/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* 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 .
*/
#include <sal/config.h>
#include <unotools/searchopt.hxx>
#include <tools/debug.hxx>
#include <unotools/configitem.hxx>
#include <com/sun/star/uno/Sequence.hxx>
#include <com/sun/star/uno/Any.h>
#include <osl/diagnose.h>
#include <i18nutil/transliteration.hxx>
using namespace utl;
using namespace com::sun::star::uno;
#define MAX_FLAGS_OFFSET 29
class SvtSearchOptions_Impl :
public ConfigItem
{
sal_Int32 nFlags;
bool bModified;
SvtSearchOptions_Impl(
const SvtSearchOptions_Impl&) =
delete;
SvtSearchOptions_Impl&
operator=(
const SvtSearchOptions_Impl&) =
delete;
// ConfigItem
virtual void ImplCommit() override;
protected:
bool IsModified()
const {
return bModified; }
using ConfigItem::SetModified;
void SetModified(
bool bVal );
void Load();
bool Save();
static Sequence< OUString > GetPropertyNames();
public:
SvtSearchOptions_Impl();
virtual ~SvtSearchOptions_Impl() override;
virtual void Notify(
const css::uno::Sequence< OUString >& aPropertyNames ) override;
bool GetFlag( sal_uInt16 nOffset )
const;
void SetFlag( sal_uInt16 nOffset,
bool bVal );
void SetSearchAlgorithm( sal_uInt16 nOffset,
bool bVal );
};
SvtSearchOptions_Impl::SvtSearchOptions_Impl() :
ConfigItem( u
"Office.Common/SearchOptions"_ustr ),
nFlags(0x0003FFFF)
// set all options values to 'true'
{
Load();
SetModified(
false );
}
SvtSearchOptions_Impl::~SvtSearchOptions_Impl()
{
assert(!IsModified());
// should have been committed
}
void SvtSearchOptions_Impl::ImplCommit()
{
if (IsModified())
Save();
}
void SvtSearchOptions_Impl::Notify(
const Sequence< OUString >& )
{
}
bool SvtSearchOptions_Impl::GetFlag( sal_uInt16 nOffset )
const
{
DBG_ASSERT( nOffset <= MAX_FLAGS_OFFSET,
"offset out of range");
return ((nFlags >> nOffset) & 0x01) != 0;
}
void SvtSearchOptions_Impl::SetFlag( sal_uInt16 nOffset,
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(
true );
}
void SvtSearchOptions_Impl::SetModified(
bool bVal )
{
bModified = bVal;
if (bModified)
{
ConfigItem::SetModified();
}
}
Sequence< OUString > SvtSearchOptions_Impl::GetPropertyNames()
{
static constexpr OUString aPropNames[ MAX_FLAGS_OFFSET + 1 ] =
{
u
"IsWholeWordsOnly"_ustr,
// 0
u
"IsBackwards"_ustr,
// 1
u
"IsUseRegularExpression"_ustr,
// 2
//"IsCurrentSelectionOnly", // interactively set or not...
u
"IsSearchForStyles"_ustr,
// 3
u
"IsSimilaritySearch"_ustr,
// 4
u
"IsUseAsianOptions"_ustr,
// 5
u
"IsMatchCase"_ustr,
// 6
u
"Japanese/IsMatchFullHalfWidthForms"_ustr,
// 7
u
"Japanese/IsMatchHiraganaKatakana"_ustr,
// 8
u
"Japanese/IsMatchContractions"_ustr,
// 9
u
"Japanese/IsMatchMinusDashCho-on"_ustr,
// 10
u
"Japanese/IsMatchRepeatCharMarks"_ustr,
// 11
u
"Japanese/IsMatchVariantFormKanji"_ustr,
// 12
u
"Japanese/IsMatchOldKanaForms"_ustr,
// 13
u
"Japanese/IsMatch_DiZi_DuZu"_ustr,
// 14
u
"Japanese/IsMatch_BaVa_HaFa"_ustr,
// 15
u
"Japanese/IsMatch_TsiThiChi_DhiZi"_ustr,
// 16
u
"Japanese/IsMatch_HyuIyu_ByuVyu"_ustr,
// 17
u
"Japanese/IsMatch_SeShe_ZeJe"_ustr,
// 18
u
"Japanese/IsMatch_IaIya"_ustr,
// 19
u
"Japanese/IsMatch_KiKu"_ustr,
// 20
u
"Japanese/IsIgnorePunctuation"_ustr,
// 21
u
"Japanese/IsIgnoreWhitespace"_ustr,
// 22
u
"Japanese/IsIgnoreProlongedSoundMark"_ustr,
// 23
u
"Japanese/IsIgnoreMiddleDot"_ustr,
// 24
u
"IsNotes"_ustr,
// 25
u
"IsIgnoreDiacritics_CTL"_ustr,
// 26
u
"IsIgnoreKashida_CTL"_ustr,
// 27
u
"IsSearchFormatted"_ustr,
// 28
u
"IsUseWildcard"_ustr
// 29
};
Sequence< OUString > aNames(std::size(aPropNames));
OUString* pNames = aNames.getArray();
for (std::size_t i = 0; i < std::size(aPropNames); ++i)
pNames[i] = aPropNames[i];
return aNames;
}
void SvtSearchOptions_Impl::SetSearchAlgorithm( sal_uInt16 nOffset,
bool bVal )
{
if (bVal)
{
// Search algorithms are mutually exclusive.
if (nOffset != 2 && GetFlag(2))
SetFlag( 2,
false );
if (nOffset != 4 && GetFlag(4))
SetFlag( 4,
false );
if (nOffset != 29 && GetFlag(29))
SetFlag( 29,
false );
}
SetFlag( nOffset, bVal );
}
void SvtSearchOptions_Impl::Load()
{
bool bSucc =
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 =
true;
const Any* pValues = aValues.getConstArray();
for (sal_Int32 i = 0; i < nProps; ++i)
{
const Any &rVal = pValues[i];
DBG_ASSERT( rVal.hasValue(),
"property value missing" );
if (rVal.hasValue())
{
bool bVal =
bool();
if (rVal >>= bVal)
{
if (i <= MAX_FLAGS_OFFSET)
{
// use index in sequence as flag index
SetFlag( i, bVal );
}
else {
OSL_FAIL(
"unexpected index" );
}
}
else
{
OSL_FAIL(
"unexpected type" );
bSucc =
false;
}
}
else
{
OSL_FAIL(
"value missing" );
bSucc =
false;
}
}
}
DBG_ASSERT( bSucc,
"LoadConfig failed" );
}
bool SvtSearchOptions_Impl::Save()
{
bool bSucc =
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 == MAX_FLAGS_OFFSET + 1)
{
for (sal_Int32 i = 0; i < nProps; ++i)
pValue[i] <<= GetFlag(i);
bSucc |= PutProperties( aNames, aValues );
}
if (bSucc)
SetModified(
false );
return bSucc;
}
SvtSearchOptions::SvtSearchOptions()
: pImpl(
new SvtSearchOptions_Impl )
{
}
SvtSearchOptions::~SvtSearchOptions()
{
}
void SvtSearchOptions::Commit()
{
pImpl->Commit();
}
TransliterationFlags SvtSearchOptions::GetTransliterationFlags()
const
{
TransliterationFlags nRes = TransliterationFlags::NONE;
if (!IsMatchCase())
// 'IsMatchCase' means act case sensitive
nRes |= TransliterationFlags::IGNORE_CASE;
if ( IsMatchFullHalfWidthForms())
nRes |= TransliterationFlags::IGNORE_WIDTH;
if ( IsMatchHiraganaKatakana())
nRes |= TransliterationFlags::IGNORE_KANA;
if ( IsMatchContractions())
nRes |= TransliterationFlags::ignoreSize_ja_JP;
if ( IsMatchMinusDashChoon())
nRes |= TransliterationFlags::ignoreMinusSign_ja_JP;
if ( IsMatchRepeatCharMarks())
nRes |= TransliterationFlags::ignoreIterationMark_ja_JP;
if ( IsMatchVariantFormKanji())
nRes |= TransliterationFlags::ignoreTraditionalKanji_ja_JP;
if ( IsMatchOldKanaForms())
nRes |= TransliterationFlags::ignoreTraditionalKana_ja_JP;
if ( IsMatchDiziDuzu())
nRes |= TransliterationFlags::ignoreZiZu_ja_JP;
if ( IsMatchBavaHafa())
nRes |= TransliterationFlags::ignoreBaFa_ja_JP;
if ( IsMatchTsithichiDhizi())
nRes |= TransliterationFlags::ignoreTiJi_ja_JP;
if ( IsMatchHyuiyuByuvyu())
nRes |= TransliterationFlags::ignoreHyuByu_ja_JP;
if ( IsMatchSesheZeje())
nRes |= TransliterationFlags::ignoreSeZe_ja_JP;
if ( IsMatchIaiya())
nRes |= TransliterationFlags::ignoreIandEfollowedByYa_ja_JP;
if ( IsMatchKiku())
nRes |= TransliterationFlags::ignoreKiKuFollowedBySa_ja_JP;
if ( IsIgnorePunctuation())
nRes |= TransliterationFlags::ignoreSeparator_ja_JP;
if ( IsIgnoreWhitespace())
nRes |= TransliterationFlags::ignoreSpace_ja_JP;
if ( IsIgnoreProlongedSoundMark())
nRes |= TransliterationFlags::ignoreProlongedSoundMark_ja_JP;
if ( IsIgnoreMiddleDot())
nRes |= TransliterationFlags::ignoreMiddleDot_ja_JP;
if ( IsIgnoreDiacritics_CTL())
nRes |= TransliterationFlags::IGNORE_DIACRITICS_CTL;
if ( IsIgnoreKashida_CTL())
nRes |= TransliterationFlags::IGNORE_KASHIDA_CTL;
return nRes;
}
bool SvtSearchOptions::IsWholeWordsOnly()
const
{
return pImpl->GetFlag( 0 );
}
void SvtSearchOptions::SetWholeWordsOnly(
bool bVal )
{
pImpl->SetFlag( 0, bVal );
}
bool SvtSearchOptions::IsBackwards()
const
{
return pImpl->GetFlag( 1 );
}
void SvtSearchOptions::SetBackwards(
bool bVal )
{
pImpl->SetFlag( 1, bVal );
}
bool SvtSearchOptions::IsUseRegularExpression()
const
{
return pImpl->GetFlag( 2 );
}
void SvtSearchOptions::SetUseRegularExpression(
bool bVal )
{
pImpl->SetSearchAlgorithm( 2, bVal );
}
void SvtSearchOptions::SetSearchForStyles(
bool bVal )
{
pImpl->SetFlag( 3, bVal );
}
bool SvtSearchOptions::IsSimilaritySearch()
const
{
return pImpl->GetFlag( 4 );
}
void SvtSearchOptions::SetSimilaritySearch(
bool bVal )
{
pImpl->SetSearchAlgorithm( 4, bVal );
}
bool SvtSearchOptions::IsUseAsianOptions()
const
{
return pImpl->GetFlag( 5 );
}
void SvtSearchOptions::SetUseAsianOptions(
bool bVal )
{
pImpl->SetFlag( 5, bVal );
}
bool SvtSearchOptions::IsMatchCase()
const
{
return pImpl->GetFlag( 6 );
}
void SvtSearchOptions::SetMatchCase(
bool bVal )
{
pImpl->SetFlag( 6, bVal );
}
bool SvtSearchOptions::IsMatchFullHalfWidthForms()
const
{
return pImpl->GetFlag( 7 );
}
void SvtSearchOptions::SetMatchFullHalfWidthForms(
bool bVal )
{
pImpl->SetFlag( 7, bVal );
}
bool SvtSearchOptions::IsMatchHiraganaKatakana()
const
{
return pImpl->GetFlag( 8 );
}
void SvtSearchOptions::SetMatchHiraganaKatakana(
bool bVal )
{
pImpl->SetFlag( 8, bVal );
}
bool SvtSearchOptions::IsMatchContractions()
const
{
return pImpl->GetFlag( 9 );
}
void SvtSearchOptions::SetMatchContractions(
bool bVal )
{
pImpl->SetFlag( 9, bVal );
}
bool SvtSearchOptions::IsMatchMinusDashChoon()
const
{
return pImpl->GetFlag( 10 );
}
void SvtSearchOptions::SetMatchMinusDashChoon(
bool bVal )
{
pImpl->SetFlag( 10, bVal );
}
bool SvtSearchOptions::IsMatchRepeatCharMarks()
const
{
return pImpl->GetFlag( 11 );
}
void SvtSearchOptions::SetMatchRepeatCharMarks(
bool bVal )
{
pImpl->SetFlag( 11, bVal );
}
bool SvtSearchOptions::IsMatchVariantFormKanji()
const
{
return pImpl->GetFlag( 12 );
}
void SvtSearchOptions::SetMatchVariantFormKanji(
bool bVal )
{
pImpl->SetFlag( 12, bVal );
}
bool SvtSearchOptions::IsMatchOldKanaForms()
const
{
return pImpl->GetFlag( 13 );
}
void SvtSearchOptions::SetMatchOldKanaForms(
bool bVal )
{
pImpl->SetFlag( 13, bVal );
}
bool SvtSearchOptions::IsMatchDiziDuzu()
const
{
return pImpl->GetFlag( 14 );
}
void SvtSearchOptions::SetMatchDiziDuzu(
bool bVal )
{
pImpl->SetFlag( 14, bVal );
}
bool SvtSearchOptions::IsMatchBavaHafa()
const
{
return pImpl->GetFlag( 15 );
}
void SvtSearchOptions::SetMatchBavaHafa(
bool bVal )
{
pImpl->SetFlag( 15, bVal );
}
bool SvtSearchOptions::IsMatchTsithichiDhizi()
const
{
return pImpl->GetFlag( 16 );
}
void SvtSearchOptions::SetMatchTsithichiDhizi(
bool bVal )
{
pImpl->SetFlag( 16, bVal );
}
bool SvtSearchOptions::IsMatchHyuiyuByuvyu()
const
{
return pImpl->GetFlag( 17 );
}
void SvtSearchOptions::SetMatchHyuiyuByuvyu(
bool bVal )
{
pImpl->SetFlag( 17, bVal );
}
bool SvtSearchOptions::IsMatchSesheZeje()
const
{
return pImpl->GetFlag( 18 );
}
void SvtSearchOptions::SetMatchSesheZeje(
bool bVal )
{
pImpl->SetFlag( 18, bVal );
}
bool SvtSearchOptions::IsMatchIaiya()
const
{
return pImpl->GetFlag( 19 );
}
void SvtSearchOptions::SetMatchIaiya(
bool bVal )
{
pImpl->SetFlag( 19, bVal );
}
bool SvtSearchOptions::IsMatchKiku()
const
{
return pImpl->GetFlag( 20 );
}
void SvtSearchOptions::SetMatchKiku(
bool bVal )
{
pImpl->SetFlag( 20, bVal );
}
bool SvtSearchOptions::IsIgnorePunctuation()
const
{
return pImpl->GetFlag( 21 );
}
void SvtSearchOptions::SetIgnorePunctuation(
bool bVal )
{
pImpl->SetFlag( 21, bVal );
}
bool SvtSearchOptions::IsIgnoreWhitespace()
const
{
return pImpl->GetFlag( 22 );
}
void SvtSearchOptions::SetIgnoreWhitespace(
bool bVal )
{
pImpl->SetFlag( 22, bVal );
}
bool SvtSearchOptions::IsIgnoreProlongedSoundMark()
const
{
return pImpl->GetFlag( 23 );
}
void SvtSearchOptions::SetIgnoreProlongedSoundMark(
bool bVal )
{
pImpl->SetFlag( 23, bVal );
}
bool SvtSearchOptions::IsIgnoreMiddleDot()
const
{
return pImpl->GetFlag( 24 );
}
void SvtSearchOptions::SetIgnoreMiddleDot(
bool bVal )
{
pImpl->SetFlag( 24, bVal );
}
bool SvtSearchOptions::IsNotes()
const
{
return pImpl->GetFlag( 25 );
}
void SvtSearchOptions::SetNotes(
bool bVal )
{
pImpl->SetFlag( 25, bVal );
}
bool SvtSearchOptions::IsIgnoreDiacritics_CTL()
const
{
return pImpl->GetFlag( 26 );
}
void SvtSearchOptions::SetIgnoreDiacritics_CTL(
bool bVal )
{
pImpl->SetFlag( 26, bVal );
}
bool SvtSearchOptions::IsIgnoreKashida_CTL()
const
{
return pImpl->GetFlag( 27 );
}
void SvtSearchOptions::SetIgnoreKashida_CTL(
bool bVal )
{
pImpl->SetFlag( 27, bVal );
}
bool SvtSearchOptions::IsSearchFormatted()
const
{
return pImpl->GetFlag( 28 );
}
void SvtSearchOptions::SetSearchFormatted(
bool bVal )
{
pImpl->SetFlag( 28, bVal );
}
bool SvtSearchOptions::IsUseWildcard()
const
{
return pImpl->GetFlag( 29 );
}
void SvtSearchOptions::SetUseWildcard(
bool bVal )
{
pImpl->SetSearchAlgorithm( 29, bVal );
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
