/**************************************************************
*
* 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"
#include <sot/object.hxx>
#define _TOOLS_BIGINT
#include <sot/factory.hxx>
#include <tools/debug.hxx>
#include <tools/bigint.hxx>
#include <tools/rc.h>
#include <vcl/event.hxx>
#include <vcl/svapp.hxx>
#include <vcl/longcurr.hxx>
#include <svdata.hxx>
#include <unotools/localedatawrapper.hxx>
// =======================================================================
#define FORMAT_LONGCURRENCY 4
// =======================================================================
static BigInt ImplPower10( sal_uInt16 n )
{
sal_uInt16 i;
BigInt nValue = 1;
for ( i=0; i < n; i++ )
nValue *= 10;
return nValue;
}
// -----------------------------------------------------------------------
static XubString ImplGetCurr( const LocaleDataWrapper& rLocaleDataWrapper, const BigInt &rNumber, sal_uInt16 nDigits, const String& rCurrSymbol, sal_Bool bShowThousandSep )
{
DBG_ASSERT( nDigits < 10, "LongCurrency duerfen nur maximal 9 Nachkommastellen haben" );
if ( rNumber.IsZero() || (long)rNumber )
return rLocaleDataWrapper.getCurr( (long)rNumber, nDigits, rCurrSymbol, bShowThousandSep );
BigInt aTmp( ImplPower10( nDigits ) );
BigInt aInteger( rNumber );
aInteger.Abs();
aInteger /= aTmp;
BigInt aFraction( rNumber );
aFraction.Abs();
aFraction %= aTmp;
if ( !aInteger.IsZero() )
{
aFraction += aTmp;
aTmp = 1000000000L;
}
if ( rNumber.IsNeg() )
aFraction *= -1;
XubString aTemplate = rLocaleDataWrapper.getCurr( (long)aFraction, nDigits, rCurrSymbol, bShowThousandSep );
while( !aInteger.IsZero() )
{
aFraction = aInteger;
aFraction %= aTmp;
aInteger /= aTmp;
if( !aInteger.IsZero() )
aFraction += aTmp;
XubString aFractionStr = rLocaleDataWrapper.getNum( (long)aFraction, 0 );
xub_StrLen nSPos = aTemplate.Search( '1' );
if ( aFractionStr.Len() == 1 )
aTemplate.SetChar( nSPos, aFractionStr.GetChar( 0 ) );
else
{
aTemplate.Erase( nSPos, 1 );
aTemplate.Insert( aFractionStr, nSPos );
}
}
return aTemplate;
}
// -----------------------------------------------------------------------
static sal_Bool ImplNumericProcessKeyInput( Edit*, const KeyEvent& rKEvt,
sal_Bool bStrictFormat, sal_Bool bThousandSep,
const LocaleDataWrapper& rLocaleDataWrapper )
{
if ( !bStrictFormat )
return sal_False;
else
{
sal_Unicode cChar = rKEvt.GetCharCode();
sal_uInt16 nGroup = rKEvt.GetKeyCode().GetGroup();
if ( (nGroup == KEYGROUP_FKEYS) || (nGroup == KEYGROUP_CURSOR) ||
(nGroup == KEYGROUP_MISC) ||
((cChar >= '0') && (cChar <= '9')) ||
(bThousandSep && (cChar == rLocaleDataWrapper.getNumThousandSep())) ||
(cChar == rLocaleDataWrapper.getNumDecimalSep() ) ||
(cChar == '-') )
return sal_False;
else
return sal_True;
}
}
// -----------------------------------------------------------------------
static sal_Bool ImplNumericGetValue( const XubString& rStr, BigInt& rValue,
sal_uInt16 nDecDigits, const LocaleDataWrapper& rLocaleDataWrapper,
sal_Bool bCurrency = sal_False )
{
XubString aStr = rStr;
XubString aStr1;
XubString aStr2;
sal_uInt16 nDecPos;
sal_Bool bNegative = sal_False;
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( rLocaleDataWrapper.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 = rLocaleDataWrapper.getCurrNegativeFormat();
if ( (nFormat == 3) || (nFormat == 6) ||
(nFormat == 7) || (nFormat == 10) )
{
for ( i = (sal_uInt16)(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
BigInt nValue( aStr );
if ( bRound )
{
if ( !bNegative )
nValue+=1;
else
nValue-=1;
}
rValue = nValue;
return sal_True;
}
// =======================================================================
static sal_Bool ImplLongCurrencyProcessKeyInput( Edit* pEdit, const KeyEvent& rKEvt,
sal_Bool, sal_Bool bUseThousandSep, const LocaleDataWrapper& rLocaleDataWrapper )
{
// Es gibt hier kein sinnvolles StrictFormat, also alle
// Zeichen erlauben
return ImplNumericProcessKeyInput( pEdit, rKEvt, sal_False, bUseThousandSep, rLocaleDataWrapper );
}
// -----------------------------------------------------------------------
inline sal_Bool ImplLongCurrencyGetValue( const XubString& rStr, BigInt& rValue,
sal_uInt16 nDecDigits, const LocaleDataWrapper& rLocaleDataWrapper )
{
// Zahlenwert holen
return ImplNumericGetValue( rStr, rValue, nDecDigits, rLocaleDataWrapper, sal_True );
}
// -----------------------------------------------------------------------
sal_Bool ImplLongCurrencyReformat( const XubString& rStr, BigInt nMin, BigInt nMax,
sal_uInt16 nDecDigits,
const LocaleDataWrapper& rLocaleDataWrapper, String& rOutStr,
LongCurrencyFormatter& rFormatter )
{
BigInt nValue;
if ( !ImplNumericGetValue( rStr, nValue, nDecDigits, rLocaleDataWrapper, sal_True ) )
return sal_True;
else
{
BigInt nTempVal = nValue;
if ( nTempVal > nMax )
nTempVal = nMax;
else if ( nTempVal < nMin )
nTempVal = nMin;
if ( rFormatter.GetErrorHdl().IsSet() && (nValue != nTempVal) )
{
rFormatter.mnCorrectedValue = nTempVal;
if ( !rFormatter.GetErrorHdl().Call( &rFormatter ) )
{
rFormatter.mnCorrectedValue = 0;
return sal_False;
}
else
{
rFormatter.mnCorrectedValue = 0;
}
}
rOutStr = ImplGetCurr( rLocaleDataWrapper, nTempVal, nDecDigits, rFormatter.GetCurrencySymbol(), rFormatter.IsUseThousandSep() );
return sal_True;
}
}
// =======================================================================
void LongCurrencyFormatter::ImpInit()
{
mnFieldValue = 0;
mnLastValue = 0;
mnMin = 0;
mnMax = 0x7FFFFFFF;
mnMax *= 0x7FFFFFFF;
mnCorrectedValue = 0;
mnDecimalDigits = 0;
mnType = FORMAT_LONGCURRENCY;
mbThousandSep = sal_True;
SetDecimalDigits( 0 );
}
// -----------------------------------------------------------------------
LongCurrencyFormatter::LongCurrencyFormatter()
{
ImpInit();
}
// -----------------------------------------------------------------------
void LongCurrencyFormatter::ImplLoadRes( const ResId& rResId )
{
ImpInit();
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;
}
}
}
// -----------------------------------------------------------------------
LongCurrencyFormatter::~LongCurrencyFormatter()
{
}
// -----------------------------------------------------------------------
void LongCurrencyFormatter::SetCurrencySymbol( const String& rStr )
{
maCurrencySymbol= rStr;
ReformatAll();
}
// -----------------------------------------------------------------------
String LongCurrencyFormatter::GetCurrencySymbol() const
{
return maCurrencySymbol.Len() ? maCurrencySymbol : GetLocaleDataWrapper().getCurrSymbol();
}
// -----------------------------------------------------------------------
void LongCurrencyFormatter::SetValue( BigInt nNewValue )
{
SetUserValue( nNewValue );
mnFieldValue = mnLastValue;
SetEmptyFieldValueData( sal_False );
}
// -----------------------------------------------------------------------
void LongCurrencyFormatter::SetUserValue( BigInt nNewValue )
{
if ( nNewValue > mnMax )
nNewValue = mnMax;
else if ( nNewValue < mnMin )
nNewValue = mnMin;
mnLastValue = nNewValue;
if ( !GetField() )
return;
XubString aStr = ImplGetCurr( GetLocaleDataWrapper(), nNewValue, GetDecimalDigits(), GetCurrencySymbol(), IsUseThousandSep() );
if ( GetField()->HasFocus() )
{
Selection aSelection = GetField()->GetSelection();
GetField()->SetText( aStr );
GetField()->SetSelection( aSelection );
}
else
GetField()->SetText( aStr );
MarkToBeReformatted( sal_False );
}
// -----------------------------------------------------------------------
BigInt LongCurrencyFormatter::GetValue() const
{
if ( !GetField() )
return 0;
BigInt nTempValue;
if ( ImplLongCurrencyGetValue( GetField()->GetText(), nTempValue, GetDecimalDigits(), GetLocaleDataWrapper() ) )
{
if ( nTempValue > mnMax )
nTempValue = mnMax;
else if ( nTempValue < mnMin )
nTempValue = mnMin;
return nTempValue;
}
else
return mnLastValue;
}
// -----------------------------------------------------------------------
void LongCurrencyFormatter::Reformat()
{
if ( !GetField() )
return;
if ( !GetField()->GetText().Len() && ImplGetEmptyFieldValue() )
return;
XubString aStr;
sal_Bool bOK = ImplLongCurrencyReformat( GetField()->GetText(), mnMin, mnMax,
GetDecimalDigits(), GetLocaleDataWrapper(), aStr, *this );
if ( !bOK )
return;
if ( aStr.Len() )
{
GetField()->SetText( aStr );
MarkToBeReformatted( sal_False );
ImplLongCurrencyGetValue( aStr, mnLastValue, GetDecimalDigits(), GetLocaleDataWrapper() );
}
else
SetValue( mnLastValue );
}
// -----------------------------------------------------------------------
void LongCurrencyFormatter::ReformatAll()
{
Reformat();
}
// -----------------------------------------------------------------------
void LongCurrencyFormatter::SetMin( BigInt nNewMin )
{
mnMin = nNewMin;
ReformatAll();
}
// -----------------------------------------------------------------------
void LongCurrencyFormatter::SetMax( BigInt nNewMax )
{
mnMax = nNewMax;
ReformatAll();
}
// -----------------------------------------------------------------------
void LongCurrencyFormatter::SetUseThousandSep( sal_Bool b )
{
mbThousandSep = b;
ReformatAll();
}
// -----------------------------------------------------------------------
void LongCurrencyFormatter::SetDecimalDigits( sal_uInt16 nDigits )
{
// DBG_ASSERT( nDigits < 10, "LongCurrency duerfen nur maximal 9 Nachkommastellen haben" );
if ( nDigits > 9 )
nDigits = 9;
mnDecimalDigits = nDigits;
ReformatAll();
}
// -----------------------------------------------------------------------
sal_uInt16 LongCurrencyFormatter::GetDecimalDigits() const
{
return mnDecimalDigits;
}
// -----------------------------------------------------------------------
sal_Bool LongCurrencyFormatter::IsValueModified() const
{
if ( ImplGetEmptyFieldValue() )
return !IsEmptyValue();
else if ( GetValue() != mnFieldValue )
return sal_True;
else
return sal_False;
}
// -----------------------------------------------------------------------
void LongCurrencyFormatter::SetEmptyValue()
{
GetField()->SetText( ImplGetSVEmptyStr() );
SetEmptyFieldValueData( sal_True );
}
// -----------------------------------------------------------------------
BigInt LongCurrencyFormatter::Normalize( BigInt nValue ) const
{
return (nValue * ImplPower10( GetDecimalDigits() ) );
}
// -----------------------------------------------------------------------
BigInt LongCurrencyFormatter::Denormalize( BigInt nValue ) const
{
BigInt nFactor = ImplPower10( GetDecimalDigits() );
BigInt nTmp = nFactor;
nTmp /= 2;
nTmp += nValue;
nTmp /= nFactor;
return nTmp;
}
// =======================================================================
void ImplNewLongCurrencyFieldValue( LongCurrencyField* pField, BigInt nNewValue )
{
Selection aSelect = pField->GetSelection();
aSelect.Justify();
XubString aText = pField->GetText();
sal_Bool bLastSelected = ((xub_StrLen)aSelect.Max() == aText.Len()) ? sal_True : sal_False;
BigInt nOldLastValue = pField->mnLastValue;
pField->SetUserValue( nNewValue );
pField->mnLastValue = nOldLastValue;
if ( bLastSelected )
{
if ( !aSelect.Len() )
aSelect.Min() = SELECTION_MAX;
aSelect.Max() = SELECTION_MAX;
}
pField->SetSelection( aSelect );
pField->SetModifyFlag();
pField->Modify();
}
// =======================================================================
LongCurrencyField::LongCurrencyField( Window* pParent, WinBits nWinStyle ) :
SpinField( pParent, nWinStyle )
{
SetField( this );
mnSpinSize = 1;
mnFirst = mnMin;
mnLast = mnMax;
Reformat();
}
// -----------------------------------------------------------------------
LongCurrencyField::LongCurrencyField( Window* pParent, const ResId& rResId ) :
SpinField( WINDOW_NUMERICFIELD )
{
rResId.SetRT( RSC_NUMERICFIELD );
WinBits nStyle = ImplInitRes( rResId ) ;
SpinField::ImplInit( pParent, nStyle );
SetField( this );
mnSpinSize = 1;
mnFirst = mnMin;
mnLast = mnMax;
Reformat();
if ( !(nStyle & WB_HIDE) )
Show();
}
// -----------------------------------------------------------------------
void LongCurrencyField::ImplLoadRes( const ResId& rResId )
{
SpinField::ImplLoadRes( rResId );
LongCurrencyFormatter::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();
}
// -----------------------------------------------------------------------
LongCurrencyField::~LongCurrencyField()
{
}
// -----------------------------------------------------------------------
long LongCurrencyField::PreNotify( NotifyEvent& rNEvt )
{
if( rNEvt.GetType() == EVENT_KEYINPUT )
{
if ( ImplLongCurrencyProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), GetLocaleDataWrapper() ) )
return 1;
}
return SpinField::PreNotify( rNEvt );
}
// -----------------------------------------------------------------------
long LongCurrencyField::Notify( NotifyEvent& rNEvt )
{
if( rNEvt.GetType() == EVENT_GETFOCUS )
{
MarkToBeReformatted( sal_False );
}
else if( rNEvt.GetType() == EVENT_LOSEFOCUS )
{
if ( MustBeReformatted() )
{
Reformat();
SpinField::Modify();
}
}
return SpinField::Notify( rNEvt );
}
// -----------------------------------------------------------------------
void LongCurrencyField::Modify()
{
MarkToBeReformatted( sal_True );
SpinField::Modify();
}
// -----------------------------------------------------------------------
void LongCurrencyField::Up()
{
BigInt nValue = GetValue();
nValue += mnSpinSize;
if ( nValue > mnMax )
nValue = mnMax;
ImplNewLongCurrencyFieldValue( this, nValue );
SpinField::Up();
}
// -----------------------------------------------------------------------
void LongCurrencyField::Down()
{
BigInt nValue = GetValue();
nValue -= mnSpinSize;
if ( nValue < mnMin )
nValue = mnMin;
ImplNewLongCurrencyFieldValue( this, nValue );
SpinField::Down();
}
// -----------------------------------------------------------------------
void LongCurrencyField::First()
{
ImplNewLongCurrencyFieldValue( this, mnFirst );
SpinField::First();
}
// -----------------------------------------------------------------------
void LongCurrencyField::Last()
{
ImplNewLongCurrencyFieldValue( this, mnLast );
SpinField::Last();
}
// =======================================================================
LongCurrencyBox::LongCurrencyBox( Window* pParent, WinBits nWinStyle ) :
ComboBox( pParent, nWinStyle )
{
SetField( this );
Reformat();
}
// -----------------------------------------------------------------------
LongCurrencyBox::LongCurrencyBox( Window* pParent, const ResId& rResId ) :
ComboBox( WINDOW_NUMERICFIELD )
{
SetField( this );
WinBits nStyle = ImplInitRes( rResId ) ;
ComboBox::ImplLoadRes( rResId );
ImplInit( pParent, nStyle );
LongCurrencyFormatter::ImplLoadRes( rResId );
Reformat();
if ( !(nStyle & WB_HIDE) )
Show();
}
// -----------------------------------------------------------------------
LongCurrencyBox::~LongCurrencyBox()
{
}
// -----------------------------------------------------------------------
long LongCurrencyBox::PreNotify( NotifyEvent& rNEvt )
{
if( rNEvt.GetType() == EVENT_KEYINPUT )
{
if ( ImplLongCurrencyProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsUseThousandSep(), GetLocaleDataWrapper() ) )
return 1;
}
return ComboBox::PreNotify( rNEvt );
}
// -----------------------------------------------------------------------
long LongCurrencyBox::Notify( NotifyEvent& rNEvt )
{
if( rNEvt.GetType() == EVENT_GETFOCUS )
{
MarkToBeReformatted( sal_False );
}
else if( rNEvt.GetType() == EVENT_LOSEFOCUS )
{
if ( MustBeReformatted() )
{
Reformat();
ComboBox::Modify();
}
}
return ComboBox::Notify( rNEvt );
}
// -----------------------------------------------------------------------
void LongCurrencyBox::Modify()
{
MarkToBeReformatted( sal_True );
ComboBox::Modify();
}
// -----------------------------------------------------------------------
void LongCurrencyBox::ReformatAll()
{
XubString aStr;
SetUpdateMode( sal_False );
sal_uInt16 nEntryCount = GetEntryCount();
for ( sal_uInt16 i=0; i < nEntryCount; i++ )
{
ImplLongCurrencyReformat( GetEntry( i ), mnMin, mnMax,
GetDecimalDigits(), GetLocaleDataWrapper(),
aStr, *this );
RemoveEntry( i );
InsertEntry( aStr, i );
}
LongCurrencyFormatter::Reformat();
SetUpdateMode( sal_True );
}
// -----------------------------------------------------------------------
void LongCurrencyBox::InsertValue( BigInt nValue, sal_uInt16 nPos )
{
XubString aStr = ImplGetCurr( GetLocaleDataWrapper(), nValue, GetDecimalDigits(), GetCurrencySymbol(), IsUseThousandSep() );
ComboBox::InsertEntry( aStr, nPos );
}
// -----------------------------------------------------------------------
void LongCurrencyBox::RemoveValue( BigInt nValue )
{
XubString aStr = ImplGetCurr( GetLocaleDataWrapper(), nValue, GetDecimalDigits(), GetCurrencySymbol(), IsUseThousandSep() );
ComboBox::RemoveEntry( aStr );
}
// -----------------------------------------------------------------------
BigInt LongCurrencyBox::GetValue( sal_uInt16 nPos ) const
{
BigInt nValue = 0;
ImplLongCurrencyGetValue( ComboBox::GetEntry( nPos ), nValue,
GetDecimalDigits(), GetLocaleDataWrapper() );
return nValue;
}
// -----------------------------------------------------------------------
sal_uInt16 LongCurrencyBox::GetValuePos( BigInt nValue ) const
{
XubString aStr = ImplGetCurr( GetLocaleDataWrapper(), nValue, GetDecimalDigits(), GetCurrencySymbol(), IsUseThousandSep() );
return ComboBox::GetEntryPos( aStr );
}
// =======================================================================