svl/source/items/srchitem.cxx

   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 <sal/log.hxx>
  23 #include <svl/srchitem.hxx>
  24 #include <sal/macros.h>
  25 #include <osl/diagnose.h>
  26
  27 #include <unotools/searchopt.hxx>
  28 #include <com/sun/star/beans/PropertyValue.hpp>
  29 #include <com/sun/star/lang/Locale.hpp>
  30 #include <svl/memberid.h>
  31 #include <i18nlangtag/languagetag.hxx>
  32
  33 using namespace utl;
  34 using namespace com::sun::star;
  35 using namespace com::sun::star::beans;
  36 using namespace com::sun::star::uno;
  37 using namespace com::sun::star::util;
  38
  39 #define CFG_ROOT_NODE       "Office.Common/SearchOptions"
  40
  41 #define SRCH_PARAMS         13
  42 #define SRCH_PARA_OPTIONS   "Options"
  43 #define SRCH_PARA_FAMILY    "Family"
  44 #define SRCH_PARA_COMMAND   "Command"
  45 #define SRCH_PARA_CELLTYPE  "CellType"
  46 #define SRCH_PARA_APPFLAG   "AppFlag"
  47 #define SRCH_PARA_ROWDIR    "RowDirection"
  48 #define SRCH_PARA_ALLTABLES "AllTables"
  49 #define SRCH_PARA_SEARCHFILTERED "SearchFiltered"
  50 #define SRCH_PARA_SEARCHFORMATTED  "SearchFormatted"
  51 #define SRCH_PARA_BACKWARD  "Backward"
  52 #define SRCH_PARA_PATTERN   "Pattern"
  53 #define SRCH_PARA_CONTENT   "Content"
  54 #define SRCH_PARA_ASIANOPT  "AsianOptions"
  55
  56 SfxPoolItem* SvxSearchItem::CreateDefault() { return new  SvxSearchItem(0);}
  57
  58
  59 static Sequence< OUString > lcl_GetNotifyNames()
  60 {
  61     // names of transliteration relevant properties
  62     static const char* aTranslitNames[] =
  63     {
  64         "IsMatchCase",                          //  0
  65         "Japanese/IsMatchFullHalfWidthForms",   //  1
  66         "Japanese/IsMatchHiraganaKatakana",     //  2
  67         "Japanese/IsMatchContractions",         //  3
  68         "Japanese/IsMatchMinusDashCho-on",      //  4
  69         "Japanese/IsMatchRepeatCharMarks",      //  5
  70         "Japanese/IsMatchVariantFormKanji",     //  6
  71         "Japanese/IsMatchOldKanaForms",         //  7
  72         "Japanese/IsMatch_DiZi_DuZu",           //  8
  73         "Japanese/IsMatch_BaVa_HaFa",           //  9
  74         "Japanese/IsMatch_TsiThiChi_DhiZi",     // 10
  75         "Japanese/IsMatch_HyuIyu_ByuVyu",       // 11
  76         "Japanese/IsMatch_SeShe_ZeJe",          // 12
  77         "Japanese/IsMatch_IaIya",               // 13
  78         "Japanese/IsMatch_KiKu",                // 14
  79         "Japanese/IsIgnorePunctuation",         // 15
  80         "Japanese/IsIgnoreWhitespace",          // 16
  81         "Japanese/IsIgnoreProlongedSoundMark",  // 17
  82         "Japanese/IsIgnoreMiddleDot",           // 18
  83         "IsIgnoreDiacritics_CTL",               // 19
  84         "IsIgnoreKashida_CTL"                   // 20
  85     };
  86
  87     const int nCount = SAL_N_ELEMENTS( aTranslitNames );
  88     Sequence< OUString > aNames( nCount );
  89     OUString* pNames = aNames.getArray();
  90     for (sal_Int32 i = 0;  i < nCount;  ++i)
  91         pNames[i] = OUString::createFromAscii( aTranslitNames[i] );
  92
  93     return aNames;
  94 }
  95
  96
  97 SvxSearchItem::SvxSearchItem( const sal_uInt16 nId ) :
  98
  99     SfxPoolItem( nId ),
 100     ConfigItem( CFG_ROOT_NODE ),
 101
 102     m_aSearchOpt      ( SearchAlgorithms_ABSOLUTE,
 103                         SearchFlags::LEV_RELAXED,
 104                         OUString(),
 105                         OUString(),
 106                         lang::Locale(),
 107                         2, 2, 2,
 108                         TransliterationFlags::IGNORE_CASE,
 109                         SearchAlgorithms2::ABSOLUTE, '\\' ),
 110     m_eFamily         ( SfxStyleFamily::Para ),
 111     m_nCommand        ( SvxSearchCmd::FIND ),
 112     m_nCellType       ( SvxSearchCellType::FORMULA ),
 113     m_nAppFlag        ( SvxSearchApp::WRITER ),
 114     m_bRowDirection   ( true ),
 115     m_bAllTables      ( false ),
 116     m_bSearchFiltered ( false ),
 117     m_bSearchFormatted( false ),
 118     m_bNotes          ( false),
 119     m_bBackward       ( false ),
 120     m_bPattern        ( false ),
 121     m_bContent        ( false ),
 122     m_bAsianOptions   ( false ),
 123     m_nStartPointX(0),
 124     m_nStartPointY(0)
 125 {
 126     EnableNotification( lcl_GetNotifyNames() );
 127
 128     SvtSearchOptions aOpt;
 129
 130     m_bBackward       = aOpt.IsBackwards();
 131     m_bAsianOptions   = aOpt.IsUseAsianOptions();
 132     m_bNotes = aOpt.IsNotes();
 133
 134     if (aOpt.IsUseWildcard())
 135     {
 136         m_aSearchOpt.AlgorithmType2 = SearchAlgorithms2::WILDCARD;
 137         m_aSearchOpt.algorithmType = SearchAlgorithms_ABSOLUTE; // something valid
 138     }
 139     if (aOpt.IsUseRegularExpression())
 140     {
 141         m_aSearchOpt.AlgorithmType2 = SearchAlgorithms2::REGEXP;
 142         m_aSearchOpt.algorithmType = SearchAlgorithms_REGEXP;
 143     }
 144     if (aOpt.IsSimilaritySearch())
 145     {
 146         m_aSearchOpt.AlgorithmType2 = SearchAlgorithms2::APPROXIMATE;
 147         m_aSearchOpt.algorithmType = SearchAlgorithms_APPROXIMATE;
 148     }
 149     if (aOpt.IsWholeWordsOnly())
 150         m_aSearchOpt.searchFlag |= SearchFlags::NORM_WORD_ONLY;
 151
 152     TransliterationFlags& rFlags = m_aSearchOpt.transliterateFlags;
 153
 154     if (!aOpt.IsMatchCase())
 155         rFlags |= TransliterationFlags::IGNORE_CASE;
 156     if ( aOpt.IsMatchFullHalfWidthForms())
 157         rFlags |= TransliterationFlags::IGNORE_WIDTH;
 158     if ( aOpt.IsIgnoreDiacritics_CTL())
 159         rFlags |= TransliterationFlags::IGNORE_DIACRITICS_CTL ;
 160     if ( aOpt.IsIgnoreKashida_CTL())
 161         rFlags |= TransliterationFlags::IGNORE_KASHIDA_CTL ;
 162     if ( !m_bAsianOptions )
 163         return;
 164
 165     if ( aOpt.IsMatchHiraganaKatakana())
 166         rFlags |= TransliterationFlags::IGNORE_KANA;
 167     if ( aOpt.IsMatchContractions())
 168         rFlags |= TransliterationFlags::ignoreSize_ja_JP;
 169     if ( aOpt.IsMatchMinusDashChoon())
 170         rFlags |= TransliterationFlags::ignoreMinusSign_ja_JP;
 171     if ( aOpt.IsMatchRepeatCharMarks())
 172         rFlags |= TransliterationFlags::ignoreIterationMark_ja_JP;
 173     if ( aOpt.IsMatchVariantFormKanji())
 174         rFlags |= TransliterationFlags::ignoreTraditionalKanji_ja_JP;
 175     if ( aOpt.IsMatchOldKanaForms())
 176         rFlags |= TransliterationFlags::ignoreTraditionalKana_ja_JP;
 177     if ( aOpt.IsMatchDiziDuzu())
 178         rFlags |= TransliterationFlags::ignoreZiZu_ja_JP;
 179     if ( aOpt.IsMatchBavaHafa())
 180         rFlags |= TransliterationFlags::ignoreBaFa_ja_JP;
 181     if ( aOpt.IsMatchTsithichiDhizi())
 182         rFlags |= TransliterationFlags::ignoreTiJi_ja_JP;
 183     if ( aOpt.IsMatchHyuiyuByuvyu())
 184         rFlags |= TransliterationFlags::ignoreHyuByu_ja_JP;
 185     if ( aOpt.IsMatchSesheZeje())
 186         rFlags |= TransliterationFlags::ignoreSeZe_ja_JP;
 187     if ( aOpt.IsMatchIaiya())
 188         rFlags |= TransliterationFlags::ignoreIandEfollowedByYa_ja_JP;
 189     if ( aOpt.IsMatchKiku())
 190         rFlags |= TransliterationFlags::ignoreKiKuFollowedBySa_ja_JP;
 191     if ( aOpt.IsIgnorePunctuation())
 192         rFlags |= TransliterationFlags::ignoreSeparator_ja_JP;
 193     if ( aOpt.IsIgnoreWhitespace())
 194         rFlags |= TransliterationFlags::ignoreSpace_ja_JP;
 195     if ( aOpt.IsIgnoreProlongedSoundMark())
 196         rFlags |= TransliterationFlags::ignoreProlongedSoundMark_ja_JP;
 197     if ( aOpt.IsIgnoreMiddleDot())
 198         rFlags |= TransliterationFlags::ignoreMiddleDot_ja_JP;
 199 }
 200
 201
 202 SvxSearchItem::SvxSearchItem( const SvxSearchItem& rItem ) :
 203
 204     SfxPoolItem ( rItem ),
 205     ConfigItem( CFG_ROOT_NODE ),
 206
 207     m_aSearchOpt      ( rItem.m_aSearchOpt ),
 208     m_eFamily         ( rItem.m_eFamily ),
 209     m_nCommand        ( rItem.m_nCommand ),
 210     m_nCellType       ( rItem.m_nCellType ),
 211     m_nAppFlag        ( rItem.m_nAppFlag ),
 212     m_bRowDirection   ( rItem.m_bRowDirection ),
 213     m_bAllTables      ( rItem.m_bAllTables ),
 214     m_bSearchFiltered   ( rItem.m_bSearchFiltered ),
 215     m_bSearchFormatted  ( rItem.m_bSearchFormatted ),
 216     m_bNotes          ( rItem.m_bNotes),
 217     m_bBackward       ( rItem.m_bBackward ),
 218     m_bPattern        ( rItem.m_bPattern ),
 219     m_bContent        ( rItem.m_bContent ),
 220     m_bAsianOptions   ( rItem.m_bAsianOptions ),
 221     m_nStartPointX(rItem.m_nStartPointX),
 222     m_nStartPointY(rItem.m_nStartPointY)
 223 {
 224     EnableNotification( lcl_GetNotifyNames() );
 225 }
 226
 227 SvxSearchItem::~SvxSearchItem()
 228 {
 229 }
 230
 231 SvxSearchItem* SvxSearchItem::Clone( SfxItemPool *) const
 232 {
 233     return new SvxSearchItem(*this);
 234 }
 235
 236 //! used below
 237 static bool equalsWithoutLocale( const i18nutil::SearchOptions2& rItem1, const i18nutil::SearchOptions2& rItem2 )
 238 {
 239     return rItem1.algorithmType         == rItem2.algorithmType &&
 240            rItem1.searchFlag            == rItem2.searchFlag    &&
 241            rItem1.searchString          == rItem2.searchString  &&
 242            rItem1.replaceString         == rItem2.replaceString &&
 243            //rItem1.Locale              == rItem2.Locale        &&
 244            rItem1.changedChars          == rItem2.changedChars  &&
 245            rItem1.deletedChars          == rItem2.deletedChars  &&
 246            rItem1.insertedChars         == rItem2.insertedChars &&
 247            rItem1.transliterateFlags    == rItem2.transliterateFlags &&
 248            rItem1.AlgorithmType2        == rItem2.AlgorithmType2 &&
 249            rItem1.WildcardEscapeCharacter == rItem2.WildcardEscapeCharacter;
 250 }
 251
 252
 253 bool SvxSearchItem::operator==( const SfxPoolItem& rItem ) const
 254 {
 255     assert(SfxPoolItem::operator==(rItem));
 256     const SvxSearchItem &rSItem = static_cast<const SvxSearchItem &>(rItem);
 257     return ( m_nCommand       == rSItem.m_nCommand )        &&
 258            ( m_bBackward      == rSItem.m_bBackward )       &&
 259            ( m_bPattern       == rSItem.m_bPattern )        &&
 260            ( m_bContent       == rSItem.m_bContent )        &&
 261            ( m_eFamily        == rSItem.m_eFamily )         &&
 262            ( m_bRowDirection  == rSItem.m_bRowDirection )   &&
 263            ( m_bAllTables     == rSItem.m_bAllTables )      &&
 264            ( m_bSearchFiltered  == rSItem.m_bSearchFiltered )   &&
 265            ( m_bSearchFormatted == rSItem.m_bSearchFormatted )  &&
 266            ( m_nCellType      == rSItem.m_nCellType )       &&
 267            ( m_nAppFlag       == rSItem.m_nAppFlag )        &&
 268            ( m_bAsianOptions  == rSItem.m_bAsianOptions )   &&
 269            ( equalsWithoutLocale(m_aSearchOpt,rSItem.m_aSearchOpt )) &&
 270            ( m_bNotes         == rSItem.m_bNotes );
 271 }
 272
 273
 274 bool SvxSearchItem::GetPresentation
 275 (
 276     SfxItemPresentation ,
 277     MapUnit             ,
 278     MapUnit             ,
 279     OUString&           ,
 280     const IntlWrapper&
 281 )   const
 282 {
 283     return false;
 284 }
 285
 286 void SvxSearchItem::Notify( const Sequence< OUString > & )
 287 {
 288     // applies transliteration changes in the configuration database
 289     // to the current SvxSearchItem
 290     SetTransliterationFlags( SvtSearchOptions().GetTransliterationFlags() );
 291 }
 292
 293 void SvxSearchItem::ImplCommit()
 294 {
 295 }
 296
 297 void SvxSearchItem::SetMatchFullHalfWidthForms( bool bVal )
 298 {
 299     if (bVal)
 300         m_aSearchOpt.transliterateFlags |=  TransliterationFlags::IGNORE_WIDTH;
 301     else
 302         m_aSearchOpt.transliterateFlags &= ~TransliterationFlags::IGNORE_WIDTH;
 303 }
 304
 305
 306 void SvxSearchItem::SetWordOnly( bool bVal )
 307 {
 308     if (bVal)
 309         m_aSearchOpt.searchFlag |=  SearchFlags::NORM_WORD_ONLY;
 310     else
 311         m_aSearchOpt.searchFlag &= ~SearchFlags::NORM_WORD_ONLY;
 312 }
 313
 314
 315 void SvxSearchItem::SetExact( bool bVal )
 316 {
 317     if (!bVal)
 318         m_aSearchOpt.transliterateFlags |= TransliterationFlags::IGNORE_CASE;
 319     else
 320         m_aSearchOpt.transliterateFlags &= ~TransliterationFlags::IGNORE_CASE;
 321 }
 322
 323
 324 void SvxSearchItem::SetSelection( bool bVal )
 325 {
 326     if (bVal)
 327     {
 328         m_aSearchOpt.searchFlag |=  (SearchFlags::REG_NOT_BEGINOFLINE |
 329                                    SearchFlags::REG_NOT_ENDOFLINE);
 330     }
 331     else
 332     {
 333         m_aSearchOpt.searchFlag &= ~(SearchFlags::REG_NOT_BEGINOFLINE |
 334                                    SearchFlags::REG_NOT_ENDOFLINE);
 335     }
 336 }
 337
 338
 339 void SvxSearchItem::SetRegExp( bool bVal )
 340 {
 341     if ( bVal )
 342     {
 343         m_aSearchOpt.AlgorithmType2 = SearchAlgorithms2::REGEXP;
 344         m_aSearchOpt.algorithmType = SearchAlgorithms_REGEXP;
 345     }
 346     else if ( SearchAlgorithms2::REGEXP == m_aSearchOpt.AlgorithmType2 )
 347     {
 348         m_aSearchOpt.AlgorithmType2 = SearchAlgorithms2::ABSOLUTE;
 349         m_aSearchOpt.algorithmType = SearchAlgorithms_ABSOLUTE;
 350     }
 351 }
 352
 353
 354 void SvxSearchItem::SetWildcard( bool bVal )
 355 {
 356     if ( bVal )
 357     {
 358         m_aSearchOpt.AlgorithmType2 = SearchAlgorithms2::WILDCARD;
 359         m_aSearchOpt.algorithmType = SearchAlgorithms_ABSOLUTE; // something valid
 360     }
 361     else if ( SearchAlgorithms2::REGEXP == m_aSearchOpt.AlgorithmType2 )
 362     {
 363         m_aSearchOpt.AlgorithmType2 = SearchAlgorithms2::ABSOLUTE;
 364         m_aSearchOpt.algorithmType = SearchAlgorithms_ABSOLUTE;
 365     }
 366 }
 367
 368
 369 void SvxSearchItem::SetLEVRelaxed( bool bVal )
 370 {
 371     if (bVal)
 372         m_aSearchOpt.searchFlag |=  SearchFlags::LEV_RELAXED;
 373     else
 374         m_aSearchOpt.searchFlag &= ~SearchFlags::LEV_RELAXED;
 375 }
 376
 377
 378 void SvxSearchItem::SetLevenshtein( bool bVal )
 379 {
 380     if ( bVal )
 381     {
 382         m_aSearchOpt.AlgorithmType2 = SearchAlgorithms2::APPROXIMATE;
 383         m_aSearchOpt.algorithmType = SearchAlgorithms_APPROXIMATE;
 384     }
 385     else if ( SearchAlgorithms2::APPROXIMATE == m_aSearchOpt.AlgorithmType2 )
 386     {
 387         m_aSearchOpt.AlgorithmType2 = SearchAlgorithms2::ABSOLUTE;
 388         m_aSearchOpt.algorithmType = SearchAlgorithms_ABSOLUTE;
 389     }
 390 }
 391
 392
 393 void SvxSearchItem::SetTransliterationFlags( TransliterationFlags nFlags )
 394 {
 395     m_aSearchOpt.transliterateFlags = nFlags;
 396 }
 397
 398 bool SvxSearchItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const
 399 {
 400     nMemberId &= ~CONVERT_TWIPS;
 401     switch ( nMemberId )
 402     {
 403         case 0 :
 404         {
 405             Sequence< PropertyValue > aSeq( SRCH_PARAMS );
 406             aSeq[0].Name = SRCH_PARA_OPTIONS;
 407             aSeq[0].Value <<= m_aSearchOpt.toUnoSearchOptions2();
 408             aSeq[1].Name = SRCH_PARA_FAMILY;
 409             aSeq[1].Value <<= sal_Int16( m_eFamily );
 410             aSeq[2].Name = SRCH_PARA_COMMAND;
 411             aSeq[2].Value <<= static_cast<sal_uInt16>(m_nCommand);
 412             aSeq[3].Name = SRCH_PARA_CELLTYPE;
 413             aSeq[3].Value <<= static_cast<sal_uInt16>(m_nCellType);
 414             aSeq[4].Name = SRCH_PARA_APPFLAG;
 415             aSeq[4].Value <<= static_cast<sal_uInt16>(m_nAppFlag);
 416             aSeq[5].Name = SRCH_PARA_ROWDIR;
 417             aSeq[5].Value <<= m_bRowDirection;
 418             aSeq[6].Name = SRCH_PARA_ALLTABLES;
 419             aSeq[6].Value <<= m_bAllTables;
 420             aSeq[7].Name = SRCH_PARA_SEARCHFILTERED;
 421             aSeq[7].Value <<= m_bSearchFiltered;
 422             aSeq[8].Name = SRCH_PARA_SEARCHFORMATTED;
 423             aSeq[8].Value <<= m_bSearchFormatted;
 424             aSeq[9].Name = SRCH_PARA_BACKWARD;
 425             aSeq[9].Value <<= m_bBackward;
 426             aSeq[10].Name = SRCH_PARA_PATTERN;
 427             aSeq[10].Value <<= m_bPattern;
 428             aSeq[11].Name = SRCH_PARA_CONTENT;
 429             aSeq[11].Value <<= m_bContent;
 430             aSeq[12].Name = SRCH_PARA_ASIANOPT;
 431             aSeq[12].Value <<= m_bAsianOptions;
 432             rVal <<= aSeq;
 433         }
 434         break;
 435         case MID_SEARCH_COMMAND:
 436             rVal <<= static_cast<sal_Int16>(m_nCommand); break;
 437         case MID_SEARCH_STYLEFAMILY:
 438             rVal <<= static_cast<sal_Int16>(m_eFamily); break;
 439         case MID_SEARCH_CELLTYPE:
 440             rVal <<= static_cast<sal_Int32>(m_nCellType); break;
 441         case MID_SEARCH_ROWDIRECTION:
 442             rVal <<= m_bRowDirection; break;
 443         case MID_SEARCH_ALLTABLES:
 444             rVal <<= m_bAllTables; break;
 445         case MID_SEARCH_SEARCHFILTERED:
 446             rVal <<= m_bSearchFiltered; break;
 447         case MID_SEARCH_SEARCHFORMATTED:
 448             rVal <<= m_bSearchFormatted; break;
 449         case MID_SEARCH_BACKWARD:
 450             rVal <<= m_bBackward; break;
 451         case MID_SEARCH_PATTERN:
 452             rVal <<= m_bPattern; break;
 453         case MID_SEARCH_CONTENT:
 454             rVal <<= m_bContent; break;
 455         case MID_SEARCH_ASIANOPTIONS:
 456             rVal <<= m_bAsianOptions; break;
 457         case MID_SEARCH_ALGORITHMTYPE:
 458             rVal <<= static_cast<sal_Int16>(m_aSearchOpt.algorithmType); break;
 459         case MID_SEARCH_ALGORITHMTYPE2:
 460             rVal <<= m_aSearchOpt.AlgorithmType2; break;
 461         case MID_SEARCH_FLAGS:
 462             rVal <<= m_aSearchOpt.searchFlag; break;
 463         case MID_SEARCH_SEARCHSTRING:
 464             rVal <<= m_aSearchOpt.searchString; break;
 465         case MID_SEARCH_REPLACESTRING:
 466             rVal <<= m_aSearchOpt.replaceString; break;
 467         case MID_SEARCH_CHANGEDCHARS:
 468             rVal <<= m_aSearchOpt.changedChars; break;
 469         case MID_SEARCH_DELETEDCHARS:
 470             rVal <<= m_aSearchOpt.deletedChars; break;
 471         case MID_SEARCH_INSERTEDCHARS:
 472             rVal <<= m_aSearchOpt.insertedChars; break;
 473         case MID_SEARCH_TRANSLITERATEFLAGS:
 474             rVal <<= static_cast<sal_Int32>(m_aSearchOpt.transliterateFlags); break;
 475         case MID_SEARCH_LOCALE:
 476         {
 477             LanguageType nLocale;
 478             if (!m_aSearchOpt.Locale.Language.isEmpty() || !m_aSearchOpt.Locale.Country.isEmpty() )
 479                 nLocale = LanguageTag::convertToLanguageType( m_aSearchOpt.Locale );
 480             else
 481                 nLocale = LANGUAGE_NONE;
 482             rVal <<= static_cast<sal_Int16>(static_cast<sal_uInt16>(nLocale));
 483             break;
 484         }
 485
 486         default:
 487             SAL_WARN( "svl.items", "SvxSearchItem::QueryValue(): Unknown MemberId" );
 488             return false;
 489     }
 490
 491     return true;
 492 }
 493
 494
 495 bool SvxSearchItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId )
 496 {
 497     nMemberId &= ~CONVERT_TWIPS;
 498     bool bRet = false;
 499     sal_Int32 nInt = 0;
 500     switch ( nMemberId )
 501     {
 502         case 0 :
 503         {
 504             Sequence< PropertyValue > aSeq;
 505             if ( ( rVal >>= aSeq ) && ( aSeq.getLength() == SRCH_PARAMS ) )
 506             {
 507                 sal_Int16 nConvertedCount( 0 );
 508                 for ( const auto& rProp : std::as_const(aSeq) )
 509                 {
 510                     if ( rProp.Name == SRCH_PARA_OPTIONS )
 511                     {
 512                         css::util::SearchOptions2 nTmpSearchOpt2;
 513                         if ( rProp.Value >>= nTmpSearchOpt2 )
 514                         {
 515                             m_aSearchOpt = nTmpSearchOpt2;
 516                             ++nConvertedCount;
 517                         }
 518                     }
 519                     else if ( rProp.Name == SRCH_PARA_FAMILY )
 520                     {
 521                         sal_uInt16 nTemp( 0 );
 522                         if ( rProp.Value >>= nTemp )
 523                         {
 524                             m_eFamily = SfxStyleFamily( nTemp );
 525                             ++nConvertedCount;
 526                         }
 527                     }
 528                     else if ( rProp.Name == SRCH_PARA_COMMAND )
 529                     {
 530                         sal_uInt16 nTmp;
 531                         if ( rProp.Value >>= nTmp )
 532                         {
 533                             m_nCommand = static_cast<SvxSearchCmd>(nTmp);
 534                             ++nConvertedCount;
 535                         }
 536                     }
 537                     else if ( rProp.Name == SRCH_PARA_CELLTYPE )
 538                     {
 539                         sal_uInt16 nTmp;
 540                         if ( rProp.Value >>= nTmp )
 541                         {
 542                             m_nCellType = static_cast<SvxSearchCellType>(nTmp);
 543                             ++nConvertedCount;
 544                         }
 545                     }
 546                     else if ( rProp.Name == SRCH_PARA_APPFLAG )
 547                     {
 548                         sal_uInt16 nTmp;
 549                         if ( rProp.Value >>= nTmp )
 550                         {
 551                             m_nAppFlag = static_cast<SvxSearchApp>(nTmp);
 552                             ++nConvertedCount;
 553                         }
 554                     }
 555                     else if ( rProp.Name == SRCH_PARA_ROWDIR )
 556                     {
 557                         if ( rProp.Value >>= m_bRowDirection )
 558                             ++nConvertedCount;
 559                     }
 560                     else if ( rProp.Name == SRCH_PARA_ALLTABLES )
 561                     {
 562                         if ( rProp.Value >>= m_bAllTables )
 563                             ++nConvertedCount;
 564                     }
 565                     else if ( rProp.Name == SRCH_PARA_SEARCHFILTERED )
 566                     {
 567                         if ( rProp.Value >>= m_bSearchFiltered )
 568                             ++nConvertedCount;
 569                     }
 570                     else if ( rProp.Name == SRCH_PARA_SEARCHFORMATTED )
 571                     {
 572                         if ( rProp.Value >>= m_bSearchFormatted )
 573                             ++nConvertedCount;
 574                     }
 575                     else if ( rProp.Name == SRCH_PARA_BACKWARD )
 576                     {
 577                         if ( rProp.Value >>= m_bBackward )
 578                             ++nConvertedCount;
 579                     }
 580                     else if ( rProp.Name == SRCH_PARA_PATTERN )
 581                     {
 582                         if ( rProp.Value >>= m_bPattern )
 583                             ++nConvertedCount;
 584                     }
 585                     else if ( rProp.Name == SRCH_PARA_CONTENT )
 586                     {
 587                         if ( rProp.Value >>= m_bContent )
 588                             ++nConvertedCount;
 589                     }
 590                     else if ( rProp.Name == SRCH_PARA_ASIANOPT )
 591                     {
 592                         if ( rProp.Value >>= m_bAsianOptions )
 593                             ++nConvertedCount;
 594                     }
 595                 }
 596
 597                 bRet = ( nConvertedCount == SRCH_PARAMS );
 598             }
 599             break;
 600         }
 601         case MID_SEARCH_COMMAND:
 602             bRet = (rVal >>= nInt); m_nCommand = static_cast<SvxSearchCmd>(nInt); break;
 603         case MID_SEARCH_STYLEFAMILY:
 604             bRet = (rVal >>= nInt); m_eFamily =  static_cast<SfxStyleFamily>(static_cast<sal_Int16>(nInt)); break;
 605         case MID_SEARCH_CELLTYPE:
 606             bRet = (rVal >>= nInt); m_nCellType = static_cast<SvxSearchCellType>(nInt); break;
 607         case MID_SEARCH_ROWDIRECTION:
 608             bRet = (rVal >>= m_bRowDirection); break;
 609         case MID_SEARCH_ALLTABLES:
 610             bRet = (rVal >>= m_bAllTables); break;
 611         case MID_SEARCH_SEARCHFILTERED:
 612             bRet = (rVal >>= m_bSearchFiltered); break;
 613         case MID_SEARCH_SEARCHFORMATTED:
 614             bRet = (rVal >>= m_bSearchFormatted); break;
 615         case MID_SEARCH_BACKWARD:
 616             bRet = (rVal >>= m_bBackward); break;
 617         case MID_SEARCH_PATTERN:
 618             bRet = (rVal >>= m_bPattern); break;
 619         case MID_SEARCH_CONTENT:
 620             bRet = (rVal >>= m_bContent); break;
 621         case MID_SEARCH_ASIANOPTIONS:
 622             bRet = (rVal >>= m_bAsianOptions); break;
 623         case MID_SEARCH_ALGORITHMTYPE:
 624             bRet = (rVal >>= nInt); m_aSearchOpt.algorithmType = static_cast<SearchAlgorithms>(static_cast<sal_Int16>(nInt)); break;
 625         case MID_SEARCH_ALGORITHMTYPE2:
 626             bRet = (rVal >>= nInt); m_aSearchOpt.AlgorithmType2 = static_cast<sal_Int16>(nInt); break;
 627         case MID_SEARCH_FLAGS:
 628             bRet = (rVal >>= m_aSearchOpt.searchFlag); break;
 629         case MID_SEARCH_SEARCHSTRING:
 630             bRet = (rVal >>= m_aSearchOpt.searchString); break;
 631         case MID_SEARCH_REPLACESTRING:
 632             bRet = (rVal >>= m_aSearchOpt.replaceString); break;
 633         case MID_SEARCH_CHANGEDCHARS:
 634             bRet = (rVal >>= m_aSearchOpt.changedChars); break;
 635         case MID_SEARCH_DELETEDCHARS:
 636             bRet = (rVal >>= m_aSearchOpt.deletedChars); break;
 637         case MID_SEARCH_INSERTEDCHARS:
 638             bRet = (rVal >>= m_aSearchOpt.insertedChars); break;
 639         case MID_SEARCH_TRANSLITERATEFLAGS:
 640         {
 641             bRet = (rVal >>= nInt);
 642             if (bRet)
 643                 m_aSearchOpt.transliterateFlags = static_cast<TransliterationFlags>(nInt);
 644             break;
 645         }
 646         case MID_SEARCH_LOCALE:
 647         {
 648             bRet = (rVal >>= nInt);
 649             if ( bRet )
 650             {
 651                 if ( LanguageType(nInt) == LANGUAGE_NONE )
 652                 {
 653                     m_aSearchOpt.Locale = css::lang::Locale();
 654                 }
 655                 else
 656                 {
 657                     m_aSearchOpt.Locale = LanguageTag::convertToLocale( LanguageType(nInt) );
 658                 }
 659             }
 660             break;
 661         }
 662         case MID_SEARCH_STARTPOINTX:
 663         {
 664             bRet = (rVal >>= m_nStartPointX);
 665             break;
 666         }
 667         case MID_SEARCH_STARTPOINTY:
 668         {
 669             bRet = (rVal >>= m_nStartPointY);
 670             break;
 671         }
 672         default:
 673             OSL_FAIL( "Unknown MemberId" );
 674     }
 675
 676     return bRet;
 677 }
 678
 679 sal_Int32 SvxSearchItem::GetStartPointX() const
 680 {
 681     return m_nStartPointX;
 682 }
 683
 684 sal_Int32 SvxSearchItem::GetStartPointY() const
 685 {
 686     return m_nStartPointY;
 687 }
 688
 689 bool SvxSearchItem::HasStartPoint() const
 690 {
 691     return m_nStartPointX > 0 || m_nStartPointY > 0;
 692 }
 693
 694 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */