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