Line data Source code
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 <tools/debug.hxx>
22 : #include <sal/macros.h>
23 :
24 : #include <com/sun/star/linguistic2/LinguServiceEvent.hpp>
25 : #include <com/sun/star/linguistic2/LinguServiceEventFlags.hpp>
26 : #include <com/sun/star/linguistic2/XLinguServiceEventListener.hpp>
27 : #include <com/sun/star/beans/XPropertySet.hpp>
28 : #include <osl/mutex.hxx>
29 :
30 : #include <linguistic/misc.hxx>
31 : #include <linguistic/lngprops.hxx>
32 :
33 : #include <linguistic/lngprophelp.hxx>
34 :
35 : using namespace osl;
36 : using namespace com::sun::star;
37 : using namespace com::sun::star::beans;
38 : using namespace com::sun::star::lang;
39 : using namespace com::sun::star::uno;
40 : using namespace com::sun::star::linguistic2;
41 : using namespace linguistic;
42 :
43 :
44 : namespace linguistic
45 : {
46 :
47 :
48 : static const char *aCH[] =
49 : {
50 : UPN_IS_IGNORE_CONTROL_CHARACTERS,
51 : UPN_IS_USE_DICTIONARY_LIST,
52 : };
53 :
54 : static const int nCHCount = sizeof(aCH) / sizeof(aCH[0]);
55 :
56 :
57 42 : PropertyChgHelper::PropertyChgHelper(
58 : const Reference< XInterface > &rxSource,
59 : Reference< XLinguProperties > &rxPropSet,
60 : int nAllowedEvents ) :
61 : PropertyChgHelperBase(),
62 : aPropNames (nCHCount),
63 : xMyEvtObj (rxSource),
64 42 : aLngSvcEvtListeners (GetLinguMutex()),
65 : xPropSet (rxPropSet),
66 84 : nEvtFlags (nAllowedEvents)
67 : {
68 42 : OUString *pName = aPropNames.getArray();
69 126 : for (sal_Int32 i = 0; i < nCHCount; ++i)
70 : {
71 84 : pName[i] = OUString::createFromAscii( aCH[i] );
72 : }
73 :
74 42 : SetDefaultValues();
75 42 : }
76 :
77 :
78 0 : PropertyChgHelper::PropertyChgHelper( const PropertyChgHelper &rHelper ) :
79 : PropertyChgHelperBase(),
80 0 : aLngSvcEvtListeners (GetLinguMutex())
81 : {
82 0 : RemoveAsPropListener();
83 0 : aPropNames = rHelper.aPropNames;
84 0 : xMyEvtObj = rHelper.xMyEvtObj;
85 0 : xPropSet = rHelper.xPropSet;
86 0 : nEvtFlags = rHelper.nEvtFlags;
87 0 : AddAsPropListener();
88 :
89 0 : SetDefaultValues();
90 0 : GetCurrentValues();
91 0 : }
92 :
93 :
94 42 : PropertyChgHelper::~PropertyChgHelper()
95 : {
96 42 : }
97 :
98 :
99 42 : void PropertyChgHelper::AddPropNames( const char *pNewNames[], sal_Int32 nCount )
100 : {
101 42 : if (pNewNames && nCount)
102 : {
103 42 : sal_Int32 nLen = GetPropNames().getLength();
104 42 : GetPropNames().realloc( nLen + nCount );
105 42 : OUString *pName = GetPropNames().getArray();
106 168 : for (sal_Int32 i = 0; i < nCount; ++i)
107 : {
108 126 : pName[ nLen + i ] = OUString::createFromAscii( pNewNames[ i ] );
109 :
110 : }
111 : }
112 42 : }
113 :
114 :
115 84 : void PropertyChgHelper::SetDefaultValues()
116 : {
117 84 : bResIsIgnoreControlCharacters = bIsIgnoreControlCharacters = true;
118 84 : bResIsUseDictionaryList = bIsUseDictionaryList = true;
119 84 : }
120 :
121 :
122 42 : void PropertyChgHelper::GetCurrentValues()
123 : {
124 42 : sal_Int32 nLen = GetPropNames().getLength();
125 42 : if (GetPropSet().is() && nLen)
126 : {
127 42 : const OUString *pPropName = GetPropNames().getConstArray();
128 252 : for (sal_Int32 i = 0; i < nLen; ++i)
129 : {
130 210 : bool *pbVal = NULL,
131 210 : *pbResVal = NULL;
132 :
133 210 : if ( pPropName[i] == UPN_IS_IGNORE_CONTROL_CHARACTERS )
134 : {
135 42 : pbVal = &bIsIgnoreControlCharacters;
136 42 : pbResVal = &bResIsIgnoreControlCharacters;
137 : }
138 168 : else if ( pPropName[i] == UPN_IS_USE_DICTIONARY_LIST )
139 : {
140 42 : pbVal = &bIsUseDictionaryList;
141 42 : pbResVal = &bResIsUseDictionaryList;
142 : }
143 :
144 210 : if (pbVal && pbResVal)
145 : {
146 84 : GetPropSet()->getPropertyValue( pPropName[i] ) >>= *pbVal;
147 84 : *pbResVal = *pbVal;
148 : }
149 : }
150 : }
151 42 : }
152 :
153 :
154 29911 : void PropertyChgHelper::SetTmpPropVals( const PropertyValues &rPropVals )
155 : {
156 : // return value is default value unless there is an explicitly supplied
157 : // temporary value
158 29911 : bResIsIgnoreControlCharacters = bIsIgnoreControlCharacters;
159 29911 : bResIsUseDictionaryList = bIsUseDictionaryList;
160 :
161 29911 : sal_Int32 nLen = rPropVals.getLength();
162 29911 : if (nLen)
163 : {
164 0 : const PropertyValue *pVal = rPropVals.getConstArray();
165 0 : for (sal_Int32 i = 0; i < nLen; ++i)
166 : {
167 0 : bool *pbResVal = NULL;
168 0 : switch (pVal[i].Handle)
169 : {
170 : case UPH_IS_IGNORE_CONTROL_CHARACTERS :
171 0 : pbResVal = &bResIsIgnoreControlCharacters; break;
172 : case UPH_IS_USE_DICTIONARY_LIST :
173 0 : pbResVal = &bResIsUseDictionaryList; break;
174 : default:
175 : ;
176 : }
177 0 : if (pbResVal)
178 0 : pVal[i].Value >>= *pbResVal;
179 : }
180 : }
181 29911 : }
182 :
183 :
184 0 : bool PropertyChgHelper::propertyChange_Impl( const PropertyChangeEvent& rEvt )
185 : {
186 0 : bool bRes = false;
187 :
188 0 : if (GetPropSet().is() && rEvt.Source == GetPropSet())
189 : {
190 0 : sal_Int16 nLngSvcFlags = (nEvtFlags & AE_HYPHENATOR) ?
191 0 : LinguServiceEventFlags::HYPHENATE_AGAIN : 0;
192 0 : bool bSCWA = false, // SPELL_CORRECT_WORDS_AGAIN ?
193 0 : bSWWA = false; // SPELL_WRONG_WORDS_AGAIN ?
194 :
195 0 : bool *pbVal = NULL;
196 0 : switch (rEvt.PropertyHandle)
197 : {
198 : case UPH_IS_IGNORE_CONTROL_CHARACTERS :
199 : {
200 0 : pbVal = &bIsIgnoreControlCharacters;
201 0 : nLngSvcFlags = 0;
202 0 : break;
203 : }
204 : case UPH_IS_USE_DICTIONARY_LIST :
205 : {
206 0 : pbVal = &bIsUseDictionaryList;
207 0 : bSCWA = bSWWA = true;
208 0 : break;
209 : }
210 : default:
211 : {
212 0 : bRes = false;
213 : }
214 : }
215 0 : if (pbVal)
216 0 : rEvt.NewValue >>= *pbVal;
217 :
218 0 : bRes = 0 != pbVal; // sth changed?
219 0 : if (bRes)
220 : {
221 0 : bool bSpellEvts = (nEvtFlags & AE_SPELLCHECKER);
222 0 : if (bSCWA && bSpellEvts)
223 0 : nLngSvcFlags |= LinguServiceEventFlags::SPELL_CORRECT_WORDS_AGAIN;
224 0 : if (bSWWA && bSpellEvts)
225 0 : nLngSvcFlags |= LinguServiceEventFlags::SPELL_WRONG_WORDS_AGAIN;
226 0 : if (nLngSvcFlags)
227 : {
228 0 : LinguServiceEvent aEvt( GetEvtObj(), nLngSvcFlags );
229 0 : LaunchEvent( aEvt );
230 : }
231 : }
232 : }
233 :
234 0 : return bRes;
235 : }
236 :
237 :
238 : void SAL_CALL
239 0 : PropertyChgHelper::propertyChange( const PropertyChangeEvent& rEvt )
240 : throw(RuntimeException, std::exception)
241 : {
242 0 : MutexGuard aGuard( GetLinguMutex() );
243 0 : propertyChange_Impl( rEvt );
244 0 : }
245 :
246 :
247 42 : void PropertyChgHelper::AddAsPropListener()
248 : {
249 42 : if (xPropSet.is())
250 : {
251 42 : sal_Int32 nLen = aPropNames.getLength();
252 42 : const OUString *pPropName = aPropNames.getConstArray();
253 252 : for (sal_Int32 i = 0; i < nLen; ++i)
254 : {
255 210 : if (!pPropName[i].isEmpty())
256 210 : xPropSet->addPropertyChangeListener( pPropName[i], this );
257 : }
258 : }
259 42 : }
260 :
261 42 : void PropertyChgHelper::RemoveAsPropListener()
262 : {
263 42 : if (xPropSet.is())
264 : {
265 42 : sal_Int32 nLen = aPropNames.getLength();
266 42 : const OUString *pPropName = aPropNames.getConstArray();
267 252 : for (sal_Int32 i = 0; i < nLen; ++i)
268 : {
269 210 : if (!pPropName[i].isEmpty())
270 210 : xPropSet->removePropertyChangeListener( pPropName[i], this );
271 : }
272 : }
273 42 : }
274 :
275 :
276 0 : void PropertyChgHelper::LaunchEvent( const LinguServiceEvent &rEvt )
277 : {
278 0 : cppu::OInterfaceIteratorHelper aIt( aLngSvcEvtListeners );
279 0 : while (aIt.hasMoreElements())
280 : {
281 0 : Reference< XLinguServiceEventListener > xRef( aIt.next(), UNO_QUERY );
282 0 : if (xRef.is())
283 0 : xRef->processLinguServiceEvent( rEvt );
284 0 : }
285 0 : }
286 :
287 :
288 0 : void SAL_CALL PropertyChgHelper::disposing( const EventObject& rSource )
289 : throw(RuntimeException, std::exception)
290 : {
291 0 : MutexGuard aGuard( GetLinguMutex() );
292 0 : if (rSource.Source == xPropSet)
293 : {
294 0 : RemoveAsPropListener();
295 0 : xPropSet = NULL;
296 0 : aPropNames.realloc( 0 );
297 0 : }
298 0 : }
299 :
300 :
301 : sal_Bool SAL_CALL
302 42 : PropertyChgHelper::addLinguServiceEventListener(
303 : const Reference< XLinguServiceEventListener >& rxListener )
304 : throw(RuntimeException, std::exception)
305 : {
306 42 : MutexGuard aGuard( GetLinguMutex() );
307 :
308 42 : bool bRes = false;
309 42 : if (rxListener.is())
310 : {
311 42 : sal_Int32 nCount = aLngSvcEvtListeners.getLength();
312 42 : bRes = aLngSvcEvtListeners.addInterface( rxListener ) != nCount;
313 : }
314 42 : return bRes;
315 : }
316 :
317 :
318 : sal_Bool SAL_CALL
319 0 : PropertyChgHelper::removeLinguServiceEventListener(
320 : const Reference< XLinguServiceEventListener >& rxListener )
321 : throw(RuntimeException, std::exception)
322 : {
323 0 : MutexGuard aGuard( GetLinguMutex() );
324 :
325 0 : bool bRes = false;
326 0 : if (rxListener.is())
327 : {
328 0 : sal_Int32 nCount = aLngSvcEvtListeners.getLength();
329 0 : bRes = aLngSvcEvtListeners.removeInterface( rxListener ) != nCount;
330 : }
331 0 : return bRes;
332 : }
333 :
334 :
335 :
336 0 : PropertyHelper_Thes::PropertyHelper_Thes(
337 : const Reference< XInterface > &rxSource,
338 : Reference< XLinguProperties > &rxPropSet ) :
339 0 : PropertyChgHelper ( rxSource, rxPropSet, 0 )
340 : {
341 0 : SetDefaultValues();
342 0 : GetCurrentValues();
343 0 : }
344 :
345 :
346 0 : PropertyHelper_Thes::~PropertyHelper_Thes()
347 : {
348 0 : }
349 :
350 :
351 : void SAL_CALL
352 0 : PropertyHelper_Thes::propertyChange( const PropertyChangeEvent& rEvt )
353 : throw(RuntimeException, std::exception)
354 : {
355 0 : MutexGuard aGuard( GetLinguMutex() );
356 0 : PropertyChgHelper::propertyChange_Impl( rEvt );
357 0 : }
358 :
359 :
360 :
361 : // list of properties from the property set to be used
362 : // and listened to
363 : static const char *aSP[] =
364 : {
365 : UPN_IS_SPELL_UPPER_CASE,
366 : UPN_IS_SPELL_WITH_DIGITS,
367 : UPN_IS_SPELL_CAPITALIZATION
368 : };
369 :
370 :
371 32 : PropertyHelper_Spell::PropertyHelper_Spell(
372 : const Reference< XInterface > & rxSource,
373 : Reference< XLinguProperties > &rxPropSet ) :
374 32 : PropertyChgHelper ( rxSource, rxPropSet, AE_SPELLCHECKER )
375 : {
376 32 : AddPropNames( aSP, sizeof(aSP) / sizeof(aSP[0]) );
377 32 : SetDefaultValues();
378 32 : GetCurrentValues();
379 :
380 32 : nResMaxNumberOfSuggestions = GetDefaultNumberOfSuggestions();
381 32 : }
382 :
383 :
384 64 : PropertyHelper_Spell::~PropertyHelper_Spell()
385 : {
386 64 : }
387 :
388 :
389 32 : void PropertyHelper_Spell::SetDefaultValues()
390 : {
391 32 : PropertyChgHelper::SetDefaultValues();
392 :
393 32 : bResIsSpellUpperCase = bIsSpellUpperCase = false;
394 32 : bResIsSpellWithDigits = bIsSpellWithDigits = false;
395 32 : bResIsSpellCapitalization = bIsSpellCapitalization = true;
396 32 : }
397 :
398 :
399 32 : void PropertyHelper_Spell::GetCurrentValues()
400 : {
401 32 : PropertyChgHelper::GetCurrentValues();
402 :
403 32 : sal_Int32 nLen = GetPropNames().getLength();
404 32 : if (GetPropSet().is() && nLen)
405 : {
406 32 : const OUString *pPropName = GetPropNames().getConstArray();
407 192 : for (sal_Int32 i = 0; i < nLen; ++i)
408 : {
409 160 : bool *pbVal = NULL,
410 160 : *pbResVal = NULL;
411 :
412 160 : if ( pPropName[i] == UPN_IS_SPELL_UPPER_CASE )
413 : {
414 32 : pbVal = &bIsSpellUpperCase;
415 32 : pbResVal = &bResIsSpellUpperCase;
416 : }
417 128 : else if ( pPropName[i] == UPN_IS_SPELL_WITH_DIGITS )
418 : {
419 32 : pbVal = &bIsSpellWithDigits;
420 32 : pbResVal = &bResIsSpellWithDigits;
421 : }
422 96 : else if ( pPropName[i] == UPN_IS_SPELL_CAPITALIZATION )
423 : {
424 32 : pbVal = &bIsSpellCapitalization;
425 32 : pbResVal = &bResIsSpellCapitalization;
426 : }
427 :
428 160 : if (pbVal && pbResVal)
429 : {
430 96 : GetPropSet()->getPropertyValue( pPropName[i] ) >>= *pbVal;
431 96 : *pbResVal = *pbVal;
432 : }
433 : }
434 : }
435 32 : }
436 :
437 :
438 0 : bool PropertyHelper_Spell::propertyChange_Impl( const PropertyChangeEvent& rEvt )
439 : {
440 0 : bool bRes = PropertyChgHelper::propertyChange_Impl( rEvt );
441 :
442 0 : if (!bRes && GetPropSet().is() && rEvt.Source == GetPropSet())
443 : {
444 0 : bool bSCWA = false, // SPELL_CORRECT_WORDS_AGAIN ?
445 0 : bSWWA = false; // SPELL_WRONG_WORDS_AGAIN ?
446 :
447 0 : bool *pbVal = NULL;
448 0 : switch (rEvt.PropertyHandle)
449 : {
450 : case UPH_IS_SPELL_UPPER_CASE :
451 : {
452 0 : pbVal = &bIsSpellUpperCase;
453 0 : bSCWA = ! *pbVal; // sal_False->sal_True change?
454 0 : bSWWA = !bSCWA; // sal_True->sal_False change?
455 0 : break;
456 : }
457 : case UPH_IS_SPELL_WITH_DIGITS :
458 : {
459 0 : pbVal = &bIsSpellWithDigits;
460 0 : bSCWA = ! *pbVal; // sal_False->sal_True change?
461 0 : bSWWA = !bSCWA; // sal_True->sal_False change?
462 0 : break;
463 : }
464 : case UPH_IS_SPELL_CAPITALIZATION :
465 : {
466 0 : pbVal = &bIsSpellCapitalization;
467 0 : bSCWA = ! *pbVal; // sal_False->sal_True change?
468 0 : bSWWA = !bSCWA; // sal_True->sal_False change?
469 0 : break;
470 : }
471 : default:
472 : DBG_ASSERT( false, "unknown property" );
473 : }
474 0 : if (pbVal)
475 0 : rEvt.NewValue >>= *pbVal;
476 :
477 0 : bRes = (pbVal != 0);
478 0 : if (bRes)
479 : {
480 0 : sal_Int16 nLngSvcFlags = 0;
481 0 : if (bSCWA)
482 0 : nLngSvcFlags |= LinguServiceEventFlags::SPELL_CORRECT_WORDS_AGAIN;
483 0 : if (bSWWA)
484 0 : nLngSvcFlags |= LinguServiceEventFlags::SPELL_WRONG_WORDS_AGAIN;
485 0 : if (nLngSvcFlags)
486 : {
487 0 : LinguServiceEvent aEvt( GetEvtObj(), nLngSvcFlags );
488 0 : LaunchEvent( aEvt );
489 : }
490 : }
491 : }
492 :
493 0 : return bRes;
494 : }
495 :
496 :
497 : void SAL_CALL
498 0 : PropertyHelper_Spell::propertyChange( const PropertyChangeEvent& rEvt )
499 : throw(RuntimeException, std::exception)
500 : {
501 0 : MutexGuard aGuard( GetLinguMutex() );
502 0 : propertyChange_Impl( rEvt );
503 0 : }
504 :
505 :
506 8309 : void PropertyHelper_Spell::SetTmpPropVals( const PropertyValues &rPropVals )
507 : {
508 8309 : PropertyChgHelper::SetTmpPropVals( rPropVals );
509 :
510 : // return value is default value unless there is an explicitly supplied
511 : // temporary value
512 8309 : nResMaxNumberOfSuggestions = GetDefaultNumberOfSuggestions();
513 8309 : bResIsSpellWithDigits = bIsSpellWithDigits;
514 8309 : bResIsSpellCapitalization = bIsSpellCapitalization;
515 8309 : bResIsSpellUpperCase = bIsSpellUpperCase;
516 :
517 8309 : sal_Int32 nLen = rPropVals.getLength();
518 8309 : if (nLen)
519 : {
520 0 : const PropertyValue *pVal = rPropVals.getConstArray();
521 0 : for (sal_Int32 i = 0; i < nLen; ++i)
522 : {
523 0 : if ( pVal[i].Name == UPN_MAX_NUMBER_OF_SUGGESTIONS )
524 : {
525 0 : pVal[i].Value >>= nResMaxNumberOfSuggestions;
526 : }
527 : else
528 : {
529 0 : bool *pbResVal = NULL;
530 0 : switch (pVal[i].Handle)
531 : {
532 0 : case UPH_IS_SPELL_UPPER_CASE : pbResVal = &bResIsSpellUpperCase; break;
533 0 : case UPH_IS_SPELL_WITH_DIGITS : pbResVal = &bResIsSpellWithDigits; break;
534 0 : case UPH_IS_SPELL_CAPITALIZATION : pbResVal = &bResIsSpellCapitalization; break;
535 : default:
536 : DBG_ASSERT( false, "unknown property" );
537 : }
538 0 : if (pbResVal)
539 0 : pVal[i].Value >>= *pbResVal;
540 : }
541 : }
542 : }
543 8309 : }
544 :
545 8341 : sal_Int16 PropertyHelper_Spell::GetDefaultNumberOfSuggestions() const
546 : {
547 8341 : return 16;
548 : }
549 :
550 :
551 : static const char *aHP[] =
552 : {
553 : UPN_HYPH_MIN_LEADING,
554 : UPN_HYPH_MIN_TRAILING,
555 : UPN_HYPH_MIN_WORD_LENGTH
556 : };
557 :
558 :
559 10 : PropertyHelper_Hyphen::PropertyHelper_Hyphen(
560 : const Reference< XInterface > & rxSource,
561 : Reference< XLinguProperties > &rxPropSet ) :
562 10 : PropertyChgHelper ( rxSource, rxPropSet, AE_HYPHENATOR )
563 : {
564 10 : AddPropNames( aHP, sizeof(aHP) / sizeof(aHP[0]) );
565 10 : SetDefaultValues();
566 10 : GetCurrentValues();
567 10 : }
568 :
569 :
570 20 : PropertyHelper_Hyphen::~PropertyHelper_Hyphen()
571 : {
572 20 : }
573 :
574 :
575 10 : void PropertyHelper_Hyphen::SetDefaultValues()
576 : {
577 10 : PropertyChgHelper::SetDefaultValues();
578 :
579 10 : nResHyphMinLeading = nHyphMinLeading = 2;
580 10 : nResHyphMinTrailing = nHyphMinTrailing = 2;
581 10 : nResHyphMinWordLength = nHyphMinWordLength = 0;
582 10 : }
583 :
584 :
585 10 : void PropertyHelper_Hyphen::GetCurrentValues()
586 : {
587 10 : PropertyChgHelper::GetCurrentValues();
588 :
589 10 : sal_Int32 nLen = GetPropNames().getLength();
590 10 : if (GetPropSet().is() && nLen)
591 : {
592 10 : const OUString *pPropName = GetPropNames().getConstArray();
593 60 : for (sal_Int32 i = 0; i < nLen; ++i)
594 : {
595 50 : sal_Int16 *pnVal = NULL,
596 50 : *pnResVal = NULL;
597 :
598 50 : if ( pPropName[i] == UPN_HYPH_MIN_LEADING )
599 : {
600 10 : pnVal = &nHyphMinLeading;
601 10 : pnResVal = &nResHyphMinLeading;
602 : }
603 40 : else if ( pPropName[i] == UPN_HYPH_MIN_TRAILING )
604 : {
605 10 : pnVal = &nHyphMinTrailing;
606 10 : pnResVal = &nResHyphMinTrailing;
607 : }
608 30 : else if ( pPropName[i] == UPN_HYPH_MIN_WORD_LENGTH )
609 : {
610 10 : pnVal = &nHyphMinWordLength;
611 10 : pnResVal = &nResHyphMinWordLength;
612 : }
613 :
614 50 : if (pnVal && pnResVal)
615 : {
616 30 : GetPropSet()->getPropertyValue( pPropName[i] ) >>= *pnVal;
617 30 : *pnResVal = *pnVal;
618 : }
619 : }
620 : }
621 10 : }
622 :
623 :
624 0 : bool PropertyHelper_Hyphen::propertyChange_Impl( const PropertyChangeEvent& rEvt )
625 : {
626 0 : bool bRes = PropertyChgHelper::propertyChange_Impl( rEvt );
627 :
628 0 : if (!bRes && GetPropSet().is() && rEvt.Source == GetPropSet())
629 : {
630 0 : sal_Int16 nLngSvcFlags = LinguServiceEventFlags::HYPHENATE_AGAIN;
631 :
632 0 : sal_Int16 *pnVal = NULL;
633 0 : switch (rEvt.PropertyHandle)
634 : {
635 0 : case UPH_HYPH_MIN_LEADING : pnVal = &nHyphMinLeading; break;
636 0 : case UPH_HYPH_MIN_TRAILING : pnVal = &nHyphMinTrailing; break;
637 0 : case UPH_HYPH_MIN_WORD_LENGTH : pnVal = &nHyphMinWordLength; break;
638 : default:
639 : DBG_ASSERT( false, "unknown property" );
640 : }
641 0 : if (pnVal)
642 0 : rEvt.NewValue >>= *pnVal;
643 :
644 0 : bRes = (pnVal != 0);
645 0 : if (bRes)
646 : {
647 0 : if (nLngSvcFlags)
648 : {
649 0 : LinguServiceEvent aEvt( GetEvtObj(), nLngSvcFlags );
650 0 : LaunchEvent( aEvt );
651 : }
652 : }
653 : }
654 :
655 0 : return bRes;
656 : }
657 :
658 :
659 : void SAL_CALL
660 0 : PropertyHelper_Hyphen::propertyChange( const PropertyChangeEvent& rEvt )
661 : throw(RuntimeException, std::exception)
662 : {
663 0 : MutexGuard aGuard( GetLinguMutex() );
664 0 : propertyChange_Impl( rEvt );
665 0 : }
666 :
667 :
668 21602 : void PropertyHelper_Hyphen::SetTmpPropVals( const PropertyValues &rPropVals )
669 : {
670 21602 : PropertyChgHelper::SetTmpPropVals( rPropVals );
671 :
672 : // return value is default value unless there is an explicitly supplied
673 : // temporary value
674 21602 : nResHyphMinLeading = nHyphMinLeading;
675 21602 : nResHyphMinTrailing = nHyphMinTrailing;
676 21602 : nResHyphMinWordLength = nHyphMinWordLength;
677 :
678 21602 : sal_Int32 nLen = rPropVals.getLength();
679 :
680 21602 : if (nLen)
681 : {
682 0 : const PropertyValue *pVal = rPropVals.getConstArray();
683 0 : for (sal_Int32 i = 0; i < nLen; ++i)
684 : {
685 0 : sal_Int16 *pnResVal = NULL;
686 :
687 0 : if ( pVal[i].Name == UPN_HYPH_MIN_LEADING )
688 0 : pnResVal = &nResHyphMinLeading;
689 0 : else if ( pVal[i].Name == UPN_HYPH_MIN_TRAILING )
690 0 : pnResVal = &nResHyphMinTrailing;
691 0 : else if ( pVal[i].Name == UPN_HYPH_MIN_WORD_LENGTH )
692 0 : pnResVal = &nResHyphMinWordLength;
693 :
694 : DBG_ASSERT( pnResVal, "unknown property" );
695 :
696 0 : if (pnResVal)
697 0 : pVal[i].Value >>= *pnResVal;
698 : }
699 : }
700 21602 : }
701 :
702 0 : PropertyHelper_Thesaurus::PropertyHelper_Thesaurus(
703 : const ::com::sun::star::uno::Reference<
704 : ::com::sun::star::uno::XInterface > &rxSource,
705 : ::com::sun::star::uno::Reference<
706 0 : ::com::sun::star::linguistic2::XLinguProperties > &rxPropSet )
707 : {
708 0 : pInst = new PropertyHelper_Thes( rxSource, rxPropSet );
709 0 : xPropHelper = pInst;
710 0 : }
711 :
712 0 : PropertyHelper_Thesaurus::~PropertyHelper_Thesaurus()
713 : {
714 0 : }
715 :
716 0 : void PropertyHelper_Thesaurus::AddAsPropListener()
717 : {
718 0 : pInst->AddAsPropListener();
719 0 : }
720 :
721 0 : void PropertyHelper_Thesaurus::RemoveAsPropListener()
722 : {
723 0 : pInst->RemoveAsPropListener();
724 0 : }
725 :
726 0 : void PropertyHelper_Thesaurus::SetTmpPropVals( const com::sun::star::beans::PropertyValues &rPropVals )
727 : {
728 0 : pInst->SetTmpPropVals( rPropVals );
729 0 : }
730 :
731 10 : PropertyHelper_Hyphenation::PropertyHelper_Hyphenation(
732 : const ::com::sun::star::uno::Reference<
733 : ::com::sun::star::uno::XInterface > &rxSource,
734 : ::com::sun::star::uno::Reference<
735 10 : ::com::sun::star::linguistic2::XLinguProperties > &rxPropSet)
736 : {
737 10 : pInst = new PropertyHelper_Hyphen( rxSource, rxPropSet );
738 10 : xPropHelper = pInst;
739 10 : }
740 :
741 10 : PropertyHelper_Hyphenation::~PropertyHelper_Hyphenation()
742 : {
743 10 : }
744 :
745 10 : void PropertyHelper_Hyphenation::AddAsPropListener()
746 : {
747 10 : pInst->AddAsPropListener();
748 10 : }
749 :
750 10 : void PropertyHelper_Hyphenation::RemoveAsPropListener()
751 : {
752 10 : pInst->RemoveAsPropListener();
753 10 : }
754 :
755 21602 : void PropertyHelper_Hyphenation::SetTmpPropVals( const com::sun::star::beans::PropertyValues &rPropVals )
756 : {
757 21602 : pInst->SetTmpPropVals( rPropVals );
758 21602 : }
759 :
760 21602 : sal_Int16 PropertyHelper_Hyphenation::GetMinLeading() const
761 : {
762 21602 : return pInst->GetMinLeading();
763 : }
764 :
765 21602 : sal_Int16 PropertyHelper_Hyphenation::GetMinTrailing() const
766 : {
767 21602 : return pInst->GetMinTrailing();
768 : }
769 :
770 21602 : sal_Int16 PropertyHelper_Hyphenation::GetMinWordLength() const
771 : {
772 21602 : return pInst->GetMinWordLength();
773 : }
774 :
775 10 : bool PropertyHelper_Hyphenation::addLinguServiceEventListener(
776 : const ::com::sun::star::uno::Reference<
777 : ::com::sun::star::linguistic2::XLinguServiceEventListener >& rxListener )
778 : throw(::com::sun::star::uno::RuntimeException)
779 : {
780 10 : return pInst->addLinguServiceEventListener( rxListener );
781 : }
782 :
783 0 : bool PropertyHelper_Hyphenation::removeLinguServiceEventListener(
784 : const ::com::sun::star::uno::Reference<
785 : ::com::sun::star::linguistic2::XLinguServiceEventListener >& rxListener )
786 : throw(::com::sun::star::uno::RuntimeException)
787 : {
788 0 : return pInst->removeLinguServiceEventListener( rxListener );
789 : }
790 :
791 32 : PropertyHelper_Spelling::PropertyHelper_Spelling(
792 : const ::com::sun::star::uno::Reference<
793 : ::com::sun::star::uno::XInterface > &rxSource,
794 : ::com::sun::star::uno::Reference<
795 32 : ::com::sun::star::linguistic2::XLinguProperties > &rxPropSet )
796 : {
797 32 : pInst = new PropertyHelper_Spell( rxSource, rxPropSet );
798 32 : xPropHelper = pInst;
799 32 : }
800 :
801 32 : PropertyHelper_Spelling::~PropertyHelper_Spelling()
802 : {
803 32 : }
804 :
805 32 : void PropertyHelper_Spelling::AddAsPropListener()
806 : {
807 32 : pInst->AddAsPropListener();
808 32 : }
809 :
810 32 : void PropertyHelper_Spelling::RemoveAsPropListener()
811 : {
812 32 : pInst->RemoveAsPropListener();
813 32 : }
814 :
815 8309 : void PropertyHelper_Spelling::SetTmpPropVals( const com::sun::star::beans::PropertyValues &rPropVals )
816 : {
817 8309 : pInst->SetTmpPropVals( rPropVals );
818 8309 : }
819 :
820 6805 : bool PropertyHelper_Spelling::IsSpellUpperCase() const
821 : {
822 6805 : return pInst->IsSpellUpperCase();
823 : }
824 :
825 6677 : bool PropertyHelper_Spelling::IsSpellWithDigits() const
826 : {
827 6677 : return pInst->IsSpellWithDigits();
828 : }
829 :
830 865 : bool PropertyHelper_Spelling::IsSpellCapitalization() const
831 : {
832 865 : return pInst->IsSpellCapitalization();
833 : }
834 :
835 32 : bool PropertyHelper_Spelling::addLinguServiceEventListener(
836 : const ::com::sun::star::uno::Reference<
837 : ::com::sun::star::linguistic2::XLinguServiceEventListener >& rxListener )
838 : throw(::com::sun::star::uno::RuntimeException)
839 : {
840 32 : return pInst->addLinguServiceEventListener( rxListener );
841 : }
842 :
843 0 : bool PropertyHelper_Spelling::removeLinguServiceEventListener(
844 : const ::com::sun::star::uno::Reference<
845 : ::com::sun::star::linguistic2::XLinguServiceEventListener >& rxListener )
846 : throw(::com::sun::star::uno::RuntimeException)
847 : {
848 0 : return pInst->removeLinguServiceEventListener( rxListener );
849 : }
850 :
851 : } // namespace linguistic
852 :
853 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
