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