sw: prefix members of SwWW8StyInf

Change-Id: I2749607eb2271a838acb8220c80d9363d8e8d867

6 files changed, 199 insertions, 199 deletions

diff --git a/sw/source/filter/ww8/ww8graf.cxx b/sw/source/filter/ww8/ww8graf.cxx
index 1d3113cbeb25..e937f314beab 100644
--- a/sw/source/filter/ww8/ww8graf.cxx
+++ b/sw/source/filter/ww8/ww8graf.cxx
@@ -478,14 +478,14 @@ ESelection GetESelection(EditEngine &rDrawEditEngine, long nCpStart, long nCpEnd
 void SwWW8ImplReader::InsertTxbxStyAttrs( SfxItemSet& rS, sal_uInt16 nColl )
 {
     SwWW8StyInf * pStyInf = GetStyle(nColl);
-    if( pStyInf != nullptr && pStyInf->pFormat && pStyInf->bColl )
+    if( pStyInf != nullptr && pStyInf->m_pFormat && pStyInf->m_bColl )
     {
         const SfxPoolItem* pItem;
         for( sal_uInt16 i = POOLATTR_BEGIN; i < POOLATTR_END; i++ )
         {
             // If we are set in the source and not set in the destination
             // then add it in.
-            if ( SfxItemState::SET == pStyInf->pFormat->GetItemState(
+            if ( SfxItemState::SET == pStyInf->m_pFormat->GetItemState(
                 i, true, &pItem ) )
             {
                 SfxItemPool *pEditPool = rS.GetPool();
diff --git a/sw/source/filter/ww8/ww8par.cxx b/sw/source/filter/ww8/ww8par.cxx
index 1bf4914c4977..124cd5074533 100644
--- a/sw/source/filter/ww8/ww8par.cxx
+++ b/sw/source/filter/ww8/ww8par.cxx
@@ -1721,15 +1721,15 @@ void SwWW8ImplReader::Read_Tab(sal_uInt16 , const sal_uInt8* pData, short nLen)
     sal_uInt16 nTabBase;
     if (m_pAktColl && m_nAktColl < m_vColl.size()) // StyleDef
     {
-        nTabBase = m_vColl[m_nAktColl].nBase;
+        nTabBase = m_vColl[m_nAktColl].m_nBase;
         if (nTabBase < m_vColl.size())  // Based On
-            pSty = static_cast<const SwTextFormatColl*>(m_vColl[nTabBase].pFormat);
+            pSty = static_cast<const SwTextFormatColl*>(m_vColl[nTabBase].m_pFormat);
     }
     else
     { // Text
         nTabBase = m_nAktColl;
         if (m_nAktColl < m_vColl.size())
-            pSty = static_cast<const SwTextFormatColl*>(m_vColl[m_nAktColl].pFormat);
+            pSty = static_cast<const SwTextFormatColl*>(m_vColl[m_nAktColl].m_pFormat);
         //TODO: figure out else here
     }
 
@@ -1747,7 +1747,7 @@ void SwWW8ImplReader::Read_Tab(sal_uInt16 , const sal_uInt8* pData, short nLen)
             sal_uInt16 nOldTabBase = nTabBase;
             // If based on another
             if (nTabBase < m_vColl.size())
-                nTabBase = m_vColl[nTabBase].nBase;
+                nTabBase = m_vColl[nTabBase].m_nBase;
 
             if (
                     nTabBase < m_vColl.size() &&
@@ -1759,7 +1759,7 @@ void SwWW8ImplReader::Read_Tab(sal_uInt16 , const sal_uInt8* pData, short nLen)
                 // current one (prevent loop)
                 aLoopWatch.insert(reinterpret_cast<size_t>(pSty));
                 if (nTabBase < m_vColl.size())
-                    pSty = static_cast<const SwTextFormatColl*>(m_vColl[nTabBase].pFormat);
+                    pSty = static_cast<const SwTextFormatColl*>(m_vColl[nTabBase].m_pFormat);
                 //TODO figure out the else branch
 
                 if (aLoopWatch.find(reinterpret_cast<size_t>(pSty)) !=
@@ -3708,7 +3708,7 @@ void SwWW8ImplReader::ProcessAktCollChange(WW8PLCFManResult& rRes,
     m_nAktColl = m_pPlcxMan->GetColl();
 
     // Invalid Style-Id
-    if (m_nAktColl >= m_vColl.size() || !m_vColl[m_nAktColl].pFormat || !m_vColl[m_nAktColl].bColl)
+    if (m_nAktColl >= m_vColl.size() || !m_vColl[m_nAktColl].m_pFormat || !m_vColl[m_nAktColl].m_bColl)
     {
         m_nAktColl = 0;
         m_bParaAutoBefore = false;
@@ -3716,8 +3716,8 @@ void SwWW8ImplReader::ProcessAktCollChange(WW8PLCFManResult& rRes,
     }
     else
     {
-        m_bParaAutoBefore = m_vColl[m_nAktColl].bParaAutoBefore;
-        m_bParaAutoAfter = m_vColl[m_nAktColl].bParaAutoAfter;
+        m_bParaAutoBefore = m_vColl[m_nAktColl].m_bParaAutoBefore;
+        m_bParaAutoAfter = m_vColl[m_nAktColl].m_bParaAutoAfter;
     }
 
     if (nOldColl >= m_vColl.size())
@@ -3736,9 +3736,9 @@ void SwWW8ImplReader::ProcessAktCollChange(WW8PLCFManResult& rRes,
     if (!bTabRowEnd && StyleExists(m_nAktColl))
     {
         SetTextFormatCollAndListLevel( *m_pPaM, m_vColl[ m_nAktColl ]);
-        ChkToggleAttr(m_vColl[ nOldColl ].n81Flags, m_vColl[ m_nAktColl ].n81Flags);
-        ChkToggleBiDiAttr(m_vColl[nOldColl].n81BiDiFlags,
-            m_vColl[m_nAktColl].n81BiDiFlags);
+        ChkToggleAttr(m_vColl[ nOldColl ].m_n81Flags, m_vColl[ m_nAktColl ].m_n81Flags);
+        ChkToggleBiDiAttr(m_vColl[nOldColl].m_n81BiDiFlags,
+            m_vColl[m_nAktColl].m_n81BiDiFlags);
     }
 }
 
@@ -5882,7 +5882,7 @@ void SwWW8ImplReader::SetOutlineStyles()
     {
         SwWW8StyInf* pStyleInf = (*aStyleIter);
 
-        if (!pStyleInf->bColl) //Character Style
+        if (!pStyleInf->m_bColl) //Character Style
             continue;
 
         const sal_uInt16 nOutlineStyleListLevelOfWW8BuiltInHeadingStyle
@@ -5894,7 +5894,7 @@ void SwWW8ImplReader::SetOutlineStyles()
         }
 
         if (pChosenWW8ListStyle != nullptr && pStyleInf->mnWW8OutlineLevel
-                                           == pStyleInf->nListLevel)
+                                           == pStyleInf->m_nListLevel)
         {
             const SwNumFormat& rRule
                 = pChosenWW8ListStyle->Get(pStyleInf->mnWW8OutlineLevel);
@@ -5906,10 +5906,10 @@ void SwWW8ImplReader::SetOutlineStyles()
         nOutlineStyleListLevelWithAssignment
             |= nOutlineStyleListLevelOfWW8BuiltInHeadingStyle;
 
-        SwTextFormatColl* pTextFormatColl = static_cast<SwTextFormatColl*>(pStyleInf->pFormat);
+        SwTextFormatColl* pTextFormatColl = static_cast<SwTextFormatColl*>(pStyleInf->m_pFormat);
         if (pStyleInf->GetOutlineNumrule() != pChosenWW8ListStyle
-            || (pStyleInf->nListLevel < WW8ListManager::nMaxLevel
-                && pStyleInf->mnWW8OutlineLevel != pStyleInf->nListLevel))
+            || (pStyleInf->m_nListLevel < WW8ListManager::nMaxLevel
+                && pStyleInf->mnWW8OutlineLevel != pStyleInf->m_nListLevel))
         {
             // WW8 Built-In Heading Style does not apply the chosen one.
             // --> delete assignment to OutlineStyle, but keep its current
diff --git a/sw/source/filter/ww8/ww8par.hxx b/sw/source/filter/ww8/ww8par.hxx
index e0b0eabde52e..ab3bd028e3ad 100644
--- a/sw/source/filter/ww8/ww8par.hxx
+++ b/sw/source/filter/ww8/ww8par.hxx
@@ -215,20 +215,20 @@ struct WW8FlyPara
 
 class SwWW8StyInf
 {
-    OUString        sWWStyleName;
-    sal_uInt16      nWWStyleId;
+    OUString        m_sWWStyleName;
+    sal_uInt16      m_nWWStyleId;
 public:
-    rtl_TextEncoding eLTRFontSrcCharSet;    // rtl_TextEncoding for the font
-    rtl_TextEncoding eRTLFontSrcCharSet;    // rtl_TextEncoding for the font
-    rtl_TextEncoding eCJKFontSrcCharSet;    // rtl_TextEncoding for the font
-    SwFormat*      pFormat;
-    WW8FlyPara* pWWFly;
-    SwNumRule*  pOutlineNumrule;
-    long        nFilePos;
-    sal_uInt16      nBase;
-    sal_uInt16      nFollow;
-    sal_uInt16      nLFOIndex;
-    sal_uInt8        nListLevel;
+    rtl_TextEncoding m_eLTRFontSrcCharSet;    // rtl_TextEncoding for the font
+    rtl_TextEncoding m_eRTLFontSrcCharSet;    // rtl_TextEncoding for the font
+    rtl_TextEncoding m_eCJKFontSrcCharSet;    // rtl_TextEncoding for the font
+    SwFormat*      m_pFormat;
+    WW8FlyPara* m_pWWFly;
+    SwNumRule*  m_pOutlineNumrule;
+    long        m_nFilePos;
+    sal_uInt16      m_nBase;
+    sal_uInt16      m_nFollow;
+    sal_uInt16      m_nLFOIndex;
+    sal_uInt8        m_nListLevel;
 
     // WW8 outline level is zero-based:
     // 0: outline level 1
@@ -238,95 +238,95 @@ public:
     // 9: body text
     sal_uInt8 mnWW8OutlineLevel;
 
-    sal_uInt16  n81Flags;           // for bold, italic, ...
-    sal_uInt16  n81BiDiFlags;       // for bold, italic, ...
+    sal_uInt16  m_n81Flags;           // for bold, italic, ...
+    sal_uInt16  m_n81BiDiFlags;       // for bold, italic, ...
     SvxLRSpaceItem maWordLR;
-    bool bValid;            // empty of valid
-    bool bImported;         // for recursive imports
-    bool bColl;             // true-> pFormat is SwTextFormatColl
-    bool bImportSkipped;    // only true if !bNewDoc && existing style
-    bool bHasStyNumRule;    // true-> named NumRule in style
-    bool bHasBrokenWW6List; // true-> WW8+ style has a WW7- list
-    bool bListReleventIndentSet; //true if this style's indent has
+    bool m_bValid;            // empty of valid
+    bool m_bImported;         // for recursive imports
+    bool m_bColl;             // true-> pFormat is SwTextFormatColl
+    bool m_bImportSkipped;    // only true if !bNewDoc && existing style
+    bool m_bHasStyNumRule;    // true-> named NumRule in style
+    bool m_bHasBrokenWW6List; // true-> WW8+ style has a WW7- list
+    bool m_bListReleventIndentSet; //true if this style's indent has
                                  //been explicitly set, it's set to the value
                                  //of pFormat->GetItemState(RES_LR_SPACE, false)
                                  //if it was possible to get the ItemState
                                  //for L of the LR space independently
-    bool bParaAutoBefore;   // For Auto spacing before a paragraph
-    bool bParaAutoAfter;    // For Auto Spacing after a paragraph
+    bool m_bParaAutoBefore;   // For Auto spacing before a paragraph
+    bool m_bParaAutoAfter;    // For Auto Spacing after a paragraph
 
     SwWW8StyInf() :
-        sWWStyleName( OUString() ),
-        nWWStyleId( 0 ),
-        eLTRFontSrcCharSet(0),
-        eRTLFontSrcCharSet(0),
-        eCJKFontSrcCharSet(0),
-        pFormat( nullptr ),
-        pWWFly( nullptr ),
-        pOutlineNumrule( nullptr ),
-        nFilePos( 0 ),
-        nBase( 0 ),
-        nFollow( 0 ),
-        nLFOIndex( USHRT_MAX ),
-        nListLevel(WW8ListManager::nMaxLevel),
+        m_sWWStyleName( OUString() ),
+        m_nWWStyleId( 0 ),
+        m_eLTRFontSrcCharSet(0),
+        m_eRTLFontSrcCharSet(0),
+        m_eCJKFontSrcCharSet(0),
+        m_pFormat( nullptr ),
+        m_pWWFly( nullptr ),
+        m_pOutlineNumrule( nullptr ),
+        m_nFilePos( 0 ),
+        m_nBase( 0 ),
+        m_nFollow( 0 ),
+        m_nLFOIndex( USHRT_MAX ),
+        m_nListLevel(WW8ListManager::nMaxLevel),
         mnWW8OutlineLevel( MAXLEVEL ),
-        n81Flags( 0 ),
-        n81BiDiFlags(0),
+        m_n81Flags( 0 ),
+        m_n81BiDiFlags(0),
         maWordLR( RES_LR_SPACE ),
-        bValid(false),
-        bImported(false),
-        bColl(false),
-        bImportSkipped(false),
-        bHasStyNumRule(false),
-        bHasBrokenWW6List(false),
-        bListReleventIndentSet(false),
-        bParaAutoBefore(false),
-        bParaAutoAfter(false)
+        m_bValid(false),
+        m_bImported(false),
+        m_bColl(false),
+        m_bImportSkipped(false),
+        m_bHasStyNumRule(false),
+        m_bHasBrokenWW6List(false),
+        m_bListReleventIndentSet(false),
+        m_bParaAutoBefore(false),
+        m_bParaAutoAfter(false)
 
     {}
 
     ~SwWW8StyInf()
     {
-        delete pWWFly;
+        delete m_pWWFly;
     }
 
     void SetOrgWWIdent( const OUString& rName, const sal_uInt16 nId )
     {
-        sWWStyleName = rName;
-        nWWStyleId = nId;
+        m_sWWStyleName = rName;
+        m_nWWStyleId = nId;
 
         // apply default WW8 outline level to WW8 Built-in Heading styles
         if (IsWW8BuiltInHeadingStyle())
         {
-            mnWW8OutlineLevel = nWWStyleId - 1;
+            mnWW8OutlineLevel = m_nWWStyleId - 1;
         }
     }
 
     const OUString& GetOrgWWName() const
     {
-        return sWWStyleName;
+        return m_sWWStyleName;
     }
 
     bool HasWW8OutlineLevel() const
     {
-        return (pFormat != nullptr && (MAXLEVEL > mnWW8OutlineLevel));
+        return (m_pFormat != nullptr && (MAXLEVEL > mnWW8OutlineLevel));
     }
 
     bool IsOutlineNumbered() const
     {
-        return pOutlineNumrule && HasWW8OutlineLevel();
+        return m_pOutlineNumrule && HasWW8OutlineLevel();
     }
 
     const SwNumRule* GetOutlineNumrule() const
     {
-        return pOutlineNumrule;
+        return m_pOutlineNumrule;
     }
     rtl_TextEncoding GetCharSet() const;
     rtl_TextEncoding GetCJKCharSet() const;
 
     sal_uInt16 GetWWStyleId() const
     {
-        return nWWStyleId;
+        return m_nWWStyleId;
     }
 
     bool IsWW8BuiltInHeadingStyle() const
diff --git a/sw/source/filter/ww8/ww8par2.cxx b/sw/source/filter/ww8/ww8par2.cxx
index f774d41280a7..7f692bc8561b 100644
--- a/sw/source/filter/ww8/ww8par2.cxx
+++ b/sw/source/filter/ww8/ww8par2.cxx
@@ -477,7 +477,7 @@ ApoTestResults SwWW8ImplReader::TestApo(int nCellLevel, bool bTableRowEnd,
     // Frame in Style Definition (word appears to ignore them if inside an
     // text autoshape)
     if (!m_bTxbxFlySection && m_nAktColl < m_vColl.size())
-        aRet.mpStyleApo = StyleExists(m_nAktColl) ? m_vColl[m_nAktColl].pWWFly : nullptr;
+        aRet.mpStyleApo = StyleExists(m_nAktColl) ? m_vColl[m_nAktColl].m_pWWFly : nullptr;
 
     /*
     #i1140#
@@ -783,7 +783,7 @@ void SwWW8ImplReader::Read_ANLevelNo( sal_uInt16, const sal_uInt8* pData, short
         // only for SwTextFormatColl, not CharFormat
         // WW: 0 = no Numbering
         SwWW8StyInf * pColl = GetStyle(m_nAktColl);
-        if (pColl != nullptr && pColl->bColl && *pData)
+        if (pColl != nullptr && pColl->m_bColl && *pData)
         {
             // Range WW:1..9 -> SW:0..8 no bullets / numbering
 
@@ -818,7 +818,7 @@ void SwWW8ImplReader::Read_ANLevelDesc( sal_uInt16, const sal_uInt8* pData, shor
 {
     SwWW8StyInf * pStyInf = GetStyle(m_nAktColl);
     if( !m_pAktColl || nLen <= 0                       // only for Styledef
-        || (pStyInf && !pStyInf->bColl)              // ignore  CharFormat ->
+        || (pStyInf && !pStyInf->m_bColl)              // ignore  CharFormat ->
         || ( m_nIniFlags & WW8FL_NO_OUTLINE ) )
     {
         m_nSwNumLevel = 0xff;
@@ -848,7 +848,7 @@ void SwWW8ImplReader::Read_ANLevelDesc( sal_uInt16, const sal_uInt8* pData, shor
 
         pStyInf = GetStyle(m_nAktColl);
         if (pStyInf != nullptr)
-            pStyInf->bHasStyNumRule = true;
+            pStyInf->m_bHasStyNumRule = true;
     }
 }
 
@@ -956,9 +956,9 @@ void SwWW8ImplReader::StartAnl(const sal_uInt8* pSprm13)
     }
 
     SwWW8StyInf * pStyInf = GetStyle(m_nAktColl);
-    if (sNumRule.isEmpty() && pStyInf != nullptr &&  pStyInf->bHasStyNumRule)
+    if (sNumRule.isEmpty() && pStyInf != nullptr &&  pStyInf->m_bHasStyNumRule)
     {
-        sNumRule = pStyInf->pFormat->GetNumRule().GetValue();
+        sNumRule = pStyInf->m_pFormat->GetNumRule().GetValue();
         pNumRule = m_rDoc.FindNumRulePtr(sNumRule);
         if (!pNumRule)
             sNumRule.clear();
@@ -3527,8 +3527,8 @@ sal_uInt16 SwWW8ImplReader::StyleUsingLFO( sal_uInt16 nLFOIndex ) const
     if( !m_vColl.empty() )
     {
         for(sal_uInt16 nI = 0; nI < m_pStyles->GetCount(); nI++ )
-            if(    m_vColl[ nI ].bValid
-                && (nLFOIndex == m_vColl[ nI ].nLFOIndex) )
+            if(    m_vColl[ nI ].m_bValid
+                && (nLFOIndex == m_vColl[ nI ].m_nLFOIndex) )
                 nRes = nI;
     }
     return nRes;
@@ -3540,10 +3540,10 @@ const SwFormat* SwWW8ImplReader::GetStyleWithOrgWWName( OUString& rName ) const
     if( !m_vColl.empty() )
     {
         for(sal_uInt16 nI = 0; nI < m_pStyles->GetCount(); nI++ )
-            if(    m_vColl[ nI ].bValid
+            if(    m_vColl[ nI ].m_bValid
                 && (rName.equals( m_vColl[ nI ].GetOrgWWName())) )
             {
-                pRet = m_vColl[ nI ].pFormat;
+                pRet = m_vColl[ nI ].m_pFormat;
                 break;
             }
     }
@@ -3743,7 +3743,7 @@ bool WW8RStyle::PrepareStyle(SwWW8StyInf &rSI, ww::sti eSti, sal_uInt16 nThisSty
     SwFormat* pColl;
     bool bStyExist;
 
-    if (rSI.bColl)
+    if (rSI.m_bColl)
     {
         // Para-Style
         sw::util::ParaStyleMapper::StyleResult aResult =
@@ -3767,7 +3767,7 @@ bool WW8RStyle::PrepareStyle(SwWW8StyInf &rSI, ww::sti eSti, sal_uInt16 nThisSty
         bImport = false;
 
     bool bOldNoImp = pIo->m_bNoAttrImport;
-    rSI.bImportSkipped = !bImport;
+    rSI.m_bImportSkipped = !bImport;
 
     if( !bImport )
         pIo->m_bNoAttrImport = true;
@@ -3780,37 +3780,37 @@ bool WW8RStyle::PrepareStyle(SwWW8StyInf &rSI, ww::sti eSti, sal_uInt16 nThisSty
         pColl->SetAuto(false);          // suggested by JP
     }                                   // but changes the UI
     pIo->m_pAktColl = pColl;
-    rSI.pFormat = pColl;                  // remember translation WW->SW
-    rSI.bImportSkipped = !bImport;
+    rSI.m_pFormat = pColl;                  // remember translation WW->SW
+    rSI.m_bImportSkipped = !bImport;
 
     // Set Based on style
-    sal_uInt16 j = rSI.nBase;
+    sal_uInt16 j = rSI.m_nBase;
     if (j != nThisStyle && j < cstd )
     {
         SwWW8StyInf* pj = &pIo->m_vColl[j];
-        if (rSI.pFormat && pj->pFormat && rSI.bColl == pj->bColl)
+        if (rSI.m_pFormat && pj->m_pFormat && rSI.m_bColl == pj->m_bColl)
         {
-            rSI.pFormat->SetDerivedFrom( pj->pFormat );  // ok, set Based on
-            rSI.eLTRFontSrcCharSet = pj->eLTRFontSrcCharSet;
-            rSI.eRTLFontSrcCharSet = pj->eRTLFontSrcCharSet;
-            rSI.eCJKFontSrcCharSet = pj->eCJKFontSrcCharSet;
-            rSI.n81Flags = pj->n81Flags;
-            rSI.n81BiDiFlags = pj->n81BiDiFlags;
+            rSI.m_pFormat->SetDerivedFrom( pj->m_pFormat );  // ok, set Based on
+            rSI.m_eLTRFontSrcCharSet = pj->m_eLTRFontSrcCharSet;
+            rSI.m_eRTLFontSrcCharSet = pj->m_eRTLFontSrcCharSet;
+            rSI.m_eCJKFontSrcCharSet = pj->m_eCJKFontSrcCharSet;
+            rSI.m_n81Flags = pj->m_n81Flags;
+            rSI.m_n81BiDiFlags = pj->m_n81BiDiFlags;
             if (!rSI.IsWW8BuiltInHeadingStyle())
             {
                 rSI.mnWW8OutlineLevel = pj->mnWW8OutlineLevel;
             }
-            rSI.bParaAutoBefore = pj->bParaAutoBefore;
-            rSI.bParaAutoAfter = pj->bParaAutoAfter;
+            rSI.m_bParaAutoBefore = pj->m_bParaAutoBefore;
+            rSI.m_bParaAutoAfter = pj->m_bParaAutoAfter;
 
-            if (pj->pWWFly)
-                rSI.pWWFly = new WW8FlyPara(pIo->m_bVer67, pj->pWWFly);
+            if (pj->m_pWWFly)
+                rSI.m_pWWFly = new WW8FlyPara(pIo->m_bVer67, pj->m_pWWFly);
         }
     }
     else if( pIo->m_bNewDoc && bStyExist )
-        rSI.pFormat->SetDerivedFrom();
+        rSI.m_pFormat->SetDerivedFrom();
 
-    rSI.nFollow = nNextStyle;       // remember Follow
+    rSI.m_nFollow = nNextStyle;       // remember Follow
 
     pStyRule = nullptr;                   // recreate if necessary
     bTextColChanged = bFontChanged = bCJKFontChanged = bCTLFontChanged =
@@ -3828,7 +3828,7 @@ void WW8RStyle::PostStyle(SwWW8StyInf &rSI, bool bOldNoImp)
     pIo->m_nCharFormat = -1;
 
     // If Style basiert auf Nichts oder Basis ignoriert
-    if ((rSI.nBase >= cstd || pIo->m_vColl[rSI.nBase].bImportSkipped) && rSI.bColl)
+    if ((rSI.m_nBase >= cstd || pIo->m_vColl[rSI.m_nBase].m_bImportSkipped) && rSI.m_bColl)
     {
         // If Char-Styles does not work
         // -> set hard WW-Defaults
@@ -3851,17 +3851,17 @@ void WW8RStyle::Import1Style( sal_uInt16 nNr )
 
     SwWW8StyInf &rSI = pIo->m_vColl[nNr];
 
-    if( rSI.bImported || !rSI.bValid )
+    if( rSI.m_bImported || !rSI.m_bValid )
         return;
 
-    rSI.bImported = true;                      // set flag now to avoid endless loops
+    rSI.m_bImported = true;                      // set flag now to avoid endless loops
 
     // valid and not NUL and not yet imported
 
-    if( rSI.nBase < cstd && !pIo->m_vColl[rSI.nBase].bImported )
-        Import1Style( rSI.nBase );
+    if( rSI.m_nBase < cstd && !pIo->m_vColl[rSI.m_nBase].m_bImported )
+        Import1Style( rSI.m_nBase );
 
-    pStStrm->Seek( rSI.nFilePos );
+    pStStrm->Seek( rSI.m_nFilePos );
 
     short nSkip, cbStd;
     OUString sName;
@@ -3891,7 +3891,7 @@ void WW8RStyle::Import1Style( sal_uInt16 nNr )
     //offset
 
     //Import of the Style Contents
-    ImportGrupx(nSkip, xStd->sgc == 1, rSI.nFilePos & 1);
+    ImportGrupx(nSkip, xStd->sgc == 1, rSI.m_nFilePos & 1);
 
     PostStyle(rSI, bOldNoImp);
 
@@ -3904,13 +3904,13 @@ void WW8RStyle::RecursiveReg(sal_uInt16 nNr)
         return;
 
     SwWW8StyInf &rSI = pIo->m_vColl[nNr];
-    if( rSI.bImported || !rSI.bValid )
+    if( rSI.m_bImported || !rSI.m_bValid )
         return;
 
-    rSI.bImported = true;
+    rSI.m_bImported = true;
 
-    if( rSI.nBase < cstd && !pIo->m_vColl[rSI.nBase].bImported )
-        RecursiveReg(rSI.nBase);
+    if( rSI.m_nBase < cstd && !pIo->m_vColl[rSI.m_nBase].m_bImported )
+        RecursiveReg(rSI.m_nBase);
 
     pIo->RegisterNumFormatOnStyle(nNr);
 
@@ -3929,7 +3929,7 @@ void WW8RStyle::PostProcessStyles()
      formats and use it to mark handled ones
     */
     for (i=0; i < cstd; ++i)
-        pIo->m_vColl[i].bImported = false;
+        pIo->m_vColl[i].m_bImported = false;
 
     /*
      Register the num formats and tabstop changes on the styles recursively.
@@ -3944,7 +3944,7 @@ void WW8RStyle::PostProcessStyles()
     */
     for (i=0; i < cstd; ++i)
     {
-        if (pIo->m_vColl[i].bValid)
+        if (pIo->m_vColl[i].m_bValid)
         {
             RecursiveReg(i);
         }
@@ -3958,13 +3958,13 @@ void WW8RStyle::ScanStyles()        // investigate style dependencies
         short nSkip;
         SwWW8StyInf &rSI = pIo->m_vColl[i];
 
-        rSI.nFilePos = pStStrm->Tell();        // remember FilePos
+        rSI.m_nFilePos = pStStrm->Tell();        // remember FilePos
         WW8_STD* pStd = Read1Style( nSkip, nullptr, nullptr );  // read STD
-        rSI.bValid = (nullptr != pStd);
-        if (rSI.bValid)
+        rSI.m_bValid = (nullptr != pStd);
+        if (rSI.m_bValid)
         {
-            rSI.nBase = pStd->istdBase;        // remember Basis
-            rSI.bColl = ( pStd->sgc == 1 );    // Para-Style
+            rSI.m_nBase = pStd->istdBase;        // remember Basis
+            rSI.m_bColl = ( pStd->sgc == 1 );    // Para-Style
         }
         else
             rSI = SwWW8StyInf();
@@ -4213,9 +4213,9 @@ void WW8RStyle::ImportOldFormatStyles()
 {
     for (sal_uInt16 i=0; i < cstd; ++i)
     {
-        pIo->m_vColl[i].bColl = true;
+        pIo->m_vColl[i].m_bColl = true;
         //every chain must end eventually at the null style (style code 222)
-        pIo->m_vColl[i].nBase = 222;
+        pIo->m_vColl[i].m_nBase = 222;
     }
 
     rtl_TextEncoding eStructChrSet = WW8Fib::GetFIBCharset(
@@ -4256,7 +4256,7 @@ void WW8RStyle::ImportOldFormatStyles()
                 nByteCount += aTmp.getLength();
                 sName = OStringToOUString(aTmp, eStructChrSet);
             }
-            rSI.bImported = true;
+            rSI.m_bImported = true;
         }
 
         if (sName.isEmpty())
@@ -4389,7 +4389,7 @@ void WW8RStyle::ImportOldFormatStyles()
             stcBase = 222;
 
         SwWW8StyInf &rSI = pIo->m_vColl[stc];
-        rSI.nBase = stcBase;
+        rSI.m_nBase = stcBase;
 
         ww::sti eSti = ww::GetCanonicalStiFromStc(stc);
 
@@ -4399,10 +4399,10 @@ void WW8RStyle::ImportOldFormatStyles()
         if (stcp >= aPAPXOffsets.size())
             continue;
 
-        rSI.bValid = true;
+        rSI.m_bValid = true;
 
         if (ww::StandardStiIsCharStyle(eSti) && !aPAPXOffsets[stcp].mnSize)
-            pIo->m_vColl[stc].bColl = false;
+            pIo->m_vColl[stc].m_bColl = false;
 
         bool bOldNoImp = PrepareStyle(rSI, eSti, stc, stcNext);
 
@@ -4423,7 +4423,7 @@ void WW8RStyle::ImportNewFormatStyles()
     ScanStyles();                       // Scan Based On
 
     for (sal_uInt16 i = 0; i < cstd; ++i) // import Styles
-        if (pIo->m_vColl[i].bValid)
+        if (pIo->m_vColl[i].m_bValid)
             Import1Style( i );
 }
 
@@ -4450,17 +4450,17 @@ void WW8RStyle::Import()
     {
         // Follow chain
         SwWW8StyInf* pi = &pIo->m_vColl[i];
-        sal_uInt16 j = pi->nFollow;
+        sal_uInt16 j = pi->m_nFollow;
         if( j < cstd )
         {
             SwWW8StyInf* pj = &pIo->m_vColl[j];
             if ( j != i                             // rational Index ?
-                 && pi->pFormat                        // Format ok ?
-                 && pj->pFormat                        // Derived-Format ok ?
-                 && pi->bColl                       // only possible for paragraph templates (WW)
-                 && pj->bColl ){                    // identical Typ ?
-                    static_cast<SwTextFormatColl*>(pi->pFormat)->SetNextTextFormatColl(
-                     *static_cast<SwTextFormatColl*>(pj->pFormat) );    // ok, register
+                 && pi->m_pFormat                        // Format ok ?
+                 && pj->m_pFormat                        // Derived-Format ok ?
+                 && pi->m_bColl                       // only possible for paragraph templates (WW)
+                 && pj->m_bColl ){                    // identical Typ ?
+                    static_cast<SwTextFormatColl*>(pi->m_pFormat)->SetNextTextFormatColl(
+                     *static_cast<SwTextFormatColl*>(pj->m_pFormat) );    // ok, register
             }
         }
     }
@@ -4475,8 +4475,8 @@ void WW8RStyle::Import()
     // for e.g. tables an always valid Std-Style is necessary
 
     if( pIo->StyleExists(0) && !pIo->m_vColl.empty() &&
-        pIo->m_vColl[0].pFormat && pIo->m_vColl[0].bColl && pIo->m_vColl[0].bValid )
-        pIo->m_pDfltTextFormatColl = static_cast<SwTextFormatColl*>(pIo->m_vColl[0].pFormat);
+        pIo->m_vColl[0].m_pFormat && pIo->m_vColl[0].m_bColl && pIo->m_vColl[0].m_bValid )
+        pIo->m_pDfltTextFormatColl = static_cast<SwTextFormatColl*>(pIo->m_vColl[0].m_pFormat);
     else
         pIo->m_pDfltTextFormatColl = pIo->m_rDoc.GetDfltTextFormatColl();
 
@@ -4514,16 +4514,16 @@ void WW8RStyle::Import()
 
 rtl_TextEncoding SwWW8StyInf::GetCharSet() const
 {
-    if ((pFormat) && (pFormat->GetFrmDir().GetValue() == FRMDIR_HORI_RIGHT_TOP))
-        return eRTLFontSrcCharSet;
-    return eLTRFontSrcCharSet;
+    if ((m_pFormat) && (m_pFormat->GetFrmDir().GetValue() == FRMDIR_HORI_RIGHT_TOP))
+        return m_eRTLFontSrcCharSet;
+    return m_eLTRFontSrcCharSet;
 }
 
 rtl_TextEncoding SwWW8StyInf::GetCJKCharSet() const
 {
-    if ((pFormat) && (pFormat->GetFrmDir().GetValue() == FRMDIR_HORI_RIGHT_TOP))
-        return eRTLFontSrcCharSet;
-    return eCJKFontSrcCharSet;
+    if ((m_pFormat) && (m_pFormat->GetFrmDir().GetValue() == FRMDIR_HORI_RIGHT_TOP))
+        return m_eRTLFontSrcCharSet;
+    return m_eCJKFontSrcCharSet;
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/filter/ww8/ww8par3.cxx b/sw/source/filter/ww8/ww8par3.cxx
index 6d7750b0a8e0..b08071a9fa13 100644
--- a/sw/source/filter/ww8/ww8par3.cxx
+++ b/sw/source/filter/ww8/ww8par3.cxx
@@ -1675,9 +1675,9 @@ bool SwWW8ImplReader::SetTextFormatCollAndListLevel(const SwPaM& rRg,
     SwWW8StyInf& rStyleInfo)
 {
     bool bRes = true;
-    if( rStyleInfo.pFormat && rStyleInfo.bColl )
+    if( rStyleInfo.m_pFormat && rStyleInfo.m_bColl )
     {
-        bRes = m_rDoc.SetTextFormatColl(rRg, static_cast<SwTextFormatColl*>(rStyleInfo.pFormat));
+        bRes = m_rDoc.SetTextFormatColl(rRg, static_cast<SwTextFormatColl*>(rStyleInfo.m_pFormat));
         SwTextNode* pTextNode = m_pPaM->GetNode().GetTextNode();
         OSL_ENSURE( pTextNode, "No Text-Node at PaM-Position" );
         if ( !pTextNode )
@@ -1694,11 +1694,11 @@ bool SwWW8ImplReader::SetTextFormatCollAndListLevel(const SwPaM& rRg,
             pTextNode->ResetAttr( RES_PARATR_NUMRULE );
         }
 
-        if (USHRT_MAX > rStyleInfo.nLFOIndex && WW8ListManager::nMaxLevel
-                                                > rStyleInfo.nListLevel)
+        if (USHRT_MAX > rStyleInfo.m_nLFOIndex && WW8ListManager::nMaxLevel
+                                                > rStyleInfo.m_nListLevel)
         {
             const bool bApplyListStyle = false;
-            RegisterNumFormatOnTextNode(rStyleInfo.nLFOIndex, rStyleInfo.nListLevel,
+            RegisterNumFormatOnTextNode(rStyleInfo.m_nLFOIndex, rStyleInfo.m_nListLevel,
                                     bApplyListStyle);
         }
     }
@@ -1712,11 +1712,11 @@ void UseListIndent(SwWW8StyInf &rStyle, const SwNumFormat &rFormat)
     {
         const long nAbsLSpace = rFormat.GetAbsLSpace();
         const long nListFirstLineIndent = GetListFirstLineIndent(rFormat);
-        SvxLRSpaceItem aLR(ItemGet<SvxLRSpaceItem>(*rStyle.pFormat, RES_LR_SPACE));
+        SvxLRSpaceItem aLR(ItemGet<SvxLRSpaceItem>(*rStyle.m_pFormat, RES_LR_SPACE));
         aLR.SetTextLeft(nAbsLSpace);
         aLR.SetTextFirstLineOfst(writer_cast<short>(nListFirstLineIndent));
-        rStyle.pFormat->SetFormatAttr(aLR);
-        rStyle.bListReleventIndentSet = true;
+        rStyle.m_pFormat->SetFormatAttr(aLR);
+        rStyle.m_bListReleventIndentSet = true;
     }
 }
 
@@ -1724,8 +1724,8 @@ void SetStyleIndent(SwWW8StyInf &rStyle, const SwNumFormat &rFormat)
 {
     if ( rFormat.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) // #i86652#
     {
-        SvxLRSpaceItem aLR(ItemGet<SvxLRSpaceItem>(*rStyle.pFormat, RES_LR_SPACE));
-        if (rStyle.bListReleventIndentSet)
+        SvxLRSpaceItem aLR(ItemGet<SvxLRSpaceItem>(*rStyle.m_pFormat, RES_LR_SPACE));
+        if (rStyle.m_bListReleventIndentSet)
         {
 
             SyncIndentWithList( aLR, rFormat, false, false ); // #i103711#, #i105414#
@@ -1735,7 +1735,7 @@ void SetStyleIndent(SwWW8StyInf &rStyle, const SwNumFormat &rFormat)
             aLR.SetTextLeft(0);
             aLR.SetTextFirstLineOfst(0);
         }
-        rStyle.pFormat->SetFormatAttr(aLR);
+        rStyle.m_pFormat->SetFormatAttr(aLR);
     }
 }
 
@@ -1746,7 +1746,7 @@ void SwWW8ImplReader::SetStylesList(sal_uInt16 nStyle, sal_uInt16 nActLFO,
         return;
 
     SwWW8StyInf &rStyleInf = m_vColl[nStyle];
-    if (rStyleInf.bValid)
+    if (rStyleInf.m_bValid)
     {
         OSL_ENSURE(m_pAktColl, "Cannot be called outside of style import");
         // Phase 1: Nummerierungsattribute beim Einlesen einer StyleDef
@@ -1759,8 +1759,8 @@ void SwWW8ImplReader::SetStylesList(sal_uInt16 nStyle, sal_uInt16 nActLFO,
                  (WW8ListManager::nMaxLevel > nActLevel)
                )
             {
-                rStyleInf.nLFOIndex  = nActLFO;
-                rStyleInf.nListLevel = nActLevel;
+                rStyleInf.m_nLFOIndex  = nActLFO;
+                rStyleInf.m_nListLevel = nActLevel;
 
                 if (
                     (USHRT_MAX > nActLFO) &&
@@ -1786,16 +1786,16 @@ void SwWW8ImplReader::RegisterNumFormatOnStyle(sal_uInt16 nStyle)
         return;
 
     SwWW8StyInf &rStyleInf = m_vColl[nStyle];
-    if (rStyleInf.bValid && rStyleInf.pFormat)
+    if (rStyleInf.m_bValid && rStyleInf.m_pFormat)
     {
         //Save old pre-list modified indent, which are the word indent values
         rStyleInf.maWordLR =
-            ItemGet<SvxLRSpaceItem>(*rStyleInf.pFormat, RES_LR_SPACE);
+            ItemGet<SvxLRSpaceItem>(*rStyleInf.m_pFormat, RES_LR_SPACE);
 
         // Phase 2: aktualisieren der StyleDef nach einlesen aller Listen
         SwNumRule* pNmRule = nullptr;
-        const sal_uInt16 nLFO = rStyleInf.nLFOIndex;
-        const sal_uInt8  nLevel = rStyleInf.nListLevel;
+        const sal_uInt16 nLFO = rStyleInf.m_nLFOIndex;
+        const sal_uInt8  nLevel = rStyleInf.m_nListLevel;
         if (
              (USHRT_MAX > nLFO) &&
              (WW8ListManager::nMaxLevel > nLevel)
@@ -1810,13 +1810,13 @@ void SwWW8ImplReader::RegisterNumFormatOnStyle(sal_uInt16 nStyle)
                 if (rStyleInf.IsWW8BuiltInHeadingStyle()
                     && rStyleInf.HasWW8OutlineLevel())
                 {
-                    rStyleInf.pOutlineNumrule = pNmRule;
+                    rStyleInf.m_pOutlineNumrule = pNmRule;
                 }
                 else
                 {
-                    rStyleInf.pFormat->SetFormatAttr(
+                    rStyleInf.m_pFormat->SetFormatAttr(
                         SwNumRuleItem(pNmRule->GetName()));
-                    rStyleInf.bHasStyNumRule = true;
+                    rStyleInf.m_bHasStyNumRule = true;
                 }
             }
         }
@@ -2056,7 +2056,7 @@ void SwWW8ImplReader::Read_LFOPosition(sal_uInt16, const sal_uInt8* pData,
             braindeadness
             */
             if (m_pAktColl && (m_nLFOPosition == 2047-1) && m_nAktColl < m_vColl.size())
-                m_vColl[m_nAktColl].bHasBrokenWW6List = true;
+                m_vColl[m_nAktColl].m_bHasBrokenWW6List = true;
 
             // die Streamdaten sind hier 1 basiert, wir ziehen EINS ab
             if (USHRT_MAX > m_nLFOPosition)
diff --git a/sw/source/filter/ww8/ww8par6.cxx b/sw/source/filter/ww8/ww8par6.cxx
index 2d88ac7464eb..092c694124df 100644
--- a/sw/source/filter/ww8/ww8par6.cxx
+++ b/sw/source/filter/ww8/ww8par6.cxx
@@ -270,10 +270,10 @@ void SwWW8ImplReader::SetDocumentGrid(SwFrameFormat &rFormat, const wwSection &r
     sal_uInt32 nCharWidth=240;
     for (sal_uInt16 nI = 0; nI < m_pStyles->GetCount(); ++nI)
     {
-        if (m_vColl[nI].bValid && m_vColl[nI].pFormat &&
+        if (m_vColl[nI].m_bValid && m_vColl[nI].m_pFormat &&
             m_vColl[nI].IsWW8BuiltInDefaultStyle())
         {
-            nCharWidth = ItemGet<SvxFontHeightItem>(*(m_vColl[nI].pFormat),
+            nCharWidth = ItemGet<SvxFontHeightItem>(*(m_vColl[nI].m_pFormat),
                 RES_CHRATR_CJK_FONTSIZE).GetHeight();
             break;
         }
@@ -1656,9 +1656,9 @@ void WW8FlyPara::ReadFull(sal_uInt8 nOrigSp29, SwWW8ImplReader* pIo)
             WW8FlyPara *pNowStyleApo=nullptr;
             sal_uInt16 nColl = pPap->GetIstd();
             ww::sti eSti = eVer < ww::eWW6 ? ww::GetCanonicalStiFromStc( static_cast< sal_uInt8 >(nColl) ) : static_cast<ww::sti>(nColl);
-            while (eSti != ww::stiNil && nColl < pIo->m_vColl.size() && nullptr == (pNowStyleApo = pIo->m_vColl[nColl].pWWFly))
+            while (eSti != ww::stiNil && nColl < pIo->m_vColl.size() && nullptr == (pNowStyleApo = pIo->m_vColl[nColl].m_pWWFly))
             {
-                nColl = pIo->m_vColl[nColl].nBase;
+                nColl = pIo->m_vColl[nColl].m_nBase;
                 eSti = eVer < ww::eWW6 ? ww::GetCanonicalStiFromStc( static_cast< sal_uInt8 >(nColl) ) : static_cast<ww::sti>(nColl);
             }
 
@@ -2681,10 +2681,10 @@ const SfxPoolItem* SwWW8ImplReader::GetFormatAttr( sal_uInt16 nWhich )
         pRet = m_pCtrlStck->GetStackAttr(*m_pPaM->GetPoint(), nWhich);
         if (!pRet)
         {
-            if (m_nAktColl < m_vColl.size() && m_vColl[m_nAktColl].pFormat &&
-                m_vColl[m_nAktColl].bColl)
+            if (m_nAktColl < m_vColl.size() && m_vColl[m_nAktColl].m_pFormat &&
+                m_vColl[m_nAktColl].m_bColl)
             {
-                pRet = &(m_vColl[m_nAktColl].pFormat->GetFormatAttr(nWhich));
+                pRet = &(m_vColl[m_nAktColl].m_pFormat->GetFormatAttr(nWhich));
             }
         }
         if (!pRet)
@@ -2901,17 +2901,17 @@ void SwWW8ImplReader::Read_BoldUsw( sal_uInt16 nId, const sal_uInt8* pData, shor
         {
             // The style based on has Bit 7 set ?
             if (
-                pSI->nBase < m_vColl.size() && (*pData & 0x80) &&
-                (m_vColl[pSI->nBase].n81Flags & nMask)
+                pSI->m_nBase < m_vColl.size() && (*pData & 0x80) &&
+                (m_vColl[pSI->m_nBase].m_n81Flags & nMask)
                )
             {
                 bOn = !bOn;                     // invert
             }
 
             if (bOn)
-                pSI->n81Flags |= nMask;         // set flag
+                pSI->m_n81Flags |= nMask;         // set flag
             else
-                pSI->n81Flags &= ~nMask;        // delete flag
+                pSI->m_n81Flags &= ~nMask;        // delete flag
        }
     }
     else
@@ -2920,7 +2920,7 @@ void SwWW8ImplReader::Read_BoldUsw( sal_uInt16 nId, const sal_uInt8* pData, shor
         // in text -> look at flags
         if( *pData & 0x80 )                 // bit 7 set?
         {
-            if (pSI && pSI->n81Flags & nMask)       // and in StyleDef at ?
+            if (pSI && pSI->m_n81Flags & nMask)       // and in StyleDef at ?
                 bOn = !bOn;                 // then invert
             // remember on stack that this is a toggle-attribute
             m_pCtrlStck->SetToggleAttr(nI, true);
@@ -2989,15 +2989,15 @@ void SwWW8ImplReader::Read_BoldBiDiUsw(sal_uInt16 nId, const sal_uInt8* pData,
     {
         if (pSI)
         {
-            if( pSI->nBase < m_vColl.size()             // Style Based on
+            if( pSI->m_nBase < m_vColl.size()             // Style Based on
                 && ( *pData & 0x80 )            // bit 7 set?
-                && ( m_vColl[pSI->nBase].n81BiDiFlags & nMask ) ) // base mask?
+                && ( m_vColl[pSI->m_nBase].m_n81BiDiFlags & nMask ) ) // base mask?
                     bOn = !bOn;                     // invert
 
             if( bOn )
-                pSI->n81BiDiFlags |= nMask;         // set flag
+                pSI->m_n81BiDiFlags |= nMask;         // set flag
             else
-                pSI->n81BiDiFlags &= ~nMask;        // delete flag
+                pSI->m_n81BiDiFlags &= ~nMask;        // delete flag
         }
     }
     else
@@ -3006,7 +3006,7 @@ void SwWW8ImplReader::Read_BoldBiDiUsw(sal_uInt16 nId, const sal_uInt8* pData,
         // in text -> look at flags
         if (*pData & 0x80)                  // Bit 7 set?
         {
-            if (pSI && pSI->n81BiDiFlags & nMask) // and in StyleDef at ?
+            if (pSI && pSI->m_n81BiDiFlags & nMask) // and in StyleDef at ?
                 bOn = !bOn;                     // then invert
             // remember on stack that this is a toggle-attribute
             m_pCtrlStck->SetToggleBiDiAttr(nI, true);
@@ -3561,13 +3561,13 @@ bool SwWW8ImplReader::SetNewFontAttr(sal_uInt16 nFCode, bool bSetEnums,
             {
                 default:
                 case RES_CHRATR_FONT:
-                    m_vColl[m_nAktColl].eLTRFontSrcCharSet = eSrcCharSet;
+                    m_vColl[m_nAktColl].m_eLTRFontSrcCharSet = eSrcCharSet;
                     break;
                 case RES_CHRATR_CTL_FONT:
-                    m_vColl[m_nAktColl].eRTLFontSrcCharSet = eSrcCharSet;
+                    m_vColl[m_nAktColl].m_eRTLFontSrcCharSet = eSrcCharSet;
                     break;
                 case RES_CHRATR_CJK_FONT:
-                    m_vColl[m_nAktColl].eCJKFontSrcCharSet = eSrcCharSet;
+                    m_vColl[m_nAktColl].m_eCJKFontSrcCharSet = eSrcCharSet;
                     break;
             }
         }
@@ -3793,8 +3793,8 @@ void SwWW8ImplReader::Read_CColl( sal_uInt16, const sal_uInt8* pData, short nLen
     }
     sal_uInt16 nId = SVBT16ToShort( pData );    // Style-Id (NOT Sprm-Id!)
 
-    if( nId >= m_vColl.size() || !m_vColl[nId].pFormat  // invalid Id?
-        || m_vColl[nId].bColl )              // or paragraph style?
+    if( nId >= m_vColl.size() || !m_vColl[nId].m_pFormat  // invalid Id?
+        || m_vColl[nId].m_bColl )              // or paragraph style?
         return;                             // then ignore
 
     // if current on loading a TOX field, and current trying to apply a hyperlink character style,
@@ -3806,7 +3806,7 @@ void SwWW8ImplReader::Read_CColl( sal_uInt16, const sal_uInt8* pData, short nLen
         return;
     }
 
-    NewAttr( SwFormatCharFormat( static_cast<SwCharFormat*>(m_vColl[nId].pFormat) ) );
+    NewAttr( SwFormatCharFormat( static_cast<SwCharFormat*>(m_vColl[nId].m_pFormat) ) );
     m_nCharFormat = (short) nId;
 }
 
@@ -4004,7 +4004,7 @@ void SwWW8ImplReader::Read_LR( sal_uInt16 nId, const sal_uInt8* pData, short nLe
             aLR.SetTextLeft( nPara );
             if (m_pAktColl && m_nAktColl < m_vColl.size())
             {
-                m_vColl[m_nAktColl].bListReleventIndentSet = true;
+                m_vColl[m_nAktColl].m_bListReleventIndentSet = true;
             }
             bLeftIndentSet = true;  // #i105414#
             break;
@@ -4023,13 +4023,13 @@ void SwWW8ImplReader::Read_LR( sal_uInt16 nId, const sal_uInt8* pData, short nLe
             been removed then we will factor the original list applied hanging
             into our calculation.
             */
-            if (m_pPlcxMan && m_nAktColl < m_vColl.size() && m_vColl[m_nAktColl].bHasBrokenWW6List)
+            if (m_pPlcxMan && m_nAktColl < m_vColl.size() && m_vColl[m_nAktColl].m_bHasBrokenWW6List)
             {
                 const sal_uInt8 *pIsZeroed = m_pPlcxMan->GetPapPLCF()->HasSprm(0x460B);
                 if (pIsZeroed && *pIsZeroed == 0)
                 {
                     const SvxLRSpaceItem &rLR =
-                        ItemGet<SvxLRSpaceItem>(*(m_vColl[m_nAktColl].pFormat),
+                        ItemGet<SvxLRSpaceItem>(*(m_vColl[m_nAktColl].m_pFormat),
                         RES_LR_SPACE);
                     nPara = nPara - rLR.GetTextFirstLineOfst();
                 }
@@ -4057,7 +4057,7 @@ void SwWW8ImplReader::Read_LR( sal_uInt16 nId, const sal_uInt8* pData, short nLe
             }
             if (m_pAktColl && m_nAktColl < m_vColl.size())
             {
-                m_vColl[m_nAktColl].bListReleventIndentSet = true;
+                m_vColl[m_nAktColl].m_bListReleventIndentSet = true;
             }
             bFirstLinOfstSet = true; // #i103711#
             break;
@@ -4161,14 +4161,14 @@ void SwWW8ImplReader::Read_ParaAutoBefore(sal_uInt16, const sal_uInt8 *pData, sh
         aUL.SetUpper(GetParagraphAutoSpace(m_pWDop->fDontUseHTMLAutoSpacing));
         NewAttr(aUL);
         if (m_pAktColl && m_nAktColl < m_vColl.size())
-            m_vColl[m_nAktColl].bParaAutoBefore = true;
+            m_vColl[m_nAktColl].m_bParaAutoBefore = true;
         else
             m_bParaAutoBefore = true;
     }
     else
     {
         if (m_pAktColl && m_nAktColl < m_vColl.size())
-            m_vColl[m_nAktColl].bParaAutoBefore = false;
+            m_vColl[m_nAktColl].m_bParaAutoBefore = false;
         else
             m_bParaAutoBefore = false;
     }
@@ -4188,14 +4188,14 @@ void SwWW8ImplReader::Read_ParaAutoAfter(sal_uInt16, const sal_uInt8 *pData, sho
         aUL.SetLower(GetParagraphAutoSpace(m_pWDop->fDontUseHTMLAutoSpacing));
         NewAttr(aUL);
         if (m_pAktColl && m_nAktColl < m_vColl.size())
-            m_vColl[m_nAktColl].bParaAutoAfter = true;
+            m_vColl[m_nAktColl].m_bParaAutoAfter = true;
         else
             m_bParaAutoAfter = true;
     }
     else
     {
         if (m_pAktColl && m_nAktColl < m_vColl.size())
-            m_vColl[m_nAktColl].bParaAutoAfter = false;
+            m_vColl[m_nAktColl].m_bParaAutoAfter = false;
         else
             m_bParaAutoAfter = false;
     }
@@ -4972,11 +4972,11 @@ void SwWW8ImplReader::Read_ApoPPC( sal_uInt16, const sal_uInt8* pData, short )
     if (m_pAktColl && m_nAktColl < m_vColl.size()) // only for Styledef, sonst anders geloest
     {
         SwWW8StyInf& rSI = m_vColl[m_nAktColl];
-        WW8FlyPara* pFly = rSI.pWWFly ? rSI.pWWFly : new WW8FlyPara(m_bVer67);
-        m_vColl[m_nAktColl].pWWFly = pFly;
+        WW8FlyPara* pFly = rSI.m_pWWFly ? rSI.m_pWWFly : new WW8FlyPara(m_bVer67);
+        m_vColl[m_nAktColl].m_pWWFly = pFly;
         pFly->Read(*pData, m_pStyles);
         if (pFly->IsEmpty())
-            delete m_vColl[m_nAktColl].pWWFly, m_vColl[m_nAktColl].pWWFly = nullptr;
+            delete m_vColl[m_nAktColl].m_pWWFly, m_vColl[m_nAktColl].m_pWWFly = nullptr;
     }
 }