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_linguistic.hxx" 26 27 #include "lngopt.hxx" 28 #include "linguistic/lngprops.hxx" 29 #include "linguistic/misc.hxx" 30 #include <tools/debug.hxx> 31 #include <unotools/lingucfg.hxx> 32 33 #include <uno/lbnames.h> // CPPU_CURRENT_LANGUAGE_BINDING_NAME macro, which specify the environment type 34 #include <cppuhelper/implbase1.hxx> // helper for implementations 35 36 #include <cppuhelper/factory.hxx> // helper for factories 37 #include <com/sun/star/container/XNameAccess.hpp> 38 #include <com/sun/star/registry/XSimpleRegistry.hpp> 39 #include <com/sun/star/registry/XRegistryKey.hpp> 40 #include <com/sun/star/lang/Locale.hpp> 41 #include <com/sun/star/i18n/ScriptType.hpp> 42 #include <unotools/processfactory.hxx> 43 #include <i18npool/mslangid.hxx> 44 45 using namespace utl; 46 using namespace osl; 47 using namespace rtl; 48 using namespace com::sun::star; 49 using namespace com::sun::star::container; 50 using namespace com::sun::star::beans; 51 using namespace com::sun::star::lang; 52 using namespace com::sun::star::uno; 53 using namespace com::sun::star::linguistic2; 54 using namespace linguistic; 55 56 using namespace com::sun::star::registry; 57 58 /////////////////////////////////////////////////////////////////////////// 59 60 61 // static member intialization 62 SvtLinguOptions * LinguOptions::pData = NULL; 63 vos::ORefCount LinguOptions::aRefCount; 64 65 66 LinguOptions::LinguOptions() 67 { 68 if (!pData) 69 { 70 pData = new SvtLinguOptions; 71 SvtLinguConfig aLinguCfg; 72 aLinguCfg.GetOptions( *pData ); 73 } 74 75 ++aRefCount; 76 } 77 78 79 LinguOptions::LinguOptions(const LinguOptions & /*rOpt*/) 80 { 81 DBG_ASSERT( pData, "lng : data missing" ); 82 ++aRefCount; 83 } 84 85 86 LinguOptions::~LinguOptions() 87 { 88 MutexGuard aGuard( GetLinguMutex() ); 89 90 if (--aRefCount == 0) 91 { 92 delete pData; pData = NULL; 93 } 94 } 95 96 97 sal_Bool LinguOptions::SetLocale_Impl( sal_Int16 &rLanguage, Any &rOld, const Any &rVal, sal_Int16 nType) 98 { 99 sal_Bool bRes = sal_False; 100 101 Locale aNew; 102 rVal >>= aNew; 103 sal_Int16 nNew = MsLangId::resolveSystemLanguageByScriptType(MsLangId::convertLocaleToLanguage(aNew), nType); 104 if (nNew != rLanguage) 105 { 106 Locale aLocale( CreateLocale( rLanguage ) ); 107 rOld.setValue( &aLocale, ::getCppuType((Locale*)0 )); 108 rLanguage = nNew; 109 bRes = sal_True; 110 } 111 112 return bRes; 113 } 114 115 116 sal_Bool LinguOptions::SetValue( Any &rOld, const Any &rVal, sal_Int32 nWID ) 117 { 118 MutexGuard aGuard( GetLinguMutex() ); 119 120 sal_Bool bRes = sal_False; 121 122 sal_Int16 *pnVal = 0; 123 sal_Bool *pbVal = 0; 124 125 switch( nWID ) 126 { 127 case WID_IS_GERMAN_PRE_REFORM : /*! deprecated !*/ break; 128 case WID_IS_USE_DICTIONARY_LIST : pbVal = &pData->bIsUseDictionaryList; break; 129 case WID_IS_IGNORE_CONTROL_CHARACTERS : pbVal = &pData->bIsIgnoreControlCharacters; break; 130 case WID_IS_HYPH_AUTO : pbVal = &pData->bIsHyphAuto; break; 131 case WID_IS_HYPH_SPECIAL : pbVal = &pData->bIsHyphSpecial; break; 132 case WID_IS_SPELL_AUTO : pbVal = &pData->bIsSpellAuto; break; 133 case WID_IS_SPELL_HIDE : /*! deprecated !*/ break; 134 case WID_IS_SPELL_IN_ALL_LANGUAGES :/*! deprecated !*/ break; 135 case WID_IS_SPELL_SPECIAL : pbVal = &pData->bIsSpellSpecial; break; 136 case WID_IS_WRAP_REVERSE : pbVal = &pData->bIsSpellReverse; break; 137 case WID_DEFAULT_LANGUAGE : pnVal = &pData->nDefaultLanguage; break; 138 case WID_IS_SPELL_CAPITALIZATION : pbVal = &pData->bIsSpellCapitalization; break; 139 case WID_IS_SPELL_WITH_DIGITS : pbVal = &pData->bIsSpellWithDigits; break; 140 case WID_IS_SPELL_UPPER_CASE : pbVal = &pData->bIsSpellUpperCase; break; 141 case WID_HYPH_MIN_LEADING : pnVal = &pData->nHyphMinLeading; break; 142 case WID_HYPH_MIN_TRAILING : pnVal = &pData->nHyphMinTrailing; break; 143 case WID_HYPH_MIN_WORD_LENGTH : pnVal = &pData->nHyphMinWordLength; break; 144 case WID_DEFAULT_LOCALE : 145 { 146 bRes = SetLocale_Impl( pData->nDefaultLanguage, rOld, rVal, ::com::sun::star::i18n::ScriptType::LATIN ); 147 break; 148 } 149 case WID_DEFAULT_LOCALE_CJK : 150 { 151 bRes = SetLocale_Impl( pData->nDefaultLanguage_CJK, rOld, rVal, ::com::sun::star::i18n::ScriptType::ASIAN ); 152 break; 153 } 154 case WID_DEFAULT_LOCALE_CTL : 155 { 156 bRes = SetLocale_Impl( pData->nDefaultLanguage_CTL, rOld, rVal, ::com::sun::star::i18n::ScriptType::COMPLEX ); 157 break; 158 } 159 default : 160 { 161 DBG_ASSERT( 0,"lng : unknown WID"); 162 bRes = sal_False; 163 } 164 } 165 166 if (pbVal) 167 { 168 sal_Bool bNew = sal_False; 169 rVal >>= bNew; 170 if (bNew != *pbVal) 171 { 172 rOld <<= *pbVal; 173 *pbVal = bNew; 174 bRes = sal_True; 175 } 176 } 177 if (pnVal) 178 { 179 sal_Int16 nNew = 0; 180 rVal >>= nNew; 181 if (nNew != *pnVal) 182 { 183 rOld <<= *pnVal; 184 *pnVal = nNew; 185 bRes = sal_True; 186 } 187 } 188 189 // if (bRes) 190 // pData->SetModified(); 191 192 return bRes; 193 } 194 195 void LinguOptions::GetValue( Any &rVal, sal_Int32 nWID ) const 196 { 197 MutexGuard aGuard( GetLinguMutex() ); 198 199 sal_Int16 *pnVal = 0; 200 sal_Bool *pbVal = 0; 201 sal_Bool bDummy = sal_False; 202 203 switch( nWID ) 204 { 205 case WID_IS_GERMAN_PRE_REFORM : pbVal = &bDummy; /*! deprecated !*/ break; 206 case WID_IS_USE_DICTIONARY_LIST : pbVal = &pData->bIsUseDictionaryList; break; 207 case WID_IS_IGNORE_CONTROL_CHARACTERS : pbVal = &pData->bIsIgnoreControlCharacters; break; 208 case WID_IS_HYPH_AUTO : pbVal = &pData->bIsHyphAuto; break; 209 case WID_IS_HYPH_SPECIAL : pbVal = &pData->bIsHyphSpecial; break; 210 case WID_IS_SPELL_AUTO : pbVal = &pData->bIsSpellAuto; break; 211 case WID_IS_SPELL_HIDE : pbVal = &bDummy; /*! deprecated !*/ break; 212 case WID_IS_SPELL_IN_ALL_LANGUAGES :pbVal = &bDummy; /*! deprecated !*/ break; 213 case WID_IS_SPELL_SPECIAL : pbVal = &pData->bIsSpellSpecial; break; 214 case WID_IS_WRAP_REVERSE : pbVal = &pData->bIsSpellReverse; break; 215 case WID_DEFAULT_LANGUAGE : pnVal = &pData->nDefaultLanguage; break; 216 case WID_IS_SPELL_CAPITALIZATION : pbVal = &pData->bIsSpellCapitalization; break; 217 case WID_IS_SPELL_WITH_DIGITS : pbVal = &pData->bIsSpellWithDigits; break; 218 case WID_IS_SPELL_UPPER_CASE : pbVal = &pData->bIsSpellUpperCase; break; 219 case WID_HYPH_MIN_LEADING : pnVal = &pData->nHyphMinLeading; break; 220 case WID_HYPH_MIN_TRAILING : pnVal = &pData->nHyphMinTrailing; break; 221 case WID_HYPH_MIN_WORD_LENGTH : pnVal = &pData->nHyphMinWordLength; break; 222 case WID_DEFAULT_LOCALE : 223 { 224 Locale aLocale( MsLangId::convertLanguageToLocale( pData->nDefaultLanguage ) ); 225 rVal.setValue( &aLocale, ::getCppuType((Locale*)0 )); 226 break; 227 } 228 case WID_DEFAULT_LOCALE_CJK : 229 { 230 Locale aLocale( MsLangId::convertLanguageToLocale( pData->nDefaultLanguage_CJK ) ); 231 rVal.setValue( &aLocale, ::getCppuType((Locale*)0 )); 232 break; 233 } 234 case WID_DEFAULT_LOCALE_CTL : 235 { 236 Locale aLocale( MsLangId::convertLanguageToLocale( pData->nDefaultLanguage_CTL ) ); 237 rVal.setValue( &aLocale, ::getCppuType((Locale*)0 )); 238 break; 239 } 240 default : 241 { 242 DBG_ASSERT( 0,"lng : unknown WID"); 243 } 244 } 245 246 if (pbVal) 247 rVal <<= *pbVal; 248 if (pnVal) 249 rVal <<= *pnVal; 250 } 251 252 253 struct WID_Name 254 { 255 sal_Int32 nWID; 256 const char *pPropertyName; 257 }; 258 259 //! order of entries is import (see LinguOptions::GetName) 260 //! since the WID is used as index in this table! 261 WID_Name aWID_Name[] = 262 { 263 { 0, 0 }, 264 { WID_IS_USE_DICTIONARY_LIST, UPN_IS_USE_DICTIONARY_LIST }, 265 { WID_IS_IGNORE_CONTROL_CHARACTERS, UPN_IS_IGNORE_CONTROL_CHARACTERS }, 266 { WID_IS_SPELL_UPPER_CASE, UPN_IS_SPELL_UPPER_CASE }, 267 { WID_IS_SPELL_WITH_DIGITS, UPN_IS_SPELL_WITH_DIGITS }, 268 { WID_IS_SPELL_CAPITALIZATION, UPN_IS_SPELL_CAPITALIZATION }, 269 { WID_HYPH_MIN_LEADING, UPN_HYPH_MIN_LEADING }, 270 { WID_HYPH_MIN_TRAILING, UPN_HYPH_MIN_TRAILING }, 271 { WID_HYPH_MIN_WORD_LENGTH, UPN_HYPH_MIN_WORD_LENGTH }, 272 { WID_DEFAULT_LOCALE, UPN_DEFAULT_LOCALE }, 273 { WID_IS_SPELL_AUTO, UPN_IS_SPELL_AUTO }, 274 { 0, 0 }, 275 { 0, 0 }, 276 { WID_IS_SPELL_SPECIAL, UPN_IS_SPELL_SPECIAL }, 277 { WID_IS_HYPH_AUTO, UPN_IS_HYPH_AUTO }, 278 { WID_IS_HYPH_SPECIAL, UPN_IS_HYPH_SPECIAL }, 279 { WID_IS_WRAP_REVERSE, UPN_IS_WRAP_REVERSE }, 280 { 0, 0 }, 281 { 0, 0 }, 282 { 0, 0 }, 283 { 0, 0 }, 284 { WID_DEFAULT_LANGUAGE, UPN_DEFAULT_LANGUAGE }, 285 { WID_DEFAULT_LOCALE_CJK, UPN_DEFAULT_LOCALE_CJK }, 286 { WID_DEFAULT_LOCALE_CTL, UPN_DEFAULT_LOCALE_CTL } 287 }; 288 289 290 OUString LinguOptions::GetName( sal_Int32 nWID ) 291 { 292 MutexGuard aGuard( GetLinguMutex() ); 293 294 OUString aRes; 295 296 sal_Int32 nLen = sizeof( aWID_Name ) / sizeof( aWID_Name[0] ); 297 if (0 <= nWID && nWID < nLen 298 && aWID_Name[ nWID ].nWID == nWID) 299 { 300 aRes = OUString( RTL_CONSTASCII_USTRINGPARAM( 301 aWID_Name[ nWID ].pPropertyName ) ); 302 } 303 else 304 { 305 DBG_ASSERT( 0,"lng : unknown WID"); 306 } 307 308 return aRes; 309 } 310 311 312 /////////////////////////////////////////////////////////////////////////// 313 314 //! map must be sorted by first entry in alphabetical increasing order. 315 const SfxItemPropertyMapEntry* lcl_GetLinguProps() 316 { 317 static const SfxItemPropertyMapEntry aLinguProps[] = 318 { 319 { MAP_CHAR_LEN(UPN_DEFAULT_LANGUAGE), WID_DEFAULT_LANGUAGE, 320 &::getCppuType( (sal_Int16*)0 ), 0, 0 }, 321 { MAP_CHAR_LEN(UPN_DEFAULT_LOCALE), WID_DEFAULT_LOCALE, 322 &::getCppuType( (Locale* )0), 0, 0 }, 323 { MAP_CHAR_LEN(UPN_DEFAULT_LOCALE_CJK), WID_DEFAULT_LOCALE_CJK, 324 &::getCppuType( (Locale* )0), 0, 0 }, 325 { MAP_CHAR_LEN(UPN_DEFAULT_LOCALE_CTL), WID_DEFAULT_LOCALE_CTL, 326 &::getCppuType( (Locale* )0), 0, 0 }, 327 { MAP_CHAR_LEN(UPN_HYPH_MIN_LEADING), WID_HYPH_MIN_LEADING, 328 &::getCppuType( (sal_Int16*)0 ), 0, 0 }, 329 { MAP_CHAR_LEN(UPN_HYPH_MIN_TRAILING), WID_HYPH_MIN_TRAILING, 330 &::getCppuType( (sal_Int16*)0 ), 0, 0 }, 331 { MAP_CHAR_LEN(UPN_HYPH_MIN_WORD_LENGTH), WID_HYPH_MIN_WORD_LENGTH, 332 &::getCppuType( (sal_Int16*)0 ), 0, 0 }, 333 { MAP_CHAR_LEN(UPN_IS_GERMAN_PRE_REFORM), WID_IS_GERMAN_PRE_REFORM, /*! deprecated !*/ 334 &::getBooleanCppuType(), 0, 0 }, 335 { MAP_CHAR_LEN(UPN_IS_HYPH_AUTO), WID_IS_HYPH_AUTO, 336 &::getBooleanCppuType(), 0, 0 }, 337 { MAP_CHAR_LEN(UPN_IS_HYPH_SPECIAL), WID_IS_HYPH_SPECIAL, 338 &::getBooleanCppuType(), 0, 0 }, 339 { MAP_CHAR_LEN(UPN_IS_IGNORE_CONTROL_CHARACTERS), WID_IS_IGNORE_CONTROL_CHARACTERS, 340 &::getBooleanCppuType(), 0, 0 }, 341 { MAP_CHAR_LEN(UPN_IS_SPELL_AUTO), WID_IS_SPELL_AUTO, 342 &::getBooleanCppuType(), 0, 0 }, 343 { MAP_CHAR_LEN(UPN_IS_SPELL_CAPITALIZATION), WID_IS_SPELL_CAPITALIZATION, 344 &::getBooleanCppuType(), 0, 0 }, 345 { MAP_CHAR_LEN(UPN_IS_SPELL_HIDE), WID_IS_SPELL_HIDE, /*! deprecated !*/ 346 &::getBooleanCppuType(), 0, 0 }, 347 { MAP_CHAR_LEN(UPN_IS_SPELL_IN_ALL_LANGUAGES), WID_IS_SPELL_IN_ALL_LANGUAGES, /*! deprecated !*/ 348 &::getBooleanCppuType(), 0, 0 }, 349 { MAP_CHAR_LEN(UPN_IS_SPELL_SPECIAL), WID_IS_SPELL_SPECIAL, 350 &::getBooleanCppuType(), 0, 0 }, 351 { MAP_CHAR_LEN(UPN_IS_SPELL_UPPER_CASE), WID_IS_SPELL_UPPER_CASE, 352 &::getBooleanCppuType(), 0, 0 }, 353 { MAP_CHAR_LEN(UPN_IS_SPELL_WITH_DIGITS), WID_IS_SPELL_WITH_DIGITS, 354 &::getBooleanCppuType(), 0, 0 }, 355 { MAP_CHAR_LEN(UPN_IS_USE_DICTIONARY_LIST), WID_IS_USE_DICTIONARY_LIST, 356 &::getBooleanCppuType(), 0, 0 }, 357 { MAP_CHAR_LEN(UPN_IS_WRAP_REVERSE), WID_IS_WRAP_REVERSE, 358 &::getBooleanCppuType(), 0, 0 }, 359 { 0,0,0,0,0,0 } 360 }; 361 return aLinguProps; 362 } 363 LinguProps::LinguProps() : 364 aEvtListeners (GetLinguMutex()), 365 aPropListeners (GetLinguMutex()), 366 aPropertyMap(lcl_GetLinguProps()) 367 { 368 bDisposing = sal_False; 369 } 370 371 void LinguProps::launchEvent( const PropertyChangeEvent &rEvt ) const 372 { 373 cppu::OInterfaceContainerHelper *pContainer = 374 aPropListeners.getContainer( rEvt.PropertyHandle ); 375 if (pContainer) 376 { 377 cppu::OInterfaceIteratorHelper aIt( *pContainer ); 378 while (aIt.hasMoreElements()) 379 { 380 Reference< XPropertyChangeListener > xRef( aIt.next(), UNO_QUERY ); 381 if (xRef.is()) 382 xRef->propertyChange( rEvt ); 383 } 384 } 385 } 386 387 Reference< XInterface > SAL_CALL LinguProps_CreateInstance( 388 const Reference< XMultiServiceFactory > & /*rSMgr*/ ) 389 throw(Exception) 390 { 391 Reference< XInterface > xService = (cppu::OWeakObject*)new LinguProps; 392 return xService; 393 } 394 395 Reference< XPropertySetInfo > SAL_CALL LinguProps::getPropertySetInfo() 396 throw(RuntimeException) 397 { 398 MutexGuard aGuard( GetLinguMutex() ); 399 400 static Reference< XPropertySetInfo > aRef = 401 new SfxItemPropertySetInfo( &aPropertyMap ); 402 return aRef; 403 } 404 405 void SAL_CALL LinguProps::setPropertyValue( 406 const OUString& rPropertyName, const Any& rValue ) 407 throw(UnknownPropertyException, PropertyVetoException, 408 IllegalArgumentException, WrappedTargetException, RuntimeException) 409 { 410 MutexGuard aGuard( GetLinguMutex() ); 411 412 const SfxItemPropertySimpleEntry* pCur = aPropertyMap.getByName( rPropertyName ); 413 if (pCur) 414 { 415 Any aOld( aConfig.GetProperty( pCur->nWID ) ); 416 if (aOld != rValue && aConfig.SetProperty( pCur->nWID, rValue )) 417 { 418 PropertyChangeEvent aChgEvt( (XPropertySet *) this, rPropertyName, 419 sal_False, pCur->nWID, aOld, rValue ); 420 launchEvent( aChgEvt ); 421 } 422 } 423 #ifdef LINGU_EXCEPTIONS 424 else 425 { 426 throw UnknownPropertyException(); 427 } 428 #endif 429 } 430 431 Any SAL_CALL LinguProps::getPropertyValue( const OUString& rPropertyName ) 432 throw(UnknownPropertyException, WrappedTargetException, RuntimeException) 433 { 434 MutexGuard aGuard( GetLinguMutex() ); 435 436 Any aRet; 437 438 const SfxItemPropertySimpleEntry* pCur = aPropertyMap.getByName( rPropertyName ); 439 if(pCur) 440 { 441 aRet = aConfig.GetProperty( pCur->nWID ); 442 } 443 #ifdef LINGU_EXCEPTIONS 444 else 445 { 446 throw UnknownPropertyException(); 447 } 448 #endif 449 450 return aRet; 451 } 452 453 void SAL_CALL LinguProps::addPropertyChangeListener( 454 const OUString& rPropertyName, 455 const Reference< XPropertyChangeListener >& rxListener ) 456 throw(UnknownPropertyException, WrappedTargetException, RuntimeException) 457 { 458 MutexGuard aGuard( GetLinguMutex() ); 459 460 if (!bDisposing && rxListener.is()) 461 { 462 const SfxItemPropertySimpleEntry* pCur = aPropertyMap.getByName( rPropertyName ); 463 if(pCur) 464 aPropListeners.addInterface( pCur->nWID, rxListener ); 465 #ifdef LINGU_EXCEPTIONS 466 else 467 { 468 throw UnknownPropertyException(); 469 } 470 #endif 471 } 472 } 473 474 void SAL_CALL LinguProps::removePropertyChangeListener( 475 const OUString& rPropertyName, 476 const Reference< XPropertyChangeListener >& rxListener ) 477 throw(UnknownPropertyException, WrappedTargetException, RuntimeException) 478 { 479 MutexGuard aGuard( GetLinguMutex() ); 480 481 if (!bDisposing && rxListener.is()) 482 { 483 const SfxItemPropertySimpleEntry* pCur = aPropertyMap.getByName( rPropertyName ); 484 if(pCur) 485 aPropListeners.removeInterface( pCur->nWID, rxListener ); 486 #ifdef LINGU_EXCEPTIONS 487 else 488 { 489 throw UnknownPropertyException(); 490 } 491 #endif 492 } 493 } 494 495 void SAL_CALL LinguProps::addVetoableChangeListener( 496 const OUString& /*rPropertyName*/, 497 const Reference< XVetoableChangeListener >& /*xListener*/ ) 498 throw(UnknownPropertyException, WrappedTargetException, RuntimeException) 499 { 500 // MutexGuard aGuard( GetLinguMutex() ); 501 } 502 503 void SAL_CALL LinguProps::removeVetoableChangeListener( 504 const OUString& /*rPropertyName*/, 505 const Reference< XVetoableChangeListener >& /*xListener*/ ) 506 throw(UnknownPropertyException, WrappedTargetException, RuntimeException) 507 { 508 // MutexGuard aGuard( GetLinguMutex() ); 509 } 510 511 512 void SAL_CALL LinguProps::setFastPropertyValue( sal_Int32 nHandle, const Any& rValue ) 513 throw(UnknownPropertyException, PropertyVetoException, 514 IllegalArgumentException, WrappedTargetException, RuntimeException) 515 { 516 MutexGuard aGuard( GetLinguMutex() ); 517 518 Any aOld( aConfig.GetProperty( nHandle ) ); 519 if (aOld != rValue && aConfig.SetProperty( nHandle, rValue )) 520 { 521 PropertyChangeEvent aChgEvt( (XPropertySet *) this, 522 LinguOptions::GetName( nHandle ), sal_False, nHandle, aOld, rValue ); 523 launchEvent( aChgEvt ); 524 } 525 } 526 527 528 Any SAL_CALL LinguProps::getFastPropertyValue( sal_Int32 nHandle ) 529 throw(UnknownPropertyException, WrappedTargetException, RuntimeException) 530 { 531 MutexGuard aGuard( GetLinguMutex() ); 532 533 Any aRes( aConfig.GetProperty( nHandle ) ); 534 return aRes; 535 } 536 537 538 Sequence< PropertyValue > SAL_CALL 539 LinguProps::getPropertyValues() 540 throw(RuntimeException) 541 { 542 MutexGuard aGuard( GetLinguMutex() ); 543 544 sal_Int32 nLen = aPropertyMap.getSize(); 545 Sequence< PropertyValue > aProps( nLen ); 546 PropertyValue *pProp = aProps.getArray(); 547 PropertyEntryVector_t aPropEntries = aPropertyMap.getPropertyEntries(); 548 PropertyEntryVector_t::const_iterator aIt = aPropEntries.begin(); 549 for (sal_Int32 i = 0; i < nLen; ++i, ++aIt) 550 { 551 PropertyValue &rVal = pProp[i]; 552 Any aAny( aConfig.GetProperty( aIt->nWID ) ); 553 554 rVal.Name = aIt->sName; 555 rVal.Handle = aIt->nWID; 556 rVal.Value = aAny; 557 rVal.State = PropertyState_DIRECT_VALUE ; 558 } 559 return aProps; 560 } 561 562 void SAL_CALL 563 LinguProps::setPropertyValues( const Sequence< PropertyValue >& rProps ) 564 throw(UnknownPropertyException, PropertyVetoException, 565 IllegalArgumentException, WrappedTargetException, RuntimeException) 566 { 567 MutexGuard aGuard( GetLinguMutex() ); 568 569 sal_Int32 nLen = rProps.getLength(); 570 const PropertyValue *pVal = rProps.getConstArray(); 571 for (sal_Int32 i = 0; i < nLen; ++i) 572 { 573 const PropertyValue &rVal = pVal[i]; 574 setPropertyValue( rVal.Name, rVal.Value ); 575 } 576 } 577 578 void SAL_CALL 579 LinguProps::dispose() 580 throw(RuntimeException) 581 { 582 MutexGuard aGuard( GetLinguMutex() ); 583 584 if (!bDisposing) 585 { 586 bDisposing = sal_True; 587 588 //! its too late to save the options here! 589 // (see AppExitListener for saving) 590 //aOpt.Save(); // save (possible) changes before exiting 591 592 EventObject aEvtObj( (XPropertySet *) this ); 593 aEvtListeners.disposeAndClear( aEvtObj ); 594 aPropListeners.disposeAndClear( aEvtObj ); 595 } 596 } 597 598 void SAL_CALL 599 LinguProps::addEventListener( const Reference< XEventListener >& rxListener ) 600 throw(RuntimeException) 601 { 602 MutexGuard aGuard( GetLinguMutex() ); 603 604 if (!bDisposing && rxListener.is()) 605 aEvtListeners.addInterface( rxListener ); 606 } 607 608 void SAL_CALL 609 LinguProps::removeEventListener( const Reference< XEventListener >& rxListener ) 610 throw(RuntimeException) 611 { 612 MutexGuard aGuard( GetLinguMutex() ); 613 614 if (!bDisposing && rxListener.is()) 615 aEvtListeners.removeInterface( rxListener ); 616 } 617 618 619 /////////////////////////////////////////////////////////////////////////// 620 // Service specific part 621 // 622 623 // XServiceInfo 624 OUString SAL_CALL LinguProps::getImplementationName() 625 throw(RuntimeException) 626 { 627 MutexGuard aGuard( GetLinguMutex() ); 628 return getImplementationName_Static(); 629 } 630 631 // XServiceInfo 632 sal_Bool SAL_CALL LinguProps::supportsService( const OUString& ServiceName ) 633 throw(RuntimeException) 634 { 635 MutexGuard aGuard( GetLinguMutex() ); 636 637 uno::Sequence< OUString > aSNL = getSupportedServiceNames(); 638 const OUString * pArray = aSNL.getConstArray(); 639 for( sal_Int32 i = 0; i < aSNL.getLength(); i++ ) 640 if( pArray[i] == ServiceName ) 641 return sal_True; 642 return sal_False; 643 } 644 645 // XServiceInfo 646 uno::Sequence< OUString > SAL_CALL LinguProps::getSupportedServiceNames() 647 throw(RuntimeException) 648 { 649 MutexGuard aGuard( GetLinguMutex() ); 650 return getSupportedServiceNames_Static(); 651 } 652 653 // ORegistryServiceManager_Static 654 uno::Sequence< OUString > LinguProps::getSupportedServiceNames_Static() 655 throw() 656 { 657 MutexGuard aGuard( GetLinguMutex() ); 658 659 uno::Sequence< OUString > aSNS( 1 ); // auch mehr als 1 Service moeglich 660 aSNS.getArray()[0] = A2OU( SN_LINGU_PROPERTIES ); 661 return aSNS; 662 } 663 664 void * SAL_CALL LinguProps_getFactory( const sal_Char * pImplName, 665 XMultiServiceFactory *pServiceManager, void * ) 666 { 667 void * pRet = 0; 668 if ( !LinguProps::getImplementationName_Static().compareToAscii( pImplName ) ) 669 { 670 Reference< XSingleServiceFactory > xFactory = 671 cppu::createOneInstanceFactory( 672 pServiceManager, 673 LinguProps::getImplementationName_Static(), 674 LinguProps_CreateInstance, 675 LinguProps::getSupportedServiceNames_Static()); 676 // acquire, because we return an interface pointer instead of a reference 677 xFactory->acquire(); 678 pRet = xFactory.get(); 679 } 680 return pRet; 681 } 682 683 /////////////////////////////////////////////////////////////////////////// 684 685