AOO410/main/vcl/source/control/longcurr.cxx - openoffice - Git at Google

 /**************************************************************
  *
  * 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 );
 }

 // =======================================================================
	/**************************************************************
	*
	* 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 );
	}

	// =======================================================================