Move away from SV_DECL_PTRARR in CharAttribList.

This is a huge change.  I'm sure I broke something somewhere...

12 files changed, 425 insertions, 359 deletions

diff --git a/editeng/source/editeng/editattr.cxx b/editeng/source/editeng/editattr.cxx
index 8c7677a37968..171eb3652ed9 100644
--- a/editeng/source/editeng/editattr.cxx
+++ b/editeng/source/editeng/editattr.cxx
@@ -66,6 +66,12 @@ EditAttrib::EditAttrib( const SfxPoolItem& rAttr )
     pItem = &rAttr;
 }
 
+EditAttrib::EditAttrib(const EditAttrib& r) :
+    pItem(r.pItem)
+{
+    DBG_CTOR( EE_EditAttrib, 0 );
+}
+
 EditAttrib::~EditAttrib()
 {
     DBG_DTOR( EE_EditAttrib, 0 );
@@ -74,18 +80,18 @@ EditAttrib::~EditAttrib()
 // -------------------------------------------------------------------------
 // class EditCharAttrib
 // -------------------------------------------------------------------------
-EditCharAttrib::EditCharAttrib( const SfxPoolItem& rAttr, sal_uInt16 nS, sal_uInt16 nE )
-                    : EditAttrib( rAttr )
+EditCharAttrib::EditCharAttrib( const SfxPoolItem& rAttr, sal_uInt16 nS, sal_uInt16 nE ) :
+    EditAttrib(rAttr),
+    nStart(nS), nEnd(nE), bFeature(false), bEdge(false)
 {
-    nStart      = nS;
-    nEnd        = nE;
-    bFeature    = sal_False;
-    bEdge       = sal_False;
-
     DBG_ASSERT( ( rAttr.Which() >= EE_ITEMS_START ) && ( rAttr.Which() <= EE_ITEMS_END ), "EditCharAttrib CTOR: Invalid id!" );
     DBG_ASSERT( ( rAttr.Which() < EE_FEATURE_START ) || ( rAttr.Which() > EE_FEATURE_END ) || ( nE == (nS+1) ), "EditCharAttrib CTOR: Invalid feature!" );
 }
 
+EditCharAttrib::EditCharAttrib(const EditCharAttrib& r) :
+    EditAttrib(r),
+    nStart(r.nStart), nEnd(r.nEnd), bFeature(r.bFeature), bEdge(r.bEdge) {}
+
 void EditCharAttrib::SetFont( SvxFont&, OutputDevice* )
 {
 }
diff --git a/editeng/source/editeng/editattr.hxx b/editeng/source/editeng/editattr.hxx
index 8e820848a209..0ad35a23e5e4 100644
--- a/editeng/source/editeng/editattr.hxx
+++ b/editeng/source/editeng/editattr.hxx
@@ -71,14 +71,14 @@ class SfxVoidItem;
 class EditAttrib
 {
 private:
-            EditAttrib() {;}
-            EditAttrib( const EditAttrib & ) {;}
+    EditAttrib();
 
 protected:
     const SfxPoolItem*  pItem;
 
-                        EditAttrib( const SfxPoolItem& rAttr );
-    virtual             ~EditAttrib();
+    EditAttrib( const SfxPoolItem& rAttr );
+    EditAttrib(const EditAttrib& r);
+    virtual ~EditAttrib();
 
 public:
     // RemoveFromPool must always be called before the destructor!!
@@ -103,7 +103,8 @@ protected:
     sal_Bool                bEdge       :1;
 
 public:
-            EditCharAttrib( const SfxPoolItem& rAttr, sal_uInt16 nStart, sal_uInt16 nEnd );
+    EditCharAttrib( const SfxPoolItem& rAttr, sal_uInt16 nStart, sal_uInt16 nEnd );
+    EditCharAttrib(const EditCharAttrib& r);
 
     sal_uInt16&         GetStart()                  { return nStart; }
     sal_uInt16&         GetEnd()                    { return nEnd; }
@@ -180,7 +181,7 @@ public:
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribWeight
 // -------------------------------------------------------------------------
 class EditCharAttribWeight : public EditCharAttrib
@@ -190,7 +191,7 @@ public:
 
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribItalic
 // -------------------------------------------------------------------------
 class EditCharAttribItalic : public EditCharAttrib
@@ -201,7 +202,7 @@ public:
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribShadow
 // -------------------------------------------------------------------------
 class EditCharAttribShadow : public EditCharAttrib
@@ -212,7 +213,7 @@ public:
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribEscapement
 // -------------------------------------------------------------------------
 class EditCharAttribEscapement : public EditCharAttrib
@@ -223,7 +224,7 @@ public:
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribOutline
 // -------------------------------------------------------------------------
 class EditCharAttribOutline : public EditCharAttrib
@@ -234,7 +235,7 @@ public:
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribStrikeout
 // -------------------------------------------------------------------------
 class EditCharAttribStrikeout : public EditCharAttrib
@@ -245,7 +246,7 @@ public:
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribUnderline
 // -------------------------------------------------------------------------
 class EditCharAttribUnderline : public EditCharAttrib
@@ -289,7 +290,7 @@ public:
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribFontHeight
 // -------------------------------------------------------------------------
 class EditCharAttribFontHeight : public EditCharAttrib
@@ -300,7 +301,7 @@ public:
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribFontWidth
 // -------------------------------------------------------------------------
 class EditCharAttribFontWidth : public EditCharAttrib
@@ -311,7 +312,7 @@ public:
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribColor
 // -------------------------------------------------------------------------
 class EditCharAttribColor : public EditCharAttrib
@@ -322,7 +323,7 @@ public:
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribLanguage
 // -------------------------------------------------------------------------
 class EditCharAttribLanguage : public EditCharAttrib
@@ -333,7 +334,7 @@ public:
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribTab
 // -------------------------------------------------------------------------
 class EditCharAttribTab : public EditCharAttrib
@@ -344,7 +345,7 @@ public:
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribLineBreak
 // -------------------------------------------------------------------------
 class EditCharAttribLineBreak : public EditCharAttrib
@@ -355,7 +356,7 @@ public:
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribField
 // -------------------------------------------------------------------------
 class EditCharAttribField: public EditCharAttrib
@@ -390,7 +391,7 @@ public:
                     }
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribPairKerning
 // -------------------------------------------------------------------------
 class EditCharAttribPairKerning : public EditCharAttrib
@@ -401,7 +402,7 @@ public:
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribKerning
 // -------------------------------------------------------------------------
 class EditCharAttribKerning : public EditCharAttrib
@@ -412,7 +413,7 @@ public:
     virtual void    SetFont( SvxFont& rFont, OutputDevice* pOutDev );
 };
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // class EditCharAttribWordLineMode
 // -------------------------------------------------------------------------
 class EditCharAttribWordLineMode: public EditCharAttrib
diff --git a/editeng/source/editeng/editdoc.cxx b/editeng/source/editeng/editdoc.cxx
index 98268d90a9c8..f83d05420aa7 100644
--- a/editeng/source/editeng/editdoc.cxx
+++ b/editeng/source/editeng/editdoc.cxx
@@ -63,7 +63,8 @@
 #include <tools/shl.hxx>
 #include <vcl/svapp.hxx>
 #include <com/sun/star/i18n/ScriptType.hpp>
-#include <stdlib.h> // qsort
+
+#include <boost/bind.hpp>
 
 using namespace ::com::sun::star;
 
@@ -257,15 +258,6 @@ sal_uInt16 aV5Map[] = {
 
 SV_IMPL_PTRARR( DummyContentList, ContentNode* );
 
-int SAL_CALL CompareStart( const void* pFirst, const void* pSecond )
-{
-    if ( (*((EditCharAttrib**)pFirst))->GetStart() < (*((EditCharAttrib**)pSecond))->GetStart() )
-        return (-1);
-    else if ( (*((EditCharAttrib**)pFirst))->GetStart() > (*((EditCharAttrib**)pSecond))->GetStart() )
-        return (1);
-    return 0;
-}
-
 EditCharAttrib* MakeCharAttrib( SfxItemPool& rPool, const SfxPoolItem& rAttr, sal_uInt16 nS, sal_uInt16 nE )
 {
     // Create a new attribute in the pool
@@ -719,11 +711,12 @@ void ContentNode::ExpandAttribs( sal_uInt16 nIndex, sal_uInt16 nNew, SfxItemPool
     // an existing special case, must (n-1) opportunities be provided with
     // bResort. The most likely possibility receives no bResort, so that is
     // not sorted anew when all attributes are the same.
-    sal_Bool bResort = sal_False;
-    sal_Bool bExpandedEmptyAtIndexNull = sal_False;
+    bool bResort = false;
+    bool bExpandedEmptyAtIndexNull = false;
 
-    sal_uInt16 nAttr = 0;
-    EditCharAttrib* pAttrib = GetAttrib( aCharAttribList.GetAttribs(), nAttr );
+    size_t nAttr = 0;
+    CharAttribList::AttribsType& rAttribs = aCharAttribList.GetAttribs();
+    EditCharAttrib* pAttrib = GetAttrib(rAttribs, nAttr);
     while ( pAttrib )
     {
         if ( pAttrib->GetEnd() >= nIndex )
@@ -777,7 +770,7 @@ void ContentNode::ExpandAttribs( sal_uInt16 nIndex, sal_uInt16 nNew, SfxItemPool
                 }
                 else
                 {
-                    sal_Bool bExpand = sal_False;
+                    bool bExpand = false;
                     if ( nIndex == 0 )
                     {
                         bExpand = sal_True;
@@ -787,10 +780,10 @@ void ContentNode::ExpandAttribs( sal_uInt16 nIndex, sal_uInt16 nNew, SfxItemPool
                             sal_uInt16 nW = pAttrib->GetItem()->Which();
                             for ( sal_uInt16 nA = 0; nA < nAttr; nA++ )
                             {
-                                EditCharAttrib* pA = aCharAttribList.GetAttribs()[nA];
-                                if ( ( pA->GetStart() == 0 ) && ( pA->GetItem()->Which() == nW ) )
+                                const EditCharAttrib& r = aCharAttribList.GetAttribs()[nA];
+                                if ( ( r.GetStart() == 0 ) && ( r.GetItem()->Which() == nW ) )
                                 {
-                                    bExpand = sal_False;
+                                    bExpand = false;
                                     break;
                                 }
                             }
@@ -800,7 +793,7 @@ void ContentNode::ExpandAttribs( sal_uInt16 nIndex, sal_uInt16 nNew, SfxItemPool
                     if ( bExpand )
                     {
                         pAttrib->Expand( nNew );
-                        bResort = sal_True;
+                        bResort = true;
                     }
                     else
                     {
@@ -811,7 +804,7 @@ void ContentNode::ExpandAttribs( sal_uInt16 nIndex, sal_uInt16 nNew, SfxItemPool
         }
 
         if ( pAttrib->IsEdge() )
-            pAttrib->SetEdge( sal_False );
+            pAttrib->SetEdge(false);
 
         DBG_ASSERT( !pAttrib->IsFeature() || ( pAttrib->GetLen() == 1 ), "Expand: FeaturesLen != 1" );
 
@@ -820,14 +813,13 @@ void ContentNode::ExpandAttribs( sal_uInt16 nIndex, sal_uInt16 nNew, SfxItemPool
         if ( pAttrib->IsEmpty() )
         {
             OSL_FAIL( "Empty Attribute after ExpandAttribs?" );
-            bResort = sal_True;
-            aCharAttribList.GetAttribs().Remove( nAttr );
+            bResort = true;
             rItemPool.Remove( *pAttrib->GetItem() );
-            delete pAttrib;
-            nAttr--;
+            rAttribs.erase(rAttribs.begin()+nAttr);
+            --nAttr;
         }
-        nAttr++;
-        pAttrib = GetAttrib( aCharAttribList.GetAttribs(), nAttr );
+        ++nAttr;
+        pAttrib = GetAttrib(rAttribs, nAttr);
     }
 
     if ( bResort )
@@ -851,15 +843,16 @@ void ContentNode::CollapsAttribs( sal_uInt16 nIndex, sal_uInt16 nDeleted, SfxIte
 
     // Since features are treated differently than normal character attributes,
     // can also the order of the start list be change!
-    sal_Bool bResort = sal_False;
-    sal_Bool bDelAttr = sal_False;
+    bool bResort = false;
+    bool bDelAttr = false;
     sal_uInt16 nEndChanges = nIndex+nDeleted;
 
-    sal_uInt16 nAttr = 0;
-    EditCharAttrib* pAttrib = GetAttrib( aCharAttribList.GetAttribs(), nAttr );
+    size_t nAttr = 0;
+    CharAttribList::AttribsType& rAttribs = aCharAttribList.GetAttribs();
+    EditCharAttrib* pAttrib = GetAttrib(rAttribs, nAttr);
     while ( pAttrib )
     {
-        bDelAttr = sal_False;
+        bDelAttr = false;
         if ( pAttrib->GetEnd() >= nIndex )
         {
             // Move all Attribute behind the insert point...
@@ -908,17 +901,16 @@ void ContentNode::CollapsAttribs( sal_uInt16 nIndex, sal_uInt16 nDeleted, SfxIte
         DBG_ASSERT( ( pAttrib->GetEnd() <= Len()) || bDelAttr, "Collaps: Attribute larger than paragraph!" );
         if ( bDelAttr )
         {
-            bResort = sal_True;
-            aCharAttribList.GetAttribs().Remove( nAttr );
+            bResort = true;
             rItemPool.Remove( *pAttrib->GetItem() );
-            delete pAttrib;
+            rAttribs.erase(rAttribs.begin()+nAttr);
             nAttr--;
         }
         else if ( pAttrib->IsEmpty() )
-            aCharAttribList.HasEmptyAttribs() = sal_True;
+            aCharAttribList.SetHasEmptyAttribs(true);
 
         nAttr++;
-        pAttrib = GetAttrib( aCharAttribList.GetAttribs(), nAttr );
+        pAttrib = GetAttrib(rAttribs, nAttr);
     }
 
     if ( bResort )
@@ -938,8 +930,9 @@ void ContentNode::CopyAndCutAttribs( ContentNode* pPrevNode, SfxItemPool& rPool,
 
     xub_StrLen nCut = pPrevNode->Len();
 
-    sal_uInt16 nAttr = 0;
-    EditCharAttrib* pAttrib = GetAttrib( pPrevNode->GetCharAttribs().GetAttribs(), nAttr );
+    size_t nAttr = 0;
+    CharAttribList::AttribsType& rPrevAttribs = pPrevNode->GetCharAttribs().GetAttribs();
+    EditCharAttrib* pAttrib = GetAttrib(rPrevAttribs, nAttr);
     while ( pAttrib )
     {
         if ( pAttrib->GetEnd() < nCut )
@@ -969,9 +962,9 @@ void ContentNode::CopyAndCutAttribs( ContentNode* pPrevNode, SfxItemPool& rPool,
         else
         {
             // Move all attributes in the current node (this)
-//          pPrevNode->GetCharAttribs().RemoveAttrib( pAttrib );
-            pPrevNode->GetCharAttribs().GetAttribs().Remove( nAttr );
-            aCharAttribList.InsertAttrib( pAttrib );
+            CharAttribList::AttribsType::iterator it = rPrevAttribs.begin() + nAttr;
+            aCharAttribList.InsertAttrib(rPrevAttribs.release(it).release());
+
             DBG_ASSERT( pAttrib->GetStart() >= nCut, "Start < nCut!" );
             DBG_ASSERT( pAttrib->GetEnd() >= nCut, "End < nCut!" );
             pAttrib->GetStart() = pAttrib->GetStart() - nCut;
@@ -979,7 +972,7 @@ void ContentNode::CopyAndCutAttribs( ContentNode* pPrevNode, SfxItemPool& rPool,
             nAttr--;
         }
         nAttr++;
-        pAttrib = GetAttrib( pPrevNode->GetCharAttribs().GetAttribs(), nAttr );
+        pAttrib = GetAttrib(rPrevAttribs, nAttr);
     }
 }
 
@@ -993,16 +986,17 @@ void ContentNode::AppendAttribs( ContentNode* pNextNode )
     OSL_ENSURE( aCharAttribList.DbgCheckAttribs(), "Attribute before AppendAttribs broken" );
 #endif
 
-    sal_uInt16 nAttr = 0;
-    EditCharAttrib* pAttrib = GetAttrib( pNextNode->GetCharAttribs().GetAttribs(), nAttr );
+    size_t nAttr = 0;
+    CharAttribList::AttribsType& rNextAttribs = pNextNode->GetCharAttribs().GetAttribs();
+    EditCharAttrib* pAttrib = GetAttrib(rNextAttribs, nAttr);
     while ( pAttrib )
     {
         // Move all attributes in the current node (this)
-        sal_Bool bMelted = sal_False;
+        bool bMelted = false;
         if ( ( pAttrib->GetStart() == 0 ) && ( !pAttrib->IsFeature() ) )
         {
             // Attributes can possibly be summarized as:
-            sal_uInt16 nTmpAttr = 0;
+            size_t nTmpAttr = 0;
             EditCharAttrib* pTmpAttrib = GetAttrib( aCharAttribList.GetAttribs(), nTmpAttr );
             while ( !bMelted && pTmpAttrib )
             {
@@ -1013,10 +1007,9 @@ void ContentNode::AppendAttribs( ContentNode* pNextNode )
                     {
                         pTmpAttrib->GetEnd() =
                             pTmpAttrib->GetEnd() + pAttrib->GetLen();
-                        pNextNode->GetCharAttribs().GetAttribs().Remove( nAttr );
+                        rNextAttribs.erase(rNextAttribs.begin()+nAttr);
                         // Unsubscribe from the pool?!
-                        delete pAttrib;
-                        bMelted = sal_True;
+                        bMelted = true;
                     }
                 }
                 ++nTmpAttr;
@@ -1028,13 +1021,13 @@ void ContentNode::AppendAttribs( ContentNode* pNextNode )
         {
             pAttrib->GetStart() = pAttrib->GetStart() + nNewStart;
             pAttrib->GetEnd() = pAttrib->GetEnd() + nNewStart;
-            aCharAttribList.InsertAttrib( pAttrib );
-            ++nAttr;
+            CharAttribList::AttribsType::iterator it = rNextAttribs.begin() + nAttr;
+            aCharAttribList.InsertAttrib(rNextAttribs.release(it).release());
         }
-        pAttrib = GetAttrib( pNextNode->GetCharAttribs().GetAttribs(), nAttr );
+        pAttrib = GetAttrib(rNextAttribs, nAttr);
     }
     // For the Attributes that just moved over:
-    pNextNode->GetCharAttribs().Clear();
+    rNextAttribs.clear();
 
 #if OSL_DEBUG_LEVEL > 2
     OSL_ENSURE( aCharAttribList.DbgCheckAttribs(), "Attribute after AppendAttribs broken" );
@@ -1232,8 +1225,8 @@ void EditDoc::RemoveItemsFromPool( ContentNode* pNode )
 {
     for ( sal_uInt16 nAttr = 0; nAttr < pNode->GetCharAttribs().Count(); nAttr++ )
     {
-        EditCharAttrib* pAttr = pNode->GetCharAttribs().GetAttribs()[nAttr];
-        GetItemPool().Remove( *pAttr->GetItem() );
+        const EditCharAttrib& rAttr = pNode->GetCharAttribs().GetAttribs()[nAttr];
+        GetItemPool().Remove(*rAttr.GetItem());
     }
 }
 
@@ -1391,7 +1384,7 @@ XubString EditDoc::GetParaAsString( ContentNode* pNode, sal_uInt16 nStartPos, sa
 
     sal_uInt16 nIndex = nStartPos;
     XubString aStr;
-    EditCharAttrib* pNextFeature = pNode->GetCharAttribs().FindFeature( nIndex );
+    const EditCharAttrib* pNextFeature = pNode->GetCharAttribs().FindFeature( nIndex );
     while ( nIndex < nEndPos )
     {
         sal_uInt16 nEnd = nEndPos;
@@ -1414,8 +1407,9 @@ XubString EditDoc::GetParaAsString( ContentNode* pNode, sal_uInt16 nStartPos, sa
                 break;
                 case EE_FEATURE_LINEBR: aStr += '\x0A';
                 break;
-                case EE_FEATURE_FIELD:  if ( bResolveFields )
-                                            aStr += ((EditCharAttribField*)pNextFeature)->GetFieldValue();
+                case EE_FEATURE_FIELD:
+                    if ( bResolveFields )
+                        aStr += static_cast<const EditCharAttribField*>(pNextFeature)->GetFieldValue();
                 break;
                 default:    OSL_FAIL( "What feature?" );
             }
@@ -1434,13 +1428,13 @@ sal_uLong EditDoc::GetTextLen() const
         ContentNode* pNode = GetObject( nNode );
         nLen += pNode->Len();
         // Fields can be longer than the placeholder in the Node
-        const CharAttribArray& rAttrs = pNode->GetCharAttribs().GetAttribs();
-        for ( sal_uInt16 nAttr = rAttrs.Count(); nAttr; )
+        const CharAttribList::AttribsType& rAttrs = pNode->GetCharAttribs().GetAttribs();
+        for (size_t nAttr = rAttrs.size(); nAttr; )
         {
-            EditCharAttrib* pAttr = rAttrs[--nAttr];
-            if ( pAttr->Which() == EE_FEATURE_FIELD )
+            const EditCharAttrib& rAttr = rAttrs[--nAttr];
+            if (rAttr.Which() == EE_FEATURE_FIELD)
             {
-                sal_uInt16 nFieldLen = ((EditCharAttribField*)pAttr)->GetFieldValue().Len();
+                sal_uInt16 nFieldLen = static_cast<const EditCharAttribField&>(rAttr).GetFieldValue().Len();
                 if ( !nFieldLen )
                     nLen--;
                 else
@@ -1639,8 +1633,7 @@ void EditDoc::InsertAttribInSelection( ContentNode* pNode, sal_uInt16 nStart, sa
         // Will become a large Attribute.
         pEndingAttrib->GetEnd() = pStartingAttrib->GetEnd();
         GetItemPool().Remove( *(pStartingAttrib->GetItem()) );
-        pNode->GetCharAttribs().GetAttribs().Remove( pNode->GetCharAttribs().GetAttribs().GetPos( pStartingAttrib ) );
-        delete pStartingAttrib;
+        pNode->GetCharAttribs().Remove(pStartingAttrib);
     }
     else if ( pStartingAttrib && ( *(pStartingAttrib->GetItem()) == rPoolItem ) )
         pStartingAttrib->GetStart() = nStart;
@@ -1652,7 +1645,7 @@ void EditDoc::InsertAttribInSelection( ContentNode* pNode, sal_uInt16 nStart, sa
     if ( pStartingAttrib )
         pNode->GetCharAttribs().ResortAttribs();
 
-    SetModified( sal_True );
+    SetModified(true);
 }
 
 sal_Bool EditDoc::RemoveAttribs( ContentNode* pNode, sal_uInt16 nStart, sal_uInt16 nEnd, sal_uInt16 nWhich )
@@ -1673,16 +1666,17 @@ sal_Bool EditDoc::RemoveAttribs( ContentNode* pNode, sal_uInt16 nStart, sal_uInt
     // This starts at the end of the selection => can be expanded
     rpStarting = 0;
 
-    sal_Bool bChanged = sal_False;
+    bool bChanged = false;
 
     DBG_ASSERT( nStart <= nEnd, "Small miscalculations in InsertAttribInSelection" );
 
     // iterate over the attributes ...
-    sal_uInt16 nAttr = 0;
-    EditCharAttrib* pAttr = GetAttrib( pNode->GetCharAttribs().GetAttribs(), nAttr );
+    size_t nAttr = 0;
+    CharAttribList::AttribsType& rAttribs = pNode->GetCharAttribs().GetAttribs();
+    EditCharAttrib* pAttr = GetAttrib(rAttribs, nAttr);
     while ( pAttr )
     {
-        sal_Bool bRemoveAttrib = sal_False;
+        bool bRemoveAttrib = false;
         sal_uInt16 nAttrWhich = pAttr->Which();
         if ( ( nAttrWhich < EE_FEATURE_START ) && ( !nWhich || ( nAttrWhich == nWhich ) ) )
         {
@@ -1752,21 +1746,19 @@ sal_Bool EditDoc::RemoveAttribs( ContentNode* pNode, sal_uInt16 nStart, sal_uInt
         {
             DBG_ASSERT( ( pAttr != rpStarting ) && ( pAttr != rpEnding ), "Delete and retain the same attribute?" );
             DBG_ASSERT( !pAttr->IsFeature(), "RemoveAttribs: Remove a feature?!" );
-            pNode->GetCharAttribs().GetAttribs().Remove(nAttr);
             GetItemPool().Remove( *pAttr->GetItem() );
-            delete pAttr;
+            rAttribs.erase(rAttribs.begin()+nAttr);
             nAttr--;
         }
         nAttr++;
-        pAttr = GetAttrib( pNode->GetCharAttribs().GetAttribs(), nAttr );
+        pAttr = GetAttrib(rAttribs, nAttr);
     }
 
     if ( bChanged )
     {
         // char attributes need to be sorted by start again
         pNode->GetCharAttribs().ResortAttribs();
-
-        SetModified( sal_True );
+        SetModified(true);
     }
 
     return bChanged;
@@ -1796,8 +1788,7 @@ void EditDoc::InsertAttrib( ContentNode* pNode, sal_uInt16 nStart, sal_uInt16 nE
         if ( pAttr )
         {
             // Remove attribute....
-            pNode->GetCharAttribs().GetAttribs().Remove(
-                pNode->GetCharAttribs().GetAttribs().GetPos( pAttr ) );
+            pNode->GetCharAttribs().Remove(pAttr);
         }
 
         // check whether 'the same' attribute exist at this place.
@@ -1932,6 +1923,17 @@ void EditDoc::FindAttribs( ContentNode* pNode, sal_uInt16 nStartPos, sal_uInt16
     }
 }
 
+namespace {
+
+struct LessByStart : std::binary_function<EditCharAttrib, EditCharAttrib, bool>
+{
+    bool operator() (const EditCharAttrib& left, const EditCharAttrib& right) const
+    {
+        return left.GetStart() < right.GetStart();
+    }
+};
+
+}
 
 CharAttribList::CharAttribList()
 {
@@ -1942,16 +1944,6 @@ CharAttribList::CharAttribList()
 CharAttribList::~CharAttribList()
 {
     DBG_DTOR( EE_CharAttribList, 0 );
-
-    sal_uInt16 nAttr = 0;
-    EditCharAttrib* pAttr = GetAttrib( aAttribs, nAttr );
-    while ( pAttr )
-    {
-        delete pAttr;
-        ++nAttr;
-        pAttr = GetAttrib( aAttribs, nAttr );
-    }
-    Clear();
 }
 
 void CharAttribList::InsertAttrib( EditCharAttrib* pAttrib )
@@ -1965,61 +1957,48 @@ void CharAttribList::InsertAttrib( EditCharAttrib* pAttrib )
     // (InsertBinTextObject!) binary search would not be optimal here.
     // => Would bring something!
 
-    const sal_uInt16 nCount = Count();
     const sal_uInt16 nStart = pAttrib->GetStart(); // may be better for Comp.Opt.
 
     if ( pAttrib->IsEmpty() )
-        bHasEmptyAttribs = sal_True;
+        bHasEmptyAttribs = true;
 
-    sal_Bool bInserted = sal_False;
-    for ( sal_uInt16 x = 0; x < nCount; x++ )
+    for (size_t i = 0, n = aAttribs.size(); i < n; ++i)
     {
-        EditCharAttribPtr pCurAttrib = aAttribs[x];
-        if ( pCurAttrib->GetStart() > nStart )
+        const EditCharAttrib& rCurAttrib = aAttribs[i];
+        if (rCurAttrib.GetStart() > nStart)
         {
-            aAttribs.Insert( pAttrib, x );
-            bInserted = sal_True;
-            break;
+            aAttribs.insert(aAttribs.begin()+i, pAttrib);
+            return;
         }
     }
-    if ( !bInserted )
-        aAttribs.Insert( pAttrib, nCount );
+
+    aAttribs.push_back(pAttrib);
 }
 
 void CharAttribList::ResortAttribs()
 {
-    if ( Count() )
-    {
-#if defined __SUNPRO_CC
-#pragma disable_warn
-#endif
-        qsort( (void*)aAttribs.GetData(), aAttribs.Count(), sizeof( EditCharAttrib* ), CompareStart );
-#if defined __SUNPRO_CC
-#pragma enable_warn
-#endif
-    }
+    std::sort(aAttribs.begin(), aAttribs.end(), LessByStart());
 }
 
 void CharAttribList::OptimizeRanges( SfxItemPool& rItemPool )
 {
-    for ( sal_uInt16 n = 0; n < aAttribs.Count(); n++ )
+    for (size_t i = 0, n = aAttribs.size(); i < n; ++i)
     {
-        EditCharAttrib* pAttr = aAttribs.GetObject( n );
-        for ( sal_uInt16 nNext = n+1; nNext < aAttribs.Count(); nNext++ )
+        EditCharAttrib& rAttr = aAttribs[i];
+        for (size_t nNext = i+1; nNext < n; ++nNext)
         {
-            EditCharAttrib* p = aAttribs.GetObject( nNext );
-            if ( !pAttr->IsFeature() && ( p->GetStart() == pAttr->GetEnd() ) && ( p->Which() == pAttr->Which() ) )
+            EditCharAttrib& rNext = aAttribs[nNext];
+            if (!rAttr.IsFeature() && rNext.GetStart() == rAttr.GetEnd() && rNext.Which() == rAttr.Which())
             {
-                if ( *p->GetItem() == *pAttr->GetItem() )
+                if (*rNext.GetItem() == *rAttr.GetItem())
                 {
-                    pAttr->GetEnd() = p->GetEnd();
-                    aAttribs.Remove( nNext );
-                    rItemPool.Remove( *p->GetItem() );
-                    delete p;
+                    rAttr.GetEnd() = rNext.GetEnd();
+                    aAttribs.erase(aAttribs.begin()+nNext);
+                    rItemPool.Remove(*rNext.GetItem());
                 }
                 break;  // only 1 attr with same which can start here.
             }
-            else if ( p->GetStart() > pAttr->GetEnd() )
+            else if (rNext.GetStart() > rAttr.GetEnd())
             {
                 break;
             }
@@ -2027,131 +2006,199 @@ void CharAttribList::OptimizeRanges( SfxItemPool& rItemPool )
     }
 }
 
+size_t CharAttribList::Count() const
+{
+    return aAttribs.size();
+}
+
+void CharAttribList::Clear()
+{
+    aAttribs.clear();
+}
+
 EditCharAttrib* CharAttribList::FindAttrib( sal_uInt16 nWhich, sal_uInt16 nPos )
 {
     // Backwards, if one ends where the next starts.
     // => The starting one is the valid one ...
-    sal_uInt16 nAttr = aAttribs.Count()-1;
-    EditCharAttrib* pAttr = GetAttrib( aAttribs, nAttr );
-    while ( pAttr )
+    AttribsType::reverse_iterator it = aAttribs.rbegin(), itEnd = aAttribs.rend();
+    for (; it != itEnd; ++it)
     {
-        if ( ( pAttr->Which() == nWhich ) && pAttr->IsIn(nPos) )
-            return pAttr;
-        pAttr = GetAttrib( aAttribs, --nAttr );
+        EditCharAttrib& rAttr = *it;
+        if (rAttr.Which() == nWhich && rAttr.IsIn(nPos))
+            return &rAttr;
     }
-    return 0;
+    return NULL;
 }
 
-EditCharAttrib* CharAttribList::FindNextAttrib( sal_uInt16 nWhich, sal_uInt16 nFromPos ) const
+const EditCharAttrib* CharAttribList::FindNextAttrib( sal_uInt16 nWhich, sal_uInt16 nFromPos ) const
 {
     DBG_ASSERT( nWhich, "FindNextAttrib: Which?" );
-    const sal_uInt16 nAttribs = aAttribs.Count();
-    for ( sal_uInt16 nAttr = 0; nAttr < nAttribs; nAttr++ )
+    AttribsType::const_iterator it = aAttribs.begin(), itEnd = aAttribs.end();
+    for (; it != itEnd; ++it)
     {
-        EditCharAttrib* pAttr = aAttribs[ nAttr ];
-        if ( ( pAttr->GetStart() >= nFromPos ) && ( pAttr->Which() == nWhich ) )
-            return pAttr;
+        const EditCharAttrib& rAttr = *it;
+        if (rAttr.GetStart() >= nFromPos && rAttr.Which() == nWhich)
+            return &rAttr;
     }
-    return 0;
+    return NULL;
+}
+
+bool CharAttribList::HasAttrib( sal_uInt16 nStartPos, sal_uInt16 nEndPos ) const
+{
+    AttribsType::const_reverse_iterator it = aAttribs.rbegin(), itEnd = aAttribs.rend();
+    for (; it != itEnd; ++it)
+    {
+        const EditCharAttrib& rAttr = *it;
+        if (rAttr.GetStart() < nEndPos && rAttr.GetEnd() > nStartPos)
+            return true;
+    }
+    return false;
+}
+
+CharAttribList::AttribsType& CharAttribList::GetAttribs()
+{
+    return aAttribs;
 }
 
-sal_Bool CharAttribList::HasAttrib( sal_uInt16 nStartPos, sal_uInt16 nEndPos ) const
+const CharAttribList::AttribsType& CharAttribList::GetAttribs() const
 {
-    sal_Bool bAttr = sal_False;
-    for ( sal_uInt16 nAttr = aAttribs.Count(); nAttr && !bAttr; )
+    return aAttribs;
+}
+
+namespace {
+
+class FindByAddress : std::unary_function<EditCharAttrib, bool>
+{
+    const EditCharAttrib* mpAttr;
+public:
+    FindByAddress(const EditCharAttrib* p) : mpAttr(p) {}
+    bool operator() (const EditCharAttrib& r) const
     {
-        const EditCharAttrib* pAttr = aAttribs[--nAttr];
-        if ( ( pAttr->GetStart() < nEndPos ) && ( pAttr->GetEnd() > nStartPos ) )
-            return bAttr = sal_True;
+        return &r == mpAttr;
     }
-    return bAttr;
+};
+
+}
+
+void CharAttribList::Remove(const EditCharAttrib* p)
+{
+    AttribsType::iterator it = std::find_if(aAttribs.begin(), aAttribs.end(), FindByAddress(p));
+    if (it != aAttribs.end())
+        aAttribs.erase(it);
 }
 
+void CharAttribList::Remove(size_t nPos)
+{
+    if (nPos >= aAttribs.size())
+        return;
+
+    aAttribs.erase(aAttribs.begin()+nPos);
+}
+
+void CharAttribList::SetHasEmptyAttribs(bool b)
+{
+    bHasEmptyAttribs = b;
+}
 
-sal_Bool CharAttribList::HasBoundingAttrib( sal_uInt16 nBound )
+bool CharAttribList::HasBoundingAttrib( sal_uInt16 nBound ) const
 {
     // Backwards, if one ends where the next starts.
     // => The starting one is the valid one ...
-    sal_uInt16 nAttr = aAttribs.Count()-1;
-    EditCharAttrib* pAttr = GetAttrib( aAttribs, nAttr );
-    while ( pAttr && ( pAttr->GetEnd() >= nBound ) )
+    AttribsType::const_reverse_iterator it = aAttribs.rbegin(), itEnd = aAttribs.rend();
+    for (; it != itEnd; ++it)
     {
-        if ( ( pAttr->GetStart() == nBound ) || ( pAttr->GetEnd() == nBound ) )
-            return sal_True;
-        pAttr = GetAttrib( aAttribs, --nAttr );
+        const EditCharAttrib& rAttr = *it;
+        if (rAttr.GetEnd() < nBound)
+            return false;
+
+        if (rAttr.GetStart() == nBound || rAttr.GetEnd() == nBound)
+            return true;
     }
-    return sal_False;
+    return false;
 }
 
 EditCharAttrib* CharAttribList::FindEmptyAttrib( sal_uInt16 nWhich, sal_uInt16 nPos )
 {
     if ( !bHasEmptyAttribs )
-        return 0;
-    sal_uInt16 nAttr = 0;
-    EditCharAttrib* pAttr = GetAttrib( aAttribs, nAttr );
-    while ( pAttr && ( pAttr->GetStart() <= nPos ) )
+        return NULL;
+
+    AttribsType::iterator it = aAttribs.begin(), itEnd = aAttribs.end();
+    for (; it != itEnd; ++it)
     {
-        if ( ( pAttr->GetStart() == nPos ) && ( pAttr->GetEnd() == nPos ) && ( pAttr->Which() == nWhich ) )
-            return pAttr;
-        nAttr++;
-        pAttr = GetAttrib( aAttribs, nAttr );
+        EditCharAttrib& rAttr = *it;
+        if (rAttr.GetStart() == nPos && rAttr.GetEnd() == nPos && rAttr.Which() == nWhich)
+            return &rAttr;
     }
-    return 0;
+    return NULL;
 }
 
-EditCharAttrib* CharAttribList::FindFeature( sal_uInt16 nPos ) const
-{
-
-    sal_uInt16 nAttr = 0;
-    EditCharAttrib* pNextAttrib = GetAttrib( aAttribs, nAttr );
+namespace {
 
-    // first to the desired position ...
-    while ( pNextAttrib && ( pNextAttrib->GetStart() < nPos ) )
+class FindByStartPos : std::unary_function<EditCharAttrib, bool>
+{
+    sal_uInt16 mnPos;
+public:
+    FindByStartPos(sal_uInt16 nPos) : mnPos(nPos) {}
+    bool operator() (const EditCharAttrib& r) const
     {
-        nAttr++;
-        pNextAttrib = GetAttrib( aAttribs, nAttr );
+        return r.GetStart() >= mnPos;
     }
+};
 
-    // Now search for the Feature...
-    while ( pNextAttrib && !pNextAttrib->IsFeature() )
-    {
-        nAttr++;
-        pNextAttrib = GetAttrib( aAttribs, nAttr );
-    }
+}
+
+const EditCharAttrib* CharAttribList::FindFeature( sal_uInt16 nPos ) const
+{
+    // First, find the first attribute that starts at or after specified position.
+    AttribsType::const_iterator it =
+        std::find_if(aAttribs.begin(), aAttribs.end(), FindByStartPos(nPos));
 
-    return pNextAttrib;
+    if (it == aAttribs.end())
+        // All attributes are before the specified position.
+        return NULL;
+
+    // And find the first attribute with feature.
+    it = std::find_if(it, aAttribs.end(), boost::bind(&EditCharAttrib::IsFeature, _1) == true);
+    return it == aAttribs.end() ? NULL : &(*it);
 }
 
+namespace {
 
-void CharAttribList::DeleteEmptyAttribs( SfxItemPool& rItemPool )
+class RemoveEmptyAttrItem : std::unary_function<EditCharAttrib, void>
 {
-    for ( sal_uInt16 nAttr = 0; nAttr < aAttribs.Count(); nAttr++ )
+    SfxItemPool& mrItemPool;
+public:
+    RemoveEmptyAttrItem(SfxItemPool& rPool) : mrItemPool(rPool) {}
+    void operator() (const EditCharAttrib& r)
     {
-        EditCharAttrib* pAttr = aAttribs[nAttr];
-        if ( pAttr->IsEmpty() )
-        {
-            rItemPool.Remove( *pAttr->GetItem() );
-            aAttribs.Remove( nAttr );
-            delete pAttr;
-            nAttr--;
-        }
+        if (r.IsEmpty())
+            mrItemPool.Remove(*r.GetItem());
     }
-    bHasEmptyAttribs = sal_False;
+};
+
+}
+
+void CharAttribList::DeleteEmptyAttribs( SfxItemPool& rItemPool )
+{
+    std::for_each(aAttribs.begin(), aAttribs.end(), RemoveEmptyAttrItem(rItemPool));
+    aAttribs.erase_if(boost::bind(&EditCharAttrib::IsEmpty, _1) == true);
+    bHasEmptyAttribs = false;
 }
 
 #if OSL_DEBUG_LEVEL > 2
 bool CharAttribList::DbgCheckAttribs() const
 {
     bool bOK = true;
-    for ( sal_uInt16 nAttr = 0; nAttr < aAttribs.Count(); nAttr++ )
+    AttribsType::const_iterator it = aAttribs.begin(), itEnd = aAttribs.end();
+    for (; it != itEnd; ++it)
     {
-        const EditCharAttrib* pAttr = aAttribs[nAttr];
-        if ( pAttr->GetStart() > pAttr->GetEnd() )
+        const EditCharAttrib& rAttr = *it;
+        if (rAttr.GetStart() > rAttr.GetEnd())
         {
             bOK = false;
             OSL_FAIL( "Attribute is distorted" );
         }
-        else if ( pAttr->IsFeature() && ( pAttr->GetLen() != 1 ) )
+        else if (rAttr.IsFeature() && rAttr.GetLen() != 1)
         {
             bOK = false;
             OSL_FAIL( "Feature, Len != 1" );
diff --git a/editeng/source/editeng/editdoc.hxx b/editeng/source/editeng/editdoc.hxx
index e9b196cc5cea..7ddaa392c2f8 100644
--- a/editeng/source/editeng/editdoc.hxx
+++ b/editeng/source/editeng/editdoc.hxx
@@ -208,10 +208,13 @@ public:
 // -------------------------------------------------------------------------
 class CharAttribList
 {
+public:
+    typedef boost::ptr_vector<EditCharAttrib> AttribsType;
+
 private:
-    CharAttribArray aAttribs;
+    AttribsType     aAttribs;
     SvxFont         aDefFont;          // faster than ever from the pool!
-    sal_Bool        bHasEmptyAttribs;
+    bool            bHasEmptyAttribs;
 
                     CharAttribList( const CharAttribList& ) {;}
 
@@ -223,27 +226,32 @@ public:
     void            RemoveItemsFromPool( SfxItemPool* pItemPool );
 
     EditCharAttrib* FindAttrib( sal_uInt16 nWhich, sal_uInt16 nPos );
-    EditCharAttrib* FindNextAttrib( sal_uInt16 nWhich, sal_uInt16 nFromPos ) const;
+    const EditCharAttrib* FindNextAttrib( sal_uInt16 nWhich, sal_uInt16 nFromPos ) const;
     EditCharAttrib* FindEmptyAttrib( sal_uInt16 nWhich, sal_uInt16 nPos );
-    EditCharAttrib* FindFeature( sal_uInt16 nPos ) const;
+    const EditCharAttrib* FindFeature( sal_uInt16 nPos ) const;
 
 
     void            ResortAttribs();
     void            OptimizeRanges( SfxItemPool& rItemPool );
 
-    sal_uInt16          Count()                 { return aAttribs.Count(); }
-    void            Clear()                 { aAttribs.Remove( 0, aAttribs.Count()); }
+    size_t Count() const;
+    void Clear();
+
     void            InsertAttrib( EditCharAttrib* pAttrib );
 
     SvxFont&        GetDefFont()            { return aDefFont; }
 
-    sal_Bool            HasEmptyAttribs() const { return bHasEmptyAttribs; }
-    sal_Bool&           HasEmptyAttribs()       { return bHasEmptyAttribs; }
-    sal_Bool            HasBoundingAttrib( sal_uInt16 nBound );
-    sal_Bool            HasAttrib( sal_uInt16 nStartPos, sal_uInt16 nEndPos ) const;
+    bool            HasEmptyAttribs() const { return bHasEmptyAttribs; }
+    void SetHasEmptyAttribs(bool b);
+    bool HasBoundingAttrib( sal_uInt16 nBound ) const;
+    bool HasAttrib( sal_uInt16 nStartPos, sal_uInt16 nEndPos ) const;
+
+    AttribsType& GetAttribs();
+    const AttribsType& GetAttribs() const;
+
+    void Remove(const EditCharAttrib* p);
+    void Remove(size_t nPos);
 
-    CharAttribArray&        GetAttribs()        { return aAttribs; }
-    const CharAttribArray&  GetAttribs() const  { return aAttribs; }
 #if OSL_DEBUG_LEVEL > 2
     // Debug:
     bool DbgCheckAttribs() const;
@@ -788,9 +796,9 @@ inline EditPaM EditDoc::GetEndPaM() const
     return EditPaM( pLastNode, pLastNode->Len() );
 }
 
-inline EditCharAttrib* GetAttrib( const CharAttribArray& rAttribs, sal_uInt16 nAttr )
+inline EditCharAttrib* GetAttrib(CharAttribList::AttribsType& rAttribs, size_t nAttr)
 {
-    return ( nAttr < rAttribs.Count() ) ? rAttribs[nAttr] : 0;
+    return (nAttr < rAttribs.size()) ? &rAttribs[nAttr] : NULL;
 }
 
 sal_Bool CheckOrderedList( CharAttribArray& rAttribs, sal_Bool bStart );
diff --git a/editeng/source/editeng/editeng.cxx b/editeng/source/editeng/editeng.cxx
index 2964ad4b0d47..0954d51195bb 100644
--- a/editeng/source/editeng/editeng.cxx
+++ b/editeng/source/editeng/editeng.cxx
@@ -2043,12 +2043,12 @@ sal_uInt16 EditEngine::GetFieldCount( sal_uInt16 nPara ) const
     ContentNode* pNode = pImpEditEngine->GetEditDoc().SaveGetObject( nPara );
     if ( pNode )
     {
-        const CharAttribArray& rAttrs = pNode->GetCharAttribs().GetAttribs();
-        for ( sal_uInt16 nAttr = 0; nAttr < rAttrs.Count(); nAttr++ )
+        const CharAttribList::AttribsType& rAttrs = pNode->GetCharAttribs().GetAttribs();
+        CharAttribList::AttribsType::const_iterator it = rAttrs.begin(), itEnd = rAttrs.end();
+        for (; it != itEnd; ++it)
         {
-            EditCharAttrib* pAttr = rAttrs[nAttr];
-            if ( pAttr->Which() == EE_FEATURE_FIELD )
-                nFields++;
+            if (it->Which() == EE_FEATURE_FIELD)
+                ++nFields;
         }
     }
 
@@ -2061,20 +2061,22 @@ EFieldInfo EditEngine::GetFieldInfo( sal_uInt16 nPara, sal_uInt16 nField ) const
     if ( pNode )
     {
         sal_uInt16 nCurrentField = 0;
-        const CharAttribArray& rAttrs = pNode->GetCharAttribs().GetAttribs();
-        for ( sal_uInt16 nAttr = 0; nAttr < rAttrs.Count(); nAttr++ )
+        const CharAttribList::AttribsType& rAttrs = pNode->GetCharAttribs().GetAttribs();
+        CharAttribList::AttribsType::const_iterator it = rAttrs.begin(), itEnd = rAttrs.end();
+        for (; it != itEnd; ++it)
         {
-            EditCharAttrib* pAttr = rAttrs[nAttr];
-            if ( pAttr->Which() == EE_FEATURE_FIELD )
+            const EditCharAttrib& rAttr = *it;
+            if (rAttr.Which() == EE_FEATURE_FIELD)
             {
                 if ( nCurrentField == nField )
                 {
-                    EFieldInfo aInfo( *(const SvxFieldItem*)pAttr->GetItem(), nPara, pAttr->GetStart() );
-                    aInfo.aCurrentText = ((EditCharAttribField*)pAttr)->GetFieldValue();
+                    const SvxFieldItem* p = static_cast<const SvxFieldItem*>(rAttr.GetItem());
+                    EFieldInfo aInfo(*p, nPara, rAttr.GetStart());
+                    aInfo.aCurrentText = static_cast<const EditCharAttribField&>(rAttr).GetFieldValue();
                     return aInfo;
                 }
 
-                nCurrentField++;
+                ++nCurrentField;
             }
         }
     }
@@ -2102,18 +2104,18 @@ void EditEngine::RemoveFields( sal_Bool bKeepFieldText, TypeId aType )
     for ( sal_uInt16 nPara = 0; nPara < nParas; nPara++  )
     {
         ContentNode* pNode = pImpEditEngine->GetEditDoc().GetObject( nPara );
-        const CharAttribArray& rAttrs = pNode->GetCharAttribs().GetAttribs();
-        for ( sal_uInt16 nAttr = rAttrs.Count(); nAttr; )
+        const CharAttribList::AttribsType& rAttrs = pNode->GetCharAttribs().GetAttribs();
+        for (size_t nAttr = rAttrs.size(); nAttr; )
         {
-            const EditCharAttrib* pAttr = rAttrs[--nAttr];
-            if ( pAttr->Which() == EE_FEATURE_FIELD )
+            const EditCharAttrib& rAttr = rAttrs[--nAttr];
+            if (rAttr.Which() == EE_FEATURE_FIELD)
             {
-                const SvxFieldData* pFldData = ((const SvxFieldItem*)pAttr->GetItem())->GetField();
+                const SvxFieldData* pFldData = static_cast<const SvxFieldItem*>(rAttr.GetItem())->GetField();
                 if ( pFldData && ( !aType || ( pFldData->IsA( aType ) ) ) )
                 {
-                    DBG_ASSERT( pAttr->GetItem()->ISA( SvxFieldItem ), "no field item..." );
-                    EditSelection aSel( EditPaM( pNode, pAttr->GetStart() ), EditPaM( pNode, pAttr->GetEnd() ) );
-                    String aFieldText = ((EditCharAttribField*)pAttr)->GetFieldValue();
+                    DBG_ASSERT( rAttr->GetItem()->ISA( SvxFieldItem ), "no field item..." );
+                    EditSelection aSel( EditPaM(pNode, rAttr.GetStart()), EditPaM(pNode, rAttr.GetEnd()) );
+                    String aFieldText = static_cast<const EditCharAttribField&>(rAttr).GetFieldValue();
                     pImpEditEngine->ImpInsertText( aSel, aFieldText );
                 }
             }
diff --git a/editeng/source/editeng/editview.cxx b/editeng/source/editeng/editview.cxx
index bff5f04f4af1..b7dfee803481 100644
--- a/editeng/source/editeng/editview.cxx
+++ b/editeng/source/editeng/editview.cxx
@@ -1225,16 +1225,16 @@ const SvxFieldItem* EditView::GetFieldAtSelection() const
            ( aSel.Max().GetIndex() == aSel.Min().GetIndex()+1 ) ) )
     {
         EditPaM aPaM = aSel.Min();
-        const CharAttribArray& rAttrs = aPaM.GetNode()->GetCharAttribs().GetAttribs();
+        const CharAttribList::AttribsType& rAttrs = aPaM.GetNode()->GetCharAttribs().GetAttribs();
         sal_uInt16 nXPos = aPaM.GetIndex();
-        for ( sal_uInt16 nAttr = rAttrs.Count(); nAttr; )
+        for (size_t nAttr = rAttrs.size(); nAttr; )
         {
-            EditCharAttrib* pAttr = rAttrs[--nAttr];
-            if ( pAttr->GetStart() == nXPos )
-                if ( pAttr->Which() == EE_FEATURE_FIELD )
+            const EditCharAttrib& rAttr = rAttrs[--nAttr];
+            if (rAttr.GetStart() == nXPos)
+                if (rAttr.Which() == EE_FEATURE_FIELD)
                 {
-                    DBG_ASSERT( pAttr->GetItem()->ISA( SvxFieldItem ), "No FeldItem..." );
-                    return (const SvxFieldItem*)pAttr->GetItem();
+                    DBG_ASSERT(rAttr.GetItem()->ISA( SvxFieldItem ), "No FeldItem...");
+                    return static_cast<const SvxFieldItem*>(rAttr.GetItem());
                 }
         }
     }
diff --git a/editeng/source/editeng/edtspell.cxx b/editeng/source/editeng/edtspell.cxx
index b3c9dbb70637..0dcea4f9ae78 100644
--- a/editeng/source/editeng/edtspell.cxx
+++ b/editeng/source/editeng/edtspell.cxx
@@ -694,23 +694,23 @@ sal_Bool EdtAutoCorrDoc::HasSymbolChars( sal_uInt16 nStt, sal_uInt16 nEnd )
     sal_uInt16 nScriptType = pImpEE->GetScriptType( EditPaM( pCurNode, nStt ) );
     sal_uInt16 nScriptFontInfoItemId = GetScriptItemId( EE_CHAR_FONTINFO, nScriptType );
 
-    CharAttribArray& rAttribs = pCurNode->GetCharAttribs().GetAttribs();
-    sal_uInt16 nAttrs = rAttribs.Count();
-    for ( sal_uInt16 n = 0; n < nAttrs; n++ )
+    const CharAttribList::AttribsType& rAttribs = pCurNode->GetCharAttribs().GetAttribs();
+    CharAttribList::AttribsType::const_iterator it = rAttribs.begin(), itEnd = rAttribs.end();
+    for (; it != itEnd; ++it)
     {
-        EditCharAttrib* pAttr = rAttribs.GetObject( n );
-        if ( pAttr->GetStart() >= nEnd )
-            return sal_False;
+        const EditCharAttrib& rAttr = *it;
+        if (rAttr.GetStart() >= nEnd)
+            return false;
 
-        if ( ( pAttr->Which() == nScriptFontInfoItemId ) &&
-                ( ((SvxFontItem*)pAttr->GetItem())->GetCharSet() == RTL_TEXTENCODING_SYMBOL ) )
+        if (rAttr.Which() == nScriptFontInfoItemId &&
+            static_cast<const SvxFontItem*>(rAttr.GetItem())->GetCharSet() == RTL_TEXTENCODING_SYMBOL)
         {
             // check if the Attribtuteis within range...
-            if ( pAttr->GetEnd() >= nStt )
-                return sal_True;
+            if (rAttr.GetEnd() >= nStt)
+                return true;
         }
     }
-    return sal_False;
+    return false;
 }
 
 const String* EdtAutoCorrDoc::GetPrevPara( sal_Bool )
diff --git a/editeng/source/editeng/impedit.cxx b/editeng/source/editeng/impedit.cxx
index c5a3f5d4bbd6..f63ab6aa1dce 100644
--- a/editeng/source/editeng/impedit.cxx
+++ b/editeng/source/editeng/impedit.cxx
@@ -1181,21 +1181,23 @@ const SvxFieldItem* ImpEditView::GetField( const Point& rPos, sal_uInt16* pPara,
         return 0;
     }
 
-    const CharAttribArray& rAttrs = aPaM.GetNode()->GetCharAttribs().GetAttribs();
+    const CharAttribList::AttribsType& rAttrs = aPaM.GetNode()->GetCharAttribs().GetAttribs();
     sal_uInt16 nXPos = aPaM.GetIndex();
-    for ( sal_uInt16 nAttr = rAttrs.Count(); nAttr; )
+    for (size_t nAttr = rAttrs.size(); nAttr; )
     {
-        EditCharAttrib* pAttr = rAttrs[--nAttr];
-        if ( pAttr->GetStart() == nXPos )
-            if ( pAttr->Which() == EE_FEATURE_FIELD )
+        const EditCharAttrib& rAttr = rAttrs[--nAttr];
+        if (rAttr.GetStart() == nXPos)
+        {
+            if (rAttr.Which() == EE_FEATURE_FIELD)
             {
-                DBG_ASSERT( pAttr->GetItem()->ISA( SvxFieldItem ), "No FieldItem..." );
+                DBG_ASSERT(dynamic_cast<const SvxFieldItem*>(rAttr.GetItem()), "No FieldItem...");
                 if ( pPara )
                     *pPara = pEditEngine->pImpEditEngine->GetEditDoc().GetPos( aPaM.GetNode() );
                 if ( pPos )
-                    *pPos = pAttr->GetStart();
-                return (const SvxFieldItem*)pAttr->GetItem();
+                    *pPos = rAttr.GetStart();
+                return static_cast<const SvxFieldItem*>(rAttr.GetItem());
             }
+        }
     }
     return NULL;
 }
diff --git a/editeng/source/editeng/impedit2.cxx b/editeng/source/editeng/impedit2.cxx
index 80f2710b050d..8d0c04c96ac7 100644
--- a/editeng/source/editeng/impedit2.cxx
+++ b/editeng/source/editeng/impedit2.cxx
@@ -73,6 +73,8 @@
 
 #include <unicode/ubidi.h>
 
+#include <boost/scoped_ptr.hpp>
+
 using namespace ::com::sun::star;
 
 sal_uInt16 lcl_CalcExtraSpace( ParaPortion*, const SvxLineSpacingItem& rLSItem )
@@ -1404,7 +1406,7 @@ EditPaM ImpEditEngine::CursorEndOfLine( const EditPaM& rPaM )
         if ( aNewPaM.GetNode()->IsFeature( aNewPaM.GetIndex() - 1 ) )
         {
             // When a soft break, be in front of it!
-            EditCharAttrib* pNextFeature = aNewPaM.GetNode()->GetCharAttribs().FindFeature( aNewPaM.GetIndex()-1 );
+            const EditCharAttrib* pNextFeature = aNewPaM.GetNode()->GetCharAttribs().FindFeature( aNewPaM.GetIndex()-1 );
             if ( pNextFeature && ( pNextFeature->GetItem()->Which() == EE_FEATURE_LINEBR ) )
                 aNewPaM = CursorLeft( aNewPaM );
         }
@@ -1685,10 +1687,10 @@ void ImpEditEngine::InitScriptTypes( sal_uInt16 nPara )
 
         // To handle fields put the character from the field in the string,
         // because endOfScript( ... ) will skip the CH_FEATURE, because this is WEAK
-        EditCharAttrib* pField = pNode->GetCharAttribs().FindNextAttrib( EE_FEATURE_FIELD, 0 );
+        const EditCharAttrib* pField = pNode->GetCharAttribs().FindNextAttrib( EE_FEATURE_FIELD, 0 );
         while ( pField )
         {
-            ::rtl::OUString aFldText( ((EditCharAttribField*)pField)->GetFieldValue() );
+            rtl::OUString aFldText = static_cast<const EditCharAttribField*>(pField)->GetFieldValue();
             if ( !aFldText.isEmpty() )
             {
                 aText.SetChar( pField->GetStart(), aFldText.getStr()[0] );
@@ -2102,11 +2104,11 @@ void ImpEditEngine::ImpRemoveChars( const EditPaM& rPaM, sal_uInt16 nChars, Edit
         // Check whether attributes are deleted or changed:
         sal_uInt16 nStart = rPaM.GetIndex();
         sal_uInt16 nEnd = nStart + nChars;
-        CharAttribArray& rAttribs = rPaM.GetNode()->GetCharAttribs().GetAttribs();
-        for ( sal_uInt16 nAttr = 0; nAttr < rAttribs.Count(); nAttr++ )
+        const CharAttribList::AttribsType& rAttribs = rPaM.GetNode()->GetCharAttribs().GetAttribs();
+        for (size_t i = 0, n = rAttribs.size(); i < n; ++i)
         {
-            EditCharAttrib* pAttr = rAttribs[nAttr];
-            if ( ( pAttr->GetEnd() >= nStart ) && ( pAttr->GetStart() < nEnd ) )
+            const EditCharAttrib& rAttr = rAttribs[i];
+            if (rAttr.GetEnd() >= nStart && rAttr.GetStart() < nEnd)
             {
                 EditSelection aSel( rPaM );
                 aSel.Max().GetIndex() = aSel.Max().GetIndex() + nChars;
@@ -2964,37 +2966,37 @@ EditPaM ImpEditEngine::InsertField( EditSelection aCurSel, const SvxFieldItem& r
 
 sal_Bool ImpEditEngine::UpdateFields()
 {
-    sal_Bool bChanges = sal_False;
+    bool bChanges = false;
     sal_uInt16 nParas = GetEditDoc().Count();
     for ( sal_uInt16 nPara = 0; nPara < nParas; nPara++ )
     {
-        sal_Bool bChangesInPara = sal_False;
+        bool bChangesInPara = false;
         ContentNode* pNode = GetEditDoc().GetObject( nPara );
         OSL_ENSURE( pNode, "NULL-Pointer in Doc" );
-        CharAttribArray& rAttribs = pNode->GetCharAttribs().GetAttribs();
-        for ( sal_uInt16 nAttr = 0; nAttr < rAttribs.Count(); nAttr++ )
+        CharAttribList::AttribsType& rAttribs = pNode->GetCharAttribs().GetAttribs();
+        for (size_t nAttr = 0; nAttr < rAttribs.size(); ++nAttr)
         {
-            EditCharAttrib* pAttr = rAttribs[nAttr];
-            if ( pAttr->Which() == EE_FEATURE_FIELD )
+            EditCharAttrib& rAttr = rAttribs[nAttr];
+            if (rAttr.Which() == EE_FEATURE_FIELD)
             {
-                EditCharAttribField* pField = (EditCharAttribField*)pAttr;
-                EditCharAttribField* pCurrent = new EditCharAttribField( *pField );
-                pField->Reset();
+                EditCharAttribField& rField = static_cast<EditCharAttribField&>(rAttr);
+                boost::scoped_ptr<EditCharAttribField> pCurrent(new EditCharAttribField(rField));
+                rField.Reset();
 
                 if ( aStatus.MarkFields() )
-                    pField->GetFldColor() = new Color( GetColorConfig().GetColorValue( svtools::WRITERFIELDSHADINGS ).nColor );
-
-                XubString aFldValue = GetEditEnginePtr()->CalcFieldValue(
-                                        (const SvxFieldItem&)*pField->GetItem(),
-                                        nPara, pField->GetStart(),
-                                        pField->GetTxtColor(), pField->GetFldColor() );
-                pField->GetFieldValue() = aFldValue;
-                if ( *pField != *pCurrent )
+                    rField.GetFldColor() = new Color( GetColorConfig().GetColorValue( svtools::WRITERFIELDSHADINGS ).nColor );
+
+                rtl::OUString aFldValue =
+                    GetEditEnginePtr()->CalcFieldValue(
+                        static_cast<const SvxFieldItem&>(*rField.GetItem()),
+                        nPara, rField.GetStart(), rField.GetTxtColor(), rField.GetFldColor());
+
+                rField.GetFieldValue() = aFldValue;
+                if (rField != *pCurrent)
                 {
-                    bChanges = sal_True;
-                    bChangesInPara = sal_True;
+                    bChanges = true;
+                    bChangesInPara = true;
                 }
-                delete pCurrent;
             }
         }
         if ( bChangesInPara )
@@ -4310,7 +4312,7 @@ void ImpEditEngine::IndentBlock( EditView* pEditView, sal_Bool bRight )
             else
             {
                 // Remove Tabs
-                EditCharAttrib* pFeature = pNode->GetCharAttribs().FindFeature( 0 );
+                const EditCharAttrib* pFeature = pNode->GetCharAttribs().FindFeature( 0 );
                 if ( pFeature && ( pFeature->GetStart() == 0 ) &&
                    ( pFeature->GetItem()->Which() == EE_FEATURE_TAB ) )
                 {
diff --git a/editeng/source/editeng/impedit3.cxx b/editeng/source/editeng/impedit3.cxx
index a7919a2c7a57..110d5fbf380f 100644
--- a/editeng/source/editeng/impedit3.cxx
+++ b/editeng/source/editeng/impedit3.cxx
@@ -889,7 +889,7 @@ sal_Bool ImpEditEngine::CreateLines( sal_uInt16 nPara, sal_uInt32 nStartPosY )
         TextPortion* pPortion = 0;
         sal_Bool bBrokenLine = sal_False;
         bLineBreak = sal_False;
-        EditCharAttrib* pNextFeature = pNode->GetCharAttribs().FindFeature( pLine->GetStart() );
+        const EditCharAttrib* pNextFeature = pNode->GetCharAttribs().FindFeature( pLine->GetStart() );
         while ( ( nTmpWidth < nXWidth ) && !bEOL && ( nTmpPortion < pParaPortion->GetTextPortions().Count() ) )
         {
             nPortionStart = nTmpPos;
@@ -1734,13 +1734,13 @@ void ImpEditEngine::ImpBreakLine( ParaPortion* pParaPortion, EditLine* pLine, Te
     else
     {
         sal_uInt16 nMinBreakPos = pLine->GetStart();
-        sal_uInt16 nAttrs = pNode->GetCharAttribs().GetAttribs().Count();
-        for ( sal_uInt16 nAttr = nAttrs; nAttr; )
+        const CharAttribList::AttribsType& rAttrs = pNode->GetCharAttribs().GetAttribs();
+        for (size_t nAttr = rAttrs.size(); nAttr; )
         {
-            EditCharAttrib* pAttr = pNode->GetCharAttribs().GetAttribs()[--nAttr];
-            if ( pAttr->IsFeature() && ( pAttr->GetEnd() > nMinBreakPos ) && ( pAttr->GetEnd() <= nMaxBreakPos ) )
+            const EditCharAttrib& rAttr = rAttrs[--nAttr];
+            if (rAttr.IsFeature() && rAttr.GetEnd() > nMinBreakPos && rAttr.GetEnd() <= nMaxBreakPos)
             {
-                nMinBreakPos = pAttr->GetEnd();
+                nMinBreakPos = rAttr.GetEnd();
                 break;
             }
         }
@@ -2563,9 +2563,9 @@ void ImpEditEngine::SeekCursor( ContentNode* pNode, sal_uInt16 nPos, SvxFont& rF
 
     if ( aStatus.UseCharAttribs() )
     {
-        const CharAttribArray& rAttribs = pNode->GetCharAttribs().GetAttribs();
-        sal_uInt16 nAttr = 0;
-        EditCharAttrib* pAttrib = GetAttrib( rAttribs, nAttr );
+        CharAttribList::AttribsType& rAttribs = pNode->GetCharAttribs().GetAttribs();
+        size_t nAttr = 0;
+        EditCharAttrib* pAttrib = GetAttrib(rAttribs, nAttr);
         while ( pAttrib && ( pAttrib->GetStart() <= nPos ) )
         {
             // when seeking, ignore attributes which start there! Empty attributes
@@ -3078,7 +3078,7 @@ void ImpEditEngine::Paint( OutputDevice* pOutDev, Rectangle aClipRec, Point aSta
                                 }
                                 else if ( pTextPortion->GetKind() == PORTIONKIND_FIELD )
                                 {
-                                    EditCharAttrib* pAttr = pPortion->GetNode()->GetCharAttribs().FindFeature( nIndex );
+                                    const EditCharAttrib* pAttr = pPortion->GetNode()->GetCharAttribs().FindFeature(nIndex);
                                     DBG_ASSERT( pAttr, "Field not found");
                                     DBG_ASSERT( pAttr && pAttr->GetItem()->ISA( SvxFieldItem ), "Field of the wrong type! ");
                                     aText = ((EditCharAttribField*)pAttr)->GetFieldValue();
@@ -3096,7 +3096,7 @@ void ImpEditEngine::Paint( OutputDevice* pOutDev, Rectangle aClipRec, Point aSta
                                     // add a meta file comment if we record to a metafile
                                     if( bMetafileValid )
                                     {
-                                        SvxFieldItem* pFieldItem = PTR_CAST( SvxFieldItem, pAttr->GetItem() );
+                                        const SvxFieldItem* pFieldItem = dynamic_cast<const SvxFieldItem*>(pAttr->GetItem());
                                         if( pFieldItem )
                                         {
                                             const SvxFieldData* pFieldData = pFieldItem->GetField();
@@ -3187,8 +3187,8 @@ void ImpEditEngine::Paint( OutputDevice* pOutDev, Rectangle aClipRec, Point aSta
 
                                     if(PORTIONKIND_FIELD == pTextPortion->GetKind())
                                     {
-                                        EditCharAttrib* pAttr = pPortion->GetNode()->GetCharAttribs().FindFeature(nIndex);
-                                        SvxFieldItem* pFieldItem = PTR_CAST(SvxFieldItem, pAttr->GetItem());
+                                        const EditCharAttrib* pAttr = pPortion->GetNode()->GetCharAttribs().FindFeature(nIndex);
+                                        const SvxFieldItem* pFieldItem = dynamic_cast<const SvxFieldItem*>(pAttr->GetItem());
 
                                         if(pFieldItem)
                                         {
@@ -3335,8 +3335,8 @@ void ImpEditEngine::Paint( OutputDevice* pOutDev, Rectangle aClipRec, Point aSta
                                         {
                                             if ( pTextPortion->GetKind() == PORTIONKIND_FIELD )
                                             {
-                                                EditCharAttrib* pAttr = pPortion->GetNode()->GetCharAttribs().FindFeature( nIndex );
-                                                SvxFieldItem* pFieldItem = PTR_CAST( SvxFieldItem, pAttr->GetItem() );
+                                                const EditCharAttrib* pAttr = pPortion->GetNode()->GetCharAttribs().FindFeature(nIndex);
+                                                const SvxFieldItem* pFieldItem = dynamic_cast<const SvxFieldItem*>(pAttr->GetItem());
                                                 if( pFieldItem )
                                                 {
                                                     const SvxFieldData* pFieldData = pFieldItem->GetField();
@@ -3344,8 +3344,6 @@ void ImpEditEngine::Paint( OutputDevice* pOutDev, Rectangle aClipRec, Point aSta
                                                     {
                                                         Point aTopLeft( aTmpPos );
                                                         aTopLeft.Y() -= pLine->GetMaxAscent();
-//                                                      if ( nOrientation )
-//                                                          aTopLeft = lcl_ImplCalcRotatedPos( aTopLeft, aOrigin, nSin, nCos );
 
                                                         Rectangle aRect( aTopLeft, pTextPortion->GetSize() );
                                                         vcl::PDFExtOutDevBookmarkEntry aBookmark;
@@ -3386,14 +3384,14 @@ void ImpEditEngine::Paint( OutputDevice* pOutDev, Rectangle aClipRec, Point aSta
 
                                 if ( pTextPortion->GetKind() == PORTIONKIND_FIELD )
                                 {
-                                    EditCharAttrib* pAttr = pPortion->GetNode()->GetCharAttribs().FindFeature( nIndex );
+                                    const EditCharAttrib* pAttr = pPortion->GetNode()->GetCharAttribs().FindFeature(nIndex);
                                     DBG_ASSERT( pAttr, "Field not found" );
                                     DBG_ASSERT( pAttr && pAttr->GetItem()->ISA( SvxFieldItem ), "Wrong type of field!" );
 
                                     // add a meta file comment if we record to a metafile
                                     if( bMetafileValid )
                                     {
-                                        SvxFieldItem* pFieldItem = PTR_CAST( SvxFieldItem, pAttr->GetItem() );
+                                        const SvxFieldItem* pFieldItem = dynamic_cast<const SvxFieldItem*>(pAttr->GetItem());
 
                                         if( pFieldItem )
                                         {
diff --git a/editeng/source/editeng/impedit4.cxx b/editeng/source/editeng/impedit4.cxx
index 5a23d6236fc3..405a4d086f9c 100644
--- a/editeng/source/editeng/impedit4.cxx
+++ b/editeng/source/editeng/impedit4.cxx
@@ -627,7 +627,7 @@ sal_uInt32 ImpEditEngine::WriteRTF( SvStream& rOutput, EditSelection aSel )
             nEndPortion = pParaPortion->GetTextPortions().FindPortion( nEndPos, nPortionStart );
         }
 
-        EditCharAttrib* pNextFeature = pNode->GetCharAttribs().FindFeature( nIndex );
+        const EditCharAttrib* pNextFeature = pNode->GetCharAttribs().FindFeature(nIndex);
         // start at 0, so the index is right ...
         for ( sal_uInt16 n = 0; n <= nEndPortion; n++ )
         {
@@ -2060,7 +2060,7 @@ void ImpEditEngine::AddPortionIterated(
                 //determine whether a field and has been reached
                 bIsEndField = nEndField == aCursor.GetIndex();
                 //search for a new field attribute
-                EditCharAttrib* _pFieldAttr = aCursor.GetNode()->GetCharAttribs().
+                const EditCharAttrib* _pFieldAttr = aCursor.GetNode()->GetCharAttribs().
                                                         FindFeature( aCursor.GetIndex() );
                 bIsField = _pFieldAttr &&
                         _pFieldAttr->GetStart() == aCursor.GetIndex() &&
diff --git a/editeng/source/editeng/impedit5.cxx b/editeng/source/editeng/impedit5.cxx
index d99e30550fe3..02b39a6d104a 100644
--- a/editeng/source/editeng/impedit5.cxx
+++ b/editeng/source/editeng/impedit5.cxx
@@ -217,10 +217,10 @@ EditUndoSetAttribs* ImpEditEngine::CreateAttribUndo( EditSelection aSel, const S
 
         for ( sal_uInt16 nAttr = 0; nAttr < pNode->GetCharAttribs().Count(); nAttr++ )
         {
-            EditCharAttribPtr pAttr = pNode->GetCharAttribs().GetAttribs()[ nAttr ];
-            if ( pAttr->GetLen() )
+            const EditCharAttrib& rAttr = pNode->GetCharAttribs().GetAttribs()[nAttr];
+            if (rAttr.GetLen())
             {
-                EditCharAttribPtr pNew = MakeCharAttrib( *pPool, *pAttr->GetItem(), pAttr->GetStart(), pAttr->GetEnd() );
+                EditCharAttrib* pNew = MakeCharAttrib(*pPool, *rAttr.GetItem(), rAttr.GetStart(), rAttr.GetEnd());
                 pInf->GetPrevCharAttribs().Insert( pNew, pInf->GetPrevCharAttribs().Count() );
             }
         }
@@ -438,50 +438,50 @@ SfxItemSet ImpEditEngine::GetAttribs( sal_uInt16 nPara, sal_uInt16 nStart, sal_u
             // Make testing easier...
             pNode->GetCharAttribs().OptimizeRanges( ((ImpEditEngine*)this)->GetEditDoc().GetItemPool() );
 
-            const CharAttribArray& rAttrs = pNode->GetCharAttribs().GetAttribs();
-            for ( sal_uInt16 nAttr = 0; nAttr < rAttrs.Count(); nAttr++ )
+            const CharAttribList::AttribsType& rAttrs = pNode->GetCharAttribs().GetAttribs();
+            for (size_t nAttr = 0; nAttr < rAttrs.size(); ++nAttr)
             {
-                EditCharAttrib* pAttr = rAttrs.GetObject( nAttr );
+                const EditCharAttrib& rAttr = rAttrs[nAttr];
 
                 if ( nStart == nEnd )
                 {
                     sal_uInt16 nCursorPos = nStart;
-                    if ( ( pAttr->GetStart() <= nCursorPos ) && ( pAttr->GetEnd() >= nCursorPos ) )
+                    if ( ( rAttr.GetStart() <= nCursorPos ) && ( rAttr.GetEnd() >= nCursorPos ) )
                     {
                         // To be used the attribute has to start BEFORE the position, or it must be a
                         // new empty attr AT the position, or we are on position 0.
-                        if ( ( pAttr->GetStart() < nCursorPos ) || pAttr->IsEmpty() || !nCursorPos )
+                        if ( ( rAttr.GetStart() < nCursorPos ) || rAttr.IsEmpty() || !nCursorPos )
                         {
                             // maybe this attrib ends here and a new attrib with 0 Len may follow and be valid here,
                             // but that s no problem, the empty item will come later and win.
-                            aAttribs.Put( *pAttr->GetItem() );
+                            aAttribs.Put( *rAttr.GetItem() );
                         }
                     }
                 }
                 else
                 {
                     // Check every attribute covering the area, partial or full.
-                    if ( ( pAttr->GetStart() < nEnd ) && ( pAttr->GetEnd() > nStart ) )
+                    if ( ( rAttr.GetStart() < nEnd ) && ( rAttr.GetEnd() > nStart ) )
                     {
-                        if ( ( pAttr->GetStart() <= nStart ) && ( pAttr->GetEnd() >= nEnd ) )
+                        if ( ( rAttr.GetStart() <= nStart ) && ( rAttr.GetEnd() >= nEnd ) )
                         {
                             // full coverage
-                            aAttribs.Put( *pAttr->GetItem() );
+                            aAttribs.Put( *rAttr.GetItem() );
                         }
                         else
                         {
                             // OptimizeRagnge() assures that not the same attr can follow for full coverage
                             // only partial, check with current, when using para/styhe, otherwise invalid.
                             if ( !( nFlags & (GETATTRIBS_PARAATTRIBS|GETATTRIBS_STYLESHEET) ) ||
-                                ( *pAttr->GetItem() != aAttribs.Get( pAttr->Which() ) ) )
+                                ( *rAttr.GetItem() != aAttribs.Get( rAttr.Which() ) ) )
                             {
-                                aAttribs.InvalidateItem( pAttr->Which() );
+                                aAttribs.InvalidateItem( rAttr.Which() );
                             }
                         }
                     }
                 }
 
-                if ( pAttr->GetStart() > nEnd )
+                if ( rAttr.GetStart() > nEnd )
                 {
                     break;
                 }
@@ -556,17 +556,16 @@ void ImpEditEngine::SetAttribs( EditSelection aSel, const SfxItemSet& rSet, sal_
                     bCharAttribFound = sal_True;
                     if ( nSpecial == ATTRSPECIAL_EDGE )
                     {
-                        CharAttribArray& rAttribs = pNode->GetCharAttribs().GetAttribs();
-                        sal_uInt16 nAttrs = rAttribs.Count();
-                        for ( sal_uInt16 n = 0; n < nAttrs; n++ )
+                        CharAttribList::AttribsType& rAttribs = pNode->GetCharAttribs().GetAttribs();
+                        for (size_t i = 0, n = rAttribs.size(); i < n; ++i)
                         {
-                            EditCharAttrib* pAttr = rAttribs.GetObject( n );
-                            if ( pAttr->GetStart() > nEndPos )
+                            EditCharAttrib& rAttr = rAttribs[i];
+                            if (rAttr.GetStart() > nEndPos)
                                 break;
 
-                            if ( ( pAttr->GetEnd() == nEndPos ) && ( pAttr->Which() == nWhich ) )
+                            if (rAttr.GetEnd() == nEndPos && rAttr.Which() == nWhich)
                             {
-                                pAttr->SetEdge( sal_True );
+                                rAttr.SetEdge(true);
                                 break;
                             }
                         }
@@ -671,19 +670,19 @@ void ImpEditEngine::RemoveCharAttribs( sal_uInt16 nPara, sal_uInt16 nWhich, sal_
     if ( !pNode )
         return;
 
-    sal_uInt16 nAttr = 0;
-    EditCharAttribPtr pAttr = GetAttrib( pNode->GetCharAttribs().GetAttribs(), nAttr );
+    size_t nAttr = 0;
+    CharAttribList::AttribsType& rAttrs = pNode->GetCharAttribs().GetAttribs();
+    EditCharAttrib* pAttr = GetAttrib(rAttrs, nAttr);
     while ( pAttr )
     {
         if ( ( !pAttr->IsFeature() || bRemoveFeatures ) &&
              ( !nWhich || ( pAttr->GetItem()->Which() == nWhich ) ) )
         {
-            pNode->GetCharAttribs().GetAttribs().Remove( nAttr );
-            delete pAttr;
+            pNode->GetCharAttribs().Remove(nAttr);
             nAttr--;
         }
         nAttr++;
-        pAttr = GetAttrib( pNode->GetCharAttribs().GetAttribs(), nAttr );
+        pAttr = GetAttrib(rAttrs, nAttr);
     }
 
     pPortion->MarkSelectionInvalid( 0, pNode->Len() );
@@ -749,14 +748,15 @@ void ImpEditEngine::GetCharAttribs( sal_uInt16 nPara, std::vector<EECharAttrib>&
     if ( pNode )
     {
         rLst.reserve(pNode->GetCharAttribs().Count());
-        for (size_t i = 0; i < pNode->GetCharAttribs().Count(); ++i)
+        const CharAttribList::AttribsType& rAttrs = pNode->GetCharAttribs().GetAttribs();
+        for (size_t i = 0; i < rAttrs.size(); ++i)
         {
-            EditCharAttribPtr pAttr = pNode->GetCharAttribs().GetAttribs()[i];
+            const EditCharAttrib& rAttr = rAttrs[i];
             EECharAttrib aEEAttr;
-            aEEAttr.pAttr = pAttr->GetItem();
+            aEEAttr.pAttr = rAttr.GetItem();
             aEEAttr.nPara = nPara;
-            aEEAttr.nStart = pAttr->GetStart();
-            aEEAttr.nEnd = pAttr->GetEnd();
+            aEEAttr.nStart = rAttr.GetStart();
+            aEEAttr.nEnd = rAttr.GetEnd();
             rLst.push_back(aEEAttr);
         }
     }
@@ -773,7 +773,7 @@ void ImpEditEngine::ParaAttribsToCharAttribs( ContentNode* pNode )
             const SfxPoolItem& rItem = pNode->GetContentAttribs().GetItem( nWhich );
             // Fill the gap:
             sal_uInt16 nLastEnd = 0;
-            EditCharAttrib* pAttr = pNode->GetCharAttribs().FindNextAttrib( nWhich, nLastEnd );
+            const EditCharAttrib* pAttr = pNode->GetCharAttribs().FindNextAttrib( nWhich, nLastEnd );
             while ( pAttr )
             {
                 nLastEnd = pAttr->GetEnd();