| /************************************************************** |
| * |
| * 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_svx.hxx" |
| |
| // include --------------------------------------------------------------- |
| #include <tools/color.hxx> |
| |
| #define _SVX_NUMFMTSH_CXX |
| #define _SVSTDARR_STRINGSDTOR |
| #include <tools/debug.hxx> |
| #include <i18npool/mslangid.hxx> |
| |
| #define _ZFORLIST_DECLARE_TABLE |
| #include <svl/zforlist.hxx> |
| #include <svl/zformat.hxx> |
| |
| #include <svtools/langtab.hxx> |
| #include <vcl/svapp.hxx> |
| #include <comphelper/processfactory.hxx> |
| |
| #include <svx/numfmtsh.hxx> |
| // class SvxNumberFormatShell -------------------------------------------- |
| |
| const double SvxNumberFormatShell::DEFAULT_NUMVALUE = 1234.56789; |
| |
| SV_IMPL_PTRARR( NfShCurrencyEntries, NfCurrencyEntry* ); |
| |
| // ----------------------------------------------------------------------- |
| |
| |
| |
| SvxNumberFormatShell* SvxNumberFormatShell::Create( SvNumberFormatter* pNumFormatter, |
| sal_uInt32 nFormatKey, |
| SvxNumberValueType eNumValType, |
| const String& rNumStr ) |
| { |
| return new SvxNumberFormatShell(pNumFormatter,nFormatKey, |
| eNumValType,rNumStr ); |
| } |
| |
| SvxNumberFormatShell* SvxNumberFormatShell::Create( SvNumberFormatter* pNumFormatter, |
| sal_uInt32 nFormatKey, |
| SvxNumberValueType eNumValType, |
| double nNumVal, |
| const String* pNumStr ) |
| { |
| return new SvxNumberFormatShell(pNumFormatter,nFormatKey, |
| eNumValType,nNumVal,pNumStr ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| #define _INIT \ |
| pFormatter ( pNumFormatter ), \ |
| pCurFmtTable ( NULL ), \ |
| eValType ( eNumValType ), \ |
| bUndoAddList ( sal_True ), \ |
| nInitFormatKey ( nFormatKey ), \ |
| nCurFormatKey ( nFormatKey ), \ |
| pCurCurrencyEntry(NULL), \ |
| bBankingSymbol (sal_False), \ |
| nCurCurrencyEntryPos((sal_uInt16) SELPOS_NONE) |
| |
| // ----------------------------------------------------------------------- |
| |
| SvxNumberFormatShell::SvxNumberFormatShell( SvNumberFormatter* pNumFormatter, |
| sal_uInt32 nFormatKey, |
| SvxNumberValueType eNumValType, |
| const String& rNumStr ) |
| : _INIT |
| { |
| nValNum = DEFAULT_NUMVALUE; |
| |
| switch ( eValType ) |
| { |
| case SVX_VALUE_TYPE_STRING: |
| aValStr = rNumStr; |
| break; |
| case SVX_VALUE_TYPE_NUMBER: |
| case SVX_VALUE_TYPE_UNDEFINED: |
| default: |
| aValStr.Erase(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SvxNumberFormatShell::SvxNumberFormatShell( SvNumberFormatter* pNumFormatter, |
| sal_uInt32 nFormatKey, |
| SvxNumberValueType eNumValType, |
| double nNumVal, |
| const String* pNumStr ) |
| : _INIT |
| { |
| // #50441# When used in Writer, the SvxNumberInfoItem contains the |
| // original string in addition to the value |
| |
| if ( pNumStr ) |
| aValStr = *pNumStr; |
| |
| switch ( eValType ) |
| { |
| case SVX_VALUE_TYPE_NUMBER: |
| nValNum = nNumVal; |
| break; |
| case SVX_VALUE_TYPE_STRING: |
| case SVX_VALUE_TYPE_UNDEFINED: |
| default: |
| nValNum = DEFAULT_NUMVALUE; |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SvxNumberFormatShell::~SvxNumberFormatShell() |
| { |
| /* |
| * An dieser Stelle wird abhaengig davon, ob die |
| * hinzugefuegten, benutzerdefinierten als gueltig |
| * erklaert wurden (ValidateNewEntries()), die |
| * Add-Liste wieder aus dem Zahlenformatierer entfernt. |
| * |
| * Loeschen von Formaten aus dem Formatierer passiert |
| * aus Undo-Gruenden nur in der aufrufenden Instanz. |
| */ |
| |
| if ( bUndoAddList ) |
| { |
| // Hinzugefuegte Formate sind nicht gueltig: |
| // => wieder entfernen: |
| |
| for ( sal_uInt16 i = 0; i < aAddList.Count(); ++i ) |
| pFormatter->DeleteEntry( aAddList[i] ); |
| } |
| |
| //-------------------------------- |
| // Add-/Remove-Listen leerraeumen: |
| //-------------------------------- |
| aAddList.Remove( 0, aAddList.Count() ); |
| aDelList.Remove( 0, aAddList.Count() ); |
| |
| if(aCurrencyFormatList.Count()>0) |
| aCurrencyFormatList.DeleteAndDestroy(0,aCurrencyFormatList.Count()); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_uInt32 SvxNumberFormatShell::GetUpdateDataCount() const |
| { |
| return aDelList.Count(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SvxNumberFormatShell::GetUpdateData( sal_uInt32* pDelArray, const sal_uInt32 nSize ) |
| { |
| const sal_uInt32 nCount = aDelList.Count(); |
| |
| DBG_ASSERT( pDelArray && ( nSize == nCount ), "Array nicht initialisiert!" ); |
| |
| if ( pDelArray && ( nSize == nCount ) ) |
| for ( sal_uInt16 i = 0; i < aDelList.Count(); ++i ) |
| *pDelArray++ = aDelList[i]; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SvxNumberFormatShell::CategoryChanged( sal_uInt16 nCatLbPos, |
| short& rFmtSelPos, |
| SvStrings& rFmtEntries ) |
| { |
| short nOldCategory = nCurCategory; |
| PosToCategory_Impl( nCatLbPos, nCurCategory ); |
| pCurFmtTable = &( pFormatter->GetEntryTable( nCurCategory, |
| nCurFormatKey, |
| eCurLanguage ) ); |
| // reinitialize currency if category newly entered |
| if ( nCurCategory == NUMBERFORMAT_CURRENCY && nOldCategory != nCurCategory ) |
| pCurCurrencyEntry = NULL; |
| rFmtSelPos = FillEntryList_Impl( rFmtEntries ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SvxNumberFormatShell::LanguageChanged( LanguageType eLangType, |
| short& rFmtSelPos, |
| SvStrings& rFmtEntries ) |
| { |
| eCurLanguage = eLangType; |
| pCurFmtTable = &(pFormatter->ChangeCL( nCurCategory, |
| nCurFormatKey, |
| eCurLanguage ) ); |
| rFmtSelPos = FillEntryList_Impl( rFmtEntries ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SvxNumberFormatShell::FormatChanged( sal_uInt16 nFmtLbPos, |
| String& rPreviewStr, |
| Color*& rpFontColor ) |
| { |
| //nCurFormatKey = pCurFmtTable->GetKey( pCurFmtTable->GetObject( nFmtLbPos ) ); |
| |
| if(nFmtLbPos<aCurEntryList.Count()) |
| { |
| nCurFormatKey=aCurEntryList[nFmtLbPos]; |
| |
| if(nCurFormatKey!=NUMBERFORMAT_ENTRY_NOT_FOUND) |
| { |
| GetPreviewString_Impl( rPreviewStr, rpFontColor ); |
| } |
| else if(nCurCategory==NUMBERFORMAT_CURRENCY) |
| { |
| if(nFmtLbPos<aCurrencyFormatList.Count()) |
| { |
| //nCurFormatKey=nFmtLbPos; |
| MakePrevStringFromVal(*aCurrencyFormatList[nFmtLbPos], |
| rPreviewStr,rpFontColor,nValNum); |
| } |
| } |
| } |
| } |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SvxNumberFormatShell::AddFormat( String& rFormat, xub_StrLen& rErrPos, |
| sal_uInt16& rCatLbSelPos, short& rFmtSelPos, |
| SvStrings& rFmtEntries ) |
| { |
| sal_Bool bInserted = sal_False; |
| sal_uInt32 nAddKey = pFormatter->GetEntryKey( rFormat, eCurLanguage ); |
| |
| if ( nAddKey != NUMBERFORMAT_ENTRY_NOT_FOUND ) // bereits vorhanden? |
| { |
| if ( IsRemoved_Impl( nAddKey ) ) |
| { |
| // Key suchen und loeschen |
| sal_Bool bFound = sal_False; |
| sal_uInt16 nAt = 0; |
| |
| for ( sal_uInt16 i = 0; !bFound && i < aDelList.Count(); ++i ) |
| { |
| if ( aDelList[i] == nAddKey ) |
| { |
| bFound = sal_True; |
| nAt = i; |
| } |
| } |
| DBG_ASSERT( bFound, "Key not found" ); |
| aDelList.Remove( nAt ); |
| bInserted = sal_True; |
| } |
| else |
| { |
| DBG_ERROR( "Doppeltes Format!" ); |
| } |
| } |
| else // neues Format |
| { |
| bInserted = pFormatter->PutEntry( rFormat, rErrPos, |
| nCurCategory, nAddKey, |
| eCurLanguage ); |
| } |
| |
| if ( bInserted ) // eingefuegt |
| { |
| nCurFormatKey = nAddKey; |
| DBG_ASSERT( !IsAdded_Impl( nCurFormatKey ), "Doppeltes Format!" ); |
| aAddList.Insert( nCurFormatKey, aAddList.Count() ); |
| |
| // aktuelle Tabelle holen |
| pCurFmtTable = &(pFormatter->GetEntryTable( nCurCategory, |
| nCurFormatKey, |
| eCurLanguage )); |
| nCurCategory=pFormatter->GetType(nAddKey); //@@ ??? |
| CategoryToPos_Impl( nCurCategory, rCatLbSelPos ); |
| rFmtSelPos = FillEntryList_Impl( rFmtEntries ); |
| } |
| else if ( rErrPos != 0 ) // Syntaxfehler |
| { |
| ; |
| } |
| else // Doppelt einfuegen nicht moeglich |
| { |
| DBG_ERROR( "Doppeltes Format!" ); // oder doch? |
| } |
| |
| return bInserted; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SvxNumberFormatShell::RemoveFormat( const String& rFormat, |
| sal_uInt16& rCatLbSelPos, |
| short& rFmtSelPos, |
| SvStrings& rFmtEntries ) |
| { |
| sal_uInt32 nDelKey = pFormatter->GetEntryKey( rFormat, eCurLanguage ); |
| |
| DBG_ASSERT( nDelKey != NUMBERFORMAT_ENTRY_NOT_FOUND, "Eintrag nicht gefunden!" ); |
| DBG_ASSERT( !IsRemoved_Impl( nDelKey ), "Eintrag bereits geloescht!" ); |
| |
| if ( (nDelKey != NUMBERFORMAT_ENTRY_NOT_FOUND) && !IsRemoved_Impl( nDelKey ) ) |
| { |
| aDelList.Insert( nDelKey, aDelList.Count() ); |
| |
| if ( IsAdded_Impl( nDelKey ) ) |
| { |
| // Key suchen und loeschen |
| sal_Bool bFound = sal_False; |
| sal_uInt16 nAt = 0; |
| |
| for ( sal_uInt16 i = 0; !bFound && i < aAddList.Count(); ++i ) |
| { |
| if ( aAddList[i] == nDelKey ) |
| { |
| bFound = sal_True; |
| nAt = i; |
| } |
| } |
| DBG_ASSERT( bFound, "Key not found" ); |
| aAddList.Remove( nAt ); |
| } |
| |
| nCurCategory=pFormatter->GetType(nDelKey); //@@ 01.10.97 |
| pCurFmtTable = &(pFormatter->GetEntryTable( nCurCategory, |
| nCurFormatKey, |
| eCurLanguage )); |
| |
| nCurFormatKey=pFormatter->GetStandardFormat(nCurCategory, |
| eCurLanguage ); |
| |
| CategoryToPos_Impl( nCurCategory, rCatLbSelPos ); |
| rFmtSelPos = FillEntryList_Impl( rFmtEntries ); |
| //rFmtSelPos = (short) nCurFormatKey; //@@ 01.10.97 |
| } |
| return sal_True; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SvxNumberFormatShell::MakeFormat( String& rFormat, |
| sal_Bool bThousand, sal_Bool bNegRed, |
| sal_uInt16 nPrecision, sal_uInt16 nLeadingZeroes, |
| sal_uInt16 nCurrencyPos) |
| { |
| if(aCurrencyFormatList.Count()>nCurrencyPos) |
| { |
| xub_StrLen rErrPos=0; |
| sal_uInt16 rCatLbSelPos=0; |
| short rFmtSelPos=0; |
| SvStrings aFmtEList; |
| |
| sal_uInt32 nFound = pFormatter->TestNewString( *aCurrencyFormatList[nCurrencyPos], eCurLanguage ); |
| |
| if ( nFound == NUMBERFORMAT_ENTRY_NOT_FOUND ) |
| { |
| AddFormat( *aCurrencyFormatList[nCurrencyPos],rErrPos,rCatLbSelPos, |
| rFmtSelPos,aFmtEList); |
| } |
| |
| if(rErrPos==0) |
| { |
| pFormatter->GenerateFormat( rFormat, nCurFormatKey, |
| eCurLanguage, |
| bThousand, bNegRed, |
| nPrecision, nLeadingZeroes ); |
| } |
| aFmtEList.DeleteAndDestroy(0,aFmtEList.Count()); |
| } |
| else |
| { |
| pFormatter->GenerateFormat( rFormat, nCurFormatKey, |
| eCurLanguage, |
| bThousand, bNegRed, |
| nPrecision, nLeadingZeroes ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SvxNumberFormatShell::GetOptions( const String& rFormat, |
| sal_Bool& rThousand, |
| sal_Bool& rNegRed, |
| sal_uInt16& rPrecision, |
| sal_uInt16& rLeadingZeroes, |
| sal_uInt16& rCatLbPos ) |
| { |
| |
| sal_uInt32 nFmtKey = pFormatter->GetEntryKey( rFormat, eCurLanguage ); |
| |
| if(nFmtKey != NUMBERFORMAT_ENTRY_NOT_FOUND) |
| { |
| if ( nFmtKey != NUMBERFORMAT_ENTRY_NOT_FOUND ) |
| { |
| pFormatter->GetFormatSpecialInfo( nFmtKey, |
| rThousand, rNegRed, |
| rPrecision, rLeadingZeroes ); |
| |
| CategoryToPos_Impl( pFormatter->GetType( nFmtKey ), rCatLbPos ); |
| } |
| else |
| rCatLbPos = CAT_USERDEFINED; |
| } |
| else |
| { |
| sal_Bool bTestBanking=sal_False; |
| sal_uInt16 nPos=FindCurrencyTableEntry(rFormat, bTestBanking ); |
| |
| if(IsInTable(nPos,bTestBanking,rFormat) && |
| pFormatter->GetFormatSpecialInfo( rFormat,rThousand, rNegRed, |
| rPrecision, rLeadingZeroes,eCurLanguage)==0) |
| { |
| rCatLbPos = CAT_CURRENCY; |
| } |
| else |
| rCatLbPos = CAT_USERDEFINED; |
| } |
| |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SvxNumberFormatShell::MakePreviewString( const String& rFormatStr, |
| String& rPreviewStr, |
| Color*& rpFontColor ) |
| { |
| rpFontColor = NULL; |
| |
| sal_uIntPtr nExistingFormat = pFormatter->GetEntryKey( rFormatStr, eCurLanguage ); |
| if ( nExistingFormat == NUMBERFORMAT_ENTRY_NOT_FOUND ) |
| { |
| // real preview - not implemented in NumberFormatter for text formats |
| |
| pFormatter->GetPreviewString( rFormatStr, nValNum, rPreviewStr, |
| &rpFontColor, eCurLanguage ); |
| } |
| else |
| { |
| // format exists |
| |
| // #50441# if a string was set in addition to the value, use it for text formats |
| sal_Bool bUseText = ( eValType == SVX_VALUE_TYPE_STRING || |
| ( aValStr.Len() && ( pFormatter->GetType(nExistingFormat) & NUMBERFORMAT_TEXT ) ) ); |
| if ( bUseText ) |
| pFormatter->GetOutputString( aValStr, nExistingFormat, |
| rPreviewStr, &rpFontColor ); |
| else |
| pFormatter->GetOutputString( nValNum, nExistingFormat, |
| rPreviewStr, &rpFontColor ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SvxNumberFormatShell::IsUserDefined( const String& rFmtString ) |
| { |
| sal_uInt32 nFound = pFormatter->GetEntryKey( rFmtString, eCurLanguage ); |
| |
| sal_Bool bFlag=sal_False; |
| if ( nFound != NUMBERFORMAT_ENTRY_NOT_FOUND ) |
| { |
| bFlag=pFormatter->IsUserDefined( rFmtString, eCurLanguage ); |
| |
| if(bFlag) |
| { |
| const SvNumberformat* pNumEntry = pFormatter->GetEntry(nFound); |
| |
| if(pNumEntry!=NULL && pNumEntry->HasNewCurrency()) |
| { |
| sal_Bool bTestBanking; |
| sal_uInt16 nPos=FindCurrencyTableEntry(rFmtString,bTestBanking); |
| bFlag=!IsInTable(nPos,bTestBanking,rFmtString); |
| } |
| } |
| } |
| return bFlag; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SvxNumberFormatShell::FindEntry( const String& rFmtString, sal_uInt32* pAt /* = NULL */ ) |
| { |
| sal_Bool bRes=sal_False; |
| sal_uInt32 nFound = pFormatter->TestNewString( rFmtString, eCurLanguage ); |
| |
| if ( nFound == NUMBERFORMAT_ENTRY_NOT_FOUND ) |
| { |
| sal_Bool bTestBanking=sal_False; |
| sal_uInt16 nPos=FindCurrencyTableEntry(rFmtString, bTestBanking ); |
| |
| if(IsInTable(nPos,bTestBanking,rFmtString)) |
| { |
| nFound=NUMBERFORMAT_ENTRY_NEW_CURRENCY; |
| bRes=sal_True; |
| } |
| } |
| else |
| { |
| bRes=!IsRemoved_Impl( nFound ); |
| } |
| |
| if ( pAt ) |
| *pAt = nFound; |
| |
| return bRes; |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| |
| void SvxNumberFormatShell::GetInitSettings( |
| sal_uInt16& nCatLbPos, |
| LanguageType& rLangType, |
| sal_uInt16& nFmtLbSelPos, |
| SvStrings& rFmtEntries, |
| String& rPrevString, |
| Color*& rpPrevColor ) |
| { |
| // ------------------------------------------------------------------- |
| // Vorbedingung: Zahlenformatierer gefunden |
| DBG_ASSERT( pFormatter != NULL, "Zahlenformatierer nicht gefunden!" ); |
| |
| // sal_uInt16 nCount = 0; |
| short nSelPos = SELPOS_NONE; |
| // SvNumberFormatTable* pFmtTable = NULL; |
| |
| // Sonderbehandlung fuer undefiniertes Zahlenformat: |
| if ( (eValType == SVX_VALUE_TYPE_UNDEFINED) && (nCurFormatKey == 0) ) |
| PosToCategory_Impl( CAT_ALL, nCurCategory ); // Kategorie = Alle |
| else |
| nCurCategory = NUMBERFORMAT_UNDEFINED; // Kategorie = Undefiniert |
| |
| pCurFmtTable = &(pFormatter->GetFirstEntryTable( nCurCategory, |
| nCurFormatKey, |
| eCurLanguage )); |
| |
| |
| |
| CategoryToPos_Impl( nCurCategory, nCatLbPos ); |
| rLangType = eCurLanguage; |
| |
| nSelPos = FillEntryList_Impl( rFmtEntries ); |
| |
| DBG_ASSERT( nSelPos != SELPOS_NONE, "Leere Formatliste!" ); |
| |
| nFmtLbSelPos = (nSelPos != SELPOS_NONE) ? (sal_uInt16)nSelPos : 0; |
| GetPreviewString_Impl( rPrevString, rpPrevColor ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| short SvxNumberFormatShell::FillEntryList_Impl( SvStrings& rList ) |
| { |
| /* Erstellen einer aktuellen Liste von Format-Eintraegen. |
| * Rueckgabewert ist die Listenposition des aktuellen Formates. |
| * Ist die Liste leer oder gibt es kein aktuelles Format, |
| * so wird SELPOS_NONE geliefert. |
| */ |
| short nSelPos=0; |
| aCurEntryList.Remove(nSelPos,aCurEntryList.Count()); |
| sal_uInt16 nPrivCat = CAT_CURRENCY; |
| nSelPos=SELPOS_NONE; |
| |
| if(nCurCategory==NUMBERFORMAT_ALL) |
| { |
| FillEListWithStd_Impl(rList,CAT_NUMBER,nSelPos); |
| FillEListWithStd_Impl(rList,CAT_PERCENT,nSelPos); |
| FillEListWithStd_Impl(rList,CAT_CURRENCY,nSelPos); |
| FillEListWithStd_Impl(rList,CAT_DATE,nSelPos); |
| FillEListWithStd_Impl(rList,CAT_TIME,nSelPos); |
| FillEListWithStd_Impl(rList,CAT_SCIENTIFIC,nSelPos); |
| FillEListWithStd_Impl(rList,CAT_FRACTION,nSelPos); |
| FillEListWithStd_Impl(rList,CAT_BOOLEAN,nSelPos); |
| FillEListWithStd_Impl(rList,CAT_TEXT,nSelPos); |
| } |
| else |
| { |
| CategoryToPos_Impl(nCurCategory, nPrivCat); |
| FillEListWithStd_Impl(rList,nPrivCat,nSelPos); |
| } |
| |
| if( nPrivCat!=CAT_CURRENCY) |
| nSelPos=FillEListWithUsD_Impl(rList,nPrivCat,nSelPos); |
| |
| return nSelPos; |
| } |
| |
| void SvxNumberFormatShell::FillEListWithStd_Impl( SvStrings& rList,sal_uInt16 nPrivCat,short &nSelPos ) |
| { |
| /* Erstellen einer aktuellen Liste von Format-Eintraegen. |
| * Rueckgabewert ist die Listenposition des aktuellen Formates. |
| * Ist die Liste leer oder gibt es kein aktuelles Format, |
| * so wird SELPOS_NONE geliefert. |
| */ |
| DBG_ASSERT( pCurFmtTable != NULL, "Unbekanntes Zahlenformat!" ); |
| |
| if(aCurrencyFormatList.Count()>0) |
| aCurrencyFormatList.DeleteAndDestroy(0,aCurrencyFormatList.Count()); |
| |
| if(nPrivCat==CAT_CURRENCY) |
| { |
| nSelPos=FillEListWithCurrency_Impl(rList,nSelPos); |
| } |
| else |
| { |
| NfIndexTableOffset eOffsetStart; |
| NfIndexTableOffset eOffsetEnd; |
| |
| switch(nPrivCat) |
| { |
| case CAT_NUMBER :eOffsetStart=NF_NUMBER_START; |
| eOffsetEnd=NF_NUMBER_END; |
| break; |
| case CAT_PERCENT :eOffsetStart=NF_PERCENT_START; |
| eOffsetEnd=NF_PERCENT_END; |
| break; |
| case CAT_CURRENCY :eOffsetStart=NF_CURRENCY_START; |
| eOffsetEnd=NF_CURRENCY_END; |
| break; |
| case CAT_DATE :eOffsetStart=NF_DATE_START; |
| eOffsetEnd=NF_DATE_END; |
| break; |
| case CAT_TIME :eOffsetStart=NF_TIME_START; |
| eOffsetEnd=NF_TIME_END; |
| break; |
| case CAT_SCIENTIFIC :eOffsetStart=NF_SCIENTIFIC_START; |
| eOffsetEnd=NF_SCIENTIFIC_END; |
| break; |
| case CAT_FRACTION :eOffsetStart=NF_FRACTION_START; |
| eOffsetEnd=NF_FRACTION_END; |
| break; |
| case CAT_BOOLEAN :eOffsetStart=NF_BOOLEAN; |
| eOffsetEnd=NF_BOOLEAN; |
| break; |
| case CAT_TEXT :eOffsetStart=NF_TEXT; |
| eOffsetEnd=NF_TEXT; |
| break; |
| default :return; |
| } |
| |
| nSelPos=FillEListWithFormats_Impl(rList,nSelPos,eOffsetStart,eOffsetEnd); |
| |
| if(nPrivCat==CAT_DATE || nPrivCat==CAT_TIME) |
| { |
| nSelPos=FillEListWithDateTime_Impl(rList,nSelPos); |
| //if(nSelPos!=SELPOS_NONE) nSelPos=nTmpPos; |
| } |
| } |
| } |
| |
| short SvxNumberFormatShell::FillEListWithFormats_Impl( SvStrings& rList,short nSelPos, |
| NfIndexTableOffset eOffsetStart, |
| NfIndexTableOffset eOffsetEnd) |
| { |
| /* Erstellen einer aktuellen Liste von Format-Eintraegen. |
| * Rueckgabewert ist die Listenposition des aktuellen Formates. |
| * Ist die Liste leer oder gibt es kein aktuelles Format, |
| * so wird SELPOS_NONE geliefert. |
| */ |
| sal_uInt16 nMyType; |
| |
| DBG_ASSERT( pCurFmtTable != NULL, "Unbekanntes Zahlenformat!" ); |
| |
| const SvNumberformat* pNumEntry = pCurFmtTable->First(); |
| // sal_uInt16 nCount = 0; |
| sal_uInt32 nNFEntry; |
| String aStrComment; |
| String aNewFormNInfo; |
| String aPrevString; |
| String a2PrevString; |
| |
| short nMyCat = SELPOS_NONE; |
| // short nIq=0; |
| |
| long nIndex; |
| |
| for(nIndex=eOffsetStart;nIndex<=eOffsetEnd;nIndex++) |
| { |
| nNFEntry=pFormatter->GetFormatIndex((NfIndexTableOffset)nIndex,eCurLanguage); |
| |
| pNumEntry = pFormatter->GetEntry(nNFEntry); |
| |
| if(pNumEntry==NULL) continue; |
| |
| nMyCat=pNumEntry->GetType() & ~NUMBERFORMAT_DEFINED; |
| aStrComment=pNumEntry->GetComment(); |
| CategoryToPos_Impl(nMyCat,nMyType); |
| aNewFormNInfo= pNumEntry->GetFormatstring(); |
| |
| const StringPtr pStr = new String(aNewFormNInfo); |
| |
| if ( nNFEntry == nCurFormatKey ) |
| { |
| nSelPos = ( !IsRemoved_Impl( nNFEntry ) ) ? aCurEntryList.Count() : SELPOS_NONE; |
| } |
| |
| rList.Insert( pStr,rList.Count()); |
| aCurEntryList.Insert( nNFEntry, aCurEntryList.Count() ); |
| } |
| |
| return nSelPos; |
| } |
| |
| short SvxNumberFormatShell::FillEListWithDateTime_Impl( SvStrings& rList,short nSelPos) |
| { |
| sal_uInt16 nMyType; |
| |
| DBG_ASSERT( pCurFmtTable != NULL, "Unbekanntes Zahlenformat!" ); |
| |
| const SvNumberformat* pNumEntry = pCurFmtTable->First(); |
| // sal_uInt16 nCount = 0; |
| sal_uInt32 nNFEntry; |
| String aStrComment; |
| String aNewFormNInfo; |
| String aPrevString; |
| String a2PrevString; |
| |
| short nMyCat = SELPOS_NONE; |
| // short nIq=0; |
| |
| long nIndex; |
| |
| for(nIndex=NF_DATETIME_START;nIndex<=NF_DATETIME_END;nIndex++) |
| { |
| nNFEntry=pFormatter->GetFormatIndex((NfIndexTableOffset)nIndex,eCurLanguage); |
| |
| pNumEntry = pFormatter->GetEntry(nNFEntry); |
| if(pNumEntry!=NULL) |
| { |
| nMyCat=pNumEntry->GetType() & ~NUMBERFORMAT_DEFINED; |
| aStrComment=pNumEntry->GetComment(); |
| CategoryToPos_Impl(nMyCat,nMyType); |
| aNewFormNInfo= pNumEntry->GetFormatstring(); |
| |
| const StringPtr pStr = new String(aNewFormNInfo); |
| |
| if ( nNFEntry == nCurFormatKey ) |
| { |
| nSelPos = ( !IsRemoved_Impl( nNFEntry ) ) ? aCurEntryList.Count() : SELPOS_NONE; |
| } |
| |
| rList.Insert( pStr,rList.Count()); |
| aCurEntryList.Insert( nNFEntry, aCurEntryList.Count() ); |
| } |
| } |
| |
| return nSelPos; |
| } |
| |
| short SvxNumberFormatShell::FillEListWithCurrency_Impl( SvStrings& rList,short nSelPos) |
| { |
| /* Erstellen einer aktuellen Liste von Format-Eintraegen. |
| * Rueckgabewert ist die Listenposition des aktuellen Formates. |
| * Ist die Liste leer oder gibt es kein aktuelles Format, |
| * so wird SELPOS_NONE geliefert. |
| */ |
| DBG_ASSERT( pCurFmtTable != NULL, "Unbekanntes Zahlenformat!" ); |
| |
| const NfCurrencyEntry* pTmpCurrencyEntry; |
| sal_Bool bTmpBanking; |
| XubString rSymbol; |
| |
| sal_Bool bFlag=pFormatter->GetNewCurrencySymbolString(nCurFormatKey,rSymbol, |
| &pTmpCurrencyEntry,&bTmpBanking); |
| |
| if((!bFlag && pCurCurrencyEntry==NULL) || |
| (bFlag && pTmpCurrencyEntry==NULL && !rSymbol.Len()) || |
| nCurCategory==NUMBERFORMAT_ALL) |
| { |
| if ( nCurCategory == NUMBERFORMAT_ALL ) |
| FillEListWithUserCurrencys(rList,nSelPos); |
| nSelPos=FillEListWithSysCurrencys(rList,nSelPos); |
| } |
| else |
| { |
| nSelPos=FillEListWithUserCurrencys(rList,nSelPos); |
| } |
| |
| return nSelPos; |
| } |
| |
| |
| short SvxNumberFormatShell::FillEListWithSysCurrencys( SvStrings& rList,short nSelPos) |
| { |
| /* Erstellen einer aktuellen Liste von Format-Eintraegen. |
| * Rueckgabewert ist die Listenposition des aktuellen Formates. |
| * Ist die Liste leer oder gibt es kein aktuelles Format, |
| * so wird SELPOS_NONE geliefert. |
| */ |
| sal_uInt16 nMyType; |
| |
| DBG_ASSERT( pCurFmtTable != NULL, "Unbekanntes Zahlenformat!" ); |
| |
| const SvNumberformat* pNumEntry = pCurFmtTable->First(); |
| sal_uInt16 nCount = 0; |
| sal_uInt32 nNFEntry; |
| String aStrComment; |
| String aNewFormNInfo; |
| String aPrevString; |
| String a2PrevString; |
| |
| nCurCurrencyEntryPos=0; |
| |
| short nMyCat = SELPOS_NONE; |
| // short nIq=0; |
| |
| NfIndexTableOffset eOffsetStart=NF_CURRENCY_START; |
| NfIndexTableOffset eOffsetEnd=NF_CURRENCY_END;; |
| long nIndex; |
| |
| for(nIndex=eOffsetStart;nIndex<=eOffsetEnd;nIndex++) |
| { |
| nNFEntry=pFormatter->GetFormatIndex((NfIndexTableOffset)nIndex,eCurLanguage); |
| |
| pNumEntry = pFormatter->GetEntry(nNFEntry); |
| |
| if(pNumEntry==NULL) continue; |
| |
| nMyCat=pNumEntry->GetType() & ~NUMBERFORMAT_DEFINED; |
| aStrComment=pNumEntry->GetComment(); |
| CategoryToPos_Impl(nMyCat,nMyType); |
| aNewFormNInfo= pNumEntry->GetFormatstring(); |
| |
| const StringPtr pStr = new String(aNewFormNInfo); |
| |
| if ( nNFEntry == nCurFormatKey ) |
| { |
| nSelPos = ( !IsRemoved_Impl( nNFEntry ) ) ? aCurEntryList.Count() : SELPOS_NONE; |
| } |
| |
| rList.Insert( pStr,rList.Count()); |
| aCurEntryList.Insert( nNFEntry, aCurEntryList.Count() ); |
| } |
| |
| if(nCurCategory!=NUMBERFORMAT_ALL) |
| { |
| pNumEntry = pCurFmtTable->First(); |
| nCount = 0; |
| while ( pNumEntry ) |
| { |
| sal_uInt32 nKey = pCurFmtTable->GetCurKey(); |
| |
| nCount++; |
| |
| if ( !IsRemoved_Impl( nKey )) |
| { |
| sal_Bool bUserNewCurrency=sal_False; |
| if(pNumEntry->HasNewCurrency()) |
| { |
| const NfCurrencyEntry* pTmpCurrencyEntry; |
| sal_Bool bTmpBanking; |
| XubString rSymbol; |
| |
| pFormatter->GetNewCurrencySymbolString(nKey,rSymbol, |
| &pTmpCurrencyEntry,&bTmpBanking); |
| |
| bUserNewCurrency=(pTmpCurrencyEntry!=NULL); |
| } |
| |
| if(!bUserNewCurrency &&(pNumEntry->GetType() & NUMBERFORMAT_DEFINED)) |
| { |
| nMyCat=pNumEntry->GetType() & ~NUMBERFORMAT_DEFINED; |
| aStrComment=pNumEntry->GetComment(); |
| CategoryToPos_Impl(nMyCat,nMyType); |
| aNewFormNInfo= pNumEntry->GetFormatstring(); |
| |
| const StringPtr pStr = new String(aNewFormNInfo); |
| |
| if ( nKey == nCurFormatKey ) nSelPos =aCurEntryList.Count(); |
| rList.Insert( pStr,rList.Count()); |
| aCurEntryList.Insert( nKey, aCurEntryList.Count() ); |
| } |
| } |
| pNumEntry = pCurFmtTable->Next(); |
| } |
| } |
| return nSelPos; |
| } |
| |
| short SvxNumberFormatShell::FillEListWithUserCurrencys( SvStrings& rList,short nSelPos) |
| { |
| /* Erstellen einer aktuellen Liste von Format-Eintraegen. |
| * Rueckgabewert ist die Listenposition des aktuellen Formates. |
| * Ist die Liste leer oder gibt es kein aktuelles Format, |
| * so wird SELPOS_NONE geliefert. |
| */ |
| sal_uInt16 nMyType; |
| |
| DBG_ASSERT( pCurFmtTable != NULL, "Unbekanntes Zahlenformat!" ); |
| |
| sal_uInt16 nCount = 0; |
| String aStrComment; |
| String aNewFormNInfo; |
| String aPrevString; |
| String a2PrevString; |
| short nMyCat = SELPOS_NONE; |
| // short nIq=0; |
| |
| const NfCurrencyEntry* pTmpCurrencyEntry; |
| sal_Bool bTmpBanking, bAdaptSelPos; |
| XubString rSymbol; |
| XubString rBankSymbol; |
| |
| SvStrings aList; |
| SvULongs aKeyList; |
| |
| /*sal_Bool bFlag=*/pFormatter->GetNewCurrencySymbolString(nCurFormatKey,rSymbol, |
| &pTmpCurrencyEntry,&bTmpBanking); |
| |
| XubString rShortSymbol; |
| |
| if(pCurCurrencyEntry==NULL) |
| { |
| // #110398# If no currency format was previously selected (we're not |
| // about to add another currency), try to select the initial currency |
| // format (nCurFormatKey) that was set in FormatChanged() after |
| // matching the format string entered in the dialog. |
| bAdaptSelPos = sal_True; |
| pCurCurrencyEntry=(NfCurrencyEntry*)pTmpCurrencyEntry; |
| bBankingSymbol=bTmpBanking; |
| nCurCurrencyEntryPos=FindCurrencyFormat(pTmpCurrencyEntry,bTmpBanking); |
| } |
| else |
| { |
| if (pTmpCurrencyEntry == pCurCurrencyEntry) |
| bAdaptSelPos = sal_True; |
| else |
| { |
| bAdaptSelPos = sal_False; |
| pTmpCurrencyEntry = pCurCurrencyEntry; |
| } |
| bTmpBanking=bBankingSymbol; |
| } |
| |
| if(pTmpCurrencyEntry!=NULL) |
| { |
| pTmpCurrencyEntry->BuildSymbolString(rSymbol,sal_False); |
| pTmpCurrencyEntry->BuildSymbolString(rBankSymbol,sal_True); |
| pTmpCurrencyEntry->BuildSymbolString(rShortSymbol,bTmpBanking,sal_True); |
| } |
| |
| const SvNumberformat* pNumEntry = pCurFmtTable->First(); |
| |
| while ( pNumEntry ) |
| { |
| sal_uInt32 nKey = pCurFmtTable->GetCurKey(); |
| |
| nCount++; |
| |
| if ( !IsRemoved_Impl( nKey ) ) |
| { |
| if( pNumEntry->GetType() & NUMBERFORMAT_DEFINED || |
| pNumEntry->IsAdditionalStandardDefined() ) |
| { |
| nMyCat=pNumEntry->GetType() & ~NUMBERFORMAT_DEFINED; |
| aStrComment=pNumEntry->GetComment(); |
| CategoryToPos_Impl(nMyCat,nMyType); |
| aNewFormNInfo= pNumEntry->GetFormatstring(); |
| |
| sal_Bool bInsFlag=sal_False; |
| if ( pNumEntry->HasNewCurrency() ) |
| bInsFlag = sal_True; // merge locale formats into currency selection |
| else if( (!bTmpBanking && aNewFormNInfo.Search(rSymbol)!=STRING_NOTFOUND) || |
| (bTmpBanking && aNewFormNInfo.Search(rBankSymbol)!=STRING_NOTFOUND) ) |
| { |
| bInsFlag=sal_True; |
| } |
| else if(aNewFormNInfo.Search(rShortSymbol)!=STRING_NOTFOUND) |
| { |
| XubString rTstSymbol; |
| const NfCurrencyEntry* pTstCurrencyEntry; |
| sal_Bool bTstBanking; |
| |
| /*sal_Bool bTstFlag=*/pFormatter->GetNewCurrencySymbolString(nKey,rTstSymbol, |
| &pTstCurrencyEntry,&bTstBanking); |
| |
| if(pTmpCurrencyEntry==pTstCurrencyEntry && bTstBanking==bTmpBanking) |
| { |
| bInsFlag=sal_True; |
| } |
| |
| } |
| |
| if(bInsFlag) |
| { |
| const StringPtr pStr = new String(aNewFormNInfo); |
| |
| aList.Insert( pStr,aList.Count()); |
| aKeyList.Insert( nKey, aKeyList.Count() ); |
| } |
| } |
| } |
| pNumEntry = pCurFmtTable->Next(); |
| } |
| |
| NfWSStringsDtor aWSStringsDtor; |
| sal_uInt16 nDefault; |
| if ( pTmpCurrencyEntry && nCurCategory != NUMBERFORMAT_ALL ) |
| { |
| nDefault = pFormatter->GetCurrencyFormatStrings( |
| aWSStringsDtor, *pTmpCurrencyEntry, bTmpBanking ); |
| if ( !bTmpBanking ) |
| pFormatter->GetCurrencyFormatStrings( |
| aWSStringsDtor, *pTmpCurrencyEntry, sal_True ); |
| } |
| else |
| nDefault = 0; |
| if ( !bTmpBanking && nCurCategory != NUMBERFORMAT_ALL ) |
| { // append formats for all currencies defined in the current I18N locale |
| const NfCurrencyTable& rCurrencyTable = SvNumberFormatter::GetTheCurrencyTable(); |
| sal_uInt16 nCurrCount = rCurrencyTable.Count(); |
| LanguageType eLang = MsLangId::getRealLanguage( eCurLanguage ); |
| for ( sal_uInt16 i=0; i < nCurrCount; ++i ) |
| { |
| const NfCurrencyEntry* pCurr = rCurrencyTable[i]; |
| if ( pCurr->GetLanguage() == eLang && pTmpCurrencyEntry != pCurr ) |
| { |
| pFormatter->GetCurrencyFormatStrings( aWSStringsDtor, *pCurr, sal_False ); |
| pFormatter->GetCurrencyFormatStrings( aWSStringsDtor, *pCurr, sal_True ); |
| } |
| } |
| } |
| |
| sal_uInt16 i,nPos; |
| sal_uInt16 nOldListCount = rList.Count(); |
| for( i=0, nPos=nOldListCount; i<aWSStringsDtor.Count(); i++) |
| { |
| sal_Bool bFlag=sal_True; |
| String aInsStr(*aWSStringsDtor[i]); |
| sal_uInt16 j; |
| for(j=0;j<aList.Count();j++) |
| { |
| const StringPtr pTestStr=aList[j]; |
| |
| if(*pTestStr==aInsStr) |
| { |
| bFlag=sal_False; |
| break; |
| } |
| } |
| if(bFlag) |
| { |
| rList.Insert(new String(aInsStr),nPos); |
| aCurEntryList.Insert( NUMBERFORMAT_ENTRY_NOT_FOUND, nPos++); |
| } |
| else |
| { |
| rList.Insert(aList[j],nPos); |
| aList.Remove(j); |
| aCurEntryList.Insert( aKeyList[j],nPos++); |
| aKeyList.Remove(j); |
| } |
| } |
| |
| for(i=0;i<aKeyList.Count();i++) |
| { |
| if(aKeyList[i]!=NUMBERFORMAT_ENTRY_NOT_FOUND) |
| { |
| rList.Insert(aList[i],rList.Count()); |
| aCurEntryList.Insert( aKeyList[i],aCurEntryList.Count()); |
| } |
| } |
| |
| for(i=nOldListCount;i<rList.Count();i++) |
| { |
| aCurrencyFormatList.Insert(new String(*rList[i]),aCurrencyFormatList.Count()); |
| |
| if ( nSelPos == SELPOS_NONE && bAdaptSelPos && aCurEntryList[i] == nCurFormatKey ) |
| nSelPos = i; |
| } |
| |
| if ( nSelPos == SELPOS_NONE && nCurCategory != NUMBERFORMAT_ALL ) |
| nSelPos = nDefault; |
| |
| return nSelPos; |
| } |
| |
| |
| short SvxNumberFormatShell::FillEListWithUsD_Impl( SvStrings& rList, sal_uInt16 nPrivCat, short nSelPos) |
| { |
| /* Erstellen einer aktuellen Liste von Format-Eintraegen. |
| * Rueckgabewert ist die Listenposition des aktuellen Formates. |
| * Ist die Liste leer oder gibt es kein aktuelles Format, |
| * so wird SELPOS_NONE geliefert. |
| */ |
| sal_uInt16 nMyType; |
| |
| DBG_ASSERT( pCurFmtTable != NULL, "Unbekanntes Zahlenformat!" ); |
| |
| const SvNumberformat* pNumEntry = pCurFmtTable->First(); |
| sal_uInt16 nCount = 0; |
| String aStrComment; |
| String aNewFormNInfo; |
| String aPrevString; |
| String a2PrevString; |
| |
| short nMyCat = SELPOS_NONE; |
| // short nIq=0; |
| sal_Bool bAdditional = (nPrivCat != CAT_USERDEFINED && |
| nCurCategory != NUMBERFORMAT_ALL); |
| |
| while ( pNumEntry ) |
| { |
| sal_uInt32 nKey = pCurFmtTable->GetCurKey(); |
| |
| nCount++; |
| |
| if ( !IsRemoved_Impl( nKey ) ) |
| { |
| if( (pNumEntry->GetType() & NUMBERFORMAT_DEFINED) || |
| (bAdditional && pNumEntry->IsAdditionalStandardDefined()) ) |
| { |
| nMyCat=pNumEntry->GetType() & ~NUMBERFORMAT_DEFINED; |
| aStrComment=pNumEntry->GetComment(); |
| CategoryToPos_Impl(nMyCat,nMyType); |
| aNewFormNInfo= pNumEntry->GetFormatstring(); |
| |
| sal_Bool bFlag=sal_True; |
| if(pNumEntry->HasNewCurrency()) |
| { |
| sal_Bool bTestBanking; |
| sal_uInt16 nPos=FindCurrencyTableEntry(aNewFormNInfo,bTestBanking); |
| bFlag=!IsInTable(nPos,bTestBanking,aNewFormNInfo); |
| } |
| if(bFlag) |
| { |
| const StringPtr pStr = new String(aNewFormNInfo); |
| |
| if ( nKey == nCurFormatKey ) nSelPos =aCurEntryList.Count(); |
| rList.Insert( pStr,rList.Count()); |
| aCurEntryList.Insert( nKey, aCurEntryList.Count() ); |
| } |
| } |
| } |
| pNumEntry = pCurFmtTable->Next(); |
| } |
| return nSelPos; |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| |
| void SvxNumberFormatShell::GetPreviewString_Impl( String& rString, Color*& rpColor ) |
| { |
| rpColor = NULL; |
| |
| // #50441# if a string was set in addition to the value, use it for text formats |
| sal_Bool bUseText = ( eValType == SVX_VALUE_TYPE_STRING || |
| ( aValStr.Len() && ( pFormatter->GetType(nCurFormatKey) & NUMBERFORMAT_TEXT ) ) ); |
| |
| if ( bUseText ) |
| pFormatter->GetOutputString( aValStr, nCurFormatKey, rString, &rpColor ); |
| else |
| pFormatter->GetOutputString( nValNum, nCurFormatKey, rString, &rpColor ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SvxNumberFormatShell::IsRemoved_Impl( sal_uInt32 nKey ) |
| { |
| sal_Bool bFound = sal_False; |
| for ( sal_uInt16 i = 0; !bFound && i < aDelList.Count(); ++i ) |
| if ( aDelList[i] == nKey ) |
| bFound = sal_True; |
| return bFound; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SvxNumberFormatShell::IsAdded_Impl( sal_uInt32 nKey ) |
| { |
| sal_Bool bFound = sal_False; |
| for ( sal_uInt16 i = 0; !bFound && i < aAddList.Count(); ++i ) |
| if ( aAddList[i] == nKey ) |
| bFound = sal_True; |
| return bFound; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Konvertierungs-Routinen: |
| // ------------------------ |
| |
| void SvxNumberFormatShell::PosToCategory_Impl( sal_uInt16 nPos, short& rCategory ) |
| { |
| // Kategorie ::com::sun::star::form-Positionen abbilden (->Resource) |
| switch ( nPos ) |
| { |
| case CAT_USERDEFINED: rCategory = NUMBERFORMAT_DEFINED; break; |
| case CAT_NUMBER: rCategory = NUMBERFORMAT_NUMBER; break; |
| case CAT_PERCENT: rCategory = NUMBERFORMAT_PERCENT; break; |
| case CAT_CURRENCY: rCategory = NUMBERFORMAT_CURRENCY; break; |
| case CAT_DATE: rCategory = NUMBERFORMAT_DATE; break; |
| case CAT_TIME: rCategory = NUMBERFORMAT_TIME; break; |
| case CAT_SCIENTIFIC: rCategory = NUMBERFORMAT_SCIENTIFIC; break; |
| case CAT_FRACTION: rCategory = NUMBERFORMAT_FRACTION; break; |
| case CAT_BOOLEAN: rCategory = NUMBERFORMAT_LOGICAL; break; |
| case CAT_TEXT: rCategory = NUMBERFORMAT_TEXT; break; |
| case CAT_ALL: |
| default: rCategory = NUMBERFORMAT_ALL; break; |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SvxNumberFormatShell::CategoryToPos_Impl( short nCategory, sal_uInt16& rPos ) |
| { |
| // Kategorie auf ::com::sun::star::form-Positionen abbilden (->Resource) |
| switch ( nCategory ) |
| { |
| case NUMBERFORMAT_DEFINED: rPos = CAT_USERDEFINED; break; |
| case NUMBERFORMAT_NUMBER: rPos = CAT_NUMBER; break; |
| case NUMBERFORMAT_PERCENT: rPos = CAT_PERCENT; break; |
| case NUMBERFORMAT_CURRENCY: rPos = CAT_CURRENCY; break; |
| case NUMBERFORMAT_DATETIME: |
| case NUMBERFORMAT_DATE: rPos = CAT_DATE; break; |
| case NUMBERFORMAT_TIME: rPos = CAT_TIME; break; |
| case NUMBERFORMAT_SCIENTIFIC: rPos = CAT_SCIENTIFIC; break; |
| case NUMBERFORMAT_FRACTION: rPos = CAT_FRACTION; break; |
| case NUMBERFORMAT_LOGICAL: rPos = CAT_BOOLEAN; break; |
| case NUMBERFORMAT_TEXT: rPos = CAT_TEXT; break; |
| case NUMBERFORMAT_ALL: |
| default: rPos = CAT_ALL; |
| } |
| } |
| |
| |
| /************************************************************************* |
| #* Member: MakePrevStringFromVal Datum:19.09.97 |
| #*------------------------------------------------------------------------ |
| #* |
| #* Klasse: SvxNumberFormatShell |
| #* |
| #* Funktion: Formatiert die Zahl nValue abhaengig von rFormatStr |
| #* und speichert das Ergebnis in rPreviewStr. |
| #* |
| #* Input: FormatString, Farbe, zu formatierende Zahl |
| #* |
| #* Output: Ausgabestring rPreviewStr |
| #* |
| #************************************************************************/ |
| |
| void SvxNumberFormatShell::MakePrevStringFromVal( |
| const String& rFormatStr, |
| String& rPreviewStr, |
| Color*& rpFontColor, |
| double nValue) |
| { |
| rpFontColor = NULL; |
| pFormatter->GetPreviewString( rFormatStr, nValue, rPreviewStr, &rpFontColor, eCurLanguage ); |
| } |
| |
| /************************************************************************* |
| #* Member: GetComment4Entry Datum:30.10.97 |
| #*------------------------------------------------------------------------ |
| #* |
| #* Klasse: SvxNumberFormatShell |
| #* |
| #* Funktion: Liefert den Kommentar fuer einen gegebenen |
| #* Eintrag zurueck. |
| #* |
| #* Input: Nummer des Eintrags |
| #* |
| #* Output: Kommentar-String |
| #* |
| #************************************************************************/ |
| |
| void SvxNumberFormatShell::SetComment4Entry(short nEntry,String aEntStr) |
| { |
| SvNumberformat *pNumEntry; |
| if(nEntry<0) return; |
| sal_uInt32 nMyNfEntry=aCurEntryList[nEntry]; |
| pNumEntry = (SvNumberformat*)pFormatter->GetEntry(nMyNfEntry); |
| if(pNumEntry!=NULL) pNumEntry->SetComment(aEntStr); |
| } |
| |
| /************************************************************************* |
| #* Member: GetComment4Entry Datum:30.10.97 |
| #*------------------------------------------------------------------------ |
| #* |
| #* Klasse: SvxNumberFormatShell |
| #* |
| #* Funktion: Liefert den Kommentar fuer einen gegebenen |
| #* Eintrag zurueck. |
| #* |
| #* Input: Nummer des Eintrags |
| #* |
| #* Output: Kommentar-String |
| #* |
| #************************************************************************/ |
| |
| String SvxNumberFormatShell::GetComment4Entry(short nEntry) |
| { |
| const SvNumberformat *pNumEntry; |
| |
| if(nEntry < 0) |
| return String(); |
| |
| if(nEntry<aCurEntryList.Count()) |
| { |
| sal_uInt32 nMyNfEntry=aCurEntryList[nEntry]; |
| pNumEntry = pFormatter->GetEntry(nMyNfEntry); |
| if(pNumEntry!=NULL) |
| return pNumEntry->GetComment(); |
| } |
| |
| return String(); |
| } |
| |
| /************************************************************************* |
| #* Member: GetCategory4Entry Datum:30.10.97 |
| #*------------------------------------------------------------------------ |
| #* |
| #* Klasse: SvxNumberFormatShell |
| #* |
| #* Funktion: Liefert die Kategorie- Nummer fuer einen gegebenen |
| #* Eintrag zurueck. |
| #* |
| #* Input: Nummer des Eintrags |
| #* |
| #* Output: Kategorie- Nummer |
| #* |
| #************************************************************************/ |
| |
| short SvxNumberFormatShell::GetCategory4Entry(short nEntry) |
| { |
| const SvNumberformat *pNumEntry; |
| if(nEntry<0) return 0; |
| |
| if(nEntry<aCurEntryList.Count()) |
| { |
| sal_uInt32 nMyNfEntry=aCurEntryList[nEntry]; |
| |
| if(nMyNfEntry!=NUMBERFORMAT_ENTRY_NOT_FOUND) |
| { |
| pNumEntry = pFormatter->GetEntry(nMyNfEntry); |
| sal_uInt16 nMyCat,nMyType; |
| if(pNumEntry!=NULL) |
| { |
| nMyCat=pNumEntry->GetType() & ~NUMBERFORMAT_DEFINED; |
| CategoryToPos_Impl(nMyCat,nMyType); |
| |
| return (short) nMyType; |
| } |
| return 0; |
| } |
| else if(aCurrencyFormatList.Count()>0) |
| { |
| return CAT_CURRENCY; |
| } |
| } |
| return 0; |
| |
| } |
| |
| /************************************************************************* |
| #* Member: GetUserDefined4Entry Datum:31.10.97 |
| #*------------------------------------------------------------------------ |
| #* |
| #* Klasse: SvxNumberFormatShell |
| #* |
| #* Funktion: Liefert die Information, ob ein Eintrag |
| #* benutzerspezifisch ist zurueck. |
| #* |
| #* Input: Nummer des Eintrags |
| #* |
| #* Output: Benutzerspezifisch? |
| #* |
| #************************************************************************/ |
| |
| sal_Bool SvxNumberFormatShell::GetUserDefined4Entry(short nEntry) |
| { |
| const SvNumberformat *pNumEntry; |
| if(nEntry<0) return 0; |
| if(nEntry<aCurEntryList.Count()) |
| { |
| sal_uInt32 nMyNfEntry=aCurEntryList[nEntry]; |
| pNumEntry = pFormatter->GetEntry(nMyNfEntry); |
| |
| if(pNumEntry!=NULL) |
| { |
| if((pNumEntry->GetType() & NUMBERFORMAT_DEFINED)>0) |
| { |
| return sal_True; |
| } |
| } |
| } |
| return sal_False; |
| } |
| |
| |
| /************************************************************************* |
| #* Member: GetFormat4Entry Datum:30.10.97 |
| #*------------------------------------------------------------------------ |
| #* |
| #* Klasse: SvxNumberFormatShell |
| #* |
| #* Funktion: Liefert den Format- String fuer einen gegebenen |
| #* Eintrag zurueck. |
| #* |
| #* Input: Nummer des Eintrags |
| #* |
| #* Output: Format- String |
| #* |
| #************************************************************************/ |
| |
| String SvxNumberFormatShell::GetFormat4Entry(short nEntry) |
| { |
| const SvNumberformat *pNumEntry; |
| |
| if(nEntry < 0) |
| return String(); |
| |
| if(aCurrencyFormatList.Count()>0) |
| { |
| if(aCurrencyFormatList.Count()>nEntry) |
| return *aCurrencyFormatList[nEntry]; |
| } |
| else |
| { |
| sal_uInt32 nMyNfEntry=aCurEntryList[nEntry]; |
| pNumEntry = pFormatter->GetEntry(nMyNfEntry); |
| |
| if(pNumEntry!=NULL) |
| return pNumEntry->GetFormatstring(); |
| } |
| return String(); |
| } |
| |
| /************************************************************************* |
| #* Member: GetListPos4Entry Datum:31.10.97 |
| #*------------------------------------------------------------------------ |
| #* |
| #* Klasse: SvxNumberFormatShell |
| #* |
| #* Funktion: Liefert die Listen- Nummer fuer einen gegebenen |
| #* Formatindex zurueck. |
| #* |
| #* Input: Nummer des Eintrags |
| #* |
| #* Output: Kategorie- Nummer |
| #* |
| #************************************************************************/ |
| |
| short SvxNumberFormatShell::GetListPos4Entry(sal_uInt32 nIdx) |
| { |
| short nSelP=SELPOS_NONE; |
| if( aCurEntryList.Count() <= 0x7fff ) |
| { |
| for(short i=0;i<aCurEntryList.Count();i++) |
| { |
| if(aCurEntryList[i]==nIdx) |
| { |
| nSelP=i; |
| break; |
| } |
| } |
| } |
| else |
| { |
| DBG_ERROR("svx::SvxNumberFormatShell::GetListPos4Entry(), list got to large!" ); |
| } |
| return nSelP; |
| } |
| |
| short SvxNumberFormatShell::GetListPos4Entry( const String& rFmtString ) |
| { |
| sal_uInt32 nAt=0; |
| short nSelP=SELPOS_NONE; |
| if(FindEntry(rFmtString, &nAt)) |
| { |
| if(NUMBERFORMAT_ENTRY_NOT_FOUND!=nAt && NUMBERFORMAT_ENTRY_NEW_CURRENCY!=nAt) |
| { |
| nSelP=GetListPos4Entry(nAt); |
| } |
| else |
| { |
| if(aCurrencyFormatList.Count()>0) |
| { |
| for(sal_uInt16 i=0;i<aCurrencyFormatList.Count();i++) |
| { |
| if (rFmtString==*aCurrencyFormatList[i]) |
| { |
| nSelP=i; |
| break; |
| } |
| } |
| } |
| } |
| } |
| return nSelP; |
| } |
| |
| String SvxNumberFormatShell::GetStandardName() const |
| { |
| return pFormatter->GetStandardName( eCurLanguage); |
| } |
| |
| void SvxNumberFormatShell::GetCurrencySymbols( SvStringsDtor& rList, sal_uInt16* pPos ) |
| { |
| |
| const NfCurrencyEntry* pTmpCurrencyEntry=SvNumberFormatter::MatchSystemCurrency(); |
| |
| sal_Bool bFlag=(pTmpCurrencyEntry==NULL); |
| |
| GetCurrencySymbols( rList, bFlag); |
| |
| if(pPos!=NULL) |
| { |
| const NfCurrencyTable& rCurrencyTable=SvNumberFormatter::GetTheCurrencyTable(); |
| sal_uInt16 nTableCount=rCurrencyTable.Count(); |
| |
| *pPos=0; |
| sal_uInt16 nCount=aCurCurrencyList.Count(); |
| |
| if(bFlag) |
| { |
| *pPos=1; |
| nCurCurrencyEntryPos=1; |
| } |
| else |
| { |
| for(sal_uInt16 i=1;i<nCount;i++) |
| { |
| const sal_uInt16 j = aCurCurrencyList[i]; |
| if (j != (sal_uInt16)-1 && j < nTableCount && |
| pTmpCurrencyEntry == rCurrencyTable[j]) |
| { |
| *pPos=i; |
| nCurCurrencyEntryPos=i; |
| break; |
| } |
| } |
| } |
| } |
| |
| } |
| |
| void SvxNumberFormatShell::GetCurrencySymbols( SvStringsDtor& rList, sal_Bool bFlag ) |
| { |
| aCurCurrencyList.Remove(0,aCurCurrencyList.Count()); |
| |
| const NfCurrencyTable& rCurrencyTable=SvNumberFormatter::GetTheCurrencyTable(); |
| sal_uInt16 nCount=rCurrencyTable.Count(); |
| |
| SvtLanguageTable* pLanguageTable=new SvtLanguageTable; |
| |
| sal_uInt16 nStart=1; |
| sal_uInt16 i,j; |
| |
| XubString aString( ApplyLreOrRleEmbedding( rCurrencyTable[0]->GetSymbol())); |
| aString += sal_Unicode(' '); |
| aString += ApplyLreOrRleEmbedding( pLanguageTable->GetString( rCurrencyTable[0]->GetLanguage())); |
| |
| WSStringPtr pStr = new XubString(aString); |
| rList.Insert( pStr,rList.Count()); |
| sal_uInt16 nAuto=(sal_uInt16)-1; |
| aCurCurrencyList.Insert(nAuto,aCurCurrencyList.Count()); |
| |
| if(bFlag) |
| { |
| pStr = new XubString(aString); |
| rList.Insert( pStr,rList.Count()); |
| aCurCurrencyList.Insert((sal_uInt16)0,aCurCurrencyList.Count()); |
| ++nStart; |
| } |
| |
| CollatorWrapper aCollator( ::comphelper::getProcessServiceFactory()); |
| aCollator.loadDefaultCollator( Application::GetSettings().GetLocale(), 0); |
| |
| const String aTwoSpace( RTL_CONSTASCII_USTRINGPARAM( " ")); |
| |
| for(i=1;i<nCount;i++) |
| { |
| XubString aStr( ApplyLreOrRleEmbedding( rCurrencyTable[i]->GetBankSymbol())); |
| aStr += aTwoSpace; |
| aStr += ApplyLreOrRleEmbedding( rCurrencyTable[i]->GetSymbol()); |
| aStr += aTwoSpace; |
| aStr += ApplyLreOrRleEmbedding( pLanguageTable->GetString( rCurrencyTable[i]->GetLanguage())); |
| |
| pStr = new XubString(aStr); |
| #if 0 |
| fprintf( stderr, "currency entry: %s\n", ByteString( *pStr, RTL_TEXTENCODING_UTF8).GetBuffer()); |
| #endif |
| for(j=nStart;j<rList.Count();j++) |
| { |
| const StringPtr pTestStr=rList[j]; |
| if (aCollator.compareString( *pStr, *pTestStr) < 0) |
| break; // insert before first greater than |
| } |
| rList.Insert( pStr,j); |
| aCurCurrencyList.Insert(i,j); |
| } |
| |
| // Append ISO codes to symbol list. |
| // XXX If this is to be changed, various other places would had to be |
| // adapted that assume this order! |
| sal_uInt16 nCont = rList.Count(); |
| |
| for(i=1;i<nCount;i++) |
| { |
| bool bInsert = true; |
| pStr = new XubString( ApplyLreOrRleEmbedding( rCurrencyTable[i]->GetBankSymbol())); |
| |
| for (j = nCont; j < rList.Count() && bInsert; ++j) |
| { |
| const StringPtr pTestStr=rList[j]; |
| |
| if(*pTestStr==*pStr) |
| bInsert = false; |
| else |
| if (aCollator.compareString( *pStr, *pTestStr) < 0) |
| break; // insert before first greater than |
| } |
| if(bInsert) |
| { |
| rList.Insert( pStr,j); |
| aCurCurrencyList.Insert(i,j); |
| } |
| } |
| |
| delete pLanguageTable; |
| } |
| |
| void SvxNumberFormatShell::GetCurrencyFormats(SvStrings& aListDtor) |
| { |
| if(pCurCurrencyEntry!=NULL) |
| { |
| NfWSStringsDtor aWSStringsDtor; |
| /*sal_uInt16 nDefault = */pFormatter->GetCurrencyFormatStrings( aWSStringsDtor, |
| *pCurCurrencyEntry, bBankingSymbol ); |
| |
| for(sal_uInt16 i=0;i<aWSStringsDtor.Count();i++) |
| { |
| aListDtor.Insert(new String(*aWSStringsDtor[i]),aListDtor.Count()); |
| } |
| } |
| } |
| |
| sal_Bool SvxNumberFormatShell::IsBankingSymbol(sal_uInt16 nPos) |
| { |
| const NfCurrencyTable& rCurrencyTable=SvNumberFormatter::GetTheCurrencyTable(); |
| sal_uInt16 nCount=rCurrencyTable.Count(); |
| |
| return (nPos>nCount); |
| } |
| |
| void SvxNumberFormatShell::SetCurrencySymbol(sal_uInt16 nPos) |
| { |
| const NfCurrencyTable& rCurrencyTable=SvNumberFormatter::GetTheCurrencyTable(); |
| sal_uInt16 nCount=rCurrencyTable.Count(); |
| |
| bBankingSymbol=(nPos>=nCount); |
| |
| if(nPos<aCurCurrencyList.Count()) |
| { |
| sal_uInt16 nCurrencyPos=aCurCurrencyList[nPos]; |
| if(nCurrencyPos!=(sal_uInt16)-1) |
| { |
| pCurCurrencyEntry=rCurrencyTable[nCurrencyPos]; |
| nCurCurrencyEntryPos=nPos; |
| } |
| else |
| { |
| pCurCurrencyEntry=NULL; |
| nCurCurrencyEntryPos=0; |
| nCurFormatKey=pFormatter->GetFormatIndex( |
| NF_CURRENCY_1000DEC2_RED, eCurLanguage); |
| } |
| } |
| } |
| |
| sal_uInt32 SvxNumberFormatShell::GetCurrencySymbol() |
| { |
| return nCurCurrencyEntryPos; |
| } |
| |
| NfCurrencyEntry* SvxNumberFormatShell::GetCurCurrencyEntry() |
| { |
| return pCurCurrencyEntry; |
| } |
| |
| void SvxNumberFormatShell::SetCurCurrencyEntry(NfCurrencyEntry* pCEntry) |
| { |
| pCurCurrencyEntry=pCEntry; |
| } |
| |
| sal_Bool SvxNumberFormatShell::IsTmpCurrencyFormat( const String& rFmtString ) |
| { |
| sal_uInt32 nFound; |
| /*sal_Bool bRes=*/FindEntry(rFmtString, &nFound); |
| |
| if(nFound==NUMBERFORMAT_ENTRY_NEW_CURRENCY) |
| { |
| return sal_True; |
| } |
| return sal_False; |
| } |
| |
| sal_uInt16 SvxNumberFormatShell::FindCurrencyFormat( const String& rFmtString ) |
| { |
| const NfCurrencyTable& rCurrencyTable=SvNumberFormatter::GetTheCurrencyTable(); |
| sal_uInt16 nCount=rCurrencyTable.Count(); |
| |
| sal_Bool bTestBanking=sal_False; |
| |
| sal_uInt16 nPos=FindCurrencyTableEntry(rFmtString, bTestBanking); |
| |
| sal_uInt16 nStart=0; |
| |
| if(nPos!=(sal_uInt16)-1) |
| { |
| if(bTestBanking && aCurCurrencyList.Count()>nPos) |
| { |
| nStart=nCount; |
| } |
| for(sal_uInt16 j=nStart;j<aCurCurrencyList.Count();j++) |
| { |
| if(aCurCurrencyList[j]==nPos) return j; |
| } |
| } |
| return (sal_uInt16) -1; |
| } |
| |
| sal_uInt16 SvxNumberFormatShell::FindCurrencyTableEntry( const String& rFmtString, sal_Bool &bTestBanking ) |
| { |
| sal_uInt16 nPos=(sal_uInt16) -1; |
| |
| const NfCurrencyTable& rCurrencyTable=SvNumberFormatter::GetTheCurrencyTable(); |
| sal_uInt16 nCount=rCurrencyTable.Count(); |
| |
| const SvNumberformat* pFormat; |
| String aSymbol, aExtension; |
| sal_uInt32 nFound = pFormatter->TestNewString( rFmtString, eCurLanguage ); |
| if ( nFound != NUMBERFORMAT_ENTRY_NOT_FOUND && |
| ((pFormat = pFormatter->GetEntry( nFound )) != 0) && |
| pFormat->GetNewCurrencySymbol( aSymbol, aExtension ) ) |
| { // eventually match with format locale |
| const NfCurrencyEntry* pTmpCurrencyEntry = |
| SvNumberFormatter::GetCurrencyEntry( bTestBanking, aSymbol, aExtension, |
| pFormat->GetLanguage() ); |
| if ( pTmpCurrencyEntry ) |
| { |
| for(sal_uInt16 i=0;i<nCount;i++) |
| { |
| if(pTmpCurrencyEntry==rCurrencyTable[i]) |
| { |
| nPos=i; |
| break; |
| } |
| } |
| } |
| } |
| else |
| { // search symbol string only |
| for(sal_uInt16 i=0;i<nCount;i++) |
| { |
| const NfCurrencyEntry* pTmpCurrencyEntry=rCurrencyTable[i]; |
| XubString _aSymbol, aBankSymbol; |
| pTmpCurrencyEntry->BuildSymbolString(_aSymbol,sal_False); |
| pTmpCurrencyEntry->BuildSymbolString(aBankSymbol,sal_True); |
| |
| if(rFmtString.Search(_aSymbol)!=STRING_NOTFOUND) |
| { |
| bTestBanking=sal_False; |
| nPos=i; |
| break; |
| } |
| else if(rFmtString.Search(aBankSymbol)!=STRING_NOTFOUND) |
| { |
| bTestBanking=sal_True; |
| nPos=i; |
| break; |
| } |
| } |
| } |
| |
| return nPos; |
| } |
| |
| sal_uInt16 SvxNumberFormatShell::FindCurrencyFormat(const NfCurrencyEntry* pTmpCurrencyEntry,sal_Bool bTmpBanking) |
| { |
| const NfCurrencyTable& rCurrencyTable=SvNumberFormatter::GetTheCurrencyTable(); |
| sal_uInt16 nCount=rCurrencyTable.Count(); |
| |
| // sal_Bool bTestBanking=sal_False; |
| sal_uInt16 nPos=0; |
| for(sal_uInt16 i=0;i<nCount;i++) |
| { |
| if(pTmpCurrencyEntry==rCurrencyTable[i]) |
| { |
| nPos=i; |
| break; |
| } |
| } |
| |
| sal_uInt16 nStart=0; |
| if(bTmpBanking && aCurCurrencyList.Count()>nPos) |
| { |
| nStart=nCount; |
| } |
| for(sal_uInt16 j=nStart;j<aCurCurrencyList.Count();j++) |
| { |
| if(aCurCurrencyList[j]==nPos) return j; |
| } |
| return (sal_uInt16) -1; |
| } |
| |
| sal_Bool SvxNumberFormatShell::IsInTable(sal_uInt16 nPos,sal_Bool bTmpBanking,const String &rFmtString) |
| { |
| sal_Bool bFlag=sal_False; |
| |
| if(nPos!=(sal_uInt16)-1) |
| { |
| const NfCurrencyTable& rCurrencyTable=SvNumberFormatter::GetTheCurrencyTable(); |
| sal_uInt16 nCount=rCurrencyTable.Count(); |
| |
| if(nPos<nCount) |
| { |
| NfWSStringsDtor aWSStringsDtor; |
| sal_uInt16 nDefault; |
| |
| const NfCurrencyEntry* pTmpCurrencyEntry=rCurrencyTable[nPos]; |
| |
| if ( pTmpCurrencyEntry!=NULL) |
| { |
| nDefault = pFormatter->GetCurrencyFormatStrings( aWSStringsDtor, |
| *pTmpCurrencyEntry, bTmpBanking ); |
| |
| for(sal_uInt16 i=0;i<aWSStringsDtor.Count();i++) |
| { |
| if(*aWSStringsDtor[i]==rFmtString) |
| { |
| bFlag=sal_True; |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| return bFlag; |
| } |
| |