svtools/source/config/searchopt.cxx

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