configmgr/source/api2/propsetaccessimpl.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: propsetaccessimpl.cxx,v $
  10  * $Revision: 1.24.10.5 $
  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
  34 #include "propsetaccessimpl.hxx"
  35 #include "propertyinfohelper.hxx"
  36 #include "apinodeaccess.hxx"
  37 #include "apinodeupdate.hxx"
  38 #include "noderef.hxx"
  39 #include "valueref.hxx"
  40 #include "anynoderef.hxx"
  41 #include "nodechange.hxx"
  42 #include "configgroup.hxx"
  43 #include "confignotifier.hxx"
  44 #include "broadcaster.hxx"
  45 #include "apitypes.hxx"
  46 #include "attributes.hxx"
  47 #include <com/sun/star/lang/DisposedException.hpp>
  48 #include <com/sun/star/beans/XPropertySetInfo.hpp>
  49 #include <com/sun/star/beans/PropertyAttribute.hpp>
  50 #include <osl/diagnose.h>
  51 #include <cppuhelper/implbase1.hxx>
  52
  53 #ifndef INCLUDED_ALGORITHM
  54 #include <algorithm>
  55 #define INCLUDED_ALGORITHM
  56 #endif
  57
  58 namespace configmgr
  59 {
  60     namespace configapi
  61     {
  62 //-----------------------------------------------------------------------------------
  63         namespace lang = css::lang;
  64         namespace beans = css::beans;
  65
  66 //-----------------------------------------------------------------------------------
  67 // a helper class
  68 //-----------------------------------------------------------------------------------
  69
  70 class CollectProperties : configuration::NodeVisitor
  71 {
  72     std::vector< beans::Property >              m_aProperties;
  73     sal_Bool                                    m_bReadonly;
  74 public:
  75     CollectProperties(sal_Bool _bReadonly)
  76     : m_bReadonly(_bReadonly)
  77     { }
  78     CollectProperties(sal_Bool _bReadonly, sal_Int32 _nCount)
  79     : m_bReadonly(_bReadonly)
  80     { m_aProperties.reserve(_nCount); }
  81
  82     uno::Sequence<beans::Property> forChildren(rtl::Reference< configuration::Tree > const& _aPropertyTree, configuration::NodeRef const& _rNode)
  83     {
  84         OSL_ENSURE( _rNode.isValid() && _aPropertyTree->isValidNode(_rNode.getOffset()), "Node to retrieve properties from does not match tree");
  85         reset();
  86         _aPropertyTree->dispatchToChildren(_rNode, *this);
  87         return makeSequence(m_aProperties);
  88     }
  89
  90 private:
  91     void        reset() { m_aProperties.clear(); }
  92
  93     node::Attributes    adjustAttributes(node::Attributes nNodeAttr);
  94
  95     Result      handle(rtl::Reference< configuration::Tree > const& _aTree, configuration::NodeRef const& _rValue);
  96     Result      handle(rtl::Reference< configuration::Tree > const& _aTree, configuration::ValueRef const& _rValue);
  97 };
  98
  99 //-----------------------------------------------------------------------------------
 100 node::Attributes CollectProperties::adjustAttributes(node::Attributes nNodeAttr)
 101 {
 102     if (m_bReadonly) nNodeAttr.markReadonly();
 103
 104     return nNodeAttr;
 105 }
 106
 107 //-----------------------------------------------------------------------------------
 108 CollectProperties::Result CollectProperties::handle(rtl::Reference< configuration::Tree > const& _aTree, configuration::ValueRef const& _rValue)
 109 {
 110     // can be default ?
 111     m_aProperties.push_back(
 112                 helperMakeProperty(     _rValue.m_sNodeName,
 113                                     adjustAttributes(_aTree->getAttributes(_rValue)),
 114                                     _aTree->getUnoType(_rValue),
 115                                     _aTree->hasNodeDefault(_rValue)
 116                                 )
 117             );
 118
 119     return CONTINUE;
 120 }
 121
 122 //-----------------------------------------------------------------------------------
 123 CollectProperties::Result CollectProperties::handle(rtl::Reference< configuration::Tree > const& _aTree, configuration::NodeRef const& _rNode)
 124 {
 125     // can be default ?
 126     OSL_ENSURE( configuration::isStructuralNode(_aTree,_rNode),
 127                 "Unexpected value element node. Cannot get proper type for this node as property" );
 128
 129     m_aProperties.push_back(
 130         helperMakeProperty(     _aTree->getSimpleNodeName(_rNode.getOffset()),
 131                                     adjustAttributes(_aTree->getAttributes(_rNode)),
 132                                     getUnoInterfaceType(),
 133                                     _aTree->hasNodeDefault(_rNode)
 134                                 )
 135             );
 136
 137     return CONTINUE;
 138 }
 139
 140 //-----------------------------------------------------------------------------------
 141 // yet another helper class (more robust, but can't well be extended to be a HierarchicalPropertySetInfo though)
 142 //-----------------------------------------------------------------------------------
 143
 144 class NodePropertySetInfo
 145     :public ::cppu::WeakImplHelper1< beans::XPropertySetInfo >
 146 {
 147     uno::Sequence< beans::Property > const m_aProperties;
 148
 149 public:
 150     NodePropertySetInfo(uno::Sequence< beans::Property > const& _aProperties) throw(uno::RuntimeException)
 151     : m_aProperties(_aProperties)
 152     {
 153     }
 154
 155     static NodePropertySetInfo* create(NodeGroupInfoAccess& _rNode, sal_Bool _bReadonly ) throw(uno::RuntimeException);
 156     beans::Property const* begin() const throw() { return m_aProperties.getConstArray(); }
 157     beans::Property const* end()   const throw() { return m_aProperties.getConstArray() + m_aProperties.getLength(); }
 158
 159     beans::Property const* find(const rtl::OUString& _rPropertyName) const throw(uno::RuntimeException);
 160
 161     // XPropertySetInfo
 162     virtual uno::Sequence< beans::Property > SAL_CALL getProperties() throw(uno::RuntimeException);
 163     virtual beans::Property SAL_CALL    getPropertyByName(const rtl::OUString& _rPropertyName) throw(beans::UnknownPropertyException, uno::RuntimeException);
 164     virtual sal_Bool SAL_CALL   hasPropertyByName(const rtl::OUString& _rPropertyName) throw(uno::RuntimeException);
 165 };
 166
 167 //-----------------------------------------------------------------------------------
 168 //-----------------------------------------------------------------------------------
 169 NodePropertySetInfo* NodePropertySetInfo::create(NodeGroupInfoAccess& _rNode, sal_Bool _bReadonly ) throw(uno::RuntimeException)
 170 {
 171     UnoApiLock aLock;
 172
 173     rtl::Reference< configuration::Tree > aTree( _rNode.getTree() );
 174     OSL_ENSURE( !configuration::isEmpty(aTree.get()), "WARNING: Getting Tree information requires a valid tree");
 175     if (configuration::isEmpty(aTree.get())) return NULL;
 176
 177     configuration::NodeRef aNode( _rNode.getNodeRef() );
 178     OSL_ENSURE( aNode.isValid() && aTree->isValidNode(aNode.getOffset()), "ERROR: Tree does not match node");
 179
 180     uno::Sequence< beans::Property > aProperties = CollectProperties(_bReadonly).forChildren(aTree,aNode);
 181     OSL_ENSURE( aProperties.getLength() > 0, "ERROR: PropertySet (Configuration group) has no Properties");
 182
 183     return new NodePropertySetInfo( aProperties );
 184 }
 185
 186 //-----------------------------------------------------------------------------------
 187 struct MatchName // : std::unary_function< beans::Property, bool >
 188 {
 189     rtl::OUString sName;
 190     MatchName(rtl::OUString const& _sName)  throw(uno::RuntimeException)
 191     : sName(_sName)
 192     {
 193     }
 194
 195     bool operator()(beans::Property const& _aProperty) const
 196     {
 197         return !!(_aProperty.Name == this->sName);
 198     }
 199 };
 200
 201 beans::Property const* NodePropertySetInfo::find(const rtl::OUString& _rPropertyName)  const throw(uno::RuntimeException)
 202 {
 203     beans::Property const* const first = this->begin();
 204     beans::Property const* const last  = this->end();
 205
 206     return std::find_if(first,last,MatchName(_rPropertyName));
 207 }
 208
 209 //-----------------------------------------------------------------------------------
 210 uno::Sequence< beans::Property > SAL_CALL NodePropertySetInfo::getProperties() throw(uno::RuntimeException)
 211 {
 212     return m_aProperties;
 213 }
 214 //-----------------------------------------------------------------------------------
 215 beans::Property SAL_CALL NodePropertySetInfo::getPropertyByName(const rtl::OUString& _rPropertyName)
 216     throw(beans::UnknownPropertyException, uno::RuntimeException)
 217 {
 218     UnoApiLock aLock;
 219
 220     beans::Property const* pFound = find(_rPropertyName);
 221
 222     if (pFound == this->end())
 223     {
 224         rtl::OUString sMessage = rtl::OUString::createFromAscii("Configuration - ");
 225         sMessage += rtl::OUString::createFromAscii("No Property named '");
 226         sMessage += _rPropertyName;
 227         sMessage += rtl::OUString::createFromAscii("' in this PropertySetInfo");
 228         throw beans::UnknownPropertyException(sMessage, static_cast<XPropertySetInfo*>(this));
 229     }
 230
 231     return *pFound;
 232 }
 233
 234 //-----------------------------------------------------------------------------------
 235 sal_Bool SAL_CALL NodePropertySetInfo::hasPropertyByName(const rtl::OUString& _rPropertyName)
 236     throw(uno::RuntimeException)
 237 {
 238     UnoApiLock aLock;
 239
 240     beans::Property const* pFound = find(_rPropertyName);
 241
 242     return (pFound != this->end());
 243 }
 244
 245 // Interface methods
 246 //-----------------------------------------------------------------------------------
 247
 248 //-----------------------------------------------------------------------------------
 249 // getting Property Metadata
 250 //-----------------------------------------------------------------------------------
 251
 252 // XPropertySet & XMultiPropertySet
 253 //-----------------------------------------------------------------------------------
 254 uno::Reference< beans::XPropertySetInfo > implGetPropertySetInfo( NodeGroupInfoAccess& rNode, sal_Bool _bWriteable )
 255     throw(uno::RuntimeException)
 256 {
 257     GuardedNodeData<NodeAccess> lock( rNode );
 258     return NodePropertySetInfo::create(rNode, !_bWriteable);
 259 }
 260
 261 // XHierarchicalPropertySet & XHierarchicalMultiPropertySet
 262 //-----------------------------------------------------------------------------------
 263 uno::Reference< beans::XHierarchicalPropertySetInfo > implGetHierarchicalPropertySetInfo( NodeGroupInfoAccess& /*rNode*/ )
 264     throw(uno::RuntimeException)
 265 {
 266     // TODO: Implement
 267     return 0;
 268 }
 269
 270 //-----------------------------------------------------------------------------------
 271 // setting values - may all throw (PropertyVeto)Exceptions on read-only property sets
 272 //-----------------------------------------------------------------------------------
 273
 274 // XPropertySet
 275 //-----------------------------------------------------------------------------------
 276 void implSetPropertyValue( NodeGroupAccess& rNode, const rtl::OUString& sPropertyName, const uno::Any& aValue )
 277     throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException,
 278               lang::WrappedTargetException, uno::RuntimeException)
 279 {
 280     try
 281     {
 282         GuardedNodeUpdate<NodeGroupAccess> lock( rNode );
 283
 284         rtl::Reference< configuration::Tree > const aTree( lock.getTree() );
 285         configuration::NodeRef const aNode( lock.getNode() );
 286
 287         rtl::OUString aChildName = configuration::validateChildName(sPropertyName,aTree,aNode);
 288
 289         configuration::ValueRef aChild( aTree->getChildValue(aNode, aChildName) );
 290
 291         if (!aChild.isValid())
 292         {
 293             if ( configuration::hasChildOrElement(aTree, aNode, aChildName) )
 294             {
 295                 OSL_ENSURE(aTree->hasChildNode(aNode, aChildName),"ERROR: Configuration: Existing Property not found by implementation");
 296
 297                 rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot set Property Value.") );
 298                 sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(" Property '") );
 299                 sMessage += sPropertyName;
 300                 sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' is not a simple value.") );
 301
 302                 uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 303                 throw beans::PropertyVetoException( sMessage, xContext );
 304             }
 305             else
 306             {
 307                 rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot set Property Value.") );
 308                 sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(" Property '") );
 309                 sMessage += sPropertyName;
 310                 sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' not found in ") );
 311                 sMessage += aTree->getAbsolutePath(aNode).toString();
 312
 313                 uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 314                 throw beans::UnknownPropertyException( sMessage, xContext );
 315             }
 316         }
 317
 318         configuration::NodeChange aChange = lock.getNodeUpdater().validateSetValue( aChild, aValue );
 319         if (aChange.test().isChange())
 320         {
 321             Broadcaster aSender(rNode.getNotifier().makeBroadcaster(aChange,true));
 322
 323             aSender.queryConstraints(aChange);
 324
 325             aTree->integrate(aChange, aNode, true);
 326
 327             lock.clearForBroadcast();
 328             aSender.notifyListeners(aChange);
 329         }
 330     }
 331     catch (configuration::InvalidName& ex)
 332     {
 333         ExceptionMapper e(ex);
 334         rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot set Property Value: ") );
 335         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 336         throw beans::UnknownPropertyException( sMessage += e.message(), xContext );
 337     }
 338     catch (configuration::TypeMismatch& ex)
 339     {
 340         ExceptionMapper e(ex);
 341         e.setContext( rNode.getUnoInstance() );
 342         e.illegalArgument(2);
 343     }
 344     catch (configuration::ConstraintViolation& ex)
 345     {
 346         ExceptionMapper e(ex);
 347         rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot set Property Value: ") );
 348         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 349         throw beans::PropertyVetoException( sMessage += e.message(), xContext );
 350     }
 351     catch (configuration::Exception& ex)
 352     {
 353         ExceptionMapper e(ex);
 354         e.setContext( rNode.getUnoInstance() );
 355         e.unhandled();
 356     }
 357 }
 358
 359 // XMultiPropertySet
 360 //-----------------------------------------------------------------------------------
 361 void implSetPropertyValues( NodeGroupAccess& rNode, const uno::Sequence< rtl::OUString >& aPropertyNames, const uno::Sequence< uno::Any >& aValues )
 362     throw(beans::PropertyVetoException, lang::IllegalArgumentException,
 363               lang::WrappedTargetException, uno::RuntimeException)
 364 {
 365     try
 366     {
 367         GuardedNodeUpdate<NodeGroupAccess> lock( rNode );
 368
 369         rtl::Reference< configuration::Tree > const aTree( lock.getTree() );
 370         configuration::NodeRef const aNode( lock.getNode() );
 371
 372         configuration::NodeChanges aChanges;
 373         for(sal_Int32 i = 0, count= aValues.getLength(); i < count; ++i)
 374         {
 375             rtl::OUString aChildName( aPropertyNames[i] ); // not validated
 376
 377             configuration::ValueRef aChild( aTree->getChildValue(aNode, aChildName) );
 378
 379             if (!aChild.isValid())
 380             {
 381                 if ( configuration::hasChildOrElement(aTree, aNode, aChildName) )
 382                 {
 383                     OSL_ENSURE(aTree->hasChildNode(aNode, aChildName),"ERROR: Configuration: Existing Property not found by implementation");
 384
 385                     rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot set Property Values.") );
 386                     sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(" Property '") );
 387                     sMessage += aChildName;
 388                     sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' is not a simple value.") );
 389
 390                     uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 391                     throw beans::PropertyVetoException( sMessage, xContext );
 392                 }
 393
 394                 OSL_TRACE("Configuration: MultiPropertySet: trying to set unknown property - ignored");
 395                 continue;
 396             }
 397
 398             configuration::NodeChange aChange = lock.getNodeUpdater().validateSetValue( aChild, aValues[i] );
 399             if (aChange.maybeChange())
 400             {
 401                 aChanges.add(aChange);
 402             }
 403         }
 404
 405         if (!aChanges.test().compact().isEmpty())
 406         {
 407             Broadcaster aSender(rNode.getNotifier().makeBroadcaster(aChanges,true));
 408
 409             aSender.queryConstraints(aChanges);
 410
 411             aTree->integrate(aChanges, aNode, true);
 412
 413             lock.clearForBroadcast();
 414             aSender.notifyListeners(aChanges, true);
 415         }
 416     }
 417     catch (configuration::TypeMismatch& ex)
 418     {
 419         ExceptionMapper e(ex);
 420         e.setContext( rNode.getUnoInstance() );
 421         e.illegalArgument(2);
 422     }
 423     catch (configuration::ConstraintViolation& ex)
 424     {
 425         ExceptionMapper e(ex);
 426         rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot set Property Value: ") );
 427         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 428         throw beans::PropertyVetoException( sMessage += e.message(), xContext );
 429     }
 430     catch (configuration::Exception& ex)
 431     {
 432         ExceptionMapper e(ex);
 433         e.setContext( rNode.getUnoInstance() );
 434         e.unhandled();
 435     }
 436 }
 437
 438 // XHierarchicalPropertySet
 439 //-----------------------------------------------------------------------------------
 440 void implSetHierarchicalPropertyValue( NodeGroupAccess& rNode, const rtl::OUString& aPropertyName, const uno::Any& aValue )
 441     throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException,
 442           lang::WrappedTargetException, uno::RuntimeException)
 443 {
 444     try
 445     {
 446         GuardedNodeUpdate<NodeGroupAccess> lock( rNode );
 447
 448         rtl::Reference< configuration::Tree > const aTree( lock.getTree() );
 449         configuration::NodeRef const aNode( lock.getNode() );
 450
 451         configuration::RelativePath const aRelPath = configuration::validateRelativePath( aPropertyName, aTree, aNode );
 452
 453         configuration::AnyNodeRef aNestedValue = configuration::getLocalDescendant( aTree, aNode, aRelPath );
 454
 455         if (!aNestedValue.isValid())
 456         {
 457             rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot set Property Value. Property '") );
 458             sMessage += aRelPath.toString();
 459             sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' was not found in ")  );
 460             sMessage += aTree->getAbsolutePath(aNode).toString();
 461
 462             uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 463             throw beans::UnknownPropertyException( sMessage, xContext );
 464         }
 465         if (aNestedValue.isNode())
 466         {
 467             rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot set Property Value. Property '") );
 468             sMessage += aRelPath.toString();
 469             sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' is not a simple value property.")  );
 470
 471             uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 472             throw beans::PropertyVetoException( sMessage, xContext );
 473         }
 474         OSL_ASSERT(aNode.isValid());
 475
 476         configuration::NodeChange aChange = lock.getNodeUpdater().validateSetValue( aNestedValue.toValue(), aValue );
 477         if (aChange.test().isChange())
 478         {
 479             Broadcaster aSender(rNode.getNotifier().makeBroadcaster(aChange,false));
 480
 481             aSender.queryConstraints(aChange);
 482
 483             aTree->integrate(aChange, aNode, false);
 484
 485             lock.clearForBroadcast();
 486             aSender.notifyListeners(aChange);
 487         }
 488     }
 489     catch (configuration::InvalidName& ex)
 490     {
 491         ExceptionMapper e(ex);
 492         rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot set Property Value: ") );
 493         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 494         throw beans::UnknownPropertyException( e.message(), xContext );
 495     }
 496     catch (configuration::TypeMismatch& ex)
 497     {
 498         ExceptionMapper e(ex);
 499         e.setContext( rNode.getUnoInstance() );
 500         e.illegalArgument(2);
 501     }
 502     catch (configuration::ConstraintViolation& ex)
 503     {
 504         ExceptionMapper e(ex);
 505         rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot set Property Value: ") );
 506         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 507         throw beans::PropertyVetoException( sMessage += e.message(), xContext );
 508     }
 509     catch (configuration::Exception& ex)
 510     {
 511         ExceptionMapper e(ex);
 512         e.setContext( rNode.getUnoInstance() );
 513         e.unhandled();
 514     }
 515 }
 516
 517 // XMultiHierarchicalPropertySet
 518 //-----------------------------------------------------------------------------------
 519 void implSetHierarchicalPropertyValues( NodeGroupAccess& rNode, const uno::Sequence< rtl::OUString >& aPropertyNames, const uno::Sequence< uno::Any >& aValues )
 520     throw(beans::PropertyVetoException, lang::IllegalArgumentException,
 521           lang::WrappedTargetException, uno::RuntimeException)
 522 {
 523     try
 524     {
 525         GuardedNodeUpdate<NodeGroupAccess> lock( rNode );
 526
 527         rtl::Reference< configuration::Tree > const aTree( lock.getTree() );
 528         configuration::NodeRef const aNode( lock.getNode() );
 529
 530         configuration::NodeChanges aChanges;
 531         for(sal_Int32 i = 0, count= aValues.getLength(); i < count; ++i)
 532         try
 533         {
 534             configuration::RelativePath aRelPath = configuration::validateRelativePath( aPropertyNames[i], aTree, aNode );
 535
 536             configuration::AnyNodeRef aNestedValue = configuration::getLocalDescendant( aTree, aNode, aRelPath );
 537
 538             if (!aNestedValue.isValid())
 539             {
 540                 OSL_TRACE("Configuration: MultiPropertySet: trying to set unknown property - ignored");
 541                 continue;
 542             }
 543             if ( aNestedValue.isNode() )
 544             {
 545                 rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot set Property Values.") );
 546                 sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(" Property '") );
 547                 sMessage += aRelPath.toString();
 548                 sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' is not a simple value property.") );
 549
 550                 uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 551                 throw beans::PropertyVetoException( sMessage, xContext );
 552             }
 553             OSL_ASSERT(aNode.isValid());
 554
 555             configuration::NodeChange aChange = lock.getNodeUpdater().validateSetValue( aNestedValue.toValue(), aValues[i] );
 556             if (aChange.maybeChange())
 557             {
 558                 aChanges.add(aChange);
 559             }
 560         }
 561         catch (configuration::InvalidName& )
 562         {
 563             OSL_TRACE("Configuration: MultiHierarchicalPropertySet: trying to set property <invalid path> - ignored");
 564             continue;
 565         }
 566
 567         if (!aChanges.test().compact().isEmpty())
 568         {
 569             Broadcaster aSender(rNode.getNotifier().makeBroadcaster(aChanges,false));
 570
 571             aSender.queryConstraints(aChanges);
 572
 573             aTree->integrate(aChanges, aNode, false);
 574
 575             lock.clearForBroadcast();
 576             aSender.notifyListeners(aChanges, true); // if we use 'false' we don't need 'Deep' change objects
 577         }
 578     }
 579     catch (configuration::TypeMismatch& ex)
 580     {
 581         ExceptionMapper e(ex);
 582         e.setContext( rNode.getUnoInstance() );
 583         e.illegalArgument(2);
 584     }
 585     catch (configuration::ConstraintViolation& ex)
 586     {
 587         ExceptionMapper e(ex);
 588         rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot set Property Value: ") );
 589         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 590         throw beans::PropertyVetoException( sMessage += e.message(), xContext );
 591     }
 592     catch (configuration::Exception& ex)
 593     {
 594         ExceptionMapper e(ex);
 595         e.setContext( rNode.getUnoInstance() );
 596         e.unhandled();
 597     }
 598 }
 599
 600 //-----------------------------------------------------------------------------------
 601 // getting values
 602 //-----------------------------------------------------------------------------------
 603
 604 // XPropertySet
 605 //-----------------------------------------------------------------------------------
 606 uno::Any implGetPropertyValue( NodeGroupInfoAccess& rNode,const rtl::OUString& aPropertyName )
 607     throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 608 {
 609     try
 610     {
 611         GuardedNodeData<NodeAccess> lock( rNode );
 612
 613         rtl::Reference< configuration::Tree > const aTree( lock.getTree() );
 614         configuration::NodeRef const aNode( lock.getNode() );
 615
 616         rtl::OUString aChildName = configuration::validateChildName(aPropertyName,aTree,aNode);
 617
 618         configuration::AnyNodeRef aChild( aTree->getAnyChild(aNode, aChildName) );
 619
 620         if (!aChild.isValid())
 621         {
 622             OSL_ENSURE(!configuration::hasChildOrElement(aTree,aNode,aChildName),"ERROR: Configuration: Existing Property not found by implementation");
 623
 624             rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot get Property Value. Property '") );
 625             sMessage += aPropertyName;
 626             sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' could not be found in ")  );
 627             sMessage += aTree->getAbsolutePath(aNode).toString();
 628
 629             uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 630             throw beans::UnknownPropertyException( sMessage, xContext );
 631         }
 632
 633         return configapi::makeElement( rNode.getFactory(), aTree, aChild );
 634     }
 635     catch (configuration::InvalidName& ex)
 636     {
 637         ExceptionMapper e(ex);
 638         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 639         throw beans::UnknownPropertyException( e.message(), xContext );
 640     }
 641     catch (configuration::Exception& ex)
 642     {
 643         ExceptionMapper e(ex);
 644         e.setContext( rNode.getUnoInstance() );
 645         e.unhandled();
 646     }
 647
 648     // unreachable, but still there to make some compilers happy
 649     OSL_ASSERT(!"Unreachable code");
 650     return uno::Any();
 651 }
 652
 653 // XMultiPropertySet
 654 //-----------------------------------------------------------------------------------
 655 uno::Sequence< uno::Any > implGetPropertyValues( NodeGroupInfoAccess& rNode, const uno::Sequence< rtl::OUString >& aPropertyNames )
 656     throw(uno::RuntimeException)
 657 {
 658     sal_Int32 const count = aPropertyNames.getLength();
 659     uno::Sequence<uno::Any> aRet(count);
 660
 661     try
 662     {
 663         GuardedNodeData<NodeAccess> lock( rNode );
 664
 665         rtl::Reference< configuration::Tree > const aTree( lock.getTree() );
 666         configuration::NodeRef const aNode( lock.getNode() );
 667
 668         for(sal_Int32 i = 0; i < count; ++i)
 669         {
 670             rtl::OUString aChildName( aPropertyNames[i] ); // not validated
 671
 672             configuration::AnyNodeRef aChild( aTree->getAnyChild(aNode, aChildName) );
 673
 674             if (aChild.isValid())
 675             {
 676                 aRet[i] = configapi::makeElement( rNode.getFactory(), aTree, aChild );
 677             }
 678             else
 679             {
 680                 OSL_ENSURE(!configuration::hasChildOrElement(aTree,aNode,aChildName),"ERROR: Configuration: Existing Property not found by implementation");
 681                 OSL_TRACE("Configuration: MultiPropertySet: trying to get unknown property - returning void");
 682             }
 683         }
 684     }
 685     catch (configuration::Exception& ex)
 686     {
 687         ExceptionMapper e(ex);
 688         e.setContext( rNode.getUnoInstance() );
 689         e.unhandled();
 690     }
 691
 692     return aRet;
 693 }
 694
 695 // XHierarchicalPropertySet
 696 //-----------------------------------------------------------------------------------
 697 uno::Any implGetHierarchicalPropertyValue( NodeGroupInfoAccess& rNode, const rtl::OUString& aPropertyName )
 698     throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 699 {
 700     try
 701     {
 702         GuardedNodeData<NodeAccess> lock( rNode );
 703
 704         rtl::Reference< configuration::Tree > const aTree( lock.getTree() );
 705         configuration::NodeRef const aNode( lock.getNode() );
 706
 707         configuration::RelativePath aRelPath = configuration::validateRelativePath( aPropertyName, aTree, aNode );
 708
 709         configuration::AnyNodeRef aNestedNode = configuration::getLocalDescendant( aTree, aNode, aRelPath );
 710
 711         if (!aNestedNode.isValid())
 712         {
 713             rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot get Property Value. Property '") );
 714             sMessage += aRelPath.toString();
 715             sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' could not be found in ")  );
 716             sMessage += aTree->getAbsolutePath(aNode).toString();
 717
 718             uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 719             throw beans::UnknownPropertyException( sMessage, xContext );
 720         }
 721         OSL_ASSERT(aNode.isValid());
 722
 723         return configapi::makeElement( rNode.getFactory(), aTree, aNestedNode );
 724     }
 725     catch (configuration::InvalidName& ex)
 726     {
 727         ExceptionMapper e(ex);
 728         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 729         throw beans::UnknownPropertyException( e.message(), xContext );
 730     }
 731     catch (configuration::Exception& ex)
 732     {
 733         ExceptionMapper e(ex);
 734         e.setContext( rNode.getUnoInstance() );
 735         e.unhandled();
 736     }
 737
 738     // unreachable, but still there to make some compilers happy
 739     OSL_ASSERT(!"Unreachable code");
 740     return uno::Any();
 741 }
 742
 743 // XMultiHierarchicalPropertySet
 744 //-----------------------------------------------------------------------------------
 745 uno::Sequence< uno::Any > implGetHierarchicalPropertyValues( NodeGroupInfoAccess& rNode, const uno::Sequence< rtl::OUString >& aPropertyNames )
 746     throw(uno::RuntimeException)
 747 {
 748     sal_Int32 const count = aPropertyNames.getLength();
 749     uno::Sequence<uno::Any> aRet(count);
 750
 751     try
 752     {
 753         GuardedNodeData<NodeAccess> lock( rNode );
 754
 755         rtl::Reference< configuration::Tree > const aTree( lock.getTree() );
 756         configuration::NodeRef const aNode( lock.getNode() );
 757
 758         for(sal_Int32 i = 0; i < count; ++i)
 759         try
 760         {
 761             configuration::RelativePath aRelPath = configuration::validateRelativePath( aPropertyNames[i], aTree, aNode );
 762
 763             configuration::AnyNodeRef aNestedValue = configuration::getLocalDescendant( aTree, aNode, aRelPath );
 764
 765             if (aNestedValue.isValid())
 766             {
 767                 aRet[i] = configapi::makeElement( rNode.getFactory(), aTree, aNestedValue );
 768             }
 769             else
 770             {
 771                 OSL_TRACE("Configuration: MultiPropertySet: trying to get unknown property - returning void");
 772             }
 773         }
 774         catch (configuration::InvalidName& )
 775         {
 776             OSL_TRACE("Configuration: MultiPropertySet: trying to get property from unknown path - returning void");
 777             OSL_ASSERT(!aRet[i].hasValue());
 778         }
 779     }
 780     catch (configuration::Exception& ex)
 781     {
 782         ExceptionMapper e(ex);
 783         e.setContext( rNode.getUnoInstance() );
 784         e.unhandled();
 785     }
 786
 787     return aRet;
 788 }
 789
 790 //------------------------------------------------------------------------------------------------------------------
 791 // SPECIAL: XMultiPropertySet::firePropertiesChangeEvent
 792 //------------------------------------------------------------------------------------------------------------------
 793
 794 void implFirePropertiesChangeEvent( NodeGroupInfoAccess& rNode, const uno::Sequence< rtl::OUString >& aPropertyNames, const uno::Reference< beans::XPropertiesChangeListener >& xListener )
 795     throw(uno::RuntimeException)
 796 {
 797     OSL_ENSURE(xListener.is(), "ERROR: requesting to fire Events to a NULL listener.");
 798     if (!xListener.is())
 799     {
 800         return; // should this be an exception ??
 801     }
 802
 803     sal_Int32 const count = aPropertyNames.getLength();
 804     uno::Sequence<beans::PropertyChangeEvent> aEvents(count);
 805
 806     try
 807     {
 808         GuardedNodeData<NodeAccess> lock( rNode );
 809
 810         rtl::Reference< configuration::Tree > const aTree( lock.getTree() );
 811         configuration::NodeRef const aNode( lock.getNode() );
 812         configapi::Factory& rFactory = rNode.getFactory();
 813
 814         sal_Int32 nFire = 0;
 815
 816         for(sal_Int32 i = 0; i < count; ++i)
 817         {
 818             rtl::OUString aChildName( aPropertyNames[i] ); // not validated
 819
 820             configuration::AnyNodeRef aChild( aTree->getAnyChild(aNode, aChildName) );
 821
 822             if (aChild.isValid())
 823             {
 824                 aEvents[nFire].Source = rNode.getUnoInstance();
 825                 aEvents[nFire].PropertyName = aChildName;
 826                 aEvents[nFire].PropertyHandle = -1;
 827
 828                 aEvents[nFire].NewValue = aEvents[nFire].OldValue = configapi::makeElement( rFactory, aTree, aChild );
 829                 nFire++;
 830             }
 831             else
 832             {
 833                 OSL_ENSURE(!configuration::hasChildOrElement(aTree,aNode,aChildName),"ERROR: Configuration: Existing Property not found by implementation");
 834                 OSL_TRACE("Configuration: MultiPropertySet: request to fire unknown property - skipping");
 835             }
 836         }
 837
 838         if (nFire < count) aEvents.realloc(nFire);;
 839     }
 840     catch (configuration::Exception& ex)
 841     {
 842         ExceptionMapper e(ex);
 843         e.setContext( rNode.getUnoInstance() );
 844         e.unhandled();
 845     }
 846
 847     xListener->propertiesChange(aEvents);
 848 }
 849
 850 //------------------------------------------------------------------------------------------------------------------
 851 // XPropertyState
 852 //------------------------------------------------------------------------------------------------------------------
 853
 854 beans::PropertyState implGetPropertyState( NodeAccess& rNode, const rtl::OUString& sPropertyName )
 855     throw(beans::UnknownPropertyException, uno::RuntimeException)
 856 {
 857     try
 858     {
 859         GuardedNodeData<NodeAccess> lock( rNode );
 860
 861         rtl::Reference< configuration::Tree > aTree( lock.getTree() );
 862         configuration::NodeRef const aNode( lock.getNode() );
 863
 864         rtl::OUString aChildName = configuration::validateChildOrElementName(sPropertyName,aTree,aNode);
 865
 866         configuration::AnyNodeRef aChild = configuration::getChildOrElement(aTree,aNode,aChildName);
 867         if (!aChild.isValid())
 868         {
 869             rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot get PropertyState. Property '") );
 870             sMessage += sPropertyName;
 871             sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' not found in ")  );
 872             sMessage += aTree->getAbsolutePath(aNode).toString();
 873
 874             uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 875             throw beans::UnknownPropertyException( sMessage, xContext );
 876         }
 877         OSL_ASSERT(aNode.isValid());
 878
 879         return aTree->isNodeDefault(aChild)  ? beans::PropertyState_DEFAULT_VALUE :
 880                aChild.isNode()              ? beans::PropertyState_AMBIGUOUS_VALUE :
 881                                               beans::PropertyState_DIRECT_VALUE;
 882     }
 883     catch (configuration::InvalidName& ex)
 884     {
 885         ExceptionMapper e(ex);
 886         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 887         throw beans::UnknownPropertyException( e.message(), xContext );
 888     }
 889     catch (configuration::Exception& ex)
 890     {
 891         ExceptionMapper e(ex);
 892         e.setContext( rNode.getUnoInstance() );
 893         e.unhandled();
 894     }
 895
 896     // unreachable, but still there to make some compilers happy
 897     OSL_ASSERT(!"Unreachable code");
 898     return beans::PropertyState_AMBIGUOUS_VALUE;
 899 }
 900
 901 //-----------------------------------------------------------------------------------
 902 uno::Sequence< beans::PropertyState > implGetPropertyStates( NodeAccess& rNode, const uno::Sequence< rtl::OUString >& aPropertyNames )
 903     throw(beans::UnknownPropertyException, uno::RuntimeException)
 904 {
 905     sal_Int32 const count = aPropertyNames.getLength();
 906     uno::Sequence<beans::PropertyState> aRet(count);
 907
 908     try
 909     {
 910         GuardedNodeData<NodeAccess> lock( rNode );
 911
 912         rtl::Reference< configuration::Tree > const aTree( lock.getTree() );
 913         configuration::NodeRef const aNode( lock.getNode() );
 914
 915         for(sal_Int32 i = 0; i < count; ++i)
 916         {
 917             rtl::OUString aChildName = configuration::validateChildOrElementName(aPropertyNames[i],aTree,aNode);
 918
 919             rtl::Reference< configuration::Tree > aChildTree( aTree);
 920
 921             configuration::AnyNodeRef aChildNode = configuration::getChildOrElement(aChildTree,aNode,aChildName);
 922             if (!aChildNode.isValid())
 923             {
 924                 rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot get PropertyStates. Property '") );
 925                 sMessage += aPropertyNames[i];
 926                 sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' could not be found in ")  );
 927                 sMessage += aTree->getAbsolutePath(aNode).toString();
 928
 929                 uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 930                 throw beans::UnknownPropertyException( sMessage, xContext );
 931             }
 932             OSL_ASSERT(aChildNode.isValid());
 933
 934             aRet[i] = aChildTree->isNodeDefault(aChildNode)  ? beans::PropertyState_DEFAULT_VALUE :
 935                       aChildNode.isNode()                   ? beans::PropertyState_AMBIGUOUS_VALUE :
 936                                                               beans::PropertyState_DIRECT_VALUE;
 937         }
 938
 939     }
 940     catch (configuration::InvalidName& ex)
 941     {
 942         ExceptionMapper e(ex);
 943         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 944         throw beans::UnknownPropertyException( e.message(), xContext );
 945     }
 946     catch (configuration::Exception& ex)
 947     {
 948         ExceptionMapper e(ex);
 949         e.setContext( rNode.getUnoInstance() );
 950         e.unhandled();
 951     }
 952
 953     return aRet;
 954 }
 955
 956 //-----------------------------------------------------------------------------------
 957 static inline configuration::NodeChange validateSetToDefaultHelper(configuration::GroupDefaulter& _rDefaulter, configuration::AnyNodeRef _aNode)
 958 {
 959     if (!_aNode.isNode())
 960         return _rDefaulter.validateSetToDefaultValue( _aNode.toValue() );
 961
 962     else
 963         return _rDefaulter.validateSetToDefaultState( _aNode.toNode() );
 964 }
 965 //-----------------------------------------------------------------------------------
 966 void implSetPropertyToDefault( NodeGroupAccess& rNode, const rtl::OUString& sPropertyName )
 967     throw(beans::UnknownPropertyException, uno::RuntimeException)
 968 {
 969     try
 970     {
 971         UnoApiLock aWithDefaultLock;
 972         GuardedNodeUpdate<NodeGroupAccess> lock( withDefaultData( rNode ) );
 973
 974         rtl::Reference< configuration::Tree > const aTree( lock.getTree() );
 975         configuration::NodeRef const aNode( lock.getNode() );
 976
 977         configuration::GroupDefaulter aDefaulter = lock.getNodeDefaulter();
 978
 979         rtl::OUString aChildName = configuration::validateChildName(sPropertyName,aTree,aNode);
 980
 981         configuration::AnyNodeRef aChild( aTree->getAnyChild(aNode, aChildName) );
 982
 983         configuration::NodeChange aChange = validateSetToDefaultHelper( aDefaulter, aChild );
 984
 985         const bool bLocal = !aDefaulter.hasDoneSet();
 986
 987         if (aChange.test().isChange() )
 988         {
 989             Broadcaster aSender(rNode.getNotifier().makeBroadcaster(aChange,bLocal));
 990
 991             aSender.queryConstraints(aChange);
 992
 993             aTree->integrate(aChange, aNode, bLocal);
 994
 995             lock.clearForBroadcast();
 996             aSender.notifyListeners(aChange);
 997         }
 998     }
 999     catch (configuration::InvalidName& ex)
1000     {
1001         ExceptionMapper e(ex);
1002         rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot restore Default: ") );
1003         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
1004         throw beans::UnknownPropertyException( sMessage += e.message(), xContext );
1005     }
1006     catch (configuration::ConstraintViolation & ex)
1007     {
1008         ExceptionMapper e(ex);
1009         rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot restore Default: ") );
1010         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
1011         throw beans::UnknownPropertyException( sMessage += e.message(), xContext );
1012     }
1013     catch (configuration::Exception& ex)
1014     {
1015         ExceptionMapper e(ex);
1016         e.setContext( rNode.getUnoInstance() );
1017         e.unhandled();
1018     }
1019 }
1020 //-----------------------------------------------------------------------------------
1021 void implSetPropertiesToDefault( NodeGroupAccess& rNode, const uno::Sequence< rtl::OUString >& aPropertyNames )
1022     throw(beans::UnknownPropertyException, uno::RuntimeException)
1023 {
1024     try
1025     {
1026         UnoApiLock aWithDefaultLock;
1027         GuardedNodeUpdate<NodeGroupAccess> lock( withDefaultData( rNode ) );
1028
1029         rtl::Reference< configuration::Tree > const aTree( lock.getTree() );
1030         configuration::NodeRef const aNode( lock.getNode() );
1031
1032         configuration::GroupDefaulter aDefaulter = lock.getNodeDefaulter();
1033
1034         configuration::NodeChanges aChanges;
1035         for(sal_Int32 i = 0, count= aPropertyNames.getLength(); i < count; ++i)
1036         {
1037             rtl::OUString aChildName = configuration::validateChildName( aPropertyNames[i], aTree, aNode ); // validated
1038
1039             configuration::AnyNodeRef aChild( aTree->getAnyChild(aNode, aChildName) );
1040
1041             if (!aChild.isValid())
1042             {
1043                 OSL_ENSURE(!configuration::hasChildOrElement(aTree, aNode, aChildName),"ERROR: Configuration: Existing Property not found by implementation");
1044
1045                 rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot restore Default.") );
1046                 sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(" Property '") );
1047                 sMessage += aChildName;
1048                 sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' not found in ") );
1049                 sMessage += aTree->getAbsolutePath(aNode).toString();
1050
1051                 uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
1052                 throw beans::UnknownPropertyException( sMessage, xContext );
1053             }
1054             OSL_ASSERT(aNode.isValid());
1055
1056             if (!aTree->hasNodeDefault(aChild))
1057             {
1058                 rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot restore Default.") );
1059                 sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(" Property '") );
1060                 sMessage += aChildName;
1061
1062                 if (aChild.isNode())
1063                     sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' is not a simple value.") );
1064
1065                 else
1066                     sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' does not have a default value.") );
1067
1068                 uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
1069                 throw beans::UnknownPropertyException( sMessage, xContext );
1070             }
1071
1072             configuration::NodeChange aChildChange = validateSetToDefaultHelper(aDefaulter, aChild );
1073             if (aChildChange.maybeChange())
1074                 aChanges.add(aChildChange);
1075         }
1076
1077         const bool bLocal = !aDefaulter.hasDoneSet();
1078
1079         if (!aChanges.test().compact().isEmpty())
1080         {
1081             Broadcaster aSender(rNode.getNotifier().makeBroadcaster(aChanges,bLocal));
1082
1083             aSender.queryConstraints(aChanges);
1084
1085             aTree->integrate(aChanges, aNode, bLocal);
1086
1087             lock.clearForBroadcast();
1088             aSender.notifyListeners(aChanges, bLocal);
1089         }
1090
1091     }
1092     catch (configuration::InvalidName& ex)
1093     {
1094         ExceptionMapper e(ex);
1095         rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot restore Defaults: ") );
1096         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
1097         throw beans::UnknownPropertyException( sMessage += e.message(), xContext );
1098     }
1099     catch (configuration::ConstraintViolation & ex)
1100     {
1101         ExceptionMapper e(ex);
1102         rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot restore Defaults: ") );
1103         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
1104         throw beans::UnknownPropertyException( sMessage += e.message(), xContext );
1105     }
1106     catch (configuration::Exception& ex)
1107     {
1108         ExceptionMapper e(ex);
1109         e.setContext( rNode.getUnoInstance() );
1110         e.unhandled();
1111     }
1112 }
1113
1114 //-----------------------------------------------------------------------------------
1115 void implSetAllPropertiesToDefault( NodeGroupAccess& rNode )
1116     throw(uno::RuntimeException)
1117 {
1118     try
1119     {
1120         UnoApiLock aWithDefaultLock;
1121         GuardedNodeUpdate<NodeGroupAccess> lock( withDefaultData( rNode ) );
1122
1123         rtl::Reference< configuration::Tree > const aTree( lock.getTree() );
1124         configuration::NodeRef const aNode( lock.getNode() );
1125
1126         configuration::GroupDefaulter aDefaulter = lock.getNodeDefaulter();
1127
1128         configuration::NodeChanges aChanges = aDefaulter.validateSetAllToDefault( );
1129
1130         const bool bLocal = !aDefaulter.hasDoneSet();
1131
1132         if (!aChanges.test().compact().isEmpty())
1133         {
1134             Broadcaster aSender(rNode.getNotifier().makeBroadcaster(aChanges,bLocal));
1135
1136             aSender.queryConstraints(aChanges);
1137
1138             aTree->integrate(aChanges, aNode, bLocal);
1139
1140             lock.clearForBroadcast();
1141             aSender.notifyListeners(aChanges, bLocal);
1142         }
1143
1144     }
1145     catch (configuration::InvalidName& ex)
1146     {
1147         ExceptionMapper e(ex);
1148         rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot restore Defaults: ") );
1149         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
1150         throw beans::UnknownPropertyException( sMessage += e.message(), xContext );
1151     }
1152     catch (configuration::ConstraintViolation & ex)
1153     {
1154         ExceptionMapper e(ex);
1155         rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot restore Defaults: ") );
1156         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
1157         throw beans::UnknownPropertyException( sMessage += e.message(), xContext );
1158     }
1159     catch (configuration::Exception& ex)
1160     {
1161         ExceptionMapper e(ex);
1162         e.setContext( rNode.getUnoInstance() );
1163         e.unhandled();
1164     }
1165 }
1166
1167 //-----------------------------------------------------------------------------------
1168 uno::Any implGetPropertyDefault( NodeGroupInfoAccess& rNode, const rtl::OUString& sPropertyName )
1169     throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1170 {
1171     uno::Any aDefault;
1172     try
1173     {
1174         GuardedNodeData<NodeAccess> lock( rNode );
1175
1176         rtl::Reference< configuration::Tree > const aTree( lock.getTree() );
1177         configuration::NodeRef const aNode( lock.getNode() );
1178
1179         rtl::OUString aChildName = configuration::validateChildName(sPropertyName,aTree,aNode);
1180
1181         configuration::AnyNodeRef aChildNode = aTree->getAnyChild(aNode, aChildName);
1182         if (!aChildNode.isValid())
1183         {
1184             rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot get Default. Property '") );
1185             sMessage += sPropertyName;
1186             sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' not found in ")  );
1187             sMessage += aTree->getAbsolutePath(aNode).toString();
1188
1189             uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
1190             throw beans::UnknownPropertyException( sMessage, xContext );
1191         }
1192         OSL_ASSERT(aNode.isValid());
1193
1194         if (!aChildNode.isNode())
1195         {
1196             aDefault = aTree->getNodeDefaultValue(aChildNode.toValue());
1197         }
1198     }
1199     catch (configuration::InvalidName& ex)
1200     {
1201         ExceptionMapper e(ex);
1202         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
1203         throw beans::UnknownPropertyException( e.message(), xContext );
1204     }
1205     catch (configuration::ConstraintViolation & ex)
1206     {
1207         ExceptionMapper e(ex);
1208         rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot get Default: ") );
1209         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
1210         throw beans::UnknownPropertyException( sMessage += e.message(), xContext );
1211     }
1212     catch (configuration::Exception& ex)
1213     {
1214         ExceptionMapper e(ex);
1215         e.setContext( rNode.getUnoInstance() );
1216         e.unhandled();
1217     }
1218
1219     return aDefault;
1220 }
1221
1222 //-----------------------------------------------------------------------------------
1223 uno::Sequence< uno::Any > implGetPropertyDefaults( NodeGroupInfoAccess& rNode, const uno::Sequence< rtl::OUString >& aPropertyNames )
1224     throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1225 {
1226     sal_Int32 const count = aPropertyNames.getLength();
1227     uno::Sequence<uno::Any> aDefaults(count);
1228
1229     try
1230     {
1231         GuardedNodeData<NodeAccess> lock( rNode );
1232
1233         rtl::Reference< configuration::Tree > const aTree( lock.getTree() );
1234         configuration::NodeRef const aNode( lock.getNode() );
1235
1236         for(sal_Int32 i = 0; i < count; ++i)
1237         {
1238             rtl::OUString aChildName = configuration::validateChildName(aPropertyNames[i],aTree,aNode);
1239
1240             configuration::AnyNodeRef aChildNode = aTree->getAnyChild(aNode, aChildName);
1241             if (!aChildNode.isValid())
1242             {
1243                 rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot get Default. Property '") );
1244                 sMessage += aPropertyNames[i];
1245                 sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' not found in ")  );
1246                 sMessage += aTree->getAbsolutePath(aNode).toString();
1247
1248                 uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
1249                 throw beans::UnknownPropertyException( sMessage, xContext );
1250             }
1251             OSL_ASSERT(aNode.isValid());
1252
1253             if (!aChildNode.isNode())
1254             {
1255                 aDefaults[i] = aTree->getNodeDefaultValue(aChildNode.toValue());
1256             }
1257         }
1258     }
1259     catch (configuration::InvalidName& ex)
1260     {
1261         ExceptionMapper e(ex);
1262         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
1263         throw beans::UnknownPropertyException( e.message(), xContext );
1264     }
1265     catch (configuration::ConstraintViolation & ex)
1266     {
1267         ExceptionMapper e(ex);
1268         rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot get Default: ") );
1269         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
1270         throw beans::UnknownPropertyException( sMessage += e.message(), xContext );
1271     }
1272     catch (configuration::Exception& ex)
1273     {
1274         ExceptionMapper e(ex);
1275         e.setContext( rNode.getUnoInstance() );
1276         e.unhandled();
1277     }
1278
1279     return aDefaults;
1280 }
1281
1282 //-----------------------------------------------------------------------------------
1283     } // namespace configapi
1284
1285 } // namespace configmgr
1286
1287