linguistic/source/lngprophelp.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 <tools/debug.hxx>
  22 #include <sal/log.hxx>
  23
  24 #include <com/sun/star/linguistic2/LinguServiceEvent.hpp>
  25 #include <com/sun/star/linguistic2/LinguServiceEventFlags.hpp>
  26 #include <com/sun/star/linguistic2/XLinguServiceEventListener.hpp>
  27 #include <com/sun/star/linguistic2/XLinguProperties.hpp>
  28 #include <com/sun/star/beans/XPropertySet.hpp>
  29 #include <osl/mutex.hxx>
  30 #include <unotools/linguprops.hxx>
  31
  32 #include <linguistic/misc.hxx>
  33 #include <linguistic/lngprops.hxx>
  34
  35 #include <linguistic/lngprophelp.hxx>
  36
  37 using namespace osl;
  38 using namespace com::sun::star;
  39 using namespace com::sun::star::beans;
  40 using namespace com::sun::star::lang;
  41 using namespace com::sun::star::uno;
  42 using namespace com::sun::star::linguistic2;
  43 using namespace linguistic;
  44
  45
  46 namespace linguistic
  47 {
  48
  49
  50 PropertyChgHelper::PropertyChgHelper(
  51         const Reference< XInterface > &rxSource,
  52         Reference< XLinguProperties > const &rxPropSet,
  53         int nAllowedEvents ) :
  54     aPropNames          ({UPN_IS_IGNORE_CONTROL_CHARACTERS, UPN_IS_USE_DICTIONARY_LIST}),
  55     xMyEvtObj           (rxSource),
  56     aLngSvcEvtListeners (GetLinguMutex()),
  57     xPropSet            (rxPropSet),
  58     nEvtFlags           (nAllowedEvents)
  59 {
  60     SetDefaultValues();
  61 }
  62
  63 PropertyChgHelper::~PropertyChgHelper()
  64 {
  65 }
  66
  67 void PropertyChgHelper::SetDefaultValues()
  68 {
  69     bResIsIgnoreControlCharacters   = bIsIgnoreControlCharacters    = true;
  70     bResIsUseDictionaryList         = bIsUseDictionaryList          = true;
  71 }
  72
  73
  74 void PropertyChgHelper::GetCurrentValues()
  75 {
  76     const auto& rPropNames = GetPropNames();
  77     if (!GetPropSet().is() || rPropNames.empty())
  78         return;
  79
  80     for (const OUString& rPropName : rPropNames)
  81     {
  82         bool *pbVal     = nullptr,
  83              *pbResVal  = nullptr;
  84
  85         if ( rPropName == UPN_IS_IGNORE_CONTROL_CHARACTERS )
  86         {
  87             pbVal    = &bIsIgnoreControlCharacters;
  88             pbResVal = &bResIsIgnoreControlCharacters;
  89         }
  90         else if ( rPropName == UPN_IS_USE_DICTIONARY_LIST )
  91         {
  92             pbVal    = &bIsUseDictionaryList;
  93             pbResVal = &bResIsUseDictionaryList;
  94         }
  95
  96         if (pbVal && pbResVal)
  97         {
  98             GetPropSet()->getPropertyValue( rPropName ) >>= *pbVal;
  99             *pbResVal = *pbVal;
 100         }
 101     }
 102 }
 103
 104
 105 void PropertyChgHelper::SetTmpPropVals( const PropertyValues &rPropVals )
 106 {
 107     // return value is default value unless there is an explicitly supplied
 108     // temporary value
 109     bResIsIgnoreControlCharacters   = bIsIgnoreControlCharacters;
 110     bResIsUseDictionaryList         = bIsUseDictionaryList;
 111
 112     for (const PropertyValue& rVal : rPropVals)
 113     {
 114         bool  *pbResVal = nullptr;
 115         switch (rVal.Handle)
 116         {
 117             case UPH_IS_IGNORE_CONTROL_CHARACTERS :
 118                     pbResVal = &bResIsIgnoreControlCharacters; break;
 119             case UPH_IS_USE_DICTIONARY_LIST     :
 120                     pbResVal = &bResIsUseDictionaryList; break;
 121             default:
 122                     ;
 123         }
 124         if (pbResVal)
 125             rVal.Value >>= *pbResVal;
 126     }
 127 }
 128
 129
 130 bool PropertyChgHelper::propertyChange_Impl( const PropertyChangeEvent& rEvt )
 131 {
 132     bool bRes = false;
 133
 134     if (GetPropSet().is()  &&  rEvt.Source == GetPropSet())
 135     {
 136         sal_Int16 nLngSvcFlags = (nEvtFlags & AE_HYPHENATOR) ?
 137                     LinguServiceEventFlags::HYPHENATE_AGAIN : 0;
 138         bool bSCWA = false, // SPELL_CORRECT_WORDS_AGAIN ?
 139              bSWWA = false; // SPELL_WRONG_WORDS_AGAIN ?
 140
 141         bool  *pbVal = nullptr;
 142         switch (rEvt.PropertyHandle)
 143         {
 144             case UPH_IS_IGNORE_CONTROL_CHARACTERS :
 145             {
 146                 pbVal = &bIsIgnoreControlCharacters;
 147                 nLngSvcFlags = 0;
 148                 break;
 149             }
 150             case UPH_IS_USE_DICTIONARY_LIST       :
 151             {
 152                 pbVal = &bIsUseDictionaryList;
 153                 bSCWA = bSWWA = true;
 154                 break;
 155             }
 156         }
 157         if (pbVal)
 158             rEvt.NewValue >>= *pbVal;
 159
 160         bRes = nullptr != pbVal;  // sth changed?
 161         if (bRes)
 162         {
 163             bool bSpellEvts = (nEvtFlags & AE_SPELLCHECKER);
 164             if (bSCWA && bSpellEvts)
 165                 nLngSvcFlags |= LinguServiceEventFlags::SPELL_CORRECT_WORDS_AGAIN;
 166             if (bSWWA && bSpellEvts)
 167                 nLngSvcFlags |= LinguServiceEventFlags::SPELL_WRONG_WORDS_AGAIN;
 168             if (nLngSvcFlags)
 169             {
 170                 LinguServiceEvent aEvt( GetEvtObj(), nLngSvcFlags );
 171                 LaunchEvent( aEvt );
 172             }
 173         }
 174     }
 175
 176     return bRes;
 177 }
 178
 179
 180 void SAL_CALL
 181     PropertyChgHelper::propertyChange( const PropertyChangeEvent& rEvt )
 182 {
 183     MutexGuard  aGuard( GetLinguMutex() );
 184     propertyChange_Impl( rEvt );
 185 }
 186
 187
 188 void PropertyChgHelper::AddAsPropListener()
 189 {
 190     if (xPropSet.is())
 191     {
 192         for (const OUString& rPropName : std::as_const(aPropNames))
 193         {
 194             if (!rPropName.isEmpty())
 195                 xPropSet->addPropertyChangeListener( rPropName, this );
 196         }
 197     }
 198 }
 199
 200 void PropertyChgHelper::RemoveAsPropListener()
 201 {
 202     if (xPropSet.is())
 203     {
 204         for (const OUString& rPropName : std::as_const(aPropNames))
 205         {
 206             if (!rPropName.isEmpty())
 207                 xPropSet->removePropertyChangeListener( rPropName, this );
 208         }
 209     }
 210 }
 211
 212
 213 void PropertyChgHelper::LaunchEvent( const LinguServiceEvent &rEvt )
 214 {
 215     aLngSvcEvtListeners.notifyEach( &XLinguServiceEventListener::processLinguServiceEvent, rEvt );
 216 }
 217
 218
 219 void SAL_CALL PropertyChgHelper::disposing( const EventObject& rSource )
 220 {
 221     MutexGuard  aGuard( GetLinguMutex() );
 222     if (rSource.Source == xPropSet)
 223     {
 224         RemoveAsPropListener();
 225         xPropSet = nullptr;
 226         aPropNames.clear();
 227     }
 228 }
 229
 230
 231 sal_Bool SAL_CALL
 232     PropertyChgHelper::addLinguServiceEventListener(
 233             const Reference< XLinguServiceEventListener >& rxListener )
 234 {
 235     MutexGuard  aGuard( GetLinguMutex() );
 236
 237     bool bRes = false;
 238     if (rxListener.is())
 239     {
 240         sal_Int32   nCount = aLngSvcEvtListeners.getLength();
 241         bRes = aLngSvcEvtListeners.addInterface( rxListener ) != nCount;
 242     }
 243     return bRes;
 244 }
 245
 246
 247 sal_Bool SAL_CALL
 248     PropertyChgHelper::removeLinguServiceEventListener(
 249             const Reference< XLinguServiceEventListener >& rxListener )
 250 {
 251     MutexGuard  aGuard( GetLinguMutex() );
 252
 253     bool bRes = false;
 254     if (rxListener.is())
 255     {
 256         sal_Int32   nCount = aLngSvcEvtListeners.getLength();
 257         bRes = aLngSvcEvtListeners.removeInterface( rxListener ) != nCount;
 258     }
 259     return bRes;
 260 }
 261
 262
 263 PropertyHelper_Thes::PropertyHelper_Thes(
 264         const Reference< XInterface > &rxSource,
 265         Reference< XLinguProperties > const &rxPropSet ) :
 266     PropertyChgHelper   ( rxSource, rxPropSet, 0 )
 267 {
 268     SetDefaultValues();
 269     GetCurrentValues();
 270 }
 271
 272
 273 PropertyHelper_Thes::~PropertyHelper_Thes()
 274 {
 275 }
 276
 277
 278 void SAL_CALL
 279     PropertyHelper_Thes::propertyChange( const PropertyChangeEvent& rEvt )
 280 {
 281     MutexGuard  aGuard( GetLinguMutex() );
 282     PropertyChgHelper::propertyChange_Impl( rEvt );
 283 }
 284
 285
 286 PropertyHelper_Spell::PropertyHelper_Spell(
 287         const Reference< XInterface > & rxSource,
 288         Reference< XLinguProperties > const &rxPropSet ) :
 289     PropertyChgHelper   ( rxSource, rxPropSet, AE_SPELLCHECKER )
 290 {
 291     auto& rPropNames = GetPropNames();
 292     rPropNames.push_back(UPN_IS_SPELL_UPPER_CASE);
 293     rPropNames.push_back(UPN_IS_SPELL_WITH_DIGITS);
 294     rPropNames.push_back(UPN_IS_SPELL_CAPITALIZATION);
 295     SetDefaultValues();
 296     GetCurrentValues();
 297 }
 298
 299
 300 PropertyHelper_Spell::~PropertyHelper_Spell()
 301 {
 302 }
 303
 304
 305 void PropertyHelper_Spell::SetDefaultValues()
 306 {
 307     PropertyChgHelper::SetDefaultValues();
 308
 309     bResIsSpellUpperCase        = bIsSpellUpperCase         = false;
 310     bResIsSpellWithDigits       = bIsSpellWithDigits        = false;
 311     bResIsSpellCapitalization   = bIsSpellCapitalization    = true;
 312 }
 313
 314
 315 void PropertyHelper_Spell::GetCurrentValues()
 316 {
 317     PropertyChgHelper::GetCurrentValues();
 318
 319     const auto& rPropNames = GetPropNames();
 320     if (!GetPropSet().is() || rPropNames.empty())
 321         return;
 322
 323     for (const OUString& rPropName : rPropNames)
 324     {
 325         bool *pbVal     = nullptr,
 326              *pbResVal  = nullptr;
 327
 328         if ( rPropName == UPN_IS_SPELL_UPPER_CASE )
 329         {
 330             pbVal    = &bIsSpellUpperCase;
 331             pbResVal = &bResIsSpellUpperCase;
 332         }
 333         else if ( rPropName == UPN_IS_SPELL_WITH_DIGITS )
 334         {
 335             pbVal    = &bIsSpellWithDigits;
 336             pbResVal = &bResIsSpellWithDigits;
 337         }
 338         else if ( rPropName == UPN_IS_SPELL_CAPITALIZATION )
 339         {
 340             pbVal    = &bIsSpellCapitalization;
 341             pbResVal = &bResIsSpellCapitalization;
 342         }
 343
 344         if (pbVal && pbResVal)
 345         {
 346             GetPropSet()->getPropertyValue( rPropName ) >>= *pbVal;
 347             *pbResVal = *pbVal;
 348         }
 349     }
 350 }
 351
 352
 353 bool PropertyHelper_Spell::propertyChange_Impl( const PropertyChangeEvent& rEvt )
 354 {
 355     bool bRes = PropertyChgHelper::propertyChange_Impl( rEvt );
 356
 357     if (!bRes  &&  GetPropSet().is()  &&  rEvt.Source == GetPropSet())
 358     {
 359         bool bSCWA = false, // SPELL_CORRECT_WORDS_AGAIN ?
 360              bSWWA = false; // SPELL_WRONG_WORDS_AGAIN ?
 361
 362         bool *pbVal = nullptr;
 363         switch (rEvt.PropertyHandle)
 364         {
 365             case UPH_IS_SPELL_UPPER_CASE          :
 366             {
 367                 pbVal = &bIsSpellUpperCase;
 368                 bSCWA = ! *pbVal;    // sal_False->sal_True change?
 369                 bSWWA = !bSCWA;             // sal_True->sal_False change?
 370                 break;
 371             }
 372             case UPH_IS_SPELL_WITH_DIGITS         :
 373             {
 374                 pbVal = &bIsSpellWithDigits;
 375                 bSCWA = ! *pbVal;    // sal_False->sal_True change?
 376                 bSWWA = !bSCWA;             // sal_True->sal_False change?
 377                 break;
 378             }
 379             case UPH_IS_SPELL_CAPITALIZATION      :
 380             {
 381                 pbVal = &bIsSpellCapitalization;
 382                 bSCWA = ! *pbVal;    // sal_False->sal_True change?
 383                 bSWWA = !bSCWA;             // sal_True->sal_False change?
 384                 break;
 385             }
 386             default:
 387                 SAL_WARN( "linguistic", "unknown property" );
 388         }
 389         if (pbVal)
 390             rEvt.NewValue >>= *pbVal;
 391
 392         bRes = (pbVal != nullptr);
 393         if (bRes)
 394         {
 395             sal_Int16 nLngSvcFlags = 0;
 396             if (bSCWA)
 397                 nLngSvcFlags |= LinguServiceEventFlags::SPELL_CORRECT_WORDS_AGAIN;
 398             if (bSWWA)
 399                 nLngSvcFlags |= LinguServiceEventFlags::SPELL_WRONG_WORDS_AGAIN;
 400             if (nLngSvcFlags)
 401             {
 402                 LinguServiceEvent aEvt( GetEvtObj(), nLngSvcFlags );
 403                 LaunchEvent( aEvt );
 404             }
 405         }
 406     }
 407
 408     return bRes;
 409 }
 410
 411
 412 void SAL_CALL
 413     PropertyHelper_Spell::propertyChange( const PropertyChangeEvent& rEvt )
 414 {
 415     MutexGuard  aGuard( GetLinguMutex() );
 416     propertyChange_Impl( rEvt );
 417 }
 418
 419
 420 void PropertyHelper_Spell::SetTmpPropVals( const PropertyValues &rPropVals )
 421 {
 422     PropertyChgHelper::SetTmpPropVals( rPropVals );
 423
 424     // return value is default value unless there is an explicitly supplied
 425     // temporary value
 426     bResIsSpellWithDigits       = bIsSpellWithDigits;
 427     bResIsSpellCapitalization   = bIsSpellCapitalization;
 428     bResIsSpellUpperCase        = bIsSpellUpperCase;
 429
 430     for (const PropertyValue& rVal : rPropVals)
 431     {
 432         if ( rVal.Name == UPN_MAX_NUMBER_OF_SUGGESTIONS )
 433         {
 434             // special value that is not part of the property set and thus needs to be handled differently
 435         }
 436         else
 437         {
 438             bool *pbResVal = nullptr;
 439             switch (rVal.Handle)
 440             {
 441                 case UPH_IS_SPELL_UPPER_CASE     : pbResVal = &bResIsSpellUpperCase; break;
 442                 case UPH_IS_SPELL_WITH_DIGITS    : pbResVal = &bResIsSpellWithDigits; break;
 443                 case UPH_IS_SPELL_CAPITALIZATION : pbResVal = &bResIsSpellCapitalization; break;
 444                 default:
 445                     SAL_WARN( "linguistic", "unknown property" );
 446             }
 447             if (pbResVal)
 448                 rVal.Value >>= *pbResVal;
 449         }
 450     }
 451 }
 452
 453 PropertyHelper_Hyphen::PropertyHelper_Hyphen(
 454         const Reference< XInterface > & rxSource,
 455         Reference< XLinguProperties > const &rxPropSet ) :
 456     PropertyChgHelper   ( rxSource, rxPropSet, AE_HYPHENATOR )
 457 {
 458     auto& rPropNames = GetPropNames();
 459     rPropNames.push_back(UPN_HYPH_MIN_LEADING);
 460     rPropNames.push_back(UPN_HYPH_MIN_TRAILING);
 461     rPropNames.push_back(UPN_HYPH_MIN_WORD_LENGTH);
 462     SetDefaultValues();
 463     GetCurrentValues();
 464 }
 465
 466
 467 PropertyHelper_Hyphen::~PropertyHelper_Hyphen()
 468 {
 469 }
 470
 471
 472 void PropertyHelper_Hyphen::SetDefaultValues()
 473 {
 474     PropertyChgHelper::SetDefaultValues();
 475
 476     nResHyphMinLeading      = nHyphMinLeading       = 2;
 477     nResHyphMinTrailing     = nHyphMinTrailing      = 2;
 478     nResHyphMinWordLength   = nHyphMinWordLength    = 0;
 479     bResNoHyphenateCaps = bNoHyphenateCaps = false;
 480 }
 481
 482
 483 void PropertyHelper_Hyphen::GetCurrentValues()
 484 {
 485     PropertyChgHelper::GetCurrentValues();
 486
 487     const auto& rPropNames = GetPropNames();
 488     if (!GetPropSet().is() || rPropNames.empty())
 489         return;
 490
 491     for (const OUString& rPropName : rPropNames)
 492     {
 493         sal_Int16  *pnVal    = nullptr,
 494                *pnResVal = nullptr;
 495         bool *pbVal = nullptr;
 496         bool *pbResVal = nullptr;
 497
 498         if ( rPropName == UPN_HYPH_MIN_LEADING )
 499         {
 500             pnVal    = &nHyphMinLeading;
 501             pnResVal = &nResHyphMinLeading;
 502         }
 503         else if ( rPropName == UPN_HYPH_MIN_TRAILING )
 504         {
 505             pnVal    = &nHyphMinTrailing;
 506             pnResVal = &nResHyphMinTrailing;
 507         }
 508         else if ( rPropName == UPN_HYPH_MIN_WORD_LENGTH )
 509         {
 510             pnVal    = &nHyphMinWordLength;
 511             pnResVal = &nResHyphMinWordLength;
 512         }
 513         else if ( rPropName == UPN_HYPH_NO_CAPS )
 514         {
 515             pbVal    = &bNoHyphenateCaps;
 516             pbResVal = &bResNoHyphenateCaps;
 517         }
 518
 519         if (pnVal && pnResVal)
 520         {
 521             GetPropSet()->getPropertyValue( rPropName ) >>= *pnVal;
 522             *pnResVal = *pnVal;
 523         }
 524         else if (pbVal && pbResVal)
 525         {
 526             GetPropSet()->getPropertyValue( rPropName ) >>= *pbVal;
 527             *pbResVal = *pbVal;
 528         }
 529     }
 530 }
 531
 532
 533 bool PropertyHelper_Hyphen::propertyChange_Impl( const PropertyChangeEvent& rEvt )
 534 {
 535     bool bRes = PropertyChgHelper::propertyChange_Impl( rEvt );
 536
 537     if (!bRes  &&  GetPropSet().is()  &&  rEvt.Source == GetPropSet())
 538     {
 539         sal_Int16   *pnVal = nullptr;
 540         bool *pbVal = nullptr;
 541         switch (rEvt.PropertyHandle)
 542         {
 543             case UPH_HYPH_MIN_LEADING     : pnVal = &nHyphMinLeading; break;
 544             case UPH_HYPH_MIN_TRAILING    : pnVal = &nHyphMinTrailing; break;
 545             case UPH_HYPH_MIN_WORD_LENGTH : pnVal = &nHyphMinWordLength; break;
 546             case UPH_HYPH_NO_CAPS : pbVal = &bNoHyphenateCaps; break;
 547             default:
 548                 SAL_WARN( "linguistic", "unknown property" );
 549         }
 550         if (pnVal)
 551             rEvt.NewValue >>= *pnVal;
 552         else if (pbVal)
 553             rEvt.NewValue >>= *pbVal;
 554
 555         bRes = (pnVal != nullptr || pbVal != nullptr);
 556         if (bRes)
 557         {
 558             LinguServiceEvent aEvt(GetEvtObj(), LinguServiceEventFlags::HYPHENATE_AGAIN);
 559             LaunchEvent(aEvt);
 560         }
 561     }
 562
 563     return bRes;
 564 }
 565
 566
 567 void SAL_CALL
 568     PropertyHelper_Hyphen::propertyChange( const PropertyChangeEvent& rEvt )
 569 {
 570     MutexGuard  aGuard( GetLinguMutex() );
 571     propertyChange_Impl( rEvt );
 572 }
 573
 574
 575 void PropertyHelper_Hyphen::SetTmpPropVals( const PropertyValues &rPropVals )
 576 {
 577     PropertyChgHelper::SetTmpPropVals( rPropVals );
 578
 579     // return value is default value unless there is an explicitly supplied
 580     // temporary value
 581     nResHyphMinLeading      = nHyphMinLeading;
 582     nResHyphMinTrailing     = nHyphMinTrailing;
 583     nResHyphMinWordLength   = nHyphMinWordLength;
 584     bResNoHyphenateCaps = bNoHyphenateCaps;
 585
 586     for (const PropertyValue& rVal : rPropVals)
 587     {
 588         sal_Int16 *pnResVal = nullptr;
 589         bool *pbResVal = nullptr;
 590
 591         if ( rVal.Name == UPN_HYPH_MIN_LEADING )
 592             pnResVal = &nResHyphMinLeading;
 593         else if ( rVal.Name == UPN_HYPH_MIN_TRAILING )
 594             pnResVal = &nResHyphMinTrailing;
 595         else if ( rVal.Name == UPN_HYPH_MIN_WORD_LENGTH )
 596             pnResVal = &nResHyphMinWordLength;
 597         else if ( rVal.Name == UPN_HYPH_NO_CAPS )
 598             pbResVal = &bResNoHyphenateCaps;
 599
 600         DBG_ASSERT( pnResVal || pbResVal, "unknown property" );
 601
 602         if (pnResVal)
 603             rVal.Value >>= *pnResVal;
 604         else if (pbResVal)
 605             rVal.Value >>= *pbResVal;
 606     }
 607 }
 608
 609 PropertyHelper_Thesaurus::PropertyHelper_Thesaurus(
 610             const css::uno::Reference< css::uno::XInterface > &rxSource,
 611             css::uno::Reference< css::linguistic2::XLinguProperties > const &rxPropSet )
 612 {
 613     mxPropHelper = new PropertyHelper_Thes( rxSource, rxPropSet );
 614 }
 615
 616 PropertyHelper_Thesaurus::~PropertyHelper_Thesaurus()
 617 {
 618 }
 619
 620 void PropertyHelper_Thesaurus::AddAsPropListener()
 621 {
 622     mxPropHelper->AddAsPropListener();
 623 }
 624
 625 void PropertyHelper_Thesaurus::RemoveAsPropListener()
 626 {
 627     mxPropHelper->RemoveAsPropListener();
 628 }
 629
 630 void PropertyHelper_Thesaurus::SetTmpPropVals( const css::beans::PropertyValues &rPropVals )
 631 {
 632     mxPropHelper->SetTmpPropVals( rPropVals );
 633 }
 634
 635 PropertyHelper_Hyphenation::PropertyHelper_Hyphenation(
 636             const css::uno::Reference< css::uno::XInterface > &rxSource,
 637             css::uno::Reference< css::linguistic2::XLinguProperties > const &rxPropSet)
 638 {
 639     mxPropHelper = new PropertyHelper_Hyphen( rxSource, rxPropSet );
 640 }
 641
 642 PropertyHelper_Hyphenation::~PropertyHelper_Hyphenation()
 643 {
 644 }
 645
 646 void PropertyHelper_Hyphenation::AddAsPropListener()
 647 {
 648     mxPropHelper->AddAsPropListener();
 649 }
 650
 651 void PropertyHelper_Hyphenation::RemoveAsPropListener()
 652 {
 653     mxPropHelper->RemoveAsPropListener();
 654 }
 655
 656 void PropertyHelper_Hyphenation::SetTmpPropVals( const css::beans::PropertyValues &rPropVals )
 657 {
 658     mxPropHelper->SetTmpPropVals( rPropVals );
 659 }
 660
 661 sal_Int16 PropertyHelper_Hyphenation::GetMinLeading() const
 662 {
 663     return mxPropHelper->GetMinLeading();
 664 }
 665
 666 sal_Int16 PropertyHelper_Hyphenation::GetMinTrailing() const
 667 {
 668     return mxPropHelper->GetMinTrailing();
 669 }
 670
 671 sal_Int16 PropertyHelper_Hyphenation::GetMinWordLength() const
 672 {
 673     return mxPropHelper->GetMinWordLength();
 674 }
 675
 676 bool PropertyHelper_Hyphenation::IsNoHyphenateCaps() const
 677 {
 678     return mxPropHelper->IsNoHyphenateCaps();
 679 }
 680
 681 bool PropertyHelper_Hyphenation::addLinguServiceEventListener(
 682                 const css::uno::Reference< css::linguistic2::XLinguServiceEventListener >& rxListener )
 683 {
 684     return mxPropHelper->addLinguServiceEventListener( rxListener );
 685 }
 686
 687 bool PropertyHelper_Hyphenation::removeLinguServiceEventListener(
 688                 const css::uno::Reference< css::linguistic2::XLinguServiceEventListener >& rxListener )
 689 {
 690     return mxPropHelper->removeLinguServiceEventListener( rxListener );
 691 }
 692
 693 PropertyHelper_Spelling::PropertyHelper_Spelling(
 694             const css::uno::Reference< css::uno::XInterface > &rxSource,
 695             css::uno::Reference< css::linguistic2::XLinguProperties > const &rxPropSet )
 696 {
 697     mxPropHelper = new PropertyHelper_Spell( rxSource, rxPropSet );
 698 }
 699
 700 PropertyHelper_Spelling::~PropertyHelper_Spelling()
 701 {
 702 }
 703
 704 void PropertyHelper_Spelling::AddAsPropListener()
 705 {
 706     mxPropHelper->AddAsPropListener();
 707 }
 708
 709 void PropertyHelper_Spelling::RemoveAsPropListener()
 710 {
 711     mxPropHelper->RemoveAsPropListener();
 712 }
 713
 714 void PropertyHelper_Spelling::SetTmpPropVals( const css::beans::PropertyValues &rPropVals )
 715 {
 716     mxPropHelper->SetTmpPropVals( rPropVals );
 717 }
 718
 719 bool PropertyHelper_Spelling::IsSpellUpperCase() const
 720 {
 721     return mxPropHelper->IsSpellUpperCase();
 722 }
 723
 724 bool PropertyHelper_Spelling::IsSpellWithDigits() const
 725 {
 726     return mxPropHelper->IsSpellWithDigits();
 727 }
 728
 729 bool PropertyHelper_Spelling::IsSpellCapitalization() const
 730 {
 731     return mxPropHelper->IsSpellCapitalization();
 732 }
 733
 734 bool PropertyHelper_Spelling::addLinguServiceEventListener(
 735                 const css::uno::Reference<
 736                     css::linguistic2::XLinguServiceEventListener >& rxListener )
 737 {
 738     return mxPropHelper->addLinguServiceEventListener( rxListener );
 739 }
 740
 741 bool PropertyHelper_Spelling::removeLinguServiceEventListener(
 742                 const css::uno::Reference<
 743                     css::linguistic2::XLinguServiceEventListener >& rxListener )
 744 {
 745     return mxPropHelper->removeLinguServiceEventListener( rxListener );
 746 }
 747
 748 }   // namespace linguistic
 749
 750 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */