basic/source/basmgr/basicmanagerrepository.cxx

   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 <basic/basicmanagerrepository.hxx>
  21 #include <basic/basmgr.hxx>
  22 #include <scriptcont.hxx>
  23 #include <dlgcont.hxx>
  24 #include <sbintern.hxx>
  25
  26 #include <com/sun/star/document/XStorageBasedDocument.hpp>
  27 #include <com/sun/star/document/XEmbeddedScripts.hpp>
  28 #include <com/sun/star/frame/Desktop.hpp>
  29 #include <svtools/ehdl.hxx>
  30 #include <svtools/sfxecode.hxx>
  31 #include <unotools/pathoptions.hxx>
  32 #include <svl/hint.hxx>
  33 #include <vcl/svapp.hxx>
  34 #include <tools/debug.hxx>
  35 #include <tools/diagnose_ex.h>
  36 #include <tools/urlobj.hxx>
  37 #include <comphelper/processfactory.hxx>
  38 #include <comphelper/documentinfo.hxx>
  39 #include <unotools/eventlisteneradapter.hxx>
  40
  41 #include <osl/getglobalmutex.hxx>
  42 #include <rtl/instance.hxx>
  43 #include <sot/storage.hxx>
  44
  45 #include <map>
  46
  47
  48 namespace basic
  49 {
  50     using ::com::sun::star::uno::Reference;
  51     using ::com::sun::star::uno::XComponentContext;
  52     using ::com::sun::star::frame::XModel;
  53     using ::com::sun::star::frame::Desktop;
  54     using ::com::sun::star::uno::XInterface;
  55     using ::com::sun::star::uno::UNO_QUERY;
  56     using ::com::sun::star::embed::XStorage;
  57     using ::com::sun::star::script::XPersistentLibraryContainer;
  58     using ::com::sun::star::uno::UNO_QUERY_THROW;
  59     using ::com::sun::star::uno::Exception;
  60     using ::com::sun::star::document::XStorageBasedDocument;
  61     using ::com::sun::star::document::XEmbeddedScripts;
  62
  63     typedef std::map< Reference< XInterface >, std::unique_ptr<BasicManager> > BasicManagerStore;
  64
  65     typedef std::vector< BasicManagerCreationListener* >  CreationListeners;
  66
  67     class ImplRepository : public ::utl::OEventListenerAdapter, public SfxListener
  68     {
  69     private:
  70         friend struct CreateImplRepository;
  71         ImplRepository();
  72
  73     private:
  74         BasicManagerStore   m_aStore;
  75         CreationListeners   m_aCreationListeners;
  76
  77     public:
  78         static ImplRepository& Instance();
  79
  80         BasicManager*   getDocumentBasicManager( const Reference< XModel >& _rxDocumentModel );
  81         BasicManager*   getOrCreateApplicationBasicManager();
  82         static BasicManager* getApplicationBasicManager();
  83         static void          setApplicationBasicManager( std::unique_ptr<BasicManager> _pBasicManager );
  84         void    registerCreationListener( BasicManagerCreationListener& _rListener );
  85         void    revokeCreationListener( BasicManagerCreationListener& _rListener );
  86
  87     private:
  88         /** retrieves the location at which the BasicManager for the given model
  89             is stored.
  90
  91             If previously, the BasicManager for this model has never been requested,
  92             then the model is added to the map, with an initial NULL BasicManager.
  93
  94             @param _rxDocumentModel
  95                 the model whose BasicManager's location is to be retrieved. Must not be <NULL/>.
  96
  97             @precond
  98                 our mutex is locked
  99         */
 100         std::unique_ptr<BasicManager>&
 101                 impl_getLocationForModel( const Reference< XModel >& _rxDocumentModel );
 102
 103         /** tests if there is a location set at which the BasicManager for the given model
 104             is stored.
 105
 106             @param _rxDocumentModel
 107                 the model whose BasicManager's location is to be retrieved. Must not be <NULL/>.
 108
 109             @precond
 110                 our mutex is locked
 111         */
 112         bool impl_hasLocationForModel( const Reference< XModel >& _rxDocumentModel ) const;
 113
 114         /** creates a new BasicManager instance for the given model
 115
 116             @param _out_rpBasicManager
 117                 reference to the pointer variable that will hold the new
 118                 BasicManager.
 119
 120             @param _rxDocumentModel
 121                 the model whose BasicManager will be created. Must not be <NULL/>.
 122         */
 123         bool impl_createManagerForModel(
 124                     std::unique_ptr<BasicManager>& _out_rpBasicManager,
 125                     const Reference< XModel >& _rxDocumentModel );
 126
 127         /** creates the application-wide BasicManager
 128         */
 129         BasicManager* impl_createApplicationBasicManager();
 130
 131         /** notifies all listeners which expressed interest in the creation of BasicManager instances.
 132         */
 133         void    impl_notifyCreationListeners(
 134                     const Reference< XModel >& _rxDocumentModel,
 135                     BasicManager& _rManager
 136                  );
 137
 138         /** retrieves the current storage of a given document
 139
 140             @param  _rxDocument
 141                 the document whose storage is to be retrieved.
 142
 143             @param  _out_rStorage
 144                 takes the storage upon successful return. Note that this might be <NULL/> even
 145                 if <TRUE/> is returned. In this case, the document has not yet been saved.
 146
 147             @return
 148                 <TRUE/> if the storage could be successfully retrieved (in which case
 149                 <arg>_out_rStorage</arg> might or might not be <NULL/>), <FALSE/> otherwise.
 150                 In the latter case, processing this document should stop.
 151         */
 152         static bool impl_getDocumentStorage_nothrow( const Reference< XModel >& _rxDocument, Reference< XStorage >& _out_rStorage );
 153
 154         /** retrieves the containers for Basic and Dialog libraries for a given document
 155
 156             @param  _rxDocument
 157                 the document whose containers are to be retrieved.
 158
 159             @param _out_rxBasicLibraries
 160                 takes the basic library container upon successful return
 161
 162             @param _out_rxDialogLibraries
 163                 takes the dialog library container upon successful return
 164
 165             @return
 166                 <TRUE/> if and only if both containers exist, and could successfully be retrieved
 167         */
 168         static bool impl_getDocumentLibraryContainers_nothrow(
 169                     const Reference< XModel >& _rxDocument,
 170                     Reference< XPersistentLibraryContainer >& _out_rxBasicLibraries,
 171                     Reference< XPersistentLibraryContainer >& _out_rxDialogLibraries
 172                 );
 173
 174         /** initializes the given library containers, which belong to a document
 175         */
 176         static void impl_initDocLibraryContainers_nothrow(
 177                     const Reference< XPersistentLibraryContainer >& _rxBasicLibraries,
 178                     const Reference< XPersistentLibraryContainer >& _rxDialogLibraries
 179                 );
 180
 181         // OEventListenerAdapter overridables
 182         virtual void _disposing( const css::lang::EventObject& _rSource ) override;
 183
 184         // SfxListener overridables
 185         virtual void Notify( SfxBroadcaster& _rBC, const SfxHint& _rHint ) override;
 186
 187         /** removes the Model/BasicManager pair given by iterator from our store
 188         */
 189         void impl_removeFromRepository( const BasicManagerStore::iterator& _pos );
 190
 191     private:
 192         StarBASIC* impl_getDefaultAppBasicLibrary();
 193     };
 194
 195
 196     struct CreateImplRepository
 197     {
 198         ImplRepository* operator()()
 199         {
 200             static ImplRepository* pRepository = new ImplRepository;
 201             return pRepository;
 202         }
 203     };
 204
 205
 206     ImplRepository::ImplRepository()
 207     {
 208     }
 209
 210
 211     ImplRepository& ImplRepository::Instance()
 212     {
 213         return *rtl_Instance< ImplRepository, CreateImplRepository, ::osl::MutexGuard, ::osl::GetGlobalMutex >::
 214             create( CreateImplRepository(), ::osl::GetGlobalMutex() );
 215     }
 216
 217     BasicManager* ImplRepository::getDocumentBasicManager( const Reference< XModel >& _rxDocumentModel )
 218     {
 219         SolarMutexGuard g;
 220
 221         /*  #163556# (DR) - This function may be called recursively while
 222             constructing the Basic manager and loading the Basic storage. By
 223             passing the map entry received from impl_getLocationForModel() to
 224             the function impl_createManagerForModel(), the new Basic manager
 225             will be put immediately into the map of existing Basic managers,
 226             thus a recursive call of this function will find and return it
 227             without creating another instance.
 228          */
 229         std::unique_ptr<BasicManager>& pBasicManager = impl_getLocationForModel( _rxDocumentModel );
 230         if (pBasicManager != nullptr)
 231             return pBasicManager.get();
 232         if (impl_createManagerForModel(pBasicManager, _rxDocumentModel))
 233             return pBasicManager.get();
 234         return nullptr;
 235     }
 236
 237     BasicManager* ImplRepository::getOrCreateApplicationBasicManager()
 238     {
 239         SolarMutexGuard g;
 240
 241         BasicManager* pAppManager = GetSbData()->pAppBasMgr.get();
 242         if (pAppManager == nullptr)
 243             pAppManager = impl_createApplicationBasicManager();
 244         return pAppManager;
 245     }
 246
 247     BasicManager* ImplRepository::getApplicationBasicManager()
 248     {
 249         SolarMutexGuard g;
 250
 251         return GetSbData()->pAppBasMgr.get();
 252     }
 253
 254     void ImplRepository::setApplicationBasicManager( std::unique_ptr<BasicManager> _pBasicManager )
 255     {
 256         SolarMutexGuard g;
 257
 258         GetSbData()->pAppBasMgr = std::move(_pBasicManager);
 259     }
 260
 261
 262     BasicManager* ImplRepository::impl_createApplicationBasicManager()
 263     {
 264         SolarMutexGuard g;
 265
 266         OSL_PRECOND(getApplicationBasicManager() == nullptr, "ImplRepository::impl_createApplicationBasicManager: there already is one!");
 267
 268         // Determine Directory
 269         SvtPathOptions aPathCFG;
 270         OUString aAppBasicDir( aPathCFG.GetBasicPath() );
 271         if ( aAppBasicDir.isEmpty() )
 272         {
 273             aPathCFG.SetBasicPath("$(prog)");
 274         }
 275
 276         // Create basic and load it
 277         // AppBasicDir is now a PATH
 278         INetURLObject aAppBasic( SvtPathOptions().SubstituteVariable("$(progurl)") );
 279         aAppBasic.insertName( Application::GetAppName() );
 280
 281         BasicManager* pBasicManager = new BasicManager( new StarBASIC, &aAppBasicDir );
 282         setApplicationBasicManager( std::unique_ptr<BasicManager>(pBasicManager) );
 283
 284         // The first dir in the path as destination:
 285         OUString aFileName( aAppBasic.getName() );
 286         aAppBasic = INetURLObject( aAppBasicDir.getToken(1, ';') );
 287         DBG_ASSERT(aAppBasic.GetProtocol() != INetProtocol::NotValid,
 288             OString("Invalid URL: \"" +
 289                     OUStringToOString(aAppBasicDir, osl_getThreadTextEncoding()) +
 290                     "\"").getStr());
 291         aAppBasic.insertName( aFileName );
 292         pBasicManager->SetStorageName( aAppBasic.PathToFileName() );
 293
 294         // Basic container
 295         SfxScriptLibraryContainer* pBasicCont = new SfxScriptLibraryContainer( Reference< XStorage >() );
 296         Reference< XPersistentLibraryContainer > xBasicCont( pBasicCont );
 297         pBasicCont->setBasicManager( pBasicManager );
 298
 299         // Dialog container
 300         SfxDialogLibraryContainer* pDialogCont = new SfxDialogLibraryContainer( Reference< XStorage >() );
 301         Reference< XPersistentLibraryContainer > xDialogCont( pDialogCont );
 302
 303         LibraryContainerInfo aInfo( xBasicCont, xDialogCont, static_cast< OldBasicPassword* >( pBasicCont ) );
 304         pBasicManager->SetLibraryContainerInfo( aInfo );
 305
 306         // global constants
 307
 308         // StarDesktop
 309         Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext();
 310         pBasicManager->SetGlobalUNOConstant( "StarDesktop", css::uno::Any( Desktop::create(xContext)));
 311
 312         // (BasicLibraries and DialogLibraries have automatically been added in SetLibraryContainerInfo)
 313
 314         // notify
 315         impl_notifyCreationListeners( nullptr, *pBasicManager );
 316
 317         // outta here
 318         return pBasicManager;
 319     }
 320
 321
 322     void ImplRepository::registerCreationListener( BasicManagerCreationListener& _rListener )
 323     {
 324         SolarMutexGuard g;
 325
 326         m_aCreationListeners.push_back( &_rListener );
 327     }
 328
 329
 330     void ImplRepository::revokeCreationListener( BasicManagerCreationListener& _rListener )
 331     {
 332         SolarMutexGuard g;
 333
 334         CreationListeners::iterator pos = std::find( m_aCreationListeners.begin(), m_aCreationListeners.end(), &_rListener );
 335         if ( pos != m_aCreationListeners.end() )
 336             m_aCreationListeners.erase( pos );
 337         else {
 338             OSL_FAIL( "ImplRepository::revokeCreationListener: listener is not registered!" );
 339         }
 340     }
 341
 342
 343     void ImplRepository::impl_notifyCreationListeners( const Reference< XModel >& _rxDocumentModel, BasicManager& _rManager )
 344     {
 345         for (auto const& creationListener : m_aCreationListeners)
 346         {
 347             creationListener->onBasicManagerCreated( _rxDocumentModel, _rManager );
 348         }
 349     }
 350
 351
 352     StarBASIC* ImplRepository::impl_getDefaultAppBasicLibrary()
 353     {
 354         BasicManager* pAppManager = getOrCreateApplicationBasicManager();
 355
 356         StarBASIC* pAppBasic = pAppManager ? pAppManager->GetLib(0) : nullptr;
 357         DBG_ASSERT( pAppBasic != nullptr, "impl_getApplicationBasic: unable to determine the default application's Basic library!" );
 358         return pAppBasic;
 359     }
 360
 361     std::unique_ptr<BasicManager>& ImplRepository::impl_getLocationForModel( const Reference< XModel >& _rxDocumentModel )
 362     {
 363         Reference< XInterface > xNormalized( _rxDocumentModel, UNO_QUERY );
 364         DBG_ASSERT( _rxDocumentModel.is(), "ImplRepository::impl_getLocationForModel: invalid model!" );
 365
 366         std::unique_ptr<BasicManager>& location = m_aStore[ xNormalized ];
 367         return location;
 368     }
 369
 370     bool ImplRepository::impl_hasLocationForModel( const Reference< XModel >& _rxDocumentModel ) const
 371     {
 372         Reference< XInterface > xNormalized( _rxDocumentModel, UNO_QUERY );
 373         DBG_ASSERT( _rxDocumentModel.is(), "ImplRepository::impl_getLocationForModel: invalid model!" );
 374
 375         return m_aStore.find(xNormalized) != m_aStore.end();
 376     }
 377
 378     void ImplRepository::impl_initDocLibraryContainers_nothrow( const Reference< XPersistentLibraryContainer >& _rxBasicLibraries, const Reference< XPersistentLibraryContainer >& _rxDialogLibraries )
 379     {
 380         OSL_PRECOND( _rxBasicLibraries.is() && _rxDialogLibraries.is(),
 381             "ImplRepository::impl_initDocLibraryContainers_nothrow: illegal library containers, this will crash!" );
 382
 383         try
 384         {
 385             // ensure there's a standard library in the basic container
 386             OUString aStdLibName( "Standard" );
 387             if ( !_rxBasicLibraries->hasByName( aStdLibName ) )
 388             {
 389                 _rxBasicLibraries->createLibrary( aStdLibName );
 390             }
 391             // as well as in the dialog container
 392             if ( !_rxDialogLibraries->hasByName( aStdLibName ) )
 393             {
 394                 _rxDialogLibraries->createLibrary( aStdLibName );
 395             }
 396         }
 397         catch( const Exception& )
 398         {
 399             DBG_UNHANDLED_EXCEPTION("basic");
 400         }
 401     }
 402
 403     bool ImplRepository::impl_createManagerForModel( std::unique_ptr<BasicManager>& _out_rpBasicManager, const Reference< XModel >& _rxDocumentModel )
 404     {
 405         StarBASIC* pAppBasic = impl_getDefaultAppBasicLibrary();
 406
 407         _out_rpBasicManager = nullptr;
 408         Reference< XStorage > xStorage;
 409         if ( !impl_getDocumentStorage_nothrow( _rxDocumentModel, xStorage ) )
 410         {
 411             // the document is not able to provide the storage it is based on.
 412             return false;
 413         }
 414         Reference< XPersistentLibraryContainer > xBasicLibs;
 415         Reference< XPersistentLibraryContainer > xDialogLibs;
 416         if ( !impl_getDocumentLibraryContainers_nothrow( _rxDocumentModel, xBasicLibs, xDialogLibs ) )
 417             // the document does not have BasicLibraries and DialogLibraries
 418             return false;
 419
 420         if ( xStorage.is() )
 421         {
 422             // load BASIC-manager
 423             SfxErrorContext aErrContext( ERRCTX_SFX_LOADBASIC,
 424                 ::comphelper::DocumentInfo::getDocumentTitle( _rxDocumentModel ) );
 425             OUString aAppBasicDir = SvtPathOptions().GetBasicPath();
 426
 427             // Storage and BaseURL are only needed by binary documents!
 428             tools::SvRef<SotStorage> xDummyStor = new SotStorage( OUString() );
 429             _out_rpBasicManager.reset(new BasicManager( *xDummyStor, OUString() /* TODO/LATER: xStorage */,
 430                                                                 pAppBasic,
 431                                                                 &aAppBasicDir, true ));
 432             if ( !_out_rpBasicManager->GetErrors().empty() )
 433             {
 434                 // handle errors
 435                 std::vector<BasicError>& aErrors = _out_rpBasicManager->GetErrors();
 436                 for(const auto& rError : aErrors)
 437                 {
 438                     // show message to user
 439                     if ( ErrorHandler::HandleError( rError.GetErrorId() ) == DialogMask::ButtonsCancel )
 440                     {
 441                         // user wants to break loading of BASIC-manager
 442                         _out_rpBasicManager.reset();
 443                         xStorage.clear();
 444                         break;
 445                     }
 446                 }
 447             }
 448         }
 449
 450         // not loaded?
 451         if ( !xStorage.is() )
 452         {
 453             // create new BASIC-manager
 454             StarBASIC* pBasic = new StarBASIC( pAppBasic );
 455             pBasic->SetFlag( SbxFlagBits::ExtSearch );
 456             _out_rpBasicManager.reset(new BasicManager( pBasic, nullptr, true ));
 457         }
 458
 459         // knit the containers with the BasicManager
 460         LibraryContainerInfo aInfo( xBasicLibs, xDialogLibs, dynamic_cast< OldBasicPassword* >( xBasicLibs.get() ) );
 461         OSL_ENSURE( aInfo.mpOldBasicPassword, "ImplRepository::impl_createManagerForModel: wrong BasicLibraries implementation!" );
 462         _out_rpBasicManager->SetLibraryContainerInfo( aInfo );
 463
 464         // initialize the containers
 465         impl_initDocLibraryContainers_nothrow( xBasicLibs, xDialogLibs );
 466
 467         // so that also dialogs etc. could be 'qualified' addressed
 468         _out_rpBasicManager->GetLib(0)->SetParent( pAppBasic );
 469
 470         // global properties in the document's Basic
 471         _out_rpBasicManager->SetGlobalUNOConstant( "ThisComponent", css::uno::Any( _rxDocumentModel ) );
 472
 473         // notify
 474         impl_notifyCreationListeners( _rxDocumentModel, *_out_rpBasicManager );
 475
 476         // register as listener for this model being disposed/closed
 477         OSL_ENSURE( _rxDocumentModel.is(), "ImplRepository::impl_createManagerForModel: the document must be an XComponent!" );
 478         assert(impl_hasLocationForModel(_rxDocumentModel));
 479         startComponentListening( _rxDocumentModel );
 480
 481         bool bOk = false;
 482         // startComponentListening may fail in a disposed _rxDocumentModel, in which case _out_rpBasicManager will be removed
 483         // from the map and destroyed
 484         if (impl_hasLocationForModel(_rxDocumentModel))
 485         {
 486             bOk = true;
 487             // register as listener for the BasicManager being destroyed
 488             StartListening( *_out_rpBasicManager );
 489         }
 490
 491         // #i104876: Library container must not be modified just after
 492         // creation. This happens as side effect when creating default
 493         // "Standard" libraries and needs to be corrected here
 494         xBasicLibs->setModified( false );
 495         xDialogLibs->setModified( false );
 496         return bOk;
 497     }
 498
 499     bool ImplRepository::impl_getDocumentStorage_nothrow( const Reference< XModel >& _rxDocument, Reference< XStorage >& _out_rStorage )
 500     {
 501         _out_rStorage.clear();
 502         try
 503         {
 504             Reference< XStorageBasedDocument > xStorDoc( _rxDocument, UNO_QUERY_THROW );
 505             _out_rStorage.set( xStorDoc->getDocumentStorage() );
 506         }
 507         catch( const Exception& )
 508         {
 509             DBG_UNHANDLED_EXCEPTION("basic");
 510             return false;
 511         }
 512         return true;
 513     }
 514
 515
 516     bool ImplRepository::impl_getDocumentLibraryContainers_nothrow( const Reference< XModel >& _rxDocument,
 517         Reference< XPersistentLibraryContainer >& _out_rxBasicLibraries, Reference< XPersistentLibraryContainer >& _out_rxDialogLibraries )
 518     {
 519         _out_rxBasicLibraries.clear();
 520         _out_rxDialogLibraries.clear();
 521         try
 522         {
 523             Reference< XEmbeddedScripts > xScripts( _rxDocument, UNO_QUERY_THROW );
 524             _out_rxBasicLibraries.set( xScripts->getBasicLibraries(), UNO_QUERY_THROW );
 525             _out_rxDialogLibraries.set( xScripts->getDialogLibraries(), UNO_QUERY_THROW );
 526         }
 527         catch( const Exception& )
 528         {
 529             DBG_UNHANDLED_EXCEPTION("basic");
 530         }
 531         return _out_rxBasicLibraries.is() && _out_rxDialogLibraries.is();
 532     }
 533
 534
 535     void ImplRepository::impl_removeFromRepository( const BasicManagerStore::iterator& _pos )
 536     {
 537         OSL_PRECOND( _pos != m_aStore.end(), "ImplRepository::impl_removeFromRepository: invalid position!" );
 538
 539         std::unique_ptr<BasicManager> pManager = std::move(_pos->second);
 540         Reference<XModel> xModel(_pos->first, UNO_QUERY);
 541
 542         // *first* remove from map (else Notify won't work properly)
 543         m_aStore.erase( _pos );
 544
 545         EndListening( *pManager );
 546
 547         assert(xModel.is());
 548         if (xModel.is())
 549             stopComponentListening(xModel);
 550     }
 551
 552
 553     void ImplRepository::_disposing( const css::lang::EventObject& _rSource )
 554     {
 555         SolarMutexGuard g;
 556
 557         Reference< XInterface > xNormalizedSource( _rSource.Source, UNO_QUERY );
 558
 559         BasicManagerStore::iterator it = std::find_if(m_aStore.begin(), m_aStore.end(),
 560             [&xNormalizedSource](BasicManagerStore::reference rEntry) {
 561                 return rEntry.first.get() == xNormalizedSource.get(); });
 562         if (it != m_aStore.end())
 563         {
 564             impl_removeFromRepository( it );
 565             return;
 566         }
 567
 568         OSL_FAIL( "ImplRepository::_disposing: where does this come from?" );
 569     }
 570
 571
 572     void ImplRepository::Notify( SfxBroadcaster& _rBC, const SfxHint& _rHint )
 573     {
 574         if ( _rHint.GetId() != SfxHintId::Dying )
 575             // not interested in
 576             return;
 577
 578         BasicManager* pManager = dynamic_cast< BasicManager* >( &_rBC );
 579         OSL_ENSURE( pManager, "ImplRepository::Notify: where does this come from?" );
 580
 581         BasicManagerStore::iterator it = std::find_if(m_aStore.begin(), m_aStore.end(),
 582             [&pManager](BasicManagerStore::reference rEntry) { return rEntry.second.get() == pManager; });
 583         if (it != m_aStore.end())
 584         {
 585             // a BasicManager which is still in our repository is being deleted.
 586             // That's bad, since by definition, we *own* all instances in our
 587             // repository.
 588             OSL_FAIL( "ImplRepository::Notify: nobody should tamper with the managers, except ourself!" );
 589             m_aStore.erase( it );
 590         }
 591     }
 592
 593     BasicManager* BasicManagerRepository::getDocumentBasicManager( const Reference< XModel >& _rxDocumentModel )
 594     {
 595         return ImplRepository::Instance().getDocumentBasicManager( _rxDocumentModel );
 596     }
 597
 598     BasicManager* BasicManagerRepository::getApplicationBasicManager()
 599     {
 600         return ImplRepository::Instance().getOrCreateApplicationBasicManager();
 601     }
 602
 603     void BasicManagerRepository::resetApplicationBasicManager()
 604     {
 605         ImplRepository::setApplicationBasicManager( nullptr );
 606     }
 607
 608     void BasicManagerRepository::registerCreationListener( BasicManagerCreationListener& _rListener )
 609     {
 610         ImplRepository::Instance().registerCreationListener( _rListener );
 611     }
 612
 613     void BasicManagerRepository::revokeCreationListener( BasicManagerCreationListener& _rListener )
 614     {
 615         ImplRepository::Instance().revokeCreationListener( _rListener );
 616     }
 617
 618 } // namespace basic
 619
 620
 621 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */