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/i18n/TransliterationModules.hpp>
  26 #include <com/sun/star/i18n/TransliterationModulesExtra.hpp>
  27 #include <com/sun/star/uno/Sequence.hxx>
  28 #include <com/sun/star/uno/Any.h>
  29 #include <sal/macros.h>
  30 #include <osl/diagnose.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
  39 {
  40     sal_Int32   nFlags;
  41     bool    bModified;
  42
  43     SvtSearchOptions_Impl(const SvtSearchOptions_Impl&) SAL_DELETED_FUNCTION;
  44     SvtSearchOptions_Impl& operator=(const SvtSearchOptions_Impl&) SAL_DELETED_FUNCTION;
  45
  46     // ConfigItem
  47     virtual void    ImplCommit() SAL_OVERRIDE;
  48
  49 protected:
  50     bool            IsModified() const { return bModified; }
  51     using ConfigItem::SetModified;
  52     void            SetModified( bool bVal );
  53     bool            Load();
  54     bool            Save();
  55
  56     static Sequence< OUString >    GetPropertyNames();
  57
  58 public:
  59     SvtSearchOptions_Impl();
  60     virtual ~SvtSearchOptions_Impl();
  61
  62     virtual void    Notify( const com::sun::star::uno::Sequence< OUString >& aPropertyNames ) SAL_OVERRIDE;
  63
  64     bool            GetFlag( sal_uInt16 nOffset ) const;
  65     void            SetFlag( sal_uInt16 nOffset, bool bVal );
  66 };
  67
  68 SvtSearchOptions_Impl::SvtSearchOptions_Impl() :
  69     ConfigItem( OUString("Office.Common/SearchOptions") )
  70 {
  71     nFlags = 0x0003FFFF;    // set all options values to 'true'
  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     };
 153
 154     const int nCount = SAL_N_ELEMENTS( aPropNames );
 155     Sequence< OUString > aNames( nCount );
 156     OUString* pNames = aNames.getArray();
 157     for (sal_Int32 i = 0;  i < nCount;  ++i)
 158         pNames[i] = OUString::createFromAscii( aPropNames[i] );
 159
 160     return aNames;
 161 }
 162
 163 bool SvtSearchOptions_Impl::Load()
 164 {
 165     bool bSucc = false;
 166
 167     Sequence< OUString > aNames = GetPropertyNames();
 168     sal_Int32 nProps = aNames.getLength();
 169
 170     const Sequence< Any > aValues = GetProperties( aNames );
 171     DBG_ASSERT( aValues.getLength() == aNames.getLength(),
 172             "GetProperties failed" );
 173     //EnableNotification( aNames );
 174
 175     if (nProps  &&  aValues.getLength() == nProps)
 176     {
 177         bSucc = true;
 178
 179         const Any* pValues = aValues.getConstArray();
 180         for (sal_uInt16 i = 0;  i < nProps;  ++i)
 181         {
 182             const Any &rVal = pValues[i];
 183             DBG_ASSERT( rVal.hasValue(), "property value missing" );
 184             if (rVal.hasValue())
 185             {
 186                 bool bVal = bool();
 187                 if (rVal >>= bVal)
 188                 {
 189                     if (i <= MAX_FLAGS_OFFSET)
 190                     {
 191                         // use index in sequence as flag index
 192                         SetFlag( i, bVal );
 193                     }
 194                     else {
 195                         OSL_FAIL( "unexpected index" );
 196                     }
 197                 }
 198                 else
 199                 {
 200                     OSL_FAIL( "unexpected type" );
 201                     bSucc = false;
 202                 }
 203             }
 204             else
 205             {
 206                 OSL_FAIL( "value missing" );
 207                 bSucc = false;
 208             }
 209         }
 210     }
 211     DBG_ASSERT( bSucc, "LoadConfig failed" );
 212
 213     return bSucc;
 214 }
 215
 216 bool SvtSearchOptions_Impl::Save()
 217 {
 218     bool bSucc = false;
 219
 220     const Sequence< OUString > aNames = GetPropertyNames();
 221     sal_Int32 nProps = aNames.getLength();
 222
 223     Sequence< Any > aValues( nProps );
 224     Any *pValue = aValues.getArray();
 225
 226     DBG_ASSERT( nProps == MAX_FLAGS_OFFSET + 1,
 227             "unexpected size of index" );
 228     if (nProps  &&  nProps == MAX_FLAGS_OFFSET + 1)
 229     {
 230         for (sal_uInt16 i = 0;  i < nProps;  ++i)
 231             pValue[i] <<= GetFlag(i);
 232         bSucc |= PutProperties( aNames, aValues );
 233     }
 234
 235     if (bSucc)
 236         SetModified( false );
 237
 238     return bSucc;
 239 }
 240
 241 SvtSearchOptions::SvtSearchOptions()
 242 {
 243     pImpl = new SvtSearchOptions_Impl;
 244 }
 245
 246 SvtSearchOptions::~SvtSearchOptions()
 247 {
 248     delete pImpl;
 249 }
 250
 251 void SvtSearchOptions::Commit()
 252 {
 253     pImpl->Commit();
 254 }
 255
 256 sal_Int32 SvtSearchOptions::GetTransliterationFlags() const
 257 {
 258     sal_Int32 nRes = 0;
 259
 260     if (!IsMatchCase()) // 'IsMatchCase' means act case sensitive
 261         nRes |= TransliterationModules_IGNORE_CASE;
 262     if ( IsMatchFullHalfWidthForms())
 263         nRes |= TransliterationModules_IGNORE_WIDTH;
 264     if ( IsMatchHiraganaKatakana())
 265         nRes |= TransliterationModules_IGNORE_KANA;
 266     if ( IsMatchContractions())
 267         nRes |= TransliterationModules_ignoreSize_ja_JP;
 268     if ( IsMatchMinusDashChoon())
 269         nRes |= TransliterationModules_ignoreMinusSign_ja_JP;
 270     if ( IsMatchRepeatCharMarks())
 271         nRes |= TransliterationModules_ignoreIterationMark_ja_JP;
 272     if ( IsMatchVariantFormKanji())
 273         nRes |= TransliterationModules_ignoreTraditionalKanji_ja_JP;
 274     if ( IsMatchOldKanaForms())
 275         nRes |= TransliterationModules_ignoreTraditionalKana_ja_JP;
 276     if ( IsMatchDiziDuzu())
 277         nRes |= TransliterationModules_ignoreZiZu_ja_JP;
 278     if ( IsMatchBavaHafa())
 279         nRes |= TransliterationModules_ignoreBaFa_ja_JP;
 280     if ( IsMatchTsithichiDhizi())
 281         nRes |= TransliterationModules_ignoreTiJi_ja_JP;
 282     if ( IsMatchHyuiyuByuvyu())
 283         nRes |= TransliterationModules_ignoreHyuByu_ja_JP;
 284     if ( IsMatchSesheZeje())
 285         nRes |= TransliterationModules_ignoreSeZe_ja_JP;
 286     if ( IsMatchIaiya())
 287         nRes |= TransliterationModules_ignoreIandEfollowedByYa_ja_JP;
 288     if ( IsMatchKiku())
 289         nRes |= TransliterationModules_ignoreKiKuFollowedBySa_ja_JP;
 290     if ( IsIgnorePunctuation())
 291         nRes |= TransliterationModules_ignoreSeparator_ja_JP;
 292     if ( IsIgnoreWhitespace())
 293         nRes |= TransliterationModules_ignoreSpace_ja_JP;
 294     if ( IsIgnoreProlongedSoundMark())
 295         nRes |= TransliterationModules_ignoreProlongedSoundMark_ja_JP;
 296     if ( IsIgnoreMiddleDot())
 297         nRes |= TransliterationModules_ignoreMiddleDot_ja_JP;
 298     if ( IsIgnoreDiacritics_CTL())
 299         nRes |= TransliterationModulesExtra::IGNORE_DIACRITICS_CTL;
 300     if ( IsIgnoreKashida_CTL())
 301         nRes |= TransliterationModulesExtra::IGNORE_KASHIDA_CTL;
 302     return nRes;
 303 }
 304
 305 bool SvtSearchOptions::IsWholeWordsOnly() const
 306 {
 307     return pImpl->GetFlag( 0 );
 308 }
 309
 310 void SvtSearchOptions::SetWholeWordsOnly( bool bVal )
 311 {
 312     pImpl->SetFlag( 0, bVal );
 313 }
 314
 315 bool SvtSearchOptions::IsBackwards() const
 316 {
 317     return pImpl->GetFlag( 1 );
 318 }
 319
 320 void SvtSearchOptions::SetBackwards( bool bVal )
 321 {
 322     pImpl->SetFlag( 1, bVal );
 323 }
 324
 325 bool SvtSearchOptions::IsUseRegularExpression() const
 326 {
 327     return pImpl->GetFlag( 2 );
 328 }
 329
 330 void SvtSearchOptions::SetUseRegularExpression( bool bVal )
 331 {
 332     pImpl->SetFlag( 2, bVal );
 333 }
 334
 335 void SvtSearchOptions::SetSearchForStyles( bool bVal )
 336 {
 337     pImpl->SetFlag( 3, bVal );
 338 }
 339
 340 bool SvtSearchOptions::IsSimilaritySearch() const
 341 {
 342     return pImpl->GetFlag( 4 );
 343 }
 344
 345 void SvtSearchOptions::SetSimilaritySearch( bool bVal )
 346 {
 347     pImpl->SetFlag( 4, bVal );
 348 }
 349
 350 bool SvtSearchOptions::IsUseAsianOptions() const
 351 {
 352     return pImpl->GetFlag( 5 );
 353 }
 354
 355 void SvtSearchOptions::SetUseAsianOptions( bool bVal )
 356 {
 357     pImpl->SetFlag( 5, bVal );
 358 }
 359
 360 bool SvtSearchOptions::IsMatchCase() const
 361 {
 362     return pImpl->GetFlag( 6 );
 363 }
 364
 365 void SvtSearchOptions::SetMatchCase( bool bVal )
 366 {
 367     pImpl->SetFlag( 6, bVal );
 368 }
 369
 370 bool SvtSearchOptions::IsMatchFullHalfWidthForms() const
 371 {
 372     return pImpl->GetFlag( 7 );
 373 }
 374
 375 void SvtSearchOptions::SetMatchFullHalfWidthForms( bool bVal )
 376 {
 377     pImpl->SetFlag( 7, bVal );
 378 }
 379
 380 bool SvtSearchOptions::IsMatchHiraganaKatakana() const
 381 {
 382     return pImpl->GetFlag( 8 );
 383 }
 384
 385 void SvtSearchOptions::SetMatchHiraganaKatakana( bool bVal )
 386 {
 387     pImpl->SetFlag( 8, bVal );
 388 }
 389
 390 bool SvtSearchOptions::IsMatchContractions() const
 391 {
 392     return pImpl->GetFlag( 9 );
 393 }
 394
 395 void SvtSearchOptions::SetMatchContractions( bool bVal )
 396 {
 397     pImpl->SetFlag( 9, bVal );
 398 }
 399
 400 bool SvtSearchOptions::IsMatchMinusDashChoon() const
 401 {
 402     return pImpl->GetFlag( 10 );
 403 }
 404
 405 void SvtSearchOptions::SetMatchMinusDashChoon( bool bVal )
 406 {
 407     pImpl->SetFlag( 10, bVal );
 408 }
 409
 410 bool SvtSearchOptions::IsMatchRepeatCharMarks() const
 411 {
 412     return pImpl->GetFlag( 11 );
 413 }
 414
 415 void SvtSearchOptions::SetMatchRepeatCharMarks( bool bVal )
 416 {
 417     pImpl->SetFlag( 11, bVal );
 418 }
 419
 420 bool SvtSearchOptions::IsMatchVariantFormKanji() const
 421 {
 422     return pImpl->GetFlag( 12 );
 423 }
 424
 425 void SvtSearchOptions::SetMatchVariantFormKanji( bool bVal )
 426 {
 427     pImpl->SetFlag( 12, bVal );
 428 }
 429
 430 bool SvtSearchOptions::IsMatchOldKanaForms() const
 431 {
 432     return pImpl->GetFlag( 13 );
 433 }
 434
 435 void SvtSearchOptions::SetMatchOldKanaForms( bool bVal )
 436 {
 437     pImpl->SetFlag( 13, bVal );
 438 }
 439
 440 bool SvtSearchOptions::IsMatchDiziDuzu() const
 441 {
 442     return pImpl->GetFlag( 14 );
 443 }
 444
 445 void SvtSearchOptions::SetMatchDiziDuzu( bool bVal )
 446 {
 447     pImpl->SetFlag( 14, bVal );
 448 }
 449
 450 bool SvtSearchOptions::IsMatchBavaHafa() const
 451 {
 452     return pImpl->GetFlag( 15 );
 453 }
 454
 455 void SvtSearchOptions::SetMatchBavaHafa( bool bVal )
 456 {
 457     pImpl->SetFlag( 15, bVal );
 458 }
 459
 460 bool SvtSearchOptions::IsMatchTsithichiDhizi() const
 461 {
 462     return pImpl->GetFlag( 16 );
 463 }
 464
 465 void SvtSearchOptions::SetMatchTsithichiDhizi( bool bVal )
 466 {
 467     pImpl->SetFlag( 16, bVal );
 468 }
 469
 470 bool SvtSearchOptions::IsMatchHyuiyuByuvyu() const
 471 {
 472     return pImpl->GetFlag( 17 );
 473 }
 474
 475 void SvtSearchOptions::SetMatchHyuiyuByuvyu( bool bVal )
 476 {
 477     pImpl->SetFlag( 17, bVal );
 478 }
 479
 480 bool SvtSearchOptions::IsMatchSesheZeje() const
 481 {
 482     return pImpl->GetFlag( 18 );
 483 }
 484
 485 void SvtSearchOptions::SetMatchSesheZeje( bool bVal )
 486 {
 487     pImpl->SetFlag( 18, bVal );
 488 }
 489
 490 bool SvtSearchOptions::IsMatchIaiya() const
 491 {
 492     return pImpl->GetFlag( 19 );
 493 }
 494
 495 void SvtSearchOptions::SetMatchIaiya( bool bVal )
 496 {
 497     pImpl->SetFlag( 19, bVal );
 498 }
 499
 500 bool SvtSearchOptions::IsMatchKiku() const
 501 {
 502     return pImpl->GetFlag( 20 );
 503 }
 504
 505 void SvtSearchOptions::SetMatchKiku( bool bVal )
 506 {
 507     pImpl->SetFlag( 20, bVal );
 508 }
 509
 510 bool SvtSearchOptions::IsIgnorePunctuation() const
 511 {
 512     return pImpl->GetFlag( 21 );
 513 }
 514
 515 void SvtSearchOptions::SetIgnorePunctuation( bool bVal )
 516 {
 517     pImpl->SetFlag( 21, bVal );
 518 }
 519
 520 bool SvtSearchOptions::IsIgnoreWhitespace() const
 521 {
 522     return pImpl->GetFlag( 22 );
 523 }
 524
 525 void SvtSearchOptions::SetIgnoreWhitespace( bool bVal )
 526 {
 527     pImpl->SetFlag( 22, bVal );
 528 }
 529
 530 bool SvtSearchOptions::IsIgnoreProlongedSoundMark() const
 531 {
 532     return pImpl->GetFlag( 23 );
 533 }
 534
 535 void SvtSearchOptions::SetIgnoreProlongedSoundMark( bool bVal )
 536 {
 537     pImpl->SetFlag( 23, bVal );
 538 }
 539
 540 bool SvtSearchOptions::IsIgnoreMiddleDot() const
 541 {
 542     return pImpl->GetFlag( 24 );
 543 }
 544
 545 void SvtSearchOptions::SetIgnoreMiddleDot( bool bVal )
 546 {
 547     pImpl->SetFlag( 24, bVal );
 548 }
 549
 550 bool SvtSearchOptions::IsNotes() const
 551 {
 552     return pImpl->GetFlag( 25 );
 553 }
 554
 555 void SvtSearchOptions::SetNotes( bool bVal )
 556 {
 557     pImpl->SetFlag( 25, bVal );
 558 }
 559
 560 bool SvtSearchOptions::IsIgnoreDiacritics_CTL() const
 561 {
 562     return pImpl->GetFlag( 26 );
 563 }
 564
 565 void SvtSearchOptions::SetIgnoreDiacritics_CTL( bool bVal )
 566 {
 567     pImpl->SetFlag( 26, bVal );
 568 }
 569
 570 bool SvtSearchOptions::IsIgnoreKashida_CTL() const
 571 {
 572     return pImpl->GetFlag( 27 );
 573 }
 574
 575 void SvtSearchOptions::SetIgnoreKashida_CTL( bool bVal )
 576 {
 577     pImpl->SetFlag( 27, bVal );
 578 }
 579
 580 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */