convert CR flags to typed_flags_set

Change-Id: I20f602eedc72581e22f18c514d8f406690844c28

6 files changed, 53 insertions, 53 deletions

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 )