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