convert auto correct flags to scoped enum

Change-Id: I73356493d97bb4f0d5b7db8b5c742837d7a4c78b
Reviewed-on: https://gerrit.libreoffice.org/53505
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>

4 files changed, 91 insertions, 91 deletions

diff --git a/editeng/qa/unit/core-test.cxx b/editeng/qa/unit/core-test.cxx
index c6d3a86c44a0..9e882ad77b5c 100644
--- a/editeng/qa/unit/core-test.cxx
+++ b/editeng/qa/unit/core-test.cxx
@@ -507,7 +507,7 @@ void Test::testAutocorrect()
         bool bNbspRunNext = false;
 
         TestAutoCorrDoc aFoo(sInput, LANGUAGE_ENGLISH_US);
-        aAutoCorrect.SetAutoCorrFlag(ChgQuotes, true);
+        aAutoCorrect.SetAutoCorrFlag(ACFlags::ChgQuotes, true);
         aAutoCorrect.DoAutoCorrect(aFoo, sInput, sInput.getLength(), cNextChar, true, bNbspRunNext);
         fprintf(stderr, "text is %x\n", aFoo.getResult()[aFoo.getResult().getLength() - 1]);
 
diff --git a/editeng/source/editeng/impedit2.cxx b/editeng/source/editeng/impedit2.cxx
index 19e035fafccd..04a7c959278a 100644
--- a/editeng/source/editeng/impedit2.cxx
+++ b/editeng/source/editeng/impedit2.cxx
@@ -2512,7 +2512,7 @@ EditPaM ImpEditEngine::AutoCorrect( const EditSelection& rCurSel, sal_Unicode c,
         // #i78661 allow application to turn off capitalization of
         // start sentence explicitly.
         // (This is done by setting IsFirstWordCapitalization to sal_False.)
-        bool bOldCapitalStartSentence = pAutoCorrect->IsAutoCorrFlag( CapitalStartSentence );
+        bool bOldCapitalStartSentence = pAutoCorrect->IsAutoCorrFlag( ACFlags::CapitalStartSentence );
         if (!IsFirstWordCapitalization())
         {
             ESelection aESel( CreateESel(aSel) );
@@ -2543,7 +2543,7 @@ EditPaM ImpEditEngine::AutoCorrect( const EditSelection& rCurSel, sal_Unicode c,
                     aSel.Max().GetIndex() <= aSecondWordSel.Min().GetIndex();
 
             if (bIsFirstWordInFirstPara)
-                pAutoCorrect->SetAutoCorrFlag( CapitalStartSentence, IsFirstWordCapitalization() );
+                pAutoCorrect->SetAutoCorrFlag( ACFlags::CapitalStartSentence, IsFirstWordCapitalization() );
         }
 
         ContentNode* pNode = aSel.Max().GetNode();
@@ -2557,7 +2557,7 @@ EditPaM ImpEditEngine::AutoCorrect( const EditSelection& rCurSel, sal_Unicode c,
 
         // #i78661 since the SvxAutoCorrect object used here is
         // shared we need to reset the value to its original state.
-        pAutoCorrect->SetAutoCorrFlag( CapitalStartSentence, bOldCapitalStartSentence );
+        pAutoCorrect->SetAutoCorrFlag( ACFlags::CapitalStartSentence, bOldCapitalStartSentence );
     }
     return aSel.Max();
 }
diff --git a/editeng/source/misc/acorrcfg.cxx b/editeng/source/misc/acorrcfg.cxx
index 5bd97c67a197..e2c45e1850b0 100644
--- a/editeng/source/misc/acorrcfg.cxx
+++ b/editeng/source/misc/acorrcfg.cxx
@@ -129,7 +129,7 @@ void SvxBaseAutoCorrCfg::Load(bool bInit)
     DBG_ASSERT(aValues.getLength() == aNames.getLength(), "GetProperties failed");
     if(aValues.getLength() == aNames.getLength())
     {
-        long nFlags = 0;        // default all off
+        ACFlags nFlags = ACFlags::NONE;        // default all off
         sal_Int32 nTemp = 0;
         for(int nProp = 0; nProp < aNames.getLength(); nProp++)
         {
@@ -139,51 +139,51 @@ void SvxBaseAutoCorrCfg::Load(bool bInit)
                 {
                     case  0:
                         if(*o3tl::doAccess<bool>(pValues[nProp]))
-                            nFlags |= SaveWordCplSttLst;
+                            nFlags |= ACFlags::SaveWordCplSttLst;
                     break;//"Exceptions/TwoCapitalsAtStart",
                     case  1:
                         if(*o3tl::doAccess<bool>(pValues[nProp]))
-                            nFlags |= SaveWordWrdSttLst;
+                            nFlags |= ACFlags::SaveWordWrdSttLst;
                     break;//"Exceptions/CapitalAtStartSentence",
                     case  2:
                         if(*o3tl::doAccess<bool>(pValues[nProp]))
-                            nFlags |= Autocorrect;
+                            nFlags |= ACFlags::Autocorrect;
                     break;//"UseReplacementTable",
                     case  3:
                         if(*o3tl::doAccess<bool>(pValues[nProp]))
-                            nFlags |= CapitalStartWord;
+                            nFlags |= ACFlags::CapitalStartWord;
                     break;//"TwoCapitalsAtStart",
                     case  4:
                         if(*o3tl::doAccess<bool>(pValues[nProp]))
-                            nFlags |= CapitalStartSentence;
+                            nFlags |= ACFlags::CapitalStartSentence;
                     break;//"CapitalAtStartSentence",
                     case  5:
                         if(*o3tl::doAccess<bool>(pValues[nProp]))
-                            nFlags |= ChgWeightUnderl;
+                            nFlags |= ACFlags::ChgWeightUnderl;
                     break;//"ChangeUnderlineWeight",
                     case  6:
                         if(*o3tl::doAccess<bool>(pValues[nProp]))
-                            nFlags |= SetINetAttr;
+                            nFlags |= ACFlags::SetINetAttr;
                     break;//"SetInetAttribute",
                     case  7:
                         if(*o3tl::doAccess<bool>(pValues[nProp]))
-                            nFlags |= ChgOrdinalNumber;
+                            nFlags |= ACFlags::ChgOrdinalNumber;
                     break;//"ChangeOrdinalNumber",
                     case 8:
                         if(*o3tl::doAccess<bool>(pValues[nProp]))
-                             nFlags |= AddNonBrkSpace;
+                             nFlags |= ACFlags::AddNonBrkSpace;
                     break;//"AddNonBreakingSpace"
                     case  9:
                         if(*o3tl::doAccess<bool>(pValues[nProp]))
-                            nFlags |= ChgToEnEmDash;
+                            nFlags |= ACFlags::ChgToEnEmDash;
                     break;//"ChangeDash",
                     case 10:
                         if(*o3tl::doAccess<bool>(pValues[nProp]))
-                            nFlags |= IgnoreDoubleSpace;
+                            nFlags |= ACFlags::IgnoreDoubleSpace;
                     break;//"RemoveDoubleSpaces",
                     case 11:
                         if(*o3tl::doAccess<bool>(pValues[nProp]))
-                            nFlags |= ChgSglQuotes;
+                            nFlags |= ACFlags::ChgSglQuotes;
                     break;//"ReplaceSingleQuote",
                     case 12:
                         pValues[nProp] >>= nTemp;
@@ -197,7 +197,7 @@ void SvxBaseAutoCorrCfg::Load(bool bInit)
                     break;//"SingleQuoteAtEnd",
                     case 14:
                         if(*o3tl::doAccess<bool>(pValues[nProp]))
-                            nFlags |= ChgQuotes;
+                            nFlags |= ACFlags::ChgQuotes;
                     break;//"ReplaceDoubleQuote",
                     case 15:
                         pValues[nProp] >>= nTemp;
@@ -211,14 +211,14 @@ void SvxBaseAutoCorrCfg::Load(bool bInit)
                     break;//"DoubleQuoteAtEnd"
                     case 17:
                         if(*o3tl::doAccess<bool>(pValues[nProp]))
-                            nFlags |= CorrectCapsLock;
+                            nFlags |= ACFlags::CorrectCapsLock;
                     break;//"CorrectAccidentalCapsLock"
                 }
             }
         }
-        if( nFlags )
+        if( nFlags != ACFlags::NONE )
             rParent.pAutoCorrect->SetAutoCorrFlag( nFlags );
-        rParent.pAutoCorrect->SetAutoCorrFlag( ( 0xffff & ~nFlags ), false );
+        rParent.pAutoCorrect->SetAutoCorrFlag( ( static_cast<ACFlags>(0x3fff) & ~nFlags ), false );
 
     }
 }
@@ -235,38 +235,38 @@ SvxBaseAutoCorrCfg::~SvxBaseAutoCorrCfg()
 
 void SvxBaseAutoCorrCfg::ImplCommit()
 {
-    const long nFlags = rParent.pAutoCorrect->GetFlags();
+    const ACFlags nFlags = rParent.pAutoCorrect->GetFlags();
     PutProperties(
         GetPropertyNames(),
-        {css::uno::Any((nFlags & SaveWordCplSttLst) != 0),
+        {css::uno::Any(bool(nFlags & ACFlags::SaveWordCplSttLst)),
             // "Exceptions/TwoCapitalsAtStart"
-         css::uno::Any((nFlags & SaveWordWrdSttLst) != 0),
+         css::uno::Any(bool(nFlags & ACFlags::SaveWordWrdSttLst)),
             // "Exceptions/CapitalAtStartSentence"
-         css::uno::Any((nFlags & Autocorrect) != 0), // "UseReplacementTable"
-         css::uno::Any((nFlags & CapitalStartWord) != 0),
+         css::uno::Any(bool(nFlags & ACFlags::Autocorrect)), // "UseReplacementTable"
+         css::uno::Any(bool(nFlags & ACFlags::CapitalStartWord)),
             // "TwoCapitalsAtStart"
-         css::uno::Any((nFlags & CapitalStartSentence) != 0),
+         css::uno::Any(bool(nFlags & ACFlags::CapitalStartSentence)),
             // "CapitalAtStartSentence"
-         css::uno::Any((nFlags & ChgWeightUnderl) != 0),
+         css::uno::Any(bool(nFlags & ACFlags::ChgWeightUnderl)),
             // "ChangeUnderlineWeight"
-         css::uno::Any((nFlags & SetINetAttr) != 0), // "SetInetAttribute"
-         css::uno::Any((nFlags & ChgOrdinalNumber) != 0),
+         css::uno::Any(bool(nFlags & ACFlags::SetINetAttr)), // "SetInetAttribute"
+         css::uno::Any(bool(nFlags & ACFlags::ChgOrdinalNumber)),
             // "ChangeOrdinalNumber"
-         css::uno::Any((nFlags & AddNonBrkSpace) != 0), // "AddNonBreakingSpace"
-         css::uno::Any((nFlags & ChgToEnEmDash) != 0), // "ChangeDash"
-         css::uno::Any((nFlags & IgnoreDoubleSpace) != 0),
+         css::uno::Any(bool(nFlags & ACFlags::AddNonBrkSpace)), // "AddNonBreakingSpace"
+         css::uno::Any(bool(nFlags & ACFlags::ChgToEnEmDash)), // "ChangeDash"
+         css::uno::Any(bool(nFlags & ACFlags::IgnoreDoubleSpace)),
             // "RemoveDoubleSpaces"
-         css::uno::Any((nFlags & ChgSglQuotes) != 0), // "ReplaceSingleQuote"
+         css::uno::Any(bool(nFlags & ACFlags::ChgSglQuotes)), // "ReplaceSingleQuote"
          css::uno::Any(sal_Int32(rParent.pAutoCorrect->GetStartSingleQuote())),
             // "SingleQuoteAtStart"
          css::uno::Any(sal_Int32(rParent.pAutoCorrect->GetEndSingleQuote())),
             // "SingleQuoteAtEnd"
-         css::uno::Any((nFlags & ChgQuotes) != 0), // "ReplaceDoubleQuote"
+         css::uno::Any(bool(nFlags & ACFlags::ChgQuotes)), // "ReplaceDoubleQuote"
          css::uno::Any(sal_Int32(rParent.pAutoCorrect->GetStartDoubleQuote())),
             // "DoubleQuoteAtStart"
          css::uno::Any(sal_Int32(rParent.pAutoCorrect->GetEndDoubleQuote())),
             // "DoubleQuoteAtEnd"
-         css::uno::Any((nFlags & CorrectCapsLock) != 0)});
+        css::uno::Any(bool(nFlags & ACFlags::CorrectCapsLock))});
             // "CorrectAccidentalCapsLock"
 }
 
diff --git a/editeng/source/misc/svxacorr.cxx b/editeng/source/misc/svxacorr.cxx
index 8d4d9d7cc0b0..bcc722e1f31a 100644
--- a/editeng/source/misc/svxacorr.cxx
+++ b/editeng/source/misc/svxacorr.cxx
@@ -188,7 +188,7 @@ SvxAutoCorrDoc::~SvxAutoCorrDoc()
 //  - FnCapitalStartSentence
 // after the exchange of characters. Then the words, if necessary, can be inserted
 // into the exception list.
-void SvxAutoCorrDoc::SaveCpltSttWord( sal_uLong, sal_Int32, const OUString&,
+void SvxAutoCorrDoc::SaveCpltSttWord( ACFlags, sal_Int32, const OUString&,
                                         sal_Unicode )
 {
 }
@@ -270,20 +270,20 @@ bool SvxAutoCorrect::NeedsHardspaceAutocorr( sal_Unicode cChar )
         cChar == '/' /*case for the urls exception*/;
 }
 
-long SvxAutoCorrect::GetDefaultFlags()
-{
-    long nRet = Autocorrect
-                    | CapitalStartSentence
-                    | CapitalStartWord
-                    | ChgOrdinalNumber
-                    | ChgToEnEmDash
-                    | AddNonBrkSpace
-                    | ChgWeightUnderl
-                    | SetINetAttr
-                    | ChgQuotes
-                    | SaveWordCplSttLst
-                    | SaveWordWrdSttLst
-                    | CorrectCapsLock;
+ACFlags SvxAutoCorrect::GetDefaultFlags()
+{
+    ACFlags nRet = ACFlags::Autocorrect
+                    | ACFlags::CapitalStartSentence
+                    | ACFlags::CapitalStartWord
+                    | ACFlags::ChgOrdinalNumber
+                    | ACFlags::ChgToEnEmDash
+                    | ACFlags::AddNonBrkSpace
+                    | ACFlags::ChgWeightUnderl
+                    | ACFlags::SetINetAttr
+                    | ACFlags::ChgQuotes
+                    | ACFlags::SaveWordCplSttLst
+                    | ACFlags::SaveWordWrdSttLst
+                    | ACFlags::CorrectCapsLock;
     LanguageType eLang = GetAppLang().getLanguageType();
     if( eLang.anyOf(
         LANGUAGE_ENGLISH,
@@ -296,7 +296,7 @@ long SvxAutoCorrect::GetDefaultFlags()
         LANGUAGE_ENGLISH_SAFRICA,
         LANGUAGE_ENGLISH_JAMAICA,
         LANGUAGE_ENGLISH_CARRIBEAN))
-        nRet &= ~(ChgQuotes|ChgSglQuotes);
+        nRet &= ~ACFlags(ACFlags::ChgQuotes|ACFlags::ChgSglQuotes);
     return nRet;
 }
 
@@ -321,7 +321,7 @@ SvxAutoCorrect::SvxAutoCorrect( const SvxAutoCorrect& rCpy )
     , sUserAutoCorrFile( rCpy.sUserAutoCorrFile )
     , aSwFlags( rCpy.aSwFlags )
     , eCharClassLang(rCpy.eCharClassLang)
-    , nFlags( rCpy.nFlags & ~(ChgWordLstLoad|CplSttLstLoad|WrdSttLstLoad))
+    , nFlags( rCpy.nFlags & ~ACFlags(ACFlags::ChgWordLstLoad|ACFlags::CplSttLstLoad|ACFlags::WrdSttLstLoad))
     , cStartDQuote( rCpy.cStartDQuote )
     , cEndDQuote( rCpy.cEndDQuote )
     , cStartSQuote( rCpy.cStartSQuote )
@@ -342,20 +342,20 @@ void SvxAutoCorrect::GetCharClass_( LanguageType eLang )
     eCharClassLang = eLang;
 }
 
-void SvxAutoCorrect::SetAutoCorrFlag( long nFlag, bool bOn )
+void SvxAutoCorrect::SetAutoCorrFlag( ACFlags nFlag, bool bOn )
 {
-    long nOld = nFlags;
+    ACFlags nOld = nFlags;
     nFlags = bOn ? nFlags | nFlag
                  : nFlags & ~nFlag;
 
     if( !bOn )
     {
-        if( (nOld & CapitalStartSentence) != (nFlags & CapitalStartSentence) )
-            nFlags &= ~CplSttLstLoad;
-        if( (nOld & CapitalStartWord) != (nFlags & CapitalStartWord) )
-            nFlags &= ~WrdSttLstLoad;
-        if( (nOld & Autocorrect) != (nFlags & Autocorrect) )
-            nFlags &= ~ChgWordLstLoad;
+        if( (nOld & ACFlags::CapitalStartSentence) != (nFlags & ACFlags::CapitalStartSentence) )
+            nFlags &= ~ACFlags::CplSttLstLoad;
+        if( (nOld & ACFlags::CapitalStartWord) != (nFlags & ACFlags::CapitalStartWord) )
+            nFlags &= ~ACFlags::WrdSttLstLoad;
+        if( (nOld & ACFlags::Autocorrect) != (nFlags & ACFlags::Autocorrect) )
+            nFlags &= ~ACFlags::ChgWordLstLoad;
     }
 }
 
@@ -437,8 +437,8 @@ void SvxAutoCorrect::FnCapitalStartWord( SvxAutoCorrDoc& rDoc, const OUString& r
                 sChar = rCC.lowercase( sChar );
                 if( sChar[0] != cSave && rDoc.ReplaceRange( nSttPos, 1, sChar ))
                 {
-                    if( SaveWordWrdSttLst & nFlags )
-                        rDoc.SaveCpltSttWord( CapitalStartWord, nSttPos, sWord, cSave );
+                    if( ACFlags::SaveWordWrdSttLst & nFlags )
+                        rDoc.SaveCpltSttWord( ACFlags::CapitalStartWord, nSttPos, sWord, cSave );
                 }
             }
         }
@@ -1089,8 +1089,8 @@ void SvxAutoCorrect::FnCapitalStartSentence( SvxAutoCorrDoc& rDoc,
     bool bRet = sChar[0] != cSave && rDoc.ReplaceRange( nSttPos, 1, sChar );
 
     // Perhaps someone wants to have the word
-    if( bRet && SaveWordCplSttLst & nFlags )
-        rDoc.SaveCpltSttWord( CapitalStartSentence, nSttPos, sWord, cSave );
+    if( bRet && ACFlags::SaveWordCplSttLst & nFlags )
+        rDoc.SaveCpltSttWord( ACFlags::CapitalStartSentence, nSttPos, sWord, cSave );
 }
 
 bool SvxAutoCorrect::FnCorrectCapsLock( SvxAutoCorrDoc& rDoc, const OUString& rTxt,
@@ -1241,7 +1241,7 @@ void SvxAutoCorrect::DoAutoCorrect( SvxAutoCorrDoc& rDoc, const OUString& rTxt,
         {
             // Prevent double space
             if( nInsPos && ' ' == cChar &&
-                IsAutoCorrFlag( IgnoreDoubleSpace ) &&
+                IsAutoCorrFlag( ACFlags::IgnoreDoubleSpace ) &&
                 ' ' == rTxt[ nInsPos - 1 ])
             {
                 break;
@@ -1249,8 +1249,8 @@ void SvxAutoCorrect::DoAutoCorrect( SvxAutoCorrDoc& rDoc, const OUString& rTxt,
 
             bool bSingle = '\'' == cChar;
             bool bIsReplaceQuote =
-                        (IsAutoCorrFlag( ChgQuotes ) && ('\"' == cChar )) ||
-                        (IsAutoCorrFlag( ChgSglQuotes ) && bSingle );
+                        (IsAutoCorrFlag( ACFlags::ChgQuotes ) && ('\"' == cChar )) ||
+                        (IsAutoCorrFlag( ACFlags::ChgSglQuotes ) && bSingle );
             if( bIsReplaceQuote )
             {
                 sal_Unicode cPrev;
@@ -1270,7 +1270,7 @@ void SvxAutoCorrect::DoAutoCorrect( SvxAutoCorrDoc& rDoc, const OUString& rTxt,
                 rDoc.Replace( nInsPos, OUString(cChar) );
 
             // Hardspaces autocorrection
-            if ( IsAutoCorrFlag( AddNonBrkSpace ) )
+            if ( IsAutoCorrFlag( ACFlags::AddNonBrkSpace ) )
             {
                 if ( NeedsHardspaceAutocorr( cChar ) &&
                     FnAddNonBrkSpace( rDoc, rTxt, nInsPos, GetDocLanguage( rDoc, nInsPos ), io_bNbspRunNext ) )
@@ -1314,7 +1314,7 @@ void SvxAutoCorrect::DoAutoCorrect( SvxAutoCorrDoc& rDoc, const OUString& rTxt,
         // Set bold or underline automatically?
         if (('*' == cChar || '_' == cChar || '/' == cChar || '-' == cChar) && (nPos+1 < rTxt.getLength()))
         {
-            if( IsAutoCorrFlag( ChgWeightUnderl ) )
+            if( IsAutoCorrFlag( ACFlags::ChgWeightUnderl ) )
             {
                 FnChgWeightUnderl( rDoc, rTxt, nPos+1 );
             }
@@ -1337,13 +1337,13 @@ void SvxAutoCorrect::DoAutoCorrect( SvxAutoCorrDoc& rDoc, const OUString& rTxt,
         if( lcl_IsSymbolChar( rCC, rTxt, nCapLttrPos, nInsPos ))
             break;
 
-        if( IsAutoCorrFlag( Autocorrect ) )
+        if( IsAutoCorrFlag( ACFlags::Autocorrect ) )
         {
             // WARNING ATTENTION: rTxt is an alias of the text node's OUString
             // and becomes INVALID if ChgAutoCorrWord returns true!
             // => use aPara/pPara to create a valid copy of the string!
             OUString aPara;
-            OUString* pPara = IsAutoCorrFlag(CapitalStartSentence) ? &aPara : nullptr;
+            OUString* pPara = IsAutoCorrFlag(ACFlags::CapitalStartSentence) ? &aPara : nullptr;
 
             bool bChgWord = rDoc.ChgAutoCorrWord( nCapLttrPos, nInsPos,
                                                     *this, pPara );
@@ -1378,13 +1378,13 @@ void SvxAutoCorrect::DoAutoCorrect( SvxAutoCorrDoc& rDoc, const OUString& rTxt,
                         ++nEnd;
 
                     // Capital letter at beginning of paragraph?
-                    if( IsAutoCorrFlag( CapitalStartSentence ) )
+                    if( IsAutoCorrFlag( ACFlags::CapitalStartSentence ) )
                     {
                         FnCapitalStartSentence( rDoc, aPara, false,
                                                 nCapLttrPos, nEnd, eLang );
                     }
 
-                    if( IsAutoCorrFlag( ChgToEnEmDash ) )
+                    if( IsAutoCorrFlag( ACFlags::ChgToEnEmDash ) )
                     {
                         FnChgToEnEmDash( rDoc, aPara, nCapLttrPos, nEnd, eLang );
                     }
@@ -1393,11 +1393,11 @@ void SvxAutoCorrect::DoAutoCorrect( SvxAutoCorrDoc& rDoc, const OUString& rTxt,
             }
         }
 
-        if( ( IsAutoCorrFlag( ChgOrdinalNumber ) &&
+        if( ( IsAutoCorrFlag( ACFlags::ChgOrdinalNumber ) &&
                 (nInsPos >= 2 ) &&       // fdo#69762 avoid autocorrect for 2e-3
                 ( '-' != cChar || 'E' != rtl::toAsciiUpperCase(rTxt[nInsPos-1]) || '0' > rTxt[nInsPos-2] || '9' < rTxt[nInsPos-2] ) &&
                 FnChgOrdinalNumber( rDoc, rTxt, nCapLttrPos, nInsPos, eLang ) ) ||
-            ( IsAutoCorrFlag( SetINetAttr ) &&
+            ( IsAutoCorrFlag( ACFlags::SetINetAttr ) &&
                 ( ' ' == cChar || '\t' == cChar || 0x0a == cChar || !cChar ) &&
                 FnSetINetAttr( rDoc, rTxt, nCapLttrPos, nInsPos, eLang ) ) )
             ;
@@ -1406,7 +1406,7 @@ void SvxAutoCorrect::DoAutoCorrect( SvxAutoCorrDoc& rDoc, const OUString& rTxt,
             bool bLockKeyOn = pFrameWin && (pFrameWin->GetIndicatorState() & KeyIndicatorState::CAPSLOCK);
             bool bUnsupported = lcl_IsUnsupportedUnicodeChar( rCC, rTxt, nCapLttrPos, nInsPos );
 
-            if ( bLockKeyOn && IsAutoCorrFlag( CorrectCapsLock ) &&
+            if ( bLockKeyOn && IsAutoCorrFlag( ACFlags::CorrectCapsLock ) &&
                  FnCorrectCapsLock( rDoc, rTxt, nCapLttrPos, nInsPos, eLang ) )
             {
                 // Correct accidental use of cAPS LOCK key (do this only when
@@ -1417,19 +1417,19 @@ void SvxAutoCorrect::DoAutoCorrect( SvxAutoCorrDoc& rDoc, const OUString& rTxt,
 
             // Capital letter at beginning of paragraph ?
             if( !bUnsupported &&
-                IsAutoCorrFlag( CapitalStartSentence ) )
+                IsAutoCorrFlag( ACFlags::CapitalStartSentence ) )
             {
                 FnCapitalStartSentence( rDoc, rTxt, true, nCapLttrPos, nInsPos, eLang );
             }
 
             // Two capital letters at beginning of word ??
             if( !bUnsupported &&
-                IsAutoCorrFlag( CapitalStartWord ) )
+                IsAutoCorrFlag( ACFlags::CapitalStartWord ) )
             {
                 FnCapitalStartWord( rDoc, rTxt, nCapLttrPos, nInsPos, eLang );
             }
 
-            if( IsAutoCorrFlag( ChgToEnEmDash ) )
+            if( IsAutoCorrFlag( ACFlags::ChgToEnEmDash ) )
             {
                 FnChgToEnEmDash( rDoc, rTxt, nCapLttrPos, nInsPos, eLang );
             }
@@ -1918,7 +1918,7 @@ SvxAutoCorrectLanguageLists::SvxAutoCorrectLanguageLists(
     pWrdStt_ExcptLst( nullptr ),
     pAutocorr_List( nullptr ),
     rAutoCorrect(rParent),
-    nFlags(0)
+    nFlags(ACFlags::NONE)
 {
 }
 
@@ -1943,19 +1943,19 @@ bool SvxAutoCorrectLanguageLists::IsFileChanged_Imp()
         {
             bRet = true;
             // then remove all the lists fast!
-            if( CplSttLstLoad & nFlags && pCplStt_ExcptLst )
+            if( (ACFlags::CplSttLstLoad & nFlags) && pCplStt_ExcptLst )
             {
                 pCplStt_ExcptLst.reset();
             }
-            if( WrdSttLstLoad & nFlags && pWrdStt_ExcptLst )
+            if( (ACFlags::WrdSttLstLoad & nFlags) && pWrdStt_ExcptLst )
             {
                 pWrdStt_ExcptLst.reset();
             }
-            if( ChgWordLstLoad & nFlags && pAutocorr_List )
+            if( (ACFlags::ChgWordLstLoad & nFlags) && pAutocorr_List )
             {
                 pAutocorr_List.reset();
             }
-            nFlags &= ~(CplSttLstLoad | WrdSttLstLoad | ChgWordLstLoad );
+            nFlags &= ~ACFlags(ACFlags::CplSttLstLoad | ACFlags::WrdSttLstLoad | ACFlags::ChgWordLstLoad );
         }
         aLastCheckTime = tools::Time( tools::Time::SYSTEM );
     }
@@ -2136,7 +2136,7 @@ SvxAutocorrWordList* SvxAutoCorrectLanguageLists::LoadAutocorrWordList()
 
 const SvxAutocorrWordList* SvxAutoCorrectLanguageLists::GetAutocorrWordList()
 {
-    if( !( ChgWordLstLoad & nFlags ) || IsFileChanged_Imp() )
+    if( !( ACFlags::ChgWordLstLoad & nFlags ) || IsFileChanged_Imp() )
     {
         LoadAutocorrWordList();
         if( !pAutocorr_List )
@@ -2144,14 +2144,14 @@ const SvxAutocorrWordList* SvxAutoCorrectLanguageLists::GetAutocorrWordList()
             OSL_ENSURE( false, "No valid list" );
             pAutocorr_List.reset( new SvxAutocorrWordList() );
         }
-        nFlags |= ChgWordLstLoad;
+        nFlags |= ACFlags::ChgWordLstLoad;
     }
     return pAutocorr_List.get();
 }
 
 SvStringsISortDtor* SvxAutoCorrectLanguageLists::GetCplSttExceptList()
 {
-    if( !( CplSttLstLoad & nFlags ) || IsFileChanged_Imp() )
+    if( !( ACFlags::CplSttLstLoad & nFlags ) || IsFileChanged_Imp() )
     {
         LoadCplSttExceptList();
         if( !pCplStt_ExcptLst )
@@ -2159,7 +2159,7 @@ SvStringsISortDtor* SvxAutoCorrectLanguageLists::GetCplSttExceptList()
             OSL_ENSURE( false, "No valid list" );
             pCplStt_ExcptLst.reset( new SvStringsISortDtor );
         }
-        nFlags |= CplSttLstLoad;
+        nFlags |= ACFlags::CplSttLstLoad;
     }
     return pCplStt_ExcptLst.get();
 }
@@ -2267,7 +2267,7 @@ void SvxAutoCorrectLanguageLists::SaveWrdSttExceptList()
 
 SvStringsISortDtor* SvxAutoCorrectLanguageLists::GetWrdSttExceptList()
 {
-    if( !( WrdSttLstLoad & nFlags ) || IsFileChanged_Imp() )
+    if( !( ACFlags::WrdSttLstLoad & nFlags ) || IsFileChanged_Imp() )
     {
         LoadWrdSttExceptList();
         if( !pWrdStt_ExcptLst )
@@ -2275,7 +2275,7 @@ SvStringsISortDtor* SvxAutoCorrectLanguageLists::GetWrdSttExceptList()
             OSL_ENSURE( false, "No valid list" );
             pWrdStt_ExcptLst.reset( new SvStringsISortDtor );
         }
-        nFlags |= WrdSttLstLoad;
+        nFlags |= ACFlags::WrdSttLstLoad;
     }
     return pWrdStt_ExcptLst.get();
 }