sw: prefix members of WW8TabDesc

Change-Id: I8c6e52d40f497fb7cee3ef812e2974aa292a11a8

1 files changed, 399 insertions, 399 deletions

diff --git a/sw/source/filter/ww8/ww8par2.cxx b/sw/source/filter/ww8/ww8par2.cxx
index f7ddc8bf362b..0f9f245aa315 100644
--- a/sw/source/filter/ww8/ww8par2.cxx
+++ b/sw/source/filter/ww8/ww8par2.cxx
@@ -115,47 +115,47 @@ WW8TabBandDesc::~WW8TabBandDesc()
 
 class WW8TabDesc
 {
-    std::vector<OUString> aNumRuleNames;
+    std::vector<OUString> m_aNumRuleNames;
     sw::util::RedlineStack *mpOldRedlineStack;
 
-    SwWW8ImplReader* pIo;
+    SwWW8ImplReader* m_pIo;
 
-    WW8TabBandDesc* pFirstBand;
-    WW8TabBandDesc* pActBand;
+    WW8TabBandDesc* m_pFirstBand;
+    WW8TabBandDesc* m_pActBand;
 
-    SwPosition* pTmpPos;
+    SwPosition* m_pTmpPos;
 
-    SwTableNode* pTableNd;            // table node
-    const SwTableLines* pTabLines;  // row array of node
-    SwTableLine* pTabLine;          // current row
-    SwTableBoxes* pTabBoxes;        // boxes array in current row
-    SwTableBox* pTabBox;            // current cell
+    SwTableNode* m_pTableNd;            // table node
+    const SwTableLines* m_pTabLines;  // row array of node
+    SwTableLine* m_pTabLine;          // current row
+    SwTableBoxes* m_pTabBoxes;        // boxes array in current row
+    SwTableBox* m_pTabBox;            // current cell
 
     std::vector<std::unique_ptr<WW8SelBoxInfo>> m_MergeGroups;   // list of all cells to be merged
 
-    WW8_TCell* pAktWWCell;
-
-    short nRows;
-    short nDefaultSwCols;
-    short nBands;
-    short nMinLeft;
-    short nConvertedLeft;
-    short nMaxRight;
-    short nSwWidth;
-    short nPreferredWidth;
-    short nOrgDxaLeft;
-
-    bool bOk;
-    bool bClaimLineFormat;
-    sal_Int16 eOri;
-    bool bIsBiDi;
+    WW8_TCell* m_pAktWWCell;
+
+    short m_nRows;
+    short m_nDefaultSwCols;
+    short m_nBands;
+    short m_nMinLeft;
+    short m_nConvertedLeft;
+    short m_nMaxRight;
+    short m_nSwWidth;
+    short m_nPreferredWidth;
+    short m_nOrgDxaLeft;
+
+    bool m_bOk;
+    bool m_bClaimLineFormat;
+    sal_Int16 m_eOri;
+    bool m_bIsBiDi;
                                 // 2. common admin info
-    short nAktRow;
-    short nAktBandRow;          // SW: row of current band
+    short m_nAktRow;
+    short m_nAktBandRow;          // SW: row of current band
                                 // 3. admin info for writer
-    short nAktCol;
+    short m_nAktCol;
 
-    sal_uInt16 nRowsToRepeat;
+    sal_uInt16 m_nRowsToRepeat;
 
     // 4. methods
 
@@ -182,15 +182,15 @@ class WW8TabDesc
     WW8TabDesc& operator=(WW8TabDesc const&) = delete;
 
 public:
-    const SwTable* pTable;          // table
-    SwPosition* pParentPos;
-    SwFlyFrameFormat* pFlyFormat;
-    SfxItemSet aItemSet;
+    const SwTable* m_pTable;          // table
+    SwPosition* m_pParentPos;
+    SwFlyFrameFormat* m_pFlyFormat;
+    SfxItemSet m_aItemSet;
     bool IsValidCell(short nCol) const;
     bool InFirstParaInCell() const;
 
     WW8TabDesc( SwWW8ImplReader* pIoClass, WW8_CP nStartCp );
-    bool Ok() const { return bOk; }
+    bool Ok() const { return m_bOk; }
     void CreateSwTable(SvxULSpaceItem* pULSpaceItem);
     void UseSwTable();
     void SetSizePosition(SwFrameFormat* pFrameFormat);
@@ -199,11 +199,11 @@ public:
     void ParkPaM();
     void FinishSwTable();
     void MergeCells();
-    short GetMinLeft() const { return nConvertedLeft; }
+    short GetMinLeft() const { return m_nConvertedLeft; }
     ~WW8TabDesc();
 
-    const WW8_TCell* GetAktWWCell() const { return pAktWWCell; }
-    short GetAktCol() const { return nAktCol; }
+    const WW8_TCell* GetAktWWCell() const { return m_pAktWWCell; }
+    short GetAktCol() const { return m_nAktCol; }
     // find name of numrule valid for current WW-COL
     OUString GetNumRuleName() const;
     void SetNumRuleName( const OUString& rName );
@@ -1734,58 +1734,58 @@ wwTableSprm GetTableSprm(sal_uInt16 nId, ww::WordVersion eVer)
 
 WW8TabDesc::WW8TabDesc(SwWW8ImplReader* pIoClass, WW8_CP nStartCp) :
     mpOldRedlineStack(nullptr),
-    pIo(pIoClass),
-    pFirstBand(nullptr),
-    pActBand(nullptr),
-    pTmpPos(nullptr),
-    pTableNd(nullptr),
-    pTabLines(nullptr),
-    pTabLine(nullptr),
-    pTabBoxes(nullptr),
-    pTabBox(nullptr),
-    pAktWWCell(nullptr),
-    nRows(0),
-    nDefaultSwCols(0),
-    nBands(0),
-    nMinLeft(0),
-    nConvertedLeft(0),
-    nMaxRight(0),
-    nSwWidth(0),
-    nPreferredWidth(0),
-    nOrgDxaLeft(0),
-    bOk(true),
-    bClaimLineFormat(false),
-    eOri(text::HoriOrientation::NONE),
-    bIsBiDi(false),
-    nAktRow(0),
-    nAktBandRow(0),
-    nAktCol(0),
-    nRowsToRepeat(0),
-    pTable(nullptr),
-    pParentPos(nullptr),
-    pFlyFormat(nullptr),
-    aItemSet(pIo->m_rDoc.GetAttrPool(),RES_FRMATR_BEGIN,RES_FRMATR_END-1)
+    m_pIo(pIoClass),
+    m_pFirstBand(nullptr),
+    m_pActBand(nullptr),
+    m_pTmpPos(nullptr),
+    m_pTableNd(nullptr),
+    m_pTabLines(nullptr),
+    m_pTabLine(nullptr),
+    m_pTabBoxes(nullptr),
+    m_pTabBox(nullptr),
+    m_pAktWWCell(nullptr),
+    m_nRows(0),
+    m_nDefaultSwCols(0),
+    m_nBands(0),
+    m_nMinLeft(0),
+    m_nConvertedLeft(0),
+    m_nMaxRight(0),
+    m_nSwWidth(0),
+    m_nPreferredWidth(0),
+    m_nOrgDxaLeft(0),
+    m_bOk(true),
+    m_bClaimLineFormat(false),
+    m_eOri(text::HoriOrientation::NONE),
+    m_bIsBiDi(false),
+    m_nAktRow(0),
+    m_nAktBandRow(0),
+    m_nAktCol(0),
+    m_nRowsToRepeat(0),
+    m_pTable(nullptr),
+    m_pParentPos(nullptr),
+    m_pFlyFormat(nullptr),
+    m_aItemSet(m_pIo->m_rDoc.GetAttrPool(),RES_FRMATR_BEGIN,RES_FRMATR_END-1)
 {
-    pIo->m_bAktAND_fNumberAcross = false;
+    m_pIo->m_bAktAND_fNumberAcross = false;
 
     static const sal_Int16 aOriArr[] =
     {
         text::HoriOrientation::LEFT, text::HoriOrientation::CENTER, text::HoriOrientation::RIGHT, text::HoriOrientation::CENTER
     };
 
-    bool bOldVer = ww::IsSevenMinus(pIo->GetFib().GetFIBVersion());
+    bool bOldVer = ww::IsSevenMinus(m_pIo->GetFib().GetFIBVersion());
     WW8_TablePos aTabPos;
 
     WW8PLCFxSave1 aSave;
-    pIo->m_pPlcxMan->GetPap()->Save( aSave );
+    m_pIo->m_pPlcxMan->GetPap()->Save( aSave );
 
-    WW8PLCFx_Cp_FKP* pPap = pIo->m_pPlcxMan->GetPapPLCF();
+    WW8PLCFx_Cp_FKP* pPap = m_pIo->m_pPlcxMan->GetPapPLCF();
 
-    eOri = text::HoriOrientation::LEFT;
+    m_eOri = text::HoriOrientation::LEFT;
 
     WW8TabBandDesc* pNewBand = new WW8TabBandDesc;
 
-    wwSprmParser aSprmParser(pIo->GetFib().GetFIBVersion());
+    wwSprmParser aSprmParser(m_pIo->GetFib().GetFIBVersion());
 
     // process pPap until end of table found
     do
@@ -1800,9 +1800,9 @@ WW8TabDesc::WW8TabDesc(SwWW8ImplReader* pIoClass, WW8_CP nStartCp) :
         WW8_TablePos *pTabPos  = nullptr;
 
         // search end of a tab row
-        if(!(pIo->SearchRowEnd(pPap, nStartCp, pIo->m_nInTable)))
+        if(!(m_pIo->SearchRowEnd(pPap, nStartCp, m_pIo->m_nInTable)))
         {
-            bOk = false;
+            m_bOk = false;
             break;
         }
 
@@ -1819,7 +1819,7 @@ WW8TabDesc::WW8TabDesc(SwWW8ImplReader* pIoClass, WW8_CP nStartCp) :
             while (aSprmIter.GetSprms() && nullptr != (pParams = aSprmIter.GetAktParams()))
             {
                 sal_uInt16 nId = aSprmIter.GetAktId();
-                wwTableSprm eSprm = GetTableSprm(nId, pIo->GetFib().GetFIBVersion());
+                wwTableSprm eSprm = GetTableSprm(nId, m_pIo->GetFib().GetFIBVersion());
                 switch (eSprm)
                 {
                     case sprmTTableWidth:
@@ -1828,7 +1828,7 @@ WW8TabDesc::WW8TabDesc(SwWW8ImplReader* pIoClass, WW8_CP nStartCp) :
                         const sal_uInt8 b1 = pParams[1];
                         const sal_uInt8 b2 = pParams[2];
                         if (b0 == 3) // Twips
-                            nPreferredWidth = b2 * 0x100 + b1;
+                            m_nPreferredWidth = b2 * 0x100 + b1;
                         }
                         break;
                     case sprmTTextFlow:
@@ -1836,7 +1836,7 @@ WW8TabDesc::WW8TabDesc(SwWW8ImplReader* pIoClass, WW8_CP nStartCp) :
                         break;
                     case sprmTFCantSplit:
                         pNewBand->bCantSplit = *pParams;
-                        bClaimLineFormat = true;
+                        m_bClaimLineFormat = true;
                         break;
                     case sprmTTableBorders:
                         pTableBorders = pParams; // process at end
@@ -1847,24 +1847,24 @@ WW8TabDesc::WW8TabDesc(SwWW8ImplReader* pIoClass, WW8_CP nStartCp) :
                     case sprmTTableHeader:
                         if (!bRepeatedSprm)
                         {
-                            nRowsToRepeat++;
+                            m_nRowsToRepeat++;
                             bRepeatedSprm = true;
                         }
                         break;
                     case sprmTJc:
                         // sprmTJc  -  Justification Code
-                        if (nRows == 0)
-                            eOri = aOriArr[*pParams & 0x3];
+                        if (m_nRows == 0)
+                            m_eOri = aOriArr[*pParams & 0x3];
                         break;
                     case sprmTFBiDi:
-                        bIsBiDi = SVBT16ToShort(pParams) != 0;
+                        m_bIsBiDi = SVBT16ToShort(pParams) != 0;
                         break;
                     case sprmTDxaGapHalf:
                         pNewBand->nGapHalf = (sal_Int16)SVBT16ToShort( pParams );
                         break;
                     case sprmTDyaRowHeight:
                         pNewBand->nLineHeight = (sal_Int16)SVBT16ToShort( pParams );
-                        bClaimLineFormat = true;
+                        m_bClaimLineFormat = true;
                         break;
                     case sprmTDefTable:
                         pNewBand->ReadDef(bOldVer, pParams);
@@ -1883,7 +1883,7 @@ WW8TabDesc::WW8TabDesc(SwWW8ImplReader* pIoClass, WW8_CP nStartCp) :
                         // shift the whole table to that margin (see below)
                         {
                             short nDxaNew = (sal_Int16)SVBT16ToShort( pParams );
-                            nOrgDxaLeft = nDxaNew;
+                            m_nOrgDxaLeft = nDxaNew;
                             if( nDxaNew < nTabeDxaNew )
                                 nTabeDxaNew = nDxaNew;
                         }
@@ -1960,19 +1960,19 @@ WW8TabDesc::WW8TabDesc(SwWW8ImplReader* pIoClass, WW8_CP nStartCp) :
             }
         }
 
-        if (!pActBand)
-            pActBand = pFirstBand = pNewBand;
+        if (!m_pActBand)
+            m_pActBand = m_pFirstBand = pNewBand;
         else
         {
-            pActBand->pNextBand = pNewBand;
-            pActBand = pNewBand;
+            m_pActBand->pNextBand = pNewBand;
+            m_pActBand = pNewBand;
         }
-        nBands++;
+        m_nBands++;
 
         pNewBand = new WW8TabBandDesc;
 
-        nRows++;
-        pActBand->nRows++;
+        m_nRows++;
+        m_pActBand->nRows++;
 
         //Seek our pap to its next block of properties
         WW8PLCFxDesc aRes;
@@ -1993,7 +1993,7 @@ WW8TabDesc::WW8TabDesc(SwWW8ImplReader* pIoClass, WW8_CP nStartCp) :
              aRes.nStartPos == WW8_CP_MAX
            )
         {
-            bOk = false;
+            m_bOk = false;
             break;
         }
 
@@ -2002,15 +2002,15 @@ WW8TabDesc::WW8TabDesc(SwWW8ImplReader* pIoClass, WW8_CP nStartCp) :
         const sal_uInt8 *pLevel = pPap->HasSprm(0x6649);
         // InTable
         if (!pParams || (1 != *pParams) ||
-            (pLevel && (*pLevel <= pIo->m_nInTable)))
+            (pLevel && (*pLevel <= m_pIo->m_nInTable)))
         {
             break;
         }
 
         //Get the end of row new table positioning data
         WW8_CP nMyStartCp=nStartCp;
-        if (pIo->SearchRowEnd(pPap, nMyStartCp, pIo->m_nInTable))
-            if (pIo->ParseTabPos(&aTabPos, pPap))
+        if (m_pIo->SearchRowEnd(pPap, nMyStartCp, m_pIo->m_nInTable))
+            if (m_pIo->ParseTabPos(&aTabPos, pPap))
                 pTabPos = &aTabPos;
 
         //Move back to this cell
@@ -2019,7 +2019,7 @@ WW8TabDesc::WW8TabDesc(SwWW8ImplReader* pIoClass, WW8_CP nStartCp) :
 
         // PlcxMan currently points too far ahead so we need to bring
         // it back to where we are trying to make a table
-        pIo->m_pPlcxMan->GetPap()->nOrigStartPos = aRes.nStartPos;
+        m_pIo->m_pPlcxMan->GetPap()->nOrigStartPos = aRes.nStartPos;
         if (!(pPap->SeekPos(aRes.nStartPos)))
         {
             aRes.nEndPos = WW8_CP_MAX;
@@ -2030,7 +2030,7 @@ WW8TabDesc::WW8TabDesc(SwWW8ImplReader* pIoClass, WW8_CP nStartCp) :
 
         //Does this row match up with the last row closely enough to be
         //considered part of the same table
-        ApoTestResults aApo = pIo->TestApo(pIo->m_nInTable + 1, false, pTabPos);
+        ApoTestResults aApo = m_pIo->TestApo(m_pIo->m_nInTable + 1, false, pTabPos);
 
         /*
         ##513##, #79474# If this is not sufficient, then we should look at
@@ -2043,7 +2043,7 @@ WW8TabDesc::WW8TabDesc(SwWW8ImplReader* pIoClass, WW8_CP nStartCp) :
         if (aApo.mbStartApo)
         {
             //if there really is a fly here, and not a "null" fly then break.
-            WW8FlyPara *pNewFly = pIo->ConstructApo(aApo, pTabPos);
+            WW8FlyPara *pNewFly = m_pIo->ConstructApo(aApo, pTabPos);
             if (pNewFly)
                 delete pNewFly;
             else
@@ -2054,29 +2054,29 @@ WW8TabDesc::WW8TabDesc(SwWW8ImplReader* pIoClass, WW8_CP nStartCp) :
     }
     while(true);
 
-    if( bOk )
+    if( m_bOk )
     {
-        if( pActBand->nRows > 1 )
+        if( m_pActBand->nRows > 1 )
         {
             // last band has more than 1 cell
             delete pNewBand;
-            pNewBand = new WW8TabBandDesc( *pActBand ); // create new
-            pActBand->nRows--;      // wegen Sonderbehandlung Raender-Defaults
+            pNewBand = new WW8TabBandDesc( *m_pActBand ); // create new
+            m_pActBand->nRows--;      // wegen Sonderbehandlung Raender-Defaults
             pNewBand->nRows = 1;
-            pActBand->pNextBand = pNewBand; // am Ende einschleifen
-            nBands++;
+            m_pActBand->pNextBand = pNewBand; // am Ende einschleifen
+            m_nBands++;
             pNewBand = nullptr;                   // do not delete
         }
         CalcDefaults();
     }
     delete pNewBand;
 
-    pIo->m_pPlcxMan->GetPap()->Restore( aSave );
+    m_pIo->m_pPlcxMan->GetPap()->Restore( aSave );
 }
 
 WW8TabDesc::~WW8TabDesc()
 {
-    WW8TabBandDesc* pR = pFirstBand;
+    WW8TabBandDesc* pR = m_pFirstBand;
     while(pR)
     {
         WW8TabBandDesc* pR2 = pR->pNextBand;
@@ -2084,7 +2084,7 @@ WW8TabDesc::~WW8TabDesc()
         pR = pR2;
     }
 
-    delete pParentPos;
+    delete m_pParentPos;
 }
 
 void WW8TabDesc::CalcDefaults()
@@ -2092,8 +2092,8 @@ void WW8TabDesc::CalcDefaults()
     short nMinCols = SHRT_MAX;
     WW8TabBandDesc* pR;
 
-    nMinLeft = SHRT_MAX;
-    nMaxRight = SHRT_MIN;
+    m_nMinLeft = SHRT_MAX;
+    m_nMaxRight = SHRT_MIN;
 
     /*
     If we are an honestly inline centered table, then the normal rules of
@@ -2105,18 +2105,18 @@ void WW8TabDesc::CalcDefaults()
     to around (in frame (bApo)) and the table splits into two very disjoint
     rows as the beginning point of each row are very different
     */
-    if ((!pIo->InLocalApo()) && (eOri == text::HoriOrientation::CENTER))
+    if ((!m_pIo->InLocalApo()) && (m_eOri == text::HoriOrientation::CENTER))
     {
-        for (pR = pFirstBand; pR; pR = pR->pNextBand)
+        for (pR = m_pFirstBand; pR; pR = pR->pNextBand)
             for( short i = pR->nWwCols; i >= 0; --i)
                 pR->nCenter[i] = pR->nCenter[i] -  pR->nCenter[0];
     }
 
     // 1. Durchlauf: aeusserste L- und R-Grenzen finden
-    for( pR = pFirstBand; pR; pR = pR->pNextBand )
+    for( pR = m_pFirstBand; pR; pR = pR->pNextBand )
     {
-        if( pR->nCenter[0] < nMinLeft )
-            nMinLeft = pR->nCenter[0];
+        if( pR->nCenter[0] < m_nMinLeft )
+            m_nMinLeft = pR->nCenter[0];
 
         for( short i = 0; i < pR->nWwCols; i++ )
         {
@@ -2136,19 +2136,19 @@ void WW8TabDesc::CalcDefaults()
             }
         }
 
-        if( pR->nCenter[pR->nWwCols] > nMaxRight )
-            nMaxRight = pR->nCenter[pR->nWwCols];
+        if( pR->nCenter[pR->nWwCols] > m_nMaxRight )
+            m_nMaxRight = pR->nCenter[pR->nWwCols];
     }
-    nSwWidth = nMaxRight - nMinLeft;
+    m_nSwWidth = m_nMaxRight - m_nMinLeft;
 
     // If the table is right aligned we need to align all rows to the
     // row that has the furthest right point
 
-    if(eOri == text::HoriOrientation::RIGHT)
+    if(m_eOri == text::HoriOrientation::RIGHT)
     {
-        for( pR = pFirstBand; pR; pR = pR->pNextBand )
+        for( pR = m_pFirstBand; pR; pR = pR->pNextBand )
         {
-            int adjust = nMaxRight - pR->nCenter[pR->nWwCols];
+            int adjust = m_nMaxRight - pR->nCenter[pR->nWwCols];
             for( short i = 0; i < pR->nWwCols + 1; i++ )
             {
                 pR->nCenter[i] = static_cast< short >(pR->nCenter[i] + adjust);
@@ -2163,10 +2163,10 @@ void WW8TabDesc::CalcDefaults()
     // Non existent cells can reduce the number of columns.
 
     // 3. pass: Replace border with defaults if needed
-    nConvertedLeft = nMinLeft;
+    m_nConvertedLeft = m_nMinLeft;
 
     short nLeftMaxThickness = 0, nRightMaxThickness=0;
-    for( pR = pFirstBand ; pR; pR = pR->pNextBand )
+    for( pR = m_pFirstBand ; pR; pR = pR->pNextBand )
     {
         if( !pR->pTCs )
         {
@@ -2187,7 +2187,7 @@ void WW8TabDesc::CalcDefaults()
                     {
                     case 0:
                         // outer top / horizontally inside
-                        j = (pR == pFirstBand) ? 0 : 4;
+                        j = (pR == m_pFirstBand) ? 0 : 4;
                         break;
                     case 1:
                         // outer left / vertically inside
@@ -2243,15 +2243,15 @@ void WW8TabDesc::CalcDefaults()
             }
         }
     }
-    nSwWidth = nSwWidth + nRightMaxThickness;
-    nMaxRight = nMaxRight + nRightMaxThickness;
-    nConvertedLeft = nMinLeft-(nLeftMaxThickness/2);
+    m_nSwWidth = m_nSwWidth + nRightMaxThickness;
+    m_nMaxRight = m_nMaxRight + nRightMaxThickness;
+    m_nConvertedLeft = m_nMinLeft-(nLeftMaxThickness/2);
 
-    for( pR = pFirstBand; pR; pR = pR->pNextBand )
+    for( pR = m_pFirstBand; pR; pR = pR->pNextBand )
     {
         pR->nSwCols = pR->nWwCols;
-        pR->bLEmptyCol = pR->nCenter[0] - nMinLeft >= MINLAY;
-        pR->bREmptyCol = (nMaxRight - pR->nCenter[pR->nWwCols] - nRightMaxThickness) >= MINLAY;
+        pR->bLEmptyCol = pR->nCenter[0] - m_nMinLeft >= MINLAY;
+        pR->bREmptyCol = (m_nMaxRight - pR->nCenter[pR->nWwCols] - nRightMaxThickness) >= MINLAY;
 
         short nAddCols = short(pR->bLEmptyCol) + short(pR->bREmptyCol);
         sal_uInt16 i;
@@ -2302,32 +2302,32 @@ void WW8TabDesc::CalcDefaults()
     disjoint upper and lowers to see what happens there.
     */
 
-    if ((nMinLeft && !bIsBiDi && text::HoriOrientation::LEFT == eOri) ||
-        (nMinLeft != -108 && bIsBiDi && text::HoriOrientation::RIGHT == eOri)) // Word sets the first nCenter value to -108 when no indent is used
-        eOri = text::HoriOrientation::LEFT_AND_WIDTH; //  absolutely positioned
+    if ((m_nMinLeft && !m_bIsBiDi && text::HoriOrientation::LEFT == m_eOri) ||
+        (m_nMinLeft != -108 && m_bIsBiDi && text::HoriOrientation::RIGHT == m_eOri)) // Word sets the first nCenter value to -108 when no indent is used
+        m_eOri = text::HoriOrientation::LEFT_AND_WIDTH; //  absolutely positioned
 
-    nDefaultSwCols = nMinCols;  // because inserting cells is cheaper than merging
-    if( nDefaultSwCols == 0 )
-        bOk = false;
-    pActBand = pFirstBand;
-    nAktBandRow = 0;
-    OSL_ENSURE( pActBand, "pActBand ist 0" );
+    m_nDefaultSwCols = nMinCols;  // because inserting cells is cheaper than merging
+    if( m_nDefaultSwCols == 0 )
+        m_bOk = false;
+    m_pActBand = m_pFirstBand;
+    m_nAktBandRow = 0;
+    OSL_ENSURE( m_pActBand, "pActBand ist 0" );
 }
 
 void WW8TabDesc::SetSizePosition(SwFrameFormat* pFrameFormat)
 {
     SwFrameFormat* pApply = pFrameFormat;
     if (!pApply )
-        pApply = pTable->GetFrameFormat();
+        pApply = m_pTable->GetFrameFormat();
     OSL_ENSURE(pApply,"No frame");
-    pApply->SetFormatAttr(aItemSet);
+    pApply->SetFormatAttr(m_aItemSet);
     if (pFrameFormat)
     {
         SwFormatFrameSize aSize = pFrameFormat->GetFrameSize();
         aSize.SetHeightSizeType(ATT_MIN_SIZE);
         aSize.SetHeight(MINLAY);
         pFrameFormat->SetFormatAttr(aSize);
-        pTable->GetFrameFormat()->SetFormatAttr(SwFormatHoriOrient(0,text::HoriOrientation::FULL));
+        m_pTable->GetFrameFormat()->SetFormatAttr(SwFormatHoriOrient(0,text::HoriOrientation::FULL));
     }
 }
 
@@ -2342,11 +2342,11 @@ void wwSectionManager::PrependedInlineNode(const SwPosition &rPos,
 
 void WW8TabDesc::CreateSwTable(SvxULSpaceItem* pULSpaceItem)
 {
-    ::SetProgressState(pIo->m_nProgress, pIo->m_pDocShell);   // Update
+    ::SetProgressState(m_pIo->m_nProgress, m_pIo->m_pDocShell);   // Update
 
     // if there is already some content on the Node append new node to ensure
     // that this content remains ABOVE the table
-    SwPosition* pPoint = pIo->m_pPaM->GetPoint();
+    SwPosition* pPoint = m_pIo->m_pPaM->GetPoint();
     bool bInsNode = pPoint->nContent.GetIndex() != 0;
     bool bSetMinHeight = false;
 
@@ -2355,18 +2355,18 @@ void WW8TabDesc::CreateSwTable(SvxULSpaceItem* pULSpaceItem)
      Set fly anchor to its anchor pos, so that if a table starts immediately
      at this position a new node will be inserted before inserting the table.
     */
-    if (!bInsNode && pIo->m_pFormatOfJustInsertedApo)
+    if (!bInsNode && m_pIo->m_pFormatOfJustInsertedApo)
     {
         const SwPosition* pAPos =
-            pIo->m_pFormatOfJustInsertedApo->GetAnchor().GetContentAnchor();
+            m_pIo->m_pFormatOfJustInsertedApo->GetAnchor().GetContentAnchor();
         if (pAPos && &pAPos->nNode.GetNode() == &pPoint->nNode.GetNode())
         {
             bInsNode = true;
             bSetMinHeight = true;
 
-            SwFormatSurround aSur(pIo->m_pFormatOfJustInsertedApo->GetSurround());
+            SwFormatSurround aSur(m_pIo->m_pFormatOfJustInsertedApo->GetSurround());
             aSur.SetAnchorOnly(true);
-            pIo->m_pFormatOfJustInsertedApo->SetFormatAttr(aSur);
+            m_pIo->m_pFormatOfJustInsertedApo->SetFormatAttr(aSur);
         }
     }
 
@@ -2375,35 +2375,35 @@ void WW8TabDesc::CreateSwTable(SvxULSpaceItem* pULSpaceItem)
         // minimize Fontsize to minimize height growth of the header/footer
         // set font size to 1 point to minimize y-growth of Hd/Ft
         SvxFontHeightItem aSz(20, 100, RES_CHRATR_FONTSIZE);
-        pIo->NewAttr( aSz );
-        pIo->m_pCtrlStck->SetAttr(*pPoint, RES_CHRATR_FONTSIZE);
+        m_pIo->NewAttr( aSz );
+        m_pIo->m_pCtrlStck->SetAttr(*pPoint, RES_CHRATR_FONTSIZE);
     }
 
     if (bInsNode)
-        pIo->AppendTextNode(*pPoint);
+        m_pIo->AppendTextNode(*pPoint);
 
-    pTmpPos = new SwPosition( *pIo->m_pPaM->GetPoint() );
+    m_pTmpPos = new SwPosition( *m_pIo->m_pPaM->GetPoint() );
 
     // The table is small: The number of columns is the lowest count of
     // columns of the origin, because inserting is faster than deleting.
     // The number of rows is the count of bands because (identically)
     // rows of a band can be duplicated easy.
-    pTable = pIo->m_rDoc.InsertTable(
+    m_pTable = m_pIo->m_rDoc.InsertTable(
             SwInsertTableOptions( tabopts::HEADLINE_NO_BORDER, 0 ),
-            *pTmpPos, nBands, nDefaultSwCols, eOri );
+            *m_pTmpPos, m_nBands, m_nDefaultSwCols, m_eOri );
 
-    OSL_ENSURE(pTable && pTable->GetFrameFormat(), "insert table failed");
-    if (!pTable || !pTable->GetFrameFormat())
+    OSL_ENSURE(m_pTable && m_pTable->GetFrameFormat(), "insert table failed");
+    if (!m_pTable || !m_pTable->GetFrameFormat())
         return;
 
     if (pULSpaceItem && pULSpaceItem->GetUpper() != 0)
-        aItemSet.Put(*pULSpaceItem);
+        m_aItemSet.Put(*pULSpaceItem);
 
-    SwTableNode* pTableNode = pTable->GetTableNode();
+    SwTableNode* pTableNode = m_pTable->GetTableNode();
     OSL_ENSURE(pTableNode, "no table node!");
     if (pTableNode)
     {
-        pIo->m_aSectionManager.PrependedInlineNode(*pIo->m_pPaM->GetPoint(),
+        m_pIo->m_aSectionManager.PrependedInlineNode(*m_pIo->m_pPaM->GetPoint(),
             *pTableNode);
     }
 
@@ -2411,7 +2411,7 @@ void WW8TabDesc::CreateSwTable(SvxULSpaceItem* pULSpaceItem)
     // contains a Pagedesc. If so that Pagedesc would be moved to the
     // row after the table, whats wrong. So delete and
     // set later to the table format.
-    if (SwTextNode *const pNd = pTmpPos->nNode.GetNode().GetTextNode())
+    if (SwTextNode *const pNd = m_pTmpPos->nNode.GetNode().GetTextNode())
     {
         if (const SfxItemSet* pSet = pNd->GetpSwAttrSet())
         {
@@ -2426,41 +2426,41 @@ void WW8TabDesc::CreateSwTable(SvxULSpaceItem* pULSpaceItem)
             // eventually set the PageDesc/Break now to the table
             if (pSetAttr)
             {
-                aItemSet.Put(*pSetAttr);
+                m_aItemSet.Put(*pSetAttr);
                 delete pSetAttr;
             }
         }
     }
 
     // total width of table
-    if( nMaxRight - nMinLeft > MINLAY * nDefaultSwCols )
+    if( m_nMaxRight - m_nMinLeft > MINLAY * m_nDefaultSwCols )
     {
-        pTable->GetFrameFormat()->SetFormatAttr(SwFormatFrameSize(ATT_FIX_SIZE, nSwWidth));
-        aItemSet.Put(SwFormatFrameSize(ATT_FIX_SIZE, nSwWidth));
+        m_pTable->GetFrameFormat()->SetFormatAttr(SwFormatFrameSize(ATT_FIX_SIZE, m_nSwWidth));
+        m_aItemSet.Put(SwFormatFrameSize(ATT_FIX_SIZE, m_nSwWidth));
     }
 
     SvxFrameDirectionItem aDirection(
-        bIsBiDi ? FRMDIR_HORI_RIGHT_TOP : FRMDIR_HORI_LEFT_TOP, RES_FRAMEDIR );
-    pTable->GetFrameFormat()->SetFormatAttr(aDirection);
+        m_bIsBiDi ? FRMDIR_HORI_RIGHT_TOP : FRMDIR_HORI_LEFT_TOP, RES_FRAMEDIR );
+    m_pTable->GetFrameFormat()->SetFormatAttr(aDirection);
 
-    if (text::HoriOrientation::LEFT_AND_WIDTH == eOri)
+    if (text::HoriOrientation::LEFT_AND_WIDTH == m_eOri)
     {
-        if (!pIo->m_nInTable && pIo->InLocalApo() && pIo->m_pSFlyPara->pFlyFormat &&
+        if (!m_pIo->m_nInTable && m_pIo->InLocalApo() && m_pIo->m_pSFlyPara->pFlyFormat &&
             GetMinLeft())
         {
             //If we are inside a frame and we have a border, the frames
             //placement does not consider the tables border, which word
             //displays outside the frame, so adjust here.
-            SwFormatHoriOrient aHori(pIo->m_pSFlyPara->pFlyFormat->GetHoriOrient());
+            SwFormatHoriOrient aHori(m_pIo->m_pSFlyPara->pFlyFormat->GetHoriOrient());
             sal_Int16 eHori = aHori.GetHoriOrient();
             if ((eHori == text::HoriOrientation::NONE) || (eHori == text::HoriOrientation::LEFT) ||
                 (eHori == text::HoriOrientation::LEFT_AND_WIDTH))
             {
                 //With multiple table, use last table settings. Perhaps
                 //the maximum is what word does ?
-                aHori.SetPos(pIo->m_pSFlyPara->nXPos + GetMinLeft());
+                aHori.SetPos(m_pIo->m_pSFlyPara->nXPos + GetMinLeft());
                 aHori.SetHoriOrient(text::HoriOrientation::NONE);
-                pIo->m_pSFlyPara->pFlyFormat->SetFormatAttr(aHori);
+                m_pIo->m_pSFlyPara->pFlyFormat->SetFormatAttr(aHori);
             }
         }
         else
@@ -2474,14 +2474,14 @@ void WW8TabDesc::CreateSwTable(SvxULSpaceItem* pULSpaceItem)
             // set right to original DxaLeft (i28656)
 
             long nLeft = 0;
-            if (!bIsBiDi)
+            if (!m_bIsBiDi)
                 nLeft = GetMinLeft();
             else
             {
-                if (nPreferredWidth)
+                if (m_nPreferredWidth)
                 {
-                    nLeft = pIo->m_aSectionManager.GetTextAreaWidth();
-                    nLeft = nLeft - nPreferredWidth  - nOrgDxaLeft;
+                    nLeft = m_pIo->m_aSectionManager.GetTextAreaWidth();
+                    nLeft = nLeft - m_nPreferredWidth  - m_nOrgDxaLeft;
                 }
                 else
                     nLeft = -GetMinLeft();
@@ -2489,81 +2489,81 @@ void WW8TabDesc::CreateSwTable(SvxULSpaceItem* pULSpaceItem)
 
             aL.SetLeft(nLeft);
 
-            aItemSet.Put(aL);
+            m_aItemSet.Put(aL);
         }
     }
 
-    mpOldRedlineStack = pIo->m_pRedlineStack;
-    pIo->m_pRedlineStack = new sw::util::RedlineStack(pIo->m_rDoc);
+    mpOldRedlineStack = m_pIo->m_pRedlineStack;
+    m_pIo->m_pRedlineStack = new sw::util::RedlineStack(m_pIo->m_rDoc);
 }
 
 void WW8TabDesc::UseSwTable()
 {
     // init global Vars
-    pTabLines = &pTable->GetTabLines();
-    nAktRow = nAktCol = nAktBandRow = 0;
+    m_pTabLines = &m_pTable->GetTabLines();
+    m_nAktRow = m_nAktCol = m_nAktBandRow = 0;
 
-    pTableNd  = const_cast<SwTableNode*>((*pTabLines)[0]->GetTabBoxes()[0]->
+    m_pTableNd  = const_cast<SwTableNode*>((*m_pTabLines)[0]->GetTabBoxes()[0]->
         GetSttNd()->FindTableNode());
-    OSL_ENSURE( pTableNd, "wo ist mein TabellenNode" );
+    OSL_ENSURE( m_pTableNd, "wo ist mein TabellenNode" );
 
     // #i69519# - Restrict rows to repeat to a decent value
-    if ( nRowsToRepeat == static_cast<sal_uInt16>(nRows) )
-        nRowsToRepeat = 1;
+    if ( m_nRowsToRepeat == static_cast<sal_uInt16>(m_nRows) )
+        m_nRowsToRepeat = 1;
 
-    pTableNd->GetTable().SetRowsToRepeat( nRowsToRepeat );
+    m_pTableNd->GetTable().SetRowsToRepeat( m_nRowsToRepeat );
     // insert extra cells if needed and something like this
     AdjustNewBand();
 
-    WW8DupProperties aDup(pIo->m_rDoc,pIo->m_pCtrlStck);
-    pIo->m_pCtrlStck->SetAttr(*pIo->m_pPaM->GetPoint(), 0, false);
+    WW8DupProperties aDup(m_pIo->m_rDoc,m_pIo->m_pCtrlStck);
+    m_pIo->m_pCtrlStck->SetAttr(*m_pIo->m_pPaM->GetPoint(), 0, false);
 
     // now set the correct PaM and prepare first merger group if any
-    SetPamInCell(nAktCol, true);
-    aDup.Insert(*pIo->m_pPaM->GetPoint());
+    SetPamInCell(m_nAktCol, true);
+    aDup.Insert(*m_pIo->m_pPaM->GetPoint());
 
-    pIo->m_bWasTabRowEnd = false;
-    pIo->m_bWasTabCellEnd = false;
+    m_pIo->m_bWasTabRowEnd = false;
+    m_pIo->m_bWasTabCellEnd = false;
 }
 
 void WW8TabDesc::MergeCells()
 {
     short nRow;
 
-    for (pActBand=pFirstBand, nRow=0; pActBand; pActBand=pActBand->pNextBand)
+    for (m_pActBand=m_pFirstBand, nRow=0; m_pActBand; m_pActBand=m_pActBand->pNextBand)
     {
         // insert current box into merge group if appropriate
-        if( pActBand->pTCs )
+        if( m_pActBand->pTCs )
         {
-            for( short j = 0; j < pActBand->nRows; j++, nRow++ )
-                for( short i = 0; i < pActBand->nWwCols; i++ )
+            for( short j = 0; j < m_pActBand->nRows; j++, nRow++ )
+                for( short i = 0; i < m_pActBand->nWwCols; i++ )
                 {
                     WW8SelBoxInfo* pActMGroup = nullptr;
 
                     // start a new merge group if appropriate
 
-                    OSL_ENSURE(nRow < (sal_uInt16)pTabLines->size(),
+                    OSL_ENSURE(nRow < (sal_uInt16)m_pTabLines->size(),
                         "Too few lines, table ended early");
-                    if (nRow >= (sal_uInt16)pTabLines->size())
+                    if (nRow >= (sal_uInt16)m_pTabLines->size())
                         return;
-                    pTabLine = (*pTabLines)[ nRow ];
-                    pTabBoxes = &pTabLine->GetTabBoxes();
+                    m_pTabLine = (*m_pTabLines)[ nRow ];
+                    m_pTabBoxes = &m_pTabLine->GetTabBoxes();
 
-                    sal_uInt16 nCol = pActBand->nTransCell[ i ];
-                    if (!pActBand->bExist[i])
+                    sal_uInt16 nCol = m_pActBand->nTransCell[ i ];
+                    if (!m_pActBand->bExist[i])
                         continue;
-                    OSL_ENSURE(nCol < pTabBoxes->size(),
+                    OSL_ENSURE(nCol < m_pTabBoxes->size(),
                         "Too few columns, table ended early");
-                    if (nCol >= pTabBoxes->size())
+                    if (nCol >= m_pTabBoxes->size())
                         return;
-                    pTabBox = (*pTabBoxes)[nCol];
-                    WW8_TCell& rCell = pActBand->pTCs[ i ];
+                    m_pTabBox = (*m_pTabBoxes)[nCol];
+                    WW8_TCell& rCell = m_pActBand->pTCs[ i ];
                     // is this the left upper cell of a merge group ?
 
                     bool bMerge = false;
                     if ( rCell.bVertRestart && !rCell.bMerged )
                         bMerge = true;
-                    else if (rCell.bFirstMerged && pActBand->bExist[i])
+                    else if (rCell.bFirstMerged && m_pActBand->bExist[i])
                     {
                         // Some tests to avoid merging cells which previously were
                         // declared invalid because of sharing the exact same dimensions
@@ -2577,11 +2577,11 @@ void WW8TabDesc::MergeCells()
                             //If it's a hori merge only, and the only things in
                             //it are invalid cells then it's already taken care
                             //of, so don't merge.
-                            for (sal_uInt16 i2 = i+1; i2 < pActBand->nWwCols; i2++ )
-                                if (pActBand->pTCs[ i2 ].bMerged &&
-                                    !pActBand->pTCs[ i2 ].bFirstMerged  )
+                            for (sal_uInt16 i2 = i+1; i2 < m_pActBand->nWwCols; i2++ )
+                                if (m_pActBand->pTCs[ i2 ].bMerged &&
+                                    !m_pActBand->pTCs[ i2 ].bFirstMerged  )
                                 {
-                                    if (pActBand->bExist[i2])
+                                    if (m_pActBand->bExist[i2])
                                     {
                                         bMerge = true;
                                         break;
@@ -2594,8 +2594,8 @@ void WW8TabDesc::MergeCells()
 
                     if (bMerge)
                     {
-                        short nX1    = pActBand->nCenter[ i ];
-                        short nWidth = pActBand->nWidth[ i ];
+                        short nX1    = m_pActBand->nCenter[ i ];
+                        short nWidth = m_pActBand->nWidth[ i ];
 
                         // 2. create current merge group
                         pActMGroup = new WW8SelBoxInfo( nX1, nWidth );
@@ -2604,12 +2604,12 @@ void WW8TabDesc::MergeCells()
                         // before inserted the new merge group.
                         // Needed to correctly locked previously created merge groups.
                         // Calculate total width and set
-                        short nSizCell = pActBand->nWidth[ i ];
-                        for (sal_uInt16 i2 = i+1; i2 < pActBand->nWwCols; i2++ )
-                            if (pActBand->pTCs[ i2 ].bMerged &&
-                                !pActBand->pTCs[ i2 ].bFirstMerged  )
+                        short nSizCell = m_pActBand->nWidth[ i ];
+                        for (sal_uInt16 i2 = i+1; i2 < m_pActBand->nWwCols; i2++ )
+                            if (m_pActBand->pTCs[ i2 ].bMerged &&
+                                !m_pActBand->pTCs[ i2 ].bFirstMerged  )
                             {
-                                nSizCell = nSizCell + pActBand->nWidth[ i2 ];
+                                nSizCell = nSizCell + m_pActBand->nWidth[ i2 ];
                             }
                             else
                                 break;
@@ -2636,7 +2636,7 @@ void WW8TabDesc::MergeCells()
 
                     // if necessary add the current box to a merge group
                     // (that can be a newly created or another group)
-                    UpdateTableMergeGroup( rCell, pActMGroup, pTabBox, i );
+                    UpdateTableMergeGroup( rCell, pActMGroup, m_pTabBox, i );
                 }
             }
     }
@@ -2649,10 +2649,10 @@ void WW8TabDesc::MergeCells()
 void WW8TabDesc::ParkPaM()
 {
     SwTableBox *pTabBox2 = nullptr;
-    short nRow = nAktRow + 1;
-    if (nRow < (sal_uInt16)pTabLines->size())
+    short nRow = m_nAktRow + 1;
+    if (nRow < (sal_uInt16)m_pTabLines->size())
     {
-        if (SwTableLine *pLine = (*pTabLines)[nRow])
+        if (SwTableLine *pLine = (*m_pTabLines)[nRow])
         {
             SwTableBoxes &rBoxes = pLine->GetTabBoxes();
             pTabBox2 = rBoxes.empty() ? nullptr : rBoxes.front();
@@ -2668,46 +2668,46 @@ void WW8TabDesc::ParkPaM()
     sal_uLong nSttNd = pTabBox2->GetSttIdx() + 1,
               nEndNd = pTabBox2->GetSttNd()->EndOfSectionIndex();
 
-    if (pIo->m_pPaM->GetPoint()->nNode != nSttNd)
+    if (m_pIo->m_pPaM->GetPoint()->nNode != nSttNd)
     {
         do
         {
-            pIo->m_pPaM->GetPoint()->nNode = nSttNd;
+            m_pIo->m_pPaM->GetPoint()->nNode = nSttNd;
         }
-        while (pIo->m_pPaM->GetNode().GetNodeType() != ND_TEXTNODE && ++nSttNd < nEndNd);
+        while (m_pIo->m_pPaM->GetNode().GetNodeType() != ND_TEXTNODE && ++nSttNd < nEndNd);
 
-        pIo->m_pPaM->GetPoint()->nContent.Assign(pIo->m_pPaM->GetContentNode(), 0);
-        pIo->m_rDoc.SetTextFormatColl(*pIo->m_pPaM, const_cast<SwTextFormatColl*>(pIo->m_pDfltTextFormatColl));
+        m_pIo->m_pPaM->GetPoint()->nContent.Assign(m_pIo->m_pPaM->GetContentNode(), 0);
+        m_pIo->m_rDoc.SetTextFormatColl(*m_pIo->m_pPaM, const_cast<SwTextFormatColl*>(m_pIo->m_pDfltTextFormatColl));
     }
 }
 
 void WW8TabDesc::MoveOutsideTable()
 {
-    OSL_ENSURE(pTmpPos && pIo, "I've forgotten where the table is anchored");
-    if (pTmpPos && pIo)
-        *pIo->m_pPaM->GetPoint() = *pTmpPos;
+    OSL_ENSURE(m_pTmpPos && m_pIo, "I've forgotten where the table is anchored");
+    if (m_pTmpPos && m_pIo)
+        *m_pIo->m_pPaM->GetPoint() = *m_pTmpPos;
 }
 
 void WW8TabDesc::FinishSwTable()
 {
-    pIo->m_pRedlineStack->closeall(*pIo->m_pPaM->GetPoint());
-    delete pIo->m_pRedlineStack;
-    pIo->m_pRedlineStack = mpOldRedlineStack;
+    m_pIo->m_pRedlineStack->closeall(*m_pIo->m_pPaM->GetPoint());
+    delete m_pIo->m_pRedlineStack;
+    m_pIo->m_pRedlineStack = mpOldRedlineStack;
     mpOldRedlineStack = nullptr;
 
-    WW8DupProperties aDup(pIo->m_rDoc,pIo->m_pCtrlStck);
-    pIo->m_pCtrlStck->SetAttr( *pIo->m_pPaM->GetPoint(), 0, false);
+    WW8DupProperties aDup(m_pIo->m_rDoc,m_pIo->m_pCtrlStck);
+    m_pIo->m_pCtrlStck->SetAttr( *m_pIo->m_pPaM->GetPoint(), 0, false);
 
     MoveOutsideTable();
-    delete pTmpPos;
-    pTmpPos = nullptr;
+    delete m_pTmpPos;
+    m_pTmpPos = nullptr;
 
-    aDup.Insert(*pIo->m_pPaM->GetPoint());
+    aDup.Insert(*m_pIo->m_pPaM->GetPoint());
 
-    pIo->m_bWasTabRowEnd = false;
-    pIo->m_bWasTabCellEnd = false;
+    m_pIo->m_bWasTabRowEnd = false;
+    m_pIo->m_bWasTabCellEnd = false;
 
-    pIo->m_aInsertedTables.InsertTable(*pTableNd, *pIo->m_pPaM);
+    m_pIo->m_aInsertedTables.InsertTable(*m_pTableNd, *m_pIo->m_pPaM);
 
     MergeCells();
 
@@ -2732,7 +2732,7 @@ void WW8TabDesc::FinishSwTable()
                 }
             }
         }
-        pIo->m_pFormatOfJustInsertedApo = nullptr;
+        m_pIo->m_pFormatOfJustInsertedApo = nullptr;
         m_MergeGroups.clear();
     }
 
@@ -2744,9 +2744,9 @@ void WW8TabDesc::FinishSwTable()
     bool bDontSplit = false;
     sal_uInt32 nRow=0;
     std::vector< SwTextNode* > vEmulatedNodes;
-    while( bKeep && nRow < pTabLines->size() )
+    while( bKeep && nRow < m_pTabLines->size() )
     {
-        const SwTableLine* pIterTableRow = (*pTabLines)[ nRow ];
+        const SwTableLine* pIterTableRow = (*m_pTabLines)[ nRow ];
         const SwTableBoxes& rIterTableBoxes = pIterTableRow->GetTabBoxes();
         const SwTableBox* pIterFirstCell = rIterTableBoxes.empty() ? nullptr : rIterTableBoxes.front();
         // only for non-complex tables
@@ -2765,7 +2765,7 @@ void WW8TabDesc::FinishSwTable()
                 if( !pFirstParagraphNode->GetSwAttrSet().GetKeep().GetValue() )
                     bKeep = false;
                 // all rows except the last one have been kept
-                else if ( nRow == pTabLines->size() - 2 )
+                else if ( nRow == m_pTabLines->size() - 2 )
                     bDontSplit = true;
 
                 // save the node, so the paragraph's keep-with-next-paragraph setting can be removed later if it was added for the emulation
@@ -2785,9 +2785,9 @@ void WW8TabDesc::FinishSwTable()
         }
 
         // Set the table properties
-        pTable->GetFrameFormat()->SetFormatAttr(SwFormatLayoutSplit( false ));
+        m_pTable->GetFrameFormat()->SetFormatAttr(SwFormatLayoutSplit( false ));
         if( bKeep )
-            pTable->GetFrameFormat()->SetFormatAttr(SvxFormatKeepItem( true, RES_KEEP ));
+            m_pTable->GetFrameFormat()->SetFormatAttr(SvxFormatKeepItem( true, RES_KEEP ));
     }
 }
 
@@ -2853,15 +2853,15 @@ WW8SelBoxInfo* WW8TabDesc::FindMergeGroup(short nX1, short nWidth, bool bExact)
 
 bool WW8TabDesc::IsValidCell(short nCol) const
 {
-    return (static_cast<size_t>(nCol) < SAL_N_ELEMENTS(pActBand->bExist)) &&
-           pActBand->bExist[nCol] &&
-           (sal_uInt16)nAktRow < pTabLines->size();
+    return (static_cast<size_t>(nCol) < SAL_N_ELEMENTS(m_pActBand->bExist)) &&
+           m_pActBand->bExist[nCol] &&
+           (sal_uInt16)m_nAktRow < m_pTabLines->size();
 }
 
 bool WW8TabDesc::InFirstParaInCell() const
 {
     //e.g. #i19718#
-    if (!pTabBox || !pTabBox->GetSttNd())
+    if (!m_pTabBox || !m_pTabBox->GetSttNd())
     {
         OSL_FAIL("Problem with table");
         return false;
@@ -2870,7 +2870,7 @@ bool WW8TabDesc::InFirstParaInCell() const
     if (!IsValidCell(GetAktCol()))
         return false;
 
-    if (pIo->m_pPaM->GetPoint()->nNode == pTabBox->GetSttIdx() + 1)
+    if (m_pIo->m_pPaM->GetPoint()->nNode == m_pTabBox->GetSttIdx() + 1)
         return true;
 
     return false;
@@ -2878,30 +2878,30 @@ bool WW8TabDesc::InFirstParaInCell() const
 
 void WW8TabDesc::StartMiserableHackForUnsupportedDirection(short nWwCol)
 {
-    OSL_ENSURE(pActBand, "Impossible");
-    if (pActBand && pActBand->maDirections[nWwCol] == 3)
+    OSL_ENSURE(m_pActBand, "Impossible");
+    if (m_pActBand && m_pActBand->maDirections[nWwCol] == 3)
     {
-        pIo->m_pCtrlStck->NewAttr(*pIo->m_pPaM->GetPoint(),
+        m_pIo->m_pCtrlStck->NewAttr(*m_pIo->m_pPaM->GetPoint(),
             SvxCharRotateItem(900, false, RES_CHRATR_ROTATE));
     }
 }
 
 void WW8TabDesc::EndMiserableHackForUnsupportedDirection(short nWwCol)
 {
-    OSL_ENSURE(pActBand, "Impossible");
-    if (pActBand && pActBand->maDirections[nWwCol] == 3)
-        pIo->m_pCtrlStck->SetAttr(*pIo->m_pPaM->GetPoint(), RES_CHRATR_ROTATE);
+    OSL_ENSURE(m_pActBand, "Impossible");
+    if (m_pActBand && m_pActBand->maDirections[nWwCol] == 3)
+        m_pIo->m_pCtrlStck->SetAttr(*m_pIo->m_pPaM->GetPoint(), RES_CHRATR_ROTATE);
 }
 
 void WW8TabDesc::SetPamInCell(short nWwCol, bool bPam)
 {
-    OSL_ENSURE( pActBand, "pActBand ist 0" );
-    if (!pActBand)
+    OSL_ENSURE( m_pActBand, "pActBand ist 0" );
+    if (!m_pActBand)
         return;
 
-    sal_uInt16 nCol = pActBand->transCell(nWwCol);
+    sal_uInt16 nCol = m_pActBand->transCell(nWwCol);
 
-    if ((sal_uInt16)nAktRow >= pTabLines->size())
+    if ((sal_uInt16)m_nAktRow >= m_pTabLines->size())
     {
         OSL_ENSURE(false, "Actual row bigger than expected." );
         if (bPam)
@@ -2909,75 +2909,75 @@ void WW8TabDesc::SetPamInCell(short nWwCol, bool bPam)
         return;
     }
 
-    pTabLine = (*pTabLines)[nAktRow];
-    pTabBoxes = &pTabLine->GetTabBoxes();
+    m_pTabLine = (*m_pTabLines)[m_nAktRow];
+    m_pTabBoxes = &m_pTabLine->GetTabBoxes();
 
-    if (nCol >= pTabBoxes->size())
+    if (nCol >= m_pTabBoxes->size())
     {
         if (bPam)
         {
             // The first paragraph in a cell with upper autospacing has upper
             // spacing set to 0
             if (
-                 pIo->m_bParaAutoBefore && pIo->m_bFirstPara &&
-                 !pIo->m_pWDop->fDontUseHTMLAutoSpacing
+                 m_pIo->m_bParaAutoBefore && m_pIo->m_bFirstPara &&
+                 !m_pIo->m_pWDop->fDontUseHTMLAutoSpacing
                )
             {
-                pIo->SetUpperSpacing(*pIo->m_pPaM, 0);
+                m_pIo->SetUpperSpacing(*m_pIo->m_pPaM, 0);
             }
 
             // The last paragraph in a cell with lower autospacing has lower
             // spacing set to 0
-            if (pIo->m_bParaAutoAfter && !pIo->m_pWDop->fDontUseHTMLAutoSpacing)
-                pIo->SetLowerSpacing(*pIo->m_pPaM, 0);
+            if (m_pIo->m_bParaAutoAfter && !m_pIo->m_pWDop->fDontUseHTMLAutoSpacing)
+                m_pIo->SetLowerSpacing(*m_pIo->m_pPaM, 0);
 
             ParkPaM();
         }
         return;
     }
-    pTabBox = (*pTabBoxes)[nCol];
-    if( !pTabBox->GetSttNd() )
+    m_pTabBox = (*m_pTabBoxes)[nCol];
+    if( !m_pTabBox->GetSttNd() )
     {
-        OSL_ENSURE(pTabBox->GetSttNd(), "Probleme beim Aufbau der Tabelle");
+        OSL_ENSURE(m_pTabBox->GetSttNd(), "Probleme beim Aufbau der Tabelle");
         if (bPam)
             MoveOutsideTable();
         return;
     }
     if (bPam)
     {
-        pAktWWCell = &pActBand->pTCs[ nWwCol ];
+        m_pAktWWCell = &m_pActBand->pTCs[ nWwCol ];
 
        // The first paragraph in a cell with upper autospacing has upper spacing set to 0
-        if(pIo->m_bParaAutoBefore && pIo->m_bFirstPara && !pIo->m_pWDop->fDontUseHTMLAutoSpacing)
-            pIo->SetUpperSpacing(*pIo->m_pPaM, 0);
+        if(m_pIo->m_bParaAutoBefore && m_pIo->m_bFirstPara && !m_pIo->m_pWDop->fDontUseHTMLAutoSpacing)
+            m_pIo->SetUpperSpacing(*m_pIo->m_pPaM, 0);
 
         // The last paragraph in a cell with lower autospacing has lower spacing set to 0
-        if(pIo->m_bParaAutoAfter && !pIo->m_pWDop->fDontUseHTMLAutoSpacing)
-            pIo->SetLowerSpacing(*pIo->m_pPaM, 0);
+        if(m_pIo->m_bParaAutoAfter && !m_pIo->m_pWDop->fDontUseHTMLAutoSpacing)
+            m_pIo->SetLowerSpacing(*m_pIo->m_pPaM, 0);
 
         //We need to set the pPaM on the first cell, invalid
         //or not so that we can collect paragraph properties over
         //all the cells, but in that case on the valid cell we do not
         //want to reset the fmt properties
-        sal_uLong nSttNd = pTabBox->GetSttIdx() + 1,
-                  nEndNd = pTabBox->GetSttNd()->EndOfSectionIndex();
-        if (pIo->m_pPaM->GetPoint()->nNode != nSttNd)
+        sal_uLong nSttNd = m_pTabBox->GetSttIdx() + 1,
+                  nEndNd = m_pTabBox->GetSttNd()->EndOfSectionIndex();
+        if (m_pIo->m_pPaM->GetPoint()->nNode != nSttNd)
         {
             do
             {
-                pIo->m_pPaM->GetPoint()->nNode = nSttNd;
+                m_pIo->m_pPaM->GetPoint()->nNode = nSttNd;
             }
-            while (pIo->m_pPaM->GetNode().GetNodeType() != ND_TEXTNODE && ++nSttNd < nEndNd);
-            pIo->m_pPaM->GetPoint()->nContent.Assign(pIo->m_pPaM->GetContentNode(), 0);
+            while (m_pIo->m_pPaM->GetNode().GetNodeType() != ND_TEXTNODE && ++nSttNd < nEndNd);
+            m_pIo->m_pPaM->GetPoint()->nContent.Assign(m_pIo->m_pPaM->GetContentNode(), 0);
             // Precautionally set now, otherwise the style is not set for cells
             // that are inserted for margin balancing.
-            pIo->m_rDoc.SetTextFormatColl(*pIo->m_pPaM, const_cast<SwTextFormatColl*>(pIo->m_pDfltTextFormatColl));
+            m_pIo->m_rDoc.SetTextFormatColl(*m_pIo->m_pPaM, const_cast<SwTextFormatColl*>(m_pIo->m_pDfltTextFormatColl));
             // because this cells are invisible helper constructions only to simulate
             // the frayed view of WW-tables we do NOT need SetTextFormatCollAndListLevel()
         }
 
         // Better to turn Snap to Grid off for all paragraphs in tables
-        if(SwTextNode *pNd = pIo->m_pPaM->GetNode().GetTextNode())
+        if(SwTextNode *pNd = m_pIo->m_pPaM->GetNode().GetTextNode())
         {
             const SfxPoolItem &rItm = pNd->SwContentNode::GetAttr(RES_PARATR_SNAPTOGRID);
             const SvxParaGridItem &rSnapToGrid = static_cast<const SvxParaGridItem&>(rItm);
@@ -2987,13 +2987,13 @@ void WW8TabDesc::SetPamInCell(short nWwCol, bool bPam)
                 SvxParaGridItem aGridItem( rSnapToGrid );
                 aGridItem.SetValue(false);
 
-                SwPosition* pGridPos = pIo->m_pPaM->GetPoint();
+                SwPosition* pGridPos = m_pIo->m_pPaM->GetPoint();
 
                 const sal_Int32 nEnd = pGridPos->nContent.GetIndex();
-                pGridPos->nContent.Assign(pIo->m_pPaM->GetContentNode(), 0);
-                pIo->m_pCtrlStck->NewAttr(*pGridPos, aGridItem);
-                pGridPos->nContent.Assign(pIo->m_pPaM->GetContentNode(), nEnd);
-                pIo->m_pCtrlStck->SetAttr(*pGridPos, RES_PARATR_SNAPTOGRID);
+                pGridPos->nContent.Assign(m_pIo->m_pPaM->GetContentNode(), 0);
+                m_pIo->m_pCtrlStck->NewAttr(*pGridPos, aGridItem);
+                pGridPos->nContent.Assign(m_pIo->m_pPaM->GetContentNode(), nEnd);
+                m_pIo->m_pCtrlStck->SetAttr(*pGridPos, RES_PARATR_SNAPTOGRID);
             }
         }
 
@@ -3003,63 +3003,63 @@ void WW8TabDesc::SetPamInCell(short nWwCol, bool bPam)
 
 void WW8TabDesc::InsertCells( short nIns )
 {
-    pTabLine = (*pTabLines)[nAktRow];
-    pTabBoxes = &pTabLine->GetTabBoxes();
-    pTabBox = (*pTabBoxes)[0];
+    m_pTabLine = (*m_pTabLines)[m_nAktRow];
+    m_pTabBoxes = &m_pTabLine->GetTabBoxes();
+    m_pTabBox = (*m_pTabBoxes)[0];
 
-    pIo->m_rDoc.GetNodes().InsBoxen( pTableNd, pTabLine, static_cast<SwTableBoxFormat*>(pTabBox->GetFrameFormat()),
-                            const_cast<SwTextFormatColl*>(pIo->m_pDfltTextFormatColl), nullptr, pTabBoxes->size(), nIns );
+    m_pIo->m_rDoc.GetNodes().InsBoxen( m_pTableNd, m_pTabLine, static_cast<SwTableBoxFormat*>(m_pTabBox->GetFrameFormat()),
+                            const_cast<SwTextFormatColl*>(m_pIo->m_pDfltTextFormatColl), nullptr, m_pTabBoxes->size(), nIns );
     // The third parameter contains the FrameFormat of the boxes.
     // Here it is possible to optimize to save (reduce) FrameFormats.
 }
 
 void WW8TabDesc::SetTabBorders(SwTableBox* pBox, short nWwIdx)
 {
-    if( nWwIdx < 0 || nWwIdx >= pActBand->nWwCols )
+    if( nWwIdx < 0 || nWwIdx >= m_pActBand->nWwCols )
         return;                 // faked cells -> no border
 
     SvxBoxItem aFormatBox( RES_BOX );
-    if (pActBand->pTCs)     // neither Cell Border nor Default Border defined ?
+    if (m_pActBand->pTCs)     // neither Cell Border nor Default Border defined ?
     {
-        WW8_TCell* pT = &pActBand->pTCs[nWwIdx];
+        WW8_TCell* pT = &m_pActBand->pTCs[nWwIdx];
         if (SwWW8ImplReader::IsBorder(pT->rgbrc))
             SwWW8ImplReader::SetBorder(aFormatBox, pT->rgbrc);
     }
 
-    if (pActBand->nOverrideSpacing[nWwIdx] & (1 << WW8TabBandDesc::wwTOP))
+    if (m_pActBand->nOverrideSpacing[nWwIdx] & (1 << WW8TabBandDesc::wwTOP))
     {
         aFormatBox.SetDistance(
-            pActBand->nOverrideValues[nWwIdx][WW8TabBandDesc::wwTOP],
+            m_pActBand->nOverrideValues[nWwIdx][WW8TabBandDesc::wwTOP],
             SvxBoxItemLine::TOP);
     }
     else
-        aFormatBox.SetDistance(pActBand->mnDefaultTop, SvxBoxItemLine::TOP);
-    if (pActBand->nOverrideSpacing[nWwIdx] & (1 << WW8TabBandDesc::wwBOTTOM))
+        aFormatBox.SetDistance(m_pActBand->mnDefaultTop, SvxBoxItemLine::TOP);
+    if (m_pActBand->nOverrideSpacing[nWwIdx] & (1 << WW8TabBandDesc::wwBOTTOM))
     {
         aFormatBox.SetDistance(
-            pActBand->nOverrideValues[nWwIdx][WW8TabBandDesc::wwBOTTOM],
+            m_pActBand->nOverrideValues[nWwIdx][WW8TabBandDesc::wwBOTTOM],
             SvxBoxItemLine::BOTTOM);
     }
     else
-        aFormatBox.SetDistance(pActBand->mnDefaultBottom,SvxBoxItemLine::BOTTOM);
+        aFormatBox.SetDistance(m_pActBand->mnDefaultBottom,SvxBoxItemLine::BOTTOM);
 
     // nGapHalf for WW is a *horizontal* gap between table cell and content.
     short nLeftDist =
-        pActBand->mbHasSpacing ? pActBand->mnDefaultLeft : pActBand->nGapHalf;
+        m_pActBand->mbHasSpacing ? m_pActBand->mnDefaultLeft : m_pActBand->nGapHalf;
     short nRightDist =
-        pActBand->mbHasSpacing ? pActBand->mnDefaultRight : pActBand->nGapHalf;
-    if (pActBand->nOverrideSpacing[nWwIdx] & (1 << WW8TabBandDesc::wwLEFT))
+        m_pActBand->mbHasSpacing ? m_pActBand->mnDefaultRight : m_pActBand->nGapHalf;
+    if (m_pActBand->nOverrideSpacing[nWwIdx] & (1 << WW8TabBandDesc::wwLEFT))
     {
         aFormatBox.SetDistance(
-            pActBand->nOverrideValues[nWwIdx][WW8TabBandDesc::wwLEFT],
+            m_pActBand->nOverrideValues[nWwIdx][WW8TabBandDesc::wwLEFT],
             SvxBoxItemLine::LEFT);
     }
     else
         aFormatBox.SetDistance(nLeftDist, SvxBoxItemLine::LEFT);
-    if (pActBand->nOverrideSpacing[nWwIdx] & (1 << WW8TabBandDesc::wwRIGHT))
+    if (m_pActBand->nOverrideSpacing[nWwIdx] & (1 << WW8TabBandDesc::wwRIGHT))
     {
         aFormatBox.SetDistance(
-            pActBand->nOverrideValues[nWwIdx][WW8TabBandDesc::wwRIGHT],
+            m_pActBand->nOverrideValues[nWwIdx][WW8TabBandDesc::wwRIGHT],
             SvxBoxItemLine::RIGHT);
     }
     else
@@ -3070,25 +3070,25 @@ void WW8TabDesc::SetTabBorders(SwTableBox* pBox, short nWwIdx)
 
 void WW8TabDesc::SetTabShades( SwTableBox* pBox, short nWwIdx )
 {
-    if( nWwIdx < 0 || nWwIdx >= pActBand->nWwCols )
+    if( nWwIdx < 0 || nWwIdx >= m_pActBand->nWwCols )
         return;                 // faked cells -> no color
 
     bool bFound=false;
-    if (pActBand->pNewSHDs && pActBand->pNewSHDs[nWwIdx] != COL_AUTO)
+    if (m_pActBand->pNewSHDs && m_pActBand->pNewSHDs[nWwIdx] != COL_AUTO)
     {
-        Color aColor(pActBand->pNewSHDs[nWwIdx]);
+        Color aColor(m_pActBand->pNewSHDs[nWwIdx]);
         pBox->GetFrameFormat()->SetFormatAttr(SvxBrushItem(aColor, RES_BACKGROUND));
         bFound = true;
     }
 
     //If there was no new shades, or no new shade setting
-    if (pActBand->pSHDs && !bFound)
+    if (m_pActBand->pSHDs && !bFound)
     {
-        WW8_SHD& rSHD = pActBand->pSHDs[nWwIdx];
+        WW8_SHD& rSHD = m_pActBand->pSHDs[nWwIdx];
         if (!rSHD.GetValue())       // auto
             return;
 
-        SwWW8Shade aSh( pIo->m_bVer67, rSHD );
+        SwWW8Shade aSh( m_pIo->m_bVer67, rSHD );
         pBox->GetFrameFormat()->SetFormatAttr(SvxBrushItem(aSh.aColor, RES_BACKGROUND));
     }
 }
@@ -3123,22 +3123,22 @@ SvxFrameDirection MakeDirection(sal_uInt16 nCode, bool bIsBiDi)
 
 void WW8TabDesc::SetTabDirection(SwTableBox* pBox, short nWwIdx)
 {
-    if (nWwIdx < 0 || nWwIdx >= pActBand->nWwCols)
+    if (nWwIdx < 0 || nWwIdx >= m_pActBand->nWwCols)
         return;
-    SvxFrameDirectionItem aItem(MakeDirection(pActBand->maDirections[nWwIdx], bIsBiDi), RES_FRAMEDIR);
+    SvxFrameDirectionItem aItem(MakeDirection(m_pActBand->maDirections[nWwIdx], m_bIsBiDi), RES_FRAMEDIR);
     pBox->GetFrameFormat()->SetFormatAttr(aItem);
 }
 
 void WW8TabDesc::SetTabVertAlign( SwTableBox* pBox, short nWwIdx )
 {
-    if( nWwIdx < 0 || nWwIdx >= pActBand->nWwCols )
+    if( nWwIdx < 0 || nWwIdx >= m_pActBand->nWwCols )
         return;
 
     sal_Int16 eVertOri=text::VertOrientation::TOP;
 
-    if( pActBand->pTCs )
+    if( m_pActBand->pTCs )
     {
-        WW8_TCell* pT = &pActBand->pTCs[nWwIdx];
+        WW8_TCell* pT = &m_pActBand->pTCs[nWwIdx];
         switch (pT->nVertAlign)
         {
             case 0:
@@ -3159,69 +3159,69 @@ void WW8TabDesc::SetTabVertAlign( SwTableBox* pBox, short nWwIdx )
 
 void WW8TabDesc::AdjustNewBand()
 {
-    if( pActBand->nSwCols > nDefaultSwCols )        // split cells
-        InsertCells( pActBand->nSwCols - nDefaultSwCols );
+    if( m_pActBand->nSwCols > m_nDefaultSwCols )        // split cells
+        InsertCells( m_pActBand->nSwCols - m_nDefaultSwCols );
 
     SetPamInCell( 0, false);
-    OSL_ENSURE( pTabBoxes && pTabBoxes->size() == (sal_uInt16)pActBand->nSwCols,
+    OSL_ENSURE( m_pTabBoxes && m_pTabBoxes->size() == (sal_uInt16)m_pActBand->nSwCols,
         "Falsche Spaltenzahl in Tabelle" );
 
-    if( bClaimLineFormat )
+    if( m_bClaimLineFormat )
     {
-        pTabLine->ClaimFrameFormat();            // necessary because of cell height
+        m_pTabLine->ClaimFrameFormat();            // necessary because of cell height
         SwFormatFrameSize aF( ATT_MIN_SIZE, 0, 0 );  // default
 
-        if (pActBand->nLineHeight == 0)    // 0 = Auto
+        if (m_pActBand->nLineHeight == 0)    // 0 = Auto
             aF.SetHeightSizeType( ATT_VAR_SIZE );
         else
         {
-            if (pActBand->nLineHeight < 0) // positive = min, negative = exact
+            if (m_pActBand->nLineHeight < 0) // positive = min, negative = exact
             {
                 aF.SetHeightSizeType(ATT_FIX_SIZE);
-                pActBand->nLineHeight = -pActBand->nLineHeight;
+                m_pActBand->nLineHeight = -m_pActBand->nLineHeight;
             }
-            if (pActBand->nLineHeight < MINLAY) // invalid cell height
-                pActBand->nLineHeight = MINLAY;
+            if (m_pActBand->nLineHeight < MINLAY) // invalid cell height
+                m_pActBand->nLineHeight = MINLAY;
 
-            aF.SetHeight(pActBand->nLineHeight);// set min/exact height
+            aF.SetHeight(m_pActBand->nLineHeight);// set min/exact height
         }
-        pTabLine->GetFrameFormat()->SetFormatAttr(aF);
+        m_pTabLine->GetFrameFormat()->SetFormatAttr(aF);
     }
 
     //Word stores 1 for bCantSplit if the row cannot be split, we set true if
     //we can split the row
-    bool bSetCantSplit = pActBand->bCantSplit;
-    pTabLine->GetFrameFormat()->SetFormatAttr(SwFormatRowSplit(!bSetCantSplit));
+    bool bSetCantSplit = m_pActBand->bCantSplit;
+    m_pTabLine->GetFrameFormat()->SetFormatAttr(SwFormatRowSplit(!bSetCantSplit));
 
     //  if table is only a single row, and row is set as don't split, set the same value for the whole table.
-    if( bSetCantSplit && pTabLines->size() == 1 )
-        pTable->GetFrameFormat()->SetFormatAttr(SwFormatLayoutSplit( !bSetCantSplit ));
+    if( bSetCantSplit && m_pTabLines->size() == 1 )
+        m_pTable->GetFrameFormat()->SetFormatAttr(SwFormatLayoutSplit( !bSetCantSplit ));
 
     short i;    // SW-Index
     short j;    // WW-Index
     short nW;   // Width
     SwFormatFrameSize aFS( ATT_FIX_SIZE );
-    j = pActBand->bLEmptyCol ? -1 : 0;
+    j = m_pActBand->bLEmptyCol ? -1 : 0;
 
-    for( i = 0; i < pActBand->nSwCols; i++ )
+    for( i = 0; i < m_pActBand->nSwCols; i++ )
     {
         // set cell width
         if( j < 0 )
-            nW = pActBand->nCenter[0] - nMinLeft;
+            nW = m_pActBand->nCenter[0] - m_nMinLeft;
         else
         {
             //Set j to first non invalid cell
-            while ((j < pActBand->nWwCols) && (!pActBand->bExist[j]))
+            while ((j < m_pActBand->nWwCols) && (!m_pActBand->bExist[j]))
                 j++;
 
-            if( j < pActBand->nWwCols )
-                nW = pActBand->nCenter[j+1] - pActBand->nCenter[j];
+            if( j < m_pActBand->nWwCols )
+                nW = m_pActBand->nCenter[j+1] - m_pActBand->nCenter[j];
             else
-                nW = nMaxRight - pActBand->nCenter[j];
-            pActBand->nWidth[ j ] = nW;
+                nW = m_nMaxRight - m_pActBand->nCenter[j];
+            m_pActBand->nWidth[ j ] = nW;
         }
 
-        SwTableBox* pBox = (*pTabBoxes)[i];
+        SwTableBox* pBox = (*m_pTabBoxes)[i];
         // could be reduced further by intelligent moving of FrameFormats
         pBox->ClaimFrameFormat();
 
@@ -3238,7 +3238,7 @@ void WW8TabDesc::AdjustNewBand()
 
         if (i != 0)
         {
-            SwTableBox* pBox2 = (*pTabBoxes)[i-1];
+            SwTableBox* pBox2 = (*m_pTabBoxes)[i-1];
             SvxBoxItem aOldBox(sw::util::ItemGet<SvxBoxItem>(*(pBox2->GetFrameFormat()), RES_BOX));
             const ::editeng::SvxBorderLine *pRightLine = aOldBox.GetLine(SvxBoxItemLine::RIGHT);
             int nOldBoxRightLineWidth = 0;
@@ -3256,7 +3256,7 @@ void WW8TabDesc::AdjustNewBand()
 
         SetTabVertAlign(pBox, j);
         SetTabDirection(pBox, j);
-        if( pActBand->pSHDs || pActBand->pNewSHDs)
+        if( m_pActBand->pSHDs || m_pActBand->pNewSHDs)
             SetTabShades(pBox, j);
         j++;
 
@@ -3264,9 +3264,9 @@ void WW8TabDesc::AdjustNewBand()
         pBox->GetFrameFormat()->SetFormatAttr( aFS );
 
         // skip non existing cells
-        while( ( j < pActBand->nWwCols ) && !pActBand->bExist[j] )
+        while( ( j < m_pActBand->nWwCols ) && !m_pActBand->bExist[j] )
         {
-            pActBand->nWidth[j] = pActBand->nCenter[j+1] - pActBand->nCenter[j];
+            m_pActBand->nWidth[j] = m_pActBand->nCenter[j+1] - m_pActBand->nCenter[j];
             j++;
         }
     }
@@ -3274,57 +3274,57 @@ void WW8TabDesc::AdjustNewBand()
 
 void WW8TabDesc::TableCellEnd()
 {
-    ::SetProgressState(pIo->m_nProgress, pIo->m_pDocShell);   // Update
+    ::SetProgressState(m_pIo->m_nProgress, m_pIo->m_pDocShell);   // Update
 
-    EndMiserableHackForUnsupportedDirection(nAktCol);
+    EndMiserableHackForUnsupportedDirection(m_nAktCol);
 
     // new line/row
-    if( pIo->m_bWasTabRowEnd )
+    if( m_pIo->m_bWasTabRowEnd )
     {
         // bWasTabRowEnd will be deactivated in
         // SwWW8ImplReader::ProcessSpecial()
 
         sal_uInt16 iCol = GetLogicalWWCol();
-        if (iCol < aNumRuleNames.size())
+        if (iCol < m_aNumRuleNames.size())
         {
-            aNumRuleNames.erase(aNumRuleNames.begin() + iCol,
-                aNumRuleNames.end());
+            m_aNumRuleNames.erase(m_aNumRuleNames.begin() + iCol,
+                m_aNumRuleNames.end());
         }
 
-        nAktCol = 0;
-        nAktRow++;
-        nAktBandRow++;
-        OSL_ENSURE( pActBand , "pActBand ist 0" );
-        if( pActBand )
+        m_nAktCol = 0;
+        m_nAktRow++;
+        m_nAktBandRow++;
+        OSL_ENSURE( m_pActBand , "pActBand ist 0" );
+        if( m_pActBand )
         {
-            if( nAktRow >= nRows )  // nothing to at end of table
+            if( m_nAktRow >= m_nRows )  // nothing to at end of table
                 return;
 
-            bool bNewBand = nAktBandRow >= pActBand->nRows;
+            bool bNewBand = m_nAktBandRow >= m_pActBand->nRows;
             if( bNewBand )
             {                       // new band needed ?
-                pActBand = pActBand->pNextBand;
-                nAktBandRow = 0;
-                OSL_ENSURE( pActBand, "pActBand ist 0" );
+                m_pActBand = m_pActBand->pNextBand;
+                m_nAktBandRow = 0;
+                OSL_ENSURE( m_pActBand, "pActBand ist 0" );
                 AdjustNewBand();
             }
             else
             {
-                SwTableBox* pBox = (*pTabBoxes)[0];
+                SwTableBox* pBox = (*m_pTabBoxes)[0];
                 SwSelBoxes aBoxes;
-                pIo->m_rDoc.InsertRow( SwTable::SelLineFromBox( pBox, aBoxes ) );
+                m_pIo->m_rDoc.InsertRow( SwTable::SelLineFromBox( pBox, aBoxes ) );
             }
         }
     }
     else
     {                       // new column ( cell )
-        nAktCol++;
+        m_nAktCol++;
     }
-    SetPamInCell(nAktCol, true);
+    SetPamInCell(m_nAktCol, true);
 
     // finish Annotated Level Numbering ?
-    if (pIo->m_bAnl && !pIo->m_bAktAND_fNumberAcross && pActBand)
-        pIo->StopAllAnl(IsValidCell(nAktCol));
+    if (m_pIo->m_bAnl && !m_pIo->m_bAktAND_fNumberAcross && m_pActBand)
+        m_pIo->StopAllAnl(IsValidCell(m_nAktCol));
 }
 
 // if necessary register the box for the merge group for this column
@@ -3338,7 +3338,7 @@ void WW8TabDesc::UpdateTableMergeGroup(  WW8_TCell&     rCell,
     // E.g., it could be that a cell is the first one to be merged, but no
     // new merge group is provided, because the potential other cell to be merged
     // doesn't exist - see method <WW8TabDesc::MergeCells>.
-    if ( pActBand->bExist[ nCol ] &&
+    if ( m_pActBand->bExist[ nCol ] &&
          ( ( rCell.bFirstMerged && pActGroup ) ||
            rCell.bMerged ||
            rCell.bVertMerge ||
@@ -3353,7 +3353,7 @@ void WW8TabDesc::UpdateTableMergeGroup(  WW8_TCell&     rCell,
         {
             // find group
             pTheMergeGroup = FindMergeGroup(
-                pActBand->nCenter[ nCol ], pActBand->nWidth[  nCol ], true );
+                m_pActBand->nCenter[ nCol ], m_pActBand->nWidth[  nCol ], true );
         }
         if( pTheMergeGroup )
         {
@@ -3366,11 +3366,11 @@ void WW8TabDesc::UpdateTableMergeGroup(  WW8_TCell&     rCell,
 sal_uInt16 WW8TabDesc::GetLogicalWWCol() const // returns number of col as INDICATED within WW6 UI status line -1
 {
     sal_uInt16 nCol = 0;
-    if( pActBand && pActBand->pTCs)
+    if( m_pActBand && m_pActBand->pTCs)
     {
-        for( sal_uInt16 iCol = 1; iCol <= nAktCol && iCol <= pActBand->nWwCols; ++iCol )
+        for( sal_uInt16 iCol = 1; iCol <= m_nAktCol && iCol <= m_pActBand->nWwCols; ++iCol )
         {
-            if( !pActBand->pTCs[ iCol-1 ].bMerged )
+            if( !m_pActBand->pTCs[ iCol-1 ].bMerged )
                 ++nCol;
         }
     }
@@ -3381,17 +3381,17 @@ sal_uInt16 WW8TabDesc::GetLogicalWWCol() const // returns number of col as INDIC
 OUString WW8TabDesc::GetNumRuleName() const
 {
     sal_uInt16 nCol = GetLogicalWWCol();
-    if (nCol < aNumRuleNames.size())
-        return aNumRuleNames[nCol];
+    if (nCol < m_aNumRuleNames.size())
+        return m_aNumRuleNames[nCol];
     return OUString();
 }
 
 void WW8TabDesc::SetNumRuleName( const OUString& rName )
 {
     sal_uInt16 nCol = GetLogicalWWCol();
-    for (sal_uInt16 nSize = static_cast< sal_uInt16 >(aNumRuleNames.size()); nSize <= nCol; ++nSize)
-        aNumRuleNames.push_back(OUString());
-    aNumRuleNames[nCol] = rName;
+    for (sal_uInt16 nSize = static_cast< sal_uInt16 >(m_aNumRuleNames.size()); nSize <= nCol; ++nSize)
+        m_aNumRuleNames.push_back(OUString());
+    m_aNumRuleNames[nCol] = rName;
 }
 
 bool SwWW8ImplReader::StartTable(WW8_CP nStartCp, SvxULSpaceItem* pULSpaceItem)
@@ -3463,44 +3463,44 @@ bool SwWW8ImplReader::StartTable(WW8_CP nStartCp, SvxULSpaceItem* pULSpaceItem)
         if ((eAnchor == FLY_AT_CHAR)
             && !m_aTableStack.empty() && !InEqualApo(nNewInTable) )
         {
-            m_pTableDesc->pParentPos = new SwPosition(*m_pPaM->GetPoint());
+            m_pTableDesc->m_pParentPos = new SwPosition(*m_pPaM->GetPoint());
             SfxItemSet aItemSet(m_rDoc.GetAttrPool(),
                                 RES_FRMATR_BEGIN, RES_FRMATR_END-1);
             // #i33818# - anchor the Writer fly frame for the nested table at-character.
             // #i45301#
             SwFormatAnchor aAnchor( eAnchor );
-            aAnchor.SetAnchor( m_pTableDesc->pParentPos );
+            aAnchor.SetAnchor( m_pTableDesc->m_pParentPos );
             aItemSet.Put( aAnchor );
-            m_pTableDesc->pFlyFormat = m_rDoc.MakeFlySection( eAnchor,
-                                                      m_pTableDesc->pParentPos, &aItemSet);
-            OSL_ENSURE( m_pTableDesc->pFlyFormat->GetAnchor().GetAnchorId() == eAnchor,
+            m_pTableDesc->m_pFlyFormat = m_rDoc.MakeFlySection( eAnchor,
+                                                      m_pTableDesc->m_pParentPos, &aItemSet);
+            OSL_ENSURE( m_pTableDesc->m_pFlyFormat->GetAnchor().GetAnchorId() == eAnchor,
                    "Not the anchor type requested!" );
-            MoveInsideFly(m_pTableDesc->pFlyFormat);
+            MoveInsideFly(m_pTableDesc->m_pFlyFormat);
         }
         m_pTableDesc->CreateSwTable(pULSpaceItem);
-        if (m_pTableDesc->pFlyFormat)
+        if (m_pTableDesc->m_pFlyFormat)
         {
-            m_pTableDesc->SetSizePosition(m_pTableDesc->pFlyFormat);
+            m_pTableDesc->SetSizePosition(m_pTableDesc->m_pFlyFormat);
             // #i33818# - Use absolute position object attributes,
             // if existing, and apply them to the created Writer fly frame.
             if ( pTableWFlyPara && pTableSFlyPara )
             {
                 WW8FlySet aFlySet( *this, pTableWFlyPara, pTableSFlyPara, false );
                 SwFormatAnchor aAnchor( FLY_AT_CHAR );
-                aAnchor.SetAnchor( m_pTableDesc->pParentPos );
+                aAnchor.SetAnchor( m_pTableDesc->m_pParentPos );
                 aFlySet.Put( aAnchor );
-                m_pTableDesc->pFlyFormat->SetFormatAttr( aFlySet );
+                m_pTableDesc->m_pFlyFormat->SetFormatAttr( aFlySet );
             }
             else
             {
                 SwFormatHoriOrient aHori =
-                            m_pTableDesc->pTable->GetFrameFormat()->GetHoriOrient();
-                m_pTableDesc->pFlyFormat->SetFormatAttr(aHori);
-                m_pTableDesc->pFlyFormat->SetFormatAttr( SwFormatSurround( SURROUND_NONE ) );
+                            m_pTableDesc->m_pTable->GetFrameFormat()->GetHoriOrient();
+                m_pTableDesc->m_pFlyFormat->SetFormatAttr(aHori);
+                m_pTableDesc->m_pFlyFormat->SetFormatAttr( SwFormatSurround( SURROUND_NONE ) );
             }
             // #i33818# - The nested table doesn't have to leave
             // the table cell. Thus, the Writer fly frame has to follow the text flow.
-            m_pTableDesc->pFlyFormat->SetFormatAttr( SwFormatFollowTextFlow( true ) );
+            m_pTableDesc->m_pFlyFormat->SetFormatAttr( SwFormatFollowTextFlow( true ) );
         }
         else
             m_pTableDesc->SetSizePosition(nullptr);
@@ -3540,9 +3540,9 @@ void SwWW8ImplReader::Read_TabRowEnd( sal_uInt16, const sal_uInt8* pData, short
 
 void SwWW8ImplReader::PopTableDesc()
 {
-    if (m_pTableDesc && m_pTableDesc->pFlyFormat)
+    if (m_pTableDesc && m_pTableDesc->m_pFlyFormat)
     {
-        MoveOutsideFly(m_pTableDesc->pFlyFormat,*m_pTableDesc->pParentPos);
+        MoveOutsideFly(m_pTableDesc->m_pFlyFormat,*m_pTableDesc->m_pParentPos);
     }
 
     delete m_pTableDesc;