lingucomponent/source/spellcheck/macosxspell/macspellimp.mm

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   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 #include <com/sun/star/uno/Reference.h>
  21
  22 #include <com/sun/star/linguistic2/SpellFailure.hpp>
  23 #include <com/sun/star/linguistic2/XLinguProperties.hpp>
  24 #include <cppuhelper/factory.hxx>
  25 #include <cppuhelper/supportsservice.hxx>
  26 #include <cppuhelper/weak.hxx>
  27 #include <com/sun/star/registry/XRegistryKey.hpp>
  28 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  29 #include <tools/debug.hxx>
  30 #include <osl/mutex.hxx>
  31
  32 #include "macspellimp.hxx"
  33
  34 #include <linguistic/spelldta.hxx>
  35 #include <unotools/pathoptions.hxx>
  36 #include <unotools/useroptions.hxx>
  37 #include <osl/diagnose.h>
  38 #include <osl/file.hxx>
  39 #include <rtl/ref.hxx>
  40 #include <rtl/ustrbuf.hxx>
  41
  42 using namespace utl;
  43 using namespace osl;
  44 using namespace com::sun::star;
  45 using namespace com::sun::star::beans;
  46 using namespace com::sun::star::lang;
  47 using namespace com::sun::star::uno;
  48 using namespace com::sun::star::linguistic2;
  49 using namespace linguistic;
  50
  51 MacSpellChecker::MacSpellChecker() :
  52     aEvtListeners( GetLinguMutex() )
  53 {
  54     aDEncs = nullptr;
  55     aDLocs = nullptr;
  56     aDNames = nullptr;
  57     bDisposing = false;
  58     numdict = 0;
  59 #ifndef IOS
  60     NSApplicationLoad();
  61     NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
  62     macTag = [NSSpellChecker uniqueSpellDocumentTag];
  63     [pool release];
  64 #else
  65     pChecker = [[UITextChecker alloc] init];
  66 #endif
  67 }
  68
  69
  70 MacSpellChecker::~MacSpellChecker()
  71 {
  72   numdict = 0;
  73   if (aDEncs) delete[] aDEncs;
  74   aDEncs = nullptr;
  75   if (aDLocs) delete[] aDLocs;
  76   aDLocs = nullptr;
  77   if (aDNames) delete[] aDNames;
  78   aDNames = nullptr;
  79   if (xPropHelper.is())
  80      xPropHelper->RemoveAsPropListener();
  81 }
  82
  83
  84 PropertyHelper_Spell & MacSpellChecker::GetPropHelper_Impl()
  85 {
  86     if (!xPropHelper.is())
  87     {
  88         Reference< XLinguProperties >   xPropSet( GetLinguProperties() );
  89
  90         xPropHelper = new PropertyHelper_Spell( static_cast<XSpellChecker *>(this), xPropSet );
  91         xPropHelper->AddAsPropListener();
  92     }
  93     return *xPropHelper;
  94 }
  95
  96
  97 Sequence< Locale > SAL_CALL MacSpellChecker::getLocales()
  98 {
  99     MutexGuard  aGuard( GetLinguMutex() );
 100
 101     // this routine should return the locales supported by the installed
 102     // dictionaries.  So here we need to parse both the user edited
 103     // dictionary list and the shared dictionary list
 104     // to see what dictionaries the admin/user has installed
 105
 106     int numshr;          // number of shared dictionary entries
 107     rtl_TextEncoding aEnc = RTL_TEXTENCODING_UTF8;
 108
 109     std::vector<NSString *> postspdict;
 110
 111     if (!numdict) {
 112
 113         // invoke a dictionary manager to get the user dictionary list
 114         // TODO How on macOS?
 115
 116         // invoke a second  dictionary manager to get the shared dictionary list
 117 #ifdef MACOSX
 118         NSArray *aSpellCheckLanguages = [[NSSpellChecker sharedSpellChecker] availableLanguages];
 119 #else
 120         NSArray *aSpellCheckLanguages = [UITextChecker availableLanguages];
 121 #endif
 122
 123         for (NSUInteger i = 0; i < [aSpellCheckLanguages count]; i++)
 124         {
 125             NSString* pLangStr = static_cast<NSString*>([aSpellCheckLanguages objectAtIndex:i]);
 126
 127             // Fix up generic languages (without territory code) and odd combinations that LO
 128             // doesn't handle.
 129             if ([pLangStr isEqualToString:@"ar"])
 130             {
 131                 const std::vector<NSString*> aAR
 132                     { @"AE", @"BH", @"DJ", @"DZ", @"EG", @"ER", @"IL", @"IQ", @"JO",
 133                       @"KM", @"KW", @"LB", @"LY", @"MA", @"MR", @"OM", @"PS", @"QA",
 134                       @"SA", @"SD", @"SO", @"SY", @"TD", @"TN", @"YE" };
 135                 for (auto c: aAR)
 136                 {
 137                     pLangStr = [@"ar_" stringByAppendingString: c];
 138                     postspdict.push_back( pLangStr );
 139                 }
 140             }
 141             else if ([pLangStr isEqualToString:@"da"])
 142             {
 143                 postspdict.push_back( @"da_DK" );
 144             }
 145             else if ([pLangStr isEqualToString:@"de"])
 146             {
 147                 // Not de_CH and de_LI, though. They need separate dictionaries.
 148                 const std::vector<NSString*> aDE
 149                     { @"AT", @"BE", @"DE", @"LU" };
 150                 for (auto c: aDE)
 151                 {
 152                     pLangStr = [@"de_" stringByAppendingString: c];
 153                     postspdict.push_back( pLangStr );
 154                 }
 155             }
 156 #ifdef IOS
 157             // iOS says it has specifically de_DE. Let's assume it is good enough for German as
 158             // written in Austria, Belgium, and Luxembourg, too. (Not for German in Switzerland and
 159             // Liechtenstein. For those you need to bundle the myspell dictionary.)
 160             else if ([pLangStr isEqualToString:@"de_DE"])
 161             {
 162                 const std::vector<NSString*> aDE
 163                     { @"AT", @"BE", @"DE", @"LU" };
 164                 for (auto c: aDE)
 165                 {
 166                     pLangStr = [@"de_" stringByAppendingString: c];
 167                     postspdict.push_back( pLangStr );
 168                 }
 169             }
 170 #endif
 171             else if ([pLangStr isEqualToString:@"en"])
 172             {
 173                 // System has en_AU, en_CA, en_GB, and en_IN. Add the rest.
 174                 const std::vector<NSString*> aEN
 175                     { @"BW", @"BZ", @"GH", @"GM", @"IE", @"JM", @"MU", @"MW", @"MY", @"NA",
 176                       @"NZ", @"PH", @"TT", @"US", @"ZA", @"ZW" };
 177                 for (auto c: aEN)
 178                 {
 179                     pLangStr = [@"en_" stringByAppendingString: c];
 180                     postspdict.push_back( pLangStr );
 181                 }
 182             }
 183             else if ([pLangStr isEqualToString:@"en_JP"]
 184                      || [pLangStr isEqualToString:@"en_SG"])
 185             {
 186                 // Just skip, LO doesn't have those yet in this context.
 187             }
 188             else if ([pLangStr isEqualToString:@"es"])
 189             {
 190                 const std::vector<NSString*> aES
 191                     { @"AR", @"BO", @"CL", @"CO", @"CR", @"CU", @"DO", @"EC", @"ES", @"GT",
 192                       @"HN", @"MX", @"NI", @"PA", @"PE", @"PR", @"PY", @"SV", @"UY", @"VE" };
 193                 for (auto c: aES)
 194                 {
 195                     pLangStr = [@"es_" stringByAppendingString: c];
 196                     postspdict.push_back( pLangStr );
 197                 }
 198             }
 199             else if ([pLangStr isEqualToString:@"fi"])
 200             {
 201                 postspdict.push_back( @"fi_FI" );
 202             }
 203             else if ([pLangStr isEqualToString:@"fr"])
 204             {
 205                 const std::vector<NSString*> aFR
 206                     { @"BE", @"BF", @"BJ", @"CA", @"CH", @"CI", @"FR", @"LU", @"MC", @"ML",
 207                       @"MU", @"NE", @"SN", @"TG" };
 208                 for (auto c: aFR)
 209                 {
 210                     pLangStr = [@"fr_" stringByAppendingString: c];
 211                     postspdict.push_back( pLangStr );
 212                 }
 213             }
 214 #ifdef IOS
 215             else if ([pLangStr isEqualToString:@"fr_FR"])
 216             {
 217                 const std::vector<NSString*> aFR
 218                     { @"BE", @"BF", @"BJ", @"CA", @"CH", @"CI", @"FR", @"LU", @"MC", @"ML",
 219                       @"MU", @"NE", @"SN", @"TG" };
 220                 for (auto c: aFR)
 221                 {
 222                     pLangStr = [@"fr_" stringByAppendingString: c];
 223                     postspdict.push_back( pLangStr );
 224                 }
 225             }
 226 #endif
 227             else if ([pLangStr isEqualToString:@"it"])
 228             {
 229                 postspdict.push_back( @"it_CH" );
 230                 postspdict.push_back( @"it_IT" );
 231             }
 232 #ifdef IOS
 233             else if ([pLangStr isEqualToString:@"it_IT"])
 234             {
 235                 const std::vector<NSString*> aIT
 236                     { @"CH", @"IT" };
 237                 for (auto c: aIT)
 238                 {
 239                     pLangStr = [@"it_" stringByAppendingString: c];
 240                     postspdict.push_back( pLangStr );
 241                 }
 242             }
 243 #endif
 244             else if ([pLangStr isEqualToString:@"ko"])
 245             {
 246                 postspdict.push_back( @"ko_KR" );
 247             }
 248             else if ([pLangStr isEqualToString:@"nl"])
 249             {
 250                 postspdict.push_back( @"nl_BE" );
 251                 postspdict.push_back( @"nl_NL" );
 252             }
 253             else if ([pLangStr isEqualToString:@"nb"])
 254             {
 255                 postspdict.push_back( @"nb_NO" );
 256             }
 257             else if ([pLangStr isEqualToString:@"pl"])
 258             {
 259                 postspdict.push_back( @"pl_PL" );
 260             }
 261             else if ([pLangStr isEqualToString:@"ru"])
 262             {
 263                 postspdict.push_back( @"ru_RU" );
 264             }
 265             else if ([pLangStr isEqualToString:@"sv"])
 266             {
 267                 postspdict.push_back( @"sv_FI" );
 268                 postspdict.push_back( @"sv_SE" );
 269             }
 270 #ifdef IOS
 271             else if ([pLangStr isEqualToString:@"sv_SE"])
 272             {
 273                 postspdict.push_back( @"sv_FI" );
 274                 postspdict.push_back( @"sv_SE" );
 275             }
 276 #endif
 277             else if ([pLangStr isEqualToString:@"tr"])
 278             {
 279                 postspdict.push_back( @"tr_TR" );
 280             }
 281             else
 282                 postspdict.push_back( pLangStr );
 283         }
 284         // System has pt_BR and pt_PT, add pt_AO.
 285         postspdict.push_back( @"pt_AO" );
 286
 287         numshr = postspdict.size();
 288
 289         // we really should merge these and remove duplicates but since
 290         // users can name their dictionaries anything they want it would
 291         // be impossible to know if a real duplication exists unless we
 292         // add some unique key to each myspell dictionary
 293         numdict = numshr;
 294
 295         if (numdict) {
 296             aDLocs = new Locale [numdict];
 297             aDEncs  = new rtl_TextEncoding [numdict];
 298             aDNames = new OUString [numdict];
 299             aSuppLocales.realloc(numdict);
 300             Locale * pLocale = aSuppLocales.getArray();
 301             int numlocs = 0;
 302             int newloc;
 303             int i,j;
 304             int k = 0;
 305
 306             //first add the user dictionaries
 307             //TODO for MAC?
 308
 309             // now add the shared dictionaries
 310             for (i = 0; i < numshr; i++) {
 311                 NSDictionary *aLocDict = [ NSLocale componentsFromLocaleIdentifier:postspdict[i] ];
 312                 NSString* aLang = [ aLocDict objectForKey:NSLocaleLanguageCode ];
 313                 NSString* aCountry = [ aLocDict objectForKey:NSLocaleCountryCode ];
 314                 OUString lang([aLang cStringUsingEncoding: NSUTF8StringEncoding], [aLang length], aEnc);
 315                 OUString country([ aCountry cStringUsingEncoding: NSUTF8StringEncoding], [aCountry length], aEnc);
 316                 Locale nLoc( lang, country, OUString() );
 317                 newloc = 1;
 318                 //eliminate duplicates (is this needed for MacOS?)
 319                 for (j = 0; j < numlocs; j++) {
 320                     if (nLoc == pLocale[j]) newloc = 0;
 321                 }
 322                 if (newloc) {
 323                     pLocale[numlocs] = nLoc;
 324                     numlocs++;
 325                 }
 326                 aDLocs[k] = nLoc;
 327                 aDEncs[k] = 0;
 328                 k++;
 329             }
 330
 331             aSuppLocales.realloc(numlocs);
 332
 333         } else {
 334             /* no dictionary.lst found so register no dictionaries */
 335             numdict = 0;
 336             aDEncs  = nullptr;
 337             aDLocs = nullptr;
 338             aDNames = nullptr;
 339             aSuppLocales.realloc(0);
 340         }
 341     }
 342
 343     return aSuppLocales;
 344 }
 345
 346
 347
 348 sal_Bool SAL_CALL MacSpellChecker::hasLocale(const Locale& rLocale)
 349 {
 350     MutexGuard  aGuard( GetLinguMutex() );
 351
 352     bool bRes = false;
 353     if (!aSuppLocales.getLength())
 354         getLocales();
 355
 356     sal_Int32 nLen = aSuppLocales.getLength();
 357     for (sal_Int32 i = 0;  i < nLen;  ++i)
 358     {
 359         const Locale *pLocale = aSuppLocales.getConstArray();
 360         if (rLocale == pLocale[i])
 361         {
 362             bRes = true;
 363             break;
 364         }
 365     }
 366     return bRes;
 367 }
 368
 369
 370 sal_Int16 MacSpellChecker::GetSpellFailure( const OUString &rWord, const Locale &rLocale )
 371 {
 372     // initialize a myspell object for each dictionary once
 373         // (note: mutex is held higher up in isValid)
 374
 375
 376     sal_Int16 nRes = -1;
 377
 378     // first handle smart quotes both single and double
 379     OUStringBuffer rBuf(rWord);
 380     sal_Int32 n = rBuf.getLength();
 381     sal_Unicode c;
 382     for (sal_Int32 ix=0; ix < n; ix++) {
 383         c = rBuf[ix];
 384         if ((c == 0x201C) || (c == 0x201D)) rBuf[ix] = u'"';
 385         if ((c == 0x2018) || (c == 0x2019)) rBuf[ix] = u'\'';
 386     }
 387     OUString nWord(rBuf.makeStringAndClear());
 388
 389     if (n)
 390     {
 391         NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
 392         NSString* aNSStr = [[[NSString alloc] initWithCharacters: reinterpret_cast<unichar const *>(nWord.getStr()) length: nWord.getLength()]autorelease];
 393         NSString* aLang = [[[NSString alloc] initWithCharacters: reinterpret_cast<unichar const *>(rLocale.Language.getStr()) length: rLocale.Language.getLength()]autorelease];
 394         if(rLocale.Country.getLength()>0)
 395         {
 396             NSString* aCountry = [[[NSString alloc] initWithCharacters: reinterpret_cast<unichar const *>(rLocale.Country.getStr()) length: rLocale.Country.getLength()]autorelease];
 397             NSString* aTaggedCountry = [@"_" stringByAppendingString:aCountry];
 398             aLang = [aLang  stringByAppendingString:aTaggedCountry];
 399         }
 400
 401 #ifdef MACOSX
 402         NSInteger aCount;
 403         NSRange range = [[NSSpellChecker sharedSpellChecker] checkSpellingOfString:aNSStr startingAt:0 language:aLang wrap:false inSpellDocumentWithTag:macTag wordCount:&aCount];
 404 #else
 405         NSRange range = [pChecker rangeOfMisspelledWordInString:aNSStr range:NSMakeRange(0, [aNSStr length]) startingAt:0 wrap:NO language:aLang];
 406 #endif
 407         int rVal = 0;
 408         if(range.length>0)
 409         {
 410             rVal = -1;
 411         }
 412         else
 413         {
 414             rVal = 1;
 415         }
 416         [pool release];
 417         if (rVal != 1)
 418         {
 419             nRes = SpellFailure::SPELLING_ERROR;
 420         } else {
 421             return -1;
 422         }
 423     }
 424     return nRes;
 425 }
 426
 427
 428
 429 sal_Bool SAL_CALL
 430     MacSpellChecker::isValid( const OUString& rWord, const Locale& rLocale,
 431             const css::uno::Sequence<PropertyValue>& rProperties )
 432 {
 433     MutexGuard  aGuard( GetLinguMutex() );
 434
 435     if (rLocale == Locale()  ||  !rWord.getLength())
 436         return true;
 437
 438     if (!hasLocale( rLocale ))
 439         return true;
 440
 441     // Get property values to be used.
 442     // These are be the default values set in the SN_LINGU_PROPERTIES
 443     // PropertySet which are overridden by the supplied ones from the
 444     // last argument.
 445     // You'll probably like to use a simpler solution than the provided
 446     // one using the PropertyHelper_Spell.
 447
 448     PropertyHelper_Spell &rHelper = GetPropHelper();
 449     rHelper.SetTmpPropVals( rProperties );
 450
 451     sal_Int16 nFailure = GetSpellFailure( rWord, rLocale );
 452     if (nFailure != -1)
 453     {
 454         LanguageType nLang = LinguLocaleToLanguage( rLocale );
 455         // postprocess result for errors that should be ignored
 456         if (   (!rHelper.IsSpellUpperCase()  && IsUpper( rWord, nLang ))
 457             || (!rHelper.IsSpellWithDigits() && HasDigits( rWord ))
 458         )
 459             nFailure = -1;
 460     }
 461
 462     return (nFailure == -1);
 463 }
 464
 465 Reference< XSpellAlternatives >
 466     MacSpellChecker::GetProposals( const OUString &rWord, const Locale &rLocale )
 467 {
 468     // Retrieves the return values for the 'spell' function call in case
 469     // of a misspelled word.
 470     // Especially it may give a list of suggested (correct) words:
 471
 472     Reference< XSpellAlternatives > xRes;
 473         // note: mutex is held by higher up by spell which covers both
 474
 475     LanguageType nLang = LinguLocaleToLanguage( rLocale );
 476     int count;
 477     Sequence< OUString > aStr( 0 );
 478
 479         // first handle smart quotes (single and double)
 480     OUStringBuffer rBuf(rWord);
 481     sal_Int32 n = rBuf.getLength();
 482     sal_Unicode c;
 483     for (sal_Int32 ix=0; ix < n; ix++) {
 484          c = rBuf[ix];
 485          if ((c == 0x201C) || (c == 0x201D)) rBuf[ix] = u'"';
 486          if ((c == 0x2018) || (c == 0x2019)) rBuf[ix] = u'\'';
 487     }
 488     OUString nWord(rBuf.makeStringAndClear());
 489
 490     if (n)
 491     {
 492         NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
 493         NSString* aNSStr = [[[NSString alloc] initWithCharacters: reinterpret_cast<unichar const *>(nWord.getStr()) length: nWord.getLength()]autorelease];
 494         NSString* aLang = [[[NSString alloc] initWithCharacters: reinterpret_cast<unichar const *>(rLocale.Language.getStr()) length: rLocale.Language.getLength()]autorelease];
 495         if(rLocale.Country.getLength()>0)
 496         {
 497             NSString* aCountry = [[[NSString alloc] initWithCharacters: reinterpret_cast<unichar const *>(rLocale.Country.getStr()) length: rLocale.Country.getLength()]autorelease];
 498             NSString* aTaggedCountry = [@"_" stringByAppendingString:aCountry];
 499             aLang = [aLang  stringByAppendingString:aTaggedCountry];
 500         }
 501 #ifdef MACOSX
 502         [[NSSpellChecker sharedSpellChecker] setLanguage:aLang];
 503         NSArray *guesses = [[NSSpellChecker sharedSpellChecker] guessesForWordRange:NSMakeRange(0, [aNSStr length]) inString:aNSStr language:aLang inSpellDocumentWithTag:0];
 504         (void) this; // avoid loplugin:staticmethods, the !MACOSX case uses 'this'
 505 #else
 506         NSArray *guesses = [pChecker guessesForWordRange:NSMakeRange(0, [aNSStr length]) inString:aNSStr language:aLang];
 507 #endif
 508         count = [guesses count];
 509         if (count)
 510         {
 511            aStr.realloc( count );
 512            OUString *pStr = aStr.getArray();
 513            for (int ii=0; ii < count; ii++)
 514            {
 515                   // if needed add: if (suglst[ii] == NULL) continue;
 516                   NSString* guess = [guesses objectAtIndex:ii];
 517                   OUString cvtwrd(reinterpret_cast<const sal_Unicode*>([guess cStringUsingEncoding:NSUnicodeStringEncoding]), static_cast<sal_Int32>([guess length]));
 518                   pStr[ii] = cvtwrd;
 519            }
 520         }
 521         [pool release];
 522     }
 523
 524     // now return an empty alternative for no suggestions or the list of alternatives if some found
 525     rtl::Reference<SpellAlternatives> pAlt = new SpellAlternatives;
 526     pAlt->SetWordLanguage( rWord, nLang );
 527     pAlt->SetFailureType( SpellFailure::SPELLING_ERROR );
 528     pAlt->SetAlternatives( aStr );
 529     xRes = pAlt;
 530     return xRes;
 531
 532 }
 533
 534 Reference< XSpellAlternatives > SAL_CALL
 535     MacSpellChecker::spell( const OUString& rWord, const Locale& rLocale,
 536             const css::uno::Sequence<PropertyValue>& rProperties )
 537 {
 538     MutexGuard  aGuard( GetLinguMutex() );
 539
 540     if (rLocale == Locale()  ||  !rWord.getLength())
 541         return nullptr;
 542
 543     if (!hasLocale( rLocale ))
 544         return nullptr;
 545
 546     Reference< XSpellAlternatives > xAlt;
 547     if (!isValid( rWord, rLocale, rProperties ))
 548     {
 549         xAlt =  GetProposals( rWord, rLocale );
 550     }
 551     return xAlt;
 552 }
 553
 554 sal_Bool SAL_CALL
 555     MacSpellChecker::addLinguServiceEventListener(
 556             const Reference< XLinguServiceEventListener >& rxLstnr )
 557 {
 558     MutexGuard  aGuard( GetLinguMutex() );
 559
 560     bool bRes = false;
 561     if (!bDisposing && rxLstnr.is())
 562     {
 563         bRes = GetPropHelper().addLinguServiceEventListener( rxLstnr );
 564     }
 565     return bRes;
 566 }
 567
 568
 569 sal_Bool SAL_CALL
 570     MacSpellChecker::removeLinguServiceEventListener(
 571             const Reference< XLinguServiceEventListener >& rxLstnr )
 572 {
 573     MutexGuard  aGuard( GetLinguMutex() );
 574
 575     bool bRes = false;
 576     if (!bDisposing && rxLstnr.is())
 577     {
 578         DBG_ASSERT( xPropHelper.is(), "xPropHelper non existent" );
 579         bRes = GetPropHelper().removeLinguServiceEventListener( rxLstnr );
 580     }
 581     return bRes;
 582 }
 583
 584
 585 OUString SAL_CALL
 586     MacSpellChecker::getServiceDisplayName( const Locale& /*rLocale*/ )
 587 {
 588     MutexGuard  aGuard( GetLinguMutex() );
 589     return "macOS Spell Checker";
 590 }
 591
 592
 593 void SAL_CALL
 594     MacSpellChecker::initialize( const Sequence< Any >& rArguments )
 595 {
 596     MutexGuard  aGuard( GetLinguMutex() );
 597
 598     if (!xPropHelper.is())
 599     {
 600         sal_Int32 nLen = rArguments.getLength();
 601         if (2 == nLen)
 602         {
 603             Reference< XLinguProperties >   xPropSet;
 604             rArguments.getConstArray()[0] >>= xPropSet;
 605             //rArguments.getConstArray()[1] >>= xDicList;
 606
 607             //! Pointer allows for access of the non-UNO functions.
 608             //! And the reference to the UNO-functions while increasing
 609             //! the ref-count and will implicitly free the memory
 610             //! when the object is no longer used.
 611             xPropHelper = new PropertyHelper_Spell( static_cast<XSpellChecker *>(this), xPropSet );
 612             xPropHelper->AddAsPropListener();
 613         }
 614         else
 615             OSL_FAIL( "wrong number of arguments in sequence" );
 616
 617     }
 618 }
 619
 620
 621 void SAL_CALL
 622     MacSpellChecker::dispose()
 623 {
 624     MutexGuard  aGuard( GetLinguMutex() );
 625
 626     if (!bDisposing)
 627     {
 628         bDisposing = true;
 629         EventObject aEvtObj( static_cast<XSpellChecker *>(this) );
 630         aEvtListeners.disposeAndClear( aEvtObj );
 631     }
 632 }
 633
 634
 635 void SAL_CALL
 636     MacSpellChecker::addEventListener( const Reference< XEventListener >& rxListener )
 637 {
 638     MutexGuard  aGuard( GetLinguMutex() );
 639
 640     if (!bDisposing && rxListener.is())
 641         aEvtListeners.addInterface( rxListener );
 642 }
 643
 644
 645 void SAL_CALL
 646     MacSpellChecker::removeEventListener( const Reference< XEventListener >& rxListener )
 647 {
 648     MutexGuard  aGuard( GetLinguMutex() );
 649
 650     if (!bDisposing && rxListener.is())
 651         aEvtListeners.removeInterface( rxListener );
 652 }
 653
 654 // Service specific part
 655 OUString SAL_CALL MacSpellChecker::getImplementationName()
 656 {
 657     return "org.openoffice.lingu.MacOSXSpellChecker";
 658 }
 659
 660 sal_Bool SAL_CALL MacSpellChecker::supportsService( const OUString& ServiceName )
 661 {
 662     return cppu::supportsService(this, ServiceName);
 663 }
 664
 665 Sequence< OUString > SAL_CALL MacSpellChecker::getSupportedServiceNames()
 666 {
 667     return { SN_SPELLCHECKER };
 668 }
 669
 670 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 671 lingucomponent_MacSpellChecker_get_implementation(
 672     css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const&)
 673 {
 674     return cppu::acquire(new MacSpellChecker());
 675 }
 676
 677 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */