Renamed 'SwRedline' to 'SwRangeRedline'

This is in preparation to adding more types of 'SwRedlines'.

Change-Id: Id61217ed3c4622f7689427ea9f30e364f6bb65d1
Reviewed-on: https://gerrit.libreoffice.org/7410
Reviewed-by: Miklos Vajna <vmiklos@collabora.co.uk>
Tested-by: Miklos Vajna <vmiklos@collabora.co.uk>

67 files changed, 332 insertions, 332 deletions

diff --git a/sw/inc/IDocumentRedlineAccess.hxx b/sw/inc/IDocumentRedlineAccess.hxx
index ddea588de31b..8125717feb5e 100644
--- a/sw/inc/IDocumentRedlineAccess.hxx
+++ b/sw/inc/IDocumentRedlineAccess.hxx
@@ -27,7 +27,7 @@
 
  #include <com/sun/star/uno/Sequence.hxx>
 
- class SwRedline;
+ class SwRangeRedline;
  class SwRedlineTbl;
  class SwPaM;
  struct SwPosition;
@@ -141,7 +141,7 @@ public:
 
         @returns
     */
-    virtual bool AppendRedline(/*[in]*/SwRedline* pPtr, /*[in]*/bool bCallDelete) = 0;
+    virtual bool AppendRedline(/*[in]*/SwRangeRedline* pPtr, /*[in]*/bool bCallDelete) = 0;
 
     virtual bool SplitRedline(/*[in]*/const SwPaM& rPam) = 0;
 
@@ -161,7 +161,7 @@ public:
 
     virtual void CompressRedlines() = 0;
 
-    virtual const SwRedline* GetRedline(
+    virtual const SwRangeRedline* GetRedline(
         /*[in]*/const SwPosition& rPos,
         /*[in]*/sal_uInt16* pFndPos) const = 0;
 
@@ -177,9 +177,9 @@ public:
 
     virtual bool RejectRedline(/*[in]*/const SwPaM& rPam, /*[in]*/bool bCallDelete) = 0;
 
-    virtual const SwRedline* SelNextRedline(/*[in]*/SwPaM& rPam) const = 0;
+    virtual const SwRangeRedline* SelNextRedline(/*[in]*/SwPaM& rPam) const = 0;
 
-    virtual const SwRedline* SelPrevRedline(/*[in]*/SwPaM& rPam) const = 0;
+    virtual const SwRangeRedline* SelPrevRedline(/*[in]*/SwPaM& rPam) const = 0;
 
     // Representation has changed, invalidate all Redlines.
     virtual void UpdateRedlineAttr() = 0;
diff --git a/sw/inc/crsrsh.hxx b/sw/inc/crsrsh.hxx
index 160ae4dbfd25..cfb409f7e041 100644
--- a/sw/inc/crsrsh.hxx
+++ b/sw/inc/crsrsh.hxx
@@ -60,7 +60,7 @@ class SwFmtINetFmt;
 class SwTxtAttr;
 class SwTableBox;
 class SwTOXMark;
-class SwRedline;
+class SwRangeRedline;
 class IBlockCursor;
 class SwCntntNode;
 class SwPostItField;
@@ -108,7 +108,7 @@ struct SwContentAtPos
     union {
         const SwField* pFld;
         const SfxPoolItem* pAttr;
-        const SwRedline* pRedl;
+        const SwRangeRedline* pRedl;
         SwCntntNode * pNode;
         const sw::mark::IFieldmark* pFldmark;
     } aFnd;
@@ -263,7 +263,7 @@ private:
 typedef sal_Bool (SwCursor:: *FNCrsr)();
     SW_DLLPRIVATE sal_Bool CallCrsrFN( FNCrsr );
 
-    SW_DLLPRIVATE const SwRedline* _GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect );
+    SW_DLLPRIVATE const SwRangeRedline* _GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect );
 
 protected:
 
@@ -817,9 +817,9 @@ public:
                             SwRect& rRect, short& rOrient );
     sal_Bool SetShadowCrsrPos( const Point& rPt, SwFillMode eFillMode );
 
-    const SwRedline* SelNextRedline();
-    const SwRedline* SelPrevRedline();
-    const SwRedline* GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect = sal_False );
+    const SwRangeRedline* SelNextRedline();
+    const SwRangeRedline* SelPrevRedline();
+    const SwRangeRedline* GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect = sal_False );
 
     // is cursor or the point in/over a vertical formatted text?
     bool IsInVerticalText( const Point* pPt = 0 ) const;
diff --git a/sw/inc/doc.hxx b/sw/inc/doc.hxx
index de4487cdf0fa..4f2bea99bf0f 100644
--- a/sw/inc/doc.hxx
+++ b/sw/inc/doc.hxx
@@ -142,7 +142,7 @@ class SwNumRule;
 class SwNumRuleTbl;
 class SwPageDesc;
 class SwPagePreviewPrtData;
-class SwRedline;
+class SwRangeRedline;
 class SwRedlineTbl;
 class SwRootFrm;
 class SwRubyList;
@@ -767,21 +767,21 @@ public:
     virtual bool IsIgnoreRedline() const;
     virtual bool IsInRedlines(const SwNode& rNode) const;
     virtual const SwRedlineTbl& GetRedlineTbl() const;
-    virtual bool AppendRedline(/*[in]*/SwRedline* pPtr, /*[in]*/bool bCallDelete);
+    virtual bool AppendRedline(/*[in]*/SwRangeRedline* pPtr, /*[in]*/bool bCallDelete);
     virtual bool SplitRedline(const SwPaM& rPam);
     virtual bool DeleteRedline(/*[in]*/const SwPaM& rPam, /*[in]*/bool bSaveInUndo, /*[in]*/sal_uInt16 nDelType);
     virtual bool DeleteRedline(/*[in]*/const SwStartNode& rSection, /*[in]*/bool bSaveInUndo, /*[in]*/sal_uInt16 nDelType);
     virtual sal_uInt16 GetRedlinePos(/*[in]*/const SwNode& rNode, /*[in]*/sal_uInt16 nType) const;
     virtual void CompressRedlines();
-    virtual const SwRedline* GetRedline(/*[in]*/const SwPosition& rPos, /*[in]*/sal_uInt16* pFndPos) const;
+    virtual const SwRangeRedline* GetRedline(/*[in]*/const SwPosition& rPos, /*[in]*/sal_uInt16* pFndPos) const;
     virtual bool IsRedlineMove() const;
     virtual void SetRedlineMove(/*[in]*/bool bFlag);
     virtual bool AcceptRedline(/*[in]*/sal_uInt16 nPos, /*[in]*/bool bCallDelete);
     virtual bool AcceptRedline(/*[in]*/const SwPaM& rPam, /*[in]*/bool bCallDelete);
     virtual bool RejectRedline(/*[in]*/sal_uInt16 nPos, /*[in]*/bool bCallDelete);
     virtual bool RejectRedline(/*[in]*/const SwPaM& rPam, /*[in]*/bool bCallDelete);
-    virtual const SwRedline* SelNextRedline(/*[in]*/SwPaM& rPam) const;
-    virtual const SwRedline* SelPrevRedline(/*[in]*/SwPaM& rPam) const;
+    virtual const SwRangeRedline* SelNextRedline(/*[in]*/SwPaM& rPam) const;
+    virtual const SwRangeRedline* SelPrevRedline(/*[in]*/SwPaM& rPam) const;
     virtual void UpdateRedlineAttr();
     virtual sal_uInt16 GetRedlineAuthor();
     virtual sal_uInt16 InsertRedlineAuthor(const OUString& rAuthor);
diff --git a/sw/inc/docary.hxx b/sw/inc/docary.hxx
index 8927cdea2eeb..ea868e846046 100644
--- a/sw/inc/docary.hxx
+++ b/sw/inc/docary.hxx
@@ -33,7 +33,7 @@ class SwTOXType;
 class SwUndo;
 class SwSectionFmt;
 class SwNumRule;
-class SwRedline;
+class SwRangeRedline;
 class SwUnoCrsr;
 class SwOLENode;
 class SwTxtFmtColl;
@@ -140,10 +140,10 @@ public:
 
 struct CompareSwRedlineTbl
 {
-    bool operator()(SwRedline* const &lhs, SwRedline* const &rhs) const;
+    bool operator()(SwRangeRedline* const &lhs, SwRangeRedline* const &rhs) const;
 };
 class _SwRedlineTbl
-    : public o3tl::sorted_vector<SwRedline*, CompareSwRedlineTbl,
+    : public o3tl::sorted_vector<SwRangeRedline*, CompareSwRedlineTbl,
                 o3tl::find_partialorder_ptrequals>
 {
 public:
@@ -153,15 +153,15 @@ public:
 class SwRedlineTbl : private _SwRedlineTbl
 {
 public:
-    bool Contains(const SwRedline* p) const { return find(const_cast<SwRedline* const>(p)) != end(); }
-    sal_uInt16 GetPos(const SwRedline* p) const;
+    bool Contains(const SwRangeRedline* p) const { return find(const_cast<SwRangeRedline* const>(p)) != end(); }
+    sal_uInt16 GetPos(const SwRangeRedline* p) const;
 
-    bool Insert( SwRedline* p, bool bIns = true );
-    bool Insert( SwRedline* p, sal_uInt16& rInsPos, bool bIns = true );
-    bool InsertWithValidRanges( SwRedline* p, sal_uInt16* pInsPos = 0 );
+    bool Insert( SwRangeRedline* p, bool bIns = true );
+    bool Insert( SwRangeRedline* p, sal_uInt16& rInsPos, bool bIns = true );
+    bool InsertWithValidRanges( SwRangeRedline* p, sal_uInt16* pInsPos = 0 );
 
     void Remove( sal_uInt16 nPos );
-    bool Remove( const SwRedline* p );
+    bool Remove( const SwRangeRedline* p );
     void DeleteAndDestroy( sal_uInt16 nPos, sal_uInt16 nLen = 1 );
     void DeleteAndDestroyAll();
 
diff --git a/sw/inc/editsh.hxx b/sw/inc/editsh.hxx
index 9991fd014987..eebd616870f5 100644
--- a/sw/inc/editsh.hxx
+++ b/sw/inc/editsh.hxx
@@ -86,7 +86,7 @@ class SwTxtINetFmt;
 class SwSeqFldList;
 class SwGlblDocContent;
 class SwGlblDocContents;
-class SwRedline;
+class SwRangeRedline;
 class SwRedlineData;
 class SwFtnInfo;
 class SwEndNoteInfo;
@@ -891,7 +891,7 @@ public:
     void SetRedlineMode( sal_uInt16 eMode );
     sal_Bool IsRedlineOn() const;
     sal_uInt16 GetRedlineCount() const;
-    const SwRedline& GetRedline( sal_uInt16 nPos ) const;
+    const SwRangeRedline& GetRedline( sal_uInt16 nPos ) const;
     sal_Bool AcceptRedline( sal_uInt16 nPos );
     sal_Bool RejectRedline( sal_uInt16 nPos );
 
@@ -903,7 +903,7 @@ public:
 
     /// Set comment to Redline at position.
     sal_Bool SetRedlineComment( const OUString& rS );
-    const SwRedline* GetCurrRedline() const;
+    const SwRangeRedline* GetCurrRedline() const;
 
     /// Redline attributes have been changed. Updated views.
     void UpdateRedlineAttr();
diff --git a/sw/inc/redline.hxx b/sw/inc/redline.hxx
index ff84272f708a..7895d617d92b 100644
--- a/sw/inc/redline.hxx
+++ b/sw/inc/redline.hxx
@@ -105,7 +105,7 @@ public:
 
 class SW_DLLPUBLIC SwRedlineData
 {
-    friend class SwRedline;
+    friend class SwRangeRedline;
     SwRedlineData* pNext;       // Points to other data.
     SwRedlineExtraData* pExtraData;
 
@@ -181,7 +181,7 @@ public:
 };
 
 
-class SW_DLLPUBLIC SwRedline : public SwPaM
+class SW_DLLPUBLIC SwRangeRedline : public SwPaM
 {
     SwRedlineData* pRedlineData;
     SwNodeIndex* pCntntSect;
@@ -195,17 +195,17 @@ class SW_DLLPUBLIC SwRedline : public SwPaM
     void MoveFromSection();
 
 public:
-    SwRedline( RedlineType_t eType, const SwPaM& rPam );
-    SwRedline( const SwRedlineData& rData, const SwPaM& rPam );
-    SwRedline( const SwRedlineData& rData, const SwPosition& rPos );
+    SwRangeRedline( RedlineType_t eType, const SwPaM& rPam );
+    SwRangeRedline( const SwRedlineData& rData, const SwPaM& rPam );
+    SwRangeRedline( const SwRedlineData& rData, const SwPosition& rPos );
     // For sw3io: pData is taken over!
-    SwRedline(SwRedlineData* pData, const SwPosition& rPos, sal_Bool bVsbl,
+    SwRangeRedline(SwRedlineData* pData, const SwPosition& rPos, sal_Bool bVsbl,
                sal_Bool bDelLP, sal_Bool bIsPD) :
         SwPaM( rPos ), pRedlineData( pData ), pCntntSect( 0 ),
         bDelLastPara( bDelLP ), bIsLastParaDelete( bIsPD ), bIsVisible( bVsbl )
     {}
-    SwRedline( const SwRedline& );
-    virtual ~SwRedline();
+    SwRangeRedline( const SwRangeRedline& );
+    virtual ~SwRangeRedline();
 
     SwNodeIndex* GetContentIdx() const { return pCntntSect; }
     // For Undo.
@@ -275,11 +275,11 @@ public:
     /// Initiate the layout.
     void InvalidateRange();
 
-    sal_Bool IsOwnRedline( const SwRedline& rRedl ) const
+    sal_Bool IsOwnRedline( const SwRangeRedline& rRedl ) const
         { return GetAuthor() == rRedl.GetAuthor(); }
-    sal_Bool CanCombine( const SwRedline& rRedl ) const;
+    sal_Bool CanCombine( const SwRangeRedline& rRedl ) const;
 
-    void PushData( const SwRedline& rRedl, sal_Bool bOwnAsNext = sal_True );
+    void PushData( const SwRangeRedline& rRedl, sal_Bool bOwnAsNext = sal_True );
     sal_Bool PopData();
 
     /**
@@ -295,8 +295,8 @@ public:
      */
     OUString GetDescr(sal_uInt16 nPos = 0);
 
-    int operator==( const SwRedline& ) const;
-    int operator<( const SwRedline& ) const;
+    int operator==( const SwRangeRedline& ) const;
+    int operator<( const SwRangeRedline& ) const;
 };
 
 class SW_DLLPUBLIC SwRedlineHint : public SfxHint
@@ -307,19 +307,19 @@ class SW_DLLPUBLIC SwRedlineHint : public SfxHint
 #define SWREDLINE_CHANGED   4
 #define SWREDLINE_LANGUAGE  5
 
-    const SwRedline* pRedline;
+    const SwRangeRedline* pRedline;
     sal_Int16 nWhich;
     const SwView* pView;
 
 public:
-    SwRedlineHint( const SwRedline* p, sal_Int16 n, const SwView* pV = 0)
+    SwRedlineHint( const SwRangeRedline* p, sal_Int16 n, const SwView* pV = 0)
         : pRedline(p)
         , nWhich(n)
         , pView(pV)
         {}
 
     TYPEINFO();
-    const SwRedline* GetRedline() const { return pRedline; }
+    const SwRangeRedline* GetRedline() const { return pRedline; }
     sal_Int16 Which() const { return nWhich; }
         const SwView* GetView() const { return pView; }
 };
diff --git a/sw/inc/unoredline.hxx b/sw/inc/unoredline.hxx
index 25d2e7904ee9..4ef269008420 100644
--- a/sw/inc/unoredline.hxx
+++ b/sw/inc/unoredline.hxx
@@ -22,7 +22,7 @@
 #include <unotext.hxx>
 
 
-class SwRedline;
+class SwRangeRedline;
 
 /**
  * SwXRedlineText provides an XText which may be used to write
@@ -71,9 +71,9 @@ class SwXRedline :
         public SwClient
 {
     SwDoc*      pDoc;
-    SwRedline*  pRedline;
+    SwRangeRedline*  pRedline;
 public:
-    SwXRedline(SwRedline& rRedline, SwDoc& rDoc);
+    SwXRedline(SwRangeRedline& rRedline, SwDoc& rDoc);
     ~SwXRedline();
 
     TYPEINFO();
@@ -105,7 +105,7 @@ public:
     virtual ::com::sun::star::uno::Type SAL_CALL getElementType(  ) throw(::com::sun::star::uno::RuntimeException);
     virtual sal_Bool SAL_CALL hasElements(  ) throw(::com::sun::star::uno::RuntimeException);
 
-    const SwRedline*    GetRedline() const {return pRedline;}
+    const SwRangeRedline*    GetRedline() const {return pRedline;}
 protected:
     //SwClient
    virtual void Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew);
diff --git a/sw/inc/unoredlines.hxx b/sw/inc/unoredlines.hxx
index ed2595ae4506..ea2527dace11 100644
--- a/sw/inc/unoredlines.hxx
+++ b/sw/inc/unoredlines.hxx
@@ -23,7 +23,7 @@
 #include <unobaseclass.hxx>
 #include <com/sun/star/container/XEnumerationAccess.hpp>
 
-class SwRedline;
+class SwRangeRedline;
 namespace com{ namespace sun{ namespace star{
         namespace beans{
             class XPropertySet;
@@ -62,7 +62,7 @@ public:
     virtual sal_Bool SAL_CALL supportsService(const OUString& ServiceName) throw( ::com::sun::star::uno::RuntimeException );
     virtual ::com::sun::star::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames(void) throw( ::com::sun::star::uno::RuntimeException );
 
-    static ::com::sun::star::beans::XPropertySet*           GetObject( SwRedline& rRedline, SwDoc& rDoc );
+    static ::com::sun::star::beans::XPropertySet*           GetObject( SwRangeRedline& rRedline, SwDoc& rDoc );
 };
 
 class SwXRedlineEnumeration
diff --git a/sw/source/core/access/accpara.cxx b/sw/source/core/access/accpara.cxx
index b629d424912d..6f23da119829 100644
--- a/sw/source/core/access/accpara.cxx
+++ b/sw/source/core/access/accpara.cxx
@@ -715,9 +715,9 @@ short SwAccessibleParagraph::GetTOCLevel()
 }
 
 //the function is to check whether the position is in a redline range.
-const SwRedline* SwAccessibleParagraph::GetRedlineAtIndex( sal_Int32 )
+const SwRangeRedline* SwAccessibleParagraph::GetRedlineAtIndex( sal_Int32 )
 {
-    const SwRedline* pRedline = NULL;
+    const SwRangeRedline* pRedline = NULL;
     SwPaM* pCrSr = GetCursor( true );
     if ( pCrSr )
     {
@@ -2285,7 +2285,7 @@ void SwAccessibleParagraph::_correctValues( const sal_Int32 nIndex,
 {
     PropertyValue ChangeAttr, ChangeAttrColor;
 
-    const SwRedline* pRedline = GetRedlineAtIndex( nIndex );
+    const SwRangeRedline* pRedline = GetRedlineAtIndex( nIndex );
     if ( pRedline )
     {
 
diff --git a/sw/source/core/access/accpara.hxx b/sw/source/core/access/accpara.hxx
index 37e76078619b..ff02bb364923 100644
--- a/sw/source/core/access/accpara.hxx
+++ b/sw/source/core/access/accpara.hxx
@@ -39,7 +39,7 @@ class SwTxtNode;
 class SwPaM;
 class SwAccessiblePortionData;
 class SwAccessibleHyperTextData;
-class SwRedline;
+class SwRangeRedline;
 class SwXTextPortion;
 class SwParaChangeTrackingInfo; //#i108125#
 
@@ -139,7 +139,7 @@ class SwAccessibleParagraph :
         }
     }
 
-    const SwRedline* GetRedlineAtIndex( sal_Int32 nPos );
+    const SwRangeRedline* GetRedlineAtIndex( sal_Int32 nPos );
     OUString GetFieldTypeNameAtIndex(sal_Int32 nIndex);
 
     // #i63870#
diff --git a/sw/source/core/access/parachangetrackinginfo.cxx b/sw/source/core/access/parachangetrackinginfo.cxx
index b76d9d361bd9..0ad7a77b01c4 100644
--- a/sw/source/core/access/parachangetrackinginfo.cxx
+++ b/sw/source/core/access/parachangetrackinginfo.cxx
@@ -83,7 +83,7 @@ namespace {
               nActRedline < nRedlineCount;
               ++nActRedline)
         {
-            const SwRedline* pActRedline = rRedlineTbl[ nActRedline ];
+            const SwRangeRedline* pActRedline = rRedlineTbl[ nActRedline ];
             if ( pActRedline->Start()->nNode > rTxtNode.GetIndex() )
             {
                 break;
diff --git a/sw/source/core/crsr/crstrvl.cxx b/sw/source/core/crsr/crstrvl.cxx
index 1d5f42e47ab3..724b5ceaa250 100644
--- a/sw/source/core/crsr/crstrvl.cxx
+++ b/sw/source/core/crsr/crstrvl.cxx
@@ -1451,7 +1451,7 @@ sal_Bool SwCrsrShell::GetContentAtPos( const Point& rPt,
 
                 if( !bRet && SwContentAtPos::SW_REDLINE & rCntntAtPos.eCntntAtPos )
                 {
-                    const SwRedline* pRedl = GetDoc()->GetRedline(aPos, NULL);
+                    const SwRangeRedline* pRedl = GetDoc()->GetRedline(aPos, NULL);
                     if( pRedl )
                     {
                         rCntntAtPos.aFnd.pRedl = pRedl;
@@ -1974,9 +1974,9 @@ sal_Bool SwCrsrShell::SetShadowCrsrPos( const Point& rPt, SwFillMode eFillMode )
     return bRet;
 }
 
-const SwRedline* SwCrsrShell::SelNextRedline()
+const SwRangeRedline* SwCrsrShell::SelNextRedline()
 {
-    const SwRedline* pFnd = 0;
+    const SwRangeRedline* pFnd = 0;
     if( !IsTableMode() )
     {
         SET_CURR_SHELL( this );
@@ -1992,9 +1992,9 @@ const SwRedline* SwCrsrShell::SelNextRedline()
     return pFnd;
 }
 
-const SwRedline* SwCrsrShell::SelPrevRedline()
+const SwRangeRedline* SwCrsrShell::SelPrevRedline()
 {
-    const SwRedline* pFnd = 0;
+    const SwRangeRedline* pFnd = 0;
     if( !IsTableMode() )
     {
         SET_CURR_SHELL( this );
@@ -2010,9 +2010,9 @@ const SwRedline* SwCrsrShell::SelPrevRedline()
     return pFnd;
 }
 
-const SwRedline* SwCrsrShell::_GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect )
+const SwRangeRedline* SwCrsrShell::_GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect )
 {
-    const SwRedline* pFnd = 0;
+    const SwRangeRedline* pFnd = 0;
     SwCallLink aLk( *this ); // watch Crsr-Moves
     SwCrsrSaveState aSaveState( *m_pCurCrsr );
 
@@ -2078,15 +2078,15 @@ const SwRedline* SwCrsrShell::_GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect
     return pFnd;
 }
 
-const SwRedline* SwCrsrShell::GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect )
+const SwRangeRedline* SwCrsrShell::GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect )
 {
-    const SwRedline* pFnd = 0;
+    const SwRangeRedline* pFnd = 0;
     if( !IsTableMode() )
     {
         SET_CURR_SHELL( this );
 
         const SwRedlineTbl& rTbl = GetDoc()->GetRedlineTbl();
-        const SwRedline* pTmp = rTbl[ nArrPos ];
+        const SwRangeRedline* pTmp = rTbl[ nArrPos ];
         sal_uInt16 nSeqNo = pTmp->GetSeqNo();
         if( nSeqNo && bSelect )
         {
diff --git a/sw/source/core/crsr/swcrsr.cxx b/sw/source/core/crsr/swcrsr.cxx
index 20e3655d7974..8c1e28211149 100644
--- a/sw/source/core/crsr/swcrsr.cxx
+++ b/sw/source/core/crsr/swcrsr.cxx
@@ -1403,7 +1403,7 @@ static OUString lcl_MaskDeletedRedlines( const SwTxtNode* pTxtNd )
             sal_uInt16 nAct = rDoc.GetRedlinePos( *pTxtNd, USHRT_MAX );
             for ( ; nAct < rDoc.GetRedlineTbl().size(); nAct++ )
             {
-                const SwRedline* pRed = rDoc.GetRedlineTbl()[ nAct ];
+                const SwRangeRedline* pRed = rDoc.GetRedlineTbl()[ nAct ];
                 if ( pRed->Start()->nNode > pTxtNd->GetIndex() )
                     break;
 
diff --git a/sw/source/core/doc/doc.cxx b/sw/source/core/doc/doc.cxx
index b5603fd08838..7e8513285913 100644
--- a/sw/source/core/doc/doc.cxx
+++ b/sw/source/core/doc/doc.cxx
@@ -874,7 +874,7 @@ bool SwDoc::SplitNode( const SwPosition &rPos, bool bChkTableStart )
             aPam.SetMark();
             aPam.Move( fnMoveBackward );
             if( IsRedlineOn() )
-                AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
+                AppendRedline( new SwRangeRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
             else
                 SplitRedline( aPam );
         }
@@ -912,7 +912,7 @@ bool SwDoc::AppendTxtNode( SwPosition& rPos )
         aPam.SetMark();
         aPam.Move( fnMoveBackward );
         if( IsRedlineOn() )
-            AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
+            AppendRedline( new SwRangeRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
         else
             SplitRedline( aPam );
     }
@@ -1004,7 +1004,7 @@ bool SwDoc::InsertString( const SwPaM &rRg, const OUString &rStr,
         if( IsRedlineOn() )
         {
             AppendRedline(
-                new SwRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
+                new SwRangeRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
         }
         else
         {
diff --git a/sw/source/core/doc/docbm.cxx b/sw/source/core/doc/docbm.cxx
index e914069c3b63..224fae12e496 100644
--- a/sw/source/core/doc/docbm.cxx
+++ b/sw/source/core/doc/docbm.cxx
@@ -1325,7 +1325,7 @@ void _DelBookmarks(
     for(sal_uInt16 nCnt = 0; nCnt < rTbl.size(); ++nCnt )
     {
         // Is at position?
-        SwRedline* pRedl = rTbl[ nCnt ];
+        SwRangeRedline* pRedl = rTbl[ nCnt ];
 
         SwPosition *pRStt = &pRedl->GetBound(sal_True),
                    *pREnd = &pRedl->GetBound(sal_False);
@@ -1430,7 +1430,7 @@ void _SaveCntntIdx(SwDoc* pDoc,
     const SwRedlineTbl& rRedlTbl = pDoc->GetRedlineTbl();
     for( ; aSave.GetCount() < rRedlTbl.size(); aSave.IncCount() )
     {
-        const SwRedline* pRdl = rRedlTbl[ aSave.GetCount() ];
+        const SwRangeRedline* pRdl = rRedlTbl[ aSave.GetCount() ];
         int nPointPos = lcl_RelativePosition( *pRdl->GetPoint(), nNode, nCntnt );
         int nMarkPos = pRdl->HasMark() ? lcl_RelativePosition( *pRdl->GetMark(), nNode, nCntnt ) :
                                           nPointPos;
diff --git a/sw/source/core/doc/doccomp.cxx b/sw/source/core/doc/doccomp.cxx
index 0ae219b60bdf..12d5bb96d9d2 100644
--- a/sw/source/core/doc/doccomp.cxx
+++ b/sw/source/core/doc/doccomp.cxx
@@ -1687,7 +1687,7 @@ void SwCompareData::SetRedlinesToDoc( sal_Bool bUseDocInfo )
                 SwUndo *const pUndo(new SwUndoCompDoc( *pTmp, sal_False )) ;
                 rDoc.GetIDocumentUndoRedo().AppendUndo(pUndo);
             }
-            rDoc.AppendRedline( new SwRedline( aRedlnData, *pTmp ), true );
+            rDoc.AppendRedline( new SwRangeRedline( aRedlnData, *pTmp ), true );
 
         } while( pDelRing != ( pTmp = (SwPaM*)pTmp->GetNext() ));
     }
@@ -1749,7 +1749,7 @@ void SwCompareData::SetRedlinesToDoc( sal_Bool bUseDocInfo )
         }
 
         do {
-            if( rDoc.AppendRedline( new SwRedline( aRedlnData, *pTmp ), true) &&
+            if( rDoc.AppendRedline( new SwRangeRedline( aRedlnData, *pTmp ), true) &&
                 rDoc.GetIDocumentUndoRedo().DoesUndo())
             {
                 SwUndo *const pUndo(new SwUndoCompDoc( *pTmp, sal_True ));
@@ -1828,18 +1828,18 @@ long SwDoc::CompareDoc( const SwDoc& rDoc )
 
 class _SaveMergeRedlines : public Ring
 {
-    const SwRedline* pSrcRedl;
-    SwRedline* pDestRedl;
+    const SwRangeRedline* pSrcRedl;
+    SwRangeRedline* pDestRedl;
 public:
     _SaveMergeRedlines( const SwNode& rDstNd,
-                        const SwRedline& rSrcRedl, Ring* pRing );
+                        const SwRangeRedline& rSrcRedl, Ring* pRing );
     sal_uInt16 InsertRedline();
 
-    SwRedline* GetDestRedline() { return pDestRedl; }
+    SwRangeRedline* GetDestRedline() { return pDestRedl; }
 };
 
 _SaveMergeRedlines::_SaveMergeRedlines( const SwNode& rDstNd,
-                        const SwRedline& rSrcRedl, Ring* pRing )
+                        const SwRangeRedline& rSrcRedl, Ring* pRing )
     : Ring( pRing ), pSrcRedl( &rSrcRedl )
 {
     SwPosition aPos( rDstNd );
@@ -1847,7 +1847,7 @@ _SaveMergeRedlines::_SaveMergeRedlines( const SwNode& rDstNd,
     const SwPosition* pStt = rSrcRedl.Start();
     if( rDstNd.IsCntntNode() )
         aPos.nContent.Assign( ((SwCntntNode*)&rDstNd), pStt->nContent.GetIndex() );
-    pDestRedl = new SwRedline( rSrcRedl.GetRedlineData(), aPos );
+    pDestRedl = new SwRangeRedline( rSrcRedl.GetRedlineData(), aPos );
 
     if( nsRedlineType_t::REDLINE_DELETE == pDestRedl->GetType() )
     {
@@ -1914,7 +1914,7 @@ sal_uInt16 _SaveMergeRedlines::InsertRedline()
         const SwRedlineTbl& rRedlineTbl = pDoc->GetRedlineTbl();
         for( ; n < rRedlineTbl.size(); ++n )
         {
-            SwRedline* pRedl = rRedlineTbl[ n ];
+            SwRangeRedline* pRedl = rRedlineTbl[ n ];
             SwPosition* pRStt = pRedl->Start(),
                       * pREnd = pRStt == pRedl->GetPoint() ? pRedl->GetMark()
                                                            : pRedl->GetPoint();
@@ -1940,7 +1940,7 @@ sal_uInt16 _SaveMergeRedlines::InsertRedline()
 
                 case POS_OUTSIDE:
                     {
-                        SwRedline* pCpyRedl = new SwRedline(
+                        SwRangeRedline* pCpyRedl = new SwRangeRedline(
                             pDestRedl->GetRedlineData(), *pDStt );
                         pCpyRedl->SetMark();
                         *pCpyRedl->GetPoint() = *pRStt;
@@ -2033,7 +2033,7 @@ long SwDoc::MergeDoc( const SwDoc& rDoc )
         sal_uLong nMyEndOfExtra = GetNodes().GetEndOfExtras().GetIndex();
         for( sal_uInt16 n = 0; n < rSrcRedlTbl.size(); ++n )
         {
-            const SwRedline* pRedl = rSrcRedlTbl[ n ];
+            const SwRangeRedline* pRedl = rSrcRedlTbl[ n ];
             sal_uLong nNd = pRedl->GetPoint()->nNode.GetIndex();
             RedlineType_t eType = pRedl->GetType();
             if( nEndOfExtra < nNd &&
diff --git a/sw/source/core/doc/doccorr.cxx b/sw/source/core/doc/doccorr.cxx
index 6f8b07d82738..03aa3b386fdd 100644
--- a/sw/source/core/doc/doccorr.cxx
+++ b/sw/source/core/doc/doccorr.cxx
@@ -192,7 +192,7 @@ void SwDoc::CorrAbs(const SwNodeIndex& rOldNode,
         for (sal_uInt16 n = 0; n < rTbl.size(); )
         {
             // is on position ??
-            SwRedline *const pRedline( rTbl[ n ] );
+            SwRangeRedline *const pRedline( rTbl[ n ] );
             bool const bChanged =
                 lcl_PaMCorrAbs(*pRedline, *aPam.Start(), *aPam.End(), aNewPos);
             // clean up empty redlines: docredln.cxx asserts these as invalid
diff --git a/sw/source/core/doc/docedt.cxx b/sw/source/core/doc/docedt.cxx
index 4a4ad171d36e..fdba68e54dbd 100644
--- a/sw/source/core/doc/docedt.cxx
+++ b/sw/source/core/doc/docedt.cxx
@@ -54,12 +54,12 @@ using namespace ::com::sun::star::i18n;
 
 struct _SaveRedline
 {
-    SwRedline* pRedl;
+    SwRangeRedline* pRedl;
     sal_uInt32 nStt, nEnd;
     sal_Int32 nSttCnt;
     sal_Int32 nEndCnt;
 
-    _SaveRedline( SwRedline* pR, const SwNodeIndex& rSttIdx )
+    _SaveRedline( SwRangeRedline* pR, const SwNodeIndex& rSttIdx )
         : pRedl( pR )
     {
         const SwPosition* pStt = pR->Start(),
@@ -79,7 +79,7 @@ struct _SaveRedline
         pRedl->GetMark()->nContent.Assign( 0, 0 );
     }
 
-    _SaveRedline( SwRedline* pR, const SwPosition& rPos )
+    _SaveRedline( SwRangeRedline* pR, const SwPosition& rPos )
         : pRedl( pR )
     {
         const SwPosition* pStt = pR->Start(),
@@ -465,7 +465,7 @@ static void lcl_SaveRedlines( const SwPaM& aPam, _SaveRedlines& rArr )
     SwRedlineTbl& rRedlineTable = const_cast<SwRedlineTbl&>( pDoc->GetRedlineTbl() );
     for( ; nCurrentRedline < rRedlineTable.size(); nCurrentRedline++ )
     {
-        SwRedline* pCurrent = rRedlineTable[ nCurrentRedline ];
+        SwRangeRedline* pCurrent = rRedlineTable[ nCurrentRedline ];
         SwComparePosition eCompare =
             ComparePosition( *pCurrent->Start(), *pCurrent->End(),
                              *pStart, *pEnd);
@@ -484,7 +484,7 @@ static void lcl_SaveRedlines( const SwPaM& aPam, _SaveRedlines& rArr )
             if( eCompare == POS_OVERLAP_BEFORE  ||
                 eCompare == POS_OUTSIDE )
             {
-                SwRedline* pNewRedline = new SwRedline( *pCurrent );
+                SwRangeRedline* pNewRedline = new SwRangeRedline( *pCurrent );
                 *pNewRedline->End() = *pStart;
                 *pCurrent->Start() = *pStart;
                 pDoc->AppendRedline( pNewRedline, true );
@@ -494,7 +494,7 @@ static void lcl_SaveRedlines( const SwPaM& aPam, _SaveRedlines& rArr )
             if( eCompare == POS_OVERLAP_BEHIND  ||
                 eCompare == POS_OUTSIDE )
             {
-                SwRedline* pNewRedline = new SwRedline( *pCurrent );
+                SwRangeRedline* pNewRedline = new SwRangeRedline( *pCurrent );
                 *pNewRedline->Start() = *pEnd;
                 *pCurrent->End() = *pEnd;
                 pDoc->AppendRedline( pNewRedline, true );
@@ -540,7 +540,7 @@ static void lcl_SaveRedlines( const SwNodeRange& rRg, _SaveRedlines& rArr )
     SwRedlineTbl& rRedlTbl = (SwRedlineTbl&)pDoc->GetRedlineTbl();
 
     do {
-        SwRedline* pTmp = rRedlTbl[ nRedlPos ];
+        SwRangeRedline* pTmp = rRedlTbl[ nRedlPos ];
 
         const SwPosition* pRStt = pTmp->Start(),
                         * pREnd = pTmp->GetMark() == pRStt
@@ -552,7 +552,7 @@ static void lcl_SaveRedlines( const SwNodeRange& rRg, _SaveRedlines& rArr )
             {
                 // Create a copy and set the end of the original to the end of the MoveArea.
                 // The copy is moved too.
-                SwRedline* pNewRedl = new SwRedline( *pTmp );
+                SwRangeRedline* pNewRedl = new SwRangeRedline( *pTmp );
                 SwPosition* pTmpPos = pNewRedl->Start();
                 pTmpPos->nNode = rRg.aStart;
                 pTmpPos->nContent.Assign(
@@ -587,7 +587,7 @@ static void lcl_SaveRedlines( const SwNodeRange& rRg, _SaveRedlines& rArr )
             else
             {
                 // split
-                SwRedline* pNewRedl = new SwRedline( *pTmp );
+                SwRangeRedline* pNewRedl = new SwRangeRedline( *pTmp );
                 SwPosition* pTmpPos = pNewRedl->End();
                 pTmpPos->nNode = rRg.aEnd;
                 pTmpPos->nContent.Assign(
@@ -638,7 +638,7 @@ _SaveRedlEndPosForRestore::_SaveRedlEndPosForRestore( const SwNodeIndex& rInsIdx
         sal_uInt16 nFndPos;
         const SwPosition* pEnd;
         SwPosition aSrcPos( rInsIdx, SwIndex( rNd.GetCntntNode(), nCnt ));
-        const SwRedline* pRedl = pDest->GetRedline( aSrcPos, &nFndPos );
+        const SwRangeRedline* pRedl = pDest->GetRedline( aSrcPos, &nFndPos );
         while( nFndPos--
               && *( pEnd = ( pRedl = pDest->GetRedlineTbl()[ nFndPos ] )->End() ) == aSrcPos
               && *pRedl->Start() < aSrcPos )
@@ -796,7 +796,7 @@ bool SwDoc::Overwrite( const SwPaM &rRg, const OUString &rStr )
         // FIXME: this redline is WRONG: there is no DELETE, and the skipped
         // characters are also included in aPam
         SwPaM aPam( rPt.nNode, nStart, rPt.nNode, rPt.nContent.GetIndex() );
-        AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
+        AppendRedline( new SwRangeRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
     }
 
     SetModified();
@@ -1094,7 +1094,7 @@ bool SwDoc::MoveNodeRange( SwNodeRange& rRange, SwNodeIndex& rPos,
     }
 
     _SaveRedlines aSaveRedl;
-    std::vector<SwRedline*> aSavRedlInsPosArr;
+    std::vector<SwRangeRedline*> aSavRedlInsPosArr;
     if( DOC_MOVEREDLINES & eMvFlags && !GetRedlineTbl().empty() )
     {
         lcl_SaveRedlines( rRange, aSaveRedl );
@@ -1106,7 +1106,7 @@ bool SwDoc::MoveNodeRange( SwNodeRange& rRange, SwNodeIndex& rPos,
         {
             const SwPosition *pRStt, *pREnd;
             do {
-                SwRedline* pTmp = GetRedlineTbl()[ nRedlPos ];
+                SwRangeRedline* pTmp = GetRedlineTbl()[ nRedlPos ];
                 pRStt = pTmp->Start();
                 pREnd = pTmp->End();
                 if( pREnd->nNode == rPos && pRStt->nNode < rPos )
@@ -1165,7 +1165,7 @@ bool SwDoc::MoveNodeRange( SwNodeRange& rRange, SwNodeIndex& rPos,
         SwNode* pNewNd = &aIdx.GetNode();
         for( sal_uInt16 n = 0; n < aSavRedlInsPosArr.size(); ++n )
         {
-            SwRedline* pTmp = aSavRedlInsPosArr[ n ];
+            SwRangeRedline* pTmp = aSavRedlInsPosArr[ n ];
             if( GetRedlineTbl().Contains( pTmp ) )
             {
                 SwPosition* pEnd = pTmp->End();
@@ -1491,7 +1491,7 @@ bool SwDoc::DeleteAndJoinWithRedlineImpl( SwPaM & rPam, const bool )
             GetIDocumentUndoRedo().AppendUndo(pUndo);
         }
         if( *rPam.GetPoint() != *rPam.GetMark() )
-            AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_DELETE, rPam ), true);
+            AppendRedline( new SwRangeRedline( nsRedlineType_t::REDLINE_DELETE, rPam ), true);
         SetModified();
 
         if( pUndo )
@@ -2339,7 +2339,7 @@ bool SwDoc::ReplaceRangeImpl( SwPaM& rPam, const OUString& rStr,
                     new SwUndoRedlineDelete( aDelPam, UNDO_REPLACE );
                 GetIDocumentUndoRedo().AppendUndo(pUndoRD);
             }
-            AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_DELETE, aDelPam ), true);
+            AppendRedline( new SwRangeRedline( nsRedlineType_t::REDLINE_DELETE, aDelPam ), true);
 
             *rPam.GetMark() = *aDelPam.GetMark();
             if (GetIDocumentUndoRedo().DoesUndo())
diff --git a/sw/source/core/doc/docfmt.cxx b/sw/source/core/doc/docfmt.cxx
index 2a09e5987978..e8cc62021f73 100644
--- a/sw/source/core/doc/docfmt.cxx
+++ b/sw/source/core/doc/docfmt.cxx
@@ -637,7 +637,7 @@ static bool lcl_InsAttr(
                         pUndo->SaveRedlineData( aPam, sal_True );
 
                     if( pDoc->IsRedlineOn() )
-                        pDoc->AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
+                        pDoc->AppendRedline( new SwRangeRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
                     else
                         pDoc->SplitRedline( aPam );
                 }
@@ -680,7 +680,7 @@ static bool lcl_InsAttr(
 
                     if( pDoc->IsRedlineOn() )
                         pDoc->AppendRedline(
-                            new SwRedline(
+                            new SwRangeRedline(
                                 bTxtIns ? nsRedlineType_t::REDLINE_INSERT : nsRedlineType_t::REDLINE_FORMAT, aPam ),
                                 true);
                     else if( bTxtIns )
@@ -856,7 +856,7 @@ static bool lcl_InsAttr(
 
                 if( pUndo )
                     pUndo->SaveRedlineData( aPam, sal_False );
-                pDoc->AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_FORMAT, aPam ), true);
+                pDoc->AppendRedline( new SwRangeRedline( nsRedlineType_t::REDLINE_FORMAT, aPam ), true);
             }
         }
         if( pOtherSet && pOtherSet->Count() )
@@ -873,7 +873,7 @@ static bool lcl_InsAttr(
     {
         if( pUndo )
             pUndo->SaveRedlineData( rRg, sal_False );
-        pDoc->AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_FORMAT, rRg ), true);
+        pDoc->AppendRedline( new SwRangeRedline( nsRedlineType_t::REDLINE_FORMAT, rRg ), true);
     }
 
     /* now if range */
@@ -2427,7 +2427,7 @@ void SwDoc::SetTxtFmtCollByAutoFmt( const SwPosition& rPos, sal_uInt16 nPoolId,
     {
         // create the redline object
         const SwTxtFmtColl& rColl = *pTNd->GetTxtColl();
-        SwRedline* pRedl = new SwRedline( nsRedlineType_t::REDLINE_FMTCOLL, aPam );
+        SwRangeRedline* pRedl = new SwRangeRedline( nsRedlineType_t::REDLINE_FMTCOLL, aPam );
         pRedl->SetMark();
 
         // Only those items that are not set by the Set again in the Node
@@ -2471,7 +2471,7 @@ void SwDoc::SetFmtItemByAutoFmt( const SwPaM& rPam, const SfxItemSet& rSet )
     if (mbIsAutoFmtRedline)
     {
         // create the redline object
-        SwRedline* pRedl = new SwRedline( nsRedlineType_t::REDLINE_FORMAT, rPam );
+        SwRangeRedline* pRedl = new SwRangeRedline( nsRedlineType_t::REDLINE_FORMAT, rPam );
         if( !pRedl->HasMark() )
             pRedl->SetMark();
 
diff --git a/sw/source/core/doc/docnum.cxx b/sw/source/core/doc/docnum.cxx
index 8e54aa95bd6f..9e7c1eaa1c04 100644
--- a/sw/source/core/doc/docnum.cxx
+++ b/sw/source/core/doc/docnum.cxx
@@ -1820,7 +1820,7 @@ bool SwDoc::MoveParagraph( const SwPaM& rPam, long nOffset, bool bIsOutlMv )
             // There is a some Redline Delete Object for the range
             for( ; nRedlPos < GetRedlineTbl().size(); ++nRedlPos )
             {
-                const SwRedline* pTmp = GetRedlineTbl()[ nRedlPos ];
+                const SwRangeRedline* pTmp = GetRedlineTbl()[ nRedlPos ];
                 if( !bCheckDel || nsRedlineType_t::REDLINE_DELETE == pTmp->GetType() )
                 {
                     const SwPosition *pRStt = pTmp->Start(), *pREnd = pTmp->End();
@@ -1861,16 +1861,16 @@ bool SwDoc::MoveParagraph( const SwPaM& rPam, long nOffset, bool bIsOutlMv )
     SwNodeIndex aIdx( nOffset > 0 ? pEnd->nNode : pStt->nNode, nOffs );
     SwNodeRange aMvRg( pStt->nNode, 0, pEnd->nNode, +1 );
 
-    SwRedline* pOwnRedl = 0;
+    SwRangeRedline* pOwnRedl = 0;
     if( IsRedlineOn() )
     {
         // If the range is completely in the own Redline, we can move it!
         sal_uInt16 nRedlPos = GetRedlinePos( pStt->nNode.GetNode(), nsRedlineType_t::REDLINE_INSERT );
         if( USHRT_MAX != nRedlPos )
         {
-            SwRedline* pTmp = GetRedlineTbl()[ nRedlPos ];
+            SwRangeRedline* pTmp = GetRedlineTbl()[ nRedlPos ];
             const SwPosition *pRStt = pTmp->Start(), *pREnd = pTmp->End();
-            SwRedline aTmpRedl( nsRedlineType_t::REDLINE_INSERT, rPam );
+            SwRangeRedline aTmpRedl( nsRedlineType_t::REDLINE_INSERT, rPam );
             const SwCntntNode* pCEndNd = pEnd->nNode.GetNode().GetCntntNode();
             // Is completely in the range and is the own Redline too?
             if( aTmpRedl.IsOwnRedline( *pTmp ) &&
@@ -1953,7 +1953,7 @@ bool SwDoc::MoveParagraph( const SwPaM& rPam, long nOffset, bool bIsOutlMv )
                 SwPosition* pPos;
                 for( sal_uInt16 n = 0; n < GetRedlineTbl().size(); ++n )
                 {
-                    SwRedline* pTmp = GetRedlineTbl()[ n ];
+                    SwRangeRedline* pTmp = GetRedlineTbl()[ n ];
                     if( ( pPos = &pTmp->GetBound(sal_True))->nNode == aIdx )
                     {
                         pPos->nNode++;
@@ -1984,7 +1984,7 @@ bool SwDoc::MoveParagraph( const SwPaM& rPam, long nOffset, bool bIsOutlMv )
                 GetIDocumentUndoRedo().AppendUndo(pUndo);
             }
 
-            SwRedline* pNewRedline = new SwRedline( nsRedlineType_t::REDLINE_DELETE, aPam );
+            SwRangeRedline* pNewRedline = new SwRangeRedline( nsRedlineType_t::REDLINE_DELETE, aPam );
 
             // prevent assertion from aPam's target being deleted
             // (Alternatively, one could just let aPam go out of scope, but
diff --git a/sw/source/core/doc/docredln.cxx b/sw/source/core/doc/docredln.cxx
index f6c7b01f383d..9aeb7c42e3d6 100644
--- a/sw/source/core/doc/docredln.cxx
+++ b/sw/source/core/doc/docredln.cxx
@@ -104,8 +104,8 @@ TYPEINIT1(SwRedlineHint, SfxHint);
         // verify proper redline sorting
         for( sal_uInt16 n = 1; n < rTbl.size(); ++n )
         {
-            const SwRedline* pPrev = rTbl[ n-1 ];
-            const SwRedline* pCurrent = rTbl[ n ];
+            const SwRangeRedline* pPrev = rTbl[ n-1 ];
+            const SwRangeRedline* pCurrent = rTbl[ n ];
 
             // check redline sorting
             SAL_WARN_IF( *pPrev->Start() > *pCurrent->Start(), "sw",
@@ -126,8 +126,8 @@ TYPEINIT1(SwRedlineHint, SfxHint);
         for( sal_uInt16 n = 0; n < rTbl.size(); ++n )
         {
             sal_uInt16 nDummy = 0;
-            const SwRedline* pCurrent = rTbl[ n ];
-            const SwRedline* pNext = n+1 < (sal_uInt16)rTbl.size() ? rTbl[ n+1 ] : 0;
+            const SwRangeRedline* pCurrent = rTbl[ n ];
+            const SwRangeRedline* pNext = n+1 < (sal_uInt16)rTbl.size() ? rTbl[ n+1 ] : 0;
             if( pCurrent == pNext )
                 ++nDummy;
             if( n == nWatch )
@@ -156,22 +156,22 @@ void SwDoc::SetRedlineMode( RedlineMode_t eMode )
             bool bSaveInXMLImportFlag = IsInXMLImport();
             SetInXMLImport( false );
             // and then hide/display everything
-            void (SwRedline::*pFnc)( sal_uInt16 ) = 0;
+            void (SwRangeRedline::*pFnc)( sal_uInt16 ) = 0;
 
             switch( nsRedlineMode_t::REDLINE_SHOW_MASK & eMode )
             {
             case nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE :
-                pFnc = &SwRedline::Show;
+                pFnc = &SwRangeRedline::Show;
                 break;
             case nsRedlineMode_t::REDLINE_SHOW_INSERT:
-                pFnc = &SwRedline::Hide;
+                pFnc = &SwRangeRedline::Hide;
                 break;
             case nsRedlineMode_t::REDLINE_SHOW_DELETE:
-                pFnc = &SwRedline::ShowOriginal;
+                pFnc = &SwRangeRedline::ShowOriginal;
                 break;
 
             default:
-                pFnc = &SwRedline::Hide;
+                pFnc = &SwRangeRedline::Hide;
                 eMode = (RedlineMode_t)(eMode | nsRedlineMode_t::REDLINE_SHOW_INSERT);
                 break;
             }
@@ -285,7 +285,7 @@ Behaviour of Delete-Redline:
                                           other Insert is overlapped by
                                           the Delete
 */
-bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
+bool SwDoc::AppendRedline( SwRangeRedline* pNewRedl, bool bCallDelete )
 {
     bool bMerged = false;
     _CHECK_REDLINE( this )
@@ -360,7 +360,7 @@ bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
         {
             bDec = false;
 
-            SwRedline* pRedl = (*mpRedlineTbl)[ n ];
+            SwRangeRedline* pRedl = (*mpRedlineTbl)[ n ];
             SwPosition* pRStt = pRedl->Start(),
                       * pREnd = pRStt == pRedl->GetPoint() ? pRedl->GetMark()
                                                            : pRedl->GetPoint();
@@ -457,7 +457,7 @@ bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
                         // split up
                         if( *pEnd != *pREnd )
                         {
-                            SwRedline* pCpy = new SwRedline( *pRedl );
+                            SwRangeRedline* pCpy = new SwRangeRedline( *pRedl );
                             pCpy->SetStart( *pEnd );
                             mpRedlineTbl->Insert( pCpy );
                         }
@@ -482,7 +482,7 @@ bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
                         // split up the new redline, since it covers the
                         // existing redline. Insert the first part, and
                         // progress with the remainder as usual
-                        SwRedline* pSplit = new SwRedline( *pNewRedl );
+                        SwRangeRedline* pSplit = new SwRangeRedline( *pNewRedl );
                         pSplit->SetEnd( *pRStt );
                         pNewRedl->SetStart( *pREnd );
                         mpRedlineTbl->Insert( pSplit );
@@ -517,7 +517,7 @@ bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
                         // split up
                         if( *pEnd != *pREnd )
                         {
-                            SwRedline* pCpy = new SwRedline( *pRedl );
+                            SwRangeRedline* pCpy = new SwRangeRedline( *pRedl );
                             pCpy->SetStart( *pEnd );
                             mpRedlineTbl->Insert( pCpy );
                         }
@@ -542,7 +542,7 @@ bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
                         // split up the new redline, since it covers the
                         // existing redline. Insert the first part, and
                         // progress with the remainder as usual
-                        SwRedline* pSplit = new SwRedline( *pNewRedl );
+                        SwRangeRedline* pSplit = new SwRangeRedline( *pNewRedl );
                         pSplit->SetEnd( *pRStt );
                         pNewRedl->SetStart( *pREnd );
                         mpRedlineTbl->Insert( pSplit );
@@ -600,7 +600,7 @@ bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
                         {
                             if( *pEnd != *pRStt )
                             {
-                                SwRedline* pNew = new SwRedline( *pRedl );
+                                SwRangeRedline* pNew = new SwRangeRedline( *pRedl );
                                 pNew->SetStart( *pEnd );
                                 pRedl->SetEnd( *pStt, pREnd );
                                 if( *pStt == *pRStt && pRedl->GetContentIdx() == NULL )
@@ -634,7 +634,7 @@ bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
                             // split the new one
                             if( *pEnd != *pREnd )
                             {
-                                SwRedline* pNew = new SwRedline( *pNewRedl );
+                                SwRangeRedline* pNew = new SwRangeRedline( *pNewRedl );
                                 pNew->SetStart( *pREnd );
                                 pNewRedl->SetEnd( *pRStt, pEnd );
                                 AppendRedline( pNew, bCallDelete );
@@ -851,7 +851,7 @@ bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
                         // two. In this case, pRedl will be changed to cover
                         // only part of it's former range, and pNew will cover
                         // the remainder.
-                        SwRedline* pNew = 0;
+                        SwRangeRedline* pNew = 0;
 
                         switch( eCmpPos )
                         {
@@ -886,7 +886,7 @@ bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
                                     pNewRedl->PushData( *pRedl, sal_False );
                                     if( *pREnd != *pEnd )
                                     {
-                                        pNew = new SwRedline( *pRedl );
+                                        pNew = new SwRangeRedline( *pRedl );
                                         pNew->SetStart( *pEnd );
                                     }
                                     pRedl->SetEnd( *pStt, pREnd );
@@ -907,7 +907,7 @@ bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
                                     pNewRedl->SetEnd( *pRStt, pEnd );
                                 else
                                 {
-                                    pNew = new SwRedline( *pNewRedl );
+                                    pNew = new SwRangeRedline( *pNewRedl );
                                     pNew->SetEnd( *pRStt );
                                     pNewRedl->SetStart( *pREnd, pStt );
                                 }
@@ -930,7 +930,7 @@ bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
                                 }
                                 else
                                 {
-                                    pNew = new SwRedline( *pRedl );
+                                    pNew = new SwRangeRedline( *pRedl );
                                     pNew->PushData( *pNewRedl );
                                     pNew->SetEnd( *pEnd );
                                     pNewRedl->SetEnd( *pRStt, pEnd );
@@ -958,7 +958,7 @@ bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
                                 }
                                 else
                                 {
-                                    pNew = new SwRedline( *pRedl );
+                                    pNew = new SwRangeRedline( *pRedl );
                                     pNew->PushData( *pNewRedl );
                                     pNew->SetStart( *pStt );
                                     pNewRedl->SetStart( *pREnd, pStt );
@@ -1024,7 +1024,7 @@ bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
                         {
                             if( *pEnd != *pRStt )
                             {
-                                SwRedline* pNew = new SwRedline( *pRedl );
+                                SwRangeRedline* pNew = new SwRangeRedline( *pRedl );
                                 pNew->SetStart( *pEnd );
                                 pRedl->SetEnd( *pStt, pREnd );
                                 if( ( *pStt == *pRStt ) &&
@@ -1074,7 +1074,7 @@ bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
                         {
                             if( *pEnd != *pRStt )
                             {
-                                SwRedline* pNew = new SwRedline( *pNewRedl );
+                                SwRangeRedline* pNew = new SwRangeRedline( *pNewRedl );
                                 pNew->SetStart( *pREnd );
                                 pNewRedl->SetEnd( *pRStt, pEnd );
                                 AppendRedline( pNew, bCallDelete );
@@ -1124,7 +1124,7 @@ bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
                         {
                             // If it lies completely within the current one
                             // we need to split it
-                            SwRedline* pNew = new SwRedline( *pRedl );
+                            SwRangeRedline* pNew = new SwRangeRedline( *pRedl );
                             pNew->SetStart( *pEnd );
                             pRedl->SetEnd( *pStt, pREnd );
                             AppendRedline( pNew, bCallDelete );
@@ -1233,21 +1233,21 @@ void SwDoc::CompressRedlines()
 {
     _CHECK_REDLINE( this )
 
-    void (SwRedline::*pFnc)(sal_uInt16) = 0;
+    void (SwRangeRedline::*pFnc)(sal_uInt16) = 0;
     switch( nsRedlineMode_t::REDLINE_SHOW_MASK & meRedlineMode )
     {
     case nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE:
-        pFnc = &SwRedline::Show;
+        pFnc = &SwRangeRedline::Show;
         break;
     case nsRedlineMode_t::REDLINE_SHOW_INSERT:
-        pFnc = &SwRedline::Hide;
+        pFnc = &SwRangeRedline::Hide;
         break;
     }
 
     // Try to merge identical ones
     for( sal_uInt16 n = 1; n < mpRedlineTbl->size(); ++n )
     {
-        SwRedline* pPrev = (*mpRedlineTbl)[ n-1 ],
+        SwRangeRedline* pPrev = (*mpRedlineTbl)[ n-1 ],
                     * pCur = (*mpRedlineTbl)[ n ];
         const SwPosition* pPrevStt = pPrev->Start(),
                         * pPrevEnd = pPrevStt == pPrev->GetPoint()
@@ -1284,7 +1284,7 @@ bool SwDoc::SplitRedline( const SwPaM& rRange )
     GetRedline( *pStt, &n );
     for( ; n < mpRedlineTbl->size() ; ++n )
     {
-        SwRedline* pTmp = (*mpRedlineTbl)[ n ];
+        SwRangeRedline* pTmp = (*mpRedlineTbl)[ n ];
         SwPosition* pTStt = pTmp->Start(),
                   * pTEnd = pTStt == pTmp->GetPoint() ? pTmp->GetMark()
                                                       : pTmp->GetPoint();
@@ -1298,11 +1298,11 @@ bool SwDoc::SplitRedline( const SwPaM& rRange )
             if( *pEnd == *pTEnd )
                 nn += 2;
 
-            SwRedline* pNew = 0;
+            SwRangeRedline* pNew = 0;
             switch( nn )
             {
             case 0:
-                pNew = new SwRedline( *pTmp );
+                pNew = new SwRangeRedline( *pTmp );
                 pTmp->SetEnd( *pStt, pTEnd );
                 pNew->SetStart( *pEnd );
                 break;
@@ -1363,7 +1363,7 @@ bool SwDoc::DeleteRedline( const SwPaM& rRange, bool bSaveInUndo,
     GetRedline( *pStt, &n );
     for( ; n < mpRedlineTbl->size() ; ++n )
     {
-        SwRedline* pRedl = (*mpRedlineTbl)[ n ];
+        SwRangeRedline* pRedl = (*mpRedlineTbl)[ n ];
         if( USHRT_MAX != nDelType && nDelType != pRedl->GetType() )
             continue;
 
@@ -1414,10 +1414,10 @@ bool SwDoc::DeleteRedline( const SwPaM& rRange, bool bSaveInUndo,
                 }
                 else
                 {
-                    SwRedline* pCpy;
+                    SwRangeRedline* pCpy;
                     if( *pREnd != *pEnd )
                     {
-                        pCpy = new SwRedline( *pRedl );
+                        pCpy = new SwRangeRedline( *pRedl );
                         pCpy->SetStart( *pEnd );
                     }
                     else
@@ -1463,7 +1463,7 @@ sal_uInt16 SwDoc::GetRedlinePos( const SwNode& rNd, sal_uInt16 nType ) const
     const sal_uLong nNdIdx = rNd.GetIndex();
     for( sal_uInt16 n = 0; n < mpRedlineTbl->size() ; ++n )
     {
-        const SwRedline* pTmp = (*mpRedlineTbl)[ n ];
+        const SwRangeRedline* pTmp = (*mpRedlineTbl)[ n ];
         sal_uLong nPt = pTmp->GetPoint()->nNode.GetIndex(),
               nMk = pTmp->GetMark()->nNode.GetIndex();
         if( nPt < nMk ) { long nTmp = nMk; nMk = nPt; nPt = nTmp; }
@@ -1478,7 +1478,7 @@ sal_uInt16 SwDoc::GetRedlinePos( const SwNode& rNd, sal_uInt16 nType ) const
     return USHRT_MAX;
 }
 
-const SwRedline* SwDoc::GetRedline( const SwPosition& rPos,
+const SwRangeRedline* SwDoc::GetRedline( const SwPosition& rPos,
                                     sal_uInt16* pFndPos ) const
 {
     sal_uInt16 nO = mpRedlineTbl->size(), nM, nU = 0;
@@ -1488,7 +1488,7 @@ const SwRedline* SwDoc::GetRedline( const SwPosition& rPos,
         while( nU <= nO )
         {
             nM = nU + ( nO - nU ) / 2;
-            const SwRedline* pRedl = (*mpRedlineTbl)[ nM ];
+            const SwRangeRedline* pRedl = (*mpRedlineTbl)[ nM ];
             const SwPosition* pStt = pRedl->Start();
             const SwPosition* pEnd = pStt == pRedl->GetPoint()
                                         ? pRedl->GetMark()
@@ -1557,7 +1557,7 @@ static sal_Bool lcl_AcceptRedline( SwRedlineTbl& rArr, sal_uInt16& rPos,
                         const SwPosition* pEndRng = 0 )
 {
     sal_Bool bRet = sal_True;
-    SwRedline* pRedl = rArr[ rPos ];
+    SwRangeRedline* pRedl = rArr[ rPos ];
     SwPosition *pRStt = 0, *pREnd = 0;
     SwComparePosition eCmp = POS_OUTSIDE;
     if( pSttRng && pEndRng )
@@ -1585,7 +1585,7 @@ static sal_Bool lcl_AcceptRedline( SwRedlineTbl& rArr, sal_uInt16& rPos,
                     if( *pEndRng != *pREnd )
                     {
                         // split up
-                        SwRedline* pNew = new SwRedline( *pRedl );
+                        SwRangeRedline* pNew = new SwRangeRedline( *pRedl );
                         pNew->SetStart( *pEndRng );
                         rArr.Insert( pNew ); ++rPos;
                     }
@@ -1716,7 +1716,7 @@ static sal_Bool lcl_RejectRedline( SwRedlineTbl& rArr, sal_uInt16& rPos,
                         const SwPosition* pEndRng = 0 )
 {
     sal_Bool bRet = sal_True;
-    SwRedline* pRedl = rArr[ rPos ];
+    SwRangeRedline* pRedl = rArr[ rPos ];
     SwPosition *pRStt = 0, *pREnd = 0;
     SwComparePosition eCmp = POS_OUTSIDE;
     if( pSttRng && pEndRng )
@@ -1811,7 +1811,7 @@ static sal_Bool lcl_RejectRedline( SwRedlineTbl& rArr, sal_uInt16& rPos,
         break;
     case nsRedlineType_t::REDLINE_DELETE:
         {
-            SwRedline* pNew = 0;
+            SwRangeRedline* pNew = 0;
             bool bCheck = false, bReplace = false;
 
             switch( eCmp )
@@ -1820,7 +1820,7 @@ static sal_Bool lcl_RejectRedline( SwRedlineTbl& rArr, sal_uInt16& rPos,
                 {
                     if( 1 < pRedl->GetStackCount() )
                     {
-                        pNew = new SwRedline( *pRedl );
+                        pNew = new SwRangeRedline( *pRedl );
                         pNew->PopData();
                     }
                     if( *pSttRng == *pRStt )
@@ -1835,7 +1835,7 @@ static sal_Bool lcl_RejectRedline( SwRedlineTbl& rArr, sal_uInt16& rPos,
                         if( *pEndRng != *pREnd )
                         {
                             // split up
-                            SwRedline* pCpy = new SwRedline( *pRedl );
+                            SwRangeRedline* pCpy = new SwRangeRedline( *pRedl );
                             pCpy->SetStart( *pEndRng );
                             rArr.Insert( pCpy ); ++rPos;
                             if( pNew )
@@ -1853,7 +1853,7 @@ static sal_Bool lcl_RejectRedline( SwRedlineTbl& rArr, sal_uInt16& rPos,
             case POS_OVERLAP_BEFORE:
                 if( 1 < pRedl->GetStackCount() )
                 {
-                    pNew = new SwRedline( *pRedl );
+                    pNew = new SwRangeRedline( *pRedl );
                     pNew->PopData();
                 }
                 pRedl->SetStart( *pEndRng, pRStt );
@@ -1865,7 +1865,7 @@ static sal_Bool lcl_RejectRedline( SwRedlineTbl& rArr, sal_uInt16& rPos,
             case POS_OVERLAP_BEHIND:
                 if( 1 < pRedl->GetStackCount() )
                 {
-                    pNew = new SwRedline( *pRedl );
+                    pNew = new SwRangeRedline( *pRedl );
                     pNew->PopData();
                 }
                 pRedl->SetEnd( *pSttRng, pREnd );
@@ -1914,15 +1914,15 @@ static sal_Bool lcl_RejectRedline( SwRedlineTbl& rArr, sal_uInt16& rPos,
     return bRet;
 }
 
-static const SwRedline* lcl_FindCurrRedline( const SwPosition& rSttPos,
+static const SwRangeRedline* lcl_FindCurrRedline( const SwPosition& rSttPos,
                                         sal_uInt16& rPos,
                                         bool bNext = true )
 {
-    const SwRedline* pFnd = 0;
+    const SwRangeRedline* pFnd = 0;
     const SwRedlineTbl& rArr = rSttPos.nNode.GetNode().GetDoc()->GetRedlineTbl();
     for( ; rPos < rArr.size() ; ++rPos )
     {
-        const SwRedline* pTmp = rArr[ rPos ];
+        const SwRangeRedline* pTmp = rArr[ rPos ];
         if( pTmp->HasMark() && pTmp->IsVisible() )
         {
             const SwPosition* pRStt = pTmp->Start(),
@@ -1953,7 +1953,7 @@ static int lcl_AcceptRejectRedl( Fn_AcceptReject fn_AcceptReject,
     const SwPosition* pStt = rPam.Start(),
                     * pEnd = pStt == rPam.GetPoint() ? rPam.GetMark()
                                                      : rPam.GetPoint();
-    const SwRedline* pFnd = lcl_FindCurrRedline( *pStt, n, true );
+    const SwRangeRedline* pFnd = lcl_FindCurrRedline( *pStt, n, true );
     if( pFnd &&     // Is new a part of it?
         ( *pFnd->Start() != *pStt || *pFnd->End() > *pEnd ))
     {
@@ -1965,7 +1965,7 @@ static int lcl_AcceptRejectRedl( Fn_AcceptReject fn_AcceptReject,
 
     for( ; n < rArr.size(); ++n )
     {
-        SwRedline* pTmp = rArr[ n ];
+        SwRangeRedline* pTmp = rArr[ n ];
         if( pTmp->HasMark() && pTmp->IsVisible() )
         {
             if( *pTmp->End() <= *pEnd )
@@ -2000,7 +2000,7 @@ static void lcl_AdjustRedlineRange( SwPaM& rPam )
     if( !pStt->nContent.GetIndex() &&
         !pDoc->GetNodes()[ pStt->nNode.GetIndex() - 1 ]->IsCntntNode() )
     {
-        const SwRedline* pRedl = pDoc->GetRedline( *pStt, 0 );
+        const SwRangeRedline* pRedl = pDoc->GetRedline( *pStt, 0 );
         if( pRedl )
         {
             const SwPosition* pRStt = pRedl->Start();
@@ -2013,7 +2013,7 @@ static void lcl_AdjustRedlineRange( SwPaM& rPam )
         !pDoc->GetNodes()[ pEnd->nNode.GetIndex() + 1 ]->IsCntntNode() &&
         pEnd->nContent.GetIndex() == pEnd->nNode.GetNode().GetCntntNode()->Len()    )
     {
-        const SwRedline* pRedl = pDoc->GetRedline( *pEnd, 0 );
+        const SwRangeRedline* pRedl = pDoc->GetRedline( *pEnd, 0 );
         if( pRedl )
         {
             const SwPosition* pREnd = pRedl->End();
@@ -2033,7 +2033,7 @@ bool SwDoc::AcceptRedline( sal_uInt16 nPos, bool bCallDelete )
         (nsRedlineMode_t::REDLINE_SHOW_MASK & meRedlineMode) )
       SetRedlineMode( (RedlineMode_t)(nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE | meRedlineMode));
 
-    SwRedline* pTmp = (*mpRedlineTbl)[ nPos ];
+    SwRangeRedline* pTmp = (*mpRedlineTbl)[ nPos ];
     if( pTmp->HasMark() && pTmp->IsVisible() )
     {
         if (GetIDocumentUndoRedo().DoesUndo())
@@ -2143,7 +2143,7 @@ bool SwDoc::RejectRedline( sal_uInt16 nPos, bool bCallDelete )
         (nsRedlineMode_t::REDLINE_SHOW_MASK & meRedlineMode) )
       SetRedlineMode( (RedlineMode_t)(nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE | meRedlineMode));
 
-    SwRedline* pTmp = (*mpRedlineTbl)[ nPos ];
+    SwRangeRedline* pTmp = (*mpRedlineTbl)[ nPos ];
     if( pTmp->HasMark() && pTmp->IsVisible() )
     {
         if (GetIDocumentUndoRedo().DoesUndo())
@@ -2245,7 +2245,7 @@ bool SwDoc::RejectRedline( const SwPaM& rPam, bool bCallDelete )
     return nRet != 0;
 }
 
-const SwRedline* SwDoc::SelNextRedline( SwPaM& rPam ) const
+const SwRangeRedline* SwDoc::SelNextRedline( SwPaM& rPam ) const
 {
     rPam.DeleteMark();
     rPam.SetMark();
@@ -2257,7 +2257,7 @@ const SwRedline* SwDoc::SelNextRedline( SwPaM& rPam ) const
     // If the starting positon points to the last valid ContentNode,
     // we take the next Redline in any case.
     sal_uInt16 n = 0;
-    const SwRedline* pFnd = lcl_FindCurrRedline( rSttPos, n, true );
+    const SwRangeRedline* pFnd = lcl_FindCurrRedline( rSttPos, n, true );
     if( pFnd )
     {
         const SwPosition* pEnd = pFnd->End();
@@ -2296,7 +2296,7 @@ const SwRedline* SwDoc::SelNextRedline( SwPaM& rPam ) const
             const SwPosition* pPrevEnd = pFnd->End();
             while( ++n < mpRedlineTbl->size() )
             {
-                const SwRedline* pTmp = (*mpRedlineTbl)[ n ];
+                const SwRangeRedline* pTmp = (*mpRedlineTbl)[ n ];
                 if( pTmp->HasMark() && pTmp->IsVisible() )
                 {
                     const SwPosition *pRStt;
@@ -2316,7 +2316,7 @@ const SwRedline* SwDoc::SelNextRedline( SwPaM& rPam ) const
 
         if( pFnd )
         {
-            const SwRedline* pSaveFnd = pFnd;
+            const SwRangeRedline* pSaveFnd = pFnd;
 
             SwCntntNode* pCNd;
             SwNodeIndex* pIdx = &rPam.GetMark()->nNode;
@@ -2362,7 +2362,7 @@ const SwRedline* SwDoc::SelNextRedline( SwPaM& rPam ) const
     return pFnd;
 }
 
-const SwRedline* SwDoc::SelPrevRedline( SwPaM& rPam ) const
+const SwRangeRedline* SwDoc::SelPrevRedline( SwPaM& rPam ) const
 {
     rPam.DeleteMark();
     rPam.SetMark();
@@ -2374,7 +2374,7 @@ const SwRedline* SwDoc::SelPrevRedline( SwPaM& rPam ) const
     // If the starting positon points to the last valid ContentNode,
     // we take the previous Redline in any case.
     sal_uInt16 n = 0;
-    const SwRedline* pFnd = lcl_FindCurrRedline( rSttPos, n, false );
+    const SwRangeRedline* pFnd = lcl_FindCurrRedline( rSttPos, n, false );
     if( pFnd )
     {
         const SwPosition* pStt = pFnd->Start();
@@ -2412,7 +2412,7 @@ const SwRedline* SwDoc::SelPrevRedline( SwPaM& rPam ) const
             const SwPosition* pNextStt = pFnd->Start();
             while( 0 < n )
             {
-                const SwRedline* pTmp = (*mpRedlineTbl)[ --n ];
+                const SwRangeRedline* pTmp = (*mpRedlineTbl)[ --n ];
                 if( pTmp->HasMark() && pTmp->IsVisible() )
                 {
                     const SwPosition *pREnd;
@@ -2435,7 +2435,7 @@ const SwRedline* SwDoc::SelPrevRedline( SwPaM& rPam ) const
 
         if( pFnd )
         {
-            const SwRedline* pSaveFnd = pFnd;
+            const SwRangeRedline* pSaveFnd = pFnd;
 
             SwCntntNode* pCNd;
             SwNodeIndex* pIdx = &rPam.GetMark()->nNode;
@@ -2494,7 +2494,7 @@ bool SwDoc::SetRedlineComment( const SwPaM& rPaM, const OUString& rS )
         for( ; n < mpRedlineTbl->size(); ++n )
         {
             bRet = true;
-            SwRedline* pTmp = (*mpRedlineTbl)[ n ];
+            SwRangeRedline* pTmp = (*mpRedlineTbl)[ n ];
             if( pStt != pEnd && *pTmp->Start() > *pEnd )
                 break;
 
@@ -2526,7 +2526,7 @@ void SwDoc::UpdateRedlineAttr()
     const SwRedlineTbl& rTbl = GetRedlineTbl();
     for( sal_uInt16 n = 0; n < rTbl.size(); ++n )
     {
-        SwRedline* pRedl = rTbl[ n ];
+        SwRangeRedline* pRedl = rTbl[ n ];
         if( pRedl->IsVisible() )
             pRedl->InvalidateRange();
     }
@@ -2559,7 +2559,7 @@ void SwDoc::SetRedlinePassword(
     SetModified();
 }
 
-bool SwRedlineTbl::Insert( SwRedline* p, bool bIns )
+bool SwRedlineTbl::Insert( SwRangeRedline* p, bool bIns )
 {
     bool bRet = false;
     if( p->HasValidRange() )
@@ -2576,7 +2576,7 @@ bool SwRedlineTbl::Insert( SwRedline* p, bool bIns )
     return bRet;
 }
 
-bool SwRedlineTbl::Insert( SwRedline* p, sal_uInt16& rP, bool bIns )
+bool SwRedlineTbl::Insert( SwRangeRedline* p, sal_uInt16& rP, bool bIns )
 {
     bool bRet = false;
     if( p->HasValidRange() )
@@ -2595,7 +2595,7 @@ bool SwRedlineTbl::Insert( SwRedline* p, sal_uInt16& rP, bool bIns )
     return bRet;
 }
 
-bool SwRedlineTbl::InsertWithValidRanges( SwRedline* p, sal_uInt16* pInsPos )
+bool SwRedlineTbl::InsertWithValidRanges( SwRangeRedline* p, sal_uInt16* pInsPos )
 {
     // Create valid "sub-ranges" from the Selection
     bool bAnyIns = false;
@@ -2614,13 +2614,13 @@ bool SwRedlineTbl::InsertWithValidRanges( SwRedline* p, sal_uInt16* pInsPos )
             aNewStt.nNode = rNds.GetEndOfContent();
     }
 
-    SwRedline* pNew = 0;
+    SwRangeRedline* pNew = 0;
     sal_uInt16 nInsPos;
 
     if( aNewStt < *pEnd )
         do {
             if( !pNew )
-                pNew = new SwRedline( p->GetRedlineData(), aNewStt );
+                pNew = new SwRangeRedline( p->GetRedlineData(), aNewStt );
             else
             {
                 pNew->DeleteMark();
@@ -2706,7 +2706,7 @@ bool SwRedlineTbl::InsertWithValidRanges( SwRedline* p, sal_uInt16* pInsPos )
     return bAnyIns;
 }
 
-bool CompareSwRedlineTbl::operator()(SwRedline* const &lhs, SwRedline* const &rhs) const
+bool CompareSwRedlineTbl::operator()(SwRangeRedline* const &lhs, SwRangeRedline* const &rhs) const
 {
     return *lhs < *rhs;
 }
@@ -2716,15 +2716,15 @@ _SwRedlineTbl::~_SwRedlineTbl()
     DeleteAndDestroyAll();
 }
 
-sal_uInt16 SwRedlineTbl::GetPos(const SwRedline* p) const
+sal_uInt16 SwRedlineTbl::GetPos(const SwRangeRedline* p) const
 {
-    const_iterator it = find(const_cast<SwRedline* const>(p));
+    const_iterator it = find(const_cast<SwRangeRedline* const>(p));
     if( it == end() )
         return USHRT_MAX;
     return it - begin();
 }
 
-bool SwRedlineTbl::Remove( const SwRedline* p )
+bool SwRedlineTbl::Remove( const SwRangeRedline* p )
 {
     sal_uInt16 nPos = GetPos(p);
     if (nPos != USHRT_MAX)
@@ -3091,7 +3091,7 @@ OUString SwRedlineData::GetDescr() const
     return aResult;
 }
 
-SwRedline::SwRedline(RedlineType_t eTyp, const SwPaM& rPam )
+SwRangeRedline::SwRangeRedline(RedlineType_t eTyp, const SwPaM& rPam )
     : SwPaM( *rPam.GetMark(), *rPam.GetPoint() ),
     pRedlineData( new SwRedlineData( eTyp, GetDoc()->GetRedlineAuthor() ) ),
     pCntntSect( 0 )
@@ -3102,7 +3102,7 @@ SwRedline::SwRedline(RedlineType_t eTyp, const SwPaM& rPam )
         DeleteMark();
 }
 
-SwRedline::SwRedline( const SwRedlineData& rData, const SwPaM& rPam )
+SwRangeRedline::SwRangeRedline( const SwRedlineData& rData, const SwPaM& rPam )
     : SwPaM( *rPam.GetMark(), *rPam.GetPoint() ),
     pRedlineData( new SwRedlineData( rData )),
     pCntntSect( 0 )
@@ -3113,7 +3113,7 @@ SwRedline::SwRedline( const SwRedlineData& rData, const SwPaM& rPam )
         DeleteMark();
 }
 
-SwRedline::SwRedline( const SwRedlineData& rData, const SwPosition& rPos )
+SwRangeRedline::SwRangeRedline( const SwRedlineData& rData, const SwPosition& rPos )
     : SwPaM( rPos ),
     pRedlineData( new SwRedlineData( rData )),
     pCntntSect( 0 )
@@ -3122,7 +3122,7 @@ SwRedline::SwRedline( const SwRedlineData& rData, const SwPosition& rPos )
     bIsVisible = sal_True;
 }
 
-SwRedline::SwRedline( const SwRedline& rCpy )
+SwRangeRedline::SwRangeRedline( const SwRangeRedline& rCpy )
     : SwPaM( *rCpy.GetMark(), *rCpy.GetPoint() ),
     pRedlineData( new SwRedlineData( *rCpy.pRedlineData )),
     pCntntSect( 0 )
@@ -3133,7 +3133,7 @@ SwRedline::SwRedline( const SwRedline& rCpy )
         DeleteMark();
 }
 
-SwRedline::~SwRedline()
+SwRangeRedline::~SwRangeRedline()
 {
     if( pCntntSect )
     {
@@ -3146,7 +3146,7 @@ SwRedline::~SwRedline()
 }
 
 /// Do we have a valid Selection?
-sal_Bool SwRedline::HasValidRange() const
+sal_Bool SwRangeRedline::HasValidRange() const
 {
     const SwNode* pPtNd = &GetPoint()->nNode.GetNode(),
                 * pMkNd = &GetMark()->nNode.GetNode();
@@ -3161,7 +3161,7 @@ sal_Bool SwRedline::HasValidRange() const
     return sal_False;
 }
 
-void SwRedline::CallDisplayFunc( sal_uInt16 nLoop )
+void SwRangeRedline::CallDisplayFunc( sal_uInt16 nLoop )
 {
     switch( nsRedlineMode_t::REDLINE_SHOW_MASK & GetDoc()->GetRedlineMode() )
     {
@@ -3177,7 +3177,7 @@ void SwRedline::CallDisplayFunc( sal_uInt16 nLoop )
     }
 }
 
-void SwRedline::Show( sal_uInt16 nLoop )
+void SwRangeRedline::Show( sal_uInt16 nLoop )
 {
     if( 1 <= nLoop )
     {
@@ -3209,7 +3209,7 @@ void SwRedline::Show( sal_uInt16 nLoop )
     }
 }
 
-void SwRedline::Hide( sal_uInt16 nLoop )
+void SwRangeRedline::Hide( sal_uInt16 nLoop )
 {
     SwDoc* pDoc = GetDoc();
     RedlineMode_t eOld = pDoc->GetRedlineMode();
@@ -3245,7 +3245,7 @@ void SwRedline::Hide( sal_uInt16 nLoop )
     pDoc->SetRedlineMode_intern( eOld );
 }
 
-void SwRedline::ShowOriginal( sal_uInt16 nLoop )
+void SwRangeRedline::ShowOriginal( sal_uInt16 nLoop )
 {
     SwDoc* pDoc = GetDoc();
     RedlineMode_t eOld = pDoc->GetRedlineMode();
@@ -3287,7 +3287,7 @@ void SwRedline::ShowOriginal( sal_uInt16 nLoop )
     pDoc->SetRedlineMode_intern( eOld );
 }
 
-void SwRedline::InvalidateRange()       // trigger the Layout
+void SwRangeRedline::InvalidateRange()       // trigger the Layout
 {
     sal_uLong nSttNd = GetMark()->nNode.GetIndex(),
             nEndNd = GetPoint()->nNode.GetIndex();
@@ -3318,7 +3318,7 @@ void SwRedline::InvalidateRange()       // trigger the Layout
 
 /** Calculates the start and end position of the intersection rTmp and
     text node nNdIdx */
-void SwRedline::CalcStartEnd( sal_uLong nNdIdx, xub_StrLen& rStart, xub_StrLen& rEnd ) const
+void SwRangeRedline::CalcStartEnd( sal_uLong nNdIdx, xub_StrLen& rStart, xub_StrLen& rEnd ) const
 {
     const SwPosition *pRStt = Start(), *pREnd = End();
     if( pRStt->nNode < nNdIdx )
@@ -3351,7 +3351,7 @@ void SwRedline::CalcStartEnd( sal_uLong nNdIdx, xub_StrLen& rStart, xub_StrLen&
     }
 }
 
-void SwRedline::MoveToSection()
+void SwRangeRedline::MoveToSection()
 {
     if( !pCntntSect )
     {
@@ -3370,7 +3370,7 @@ void SwRedline::MoveToSection()
             const SwRedlineTbl& rTbl = pDoc->GetRedlineTbl();
             for( sal_uInt16 n = 0; n < rTbl.size(); ++n )
             {
-                SwRedline* pRedl = rTbl[ n ];
+                SwRangeRedline* pRedl = rTbl[ n ];
                 if( pRedl->GetBound(sal_True) == *pStt )
                     pRedl->GetBound(sal_True) = *pEnd;
                 if( pRedl->GetBound(sal_False) == *pStt )
@@ -3425,7 +3425,7 @@ void SwRedline::MoveToSection()
         InvalidateRange();
 }
 
-void SwRedline::CopyToSection()
+void SwRangeRedline::CopyToSection()
 {
     if( !pCntntSect )
     {
@@ -3504,7 +3504,7 @@ void SwRedline::CopyToSection()
     }
 }
 
-void SwRedline::DelCopyOfSection()
+void SwRangeRedline::DelCopyOfSection()
 {
     if( pCntntSect )
     {
@@ -3523,7 +3523,7 @@ void SwRedline::DelCopyOfSection()
             const SwRedlineTbl& rTbl = pDoc->GetRedlineTbl();
             for( sal_uInt16 n = 0; n < rTbl.size(); ++n )
             {
-                SwRedline* pRedl = rTbl[ n ];
+                SwRangeRedline* pRedl = rTbl[ n ];
                 if( pRedl->GetBound(sal_True) == *pStt )
                     pRedl->GetBound(sal_True) = *pEnd;
                 if( pRedl->GetBound(sal_False) == *pStt )
@@ -3592,7 +3592,7 @@ void SwRedline::DelCopyOfSection()
     }
 }
 
-void SwRedline::MoveFromSection()
+void SwRangeRedline::MoveFromSection()
 {
     if( pCntntSect )
     {
@@ -3685,7 +3685,7 @@ void SwRedline::MoveFromSection()
         }
         // #i95771#
         // Under certain conditions the previous <SwDoc::Move(..)> has already
-        // removed the change tracking section of this <SwRedline> instance from
+        // removed the change tracking section of this <SwRangeRedline> instance from
         // the change tracking nodes area.
         // Thus, check if <pCntntSect> still points to the change tracking section
         // by comparing it with the "indexed" <SwNode> instance copied before
@@ -3709,7 +3709,7 @@ void SwRedline::MoveFromSection()
 }
 
 // for Undo
-void SwRedline::SetContentIdx( const SwNodeIndex* pIdx )
+void SwRangeRedline::SetContentIdx( const SwNodeIndex* pIdx )
 {
     if( pIdx && !pCntntSect )
     {
@@ -3723,17 +3723,17 @@ void SwRedline::SetContentIdx( const SwNodeIndex* pIdx )
     }
     else
     {
-        OSL_FAIL("SwRedline::SetContentIdx: invalid state");
+        OSL_FAIL("SwRangeRedline::SetContentIdx: invalid state");
     }
 }
 
-sal_Bool SwRedline::CanCombine( const SwRedline& rRedl ) const
+sal_Bool SwRangeRedline::CanCombine( const SwRangeRedline& rRedl ) const
 {
     return  IsVisible() && rRedl.IsVisible() &&
             pRedlineData->CanCombine( *rRedl.pRedlineData );
 }
 
-void SwRedline::PushData( const SwRedline& rRedl, sal_Bool bOwnAsNext )
+void SwRangeRedline::PushData( const SwRangeRedline& rRedl, sal_Bool bOwnAsNext )
 {
     SwRedlineData* pNew = new SwRedlineData( *rRedl.pRedlineData, sal_False );
     if( bOwnAsNext )
@@ -3748,7 +3748,7 @@ void SwRedline::PushData( const SwRedline& rRedl, sal_Bool bOwnAsNext )
     }
 }
 
-sal_Bool SwRedline::PopData()
+sal_Bool SwRangeRedline::PopData()
 {
     if( !pRedlineData->pNext )
         return sal_False;
@@ -3759,7 +3759,7 @@ sal_Bool SwRedline::PopData()
     return sal_True;
 }
 
-sal_uInt16 SwRedline::GetStackCount() const
+sal_uInt16 SwRangeRedline::GetStackCount() const
 {
     sal_uInt16 nRet = 1;
     for( SwRedlineData* pCur = pRedlineData; pCur->pNext; ++nRet )
@@ -3767,37 +3767,37 @@ sal_uInt16 SwRedline::GetStackCount() const
     return nRet;
 }
 
-sal_uInt16 SwRedline::GetAuthor( sal_uInt16 nPos ) const
+sal_uInt16 SwRangeRedline::GetAuthor( sal_uInt16 nPos ) const
 {
     return GetRedlineData(nPos).nAuthor;
 }
 
-OUString SwRedline::GetAuthorString( sal_uInt16 nPos ) const
+OUString SwRangeRedline::GetAuthorString( sal_uInt16 nPos ) const
 {
     return SW_MOD()->GetRedlineAuthor(GetRedlineData(nPos).nAuthor);
 }
 
-const DateTime& SwRedline::GetTimeStamp( sal_uInt16 nPos ) const
+const DateTime& SwRangeRedline::GetTimeStamp( sal_uInt16 nPos ) const
 {
     return GetRedlineData(nPos).aStamp;
 }
 
-RedlineType_t SwRedline::GetRealType( sal_uInt16 nPos ) const
+RedlineType_t SwRangeRedline::GetRealType( sal_uInt16 nPos ) const
 {
     return GetRedlineData(nPos).eType;
 }
 
-const OUString& SwRedline::GetComment( sal_uInt16 nPos ) const
+const OUString& SwRangeRedline::GetComment( sal_uInt16 nPos ) const
 {
     return GetRedlineData(nPos).sComment;
 }
 
-int SwRedline::operator==( const SwRedline& rCmp ) const
+int SwRangeRedline::operator==( const SwRangeRedline& rCmp ) const
 {
     return this == &rCmp;
 }
 
-int SwRedline::operator<( const SwRedline& rCmp ) const
+int SwRangeRedline::operator<( const SwRangeRedline& rCmp ) const
 {
     sal_Bool nResult = sal_False;
 
@@ -3810,7 +3810,7 @@ int SwRedline::operator<( const SwRedline& rCmp ) const
     return nResult;
 }
 
-const SwRedlineData & SwRedline::GetRedlineData(sal_uInt16 nPos) const
+const SwRedlineData & SwRangeRedline::GetRedlineData(sal_uInt16 nPos) const
 {
     SwRedlineData * pCur = pRedlineData;
 
@@ -3826,7 +3826,7 @@ const SwRedlineData & SwRedline::GetRedlineData(sal_uInt16 nPos) const
     return *pCur;
 }
 
-OUString SwRedline::GetDescr(sal_uInt16 nPos)
+OUString SwRangeRedline::GetDescr(sal_uInt16 nPos)
 {
     OUString aResult;
 
diff --git a/sw/source/core/doc/docsort.cxx b/sw/source/core/doc/docsort.cxx
index 0d8b894fc7c7..078fe1d63489 100644
--- a/sw/source/core/doc/docsort.cxx
+++ b/sw/source/core/doc/docsort.cxx
@@ -433,8 +433,8 @@ bool SwDoc::SortText(const SwPaM& rPaM, const SwSortOptions& rOpt)
         SwNodeIndex aSttIdx( GetNodes(), nBeg );
 
         // the copied range is deleted
-        SwRedline *const pDeleteRedline(
-            new SwRedline( nsRedlineType_t::REDLINE_DELETE, *pRedlPam ));
+        SwRangeRedline *const pDeleteRedline(
+            new SwRangeRedline( nsRedlineType_t::REDLINE_DELETE, *pRedlPam ));
 
         // pRedlPam points to nodes that may be deleted (hidden) by
         // AppendRedline, so adjust it beforehand to prevent ASSERT
@@ -445,7 +445,7 @@ bool SwDoc::SortText(const SwPaM& rPaM, const SwSortOptions& rOpt)
         AppendRedline(pDeleteRedline, true);
 
         // the sorted range is inserted
-        AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, *pRedlPam ), true);
+        AppendRedline( new SwRangeRedline( nsRedlineType_t::REDLINE_INSERT, *pRedlPam ), true);
 
         if( pRedlUndo )
         {
diff --git a/sw/source/core/docnode/ndcopy.cxx b/sw/source/core/docnode/ndcopy.cxx
index f274494e05f2..3840c19bdc50 100644
--- a/sw/source/core/docnode/ndcopy.cxx
+++ b/sw/source/core/docnode/ndcopy.cxx
@@ -586,7 +586,7 @@ static void lcl_DeleteRedlines( const SwPaM& rPam, SwPaM& rCpyPam )
         pSrcDoc->GetRedline( *pStt, &n );
         for( ; n < rTbl.size(); ++n )
         {
-            const SwRedline* pRedl = rTbl[ n ];
+            const SwRangeRedline* pRedl = rTbl[ n ];
             if( nsRedlineType_t::REDLINE_DELETE == pRedl->GetType() && pRedl->IsVisible() )
             {
                 const SwPosition *pRStt = pRedl->Start(), *pREnd = pRedl->End();
@@ -786,7 +786,7 @@ SwDoc::CopyRange( SwPaM& rPam, SwPosition& rPos, const bool bCopyAll ) const
     if( pRedlineRange )
     {
         if( pDoc->IsRedlineOn() )
-            pDoc->AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, *pRedlineRange ), true);
+            pDoc->AppendRedline( new SwRangeRedline( nsRedlineType_t::REDLINE_INSERT, *pRedlineRange ), true);
         else
             pDoc->SplitRedline( *pRedlineRange );
         delete pRedlineRange;
diff --git a/sw/source/core/docnode/ndsect.cxx b/sw/source/core/docnode/ndsect.cxx
index 30cb489799ab..3b0ce89b8c31 100644
--- a/sw/source/core/docnode/ndsect.cxx
+++ b/sw/source/core/docnode/ndsect.cxx
@@ -321,7 +321,7 @@ SwDoc::InsertSwSection(SwPaM const& rRange, SwSectionData & rNewData,
         SwPaM aPam( *pNewSectNode->EndOfSectionNode(), *pNewSectNode, 1 );
         if( IsRedlineOn() )
         {
-            AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
+            AppendRedline( new SwRangeRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
         }
         else
         {
diff --git a/sw/source/core/docnode/ndtbl.cxx b/sw/source/core/docnode/ndtbl.cxx
index 887dc9cba3f7..4933b9dbdd1a 100644
--- a/sw/source/core/docnode/ndtbl.cxx
+++ b/sw/source/core/docnode/ndtbl.cxx
@@ -542,7 +542,7 @@ const SwTable* SwDoc::InsertTable( const SwInsertTableOptions& rInsTblOpts,
     {
         SwPaM aPam( *pTblNd->EndOfSectionNode(), *pTblNd, 1 );
         if( IsRedlineOn() )
-            AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
+            AppendRedline( new SwRangeRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
         else
             SplitRedline( aPam );
     }
diff --git a/sw/source/core/docnode/nodedump.cxx b/sw/source/core/docnode/nodedump.cxx
index 0ef267416e89..abbd9918d06e 100644
--- a/sw/source/core/docnode/nodedump.cxx
+++ b/sw/source/core/docnode/nodedump.cxx
@@ -473,7 +473,7 @@ void SwRedlineTbl::dumpAsXml( xmlTextWriterPtr w )
     for( sal_uInt16 nCurRedlinePos = 0; nCurRedlinePos < size(); ++nCurRedlinePos )
     {
         const SwRedlineTbl& redlineTbl = (*this);
-        const SwRedline* pRedline = redlineTbl[ nCurRedlinePos ];
+        const SwRangeRedline* pRedline = redlineTbl[ nCurRedlinePos ];
 
         writer.startElement( "swredline" );
         writer.writeFormatAttribute( "ptr", "%p", pRedline );
diff --git a/sw/source/core/edit/edlingu.cxx b/sw/source/core/edit/edlingu.cxx
index ad28af8b8a6c..3380f5314f78 100644
--- a/sw/source/core/edit/edlingu.cxx
+++ b/sw/source/core/edit/edlingu.cxx
@@ -1264,7 +1264,7 @@ static SpellContentPositions lcl_CollectDeletedRedlines(SwEditShell* pSh)
         const sal_Int32 nStartIndex = pStartPos->nContent.GetIndex();
         for ( ; nAct < pDoc->GetRedlineTbl().size(); nAct++ )
         {
-            const SwRedline* pRed = pDoc->GetRedlineTbl()[ nAct ];
+            const SwRangeRedline* pRed = pDoc->GetRedlineTbl()[ nAct ];
 
             if ( pRed->Start()->nNode > pTxtNode->GetIndex() )
                 break;
diff --git a/sw/source/core/edit/edredln.cxx b/sw/source/core/edit/edredln.cxx
index 5a553614bb19..eaf439427044 100644
--- a/sw/source/core/edit/edredln.cxx
+++ b/sw/source/core/edit/edredln.cxx
@@ -52,7 +52,7 @@ sal_uInt16 SwEditShell::GetRedlineCount() const
     return GetDoc()->GetRedlineTbl().size();
 }
 
-const SwRedline& SwEditShell::GetRedline( sal_uInt16 nPos ) const
+const SwRangeRedline& SwEditShell::GetRedline( sal_uInt16 nPos ) const
 {
     return *GetDoc()->GetRedlineTbl()[ nPos ];
 }
@@ -102,7 +102,7 @@ sal_Bool SwEditShell::SetRedlineComment( const OUString& rS )
     return bRet;
 }
 
-const SwRedline* SwEditShell::GetCurrRedline() const
+const SwRangeRedline* SwEditShell::GetCurrRedline() const
 {
     return GetDoc()->GetRedline( *GetCrsr()->GetPoint(), 0 );
 }
diff --git a/sw/source/core/fields/postithelper.cxx b/sw/source/core/fields/postithelper.cxx
index 73d163a2b3fe..e259a18d23d5 100644
--- a/sw/source/core/fields/postithelper.cxx
+++ b/sw/source/core/fields/postithelper.cxx
@@ -118,7 +118,7 @@ SwPostItHelper::SwLayoutStatus SwPostItHelper::getLayoutInfos(
                 const IDocumentRedlineAccess* pIDRA = pTxtNode->getIDocumentRedlineAccess();
                 if( IDocumentRedlineAccess::IsShowChanges( pIDRA->GetRedlineMode() ) )
                 {
-                    const SwRedline* pRedline = pIDRA->GetRedline( rAnchorPos, 0 );
+                    const SwRangeRedline* pRedline = pIDRA->GetRedline( rAnchorPos, 0 );
                     if( pRedline )
                     {
                         if( nsRedlineType_t::REDLINE_INSERT == pRedline->GetType() )
diff --git a/sw/source/core/inc/UndoRedline.hxx b/sw/source/core/inc/UndoRedline.hxx
index 24476073e2e5..3db2a764cfde 100644
--- a/sw/source/core/inc/UndoRedline.hxx
+++ b/sw/source/core/inc/UndoRedline.hxx
@@ -23,7 +23,7 @@
 #include <undobj.hxx>
 
 struct SwSortOptions;
-class SwRedline;
+class SwRangeRedline;
 class SwRedlineSaveDatas;
 class SwUndoDelete;
 
@@ -120,7 +120,7 @@ class SwUndoCompDoc : public SwUndo, public SwUndRng
 
 public:
     SwUndoCompDoc( const SwPaM& rRg, sal_Bool bIns );
-    SwUndoCompDoc( const SwRedline& rRedl );
+    SwUndoCompDoc( const SwRangeRedline& rRedl );
 
     virtual ~SwUndoCompDoc();
 
diff --git a/sw/source/core/inc/unoport.hxx b/sw/source/core/inc/unoport.hxx
index cd5c74a23568..970eb69c691f 100644
--- a/sw/source/core/inc/unoport.hxx
+++ b/sw/source/core/inc/unoport.hxx
@@ -47,7 +47,7 @@
 
 class SwFmtFld;
 class SwFrmFmt;
-class SwRedline;
+class SwRangeRedline;
 class SwTxtRuby;
 
 
@@ -314,7 +314,7 @@ protected:
 class SwXRedlinePortion : public SwXTextPortion
 {
 private:
-    SwRedline const& m_rRedline;
+    SwRangeRedline const& m_rRedline;
 
     void Validate() throw (::com::sun::star::uno::RuntimeException);
 
@@ -324,17 +324,17 @@ private:
 
 public:
     SwXRedlinePortion(
-        SwRedline const& rRedline,
+        SwRangeRedline const& rRedline,
         SwUnoCrsr const* pPortionCrsr,
         ::com::sun::star::uno::Reference< ::com::sun::star::text::XText >
             const& xParent,
         bool const bIsStart);
 
     static ::com::sun::star::uno::Any  GetPropertyValue(
-            OUString const& PropertyName, SwRedline const& rRedline) throw();
+            OUString const& PropertyName, SwRangeRedline const& rRedline) throw();
     static ::com::sun::star::uno::Sequence<
         ::com::sun::star::beans::PropertyValue > CreateRedlineProperties(
-                SwRedline const& rRedline, sal_Bool const bIsStart) throw();
+                SwRangeRedline const& rRedline, sal_Bool const bIsStart) throw();
 
     virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL
         getImplementationId() throw (::com::sun::star::uno::RuntimeException);
diff --git a/sw/source/core/table/swtable.cxx b/sw/source/core/table/swtable.cxx
index fbc1b61d7ed3..3495ac069e2b 100644
--- a/sw/source/core/table/swtable.cxx
+++ b/sw/source/core/table/swtable.cxx
@@ -2119,7 +2119,7 @@ void ChgTextToNum( SwTableBox& rBox, const OUString& rTxt, const Color* pCol,
             if( pDoc->IsRedlineOn() )
             {
                 SwPaM aTemp(*pTNd, 0, *pTNd, rTxt.getLength());
-                pDoc->AppendRedline(new SwRedline(nsRedlineType_t::REDLINE_INSERT, aTemp), true);
+                pDoc->AppendRedline(new SwRangeRedline(nsRedlineType_t::REDLINE_INSERT, aTemp), true);
             }
         }
 
diff --git a/sw/source/core/text/porlay.cxx b/sw/source/core/text/porlay.cxx
index 0d4a2183bad0..4acd55198c10 100644
--- a/sw/source/core/text/porlay.cxx
+++ b/sw/source/core/text/porlay.cxx
@@ -2245,7 +2245,7 @@ void SwScriptInfo::selectRedLineDeleted(const SwTxtNode& rNode, MultiSelection &
 
         for ( ; nAct < rIDRA.GetRedlineTbl().size(); nAct++ )
         {
-            const SwRedline* pRed = rIDRA.GetRedlineTbl()[ nAct ];
+            const SwRangeRedline* pRed = rIDRA.GetRedlineTbl()[ nAct ];
 
             if ( pRed->Start()->nNode > rNode.GetIndex() )
                 break;
diff --git a/sw/source/core/text/redlnitr.cxx b/sw/source/core/text/redlnitr.cxx
index 01196b4f53e3..e95cd1856486 100644
--- a/sw/source/core/text/redlnitr.cxx
+++ b/sw/source/core/text/redlnitr.cxx
@@ -239,7 +239,7 @@ short SwRedlineItr::_Seek( SwFont& rFnt, xub_StrLen nNew, xub_StrLen nOld )
                 if( nNew >= nStart ) // der einzig moegliche Kandidat
                 {
                     bOn = sal_True;
-                    const SwRedline *pRed = rDoc.GetRedlineTbl()[ nAct ];
+                    const SwRangeRedline *pRed = rDoc.GetRedlineTbl()[ nAct ];
 
                     if (pSet)
                         pSet->ClearItem();
diff --git a/sw/source/core/txtnode/ndtxt.cxx b/sw/source/core/txtnode/ndtxt.cxx
index be3d458f62a8..3a2a174c403b 100644
--- a/sw/source/core/txtnode/ndtxt.cxx
+++ b/sw/source/core/txtnode/ndtxt.cxx
@@ -1022,7 +1022,7 @@ void SwTxtNode::Update(
         const SwRedlineTbl& rTbl = GetDoc()->GetRedlineTbl();
         for ( sal_uInt16 i = 0; i < rTbl.size(); ++i )
         {
-            SwRedline *const pRedl = rTbl[ i ];
+            SwRangeRedline *const pRedl = rTbl[ i ];
             if ( pRedl->HasMark() )
             {
                 SwPosition* const pEnd = pRedl->End();
@@ -2101,7 +2101,7 @@ void SwTxtNode::CutImpl( SwTxtNode * const pDest, const SwIndex & rDestStart,
                             m_Text.copy(nTxtStartIdx, nLen));
         m_Text = m_Text.replaceAt(nTxtStartIdx, nLen, "");
         if (GetSpaceLeft()<0)
-        {   // FIXME: could only happen when called from SwRedline::Show.
+        {   // FIXME: could only happen when called from SwRangeRedline::Show.
             // unfortunately can't really do anything here to handle that...
             abort();
         }
@@ -3338,7 +3338,7 @@ OUString SwTxtNode::GetRedlineTxt( sal_Int32 nIdx, sal_Int32 nLen,
         const sal_uLong nNdIdx = GetIndex();
         for( ; nRedlPos < pDoc->GetRedlineTbl().size() ; ++nRedlPos )
         {
-            const SwRedline* pTmp = pDoc->GetRedlineTbl()[ nRedlPos ];
+            const SwRangeRedline* pTmp = pDoc->GetRedlineTbl()[ nRedlPos ];
             if( nsRedlineType_t::REDLINE_DELETE == pTmp->GetType() )
             {
                 const SwPosition *pRStt = pTmp->Start(), *pREnd = pTmp->End();
diff --git a/sw/source/core/txtnode/txtedt.cxx b/sw/source/core/txtnode/txtedt.cxx
index de9ab9db93d4..c2c660289750 100644
--- a/sw/source/core/txtnode/txtedt.cxx
+++ b/sw/source/core/txtnode/txtedt.cxx
@@ -107,7 +107,7 @@ lcl_MaskRedlines( const SwTxtNode& rNode, OUStringBuffer& rText,
 
     for ( ; nAct < rDoc.GetRedlineTbl().size(); nAct++ )
     {
-        const SwRedline* pRed = rDoc.GetRedlineTbl()[ nAct ];
+        const SwRangeRedline* pRed = rDoc.GetRedlineTbl()[ nAct ];
 
         if ( pRed->Start()->nNode > rNode.GetIndex() )
             break;
diff --git a/sw/source/core/undo/unattr.cxx b/sw/source/core/undo/unattr.cxx
index 5aa0c4d8bb27..5a5df29a6ded 100644
--- a/sw/source/core/undo/unattr.cxx
+++ b/sw/source/core/undo/unattr.cxx
@@ -870,14 +870,14 @@ void SwUndoAttr::RedoImpl(::sw::UndoRedoContext & rContext)
             rPam.SetMark();
             if ( rPam.Move( fnMoveBackward ) )
             {
-                rDoc.AppendRedline( new SwRedline( *m_pRedlineData, rPam ),
+                rDoc.AppendRedline( new SwRangeRedline( *m_pRedlineData, rPam ),
                         true);
             }
             rPam.DeleteMark();
         }
         else
         {
-            rDoc.AppendRedline( new SwRedline( *m_pRedlineData, rPam ), true);
+            rDoc.AppendRedline( new SwRangeRedline( *m_pRedlineData, rPam ), true);
         }
 
         rDoc.SetRedlineMode_intern( eOld );
diff --git a/sw/source/core/undo/undobj.cxx b/sw/source/core/undo/undobj.cxx
index f552dc90fd66..12bd392f5cee 100644
--- a/sw/source/core/undo/undobj.cxx
+++ b/sw/source/core/undo/undobj.cxx
@@ -45,7 +45,7 @@ class SwRedlineSaveData : public SwUndRng, public SwRedlineData,
 public:
     SwRedlineSaveData( SwComparePosition eCmpPos,
                         const SwPosition& rSttPos, const SwPosition& rEndPos,
-                        SwRedline& rRedl, sal_Bool bCopyNext );
+                        SwRangeRedline& rRedl, sal_Bool bCopyNext );
     ~SwRedlineSaveData();
     void RedlineToDoc( SwPaM& rPam );
     SwNodeIndex* GetMvSttIdx() const
@@ -907,7 +907,7 @@ void SwUndoSaveSection::RestoreSection( SwDoc* pDoc, const SwNodeIndex& rInsPos
 SwRedlineSaveData::SwRedlineSaveData( SwComparePosition eCmpPos,
                                         const SwPosition& rSttPos,
                                         const SwPosition& rEndPos,
-                                        SwRedline& rRedl,
+                                        SwRangeRedline& rRedl,
                                         sal_Bool bCopyNext )
     : SwUndRng( rRedl ),
     SwRedlineData( rRedl.GetRedlineData(), bCopyNext )
@@ -961,7 +961,7 @@ SwRedlineSaveData::~SwRedlineSaveData()
 void SwRedlineSaveData::RedlineToDoc( SwPaM& rPam )
 {
     SwDoc& rDoc = *rPam.GetDoc();
-    SwRedline* pRedl = new SwRedline( *this, rPam );
+    SwRangeRedline* pRedl = new SwRangeRedline( *this, rPam );
 
     if( GetMvSttIdx() )
     {
@@ -1001,7 +1001,7 @@ sal_Bool SwUndo::FillSaveData( const SwPaM& rRange, SwRedlineSaveDatas& rSData,
     rRange.GetDoc()->GetRedline( *pStt, &n );
     for( ; n < rTbl.size(); ++n )
     {
-        SwRedline* pRedl = rTbl[ n ];
+        SwRangeRedline* pRedl = rTbl[ n ];
         const SwPosition *pRStt = pRedl->Start(), *pREnd = pRedl->End();
 
         SwComparePosition eCmpPos = ComparePosition( *pStt, *pEnd, *pRStt, *pREnd );
@@ -1029,7 +1029,7 @@ sal_Bool SwUndo::FillSaveDataForFmt( const SwPaM& rRange, SwRedlineSaveDatas& rS
     rRange.GetDoc()->GetRedline( *pStt, &n );
     for( ; n < rTbl.size(); ++n )
     {
-        SwRedline* pRedl = rTbl[ n ];
+        SwRangeRedline* pRedl = rTbl[ n ];
         if( nsRedlineType_t::REDLINE_FORMAT == pRedl->GetType() )
         {
             const SwPosition *pRStt = pRedl->Start(), *pREnd = pRedl->End();
diff --git a/sw/source/core/undo/unins.cxx b/sw/source/core/undo/unins.cxx
index b0b9b4a0d4e9..864af5cfd4e9 100644
--- a/sw/source/core/undo/unins.cxx
+++ b/sw/source/core/undo/unins.cxx
@@ -175,7 +175,7 @@ sal_Bool SwUndoInsert::CanGrouping( const SwPosition& rPos )
                 SwIndex* pIdx;
                 for( sal_uInt16 i = 0; i < rTbl.size(); ++i )
                 {
-                    SwRedline* pRedl = rTbl[ i ];
+                    SwRangeRedline* pRedl = rTbl[ i ];
                     if( pIReg == (pIdx = &pRedl->End()->nContent)->GetIdxReg() &&
                         nCntnt == pIdx->GetIndex() )
                     {
@@ -316,7 +316,7 @@ void SwUndoInsert::RedoImpl(::sw::UndoRedoContext & rContext)
         {
             RedlineMode_t eOld = pTmpDoc->GetRedlineMode();
             pTmpDoc->SetRedlineMode_intern((RedlineMode_t)(eOld & ~nsRedlineMode_t::REDLINE_IGNORE));
-            pTmpDoc->AppendRedline( new SwRedline( *pRedlData, *pPam ), true);
+            pTmpDoc->AppendRedline( new SwRangeRedline( *pRedlData, *pPam ), true);
             pTmpDoc->SetRedlineMode_intern( eOld );
         }
         else if( !( nsRedlineMode_t::REDLINE_IGNORE & GetRedlineMode() ) &&
@@ -367,7 +367,7 @@ void SwUndoInsert::RedoImpl(::sw::UndoRedoContext & rContext)
             {
                 RedlineMode_t eOld = pTmpDoc->GetRedlineMode();
                 pTmpDoc->SetRedlineMode_intern((RedlineMode_t)(eOld & ~nsRedlineMode_t::REDLINE_IGNORE));
-                pTmpDoc->AppendRedline( new SwRedline( *pRedlData,
+                pTmpDoc->AppendRedline( new SwRangeRedline( *pRedlData,
                                             *pPam ), true);
                 pTmpDoc->SetRedlineMode_intern( eOld );
             }
diff --git a/sw/source/core/undo/unredln.cxx b/sw/source/core/undo/unredln.cxx
index e2b4c7079cd8..a97bd17c1923 100644
--- a/sw/source/core/undo/unredln.cxx
+++ b/sw/source/core/undo/unredln.cxx
@@ -172,7 +172,7 @@ void SwUndoRedlineDelete::RedoRedlineImpl(SwDoc & rDoc, SwPaM & rPam)
 {
     if (rPam.GetPoint() != rPam.GetMark())
     {
-        rDoc.AppendRedline( new SwRedline(*pRedlData, rPam), sal_False );
+        rDoc.AppendRedline( new SwRangeRedline(*pRedlData, rPam), sal_False );
     }
 }
 
@@ -367,7 +367,7 @@ SwUndoCompDoc::SwUndoCompDoc( const SwPaM& rRg, sal_Bool bIns )
     }
 }
 
-SwUndoCompDoc::SwUndoCompDoc( const SwRedline& rRedl )
+SwUndoCompDoc::SwUndoCompDoc( const SwRangeRedline& rRedl )
     : SwUndo( UNDO_COMPAREDOC ), SwUndRng( rRedl ), pRedlData( 0 ),
     pUnDel( 0 ), pUnDel2( 0 ), pRedlSaveData( 0 ),
     // for MergeDoc the corresponding inverse is needed
@@ -469,7 +469,7 @@ void SwUndoCompDoc::RedoImpl(::sw::UndoRedoContext & rContext)
     {
         if( pRedlData && IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
         {
-            SwRedline* pTmp = new SwRedline( *pRedlData, *pPam );
+            SwRangeRedline* pTmp = new SwRangeRedline( *pRedlData, *pPam );
             ((SwRedlineTbl&)pDoc->GetRedlineTbl()).Insert( pTmp );
             pTmp->InvalidateRange();
         }
@@ -489,7 +489,7 @@ void SwUndoCompDoc::RedoImpl(::sw::UndoRedoContext & rContext)
 
         SetPaM( *pPam );
 
-        SwRedline* pTmp = new SwRedline( *pRedlData, *pPam );
+        SwRangeRedline* pTmp = new SwRangeRedline( *pRedlData, *pPam );
         ((SwRedlineTbl&)pDoc->GetRedlineTbl()).Insert( pTmp );
         if (pTmp) // #i19649#
             pTmp->InvalidateRange();
diff --git a/sw/source/core/undo/unsect.cxx b/sw/source/core/undo/unsect.cxx
index 9a760a63398f..da33bf65386b 100644
--- a/sw/source/core/undo/unsect.cxx
+++ b/sw/source/core/undo/unsect.cxx
@@ -189,7 +189,7 @@ void SwUndoInsSection::RedoImpl(::sw::UndoRedoContext & rContext)
         rDoc.SetRedlineMode_intern((RedlineMode_t)(eOld & ~nsRedlineMode_t::REDLINE_IGNORE));
 
         SwPaM aPam( *pSectNd->EndOfSectionNode(), *pSectNd, 1 );
-        rDoc.AppendRedline( new SwRedline( *m_pRedlData, aPam ), true);
+        rDoc.AppendRedline( new SwRangeRedline( *m_pRedlData, aPam ), true);
         rDoc.SetRedlineMode_intern( eOld );
     }
     else if( !( nsRedlineMode_t::REDLINE_IGNORE & GetRedlineMode() ) &&
diff --git a/sw/source/core/undo/unspnd.cxx b/sw/source/core/undo/unspnd.cxx
index e65b15a17c85..22e07f44422f 100644
--- a/sw/source/core/undo/unspnd.cxx
+++ b/sw/source/core/undo/unspnd.cxx
@@ -173,7 +173,7 @@ void SwUndoSplitNode::RedoImpl(::sw::UndoRedoContext & rContext)
                 {
                     RedlineMode_t eOld = pDoc->GetRedlineMode();
                     pDoc->SetRedlineMode_intern((RedlineMode_t)(eOld & ~nsRedlineMode_t::REDLINE_IGNORE));
-                    pDoc->AppendRedline( new SwRedline( *pRedlData, rPam ), true);
+                    pDoc->AppendRedline( new SwRangeRedline( *pRedlData, rPam ), true);
                     pDoc->SetRedlineMode_intern( eOld );
                 }
                 else
diff --git a/sw/source/core/undo/untbl.cxx b/sw/source/core/undo/untbl.cxx
index f247ada037e0..a2d2565d4ced 100644
--- a/sw/source/core/undo/untbl.cxx
+++ b/sw/source/core/undo/untbl.cxx
@@ -333,7 +333,7 @@ void SwUndoInsTbl::RedoImpl(::sw::UndoRedoContext & rContext)
             RedlineMode_t eOld = rDoc.GetRedlineMode();
             rDoc.SetRedlineMode_intern((RedlineMode_t)(eOld & ~nsRedlineMode_t::REDLINE_IGNORE));
 
-            rDoc.AppendRedline( new SwRedline( *pRedlData, aPam ), true);
+            rDoc.AppendRedline( new SwRangeRedline( *pRedlData, aPam ), true);
             rDoc.SetRedlineMode_intern( eOld );
         }
         else
@@ -2745,7 +2745,7 @@ SwUndo* SwUndoTblCpyTbl::PrepareRedline( SwDoc* pDoc, const SwTableBox& rBox,
     {   // If the old (deleted) part is not empty, here we are...
         SwPaM aDeletePam( aDeleteStart, aCellEnd );
         pUndo = new SwUndoRedlineDelete( aDeletePam, UNDO_DELETE );
-        pDoc->AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_DELETE, aDeletePam ), true );
+        pDoc->AppendRedline( new SwRangeRedline( nsRedlineType_t::REDLINE_DELETE, aDeletePam ), true );
     }
     else if( !rJoin ) // If the old part is empty and joined, we are finished
     {   // if it is not joined, we have to delete this empty paragraph
@@ -2761,7 +2761,7 @@ SwUndo* SwUndoTblCpyTbl::PrepareRedline( SwDoc* pDoc, const SwTableBox& rBox,
     if( aCellStart != aInsertEnd ) // An empty insertion will not been marked
     {
         SwPaM aTmpPam( aCellStart, aInsertEnd );
-        pDoc->AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, aTmpPam ), true );
+        pDoc->AppendRedline( new SwRangeRedline( nsRedlineType_t::REDLINE_INSERT, aTmpPam ), true );
     }
 
     pDoc->SetRedlineMode_intern( eOld );
diff --git a/sw/source/core/undo/untblk.cxx b/sw/source/core/undo/untblk.cxx
index 418746c03b74..84f4fbcd99ef 100644
--- a/sw/source/core/undo/untblk.cxx
+++ b/sw/source/core/undo/untblk.cxx
@@ -295,7 +295,7 @@ void SwUndoInserts::RedoImpl(::sw::UndoRedoContext & rContext)
     {
         RedlineMode_t eOld = pDoc->GetRedlineMode();
         pDoc->SetRedlineMode_intern((RedlineMode_t)( eOld & ~nsRedlineMode_t::REDLINE_IGNORE ));
-        pDoc->AppendRedline( new SwRedline( *pRedlData, *pPam ), true);
+        pDoc->AppendRedline( new SwRangeRedline( *pRedlData, *pPam ), true);
         pDoc->SetRedlineMode_intern( eOld );
     }
     else if( !( nsRedlineMode_t::REDLINE_IGNORE & GetRedlineMode() ) &&
diff --git a/sw/source/core/unocore/unocrsrhelper.cxx b/sw/source/core/unocore/unocrsrhelper.cxx
index d0bde04874d1..4dd150ea2145 100644
--- a/sw/source/core/unocore/unocrsrhelper.cxx
+++ b/sw/source/core/unocore/unocrsrhelper.cxx
@@ -1280,7 +1280,7 @@ void makeRedline( SwPaM& rPaM,
         }
     }
 
-    SwRedline* pRedline = new SwRedline( aRedlineData, rPaM );
+    SwRangeRedline* pRedline = new SwRangeRedline( aRedlineData, rPaM );
     RedlineMode_t nPrevMode = pRedlineAccess->GetRedlineMode( );
     pRedline->SetExtraData( pRedlineExtraData );
 
diff --git a/sw/source/core/unocore/unoportenum.cxx b/sw/source/core/unocore/unoportenum.cxx
index 45a78d415da9..eb75da8da86d 100644
--- a/sw/source/core/unocore/unoportenum.cxx
+++ b/sw/source/core/unocore/unoportenum.cxx
@@ -644,10 +644,10 @@ static void lcl_ExportSoftPageBreak(
 
 struct SwXRedlinePortion_Impl
 {
-    const SwRedline*    m_pRedline;
+    const SwRangeRedline*    m_pRedline;
     const bool          m_bStart;
 
-    SwXRedlinePortion_Impl ( const SwRedline* pRed, const bool bIsStart )
+    SwXRedlinePortion_Impl ( const SwRangeRedline* pRed, const bool bIsStart )
     : m_pRedline(pRed)
     , m_bStart(bIsStart)
     {
@@ -1037,7 +1037,7 @@ static void lcl_FillRedlineArray(
 
         for(sal_uInt16 nRed = 0; nRed < nRedTblCount; nRed++)
         {
-            const SwRedline* pRedline = rRedTbl[nRed];
+            const SwRangeRedline* pRedline = rRedTbl[nRed];
             const SwPosition* pRedStart = pRedline->Start();
             const SwNodeIndex nRedNode = pRedStart->nNode;
             if ( nOwnNode == nRedNode )
diff --git a/sw/source/core/unocore/unoredline.cxx b/sw/source/core/unocore/unoredline.cxx
index d5439d8ae28c..b0d78f28491e 100644
--- a/sw/source/core/unocore/unoredline.cxx
+++ b/sw/source/core/unocore/unoredline.cxx
@@ -181,7 +181,7 @@ sal_Bool SwXRedlineText::hasElements(  ) throw(uno::RuntimeException)
     return sal_True;    // we always have a content index
 }
 
-SwXRedlinePortion::SwXRedlinePortion(SwRedline const& rRedline,
+SwXRedlinePortion::SwXRedlinePortion(SwRangeRedline const& rRedline,
         SwUnoCrsr const*const pPortionCrsr,
         uno::Reference< text::XText > const& xParent, bool const bStart)
     : SwXTextPortion(pPortionCrsr, xParent,
@@ -222,7 +222,7 @@ static OUString lcl_RedlineTypeToOUString(RedlineType_t eType)
     return sRet;
 }
 
-static uno::Sequence<beans::PropertyValue> lcl_GetSuccessorProperties(const SwRedline& rRedline)
+static uno::Sequence<beans::PropertyValue> lcl_GetSuccessorProperties(const SwRangeRedline& rRedline)
 {
     uno::Sequence<beans::PropertyValue> aValues(4);
 
@@ -301,7 +301,7 @@ uno::Sequence< sal_Int8 > SAL_CALL SwXRedlinePortion::getImplementationId(  ) th
     return theSwXRedlinePortionImplementationId::get().getSeq();
 }
 
-uno::Any  SwXRedlinePortion::GetPropertyValue( const OUString& rPropertyName, const SwRedline& rRedline ) throw()
+uno::Any  SwXRedlinePortion::GetPropertyValue( const OUString& rPropertyName, const SwRangeRedline& rRedline ) throw()
 {
     uno::Any aRet;
     if(rPropertyName == UNO_NAME_REDLINE_AUTHOR)
@@ -342,7 +342,7 @@ uno::Any  SwXRedlinePortion::GetPropertyValue( const OUString& rPropertyName, co
 }
 
 uno::Sequence< beans::PropertyValue > SwXRedlinePortion::CreateRedlineProperties(
-    const SwRedline& rRedline, sal_Bool bIsStart ) throw()
+    const SwRangeRedline& rRedline, sal_Bool bIsStart ) throw()
 {
     uno::Sequence< beans::PropertyValue > aRet(11);
     const SwRedlineData* pNext = rRedline.GetRedlineData().Next();
@@ -396,7 +396,7 @@ uno::Sequence< beans::PropertyValue > SwXRedlinePortion::CreateRedlineProperties
 }
 
 TYPEINIT1(SwXRedline, SwClient);
-SwXRedline::SwXRedline(SwRedline& rRedline, SwDoc& rDoc) :
+SwXRedline::SwXRedline(SwRangeRedline& rRedline, SwDoc& rDoc) :
     SwXText(&rDoc, CURSOR_REDLINE),
     pDoc(&rDoc),
     pRedline(&rRedline)
diff --git a/sw/source/core/unocore/unoredlines.cxx b/sw/source/core/unocore/unoredlines.cxx
index 323f7f783874..3bb895ffb085 100644
--- a/sw/source/core/unocore/unoredlines.cxx
+++ b/sw/source/core/unocore/unoredlines.cxx
@@ -113,7 +113,7 @@ uno::Sequence< OUString > SwXRedlines::getSupportedServiceNames(void)
     return uno::Sequence< OUString >();
 }
 
-beans::XPropertySet*    SwXRedlines::GetObject( SwRedline& rRedline, SwDoc& rDoc )
+beans::XPropertySet*    SwXRedlines::GetObject( SwRangeRedline& rRedline, SwDoc& rDoc )
 {
     SwPageDesc* pStdDesc = rDoc.GetPageDescFromPool(RES_POOLPAGE_STANDARD);
     SwIterator<SwXRedline,SwPageDesc> aIter(*pStdDesc);
diff --git a/sw/source/core/unocore/unosect.cxx b/sw/source/core/unocore/unosect.cxx
index bf4f91314713..95d554a8f472 100644
--- a/sw/source/core/unocore/unosect.cxx
+++ b/sw/source/core/unocore/unosect.cxx
@@ -1157,7 +1157,7 @@ throw (beans::UnknownPropertyException, lang::WrappedTargetException,
                     pFmt->GetDoc()->GetRedlineTbl();
                 for (sal_uInt16 nRed = 0; nRed < rRedTbl.size(); nRed++)
                 {
-                    const SwRedline* pRedline = rRedTbl[nRed];
+                    const SwRangeRedline* pRedline = rRedTbl[nRed];
                     SwNode const*const pRedPointNode = pRedline->GetNode(sal_True);
                     SwNode const*const pRedMarkNode = pRedline->GetNode(sal_False);
                     if ((pRedPointNode == pSectNode) ||
diff --git a/sw/source/core/unocore/unotbl.cxx b/sw/source/core/unocore/unotbl.cxx
index 9702a50dfb59..0f9175fb4f0f 100644
--- a/sw/source/core/unocore/unotbl.cxx
+++ b/sw/source/core/unocore/unotbl.cxx
@@ -315,7 +315,7 @@ static uno::Any lcl_GetSpecialProperty(SwFrmFmt* pFmt, const SfxItemPropertySimp
             const SwRedlineTbl& rRedTbl = pFmt->GetDoc()->GetRedlineTbl();
             for(sal_uInt16 nRed = 0; nRed < rRedTbl.size(); nRed++)
             {
-                const SwRedline* pRedline = rRedTbl[nRed];
+                const SwRangeRedline* pRedline = rRedTbl[nRed];
                 const SwNode* pRedPointNode = pRedline->GetNode(sal_True);
                 const SwNode* pRedMarkNode = pRedline->GetNode(sal_False);
                 if(pRedPointNode == pTblNode || pRedMarkNode == pTblNode)
diff --git a/sw/source/core/unocore/unotext.cxx b/sw/source/core/unocore/unotext.cxx
index f59653b8818d..9f8ad7ea6aa3 100644
--- a/sw/source/core/unocore/unotext.cxx
+++ b/sw/source/core/unocore/unotext.cxx
@@ -1167,7 +1167,7 @@ throw (beans::UnknownPropertyException, lang::WrappedTargetException,
                 const sal_uLong nOwnIndex = pStartNode->EndOfSectionIndex();
                 for (sal_uInt16 nRed = 0; nRed < nRedTblCount; nRed++)
                 {
-                    SwRedline const*const pRedline = rRedTbl[nRed];
+                    SwRangeRedline const*const pRedline = rRedTbl[nRed];
                     SwPosition const*const pRedStart = pRedline->Start();
                     const SwNodeIndex nRedNode = pRedStart->nNode;
                     if (nOwnIndex == nRedNode.GetIndex())
diff --git a/sw/source/filter/basflt/shellio.cxx b/sw/source/filter/basflt/shellio.cxx
index 622b4b753d24..d617de8dccfb 100644
--- a/sw/source/filter/basflt/shellio.cxx
+++ b/sw/source/filter/basflt/shellio.cxx
@@ -302,7 +302,7 @@ sal_uLong SwReader::Read( const Reader& rOptions )
 
             pDoc->SetRedlineMode_intern( eOld );
             if( pDoc->IsRedlineOn() )
-                pDoc->AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, *pUndoPam ), true);
+                pDoc->AppendRedline( new SwRangeRedline( nsRedlineType_t::REDLINE_INSERT, *pUndoPam ), true);
             else
                 pDoc->SplitRedline( *pUndoPam );
             pDoc->SetRedlineMode_intern( nsRedlineMode_t::REDLINE_IGNORE );
diff --git a/sw/source/filter/ww1/fltshell.cxx b/sw/source/filter/ww1/fltshell.cxx
index 17d24bc0e383..fac9a06ca54c 100644
--- a/sw/source/filter/ww1/fltshell.cxx
+++ b/sw/source/filter/ww1/fltshell.cxx
@@ -657,7 +657,7 @@ void SwFltControlStack::SetAttrInDoc(const SwPosition& rTmpPos,
                                         aEmptyOUStr,
                                         0
                                         );
-                    pDoc->AppendRedline(new SwRedline(aData, aRegion), true);
+                    pDoc->AppendRedline(new SwRangeRedline(aData, aRegion), true);
                 }
                 SwRedlineData aData(rFltRedline.eType,
                                     rFltRedline.nAutorNo,
@@ -665,7 +665,7 @@ void SwFltControlStack::SetAttrInDoc(const SwPosition& rTmpPos,
                                     aEmptyOUStr,
                                     0
                                     );
-                pDoc->AppendRedline( new SwRedline(aData, aRegion), true );
+                pDoc->AppendRedline( new SwRangeRedline(aData, aRegion), true );
                 pDoc->SetRedlineMode((RedlineMode_t)( nsRedlineMode_t::REDLINE_NONE
                                                 | nsRedlineMode_t::REDLINE_SHOW_INSERT
                                                 | nsRedlineMode_t::REDLINE_SHOW_DELETE ));
diff --git a/sw/source/filter/ww8/rtfexport.cxx b/sw/source/filter/ww8/rtfexport.cxx
index 28d05f0230e3..220442ea0ae7 100644
--- a/sw/source/filter/ww8/rtfexport.cxx
+++ b/sw/source/filter/ww8/rtfexport.cxx
@@ -287,7 +287,7 @@ void RtfExport::WriteRevTab()
 
     for( sal_uInt16 i = 0; i < pDoc->GetRedlineTbl().size(); ++i )
     {
-        const SwRedline* pRedl = pDoc->GetRedlineTbl()[ i ];
+        const SwRangeRedline* pRedl = pDoc->GetRedlineTbl()[ i ];
 
         GetRedline(SW_MOD()->GetRedlineAuthor(pRedl->GetAuthor()));
     }
diff --git a/sw/source/filter/ww8/writerhelper.cxx b/sw/source/filter/ww8/writerhelper.cxx
index 740bdd29c3f8..af6e1e28c90d 100644
--- a/sw/source/filter/ww8/writerhelper.cxx
+++ b/sw/source/filter/ww8/writerhelper.cxx
@@ -745,13 +745,13 @@ namespace sw
                         pFltRedline->nAutorNoPrev, pFltRedline->aStampPrev, aEmptyOUStr,
                         0);
 
-                    mrDoc.AppendRedline(new SwRedline(aData, aRegion), true);
+                    mrDoc.AppendRedline(new SwRangeRedline(aData, aRegion), true);
                 }
 
                 SwRedlineData aData(pFltRedline->eType, pFltRedline->nAutorNo,
                         pFltRedline->aStamp, aEmptyOUStr, 0);
 
-                SwRedline *const pNewRedline(new SwRedline(aData, aRegion));
+                SwRangeRedline *const pNewRedline(new SwRangeRedline(aData, aRegion));
                 // the point node may be deleted in AppendRedline, so park
                 // the PaM somewhere safe
                 aRegion.DeleteMark();
diff --git a/sw/source/filter/ww8/wrtw8nds.cxx b/sw/source/filter/ww8/wrtw8nds.cxx
index d641cbeb6740..f101c1ed1a5e 100644
--- a/sw/source/filter/ww8/wrtw8nds.cxx
+++ b/sw/source/filter/ww8/wrtw8nds.cxx
@@ -271,7 +271,7 @@ sal_Int32 SwWW8AttrIter::SearchNext( sal_Int32 nStartPos )
 
         for ( ; nRedLinePos < m_rExport.pDoc->GetRedlineTbl().size(); ++nRedLinePos )
         {
-            const SwRedline* pRedl = m_rExport.pDoc->GetRedlineTbl()[ nRedLinePos ];
+            const SwRangeRedline* pRedl = m_rExport.pDoc->GetRedlineTbl()[ nRedLinePos ];
 
             const SwPosition* pStt = pRedl->Start();
             const SwPosition* pEnd = pStt == pRedl->GetPoint()
@@ -1213,7 +1213,7 @@ const SwRedlineData* SwWW8AttrIter::GetParagraphLevelRedline( )
     // ToDo : this is not the most ideal ... should start maybe from 'nCurRedlinePos'
     for( sal_uInt16 nRedlinePos = 0; nRedlinePos < m_rExport.pDoc->GetRedlineTbl().size(); ++nRedlinePos )
     {
-        const SwRedline* pRedl = m_rExport.pDoc->GetRedlineTbl()[ nRedlinePos ];
+        const SwRangeRedline* pRedl = m_rExport.pDoc->GetRedlineTbl()[ nRedlinePos ];
 
         const SwPosition* pCheckedStt = pRedl->Start();
 
@@ -1268,7 +1268,7 @@ const SwRedlineData* SwWW8AttrIter::GetRunLevelRedline( sal_Int32 nPos )
         for( ; nCurRedlinePos < m_rExport.pDoc->GetRedlineTbl().size();
                 ++nCurRedlinePos )
         {
-            const SwRedline* pRedl = m_rExport.pDoc->GetRedlineTbl()[ nCurRedlinePos ];
+            const SwRangeRedline* pRedl = m_rExport.pDoc->GetRedlineTbl()[ nCurRedlinePos ];
 
             const SwPosition* pStt = pRedl->Start();
             const SwPosition* pEnd = pStt == pRedl->GetPoint()
@@ -1530,7 +1530,7 @@ static SwTxtFmtColl& lcl_getFormatCollection( MSWordExportBase& rExport, const S
     sal_uInt16 nMax = rExport.pDoc->GetRedlineTbl().size();
     while( nPos < nMax )
     {
-        const SwRedline* pRedl = rExport.pDoc->GetRedlineTbl()[ nPos++ ];
+        const SwRangeRedline* pRedl = rExport.pDoc->GetRedlineTbl()[ nPos++ ];
         const SwPosition* pStt = pRedl->Start();
         const SwPosition* pEnd = pStt == pRedl->GetPoint()
                                     ? pRedl->GetMark()
diff --git a/sw/source/filter/ww8/wrtww8.hxx b/sw/source/filter/ww8/wrtww8.hxx
index 28d9d695cd1f..ea56f3204cda 100644
--- a/sw/source/filter/ww8/wrtww8.hxx
+++ b/sw/source/filter/ww8/wrtww8.hxx
@@ -1481,7 +1481,7 @@ private:
     sal_uInt16 mnScript;
     bool mbCharIsRTL;
 
-    const SwRedline* pCurRedline;
+    const SwRangeRedline* pCurRedline;
     sal_Int32 nAktSwPos;
     sal_uInt16 nCurRedlinePos;
 
diff --git a/sw/source/filter/ww8/ww8atr.cxx b/sw/source/filter/ww8/ww8atr.cxx
index 24d4a18e3553..c7c67c780b62 100644
--- a/sw/source/filter/ww8/ww8atr.cxx
+++ b/sw/source/filter/ww8/ww8atr.cxx
@@ -5405,7 +5405,7 @@ const SwRedlineData* AttributeOutputBase::GetParagraphMarkerRedline( const SwTxt
     // ToDo : this is not the most ideal ... should start maybe from 'nCurRedlinePos'
     for( sal_uInt16 nRedlinePos = 0; nRedlinePos < GetExport().pDoc->GetRedlineTbl().size(); ++nRedlinePos )
     {
-        const SwRedline* pRedl = GetExport().pDoc->GetRedlineTbl()[ nRedlinePos ];
+        const SwRangeRedline* pRedl = GetExport().pDoc->GetRedlineTbl()[ nRedlinePos ];
 
         // Only check redlines that are of type 'Delete'
         if ( pRedl->GetRedlineData().GetType() != aRedlineType )
diff --git a/sw/source/filter/xml/XMLRedlineImportHelper.cxx b/sw/source/filter/xml/XMLRedlineImportHelper.cxx
index e7583aac9f25..aef72a3887e2 100644
--- a/sw/source/filter/xml/XMLRedlineImportHelper.cxx
+++ b/sw/source/filter/xml/XMLRedlineImportHelper.cxx
@@ -215,7 +215,7 @@ public:
     OUString sAuthor;               /// change author string
     OUString sComment;              /// change comment string
     util::DateTime aDateTime;       /// change DateTime
-    sal_Bool bMergeLastParagraph;   /// the SwRedline::IsDelLastPara flag
+    sal_Bool bMergeLastParagraph;   /// the SwRangeRedline::IsDelLastPara flag
 
     // each position can may be either empty, an XTextRange, or an SwNodeIndex
 
@@ -680,10 +680,10 @@ void XMLRedlineImportHelper::InsertIntoDocument(RedlineInfo* pRedlineInfo)
     {
         // regular file loading: insert redline
 
-        // create redline (using pRedlineData which gets copied in SwRedline())
+        // create redline (using pRedlineData which gets copied in SwRangeRedline())
         SwRedlineData* pRedlineData = ConvertRedline(pRedlineInfo, pDoc);
-        SwRedline* pRedline =
-            new SwRedline( pRedlineData, *aPaM.GetPoint(), sal_True,
+        SwRangeRedline* pRedline =
+            new SwRangeRedline( pRedlineData, *aPaM.GetPoint(), sal_True,
                            !pRedlineInfo->bMergeLastParagraph, sal_False );
 
         // set mark
diff --git a/sw/source/ui/docvw/edtwin2.cxx b/sw/source/ui/docvw/edtwin2.cxx
index f5fd78c11fb5..81413b89351c 100644
--- a/sw/source/ui/docvw/edtwin2.cxx
+++ b/sw/source/ui/docvw/edtwin2.cxx
@@ -69,7 +69,7 @@
 #include <IDocumentMarkAccess.hxx>
 #include <ndtxt.hxx>
 
-static OUString lcl_GetRedlineHelp( const SwRedline& rRedl, sal_Bool bBalloon )
+static OUString lcl_GetRedlineHelp( const SwRangeRedline& rRedl, sal_Bool bBalloon )
 {
     sal_uInt16 nResId = 0;
     switch( rRedl.GetType() )
diff --git a/sw/source/ui/inc/content.hxx b/sw/source/ui/inc/content.hxx
index b812d05ca87e..20736297e468 100644
--- a/sw/source/ui/inc/content.hxx
+++ b/sw/source/ui/inc/content.hxx
@@ -29,7 +29,7 @@ class SwContentType;
 class SwFmtFld;
 class SwTxtINetFmt;
 class SwTOXBase;
-class SwRedline;
+class SwRangeRedline;
 
 //----------------------------------------------------------------------------
 //  helper classes
@@ -111,7 +111,7 @@ public:
 class SwPostItContent : public SwContent
 {
     const SwFmtFld*     pFld;
-    SwRedline*          pRedline;
+    SwRangeRedline*          pRedline;
     bool                mbPostIt;
 public:
     SwPostItContent( const SwContentType* pCnt,
@@ -122,13 +122,13 @@ public:
     {}
     SwPostItContent( const SwContentType* pCnt,
                             const OUString& rName,
-                            SwRedline* pRed,
+                            SwRangeRedline* pRed,
                             long nYPos )
         : SwContent( pCnt, rName, nYPos ), pRedline( pRed ),mbPostIt(false)
     {}
 
     const SwFmtFld* GetPostIt()     { return pFld; }
-    SwRedline* GetRedline() { return pRedline; }
+    SwRangeRedline* GetRedline() { return pRedline; }
     virtual sal_Bool    IsProtect()     const;
     bool            IsPostIt()      {return mbPostIt; }
 };
diff --git a/sw/source/ui/inc/redlndlg.hxx b/sw/source/ui/inc/redlndlg.hxx
index ba0a32d9bd9d..4210861ba6fb 100644
--- a/sw/source/ui/inc/redlndlg.hxx
+++ b/sw/source/ui/inc/redlndlg.hxx
@@ -105,13 +105,13 @@ class SW_DLLPUBLIC SwRedlineAcceptDlg
     SW_DLLPRIVATE DECL_LINK( CommandHdl,        void* );
 
     SW_DLLPRIVATE sal_uInt16            CalcDiff(sal_uInt16 nStart, sal_Bool bChild);
-    SW_DLLPRIVATE void          InsertChildren(SwRedlineDataParent *pParent, const SwRedline& rRedln, const sal_uInt16 nAutoFmt);
+    SW_DLLPRIVATE void          InsertChildren(SwRedlineDataParent *pParent, const SwRangeRedline& rRedln, const sal_uInt16 nAutoFmt);
     SW_DLLPRIVATE void          InsertParents(sal_uInt16 nStart, sal_uInt16 nEnd = USHRT_MAX);
     SW_DLLPRIVATE void          RemoveParents(sal_uInt16 nStart, sal_uInt16 nEnd);
     SW_DLLPRIVATE void          InitAuthors();
 
-    SW_DLLPRIVATE OUString      GetRedlineText(const SwRedline& rRedln, DateTime &rDateTime, sal_uInt16 nStack = 0);
-    SW_DLLPRIVATE OUString      GetActionText(const SwRedline& rRedln, sal_uInt16 nStack = 0);
+    SW_DLLPRIVATE OUString      GetRedlineText(const SwRangeRedline& rRedln, DateTime &rDateTime, sal_uInt16 nStack = 0);
+    SW_DLLPRIVATE OUString      GetActionText(const SwRangeRedline& rRedln, sal_uInt16 nStack = 0);
     SW_DLLPRIVATE sal_uInt16    GetRedlinePos( const SvTreeListEntry& rEntry) const;
 
 public:
diff --git a/sw/source/ui/inc/wrtsh.hxx b/sw/source/ui/inc/wrtsh.hxx
index 580376dd412b..2a4f2e28f312 100644
--- a/sw/source/ui/inc/wrtsh.hxx
+++ b/sw/source/ui/inc/wrtsh.hxx
@@ -468,7 +468,7 @@ typedef sal_Bool (SwWrtShell:: *FNSimpleMove)();
     sal_Bool GotoNextTOXBase( const OUString* pName = 0);
     bool GotoTable( const OUString& rName );
     sal_Bool GotoFld( const SwFmtFld& rFld );
-    const SwRedline* GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect = sal_False);
+    const SwRangeRedline* GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect = sal_False);
 
     void ChangeHeaderOrFooter(const OUString& rStyleName, sal_Bool bHeader, sal_Bool bOn, sal_Bool bShowWarning);
     virtual void SetShowHeaderFooterSeparator( FrameControlType eControl, bool bShow );
diff --git a/sw/source/ui/misc/redlndlg.cxx b/sw/source/ui/misc/redlndlg.cxx
index 907cdfeb74ea..d6168a1bd683 100644
--- a/sw/source/ui/misc/redlndlg.cxx
+++ b/sw/source/ui/misc/redlndlg.cxx
@@ -265,7 +265,7 @@ void SwRedlineAcceptDlg::InitAuthors()
     // determine authors
     for ( i = 0; i < nCount; i++)
     {
-        const SwRedline& rRedln = pSh->GetRedline(i);
+        const SwRangeRedline& rRedln = pSh->GetRedline(i);
 
         if( bOnlyFormatedRedlines && nsRedlineType_t::REDLINE_FORMAT != rRedln.GetType() )
             bOnlyFormatedRedlines = sal_False;
@@ -298,7 +298,7 @@ void SwRedlineAcceptDlg::InitAuthors()
         sal_uInt16 nPos = GetRedlinePos(*pSelEntry);
         if( nPos != USHRT_MAX )
         {
-            const SwRedline& rRedln = pSh->GetRedline( nPos );
+            const SwRangeRedline& rRedln = pSh->GetRedline( nPos );
 
             bIsNotFormated |= nsRedlineType_t::REDLINE_FORMAT != rRedln.GetType();
         }
@@ -312,7 +312,7 @@ void SwRedlineAcceptDlg::InitAuthors()
                                 !bOnlyFormatedRedlines );
 }
 
-OUString SwRedlineAcceptDlg::GetRedlineText( const SwRedline& rRedln,
+OUString SwRedlineAcceptDlg::GetRedlineText( const SwRangeRedline& rRedln,
                                         DateTime &rDateTime, sal_uInt16 nStack)
 {
     OUString sEntry(GetActionText(rRedln, nStack));
@@ -331,7 +331,7 @@ OUString SwRedlineAcceptDlg::GetRedlineText( const SwRedline& rRedln,
     return sEntry;
 }
 
-OUString SwRedlineAcceptDlg::GetActionText(const SwRedline& rRedln, sal_uInt16 nStack)
+OUString SwRedlineAcceptDlg::GetActionText(const SwRangeRedline& rRedln, sal_uInt16 nStack)
 {
     switch( rRedln.GetType(nStack) )
     {
@@ -374,7 +374,7 @@ void SwRedlineAcceptDlg::Activate()
 
     for ( i = 0; i < nCount; i++)
     {
-        const SwRedline& rRedln = pSh->GetRedline(i);
+        const SwRangeRedline& rRedln = pSh->GetRedline(i);
 
         if (i >= aRedlineParents.size())
         {
@@ -430,7 +430,7 @@ void SwRedlineAcceptDlg::Activate()
     // check comment
     for (i = 0; i < nCount; i++)
     {
-        const SwRedline& rRedln = pSh->GetRedline(i);
+        const SwRangeRedline& rRedln = pSh->GetRedline(i);
         pParent = &aRedlineParents[i];
 
         if(rRedln.GetComment() != pParent->sComment)
@@ -461,7 +461,7 @@ sal_uInt16 SwRedlineAcceptDlg::CalcDiff(sal_uInt16 nStart, sal_Bool bChild)
     SwWrtShell* pSh = pView->GetWrtShellPtr();
     sal_uInt16 nAutoFmt = HasRedlineAutoFmt() ? nsRedlineType_t::REDLINE_FORM_AUTOFMT : 0;
     SwRedlineDataParent *pParent = &aRedlineParents[nStart];
-    const SwRedline& rRedln = pSh->GetRedline(nStart);
+    const SwRangeRedline& rRedln = pSh->GetRedline(nStart);
 
     if (bChild)     // should actually never happen, but just in case...
     {
@@ -527,7 +527,7 @@ sal_uInt16 SwRedlineAcceptDlg::CalcDiff(sal_uInt16 nStart, sal_Bool bChild)
     return USHRT_MAX;
 }
 
-void SwRedlineAcceptDlg::InsertChildren(SwRedlineDataParent *pParent, const SwRedline& rRedln, const sal_uInt16 nAutoFmt)
+void SwRedlineAcceptDlg::InsertChildren(SwRedlineDataParent *pParent, const SwRangeRedline& rRedln, const sal_uInt16 nAutoFmt)
 {
     OUString sChild;
     SwRedlineDataChild *pLastRedlineChild = 0;
@@ -701,7 +701,7 @@ void SwRedlineAcceptDlg::InsertParents(sal_uInt16 nStart, sal_uInt16 nEnd)
     RedlinData *pData;
     SvTreeListEntry *pParent;
     SwRedlineDataParent* pRedlineParent;
-    const SwRedline* pCurrRedline;
+    const SwRangeRedline* pCurrRedline;
     if( !nStart && !pTable->FirstSelected() )
     {
         pCurrRedline = pSh->GetCurrRedline();
@@ -718,7 +718,7 @@ void SwRedlineAcceptDlg::InsertParents(sal_uInt16 nStart, sal_uInt16 nEnd)
 
     for (sal_uInt16 i = nStart; i <= nEnd; i++)
     {
-        const SwRedline& rRedln = pSh->GetRedline(i);
+        const SwRangeRedline& rRedln = pSh->GetRedline(i);
         const SwRedlineData *pRedlineData = &rRedln.GetRedlineData();
 
         pRedlineParent = new SwRedlineDataParent;
@@ -963,7 +963,7 @@ IMPL_LINK_NOARG(SwRedlineAcceptDlg, GotoHdl)
             if( nPos != USHRT_MAX )
             {
 
-                const SwRedline& rRedln = pSh->GetRedline( nPos );
+                const SwRangeRedline& rRedln = pSh->GetRedline( nPos );
                 bIsNotFormated |= nsRedlineType_t::REDLINE_FORMAT != rRedln.GetType();
 
                 if (pSh->GotoRedline(nPos, sal_True))
@@ -998,7 +998,7 @@ IMPL_LINK_NOARG(SwRedlineAcceptDlg, CommandHdl)
         {
             SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr();
             SvTreeListEntry* pEntry = pTable->FirstSelected();
-            const SwRedline *pRed = 0;
+            const SwRangeRedline *pRed = 0;
 
             if (pEntry)
             {
@@ -1055,14 +1055,14 @@ IMPL_LINK_NOARG(SwRedlineAcceptDlg, CommandHdl)
                         if (nPos == USHRT_MAX)
                             break;
 
-                        const SwRedline &rRedline = pSh->GetRedline(nPos);
+                        const SwRangeRedline &rRedline = pSh->GetRedline(nPos);
 
 
                         /* enable again once we have redline comments in the margin
                         sComment = rRedline.GetComment();
                         if ( !sComment.Len() )
                             GetActiveView()->GetDocShell()->Broadcast(SwRedlineHint(&rRedline,SWREDLINE_INSERTED));
-                        const_cast<SwRedline&>(rRedline).Broadcast(SwRedlineHint(&rRedline,SWREDLINE_FOCUS));
+                        const_cast<SwRangeRedline&>(rRedline).Broadcast(SwRedlineHint(&rRedline,SWREDLINE_FOCUS));
                         */
 
                         OUString sComment = convertLineEnd(rRedline.GetComment(), GetSystemLineEnd());
diff --git a/sw/source/ui/shells/textfld.cxx b/sw/source/ui/shells/textfld.cxx
index ca167c05f8d0..c19ba32b57b5 100644
--- a/sw/source/ui/shells/textfld.cxx
+++ b/sw/source/ui/shells/textfld.cxx
@@ -398,18 +398,18 @@ void SwTextShell::ExecField(SfxRequest &rReq)
                 /*  this code can be used once we want redline comments in the margin, all other stuff can
                     then be deleted
                 String sComment;
-                const SwRedline *pRedline = rSh.GetCurrRedline();
+                const SwRangeRedline *pRedline = rSh.GetCurrRedline();
 
                 if (pRedline)
                 {
                     sComment = pRedline->GetComment();
                     if ( !sComment.Len() )
                         GetView().GetDocShell()->Broadcast(SwRedlineHint(pRedline,SWREDLINE_INSERTED));
-                    const_cast<SwRedline*>(pRedline)->Broadcast(SwRedlineHint(pRedline,SWREDLINE_FOCUS,&GetView()));
+                    const_cast<SwRangeRedline*>(pRedline)->Broadcast(SwRedlineHint(pRedline,SWREDLINE_FOCUS,&GetView()));
                 }
                 */
 
-                const SwRedline *pRedline = rSh.GetCurrRedline();
+                const SwRangeRedline *pRedline = rSh.GetCurrRedline();
 
                 if (pRedline)
                 {
@@ -433,7 +433,7 @@ void SwTextShell::ExecField(SfxRequest &rReq)
                     rSh.StartAction();
 
                     rSh.Push();
-                    const SwRedline *pActRed = rSh.SelPrevRedline();
+                    const SwRangeRedline *pActRed = rSh.SelPrevRedline();
 
                     if (pActRed == pRedline)
                     {   // New cursor is at the beginning of the current redlines.
@@ -829,7 +829,7 @@ IMPL_LINK( SwTextShell, RedlineNextHdl, AbstractSvxPostItDialog *, pBtn )
     // Insert or change a comment.
     pSh->SetRedlineComment(pDlg->GetNote());
 
-    const SwRedline *pRedline = pSh->GetCurrRedline();
+    const SwRangeRedline *pRedline = pSh->GetCurrRedline();
 
     if (pRedline)
     {
@@ -838,7 +838,7 @@ IMPL_LINK( SwTextShell, RedlineNextHdl, AbstractSvxPostItDialog *, pBtn )
             pSh->SwapPam(); // Move the cursor behind the Redline.
 
         pSh->Push();
-        const SwRedline *pActRed = pSh->SelNextRedline();
+        const SwRangeRedline *pActRed = pSh->SelNextRedline();
         pSh->Pop(pActRed != 0);
 
         sal_Bool bEnable = sal_False;
@@ -882,13 +882,13 @@ IMPL_LINK( SwTextShell, RedlinePrevHdl, AbstractSvxPostItDialog *, pBtn )
     // Insert or change a comment.
     pSh->SetRedlineComment(pDlg->GetNote());
 
-    const SwRedline *pRedline = pSh->GetCurrRedline();
+    const SwRangeRedline *pRedline = pSh->GetCurrRedline();
 
     if (pRedline)
     {
         // Traveling only if more than one field.
         pSh->Push();
-        const SwRedline *pActRed = pSh->SelPrevRedline();
+        const SwRangeRedline *pActRed = pSh->SelPrevRedline();
         pSh->Pop(pActRed != 0);
 
         sal_Bool bEnable = sal_False;
diff --git a/sw/source/ui/uiview/view2.cxx b/sw/source/ui/uiview/view2.cxx
index 60b109ec117e..26014735fd0e 100644
--- a/sw/source/ui/uiview/view2.cxx
+++ b/sw/source/ui/uiview/view2.cxx
@@ -648,7 +648,7 @@ void SwView::Execute(SfxRequest &rReq)
             SwPaM *pCursor = m_pWrtShell->GetCrsr();
 
             sal_uInt16 nRedline = 0;
-            const SwRedline *pRedline = pDoc->GetRedline(*pCursor->Start(), &nRedline);
+            const SwRangeRedline *pRedline = pDoc->GetRedline(*pCursor->Start(), &nRedline);
             assert(pRedline != 0);
             if (pRedline)
             {
@@ -662,8 +662,8 @@ void SwView::Execute(SfxRequest &rReq)
 
         case FN_REDLINE_NEXT_CHANGE:
         {
-            const SwRedline *pCurrent = m_pWrtShell->GetCurrRedline();
-            const SwRedline *pNext = m_pWrtShell->SelNextRedline();
+            const SwRangeRedline *pCurrent = m_pWrtShell->GetCurrRedline();
+            const SwRangeRedline *pNext = m_pWrtShell->SelNextRedline();
 
             // FN_REDLINE_PREV_CHANGE leaves the selection point at the start of the redline.
             // In such cases, SelNextRedline (which starts searching from the selection point)
@@ -683,7 +683,7 @@ void SwView::Execute(SfxRequest &rReq)
         {
             const SwPaM *pCursor = m_pWrtShell->GetCrsr();
             const SwPosition initialCursorStart = *pCursor->Start();
-            const SwRedline *pPrev = m_pWrtShell->SelPrevRedline();
+            const SwRangeRedline *pPrev = m_pWrtShell->SelPrevRedline();
 
             if (pPrev)
             {
diff --git a/sw/source/ui/wrtsh/move.cxx b/sw/source/ui/wrtsh/move.cxx
index 7f5cab28888b..c31afc6afec2 100644
--- a/sw/source/ui/wrtsh/move.cxx
+++ b/sw/source/ui/wrtsh/move.cxx
@@ -675,9 +675,9 @@ sal_Bool SwWrtShell::GotoFld( const SwFmtFld& rFld ) {
     return bRet;
 }
 
-const SwRedline* SwWrtShell::GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect ) {
+const SwRangeRedline* SwWrtShell::GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect ) {
     SwPosition aPos = *GetCrsr()->GetPoint();
-    const SwRedline *pRedline = SwCrsrShell::GotoRedline(nArrPos, bSelect);
+    const SwRangeRedline *pRedline = SwCrsrShell::GotoRedline(nArrPos, bSelect);
     if (pRedline)
         aNavigationMgr.addEntry(aPos);
     return pRedline;