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 <comphelper/string.hxx>
21 : #include <sot/object.hxx>
22 : #include <sot/factory.hxx>
23 : #include <tools/debug.hxx>
24 : #include <tools/bigint.hxx>
25 :
26 : #include <tools/rc.h>
27 :
28 : #include <vcl/event.hxx>
29 : #include <vcl/svapp.hxx>
30 : #include <vcl/longcurr.hxx>
31 :
32 : #include <svdata.hxx>
33 :
34 : #include <unotools/localedatawrapper.hxx>
35 :
36 : using namespace ::comphelper;
37 :
38 : // =======================================================================
39 :
40 : #define FORMAT_LONGCURRENCY 4
41 :
42 : // =======================================================================
43 :
44 0 : static BigInt ImplPower10( sal_uInt16 n )
45 : {
46 : sal_uInt16 i;
47 0 : BigInt nValue = 1;
48 :
49 0 : for ( i=0; i < n; i++ )
50 0 : nValue *= 10;
51 :
52 0 : return nValue;
53 : }
54 :
55 : // -----------------------------------------------------------------------
56 :
57 0 : static XubString ImplGetCurr( const LocaleDataWrapper& rLocaleDataWrapper, const BigInt &rNumber, sal_uInt16 nDigits, const String& rCurrSymbol, sal_Bool bShowThousandSep )
58 : {
59 : DBG_ASSERT( nDigits < 10, "LongCurrency duerfen nur maximal 9 Nachkommastellen haben" );
60 :
61 0 : if ( rNumber.IsZero() || (long)rNumber )
62 0 : return rLocaleDataWrapper.getCurr( (long)rNumber, nDigits, rCurrSymbol, bShowThousandSep );
63 :
64 0 : BigInt aTmp( ImplPower10( nDigits ) );
65 0 : BigInt aInteger( rNumber );
66 0 : aInteger.Abs();
67 0 : aInteger /= aTmp;
68 0 : BigInt aFraction( rNumber );
69 0 : aFraction.Abs();
70 0 : aFraction %= aTmp;
71 0 : if ( !aInteger.IsZero() )
72 : {
73 0 : aFraction += aTmp;
74 0 : aTmp = 1000000000L;
75 : }
76 0 : if ( rNumber.IsNeg() )
77 0 : aFraction *= -1;
78 :
79 0 : XubString aTemplate = rLocaleDataWrapper.getCurr( (long)aFraction, nDigits, rCurrSymbol, bShowThousandSep );
80 0 : while( !aInteger.IsZero() )
81 : {
82 0 : aFraction = aInteger;
83 0 : aFraction %= aTmp;
84 0 : aInteger /= aTmp;
85 0 : if( !aInteger.IsZero() )
86 0 : aFraction += aTmp;
87 :
88 0 : XubString aFractionStr = rLocaleDataWrapper.getNum( (long)aFraction, 0 );
89 :
90 0 : xub_StrLen nSPos = aTemplate.Search( '1' );
91 0 : if ( aFractionStr.Len() == 1 )
92 0 : aTemplate.SetChar( nSPos, aFractionStr.GetChar( 0 ) );
93 : else
94 : {
95 0 : aTemplate.Erase( nSPos, 1 );
96 0 : aTemplate.Insert( aFractionStr, nSPos );
97 : }
98 0 : }
99 :
100 0 : return aTemplate;
101 : }
102 :
103 : // -----------------------------------------------------------------------
104 :
105 0 : static sal_Bool ImplNumericProcessKeyInput( Edit*, const KeyEvent& rKEvt,
106 : sal_Bool bStrictFormat, sal_Bool bThousandSep,
107 : const LocaleDataWrapper& rLocaleDataWrapper )
108 : {
109 0 : if ( !bStrictFormat )
110 0 : return sal_False;
111 : else
112 : {
113 0 : sal_Unicode cChar = rKEvt.GetCharCode();
114 0 : sal_uInt16 nGroup = rKEvt.GetKeyCode().GetGroup();
115 :
116 0 : if ( (nGroup == KEYGROUP_FKEYS) || (nGroup == KEYGROUP_CURSOR) ||
117 : (nGroup == KEYGROUP_MISC) ||
118 : ((cChar >= '0') && (cChar <= '9')) ||
119 0 : (bThousandSep && string::equals(rLocaleDataWrapper.getNumThousandSep(), cChar)) ||
120 0 : (string::equals(rLocaleDataWrapper.getNumDecimalSep(), cChar) ) ||
121 : (cChar == '-') )
122 0 : return sal_False;
123 : else
124 0 : return sal_True;
125 : }
126 : }
127 :
128 : // -----------------------------------------------------------------------
129 :
130 0 : static sal_Bool ImplNumericGetValue( const XubString& rStr, BigInt& rValue,
131 : sal_uInt16 nDecDigits, const LocaleDataWrapper& rLocaleDataWrapper,
132 : sal_Bool bCurrency = sal_False )
133 : {
134 0 : XubString aStr = rStr;
135 0 : XubString aStr1;
136 0 : rtl::OUStringBuffer aStr2;
137 : sal_uInt16 nDecPos;
138 0 : sal_Bool bNegative = sal_False;
139 :
140 : // Reaktion auf leeren String
141 0 : if ( !rStr.Len() )
142 0 : return sal_False;
143 :
144 : // Fuehrende und nachfolgende Leerzeichen entfernen
145 0 : aStr = string::strip(aStr, ' ');
146 :
147 : // Position des Dezimalpunktes suchen
148 0 : nDecPos = aStr.Search( rLocaleDataWrapper.getNumDecimalSep() );
149 :
150 0 : if ( nDecPos != STRING_NOTFOUND )
151 : {
152 0 : aStr1 = aStr.Copy( 0, nDecPos );
153 0 : aStr2.append(aStr.Copy(nDecPos+1));
154 : }
155 : else
156 0 : aStr1 = aStr;
157 :
158 : // Negativ ?
159 0 : if ( bCurrency )
160 : {
161 0 : if ( (aStr.GetChar( 0 ) == '(') && (aStr.GetChar( aStr.Len()-1 ) == ')') )
162 0 : bNegative = sal_True;
163 0 : if ( !bNegative )
164 : {
165 0 : for (xub_StrLen i=0; i < aStr.Len(); i++ )
166 : {
167 0 : if ( (aStr.GetChar( i ) >= '0') && (aStr.GetChar( i ) <= '9') )
168 0 : break;
169 0 : else if ( aStr.GetChar( i ) == '-' )
170 : {
171 0 : bNegative = sal_True;
172 0 : break;
173 : }
174 : }
175 : }
176 0 : if ( !bNegative && bCurrency && aStr.Len() )
177 : {
178 0 : sal_uInt16 nFormat = rLocaleDataWrapper.getCurrNegativeFormat();
179 0 : if ( (nFormat == 3) || (nFormat == 6) ||
180 : (nFormat == 7) || (nFormat == 10) )
181 : {
182 0 : for (xub_StrLen i = (sal_uInt16)(aStr.Len()-1); i > 0; i++ )
183 : {
184 0 : if ( (aStr.GetChar( i ) >= '0') && (aStr.GetChar( i ) <= '9') )
185 0 : break;
186 0 : else if ( aStr.GetChar( i ) == '-' )
187 : {
188 0 : bNegative = sal_True;
189 0 : break;
190 : }
191 : }
192 : }
193 : }
194 : }
195 : else
196 : {
197 0 : if ( aStr1.GetChar( 0 ) == '-' )
198 0 : bNegative = sal_True;
199 : }
200 :
201 : // Alle unerwuenschten Zeichen rauswerfen
202 0 : for (xub_StrLen i=0; i < aStr1.Len(); )
203 : {
204 0 : if ( (aStr1.GetChar( i ) >= '0') && (aStr1.GetChar( i ) <= '9') )
205 0 : i++;
206 : else
207 0 : aStr1.Erase( i, 1 );
208 : }
209 0 : for (sal_Int32 i=0; i < aStr2.getLength();)
210 : {
211 0 : if ((aStr2[i] >= '0') && (aStr2[i] <= '9'))
212 0 : ++i;
213 : else
214 0 : aStr2.remove(i, 1);
215 : }
216 :
217 0 : if (!aStr1.Len() && !aStr2.getLength())
218 0 : return sal_False;
219 :
220 0 : if ( !aStr1.Len() )
221 0 : aStr1.Insert( '0' );
222 0 : if ( bNegative )
223 0 : aStr1.Insert( '-', 0 );
224 :
225 : // Nachkommateil zurechtstutzen und dabei runden
226 0 : bool bRound = false;
227 0 : if (aStr2.getLength() > nDecDigits)
228 : {
229 0 : if (aStr2[nDecDigits] >= '5')
230 0 : bRound = true;
231 0 : string::truncateToLength(aStr2, nDecDigits);
232 : }
233 0 : if (aStr2.getLength() < nDecDigits)
234 0 : string::padToLength(aStr2, nDecDigits, '0');
235 :
236 0 : aStr = aStr1;
237 0 : aStr += aStr2.makeStringAndClear();
238 :
239 : // Bereichsueberpruefung
240 0 : BigInt nValue( aStr );
241 0 : if ( bRound )
242 : {
243 0 : if ( !bNegative )
244 0 : nValue+=1;
245 : else
246 0 : nValue-=1;
247 : }
248 :
249 0 : rValue = nValue;
250 :
251 0 : return sal_True;
252 : }
253 :
254 : // =======================================================================
255 :
256 0 : static sal_Bool ImplLongCurrencyProcessKeyInput( Edit* pEdit, const KeyEvent& rKEvt,
257 : sal_Bool, sal_Bool bUseThousandSep, const LocaleDataWrapper& rLocaleDataWrapper )
258 : {
259 : // Es gibt hier kein sinnvolles StrictFormat, also alle
260 : // Zeichen erlauben
261 0 : return ImplNumericProcessKeyInput( pEdit, rKEvt, sal_False, bUseThousandSep, rLocaleDataWrapper );
262 : }
263 :
264 : // -----------------------------------------------------------------------
265 :
266 0 : inline sal_Bool ImplLongCurrencyGetValue( const XubString& rStr, BigInt& rValue,
267 : sal_uInt16 nDecDigits, const LocaleDataWrapper& rLocaleDataWrapper )
268 : {
269 : // Zahlenwert holen
270 0 : return ImplNumericGetValue( rStr, rValue, nDecDigits, rLocaleDataWrapper, sal_True );
271 : }
272 :
273 : // -----------------------------------------------------------------------
274 :
275 0 : sal_Bool ImplLongCurrencyReformat( const XubString& rStr, BigInt nMin, BigInt nMax,
276 : sal_uInt16 nDecDigits,
277 : const LocaleDataWrapper& rLocaleDataWrapper, String& rOutStr,
278 : LongCurrencyFormatter& rFormatter )
279 : {
280 0 : BigInt nValue;
281 0 : if ( !ImplNumericGetValue( rStr, nValue, nDecDigits, rLocaleDataWrapper, sal_True ) )
282 0 : return sal_True;
283 : else
284 : {
285 0 : BigInt nTempVal = nValue;
286 0 : if ( nTempVal > nMax )
287 0 : nTempVal = nMax;
288 0 : else if ( nTempVal < nMin )
289 0 : nTempVal = nMin;
290 :
291 0 : if ( rFormatter.GetErrorHdl().IsSet() && (nValue != nTempVal) )
292 : {
293 0 : rFormatter.mnCorrectedValue = nTempVal;
294 0 : if ( !rFormatter.GetErrorHdl().Call( &rFormatter ) )
295 : {
296 0 : rFormatter.mnCorrectedValue = 0;
297 0 : return sal_False;
298 : }
299 : else
300 : {
301 0 : rFormatter.mnCorrectedValue = 0;
302 : }
303 : }
304 :
305 0 : rOutStr = ImplGetCurr( rLocaleDataWrapper, nTempVal, nDecDigits, rFormatter.GetCurrencySymbol(), rFormatter.IsUseThousandSep() );
306 0 : return sal_True;
307 : }
308 : }
309 :
310 :
311 : // =======================================================================
312 :
313 0 : void LongCurrencyFormatter::ImpInit()
314 : {
315 0 : mnFieldValue = 0;
316 0 : mnLastValue = 0;
317 0 : mnMin = 0;
318 0 : mnMax = 0x7FFFFFFF;
319 0 : mnMax *= 0x7FFFFFFF;
320 0 : mnCorrectedValue = 0;
321 0 : mnDecimalDigits = 0;
322 0 : mnType = FORMAT_LONGCURRENCY;
323 0 : mbThousandSep = sal_True;
324 0 : SetDecimalDigits( 0 );
325 0 : }
326 :
327 : // -----------------------------------------------------------------------
328 :
329 0 : LongCurrencyFormatter::LongCurrencyFormatter()
330 : {
331 0 : ImpInit();
332 0 : }
333 :
334 : // -----------------------------------------------------------------------
335 :
336 0 : LongCurrencyFormatter::~LongCurrencyFormatter()
337 : {
338 0 : }
339 :
340 : // -----------------------------------------------------------------------
341 :
342 0 : void LongCurrencyFormatter::SetCurrencySymbol( const String& rStr )
343 : {
344 0 : maCurrencySymbol= rStr;
345 0 : ReformatAll();
346 0 : }
347 :
348 : // -----------------------------------------------------------------------
349 :
350 0 : String LongCurrencyFormatter::GetCurrencySymbol() const
351 : {
352 0 : return !maCurrencySymbol.isEmpty() ? maCurrencySymbol : GetLocaleDataWrapper().getCurrSymbol();
353 : }
354 :
355 : // -----------------------------------------------------------------------
356 :
357 0 : void LongCurrencyFormatter::SetValue( BigInt nNewValue )
358 : {
359 0 : SetUserValue( nNewValue );
360 0 : mnFieldValue = mnLastValue;
361 0 : SetEmptyFieldValueData( sal_False );
362 0 : }
363 :
364 : // -----------------------------------------------------------------------
365 :
366 0 : void LongCurrencyFormatter::SetUserValue( BigInt nNewValue )
367 : {
368 0 : if ( nNewValue > mnMax )
369 0 : nNewValue = mnMax;
370 0 : else if ( nNewValue < mnMin )
371 0 : nNewValue = mnMin;
372 0 : mnLastValue = nNewValue;
373 :
374 0 : if ( !GetField() )
375 0 : return;
376 :
377 0 : XubString aStr = ImplGetCurr( GetLocaleDataWrapper(), nNewValue, GetDecimalDigits(), GetCurrencySymbol(), IsUseThousandSep() );
378 0 : if ( GetField()->HasFocus() )
379 : {
380 0 : Selection aSelection = GetField()->GetSelection();
381 0 : GetField()->SetText( aStr );
382 0 : GetField()->SetSelection( aSelection );
383 : }
384 : else
385 0 : GetField()->SetText( aStr );
386 0 : MarkToBeReformatted( sal_False );
387 : }
388 :
389 : // -----------------------------------------------------------------------
390 :
391 0 : BigInt LongCurrencyFormatter::GetValue() const
392 : {
393 0 : if ( !GetField() )
394 0 : return 0;
395 :
396 0 : BigInt nTempValue;
397 0 : if ( ImplLongCurrencyGetValue( GetField()->GetText(), nTempValue, GetDecimalDigits(), GetLocaleDataWrapper() ) )
398 : {
399 0 : if ( nTempValue > mnMax )
400 0 : nTempValue = mnMax;
401 0 : else if ( nTempValue < mnMin )
402 0 : nTempValue = mnMin;
403 0 : return nTempValue;
404 : }
405 : else
406 0 : return mnLastValue;
407 : }
408 :
409 : // -----------------------------------------------------------------------
410 :
411 0 : void LongCurrencyFormatter::Reformat()
412 : {
413 0 : if ( !GetField() )
414 : return;
415 :
416 0 : if ( !GetField()->GetText().Len() && ImplGetEmptyFieldValue() )
417 : return;
418 :
419 0 : XubString aStr;
420 0 : sal_Bool bOK = ImplLongCurrencyReformat( GetField()->GetText(), mnMin, mnMax,
421 0 : GetDecimalDigits(), GetLocaleDataWrapper(), aStr, *this );
422 0 : if ( !bOK )
423 : return;
424 :
425 0 : if ( aStr.Len() )
426 : {
427 0 : GetField()->SetText( aStr );
428 0 : MarkToBeReformatted( sal_False );
429 0 : ImplLongCurrencyGetValue( aStr, mnLastValue, GetDecimalDigits(), GetLocaleDataWrapper() );
430 : }
431 : else
432 0 : SetValue( mnLastValue );
433 : }
434 :
435 : // -----------------------------------------------------------------------
436 :
437 0 : void LongCurrencyFormatter::ReformatAll()
438 : {
439 0 : Reformat();
440 0 : }
441 :
442 : // -----------------------------------------------------------------------
443 :
444 0 : void LongCurrencyFormatter::SetMin( BigInt nNewMin )
445 : {
446 0 : mnMin = nNewMin;
447 0 : ReformatAll();
448 0 : }
449 :
450 : // -----------------------------------------------------------------------
451 :
452 0 : void LongCurrencyFormatter::SetMax( BigInt nNewMax )
453 : {
454 0 : mnMax = nNewMax;
455 0 : ReformatAll();
456 0 : }
457 :
458 : // -----------------------------------------------------------------------
459 :
460 0 : void LongCurrencyFormatter::SetUseThousandSep( sal_Bool b )
461 : {
462 0 : mbThousandSep = b;
463 0 : ReformatAll();
464 0 : }
465 :
466 :
467 : // -----------------------------------------------------------------------
468 :
469 0 : void LongCurrencyFormatter::SetDecimalDigits( sal_uInt16 nDigits )
470 : {
471 : // DBG_ASSERT( nDigits < 10, "LongCurrency duerfen nur maximal 9 Nachkommastellen haben" );
472 :
473 0 : if ( nDigits > 9 )
474 0 : nDigits = 9;
475 :
476 0 : mnDecimalDigits = nDigits;
477 0 : ReformatAll();
478 0 : }
479 :
480 : // -----------------------------------------------------------------------
481 :
482 0 : sal_uInt16 LongCurrencyFormatter::GetDecimalDigits() const
483 : {
484 0 : return mnDecimalDigits;
485 : }
486 :
487 : // =======================================================================
488 :
489 0 : void ImplNewLongCurrencyFieldValue( LongCurrencyField* pField, BigInt nNewValue )
490 : {
491 0 : Selection aSelect = pField->GetSelection();
492 0 : aSelect.Justify();
493 0 : XubString aText = pField->GetText();
494 0 : sal_Bool bLastSelected = ((xub_StrLen)aSelect.Max() == aText.Len()) ? sal_True : sal_False;
495 :
496 0 : BigInt nOldLastValue = pField->mnLastValue;
497 0 : pField->SetUserValue( nNewValue );
498 0 : pField->mnLastValue = nOldLastValue;
499 :
500 0 : if ( bLastSelected )
501 : {
502 0 : if ( !aSelect.Len() )
503 0 : aSelect.Min() = SELECTION_MAX;
504 0 : aSelect.Max() = SELECTION_MAX;
505 : }
506 0 : pField->SetSelection( aSelect );
507 0 : pField->SetModifyFlag();
508 0 : pField->Modify();
509 0 : }
510 :
511 : // =======================================================================
512 :
513 0 : LongCurrencyField::LongCurrencyField( Window* pParent, WinBits nWinStyle ) :
514 0 : SpinField( pParent, nWinStyle )
515 : {
516 0 : SetField( this );
517 0 : mnSpinSize = 1;
518 0 : mnFirst = mnMin;
519 0 : mnLast = mnMax;
520 :
521 0 : Reformat();
522 0 : }
523 :
524 : // -----------------------------------------------------------------------
525 :
526 0 : LongCurrencyField::~LongCurrencyField()
527 : {
528 0 : }
529 :
530 : // -----------------------------------------------------------------------
531 :
532 0 : long LongCurrencyField::PreNotify( NotifyEvent& rNEvt )
533 : {
534 0 : if( rNEvt.GetType() == EVENT_KEYINPUT )
535 : {
536 0 : if ( ImplLongCurrencyProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), GetLocaleDataWrapper() ) )
537 0 : return 1;
538 : }
539 0 : return SpinField::PreNotify( rNEvt );
540 : }
541 :
542 : // -----------------------------------------------------------------------
543 :
544 0 : long LongCurrencyField::Notify( NotifyEvent& rNEvt )
545 : {
546 0 : if( rNEvt.GetType() == EVENT_GETFOCUS )
547 : {
548 0 : MarkToBeReformatted( sal_False );
549 : }
550 0 : else if( rNEvt.GetType() == EVENT_LOSEFOCUS )
551 : {
552 0 : if ( MustBeReformatted() )
553 : {
554 0 : Reformat();
555 0 : SpinField::Modify();
556 : }
557 : }
558 0 : return SpinField::Notify( rNEvt );
559 : }
560 :
561 : // -----------------------------------------------------------------------
562 :
563 0 : void LongCurrencyField::Modify()
564 : {
565 0 : MarkToBeReformatted( sal_True );
566 0 : SpinField::Modify();
567 0 : }
568 :
569 : // -----------------------------------------------------------------------
570 :
571 0 : void LongCurrencyField::Up()
572 : {
573 0 : BigInt nValue = GetValue();
574 0 : nValue += mnSpinSize;
575 0 : if ( nValue > mnMax )
576 0 : nValue = mnMax;
577 :
578 0 : ImplNewLongCurrencyFieldValue( this, nValue );
579 0 : SpinField::Up();
580 0 : }
581 :
582 : // -----------------------------------------------------------------------
583 :
584 0 : void LongCurrencyField::Down()
585 : {
586 0 : BigInt nValue = GetValue();
587 0 : nValue -= mnSpinSize;
588 0 : if ( nValue < mnMin )
589 0 : nValue = mnMin;
590 :
591 0 : ImplNewLongCurrencyFieldValue( this, nValue );
592 0 : SpinField::Down();
593 0 : }
594 :
595 : // -----------------------------------------------------------------------
596 :
597 0 : void LongCurrencyField::First()
598 : {
599 0 : ImplNewLongCurrencyFieldValue( this, mnFirst );
600 0 : SpinField::First();
601 0 : }
602 :
603 : // -----------------------------------------------------------------------
604 :
605 0 : void LongCurrencyField::Last()
606 : {
607 0 : ImplNewLongCurrencyFieldValue( this, mnLast );
608 0 : SpinField::Last();
609 0 : }
610 :
611 : // =======================================================================
612 :
613 0 : LongCurrencyBox::LongCurrencyBox( Window* pParent, WinBits nWinStyle ) :
614 0 : ComboBox( pParent, nWinStyle )
615 : {
616 0 : SetField( this );
617 0 : Reformat();
618 0 : }
619 :
620 : // -----------------------------------------------------------------------
621 :
622 0 : LongCurrencyBox::~LongCurrencyBox()
623 : {
624 0 : }
625 :
626 : // -----------------------------------------------------------------------
627 :
628 0 : long LongCurrencyBox::PreNotify( NotifyEvent& rNEvt )
629 : {
630 0 : if( rNEvt.GetType() == EVENT_KEYINPUT )
631 : {
632 0 : if ( ImplLongCurrencyProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), GetLocaleDataWrapper() ) )
633 0 : return 1;
634 : }
635 0 : return ComboBox::PreNotify( rNEvt );
636 : }
637 :
638 : // -----------------------------------------------------------------------
639 :
640 0 : long LongCurrencyBox::Notify( NotifyEvent& rNEvt )
641 : {
642 0 : if( rNEvt.GetType() == EVENT_GETFOCUS )
643 : {
644 0 : MarkToBeReformatted( sal_False );
645 : }
646 0 : else if( rNEvt.GetType() == EVENT_LOSEFOCUS )
647 : {
648 0 : if ( MustBeReformatted() )
649 : {
650 0 : Reformat();
651 0 : ComboBox::Modify();
652 : }
653 : }
654 0 : return ComboBox::Notify( rNEvt );
655 : }
656 :
657 : // -----------------------------------------------------------------------
658 :
659 0 : void LongCurrencyBox::Modify()
660 : {
661 0 : MarkToBeReformatted( sal_True );
662 0 : ComboBox::Modify();
663 0 : }
664 :
665 : // -----------------------------------------------------------------------
666 :
667 0 : void LongCurrencyBox::ReformatAll()
668 : {
669 0 : XubString aStr;
670 0 : SetUpdateMode( sal_False );
671 0 : sal_uInt16 nEntryCount = GetEntryCount();
672 0 : for ( sal_uInt16 i=0; i < nEntryCount; i++ )
673 : {
674 : ImplLongCurrencyReformat( GetEntry( i ), mnMin, mnMax,
675 0 : GetDecimalDigits(), GetLocaleDataWrapper(),
676 0 : aStr, *this );
677 0 : RemoveEntry( i );
678 0 : InsertEntry( aStr, i );
679 : }
680 0 : LongCurrencyFormatter::Reformat();
681 0 : SetUpdateMode( sal_True );
682 0 : }
683 :
684 : // =======================================================================
685 :
686 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
