LCOV - code coverage report
Current view: top level - unotools/source/config - searchopt.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 259 0.0 %
Date: 2014-04-14 Functions: 0 70 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <sal/config.h>
      21             : 
      22             : #include <boost/noncopyable.hpp>
      23             : #include <unotools/searchopt.hxx>
      24             : #include <tools/debug.hxx>
      25             : #include <unotools/configitem.hxx>
      26             : #include <com/sun/star/i18n/TransliterationModules.hpp>
      27             : #include <com/sun/star/i18n/TransliterationModulesExtra.hpp>
      28             : #include <com/sun/star/uno/Sequence.hxx>
      29             : #include <com/sun/star/uno/Any.h>
      30             : #include <sal/macros.h>
      31             : 
      32             : using namespace utl;
      33             : using namespace com::sun::star::uno;
      34             : using namespace com::sun::star::i18n;
      35             : 
      36             : #define MAX_FLAGS_OFFSET    27
      37             : 
      38             : class SvtSearchOptions_Impl: public ConfigItem, private boost::noncopyable
      39             : {
      40             :     sal_Int32   nFlags;
      41             :     bool    bModified;
      42             : 
      43             : protected:
      44           0 :     bool            IsModified() const { return bModified; }
      45             :     using ConfigItem::SetModified;
      46             :     void            SetModified( bool bVal );
      47             :     bool            Load();
      48             :     bool            Save();
      49             : 
      50             :     Sequence< OUString >    GetPropertyNames() const;
      51             : 
      52             : public:
      53             :     SvtSearchOptions_Impl();
      54             :     virtual ~SvtSearchOptions_Impl();
      55             : 
      56             :     // ConfigItem
      57             :     virtual void    Commit() SAL_OVERRIDE;
      58             :     virtual void    Notify( const com::sun::star::uno::Sequence< OUString >& aPropertyNames ) SAL_OVERRIDE;
      59             : 
      60             :     bool            GetFlag( sal_uInt16 nOffset ) const;
      61             :     void            SetFlag( sal_uInt16 nOffset, bool bVal );
      62             : };
      63             : 
      64           0 : SvtSearchOptions_Impl::SvtSearchOptions_Impl() :
      65           0 :     ConfigItem( OUString("Office.Common/SearchOptions") )
      66             : {
      67           0 :     nFlags = 0x0003FFFF;    // set all options values to 'true'
      68           0 :     Load();
      69           0 :     SetModified( false );
      70           0 : }
      71             : 
      72           0 : SvtSearchOptions_Impl::~SvtSearchOptions_Impl()
      73             : {
      74           0 :     Commit();
      75           0 : }
      76             : 
      77           0 : void SvtSearchOptions_Impl::Commit()
      78             : {
      79           0 :     if (IsModified())
      80           0 :         Save();
      81           0 : }
      82             : 
      83           0 : void SvtSearchOptions_Impl::Notify( const Sequence< OUString >&  )
      84             : {
      85           0 : }
      86             : 
      87           0 : bool SvtSearchOptions_Impl::GetFlag( sal_uInt16 nOffset ) const
      88             : {
      89             :     DBG_ASSERT( nOffset <= MAX_FLAGS_OFFSET, "offset out of range");
      90           0 :     return ((nFlags >> nOffset) & 0x01) ? sal_True : sal_False;
      91             : }
      92             : 
      93           0 : void SvtSearchOptions_Impl::SetFlag( sal_uInt16 nOffset, bool bVal )
      94             : {
      95             :     DBG_ASSERT( nOffset <= MAX_FLAGS_OFFSET, "offset out of range");
      96           0 :     sal_Int32 nOldFlags = nFlags;
      97           0 :     sal_Int32 nMask = ((sal_Int32) 1)  << nOffset;
      98           0 :     if (bVal)
      99           0 :         nFlags |= nMask;
     100             :     else
     101           0 :         nFlags &= ~nMask;
     102           0 :     if (nFlags != nOldFlags)
     103           0 :         SetModified( true );
     104           0 : }
     105             : 
     106           0 : void SvtSearchOptions_Impl::SetModified( bool bVal )
     107             : {
     108           0 :     bModified = bVal;
     109           0 :     if (bModified)
     110             :     {
     111           0 :         ConfigItem::SetModified();
     112             :     }
     113           0 : }
     114             : 
     115           0 : Sequence< OUString > SvtSearchOptions_Impl::GetPropertyNames() const
     116             : {
     117             :     static const char* aPropNames[ MAX_FLAGS_OFFSET + 1 ] =
     118             :     {
     119             :         "IsWholeWordsOnly",                     //  0
     120             :         "IsBackwards",                          //  1
     121             :         "IsUseRegularExpression",               //  2
     122             :         //"IsCurrentSelectionOnly",             // interactively set or not...
     123             :         "IsSearchForStyles",                    //  3
     124             :         "IsSimilaritySearch",                   //  4
     125             :         "IsUseAsianOptions",                    //  5
     126             :         "IsMatchCase",                          //  6
     127             :         "Japanese/IsMatchFullHalfWidthForms",   //  7
     128             :         "Japanese/IsMatchHiraganaKatakana",     //  8
     129             :         "Japanese/IsMatchContractions",         //  9
     130             :         "Japanese/IsMatchMinusDashCho-on",      // 10
     131             :         "Japanese/IsMatchRepeatCharMarks",      // 11
     132             :         "Japanese/IsMatchVariantFormKanji",     // 12
     133             :         "Japanese/IsMatchOldKanaForms",         // 13
     134             :         "Japanese/IsMatch_DiZi_DuZu",           // 14
     135             :         "Japanese/IsMatch_BaVa_HaFa",           // 15
     136             :         "Japanese/IsMatch_TsiThiChi_DhiZi",     // 16
     137             :         "Japanese/IsMatch_HyuIyu_ByuVyu",       // 17
     138             :         "Japanese/IsMatch_SeShe_ZeJe",          // 18
     139             :         "Japanese/IsMatch_IaIya",               // 19
     140             :         "Japanese/IsMatch_KiKu",                // 20
     141             :         "Japanese/IsIgnorePunctuation",         // 21
     142             :         "Japanese/IsIgnoreWhitespace",          // 22
     143             :         "Japanese/IsIgnoreProlongedSoundMark",      // 23
     144             :         "Japanese/IsIgnoreMiddleDot",           // 24
     145             :         "IsNotes",                              // 25
     146             :         "IsIgnoreDiacritics_CTL",               // 26
     147             :         "IsIgnoreKashida_CTL"                   // 27
     148             :     };
     149             : 
     150           0 :     const int nCount = SAL_N_ELEMENTS( aPropNames );
     151           0 :     Sequence< OUString > aNames( nCount );
     152           0 :     OUString* pNames = aNames.getArray();
     153           0 :     for (sal_Int32 i = 0;  i < nCount;  ++i)
     154           0 :         pNames[i] = OUString::createFromAscii( aPropNames[i] );
     155             : 
     156           0 :     return aNames;
     157             : }
     158             : 
     159           0 : bool SvtSearchOptions_Impl::Load()
     160             : {
     161           0 :     bool bSucc = false;
     162             : 
     163           0 :     Sequence< OUString > aNames = GetPropertyNames();
     164           0 :     sal_Int32 nProps = aNames.getLength();
     165             : 
     166           0 :     const Sequence< Any > aValues = GetProperties( aNames );
     167             :     DBG_ASSERT( aValues.getLength() == aNames.getLength(),
     168             :             "GetProperties failed" );
     169             :     //EnableNotification( aNames );
     170             : 
     171           0 :     if (nProps  &&  aValues.getLength() == nProps)
     172             :     {
     173           0 :         bSucc = true;
     174             : 
     175           0 :         const Any* pValues = aValues.getConstArray();
     176           0 :         for (sal_uInt16 i = 0;  i < nProps;  ++i)
     177             :         {
     178           0 :             const Any &rVal = pValues[i];
     179             :             DBG_ASSERT( rVal.hasValue(), "property value missing" );
     180           0 :             if (rVal.hasValue())
     181             :             {
     182           0 :                 bool bVal = bool();
     183           0 :                 if (rVal >>= bVal)
     184             :                 {
     185           0 :                     if (i <= MAX_FLAGS_OFFSET)
     186             :                     {
     187             :                         // use index in sequence as flag index
     188           0 :                         SetFlag( i, bVal );
     189             :                     }
     190             :                     else {
     191             :                         OSL_FAIL( "unexpected index" );
     192             :                     }
     193             :                 }
     194             :                 else
     195             :                 {
     196             :                     OSL_FAIL( "unexpected type" );
     197           0 :                     bSucc = false;
     198             :                 }
     199             :             }
     200             :             else
     201             :             {
     202             :                 OSL_FAIL( "value missing" );
     203           0 :                 bSucc = false;
     204             :             }
     205             :         }
     206             :     }
     207             :     DBG_ASSERT( bSucc, "LoadConfig failed" );
     208             : 
     209           0 :     return bSucc;
     210             : }
     211             : 
     212           0 : bool SvtSearchOptions_Impl::Save()
     213             : {
     214           0 :     bool bSucc = false;
     215             : 
     216           0 :     const Sequence< OUString > aNames = GetPropertyNames();
     217           0 :     sal_Int32 nProps = aNames.getLength();
     218             : 
     219           0 :     Sequence< Any > aValues( nProps );
     220           0 :     Any *pValue = aValues.getArray();
     221             : 
     222             :     DBG_ASSERT( nProps == MAX_FLAGS_OFFSET + 1,
     223             :             "unexpected size of index" );
     224           0 :     if (nProps  &&  nProps == MAX_FLAGS_OFFSET + 1)
     225             :     {
     226           0 :         for (sal_uInt16 i = 0;  i < nProps;  ++i)
     227           0 :             pValue[i] <<= GetFlag(i);
     228           0 :         bSucc |= PutProperties( aNames, aValues );
     229             :     }
     230             : 
     231           0 :     if (bSucc)
     232           0 :         SetModified( false );
     233             : 
     234           0 :     return bSucc;
     235             : }
     236             : 
     237           0 : SvtSearchOptions::SvtSearchOptions()
     238             : {
     239           0 :     pImpl = new SvtSearchOptions_Impl;
     240           0 : }
     241             : 
     242           0 : SvtSearchOptions::~SvtSearchOptions()
     243             : {
     244           0 :     delete pImpl;
     245           0 : }
     246             : 
     247           0 : sal_Int32 SvtSearchOptions::GetTransliterationFlags() const
     248             : {
     249           0 :     sal_Int32 nRes = 0;
     250             : 
     251           0 :     if (!IsMatchCase()) // 'IsMatchCase' means act case sensitive
     252           0 :         nRes |= TransliterationModules_IGNORE_CASE;
     253           0 :     if ( IsMatchFullHalfWidthForms())
     254           0 :         nRes |= TransliterationModules_IGNORE_WIDTH;
     255           0 :     if ( IsMatchHiraganaKatakana())
     256           0 :         nRes |= TransliterationModules_IGNORE_KANA;
     257           0 :     if ( IsMatchContractions())
     258           0 :         nRes |= TransliterationModules_ignoreSize_ja_JP;
     259           0 :     if ( IsMatchMinusDashChoon())
     260           0 :         nRes |= TransliterationModules_ignoreMinusSign_ja_JP;
     261           0 :     if ( IsMatchRepeatCharMarks())
     262           0 :         nRes |= TransliterationModules_ignoreIterationMark_ja_JP;
     263           0 :     if ( IsMatchVariantFormKanji())
     264           0 :         nRes |= TransliterationModules_ignoreTraditionalKanji_ja_JP;
     265           0 :     if ( IsMatchOldKanaForms())
     266           0 :         nRes |= TransliterationModules_ignoreTraditionalKana_ja_JP;
     267           0 :     if ( IsMatchDiziDuzu())
     268           0 :         nRes |= TransliterationModules_ignoreZiZu_ja_JP;
     269           0 :     if ( IsMatchBavaHafa())
     270           0 :         nRes |= TransliterationModules_ignoreBaFa_ja_JP;
     271           0 :     if ( IsMatchTsithichiDhizi())
     272           0 :         nRes |= TransliterationModules_ignoreTiJi_ja_JP;
     273           0 :     if ( IsMatchHyuiyuByuvyu())
     274           0 :         nRes |= TransliterationModules_ignoreHyuByu_ja_JP;
     275           0 :     if ( IsMatchSesheZeje())
     276           0 :         nRes |= TransliterationModules_ignoreSeZe_ja_JP;
     277           0 :     if ( IsMatchIaiya())
     278           0 :         nRes |= TransliterationModules_ignoreIandEfollowedByYa_ja_JP;
     279           0 :     if ( IsMatchKiku())
     280           0 :         nRes |= TransliterationModules_ignoreKiKuFollowedBySa_ja_JP;
     281           0 :     if ( IsIgnorePunctuation())
     282           0 :         nRes |= TransliterationModules_ignoreSeparator_ja_JP;
     283           0 :     if ( IsIgnoreWhitespace())
     284           0 :         nRes |= TransliterationModules_ignoreSpace_ja_JP;
     285           0 :     if ( IsIgnoreProlongedSoundMark())
     286           0 :         nRes |= TransliterationModules_ignoreProlongedSoundMark_ja_JP;
     287           0 :     if ( IsIgnoreMiddleDot())
     288           0 :         nRes |= TransliterationModules_ignoreMiddleDot_ja_JP;
     289           0 :     if ( IsIgnoreDiacritics_CTL())
     290           0 :         nRes |= TransliterationModulesExtra::IGNORE_DIACRITICS_CTL;
     291           0 :     if ( IsIgnoreKashida_CTL())
     292           0 :         nRes |= TransliterationModulesExtra::IGNORE_KASHIDA_CTL;
     293           0 :     return nRes;
     294             : }
     295             : 
     296           0 : bool SvtSearchOptions::IsWholeWordsOnly() const
     297             : {
     298           0 :     return pImpl->GetFlag( 0 );
     299             : }
     300             : 
     301           0 : void SvtSearchOptions::SetWholeWordsOnly( bool bVal )
     302             : {
     303           0 :     pImpl->SetFlag( 0, bVal );
     304           0 : }
     305             : 
     306           0 : bool SvtSearchOptions::IsBackwards() const
     307             : {
     308           0 :     return pImpl->GetFlag( 1 );
     309             : }
     310             : 
     311           0 : void SvtSearchOptions::SetBackwards( bool bVal )
     312             : {
     313           0 :     pImpl->SetFlag( 1, bVal );
     314           0 : }
     315             : 
     316           0 : bool SvtSearchOptions::IsUseRegularExpression() const
     317             : {
     318           0 :     return pImpl->GetFlag( 2 );
     319             : }
     320             : 
     321           0 : void SvtSearchOptions::SetUseRegularExpression( bool bVal )
     322             : {
     323           0 :     pImpl->SetFlag( 2, bVal );
     324           0 : }
     325             : 
     326           0 : void SvtSearchOptions::SetSearchForStyles( bool bVal )
     327             : {
     328           0 :     pImpl->SetFlag( 3, bVal );
     329           0 : }
     330             : 
     331           0 : bool SvtSearchOptions::IsSimilaritySearch() const
     332             : {
     333           0 :     return pImpl->GetFlag( 4 );
     334             : }
     335             : 
     336           0 : void SvtSearchOptions::SetSimilaritySearch( bool bVal )
     337             : {
     338           0 :     pImpl->SetFlag( 4, bVal );
     339           0 : }
     340             : 
     341           0 : bool SvtSearchOptions::IsUseAsianOptions() const
     342             : {
     343           0 :     return pImpl->GetFlag( 5 );
     344             : }
     345             : 
     346           0 : void SvtSearchOptions::SetUseAsianOptions( bool bVal )
     347             : {
     348           0 :     pImpl->SetFlag( 5, bVal );
     349           0 : }
     350             : 
     351           0 : bool SvtSearchOptions::IsMatchCase() const
     352             : {
     353           0 :     return pImpl->GetFlag( 6 );
     354             : }
     355             : 
     356           0 : void SvtSearchOptions::SetMatchCase( bool bVal )
     357             : {
     358           0 :     pImpl->SetFlag( 6, bVal );
     359           0 : }
     360             : 
     361           0 : bool SvtSearchOptions::IsMatchFullHalfWidthForms() const
     362             : {
     363           0 :     return pImpl->GetFlag( 7 );
     364             : }
     365             : 
     366           0 : void SvtSearchOptions::SetMatchFullHalfWidthForms( bool bVal )
     367             : {
     368           0 :     pImpl->SetFlag( 7, bVal );
     369           0 : }
     370             : 
     371           0 : bool SvtSearchOptions::IsMatchHiraganaKatakana() const
     372             : {
     373           0 :     return pImpl->GetFlag( 8 );
     374             : }
     375             : 
     376           0 : void SvtSearchOptions::SetMatchHiraganaKatakana( bool bVal )
     377             : {
     378           0 :     pImpl->SetFlag( 8, bVal );
     379           0 : }
     380             : 
     381           0 : bool SvtSearchOptions::IsMatchContractions() const
     382             : {
     383           0 :     return pImpl->GetFlag( 9 );
     384             : }
     385             : 
     386           0 : void SvtSearchOptions::SetMatchContractions( bool bVal )
     387             : {
     388           0 :     pImpl->SetFlag( 9, bVal );
     389           0 : }
     390             : 
     391           0 : bool SvtSearchOptions::IsMatchMinusDashChoon() const
     392             : {
     393           0 :     return pImpl->GetFlag( 10 );
     394             : }
     395             : 
     396           0 : void SvtSearchOptions::SetMatchMinusDashChoon( bool bVal )
     397             : {
     398           0 :     pImpl->SetFlag( 10, bVal );
     399           0 : }
     400             : 
     401           0 : bool SvtSearchOptions::IsMatchRepeatCharMarks() const
     402             : {
     403           0 :     return pImpl->GetFlag( 11 );
     404             : }
     405             : 
     406           0 : void SvtSearchOptions::SetMatchRepeatCharMarks( bool bVal )
     407             : {
     408           0 :     pImpl->SetFlag( 11, bVal );
     409           0 : }
     410             : 
     411           0 : bool SvtSearchOptions::IsMatchVariantFormKanji() const
     412             : {
     413           0 :     return pImpl->GetFlag( 12 );
     414             : }
     415             : 
     416           0 : void SvtSearchOptions::SetMatchVariantFormKanji( bool bVal )
     417             : {
     418           0 :     pImpl->SetFlag( 12, bVal );
     419           0 : }
     420             : 
     421           0 : bool SvtSearchOptions::IsMatchOldKanaForms() const
     422             : {
     423           0 :     return pImpl->GetFlag( 13 );
     424             : }
     425             : 
     426           0 : void SvtSearchOptions::SetMatchOldKanaForms( bool bVal )
     427             : {
     428           0 :     pImpl->SetFlag( 13, bVal );
     429           0 : }
     430             : 
     431           0 : bool SvtSearchOptions::IsMatchDiziDuzu() const
     432             : {
     433           0 :     return pImpl->GetFlag( 14 );
     434             : }
     435             : 
     436           0 : void SvtSearchOptions::SetMatchDiziDuzu( bool bVal )
     437             : {
     438           0 :     pImpl->SetFlag( 14, bVal );
     439           0 : }
     440             : 
     441           0 : bool SvtSearchOptions::IsMatchBavaHafa() const
     442             : {
     443           0 :     return pImpl->GetFlag( 15 );
     444             : }
     445             : 
     446           0 : void SvtSearchOptions::SetMatchBavaHafa( bool bVal )
     447             : {
     448           0 :     pImpl->SetFlag( 15, bVal );
     449           0 : }
     450             : 
     451           0 : bool SvtSearchOptions::IsMatchTsithichiDhizi() const
     452             : {
     453           0 :     return pImpl->GetFlag( 16 );
     454             : }
     455             : 
     456           0 : void SvtSearchOptions::SetMatchTsithichiDhizi( bool bVal )
     457             : {
     458           0 :     pImpl->SetFlag( 16, bVal );
     459           0 : }
     460             : 
     461           0 : bool SvtSearchOptions::IsMatchHyuiyuByuvyu() const
     462             : {
     463           0 :     return pImpl->GetFlag( 17 );
     464             : }
     465             : 
     466           0 : void SvtSearchOptions::SetMatchHyuiyuByuvyu( bool bVal )
     467             : {
     468           0 :     pImpl->SetFlag( 17, bVal );
     469           0 : }
     470             : 
     471           0 : bool SvtSearchOptions::IsMatchSesheZeje() const
     472             : {
     473           0 :     return pImpl->GetFlag( 18 );
     474             : }
     475             : 
     476           0 : void SvtSearchOptions::SetMatchSesheZeje( bool bVal )
     477             : {
     478           0 :     pImpl->SetFlag( 18, bVal );
     479           0 : }
     480             : 
     481           0 : bool SvtSearchOptions::IsMatchIaiya() const
     482             : {
     483           0 :     return pImpl->GetFlag( 19 );
     484             : }
     485             : 
     486           0 : void SvtSearchOptions::SetMatchIaiya( bool bVal )
     487             : {
     488           0 :     pImpl->SetFlag( 19, bVal );
     489           0 : }
     490             : 
     491           0 : bool SvtSearchOptions::IsMatchKiku() const
     492             : {
     493           0 :     return pImpl->GetFlag( 20 );
     494             : }
     495             : 
     496           0 : void SvtSearchOptions::SetMatchKiku( bool bVal )
     497             : {
     498           0 :     pImpl->SetFlag( 20, bVal );
     499           0 : }
     500             : 
     501           0 : bool SvtSearchOptions::IsIgnorePunctuation() const
     502             : {
     503           0 :     return pImpl->GetFlag( 21 );
     504             : }
     505             : 
     506           0 : void SvtSearchOptions::SetIgnorePunctuation( bool bVal )
     507             : {
     508           0 :     pImpl->SetFlag( 21, bVal );
     509           0 : }
     510             : 
     511           0 : bool SvtSearchOptions::IsIgnoreWhitespace() const
     512             : {
     513           0 :     return pImpl->GetFlag( 22 );
     514             : }
     515             : 
     516           0 : void SvtSearchOptions::SetIgnoreWhitespace( bool bVal )
     517             : {
     518           0 :     pImpl->SetFlag( 22, bVal );
     519           0 : }
     520             : 
     521           0 : bool SvtSearchOptions::IsIgnoreProlongedSoundMark() const
     522             : {
     523           0 :     return pImpl->GetFlag( 23 );
     524             : }
     525             : 
     526           0 : void SvtSearchOptions::SetIgnoreProlongedSoundMark( bool bVal )
     527             : {
     528           0 :     pImpl->SetFlag( 23, bVal );
     529           0 : }
     530             : 
     531           0 : bool SvtSearchOptions::IsIgnoreMiddleDot() const
     532             : {
     533           0 :     return pImpl->GetFlag( 24 );
     534             : }
     535             : 
     536           0 : void SvtSearchOptions::SetIgnoreMiddleDot( bool bVal )
     537             : {
     538           0 :     pImpl->SetFlag( 24, bVal );
     539           0 : }
     540             : 
     541           0 : bool SvtSearchOptions::IsNotes() const
     542             : {
     543           0 :     return pImpl->GetFlag( 25 );
     544             : }
     545             : 
     546           0 : void SvtSearchOptions::SetNotes( bool bVal )
     547             : {
     548           0 :     pImpl->SetFlag( 25, bVal );
     549           0 : }
     550             : 
     551           0 : bool SvtSearchOptions::IsIgnoreDiacritics_CTL() const
     552             : {
     553           0 :     return pImpl->GetFlag( 26 );
     554             : }
     555             : 
     556           0 : void SvtSearchOptions::SetIgnoreDiacritics_CTL( bool bVal )
     557             : {
     558           0 :     pImpl->SetFlag( 26, bVal );
     559           0 : }
     560             : 
     561           0 : bool SvtSearchOptions::IsIgnoreKashida_CTL() const
     562             : {
     563           0 :     return pImpl->GetFlag( 27 );
     564             : }
     565             : 
     566           0 : void SvtSearchOptions::SetIgnoreKashida_CTL( bool bVal )
     567             : {
     568           0 :     pImpl->SetFlag( 27, bVal );
     569           0 : }
     570             : 
     571             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10