linguistic/source/lngopt.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
  21 #include <sal/macros.h>
  22 #include "lngopt.hxx"
  23 #include <linguistic/misc.hxx>
  24 #include <o3tl/safeint.hxx>
  25 #include <tools/debug.hxx>
  26 #include <unotools/lingucfg.hxx>
  27
  28 #include <comphelper/sequence.hxx>
  29 #include <cppuhelper/factory.hxx>
  30 #include <cppuhelper/supportsservice.hxx>
  31 #include <cppuhelper/weak.hxx>
  32 #include <com/sun/star/lang/Locale.hpp>
  33
  34 using namespace osl;
  35 using namespace com::sun::star;
  36 using namespace com::sun::star::beans;
  37 using namespace com::sun::star::lang;
  38 using namespace com::sun::star::uno;
  39 using namespace com::sun::star::linguistic2;
  40 using namespace linguistic;
  41
  42 using namespace com::sun::star::registry;
  43
  44
  45 // static member initialization
  46 SvtLinguOptions *   LinguOptions::pData = nullptr;
  47 oslInterlockedCount LinguOptions::nRefCount;
  48
  49
  50 LinguOptions::LinguOptions()
  51 {
  52     if (!pData)
  53     {
  54         pData = new SvtLinguOptions;
  55         SvtLinguConfig aLinguCfg;
  56         aLinguCfg.GetOptions( *pData );
  57     }
  58
  59     osl_atomic_increment( &nRefCount );
  60 }
  61
  62
  63 LinguOptions::LinguOptions(const LinguOptions & /*rOpt*/)
  64 {
  65     DBG_ASSERT( pData, "lng : data missing" );
  66     osl_atomic_increment( &nRefCount );
  67 }
  68
  69
  70 LinguOptions::~LinguOptions()
  71 {
  72     MutexGuard  aGuard( GetLinguMutex() );
  73
  74     if ( osl_atomic_decrement( &nRefCount ) == 0 )
  75     {
  76         delete pData;   pData  = nullptr;
  77     }
  78 }
  79
  80 namespace {
  81
  82 struct WID_Name
  83 {
  84     sal_Int32        nWID;
  85     OUString         aPropertyName;
  86 };
  87
  88 }
  89
  90 //! order of entries is import (see LinguOptions::GetName)
  91 //! since the WID is used as index in this table!
  92 WID_Name const aWID_Name[] =
  93 {
  94     { 0,                                  "" },
  95     { UPH_IS_USE_DICTIONARY_LIST,         UPN_IS_USE_DICTIONARY_LIST },
  96     { UPH_IS_IGNORE_CONTROL_CHARACTERS,   UPN_IS_IGNORE_CONTROL_CHARACTERS },
  97     { UPH_IS_SPELL_UPPER_CASE,            UPN_IS_SPELL_UPPER_CASE },
  98     { UPH_IS_SPELL_WITH_DIGITS,           UPN_IS_SPELL_WITH_DIGITS },
  99     { UPH_HYPH_MIN_LEADING,               UPN_HYPH_MIN_LEADING },
 100     { UPH_HYPH_MIN_TRAILING,              UPN_HYPH_MIN_TRAILING },
 101     { UPH_HYPH_MIN_WORD_LENGTH,           UPN_HYPH_MIN_WORD_LENGTH },
 102     { UPH_DEFAULT_LOCALE,                 UPN_DEFAULT_LOCALE },
 103     { UPH_IS_SPELL_AUTO,                  UPN_IS_SPELL_AUTO },
 104     { 0,                                  "" },
 105     { 0,                                  "" },
 106     { UPH_IS_SPELL_SPECIAL,               UPN_IS_SPELL_SPECIAL },
 107     { UPH_IS_HYPH_AUTO,                   UPN_IS_HYPH_AUTO },
 108     { UPH_IS_HYPH_SPECIAL,                UPN_IS_HYPH_SPECIAL },
 109     { UPH_IS_WRAP_REVERSE,                UPN_IS_WRAP_REVERSE },
 110     { 0,                                  "" },
 111     { 0,                                  "" },
 112     { 0,                                  "" },
 113     { 0,                                  "" },
 114     { UPH_DEFAULT_LANGUAGE,               UPN_DEFAULT_LANGUAGE },
 115     { UPH_DEFAULT_LOCALE_CJK,             UPN_DEFAULT_LOCALE_CJK },
 116     { UPH_DEFAULT_LOCALE_CTL,             UPN_DEFAULT_LOCALE_CTL },
 117     { UPH_IS_SPELL_CLOSED_COMPOUND,       UPN_IS_SPELL_CLOSED_COMPOUND },
 118     { UPH_IS_SPELL_HYPHENATED_COMPOUND,   UPN_IS_SPELL_HYPHENATED_COMPOUND }
 119 };
 120
 121
 122 OUString LinguOptions::GetName( sal_Int32 nWID )
 123 {
 124     MutexGuard  aGuard( GetLinguMutex() );
 125
 126     OUString aRes;
 127
 128     if (0 <= nWID && o3tl::make_unsigned(nWID) < SAL_N_ELEMENTS(aWID_Name)
 129         && aWID_Name[ nWID ].nWID == nWID)
 130         aRes = aWID_Name[nWID].aPropertyName;
 131     else
 132         OSL_FAIL("lng : unknown WID");
 133
 134     return aRes;
 135 }
 136
 137
 138 //! map must be sorted by first entry in alphabetical increasing order.
 139 static std::span<const SfxItemPropertyMapEntry> lcl_GetLinguProps()
 140 {
 141     static const SfxItemPropertyMapEntry aLinguProps[] =
 142     {
 143         { UPN_DEFAULT_LANGUAGE,           UPH_DEFAULT_LANGUAGE,
 144                 ::cppu::UnoType<sal_Int16>::get(),    0, 0 },
 145         { UPN_DEFAULT_LOCALE,             UPH_DEFAULT_LOCALE,
 146                 ::cppu::UnoType<Locale>::get(),       0, 0 },
 147         { UPN_DEFAULT_LOCALE_CJK,         UPH_DEFAULT_LOCALE_CJK,
 148                 ::cppu::UnoType<Locale>::get(),       0, 0 },
 149         { UPN_DEFAULT_LOCALE_CTL,         UPH_DEFAULT_LOCALE_CTL,
 150                 ::cppu::UnoType<Locale>::get(),       0, 0 },
 151         { UPN_HYPH_MIN_LEADING,           UPH_HYPH_MIN_LEADING,
 152                 ::cppu::UnoType<sal_Int16>::get(),    0, 0 },
 153         { UPN_HYPH_MIN_TRAILING,          UPH_HYPH_MIN_TRAILING,
 154                 ::cppu::UnoType<sal_Int16>::get(),    0, 0 },
 155         { UPN_HYPH_MIN_WORD_LENGTH,       UPH_HYPH_MIN_WORD_LENGTH,
 156                 ::cppu::UnoType<sal_Int16>::get(),    0, 0 },
 157         { UPN_IS_HYPH_AUTO,               UPH_IS_HYPH_AUTO,
 158                 cppu::UnoType<bool>::get(),            0, 0 },
 159         { UPN_IS_HYPH_SPECIAL,            UPH_IS_HYPH_SPECIAL,
 160                 cppu::UnoType<bool>::get(),            0, 0 },
 161         { UPN_IS_IGNORE_CONTROL_CHARACTERS,   UPH_IS_IGNORE_CONTROL_CHARACTERS,
 162                 cppu::UnoType<bool>::get(),            0, 0 },
 163         { UPN_IS_SPELL_AUTO,              UPH_IS_SPELL_AUTO,
 164                 cppu::UnoType<bool>::get(),            0, 0 },
 165         { UPN_IS_SPELL_CLOSED_COMPOUND,   UPH_IS_SPELL_CLOSED_COMPOUND,
 166                 cppu::UnoType<bool>::get(),            0, 0 },
 167         { UPN_IS_SPELL_HYPHENATED_COMPOUND,   UPH_IS_SPELL_HYPHENATED_COMPOUND,
 168                 cppu::UnoType<bool>::get(),            0, 0 },
 169         { UPN_IS_SPELL_SPECIAL,           UPH_IS_SPELL_SPECIAL,
 170                 cppu::UnoType<bool>::get(),            0, 0 },
 171         { UPN_IS_SPELL_UPPER_CASE,        UPH_IS_SPELL_UPPER_CASE,
 172                 cppu::UnoType<bool>::get(),            0, 0 },
 173         { UPN_IS_SPELL_WITH_DIGITS,       UPH_IS_SPELL_WITH_DIGITS,
 174                 cppu::UnoType<bool>::get(),            0, 0 },
 175         { UPN_IS_USE_DICTIONARY_LIST,     UPH_IS_USE_DICTIONARY_LIST,
 176                 cppu::UnoType<bool>::get(),            0, 0 },
 177         { UPN_IS_WRAP_REVERSE,            UPH_IS_WRAP_REVERSE,
 178                 cppu::UnoType<bool>::get(),            0, 0 },
 179     };
 180     return aLinguProps;
 181 }
 182 LinguProps::LinguProps() :
 183     aEvtListeners   (GetLinguMutex()),
 184     aPropListeners  (GetLinguMutex()),
 185     aPropertyMap(lcl_GetLinguProps())
 186 {
 187     bDisposing = false;
 188 }
 189
 190 void LinguProps::launchEvent( const PropertyChangeEvent &rEvt ) const
 191 {
 192     comphelper::OInterfaceContainerHelper3<XPropertyChangeListener> *pContainer =
 193             aPropListeners.getContainer( rEvt.PropertyHandle );
 194     if (pContainer)
 195         pContainer->notifyEach( &XPropertyChangeListener::propertyChange, rEvt );
 196 }
 197
 198 Reference< XPropertySetInfo > SAL_CALL LinguProps::getPropertySetInfo()
 199 {
 200     MutexGuard  aGuard( GetLinguMutex() );
 201
 202     static Reference< XPropertySetInfo > aRef =
 203             new SfxItemPropertySetInfo( aPropertyMap );
 204     return aRef;
 205 }
 206
 207 void SAL_CALL LinguProps::setPropertyValue(
 208             const OUString& rPropertyName, const Any& rValue )
 209 {
 210     MutexGuard  aGuard( GetLinguMutex() );
 211
 212     const SfxItemPropertyMapEntry* pCur = aPropertyMap.getByName( rPropertyName );
 213     if (pCur)
 214     {
 215         Any aOld( aConfig.GetProperty( pCur->nWID ) );
 216         if (aOld != rValue && aConfig.SetProperty( pCur->nWID, rValue ))
 217         {
 218             PropertyChangeEvent aChgEvt( static_cast<XPropertySet *>(this), rPropertyName,
 219                     false, pCur->nWID, aOld, rValue );
 220             launchEvent( aChgEvt );
 221         }
 222     }
 223 }
 224
 225 Any SAL_CALL LinguProps::getPropertyValue( const OUString& rPropertyName )
 226 {
 227     MutexGuard  aGuard( GetLinguMutex() );
 228
 229     Any aRet;
 230
 231     const SfxItemPropertyMapEntry* pCur = aPropertyMap.getByName( rPropertyName );
 232     if(pCur)
 233     {
 234         aRet = aConfig.GetProperty( pCur->nWID );
 235     }
 236
 237     return aRet;
 238 }
 239
 240 void SAL_CALL LinguProps::addPropertyChangeListener(
 241             const OUString& rPropertyName,
 242             const Reference< XPropertyChangeListener >& rxListener )
 243 {
 244     MutexGuard  aGuard( GetLinguMutex() );
 245
 246     if (!bDisposing && rxListener.is())
 247     {
 248         const SfxItemPropertyMapEntry* pCur = aPropertyMap.getByName( rPropertyName );
 249         if(pCur)
 250             aPropListeners.addInterface( pCur->nWID, rxListener );
 251     }
 252 }
 253
 254 void SAL_CALL LinguProps::removePropertyChangeListener(
 255             const OUString& rPropertyName,
 256             const Reference< XPropertyChangeListener >& rxListener )
 257 {
 258     MutexGuard  aGuard( GetLinguMutex() );
 259
 260     if (!bDisposing && rxListener.is())
 261     {
 262         const SfxItemPropertyMapEntry* pCur = aPropertyMap.getByName( rPropertyName );
 263         if(pCur)
 264             aPropListeners.removeInterface( pCur->nWID, rxListener );
 265     }
 266 }
 267
 268 void SAL_CALL LinguProps::addVetoableChangeListener(
 269             const OUString& /*rPropertyName*/,
 270             const Reference< XVetoableChangeListener >& /*xListener*/ )
 271 {
 272 }
 273
 274 void SAL_CALL LinguProps::removeVetoableChangeListener(
 275             const OUString& /*rPropertyName*/,
 276             const Reference< XVetoableChangeListener >& /*xListener*/ )
 277 {
 278 }
 279
 280
 281 void SAL_CALL LinguProps::setFastPropertyValue( sal_Int32 nHandle, const Any& rValue )
 282 {
 283     MutexGuard  aGuard( GetLinguMutex() );
 284
 285     Any aOld( aConfig.GetProperty( nHandle ) );
 286     if (aOld != rValue && aConfig.SetProperty( nHandle, rValue ))
 287     {
 288         PropertyChangeEvent aChgEvt( static_cast<XPropertySet *>(this),
 289                 LinguOptions::GetName( nHandle ), false, nHandle, aOld, rValue );
 290         launchEvent( aChgEvt );
 291     }
 292 }
 293
 294
 295 Any SAL_CALL LinguProps::getFastPropertyValue( sal_Int32 nHandle )
 296 {
 297     MutexGuard  aGuard( GetLinguMutex() );
 298
 299     Any aRes( aConfig.GetProperty( nHandle ) );
 300     return aRes;
 301 }
 302
 303
 304 Sequence< PropertyValue > SAL_CALL
 305     LinguProps::getPropertyValues()
 306 {
 307     MutexGuard  aGuard( GetLinguMutex() );
 308
 309     std::vector<PropertyValue> aProps;
 310     aProps.reserve(aPropertyMap.getPropertyEntries().size());
 311     for(auto pEntry : aPropertyMap.getPropertyEntries())
 312         aProps.push_back(PropertyValue(pEntry->aName, pEntry->nWID,
 313                                  aConfig.GetProperty(pEntry->nWID),
 314                                  css::beans::PropertyState_DIRECT_VALUE));
 315     return comphelper::containerToSequence(aProps);
 316 }
 317
 318 void SAL_CALL
 319     LinguProps::setPropertyValues( const Sequence< PropertyValue >& rProps )
 320 {
 321     MutexGuard  aGuard( GetLinguMutex() );
 322
 323     for (const PropertyValue &rVal : rProps)
 324     {
 325         setPropertyValue( rVal.Name, rVal.Value );
 326     }
 327 }
 328
 329 void SAL_CALL
 330     LinguProps::dispose()
 331 {
 332     MutexGuard  aGuard( GetLinguMutex() );
 333
 334     if (!bDisposing)
 335     {
 336         bDisposing = true;
 337
 338         //! it's too late to save the options here!
 339         // (see AppExitListener for saving)
 340         //aOpt.Save();  // save (possible) changes before exiting
 341
 342         EventObject aEvtObj( static_cast<XPropertySet *>(this) );
 343         aEvtListeners.disposeAndClear( aEvtObj );
 344         aPropListeners.disposeAndClear( aEvtObj );
 345     }
 346 }
 347
 348 void SAL_CALL
 349     LinguProps::addEventListener( const Reference< XEventListener >& rxListener )
 350 {
 351     MutexGuard  aGuard( GetLinguMutex() );
 352
 353     if (!bDisposing && rxListener.is())
 354         aEvtListeners.addInterface( rxListener );
 355 }
 356
 357 void SAL_CALL
 358     LinguProps::removeEventListener( const Reference< XEventListener >& rxListener )
 359 {
 360     MutexGuard  aGuard( GetLinguMutex() );
 361
 362     if (!bDisposing && rxListener.is())
 363         aEvtListeners.removeInterface( rxListener );
 364 }
 365
 366
 367 // Service specific part
 368
 369 // XServiceInfo
 370 OUString SAL_CALL LinguProps::getImplementationName()
 371 {
 372     return "com.sun.star.lingu2.LinguProps";
 373 }
 374
 375 // XServiceInfo
 376 sal_Bool SAL_CALL LinguProps::supportsService( const OUString& ServiceName )
 377 {
 378     return cppu::supportsService(this, ServiceName);
 379 }
 380
 381 // XServiceInfo
 382 uno::Sequence< OUString > SAL_CALL LinguProps::getSupportedServiceNames()
 383 {
 384     return { "com.sun.star.linguistic2.LinguProperties" };
 385 }
 386
 387 bool LinguProps::getPropertyBool(const OUString& aPropertyName)
 388 {
 389    uno::Any any = getPropertyValue(aPropertyName);
 390    bool b = false;
 391    any >>= b;
 392    return b;
 393 }
 394
 395 sal_Int16 LinguProps::getPropertyInt16(const OUString& aPropertyName)
 396 {
 397    uno::Any any = getPropertyValue(aPropertyName);
 398    sal_Int16 b = 0;
 399    any >>= b;
 400    return b;
 401 }
 402
 403 Locale LinguProps::getPropertyLocale(const OUString& aPropertyName)
 404 {
 405    uno::Any any = getPropertyValue(aPropertyName);
 406    css::lang::Locale b;
 407    any >>= b;
 408    return b;
 409 }
 410
 411 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 412 linguistic_LinguProps_get_implementation(
 413     css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const&)
 414 {
 415     return cppu::acquire(new LinguProps());
 416 }
 417
 418
 419 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */