linguistic/workben/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 #include <com/sun/star/uno/Reference.h>
  21 #include <com/sun/star/linguistic2/XSearchableDictionaryList.hpp>
  22 #include <com/sun/star/linguistic2/SpellFailure.hpp>
  23 #include <com/sun/star/registry/XRegistryKey.hpp>
  24 #include <cppuhelper/factory.hxx>
  25 #include <cppuhelper/supportsservice.hxx>
  26 #include <tools/debug.hxx>
  27 #include <osl/mutex.hxx>
  28
  29 #include <sspellimp.hxx>
  30
  31 #include "linguistic/lngprops.hxx"
  32 #include "linguistic/spelldta.hxx"
  33
  34 using namespace utl;
  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 sal_Bool operator == ( const Locale &rL1, const Locale &rL2 )
  45 {
  46     return  rL1.Language ==  rL2.Language   &&
  47             rL1.Country  ==  rL2.Country    &&
  48             rL1.Variant  ==  rL2.Variant;
  49 }
  50
  51
  52 SpellChecker::SpellChecker() :
  53     aEvtListeners   ( GetLinguMutex() ),
  54     pPropHelper(NULL),
  55     bDisposing(sal_False)
  56 {
  57 }
  58
  59
  60 SpellChecker::~SpellChecker()
  61 {
  62     if (pPropHelper)
  63         pPropHelper->RemoveAsPropListener();
  64 }
  65
  66
  67 PropertyHelper_Spell & SpellChecker::GetPropHelper_Impl()
  68 {
  69     if (!pPropHelper)
  70     {
  71         Reference< XLinguProperties >   xPropSet = GetLinguProperties();
  72
  73         pPropHelper = new PropertyHelper_Spell( (XSpellChecker *) this, xPropSet );
  74         xPropHelper = pPropHelper;
  75         pPropHelper->AddAsPropListener();   //! after a reference is established
  76     }
  77     return *pPropHelper;
  78 }
  79
  80
  81 Sequence< Locale > SAL_CALL SpellChecker::getLocales()
  82         throw(RuntimeException)
  83 {
  84     MutexGuard  aGuard( GetLinguMutex() );
  85
  86     if (!aSuppLocales.getLength())
  87     {
  88         aSuppLocales.realloc( 3 );
  89         Locale *pLocale = aSuppLocales.getArray();
  90         pLocale[0] = Locale( "en", "US", OUString() );
  91         pLocale[1] = Locale( "de", "DE", OUString() );
  92         pLocale[2] = Locale( "de", "CH", OUString() );
  93     }
  94
  95     return aSuppLocales;
  96 }
  97
  98
  99 sal_Bool SAL_CALL SpellChecker::hasLocale(const Locale& rLocale)
 100         throw(RuntimeException)
 101 {
 102     MutexGuard  aGuard( GetLinguMutex() );
 103
 104     sal_Bool bRes = sal_False;
 105     if (!aSuppLocales.getLength())
 106         getLocales();
 107     sal_Int32 nLen = aSuppLocales.getLength();
 108     for (sal_Int32 i = 0;  i < nLen;  ++i)
 109     {
 110         const Locale *pLocale = aSuppLocales.getConstArray();
 111         if (rLocale == pLocale[i])
 112         {
 113             bRes = sal_True;
 114             break;
 115         }
 116     }
 117     return bRes;
 118 }
 119
 120
 121 sal_Int16 SpellChecker::GetSpellFailure( const OUString &rWord, const Locale & )
 122 {
 123     // Checks whether a word is OK in a given language (Locale) or not, and
 124     // provides a failure type for the incorrect ones.
 125     // - words with "liss" (case sensitive) as substring will be negative.
 126     // - words with 'x' or 'X' will have incorrect spelling.
 127     // - words with 's' or 'S' as first letter will have the wrong caption.
 128     // - all other words will be OK.
 129
 130     sal_Int16 nRes = -1;
 131
 132     String aTmp( rWord );
 133     if (aTmp.Len())
 134     {
 135         if (-1 != aTmp.indexOf( "liss" ))
 136         {
 137             nRes = SpellFailure::IS_NEGATIVE_WORD;
 138         }
 139         else if (-1 != aTmp.indexOf( 'x' )  ||
 140                  -1 != aTmp.indexOf( 'X' ))
 141         {
 142             nRes = SpellFailure::SPELLING_ERROR;
 143         }
 144         else
 145         {
 146             sal_Unicode cChar = aTmp.GetChar( 0 );
 147             if (cChar == 's'  ||  cChar == 'S')
 148                 nRes = SpellFailure::CAPTION_ERROR;
 149         }
 150     }
 151
 152     return nRes;
 153 }
 154
 155
 156 sal_Bool SAL_CALL
 157     SpellChecker::isValid( const OUString& rWord, const Locale& rLocale,
 158             const PropertyValues& rProperties )
 159         throw(IllegalArgumentException, RuntimeException)
 160 {
 161     MutexGuard  aGuard( GetLinguMutex() );
 162
 163      if (rLocale == Locale()  ||  !rWord.getLength())
 164         return sal_True;
 165
 166     if (!hasLocale( rLocale ))
 167 #ifdef LINGU_EXCEPTIONS
 168         throw( IllegalArgumentException() );
 169 #else
 170         return sal_True;
 171 #endif
 172
 173     // Get property values to be used.
 174     // These are be the default values set in the SN_LINGU_PROPERTIES
 175     // PropertySet which are overridden by the supplied ones from the
 176     // last argument.
 177     // You'll probably like to use a simpler solution than the provided
 178     // one using the PropertyHelper_Spell.
 179     PropertyHelper_Spell &rHelper = GetPropHelper();
 180     rHelper.SetTmpPropVals( rProperties );
 181
 182     sal_Int16 nFailure = GetSpellFailure( rWord, rLocale );
 183     if (nFailure != -1)
 184     {
 185         sal_Int16 nLang = LinguLocaleToLanguage( rLocale );
 186         // postprocess result for errors that should be ignored
 187         if (   (!rHelper.IsSpellUpperCase()  && IsUpper( rWord, nLang ))
 188             || (!rHelper.IsSpellWithDigits() && HasDigits( rWord ))
 189             || (!rHelper.IsSpellCapitalization()
 190                 &&  nFailure == SpellFailure::CAPTION_ERROR)
 191         )
 192             nFailure = -1;
 193     }
 194     return nFailure == -1;
 195 }
 196
 197
 198 Reference< XSpellAlternatives >
 199     SpellChecker::GetProposals( const OUString &rWord, const Locale &rLocale )
 200 {
 201     // Retrieves the return values for the 'spell' function call in case
 202     // of a misspelled word.
 203     // Especially it may give a list of suggested (correct) words:
 204     // - a "liss" substring will be replaced by "liz".
 205     // - 'x' or 'X' will be replaced by 'u' or 'U' for the first proposal
 206     //   and they will be removed from the word for the second proposal.
 207     // - 's' or 'S' as first letter will be changed to the other caption.
 208
 209     Reference< XSpellAlternatives > xRes;
 210
 211     String aTmp( rWord );
 212     if (aTmp.Len())
 213     {
 214         sal_Int16 nLang = LinguLocaleToLanguage( rLocale );
 215
 216         if (-1 != aTmp.indexOf( "liss" ))
 217         {
 218             aTmp.SearchAndReplaceAllAscii( "liss", "liz" );
 219             xRes = new SpellAlternatives( aTmp, nLang,
 220                         SpellFailure::IS_NEGATIVE_WORD, css::uno::Sequence< OUString >() );
 221         }
 222         else if (-1 != aTmp.indexOf( 'x' )  ||
 223                  -1 != aTmp.indexOf( 'X' ))
 224         {
 225             Sequence< OUString > aStr( 2 );
 226             OUString *pStr = aStr.getArray();
 227             String  aAlt1( aTmp ),
 228                     aAlt2( aTmp );
 229             aAlt1.SearchAndReplaceAll( 'x', 'u');
 230             aAlt1.SearchAndReplaceAll( 'X', 'U');
 231             aAlt2 = aAlt2.replaceAll("x", "").replaceAll("X", "");
 232             pStr[0] = aAlt1;
 233             pStr[1] = aAlt2;
 234
 235             SpellAlternatives *pAlt = new SpellAlternatives;
 236             pAlt->SetWordLanguage( aTmp, nLang );
 237             pAlt->SetFailureType( SpellFailure::SPELLING_ERROR );
 238             pAlt->SetAlternatives( aStr );
 239
 240             xRes = pAlt;
 241         }
 242         else
 243         {
 244             sal_Unicode cChar = aTmp.GetChar( 0 );
 245             if (cChar == 's'  ||  cChar == 'S')
 246             {
 247                 sal_Unicode cNewChar = cChar == 's' ?
 248                         'S': 's';
 249                 aTmp.GetBufferAccess()[0] = cNewChar;
 250                 xRes = new SpellAlternatives( aTmp, nLang,
 251                         SpellFailure::CAPTION_ERROR, css::uno::Sequence< OUString >() );
 252             }
 253         }
 254     }
 255
 256     return xRes;
 257 }
 258
 259
 260 Reference< XSpellAlternatives > SAL_CALL
 261     SpellChecker::spell( const OUString& rWord, const Locale& rLocale,
 262             const PropertyValues& rProperties )
 263         throw(IllegalArgumentException, RuntimeException)
 264 {
 265     MutexGuard  aGuard( GetLinguMutex() );
 266
 267      if (rLocale == Locale()  ||  !rWord.getLength())
 268         return NULL;
 269
 270     if (!hasLocale( rLocale ))
 271 #ifdef LINGU_EXCEPTIONS
 272         throw( IllegalArgumentException() );
 273 #else
 274         return NULL;
 275 #endif
 276
 277     Reference< XSpellAlternatives > xAlt;
 278     if (!isValid( rWord, rLocale, rProperties ))
 279     {
 280         xAlt =  GetProposals( rWord, rLocale );
 281     }
 282     return xAlt;
 283 }
 284
 285
 286 Reference< XInterface > SAL_CALL SpellChecker_CreateInstance(
 287             const Reference< XMultiServiceFactory > & )
 288         throw(Exception)
 289 {
 290     Reference< XInterface > xService = (cppu::OWeakObject*) new SpellChecker;
 291     return xService;
 292 }
 293
 294
 295 sal_Bool SAL_CALL
 296     SpellChecker::addLinguServiceEventListener(
 297             const Reference< XLinguServiceEventListener >& rxLstnr )
 298         throw(RuntimeException)
 299 {
 300     MutexGuard  aGuard( GetLinguMutex() );
 301
 302     sal_Bool bRes = sal_False;
 303     if (!bDisposing && rxLstnr.is())
 304     {
 305         bRes = GetPropHelper().addLinguServiceEventListener( rxLstnr );
 306     }
 307     return bRes;
 308 }
 309
 310
 311 sal_Bool SAL_CALL
 312     SpellChecker::removeLinguServiceEventListener(
 313             const Reference< XLinguServiceEventListener >& rxLstnr )
 314         throw(RuntimeException)
 315 {
 316     MutexGuard  aGuard( GetLinguMutex() );
 317
 318     sal_Bool bRes = sal_False;
 319     if (!bDisposing && rxLstnr.is())
 320     {
 321         DBG_ASSERT( xPropHelper.is(), "xPropHelper non existent" );
 322         bRes = GetPropHelper().removeLinguServiceEventListener( rxLstnr );
 323     }
 324     return bRes;
 325 }
 326
 327
 328 OUString SAL_CALL
 329     SpellChecker::getServiceDisplayName( const Locale& )
 330         throw(RuntimeException)
 331 {
 332     MutexGuard  aGuard( GetLinguMutex() );
 333     return OUString( "OpenOffice example spellchecker" );
 334 }
 335
 336
 337 void SAL_CALL
 338     SpellChecker::initialize( const Sequence< Any >& rArguments )
 339         throw(Exception, RuntimeException)
 340 {
 341     MutexGuard  aGuard( GetLinguMutex() );
 342
 343     if (!pPropHelper)
 344     {
 345         sal_Int32 nLen = rArguments.getLength();
 346         if (2 == nLen)
 347         {
 348             Reference< XPropertySet >   xPropSet;
 349             rArguments.getConstArray()[0] >>= xPropSet;
 350
 351             //! Pointer allows for access of the non-UNO functions.
 352             //! And the reference to the UNO-functions while increasing
 353             //! the ref-count and will implicitly free the memory
 354             //! when the object is no longer used.
 355             pPropHelper = new PropertyHelper_Spell( (XSpellChecker *) this, xPropSet );
 356             xPropHelper = pPropHelper;
 357             pPropHelper->AddAsPropListener();   //! after a reference is established
 358         }
 359         else
 360             OSL_FAIL( "wrong number of arguments in sequence" );
 361     }
 362 }
 363
 364
 365 void SAL_CALL
 366     SpellChecker::dispose()
 367         throw(RuntimeException)
 368 {
 369     MutexGuard  aGuard( GetLinguMutex() );
 370
 371     if (!bDisposing)
 372     {
 373         bDisposing = sal_True;
 374         EventObject aEvtObj( (XSpellChecker *) this );
 375         aEvtListeners.disposeAndClear( aEvtObj );
 376     }
 377 }
 378
 379
 380 void SAL_CALL
 381     SpellChecker::addEventListener( const Reference< XEventListener >& rxListener )
 382         throw(RuntimeException)
 383 {
 384     MutexGuard  aGuard( GetLinguMutex() );
 385
 386     if (!bDisposing && rxListener.is())
 387         aEvtListeners.addInterface( rxListener );
 388 }
 389
 390
 391 void SAL_CALL
 392     SpellChecker::removeEventListener( const Reference< XEventListener >& rxListener )
 393         throw(RuntimeException)
 394 {
 395     MutexGuard  aGuard( GetLinguMutex() );
 396
 397     if (!bDisposing && rxListener.is())
 398         aEvtListeners.removeInterface( rxListener );
 399 }
 400
 401
 402 // Service specific part
 403
 404 OUString SAL_CALL SpellChecker::getImplementationName()
 405         throw(RuntimeException)
 406 {
 407     return getImplementationName_Static();
 408 }
 409
 410
 411 sal_Bool SAL_CALL SpellChecker::supportsService( const OUString& ServiceName )
 412         throw(RuntimeException)
 413 {
 414     return cppu::supportsService(this, ServiceName);
 415 }
 416
 417 Sequence< OUString > SAL_CALL SpellChecker::getSupportedServiceNames()
 418         throw(RuntimeException)
 419 {
 420     return getSupportedServiceNames_Static();
 421 }
 422
 423
 424 Sequence< OUString > SpellChecker::getSupportedServiceNames_Static()
 425         throw()
 426 {
 427     Sequence< OUString > aSNS { SN_SPELLCHECKER };
 428     return aSNS;
 429 }
 430
 431
 432 sal_Bool SAL_CALL SpellChecker_writeInfo(
 433             void * /*pServiceManager*/, registry::XRegistryKey * pRegistryKey )
 434 {
 435     try
 436     {
 437         OUString aImpl( "/" + SpellChecker::getImplementationName_Static().getStr() +
 438             "/UNO/SERVICES" );
 439
 440         Reference< registry::XRegistryKey > xNewKey =
 441                 pRegistryKey->createKey( aImpl );
 442         Sequence< OUString > aServices =
 443                 SpellChecker::getSupportedServiceNames_Static();
 444         for( sal_Int32 i = 0; i < aServices.getLength(); i++ )
 445             xNewKey->createKey( aServices.getConstArray()[i] );
 446
 447         return sal_True;
 448     }
 449     catch(Exception &)
 450     {
 451         return sal_False;
 452     }
 453 }
 454
 455
 456 void * SAL_CALL SpellChecker_getFactory( const char * pImplName,
 457             XMultiServiceFactory * pServiceManager, void *  )
 458 {
 459     void * pRet = 0;
 460     if ( SpellChecker::getImplementationName_Static().equalsAscii( pImplName ) )
 461     {
 462         Reference< XSingleServiceFactory > xFactory =
 463             cppu::createOneInstanceFactory(
 464                 pServiceManager,
 465                 SpellChecker::getImplementationName_Static(),
 466                 SpellChecker_CreateInstance,
 467                 SpellChecker::getSupportedServiceNames_Static());
 468         // acquire, because we return an interface pointer instead of a reference
 469         xFactory->acquire();
 470         pRet = xFactory.get();
 471     }
 472     return pRet;
 473 }
 474
 475
 476 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */