ucb/source/core/ucbstore.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: ucbstore.cxx,v $
  10  * $Revision: 1.17 $
  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_ucb.hxx"
  33
  34 /**************************************************************************
  35                                 TODO
  36  **************************************************************************
  37
  38   *************************************************************************/
  39
  40 #include <list>
  41 #include <hash_map>
  42 #include <osl/diagnose.h>
  43 #include <rtl/ustrbuf.hxx>
  44 #include <cppuhelper/interfacecontainer.hxx>
  45 #include <com/sun/star/beans/PropertyAttribute.hpp>
  46 #include <com/sun/star/beans/PropertySetInfoChange.hpp>
  47 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  48 #include <com/sun/star/container/XNameContainer.hpp>
  49 #include <com/sun/star/container/XNameReplace.hpp>
  50 #include <com/sun/star/util/XChangesBatch.hpp>
  51 #include "ucbstore.hxx"
  52
  53 using namespace com::sun::star::beans;
  54 using namespace com::sun::star::container;
  55 using namespace com::sun::star::lang;
  56 using namespace com::sun::star::ucb;
  57 using namespace com::sun::star::uno;
  58 using namespace com::sun::star::util;
  59 using namespace cppu;
  60 using namespace rtl;
  61
  62 //=========================================================================
  63 rtl::OUString makeHierarchalNameSegment( const rtl::OUString & rIn  )
  64 {
  65     rtl::OUStringBuffer aBuffer;
  66     aBuffer.appendAscii( "['" );
  67
  68     sal_Int32 nCount = rIn.getLength();
  69     for ( sal_Int32 n = 0; n < nCount; ++n )
  70     {
  71         const sal_Unicode c = rIn.getStr()[ n ];
  72         switch ( c )
  73         {
  74             case '&':
  75                 aBuffer.appendAscii( "&amp;" );
  76                 break;
  77
  78             case '"':
  79                 aBuffer.appendAscii( "&quot;" );
  80                 break;
  81
  82             case '\'':
  83                 aBuffer.appendAscii( "&apos;" );
  84                 break;
  85
  86             case '<':
  87                 aBuffer.appendAscii( "&lt;" );
  88                 break;
  89
  90             case '>':
  91                 aBuffer.appendAscii( "&gt;" );
  92                 break;
  93
  94             default:
  95                 aBuffer.append( c );
  96                 break;
  97         }
  98     }
  99
 100     aBuffer.appendAscii( "']" );
 101     return rtl::OUString( aBuffer.makeStringAndClear() );
 102 }
 103
 104 //=========================================================================
 105
 106 #define STORE_CONTENTPROPERTIES_KEY     "/org.openoffice.ucb.Store/ContentProperties"
 107
 108 // describe path of cfg entry
 109 #define CFGPROPERTY_NODEPATH            "nodepath"
 110 // true->async. update; false->sync. update
 111 #define CFGPROPERTY_LAZYWRITE           "lazywrite"
 112
 113 //=========================================================================
 114
 115 struct equalString_Impl
 116 {
 117   bool operator()( const OUString& s1, const OUString& s2 ) const
 118   {
 119         return !!( s1 == s2 );
 120   }
 121 };
 122
 123 struct hashString_Impl
 124 {
 125     size_t operator()( const OUString & rName ) const
 126     {
 127         return rName.hashCode();
 128     }
 129 };
 130
 131 //=========================================================================
 132 //
 133 // PropertySetMap_Impl.
 134 //
 135 //=========================================================================
 136
 137 typedef std::hash_map
 138 <
 139     OUString,
 140     PersistentPropertySet*,
 141     hashString_Impl,
 142     equalString_Impl
 143 >
 144 PropertySetMap_Impl;
 145
 146 //=========================================================================
 147 //
 148 // class PropertySetInfo_Impl
 149 //
 150 //=========================================================================
 151
 152 class PropertySetInfo_Impl :
 153         public OWeakObject,     public XTypeProvider, public XPropertySetInfo
 154 {
 155     Reference< XMultiServiceFactory > m_xSMgr;
 156     Sequence< Property >*                         m_pProps;
 157     PersistentPropertySet*                        m_pOwner;
 158
 159 public:
 160     PropertySetInfo_Impl( const Reference< XMultiServiceFactory >& rxSMgr,
 161                           PersistentPropertySet* pOwner );
 162     virtual ~PropertySetInfo_Impl();
 163
 164     // XInterface
 165     XINTERFACE_DECL()
 166
 167     // XTypeProvider
 168     XTYPEPROVIDER_DECL()
 169
 170     // XPropertySetInfo
 171     virtual Sequence< Property > SAL_CALL getProperties()
 172         throw( RuntimeException );
 173     virtual Property SAL_CALL getPropertyByName( const OUString& aName )
 174         throw( UnknownPropertyException, RuntimeException );
 175     virtual sal_Bool SAL_CALL hasPropertyByName( const OUString& Name )
 176         throw( RuntimeException );
 177
 178     // Non-interface methods.
 179     void reset() { delete m_pProps; m_pProps = 0; }
 180 };
 181
 182 //=========================================================================
 183 //
 184 // UcbStore_Impl.
 185 //
 186 //=========================================================================
 187
 188 struct UcbStore_Impl
 189 {
 190     osl::Mutex                                            m_aMutex;
 191     Sequence< Any >                               m_aInitArgs;
 192     Reference< XPropertySetRegistry > m_xTheRegistry;
 193 };
 194
 195 //=========================================================================
 196 //=========================================================================
 197 //=========================================================================
 198 //
 199 // UcbStore Implementation.
 200 //
 201 //=========================================================================
 202 //=========================================================================
 203 //=========================================================================
 204
 205 UcbStore::UcbStore(     const Reference< XMultiServiceFactory >& rXSMgr )
 206 : m_xSMgr( rXSMgr ),
 207   m_pImpl( new UcbStore_Impl() )
 208 {
 209 }
 210
 211 //=========================================================================
 212 // virtual
 213 UcbStore::~UcbStore()
 214 {
 215     delete m_pImpl;
 216 }
 217
 218 //=========================================================================
 219 //
 220 // XInterface methods.
 221 //
 222 //=========================================================================
 223
 224 XINTERFACE_IMPL_4( UcbStore,
 225                    XTypeProvider,
 226                    XServiceInfo,
 227                    XPropertySetRegistryFactory,
 228                    XInitialization );
 229
 230 //=========================================================================
 231 //
 232 // XTypeProvider methods.
 233 //
 234 //=========================================================================
 235
 236 XTYPEPROVIDER_IMPL_4( UcbStore,
 237                          XTypeProvider,
 238                          XServiceInfo,
 239                       XPropertySetRegistryFactory,
 240                       XInitialization );
 241
 242 //=========================================================================
 243 //
 244 // XServiceInfo methods.
 245 //
 246 //=========================================================================
 247
 248 XSERVICEINFO_IMPL_1( UcbStore,
 249                      OUString::createFromAscii(
 250                          "com.sun.star.comp.ucb.UcbStore" ),
 251                      OUString::createFromAscii(
 252                          STORE_SERVICE_NAME ) );
 253
 254 //=========================================================================
 255 //
 256 // Service factory implementation.
 257 //
 258 //=========================================================================
 259
 260 ONE_INSTANCE_SERVICE_FACTORY_IMPL( UcbStore );
 261
 262 //=========================================================================
 263 //
 264 // XPropertySetRegistryFactory methods.
 265 //
 266 //=========================================================================
 267
 268 // virtual
 269 Reference< XPropertySetRegistry > SAL_CALL
 270 UcbStore::createPropertySetRegistry( const OUString& )
 271     throw( RuntimeException )
 272 {
 273     // The URL parameter is ignored by this interface implementation. It always
 274     // uses the configuration server as storage medium.
 275
 276     if ( !m_pImpl->m_xTheRegistry.is() )
 277     {
 278         osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 279         if ( !m_pImpl->m_xTheRegistry.is() )
 280             m_pImpl->m_xTheRegistry = new PropertySetRegistry( m_xSMgr, *this );
 281     }
 282     return m_pImpl->m_xTheRegistry;
 283 }
 284
 285 //=========================================================================
 286 //
 287 // XInitialization methods.
 288 //
 289 //=========================================================================
 290
 291 // virtual
 292 void SAL_CALL UcbStore::initialize( const Sequence< Any >& aArguments )
 293     throw( Exception, RuntimeException )
 294 {
 295     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 296     m_pImpl->m_aInitArgs = aArguments;
 297 }
 298
 299 //=========================================================================
 300 //
 301 // New methods.
 302 //
 303 //=========================================================================
 304
 305 void UcbStore::removeRegistry()
 306 {
 307     if ( m_pImpl->m_xTheRegistry.is() )
 308     {
 309         osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 310         if ( m_pImpl->m_xTheRegistry.is() )
 311             m_pImpl->m_xTheRegistry = 0;
 312     }
 313 }
 314
 315 //=========================================================================
 316 const Sequence< Any >& UcbStore::getInitArgs() const
 317 {
 318     return m_pImpl->m_aInitArgs;
 319 }
 320
 321 //=========================================================================
 322 //
 323 // PropertySetRegistry_Impl.
 324 //
 325 //=========================================================================
 326
 327 struct PropertySetRegistry_Impl
 328 {
 329     UcbStore*                                             m_pCreator;
 330     PropertySetMap_Impl                           m_aPropSets;
 331     Reference< XMultiServiceFactory > m_xConfigProvider;
 332     Reference< XInterface >                       m_xRootReadAccess;
 333     Reference< XInterface >                       m_xRootWriteAccess;
 334     osl::Mutex                                            m_aMutex;
 335     sal_Bool                                              m_bTriedToGetRootReadAccess;  // #82494#
 336     sal_Bool                                              m_bTriedToGetRootWriteAccess; // #82494#
 337
 338     PropertySetRegistry_Impl( UcbStore& rCreator )
 339     : m_pCreator( &rCreator ),
 340       m_bTriedToGetRootReadAccess( sal_False ),
 341       m_bTriedToGetRootWriteAccess( sal_False )
 342     {
 343         m_pCreator->acquire();
 344     }
 345
 346     ~PropertySetRegistry_Impl()
 347     {
 348         m_pCreator->removeRegistry();
 349         m_pCreator->release();
 350     }
 351 };
 352
 353 //=========================================================================
 354 //=========================================================================
 355 //=========================================================================
 356 //
 357 // PropertySetRegistry Implementation.
 358 //
 359 //=========================================================================
 360 //=========================================================================
 361 //=========================================================================
 362
 363 PropertySetRegistry::PropertySetRegistry(
 364                         const Reference< XMultiServiceFactory >& rXSMgr,
 365                         UcbStore& rCreator )
 366 : m_xSMgr( rXSMgr ),
 367   m_pImpl( new PropertySetRegistry_Impl( rCreator ) )
 368 {
 369 }
 370
 371 //=========================================================================
 372 // virtual
 373 PropertySetRegistry::~PropertySetRegistry()
 374 {
 375     delete m_pImpl;
 376 }
 377
 378 //=========================================================================
 379 //
 380 // XInterface methods.
 381 //
 382 //=========================================================================
 383
 384 XINTERFACE_IMPL_5( PropertySetRegistry,
 385                    XTypeProvider,
 386                    XServiceInfo,
 387                    XPropertySetRegistry,
 388                    XElementAccess, /* base of XNameAccess */
 389                    XNameAccess );
 390
 391 //=========================================================================
 392 //
 393 // XTypeProvider methods.
 394 //
 395 //=========================================================================
 396
 397 XTYPEPROVIDER_IMPL_4( PropertySetRegistry,
 398                          XTypeProvider,
 399                       XServiceInfo,
 400                       XPropertySetRegistry,
 401                       XNameAccess );
 402
 403 //=========================================================================
 404 //
 405 // XServiceInfo methods.
 406 //
 407 //=========================================================================
 408
 409 XSERVICEINFO_NOFACTORY_IMPL_1( PropertySetRegistry,
 410                                 OUString::createFromAscii(
 411                                    "com.sun.star.comp.ucb.PropertySetRegistry" ),
 412                                 OUString::createFromAscii(
 413                                    PROPSET_REG_SERVICE_NAME ) );
 414
 415 //=========================================================================
 416 //
 417 // XPropertySetRegistry methods.
 418 //
 419 //=========================================================================
 420
 421 // virtual
 422 Reference< XPersistentPropertySet > SAL_CALL
 423 PropertySetRegistry::openPropertySet( const OUString& key, sal_Bool create )
 424     throw( RuntimeException )
 425 {
 426     if ( key.getLength() )
 427     {
 428         osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 429
 430         PropertySetMap_Impl& rSets = m_pImpl->m_aPropSets;
 431
 432         PropertySetMap_Impl::const_iterator it = rSets.find( key );
 433         if ( it != rSets.end() )
 434         {
 435             // Already instanciated.
 436             return Reference< XPersistentPropertySet >( (*it).second );
 437         }
 438         else
 439         {
 440             // Create new instance.
 441             Reference< XNameAccess > xRootNameAccess(
 442                                     getRootConfigReadAccess(), UNO_QUERY );
 443             if ( xRootNameAccess.is() )
 444             {
 445                 // Propertyset in registry?
 446                 if ( xRootNameAccess->hasByName( key ) )
 447                 {
 448                     // Yep!
 449                     return Reference< XPersistentPropertySet >(
 450                                             new PersistentPropertySet(
 451                                                     m_xSMgr, *this, key ) );
 452                 }
 453                 else if ( create )
 454                 {
 455                     // No. Create entry for propertyset.
 456
 457                     Reference< XSingleServiceFactory > xFac(
 458                             getConfigWriteAccess( OUString() ), UNO_QUERY );
 459                     Reference< XChangesBatch >  xBatch( xFac, UNO_QUERY );
 460                     Reference< XNameContainer > xContainer( xFac, UNO_QUERY );
 461
 462                     OSL_ENSURE( xFac.is(),
 463                                 "PropertySetRegistry::openPropertySet - "
 464                                 "No factory!" );
 465
 466                     OSL_ENSURE( xBatch.is(),
 467                                 "PropertySetRegistry::openPropertySet - "
 468                                 "No batch!" );
 469
 470                     OSL_ENSURE( xContainer.is(),
 471                                 "PropertySetRegistry::openPropertySet - "
 472                                 "No conteiner!" );
 473
 474                     if ( xFac.is() && xBatch.is() && xContainer.is() )
 475                     {
 476                         try
 477                         {
 478                             // Create new "Properties" config item.
 479                             Reference< XNameReplace > xNameReplace(
 480                                         xFac->createInstance(), UNO_QUERY );
 481
 482                             if ( xNameReplace.is() )
 483                             {
 484                                 // Fill new item...
 485
 486 //                                                              // Set Values
 487 //                                                              xNameReplace->replaceByName(
 488 //                                                                              OUString::createFromAscii( "Values" ),
 489 //                                                                              makeAny( ... ) );
 490
 491                                 // Insert new item.
 492                                 xContainer->insertByName(
 493                                         key, makeAny( xNameReplace ) );
 494                                 // Commit changes.
 495                                 xBatch->commitChanges();
 496
 497                                 return Reference< XPersistentPropertySet >(
 498                                             new PersistentPropertySet(
 499                                                     m_xSMgr, *this, key ) );
 500                             }
 501                         }
 502                         catch ( IllegalArgumentException& )
 503                         {
 504                             // insertByName
 505
 506                             OSL_ENSURE( sal_False,
 507                                         "PropertySetRegistry::openPropertySet - "
 508                                         "caught IllegalArgumentException!" );
 509                         }
 510                         catch ( ElementExistException& )
 511                         {
 512                             // insertByName
 513
 514                             OSL_ENSURE( sal_False,
 515                                         "PropertySetRegistry::openPropertySet - "
 516                                         "caught ElementExistException!" );
 517                         }
 518                         catch ( WrappedTargetException& )
 519                         {
 520                             // insertByName, commitChanges
 521
 522                             OSL_ENSURE( sal_False,
 523                                         "PropertySetRegistry::openPropertySet - "
 524                                         "caught WrappedTargetException!" );
 525                         }
 526                         catch ( RuntimeException& )
 527                         {
 528                             OSL_ENSURE( sal_False,
 529                                         "PropertySetRegistry::openPropertySet - "
 530                                         "caught RuntimeException!" );
 531                         }
 532                         catch ( Exception& )
 533                         {
 534                             // createInstance
 535
 536                             OSL_ENSURE( sal_False,
 537                                         "PropertySetRegistry::openPropertySet - "
 538                                         "caught Exception!" );
 539                         }
 540                     }
 541                 }
 542                 else
 543                 {
 544                     // No entry. Fail, but no error.
 545                     return Reference< XPersistentPropertySet >();
 546                 }
 547             }
 548
 549             OSL_ENSURE( sal_False,
 550                         "PropertySetRegistry::openPropertySet - Error!" );
 551         }
 552     }
 553
 554     return Reference< XPersistentPropertySet >();
 555 }
 556
 557 //=========================================================================
 558 // virtual
 559 void SAL_CALL PropertySetRegistry::removePropertySet( const OUString& key )
 560     throw( RuntimeException )
 561 {
 562     if ( !key.getLength() )
 563         return;
 564
 565     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 566
 567     Reference< XNameAccess > xRootNameAccess(
 568                                     getRootConfigReadAccess(), UNO_QUERY );
 569     if ( xRootNameAccess.is() )
 570     {
 571         // Propertyset in registry?
 572         if ( !xRootNameAccess->hasByName( key ) )
 573             return;
 574         Reference< XChangesBatch > xBatch(
 575                             getConfigWriteAccess( OUString() ), UNO_QUERY );
 576         Reference< XNameContainer > xContainer( xBatch, UNO_QUERY );
 577
 578         OSL_ENSURE( xBatch.is(),
 579                     "PropertySetRegistry::removePropertySet - "
 580                     "No batch!" );
 581
 582         OSL_ENSURE( xContainer.is(),
 583                     "PropertySetRegistry::removePropertySet - "
 584                     "No conteiner!" );
 585
 586         if ( xBatch.is() && xContainer.is() )
 587         {
 588             try
 589             {
 590                 // Remove item.
 591                 xContainer->removeByName( key );
 592                 // Commit changes.
 593                 xBatch->commitChanges();
 594
 595                 // Success.
 596                 return;
 597             }
 598             catch ( NoSuchElementException& )
 599             {
 600                 // removeByName
 601
 602                 OSL_ENSURE( sal_False,
 603                             "PropertySetRegistry::removePropertySet - "
 604                             "caught NoSuchElementException!" );
 605                 return;
 606             }
 607             catch ( WrappedTargetException& )
 608             {
 609                 // commitChanges
 610
 611                 OSL_ENSURE( sal_False,
 612                             "PropertySetRegistry::removePropertySet - "
 613                             "caught WrappedTargetException!" );
 614                 return;
 615             }
 616         }
 617
 618         return;
 619     }
 620
 621     OSL_ENSURE( sal_False, "PropertySetRegistry::removePropertySet - Error!" );
 622 }
 623
 624 //=========================================================================
 625 //
 626 // XElementAccess methods.
 627 //
 628 //=========================================================================
 629
 630 // virtual
 631 com::sun::star::uno::Type SAL_CALL PropertySetRegistry::getElementType()
 632     throw( RuntimeException )
 633 {
 634     return getCppuType( ( Reference< XPersistentPropertySet > * ) 0 );
 635 }
 636
 637 //=========================================================================
 638 // virtual
 639 sal_Bool SAL_CALL PropertySetRegistry::hasElements()
 640     throw( RuntimeException )
 641 {
 642     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 643
 644     Reference< XElementAccess > xElemAccess(
 645                                     getRootConfigReadAccess(), UNO_QUERY );
 646     if ( xElemAccess.is() )
 647         return xElemAccess->hasElements();
 648
 649     return sal_False;
 650 }
 651
 652 //=========================================================================
 653 //
 654 // XNameAccess methods.
 655 //
 656 //=========================================================================
 657
 658 // virtual
 659 Any SAL_CALL PropertySetRegistry::getByName( const OUString& aName )
 660     throw( NoSuchElementException, WrappedTargetException, RuntimeException )
 661 {
 662     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 663
 664     Reference< XNameAccess > xNameAccess(
 665                                     getRootConfigReadAccess(), UNO_QUERY );
 666     if ( xNameAccess.is() )
 667     {
 668
 669         try
 670         {
 671             return xNameAccess->getByName( aName );
 672         }
 673         catch ( NoSuchElementException& )
 674         {
 675             // getByName
 676         }
 677         catch ( WrappedTargetException& )
 678         {
 679             // getByName
 680         }
 681     }
 682
 683     return Any();
 684 }
 685
 686 //=========================================================================
 687 // virtual
 688 Sequence< OUString > SAL_CALL PropertySetRegistry::getElementNames()
 689     throw( RuntimeException )
 690 {
 691     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 692
 693     Reference< XNameAccess > xNameAccess(
 694                                     getRootConfigReadAccess(), UNO_QUERY );
 695     if ( xNameAccess.is() )
 696     {
 697         return xNameAccess->getElementNames();
 698     }
 699     return Sequence< OUString >( 0 );
 700 }
 701
 702 //=========================================================================
 703 // virtual
 704 sal_Bool SAL_CALL PropertySetRegistry::hasByName( const OUString& aName )
 705     throw( RuntimeException )
 706 {
 707     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 708
 709     Reference< XNameAccess > xNameAccess(
 710                                     getRootConfigReadAccess(), UNO_QUERY );
 711     if ( xNameAccess.is() )
 712     {
 713         return xNameAccess->hasByName( aName );
 714     }
 715
 716     return sal_False;
 717 }
 718
 719 //=========================================================================
 720 void PropertySetRegistry::add( PersistentPropertySet* pSet )
 721 {
 722     OUString key( pSet->getKey() );
 723
 724     if ( key.getLength() )
 725     {
 726         osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 727         m_pImpl->m_aPropSets[ key ] = pSet;
 728     }
 729 }
 730
 731 //=========================================================================
 732 void PropertySetRegistry::remove( PersistentPropertySet* pSet )
 733 {
 734     OUString key( pSet->getKey() );
 735
 736     if ( key.getLength() )
 737     {
 738         osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 739
 740         PropertySetMap_Impl& rSets = m_pImpl->m_aPropSets;
 741
 742         PropertySetMap_Impl::iterator it = rSets.find( key );
 743         if ( it != rSets.end() )
 744         {
 745             // Found.
 746             rSets.erase( it );
 747         }
 748     }
 749 }
 750
 751 //=========================================================================
 752 void PropertySetRegistry::renamePropertySet( const OUString& rOldKey,
 753                                              const OUString& rNewKey )
 754 {
 755     if ( rOldKey == rNewKey )
 756         return;
 757
 758     Reference< XNameAccess > xRootNameAccess(
 759                             getConfigWriteAccess( OUString() ), UNO_QUERY );
 760     if ( xRootNameAccess.is() )
 761     {
 762         // Old key present?
 763         if ( xRootNameAccess->hasByName( rOldKey ) )
 764         {
 765             // New key not present?
 766             if ( xRootNameAccess->hasByName( rNewKey ) )
 767             {
 768                 OSL_ENSURE( sal_False,
 769                             "PropertySetRegistry::renamePropertySet - "
 770                             "New key exists!" );
 771                 return;
 772             }
 773             Reference< XSingleServiceFactory > xFac(
 774                                                 xRootNameAccess, UNO_QUERY );
 775             Reference< XChangesBatch >  xBatch( xFac, UNO_QUERY );
 776             Reference< XNameContainer > xContainer( xFac, UNO_QUERY );
 777
 778             OSL_ENSURE( xFac.is(),
 779                         "PropertySetRegistry::renamePropertySet - "
 780                         "No factory!" );
 781
 782             OSL_ENSURE( xBatch.is(),
 783                         "PropertySetRegistry::renamePropertySet - "
 784                         "No batch!" );
 785
 786             OSL_ENSURE( xContainer.is(),
 787                         "PropertySetRegistry::renamePropertySet - "
 788                         "No container!" );
 789
 790             if ( xFac.is() && xBatch.is() && xContainer.is() )
 791             {
 792                 //////////////////////////////////////////////////////
 793                 // Create new "Properties" config item.
 794                 //////////////////////////////////////////////////////
 795
 796                 try
 797                 {
 798                     Reference< XNameReplace > xNameReplace(
 799                                     xFac->createInstance(), UNO_QUERY );
 800
 801                     if ( xNameReplace.is() )
 802                     {
 803                         // Insert new item.
 804                         xContainer->insertByName(
 805                                     rNewKey, makeAny( xNameReplace ) );
 806                         // Commit changes.
 807                         xBatch->commitChanges();
 808                     }
 809                 }
 810                 catch ( IllegalArgumentException& )
 811                 {
 812                     // insertByName
 813
 814                     OSL_ENSURE( sal_False,
 815                                 "PropertySetRegistry::renamePropertySet - "
 816                                 "caught IllegalArgumentException!" );
 817                     return;
 818                 }
 819                 catch ( ElementExistException& )
 820                 {
 821                     // insertByName
 822
 823                     OSL_ENSURE( sal_False,
 824                                 "PropertySetRegistry::renamePropertySet - "
 825                                 "caught ElementExistException!" );
 826                     return;
 827                 }
 828                 catch ( WrappedTargetException& )
 829                 {
 830                     // insertByName, commitChanges
 831
 832                     OSL_ENSURE( sal_False,
 833                                 "PropertySetRegistry::renamePropertySet - "
 834                                 "caught WrappedTargetException!" );
 835                     return;
 836                 }
 837                 catch ( RuntimeException& )
 838                 {
 839                     OSL_ENSURE( sal_False,
 840                                 "PropertySetRegistry::renamePropertySet - "
 841                                 "caught RuntimeException!" );
 842                     return;
 843                 }
 844                 catch ( Exception& )
 845                 {
 846                     // createInstance
 847
 848                     OSL_ENSURE( sal_False,
 849                                 "PropertySetRegistry::renamePropertySet - "
 850                                 "caught Exception!" );
 851                     return;
 852                 }
 853
 854                 //////////////////////////////////////////////////////
 855                 // Copy data...
 856                 //////////////////////////////////////////////////////
 857
 858                 Reference< XHierarchicalNameAccess > xRootHierNameAccess(
 859                                                 xRootNameAccess, UNO_QUERY );
 860                 if ( !xRootHierNameAccess.is() )
 861                 {
 862                     OSL_ENSURE( sal_False,
 863                                 "PropertySetRegistry::renamePropertySet - "
 864                                 "No hierarchical name access!" );
 865                     return;
 866                 }
 867
 868                 try
 869                 {
 870                     rtl::OUString aOldValuesKey
 871                         = makeHierarchalNameSegment( rOldKey );
 872                     aOldValuesKey += OUString::createFromAscii( "/Values" );
 873
 874                     Reference< XNameAccess > xOldNameAccess;
 875                     xRootHierNameAccess->getByHierarchicalName(
 876                                                         aOldValuesKey )
 877                         >>= xOldNameAccess;
 878                     if ( !xOldNameAccess.is() )
 879                     {
 880                         OSL_ENSURE( sal_False,
 881                             "PersistentPropertySet::renamePropertySet - "
 882                             "No old name access!" );
 883                         return;
 884                     }
 885
 886                     // Obtain property names.
 887                     Sequence< OUString > aElems
 888                                     = xOldNameAccess->getElementNames();
 889                     sal_Int32 nCount = aElems.getLength();
 890                     if ( nCount )
 891                     {
 892                         rtl::OUString aNewValuesKey
 893                             = makeHierarchalNameSegment( rNewKey );
 894                         aNewValuesKey += OUString::createFromAscii( "/Values" );
 895
 896                         Reference< XSingleServiceFactory > xNewFac;
 897                         xRootHierNameAccess->getByHierarchicalName(
 898                                                         aNewValuesKey )
 899                             >>= xNewFac;
 900                         if ( !xNewFac.is() )
 901                         {
 902                             OSL_ENSURE( sal_False,
 903                                 "PersistentPropertySet::renamePropertySet - "
 904                                 "No new factory!" );
 905                             return;
 906                         }
 907
 908                         Reference< XNameContainer > xNewContainer(
 909                                                     xNewFac, UNO_QUERY );
 910                         if ( !xNewContainer.is() )
 911                         {
 912                             OSL_ENSURE( sal_False,
 913                                 "PersistentPropertySet::renamePropertySet - "
 914                                 "No new container!" );
 915                             return;
 916                         }
 917
 918                         aOldValuesKey += OUString::createFromAscii( "/" );
 919
 920                         OUString aHandleKey
 921                             = OUString::createFromAscii( "/Handle" );
 922                         OUString aValueKey
 923                             = OUString::createFromAscii( "/Value" );
 924                         OUString aStateKey
 925                             = OUString::createFromAscii( "/State" );
 926                         OUString aAttrKey
 927                             = OUString::createFromAscii( "/Attributes" );
 928
 929                         for ( sal_Int32 n = 0; n < nCount; ++n )
 930                         {
 931                             const OUString& rPropName = aElems[ n ];
 932
 933                             // Create new item.
 934                             Reference< XNameReplace > xNewPropNameReplace(
 935                                 xNewFac->createInstance(), UNO_QUERY );
 936
 937                             if ( !xNewPropNameReplace.is() )
 938                             {
 939                                 OSL_ENSURE( sal_False,
 940                                     "PersistentPropertySet::renamePropertySet - "
 941                                     "No new prop name replace!" );
 942                                 return;
 943                             }
 944
 945                             // Fill new item...
 946
 947                             // Set Values
 948                             OUString aKey = aOldValuesKey;
 949                             aKey += makeHierarchalNameSegment( rPropName );
 950
 951                             // ... handle
 952                             OUString aNewKey1 = aKey;
 953                             aNewKey1 += aHandleKey;
 954                             Any aAny =
 955                                 xRootHierNameAccess->getByHierarchicalName(
 956                                     aNewKey1 );
 957                             xNewPropNameReplace->replaceByName(
 958                                 OUString::createFromAscii( "Handle" ),
 959                                 aAny );
 960
 961                             // ... value
 962                             aNewKey1 = aKey;
 963                             aNewKey1 += aValueKey;
 964                             aAny =
 965                                 xRootHierNameAccess->getByHierarchicalName(
 966                                     aNewKey1 );
 967                             xNewPropNameReplace->replaceByName(
 968                                 OUString::createFromAscii( "Value" ),
 969                                 aAny );
 970
 971                             // ... state
 972                             aNewKey1 = aKey;
 973                             aNewKey1 += aStateKey;
 974                             aAny =
 975                                 xRootHierNameAccess->getByHierarchicalName(
 976                                     aNewKey1 );
 977                             xNewPropNameReplace->replaceByName(
 978                                 OUString::createFromAscii( "State" ),
 979                                 aAny );
 980
 981                             // ... attributes
 982                             aNewKey1 = aKey;
 983                             aNewKey1 += aAttrKey;
 984                             aAny =
 985                                 xRootHierNameAccess->getByHierarchicalName(
 986                                     aNewKey1 );
 987                             xNewPropNameReplace->replaceByName(
 988                                 OUString::createFromAscii( "Attributes" ),
 989                                 aAny );
 990
 991                             // Insert new item.
 992                             xNewContainer->insertByName(
 993                                 rPropName, makeAny( xNewPropNameReplace ) );
 994
 995                             // Commit changes.
 996                             xBatch->commitChanges();
 997                         }
 998                     }
 999                 }
1000                 catch ( IllegalArgumentException& )
1001                 {
1002                     // insertByName, replaceByName
1003
1004                     OSL_ENSURE( sal_False,
1005                                 "PropertySetRegistry::renamePropertySet - "
1006                                 "caught IllegalArgumentException!" );
1007                     return;
1008                 }
1009                 catch ( ElementExistException& )
1010                 {
1011                     // insertByName
1012
1013                     OSL_ENSURE( sal_False,
1014                                 "PropertySetRegistry::renamePropertySet - "
1015                                 "caught ElementExistException!" );
1016                     return;
1017                 }
1018                 catch ( WrappedTargetException& )
1019                 {
1020                     // insertByName, replaceByName, commitChanges
1021
1022                     OSL_ENSURE( sal_False,
1023                                 "PropertySetRegistry::renamePropertySet - "
1024                                 "caught WrappedTargetException!" );
1025                     return;
1026                 }
1027                 catch ( NoSuchElementException& )
1028                 {
1029                     // getByHierarchicalName, replaceByName
1030
1031                     OSL_ENSURE( sal_False,
1032                                 "PropertySetRegistry::renamePropertySet - "
1033                                 "caught NoSuchElementException!" );
1034                     return;
1035                 }
1036                 catch ( RuntimeException& )
1037                 {
1038                     OSL_ENSURE( sal_False,
1039                                 "PropertySetRegistry::renamePropertySet - "
1040                                 "caught RuntimeException!" );
1041                     return;
1042                 }
1043                 catch ( Exception& )
1044                 {
1045                     // createInstance
1046
1047                     OSL_ENSURE( sal_False,
1048                                 "PropertySetRegistry::renamePropertySet - "
1049                                 "caught Exception!" );
1050                     return;
1051                 }
1052
1053                 //////////////////////////////////////////////////////
1054                 // Remove old entry...
1055                 //////////////////////////////////////////////////////
1056
1057                 try
1058                 {
1059                     // Remove item.
1060                     xContainer->removeByName( rOldKey );
1061                     // Commit changes.
1062                     xBatch->commitChanges();
1063
1064                     // Success.
1065                     return;
1066                 }
1067                 catch ( NoSuchElementException& )
1068                 {
1069                     // removeByName
1070
1071                     OSL_ENSURE( sal_False,
1072                                 "PropertySetRegistry::renamePropertySet - "
1073                                 "caught NoSuchElementException!" );
1074                     return;
1075                 }
1076                 catch ( WrappedTargetException& )
1077                 {
1078                     // commitChanges
1079
1080                     OSL_ENSURE( sal_False,
1081                                 "PropertySetRegistry::renamePropertySet - "
1082                                 "caught WrappedTargetException!" );
1083                     return;
1084                 }
1085             }
1086         }
1087     }
1088
1089     OSL_ENSURE( sal_False, "PropertySetRegistry::renamePropertySet - Error!" );
1090 }
1091
1092 //=========================================================================
1093 Reference< XMultiServiceFactory > PropertySetRegistry::getConfigProvider()
1094 {
1095     if ( !m_pImpl->m_xConfigProvider.is() )
1096     {
1097         osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
1098         if ( !m_pImpl->m_xConfigProvider.is() )
1099         {
1100             const Sequence< Any >& rInitArgs
1101                 = m_pImpl->m_pCreator->getInitArgs();
1102
1103             if ( rInitArgs.getLength() > 0 )
1104             {
1105                 // Extract config provider from service init args.
1106                 rInitArgs[ 0 ] >>= m_pImpl->m_xConfigProvider;
1107
1108                 OSL_ENSURE( m_pImpl->m_xConfigProvider.is(),
1109                             "PropertySetRegistry::getConfigProvider - "
1110                             "No config provider!" );
1111             }
1112             else
1113             {
1114                 try
1115                 {
1116                     m_pImpl->m_xConfigProvider
1117                         = Reference< XMultiServiceFactory >(
1118                             m_xSMgr->createInstance(
1119                                 OUString::createFromAscii(
1120                                     "com.sun.star.configuration."
1121                                     "ConfigurationProvider" ) ),
1122                             UNO_QUERY );
1123
1124                     OSL_ENSURE( m_pImpl->m_xConfigProvider.is(),
1125                                 "PropertySetRegistry::getConfigProvider - "
1126                                 "No config provider!" );
1127
1128                 }
1129                 catch ( Exception& )
1130                 {
1131                     OSL_ENSURE( sal_False,
1132                                 "PropertySetRegistry::getConfigProvider - "
1133                                 "caught exception!" );
1134                 }
1135             }
1136         }
1137     }
1138
1139     return m_pImpl->m_xConfigProvider;
1140 }
1141
1142 //=========================================================================
1143 Reference< XInterface > PropertySetRegistry::getRootConfigReadAccess()
1144 {
1145     try
1146     {
1147         osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
1148
1149         if ( !m_pImpl->m_xRootReadAccess.is() )
1150         {
1151             if ( m_pImpl->m_bTriedToGetRootReadAccess ) // #82494#
1152             {
1153                 OSL_ENSURE( sal_False,
1154                             "PropertySetRegistry::getRootConfigReadAccess - "
1155                             "Unable to read any config data! -> #82494#" );
1156                 return Reference< XInterface >();
1157             }
1158
1159             getConfigProvider();
1160
1161             if ( m_pImpl->m_xConfigProvider.is() )
1162             {
1163                 Sequence< Any > aArguments( 1 );
1164                 PropertyValue aProperty;
1165                 aProperty.Name
1166                     = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
1167                                             CFGPROPERTY_NODEPATH ) );
1168                 aProperty.Value
1169                     <<= rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
1170                                             STORE_CONTENTPROPERTIES_KEY ) );
1171                 aArguments[ 0 ] <<= aProperty;
1172
1173                 m_pImpl->m_bTriedToGetRootReadAccess = sal_True;
1174
1175                 m_pImpl->m_xRootReadAccess =
1176                     m_pImpl->m_xConfigProvider->createInstanceWithArguments(
1177                         OUString::createFromAscii(
1178                             "com.sun.star.configuration.ConfigurationAccess" ),
1179                         aArguments );
1180
1181                 if ( m_pImpl->m_xRootReadAccess.is() )
1182                     return m_pImpl->m_xRootReadAccess;
1183             }
1184         }
1185         else
1186             return m_pImpl->m_xRootReadAccess;
1187     }
1188     catch ( RuntimeException& )
1189     {
1190         throw;
1191     }
1192     catch ( Exception& )
1193     {
1194         // createInstance, createInstanceWithArguments
1195
1196         OSL_ENSURE( sal_False,
1197             "PropertySetRegistry::getRootConfigReadAccess - caught Exception!" );
1198         return Reference< XInterface >();
1199     }
1200
1201     OSL_ENSURE( sal_False,
1202                 "PropertySetRegistry::getRootConfigReadAccess - Error!" );
1203     return Reference< XInterface >();
1204 }
1205
1206 //=========================================================================
1207 Reference< XInterface > PropertySetRegistry::getConfigWriteAccess(
1208                                                     const OUString& rPath )
1209 {
1210     try
1211     {
1212         osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
1213
1214         if ( !m_pImpl->m_xRootWriteAccess.is() )
1215         {
1216             if ( m_pImpl->m_bTriedToGetRootWriteAccess ) // #82494#
1217             {
1218                 OSL_ENSURE( sal_False,
1219                             "PropertySetRegistry::getConfigWriteAccess - "
1220                             "Unable to write any config data! -> #82494#" );
1221                 return Reference< XInterface >();
1222             }
1223
1224             getConfigProvider();
1225
1226             if ( m_pImpl->m_xConfigProvider.is() )
1227             {
1228                 Sequence< Any > aArguments( 2 );
1229                 PropertyValue   aProperty;
1230
1231                 aProperty.Name
1232                     = OUString( RTL_CONSTASCII_USTRINGPARAM(
1233                                             CFGPROPERTY_NODEPATH ) );
1234                 aProperty.Value
1235                     <<= OUString( RTL_CONSTASCII_USTRINGPARAM(
1236                                             STORE_CONTENTPROPERTIES_KEY ) );
1237                 aArguments[ 0 ] <<= aProperty;
1238
1239                 aProperty.Name
1240                     = OUString( RTL_CONSTASCII_USTRINGPARAM(
1241                                             CFGPROPERTY_LAZYWRITE ) );
1242                 aProperty.Value <<= sal_True;
1243                 aArguments[ 1 ] <<= aProperty;
1244
1245                 m_pImpl->m_bTriedToGetRootWriteAccess = sal_True;
1246
1247                 m_pImpl->m_xRootWriteAccess =
1248                     m_pImpl->m_xConfigProvider->createInstanceWithArguments(
1249                         OUString::createFromAscii(
1250                             "com.sun.star.configuration.ConfigurationUpdateAccess" ),
1251                         aArguments );
1252
1253                 OSL_ENSURE( m_pImpl->m_xRootWriteAccess.is(),
1254                             "PropertySetRegistry::getConfigWriteAccess - "
1255                             "No config update access!" );
1256             }
1257         }
1258
1259         if ( m_pImpl->m_xRootWriteAccess.is() )
1260         {
1261             if ( rPath.getLength() )
1262             {
1263                 Reference< XHierarchicalNameAccess > xNA(
1264                                 m_pImpl->m_xRootWriteAccess, UNO_QUERY );
1265                 if ( xNA.is() )
1266                 {
1267                     Reference< XInterface > xInterface;
1268                     xNA->getByHierarchicalName( rPath ) >>= xInterface;
1269
1270                     if ( xInterface.is() )
1271                         return xInterface;
1272                 }
1273             }
1274             else
1275                 return m_pImpl->m_xRootWriteAccess;
1276         }
1277     }
1278     catch ( RuntimeException& )
1279     {
1280         throw;
1281     }
1282     catch ( NoSuchElementException& )
1283     {
1284         // getByHierarchicalName
1285
1286         OSL_ENSURE( sal_False,
1287             "PropertySetRegistry::getConfigWriteAccess - "
1288             "caught NoSuchElementException!" );
1289         return Reference< XInterface >();
1290     }
1291     catch ( Exception& )
1292     {
1293         // createInstance, createInstanceWithArguments
1294
1295         OSL_ENSURE( sal_False,
1296                     "PropertySetRegistry::getConfigWriteAccess - "
1297                     "caught Exception!" );
1298         return Reference< XInterface >();
1299     }
1300
1301     OSL_ENSURE( sal_False,
1302                 "PropertySetRegistry::getConfigWriteAccess - Error!" );
1303     return Reference< XInterface >();
1304 }
1305
1306 //=========================================================================
1307 //
1308 // PropertyListeners_Impl.
1309 //
1310 //=========================================================================
1311
1312 typedef OMultiTypeInterfaceContainerHelperVar
1313 <
1314     OUString,
1315     hashString_Impl,
1316     equalString_Impl
1317 > PropertyListeners_Impl;
1318
1319 //=========================================================================
1320 //
1321 // PersistentPropertySet_Impl.
1322 //
1323 //=========================================================================
1324
1325 struct PersistentPropertySet_Impl
1326 {
1327     PropertySetRegistry*                m_pCreator;
1328     PropertySetInfo_Impl*               m_pInfo;
1329     OUString                                    m_aKey;
1330     OUString                                    m_aFullKey;
1331     osl::Mutex                          m_aMutex;
1332     OInterfaceContainerHelper*  m_pDisposeEventListeners;
1333     OInterfaceContainerHelper*  m_pPropSetChangeListeners;
1334     PropertyListeners_Impl*             m_pPropertyChangeListeners;
1335
1336     PersistentPropertySet_Impl( PropertySetRegistry& rCreator,
1337                                 const OUString& rKey )
1338     : m_pCreator( &rCreator ), m_pInfo( NULL ), m_aKey( rKey ),
1339       m_pDisposeEventListeners( NULL ), m_pPropSetChangeListeners( NULL ),
1340       m_pPropertyChangeListeners( NULL )
1341     {
1342         m_pCreator->acquire();
1343     }
1344
1345     ~PersistentPropertySet_Impl()
1346     {
1347         m_pCreator->release();
1348
1349         if ( m_pInfo )
1350             m_pInfo->release();
1351
1352         delete m_pDisposeEventListeners;
1353         delete m_pPropSetChangeListeners;
1354         delete m_pPropertyChangeListeners;
1355     }
1356 };
1357
1358 //=========================================================================
1359 //=========================================================================
1360 //=========================================================================
1361 //
1362 // PersistentPropertySet Implementation.
1363 //
1364 //=========================================================================
1365 //=========================================================================
1366 //=========================================================================
1367
1368 PersistentPropertySet::PersistentPropertySet(
1369                         const Reference< XMultiServiceFactory >& rXSMgr,
1370                         PropertySetRegistry& rCreator,
1371                         const OUString& rKey )
1372 : m_xSMgr( rXSMgr ),
1373   m_pImpl( new PersistentPropertySet_Impl( rCreator, rKey ) )
1374 {
1375     // register at creator.
1376     rCreator.add( this );
1377 }
1378
1379 //=========================================================================
1380 // virtual
1381 PersistentPropertySet::~PersistentPropertySet()
1382 {
1383     // deregister at creator.
1384     m_pImpl->m_pCreator->remove( this );
1385
1386     delete m_pImpl;
1387 }
1388
1389 //=========================================================================
1390 //
1391 // XInterface methods.
1392 //
1393 //=========================================================================
1394
1395 XINTERFACE_IMPL_9( PersistentPropertySet,
1396                    XTypeProvider,
1397                    XServiceInfo,
1398                    XComponent,
1399                    XPropertySet, /* base of XPersistentPropertySet */
1400                    XNamed,
1401                    XPersistentPropertySet,
1402                    XPropertyContainer,
1403                    XPropertySetInfoChangeNotifier,
1404                    XPropertyAccess );
1405
1406 //=========================================================================
1407 //
1408 // XTypeProvider methods.
1409 //
1410 //=========================================================================
1411
1412 XTYPEPROVIDER_IMPL_8( PersistentPropertySet,
1413                          XTypeProvider,
1414                          XServiceInfo,
1415                       XComponent,
1416                       XPersistentPropertySet,
1417                       XNamed,
1418                       XPropertyContainer,
1419                       XPropertySetInfoChangeNotifier,
1420                       XPropertyAccess );
1421
1422 //=========================================================================
1423 //
1424 // XServiceInfo methods.
1425 //
1426 //=========================================================================
1427
1428 XSERVICEINFO_NOFACTORY_IMPL_1( PersistentPropertySet,
1429                                 OUString::createFromAscii(
1430                                    "com.sun.star.comp.ucb.PersistentPropertySet" ),
1431                                 OUString::createFromAscii(
1432                                    PERS_PROPSET_SERVICE_NAME ) );
1433
1434 //=========================================================================
1435 //
1436 // XComponent methods.
1437 //
1438 //=========================================================================
1439
1440 // virtual
1441 void SAL_CALL PersistentPropertySet::dispose()
1442     throw( RuntimeException )
1443 {
1444     if ( m_pImpl->m_pDisposeEventListeners &&
1445          m_pImpl->m_pDisposeEventListeners->getLength() )
1446     {
1447         EventObject aEvt;
1448         aEvt.Source = static_cast< XComponent * >( this  );
1449         m_pImpl->m_pDisposeEventListeners->disposeAndClear( aEvt );
1450     }
1451
1452     if ( m_pImpl->m_pPropSetChangeListeners &&
1453          m_pImpl->m_pPropSetChangeListeners->getLength() )
1454     {
1455         EventObject aEvt;
1456         aEvt.Source = static_cast< XPropertySetInfoChangeNotifier * >( this  );
1457         m_pImpl->m_pPropSetChangeListeners->disposeAndClear( aEvt );
1458     }
1459
1460     if ( m_pImpl->m_pPropertyChangeListeners )
1461     {
1462         EventObject aEvt;
1463         aEvt.Source = static_cast< XPropertySet * >( this  );
1464         m_pImpl->m_pPropertyChangeListeners->disposeAndClear( aEvt );
1465     }
1466 }
1467
1468 //=========================================================================
1469 // virtual
1470 void SAL_CALL PersistentPropertySet::addEventListener(
1471                             const Reference< XEventListener >& Listener )
1472     throw( RuntimeException )
1473 {
1474     if ( !m_pImpl->m_pDisposeEventListeners )
1475         m_pImpl->m_pDisposeEventListeners =
1476                     new OInterfaceContainerHelper( m_pImpl->m_aMutex );
1477
1478     m_pImpl->m_pDisposeEventListeners->addInterface( Listener );
1479 }
1480
1481 //=========================================================================
1482 // virtual
1483 void SAL_CALL PersistentPropertySet::removeEventListener(
1484                             const Reference< XEventListener >& Listener )
1485     throw( RuntimeException )
1486 {
1487     if ( m_pImpl->m_pDisposeEventListeners )
1488         m_pImpl->m_pDisposeEventListeners->removeInterface( Listener );
1489
1490     // Note: Don't want to delete empty container here -> performance.
1491 }
1492
1493 //=========================================================================
1494 //
1495 // XPropertySet methods.
1496 //
1497 //=========================================================================
1498
1499 // virtual
1500 Reference< XPropertySetInfo > SAL_CALL
1501                                 PersistentPropertySet::getPropertySetInfo()
1502     throw( RuntimeException )
1503 {
1504     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
1505
1506     PropertySetInfo_Impl*& rpInfo = m_pImpl->m_pInfo;
1507     if ( !rpInfo )
1508     {
1509         rpInfo = new PropertySetInfo_Impl( m_xSMgr, this );
1510         rpInfo->acquire();
1511     }
1512     return Reference< XPropertySetInfo >( rpInfo );
1513 }
1514
1515 //=========================================================================
1516 // virtual
1517 void SAL_CALL PersistentPropertySet::setPropertyValue(
1518                         const OUString& aPropertyName, const Any& aValue )
1519     throw( UnknownPropertyException,
1520            PropertyVetoException,
1521            IllegalArgumentException,
1522            WrappedTargetException,
1523            RuntimeException )
1524 {
1525     if ( !aPropertyName.getLength() )
1526         throw UnknownPropertyException();
1527
1528     osl::ClearableGuard< osl::Mutex > aCGuard( m_pImpl->m_aMutex );
1529
1530     Reference< XHierarchicalNameAccess > xRootHierNameAccess(
1531                 m_pImpl->m_pCreator->getRootConfigReadAccess(), UNO_QUERY );
1532     if ( xRootHierNameAccess.is() )
1533     {
1534         OUString aFullPropName( getFullKey() );
1535         aFullPropName += OUString::createFromAscii( "/" );
1536         aFullPropName += makeHierarchalNameSegment( aPropertyName );
1537
1538         // Does property exist?
1539         if ( xRootHierNameAccess->hasByHierarchicalName( aFullPropName ) )
1540         {
1541             Reference< XNameReplace > xNameReplace(
1542                     m_pImpl->m_pCreator->getConfigWriteAccess(
1543                                             aFullPropName ), UNO_QUERY );
1544             Reference< XChangesBatch > xBatch(
1545                     m_pImpl->m_pCreator->getConfigWriteAccess(
1546                                             OUString() ), UNO_QUERY );
1547
1548             if ( xNameReplace.is() && xBatch.is() )
1549             {
1550                 try
1551                 {
1552                     // Obtain old value
1553                     OUString aValueName = aFullPropName;
1554                     aValueName += OUString::createFromAscii( "/Value" );
1555                     Any aOldValue
1556                         = xRootHierNameAccess->getByHierarchicalName(
1557                                                                 aValueName );
1558                     // Check value type.
1559                     if ( aOldValue.getValueType() != aValue.getValueType() )
1560                     {
1561                         aCGuard.clear();
1562                         throw IllegalArgumentException();
1563                     }
1564
1565                     // Write value
1566                     xNameReplace->replaceByName(
1567                                     OUString::createFromAscii( "Value" ),
1568                                     aValue );
1569
1570                     // Write state ( Now it is a directly set value )
1571                     xNameReplace->replaceByName(
1572                                     OUString::createFromAscii( "State" ),
1573                                     makeAny( PropertyState_DIRECT_VALUE ) );
1574
1575                     // Commit changes.
1576                     xBatch->commitChanges();
1577
1578                     PropertyChangeEvent aEvt;
1579                     if ( m_pImpl->m_pPropertyChangeListeners )
1580                     {
1581                         // Obtain handle
1582                         aValueName = aFullPropName;
1583                         aValueName += OUString::createFromAscii( "/Handle" );
1584                         sal_Int32 nHandle = -1;
1585                         xRootHierNameAccess->getByHierarchicalName(     aValueName )
1586                             >>= nHandle;
1587
1588                         aEvt.Source         = (OWeakObject*)this;
1589                         aEvt.PropertyName   = aPropertyName;
1590                         aEvt.PropertyHandle = nHandle;
1591                         aEvt.Further        = sal_False;
1592                         aEvt.OldValue       = aOldValue;
1593                         aEvt.NewValue       = aValue;
1594
1595                         // Callback follows!
1596                         aCGuard.clear();
1597
1598                         notifyPropertyChangeEvent( aEvt );
1599                     }
1600                     return;
1601                 }
1602                 catch ( IllegalArgumentException& )
1603                 {
1604                     // replaceByName
1605                 }
1606                 catch ( NoSuchElementException& )
1607                 {
1608                     // getByHierarchicalName, replaceByName
1609                 }
1610                 catch ( WrappedTargetException& )
1611                 {
1612                     // replaceByName, commitChanges
1613                 }
1614             }
1615         }
1616     }
1617
1618     throw UnknownPropertyException();
1619 }
1620
1621 //=========================================================================
1622 // virtual
1623 Any SAL_CALL PersistentPropertySet::getPropertyValue(
1624                                             const OUString& PropertyName )
1625     throw( UnknownPropertyException,
1626            WrappedTargetException,
1627            RuntimeException )
1628 {
1629     if ( !PropertyName.getLength() )
1630         throw UnknownPropertyException();
1631
1632     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
1633
1634     Reference< XHierarchicalNameAccess > xNameAccess(
1635                 m_pImpl->m_pCreator->getRootConfigReadAccess(), UNO_QUERY );
1636     if ( xNameAccess.is() )
1637     {
1638         OUString aFullPropName( getFullKey() );
1639         aFullPropName += OUString::createFromAscii( "/" );
1640         aFullPropName += makeHierarchalNameSegment( PropertyName );
1641         aFullPropName += OUString::createFromAscii( "/Value" );
1642         try
1643         {
1644             return xNameAccess->getByHierarchicalName( aFullPropName );
1645         }
1646         catch ( NoSuchElementException& )
1647         {
1648             throw UnknownPropertyException();
1649         }
1650     }
1651
1652     throw UnknownPropertyException();
1653 }
1654
1655 //=========================================================================
1656 // virtual
1657 void SAL_CALL PersistentPropertySet::addPropertyChangeListener(
1658                     const OUString& aPropertyName,
1659                     const Reference< XPropertyChangeListener >& xListener )
1660     throw( UnknownPropertyException,
1661            WrappedTargetException,
1662            RuntimeException )
1663 {
1664 //      load();
1665
1666     if ( !m_pImpl->m_pPropertyChangeListeners )
1667         m_pImpl->m_pPropertyChangeListeners =
1668                     new PropertyListeners_Impl( m_pImpl->m_aMutex );
1669
1670     m_pImpl->m_pPropertyChangeListeners->addInterface(
1671                                                 aPropertyName, xListener );
1672 }
1673
1674 //=========================================================================
1675 // virtual
1676 void SAL_CALL PersistentPropertySet::removePropertyChangeListener(
1677                     const OUString& aPropertyName,
1678                     const Reference< XPropertyChangeListener >& aListener )
1679     throw( UnknownPropertyException,
1680            WrappedTargetException,
1681            RuntimeException )
1682 {
1683 //      load();
1684
1685     if ( m_pImpl->m_pPropertyChangeListeners )
1686         m_pImpl->m_pPropertyChangeListeners->removeInterface(
1687                                                 aPropertyName, aListener );
1688
1689     // Note: Don't want to delete empty container here -> performance.
1690 }
1691
1692 //=========================================================================
1693 // virtual
1694 void SAL_CALL PersistentPropertySet::addVetoableChangeListener(
1695                     const OUString&,
1696                     const Reference< XVetoableChangeListener >& )
1697     throw( UnknownPropertyException,
1698            WrappedTargetException,
1699            RuntimeException )
1700 {
1701 //      load();
1702 //      OSL_ENSURE( sal_False,
1703 //                              "PersistentPropertySet::addVetoableChangeListener - N.Y.I." );
1704 }
1705
1706 //=========================================================================
1707 // virtual
1708 void SAL_CALL PersistentPropertySet::removeVetoableChangeListener(
1709                     const OUString&,
1710                     const Reference< XVetoableChangeListener >& )
1711     throw( UnknownPropertyException,
1712            WrappedTargetException,
1713            RuntimeException )
1714 {
1715 //      load();
1716 //      OSL_ENSURE( sal_False,
1717 //                              "PersistentPropertySet::removeVetoableChangeListener - N.Y.I." );
1718 }
1719
1720 //=========================================================================
1721 //
1722 // XPersistentPropertySet methods.
1723 //
1724 //=========================================================================
1725
1726 // virtual
1727 Reference< XPropertySetRegistry > SAL_CALL PersistentPropertySet::getRegistry()
1728     throw( RuntimeException )
1729 {
1730     return Reference< XPropertySetRegistry >( m_pImpl->m_pCreator );
1731 }
1732
1733 //=========================================================================
1734 // virtual
1735 OUString SAL_CALL PersistentPropertySet::getKey()
1736     throw( RuntimeException )
1737 {
1738     return m_pImpl->m_aKey;
1739 }
1740
1741 //=========================================================================
1742 //
1743 // XNamed methods.
1744 //
1745 //=========================================================================
1746
1747 // virtual
1748 rtl::OUString SAL_CALL PersistentPropertySet::getName()
1749     throw( RuntimeException )
1750 {
1751     // same as getKey()
1752     return m_pImpl->m_aKey;
1753 }
1754
1755 //=========================================================================
1756 // virtual
1757 void SAL_CALL PersistentPropertySet::setName( const OUString& aName )
1758     throw( RuntimeException )
1759 {
1760     if ( aName != m_pImpl->m_aKey )
1761         m_pImpl->m_pCreator->renamePropertySet( m_pImpl->m_aKey, aName );
1762 }
1763
1764 //=========================================================================
1765 //
1766 // XPropertyContainer methods.
1767 //
1768 //=========================================================================
1769
1770 // virtual
1771 void SAL_CALL PersistentPropertySet::addProperty(
1772         const OUString& Name, sal_Int16 Attributes, const Any& DefaultValue )
1773     throw( PropertyExistException,
1774            IllegalTypeException,
1775            IllegalArgumentException,
1776            RuntimeException )
1777 {
1778     if ( !Name.getLength() )
1779         throw IllegalArgumentException();
1780
1781     // @@@ What other types can't be written to config server?
1782
1783     // Check type class ( Not all types can be written to storage )
1784     TypeClass eTypeClass = DefaultValue.getValueTypeClass();
1785     if ( eTypeClass == TypeClass_INTERFACE )
1786         throw IllegalTypeException();
1787
1788     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
1789
1790     // Property already in set?
1791
1792     OUString aFullValuesName;
1793
1794     Reference< XHierarchicalNameAccess > xRootHierNameAccess(
1795                 m_pImpl->m_pCreator->getRootConfigReadAccess(), UNO_QUERY );
1796     if ( xRootHierNameAccess.is() )
1797     {
1798         aFullValuesName = getFullKey();
1799         OUString aFullPropName = aFullValuesName;
1800         aFullPropName += OUString::createFromAscii( "/" );
1801         aFullPropName += makeHierarchalNameSegment( Name );
1802
1803         if ( xRootHierNameAccess->hasByHierarchicalName( aFullPropName ) )
1804         {
1805             // Already in set.
1806             throw PropertyExistException();
1807         }
1808     }
1809
1810     // Property is always removeable.
1811     Attributes |= PropertyAttribute::REMOVEABLE;
1812
1813     // Add property.
1814
1815     Reference< XSingleServiceFactory > xFac(
1816                 m_pImpl->m_pCreator->getConfigWriteAccess( aFullValuesName ),
1817                 UNO_QUERY );
1818     Reference< XNameContainer > xContainer( xFac, UNO_QUERY );
1819     Reference< XChangesBatch >  xBatch(
1820                 m_pImpl->m_pCreator->getConfigWriteAccess( OUString() ),
1821                 UNO_QUERY );
1822
1823     OSL_ENSURE( xFac.is(),
1824                 "PersistentPropertySet::addProperty - No factory!" );
1825
1826     OSL_ENSURE( xBatch.is(),
1827                 "PersistentPropertySet::addProperty - No batch!" );
1828
1829     OSL_ENSURE( xContainer.is(),
1830                 "PersistentPropertySet::addProperty - No container!" );
1831
1832     if ( xFac.is() && xBatch.is() && xContainer.is() )
1833     {
1834         try
1835         {
1836             // Create new "PropertyValue" config item.
1837             Reference< XNameReplace > xNameReplace(
1838                                         xFac->createInstance(), UNO_QUERY );
1839
1840             if ( xNameReplace.is() )
1841             {
1842                 // Fill new item...
1843
1844                 // Set handle
1845                 xNameReplace->replaceByName(
1846                                     OUString::createFromAscii( "Handle" ),
1847                                     makeAny( sal_Int32( -1 ) ) );
1848
1849                 // Set default value
1850                 xNameReplace->replaceByName(
1851                                     OUString::createFromAscii( "Value" ),
1852                                     DefaultValue );
1853
1854                 // Set state ( always "default" )
1855                 xNameReplace->replaceByName(
1856                                     OUString::createFromAscii( "State" ),
1857                                     makeAny( PropertyState_DEFAULT_VALUE ) );
1858
1859                 // Set attributes
1860                 xNameReplace->replaceByName(
1861                                     OUString::createFromAscii( "Attributes" ),
1862                                     makeAny( sal_Int32( Attributes ) ) );
1863
1864                 // Insert new item.
1865                 xContainer->insertByName( Name, makeAny( xNameReplace ) );
1866
1867                 // Commit changes.
1868                 xBatch->commitChanges();
1869
1870                 // Property set info is invalid.
1871                 if ( m_pImpl->m_pInfo )
1872                     m_pImpl->m_pInfo->reset();
1873
1874                 // Notify propertyset info change listeners.
1875                 if ( m_pImpl->m_pPropSetChangeListeners &&
1876                      m_pImpl->m_pPropSetChangeListeners->getLength() )
1877                 {
1878                     PropertySetInfoChangeEvent evt(
1879                                     static_cast< OWeakObject * >( this ),
1880                                     Name,
1881                                     -1,
1882                                     PropertySetInfoChange::PROPERTY_INSERTED );
1883                     notifyPropertySetInfoChange( evt );
1884                 }
1885
1886                 // Success.
1887                 return;
1888             }
1889         }
1890         catch ( IllegalArgumentException& )
1891         {
1892             // insertByName
1893
1894             OSL_ENSURE( sal_False,
1895                         "PersistentPropertySet::addProperty - "
1896                         "caught IllegalArgumentException!" );
1897             return;
1898         }
1899         catch ( ElementExistException& )
1900         {
1901             // insertByName
1902
1903             OSL_ENSURE( sal_False,
1904                         "PersistentPropertySet::addProperty - "
1905                         "caught ElementExistException!" );
1906             return;
1907         }
1908         catch ( WrappedTargetException& )
1909         {
1910             // replaceByName, insertByName, commitChanges
1911
1912             OSL_ENSURE( sal_False,
1913                         "PersistentPropertySet::addProperty - "
1914                         "caught WrappedTargetException!" );
1915             return;
1916         }
1917         catch ( RuntimeException& )
1918         {
1919             throw;
1920         }
1921         catch ( Exception& )
1922         {
1923             // createInstance
1924
1925             OSL_ENSURE( sal_False,
1926                         "PersistentPropertySet::addProperty - "
1927                         "caught Exception!" );
1928             return;
1929         }
1930     }
1931
1932     OSL_ENSURE( sal_False,
1933                 "PersistentPropertySet::addProperty - Error!" );
1934 }
1935
1936 //=========================================================================
1937 // virtual
1938 void SAL_CALL PersistentPropertySet::removeProperty( const OUString& Name )
1939     throw( UnknownPropertyException,
1940            NotRemoveableException,
1941            RuntimeException )
1942 {
1943     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
1944
1945     OUString aFullValuesName;
1946     OUString aFullPropName;
1947
1948     Reference< XHierarchicalNameAccess > xRootHierNameAccess(
1949                 m_pImpl->m_pCreator->getRootConfigReadAccess(), UNO_QUERY );
1950     if ( xRootHierNameAccess.is() )
1951     {
1952         aFullValuesName = getFullKey();
1953         aFullPropName   = aFullValuesName;
1954         aFullPropName   += OUString::createFromAscii( "/" );
1955         aFullPropName   += makeHierarchalNameSegment( Name );
1956
1957         // Property in set?
1958         if ( !xRootHierNameAccess->hasByHierarchicalName( aFullPropName ) )
1959             throw UnknownPropertyException();
1960
1961         // Property removeable?
1962         try
1963         {
1964             OUString aFullAttrName = aFullPropName;
1965             aFullAttrName += OUString::createFromAscii( "/Attributes" );
1966
1967             sal_Int32 nAttribs = 0;
1968             if ( xRootHierNameAccess->getByHierarchicalName( aFullAttrName )
1969                     >>= nAttribs )
1970             {
1971                 if ( !( nAttribs & PropertyAttribute::REMOVEABLE ) )
1972                 {
1973                     // Not removeable!
1974                     throw NotRemoveableException();
1975                 }
1976             }
1977             else
1978             {
1979                 OSL_ENSURE( sal_False,
1980                             "PersistentPropertySet::removeProperty - "
1981                             "No attributes!" );
1982                 return;
1983             }
1984         }
1985         catch ( NoSuchElementException& )
1986         {
1987             // getByHierarchicalName
1988
1989             OSL_ENSURE( sal_False,
1990                         "PersistentPropertySet::removeProperty - "
1991                         "caught NoSuchElementException!" );
1992         }
1993
1994         // Remove property...
1995
1996         Reference< XNameContainer > xContainer(
1997                 m_pImpl->m_pCreator->getConfigWriteAccess( aFullValuesName ),
1998                 UNO_QUERY );
1999         Reference< XChangesBatch > xBatch(
2000                 m_pImpl->m_pCreator->getConfigWriteAccess( OUString() ),
2001                 UNO_QUERY );
2002
2003         OSL_ENSURE( xBatch.is(),
2004                     "PersistentPropertySet::removeProperty - No batch!" );
2005
2006         OSL_ENSURE( xContainer.is(),
2007                     "PersistentPropertySet::removeProperty - No container!" );
2008
2009         if ( xBatch.is() && xContainer.is() )
2010         {
2011             try
2012             {
2013                 sal_Int32 nHandle = -1;
2014
2015                 if ( m_pImpl->m_pPropSetChangeListeners &&
2016                        m_pImpl->m_pPropSetChangeListeners->getLength() )
2017                 {
2018                     // Obtain property handle ( needed for propertysetinfo
2019                     // change event )...
2020
2021                     try
2022                     {
2023                         OUString aFullHandleName = aFullPropName;
2024                         aFullHandleName
2025                                 += OUString::createFromAscii( "/Handle" );
2026
2027                         if ( ! ( xRootHierNameAccess->getByHierarchicalName(
2028                                         aFullHandleName ) >>= nHandle ) )
2029                             nHandle = -1;
2030
2031                     }
2032                     catch ( NoSuchElementException& )
2033                     {
2034                         // getByHierarchicalName
2035
2036                         OSL_ENSURE( sal_False,
2037                                     "PersistentPropertySet::removeProperty - "
2038                                     "caught NoSuchElementException!" );
2039                         nHandle = -1;
2040                     }
2041                 }
2042
2043                 xContainer->removeByName( Name );
2044                 xBatch->commitChanges();
2045
2046                 // Property set info is invalid.
2047                 if ( m_pImpl->m_pInfo )
2048                     m_pImpl->m_pInfo->reset();
2049
2050                 // Notify propertyset info change listeners.
2051                 if ( m_pImpl->m_pPropSetChangeListeners &&
2052                       m_pImpl->m_pPropSetChangeListeners->getLength() )
2053                 {
2054                     PropertySetInfoChangeEvent evt(
2055                                     static_cast< OWeakObject * >( this ),
2056                                     Name,
2057                                     nHandle,
2058                                     PropertySetInfoChange::PROPERTY_REMOVED );
2059                     notifyPropertySetInfoChange( evt );
2060                 }
2061
2062                 // Success.
2063                 return;
2064             }
2065             catch ( NoSuchElementException& )
2066             {
2067                 // removeByName
2068
2069                 OSL_ENSURE( sal_False,
2070                             "PersistentPropertySet::removeProperty - "
2071                             "caught NoSuchElementException!" );
2072                 return;
2073             }
2074             catch ( WrappedTargetException& )
2075             {
2076                 // commitChanges
2077
2078                 OSL_ENSURE( sal_False,
2079                             "PersistentPropertySet::removeProperty - "
2080                             "caught WrappedTargetException!" );
2081                 return;
2082             }
2083         }
2084     }
2085
2086     OSL_ENSURE( sal_False,
2087                 "PersistentPropertySet::removeProperty - Error!" );
2088 }
2089
2090 //=========================================================================
2091 //
2092 // XPropertySetInfoChangeNotifier methods.
2093 //
2094 //=========================================================================
2095
2096 // virtual
2097 void SAL_CALL PersistentPropertySet::addPropertySetInfoChangeListener(
2098                 const Reference< XPropertySetInfoChangeListener >& Listener )
2099     throw( RuntimeException )
2100 {
2101     if ( !m_pImpl->m_pPropSetChangeListeners )
2102         m_pImpl->m_pPropSetChangeListeners =
2103                     new OInterfaceContainerHelper( m_pImpl->m_aMutex );
2104
2105     m_pImpl->m_pPropSetChangeListeners->addInterface( Listener );
2106 }
2107
2108 //=========================================================================
2109 // virtual
2110 void SAL_CALL PersistentPropertySet::removePropertySetInfoChangeListener(
2111                 const Reference< XPropertySetInfoChangeListener >& Listener )
2112     throw( RuntimeException )
2113 {
2114     if ( m_pImpl->m_pPropSetChangeListeners )
2115         m_pImpl->m_pPropSetChangeListeners->removeInterface( Listener );
2116 }
2117
2118 //=========================================================================
2119 //
2120 // XPropertyAccess methods.
2121 //
2122 //=========================================================================
2123
2124 // virtual
2125 Sequence< PropertyValue > SAL_CALL PersistentPropertySet::getPropertyValues()
2126     throw( RuntimeException )
2127 {
2128     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
2129
2130     Reference< XHierarchicalNameAccess > xRootHierNameAccess(
2131                 m_pImpl->m_pCreator->getRootConfigReadAccess(), UNO_QUERY );
2132     if ( xRootHierNameAccess.is() )
2133     {
2134         try
2135         {
2136             Reference< XNameAccess > xNameAccess;
2137             xRootHierNameAccess->getByHierarchicalName(getFullKey())
2138                 >>= xNameAccess;
2139             if ( xNameAccess.is() )
2140             {
2141                 // Obtain property names.
2142
2143                 Sequence< OUString > aElems = xNameAccess->getElementNames();
2144
2145                 sal_Int32 nCount = aElems.getLength();
2146                 if ( nCount )
2147                 {
2148                     Reference< XHierarchicalNameAccess > xHierNameAccess(
2149                                                     xNameAccess, UNO_QUERY );
2150
2151                     OSL_ENSURE( xHierNameAccess.is(),
2152                                 "PersistentPropertySet::getPropertyValues - "
2153                                 "No hierarchical name access!" );
2154
2155                     if ( xHierNameAccess.is() )
2156                     {
2157                         Sequence< PropertyValue > aValues( nCount );
2158
2159                         const OUString aHandleName
2160                                     = OUString::createFromAscii( "/Handle" );
2161                         const OUString aValueName
2162                                     = OUString::createFromAscii( "/Value" );
2163                         const OUString aStateName
2164                                     = OUString::createFromAscii( "/State" );
2165
2166                         for ( sal_Int32 n = 0; n < nCount; ++n )
2167                         {
2168                             PropertyValue& rValue = aValues[ n ];
2169                             OUString rName    = aElems[ n ];
2170                             OUString aXMLName
2171                                         = makeHierarchalNameSegment( rName );
2172
2173                             // Set property name.
2174
2175                             rValue.Name = rName;
2176
2177                             try
2178                             {
2179                                 // Obtain and set property handle
2180                                 OUString aHierName = aXMLName;
2181                                 aHierName += aHandleName;
2182                                 Any aKeyValue
2183                                     = xHierNameAccess->getByHierarchicalName(
2184                                         aHierName );
2185
2186                                 if ( !( aKeyValue >>= rValue.Handle ) )
2187                                     OSL_ENSURE( sal_False,
2188                                       "PersistentPropertySet::getPropertyValues - "
2189                                       "Error getting property handle!" );
2190                             }
2191                             catch ( NoSuchElementException& )
2192                             {
2193                                 // getByHierarchicalName
2194
2195                                 OSL_ENSURE( sal_False,
2196                                   "PersistentPropertySet::getPropertyValues - "
2197                                   "NoSuchElementException!" );
2198                             }
2199
2200                             try
2201                             {
2202                                 // Obtain and set property value
2203                                 OUString aHierName = aXMLName;
2204                                 aHierName += aValueName;
2205                                 rValue.Value
2206                                     = xHierNameAccess->getByHierarchicalName(
2207                                         aHierName );
2208
2209                                 // Note: The value may be void if addProperty
2210                                 //       was called with a default value
2211                                 //       of type void.
2212                             }
2213                             catch ( NoSuchElementException& )
2214                             {
2215                                 // getByHierarchicalName
2216
2217                                 OSL_ENSURE( sal_False,
2218                                   "PersistentPropertySet::getPropertyValues - "
2219                                   "NoSuchElementException!" );
2220                             }
2221
2222                             try
2223                             {
2224                                 // Obtain and set property state
2225                                 OUString aHierName = aXMLName;
2226                                 aHierName += aStateName;
2227                                 Any aKeyValue
2228                                     = xHierNameAccess->getByHierarchicalName(
2229                                         aHierName );
2230
2231                                 sal_Int32 nState = 0;
2232                                 if ( !( aKeyValue >>= nState ) )
2233                                     OSL_ENSURE( sal_False,
2234                                       "PersistentPropertySet::getPropertyValues - "
2235                                       "Error getting property state!" );
2236                                 else
2237                                     rValue.State = PropertyState( nState );
2238                             }
2239                             catch ( NoSuchElementException& )
2240                             {
2241                                 // getByHierarchicalName
2242
2243                                 OSL_ENSURE( sal_False,
2244                                   "PersistentPropertySet::getPropertyValues - "
2245                                   "NoSuchElementException!" );
2246                             }
2247                         }
2248
2249                         return aValues;
2250                     }
2251                 }
2252             }
2253         }
2254         catch ( NoSuchElementException& )
2255         {
2256             // getByHierarchicalName
2257         }
2258     }
2259
2260     return Sequence< PropertyValue >( 0 );
2261 }
2262
2263 //=========================================================================
2264 // virtual
2265 void SAL_CALL PersistentPropertySet::setPropertyValues(
2266                                  const Sequence< PropertyValue >& aProps )
2267     throw( UnknownPropertyException,
2268            PropertyVetoException,
2269            IllegalArgumentException,
2270            WrappedTargetException,
2271            RuntimeException )
2272 {
2273     sal_Int32 nCount = aProps.getLength();
2274     if ( !nCount )
2275         return;
2276
2277     osl::ClearableGuard< osl::Mutex > aCGuard( m_pImpl->m_aMutex );
2278
2279     Reference< XHierarchicalNameAccess > xRootHierNameAccess(
2280                 m_pImpl->m_pCreator->getRootConfigReadAccess(), UNO_QUERY );
2281     if ( xRootHierNameAccess.is() )
2282     {
2283         const PropertyValue* pNewValues = aProps.getConstArray();
2284
2285         typedef std::list< PropertyChangeEvent > Events;
2286         Events aEvents;
2287
2288         OUString aFullPropNamePrefix( getFullKey() );
2289         aFullPropNamePrefix += OUString::createFromAscii( "/" );
2290
2291         // Iterate over given property value sequence.
2292         for ( sal_Int32 n = 0; n < nCount; ++n )
2293         {
2294             const PropertyValue& rNewValue = pNewValues[ n ];
2295             const OUString& rName = rNewValue.Name;
2296
2297             OUString aFullPropName = aFullPropNamePrefix;
2298             aFullPropName += makeHierarchalNameSegment( rName );
2299
2300             // Does property exist?
2301             if ( xRootHierNameAccess->hasByHierarchicalName( aFullPropName ) )
2302             {
2303                 Reference< XNameReplace > xNameReplace(
2304                     m_pImpl->m_pCreator->getConfigWriteAccess(
2305                                             aFullPropName ), UNO_QUERY );
2306                 Reference< XChangesBatch > xBatch(
2307                     m_pImpl->m_pCreator->getConfigWriteAccess(
2308                                             OUString() ), UNO_QUERY );
2309
2310                 if ( xNameReplace.is() && xBatch.is() )
2311                 {
2312                     try
2313                     {
2314                         // Write handle
2315                         xNameReplace->replaceByName(
2316                                     OUString::createFromAscii( "Handle" ),
2317                                     makeAny( rNewValue.Handle ) );
2318
2319                         // Save old value
2320                         OUString aValueName = aFullPropName;
2321                         aValueName += OUString::createFromAscii( "/Value" );
2322                         Any aOldValue
2323                             = xRootHierNameAccess->getByHierarchicalName(
2324                                                                 aValueName );
2325                         // Write value
2326                         xNameReplace->replaceByName(
2327                                     OUString::createFromAscii( "Value" ),
2328                                     rNewValue.Value );
2329
2330                         // Write state ( Now it is a directly set value )
2331                         xNameReplace->replaceByName(
2332                                     OUString::createFromAscii( "State" ),
2333                                     makeAny( PropertyState_DIRECT_VALUE ) );
2334
2335                         // Commit changes.
2336                         xBatch->commitChanges();
2337
2338                         if ( m_pImpl->m_pPropertyChangeListeners )
2339                         {
2340                             PropertyChangeEvent aEvt;
2341                             aEvt.Source             = (OWeakObject*)this;
2342                             aEvt.PropertyName   = rNewValue.Name;
2343                             aEvt.PropertyHandle = rNewValue.Handle;
2344                             aEvt.Further        = sal_False;
2345                             aEvt.OldValue       = aOldValue;
2346                             aEvt.NewValue       = rNewValue.Value;
2347
2348                             aEvents.push_back( aEvt );
2349                         }
2350                     }
2351                     catch ( IllegalArgumentException& )
2352                     {
2353                         // replaceByName
2354                     }
2355                     catch ( NoSuchElementException& )
2356                     {
2357                         // getByHierarchicalName, replaceByName
2358                     }
2359                     catch ( WrappedTargetException& )
2360                     {
2361                         // replaceByName, commitChanges
2362                     }
2363                 }
2364             }
2365         }
2366
2367         // Callback follows!
2368         aCGuard.clear();
2369
2370         if ( m_pImpl->m_pPropertyChangeListeners )
2371         {
2372             // Notify property changes.
2373             Events::const_iterator it  = aEvents.begin();
2374             Events::const_iterator end = aEvents.end();
2375
2376             while ( it != end )
2377             {
2378                 notifyPropertyChangeEvent( (*it) );
2379                 it++;
2380             }
2381         }
2382
2383         return;
2384     }
2385
2386     OSL_ENSURE( sal_False,
2387                 "PersistentPropertySet::setPropertyValues - Nothing set!" );
2388 }
2389
2390 //=========================================================================
2391 //
2392 // Non-interface methods
2393 //
2394 //=========================================================================
2395
2396 void PersistentPropertySet::notifyPropertyChangeEvent(
2397                                     const PropertyChangeEvent& rEvent ) const
2398 {
2399     // Get "normal" listeners for the property.
2400     OInterfaceContainerHelper* pContainer =
2401             m_pImpl->m_pPropertyChangeListeners->getContainer(
2402                                                     rEvent.PropertyName );
2403     if ( pContainer && pContainer->getLength() )
2404     {
2405         OInterfaceIteratorHelper aIter( *pContainer );
2406         while ( aIter.hasMoreElements() )
2407         {
2408             // Propagate event.
2409             Reference< XPropertyChangeListener > xListener(
2410                                                     aIter.next(), UNO_QUERY );
2411             if ( xListener.is() )
2412                 xListener->propertyChange( rEvent );
2413         }
2414     }
2415
2416     // Get "normal" listeners for all properties.
2417     OInterfaceContainerHelper* pNoNameContainer =
2418             m_pImpl->m_pPropertyChangeListeners->getContainer( OUString() );
2419     if ( pNoNameContainer && pNoNameContainer->getLength() )
2420     {
2421         OInterfaceIteratorHelper aIter( *pNoNameContainer );
2422         while ( aIter.hasMoreElements() )
2423         {
2424             // Propagate event.
2425             Reference< XPropertyChangeListener > xListener(
2426                                                     aIter.next(), UNO_QUERY );
2427             if ( xListener.is() )
2428                 xListener->propertyChange( rEvent );
2429         }
2430     }
2431 }
2432
2433 //=========================================================================
2434 void PersistentPropertySet::notifyPropertySetInfoChange(
2435                                 const PropertySetInfoChangeEvent& evt ) const
2436 {
2437     if ( !m_pImpl->m_pPropSetChangeListeners )
2438         return;
2439
2440     // Notify event listeners.
2441     OInterfaceIteratorHelper aIter( *( m_pImpl->m_pPropSetChangeListeners ) );
2442     while ( aIter.hasMoreElements() )
2443     {
2444         // Propagate event.
2445         Reference< XPropertySetInfoChangeListener >
2446                             xListener( aIter.next(), UNO_QUERY );
2447         if ( xListener.is() )
2448             xListener->propertySetInfoChange( evt );
2449     }
2450 }
2451
2452 //=========================================================================
2453 const OUString& PersistentPropertySet::getFullKey()
2454 {
2455     if ( !m_pImpl->m_aFullKey.getLength() )
2456     {
2457         osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
2458         if ( !m_pImpl->m_aFullKey.getLength() )
2459         {
2460             m_pImpl->m_aFullKey
2461                 = makeHierarchalNameSegment( m_pImpl->m_aKey );
2462             m_pImpl->m_aFullKey
2463                 += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/Values" ) );
2464         }
2465     }
2466
2467     return m_pImpl->m_aFullKey;
2468 }
2469
2470 //=========================================================================
2471 PropertySetRegistry& PersistentPropertySet::getPropertySetRegistry()
2472 {
2473     return *m_pImpl->m_pCreator;
2474 }
2475
2476 //=========================================================================
2477 //=========================================================================
2478 //
2479 // PropertySetInfo_Impl Implementation.
2480 //
2481 //=========================================================================
2482 //=========================================================================
2483
2484 PropertySetInfo_Impl::PropertySetInfo_Impl(
2485                         const Reference< XMultiServiceFactory >& rxSMgr,
2486                         PersistentPropertySet* pOwner )
2487 : m_xSMgr( rxSMgr ),
2488   m_pProps( NULL ),
2489   m_pOwner( pOwner )
2490 {
2491 }
2492
2493 //=========================================================================
2494 // virtual
2495 PropertySetInfo_Impl::~PropertySetInfo_Impl()
2496 {
2497     delete m_pProps;
2498
2499     // !!! Do not delete m_pOwner !!!
2500 }
2501
2502 //=========================================================================
2503 //
2504 // XInterface methods.
2505 //
2506 //=========================================================================
2507
2508 XINTERFACE_IMPL_2( PropertySetInfo_Impl,
2509                    XTypeProvider,
2510                    XPropertySetInfo );
2511
2512 //=========================================================================
2513 //
2514 // XTypeProvider methods.
2515 //
2516 //=========================================================================
2517
2518 XTYPEPROVIDER_IMPL_2( PropertySetInfo_Impl,
2519                          XTypeProvider,
2520                          XPropertySetInfo );
2521
2522 //=========================================================================
2523 //
2524 // XPropertySetInfo methods.
2525 //
2526 //=========================================================================
2527
2528 // virtual
2529 Sequence< Property > SAL_CALL PropertySetInfo_Impl::getProperties()
2530     throw( RuntimeException )
2531 {
2532     if ( !m_pProps )
2533     {
2534         Reference< XHierarchicalNameAccess > xRootHierNameAccess(
2535             m_pOwner->getPropertySetRegistry().getRootConfigReadAccess(),
2536             UNO_QUERY );
2537         if ( xRootHierNameAccess.is() )
2538         {
2539             try
2540             {
2541                 Reference< XNameAccess > xNameAccess;
2542                 xRootHierNameAccess->getByHierarchicalName(
2543                             m_pOwner->getFullKey() )
2544                     >>= xNameAccess;
2545                 if ( xNameAccess.is() )
2546                 {
2547                     // Obtain property names.
2548
2549                     Sequence< OUString > aElems
2550                                             = xNameAccess->getElementNames();
2551
2552                     sal_uInt32 nCount = aElems.getLength();
2553                     Sequence< Property >* pPropSeq
2554                                         = new Sequence< Property >( nCount );
2555
2556                     if ( nCount )
2557                     {
2558                         Reference< XHierarchicalNameAccess > xHierNameAccess(
2559                                                     xNameAccess, UNO_QUERY );
2560
2561                         OSL_ENSURE( xHierNameAccess.is(),
2562                                     "PropertySetInfo_Impl::getProperties - "
2563                                     "No hierarchical name access!" );
2564
2565                         if ( xHierNameAccess.is() )
2566                         {
2567                             const OUString aHandleName
2568                                 = OUString::createFromAscii( "/Handle" );
2569                             const OUString aValueName
2570                                 = OUString::createFromAscii( "/Value" );
2571                             const OUString aAttrName
2572                                 = OUString::createFromAscii( "/Attributes" );
2573
2574                             Property* pProps = pPropSeq->getArray();
2575
2576                             for ( sal_uInt32 n = 0; n < nCount; ++n )
2577                             {
2578                                 Property& rProp = pProps[ n ];
2579                                 OUString  rName = aElems[ n ];
2580                                 OUString aXMLName
2581                                     = makeHierarchalNameSegment( rName );
2582
2583                                 // Set property name.
2584
2585                                 rProp.Name = rName;
2586
2587                                 try
2588                                 {
2589                                     // Obtain and set property handle
2590                                     rtl::OUString aHierName = aXMLName;
2591                                     aHierName += aHandleName;
2592                                     Any aKeyValue
2593                                         = xHierNameAccess->getByHierarchicalName(
2594                                             aHierName );
2595
2596                                     if ( !( aKeyValue >>= rProp.Handle ) )
2597                                         OSL_ENSURE( sal_False,
2598                                           "PropertySetInfo_Impl::getProperties - "
2599                                           "Error getting property handle!" );
2600                                 }
2601                                 catch ( NoSuchElementException& )
2602                                 {
2603                                     // getByHierarchicalName
2604
2605                                     OSL_ENSURE( sal_False,
2606                                       "PropertySetInfo_Impl::getProperties - "
2607                                       "NoSuchElementException!" );
2608                                 }
2609
2610                                 try
2611                                 {
2612                                     // Obtain and set property type
2613                                     rtl::OUString aHierName = aXMLName;
2614                                     aHierName += aValueName;
2615                                     Any aKeyValue
2616                                         = xHierNameAccess->getByHierarchicalName(
2617                                             aHierName );
2618
2619                                     // Note: The type may be void if addProperty
2620                                     //       was called with a default value
2621                                     //       of type void.
2622
2623                                     rProp.Type = aKeyValue.getValueType();
2624                                 }
2625                                 catch ( NoSuchElementException& )
2626                                 {
2627                                     // getByHierarchicalName
2628
2629                                     OSL_ENSURE( sal_False,
2630                                       "PropertySetInfo_Impl::getProperties - "
2631                                       "NoSuchElementException!" );
2632                                 }
2633
2634                                 try
2635                                 {
2636                                     // Obtain and set property attributes
2637                                     rtl::OUString aHierName = aXMLName;
2638                                     aHierName += aAttrName;
2639                                     Any aKeyValue
2640                                         = xHierNameAccess->getByHierarchicalName(
2641                                             aHierName );
2642
2643                                     sal_Int32 nAttribs = 0;
2644                                     if ( aKeyValue >>= nAttribs )
2645                                         rProp.Attributes
2646                                             = sal_Int16( nAttribs );
2647                                     else
2648                                         OSL_ENSURE( sal_False,
2649                                           "PropertySetInfo_Impl::getProperties - "
2650                                           "Error getting property attributes!" );
2651                                 }
2652                                 catch ( NoSuchElementException& )
2653                                 {
2654                                     // getByHierarchicalName
2655
2656                                     OSL_ENSURE( sal_False,
2657                                       "PropertySetInfo_Impl::getProperties - "
2658                                       "NoSuchElementException!" );
2659                                 }
2660                             }
2661                         }
2662                     }
2663
2664                     // Success.
2665                     m_pProps = pPropSeq;
2666                     return *m_pProps;
2667                 }
2668             }
2669             catch ( NoSuchElementException& )
2670             {
2671                 // getByHierarchicalName
2672             }
2673         }
2674
2675         OSL_ENSURE( sal_False, "PropertySetInfo_Impl::getProperties - Error!" );
2676         m_pProps = new Sequence< Property >( 0 );
2677     }
2678
2679     return *m_pProps;
2680 }
2681
2682 //=========================================================================
2683 // virtual
2684 Property SAL_CALL PropertySetInfo_Impl::getPropertyByName(
2685                                                     const OUString& aName )
2686     throw( UnknownPropertyException, RuntimeException )
2687 {
2688     Reference< XHierarchicalNameAccess > xRootHierNameAccess(
2689             m_pOwner->getPropertySetRegistry().getRootConfigReadAccess(),
2690             UNO_QUERY );
2691     if ( xRootHierNameAccess.is() )
2692     {
2693         OUString aFullPropName( m_pOwner->getFullKey() );
2694         aFullPropName += OUString::createFromAscii( "/" );
2695         aFullPropName += makeHierarchalNameSegment( aName );
2696
2697         // Does property exist?
2698         if ( !xRootHierNameAccess->hasByHierarchicalName( aFullPropName ) )
2699             throw UnknownPropertyException();
2700
2701         try
2702         {
2703             Property aProp;
2704
2705             // Obtain handle.
2706             OUString aKey = aFullPropName;
2707             aKey += OUString::createFromAscii( "/Handle" );
2708
2709             if ( !( xRootHierNameAccess->getByHierarchicalName( aKey )
2710                     >>= aProp.Handle ) )
2711             {
2712                 OSL_ENSURE( sal_False,
2713                             "PropertySetInfo_Impl::getPropertyByName - "
2714                             "No handle!" );
2715                 return Property();
2716             }
2717
2718             // Obtain Value and extract type.
2719             aKey = aFullPropName;
2720             aKey += OUString::createFromAscii( "/Value" );
2721
2722             Any aValue = xRootHierNameAccess->getByHierarchicalName( aKey );
2723             if ( !aValue.hasValue() )
2724             {
2725                 OSL_ENSURE( sal_False,
2726                             "PropertySetInfo_Impl::getPropertyByName - "
2727                             "No Value!" );
2728                 return Property();
2729             }
2730
2731             aProp.Type = aValue.getValueType();
2732
2733             // Obtain Attributes.
2734             aKey = aFullPropName;
2735             aKey += OUString::createFromAscii( "/Attributes" );
2736
2737             sal_Int32 nAttribs = 0;
2738             if ( xRootHierNameAccess->getByHierarchicalName( aKey )
2739                     >>= nAttribs )
2740                 aProp.Attributes = sal_Int16( nAttribs );
2741             else
2742             {
2743                 OSL_ENSURE( sal_False,
2744                             "PropertySetInfo_Impl::getPropertyByName - "
2745                             "No attributes!" );
2746                 return Property();
2747             }
2748
2749             // set name.
2750             aProp.Name = aName;
2751
2752             // Success.
2753             return aProp;
2754         }
2755         catch ( NoSuchElementException& )
2756         {
2757             // getByHierarchicalName
2758
2759             OSL_ENSURE( sal_False,
2760                         "PropertySetInfo_Impl::getPropertyByName - "
2761                         "caught NoSuchElementException!" );
2762         }
2763
2764     }
2765
2766     OSL_ENSURE( sal_False, "PropertySetInfo_Impl::getPropertyByName - Error!" );
2767     return Property();
2768 }
2769
2770 //=========================================================================
2771 // virtual
2772 sal_Bool SAL_CALL PropertySetInfo_Impl::hasPropertyByName(
2773                                                     const OUString& Name )
2774     throw( RuntimeException )
2775 {
2776     Reference< XHierarchicalNameAccess > xRootHierNameAccess(
2777             m_pOwner->getPropertySetRegistry().getRootConfigReadAccess(),
2778             UNO_QUERY );
2779     if ( xRootHierNameAccess.is() )
2780     {
2781         OUString aFullPropName( m_pOwner->getFullKey() );
2782         aFullPropName += OUString::createFromAscii( "/" );
2783         aFullPropName += makeHierarchalNameSegment( Name );
2784
2785         return xRootHierNameAccess->hasByHierarchicalName( aFullPropName );
2786     }
2787
2788     return sal_False;
2789 }
2790