vcl/source/control/field.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: field.cxx,v $
  10  * $Revision: 1.26.86.1 $
  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_vcl.hxx"
  33
  34 #ifndef _BIGINT_HXX
  35 #define _TOOLS_BIGINT
  36 #include "tools/bigint.hxx"
  37 #endif
  38
  39 #include "tools/debug.hxx"
  40
  41 #include "tools/rc.h"
  42 #include "tools/resary.hxx"
  43 #include "vcl/svids.hrc"
  44 #include "vcl/field.hxx"
  45 #include "vcl/event.hxx"
  46 #include "vcl/svapp.hxx"
  47 #include "vcl/svdata.hxx"
  48 #include "vcl/unohelp.hxx"
  49 #include "i18nutil/unicode.hxx"
  50
  51 #include "rtl/math.hxx"
  52
  53
  54 #include <unotools/localedatawrapper.hxx>
  55
  56 using namespace ::com::sun::star;
  57
  58 static ResStringArray *strAllUnits = NULL;
  59
  60 // -----------------------------------------------------------------------
  61
  62 #define FORMAT_NUMERIC       1
  63 #define FORMAT_METRIC        2
  64 #define FORMAT_CURRENCY      3
  65
  66 // -----------------------------------------------------------------------
  67
  68 static sal_Int64 ImplPower10( USHORT n )
  69 {
  70     USHORT i;
  71     sal_Int64   nValue = 1;
  72
  73     for ( i=0; i < n; i++ )
  74         nValue *= 10;
  75
  76     return nValue;
  77 }
  78
  79 // -----------------------------------------------------------------------
  80
  81 static BOOL ImplNumericProcessKeyInput( Edit*, const KeyEvent& rKEvt,
  82                                         BOOL bStrictFormat, BOOL bThousandSep,
  83                                         const LocaleDataWrapper& rLocaleDataWrappper )
  84 {
  85     if ( !bStrictFormat )
  86         return FALSE;
  87     else
  88     {
  89         xub_Unicode cChar = rKEvt.GetCharCode();
  90         USHORT      nGroup = rKEvt.GetKeyCode().GetGroup();
  91
  92         if ( (nGroup == KEYGROUP_FKEYS) || (nGroup == KEYGROUP_CURSOR) ||
  93              (nGroup == KEYGROUP_MISC) ||
  94              ((cChar >= '0') && (cChar <= '9')) ||
  95              (cChar == rLocaleDataWrappper.getNumDecimalSep() ) ||
  96              (bThousandSep && (cChar == rLocaleDataWrappper.getNumThousandSep())) ||
  97              (cChar == '-') )
  98             return FALSE;
  99         else
 100             return TRUE;
 101     }
 102 }
 103
 104 // -----------------------------------------------------------------------
 105
 106 static BOOL ImplNumericGetValue( const XubString& rStr, double& rValue,
 107                                  USHORT nDecDigits, const LocaleDataWrapper& rLocaleDataWrappper,
 108                                  BOOL bCurrency = FALSE )
 109 {
 110     XubString   aStr = rStr;
 111     XubString   aStr1;
 112     XubString   aStr2;
 113     BOOL        bNegative = FALSE;
 114     xub_StrLen  nDecPos;
 115     xub_StrLen  i;
 116
 117     // Reaktion auf leeren String
 118     if ( !rStr.Len() )
 119         return FALSE;
 120
 121     // Fuehrende und nachfolgende Leerzeichen entfernen
 122     aStr.EraseLeadingAndTrailingChars( ' ' );
 123
 124     // Position des Dezimalpunktes suchen
 125     nDecPos = aStr.Search( rLocaleDataWrappper.getNumDecimalSep() );
 126     if ( nDecPos != STRING_NOTFOUND )
 127     {
 128         aStr1 = aStr.Copy( 0, nDecPos );
 129         aStr2 = aStr.Copy( nDecPos+1 );
 130     }
 131     else
 132         aStr1 = aStr;
 133
 134     // Negativ ?
 135     if ( bCurrency )
 136     {
 137         if ( (aStr.GetChar( 0 ) == '(') && (aStr.GetChar( aStr.Len()-1 ) == ')') )
 138             bNegative = TRUE;
 139         if ( !bNegative )
 140         {
 141             for ( i=0; i < aStr.Len(); i++ )
 142             {
 143                 if ( (aStr.GetChar( i ) >= '0') && (aStr.GetChar( i ) <= '9') )
 144                     break;
 145                 else if ( aStr.GetChar( i ) == '-' )
 146                 {
 147                     bNegative = TRUE;
 148                     break;
 149                 }
 150             }
 151         }
 152         if ( !bNegative && bCurrency && aStr.Len() )
 153         {
 154             USHORT nFormat = rLocaleDataWrappper.getCurrNegativeFormat();
 155             if ( (nFormat == 3) || (nFormat == 6)  ||
 156                  (nFormat == 7) || (nFormat == 10) )
 157             {
 158                 for ( i = (xub_StrLen)(aStr.Len()-1); i > 0; i++ )
 159                 {
 160                     if ( (aStr.GetChar( i ) >= '0') && (aStr.GetChar( i ) <= '9') )
 161                         break;
 162                     else if ( aStr.GetChar( i ) == '-' )
 163                     {
 164                         bNegative = TRUE;
 165                         break;
 166                     }
 167                 }
 168             }
 169         }
 170     }
 171     else
 172     {
 173         if ( aStr1.GetChar( 0 ) == '-' )
 174             bNegative = TRUE;
 175     }
 176
 177     // Alle unerwuenschten Zeichen rauswerfen
 178     for ( i=0; i < aStr1.Len(); )
 179     {
 180         if ( (aStr1.GetChar( i ) >= '0') && (aStr1.GetChar( i ) <= '9') )
 181             i++;
 182         else
 183             aStr1.Erase( i, 1 );
 184     }
 185     for ( i=0; i < aStr2.Len(); )
 186     {
 187         if ( (aStr2.GetChar( i ) >= '0') && (aStr2.GetChar( i ) <= '9') )
 188             i++;
 189         else
 190             aStr2.Erase( i, 1 );
 191     }
 192
 193     if ( !aStr1.Len() && !aStr2.Len() )
 194         return FALSE;
 195
 196     if ( !aStr1.Len() )
 197         aStr1.Insert( '0' );
 198     if ( bNegative )
 199         aStr1.Insert( '-', 0 );
 200
 201     // Nachkommateil zurechtstutzen und dabei runden
 202     BOOL bRound = FALSE;
 203     if ( aStr2.Len() > nDecDigits )
 204     {
 205         if ( aStr2.GetChar( nDecDigits ) >= '5' )
 206             bRound = TRUE;
 207         aStr2.Erase( nDecDigits );
 208     }
 209     if ( aStr2.Len() < nDecDigits )
 210         aStr2.Expand( nDecDigits, '0' );
 211
 212     aStr  = aStr1;
 213     aStr += aStr2;
 214
 215     // Bereichsueberpruefung
 216     double nValue = aStr.ToDouble();
 217     if ( bRound )
 218     {
 219         if ( !bNegative )
 220             nValue++;
 221         else
 222             nValue--;
 223     }
 224
 225     rValue = nValue;
 226
 227     return TRUE;
 228 }
 229
 230 static void ImplUpdateSeparators( const String& rOldDecSep, const String& rNewDecSep,
 231                                   const String& rOldThSep, const String& rNewThSep,
 232                                   Edit* pEdit )
 233 {
 234     bool bChangeDec = (rOldDecSep != rNewDecSep);
 235     bool bChangeTh = (rOldThSep != rNewThSep );
 236
 237     if( bChangeDec || bChangeTh )
 238     {
 239         BOOL bUpdateMode = pEdit->IsUpdateMode();
 240         pEdit->SetUpdateMode( FALSE );
 241         String aText = pEdit->GetText();
 242         if( bChangeDec )
 243             aText.SearchAndReplaceAll( rNewDecSep, rOldDecSep );
 244         if( bChangeTh )
 245             aText.SearchAndReplaceAll( rNewThSep, rOldThSep );
 246         pEdit->SetText( aText );
 247
 248         ComboBox* pCombo = dynamic_cast<ComboBox*>(pEdit);
 249         if( pCombo )
 250         {
 251             // update box entries
 252             USHORT nEntryCount = pCombo->GetEntryCount();
 253             for ( USHORT i=0; i < nEntryCount; i++ )
 254             {
 255                 aText = pCombo->GetEntry( i );
 256                 if( bChangeDec )
 257                     aText.SearchAndReplaceAll( rNewDecSep, rOldDecSep );
 258                 if( bChangeTh )
 259                     aText.SearchAndReplaceAll( rNewThSep, rOldThSep );
 260                 pCombo->RemoveEntry( i );
 261                 pCombo->InsertEntry( aText, i );
 262             }
 263         }
 264         if( bUpdateMode )
 265             pEdit->SetUpdateMode( bUpdateMode );
 266     }
 267 }
 268
 269 // -----------------------------------------------------------------------
 270
 271 FormatterBase::FormatterBase( Edit* pField )
 272 {
 273     mpField                     = pField;
 274     mpLocaleDataWrapper         = NULL;
 275     mbReformat                  = FALSE;
 276     mbStrictFormat              = FALSE;
 277     mbEmptyFieldValue           = FALSE;
 278     mbEmptyFieldValueEnabled    = FALSE;
 279     mbDefaultLocale             = TRUE;
 280 }
 281
 282 // -----------------------------------------------------------------------
 283
 284 FormatterBase::~FormatterBase()
 285 {
 286     delete mpLocaleDataWrapper;
 287 }
 288
 289 // -----------------------------------------------------------------------
 290
 291 LocaleDataWrapper& FormatterBase::ImplGetLocaleDataWrapper() const
 292 {
 293     if ( !mpLocaleDataWrapper )
 294     {
 295         ((FormatterBase*)this)->mpLocaleDataWrapper = new LocaleDataWrapper( vcl::unohelper::GetMultiServiceFactory(), GetLocale() );
 296     }
 297     return *mpLocaleDataWrapper;
 298 }
 299
 300 const LocaleDataWrapper& FormatterBase::GetLocaleDataWrapper() const
 301 {
 302     return ImplGetLocaleDataWrapper();
 303 }
 304
 305 // -----------------------------------------------------------------------
 306
 307 void FormatterBase::Reformat()
 308 {
 309 }
 310
 311 // -----------------------------------------------------------------------
 312
 313 void FormatterBase::ReformatAll()
 314 {
 315     Reformat();
 316 };
 317
 318 // -----------------------------------------------------------------------
 319
 320 void FormatterBase::SetStrictFormat( BOOL bStrict )
 321 {
 322     if ( bStrict != mbStrictFormat )
 323     {
 324         mbStrictFormat = bStrict;
 325         if ( mbStrictFormat )
 326             ReformatAll();
 327     }
 328 }
 329
 330 // -----------------------------------------------------------------------
 331
 332 void FormatterBase::SetLocale( const lang::Locale& rLocale )
 333 {
 334     ImplGetLocaleDataWrapper().setLocale( rLocale );
 335     mbDefaultLocale = FALSE;
 336     ReformatAll();
 337 }
 338
 339 // -----------------------------------------------------------------------
 340
 341 const lang::Locale& FormatterBase::GetLocale() const
 342 {
 343     if ( !mpLocaleDataWrapper || mbDefaultLocale )
 344     {
 345         if ( mpField )
 346             return mpField->GetSettings().GetLocale();
 347         else
 348             return Application::GetSettings().GetLocale();
 349     }
 350
 351     return mpLocaleDataWrapper->getLocale();
 352 }
 353
 354 // -----------------------------------------------------------------------
 355
 356 const AllSettings& FormatterBase::GetFieldSettings() const
 357 {
 358     if ( mpField )
 359         return mpField->GetSettings();
 360     else
 361         return Application::GetSettings();
 362 }
 363
 364 // -----------------------------------------------------------------------
 365
 366 void FormatterBase::SetFieldText( const XubString& rText, BOOL bKeepSelection )
 367 {
 368     if ( mpField )
 369     {
 370         Selection aNewSelection( 0xFFFF, 0xFFFF );
 371         if ( bKeepSelection )
 372             aNewSelection = mpField->GetSelection();
 373
 374         ImplSetText( rText, &aNewSelection );
 375     }
 376 }
 377
 378 // -----------------------------------------------------------------------
 379
 380 void FormatterBase::ImplSetText( const XubString& rText, Selection* pNewSelection )
 381 {
 382     if ( mpField )
 383     {
 384         if ( pNewSelection )
 385             mpField->SetText( rText, *pNewSelection );
 386         else
 387         {
 388             Selection aSel = mpField->GetSelection();
 389             aSel.Min() = aSel.Max();
 390             mpField->SetText( rText, aSel );
 391         }
 392
 393         MarkToBeReformatted( FALSE );
 394     }
 395 }
 396
 397 // -----------------------------------------------------------------------
 398
 399 void FormatterBase::SetEmptyFieldValue()
 400 {
 401     if ( mpField )
 402         mpField->SetText( ImplGetSVEmptyStr() );
 403     mbEmptyFieldValue = TRUE;
 404 }
 405
 406 // -----------------------------------------------------------------------
 407
 408 BOOL FormatterBase::IsEmptyFieldValue() const
 409 {
 410     return (!mpField || !mpField->GetText().Len());
 411 }
 412
 413 // -----------------------------------------------------------------------
 414
 415 BOOL NumericFormatter::ImplNumericReformat( const XubString& rStr, double& rValue,
 416                                             XubString& rOutStr )
 417 {
 418     if ( !ImplNumericGetValue( rStr, rValue, GetDecimalDigits(), ImplGetLocaleDataWrapper() ) )
 419         return TRUE;
 420     else
 421     {
 422         double nTempVal = rValue;
 423         // caution: precision loss in double cast
 424         if ( nTempVal > mnMax )
 425             nTempVal = (double)mnMax;
 426         else if ( nTempVal < mnMin )
 427             nTempVal = (double)mnMin;
 428
 429         if ( GetErrorHdl().IsSet() && (rValue != nTempVal) )
 430         {
 431             mnCorrectedValue = (sal_Int64)nTempVal;
 432             if ( !GetErrorHdl().Call( this ) )
 433             {
 434                 mnCorrectedValue = 0;
 435                 return FALSE;
 436             }
 437             else
 438                 mnCorrectedValue = 0;
 439         }
 440
 441         rOutStr = CreateFieldText( (sal_Int64)nTempVal );
 442         return TRUE;
 443     }
 444 }
 445
 446 // -----------------------------------------------------------------------
 447
 448 void NumericFormatter::ImplInit()
 449 {
 450     mnFieldValue        = 0;
 451     mnLastValue         = 0;
 452     mnMin               = 0;
 453     mnMax               = 0x7FFFFFFFFFFFFFFFLL;
 454     mnCorrectedValue    = 0;
 455     mnDecimalDigits     = 2;
 456     mnType              = FORMAT_NUMERIC;
 457     mbThousandSep       = TRUE;
 458     mbShowTrailingZeros = TRUE;
 459
 460     // for fields
 461     mnSpinSize          = 1;
 462     mnFirst             = mnMin;
 463     mnLast              = mnMax;
 464
 465     SetDecimalDigits( 0 );
 466 }
 467
 468 // -----------------------------------------------------------------------
 469
 470 NumericFormatter::NumericFormatter()
 471 {
 472     ImplInit();
 473 }
 474
 475 // -----------------------------------------------------------------------
 476
 477 void NumericFormatter::ImplLoadRes( const ResId& rResId )
 478 {
 479     ResMgr*     pMgr = rResId.GetResMgr();
 480
 481     if( pMgr )
 482     {
 483         ULONG nMask = pMgr->ReadLong();
 484
 485         if ( NUMERICFORMATTER_MIN & nMask )
 486             mnMin = pMgr->ReadLong();
 487
 488         if ( NUMERICFORMATTER_MAX & nMask )
 489             mnMax = pMgr->ReadLong();
 490
 491         if ( NUMERICFORMATTER_STRICTFORMAT & nMask )
 492             SetStrictFormat( (BOOL)pMgr->ReadShort() );
 493
 494         if ( NUMERICFORMATTER_DECIMALDIGITS & nMask )
 495             SetDecimalDigits( pMgr->ReadShort() );
 496
 497         if ( NUMERICFORMATTER_VALUE & nMask )
 498         {
 499             mnFieldValue = pMgr->ReadLong();
 500             if ( mnFieldValue > mnMax )
 501                 mnFieldValue = mnMax;
 502             else if ( mnFieldValue < mnMin )
 503                 mnFieldValue = mnMin;
 504             mnLastValue = mnFieldValue;
 505         }
 506     }
 507 }
 508
 509 // -----------------------------------------------------------------------
 510
 511 NumericFormatter::~NumericFormatter()
 512 {
 513 }
 514
 515 // -----------------------------------------------------------------------
 516
 517 void NumericFormatter::SetMin( sal_Int64 nNewMin )
 518 {
 519     mnMin = nNewMin;
 520     if ( !IsEmptyFieldValue() )
 521         ReformatAll();
 522 }
 523
 524 // -----------------------------------------------------------------------
 525
 526 void NumericFormatter::SetMax( sal_Int64 nNewMax )
 527 {
 528     mnMax = nNewMax;
 529     if ( !IsEmptyFieldValue() )
 530         ReformatAll();
 531 }
 532
 533 // -----------------------------------------------------------------------
 534
 535 void NumericFormatter::SetUseThousandSep( BOOL b )
 536 {
 537     mbThousandSep = b;
 538     ReformatAll();
 539 }
 540
 541 // -----------------------------------------------------------------------
 542
 543 void NumericFormatter::SetDecimalDigits( USHORT nDigits )
 544 {
 545     mnDecimalDigits = nDigits;
 546     ReformatAll();
 547 }
 548
 549 // -----------------------------------------------------------------------
 550
 551 void NumericFormatter::SetShowTrailingZeros( BOOL bShowTrailingZeros )
 552 {
 553     if ( mbShowTrailingZeros != bShowTrailingZeros )
 554     {
 555         mbShowTrailingZeros = bShowTrailingZeros;
 556         ReformatAll();
 557     }
 558 }
 559
 560 // -----------------------------------------------------------------------
 561
 562 USHORT NumericFormatter::GetDecimalDigits() const
 563 {
 564     return mnDecimalDigits;
 565 }
 566
 567 // -----------------------------------------------------------------------
 568
 569 void NumericFormatter::SetValue( sal_Int64 nNewValue )
 570 {
 571     SetUserValue( nNewValue );
 572     mnFieldValue = mnLastValue;
 573     SetEmptyFieldValueData( FALSE );
 574 }
 575
 576 // -----------------------------------------------------------------------
 577
 578 XubString NumericFormatter::CreateFieldText( sal_Int64 nValue ) const
 579 {
 580     return ImplGetLocaleDataWrapper().getNum( nValue, GetDecimalDigits(), IsUseThousandSep(), IsShowTrailingZeros() );
 581 }
 582
 583 // -----------------------------------------------------------------------
 584
 585 void NumericFormatter::ImplSetUserValue( sal_Int64 nNewValue, Selection* pNewSelection )
 586 {
 587     if ( nNewValue > mnMax )
 588         nNewValue = mnMax;
 589     else if ( nNewValue < mnMin )
 590         nNewValue = mnMin;
 591     mnLastValue = nNewValue;
 592
 593     if ( GetField() )
 594         ImplSetText( CreateFieldText( nNewValue ), pNewSelection );
 595 }
 596
 597 // -----------------------------------------------------------------------
 598
 599 void NumericFormatter::SetUserValue( sal_Int64 nNewValue )
 600 {
 601     ImplSetUserValue( nNewValue );
 602 }
 603
 604 // -----------------------------------------------------------------------
 605
 606 sal_Int64 NumericFormatter::GetValue() const
 607 {
 608     if ( !GetField() )
 609         return 0;
 610
 611     double nTempValue;
 612
 613     if ( ImplNumericGetValue( GetField()->GetText(), nTempValue,
 614                               GetDecimalDigits(), ImplGetLocaleDataWrapper() ) )
 615     {
 616         // caution: precision loss in double cast
 617         if ( nTempValue > mnMax )
 618             nTempValue = (double)mnMax;
 619         else if ( nTempValue < mnMin )
 620             nTempValue = (double)mnMin;
 621         return (sal_Int64)nTempValue;
 622     }
 623     else
 624         return mnLastValue;
 625 }
 626
 627 // -----------------------------------------------------------------------
 628
 629 BOOL NumericFormatter::IsValueModified() const
 630 {
 631     if ( ImplGetEmptyFieldValue() )
 632         return !IsEmptyFieldValue();
 633     else if ( GetValue() != mnFieldValue )
 634         return TRUE;
 635     else
 636         return FALSE;
 637 }
 638
 639 // -----------------------------------------------------------------------
 640
 641 Fraction NumericFormatter::ConvertToFraction( sal_Int64 nValue )
 642 {
 643     // caution: precision loss in double cast (and in fraction anyhow)
 644     return Fraction( (double)nValue/(double)ImplPower10( GetDecimalDigits() ) );
 645 }
 646
 647 // -----------------------------------------------------------------------
 648
 649 sal_Int64 NumericFormatter::ConvertToLong( const Fraction& rValue )
 650 {
 651     Fraction aFract = rValue;
 652     aFract *= Fraction( (long)ImplPower10( GetDecimalDigits() ), 1 );
 653     return (sal_Int64)(double)aFract;
 654 }
 655
 656 // -----------------------------------------------------------------------
 657
 658 sal_Int64 NumericFormatter::Normalize( sal_Int64 nValue ) const
 659 {
 660     return (nValue * ImplPower10( GetDecimalDigits() ) );
 661 }
 662
 663 // -----------------------------------------------------------------------
 664
 665 sal_Int64 NumericFormatter::Denormalize( sal_Int64 nValue ) const
 666 {
 667     sal_Int64 nFactor = ImplPower10( GetDecimalDigits() );
 668     if( nValue < 0 )
 669         return ((nValue-(nFactor/2)) / nFactor );
 670     else
 671         return ((nValue+(nFactor/2)) / nFactor );
 672 }
 673
 674 // -----------------------------------------------------------------------
 675
 676 void NumericFormatter::Reformat()
 677 {
 678     if ( !GetField() )
 679         return;
 680
 681     if ( !GetField()->GetText().Len() && ImplGetEmptyFieldValue() )
 682         return;
 683
 684     XubString aStr;
 685     // caution: precision loss in double cast
 686     double nTemp = (double)mnLastValue;
 687     BOOL bOK = ImplNumericReformat( GetField()->GetText(), nTemp, aStr );
 688     mnLastValue = (sal_Int64)nTemp;
 689     if ( !bOK )
 690         return;
 691
 692     if ( aStr.Len() )
 693         ImplSetText( aStr );
 694     else
 695         SetValue( mnLastValue );
 696 }
 697
 698 // -----------------------------------------------------------------------
 699
 700 void NumericFormatter::FieldUp()
 701 {
 702     sal_Int64 nValue = GetValue();
 703     nValue += mnSpinSize;
 704     if ( nValue > mnMax )
 705         nValue = mnMax;
 706
 707     ImplNewFieldValue( nValue );
 708 }
 709
 710 // -----------------------------------------------------------------------
 711
 712 void NumericFormatter::FieldDown()
 713 {
 714     sal_Int64 nValue = GetValue();
 715     nValue -= mnSpinSize;
 716     if ( nValue < mnMin )
 717         nValue = mnMin;
 718
 719     ImplNewFieldValue( nValue );
 720 }
 721
 722 // -----------------------------------------------------------------------
 723
 724 void NumericFormatter::FieldFirst()
 725 {
 726     ImplNewFieldValue( mnFirst );
 727 }
 728
 729 // -----------------------------------------------------------------------
 730
 731 void NumericFormatter::FieldLast()
 732 {
 733     ImplNewFieldValue( mnLast );
 734 }
 735
 736 // -----------------------------------------------------------------------
 737
 738 void NumericFormatter::ImplNewFieldValue( sal_Int64 nNewValue )
 739 {
 740     if ( GetField() )
 741     {
 742         // !!! TH-18.2.99: Wenn wir Zeit haben sollte mal geklaert werden,
 743         // !!! warum nicht bei ImplSetUserValue() geprueft wird, ob
 744         // !!! sich der Wert aendert. Denn auch hier muesste dieses
 745         // !!! gemacht werden, da ansonsten der Modify-Aufruf
 746         // !!! nicht gemacht werden duerfte. Jedenfalls sollten die
 747         // !!! Wege von ImplNewFieldValue, ImplSetUserValue und
 748         // !!! ImplSetText ueberprueft und klarer gestalltet (mit Kommentar)
 749         // !!! werden, damit wir mal wissen, was dort ablaeuft!!!
 750
 751         Selection aSelection = GetField()->GetSelection();
 752         aSelection.Justify();
 753         XubString aText = GetField()->GetText();
 754         // Wenn bis ans Ende selektiert war, soll das auch so bleiben...
 755         if ( (xub_StrLen)aSelection.Max() == aText.Len() )
 756         {
 757             if ( !aSelection.Len() )
 758                 aSelection.Min() = SELECTION_MAX;
 759             aSelection.Max() = SELECTION_MAX;
 760         }
 761
 762         sal_Int64 nOldLastValue  = mnLastValue;
 763         ImplSetUserValue( nNewValue, &aSelection );
 764         mnLastValue = nOldLastValue;
 765
 766         // Modify am Edit wird nur bei KeyInput gesetzt...
 767         if ( GetField()->GetText() != aText )
 768         {
 769             GetField()->SetModifyFlag();
 770             GetField()->Modify();
 771         }
 772     }
 773 }
 774
 775 // -----------------------------------------------------------------------
 776
 777 NumericField::NumericField( Window* pParent, WinBits nWinStyle ) :
 778     SpinField( pParent, nWinStyle )
 779 {
 780     SetField( this );
 781     Reformat();
 782 }
 783
 784 // -----------------------------------------------------------------------
 785
 786 NumericField::NumericField( Window* pParent, const ResId& rResId ) :
 787     SpinField( WINDOW_NUMERICFIELD )
 788 {
 789     rResId.SetRT( RSC_NUMERICFIELD );
 790     WinBits nStyle = ImplInitRes( rResId ) ;
 791     SpinField::ImplInit( pParent, nStyle );
 792     SetField( this );
 793     ImplLoadRes( rResId );
 794     Reformat();
 795
 796     if ( !(nStyle & WB_HIDE ) )
 797         Show();
 798 }
 799
 800 // -----------------------------------------------------------------------
 801
 802 void NumericField::ImplLoadRes( const ResId& rResId )
 803 {
 804     SpinField::ImplLoadRes( rResId );
 805     NumericFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
 806
 807     ULONG      nMask = ReadLongRes();
 808
 809     if ( NUMERICFIELD_FIRST & nMask )
 810         mnFirst = ReadLongRes();
 811
 812     if ( NUMERICFIELD_LAST & nMask )
 813         mnLast = ReadLongRes();
 814
 815     if ( NUMERICFIELD_SPINSIZE & nMask )
 816         mnSpinSize = ReadLongRes();
 817 }
 818
 819 // -----------------------------------------------------------------------
 820
 821 NumericField::~NumericField()
 822 {
 823 }
 824
 825 // -----------------------------------------------------------------------
 826
 827 long NumericField::PreNotify( NotifyEvent& rNEvt )
 828 {
 829         if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
 830     {
 831         if ( ImplNumericProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), ImplGetLocaleDataWrapper() ) )
 832             return 1;
 833     }
 834
 835     return SpinField::PreNotify( rNEvt );
 836 }
 837
 838 // -----------------------------------------------------------------------
 839
 840 long NumericField::Notify( NotifyEvent& rNEvt )
 841 {
 842     if ( rNEvt.GetType() == EVENT_GETFOCUS )
 843         MarkToBeReformatted( FALSE );
 844     else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
 845     {
 846         if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
 847             Reformat();
 848     }
 849
 850     return SpinField::Notify( rNEvt );
 851 }
 852
 853 // -----------------------------------------------------------------------
 854
 855 void NumericField::DataChanged( const DataChangedEvent& rDCEvt )
 856 {
 857     SpinField::DataChanged( rDCEvt );
 858
 859     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_LOCALE) )
 860     {
 861         String sOldDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
 862         String sOldThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
 863         if ( IsDefaultLocale() )
 864             ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
 865         String sNewDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
 866         String sNewThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
 867         ImplUpdateSeparators( sOldDecSep, sNewDecSep, sOldThSep, sNewThSep, this );
 868         ReformatAll();
 869     }
 870 }
 871
 872 // -----------------------------------------------------------------------
 873
 874 void NumericField::Modify()
 875 {
 876     MarkToBeReformatted( TRUE );
 877     SpinField::Modify();
 878 }
 879
 880 // -----------------------------------------------------------------------
 881
 882 void NumericField::Up()
 883 {
 884     FieldUp();
 885     SpinField::Up();
 886 }
 887
 888 // -----------------------------------------------------------------------
 889
 890 void NumericField::Down()
 891 {
 892     FieldDown();
 893     SpinField::Down();
 894 }
 895
 896 // -----------------------------------------------------------------------
 897
 898 void NumericField::First()
 899 {
 900     FieldFirst();
 901     SpinField::First();
 902 }
 903
 904 // -----------------------------------------------------------------------
 905
 906 void NumericField::Last()
 907 {
 908     FieldLast();
 909     SpinField::Last();
 910 }
 911
 912 // -----------------------------------------------------------------------
 913
 914 NumericBox::NumericBox( Window* pParent, WinBits nWinStyle ) :
 915     ComboBox( pParent, nWinStyle )
 916 {
 917     SetField( this );
 918     Reformat();
 919 }
 920
 921 // -----------------------------------------------------------------------
 922
 923 NumericBox::NumericBox( Window* pParent, const ResId& rResId ) :
 924     ComboBox( WINDOW_NUMERICBOX )
 925 {
 926     rResId.SetRT( RSC_NUMERICBOX );
 927     WinBits nStyle = ImplInitRes( rResId );
 928     ComboBox::ImplInit( pParent, nStyle );
 929     SetField( this );
 930     ComboBox::ImplLoadRes( rResId );
 931     NumericFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
 932     Reformat();
 933
 934     if ( !(nStyle & WB_HIDE ) )
 935         Show();
 936 }
 937
 938 // -----------------------------------------------------------------------
 939
 940 NumericBox::~NumericBox()
 941 {
 942 }
 943
 944 // -----------------------------------------------------------------------
 945
 946 long NumericBox::PreNotify( NotifyEvent& rNEvt )
 947 {
 948     if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
 949     {
 950         if ( ImplNumericProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), ImplGetLocaleDataWrapper() ) )
 951             return 1;
 952     }
 953
 954     return ComboBox::PreNotify( rNEvt );
 955 }
 956
 957 // -----------------------------------------------------------------------
 958
 959 long NumericBox::Notify( NotifyEvent& rNEvt )
 960 {
 961     if ( rNEvt.GetType() == EVENT_GETFOCUS )
 962         MarkToBeReformatted( FALSE );
 963     else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
 964     {
 965         if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
 966             Reformat();
 967     }
 968
 969     return ComboBox::Notify( rNEvt );
 970 }
 971
 972 // -----------------------------------------------------------------------
 973
 974 void NumericBox::DataChanged( const DataChangedEvent& rDCEvt )
 975 {
 976     ComboBox::DataChanged( rDCEvt );
 977
 978     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_LOCALE) )
 979     {
 980         String sOldDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
 981         String sOldThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
 982         if ( IsDefaultLocale() )
 983             ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
 984         String sNewDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
 985         String sNewThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
 986         ImplUpdateSeparators( sOldDecSep, sNewDecSep, sOldThSep, sNewThSep, this );
 987         ReformatAll();
 988     }
 989 }
 990
 991 // -----------------------------------------------------------------------
 992
 993 void NumericBox::Modify()
 994 {
 995     MarkToBeReformatted( TRUE );
 996     ComboBox::Modify();
 997 }
 998
 999 // -----------------------------------------------------------------------
1000
1001 void NumericBox::ReformatAll()
1002 {
1003     double nValue;
1004     XubString aStr;
1005     SetUpdateMode( FALSE );
1006     USHORT nEntryCount = GetEntryCount();
1007     for ( USHORT i=0; i < nEntryCount; i++ )
1008     {
1009         ImplNumericReformat( GetEntry( i ), nValue, aStr );
1010         RemoveEntry( i );
1011         InsertEntry( aStr, i );
1012     }
1013     NumericFormatter::Reformat();
1014     SetUpdateMode( TRUE );
1015 }
1016
1017 // -----------------------------------------------------------------------
1018
1019 void NumericBox::InsertValue( sal_Int64 nValue, USHORT nPos )
1020 {
1021     ComboBox::InsertEntry( CreateFieldText( nValue ), nPos );
1022 }
1023
1024 // -----------------------------------------------------------------------
1025
1026 void NumericBox::RemoveValue( sal_Int64 nValue )
1027 {
1028     ComboBox::RemoveEntry( CreateFieldText( nValue ) );
1029 }
1030
1031 // -----------------------------------------------------------------------
1032
1033 sal_Int64 NumericBox::GetValue( USHORT nPos ) const
1034 {
1035     double nValue = 0;
1036     ImplNumericGetValue( ComboBox::GetEntry( nPos ), nValue, GetDecimalDigits(), ImplGetLocaleDataWrapper() );
1037     return (sal_Int64)nValue;
1038 }
1039
1040 // -----------------------------------------------------------------------
1041
1042 USHORT NumericBox::GetValuePos( sal_Int64 nValue ) const
1043 {
1044     return ComboBox::GetEntryPos( CreateFieldText( nValue ) );
1045 }
1046
1047 // -----------------------------------------------------------------------
1048
1049 static BOOL ImplMetricProcessKeyInput( Edit* pEdit, const KeyEvent& rKEvt,
1050                                        BOOL, BOOL bUseThousandSep, const LocaleDataWrapper& rWrapper )
1051 {
1052     // Es gibt hier kein sinnvolles StrictFormat, also alle
1053     // Zeichen erlauben
1054     return ImplNumericProcessKeyInput( pEdit, rKEvt, FALSE, bUseThousandSep, rWrapper );
1055 }
1056
1057 // -----------------------------------------------------------------------
1058
1059 static XubString ImplMetricGetUnitText( const XubString& rStr )
1060 {
1061     // Einheitentext holen
1062     XubString aStr;
1063     for ( short i = rStr.Len()-1; i >= 0; i-- )
1064     {
1065         xub_Unicode c = rStr.GetChar( i );
1066         if ( unicode::isAlpha( c ) ||
1067              (c == '\'') || (c == '\"') || (c == '%' ) )
1068             aStr.Insert( c, 0 );
1069         else
1070         {
1071             if ( aStr.Len() )
1072                 break;
1073         }
1074     }
1075     return aStr;
1076
1077 /*
1078     // MT: #90545# Preparation for translated strings...
1079     String aMetricText;
1080     for ( USHORT n = rStr.Len(); n; )
1081     {
1082         sal_Unicode c = rStr.GetChar( --n );
1083         sal_Int32 nType = xCharClass->getStringType( rStr, n, 1, rLocale );
1084
1085         if ( CharClass::isLetterType( nType ) )
1086         {
1087             aMetricText.Insert( c, 0 );
1088         }
1089         else
1090         {
1091             if ( aMetricText.Len() )
1092                 break;
1093         }
1094     }
1095 */
1096 }
1097
1098 // -----------------------------------------------------------------------
1099
1100 // #104355# support localized mesaurements
1101
1102 static String ImplMetricToString( FieldUnit rUnit )
1103 {
1104     if( !strAllUnits )
1105     {
1106         ResMgr* pResMgr = ImplGetResMgr();
1107         strAllUnits = new ResStringArray( ResId (SV_FUNIT_STRINGS, *pResMgr) );
1108     }
1109     // return unit's default string (ie, the first one )
1110     for( USHORT i=0; i < strAllUnits->Count(); i++ )
1111         if( (FieldUnit) strAllUnits->GetValue( i ) == rUnit )
1112             return strAllUnits->GetString( i );
1113
1114     return String();
1115 }
1116
1117 static FieldUnit ImplStringToMetric( const String &rMetricString )
1118 {
1119     if( !strAllUnits )
1120     {
1121         ResMgr* pResMgr = ImplGetResMgr();
1122         strAllUnits = new ResStringArray( ResId (SV_FUNIT_STRINGS, *pResMgr) );
1123     }
1124     // return FieldUnit
1125     String aStr( rMetricString );
1126     aStr.ToLowerAscii();
1127     for( USHORT i=0; i < strAllUnits->Count(); i++ )
1128         if ( strAllUnits->GetString( i ).Equals( aStr ) )
1129             return (FieldUnit) strAllUnits->GetValue( i );
1130
1131     // Amelia : about character unit
1132     if (aStr.EqualsIgnoreCaseAscii("cm"))
1133         return FUNIT_CM;
1134
1135     return FUNIT_NONE;
1136 }
1137
1138 // -----------------------------------------------------------------------
1139
1140 static FieldUnit ImplMetricGetUnit( const XubString& rStr )
1141 {
1142     XubString aStr = ImplMetricGetUnitText( rStr );
1143     return ImplStringToMetric( aStr );
1144 }
1145
1146 #define K *1000L
1147 #define M *1000000L
1148 #define X *5280L
1149
1150 // Amelia : about measurement unit, 'char' and 'line'
1151 //static const sal_Int64 aImplFactor[FUNIT_MILE+1][FUNIT_MILE+1] =
1152 static const sal_Int64 aImplFactor[FUNIT_LINE+1][FUNIT_LINE+1] =
1153 { /*
1154 mm/100    mm    cm       m     km  twip point  pica  inch    foot     mile    char    line*/
1155 {    1,  100,  1 K,  100 K, 100 M, 2540, 2540, 2540, 2540,2540*12,2540*12 X ,   53340, 396240},
1156 {    1,    1,   10,    1 K,   1 M, 2540, 2540, 2540, 2540,2540*12,2540*12 X ,    5334, 396240},
1157 {    1,    1,    1,    100, 100 K,  254,  254,  254,  254, 254*12, 254*12 X ,    5334,  39624},
1158 {    1,    1,    1,      1,   1 K,  254,  254,  254,  254, 254*12, 254*12 X ,  533400,  39624},
1159 {    1,    1,    1,      1,     1,    0,  254,  254,  254, 254*12, 254*12 X ,533400 K,  39624},
1160 { 1440,144 K,144 K,14400 K,     0,    1,   20,  240, 1440,1440*12,1440*12 X ,     210,   3120},
1161 {   72, 7200, 7200,  720 K, 720 M,    1,    1,   12,   72,  72*12,  72*12 X ,     210,    156},
1162 {    6,  600,  600,   60 K,  60 M,    1,    1,    1,    6,   6*12,   6*12 X ,     210,     10},
1163 {    1,  100,  100,   10 K,  10 M,    1,    1,    1,    1,     12,     12 X ,     210,     45},
1164 {    1,  100,  100,   10 K,  10 M,    1,    1,    1,    1,      1,      1 X ,     210,     45},
1165 {    1,  100,  100,   10 K,  10 M,    1,    1,    1,    1,      1,        1 ,     210,     45},
1166 {  144, 1440,14400,  14400, 14400,    1,   20,  240, 1440,1440*12, 1440*12 X,       1,   156 },
1167 {  720,72000,72000, 7200 K,7200 M,   20,   10,   13,   11,  11*12,   11*12 X,     105,     1 }
1168 };
1169
1170 #undef X
1171 #undef M
1172 #undef K
1173 // twip in km 254/14400 M
1174
1175 static FieldUnit eDefaultUnit = FUNIT_NONE;
1176
1177 FieldUnit MetricField::GetDefaultUnit() { return eDefaultUnit; }
1178 void MetricField::SetDefaultUnit( FieldUnit meUnit ) { eDefaultUnit = meUnit; }
1179
1180 static FieldUnit ImplMap2FieldUnit( MapUnit meUnit, long& nDecDigits )
1181 {
1182     switch( meUnit )
1183     {
1184         case MAP_100TH_MM :
1185             nDecDigits -= 2;
1186             return FUNIT_MM;
1187         case MAP_10TH_MM :
1188             nDecDigits -= 1;
1189             return FUNIT_MM;
1190         case MAP_MM :
1191             return FUNIT_MM;
1192         case MAP_CM :
1193             return FUNIT_CM;
1194         case MAP_1000TH_INCH :
1195             nDecDigits -= 3;
1196             return FUNIT_INCH;
1197         case MAP_100TH_INCH :
1198             nDecDigits -= 2;
1199             return FUNIT_INCH;
1200         case MAP_10TH_INCH :
1201             nDecDigits -= 1;
1202             return FUNIT_INCH;
1203         case MAP_INCH :
1204             return FUNIT_INCH;
1205         case MAP_POINT :
1206             return FUNIT_POINT;
1207         case MAP_TWIP :
1208             return FUNIT_TWIP;
1209         default:
1210             DBG_ERROR( "default eInUnit" );
1211             break;
1212     }
1213     return FUNIT_NONE;
1214 }
1215
1216 // -----------------------------------------------------------------------
1217
1218 static double nonValueDoubleToValueDouble( double nValue )
1219 {
1220     return rtl::math::isFinite( nValue ) ? nValue : 0.0;
1221 }
1222
1223 sal_Int64 MetricField::ConvertValue( sal_Int64 nValue, sal_Int64 mnBaseValue, USHORT nDecDigits,
1224                                      FieldUnit eInUnit, FieldUnit eOutUnit )
1225 {
1226     // caution: precision loss in double cast
1227     return static_cast<sal_Int64>(
1228         // #150733# cast double to sal_Int64 can throw a
1229         // EXCEPTION_FLT_INVALID_OPERATION on Windows
1230         nonValueDoubleToValueDouble(
1231             ConvertDoubleValue( (double)nValue, mnBaseValue, nDecDigits,
1232                                 eInUnit, eOutUnit ) ) );
1233 }
1234
1235 // -----------------------------------------------------------------------
1236
1237 sal_Int64 MetricField::ConvertValue( sal_Int64 nValue, USHORT nDigits,
1238                                      MapUnit eInUnit, FieldUnit eOutUnit )
1239 {
1240     return static_cast<sal_Int64>(
1241         // #150733# cast double to sal_Int64 can throw a
1242         // EXCEPTION_FLT_INVALID_OPERATION on Windows
1243         nonValueDoubleToValueDouble(
1244             ConvertDoubleValue( nValue, nDigits, eInUnit, eOutUnit ) ) );
1245 }
1246
1247 // -----------------------------------------------------------------------
1248
1249 sal_Int64 MetricField::ConvertValue( sal_Int64 nValue, USHORT nDigits,
1250                                      FieldUnit eInUnit, MapUnit eOutUnit )
1251 {
1252     return static_cast<sal_Int64>(
1253         // #150733# cast double to sal_Int64 can throw a
1254         // EXCEPTION_FLT_INVALID_OPERATION on Windows
1255         nonValueDoubleToValueDouble(
1256             ConvertDoubleValue( nValue, nDigits, eInUnit, eOutUnit ) ) );
1257 }
1258
1259 // -----------------------------------------------------------------------
1260
1261 double MetricField::ConvertDoubleValue( double nValue, sal_Int64 mnBaseValue, USHORT nDecDigits,
1262                                         FieldUnit eInUnit, FieldUnit eOutUnit )
1263 {
1264     if ( eInUnit != eOutUnit )
1265     {
1266         sal_Int64 nMult = 1, nDiv = 1;
1267
1268         if ( eInUnit == FUNIT_PERCENT )
1269         {
1270             if ( (mnBaseValue <= 0) || (nValue <= 0) )
1271                 return nValue;
1272             nDiv = 100;
1273             for ( USHORT i=0; i < nDecDigits; i++ )
1274                 nDiv *= 10;
1275
1276             nMult = mnBaseValue;
1277         }
1278         else if ( eOutUnit == FUNIT_PERCENT ||
1279                   eOutUnit == FUNIT_CUSTOM ||
1280                   eOutUnit == FUNIT_NONE ||
1281                   eInUnit  == FUNIT_CUSTOM ||
1282                   eInUnit  == FUNIT_NONE )
1283              return nValue;
1284         else
1285         {
1286             if ( eOutUnit == FUNIT_100TH_MM )
1287                 eOutUnit = FUNIT_NONE;
1288             if ( eInUnit == FUNIT_100TH_MM )
1289                 eInUnit = FUNIT_NONE;
1290
1291             nDiv  = aImplFactor[eInUnit][eOutUnit];
1292             nMult = aImplFactor[eOutUnit][eInUnit];
1293
1294             DBG_ASSERT( nMult > 0, "illegal *" );
1295             DBG_ASSERT( nDiv  > 0, "illegal /" );
1296         }
1297
1298         if ( nMult != 1 && nMult > 0 )
1299             nValue *= nMult;
1300         if ( nDiv != 1 && nDiv > 0 )
1301         {
1302             nValue += ( nValue < 0 ) ? (-nDiv/2) : (nDiv/2);
1303             nValue /= nDiv;
1304         }
1305     }
1306
1307     return nValue;
1308 }
1309
1310 // -----------------------------------------------------------------------
1311
1312 double MetricField::ConvertDoubleValue( double nValue, USHORT nDigits,
1313                                         MapUnit eInUnit, FieldUnit eOutUnit )
1314 {
1315     if ( eOutUnit == FUNIT_PERCENT ||
1316          eOutUnit == FUNIT_CUSTOM ||
1317          eOutUnit == FUNIT_NONE ||
1318          eInUnit == MAP_PIXEL ||
1319          eInUnit == MAP_SYSFONT ||
1320          eInUnit == MAP_APPFONT ||
1321          eInUnit == MAP_RELATIVE )
1322     {
1323         DBG_ERROR( "invalid parameters" );
1324         return nValue;
1325     }
1326
1327     long nDecDigits = nDigits;
1328     FieldUnit eFieldUnit = ImplMap2FieldUnit( eInUnit, nDecDigits );
1329
1330     if ( nDecDigits < 0 )
1331     {
1332         while ( nDecDigits )
1333         {
1334             nValue += 5;
1335             nValue /= 10;
1336             nDecDigits++;
1337         }
1338     }
1339     else
1340     {
1341         while ( nDecDigits )
1342         {
1343             nValue *= 10;
1344             nDecDigits--;
1345         }
1346     }
1347
1348     if ( eFieldUnit != eOutUnit )
1349     {
1350         sal_Int64 nDiv  = aImplFactor[eFieldUnit][eOutUnit];
1351         sal_Int64 nMult = aImplFactor[eOutUnit][eFieldUnit];
1352
1353         DBG_ASSERT( nMult > 0, "illegal *" );
1354         DBG_ASSERT( nDiv  > 0, "illegal /" );
1355
1356         if ( nMult != 1 && nMult > 0)
1357             nValue *= nMult;
1358         if ( nDiv != 1 && nDiv > 0 )
1359         {
1360             nValue += (nValue < 0) ? (-nDiv/2) : (nDiv/2);
1361             nValue /= nDiv;
1362         }
1363     }
1364     return nValue;
1365 }
1366
1367 // -----------------------------------------------------------------------
1368
1369 double MetricField::ConvertDoubleValue( double nValue, USHORT nDigits,
1370                                         FieldUnit eInUnit, MapUnit eOutUnit )
1371 {
1372     if ( eInUnit == FUNIT_PERCENT ||
1373          eInUnit == FUNIT_CUSTOM ||
1374          eInUnit == FUNIT_NONE ||
1375          eOutUnit == MAP_PIXEL ||
1376          eOutUnit == MAP_SYSFONT ||
1377          eOutUnit == MAP_APPFONT ||
1378          eOutUnit == MAP_RELATIVE )
1379     {
1380         DBG_ERROR( "invalid parameters" );
1381         return nValue;
1382     }
1383
1384     long nDecDigits = nDigits;
1385     FieldUnit eFieldUnit = ImplMap2FieldUnit( eOutUnit, nDecDigits );
1386
1387     if ( nDecDigits < 0 )
1388     {
1389         while ( nDecDigits )
1390         {
1391             nValue *= 10;
1392             nDecDigits++;
1393         }
1394     }
1395     else
1396     {
1397         while ( nDecDigits )
1398         {
1399             nValue += 5;
1400             nValue /= 10;
1401             nDecDigits--;
1402         }
1403     }
1404
1405     if ( eFieldUnit != eInUnit )
1406     {
1407         sal_Int64 nDiv  = aImplFactor[eInUnit][eFieldUnit];
1408         sal_Int64 nMult = aImplFactor[eFieldUnit][eInUnit];
1409
1410         DBG_ASSERT( nMult > 0, "illegal *" );
1411         DBG_ASSERT( nDiv  > 0, "illegal /" );
1412
1413         if( nMult != 1 && nMult > 0 )
1414             nValue *= nMult;
1415         if( nDiv != 1 && nDiv > 0 )
1416         {
1417             nValue += (nValue < 0) ? (-nDiv/2) : (nDiv/2);
1418             nValue /= nDiv;
1419         }
1420     }
1421     return nValue;
1422 }
1423
1424 // -----------------------------------------------------------------------
1425
1426 static BOOL ImplMetricGetValue( const XubString& rStr, double& rValue, sal_Int64 nBaseValue,
1427                                 USHORT nDecDigits, const LocaleDataWrapper& rLocaleDataWrapper, FieldUnit eUnit )
1428 {
1429     // Zahlenwert holen
1430     if ( !ImplNumericGetValue( rStr, rValue, nDecDigits, rLocaleDataWrapper ) )
1431         return FALSE;
1432
1433     // Einheit rausfinden
1434     FieldUnit eEntryUnit = ImplMetricGetUnit( rStr );
1435
1436     // Einheiten umrechnen
1437     rValue = MetricField::ConvertDoubleValue( rValue, nBaseValue, nDecDigits, eEntryUnit, eUnit );
1438
1439     return TRUE;
1440 }
1441
1442 // -----------------------------------------------------------------------
1443
1444 BOOL MetricFormatter::ImplMetricReformat( const XubString& rStr, double& rValue, XubString& rOutStr )
1445 {
1446     if ( !ImplMetricGetValue( rStr, rValue, mnBaseValue, GetDecimalDigits(), ImplGetLocaleDataWrapper(), meUnit ) )
1447         return TRUE;
1448     else
1449     {
1450         double nTempVal = rValue;
1451         // caution: precision loss in double cast
1452         if ( nTempVal > GetMax() )
1453             nTempVal = (double)GetMax();
1454         else if ( nTempVal < GetMin())
1455             nTempVal = (double)GetMin();
1456
1457         if ( GetErrorHdl().IsSet() && (rValue != nTempVal) )
1458         {
1459             mnCorrectedValue = (sal_Int64)nTempVal;
1460             if ( !GetErrorHdl().Call( this ) )
1461             {
1462                 mnCorrectedValue = 0;
1463                 return FALSE;
1464             }
1465             else
1466                 mnCorrectedValue = 0;
1467         }
1468
1469         rOutStr = CreateFieldText( (sal_Int64)nTempVal );
1470         return TRUE;
1471     }
1472 }
1473
1474 // -----------------------------------------------------------------------
1475
1476 inline void MetricFormatter::ImplInit()
1477 {
1478     mnBaseValue = 0;
1479     meUnit = MetricField::GetDefaultUnit();
1480     mnType = FORMAT_METRIC;
1481 }
1482
1483 // -----------------------------------------------------------------------
1484
1485 MetricFormatter::MetricFormatter()
1486 {
1487     ImplInit();
1488 }
1489
1490 // -----------------------------------------------------------------------
1491
1492 void MetricFormatter::ImplLoadRes( const ResId& rResId )
1493 {
1494     NumericFormatter::ImplLoadRes( rResId );
1495
1496     ResMgr*     pMgr = rResId.GetResMgr();
1497     if( pMgr )
1498     {
1499         ULONG       nMask = pMgr->ReadLong();
1500
1501         if ( METRICFORMATTER_UNIT & nMask )
1502             meUnit = (FieldUnit)pMgr->ReadLong();
1503
1504         if ( METRICFORMATTER_CUSTOMUNITTEXT & nMask )
1505             maCustomUnitText = pMgr->ReadString();
1506     }
1507 }
1508
1509 // -----------------------------------------------------------------------
1510
1511 MetricFormatter::~MetricFormatter()
1512 {
1513 }
1514
1515 // -----------------------------------------------------------------------
1516
1517 void MetricFormatter::SetUnit( FieldUnit eNewUnit )
1518 {
1519     if ( eNewUnit == FUNIT_100TH_MM )
1520     {
1521         SetDecimalDigits( GetDecimalDigits() + 2 );
1522         meUnit = FUNIT_MM;
1523     }
1524     else
1525         meUnit = eNewUnit;
1526     ReformatAll();
1527 }
1528
1529 // -----------------------------------------------------------------------
1530
1531 void MetricFormatter::SetCustomUnitText( const XubString& rStr )
1532 {
1533     maCustomUnitText = rStr;
1534     ReformatAll();
1535 }
1536
1537 // -----------------------------------------------------------------------
1538
1539 void MetricFormatter::SetValue( sal_Int64 nNewValue, FieldUnit eInUnit )
1540 {
1541     SetUserValue( nNewValue, eInUnit );
1542     mnFieldValue = mnLastValue;
1543 }
1544
1545 // -----------------------------------------------------------------------
1546
1547 XubString MetricFormatter::CreateFieldText( sal_Int64 nValue ) const
1548 {
1549     XubString aStr = NumericFormatter::CreateFieldText( nValue );
1550
1551     if( meUnit == FUNIT_CUSTOM )
1552         aStr += maCustomUnitText;
1553     else
1554         aStr += ImplMetricToString( meUnit );
1555
1556     return aStr;
1557 }
1558
1559 // -----------------------------------------------------------------------
1560
1561 void MetricFormatter::SetUserValue( sal_Int64 nNewValue, FieldUnit eInUnit )
1562 {
1563     // Umrechnen auf eingestellte Einheiten
1564     nNewValue = MetricField::ConvertValue( nNewValue, mnBaseValue, GetDecimalDigits(), eInUnit, meUnit );
1565     NumericFormatter::SetUserValue( nNewValue );
1566 }
1567
1568 // -----------------------------------------------------------------------
1569
1570 sal_Int64 MetricFormatter::GetValue( FieldUnit eOutUnit ) const
1571 {
1572     if ( !GetField() )
1573         return 0;
1574
1575     double nTempValue;
1576     // caution: precision loss in double cast
1577     if ( !ImplMetricGetValue( GetField()->GetText(), nTempValue, mnBaseValue, GetDecimalDigits(), ImplGetLocaleDataWrapper(), meUnit ) )
1578         nTempValue = (double)mnLastValue;
1579
1580     // caution: precision loss in double cast
1581     if ( nTempValue > mnMax )
1582         nTempValue = (double)mnMax;
1583     else if ( nTempValue < mnMin )
1584         nTempValue = (double)mnMin;
1585
1586     // Umrechnen auf gewuenschte Einheiten
1587     return MetricField::ConvertValue( (sal_Int64)nTempValue, mnBaseValue, GetDecimalDigits(), meUnit, eOutUnit );
1588 }
1589
1590 // -----------------------------------------------------------------------
1591
1592 void MetricFormatter::SetValue( sal_Int64 nValue )
1593 {
1594     // Implementation not inline, because it is a virtual Function
1595     SetValue( nValue, FUNIT_NONE );
1596 }
1597
1598 // -----------------------------------------------------------------------
1599
1600 sal_Int64 MetricFormatter::GetValue() const
1601 {
1602     // Implementation not inline, because it is a virtual Function
1603     return GetValue( FUNIT_NONE );
1604 }
1605
1606 // -----------------------------------------------------------------------
1607
1608 void MetricFormatter::SetMin( sal_Int64 nNewMin, FieldUnit eInUnit )
1609 {
1610     // Umrechnen auf gewuenschte Einheiten
1611     NumericFormatter::SetMin( MetricField::ConvertValue( nNewMin, mnBaseValue, GetDecimalDigits(),
1612                                                          eInUnit, meUnit ) );
1613 }
1614
1615 // -----------------------------------------------------------------------
1616
1617 sal_Int64 MetricFormatter::GetMin( FieldUnit eOutUnit ) const
1618 {
1619     // Umrechnen auf gewuenschte Einheiten
1620     return MetricField::ConvertValue( NumericFormatter::GetMin(), mnBaseValue,
1621                                       GetDecimalDigits(), meUnit, eOutUnit );
1622 }
1623
1624 // -----------------------------------------------------------------------
1625
1626 void MetricFormatter::SetMax( sal_Int64 nNewMax, FieldUnit eInUnit )
1627 {
1628     // Umrechnen auf gewuenschte Einheiten
1629     NumericFormatter::SetMax( MetricField::ConvertValue( nNewMax, mnBaseValue, GetDecimalDigits(),
1630                                                          eInUnit, meUnit ) );
1631 }
1632
1633 // -----------------------------------------------------------------------
1634
1635 sal_Int64 MetricFormatter::GetMax( FieldUnit eOutUnit ) const
1636 {
1637     // Umrechnen auf gewuenschte Einheiten
1638     return MetricField::ConvertValue( NumericFormatter::GetMax(), mnBaseValue,
1639                                       GetDecimalDigits(), meUnit, eOutUnit );
1640 }
1641
1642 // -----------------------------------------------------------------------
1643
1644 void MetricFormatter::SetBaseValue( sal_Int64 nNewBase, FieldUnit eInUnit )
1645 {
1646     mnBaseValue = MetricField::ConvertValue( nNewBase, mnBaseValue, GetDecimalDigits(),
1647                                              eInUnit, meUnit );
1648 }
1649
1650 // -----------------------------------------------------------------------
1651
1652 sal_Int64 MetricFormatter::GetBaseValue( FieldUnit eOutUnit ) const
1653 {
1654     // Umrechnen auf gewuenschte Einheiten
1655     return MetricField::ConvertValue( mnBaseValue, mnBaseValue, GetDecimalDigits(),
1656                                       meUnit, eOutUnit );
1657 }
1658
1659 // -----------------------------------------------------------------------
1660
1661 void MetricFormatter::Reformat()
1662 {
1663     if ( !GetField() )
1664         return;
1665
1666     XubString aText = GetField()->GetText();
1667     if ( meUnit == FUNIT_CUSTOM )
1668         maCurUnitText = ImplMetricGetUnitText( aText );
1669
1670     XubString aStr;
1671     // caution: precision loss in double cast
1672     double nTemp = (double)mnLastValue;
1673     BOOL bOK = ImplMetricReformat( aText, nTemp, aStr );
1674     mnLastValue = (sal_Int64)nTemp;
1675
1676     if ( !bOK )
1677         return;
1678
1679     if ( aStr.Len() )
1680     {
1681         ImplSetText( aStr );
1682         if ( meUnit == FUNIT_CUSTOM )
1683             CustomConvert();
1684     }
1685     else
1686         SetValue( mnLastValue );
1687     maCurUnitText.Erase();
1688 }
1689
1690 // -----------------------------------------------------------------------
1691
1692 sal_Int64 MetricFormatter::GetCorrectedValue( FieldUnit eOutUnit ) const
1693 {
1694     // Umrechnen auf gewuenschte Einheiten
1695     return MetricField::ConvertValue( mnCorrectedValue, mnBaseValue, GetDecimalDigits(),
1696                                       meUnit, eOutUnit );
1697 }
1698
1699 // -----------------------------------------------------------------------
1700
1701 MetricField::MetricField( Window* pParent, WinBits nWinStyle ) :
1702     SpinField( pParent, nWinStyle )
1703 {
1704     SetField( this );
1705     Reformat();
1706 }
1707
1708 // -----------------------------------------------------------------------
1709
1710 MetricField::MetricField( Window* pParent, const ResId& rResId ) :
1711     SpinField( WINDOW_METRICFIELD )
1712 {
1713     rResId.SetRT( RSC_METRICFIELD );
1714     WinBits nStyle = ImplInitRes( rResId ) ;
1715     SpinField::ImplInit( pParent, nStyle );
1716     SetField( this );
1717     ImplLoadRes( rResId );
1718
1719     if ( !(nStyle & WB_HIDE ) )
1720         Show();
1721 }
1722
1723 // -----------------------------------------------------------------------
1724
1725 void MetricField::ImplLoadRes( const ResId& rResId )
1726 {
1727     SpinField::ImplLoadRes( rResId );
1728     MetricFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
1729
1730     ULONG      nMask = ReadLongRes();
1731
1732     if ( METRICFIELD_FIRST & nMask )
1733         mnFirst = ReadLongRes();
1734
1735     if ( METRICFIELD_LAST & nMask )
1736         mnLast = ReadLongRes();
1737
1738     if ( METRICFIELD_SPINSIZE & nMask )
1739         mnSpinSize = ReadLongRes();
1740
1741     Reformat();
1742 }
1743
1744 // -----------------------------------------------------------------------
1745
1746 MetricField::~MetricField()
1747 {
1748 }
1749
1750 // -----------------------------------------------------------------------
1751
1752 void MetricField::SetFirst( sal_Int64 nNewFirst, FieldUnit eInUnit )
1753 {
1754     // convert
1755     nNewFirst = MetricField::ConvertValue( nNewFirst, mnBaseValue, GetDecimalDigits(),
1756                                            eInUnit, meUnit );
1757     mnFirst = nNewFirst;
1758 }
1759
1760 // -----------------------------------------------------------------------
1761
1762 sal_Int64 MetricField::GetFirst( FieldUnit eOutUnit ) const
1763 {
1764     // convert
1765     return MetricField::ConvertValue( mnFirst, mnBaseValue, GetDecimalDigits(),
1766                                       meUnit, eOutUnit );
1767 }
1768
1769 // -----------------------------------------------------------------------
1770
1771 void MetricField::SetLast( sal_Int64 nNewLast, FieldUnit eInUnit )
1772 {
1773     // Umrechnen
1774     nNewLast = MetricField::ConvertValue( nNewLast, mnBaseValue, GetDecimalDigits(),
1775                                           eInUnit, meUnit );
1776     mnLast = nNewLast;
1777 }
1778
1779 // -----------------------------------------------------------------------
1780
1781 sal_Int64 MetricField::GetLast( FieldUnit eOutUnit ) const
1782 {
1783     // Umrechnen
1784     return MetricField::ConvertValue( mnLast, mnBaseValue, GetDecimalDigits(),
1785                                       meUnit, eOutUnit );
1786 }
1787
1788 // -----------------------------------------------------------------------
1789
1790 long MetricField::PreNotify( NotifyEvent& rNEvt )
1791 {
1792     if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
1793     {
1794         if ( ImplMetricProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), ImplGetLocaleDataWrapper() ) )
1795             return 1;
1796     }
1797
1798     return SpinField::PreNotify( rNEvt );
1799 }
1800
1801 // -----------------------------------------------------------------------
1802
1803 long MetricField::Notify( NotifyEvent& rNEvt )
1804 {
1805     if ( rNEvt.GetType() == EVENT_GETFOCUS )
1806         MarkToBeReformatted( FALSE );
1807     else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
1808     {
1809         if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
1810             Reformat();
1811     }
1812
1813     return SpinField::Notify( rNEvt );
1814 }
1815
1816 // -----------------------------------------------------------------------
1817
1818 void MetricField::DataChanged( const DataChangedEvent& rDCEvt )
1819 {
1820     SpinField::DataChanged( rDCEvt );
1821
1822     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_LOCALE) )
1823     {
1824         String sOldDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
1825         String sOldThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
1826         if ( IsDefaultLocale() )
1827             ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
1828         String sNewDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
1829         String sNewThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
1830         ImplUpdateSeparators( sOldDecSep, sNewDecSep, sOldThSep, sNewThSep, this );
1831         ReformatAll();
1832     }
1833 }
1834
1835 // -----------------------------------------------------------------------
1836
1837 void MetricField::Modify()
1838 {
1839     MarkToBeReformatted( TRUE );
1840     SpinField::Modify();
1841 }
1842
1843 // -----------------------------------------------------------------------
1844
1845 void MetricField::Up()
1846 {
1847     FieldUp();
1848     SpinField::Up();
1849 }
1850
1851 // -----------------------------------------------------------------------
1852
1853 void MetricField::Down()
1854 {
1855     FieldDown();
1856     SpinField::Down();
1857 }
1858
1859 // -----------------------------------------------------------------------
1860
1861 void MetricField::First()
1862 {
1863     FieldFirst();
1864     SpinField::First();
1865 }
1866
1867 // -----------------------------------------------------------------------
1868
1869 void MetricField::Last()
1870 {
1871     FieldLast();
1872     SpinField::Last();
1873 }
1874
1875 // -----------------------------------------------------------------------
1876
1877 void MetricField::CustomConvert()
1878 {
1879     maCustomConvertLink.Call( this );
1880 }
1881
1882 // -----------------------------------------------------------------------
1883
1884 MetricBox::MetricBox( Window* pParent, WinBits nWinStyle ) :
1885     ComboBox( pParent, nWinStyle )
1886 {
1887     SetField( this );
1888     Reformat();
1889 }
1890
1891 // -----------------------------------------------------------------------
1892
1893 MetricBox::MetricBox( Window* pParent, const ResId& rResId ) :
1894     ComboBox( WINDOW_METRICBOX )
1895 {
1896     rResId.SetRT( RSC_METRICBOX );
1897     WinBits nStyle = ImplInitRes( rResId );
1898     ComboBox::ImplInit( pParent, nStyle );
1899     SetField( this );
1900     Reformat();
1901     ComboBox::ImplLoadRes( rResId );
1902     MetricFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
1903
1904     if ( !(nStyle & WB_HIDE ) )
1905         Show();
1906 }
1907
1908 // -----------------------------------------------------------------------
1909
1910 MetricBox::~MetricBox()
1911 {
1912 }
1913
1914 // -----------------------------------------------------------------------
1915
1916 long MetricBox::PreNotify( NotifyEvent& rNEvt )
1917 {
1918     if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2()  )
1919     {
1920         if ( ImplMetricProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), ImplGetLocaleDataWrapper() ) )
1921             return 1;
1922     }
1923
1924     return ComboBox::PreNotify( rNEvt );
1925 }
1926
1927 // -----------------------------------------------------------------------
1928
1929 long MetricBox::Notify( NotifyEvent& rNEvt )
1930 {
1931     if ( rNEvt.GetType() == EVENT_GETFOCUS )
1932         MarkToBeReformatted( FALSE );
1933     else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
1934     {
1935         if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
1936             Reformat();
1937     }
1938
1939     return ComboBox::Notify( rNEvt );
1940 }
1941
1942 // -----------------------------------------------------------------------
1943
1944 void MetricBox::DataChanged( const DataChangedEvent& rDCEvt )
1945 {
1946     ComboBox::DataChanged( rDCEvt );
1947
1948     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_LOCALE) )
1949     {
1950         String sOldDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
1951         String sOldThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
1952         if ( IsDefaultLocale() )
1953             ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
1954         String sNewDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
1955         String sNewThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
1956         ImplUpdateSeparators( sOldDecSep, sNewDecSep, sOldThSep, sNewThSep, this );
1957         ReformatAll();
1958     }
1959 }
1960
1961 // -----------------------------------------------------------------------
1962
1963 void MetricBox::Modify()
1964 {
1965     MarkToBeReformatted( TRUE );
1966     ComboBox::Modify();
1967 }
1968
1969 // -----------------------------------------------------------------------
1970
1971 void MetricBox::ReformatAll()
1972 {
1973     double nValue;
1974     XubString aStr;
1975     SetUpdateMode( FALSE );
1976     USHORT nEntryCount = GetEntryCount();
1977     for ( USHORT i=0; i < nEntryCount; i++ )
1978     {
1979         ImplMetricReformat( GetEntry( i ), nValue, aStr );
1980         RemoveEntry( i );
1981         InsertEntry( aStr, i );
1982     }
1983     MetricFormatter::Reformat();
1984     SetUpdateMode( TRUE );
1985 }
1986
1987 // -----------------------------------------------------------------------
1988
1989 void MetricBox::CustomConvert()
1990 {
1991     maCustomConvertLink.Call( this );
1992 }
1993
1994 // -----------------------------------------------------------------------
1995
1996 void MetricBox::InsertValue( sal_Int64 nValue, FieldUnit eInUnit, USHORT nPos )
1997 {
1998     // Umrechnen auf eingestellte Einheiten
1999     nValue = MetricField::ConvertValue( nValue, mnBaseValue, GetDecimalDigits(),
2000                                         eInUnit, meUnit );
2001     ComboBox::InsertEntry( CreateFieldText( nValue ), nPos );
2002 }
2003
2004 // -----------------------------------------------------------------------
2005
2006 void MetricBox::RemoveValue( sal_Int64 nValue, FieldUnit eInUnit )
2007 {
2008     // Umrechnen auf eingestellte Einheiten
2009     nValue = MetricField::ConvertValue( nValue, mnBaseValue, GetDecimalDigits(),
2010                                         eInUnit, meUnit );
2011     ComboBox::RemoveEntry( CreateFieldText( nValue ) );
2012 }
2013
2014 // -----------------------------------------------------------------------
2015
2016 sal_Int64 MetricBox::GetValue( USHORT nPos, FieldUnit eOutUnit ) const
2017 {
2018     double nValue = 0;
2019     ImplMetricGetValue( ComboBox::GetEntry( nPos ), nValue, mnBaseValue,
2020                         GetDecimalDigits(), ImplGetLocaleDataWrapper(), meUnit );
2021
2022     // Umrechnen auf eingestellte Einheiten
2023     sal_Int64 nRetValue = MetricField::ConvertValue( (sal_Int64)nValue, mnBaseValue, GetDecimalDigits(),
2024                                                      meUnit, eOutUnit );
2025
2026     return nRetValue;
2027 }
2028
2029 // -----------------------------------------------------------------------
2030
2031 USHORT MetricBox::GetValuePos( sal_Int64 nValue, FieldUnit eInUnit ) const
2032 {
2033     // Umrechnen auf eingestellte Einheiten
2034     nValue = MetricField::ConvertValue( nValue, mnBaseValue, GetDecimalDigits(),
2035                                         eInUnit, meUnit );
2036     return ComboBox::GetEntryPos( CreateFieldText( nValue ) );
2037 }
2038
2039 // -----------------------------------------------------------------------
2040
2041 sal_Int64 MetricBox::GetValue( FieldUnit eOutUnit ) const
2042 {
2043     // Implementation not inline, because it is a virtual Function
2044     return MetricFormatter::GetValue( eOutUnit );
2045 }
2046
2047 // -----------------------------------------------------------------------
2048
2049 sal_Int64 MetricBox::GetValue() const
2050 {
2051     // Implementation not inline, because it is a virtual Function
2052     return GetValue( FUNIT_NONE );
2053 }
2054
2055 // -----------------------------------------------------------------------
2056
2057 static BOOL ImplCurrencyProcessKeyInput( Edit* pEdit, const KeyEvent& rKEvt,
2058                                          BOOL, BOOL bUseThousandSep, const LocaleDataWrapper& rWrapper )
2059 {
2060     // Es gibt hier kein sinnvolles StrictFormat, also alle
2061     // Zeichen erlauben
2062     return ImplNumericProcessKeyInput( pEdit, rKEvt, FALSE, bUseThousandSep, rWrapper );
2063 }
2064
2065 // -----------------------------------------------------------------------
2066
2067 inline BOOL ImplCurrencyGetValue( const XubString& rStr, double& rValue,
2068                                   USHORT nDecDigits, const LocaleDataWrapper& rWrapper )
2069 {
2070     // Zahlenwert holen
2071     return ImplNumericGetValue( rStr, rValue, nDecDigits, rWrapper, TRUE );
2072 }
2073
2074 // -----------------------------------------------------------------------
2075
2076 BOOL CurrencyFormatter::ImplCurrencyReformat( const XubString& rStr,
2077                                               XubString& rOutStr )
2078 {
2079     double nValue;
2080     if ( !ImplNumericGetValue( rStr, nValue, GetDecimalDigits(), ImplGetLocaleDataWrapper(), TRUE ) )
2081         return TRUE;
2082     else
2083     {
2084         double nTempVal = nValue;
2085         // caution: precision loss in double cast
2086         if ( nTempVal > GetMax() )
2087             nTempVal = (double)GetMax();
2088         else if ( nTempVal < GetMin())
2089             nTempVal = (double)GetMin();
2090
2091         if ( GetErrorHdl().IsSet() && (nValue != nTempVal) )
2092         {
2093             mnCorrectedValue = (sal_Int64)nTempVal;
2094             if ( !GetErrorHdl().Call( this ) )
2095             {
2096                 mnCorrectedValue = 0;
2097                 return FALSE;
2098             }
2099             else
2100                 mnCorrectedValue = 0;
2101         }
2102
2103         rOutStr = CreateFieldText( (long)nTempVal );
2104         return TRUE;
2105     }
2106 }
2107
2108 // -----------------------------------------------------------------------
2109
2110 inline void CurrencyFormatter::ImplInit()
2111 {
2112     mnType = FORMAT_CURRENCY;
2113 }
2114
2115 // -----------------------------------------------------------------------
2116
2117 CurrencyFormatter::CurrencyFormatter()
2118 {
2119     ImplInit();
2120 }
2121
2122 // -----------------------------------------------------------------------
2123
2124 CurrencyFormatter::~CurrencyFormatter()
2125 {
2126 }
2127
2128 // -----------------------------------------------------------------------
2129
2130 void CurrencyFormatter::SetCurrencySymbol( const String& rStr )
2131 {
2132     maCurrencySymbol= rStr;
2133     ReformatAll();
2134 }
2135
2136 // -----------------------------------------------------------------------
2137
2138 String CurrencyFormatter::GetCurrencySymbol() const
2139 {
2140     return maCurrencySymbol.Len() ? maCurrencySymbol : ImplGetLocaleDataWrapper().getCurrSymbol();
2141 }
2142
2143 // -----------------------------------------------------------------------
2144
2145 void CurrencyFormatter::SetValue( sal_Int64 nNewValue )
2146 {
2147     SetUserValue( nNewValue );
2148     mnFieldValue = mnLastValue;
2149     SetEmptyFieldValueData( FALSE );
2150 }
2151
2152 // -----------------------------------------------------------------------
2153
2154 XubString CurrencyFormatter::CreateFieldText( sal_Int64 nValue ) const
2155 {
2156     return ImplGetLocaleDataWrapper().getCurr( nValue, GetDecimalDigits(), GetCurrencySymbol(), IsUseThousandSep() );
2157 }
2158
2159 // -----------------------------------------------------------------------
2160
2161 sal_Int64 CurrencyFormatter::GetValue() const
2162 {
2163     if ( !GetField() )
2164         return 0;
2165
2166     double nTempValue;
2167     if ( ImplCurrencyGetValue( GetField()->GetText(), nTempValue, GetDecimalDigits(), ImplGetLocaleDataWrapper() ) )
2168     {
2169         // caution: precision loss in double cast
2170         if ( nTempValue > mnMax )
2171             nTempValue = (double)mnMax;
2172         else if ( nTempValue < mnMin )
2173             nTempValue = (double)mnMin;
2174         return (sal_Int64)nTempValue;
2175     }
2176     else
2177         return mnLastValue;
2178 }
2179
2180 // -----------------------------------------------------------------------
2181
2182 void CurrencyFormatter::Reformat()
2183 {
2184     if ( !GetField() )
2185         return;
2186
2187     XubString aStr;
2188     BOOL bOK = ImplCurrencyReformat( GetField()->GetText(), aStr );
2189     if ( !bOK )
2190         return;
2191
2192     if ( aStr.Len() )
2193     {
2194         ImplSetText( aStr  );
2195         // caution: precision loss in double cast
2196         double nTemp = (double)mnLastValue;
2197         ImplCurrencyGetValue( aStr, nTemp, GetDecimalDigits(), ImplGetLocaleDataWrapper() );
2198         mnLastValue = (sal_Int64)nTemp;
2199     }
2200     else
2201         SetValue( mnLastValue );
2202 }
2203
2204 // -----------------------------------------------------------------------
2205
2206 CurrencyField::CurrencyField( Window* pParent, WinBits nWinStyle ) :
2207     SpinField( pParent, nWinStyle )
2208 {
2209     SetField( this );
2210     Reformat();
2211 }
2212
2213 // -----------------------------------------------------------------------
2214
2215 CurrencyField::CurrencyField( Window* pParent, const ResId& rResId ) :
2216     SpinField( WINDOW_CURRENCYFIELD )
2217 {
2218     rResId.SetRT( RSC_CURRENCYFIELD );
2219     WinBits nStyle = ImplInitRes( rResId );
2220     SpinField::ImplInit( pParent, nStyle);
2221     SetField( this );
2222     ImplLoadRes( rResId );
2223
2224     if ( !(nStyle & WB_HIDE ) )
2225         Show();
2226 }
2227
2228 // -----------------------------------------------------------------------
2229
2230 void CurrencyField::ImplLoadRes( const ResId& rResId )
2231 {
2232     SpinField::ImplLoadRes( rResId );
2233     CurrencyFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
2234
2235     ULONG      nMask = ReadLongRes();
2236
2237     if ( CURRENCYFIELD_FIRST & nMask )
2238         mnFirst = ReadLongRes();
2239
2240     if ( CURRENCYFIELD_LAST & nMask )
2241         mnLast = ReadLongRes();
2242
2243     if ( CURRENCYFIELD_SPINSIZE & nMask )
2244         mnSpinSize = ReadLongRes();
2245
2246     Reformat();
2247 }
2248
2249 // -----------------------------------------------------------------------
2250
2251 CurrencyField::~CurrencyField()
2252 {
2253 }
2254
2255 // -----------------------------------------------------------------------
2256
2257 long CurrencyField::PreNotify( NotifyEvent& rNEvt )
2258 {
2259     if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
2260     {
2261         if ( ImplCurrencyProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), ImplGetLocaleDataWrapper() ) )
2262             return 1;
2263     }
2264
2265     return SpinField::PreNotify( rNEvt );
2266 }
2267
2268 // -----------------------------------------------------------------------
2269
2270 long CurrencyField::Notify( NotifyEvent& rNEvt )
2271 {
2272     if ( rNEvt.GetType() == EVENT_GETFOCUS )
2273         MarkToBeReformatted( FALSE );
2274     else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
2275     {
2276         if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
2277             Reformat();
2278     }
2279
2280     return SpinField::Notify( rNEvt );
2281 }
2282
2283 // -----------------------------------------------------------------------
2284
2285 void CurrencyField::DataChanged( const DataChangedEvent& rDCEvt )
2286 {
2287     SpinField::DataChanged( rDCEvt );
2288
2289     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_LOCALE) )
2290     {
2291         String sOldDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
2292         String sOldThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
2293         if ( IsDefaultLocale() )
2294             ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
2295         String sNewDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
2296         String sNewThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
2297         ImplUpdateSeparators( sOldDecSep, sNewDecSep, sOldThSep, sNewThSep, this );
2298         ReformatAll();
2299     }
2300 }
2301
2302 // -----------------------------------------------------------------------
2303
2304 void CurrencyField::Modify()
2305 {
2306     MarkToBeReformatted( TRUE );
2307     SpinField::Modify();
2308 }
2309
2310 // -----------------------------------------------------------------------
2311
2312 void CurrencyField::Up()
2313 {
2314     FieldUp();
2315     SpinField::Up();
2316 }
2317
2318 // -----------------------------------------------------------------------
2319
2320 void CurrencyField::Down()
2321 {
2322     FieldDown();
2323     SpinField::Down();
2324 }
2325
2326 // -----------------------------------------------------------------------
2327
2328 void CurrencyField::First()
2329 {
2330     FieldFirst();
2331     SpinField::First();
2332 }
2333
2334 // -----------------------------------------------------------------------
2335
2336 void CurrencyField::Last()
2337 {
2338     FieldLast();
2339     SpinField::Last();
2340 }
2341
2342 // -----------------------------------------------------------------------
2343
2344 CurrencyBox::CurrencyBox( Window* pParent, WinBits nWinStyle ) :
2345     ComboBox( pParent, nWinStyle )
2346 {
2347     SetField( this );
2348     Reformat();
2349 }
2350
2351 // -----------------------------------------------------------------------
2352
2353 CurrencyBox::CurrencyBox( Window* pParent, const ResId& rResId ) :
2354     ComboBox( WINDOW_CURRENCYBOX )
2355 {
2356     rResId.SetRT( RSC_CURRENCYBOX );
2357     WinBits nStyle = ImplInitRes( rResId );
2358     ComboBox::ImplInit( pParent, nStyle );
2359     CurrencyFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
2360     SetField( this );
2361     ComboBox::ImplLoadRes( rResId );
2362     Reformat();
2363
2364     if ( !(nStyle & WB_HIDE ) )
2365         Show();
2366 }
2367
2368 // -----------------------------------------------------------------------
2369
2370 CurrencyBox::~CurrencyBox()
2371 {
2372 }
2373
2374 // -----------------------------------------------------------------------
2375
2376 long CurrencyBox::PreNotify( NotifyEvent& rNEvt )
2377 {
2378     if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
2379     {
2380         if ( ImplCurrencyProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), ImplGetLocaleDataWrapper() ) )
2381             return 1;
2382     }
2383
2384     return ComboBox::PreNotify( rNEvt );
2385 }
2386
2387 // -----------------------------------------------------------------------
2388
2389 long CurrencyBox::Notify( NotifyEvent& rNEvt )
2390 {
2391     if ( rNEvt.GetType() == EVENT_GETFOCUS )
2392         MarkToBeReformatted( FALSE );
2393     else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
2394     {
2395         if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
2396             Reformat();
2397     }
2398
2399     return ComboBox::Notify( rNEvt );
2400 }
2401
2402 // -----------------------------------------------------------------------
2403
2404 void CurrencyBox::DataChanged( const DataChangedEvent& rDCEvt )
2405 {
2406     ComboBox::DataChanged( rDCEvt );
2407
2408     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_LOCALE) )
2409     {
2410         String sOldDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
2411         String sOldThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
2412         if ( IsDefaultLocale() )
2413             ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
2414         String sNewDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
2415         String sNewThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
2416         ImplUpdateSeparators( sOldDecSep, sNewDecSep, sOldThSep, sNewThSep, this );
2417         ReformatAll();
2418     }
2419 }
2420
2421 // -----------------------------------------------------------------------
2422
2423 void CurrencyBox::Modify()
2424 {
2425     MarkToBeReformatted( TRUE );
2426     ComboBox::Modify();
2427 }
2428
2429 // -----------------------------------------------------------------------
2430
2431 void CurrencyBox::ReformatAll()
2432 {
2433     XubString aStr;
2434     SetUpdateMode( FALSE );
2435     USHORT nEntryCount = GetEntryCount();
2436     for ( USHORT i=0; i < nEntryCount; i++ )
2437     {
2438         ImplCurrencyReformat( GetEntry( i ), aStr );
2439         RemoveEntry( i );
2440         InsertEntry( aStr, i );
2441     }
2442     CurrencyFormatter::Reformat();
2443     SetUpdateMode( TRUE );
2444 }
2445
2446 // -----------------------------------------------------------------------
2447
2448 void CurrencyBox::InsertValue( sal_Int64 nValue, USHORT nPos )
2449 {
2450     ComboBox::InsertEntry( CreateFieldText( nValue ), nPos );
2451 }
2452
2453 // -----------------------------------------------------------------------
2454
2455 void CurrencyBox::RemoveValue( sal_Int64 nValue )
2456 {
2457     ComboBox::RemoveEntry( CreateFieldText( nValue ) );
2458 }
2459
2460 // -----------------------------------------------------------------------
2461
2462 sal_Int64 CurrencyBox::GetValue( USHORT nPos ) const
2463 {
2464     double nValue = 0;
2465     ImplCurrencyGetValue( ComboBox::GetEntry( nPos ), nValue, GetDecimalDigits(), ImplGetLocaleDataWrapper() );
2466     return (sal_Int64)nValue;
2467 }
2468
2469 // -----------------------------------------------------------------------
2470
2471 USHORT CurrencyBox::GetValuePos( sal_Int64 nValue ) const
2472 {
2473     return ComboBox::GetEntryPos( CreateFieldText( nValue ) );
2474 }
2475
2476 // -----------------------------------------------------------------------
2477
2478 sal_Int64 CurrencyBox::GetValue() const
2479 {
2480     // Implementation not inline, because it is a virtual Function
2481     return CurrencyFormatter::GetValue();
2482 }