svl: sal_Bool -> bool

Change-Id: Ic31455a1f5ffffa35d4fdde901dd70734207b6f4

3 files changed, 75 insertions, 75 deletions

diff --git a/svl/source/config/cjkoptions.cxx b/svl/source/config/cjkoptions.cxx
index d69880aad0ab..7c9538f101a9 100644
--- a/svl/source/config/cjkoptions.cxx
+++ b/svl/source/config/cjkoptions.cxx
@@ -34,30 +34,30 @@
 using namespace ::com::sun::star::uno;
 using namespace ::rtl;
 
-#define CFG_READONLY_DEFAULT sal_False
+#define CFG_READONLY_DEFAULT false
 
 class SvtCJKOptions_Impl : public utl::ConfigItem
 {
-    sal_Bool        bIsLoaded;
-    sal_Bool        bCJKFont;
-    sal_Bool        bVerticalText;
-    sal_Bool        bAsianTypography;
-    sal_Bool        bJapaneseFind;
-    sal_Bool        bRuby;
-    sal_Bool        bChangeCaseMap;
-    sal_Bool        bDoubleLines;
-    sal_Bool        bEmphasisMarks;
-    sal_Bool        bVerticalCallOut;
-
-    sal_Bool        bROCJKFont;
-    sal_Bool        bROVerticalText;
-    sal_Bool        bROAsianTypography;
-    sal_Bool        bROJapaneseFind;
-    sal_Bool        bRORuby;
-    sal_Bool        bROChangeCaseMap;
-    sal_Bool        bRODoubleLines;
-    sal_Bool        bROEmphasisMarks;
-    sal_Bool        bROVerticalCallOut;
+    bool        bIsLoaded;
+    bool        bCJKFont;
+    bool        bVerticalText;
+    bool        bAsianTypography;
+    bool        bJapaneseFind;
+    bool        bRuby;
+    bool        bChangeCaseMap;
+    bool        bDoubleLines;
+    bool        bEmphasisMarks;
+    bool        bVerticalCallOut;
+
+    bool        bROCJKFont;
+    bool        bROVerticalText;
+    bool        bROAsianTypography;
+    bool        bROJapaneseFind;
+    bool        bRORuby;
+    bool        bROChangeCaseMap;
+    bool        bRODoubleLines;
+    bool        bROEmphasisMarks;
+    bool        bROVerticalCallOut;
 
 public:
     SvtCJKOptions_Impl();
@@ -67,21 +67,21 @@ public:
     virtual void    Commit();
     void            Load();
 
-    sal_Bool IsLoaded()                         { return bIsLoaded;         }
+    bool IsLoaded()                         { return bIsLoaded;         }
 
-    sal_Bool IsCJKFontEnabled() const           { return bCJKFont;          }
-    sal_Bool IsVerticalTextEnabled() const      { return bVerticalText;     }
-    sal_Bool IsAsianTypographyEnabled() const   { return bAsianTypography;  }
-    sal_Bool IsJapaneseFindEnabled() const      { return bJapaneseFind;     }
-    sal_Bool IsRubyEnabled() const              { return bRuby;             }
-    sal_Bool IsChangeCaseMapEnabled() const     { return bChangeCaseMap;    }
-    sal_Bool IsDoubleLinesEnabled() const       { return bDoubleLines;      }
+    bool IsCJKFontEnabled() const           { return bCJKFont;          }
+    bool IsVerticalTextEnabled() const      { return bVerticalText;     }
+    bool IsAsianTypographyEnabled() const   { return bAsianTypography;  }
+    bool IsJapaneseFindEnabled() const      { return bJapaneseFind;     }
+    bool IsRubyEnabled() const              { return bRuby;             }
+    bool IsChangeCaseMapEnabled() const     { return bChangeCaseMap;    }
+    bool IsDoubleLinesEnabled() const       { return bDoubleLines;      }
 
-    sal_Bool IsAnyEnabled() const {
+    bool IsAnyEnabled() const {
         return  bCJKFont||bVerticalText||bAsianTypography||bJapaneseFind||
                 bRuby||bChangeCaseMap||bDoubleLines||bEmphasisMarks||bVerticalCallOut;   }
-    void    SetAll(sal_Bool bSet);
-    sal_Bool IsReadOnly(SvtCJKOptions::EOption eOption) const;
+    void    SetAll(bool bSet);
+    bool IsReadOnly(SvtCJKOptions::EOption eOption) const;
 };
 
 namespace
@@ -92,16 +92,16 @@ namespace
 
 SvtCJKOptions_Impl::SvtCJKOptions_Impl() :
     utl::ConfigItem("Office.Common/I18N/CJK"),
-    bIsLoaded(sal_False),
-    bCJKFont(sal_True),
-    bVerticalText(sal_True),
-    bAsianTypography(sal_True),
-    bJapaneseFind(sal_True),
-    bRuby(sal_True),
-    bChangeCaseMap(sal_True),
-    bDoubleLines(sal_True),
-    bEmphasisMarks(sal_True),
-    bVerticalCallOut(sal_True),
+    bIsLoaded(false),
+    bCJKFont(true),
+    bVerticalText(true),
+    bAsianTypography(true),
+    bJapaneseFind(true),
+    bRuby(true),
+    bChangeCaseMap(true),
+    bDoubleLines(true),
+    bEmphasisMarks(true),
+    bVerticalCallOut(true),
     bROCJKFont(CFG_READONLY_DEFAULT),
     bROVerticalText(CFG_READONLY_DEFAULT),
     bROAsianTypography(CFG_READONLY_DEFAULT),
@@ -118,7 +118,7 @@ SvtCJKOptions_Impl::~SvtCJKOptions_Impl()
 {
 }
 
-void    SvtCJKOptions_Impl::SetAll(sal_Bool bSet)
+void    SvtCJKOptions_Impl::SetAll(bool bSet)
 {
     if (
         !bROCJKFont          &&
@@ -180,7 +180,7 @@ void SvtCJKOptions_Impl::Load()
         {
             if( pValues[nProp].hasValue() )
             {
-                sal_Bool bValue = *(sal_Bool*)pValues[nProp].getValue();
+                bool bValue = *(sal_Bool*)pValues[nProp].getValue();
                 switch ( nProp )
                 {
                     case 0: { bCJKFont = bValue; bROCJKFont = pROStates[nProp]; } break;
@@ -224,10 +224,10 @@ void SvtCJKOptions_Impl::Load()
 
         if (bAutoEnableCJK)
         {
-            SetAll(sal_True);
+            SetAll(true);
         }
     }
-    bIsLoaded = sal_True;
+    bIsLoaded = true;
 }
 
 void    SvtCJKOptions_Impl::Notify( const Sequence< OUString >& )
@@ -359,9 +359,9 @@ void    SvtCJKOptions_Impl::Commit()
     PutProperties(aNames, aValues);
 }
 
-sal_Bool SvtCJKOptions_Impl::IsReadOnly(SvtCJKOptions::EOption eOption) const
+bool SvtCJKOptions_Impl::IsReadOnly(SvtCJKOptions::EOption eOption) const
 {
-    sal_Bool bReadOnly = CFG_READONLY_DEFAULT;
+    bool bReadOnly = CFG_READONLY_DEFAULT;
     switch(eOption)
     {
         case SvtCJKOptions::E_CJKFONT : bReadOnly = bROCJKFont; break;
@@ -374,7 +374,7 @@ sal_Bool SvtCJKOptions_Impl::IsReadOnly(SvtCJKOptions::EOption eOption) const
         case SvtCJKOptions::E_EMPHASISMARKS : bReadOnly = bROEmphasisMarks; break;
         case SvtCJKOptions::E_VERTICALCALLOUT : bReadOnly = bROVerticalCallOut; break;
         case SvtCJKOptions::E_ALL : if (bROCJKFont || bROVerticalText || bROAsianTypography || bROJapaneseFind || bRORuby || bROChangeCaseMap || bRODoubleLines || bROEmphasisMarks || bROVerticalCallOut)
-                                        bReadOnly = sal_True;
+                                        bReadOnly = true;
                                 break;
     }
     return bReadOnly;
@@ -389,7 +389,7 @@ namespace { struct theCJKOptionsMutex : public rtl::Static< ::osl::Mutex , theCJ
 
 // class SvtCJKOptions --------------------------------------------------
 
-SvtCJKOptions::SvtCJKOptions(sal_Bool bDontLoad)
+SvtCJKOptions::SvtCJKOptions(bool bDontLoad)
 {
     // Global access, must be guarded (multithreading)
     ::osl::MutexGuard aGuard( theCJKOptionsMutex::get() );
@@ -415,61 +415,61 @@ SvtCJKOptions::~SvtCJKOptions()
         DELETEZ( pCJKOptions );
 }
 // -----------------------------------------------------------------------
-sal_Bool SvtCJKOptions::IsCJKFontEnabled() const
+bool SvtCJKOptions::IsCJKFontEnabled() const
 {
     DBG_ASSERT(pCJKOptions->IsLoaded(), "CJK options not loaded");
     return pCJKOptions->IsCJKFontEnabled();
 }
 // -----------------------------------------------------------------------
-sal_Bool SvtCJKOptions::IsVerticalTextEnabled() const
+bool SvtCJKOptions::IsVerticalTextEnabled() const
 {
     DBG_ASSERT(pCJKOptions->IsLoaded(), "CJK options not loaded");
     return pCJKOptions->IsVerticalTextEnabled();
 }
 // -----------------------------------------------------------------------
-sal_Bool SvtCJKOptions::IsAsianTypographyEnabled() const
+bool SvtCJKOptions::IsAsianTypographyEnabled() const
 {
     DBG_ASSERT(pCJKOptions->IsLoaded(), "CJK options not loaded");
     return pCJKOptions->IsAsianTypographyEnabled();
 }
 // -----------------------------------------------------------------------
-sal_Bool SvtCJKOptions::IsJapaneseFindEnabled() const
+bool SvtCJKOptions::IsJapaneseFindEnabled() const
 {
     DBG_ASSERT(pCJKOptions->IsLoaded(), "CJK options not loaded");
     return pCJKOptions->IsJapaneseFindEnabled();
 }
 // -----------------------------------------------------------------------
-sal_Bool SvtCJKOptions::IsRubyEnabled() const
+bool SvtCJKOptions::IsRubyEnabled() const
 {
     DBG_ASSERT(pCJKOptions->IsLoaded(), "CJK options not loaded");
     return pCJKOptions->IsRubyEnabled();
 }
 // -----------------------------------------------------------------------
-sal_Bool SvtCJKOptions::IsChangeCaseMapEnabled() const
+bool SvtCJKOptions::IsChangeCaseMapEnabled() const
 {
     DBG_ASSERT(pCJKOptions->IsLoaded(), "CJK options not loaded");
     return pCJKOptions->IsChangeCaseMapEnabled();
 }
 // -----------------------------------------------------------------------
-sal_Bool SvtCJKOptions::IsDoubleLinesEnabled() const
+bool SvtCJKOptions::IsDoubleLinesEnabled() const
 {
     DBG_ASSERT(pCJKOptions->IsLoaded(), "CJK options not loaded");
     return pCJKOptions->IsDoubleLinesEnabled();
 }
 
-void        SvtCJKOptions::SetAll(sal_Bool bSet)
+void        SvtCJKOptions::SetAll(bool bSet)
 {
     DBG_ASSERT(pCJKOptions->IsLoaded(), "CJK options not loaded");
     pCJKOptions->SetAll(bSet);
 }
 
-sal_Bool    SvtCJKOptions::IsAnyEnabled() const
+bool    SvtCJKOptions::IsAnyEnabled() const
 {
     DBG_ASSERT(pCJKOptions->IsLoaded(), "CJK options not loaded");
     return pCJKOptions->IsAnyEnabled();
 }
 
-sal_Bool    SvtCJKOptions::IsReadOnly(EOption eOption) const
+bool    SvtCJKOptions::IsReadOnly(EOption eOption) const
 {
     DBG_ASSERT(pCJKOptions->IsLoaded(), "CJK options not loaded");
     return pCJKOptions->IsReadOnly(eOption);
diff --git a/svl/source/config/ctloptions.cxx b/svl/source/config/ctloptions.cxx
index bbad8e9e14f0..561f2f59e20b 100644
--- a/svl/source/config/ctloptions.cxx
+++ b/svl/source/config/ctloptions.cxx
@@ -255,7 +255,7 @@ void SvtCTLOptions_Impl::Load()
     DBG_ASSERT( aROStates.getLength() == rPropertyNames.getLength(), "GetReadOnlyStates failed" );
     if ( aValues.getLength() == rPropertyNames.getLength() && aROStates.getLength() == rPropertyNames.getLength() )
     {
-        sal_Bool bValue = sal_False;
+        bool bValue = false;
         sal_Int32 nValue = 0;
 
         for ( int nProp = 0; nProp < rPropertyNames.getLength(); nProp++ )
diff --git a/svl/source/config/languageoptions.cxx b/svl/source/config/languageoptions.cxx
index 9bebe8afe0b0..0bdfea1af765 100644
--- a/svl/source/config/languageoptions.cxx
+++ b/svl/source/config/languageoptions.cxx
@@ -39,7 +39,7 @@ namespace { struct ALMutex : public rtl::Static< ::osl::Mutex, ALMutex > {}; }
 
 // class SvtLanguageOptions ----------------------------------------------------
 
-SvtLanguageOptions::SvtLanguageOptions( sal_Bool _bDontLoad )
+SvtLanguageOptions::SvtLanguageOptions( bool _bDontLoad )
 {
     // Global access, must be guarded (multithreading)
     ::osl::MutexGuard aGuard( ALMutex::get() );
@@ -61,57 +61,57 @@ SvtLanguageOptions::~SvtLanguageOptions()
     delete m_pCTLOptions;
 }
 // CJK options -----------------------------------------------------------------
-sal_Bool SvtLanguageOptions::IsCJKFontEnabled() const
+bool SvtLanguageOptions::IsCJKFontEnabled() const
 {
     return m_pCJKOptions->IsCJKFontEnabled();
 }
-sal_Bool SvtLanguageOptions::IsVerticalTextEnabled() const
+bool SvtLanguageOptions::IsVerticalTextEnabled() const
 {
     return m_pCJKOptions->IsVerticalTextEnabled();
 }
-sal_Bool SvtLanguageOptions::IsAsianTypographyEnabled() const
+bool SvtLanguageOptions::IsAsianTypographyEnabled() const
 {
     return m_pCJKOptions->IsAsianTypographyEnabled();
 }
-sal_Bool SvtLanguageOptions::IsJapaneseFindEnabled() const
+bool SvtLanguageOptions::IsJapaneseFindEnabled() const
 {
     return m_pCJKOptions->IsJapaneseFindEnabled();
 }
-void SvtLanguageOptions::SetAll( sal_Bool _bSet )
+void SvtLanguageOptions::SetAll( bool _bSet )
 {
     m_pCJKOptions->SetAll( _bSet );
 }
-sal_Bool SvtLanguageOptions::IsAnyEnabled() const
+bool SvtLanguageOptions::IsAnyEnabled() const
 {
     return m_pCJKOptions->IsAnyEnabled();
 }
 // CTL options -----------------------------------------------------------------
-void SvtLanguageOptions::SetCTLFontEnabled( sal_Bool _bEnabled )
+void SvtLanguageOptions::SetCTLFontEnabled( bool _bEnabled )
 {
     m_pCTLOptions->SetCTLFontEnabled( _bEnabled );
 }
-sal_Bool SvtLanguageOptions::IsCTLFontEnabled() const
+bool SvtLanguageOptions::IsCTLFontEnabled() const
 {
     return m_pCTLOptions->IsCTLFontEnabled();
 }
-void SvtLanguageOptions::SetCTLSequenceChecking( sal_Bool _bEnabled )
+void SvtLanguageOptions::SetCTLSequenceChecking( bool _bEnabled )
 {
     m_pCTLOptions->SetCTLSequenceChecking( _bEnabled );
 }
 
-void SvtLanguageOptions::SetCTLSequenceCheckingRestricted( sal_Bool _bEnable )
+void SvtLanguageOptions::SetCTLSequenceCheckingRestricted( bool _bEnable )
 {
     m_pCTLOptions->SetCTLSequenceCheckingRestricted( _bEnable );
 }
 
-void SvtLanguageOptions::SetCTLSequenceCheckingTypeAndReplace( sal_Bool _bEnable )
+void SvtLanguageOptions::SetCTLSequenceCheckingTypeAndReplace( bool _bEnable )
 {
     m_pCTLOptions->SetCTLSequenceCheckingTypeAndReplace( _bEnable );
 }
 
-sal_Bool SvtLanguageOptions::IsReadOnly(SvtLanguageOptions::EOption eOption) const
+bool SvtLanguageOptions::IsReadOnly(SvtLanguageOptions::EOption eOption) const
 {
-    sal_Bool bReadOnly = sal_False;
+    bool bReadOnly = false;
     switch(eOption)
     {
         // cjk options