/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_svl.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace ::com::sun::star; using namespace ::com::sun::star::uno; #define ASCII_STR(s) rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(s) ) #define CFG_READONLY_DEFAULT sal_False // SvtCJKOptions_Impl ---------------------------------------------------------- class SvtCTLOptions_Impl : public utl::ConfigItem { private: sal_Bool m_bIsLoaded; sal_Bool m_bCTLFontEnabled; sal_Bool m_bCTLSequenceChecking; sal_Bool m_bCTLRestricted; sal_Bool m_bCTLTypeAndReplace; SvtCTLOptions::CursorMovement m_eCTLCursorMovement; SvtCTLOptions::TextNumerals m_eCTLTextNumerals; sal_Bool m_bROCTLFontEnabled; sal_Bool m_bROCTLSequenceChecking; sal_Bool m_bROCTLRestricted; sal_Bool m_bROCTLTypeAndReplace; sal_Bool m_bROCTLCursorMovement; sal_Bool m_bROCTLTextNumerals; public: SvtCTLOptions_Impl(); ~SvtCTLOptions_Impl(); virtual void Notify( const Sequence< rtl::OUString >& _aPropertyNames ); virtual void Commit(); void Load(); sal_Bool IsLoaded() { return m_bIsLoaded; } void SetCTLFontEnabled( sal_Bool _bEnabled ); sal_Bool IsCTLFontEnabled() const { return m_bCTLFontEnabled; } void SetCTLSequenceChecking( sal_Bool _bEnabled ); sal_Bool IsCTLSequenceChecking() const { return m_bCTLSequenceChecking;} void SetCTLSequenceCheckingRestricted( sal_Bool _bEnable ); sal_Bool IsCTLSequenceCheckingRestricted( void ) const { return m_bCTLRestricted; } void SetCTLSequenceCheckingTypeAndReplace( sal_Bool _bEnable ); sal_Bool IsCTLSequenceCheckingTypeAndReplace() const { return m_bCTLTypeAndReplace; } void SetCTLCursorMovement( SvtCTLOptions::CursorMovement _eMovement ); SvtCTLOptions::CursorMovement GetCTLCursorMovement() const { return m_eCTLCursorMovement; } void SetCTLTextNumerals( SvtCTLOptions::TextNumerals _eNumerals ); SvtCTLOptions::TextNumerals GetCTLTextNumerals() const { return m_eCTLTextNumerals; } sal_Bool IsReadOnly(SvtCTLOptions::EOption eOption) const; }; //------------------------------------------------------------------------------ namespace { struct PropertyNames : public rtl::Static< Sequence< rtl::OUString >, PropertyNames > {}; } //------------------------------------------------------------------------------ sal_Bool SvtCTLOptions_Impl::IsReadOnly(SvtCTLOptions::EOption eOption) const { sal_Bool bReadOnly = CFG_READONLY_DEFAULT; switch(eOption) { case SvtCTLOptions::E_CTLFONT : bReadOnly = m_bROCTLFontEnabled ; break; case SvtCTLOptions::E_CTLSEQUENCECHECKING : bReadOnly = m_bROCTLSequenceChecking ; break; case SvtCTLOptions::E_CTLCURSORMOVEMENT : bReadOnly = m_bROCTLCursorMovement ; break; case SvtCTLOptions::E_CTLTEXTNUMERALS : bReadOnly = m_bROCTLTextNumerals ; break; case SvtCTLOptions::E_CTLSEQUENCECHECKINGRESTRICTED: bReadOnly = m_bROCTLRestricted ; break; case SvtCTLOptions::E_CTLSEQUENCECHECKINGTYPEANDREPLACE: bReadOnly = m_bROCTLTypeAndReplace; break; default: DBG_ERROR( "SvtCTLOptions_Impl::IsReadOnly() - invalid option" ); } return bReadOnly; } //------------------------------------------------------------------------------ SvtCTLOptions_Impl::SvtCTLOptions_Impl() : utl::ConfigItem( ASCII_STR("Office.Common/I18N/CTL") ), m_bIsLoaded ( sal_False ), m_bCTLFontEnabled ( sal_False ), m_bCTLSequenceChecking ( sal_False ), m_bCTLRestricted ( sal_False ), m_eCTLCursorMovement ( SvtCTLOptions::MOVEMENT_LOGICAL ), m_eCTLTextNumerals ( SvtCTLOptions::NUMERALS_ARABIC ), m_bROCTLFontEnabled ( CFG_READONLY_DEFAULT ), m_bROCTLSequenceChecking( CFG_READONLY_DEFAULT ), m_bROCTLRestricted ( CFG_READONLY_DEFAULT ), m_bROCTLCursorMovement ( CFG_READONLY_DEFAULT ), m_bROCTLTextNumerals ( CFG_READONLY_DEFAULT ) { } //------------------------------------------------------------------------------ SvtCTLOptions_Impl::~SvtCTLOptions_Impl() { if ( IsModified() == sal_True ) Commit(); } // ----------------------------------------------------------------------------- void SvtCTLOptions_Impl::Notify( const Sequence< rtl::OUString >& ) { Load(); NotifyListeners(SFX_HINT_CTL_SETTINGS_CHANGED); } // ----------------------------------------------------------------------------- void SvtCTLOptions_Impl::Commit() { Sequence< rtl::OUString > &rPropertyNames = PropertyNames::get(); rtl::OUString* pOrgNames = rPropertyNames.getArray(); sal_Int32 nOrgCount = rPropertyNames.getLength(); Sequence< rtl::OUString > aNames( nOrgCount ); Sequence< Any > aValues( nOrgCount ); rtl::OUString* pNames = aNames.getArray(); Any* pValues = aValues.getArray(); sal_Int32 nRealCount = 0; const uno::Type& rType = ::getBooleanCppuType(); for ( int nProp = 0; nProp < nOrgCount; nProp++ ) { switch ( nProp ) { case 0: { if (!m_bROCTLFontEnabled) { pNames[nRealCount] = pOrgNames[nProp]; pValues[nRealCount].setValue( &m_bCTLFontEnabled, rType ); ++nRealCount; } } break; case 1: { if (!m_bROCTLSequenceChecking) { pNames[nRealCount] = pOrgNames[nProp]; pValues[nRealCount].setValue( &m_bCTLSequenceChecking, rType ); ++nRealCount; } } break; case 2: { if (!m_bROCTLCursorMovement) { pNames[nRealCount] = pOrgNames[nProp]; pValues[nRealCount] <<= (sal_Int32)m_eCTLCursorMovement; ++nRealCount; } } break; case 3: { if (!m_bROCTLTextNumerals) { pNames[nRealCount] = pOrgNames[nProp]; pValues[nRealCount] <<= (sal_Int32)m_eCTLTextNumerals; ++nRealCount; } } break; case 4: { if (!m_bROCTLRestricted) { pNames[nRealCount] = pOrgNames[nProp]; pValues[nRealCount].setValue( &m_bCTLRestricted, rType ); ++nRealCount; } } break; case 5: { if(!m_bROCTLTypeAndReplace) { pNames[nRealCount] = pOrgNames[nProp]; pValues[nRealCount].setValue( &m_bCTLTypeAndReplace, rType ); ++nRealCount; } } break; } } aNames.realloc(nRealCount); aValues.realloc(nRealCount); PutProperties( aNames, aValues ); //broadcast changes NotifyListeners(SFX_HINT_CTL_SETTINGS_CHANGED); } // ----------------------------------------------------------------------------- void SvtCTLOptions_Impl::Load() { Sequence< rtl::OUString >& rPropertyNames = PropertyNames::get(); if ( !rPropertyNames.getLength() ) { rPropertyNames.realloc(6); rtl::OUString* pNames = rPropertyNames.getArray(); pNames[0] = ASCII_STR("CTLFont"); pNames[1] = ASCII_STR("CTLSequenceChecking"); pNames[2] = ASCII_STR("CTLCursorMovement"); pNames[3] = ASCII_STR("CTLTextNumerals"); pNames[4] = ASCII_STR("CTLSequenceCheckingRestricted"); pNames[5] = ASCII_STR("CTLSequenceCheckingTypeAndReplace"); EnableNotification( rPropertyNames ); } Sequence< Any > aValues = GetProperties( rPropertyNames ); Sequence< sal_Bool > aROStates = GetReadOnlyStates( rPropertyNames ); const Any* pValues = aValues.getConstArray(); const sal_Bool* pROStates = aROStates.getConstArray(); DBG_ASSERT( aValues.getLength() == rPropertyNames.getLength(), "GetProperties failed" ); DBG_ASSERT( aROStates.getLength() == rPropertyNames.getLength(), "GetReadOnlyStates failed" ); if ( aValues.getLength() == rPropertyNames.getLength() && aROStates.getLength() == rPropertyNames.getLength() ) { sal_Bool bValue = sal_False; sal_Int32 nValue = 0; for ( int nProp = 0; nProp < rPropertyNames.getLength(); nProp++ ) { if ( pValues[nProp].hasValue() ) { if ( pValues[nProp] >>= bValue ) { switch ( nProp ) { case 0: { m_bCTLFontEnabled = bValue; m_bROCTLFontEnabled = pROStates[nProp]; } break; case 1: { m_bCTLSequenceChecking = bValue; m_bROCTLSequenceChecking = pROStates[nProp]; } break; case 4: { m_bCTLRestricted = bValue; m_bROCTLRestricted = pROStates[nProp]; } break; case 5: { m_bCTLTypeAndReplace = bValue; m_bROCTLTypeAndReplace = pROStates[nProp]; } break; } } else if ( pValues[nProp] >>= nValue ) { switch ( nProp ) { case 2: { m_eCTLCursorMovement = (SvtCTLOptions::CursorMovement)nValue; m_bROCTLCursorMovement = pROStates[nProp]; } break; case 3: { m_eCTLTextNumerals = (SvtCTLOptions::TextNumerals)nValue; m_bROCTLTextNumerals = pROStates[nProp]; } break; } } } } } sal_uInt16 nType = SvtLanguageOptions::GetScriptTypeOfLanguage(LANGUAGE_SYSTEM); SvtSystemLanguageOptions aSystemLocaleSettings; LanguageType eSystemLanguage = aSystemLocaleSettings.GetWin16SystemLanguage(); sal_uInt16 nWinScript = SvtLanguageOptions::GetScriptTypeOfLanguage( eSystemLanguage ); if( !m_bCTLFontEnabled && (( nType & SCRIPTTYPE_COMPLEX ) || ((eSystemLanguage != LANGUAGE_SYSTEM) && ( nWinScript & SCRIPTTYPE_COMPLEX ))) ) { m_bCTLFontEnabled = sal_True; sal_uInt16 nLanguage = SvtSysLocale().GetLanguage(); //enable sequence checking for the appropriate languages m_bCTLSequenceChecking = m_bCTLRestricted = m_bCTLTypeAndReplace = (MsLangId::needsSequenceChecking( nLanguage) || MsLangId::needsSequenceChecking( eSystemLanguage)); Commit(); } m_bIsLoaded = sal_True; } //------------------------------------------------------------------------------ void SvtCTLOptions_Impl::SetCTLFontEnabled( sal_Bool _bEnabled ) { if(!m_bROCTLFontEnabled && m_bCTLFontEnabled != _bEnabled) { m_bCTLFontEnabled = _bEnabled; SetModified(); NotifyListeners(0); } } //------------------------------------------------------------------------------ void SvtCTLOptions_Impl::SetCTLSequenceChecking( sal_Bool _bEnabled ) { if(!m_bROCTLSequenceChecking && m_bCTLSequenceChecking != _bEnabled) { SetModified(); m_bCTLSequenceChecking = _bEnabled; NotifyListeners(0); } } //------------------------------------------------------------------------------ void SvtCTLOptions_Impl::SetCTLSequenceCheckingRestricted( sal_Bool _bEnabled ) { if(!m_bROCTLRestricted && m_bCTLRestricted != _bEnabled) { SetModified(); m_bCTLRestricted = _bEnabled; NotifyListeners(0); } } //------------------------------------------------------------------------------ void SvtCTLOptions_Impl::SetCTLSequenceCheckingTypeAndReplace( sal_Bool _bEnabled ) { if(!m_bROCTLTypeAndReplace && m_bCTLTypeAndReplace != _bEnabled) { SetModified(); m_bCTLTypeAndReplace = _bEnabled; NotifyListeners(0); } } //------------------------------------------------------------------------------ void SvtCTLOptions_Impl::SetCTLCursorMovement( SvtCTLOptions::CursorMovement _eMovement ) { if (!m_bROCTLCursorMovement && m_eCTLCursorMovement != _eMovement ) { SetModified(); m_eCTLCursorMovement = _eMovement; NotifyListeners(0); } } //------------------------------------------------------------------------------ void SvtCTLOptions_Impl::SetCTLTextNumerals( SvtCTLOptions::TextNumerals _eNumerals ) { if (!m_bROCTLTextNumerals && m_eCTLTextNumerals != _eNumerals ) { SetModified(); m_eCTLTextNumerals = _eNumerals; NotifyListeners(0); } } // global ---------------------------------------------------------------- static SvtCTLOptions_Impl* pCTLOptions = NULL; static sal_Int32 nCTLRefCount = 0; namespace { struct CTLMutex : public rtl::Static< osl::Mutex, CTLMutex > {}; } // class SvtCTLOptions -------------------------------------------------- SvtCTLOptions::SvtCTLOptions( sal_Bool bDontLoad ) { // Global access, must be guarded (multithreading) ::osl::MutexGuard aGuard( CTLMutex::get() ); if ( !pCTLOptions ) { pCTLOptions = new SvtCTLOptions_Impl; ItemHolder2::holdConfigItem(E_CTLOPTIONS); } if( !bDontLoad && !pCTLOptions->IsLoaded() ) pCTLOptions->Load(); ++nCTLRefCount; m_pImp = pCTLOptions; m_pImp->AddListener(this); } // ----------------------------------------------------------------------- SvtCTLOptions::~SvtCTLOptions() { // Global access, must be guarded (multithreading) ::osl::MutexGuard aGuard( CTLMutex::get() ); m_pImp->RemoveListener(this); if ( !--nCTLRefCount ) DELETEZ( pCTLOptions ); } // ----------------------------------------------------------------------------- void SvtCTLOptions::SetCTLFontEnabled( sal_Bool _bEnabled ) { DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" ); pCTLOptions->SetCTLFontEnabled( _bEnabled ); } // ----------------------------------------------------------------------------- sal_Bool SvtCTLOptions::IsCTLFontEnabled() const { DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" ); return pCTLOptions->IsCTLFontEnabled(); } // ----------------------------------------------------------------------------- void SvtCTLOptions::SetCTLSequenceChecking( sal_Bool _bEnabled ) { DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" ); pCTLOptions->SetCTLSequenceChecking(_bEnabled); } // ----------------------------------------------------------------------------- sal_Bool SvtCTLOptions::IsCTLSequenceChecking() const { DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" ); return pCTLOptions->IsCTLSequenceChecking(); } // ----------------------------------------------------------------------------- void SvtCTLOptions::SetCTLSequenceCheckingRestricted( sal_Bool _bEnable ) { DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" ); pCTLOptions->SetCTLSequenceCheckingRestricted(_bEnable); } // ----------------------------------------------------------------------------- sal_Bool SvtCTLOptions::IsCTLSequenceCheckingRestricted( void ) const { DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" ); return pCTLOptions->IsCTLSequenceCheckingRestricted(); } // ----------------------------------------------------------------------------- void SvtCTLOptions::SetCTLSequenceCheckingTypeAndReplace( sal_Bool _bEnable ) { DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" ); pCTLOptions->SetCTLSequenceCheckingTypeAndReplace(_bEnable); } // ----------------------------------------------------------------------------- sal_Bool SvtCTLOptions::IsCTLSequenceCheckingTypeAndReplace() const { DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" ); return pCTLOptions->IsCTLSequenceCheckingTypeAndReplace(); } // ----------------------------------------------------------------------------- void SvtCTLOptions::SetCTLCursorMovement( SvtCTLOptions::CursorMovement _eMovement ) { DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" ); pCTLOptions->SetCTLCursorMovement( _eMovement ); } // ----------------------------------------------------------------------------- SvtCTLOptions::CursorMovement SvtCTLOptions::GetCTLCursorMovement() const { DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" ); return pCTLOptions->GetCTLCursorMovement(); } // ----------------------------------------------------------------------------- void SvtCTLOptions::SetCTLTextNumerals( SvtCTLOptions::TextNumerals _eNumerals ) { DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" ); pCTLOptions->SetCTLTextNumerals( _eNumerals ); } // ----------------------------------------------------------------------------- SvtCTLOptions::TextNumerals SvtCTLOptions::GetCTLTextNumerals() const { DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" ); return pCTLOptions->GetCTLTextNumerals(); } // ----------------------------------------------------------------------------- sal_Bool SvtCTLOptions::IsReadOnly(EOption eOption) const { DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" ); return pCTLOptions->IsReadOnly(eOption); } // -----------------------------------------------------------------------------