CWS-TOOLING: integrate CWS os128

2009-04-22 12:58:26 +0200 b_michaelsen  r271093 : #i101084# using the frames enumeration for other SwXFrames-queries; also added a complex test to ensure the behavior to be the same
2009-04-20 14:53:03 +0200 mav  r270987 : #i101219# adjust the testcases to test memory cache and temporary file cache
2009-04-20 14:52:09 +0200 mav  r270986 : #i101219#,#i99077# use memory to cache data; no precopying on commit
2009-04-20 14:39:21 +0200 mav  r270984 : #i101219# use memory to cache data
2009-04-20 14:39:08 +0200 mav  r270983 : #i101219# use memory to cache data
2009-04-20 14:38:45 +0200 mav  r270982 : #i101219# use memory to cache data
2009-04-17 07:37:52 +0200 os  r270912 : CWS-TOOLING: rebase CWS os128 to trunk@270723 (milestone: DEV300:m46)
2009-04-15 14:54:18 +0200 b_michaelsen  r270845 : #i101084# using frame enumerations for paragraph export for better performance
2009-04-15 14:52:54 +0200 b_michaelsen  r270843 : #i101084# implemented XEnumerationAccess interface on framesets
2009-04-03 17:08:10 +0200 mav  r270504 : #i100722# do not compress streams of known compressed types per default
2009-04-03 13:49:50 +0200 os  r270484 : resync error fixed
2009-04-03 12:55:32 +0200 mav  r270470 : #i100722# do not compress streams of known compressed types per default
2009-04-03 10:00:58 +0200 os  r270463 : resync error fixed
2009-04-03 09:52:53 +0200 os  r270462 : resync error fixed
2009-04-03 09:10:14 +0200 os  r270449 : #i99568# string compare operator of hash_map changed
2009-04-03 09:03:49 +0200 os  r270446 : #i100683# normalize file URLs
2009-04-02 11:09:27 +0200 os  r270381 : #i100683# making URLs relative without file access
2009-04-02 09:04:42 +0200 os  r270366 : CWS-TOOLING: rebase CWS os128 to trunk@270033 (milestone: DEV300:m45)
2009-03-31 08:08:37 +0200 os  r270258 : #i100683# reducing calls to URIHelper::simpleNormalizeMakeRelative()
2009-03-19 17:06:22 +0100 os  r269756 : #i99568# XTolerantMultiPropertySet activated
2009-03-16 11:46:14 +0100 os  r269517 : wrong commit to #i97471# removed
2009-03-16 11:36:50 +0100 os  r269514 : #i97471# SwDrawTextShell::Init(): mouse double click and key input in group objects at the same time: prevent crash
2009-03-13 11:08:54 +0100 os  r269464 : #i99568# static SfxItemPropertySet
2009-03-13 11:03:22 +0100 os  r269463 : #i99568# static SfxItemPropertySet
2009-03-11 12:59:27 +0100 os  r269320 : #i99568# WhichId of properties handled from ScDocOptionsObj added
2009-03-06 09:09:58 +0100 os  r268972 : #i99568# SfxItemPropertySet improvements
2009-03-05 20:54:43 +0100 os  r268942 : #i99568# Sfx/SvxItemPropertySet improvements
2009-03-05 20:19:52 +0100 os  r268941 : #i99568# SfxItemPropertySet improvements
2009-03-05 20:05:03 +0100 os  r268940 : #i99568# SfxItemPropertySet improvements
2009-03-05 18:54:47 +0100 os  r268936 : #i99568# Sfx/SvxItemPropertySet improvements
2009-03-05 17:51:38 +0100 os  r268931 : #i99568# Sfx/SvxItemPropertySet improvements
2009-03-05 17:33:03 +0100 os  r268930 : #i99568# Sfx/SvxItemPropertySet improvements
2009-03-05 15:53:00 +0100 os  r268920 : #i99568# Sfx/SvxItemPropertySet improvements
2009-03-05 15:52:50 +0100 os  r268919 : #i99568# Sfx/SvxItemPropertySet improvements
2009-03-05 15:50:41 +0100 os  r268918 : #i99568# Sfx/SvxItemPropertySet improvements
2009-03-05 15:41:04 +0100 os  r268916 : #i99568# Sfx/SvxItemPropertySet improvements
2009-03-05 15:40:40 +0100 os  r268915 : #i99568# Sfx/SvxItemPropertySet improvements
2009-03-05 10:16:20 +0100 os  r268881 : #i99568# Sfx/SvxItemPropertySet improvements
2009-03-05 10:15:55 +0100 os  r268880 : #i99568# Sfx/SvxItemPropertySet improvements
2009-03-03 08:40:09 +0100 os  r268704 : ScTableSheetObj::GetItemPropertyMap fixed
2009-03-03 07:50:00 +0100 os  r268703 : SfxItemProperty set as pointer
2009-03-03 07:49:46 +0100 os  r268702 : SfxItemProperty set as pointer
2009-03-02 08:15:37 +0100 os  r268631 : minor fix
2009-03-02 07:58:38 +0100 os  r268630 : minor fix
2009-02-27 13:03:25 +0100 os  r268584 : exports
2009-02-27 11:17:04 +0100 os  r268567 : debug code removed
2009-02-27 11:04:07 +0100 os  r268565 : duplicate return removed
2009-02-27 10:17:37 +0100 os  r268558 : syntax fixed
2009-02-27 09:56:14 +0100 os  r268554 : #i99568# type mix fixed
2009-02-27 09:40:56 +0100 os  r268553 : #i99568# exports changes reverted
2009-02-25 12:50:54 +0100 os  r268433 : #i99568# SfxItemPropertySet rework
2009-02-25 12:13:39 +0100 os  r268432 : #i99568# SfxItemPropertySet rework
2009-02-25 12:12:47 +0100 os  r268431 : #i99568# SfxItemPropertySet rework
2009-02-25 12:10:27 +0100 os  r268430 : #i99568# SfxItemPropertySet rework
2009-02-25 12:09:36 +0100 os  r268429 : #i99568# SfxItemPropertySet rework
2009-02-25 12:07:39 +0100 os  r268428 : #i99568# SfxItemPropertySet rework
2009-02-25 11:59:35 +0100 os  r268427 : #i99568# SfxItemPropertySet rework
2009-02-25 11:52:52 +0100 os  r268425 : #i99568# SfxItemPropertySet rework
2009-02-25 11:49:17 +0100 os  r268424 : #i99568# SfxItemPropertySet rework
2009-02-25 11:45:17 +0100 os  r268423 : #i99568# SfxItemPropertySet rework
2009-02-11 11:39:04 +0100 os  r267587 : #i57008# use registration of index marks at SwUnoCallback

4 files changed, 347 insertions, 259 deletions

diff --git a/svtools/inc/svtools/itemprop.hxx b/svtools/inc/svtools/itemprop.hxx
index 34064595753e..feab0eab004b 100644
--- a/svtools/inc/svtools/itemprop.hxx
+++ b/svtools/inc/svtools/itemprop.hxx
@@ -38,12 +38,13 @@
 #include <com/sun/star/beans/XPropertySetInfo.hpp>
 #include <com/sun/star/beans/PropertyState.hpp>
 #include <com/sun/star/lang/IllegalArgumentException.hpp>
-
+#include <vector>
 /* -----------------------------21.02.00 11:03--------------------------------
     UNO III - Implementation
  ---------------------------------------------------------------------------*/
 #define MAP_CHAR_LEN(cchar) cchar, sizeof(cchar) - 1
-struct SfxItemPropertyMap
+
+struct SfxItemPropertyMapEntry
 {
     const char*                         pName;
     USHORT                              nNameLen;
@@ -52,34 +53,83 @@ struct SfxItemPropertyMap
     long                                nFlags;
     BYTE                                nMemberId;
 
-    SVL_DLLPUBLIC static const SfxItemPropertyMap*  GetByName(
-        const SfxItemPropertyMap *pMap,
-        const ::rtl::OUString &rName );
-    SVL_DLLPUBLIC static const SfxItemPropertyMap*  GetTolerantByName(
-        const SfxItemPropertyMap *pMap,
-        const ::rtl::OUString &rName );
+};
+
+struct SfxItemPropertySimpleEntry
+{
+    USHORT                              nWID;
+    const com::sun::star::uno::Type*    pType;
+    long                                nFlags;
+    BYTE                                nMemberId;
+
+    SfxItemPropertySimpleEntry() :
+        nWID( 0 ),
+        pType( 0 ),
+        nFlags( 0 ),
+        nMemberId( 0 ){}
+
+    SfxItemPropertySimpleEntry(USHORT _nWID, const com::sun::star::uno::Type* _pType,
+                               long _nFlags, BYTE _nMemberId) :
+        nWID(      _nWID ),
+        pType(     _pType ),
+        nFlags(    _nFlags ),
+        nMemberId( _nMemberId ){}
+
+    SfxItemPropertySimpleEntry( const SfxItemPropertyMapEntry* pMapEntry ) :
+        nWID(      pMapEntry->nWID ),
+        pType(     pMapEntry->pType ),
+        nFlags(    pMapEntry->nFlags ),
+        nMemberId( pMapEntry->nMemberId ){}
+
+};
+struct SfxItemPropertyNamedEntry : public SfxItemPropertySimpleEntry
+{
+    ::rtl::OUString sName;
+    SfxItemPropertyNamedEntry( const String& rName, const SfxItemPropertySimpleEntry& rSimpleEntry) :
+        SfxItemPropertySimpleEntry( rSimpleEntry ),
+        sName( rName ){}
+
+};
+typedef std::vector< SfxItemPropertyNamedEntry > PropertyEntryVector_t;
+class SfxItemPropertyMap_Impl;
+class SVL_DLLPUBLIC SfxItemPropertyMap
+{
+    SfxItemPropertyMap_Impl* m_pImpl;
+public:
+    SfxItemPropertyMap( const SfxItemPropertyMapEntry* pEntries );
+    SfxItemPropertyMap( const SfxItemPropertyMap* pSource );
+    ~SfxItemPropertyMap();
+
+    const SfxItemPropertySimpleEntry*  getByName( const ::rtl::OUString &rName ) const;
+    com::sun::star::uno::Sequence< com::sun::star::beans::Property > getProperties() const;
+    com::sun::star::beans::Property getPropertyByName( const ::rtl::OUString rName ) const
+        throw( ::com::sun::star::beans::UnknownPropertyException );
+    sal_Bool hasPropertyByName( const ::rtl::OUString& rName ) const;
+
+    void mergeProperties( const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::Property >& rPropSeq );
+    PropertyEntryVector_t getPropertyEntries() const;
+    sal_uInt32 getSize() const;
+
 };
 /* -----------------------------21.02.00 11:19--------------------------------
 
  ---------------------------------------------------------------------------*/
 class SVL_DLLPUBLIC SfxItemPropertySet
 {
-    const SfxItemPropertyMap*   _pMap;
+    SfxItemPropertyMap                                                              m_aMap;
+    mutable com::sun::star::uno::Reference<com::sun::star::beans::XPropertySetInfo> m_xInfo;
 protected:
     virtual BOOL            FillItem(SfxItemSet& rSet, USHORT nWhich, BOOL bGetProperty) const;
 
 public:
-                            SfxItemPropertySet( const SfxItemPropertyMap *pMap ) :
-                                _pMap(pMap) {}
-
-    void getPropertyValue( const SfxItemPropertyMap& rMap,
-                                            const SfxItemSet& rSet,
-                                            com::sun::star::uno::Any& rAny) const
-                                            throw(::com::sun::star::uno::RuntimeException);
-    com::sun::star::uno::Any
-        getPropertyValue( const SfxItemPropertyMap& rMap,
-                                            const SfxItemSet& rSet ) const
-                                            throw(::com::sun::star::uno::RuntimeException);
+                            SfxItemPropertySet( const SfxItemPropertyMapEntry *pMap ) :
+                                m_aMap(pMap) {}
+                            virtual ~SfxItemPropertySet();
+
+    void getPropertyValue( const SfxItemPropertySimpleEntry& rEntry,
+                                          const SfxItemSet& rSet,
+                                          com::sun::star::uno::Any& rAny) const
+                                          throw(::com::sun::star::uno::RuntimeException);
     void getPropertyValue( const ::rtl::OUString &rName,
                                             const SfxItemSet& rSet,
                                             com::sun::star::uno::Any& rAny) const
@@ -90,11 +140,11 @@ public:
                                             const SfxItemSet& rSet ) const
                                             throw(::com::sun::star::uno::RuntimeException,
                                                     ::com::sun::star::beans::UnknownPropertyException);
-    void                    setPropertyValue( const SfxItemPropertyMap& rMap,
-                                            const com::sun::star::uno::Any& aVal,
-                                            SfxItemSet& rSet ) const
-                                            throw(::com::sun::star::uno::RuntimeException,
-                                                    com::sun::star::lang::IllegalArgumentException);
+    void                    setPropertyValue( const SfxItemPropertySimpleEntry& rEntry,
+                                          const com::sun::star::uno::Any& aVal,
+                                          SfxItemSet& rSet ) const
+                                          throw(::com::sun::star::uno::RuntimeException,
+                                                  com::sun::star::lang::IllegalArgumentException);
     void                    setPropertyValue( const ::rtl::OUString& rPropertyName,
                                             const com::sun::star::uno::Any& aVal,
                                             SfxItemSet& rSet ) const
@@ -103,29 +153,31 @@ public:
                                                     ::com::sun::star::beans::UnknownPropertyException);
 
     com::sun::star::beans::PropertyState
-        getPropertyState(const ::rtl::OUString& rName, const SfxItemSet& rSet)
+        getPropertyState(const ::rtl::OUString& rName, const SfxItemSet& rSet)const
                                     throw(com::sun::star::beans::UnknownPropertyException);
     com::sun::star::beans::PropertyState
-        getPropertyState(const SfxItemPropertyMap& rMap, const SfxItemSet& rSet)
+        getPropertyState(const SfxItemPropertySimpleEntry& rEntry, const SfxItemSet& rSet) const
                                     throw();
 
     com::sun::star::uno::Reference<com::sun::star::beans::XPropertySetInfo>
         getPropertySetInfo() const;
     const SfxItemPropertyMap*
-        getPropertyMap() const {return _pMap;}
+        getPropertyMap() const {return &m_aMap;}
 
 };
 /* -----------------------------21.02.00 11:09--------------------------------
 
  ---------------------------------------------------------------------------*/
+struct SfxItemPropertySetInfo_Impl;
 class SVL_DLLPUBLIC SfxItemPropertySetInfo : public
     cppu::WeakImplHelper1<com::sun::star::beans::XPropertySetInfo>
 {
-    const SfxItemPropertyMap*   _pMap;
+    SfxItemPropertySetInfo_Impl* m_pImpl;
 
 public:
-    SfxItemPropertySetInfo(const SfxItemPropertyMap *pMap ) :
-                                _pMap(pMap) {}
+    SfxItemPropertySetInfo(const SfxItemPropertyMap *pMap );
+    SfxItemPropertySetInfo(const SfxItemPropertyMapEntry *pEntries );
+    virtual ~SfxItemPropertySetInfo();
 
     virtual ::com::sun::star::uno::Sequence< ::com::sun::star::beans::Property > SAL_CALL
         getProperties(  )
@@ -140,19 +192,19 @@ public:
         hasPropertyByName( const ::rtl::OUString& Name )
             throw(::com::sun::star::uno::RuntimeException);
 
-    const SfxItemPropertyMap* getMap() const { return _pMap; }
+    const SfxItemPropertyMap* getMap() const;
 };
 /* -----------------------------21.02.00 12:01--------------------------------
 
  ---------------------------------------------------------------------------*/
 class SVL_DLLPUBLIC SfxExtItemPropertySetInfo: public cppu::WeakImplHelper1<com::sun::star::beans::XPropertySetInfo >
 {
-    const SfxItemPropertyMap*                                           _pExtMap;
-    com::sun::star::uno::Sequence<com::sun::star::beans::Property>      aPropertySeq;
+    SfxItemPropertyMap aExtMap;
 public:
                             SfxExtItemPropertySetInfo(
-                                const SfxItemPropertyMap *pMap,
+                                const SfxItemPropertyMapEntry *pMap,
                                 const com::sun::star::uno::Sequence<com::sun::star::beans::Property>& rPropSeq );
+                            virtual ~SfxExtItemPropertySetInfo();
 
     virtual ::com::sun::star::uno::Sequence< ::com::sun::star::beans::Property > SAL_CALL
         getProperties(  )
diff --git a/svtools/source/items1/itemprop.cxx b/svtools/source/items1/itemprop.cxx
index 0c31e3f0a64a..354e0a1441ba 100644
--- a/svtools/source/items1/itemprop.cxx
+++ b/svtools/source/items1/itemprop.cxx
@@ -30,56 +30,189 @@
 
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_svtools.hxx"
-#include <string.h>
-#ifndef GCC
-#endif
 
 #include <svtools/itemprop.hxx>
 #include <svtools/itempool.hxx>
 #include <svtools/itemset.hxx>
 #include <com/sun/star/beans/PropertyAttribute.hpp>
-
+#include <hash_map>
 /*************************************************************************
     UNO III Implementation
 *************************************************************************/
+using namespace com::sun::star;
 using namespace com::sun::star::beans;
 using namespace com::sun::star::lang;
 using namespace com::sun::star::uno;
 using namespace ::rtl;
-/* -----------------------------21.02.00 11:26--------------------------------
+/*-- 16.02.2009 10:03:55---------------------------------------------------
 
- ---------------------------------------------------------------------------*/
-const SfxItemPropertyMap*   SfxItemPropertyMap::GetByName(
-    const SfxItemPropertyMap *pMap, const OUString &rName )
+  -----------------------------------------------------------------------*/
+
+struct equalOUString
+{
+  bool operator()(const ::rtl::OUString& r1, const ::rtl::OUString&  r2) const
+  {
+    return r1.equals( r2 );
+  }
+};
+
+typedef ::std::hash_map< ::rtl::OUString,
+                                 SfxItemPropertySimpleEntry,
+                                 ::rtl::OUStringHash,
+                                 equalOUString > SfxItemPropertyHashMap_t;
+
+class SfxItemPropertyMap_Impl : public SfxItemPropertyHashMap_t
+{
+public:
+    mutable uno::Sequence< beans::Property > m_aPropSeq;
+
+    SfxItemPropertyMap_Impl(){}
+    SfxItemPropertyMap_Impl( const SfxItemPropertyMap_Impl* pSource );
+};
+SfxItemPropertyMap_Impl::SfxItemPropertyMap_Impl( const SfxItemPropertyMap_Impl* pSource )
 {
-    while ( pMap->pName )
+    this->SfxItemPropertyHashMap_t::operator=( *pSource );
+    m_aPropSeq = pSource->m_aPropSeq;
+}
+
+/*-- 16.02.2009 10:03:51---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+SfxItemPropertyMap::SfxItemPropertyMap( const SfxItemPropertyMapEntry* pEntries ) :
+    m_pImpl( new SfxItemPropertyMap_Impl )
+{
+    while( pEntries->pName )
     {
-        if( rName.equalsAsciiL( pMap->pName, pMap->nNameLen ) )
-            return pMap;
-        ++pMap;
+        ::rtl::OUString sEntry(pEntries->pName, pEntries->nNameLen, RTL_TEXTENCODING_ASCII_US );
+        (*m_pImpl) [ sEntry ] = pEntries;
+        ++pEntries;
     }
-    return 0;
 }
-/* -----------------------------12.12.03 14:04--------------------------------
+/*-- 16.02.2009 12:46:41---------------------------------------------------
 
- ---------------------------------------------------------------------------*/
-const SfxItemPropertyMap*   SfxItemPropertyMap::GetTolerantByName(
-    const SfxItemPropertyMap *pMap, const OUString &rName )
+  -----------------------------------------------------------------------*/
+SfxItemPropertyMap::SfxItemPropertyMap( const SfxItemPropertyMap* pSource ) :
+    m_pImpl( new SfxItemPropertyMap_Impl( pSource->m_pImpl ) )
 {
-    sal_Int32 nLength(rName.getLength());
-    while ( pMap->pName )
+}
+/*-- 16.02.2009 10:03:51---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+SfxItemPropertyMap::~SfxItemPropertyMap()
+{
+    delete m_pImpl;
+}
+/*-- 16.02.2009 10:03:51---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+const SfxItemPropertySimpleEntry* SfxItemPropertyMap::getByName( const ::rtl::OUString &rName ) const
+{
+    SfxItemPropertyHashMap_t::const_iterator aIter = m_pImpl->find(rName);
+    if( aIter == m_pImpl->end() )
+        return 0;
+    return &aIter->second;
+}
+
+/*-- 16.02.2009 10:44:24---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+uno::Sequence<beans::Property> SfxItemPropertyMap::getProperties() const
+{
+    if( !m_pImpl->m_aPropSeq.getLength() )
     {
-        if( nLength == pMap->nNameLen )
+        m_pImpl->m_aPropSeq.realloc( m_pImpl->size() );
+        beans::Property* pPropArray = m_pImpl->m_aPropSeq.getArray();
+        sal_uInt32 n = 0;
+        SfxItemPropertyHashMap_t::const_iterator aIt = m_pImpl->begin();
+        while( aIt != m_pImpl->end() )
+        //for ( const SfxItemPropertyMap *pMap = _pMap; pMap->pName; ++pMap )
         {
-            sal_Int32 nResult(rName.compareToAscii(pMap->pName));
-            if (nResult == 0)
-                return pMap;
-            else if (nResult < 0)
-                return 0;
+            const SfxItemPropertySimpleEntry* pEntry = &(*aIt).second;
+            pPropArray[n].Name = (*aIt).first;
+            pPropArray[n].Handle = pEntry->nWID;
+            if(pEntry->pType)
+                pPropArray[n].Type = *pEntry->pType;
+            pPropArray[n].Attributes =
+                sal::static_int_cast< sal_Int16 >(pEntry->nFlags);
+            n++;
+            ++aIt;
         }
-        ++pMap;
     }
-    return 0;
+
+    return m_pImpl->m_aPropSeq;
+}
+/*-- 16.02.2009 11:04:31---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+beans::Property SfxItemPropertyMap::getPropertyByName( const ::rtl::OUString rName ) const
+    throw( beans::UnknownPropertyException )
+{
+    SfxItemPropertyHashMap_t::const_iterator aIter = m_pImpl->find(rName);
+    if( aIter == m_pImpl->end() )
+        throw UnknownPropertyException();
+    const SfxItemPropertySimpleEntry* pEntry = &aIter->second;
+    beans::Property aProp;
+    aProp.Name = rName;
+    aProp.Handle = pEntry->nWID;
+    if(pEntry->pType)
+        aProp.Type = *pEntry->pType;
+    aProp.Attributes = sal::static_int_cast< sal_Int16 >(pEntry->nFlags);
+    return aProp;
+}
+/*-- 16.02.2009 11:09:16---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+sal_Bool SfxItemPropertyMap::hasPropertyByName( const ::rtl::OUString& rName ) const
+{
+    SfxItemPropertyHashMap_t::const_iterator aIter = m_pImpl->find(rName);
+    return aIter != m_pImpl->end();
+}
+/*-- 16.02.2009 11:25:14---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+void SfxItemPropertyMap::mergeProperties( const uno::Sequence< beans::Property >& rPropSeq )
+{
+    const beans::Property* pPropArray = rPropSeq.getConstArray();
+    sal_uInt32 nElements = rPropSeq.getLength();
+    for( sal_uInt32 nElement = 0; nElement < nElements; ++nElement )
+    {
+        SfxItemPropertySimpleEntry aTemp(
+            sal::static_int_cast< sal_Int16 >( pPropArray[nElement].Handle ), //nWID
+            &pPropArray[nElement].Type, //pType
+            pPropArray[nElement].Attributes, //nFlags
+            0 ); //nMemberId
+        (*m_pImpl)[pPropArray[nElement].Name] = aTemp;
+    }
+}
+/*-- 18.02.2009 12:04:42---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+PropertyEntryVector_t SfxItemPropertyMap::getPropertyEntries() const
+{
+    PropertyEntryVector_t aRet;
+    aRet.reserve(m_pImpl->size());
+
+    SfxItemPropertyHashMap_t::const_iterator aIt = m_pImpl->begin();
+    while( aIt != m_pImpl->end() )
+    {
+        const SfxItemPropertySimpleEntry* pEntry = &(*aIt).second;
+        aRet.push_back( SfxItemPropertyNamedEntry( (*aIt).first, * pEntry ) );
+        ++aIt;
+    }
+    return aRet;
+}
+/*-- 18.02.2009 15:11:06---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+sal_uInt32 SfxItemPropertyMap::getSize() const
+{
+    return m_pImpl->size();
+}
+/*-- 16.02.2009 13:44:54---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+SfxItemPropertySet::~SfxItemPropertySet()
+{
 }
 /* -----------------------------21.02.00 11:26--------------------------------
 
@@ -91,55 +224,41 @@ BOOL SfxItemPropertySet::FillItem(SfxItemSet&, USHORT, BOOL) const
 /* -----------------------------06.06.01 12:32--------------------------------
 
  ---------------------------------------------------------------------------*/
-void SfxItemPropertySet::getPropertyValue( const SfxItemPropertyMap& rMap,
+void SfxItemPropertySet::getPropertyValue( const SfxItemPropertySimpleEntry& rEntry,
             const SfxItemSet& rSet, Any& rAny ) const
                         throw(RuntimeException)
 {
-    // item holen
+    // get the SfxPoolItem
     const SfxPoolItem* pItem = 0;
-    SfxItemState eState = rSet.GetItemState( rMap.nWID, TRUE, &pItem );
-    if(SFX_ITEM_SET != eState && SFX_WHICH_MAX > rMap.nWID )
-        pItem = &rSet.GetPool()->GetDefaultItem(rMap.nWID);
-    // item-Wert als UnoAny zurueckgeben
+    SfxItemState eState = rSet.GetItemState( rEntry.nWID, TRUE, &pItem );
+    if(SFX_ITEM_SET != eState && SFX_WHICH_MAX > rEntry.nWID )
+        pItem = &rSet.GetPool()->GetDefaultItem(rEntry.nWID);
+    // return item values as uno::Any
     if(eState >= SFX_ITEM_DEFAULT && pItem)
     {
-        pItem->QueryValue( rAny, rMap.nMemberId );
+        pItem->QueryValue( rAny, rEntry.nMemberId );
     }
     else
     {
-        SfxItemSet aSet(*rSet.GetPool(), rMap.nWID, rMap.nWID);
-        if(FillItem(aSet, rMap.nWID, TRUE))
+        SfxItemSet aSet(*rSet.GetPool(), rEntry.nWID, rEntry.nWID);
+        if(FillItem(aSet, rEntry.nWID, TRUE))
         {
-            const SfxPoolItem& rItem = aSet.Get(rMap.nWID);
-            rItem.QueryValue( rAny, rMap.nMemberId );
+            const SfxPoolItem& rItem = aSet.Get(rEntry.nWID);
+            rItem.QueryValue( rAny, rEntry.nMemberId );
         }
-        else if(0 == (rMap.nFlags & PropertyAttribute::MAYBEVOID))
+        else if(0 == (rEntry.nFlags & PropertyAttribute::MAYBEVOID))
             throw RuntimeException();
     }
 
 
-    // allgemeine SfxEnumItem Values in konkrete wandeln
-    if( rMap.pType && TypeClass_ENUM == rMap.pType->getTypeClass() &&
+    // convert general SfxEnumItem values to specific values
+    if( rEntry.pType && TypeClass_ENUM == rEntry.pType->getTypeClass() &&
          rAny.getValueTypeClass() == TypeClass_LONG )
     {
         INT32 nTmp = *(INT32*)rAny.getValue();
-        rAny.setValue( &nTmp, *rMap.pType );
+        rAny.setValue( &nTmp, *rEntry.pType );
     }
 }
-
-
-/* -----------------------------15.11.00 12:32--------------------------------
-
- ---------------------------------------------------------------------------*/
-Any SfxItemPropertySet::getPropertyValue( const SfxItemPropertyMap& rMap,
-            const SfxItemSet& rSet ) const
-                        throw(RuntimeException)
-{
-    Any aAny;
-    getPropertyValue(rMap, rSet, aAny);
-    return aAny;
-}
-
 /* -----------------------------06.06.01 12:32--------------------------------
 
  ---------------------------------------------------------------------------*/
@@ -147,11 +266,11 @@ void SfxItemPropertySet::getPropertyValue( const OUString &rName,
             const SfxItemSet& rSet, Any& rAny ) const
                         throw(RuntimeException, UnknownPropertyException)
 {
-    // which-id ermitteln
-    const SfxItemPropertyMap* pMap = SfxItemPropertyMap::GetByName( _pMap, rName );
-    if ( !pMap )
+    // detect which-id
+    const SfxItemPropertySimpleEntry* pEntry = m_aMap.getByName( rName );
+    if ( !pEntry )
         throw UnknownPropertyException();
-    getPropertyValue( *pMap,rSet, rAny );
+    getPropertyValue( *pEntry,rSet, rAny );
 }
 /* -----------------------------21.02.00 11:26--------------------------------
 
@@ -167,25 +286,25 @@ Any SfxItemPropertySet::getPropertyValue( const OUString &rName,
 /* -----------------------------15.11.00 14:46--------------------------------
 
  ---------------------------------------------------------------------------*/
-void SfxItemPropertySet::setPropertyValue( const SfxItemPropertyMap& rMap,
+void SfxItemPropertySet::setPropertyValue( const SfxItemPropertySimpleEntry& rEntry,
                                             const Any& aVal,
                                             SfxItemSet& rSet ) const
                                             throw(RuntimeException,
                                                     IllegalArgumentException)
 {
-    // item holen
+    // get the SfxPoolItem
     const SfxPoolItem* pItem = 0;
     SfxPoolItem *pNewItem = 0;
-    SfxItemState eState = rSet.GetItemState( rMap.nWID, TRUE, &pItem );
-    if(SFX_ITEM_SET != eState && SFX_WHICH_MAX > rMap.nWID )
-        pItem = &rSet.GetPool()->GetDefaultItem(rMap.nWID);
+    SfxItemState eState = rSet.GetItemState( rEntry.nWID, TRUE, &pItem );
+    if(SFX_ITEM_SET != eState && SFX_WHICH_MAX > rEntry.nWID )
+        pItem = &rSet.GetPool()->GetDefaultItem(rEntry.nWID);
     //maybe there's another way to find an Item
     if(eState < SFX_ITEM_DEFAULT)
     {
-        SfxItemSet aSet(*rSet.GetPool(), rMap.nWID, rMap.nWID);
-        if(FillItem(aSet, rMap.nWID, FALSE))
+        SfxItemSet aSet(*rSet.GetPool(), rEntry.nWID, rEntry.nWID);
+        if(FillItem(aSet, rEntry.nWID, FALSE))
         {
-            const SfxPoolItem &rItem = aSet.Get(rMap.nWID);
+            const SfxPoolItem &rItem = aSet.Get(rEntry.nWID);
             pNewItem = rItem.Clone();
         }
     }
@@ -195,13 +314,13 @@ void SfxItemPropertySet::setPropertyValue( const SfxItemPropertyMap& rMap,
     }
     if(pNewItem)
     {
-        if( !pNewItem->PutValue( aVal, rMap.nMemberId ) )
+        if( !pNewItem->PutValue( aVal, rEntry.nMemberId ) )
         {
             DELETEZ(pNewItem);
             throw IllegalArgumentException();
         }
-        // neues item in itemset setzen
-        rSet.Put( *pNewItem, rMap.nWID );
+        // apply new item
+        rSet.Put( *pNewItem, rEntry.nWID );
         delete pNewItem;
     }
 }
@@ -215,21 +334,21 @@ void SfxItemPropertySet::setPropertyValue( const OUString &rName,
                                                     IllegalArgumentException,
                                                     UnknownPropertyException)
 {
-    const SfxItemPropertyMap* pMap = SfxItemPropertyMap::GetByName( _pMap, rName );
-    if ( !pMap )
+    const SfxItemPropertySimpleEntry* pEntry = m_aMap.getByName( rName );
+    if ( !pEntry )
     {
         throw UnknownPropertyException();
     }
-    setPropertyValue(*pMap, aVal, rSet);
+    setPropertyValue(*pEntry, aVal, rSet);
 }
 /* -----------------------------21.02.00 11:26--------------------------------
 
  ---------------------------------------------------------------------------*/
-PropertyState SfxItemPropertySet::getPropertyState(const SfxItemPropertyMap& rMap, const SfxItemSet& rSet)
+PropertyState SfxItemPropertySet::getPropertyState(const SfxItemPropertySimpleEntry& rEntry, const SfxItemSet& rSet) const
                                     throw()
 {
     PropertyState eRet = PropertyState_DIRECT_VALUE;
-    USHORT nWhich = rMap.nWID;
+    USHORT nWhich = rEntry.nWID;
 
     // item state holen
     SfxItemState eState = rSet.GetItemState( nWhich, FALSE );
@@ -240,20 +359,19 @@ PropertyState SfxItemPropertySet::getPropertyState(const SfxItemPropertyMap& rMa
         eRet = PropertyState_AMBIGUOUS_VALUE;
     return eRet;
 }
-
 PropertyState   SfxItemPropertySet::getPropertyState(
-                                const OUString& rName, const SfxItemSet& rSet)
+                                const OUString& rName, const SfxItemSet& rSet) const
                                     throw(UnknownPropertyException)
 {
     PropertyState eRet = PropertyState_DIRECT_VALUE;
 
     // which-id ermitteln
-    const SfxItemPropertyMap* pMap = SfxItemPropertyMap::GetByName( _pMap, rName );
-    USHORT nWhich = pMap ? pMap->nWID : 0;
-    if ( !nWhich )
+    const SfxItemPropertySimpleEntry* pEntry = m_aMap.getByName( rName );
+    if( !pEntry || !pEntry->nWID )
     {
         throw UnknownPropertyException();
     }
+    USHORT nWhich = pEntry->nWID;
 
     // item holen
     const SfxPoolItem* pItem = 0;
@@ -273,10 +391,33 @@ PropertyState   SfxItemPropertySet::getPropertyState(
 Reference<XPropertySetInfo>
     SfxItemPropertySet::getPropertySetInfo() const
 {
-    Reference<XPropertySetInfo> aRef(new SfxItemPropertySetInfo( _pMap ));
-    return aRef;
+    if( !m_xInfo.is() )
+        m_xInfo = new SfxItemPropertySetInfo( &m_aMap );
+    return m_xInfo;
+}
+/*-- 16.02.2009 13:49:25---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+struct SfxItemPropertySetInfo_Impl
+{
+    SfxItemPropertyMap*         m_pOwnMap;
+};
+/*-- 16.02.2009 13:49:24---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+SfxItemPropertySetInfo::SfxItemPropertySetInfo(const SfxItemPropertyMap *pMap ) :
+    m_pImpl( new SfxItemPropertySetInfo_Impl )
+{
+    m_pImpl->m_pOwnMap = new SfxItemPropertyMap( pMap );
 }
+/*-- 16.02.2009 13:49:25---------------------------------------------------
 
+  -----------------------------------------------------------------------*/
+SfxItemPropertySetInfo::SfxItemPropertySetInfo(const SfxItemPropertyMapEntry *pEntries ) :
+    m_pImpl( new SfxItemPropertySetInfo_Impl )
+{
+    m_pImpl->m_pOwnMap = new SfxItemPropertyMap( pEntries );
+}
 /* -----------------------------21.02.00 11:09--------------------------------
 
  ---------------------------------------------------------------------------*/
@@ -284,26 +425,23 @@ Sequence< Property > SAL_CALL
         SfxItemPropertySetInfo::getProperties(  )
             throw(RuntimeException)
 {
-    USHORT n = 0;
-    {
-        for ( const SfxItemPropertyMap *pMap = _pMap; pMap->pName; ++pMap )
-            ++n;
-    }
+    return m_pImpl->m_pOwnMap->getProperties();
+}
+/*-- 16.02.2009 13:49:27---------------------------------------------------
 
-    Sequence<Property> aPropSeq( n );
-    n = 0;
-    for ( const SfxItemPropertyMap *pMap = _pMap; pMap->pName; ++pMap )
-    {
-        aPropSeq.getArray()[n].Name = OUString::createFromAscii( pMap->pName );
-        aPropSeq.getArray()[n].Handle = pMap->nWID;
-        if(pMap->pType)
-            aPropSeq.getArray()[n].Type = *pMap->pType;
-        aPropSeq.getArray()[n].Attributes =
-            sal::static_int_cast< sal_Int16 >(pMap->nFlags);
-        n++;
-    }
+  -----------------------------------------------------------------------*/
+const SfxItemPropertyMap* SfxItemPropertySetInfo::getMap() const
+{
+    return m_pImpl->m_pOwnMap;
+}
+
+/*-- 16.02.2009 12:43:36---------------------------------------------------
 
-    return aPropSeq;
+  -----------------------------------------------------------------------*/
+SfxItemPropertySetInfo::~SfxItemPropertySetInfo()
+{
+    delete m_pImpl->m_pOwnMap;
+    delete m_pImpl;
 }
 /* -----------------------------21.02.00 11:27--------------------------------
 
@@ -312,22 +450,7 @@ Property SAL_CALL
         SfxItemPropertySetInfo::getPropertyByName( const ::rtl::OUString& rName )
             throw(UnknownPropertyException, RuntimeException)
 {
-    Property aProp;
-    for( const SfxItemPropertyMap *pMap = _pMap; pMap->pName; ++pMap )
-    {
-        if( rName.equalsAsciiL( pMap->pName, pMap->nNameLen ))
-        {
-            aProp.Name = rName;
-            aProp.Handle = pMap->nWID;
-            if(pMap->pType)
-                aProp.Type = *pMap->pType;
-            aProp.Attributes = sal::static_int_cast< sal_Int16 >(pMap->nFlags);
-            break;
-        }
-    }
-    if(!aProp.Name.getLength())
-        throw UnknownPropertyException();
-    return aProp;
+    return m_pImpl->m_pOwnMap->getPropertyByName( rName );
 }
 /* -----------------------------21.02.00 11:28--------------------------------
 
@@ -336,79 +459,23 @@ sal_Bool SAL_CALL
         SfxItemPropertySetInfo::hasPropertyByName( const ::rtl::OUString& rName )
             throw(RuntimeException)
 {
-    for ( const SfxItemPropertyMap *pMap = _pMap; pMap->pName; ++pMap )
-    {
-        if( rName.equalsAsciiL( pMap->pName, pMap->nNameLen ))
-            return TRUE;
-    }
-    return FALSE;
+    return m_pImpl->m_pOwnMap->hasPropertyByName( rName );
 }
 /* -----------------------------21.02.00 12:03--------------------------------
 
  ---------------------------------------------------------------------------*/
 SfxExtItemPropertySetInfo::SfxExtItemPropertySetInfo(
-                                const SfxItemPropertyMap *pMap,
+                                const SfxItemPropertyMapEntry *pMap,
                                 const Sequence<Property>& rPropSeq ) :
-                _pExtMap(pMap)
+                aExtMap( pMap )
 {
-    long nLen = rPropSeq.getLength();
-    long nExtLen = 0;
-    while(pMap[nExtLen].pName)
-        nExtLen++;
-    aPropertySeq.realloc(nExtLen + nLen);
-
-
-    long nNewLen = aPropertySeq.getLength();
-    Property* pNewArr = aPropertySeq.getArray();
-    long nCount1 = 0;//map
-    long nCount2 = 0;//sequence
-    long nDouble = 0;//Anzahl gleicher Property-Namen
-    BOOL bFromMap, bZero = FALSE;
+    aExtMap.mergeProperties( rPropSeq );
+}
+/*-- 16.02.2009 12:06:49---------------------------------------------------
 
-    const Property* pPropSeqArr = rPropSeq.getConstArray();
-    for( long i = 0; i < nNewLen; i++)
-    {
-        bFromMap = FALSE;
-        if(nCount1 < nExtLen && nCount2 < nLen)
-        {
-//          int nDiff = strcmp(pMap[nCount1].pName, OUStringToString(rPropSeq.getConstArray()[nCount2].Name, CHARSET_SYSTEM ));
-            sal_Int32 nDiff = pPropSeqArr[nCount2].Name.compareToAscii(pMap[nCount1].pName, pMap[nCount1].nNameLen );
-            if(nDiff > 0)
-            {
-                bFromMap = TRUE;
-            }
-            else if(0 == nDiff)
-            {
-                nDouble++;
-                bFromMap = TRUE;
-                nCount2++;
-            }
-        }
-        else
-        {
-            if(nCount1 < nExtLen)
-                bFromMap = TRUE;
-            else if(nCount2>= nLen)
-                bZero = TRUE;
-        }
-        if(bFromMap)
-        {
-            pNewArr[i].Name = OUString::createFromAscii( pMap[nCount1].pName );
-            pNewArr[i].Handle = pMap[nCount1].nWID;
-            if(pMap[nCount1].pType)
-                pNewArr[i].Type = *pMap[nCount1].pType;
-            pNewArr[i].Attributes = sal::static_int_cast< sal_Int16 >(
-                pMap[nCount1].nFlags);
-            nCount1++;
-        }
-        else if(!bZero)
-        {
-            pNewArr[i] = pPropSeqArr[nCount2];
-            nCount2++;
-        }
-    }
-    if(nDouble)
-        aPropertySeq.realloc(nExtLen + nLen - nDouble);
+  -----------------------------------------------------------------------*/
+SfxExtItemPropertySetInfo::~SfxExtItemPropertySetInfo()
+{
 }
 /* -----------------------------21.02.00 12:03--------------------------------
 
@@ -416,38 +483,24 @@ SfxExtItemPropertySetInfo::SfxExtItemPropertySetInfo(
 Sequence< Property > SAL_CALL
         SfxExtItemPropertySetInfo::getProperties(  ) throw(RuntimeException)
 {
-    return aPropertySeq;
+    return aExtMap.getProperties();
 }
 /* -----------------------------21.02.00 12:03--------------------------------
 
  ---------------------------------------------------------------------------*/
 Property SAL_CALL
-        SfxExtItemPropertySetInfo::getPropertyByName( const OUString& aPropertyName )
+        SfxExtItemPropertySetInfo::getPropertyByName( const OUString& rPropertyName )
             throw(UnknownPropertyException, RuntimeException)
 {
-    const Property* pPropArr = aPropertySeq.getConstArray();
-    long nLen = aPropertySeq.getLength();
-    for( long i = 0; i < nLen; i++)
-    {
-        if(aPropertyName == pPropArr[i].Name)
-            return pPropArr[i];
-    }
-    return Property();
+    return aExtMap.getPropertyByName( rPropertyName );
 }
 /* -----------------------------21.02.00 12:03--------------------------------
 
  ---------------------------------------------------------------------------*/
 sal_Bool SAL_CALL
-        SfxExtItemPropertySetInfo::hasPropertyByName( const OUString& aPropertyName )
+        SfxExtItemPropertySetInfo::hasPropertyByName( const OUString& rPropertyName )
             throw(RuntimeException)
 {
-    const Property* pPropArr = aPropertySeq.getConstArray();
-    long nLen = aPropertySeq.getLength();
-    for( long i = 0; i < nLen; i++)
-    {
-        if(aPropertyName == pPropArr[i].Name)
-            return TRUE;
-    }
-    return FALSE;
+    return aExtMap.hasPropertyByName( rPropertyName );
 }
 
diff --git a/svtools/source/misc/acceleratorexecute.cxx b/svtools/source/misc/acceleratorexecute.cxx
index b540a48347c5..3e2d63e0b622 100644
--- a/svtools/source/misc/acceleratorexecute.cxx
+++ b/svtools/source/misc/acceleratorexecute.cxx
@@ -79,7 +79,6 @@
 #include <vcl/window.hxx>
 #include <vcl/svapp.hxx>
 #include <vos/mutex.hxx>
-#include <comphelper/uieventslogger.hxx>
 
 //===============================================
 // namespace
@@ -257,22 +256,6 @@ sal_Bool AcceleratorExecute::execute(const css::awt::KeyEvent& aAWTKey)
     sal_Bool bRet = xDispatch.is();
     if ( bRet )
     {
-        if(::comphelper::UiEventsLogger::isEnabled() && m_xSMGR.is() && m_xDispatcher.is()) //#i88653#
-        {
-            try
-            {
-                css::uno::Reference< css::frame::XModuleManager > xModuleDetection(
-                    m_xSMGR->createInstance(::rtl::OUString::createFromAscii("com.sun.star.frame.ModuleManager")),
-                    css::uno::UNO_QUERY_THROW);
-
-                const ::rtl::OUString sModule = xModuleDetection->identify(m_xDispatcher);
-                css::uno::Sequence<css::beans::PropertyValue> source;
-                ::comphelper::UiEventsLogger::appendDispatchOrigin(source, sModule, ::rtl::OUString::createFromAscii("AcceleratorExecute"));
-                ::comphelper::UiEventsLogger::logDispatch(aURL, source);
-            }
-            catch(const css::uno::Exception&)
-                { }
-        }
         // Note: Such instance can be used one times only and destroy itself afterwards .-)
         AsyncAccelExec* pExec = AsyncAccelExec::createOnShotInstance(xDispatch, aURL);
         pExec->execAsync();
@@ -579,8 +562,8 @@ IMPL_LINK(AsyncAccelExec, impl_ts_asyncCallback, void*,)
     }
     catch(const css::lang::DisposedException&)
         {}
-    catch(const css::uno::RuntimeException&rEx)
-        { (void) rEx; throw; }
+    catch(const css::uno::RuntimeException& )
+        { throw; }
     catch(const css::uno::Exception&)
         {}
 
diff --git a/svtools/source/numbers/numfmuno.cxx b/svtools/source/numbers/numfmuno.cxx
index 5d9c88ec8760..7417367ec124 100644
--- a/svtools/source/numbers/numfmuno.cxx
+++ b/svtools/source/numbers/numfmuno.cxx
@@ -83,9 +83,9 @@ using namespace com::sun::star;
 
 //  alles ohne Which-ID, Map nur fuer PropertySetInfo
 
-const SfxItemPropertyMap* lcl_GetNumberFormatPropertyMap()
+const SfxItemPropertyMapEntry* lcl_GetNumberFormatPropertyMap()
 {
-    static SfxItemPropertyMap aNumberFormatPropertyMap_Impl[] =
+    static SfxItemPropertyMapEntry aNumberFormatPropertyMap_Impl[] =
     {
         {MAP_CHAR_LEN(PROPERTYNAME_FMTSTR),   0, &getCppuType((rtl::OUString*)0),beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
         {MAP_CHAR_LEN(PROPERTYNAME_LOCALE),   0, &getCppuType((lang::Locale*)0),beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
@@ -105,9 +105,9 @@ const SfxItemPropertyMap* lcl_GetNumberFormatPropertyMap()
     return aNumberFormatPropertyMap_Impl;
 }
 
-const SfxItemPropertyMap* lcl_GetNumberSettingsPropertyMap()
+const SfxItemPropertyMapEntry* lcl_GetNumberSettingsPropertyMap()
 {
-    static SfxItemPropertyMap aNumberSettingsPropertyMap_Impl[] =
+    static SfxItemPropertyMapEntry aNumberSettingsPropertyMap_Impl[] =
     {
         {MAP_CHAR_LEN(PROPERTYNAME_NOZERO),   0, &getBooleanCppuType(),         beans::PropertyAttribute::BOUND, 0},
         {MAP_CHAR_LEN(PROPERTYNAME_NULLDATE), 0, &getCppuType((util::Date*)0),  beans::PropertyAttribute::BOUND, 0},