sd/source/ui/framework/configuration/ConfigurationController.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 "framework/ConfigurationController.hxx"
  21 #include "framework/Configuration.hxx"
  22 #include "framework/FrameworkHelper.hxx"
  23 #include "ConfigurationUpdater.hxx"
  24 #include "ConfigurationControllerBroadcaster.hxx"
  25 #include "ConfigurationTracer.hxx"
  26 #include "GenericConfigurationChangeRequest.hxx"
  27 #include "ResourceFactoryManager.hxx"
  28 #include "UpdateRequest.hxx"
  29 #include "ChangeRequestQueueProcessor.hxx"
  30 #include "ConfigurationClassifier.hxx"
  31 #include "ViewShellBase.hxx"
  32 #include "DrawController.hxx"
  33 #include <com/sun/star/drawing/framework/XControllerManager.hpp>
  34 #include <com/sun/star/util/XURLTransformer.hpp>
  35
  36 #include <comphelper/stl_types.hxx>
  37 #include <osl/mutex.hxx>
  38 #include <vcl/svapp.hxx>
  39
  40 using namespace ::com::sun::star;
  41 using namespace ::com::sun::star::uno;
  42 using namespace ::com::sun::star::drawing::framework;
  43 using ::sd::framework::FrameworkHelper;
  44
  45 namespace sd { namespace framework {
  46
  47 Reference<XInterface> SAL_CALL ConfigurationController_createInstance (
  48     const Reference<XComponentContext>& rxContext)
  49 {
  50     (void)rxContext;
  51     return static_cast<XWeak*>(new ConfigurationController());
  52 }
  53
  54
  55
  56
  57 OUString ConfigurationController_getImplementationName (void) throw(RuntimeException)
  58 {
  59     return OUString("com.sun.star.comp.Draw.framework.configuration.ConfigurationController");
  60 }
  61
  62
  63
  64
  65 Sequence<OUString> SAL_CALL ConfigurationController_getSupportedServiceNames (void)
  66     throw (RuntimeException)
  67 {
  68     static const OUString sServiceName("com.sun.star.drawing.framework.ConfigurationController");
  69     return Sequence<OUString>(&sServiceName, 1);
  70 }
  71
  72
  73
  74
  75 //----- ConfigurationController::Implementation -------------------------------
  76
  77 class ConfigurationController::Implementation
  78 {
  79 public:
  80     Implementation (
  81         ConfigurationController& rController,
  82         const Reference<frame::XController>& rxController);
  83     ~Implementation (void);
  84
  85     Reference<XControllerManager> mxControllerManager;
  86
  87     /** The Broadcaster class implements storing and calling of listeners.
  88     */
  89     ::boost::shared_ptr<ConfigurationControllerBroadcaster> mpBroadcaster;
  90
  91     /** The requested configuration which is modifed (asynchronously) by
  92         calls to requestResourceActivation() and
  93         requestResourceDeactivation().  The mpConfigurationUpdater makes the
  94         current configuration reflect the content of this one.
  95     */
  96     ::com::sun::star::uno::Reference<
  97         ::com::sun::star::drawing::framework::XConfiguration> mxRequestedConfiguration;
  98
  99     ViewShellBase* mpBase;
 100
 101     ::boost::shared_ptr<ResourceFactoryManager> mpResourceFactoryContainer;
 102
 103     ::boost::shared_ptr<ConfigurationControllerResourceManager> mpResourceManager;
 104
 105     ::boost::shared_ptr<ConfigurationUpdater> mpConfigurationUpdater;
 106
 107     /** The queue processor ownes the queue of configuration change request
 108         objects and processes the objects.
 109     */
 110     ::boost::scoped_ptr<ChangeRequestQueueProcessor> mpQueueProcessor;
 111
 112     ::boost::shared_ptr<ConfigurationUpdaterLock> mpConfigurationUpdaterLock;
 113
 114     sal_Int32 mnLockCount;
 115 };
 116
 117
 118
 119
 120 //===== ConfigurationController::Lock =========================================
 121
 122 ConfigurationController::Lock::Lock (const Reference<XConfigurationController>& rxController)
 123     : mxController(rxController)
 124 {
 125     OSL_ASSERT(mxController.is());
 126
 127     if (mxController.is())
 128         mxController->lock();
 129 }
 130
 131
 132
 133
 134 ConfigurationController::Lock::~Lock (void)
 135 {
 136     if (mxController.is())
 137         mxController->unlock();
 138 }
 139
 140
 141
 142
 143 //===== ConfigurationController ===============================================
 144
 145 ConfigurationController::ConfigurationController (void) throw()
 146     : ConfigurationControllerInterfaceBase(MutexOwner::maMutex)
 147     , mpImplementation()
 148     , mbIsDisposed(false)
 149 {
 150 }
 151
 152 ConfigurationController::~ConfigurationController (void) throw()
 153 {
 154 }
 155
 156
 157 void SAL_CALL ConfigurationController::disposing (void)
 158 {
 159     if (mpImplementation.get() == NULL)
 160         return;
 161
 162     SAL_INFO("sd.fwk", OSL_THIS_FUNC << ": ConfigurationController::disposing");
 163     SAL_INFO("sd.fwk", OSL_THIS_FUNC << ":     requesting empty configuration");
 164     // To destroy all resources an empty configuration is requested and then,
 165     // synchronously, all resulting requests are processed.
 166     mpImplementation->mpQueueProcessor->Clear();
 167     restoreConfiguration(new Configuration(this,false));
 168     mpImplementation->mpQueueProcessor->ProcessUntilEmpty();
 169     SAL_INFO("sd.fwk", OSL_THIS_FUNC << ":     all requests processed");
 170
 171     // Now that all resources have been deactivated, mark the controller as
 172     // disposed.
 173     mbIsDisposed = true;
 174
 175     // Release the listeners.
 176     lang::EventObject aEvent;
 177     aEvent.Source = uno::Reference<uno::XInterface>((cppu::OWeakObject*)this);
 178
 179     {
 180         const SolarMutexGuard aSolarGuard;
 181         mpImplementation->mpBroadcaster->DisposeAndClear();
 182     }
 183
 184     mpImplementation->mpQueueProcessor.reset();
 185     mpImplementation->mxRequestedConfiguration = NULL;
 186     mpImplementation.reset();
 187 }
 188
 189
 190
 191
 192 void ConfigurationController::ProcessEvent (void)
 193 {
 194     if (mpImplementation.get() != NULL)
 195     {
 196         OSL_ASSERT(mpImplementation->mpQueueProcessor.get()!=NULL);
 197
 198         mpImplementation->mpQueueProcessor->ProcessOneEvent();
 199     }
 200 }
 201
 202
 203
 204
 205 void ConfigurationController::RequestSynchronousUpdate (void)
 206 {
 207     if (mpImplementation.get() == NULL)
 208         return;
 209     if (mpImplementation->mpQueueProcessor.get() == 0)
 210         return;
 211     mpImplementation->mpQueueProcessor->ProcessUntilEmpty();
 212 }
 213
 214
 215
 216
 217 //----- XConfigurationControllerBroadcaster -----------------------------------
 218
 219 void SAL_CALL ConfigurationController::addConfigurationChangeListener (
 220     const Reference<XConfigurationChangeListener>& rxListener,
 221     const OUString& rsEventType,
 222     const Any& rUserData)
 223     throw (RuntimeException)
 224 {
 225     ::osl::MutexGuard aGuard (maMutex);
 226
 227     ThrowIfDisposed();
 228     OSL_ASSERT(mpImplementation.get()!=NULL);
 229     mpImplementation->mpBroadcaster->AddListener(rxListener, rsEventType, rUserData);
 230 }
 231
 232
 233
 234
 235 void SAL_CALL ConfigurationController::removeConfigurationChangeListener (
 236     const Reference<XConfigurationChangeListener>& rxListener)
 237     throw (RuntimeException)
 238 {
 239     ::osl::MutexGuard aGuard (maMutex);
 240
 241     ThrowIfDisposed();
 242     mpImplementation->mpBroadcaster->RemoveListener(rxListener);
 243 }
 244
 245
 246
 247
 248 void SAL_CALL ConfigurationController::notifyEvent (
 249     const ConfigurationChangeEvent& rEvent)
 250     throw (RuntimeException)
 251 {
 252     ThrowIfDisposed();
 253     mpImplementation->mpBroadcaster->NotifyListeners(rEvent);
 254 }
 255
 256
 257
 258
 259
 260 //----- XConfigurationController ----------------------------------------------
 261
 262 void SAL_CALL ConfigurationController::lock (void)
 263     throw (RuntimeException)
 264 {
 265     OSL_ASSERT(mpImplementation.get()!=NULL);
 266     OSL_ASSERT(mpImplementation->mpConfigurationUpdater.get()!=NULL);
 267
 268     ::osl::MutexGuard aGuard (maMutex);
 269     ThrowIfDisposed();
 270
 271
 272     ++mpImplementation->mnLockCount;
 273     if (mpImplementation->mpConfigurationUpdaterLock.get()==NULL)
 274         mpImplementation->mpConfigurationUpdaterLock
 275             = mpImplementation->mpConfigurationUpdater->GetLock();
 276 }
 277
 278
 279
 280
 281 void SAL_CALL ConfigurationController::unlock (void)
 282     throw (RuntimeException)
 283 {
 284     ::osl::MutexGuard aGuard (maMutex);
 285
 286     // Allow unlocking while the ConfigurationController is being disposed
 287     // (but not when that is done and the controller is disposed.)
 288     if (rBHelper.bDisposed)
 289         ThrowIfDisposed();
 290
 291     OSL_ASSERT(mpImplementation->mnLockCount>0);
 292     --mpImplementation->mnLockCount;
 293     if (mpImplementation->mnLockCount == 0)
 294         mpImplementation->mpConfigurationUpdaterLock.reset();
 295 }
 296
 297
 298
 299
 300 void SAL_CALL ConfigurationController::requestResourceActivation (
 301     const Reference<XResourceId>& rxResourceId,
 302     ResourceActivationMode eMode)
 303     throw (RuntimeException)
 304 {
 305     ::osl::MutexGuard aGuard (maMutex);
 306        ThrowIfDisposed();
 307
 308     // Check whether we are being disposed.  This is handled differently
 309     // then being completely disposed because the first thing disposing()
 310     // does is to deactivate all remaining resources.  This is done via
 311     // regular methods which must not throw DisposedExceptions.  Therefore
 312     // we just return silently during that stage.
 313     if (rBHelper.bInDispose)
 314     {
 315         SAL_INFO("sd.fwk", OSL_THIS_FUNC << ": ConfigurationController::requestResourceActivation(): ignoring " <<
 316             OUStringToOString(
 317                 FrameworkHelper::ResourceIdToString(rxResourceId), RTL_TEXTENCODING_UTF8).getStr());
 318         return;
 319     }
 320
 321     SAL_INFO("sd.fwk", OSL_THIS_FUNC << ": ConfigurationController::requestResourceActivation() " <<
 322         OUStringToOString(
 323             FrameworkHelper::ResourceIdToString(rxResourceId), RTL_TEXTENCODING_UTF8).getStr());
 324
 325     if (rxResourceId.is())
 326     {
 327         if (eMode == ResourceActivationMode_REPLACE)
 328         {
 329             // Get a list of the matching resources and create deactivation
 330             // requests for them.
 331             Sequence<Reference<XResourceId> > aResourceList (
 332                 mpImplementation->mxRequestedConfiguration->getResources(
 333                     rxResourceId->getAnchor(),
 334                     rxResourceId->getResourceTypePrefix(),
 335                     AnchorBindingMode_DIRECT));
 336
 337             for (sal_Int32 nIndex=0; nIndex<aResourceList.getLength(); ++nIndex)
 338             {
 339                 // Do not request the deactivation of the resource for which
 340                 // this method was called.  Doing it would not change the
 341                 // outcome but would result in unnecessary work.
 342                 if (rxResourceId->compareTo(aResourceList[nIndex]) == 0)
 343                     continue;
 344
 345                 // Request the deactivation of a resource and all resources
 346                 // linked to it.
 347                 requestResourceDeactivation(aResourceList[nIndex]);
 348             }
 349         }
 350
 351         Reference<XConfigurationChangeRequest> xRequest(
 352             new GenericConfigurationChangeRequest(
 353                 rxResourceId,
 354                 GenericConfigurationChangeRequest::Activation));
 355         postChangeRequest(xRequest);
 356     }
 357 }
 358
 359
 360
 361
 362 void SAL_CALL ConfigurationController::requestResourceDeactivation (
 363     const Reference<XResourceId>& rxResourceId)
 364     throw (RuntimeException)
 365 {
 366     ::osl::MutexGuard aGuard (maMutex);
 367     ThrowIfDisposed();
 368
 369     SAL_INFO("sd.fwk", OSL_THIS_FUNC << ": ConfigurationController::requestResourceDeactivation() " <<
 370             OUStringToOString(
 371                 FrameworkHelper::ResourceIdToString(rxResourceId), RTL_TEXTENCODING_UTF8).getStr());
 372
 373     if (rxResourceId.is())
 374     {
 375         // Request deactivation of all resources linked to the specified one
 376         // as well.
 377         const Sequence<Reference<XResourceId> > aLinkedResources (
 378             mpImplementation->mxRequestedConfiguration->getResources(
 379                 rxResourceId,
 380                 OUString(),
 381                 AnchorBindingMode_DIRECT));
 382         const sal_Int32 nCount (aLinkedResources.getLength());
 383         for (sal_Int32 nIndex=0; nIndex<nCount; ++nIndex)
 384         {
 385             // We do not add deactivation requests directly but call this
 386             // method recursively, so that when one time there are resources
 387             // linked to linked resources, these are handled correctly, too.
 388             requestResourceDeactivation(aLinkedResources[nIndex]);
 389         }
 390
 391         // Add a deactivation request for the specified resource.
 392         Reference<XConfigurationChangeRequest> xRequest(
 393             new GenericConfigurationChangeRequest(
 394                 rxResourceId,
 395                 GenericConfigurationChangeRequest::Deactivation));
 396         postChangeRequest(xRequest);
 397     }
 398 }
 399
 400
 401
 402
 403 Reference<XResource> SAL_CALL ConfigurationController::getResource (
 404     const Reference<XResourceId>& rxResourceId)
 405     throw (RuntimeException)
 406 {
 407     ::osl::MutexGuard aGuard (maMutex);
 408     ThrowIfDisposed();
 409
 410     ConfigurationControllerResourceManager::ResourceDescriptor aDescriptor (
 411         mpImplementation->mpResourceManager->GetResource(rxResourceId));
 412     return aDescriptor.mxResource;
 413 }
 414
 415
 416
 417
 418 void SAL_CALL ConfigurationController::update (void)
 419     throw (RuntimeException)
 420 {
 421     ::osl::MutexGuard aGuard (maMutex);
 422     ThrowIfDisposed();
 423
 424     if (mpImplementation->mpQueueProcessor->IsEmpty())
 425     {
 426         // The queue is empty.  Add another request that does nothing but
 427         // asynchronously trigger a request for an update.
 428         mpImplementation->mpQueueProcessor->AddRequest(new UpdateRequest());
 429     }
 430     else
 431     {
 432         // The queue is not empty, so we rely on the queue processor to
 433         // request an update automatically when the queue becomes empty.
 434     }
 435 }
 436
 437
 438
 439
 440 sal_Bool SAL_CALL ConfigurationController::hasPendingRequests (void)
 441     throw (RuntimeException)
 442 {
 443     ::osl::MutexGuard aGuard (maMutex);
 444     ThrowIfDisposed();
 445
 446     return ! mpImplementation->mpQueueProcessor->IsEmpty();
 447 }
 448
 449
 450
 451
 452
 453 void SAL_CALL ConfigurationController::postChangeRequest (
 454     const Reference<XConfigurationChangeRequest>& rxRequest)
 455     throw (RuntimeException)
 456 {
 457     ::osl::MutexGuard aGuard (maMutex);
 458     ThrowIfDisposed();
 459
 460     mpImplementation->mpQueueProcessor->AddRequest(rxRequest);
 461 }
 462
 463
 464
 465
 466 Reference<XConfiguration> SAL_CALL ConfigurationController::getRequestedConfiguration (void)
 467     throw (RuntimeException)
 468 {
 469     ::osl::MutexGuard aGuard (maMutex);
 470     ThrowIfDisposed();
 471
 472     if (mpImplementation->mxRequestedConfiguration.is())
 473         return Reference<XConfiguration>(
 474             mpImplementation->mxRequestedConfiguration->createClone(), UNO_QUERY);
 475     else
 476         return Reference<XConfiguration>();
 477 }
 478
 479
 480
 481
 482 Reference<XConfiguration> SAL_CALL ConfigurationController::getCurrentConfiguration (void)
 483     throw (RuntimeException)
 484 {
 485     ::osl::MutexGuard aGuard (maMutex);
 486     ThrowIfDisposed();
 487
 488     Reference<XConfiguration> xCurrentConfiguration(
 489         mpImplementation->mpConfigurationUpdater->GetCurrentConfiguration());
 490     if (xCurrentConfiguration.is())
 491         return Reference<XConfiguration>(xCurrentConfiguration->createClone(), UNO_QUERY);
 492     else
 493         return Reference<XConfiguration>();
 494 }
 495
 496
 497
 498
 499 /** The given configuration is restored by generating the appropriate set of
 500     activation and deactivation requests.
 501 */
 502 void SAL_CALL ConfigurationController::restoreConfiguration (
 503     const Reference<XConfiguration>& rxNewConfiguration)
 504     throw (RuntimeException)
 505 {
 506     ::osl::MutexGuard aGuard (maMutex);
 507     ThrowIfDisposed();
 508
 509     // We will probably be making a couple of activation and deactivation
 510     // requests so lock the configuration controller and let it later update
 511     // all changes at once.
 512     ::boost::shared_ptr<ConfigurationUpdaterLock> pLock (
 513         mpImplementation->mpConfigurationUpdater->GetLock());
 514
 515     // Get lists of resources that are to be activated or deactivated.
 516     Reference<XConfiguration> xCurrentConfiguration (mpImplementation->mxRequestedConfiguration);
 517 #if OSL_DEBUG_LEVEL >=1
 518     SAL_INFO("sd.fwk", OSL_THIS_FUNC << ": ConfigurationController::restoreConfiguration(");
 519     ConfigurationTracer::TraceConfiguration(rxNewConfiguration, "requested configuration");
 520     ConfigurationTracer::TraceConfiguration(xCurrentConfiguration, "current configuration");
 521 #endif
 522     ConfigurationClassifier aClassifier (rxNewConfiguration, xCurrentConfiguration);
 523     aClassifier.Partition();
 524 #if OSL_DEBUG_LEVEL >=2
 525     aClassifier.TraceResourceIdVector(
 526         "requested but not current resources:\n", aClassifier.GetC1minusC2());
 527     aClassifier.TraceResourceIdVector(
 528         "current but not requested resources:\n", aClassifier.GetC2minusC1());
 529     aClassifier.TraceResourceIdVector(
 530         "requested and current resources:\n", aClassifier.GetC1andC2());
 531 #endif
 532
 533     ConfigurationClassifier::ResourceIdVector::const_iterator iResource;
 534
 535     // Request the deactivation of resources that are not requested in the
 536     // new configuration.
 537     const ConfigurationClassifier::ResourceIdVector& rResourcesToDeactivate (
 538         aClassifier.GetC2minusC1());
 539     for (iResource=rResourcesToDeactivate.begin();
 540          iResource!=rResourcesToDeactivate.end();
 541          ++iResource)
 542     {
 543         requestResourceDeactivation(*iResource);
 544     }
 545
 546     // Request the activation of resources that are requested in the
 547     // new configuration but are not part of the current configuration.
 548     const ConfigurationClassifier::ResourceIdVector& rResourcesToActivate (
 549         aClassifier.GetC1minusC2());
 550     for (iResource=rResourcesToActivate.begin();
 551          iResource!=rResourcesToActivate.end();
 552          ++iResource)
 553     {
 554         requestResourceActivation(*iResource, ResourceActivationMode_ADD);
 555     }
 556
 557     pLock.reset();
 558 }
 559
 560
 561
 562
 563 //----- XResourceFactoryManager -----------------------------------------------
 564
 565 void SAL_CALL ConfigurationController::addResourceFactory(
 566     const OUString& sResourceURL,
 567     const Reference<XResourceFactory>& rxResourceFactory)
 568     throw (RuntimeException)
 569 {
 570     ::osl::MutexGuard aGuard (maMutex);
 571     ThrowIfDisposed();
 572     mpImplementation->mpResourceFactoryContainer->AddFactory(sResourceURL, rxResourceFactory);
 573 }
 574
 575
 576
 577
 578 void SAL_CALL ConfigurationController::removeResourceFactoryForURL(
 579     const OUString& sResourceURL)
 580     throw (RuntimeException)
 581 {
 582     ::osl::MutexGuard aGuard (maMutex);
 583     ThrowIfDisposed();
 584     mpImplementation->mpResourceFactoryContainer->RemoveFactoryForURL(sResourceURL);
 585 }
 586
 587
 588
 589
 590 void SAL_CALL ConfigurationController::removeResourceFactoryForReference(
 591     const Reference<XResourceFactory>& rxResourceFactory)
 592     throw (RuntimeException)
 593 {
 594     ::osl::MutexGuard aGuard (maMutex);
 595     ThrowIfDisposed();
 596     mpImplementation->mpResourceFactoryContainer->RemoveFactoryForReference(rxResourceFactory);
 597 }
 598
 599
 600
 601
 602 Reference<XResourceFactory> SAL_CALL ConfigurationController::getResourceFactory (
 603     const OUString& sResourceURL)
 604     throw (RuntimeException)
 605 {
 606     ::osl::MutexGuard aGuard (maMutex);
 607     ThrowIfDisposed();
 608
 609     return mpImplementation->mpResourceFactoryContainer->GetFactory(sResourceURL);
 610 }
 611
 612
 613
 614
 615 //----- XInitialization -------------------------------------------------------
 616
 617 void SAL_CALL ConfigurationController::initialize (const Sequence<Any>& aArguments)
 618     throw (Exception, RuntimeException)
 619 {
 620     ::osl::MutexGuard aGuard (maMutex);
 621
 622     if (aArguments.getLength() == 1)
 623     {
 624         const SolarMutexGuard aSolarGuard;
 625
 626         mpImplementation.reset(new Implementation(
 627             *this,
 628             Reference<frame::XController>(aArguments[0], UNO_QUERY_THROW)));
 629     }
 630 }
 631
 632
 633
 634
 635 //-----------------------------------------------------------------------------
 636
 637 void ConfigurationController::ThrowIfDisposed (void) const
 638     throw (::com::sun::star::lang::DisposedException)
 639 {
 640     if (mbIsDisposed)
 641     {
 642         throw lang::DisposedException ("ConfigurationController object has already been disposed",
 643             const_cast<uno::XWeak*>(static_cast<const uno::XWeak*>(this)));
 644     }
 645
 646     if (mpImplementation.get() == NULL)
 647     {
 648         OSL_ASSERT(mpImplementation.get() != NULL);
 649         throw RuntimeException("ConfigurationController not initialized",
 650             const_cast<uno::XWeak*>(static_cast<const uno::XWeak*>(this)));
 651     }
 652 }
 653
 654
 655
 656
 657 //===== ConfigurationController::Implementation ===============================
 658
 659 ConfigurationController::Implementation::Implementation (
 660     ConfigurationController& rController,
 661     const Reference<frame::XController>& rxController)
 662     : mxControllerManager(rxController, UNO_QUERY_THROW),
 663       mpBroadcaster(new ConfigurationControllerBroadcaster(&rController)),
 664       mxRequestedConfiguration(new Configuration(&rController, true)),
 665       mpBase(NULL),
 666       mpResourceFactoryContainer(new ResourceFactoryManager(mxControllerManager)),
 667       mpResourceManager(
 668           new ConfigurationControllerResourceManager(mpResourceFactoryContainer,mpBroadcaster)),
 669       mpConfigurationUpdater(
 670           new ConfigurationUpdater(mpBroadcaster, mpResourceManager,mxControllerManager)),
 671       mpQueueProcessor(new ChangeRequestQueueProcessor(&rController,mpConfigurationUpdater)),
 672       mpConfigurationUpdaterLock(),
 673       mnLockCount(0)
 674 {
 675     mpQueueProcessor->SetConfiguration(mxRequestedConfiguration);
 676 }
 677
 678
 679
 680
 681 ConfigurationController::Implementation::~Implementation (void)
 682 {
 683 }
 684
 685
 686
 687
 688 } } // end of namespace sd::framework
 689
 690 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */