lingucomponent/source/spellcheck/spell/sspellimp.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 <com/sun/star/uno/Reference.h>
  22 #include <com/sun/star/linguistic2/XSearchableDictionaryList.hpp>
  23
  24 #include <com/sun/star/linguistic2/SpellFailure.hpp>
  25 #include <cppuhelper/factory.hxx>
  26 #include <cppuhelper/supportsservice.hxx>
  27 #include <com/sun/star/registry/XRegistryKey.hpp>
  28 #include <tools/debug.hxx>
  29 #include <osl/mutex.hxx>
  30
  31 #include <lingutil.hxx>
  32 #include <hunspell.hxx>
  33 #include <dictmgr.hxx>
  34 #include <sspellimp.hxx>
  35
  36 #include <linguistic/lngprops.hxx>
  37 #include <linguistic/spelldta.hxx>
  38 #include <i18nlangtag/languagetag.hxx>
  39 #include <unotools/pathoptions.hxx>
  40 #include <unotools/lingucfg.hxx>
  41 #include <unotools/useroptions.hxx>
  42 #include <osl/file.hxx>
  43 #include <rtl/ustrbuf.hxx>
  44 #include <rtl/textenc.h>
  45
  46 #include <list>
  47 #include <set>
  48 #include <string.h>
  49
  50 using namespace utl;
  51 using namespace osl;
  52 using namespace com::sun::star;
  53 using namespace com::sun::star::beans;
  54 using namespace com::sun::star::lang;
  55 using namespace com::sun::star::uno;
  56 using namespace com::sun::star::linguistic2;
  57 using namespace linguistic;
  58
  59
  60 // XML-header of SPELLML queries
  61 #define SPELLML_HEADER "<?xml?>"
  62
  63 ///////////////////////////////////////////////////////////////////////////
  64
  65 SpellChecker::SpellChecker() :
  66     aDicts(NULL),
  67     aDEncs(NULL),
  68     aDLocs(NULL),
  69     aDNames(NULL),
  70     numdict(0),
  71     aEvtListeners(GetLinguMutex()),
  72     pPropHelper(NULL),
  73     bDisposing(false)
  74 {
  75 }
  76
  77 SpellChecker::~SpellChecker()
  78 {
  79     if (aDicts)
  80     {
  81        for (int i = 0; i < numdict; ++i)
  82        {
  83             delete aDicts[i];
  84        }
  85        delete[] aDicts;
  86     }
  87     delete[] aDEncs;
  88     delete[] aDLocs;
  89     delete[] aDNames;
  90     if (pPropHelper)
  91     {
  92         pPropHelper->RemoveAsPropListener();
  93         delete pPropHelper;
  94     }
  95 }
  96
  97 PropertyHelper_Spelling & SpellChecker::GetPropHelper_Impl()
  98 {
  99     if (!pPropHelper)
 100     {
 101         Reference< XLinguProperties >   xPropSet( GetLinguProperties(), UNO_QUERY );
 102
 103         pPropHelper = new PropertyHelper_Spelling( (XSpellChecker *) this, xPropSet );
 104         pPropHelper->AddAsPropListener();   //! after a reference is established
 105     }
 106     return *pPropHelper;
 107 }
 108
 109
 110 Sequence< Locale > SAL_CALL SpellChecker::getLocales()
 111         throw(RuntimeException)
 112 {
 113     MutexGuard  aGuard( GetLinguMutex() );
 114
 115     // this routine should return the locales supported by the installed
 116     // dictionaries.
 117
 118     if (!numdict)
 119     {
 120         SvtLinguConfig aLinguCfg;
 121
 122         // get list of extension dictionaries-to-use
 123         // (or better speaking: the list of dictionaries using the
 124         // new configuration entries).
 125         std::list< SvtLinguConfigDictionaryEntry > aDics;
 126         uno::Sequence< OUString > aFormatList;
 127         aLinguCfg.GetSupportedDictionaryFormatsFor( "SpellCheckers",
 128                 "org.openoffice.lingu.MySpellSpellChecker", aFormatList );
 129         sal_Int32 nLen = aFormatList.getLength();
 130         for (sal_Int32 i = 0;  i < nLen;  ++i)
 131         {
 132             std::vector< SvtLinguConfigDictionaryEntry > aTmpDic(
 133                     aLinguCfg.GetActiveDictionariesByFormat( aFormatList[i] ) );
 134             aDics.insert( aDics.end(), aTmpDic.begin(), aTmpDic.end() );
 135         }
 136
 137         //!! for compatibility with old dictionaries (the ones not using extensions
 138         //!! or new configuration entries, but still using the dictionary.lst file)
 139         //!! Get the list of old style spell checking dictionaries to use...
 140         std::vector< SvtLinguConfigDictionaryEntry > aOldStyleDics(
 141                 GetOldStyleDics( "DICT" ) );
 142
 143         // to prefer dictionaries with configuration entries we will only
 144         // use those old style dictionaries that add a language that
 145         // is not yet supported by the list od new style dictionaries
 146         MergeNewStyleDicsAndOldStyleDics( aDics, aOldStyleDics );
 147
 148         if (!aDics.empty())
 149         {
 150             // get supported locales from the dictionaries-to-use...
 151             sal_Int32 k = 0;
 152             std::set< OUString, lt_rtl_OUString > aLocaleNamesSet;
 153             std::list< SvtLinguConfigDictionaryEntry >::const_iterator aDictIt;
 154             for (aDictIt = aDics.begin();  aDictIt != aDics.end();  ++aDictIt)
 155             {
 156                 uno::Sequence< OUString > aLocaleNames( aDictIt->aLocaleNames );
 157                 sal_Int32 nLen2 = aLocaleNames.getLength();
 158                 for (k = 0;  k < nLen2;  ++k)
 159                 {
 160                     aLocaleNamesSet.insert( aLocaleNames[k] );
 161                 }
 162             }
 163             // ... and add them to the resulting sequence
 164             aSuppLocales.realloc( aLocaleNamesSet.size() );
 165             std::set< OUString, lt_rtl_OUString >::const_iterator aItB;
 166             k = 0;
 167             for (aItB = aLocaleNamesSet.begin();  aItB != aLocaleNamesSet.end();  ++aItB)
 168             {
 169                 Locale aTmp( LanguageTag::convertToLocale( *aItB ));
 170                 aSuppLocales[k++] = aTmp;
 171             }
 172
 173             //! For each dictionary and each locale we need a separate entry.
 174             //! If this results in more than one dictionary per locale than (for now)
 175             //! it is undefined which dictionary gets used.
 176             //! In the future the implementation should support using several dictionaries
 177             //! for one locale.
 178             numdict = 0;
 179             for (aDictIt = aDics.begin();  aDictIt != aDics.end();  ++aDictIt)
 180                 numdict = numdict + aDictIt->aLocaleNames.getLength();
 181
 182             // add dictionary information
 183             aDicts  = new Hunspell* [numdict];
 184             aDEncs  = new rtl_TextEncoding [numdict];
 185             aDLocs  = new Locale [numdict];
 186             aDNames = new OUString [numdict];
 187             k = 0;
 188             for (aDictIt = aDics.begin();  aDictIt != aDics.end();  ++aDictIt)
 189             {
 190                 if (aDictIt->aLocaleNames.getLength() > 0 &&
 191                     aDictIt->aLocations.getLength() > 0)
 192                 {
 193                     uno::Sequence< OUString > aLocaleNames( aDictIt->aLocaleNames );
 194                     sal_Int32 nLocales = aLocaleNames.getLength();
 195
 196                     // currently only one language per dictionary is supported in the actual implementation...
 197                     // Thus here we work-around this by adding the same dictionary several times.
 198                     // Once for each of it's supported locales.
 199                     for (sal_Int32 i = 0;  i < nLocales;  ++i)
 200                     {
 201                         aDicts[k]  = NULL;
 202                         aDEncs[k]  = RTL_TEXTENCODING_DONTKNOW;
 203                         aDLocs[k]  = LanguageTag::convertToLocale( aLocaleNames[i] );
 204                         // also both files have to be in the same directory and the
 205                         // file names must only differ in the extension (.aff/.dic).
 206                         // Thus we use the first location only and strip the extension part.
 207                         OUString aLocation = aDictIt->aLocations[0];
 208                         sal_Int32 nPos = aLocation.lastIndexOf( '.' );
 209                         aLocation = aLocation.copy( 0, nPos );
 210                         aDNames[k] = aLocation;
 211
 212                         ++k;
 213                     }
 214                 }
 215             }
 216             DBG_ASSERT( k == numdict, "index mismatch?" );
 217         }
 218         else
 219         {
 220             /* no dictionary found so register no dictionaries */
 221             numdict = 0;
 222             delete[] aDicts;
 223             aDicts  = NULL;
 224             delete[] aDEncs;
 225             aDEncs = NULL;
 226             delete[] aDLocs;
 227             aDLocs  = NULL;
 228             delete[] aDNames;
 229             aDNames = NULL;
 230             aSuppLocales.realloc(0);
 231         }
 232     }
 233
 234     return aSuppLocales;
 235 }
 236
 237
 238 sal_Bool SAL_CALL SpellChecker::hasLocale(const Locale& rLocale)
 239         throw(RuntimeException)
 240 {
 241     MutexGuard  aGuard( GetLinguMutex() );
 242
 243     sal_Bool bRes = sal_False;
 244     if (!aSuppLocales.getLength())
 245         getLocales();
 246
 247     const Locale *pLocale = aSuppLocales.getConstArray();
 248     sal_Int32 nLen = aSuppLocales.getLength();
 249     for (sal_Int32 i = 0;  i < nLen;  ++i)
 250     {
 251         if (rLocale == pLocale[i])
 252         {
 253             bRes = sal_True;
 254             break;
 255         }
 256     }
 257     return bRes;
 258 }
 259
 260
 261 sal_Int16 SpellChecker::GetSpellFailure( const OUString &rWord, const Locale &rLocale )
 262 {
 263     Hunspell * pMS = NULL;
 264     rtl_TextEncoding eEnc = RTL_TEXTENCODING_DONTKNOW;
 265
 266     // initialize a myspell object for each dictionary once
 267     // (note: mutex is held higher up in isValid)
 268
 269     sal_Int16 nRes = -1;
 270
 271     // first handle smart quotes both single and double
 272     OUStringBuffer rBuf(rWord);
 273     sal_Int32 n = rBuf.getLength();
 274     sal_Unicode c;
 275     sal_Int32 extrachar = 0;
 276
 277     for (sal_Int32 ix=0; ix < n; ix++)
 278     {
 279         c = rBuf[ix];
 280         if ((c == 0x201C) || (c == 0x201D))
 281             rBuf[ix] = (sal_Unicode)0x0022;
 282         else if ((c == 0x2018) || (c == 0x2019))
 283             rBuf[ix] = (sal_Unicode)0x0027;
 284
 285 // recognize words with Unicode ligatures and ZWNJ/ZWJ characters (only
 286 // with 8-bit encoded dictionaries. For UTF-8 encoded dictionaries
 287 // set ICONV and IGNORE aff file options, if needed.)
 288
 289         else if ((c == 0x200C) || (c == 0x200D) ||
 290             ((c >= 0xFB00) && (c <= 0xFB04)))
 291                 extrachar = 1;
 292     }
 293     OUString nWord(rBuf.makeStringAndClear());
 294
 295     if (n)
 296     {
 297         for (sal_Int32 i = 0; i < numdict; ++i)
 298         {
 299             pMS = NULL;
 300             eEnc = RTL_TEXTENCODING_DONTKNOW;
 301
 302             if (rLocale == aDLocs[i])
 303             {
 304                 if (!aDicts[i])
 305                 {
 306                     OUString dicpath = aDNames[i] + ".dic";
 307                     OUString affpath = aDNames[i] + ".aff";
 308                     OUString dict;
 309                     OUString aff;
 310                     osl::FileBase::getSystemPathFromFileURL(dicpath,dict);
 311                     osl::FileBase::getSystemPathFromFileURL(affpath,aff);
 312                     OString aTmpaff(OU2ENC(aff,osl_getThreadTextEncoding()));
 313                     OString aTmpdict(OU2ENC(dict,osl_getThreadTextEncoding()));
 314
 315 #if defined(WNT)
 316                     // workaround for Windows specifc problem that the
 317                     // path length in calls to 'fopen' is limted to somewhat
 318                     // about 120+ characters which will usually be exceed when
 319                     // using dictionaries as extensions.
 320                     aTmpaff = Win_GetShortPathName( aff );
 321                     aTmpdict = Win_GetShortPathName( dict );
 322 #endif
 323
 324                     aDicts[i] = new Hunspell(aTmpaff.getStr(),aTmpdict.getStr());
 325                     aDEncs[i] = RTL_TEXTENCODING_DONTKNOW;
 326                     if (aDicts[i])
 327                         aDEncs[i] = getTextEncodingFromCharset(aDicts[i]->get_dic_encoding());
 328                 }
 329                 pMS = aDicts[i];
 330                 eEnc = aDEncs[i];
 331             }
 332
 333             if (pMS)
 334             {
 335                 // we don't want to work with a default text encoding since following incorrect
 336                 // results may occur only for specific text and thus may be hard to notice.
 337                 // Thus better always make a clean exit here if the text encoding is in question.
 338                 // Hopefully something not working at all will raise proper attention quickly. ;-)
 339                 DBG_ASSERT( eEnc != RTL_TEXTENCODING_DONTKNOW, "failed to get text encoding! (maybe incorrect encoding string in file)" );
 340                 if (eEnc == RTL_TEXTENCODING_DONTKNOW)
 341                     return -1;
 342
 343                 OString aWrd(OU2ENC(nWord,eEnc));
 344                 int rVal = pMS->spell((char*)aWrd.getStr());
 345                 if (rVal != 1) {
 346                     if (extrachar && (eEnc != RTL_TEXTENCODING_UTF8)) {
 347                         OUStringBuffer mBuf(nWord);
 348                         n = mBuf.getLength();
 349                         for (sal_Int32 ix=n-1; ix >= 0; ix--)
 350                         {
 351                           switch (mBuf[ix]) {
 352                             case 0xFB00: mBuf.remove(ix, 1); mBuf.insert(ix, "ff"); break;
 353                             case 0xFB01: mBuf.remove(ix, 1); mBuf.insert(ix, "fi"); break;
 354                             case 0xFB02: mBuf.remove(ix, 1); mBuf.insert(ix, "fl"); break;
 355                             case 0xFB03: mBuf.remove(ix, 1); mBuf.insert(ix, "ffi"); break;
 356                             case 0xFB04: mBuf.remove(ix, 1); mBuf.insert(ix, "ffl"); break;
 357                             case 0x200C:
 358                             case 0x200D: mBuf.remove(ix, 1); break;
 359                           }
 360                         }
 361                         OUString mWord(mBuf.makeStringAndClear());
 362                         OString bWrd(OU2ENC(mWord, eEnc));
 363                         rVal = pMS->spell((char*)bWrd.getStr());
 364                         if (rVal == 1) return -1;
 365                     }
 366                     nRes = SpellFailure::SPELLING_ERROR;
 367                 } else {
 368                     return -1;
 369                 }
 370                 pMS = NULL;
 371             }
 372         }
 373     }
 374
 375     return nRes;
 376 }
 377
 378
 379 sal_Bool SAL_CALL SpellChecker::isValid( const OUString& rWord, const Locale& rLocale,
 380             const PropertyValues& rProperties )
 381         throw(IllegalArgumentException, RuntimeException)
 382 {
 383     MutexGuard  aGuard( GetLinguMutex() );
 384
 385      if (rLocale == Locale()  ||  rWord.isEmpty())
 386         return sal_True;
 387
 388     if (!hasLocale( rLocale ))
 389         return sal_True;
 390
 391     // return sal_False to process SPELLML requests (they are longer than the header)
 392     if (rWord.match(SPELLML_HEADER, 0) && (rWord.getLength() > 10)) return sal_False;
 393
 394     // Get property values to be used.
 395     // These are be the default values set in the SN_LINGU_PROPERTIES
 396     // PropertySet which are overridden by the supplied ones from the
 397     // last argument.
 398     // You'll probably like to use a simplier solution than the provided
 399     // one using the PropertyHelper_Spell.
 400
 401     PropertyHelper_Spelling& rHelper = GetPropHelper();
 402     rHelper.SetTmpPropVals( rProperties );
 403
 404     sal_Int16 nFailure = GetSpellFailure( rWord, rLocale );
 405     if (nFailure != -1 && !rWord.match(SPELLML_HEADER, 0))
 406     {
 407         sal_Int16 nLang = LinguLocaleToLanguage( rLocale );
 408         // postprocess result for errors that should be ignored
 409         const bool bIgnoreError =
 410                 (!rHelper.IsSpellUpperCase()  && IsUpper( rWord, nLang )) ||
 411                 (!rHelper.IsSpellWithDigits() && HasDigits( rWord )) ||
 412                 (!rHelper.IsSpellCapitalization()  &&  nFailure == SpellFailure::CAPTION_ERROR);
 413         if (bIgnoreError)
 414             nFailure = -1;
 415     }
 416
 417     return (nFailure == -1);
 418 }
 419
 420
 421 Reference< XSpellAlternatives >
 422     SpellChecker::GetProposals( const OUString &rWord, const Locale &rLocale )
 423 {
 424     // Retrieves the return values for the 'spell' function call in case
 425     // of a misspelled word.
 426     // Especially it may give a list of suggested (correct) words:
 427
 428     Reference< XSpellAlternatives > xRes;
 429     // note: mutex is held by higher up by spell which covers both
 430
 431     Hunspell* pMS = NULL;
 432     rtl_TextEncoding eEnc = RTL_TEXTENCODING_DONTKNOW;
 433
 434     // first handle smart quotes (single and double)
 435     OUStringBuffer rBuf(rWord);
 436     sal_Int32 n = rBuf.getLength();
 437     sal_Unicode c;
 438     for (sal_Int32 ix=0; ix < n; ix++)
 439     {
 440         c = rBuf[ix];
 441         if ((c == 0x201C) || (c == 0x201D))
 442             rBuf[ix] = (sal_Unicode)0x0022;
 443         if ((c == 0x2018) || (c == 0x2019))
 444             rBuf[ix] = (sal_Unicode)0x0027;
 445     }
 446     OUString nWord(rBuf.makeStringAndClear());
 447
 448     if (n)
 449     {
 450         sal_Int16 nLang = LinguLocaleToLanguage( rLocale );
 451         int numsug = 0;
 452
 453         Sequence< OUString > aStr( 0 );
 454         for (int i = 0; i < numdict; i++)
 455         {
 456             pMS = NULL;
 457             eEnc = RTL_TEXTENCODING_DONTKNOW;
 458
 459             if (rLocale == aDLocs[i])
 460             {
 461                 pMS = aDicts[i];
 462                 eEnc = aDEncs[i];
 463             }
 464
 465             if (pMS)
 466             {
 467                 char ** suglst = NULL;
 468                 OString aWrd(OU2ENC(nWord,eEnc));
 469                 int count = pMS->suggest(&suglst, (const char *) aWrd.getStr());
 470
 471                 if (count)
 472                 {
 473                     aStr.realloc( numsug + count );
 474                     OUString *pStr = aStr.getArray();
 475                     for (int ii=0; ii < count; ++ii)
 476                     {
 477                         OUString cvtwrd(suglst[ii],strlen(suglst[ii]),eEnc);
 478                         pStr[numsug + ii] = cvtwrd;
 479                     }
 480                     numsug += count;
 481                 }
 482
 483                 pMS->free_list(&suglst, count);
 484             }
 485         }
 486
 487         // now return an empty alternative for no suggestions or the list of alternatives if some found
 488         OUString aTmp(rWord);
 489         xRes = SpellAlternatives::CreateSpellAlternatives( aTmp, nLang, SpellFailure::SPELLING_ERROR, aStr );
 490         return xRes;
 491     }
 492     return xRes;
 493 }
 494
 495
 496 Reference< XSpellAlternatives > SAL_CALL SpellChecker::spell(
 497         const OUString& rWord, const Locale& rLocale,
 498         const PropertyValues& rProperties )
 499         throw(IllegalArgumentException, RuntimeException)
 500 {
 501     MutexGuard  aGuard( GetLinguMutex() );
 502
 503      if (rLocale == Locale()  ||  rWord.isEmpty())
 504         return NULL;
 505
 506     if (!hasLocale( rLocale ))
 507         return NULL;
 508
 509     Reference< XSpellAlternatives > xAlt;
 510     if (!isValid( rWord, rLocale, rProperties ))
 511     {
 512         xAlt =  GetProposals( rWord, rLocale );
 513     }
 514     return xAlt;
 515 }
 516
 517
 518 Reference< XInterface > SAL_CALL SpellChecker_CreateInstance(
 519         const Reference< XMultiServiceFactory > & /*rSMgr*/ )
 520         throw(Exception)
 521 {
 522
 523     Reference< XInterface > xService = (cppu::OWeakObject*) new SpellChecker;
 524     return xService;
 525 }
 526
 527
 528 sal_Bool SAL_CALL SpellChecker::addLinguServiceEventListener(
 529         const Reference< XLinguServiceEventListener >& rxLstnr )
 530         throw(RuntimeException)
 531 {
 532     MutexGuard  aGuard( GetLinguMutex() );
 533
 534     sal_Bool bRes = sal_False;
 535     if (!bDisposing && rxLstnr.is())
 536     {
 537         bRes = GetPropHelper().addLinguServiceEventListener( rxLstnr );
 538     }
 539     return bRes;
 540 }
 541
 542
 543 sal_Bool SAL_CALL SpellChecker::removeLinguServiceEventListener(
 544         const Reference< XLinguServiceEventListener >& rxLstnr )
 545         throw(RuntimeException)
 546 {
 547     MutexGuard  aGuard( GetLinguMutex() );
 548
 549     sal_Bool bRes = sal_False;
 550     if (!bDisposing && rxLstnr.is())
 551     {
 552         bRes = GetPropHelper().removeLinguServiceEventListener( rxLstnr );
 553     }
 554     return bRes;
 555 }
 556
 557
 558 OUString SAL_CALL SpellChecker::getServiceDisplayName( const Locale& /*rLocale*/ )
 559         throw(RuntimeException)
 560 {
 561     MutexGuard  aGuard( GetLinguMutex() );
 562     return OUString( "Hunspell SpellChecker" );
 563 }
 564
 565
 566 void SAL_CALL SpellChecker::initialize( const Sequence< Any >& rArguments )
 567         throw(Exception, RuntimeException)
 568 {
 569     MutexGuard  aGuard( GetLinguMutex() );
 570
 571     if (!pPropHelper)
 572     {
 573         sal_Int32 nLen = rArguments.getLength();
 574         if (2 == nLen)
 575         {
 576             Reference< XLinguProperties >   xPropSet;
 577             rArguments.getConstArray()[0] >>= xPropSet;
 578             //rArguments.getConstArray()[1] >>= xDicList;
 579
 580             //! Pointer allows for access of the non-UNO functions.
 581             //! And the reference to the UNO-functions while increasing
 582             //! the ref-count and will implicitly free the memory
 583             //! when the object is not longer used.
 584             pPropHelper = new PropertyHelper_Spelling( (XSpellChecker *) this, xPropSet );
 585             pPropHelper->AddAsPropListener();   //! after a reference is established
 586         }
 587         else {
 588             OSL_FAIL( "wrong number of arguments in sequence" );
 589         }
 590     }
 591 }
 592
 593
 594 void SAL_CALL SpellChecker::dispose()
 595         throw(RuntimeException)
 596 {
 597     MutexGuard  aGuard( GetLinguMutex() );
 598
 599     if (!bDisposing)
 600     {
 601         bDisposing = true;
 602         EventObject aEvtObj( (XSpellChecker *) this );
 603         aEvtListeners.disposeAndClear( aEvtObj );
 604         if (pPropHelper)
 605         {
 606             pPropHelper->RemoveAsPropListener();
 607             delete pPropHelper;
 608             pPropHelper = NULL;
 609         }
 610     }
 611 }
 612
 613
 614 void SAL_CALL SpellChecker::addEventListener( const Reference< XEventListener >& rxListener )
 615         throw(RuntimeException)
 616 {
 617     MutexGuard  aGuard( GetLinguMutex() );
 618
 619     if (!bDisposing && rxListener.is())
 620         aEvtListeners.addInterface( rxListener );
 621 }
 622
 623
 624 void SAL_CALL SpellChecker::removeEventListener( const Reference< XEventListener >& rxListener )
 625         throw(RuntimeException)
 626 {
 627     MutexGuard  aGuard( GetLinguMutex() );
 628
 629     if (!bDisposing && rxListener.is())
 630         aEvtListeners.removeInterface( rxListener );
 631 }
 632
 633
 634 // Service specific part
 635 OUString SAL_CALL SpellChecker::getImplementationName()
 636         throw(RuntimeException)
 637 {
 638     MutexGuard  aGuard( GetLinguMutex() );
 639
 640     return getImplementationName_Static();
 641 }
 642
 643 sal_Bool SAL_CALL SpellChecker::supportsService( const OUString& ServiceName )
 644         throw(RuntimeException)
 645 {
 646     return cppu::supportsService(this, ServiceName);
 647 }
 648
 649 Sequence< OUString > SAL_CALL SpellChecker::getSupportedServiceNames()
 650         throw(RuntimeException)
 651 {
 652     MutexGuard  aGuard( GetLinguMutex() );
 653
 654     return getSupportedServiceNames_Static();
 655 }
 656
 657 Sequence< OUString > SpellChecker::getSupportedServiceNames_Static()
 658         throw()
 659 {
 660     MutexGuard  aGuard( GetLinguMutex() );
 661
 662     Sequence< OUString > aSNS( 1 ); // auch mehr als 1 Service moeglich
 663     aSNS.getArray()[0] = SN_SPELLCHECKER;
 664     return aSNS;
 665 }
 666
 667 void * SAL_CALL SpellChecker_getFactory( const sal_Char * pImplName,
 668             XMultiServiceFactory * pServiceManager, void *  )
 669 {
 670     void * pRet = 0;
 671     if ( SpellChecker::getImplementationName_Static().equalsAscii( pImplName ) )
 672     {
 673         Reference< XSingleServiceFactory > xFactory =
 674             cppu::createOneInstanceFactory(
 675                 pServiceManager,
 676                 SpellChecker::getImplementationName_Static(),
 677                 SpellChecker_CreateInstance,
 678                 SpellChecker::getSupportedServiceNames_Static());
 679         // acquire, because we return an interface pointer instead of a reference
 680         xFactory->acquire();
 681         pRet = xFactory.get();
 682     }
 683     return pRet;
 684 }
 685
 686
 687 ///////////////////////////////////////////////////////////////////////////
 688
 689 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */