lingucomponent/source/thesaurus/libnth/nthesimp.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: nthesimp.cxx,v $
  10  * $Revision: 1.15.6.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_lingucomponent.hxx"
  33
  34 // include <stdio.h>
  35 #include <com/sun/star/uno/Reference.h>
  36
  37 #include <cppuhelper/factory.hxx>       // helper for factories
  38 #include <com/sun/star/registry/XRegistryKey.hpp>
  39 #include <com/sun/star/beans/XPropertySet.hpp>
  40 #include <i18npool/mslangid.hxx>
  41 #include <tools/debug.hxx>
  42 #include <unotools/processfactory.hxx>
  43 #include <osl/mutex.hxx>
  44 #include <svtools/pathoptions.hxx>
  45 #include <svtools/lingucfg.hxx>
  46
  47 #include <rtl/string.hxx>
  48 #include <rtl/ustrbuf.hxx>
  49 #include "nthesimp.hxx"
  50 #include <linguistic/misc.hxx>
  51 #include <linguistic/lngprops.hxx>
  52 #include "nthesdta.hxx"
  53 #include <dictmgr.hxx>
  54
  55 #include <list>
  56 #include <set>
  57
  58 // values asigned to capitalization types
  59 #define CAPTYPE_UNKNOWN 0
  60 #define CAPTYPE_NOCAP   1
  61 #define CAPTYPE_INITCAP 2
  62 #define CAPTYPE_ALLCAP  3
  63 #define CAPTYPE_MIXED   4
  64
  65 // XML-header to query SPELLML support
  66 #define SPELLML_SUPPORT "<?xml?>"
  67
  68 using namespace utl;
  69 using namespace osl;
  70 using namespace rtl;
  71 using namespace com::sun::star;
  72 using namespace com::sun::star::beans;
  73 using namespace com::sun::star::lang;
  74 using namespace com::sun::star::uno;
  75 using namespace com::sun::star::linguistic2;
  76 using namespace linguistic;
  77
  78
  79
  80 ///////////////////////////////////////////////////////////////////////////
  81
  82 static uno::Reference< XLinguServiceManager > GetLngSvcMgr_Impl()
  83 {
  84     uno::Reference< XLinguServiceManager > xRes;
  85     uno::Reference< XMultiServiceFactory >  xMgr = getProcessServiceFactory();
  86     if (xMgr.is())
  87     {
  88         xRes = uno::Reference< XLinguServiceManager > ( xMgr->createInstance(
  89                 OUString( RTL_CONSTASCII_USTRINGPARAM(
  90                     "com.sun.star.linguistic2.LinguServiceManager" ) ) ), UNO_QUERY ) ;
  91     }
  92     return xRes;
  93 }
  94
  95 Thesaurus::Thesaurus() :
  96     aEvtListeners       ( GetLinguMutex() )
  97 {
  98     bDisposing = FALSE;
  99     pPropHelper = NULL;
 100     aThes = NULL;
 101     aCharSetInfo = NULL;
 102     aTEncs = NULL;
 103     aTLocs = NULL;
 104     aTNames = NULL;
 105         numthes = 0;
 106 }
 107
 108
 109 Thesaurus::~Thesaurus()
 110 {
 111
 112     if (aThes) {
 113         for (int i = 0; i < numthes; i++) {
 114             if (aThes[i]) delete aThes[i];
 115             aThes[i] = NULL;
 116         }
 117         delete[] aThes;
 118     }
 119     aThes = NULL;
 120     if (aCharSetInfo) {
 121         for (int i = 0; i < numthes; i++) {
 122             if (aCharSetInfo[i]) delete aCharSetInfo[i];
 123             aCharSetInfo[i] = NULL;
 124         }
 125         delete[] aCharSetInfo;
 126     }
 127     aCharSetInfo = NULL;
 128     numthes = 0;
 129     if (aTEncs) delete[] aTEncs;
 130     aTEncs = NULL;
 131     if (aTLocs) delete[] aTLocs;
 132     aTLocs = NULL;
 133     if (aTNames) delete[] aTNames;
 134     aTNames = NULL;
 135
 136     if (pPropHelper)
 137         pPropHelper->RemoveAsPropListener();
 138 }
 139
 140
 141 PropertyHelper_Thes & Thesaurus::GetPropHelper_Impl()
 142 {
 143     if (!pPropHelper)
 144     {
 145         Reference< XPropertySet >       xPropSet( GetLinguProperties(), UNO_QUERY );
 146
 147         pPropHelper     = new PropertyHelper_Thes( (XThesaurus *) this, xPropSet );
 148         xPropHelper = pPropHelper;
 149         pPropHelper->AddAsPropListener();       //! after a reference is established
 150     }
 151     return *pPropHelper;
 152 }
 153
 154
 155 Sequence< Locale > SAL_CALL Thesaurus::getLocales()
 156         throw(RuntimeException)
 157 {
 158     MutexGuard  aGuard( GetLinguMutex() );
 159
 160     // this routine should return the locales supported by the installed
 161     // dictionaries.
 162
 163     if (!numthes)
 164     {
 165         SvtLinguConfig aLinguCfg;
 166
 167         // get list of dictionaries-to-use
 168         std::list< SvtLinguConfigDictionaryEntry > aDics;
 169         uno::Sequence< rtl::OUString > aFormatList;
 170         aLinguCfg.GetSupportedDictionaryFormatsFor( A2OU("Thesauri"),
 171                 A2OU("org.openoffice.lingu.new.Thesaurus"), aFormatList );
 172         sal_Int32 nLen = aFormatList.getLength();
 173         for (sal_Int32 i = 0;  i < nLen;  ++i)
 174         {
 175             std::vector< SvtLinguConfigDictionaryEntry > aTmpDic(
 176                     aLinguCfg.GetActiveDictionariesByFormat( aFormatList[i] ) );
 177             aDics.insert( aDics.end(), aTmpDic.begin(), aTmpDic.end() );
 178         }
 179
 180         //!! for compatibility with old dictionaries (the ones not using extensions
 181         //!! or new configuration entries, but still using the dictionary.lst file)
 182         //!! Get the list of old style spell checking dictionaries to use...
 183         std::vector< SvtLinguConfigDictionaryEntry > aOldStyleDics(
 184                 GetOldStyleDics( "THES" ) );
 185
 186         // to prefer dictionaries with configuration entries we will only
 187         // use those old style dictionaries that add a language that
 188         // is not yet supported by the list od new style dictionaries
 189         MergeNewStyleDicsAndOldStyleDics( aDics, aOldStyleDics );
 190
 191         numthes = aDics.size();
 192         if (numthes)
 193         {
 194             // get supported locales from the dictionaries-to-use...
 195             sal_Int32 k = 0;
 196             std::set< rtl::OUString, lt_rtl_OUString > aLocaleNamesSet;
 197             std::list< SvtLinguConfigDictionaryEntry >::const_iterator aDictIt;
 198             for (aDictIt = aDics.begin();  aDictIt != aDics.end();  ++aDictIt)
 199             {
 200                 uno::Sequence< rtl::OUString > aLocaleNames( aDictIt->aLocaleNames );
 201                 sal_Int32 nLen2 = aLocaleNames.getLength();
 202                 for (k = 0;  k < nLen2;  ++k)
 203                 {
 204                     aLocaleNamesSet.insert( aLocaleNames[k] );
 205                 }
 206             }
 207             // ... and add them to the resulting sequence
 208             aSuppLocales.realloc( aLocaleNamesSet.size() );
 209             std::set< rtl::OUString, lt_rtl_OUString >::const_iterator aItB;
 210             k = 0;
 211             for (aItB = aLocaleNamesSet.begin();  aItB != aLocaleNamesSet.end();  ++aItB)
 212             {
 213                 Locale aTmp( MsLangId::convertLanguageToLocale(
 214                         MsLangId::convertIsoStringToLanguage( *aItB )));
 215                 aSuppLocales[k++] = aTmp;
 216             }
 217
 218             //! For each dictionary and each locale we need a seperate entry.
 219             //! If this results in more than one dictionary per locale than (for now)
 220             //! it is undefined which dictionary gets used.
 221             //! In the future the implementation should support using several dictionaries
 222             //! for one locale.
 223             numthes = 0;
 224             for (aDictIt = aDics.begin();  aDictIt != aDics.end();  ++aDictIt)
 225                 numthes = numthes + aDictIt->aLocaleNames.getLength();
 226
 227             // add dictionary information
 228             aThes   = new MyThes* [numthes];
 229             aTEncs  = new rtl_TextEncoding [numthes];
 230             aTLocs  = new Locale [numthes];
 231             aTNames = new OUString [numthes];
 232             aCharSetInfo = new CharClass* [numthes];
 233
 234             k = 0;
 235             for (aDictIt = aDics.begin();  aDictIt != aDics.end();  ++aDictIt)
 236             {
 237                 if (aDictIt->aLocaleNames.getLength() > 0 &&
 238                     aDictIt->aLocations.getLength() > 0)
 239                 {
 240                     uno::Sequence< rtl::OUString > aLocaleNames( aDictIt->aLocaleNames );
 241                     sal_Int32 nLocales = aLocaleNames.getLength();
 242
 243                     // currently only one language per dictionary is supported in the actual implementation...
 244                     // Thus here we work-around this by adding the same dictionary several times.
 245                     // Once for each of it's supported locales.
 246                     for (sal_Int32 i = 0;  i < nLocales;  ++i)
 247                     {
 248                         aThes[k]  = NULL;
 249                         aTEncs[k]  = 0;
 250                         aTLocs[k]  = MsLangId::convertLanguageToLocale(
 251                                         MsLangId::convertIsoStringToLanguage( aDictIt->aLocaleNames[i] ));
 252                         aCharSetInfo[k] = new CharClass( aTLocs[k] );
 253                         // also both files have to be in the same directory and the
 254                         // file names must only differ in the extension (.aff/.dic).
 255                         // Thus we use the first location only and strip the extension part.
 256                         rtl::OUString aLocation = aDictIt->aLocations[0];
 257                         sal_Int32 nPos = aLocation.lastIndexOf( '.' );
 258                         aLocation = aLocation.copy( 0, nPos );
 259                         aTNames[k] = aLocation;
 260
 261                         ++k;
 262                     }
 263                 }
 264             }
 265             DBG_ASSERT( k == numthes, "index mismatch?" );
 266         }
 267         else
 268         {
 269             /* no dictionary found so register no dictionaries */
 270             numthes = 0;
 271             aThes  = NULL;
 272             aTEncs  = NULL;
 273             aTLocs  = NULL;
 274             aTNames = NULL;
 275             aCharSetInfo = NULL;
 276             aSuppLocales.realloc(0);
 277         }
 278     }
 279
 280     return aSuppLocales;
 281 }
 282
 283
 284
 285 sal_Bool SAL_CALL Thesaurus::hasLocale(const Locale& rLocale)
 286         throw(RuntimeException)
 287 {
 288     MutexGuard  aGuard( GetLinguMutex() );
 289
 290     BOOL bRes = FALSE;
 291     if (!aSuppLocales.getLength())
 292         getLocales();
 293     INT32 nLen = aSuppLocales.getLength();
 294     for (INT32 i = 0;  i < nLen;  ++i)
 295     {
 296         const Locale *pLocale = aSuppLocales.getConstArray();
 297         if (rLocale == pLocale[i])
 298         {
 299             bRes = TRUE;
 300             break;
 301         }
 302     }
 303     return bRes;
 304 }
 305
 306
 307 Sequence < Reference < ::com::sun::star::linguistic2::XMeaning > > SAL_CALL
 308         Thesaurus::queryMeanings( const OUString& qTerm, const Locale& rLocale,
 309                                   const PropertyValues& rProperties)
 310                                   throw(IllegalArgumentException, RuntimeException)
 311 {
 312         MutexGuard      aGuard( GetLinguMutex() );
 313
 314         uno::Sequence< Reference< XMeaning > > aMeanings( 1 );
 315         uno::Sequence< Reference< XMeaning > > noMeanings( 0 );
 316         uno::Reference< XLinguServiceManager > xLngSvcMgr( GetLngSvcMgr_Impl() );
 317         uno::Reference< XSpellChecker1 > xSpell;
 318
 319         OUString rTerm(qTerm);
 320         OUString pTerm(qTerm);
 321         sal_uInt16 ct = CAPTYPE_UNKNOWN;
 322         sal_Int32 stem = 0;
 323         sal_Int32 stem2 = 0;
 324
 325         INT16 nLanguage = LocaleToLanguage( rLocale );
 326
 327         if (nLanguage == LANGUAGE_NONE  || !rTerm.getLength())
 328                 return noMeanings;
 329
 330     if (!hasLocale( rLocale ))
 331 #ifdef LINGU_EXCEPTIONS
 332         throw( IllegalArgumentException() );
 333 #else
 334         return noMeanings;
 335 #endif
 336
 337         if (prevTerm == qTerm && prevLocale == nLanguage) return prevMeanings;
 338
 339         mentry * pmean = NULL;
 340     sal_Int32 nmean = 0;
 341
 342         PropertyHelper_Thes &rHelper = GetPropHelper();
 343         rHelper.SetTmpPropVals( rProperties );
 344
 345         MyThes * pTH = NULL;
 346         rtl_TextEncoding aEnc = 0;
 347         CharClass * pCC = NULL;
 348
 349         // find the first thesaurus that matches the locale
 350         for (int i =0; i < numthes; i++) {
 351             if (rLocale == aTLocs[i])
 352             {
 353            // open up and intialize this thesaurus if need be
 354                    if (!aThes[i])
 355                    {
 356                       OUString datpath = aTNames[i] + A2OU(".dat");
 357                       OUString idxpath = aTNames[i] + A2OU(".idx");
 358                       OUString ndat;
 359                       OUString nidx;
 360                       osl::FileBase::getSystemPathFromFileURL(datpath,ndat);
 361                       osl::FileBase::getSystemPathFromFileURL(idxpath,nidx);
 362                       OString aTmpidx(OU2ENC(nidx,osl_getThreadTextEncoding()));
 363                       OString aTmpdat(OU2ENC(ndat,osl_getThreadTextEncoding()));
 364
 365 #if defined(WNT)
 366                       // workaround for Windows specifc problem that the
 367                       // path length in calls to 'fopen' is limted to somewhat
 368                       // about 120+ characters which will usually be exceed when
 369                       // using dictionaries as extensions.
 370                       aTmpidx = Win_GetShortPathName( nidx );
 371                       aTmpdat = Win_GetShortPathName( ndat );
 372 #endif
 373
 374                       aThes[i] = new MyThes(aTmpidx.getStr(),aTmpdat.getStr());
 375                       if (aThes[i]) {
 376                         const char * enc_string = aThes[i]->get_th_encoding();
 377                         if (!enc_string) {
 378                           aTEncs[i] = rtl_getTextEncodingFromUnixCharset("ISO8859-1");
 379                         } else {
 380                           aTEncs[i] = rtl_getTextEncodingFromUnixCharset(enc_string);
 381                           if (aTEncs[i] == RTL_TEXTENCODING_DONTKNOW) {
 382                             if (strcmp("ISCII-DEVANAGARI", enc_string) == 0) {
 383                               aTEncs[i] = RTL_TEXTENCODING_ISCII_DEVANAGARI;
 384                             } else if (strcmp("UTF-8", enc_string) == 0) {
 385                               aTEncs[i] = RTL_TEXTENCODING_UTF8;
 386                             }
 387                           }
 388                       }
 389                    }
 390                }
 391                pTH = aThes[i];
 392                    aEnc = aTEncs[i];
 393                    pCC = aCharSetInfo[i];
 394
 395                if (pTH)
 396                    break;
 397         }
 398     }
 399
 400         while (pTH) {
 401          // convert word to all lower case for searching
 402              if (!stem) ct = capitalType(rTerm, pCC);
 403              OUString nTerm(makeLowerCase(rTerm, pCC));
 404              OString aTmp( OU2ENC(nTerm, aEnc) );
 405              nmean = pTH->Lookup(aTmp.getStr(),aTmp.getLength(),&pmean);
 406
 407              if (nmean) aMeanings.realloc( nmean );
 408
 409              mentry * pe = pmean;
 410              OUString codeTerm = qTerm;
 411          Reference< XSpellAlternatives > xTmpRes2;
 412
 413          if (stem) {
 414                xTmpRes2 = xSpell->spell( A2OU("<?xml?><query type='analyze'><word>") +
 415             pTerm + A2OU("</word></query>"), nLanguage, rProperties );
 416                if (xTmpRes2.is()) {
 417                  Sequence<OUString>seq = xTmpRes2->getAlternatives();
 418                  if (seq.getLength() > 0) {
 419                     codeTerm = seq[0];
 420                     stem2 = 1;
 421                  }
 422 #if 0
 423                  OString o = OUStringToOString(codeTerm, rtl_getTextEncodingFromUnixCharset("UTF-8"));
 424                  fprintf(stderr, "CODETERM: %s\n", o.pData->buffer);
 425 #endif
 426                }
 427              }
 428
 429          for (int j = 0; j < nmean; j++) {
 430              int count = pe->count;
 431                  if (count) {
 432                      Sequence< OUString > aStr( count );
 433                      OUString *pStr = aStr.getArray();
 434
 435                      for (int i=0; i < count; i++) {
 436                        OUString sTerm(pe->psyns[i],strlen(pe->psyns[i]),aEnc );
 437                        sal_Int32 catpos = sTerm.indexOf('(');
 438                        sal_Int32 catpos2 = 0;
 439                        OUString catst;
 440                        OUString catst2;
 441                        if (catpos > 2) {
 442                          // remove category name for affixation and casing
 443                          catst = A2OU(" ") + sTerm.copy(catpos);
 444                          sTerm = sTerm.copy(0, catpos);
 445                          sTerm = sTerm.trim();
 446                        }
 447                        // generate synonyms with affixes
 448                        if (stem && stem2) {
 449                  Reference< XSpellAlternatives > xTmpRes;
 450                  xTmpRes = xSpell->spell( A2OU("<?xml?><query type='generate'><word>") +
 451                  sTerm + A2OU("</word>") + codeTerm + A2OU("</query>"), nLanguage, rProperties );
 452                  if (xTmpRes.is()) {
 453                    Sequence<OUString>seq = xTmpRes->getAlternatives();
 454                    for (int k = 0; k < seq.getLength(); k++) {
 455                      OString o = OUStringToOString(seq[k], rtl_getTextEncodingFromUnixCharset("UTF-8"));
 456                    }
 457                    if (seq.getLength() > 0) sTerm = seq[0];
 458                  }
 459                }
 460                if (catpos2) sTerm = catst2 + sTerm;
 461
 462                        sal_uInt16 ct1 = capitalType(sTerm, pCC);
 463                        if (CAPTYPE_MIXED == ct1)
 464                             ct = ct1;
 465                        OUString cTerm;
 466                        switch (ct) {
 467                        case CAPTYPE_ALLCAP:
 468                      {
 469                                cTerm = makeUpperCase(sTerm, pCC);
 470                                break;
 471                              }
 472                        case CAPTYPE_INITCAP:
 473                      {
 474                                cTerm = makeInitCap(sTerm, pCC);
 475                                break;
 476                              }
 477                            default:
 478                      {
 479                                cTerm = sTerm;
 480                                break;
 481                              }
 482                }
 483                        OUString aAlt( cTerm + catst);
 484                        pStr[i] = aAlt;
 485              }
 486 #if 0
 487                      Meaning * pMn = new Meaning(rTerm,nLanguage,rHelper);
 488 #endif
 489                      Meaning * pMn = new Meaning(rTerm,nLanguage);
 490                      OUString dTerm(pe->defn,strlen(pe->defn),aEnc );
 491                      pMn->SetMeaning(dTerm);
 492                      pMn->SetSynonyms(aStr);
 493                      Reference<XMeaning>* pMeaning = aMeanings.getArray();
 494                      pMeaning[j] = pMn;
 495          }
 496                  pe++;
 497          }
 498              pTH->CleanUpAfterLookup(&pmean,nmean);
 499
 500         if (nmean) {
 501             prevTerm = qTerm;
 502             prevMeanings = aMeanings;
 503             prevLocale = nLanguage;
 504             return aMeanings;
 505     }
 506
 507         if (stem || !xLngSvcMgr.is()) return noMeanings;
 508         stem = 1;
 509
 510         xSpell = uno::Reference< XSpellChecker1 >( xLngSvcMgr->getSpellChecker(), UNO_QUERY );
 511         if (!xSpell.is() || !xSpell->isValid( A2OU(SPELLML_SUPPORT), nLanguage, rProperties )) {
 512             return noMeanings;
 513         }
 514         Reference< XSpellAlternatives > xTmpRes;
 515         xTmpRes = xSpell->spell( A2OU("<?xml?><query type='stem'><word>") +
 516             rTerm + A2OU("</word></query>"), nLanguage, rProperties );
 517         if (xTmpRes.is()) {
 518             Sequence<OUString>seq = xTmpRes->getAlternatives();
 519 #if 0
 520             for (int i = 0; i < seq.getLength(); i++) {
 521                 OString o = OUStringToOString(seq[i], rtl_getTextEncodingFromUnixCharset("UTF-8"));
 522                 fprintf(stderr, "%d: %s\n", i + 1, o.pData->buffer);
 523             }
 524 #endif
 525             if (seq.getLength() > 0) {
 526                 rTerm = seq[0];  // XXX Use only the first stem
 527                 continue;
 528             }
 529         }
 530
 531         // stem the last word of the synonym (for categories after affixation)
 532         rTerm = rTerm.trim();
 533         sal_Int32 pos = rTerm.lastIndexOf(' ');
 534         if (!pos) return noMeanings;
 535         xTmpRes = xSpell->spell( A2OU("<?xml?><query type='stem'><word>") +
 536             rTerm.copy(pos + 1) + A2OU("</word></query>"), nLanguage, rProperties );
 537         if (xTmpRes.is()) {
 538             Sequence<OUString>seq = xTmpRes->getAlternatives();
 539             if (seq.getLength() > 0) {
 540                 pTerm = rTerm.copy(pos + 1);
 541                 rTerm = rTerm.copy(0, pos + 1) + seq[0];
 542 #if 0
 543                 for (int i = 0; i < seq.getLength(); i++) {
 544                     OString o = OUStringToOString(seq[i], rtl_getTextEncodingFromUnixCharset("UTF-8"));
 545                     fprintf(stderr, "%d: %s\n", i + 1, o.pData->buffer);
 546                 }
 547 #endif
 548                 continue;
 549             }
 550         }
 551         break;
 552         }
 553     return noMeanings;
 554 }
 555
 556
 557
 558 Reference< XInterface > SAL_CALL Thesaurus_CreateInstance(
 559             const Reference< XMultiServiceFactory > & /*rSMgr*/ )
 560         throw(Exception)
 561 {
 562     Reference< XInterface > xService = (cppu::OWeakObject*) new Thesaurus;
 563     return xService;
 564 }
 565
 566
 567 OUString SAL_CALL
 568     Thesaurus::getServiceDisplayName( const Locale& /*rLocale*/ )
 569         throw(RuntimeException)
 570 {
 571     MutexGuard  aGuard( GetLinguMutex() );
 572     return A2OU( "OpenOffice.org New Thesaurus" );
 573 }
 574
 575
 576 void SAL_CALL
 577     Thesaurus::initialize( const Sequence< Any >& rArguments )
 578         throw(Exception, RuntimeException)
 579 {
 580     MutexGuard  aGuard( GetLinguMutex() );
 581
 582     if (!pPropHelper)
 583     {
 584         INT32 nLen = rArguments.getLength();
 585         if (1 == nLen)
 586         {
 587             Reference< XPropertySet     >       xPropSet;
 588             rArguments.getConstArray()[0] >>= xPropSet;
 589
 590             //! Pointer allows for access of the non-UNO functions.
 591             //! And the reference to the UNO-functions while increasing
 592             //! the ref-count and will implicitly free the memory
 593             //! when the object is not longer used.
 594             pPropHelper = new PropertyHelper_Thes( (XThesaurus *) this, xPropSet );
 595             xPropHelper = pPropHelper;
 596             pPropHelper->AddAsPropListener();   //! after a reference is established
 597         }
 598         else
 599             DBG_ERROR( "wrong number of arguments in sequence" );
 600     }
 601 }
 602
 603
 604
 605 sal_uInt16 SAL_CALL Thesaurus::capitalType(const OUString& aTerm, CharClass * pCC)
 606 {
 607         sal_Int32 tlen = aTerm.getLength();
 608         if ((pCC) && (tlen)) {
 609               String aStr(aTerm);
 610               sal_Int32 nc = 0;
 611               for (USHORT tindex = 0; tindex < tlen;  tindex++) {
 612                if (pCC->getCharacterType(aStr,tindex) &
 613                        ::com::sun::star::i18n::KCharacterType::UPPER) nc++;
 614           }
 615
 616               if (nc == 0) return (sal_uInt16) CAPTYPE_NOCAP;
 617
 618               if (nc == tlen) return (sal_uInt16) CAPTYPE_ALLCAP;
 619
 620               if ((nc == 1) && (pCC->getCharacterType(aStr,0) &
 621                       ::com::sun::star::i18n::KCharacterType::UPPER))
 622                    return (sal_uInt16) CAPTYPE_INITCAP;
 623
 624               return (sal_uInt16) CAPTYPE_MIXED;
 625     }
 626         return (sal_uInt16) CAPTYPE_UNKNOWN;
 627 }
 628
 629
 630
 631 OUString SAL_CALL Thesaurus::makeLowerCase(const OUString& aTerm, CharClass * pCC)
 632 {
 633         if (pCC)
 634       return pCC->toLower_rtl(aTerm, 0, aTerm.getLength());
 635         return aTerm;
 636 }
 637
 638
 639 OUString SAL_CALL Thesaurus::makeUpperCase(const OUString& aTerm, CharClass * pCC)
 640 {
 641         if (pCC)
 642               return pCC->toUpper_rtl(aTerm, 0, aTerm.getLength());
 643         return aTerm;
 644 }
 645
 646
 647 OUString SAL_CALL Thesaurus::makeInitCap(const OUString& aTerm, CharClass * pCC)
 648 {
 649         sal_Int32 tlen = aTerm.getLength();
 650         if ((pCC) && (tlen)) {
 651               OUString bTemp = aTerm.copy(0,1);
 652               if (tlen > 1)
 653                    return ( pCC->toUpper_rtl(bTemp, 0, 1)
 654                              + pCC->toLower_rtl(aTerm,1,(tlen-1)) );
 655
 656           return pCC->toUpper_rtl(bTemp, 0, 1);
 657     }
 658         return aTerm;
 659 }
 660
 661
 662
 663 void SAL_CALL
 664     Thesaurus::dispose()
 665         throw(RuntimeException)
 666 {
 667     MutexGuard  aGuard( GetLinguMutex() );
 668
 669     if (!bDisposing)
 670     {
 671         bDisposing = TRUE;
 672         EventObject     aEvtObj( (XThesaurus *) this );
 673         aEvtListeners.disposeAndClear( aEvtObj );
 674     }
 675 }
 676
 677
 678 void SAL_CALL
 679     Thesaurus::addEventListener( const Reference< XEventListener >& rxListener )
 680         throw(RuntimeException)
 681 {
 682     MutexGuard  aGuard( GetLinguMutex() );
 683
 684     if (!bDisposing && rxListener.is())
 685         aEvtListeners.addInterface( rxListener );
 686 }
 687
 688
 689 void SAL_CALL
 690     Thesaurus::removeEventListener( const Reference< XEventListener >& rxListener )
 691         throw(RuntimeException)
 692 {
 693     MutexGuard  aGuard( GetLinguMutex() );
 694
 695     if (!bDisposing && rxListener.is())
 696         aEvtListeners.removeInterface( rxListener );
 697 }
 698
 699
 700 ///////////////////////////////////////////////////////////////////////////
 701 // Service specific part
 702 //
 703
 704 OUString SAL_CALL Thesaurus::getImplementationName()
 705         throw(RuntimeException)
 706 {
 707     MutexGuard  aGuard( GetLinguMutex() );
 708     return getImplementationName_Static();
 709 }
 710
 711
 712 sal_Bool SAL_CALL Thesaurus::supportsService( const OUString& ServiceName )
 713         throw(RuntimeException)
 714 {
 715     MutexGuard  aGuard( GetLinguMutex() );
 716
 717     Sequence< OUString > aSNL = getSupportedServiceNames();
 718     const OUString * pArray = aSNL.getConstArray();
 719     for( INT32 i = 0; i < aSNL.getLength(); i++ )
 720         if( pArray[i] == ServiceName )
 721             return TRUE;
 722     return FALSE;
 723 }
 724
 725
 726 Sequence< OUString > SAL_CALL Thesaurus::getSupportedServiceNames()
 727         throw(RuntimeException)
 728 {
 729     MutexGuard  aGuard( GetLinguMutex() );
 730     return getSupportedServiceNames_Static();
 731 }
 732
 733
 734 Sequence< OUString > Thesaurus::getSupportedServiceNames_Static()
 735         throw()
 736 {
 737     MutexGuard  aGuard( GetLinguMutex() );
 738
 739     Sequence< OUString > aSNS( 1 );     // auch mehr als 1 Service moeglich
 740     aSNS.getArray()[0] = A2OU( SN_THESAURUS );
 741     return aSNS;
 742 }
 743
 744
 745 sal_Bool SAL_CALL Thesaurus_writeInfo(
 746             void * /*pServiceManager*/, registry::XRegistryKey * pRegistryKey )
 747 {
 748     try
 749     {
 750         String aImpl( '/' );
 751         aImpl += Thesaurus::getImplementationName_Static().getStr();
 752         aImpl.AppendAscii( "/UNO/SERVICES" );
 753         Reference< registry::XRegistryKey > xNewKey =
 754                 pRegistryKey->createKey( aImpl );
 755         Sequence< OUString > aServices =
 756                 Thesaurus::getSupportedServiceNames_Static();
 757         for( INT32 i = 0; i < aServices.getLength(); i++ )
 758             xNewKey->createKey( aServices.getConstArray()[i] );
 759
 760         return sal_True;
 761     }
 762     catch(Exception &)
 763     {
 764         return sal_False;
 765     }
 766 }
 767
 768
 769 void * SAL_CALL Thesaurus_getFactory( const sal_Char * pImplName,
 770             XMultiServiceFactory * pServiceManager, void *  )
 771 {
 772     void * pRet = 0;
 773     if ( !Thesaurus::getImplementationName_Static().compareToAscii( pImplName ) )
 774     {
 775
 776         Reference< XSingleServiceFactory > xFactory =
 777             cppu::createOneInstanceFactory(
 778                 pServiceManager,
 779                 Thesaurus::getImplementationName_Static(),
 780                 Thesaurus_CreateInstance,
 781                 Thesaurus::getSupportedServiceNames_Static());
 782         // acquire, because we return an interface pointer instead of a reference
 783         xFactory->acquire();
 784         pRet = xFactory.get();
 785     }
 786     return pRet;
 787 }
 788
 789
 790 ///////////////////////////////////////////////////////////////////////////
 791
 792
 793 #undef CAPTYPE_UNKNOWN
 794 #undef CAPTYPE_NOCAP
 795 #undef CAPTYPE_INITCAP
 796 #undef CAPTYPE_ALLCAP
 797 #undef CAPTYPE_MIXED