sc/inc/conditio.hxx | 54 ++++---- sc/qa/unit/subsequent_filters-test.cxx | 4 sc/qa/unit/ucalc_condformat.cxx | 40 +++--- sc/qa/unit/ucalc_formula.cxx | 2 sc/source/core/data/conditio.cxx | 162 ++++++++++++------------- sc/source/core/data/validat.cxx | 6 sc/source/filter/excel/xecontent.cxx | 136 ++++++++++---------- sc/source/filter/excel/xicontent.cxx | 38 ++--- sc/source/filter/inc/condformatbuffer.hxx | 3 sc/source/filter/oox/condformatbuffer.cxx | 82 ++++++------ sc/source/filter/xml/xmlcondformat.cxx | 52 ++++---- sc/source/filter/xml/xmlexprt.cxx | 52 ++++---- sc/source/ui/condformat/condformatdlg.cxx | 2 sc/source/ui/condformat/condformatdlgentry.cxx | 98 +++++++-------- sc/source/ui/condformat/condformathelper.cxx | 6 sc/source/ui/dbgui/validate.cxx | 36 ++--- sc/source/ui/unoobj/condformatuno.cxx | 54 ++++---- sc/source/ui/unoobj/fmtuno.cxx | 64 ++++----- sc/source/ui/view/cellsh2.cxx | 10 - 19 files changed, 451 insertions(+), 450 deletions(-)
New commits: commit b48950d8b326d29891b809434fd862e960e2ec99 Author: Tor Lillqvist <t...@collabora.com> Date: Thu Nov 23 16:22:38 2017 +0200 Convert ScConditionMode to scoped enum Change-Id: I9b6aaa64e7f649581b27f0238e2908026ab6e0bd Reviewed-on: https://gerrit.libreoffice.org/45157 Tested-by: Jenkins <c...@libreoffice.org> Reviewed-by: Tor Lillqvist <t...@collabora.com> 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; _______________________________________________ Libreoffice-commits mailing list libreoffice-comm...@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/libreoffice-commits