[Libreoffice-commits] core.git: sw/inc sw/source
Miklos Vajna
vmiklos at collabora.co.uk
Mon May 22 10:38:10 UTC 2017
sw/inc/cellfml.hxx | 20 ++++-----
sw/source/core/attr/cellatr.cxx | 8 +--
sw/source/core/fields/cellfml.cxx | 78 +++++++++++++++++++-------------------
sw/source/core/fields/tblcalc.cxx | 6 +-
4 files changed, 56 insertions(+), 56 deletions(-)
New commits:
commit 16a645870327453391b73c94470f92e876a2adb5
Author: Miklos Vajna <vmiklos at collabora.co.uk>
Date: Mon May 22 09:04:27 2017 +0200
sw: prefix members of SwTableCalcPara
Change-Id: I975ffa6834d1f39fa9e005aec247d350139e2208
Reviewed-on: https://gerrit.libreoffice.org/37897
Reviewed-by: Miklos Vajna <vmiklos at collabora.co.uk>
Tested-by: Jenkins <ci at libreoffice.org>
diff --git a/sw/inc/cellfml.hxx b/sw/inc/cellfml.hxx
index 6492095e7c06..132dc65a3600 100644
--- a/sw/inc/cellfml.hxx
+++ b/sw/inc/cellfml.hxx
@@ -34,22 +34,22 @@ class SwDoc;
class SwTableCalcPara
{
- const SwTableBox* pLastTableBox;
- sal_uInt16 nStackCnt, nMaxSize;
+ const SwTableBox* m_pLastTableBox;
+ sal_uInt16 m_nStackCount, m_nMaxSize;
public:
- std::unique_ptr<SwTableSortBoxes> pBoxStack; ///< stack for recognizing recursion
- SwCalc& rCalc; ///< current Calculator
- const SwTable* pTable; ///< current table
+ std::unique_ptr<SwTableSortBoxes> m_pBoxStack; ///< stack for recognizing recursion
+ SwCalc& m_rCalc; ///< current Calculator
+ const SwTable* m_pTable; ///< current table
SwTableCalcPara( SwCalc& rCalculator, const SwTable& rTable );
~SwTableCalcPara();
bool CalcWithStackOverflow();
- bool IsStackOverflow() const { return nMaxSize == nStackCnt; }
- bool IncStackCnt() { return nMaxSize == ++nStackCnt; }
- void DecStackCnt() { if( nStackCnt ) --nStackCnt; }
- void SetLastTableBox( const SwTableBox* pBox ) { pLastTableBox = pBox; }
+ bool IsStackOverflow() const { return m_nMaxSize == m_nStackCount; }
+ bool IncStackCnt() { return m_nMaxSize == ++m_nStackCount; }
+ void DecStackCnt() { if( m_nStackCount ) --m_nStackCount; }
+ void SetLastTableBox( const SwTableBox* pBox ) { m_pLastTableBox = pBox; }
};
class SwTableFormula
@@ -101,7 +101,7 @@ protected:
OUString MakeFormula( SwTableCalcPara& rCalcPara ) const
{
return ScanString( &SwTableFormula::MakeFormula_,
- *rCalcPara.pTable, &rCalcPara );
+ *rCalcPara.m_pTable, &rCalcPara );
}
static sal_uInt16 GetLnPosInTable( const SwTable& rTable, const SwTableBox* pBox );
diff --git a/sw/source/core/attr/cellatr.cxx b/sw/source/core/attr/cellatr.cxx
index a157927a6089..e8ec2c59a049 100644
--- a/sw/source/core/attr/cellatr.cxx
+++ b/sw/source/core/attr/cellatr.cxx
@@ -179,13 +179,13 @@ void SwTableBoxFormula::ChangeState( const SfxPoolItem* pItem )
void SwTableBoxFormula::Calc( SwTableCalcPara& rCalcPara, double& rValue )
{
- if( !rCalcPara.rCalc.IsCalcError() )
+ if( !rCalcPara.m_rCalc.IsCalcError() )
{
// create pointers from box names
- BoxNmToPtr( rCalcPara.pTable );
+ BoxNmToPtr( rCalcPara.m_pTable );
const OUString sFormula( MakeFormula( rCalcPara ));
- if( !rCalcPara.rCalc.IsCalcError() )
- rValue = rCalcPara.rCalc.Calculate( sFormula ).GetDouble();
+ if( !rCalcPara.m_rCalc.IsCalcError() )
+ rValue = rCalcPara.m_rCalc.Calculate( sFormula ).GetDouble();
else
rValue = DBL_MAX;
ChgValid( !rCalcPara.IsStackOverflow() ); // value is now valid again
diff --git a/sw/source/core/fields/cellfml.cxx b/sw/source/core/fields/cellfml.cxx
index 3b4906e5a390..c0655b2de3f7 100644
--- a/sw/source/core/fields/cellfml.cxx
+++ b/sw/source/core/fields/cellfml.cxx
@@ -75,10 +75,10 @@ double SwTableBox::GetValue( SwTableCalcPara& rCalcPara ) const
{
double nRet = 0;
- if( rCalcPara.rCalc.IsCalcError() )
+ if( rCalcPara.m_rCalc.IsCalcError() )
return nRet; // stop if there is already an error set
- rCalcPara.rCalc.SetCalcError( SwCalcError::Syntax ); // default: error
+ rCalcPara.m_rCalc.SetCalcError( SwCalcError::Syntax ); // default: error
// no content box?
if( !m_pStartNode )
@@ -91,13 +91,13 @@ double SwTableBox::GetValue( SwTableCalcPara& rCalcPara ) const
// Does it create a recursion?
SwTableBox* pBox = const_cast<SwTableBox*>(this);
- if( rCalcPara.pBoxStack->find( pBox ) != rCalcPara.pBoxStack->end() )
+ if( rCalcPara.m_pBoxStack->find( pBox ) != rCalcPara.m_pBoxStack->end() )
return nRet; // already on the stack: error
// re-start with this box
rCalcPara.SetLastTableBox( this );
- rCalcPara.pBoxStack->insert( pBox ); // add
+ rCalcPara.m_pBoxStack->insert( pBox ); // add
do { // Middle-Check-Loop, so that we can jump from here. Used so that the box pointer
// will be removed from stack at the end.
SwDoc* pDoc = GetFrameFormat()->GetDoc();
@@ -106,12 +106,12 @@ double SwTableBox::GetValue( SwTableCalcPara& rCalcPara ) const
if( SfxItemState::SET == GetFrameFormat()->GetItemState(
RES_BOXATR_FORMULA, false, &pItem ) )
{
- rCalcPara.rCalc.SetCalcError( SwCalcError::NONE ); // reset status
+ rCalcPara.m_rCalc.SetCalcError( SwCalcError::NONE ); // reset status
if( !static_cast<const SwTableBoxFormula*>(pItem)->IsValid() )
{
// calculate
- const SwTable* pTmp = rCalcPara.pTable;
- rCalcPara.pTable = &pBox->GetSttNd()->FindTableNode()->GetTable();
+ const SwTable* pTmp = rCalcPara.m_pTable;
+ rCalcPara.m_pTable = &pBox->GetSttNd()->FindTableNode()->GetTable();
const_cast<SwTableBoxFormula*>(static_cast<const SwTableBoxFormula*>(pItem))->Calc( rCalcPara, nRet );
if( !rCalcPara.IsStackOverflow() )
@@ -124,7 +124,7 @@ double SwTableBox::GetValue( SwTableCalcPara& rCalcPara ) const
aTmp.Put( SwTableBoxNumFormat( 0 ));
pFormat->SetFormatAttr( aTmp );
}
- rCalcPara.pTable = pTmp;
+ rCalcPara.m_pTable = pTmp;
}
else
nRet = GetFrameFormat()->GetTableBoxValue().GetValue();
@@ -133,7 +133,7 @@ double SwTableBox::GetValue( SwTableCalcPara& rCalcPara ) const
else if( SfxItemState::SET == pBox->GetFrameFormat()->GetItemState(
RES_BOXATR_VALUE, false, &pItem ) )
{
- rCalcPara.rCalc.SetCalcError( SwCalcError::NONE ); // reset status
+ rCalcPara.m_rCalc.SetCalcError( SwCalcError::NONE ); // reset status
nRet = static_cast<const SwTableBoxValue*>(pItem)->GetValue();
break;
}
@@ -157,7 +157,7 @@ double SwTableBox::GetValue( SwTableCalcPara& rCalcPara ) const
}
if ( pTextField != nullptr )
{
- rCalcPara.rCalc.SetCalcError( SwCalcError::NONE ); // reset status
+ rCalcPara.m_rCalc.SetCalcError( SwCalcError::NONE ); // reset status
const SwField* pField = pTextField->GetFormatField().GetField();
switch ( pField->GetTyp()->Which() )
@@ -174,10 +174,10 @@ double SwTableBox::GetValue( SwTableCalcPara& rCalcPara ) const
if( !pTableField->IsValid() )
{
// use the right table!
- const SwTable* pTmp = rCalcPara.pTable;
- rCalcPara.pTable = &pTextNd->FindTableNode()->GetTable();
+ const SwTable* pTmp = rCalcPara.m_pTable;
+ rCalcPara.m_pTable = &pTextNd->FindTableNode()->GetTable();
pTableField->CalcField( rCalcPara );
- rCalcPara.pTable = pTmp;
+ rCalcPara.m_pTable = pTmp;
}
nRet = pTableField->GetValue();
}
@@ -193,7 +193,7 @@ double SwTableBox::GetValue( SwTableCalcPara& rCalcPara ) const
break;
default:
- nRet = rCalcPara.rCalc.Calculate( pField->ExpandField(true) ).GetDouble();
+ nRet = rCalcPara.m_rCalc.Calculate( pField->ExpandField(true) ).GetDouble();
}
}
else if ( nSttPos < sText.getLength()
@@ -204,12 +204,12 @@ double SwTableBox::GetValue( SwTableCalcPara& rCalcPara ) const
pTextNd->GetTextAttrAt( nSttPos, RES_TXTATR_INPUTFIELD ) );
if ( pTextInputField == nullptr )
break;
- nRet = rCalcPara.rCalc.Calculate( pTextInputField->GetFieldContent() ).GetDouble();
+ nRet = rCalcPara.m_rCalc.Calculate( pTextInputField->GetFieldContent() ).GetDouble();
}
else if ( Char != CH_TXTATR_BREAKWORD )
{
// result is 0 but no error!
- rCalcPara.rCalc.SetCalcError( SwCalcError::NONE ); // reset status
+ rCalcPara.m_rCalc.SetCalcError( SwCalcError::NONE ); // reset status
double aNum = 0.0;
sText = bOK ? sText.copy( nSttPos ) : OUString();
@@ -237,13 +237,13 @@ double SwTableBox::GetValue( SwTableCalcPara& rCalcPara ) const
if( !rCalcPara.IsStackOverflow() )
{
- rCalcPara.pBoxStack->erase( pBox ); // remove from stack
+ rCalcPara.m_pBoxStack->erase( pBox ); // remove from stack
rCalcPara.DecStackCnt();
}
//JP 12.01.99: error detection, Bug 60794
if( DBL_MAX == nRet )
- rCalcPara.rCalc.SetCalcError( SwCalcError::Syntax ); // set error
+ rCalcPara.m_rCalc.SetCalcError( SwCalcError::Syntax ); // set error
return nRet;
}
@@ -251,9 +251,9 @@ double SwTableBox::GetValue( SwTableCalcPara& rCalcPara ) const
// structure needed for calculation of tables
SwTableCalcPara::SwTableCalcPara( SwCalc& rCalculator, const SwTable& rTable )
- : pLastTableBox( nullptr ), nStackCnt( 0 ), nMaxSize( cMAXSTACKSIZE ),
- pBoxStack( new SwTableSortBoxes ),
- rCalc( rCalculator ), pTable( &rTable )
+ : m_pLastTableBox( nullptr ), m_nStackCount( 0 ), m_nMaxSize( cMAXSTACKSIZE ),
+ m_pBoxStack( new SwTableSortBoxes ),
+ m_rCalc( rCalculator ), m_pTable( &rTable )
{
}
@@ -264,38 +264,38 @@ SwTableCalcPara::~SwTableCalcPara()
bool SwTableCalcPara::CalcWithStackOverflow()
{
// If a stack overflow was detected, redo with last box.
- sal_uInt16 nSaveMaxSize = nMaxSize;
+ sal_uInt16 nSaveMaxSize = m_nMaxSize;
- nMaxSize = cMAXSTACKSIZE - 5;
+ m_nMaxSize = cMAXSTACKSIZE - 5;
sal_uInt16 nCnt = 0;
SwTableBoxes aStackOverflows;
do {
- SwTableBox* pBox = const_cast<SwTableBox*>(pLastTableBox);
- nStackCnt = 0;
- rCalc.SetCalcError( SwCalcError::NONE );
+ SwTableBox* pBox = const_cast<SwTableBox*>(m_pLastTableBox);
+ m_nStackCount = 0;
+ m_rCalc.SetCalcError( SwCalcError::NONE );
aStackOverflows.insert( aStackOverflows.begin() + nCnt++, pBox );
- pBoxStack->erase( pBox );
+ m_pBoxStack->erase( pBox );
pBox->GetValue( *this );
} while( IsStackOverflow() );
- nMaxSize = cMAXSTACKSIZE - 3; // decrease at least one level
+ m_nMaxSize = cMAXSTACKSIZE - 3; // decrease at least one level
// if recursion was detected
- nStackCnt = 0;
- rCalc.SetCalcError( SwCalcError::NONE );
- pBoxStack->clear();
+ m_nStackCount = 0;
+ m_rCalc.SetCalcError( SwCalcError::NONE );
+ m_pBoxStack->clear();
- while( !rCalc.IsCalcError() && nCnt )
+ while( !m_rCalc.IsCalcError() && nCnt )
{
aStackOverflows[ --nCnt ]->GetValue( *this );
if( IsStackOverflow() && !CalcWithStackOverflow() )
break;
}
- nMaxSize = nSaveMaxSize;
+ m_nMaxSize = nSaveMaxSize;
aStackOverflows.clear();
- return !rCalc.IsCalcError();
+ return !m_rCalc.IsCalcError();
}
SwTableFormula::SwTableFormula( const OUString& rFormula )
@@ -313,7 +313,7 @@ void SwTableFormula::MakeFormula_( const SwTable& rTable, OUString& rNewStr,
OUString& rFirstBox, OUString* pLastBox, void* pPara ) const
{
SwTableCalcPara* pCalcPara = static_cast<SwTableCalcPara*>(pPara);
- if( pCalcPara->rCalc.IsCalcError() ) // stop if there is already an error set
+ if( pCalcPara->m_rCalc.IsCalcError() ) // stop if there is already an error set
return;
SwTableBox *pEndBox = nullptr;
@@ -345,7 +345,7 @@ void SwTableFormula::MakeFormula_( const SwTable& rTable, OUString& rNewStr,
rNewStr += "(";
bool bDelim = false;
for (size_t n = 0; n < aBoxes.size() &&
- !pCalcPara->rCalc.IsCalcError(); ++n)
+ !pCalcPara->m_rCalc.IsCalcError(); ++n)
{
const SwTableBox* pTableBox = aBoxes[n];
if ( pTableBox->getRowSpan() >= 1 )
@@ -353,7 +353,7 @@ void SwTableFormula::MakeFormula_( const SwTable& rTable, OUString& rNewStr,
if( bDelim )
rNewStr += OUStringLiteral1(cListDelim);
bDelim = true;
- rNewStr += pCalcPara->rCalc.GetStrResult(
+ rNewStr += pCalcPara->m_rCalc.GetStrResult(
pTableBox->GetValue( *pCalcPara ) );
}
}
@@ -366,13 +366,13 @@ void SwTableFormula::MakeFormula_( const SwTable& rTable, OUString& rNewStr,
if ( pSttBox->getRowSpan() >= 1 )
{
rNewStr += "(";
- rNewStr += pCalcPara->rCalc.GetStrResult(
+ rNewStr += pCalcPara->m_rCalc.GetStrResult(
pSttBox->GetValue( *pCalcPara ) );
rNewStr += ")";
}
}
else
- pCalcPara->rCalc.SetCalcError( SwCalcError::Syntax ); // set error
+ pCalcPara->m_rCalc.SetCalcError( SwCalcError::Syntax ); // set error
rNewStr += " ";
}
diff --git a/sw/source/core/fields/tblcalc.cxx b/sw/source/core/fields/tblcalc.cxx
index 9fe3b6e449b1..3448535eee06 100644
--- a/sw/source/core/fields/tblcalc.cxx
+++ b/sw/source/core/fields/tblcalc.cxx
@@ -45,13 +45,13 @@ SwFieldType* SwTableFieldType::Copy() const
void SwTableField::CalcField( SwTableCalcPara& rCalcPara )
{
- if( rCalcPara.rCalc.IsCalcError() ) // stop if there is already an error set
+ if( rCalcPara.m_rCalc.IsCalcError() ) // stop if there is already an error set
return;
// create pointers from box name
- BoxNmToPtr( rCalcPara.pTable );
+ BoxNmToPtr( rCalcPara.m_pTable );
OUString sFormula( MakeFormula( rCalcPara ));
- SetValue( rCalcPara.rCalc.Calculate( sFormula ).GetDouble() );
+ SetValue( rCalcPara.m_rCalc.Calculate( sFormula ).GetDouble() );
ChgValid( !rCalcPara.IsStackOverflow() ); // is the value again valid?
}
More information about the Libreoffice-commits
mailing list