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 #include <sbxbase.hxx>
  26
  27 #include <com/sun/star/document/XStorageBasedDocument.hpp>
  28 #include <com/sun/star/document/XEmbeddedScripts.hpp>
  29 #include <com/sun/star/frame/Desktop.hpp>
  30 #include <svtools/ehdl.hxx>
  31 #include <svtools/sfxecode.hxx>
  32 #include <unotools/pathoptions.hxx>
  33 #include <svl/hint.hxx>
  34 #include <vcl/svapp.hxx>
  35 #include <tools/debug.hxx>
  36 #include <tools/diagnose_ex.h>
  37 #include <tools/urlobj.hxx>
  38 #include <comphelper/processfactory.hxx>
  39 #include <comphelper/documentinfo.hxx>
  40 #include <unotools/eventlisteneradapter.hxx>
  41
  42 #include <sot/storage.hxx>
  43
  44 #include <map>
  45
  46
  47 namespace basic
  48 {
  49     using ::com::sun::star::uno::Reference;
  50     using ::com::sun::star::uno::XComponentContext;
  51     using ::com::sun::star::frame::XModel;
  52     using ::com::sun::star::frame::Desktop;
  53     using ::com::sun::star::uno::XInterface;
  54     using ::com::sun::star::uno::UNO_QUERY;
  55     using ::com::sun::star::embed::XStorage;
  56     using ::com::sun::star::script::XPersistentLibraryContainer;
  57     using ::com::sun::star::uno::UNO_QUERY_THROW;
  58     using ::com::sun::star::uno::Exception;
  59     using ::com::sun::star::document::XStorageBasedDocument;
  60     using ::com::sun::star::document::XEmbeddedScripts;
  61
  62     typedef std::map< Reference< XInterface >, std::unique_ptr<BasicManager> > BasicManagerStore;
  63
  64     typedef std::vector< BasicManagerCreationListener* >  CreationListeners;
  65
  66     class ImplRepository : public ::utl::OEventListenerAdapter, public SfxListener, public SvRefBase
  67     {
  68     private:
  69         ImplRepository();
  70         ~ImplRepository();
  71
  72     private:
  73         BasicManagerStore   m_aStore;
  74         CreationListeners   m_aCreationListeners;
  75
  76     public:
  77         static ImplRepository& Instance();
  78
  79         BasicManager*   getDocumentBasicManager( const Reference< XModel >& _rxDocumentModel );
  80         BasicManager*   getOrCreateApplicationBasicManager();
  81         static BasicManager* getApplicationBasicManager();
  82         static void          setApplicationBasicManager( std::unique_ptr<BasicManager> _pBasicManager );
  83         void    registerCreationListener( BasicManagerCreationListener& _rListener );
  84         void    revokeCreationListener( BasicManagerCreationListener& _rListener );
  85
  86     private:
  87         /** retrieves the location at which the BasicManager for the given model
  88             is stored.
  89
  90             If previously, the BasicManager for this model has never been requested,
  91             then the model is added to the map, with an initial NULL BasicManager.
  92
  93             @param _rxDocumentModel
  94                 the model whose BasicManager's location is to be retrieved. Must not be <NULL/>.
  95
  96             @precond
  97                 our mutex is locked
  98         */
  99         BasicManagerStore::iterator
 100                 impl_getLocationForModel( const Reference< XModel >& _rxDocumentModel );
 101
 102         /** tests if there is a location set at which the BasicManager for the given model
 103             is stored.
 104
 105             @param _rxDocumentModel
 106                 the model whose BasicManager's location is to be retrieved. Must not be <NULL/>.
 107
 108             @precond
 109                 our mutex is locked
 110         */
 111         bool impl_hasLocationForModel( const Reference< XModel >& _rxDocumentModel ) const;
 112
 113         /** creates a new BasicManager instance for the given model
 114
 115             @param _out_rpBasicManager
 116                 reference to the pointer variable that will hold the new
 117                 BasicManager.
 118
 119             @param _rxDocumentModel
 120                 the model whose BasicManager will be created. Must not be <NULL/>.
 121         */
 122         bool impl_createManagerForModel(
 123                     BasicManagerStore::iterator location,
 124                     const Reference< XModel >& _rxDocumentModel );
 125
 126         /** creates the application-wide BasicManager
 127         */
 128         BasicManager* impl_createApplicationBasicManager();
 129
 130         /** notifies all listeners which expressed interest in the creation of BasicManager instances.
 131         */
 132         void    impl_notifyCreationListeners(
 133                     const Reference< XModel >& _rxDocumentModel,
 134                     BasicManager& _rManager
 135                  );
 136
 137         /** retrieves the current storage of a given document
 138
 139             @param  _rxDocument
 140                 the document whose storage is to be retrieved.
 141
 142             @param  _out_rStorage
 143                 takes the storage upon successful return. Note that this might be <NULL/> even
 144                 if <TRUE/> is returned. In this case, the document has not yet been saved.
 145
 146             @return
 147                 <TRUE/> if the storage could be successfully retrieved (in which case
 148                 <arg>_out_rStorage</arg> might or might not be <NULL/>), <FALSE/> otherwise.
 149                 In the latter case, processing this document should stop.
 150         */
 151         static bool impl_getDocumentStorage_nothrow( const Reference< XModel >& _rxDocument, Reference< XStorage >& _out_rStorage );
 152
 153         /** retrieves the containers for Basic and Dialog libraries for a given document
 154
 155             @param  _rxDocument
 156                 the document whose containers are to be retrieved.
 157
 158             @param _out_rxBasicLibraries
 159                 takes the basic library container upon successful return
 160
 161             @param _out_rxDialogLibraries
 162                 takes the dialog library container upon successful return
 163
 164             @return
 165                 <TRUE/> if and only if both containers exist, and could successfully be retrieved
 166         */
 167         static bool impl_getDocumentLibraryContainers_nothrow(
 168                     const Reference< XModel >& _rxDocument,
 169                     Reference< XPersistentLibraryContainer >& _out_rxBasicLibraries,
 170                     Reference< XPersistentLibraryContainer >& _out_rxDialogLibraries
 171                 );
 172
 173         /** initializes the given library containers, which belong to a document
 174         */
 175         static void impl_initDocLibraryContainers_nothrow(
 176                     const Reference< XPersistentLibraryContainer >& _rxBasicLibraries,
 177                     const Reference< XPersistentLibraryContainer >& _rxDialogLibraries
 178                 );
 179
 180         // OEventListenerAdapter overridables
 181         virtual void _disposing( const css::lang::EventObject& _rSource ) override;
 182
 183         // SfxListener overridables
 184         virtual void Notify( SfxBroadcaster& _rBC, const SfxHint& _rHint ) override;
 185
 186         /** removes the Model/BasicManager pair given by iterator from our store
 187         */
 188         void impl_removeFromRepository( const BasicManagerStore::iterator& _pos );
 189
 190     private:
 191         StarBASIC* impl_getDefaultAppBasicLibrary();
 192     };
 193
 194     ImplRepository::ImplRepository()
 195     {
 196     }
 197
 198     ImplRepository::~ImplRepository()
 199     {
 200         // Avoid double-delete of managers when they are destroyed in our dtor, and start notify us
 201         for (auto& it : m_aStore)
 202             EndListening(*it.second);
 203     }
 204
 205     ImplRepository& ImplRepository::Instance()
 206     {
 207         tools::SvRef<SvRefBase>& repository = GetSbxData_Impl().mrImplRepository;
 208         {
 209             static osl::Mutex aMutex;
 210             osl::MutexGuard aGuard(aMutex);
 211             if (!repository)
 212                 repository = new ImplRepository;
 213         }
 214         return *static_cast<ImplRepository*>(repository.get());
 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         auto const loc = impl_getLocationForModel( _rxDocumentModel );
 230         if (loc->second != nullptr)
 231             return loc->second.get();
 232         if (impl_createManagerForModel(loc, _rxDocumentModel))
 233             return loc->second.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     BasicManagerStore::iterator 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         return m_aStore.try_emplace(xNormalized).first;
 367     }
 368
 369     bool ImplRepository::impl_hasLocationForModel( const Reference< XModel >& _rxDocumentModel ) const
 370     {
 371         Reference< XInterface > xNormalized( _rxDocumentModel, UNO_QUERY );
 372         DBG_ASSERT( _rxDocumentModel.is(), "ImplRepository::impl_getLocationForModel: invalid model!" );
 373
 374         return m_aStore.find(xNormalized) != m_aStore.end();
 375     }
 376
 377     void ImplRepository::impl_initDocLibraryContainers_nothrow( const Reference< XPersistentLibraryContainer >& _rxBasicLibraries, const Reference< XPersistentLibraryContainer >& _rxDialogLibraries )
 378     {
 379         OSL_PRECOND( _rxBasicLibraries.is() && _rxDialogLibraries.is(),
 380             "ImplRepository::impl_initDocLibraryContainers_nothrow: illegal library containers, this will crash!" );
 381
 382         try
 383         {
 384             // ensure there's a standard library in the basic container
 385             OUString aStdLibName( "Standard" );
 386             if ( !_rxBasicLibraries->hasByName( aStdLibName ) )
 387             {
 388                 _rxBasicLibraries->createLibrary( aStdLibName );
 389             }
 390             // as well as in the dialog container
 391             if ( !_rxDialogLibraries->hasByName( aStdLibName ) )
 392             {
 393                 _rxDialogLibraries->createLibrary( aStdLibName );
 394             }
 395         }
 396         catch( const Exception& )
 397         {
 398             DBG_UNHANDLED_EXCEPTION("basic");
 399         }
 400     }
 401
 402     bool ImplRepository::impl_createManagerForModel( BasicManagerStore::iterator location, const Reference< XModel >& _rxDocumentModel )
 403     {
 404         auto & _out_rpBasicManager = location->second;
 405
 406         StarBASIC* pAppBasic = impl_getDefaultAppBasicLibrary();
 407
 408         _out_rpBasicManager = nullptr;
 409         Reference< XStorage > xStorage;
 410         if ( !impl_getDocumentStorage_nothrow( _rxDocumentModel, xStorage ) )
 411         {
 412             m_aStore.erase(location);
 413             // the document is not able to provide the storage it is based on.
 414             return false;
 415         }
 416         Reference< XPersistentLibraryContainer > xBasicLibs;
 417         Reference< XPersistentLibraryContainer > xDialogLibs;
 418         if ( !impl_getDocumentLibraryContainers_nothrow( _rxDocumentModel, xBasicLibs, xDialogLibs ) )
 419         {
 420             m_aStore.erase(location);
 421             // the document does not have BasicLibraries and DialogLibraries
 422             return false;
 423         }
 424
 425         if ( xStorage.is() )
 426         {
 427             // load BASIC-manager
 428             SfxErrorContext aErrContext( ERRCTX_SFX_LOADBASIC,
 429                 ::comphelper::DocumentInfo::getDocumentTitle( _rxDocumentModel ) );
 430             OUString aAppBasicDir = SvtPathOptions().GetBasicPath();
 431
 432             // Storage and BaseURL are only needed by binary documents!
 433             tools::SvRef<SotStorage> xDummyStor = new SotStorage( OUString() );
 434             _out_rpBasicManager.reset(new BasicManager( *xDummyStor, OUString() /* TODO/LATER: xStorage */,
 435                                                                 pAppBasic,
 436                                                                 &aAppBasicDir, true ));
 437             if ( !_out_rpBasicManager->GetErrors().empty() )
 438             {
 439                 // handle errors
 440                 std::vector<BasicError>& aErrors = _out_rpBasicManager->GetErrors();
 441                 for(const auto& rError : aErrors)
 442                 {
 443                     // show message to user
 444                     if ( ErrorHandler::HandleError( rError.GetErrorId() ) == DialogMask::ButtonsCancel )
 445                     {
 446                         // user wants to break loading of BASIC-manager
 447                         _out_rpBasicManager.reset();
 448                         xStorage.clear();
 449                         break;
 450                     }
 451                 }
 452             }
 453         }
 454
 455         // not loaded?
 456         if ( !xStorage.is() )
 457         {
 458             // create new BASIC-manager
 459             StarBASIC* pBasic = new StarBASIC( pAppBasic );
 460             pBasic->SetFlag( SbxFlagBits::ExtSearch );
 461             _out_rpBasicManager.reset(new BasicManager( pBasic, nullptr, true ));
 462         }
 463
 464         // knit the containers with the BasicManager
 465         LibraryContainerInfo aInfo( xBasicLibs, xDialogLibs, dynamic_cast< OldBasicPassword* >( xBasicLibs.get() ) );
 466         OSL_ENSURE( aInfo.mpOldBasicPassword, "ImplRepository::impl_createManagerForModel: wrong BasicLibraries implementation!" );
 467         _out_rpBasicManager->SetLibraryContainerInfo( aInfo );
 468
 469         // initialize the containers
 470         impl_initDocLibraryContainers_nothrow( xBasicLibs, xDialogLibs );
 471
 472         // so that also dialogs etc. could be 'qualified' addressed
 473         _out_rpBasicManager->GetLib(0)->SetParent( pAppBasic );
 474
 475         // global properties in the document's Basic
 476         _out_rpBasicManager->SetGlobalUNOConstant( "ThisComponent", css::uno::Any( _rxDocumentModel ) );
 477
 478         // notify
 479         impl_notifyCreationListeners( _rxDocumentModel, *_out_rpBasicManager );
 480
 481         // register as listener for this model being disposed/closed
 482         OSL_ENSURE( _rxDocumentModel.is(), "ImplRepository::impl_createManagerForModel: the document must be an XComponent!" );
 483         assert(impl_hasLocationForModel(_rxDocumentModel));
 484         startComponentListening( _rxDocumentModel );
 485
 486         bool bOk = false;
 487         // startComponentListening may fail in a disposed _rxDocumentModel, in which case _out_rpBasicManager will be removed
 488         // from the map and destroyed
 489         if (impl_hasLocationForModel(_rxDocumentModel))
 490         {
 491             bOk = true;
 492             // register as listener for the BasicManager being destroyed
 493             StartListening( *_out_rpBasicManager );
 494         }
 495
 496         // #i104876: Library container must not be modified just after
 497         // creation. This happens as side effect when creating default
 498         // "Standard" libraries and needs to be corrected here
 499         xBasicLibs->setModified( false );
 500         xDialogLibs->setModified( false );
 501         return bOk;
 502     }
 503
 504     bool ImplRepository::impl_getDocumentStorage_nothrow( const Reference< XModel >& _rxDocument, Reference< XStorage >& _out_rStorage )
 505     {
 506         _out_rStorage.clear();
 507         try
 508         {
 509             Reference< XStorageBasedDocument > xStorDoc( _rxDocument, UNO_QUERY_THROW );
 510             _out_rStorage.set( xStorDoc->getDocumentStorage() );
 511         }
 512         catch( const Exception& )
 513         {
 514             DBG_UNHANDLED_EXCEPTION("basic");
 515             return false;
 516         }
 517         return true;
 518     }
 519
 520
 521     bool ImplRepository::impl_getDocumentLibraryContainers_nothrow( const Reference< XModel >& _rxDocument,
 522         Reference< XPersistentLibraryContainer >& _out_rxBasicLibraries, Reference< XPersistentLibraryContainer >& _out_rxDialogLibraries )
 523     {
 524         _out_rxBasicLibraries.clear();
 525         _out_rxDialogLibraries.clear();
 526         try
 527         {
 528             Reference< XEmbeddedScripts > xScripts( _rxDocument, UNO_QUERY_THROW );
 529             _out_rxBasicLibraries.set( xScripts->getBasicLibraries(), UNO_QUERY_THROW );
 530             _out_rxDialogLibraries.set( xScripts->getDialogLibraries(), UNO_QUERY_THROW );
 531         }
 532         catch( const Exception& )
 533         {
 534             DBG_UNHANDLED_EXCEPTION("basic");
 535         }
 536         return _out_rxBasicLibraries.is() && _out_rxDialogLibraries.is();
 537     }
 538
 539
 540     void ImplRepository::impl_removeFromRepository( const BasicManagerStore::iterator& _pos )
 541     {
 542         OSL_PRECOND( _pos != m_aStore.end(), "ImplRepository::impl_removeFromRepository: invalid position!" );
 543
 544         std::unique_ptr<BasicManager> pManager = std::move(_pos->second);
 545         Reference<XModel> xModel(_pos->first, UNO_QUERY);
 546
 547         // *first* remove from map (else Notify won't work properly)
 548         m_aStore.erase( _pos );
 549
 550         EndListening( *pManager );
 551
 552         assert(xModel.is());
 553         if (xModel.is())
 554             stopComponentListening(xModel);
 555     }
 556
 557
 558     void ImplRepository::_disposing( const css::lang::EventObject& _rSource )
 559     {
 560         SolarMutexGuard g;
 561
 562         Reference< XInterface > xNormalizedSource( _rSource.Source, UNO_QUERY );
 563
 564         BasicManagerStore::iterator it = std::find_if(m_aStore.begin(), m_aStore.end(),
 565             [&xNormalizedSource](BasicManagerStore::reference rEntry) {
 566                 return rEntry.first.get() == xNormalizedSource.get(); });
 567         if (it != m_aStore.end())
 568         {
 569             impl_removeFromRepository( it );
 570             return;
 571         }
 572
 573         OSL_FAIL( "ImplRepository::_disposing: where does this come from?" );
 574     }
 575
 576
 577     void ImplRepository::Notify( SfxBroadcaster& _rBC, const SfxHint& _rHint )
 578     {
 579         if ( _rHint.GetId() != SfxHintId::Dying )
 580             // not interested in
 581             return;
 582
 583         BasicManager* pManager = dynamic_cast< BasicManager* >( &_rBC );
 584         OSL_ENSURE( pManager, "ImplRepository::Notify: where does this come from?" );
 585
 586         BasicManagerStore::iterator it = std::find_if(m_aStore.begin(), m_aStore.end(),
 587             [&pManager](BasicManagerStore::reference rEntry) { return rEntry.second.get() == pManager; });
 588         if (it != m_aStore.end())
 589         {
 590             // a BasicManager which is still in our repository is being deleted.
 591             // That's bad, since by definition, we *own* all instances in our
 592             // repository.
 593             OSL_FAIL( "ImplRepository::Notify: nobody should tamper with the managers, except ourself!" );
 594             m_aStore.erase( it );
 595         }
 596     }
 597
 598     BasicManager* BasicManagerRepository::getDocumentBasicManager( const Reference< XModel >& _rxDocumentModel )
 599     {
 600         return ImplRepository::Instance().getDocumentBasicManager( _rxDocumentModel );
 601     }
 602
 603     BasicManager* BasicManagerRepository::getApplicationBasicManager()
 604     {
 605         return ImplRepository::Instance().getOrCreateApplicationBasicManager();
 606     }
 607
 608     void BasicManagerRepository::resetApplicationBasicManager()
 609     {
 610         ImplRepository::setApplicationBasicManager( nullptr );
 611     }
 612
 613     void BasicManagerRepository::registerCreationListener( BasicManagerCreationListener& _rListener )
 614     {
 615         ImplRepository::Instance().registerCreationListener( _rListener );
 616     }
 617
 618     void BasicManagerRepository::revokeCreationListener( BasicManagerCreationListener& _rListener )
 619     {
 620         ImplRepository::Instance().revokeCreationListener( _rListener );
 621     }
 622
 623 } // namespace basic
 624
 625
 626 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */