swunolocking1: #i105557#: fix locking for SwXDocumentIndexMark:

 add Impl struct, and use UnoImplPtr to lock destructor.
 move all implementation details out of header, into Impl struct.
 disable broken SwClient iteration.
 make constructor private, and add factory function CreateXDocumentIndexMark.
 use new XUnoTunnel helpers.
 clean up the implementation a little.
 remove SwXDocumentIndexMark::GetObject().

5 files changed, 700 insertions, 496 deletions

diff --git a/sw/inc/unoidx.hxx b/sw/inc/unoidx.hxx
index c4737e0e68..4824068b3f 100644
--- a/sw/inc/unoidx.hxx
+++ b/sw/inc/unoidx.hxx
@@ -36,14 +36,13 @@
 #include <com/sun/star/text/XDocumentIndexMark.hpp>
 #include <com/sun/star/text/XDocumentIndex.hpp>
 
+#include <cppuhelper/implbase4.hxx>
 #include <cppuhelper/implbase5.hxx>
 
-#include <unoevtlstnr.hxx>
 #include <unocoll.hxx>
 #include <toxe.hxx>
 
 
-class SfxItemPropertySet;
 class SwTOXBaseSection;
 class SwTOXMark;
 class SwTOXType;
@@ -189,87 +188,129 @@ public:
 /* -----------------07.12.98 10:08-------------------
  *
  * --------------------------------------------------*/
-class SwXDocumentIndexMark : public cppu::WeakImplHelper4
-<
-    ::com::sun::star::text::XDocumentIndexMark,
-    ::com::sun::star::lang::XServiceInfo,
-    ::com::sun::star::beans::XPropertySet,
-    ::com::sun::star::lang::XUnoTunnel
->,
-        public SwClient
+typedef ::cppu::WeakImplHelper4
+<   ::com::sun::star::lang::XUnoTunnel
+,   ::com::sun::star::lang::XServiceInfo
+,   ::com::sun::star::beans::XPropertySet
+,   ::com::sun::star::text::XDocumentIndexMark
+> SwXDocumentIndexMark_Base;
+
+class SwXDocumentIndexMark
+    : public SwXDocumentIndexMark_Base
 {
-    SwEventListenerContainer	aLstnrCntnr;
-    SwDepend					aTypeDepend;
-    SwDoc* 						m_pDoc;
-    const SwTOXMark* 			m_pTOXMark;
-    const SfxItemPropertySet*   m_pPropSet;
-
-    sal_Bool					bIsDescriptor;
-    sal_Bool					bMainEntry;
-    TOXTypes 					eType;
-    sal_uInt16 						nLevel;
-    String						sAltText;
-    String 						sPrimaryKey;
-    String 						sSecondaryKey;
-    String                      sTextReading;
-    String                      sPrimaryKeyReading;
-    String                      sSecondaryKeyReading;
-    String 						sUserIndexName;
-
-    void 				InitMap(TOXTypes eToxType);
-protected:
+
+private:
+
+    class Impl;
+    ::sw::UnoImplPtr<Impl> m_pImpl;
+
     virtual ~SwXDocumentIndexMark();
-public:
-    SwXDocumentIndexMark(TOXTypes eToxType);
-    SwXDocumentIndexMark(const SwTOXType* pType,
-                        const SwTOXMark* pMark,
-                        SwDoc* pDc);
-    
 
-    TYPEINFO();
+    SwXDocumentIndexMark(SwDoc & rDoc,
+                SwTOXType & rType, const SwTOXMark & rMark);
 
-    static const ::com::sun::star::uno::Sequence< sal_Int8 > & getUnoTunnelId();
+public:
 
-    //XUnoTunnel
-    virtual sal_Int64 SAL_CALL getSomething( const ::com::sun::star::uno::Sequence< sal_Int8 >& aIdentifier ) throw(::com::sun::star::uno::RuntimeException);
+    /// descriptor
+    SwXDocumentIndexMark(const TOXTypes eToxType);
 
-    virtual rtl::OUString SAL_CALL getMarkEntry(void) throw( ::com::sun::star::uno::RuntimeException );
-    virtual void SAL_CALL setMarkEntry(const rtl::OUString& aIndexEntry) throw( ::com::sun::star::uno::RuntimeException );
+    static ::com::sun::star::uno::Reference<
+            ::com::sun::star::text::XDocumentIndexMark>
+        CreateXDocumentIndexMark(SwDoc & rDoc,
+                SwTOXType & rType, const SwTOXMark & rMark);
 
-    //XTextContent
-    virtual void SAL_CALL attach(const ::com::sun::star::uno::Reference< ::com::sun::star::text::XTextRange > & xTextRange) throw( ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException );
-    virtual ::com::sun::star::uno::Reference< ::com::sun::star::text::XTextRange >  SAL_CALL getAnchor(void) throw( ::com::sun::star::uno::RuntimeException );
+    static const ::com::sun::star::uno::Sequence< sal_Int8 > & getUnoTunnelId();
 
-    //XComponent
-    virtual void SAL_CALL dispose(void) throw( ::com::sun::star::uno::RuntimeException );
-    virtual void SAL_CALL addEventListener(const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener > & aListener) throw( ::com::sun::star::uno::RuntimeException );
-    virtual void SAL_CALL removeEventListener(const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener > & aListener) throw( ::com::sun::star::uno::RuntimeException );
+    // XUnoTunnel
+    virtual sal_Int64 SAL_CALL getSomething(
+            const ::com::sun::star::uno::Sequence< sal_Int8 >& rIdentifier)
+        throw (::com::sun::star::uno::RuntimeException);
 
-    //XPropertySet
-    virtual ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL getPropertySetInfo(  ) throw(::com::sun::star::uno::RuntimeException);
-    virtual void SAL_CALL setPropertyValue( const ::rtl::OUString& aPropertyName, const ::com::sun::star::uno::Any& aValue ) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::beans::PropertyVetoException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
-    virtual ::com::sun::star::uno::Any SAL_CALL getPropertyValue( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
-    virtual void SAL_CALL addPropertyChangeListener( const ::rtl::OUString& aPropertyName, const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyChangeListener >& xListener ) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
-    virtual void SAL_CALL removePropertyChangeListener( const ::rtl::OUString& aPropertyName, const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyChangeListener >& aListener ) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
-    virtual void SAL_CALL addVetoableChangeListener( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XVetoableChangeListener >& aListener ) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
-    virtual void SAL_CALL removeVetoableChangeListener( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XVetoableChangeListener >& aListener ) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
+    // XServiceInfo
+    virtual ::rtl::OUString SAL_CALL getImplementationName()
+        throw (::com::sun::star::uno::RuntimeException);
+    virtual sal_Bool SAL_CALL supportsService(
+            const ::rtl::OUString& rServiceName)
+        throw (::com::sun::star::uno::RuntimeException);
+    virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL
+        getSupportedServiceNames()
+        throw (::com::sun::star::uno::RuntimeException);
 
-    //XServiceInfo
-    virtual rtl::OUString SAL_CALL getImplementationName(void) throw( ::com::sun::star::uno::RuntimeException );
-    virtual BOOL SAL_CALL supportsService(const rtl::OUString& ServiceName) throw( ::com::sun::star::uno::RuntimeException );
-    virtual ::com::sun::star::uno::Sequence< rtl::OUString > SAL_CALL getSupportedServiceNames(void) throw( ::com::sun::star::uno::RuntimeException );
+    // XComponent
+    virtual void SAL_CALL dispose()
+        throw (::com::sun::star::uno::RuntimeException);
+    virtual void SAL_CALL addEventListener(
+            const ::com::sun::star::uno::Reference<
+                ::com::sun::star::lang::XEventListener > & xListener)
+        throw (::com::sun::star::uno::RuntimeException);
+    virtual void SAL_CALL removeEventListener(
+            const ::com::sun::star::uno::Reference<
+                ::com::sun::star::lang::XEventListener > & xListener)
+        throw (::com::sun::star::uno::RuntimeException);
 
-    //SwClient
-    virtual void Modify( SfxPoolItem *pOld, SfxPoolItem *pNew);
+    // XPropertySet
+    virtual ::com::sun::star::uno::Reference<
+                ::com::sun::star::beans::XPropertySetInfo > SAL_CALL
+        getPropertySetInfo()
+        throw (::com::sun::star::uno::RuntimeException);
+    virtual void SAL_CALL setPropertyValue(
+            const ::rtl::OUString& rPropertyName,
+            const ::com::sun::star::uno::Any& rValue)
+        throw (::com::sun::star::beans::UnknownPropertyException,
+                ::com::sun::star::beans::PropertyVetoException,
+                ::com::sun::star::lang::IllegalArgumentException,
+                ::com::sun::star::lang::WrappedTargetException,
+                ::com::sun::star::uno::RuntimeException);
+    virtual ::com::sun::star::uno::Any SAL_CALL getPropertyValue(
+            const ::rtl::OUString& rPropertyName)
+        throw (::com::sun::star::beans::UnknownPropertyException,
+                ::com::sun::star::lang::WrappedTargetException,
+                ::com::sun::star::uno::RuntimeException);
+    virtual void SAL_CALL addPropertyChangeListener(
+            const ::rtl::OUString& rPropertyName,
+            const ::com::sun::star::uno::Reference<
+                ::com::sun::star::beans::XPropertyChangeListener >& xListener)
+        throw (::com::sun::star::beans::UnknownPropertyException,
+                ::com::sun::star::lang::WrappedTargetException,
+                ::com::sun::star::uno::RuntimeException);
+    virtual void SAL_CALL removePropertyChangeListener(
+            const ::rtl::OUString& rPropertyName,
+            const ::com::sun::star::uno::Reference<
+                ::com::sun::star::beans::XPropertyChangeListener >& xListener)
+        throw (::com::sun::star::beans::UnknownPropertyException,
+                ::com::sun::star::lang::WrappedTargetException,
+                ::com::sun::star::uno::RuntimeException);
+    virtual void SAL_CALL addVetoableChangeListener(
+            const ::rtl::OUString& rPropertyName,
+            const ::com::sun::star::uno::Reference<
+                ::com::sun::star::beans::XVetoableChangeListener >& xListener)
+        throw (::com::sun::star::beans::UnknownPropertyException,
+                ::com::sun::star::lang::WrappedTargetException,
+                ::com::sun::star::uno::RuntimeException);
+    virtual void SAL_CALL removeVetoableChangeListener(
+            const ::rtl::OUString& rPropertyName,
+            const ::com::sun::star::uno::Reference<
+                ::com::sun::star::beans::XVetoableChangeListener >& xListener)
+        throw (::com::sun::star::beans::UnknownPropertyException,
+                ::com::sun::star::lang::WrappedTargetException,
+                ::com::sun::star::uno::RuntimeException);
 
-    void attachToRange(const ::com::sun::star::uno::Reference< ::com::sun::star::text::XTextRange > & xTextRange)throw( ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException );
+    // XTextContent
+    virtual void SAL_CALL attach(
+            const ::com::sun::star::uno::Reference<
+                ::com::sun::star::text::XTextRange > & xTextRange)
+        throw (::com::sun::star::lang::IllegalArgumentException,
+                ::com::sun::star::uno::RuntimeException);
+    virtual ::com::sun::star::uno::Reference<
+                ::com::sun::star::text::XTextRange > SAL_CALL getAnchor()
+        throw (::com::sun::star::uno::RuntimeException);
 
-    SwTOXType* 			GetTOXType() const {return (SwTOXType*)aTypeDepend.GetRegisteredIn();}
-    const SwTOXMark* 	GetTOXMark() const {return m_pTOXMark;}
+    // XDocumentIndexMark
+    virtual rtl::OUString SAL_CALL getMarkEntry()
+        throw (::com::sun::star::uno::RuntimeException);
+    virtual void SAL_CALL setMarkEntry(const rtl::OUString& rIndexEntry)
+        throw (::com::sun::star::uno::RuntimeException);
 
-    static SwXDocumentIndexMark*	GetObject(SwTOXType* pType, const SwTOXMark* pMark,
-                                                SwDoc* pDoc);
-    void				Invalidate();
 };
 
 /* -----------------05.05.99 12:27-------------------
diff --git a/sw/source/core/unocore/unoclbck.cxx b/sw/source/core/unocore/unoclbck.cxx
index 96ba9b2421..a05a37abf7 100644
--- a/sw/source/core/unocore/unoclbck.cxx
+++ b/sw/source/core/unocore/unoclbck.cxx
@@ -78,18 +78,8 @@ SwXFootnote* SwUnoCallBack::GetFootnote(const SwFmtFtn& rMark)
 /* -----------------------------27.11.00 17:15--------------------------------
 
  ---------------------------------------------------------------------------*/
-SwXDocumentIndexMark* SwUnoCallBack::GetTOXMark(const SwTOXMark& rMark)
+SwXDocumentIndexMark* SwUnoCallBack::GetTOXMark(const SwTOXMark& /*rMark*/)
 {
-    SwClientIter aIter( *this );
-    SwXDocumentIndexMark* pxIndexMark = (SwXDocumentIndexMark*)aIter.First( TYPE( SwXDocumentIndexMark ));
-    while(pxIndexMark)
-    {
-        const SwTOXMark* pMark = pxIndexMark->GetTOXMark();
-        if(pMark == &rMark)
-            return pxIndexMark;
-
-        pxIndexMark = (SwXDocumentIndexMark*)aIter.Next( );
-    }
     return 0;
 }
 
diff --git a/sw/source/core/unocore/unocrsrhelper.cxx b/sw/source/core/unocore/unocrsrhelper.cxx
index 739378f3fb..cb0aa83e22 100644
--- a/sw/source/core/unocore/unocrsrhelper.cxx
+++ b/sw/source/core/unocore/unocrsrhelper.cxx
@@ -314,9 +314,11 @@ sal_Bool getCrsrPropertyValue(const SfxItemPropertySimpleEntry& rEntry
                 if( pAny )
                 {
                     const SwTOXMark& rMark = pTxtAttr->GetTOXMark();
-                    uno::Reference< XDocumentIndexMark >  xRef = SwXDocumentIndexMark::GetObject(
-                            (SwTOXType*)rMark.GetTOXType(), &rMark, rPam.GetDoc());
-                    pAny->setValue(&xRef, ::getCppuType((uno::Reference<XDocumentIndex>*)0));
+                    const uno::Reference< text::XDocumentIndexMark > xRef =
+                        SwXDocumentIndexMark::CreateXDocumentIndexMark(
+                            *rPam.GetDoc(),
+                            *const_cast<SwTOXType*>(rMark.GetTOXType()), rMark);
+                    (*pAny) <<= xRef;
                 }
             }
             else
diff --git a/sw/source/core/unocore/unoidx.cxx b/sw/source/core/unocore/unoidx.cxx
index ee94746f0a..8e4d56e705 100644
--- a/sw/source/core/unocore/unoidx.cxx
+++ b/sw/source/core/unocore/unoidx.cxx
@@ -70,6 +70,7 @@
 #include <docsh.hxx>
 #include <chpfld.hxx>
 #include <SwStyleNameMapper.hxx>
+#include <unoevtlstnr.hxx>
 
 
 using namespace ::com::sun::star;
@@ -326,7 +327,7 @@ SwDocIndexDescriptorProperties_Impl::SwDocIndexDescriptorProperties_Impl(
 }
 
 static sal_uInt16
-lcl_TypeToPropertyMap(const TOXTypes eType)
+lcl_TypeToPropertyMap_Index(const TOXTypes eType)
 {
     switch (eType)
     {
@@ -363,7 +364,7 @@ public:
             SwTOXBaseSection const*const pBaseSection)
         : SwClient((pBaseSection) ? pBaseSection->GetFmt() : 0)
         , m_rPropSet(
-            *aSwMapProvider.GetPropertySet(lcl_TypeToPropertyMap(eType)))
+            *aSwMapProvider.GetPropertySet(lcl_TypeToPropertyMap_Index(eType)))
         , m_eTOXType(eType)
         , m_ListenerContainer(static_cast< ::cppu::OWeakObject* >(&rThis))
         , m_bIsDescriptor(0 == pBaseSection)
@@ -1264,8 +1265,9 @@ throw (beans::UnknownPropertyException, lang::WrappedTargetException,
                 for(USHORT i = 0; i < aMarks.Count(); i++)
                 {
                     pMark = aMarks.GetObject(i);
-                    pxMarks[i] = SwXDocumentIndexMark::GetObject(
-                        const_cast<SwTOXType*>(pType), pMark, m_pImpl->m_pDoc);
+                    pxMarks[i] = SwXDocumentIndexMark::CreateXDocumentIndexMark(
+                        *m_pImpl->m_pDoc,
+                        *const_cast<SwTOXType*>(pType), *pMark);
                 }
                 aRet <<= aXMarks;
             }
@@ -1552,6 +1554,165 @@ SwXDocumentIndex::setName(const OUString& rName) throw (uno::RuntimeException)
 /******************************************************************
  * SwXDocumentIndexMark
  ******************************************************************/
+/* -----------------21.04.99 09:36-------------------
+ *
+ * --------------------------------------------------*/
+static sal_uInt16
+lcl_TypeToPropertyMap_Mark(const TOXTypes eType)
+{
+    switch (eType)
+    {
+        case TOX_INDEX:         return PROPERTY_MAP_INDEX_MARK;
+        case TOX_CONTENT:       return PROPERTY_MAP_CNTIDX_MARK;
+        //case TOX_USER:
+        default:
+            return PROPERTY_MAP_USER_MARK;
+    }
+}
+
+class SwXDocumentIndexMark::Impl
+    : public SwClient
+{
+
+public:
+
+    SfxItemPropertySet const&   m_rPropSet;
+    const TOXTypes              m_eTOXType;
+    SwEventListenerContainer    m_ListenerContainer;
+    bool                        m_bIsDescriptor;
+    SwDepend                    m_TypeDepend;
+    const SwTOXMark *           m_pTOXMark;
+    SwDoc *                     m_pDoc;
+
+    sal_Bool                    m_bMainEntry;
+    sal_uInt16                  m_nLevel;
+    OUString                    m_sAltText;
+    OUString                    m_sPrimaryKey;
+    OUString                    m_sSecondaryKey;
+    OUString                    m_sTextReading;
+    OUString                    m_sPrimaryKeyReading;
+    OUString                    m_sSecondaryKeyReading;
+    OUString                    m_sUserIndexName;
+
+    Impl(   SwXDocumentIndexMark & rThis,
+            SwDoc *const pDoc,
+            const enum TOXTypes eType,
+            SwTOXType *const pType, SwTOXMark const*const pMark)
+        : SwClient((pDoc) ? pDoc->GetUnoCallBack() : 0)
+        , m_rPropSet(
+            *aSwMapProvider.GetPropertySet(lcl_TypeToPropertyMap_Mark(eType)))
+        , m_eTOXType(eType)
+        , m_ListenerContainer(static_cast< ::cppu::OWeakObject* >(&rThis))
+        , m_bIsDescriptor(0 == pMark)
+        , m_TypeDepend(this, pType)
+        , m_pTOXMark(pMark)
+        , m_pDoc(pDoc)
+        , m_bMainEntry(sal_False)
+        , m_nLevel(0)
+    {
+    }
+
+    SwTOXType * GetTOXType() const {
+        return static_cast<SwTOXType*>(
+                const_cast<SwModify *>(m_TypeDepend.GetRegisteredIn()));
+    }
+
+    void    Invalidate();
+
+    // SwClient
+    virtual void    Modify(SfxPoolItem *pOld, SfxPoolItem *pNew);
+
+};
+
+/* -----------------------------16.10.00 11:24--------------------------------
+
+ ---------------------------------------------------------------------------*/
+void SwXDocumentIndexMark::Impl::Invalidate()
+{
+    if (GetRegisteredIn())
+    {
+        const_cast<SwModify*>(GetRegisteredIn())->Remove(this);
+        if (m_TypeDepend.GetRegisteredIn())
+        {
+            const_cast<SwModify*>(m_TypeDepend.GetRegisteredIn())->Remove(
+                &m_TypeDepend);
+        }
+    }
+    m_ListenerContainer.Disposing();
+    m_pDoc = 0;
+    m_pTOXMark = 0;
+}
+
+/*-- 14.12.98 10:25:47---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+void SwXDocumentIndexMark::Impl::Modify(SfxPoolItem *pOld, SfxPoolItem *pNew)
+{
+    ClientModify(this, pOld, pNew);
+
+    if (!GetRegisteredIn()) // removed => dispose
+    {
+        Invalidate();
+    }
+    else if (pOld)
+    {
+        switch (pOld->Which())
+        {
+            case RES_TOXMARK_DELETED:
+                if (static_cast<const void*>(m_pTOXMark) ==
+                        static_cast<SwPtrMsgPoolItem *>(pOld)->pObject)
+                {
+                    Invalidate();
+                }
+                break;
+        }
+    }
+}
+
+/*-- 14.12.98 10:25:43---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+SwXDocumentIndexMark::SwXDocumentIndexMark(const TOXTypes eToxType)
+    : m_pImpl( new SwXDocumentIndexMark::Impl(*this, 0, eToxType, 0, 0) )
+{
+}
+/*-- 14.12.98 10:25:44---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+SwXDocumentIndexMark::SwXDocumentIndexMark(SwDoc & rDoc,
+                SwTOXType & rType, const SwTOXMark & rMark)
+    : m_pImpl( new SwXDocumentIndexMark::Impl(*this, &rDoc, rType.GetType(),
+                    &rType, &rMark) )
+{
+}
+/*-- 14.12.98 10:25:44---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+SwXDocumentIndexMark::~SwXDocumentIndexMark()
+{
+}
+
+uno::Reference<text::XDocumentIndexMark>
+SwXDocumentIndexMark::CreateXDocumentIndexMark(
+        SwDoc & rDoc, SwTOXType & rType, const SwTOXMark & rMark)
+{
+    // #i105557#: do not iterate over the registered clients: race condition
+    // to do this properly requires the SwXDocumentIndexMark to register at the
+    // format directly, not at the unocallback
+#if 0
+    SwClientIter aIter(*pType);
+    SwXDocumentIndexMark::Impl* pxMark = (SwXDocumentIndexMark::Impl*)
+                            aIter.First(TYPE(SwXDocumentIndexMark::Impl));
+    while( pxMark )
+    {
+        if(pxMark->m_pTOXMark == pMark)
+            return pxMark->m_rThis;
+        pxMark = (SwXDocumentIndexMark::Impl*)aIter.Next();
+    }
+#endif
+    return new SwXDocumentIndexMark(rDoc, rType, rMark);
+}
+
 /* -----------------------------10.03.00 18:02--------------------------------
 
  ---------------------------------------------------------------------------*/
@@ -1563,55 +1724,62 @@ const uno::Sequence< sal_Int8 > & SwXDocumentIndexMark::getUnoTunnelId()
 /* -----------------------------10.03.00 18:04--------------------------------
 
  ---------------------------------------------------------------------------*/
-sal_Int64 SAL_CALL SwXDocumentIndexMark::getSomething( const uno::Sequence< sal_Int8 >& rId )
-    throw(uno::RuntimeException)
+sal_Int64 SAL_CALL
+SwXDocumentIndexMark::getSomething(const uno::Sequence< sal_Int8 >& rId)
+throw (uno::RuntimeException)
 {
-    if( rId.getLength() == 16
-        && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
-                                        rId.getConstArray(), 16 ) )
-    {
-        return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >(this) );
-    }
-    return 0;
+    return ::sw::UnoTunnelImpl<SwXDocumentIndexMark>(rId, this);
 }
 
-TYPEINIT1(SwXDocumentIndexMark, SwClient)
-const sal_Char cBaseMark[]      = "com.sun.star.text.BaseIndexMark";
-const sal_Char cContentMark[]   = "com.sun.star.text.ContentIndexMark";
-const sal_Char cIdxMark[]       = "com.sun.star.text.DocumentIndexMark";
-const sal_Char cIdxMarkAsian[]  = "com.sun.star.text.DocumentIndexMarkAsian";
-const sal_Char cUserMark[]      = "com.sun.star.text.UserIndexMark";
-const sal_Char cTextContent[]   = "com.sun.star.text.TextContent";
+static const sal_Char cBaseMark[]      = "com.sun.star.text.BaseIndexMark";
+static const sal_Char cContentMark[]   = "com.sun.star.text.ContentIndexMark";
+static const sal_Char cIdxMark[]       = "com.sun.star.text.DocumentIndexMark";
+static const sal_Char cIdxMarkAsian[]  = "com.sun.star.text.DocumentIndexMarkAsian";
+static const sal_Char cUserMark[]      = "com.sun.star.text.UserIndexMark";
+static const sal_Char cTextContent[]   = "com.sun.star.text.TextContent";
+
 /* -----------------------------06.04.00 15:07--------------------------------
 
  ---------------------------------------------------------------------------*/
-OUString SwXDocumentIndexMark::getImplementationName(void) throw( uno::RuntimeException )
+OUString SAL_CALL
+SwXDocumentIndexMark::getImplementationName() throw (uno::RuntimeException)
 {
     return C2U("SwXDocumentIndexMark");
 }
 /* -----------------------------06.04.00 15:07--------------------------------
 
  ---------------------------------------------------------------------------*/
-BOOL SwXDocumentIndexMark::supportsService(const OUString& rServiceName) throw( uno::RuntimeException )
+sal_Bool SAL_CALL
+SwXDocumentIndexMark::supportsService(const OUString& rServiceName)
+throw (uno::RuntimeException)
 {
-    return !rServiceName.compareToAscii(cBaseMark)||
-        !rServiceName.compareToAscii(cTextContent) ||
-        (eType == TOX_USER && !rServiceName.compareToAscii(cUserMark)) ||
-        (eType == TOX_CONTENT && !rServiceName.compareToAscii(cContentMark)) ||
-        (eType == TOX_INDEX && !rServiceName.compareToAscii(cIdxMark)) ||
-        (eType == TOX_INDEX && !rServiceName.compareToAscii(cIdxMarkAsian));
+    vos::OGuard g(Application::GetSolarMutex());
+
+    return rServiceName.equalsAscii(cBaseMark)
+        || rServiceName.equalsAscii(cTextContent)
+        || ((m_pImpl->m_eTOXType == TOX_USER)
+                && rServiceName.equalsAscii(cUserMark))
+        || ((m_pImpl->m_eTOXType == TOX_CONTENT)
+                && rServiceName.equalsAscii(cContentMark))
+        || ((m_pImpl->m_eTOXType == TOX_INDEX)
+                && rServiceName.equalsAscii(cIdxMark))
+        || ((m_pImpl->m_eTOXType == TOX_INDEX)
+                && rServiceName.equalsAscii(cIdxMarkAsian));
 }
 /* -----------------------------06.04.00 15:07--------------------------------
 
  ---------------------------------------------------------------------------*/
-uno::Sequence< OUString > SwXDocumentIndexMark::getSupportedServiceNames(void) throw( uno::RuntimeException )
+uno::Sequence< OUString > SAL_CALL
+SwXDocumentIndexMark::getSupportedServiceNames() throw (uno::RuntimeException)
 {
-    INT32 nCnt = (eType == TOX_INDEX) ? 4 : 3;
+    vos::OGuard g(Application::GetSolarMutex());
+
+    const sal_Int32 nCnt = (m_pImpl->m_eTOXType == TOX_INDEX) ? 4 : 3;
     uno::Sequence< OUString > aRet(nCnt);
     OUString* pArray = aRet.getArray();
     pArray[0] = C2U(cBaseMark);
     pArray[1] = C2U(cTextContent);
-    switch(eType)
+    switch (m_pImpl->m_eTOXType)
     {
         case TOX_USER:
             pArray[2] = C2U(cUserMark);
@@ -1629,97 +1797,47 @@ uno::Sequence< OUString > SwXDocumentIndexMark::getSupportedServiceNames(void) t
     }
     return aRet;
 }
-/*-- 14.12.98 10:25:43---------------------------------------------------
-
-  -----------------------------------------------------------------------*/
-SwXDocumentIndexMark::SwXDocumentIndexMark(TOXTypes eToxType) :
-    aLstnrCntnr( (text::XTextContent*)this),
-    aTypeDepend(this, 0),
-    m_pDoc(0),
-    m_pTOXMark(0),
-    bIsDescriptor(sal_True),
-    bMainEntry(sal_False),
-    eType(eToxType),
-    nLevel(0)
-{
-    InitMap(eToxType);
-}
-/*-- 14.12.98 10:25:44---------------------------------------------------
-
-  -----------------------------------------------------------------------*/
-SwXDocumentIndexMark::SwXDocumentIndexMark(const SwTOXType* pType,
-                                    const SwTOXMark* pMark,
-                                    SwDoc* pDc) :
-    aLstnrCntnr( (text::XTextContent*)this),
-    aTypeDepend(this, (SwTOXType*)pType),
-    m_pDoc(pDc),
-    m_pTOXMark(pMark),
-    bIsDescriptor(sal_False),
-    bMainEntry(sal_False),
-    eType(pType->GetType()),
-    nLevel(0)
-{
-    m_pDoc->GetUnoCallBack()->Add(this);
-    InitMap(eType);
-}
-/*-- 14.12.98 10:25:44---------------------------------------------------
-
-  -----------------------------------------------------------------------*/
-SwXDocumentIndexMark::~SwXDocumentIndexMark()
-{
-
-}
-/* -----------------21.04.99 09:36-------------------
- *
- * --------------------------------------------------*/
-void SwXDocumentIndexMark::InitMap(TOXTypes eToxType)
-{
-    sal_uInt16 nMapId = PROPERTY_MAP_USER_MARK; //case TOX_USER:
-    switch( eToxType )
-    {
-        case TOX_INDEX:
-            nMapId = PROPERTY_MAP_INDEX_MARK ;
-        break;
-        case TOX_CONTENT:
-            nMapId = PROPERTY_MAP_CNTIDX_MARK;
-        break;
-        //case TOX_USER:
 
-        default:
-            ;
-    }
-    m_pPropSet = aSwMapProvider.GetPropertySet(nMapId);
-}
 /*-- 14.12.98 10:25:45---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-OUString SwXDocumentIndexMark::getMarkEntry(void) throw( uno::RuntimeException )
+OUString SAL_CALL
+SwXDocumentIndexMark::getMarkEntry() throw (uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
-    SwTOXType* pType = ((SwXDocumentIndexMark*)this)->GetTOXType();
+
     OUString sRet;
-    if(pType && m_pTOXMark)
+    SwTOXType *const pType = m_pImpl->GetTOXType();
+    if (pType && m_pImpl->m_pTOXMark)
     {
-        sRet = OUString(m_pTOXMark->GetAlternativeText());
+        sRet = OUString(m_pImpl->m_pTOXMark->GetAlternativeText());
+    }
+    else if (m_pImpl->m_bIsDescriptor)
+    {
+        sRet = m_pImpl->m_sAltText;
     }
-    else if(bIsDescriptor)
-         sRet = sAltText;
     else
+    {
         throw uno::RuntimeException();
+    }
     return sRet;
 }
 /*-- 14.12.98 10:25:45---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXDocumentIndexMark::setMarkEntry(const OUString& rIndexEntry) throw( uno::RuntimeException )
+void SAL_CALL
+SwXDocumentIndexMark::setMarkEntry(const OUString& rIndexEntry)
+throw (uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
-    SwTOXType* pType = ((SwXDocumentIndexMark*)this)->GetTOXType();
-    if(pType && m_pTOXMark)
+
+    SwTOXType *const pType = m_pImpl->GetTOXType();
+    if (pType && m_pImpl->m_pTOXMark)
     {
-        SwTOXMark aMark(*m_pTOXMark);
+        SwTOXMark aMark(*m_pImpl->m_pTOXMark);
         aMark.SetAlternativeText(rIndexEntry);
-        const SwTxtTOXMark* pTxtMark = m_pTOXMark->GetTxtTOXMark();
+        SwTxtTOXMark const*const pTxtMark =
+            m_pImpl->m_pTOXMark->GetTxtTOXMark();
         SwPaM aPam(pTxtMark->GetTxtNode(), *pTxtMark->GetStart());
         aPam.SetMark();
         if(pTxtMark->GetEnd())
@@ -1729,9 +1847,9 @@ void SwXDocumentIndexMark::setMarkEntry(const OUString& rIndexEntry) throw( uno:
         else
             aPam.GetPoint()->nContent++;
 
-        //die alte Marke loeschen
-        m_pDoc->DeleteTOXMark(m_pTOXMark);
-        m_pTOXMark = 0;
+        // delete old mark
+        m_pImpl->m_pDoc->DeleteTOXMark(m_pImpl->m_pTOXMark);
+        m_pImpl->m_pTOXMark = 0;
 
         SwTxtAttr* pTxtAttr = 0;
         sal_Bool bInsAtPos = aMark.IsAlternativeText();
@@ -1740,311 +1858,377 @@ void SwXDocumentIndexMark::setMarkEntry(const OUString& rIndexEntry) throw( uno:
         if( bInsAtPos )
         {
             SwPaM aTmp( *pStt );
-            m_pDoc->InsertPoolItem( aTmp, aMark, 0 );
+            m_pImpl->m_pDoc->InsertPoolItem( aTmp, aMark, 0 );
             pTxtAttr = pStt->nNode.GetNode().GetTxtNode()->GetTxtAttrForCharAt(
                         pStt->nContent.GetIndex()-1, RES_TXTATR_TOXMARK);
         }
         else if( *pEnd != *pStt )
         {
-            m_pDoc->InsertPoolItem( aPam, aMark,
+            m_pImpl->m_pDoc->InsertPoolItem( aPam, aMark,
                         nsSetAttrMode::SETATTR_DONTEXPAND );
             pTxtAttr = pStt->nNode.GetNode().GetTxtNode()->GetTxtAttr(
                                 pStt->nContent, RES_TXTATR_TOXMARK);
         }
-        //und sonst - Marke geloescht?
         if(pTxtAttr)
-            m_pTOXMark = &pTxtAttr->GetTOXMark();
+        {
+            m_pImpl->m_pTOXMark = &pTxtAttr->GetTOXMark();
+        }
     }
-    else if(bIsDescriptor)
+    else if (m_pImpl->m_bIsDescriptor)
     {
-        sAltText = rIndexEntry;
+        m_pImpl->m_sAltText = rIndexEntry;
     }
     else
+    {
         throw uno::RuntimeException();
+    }
 }
+
 /* -----------------18.02.99 13:40-------------------
  *
  * --------------------------------------------------*/
-void SwXDocumentIndexMark::attachToRange(const uno::Reference< text::XTextRange > & xTextRange)
-                throw( lang::IllegalArgumentException, uno::RuntimeException )
+void SAL_CALL
+SwXDocumentIndexMark::attach(
+        const uno::Reference< text::XTextRange > & xTextRange)
+throw (lang::IllegalArgumentException, uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
-    if(!bIsDescriptor)
-        throw uno::RuntimeException();
 
-    uno::Reference<XUnoTunnel> xRangeTunnel( xTextRange, uno::UNO_QUERY);
-    SwXTextRange* pRange = 0;
-    OTextCursorHelper* pCursor = 0;
-    if(xRangeTunnel.is())
+    if (!m_pImpl->m_bIsDescriptor)
     {
-        pRange 	= reinterpret_cast< SwXTextRange * >(
-                sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXTextRange::getUnoTunnelId()) ));
-        pCursor = reinterpret_cast< OTextCursorHelper * >(
-                sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
+        throw uno::RuntimeException();
     }
 
-    SwDoc* pDoc = pRange ? (SwDoc*)pRange->GetDoc() : pCursor ? (SwDoc*)pCursor->GetDoc() : 0;
+    const uno::Reference<XUnoTunnel> xRangeTunnel(xTextRange, uno::UNO_QUERY);
+    SwXTextRange *const pRange =
+        ::sw::UnoTunnelGetImplementation<SwXTextRange>(xRangeTunnel);
+    OTextCursorHelper *const pCursor =
+        ::sw::UnoTunnelGetImplementation<OTextCursorHelper>(xRangeTunnel);
+    SwDoc *const pDoc =
+        (pRange) ? pRange->GetDoc() : ((pCursor) ? pCursor->GetDoc() : 0);
+    if (!pDoc)
+    {
+        throw lang::IllegalArgumentException();
+    }
 
-    if(pDoc )
+    const SwTOXType* pTOXType = 0;
+    switch (m_pImpl->m_eTOXType)
     {
-        const SwTOXType* pTOXType = 0;
-        switch(eType)
+        case TOX_INDEX:
+        case TOX_CONTENT:
+            pTOXType = pDoc->GetTOXType( m_pImpl->m_eTOXType, 0 );
+        break;
+        case TOX_USER:
         {
-            case TOX_INDEX:
-            case TOX_CONTENT:
-                pTOXType = pDoc->GetTOXType( eType, 0 );
-            break;
-            case TOX_USER:
+            if (!m_pImpl->m_sUserIndexName.getLength())
             {
-                if(!sUserIndexName.Len())
-                    pTOXType = pDoc->GetTOXType( eType, 0 );
-                else
+                pTOXType = pDoc->GetTOXType( m_pImpl->m_eTOXType, 0 );
+            }
+            else
+            {
+                const sal_uInt16 nCount =
+                    pDoc->GetTOXTypeCount(m_pImpl->m_eTOXType);
+                for (sal_uInt16 i = 0; i < nCount; i++)
                 {
-                    sal_uInt16 nCount = pDoc->GetTOXTypeCount( eType);
-                    for(sal_uInt16 i = 0; i < nCount; i++)
+                    SwTOXType const*const pTemp =
+                        pDoc->GetTOXType( m_pImpl->m_eTOXType, i );
+                    if (m_pImpl->m_sUserIndexName ==
+                            OUString(pTemp->GetTypeName()))
                     {
-                        const SwTOXType* pTemp = pDoc->GetTOXType( eType, i );
-                        if(sUserIndexName == pTemp->GetTypeName())
-                        {
-                            pTOXType = pTemp;
-                            break;
-                        }
-                    }
-                    if(!pTOXType)
-                    {
-                        SwTOXType aUserType(TOX_USER, sUserIndexName);
-                        pTOXType = pDoc->InsertTOXType(aUserType);
+                        pTOXType = pTemp;
+                        break;
                     }
                 }
+                if (!pTOXType)
+                {
+                    SwTOXType aUserType(TOX_USER, m_pImpl->m_sUserIndexName);
+                    pTOXType = pDoc->InsertTOXType(aUserType);
+                }
             }
-            break;
-
-            default:
-                ;
         }
-        if(!pTOXType)
-            throw lang::IllegalArgumentException();
-        pDoc->GetUnoCallBack()->Add(this);
-        ((SwTOXType*)pTOXType)->Add(&aTypeDepend);
-
-        SwUnoInternalPaM aPam(*pDoc);
-        //das muss jetzt sal_True liefern
-        ::sw::XTextRangeToSwPaM(aPam, xTextRange);
-        SwTOXMark aMark (pTOXType);
-        if(sAltText.Len())
-            aMark.SetAlternativeText(sAltText);
-        switch(eType)
-        {
-            case TOX_INDEX:
-                if(sPrimaryKey.Len())
-                    aMark.SetPrimaryKey(sPrimaryKey);
-                if(sSecondaryKey.Len())
-                    aMark.SetSecondaryKey(sSecondaryKey);
-                if(sTextReading.Len())
-                    aMark.SetTextReading(sTextReading);
-                if(sPrimaryKeyReading.Len())
-                    aMark.SetPrimaryKeyReading(sPrimaryKeyReading);
-                if(sSecondaryKeyReading.Len())
-                    aMark.SetSecondaryKeyReading(sSecondaryKeyReading);
-                aMark.SetMainEntry(bMainEntry);
-            break;
-            case TOX_USER:
-            case TOX_CONTENT:
-                if(USHRT_MAX != nLevel)
-                    aMark.SetLevel(nLevel+1);
-            break;
+        break;
 
-            default:
-                ;
-        }
-        UnoActionContext aAction(pDoc);
-        sal_Bool bMark = *aPam.GetPoint() != *aPam.GetMark();
-        // Marks ohne Alternativtext ohne selektierten Text koennen nicht eingefuegt werden,
-        // deshalb hier ein Leerzeichen - ob das die ideale Loesung ist?
-        if(!bMark && !aMark.GetAlternativeText().Len())
-            aMark.SetAlternativeText( String(' ') );
-
-        SwXTextCursor const*const pTextCursor(
-                dynamic_cast<SwXTextCursor*>(pCursor));
-        const bool bForceExpandHints( (!bMark && pTextCursor)
-                ? pTextCursor->IsAtEndOfMeta() : false );
-        const SetAttrMode nInsertFlags = (bForceExpandHints)
-            ?   ( nsSetAttrMode::SETATTR_FORCEHINTEXPAND
-                | nsSetAttrMode::SETATTR_DONTEXPAND)
-            : nsSetAttrMode::SETATTR_DONTEXPAND;
-
-        pDoc->InsertPoolItem(aPam, aMark, nInsertFlags);
-        if( bMark && *aPam.GetPoint() > *aPam.GetMark())
-            aPam.Exchange();
+        default:
+        break;
+    }
+    if (!pTOXType)
+    {
+        throw lang::IllegalArgumentException();
+    }
+    pDoc->GetUnoCallBack()->Add(m_pImpl.get());
+    const_cast<SwTOXType*>(pTOXType)->Add(&m_pImpl->m_TypeDepend);
 
-        SwTxtAttr* pTxtAttr = 0;
-        if( bMark )
-            pTxtAttr = aPam.GetNode()->GetTxtNode()->GetTxtAttr(
-                            aPam.GetPoint()->nContent, RES_TXTATR_TOXMARK );
-        else
-        {
-            pTxtAttr = aPam.GetNode()->GetTxtNode()->GetTxtAttrForCharAt(
-                aPam.GetPoint()->nContent.GetIndex()-1, RES_TXTATR_TOXMARK );
-        }
+    SwUnoInternalPaM aPam(*pDoc);
+    //das muss jetzt sal_True liefern
+    ::sw::XTextRangeToSwPaM(aPam, xTextRange);
+    SwTOXMark aMark (pTOXType);
+    if (m_pImpl->m_sAltText.getLength())
+    {
+        aMark.SetAlternativeText(m_pImpl->m_sAltText);
+    }
+    switch (m_pImpl->m_eTOXType)
+    {
+        case TOX_INDEX:
+            if (m_pImpl->m_sPrimaryKey.getLength())
+            {
+                aMark.SetPrimaryKey(m_pImpl->m_sPrimaryKey);
+            }
+            if (m_pImpl->m_sSecondaryKey.getLength())
+            {
+                aMark.SetSecondaryKey(m_pImpl->m_sSecondaryKey);
+            }
+            if (m_pImpl->m_sTextReading.getLength())
+            {
+                aMark.SetTextReading(m_pImpl->m_sTextReading);
+            }
+            if (m_pImpl->m_sPrimaryKeyReading.getLength())
+            {
+                aMark.SetPrimaryKeyReading(m_pImpl->m_sPrimaryKeyReading);
+            }
+            if (m_pImpl->m_sSecondaryKeyReading.getLength())
+            {
+                aMark.SetSecondaryKeyReading(m_pImpl->m_sSecondaryKeyReading);
+            }
+            aMark.SetMainEntry(m_pImpl->m_bMainEntry);
+        break;
+        case TOX_USER:
+        case TOX_CONTENT:
+            if (USHRT_MAX != m_pImpl->m_nLevel)
+            {
+                aMark.SetLevel(m_pImpl->m_nLevel+1);
+            }
+        break;
 
-        if(pTxtAttr)
-        {
-            m_pTOXMark = &pTxtAttr->GetTOXMark();
-            m_pDoc = pDoc;
-            bIsDescriptor = sal_False;
-        }
-        else
-            throw uno::RuntimeException();
+        default:
+        break;
+    }
+    UnoActionContext aAction(pDoc);
+    const sal_Bool bMark = *aPam.GetPoint() != *aPam.GetMark();
+    // Marks ohne Alternativtext ohne selektierten Text koennen nicht eingefuegt werden,
+    // deshalb hier ein Leerzeichen - ob das die ideale Loesung ist?
+    if (!bMark && !aMark.GetAlternativeText().Len())
+    {
+        aMark.SetAlternativeText( String(' ') );
     }
-}
-/*-- 14.12.98 10:25:45---------------------------------------------------
 
-  -----------------------------------------------------------------------*/
-void SwXDocumentIndexMark::attach(const uno::Reference< text::XTextRange > & xTextRange)
-                throw( lang::IllegalArgumentException, uno::RuntimeException )
-{
-    vos::OGuard aGuard(Application::GetSolarMutex());
-    attachToRange( xTextRange );
+    SwXTextCursor const*const pTextCursor(
+            dynamic_cast<SwXTextCursor*>(pCursor));
+    const bool bForceExpandHints( (!bMark && pTextCursor)
+            ? pTextCursor->IsAtEndOfMeta() : false );
+    const SetAttrMode nInsertFlags = (bForceExpandHints)
+        ?   ( nsSetAttrMode::SETATTR_FORCEHINTEXPAND
+            | nsSetAttrMode::SETATTR_DONTEXPAND)
+        : nsSetAttrMode::SETATTR_DONTEXPAND;
+
+    pDoc->InsertPoolItem(aPam, aMark, nInsertFlags);
+    if (bMark && *aPam.GetPoint() > *aPam.GetMark())
+    {
+        aPam.Exchange();
+    }
+
+    SwTxtAttr* pTxtAttr = 0;
+    if (bMark)
+    {
+        pTxtAttr = aPam.GetNode()->GetTxtNode()->GetTxtAttr(
+                        aPam.GetPoint()->nContent, RES_TXTATR_TOXMARK );
+    }
+    else
+    {
+        pTxtAttr = aPam.GetNode()->GetTxtNode()->GetTxtAttrForCharAt(
+            aPam.GetPoint()->nContent.GetIndex()-1, RES_TXTATR_TOXMARK );
+    }
+
+    if (!pTxtAttr)
+    {
+        throw uno::RuntimeException();
+    }
+
+    m_pImpl->m_pTOXMark = &pTxtAttr->GetTOXMark();
+    m_pImpl->m_pDoc = pDoc;
+    m_pImpl->m_bIsDescriptor = sal_False;
 }
+
 /*-- 14.12.98 10:25:45---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-uno::Reference< text::XTextRange >  SwXDocumentIndexMark::getAnchor(void) throw( uno::RuntimeException )
+uno::Reference< text::XTextRange > SAL_CALL
+SwXDocumentIndexMark::getAnchor() throw (uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
-    uno::Reference< text::XTextRange >  aRet;
-    SwTOXType* pType = ((SwXDocumentIndexMark*)this)->GetTOXType();
-    if(pType && m_pTOXMark)
+
+    SwTOXType *const pType = m_pImpl->GetTOXType();
+    if (!pType || !m_pImpl->m_pTOXMark)
     {
-        if( m_pTOXMark->GetTxtTOXMark() )
-        {
-            const SwTxtTOXMark* pTxtMark = m_pTOXMark->GetTxtTOXMark();
-            SwPaM aPam(pTxtMark->GetTxtNode(), *pTxtMark->GetStart());
-            aPam.SetMark();
-            if(pTxtMark->GetEnd())
-            {
-                aPam.GetPoint()->nContent = *pTxtMark->GetEnd();
-            }
-            else
-                aPam.GetPoint()->nContent++;
-            uno::Reference< frame::XModel >  xModel = m_pDoc->GetDocShell()->GetBaseModel();
-            uno::Reference< text::XTextDocument > xTDoc(xModel, uno::UNO_QUERY);
-            aRet = new SwXTextRange(aPam, xTDoc->getText());
-        }
+        throw uno::RuntimeException();
     }
-    if(!aRet.is())
+    if (!m_pImpl->m_pTOXMark->GetTxtTOXMark())
+    {
         throw uno::RuntimeException();
-    return aRet;
+    }
+    const SwTxtTOXMark* pTxtMark = m_pImpl->m_pTOXMark->GetTxtTOXMark();
+    SwPaM aPam(pTxtMark->GetTxtNode(), *pTxtMark->GetStart());
+    aPam.SetMark();
+    if(pTxtMark->GetEnd())
+    {
+        aPam.GetPoint()->nContent = *pTxtMark->GetEnd();
+    }
+    else
+    {
+        aPam.GetPoint()->nContent++;
+    }
+    const uno::Reference< frame::XModel > xModel =
+        m_pImpl->m_pDoc->GetDocShell()->GetBaseModel();
+    const uno::Reference< text::XTextDocument > xTDoc(xModel, uno::UNO_QUERY);
+    const uno::Reference< text::XTextRange >  xRet =
+        new SwXTextRange(aPam, xTDoc->getText());
+
+    return xRet;
 }
+
 /*-- 14.12.98 10:25:45---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXDocumentIndexMark::dispose(void) throw( uno::RuntimeException )
+void SAL_CALL
+SwXDocumentIndexMark::dispose() throw (uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
-    SwTOXType* pType = ((SwXDocumentIndexMark*)this)->GetTOXType();
-    if(pType && m_pTOXMark)
+
+    SwTOXType *const pType = m_pImpl->GetTOXType();
+    if (pType && m_pImpl->m_pTOXMark)
     {
-        m_pDoc->DeleteTOXMark(m_pTOXMark);
+        m_pImpl->m_pDoc->DeleteTOXMark(m_pImpl->m_pTOXMark);
     }
-    else
-        throw uno::RuntimeException();
 }
 /*-- 14.12.98 10:25:45---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXDocumentIndexMark::addEventListener(const uno::Reference< lang::XEventListener > & aListener)
-    throw( uno::RuntimeException )
+void SAL_CALL
+SwXDocumentIndexMark::addEventListener(
+        const uno::Reference< lang::XEventListener > & xListener)
+throw (uno::RuntimeException)
 {
-    if(!GetRegisteredIn())
+    vos::OGuard g(Application::GetSolarMutex());
+
+    if (!m_pImpl->GetRegisteredIn())
+    {
         throw uno::RuntimeException();
-    aLstnrCntnr.AddListener(aListener);
+    }
+    m_pImpl->m_ListenerContainer.AddListener(xListener);
 }
 /*-- 14.12.98 10:25:46---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXDocumentIndexMark::removeEventListener(const uno::Reference< lang::XEventListener > & aListener)
-    throw( uno::RuntimeException )
+void SAL_CALL
+SwXDocumentIndexMark::removeEventListener(
+        const uno::Reference< lang::XEventListener > & xListener)
+throw (uno::RuntimeException)
 {
-    if(!GetRegisteredIn() || !aLstnrCntnr.RemoveListener(aListener))
+    vos::OGuard g(Application::GetSolarMutex());
+
+    if (!m_pImpl->GetRegisteredIn() ||
+        !m_pImpl->m_ListenerContainer.RemoveListener(xListener))
+    {
         throw uno::RuntimeException();
+    }
 }
+
 /*-- 14.12.98 10:25:46---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-uno::Reference< beans::XPropertySetInfo >  SwXDocumentIndexMark::getPropertySetInfo(void)
-    throw( uno::RuntimeException )
+uno::Reference< beans::XPropertySetInfo > SAL_CALL
+SwXDocumentIndexMark::getPropertySetInfo() throw (uno::RuntimeException)
 {
+    vos::OGuard g(Application::GetSolarMutex());
+
     static uno::Reference< beans::XPropertySetInfo >  xInfos[3];
     int nPos = 0;
-    switch(eType)
+    switch (m_pImpl->m_eTOXType)
     {
-        case TOX_INDEX: nPos = 0; break;
-        case TOX_CONTENT: nPos = 1; break;
-        case TOX_USER:  nPos = 2; break;
+        case TOX_INDEX:     nPos = 0; break;
+        case TOX_CONTENT:   nPos = 1; break;
+        case TOX_USER:      nPos = 2; break;
         default:
             ;
     }
     if(!xInfos[nPos].is())
     {
-        uno::Reference< beans::XPropertySetInfo >  xInfo = m_pPropSet->getPropertySetInfo();
+        const uno::Reference< beans::XPropertySetInfo > xInfo =
+            m_pImpl->m_rPropSet.getPropertySetInfo();
         // extend PropertySetInfo!
         const uno::Sequence<beans::Property> aPropSeq = xInfo->getProperties();
         xInfos[nPos] = new SfxExtItemPropertySetInfo(
-            aSwMapProvider.GetPropertyMapEntries(PROPERTY_MAP_PARAGRAPH_EXTENSIONS),
+            aSwMapProvider.GetPropertyMapEntries(
+                PROPERTY_MAP_PARAGRAPH_EXTENSIONS),
             aPropSeq );
     }
     return xInfos[nPos];
 }
+
 /*-- 14.12.98 10:25:46---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXDocumentIndexMark::setPropertyValue(const OUString& rPropertyName,
-                                            const uno::Any& aValue)
-    throw( beans::UnknownPropertyException, beans::PropertyVetoException,
-        lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException )
+void SAL_CALL
+SwXDocumentIndexMark::setPropertyValue(
+        const OUString& rPropertyName, const uno::Any& rValue)
+throw (beans::UnknownPropertyException, beans::PropertyVetoException,
+    lang::IllegalArgumentException, lang::WrappedTargetException,
+    uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
-    SwTOXType* pType = ((SwXDocumentIndexMark*)this)->GetTOXType();
-    const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName(rPropertyName);
+
+    SfxItemPropertySimpleEntry const*const pEntry =
+        m_pImpl->m_rPropSet.getPropertyMap()->getByName(rPropertyName);
     if (!pEntry)
-        throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
-    if ( pEntry->nFlags & beans::PropertyAttribute::READONLY)
-        throw beans::PropertyVetoException ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
-    if(pType && m_pTOXMark)
     {
-        SwDoc* pLocalDoc = m_pDoc;
+        throw beans::UnknownPropertyException(
+            OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: "))
+                + rPropertyName,
+            static_cast<cppu::OWeakObject *>(this));
+    }
+    if (pEntry->nFlags & beans::PropertyAttribute::READONLY)
+    {
+        throw beans::PropertyVetoException(
+            OUString(RTL_CONSTASCII_USTRINGPARAM("Property is read-only: "))
+                + rPropertyName,
+            static_cast<cppu::OWeakObject *>(this));
+    }
+
+    SwTOXType *const pType = m_pImpl->GetTOXType();
+    if (pType && m_pImpl->m_pTOXMark)
+    {
+        SwDoc* pLocalDoc = m_pImpl->m_pDoc;
 
-        SwTOXMark aMark(*m_pTOXMark);
+        SwTOXMark aMark(*m_pImpl->m_pTOXMark);
         switch(pEntry->nWID)
         {
             case WID_ALT_TEXT:
-                aMark.SetAlternativeText(lcl_AnyToString(aValue));
+                aMark.SetAlternativeText(lcl_AnyToString(rValue));
             break;
             case WID_LEVEL:
-                aMark.SetLevel(Min( (sal_Int8) ( MAXLEVEL ),
-                                    (sal_Int8)(lcl_AnyToInt16(aValue)+1)));
+                aMark.SetLevel(Min( static_cast<sal_Int8>( MAXLEVEL ),
+                            static_cast<sal_Int8>(lcl_AnyToInt16(rValue)+1)));
             break;
             case WID_PRIMARY_KEY  :
-                aMark.SetPrimaryKey(lcl_AnyToString(aValue));
+                aMark.SetPrimaryKey(lcl_AnyToString(rValue));
             break;
             case WID_SECONDARY_KEY:
-                aMark.SetSecondaryKey(lcl_AnyToString(aValue));
+                aMark.SetSecondaryKey(lcl_AnyToString(rValue));
             break;
             case WID_MAIN_ENTRY:
-                aMark.SetMainEntry(lcl_AnyToBool(aValue));
+                aMark.SetMainEntry(lcl_AnyToBool(rValue));
             break;
             case WID_TEXT_READING:
-                aMark.SetTextReading(lcl_AnyToString(aValue));
+                aMark.SetTextReading(lcl_AnyToString(rValue));
             break;
             case WID_PRIMARY_KEY_READING:
-                aMark.SetPrimaryKeyReading(lcl_AnyToString(aValue));
+                aMark.SetPrimaryKeyReading(lcl_AnyToString(rValue));
             break;
             case WID_SECONDARY_KEY_READING:
-                aMark.SetSecondaryKeyReading(lcl_AnyToString(aValue));
+                aMark.SetSecondaryKeyReading(lcl_AnyToString(rValue));
             break;
         }
-        const SwTxtTOXMark* pTxtMark = m_pTOXMark->GetTxtTOXMark();
+        SwTxtTOXMark const*const pTxtMark =
+            m_pImpl->m_pTOXMark->GetTxtTOXMark();
         SwPaM aPam(pTxtMark->GetTxtNode(), *pTxtMark->GetStart());
         aPam.SetMark();
         if(pTxtMark->GetEnd())
@@ -2052,15 +2236,17 @@ void SwXDocumentIndexMark::setPropertyValue(const OUString& rPropertyName,
             aPam.GetPoint()->nContent = *pTxtMark->GetEnd();
         }
         else
+        {
             aPam.GetPoint()->nContent++;
+        }
 
         //delete the old mark
-        pLocalDoc->DeleteTOXMark(m_pTOXMark);
-        m_pTOXMark = 0;
+        pLocalDoc->DeleteTOXMark(m_pImpl->m_pTOXMark);
+        m_pImpl->m_pTOXMark = 0;
 
         sal_Bool bInsAtPos = aMark.IsAlternativeText();
-        const SwPosition *pStt = aPam.Start(),
-                            *pEnd = aPam.End();
+        const SwPosition *pStt = aPam.Start();
+        const SwPosition *pEnd = aPam.End();
 
         SwTxtAttr* pTxtAttr = 0;
         if( bInsAtPos )
@@ -2077,101 +2263,120 @@ void SwXDocumentIndexMark::setPropertyValue(const OUString& rPropertyName,
             pTxtAttr = pStt->nNode.GetNode().GetTxtNode()->GetTxtAttr(
                             pStt->nContent, RES_TXTATR_TOXMARK );
         }
-        m_pDoc = pLocalDoc;
+        m_pImpl->m_pDoc = pLocalDoc;
 
         if(pTxtAttr)
         {
-            m_pTOXMark = &pTxtAttr->GetTOXMark();
-            m_pDoc->GetUnoCallBack()->Add(this);
-            pType->Add(&aTypeDepend);
+            m_pImpl->m_pTOXMark = &pTxtAttr->GetTOXMark();
+            m_pImpl->m_pDoc->GetUnoCallBack()->Add(m_pImpl.get());
+            pType->Add(&m_pImpl->m_TypeDepend);
         }
     }
-    else if(bIsDescriptor)
+    else if (m_pImpl->m_bIsDescriptor)
     {
         switch(pEntry->nWID)
         {
             case WID_ALT_TEXT:
-                sAltText = lcl_AnyToString(aValue);
+                m_pImpl->m_sAltText = lcl_AnyToString(rValue);
             break;
             case WID_LEVEL:
             {
-                sal_Int16 nVal = lcl_AnyToInt16(aValue);
+                const sal_Int16 nVal = lcl_AnyToInt16(rValue);
                 if(nVal >= 0 && nVal < MAXLEVEL)
-                    nLevel = nVal;
+                {
+                    m_pImpl->m_nLevel = nVal;
+                }
                 else
+                {
                     throw lang::IllegalArgumentException();
+                }
             }
             break;
-            case WID_PRIMARY_KEY  :
-                sPrimaryKey = lcl_AnyToString(aValue);
+            case WID_PRIMARY_KEY:
+                m_pImpl->m_sPrimaryKey = lcl_AnyToString(rValue);
             break;
             case WID_SECONDARY_KEY:
-                sSecondaryKey = lcl_AnyToString(aValue);
+                m_pImpl->m_sSecondaryKey = lcl_AnyToString(rValue);
             break;
             case WID_TEXT_READING:
-                sTextReading = lcl_AnyToString(aValue);
+                m_pImpl->m_sTextReading = lcl_AnyToString(rValue);
             break;
             case WID_PRIMARY_KEY_READING:
-                sPrimaryKeyReading = lcl_AnyToString(aValue);
+                m_pImpl->m_sPrimaryKeyReading = lcl_AnyToString(rValue);
             break;
             case WID_SECONDARY_KEY_READING:
-                sSecondaryKeyReading = lcl_AnyToString(aValue);
+                m_pImpl->m_sSecondaryKeyReading = lcl_AnyToString(rValue);
             break;
-            case WID_USER_IDX_NAME :
+            case WID_USER_IDX_NAME:
             {
-                OUString sTmp(lcl_AnyToString(aValue));
+                OUString sTmp(lcl_AnyToString(rValue));
                 lcl_ConvertTOUNameToUserName(sTmp);
-                sUserIndexName = sTmp;
+                m_pImpl->m_sUserIndexName = sTmp;
             }
             break;
             case WID_MAIN_ENTRY:
-                bMainEntry = lcl_AnyToBool(aValue);
+                m_pImpl->m_bMainEntry = lcl_AnyToBool(rValue);
             break;
         }
     }
     else
+    {
         throw uno::RuntimeException();
+    }
 }
+
 /*-- 14.12.98 10:25:46---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-uno::Any SwXDocumentIndexMark::getPropertyValue(const OUString& rPropertyName)
-    throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
+uno::Any SAL_CALL
+SwXDocumentIndexMark::getPropertyValue(const OUString& rPropertyName)
+throw (beans::UnknownPropertyException, lang::WrappedTargetException,
+        uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
+
     uno::Any aRet;
-    SwTOXType* pType = ((SwXDocumentIndexMark*)this)->GetTOXType();
-    const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName(rPropertyName);
+    SfxItemPropertySimpleEntry const*const pEntry =
+        m_pImpl->m_rPropSet.getPropertyMap()->getByName(rPropertyName);
     if (!pEntry)
-        throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
+    {
+        throw beans::UnknownPropertyException(
+            OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: "))
+                + rPropertyName,
+            static_cast<cppu::OWeakObject *>(this));
+    }
     if (::sw::GetDefaultTextContentValue(aRet, rPropertyName, pEntry->nWID))
     {
         return aRet;
     }
-    if(pType && m_pTOXMark)
+
+    SwTOXType *const pType = m_pImpl->GetTOXType();
+    if (pType && m_pImpl->m_pTOXMark)
     {
         switch(pEntry->nWID)
         {
             case WID_ALT_TEXT:
-                aRet <<= OUString(m_pTOXMark->GetAlternativeText());
+                aRet <<= OUString(m_pImpl->m_pTOXMark->GetAlternativeText());
             break;
             case WID_LEVEL:
-                aRet <<= (sal_Int16)(m_pTOXMark->GetLevel() - 1);
+                aRet <<= static_cast<sal_Int16>(
+                            m_pImpl->m_pTOXMark->GetLevel() - 1);
             break;
             case WID_PRIMARY_KEY  :
-                aRet <<= OUString(m_pTOXMark->GetPrimaryKey());
+                aRet <<= OUString(m_pImpl->m_pTOXMark->GetPrimaryKey());
             break;
             case WID_SECONDARY_KEY:
-                aRet <<= OUString(m_pTOXMark->GetSecondaryKey());
+                aRet <<= OUString(m_pImpl->m_pTOXMark->GetSecondaryKey());
             break;
             case WID_TEXT_READING:
-                aRet <<= OUString(m_pTOXMark->GetTextReading());
+                aRet <<= OUString(m_pImpl->m_pTOXMark->GetTextReading());
             break;
             case WID_PRIMARY_KEY_READING:
-                aRet <<= OUString(m_pTOXMark->GetPrimaryKeyReading());
+                aRet <<= OUString(m_pImpl->m_pTOXMark->GetPrimaryKeyReading());
             break;
             case WID_SECONDARY_KEY_READING:
-                aRet <<= OUString(m_pTOXMark->GetSecondaryKeyReading());
+                aRet <<= OUString(
+                        m_pImpl->m_pTOXMark->GetSecondaryKeyReading());
             break;
             case WID_USER_IDX_NAME :
             {
@@ -2182,136 +2387,101 @@ uno::Any SwXDocumentIndexMark::getPropertyValue(const OUString& rPropertyName)
             break;
             case WID_MAIN_ENTRY:
             {
-                sal_Bool bTemp = m_pTOXMark->IsMainEntry();
-                aRet.setValue(&bTemp, ::getBooleanCppuType());
+                const sal_Bool bTemp = m_pImpl->m_pTOXMark->IsMainEntry();
+                aRet <<= bTemp;
             }
             break;
         }
     }
-    else if(bIsDescriptor)
+    else if (m_pImpl->m_bIsDescriptor)
     {
         switch(pEntry->nWID)
         {
             case WID_ALT_TEXT:
-                aRet <<= OUString(sAltText);
+                aRet <<= m_pImpl->m_sAltText;
             break;
             case WID_LEVEL:
-                aRet <<= (sal_Int16)nLevel;
+                aRet <<= static_cast<sal_Int16>(m_pImpl->m_nLevel);
             break;
-            case WID_PRIMARY_KEY  :
-                aRet <<= OUString(sPrimaryKey);
+            case WID_PRIMARY_KEY:
+                aRet <<= m_pImpl->m_sPrimaryKey;
             break;
             case WID_SECONDARY_KEY:
-                aRet <<= OUString(sSecondaryKey);
+                aRet <<= m_pImpl->m_sSecondaryKey;
             break;
             case WID_TEXT_READING:
-                aRet <<= OUString(sTextReading);
+                aRet <<= m_pImpl->m_sTextReading;
             break;
             case WID_PRIMARY_KEY_READING:
-                aRet <<= OUString(sPrimaryKeyReading);
+                aRet <<= m_pImpl->m_sPrimaryKeyReading;
             break;
             case WID_SECONDARY_KEY_READING:
-                aRet <<= OUString(sSecondaryKeyReading);
+                aRet <<= m_pImpl->m_sSecondaryKeyReading;
             break;
             case WID_USER_IDX_NAME :
-                aRet <<= OUString(sUserIndexName);
+                aRet <<= m_pImpl->m_sUserIndexName;
             break;
             case WID_MAIN_ENTRY:
             {
-                aRet.setValue(&bMainEntry, ::getBooleanCppuType());
+                aRet <<= static_cast<sal_Bool>(m_pImpl->m_bMainEntry);
             }
             break;
         }
     }
     else
+    {
         throw uno::RuntimeException();
+    }
     return aRet;
 }
-/*-- 14.12.98 10:25:46---------------------------------------------------
 
-  -----------------------------------------------------------------------*/
-void SwXDocumentIndexMark::addPropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
-{
-    DBG_WARNING("not implemented");
-}
 /*-- 14.12.98 10:25:46---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXDocumentIndexMark::removePropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
-{
-    DBG_WARNING("not implemented");
-}
-/*-- 14.12.98 10:25:47---------------------------------------------------
-
-  -----------------------------------------------------------------------*/
-void SwXDocumentIndexMark::addVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
+void SAL_CALL
+SwXDocumentIndexMark::addPropertyChangeListener(
+        const ::rtl::OUString& /*rPropertyName*/,
+        const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
+throw (beans::UnknownPropertyException, lang::WrappedTargetException,
+    uno::RuntimeException)
 {
-    DBG_WARNING("not implemented");
+    OSL_ENSURE(false,
+        "SwXDocumentIndexMark::addPropertyChangeListener(): not implemented");
 }
-/*-- 14.12.98 10:25:47---------------------------------------------------
 
-  -----------------------------------------------------------------------*/
-void SwXDocumentIndexMark::removeVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
+void SAL_CALL
+SwXDocumentIndexMark::removePropertyChangeListener(
+        const ::rtl::OUString& /*rPropertyName*/,
+        const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
+throw (beans::UnknownPropertyException, lang::WrappedTargetException,
+    uno::RuntimeException)
 {
-    DBG_WARNING("not implemented");
+    OSL_ENSURE(false,
+    "SwXDocumentIndexMark::removePropertyChangeListener(): not implemented");
 }
-/*-- 14.12.98 10:25:47---------------------------------------------------
 
-  -----------------------------------------------------------------------*/
-SwXDocumentIndexMark*	SwXDocumentIndexMark::GetObject(SwTOXType* pType,
-                                    const SwTOXMark* pMark,	SwDoc* pDoc)
+void SAL_CALL
+SwXDocumentIndexMark::addVetoableChangeListener(
+        const ::rtl::OUString& /*rPropertyName*/,
+        const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
+throw (beans::UnknownPropertyException, lang::WrappedTargetException,
+    uno::RuntimeException)
 {
-    SwClientIter aIter(*pType);
-    SwXDocumentIndexMark* pxMark = (SwXDocumentIndexMark*)
-                                            aIter.First(TYPE(SwXDocumentIndexMark));
-    while( pxMark )
-    {
-        if(pxMark->m_pTOXMark == pMark)
-            return pxMark;
-        pxMark = (SwXDocumentIndexMark*)aIter.Next();
-    }
-    return new SwXDocumentIndexMark(pType, pMark, pDoc);
+    OSL_ENSURE(false,
+        "SwXDocumentIndexMark::addVetoableChangeListener(): not implemented");
 }
-/*-- 14.12.98 10:25:47---------------------------------------------------
 
-  -----------------------------------------------------------------------*/
-void SwXDocumentIndexMark::Modify( SfxPoolItem *pOld, SfxPoolItem *pNew)
+void SAL_CALL
+SwXDocumentIndexMark::removeVetoableChangeListener(
+        const ::rtl::OUString& /*rPropertyName*/,
+        const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
+throw (beans::UnknownPropertyException, lang::WrappedTargetException,
+        uno::RuntimeException)
 {
-    switch( pOld ? pOld->Which() : 0 )
-    {
-    case RES_REMOVE_UNO_OBJECT:
-    case RES_OBJECTDYING:
-        if( (void*)GetRegisteredIn() == ((SwPtrMsgPoolItem *)pOld)->pObject )
-            Invalidate();
-        break;
-
-    case RES_FMT_CHG:
-        // wurden wir an das neue umgehaengt und wird das alte geloscht?
-        if( ((SwFmtChg*)pNew)->pChangedFmt == GetRegisteredIn() &&
-            ((SwFmtChg*)pOld)->pChangedFmt->IsFmtInDTOR() )
-            Invalidate();
-        break;
-    case  RES_TOXMARK_DELETED:
-        if( (void*)m_pTOXMark == ((SwPtrMsgPoolItem *)pOld)->pObject )
-            Invalidate();
-        break;
-    }
+    OSL_ENSURE(false,
+    "SwXDocumentIndexMark::removeVetoableChangeListener(): not implemented");
 }
-/* -----------------------------16.10.00 11:24--------------------------------
 
- ---------------------------------------------------------------------------*/
-void SwXDocumentIndexMark::Invalidate()
-{
-    if(GetRegisteredIn())
-    {
-        ((SwModify*)GetRegisteredIn())->Remove(this);
-        if(aTypeDepend.GetRegisteredIn())
-            ((SwModify*)aTypeDepend.GetRegisteredIn())->Remove(&aTypeDepend);
-        aLstnrCntnr.Disposing();
-        m_pTOXMark = 0;
-        m_pDoc = 0;
-    }
-}
 
 /******************************************************************
  * SwXDocumentIndexes
diff --git a/sw/source/core/unocore/unoportenum.cxx b/sw/source/core/unocore/unoportenum.cxx
index 10c6c1eb07..cf5853b06b 100644
--- a/sw/source/core/unocore/unoportenum.cxx
+++ b/sw/source/core/unocore/unoportenum.cxx
@@ -481,8 +481,9 @@ lcl_CreateTOXMarkPortion(
         ->GetTOXMark(rTOXMark);
     if (!xContent.is())
     {
-        xContent = new SwXDocumentIndexMark(rTOXMark.GetTOXType(),
-                       &rTOXMark, pDoc);
+        xContent.set( SwXDocumentIndexMark::CreateXDocumentIndexMark(*pDoc,
+                    *const_cast<SwTOXType*>(rTOXMark.GetTOXType()), rTOXMark),
+            uno::UNO_QUERY);
     }
 
     SwXTextPortion* pPortion = 0;