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