linguistic/workben/sprophelp.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 "linguistic/misc.hxx"
  23
  24 #include "sprophelp.hxx"
  25 #include "linguistic/lngprops.hxx"
  26
  27 #include <com/sun/star/linguistic2/LinguServiceEvent.hpp>
  28 #include <com/sun/star/linguistic2/LinguServiceEventFlags.hpp>
  29 #include <com/sun/star/linguistic2/XLinguServiceEventListener.hpp>
  30 #include <com/sun/star/beans/XPropertySet.hpp>
  31 #include <osl/mutex.hxx>
  32
  33 using namespace osl;
  34 using namespace com::sun::star;
  35 using namespace com::sun::star::beans;
  36 using namespace com::sun::star::lang;
  37 using namespace com::sun::star::uno;
  38 using namespace com::sun::star::linguistic2;
  39 using namespace linguistic;
  40
  41
  42 PropertyChgHelper::PropertyChgHelper(
  43         const Reference< XInterface > & rxSource,
  44         Reference< XPropertySet > &rxPropSet,
  45         const char *pPropNames[], sal_uInt16 nPropCount )
  46     : aPropNames(nPropCount)
  47     , xMyEvtObj(rxSource)
  48     , aLngSvcEvtListeners(GetLinguMutex())
  49     , xPropSet(rxPropSet)
  50 {
  51     OUString *pName = aPropNames.getArray();
  52     for (sal_Int32 i = 0;  i < nPropCount;  ++i)
  53     {
  54         pName[i] = OUString::createFromAscii( pPropNames[i] );
  55     }
  56 }
  57
  58
  59 PropertyChgHelper::PropertyChgHelper( const PropertyChgHelper &rHelper ) :
  60     aPropNames(rHelper.aPropNames),
  61     xMyEvtObj(rHelper.xMyEvtObj),
  62     aLngSvcEvtListeners (GetLinguMutex()),
  63     xPropSet(rHelper.xPropSet)
  64 {
  65     AddAsPropListener();
  66
  67 }
  68
  69
  70 PropertyChgHelper::~PropertyChgHelper()
  71 {
  72 }
  73
  74
  75 void PropertyChgHelper::AddAsPropListener()
  76 {
  77     if (xPropSet.is())
  78     {
  79         sal_Int32 nLen = aPropNames.getLength();
  80         const OUString *pPropName = aPropNames.getConstArray();
  81         for (sal_Int32 i = 0;  i < nLen;  ++i)
  82         {
  83             if (pPropName[i].getLength())
  84                 xPropSet->addPropertyChangeListener( pPropName[i], this );
  85         }
  86     }
  87 }
  88
  89 void PropertyChgHelper::RemoveAsPropListener()
  90 {
  91     if (xPropSet.is())
  92     {
  93         sal_Int32 nLen = aPropNames.getLength();
  94         const OUString *pPropName = aPropNames.getConstArray();
  95         for (sal_Int32 i = 0;  i < nLen;  ++i)
  96         {
  97             if (pPropName[i].getLength())
  98                 xPropSet->removePropertyChangeListener( pPropName[i], this );
  99         }
 100     }
 101 }
 102
 103
 104 void PropertyChgHelper::LaunchEvent( const LinguServiceEvent &rEvt )
 105 {
 106     cppu::OInterfaceIteratorHelper aIt( aLngSvcEvtListeners );
 107     while (aIt.hasMoreElements())
 108     {
 109         Reference< XLinguServiceEventListener > xRef( aIt.next(), UNO_QUERY );
 110         if (xRef.is())
 111             xRef->processLinguServiceEvent( rEvt );
 112     }
 113 }
 114
 115
 116 void SAL_CALL PropertyChgHelper::disposing( const EventObject& rSource )
 117         throw(RuntimeException)
 118 {
 119     MutexGuard  aGuard( GetLinguMutex() );
 120     if (rSource.Source == xPropSet)
 121     {
 122         RemoveAsPropListener();
 123         xPropSet = NULL;
 124         aPropNames.realloc( 0 );
 125     }
 126 }
 127
 128
 129 sal_Bool SAL_CALL
 130     PropertyChgHelper::addLinguServiceEventListener(
 131             const Reference< XLinguServiceEventListener >& rxListener )
 132         throw(RuntimeException)
 133 {
 134     MutexGuard  aGuard( GetLinguMutex() );
 135
 136     sal_Bool bRes = sal_False;
 137     if (rxListener.is())
 138     {
 139         sal_Int32   nCount = aLngSvcEvtListeners.getLength();
 140         bRes = aLngSvcEvtListeners.addInterface( rxListener ) != nCount;
 141     }
 142     return bRes;
 143 }
 144
 145
 146 sal_Bool SAL_CALL
 147     PropertyChgHelper::removeLinguServiceEventListener(
 148             const Reference< XLinguServiceEventListener >& rxListener )
 149         throw(RuntimeException)
 150 {
 151     MutexGuard  aGuard( GetLinguMutex() );
 152
 153     sal_Bool bRes = sal_False;
 154     if (rxListener.is())
 155     {
 156         sal_Int32   nCount = aLngSvcEvtListeners.getLength();
 157         bRes = aLngSvcEvtListeners.removeInterface( rxListener ) != nCount;
 158     }
 159     return bRes;
 160 }
 161
 162
 163 static const char *aSP[] =
 164 {
 165     UPN_IS_GERMAN_PRE_REFORM,
 166     UPN_IS_IGNORE_CONTROL_CHARACTERS,
 167     UPN_IS_USE_DICTIONARY_LIST,
 168     UPN_IS_SPELL_UPPER_CASE,
 169     UPN_IS_SPELL_WITH_DIGITS,
 170     UPN_IS_SPELL_CAPITALIZATION,
 171     UPN_IS_SPELL_CLOSED_COMPOUND,
 172     UPN_IS_SPELL_HYPHENATED_COMPOUND
 173 };
 174
 175
 176 PropertyHelper_Spell::PropertyHelper_Spell(
 177         const Reference< XInterface > & rxSource,
 178         Reference< XPropertySet > &rxPropSet ) :
 179     PropertyChgHelper   ( rxSource, rxPropSet, aSP, SAL_N_ELEMENTS(aSP) )
 180 {
 181     SetDefault();
 182     sal_Int32 nLen = GetPropNames().getLength();
 183     if (rxPropSet.is() && nLen)
 184     {
 185         const OUString *pPropName = GetPropNames().getConstArray();
 186         for (sal_Int32 i = 0;  i < nLen;  ++i)
 187         {
 188             sal_Bool *pbVal     = NULL,
 189                  *pbResVal  = NULL;
 190
 191             if (OUString( UPN_IS_GERMAN_PRE_REFORM ) == pPropName[i])
 192             {
 193                 pbVal    = &bIsGermanPreReform;
 194                 pbResVal = &bResIsGermanPreReform;
 195             }
 196             else if (OUString( UPN_IS_IGNORE_CONTROL_CHARACTERS ) == pPropName[i])
 197             {
 198                 pbVal    = &bIsIgnoreControlCharacters;
 199                 pbResVal = &bResIsIgnoreControlCharacters;
 200             }
 201             else if (OUString( UPN_IS_USE_DICTIONARY_LIST ) == pPropName[i])
 202             {
 203                 pbVal    = &bIsUseDictionaryList;
 204                 pbResVal = &bResIsUseDictionaryList;
 205             }
 206             else if (OUString( UPN_IS_SPELL_UPPER_CASE ) == pPropName[i])
 207             {
 208                 pbVal    = &bIsSpellUpperCase;
 209                 pbResVal = &bResIsSpellUpperCase;
 210             }
 211             else if (OUString( UPN_IS_SPELL_WITH_DIGITS ) == pPropName[i])
 212             {
 213                 pbVal    = &bIsSpellWithDigits;
 214                 pbResVal = &bResIsSpellWithDigits;
 215             }
 216             else if (OUString( UPN_IS_SPELL_CAPITALIZATION ) == pPropName[i])
 217             {
 218                 pbVal    = &bIsSpellCapitalization;
 219                 pbResVal = &bResIsSpellCapitalization;
 220             }
 221             else if (OUString( UPN_IS_SPELL_CLOSED_COMPOUND ) == pPropName[i])
 222             {
 223                 pbVal    = &bIsSpellClosedCompound;
 224                 pbResVal = &bResIsSpellClosedCompound;
 225             }
 226             else if (OUString( UPN_IS_SPELL_HYPHENATED_COMPOUND ) == pPropName[i])
 227             {
 228                 pbVal    = &bIsSpellHyphenatedCompound;
 229                 pbResVal = &bResIsSpellHyphenatedCompound;
 230             }
 231
 232             if (pbVal && pbResVal)
 233             {
 234                 rxPropSet->getPropertyValue( pPropName[i] ) >>= *pbVal;
 235                 *pbResVal = *pbVal;
 236             }
 237         }
 238     }
 239 }
 240
 241
 242 PropertyHelper_Spell::~PropertyHelper_Spell()
 243 {
 244 }
 245
 246
 247 void PropertyHelper_Spell::SetDefault()
 248 {
 249     bResIsGermanPreReform           = bIsGermanPreReform            = sal_False;
 250     bResIsIgnoreControlCharacters   = bIsIgnoreControlCharacters    = sal_True;
 251     bResIsUseDictionaryList         = bIsUseDictionaryList          = sal_True;
 252     bResIsSpellUpperCase            = bIsSpellUpperCase             = sal_False;
 253     bResIsSpellWithDigits           = bIsSpellWithDigits            = sal_False;
 254     bResIsSpellCapitalization       = bIsSpellCapitalization        = sal_True;
 255     bResIsSpellClosedCompound       = bIsSpellClosedCompound        = sal_True;
 256     bResIsSpellHyphenatedCompound   = bIsSpellHyphenatedCompound    = sal_True;
 257 }
 258
 259
 260 void SAL_CALL
 261     PropertyHelper_Spell::propertyChange( const PropertyChangeEvent& rEvt )
 262         throw(RuntimeException)
 263 {
 264     MutexGuard  aGuard( GetLinguMutex() );
 265
 266     if (GetPropSet().is()  &&  rEvt.Source == GetPropSet())
 267     {
 268         sal_Int16 nLngSvcFlags = 0;
 269         sal_Bool bSCWA = sal_False, // SPELL_CORRECT_WORDS_AGAIN ?
 270              bSWWA = sal_False; // SPELL_WRONG_WORDS_AGAIN ?
 271
 272         sal_Bool *pbVal = NULL;
 273         switch (rEvt.PropertyHandle)
 274         {
 275             case UPH_IS_IGNORE_CONTROL_CHARACTERS :
 276             {
 277                 pbVal = &bIsIgnoreControlCharacters;
 278                 break;
 279             }
 280             case UPH_IS_GERMAN_PRE_REFORM         :
 281             {
 282                 pbVal = &bIsGermanPreReform;
 283                 bSCWA = bSWWA = sal_True;
 284                 break;
 285             }
 286             case UPH_IS_USE_DICTIONARY_LIST       :
 287             {
 288                 pbVal = &bIsUseDictionaryList;
 289                 bSCWA = bSWWA = sal_True;
 290                 break;
 291             }
 292             case UPH_IS_SPELL_UPPER_CASE          :
 293             {
 294                 pbVal = &bIsSpellUpperCase;
 295                 bSCWA = sal_False == *pbVal;    // sal_False->sal_True change?
 296                 bSWWA = !bSCWA;             // sal_True->sal_False change?
 297                 break;
 298             }
 299             case UPH_IS_SPELL_WITH_DIGITS         :
 300             {
 301                 pbVal = &bIsSpellWithDigits;
 302                 bSCWA = sal_False == *pbVal;    // sal_False->sal_True change?
 303                 bSWWA = !bSCWA;             // sal_True->sal_False change?
 304                 break;
 305             }
 306             case UPH_IS_SPELL_CAPITALIZATION      :
 307             {
 308                 pbVal = &bIsSpellCapitalization;
 309                 bSCWA = sal_False == *pbVal;    // sal_False->sal_True change?
 310                 bSWWA = !bSCWA;             // sal_True->sal_False change?
 311                 break;
 312             }
 313             case UPH_IS_SPELL_CLOSED_COMPOUND     :
 314             {
 315                 pbVal = &bIsSpellClosedCompound;
 316                 bSCWA = sal_False == *pbVal;    // sal_False->sal_True change?
 317                 bSWWA = !bSCWA;             // sal_True->sal_False change?
 318                 break;
 319             }
 320             case UPH_IS_SPELL_HYPHENATED_COMPOUND     :
 321             {
 322                 pbVal = &bIsSpellHyphenatedCompound;
 323                 bSCWA = sal_False == *pbVal;    // sal_False->sal_True change?
 324                 bSWWA = !bSCWA;             // sal_True->sal_False change?
 325                 break;
 326             }
 327
 328             default:
 329                 OSL_FAIL( "unknown property" );
 330         }
 331         if (pbVal)
 332             rEvt.NewValue >>= *pbVal;
 333
 334         if (bSCWA)
 335             nLngSvcFlags |= LinguServiceEventFlags::SPELL_CORRECT_WORDS_AGAIN;
 336         if (bSWWA)
 337             nLngSvcFlags |= LinguServiceEventFlags::SPELL_WRONG_WORDS_AGAIN;
 338         if (nLngSvcFlags)
 339         {
 340             LinguServiceEvent aEvt( GetEvtObj(), nLngSvcFlags );
 341             LaunchEvent( aEvt );
 342         }
 343     }
 344 }
 345
 346
 347 void PropertyHelper_Spell::SetTmpPropVals( const PropertyValues &rPropVals )
 348 {
 349     // set return value to default value unless there is an
 350     // explicitly supplied temporary value
 351     bResIsGermanPreReform           = bIsGermanPreReform;
 352     bResIsIgnoreControlCharacters   = bIsIgnoreControlCharacters;
 353     bResIsUseDictionaryList         = bIsUseDictionaryList;
 354     bResIsSpellUpperCase            = bIsSpellUpperCase;
 355     bResIsSpellWithDigits           = bIsSpellWithDigits;
 356     bResIsSpellCapitalization       = bIsSpellCapitalization;
 357     bResIsSpellClosedCompound       = bIsSpellClosedCompound;
 358     bResIsSpellHyphenatedCompound   = bIsSpellHyphenatedCompound;
 359
 360     sal_Int32 nLen = rPropVals.getLength();
 361     if (nLen)
 362     {
 363         const PropertyValue *pVal = rPropVals.getConstArray();
 364         for (sal_Int32 i = 0;  i < nLen;  ++i)
 365         {
 366             sal_Bool *pbResVal = NULL;
 367             switch (pVal[i].Handle)
 368             {
 369                 case UPH_IS_GERMAN_PRE_REFORM         : pbResVal = &bResIsGermanPreReform; break;
 370                 case UPH_IS_IGNORE_CONTROL_CHARACTERS : pbResVal = &bResIsIgnoreControlCharacters; break;
 371                 case UPH_IS_USE_DICTIONARY_LIST       : pbResVal = &bResIsUseDictionaryList; break;
 372                 case UPH_IS_SPELL_UPPER_CASE          : pbResVal = &bResIsSpellUpperCase; break;
 373                 case UPH_IS_SPELL_WITH_DIGITS         : pbResVal = &bResIsSpellWithDigits; break;
 374                 case UPH_IS_SPELL_CAPITALIZATION      : pbResVal = &bResIsSpellCapitalization; break;
 375                 case UPH_IS_SPELL_CLOSED_COMPOUND     : pbResVal = &bResIsSpellClosedCompound; break;
 376                 case UPH_IS_SPELL_HYPHENATED_COMPOUND : pbResVal = &bResIsSpellHyphenatedCompound; break;
 377                 default:
 378                     OSL_FAIL( "unknown property" );
 379             }
 380             if (pbResVal)
 381                 pVal[i].Value >>= *pbResVal;
 382         }
 383     }
 384 }
 385
 386
 387 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */