configmgr/source/api2/apitreeimplobj.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: apitreeimplobj.cxx,v $
  10  * $Revision: 1.44 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_configmgr.hxx"
  33 #include <stdio.h>
  34
  35 #include "apitreeimplobj.hxx"
  36 #include "confignotifier.hxx"
  37 #include "notifierimpl.hxx"
  38 #include "apifactory.hxx"
  39 #include "apitreeaccess.hxx"
  40 #include "nodechangeinfo.hxx"
  41 #include "broadcaster.hxx"
  42 #include "change.hxx"
  43 #include "providerimpl.hxx"
  44 #include "roottree.hxx"
  45 #include "noderef.hxx"
  46 #include "anynoderef.hxx"
  47 #include "tracer.hxx"
  48 #include "treemanager.hxx"
  49 #include <cppuhelper/queryinterface.hxx>
  50 #include <vos/refernce.hxx>
  51
  52 namespace configmgr
  53 {
  54 //-----------------------------------------------------------------------------
  55     namespace configapi
  56     {
  57 //-----------------------------------------------------------------------------
  58         namespace lang = ::com::sun::star::lang;
  59 //-----------------------------------------------------------------------------
  60         class Factory;
  61         class Notifier;
  62 //-----------------------------------------------------------------------------
  63 class ApiTreeImpl::ComponentAdapter : public lang::XEventListener
  64 {
  65     vos::ORefCount m_refs;
  66
  67     ApiTreeImpl* pOwner;
  68
  69     uno::Reference< lang::XComponent > xProvider;
  70     uno::Reference< lang::XComponent > xParent;
  71 public:
  72     ComponentAdapter(ApiTreeImpl& rParent) : pOwner(&rParent) {}
  73     virtual ~ComponentAdapter() {}
  74
  75     void clear();
  76
  77     void setProvider(uno::Reference< lang::XComponent > const& xProvider);
  78     void setParent(uno::Reference< lang::XComponent > const& xParent);
  79     uno::Reference< lang::XComponent > getProvider() const;
  80
  81 // XEventListener
  82     virtual void SAL_CALL acquire() throw();
  83     virtual void SAL_CALL release() throw();
  84 private:
  85     void setComponent(uno::Reference< lang::XComponent >& rxSlot,uno::Reference< lang::XComponent > const& xComp);
  86     uno::Reference< lang::XComponent > getComponent(uno::Reference< lang::XComponent > const& rxSlot) const;
  87
  88     virtual uno::Any SAL_CALL queryInterface(uno::Type const& rType) throw();
  89     virtual void SAL_CALL disposing(com::sun::star::lang::EventObject const& rEvt) throw();
  90 };
  91 //-----------------------------------------------------------------------------
  92 inline
  93 uno::Reference< lang::XComponent >
  94     ApiTreeImpl::ComponentAdapter::getComponent(
  95         uno::Reference< lang::XComponent > const& rxSlot
  96     ) const
  97 {
  98     return rxSlot;
  99 }
 100 //-----------------------------------------------------------------------------
 101 inline
 102 void ApiTreeImpl::ComponentAdapter::setComponent(
 103         uno::Reference< lang::XComponent >& rxSlot,
 104         uno::Reference< lang::XComponent > const& xComp
 105     )
 106 {
 107     UnoApiLockClearable aGuard;
 108
 109     uno::Reference< lang::XComponent > xOld = rxSlot;
 110     if (xOld != xComp)
 111     {
 112         rxSlot = xComp;
 113
 114         aGuard.clear();
 115
 116         if (xOld.is())  try { xOld->removeEventListener(this); } catch (uno::Exception & ) {}
 117         if (xComp.is()) xComp->addEventListener(this);
 118     }
 119 }
 120 //-----------------------------------------------------------------------------
 121 uno::Reference< lang::XComponent > ApiTreeImpl::ComponentAdapter::getProvider() const
 122 {
 123     return this->getComponent( this->xProvider );
 124 }
 125 void ApiTreeImpl::ComponentAdapter::setProvider(uno::Reference< lang::XComponent > const& rProvider)
 126 {
 127     this->setComponent( this->xProvider, rProvider);
 128 }
 129 void ApiTreeImpl::ComponentAdapter::setParent(uno::Reference< lang::XComponent > const& rParent)
 130 {
 131     this->setComponent( this->xParent, rParent);
 132 }
 133 //-----------------------------------------------------------------------------
 134
 135 void SAL_CALL ApiTreeImpl::ComponentAdapter::acquire() throw()
 136 {
 137     ++m_refs;
 138 }
 139 //-------------------------------------------------------------------------
 140
 141 void SAL_CALL ApiTreeImpl::ComponentAdapter::release() throw()
 142 {
 143     if (--m_refs == 0)
 144         delete this;
 145 }
 146 //-------------------------------------------------------------------------
 147
 148 uno::Any SAL_CALL ApiTreeImpl::ComponentAdapter::queryInterface(uno::Type const& rType) throw()
 149 {
 150     return cppu::queryInterface( rType
 151                 , static_cast< com::sun::star::lang::XEventListener*>(this)
 152                 , static_cast< uno::XInterface*>(this)
 153             );
 154 }
 155 //-------------------------------------------------------------------------
 156
 157 void SAL_CALL ApiTreeImpl::ComponentAdapter::disposing(com::sun::star::lang::EventObject const& rEvt) throw()
 158 {
 159     UnoApiLockClearable aGuard;
 160
 161     if (this->pOwner != NULL)
 162     {
 163         CFG_TRACE_INFO("ApiTreeImpl:ComponentAdapter: Providing UNO object is disposed - relaying to my owner");
 164         // ensure our owner stays alive
 165         uno::Reference<uno::XInterface> xKeepOwnerAlive( this->pOwner->getUnoInstance() );
 166         // and we stay alive too
 167         rtl::Reference< ApiTreeImpl::ComponentAdapter > xKeepAlive( this );
 168
 169         aGuard.clear();
 170
 171         pOwner->disposing( rEvt );
 172
 173         UnoApiLock aClearGuard;
 174         if (rEvt.Source == this->xParent) this->xParent.clear();
 175         if (rEvt.Source == this->xProvider) this->xProvider.clear();
 176     }
 177     else
 178         CFG_TRACE_INFO("ApiTreeImpl:ComponentAdapter: Providing UNO object is disposed - but my owner is already gone");
 179 }
 180
 181 //-------------------------------------------------------------------------
 182
 183 void ApiTreeImpl::ComponentAdapter::clear()
 184 {
 185     UnoApiLockClearable aGuard;
 186
 187     this->pOwner = 0;
 188
 189     uno::Reference< lang::XComponent > aProvider = this->xProvider;
 190     uno::Reference< lang::XComponent > aParent   = this->xParent;
 191     this->xProvider = 0;
 192     this->xParent = 0;
 193
 194     aGuard.clear();
 195
 196     if (aParent.is())   try { aParent  ->removeEventListener(this); } catch (uno::Exception & ) {}
 197     if (aProvider.is()) try { aProvider->removeEventListener(this); } catch (uno::Exception & ) {}
 198 }
 199
 200 //-----------------------------------------------------------------------------
 201 class ApiRootTreeImpl::NodeListener : public INodeListener
 202 {
 203     ApiRootTreeImpl*    pParent;
 204     TreeManager * pSource;
 205
 206     vos::ORef< OOptions >           m_xOptions;
 207     configuration::AbsolutePath           m_aLocationPath;
 208 public:
 209     NodeListener(ApiRootTreeImpl& _rParent)
 210         : pParent(&_rParent)
 211         , pSource(NULL)
 212         , m_aLocationPath( configuration::AbsolutePath::root() )
 213     {}
 214     ~NodeListener()
 215     {
 216         unbind();
 217     }
 218
 219     TreeManager * getSource()
 220     {
 221         UnoApiLock aGuard;
 222         return pSource;
 223     }
 224
 225     void setSource(TreeManager * pNew)
 226     {
 227         UnoApiLock aGuard;
 228         if (pParent)
 229         {
 230             if (pNew != pSource)
 231             {
 232                 OSL_ENSURE(m_xOptions.isValid(),"Cannot set IConfigListener without Options");
 233                 if (m_xOptions.isValid())
 234                 {
 235                     if (pSource)
 236                         pSource->removeListener(m_xOptions->getRequestOptions(), this);
 237
 238                     pSource = pNew;
 239                     if (pNew)
 240                     {
 241                         OSL_ENSURE(!m_aLocationPath.isRoot(), "Cannot register for notifications: no location set");
 242                         pNew->addListener(m_aLocationPath, m_xOptions->getRequestOptions(), this);
 243                     }
 244                 }
 245                 else
 246                     pSource = 0;
 247             }
 248         }
 249     }
 250
 251     void setLocation(configuration::AbsolutePath const& _aLocation, vos::ORef< OOptions > const& _xOptions)
 252     {
 253         OSL_ASSERT(_xOptions.isValid());
 254
 255         UnoApiLock aGuard;
 256
 257         if (pSource && pParent)
 258         {
 259             OSL_ASSERT(m_xOptions.isValid());
 260             pSource->removeListener(m_xOptions->getRequestOptions(), this);
 261         }
 262
 263         m_aLocationPath = _aLocation;
 264         m_xOptions = _xOptions;
 265
 266         if (pSource && pParent)
 267             pSource->addListener(m_aLocationPath, m_xOptions->getRequestOptions(), this);
 268     }
 269
 270     void unbind()
 271     {
 272         UnoApiLock aGuard;
 273         OSL_ASSERT(pParent == 0);
 274         pParent = 0;
 275         if (pSource)
 276         {
 277             OSL_ASSERT(m_xOptions.isValid());
 278             pSource->removeListener(m_xOptions->getRequestOptions(), this);
 279             m_xOptions.unbind();
 280             m_aLocationPath = configuration::AbsolutePath::root();
 281         }
 282
 283     }
 284
 285     void clearParent()
 286     {
 287         UnoApiLockClearable aGuard;
 288         if (pParent)
 289         {
 290             pParent = 0;
 291
 292             if (pSource)
 293             {
 294                 TreeManager * pOrgSource = pSource;
 295                 vos::ORef< OOptions > xOptions = m_xOptions;
 296
 297                 pSource = 0;
 298                 m_xOptions.unbind();
 299                 m_aLocationPath = configuration::AbsolutePath::root();
 300
 301                 aGuard.clear();
 302
 303                 OSL_ASSERT(xOptions.isValid());
 304                 pOrgSource->removeListener(xOptions->getRequestOptions(), this);
 305             }
 306         }
 307     }
 308
 309     // Interfaces
 310     virtual void disposing(TreeManager * pSource);
 311     virtual void nodeChanged(Change const& aChange, configuration::AbsolutePath const& sPath, TreeManager * pSource);
 312     virtual void nodeDeleted(configuration::AbsolutePath const& sPath, TreeManager * pSource);
 313 };
 314
 315 //-------------------------------------------------------------------------
 316
 317 //-----------------------------------------------------------------------------
 318 // API object implementation wrappers
 319 //-------------------------------------------------------------------------
 320 ApiProvider::ApiProvider(Factory& rFactory, OProviderImpl& rProviderImpl )
 321     : m_rFactory(rFactory)
 322     , m_rProviderImpl(rProviderImpl)
 323 {}
 324 //-------------------------------------------------------------------------
 325
 326 uno::Reference<com::sun::star::script::XTypeConverter> ApiProvider::getTypeConverter() const
 327 {
 328     return m_rProviderImpl.getTypeConverter();
 329 }
 330 //-------------------------------------------------------------------------
 331 static
 332 inline
 333 configuration::DefaultProvider createDefaultProvider(
 334                                     ApiProvider& rProvider,
 335                                     rtl::Reference< configuration::Tree > const& aTree,
 336                                     vos::ORef< OOptions > const& _xOptions
 337                                )
 338 {
 339     OProviderImpl& rProviderImpl        = rProvider.getProviderImpl();
 340     rtl::Reference< TreeManager > xDefaultProvider  = rProviderImpl.getDefaultProvider();
 341
 342     OSL_ASSERT(_xOptions.isValid());
 343     RequestOptions const aOptions = _xOptions.isValid() ? _xOptions->getRequestOptions() : RequestOptions();
 344
 345     return configuration::DefaultProvider::create(aTree,aOptions,xDefaultProvider,&rProviderImpl);
 346 }
 347 //-------------------------------------------------------------------------
 348 static
 349 inline
 350 configuration::DefaultProvider extractDefaultProvider(ApiTreeImpl* pParentTree)
 351 {
 352     if (pParentTree)
 353         return pParentTree->getDefaultProvider();
 354
 355     else
 356         return configuration::DefaultProvider::createEmpty();
 357 }
 358 //-------------------------------------------------------------------------
 359 ApiTreeImpl::ApiTreeImpl(uno::XInterface* pInstance, ApiProvider& rProvider, rtl::Reference< configuration::Tree > const& aTree, ApiTreeImpl* pParentTree)
 360 : m_aTree(aTree)
 361 , m_aNotifier(new NotifierImpl(aTree))
 362 , m_aDefaultProvider(extractDefaultProvider(pParentTree))
 363 , m_xProvider()
 364 , m_rProvider(rProvider)
 365 , m_pParentTree(0)
 366 , m_pInstance(pInstance)
 367 {
 368     OSL_ENSURE(pParentTree == NULL || &rProvider == &pParentTree->m_rProvider,"WARNING: Parent tree has a different provider - trouble may be ahead");
 369     setNodeInstance(aTree->getRootNode(), pInstance);
 370     init(pParentTree);
 371 }
 372 //-------------------------------------------------------------------------
 373 ApiTreeImpl::ApiTreeImpl(uno::XInterface* _pInstance, ApiProvider& _rProvider, rtl::Reference< configuration::Tree > const& _aTree, configuration::DefaultProvider const& _aDefaultProvider)
 374 : m_aTree(_aTree)
 375 , m_aNotifier(new NotifierImpl(_aTree))
 376 , m_aDefaultProvider(_aDefaultProvider)
 377 , m_xProvider()
 378 , m_rProvider(_rProvider)
 379 , m_pParentTree(0)
 380 , m_pInstance(_pInstance)
 381 {
 382     setNodeInstance(_aTree->getRootNode(), _pInstance);
 383     init(NULL);
 384 }
 385 //-------------------------------------------------------------------------
 386
 387 ApiTreeImpl::~ApiTreeImpl()
 388 {
 389     OSL_ENSURE(m_aNotifier->m_aListeners.isDisposed(),"ApiTree Object was not disposed properly");
 390     deinit();
 391 }
 392 //-------------------------------------------------------------------------
 393
 394 ApiRootTreeImpl::ApiRootTreeImpl(uno::XInterface* pInstance, ApiProvider& rProvider, rtl::Reference< configuration::Tree > const& aTree, vos::ORef< OOptions > const& _xOptions)
 395 : m_aTreeImpl(pInstance, rProvider, aTree, createDefaultProvider(rProvider, aTree, _xOptions))
 396 , m_aLocationPath( configuration::Path::Rep() )
 397 , m_pNotificationListener(NULL)
 398 , m_xOptions(_xOptions)
 399 {
 400     implSetLocation(aTree);
 401     enableNotification(true);
 402 }
 403 //-------------------------------------------------------------------------
 404 ApiRootTreeImpl::~ApiRootTreeImpl()
 405 {
 406     if (m_pNotificationListener.is())
 407     {
 408         m_pNotificationListener->setSource(0);
 409         m_pNotificationListener->clearParent();
 410     }
 411 }
 412 //-------------------------------------------------------------------------
 413
 414 void ApiTreeImpl::setNodeInstance(configuration::NodeRef const& aNode, uno::XInterface* pInstance)
 415 {
 416     OSL_ENSURE(aNode.isValid(),"ERROR: adding invalid node to ApiTree");
 417     OSL_ENSURE(m_aTree->isValidNode(aNode.getOffset()),"ERROR: foreign node being added to ApiTree");
 418     m_aNotifier->m_aListeners.setObjectAt( configuration::NodeID(m_aTree, aNode).toIndex(), pInstance );
 419 }
 420
 421 //-------------------------------------------------------------------------
 422
 423 bool ApiTreeImpl::isAlive() const
 424 {
 425     return m_aNotifier->m_aListeners.isAlive();
 426 }
 427 //-------------------------------------------------------------------------
 428 void ApiTreeImpl::checkAlive() const
 429 {
 430     m_aNotifier->m_aListeners.checkAlive( getUnoInstance() );
 431 }
 432
 433 //-------------------------------------------------------------------------
 434
 435 Notifier ApiTreeImpl::getNotifier() const
 436 {
 437     return Notifier(m_aNotifier,this);
 438 }
 439 //-------------------------------------------------------------------------
 440
 441 bool ApiRootTreeImpl::enableNotification(bool bEnable)
 442 {
 443     TreeManager * pSource = bEnable ? getApiTree().getProvider().getProviderImpl().getNotifier() : 0;
 444
 445     TreeManager * pOld = this->implSetNotificationSource(pSource);
 446
 447     return pOld != 0;
 448 }
 449 //-------------------------------------------------------------------------
 450
 451 bool ApiTreeImpl::disposeTree(bool bForce)
 452 {
 453     CFG_TRACE_INFO("ApiTreeImpl: Disposing Tree (may throw if already disposed)");
 454
 455     // ensure our provider stays alive
 456     uno::Reference<uno::XInterface> xKeepParentAlive(this->getParentComponent());
 457     // ensure we stay alive too
 458     uno::Reference<uno::XInterface> xKeepAlive(this->getUnoInstance());
 459
 460     // #109077# If already disposed, we may have no source data or data lock
 461     if (!isAlive())
 462         return false;
 463
 464     if (!bForce)
 465     {
 466         if (m_pParentTree != 0)
 467             return false;
 468
 469         // recheck after having the mutex
 470         checkAlive(); // may throw
 471     }
 472     else if (m_pParentTree)
 473         setParentTree(NULL);
 474
 475     implDisposeTree();
 476     OSL_ASSERT(!isAlive()); // post condition
 477
 478     return true;
 479 }
 480 //-------------------------------------------------------------------------
 481
 482 bool ApiTreeImpl::disposeTreeNow()
 483 {
 484     CFG_TRACE_INFO("ApiTreeImpl: Disposing Tree Now (unless disposed)");
 485     if (isAlive() )
 486         return implDisposeTree();
 487     else
 488         return false;
 489 }
 490 //-------------------------------------------------------------------------
 491 bool ApiRootTreeImpl::disposeTree()
 492 {
 493     CFG_TRACE_INFO("Api Root Tree: Disposing Tree And Releasing (unless disposed)");
 494     // ensure our provider stays alive
 495     uno::Reference<uno::XInterface> xKeepProvider( m_aTreeImpl.getUnoProviderInstance() );
 496
 497     rtl::Reference<NodeListener> xListener = m_pNotificationListener;
 498     if (xListener.is())
 499     {
 500         xListener->clearParent();
 501         xListener.clear();
 502     }
 503
 504     bool bDisposed = m_aTreeImpl.disposeTreeNow();
 505
 506     if (bDisposed) releaseData();
 507
 508     if (!m_xOptions.isEmpty())
 509     {
 510         OSL_ENSURE(!bDisposed, "Disposing/Releasing should clear the options");
 511         CFG_TRACE_INFO2("Api Root Tree: data was not released in disposeTree");
 512     }
 513
 514     return bDisposed;
 515 }
 516 //-------------------------------------------------------------------------
 517 bool ApiTreeImpl::implDisposeTree()
 518 {
 519     OSL_ENSURE(m_pParentTree == 0,"WARNING: Disposing a tree that still has a parent tree set");
 520
 521     SpecialListenerContainer <configuration::SubNodeID,SubNodeHash,SubNodeEq,SubNodeToIndex>& aContainer = m_aNotifier->m_aListeners;
 522     if (aContainer.beginDisposing())
 523     {
 524         CFG_TRACE_INFO("ApiTreeImpl: Tree is now disposed");
 525
 526         Factory& rFactory = getFactory();
 527
 528         std::vector<configuration::NodeID> aChildNodes;
 529         configuration::getAllContainedNodes( m_aTree, aChildNodes);
 530
 531         for (std::vector<configuration::NodeID>::reverse_iterator it = aChildNodes.rbegin(), stop = aChildNodes.rend();
 532             it != stop;
 533             ++it)
 534         {
 535             rFactory.revokeElement( *it );
 536         }
 537
 538         CFG_TRACE_INFO_NI("ApiTreeImpl: Listeners are now informed");
 539         aContainer.notifyDisposing();
 540
 541         OSL_ASSERT(!aContainer.isDisposed());
 542
 543         CFG_TRACE_INFO_NI("ApiTreeImpl: Deinitializing");
 544         deinit(); // releases the provider and parent
 545         aContainer.endDisposing();
 546
 547         OSL_ASSERT(aContainer.isDisposed());
 548
 549         return true;
 550     }
 551     else
 552     {
 553         CFG_TRACE_INFO("ApiTreeImpl: Tree was already disposed.");
 554         return false;
 555     }
 556 }
 557 //-------------------------------------------------------------------------
 558 void ApiTreeImpl::disposeNode(configuration::NodeRef const& aNode, uno::XInterface* pInstance)
 559 {
 560     // This used to contain 3 nested 'isAlive()' calls; why !?
 561     if (isAlive())
 562         implDisposeNode(aNode,pInstance);
 563 }
 564 //-------------------------------------------------------------------------
 565 void ApiTreeImpl::implDisposeNode(configuration::NodeRef const& aNode, uno::XInterface* )
 566 {
 567     CFG_TRACE_INFO("ApiTreeImpl: Disposing a single node.");
 568     OSL_ENSURE(aNode.isValid(),"INTERNAL ERROR: Disposing NULL node");
 569     OSL_ENSURE(m_aTree->isValidNode(aNode.getOffset()),"INTERNAL ERROR: Disposing: node does not match tree");
 570     OSL_ENSURE( !m_aTree->isRootNode(aNode),"INTERNAL ERROR: Disposing the root node of the tree");
 571
 572     configuration::NodeID aNodeID(m_aTree,aNode);
 573
 574     if (m_aNotifier->m_aListeners.disposeOne(aNodeID.toIndex()) )
 575     {
 576         getFactory().revokeElement(aNodeID);
 577     }
 578 }
 579 //-------------------------------------------------------------------------
 580 void ApiTreeImpl::init(ApiTreeImpl*     pParentTree)
 581 {
 582     m_xProvider = new ComponentAdapter(*this);
 583     m_xProvider->setProvider( this->getProviderComponent() );
 584
 585     OSL_ENSURE(m_xProvider->getProvider().is(),"WARNING: Provider is no Component - Lifetime trouble ahead");
 586
 587     OSL_ASSERT(m_pParentTree == 0);
 588     setParentTree(pParentTree);
 589 }
 590 //-------------------------------------------------------------------------
 591 void ApiTreeImpl::deinit()
 592 {
 593     setParentTree(0);
 594
 595     uno::Reference<ComponentAdapter> xAdapter = m_xProvider;
 596     m_xProvider.clear();
 597
 598     if (xAdapter.is())
 599         xAdapter->clear();
 600 }
 601 //-------------------------------------------------------------------------
 602 void ApiTreeImpl::haveNewParent(ApiTreeImpl* pNewParent) // public interface
 603 {
 604     setParentTree(pNewParent);
 605 }
 606
 607 //-------------------------------------------------------------------------
 608
 609 ApiTreeImpl const* ApiTreeImpl::getRootTreeImpl() const
 610 {
 611     ApiTreeImpl const* pRet = this;
 612     while (pRet->m_pParentTree)
 613         pRet = pRet->m_pParentTree;
 614
 615     return pRet;
 616 }
 617
 618 //-------------------------------------------------------------------------
 619 void ApiTreeImpl::setParentTree(ApiTreeImpl*    pParentTree) // internal implementation
 620 {
 621 #if OSL_DEBUG_LEVEL > 0
 622     if (pParentTree)
 623     {
 624         rtl::Reference< configuration::Tree > aContext = m_aTree->getContextTree();
 625         rtl::Reference< configuration::Tree > aParent = pParentTree->m_aTree;
 626
 627         configuration::NodeID aContextID( aContext, aContext->getRootNode() );
 628         configuration::NodeID aParentID( aParent, aParent->getRootNode() );
 629
 630         OSL_ENSURE( aContextID == aParentID, "Parent relationship mismatch !");
 631     }
 632 #endif
 633
 634     if (m_pParentTree != pParentTree)
 635     {
 636         uno::Reference<ComponentAdapter> xAdapter = m_xProvider;
 637
 638         m_pParentTree = pParentTree;
 639
 640         uno::Reference<com::sun::star::lang::XComponent> xNew = getParentComponent();
 641         OSL_ENSURE( xNew.is() == (pParentTree != 0), "WARNING: Parent Tree is no Component");
 642
 643         if (xAdapter.is())
 644             xAdapter->setParent(xNew);
 645         else
 646             OSL_ENSURE( pParentTree == 0, "ERROR: Setting New Parent at deinitialized ApiTreeImpl");
 647
 648     }
 649 }
 650 //-------------------------------------------------------------------------
 651
 652 uno::Reference<uno::XInterface> ApiTreeImpl::getUnoProviderInstance() const
 653 {
 654     uno::Reference<ComponentAdapter> xAdapter = m_xProvider;
 655
 656     uno::Reference<uno::XInterface> xReturn;
 657     if (xAdapter.is())
 658         xReturn = xAdapter->getProvider();
 659     return xReturn;
 660 }
 661
 662 //-------------------------------------------------------------------------
 663 uno::Reference<com::sun::star::lang::XComponent> ApiTreeImpl::getParentComponent()
 664 {
 665     uno::XInterface* pInterface = m_pParentTree ? m_pParentTree->getUnoInstance() : 0;
 666     return uno::Reference<com::sun::star::lang::XComponent>::query(pInterface);
 667 }
 668 //-------------------------------------------------------------------------
 669
 670 uno::Reference<com::sun::star::lang::XComponent> ApiTreeImpl::getProviderComponent()
 671 {
 672     uno::XInterface* pInterface = m_rProvider.getProviderImpl().getProviderInstance();
 673     return uno::Reference<com::sun::star::lang::XComponent>::query(pInterface);
 674 }
 675
 676 //-------------------------------------------------------------------------
 677
 678 void ApiTreeImpl::disposing(com::sun::star::lang::EventObject const& ) throw()
 679 {
 680     // this is a non-UNO external entry point - we need to keep this object alive for the duration of the call
 681     CFG_TRACE_INFO("ApiTreeImpl: Providing UNO object is disposed - disposing the tree");
 682
 683     // Tree write Lock should be set by sender
 684
 685     CFG_TRACE_INFO_NI("Clearing parent reference");
 686     setParentTree(0);
 687
 688     CFG_TRACE_INFO_NI("Trying to dispose");
 689     //implDisposeTree();
 690     disposeTreeNow();
 691
 692     CFG_TRACE_INFO_NI("Done disposing Tree");
 693     // uno::Reference<com::sun::star::lang::XComponent> xThis(getUnoInstance(),UNO_QUERY);
 694     // if (xThis.is()) xThis->dispose();
 695 }
 696 //-------------------------------------------------------------------------
 697 TreeManager * ApiRootTreeImpl::implSetNotificationSource(TreeManager * pNew)
 698 {
 699     TreeManager * pOld = m_pNotificationListener.is() ? m_pNotificationListener->getSource() : 0;
 700     if (pOld != pNew)
 701     {
 702         OSL_ENSURE(m_xOptions.isValid(), "Cannot change notification source without options");
 703
 704         if (!m_pNotificationListener.is())
 705             m_pNotificationListener = new NodeListener(*this);
 706
 707         m_pNotificationListener->setSource(pNew);
 708
 709     }
 710     return pOld;
 711 }
 712 // ---------------------------------------------------------------------------------------------------
 713
 714 void ApiRootTreeImpl::implSetLocation(rtl::Reference< configuration::Tree > const& _aTree)
 715 {
 716     OSL_ASSERT(_aTree == getApiTree().getTree());
 717     if (!configuration::isEmpty(_aTree.get()))
 718     {
 719         m_aLocationPath = _aTree->getRootPath();
 720         OSL_ENSURE(!m_aLocationPath.isRoot(), "Setting up a root tree without location");
 721     }
 722     else
 723     {
 724         OSL_ENSURE(false, "Setting up a root tree without data");
 725         m_aLocationPath = configuration::AbsolutePath::root();
 726     }
 727
 728     if (!m_pNotificationListener.is())
 729         m_pNotificationListener = new NodeListener(*this);
 730
 731     OSL_ENSURE(!m_aLocationPath.isRoot() && !m_aLocationPath.isDetached(), "Cannot reregister for notifications: setting empty location");
 732     OSL_ENSURE( m_xOptions.isValid(), "Cannot reregister for notifications: no options available" );
 733
 734     m_pNotificationListener->setLocation(m_aLocationPath, m_xOptions);
 735 }
 736 // ---------------------------------------------------------------------------------------------------
 737
 738 void ApiRootTreeImpl::releaseData()
 739 {
 740     CFG_TRACE_INFO("Api Root Tree at %s: releasing the Data",OUSTRING2ASCII(m_aLocationPath.toString()));
 741     rtl::Reference< configuration::Tree > aTree( m_aTreeImpl.getTree() );
 742
 743     if (aTree.is()) {
 744         aTree->disposeData();
 745     }
 746     OSL_ASSERT(configuration::isEmpty(aTree.get()));
 747
 748     OSL_ENSURE( !m_aLocationPath.isRoot() && !m_aLocationPath.isDetached(), "Location still needed to release data" );
 749     OSL_ENSURE( m_xOptions.isValid(), "Options still needed to release data" );
 750
 751     getApiTree().getProvider().getProviderImpl().releaseSubtree(m_aLocationPath,m_xOptions->getRequestOptions());
 752     m_xOptions.unbind();
 753
 754     m_aLocationPath = configuration::AbsolutePath::detachedRoot();
 755 }
 756 // ---------------------------------------------------------------------------------------------------
 757
 758 void ApiRootTreeImpl::NodeListener::disposing(TreeManager * _pSource)
 759 {
 760     UnoApiLockClearable aGuard;
 761
 762     OSL_ASSERT( !pSource || _pSource == pSource );
 763     if (pParent)
 764     {
 765         // this is a non-UNO external entry point - we need to keep this object alive for the duration of the call
 766         uno::Reference<uno::XInterface> xKeepAlive( pParent->m_aTreeImpl.getUnoInstance() );
 767         ApiRootTreeImpl* pKeepParent = pParent;
 768         aGuard.clear();
 769
 770         pKeepParent->disposing(_pSource);
 771     }
 772 }
 773 void ApiRootTreeImpl::disposing(TreeManager *)
 774 {
 775     CFG_TRACE_INFO("Api Root Tree at %s: Cache data is disposed - dispose and release own data",
 776                     OUSTRING2ASCII(m_aLocationPath.toString()));
 777         // ensure our provider stays alive
 778     uno::Reference<uno::XInterface> xKeepProvider( m_aTreeImpl.getUnoProviderInstance() );
 779
 780     rtl::Reference<NodeListener> xListener = m_pNotificationListener;
 781     if (xListener.is())
 782     {
 783         xListener->clearParent();
 784         xListener.clear();
 785     }
 786
 787     if (m_aTreeImpl.disposeTreeNow())
 788         releaseData(); // not really needed: the whole data is going away anyways
 789 }
 790 // ---------------------------------------------------------------------------------------------------
 791
 792 static
 793 void disposeOneRemovedNode(configuration::NodeChangeInformation const& aRemoveInfo, Factory& aFactory)
 794 {
 795     if (aRemoveInfo.change.element.oldValue.is())
 796     {
 797         OSL_ENSURE(aRemoveInfo.change.element.isDataChange(), "ERROR: Disposing replaced element: Element did not really change !");
 798
 799         rtl::Reference< configuration::ElementTree > aElementRef( aRemoveInfo.change.element.oldValue.get() );
 800
 801         SetElement* pSetElement = aFactory.findSetElement(aElementRef );
 802         if (pSetElement)
 803         {
 804             // factory always does an extra acquire
 805             uno::Reference<uno::XInterface> xReleaseSetElement(pSetElement->getUnoInstance(), uno::UNO_REF_NO_ACQUIRE);
 806
 807             pSetElement->haveNewParent(0);
 808             pSetElement->disposeTree(true);
 809         }
 810     }
 811     else
 812     {
 813         // This must apply to a node for which no element tree had been loaded in this view
 814         // thus there should not be one now after the change (even if the change was replacing)
 815         OSL_ENSURE(!aRemoveInfo.change.element.newValue.is(), "Cannot dispose replaced element: No tree object available");
 816     }
 817 }
 818 // ---------------------------------------------------------------------------------------------------
 819
 820 static
 821 void disposeRemovedNodes(configuration::NodeChangesInformation const& aChanges, Factory& aFactory)
 822 {
 823     for (std::vector< configuration::NodeChangeInformation >::const_iterator it = aChanges.begin(); it != aChanges.end(); ++it)
 824     {
 825         switch (it->change.type)
 826         {
 827         case configuration::NodeChangeData::eReplaceElement:
 828             // check if element is actually unchanged !
 829             // (cannot dispose of the tree, if it is still in use)
 830             if (! it->change.element.isDataChange()) break;
 831
 832             // else dispose the old one: fall thru
 833
 834         case configuration::NodeChangeData::eRemoveElement:
 835             disposeOneRemovedNode( *it, aFactory );
 836             break;
 837
 838         default: break;
 839         }
 840     }
 841 }
 842 // ---------------------------------------------------------------------------------------------------
 843 //INodeListener : IConfigListener
 844 void ApiRootTreeImpl::NodeListener::nodeChanged(Change const& aChange, configuration::AbsolutePath const& sPath, TreeManager * _pSource)
 845 {
 846     UnoApiLockClearable aGuard;
 847
 848     OSL_ASSERT( !pSource || _pSource == pSource );
 849     if (pParent)
 850     {
 851         // this is a non-UNO external entry point - we need to keep this object alive for the duration of the call
 852         uno::Reference<uno::XInterface> xKeepAlive( pParent->m_aTreeImpl.getUnoInstance() );
 853         ApiRootTreeImpl* pKeepParent = pParent;
 854         aGuard.clear();
 855
 856         pKeepParent->nodeChanged(aChange,sPath,_pSource);
 857     }
 858 }
 859 // ---------------------------------------------------------------------------------------------------
 860
 861 //INodeListener : IConfigListener
 862 void ApiRootTreeImpl::nodeChanged(Change const& aChange, configuration::AbsolutePath const& aChangePath, TreeManager *)
 863 {
 864     // do not dipatch if we are dying/dead anyway
 865     if (m_aTreeImpl.isAlive())
 866     try
 867     {
 868         rtl::Reference< configuration::Tree > aTree(m_aTreeImpl.getTree());
 869
 870         OSL_ENSURE(configuration::Path::hasPrefix(aChangePath, m_aLocationPath),
 871                     "'changed' Path does not indicate this tree or its context: ");
 872
 873         configuration::RelativePath aLocalChangePath = configuration::Path::stripPrefix(aChangePath,m_aLocationPath);
 874
 875         // find the node and change
 876         configuration::NodeRef  aNode;
 877
 878         if ( !aLocalChangePath.isEmpty() )
 879         {
 880             configuration::NodeRef aBaseNode = aTree->getRootNode();
 881
 882 #ifdef DBG_UTIL
 883             try {
 884                 configuration::RelativePath aLocalPathOld = configuration::validateAndReducePath(aChangePath.toString(), aTree, aBaseNode);
 885                 OSL_ENSURE( configuration::matches(aLocalPathOld,aLocalChangePath),
 886                             "New local path different from validateAndReducePath(...) result in notification dispatch");
 887             }
 888             catch (configuration::Exception& e) {
 889                 rtl::OString sMsg("Cannot validate new path handling for notification dispatch: ");
 890                 sMsg += e.what();
 891                 OSL_ENSURE(false, sMsg.getStr() );
 892             }
 893 #endif // DBG_UTIL
 894
 895             configuration::AnyNodeRef aFoundNode = configuration::getDeepDescendant(aTree, aBaseNode, aLocalChangePath);
 896             if ( aFoundNode.isValid() )
 897             {
 898                 if (aFoundNode.isNode())
 899                 {
 900                     aNode = aFoundNode.toNode();
 901                 }
 902                 else
 903                 {
 904                     // TODO: Notify using parent node and temporary dummy change
 905                     OSL_ENSURE( false, "Notification broken: Node being adressed is a Value");
 906                 }
 907             }
 908         }
 909         else
 910         {
 911             aNode = aTree->getRootNode();
 912         }
 913
 914         SubtreeChange const* pTreeChange = NULL;
 915         if (aNode.isValid())
 916         {
 917             pTreeChange = dynamic_cast<SubtreeChange const*>(&aChange);
 918             OSL_ENSURE(pTreeChange != 0, "Notification broken: Change to inner node is not a subtree change"); // TODO: Notify set change using parent (if available) and temporary dummy change
 919         }
 920
 921         if (pTreeChange != NULL) // implies aNode.isValid()
 922         {
 923             OSL_ENSURE( aChange.getNodeName() == aTree->getSimpleNodeName(aNode.getOffset()),
 924                         "Change's node-name does not match found node's name - erratic notification");
 925
 926             configuration::NodeChangesInformation aChanges;
 927
 928             if (configuration::adjustToChanges(aChanges, aTree,aNode, *pTreeChange))
 929             {
 930                 OSL_ASSERT(aChanges.size() > 0);
 931
 932                 Broadcaster aSender(m_aTreeImpl.getNotifier(),aChanges,false);
 933
 934     // Should be improved later. Maybe this is the wrong lock for disposeTree ?
 935     //                  aLocalGuard.downgrade(); // partial clear for broadcast
 936
 937                 aSender.notifyListeners(aChanges, false);
 938
 939                 disposeRemovedNodes(aChanges, m_aTreeImpl.getFactory());
 940             }
 941         }
 942     }
 943     catch (configuration::InvalidName& i)
 944     {
 945         rtl::OString sMsg("Cannot locate change within this tree: ");
 946         sMsg += i.what();
 947         OSL_ENSURE(false, sMsg.getStr() );
 948     }
 949     catch (configuration::Exception& e)
 950     {
 951         rtl::OString sMsg("Unexpected error trying to react on update: ");
 952         sMsg += e.what();
 953         OSL_ENSURE(false, sMsg.getStr() );
 954     }
 955 }
 956 // ---------------------------------------------------------------------------------------------------
 957
 958 void ApiRootTreeImpl::NodeListener::nodeDeleted(configuration::AbsolutePath const& _aPath, TreeManager * _pSource)
 959 {
 960     UnoApiLockClearable aGuard;
 961
 962     OSL_ASSERT( !pSource || _pSource == pSource );
 963     if (pParent)
 964     {
 965         // this is a non-UNO external entry point - we need to keep this object alive for the duration of the call
 966         uno::Reference<uno::XInterface> xKeepAlive( pParent->m_aTreeImpl.getUnoInstance() );
 967         ApiRootTreeImpl* pKeepParent = pParent;
 968         aGuard.clear();
 969
 970         pKeepParent->nodeDeleted(_aPath,_pSource);
 971     }
 972 }
 973 // ---------------------------------------------------------------------------------------------------
 974 void ApiRootTreeImpl::nodeDeleted(configuration::AbsolutePath const& _aDeletedPath, TreeManager *)
 975 {
 976     { (void)_aDeletedPath; }
 977
 978     // this is a non-UNO external entry point - we need to keep this object alive for the duration of the call
 979     uno::Reference<uno::XInterface> xKeepAlive( m_aTreeImpl.getUnoInstance() );
 980
 981 #ifdef DBG_UTIL
 982     OSL_ENSURE(configuration::Path::hasPrefix(m_aLocationPath, _aDeletedPath),
 983                "'deleted' Path does not indicate this tree or its context: ");
 984 #endif
 985     // ensure our provider stays alive
 986     uno::Reference<uno::XInterface> xKeepProvider( m_aTreeImpl.getUnoProviderInstance() );
 987
 988     rtl::Reference<NodeListener> xListener = m_pNotificationListener;
 989     if (xListener.is())
 990     {
 991         xListener->clearParent();
 992         xListener.clear();
 993     }
 994
 995     if (m_aTreeImpl.disposeTreeNow())
 996         releaseData();
 997 }
 998
 999 // ---------------------------------------------------------------------------------------------------
1000
1001 //-----------------------------------------------------------------------------
1002     }
1003 }
1004