[Libreoffice-commits] core.git: sw/source
Miklos Vajna
vmiklos at collabora.co.uk
Wed Nov 2 10:09:26 UTC 2016
sw/source/filter/ww8/ww8par2.cxx | 798 +++++++++++++++++++--------------------
1 file changed, 399 insertions(+), 399 deletions(-)
New commits:
commit 852bd9c2c8f13f9aded7528896121e993cd81e40
Author: Miklos Vajna <vmiklos at collabora.co.uk>
Date: Wed Nov 2 10:08:23 2016 +0100
sw: prefix members of WW8TabDesc
Change-Id: I8c6e52d40f497fb7cee3ef812e2974aa292a11a8
diff --git a/sw/source/filter/ww8/ww8par2.cxx b/sw/source/filter/ww8/ww8par2.cxx
index f7ddc8b..0f9f245 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;
More information about the Libreoffice-commits
mailing list