summaryrefslogtreecommitdiff
path: root/sc
diff options
context:
space:
mode:
Diffstat (limited to 'sc')
-rw-r--r--sc/inc/document.hxx8
-rw-r--r--sc/inc/global.hxx23
-rw-r--r--sc/inc/table.hxx14
-rw-r--r--sc/qa/unit/helper/qahelper.cxx2
-rw-r--r--sc/source/core/data/column2.cxx2
-rw-r--r--sc/source/core/data/compressedarray.cxx7
-rw-r--r--sc/source/core/data/document.cxx28
-rw-r--r--sc/source/core/data/table1.cxx16
-rw-r--r--sc/source/core/data/table2.cxx37
-rw-r--r--sc/source/core/data/table5.cxx16
-rw-r--r--sc/source/filter/excel/colrowst.cxx4
-rw-r--r--sc/source/filter/excel/xetable.cxx4
-rw-r--r--sc/source/filter/lotus/lotimpop.cxx2
-rw-r--r--sc/source/ui/docshell/docfunc.cxx8
-rw-r--r--sc/source/ui/undo/undoblk3.cxx6
-rw-r--r--sc/source/ui/unoobj/cellsuno.cxx4
-rw-r--r--sc/source/ui/unoobj/docuno.cxx4
-rw-r--r--sc/source/ui/view/output2.cxx10
-rw-r--r--sc/source/ui/view/viewdata.cxx2
-rw-r--r--sc/source/ui/view/viewfunc.cxx8
20 files changed, 105 insertions, 100 deletions
diff --git a/sc/inc/document.hxx b/sc/inc/document.hxx
index 079d120855b3..79e5b8392883 100644
--- a/sc/inc/document.hxx
+++ b/sc/inc/document.hxx
@@ -1719,11 +1719,11 @@ public:
SC_DLLPUBLIC void ShowCol(SCCOL nCol, SCTAB nTab, bool bShow);
SC_DLLPUBLIC void ShowRow(SCROW nRow, SCTAB nTab, bool bShow);
SC_DLLPUBLIC void ShowRows(SCROW nRow1, SCROW nRow2, SCTAB nTab, bool bShow);
- SC_DLLPUBLIC void SetRowFlags( SCROW nRow, SCTAB nTab, sal_uInt8 nNewFlags );
- SC_DLLPUBLIC void SetRowFlags( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_uInt8 nNewFlags );
+ SC_DLLPUBLIC void SetRowFlags( SCROW nRow, SCTAB nTab, CRFlags nNewFlags );
+ SC_DLLPUBLIC void SetRowFlags( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, CRFlags nNewFlags );
- SC_DLLPUBLIC sal_uInt8 GetColFlags( SCCOL nCol, SCTAB nTab ) const;
- SC_DLLPUBLIC sal_uInt8 GetRowFlags( SCROW nRow, SCTAB nTab ) const;
+ SC_DLLPUBLIC CRFlags GetColFlags( SCCOL nCol, SCTAB nTab ) const;
+ SC_DLLPUBLIC CRFlags GetRowFlags( SCROW nRow, SCTAB nTab ) const;
SC_DLLPUBLIC void GetAllRowBreaks(std::set<SCROW>& rBreaks, SCTAB nTab, bool bPage, bool bManual) const;
SC_DLLPUBLIC void GetAllColBreaks(std::set<SCCOL>& rBreaks, SCTAB nTab, bool bPage, bool bManual) const;
diff --git a/sc/inc/global.hxx b/sc/inc/global.hxx
index 3a2d99bd09cd..df030e7fe479 100644
--- a/sc/inc/global.hxx
+++ b/sc/inc/global.hxx
@@ -119,21 +119,26 @@ namespace sc
#define PAINT_ALL ( PAINT_GRID | PAINT_TOP | PAINT_LEFT | PAINT_EXTRAS | PAINT_OBJECTS | PAINT_SIZE )
// flags for columns / rows
- // FILTERED always together with HIDDEN
- // FILTERED and MANUALSIZE only valid for rows
-const sal_uInt8 CR_HIDDEN = 1;
-const sal_uInt8 CR_MANUALBREAK = 8;
-const sal_uInt8 CR_FILTERED = 16;
-const sal_uInt8 CR_MANUALSIZE = 32;
-const sal_uInt8 CR_ALL = (CR_HIDDEN | CR_MANUALBREAK | CR_FILTERED | CR_MANUALSIZE);
+enum class CRFlags : sal_uInt8 {
+ // Filtered always together with Hidden
+ // Filtered and ManualSize only valid for rows
+ NONE = 0x00,
+ Hidden = 0x01,
+ ManualBreak = 0x02,
+ Filtered = 0x04,
+ ManualSize = 0x08,
+ All = Hidden | ManualBreak | Filtered | ManualSize
+};
+namespace o3tl {
+ template<> struct typed_flags<CRFlags> : is_typed_flags<CRFlags, 0x0f> {};
+}
enum class ScBreakType {
NONE = 0x00,
Page = 0x01,
Manual = 0x02
};
-namespace o3tl
-{
+namespace o3tl {
template<> struct typed_flags<ScBreakType> : is_typed_flags<ScBreakType, 0x03> {};
}
diff --git a/sc/inc/table.hxx b/sc/inc/table.hxx
index 88ef6bed967b..419d8bde3f23 100644
--- a/sc/inc/table.hxx
+++ b/sc/inc/table.hxx
@@ -146,8 +146,8 @@ private:
sal_uInt16* pColWidth;
std::unique_ptr<ScFlatUInt16RowSegments> mpRowHeights;
- sal_uInt8* pColFlags;
- ScBitMaskCompressedArray< SCROW, sal_uInt8>* pRowFlags;
+ CRFlags* pColFlags;
+ ScBitMaskCompressedArray< SCROW, CRFlags>* pRowFlags;
std::unique_ptr<ScFlatBoolColSegments> mpHiddenCols;
std::unique_ptr<ScFlatBoolRowSegments> mpHiddenRows;
std::unique_ptr<ScFlatBoolColSegments> mpFilteredCols;
@@ -748,8 +748,8 @@ public:
void ShowRows(SCROW nRow1, SCROW nRow2, bool bShow);
void DBShowRows(SCROW nRow1, SCROW nRow2, bool bShow);
- void SetRowFlags( SCROW nRow, sal_uInt8 nNewFlags );
- void SetRowFlags( SCROW nStartRow, SCROW nEndRow, sal_uInt8 nNewFlags );
+ void SetRowFlags( SCROW nRow, CRFlags nNewFlags );
+ void SetRowFlags( SCROW nStartRow, SCROW nEndRow, CRFlags nNewFlags );
/// @return the index of the last row with any set flags (auto-pagebreak is ignored).
SCROW GetLastFlaggedRow() const;
@@ -761,10 +761,10 @@ public:
bool IsDataFiltered(SCCOL nColStart, SCROW nRowStart, SCCOL nColEnd, SCROW nRowEnd) const;
bool IsDataFiltered(const ScRange& rRange) const;
- sal_uInt8 GetColFlags( SCCOL nCol ) const;
- sal_uInt8 GetRowFlags( SCROW nRow ) const;
+ CRFlags GetColFlags( SCCOL nCol ) const;
+ CRFlags GetRowFlags( SCROW nRow ) const;
- const ScBitMaskCompressedArray< SCROW, sal_uInt8> * GetRowFlagsArray() const
+ const ScBitMaskCompressedArray< SCROW, CRFlags> * GetRowFlagsArray() const
{ return pRowFlags; }
bool UpdateOutlineCol( SCCOL nStartCol, SCCOL nEndCol, bool bShow );
diff --git a/sc/qa/unit/helper/qahelper.cxx b/sc/qa/unit/helper/qahelper.cxx
index 7153c4b69c49..e46de2ba16b6 100644
--- a/sc/qa/unit/helper/qahelper.cxx
+++ b/sc/qa/unit/helper/qahelper.cxx
@@ -728,7 +728,7 @@ void ScBootstrapFixture::miscRowHeightsTest( TestParam* aTestValues, unsigned in
int nHeight = sc::TwipsToHMM( rDoc.GetRowHeight(nRow, nTab, false) );
if ( bCheckOpt )
{
- bool bOpt = !(rDoc.GetRowFlags( nRow, nTab ) & CR_MANUALSIZE);
+ bool bOpt = !(rDoc.GetRowFlags( nRow, nTab ) & CRFlags::ManualSize);
CPPUNIT_ASSERT_EQUAL(aTestValues[ index ].pData[ i ].bOptimal, bOpt);
}
CPPUNIT_ASSERT_EQUAL(nExpectedHeight, nHeight);
diff --git a/sc/source/core/data/column2.cxx b/sc/source/core/data/column2.cxx
index b99c6c6507aa..d4fa874220fd 100644
--- a/sc/source/core/data/column2.cxx
+++ b/sc/source/core/data/column2.cxx
@@ -942,7 +942,7 @@ void ScColumn::GetOptimalHeight(
{
// only calculate the cell height when it's used later (#37928#)
- if (rCxt.isForceAutoSize() || !(pDocument->GetRowFlags(nRow, nTab) & CR_MANUALSIZE) )
+ if (rCxt.isForceAutoSize() || !(pDocument->GetRowFlags(nRow, nTab) & CRFlags::ManualSize) )
{
aOptions.pPattern = pPattern;
const ScPatternAttr* pOldPattern = pPattern;
diff --git a/sc/source/core/data/compressedarray.cxx b/sc/source/core/data/compressedarray.cxx
index 9f1e647658d5..5cbcb6073bd7 100644
--- a/sc/source/core/data/compressedarray.cxx
+++ b/sc/source/core/data/compressedarray.cxx
@@ -19,6 +19,7 @@
#include "compressedarray.hxx"
#include "address.hxx"
+#include "global.hxx"
#include <algorithm>
@@ -392,7 +393,7 @@ A ScBitMaskCompressedArray<A,D>::GetLastAnyBitAccess( const D& rBitMask ) const
size_t nIndex = this->nCount-1;
while (true)
{
- if ((this->pData[nIndex].aValue & rBitMask) != 0)
+ if (this->pData[nIndex].aValue & rBitMask)
{
nEnd = this->pData[nIndex].nEnd;
break; // while
@@ -414,7 +415,7 @@ A ScBitMaskCompressedArray<A,D>::GetLastAnyBitAccess( const D& rBitMask ) const
// === Force instantiation of specializations ================================
-template class ScCompressedArray< SCROW, sal_uInt8>; // flags, base class
-template class ScBitMaskCompressedArray< SCROW, sal_uInt8>; // flags
+template class ScCompressedArray< SCROW, CRFlags>; // flags, base class
+template class ScBitMaskCompressedArray< SCROW, CRFlags>; // flags
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/core/data/document.cxx b/sc/source/core/data/document.cxx
index b8b0c15a8545..96269cb622ae 100644
--- a/sc/source/core/data/document.cxx
+++ b/sc/source/core/data/document.cxx
@@ -4253,32 +4253,32 @@ void ScDocument::ShowRows(SCROW nRow1, SCROW nRow2, SCTAB nTab, bool bShow)
maTabs[nTab]->ShowRows( nRow1, nRow2, bShow );
}
-void ScDocument::SetRowFlags( SCROW nRow, SCTAB nTab, sal_uInt8 nNewFlags )
+void ScDocument::SetRowFlags( SCROW nRow, SCTAB nTab, CRFlags nNewFlags )
{
if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
maTabs[nTab]->SetRowFlags( nRow, nNewFlags );
}
-void ScDocument::SetRowFlags( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_uInt8 nNewFlags )
+void ScDocument::SetRowFlags( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, CRFlags nNewFlags )
{
if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
maTabs[nTab]->SetRowFlags( nStartRow, nEndRow, nNewFlags );
}
-sal_uInt8 ScDocument::GetColFlags( SCCOL nCol, SCTAB nTab ) const
+CRFlags ScDocument::GetColFlags( SCCOL nCol, SCTAB nTab ) const
{
if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
return maTabs[nTab]->GetColFlags( nCol );
OSL_FAIL("wrong table number");
- return 0;
+ return CRFlags::NONE;
}
-sal_uInt8 ScDocument::GetRowFlags( SCROW nRow, SCTAB nTab ) const
+CRFlags ScDocument::GetRowFlags( SCROW nRow, SCTAB nTab ) const
{
if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
return maTabs[nTab]->GetRowFlags( nRow );
OSL_FAIL("wrong table number");
- return 0;
+ return CRFlags::NONE;
}
void ScDocument::GetAllRowBreaks(set<SCROW>& rBreaks, SCTAB nTab, bool bPage, bool bManual) const
@@ -4535,13 +4535,13 @@ SCCOL ScDocument::GetNextDifferentChangedCol( SCTAB nTab, SCCOL nStart) const
{
if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
{
- sal_uInt8 nStartFlags = maTabs[nTab]->GetColFlags(nStart);
+ CRFlags nStartFlags = maTabs[nTab]->GetColFlags(nStart);
sal_uInt16 nStartWidth = maTabs[nTab]->GetOriginalWidth(nStart);
for (SCCOL nCol = nStart + 1; nCol <= MAXCOL; nCol++)
{
- if (((nStartFlags & CR_MANUALBREAK) != (maTabs[nTab]->GetColFlags(nCol) & CR_MANUALBREAK)) ||
+ if (((nStartFlags & CRFlags::ManualBreak) != (maTabs[nTab]->GetColFlags(nCol) & CRFlags::ManualBreak)) ||
(nStartWidth != maTabs[nTab]->GetOriginalWidth(nCol)) ||
- ((nStartFlags & CR_HIDDEN) != (maTabs[nTab]->GetColFlags(nCol) & CR_HIDDEN)) )
+ ((nStartFlags & CRFlags::Hidden) != (maTabs[nTab]->GetColFlags(nCol) & CRFlags::Hidden)) )
return nCol;
}
return MAXCOL+1;
@@ -4554,7 +4554,7 @@ SCROW ScDocument::GetNextDifferentChangedRow( SCTAB nTab, SCROW nStart) const
if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
return 0;
- const ScBitMaskCompressedArray<SCROW, sal_uInt8>* pRowFlagsArray = maTabs[nTab]->GetRowFlagsArray();
+ const ScBitMaskCompressedArray<SCROW, CRFlags>* pRowFlagsArray = maTabs[nTab]->GetRowFlagsArray();
if (!pRowFlagsArray)
return 0;
@@ -4565,10 +4565,10 @@ SCROW ScDocument::GetNextDifferentChangedRow( SCTAB nTab, SCROW nStart) const
SCROW nFlagsEndRow;
SCROW nHiddenEndRow;
SCROW nHeightEndRow;
- sal_uInt8 nFlags;
+ CRFlags nFlags;
bool bHidden;
sal_uInt16 nHeight;
- sal_uInt8 nStartFlags = nFlags = pRowFlagsArray->GetValue( nStart, nIndex, nFlagsEndRow);
+ CRFlags nStartFlags = nFlags = pRowFlagsArray->GetValue( nStart, nIndex, nFlagsEndRow);
bool bStartHidden = bHidden = maTabs[nTab]->RowHidden( nStart, nullptr, &nHiddenEndRow);
sal_uInt16 nStartHeight = nHeight = maTabs[nTab]->GetRowHeight( nStart, nullptr, &nHeightEndRow, false);
SCROW nRow;
@@ -4581,8 +4581,8 @@ SCROW ScDocument::GetNextDifferentChangedRow( SCTAB nTab, SCROW nStart) const
if (nHeightEndRow < nRow)
nHeight = maTabs[nTab]->GetRowHeight( nRow, nullptr, &nHeightEndRow, false);
- if (((nStartFlags & CR_MANUALBREAK) != (nFlags & CR_MANUALBREAK)) ||
- ((nStartFlags & CR_MANUALSIZE) != (nFlags & CR_MANUALSIZE)) ||
+ if (((nStartFlags & CRFlags::ManualBreak) != (nFlags & CRFlags::ManualBreak)) ||
+ ((nStartFlags & CRFlags::ManualSize) != (nFlags & CRFlags::ManualSize)) ||
(bStartHidden != bHidden) ||
(nStartHeight != nHeight))
return nRow;
diff --git a/sc/source/core/data/table1.cxx b/sc/source/core/data/table1.cxx
index b17f7aa40465..a38889d3a02f 100644
--- a/sc/source/core/data/table1.cxx
+++ b/sc/source/core/data/table1.cxx
@@ -167,7 +167,7 @@ struct SetRowHeightRangeFunc : public OptimalHeightsFuncObjBase
bool SetOptimalHeightsToRows(
sc::RowHeightContext& rCxt,
OptimalHeightsFuncObjBase& rFuncObj,
- ScBitMaskCompressedArray<SCROW, sal_uInt8>* pRowFlags, SCROW nStartRow, SCROW nEndRow )
+ ScBitMaskCompressedArray<SCROW, CRFlags>* pRowFlags, SCROW nStartRow, SCROW nEndRow )
{
bool bChanged = false;
SCROW nRngStart = 0;
@@ -178,21 +178,21 @@ bool SetOptimalHeightsToRows(
{
size_t nIndex;
SCROW nRegionEndRow;
- sal_uInt8 nRowFlag = pRowFlags->GetValue( i, nIndex, nRegionEndRow );
+ CRFlags nRowFlag = pRowFlags->GetValue( i, nIndex, nRegionEndRow );
if ( nRegionEndRow > nEndRow )
nRegionEndRow = nEndRow;
SCSIZE nMoreRows = nRegionEndRow - i; // additional equal rows after first
- bool bAutoSize = ((nRowFlag & CR_MANUALSIZE) == 0);
+ bool bAutoSize = !(nRowFlag & CRFlags::ManualSize);
if (bAutoSize || rCxt.isForceAutoSize())
{
if (nExtraHeight)
{
if (bAutoSize)
- pRowFlags->SetValue( i, nRegionEndRow, nRowFlag | CR_MANUALSIZE);
+ pRowFlags->SetValue( i, nRegionEndRow, nRowFlag | CRFlags::ManualSize);
}
else if (!bAutoSize)
- pRowFlags->SetValue( i, nRegionEndRow, nRowFlag & ~CR_MANUALSIZE);
+ pRowFlags->SetValue( i, nRegionEndRow, nRowFlag & ~CRFlags::ManualSize);
for (SCSIZE nInner = i; nInner <= i + nMoreRows; ++nInner)
{
@@ -293,19 +293,19 @@ ScTable::ScTable( ScDocument* pDoc, SCTAB nNewTab, const OUString& rNewName,
if (bColInfo)
{
pColWidth = new sal_uInt16[ MAXCOL+1 ];
- pColFlags = new sal_uInt8[ MAXCOL+1 ];
+ pColFlags = new CRFlags[ MAXCOL+1 ];
for (SCCOL i=0; i<=MAXCOL; i++)
{
pColWidth[i] = STD_COL_WIDTH;
- pColFlags[i] = 0;
+ pColFlags[i] = CRFlags::NONE;
}
}
if (bRowInfo)
{
mpRowHeights.reset(new ScFlatUInt16RowSegments(ScGlobal::nStdRowHeight));
- pRowFlags = new ScBitMaskCompressedArray< SCROW, sal_uInt8>( MAXROW, 0);
+ pRowFlags = new ScBitMaskCompressedArray<SCROW, CRFlags>( MAXROW, CRFlags::NONE);
}
if ( pDocument->IsDocVisible() )
diff --git a/sc/source/core/data/table2.cxx b/sc/source/core/data/table2.cxx
index 78dd198cefab..33227ca76780 100644
--- a/sc/source/core/data/table2.cxx
+++ b/sc/source/core/data/table2.cxx
@@ -159,11 +159,11 @@ void ScTable::InsertRow( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE
if (mpRowHeights && pRowFlags)
{
mpRowHeights->insertSegment(nStartRow, nSize);
- sal_uInt8 nNewFlags = pRowFlags->Insert( nStartRow, nSize);
+ CRFlags nNewFlags = pRowFlags->Insert( nStartRow, nSize);
// only copy manual size flag, clear all others
- if (nNewFlags && (nNewFlags != CR_MANUALSIZE))
+ if (nNewFlags != CRFlags::NONE && (nNewFlags != CRFlags::ManualSize))
pRowFlags->SetValue( nStartRow, nStartRow + nSize - 1,
- nNewFlags & CR_MANUALSIZE);
+ nNewFlags & CRFlags::ManualSize);
}
if (pOutlineTable)
@@ -522,7 +522,7 @@ void ScTable::CopyToClip(
if (pRowFlags && pTable->pRowFlags && mpRowHeights && pTable->mpRowHeights)
{
- pTable->pRowFlags->CopyFromAnded( *pRowFlags, 0, nRow2, CR_MANUALSIZE);
+ pTable->pRowFlags->CopyFromAnded( *pRowFlags, 0, nRow2, CRFlags::ManualSize);
pTable->CopyRowHeight(*this, 0, nRow2, 0);
}
@@ -679,13 +679,13 @@ void ScTable::CopyFromClip(
pRowFlags && pTable->pRowFlags)
{
CopyRowHeight(*pTable, nRow1, nRow2, -nDy);
- // Must copy CR_MANUALSIZE bit too, otherwise pRowHeight doesn't make sense
+ // Must copy CRFlags::ManualSize bit too, otherwise pRowHeight doesn't make sense
for (SCROW j=nRow1; j<=nRow2; j++)
{
- if ( pTable->pRowFlags->GetValue(j-nDy) & CR_MANUALSIZE )
- pRowFlags->OrValue( j, CR_MANUALSIZE);
+ if ( pTable->pRowFlags->GetValue(j-nDy) & CRFlags::ManualSize )
+ pRowFlags->OrValue( j, CRFlags::ManualSize);
else
- pRowFlags->AndValue( j, sal::static_int_cast<sal_uInt8>(~CR_MANUALSIZE));
+ pRowFlags->AndValue( j, ~CRFlags::ManualSize);
}
}
@@ -2842,9 +2842,9 @@ void ScTable::SetManualHeight( SCROW nStartRow, SCROW nEndRow, bool bManual )
if (ValidRow(nStartRow) && ValidRow(nEndRow) && pRowFlags)
{
if (bManual)
- pRowFlags->OrValue( nStartRow, nEndRow, CR_MANUALSIZE);
+ pRowFlags->OrValue( nStartRow, nEndRow, CRFlags::ManualSize);
else
- pRowFlags->AndValue( nStartRow, nEndRow, sal::static_int_cast<sal_uInt8>(~CR_MANUALSIZE));
+ pRowFlags->AndValue( nStartRow, nEndRow, ~CRFlags::ManualSize);
}
else
{
@@ -3241,7 +3241,7 @@ bool ScTable::IsDataFiltered(const ScRange& rRange) const
rRange.aEnd.Col(), rRange.aEnd.Row());
}
-void ScTable::SetRowFlags( SCROW nRow, sal_uInt8 nNewFlags )
+void ScTable::SetRowFlags( SCROW nRow, CRFlags nNewFlags )
{
if (ValidRow(nRow) && pRowFlags)
pRowFlags->SetValue( nRow, nNewFlags);
@@ -3251,7 +3251,7 @@ void ScTable::SetRowFlags( SCROW nRow, sal_uInt8 nNewFlags )
}
}
-void ScTable::SetRowFlags( SCROW nStartRow, SCROW nEndRow, sal_uInt8 nNewFlags )
+void ScTable::SetRowFlags( SCROW nStartRow, SCROW nEndRow, CRFlags nNewFlags )
{
if (ValidRow(nStartRow) && ValidRow(nEndRow) && pRowFlags)
pRowFlags->SetValue( nStartRow, nEndRow, nNewFlags);
@@ -3261,20 +3261,20 @@ void ScTable::SetRowFlags( SCROW nStartRow, SCROW nEndRow, sal_uInt8 nNewFlags )
}
}
-sal_uInt8 ScTable::GetColFlags( SCCOL nCol ) const
+CRFlags ScTable::GetColFlags( SCCOL nCol ) const
{
if (ValidCol(nCol) && pColFlags)
return pColFlags[nCol];
else
- return 0;
+ return CRFlags::NONE;
}
-sal_uInt8 ScTable::GetRowFlags( SCROW nRow ) const
+CRFlags ScTable::GetRowFlags( SCROW nRow ) const
{
if (ValidRow(nRow) && pRowFlags)
return pRowFlags->GetValue(nRow);
else
- return 0;
+ return CRFlags::NONE;
}
SCROW ScTable::GetLastFlaggedRow() const
@@ -3282,7 +3282,7 @@ SCROW ScTable::GetLastFlaggedRow() const
SCROW nLastFound = 0;
if (pRowFlags)
{
- SCROW nRow = pRowFlags->GetLastAnyBitAccess( sal::static_int_cast<sal_uInt8>(CR_ALL) );
+ SCROW nRow = pRowFlags->GetLastAnyBitAccess( CRFlags::All );
if (ValidRow(nRow))
nLastFound = nRow;
}
@@ -3314,7 +3314,7 @@ SCCOL ScTable::GetLastChangedCol() const
SCCOL nLastFound = 0;
for (SCCOL nCol = 1; nCol <= MAXCOL; nCol++)
- if ((pColFlags[nCol] & CR_ALL) || (pColWidth[nCol] != STD_COL_WIDTH))
+ if ((pColFlags[nCol] & CRFlags::All) || (pColWidth[nCol] != STD_COL_WIDTH))
nLastFound = nCol;
return nLastFound;
@@ -3341,7 +3341,6 @@ bool ScTable::UpdateOutlineCol( SCCOL nStartCol, SCCOL nEndCol, bool bShow )
{
if (pOutlineTable && pColFlags)
{
- ScBitMaskCompressedArray< SCCOLROW, sal_uInt8> aArray( MAXCOL, pColFlags, MAXCOLCOUNT);
return pOutlineTable->GetColArray().ManualAction( nStartCol, nEndCol, bShow, *this, true );
}
else
diff --git a/sc/source/core/data/table5.cxx b/sc/source/core/data/table5.cxx
index eb35dd087326..3ac1d04d4fcb 100644
--- a/sc/source/core/data/table5.cxx
+++ b/sc/source/core/data/table5.cxx
@@ -940,17 +940,17 @@ SCROW ScTable::CountNonFilteredRows(SCROW nStartRow, SCROW nEndRow) const
bool ScTable::IsManualRowHeight(SCROW nRow) const
{
- return (pRowFlags->GetValue(nRow) & CR_MANUALSIZE) != 0;
+ return bool(pRowFlags->GetValue(nRow) & CRFlags::ManualSize);
}
namespace {
void lcl_syncFlags(ScFlatBoolColSegments& rColSegments, ScFlatBoolRowSegments& rRowSegments,
- sal_uInt8* pColFlags, ScBitMaskCompressedArray< SCROW, sal_uInt8>* pRowFlags, const sal_uInt8 nFlagMask)
+ CRFlags* pColFlags, ScBitMaskCompressedArray< SCROW, CRFlags>* pRowFlags, const CRFlags nFlagMask)
{
using ::sal::static_int_cast;
- sal_uInt8 nFlagMaskComplement = static_int_cast<sal_uInt8>(~nFlagMask);
+ CRFlags nFlagMaskComplement = ~nFlagMask;
pRowFlags->AndValue(0, MAXROW, nFlagMaskComplement);
for (SCCOL i = 0; i <= MAXCOL; ++i)
@@ -1000,7 +1000,7 @@ void ScTable::SyncColRowFlags()
{
using ::sal::static_int_cast;
- sal_uInt8 nManualBreakComplement = static_int_cast<sal_uInt8>(~CR_MANUALBREAK);
+ CRFlags nManualBreakComplement = ~CRFlags::ManualBreak;
// Manual breaks.
pRowFlags->AndValue(0, MAXROW, nManualBreakComplement);
@@ -1011,19 +1011,19 @@ void ScTable::SyncColRowFlags()
{
for (set<SCROW>::const_iterator itr = maRowManualBreaks.begin(), itrEnd = maRowManualBreaks.end();
itr != itrEnd; ++itr)
- pRowFlags->OrValue(*itr, CR_MANUALBREAK);
+ pRowFlags->OrValue(*itr, CRFlags::ManualBreak);
}
if (!maColManualBreaks.empty())
{
for (set<SCCOL>::const_iterator itr = maColManualBreaks.begin(), itrEnd = maColManualBreaks.end();
itr != itrEnd; ++itr)
- pColFlags[*itr] |= CR_MANUALBREAK;
+ pColFlags[*itr] |= CRFlags::ManualBreak;
}
// Hidden flags.
- lcl_syncFlags(*mpHiddenCols, *mpHiddenRows, pColFlags, pRowFlags, CR_HIDDEN);
- lcl_syncFlags(*mpFilteredCols, *mpFilteredRows, pColFlags, pRowFlags, CR_FILTERED);
+ lcl_syncFlags(*mpHiddenCols, *mpHiddenRows, pColFlags, pRowFlags, CRFlags::Hidden);
+ lcl_syncFlags(*mpFilteredCols, *mpFilteredRows, pColFlags, pRowFlags, CRFlags::Filtered);
}
void ScTable::SetPageSize( const Size& rSize )
diff --git a/sc/source/filter/excel/colrowst.cxx b/sc/source/filter/excel/colrowst.cxx
index 59694f5f43aa..59dd1b019899 100644
--- a/sc/source/filter/excel/colrowst.cxx
+++ b/sc/source/filter/excel/colrowst.cxx
@@ -220,7 +220,7 @@ void XclImpColRowSettings::Convert( SCTAB nScTab )
rDoc.SetRowHeightOnly( 0, MAXROW, nScTab, mnDefHeight );
if( ::get_flag( mnDefRowFlags, EXC_DEFROW_UNSYNCED ) )
// first access to row flags, do not ask for old flags
- rDoc.SetRowFlags( 0, MAXROW, nScTab, CR_MANUALSIZE );
+ rDoc.SetRowFlags( 0, MAXROW, nScTab, CRFlags::ManualSize );
maRowHeights.build_tree();
if (!maRowHeights.is_tree_valid())
@@ -295,7 +295,7 @@ void XclImpColRowSettings::ConvertHiddenFlags( SCTAB nScTab )
if( GetBiff() == EXC_BIFF8 )
{
const XclImpAutoFilterData* pFilter = GetFilterManager().GetByTab( nScTab );
- // #i70026# use IsFiltered() to set the CR_FILTERED flag for active filters only
+ // #i70026# use IsFiltered() to set the CRFlags::Filtered flag for active filters only
if( pFilter && pFilter->IsActive() && pFilter->IsFiltered() )
{
nFirstFilterScRow = pFilter->StartRow();
diff --git a/sc/source/filter/excel/xetable.cxx b/sc/source/filter/excel/xetable.cxx
index c5ab7de726cb..f0c1096e90ee 100644
--- a/sc/source/filter/excel/xetable.cxx
+++ b/sc/source/filter/excel/xetable.cxx
@@ -1858,8 +1858,8 @@ XclExpRow::XclExpRow( const XclExpRoot& rRoot, sal_uInt32 nXclRow,
// *** Row flags *** ------------------------------------------------------
- sal_uInt8 nRowFlags = GetDoc().GetRowFlags( nScRow, nScTab );
- bool bUserHeight = ::get_flag< sal_uInt8 >( nRowFlags, CR_MANUALSIZE );
+ CRFlags nRowFlags = GetDoc().GetRowFlags( nScRow, nScTab );
+ bool bUserHeight( nRowFlags & CRFlags::ManualSize );
bool bHidden = GetDoc().RowHidden(nScRow, nScTab);
::set_flag( mnFlags, EXC_ROW_UNSYNCED, bUserHeight );
::set_flag( mnFlags, EXC_ROW_HIDDEN, bHidden );
diff --git a/sc/source/filter/lotus/lotimpop.cxx b/sc/source/filter/lotus/lotimpop.cxx
index a48cefe08baf..1d2786127e8d 100644
--- a/sc/source/filter/lotus/lotimpop.cxx
+++ b/sc/source/filter/lotus/lotimpop.cxx
@@ -317,7 +317,7 @@ void ImportLotus::RowPresentation( sal_uInt16 nRecLen )
nHeight *= 20; // -> 32 * TWIPS
nHeight /= 32; // -> TWIPS
- pD->SetRowFlags( static_cast<SCROW> (nRow), static_cast<SCTAB> (nLTab), pD->GetRowFlags( static_cast<SCROW> (nRow), static_cast<SCTAB> (nLTab) ) | CR_MANUALSIZE );
+ pD->SetRowFlags( static_cast<SCROW> (nRow), static_cast<SCTAB> (nLTab), pD->GetRowFlags( static_cast<SCROW> (nRow), static_cast<SCTAB> (nLTab) ) | CRFlags::ManualSize );
pD->SetRowHeight( static_cast<SCROW> (nRow), static_cast<SCTAB> (nLTab), nHeight );
}
diff --git a/sc/source/ui/docshell/docfunc.cxx b/sc/source/ui/docshell/docfunc.cxx
index 85714d49e82c..721084dbbd49 100644
--- a/sc/source/ui/docshell/docfunc.cxx
+++ b/sc/source/ui/docshell/docfunc.cxx
@@ -3474,15 +3474,15 @@ bool ScDocFunc::SetWidthOrHeight(
bool bAll = ( eMode==SC_SIZE_OPTIMAL );
if (!bAll)
{
- // fuer alle eingeblendeten CR_MANUALSIZE loeschen,
+ // fuer alle eingeblendeten CRFlags::ManualSize loeschen,
// dann SetOptimalHeight mit bShrink = FALSE
for (SCROW nRow=nStartNo; nRow<=nEndNo; nRow++)
{
- sal_uInt8 nOld = rDoc.GetRowFlags(nRow,nTab);
+ CRFlags nOld = rDoc.GetRowFlags(nRow,nTab);
SCROW nLastRow = -1;
bool bHidden = rDoc.RowHidden(nRow, nTab, nullptr, &nLastRow);
- if ( !bHidden && ( nOld & CR_MANUALSIZE ) )
- rDoc.SetRowFlags( nRow, nTab, nOld & ~CR_MANUALSIZE );
+ if ( !bHidden && ( nOld & CRFlags::ManualSize ) )
+ rDoc.SetRowFlags( nRow, nTab, nOld & ~CRFlags::ManualSize );
}
}
diff --git a/sc/source/ui/undo/undoblk3.cxx b/sc/source/ui/undo/undoblk3.cxx
index 9c0e21a39cd9..ed61de76be90 100644
--- a/sc/source/ui/undo/undoblk3.cxx
+++ b/sc/source/ui/undo/undoblk3.cxx
@@ -870,10 +870,10 @@ void ScUndoAutoFormat::Redo()
// as SC_SIZE_VISOPT
for (SCROW nRow=nStartY; nRow<=nEndY; nRow++)
{
- sal_uInt8 nOld = rDoc.GetRowFlags(nRow,nTab);
+ CRFlags nOld = rDoc.GetRowFlags(nRow,nTab);
bool bHidden = rDoc.RowHidden(nRow, nTab);
- if ( !bHidden && ( nOld & CR_MANUALSIZE ) )
- rDoc.SetRowFlags( nRow, nTab, nOld & ~CR_MANUALSIZE );
+ if ( !bHidden && ( nOld & CRFlags::ManualSize ) )
+ rDoc.SetRowFlags( nRow, nTab, nOld & ~CRFlags::ManualSize );
}
rDoc.SetOptimalHeight(aCxt, nStartY, nEndY, nTab);
diff --git a/sc/source/ui/unoobj/cellsuno.cxx b/sc/source/ui/unoobj/cellsuno.cxx
index c57892869e70..d090955a622b 100644
--- a/sc/source/ui/unoobj/cellsuno.cxx
+++ b/sc/source/ui/unoobj/cellsuno.cxx
@@ -8822,7 +8822,7 @@ void ScTableColumnObj::GetOnePropertyValue( const SfxItemPropertySimpleEntry* pE
else if ( pEntry->nWID == SC_WID_UNO_OWIDTH )
{
//! momentan immer gesetzt ??!?!
- bool bOpt = !(rDoc.GetColFlags( nCol, nTab ) & CR_MANUALSIZE);
+ bool bOpt = !(rDoc.GetColFlags( nCol, nTab ) & CRFlags::ManualSize);
rAny <<= bOpt;
}
else if ( pEntry->nWID == SC_WID_UNO_NEWPAGE )
@@ -8975,7 +8975,7 @@ void ScTableRowObj::GetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntr
}
else if ( pEntry->nWID == SC_WID_UNO_OHEIGHT )
{
- bool bOpt = !(rDoc.GetRowFlags( nRow, nTab ) & CR_MANUALSIZE);
+ bool bOpt = !(rDoc.GetRowFlags( nRow, nTab ) & CRFlags::ManualSize);
rAny <<= bOpt;
}
else if ( pEntry->nWID == SC_WID_UNO_NEWPAGE )
diff --git a/sc/source/ui/unoobj/docuno.cxx b/sc/source/ui/unoobj/docuno.cxx
index c12869380b31..5800a437721a 100644
--- a/sc/source/ui/unoobj/docuno.cxx
+++ b/sc/source/ui/unoobj/docuno.cxx
@@ -3743,7 +3743,7 @@ uno::Any SAL_CALL ScTableColumnsObj::getPropertyValue( const OUString& aProperty
}
else if ( aPropertyName == SC_UNONAME_OWIDTH )
{
- bool bOpt = !(rDoc.GetColFlags( nStartCol, nTab ) & CR_MANUALSIZE);
+ bool bOpt = !(rDoc.GetColFlags( nStartCol, nTab ) & CRFlags::ManualSize);
aAny <<= bOpt;
}
else if ( aPropertyName == SC_UNONAME_NEWPAGE )
@@ -4017,7 +4017,7 @@ uno::Any SAL_CALL ScTableRowsObj::getPropertyValue( const OUString& aPropertyNam
}
else if ( aPropertyName == SC_UNONAME_OHEIGHT )
{
- bool bOpt = !(rDoc.GetRowFlags( nStartRow, nTab ) & CR_MANUALSIZE);
+ bool bOpt = !(rDoc.GetRowFlags( nStartRow, nTab ) & CRFlags::ManualSize);
aAny <<= bOpt;
}
else if ( aPropertyName == SC_UNONAME_NEWPAGE )
diff --git a/sc/source/ui/view/output2.cxx b/sc/source/ui/view/output2.cxx
index 069f7e439bba..e6e75b2bd31c 100644
--- a/sc/source/ui/view/output2.cxx
+++ b/sc/source/ui/view/output2.cxx
@@ -1949,7 +1949,7 @@ Rectangle ScOutputData::LayoutStrings(bool bPixelToLogic, bool bPaint, const ScA
// no vertical clipping when printing cells with optimal height,
// except when font size is from conditional formatting.
if ( eType != OUTTYPE_PRINTER ||
- ( mpDoc->GetRowFlags( nCellY, nTab ) & CR_MANUALSIZE ) ||
+ ( mpDoc->GetRowFlags( nCellY, nTab ) & CRFlags::ManualSize ) ||
( aVars.HasCondHeight() ) )
bVClip = true;
}
@@ -3031,7 +3031,7 @@ void ScOutputData::DrawEditStandard(DrawEditParam& rParam)
// except when font size is from conditional formatting.
//! Allow clipping when vertically merged?
if ( eType != OUTTYPE_PRINTER ||
- ( mpDoc->GetRowFlags( rParam.mnCellY, nTab ) & CR_MANUALSIZE ) ||
+ ( mpDoc->GetRowFlags( rParam.mnCellY, nTab ) & CRFlags::ManualSize ) ||
( rParam.mpCondSet && SfxItemState::SET ==
rParam.mpCondSet->GetItemState(ATTR_FONT_HEIGHT) ) )
bClip = true;
@@ -3243,7 +3243,7 @@ bool ScOutputData::Clip( DrawEditParam& rParam, const Size& aCellSize,
// except when font size is from conditional formatting.
//! Allow clipping when vertically merged?
if ( eType != OUTTYPE_PRINTER ||
- ( mpDoc->GetRowFlags( rParam.mnCellY, nTab ) & CR_MANUALSIZE ) ||
+ ( mpDoc->GetRowFlags( rParam.mnCellY, nTab ) & CRFlags::ManualSize ) ||
( rParam.mpCondSet && SfxItemState::SET ==
rParam.mpCondSet->GetItemState(ATTR_FONT_HEIGHT) ) )
bClip = true;
@@ -4006,7 +4006,7 @@ void ScOutputData::DrawEditStacked(DrawEditParam& rParam)
// except when font size is from conditional formatting.
//! Allow clipping when vertically merged?
if ( eType != OUTTYPE_PRINTER ||
- ( mpDoc->GetRowFlags( rParam.mnCellY, nTab ) & CR_MANUALSIZE ) ||
+ ( mpDoc->GetRowFlags( rParam.mnCellY, nTab ) & CRFlags::ManualSize ) ||
( rParam.mpCondSet && SfxItemState::SET ==
rParam.mpCondSet->GetItemState(ATTR_FONT_HEIGHT) ) )
bClip = true;
@@ -4352,7 +4352,7 @@ void ScOutputData::DrawEditAsianVertical(DrawEditParam& rParam)
// except when font size is from conditional formatting.
//! Allow clipping when vertically merged?
if ( eType != OUTTYPE_PRINTER ||
- ( mpDoc->GetRowFlags( rParam.mnCellY, nTab ) & CR_MANUALSIZE ) ||
+ ( mpDoc->GetRowFlags( rParam.mnCellY, nTab ) & CRFlags::ManualSize ) ||
( rParam.mpCondSet && SfxItemState::SET ==
rParam.mpCondSet->GetItemState(ATTR_FONT_HEIGHT) ) )
bClip = true;
diff --git a/sc/source/ui/view/viewdata.cxx b/sc/source/ui/view/viewdata.cxx
index cbc64bd22cf2..fda2dbb92dca 100644
--- a/sc/source/ui/view/viewdata.cxx
+++ b/sc/source/ui/view/viewdata.cxx
@@ -1367,7 +1367,7 @@ void ScViewData::EditGrowY( bool bInitial )
// to be clipped before extending to following rows, to avoid obscuring cells for
// reference input (next row is likely to be useful in formulas).
long nAllowedExtra = SC_GROWY_SMALL_EXTRA;
- if ( nEditEndRow == nEditRow && !( pDoc->GetRowFlags( nEditRow, nTabNo ) & CR_MANUALSIZE ) &&
+ if ( nEditEndRow == nEditRow && !( pDoc->GetRowFlags( nEditRow, nTabNo ) & CRFlags::ManualSize ) &&
pEngine->GetParagraphCount() <= 1 )
{
// If the (only) paragraph starts with a '=', it's a formula.
diff --git a/sc/source/ui/view/viewfunc.cxx b/sc/source/ui/view/viewfunc.cxx
index 5b5c3ca5b49b..091f9482c734 100644
--- a/sc/source/ui/view/viewfunc.cxx
+++ b/sc/source/ui/view/viewfunc.cxx
@@ -1942,7 +1942,7 @@ void ScViewFunc::SetWidthOrHeight(
bool bAll = ( eMode==SC_SIZE_OPTIMAL );
if (!bAll)
{
- // delete CR_MANUALSIZE for all in range,
+ // delete CRFlags::ManualSize for all in range,
// then SetOptimalHeight with bShrink = FALSE
for (SCROW nRow = nStartNo; nRow <= nEndNo; ++nRow)
{
@@ -1953,9 +1953,9 @@ void ScViewFunc::SetWidthOrHeight(
continue;
}
- sal_uInt8 nOld = rDoc.GetRowFlags(nRow, nTab);
- if (nOld & CR_MANUALSIZE)
- rDoc.SetRowFlags(nRow, nTab, nOld & ~CR_MANUALSIZE);
+ CRFlags nOld = rDoc.GetRowFlags(nRow, nTab);
+ if (nOld & CRFlags::ManualSize)
+ rDoc.SetRowFlags(nRow, nTab, nOld & ~CRFlags::ManualSize);
}
}
generated by cgit (git 2.34.1) at 2025-02-22 09:09:21 +0000