linguistic/source/iprcache.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 <iprcache.hxx>
  22 #include <linguistic/misc.hxx>
  23
  24 #include <com/sun/star/linguistic2/DictionaryListEventFlags.hpp>
  25 #include <osl/mutex.hxx>
  26 #include <unotools/linguprops.hxx>
  27
  28 using namespace osl;
  29 using namespace com::sun::star;
  30 using namespace com::sun::star::beans;
  31 using namespace com::sun::star::lang;
  32 using namespace com::sun::star::uno;
  33 using namespace com::sun::star::linguistic2;
  34
  35
  36 namespace linguistic
  37 {
  38
  39
  40 #define NUM_FLUSH_PROPS     6
  41
  42 static const struct
  43 {
  44     const char *pPropName;
  45     sal_Int32       nPropHdl;
  46 } aFlushProperties[ NUM_FLUSH_PROPS ] =
  47 {
  48     { UPN_IS_USE_DICTIONARY_LIST,         UPH_IS_USE_DICTIONARY_LIST },
  49     { UPN_IS_IGNORE_CONTROL_CHARACTERS,   UPH_IS_IGNORE_CONTROL_CHARACTERS },
  50     { UPN_IS_SPELL_UPPER_CASE,            UPH_IS_SPELL_UPPER_CASE },
  51     { UPN_IS_SPELL_WITH_DIGITS,           UPH_IS_SPELL_WITH_DIGITS },
  52     { UPN_IS_SPELL_CAPITALIZATION,        UPH_IS_SPELL_CAPITALIZATION }
  53 };
  54
  55
  56 static void lcl_AddAsPropertyChangeListener(
  57         const Reference< XPropertyChangeListener >& xListener,
  58         Reference< XLinguProperties > const &rPropSet )
  59 {
  60     if (xListener.is() && rPropSet.is())
  61     {
  62         for (auto& aFlushPropertie : aFlushProperties)
  63         {
  64             rPropSet->addPropertyChangeListener(
  65                     OUString::createFromAscii(aFlushPropertie.pPropName), xListener );
  66         }
  67     }
  68 }
  69
  70
  71 static void lcl_RemoveAsPropertyChangeListener(
  72         const Reference< XPropertyChangeListener >& xListener,
  73         Reference< XLinguProperties > const &rPropSet )
  74 {
  75     if (xListener.is() && rPropSet.is())
  76     {
  77         for (auto& aFlushPropertie : aFlushProperties)
  78         {
  79             rPropSet->removePropertyChangeListener(
  80                     OUString::createFromAscii(aFlushPropertie.pPropName), xListener );
  81         }
  82     }
  83 }
  84
  85
  86 static bool lcl_IsFlushProperty( sal_Int32 nHandle )
  87 {
  88     int i;
  89     for (i = 0;  i < NUM_FLUSH_PROPS;  ++i)
  90     {
  91         if (nHandle == aFlushProperties[i].nPropHdl)
  92             break;
  93     }
  94     return i < NUM_FLUSH_PROPS;
  95 }
  96
  97
  98 void FlushListener::SetDicList( Reference<XSearchableDictionaryList> const &rDL )
  99 {
 100     MutexGuard  aGuard( GetLinguMutex() );
 101
 102     if (xDicList != rDL)
 103     {
 104         if (xDicList.is())
 105             xDicList->removeDictionaryListEventListener( this );
 106
 107         xDicList = rDL;
 108         if (xDicList.is())
 109             xDicList->addDictionaryListEventListener( this, false );
 110     }
 111 }
 112
 113
 114 void FlushListener::SetPropSet( Reference< XLinguProperties > const &rPS )
 115 {
 116     MutexGuard  aGuard( GetLinguMutex() );
 117
 118     if (xPropSet != rPS)
 119     {
 120         if (xPropSet.is())
 121             lcl_RemoveAsPropertyChangeListener( this, xPropSet );
 122
 123         xPropSet = rPS;
 124         if (xPropSet.is())
 125             lcl_AddAsPropertyChangeListener( this, xPropSet );
 126     }
 127 }
 128
 129
 130 void SAL_CALL FlushListener::disposing( const EventObject& rSource )
 131 {
 132     MutexGuard  aGuard( GetLinguMutex() );
 133
 134     if (xDicList.is()  &&  rSource.Source == xDicList)
 135     {
 136         xDicList->removeDictionaryListEventListener( this );
 137         xDicList = nullptr;    //! release reference
 138     }
 139     if (xPropSet.is()  &&  rSource.Source == xPropSet)
 140     {
 141         lcl_RemoveAsPropertyChangeListener( this, xPropSet );
 142         xPropSet = nullptr;    //! release reference
 143     }
 144 }
 145
 146
 147 void SAL_CALL FlushListener::processDictionaryListEvent(
 148             const DictionaryListEvent& rDicListEvent )
 149 {
 150     MutexGuard  aGuard( GetLinguMutex() );
 151
 152     if (rDicListEvent.Source == xDicList)
 153     {
 154         sal_Int16 nEvt = rDicListEvent.nCondensedEvent;
 155         sal_Int16 const nFlushFlags =
 156                 DictionaryListEventFlags::ADD_NEG_ENTRY     |
 157                 DictionaryListEventFlags::DEL_POS_ENTRY     |
 158                 DictionaryListEventFlags::ACTIVATE_NEG_DIC  |
 159                 DictionaryListEventFlags::DEACTIVATE_POS_DIC;
 160         bool bFlush = 0 != (nEvt & nFlushFlags);
 161
 162         if (bFlush)
 163             mrSpellCache.Flush();
 164     }
 165 }
 166
 167
 168 void SAL_CALL FlushListener::propertyChange(
 169             const PropertyChangeEvent& rEvt )
 170 {
 171     MutexGuard  aGuard( GetLinguMutex() );
 172
 173     if (rEvt.Source == xPropSet)
 174     {
 175         bool bFlush = lcl_IsFlushProperty( rEvt.PropertyHandle );
 176
 177         if (bFlush)
 178             mrSpellCache.Flush();
 179     }
 180 }
 181
 182
 183 SpellCache::SpellCache()
 184 {
 185     mxFlushLstnr = new FlushListener( *this );
 186     Reference<XSearchableDictionaryList> aDictionaryList(GetDictionaryList());
 187     mxFlushLstnr->SetDicList( aDictionaryList ); //! after reference is established
 188     Reference<XLinguProperties> aPropertySet(GetLinguProperties());
 189     mxFlushLstnr->SetPropSet( aPropertySet );    //! after reference is established
 190 }
 191
 192 SpellCache::~SpellCache()
 193 {
 194     Reference<XSearchableDictionaryList>  aEmptyList;
 195     Reference<XLinguProperties>     aEmptySet;
 196     mxFlushLstnr->SetDicList( aEmptyList );
 197     mxFlushLstnr->SetPropSet( aEmptySet );
 198 }
 199
 200 void SpellCache::Flush()
 201 {
 202     MutexGuard  aGuard( GetLinguMutex() );
 203     // clear word list
 204     LangWordList_t aEmpty;
 205     aWordLists.swap( aEmpty );
 206 }
 207
 208 bool SpellCache::CheckWord( const OUString& rWord, LanguageType nLang )
 209 {
 210     MutexGuard  aGuard( GetLinguMutex() );
 211     WordList_t &rList = aWordLists[ nLang ];
 212     const WordList_t::const_iterator aIt = rList.find( rWord );
 213     return aIt != rList.end();
 214 }
 215
 216 void SpellCache::AddWord( const OUString& rWord, LanguageType nLang )
 217 {
 218     MutexGuard  aGuard( GetLinguMutex() );
 219     WordList_t & rList = aWordLists[ nLang ];
 220     // occasional clean-up...
 221     if (rList.size() > 500)
 222         rList.clear();
 223     rList.insert( rWord );
 224 }
 225
 226 }   // namespace linguistic
 227
 228 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */