lingucomponent/source/thesaurus/libnth/ntprophelp.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: ntprophelp.cxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_lingucomponent.hxx"
  33
  34 #include <linguistic/misc.hxx>
  35
  36 #include "ntprophelp.hxx"
  37 #include <linguistic/lngprops.hxx>
  38 #include <tools/debug.hxx>
  39
  40 #include <com/sun/star/linguistic2/LinguServiceEvent.hpp>
  41 #include <com/sun/star/linguistic2/LinguServiceEventFlags.hpp>
  42 #include <com/sun/star/linguistic2/XLinguServiceEventListener.hpp>
  43 #include <com/sun/star/beans/XPropertySet.hpp>
  44 #include <osl/mutex.hxx>
  45
  46 //using namespace utl;
  47 using namespace osl;
  48 using namespace rtl;
  49 using namespace com::sun::star;
  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
  57 #define A2OU(x) ::rtl::OUString::createFromAscii( x )
  58
  59 ///////////////////////////////////////////////////////////////////////////
  60
  61
  62 PropertyChgHelper::PropertyChgHelper(
  63                 const Reference< XInterface > & rxSource,
  64                 Reference< XPropertySet > &rxPropSet,
  65                 const char *pPropNames[], USHORT nPropCount ) :
  66     aPropNames          (nPropCount),
  67     xMyEvtObj           (rxSource),
  68     aLngSvcEvtListeners (GetLinguMutex()),
  69     xPropSet            (rxPropSet)
  70 {
  71         OUString *pName = aPropNames.getArray();
  72         for (INT32 i = 0;  i < nPropCount;  ++i)
  73         {
  74                 pName[i] = A2OU( pPropNames[i] );
  75         }
  76 }
  77
  78
  79 /*PropertyChgHelper::PropertyChgHelper( const PropertyChgHelper &rHelper ) :
  80         aLngSvcEvtListeners     (GetLinguMutex())
  81 {
  82         xPropSet        = rHelper.xPropSet;
  83         aPropNames      = rHelper.aPropNames;
  84         AddAsPropListener();
  85
  86         xMyEvtObj       = rHelper.xMyEvtObj;
  87 } */
  88
  89
  90 PropertyChgHelper::~PropertyChgHelper()
  91 {
  92 }
  93
  94
  95 void PropertyChgHelper::AddAsPropListener()
  96 {
  97         if (xPropSet.is())
  98         {
  99                 INT32 nLen = aPropNames.getLength();
 100                 const OUString *pPropName = aPropNames.getConstArray();
 101                 for (INT32 i = 0;  i < nLen;  ++i)
 102                 {
 103                         if (pPropName[i].getLength())
 104                                 xPropSet->addPropertyChangeListener( pPropName[i], this );
 105                 }
 106         }
 107 }
 108
 109 void PropertyChgHelper::RemoveAsPropListener()
 110 {
 111         if (xPropSet.is())
 112         {
 113                 INT32 nLen = aPropNames.getLength();
 114                 const OUString *pPropName = aPropNames.getConstArray();
 115                 for (INT32 i = 0;  i < nLen;  ++i)
 116                 {
 117                         if (pPropName[i].getLength())
 118                                 xPropSet->removePropertyChangeListener( pPropName[i], this );
 119                 }
 120         }
 121 }
 122
 123
 124 void PropertyChgHelper::LaunchEvent( const LinguServiceEvent &rEvt )
 125 {
 126         cppu::OInterfaceIteratorHelper aIt( aLngSvcEvtListeners );
 127         while (aIt.hasMoreElements())
 128         {
 129                 Reference< XLinguServiceEventListener > xRef( aIt.next(), UNO_QUERY );
 130                 if (xRef.is())
 131                         xRef->processLinguServiceEvent( rEvt );
 132         }
 133 }
 134
 135
 136 void SAL_CALL PropertyChgHelper::disposing( const EventObject& rSource )
 137                 throw(RuntimeException)
 138 {
 139         MutexGuard      aGuard( GetLinguMutex() );
 140         if (rSource.Source == xPropSet)
 141         {
 142                 RemoveAsPropListener();
 143                 xPropSet = NULL;
 144                 aPropNames.realloc( 0 );
 145         }
 146 }
 147
 148
 149 sal_Bool SAL_CALL
 150         PropertyChgHelper::addLinguServiceEventListener(
 151                         const Reference< XLinguServiceEventListener >& rxListener )
 152                 throw(RuntimeException)
 153 {
 154         MutexGuard      aGuard( GetLinguMutex() );
 155
 156         BOOL bRes = FALSE;
 157         if (rxListener.is())
 158         {
 159                 INT32   nCount = aLngSvcEvtListeners.getLength();
 160                 bRes = aLngSvcEvtListeners.addInterface( rxListener ) != nCount;
 161         }
 162         return bRes;
 163 }
 164
 165
 166 sal_Bool SAL_CALL
 167         PropertyChgHelper::removeLinguServiceEventListener(
 168                         const Reference< XLinguServiceEventListener >& rxListener )
 169                 throw(RuntimeException)
 170 {
 171         MutexGuard      aGuard( GetLinguMutex() );
 172
 173         BOOL bRes = FALSE;
 174         if (rxListener.is())
 175         {
 176                 INT32   nCount = aLngSvcEvtListeners.getLength();
 177                 bRes = aLngSvcEvtListeners.removeInterface( rxListener ) != nCount;
 178         }
 179         return bRes;
 180 }
 181
 182 ///////////////////////////////////////////////////////////////////////////
 183
 184 static const char *aSP[] =
 185 {
 186         UPN_IS_GERMAN_PRE_REFORM,
 187         UPN_IS_IGNORE_CONTROL_CHARACTERS,
 188         UPN_IS_USE_DICTIONARY_LIST,
 189 };
 190
 191
 192 PropertyHelper_Thes::PropertyHelper_Thes(
 193                 const Reference< XInterface > & rxSource,
 194                 Reference< XPropertySet > &rxPropSet ) :
 195         PropertyChgHelper       ( rxSource, rxPropSet, aSP, sizeof(aSP) / sizeof(aSP[0]) )
 196 {
 197         SetDefault();
 198         INT32 nLen = GetPropNames().getLength();
 199         if (rxPropSet.is() && nLen)
 200         {
 201                 const OUString *pPropName = GetPropNames().getConstArray();
 202                 for (INT32 i = 0;  i < nLen;  ++i)
 203                 {
 204                         BOOL *pbVal             = NULL,
 205                                  *pbResVal      = NULL;
 206
 207                         if (A2OU( UPN_IS_GERMAN_PRE_REFORM ) == pPropName[i])
 208                         {
 209                                 pbVal    = &bIsGermanPreReform;
 210                                 pbResVal = &bResIsGermanPreReform;
 211                         }
 212                         else if (A2OU( UPN_IS_IGNORE_CONTROL_CHARACTERS ) == pPropName[i])
 213                         {
 214                                 pbVal    = &bIsIgnoreControlCharacters;
 215                                 pbResVal = &bResIsIgnoreControlCharacters;
 216                         }
 217                         else if (A2OU( UPN_IS_USE_DICTIONARY_LIST ) == pPropName[i])
 218                         {
 219                                 pbVal    = &bIsUseDictionaryList;
 220                                 pbResVal = &bResIsUseDictionaryList;
 221                         }
 222                         if (pbVal && pbResVal)
 223                         {
 224                                 rxPropSet->getPropertyValue( pPropName[i] ) >>= *pbVal;
 225                                 *pbResVal = *pbVal;
 226                         }
 227                 }
 228         }
 229 }
 230
 231
 232 PropertyHelper_Thes::~PropertyHelper_Thes()
 233 {
 234 }
 235
 236
 237 void PropertyHelper_Thes::SetDefault()
 238 {
 239         bResIsGermanPreReform                   = bIsGermanPreReform                    = FALSE;
 240         bResIsIgnoreControlCharacters   = bIsIgnoreControlCharacters    = TRUE;
 241         bResIsUseDictionaryList                 = bIsUseDictionaryList                  = TRUE;
 242 }
 243
 244
 245 void SAL_CALL
 246         PropertyHelper_Thes::propertyChange( const PropertyChangeEvent& rEvt )
 247                 throw(RuntimeException)
 248 {
 249         MutexGuard      aGuard( GetLinguMutex() );
 250
 251         if (GetPropSet().is()  &&  rEvt.Source == GetPropSet())
 252         {
 253                 INT16 nLngSvcFlags = 0;
 254                 BOOL bSCWA = FALSE,     // SPELL_CORRECT_WORDS_AGAIN ?
 255                          bSWWA = FALSE; // SPELL_WRONG_WORDS_AGAIN ?
 256
 257                 BOOL *pbVal = NULL;
 258                 switch (rEvt.PropertyHandle)
 259                 {
 260                         case UPH_IS_IGNORE_CONTROL_CHARACTERS :
 261                         {
 262                                 pbVal = &bIsIgnoreControlCharacters;
 263                                 break;
 264                         }
 265                         case UPH_IS_GERMAN_PRE_REFORM             :
 266                         {
 267                                 pbVal = &bIsGermanPreReform;
 268                                 bSCWA = bSWWA = TRUE;
 269                                 break;
 270                         }
 271                         case UPH_IS_USE_DICTIONARY_LIST           :
 272                         {
 273                                 pbVal = &bIsUseDictionaryList;
 274                                 bSCWA = bSWWA = TRUE;
 275                                 break;
 276                         }
 277                         default:
 278                                 DBG_ERROR( "unknown property" );
 279                 }
 280                 if (pbVal)
 281                         rEvt.NewValue >>= *pbVal;
 282
 283                 if (bSCWA)
 284                         nLngSvcFlags |= LinguServiceEventFlags::SPELL_CORRECT_WORDS_AGAIN;
 285                 if (bSWWA)
 286                         nLngSvcFlags |= LinguServiceEventFlags::SPELL_WRONG_WORDS_AGAIN;
 287                 if (nLngSvcFlags)
 288                 {
 289                         LinguServiceEvent aEvt( GetEvtObj(), nLngSvcFlags );
 290                         LaunchEvent( aEvt );
 291                 }
 292         }
 293 }
 294
 295
 296 void PropertyHelper_Thes::SetTmpPropVals( const PropertyValues &rPropVals )
 297 {
 298         // set return value to default value unless there is an
 299         // explicitly supplied temporary value
 300         bResIsGermanPreReform                   = bIsGermanPreReform;
 301         bResIsIgnoreControlCharacters   = bIsIgnoreControlCharacters;
 302         bResIsUseDictionaryList                 = bIsUseDictionaryList;
 303
 304         //
 305         INT32 nLen = rPropVals.getLength();
 306         if (nLen)
 307         {
 308                 const PropertyValue *pVal = rPropVals.getConstArray();
 309                 for (INT32 i = 0;  i < nLen;  ++i)
 310                 {
 311                         BOOL *pbResVal = NULL;
 312                         switch (pVal[i].Handle)
 313                         {
 314                                 case UPH_IS_GERMAN_PRE_REFORM             : pbResVal = &bResIsGermanPreReform; break;
 315                                 case UPH_IS_IGNORE_CONTROL_CHARACTERS : pbResVal = &bResIsIgnoreControlCharacters; break;
 316                                 case UPH_IS_USE_DICTIONARY_LIST           : pbResVal = &bResIsUseDictionaryList; break;
 317                                 default:
 318                                         DBG_ERROR( "unknown property" );
 319                         }
 320                         if (pbResVal)
 321                                 pVal[i].Value >>= *pbResVal;
 322                 }
 323         }
 324 }
 325
 326 ///////////////////////////////////////////////////////////////////////////