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