swunolocking1: #i105557#: fix locking for SwXParagraph:

 add Impl struct, and use UnoImplPtr to lock destructor.
 move all implementation details out of header, into Impl struct.
 make SwXParagraph instances reusable with a WeakReference in SwTxtNode.
 make constructor private, and add factory function CreateXParagraph.
 use new XUnoTunnel and XServiceInfo helpers.
 clean up the implementation a little.

4 files changed, 725 insertions, 473 deletions

diff --git a/sw/source/core/unocore/unodraw.cxx b/sw/source/core/unocore/unodraw.cxx
index b967f59f4899..9a2eb1dfae45 100644
--- a/sw/source/core/unocore/unodraw.cxx
+++ b/sw/source/core/unocore/unodraw.cxx
@@ -2158,7 +2158,9 @@ void SwXShape::attach(const uno::Reference< text::XTextRange > & xTextRange)
             pDoc = pPortion->GetCursor()->GetDoc();
         }
         else if ( !pDoc && pParagraph && pParagraph->GetTxtNode( ) )
-            pDoc = pParagraph->GetTxtNode( )->GetDoc( );
+        {
+            pDoc = const_cast<SwDoc*>(pParagraph->GetTxtNode()->GetDoc());
+        }
 
     }
 
diff --git a/sw/source/core/unocore/unoobj2.cxx b/sw/source/core/unocore/unoobj2.cxx
index a7f6119e5962..b5c2ea2a6993 100644
--- a/sw/source/core/unocore/unoobj2.cxx
+++ b/sw/source/core/unocore/unoobj2.cxx
@@ -1169,9 +1169,9 @@ uno::Reference< XTextContent > SAL_CALL SwXParagraphEnumeration::NextElement_Imp
             }
             else
             {
-                aRef = new SwXParagraph(static_cast<SwXText*>(pText),
-                    pStart->nNode.GetNode().GetTxtNode(),
-                    nFirstContent, nLastContent);
+                aRef = SwXParagraph::CreateXParagraph(*pUnoCrsr->GetDoc(),
+                    *pStart->nNode.GetNode().GetTxtNode(),
+                    static_cast<SwXText*>(pText), nFirstContent, nLastContent);
             }
         }
     }
@@ -1528,15 +1528,7 @@ sal_Bool SwXTextRange::XTextRangeToSwPaM( SwUnoInternalPaM& rToFill,
     {
         if (pPara)
         {
-            const SwTxtNode * pTxtNode( pPara->GetTxtNode() );
-
-            if (pTxtNode) {
-                bRet = sal_True;
-                *rToFill.GetPoint() = SwPosition( *pTxtNode );
-                // set selection to the whole paragraph
-                rToFill.SetMark();
-                rToFill.GetMark()->nContent = pTxtNode->GetTxt().Len();
-            }
+            bRet = pPara->SelectPaM(rToFill);
         }
         else
         {
diff --git a/sw/source/core/unocore/unoparagraph.cxx b/sw/source/core/unocore/unoparagraph.cxx
index 22611e0b8e5b..404a93005a19 100644
--- a/sw/source/core/unocore/unoparagraph.cxx
+++ b/sw/source/core/unocore/unoparagraph.cxx
@@ -31,13 +31,13 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
+#include <unoparagraph.hxx>
 #include <cmdid.h>
 #include <unomid.h>
 #include <unoparaframeenum.hxx>
 #include <unotext.hxx>
 #include <unotextrange.hxx>
 #include <unotextcursor.hxx>
-#include <unoparagraph.hxx>
 #include <unoport.hxx>
 #include <unomap.hxx>
 #include <unocrsr.hxx>
@@ -60,6 +60,7 @@
 #include <com/sun/star/text/WrapTextMode.hpp>
 #include <com/sun/star/text/TextContentAnchorType.hpp>
 
+
 using namespace ::com::sun::star;
 using ::rtl::OUString;
 
@@ -69,38 +70,38 @@ using ::rtl::OUString;
  ---------------------------------------------------------------------------*/
 class SwParaSelection
 {
-    SwCursor* m_pCursor;
+    SwCursor & m_rCursor;
 public:
-    SwParaSelection(SwCursor* pPam);
+    SwParaSelection(SwCursor & rCursor);
     ~SwParaSelection();
 };
 
-SwParaSelection::SwParaSelection(SwCursor* pCursor)
-    : m_pCursor(pCursor)
+SwParaSelection::SwParaSelection(SwCursor & rCursor)
+    : m_rCursor(rCursor)
 {
-    if (m_pCursor->HasMark())
+    if (m_rCursor.HasMark())
     {
-        m_pCursor->DeleteMark();
+        m_rCursor.DeleteMark();
     }
     // is it at the start?
-    if (m_pCursor->GetPoint()->nContent != 0)
+    if (m_rCursor.GetPoint()->nContent != 0)
     {
-        m_pCursor->MovePara(fnParaCurr, fnParaStart);
+        m_rCursor.MovePara(fnParaCurr, fnParaStart);
     }
     // or at the end already?
-    if (m_pCursor->GetPoint()->nContent != m_pCursor->GetCntntNode()->Len())
+    if (m_rCursor.GetPoint()->nContent != m_rCursor.GetCntntNode()->Len())
     {
-        m_pCursor->SetMark();
-        m_pCursor->MovePara(fnParaCurr, fnParaEnd);
+        m_rCursor.SetMark();
+        m_rCursor.MovePara(fnParaCurr, fnParaEnd);
     }
 }
 
 SwParaSelection::~SwParaSelection()
 {
-    if (m_pCursor->GetPoint()->nContent != 0)
+    if (m_rCursor.GetPoint()->nContent != 0)
     {
-        m_pCursor->DeleteMark();
-        m_pCursor->MovePara(fnParaCurr, fnParaStart);
+        m_rCursor.DeleteMark();
+        m_rCursor.MovePara(fnParaCurr, fnParaStart);
     }
 }
 
@@ -114,25 +115,184 @@ beans::PropertyState lcl_SwXParagraph_getPropertyState(
                             const SwAttrSet** ppSet,
                             const SfxItemPropertySimpleEntry& rEntry,
                             sal_Bool &rAttrSetFetched )
-                                throw( beans::UnknownPropertyException);
+    throw (beans::UnknownPropertyException);
 
 /******************************************************************
  * SwXParagraph
  ******************************************************************/
 
-TYPEINIT1(SwXParagraph, SwClient);
+class SwXParagraph::Impl
+    : public SwClient
+{
 
-/* -----------------------------11.07.00 12:10--------------------------------
+public:
+    SwXParagraph &              m_rThis;
+    SwEventListenerContainer    m_ListenerContainer;
+    SfxItemPropertySet const&   m_rPropSet;
+    bool                        m_bIsDescriptor;
+    sal_Int32                   m_nSelectionStartPos;
+    sal_Int32                   m_nSelectionEndPos;
+    ::rtl::OUString             m_sText;
+    uno::Reference<text::XText> m_xParentText;
+
+    Impl(   SwXParagraph & rThis,
+            SwTxtNode *const pTxtNode = 0,
+            uno::Reference< text::XText > const & xParent = 0,
+            const sal_Int32 nSelStart = -1, const sal_Int32 nSelEnd = -1)
+        : SwClient(pTxtNode)
+        , m_rThis(rThis)
+        , m_ListenerContainer(static_cast< ::cppu::OWeakObject* >(&rThis))
+        , m_rPropSet(*aSwMapProvider.GetPropertySet(PROPERTY_MAP_PARAGRAPH))
+        , m_bIsDescriptor(0 == pTxtNode)
+        , m_nSelectionStartPos(nSelStart)
+        , m_nSelectionEndPos(nSelEnd)
+        , m_xParentText(xParent)
+    {
+    }
 
- ---------------------------------------------------------------------------*/
-SwXParagraph* SwXParagraph::GetImplementation(uno::Reference< XInterface> xRef )
+    const SwTxtNode * GetTxtNode() const {
+        return static_cast<const SwTxtNode*>(GetRegisteredIn());
+    }
+          SwTxtNode * GetTxtNode()       {
+        return static_cast<SwTxtNode*>(pRegisteredIn);
+    }
+
+    SwTxtNode & GetTxtNodeOrThrow() {
+        SwTxtNode *const pTxtNode( GetTxtNode() );
+        if (!pTxtNode) {
+            throw uno::RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
+                    "SwXParagraph: disposed or invalid")), 0);
+        }
+        return *pTxtNode;
+    }
+
+    bool IsDescriptor() const { return m_bIsDescriptor; }
+
+    void SetPropertyValues_Impl(
+            const uno::Sequence< ::rtl::OUString >& rPropertyNames,
+            const uno::Sequence< uno::Any >& rValues)
+        throw (beans::UnknownPropertyException, beans::PropertyVetoException,
+                lang::IllegalArgumentException, lang::WrappedTargetException,
+                uno::RuntimeException);
+
+    uno::Sequence< uno::Any >
+        GetPropertyValues_Impl(
+            const uno::Sequence< ::rtl::OUString >& rPropertyNames)
+        throw (beans::UnknownPropertyException, lang::WrappedTargetException,
+                uno::RuntimeException);
+
+    uno::Sequence< beans::GetDirectPropertyTolerantResult >
+        GetPropertyValuesTolerant_Impl(
+            const uno::Sequence< ::rtl::OUString >& rPropertyNames,
+            bool bDirectValuesOnly)
+        throw (uno::RuntimeException);
+
+    // SwClient
+    virtual void    Modify(SfxPoolItem *pOld, SfxPoolItem *pNew);
+
+};
+
+/*-- 11.12.98 08:12:58---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+void SwXParagraph::Impl::Modify(SfxPoolItem *pOld, SfxPoolItem *pNew)
+{
+    ClientModify(this, pOld, pNew);
+    if (!GetRegisteredIn())
+    {
+        m_ListenerContainer.Disposing();
+    }
+}
+
+/*-- 11.12.98 08:12:47---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+SwXParagraph::SwXParagraph()
+    : m_pImpl( new SwXParagraph::Impl(*this) )
+{
+}
+
+/*-- 11.12.98 08:12:47---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+SwXParagraph::SwXParagraph(
+        uno::Reference< text::XText > const & xParent,
+        SwTxtNode & rTxtNode,
+        const sal_Int32 nSelStart, const sal_Int32 nSelEnd)
+    : m_pImpl(
+        new SwXParagraph::Impl(*this, &rTxtNode, xParent, nSelStart, nSelEnd))
 {
-    uno::Reference<lang::XUnoTunnel> xParaTunnel( xRef, uno::UNO_QUERY);
-    if(xParaTunnel.is())
-        return reinterpret_cast< SwXParagraph * >(
-                sal::static_int_cast< sal_IntPtr >( xParaTunnel->getSomething(SwXParagraph::getUnoTunnelId()) ));
-    return 0;
 }
+
+/*-- 11.12.98 08:12:48---------------------------------------------------
+
+  -----------------------------------------------------------------------*/
+SwXParagraph::~SwXParagraph()
+{
+}
+
+const SwTxtNode * SwXParagraph::GetTxtNode() const
+{
+    return m_pImpl->GetTxtNode();
+}
+
+bool SwXParagraph::IsDescriptor() const
+{
+    return m_pImpl->IsDescriptor();
+}
+
+uno::Reference<text::XTextContent>
+SwXParagraph::CreateXParagraph(SwDoc & rDoc, SwTxtNode& rTxtNode,
+        uno::Reference< text::XText> const& i_xParent,
+        const sal_Int32 nSelStart, const sal_Int32 nSelEnd)
+{
+    // re-use existing SwXParagraph
+    // #i105557#: do not iterate over the registered clients: race condition
+    uno::Reference<text::XTextContent> xParagraph;
+    if ((-1 == nSelStart) && (-1 == nSelEnd)) // only use cache if no selection!
+    {
+        xParagraph.set(rTxtNode.GetXParagraph());
+    }
+    if (xParagraph.is())
+    {
+        return xParagraph;
+    }
+
+    // create new SwXParagraph
+    uno::Reference<text::XText> xParentText(i_xParent);
+    if (!xParentText.is())
+    {
+        SwPosition Pos( rTxtNode );
+        xParentText.set(SwXTextRange::CreateParentXText( &rDoc, Pos ));
+    }
+    SwXParagraph *const pXPara(
+            new SwXParagraph(xParentText, rTxtNode, nSelStart, nSelEnd) );
+    // this is why the constructor is private: need to acquire pXPara here
+    xParagraph.set(pXPara);
+    // in order to initialize the weak pointer cache in the core object
+    if ((-1 == nSelStart) && (-1 == nSelEnd))
+    {
+        rTxtNode.SetXParagraph(xParagraph);
+    }
+    return xParagraph;
+}
+
+bool SwXParagraph::SelectPaM(SwPaM & rPaM)
+{
+    SwTxtNode const*const pTxtNode( GetTxtNode() );
+
+    if (!pTxtNode)
+    {
+        return false;
+    }
+
+    *rPaM.GetPoint() = SwPosition( *pTxtNode );
+    // set selection to the whole paragraph
+    rPaM.SetMark();
+    rPaM.GetMark()->nContent = pTxtNode->GetTxt().Len();
+    return true;
+}
+
 /* -----------------------------13.03.00 12:15--------------------------------
 
  ---------------------------------------------------------------------------*/
@@ -144,191 +304,176 @@ const uno::Sequence< sal_Int8 > & SwXParagraph::getUnoTunnelId()
 /* -----------------------------10.03.00 18:04--------------------------------
 
  ---------------------------------------------------------------------------*/
-sal_Int64 SAL_CALL SwXParagraph::getSomething( const uno::Sequence< sal_Int8 >& rId )
-    throw(uno::RuntimeException)
+sal_Int64 SAL_CALL
+SwXParagraph::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<SwXParagraph>(rId, this);
 }
-/* -----------------------------06.04.00 16:37--------------------------------
 
- ---------------------------------------------------------------------------*/
-OUString SwXParagraph::getImplementationName(void) throw( uno::RuntimeException )
-{
-    return C2U("SwXParagraph");
-}
 /* -----------------------------06.04.00 16:37--------------------------------
 
  ---------------------------------------------------------------------------*/
-BOOL SwXParagraph::supportsService(const OUString& rServiceName) throw( uno::RuntimeException )
+OUString SAL_CALL
+SwXParagraph::getImplementationName() throw (uno::RuntimeException)
 {
-    String sServiceName(rServiceName);
-    return sServiceName.EqualsAscii("com.sun.star.text.TextContent") ||
-        sServiceName.EqualsAscii("com.sun.star.text.Paragraph") ||
-         sServiceName.EqualsAscii("com.sun.star.style.CharacterProperties")||
-        sServiceName.EqualsAscii("com.sun.star.style.CharacterPropertiesAsian")||
-        sServiceName.EqualsAscii("com.sun.star.style.CharacterPropertiesComplex")||
-        sServiceName.EqualsAscii("com.sun.star.style.ParagraphProperties") ||
-        sServiceName.EqualsAscii("com.sun.star.style.ParagraphPropertiesAsian") ||
-        sServiceName.EqualsAscii("com.sun.star.style.ParagraphPropertiesComplex");
+    return C2U("SwXParagraph");
 }
 /* -----------------------------06.04.00 16:37--------------------------------
 
  ---------------------------------------------------------------------------*/
-uno::Sequence< OUString > SwXParagraph::getSupportedServiceNames(void) throw( uno::RuntimeException )
+static char const*const g_ServicesParagraph[] =
 {
-    uno::Sequence< OUString > aRet(8);
-    OUString* pArray = aRet.getArray();
-    pArray[0] = C2U("com.sun.star.text.Paragraph");
-     pArray[1] = C2U("com.sun.star.style.CharacterProperties");
-    pArray[2] = C2U("com.sun.star.style.CharacterPropertiesAsian");
-    pArray[3] = C2U("com.sun.star.style.CharacterPropertiesComplex");
-    pArray[4] = C2U("com.sun.star.style.ParagraphProperties");
-    pArray[5] = C2U("com.sun.star.style.ParagraphPropertiesAsian");
-    pArray[6] = C2U("com.sun.star.style.ParagraphPropertiesComplex");
-    pArray[7] = C2U("com.sun.star.text.TextContent");
-    return aRet;
-}
-/*-- 11.12.98 08:12:47---------------------------------------------------
+    "com.sun.star.text.TextContent",
+    "com.sun.star.text.Paragraph",
+    "com.sun.star.style.CharacterProperties",
+    "com.sun.star.style.CharacterPropertiesAsian",
+    "com.sun.star.style.CharacterPropertiesComplex",
+    "com.sun.star.style.ParagraphProperties",
+    "com.sun.star.style.ParagraphPropertiesAsian",
+    "com.sun.star.style.ParagraphPropertiesComplex",
+};
+static const size_t g_nServicesParagraph(
+    sizeof(g_ServicesParagraph)/sizeof(g_ServicesParagraph[0]));
 
-  -----------------------------------------------------------------------*/
-SwXParagraph::SwXParagraph() :
-    xParentText(0),
-    aLstnrCntnr( (text::XTextRange*)this),
-    m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_PARAGRAPH)),
-    nSelectionStartPos(-1),
-    nSelectionEndPos(-1),
-    m_bIsDescriptor(TRUE)
+sal_Bool SAL_CALL
+SwXParagraph::supportsService(const OUString& rServiceName)
+throw (uno::RuntimeException)
 {
+    return ::sw::SupportsServiceImpl(
+            g_nServicesParagraph, g_ServicesParagraph, rServiceName);
 }
+/* -----------------------------06.04.00 16:37--------------------------------
 
-/*-- 11.12.98 08:12:47---------------------------------------------------
-
-  -----------------------------------------------------------------------*/
-SwXParagraph::SwXParagraph(uno::Reference< text::XText > const & i_xParent, SwTxtNode * i_pTxtNode, sal_Int32 nSelStart, sal_Int32 nSelEnd) :
-    SwClient(i_pTxtNode),
-    xParentText(i_xParent),
-    aLstnrCntnr( (text::XTextRange*)this),
-    m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_PARAGRAPH)),
-    nSelectionStartPos(nSelStart),
-    nSelectionEndPos(nSelEnd),
-    m_bIsDescriptor(FALSE)
+ ---------------------------------------------------------------------------*/
+uno::Sequence< OUString > SAL_CALL
+SwXParagraph::getSupportedServiceNames() throw (uno::RuntimeException)
 {
+    return ::sw::GetSupportedServiceNamesImpl(
+            g_nServicesParagraph, g_ServicesParagraph);
 }
-/*-- 11.12.98 08:12:48---------------------------------------------------
 
-  -----------------------------------------------------------------------*/
-SwXParagraph::~SwXParagraph()
-{
-}
 /* -----------------------------11.07.00 14:48--------------------------------
 
  ---------------------------------------------------------------------------*/
 void
 SwXParagraph::attachToText(SwXText & rParent, SwTxtNode & rTxtNode)
 {
-    DBG_ASSERT(m_bIsDescriptor, "Paragraph is not a descriptor");
-    if(m_bIsDescriptor)
+    DBG_ASSERT(m_pImpl->m_bIsDescriptor, "Paragraph is not a descriptor");
+    if (m_pImpl->m_bIsDescriptor)
     {
-        m_bIsDescriptor = FALSE;
-        rTxtNode.Add(this);
-        xParentText = &rParent;
-        if(m_sText.getLength())
+        m_pImpl->m_bIsDescriptor = false;
+        rTxtNode.Add(m_pImpl.get());
+        rTxtNode.SetXParagraph(uno::Reference<text::XTextContent>(this));
+        m_pImpl->m_xParentText = &rParent;
+        if (m_pImpl->m_sText.getLength())
         {
-            try { setString(m_sText); }
+            try { setString(m_pImpl->m_sText); }
             catch(...){}
-            m_sText = OUString();
+            m_pImpl->m_sText = OUString();
         }
     }
 }
+
 /*-- 11.12.98 08:12:49---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-uno::Reference< beans::XPropertySetInfo >  SwXParagraph::getPropertySetInfo(void)
-                                            throw( uno::RuntimeException )
+uno::Reference< beans::XPropertySetInfo > SAL_CALL
+SwXParagraph::getPropertySetInfo()
+throw (uno::RuntimeException)
 {
-    static uno::Reference< beans::XPropertySetInfo >  xRef = m_pPropSet->getPropertySetInfo();
+    vos::OGuard g(Application::GetSolarMutex());
+
+    static uno::Reference< beans::XPropertySetInfo > xRef =
+        m_pImpl->m_rPropSet.getPropertySetInfo();
     return xRef;
 }
 /*-- 11.12.98 08:12:49---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXParagraph::setPropertyValue(const OUString& rPropertyName, const uno::Any& aValue)
-    throw( beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException,
-        lang::WrappedTargetException, uno::RuntimeException )
+void SAL_CALL
+SwXParagraph::setPropertyValue(const OUString& rPropertyName,
+        const uno::Any& rValue)
+throw (beans::UnknownPropertyException, beans::PropertyVetoException,
+    lang::IllegalArgumentException, lang::WrappedTargetException,
+    uno::RuntimeException )
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
     uno::Sequence<OUString> aPropertyNames(1);
     aPropertyNames.getArray()[0] = rPropertyName;
     uno::Sequence<uno::Any> aValues(1);
-    aValues.getArray()[0] = aValue;
-    SetPropertyValues_Impl( aPropertyNames, aValues );
+    aValues.getArray()[0] = rValue;
+    m_pImpl->SetPropertyValues_Impl( aPropertyNames, aValues );
 }
+
 /*-- 11.12.98 08:12:49---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-uno::Any SwXParagraph::getPropertyValue(const OUString& rPropertyName)
-    throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
+uno::Any
+SwXParagraph::getPropertyValue(const OUString& rPropertyName)
+throw (beans::UnknownPropertyException, lang::WrappedTargetException,
+    uno::RuntimeException )
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
     uno::Sequence<OUString> aPropertyNames(1);
     aPropertyNames.getArray()[0] = rPropertyName;
-    uno::Sequence< uno::Any > aRet = GetPropertyValues_Impl(aPropertyNames );
+    const uno::Sequence< uno::Any > aRet =
+        m_pImpl->GetPropertyValues_Impl(aPropertyNames);
     return aRet.getConstArray()[0];
 }
 /* -----------------------------02.04.01 11:43--------------------------------
 
  ---------------------------------------------------------------------------*/
-void SAL_CALL SwXParagraph::SetPropertyValues_Impl(
+void SwXParagraph::Impl::SetPropertyValues_Impl(
     const uno::Sequence< OUString >& rPropertyNames,
     const uno::Sequence< uno::Any >& rValues )
-    throw( beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException,
-            lang::WrappedTargetException, uno::RuntimeException)
+throw (beans::UnknownPropertyException, beans::PropertyVetoException,
+    lang::IllegalArgumentException, lang::WrappedTargetException,
+    uno::RuntimeException)
 {
-    if (GetTxtNode())
+    SwTxtNode & rTxtNode(GetTxtNodeOrThrow());
+
+    SwPosition aPos( rTxtNode );
+    SwCursor aCursor( aPos, 0, false );
+    const OUString* pPropertyNames = rPropertyNames.getConstArray();
+    const uno::Any* pValues = rValues.getConstArray();
+    SfxItemPropertyMap const*const pMap = m_rPropSet.getPropertyMap();
+    SwParaSelection aParaSel( aCursor );
+    for (sal_Int32 nProp = 0; nProp < rPropertyNames.getLength(); nProp++)
     {
-        SwPosition aPos( *GetTxtNode() );
-        SwCursor aCursor( aPos, 0, false );
-        const OUString* pPropertyNames = rPropertyNames.getConstArray();
-        const uno::Any* pValues = rValues.getConstArray();
-        const SfxItemPropertyMap*   pMap = m_pPropSet->getPropertyMap();
-        SwParaSelection aParaSel( & aCursor );
-        for(sal_Int32 nProp = 0; nProp < rPropertyNames.getLength(); nProp++)
+        SfxItemPropertySimpleEntry const*const pEntry =
+            pMap->getByName( pPropertyNames[nProp] );
+        if (!pEntry)
         {
-            const SfxItemPropertySimpleEntry* pEntry = pMap->getByName( pPropertyNames[nProp] );
-            if(!pEntry)
-                throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + pPropertyNames[nProp], static_cast < cppu::OWeakObject * > ( this ) );
-            else
-            {
-                if ( pEntry->nFlags & beans::PropertyAttribute::READONLY)
-                    throw beans::PropertyVetoException ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only: " ) ) + pPropertyNames[nProp], static_cast < cppu::OWeakObject * > ( this ) );
-
-                SwXTextCursor::SetPropertyValue(aCursor, *m_pPropSet,
-                                        pPropertyNames[nProp], pValues[nProp]);
-            }
+            throw beans::UnknownPropertyException(
+                OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: "))
+                    + pPropertyNames[nProp],
+                static_cast< cppu::OWeakObject * >(&m_rThis));
+        }
+        if (pEntry->nFlags & beans::PropertyAttribute::READONLY)
+        {
+            throw beans::PropertyVetoException(
+                OUString(RTL_CONSTASCII_USTRINGPARAM("Property is read-only: "))
+                    + pPropertyNames[nProp],
+                static_cast< cppu::OWeakObject * >(&m_rThis));
         }
+        SwXTextCursor::SetPropertyValue(aCursor, m_rPropSet,
+                pPropertyNames[nProp], pValues[nProp]);
     }
-    else
-        throw uno::RuntimeException();
 }
 
-void SwXParagraph::setPropertyValues(
+void SAL_CALL SwXParagraph::setPropertyValues(
     const uno::Sequence< OUString >& rPropertyNames,
     const uno::Sequence< uno::Any >& rValues )
-        throw(beans::PropertyVetoException, lang::IllegalArgumentException,
-                        lang::WrappedTargetException, uno::RuntimeException)
+throw (beans::PropertyVetoException, lang::IllegalArgumentException,
+    lang::WrappedTargetException, uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
 
     // workaround for bad designed API
     try
     {
-        SetPropertyValues_Impl( rPropertyNames, rValues );
+        m_pImpl->SetPropertyValues_Impl( rPropertyNames, rValues );
     }
     catch (beans::UnknownPropertyException &rException)
     {
@@ -339,53 +484,57 @@ void SwXParagraph::setPropertyValues(
         throw aWExc;
     }
 }
+
 /* -----------------------------02.04.01 11:43--------------------------------
 
  ---------------------------------------------------------------------------*/
-uno::Sequence< uno::Any > SAL_CALL SwXParagraph::GetPropertyValues_Impl(
+uno::Sequence< uno::Any > SwXParagraph::Impl::GetPropertyValues_Impl(
         const uno::Sequence< OUString > & rPropertyNames )
-    throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
+throw (beans::UnknownPropertyException, lang::WrappedTargetException,
+    uno::RuntimeException)
 {
+    SwTxtNode & rTxtNode(GetTxtNodeOrThrow());
+
     uno::Sequence< uno::Any > aValues(rPropertyNames.getLength());
-    const SwTxtNode * pTxtNode( GetTxtNode() );
-    if (pTxtNode)
+    SwPosition aPos( rTxtNode );
+    SwPaM aPam( aPos );
+    uno::Any* pValues = aValues.getArray();
+    const OUString* pPropertyNames = rPropertyNames.getConstArray();
+    SfxItemPropertyMap const*const pMap = m_rPropSet.getPropertyMap();
+    const SwAttrSet& rAttrSet( rTxtNode.GetSwAttrSet() );
+    for (sal_Int32 nProp = 0; nProp < rPropertyNames.getLength(); nProp++)
     {
-        SwPosition aPos( *pTxtNode );
-        SwPaM aPam( aPos );
-        uno::Any* pValues = aValues.getArray();
-        const OUString* pPropertyNames = rPropertyNames.getConstArray();
-        const SfxItemPropertyMap*   pMap = m_pPropSet->getPropertyMap();
-        const SwAttrSet& rAttrSet( pTxtNode->GetSwAttrSet() );
-        for(sal_Int32 nProp = 0; nProp < rPropertyNames.getLength(); nProp++)
+        SfxItemPropertySimpleEntry const*const pEntry =
+            pMap->getByName( pPropertyNames[nProp] );
+        if (!pEntry)
+        {
+            throw beans::UnknownPropertyException(
+                OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: "))
+                    + pPropertyNames[nProp],
+                static_cast< cppu::OWeakObject * >(&m_rThis));
+        }
+        if (!SwXParagraph::getDefaultTextContentValue(
+            pValues[nProp], pPropertyNames[nProp], pEntry->nWID))
         {
-            const SfxItemPropertySimpleEntry* pEntry = pMap->getByName( pPropertyNames[nProp] );
-            if(pEntry)
+            beans::PropertyState eTemp;
+            const bool bDone = SwUnoCursorHelper::getCrsrPropertyValue(
+                *pEntry, aPam, &(pValues[nProp]), eTemp, &rTxtNode );
+            if (!bDone)
             {
-                if(!SwXParagraph::getDefaultTextContentValue(
-                    pValues[nProp], pPropertyNames[nProp], pEntry->nWID))
-                {
-                    BOOL bDone = FALSE;
-                    beans::PropertyState eTemp;
-                    bDone = SwUnoCursorHelper::getCrsrPropertyValue(
-                        *pEntry, aPam, &(pValues[nProp]), eTemp, pTxtNode );
-                    if(!bDone)
-                        m_pPropSet->getPropertyValue(*pEntry, rAttrSet, pValues[nProp]);
-                }
+                m_rPropSet.getPropertyValue(
+                    *pEntry, rAttrSet, pValues[nProp]);
             }
-            else
-                throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + pPropertyNames[nProp], static_cast < cppu::OWeakObject * > ( this ) );
         }
     }
-    else
-        throw uno::RuntimeException();
     return aValues;
 }
+
 /* -----------------------------04.11.03 11:43--------------------------------
 
  ---------------------------------------------------------------------------*/
-uno::Sequence< uno::Any > SwXParagraph::getPropertyValues(
-    const uno::Sequence< OUString >& rPropertyNames )
-        throw(uno::RuntimeException)
+uno::Sequence< uno::Any > SAL_CALL
+SwXParagraph::getPropertyValues(const uno::Sequence< OUString >& rPropertyNames)
+throw (uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
     uno::Sequence< uno::Any > aValues;
@@ -393,67 +542,82 @@ uno::Sequence< uno::Any > SwXParagraph::getPropertyValues(
     // workaround for bad designed API
     try
     {
-        aValues = GetPropertyValues_Impl( rPropertyNames );
+        aValues = m_pImpl->GetPropertyValues_Impl( rPropertyNames );
     }
     catch (beans::UnknownPropertyException &)
     {
-        throw uno::RuntimeException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property exception caught" ) ), static_cast < cppu::OWeakObject * > ( this ) );
+        throw uno::RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
+                "Unknown property exception caught")),
+            static_cast<cppu::OWeakObject *>(this));
     }
     catch (lang::WrappedTargetException &)
     {
-        throw uno::RuntimeException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "WrappedTargetException caught" ) ), static_cast < cppu::OWeakObject * > ( this ) );
+        throw uno::RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
+                "WrappedTargetException caught")),
+            static_cast<cppu::OWeakObject *>(this));
     }
 
     return aValues;
 }
+
 /* -----------------------------02.04.01 11:43--------------------------------
 
  ---------------------------------------------------------------------------*/
-void SwXParagraph::addPropertiesChangeListener(
+void SAL_CALL SwXParagraph::addPropertiesChangeListener(
     const uno::Sequence< OUString >& /*aPropertyNames*/,
     const uno::Reference< beans::XPropertiesChangeListener >& /*xListener*/ )
-        throw(uno::RuntimeException)
-{}
+throw (uno::RuntimeException)
+{
+    OSL_ENSURE(false,
+        "SwXParagraph::addPropertiesChangeListener(): not implemented");
+}
 /* -----------------------------02.04.01 11:43--------------------------------
 
  ---------------------------------------------------------------------------*/
-void SwXParagraph::removePropertiesChangeListener(
+void SAL_CALL SwXParagraph::removePropertiesChangeListener(
     const uno::Reference< beans::XPropertiesChangeListener >& /*xListener*/ )
-        throw(uno::RuntimeException)
-{}
+throw (uno::RuntimeException)
+{
+    OSL_ENSURE(false,
+        "SwXParagraph::removePropertiesChangeListener(): not implemented");
+}
 /* -----------------------------02.04.01 11:43--------------------------------
 
  ---------------------------------------------------------------------------*/
-void SwXParagraph::firePropertiesChangeEvent(
+void SAL_CALL SwXParagraph::firePropertiesChangeEvent(
     const uno::Sequence< OUString >& /*aPropertyNames*/,
     const uno::Reference< beans::XPropertiesChangeListener >& /*xListener*/ )
         throw(uno::RuntimeException)
-{}
+{
+    OSL_ENSURE(false,
+        "SwXParagraph::firePropertiesChangeEvent(): not implemented");
+}
 /* -----------------------------25.09.03 11:09--------------------------------
 
  ---------------------------------------------------------------------------*/
 
 /* disabled for #i46921# */
 
-uno::Sequence< beans::SetPropertyTolerantFailed > SAL_CALL SwXParagraph::setPropertyValuesTolerant(
+uno::Sequence< beans::SetPropertyTolerantFailed > SAL_CALL
+SwXParagraph::setPropertyValuesTolerant(
         const uno::Sequence< OUString >& rPropertyNames,
         const uno::Sequence< uno::Any >& rValues )
-    throw (lang::IllegalArgumentException, uno::RuntimeException)
+throw (lang::IllegalArgumentException, uno::RuntimeException)
 {
     vos::OGuard aGuard( Application::GetSolarMutex() );
 
     if (rPropertyNames.getLength() != rValues.getLength())
+    {
         throw lang::IllegalArgumentException();
+    }
 
-    const SwTxtNode * const pTxtNode( GetTxtNode() );
-    if (!pTxtNode)
-        throw uno::RuntimeException();
+    SwTxtNode & rTxtNode(m_pImpl->GetTxtNodeOrThrow());
 
     //SwNode& rTxtNode = pUnoCrsr->GetPoint()->nNode.GetNode();
     //const SwAttrSet& rAttrSet = ((SwTxtNode&)rTxtNode).GetSwAttrSet();
     //USHORT nAttrCount = rAttrSet.Count();
 
-    sal_Int32 nProps = rPropertyNames.getLength();
+    const sal_Int32 nProps = rPropertyNames.getLength();
     const OUString *pProp = rPropertyNames.getConstArray();
 
     //sal_Int32 nVals = rValues.getLength();
@@ -464,31 +628,39 @@ uno::Sequence< beans::SetPropertyTolerantFailed > SAL_CALL SwXParagraph::setProp
     beans::SetPropertyTolerantFailed *pFailed = aFailed.getArray();
 
     // get entry to start with
-    const SfxItemPropertyMap*  pPropMap = m_pPropSet->getPropertyMap();
+    SfxItemPropertyMap const*const pPropMap =
+        m_pImpl->m_rPropSet.getPropertyMap();
 
     OUString sTmp;
-    SwPosition aPos( *pTxtNode );
+    SwPosition aPos( rTxtNode );
     SwCursor aCursor( aPos, 0, false );
-    SwParaSelection aParaSel( & aCursor );
+    SwParaSelection aParaSel( aCursor );
     for (sal_Int32 i = 0;  i < nProps;  ++i)
     {
         try
         {
             pFailed[ nFailed ].Name = pProp[i];
 
-            const SfxItemPropertySimpleEntry* pEntry = pPropMap->getByName( pProp[i] );
+            SfxItemPropertySimpleEntry const*const pEntry =
+                pPropMap->getByName( pProp[i] );
             if (!pEntry)
-                pFailed[ nFailed++ ].Result  = beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY;
+            {
+                pFailed[ nFailed++ ].Result  =
+                    beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY;
+            }
             else
             {
                 // set property value
                 // (compare to SwXParagraph::setPropertyValues)
                 if (pEntry->nFlags & beans::PropertyAttribute::READONLY)
-                    pFailed[ nFailed++ ].Result  = beans::TolerantPropertySetResultType::PROPERTY_VETO;
+                {
+                    pFailed[ nFailed++ ].Result  =
+                        beans::TolerantPropertySetResultType::PROPERTY_VETO;
+                }
                 else
                 {
                     SwXTextCursor::SetPropertyValue(
-                                aCursor, *m_pPropSet, pProp[i], pValue[i] );
+                        aCursor, m_pImpl->m_rPropSet, pProp[i], pValue[i]);
                 }
             }
         }
@@ -496,19 +668,23 @@ uno::Sequence< beans::SetPropertyTolerantFailed > SAL_CALL SwXParagraph::setProp
         {
             // should not occur because property was searched for before
             DBG_ERROR( "unexpected exception catched" );
-            pFailed[ nFailed++ ].Result = beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY;
+            pFailed[ nFailed++ ].Result =
+                beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY;
         }
         catch (lang::IllegalArgumentException &)
         {
-            pFailed[ nFailed++ ].Result = beans::TolerantPropertySetResultType::ILLEGAL_ARGUMENT;
+            pFailed[ nFailed++ ].Result =
+                beans::TolerantPropertySetResultType::ILLEGAL_ARGUMENT;
         }
         catch (beans::PropertyVetoException &)
         {
-            pFailed[ nFailed++ ].Result = beans::TolerantPropertySetResultType::PROPERTY_VETO;
+            pFailed[ nFailed++ ].Result =
+                beans::TolerantPropertySetResultType::PROPERTY_VETO;
         }
         catch (lang::WrappedTargetException &)
         {
-            pFailed[ nFailed++ ].Result = beans::TolerantPropertySetResultType::WRAPPED_TARGET;
+            pFailed[ nFailed++ ].Result =
+                beans::TolerantPropertySetResultType::WRAPPED_TARGET;
         }
     }
 
@@ -517,52 +693,56 @@ uno::Sequence< beans::SetPropertyTolerantFailed > SAL_CALL SwXParagraph::setProp
 }
 
 
-uno::Sequence< beans::GetPropertyTolerantResult > SAL_CALL SwXParagraph::getPropertyValuesTolerant(
+uno::Sequence< beans::GetPropertyTolerantResult > SAL_CALL
+SwXParagraph::getPropertyValuesTolerant(
         const uno::Sequence< OUString >& rPropertyNames )
-    throw (uno::RuntimeException)
+throw (uno::RuntimeException)
 {
     vos::OGuard aGuard( Application::GetSolarMutex() );
 
     uno::Sequence< beans::GetDirectPropertyTolerantResult > aTmpRes(
-            GetPropertyValuesTolerant_Impl( rPropertyNames, sal_False ) );
-    const beans::GetDirectPropertyTolerantResult *pTmpRes = aTmpRes.getConstArray();
+        m_pImpl->GetPropertyValuesTolerant_Impl( rPropertyNames, false ) );
+    const beans::GetDirectPropertyTolerantResult *pTmpRes =
+        aTmpRes.getConstArray();
 
     // copy temporary result to final result type
-    sal_Int32 nLen = aTmpRes.getLength();
+    const sal_Int32 nLen = aTmpRes.getLength();
     uno::Sequence< beans::GetPropertyTolerantResult > aRes( nLen );
     beans::GetPropertyTolerantResult *pRes = aRes.getArray();
     for (sal_Int32 i = 0;  i < nLen;  i++)
+    {
         *pRes++ = *pTmpRes++;
+    }
     return aRes;
 }
 
 
-uno::Sequence< beans::GetDirectPropertyTolerantResult > SAL_CALL SwXParagraph::getDirectPropertyValuesTolerant(
+uno::Sequence< beans::GetDirectPropertyTolerantResult > SAL_CALL
+SwXParagraph::getDirectPropertyValuesTolerant(
         const uno::Sequence< OUString >& rPropertyNames )
-    throw (uno::RuntimeException)
+throw (uno::RuntimeException)
 {
     vos::OGuard aGuard( Application::GetSolarMutex() );
-    return GetPropertyValuesTolerant_Impl( rPropertyNames, sal_True );
+
+    return m_pImpl->GetPropertyValuesTolerant_Impl( rPropertyNames, true );
 }
 
 
-uno::Sequence< beans::GetDirectPropertyTolerantResult > SAL_CALL SwXParagraph::GetPropertyValuesTolerant_Impl(
+uno::Sequence< beans::GetDirectPropertyTolerantResult >
+SwXParagraph::Impl::GetPropertyValuesTolerant_Impl(
         const uno::Sequence< OUString >& rPropertyNames,
-        sal_Bool bDirectValuesOnly )
-    throw (uno::RuntimeException)
+        bool bDirectValuesOnly )
+throw (uno::RuntimeException)
 {
     vos::OGuard aGuard( Application::GetSolarMutex() );
 
-    const SwTxtNode * const pTxtNode( GetTxtNode() );
-    DBG_ASSERT( pTxtNode != NULL, "need text node" );
-    if (!pTxtNode)
-        throw uno::RuntimeException();
+    SwTxtNode & rTxtNode(GetTxtNodeOrThrow());
 
     // #i46786# Use SwAttrSet pointer for determining the state.
     //          Use the value SwAttrSet (from the paragraph OR the style)
     //          for determining the actual value(s).
-    const SwAttrSet* pAttrSet = pTxtNode->GetpSwAttrSet();
-    const SwAttrSet& rValueAttrSet = pTxtNode->GetSwAttrSet();
+    const SwAttrSet* pAttrSet = rTxtNode.GetpSwAttrSet();
+    const SwAttrSet& rValueAttrSet = rTxtNode.GetSwAttrSet();
 
     sal_Int32 nProps = rPropertyNames.getLength();
     const OUString *pProp = rPropertyNames.getConstArray();
@@ -572,7 +752,7 @@ uno::Sequence< beans::GetDirectPropertyTolerantResult > SAL_CALL SwXParagraph::G
     sal_Int32 nIdx = 0;
 
     // get entry to start with
-    const SfxItemPropertyMap *pPropMap = m_pPropSet->getPropertyMap();
+    SfxItemPropertyMap const*const pPropMap = m_rPropSet.getPropertyMap();
 
     for (sal_Int32 i = 0;  i < nProps;  ++i)
     {
@@ -583,23 +763,28 @@ uno::Sequence< beans::GetDirectPropertyTolerantResult > SAL_CALL SwXParagraph::G
         {
             rResult.Name = pProp[i];
 
-            const SfxItemPropertySimpleEntry* pEntry = pPropMap->getByName( pProp[i] );
+            SfxItemPropertySimpleEntry const*const pEntry =
+                pPropMap->getByName( pProp[i] );
             if (!pEntry)  // property available?
-                rResult.Result = beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY;
+            {
+                rResult.Result =
+                    beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY;
+            }
             else
             {
                 // get property state
                 // (compare to SwXParagraph::getPropertyState)
                 sal_Bool bAttrSetFetched = sal_True;
                 beans::PropertyState eState = lcl_SwXParagraph_getPropertyState(
-                            *pTxtNode, &pAttrSet, *pEntry, bAttrSetFetched );
+                            rTxtNode, &pAttrSet, *pEntry, bAttrSetFetched );
                 rResult.State  = eState;
 
 //                if (bDirectValuesOnly  &&  PropertyState_DIRECT_VALUE != eState)
 //                    rResult.Result = beans::TolerantPropertySetResultType::NO_DIRECT_VALUE;
 //                else
                 rResult.Result = beans::TolerantPropertySetResultType::UNKNOWN_FAILURE;
-                if (!bDirectValuesOnly  ||  beans::PropertyState_DIRECT_VALUE == eState)
+                if (!bDirectValuesOnly ||
+                    (beans::PropertyState_DIRECT_VALUE == eState))
                 {
                     // get property value
                     // (compare to SwXParagraph::getPropertyValue(s))
@@ -607,18 +792,21 @@ uno::Sequence< beans::GetDirectPropertyTolerantResult > SAL_CALL SwXParagraph::G
                     if (!SwXParagraph::getDefaultTextContentValue(
                                 aValue, pProp[i], pEntry->nWID ) )
                     {
-                        SwPosition aPos( *pTxtNode );
+                        SwPosition aPos( rTxtNode );
                         SwPaM aPam( aPos );
                         // handle properties that are not part of the attribute
                         // and thus only pretendend to be paragraph attributes
-                        BOOL bDone = FALSE;
                         beans::PropertyState eTemp;
-                        bDone = SwUnoCursorHelper::getCrsrPropertyValue(
-                                    *pEntry, aPam, &aValue, eTemp, pTxtNode );
+                        const bool bDone =
+                            SwUnoCursorHelper::getCrsrPropertyValue(
+                                    *pEntry, aPam, &aValue, eTemp, &rTxtNode );
 
                         // if not found try the real paragraph attributes...
                         if (!bDone)
-                            m_pPropSet->getPropertyValue( *pEntry, rValueAttrSet, aValue );
+                        {
+                            m_rPropSet.getPropertyValue(
+                                *pEntry, rValueAttrSet, aValue );
+                        }
                     }
 
                     rResult.Value  = aValue;
@@ -661,7 +849,8 @@ uno::Sequence< beans::GetDirectPropertyTolerantResult > SAL_CALL SwXParagraph::G
 /* -----------------------------12.09.00 11:09--------------------------------
 
  ---------------------------------------------------------------------------*/
-BOOL SwXParagraph::getDefaultTextContentValue(uno::Any& rAny, const OUString& rPropertyName, USHORT nWID)
+bool SwXParagraph::getDefaultTextContentValue(
+        uno::Any& rAny, const OUString& rPropertyName, USHORT nWID)
 {
     if(!nWID)
     {
@@ -694,35 +883,59 @@ BOOL SwXParagraph::getDefaultTextContentValue(uno::Any& rAny, const OUString& rP
 /*-- 11.12.98 08:12:50---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXParagraph::addPropertyChangeListener(
-    const OUString& /*PropertyName*/,
-    const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/)
-        throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
+void SAL_CALL
+SwXParagraph::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,
+        "SwXParagraph::addPropertyChangeListener(): not implemented");
 }
+
 /*-- 11.12.98 08:12:50---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXParagraph::removePropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
+void SAL_CALL
+SwXParagraph::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,
+        "SwXParagraph::removePropertyChangeListener(): not implemented");
 }
+
 /*-- 11.12.98 08:12:50---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXParagraph::addVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
+void SAL_CALL
+SwXParagraph::addVetoableChangeListener(
+        const ::rtl::OUString& /*rPropertyName*/,
+        const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
+throw (beans::UnknownPropertyException, lang::WrappedTargetException,
+    uno::RuntimeException)
 {
-    DBG_WARNING("not implemented");
+    OSL_ENSURE(false,
+        "SwXParagraph::addVetoableChangeListener(): not implemented");
 }
+
 /*-- 11.12.98 08:12:51---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXParagraph::removeVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/)
-    throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
+void SAL_CALL
+SwXParagraph::removeVetoableChangeListener(
+        const ::rtl::OUString& /*rPropertyName*/,
+        const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
+throw (beans::UnknownPropertyException, lang::WrappedTargetException,
+        uno::RuntimeException)
 {
-    DBG_WARNING("not implemented");
+    OSL_ENSURE(false,
+        "SwXParagraph::removeVetoableChangeListener(): not implemented");
 }
+
 //-----------------------------------------------------------------------------
 beans::PropertyState lcl_SwXParagraph_getPropertyState(
 //                          SwUnoCrsr& rUnoCrsr,
@@ -730,7 +943,7 @@ beans::PropertyState lcl_SwXParagraph_getPropertyState(
                             const SwAttrSet** ppSet,
                             const SfxItemPropertySimpleEntry& rEntry,
                             sal_Bool &rAttrSetFetched )
-                                throw( beans::UnknownPropertyException)
+throw (beans::UnknownPropertyException)
 {
     beans::PropertyState eRet = beans::PropertyState_DEFAULT_VALUE;
 
@@ -786,348 +999,393 @@ beans::PropertyState lcl_SwXParagraph_getPropertyState(
 /*-- 05.03.99 11:37:30---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-beans::PropertyState SwXParagraph::getPropertyState(const OUString& rPropertyName)
-    throw( beans::UnknownPropertyException, uno::RuntimeException )
+beans::PropertyState SAL_CALL
+SwXParagraph::getPropertyState(const OUString& rPropertyName)
+throw (beans::UnknownPropertyException, uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
-    beans::PropertyState eRet = beans::PropertyState_DEFAULT_VALUE;
-    const SwTxtNode * const pTxtNode( GetTxtNode() );
-    if (pTxtNode)
+
+    SwTxtNode & rTxtNode(m_pImpl->GetTxtNodeOrThrow());
+
+    const SwAttrSet* pSet = 0;
+    SfxItemPropertySimpleEntry const*const pEntry =
+        m_pImpl->m_rPropSet.getPropertyMap()->getByName(rPropertyName);
+    if (!pEntry)
     {
-        const SwAttrSet* pSet = 0;
-        const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName( rPropertyName );
-        if(!pEntry)
-            throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
-        sal_Bool bDummy = sal_False;
-        eRet = lcl_SwXParagraph_getPropertyState( *pTxtNode, &pSet, *pEntry,
-                bDummy );
+        throw beans::UnknownPropertyException(
+            OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: "))
+                + rPropertyName,
+            static_cast<cppu::OWeakObject *>(this));
     }
-    else
-        throw uno::RuntimeException();
+    sal_Bool bDummy = sal_False;
+    const beans::PropertyState eRet =
+        lcl_SwXParagraph_getPropertyState(rTxtNode, &pSet, *pEntry, bDummy);
     return eRet;
 }
 /*-- 05.03.99 11:37:32---------------------------------------------------
 
   -----------------------------------------------------------------------*/
 
-uno::Sequence< beans::PropertyState > SwXParagraph::getPropertyStates(
+uno::Sequence< beans::PropertyState > SAL_CALL
+SwXParagraph::getPropertyStates(
         const uno::Sequence< OUString >& PropertyNames)
-        throw( beans::UnknownPropertyException, uno::RuntimeException )
+throw (beans::UnknownPropertyException, uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
+
+    SwTxtNode & rTxtNode(m_pImpl->GetTxtNodeOrThrow());
+
     const OUString* pNames = PropertyNames.getConstArray();
     uno::Sequence< beans::PropertyState > aRet(PropertyNames.getLength());
     beans::PropertyState* pStates = aRet.getArray();
+    SfxItemPropertyMap const*const pMap = m_pImpl->m_rPropSet.getPropertyMap();
+    const SwAttrSet* pSet = 0;
+    sal_Bool bAttrSetFetched = sal_False;
 
-    const SwTxtNode * pTxtNode( GetTxtNode() );
-    if (pTxtNode)
+    for (sal_Int32 i = 0, nEnd = PropertyNames.getLength(); i < nEnd;
+            ++i, ++pStates, ++pNames)
     {
-        const SfxItemPropertyMap* pMap = m_pPropSet->getPropertyMap();
-        const SwAttrSet* pSet = 0;
-        sal_Bool bAttrSetFetched = sal_False;
-        for(sal_Int32 i = 0, nEnd = PropertyNames.getLength(); i < nEnd; i++,++pStates,++pNames )
+        SfxItemPropertySimpleEntry const*const pEntry =
+            pMap->getByName( *pNames );
+        if (!pEntry)
         {
-            const SfxItemPropertySimpleEntry* pEntry = pMap->getByName( *pNames );
-            if(!pEntry)
-                throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + *pNames, static_cast < cppu::OWeakObject * > ( this ) );
+            throw beans::UnknownPropertyException(
+                OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: "))
+                    + *pNames,
+                static_cast<cppu::OWeakObject *>(this));
+        }
 
-            if (bAttrSetFetched && !pSet && isATR(pEntry->nWID))
-            {
-                *pStates = beans::PropertyState_DEFAULT_VALUE;
-            }
-            else
-            {
-                *pStates = lcl_SwXParagraph_getPropertyState(
-                    *pTxtNode, &pSet, *pEntry, bAttrSetFetched );
-            }
+        if (bAttrSetFetched && !pSet && isATR(pEntry->nWID))
+        {
+            *pStates = beans::PropertyState_DEFAULT_VALUE;
+        }
+        else
+        {
+            *pStates = lcl_SwXParagraph_getPropertyState(
+                rTxtNode, &pSet, *pEntry, bAttrSetFetched );
         }
     }
-    else
-        throw uno::RuntimeException();
 
     return aRet;
 }
+
 /*-- 05.03.99 11:37:33---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXParagraph::setPropertyToDefault(const OUString& rPropertyName)
-        throw( beans::UnknownPropertyException, uno::RuntimeException )
+void SAL_CALL
+SwXParagraph::setPropertyToDefault(const OUString& rPropertyName)
+throw (beans::UnknownPropertyException, uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
-    const SwTxtNode * pTxtNode( GetTxtNode() );
-    if (pTxtNode)
+
+    SwTxtNode & rTxtNode(m_pImpl->GetTxtNodeOrThrow());
+
+    SwPosition aPos( rTxtNode );
+    SwCursor aCursor( aPos, 0, false );
+    if (rPropertyName.equalsAsciiL(SW_PROP_NAME(UNO_NAME_ANCHOR_TYPE))  ||
+        rPropertyName.equalsAsciiL(SW_PROP_NAME(UNO_NAME_ANCHOR_TYPES)) ||
+        rPropertyName.equalsAsciiL(SW_PROP_NAME(UNO_NAME_TEXT_WRAP)))
     {
-        SwPosition aPos( *pTxtNode );
-        SwCursor aCursor( aPos, 0, false );
-        if( rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_ANCHOR_TYPE)) ||
-            rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_ANCHOR_TYPES)) ||
-            rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_TEXT_WRAP)))
-                return;
+        return;
+    }
 
-        // select paragraph
-        SwParaSelection aParaSel( & aCursor );
-        const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName( rPropertyName );
-        if(pEntry)
-        {
-            if ( pEntry->nFlags & beans::PropertyAttribute::READONLY)
-                throw uno::RuntimeException ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only:" ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
+    // select paragraph
+    SwParaSelection aParaSel( aCursor );
+    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->nWID < RES_FRMATR_END)
+    if (pEntry->nFlags & beans::PropertyAttribute::READONLY)
+    {
+        throw uno::RuntimeException(
+            OUString(RTL_CONSTASCII_USTRINGPARAM("Property is read-only: "))
+                + rPropertyName,
+            static_cast<cppu::OWeakObject *>(this));
+    }
+
+    if (pEntry->nWID < RES_FRMATR_END)
+    {
+        SvUShortsSort aWhichIds;
+        aWhichIds.Insert(pEntry->nWID);
+        if (pEntry->nWID < RES_PARATR_BEGIN)
+        {
+            aCursor.GetDoc()->ResetAttrs(aCursor, sal_True, &aWhichIds);
+        }
+        else
+        {
+            // for paragraph attributes the selection must be extended
+            // to paragraph boundaries
+            SwPosition aStart( *aCursor.Start() );
+            SwPosition aEnd  ( *aCursor.End()   );
+            ::std::auto_ptr<SwUnoCrsr> pTemp(
+                aCursor.GetDoc()->CreateUnoCrsr(aStart, sal_False) );
+            if(!SwUnoCursorHelper::IsStartOfPara(*pTemp))
             {
-                SvUShortsSort aWhichIds;
-                aWhichIds.Insert(pEntry->nWID);
-                if(pEntry->nWID < RES_PARATR_BEGIN)
-                {
-                    aCursor.GetDoc()->ResetAttrs(aCursor, sal_True, &aWhichIds);
-                }
-                else
-                {
-                    // for paragraph attributes the selection must be extended
-                    // to paragraph boundaries
-                    SwPosition aStart( *aCursor.Start() );
-                    SwPosition aEnd  ( *aCursor.End()   );
-                    std::auto_ptr<SwUnoCrsr> pTemp(
-                        aCursor.GetDoc()->CreateUnoCrsr(aStart, sal_False) );
-                    if(!SwUnoCursorHelper::IsStartOfPara(*pTemp))
-                    {
-                        pTemp->MovePara(fnParaCurr, fnParaStart);
-                    }
-                    pTemp->SetMark();
-                    *pTemp->GetPoint() = aEnd;
-                    //pTemp->Exchange();
-                    SwXTextCursor::SelectPam(*pTemp, sal_True);
-                    if(!SwUnoCursorHelper::IsEndOfPara(*pTemp))
-                    {
-                        pTemp->MovePara(fnParaCurr, fnParaEnd);
-                    }
-                    pTemp->GetDoc()->ResetAttrs(*pTemp, sal_True, &aWhichIds);
-                }
+                pTemp->MovePara(fnParaCurr, fnParaStart);
             }
-            else
+            pTemp->SetMark();
+            *pTemp->GetPoint() = aEnd;
+            //pTemp->Exchange();
+            SwXTextCursor::SelectPam(*pTemp, sal_True);
+            if (!SwUnoCursorHelper::IsEndOfPara(*pTemp))
             {
-                SwUnoCursorHelper::resetCrsrPropertyValue(*pEntry, aCursor);
+                pTemp->MovePara(fnParaCurr, fnParaEnd);
             }
+            pTemp->GetDoc()->ResetAttrs(*pTemp, sal_True, &aWhichIds);
         }
-        else
-            throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
     }
     else
-        throw uno::RuntimeException();
+    {
+        SwUnoCursorHelper::resetCrsrPropertyValue(*pEntry, aCursor);
+    }
 }
+
 /*-- 05.03.99 11:37:33---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-uno::Any SwXParagraph::getPropertyDefault(const OUString& rPropertyName)
-        throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
+uno::Any SAL_CALL
+SwXParagraph::getPropertyDefault(const OUString& rPropertyName)
+throw (beans::UnknownPropertyException, lang::WrappedTargetException,
+    uno::RuntimeException)
 {
+    vos::OGuard g(Application::GetSolarMutex());
+
+    SwTxtNode & rTxtNode(m_pImpl->GetTxtNodeOrThrow());
+
     uno::Any aRet;
-    const SwTxtNode * pTxtNode( GetTxtNode() );
-    if (pTxtNode)
+    if (SwXParagraph::getDefaultTextContentValue(aRet, rPropertyName))
     {
-        if(SwXParagraph::getDefaultTextContentValue(aRet, rPropertyName))
-            return aRet;
+        return aRet;
+    }
 
-        const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName( rPropertyName );
-        if(pEntry)
-        {
-            if(pEntry->nWID < RES_FRMATR_END)
-            {
-                const SfxPoolItem& rDefItem =
-                    pTxtNode->GetDoc()->GetAttrPool().GetDefaultItem(
-                        pEntry->nWID);
-                rDefItem.QueryValue(aRet, pEntry->nMemberId);
-            }
-        }
-        else
-            throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
+    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->nWID < RES_FRMATR_END)
+    {
+        const SfxPoolItem& rDefItem =
+            rTxtNode.GetDoc()->GetAttrPool().GetDefaultItem(pEntry->nWID);
+        rDefItem.QueryValue(aRet, pEntry->nMemberId);
     }
-    else
-        throw uno::RuntimeException();
 
     return aRet;
 }
+
 /*-- 11.12.98 08:12:51---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXParagraph::attach(const uno::Reference< text::XTextRange > & /*xTextRange*/)
-                    throw( lang::IllegalArgumentException, uno::RuntimeException )
+void SAL_CALL
+SwXParagraph::attach(const uno::Reference< text::XTextRange > & /*xTextRange*/)
+throw (lang::IllegalArgumentException, uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
-    // SwXParagraph will only created in order to be inserteb by
+    // SwXParagraph will only created in order to be inserted by
     // 'insertTextContentBefore' or 'insertTextContentAfter' therefore
     // they cannot be attached
     throw uno::RuntimeException();
 }
+
 /*-- 11.12.98 08:12:51---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-uno::Reference< text::XTextRange >  SwXParagraph::getAnchor(void) throw( uno::RuntimeException )
+uno::Reference< text::XTextRange > SAL_CALL
+SwXParagraph::getAnchor() throw (uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
-    uno::Reference< text::XTextRange >  aRet;
-    const SwTxtNode * pTxtNode( GetTxtNode() );
-    if (pTxtNode)
-    {
-        SwPosition aPos( *pTxtNode );
-        SwCursor aCursor( aPos, 0, false );
-        // select paragraph
-        SwParaSelection aParaSel( & aCursor );
-        aRet = new SwXTextRange(aCursor, xParentText);
-    }
-    else
-        throw uno::RuntimeException();
-    return aRet;
+
+    SwTxtNode & rTxtNode(m_pImpl->GetTxtNodeOrThrow());
+
+    SwPosition aPos( rTxtNode );
+    SwCursor aCursor( aPos, 0, false );
+    // select paragraph
+    SwParaSelection aParaSel( aCursor );
+    const uno::Reference< text::XTextRange >  xRet =
+        new SwXTextRange(aCursor, m_pImpl->m_xParentText);
+    return xRet;
 }
+
 /*-- 11.12.98 08:12:52---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXParagraph::dispose(void) throw( uno::RuntimeException )
+void SAL_CALL SwXParagraph::dispose() throw (uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
-    SwTxtNode * pTxtNode( GetTxtNode() );
+
+    SwTxtNode *const pTxtNode( m_pImpl->GetTxtNode() );
     if (pTxtNode)
     {
         SwCursor aCursor( SwPosition( *pTxtNode ), 0, false );
         // select paragraph
         {
-            SwParaSelection aParaSel( & aCursor );
+            SwParaSelection aParaSel( aCursor );
             pTxtNode->GetDoc()->DelFullPara(aCursor);
         }
-        aLstnrCntnr.Disposing();
+        m_pImpl->m_ListenerContainer.Disposing();
     }
-    else
-        throw uno::RuntimeException();
 }
+
 /*-- 11.12.98 08:12:52---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXParagraph::addEventListener(const uno::Reference< lang::XEventListener > & aListener) throw( uno::RuntimeException )
+void SAL_CALL SwXParagraph::addEventListener(
+        const uno::Reference< lang::XEventListener > & xListener)
+throw (uno::RuntimeException)
 {
-    if(!GetRegisteredIn())
+    vos::OGuard g(Application::GetSolarMutex());
+
+    if (!m_pImpl->GetTxtNode())
+    {
         throw uno::RuntimeException();
-    aLstnrCntnr.AddListener(aListener);
+    }
+    m_pImpl->m_ListenerContainer.AddListener(xListener);
 }
 /*-- 11.12.98 08:12:53---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXParagraph::removeEventListener(const uno::Reference< lang::XEventListener > & aListener) throw( uno::RuntimeException )
+void SAL_CALL SwXParagraph::removeEventListener(
+        const uno::Reference< lang::XEventListener > & xListener)
+throw (uno::RuntimeException)
 {
-    if(!GetRegisteredIn() || !aLstnrCntnr.RemoveListener(aListener))
+    vos::OGuard g(Application::GetSolarMutex());
+
+    if (!m_pImpl->GetTxtNode() ||
+        !m_pImpl->m_ListenerContainer.RemoveListener(xListener))
+    {
         throw uno::RuntimeException();
+    }
 }
+
 /*-- 11.12.98 08:12:53---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-uno::Reference< container::XEnumeration >  SwXParagraph::createEnumeration(void) throw( uno::RuntimeException )
+uno::Reference< container::XEnumeration >  SAL_CALL
+SwXParagraph::createEnumeration() throw (uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
-    uno::Reference< container::XEnumeration >  aRef;
-    const SwTxtNode * pTxtNode( GetTxtNode() );
-    if (pTxtNode)
-    {
-        SwPosition aPos( *pTxtNode );
-        SwPaM aPam ( aPos );
-        aRef = new SwXTextPortionEnumeration(aPam, xParentText,
-                    nSelectionStartPos, nSelectionEndPos);
-    }
-    else
-        throw uno::RuntimeException();
-    return aRef;
 
+    SwTxtNode & rTxtNode(m_pImpl->GetTxtNodeOrThrow());
+
+    SwPosition aPos( rTxtNode );
+    SwPaM aPam ( aPos );
+    const uno::Reference< container::XEnumeration > xRef =
+        new SwXTextPortionEnumeration(aPam, m_pImpl->m_xParentText,
+            m_pImpl->m_nSelectionStartPos, m_pImpl->m_nSelectionEndPos);
+    return xRef;
 }
+
 /*-- 11.12.98 08:12:54---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-uno::Type SwXParagraph::getElementType(void) throw( uno::RuntimeException )
+uno::Type SAL_CALL SwXParagraph::getElementType() throw (uno::RuntimeException)
 {
-    return ::getCppuType((uno::Reference<text::XTextRange>*)0);
+    return text::XTextRange::static_type();
 }
 /*-- 11.12.98 08:12:54---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-sal_Bool SwXParagraph::hasElements(void) throw( uno::RuntimeException )
+sal_Bool SAL_CALL SwXParagraph::hasElements() throw (uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
     return (GetTxtNode()) ? sal_True : sal_False;
 }
+
 /*-- 11.12.98 08:12:55---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-uno::Reference< text::XText >  SwXParagraph::getText(void) throw( uno::RuntimeException )
+uno::Reference< text::XText > SAL_CALL
+SwXParagraph::getText() throw (uno::RuntimeException)
 {
-    return xParentText;
+    vos::OGuard g(Application::GetSolarMutex());
+
+    return m_pImpl->m_xParentText;
 }
+
 /*-- 11.12.98 08:12:55---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-uno::Reference< text::XTextRange >  SwXParagraph::getStart(void) throw( uno::RuntimeException )
+uno::Reference< text::XTextRange > SAL_CALL
+SwXParagraph::getStart() throw (uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
-    uno::Reference< text::XTextRange >  xRet;
-    const SwTxtNode * pTxtNode( GetTxtNode() );
-    if (pTxtNode)
-    {
-        SwPosition aPos( *pTxtNode );
-        SwCursor aCursor( aPos, 0, false );
-        SwParaSelection aParaSel( &aCursor );
-        SwPaM aPam( *aCursor.Start() );
-        uno::Reference< text::XText >  xParent = getText();
-        xRet = new SwXTextRange(aPam, xParent);
-    }
-    else
-        throw uno::RuntimeException();
+
+    SwTxtNode & rTxtNode(m_pImpl->GetTxtNodeOrThrow());
+
+    SwPosition aPos( rTxtNode );
+    SwCursor aCursor( aPos, 0, false );
+    SwParaSelection aParaSel( aCursor );
+    SwPaM aPam( *aCursor.Start() );
+    uno::Reference< text::XText >  xParent = getText();
+    const uno::Reference< text::XTextRange > xRet =
+        new SwXTextRange(aPam, xParent);
     return xRet;
 }
 /*-- 11.12.98 08:12:56---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-uno::Reference< text::XTextRange >  SwXParagraph::getEnd(void) throw( uno::RuntimeException )
+uno::Reference< text::XTextRange > SAL_CALL
+SwXParagraph::getEnd() throw (uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
-    uno::Reference< text::XTextRange >  xRet;
-    const SwTxtNode * pTxtNode( GetTxtNode() );
-    if (pTxtNode)
-    {
-        SwPosition aPos( *pTxtNode );
-        SwCursor aCursor( aPos, 0, false );
-        SwParaSelection aParaSel( &aCursor );
-        SwPaM aPam( *aCursor.End() );
-        uno::Reference< text::XText >  xParent = getText();
-        xRet = new SwXTextRange(aPam, xParent);
-    }
-    else
-        throw uno::RuntimeException();
+
+    SwTxtNode & rTxtNode(m_pImpl->GetTxtNodeOrThrow());
+
+    SwPosition aPos( rTxtNode );
+    SwCursor aCursor( aPos, 0, false );
+    SwParaSelection aParaSel( aCursor );
+    SwPaM aPam( *aCursor.End() );
+    uno::Reference< text::XText >  xParent = getText();
+    const uno::Reference< text::XTextRange > xRet =
+        new SwXTextRange(aPam, xParent);
     return xRet;
 }
+
 /*-- 11.12.98 08:12:56---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-OUString SwXParagraph::getString(void) throw( uno::RuntimeException )
+OUString SAL_CALL SwXParagraph::getString() throw (uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
     OUString aRet;
-    const SwTxtNode * pTxtNode( GetTxtNode() );
+    SwTxtNode const*const pTxtNode( GetTxtNode() );
     if (pTxtNode)
     {
         SwPosition aPos( *pTxtNode );
         SwCursor aCursor( aPos, 0, false );
-        SwParaSelection aParaSel( & aCursor );
+        SwParaSelection aParaSel( aCursor );
         SwXTextCursor::getTextFromPam(aCursor, aRet);
     }
-    else if(IsDescriptor())
-        aRet = m_sText;
+    else if (m_pImpl->IsDescriptor())
+    {
+        aRet = m_pImpl->m_sText;
+    }
     else
+    {
         throw uno::RuntimeException();
+    }
     return aRet;
 }
 /*-- 11.12.98 08:12:57---------------------------------------------------
 
   -----------------------------------------------------------------------*/
-void SwXParagraph::setString(const OUString& aString) throw( uno::RuntimeException )
+void SAL_CALL SwXParagraph::setString(const OUString& aString)
+throw (uno::RuntimeException)
 {
     vos::OGuard aGuard(Application::GetSolarMutex());
 
-    const SwTxtNode * pTxtNode( GetTxtNode() );
+    SwTxtNode const*const pTxtNode( GetTxtNode() );
     if (pTxtNode)
     {
         SwPosition aPos( *pTxtNode );
@@ -1142,23 +1400,33 @@ void SwXParagraph::setString(const OUString& aString) throw( uno::RuntimeExcepti
         SwXTextCursor::SetString(aCursor, aString);
         SwXTextCursor::SelectPam(aCursor, sal_False);
     }
-    else if(IsDescriptor())
-        m_sText = aString;
+    else if (m_pImpl->IsDescriptor())
+    {
+        m_pImpl->m_sText = aString;
+    }
     else
+    {
         throw uno::RuntimeException();
-
+    }
 }
+
 /* -----------------23.03.99 12:49-------------------
  *
  * --------------------------------------------------*/
-uno::Reference< container::XEnumeration >  SwXParagraph::createContentEnumeration(const OUString& rServiceName)
-    throw( uno::RuntimeException )
+uno::Reference< container::XEnumeration > SAL_CALL
+SwXParagraph::createContentEnumeration(const OUString& rServiceName)
+throw (uno::RuntimeException)
 {
-    const SwTxtNode * pTxtNode( GetTxtNode() );
-    if(!pTxtNode || !rServiceName.equalsAscii("com.sun.star.text.TextContent"))
+    vos::OGuard g(Application::GetSolarMutex());
+
+    if (!rServiceName.equalsAscii("com.sun.star.text.TextContent"))
+    {
         throw uno::RuntimeException();
+    }
 
-    SwPosition aPos( *pTxtNode );
+    SwTxtNode & rTxtNode(m_pImpl->GetTxtNodeOrThrow());
+
+    SwPosition aPos( rTxtNode );
     SwPaM aPam( aPos );
     uno::Reference< container::XEnumeration > xRet =
         new SwXParaFrameEnumeration(aPam, PARAFRAME_PORTION_PARAGRAPH);
@@ -1167,50 +1435,31 @@ uno::Reference< container::XEnumeration >  SwXParagraph::createContentEnumeratio
 /* -----------------23.03.99 12:49-------------------
  *
  * --------------------------------------------------*/
-uno::Sequence< OUString > SwXParagraph::getAvailableServiceNames(void) throw( uno::RuntimeException )
+uno::Sequence< OUString > SAL_CALL
+SwXParagraph::getAvailableServiceNames() throw (uno::RuntimeException)
 {
     uno::Sequence< OUString > aRet(1);
     OUString* pArray = aRet.getArray();
     pArray[0] = C2U("com.sun.star.text.TextContent");
     return aRet;
 }
-/*-- 11.12.98 08:12:58---------------------------------------------------
-
-  -----------------------------------------------------------------------*/
-void SwXParagraph::Modify( SfxPoolItem *pOld, SfxPoolItem *pNew)
-{
-    ClientModify(this, pOld, pNew);
-    if(!GetRegisteredIn())
-        aLstnrCntnr.Disposing();
-}
-
-const SwTxtNode * SwXParagraph::GetTxtNode() const
-{
-        return static_cast<const SwTxtNode*>(GetRegisteredIn());
-}
 
-SwTxtNode * SwXParagraph::GetTxtNode()
-{
-        return static_cast<SwTxtNode*>(pRegisteredIn);
-}
 
+// MetadatableMixin
 ::sfx2::Metadatable* SwXParagraph::GetCoreObject()
 {
-    SwTxtNode * pTxtNode( GetTxtNode() );
+    SwTxtNode *const pTxtNode( m_pImpl->GetTxtNode() );
     return pTxtNode;
 }
 
 uno::Reference<frame::XModel> SwXParagraph::GetModel()
 {
-    SwTxtNode * pTxtNode( GetTxtNode() );
+    SwTxtNode *const pTxtNode( m_pImpl->GetTxtNode() );
     if (pTxtNode)
     {
-        const SwDocShell * pShell( pTxtNode->GetDoc()->GetDocShell() );
+        SwDocShell const*const pShell( pTxtNode->GetDoc()->GetDocShell() );
         return (pShell) ? pShell->GetModel() : 0;
     }
-    else
-    {
-        return 0;
-    }
+    return 0;
 }
 
diff --git a/sw/source/core/unocore/unotext.cxx b/sw/source/core/unocore/unotext.cxx
index e571cd722f6c..75eebe7047b2 100644
--- a/sw/source/core/unocore/unotext.cxx
+++ b/sw/source/core/unocore/unotext.cxx
@@ -666,7 +666,10 @@ void SwXText::insertTextContentBefore(
         throw aRuntime;
     }
 
-    SwXParagraph* pPara = SwXParagraph::GetImplementation(xNewContent);
+    const uno::Reference<lang::XUnoTunnel> xParaTunnel(xNewContent,
+            uno::UNO_QUERY);
+    SwXParagraph *const pPara =
+            ::sw::UnoTunnelGetImplementation<SwXParagraph>(xParaTunnel);
     if(!pPara || !pPara->IsDescriptor() || !xSuccessor.is())
         throw lang::IllegalArgumentException();
 
@@ -718,7 +721,10 @@ void SwXText::insertTextContentAfter(
     vos::OGuard aGuard(Application::GetSolarMutex());
     if(!GetDoc())
         throw uno::RuntimeException();
-    SwXParagraph* pPara = SwXParagraph::GetImplementation(xNewContent);
+    const uno::Reference<lang::XUnoTunnel> xParaTunnel(xNewContent,
+            uno::UNO_QUERY);
+    SwXParagraph *const pPara =
+            ::sw::UnoTunnelGetImplementation<SwXParagraph>(xParaTunnel);
     if(!pPara || !pPara->IsDescriptor() || !xPredecessor.is())
         throw lang::IllegalArgumentException();
 
@@ -1414,7 +1420,10 @@ uno::Reference< text::XTextRange > SwXText::finishOrAppendParagraph(
         }
         SwTxtNode * pTxtNode( aPam.Start()->nNode.GetNode().GetTxtNode() );
         OSL_ENSURE(pTxtNode, "no SwTxtNode?");
-        xRet = new SwXParagraph(this, pTxtNode);
+        if (pTxtNode)
+        {
+            xRet.set(SwXParagraph::CreateXParagraph(*pDoc, *pTxtNode, this), uno::UNO_QUERY);
+        }
     }
 
     return xRet;