/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_vcl.hxx"
#ifndef _BIGINT_HXX
#define _TOOLS_BIGINT
#include "tools/bigint.hxx"
#endif
#include "tools/debug.hxx"
#include "tools/rc.h"
#include "tools/resary.hxx"
#include "vcl/field.hxx"
#include "vcl/event.hxx"
#include "vcl/svapp.hxx"
#include "vcl/unohelp.hxx"
#include "svids.hrc"
#include "svdata.hxx"
#include "i18nutil/unicode.hxx"
#include "rtl/math.hxx"
#include <unotools/localedatawrapper.hxx>
using namespace ::com::sun::star;
// -----------------------------------------------------------------------
#define FORMAT_NUMERIC 1
#define FORMAT_METRIC 2
#define FORMAT_CURRENCY 3
// -----------------------------------------------------------------------
static sal_Int64 ImplPower10( sal_uInt16 n )
{
sal_uInt16 i;
sal_Int64 nValue = 1;
for ( i=0; i < n; i++ )
nValue *= 10;
return nValue;
}
// -----------------------------------------------------------------------
static sal_Bool ImplNumericProcessKeyInput( Edit*, const KeyEvent& rKEvt,
sal_Bool bStrictFormat, sal_Bool bThousandSep,
const LocaleDataWrapper& rLocaleDataWrappper )
{
if ( !bStrictFormat )
return sal_False;
else
{
xub_Unicode cChar = rKEvt.GetCharCode();
sal_uInt16 nGroup = rKEvt.GetKeyCode().GetGroup();
if ( (nGroup == KEYGROUP_FKEYS) || (nGroup == KEYGROUP_CURSOR) ||
(nGroup == KEYGROUP_MISC) ||
((cChar >= '0') && (cChar <= '9')) ||
(cChar == rLocaleDataWrappper.getNumDecimalSep() ) ||
(bThousandSep && (cChar == rLocaleDataWrappper.getNumThousandSep())) ||
(cChar == '-') )
return sal_False;
else
return sal_True;
}
}
// -----------------------------------------------------------------------
static sal_Bool ImplNumericGetValue( const XubString& rStr, double& rValue,
sal_uInt16 nDecDigits, const LocaleDataWrapper& rLocaleDataWrappper,
sal_Bool bCurrency = sal_False )
{
XubString aStr = rStr;
XubString aStr1;
XubString aStr2;
sal_Bool bNegative = sal_False;
xub_StrLen nDecPos;
xub_StrLen i;
// Reaktion auf leeren String
if ( !rStr.Len() )
return sal_False;
// Fuehrende und nachfolgende Leerzeichen entfernen
aStr.EraseLeadingAndTrailingChars( ' ' );
// Position des Dezimalpunktes suchen
nDecPos = aStr.Search( rLocaleDataWrappper.getNumDecimalSep() );
if ( nDecPos != STRING_NOTFOUND )
{
aStr1 = aStr.Copy( 0, nDecPos );
aStr2 = aStr.Copy( nDecPos+1 );
}
else
aStr1 = aStr;
// Negativ ?
if ( bCurrency )
{
if ( (aStr.GetChar( 0 ) == '(') && (aStr.GetChar( aStr.Len()-1 ) == ')') )
bNegative = sal_True;
if ( !bNegative )
{
for ( i=0; i < aStr.Len(); i++ )
{
if ( (aStr.GetChar( i ) >= '0') && (aStr.GetChar( i ) <= '9') )
break;
else if ( aStr.GetChar( i ) == '-' )
{
bNegative = sal_True;
break;
}
}
}
if ( !bNegative && bCurrency && aStr.Len() )
{
sal_uInt16 nFormat = rLocaleDataWrappper.getCurrNegativeFormat();
if ( (nFormat == 3) || (nFormat == 6) ||
(nFormat == 7) || (nFormat == 10) )
{
for ( i = (xub_StrLen)(aStr.Len()-1); i > 0; i++ )
{
if ( (aStr.GetChar( i ) >= '0') && (aStr.GetChar( i ) <= '9') )
break;
else if ( aStr.GetChar( i ) == '-' )
{
bNegative = sal_True;
break;
}
}
}
}
}
else
{
if ( aStr1.GetChar( 0 ) == '-' )
bNegative = sal_True;
}
// Alle unerwuenschten Zeichen rauswerfen
for ( i=0; i < aStr1.Len(); )
{
if ( (aStr1.GetChar( i ) >= '0') && (aStr1.GetChar( i ) <= '9') )
i++;
else
aStr1.Erase( i, 1 );
}
for ( i=0; i < aStr2.Len(); )
{
if ( (aStr2.GetChar( i ) >= '0') && (aStr2.GetChar( i ) <= '9') )
i++;
else
aStr2.Erase( i, 1 );
}
if ( !aStr1.Len() && !aStr2.Len() )
return sal_False;
if ( !aStr1.Len() )
aStr1.Insert( '0' );
if ( bNegative )
aStr1.Insert( '-', 0 );
// Nachkommateil zurechtstutzen und dabei runden
sal_Bool bRound = sal_False;
if ( aStr2.Len() > nDecDigits )
{
if ( aStr2.GetChar( nDecDigits ) >= '5' )
bRound = sal_True;
aStr2.Erase( nDecDigits );
}
if ( aStr2.Len() < nDecDigits )
aStr2.Expand( nDecDigits, '0' );
aStr = aStr1;
aStr += aStr2;
// Bereichsueberpruefung
double nValue = aStr.ToDouble();
if ( bRound )
{
if ( !bNegative )
nValue++;
else
nValue--;
}
rValue = nValue;
return sal_True;
}
static void ImplUpdateSeparatorString( String& io_rText,
const String& rOldDecSep, const String& rNewDecSep,
const String& rOldThSep, const String& rNewThSep )
{
rtl::OUStringBuffer aBuf( io_rText.Len() );
xub_StrLen nIndexDec = 0, nIndexTh = 0, nIndex = 0;
const sal_Unicode* pBuffer = io_rText.GetBuffer();
while( nIndex != STRING_NOTFOUND )
{
nIndexDec = io_rText.Search( rOldDecSep, nIndex );
nIndexTh = io_rText.Search( rOldThSep, nIndex );
if( (nIndexTh != STRING_NOTFOUND && nIndexDec != STRING_NOTFOUND && nIndexTh < nIndexDec )
|| (nIndexTh != STRING_NOTFOUND && nIndexDec == STRING_NOTFOUND)
)
{
aBuf.append( pBuffer + nIndex, nIndexTh - nIndex );
aBuf.append( rNewThSep );
nIndex = nIndexTh + rOldThSep.Len();
}
else if( nIndexDec != STRING_NOTFOUND )
{
aBuf.append( pBuffer + nIndex, nIndexDec - nIndex );
aBuf.append( rNewDecSep );
nIndex = nIndexDec + rOldDecSep.Len();
}
else
{
aBuf.append( pBuffer + nIndex );
nIndex = STRING_NOTFOUND;
}
}
io_rText = aBuf.makeStringAndClear();
}
static void ImplUpdateSeparators( const String& rOldDecSep, const String& rNewDecSep,
const String& rOldThSep, const String& rNewThSep,
Edit* pEdit )
{
bool bChangeDec = (rOldDecSep != rNewDecSep);
bool bChangeTh = (rOldThSep != rNewThSep );
if( bChangeDec || bChangeTh )
{
sal_Bool bUpdateMode = pEdit->IsUpdateMode();
pEdit->SetUpdateMode( sal_False );
String aText = pEdit->GetText();
ImplUpdateSeparatorString( aText, rOldDecSep, rNewDecSep, rOldThSep, rNewThSep );
pEdit->SetText( aText );
ComboBox* pCombo = dynamic_cast<ComboBox*>(pEdit);
if( pCombo )
{
// update box entries
sal_uInt16 nEntryCount = pCombo->GetEntryCount();
for ( sal_uInt16 i=0; i < nEntryCount; i++ )
{
aText = pCombo->GetEntry( i );
void* pEntryData = pCombo->GetEntryData( i );
ImplUpdateSeparatorString( aText, rOldDecSep, rNewDecSep, rOldThSep, rNewThSep );
pCombo->RemoveEntry( i );
pCombo->InsertEntry( aText, i );
pCombo->SetEntryData( i, pEntryData );
}
}
if( bUpdateMode )
pEdit->SetUpdateMode( bUpdateMode );
}
}
// -----------------------------------------------------------------------
FormatterBase::FormatterBase( Edit* pField )
{
mpField = pField;
mpLocaleDataWrapper = NULL;
mbReformat = sal_False;
mbStrictFormat = sal_False;
mbEmptyFieldValue = sal_False;
mbEmptyFieldValueEnabled = sal_False;
mbDefaultLocale = sal_True;
}
// -----------------------------------------------------------------------
FormatterBase::~FormatterBase()
{
delete mpLocaleDataWrapper;
}
// -----------------------------------------------------------------------
LocaleDataWrapper& FormatterBase::ImplGetLocaleDataWrapper() const
{
if ( !mpLocaleDataWrapper )
{
((FormatterBase*)this)->mpLocaleDataWrapper = new LocaleDataWrapper( vcl::unohelper::GetMultiServiceFactory(), GetLocale() );
}
return *mpLocaleDataWrapper;
}
const LocaleDataWrapper& FormatterBase::GetLocaleDataWrapper() const
{
return ImplGetLocaleDataWrapper();
}
// -----------------------------------------------------------------------
void FormatterBase::Reformat()
{
}
// -----------------------------------------------------------------------
void FormatterBase::ReformatAll()
{
Reformat();
};
// -----------------------------------------------------------------------
void FormatterBase::SetStrictFormat( sal_Bool bStrict )
{
if ( bStrict != mbStrictFormat )
{
mbStrictFormat = bStrict;
if ( mbStrictFormat )
ReformatAll();
}
}
// -----------------------------------------------------------------------
void FormatterBase::SetLocale( const lang::Locale& rLocale )
{
ImplGetLocaleDataWrapper().setLocale( rLocale );
mbDefaultLocale = sal_False;
ReformatAll();
}
// -----------------------------------------------------------------------
const lang::Locale& FormatterBase::GetLocale() const
{
if ( !mpLocaleDataWrapper || mbDefaultLocale )
{
if ( mpField )
return mpField->GetSettings().GetLocale();
else
return Application::GetSettings().GetLocale();
}
return mpLocaleDataWrapper->getLocale();
}
// -----------------------------------------------------------------------
const AllSettings& FormatterBase::GetFieldSettings() const
{
if ( mpField )
return mpField->GetSettings();
else
return Application::GetSettings();
}
// -----------------------------------------------------------------------
void FormatterBase::SetFieldText( const XubString& rText, sal_Bool bKeepSelection )
{
if ( mpField )
{
Selection aNewSelection( 0xFFFF, 0xFFFF );
if ( bKeepSelection )
aNewSelection = mpField->GetSelection();
ImplSetText( rText, &aNewSelection );
}
}
// -----------------------------------------------------------------------
void FormatterBase::ImplSetText( const XubString& rText, Selection* pNewSelection )
{
if ( mpField )
{
if ( pNewSelection )
mpField->SetText( rText, *pNewSelection );
else
{
Selection aSel = mpField->GetSelection();
aSel.Min() = aSel.Max();
mpField->SetText( rText, aSel );
}
MarkToBeReformatted( sal_False );
}
}
// -----------------------------------------------------------------------
void FormatterBase::SetEmptyFieldValue()
{
if ( mpField )
mpField->SetText( ImplGetSVEmptyStr() );
mbEmptyFieldValue = sal_True;
}
// -----------------------------------------------------------------------
sal_Bool FormatterBase::IsEmptyFieldValue() const
{
return (!mpField || !mpField->GetText().Len());
}
// -----------------------------------------------------------------------
sal_Bool NumericFormatter::ImplNumericReformat( const XubString& rStr, double& rValue,
XubString& rOutStr )
{
if ( !ImplNumericGetValue( rStr, rValue, GetDecimalDigits(), ImplGetLocaleDataWrapper() ) )
return sal_True;
else
{
double nTempVal = rValue;
// caution: precision loss in double cast
if ( nTempVal > mnMax )
nTempVal = (double)mnMax;
else if ( nTempVal < mnMin )
nTempVal = (double)mnMin;
if ( GetErrorHdl().IsSet() && (rValue != nTempVal) )
{
mnCorrectedValue = (sal_Int64)nTempVal;
if ( !GetErrorHdl().Call( this ) )
{
mnCorrectedValue = 0;
return sal_False;
}
else
mnCorrectedValue = 0;
}
rOutStr = CreateFieldText( (sal_Int64)nTempVal );
return sal_True;
}
}
// -----------------------------------------------------------------------
void NumericFormatter::ImplInit()
{
mnFieldValue = 0;
mnLastValue = 0;
mnMin = 0;
mnMax = 0x7FFFFFFFFFFFFFFFLL;
#ifdef OS2 // see i120312 for details.
mnMax = 0x00000000FFFFFFFFLL;
#endif
mnCorrectedValue = 0;
mnDecimalDigits = 2;
mnType = FORMAT_NUMERIC;
mbThousandSep = sal_True;
mbShowTrailingZeros = sal_True;
// for fields
mnSpinSize = 1;
mnFirst = mnMin;
mnLast = mnMax;
SetDecimalDigits( 0 );
}
// -----------------------------------------------------------------------
NumericFormatter::NumericFormatter()
{
ImplInit();
}
// -----------------------------------------------------------------------
void NumericFormatter::ImplLoadRes( const ResId& rResId )
{
ResMgr* pMgr = rResId.GetResMgr();
if( pMgr )
{
sal_uLong nMask = pMgr->ReadLong();
if ( NUMERICFORMATTER_MIN & nMask )
mnMin = pMgr->ReadLong();
if ( NUMERICFORMATTER_MAX & nMask )
mnMax = pMgr->ReadLong();
if ( NUMERICFORMATTER_STRICTFORMAT & nMask )
SetStrictFormat( (sal_Bool)pMgr->ReadShort() );
if ( NUMERICFORMATTER_DECIMALDIGITS & nMask )
SetDecimalDigits( pMgr->ReadShort() );
if ( NUMERICFORMATTER_VALUE & nMask )
{
mnFieldValue = pMgr->ReadLong();
if ( mnFieldValue > mnMax )
mnFieldValue = mnMax;
else if ( mnFieldValue < mnMin )
mnFieldValue = mnMin;
mnLastValue = mnFieldValue;
}
if ( NUMERICFORMATTER_NOTHOUSANDSEP & nMask )
SetUseThousandSep( !(sal_Bool)pMgr->ReadShort() );
}
}
// -----------------------------------------------------------------------
NumericFormatter::~NumericFormatter()
{
}
// -----------------------------------------------------------------------
void NumericFormatter::SetMin( sal_Int64 nNewMin )
{
mnMin = nNewMin;
if ( !IsEmptyFieldValue() )
ReformatAll();
}
// -----------------------------------------------------------------------
void NumericFormatter::SetMax( sal_Int64 nNewMax )
{
mnMax = nNewMax;
if ( !IsEmptyFieldValue() )
ReformatAll();
}
// -----------------------------------------------------------------------
void NumericFormatter::SetUseThousandSep( sal_Bool b )
{
mbThousandSep = b;
ReformatAll();
}
// -----------------------------------------------------------------------
void NumericFormatter::SetDecimalDigits( sal_uInt16 nDigits )
{
mnDecimalDigits = nDigits;
ReformatAll();
}
// -----------------------------------------------------------------------
void NumericFormatter::SetShowTrailingZeros( sal_Bool bShowTrailingZeros )
{
if ( mbShowTrailingZeros != bShowTrailingZeros )
{
mbShowTrailingZeros = bShowTrailingZeros;
ReformatAll();
}
}
// -----------------------------------------------------------------------
sal_uInt16 NumericFormatter::GetDecimalDigits() const
{
return mnDecimalDigits;
}
// -----------------------------------------------------------------------
void NumericFormatter::SetValue( sal_Int64 nNewValue )
{
SetUserValue( nNewValue );
mnFieldValue = mnLastValue;
SetEmptyFieldValueData( sal_False );
}
// -----------------------------------------------------------------------
XubString NumericFormatter::CreateFieldText( sal_Int64 nValue ) const
{
return ImplGetLocaleDataWrapper().getNum( nValue, GetDecimalDigits(), IsUseThousandSep(), IsShowTrailingZeros() );
}
// -----------------------------------------------------------------------
void NumericFormatter::ImplSetUserValue( sal_Int64 nNewValue, Selection* pNewSelection )
{
if ( nNewValue > mnMax )
nNewValue = mnMax;
else if ( nNewValue < mnMin )
nNewValue = mnMin;
mnLastValue = nNewValue;
if ( GetField() )
ImplSetText( CreateFieldText( nNewValue ), pNewSelection );
}
// -----------------------------------------------------------------------
void NumericFormatter::SetUserValue( sal_Int64 nNewValue )
{
ImplSetUserValue( nNewValue );
}
// -----------------------------------------------------------------------
sal_Int64 NumericFormatter::GetValue() const
{
if ( !GetField() )
return 0;
double nTempValue;
if ( ImplNumericGetValue( GetField()->GetText(), nTempValue,
GetDecimalDigits(), ImplGetLocaleDataWrapper() ) )
{
// caution: precision loss in double cast
if ( nTempValue > mnMax )
nTempValue = (double)mnMax;
else if ( nTempValue < mnMin )
nTempValue = (double)mnMin;
return (sal_Int64)nTempValue;
}
else
return mnLastValue;
}
// -----------------------------------------------------------------------
sal_Bool NumericFormatter::IsValueModified() const
{
if ( ImplGetEmptyFieldValue() )
return !IsEmptyFieldValue();
else if ( GetValue() != mnFieldValue )
return sal_True;
else
return sal_False;
}
// -----------------------------------------------------------------------
Fraction NumericFormatter::ConvertToFraction( sal_Int64 nValue )
{
// caution: precision loss in double cast (and in fraction anyhow)
return Fraction( (double)nValue/(double)ImplPower10( GetDecimalDigits() ) );
}
// -----------------------------------------------------------------------
sal_Int64 NumericFormatter::ConvertToLong( const Fraction& rValue )
{
Fraction aFract = rValue;
aFract *= Fraction( (long)ImplPower10( GetDecimalDigits() ), 1 );
return (sal_Int64)(double)aFract;
}
// -----------------------------------------------------------------------
sal_Int64 NumericFormatter::Normalize( sal_Int64 nValue ) const
{
return (nValue * ImplPower10( GetDecimalDigits() ) );
}
// -----------------------------------------------------------------------
sal_Int64 NumericFormatter::Denormalize( sal_Int64 nValue ) const
{
sal_Int64 nFactor = ImplPower10( GetDecimalDigits() );
if((nValue < ( SAL_MIN_INT64 + nFactor )) ||
(nValue > ( SAL_MAX_INT64 - nFactor )))
return ( nValue / nFactor );
if( nValue < 0 )
return ((nValue-(nFactor/2)) / nFactor );
else
return ((nValue+(nFactor/2)) / nFactor );
}
// -----------------------------------------------------------------------
void NumericFormatter::Reformat()
{
if ( !GetField() )
return;
if ( !GetField()->GetText().Len() && ImplGetEmptyFieldValue() )
return;
XubString aStr;
// caution: precision loss in double cast
double nTemp = (double)mnLastValue;
sal_Bool bOK = ImplNumericReformat( GetField()->GetText(), nTemp, aStr );
mnLastValue = (sal_Int64)nTemp;
if ( !bOK )
return;
if ( aStr.Len() )
ImplSetText( aStr );
else
SetValue( mnLastValue );
}
// -----------------------------------------------------------------------
void NumericFormatter::FieldUp()
{
sal_Int64 nValue = GetValue();
nValue += mnSpinSize;
if ( nValue > mnMax )
nValue = mnMax;
ImplNewFieldValue( nValue );
}
// -----------------------------------------------------------------------
void NumericFormatter::FieldDown()
{
sal_Int64 nValue = GetValue();
nValue -= mnSpinSize;
if ( nValue < mnMin )
nValue = mnMin;
ImplNewFieldValue( nValue );
}
// -----------------------------------------------------------------------
void NumericFormatter::FieldFirst()
{
ImplNewFieldValue( mnFirst );
}
// -----------------------------------------------------------------------
void NumericFormatter::FieldLast()
{
ImplNewFieldValue( mnLast );
}
// -----------------------------------------------------------------------
void NumericFormatter::ImplNewFieldValue( sal_Int64 nNewValue )
{
if ( GetField() )
{
// !!! TH-18.2.99: Wenn wir Zeit haben sollte mal geklaert werden,
// !!! warum nicht bei ImplSetUserValue() geprueft wird, ob
// !!! sich der Wert aendert. Denn auch hier muesste dieses
// !!! gemacht werden, da ansonsten der Modify-Aufruf
// !!! nicht gemacht werden duerfte. Jedenfalls sollten die
// !!! Wege von ImplNewFieldValue, ImplSetUserValue und
// !!! ImplSetText ueberprueft und klarer gestalltet (mit Kommentar)
// !!! werden, damit wir mal wissen, was dort ablaeuft!!!
Selection aSelection = GetField()->GetSelection();
aSelection.Justify();
XubString aText = GetField()->GetText();
// Wenn bis ans Ende selektiert war, soll das auch so bleiben...
if ( (xub_StrLen)aSelection.Max() == aText.Len() )
{
if ( !aSelection.Len() )
aSelection.Min() = SELECTION_MAX;
aSelection.Max() = SELECTION_MAX;
}
sal_Int64 nOldLastValue = mnLastValue;
ImplSetUserValue( nNewValue, &aSelection );
mnLastValue = nOldLastValue;
// Modify am Edit wird nur bei KeyInput gesetzt...
if ( GetField()->GetText() != aText )
{
GetField()->SetModifyFlag();
GetField()->Modify();
}
}
}
// -----------------------------------------------------------------------
NumericField::NumericField( Window* pParent, WinBits nWinStyle ) :
SpinField( pParent, nWinStyle )
{
SetField( this );
Reformat();
}
// -----------------------------------------------------------------------
NumericField::NumericField( Window* pParent, const ResId& rResId ) :
SpinField( WINDOW_NUMERICFIELD )
{
rResId.SetRT( RSC_NUMERICFIELD );
WinBits nStyle = ImplInitRes( rResId ) ;
SpinField::ImplInit( pParent, nStyle );
SetField( this );
ImplLoadRes( rResId );
Reformat();
if ( !(nStyle & WB_HIDE ) )
Show();
}
// -----------------------------------------------------------------------
void NumericField::ImplLoadRes( const ResId& rResId )
{
SpinField::ImplLoadRes( rResId );
NumericFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
sal_uLong nMask = ReadLongRes();
if ( NUMERICFIELD_FIRST & nMask )
mnFirst = ReadLongRes();
if ( NUMERICFIELD_LAST & nMask )
mnLast = ReadLongRes();
if ( NUMERICFIELD_SPINSIZE & nMask )
mnSpinSize = ReadLongRes();
}
// -----------------------------------------------------------------------
NumericField::~NumericField()
{
}
// -----------------------------------------------------------------------
long NumericField::PreNotify( NotifyEvent& rNEvt )
{
if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
{
if ( ImplNumericProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), ImplGetLocaleDataWrapper() ) )
return 1;
}
return SpinField::PreNotify( rNEvt );
}
// -----------------------------------------------------------------------
long NumericField::Notify( NotifyEvent& rNEvt )
{
if ( rNEvt.GetType() == EVENT_GETFOCUS )
MarkToBeReformatted( sal_False );
else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
{
if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
Reformat();
}
return SpinField::Notify( rNEvt );
}
// -----------------------------------------------------------------------
void NumericField::DataChanged( const DataChangedEvent& rDCEvt )
{
SpinField::DataChanged( rDCEvt );
if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_LOCALE) )
{
String sOldDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
String sOldThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
if ( IsDefaultLocale() )
ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
String sNewDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
String sNewThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
ImplUpdateSeparators( sOldDecSep, sNewDecSep, sOldThSep, sNewThSep, this );
ReformatAll();
}
}
// -----------------------------------------------------------------------
void NumericField::Modify()
{
MarkToBeReformatted( sal_True );
SpinField::Modify();
}
// -----------------------------------------------------------------------
void NumericField::Up()
{
FieldUp();
SpinField::Up();
}
// -----------------------------------------------------------------------
void NumericField::Down()
{
FieldDown();
SpinField::Down();
}
// -----------------------------------------------------------------------
void NumericField::First()
{
FieldFirst();
SpinField::First();
}
// -----------------------------------------------------------------------
void NumericField::Last()
{
FieldLast();
SpinField::Last();
}
// -----------------------------------------------------------------------
NumericBox::NumericBox( Window* pParent, WinBits nWinStyle ) :
ComboBox( pParent, nWinStyle )
{
SetField( this );
Reformat();
}
// -----------------------------------------------------------------------
NumericBox::NumericBox( Window* pParent, const ResId& rResId ) :
ComboBox( WINDOW_NUMERICBOX )
{
rResId.SetRT( RSC_NUMERICBOX );
WinBits nStyle = ImplInitRes( rResId );
ComboBox::ImplInit( pParent, nStyle );
SetField( this );
ComboBox::ImplLoadRes( rResId );
NumericFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
Reformat();
if ( !(nStyle & WB_HIDE ) )
Show();
}
// -----------------------------------------------------------------------
NumericBox::~NumericBox()
{
}
// -----------------------------------------------------------------------
long NumericBox::PreNotify( NotifyEvent& rNEvt )
{
if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
{
if ( ImplNumericProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), ImplGetLocaleDataWrapper() ) )
return 1;
}
return ComboBox::PreNotify( rNEvt );
}
// -----------------------------------------------------------------------
long NumericBox::Notify( NotifyEvent& rNEvt )
{
if ( rNEvt.GetType() == EVENT_GETFOCUS )
MarkToBeReformatted( sal_False );
else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
{
if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
Reformat();
}
return ComboBox::Notify( rNEvt );
}
// -----------------------------------------------------------------------
void NumericBox::DataChanged( const DataChangedEvent& rDCEvt )
{
ComboBox::DataChanged( rDCEvt );
if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_LOCALE) )
{
String sOldDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
String sOldThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
if ( IsDefaultLocale() )
ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
String sNewDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
String sNewThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
ImplUpdateSeparators( sOldDecSep, sNewDecSep, sOldThSep, sNewThSep, this );
ReformatAll();
}
}
// -----------------------------------------------------------------------
void NumericBox::Modify()
{
MarkToBeReformatted( sal_True );
ComboBox::Modify();
}
// -----------------------------------------------------------------------
void NumericBox::ReformatAll()
{
double nValue;
XubString aStr;
SetUpdateMode( sal_False );
sal_uInt16 nEntryCount = GetEntryCount();
for ( sal_uInt16 i=0; i < nEntryCount; i++ )
{
ImplNumericReformat( GetEntry( i ), nValue, aStr );
RemoveEntry( i );
InsertEntry( aStr, i );
}
NumericFormatter::Reformat();
SetUpdateMode( sal_True );
}
// -----------------------------------------------------------------------
void NumericBox::InsertValue( sal_Int64 nValue, sal_uInt16 nPos )
{
ComboBox::InsertEntry( CreateFieldText( nValue ), nPos );
}
// -----------------------------------------------------------------------
void NumericBox::RemoveValue( sal_Int64 nValue )
{
ComboBox::RemoveEntry( CreateFieldText( nValue ) );
}
// -----------------------------------------------------------------------
sal_Int64 NumericBox::GetValue( sal_uInt16 nPos ) const
{
double nValue = 0;
ImplNumericGetValue( ComboBox::GetEntry( nPos ), nValue, GetDecimalDigits(), ImplGetLocaleDataWrapper() );
return (sal_Int64)nValue;
}
// -----------------------------------------------------------------------
sal_uInt16 NumericBox::GetValuePos( sal_Int64 nValue ) const
{
return ComboBox::GetEntryPos( CreateFieldText( nValue ) );
}
// -----------------------------------------------------------------------
static sal_Bool ImplMetricProcessKeyInput( Edit* pEdit, const KeyEvent& rKEvt,
sal_Bool, sal_Bool bUseThousandSep, const LocaleDataWrapper& rWrapper )
{
// Es gibt hier kein sinnvolles StrictFormat, also alle
// Zeichen erlauben
return ImplNumericProcessKeyInput( pEdit, rKEvt, sal_False, bUseThousandSep, rWrapper );
}
// -----------------------------------------------------------------------
static XubString ImplMetricGetUnitText( const XubString& rStr )
{
// Einheitentext holen
XubString aStr;
for ( short i = rStr.Len()-1; i >= 0; i-- )
{
xub_Unicode c = rStr.GetChar( i );
if ( unicode::isAlpha( c ) ||
(c == '\'') || (c == '\"') || (c == '%' ) )
aStr.Insert( c, 0 );
else
{
if ( aStr.Len() )
break;
}
}
return aStr;
/*
// MT: #90545# Preparation for translated strings...
String aMetricText;
for ( sal_uInt16 n = rStr.Len(); n; )
{
sal_Unicode c = rStr.GetChar( --n );
sal_Int32 nType = xCharClass->getStringType( rStr, n, 1, rLocale );
if ( CharClass::isLetterType( nType ) )
{
aMetricText.Insert( c, 0 );
}
else
{
if ( aMetricText.Len() )
break;
}
}
*/
}
// -----------------------------------------------------------------------
// #104355# support localized mesaurements
static const String& ImplMetricToString( FieldUnit rUnit )
{
FieldUnitStringList* pList = ImplGetFieldUnits();
if( pList )
{
// return unit's default string (ie, the first one )
for( FieldUnitStringList::const_iterator it = pList->begin(); it != pList->end(); ++it )
{
if ( it->second == rUnit )
return it->first;
}
}
return String::EmptyString();
}
static FieldUnit ImplStringToMetric( const String &rMetricString )
{
FieldUnitStringList* pList = ImplGetCleanedFieldUnits();
if( pList )
{
// return FieldUnit
String aStr( rMetricString );
aStr.ToLowerAscii();
aStr.EraseAllChars( sal_Unicode( ' ' ) );
for( FieldUnitStringList::const_iterator it = pList->begin(); it != pList->end(); ++it )
{
if ( it->first.Equals( aStr ) )
return it->second;
}
}
return FUNIT_NONE;
}
// -----------------------------------------------------------------------
static FieldUnit ImplMetricGetUnit( const XubString& rStr )
{
XubString aStr = ImplMetricGetUnitText( rStr );
return ImplStringToMetric( aStr );
}
#define K *1000L
#define M *1000000L
#define X *5280L
static const sal_Int64 aImplFactor[FUNIT_MILE+1][FUNIT_MILE+1] =
{ /*
mm/100 mm cm m km twip point pica inch foot mile */
{ 1, 100, 1 K, 100 K, 100 M, 2540, 2540, 2540, 2540,2540*12,2540*12 X },
{ 1, 1, 10, 1 K, 1 M, 2540, 2540, 2540, 2540,2540*12,2540*12 X },
{ 1, 1, 1, 100, 100 K, 254, 254, 254, 254, 254*12, 254*12 X },
{ 1, 1, 1, 1, 1 K, 254, 254, 254, 254, 254*12, 254*12 X },
{ 1, 1, 1, 1, 1, 0, 254, 254, 254, 254*12, 254*12 X },
{ 1440,144 K,144 K,14400 K, 0, 1, 20, 240, 1440,1440*12,1440*12 X },
{ 72, 7200, 7200, 720 K, 720 M, 1, 1, 12, 72, 72*12, 72*12 X },
{ 6, 600, 600, 60 K, 60 M, 1, 1, 1, 6, 6*12, 6*12 X },
{ 1, 100, 100, 10 K, 10 M, 1, 1, 1, 1, 12, 12 X },
{ 1, 100, 100, 10 K, 10 M, 1, 1, 1, 1, 1, 1 X },
{ 1, 100, 100, 10 K, 10 M, 1, 1, 1, 1, 1, 1 }
};
#undef X
#undef M
#undef K
// twip in km 254/14400 M
static FieldUnit eDefaultUnit = FUNIT_NONE;
FieldUnit MetricField::GetDefaultUnit() { return eDefaultUnit; }
void MetricField::SetDefaultUnit( FieldUnit meUnit ) { eDefaultUnit = meUnit; }
static FieldUnit ImplMap2FieldUnit( MapUnit meUnit, long& nDecDigits )
{
switch( meUnit )
{
case MAP_100TH_MM :
nDecDigits -= 2;
return FUNIT_MM;
case MAP_10TH_MM :
nDecDigits -= 1;
return FUNIT_MM;
case MAP_MM :
return FUNIT_MM;
case MAP_CM :
return FUNIT_CM;
case MAP_1000TH_INCH :
nDecDigits -= 3;
return FUNIT_INCH;
case MAP_100TH_INCH :
nDecDigits -= 2;
return FUNIT_INCH;
case MAP_10TH_INCH :
nDecDigits -= 1;
return FUNIT_INCH;
case MAP_INCH :
return FUNIT_INCH;
case MAP_POINT :
return FUNIT_POINT;
case MAP_TWIP :
return FUNIT_TWIP;
default:
DBG_ERROR( "default eInUnit" );
break;
}
return FUNIT_NONE;
}
// -----------------------------------------------------------------------
static double nonValueDoubleToValueDouble( double nValue )
{
return rtl::math::isFinite( nValue ) ? nValue : 0.0;
}
sal_Int64 MetricField::ConvertValue( sal_Int64 nValue, sal_Int64 mnBaseValue, sal_uInt16 nDecDigits,
FieldUnit eInUnit, FieldUnit eOutUnit )
{
double nDouble = nonValueDoubleToValueDouble( ConvertDoubleValue(
(double)nValue, mnBaseValue, nDecDigits, eInUnit, eOutUnit ) );
sal_Int64 nLong ;
// caution: precision loss in double cast
if ( nDouble <= (double)SAL_MIN_INT64 )
nLong = SAL_MIN_INT64;
else if ( nDouble >= (double)SAL_MAX_INT64 )
nLong = SAL_MAX_INT64;
else
nLong = static_cast<sal_Int64>( nDouble );
return ( nLong );
}
// -----------------------------------------------------------------------
sal_Int64 MetricField::ConvertValue( sal_Int64 nValue, sal_uInt16 nDigits,
MapUnit eInUnit, FieldUnit eOutUnit )
{
return static_cast<sal_Int64>(
nonValueDoubleToValueDouble(
ConvertDoubleValue( nValue, nDigits, eInUnit, eOutUnit ) ) );
}
// -----------------------------------------------------------------------
sal_Int64 MetricField::ConvertValue( sal_Int64 nValue, sal_uInt16 nDigits,
FieldUnit eInUnit, MapUnit eOutUnit )
{
return static_cast<sal_Int64>(
// #150733# cast double to sal_Int64 can throw a
// EXCEPTION_FLT_INVALID_OPERATION on Windows
nonValueDoubleToValueDouble(
ConvertDoubleValue( nValue, nDigits, eInUnit, eOutUnit ) ) );
}
// -----------------------------------------------------------------------
double MetricField::ConvertDoubleValue( double nValue, sal_Int64 mnBaseValue, sal_uInt16 nDecDigits,
FieldUnit eInUnit, FieldUnit eOutUnit )
{
if ( eInUnit != eOutUnit )
{
sal_Int64 nMult = 1, nDiv = 1;
if ( eInUnit == FUNIT_PERCENT )
{
if ( (mnBaseValue <= 0) || (nValue <= 0) )
return nValue;
nDiv = 100;
for ( sal_uInt16 i=0; i < nDecDigits; i++ )
nDiv *= 10;
nMult = mnBaseValue;
}
else if ( eOutUnit == FUNIT_PERCENT ||
eOutUnit == FUNIT_CUSTOM ||
eOutUnit == FUNIT_NONE ||
eInUnit == FUNIT_CUSTOM ||
eInUnit == FUNIT_NONE )
return nValue;
else
{
if ( eOutUnit == FUNIT_100TH_MM )
eOutUnit = FUNIT_NONE;
if ( eInUnit == FUNIT_100TH_MM )
eInUnit = FUNIT_NONE;
nDiv = aImplFactor[eInUnit][eOutUnit];
nMult = aImplFactor[eOutUnit][eInUnit];
DBG_ASSERT( nMult > 0, "illegal *" );
DBG_ASSERT( nDiv > 0, "illegal /" );
}
if ( nMult != 1 && nMult > 0 )
nValue *= nMult;
if ( nDiv != 1 && nDiv > 0 )
{
nValue += ( nValue < 0 ) ? (-nDiv/2) : (nDiv/2);
nValue /= nDiv;
}
}
return nValue;
}
// -----------------------------------------------------------------------
double MetricField::ConvertDoubleValue( double nValue, sal_uInt16 nDigits,
MapUnit eInUnit, FieldUnit eOutUnit )
{
if ( eOutUnit == FUNIT_PERCENT ||
eOutUnit == FUNIT_CUSTOM ||
eOutUnit == FUNIT_NONE ||
eInUnit == MAP_PIXEL ||
eInUnit == MAP_SYSFONT ||
eInUnit == MAP_APPFONT ||
eInUnit == MAP_RELATIVE )
{
DBG_ERROR( "invalid parameters" );
return nValue;
}
long nDecDigits = nDigits;
FieldUnit eFieldUnit = ImplMap2FieldUnit( eInUnit, nDecDigits );
if ( nDecDigits < 0 )
{
while ( nDecDigits )
{
nValue += 5;
nValue /= 10;
nDecDigits++;
}
}
else
{
while ( nDecDigits )
{
nValue *= 10;
nDecDigits--;
}
}
if ( eFieldUnit != eOutUnit )
{
sal_Int64 nDiv = aImplFactor[eFieldUnit][eOutUnit];
sal_Int64 nMult = aImplFactor[eOutUnit][eFieldUnit];
DBG_ASSERT( nMult > 0, "illegal *" );
DBG_ASSERT( nDiv > 0, "illegal /" );
if ( nMult != 1 && nMult > 0)
nValue *= nMult;
if ( nDiv != 1 && nDiv > 0 )
{
nValue += (nValue < 0) ? (-nDiv/2) : (nDiv/2);
nValue /= nDiv;
}
}
return nValue;
}
// -----------------------------------------------------------------------
double MetricField::ConvertDoubleValue( double nValue, sal_uInt16 nDigits,
FieldUnit eInUnit, MapUnit eOutUnit )
{
if ( eInUnit == FUNIT_PERCENT ||
eInUnit == FUNIT_CUSTOM ||
eInUnit == FUNIT_NONE ||
eOutUnit == MAP_PIXEL ||
eOutUnit == MAP_SYSFONT ||
eOutUnit == MAP_APPFONT ||
eOutUnit == MAP_RELATIVE )
{
DBG_ERROR( "invalid parameters" );
return nValue;
}
long nDecDigits = nDigits;
FieldUnit eFieldUnit = ImplMap2FieldUnit( eOutUnit, nDecDigits );
if ( nDecDigits < 0 )
{
while ( nDecDigits )
{
nValue *= 10;
nDecDigits++;
}
}
else
{
while ( nDecDigits )
{
nValue += 5;
nValue /= 10;
nDecDigits--;
}
}
if ( eFieldUnit != eInUnit )
{
sal_Int64 nDiv = aImplFactor[eInUnit][eFieldUnit];
sal_Int64 nMult = aImplFactor[eFieldUnit][eInUnit];
DBG_ASSERT( nMult > 0, "illegal *" );
DBG_ASSERT( nDiv > 0, "illegal /" );
if( nMult != 1 && nMult > 0 )
nValue *= nMult;
if( nDiv != 1 && nDiv > 0 )
{
nValue += (nValue < 0) ? (-nDiv/2) : (nDiv/2);
nValue /= nDiv;
}
}
return nValue;
}
// -----------------------------------------------------------------------
static sal_Bool ImplMetricGetValue( const XubString& rStr, double& rValue, sal_Int64 nBaseValue,
sal_uInt16 nDecDigits, const LocaleDataWrapper& rLocaleDataWrapper, FieldUnit eUnit )
{
// Zahlenwert holen
if ( !ImplNumericGetValue( rStr, rValue, nDecDigits, rLocaleDataWrapper ) )
return sal_False;
// Einheit rausfinden
FieldUnit eEntryUnit = ImplMetricGetUnit( rStr );
// Einheiten umrechnen
rValue = MetricField::ConvertDoubleValue( rValue, nBaseValue, nDecDigits, eEntryUnit, eUnit );
return sal_True;
}
// -----------------------------------------------------------------------
sal_Bool MetricFormatter::ImplMetricReformat( const XubString& rStr, double& rValue, XubString& rOutStr )
{
if ( !ImplMetricGetValue( rStr, rValue, mnBaseValue, GetDecimalDigits(), ImplGetLocaleDataWrapper(), meUnit ) )
return sal_True;
else
{
double nTempVal = rValue;
// caution: precision loss in double cast
if ( nTempVal > GetMax() )
nTempVal = (double)GetMax();
else if ( nTempVal < GetMin())
nTempVal = (double)GetMin();
if ( GetErrorHdl().IsSet() && (rValue != nTempVal) )
{
mnCorrectedValue = (sal_Int64)nTempVal;
if ( !GetErrorHdl().Call( this ) )
{
mnCorrectedValue = 0;
return sal_False;
}
else
mnCorrectedValue = 0;
}
rOutStr = CreateFieldText( (sal_Int64)nTempVal );
return sal_True;
}
}
// -----------------------------------------------------------------------
inline void MetricFormatter::ImplInit()
{
mnBaseValue = 0;
meUnit = MetricField::GetDefaultUnit();
mnType = FORMAT_METRIC;
}
// -----------------------------------------------------------------------
MetricFormatter::MetricFormatter()
{
ImplInit();
}
// -----------------------------------------------------------------------
void MetricFormatter::ImplLoadRes( const ResId& rResId )
{
NumericFormatter::ImplLoadRes( rResId );
ResMgr* pMgr = rResId.GetResMgr();
if( pMgr )
{
sal_uLong nMask = pMgr->ReadLong();
if ( METRICFORMATTER_UNIT & nMask )
meUnit = (FieldUnit)pMgr->ReadLong();
if ( METRICFORMATTER_CUSTOMUNITTEXT & nMask )
maCustomUnitText = pMgr->ReadString();
}
}
// -----------------------------------------------------------------------
MetricFormatter::~MetricFormatter()
{
}
// -----------------------------------------------------------------------
void MetricFormatter::SetUnit( FieldUnit eNewUnit )
{
if ( eNewUnit == FUNIT_100TH_MM )
{
SetDecimalDigits( GetDecimalDigits() + 2 );
meUnit = FUNIT_MM;
}
else
meUnit = eNewUnit;
ReformatAll();
}
// -----------------------------------------------------------------------
void MetricFormatter::SetCustomUnitText( const XubString& rStr )
{
maCustomUnitText = rStr;
ReformatAll();
}
// -----------------------------------------------------------------------
void MetricFormatter::SetValue( sal_Int64 nNewValue, FieldUnit eInUnit )
{
SetUserValue( nNewValue, eInUnit );
mnFieldValue = mnLastValue;
}
// -----------------------------------------------------------------------
XubString MetricFormatter::CreateFieldText( sal_Int64 nValue ) const
{
XubString aStr = NumericFormatter::CreateFieldText( nValue );
if( meUnit == FUNIT_CUSTOM )
aStr += maCustomUnitText;
else
{
if ( meUnit != FUNIT_NONE && meUnit != FUNIT_PERCENT )
aStr += xub_Unicode( ' ' );
aStr += ImplMetricToString( meUnit );
}
return aStr;
}
// -----------------------------------------------------------------------
void MetricFormatter::SetUserValue( sal_Int64 nNewValue, FieldUnit eInUnit )
{
// Umrechnen auf eingestellte Einheiten
nNewValue = MetricField::ConvertValue( nNewValue, mnBaseValue, GetDecimalDigits(), eInUnit, meUnit );
NumericFormatter::SetUserValue( nNewValue );
}
// -----------------------------------------------------------------------
sal_Int64 MetricFormatter::GetValue( FieldUnit eOutUnit ) const
{
if ( !GetField() )
return 0;
double nTempValue;
// caution: precision loss in double cast
if ( !ImplMetricGetValue( GetField()->GetText(), nTempValue, mnBaseValue, GetDecimalDigits(), ImplGetLocaleDataWrapper(), meUnit ) )
nTempValue = (double)mnLastValue;
// caution: precision loss in double cast
if ( nTempValue > mnMax )
nTempValue = (double)mnMax;
else if ( nTempValue < mnMin )
nTempValue = (double)mnMin;
// Umrechnen auf gewuenschte Einheiten
return MetricField::ConvertValue( (sal_Int64)nTempValue, mnBaseValue, GetDecimalDigits(), meUnit, eOutUnit );
}
// -----------------------------------------------------------------------
void MetricFormatter::SetValue( sal_Int64 nValue )
{
// Implementation not inline, because it is a virtual Function
SetValue( nValue, FUNIT_NONE );
}
// -----------------------------------------------------------------------
sal_Int64 MetricFormatter::GetValue() const
{
// Implementation not inline, because it is a virtual Function
return GetValue( FUNIT_NONE );
}
// -----------------------------------------------------------------------
void MetricFormatter::SetMin( sal_Int64 nNewMin, FieldUnit eInUnit )
{
// Umrechnen auf gewuenschte Einheiten
NumericFormatter::SetMin( MetricField::ConvertValue( nNewMin, mnBaseValue, GetDecimalDigits(),
eInUnit, meUnit ) );
}
// -----------------------------------------------------------------------
sal_Int64 MetricFormatter::GetMin( FieldUnit eOutUnit ) const
{
// Umrechnen auf gewuenschte Einheiten
return MetricField::ConvertValue( NumericFormatter::GetMin(), mnBaseValue,
GetDecimalDigits(), meUnit, eOutUnit );
}
// -----------------------------------------------------------------------
void MetricFormatter::SetMax( sal_Int64 nNewMax, FieldUnit eInUnit )
{
// Umrechnen auf gewuenschte Einheiten
NumericFormatter::SetMax( MetricField::ConvertValue( nNewMax, mnBaseValue, GetDecimalDigits(),
eInUnit, meUnit ) );
}
// -----------------------------------------------------------------------
sal_Int64 MetricFormatter::GetMax( FieldUnit eOutUnit ) const
{
// Umrechnen auf gewuenschte Einheiten
return MetricField::ConvertValue( NumericFormatter::GetMax(), mnBaseValue,
GetDecimalDigits(), meUnit, eOutUnit );
}
// -----------------------------------------------------------------------
void MetricFormatter::SetBaseValue( sal_Int64 nNewBase, FieldUnit eInUnit )
{
mnBaseValue = MetricField::ConvertValue( nNewBase, mnBaseValue, GetDecimalDigits(),
eInUnit, meUnit );
}
// -----------------------------------------------------------------------
sal_Int64 MetricFormatter::GetBaseValue( FieldUnit eOutUnit ) const
{
// Umrechnen auf gewuenschte Einheiten
return MetricField::ConvertValue( mnBaseValue, mnBaseValue, GetDecimalDigits(),
meUnit, eOutUnit );
}
// -----------------------------------------------------------------------
void MetricFormatter::Reformat()
{
if ( !GetField() )
return;
XubString aText = GetField()->GetText();
if ( meUnit == FUNIT_CUSTOM )
maCurUnitText = ImplMetricGetUnitText( aText );
XubString aStr;
// caution: precision loss in double cast
double nTemp = (double)mnLastValue;
sal_Bool bOK = ImplMetricReformat( aText, nTemp, aStr );
mnLastValue = (sal_Int64)nTemp;
if ( !bOK )
return;
if ( aStr.Len() )
{
ImplSetText( aStr );
if ( meUnit == FUNIT_CUSTOM )
CustomConvert();
}
else
SetValue( mnLastValue );
maCurUnitText.Erase();
}
// -----------------------------------------------------------------------
sal_Int64 MetricFormatter::GetCorrectedValue( FieldUnit eOutUnit ) const
{
// Umrechnen auf gewuenschte Einheiten
return MetricField::ConvertValue( mnCorrectedValue, mnBaseValue, GetDecimalDigits(),
meUnit, eOutUnit );
}
// -----------------------------------------------------------------------
MetricField::MetricField( Window* pParent, WinBits nWinStyle ) :
SpinField( pParent, nWinStyle )
{
SetField( this );
Reformat();
}
// -----------------------------------------------------------------------
MetricField::MetricField( Window* pParent, const ResId& rResId ) :
SpinField( WINDOW_METRICFIELD )
{
rResId.SetRT( RSC_METRICFIELD );
WinBits nStyle = ImplInitRes( rResId ) ;
SpinField::ImplInit( pParent, nStyle );
SetField( this );
ImplLoadRes( rResId );
if ( !(nStyle & WB_HIDE ) )
Show();
}
// -----------------------------------------------------------------------
void MetricField::ImplLoadRes( const ResId& rResId )
{
SpinField::ImplLoadRes( rResId );
MetricFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
sal_uLong nMask = ReadLongRes();
if ( METRICFIELD_FIRST & nMask )
mnFirst = ReadLongRes();
if ( METRICFIELD_LAST & nMask )
mnLast = ReadLongRes();
if ( METRICFIELD_SPINSIZE & nMask )
mnSpinSize = ReadLongRes();
Reformat();
}
// -----------------------------------------------------------------------
MetricField::~MetricField()
{
}
// -----------------------------------------------------------------------
void MetricField::SetFirst( sal_Int64 nNewFirst, FieldUnit eInUnit )
{
// convert
nNewFirst = MetricField::ConvertValue( nNewFirst, mnBaseValue, GetDecimalDigits(),
eInUnit, meUnit );
mnFirst = nNewFirst;
}
// -----------------------------------------------------------------------
sal_Int64 MetricField::GetFirst( FieldUnit eOutUnit ) const
{
// convert
return MetricField::ConvertValue( mnFirst, mnBaseValue, GetDecimalDigits(),
meUnit, eOutUnit );
}
// -----------------------------------------------------------------------
void MetricField::SetLast( sal_Int64 nNewLast, FieldUnit eInUnit )
{
// Umrechnen
nNewLast = MetricField::ConvertValue( nNewLast, mnBaseValue, GetDecimalDigits(),
eInUnit, meUnit );
mnLast = nNewLast;
}
// -----------------------------------------------------------------------
sal_Int64 MetricField::GetLast( FieldUnit eOutUnit ) const
{
// Umrechnen
return MetricField::ConvertValue( mnLast, mnBaseValue, GetDecimalDigits(),
meUnit, eOutUnit );
}
// -----------------------------------------------------------------------
long MetricField::PreNotify( NotifyEvent& rNEvt )
{
if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
{
if ( ImplMetricProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), ImplGetLocaleDataWrapper() ) )
return 1;
}
return SpinField::PreNotify( rNEvt );
}
// -----------------------------------------------------------------------
long MetricField::Notify( NotifyEvent& rNEvt )
{
if ( rNEvt.GetType() == EVENT_GETFOCUS )
MarkToBeReformatted( sal_False );
else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
{
if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
Reformat();
}
return SpinField::Notify( rNEvt );
}
// -----------------------------------------------------------------------
void MetricField::DataChanged( const DataChangedEvent& rDCEvt )
{
SpinField::DataChanged( rDCEvt );
if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_LOCALE) )
{
String sOldDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
String sOldThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
if ( IsDefaultLocale() )
ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
String sNewDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
String sNewThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
ImplUpdateSeparators( sOldDecSep, sNewDecSep, sOldThSep, sNewThSep, this );
ReformatAll();
}
}
// -----------------------------------------------------------------------
void MetricField::Modify()
{
MarkToBeReformatted( sal_True );
SpinField::Modify();
}
// -----------------------------------------------------------------------
void MetricField::Up()
{
FieldUp();
SpinField::Up();
}
// -----------------------------------------------------------------------
void MetricField::Down()
{
FieldDown();
SpinField::Down();
}
// -----------------------------------------------------------------------
void MetricField::First()
{
FieldFirst();
SpinField::First();
}
// -----------------------------------------------------------------------
void MetricField::Last()
{
FieldLast();
SpinField::Last();
}
// -----------------------------------------------------------------------
void MetricField::CustomConvert()
{
maCustomConvertLink.Call( this );
}
// -----------------------------------------------------------------------
MetricBox::MetricBox( Window* pParent, WinBits nWinStyle ) :
ComboBox( pParent, nWinStyle )
{
SetField( this );
Reformat();
}
// -----------------------------------------------------------------------
MetricBox::MetricBox( Window* pParent, const ResId& rResId ) :
ComboBox( WINDOW_METRICBOX )
{
rResId.SetRT( RSC_METRICBOX );
WinBits nStyle = ImplInitRes( rResId );
ComboBox::ImplInit( pParent, nStyle );
SetField( this );
Reformat();
ComboBox::ImplLoadRes( rResId );
MetricFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
if ( !(nStyle & WB_HIDE ) )
Show();
}
// -----------------------------------------------------------------------
MetricBox::~MetricBox()
{
}
// -----------------------------------------------------------------------
long MetricBox::PreNotify( NotifyEvent& rNEvt )
{
if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
{
if ( ImplMetricProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), ImplGetLocaleDataWrapper() ) )
return 1;
}
return ComboBox::PreNotify( rNEvt );
}
// -----------------------------------------------------------------------
long MetricBox::Notify( NotifyEvent& rNEvt )
{
if ( rNEvt.GetType() == EVENT_GETFOCUS )
MarkToBeReformatted( sal_False );
else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
{
if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
Reformat();
}
return ComboBox::Notify( rNEvt );
}
// -----------------------------------------------------------------------
void MetricBox::DataChanged( const DataChangedEvent& rDCEvt )
{
ComboBox::DataChanged( rDCEvt );
if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_LOCALE) )
{
String sOldDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
String sOldThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
if ( IsDefaultLocale() )
ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
String sNewDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
String sNewThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
ImplUpdateSeparators( sOldDecSep, sNewDecSep, sOldThSep, sNewThSep, this );
ReformatAll();
}
}
// -----------------------------------------------------------------------
void MetricBox::Modify()
{
MarkToBeReformatted( sal_True );
ComboBox::Modify();
}
// -----------------------------------------------------------------------
void MetricBox::ReformatAll()
{
double nValue;
XubString aStr;
SetUpdateMode( sal_False );
sal_uInt16 nEntryCount = GetEntryCount();
for ( sal_uInt16 i=0; i < nEntryCount; i++ )
{
ImplMetricReformat( GetEntry( i ), nValue, aStr );
RemoveEntry( i );
InsertEntry( aStr, i );
}
MetricFormatter::Reformat();
SetUpdateMode( sal_True );
}
// -----------------------------------------------------------------------
void MetricBox::CustomConvert()
{
maCustomConvertLink.Call( this );
}
// -----------------------------------------------------------------------
void MetricBox::InsertValue( sal_Int64 nValue, FieldUnit eInUnit, sal_uInt16 nPos )
{
// Umrechnen auf eingestellte Einheiten
nValue = MetricField::ConvertValue( nValue, mnBaseValue, GetDecimalDigits(),
eInUnit, meUnit );
ComboBox::InsertEntry( CreateFieldText( nValue ), nPos );
}
// -----------------------------------------------------------------------
void MetricBox::RemoveValue( sal_Int64 nValue, FieldUnit eInUnit )
{
// Umrechnen auf eingestellte Einheiten
nValue = MetricField::ConvertValue( nValue, mnBaseValue, GetDecimalDigits(),
eInUnit, meUnit );
ComboBox::RemoveEntry( CreateFieldText( nValue ) );
}
// -----------------------------------------------------------------------
sal_Int64 MetricBox::GetValue( sal_uInt16 nPos, FieldUnit eOutUnit ) const
{
double nValue = 0;
ImplMetricGetValue( ComboBox::GetEntry( nPos ), nValue, mnBaseValue,
GetDecimalDigits(), ImplGetLocaleDataWrapper(), meUnit );
// Umrechnen auf eingestellte Einheiten
sal_Int64 nRetValue = MetricField::ConvertValue( (sal_Int64)nValue, mnBaseValue, GetDecimalDigits(),
meUnit, eOutUnit );
return nRetValue;
}
// -----------------------------------------------------------------------
sal_uInt16 MetricBox::GetValuePos( sal_Int64 nValue, FieldUnit eInUnit ) const
{
// Umrechnen auf eingestellte Einheiten
nValue = MetricField::ConvertValue( nValue, mnBaseValue, GetDecimalDigits(),
eInUnit, meUnit );
return ComboBox::GetEntryPos( CreateFieldText( nValue ) );
}
// -----------------------------------------------------------------------
sal_Int64 MetricBox::GetValue( FieldUnit eOutUnit ) const
{
// Implementation not inline, because it is a virtual Function
return MetricFormatter::GetValue( eOutUnit );
}
// -----------------------------------------------------------------------
sal_Int64 MetricBox::GetValue() const
{
// Implementation not inline, because it is a virtual Function
return GetValue( FUNIT_NONE );
}
// -----------------------------------------------------------------------
static sal_Bool ImplCurrencyProcessKeyInput( Edit* pEdit, const KeyEvent& rKEvt,
sal_Bool, sal_Bool bUseThousandSep, const LocaleDataWrapper& rWrapper )
{
// Es gibt hier kein sinnvolles StrictFormat, also alle
// Zeichen erlauben
return ImplNumericProcessKeyInput( pEdit, rKEvt, sal_False, bUseThousandSep, rWrapper );
}
// -----------------------------------------------------------------------
inline sal_Bool ImplCurrencyGetValue( const XubString& rStr, double& rValue,
sal_uInt16 nDecDigits, const LocaleDataWrapper& rWrapper )
{
// Zahlenwert holen
return ImplNumericGetValue( rStr, rValue, nDecDigits, rWrapper, sal_True );
}
// -----------------------------------------------------------------------
sal_Bool CurrencyFormatter::ImplCurrencyReformat( const XubString& rStr,
XubString& rOutStr )
{
double nValue;
if ( !ImplNumericGetValue( rStr, nValue, GetDecimalDigits(), ImplGetLocaleDataWrapper(), sal_True ) )
return sal_True;
else
{
double nTempVal = nValue;
// caution: precision loss in double cast
if ( nTempVal > GetMax() )
nTempVal = (double)GetMax();
else if ( nTempVal < GetMin())
nTempVal = (double)GetMin();
if ( GetErrorHdl().IsSet() && (nValue != nTempVal) )
{
mnCorrectedValue = (sal_Int64)nTempVal;
if ( !GetErrorHdl().Call( this ) )
{
mnCorrectedValue = 0;
return sal_False;
}
else
mnCorrectedValue = 0;
}
rOutStr = CreateFieldText( (long)nTempVal );
return sal_True;
}
}
// -----------------------------------------------------------------------
inline void CurrencyFormatter::ImplInit()
{
mnType = FORMAT_CURRENCY;
}
// -----------------------------------------------------------------------
CurrencyFormatter::CurrencyFormatter()
{
ImplInit();
}
// -----------------------------------------------------------------------
CurrencyFormatter::~CurrencyFormatter()
{
}
// -----------------------------------------------------------------------
void CurrencyFormatter::SetCurrencySymbol( const String& rStr )
{
maCurrencySymbol= rStr;
ReformatAll();
}
// -----------------------------------------------------------------------
String CurrencyFormatter::GetCurrencySymbol() const
{
return maCurrencySymbol.Len() ? maCurrencySymbol : ImplGetLocaleDataWrapper().getCurrSymbol();
}
// -----------------------------------------------------------------------
void CurrencyFormatter::SetValue( sal_Int64 nNewValue )
{
SetUserValue( nNewValue );
mnFieldValue = mnLastValue;
SetEmptyFieldValueData( sal_False );
}
// -----------------------------------------------------------------------
XubString CurrencyFormatter::CreateFieldText( sal_Int64 nValue ) const
{
return ImplGetLocaleDataWrapper().getCurr( nValue, GetDecimalDigits(), GetCurrencySymbol(), IsUseThousandSep() );
}
// -----------------------------------------------------------------------
sal_Int64 CurrencyFormatter::GetValue() const
{
if ( !GetField() )
return 0;
double nTempValue;
if ( ImplCurrencyGetValue( GetField()->GetText(), nTempValue, GetDecimalDigits(), ImplGetLocaleDataWrapper() ) )
{
// caution: precision loss in double cast
if ( nTempValue > mnMax )
nTempValue = (double)mnMax;
else if ( nTempValue < mnMin )
nTempValue = (double)mnMin;
return (sal_Int64)nTempValue;
}
else
return mnLastValue;
}
// -----------------------------------------------------------------------
void CurrencyFormatter::Reformat()
{
if ( !GetField() )
return;
XubString aStr;
sal_Bool bOK = ImplCurrencyReformat( GetField()->GetText(), aStr );
if ( !bOK )
return;
if ( aStr.Len() )
{
ImplSetText( aStr );
// caution: precision loss in double cast
double nTemp = (double)mnLastValue;
ImplCurrencyGetValue( aStr, nTemp, GetDecimalDigits(), ImplGetLocaleDataWrapper() );
mnLastValue = (sal_Int64)nTemp;
}
else
SetValue( mnLastValue );
}
// -----------------------------------------------------------------------
CurrencyField::CurrencyField( Window* pParent, WinBits nWinStyle ) :
SpinField( pParent, nWinStyle )
{
SetField( this );
Reformat();
}
// -----------------------------------------------------------------------
CurrencyField::CurrencyField( Window* pParent, const ResId& rResId ) :
SpinField( WINDOW_CURRENCYFIELD )
{
rResId.SetRT( RSC_CURRENCYFIELD );
WinBits nStyle = ImplInitRes( rResId );
SpinField::ImplInit( pParent, nStyle);
SetField( this );
ImplLoadRes( rResId );
if ( !(nStyle & WB_HIDE ) )
Show();
}
// -----------------------------------------------------------------------
void CurrencyField::ImplLoadRes( const ResId& rResId )
{
SpinField::ImplLoadRes( rResId );
CurrencyFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
sal_uLong nMask = ReadLongRes();
if ( CURRENCYFIELD_FIRST & nMask )
mnFirst = ReadLongRes();
if ( CURRENCYFIELD_LAST & nMask )
mnLast = ReadLongRes();
if ( CURRENCYFIELD_SPINSIZE & nMask )
mnSpinSize = ReadLongRes();
Reformat();
}
// -----------------------------------------------------------------------
CurrencyField::~CurrencyField()
{
}
// -----------------------------------------------------------------------
long CurrencyField::PreNotify( NotifyEvent& rNEvt )
{
if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
{
if ( ImplCurrencyProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), ImplGetLocaleDataWrapper() ) )
return 1;
}
return SpinField::PreNotify( rNEvt );
}
// -----------------------------------------------------------------------
long CurrencyField::Notify( NotifyEvent& rNEvt )
{
if ( rNEvt.GetType() == EVENT_GETFOCUS )
MarkToBeReformatted( sal_False );
else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
{
if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
Reformat();
}
return SpinField::Notify( rNEvt );
}
// -----------------------------------------------------------------------
void CurrencyField::DataChanged( const DataChangedEvent& rDCEvt )
{
SpinField::DataChanged( rDCEvt );
if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_LOCALE) )
{
String sOldDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
String sOldThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
if ( IsDefaultLocale() )
ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
String sNewDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
String sNewThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
ImplUpdateSeparators( sOldDecSep, sNewDecSep, sOldThSep, sNewThSep, this );
ReformatAll();
}
}
// -----------------------------------------------------------------------
void CurrencyField::Modify()
{
MarkToBeReformatted( sal_True );
SpinField::Modify();
}
// -----------------------------------------------------------------------
void CurrencyField::Up()
{
FieldUp();
SpinField::Up();
}
// -----------------------------------------------------------------------
void CurrencyField::Down()
{
FieldDown();
SpinField::Down();
}
// -----------------------------------------------------------------------
void CurrencyField::First()
{
FieldFirst();
SpinField::First();
}
// -----------------------------------------------------------------------
void CurrencyField::Last()
{
FieldLast();
SpinField::Last();
}
// -----------------------------------------------------------------------
CurrencyBox::CurrencyBox( Window* pParent, WinBits nWinStyle ) :
ComboBox( pParent, nWinStyle )
{
SetField( this );
Reformat();
}
// -----------------------------------------------------------------------
CurrencyBox::CurrencyBox( Window* pParent, const ResId& rResId ) :
ComboBox( WINDOW_CURRENCYBOX )
{
rResId.SetRT( RSC_CURRENCYBOX );
WinBits nStyle = ImplInitRes( rResId );
ComboBox::ImplInit( pParent, nStyle );
CurrencyFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
SetField( this );
ComboBox::ImplLoadRes( rResId );
Reformat();
if ( !(nStyle & WB_HIDE ) )
Show();
}
// -----------------------------------------------------------------------
CurrencyBox::~CurrencyBox()
{
}
// -----------------------------------------------------------------------
long CurrencyBox::PreNotify( NotifyEvent& rNEvt )
{
if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
{
if ( ImplCurrencyProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), ImplGetLocaleDataWrapper() ) )
return 1;
}
return ComboBox::PreNotify( rNEvt );
}
// -----------------------------------------------------------------------
long CurrencyBox::Notify( NotifyEvent& rNEvt )
{
if ( rNEvt.GetType() == EVENT_GETFOCUS )
MarkToBeReformatted( sal_False );
else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
{
if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
Reformat();
}
return ComboBox::Notify( rNEvt );
}
// -----------------------------------------------------------------------
void CurrencyBox::DataChanged( const DataChangedEvent& rDCEvt )
{
ComboBox::DataChanged( rDCEvt );
if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_LOCALE) )
{
String sOldDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
String sOldThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
if ( IsDefaultLocale() )
ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
String sNewDecSep = ImplGetLocaleDataWrapper().getNumDecimalSep();
String sNewThSep = ImplGetLocaleDataWrapper().getNumThousandSep();
ImplUpdateSeparators( sOldDecSep, sNewDecSep, sOldThSep, sNewThSep, this );
ReformatAll();
}
}
// -----------------------------------------------------------------------
void CurrencyBox::Modify()
{
MarkToBeReformatted( sal_True );
ComboBox::Modify();
}
// -----------------------------------------------------------------------
void CurrencyBox::ReformatAll()
{
XubString aStr;
SetUpdateMode( sal_False );
sal_uInt16 nEntryCount = GetEntryCount();
for ( sal_uInt16 i=0; i < nEntryCount; i++ )
{
ImplCurrencyReformat( GetEntry( i ), aStr );
RemoveEntry( i );
InsertEntry( aStr, i );
}
CurrencyFormatter::Reformat();
SetUpdateMode( sal_True );
}
// -----------------------------------------------------------------------
void CurrencyBox::InsertValue( sal_Int64 nValue, sal_uInt16 nPos )
{
ComboBox::InsertEntry( CreateFieldText( nValue ), nPos );
}
// -----------------------------------------------------------------------
void CurrencyBox::RemoveValue( sal_Int64 nValue )
{
ComboBox::RemoveEntry( CreateFieldText( nValue ) );
}
// -----------------------------------------------------------------------
sal_Int64 CurrencyBox::GetValue( sal_uInt16 nPos ) const
{
double nValue = 0;
ImplCurrencyGetValue( ComboBox::GetEntry( nPos ), nValue, GetDecimalDigits(), ImplGetLocaleDataWrapper() );
return (sal_Int64)nValue;
}
// -----------------------------------------------------------------------
sal_uInt16 CurrencyBox::GetValuePos( sal_Int64 nValue ) const
{
return ComboBox::GetEntryPos( CreateFieldText( nValue ) );
}
// -----------------------------------------------------------------------
sal_Int64 CurrencyBox::GetValue() const
{
// Implementation not inline, because it is a virtual Function
return CurrencyFormatter::GetValue();
}