Convert ScConditionMode to scoped enum

Change-Id: I9b6aaa64e7f649581b27f0238e2908026ab6e0bd
Reviewed-on: https://gerrit.libreoffice.org/45157
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Tor Lillqvist <tml@collabora.com>

19 files changed, 451 insertions, 450 deletions

diff --git a/sc/inc/conditio.hxx b/sc/inc/conditio.hxx
index 79554b1a8d67..10906f0dbacb 100644
--- a/sc/inc/conditio.hxx
+++ b/sc/inc/conditio.hxx
@@ -56,34 +56,34 @@ struct RefUpdateMoveTabContext;
 //  nOptions Flags
 #define SC_COND_NOBLANKS    1
 
-enum ScConditionMode
+enum class ScConditionMode
 {
-    SC_COND_EQUAL,
-    SC_COND_LESS,
-    SC_COND_GREATER,
-    SC_COND_EQLESS,
-    SC_COND_EQGREATER,
-    SC_COND_NOTEQUAL,
-    SC_COND_BETWEEN,
-    SC_COND_NOTBETWEEN,
-    SC_COND_DUPLICATE,
-    SC_COND_NOTDUPLICATE,
-    SC_COND_DIRECT,
-    SC_COND_TOP10,
-    SC_COND_BOTTOM10,
-    SC_COND_TOP_PERCENT,
-    SC_COND_BOTTOM_PERCENT,
-    SC_COND_ABOVE_AVERAGE,
-    SC_COND_BELOW_AVERAGE,
-    SC_COND_ABOVE_EQUAL_AVERAGE,
-    SC_COND_BELOW_EQUAL_AVERAGE,
-    SC_COND_ERROR,
-    SC_COND_NOERROR,
-    SC_COND_BEGINS_WITH,
-    SC_COND_ENDS_WITH,
-    SC_COND_CONTAINS_TEXT,
-    SC_COND_NOT_CONTAINS_TEXT,
-    SC_COND_NONE
+    Equal,
+    Less,
+    Greater,
+    EqLess,
+    EqGreater,
+    NotEqual,
+    Between,
+    NotBetween,
+    Duplicate,
+    NotDuplicate,
+    Direct,
+    Top10,
+    Bottom10,
+    TopPercent,
+    BottomPercent,
+    AboveAverage,
+    BelowAverage,
+    AboveEqualAverage,
+    BelowEqualAverage,
+    Error,
+    NoError,
+    BeginsWith,
+    EndsWith,
+    ContainsText,
+    NotContainsText,
+    NONE
 };
 
 class ScFormulaListener : public SvtListener
diff --git a/sc/qa/unit/subsequent_filters-test.cxx b/sc/qa/unit/subsequent_filters-test.cxx
index 9f3bc88ba9f3..1a1ff8fa6452 100644
--- a/sc/qa/unit/subsequent_filters-test.cxx
+++ b/sc/qa/unit/subsequent_filters-test.cxx
@@ -1314,14 +1314,14 @@ void ScFiltersTest::testDataValidityODS()
 
     //sheet1's expected Data Validation Entry values
     ValDataTestParams aVDTParams1(
-        SC_VALID_DECIMAL, SC_COND_GREATER, "3.14", EMPTY_OUSTRING, rDoc,
+        SC_VALID_DECIMAL, ScConditionMode::Greater, "3.14", EMPTY_OUSTRING, rDoc,
         aValBaseAddr1, "Too small",
         "The number you are trying to enter is not greater than 3.14! Are you sure you want to enter it anyway?",
         SC_VALERR_WARNING, 1
     );
     //sheet2's expected Data Validation Entry values
     ValDataTestParams aVDTParams2(
-        SC_VALID_WHOLE, SC_COND_BETWEEN, "1", "10", rDoc,
+        SC_VALID_WHOLE, ScConditionMode::Between, "1", "10", rDoc,
         aValBaseAddr2, "Error sheet 2",
         "Must be a whole number between 1 and 10.",
         SC_VALERR_STOP, 2
diff --git a/sc/qa/unit/ucalc_condformat.cxx b/sc/qa/unit/ucalc_condformat.cxx
index 1e3d94473522..f98d2e94b8eb 100644
--- a/sc/qa/unit/ucalc_condformat.cxx
+++ b/sc/qa/unit/ucalc_condformat.cxx
@@ -100,7 +100,7 @@ void Test::testCondFormatINSDEL()
     ScConditionalFormat* pFormat = new ScConditionalFormat(1, m_pDoc);
     ScRangeList aRangeList(ScRange(0,0,0,0,3,0));
     pFormat->SetRange(aRangeList);
-    ScCondFormatEntry* pEntry = new ScCondFormatEntry(SC_COND_DIRECT,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
+    ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
     pFormat->AddEntry(pEntry);
 
     m_pDoc->AddCondFormatData(pFormat->GetRange(), 0, 1);
@@ -125,7 +125,7 @@ void Test::testCondFormatInsertCol()
     ScRangeList aRangeList(ScRange(0,0,0,3,3,0));
     pFormat->SetRange(aRangeList);
 
-    ScCondFormatEntry* pEntry = new ScCondFormatEntry(SC_COND_DIRECT,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
+    ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
     pFormat->AddEntry(pEntry);
 
     m_pDoc->AddCondFormatData(pFormat->GetRange(), 0, 1);
@@ -147,7 +147,7 @@ void Test::testCondFormatInsertRow()
     ScRangeList aRangeList(ScRange(0,0,0,3,3,0));
     pFormat->SetRange(aRangeList);
 
-    ScCondFormatEntry* pEntry = new ScCondFormatEntry(SC_COND_DIRECT,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
+    ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
     pFormat->AddEntry(pEntry);
 
     m_pDoc->AddCondFormatData(pFormat->GetRange(), 0, 1);
@@ -172,7 +172,7 @@ void Test::testCondFormatInsertDeleteSheets()
 
     // Add condition in which if the value equals 2, set the "Result" style.
     ScCondFormatEntry* pEntry = new ScCondFormatEntry(
-        SC_COND_EQUAL, "=2", "" , m_pDoc, ScAddress(0,0,0), ScGlobal::GetRscString(STR_STYLENAME_RESULT));
+        ScConditionMode::Equal, "=2", "" , m_pDoc, ScAddress(0,0,0), ScGlobal::GetRscString(STR_STYLENAME_RESULT));
     pFormat->AddEntry(pEntry);
 
     // Apply the format to the range.
@@ -275,7 +275,7 @@ void Test::testCondCopyPaste()
     ScRangeList aRangeList(aCondFormatRange);
     pFormat->SetRange(aRangeList);
 
-    ScCondFormatEntry* pEntry = new ScCondFormatEntry(SC_COND_DIRECT,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
+    ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
     pFormat->AddEntry(pEntry);
     sal_uLong nIndex = m_pDoc->AddCondFormat(pFormat, 0);
 
@@ -309,7 +309,7 @@ void Test::testCondCopyPasteSingleCell()
     ScRangeList aRangeList(aCondFormatRange);
     pFormat->SetRange(aRangeList);
 
-    ScCondFormatEntry* pEntry = new ScCondFormatEntry(SC_COND_DIRECT,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
+    ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
     pFormat->AddEntry(pEntry);
     sal_uLong nIndex = m_pDoc->AddCondFormat(pFormat, 0);
 
@@ -343,7 +343,7 @@ void Test::testCondCopyPasteSingleCellToRange()
     ScRangeList aRangeList(aCondFormatRange);
     pFormat->SetRange(aRangeList);
 
-    ScCondFormatEntry* pEntry = new ScCondFormatEntry(SC_COND_DIRECT,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
+    ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
     pFormat->AddEntry(pEntry);
     sal_uLong nIndex = m_pDoc->AddCondFormat(pFormat, 0);
 
@@ -387,7 +387,7 @@ void Test::testCondCopyPasteSingleRowToRange()
     ScRangeList aRangeList(aCondFormatRange);
     pFormat->SetRange(aRangeList);
 
-    ScCondFormatEntry* pEntry = new ScCondFormatEntry(SC_COND_DIRECT,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
+    ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
     pFormat->AddEntry(pEntry);
     m_pDoc->AddCondFormat(pFormat, 0);
 
@@ -418,7 +418,7 @@ void Test::testCondCopyPasteSingleRowToRange2()
     ScRangeList aRangeList(aCondFormatRange);
     pFormat->SetRange(aRangeList);
 
-    ScCondFormatEntry* pEntry = new ScCondFormatEntry(SC_COND_DIRECT,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
+    ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
     pFormat->AddEntry(pEntry);
     m_pDoc->AddCondFormat(pFormat, 0);
 
@@ -448,7 +448,7 @@ void Test::testCondCopyPasteSheetBetweenDoc()
     ScRangeList aRangeList(aCondFormatRange);
     pFormat->SetRange(aRangeList);
 
-    ScCondFormatEntry* pEntry = new ScCondFormatEntry(SC_COND_DIRECT,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
+    ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
     pFormat->AddEntry(pEntry);
     m_pDoc->AddCondFormat(pFormat, 0);
 
@@ -470,7 +470,7 @@ void Test::testCondCopyPasteSheet()
     ScRangeList aRangeList(aCondFormatRange);
     pFormat->SetRange(aRangeList);
 
-    ScCondFormatEntry* pEntry = new ScCondFormatEntry(SC_COND_DIRECT,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
+    ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",m_pDoc,ScAddress(0,0,0),ScGlobal::GetRscString(STR_STYLENAME_RESULT));
     pFormat->AddEntry(pEntry);
     m_pDoc->AddCondFormat(pFormat, 0);
 
@@ -696,7 +696,7 @@ void Test::testCondFormatEndsWithStr()
 {
     m_pDoc->InsertTab(0, "Test");
 
-    ScConditionEntry aEntry(SC_COND_ENDS_WITH, "\"TestString\"", "", m_pDoc, ScAddress(),
+    ScConditionEntry aEntry(ScConditionMode::EndsWith, "\"TestString\"", "", m_pDoc, ScAddress(),
             "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
 
     svl::SharedStringPool& rStringPool = m_pDoc->GetSharedStringPool();
@@ -714,7 +714,7 @@ void Test::testCondFormatEndsWithVal()
 {
     m_pDoc->InsertTab(0, "Test");
 
-    ScConditionEntry aEntry(SC_COND_ENDS_WITH, "2", "", m_pDoc, ScAddress(),
+    ScConditionEntry aEntry(ScConditionMode::EndsWith, "2", "", m_pDoc, ScAddress(),
             "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
 
     for (sal_Int32 i = 0; i < 15; ++i)
@@ -852,7 +852,7 @@ void Test::testCondFormatUpdateMoveTab()
     m_pDoc->InsertTab(0, "test");
     m_pDoc->InsertTab(1, "Test2");
 
-    ScConditionEntry* pEntry = new ScConditionEntry(SC_COND_EQUAL, "A1", "", m_pDoc, ScAddress(10, 10, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
+    ScConditionEntry* pEntry = new ScConditionEntry(ScConditionMode::Equal, "A1", "", m_pDoc, ScAddress(10, 10, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
 
     ScConditionalFormat* pFormat = new ScConditionalFormat(0, m_pDoc);
     pFormat->SetRange(ScRange(10, 10, 0, 10, 12, 0));
@@ -887,7 +887,7 @@ void Test::testCondFormatUpdateInsertTab()
 {
     m_pDoc->InsertTab(0, "test");
 
-    ScConditionEntry* pEntry = new ScConditionEntry(SC_COND_EQUAL, "A1", "", m_pDoc, ScAddress(10, 10, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
+    ScConditionEntry* pEntry = new ScConditionEntry(ScConditionMode::Equal, "A1", "", m_pDoc, ScAddress(10, 10, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
 
     ScConditionalFormat* pFormat = new ScConditionalFormat(0, m_pDoc);
     pFormat->SetRange(ScRange(10, 10, 0, 10, 12, 0));
@@ -926,7 +926,7 @@ void Test::testCondFormatUpdateDeleteTab()
     m_pDoc->InsertTab(0, "test");
     m_pDoc->InsertTab(1, "Test2");
 
-    ScConditionEntry* pEntry = new ScConditionEntry(SC_COND_EQUAL, "A1", "", m_pDoc, ScAddress(10, 10, 1), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
+    ScConditionEntry* pEntry = new ScConditionEntry(ScConditionMode::Equal, "A1", "", m_pDoc, ScAddress(10, 10, 1), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
 
     ScConditionalFormat* pFormat = new ScConditionalFormat(0, m_pDoc);
     pFormat->SetRange(ScRange(10, 10, 1, 10, 12, 1));
@@ -958,7 +958,7 @@ void Test::testCondFormatUpdateReference()
     m_pDoc->InsertTab(0, "test");
     m_pDoc->InsertTab(1, "Test2");
 
-    ScConditionEntry* pEntry = new ScConditionEntry(SC_COND_EQUAL, "A1", "", m_pDoc, ScAddress(10, 10, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
+    ScConditionEntry* pEntry = new ScConditionEntry(ScConditionMode::Equal, "A1", "", m_pDoc, ScAddress(10, 10, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
 
     ScConditionalFormat* pFormat = new ScConditionalFormat(0, m_pDoc);
     pFormat->SetRange(ScRange(10, 10, 0, 10, 12, 0));
@@ -981,7 +981,7 @@ void Test::testCondFormatUpdateReferenceDelRow()
 {
     m_pDoc->InsertTab(0, "test");
 
-    ScConditionEntry* pEntry = new ScConditionEntry(SC_COND_EQUAL, "B6", "", m_pDoc, ScAddress(0, 5, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
+    ScConditionEntry* pEntry = new ScConditionEntry(ScConditionMode::Equal, "B6", "", m_pDoc, ScAddress(0, 5, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
 
     ScConditionalFormat* pFormat = new ScConditionalFormat(0, m_pDoc);
     pFormat->SetRange(ScRange(0, 5, 0, 0, 5, 0));
@@ -1001,7 +1001,7 @@ void Test::testCondFormatUpdateReferenceInsRow()
 {
     m_pDoc->InsertTab(0, "test");
 
-    ScConditionEntry* pEntry = new ScConditionEntry(SC_COND_EQUAL, "B6", "", m_pDoc, ScAddress(0, 5, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
+    ScConditionEntry* pEntry = new ScConditionEntry(ScConditionMode::Equal, "B6", "", m_pDoc, ScAddress(0, 5, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
 
     ScConditionalFormat* pFormat = new ScConditionalFormat(0, m_pDoc);
     pFormat->SetRange(ScRange(0, 5, 0, 0, 5, 0));
@@ -1021,7 +1021,7 @@ void Test::testCondFormatUndoList()
 {
     m_pDoc->InsertTab(0, "test");
 
-    ScConditionEntry* pEntry = new ScConditionEntry(SC_COND_EQUAL, "B6", "", m_pDoc, ScAddress(0, 5, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
+    ScConditionEntry* pEntry = new ScConditionEntry(ScConditionMode::Equal, "B6", "", m_pDoc, ScAddress(0, 5, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
 
     ScConditionalFormat* pFormat = new ScConditionalFormat(0, m_pDoc);
     pFormat->AddEntry(pEntry);
diff --git a/sc/qa/unit/ucalc_formula.cxx b/sc/qa/unit/ucalc_formula.cxx
index 4d3277f32d2e..bd6fbbaffa64 100644
--- a/sc/qa/unit/ucalc_formula.cxx
+++ b/sc/qa/unit/ucalc_formula.cxx
@@ -3609,7 +3609,7 @@ void Test::testFormulaRefUpdateValidity()
 
     // Set validity in A2.
     ScValidationData aData(
-        SC_VALID_LIST, SC_COND_EQUAL, "C2:C4", "", m_pDoc, ScAddress(0,1,0), "", "",
+        SC_VALID_LIST, ScConditionMode::Equal, "C2:C4", "", m_pDoc, ScAddress(0,1,0), "", "",
         m_pDoc->GetGrammar(), m_pDoc->GetGrammar());
 
     sal_uLong nIndex = m_pDoc->AddValidationEntry(aData);
diff --git a/sc/source/core/data/conditio.cxx b/sc/source/core/data/conditio.cxx
index 4d31210e4afc..7e2d9a30b372 100644
--- a/sc/source/core/data/conditio.cxx
+++ b/sc/source/core/data/conditio.cxx
@@ -1047,26 +1047,26 @@ bool ScConditionEntry::IsValid( double nArg, const ScAddress& rPos ) const
     {
         switch( eOp )
         {
-            case SC_COND_BEGINS_WITH:
-            case SC_COND_ENDS_WITH:
-            case SC_COND_CONTAINS_TEXT:
-            case SC_COND_NOT_CONTAINS_TEXT:
+            case ScConditionMode::BeginsWith:
+            case ScConditionMode::EndsWith:
+            case ScConditionMode::ContainsText:
+            case ScConditionMode::NotContainsText:
                 break;
-            case SC_COND_NOTEQUAL:
+            case ScConditionMode::NotEqual:
                 return true;
             default:
                 return false;
         }
     }
 
-    if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN )
+    if ( eOp == ScConditionMode::Between || eOp == ScConditionMode::NotBetween )
         if ( bIsStr2 )
             return false;
 
     double nComp1 = nVal1; // Copy, so that it can be changed
     double nComp2 = nVal2;
 
-    if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN )
+    if ( eOp == ScConditionMode::Between || eOp == ScConditionMode::NotBetween )
         if ( nComp1 > nComp2 )
         {
             // Right order for value range
@@ -1077,73 +1077,73 @@ bool ScConditionEntry::IsValid( double nArg, const ScAddress& rPos ) const
     bool bValid = false;
     switch (eOp)
     {
-        case SC_COND_NONE:
+        case ScConditionMode::NONE:
             break;                  // Always sal_False
-        case SC_COND_EQUAL:
+        case ScConditionMode::Equal:
             bValid = ::rtl::math::approxEqual( nArg, nComp1 );
             break;
-        case SC_COND_NOTEQUAL:
+        case ScConditionMode::NotEqual:
             bValid = !::rtl::math::approxEqual( nArg, nComp1 );
             break;
-        case SC_COND_GREATER:
+        case ScConditionMode::Greater:
             bValid = ( nArg > nComp1 ) && !::rtl::math::approxEqual( nArg, nComp1 );
             break;
-        case SC_COND_EQGREATER:
+        case ScConditionMode::EqGreater:
             bValid = ( nArg >= nComp1 ) || ::rtl::math::approxEqual( nArg, nComp1 );
             break;
-        case SC_COND_LESS:
+        case ScConditionMode::Less:
             bValid = ( nArg < nComp1 ) && !::rtl::math::approxEqual( nArg, nComp1 );
             break;
-        case SC_COND_EQLESS:
+        case ScConditionMode::EqLess:
             bValid = ( nArg <= nComp1 ) || ::rtl::math::approxEqual( nArg, nComp1 );
             break;
-        case SC_COND_BETWEEN:
+        case ScConditionMode::Between:
             bValid = ( nArg >= nComp1 && nArg <= nComp2 ) ||
                      ::rtl::math::approxEqual( nArg, nComp1 ) || ::rtl::math::approxEqual( nArg, nComp2 );
             break;
-        case SC_COND_NOTBETWEEN:
+        case ScConditionMode::NotBetween:
             bValid = ( nArg < nComp1 || nArg > nComp2 ) &&
                      !::rtl::math::approxEqual( nArg, nComp1 ) && !::rtl::math::approxEqual( nArg, nComp2 );
             break;
-        case SC_COND_DUPLICATE:
-        case SC_COND_NOTDUPLICATE:
+        case ScConditionMode::Duplicate:
+        case ScConditionMode::NotDuplicate:
             if( pCondFormat )
             {
                 bValid = IsDuplicate( nArg, OUString() );
-                if( eOp == SC_COND_NOTDUPLICATE )
+                if( eOp == ScConditionMode::NotDuplicate )
                     bValid = !bValid;
             }
             break;
-        case SC_COND_DIRECT:
+        case ScConditionMode::Direct:
             bValid = nComp1 != 0.0;
             break;
-        case SC_COND_TOP10:
+        case ScConditionMode::Top10:
             bValid = IsTopNElement( nArg );
             break;
-        case SC_COND_BOTTOM10:
+        case ScConditionMode::Bottom10:
             bValid = IsBottomNElement( nArg );
             break;
-        case SC_COND_TOP_PERCENT:
+        case ScConditionMode::TopPercent:
             bValid = IsTopNPercent( nArg );
             break;
-        case SC_COND_BOTTOM_PERCENT:
+        case ScConditionMode::BottomPercent:
             bValid = IsBottomNPercent( nArg );
             break;
-        case SC_COND_ABOVE_AVERAGE:
-        case SC_COND_ABOVE_EQUAL_AVERAGE:
-            bValid = IsAboveAverage( nArg, eOp == SC_COND_ABOVE_EQUAL_AVERAGE );
+        case ScConditionMode::AboveAverage:
+        case ScConditionMode::AboveEqualAverage:
+            bValid = IsAboveAverage( nArg, eOp == ScConditionMode::AboveEqualAverage );
             break;
-        case SC_COND_BELOW_AVERAGE:
-        case SC_COND_BELOW_EQUAL_AVERAGE:
-            bValid = IsBelowAverage( nArg, eOp == SC_COND_BELOW_EQUAL_AVERAGE );
+        case ScConditionMode::BelowAverage:
+        case ScConditionMode::BelowEqualAverage:
+            bValid = IsBelowAverage( nArg, eOp == ScConditionMode::BelowEqualAverage );
             break;
-        case SC_COND_ERROR:
-        case SC_COND_NOERROR:
+        case ScConditionMode::Error:
+        case ScConditionMode::NoError:
             bValid = IsError( rPos );
-            if( eOp == SC_COND_NOERROR )
+            if( eOp == ScConditionMode::NoError )
                 bValid = !bValid;
             break;
-        case SC_COND_BEGINS_WITH:
+        case ScConditionMode::BeginsWith:
             if(aStrVal1.isEmpty())
             {
                 OUString aStr = OUString::number(nVal1);
@@ -1156,7 +1156,7 @@ bool ScConditionEntry::IsValid( double nArg, const ScAddress& rPos ) const
                 bValid = aStr2.startsWith(aStrVal1);
             }
             break;
-        case SC_COND_ENDS_WITH:
+        case ScConditionMode::EndsWith:
             if(aStrVal1.isEmpty())
             {
                 OUString aStr = OUString::number(nVal1);
@@ -1169,8 +1169,8 @@ bool ScConditionEntry::IsValid( double nArg, const ScAddress& rPos ) const
                 bValid = aStr2.endsWith(aStrVal1);
             }
             break;
-        case SC_COND_CONTAINS_TEXT:
-        case SC_COND_NOT_CONTAINS_TEXT:
+        case ScConditionMode::ContainsText:
+        case ScConditionMode::NotContainsText:
             if(aStrVal1.isEmpty())
             {
                 OUString aStr = OUString::number(nVal1);
@@ -1183,7 +1183,7 @@ bool ScConditionEntry::IsValid( double nArg, const ScAddress& rPos ) const
                 bValid = aStr2.indexOf(aStrVal1) != -1;
             }
 
-            if( eOp == SC_COND_NOT_CONTAINS_TEXT )
+            if( eOp == ScConditionMode::NotContainsText )
                 bValid = !bValid;
             break;
         default:
@@ -1197,31 +1197,31 @@ bool ScConditionEntry::IsValidStr( const OUString& rArg, const ScAddress& rPos )
 {
     bool bValid = false;
     // Interpret must already have been called
-    if ( eOp == SC_COND_DIRECT ) // Formula is independent from the content
+    if ( eOp == ScConditionMode::Direct ) // Formula is independent from the content
         return nVal1 != 0.0;
 
-    if ( eOp == SC_COND_DUPLICATE || eOp == SC_COND_NOTDUPLICATE )
+    if ( eOp == ScConditionMode::Duplicate || eOp == ScConditionMode::NotDuplicate )
     {
         if( pCondFormat && !rArg.isEmpty() )
         {
             bValid = IsDuplicate( 0.0, rArg );
-            if( eOp == SC_COND_NOTDUPLICATE )
+            if( eOp == ScConditionMode::NotDuplicate )
                 bValid = !bValid;
             return bValid;
         }
     }
 
     // If number contains condition, always false, except for "not equal".
-    if ( !bIsStr1 && (eOp != SC_COND_ERROR && eOp != SC_COND_NOERROR) )
-        return ( eOp == SC_COND_NOTEQUAL );
-    if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN )
+    if ( !bIsStr1 && (eOp != ScConditionMode::Error && eOp != ScConditionMode::NoError) )
+        return ( eOp == ScConditionMode::NotEqual );
+    if ( eOp == ScConditionMode::Between || eOp == ScConditionMode::NotBetween )
         if ( !bIsStr2 )
             return false;
 
     OUString aUpVal1( aStrVal1 ); //TODO: As a member? (Also set in Interpret)
     OUString aUpVal2( aStrVal2 );
 
-    if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN )
+    if ( eOp == ScConditionMode::Between || eOp == ScConditionMode::NotBetween )
         if (ScGlobal::GetCollator()->compareString( aUpVal1, aUpVal2 ) > 0)
         {
             // Right order for value range
@@ -1230,37 +1230,37 @@ bool ScConditionEntry::IsValidStr( const OUString& rArg, const ScAddress& rPos )
 
     switch ( eOp )
     {
-        case SC_COND_EQUAL:
+        case ScConditionMode::Equal:
             bValid = (ScGlobal::GetCollator()->compareString(
                 rArg, aUpVal1 ) == 0);
         break;
-        case SC_COND_NOTEQUAL:
+        case ScConditionMode::NotEqual:
             bValid = (ScGlobal::GetCollator()->compareString(
                 rArg, aUpVal1 ) != 0);
         break;
-        case SC_COND_TOP_PERCENT:
-        case SC_COND_BOTTOM_PERCENT:
-        case SC_COND_TOP10:
-        case SC_COND_BOTTOM10:
-        case SC_COND_ABOVE_AVERAGE:
-        case SC_COND_BELOW_AVERAGE:
+        case ScConditionMode::TopPercent:
+        case ScConditionMode::BottomPercent:
+        case ScConditionMode::Top10:
+        case ScConditionMode::Bottom10:
+        case ScConditionMode::AboveAverage:
+        case ScConditionMode::BelowAverage:
             return false;
-        case SC_COND_ERROR:
-        case SC_COND_NOERROR:
+        case ScConditionMode::Error:
+        case ScConditionMode::NoError:
             bValid = IsError( rPos );
-            if(eOp == SC_COND_NOERROR)
+            if(eOp == ScConditionMode::NoError)
                 bValid = !bValid;
         break;
-        case SC_COND_BEGINS_WITH:
+        case ScConditionMode::BeginsWith:
             bValid = rArg.startsWith(aUpVal1);
         break;
-        case SC_COND_ENDS_WITH:
+        case ScConditionMode::EndsWith:
             bValid = rArg.endsWith(aUpVal1);
         break;
-        case SC_COND_CONTAINS_TEXT:
-        case SC_COND_NOT_CONTAINS_TEXT:
+        case ScConditionMode::ContainsText:
+        case ScConditionMode::NotContainsText:
             bValid = rArg.indexOf(aUpVal1) != -1;
-            if(eOp == SC_COND_NOT_CONTAINS_TEXT)
+            if(eOp == ScConditionMode::NotContainsText)
                 bValid = !bValid;
         break;
         default:
@@ -1269,28 +1269,28 @@ bool ScConditionEntry::IsValidStr( const OUString& rArg, const ScAddress& rPos )
                 rArg, aUpVal1 );
             switch ( eOp )
             {
-                case SC_COND_GREATER:
+                case ScConditionMode::Greater:
                     bValid = ( nCompare > 0 );
                     break;
-                case SC_COND_EQGREATER:
+                case ScConditionMode::EqGreater:
                     bValid = ( nCompare >= 0 );
                     break;
-                case SC_COND_LESS:
+                case ScConditionMode::Less:
                     bValid = ( nCompare < 0 );
                     break;
-                case SC_COND_EQLESS:
+                case ScConditionMode::EqLess:
                     bValid = ( nCompare <= 0 );
                     break;
-                case SC_COND_BETWEEN:
-                case SC_COND_NOTBETWEEN:
+                case ScConditionMode::Between:
+                case ScConditionMode::NotBetween:
                     //  Test for NOTBETWEEN:
                     bValid = ( nCompare < 0 ||
                         ScGlobal::GetCollator()->compareString( rArg,
                         aUpVal2 ) > 0 );
-                    if ( eOp == SC_COND_BETWEEN )
+                    if ( eOp == ScConditionMode::Between )
                         bValid = !bValid;
                     break;
-                //  SC_COND_DIRECT already handled above
+                //  ScConditionMode::Direct already handled above
                 default:
                     SAL_WARN("sc", "unknown operation in ScConditionEntry");
                     bValid = false;
@@ -1481,41 +1481,41 @@ ScFormatEntry* ScConditionEntry::Clone(ScDocument* pDoc) const
 
 ScConditionMode ScConditionEntry::GetModeFromApi(css::sheet::ConditionOperator nOperation)
 {
-    ScConditionMode eMode = SC_COND_NONE;
+    ScConditionMode eMode = ScConditionMode::NONE;
     switch ((sal_Int32)nOperation)
     {
         case css::sheet::ConditionOperator2::EQUAL:
-            eMode = SC_COND_EQUAL;
+            eMode = ScConditionMode::Equal;
             break;
         case css::sheet::ConditionOperator2::LESS:
-            eMode = SC_COND_LESS;
+            eMode = ScConditionMode::Less;
             break;
         case css::sheet::ConditionOperator2::GREATER:
-            eMode = SC_COND_GREATER;
+            eMode = ScConditionMode::Greater;
             break;
         case css::sheet::ConditionOperator2::LESS_EQUAL:
-            eMode = SC_COND_EQLESS;
+            eMode = ScConditionMode::EqLess;
             break;
         case css::sheet::ConditionOperator2::GREATER_EQUAL:
-            eMode = SC_COND_EQGREATER;
+            eMode = ScConditionMode::EqGreater;
             break;
         case css::sheet::ConditionOperator2::NOT_EQUAL:
-            eMode = SC_COND_NOTEQUAL;
+            eMode = ScConditionMode::NotEqual;
             break;
         case css::sheet::ConditionOperator2::BETWEEN:
-            eMode = SC_COND_BETWEEN;
+            eMode = ScConditionMode::Between;
             break;
         case css::sheet::ConditionOperator2::NOT_BETWEEN:
-            eMode = SC_COND_NOTBETWEEN;
+            eMode = ScConditionMode::NotBetween;
             break;
         case css::sheet::ConditionOperator2::FORMULA:
-            eMode = SC_COND_DIRECT;
+            eMode = ScConditionMode::Direct;
             break;
         case css::sheet::ConditionOperator2::DUPLICATE:
-            eMode = SC_COND_DUPLICATE;
+            eMode = ScConditionMode::Duplicate;
             break;
         case css::sheet::ConditionOperator2::NOT_DUPLICATE:
-            eMode = SC_COND_NOTDUPLICATE;
+            eMode = ScConditionMode::NotDuplicate;
             break;
         default:
             break;
diff --git a/sc/source/core/data/validat.cxx b/sc/source/core/data/validat.cxx
index 45c113e63a3d..433dd55c70a7 100644
--- a/sc/source/core/data/validat.cxx
+++ b/sc/source/core/data/validat.cxx
@@ -125,7 +125,7 @@ ScValidationData::~ScValidationData()
 
 bool ScValidationData::IsEmpty() const
 {
-    ScValidationData aDefault( SC_VALID_ANY, SC_COND_EQUAL, "", "", GetDocument(), ScAddress() );
+    ScValidationData aDefault( SC_VALID_ANY, ScConditionMode::Equal, "", "", GetDocument(), ScAddress() );
     return EqualEntries( aDefault );
 }
 
@@ -524,7 +524,7 @@ bool ScValidationData::IsDataValid( ScRefCellValue& rCell, const ScAddress& rPos
             break;
 
         case SC_VALID_CUSTOM:
-            //  for Custom, it must be eOp == SC_COND_DIRECT
+            //  for Custom, it must be eOp == ScConditionMode::Direct
             //TODO: the value must be in the document !!!
             bOk = IsCellValid(rCell, rPos);
             break;
@@ -844,7 +844,7 @@ bool ScValidationData::FillSelectionList(std::vector<ScTypedStrData>& rStrColl,
 bool ScValidationData::IsEqualToTokenArray( ScRefCellValue& rCell, const ScAddress& rPos, const ScTokenArray& rTokArr ) const
 {
     // create a condition entry that tests on equality and set the passed token array
-    ScConditionEntry aCondEntry( SC_COND_EQUAL, &rTokArr, nullptr, GetDocument(), rPos );
+    ScConditionEntry aCondEntry( ScConditionMode::Equal, &rTokArr, nullptr, GetDocument(), rPos );
     return aCondEntry.IsCellValid(rCell, rPos);
 }
 
diff --git a/sc/source/filter/excel/xecontent.cxx b/sc/source/filter/excel/xecontent.cxx
index 8939aadf6113..3164164c2cef 100644
--- a/sc/source/filter/excel/xecontent.cxx
+++ b/sc/source/filter/excel/xecontent.cxx
@@ -665,36 +665,36 @@ XclExpCFImpl::XclExpCFImpl( const XclExpRoot& rRoot, const ScCondFormatEntry& rF
 
     switch( rFormatEntry.GetOperation() )
     {
-        case SC_COND_NONE:
+        case ScConditionMode::NONE:
             mnType = EXC_CF_TYPE_NONE;
         break;
-        case SC_COND_BETWEEN:
+        case ScConditionMode::Between:
             mnOperator = EXC_CF_CMP_BETWEEN;
             mbFormula2 = true;
         break;
-        case SC_COND_NOTBETWEEN:
+        case ScConditionMode::NotBetween:
             mnOperator = EXC_CF_CMP_NOT_BETWEEN;
             mbFormula2 = true;
         break;
-        case SC_COND_EQUAL:
+        case ScConditionMode::Equal:
             mnOperator = EXC_CF_CMP_EQUAL;
         break;
-        case SC_COND_NOTEQUAL:
+        case ScConditionMode::NotEqual:
             mnOperator = EXC_CF_CMP_NOT_EQUAL;
         break;
-        case SC_COND_GREATER:
+        case ScConditionMode::Greater:
             mnOperator = EXC_CF_CMP_GREATER;
         break;
-        case SC_COND_LESS:
+        case ScConditionMode::Less:
             mnOperator = EXC_CF_CMP_LESS;
         break;
-        case SC_COND_EQGREATER:
+        case ScConditionMode::EqGreater:
             mnOperator = EXC_CF_CMP_GREATER_EQUAL;
         break;
-        case SC_COND_EQLESS:
+        case ScConditionMode::EqLess:
             mnOperator = EXC_CF_CMP_LESS_EQUAL;
         break;
-        case SC_COND_DIRECT:
+        case ScConditionMode::Direct:
             mnType = EXC_CF_TYPE_FMLA;
         break;
         default:
@@ -816,53 +816,53 @@ const char* GetOperatorString(ScConditionMode eMode, bool& bFrmla2)
     const char *pRet = nullptr;
     switch(eMode)
     {
-        case SC_COND_EQUAL:
+        case ScConditionMode::Equal:
             pRet = "equal";
             break;
-        case SC_COND_LESS:
+        case ScConditionMode::Less:
             pRet = "lessThan";
             break;
-        case SC_COND_GREATER:
+        case ScConditionMode::Greater:
             pRet = "greaterThan";
             break;
-        case SC_COND_EQLESS:
+        case ScConditionMode::EqLess:
             pRet = "lessThanOrEqual";
             break;
-        case SC_COND_EQGREATER:
+        case ScConditionMode::EqGreater:
             pRet = "greaterThanOrEqual";
             break;
-        case SC_COND_NOTEQUAL:
+        case ScConditionMode::NotEqual:
             pRet = "notEqual";
             break;
-        case SC_COND_BETWEEN:
+        case ScConditionMode::Between:
             bFrmla2 = true;
             pRet = "between";
             break;
-        case SC_COND_NOTBETWEEN:
+        case ScConditionMode::NotBetween:
             bFrmla2 = true;
             pRet = "notBetween";
             break;
-        case SC_COND_DUPLICATE:
+        case ScConditionMode::Duplicate:
             pRet = nullptr;
             break;
-        case SC_COND_NOTDUPLICATE:
+        case ScConditionMode::NotDuplicate:
             pRet = nullptr;
             break;
-        case SC_COND_BEGINS_WITH:
+        case ScConditionMode::BeginsWith:
             pRet = "beginsWith";
         break;
-        case SC_COND_ENDS_WITH:
+        case ScConditionMode::EndsWith:
             pRet = "endsWith";
         break;
-        case SC_COND_CONTAINS_TEXT:
+        case ScConditionMode::ContainsText:
             pRet = "containsText";
         break;
-        case SC_COND_NOT_CONTAINS_TEXT:
+        case ScConditionMode::NotContainsText:
             pRet = "notContains";
         break;
-        case SC_COND_DIRECT:
+        case ScConditionMode::Direct:
             break;
-        case SC_COND_NONE:
+        case ScConditionMode::NONE:
         default:
             break;
     }
@@ -873,33 +873,33 @@ const char* GetTypeString(ScConditionMode eMode)
 {
     switch(eMode)
     {
-        case SC_COND_DIRECT:
+        case ScConditionMode::Direct:
             return "expression";
-        case SC_COND_TOP10:
-        case SC_COND_TOP_PERCENT:
-        case SC_COND_BOTTOM10:
-        case SC_COND_BOTTOM_PERCENT:
+        case ScConditionMode::Top10:
+        case ScConditionMode::TopPercent:
+        case ScConditionMode::Bottom10:
+        case ScConditionMode::BottomPercent:
             return "top10";
-        case SC_COND_ABOVE_AVERAGE:
-        case SC_COND_BELOW_AVERAGE:
-        case SC_COND_ABOVE_EQUAL_AVERAGE:
-        case SC_COND_BELOW_EQUAL_AVERAGE:
+        case ScConditionMode::AboveAverage:
+        case ScConditionMode::BelowAverage:
+        case ScConditionMode::AboveEqualAverage:
+        case ScConditionMode::BelowEqualAverage:
             return "aboveAverage";
-        case SC_COND_NOTDUPLICATE:
+        case ScConditionMode::NotDuplicate:
             return "uniqueValues";
-        case SC_COND_DUPLICATE:
+        case ScConditionMode::Duplicate:
             return "duplicateValues";
-        case SC_COND_ERROR:
+        case ScConditionMode::Error:
             return "containsErrors";
-        case SC_COND_NOERROR:
+        case ScConditionMode::NoError:
             return "notContainsErrors";
-        case SC_COND_BEGINS_WITH:
+        case ScConditionMode::BeginsWith:
             return "beginsWith";
-        case SC_COND_ENDS_WITH:
+        case ScConditionMode::EndsWith:
             return "endsWith";
-        case SC_COND_CONTAINS_TEXT:
+        case ScConditionMode::ContainsText:
             return "containsText";
-        case SC_COND_NOT_CONTAINS_TEXT:
+        case ScConditionMode::NotContainsText:
             return "notContainsText";
         default:
             return "cellIs";
@@ -910,10 +910,10 @@ bool IsTopBottomRule(ScConditionMode eMode)
 {
     switch(eMode)
     {
-        case SC_COND_TOP10:
-        case SC_COND_BOTTOM10:
-        case SC_COND_TOP_PERCENT:
-        case SC_COND_BOTTOM_PERCENT:
+        case ScConditionMode::Top10:
+        case ScConditionMode::Bottom10:
+        case ScConditionMode::TopPercent:
+        case ScConditionMode::BottomPercent:
             return true;
         default:
             break;
@@ -926,10 +926,10 @@ bool IsTextRule(ScConditionMode eMode)
 {
     switch(eMode)
     {
-        case SC_COND_BEGINS_WITH:
-        case SC_COND_ENDS_WITH:
-        case SC_COND_CONTAINS_TEXT:
-        case SC_COND_NOT_CONTAINS_TEXT:
+        case ScConditionMode::BeginsWith:
+        case ScConditionMode::EndsWith:
+        case ScConditionMode::ContainsText:
+        case ScConditionMode::NotContainsText:
             return true;
         default:
             break;
@@ -944,14 +944,14 @@ void XclExpCFImpl::SaveXml( XclExpXmlStream& rStrm )
 {
     bool bFmla2 = false;
     ScConditionMode eOperation = mrFormatEntry.GetOperation();
-    bool bAboveAverage = eOperation == SC_COND_ABOVE_AVERAGE ||
-                                eOperation == SC_COND_ABOVE_EQUAL_AVERAGE;
-    bool bEqualAverage = eOperation == SC_COND_ABOVE_EQUAL_AVERAGE ||
-                                eOperation == SC_COND_BELOW_EQUAL_AVERAGE;
-    bool bBottom = eOperation == SC_COND_BOTTOM10
-        || eOperation == SC_COND_BOTTOM_PERCENT;
-    bool bPercent = eOperation == SC_COND_TOP_PERCENT ||
-        eOperation == SC_COND_BOTTOM_PERCENT;
+    bool bAboveAverage = eOperation == ScConditionMode::AboveAverage ||
+                                eOperation == ScConditionMode::AboveEqualAverage;
+    bool bEqualAverage = eOperation == ScConditionMode::AboveEqualAverage ||
+                                eOperation == ScConditionMode::BelowEqualAverage;
+    bool bBottom = eOperation == ScConditionMode::Bottom10
+        || eOperation == ScConditionMode::BottomPercent;
+    bool bPercent = eOperation == ScConditionMode::TopPercent ||
+        eOperation == ScConditionMode::BottomPercent;
     OString aRank("0");
     if(IsTopBottomRule(eOperation))
     {
@@ -1618,15 +1618,15 @@ XclExpDV::XclExpDV( const XclExpRoot& rRoot, sal_uLong nScHandle ) :
 
         switch( pValData->GetOperation() )
         {
-            case SC_COND_NONE:
-            case SC_COND_EQUAL:         mnFlags |= EXC_DV_COND_EQUAL;       break;
-            case SC_COND_LESS:          mnFlags |= EXC_DV_COND_LESS;        break;
-            case SC_COND_GREATER:       mnFlags |= EXC_DV_COND_GREATER;     break;
-            case SC_COND_EQLESS:        mnFlags |= EXC_DV_COND_EQLESS;      break;
-            case SC_COND_EQGREATER:     mnFlags |= EXC_DV_COND_EQGREATER;   break;
-            case SC_COND_NOTEQUAL:      mnFlags |= EXC_DV_COND_NOTEQUAL;    break;
-            case SC_COND_BETWEEN:       mnFlags |= EXC_DV_COND_BETWEEN;     break;
-            case SC_COND_NOTBETWEEN:    mnFlags |= EXC_DV_COND_NOTBETWEEN;  break;
+            case ScConditionMode::NONE:
+            case ScConditionMode::Equal:         mnFlags |= EXC_DV_COND_EQUAL;       break;
+            case ScConditionMode::Less:          mnFlags |= EXC_DV_COND_LESS;        break;
+            case ScConditionMode::Greater:       mnFlags |= EXC_DV_COND_GREATER;     break;
+            case ScConditionMode::EqLess:        mnFlags |= EXC_DV_COND_EQLESS;      break;
+            case ScConditionMode::EqGreater:     mnFlags |= EXC_DV_COND_EQGREATER;   break;
+            case ScConditionMode::NotEqual:      mnFlags |= EXC_DV_COND_NOTEQUAL;    break;
+            case ScConditionMode::Between:       mnFlags |= EXC_DV_COND_BETWEEN;     break;
+            case ScConditionMode::NotBetween:    mnFlags |= EXC_DV_COND_NOTBETWEEN;  break;
             default:                    OSL_FAIL( "XclExpDV::XclExpDV - unknown condition" );
         }
         switch( eScErrorStyle )
diff --git a/sc/source/filter/excel/xicontent.cxx b/sc/source/filter/excel/xicontent.cxx
index bf7316026d15..4db48555220a 100644
--- a/sc/source/filter/excel/xicontent.cxx
+++ b/sc/source/filter/excel/xicontent.cxx
@@ -542,21 +542,21 @@ void XclImpCondFormat::ReadCF( XclImpStream& rStrm )
 
     // *** mode and comparison operator ***
 
-    ScConditionMode eMode = SC_COND_NONE;
+    ScConditionMode eMode = ScConditionMode::NONE;
     switch( nType )
     {
         case EXC_CF_TYPE_CELL:
         {
             switch( nOperator )
             {
-                case EXC_CF_CMP_BETWEEN:        eMode = SC_COND_BETWEEN;    break;
-                case EXC_CF_CMP_NOT_BETWEEN:    eMode = SC_COND_NOTBETWEEN; break;
-                case EXC_CF_CMP_EQUAL:          eMode = SC_COND_EQUAL;      break;
-                case EXC_CF_CMP_NOT_EQUAL:      eMode = SC_COND_NOTEQUAL;   break;
-                case EXC_CF_CMP_GREATER:        eMode = SC_COND_GREATER;    break;
-                case EXC_CF_CMP_LESS:           eMode = SC_COND_LESS;       break;
-                case EXC_CF_CMP_GREATER_EQUAL:  eMode = SC_COND_EQGREATER;  break;
-                case EXC_CF_CMP_LESS_EQUAL:     eMode = SC_COND_EQLESS;     break;
+                case EXC_CF_CMP_BETWEEN:        eMode = ScConditionMode::Between;    break;
+                case EXC_CF_CMP_NOT_BETWEEN:    eMode = ScConditionMode::NotBetween; break;
+                case EXC_CF_CMP_EQUAL:          eMode = ScConditionMode::Equal;      break;
+                case EXC_CF_CMP_NOT_EQUAL:      eMode = ScConditionMode::NotEqual;   break;
+                case EXC_CF_CMP_GREATER:        eMode = ScConditionMode::Greater;    break;
+                case EXC_CF_CMP_LESS:           eMode = ScConditionMode::Less;       break;
+                case EXC_CF_CMP_GREATER_EQUAL:  eMode = ScConditionMode::EqGreater;  break;
+                case EXC_CF_CMP_LESS_EQUAL:     eMode = ScConditionMode::EqLess;     break;
                 default:
                     SAL_INFO(
                         "sc.filter", "unknown CF comparison " << nOperator);
@@ -565,7 +565,7 @@ void XclImpCondFormat::ReadCF( XclImpStream& rStrm )
         break;
 
         case EXC_CF_TYPE_FMLA:
-            eMode = SC_COND_DIRECT;
+            eMode = ScConditionMode::Direct;
         break;
 
         default:
@@ -861,17 +861,17 @@ void XclImpValidationManager::ReadDV( XclImpStream& rStrm )
     }
     rRoot.GetTracer().TraceDVType(eValMode == SC_VALID_CUSTOM);
 
-    ScConditionMode eCondMode = SC_COND_BETWEEN;
+    ScConditionMode eCondMode = ScConditionMode::Between;
     switch( nFlags & EXC_DV_COND_MASK )
     {
-        case EXC_DV_COND_BETWEEN:   eCondMode = SC_COND_BETWEEN;    break;
-        case EXC_DV_COND_NOTBETWEEN:eCondMode = SC_COND_NOTBETWEEN; break;
-        case EXC_DV_COND_EQUAL:     eCondMode = SC_COND_EQUAL;      break;
-        case EXC_DV_COND_NOTEQUAL:  eCondMode = SC_COND_NOTEQUAL;   break;
-        case EXC_DV_COND_GREATER:   eCondMode = SC_COND_GREATER;    break;
-        case EXC_DV_COND_LESS:      eCondMode = SC_COND_LESS;       break;
-        case EXC_DV_COND_EQGREATER: eCondMode = SC_COND_EQGREATER;  break;
-        case EXC_DV_COND_EQLESS:    eCondMode = SC_COND_EQLESS;     break;
+        case EXC_DV_COND_BETWEEN:   eCondMode = ScConditionMode::Between;    break;
+        case EXC_DV_COND_NOTBETWEEN:eCondMode = ScConditionMode::NotBetween; break;
+        case EXC_DV_COND_EQUAL:     eCondMode = ScConditionMode::Equal;      break;
+        case EXC_DV_COND_NOTEQUAL:  eCondMode = ScConditionMode::NotEqual;   break;
+        case EXC_DV_COND_GREATER:   eCondMode = ScConditionMode::Greater;    break;
+        case EXC_DV_COND_LESS:      eCondMode = ScConditionMode::Less;       break;
+        case EXC_DV_COND_EQGREATER: eCondMode = ScConditionMode::EqGreater;  break;
+        case EXC_DV_COND_EQLESS:    eCondMode = ScConditionMode::EqLess;     break;
         default:                    bIsValid = false;
     }
 
diff --git a/sc/source/filter/inc/condformatbuffer.hxx b/sc/source/filter/inc/condformatbuffer.hxx
index 02845bc229f5..90212c8653fa 100644
--- a/sc/source/filter/inc/condformatbuffer.hxx
+++ b/sc/source/filter/inc/condformatbuffer.hxx
@@ -23,6 +23,7 @@
 #include "formulaparser.hxx"
 #include "worksheethelper.hxx"
 #include <tools/color.hxx>
+#include <conditio.hxx>
 #include <rangelst.hxx>
 
 #include <memory>
@@ -296,7 +297,7 @@ public:
 
     /** Converts an OOXML condition operator token to the API constant. */
     static sal_Int32    convertToApiOperator( sal_Int32 nToken );
-    static sal_Int32    convertToInternalOperator( sal_Int32 nToken );
+    static ScConditionMode convertToInternalOperator( sal_Int32 nToken );
     void                finalizeImport();
 private:
     CondFormatRef       createCondFormat();
diff --git a/sc/source/filter/oox/condformatbuffer.cxx b/sc/source/filter/oox/condformatbuffer.cxx
index 170387a0c9da..515e0422accc 100644
--- a/sc/source/filter/oox/condformatbuffer.cxx
+++ b/sc/source/filter/oox/condformatbuffer.cxx
@@ -714,7 +714,7 @@ void CondFormatRule::importCfRule( SequenceInputStream& rStrm )
 
 void CondFormatRule::finalizeImport()
 {
-    ScConditionMode eOperator = SC_COND_NONE;
+    ScConditionMode eOperator = ScConditionMode::NONE;
 
     /*  Replacement formula for unsupported rule types (text comparison rules,
         time period rules, cell type rules). The replacement formulas below may
@@ -738,33 +738,33 @@ void CondFormatRule::finalizeImport()
     switch( maModel.mnType )
     {
         case XML_cellIs:
-            eOperator = static_cast<ScConditionMode>(CondFormatBuffer::convertToInternalOperator( maModel.mnOperator ));
+            eOperator = CondFormatBuffer::convertToInternalOperator( maModel.mnOperator );
         break;
         case XML_duplicateValues:
-            eOperator = SC_COND_DUPLICATE;
+            eOperator = ScConditionMode::Duplicate;
         break;
         case XML_uniqueValues:
-            eOperator = SC_COND_NOTDUPLICATE;
+            eOperator = ScConditionMode::NotDuplicate;
         break;
         case XML_expression:
-            eOperator = SC_COND_DIRECT;
+            eOperator = ScConditionMode::Direct;
         break;
         case XML_containsText:
             OSL_ENSURE( maModel.mnOperator == XML_containsText, "CondFormatRule::finalizeImport - unexpected operator" );
-            eOperator = SC_COND_CONTAINS_TEXT;
+            eOperator = ScConditionMode::ContainsText;
         break;
         case XML_notContainsText:
             // note: type XML_notContainsText vs. operator XML_notContains
             OSL_ENSURE( maModel.mnOperator == XML_notContains, "CondFormatRule::finalizeImport - unexpected operator" );
-            eOperator = SC_COND_NOT_CONTAINS_TEXT;
+            eOperator = ScConditionMode::NotContainsText;
         break;
         case XML_beginsWith:
             OSL_ENSURE( maModel.mnOperator == XML_beginsWith, "CondFormatRule::finalizeImport - unexpected operator" );
-            eOperator = SC_COND_BEGINS_WITH;
+            eOperator = ScConditionMode::BeginsWith;
         break;
         case XML_endsWith:
             OSL_ENSURE( maModel.mnOperator == XML_endsWith, "CondFormatRule::finalizeImport - unexpected operator" );
-            eOperator = SC_COND_ENDS_WITH;
+            eOperator = ScConditionMode::EndsWith;
         break;
         case XML_timePeriod:
         break;
@@ -775,41 +775,41 @@ void CondFormatRule::finalizeImport()
             aReplaceFormula = "LEN(TRIM(#B))>0";
         break;
         case XML_containsErrors:
-            eOperator = SC_COND_ERROR;
+            eOperator = ScConditionMode::Error;
         break;
         case XML_notContainsErrors:
-            eOperator = SC_COND_NOERROR;
+            eOperator = ScConditionMode::NoError;
         break;
         case XML_top10:
             if(maModel.mbPercent)
             {
                 if(maModel.mbBottom)
-                    eOperator = SC_COND_BOTTOM_PERCENT;
+                    eOperator = ScConditionMode::BottomPercent;
                 else
-                    eOperator = SC_COND_TOP_PERCENT;
+                    eOperator = ScConditionMode::TopPercent;
             }
             else
             {
                 if(maModel.mbBottom)
-                    eOperator = SC_COND_BOTTOM10;
+                    eOperator = ScConditionMode::Bottom10;
                 else
-                    eOperator = SC_COND_TOP10;
+                    eOperator = ScConditionMode::Top10;
             }
         break;
         case XML_aboveAverage:
             if(maModel.mbAboveAverage)
             {
                 if(maModel.mbEqualAverage)
-                    eOperator = SC_COND_ABOVE_EQUAL_AVERAGE;
+                    eOperator = ScConditionMode::AboveEqualAverage;
                 else
-                    eOperator = SC_COND_ABOVE_AVERAGE;
+                    eOperator = ScConditionMode::AboveAverage;
             }
             else
             {
                 if(maModel.mbEqualAverage)
-                    eOperator = SC_COND_BELOW_EQUAL_AVERAGE;
+                    eOperator = ScConditionMode::BelowEqualAverage;
                 else
-                    eOperator = SC_COND_BELOW_AVERAGE;
+                    eOperator = ScConditionMode::BelowAverage;
             }
         break;
         case XML_colorScale:
@@ -837,20 +837,20 @@ void CondFormatRule::finalizeImport()
         // set the replacement formula
         maModel.maFormulas.clear();
         appendFormula( aReplaceFormula );
-        eOperator = SC_COND_DIRECT;
+        eOperator = ScConditionMode::Direct;
     }
 
     ScAddress aPos = mrCondFormat.getRanges().GetTopLeftCorner();
 
-    if( eOperator == SC_COND_ERROR || eOperator == SC_COND_NOERROR )
+    if( eOperator == ScConditionMode::Error || eOperator == ScConditionMode::NoError )
     {
         ScDocument& rDoc = getScDocument();
         OUString aStyleName = getStyles().createDxfStyle( maModel.mnDxfId );
         ScCondFormatEntry* pNewEntry = new ScCondFormatEntry( eOperator, nullptr, nullptr, &rDoc, aPos, aStyleName );
         mpFormat->AddEntry(pNewEntry);
     }
-    else if( eOperator == SC_COND_BEGINS_WITH || eOperator == SC_COND_ENDS_WITH ||
-            eOperator == SC_COND_CONTAINS_TEXT || eOperator == SC_COND_NOT_CONTAINS_TEXT )
+    else if( eOperator == ScConditionMode::BeginsWith || eOperator == ScConditionMode::EndsWith ||
+            eOperator == ScConditionMode::ContainsText || eOperator == ScConditionMode::NotContainsText )
     {
         ScDocument& rDoc = getScDocument();
         ScTokenArray aTokenArray;
@@ -860,7 +860,7 @@ void CondFormatRule::finalizeImport()
         ScCondFormatEntry* pNewEntry = new ScCondFormatEntry( eOperator, &aTokenArray, nullptr, &rDoc, aPos, aStyleName );
         mpFormat->AddEntry(pNewEntry);
     }
-    else if( (eOperator != SC_COND_NONE) && !maModel.maFormulas.empty() )
+    else if( (eOperator != ScConditionMode::NONE) && !maModel.maFormulas.empty() )
     {
         ScDocument& rDoc = getScDocument();
         std::unique_ptr<ScTokenArray> pTokenArray2;
@@ -877,8 +877,8 @@ void CondFormatRule::finalizeImport()
                                             &aTokenArray, pTokenArray2.get(), &rDoc, aPos, aStyleName);
         mpFormat->AddEntry(pNewEntry);
     }
-    else if ( eOperator == SC_COND_TOP10 || eOperator == SC_COND_BOTTOM10 ||
-            eOperator == SC_COND_TOP_PERCENT || eOperator == SC_COND_BOTTOM_PERCENT )
+    else if ( eOperator == ScConditionMode::Top10 || eOperator == ScConditionMode::Bottom10 ||
+            eOperator == ScConditionMode::TopPercent || eOperator == ScConditionMode::BottomPercent )
     {
         ScDocument& rDoc = getScDocument();
         ScTokenArray aTokenArray;
@@ -887,8 +887,8 @@ void CondFormatRule::finalizeImport()
         ScCondFormatEntry* pNewEntry = new ScCondFormatEntry( eOperator, &aTokenArray, nullptr, &rDoc, aPos, aStyleName );
         mpFormat->AddEntry(pNewEntry);
     }
-    else if( eOperator == SC_COND_ABOVE_AVERAGE || eOperator == SC_COND_BELOW_AVERAGE ||
-            eOperator == SC_COND_ABOVE_EQUAL_AVERAGE || eOperator == SC_COND_BELOW_EQUAL_AVERAGE )
+    else if( eOperator == ScConditionMode::AboveAverage || eOperator == ScConditionMode::BelowAverage ||
+            eOperator == ScConditionMode::AboveEqualAverage || eOperator == ScConditionMode::BelowEqualAverage )
     {
         ScDocument& rDoc = getScDocument();
         // actually that is still unsupported
@@ -898,7 +898,7 @@ void CondFormatRule::finalizeImport()
         ScCondFormatEntry* pNewEntry = new ScCondFormatEntry( eOperator, &aTokenArrayDev, nullptr, &rDoc, aPos, aStyleName );
         mpFormat->AddEntry(pNewEntry);
     }
-    else if( eOperator == SC_COND_DUPLICATE || eOperator == SC_COND_NOTDUPLICATE )
+    else if( eOperator == ScConditionMode::Duplicate || eOperator == ScConditionMode::NotDuplicate )
     {
         ScDocument& rDoc = getScDocument();
         OUString aStyleName = getStyles().createDxfStyle( maModel.mnDxfId );
@@ -1182,22 +1182,22 @@ sal_Int32 CondFormatBuffer::convertToApiOperator( sal_Int32 nToken )
     return ConditionOperator2::NONE;
 }
 
-sal_Int32 CondFormatBuffer::convertToInternalOperator( sal_Int32 nToken )
+ScConditionMode CondFormatBuffer::convertToInternalOperator( sal_Int32 nToken )
 {
     switch( nToken )
     {
-        case XML_between:               return SC_COND_BETWEEN;
-        case XML_equal:                 return SC_COND_EQUAL;
-        case XML_greaterThan:           return SC_COND_GREATER;
-        case XML_greaterThanOrEqual:    return SC_COND_EQGREATER;
-        case XML_lessThan:              return SC_COND_LESS;
-        case XML_lessThanOrEqual:       return SC_COND_EQLESS;
-        case XML_notBetween:            return SC_COND_NOTBETWEEN;
-        case XML_notEqual:              return SC_COND_NOTEQUAL;
-        case XML_duplicateValues:       return SC_COND_DUPLICATE;
-        case XML_uniqueValues:          return SC_COND_NOTDUPLICATE;
+        case XML_between:               return ScConditionMode::Between;
+        case XML_equal:                 return ScConditionMode::Equal;
+        case XML_greaterThan:           return ScConditionMode::Greater;
+        case XML_greaterThanOrEqual:    return ScConditionMode::EqGreater;
+        case XML_lessThan:              return ScConditionMode::Less;
+        case XML_lessThanOrEqual:       return ScConditionMode::EqLess;
+        case XML_notBetween:            return ScConditionMode::NotBetween;
+        case XML_notEqual:              return ScConditionMode::NotEqual;
+        case XML_duplicateValues:       return ScConditionMode::Duplicate;
+        case XML_uniqueValues:          return ScConditionMode::NotDuplicate;
     }
-    return ConditionOperator2::NONE;
+    return ScConditionMode::NONE;
 }
 
 // private --------------------------------------------------------------------
diff --git a/sc/source/filter/xml/xmlcondformat.cxx b/sc/source/filter/xml/xmlcondformat.cxx
index 564025d781ce..48af2921775a 100644
--- a/sc/source/filter/xml/xmlcondformat.cxx
+++ b/sc/source/filter/xml/xmlcondformat.cxx
@@ -400,11 +400,11 @@ void GetConditionData(const OUString& rValue, ScConditionMode& eMode, OUString&
 {
     if(rValue.startsWith("unique"))
     {
-        eMode = SC_COND_NOTDUPLICATE;
+        eMode = ScConditionMode::NotDuplicate;
     }
     else if(rValue.startsWith("duplicate"))
     {
-        eMode = SC_COND_DUPLICATE;
+        eMode = ScConditionMode::Duplicate;
     }
     else if(rValue.startsWith("between"))
     {
@@ -413,7 +413,7 @@ void GetConditionData(const OUString& rValue, ScConditionMode& eMode, OUString&
         const sal_Unicode* pEnd = pStr + rValue.getLength();
         rExpr1 = ScXMLConditionHelper::getExpression( pStart, pEnd, ',');
         rExpr2 = ScXMLConditionHelper::getExpression( pStart, pEnd, ')');
-        eMode = SC_COND_BETWEEN;
+        eMode = ScConditionMode::Between;
     }
     else if(rValue.startsWith("not-between"))
     {
@@ -422,37 +422,37 @@ void GetConditionData(const OUString& rValue, ScConditionMode& eMode, OUString&
         const sal_Unicode* pEnd = pStr + rValue.getLength();
         rExpr1 = ScXMLConditionHelper::getExpression( pStart, pEnd, ',');
         rExpr2 = ScXMLConditionHelper::getExpression( pStart, pEnd, ')');
-        eMode = SC_COND_NOTBETWEEN;
+        eMode = ScConditionMode::NotBetween;
     }
     else if(rValue.startsWith("<="))
     {
         rExpr1 = rValue.copy(2);
-        eMode = SC_COND_EQLESS;
+        eMode = ScConditionMode::EqLess;
     }
     else if(rValue.startsWith(">="))
     {
         rExpr1 = rValue.copy(2);
-        eMode = SC_COND_EQGREATER;
+        eMode = ScConditionMode::EqGreater;
     }
     else if(rValue.startsWith("!="))
     {
         rExpr1 = rValue.copy(2);
-        eMode = SC_COND_NOTEQUAL;
+        eMode = ScConditionMode::NotEqual;
     }
     else if(rValue.startsWith("<"))
     {
         rExpr1 = rValue.copy(1);
-        eMode = SC_COND_LESS;
+        eMode = ScConditionMode::Less;
     }
     else if(rValue.startsWith("="))
     {
         rExpr1 = rValue.copy(1);
-        eMode = SC_COND_EQUAL;
+        eMode = ScConditionMode::Equal;
     }
     else if(rValue.startsWith(">"))
     {
         rExpr1 = rValue.copy(1);
-        eMode = SC_COND_GREATER;
+        eMode = ScConditionMode::Greater;
     }
     else if(rValue.startsWith("formula-is"))
     {
@@ -460,7 +460,7 @@ void GetConditionData(const OUString& rValue, ScConditionMode& eMode, OUString&
         const sal_Unicode* pStart = pStr + 11;
         const sal_Unicode* pEnd = pStr + rValue.getLength();
         rExpr1 = ScXMLConditionHelper::getExpression( pStart, pEnd, ')');
-        eMode = SC_COND_DIRECT;
+        eMode = ScConditionMode::Direct;
     }
     else if(rValue.startsWith("top-elements"))
     {
@@ -468,7 +468,7 @@ void GetConditionData(const OUString& rValue, ScConditionMode& eMode, OUString&
         const sal_Unicode* pStart = pStr + 13;
         const sal_Unicode* pEnd = pStr + rValue.getLength();
         rExpr1 = ScXMLConditionHelper::getExpression( pStart, pEnd, ')');
-        eMode = SC_COND_TOP10;
+        eMode = ScConditionMode::Top10;
     }
     else if(rValue.startsWith("bottom-elements"))
     {
@@ -476,7 +476,7 @@ void GetConditionData(const OUString& rValue, ScConditionMode& eMode, OUString&
         const sal_Unicode* pStart = pStr + 16;
         const sal_Unicode* pEnd = pStr + rValue.getLength();
         rExpr1 = ScXMLConditionHelper::getExpression( pStart, pEnd, ')');
-        eMode = SC_COND_BOTTOM10;
+        eMode = ScConditionMode::Bottom10;
     }
     else if(rValue.startsWith("top-percent"))
     {
@@ -484,7 +484,7 @@ void GetConditionData(const OUString& rValue, ScConditionMode& eMode, OUString&
         const sal_Unicode* pStart = pStr + 12;
         const sal_Unicode* pEnd = pStr + rValue.getLength();
         rExpr1 = ScXMLConditionHelper::getExpression( pStart, pEnd, ')');
-        eMode = SC_COND_TOP_PERCENT;
+        eMode = ScConditionMode::TopPercent;
     }
     else if(rValue.startsWith("bottom-percent"))
     {
@@ -492,35 +492,35 @@ void GetConditionData(const OUString& rValue, ScConditionMode& eMode, OUString&
         const sal_Unicode* pStart = pStr + 15;
         const sal_Unicode* pEnd = pStr + rValue.getLength();
         rExpr1 = ScXMLConditionHelper::getExpression( pStart, pEnd, ')');
-        eMode = SC_COND_BOTTOM_PERCENT;
+        eMode = ScConditionMode::BottomPercent;
     }
     else if(rValue.startsWith("above-average"))
     {
-        eMode = SC_COND_ABOVE_AVERAGE;
+        eMode = ScConditionMode::AboveAverage;
     }
     else if(rValue.startsWith("below-average"))
     {
-        eMode = SC_COND_BELOW_AVERAGE;
+        eMode = ScConditionMode::BelowAverage;
     }
     else if(rValue.startsWith("above-equal-average"))
     {
-        eMode = SC_COND_ABOVE_EQUAL_AVERAGE;
+        eMode = ScConditionMode::AboveEqualAverage;
     }
     else if(rValue.startsWith("below-equal-average"))
     {
-        eMode = SC_COND_BELOW_EQUAL_AVERAGE;
+        eMode = ScConditionMode::BelowEqualAverage;
     }
     else if(rValue.startsWith("is-error"))
     {
-        eMode = SC_COND_ERROR;
+        eMode = ScConditionMode::Error;
     }
     else if(rValue.startsWith("is-no-error"))
     {
-        eMode = SC_COND_NOERROR;
+        eMode = ScConditionMode::NoError;
     }
     else if(rValue.startsWith("begins-with"))
     {
-        eMode = SC_COND_BEGINS_WITH;
+        eMode = ScConditionMode::BeginsWith;
         const sal_Unicode* pStr = rValue.getStr();
         const sal_Unicode* pStart = pStr + 12;
         const sal_Unicode* pEnd = pStr + rValue.getLength();
@@ -528,7 +528,7 @@ void GetConditionData(const OUString& rValue, ScConditionMode& eMode, OUString&
     }
     else if(rValue.startsWith("ends-with"))
     {
-        eMode = SC_COND_ENDS_WITH;
+        eMode = ScConditionMode::EndsWith;
         const sal_Unicode* pStr = rValue.getStr();
         const sal_Unicode* pStart = pStr + 10;
         const sal_Unicode* pEnd = pStr + rValue.getLength();
@@ -536,7 +536,7 @@ void GetConditionData(const OUString& rValue, ScConditionMode& eMode, OUString&
     }
     else if(rValue.startsWith("contains-text"))
     {
-        eMode = SC_COND_CONTAINS_TEXT;
+        eMode = ScConditionMode::ContainsText;
         const sal_Unicode* pStr = rValue.getStr();
         const sal_Unicode* pStart = pStr + 14;
         const sal_Unicode* pEnd = pStr + rValue.getLength();
@@ -544,14 +544,14 @@ void GetConditionData(const OUString& rValue, ScConditionMode& eMode, OUString&
     }
     else if(rValue.startsWith("not-contains-text"))
     {
-        eMode = SC_COND_NOT_CONTAINS_TEXT;
+        eMode = ScConditionMode::NotContainsText;
         const sal_Unicode* pStr = rValue.getStr();
         const sal_Unicode* pStart = pStr + 18;
         const sal_Unicode* pEnd = pStr + rValue.getLength();
         rExpr1 = ScXMLConditionHelper::getExpression( pStart, pEnd, ')');
     }
     else
-        eMode = SC_COND_NONE;
+        eMode = ScConditionMode::NONE;
 }
 
 }
diff --git a/sc/source/filter/xml/xmlexprt.cxx b/sc/source/filter/xml/xmlexprt.cxx
index 3a9e60a99691..5db0920c020d 100644
--- a/sc/source/filter/xml/xmlexprt.cxx
+++ b/sc/source/filter/xml/xmlexprt.cxx
@@ -4262,114 +4262,114 @@ void ScXMLExport::ExportConditionalFormat(SCTAB nTab)
                         ScAddress aPos = pEntry->GetSrcPos();
                         switch(pEntry->GetOperation())
                         {
-                            case SC_COND_EQUAL:
+                            case ScConditionMode::Equal:
                                 aCond.append('=');
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 break;
-                            case SC_COND_LESS:
+                            case ScConditionMode::Less:
                                 aCond.append('<');
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 break;
-                            case SC_COND_GREATER:
+                            case ScConditionMode::Greater:
                                 aCond.append('>');
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 break;
-                            case SC_COND_EQLESS:
+                            case ScConditionMode::EqLess:
                                 aCond.append("<=");
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 break;
-                            case SC_COND_EQGREATER:
+                            case ScConditionMode::EqGreater:
                                 aCond.append(">=");
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 break;
-                            case SC_COND_NOTEQUAL:
+                            case ScConditionMode::NotEqual:
                                 aCond.append("!=");
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 break;
-                            case SC_COND_BETWEEN:
+                            case ScConditionMode::Between:
                                 aCond.append("between(");
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 aCond.append(',');
                                 aCond.append(pEntry->GetExpression(aPos, 1, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 aCond.append(')');
                                 break;
-                            case SC_COND_NOTBETWEEN:
+                            case ScConditionMode::NotBetween:
                                 aCond.append("not-between(");
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 aCond.append(',');
                                 aCond.append(pEntry->GetExpression(aPos, 1, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 aCond.append(')');
                                 break;
-                            case SC_COND_DUPLICATE:
+                            case ScConditionMode::Duplicate:
                                 aCond.append("duplicate");
                                 break;
-                            case SC_COND_NOTDUPLICATE:
+                            case ScConditionMode::NotDuplicate:
                                 aCond.append("unique");
                                 break;
-                            case SC_COND_DIRECT:
+                            case ScConditionMode::Direct:
                                 aCond.append("formula-is(");
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 aCond.append(')');
                                 break;
-                            case SC_COND_TOP10:
+                            case ScConditionMode::Top10:
                                 aCond.append("top-elements(");
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 aCond.append(")");
                                 break;
-                            case SC_COND_BOTTOM10:
+                            case ScConditionMode::Bottom10:
                                 aCond.append("bottom-elements(");
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 aCond.append(")");
                                 break;
-                            case SC_COND_TOP_PERCENT:
+                            case ScConditionMode::TopPercent:
                                 aCond.append("top-percent(");
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 aCond.append(")");
                                 break;
-                            case SC_COND_BOTTOM_PERCENT:
+                            case ScConditionMode::BottomPercent:
                                 aCond.append("bottom-percent(");
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 aCond.append(")");
                                 break;
-                            case SC_COND_ABOVE_AVERAGE:
+                            case ScConditionMode::AboveAverage:
                                 aCond.append("above-average");
                                 break;
-                            case SC_COND_BELOW_AVERAGE:
+                            case ScConditionMode::BelowAverage:
                                 aCond.append("below-average");
                                 break;
-                            case SC_COND_ABOVE_EQUAL_AVERAGE:
+                            case ScConditionMode::AboveEqualAverage:
                                 aCond.append("above-equal-average");
                                 break;
-                            case SC_COND_BELOW_EQUAL_AVERAGE:
+                            case ScConditionMode::BelowEqualAverage:
                                 aCond.append("below-equal-average");
                                 break;
-                            case SC_COND_ERROR:
+                            case ScConditionMode::Error:
                                 aCond.append("is-error");
                                 break;
-                            case SC_COND_NOERROR:
+                            case ScConditionMode::NoError:
                                 aCond.append("is-no-error");
                                 break;
-                            case SC_COND_BEGINS_WITH:
+                            case ScConditionMode::BeginsWith:
                                 aCond.append("begins-with(");
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 aCond.append(")");
                                 break;
-                            case SC_COND_ENDS_WITH:
+                            case ScConditionMode::EndsWith:
                                 aCond.append("ends-with(");
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 aCond.append(")");
                                 break;
-                            case SC_COND_CONTAINS_TEXT:
+                            case ScConditionMode::ContainsText:
                                 aCond.append("contains-text(");
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 aCond.append(")");
                                 break;
-                            case SC_COND_NOT_CONTAINS_TEXT:
+                            case ScConditionMode::NotContainsText:
                                 aCond.append("not-contains-text(");
                                 aCond.append(pEntry->GetExpression(aPos, 0, 0, formula::FormulaGrammar::GRAM_ODFF));
                                 aCond.append(")");
                                 break;
-                            case SC_COND_NONE:
+                            case ScConditionMode::NONE:
                                 continue;
                             default:
                                 SAL_WARN("sc", "unimplemented conditional format export");
diff --git a/sc/source/ui/condformat/condformatdlg.cxx b/sc/source/ui/condformat/condformatdlg.cxx
index a052c30687f9..b7b0c40a73d8 100644
--- a/sc/source/ui/condformat/condformatdlg.cxx
+++ b/sc/source/ui/condformat/condformatdlg.cxx
@@ -88,7 +88,7 @@ void ScCondFormatList::init(ScDocument* pDoc, ScCondFormatDlg* pDialogParent,
                 case condformat::CONDITION:
                     {
                         const ScCondFormatEntry* pConditionEntry = static_cast<const ScCondFormatEntry*>( pEntry );
-                        if(pConditionEntry->GetOperation() != SC_COND_DIRECT)
+                        if(pConditionEntry->GetOperation() != ScConditionMode::Direct)
                             maEntries.push_back(VclPtr<ScConditionFrmtEntry>::Create( this, mpDoc, pDialogParent, maPos, pConditionEntry ) );
                         else
                             maEntries.push_back(VclPtr<ScFormulaFrmtEntry>::Create( this, mpDoc, pDialogParent, maPos, pConditionEntry ) );
diff --git a/sc/source/ui/condformat/condformatdlgentry.cxx b/sc/source/ui/condformat/condformatdlgentry.cxx
index 968576a8d2ba..b68e99c1d171 100644
--- a/sc/source/ui/condformat/condformatdlgentry.cxx
+++ b/sc/source/ui/condformat/condformatdlgentry.cxx
@@ -163,30 +163,30 @@ void FillStyleListBox( const ScDocument* pDoc, ListBox& rLbStyle )
 }
 
 const ScConditionMode ScConditionFrmtEntry::mpEntryToCond[ScConditionFrmtEntry::NUM_COND_ENTRIES] = {
-    SC_COND_EQUAL,
-    SC_COND_LESS,
-    SC_COND_GREATER,
-    SC_COND_EQLESS,
-    SC_COND_EQGREATER,
-    SC_COND_NOTEQUAL,
-    SC_COND_BETWEEN,
-    SC_COND_NOTBETWEEN,
-    SC_COND_DUPLICATE,
-    SC_COND_NOTDUPLICATE,
-    SC_COND_TOP10,
-    SC_COND_BOTTOM10,
-    SC_COND_TOP_PERCENT,
-    SC_COND_BOTTOM_PERCENT,
-    SC_COND_ABOVE_AVERAGE,
-    SC_COND_BELOW_AVERAGE,
-    SC_COND_ABOVE_EQUAL_AVERAGE,
-    SC_COND_BELOW_EQUAL_AVERAGE,
-    SC_COND_ERROR,
-    SC_COND_NOERROR,
-    SC_COND_BEGINS_WITH,
-    SC_COND_ENDS_WITH,
-    SC_COND_CONTAINS_TEXT,
-    SC_COND_NOT_CONTAINS_TEXT
+    ScConditionMode::Equal,
+    ScConditionMode::Less,
+    ScConditionMode::Greater,
+    ScConditionMode::EqLess,
+    ScConditionMode::EqGreater,
+    ScConditionMode::NotEqual,
+    ScConditionMode::Between,
+    ScConditionMode::NotBetween,
+    ScConditionMode::Duplicate,
+    ScConditionMode::NotDuplicate,
+    ScConditionMode::Top10,
+    ScConditionMode::Bottom10,
+    ScConditionMode::TopPercent,
+    ScConditionMode::BottomPercent,
+    ScConditionMode::AboveAverage,
+    ScConditionMode::BelowAverage,
+    ScConditionMode::AboveEqualAverage,
+    ScConditionMode::BelowEqualAverage,
+    ScConditionMode::Error,
+    ScConditionMode::NoError,
+    ScConditionMode::BeginsWith,
+    ScConditionMode::EndsWith,
+    ScConditionMode::ContainsText,
+    ScConditionMode::NotContainsText
 };
 
 ScConditionFrmtEntry::ScConditionFrmtEntry(vcl::Window* pParent, ScDocument* pDoc, ScCondFormatDlg* pDialogParent,
@@ -373,32 +373,32 @@ sal_Int32 ScConditionFrmtEntry::GetNumberEditFields( ScConditionMode eMode )
 {
     switch(eMode)
     {
-        case SC_COND_EQUAL:
-        case SC_COND_LESS:
-        case SC_COND_GREATER:
-        case SC_COND_EQLESS:
-        case SC_COND_EQGREATER:
-        case SC_COND_NOTEQUAL:
-        case SC_COND_TOP10:
-        case SC_COND_BOTTOM10:
-        case SC_COND_TOP_PERCENT:
-        case SC_COND_BOTTOM_PERCENT:
-        case SC_COND_BEGINS_WITH:
-        case SC_COND_ENDS_WITH:
-        case SC_COND_CONTAINS_TEXT:
-        case SC_COND_NOT_CONTAINS_TEXT:
-        case SC_COND_ERROR:
-        case SC_COND_NOERROR:
+        case ScConditionMode::Equal:
+        case ScConditionMode::Less:
+        case ScConditionMode::Greater:
+        case ScConditionMode::EqLess:
+        case ScConditionMode::EqGreater:
+        case ScConditionMode::NotEqual:
+        case ScConditionMode::Top10:
+        case ScConditionMode::Bottom10:
+        case ScConditionMode::TopPercent:
+        case ScConditionMode::BottomPercent:
+        case ScConditionMode::BeginsWith:
+        case ScConditionMode::EndsWith:
+        case ScConditionMode::ContainsText:
+        case ScConditionMode::NotContainsText:
+        case ScConditionMode::Error:
+        case ScConditionMode::NoError:
             return 1;
-        case SC_COND_ABOVE_AVERAGE:
-        case SC_COND_BELOW_AVERAGE:
-        case SC_COND_ABOVE_EQUAL_AVERAGE:
-        case SC_COND_BELOW_EQUAL_AVERAGE:
-        case SC_COND_DUPLICATE:
-        case SC_COND_NOTDUPLICATE:
+        case ScConditionMode::AboveAverage:
+        case ScConditionMode::BelowAverage:
+        case ScConditionMode::AboveEqualAverage:
+        case ScConditionMode::BelowEqualAverage:
+        case ScConditionMode::Duplicate:
+        case ScConditionMode::NotDuplicate:
             return 0;
-        case SC_COND_BETWEEN:
-        case SC_COND_NOTBETWEEN:
+        case ScConditionMode::Between:
+        case ScConditionMode::NotBetween:
             return 2;
         default:
             assert(false); // should never get here
@@ -607,7 +607,7 @@ ScFormatEntry* ScFormulaFrmtEntry::createFormulaEntry() const
     if(aFormula.isEmpty())
         return nullptr;
 
-    ScFormatEntry* pEntry = new ScCondFormatEntry(SC_COND_DIRECT, aFormula, OUString(), mpDoc, maPos, maLbStyle->GetSelectedEntry());
+    ScFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct, aFormula, OUString(), mpDoc, maPos, maLbStyle->GetSelectedEntry());
     return pEntry;
 }
 
diff --git a/sc/source/ui/condformat/condformathelper.cxx b/sc/source/ui/condformat/condformathelper.cxx
index 63980128b24d..254be980b726 100644
--- a/sc/source/ui/condformat/condformathelper.cxx
+++ b/sc/source/ui/condformat/condformathelper.cxx
@@ -134,7 +134,7 @@ OUString ScCondFormatHelper::GetExpression(const ScConditionalFormat& rFormat, c
                 {
                     const ScConditionEntry* pEntry = static_cast<const ScConditionEntry*>(rFormat.GetEntry(0));
                     ScConditionMode eMode = pEntry->GetOperation();
-                    if(eMode == SC_COND_DIRECT)
+                    if(eMode == ScConditionMode::Direct)
                     {
                         aBuffer.append(getTextForType(FORMULA));
                         aBuffer.append(" ");
@@ -146,7 +146,7 @@ OUString ScCondFormatHelper::GetExpression(const ScConditionalFormat& rFormat, c
                         aBuffer.append(" ");
                         aBuffer.append(getExpression(static_cast<sal_Int32>(eMode)));
                         aBuffer.append(" ");
-                        if(eMode == SC_COND_BETWEEN || eMode == SC_COND_NOTBETWEEN)
+                        if(eMode == ScConditionMode::Between || eMode == ScConditionMode::NotBetween)
                         {
                             aBuffer.append(pEntry->GetExpression(rPos, 0));
                             aBuffer.append(" ");
@@ -154,7 +154,7 @@ OUString ScCondFormatHelper::GetExpression(const ScConditionalFormat& rFormat, c
                             aBuffer.append(" ");
                             aBuffer.append(pEntry->GetExpression(rPos, 1));
                         }
-                        else if(eMode <= SC_COND_NOTEQUAL || eMode >= SC_COND_BEGINS_WITH)
+                        else if(eMode <= ScConditionMode::NotEqual || eMode >= ScConditionMode::BeginsWith)
                         {
                             aBuffer.append(pEntry->GetExpression(rPos, 0));
                         }
diff --git a/sc/source/ui/dbgui/validate.cxx b/sc/source/ui/dbgui/validate.cxx
index d98e11e3eb6d..0f5363a62e04 100644
--- a/sc/source/ui/dbgui/validate.cxx
+++ b/sc/source/ui/dbgui/validate.cxx
@@ -231,15 +231,15 @@ sal_uInt16 lclGetPosFromCondMode( ScConditionMode eCondMode )
     sal_uInt16 nLbPos = SC_VALIDDLG_DATA_EQUAL;
     switch( eCondMode )
     {
-        case SC_COND_NONE:          // may occur in old XML files after Excel import
-        case SC_COND_EQUAL:         nLbPos = SC_VALIDDLG_DATA_EQUAL;        break;
-        case SC_COND_LESS:          nLbPos = SC_VALIDDLG_DATA_LESS;         break;
-        case SC_COND_GREATER:       nLbPos = SC_VALIDDLG_DATA_GREATER;      break;
-        case SC_COND_EQLESS:        nLbPos = SC_VALIDDLG_DATA_EQLESS;       break;
-        case SC_COND_EQGREATER:     nLbPos = SC_VALIDDLG_DATA_EQGREATER;    break;
-        case SC_COND_NOTEQUAL:      nLbPos = SC_VALIDDLG_DATA_NOTEQUAL;     break;
-        case SC_COND_BETWEEN:       nLbPos = SC_VALIDDLG_DATA_VALIDRANGE;      break;
-        case SC_COND_NOTBETWEEN:    nLbPos = SC_VALIDDLG_DATA_INVALIDRANGE;   break;
+        case ScConditionMode::NONE:          // may occur in old XML files after Excel import
+        case ScConditionMode::Equal:         nLbPos = SC_VALIDDLG_DATA_EQUAL;        break;
+        case ScConditionMode::Less:          nLbPos = SC_VALIDDLG_DATA_LESS;         break;
+        case ScConditionMode::Greater:       nLbPos = SC_VALIDDLG_DATA_GREATER;      break;
+        case ScConditionMode::EqLess:        nLbPos = SC_VALIDDLG_DATA_EQLESS;       break;
+        case ScConditionMode::EqGreater:     nLbPos = SC_VALIDDLG_DATA_EQGREATER;    break;
+        case ScConditionMode::NotEqual:      nLbPos = SC_VALIDDLG_DATA_NOTEQUAL;     break;
+        case ScConditionMode::Between:       nLbPos = SC_VALIDDLG_DATA_VALIDRANGE;      break;
+        case ScConditionMode::NotBetween:    nLbPos = SC_VALIDDLG_DATA_INVALIDRANGE;   break;
         default:    OSL_FAIL( "lclGetPosFromCondMode - unknown condition mode" );
     }
     return nLbPos;
@@ -248,17 +248,17 @@ sal_uInt16 lclGetPosFromCondMode( ScConditionMode eCondMode )
 /** Converts the passed list box position to an ScConditionMode. */
 ScConditionMode lclGetCondModeFromPos( sal_uInt16 nLbPos )
 {
-    ScConditionMode eCondMode = SC_COND_EQUAL;
+    ScConditionMode eCondMode = ScConditionMode::Equal;
     switch( nLbPos )
     {
-        case SC_VALIDDLG_DATA_EQUAL:        eCondMode = SC_COND_EQUAL;      break;
-        case SC_VALIDDLG_DATA_LESS:         eCondMode = SC_COND_LESS;       break;
-        case SC_VALIDDLG_DATA_GREATER:      eCondMode = SC_COND_GREATER;    break;
-        case SC_VALIDDLG_DATA_EQLESS:       eCondMode = SC_COND_EQLESS;     break;
-        case SC_VALIDDLG_DATA_EQGREATER:    eCondMode = SC_COND_EQGREATER;  break;
-        case SC_VALIDDLG_DATA_NOTEQUAL:     eCondMode = SC_COND_NOTEQUAL;   break;
-        case SC_VALIDDLG_DATA_VALIDRANGE:      eCondMode = SC_COND_BETWEEN;    break;
-        case SC_VALIDDLG_DATA_INVALIDRANGE:   eCondMode = SC_COND_NOTBETWEEN; break;
+        case SC_VALIDDLG_DATA_EQUAL:        eCondMode = ScConditionMode::Equal;      break;
+        case SC_VALIDDLG_DATA_LESS:         eCondMode = ScConditionMode::Less;       break;
+        case SC_VALIDDLG_DATA_GREATER:      eCondMode = ScConditionMode::Greater;    break;
+        case SC_VALIDDLG_DATA_EQLESS:       eCondMode = ScConditionMode::EqLess;     break;
+        case SC_VALIDDLG_DATA_EQGREATER:    eCondMode = ScConditionMode::EqGreater;  break;
+        case SC_VALIDDLG_DATA_NOTEQUAL:     eCondMode = ScConditionMode::NotEqual;   break;
+        case SC_VALIDDLG_DATA_VALIDRANGE:      eCondMode = ScConditionMode::Between;    break;
+        case SC_VALIDDLG_DATA_INVALIDRANGE:   eCondMode = ScConditionMode::NotBetween; break;
         default:    OSL_FAIL( "lclGetCondModeFromPos - invalid list box position" );
     }
     return eCondMode;
diff --git a/sc/source/ui/unoobj/condformatuno.cxx b/sc/source/ui/unoobj/condformatuno.cxx
index 78a2b17fa6d0..b9a1ab0bde82 100644
--- a/sc/source/ui/unoobj/condformatuno.cxx
+++ b/sc/source/ui/unoobj/condformatuno.cxx
@@ -81,32 +81,32 @@ struct ConditionEntryApiMap
 
 ConditionEntryApiMap aConditionEntryMap[] =
 {
-    {SC_COND_EQUAL, sheet::ConditionFormatOperator::EQUAL},
-    {SC_COND_LESS, sheet::ConditionFormatOperator::LESS},
-    {SC_COND_GREATER, sheet::ConditionFormatOperator::GREATER},
-    {SC_COND_EQLESS, sheet::ConditionFormatOperator::LESS_EQUAL},
-    {SC_COND_EQGREATER, sheet::ConditionFormatOperator::GREATER_EQUAL},
-    {SC_COND_NOTEQUAL, sheet::ConditionFormatOperator::NOT_EQUAL},
-    {SC_COND_BETWEEN, sheet::ConditionFormatOperator::BETWEEN},
-    {SC_COND_NOTBETWEEN, sheet::ConditionFormatOperator::NOT_BETWEEN},
-    {SC_COND_DUPLICATE, sheet::ConditionFormatOperator::DUPLICATE},
-    {SC_COND_NOTDUPLICATE, sheet::ConditionFormatOperator::UNIQUE},
-    {SC_COND_DIRECT, sheet::ConditionFormatOperator::EXPRESSION},
-    {SC_COND_TOP10, sheet::ConditionFormatOperator::TOP_N_ELEMENTS},
-    {SC_COND_BOTTOM10, sheet::ConditionFormatOperator::BOTTOM_N_ELEMENTS},
-    {SC_COND_TOP_PERCENT, sheet::ConditionFormatOperator::TOP_N_PERCENT},
-    {SC_COND_BOTTOM_PERCENT, sheet::ConditionFormatOperator::BOTTOM_N_PERCENT},
-    {SC_COND_ABOVE_AVERAGE, sheet::ConditionFormatOperator::ABOVE_AVERAGE},
-    {SC_COND_BELOW_AVERAGE, sheet::ConditionFormatOperator::BELOW_AVERAGE},
-    {SC_COND_ABOVE_EQUAL_AVERAGE, sheet::ConditionFormatOperator::ABOVE_EQUAL_AVERAGE},
-    {SC_COND_BELOW_EQUAL_AVERAGE, sheet::ConditionFormatOperator::BELOW_EQUAL_AVERAGE},
-    {SC_COND_ERROR, sheet::ConditionFormatOperator::ERROR},
-    {SC_COND_NOERROR, sheet::ConditionFormatOperator::NO_ERROR},
-    {SC_COND_BEGINS_WITH, sheet::ConditionFormatOperator::BEGINS_WITH},
-    {SC_COND_ENDS_WITH, sheet::ConditionFormatOperator::ENDS_WITH},
-    {SC_COND_CONTAINS_TEXT, sheet::ConditionFormatOperator::CONTAINS},
-    {SC_COND_NOT_CONTAINS_TEXT, sheet::ConditionFormatOperator::NOT_CONTAINS},
-    {SC_COND_NONE, sheet::ConditionFormatOperator::EQUAL},
+    {ScConditionMode::Equal, sheet::ConditionFormatOperator::EQUAL},
+    {ScConditionMode::Less, sheet::ConditionFormatOperator::LESS},
+    {ScConditionMode::Greater, sheet::ConditionFormatOperator::GREATER},
+    {ScConditionMode::EqLess, sheet::ConditionFormatOperator::LESS_EQUAL},
+    {ScConditionMode::EqGreater, sheet::ConditionFormatOperator::GREATER_EQUAL},
+    {ScConditionMode::NotEqual, sheet::ConditionFormatOperator::NOT_EQUAL},
+    {ScConditionMode::Between, sheet::ConditionFormatOperator::BETWEEN},
+    {ScConditionMode::NotBetween, sheet::ConditionFormatOperator::NOT_BETWEEN},
+    {ScConditionMode::Duplicate, sheet::ConditionFormatOperator::DUPLICATE},
+    {ScConditionMode::NotDuplicate, sheet::ConditionFormatOperator::UNIQUE},
+    {ScConditionMode::Direct, sheet::ConditionFormatOperator::EXPRESSION},
+    {ScConditionMode::Top10, sheet::ConditionFormatOperator::TOP_N_ELEMENTS},
+    {ScConditionMode::Bottom10, sheet::ConditionFormatOperator::BOTTOM_N_ELEMENTS},
+    {ScConditionMode::TopPercent, sheet::ConditionFormatOperator::TOP_N_PERCENT},
+    {ScConditionMode::BottomPercent, sheet::ConditionFormatOperator::BOTTOM_N_PERCENT},
+    {ScConditionMode::AboveAverage, sheet::ConditionFormatOperator::ABOVE_AVERAGE},
+    {ScConditionMode::BelowAverage, sheet::ConditionFormatOperator::BELOW_AVERAGE},
+    {ScConditionMode::AboveEqualAverage, sheet::ConditionFormatOperator::ABOVE_EQUAL_AVERAGE},
+    {ScConditionMode::BelowEqualAverage, sheet::ConditionFormatOperator::BELOW_EQUAL_AVERAGE},
+    {ScConditionMode::Error, sheet::ConditionFormatOperator::ERROR},
+    {ScConditionMode::NoError, sheet::ConditionFormatOperator::NO_ERROR},
+    {ScConditionMode::BeginsWith, sheet::ConditionFormatOperator::BEGINS_WITH},
+    {ScConditionMode::EndsWith, sheet::ConditionFormatOperator::ENDS_WITH},
+    {ScConditionMode::ContainsText, sheet::ConditionFormatOperator::CONTAINS},
+    {ScConditionMode::NotContainsText, sheet::ConditionFormatOperator::NOT_CONTAINS},
+    {ScConditionMode::NONE, sheet::ConditionFormatOperator::EQUAL},
 };
 
 enum ColorScaleProperties
@@ -477,7 +477,7 @@ void ScCondFormatObj::createEntry(const sal_Int32 nType, const sal_Int32 nPos)
     switch (nType)
     {
         case sheet::ConditionEntryType::CONDITION:
-            pNewEntry = new ScCondFormatEntry(SC_COND_EQUAL, "", "",
+            pNewEntry = new ScCondFormatEntry(ScConditionMode::Equal, "", "",
                     pDoc, pFormat->GetRange().GetTopLeftCorner(), "");
         break;
         case sheet::ConditionEntryType::COLORSCALE:
diff --git a/sc/source/ui/unoobj/fmtuno.cxx b/sc/source/ui/unoobj/fmtuno.cxx
index f89ca4601056..365b0d036ca1 100644
--- a/sc/source/ui/unoobj/fmtuno.cxx
+++ b/sc/source/ui/unoobj/fmtuno.cxx
@@ -68,16 +68,16 @@ static sal_Int32 lcl_ConditionModeToOperatorNew( ScConditionMode eMode )
     sal_Int32 eOper = sheet::ConditionOperator2::NONE;
     switch (eMode)
     {
-        case SC_COND_EQUAL:         eOper = sheet::ConditionOperator2::EQUAL;           break;
-        case SC_COND_LESS:          eOper = sheet::ConditionOperator2::LESS;            break;
-        case SC_COND_GREATER:       eOper = sheet::ConditionOperator2::GREATER;         break;
-        case SC_COND_EQLESS:        eOper = sheet::ConditionOperator2::LESS_EQUAL;      break;
-        case SC_COND_EQGREATER:     eOper = sheet::ConditionOperator2::GREATER_EQUAL;   break;
-        case SC_COND_NOTEQUAL:      eOper = sheet::ConditionOperator2::NOT_EQUAL;       break;
-        case SC_COND_BETWEEN:       eOper = sheet::ConditionOperator2::BETWEEN;         break;
-        case SC_COND_NOTBETWEEN:    eOper = sheet::ConditionOperator2::NOT_BETWEEN;     break;
-        case SC_COND_DIRECT:        eOper = sheet::ConditionOperator2::FORMULA;         break;
-        case SC_COND_DUPLICATE:     eOper = sheet::ConditionOperator2::DUPLICATE;       break;
+        case ScConditionMode::Equal:         eOper = sheet::ConditionOperator2::EQUAL;           break;
+        case ScConditionMode::Less:          eOper = sheet::ConditionOperator2::LESS;            break;
+        case ScConditionMode::Greater:       eOper = sheet::ConditionOperator2::GREATER;         break;
+        case ScConditionMode::EqLess:        eOper = sheet::ConditionOperator2::LESS_EQUAL;      break;
+        case ScConditionMode::EqGreater:     eOper = sheet::ConditionOperator2::GREATER_EQUAL;   break;
+        case ScConditionMode::NotEqual:      eOper = sheet::ConditionOperator2::NOT_EQUAL;       break;
+        case ScConditionMode::Between:       eOper = sheet::ConditionOperator2::BETWEEN;         break;
+        case ScConditionMode::NotBetween:    eOper = sheet::ConditionOperator2::NOT_BETWEEN;     break;
+        case ScConditionMode::Direct:        eOper = sheet::ConditionOperator2::FORMULA;         break;
+        case ScConditionMode::Duplicate:     eOper = sheet::ConditionOperator2::DUPLICATE;       break;
         default:
         {
             // added to avoid warnings
@@ -91,15 +91,15 @@ static sheet::ConditionOperator lcl_ConditionModeToOperator( ScConditionMode eMo
     sheet::ConditionOperator eOper = sheet::ConditionOperator_NONE;
     switch (eMode)
     {
-        case SC_COND_EQUAL:         eOper = sheet::ConditionOperator_EQUAL;         break;
-        case SC_COND_LESS:          eOper = sheet::ConditionOperator_LESS;          break;
-        case SC_COND_GREATER:       eOper = sheet::ConditionOperator_GREATER;       break;
-        case SC_COND_EQLESS:        eOper = sheet::ConditionOperator_LESS_EQUAL;    break;
-        case SC_COND_EQGREATER:     eOper = sheet::ConditionOperator_GREATER_EQUAL; break;
-        case SC_COND_NOTEQUAL:      eOper = sheet::ConditionOperator_NOT_EQUAL;     break;
-        case SC_COND_BETWEEN:       eOper = sheet::ConditionOperator_BETWEEN;       break;
-        case SC_COND_NOTBETWEEN:    eOper = sheet::ConditionOperator_NOT_BETWEEN;   break;
-        case SC_COND_DIRECT:        eOper = sheet::ConditionOperator_FORMULA;       break;
+        case ScConditionMode::Equal:         eOper = sheet::ConditionOperator_EQUAL;         break;
+        case ScConditionMode::Less:          eOper = sheet::ConditionOperator_LESS;          break;
+        case ScConditionMode::Greater:       eOper = sheet::ConditionOperator_GREATER;       break;
+        case ScConditionMode::EqLess:        eOper = sheet::ConditionOperator_LESS_EQUAL;    break;
+        case ScConditionMode::EqGreater:     eOper = sheet::ConditionOperator_GREATER_EQUAL; break;
+        case ScConditionMode::NotEqual:      eOper = sheet::ConditionOperator_NOT_EQUAL;     break;
+        case ScConditionMode::Between:       eOper = sheet::ConditionOperator_BETWEEN;       break;
+        case ScConditionMode::NotBetween:    eOper = sheet::ConditionOperator_NOT_BETWEEN;   break;
+        case ScConditionMode::Direct:        eOper = sheet::ConditionOperator_FORMULA;       break;
         default:
         {
             // added to avoid warnings
@@ -110,18 +110,18 @@ static sheet::ConditionOperator lcl_ConditionModeToOperator( ScConditionMode eMo
 
 static ScConditionMode lcl_ConditionOperatorToMode( sheet::ConditionOperator eOper )
 {
-    ScConditionMode eMode = SC_COND_NONE;
+    ScConditionMode eMode = ScConditionMode::NONE;
     switch (eOper)
     {
-        case sheet::ConditionOperator_EQUAL:            eMode = SC_COND_EQUAL;      break;
-        case sheet::ConditionOperator_LESS:             eMode = SC_COND_LESS;       break;
-        case sheet::ConditionOperator_GREATER:          eMode = SC_COND_GREATER;    break;
-        case sheet::ConditionOperator_LESS_EQUAL:       eMode = SC_COND_EQLESS;     break;
-        case sheet::ConditionOperator_GREATER_EQUAL:    eMode = SC_COND_EQGREATER;  break;
-        case sheet::ConditionOperator_NOT_EQUAL:        eMode = SC_COND_NOTEQUAL;   break;
-        case sheet::ConditionOperator_BETWEEN:          eMode = SC_COND_BETWEEN;    break;
-        case sheet::ConditionOperator_NOT_BETWEEN:      eMode = SC_COND_NOTBETWEEN; break;
-        case sheet::ConditionOperator_FORMULA:          eMode = SC_COND_DIRECT;     break;
+        case sheet::ConditionOperator_EQUAL:            eMode = ScConditionMode::Equal;      break;
+        case sheet::ConditionOperator_LESS:             eMode = ScConditionMode::Less;       break;
+        case sheet::ConditionOperator_GREATER:          eMode = ScConditionMode::Greater;    break;
+        case sheet::ConditionOperator_LESS_EQUAL:       eMode = ScConditionMode::EqLess;     break;
+        case sheet::ConditionOperator_GREATER_EQUAL:    eMode = ScConditionMode::EqGreater;  break;
+        case sheet::ConditionOperator_NOT_EQUAL:        eMode = ScConditionMode::NotEqual;   break;
+        case sheet::ConditionOperator_BETWEEN:          eMode = ScConditionMode::Between;    break;
+        case sheet::ConditionOperator_NOT_BETWEEN:      eMode = ScConditionMode::NotBetween; break;
+        case sheet::ConditionOperator_FORMULA:          eMode = ScConditionMode::Direct;     break;
         default:
         {
             // added to avoid warnings
@@ -133,7 +133,7 @@ static ScConditionMode lcl_ConditionOperatorToMode( sheet::ConditionOperator eOp
 ScCondFormatEntryItem::ScCondFormatEntryItem() :
     meGrammar1( FormulaGrammar::GRAM_UNSPECIFIED ),
     meGrammar2( FormulaGrammar::GRAM_UNSPECIFIED ),
-    meMode( SC_COND_NONE )
+    meMode( ScConditionMode::NONE )
 {
 }
 
@@ -249,7 +249,7 @@ void SAL_CALL ScTableConditionalFormat::addNew(
 {
     SolarMutexGuard aGuard;
     ScCondFormatEntryItem aEntry;
-    aEntry.meMode = SC_COND_NONE;
+    aEntry.meMode = ScConditionMode::NONE;
 
     const beans::PropertyValue* pPropArray = aConditionalEntry.getConstArray();
     long nPropCount = aConditionalEntry.getLength();
@@ -660,7 +660,7 @@ ScValidationData* ScTableValidationObj::CreateValidationData( ScDocument* pDoc,
 
 void ScTableValidationObj::ClearData_Impl()
 {
-    nMode        = SC_COND_NONE;
+    nMode        = ScConditionMode::NONE;
     nValMode     = SC_VALID_ANY;
     bIgnoreBlank = true;
     nShowList    = sheet::TableValidationVisibility::UNSORTED;
diff --git a/sc/source/ui/view/cellsh2.cxx b/sc/source/ui/view/cellsh2.cxx
index 36c13b3a2175..bd654de87e95 100644
--- a/sc/source/ui/view/cellsh2.cxx
+++ b/sc/source/ui/view/cellsh2.cxx
@@ -817,7 +817,7 @@ void ScCellShell::ExecuteDB( SfxRequest& rReq )
                 {
                     SfxItemSet aArgSet( GetPool(), ScTPValidationValue::GetRanges() );
                     ScValidationMode eMode = SC_VALID_ANY;
-                    ScConditionMode eOper = SC_COND_EQUAL;
+                    ScConditionMode eOper = ScConditionMode::Equal;
                     OUString aExpr1, aExpr2;
                     bool bBlank = true;
                     sal_Int16 nListType = css::sheet::TableValidationVisibility::UNSORTED;
@@ -918,14 +918,14 @@ void ScCellShell::ExecuteDB( SfxRequest& rReq )
                                 if ( eMode == SC_VALID_TIME ) {
                                     sal_Int32 wraparound = aExpr1.compareTo(aExpr2);
                                     if (wraparound > 0) {
-                                        if (eOper == SC_COND_BETWEEN) {
-                                            eOper = SC_COND_NOTBETWEEN;
+                                        if (eOper == ScConditionMode::Between) {
+                                            eOper = ScConditionMode::NotBetween;
                                             OUString tmp = aExpr1;
                                             aExpr1 = aExpr2;
                                             aExpr2 = tmp;
                                         }
-                                        else if (eOper == SC_COND_NOTBETWEEN) {
-                                            eOper = SC_COND_BETWEEN;
+                                        else if (eOper == ScConditionMode::NotBetween) {
+                                            eOper = ScConditionMode::Between;
                                             OUString tmp = aExpr1;
                                             aExpr1 = aExpr2;
                                             aExpr2 = tmp;