/************************************************************** * * 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 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(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( nDouble ); return ( nLong ); } // ----------------------------------------------------------------------- sal_Int64 MetricField::ConvertValue( sal_Int64 nValue, sal_uInt16 nDigits, MapUnit eInUnit, FieldUnit eOutUnit ) { return static_cast( nonValueDoubleToValueDouble( ConvertDoubleValue( nValue, nDigits, eInUnit, eOutUnit ) ) ); } // ----------------------------------------------------------------------- sal_Int64 MetricField::ConvertValue( sal_Int64 nValue, sal_uInt16 nDigits, FieldUnit eInUnit, MapUnit eOutUnit ) { return static_cast( // #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 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(); }