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