sw: prefix members of HTMLAttr

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

6 files changed, 136 insertions, 136 deletions

diff --git a/sw/source/filter/html/htmlctxt.cxx b/sw/source/filter/html/htmlctxt.cxx
index 3b0b5c59565e..8ad9815902ce 100644
--- a/sw/source/filter/html/htmlctxt.cxx
+++ b/sw/source/filter/html/htmlctxt.cxx
@@ -197,7 +197,7 @@ void SwHTMLParser::SplitAttrTab( const SwPosition& rNewPos )
             HTMLAttr *pNext = pAttr->GetNext();
             HTMLAttr *pPrev = pAttr->GetPrev();
 
-            sal_uInt16 nWhich = pAttr->pItem->Which();
+            sal_uInt16 nWhich = pAttr->m_pItem->Which();
             if( !nOldEndCnt && RES_PARATR_BEGIN <= nWhich &&
                 pAttr->GetSttParaIdx() < pOldEndPara->GetIndex() )
             {
@@ -229,7 +229,7 @@ void SwHTMLParser::SplitAttrTab( const SwPosition& rNewPos )
                     pNext->InsertPrev( pSetAttr );
                 else
                 {
-                    if (pSetAttr->bInsAtStart)
+                    if (pSetAttr->m_bInsAtStart)
                         m_aSetAttrTab.push_front( pSetAttr );
                     else
                         m_aSetAttrTab.push_back( pSetAttr );
@@ -243,7 +243,7 @@ void SwHTMLParser::SplitAttrTab( const SwPosition& rNewPos )
                     pNext->InsertPrev( pPrev );
                 else
                 {
-                    if (pPrev->bInsAtStart)
+                    if (pPrev->m_bInsAtStart)
                         m_aSetAttrTab.push_front( pPrev );
                     else
                         m_aSetAttrTab.push_back( pPrev );
@@ -251,11 +251,11 @@ void SwHTMLParser::SplitAttrTab( const SwPosition& rNewPos )
             }
 
             // Set the start of the attribute
-            pAttr->nSttPara = rNewSttPara;
-            pAttr->nEndPara = rNewSttPara;
-            pAttr->nSttContent = nNewSttCnt;
-            pAttr->nEndContent = nNewSttCnt;
-            pAttr->pPrev = nullptr;
+            pAttr->m_nStartPara = rNewSttPara;
+            pAttr->m_nEndPara = rNewSttPara;
+            pAttr->m_nStartContent = nNewSttCnt;
+            pAttr->m_nEndContent = nNewSttCnt;
+            pAttr->m_pPrev = nullptr;
 
             pAttr = pNext;
         }
diff --git a/sw/source/filter/html/htmlfld.cxx b/sw/source/filter/html/htmlfld.cxx
index 2c660150838a..9498ca1ffbc8 100644
--- a/sw/source/filter/html/htmlfld.cxx
+++ b/sw/source/filter/html/htmlfld.cxx
@@ -621,8 +621,8 @@ void SwHTMLParser::InsertComment( const OUString& rComment, const sal_Char *pTag
                 pAttr->GetSttCnt() != nIdx )
                 break;
 
-            if( RES_TXTATR_FIELD == pAttr->pItem->Which() &&
-                SwFieldIds::Script == static_cast<const SwFormatField *>(pAttr->pItem.get())->GetField()->GetTyp()->Which() )
+            if( RES_TXTATR_FIELD == pAttr->m_pItem->Which() &&
+                SwFieldIds::Script == static_cast<const SwFormatField *>(pAttr->m_pItem.get())->GetField()->GetTyp()->Which() )
             {
                 bMoveFwd = false;
                 break;
diff --git a/sw/source/filter/html/htmlgrin.cxx b/sw/source/filter/html/htmlgrin.cxx
index 92e16aa0e80b..e34ff99a90ea 100644
--- a/sw/source/filter/html/htmlgrin.cxx
+++ b/sw/source/filter/html/htmlgrin.cxx
@@ -1360,7 +1360,7 @@ bool SwHTMLParser::HasCurrentParaBookmarks( bool bIgnoreStack ) const
         for( auto i = m_aSetAttrTab.size(); i; )
         {
             HTMLAttr* pAttr = m_aSetAttrTab[ --i ];
-            if( RES_FLTR_BOOKMARK == pAttr->pItem->Which() )
+            if( RES_FLTR_BOOKMARK == pAttr->m_pItem->Which() )
             {
                 if( pAttr->GetSttParaIdx() == nNodeIdx )
                     bHasMarks = true;
diff --git a/sw/source/filter/html/htmltab.cxx b/sw/source/filter/html/htmltab.cxx
index cb320b47fc85..955bc98e1e67 100644
--- a/sw/source/filter/html/htmltab.cxx
+++ b/sw/source/filter/html/htmltab.cxx
@@ -3161,10 +3161,10 @@ HTMLTableCnts *SwHTMLParser::InsertTableContents(
         while( pAttr )
         {
             OSL_ENSURE( !pAttr->GetPrev(), "Attribute has previous list" );
-            pAttr->nSttPara = rSttPara;
-            pAttr->nEndPara = rSttPara;
-            pAttr->nSttContent = nSttCnt;
-            pAttr->nEndContent = nSttCnt;
+            pAttr->m_nStartPara = rSttPara;
+            pAttr->m_nEndPara = rSttPara;
+            pAttr->m_nStartContent = nSttCnt;
+            pAttr->m_nEndContent = nSttCnt;
 
             pAttr = pAttr->GetNext();
         }
diff --git a/sw/source/filter/html/swhtml.cxx b/sw/source/filter/html/swhtml.cxx
index 042ab0d1563d..eb6952eb5156 100644
--- a/sw/source/filter/html/swhtml.cxx
+++ b/sw/source/filter/html/swhtml.cxx
@@ -2211,7 +2211,7 @@ bool SwHTMLParser::AppendTextNode( SwHTMLAppendMode eMode, bool bUpdateNum )
                         pAttr->GetSttPara() == rEndIdx &&
                         pAttr->GetSttCnt() == 0;
 
-                    sal_Int32 nStt = pAttr->nSttContent;
+                    sal_Int32 nStt = pAttr->m_nStartContent;
                     bool bScript = false;
                     sal_uInt16 nScriptItem;
                     bool bInsert = true;
@@ -2237,11 +2237,11 @@ bool SwHTMLParser::AppendTextNode( SwHTMLAppendMode eMode, bool bUpdateNum )
                                 {
                                     HTMLAttr *pSetAttr =
                                         pAttr->Clone( rEndIdx, nScriptEnd );
-                                    pSetAttr->nSttContent = nStt;
+                                    pSetAttr->m_nStartContent = nStt;
                                     pSetAttr->ClearPrev();
                                     if( !pNext || bWholePara )
                                     {
-                                        if (pSetAttr->bInsAtStart)
+                                        if (pSetAttr->m_bInsAtStart)
                                             m_aSetAttrTab.push_front( pSetAttr );
                                         else
                                             m_aSetAttrTab.push_back( pSetAttr );
@@ -2262,7 +2262,7 @@ bool SwHTMLParser::AppendTextNode( SwHTMLAppendMode eMode, bool bUpdateNum )
                     {
                         HTMLAttr *pSetAttr =
                             pAttr->Clone( rEndIdx, nEndCnt );
-                        pSetAttr->nSttContent = nStt;
+                        pSetAttr->m_nStartContent = nStt;
 
                         // When the attribute is for the whole paragraph, the outer
                         // attributes aren't effective anymore. Hence it may not be inserted
@@ -2270,7 +2270,7 @@ bool SwHTMLParser::AppendTextNode( SwHTMLAppendMode eMode, bool bUpdateNum )
                         // set. That leads to shifting when fields are used.
                         if( !pNext || bWholePara )
                         {
-                            if (pSetAttr->bInsAtStart)
+                            if (pSetAttr->m_bInsAtStart)
                                 m_aSetAttrTab.push_front( pSetAttr );
                             else
                                 m_aSetAttrTab.push_back( pSetAttr );
@@ -2286,7 +2286,7 @@ bool SwHTMLParser::AppendTextNode( SwHTMLAppendMode eMode, bool bUpdateNum )
                             // the previous attributes must be set anyway
                             if( !pNext || bWholePara )
                             {
-                                if (pPrev->bInsAtStart)
+                                if (pPrev->m_bInsAtStart)
                                     m_aSetAttrTab.push_front( pPrev );
                                 else
                                     m_aSetAttrTab.push_back( pPrev );
@@ -2694,7 +2694,7 @@ void SwHTMLParser::SetAttr_( bool bChkEnd, bool bBeforeTable,
     for( auto n = m_aSetAttrTab.size(); n; )
     {
         pAttr = m_aSetAttrTab[ --n ];
-        sal_uInt16 nWhich = pAttr->pItem->Which();
+        sal_uInt16 nWhich = pAttr->m_pItem->Which();
 
         sal_uLong nEndParaIdx = pAttr->GetEndParaIdx();
         bool bSetAttr;
@@ -2743,7 +2743,7 @@ void SwHTMLParser::SetAttr_( bool bChkEnd, bool bBeforeTable,
             while( pAttr )
             {
                 HTMLAttr *pPrev = pAttr->GetPrev();
-                if( !pAttr->bValid )
+                if( !pAttr->m_bValid )
                 {
                     // invalid attributes can be deleted
                     delete pAttr;
@@ -2751,7 +2751,7 @@ void SwHTMLParser::SetAttr_( bool bChkEnd, bool bBeforeTable,
                     continue;
                 }
 
-                pCNd = pAttr->nSttPara.GetNode().GetContentNode();
+                pCNd = pAttr->m_nStartPara.GetNode().GetContentNode();
                 if( !pCNd )
                 {
                     // because of the awful deleting of nodes an index can also
@@ -2765,9 +2765,9 @@ void SwHTMLParser::SetAttr_( bool bChkEnd, bool bBeforeTable,
                         pAttr = pPrev;
                         continue;
                     }
-                    pCNd = m_xDoc->GetNodes().GoNext( &(pAttr->nSttPara) );
+                    pCNd = m_xDoc->GetNodes().GoNext( &(pAttr->m_nStartPara) );
                     if( pCNd )
-                        pAttr->nSttContent = 0;
+                        pAttr->m_nStartContent = 0;
                     else
                     {
                         OSL_ENSURE( false, "SetAttr: GoNext() failed!" );
@@ -2776,24 +2776,24 @@ void SwHTMLParser::SetAttr_( bool bChkEnd, bool bBeforeTable,
                         continue;
                     }
                 }
-                pAttrPam->GetPoint()->nNode = pAttr->nSttPara;
+                pAttrPam->GetPoint()->nNode = pAttr->m_nStartPara;
 
                 // because of the deleting of BRs the start index can also
                 // point behind the end the text
-                if( pAttr->nSttContent > pCNd->Len() )
-                    pAttr->nSttContent = pCNd->Len();
-                pAttrPam->GetPoint()->nContent.Assign( pCNd, pAttr->nSttContent );
+                if( pAttr->m_nStartContent > pCNd->Len() )
+                    pAttr->m_nStartContent = pCNd->Len();
+                pAttrPam->GetPoint()->nContent.Assign( pCNd, pAttr->m_nStartContent );
 
                 pAttrPam->SetMark();
                 if ( (pAttr->GetSttPara() != pAttr->GetEndPara()) &&
                          !isTXTATR_NOEND(nWhich) )
                 {
-                    pCNd = pAttr->nEndPara.GetNode().GetContentNode();
+                    pCNd = pAttr->m_nEndPara.GetNode().GetContentNode();
                     if( !pCNd )
                     {
-                        pCNd = SwNodes::GoPrevious( &(pAttr->nEndPara) );
+                        pCNd = SwNodes::GoPrevious( &(pAttr->m_nEndPara) );
                         if( pCNd )
-                            pAttr->nEndContent = pCNd->Len();
+                            pAttr->m_nEndContent = pCNd->Len();
                         else
                         {
                             OSL_ENSURE( false, "SetAttr: GoPrevious() failed!" );
@@ -2804,19 +2804,19 @@ void SwHTMLParser::SetAttr_( bool bChkEnd, bool bBeforeTable,
                         }
                     }
 
-                    pAttrPam->GetPoint()->nNode = pAttr->nEndPara;
+                    pAttrPam->GetPoint()->nNode = pAttr->m_nEndPara;
                 }
                 else if( pAttr->IsLikePara() )
                 {
-                    pAttr->nEndContent = pCNd->Len();
+                    pAttr->m_nEndContent = pCNd->Len();
                 }
 
                 // because of the deleting of BRs the start index can also
                 // point behind the end the text
-                if( pAttr->nEndContent > pCNd->Len() )
-                    pAttr->nEndContent = pCNd->Len();
+                if( pAttr->m_nEndContent > pCNd->Len() )
+                    pAttr->m_nEndContent = pCNd->Len();
 
-                pAttrPam->GetPoint()->nContent.Assign( pCNd, pAttr->nEndContent );
+                pAttrPam->GetPoint()->nContent.Assign( pCNd, pAttr->m_nEndContent );
                 if( bBeforeTable &&
                     pAttrPam->GetPoint()->nNode.GetIndex() ==
                         rEndIdx.GetIndex() )
@@ -2848,7 +2848,7 @@ void SwHTMLParser::SetAttr_( bool bChkEnd, bool bBeforeTable,
                 {
                 case RES_FLTR_BOOKMARK: // insert bookmark
                     {
-                        const OUString sName( static_cast<SfxStringItem*>(pAttr->pItem.get())->GetValue() );
+                        const OUString sName( static_cast<SfxStringItem*>(pAttr->m_pItem.get())->GetValue() );
                         IDocumentMarkAccess* const pMarkAccess = m_xDoc->getIDocumentMarkAccess();
                         IDocumentMarkAccess::const_iterator_t ppBkmk = pMarkAccess->findMark( sName );
                         if( ppBkmk != pMarkAccess->getAllMarksEnd() &&
@@ -2875,7 +2875,7 @@ void SwHTMLParser::SetAttr_( bool bChkEnd, bool bBeforeTable,
                     {
                         SwFieldIds nFieldWhich =
                             pPostIts
-                            ? static_cast<const SwFormatField *>(pAttr->pItem.get())->GetField()->GetTyp()->Which()
+                            ? static_cast<const SwFormatField *>(pAttr->m_pItem.get())->GetField()->GetTyp()->Which()
                             : SwFieldIds::Database;
                         if( pPostIts && (SwFieldIds::Postit == nFieldWhich ||
                                          SwFieldIds::Script == nFieldWhich) )
@@ -2897,7 +2897,7 @@ void SwHTMLParser::SetAttr_( bool bChkEnd, bool bBeforeTable,
                         pCNd )
                     {
                         // because of numbering set this attribute directly at node
-                        pCNd->SetAttr( *pAttr->pItem );
+                        pCNd->SetAttr( *pAttr->m_pItem );
                         break;
                     }
                     OSL_ENSURE( false,
@@ -2910,7 +2910,7 @@ void SwHTMLParser::SetAttr_( bool bChkEnd, bool bBeforeTable,
                 // may be handled more directly in HTML import to handle them.
                 case RES_BACKGROUND:
                 {
-                    const SvxBrushItem& rBrush = static_cast< SvxBrushItem& >(*pAttr->pItem);
+                    const SvxBrushItem& rBrush = static_cast< SvxBrushItem& >(*pAttr->m_pItem);
                     SfxItemSet aNewSet(m_xDoc->GetAttrPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{});
 
                     setSvxBrushItemAsFillAttributesToTargetSet(rBrush, aNewSet);
@@ -2922,13 +2922,13 @@ void SwHTMLParser::SetAttr_( bool bChkEnd, bool bBeforeTable,
                     // maybe jump to a bookmark
                     if( RES_TXTATR_INETFMT == nWhich &&
                         JUMPTO_MARK == m_eJumpTo &&
-                        m_sJmpMark == static_cast<SwFormatINetFormat*>(pAttr->pItem.get())->GetName() )
+                        m_sJmpMark == static_cast<SwFormatINetFormat*>(pAttr->m_pItem.get())->GetName() )
                     {
                         m_bChkJumpMark = true;
                         m_eJumpTo = JUMPTO_NONE;
                     }
 
-                    m_xDoc->getIDocumentContentOperations().InsertPoolItem( *pAttrPam, *pAttr->pItem, SetAttrMode::DONTREPLACE );
+                    m_xDoc->getIDocumentContentOperations().InsertPoolItem( *pAttrPam, *pAttr->m_pItem, SetAttrMode::DONTREPLACE );
                 }
                 pAttrPam->DeleteMark();
 
@@ -2994,9 +2994,9 @@ void SwHTMLParser::SetAttr_( bool bChkEnd, bool bBeforeTable,
     }
     for (auto & field : aFields)
     {
-        pCNd = field->nSttPara.GetNode().GetContentNode();
-        pAttrPam->GetPoint()->nNode = field->nSttPara;
-        pAttrPam->GetPoint()->nContent.Assign( pCNd, field->nSttContent );
+        pCNd = field->m_nStartPara.GetNode().GetContentNode();
+        pAttrPam->GetPoint()->nNode = field->m_nStartPara;
+        pAttrPam->GetPoint()->nContent.Assign( pCNd, field->m_nStartContent );
 
         if( bBeforeTable &&
             pAttrPam->GetPoint()->nNode.GetIndex() == rEndIdx.GetIndex() )
@@ -3008,7 +3008,7 @@ void SwHTMLParser::SetAttr_( bool bChkEnd, bool bBeforeTable,
             pAttrPam->Move( fnMoveBackward );
         }
 
-        m_xDoc->getIDocumentContentOperations().InsertPoolItem( *pAttrPam, *field->pItem );
+        m_xDoc->getIDocumentContentOperations().InsertPoolItem( *pAttrPam, *field->m_pItem );
 
         field.reset();
     }
@@ -3036,7 +3036,7 @@ bool SwHTMLParser::EndAttr( HTMLAttr* pAttr, bool bChkEmpty )
     bool bRet = true;
 
     // The list header is saved in the attribute.
-    HTMLAttr **ppHead = pAttr->ppHead;
+    HTMLAttr **ppHead = pAttr->m_ppHead;
 
     OSL_ENSURE( ppHead, "No list header attribute found!" );
 
@@ -3061,7 +3061,7 @@ bool SwHTMLParser::EndAttr( HTMLAttr* pAttr, bool bChkEmpty )
     }
 
     bool bMoveBack = false;
-    sal_uInt16 nWhich = pAttr->pItem->Which();
+    sal_uInt16 nWhich = pAttr->m_pItem->Which();
     if( !nEndCnt && RES_PARATR_BEGIN <= nWhich &&
         *pEndIdx != pAttr->GetSttPara() )
     {
@@ -3115,13 +3115,13 @@ bool SwHTMLParser::EndAttr( HTMLAttr* pAttr, bool bChkEmpty )
                     pNext->InsertPrev( pSetAttr );
                 else
                 {
-                    if (pSetAttr->bInsAtStart)
+                    if (pSetAttr->m_bInsAtStart)
                         m_aSetAttrTab.push_front( pSetAttr );
                     else
                         m_aSetAttrTab.push_back( pSetAttr );
                 }
             }
-            pAttr->nSttContent = nScriptEnd;
+            pAttr->m_nStartContent = nScriptEnd;
             nScriptText = g_pBreakIt->GetBreakIter()->getScriptType(
                             rText, nScriptEnd );
             nScriptEnd = g_pBreakIt->GetBreakIter()
@@ -3131,9 +3131,9 @@ bool SwHTMLParser::EndAttr( HTMLAttr* pAttr, bool bChkEmpty )
     }
     if( bInsert )
     {
-        pAttr->nEndPara = *pEndIdx;
-        pAttr->nEndContent = nEndCnt;
-        pAttr->bInsAtStart = RES_TXTATR_INETFMT != nWhich &&
+        pAttr->m_nEndPara = *pEndIdx;
+        pAttr->m_nEndContent = nEndCnt;
+        pAttr->m_bInsAtStart = RES_TXTATR_INETFMT != nWhich &&
                              RES_TXTATR_CHARFMT != nWhich;
 
         if( !pNext )
@@ -3141,7 +3141,7 @@ bool SwHTMLParser::EndAttr( HTMLAttr* pAttr, bool bChkEmpty )
             // No open attributes of that type exists any longer, so all
             // can be set. Except they depend on another attribute, then
             // they're appended there.
-            if (pAttr->bInsAtStart)
+            if (pAttr->m_bInsAtStart)
                 m_aSetAttrTab.push_front( pAttr );
             else
                 m_aSetAttrTab.push_back( pAttr );
@@ -3171,7 +3171,7 @@ bool SwHTMLParser::EndAttr( HTMLAttr* pAttr, bool bChkEmpty )
                 pNext->InsertPrev( pPrev );
             else
             {
-                if (pPrev->bInsAtStart)
+                if (pPrev->m_bInsAtStart)
                     m_aSetAttrTab.push_front( pPrev );
                 else
                     m_aSetAttrTab.push_back( pPrev );
@@ -3183,7 +3183,7 @@ bool SwHTMLParser::EndAttr( HTMLAttr* pAttr, bool bChkEmpty )
     // If the first attribute of the list was set, then the list header
     // must be corrected as well.
     if( pLast )
-        pLast->pNext = pNext;
+        pLast->m_pNext = pNext;
     else if( ppHead )
         *ppHead = pNext;
 
@@ -3202,7 +3202,7 @@ void SwHTMLParser::DeleteAttr( HTMLAttr* pAttr )
     m_aParaAttrs.clear();
 
     // The list header is saved in the attribute
-    HTMLAttr **ppHead = pAttr->ppHead;
+    HTMLAttr **ppHead = pAttr->m_ppHead;
 
     OSL_ENSURE( ppHead, "no list header attribute found!" );
 
@@ -3226,7 +3226,7 @@ void SwHTMLParser::DeleteAttr( HTMLAttr* pAttr )
     HTMLAttr *pNext = pAttr->GetNext();
     HTMLAttr *pPrev = pAttr->GetPrev();
     //hold ref to xAttrTab until end of scope to ensure *ppHead validity
-    std::shared_ptr<HTMLAttrTable> xAttrTab(pAttr->xAttrTab);
+    std::shared_ptr<HTMLAttrTable> xAttrTab(pAttr->m_xAttrTab);
     delete pAttr;
 
     if( pPrev )
@@ -3236,7 +3236,7 @@ void SwHTMLParser::DeleteAttr( HTMLAttr* pAttr )
             pNext->InsertPrev( pPrev );
         else
         {
-            if (pPrev->bInsAtStart)
+            if (pPrev->m_bInsAtStart)
                 m_aSetAttrTab.push_front( pPrev );
             else
                 m_aSetAttrTab.push_back( pPrev );
@@ -3246,7 +3246,7 @@ void SwHTMLParser::DeleteAttr( HTMLAttr* pAttr )
     // If the first attribute of the list was deleted, then the list header
     // must be corrected as well.
     if( pLast )
-        pLast->pNext = pNext;
+        pLast->m_pNext = pNext;
     else if( ppHead )
         *ppHead = pNext;
 }
@@ -3336,7 +3336,7 @@ void SwHTMLParser::SplitAttrTab( std::shared_ptr<HTMLAttrTable> const & rNewAttr
                     pNext->InsertPrev( pSetAttr );
                 else
                 {
-                    if (pSetAttr->bInsAtStart)
+                    if (pSetAttr->m_bInsAtStart)
                         m_aSetAttrTab.push_front( pSetAttr );
                     else
                         m_aSetAttrTab.push_back( pSetAttr );
@@ -3350,7 +3350,7 @@ void SwHTMLParser::SplitAttrTab( std::shared_ptr<HTMLAttrTable> const & rNewAttr
                     pNext->InsertPrev( pPrev );
                 else
                 {
-                    if (pPrev->bInsAtStart)
+                    if (pPrev->m_bInsAtStart)
                         m_aSetAttrTab.push_front( pPrev );
                     else
                         m_aSetAttrTab.push_back( pPrev );
@@ -3397,7 +3397,7 @@ void SwHTMLParser::RestoreAttrTab(std::shared_ptr<HTMLAttrTable> const & rNewAtt
         HTMLAttr *pAttr = *pHTMLAttributes;
         while (pAttr)
         {
-            OSL_ENSURE( !pAttr->GetPrev() || !pAttr->GetPrev()->ppHead,
+            OSL_ENSURE( !pAttr->GetPrev() || !pAttr->GetPrev()->m_ppHead,
                     "Previous attribute has still a header" );
             pAttr->SetHead(pHTMLAttributes, m_xAttrTab);
             pAttr = pAttr->GetNext();
@@ -5439,35 +5439,35 @@ void SwHTMLParser::ParseMoreMetaOptions()
 
 HTMLAttr::HTMLAttr( const SwPosition& rPos, const SfxPoolItem& rItem,
                       HTMLAttr **ppHd, const std::shared_ptr<HTMLAttrTable>& rAttrTab ) :
-    nSttPara( rPos.nNode ),
-    nEndPara( rPos.nNode ),
-    nSttContent( rPos.nContent.GetIndex() ),
-    nEndContent(rPos.nContent.GetIndex() ),
-    bInsAtStart( true ),
-    bLikePara( false ),
-    bValid( true ),
-    pItem( rItem.Clone() ),
-    xAttrTab( rAttrTab ),
-    pNext( nullptr ),
-    pPrev( nullptr ),
-    ppHead( ppHd )
+    m_nStartPara( rPos.nNode ),
+    m_nEndPara( rPos.nNode ),
+    m_nStartContent( rPos.nContent.GetIndex() ),
+    m_nEndContent(rPos.nContent.GetIndex() ),
+    m_bInsAtStart( true ),
+    m_bLikePara( false ),
+    m_bValid( true ),
+    m_pItem( rItem.Clone() ),
+    m_xAttrTab( rAttrTab ),
+    m_pNext( nullptr ),
+    m_pPrev( nullptr ),
+    m_ppHead( ppHd )
 {
 }
 
 HTMLAttr::HTMLAttr( const HTMLAttr &rAttr, const SwNodeIndex &rEndPara,
                       sal_Int32 nEndCnt, HTMLAttr **ppHd, const std::shared_ptr<HTMLAttrTable>& rAttrTab ) :
-    nSttPara( rAttr.nSttPara ),
-    nEndPara( rEndPara ),
-    nSttContent( rAttr.nSttContent ),
-    nEndContent( nEndCnt ),
-    bInsAtStart( rAttr.bInsAtStart ),
-    bLikePara( rAttr.bLikePara ),
-    bValid( rAttr.bValid ),
-    pItem( rAttr.pItem->Clone() ),
-    xAttrTab( rAttrTab ),
-    pNext( nullptr ),
-    pPrev( nullptr ),
-    ppHead( ppHd )
+    m_nStartPara( rAttr.m_nStartPara ),
+    m_nEndPara( rEndPara ),
+    m_nStartContent( rAttr.m_nStartContent ),
+    m_nEndContent( nEndCnt ),
+    m_bInsAtStart( rAttr.m_bInsAtStart ),
+    m_bLikePara( rAttr.m_bLikePara ),
+    m_bValid( rAttr.m_bValid ),
+    m_pItem( rAttr.m_pItem->Clone() ),
+    m_xAttrTab( rAttrTab ),
+    m_pNext( nullptr ),
+    m_pPrev( nullptr ),
+    m_ppHead( ppHd )
 {
 }
 
@@ -5478,10 +5478,10 @@ HTMLAttr::~HTMLAttr()
 HTMLAttr *HTMLAttr::Clone(const SwNodeIndex& rEndPara, sal_Int32 nEndCnt) const
 {
     // create the attribute anew with old start position
-    HTMLAttr *pNew = new HTMLAttr( *this, rEndPara, nEndCnt, ppHead, xAttrTab );
+    HTMLAttr *pNew = new HTMLAttr( *this, rEndPara, nEndCnt, m_ppHead, m_xAttrTab );
 
     // The Previous-List must be taken over, the Next-List not!
-    pNew->pPrev = pPrev;
+    pNew->m_pPrev = m_pPrev;
 
     return pNew;
 }
@@ -5490,33 +5490,33 @@ void HTMLAttr::Reset(const SwNodeIndex& rSttPara, sal_Int32 nSttCnt,
                      HTMLAttr **ppHd, const std::shared_ptr<HTMLAttrTable>& rAttrTab)
 {
     // reset the start (and the end)
-    nSttPara = rSttPara;
-    nSttContent = nSttCnt;
-    nEndPara = rSttPara;
-    nEndContent = nSttCnt;
+    m_nStartPara = rSttPara;
+    m_nStartContent = nSttCnt;
+    m_nEndPara = rSttPara;
+    m_nEndContent = nSttCnt;
 
     // correct the head and nullify link
-    pNext = nullptr;
-    pPrev = nullptr;
-    ppHead = ppHd;
-    xAttrTab = rAttrTab;
+    m_pNext = nullptr;
+    m_pPrev = nullptr;
+    m_ppHead = ppHd;
+    m_xAttrTab = rAttrTab;
 }
 
 void HTMLAttr::InsertPrev( HTMLAttr *pPrv )
 {
-    OSL_ENSURE( !pPrv->pNext || pPrv->pNext == this,
+    OSL_ENSURE( !pPrv->m_pNext || pPrv->m_pNext == this,
             "HTMLAttr::InsertPrev: pNext wrong" );
-    pPrv->pNext = nullptr;
+    pPrv->m_pNext = nullptr;
 
-    OSL_ENSURE( nullptr == pPrv->ppHead || ppHead == pPrv->ppHead,
+    OSL_ENSURE( nullptr == pPrv->m_ppHead || m_ppHead == pPrv->m_ppHead,
             "HTMLAttr::InsertPrev: ppHead wrong" );
-    pPrv->ppHead = nullptr;
+    pPrv->m_ppHead = nullptr;
 
     HTMLAttr *pAttr = this;
     while( pAttr->GetPrev() )
         pAttr = pAttr->GetPrev();
 
-    pAttr->pPrev = pPrv;
+    pAttr->m_pPrev = pPrv;
 }
 
 bool SwHTMLParser::ParseMetaOptions(
diff --git a/sw/source/filter/html/swhtml.hxx b/sw/source/filter/html/swhtml.hxx
index 2f9a633a3cd9..5c633f326964 100644
--- a/sw/source/filter/html/swhtml.hxx
+++ b/sw/source/filter/html/swhtml.hxx
@@ -129,17 +129,17 @@ class HTMLAttr
     friend class SwHTMLParser;
     friend class CellSaveStruct;
 
-    SwNodeIndex nSttPara, nEndPara;
-    sal_Int32 nSttContent, nEndContent;
-    bool bInsAtStart : 1;
-    bool bLikePara : 1; // set attribute above the whole paragraph
-    bool bValid : 1;    // is the attribute valid?
-
-    std::unique_ptr<SfxPoolItem> pItem;
-    std::shared_ptr<HTMLAttrTable> xAttrTab;
-    HTMLAttr *pNext;   // still to close attributes with different values
-    HTMLAttr *pPrev;   // already closed but not set attributes
-    HTMLAttr **ppHead; // list head
+    SwNodeIndex m_nStartPara, m_nEndPara;
+    sal_Int32 m_nStartContent, m_nEndContent;
+    bool m_bInsAtStart : 1;
+    bool m_bLikePara : 1; // set attribute above the whole paragraph
+    bool m_bValid : 1;    // is the attribute valid?
+
+    std::unique_ptr<SfxPoolItem> m_pItem;
+    std::shared_ptr<HTMLAttrTable> m_xAttrTab;
+    HTMLAttr *m_pNext;   // still to close attributes with different values
+    HTMLAttr *m_pPrev;   // already closed but not set attributes
+    HTMLAttr **m_ppHead; // list head
 
     HTMLAttr( const SwPosition& rPos, const SfxPoolItem& rItem,
                HTMLAttr **pHd, const std::shared_ptr<HTMLAttrTable>& rAttrTab );
@@ -156,39 +156,39 @@ public:
                 HTMLAttr **pHd, const std::shared_ptr<HTMLAttrTable>& rAttrTab );
     inline void SetStart( const SwPosition& rPos );
 
-    sal_uInt32 GetSttParaIdx() const { return nSttPara.GetIndex(); }
-    sal_uInt32 GetEndParaIdx() const { return nEndPara.GetIndex(); }
+    sal_uInt32 GetSttParaIdx() const { return m_nStartPara.GetIndex(); }
+    sal_uInt32 GetEndParaIdx() const { return m_nEndPara.GetIndex(); }
 
-    const SwNodeIndex& GetSttPara() const { return nSttPara; }
-    const SwNodeIndex& GetEndPara() const { return nEndPara; }
+    const SwNodeIndex& GetSttPara() const { return m_nStartPara; }
+    const SwNodeIndex& GetEndPara() const { return m_nEndPara; }
 
-    sal_Int32 GetSttCnt() const { return nSttContent; }
-    sal_Int32 GetEndCnt() const { return nEndContent; }
+    sal_Int32 GetSttCnt() const { return m_nStartContent; }
+    sal_Int32 GetEndCnt() const { return m_nEndContent; }
 
-    bool IsLikePara() const { return bLikePara; }
-    void SetLikePara() { bLikePara = true; }
+    bool IsLikePara() const { return m_bLikePara; }
+    void SetLikePara() { m_bLikePara = true; }
 
-          SfxPoolItem& GetItem()        { return *pItem; }
-    const SfxPoolItem& GetItem() const  { return *pItem; }
+          SfxPoolItem& GetItem()        { return *m_pItem; }
+    const SfxPoolItem& GetItem() const  { return *m_pItem; }
 
-    HTMLAttr *GetNext() const { return pNext; }
-    void InsertNext( HTMLAttr *pNxt ) { pNext = pNxt; }
+    HTMLAttr *GetNext() const { return m_pNext; }
+    void InsertNext( HTMLAttr *pNxt ) { m_pNext = pNxt; }
 
-    HTMLAttr *GetPrev() const { return pPrev; }
+    HTMLAttr *GetPrev() const { return m_pPrev; }
     void InsertPrev( HTMLAttr *pPrv );
-    void ClearPrev() { pPrev = nullptr; }
+    void ClearPrev() { m_pPrev = nullptr; }
 
     void SetHead(HTMLAttr **ppHd, const std::shared_ptr<HTMLAttrTable>& rAttrTab)
     {
-        ppHead = ppHd;
-        xAttrTab = rAttrTab;
+        m_ppHead = ppHd;
+        m_xAttrTab = rAttrTab;
     }
 
     // During setting attributes from styles it can happen that these
     // shouldn't be set anymore. To delete them would be very expensive, because
     // you don't know all the places where they are linked in. Therefore they're
     // made invalid and deleted at the next call of SetAttr_().
-    void Invalidate() { bValid = false; }
+    void Invalidate() { m_bValid = false; }
 };
 
 class HTMLAttrContext_SaveDoc;
@@ -945,10 +945,10 @@ struct SwPending
 
 inline void HTMLAttr::SetStart( const SwPosition& rPos )
 {
-    nSttPara = rPos.nNode;
-    nSttContent = rPos.nContent.GetIndex();
-    nEndPara = nSttPara;
-    nEndContent = nSttContent;
+    m_nStartPara = rPos.nNode;
+    m_nStartContent = rPos.nContent.GetIndex();
+    m_nEndPara = m_nStartPara;
+    m_nEndContent = m_nStartContent;
 }
 
 inline void HTMLAttrContext::SetMargins( sal_uInt16 nLeft, sal_uInt16 nRight,