unotools/source/config/searchopt.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 <unotools/searchopt.hxx>
  23 #include <tools/debug.hxx>
  24 #include <unotools/configitem.hxx>
  25 #include <com/sun/star/uno/Sequence.hxx>
  26 #include <com/sun/star/uno/Any.h>
  27 #include <sal/macros.h>
  28 #include <osl/diagnose.h>
  29 #include <i18nutil/transliteration.hxx>
  30
  31 using namespace utl;
  32 using namespace com::sun::star::uno;
  33
  34 #define MAX_FLAGS_OFFSET    29
  35
  36 class SvtSearchOptions_Impl : public ConfigItem
  37 {
  38     sal_Int32   nFlags;
  39     bool    bModified;
  40
  41     SvtSearchOptions_Impl(const SvtSearchOptions_Impl&) = delete;
  42     SvtSearchOptions_Impl& operator=(const SvtSearchOptions_Impl&) = delete;
  43
  44     // ConfigItem
  45     virtual void    ImplCommit() override;
  46
  47 protected:
  48     bool            IsModified() const { return bModified; }
  49     using ConfigItem::SetModified;
  50     void            SetModified( bool bVal );
  51     void            Load();
  52     bool            Save();
  53
  54     static Sequence< OUString >    GetPropertyNames();
  55
  56 public:
  57     SvtSearchOptions_Impl();
  58     virtual ~SvtSearchOptions_Impl() override;
  59
  60     virtual void    Notify( const css::uno::Sequence< OUString >& aPropertyNames ) override;
  61
  62     bool            GetFlag( sal_uInt16 nOffset ) const;
  63     void            SetFlag( sal_uInt16 nOffset, bool bVal );
  64     void            SetSearchAlgorithm( sal_uInt16 nOffset, bool bVal );
  65 };
  66
  67 SvtSearchOptions_Impl::SvtSearchOptions_Impl() :
  68     ConfigItem( "Office.Common/SearchOptions" ),
  69     nFlags(0x0003FFFF) // set all options values to 'true'
  70
  71 {
  72     Load();
  73     SetModified( false );
  74 }
  75
  76 SvtSearchOptions_Impl::~SvtSearchOptions_Impl()
  77 {
  78     assert(!IsModified()); // should have been committed
  79 }
  80
  81 void SvtSearchOptions_Impl::ImplCommit()
  82 {
  83     if (IsModified())
  84         Save();
  85 }
  86
  87 void SvtSearchOptions_Impl::Notify( const Sequence< OUString >&  )
  88 {
  89 }
  90
  91 bool SvtSearchOptions_Impl::GetFlag( sal_uInt16 nOffset ) const
  92 {
  93     DBG_ASSERT( nOffset <= MAX_FLAGS_OFFSET, "offset out of range");
  94     return ((nFlags >> nOffset) & 0x01) != 0;
  95 }
  96
  97 void SvtSearchOptions_Impl::SetFlag( sal_uInt16 nOffset, bool bVal )
  98 {
  99     DBG_ASSERT( nOffset <= MAX_FLAGS_OFFSET, "offset out of range");
 100     sal_Int32 nOldFlags = nFlags;
 101     sal_Int32 nMask = (sal_Int32(1))  << nOffset;
 102     if (bVal)
 103         nFlags |= nMask;
 104     else
 105         nFlags &= ~nMask;
 106     if (nFlags != nOldFlags)
 107         SetModified( true );
 108 }
 109
 110 void SvtSearchOptions_Impl::SetModified( bool bVal )
 111 {
 112     bModified = bVal;
 113     if (bModified)
 114     {
 115         ConfigItem::SetModified();
 116     }
 117 }
 118
 119 Sequence< OUString > SvtSearchOptions_Impl::GetPropertyNames()
 120 {
 121     static const char* aPropNames[ MAX_FLAGS_OFFSET + 1 ] =
 122     {
 123         "IsWholeWordsOnly",                     //  0
 124         "IsBackwards",                          //  1
 125         "IsUseRegularExpression",               //  2
 126         //"IsCurrentSelectionOnly",             // interactively set or not...
 127         "IsSearchForStyles",                    //  3
 128         "IsSimilaritySearch",                   //  4
 129         "IsUseAsianOptions",                    //  5
 130         "IsMatchCase",                          //  6
 131         "Japanese/IsMatchFullHalfWidthForms",   //  7
 132         "Japanese/IsMatchHiraganaKatakana",     //  8
 133         "Japanese/IsMatchContractions",         //  9
 134         "Japanese/IsMatchMinusDashCho-on",      // 10
 135         "Japanese/IsMatchRepeatCharMarks",      // 11
 136         "Japanese/IsMatchVariantFormKanji",     // 12
 137         "Japanese/IsMatchOldKanaForms",         // 13
 138         "Japanese/IsMatch_DiZi_DuZu",           // 14
 139         "Japanese/IsMatch_BaVa_HaFa",           // 15
 140         "Japanese/IsMatch_TsiThiChi_DhiZi",     // 16
 141         "Japanese/IsMatch_HyuIyu_ByuVyu",       // 17
 142         "Japanese/IsMatch_SeShe_ZeJe",          // 18
 143         "Japanese/IsMatch_IaIya",               // 19
 144         "Japanese/IsMatch_KiKu",                // 20
 145         "Japanese/IsIgnorePunctuation",         // 21
 146         "Japanese/IsIgnoreWhitespace",          // 22
 147         "Japanese/IsIgnoreProlongedSoundMark",  // 23
 148         "Japanese/IsIgnoreMiddleDot",           // 24
 149         "IsNotes",                              // 25
 150         "IsIgnoreDiacritics_CTL",               // 26
 151         "IsIgnoreKashida_CTL",                  // 27
 152         "IsSearchFormatted",                    // 28
 153         "IsUseWildcard"                         // 29
 154     };
 155
 156     const int nCount = SAL_N_ELEMENTS( aPropNames );
 157     Sequence< OUString > aNames( nCount );
 158     OUString* pNames = aNames.getArray();
 159     for (sal_Int32 i = 0;  i < nCount;  ++i)
 160         pNames[i] = OUString::createFromAscii( aPropNames[i] );
 161
 162     return aNames;
 163 }
 164
 165 void SvtSearchOptions_Impl::SetSearchAlgorithm( sal_uInt16 nOffset, bool bVal )
 166 {
 167     if (bVal)
 168     {
 169         // Search algorithms are mutually exclusive.
 170         if (nOffset != 2 && GetFlag(2))
 171             SetFlag( 2, false );
 172         if (nOffset != 4 && GetFlag(4))
 173             SetFlag( 4, false );
 174         if (nOffset != 29 && GetFlag(29))
 175             SetFlag( 29, false );
 176     }
 177     SetFlag( nOffset, bVal );
 178 }
 179
 180 void SvtSearchOptions_Impl::Load()
 181 {
 182     bool bSucc = false;
 183
 184     Sequence< OUString > aNames = GetPropertyNames();
 185     sal_Int32 nProps = aNames.getLength();
 186
 187     const Sequence< Any > aValues = GetProperties( aNames );
 188     DBG_ASSERT( aValues.getLength() == aNames.getLength(),
 189             "GetProperties failed" );
 190     //EnableNotification( aNames );
 191
 192     if (nProps  &&  aValues.getLength() == nProps)
 193     {
 194         bSucc = true;
 195
 196         const Any* pValues = aValues.getConstArray();
 197         for (sal_Int32 i = 0;  i < nProps;  ++i)
 198         {
 199             const Any &rVal = pValues[i];
 200             DBG_ASSERT( rVal.hasValue(), "property value missing" );
 201             if (rVal.hasValue())
 202             {
 203                 bool bVal = bool();
 204                 if (rVal >>= bVal)
 205                 {
 206                     if (i <= MAX_FLAGS_OFFSET)
 207                     {
 208                         // use index in sequence as flag index
 209                         SetFlag( i, bVal );
 210                     }
 211                     else {
 212                         OSL_FAIL( "unexpected index" );
 213                     }
 214                 }
 215                 else
 216                 {
 217                     OSL_FAIL( "unexpected type" );
 218                     bSucc = false;
 219                 }
 220             }
 221             else
 222             {
 223                 OSL_FAIL( "value missing" );
 224                 bSucc = false;
 225             }
 226         }
 227     }
 228     DBG_ASSERT( bSucc, "LoadConfig failed" );
 229 }
 230
 231 bool SvtSearchOptions_Impl::Save()
 232 {
 233     bool bSucc = false;
 234
 235     const Sequence< OUString > aNames = GetPropertyNames();
 236     sal_Int32 nProps = aNames.getLength();
 237
 238     Sequence< Any > aValues( nProps );
 239     Any *pValue = aValues.getArray();
 240
 241     DBG_ASSERT( nProps == MAX_FLAGS_OFFSET + 1,
 242             "unexpected size of index" );
 243     if (nProps == MAX_FLAGS_OFFSET + 1)
 244     {
 245         for (sal_Int32 i = 0;  i < nProps;  ++i)
 246             pValue[i] <<= GetFlag(i);
 247         bSucc |= PutProperties( aNames, aValues );
 248     }
 249
 250     if (bSucc)
 251         SetModified( false );
 252
 253     return bSucc;
 254 }
 255
 256 SvtSearchOptions::SvtSearchOptions()
 257     : pImpl( new SvtSearchOptions_Impl )
 258 {
 259 }
 260
 261 SvtSearchOptions::~SvtSearchOptions()
 262 {
 263 }
 264
 265 void SvtSearchOptions::Commit()
 266 {
 267     pImpl->Commit();
 268 }
 269
 270 TransliterationFlags SvtSearchOptions::GetTransliterationFlags() const
 271 {
 272     TransliterationFlags nRes = TransliterationFlags::NONE;
 273
 274     if (!IsMatchCase()) // 'IsMatchCase' means act case sensitive
 275         nRes |= TransliterationFlags::IGNORE_CASE;
 276     if ( IsMatchFullHalfWidthForms())
 277         nRes |= TransliterationFlags::IGNORE_WIDTH;
 278     if ( IsMatchHiraganaKatakana())
 279         nRes |= TransliterationFlags::IGNORE_KANA;
 280     if ( IsMatchContractions())
 281         nRes |= TransliterationFlags::ignoreSize_ja_JP;
 282     if ( IsMatchMinusDashChoon())
 283         nRes |= TransliterationFlags::ignoreMinusSign_ja_JP;
 284     if ( IsMatchRepeatCharMarks())
 285         nRes |= TransliterationFlags::ignoreIterationMark_ja_JP;
 286     if ( IsMatchVariantFormKanji())
 287         nRes |= TransliterationFlags::ignoreTraditionalKanji_ja_JP;
 288     if ( IsMatchOldKanaForms())
 289         nRes |= TransliterationFlags::ignoreTraditionalKana_ja_JP;
 290     if ( IsMatchDiziDuzu())
 291         nRes |= TransliterationFlags::ignoreZiZu_ja_JP;
 292     if ( IsMatchBavaHafa())
 293         nRes |= TransliterationFlags::ignoreBaFa_ja_JP;
 294     if ( IsMatchTsithichiDhizi())
 295         nRes |= TransliterationFlags::ignoreTiJi_ja_JP;
 296     if ( IsMatchHyuiyuByuvyu())
 297         nRes |= TransliterationFlags::ignoreHyuByu_ja_JP;
 298     if ( IsMatchSesheZeje())
 299         nRes |= TransliterationFlags::ignoreSeZe_ja_JP;
 300     if ( IsMatchIaiya())
 301         nRes |= TransliterationFlags::ignoreIandEfollowedByYa_ja_JP;
 302     if ( IsMatchKiku())
 303         nRes |= TransliterationFlags::ignoreKiKuFollowedBySa_ja_JP;
 304     if ( IsIgnorePunctuation())
 305         nRes |= TransliterationFlags::ignoreSeparator_ja_JP;
 306     if ( IsIgnoreWhitespace())
 307         nRes |= TransliterationFlags::ignoreSpace_ja_JP;
 308     if ( IsIgnoreProlongedSoundMark())
 309         nRes |= TransliterationFlags::ignoreProlongedSoundMark_ja_JP;
 310     if ( IsIgnoreMiddleDot())
 311         nRes |= TransliterationFlags::ignoreMiddleDot_ja_JP;
 312     if ( IsIgnoreDiacritics_CTL())
 313         nRes |= TransliterationFlags::IGNORE_DIACRITICS_CTL;
 314     if ( IsIgnoreKashida_CTL())
 315         nRes |= TransliterationFlags::IGNORE_KASHIDA_CTL;
 316     return nRes;
 317 }
 318
 319 bool SvtSearchOptions::IsWholeWordsOnly() const
 320 {
 321     return pImpl->GetFlag( 0 );
 322 }
 323
 324 void SvtSearchOptions::SetWholeWordsOnly( bool bVal )
 325 {
 326     pImpl->SetFlag( 0, bVal );
 327 }
 328
 329 bool SvtSearchOptions::IsBackwards() const
 330 {
 331     return pImpl->GetFlag( 1 );
 332 }
 333
 334 void SvtSearchOptions::SetBackwards( bool bVal )
 335 {
 336     pImpl->SetFlag( 1, bVal );
 337 }
 338
 339 bool SvtSearchOptions::IsUseRegularExpression() const
 340 {
 341     return pImpl->GetFlag( 2 );
 342 }
 343
 344 void SvtSearchOptions::SetUseRegularExpression( bool bVal )
 345 {
 346     pImpl->SetSearchAlgorithm( 2, bVal );
 347 }
 348
 349 void SvtSearchOptions::SetSearchForStyles( bool bVal )
 350 {
 351     pImpl->SetFlag( 3, bVal );
 352 }
 353
 354 bool SvtSearchOptions::IsSimilaritySearch() const
 355 {
 356     return pImpl->GetFlag( 4 );
 357 }
 358
 359 void SvtSearchOptions::SetSimilaritySearch( bool bVal )
 360 {
 361     pImpl->SetSearchAlgorithm( 4, bVal );
 362 }
 363
 364 bool SvtSearchOptions::IsUseAsianOptions() const
 365 {
 366     return pImpl->GetFlag( 5 );
 367 }
 368
 369 void SvtSearchOptions::SetUseAsianOptions( bool bVal )
 370 {
 371     pImpl->SetFlag( 5, bVal );
 372 }
 373
 374 bool SvtSearchOptions::IsMatchCase() const
 375 {
 376     return pImpl->GetFlag( 6 );
 377 }
 378
 379 void SvtSearchOptions::SetMatchCase( bool bVal )
 380 {
 381     pImpl->SetFlag( 6, bVal );
 382 }
 383
 384 bool SvtSearchOptions::IsMatchFullHalfWidthForms() const
 385 {
 386     return pImpl->GetFlag( 7 );
 387 }
 388
 389 void SvtSearchOptions::SetMatchFullHalfWidthForms( bool bVal )
 390 {
 391     pImpl->SetFlag( 7, bVal );
 392 }
 393
 394 bool SvtSearchOptions::IsMatchHiraganaKatakana() const
 395 {
 396     return pImpl->GetFlag( 8 );
 397 }
 398
 399 void SvtSearchOptions::SetMatchHiraganaKatakana( bool bVal )
 400 {
 401     pImpl->SetFlag( 8, bVal );
 402 }
 403
 404 bool SvtSearchOptions::IsMatchContractions() const
 405 {
 406     return pImpl->GetFlag( 9 );
 407 }
 408
 409 void SvtSearchOptions::SetMatchContractions( bool bVal )
 410 {
 411     pImpl->SetFlag( 9, bVal );
 412 }
 413
 414 bool SvtSearchOptions::IsMatchMinusDashChoon() const
 415 {
 416     return pImpl->GetFlag( 10 );
 417 }
 418
 419 void SvtSearchOptions::SetMatchMinusDashChoon( bool bVal )
 420 {
 421     pImpl->SetFlag( 10, bVal );
 422 }
 423
 424 bool SvtSearchOptions::IsMatchRepeatCharMarks() const
 425 {
 426     return pImpl->GetFlag( 11 );
 427 }
 428
 429 void SvtSearchOptions::SetMatchRepeatCharMarks( bool bVal )
 430 {
 431     pImpl->SetFlag( 11, bVal );
 432 }
 433
 434 bool SvtSearchOptions::IsMatchVariantFormKanji() const
 435 {
 436     return pImpl->GetFlag( 12 );
 437 }
 438
 439 void SvtSearchOptions::SetMatchVariantFormKanji( bool bVal )
 440 {
 441     pImpl->SetFlag( 12, bVal );
 442 }
 443
 444 bool SvtSearchOptions::IsMatchOldKanaForms() const
 445 {
 446     return pImpl->GetFlag( 13 );
 447 }
 448
 449 void SvtSearchOptions::SetMatchOldKanaForms( bool bVal )
 450 {
 451     pImpl->SetFlag( 13, bVal );
 452 }
 453
 454 bool SvtSearchOptions::IsMatchDiziDuzu() const
 455 {
 456     return pImpl->GetFlag( 14 );
 457 }
 458
 459 void SvtSearchOptions::SetMatchDiziDuzu( bool bVal )
 460 {
 461     pImpl->SetFlag( 14, bVal );
 462 }
 463
 464 bool SvtSearchOptions::IsMatchBavaHafa() const
 465 {
 466     return pImpl->GetFlag( 15 );
 467 }
 468
 469 void SvtSearchOptions::SetMatchBavaHafa( bool bVal )
 470 {
 471     pImpl->SetFlag( 15, bVal );
 472 }
 473
 474 bool SvtSearchOptions::IsMatchTsithichiDhizi() const
 475 {
 476     return pImpl->GetFlag( 16 );
 477 }
 478
 479 void SvtSearchOptions::SetMatchTsithichiDhizi( bool bVal )
 480 {
 481     pImpl->SetFlag( 16, bVal );
 482 }
 483
 484 bool SvtSearchOptions::IsMatchHyuiyuByuvyu() const
 485 {
 486     return pImpl->GetFlag( 17 );
 487 }
 488
 489 void SvtSearchOptions::SetMatchHyuiyuByuvyu( bool bVal )
 490 {
 491     pImpl->SetFlag( 17, bVal );
 492 }
 493
 494 bool SvtSearchOptions::IsMatchSesheZeje() const
 495 {
 496     return pImpl->GetFlag( 18 );
 497 }
 498
 499 void SvtSearchOptions::SetMatchSesheZeje( bool bVal )
 500 {
 501     pImpl->SetFlag( 18, bVal );
 502 }
 503
 504 bool SvtSearchOptions::IsMatchIaiya() const
 505 {
 506     return pImpl->GetFlag( 19 );
 507 }
 508
 509 void SvtSearchOptions::SetMatchIaiya( bool bVal )
 510 {
 511     pImpl->SetFlag( 19, bVal );
 512 }
 513
 514 bool SvtSearchOptions::IsMatchKiku() const
 515 {
 516     return pImpl->GetFlag( 20 );
 517 }
 518
 519 void SvtSearchOptions::SetMatchKiku( bool bVal )
 520 {
 521     pImpl->SetFlag( 20, bVal );
 522 }
 523
 524 bool SvtSearchOptions::IsIgnorePunctuation() const
 525 {
 526     return pImpl->GetFlag( 21 );
 527 }
 528
 529 void SvtSearchOptions::SetIgnorePunctuation( bool bVal )
 530 {
 531     pImpl->SetFlag( 21, bVal );
 532 }
 533
 534 bool SvtSearchOptions::IsIgnoreWhitespace() const
 535 {
 536     return pImpl->GetFlag( 22 );
 537 }
 538
 539 void SvtSearchOptions::SetIgnoreWhitespace( bool bVal )
 540 {
 541     pImpl->SetFlag( 22, bVal );
 542 }
 543
 544 bool SvtSearchOptions::IsIgnoreProlongedSoundMark() const
 545 {
 546     return pImpl->GetFlag( 23 );
 547 }
 548
 549 void SvtSearchOptions::SetIgnoreProlongedSoundMark( bool bVal )
 550 {
 551     pImpl->SetFlag( 23, bVal );
 552 }
 553
 554 bool SvtSearchOptions::IsIgnoreMiddleDot() const
 555 {
 556     return pImpl->GetFlag( 24 );
 557 }
 558
 559 void SvtSearchOptions::SetIgnoreMiddleDot( bool bVal )
 560 {
 561     pImpl->SetFlag( 24, bVal );
 562 }
 563
 564 bool SvtSearchOptions::IsNotes() const
 565 {
 566     return pImpl->GetFlag( 25 );
 567 }
 568
 569 void SvtSearchOptions::SetNotes( bool bVal )
 570 {
 571     pImpl->SetFlag( 25, bVal );
 572 }
 573
 574 bool SvtSearchOptions::IsIgnoreDiacritics_CTL() const
 575 {
 576     return pImpl->GetFlag( 26 );
 577 }
 578
 579 void SvtSearchOptions::SetIgnoreDiacritics_CTL( bool bVal )
 580 {
 581     pImpl->SetFlag( 26, bVal );
 582 }
 583
 584 bool SvtSearchOptions::IsIgnoreKashida_CTL() const
 585 {
 586     return pImpl->GetFlag( 27 );
 587 }
 588
 589 void SvtSearchOptions::SetIgnoreKashida_CTL( bool bVal )
 590 {
 591     pImpl->SetFlag( 27, bVal );
 592 }
 593
 594 bool SvtSearchOptions::IsSearchFormatted() const
 595 {
 596     return pImpl->GetFlag( 28 );
 597 }
 598
 599 void SvtSearchOptions::SetSearchFormatted( bool bVal )
 600 {
 601     pImpl->SetFlag( 28, bVal );
 602 }
 603
 604 bool SvtSearchOptions::IsUseWildcard() const
 605 {
 606     return pImpl->GetFlag( 29 );
 607 }
 608
 609 void SvtSearchOptions::SetUseWildcard( bool bVal )
 610 {
 611     pImpl->SetSearchAlgorithm( 29, bVal );
 612 }
 613
 614 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */