| /************************************************************** |
| * |
| * 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_unotools.hxx" |
| |
| #include <unotools/searchopt.hxx> |
| #include <tools/solar.h> |
| #include <tools/debug.hxx> |
| #include <unotools/configitem.hxx> |
| #include <com/sun/star/i18n/TransliterationModules.hpp> |
| #include <com/sun/star/uno/Sequence.hxx> |
| #include <com/sun/star/uno/Any.h> |
| #include <rtl/logfile.hxx> |
| |
| |
| using namespace rtl; |
| using namespace utl; |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star::i18n; |
| |
| #define MAX_FLAGS_OFFSET 25 |
| |
| ////////////////////////////////////////////////////////////////////// |
| |
| |
| class SvtSearchOptions_Impl : public ConfigItem |
| { |
| sal_Int32 nFlags; |
| sal_Bool bModified; |
| |
| // disallow copy-constructor and assignment-operator for now |
| SvtSearchOptions_Impl( const SvtSearchOptions_Impl & ); |
| SvtSearchOptions_Impl & operator = ( const SvtSearchOptions_Impl & ); |
| |
| protected: |
| sal_Bool IsModified() const { return bModified; } |
| using ConfigItem::SetModified; |
| void SetModified( sal_Bool bVal ); |
| sal_Bool Load(); |
| sal_Bool Save(); |
| |
| Sequence< OUString > GetPropertyNames() const; |
| |
| public: |
| SvtSearchOptions_Impl(); |
| virtual ~SvtSearchOptions_Impl(); |
| |
| // ConfigItem |
| virtual void Commit(); |
| virtual void Notify( const com::sun::star::uno::Sequence< rtl::OUString >& aPropertyNames ); |
| |
| sal_Bool GetFlag( sal_uInt16 nOffset ) const; |
| void SetFlag( sal_uInt16 nOffset, sal_Bool bVal ); |
| }; |
| |
| |
| |
| SvtSearchOptions_Impl::SvtSearchOptions_Impl() : |
| ConfigItem( OUString::createFromAscii( "Office.Common/SearchOptions" ) ) |
| { |
| RTL_LOGFILE_CONTEXT(aLog, "unotools SvtSearchOptions_Impl::SvtSearchOptions_Impl()"); |
| nFlags = 0x0003FFFF; // set all options values to 'true' |
| Load(); |
| SetModified( sal_False ); |
| } |
| |
| |
| SvtSearchOptions_Impl::~SvtSearchOptions_Impl() |
| { |
| Commit(); |
| } |
| |
| |
| void SvtSearchOptions_Impl::Commit() |
| { |
| if (IsModified()) |
| Save(); |
| } |
| |
| void SvtSearchOptions_Impl::Notify( const Sequence< rtl::OUString >& ) |
| { |
| } |
| |
| |
| sal_Bool SvtSearchOptions_Impl::GetFlag( sal_uInt16 nOffset ) const |
| { |
| DBG_ASSERT( nOffset <= MAX_FLAGS_OFFSET, "offset out of range"); |
| return ((nFlags >> nOffset) & 0x01) ? sal_True : sal_False; |
| } |
| |
| |
| void SvtSearchOptions_Impl::SetFlag( sal_uInt16 nOffset, sal_Bool bVal ) |
| { |
| DBG_ASSERT( nOffset <= MAX_FLAGS_OFFSET, "offset out of range"); |
| sal_Int32 nOldFlags = nFlags; |
| sal_Int32 nMask = ((sal_Int32) 1) << nOffset; |
| if (bVal) |
| nFlags |= nMask; |
| else |
| nFlags &= ~nMask; |
| if (nFlags != nOldFlags) |
| SetModified( sal_True ); |
| } |
| |
| |
| void SvtSearchOptions_Impl::SetModified( sal_Bool bVal ) |
| { |
| bModified = bVal; |
| if (bModified) |
| { |
| ConfigItem::SetModified(); |
| } |
| } |
| |
| |
| Sequence< OUString > SvtSearchOptions_Impl::GetPropertyNames() const |
| { |
| static const char* aPropNames[ MAX_FLAGS_OFFSET + 1 ] = |
| { |
| "IsWholeWordsOnly", // 0 |
| "IsBackwards", // 1 |
| "IsUseRegularExpression", // 2 |
| //"IsCurrentSelectionOnly", // interactively set or not... |
| "IsSearchForStyles", // 3 |
| "IsSimilaritySearch", // 4 |
| "IsUseAsianOptions", // 5 |
| "IsMatchCase", // 6 |
| "Japanese/IsMatchFullHalfWidthForms", // 7 |
| "Japanese/IsMatchHiraganaKatakana", // 8 |
| "Japanese/IsMatchContractions", // 9 |
| "Japanese/IsMatchMinusDashCho-on", // 10 |
| "Japanese/IsMatchRepeatCharMarks", // 11 |
| "Japanese/IsMatchVariantFormKanji", // 12 |
| "Japanese/IsMatchOldKanaForms", // 13 |
| "Japanese/IsMatch_DiZi_DuZu", // 14 |
| "Japanese/IsMatch_BaVa_HaFa", // 15 |
| "Japanese/IsMatch_TsiThiChi_DhiZi", // 16 |
| "Japanese/IsMatch_HyuIyu_ByuVyu", // 17 |
| "Japanese/IsMatch_SeShe_ZeJe", // 18 |
| "Japanese/IsMatch_IaIya", // 19 |
| "Japanese/IsMatch_KiKu", // 20 |
| "Japanese/IsIgnorePunctuation", // 21 |
| "Japanese/IsIgnoreWhitespace", // 22 |
| "Japanese/IsIgnoreProlongedSoundMark", // 23 |
| "Japanese/IsIgnoreMiddleDot", // 24 |
| "IsNotes" // 25 |
| }; |
| |
| const int nCount = sizeof( aPropNames ) / sizeof( aPropNames[0] ); |
| Sequence< OUString > aNames( nCount ); |
| OUString* pNames = aNames.getArray(); |
| for (sal_Int32 i = 0; i < nCount; ++i) |
| pNames[i] = OUString::createFromAscii( aPropNames[i] ); |
| |
| return aNames; |
| } |
| |
| |
| sal_Bool SvtSearchOptions_Impl::Load() |
| { |
| sal_Bool bSucc = sal_False; |
| |
| Sequence< OUString > aNames = GetPropertyNames(); |
| sal_Int32 nProps = aNames.getLength(); |
| |
| const Sequence< Any > aValues = GetProperties( aNames ); |
| DBG_ASSERT( aValues.getLength() == aNames.getLength(), |
| "GetProperties failed" ); |
| //EnableNotification( aNames ); |
| |
| if (nProps && aValues.getLength() == nProps) |
| { |
| bSucc = sal_True; |
| |
| const Any* pValues = aValues.getConstArray(); |
| for (sal_uInt16 i = 0; i < nProps; ++i) |
| { |
| const Any &rVal = pValues[i]; |
| DBG_ASSERT( rVal.hasValue(), "property value missing" ); |
| if (rVal.hasValue()) |
| { |
| sal_Bool bVal = sal_Bool(); |
| if (rVal >>= bVal) |
| { |
| if (i <= MAX_FLAGS_OFFSET) |
| { |
| // use index in sequence as flag index |
| SetFlag( i, bVal ); |
| } |
| else { |
| DBG_ERROR( "unexpected index" ); |
| } |
| } |
| else |
| { |
| DBG_ERROR( "unexpected type" ); |
| bSucc = sal_False; |
| } |
| } |
| else |
| { |
| DBG_ERROR( "value missing" ); |
| bSucc = sal_False; |
| } |
| } |
| } |
| DBG_ASSERT( bSucc, "LoadConfig failed" ); |
| |
| return bSucc; |
| } |
| |
| |
| sal_Bool SvtSearchOptions_Impl::Save() |
| { |
| sal_Bool bSucc = sal_False; |
| |
| const Sequence< OUString > aNames = GetPropertyNames(); |
| sal_Int32 nProps = aNames.getLength(); |
| |
| Sequence< Any > aValues( nProps ); |
| Any *pValue = aValues.getArray(); |
| |
| DBG_ASSERT( nProps == MAX_FLAGS_OFFSET + 1, |
| "unexpected size of index" ); |
| if (nProps && nProps == MAX_FLAGS_OFFSET + 1) |
| { |
| for (sal_uInt16 i = 0; i < nProps; ++i) |
| pValue[i] <<= (sal_Bool) GetFlag(i); |
| bSucc |= PutProperties( aNames, aValues ); |
| } |
| |
| if (bSucc) |
| SetModified( sal_False ); |
| |
| return bSucc; |
| } |
| |
| |
| ////////////////////////////////////////////////////////////////////// |
| |
| SvtSearchOptions::SvtSearchOptions() |
| { |
| pImpl = new SvtSearchOptions_Impl; |
| } |
| |
| |
| SvtSearchOptions::~SvtSearchOptions() |
| { |
| delete pImpl; |
| } |
| |
| |
| sal_Int32 SvtSearchOptions::GetTransliterationFlags() const |
| { |
| sal_Int32 nRes = 0; |
| |
| if (!IsMatchCase()) // 'IsMatchCase' means act case sensitive |
| nRes |= TransliterationModules_IGNORE_CASE; |
| if ( IsMatchFullHalfWidthForms()) |
| nRes |= TransliterationModules_IGNORE_WIDTH; |
| if ( IsMatchHiraganaKatakana()) |
| nRes |= TransliterationModules_IGNORE_KANA; |
| if ( IsMatchContractions()) |
| nRes |= TransliterationModules_ignoreSize_ja_JP; |
| if ( IsMatchMinusDashChoon()) |
| nRes |= TransliterationModules_ignoreMinusSign_ja_JP; |
| if ( IsMatchRepeatCharMarks()) |
| nRes |= TransliterationModules_ignoreIterationMark_ja_JP; |
| if ( IsMatchVariantFormKanji()) |
| nRes |= TransliterationModules_ignoreTraditionalKanji_ja_JP; |
| if ( IsMatchOldKanaForms()) |
| nRes |= TransliterationModules_ignoreTraditionalKana_ja_JP; |
| if ( IsMatchDiziDuzu()) |
| nRes |= TransliterationModules_ignoreZiZu_ja_JP; |
| if ( IsMatchBavaHafa()) |
| nRes |= TransliterationModules_ignoreBaFa_ja_JP; |
| if ( IsMatchTsithichiDhizi()) |
| nRes |= TransliterationModules_ignoreTiJi_ja_JP; |
| if ( IsMatchHyuiyuByuvyu()) |
| nRes |= TransliterationModules_ignoreHyuByu_ja_JP; |
| if ( IsMatchSesheZeje()) |
| nRes |= TransliterationModules_ignoreSeZe_ja_JP; |
| if ( IsMatchIaiya()) |
| nRes |= TransliterationModules_ignoreIandEfollowedByYa_ja_JP; |
| if ( IsMatchKiku()) |
| nRes |= TransliterationModules_ignoreKiKuFollowedBySa_ja_JP; |
| if ( IsIgnorePunctuation()) |
| nRes |= TransliterationModules_ignoreSeparator_ja_JP; |
| if ( IsIgnoreWhitespace()) |
| nRes |= TransliterationModules_ignoreSpace_ja_JP; |
| if ( IsIgnoreProlongedSoundMark()) |
| nRes |= TransliterationModules_ignoreProlongedSoundMark_ja_JP; |
| if ( IsIgnoreMiddleDot()) |
| nRes |= TransliterationModules_ignoreMiddleDot_ja_JP; |
| |
| return nRes; |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsWholeWordsOnly() const |
| { |
| return pImpl->GetFlag( 0 ); |
| } |
| |
| |
| void SvtSearchOptions::SetWholeWordsOnly( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 0, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsBackwards() const |
| { |
| return pImpl->GetFlag( 1 ); |
| } |
| |
| |
| void SvtSearchOptions::SetBackwards( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 1, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsUseRegularExpression() const |
| { |
| return pImpl->GetFlag( 2 ); |
| } |
| |
| |
| void SvtSearchOptions::SetUseRegularExpression( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 2, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsSearchForStyles() const |
| { |
| return pImpl->GetFlag( 3 ); |
| } |
| |
| |
| void SvtSearchOptions::SetSearchForStyles( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 3, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsSimilaritySearch() const |
| { |
| return pImpl->GetFlag( 4 ); |
| } |
| |
| |
| void SvtSearchOptions::SetSimilaritySearch( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 4, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsUseAsianOptions() const |
| { |
| return pImpl->GetFlag( 5 ); |
| } |
| |
| |
| void SvtSearchOptions::SetUseAsianOptions( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 5, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsMatchCase() const |
| { |
| return pImpl->GetFlag( 6 ); |
| } |
| |
| |
| void SvtSearchOptions::SetMatchCase( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 6, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsMatchFullHalfWidthForms() const |
| { |
| return pImpl->GetFlag( 7 ); |
| } |
| |
| |
| void SvtSearchOptions::SetMatchFullHalfWidthForms( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 7, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsMatchHiraganaKatakana() const |
| { |
| return pImpl->GetFlag( 8 ); |
| } |
| |
| |
| void SvtSearchOptions::SetMatchHiraganaKatakana( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 8, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsMatchContractions() const |
| { |
| return pImpl->GetFlag( 9 ); |
| } |
| |
| |
| void SvtSearchOptions::SetMatchContractions( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 9, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsMatchMinusDashChoon() const |
| { |
| return pImpl->GetFlag( 10 ); |
| } |
| |
| |
| void SvtSearchOptions::SetMatchMinusDashChoon( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 10, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsMatchRepeatCharMarks() const |
| { |
| return pImpl->GetFlag( 11 ); |
| } |
| |
| |
| void SvtSearchOptions::SetMatchRepeatCharMarks( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 11, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsMatchVariantFormKanji() const |
| { |
| return pImpl->GetFlag( 12 ); |
| } |
| |
| |
| void SvtSearchOptions::SetMatchVariantFormKanji( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 12, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsMatchOldKanaForms() const |
| { |
| return pImpl->GetFlag( 13 ); |
| } |
| |
| |
| void SvtSearchOptions::SetMatchOldKanaForms( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 13, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsMatchDiziDuzu() const |
| { |
| return pImpl->GetFlag( 14 ); |
| } |
| |
| |
| void SvtSearchOptions::SetMatchDiziDuzu( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 14, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsMatchBavaHafa() const |
| { |
| return pImpl->GetFlag( 15 ); |
| } |
| |
| |
| void SvtSearchOptions::SetMatchBavaHafa( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 15, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsMatchTsithichiDhizi() const |
| { |
| return pImpl->GetFlag( 16 ); |
| } |
| |
| |
| void SvtSearchOptions::SetMatchTsithichiDhizi( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 16, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsMatchHyuiyuByuvyu() const |
| { |
| return pImpl->GetFlag( 17 ); |
| } |
| |
| |
| void SvtSearchOptions::SetMatchHyuiyuByuvyu( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 17, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsMatchSesheZeje() const |
| { |
| return pImpl->GetFlag( 18 ); |
| } |
| |
| |
| void SvtSearchOptions::SetMatchSesheZeje( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 18, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsMatchIaiya() const |
| { |
| return pImpl->GetFlag( 19 ); |
| } |
| |
| |
| void SvtSearchOptions::SetMatchIaiya( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 19, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsMatchKiku() const |
| { |
| return pImpl->GetFlag( 20 ); |
| } |
| |
| |
| void SvtSearchOptions::SetMatchKiku( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 20, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsIgnorePunctuation() const |
| { |
| return pImpl->GetFlag( 21 ); |
| } |
| |
| |
| void SvtSearchOptions::SetIgnorePunctuation( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 21, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsIgnoreWhitespace() const |
| { |
| return pImpl->GetFlag( 22 ); |
| } |
| |
| |
| void SvtSearchOptions::SetIgnoreWhitespace( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 22, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsIgnoreProlongedSoundMark() const |
| { |
| return pImpl->GetFlag( 23 ); |
| } |
| |
| |
| void SvtSearchOptions::SetIgnoreProlongedSoundMark( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 23, bVal ); |
| } |
| |
| |
| sal_Bool SvtSearchOptions::IsIgnoreMiddleDot() const |
| { |
| return pImpl->GetFlag( 24 ); |
| } |
| |
| |
| void SvtSearchOptions::SetIgnoreMiddleDot( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 24, bVal ); |
| } |
| |
| sal_Bool SvtSearchOptions::IsNotes() const |
| { |
| return pImpl->GetFlag( 25 ); |
| } |
| |
| |
| void SvtSearchOptions::SetNotes( sal_Bool bVal ) |
| { |
| pImpl->SetFlag( 25, bVal ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////// |
| |