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 : #include <sal/config.h>
21 :
22 : #include <unotools/searchopt.hxx>
23 : #include <tools/debug.hxx>
24 : #include <unotools/configitem.hxx>
25 : #include <com/sun/star/i18n/TransliterationModules.hpp>
26 : #include <com/sun/star/i18n/TransliterationModulesExtra.hpp>
27 : #include <com/sun/star/uno/Sequence.hxx>
28 : #include <com/sun/star/uno/Any.h>
29 : #include <sal/macros.h>
30 : #include <osl/diagnose.h>
31 :
32 : using namespace utl;
33 : using namespace com::sun::star::uno;
34 : using namespace com::sun::star::i18n;
35 :
36 : #define MAX_FLAGS_OFFSET 27
37 :
38 : class SvtSearchOptions_Impl : public ConfigItem
39 : {
40 : sal_Int32 nFlags;
41 : bool bModified;
42 :
43 : SvtSearchOptions_Impl(const SvtSearchOptions_Impl&) SAL_DELETED_FUNCTION;
44 : SvtSearchOptions_Impl& operator=(const SvtSearchOptions_Impl&) SAL_DELETED_FUNCTION;
45 :
46 : // ConfigItem
47 : virtual void ImplCommit() SAL_OVERRIDE;
48 :
49 : protected:
50 0 : bool IsModified() const { return bModified; }
51 : using ConfigItem::SetModified;
52 : void SetModified( bool bVal );
53 : bool Load();
54 : bool Save();
55 :
56 : static Sequence< OUString > GetPropertyNames();
57 :
58 : public:
59 : SvtSearchOptions_Impl();
60 : virtual ~SvtSearchOptions_Impl();
61 :
62 : virtual void Notify( const com::sun::star::uno::Sequence< OUString >& aPropertyNames ) SAL_OVERRIDE;
63 :
64 : bool GetFlag( sal_uInt16 nOffset ) const;
65 : void SetFlag( sal_uInt16 nOffset, bool bVal );
66 : };
67 :
68 177 : SvtSearchOptions_Impl::SvtSearchOptions_Impl() :
69 177 : ConfigItem( OUString("Office.Common/SearchOptions") )
70 : {
71 177 : nFlags = 0x0003FFFF; // set all options values to 'true'
72 177 : Load();
73 177 : SetModified( false );
74 177 : }
75 :
76 354 : SvtSearchOptions_Impl::~SvtSearchOptions_Impl()
77 : {
78 : assert(!IsModified()); // should have been committed
79 354 : }
80 :
81 0 : void SvtSearchOptions_Impl::ImplCommit()
82 : {
83 0 : if (IsModified())
84 0 : Save();
85 0 : }
86 :
87 0 : void SvtSearchOptions_Impl::Notify( const Sequence< OUString >& )
88 : {
89 0 : }
90 :
91 1770 : bool SvtSearchOptions_Impl::GetFlag( sal_uInt16 nOffset ) const
92 : {
93 : DBG_ASSERT( nOffset <= MAX_FLAGS_OFFSET, "offset out of range");
94 1770 : return ((nFlags >> nOffset) & 0x01) != 0;
95 : }
96 :
97 4956 : void SvtSearchOptions_Impl::SetFlag( sal_uInt16 nOffset, bool bVal )
98 : {
99 : DBG_ASSERT( nOffset <= MAX_FLAGS_OFFSET, "offset out of range");
100 4956 : sal_Int32 nOldFlags = nFlags;
101 4956 : sal_Int32 nMask = ((sal_Int32) 1) << nOffset;
102 4956 : if (bVal)
103 3540 : nFlags |= nMask;
104 : else
105 1416 : nFlags &= ~nMask;
106 4956 : if (nFlags != nOldFlags)
107 2832 : SetModified( true );
108 4956 : }
109 :
110 3009 : void SvtSearchOptions_Impl::SetModified( bool bVal )
111 : {
112 3009 : bModified = bVal;
113 3009 : if (bModified)
114 : {
115 2832 : ConfigItem::SetModified();
116 : }
117 3009 : }
118 :
119 177 : Sequence< OUString > SvtSearchOptions_Impl::GetPropertyNames()
120 : {
121 : static const char* aPropNames[ MAX_FLAGS_OFFSET + 1 ] =
122 : {
123 : "IsWholeWordsOnly", // 0
124 : "IsBackwards", // 1
125 : "IsUseRegularExpression", // 2
126 : //"IsCurrentSelectionOnly", // interactively set or not...
127 : "IsSearchForStyles", // 3
128 : "IsSimilaritySearch", // 4
129 : "IsUseAsianOptions", // 5
130 : "IsMatchCase", // 6
131 : "Japanese/IsMatchFullHalfWidthForms", // 7
132 : "Japanese/IsMatchHiraganaKatakana", // 8
133 : "Japanese/IsMatchContractions", // 9
134 : "Japanese/IsMatchMinusDashCho-on", // 10
135 : "Japanese/IsMatchRepeatCharMarks", // 11
136 : "Japanese/IsMatchVariantFormKanji", // 12
137 : "Japanese/IsMatchOldKanaForms", // 13
138 : "Japanese/IsMatch_DiZi_DuZu", // 14
139 : "Japanese/IsMatch_BaVa_HaFa", // 15
140 : "Japanese/IsMatch_TsiThiChi_DhiZi", // 16
141 : "Japanese/IsMatch_HyuIyu_ByuVyu", // 17
142 : "Japanese/IsMatch_SeShe_ZeJe", // 18
143 : "Japanese/IsMatch_IaIya", // 19
144 : "Japanese/IsMatch_KiKu", // 20
145 : "Japanese/IsIgnorePunctuation", // 21
146 : "Japanese/IsIgnoreWhitespace", // 22
147 : "Japanese/IsIgnoreProlongedSoundMark", // 23
148 : "Japanese/IsIgnoreMiddleDot", // 24
149 : "IsNotes", // 25
150 : "IsIgnoreDiacritics_CTL", // 26
151 : "IsIgnoreKashida_CTL" // 27
152 : };
153 :
154 177 : const int nCount = SAL_N_ELEMENTS( aPropNames );
155 177 : Sequence< OUString > aNames( nCount );
156 177 : OUString* pNames = aNames.getArray();
157 5133 : for (sal_Int32 i = 0; i < nCount; ++i)
158 4956 : pNames[i] = OUString::createFromAscii( aPropNames[i] );
159 :
160 177 : return aNames;
161 : }
162 :
163 177 : bool SvtSearchOptions_Impl::Load()
164 : {
165 177 : bool bSucc = false;
166 :
167 177 : Sequence< OUString > aNames = GetPropertyNames();
168 177 : sal_Int32 nProps = aNames.getLength();
169 :
170 354 : const Sequence< Any > aValues = GetProperties( aNames );
171 : DBG_ASSERT( aValues.getLength() == aNames.getLength(),
172 : "GetProperties failed" );
173 : //EnableNotification( aNames );
174 :
175 177 : if (nProps && aValues.getLength() == nProps)
176 : {
177 177 : bSucc = true;
178 :
179 177 : const Any* pValues = aValues.getConstArray();
180 5133 : for (sal_Int32 i = 0; i < nProps; ++i)
181 : {
182 4956 : const Any &rVal = pValues[i];
183 : DBG_ASSERT( rVal.hasValue(), "property value missing" );
184 4956 : if (rVal.hasValue())
185 : {
186 4956 : bool bVal = bool();
187 4956 : if (rVal >>= bVal)
188 : {
189 4956 : if (i <= MAX_FLAGS_OFFSET)
190 : {
191 : // use index in sequence as flag index
192 4956 : SetFlag( i, bVal );
193 : }
194 : else {
195 : OSL_FAIL( "unexpected index" );
196 : }
197 : }
198 : else
199 : {
200 : OSL_FAIL( "unexpected type" );
201 0 : bSucc = false;
202 : }
203 : }
204 : else
205 : {
206 : OSL_FAIL( "value missing" );
207 0 : bSucc = false;
208 : }
209 : }
210 : }
211 : DBG_ASSERT( bSucc, "LoadConfig failed" );
212 :
213 354 : return bSucc;
214 : }
215 :
216 0 : bool SvtSearchOptions_Impl::Save()
217 : {
218 0 : bool bSucc = false;
219 :
220 0 : const Sequence< OUString > aNames = GetPropertyNames();
221 0 : sal_Int32 nProps = aNames.getLength();
222 :
223 0 : Sequence< Any > aValues( nProps );
224 0 : Any *pValue = aValues.getArray();
225 :
226 : DBG_ASSERT( nProps == MAX_FLAGS_OFFSET + 1,
227 : "unexpected size of index" );
228 0 : if (nProps && nProps == MAX_FLAGS_OFFSET + 1)
229 : {
230 0 : for (sal_Int32 i = 0; i < nProps; ++i)
231 0 : pValue[i] <<= GetFlag(i);
232 0 : bSucc |= PutProperties( aNames, aValues );
233 : }
234 :
235 0 : if (bSucc)
236 0 : SetModified( false );
237 :
238 0 : return bSucc;
239 : }
240 :
241 177 : SvtSearchOptions::SvtSearchOptions()
242 : {
243 177 : pImpl = new SvtSearchOptions_Impl;
244 177 : }
245 :
246 177 : SvtSearchOptions::~SvtSearchOptions()
247 : {
248 177 : delete pImpl;
249 177 : }
250 :
251 0 : void SvtSearchOptions::Commit()
252 : {
253 0 : pImpl->Commit();
254 0 : }
255 :
256 0 : sal_Int32 SvtSearchOptions::GetTransliterationFlags() const
257 : {
258 0 : sal_Int32 nRes = 0;
259 :
260 0 : if (!IsMatchCase()) // 'IsMatchCase' means act case sensitive
261 0 : nRes |= TransliterationModules_IGNORE_CASE;
262 0 : if ( IsMatchFullHalfWidthForms())
263 0 : nRes |= TransliterationModules_IGNORE_WIDTH;
264 0 : if ( IsMatchHiraganaKatakana())
265 0 : nRes |= TransliterationModules_IGNORE_KANA;
266 0 : if ( IsMatchContractions())
267 0 : nRes |= TransliterationModules_ignoreSize_ja_JP;
268 0 : if ( IsMatchMinusDashChoon())
269 0 : nRes |= TransliterationModules_ignoreMinusSign_ja_JP;
270 0 : if ( IsMatchRepeatCharMarks())
271 0 : nRes |= TransliterationModules_ignoreIterationMark_ja_JP;
272 0 : if ( IsMatchVariantFormKanji())
273 0 : nRes |= TransliterationModules_ignoreTraditionalKanji_ja_JP;
274 0 : if ( IsMatchOldKanaForms())
275 0 : nRes |= TransliterationModules_ignoreTraditionalKana_ja_JP;
276 0 : if ( IsMatchDiziDuzu())
277 0 : nRes |= TransliterationModules_ignoreZiZu_ja_JP;
278 0 : if ( IsMatchBavaHafa())
279 0 : nRes |= TransliterationModules_ignoreBaFa_ja_JP;
280 0 : if ( IsMatchTsithichiDhizi())
281 0 : nRes |= TransliterationModules_ignoreTiJi_ja_JP;
282 0 : if ( IsMatchHyuiyuByuvyu())
283 0 : nRes |= TransliterationModules_ignoreHyuByu_ja_JP;
284 0 : if ( IsMatchSesheZeje())
285 0 : nRes |= TransliterationModules_ignoreSeZe_ja_JP;
286 0 : if ( IsMatchIaiya())
287 0 : nRes |= TransliterationModules_ignoreIandEfollowedByYa_ja_JP;
288 0 : if ( IsMatchKiku())
289 0 : nRes |= TransliterationModules_ignoreKiKuFollowedBySa_ja_JP;
290 0 : if ( IsIgnorePunctuation())
291 0 : nRes |= TransliterationModules_ignoreSeparator_ja_JP;
292 0 : if ( IsIgnoreWhitespace())
293 0 : nRes |= TransliterationModules_ignoreSpace_ja_JP;
294 0 : if ( IsIgnoreProlongedSoundMark())
295 0 : nRes |= TransliterationModules_ignoreProlongedSoundMark_ja_JP;
296 0 : if ( IsIgnoreMiddleDot())
297 0 : nRes |= TransliterationModules_ignoreMiddleDot_ja_JP;
298 0 : if ( IsIgnoreDiacritics_CTL())
299 0 : nRes |= TransliterationModulesExtra::IGNORE_DIACRITICS_CTL;
300 0 : if ( IsIgnoreKashida_CTL())
301 0 : nRes |= TransliterationModulesExtra::IGNORE_KASHIDA_CTL;
302 0 : return nRes;
303 : }
304 :
305 177 : bool SvtSearchOptions::IsWholeWordsOnly() const
306 : {
307 177 : return pImpl->GetFlag( 0 );
308 : }
309 :
310 0 : void SvtSearchOptions::SetWholeWordsOnly( bool bVal )
311 : {
312 0 : pImpl->SetFlag( 0, bVal );
313 0 : }
314 :
315 177 : bool SvtSearchOptions::IsBackwards() const
316 : {
317 177 : return pImpl->GetFlag( 1 );
318 : }
319 :
320 0 : void SvtSearchOptions::SetBackwards( bool bVal )
321 : {
322 0 : pImpl->SetFlag( 1, bVal );
323 0 : }
324 :
325 177 : bool SvtSearchOptions::IsUseRegularExpression() const
326 : {
327 177 : return pImpl->GetFlag( 2 );
328 : }
329 :
330 0 : void SvtSearchOptions::SetUseRegularExpression( bool bVal )
331 : {
332 0 : pImpl->SetFlag( 2, bVal );
333 0 : }
334 :
335 0 : void SvtSearchOptions::SetSearchForStyles( bool bVal )
336 : {
337 0 : pImpl->SetFlag( 3, bVal );
338 0 : }
339 :
340 177 : bool SvtSearchOptions::IsSimilaritySearch() const
341 : {
342 177 : return pImpl->GetFlag( 4 );
343 : }
344 :
345 0 : void SvtSearchOptions::SetSimilaritySearch( bool bVal )
346 : {
347 0 : pImpl->SetFlag( 4, bVal );
348 0 : }
349 :
350 177 : bool SvtSearchOptions::IsUseAsianOptions() const
351 : {
352 177 : return pImpl->GetFlag( 5 );
353 : }
354 :
355 0 : void SvtSearchOptions::SetUseAsianOptions( bool bVal )
356 : {
357 0 : pImpl->SetFlag( 5, bVal );
358 0 : }
359 :
360 177 : bool SvtSearchOptions::IsMatchCase() const
361 : {
362 177 : return pImpl->GetFlag( 6 );
363 : }
364 :
365 0 : void SvtSearchOptions::SetMatchCase( bool bVal )
366 : {
367 0 : pImpl->SetFlag( 6, bVal );
368 0 : }
369 :
370 177 : bool SvtSearchOptions::IsMatchFullHalfWidthForms() const
371 : {
372 177 : return pImpl->GetFlag( 7 );
373 : }
374 :
375 0 : void SvtSearchOptions::SetMatchFullHalfWidthForms( bool bVal )
376 : {
377 0 : pImpl->SetFlag( 7, bVal );
378 0 : }
379 :
380 0 : bool SvtSearchOptions::IsMatchHiraganaKatakana() const
381 : {
382 0 : return pImpl->GetFlag( 8 );
383 : }
384 :
385 0 : void SvtSearchOptions::SetMatchHiraganaKatakana( bool bVal )
386 : {
387 0 : pImpl->SetFlag( 8, bVal );
388 0 : }
389 :
390 0 : bool SvtSearchOptions::IsMatchContractions() const
391 : {
392 0 : return pImpl->GetFlag( 9 );
393 : }
394 :
395 0 : void SvtSearchOptions::SetMatchContractions( bool bVal )
396 : {
397 0 : pImpl->SetFlag( 9, bVal );
398 0 : }
399 :
400 0 : bool SvtSearchOptions::IsMatchMinusDashChoon() const
401 : {
402 0 : return pImpl->GetFlag( 10 );
403 : }
404 :
405 0 : void SvtSearchOptions::SetMatchMinusDashChoon( bool bVal )
406 : {
407 0 : pImpl->SetFlag( 10, bVal );
408 0 : }
409 :
410 0 : bool SvtSearchOptions::IsMatchRepeatCharMarks() const
411 : {
412 0 : return pImpl->GetFlag( 11 );
413 : }
414 :
415 0 : void SvtSearchOptions::SetMatchRepeatCharMarks( bool bVal )
416 : {
417 0 : pImpl->SetFlag( 11, bVal );
418 0 : }
419 :
420 0 : bool SvtSearchOptions::IsMatchVariantFormKanji() const
421 : {
422 0 : return pImpl->GetFlag( 12 );
423 : }
424 :
425 0 : void SvtSearchOptions::SetMatchVariantFormKanji( bool bVal )
426 : {
427 0 : pImpl->SetFlag( 12, bVal );
428 0 : }
429 :
430 0 : bool SvtSearchOptions::IsMatchOldKanaForms() const
431 : {
432 0 : return pImpl->GetFlag( 13 );
433 : }
434 :
435 0 : void SvtSearchOptions::SetMatchOldKanaForms( bool bVal )
436 : {
437 0 : pImpl->SetFlag( 13, bVal );
438 0 : }
439 :
440 0 : bool SvtSearchOptions::IsMatchDiziDuzu() const
441 : {
442 0 : return pImpl->GetFlag( 14 );
443 : }
444 :
445 0 : void SvtSearchOptions::SetMatchDiziDuzu( bool bVal )
446 : {
447 0 : pImpl->SetFlag( 14, bVal );
448 0 : }
449 :
450 0 : bool SvtSearchOptions::IsMatchBavaHafa() const
451 : {
452 0 : return pImpl->GetFlag( 15 );
453 : }
454 :
455 0 : void SvtSearchOptions::SetMatchBavaHafa( bool bVal )
456 : {
457 0 : pImpl->SetFlag( 15, bVal );
458 0 : }
459 :
460 0 : bool SvtSearchOptions::IsMatchTsithichiDhizi() const
461 : {
462 0 : return pImpl->GetFlag( 16 );
463 : }
464 :
465 0 : void SvtSearchOptions::SetMatchTsithichiDhizi( bool bVal )
466 : {
467 0 : pImpl->SetFlag( 16, bVal );
468 0 : }
469 :
470 0 : bool SvtSearchOptions::IsMatchHyuiyuByuvyu() const
471 : {
472 0 : return pImpl->GetFlag( 17 );
473 : }
474 :
475 0 : void SvtSearchOptions::SetMatchHyuiyuByuvyu( bool bVal )
476 : {
477 0 : pImpl->SetFlag( 17, bVal );
478 0 : }
479 :
480 0 : bool SvtSearchOptions::IsMatchSesheZeje() const
481 : {
482 0 : return pImpl->GetFlag( 18 );
483 : }
484 :
485 0 : void SvtSearchOptions::SetMatchSesheZeje( bool bVal )
486 : {
487 0 : pImpl->SetFlag( 18, bVal );
488 0 : }
489 :
490 0 : bool SvtSearchOptions::IsMatchIaiya() const
491 : {
492 0 : return pImpl->GetFlag( 19 );
493 : }
494 :
495 0 : void SvtSearchOptions::SetMatchIaiya( bool bVal )
496 : {
497 0 : pImpl->SetFlag( 19, bVal );
498 0 : }
499 :
500 0 : bool SvtSearchOptions::IsMatchKiku() const
501 : {
502 0 : return pImpl->GetFlag( 20 );
503 : }
504 :
505 0 : void SvtSearchOptions::SetMatchKiku( bool bVal )
506 : {
507 0 : pImpl->SetFlag( 20, bVal );
508 0 : }
509 :
510 0 : bool SvtSearchOptions::IsIgnorePunctuation() const
511 : {
512 0 : return pImpl->GetFlag( 21 );
513 : }
514 :
515 0 : void SvtSearchOptions::SetIgnorePunctuation( bool bVal )
516 : {
517 0 : pImpl->SetFlag( 21, bVal );
518 0 : }
519 :
520 0 : bool SvtSearchOptions::IsIgnoreWhitespace() const
521 : {
522 0 : return pImpl->GetFlag( 22 );
523 : }
524 :
525 0 : void SvtSearchOptions::SetIgnoreWhitespace( bool bVal )
526 : {
527 0 : pImpl->SetFlag( 22, bVal );
528 0 : }
529 :
530 0 : bool SvtSearchOptions::IsIgnoreProlongedSoundMark() const
531 : {
532 0 : return pImpl->GetFlag( 23 );
533 : }
534 :
535 0 : void SvtSearchOptions::SetIgnoreProlongedSoundMark( bool bVal )
536 : {
537 0 : pImpl->SetFlag( 23, bVal );
538 0 : }
539 :
540 0 : bool SvtSearchOptions::IsIgnoreMiddleDot() const
541 : {
542 0 : return pImpl->GetFlag( 24 );
543 : }
544 :
545 0 : void SvtSearchOptions::SetIgnoreMiddleDot( bool bVal )
546 : {
547 0 : pImpl->SetFlag( 24, bVal );
548 0 : }
549 :
550 177 : bool SvtSearchOptions::IsNotes() const
551 : {
552 177 : return pImpl->GetFlag( 25 );
553 : }
554 :
555 0 : void SvtSearchOptions::SetNotes( bool bVal )
556 : {
557 0 : pImpl->SetFlag( 25, bVal );
558 0 : }
559 :
560 177 : bool SvtSearchOptions::IsIgnoreDiacritics_CTL() const
561 : {
562 177 : return pImpl->GetFlag( 26 );
563 : }
564 :
565 0 : void SvtSearchOptions::SetIgnoreDiacritics_CTL( bool bVal )
566 : {
567 0 : pImpl->SetFlag( 26, bVal );
568 0 : }
569 :
570 177 : bool SvtSearchOptions::IsIgnoreKashida_CTL() const
571 : {
572 177 : return pImpl->GetFlag( 27 );
573 : }
574 :
575 0 : void SvtSearchOptions::SetIgnoreKashida_CTL( bool bVal )
576 : {
577 0 : pImpl->SetFlag( 27, bVal );
578 0 : }
579 :
580 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
