1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_svl.hxx"
26 #ifndef GCC
27 #endif
28
29 // #include <math.h>
30 #include <tools/debug.hxx>
31 #include <unotools/charclass.hxx>
32 #include <i18npool/mslangid.hxx>
33 #include <unotools/localedatawrapper.hxx>
34 #include <unotools/numberformatcodewrapper.hxx>
35 #include <unotools/calendarwrapper.hxx>
36 #include <com/sun/star/i18n/KNumberFormatUsage.hpp>
37 #include <com/sun/star/i18n/KNumberFormatType.hpp>
38 #include <comphelper/processfactory.hxx>
39 #include <unotools/misccfg.hxx>
40
41 #define _SVSTDARR_USHORTS
42 #include <svl/svstdarr.hxx>
43
44 #define _ZFORLIST_CXX
45 #include <osl/mutex.hxx>
46 #include <svl/zforlist.hxx>
47 #undef _ZFORLIST_CXX
48
49 #include "zforscan.hxx"
50 #include "zforfind.hxx"
51 #include <svl/zformat.hxx>
52 #include "numhead.hxx"
53
54 #include <unotools/syslocaleoptions.hxx>
55 #include <unotools/digitgroupingiterator.hxx>
56 #include <rtl/logfile.hxx>
57 #include <rtl/instance.hxx>
58
59 #include <math.h>
60 #include <limits>
61
62 using namespace ::com::sun::star;
63 using namespace ::com::sun::star::uno;
64 using namespace ::com::sun::star::i18n;
65 using namespace ::com::sun::star::lang;
66
67
68 // Constants for type offsets per Country/Language (CL)
69 #define ZF_STANDARD 0
70 #define ZF_STANDARD_PERCENT 10
71 #define ZF_STANDARD_CURRENCY 20
72 #define ZF_STANDARD_DATE 30
73 #define ZF_STANDARD_TIME 40
74 #define ZF_STANDARD_DATETIME 50
75 #define ZF_STANDARD_SCIENTIFIC 60
76 #define ZF_STANDARD_FRACTION 70
77 #define ZF_STANDARD_NEWEXTENDED 75
78 #define ZF_STANDARD_NEWEXTENDEDMAX SV_MAX_ANZ_STANDARD_FORMATE-2 // 98
79 #define ZF_STANDARD_LOGICAL SV_MAX_ANZ_STANDARD_FORMATE-1 // 99
80 #define ZF_STANDARD_TEXT SV_MAX_ANZ_STANDARD_FORMATE // 100
81
82 /* Locale that is set if an unknown locale (from another system) is loaded of
83 * legacy documents. Can not be SYSTEM because else, for example, a German "DM"
84 * (old currency) is recognized as a date (#53155#). */
85 #define UNKNOWN_SUBSTITUTE LANGUAGE_ENGLISH_US
86
87 static sal_Bool bIndexTableInitialized = sal_False;
88 static sal_uInt32 __FAR_DATA theIndexTable[NF_INDEX_TABLE_ENTRIES];
89
90
91 // ====================================================================
92
93 /**
94 instead of every number formatter being a listener we have a registry which
95 also handles one instance of the SysLocale options
96 */
97
98 class SvNumberFormatterRegistry_Impl : public utl::ConfigurationListener
99 {
100 List aFormatters;
101 SvtSysLocaleOptions aSysLocaleOptions;
102 LanguageType eSysLanguage;
103
104 public:
105 SvNumberFormatterRegistry_Impl();
106 virtual ~SvNumberFormatterRegistry_Impl();
107
Insert(SvNumberFormatter * pThis)108 void Insert( SvNumberFormatter* pThis )
109 { aFormatters.Insert( pThis, LIST_APPEND ); }
Remove(SvNumberFormatter * pThis)110 SvNumberFormatter* Remove( SvNumberFormatter* pThis )
111 { return (SvNumberFormatter*)aFormatters.Remove( pThis ); }
Count()112 sal_uInt32 Count()
113 { return aFormatters.Count(); }
114
115 virtual void ConfigurationChanged( utl::ConfigurationBroadcaster*, sal_uInt32 );
116 };
117
118
SvNumberFormatterRegistry_Impl()119 SvNumberFormatterRegistry_Impl::SvNumberFormatterRegistry_Impl()
120 {
121 eSysLanguage = MsLangId::getRealLanguage( LANGUAGE_SYSTEM );
122 aSysLocaleOptions.AddListener( this );
123 }
124
125
~SvNumberFormatterRegistry_Impl()126 SvNumberFormatterRegistry_Impl::~SvNumberFormatterRegistry_Impl()
127 {
128 aSysLocaleOptions.RemoveListener( this );
129 }
130
131
ConfigurationChanged(utl::ConfigurationBroadcaster *,sal_uInt32 nHint)132 void SvNumberFormatterRegistry_Impl::ConfigurationChanged( utl::ConfigurationBroadcaster*, sal_uInt32 nHint )
133 {
134 if ( nHint & SYSLOCALEOPTIONS_HINT_LOCALE )
135 {
136 ::osl::MutexGuard aGuard( SvNumberFormatter::GetMutex() );
137 for ( SvNumberFormatter* p = (SvNumberFormatter*)aFormatters.First();
138 p; p = (SvNumberFormatter*)aFormatters.Next() )
139 {
140 p->ReplaceSystemCL( eSysLanguage );
141 }
142 eSysLanguage = MsLangId::getRealLanguage( LANGUAGE_SYSTEM );
143 }
144 if ( nHint & SYSLOCALEOPTIONS_HINT_CURRENCY )
145 {
146 ::osl::MutexGuard aGuard( SvNumberFormatter::GetMutex() );
147 for ( SvNumberFormatter* p = (SvNumberFormatter*)aFormatters.First();
148 p; p = (SvNumberFormatter*)aFormatters.Next() )
149 {
150 p->ResetDefaultSystemCurrency();
151 }
152 }
153 }
154
155
156 // ====================================================================
157
158 SvNumberFormatterRegistry_Impl* SvNumberFormatter::pFormatterRegistry = NULL;
159 sal_Bool SvNumberFormatter::bCurrencyTableInitialized = sal_False;
160 namespace
161 {
162 struct theCurrencyTable :
163 public rtl::Static< NfCurrencyTable, theCurrencyTable > {};
164
165 struct theLegacyOnlyCurrencyTable :
166 public rtl::Static< NfCurrencyTable, theLegacyOnlyCurrencyTable > {};
167 }
168 sal_uInt16 SvNumberFormatter::nSystemCurrencyPosition = 0;
169 SV_IMPL_PTRARR( NfCurrencyTable, NfCurrencyEntry* );
170 SV_IMPL_PTRARR( NfWSStringsDtor, String* );
171
172 // ob das BankSymbol immer am Ende ist (1 $;-1 $) oder sprachabhaengig
173 #define NF_BANKSYMBOL_FIX_POSITION 1
174
175
176 /***********************Funktionen SvNumberFormatter**************************/
177
178 const sal_uInt16 SvNumberFormatter::UNLIMITED_PRECISION = ::std::numeric_limits<sal_uInt16>::max();
179 const sal_uInt16 SvNumberFormatter::INPUTSTRING_PRECISION = ::std::numeric_limits<sal_uInt16>::max()-1;
180
SvNumberFormatter(const Reference<XMultiServiceFactory> & xSMgr,LanguageType eLang)181 SvNumberFormatter::SvNumberFormatter(
182 const Reference< XMultiServiceFactory >& xSMgr,
183 LanguageType eLang )
184 :
185 xServiceManager( xSMgr )
186 {
187 ImpConstruct( eLang );
188 }
189
190
SvNumberFormatter(LanguageType eLang)191 SvNumberFormatter::SvNumberFormatter( LanguageType eLang )
192 {
193 ImpConstruct( eLang );
194 }
195
196
~SvNumberFormatter()197 SvNumberFormatter::~SvNumberFormatter()
198 {
199 {
200 ::osl::MutexGuard aGuard( GetMutex() );
201 pFormatterRegistry->Remove( this );
202 if ( !pFormatterRegistry->Count() )
203 {
204 delete pFormatterRegistry;
205 pFormatterRegistry = NULL;
206 }
207 }
208
209 SvNumberformat* pEntry = aFTable.First();
210 while (pEntry)
211 {
212 delete pEntry;
213 pEntry = aFTable.Next();
214 }
215 delete pFormatTable;
216 delete pCharClass;
217 delete pStringScanner;
218 delete pFormatScanner;
219 ClearMergeTable();
220 delete pMergeTable;
221 }
222
223
ImpConstruct(LanguageType eLang)224 void SvNumberFormatter::ImpConstruct( LanguageType eLang )
225 {
226 RTL_LOGFILE_CONTEXT_AUTHOR( aTimeLog, "svl", "er93726", "SvNumberFormatter::ImpConstruct" );
227
228 if ( eLang == LANGUAGE_DONTKNOW )
229 eLang = UNKNOWN_SUBSTITUTE;
230 IniLnge = eLang;
231 ActLnge = eLang;
232 eEvalDateFormat = NF_EVALDATEFORMAT_INTL;
233 nDefaultSystemCurrencyFormat = NUMBERFORMAT_ENTRY_NOT_FOUND;
234
235 aLocale = MsLangId::convertLanguageToLocale( eLang );
236 pCharClass = new CharClass( xServiceManager, aLocale );
237 xLocaleData.init( xServiceManager, aLocale, eLang );
238 xCalendar.init( xServiceManager, aLocale );
239 xTransliteration.init( xServiceManager, eLang,
240 ::com::sun::star::i18n::TransliterationModules_IGNORE_CASE );
241 xNatNum.init( xServiceManager );
242
243 // cached locale data items
244 const LocaleDataWrapper* pLoc = GetLocaleData();
245 aDecimalSep = pLoc->getNumDecimalSep();
246 aThousandSep = pLoc->getNumThousandSep();
247 aDateSep = pLoc->getDateSep();
248
249 pStringScanner = new ImpSvNumberInputScan( this );
250 pFormatScanner = new ImpSvNumberformatScan( this );
251 pFormatTable = NULL;
252 MaxCLOffset = 0;
253 ImpGenerateFormats( 0, sal_False ); // 0 .. 999 for initialized language formats
254 pMergeTable = NULL;
255 bNoZero = sal_False;
256
257 ::osl::MutexGuard aGuard( GetMutex() );
258 GetFormatterRegistry().Insert( this );
259 }
260
261
ChangeIntl(LanguageType eLnge)262 void SvNumberFormatter::ChangeIntl(LanguageType eLnge)
263 {
264 if (ActLnge != eLnge)
265 {
266 ActLnge = eLnge;
267
268 aLocale = MsLangId::convertLanguageToLocale( eLnge );
269 pCharClass->setLocale( aLocale );
270 xLocaleData.changeLocale( aLocale, eLnge );
271 xCalendar.changeLocale( aLocale );
272 xTransliteration.changeLocale( eLnge );
273
274 // cached locale data items, initialize BEFORE calling ChangeIntl below
275 const LocaleDataWrapper* pLoc = GetLocaleData();
276 aDecimalSep = pLoc->getNumDecimalSep();
277 aThousandSep = pLoc->getNumThousandSep();
278 aDateSep = pLoc->getDateSep();
279
280 pFormatScanner->ChangeIntl();
281 pStringScanner->ChangeIntl();
282 }
283 }
284
285
286 // static
GetMutex()287 ::osl::Mutex& SvNumberFormatter::GetMutex()
288 {
289 static ::osl::Mutex* pMutex = NULL;
290 if( !pMutex )
291 {
292 ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
293 if( !pMutex )
294 {
295 // #i77768# Due to a static reference in the toolkit lib
296 // we need a mutex that lives longer than the svl library.
297 // Otherwise the dtor would use a destructed mutex!!
298 pMutex = new ::osl::Mutex;
299 }
300 }
301 return *pMutex;
302 }
303
304
305 // static
GetFormatterRegistry()306 SvNumberFormatterRegistry_Impl& SvNumberFormatter::GetFormatterRegistry()
307 {
308 ::osl::MutexGuard aGuard( GetMutex() );
309 if ( !pFormatterRegistry )
310 pFormatterRegistry = new SvNumberFormatterRegistry_Impl;
311 return *pFormatterRegistry;
312 }
313
314
GetUserDefColor(sal_uInt16 nIndex)315 Color* SvNumberFormatter::GetUserDefColor(sal_uInt16 nIndex)
316 {
317 if( aColorLink.IsSet() )
318 return (Color*) ( aColorLink.Call( (void*) &nIndex ));
319 else
320 return NULL;
321 }
322
ChangeNullDate(sal_uInt16 nDay,sal_uInt16 nMonth,sal_uInt16 nYear)323 void SvNumberFormatter::ChangeNullDate(sal_uInt16 nDay,
324 sal_uInt16 nMonth,
325 sal_uInt16 nYear)
326 {
327 pFormatScanner->ChangeNullDate(nDay, nMonth, nYear);
328 pStringScanner->ChangeNullDate(nDay, nMonth, nYear);
329 }
330
GetNullDate()331 Date* SvNumberFormatter::GetNullDate()
332 {
333 return pFormatScanner->GetNullDate();
334 }
335
ChangeStandardPrec(short nPrec)336 void SvNumberFormatter::ChangeStandardPrec(short nPrec)
337 {
338 pFormatScanner->ChangeStandardPrec(nPrec);
339 }
340
GetStandardPrec()341 sal_uInt16 SvNumberFormatter::GetStandardPrec()
342 {
343 return pFormatScanner->GetStandardPrec();
344 }
345
ImpChangeSysCL(LanguageType eLnge,sal_Bool bLoadingSO5)346 void SvNumberFormatter::ImpChangeSysCL( LanguageType eLnge, sal_Bool bLoadingSO5 )
347 {
348 if (eLnge == LANGUAGE_DONTKNOW)
349 eLnge = UNKNOWN_SUBSTITUTE;
350 if (eLnge != IniLnge)
351 {
352 IniLnge = eLnge;
353 ChangeIntl(eLnge);
354 SvNumberformat* pEntry = aFTable.First();
355 while (pEntry) // delete old formats
356 {
357 pEntry = (SvNumberformat*) aFTable.Remove(aFTable.GetCurKey());
358 delete pEntry;
359 pEntry = (SvNumberformat*) aFTable.First();
360 }
361 ImpGenerateFormats( 0, bLoadingSO5 ); // new standard formats
362 }
363 else if ( bLoadingSO5 )
364 { // delete additional standard formats
365 sal_uInt32 nKey;
366 aFTable.Seek( SV_MAX_ANZ_STANDARD_FORMATE + 1 );
367 while ( (nKey = aFTable.GetCurKey()) > SV_MAX_ANZ_STANDARD_FORMATE &&
368 nKey < SV_COUNTRY_LANGUAGE_OFFSET )
369 {
370 SvNumberformat* pEntry = (SvNumberformat*) aFTable.Remove( nKey );
371 delete pEntry;
372 }
373 }
374 }
375
376
ReplaceSystemCL(LanguageType eOldLanguage)377 void SvNumberFormatter::ReplaceSystemCL( LanguageType eOldLanguage )
378 {
379 sal_uInt32 nCLOffset = ImpGetCLOffset( LANGUAGE_SYSTEM );
380 if ( nCLOffset > MaxCLOffset )
381 return ; // no SYSTEM entries to replace
382
383 const sal_uInt32 nMaxBuiltin = nCLOffset + SV_MAX_ANZ_STANDARD_FORMATE;
384 const sal_uInt32 nNextCL = nCLOffset + SV_COUNTRY_LANGUAGE_OFFSET;
385 sal_uInt32 nKey;
386
387 // remove old builtin formats
388 aFTable.Seek( nCLOffset );
389 while ( (nKey = aFTable.GetCurKey()) >= nCLOffset && nKey <= nMaxBuiltin && aFTable.Count() )
390 {
391 SvNumberformat* pEntry = (SvNumberformat*) aFTable.Remove( nKey );
392 delete pEntry;
393 }
394
395 // move additional and user defined to temporary table
396 Table aOldTable;
397 while ( (nKey = aFTable.GetCurKey()) >= nCLOffset && nKey < nNextCL && aFTable.Count() )
398 {
399 SvNumberformat* pEntry = (SvNumberformat*) aFTable.Remove( nKey );
400 aOldTable.Insert( nKey, pEntry );
401 }
402
403 // generate new old builtin formats
404 // reset ActLnge otherwise ChangeIntl() wouldn't switch if already LANGUAGE_SYSTEM
405 ActLnge = LANGUAGE_DONTKNOW;
406 ChangeIntl( LANGUAGE_SYSTEM );
407 ImpGenerateFormats( nCLOffset, sal_True );
408
409 // convert additional and user defined from old system to new system
410 SvNumberformat* pStdFormat = (SvNumberformat*) aFTable.Get( nCLOffset + ZF_STANDARD );
411 sal_uInt32 nLastKey = nMaxBuiltin;
412 pFormatScanner->SetConvertMode( eOldLanguage, LANGUAGE_SYSTEM, sal_True );
413 aOldTable.First();
414 while ( aOldTable.Count() )
415 {
416 nKey = aOldTable.GetCurKey();
417 if ( nLastKey < nKey )
418 nLastKey = nKey;
419 SvNumberformat* pOldEntry = (SvNumberformat*) aOldTable.Remove( nKey );
420 String aString( pOldEntry->GetFormatstring() );
421 xub_StrLen nCheckPos = STRING_NOTFOUND;
422
423 // Same as PutEntry() but assures key position even if format code is
424 // a duplicate. Also won't mix up any LastInsertKey.
425 ChangeIntl( eOldLanguage );
426 LanguageType eLge = eOldLanguage; // ConvertMode changes this
427 sal_Bool bCheck = sal_False;
428 SvNumberformat* pNewEntry = new SvNumberformat( aString, pFormatScanner,
429 pStringScanner, nCheckPos, eLge );
430 if ( nCheckPos != 0 )
431 delete pNewEntry;
432 else
433 {
434 short eCheckType = pNewEntry->GetType();
435 if ( eCheckType != NUMBERFORMAT_UNDEFINED )
436 pNewEntry->SetType( eCheckType | NUMBERFORMAT_DEFINED );
437 else
438 pNewEntry->SetType( NUMBERFORMAT_DEFINED );
439
440 if ( !aFTable.Insert( nKey, pNewEntry ) )
441 delete pNewEntry;
442 else
443 bCheck = sal_True;
444 }
445 DBG_ASSERT( bCheck, "SvNumberFormatter::ReplaceSystemCL: couldn't convert" );
446
447 delete pOldEntry;
448 }
449 pFormatScanner->SetConvertMode(sal_False);
450 pStdFormat->SetLastInsertKey( sal_uInt16(nLastKey - nCLOffset) );
451
452 // append new system additional formats
453 NumberFormatCodeWrapper aNumberFormatCode( xServiceManager, GetLocale() );
454 ImpGenerateAdditionalFormats( nCLOffset, aNumberFormatCode, sal_True );
455 }
456
457
IsTextFormat(sal_uInt32 F_Index) const458 sal_Bool SvNumberFormatter::IsTextFormat(sal_uInt32 F_Index) const
459 {
460 SvNumberformat* pFormat = (SvNumberformat*) aFTable.Get(F_Index);
461 if (!pFormat)
462 return sal_False;
463 else
464 return pFormat->IsTextFormat();
465 }
466
HasTextFormat(sal_uInt32 F_Index) const467 sal_Bool SvNumberFormatter::HasTextFormat(sal_uInt32 F_Index) const
468 {
469 SvNumberformat* pFormat = (SvNumberformat*) aFTable.Get(F_Index);
470 if (!pFormat)
471 return sal_False;
472 else
473 return pFormat->HasTextFormat();
474 }
475
PutEntry(String & rString,xub_StrLen & nCheckPos,short & nType,sal_uInt32 & nKey,LanguageType eLnge)476 sal_Bool SvNumberFormatter::PutEntry(String& rString,
477 xub_StrLen& nCheckPos,
478 short& nType,
479 sal_uInt32& nKey, // Formatnummer
480 LanguageType eLnge)
481 {
482 nKey = 0;
483 if (rString.Len() == 0) // keinen Leerstring
484 {
485 nCheckPos = 1; // -> Fehler
486 return sal_False;
487 }
488 if (eLnge == LANGUAGE_DONTKNOW)
489 eLnge = IniLnge;
490
491 ChangeIntl(eLnge); // ggfs. austauschen
492 LanguageType eLge = eLnge; // Umgehung const fuer ConvertMode
493 sal_Bool bCheck = sal_False;
494 SvNumberformat* p_Entry = new SvNumberformat(rString,
495 pFormatScanner,
496 pStringScanner,
497 nCheckPos,
498 eLge);
499 if (nCheckPos == 0) // Format ok
500 { // Typvergleich:
501 short eCheckType = p_Entry->GetType();
502 if ( eCheckType != NUMBERFORMAT_UNDEFINED)
503 {
504 p_Entry->SetType(eCheckType | NUMBERFORMAT_DEFINED);
505 nType = eCheckType;
506 }
507 else
508 {
509 p_Entry->SetType(NUMBERFORMAT_DEFINED);
510 nType = NUMBERFORMAT_DEFINED;
511 }
512 sal_uInt32 CLOffset = ImpGenerateCL(eLge); // ggfs. neu Standard-
513 // formate anlegen
514 nKey = ImpIsEntry(p_Entry->GetFormatstring(),CLOffset, eLge);
515 if (nKey != NUMBERFORMAT_ENTRY_NOT_FOUND) // schon vorhanden
516 delete p_Entry;
517 else
518 {
519 SvNumberformat* pStdFormat =
520 (SvNumberformat*) aFTable.Get(CLOffset + ZF_STANDARD);
521 sal_uInt32 nPos = CLOffset + pStdFormat->GetLastInsertKey();
522 if (nPos - CLOffset >= SV_COUNTRY_LANGUAGE_OFFSET)
523 {
524 DBG_ERROR("SvNumberFormatter:: Zu viele Formate pro CL");
525 delete p_Entry;
526 }
527 else if (!aFTable.Insert(nPos+1,p_Entry))
528 delete p_Entry;
529 else
530 {
531 bCheck = sal_True;
532 nKey = nPos+1;
533 pStdFormat->SetLastInsertKey((sal_uInt16) (nKey-CLOffset));
534 }
535 }
536 }
537 else
538 delete p_Entry;
539 return bCheck;
540 }
541
PutandConvertEntry(String & rString,xub_StrLen & nCheckPos,short & nType,sal_uInt32 & nKey,LanguageType eLnge,LanguageType eNewLnge)542 sal_Bool SvNumberFormatter::PutandConvertEntry(String& rString,
543 xub_StrLen& nCheckPos,
544 short& nType,
545 sal_uInt32& nKey,
546 LanguageType eLnge,
547 LanguageType eNewLnge)
548 {
549 sal_Bool bRes;
550 if (eNewLnge == LANGUAGE_DONTKNOW)
551 eNewLnge = IniLnge;
552
553 pFormatScanner->SetConvertMode(eLnge, eNewLnge);
554 bRes = PutEntry(rString, nCheckPos, nType, nKey, eLnge);
555 pFormatScanner->SetConvertMode(sal_False);
556 return bRes;
557 }
558
559
PutandConvertEntrySystem(String & rString,xub_StrLen & nCheckPos,short & nType,sal_uInt32 & nKey,LanguageType eLnge,LanguageType eNewLnge)560 sal_Bool SvNumberFormatter::PutandConvertEntrySystem(String& rString,
561 xub_StrLen& nCheckPos,
562 short& nType,
563 sal_uInt32& nKey,
564 LanguageType eLnge,
565 LanguageType eNewLnge)
566 {
567 sal_Bool bRes;
568 if (eNewLnge == LANGUAGE_DONTKNOW)
569 eNewLnge = IniLnge;
570
571 pFormatScanner->SetConvertMode(eLnge, eNewLnge, sal_True);
572 bRes = PutEntry(rString, nCheckPos, nType, nKey, eLnge);
573 pFormatScanner->SetConvertMode(sal_False);
574 return bRes;
575 }
576
577
GetIndexPuttingAndConverting(String & rString,LanguageType eLnge,LanguageType eSysLnge,short & rType,sal_Bool & rNewInserted,xub_StrLen & rCheckPos)578 sal_uInt32 SvNumberFormatter::GetIndexPuttingAndConverting( String & rString,
579 LanguageType eLnge, LanguageType eSysLnge, short & rType,
580 sal_Bool & rNewInserted, xub_StrLen & rCheckPos )
581 {
582 sal_uInt32 nKey = NUMBERFORMAT_ENTRY_NOT_FOUND;
583 rNewInserted = sal_False;
584 rCheckPos = 0;
585
586 // #62389# empty format string (of Writer) => General standard format
587 if (!rString.Len())
588 ; // nothing
589 else if (eLnge == LANGUAGE_SYSTEM && eSysLnge != SvtSysLocale().GetLanguage())
590 {
591 sal_uInt32 nOrig = GetEntryKey( rString, eSysLnge );
592 if (nOrig == NUMBERFORMAT_ENTRY_NOT_FOUND)
593 nKey = nOrig; // none available, maybe user-defined
594 else
595 nKey = GetFormatForLanguageIfBuiltIn( nOrig, SvtSysLocale().GetLanguage() );
596
597 if (nKey == nOrig)
598 {
599 // Not a builtin format, convert.
600 // The format code string may get modified and adapted to the real
601 // language and wouldn't match eSysLnge anymore, do that on a copy.
602 String aTmp( rString);
603 rNewInserted = PutandConvertEntrySystem( aTmp, rCheckPos, rType,
604 nKey, eLnge, SvtSysLocale().GetLanguage());
605 if (rCheckPos > 0)
606 {
607 DBG_ERRORFILE("SvNumberFormatter::GetIndexPuttingAndConverting: bad format code string for current locale");
608 nKey = NUMBERFORMAT_ENTRY_NOT_FOUND;
609 }
610 }
611 }
612 else
613 {
614 nKey = GetEntryKey( rString, eLnge);
615 if (nKey == NUMBERFORMAT_ENTRY_NOT_FOUND)
616 {
617 rNewInserted = PutEntry( rString, rCheckPos, rType, nKey, eLnge);
618 if (rCheckPos > 0)
619 {
620 DBG_ERRORFILE("SvNumberFormatter::GetIndexPuttingAndConverting: bad format code string for specified locale");
621 nKey = NUMBERFORMAT_ENTRY_NOT_FOUND;
622 }
623 }
624 }
625 if (nKey == NUMBERFORMAT_ENTRY_NOT_FOUND)
626 nKey = GetStandardIndex( eLnge);
627 rType = GetType( nKey);
628 // Convert any (!) old "automatic" currency format to new fixed currency
629 // default format.
630 if ((rType & NUMBERFORMAT_CURRENCY) != 0)
631 {
632 const SvNumberformat* pFormat = GetEntry( nKey);
633 if (!pFormat->HasNewCurrency())
634 {
635 if (rNewInserted)
636 {
637 DeleteEntry( nKey); // don't leave trails of rubbish
638 rNewInserted = sal_False;
639 }
640 nKey = GetStandardFormat( NUMBERFORMAT_CURRENCY, eLnge);
641 }
642 }
643 return nKey;
644 }
645
646
DeleteEntry(sal_uInt32 nKey)647 void SvNumberFormatter::DeleteEntry(sal_uInt32 nKey)
648 {
649 SvNumberformat* pEntry = aFTable.Remove(nKey);
650 delete pEntry;
651 }
652
PrepareSave()653 void SvNumberFormatter::PrepareSave()
654 {
655 SvNumberformat* pFormat = aFTable.First();
656 while (pFormat)
657 {
658 pFormat->SetUsed(sal_False);
659 pFormat = aFTable.Next();
660 }
661 }
662
SetFormatUsed(sal_uInt32 nFIndex)663 void SvNumberFormatter::SetFormatUsed(sal_uInt32 nFIndex)
664 {
665 SvNumberformat* pFormat = (SvNumberformat*) aFTable.Get(nFIndex);
666 if (pFormat)
667 pFormat->SetUsed(sal_True);
668 }
669
Load(SvStream & rStream)670 sal_Bool SvNumberFormatter::Load( SvStream& rStream )
671 {
672 LanguageType eSysLang = SvtSysLocale().GetLanguage();
673 SvNumberFormatter* pConverter = NULL;
674
675 ImpSvNumMultipleReadHeader aHdr( rStream );
676 sal_uInt16 nVersion;
677 rStream >> nVersion;
678 SvNumberformat* pEntry;
679 sal_uInt32 nPos;
680 LanguageType eSaveSysLang, eLoadSysLang;
681 sal_uInt16 nSysOnStore, eLge, eDummy; // Dummy fuer kompatibles Format
682 rStream >> nSysOnStore >> eLge; // Systemeinstellung aus
683 // Dokument
684 eSaveSysLang = (nVersion < SV_NUMBERFORMATTER_VERSION_SYSTORE ?
685 LANGUAGE_SYSTEM : (LanguageType) nSysOnStore);
686 LanguageType eLnge = (LanguageType) eLge;
687 ImpChangeSysCL( eLnge, sal_True );
688
689 rStream >> nPos;
690 while (nPos != NUMBERFORMAT_ENTRY_NOT_FOUND)
691 {
692 rStream >> eDummy >> eLge;
693 eLnge = (LanguageType) eLge;
694 ImpGenerateCL( eLnge, sal_True ); // ggfs. neue Standardformate anlegen
695
696 sal_uInt32 nOffset = nPos % SV_COUNTRY_LANGUAGE_OFFSET; // relativIndex
697 sal_Bool bUserDefined = (nOffset > SV_MAX_ANZ_STANDARD_FORMATE);
698 //! HACK! ER 29.07.97 15:15
699 // SaveLang wurde bei SYSTEM nicht gespeichert sondern war auch SYSTEM,
700 // erst ab 364i Unterscheidung möglich
701 sal_Bool bConversionHack;
702 if ( eLnge == LANGUAGE_SYSTEM )
703 {
704 if ( nVersion < SV_NUMBERFORMATTER_VERSION_SYSTORE )
705 {
706 bConversionHack = bUserDefined;
707 eLoadSysLang = eSaveSysLang;
708 }
709 else
710 {
711 bConversionHack = sal_False;
712 eLoadSysLang = eSysLang;
713 }
714 }
715 else
716 {
717 bConversionHack = sal_False;
718 eLoadSysLang = eSaveSysLang;
719 }
720
721 pEntry = new SvNumberformat(*pFormatScanner, eLnge);
722 if ( bConversionHack )
723 { // SYSTEM
724 // nVersion < SV_NUMBERFORMATTER_VERSION_SYSTORE
725 // nVersion < SV_NUMBERFORMATTER_VERSION_KEYWORDS
726 if ( !pConverter )
727 pConverter = new SvNumberFormatter( xServiceManager, eSysLang );
728 NfHackConversion eHackConversion = pEntry->Load(
729 rStream, aHdr, pConverter, *pStringScanner );
730 switch ( eHackConversion )
731 {
732 case NF_CONVERT_GERMAN_ENGLISH :
733 pEntry->ConvertLanguage( *pConverter,
734 LANGUAGE_ENGLISH_US, eSysLang, sal_True );
735 break;
736 case NF_CONVERT_ENGLISH_GERMAN :
737 switch ( eSysLang )
738 {
739 case LANGUAGE_GERMAN:
740 case LANGUAGE_GERMAN_SWISS:
741 case LANGUAGE_GERMAN_AUSTRIAN:
742 case LANGUAGE_GERMAN_LUXEMBOURG:
743 case LANGUAGE_GERMAN_LIECHTENSTEIN:
744 // alles beim alten
745 break;
746 default:
747 pEntry->ConvertLanguage( *pConverter,
748 LANGUAGE_GERMAN, eSysLang, sal_True );
749 }
750 break;
751 case NF_CONVERT_NONE :
752 break; // -Wall not handled.
753 }
754
755 }
756 else
757 {
758 pEntry->Load( rStream, aHdr, NULL, *pStringScanner );
759 if ( !bUserDefined )
760 bUserDefined = (pEntry->GetNewStandardDefined() > SV_NUMBERFORMATTER_VERSION);
761 if ( bUserDefined )
762 {
763 if ( eSaveSysLang != eLoadSysLang )
764 { // SYSTEM verschieden
765 if ( !pConverter )
766 pConverter = new SvNumberFormatter( xServiceManager, eSysLang );
767 if ( nVersion < SV_NUMBERFORMATTER_VERSION_KEYWORDS )
768 {
769 switch ( eSaveSysLang )
770 {
771 case LANGUAGE_GERMAN:
772 case LANGUAGE_GERMAN_SWISS:
773 case LANGUAGE_GERMAN_AUSTRIAN:
774 case LANGUAGE_GERMAN_LUXEMBOURG:
775 case LANGUAGE_GERMAN_LIECHTENSTEIN:
776 // alles beim alten
777 pEntry->ConvertLanguage( *pConverter,
778 eSaveSysLang, eLoadSysLang, sal_True );
779 break;
780 default:
781 // alte english nach neuem anderen
782 pEntry->ConvertLanguage( *pConverter,
783 LANGUAGE_ENGLISH_US, eLoadSysLang, sal_True );
784 }
785 }
786 else
787 pEntry->ConvertLanguage( *pConverter,
788 eSaveSysLang, eLoadSysLang, sal_True );
789 }
790 else
791 { // nicht SYSTEM oder gleiches SYSTEM
792 if ( nVersion < SV_NUMBERFORMATTER_VERSION_KEYWORDS )
793 {
794 LanguageType eLoadLang;
795 sal_Bool bSystem;
796 if ( eLnge == LANGUAGE_SYSTEM )
797 {
798 eLoadLang = eSysLang;
799 bSystem = sal_True;
800 }
801 else
802 {
803 eLoadLang = eLnge;
804 bSystem = sal_False;
805 }
806 switch ( eLoadLang )
807 {
808 case LANGUAGE_GERMAN:
809 case LANGUAGE_GERMAN_SWISS:
810 case LANGUAGE_GERMAN_AUSTRIAN:
811 case LANGUAGE_GERMAN_LUXEMBOURG:
812 case LANGUAGE_GERMAN_LIECHTENSTEIN:
813 // alles beim alten
814 break;
815 default:
816 // alte english nach neuem anderen
817 if ( !pConverter )
818 pConverter = new SvNumberFormatter( xServiceManager, eSysLang );
819 pEntry->ConvertLanguage( *pConverter,
820 LANGUAGE_ENGLISH_US, eLoadLang, bSystem );
821 }
822 }
823 }
824 }
825 }
826 if ( nOffset == 0 ) // StandardFormat
827 {
828 SvNumberformat* pEnt = aFTable.Get(nPos);
829 if (pEnt)
830 pEnt->SetLastInsertKey(pEntry->GetLastInsertKey());
831 }
832 if (!aFTable.Insert(nPos, pEntry))
833 delete pEntry;
834 rStream >> nPos;
835 }
836
837 // ab SV_NUMBERFORMATTER_VERSION_YEAR2000
838 if ( nVersion >= SV_NUMBERFORMATTER_VERSION_YEAR2000 )
839 {
840 aHdr.StartEntry();
841 if ( aHdr.BytesLeft() >= sizeof(sal_uInt16) )
842 {
843 sal_uInt16 nY2k;
844 rStream >> nY2k;
845 if ( nVersion < SV_NUMBERFORMATTER_VERSION_TWODIGITYEAR && nY2k < 100 )
846 nY2k += 1901; // war vor src513e: 29, jetzt: 1930
847 SetYear2000( nY2k );
848 }
849 aHdr.EndEntry();
850 }
851
852 if ( pConverter )
853 delete pConverter;
854
855 // generate additional i18n standard formats for all used locales
856 LanguageType eOldLanguage = ActLnge;
857 NumberFormatCodeWrapper aNumberFormatCode( xServiceManager, GetLocale() );
858 SvUShorts aList;
859 GetUsedLanguages( aList );
860 sal_uInt16 nCount = aList.Count();
861 for ( sal_uInt16 j=0; j<nCount; j++ )
862 {
863 LanguageType eLang = aList[j];
864 ChangeIntl( eLang );
865 sal_uInt32 CLOffset = ImpGetCLOffset( eLang );
866 ImpGenerateAdditionalFormats( CLOffset, aNumberFormatCode, sal_True );
867 }
868 ChangeIntl( eOldLanguage );
869
870 if (rStream.GetError())
871 return sal_False;
872 else
873 return sal_True;
874 }
875
Save(SvStream & rStream) const876 sal_Bool SvNumberFormatter::Save( SvStream& rStream ) const
877 {
878 ImpSvNumMultipleWriteHeader aHdr( rStream );
879 // ab 364i wird gespeichert was SYSTEM wirklich war, vorher hart LANGUAGE_SYSTEM
880 rStream << (sal_uInt16) SV_NUMBERFORMATTER_VERSION;
881 rStream << (sal_uInt16) SvtSysLocale().GetLanguage() << (sal_uInt16) IniLnge;
882 SvNumberFormatTable* pTable = (SvNumberFormatTable*) &aFTable;
883 SvNumberformat* pEntry = (SvNumberformat*) pTable->First();
884 while (pEntry)
885 {
886 // Gespeichert werden alle markierten, benutzerdefinierten Formate und
887 // jeweils das Standardformat zu allen angewaehlten CL-Kombinationen
888 // sowie NewStandardDefined
889 if ( pEntry->GetUsed() || (pEntry->GetType() & NUMBERFORMAT_DEFINED) ||
890 pEntry->GetNewStandardDefined() ||
891 (pTable->GetCurKey() % SV_COUNTRY_LANGUAGE_OFFSET == 0) )
892 {
893 rStream << static_cast<sal_uInt32>(pTable->GetCurKey())
894 << (sal_uInt16) LANGUAGE_SYSTEM
895 << (sal_uInt16) pEntry->GetLanguage();
896 pEntry->Save(rStream, aHdr);
897 }
898 pEntry = (SvNumberformat*) pTable->Next();
899 }
900 rStream << NUMBERFORMAT_ENTRY_NOT_FOUND; // EndeKennung
901
902 // ab SV_NUMBERFORMATTER_VERSION_YEAR2000
903 aHdr.StartEntry();
904 rStream << (sal_uInt16) GetYear2000();
905 aHdr.EndEntry();
906
907 if (rStream.GetError())
908 return sal_False;
909 else
910 return sal_True;
911 }
912
913 // static
SkipNumberFormatterInStream(SvStream & rStream)914 void SvNumberFormatter::SkipNumberFormatterInStream( SvStream& rStream )
915 {
916 ImpSvNumMultipleReadHeader::Skip( rStream );
917 }
918
GetUsedLanguages(SvUShorts & rList)919 void SvNumberFormatter::GetUsedLanguages( SvUShorts& rList )
920 {
921 rList.Remove( 0, rList.Count() );
922
923 sal_uInt32 nOffset = 0;
924 while (nOffset <= MaxCLOffset)
925 {
926 SvNumberformat* pFormat = (SvNumberformat*) aFTable.Get(nOffset);
927 if (pFormat)
928 rList.Insert( pFormat->GetLanguage(), rList.Count() );
929 nOffset += SV_COUNTRY_LANGUAGE_OFFSET;
930 }
931 }
932
933
FillKeywordTable(NfKeywordTable & rKeywords,LanguageType eLang)934 void SvNumberFormatter::FillKeywordTable( NfKeywordTable& rKeywords,
935 LanguageType eLang )
936 {
937 ChangeIntl( eLang );
938 const NfKeywordTable & rTable = pFormatScanner->GetKeywords();
939 for ( sal_uInt16 i = 0; i < NF_KEYWORD_ENTRIES_COUNT; ++i )
940 {
941 rKeywords[i] = rTable[i];
942 }
943 }
944
945
GetKeyword(LanguageType eLnge,sal_uInt16 nIndex)946 String SvNumberFormatter::GetKeyword( LanguageType eLnge, sal_uInt16 nIndex )
947 {
948 ChangeIntl(eLnge);
949 const NfKeywordTable & rTable = pFormatScanner->GetKeywords();
950 if ( nIndex < NF_KEYWORD_ENTRIES_COUNT )
951 return rTable[nIndex];
952
953 DBG_ERROR("GetKeyword: invalid index");
954 return String();
955 }
956
957
GetStandardName(LanguageType eLnge)958 String SvNumberFormatter::GetStandardName( LanguageType eLnge )
959 {
960 ChangeIntl( eLnge );
961 return pFormatScanner->GetStandardName();
962 }
963
964
ImpGetCLOffset(LanguageType eLnge) const965 sal_uInt32 SvNumberFormatter::ImpGetCLOffset(LanguageType eLnge) const
966 {
967 SvNumberformat* pFormat;
968 sal_uInt32 nOffset = 0;
969 while (nOffset <= MaxCLOffset)
970 {
971 pFormat = (SvNumberformat*) aFTable.Get(nOffset);
972 if (pFormat && pFormat->GetLanguage() == eLnge)
973 return nOffset;
974 nOffset += SV_COUNTRY_LANGUAGE_OFFSET;
975 }
976 return nOffset;
977 }
978
ImpIsEntry(const String & rString,sal_uInt32 nCLOffset,LanguageType eLnge)979 sal_uInt32 SvNumberFormatter::ImpIsEntry(const String& rString,
980 sal_uInt32 nCLOffset,
981 LanguageType eLnge)
982 {
983 #ifndef NF_COMMENT_IN_FORMATSTRING
984 #error NF_COMMENT_IN_FORMATSTRING not defined (zformat.hxx)
985 #endif
986 #if NF_COMMENT_IN_FORMATSTRING
987 String aStr( rString );
988 SvNumberformat::EraseComment( aStr );
989 #endif
990 sal_uInt32 res = NUMBERFORMAT_ENTRY_NOT_FOUND;
991 SvNumberformat* pEntry;
992 pEntry = (SvNumberformat*) aFTable.Seek(nCLOffset);
993 while ( res == NUMBERFORMAT_ENTRY_NOT_FOUND &&
994 pEntry && pEntry->GetLanguage() == eLnge )
995 {
996 #if NF_COMMENT_IN_FORMATSTRING
997 if ( pEntry->GetComment().Len() )
998 {
999 String aFormat( pEntry->GetFormatstring() );
1000 SvNumberformat::EraseComment( aFormat );
1001 if ( aStr == aFormat )
1002 res = aFTable.GetCurKey();
1003 else
1004 pEntry = (SvNumberformat*) aFTable.Next();
1005 }
1006 else
1007 {
1008 if ( aStr == pEntry->GetFormatstring() )
1009 res = aFTable.GetCurKey();
1010 else
1011 pEntry = (SvNumberformat*) aFTable.Next();
1012 }
1013 #else
1014 if ( rString == pEntry->GetFormatstring() )
1015 res = aFTable.GetCurKey();
1016 else
1017 pEntry = (SvNumberformat*) aFTable.Next();
1018 #endif
1019 }
1020 return res;
1021 }
1022
1023
GetFirstEntryTable(short & eType,sal_uInt32 & FIndex,LanguageType & rLnge)1024 SvNumberFormatTable& SvNumberFormatter::GetFirstEntryTable(
1025 short& eType,
1026 sal_uInt32& FIndex,
1027 LanguageType& rLnge)
1028 {
1029 short eTypetmp = eType;
1030 if (eType == NUMBERFORMAT_ALL) // Leere Zelle oder don't care
1031 rLnge = IniLnge;
1032 else
1033 {
1034 SvNumberformat* pFormat = (SvNumberformat*) aFTable.Get(FIndex);
1035 if (!pFormat)
1036 {
1037 // DBG_ERROR("SvNumberFormatter:: Unbekanntes altes Zahlformat (1)");
1038 rLnge = IniLnge;
1039 eType = NUMBERFORMAT_ALL;
1040 eTypetmp = eType;
1041 }
1042 else
1043 {
1044 rLnge = pFormat->GetLanguage();
1045 eType = pFormat->GetType()&~NUMBERFORMAT_DEFINED;
1046 if (eType == 0)
1047 {
1048 eType = NUMBERFORMAT_DEFINED;
1049 eTypetmp = eType;
1050 }
1051 else if (eType == NUMBERFORMAT_DATETIME)
1052 {
1053 eTypetmp = eType;
1054 eType = NUMBERFORMAT_DATE;
1055 }
1056 else
1057 eTypetmp = eType;
1058 }
1059 }
1060 ChangeIntl(rLnge);
1061 return GetEntryTable(eTypetmp, FIndex, rLnge);
1062 }
1063
ImpGenerateCL(LanguageType eLnge,sal_Bool bLoadingSO5)1064 sal_uInt32 SvNumberFormatter::ImpGenerateCL( LanguageType eLnge, sal_Bool bLoadingSO5 )
1065 {
1066 ChangeIntl(eLnge);
1067 sal_uInt32 CLOffset = ImpGetCLOffset(ActLnge);
1068 if (CLOffset > MaxCLOffset)
1069 { // new CL combination
1070 if (LocaleDataWrapper::areChecksEnabled())
1071 {
1072 Locale aLoadedLocale = xLocaleData->getLoadedLocale();
1073 if ( aLoadedLocale.Language != aLocale.Language ||
1074 aLoadedLocale.Country != aLocale.Country )
1075 {
1076 String aMsg( RTL_CONSTASCII_USTRINGPARAM(
1077 "SvNumerFormatter::ImpGenerateCL: locales don't match:"));
1078 LocaleDataWrapper::outputCheckMessage(
1079 xLocaleData->appendLocaleInfo( aMsg ));
1080 }
1081 // test XML locale data FormatElement entries
1082 {
1083 uno::Sequence< i18n::FormatElement > xSeq =
1084 xLocaleData->getAllFormats();
1085 // A test for completeness of formatindex="0" ...
1086 // formatindex="47" is not needed here since it is done in
1087 // ImpGenerateFormats().
1088
1089 // Test for dupes of formatindex="..."
1090 for ( sal_Int32 j = 0; j < xSeq.getLength(); j++ )
1091 {
1092 sal_Int16 nIdx = xSeq[j].formatIndex;
1093 String aDupes;
1094 for ( sal_Int32 i = 0; i < xSeq.getLength(); i++ )
1095 {
1096 if ( i != j && xSeq[i].formatIndex == nIdx )
1097 {
1098 aDupes += String::CreateFromInt32( i );
1099 aDupes += '(';
1100 aDupes += String( xSeq[i].formatKey );
1101 aDupes += ')';
1102 aDupes += ' ';
1103 }
1104 }
1105 if ( aDupes.Len() )
1106 {
1107 String aMsg( RTL_CONSTASCII_USTRINGPARAM(
1108 "XML locale data FormatElement formatindex dupe: "));
1109 aMsg += String::CreateFromInt32( nIdx );
1110 aMsg.AppendAscii( RTL_CONSTASCII_STRINGPARAM(
1111 "\nFormatElements: "));
1112 aMsg += String::CreateFromInt32( j );
1113 aMsg += '(';
1114 aMsg += String( xSeq[j].formatKey );
1115 aMsg += ')';
1116 aMsg += ' ';
1117 aMsg += aDupes;
1118 LocaleDataWrapper::outputCheckMessage(
1119 xLocaleData->appendLocaleInfo( aMsg ));
1120 }
1121 }
1122 }
1123 }
1124
1125 MaxCLOffset += SV_COUNTRY_LANGUAGE_OFFSET;
1126 ImpGenerateFormats( MaxCLOffset, bLoadingSO5 );
1127 CLOffset = MaxCLOffset;
1128 }
1129 return CLOffset;
1130 }
1131
ChangeCL(short eType,sal_uInt32 & FIndex,LanguageType eLnge)1132 SvNumberFormatTable& SvNumberFormatter::ChangeCL(short eType,
1133 sal_uInt32& FIndex,
1134 LanguageType eLnge)
1135 {
1136 ImpGenerateCL(eLnge);
1137 return GetEntryTable(eType, FIndex, ActLnge);
1138 }
1139
GetEntryTable(short eType,sal_uInt32 & FIndex,LanguageType eLnge)1140 SvNumberFormatTable& SvNumberFormatter::GetEntryTable(
1141 short eType,
1142 sal_uInt32& FIndex,
1143 LanguageType eLnge)
1144 {
1145 if ( pFormatTable )
1146 pFormatTable->Clear();
1147 else
1148 pFormatTable = new SvNumberFormatTable;
1149 ChangeIntl(eLnge);
1150 sal_uInt32 CLOffset = ImpGetCLOffset(ActLnge);
1151
1152 // Might generate and insert a default format for the given type
1153 // (e.g. currency) => has to be done before collecting formats.
1154 sal_uInt32 nDefaultIndex = GetStandardFormat( eType, ActLnge );
1155
1156 SvNumberformat* pEntry;
1157 pEntry = (SvNumberformat*) aFTable.Seek(CLOffset);
1158
1159 if (eType == NUMBERFORMAT_ALL)
1160 {
1161 while (pEntry && pEntry->GetLanguage() == ActLnge)
1162 { // copy all entries to output table
1163 pFormatTable->Insert( aFTable.GetCurKey(), pEntry );
1164 pEntry = (SvNumberformat*) aFTable.Next();
1165 }
1166 }
1167 else
1168 {
1169 while (pEntry && pEntry->GetLanguage() == ActLnge)
1170 { // copy entries of queried type to output table
1171 if ((pEntry->GetType()) & eType)
1172 pFormatTable->Insert(aFTable.GetCurKey(),pEntry);
1173 pEntry = (SvNumberformat*) aFTable.Next();
1174 }
1175 }
1176 if ( pFormatTable->Count() > 0 )
1177 { // select default if queried format doesn't exist or queried type or
1178 // language differ from existing format
1179 pEntry = aFTable.Get(FIndex);
1180 if ( !pEntry || !(pEntry->GetType() & eType) || pEntry->GetLanguage() != ActLnge )
1181 FIndex = nDefaultIndex;
1182 }
1183 return *pFormatTable;
1184 }
1185
IsNumberFormat(const String & sString,sal_uInt32 & F_Index,double & fOutNumber)1186 sal_Bool SvNumberFormatter::IsNumberFormat(const String& sString,
1187 sal_uInt32& F_Index,
1188 double& fOutNumber)
1189 {
1190 short FType;
1191 const SvNumberformat* pFormat = (SvNumberformat*) aFTable.Get(F_Index);
1192 if (!pFormat)
1193 {
1194 // DBG_ERROR("SvNumberFormatter:: Unbekanntes altes Zahlformat (2)");
1195 ChangeIntl(IniLnge);
1196 FType = NUMBERFORMAT_NUMBER;
1197 }
1198 else
1199 {
1200 FType = pFormat->GetType() &~NUMBERFORMAT_DEFINED;
1201 if (FType == 0)
1202 FType = NUMBERFORMAT_DEFINED;
1203 ChangeIntl(pFormat->GetLanguage());
1204 }
1205 sal_Bool res;
1206 short RType = FType;
1207 // Ergebnistyp
1208 // ohne def-Kennung
1209 if (RType == NUMBERFORMAT_TEXT) // Zahlzelle ->Stringz.
1210 res = sal_False;
1211 else
1212 res = pStringScanner->IsNumberFormat(sString, RType, fOutNumber, pFormat);
1213
1214 if (res && !IsCompatible(FType, RType)) // unpassender Typ
1215 {
1216 switch ( RType )
1217 {
1218 case NUMBERFORMAT_TIME :
1219 {
1220 if ( pStringScanner->GetDecPos() )
1221 { // 100stel Sekunden
1222 if ( pStringScanner->GetAnzNums() > 3 || fOutNumber < 0.0 )
1223 F_Index = GetFormatIndex( NF_TIME_HH_MMSS00, ActLnge );
1224 else
1225 F_Index = GetFormatIndex( NF_TIME_MMSS00, ActLnge );
1226 }
1227 else if ( fOutNumber >= 1.0 || fOutNumber < 0.0 )
1228 F_Index = GetFormatIndex( NF_TIME_HH_MMSS, ActLnge );
1229 else
1230 F_Index = GetStandardFormat( RType, ActLnge );
1231 }
1232 break;
1233 default:
1234 F_Index = GetStandardFormat( RType, ActLnge );
1235 }
1236 }
1237 return res;
1238 }
1239
IsCompatible(short eOldType,short eNewType)1240 sal_Bool SvNumberFormatter::IsCompatible(short eOldType,
1241 short eNewType)
1242 {
1243 if (eOldType == eNewType)
1244 return sal_True;
1245 else if (eOldType == NUMBERFORMAT_DEFINED)
1246 return sal_True;
1247 else
1248 {
1249 switch (eNewType)
1250 {
1251 case NUMBERFORMAT_NUMBER:
1252 {
1253 switch (eOldType)
1254 {
1255 case NUMBERFORMAT_PERCENT:
1256 case NUMBERFORMAT_CURRENCY:
1257 case NUMBERFORMAT_SCIENTIFIC:
1258 case NUMBERFORMAT_FRACTION:
1259 // case NUMBERFORMAT_LOGICAL:
1260 case NUMBERFORMAT_DEFINED:
1261 return sal_True;
1262 default:
1263 return sal_False;
1264 }
1265 }
1266 break;
1267 case NUMBERFORMAT_DATE:
1268 {
1269 switch (eOldType)
1270 {
1271 case NUMBERFORMAT_DATETIME:
1272 return sal_True;
1273 default:
1274 return sal_False;
1275 }
1276 }
1277 break;
1278 case NUMBERFORMAT_TIME:
1279 {
1280 switch (eOldType)
1281 {
1282 case NUMBERFORMAT_DATETIME:
1283 return sal_True;
1284 default:
1285 return sal_False;
1286 }
1287 }
1288 break;
1289 case NUMBERFORMAT_DATETIME:
1290 {
1291 switch (eOldType)
1292 {
1293 case NUMBERFORMAT_TIME:
1294 case NUMBERFORMAT_DATE:
1295 return sal_True;
1296 default:
1297 return sal_False;
1298 }
1299 }
1300 break;
1301 default:
1302 return sal_False;
1303 }
1304 return sal_False;
1305 }
1306 }
1307
1308
ImpGetDefaultFormat(short nType)1309 sal_uInt32 SvNumberFormatter::ImpGetDefaultFormat( short nType )
1310 {
1311 sal_uInt32 CLOffset = ImpGetCLOffset( ActLnge );
1312 sal_uInt32 nSearch;
1313 switch( nType )
1314 {
1315 case NUMBERFORMAT_DATE :
1316 nSearch = CLOffset + ZF_STANDARD_DATE;
1317 break;
1318 case NUMBERFORMAT_TIME :
1319 nSearch = CLOffset + ZF_STANDARD_TIME;
1320 break;
1321 case NUMBERFORMAT_DATETIME :
1322 nSearch = CLOffset + ZF_STANDARD_DATETIME;
1323 break;
1324 case NUMBERFORMAT_PERCENT :
1325 nSearch = CLOffset + ZF_STANDARD_PERCENT;
1326 break;
1327 case NUMBERFORMAT_SCIENTIFIC:
1328 nSearch = CLOffset + ZF_STANDARD_SCIENTIFIC;
1329 break;
1330 default:
1331 nSearch = CLOffset + ZF_STANDARD;
1332 }
1333 sal_uInt32 nDefaultFormat = (sal_uInt32)(sal_uLong) aDefaultFormatKeys.Get( nSearch );
1334 if ( !nDefaultFormat )
1335 nDefaultFormat = NUMBERFORMAT_ENTRY_NOT_FOUND;
1336 if ( nDefaultFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
1337 { // look for a defined standard
1338 sal_uInt32 nStopKey = CLOffset + SV_COUNTRY_LANGUAGE_OFFSET;
1339 sal_uInt32 nKey;
1340 aFTable.Seek( CLOffset );
1341 while ( (nKey = aFTable.GetCurKey()) >= CLOffset && nKey < nStopKey )
1342 {
1343 const SvNumberformat* pEntry =
1344 (const SvNumberformat*) aFTable.GetCurObject();
1345 if ( pEntry->IsStandard() && ((pEntry->GetType() &
1346 ~NUMBERFORMAT_DEFINED) == nType) )
1347 {
1348 nDefaultFormat = nKey;
1349 break; // while
1350 }
1351 aFTable.Next();
1352 }
1353
1354 if ( nDefaultFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
1355 { // none found, use old fixed standards
1356 switch( nType )
1357 {
1358 case NUMBERFORMAT_DATE :
1359 nDefaultFormat = CLOffset + ZF_STANDARD_DATE;
1360 break;
1361 case NUMBERFORMAT_TIME :
1362 nDefaultFormat = CLOffset + ZF_STANDARD_TIME+1;
1363 break;
1364 case NUMBERFORMAT_DATETIME :
1365 nDefaultFormat = CLOffset + ZF_STANDARD_DATETIME;
1366 break;
1367 case NUMBERFORMAT_PERCENT :
1368 nDefaultFormat = CLOffset + ZF_STANDARD_PERCENT+1;
1369 break;
1370 case NUMBERFORMAT_SCIENTIFIC:
1371 nDefaultFormat = CLOffset + ZF_STANDARD_SCIENTIFIC;
1372 break;
1373 default:
1374 nDefaultFormat = CLOffset + ZF_STANDARD;
1375 }
1376 }
1377 aDefaultFormatKeys.Insert( nSearch, (void*) nDefaultFormat );
1378 }
1379 return nDefaultFormat;
1380 }
1381
1382
GetStandardFormat(short eType,LanguageType eLnge)1383 sal_uInt32 SvNumberFormatter::GetStandardFormat( short eType, LanguageType eLnge )
1384 {
1385 sal_uInt32 CLOffset = ImpGenerateCL(eLnge);
1386 switch(eType)
1387 {
1388 case NUMBERFORMAT_CURRENCY :
1389 {
1390 if ( eLnge == LANGUAGE_SYSTEM )
1391 return ImpGetDefaultSystemCurrencyFormat();
1392 else
1393 return ImpGetDefaultCurrencyFormat();
1394 }
1395 case NUMBERFORMAT_DATE :
1396 case NUMBERFORMAT_TIME :
1397 case NUMBERFORMAT_DATETIME :
1398 case NUMBERFORMAT_PERCENT :
1399 case NUMBERFORMAT_SCIENTIFIC:
1400 return ImpGetDefaultFormat( eType );
1401
1402 case NUMBERFORMAT_FRACTION : return CLOffset + ZF_STANDARD_FRACTION;
1403 case NUMBERFORMAT_LOGICAL : return CLOffset + ZF_STANDARD_LOGICAL;
1404 case NUMBERFORMAT_TEXT : return CLOffset + ZF_STANDARD_TEXT;
1405 case NUMBERFORMAT_ALL :
1406 case NUMBERFORMAT_DEFINED :
1407 case NUMBERFORMAT_NUMBER :
1408 case NUMBERFORMAT_UNDEFINED :
1409 default : return CLOffset + ZF_STANDARD;
1410 }
1411 }
1412
IsSpecialStandardFormat(sal_uInt32 nFIndex,LanguageType eLnge)1413 sal_Bool SvNumberFormatter::IsSpecialStandardFormat( sal_uInt32 nFIndex,
1414 LanguageType eLnge )
1415 {
1416 return
1417 nFIndex == GetFormatIndex( NF_TIME_MMSS00, eLnge ) ||
1418 nFIndex == GetFormatIndex( NF_TIME_HH_MMSS00, eLnge ) ||
1419 nFIndex == GetFormatIndex( NF_TIME_HH_MMSS, eLnge )
1420 ;
1421 }
1422
GetStandardFormat(sal_uInt32 nFIndex,short eType,LanguageType eLnge)1423 sal_uInt32 SvNumberFormatter::GetStandardFormat( sal_uInt32 nFIndex, short eType,
1424 LanguageType eLnge )
1425 {
1426 if ( IsSpecialStandardFormat( nFIndex, eLnge ) )
1427 return nFIndex;
1428 else
1429 return GetStandardFormat( eType, eLnge );
1430 }
1431
GetStandardFormat(double fNumber,sal_uInt32 nFIndex,short eType,LanguageType eLnge)1432 sal_uInt32 SvNumberFormatter::GetStandardFormat( double fNumber, sal_uInt32 nFIndex,
1433 short eType, LanguageType eLnge )
1434 {
1435 if ( IsSpecialStandardFormat( nFIndex, eLnge ) )
1436 return nFIndex;
1437
1438 switch( eType )
1439 {
1440 case NUMBERFORMAT_TIME :
1441 {
1442 sal_Bool bSign;
1443 if ( fNumber < 0.0 )
1444 {
1445 bSign = sal_True;
1446 fNumber = -fNumber;
1447 }
1448 else
1449 bSign = sal_False;
1450 double fSeconds = fNumber * 86400;
1451 if ( floor( fSeconds + 0.5 ) * 100 != floor( fSeconds * 100 + 0.5 ) )
1452 { // mit 100stel Sekunden
1453 if ( bSign || fSeconds >= 3600 )
1454 return GetFormatIndex( NF_TIME_HH_MMSS00, eLnge );
1455 else
1456 return GetFormatIndex( NF_TIME_MMSS00, eLnge );
1457 }
1458 else
1459 {
1460 if ( bSign || fNumber >= 1.0 )
1461 return GetFormatIndex( NF_TIME_HH_MMSS, eLnge );
1462 else
1463 return GetStandardFormat( eType, eLnge );
1464 }
1465 }
1466 default:
1467 return GetStandardFormat( eType, eLnge );
1468 }
1469 }
1470
GetInputLineString(const double & fOutNumber,sal_uInt32 nFIndex,String & sOutString)1471 void SvNumberFormatter::GetInputLineString(const double& fOutNumber,
1472 sal_uInt32 nFIndex,
1473 String& sOutString)
1474 {
1475 SvNumberformat* pFormat;
1476 Color* pColor;
1477 pFormat = (SvNumberformat*) aFTable.Get(nFIndex);
1478 if (!pFormat)
1479 pFormat = aFTable.Get(ZF_STANDARD);
1480 LanguageType eLang = pFormat->GetLanguage();
1481 ChangeIntl( eLang );
1482 short eType = pFormat->GetType() & ~NUMBERFORMAT_DEFINED;
1483 if (eType == 0)
1484 eType = NUMBERFORMAT_DEFINED;
1485 sal_uInt16 nOldPrec = pFormatScanner->GetStandardPrec();
1486 bool bPrecChanged = false;
1487 if (eType == NUMBERFORMAT_NUMBER || eType == NUMBERFORMAT_PERCENT
1488 || eType == NUMBERFORMAT_CURRENCY
1489 || eType == NUMBERFORMAT_SCIENTIFIC
1490 || eType == NUMBERFORMAT_FRACTION)
1491 {
1492 if (eType != NUMBERFORMAT_PERCENT) // später Sonderbehandlung %
1493 eType = NUMBERFORMAT_NUMBER;
1494 ChangeStandardPrec(INPUTSTRING_PRECISION);
1495 bPrecChanged = true;
1496 }
1497 sal_uInt32 nKey = nFIndex;
1498 switch ( eType )
1499 { // #61619# immer vierstelliges Jahr editieren
1500 case NUMBERFORMAT_DATE :
1501 nKey = GetFormatIndex( NF_DATE_SYS_DDMMYYYY, eLang );
1502 break;
1503 case NUMBERFORMAT_DATETIME :
1504 nKey = GetFormatIndex( NF_DATETIME_SYS_DDMMYYYY_HHMMSS, eLang );
1505 break;
1506 default:
1507 nKey = GetStandardFormat( fOutNumber, nFIndex, eType, eLang );
1508 }
1509 if ( nKey != nFIndex )
1510 pFormat = (SvNumberformat*) aFTable.Get( nKey );
1511 if (pFormat)
1512 {
1513 if ( eType == NUMBERFORMAT_TIME && pFormat->GetFormatPrecision() )
1514 {
1515 ChangeStandardPrec(INPUTSTRING_PRECISION);
1516 bPrecChanged = true;
1517 }
1518 pFormat->GetOutputString(fOutNumber, sOutString, &pColor);
1519 }
1520 if (bPrecChanged)
1521 ChangeStandardPrec(nOldPrec);
1522 }
1523
GetOutputString(const double & fOutNumber,sal_uInt32 nFIndex,String & sOutString,Color ** ppColor)1524 void SvNumberFormatter::GetOutputString(const double& fOutNumber,
1525 sal_uInt32 nFIndex,
1526 String& sOutString,
1527 Color** ppColor)
1528 {
1529 if (bNoZero && fOutNumber == 0.0)
1530 {
1531 sOutString.Erase();
1532 return;
1533 }
1534 SvNumberformat* pFormat = (SvNumberformat*) aFTable.Get(nFIndex);
1535 if (!pFormat)
1536 pFormat = aFTable.Get(ZF_STANDARD);
1537 ChangeIntl(pFormat->GetLanguage());
1538 pFormat->GetOutputString(fOutNumber, sOutString, ppColor);
1539 }
1540
GetOutputString(String & sString,sal_uInt32 nFIndex,String & sOutString,Color ** ppColor)1541 void SvNumberFormatter::GetOutputString(String& sString,
1542 sal_uInt32 nFIndex,
1543 String& sOutString,
1544 Color** ppColor)
1545 {
1546 SvNumberformat* pFormat = (SvNumberformat*) aFTable.Get(nFIndex);
1547 if (!pFormat)
1548 pFormat = aFTable.Get(ZF_STANDARD_TEXT);
1549 if (!pFormat->IsTextFormat() && !pFormat->HasTextFormat())
1550 {
1551 *ppColor = NULL;
1552 sOutString = sString;
1553 }
1554 else
1555 {
1556 ChangeIntl(pFormat->GetLanguage());
1557 pFormat->GetOutputString(sString, sOutString, ppColor);
1558 }
1559 }
1560
GetPreviewString(const String & sFormatString,double fPreviewNumber,String & sOutString,Color ** ppColor,LanguageType eLnge)1561 sal_Bool SvNumberFormatter::GetPreviewString(const String& sFormatString,
1562 double fPreviewNumber,
1563 String& sOutString,
1564 Color** ppColor,
1565 LanguageType eLnge)
1566 {
1567 if (sFormatString.Len() == 0) // keinen Leerstring
1568 return sal_False;
1569
1570 xub_StrLen nCheckPos = STRING_NOTFOUND;
1571 sal_uInt32 nKey;
1572 if (eLnge == LANGUAGE_DONTKNOW)
1573 eLnge = IniLnge;
1574 ChangeIntl(eLnge); // ggfs. austauschen
1575 eLnge = ActLnge;
1576 String sTmpString = sFormatString;
1577 SvNumberformat* p_Entry = new SvNumberformat(sTmpString,
1578 pFormatScanner,
1579 pStringScanner,
1580 nCheckPos,
1581 eLnge);
1582 if (nCheckPos == 0) // String ok
1583 {
1584 sal_uInt32 CLOffset = ImpGenerateCL(eLnge); // ggfs. neu Standard-
1585 // formate anlegen
1586 nKey = ImpIsEntry(p_Entry->GetFormatstring(),CLOffset, eLnge);
1587 if (nKey != NUMBERFORMAT_ENTRY_NOT_FOUND) // schon vorhanden
1588 GetOutputString(fPreviewNumber,nKey,sOutString,ppColor);
1589 else
1590 p_Entry->GetOutputString(fPreviewNumber,sOutString, ppColor);
1591 delete p_Entry;
1592 return sal_True;
1593 }
1594 else
1595 {
1596 delete p_Entry;
1597 return sal_False;
1598 }
1599 }
1600
GetPreviewStringGuess(const String & sFormatString,double fPreviewNumber,String & sOutString,Color ** ppColor,LanguageType eLnge)1601 sal_Bool SvNumberFormatter::GetPreviewStringGuess( const String& sFormatString,
1602 double fPreviewNumber,
1603 String& sOutString,
1604 Color** ppColor,
1605 LanguageType eLnge )
1606 {
1607 if (sFormatString.Len() == 0) // keinen Leerstring
1608 return sal_False;
1609
1610 if (eLnge == LANGUAGE_DONTKNOW)
1611 eLnge = IniLnge;
1612
1613 ChangeIntl( eLnge );
1614 eLnge = ActLnge;
1615 sal_Bool bEnglish = (eLnge == LANGUAGE_ENGLISH_US);
1616
1617 String aFormatStringUpper( pCharClass->upper( sFormatString ) );
1618 sal_uInt32 nCLOffset = ImpGenerateCL( eLnge );
1619 sal_uInt32 nKey = ImpIsEntry( aFormatStringUpper, nCLOffset, eLnge );
1620 if ( nKey != NUMBERFORMAT_ENTRY_NOT_FOUND )
1621 { // Zielformat vorhanden
1622 GetOutputString( fPreviewNumber, nKey, sOutString, ppColor );
1623 return sal_True;
1624 }
1625
1626 SvNumberformat *pEntry = NULL;
1627 xub_StrLen nCheckPos = STRING_NOTFOUND;
1628 String sTmpString;
1629
1630 if ( bEnglish )
1631 {
1632 sTmpString = sFormatString;
1633 pEntry = new SvNumberformat( sTmpString, pFormatScanner,
1634 pStringScanner, nCheckPos, eLnge );
1635 }
1636 else
1637 {
1638 nCLOffset = ImpGenerateCL( LANGUAGE_ENGLISH_US );
1639 nKey = ImpIsEntry( aFormatStringUpper, nCLOffset, LANGUAGE_ENGLISH_US );
1640 sal_Bool bEnglishFormat = (nKey != NUMBERFORMAT_ENTRY_NOT_FOUND);
1641
1642 // try english --> other bzw. english nach other konvertieren
1643 LanguageType eFormatLang = LANGUAGE_ENGLISH_US;
1644 pFormatScanner->SetConvertMode( LANGUAGE_ENGLISH_US, eLnge );
1645 sTmpString = sFormatString;
1646 pEntry = new SvNumberformat( sTmpString, pFormatScanner,
1647 pStringScanner, nCheckPos, eFormatLang );
1648 pFormatScanner->SetConvertMode( sal_False );
1649 ChangeIntl( eLnge );
1650
1651 if ( !bEnglishFormat )
1652 {
1653 if ( nCheckPos > 0 || xTransliteration->isEqual( sFormatString,
1654 pEntry->GetFormatstring() ) )
1655 { // other Format
1656 delete pEntry;
1657 sTmpString = sFormatString;
1658 pEntry = new SvNumberformat( sTmpString, pFormatScanner,
1659 pStringScanner, nCheckPos, eLnge );
1660 }
1661 else
1662 { // verify english
1663 xub_StrLen nCheckPos2 = STRING_NOTFOUND;
1664 // try other --> english
1665 eFormatLang = eLnge;
1666 pFormatScanner->SetConvertMode( eLnge, LANGUAGE_ENGLISH_US );
1667 sTmpString = sFormatString;
1668 SvNumberformat* pEntry2 = new SvNumberformat( sTmpString, pFormatScanner,
1669 pStringScanner, nCheckPos2, eFormatLang );
1670 pFormatScanner->SetConvertMode( sal_False );
1671 ChangeIntl( eLnge );
1672 if ( nCheckPos2 == 0 && !xTransliteration->isEqual( sFormatString,
1673 pEntry2->GetFormatstring() ) )
1674 { // other Format
1675 delete pEntry;
1676 sTmpString = sFormatString;
1677 pEntry = new SvNumberformat( sTmpString, pFormatScanner,
1678 pStringScanner, nCheckPos, eLnge );
1679 }
1680 delete pEntry2;
1681 }
1682 }
1683 }
1684
1685 if (nCheckPos == 0) // String ok
1686 {
1687 ImpGenerateCL( eLnge ); // ggfs. neu Standardformate anlegen
1688 pEntry->GetOutputString( fPreviewNumber, sOutString, ppColor );
1689 delete pEntry;
1690 return sal_True;
1691 }
1692 delete pEntry;
1693 return sal_False;
1694 }
1695
GetPreviewString(const String & sFormatString,const String & sPreviewString,String & sOutString,Color ** ppColor,LanguageType eLnge)1696 sal_Bool SvNumberFormatter::GetPreviewString( const String& sFormatString,
1697 const String& sPreviewString,
1698 String& sOutString,
1699 Color** ppColor,
1700 LanguageType eLnge )
1701 {
1702 if (sFormatString.Len() == 0) // no empty string
1703 return sal_False;
1704
1705 xub_StrLen nCheckPos = STRING_NOTFOUND;
1706 sal_uInt32 nKey;
1707 if (eLnge == LANGUAGE_DONTKNOW)
1708 eLnge = IniLnge;
1709 ChangeIntl(eLnge); // switch if needed
1710 eLnge = ActLnge;
1711 String sTmpString = sFormatString;
1712 SvNumberformat* p_Entry = new SvNumberformat( sTmpString,
1713 pFormatScanner,
1714 pStringScanner,
1715 nCheckPos,
1716 eLnge);
1717 if (nCheckPos == 0) // String ok
1718 {
1719 String aNonConstPreview( sPreviewString);
1720 // May have to create standard formats for this locale.
1721 sal_uInt32 CLOffset = ImpGenerateCL(eLnge);
1722 nKey = ImpIsEntry( p_Entry->GetFormatstring(), CLOffset, eLnge);
1723 if (nKey != NUMBERFORMAT_ENTRY_NOT_FOUND) // already present
1724 GetOutputString( aNonConstPreview, nKey, sOutString, ppColor);
1725 else
1726 {
1727 // If the format is valid but not a text format and does not
1728 // include a text subformat, an empty string would result. Same as
1729 // in SvNumberFormatter::GetOutputString()
1730 if (p_Entry->IsTextFormat() || p_Entry->HasTextFormat())
1731 p_Entry->GetOutputString( aNonConstPreview, sOutString, ppColor);
1732 else
1733 {
1734 *ppColor = NULL;
1735 sOutString = sPreviewString;
1736 }
1737 }
1738 delete p_Entry;
1739 return sal_True;
1740 }
1741 else
1742 {
1743 delete p_Entry;
1744 return sal_False;
1745 }
1746 }
1747
TestNewString(const String & sFormatString,LanguageType eLnge)1748 sal_uInt32 SvNumberFormatter::TestNewString(const String& sFormatString,
1749 LanguageType eLnge)
1750 {
1751 if (sFormatString.Len() == 0) // keinen Leerstring
1752 return NUMBERFORMAT_ENTRY_NOT_FOUND;
1753
1754 xub_StrLen nCheckPos = STRING_NOTFOUND;
1755 if (eLnge == LANGUAGE_DONTKNOW)
1756 eLnge = IniLnge;
1757 ChangeIntl(eLnge); // ggfs. austauschen
1758 eLnge = ActLnge;
1759 sal_uInt32 nRes;
1760 String sTmpString = sFormatString;
1761 SvNumberformat* pEntry = new SvNumberformat(sTmpString,
1762 pFormatScanner,
1763 pStringScanner,
1764 nCheckPos,
1765 eLnge);
1766 if (nCheckPos == 0) // String ok
1767 {
1768 sal_uInt32 CLOffset = ImpGenerateCL(eLnge); // ggfs. neu Standard-
1769 // formate anlegen
1770 nRes = ImpIsEntry(pEntry->GetFormatstring(),CLOffset, eLnge);
1771 // schon vorhanden ?
1772 }
1773 else
1774 nRes = NUMBERFORMAT_ENTRY_NOT_FOUND;
1775 delete pEntry;
1776 return nRes;
1777 }
1778
ImpInsertFormat(const::com::sun::star::i18n::NumberFormatCode & rCode,sal_uInt32 nPos,sal_Bool bAfterLoadingSO5,sal_Int16 nOrgIndex)1779 SvNumberformat* SvNumberFormatter::ImpInsertFormat(
1780 const ::com::sun::star::i18n::NumberFormatCode& rCode,
1781 sal_uInt32 nPos, sal_Bool bAfterLoadingSO5, sal_Int16 nOrgIndex )
1782 {
1783 String aCodeStr( rCode.Code );
1784 if ( rCode.Index < NF_INDEX_TABLE_ENTRIES &&
1785 rCode.Usage == ::com::sun::star::i18n::KNumberFormatUsage::CURRENCY &&
1786 rCode.Index != NF_CURRENCY_1000DEC2_CCC )
1787 { // strip surrounding [$...] on automatic currency
1788 if ( aCodeStr.SearchAscii( "[$" ) != STRING_NOTFOUND )
1789 aCodeStr = SvNumberformat::StripNewCurrencyDelimiters( aCodeStr, sal_False );
1790 else
1791 {
1792 if (LocaleDataWrapper::areChecksEnabled() &&
1793 rCode.Index != NF_CURRENCY_1000DEC2_CCC )
1794 {
1795 String aMsg( RTL_CONSTASCII_USTRINGPARAM(
1796 "SvNumberFormatter::ImpInsertFormat: no [$...] on currency format code, index "));
1797 aMsg += String::CreateFromInt32( rCode.Index );
1798 aMsg.AppendAscii( RTL_CONSTASCII_STRINGPARAM( ":\n"));
1799 aMsg += String( rCode.Code );
1800 LocaleDataWrapper::outputCheckMessage(
1801 xLocaleData->appendLocaleInfo( aMsg));
1802 }
1803 }
1804 }
1805 xub_StrLen nCheckPos = 0;
1806 SvNumberformat* pFormat = new SvNumberformat(aCodeStr,
1807 pFormatScanner,
1808 pStringScanner,
1809 nCheckPos,
1810 ActLnge);
1811 if ( !pFormat || nCheckPos > 0 )
1812 {
1813 if (LocaleDataWrapper::areChecksEnabled())
1814 {
1815 String aMsg( RTL_CONSTASCII_USTRINGPARAM(
1816 "SvNumberFormatter::ImpInsertFormat: bad format code, index "));
1817 aMsg += String::CreateFromInt32( rCode.Index );
1818 aMsg += '\n';
1819 aMsg += String( rCode.Code );
1820 LocaleDataWrapper::outputCheckMessage(
1821 xLocaleData->appendLocaleInfo( aMsg));
1822 }
1823 delete pFormat;
1824 return NULL;
1825 }
1826 if ( rCode.Index >= NF_INDEX_TABLE_ENTRIES )
1827 {
1828 sal_uInt32 nCLOffset = nPos - (nPos % SV_COUNTRY_LANGUAGE_OFFSET);
1829 sal_uInt32 nKey = ImpIsEntry( aCodeStr, nCLOffset, ActLnge );
1830 if ( nKey != NUMBERFORMAT_ENTRY_NOT_FOUND )
1831 {
1832 if (LocaleDataWrapper::areChecksEnabled())
1833 {
1834 switch ( nOrgIndex )
1835 {
1836 // These may be dupes of integer versions for locales where
1837 // currencies have no decimals like Italian Lira.
1838 case NF_CURRENCY_1000DEC2 : // NF_CURRENCY_1000INT
1839 case NF_CURRENCY_1000DEC2_RED : // NF_CURRENCY_1000INT_RED
1840 case NF_CURRENCY_1000DEC2_DASHED : // NF_CURRENCY_1000INT_RED
1841 break;
1842 default:
1843 if ( !bAfterLoadingSO5 )
1844 { // If bAfterLoadingSO5 there will definitely be some dupes,
1845 // don't cry. But we need this test for verification of locale
1846 // data if not loading old SO5 documents.
1847 String aMsg( RTL_CONSTASCII_USTRINGPARAM(
1848 "SvNumberFormatter::ImpInsertFormat: dup format code, index "));
1849 aMsg += String::CreateFromInt32( rCode.Index );
1850 aMsg += '\n';
1851 aMsg += String( rCode.Code );
1852 LocaleDataWrapper::outputCheckMessage(
1853 xLocaleData->appendLocaleInfo( aMsg));
1854 }
1855 }
1856 }
1857 delete pFormat;
1858 return NULL;
1859 }
1860 else if ( nPos - nCLOffset >= SV_COUNTRY_LANGUAGE_OFFSET )
1861 {
1862 if (LocaleDataWrapper::areChecksEnabled())
1863 {
1864 String aMsg( RTL_CONSTASCII_USTRINGPARAM(
1865 "SvNumberFormatter::ImpInsertFormat: too many format codes, index "));
1866 aMsg += String::CreateFromInt32( rCode.Index );
1867 aMsg += '\n';
1868 aMsg += String( rCode.Code );
1869 LocaleDataWrapper::outputCheckMessage(
1870 xLocaleData->appendLocaleInfo( aMsg));
1871 }
1872 delete pFormat;
1873 return NULL;
1874 }
1875 }
1876 if ( !aFTable.Insert( nPos, pFormat ) )
1877 {
1878 if (LocaleDataWrapper::areChecksEnabled())
1879 {
1880 String aMsg( RTL_CONSTASCII_USTRINGPARAM(
1881 "ImpInsertFormat: can't insert number format key pos: "));
1882 aMsg += String::CreateFromInt32( nPos );
1883 aMsg.AppendAscii( RTL_CONSTASCII_STRINGPARAM( ", code index "));
1884 aMsg += String::CreateFromInt32( rCode.Index );
1885 aMsg += '\n';
1886 aMsg += String( rCode.Code );
1887 LocaleDataWrapper::outputCheckMessage(
1888 xLocaleData->appendLocaleInfo( aMsg));
1889 }
1890 delete pFormat;
1891 return NULL;
1892 }
1893 if ( rCode.Default )
1894 pFormat->SetStandard();
1895 if ( rCode.DefaultName.getLength() )
1896 pFormat->SetComment( rCode.DefaultName );
1897 return pFormat;
1898 }
1899
ImpInsertNewStandardFormat(const::com::sun::star::i18n::NumberFormatCode & rCode,sal_uInt32 nPos,sal_uInt16 nVersion,sal_Bool bAfterLoadingSO5,sal_Int16 nOrgIndex)1900 SvNumberformat* SvNumberFormatter::ImpInsertNewStandardFormat(
1901 const ::com::sun::star::i18n::NumberFormatCode& rCode,
1902 sal_uInt32 nPos, sal_uInt16 nVersion, sal_Bool bAfterLoadingSO5,
1903 sal_Int16 nOrgIndex )
1904 {
1905 SvNumberformat* pNewFormat = ImpInsertFormat( rCode, nPos,
1906 bAfterLoadingSO5, nOrgIndex );
1907 if (pNewFormat)
1908 pNewFormat->SetNewStandardDefined( nVersion );
1909 // so that it gets saved, displayed properly, and converted by old versions
1910 return pNewFormat;
1911 }
1912
GetFormatSpecialInfo(sal_uInt32 nFormat,sal_Bool & bThousand,sal_Bool & IsRed,sal_uInt16 & nPrecision,sal_uInt16 & nAnzLeading)1913 void SvNumberFormatter::GetFormatSpecialInfo(sal_uInt32 nFormat,
1914 sal_Bool& bThousand,
1915 sal_Bool& IsRed,
1916 sal_uInt16& nPrecision,
1917 sal_uInt16& nAnzLeading)
1918
1919 {
1920 const SvNumberformat* pFormat = aFTable.Get(nFormat);
1921 if (pFormat)
1922 pFormat->GetFormatSpecialInfo(bThousand, IsRed,
1923 nPrecision, nAnzLeading);
1924 else
1925 {
1926 bThousand = sal_False;
1927 IsRed = sal_False;
1928 nPrecision = pFormatScanner->GetStandardPrec();
1929 nAnzLeading = 0;
1930 }
1931 }
1932
GetFormatPrecision(sal_uInt32 nFormat) const1933 sal_uInt16 SvNumberFormatter::GetFormatPrecision( sal_uInt32 nFormat ) const
1934 {
1935 const SvNumberformat* pFormat = aFTable.Get( nFormat );
1936 if ( pFormat )
1937 return pFormat->GetFormatPrecision();
1938 else
1939 return pFormatScanner->GetStandardPrec();
1940 }
1941
1942
GetFormatDecimalSep(sal_uInt32 nFormat) const1943 String SvNumberFormatter::GetFormatDecimalSep( sal_uInt32 nFormat ) const
1944 {
1945 const SvNumberformat* pFormat = aFTable.Get( nFormat );
1946 if ( !pFormat || pFormat->GetLanguage() == ActLnge )
1947 return GetNumDecimalSep();
1948
1949 String aRet;
1950 LanguageType eSaveLang = xLocaleData.getCurrentLanguage();
1951 if ( pFormat->GetLanguage() == eSaveLang )
1952 aRet = xLocaleData->getNumDecimalSep();
1953 else
1954 {
1955 ::com::sun::star::lang::Locale aSaveLocale( xLocaleData->getLocale() );
1956 ::com::sun::star::lang::Locale aTmpLocale(MsLangId::convertLanguageToLocale(pFormat->GetLanguage()));
1957 ((SvNumberFormatter*)this)->xLocaleData.changeLocale(aTmpLocale, pFormat->GetLanguage() );
1958 aRet = xLocaleData->getNumDecimalSep();
1959 ((SvNumberFormatter*)this)->xLocaleData.changeLocale( aSaveLocale, eSaveLang );
1960 }
1961 return aRet;
1962 }
1963
1964
GetFormatSpecialInfo(const String & rFormatString,sal_Bool & bThousand,sal_Bool & IsRed,sal_uInt16 & nPrecision,sal_uInt16 & nAnzLeading,LanguageType eLnge)1965 sal_uInt32 SvNumberFormatter::GetFormatSpecialInfo( const String& rFormatString,
1966 sal_Bool& bThousand, sal_Bool& IsRed, sal_uInt16& nPrecision,
1967 sal_uInt16& nAnzLeading, LanguageType eLnge )
1968
1969 {
1970 xub_StrLen nCheckPos = 0;
1971 if (eLnge == LANGUAGE_DONTKNOW)
1972 eLnge = IniLnge;
1973 ChangeIntl(eLnge); // ggfs. austauschen
1974 eLnge = ActLnge;
1975 String aTmpStr( rFormatString );
1976 SvNumberformat* pFormat = new SvNumberformat( aTmpStr,
1977 pFormatScanner, pStringScanner, nCheckPos, eLnge );
1978 if ( nCheckPos == 0 )
1979 pFormat->GetFormatSpecialInfo( bThousand, IsRed, nPrecision, nAnzLeading );
1980 else
1981 {
1982 bThousand = sal_False;
1983 IsRed = sal_False;
1984 nPrecision = pFormatScanner->GetStandardPrec();
1985 nAnzLeading = 0;
1986 }
1987 delete pFormat;
1988 return nCheckPos;
1989 }
1990
1991
SetIndexTable(NfIndexTableOffset nTabOff,sal_uInt32 nIndOff)1992 inline sal_uInt32 SetIndexTable( NfIndexTableOffset nTabOff, sal_uInt32 nIndOff )
1993 {
1994 if ( !bIndexTableInitialized )
1995 {
1996 DBG_ASSERT( theIndexTable[nTabOff] == NUMBERFORMAT_ENTRY_NOT_FOUND,
1997 "SetIndexTable: theIndexTable[nTabOff] already occupied" );
1998 theIndexTable[nTabOff] = nIndOff;
1999 }
2000 return nIndOff;
2001 }
2002
2003
ImpGetFormatCodeIndex(::com::sun::star::uno::Sequence<::com::sun::star::i18n::NumberFormatCode> & rSeq,const NfIndexTableOffset nTabOff)2004 sal_Int32 SvNumberFormatter::ImpGetFormatCodeIndex(
2005 ::com::sun::star::uno::Sequence< ::com::sun::star::i18n::NumberFormatCode >& rSeq,
2006 const NfIndexTableOffset nTabOff )
2007 {
2008 const sal_Int32 nLen = rSeq.getLength();
2009 for ( sal_Int32 j=0; j<nLen; j++ )
2010 {
2011 if ( rSeq[j].Index == nTabOff )
2012 return j;
2013 }
2014 if (LocaleDataWrapper::areChecksEnabled() && (nTabOff < NF_CURRENCY_START
2015 || NF_CURRENCY_END < nTabOff || nTabOff == NF_CURRENCY_1000INT
2016 || nTabOff == NF_CURRENCY_1000INT_RED
2017 || nTabOff == NF_CURRENCY_1000DEC2_CCC))
2018 { // currency entries with decimals might not exist, e.g. Italian Lira
2019 String aMsg( RTL_CONSTASCII_USTRINGPARAM(
2020 "SvNumberFormatter::ImpGetFormatCodeIndex: not found: "));
2021 aMsg += String::CreateFromInt32( nTabOff );
2022 LocaleDataWrapper::outputCheckMessage( xLocaleData->appendLocaleInfo(
2023 aMsg));
2024 }
2025 if ( nLen )
2026 {
2027 sal_Int32 j;
2028 // look for a preset default
2029 for ( j=0; j<nLen; j++ )
2030 {
2031 if ( rSeq[j].Default )
2032 return j;
2033 }
2034 // currencies are special, not all format codes must exist, but all
2035 // builtin number format key index positions must have a format assigned
2036 if ( NF_CURRENCY_START <= nTabOff && nTabOff <= NF_CURRENCY_END )
2037 {
2038 // look for a format with decimals
2039 for ( j=0; j<nLen; j++ )
2040 {
2041 if ( rSeq[j].Index == NF_CURRENCY_1000DEC2 )
2042 return j;
2043 }
2044 // last resort: look for a format without decimals
2045 for ( j=0; j<nLen; j++ )
2046 {
2047 if ( rSeq[j].Index == NF_CURRENCY_1000INT )
2048 return j;
2049 }
2050 }
2051 }
2052 else
2053 { // we need at least _some_ format
2054 rSeq.realloc(1);
2055 rSeq[0] = ::com::sun::star::i18n::NumberFormatCode();
2056 String aTmp( '0' );
2057 aTmp += GetNumDecimalSep();
2058 aTmp.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "############" ) );
2059 rSeq[0].Code = aTmp;
2060 }
2061 return 0;
2062 }
2063
2064
ImpAdjustFormatCodeDefault(::com::sun::star::i18n::NumberFormatCode * pFormatArr,sal_Int32 nCnt,sal_Bool bCheckCorrectness)2065 sal_Int32 SvNumberFormatter::ImpAdjustFormatCodeDefault(
2066 ::com::sun::star::i18n::NumberFormatCode * pFormatArr,
2067 sal_Int32 nCnt, sal_Bool bCheckCorrectness )
2068 {
2069 using namespace ::com::sun::star;
2070
2071 if ( !nCnt )
2072 return -1;
2073 if (bCheckCorrectness && LocaleDataWrapper::areChecksEnabled())
2074 { // check the locale data for correctness
2075 ByteString aMsg;
2076 sal_Int32 nElem, nShort, nMedium, nLong, nShortDef, nMediumDef, nLongDef;
2077 nShort = nMedium = nLong = nShortDef = nMediumDef = nLongDef = -1;
2078 for ( nElem = 0; nElem < nCnt; nElem++ )
2079 {
2080 switch ( pFormatArr[nElem].Type )
2081 {
2082 case i18n::KNumberFormatType::SHORT :
2083 nShort = nElem;
2084 break;
2085 case i18n::KNumberFormatType::MEDIUM :
2086 nMedium = nElem;
2087 break;
2088 case i18n::KNumberFormatType::LONG :
2089 nLong = nElem;
2090 break;
2091 default:
2092 aMsg = "unknown type";
2093 }
2094 if ( pFormatArr[nElem].Default )
2095 {
2096 switch ( pFormatArr[nElem].Type )
2097 {
2098 case i18n::KNumberFormatType::SHORT :
2099 if ( nShortDef != -1 )
2100 aMsg = "dupe short type default";
2101 nShortDef = nElem;
2102 break;
2103 case i18n::KNumberFormatType::MEDIUM :
2104 if ( nMediumDef != -1 )
2105 aMsg = "dupe medium type default";
2106 nMediumDef = nElem;
2107 break;
2108 case i18n::KNumberFormatType::LONG :
2109 if ( nLongDef != -1 )
2110 aMsg = "dupe long type default";
2111 nLongDef = nElem;
2112 break;
2113 }
2114 }
2115 if ( aMsg.Len() )
2116 {
2117 aMsg.Insert( "SvNumberFormatter::ImpAdjustFormatCodeDefault: ", 0 );
2118 aMsg += "\nXML locale data FormatElement formatindex: ";
2119 aMsg += ByteString::CreateFromInt32( pFormatArr[nElem].Index );
2120 String aUMsg( aMsg, RTL_TEXTENCODING_ASCII_US);
2121 LocaleDataWrapper::outputCheckMessage(
2122 xLocaleData->appendLocaleInfo( aUMsg));
2123 aMsg.Erase();
2124 }
2125 }
2126 if ( nShort != -1 && nShortDef == -1 )
2127 aMsg += "no short type default ";
2128 if ( nMedium != -1 && nMediumDef == -1 )
2129 aMsg += "no medium type default ";
2130 if ( nLong != -1 && nLongDef == -1 )
2131 aMsg += "no long type default ";
2132 if ( aMsg.Len() )
2133 {
2134 aMsg.Insert( "SvNumberFormatter::ImpAdjustFormatCodeDefault: ", 0 );
2135 aMsg += "\nXML locale data FormatElement group of: ";
2136 String aUMsg( aMsg, RTL_TEXTENCODING_ASCII_US);
2137 aUMsg += String( pFormatArr[0].NameID );
2138 LocaleDataWrapper::outputCheckMessage(
2139 xLocaleData->appendLocaleInfo( aUMsg));
2140 aMsg.Erase();
2141 }
2142 }
2143 // find the default (medium preferred, then long) and reset all other defaults
2144 sal_Int32 nElem, nDef, nMedium;
2145 nDef = nMedium = -1;
2146 for ( nElem = 0; nElem < nCnt; nElem++ )
2147 {
2148 if ( pFormatArr[nElem].Default )
2149 {
2150 switch ( pFormatArr[nElem].Type )
2151 {
2152 case i18n::KNumberFormatType::MEDIUM :
2153 nDef = nMedium = nElem;
2154 break;
2155 case i18n::KNumberFormatType::LONG :
2156 if ( nMedium == -1 )
2157 nDef = nElem;
2158 // fallthru
2159 default:
2160 if ( nDef == -1 )
2161 nDef = nElem;
2162 pFormatArr[nElem].Default = sal_False;
2163 }
2164 }
2165 }
2166 if ( nDef == -1 )
2167 nDef = 0;
2168 pFormatArr[nDef].Default = sal_True;
2169 return nDef;
2170 }
2171
2172
ImpGenerateFormats(sal_uInt32 CLOffset,sal_Bool bLoadingSO5)2173 void SvNumberFormatter::ImpGenerateFormats( sal_uInt32 CLOffset, sal_Bool bLoadingSO5 )
2174 {
2175 using namespace ::com::sun::star;
2176
2177 if ( !bIndexTableInitialized )
2178 {
2179 for ( sal_uInt16 j=0; j<NF_INDEX_TABLE_ENTRIES; j++ )
2180 {
2181 theIndexTable[j] = NUMBERFORMAT_ENTRY_NOT_FOUND;
2182 }
2183 }
2184 sal_Bool bOldConvertMode = pFormatScanner->GetConvertMode();
2185 if (bOldConvertMode)
2186 pFormatScanner->SetConvertMode(sal_False); // switch off for this function
2187
2188 NumberFormatCodeWrapper aNumberFormatCode( xServiceManager, GetLocale() );
2189
2190 xub_StrLen nCheckPos = 0;
2191 SvNumberformat* pNewFormat = NULL;
2192 String aFormatCode;
2193 sal_Int32 nIdx;
2194 sal_Bool bDefault;
2195
2196 // Counter for additional builtin formats not fitting into the first 10
2197 // of a category (TLOT:=The Legacy Of Templin), altogether about 20 formats.
2198 // Has to be incremented on each ImpInsertNewStandardformat, new formats
2199 // must be appended, not inserted!
2200 sal_uInt16 nNewExtended = ZF_STANDARD_NEWEXTENDED;
2201
2202 // Number
2203 uno::Sequence< i18n::NumberFormatCode > aFormatSeq
2204 = aNumberFormatCode.getAllFormatCode( i18n::KNumberFormatUsage::FIXED_NUMBER );
2205 ImpAdjustFormatCodeDefault( aFormatSeq.getArray(), aFormatSeq.getLength() );
2206
2207 // General
2208 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_NUMBER_STANDARD );
2209 SvNumberformat* pStdFormat = ImpInsertFormat( aFormatSeq[nIdx],
2210 CLOffset + SetIndexTable( NF_NUMBER_STANDARD, ZF_STANDARD ));
2211 if (pStdFormat)
2212 {
2213 // This is _the_ standard format.
2214 if (LocaleDataWrapper::areChecksEnabled() &&
2215 pStdFormat->GetType() != NUMBERFORMAT_NUMBER)
2216 {
2217 String aMsg( RTL_CONSTASCII_USTRINGPARAM(
2218 "SvNumberFormatter::ImpGenerateFormats: General format not NUMBER"));
2219 LocaleDataWrapper::outputCheckMessage(
2220 xLocaleData->appendLocaleInfo( aMsg));
2221 }
2222 pStdFormat->SetType( NUMBERFORMAT_NUMBER );
2223 pStdFormat->SetStandard();
2224 pStdFormat->SetLastInsertKey( SV_MAX_ANZ_STANDARD_FORMATE );
2225 }
2226 else
2227 {
2228 if (LocaleDataWrapper::areChecksEnabled())
2229 {
2230 String aMsg( RTL_CONSTASCII_USTRINGPARAM(
2231 "SvNumberFormatter::ImpGenerateFormats: General format not insertable, nothing will work"));
2232 LocaleDataWrapper::outputCheckMessage(
2233 xLocaleData->appendLocaleInfo( aMsg));
2234 }
2235 }
2236
2237 // Boolean
2238 aFormatCode = pFormatScanner->GetBooleanString();
2239 pNewFormat = new SvNumberformat( aFormatCode,
2240 pFormatScanner, pStringScanner, nCheckPos, ActLnge );
2241 pNewFormat->SetType(NUMBERFORMAT_LOGICAL);
2242 pNewFormat->SetStandard();
2243 if ( !aFTable.Insert(
2244 CLOffset + SetIndexTable( NF_BOOLEAN, ZF_STANDARD_LOGICAL ),
2245 pNewFormat))
2246 delete pNewFormat;
2247
2248 // Text
2249 aFormatCode = '@';
2250 pNewFormat = new SvNumberformat( aFormatCode,
2251 pFormatScanner, pStringScanner, nCheckPos, ActLnge );
2252 pNewFormat->SetType(NUMBERFORMAT_TEXT);
2253 pNewFormat->SetStandard();
2254 if ( !aFTable.Insert(
2255 CLOffset + SetIndexTable( NF_TEXT, ZF_STANDARD_TEXT ),
2256 pNewFormat))
2257 delete pNewFormat;
2258
2259
2260
2261 // 0
2262 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_NUMBER_INT );
2263 ImpInsertFormat( aFormatSeq[nIdx],
2264 CLOffset + SetIndexTable( NF_NUMBER_INT, ZF_STANDARD+1 ));
2265
2266 // 0.00
2267 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_NUMBER_DEC2 );
2268 ImpInsertFormat( aFormatSeq[nIdx],
2269 CLOffset + SetIndexTable( NF_NUMBER_DEC2, ZF_STANDARD+2 ));
2270
2271 // #,##0
2272 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_NUMBER_1000INT );
2273 ImpInsertFormat( aFormatSeq[nIdx],
2274 CLOffset + SetIndexTable( NF_NUMBER_1000INT, ZF_STANDARD+3 ));
2275
2276 // #,##0.00
2277 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_NUMBER_1000DEC2 );
2278 ImpInsertFormat( aFormatSeq[nIdx],
2279 CLOffset + SetIndexTable( NF_NUMBER_1000DEC2, ZF_STANDARD+4 ));
2280
2281 // #.##0,00 System country/language dependent since number formatter version 6
2282 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_NUMBER_SYSTEM );
2283 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2284 CLOffset + SetIndexTable( NF_NUMBER_SYSTEM, ZF_STANDARD+5 ),
2285 SV_NUMBERFORMATTER_VERSION_NEWSTANDARD );
2286
2287
2288 // Percent number
2289 aFormatSeq = aNumberFormatCode.getAllFormatCode( i18n::KNumberFormatUsage::PERCENT_NUMBER );
2290 ImpAdjustFormatCodeDefault( aFormatSeq.getArray(), aFormatSeq.getLength() );
2291
2292 // 0%
2293 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_PERCENT_INT );
2294 ImpInsertFormat( aFormatSeq[nIdx],
2295 CLOffset + SetIndexTable( NF_PERCENT_INT, ZF_STANDARD_PERCENT ));
2296
2297 // 0.00%
2298 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_PERCENT_DEC2 );
2299 ImpInsertFormat( aFormatSeq[nIdx],
2300 CLOffset + SetIndexTable( NF_PERCENT_DEC2, ZF_STANDARD_PERCENT+1 ));
2301
2302
2303
2304 // Currency. NO default standard option! Default is determined of locale
2305 // data default currency and format is generated if needed.
2306 aFormatSeq = aNumberFormatCode.getAllFormatCode( i18n::KNumberFormatUsage::CURRENCY );
2307 if (LocaleDataWrapper::areChecksEnabled())
2308 {
2309 // though no default desired here, test for correctness of locale data
2310 ImpAdjustFormatCodeDefault( aFormatSeq.getArray(), aFormatSeq.getLength() );
2311 }
2312
2313 // #,##0
2314 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_CURRENCY_1000INT );
2315 bDefault = aFormatSeq[nIdx].Default;
2316 aFormatSeq[nIdx].Default = sal_False;
2317 ImpInsertFormat( aFormatSeq[nIdx],
2318 CLOffset + SetIndexTable( NF_CURRENCY_1000INT, ZF_STANDARD_CURRENCY ));
2319 aFormatSeq[nIdx].Default = bDefault;
2320
2321 // #,##0.00
2322 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_CURRENCY_1000DEC2 );
2323 bDefault = aFormatSeq[nIdx].Default;
2324 aFormatSeq[nIdx].Default = sal_False;
2325 ImpInsertFormat( aFormatSeq[nIdx],
2326 CLOffset + SetIndexTable( NF_CURRENCY_1000DEC2, ZF_STANDARD_CURRENCY+1 ));
2327 aFormatSeq[nIdx].Default = bDefault;
2328
2329 // #,##0 negative red
2330 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_CURRENCY_1000INT_RED );
2331 bDefault = aFormatSeq[nIdx].Default;
2332 aFormatSeq[nIdx].Default = sal_False;
2333 ImpInsertFormat( aFormatSeq[nIdx],
2334 CLOffset + SetIndexTable( NF_CURRENCY_1000INT_RED, ZF_STANDARD_CURRENCY+2 ));
2335 aFormatSeq[nIdx].Default = bDefault;
2336
2337 // #,##0.00 negative red
2338 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_CURRENCY_1000DEC2_RED );
2339 bDefault = aFormatSeq[nIdx].Default;
2340 aFormatSeq[nIdx].Default = sal_False;
2341 ImpInsertFormat( aFormatSeq[nIdx],
2342 CLOffset + SetIndexTable( NF_CURRENCY_1000DEC2_RED, ZF_STANDARD_CURRENCY+3 ));
2343 aFormatSeq[nIdx].Default = bDefault;
2344
2345 // #,##0.00 USD since number formatter version 3
2346 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_CURRENCY_1000DEC2_CCC );
2347 bDefault = aFormatSeq[nIdx].Default;
2348 aFormatSeq[nIdx].Default = sal_False;
2349 pNewFormat = ImpInsertFormat( aFormatSeq[nIdx],
2350 CLOffset + SetIndexTable( NF_CURRENCY_1000DEC2_CCC, ZF_STANDARD_CURRENCY+4 ));
2351 if ( pNewFormat )
2352 pNewFormat->SetUsed(sal_True); // must be saved for older versions
2353 aFormatSeq[nIdx].Default = bDefault;
2354
2355 // #.##0,-- since number formatter version 6
2356 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_CURRENCY_1000DEC2_DASHED );
2357 bDefault = aFormatSeq[nIdx].Default;
2358 aFormatSeq[nIdx].Default = sal_False;
2359 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2360 CLOffset + SetIndexTable( NF_CURRENCY_1000DEC2_DASHED, ZF_STANDARD_CURRENCY+5 ),
2361 SV_NUMBERFORMATTER_VERSION_NEWSTANDARD );
2362 aFormatSeq[nIdx].Default = bDefault;
2363
2364
2365
2366 // Date
2367 aFormatSeq = aNumberFormatCode.getAllFormatCode( i18n::KNumberFormatUsage::DATE );
2368 ImpAdjustFormatCodeDefault( aFormatSeq.getArray(), aFormatSeq.getLength() );
2369
2370 // DD.MM.YY System
2371 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYSTEM_SHORT );
2372 ImpInsertFormat( aFormatSeq[nIdx],
2373 CLOffset + SetIndexTable( NF_DATE_SYSTEM_SHORT, ZF_STANDARD_DATE ));
2374
2375 // NN DD.MMM YY
2376 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_DEF_NNDDMMMYY );
2377 ImpInsertFormat( aFormatSeq[nIdx],
2378 CLOffset + SetIndexTable( NF_DATE_DEF_NNDDMMMYY, ZF_STANDARD_DATE+1 ));
2379
2380 // DD.MM.YY def/System
2381 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_MMYY );
2382 ImpInsertFormat( aFormatSeq[nIdx],
2383 CLOffset + SetIndexTable( NF_DATE_SYS_MMYY, ZF_STANDARD_DATE+2 ));
2384
2385 // DD MMM
2386 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_DDMMM );
2387 ImpInsertFormat( aFormatSeq[nIdx],
2388 CLOffset + SetIndexTable( NF_DATE_SYS_DDMMM, ZF_STANDARD_DATE+3 ));
2389
2390 // MMMM
2391 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_MMMM );
2392 ImpInsertFormat( aFormatSeq[nIdx],
2393 CLOffset + SetIndexTable( NF_DATE_MMMM, ZF_STANDARD_DATE+4 ));
2394
2395 // QQ YY
2396 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_QQJJ );
2397 ImpInsertFormat( aFormatSeq[nIdx],
2398 CLOffset + SetIndexTable( NF_DATE_QQJJ, ZF_STANDARD_DATE+5 ));
2399
2400 // DD.MM.YYYY since number formatter version 2, was DD.MM.[YY]YY
2401 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_DDMMYYYY );
2402 pNewFormat = ImpInsertFormat( aFormatSeq[nIdx],
2403 CLOffset + SetIndexTable( NF_DATE_SYS_DDMMYYYY, ZF_STANDARD_DATE+6 ));
2404 if ( pNewFormat )
2405 pNewFormat->SetUsed(sal_True); // must be saved for older versions
2406
2407 // DD.MM.YY def/System, since number formatter version 6
2408 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_DDMMYY );
2409 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2410 CLOffset + SetIndexTable( NF_DATE_SYS_DDMMYY, ZF_STANDARD_DATE+7 ),
2411 SV_NUMBERFORMATTER_VERSION_NEWSTANDARD );
2412
2413 // NNN, D. MMMM YYYY System
2414 // Long day of week: "NNNN" instead of "NNN," because of compatibility
2415 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYSTEM_LONG );
2416 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2417 CLOffset + SetIndexTable( NF_DATE_SYSTEM_LONG, ZF_STANDARD_DATE+8 ),
2418 SV_NUMBERFORMATTER_VERSION_NEWSTANDARD );
2419
2420 // Hard coded but system (regional settings) delimiters dependent long date formats
2421 // since numberformatter version 6
2422
2423 // D. MMM YY def/System
2424 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_DMMMYY );
2425 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2426 CLOffset + SetIndexTable( NF_DATE_SYS_DMMMYY, ZF_STANDARD_DATE+9 ),
2427 SV_NUMBERFORMATTER_VERSION_NEWSTANDARD );
2428
2429 //! Unfortunately TLOT intended only 10 builtin formats per category, more
2430 //! would overwrite the next category (ZF_STANDARD_TIME) :-((
2431 //! Therefore they are inserted with nNewExtended++ (which is also limited)
2432
2433 // D. MMM YYYY def/System
2434 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_DMMMYYYY );
2435 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2436 CLOffset + SetIndexTable( NF_DATE_SYS_DMMMYYYY, nNewExtended++ ),
2437 SV_NUMBERFORMATTER_VERSION_NEWSTANDARD );
2438
2439 // D. MMMM YYYY def/System
2440 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_DMMMMYYYY );
2441 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2442 CLOffset + SetIndexTable( NF_DATE_SYS_DMMMMYYYY, nNewExtended++ ),
2443 SV_NUMBERFORMATTER_VERSION_NEWSTANDARD );
2444
2445 // NN, D. MMM YY def/System
2446 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_NNDMMMYY );
2447 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2448 CLOffset + SetIndexTable( NF_DATE_SYS_NNDMMMYY, nNewExtended++ ),
2449 SV_NUMBERFORMATTER_VERSION_NEWSTANDARD );
2450
2451 // NN, D. MMMM YYYY def/System
2452 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_NNDMMMMYYYY );
2453 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2454 CLOffset + SetIndexTable( NF_DATE_SYS_NNDMMMMYYYY, nNewExtended++ ),
2455 SV_NUMBERFORMATTER_VERSION_NEWSTANDARD );
2456
2457 // NNN, D. MMMM YYYY def/System
2458 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_SYS_NNNNDMMMMYYYY );
2459 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2460 CLOffset + SetIndexTable( NF_DATE_SYS_NNNNDMMMMYYYY, nNewExtended++ ),
2461 SV_NUMBERFORMATTER_VERSION_NEWSTANDARD );
2462
2463 // Hard coded DIN (Deutsche Industrie Norm) and EN (European Norm) date formats
2464
2465 // D. MMM. YYYY DIN/EN
2466 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_DIN_DMMMYYYY );
2467 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2468 CLOffset + SetIndexTable( NF_DATE_DIN_DMMMYYYY, nNewExtended++ ),
2469 SV_NUMBERFORMATTER_VERSION_NEWSTANDARD );
2470
2471 // D. MMMM YYYY DIN/EN
2472 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_DIN_DMMMMYYYY );
2473 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2474 CLOffset + SetIndexTable( NF_DATE_DIN_DMMMMYYYY, nNewExtended++ ),
2475 SV_NUMBERFORMATTER_VERSION_NEWSTANDARD );
2476
2477 // MM-DD DIN/EN
2478 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_DIN_MMDD );
2479 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2480 CLOffset + SetIndexTable( NF_DATE_DIN_MMDD, nNewExtended++ ),
2481 SV_NUMBERFORMATTER_VERSION_NEWSTANDARD );
2482
2483 // YY-MM-DD DIN/EN
2484 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_DIN_YYMMDD );
2485 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2486 CLOffset + SetIndexTable( NF_DATE_DIN_YYMMDD, nNewExtended++ ),
2487 SV_NUMBERFORMATTER_VERSION_NEWSTANDARD );
2488
2489 // YYYY-MM-DD DIN/EN
2490 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATE_DIN_YYYYMMDD );
2491 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2492 CLOffset + SetIndexTable( NF_DATE_DIN_YYYYMMDD, nNewExtended++ ),
2493 SV_NUMBERFORMATTER_VERSION_NEWSTANDARD );
2494
2495
2496
2497 // Time
2498 aFormatSeq = aNumberFormatCode.getAllFormatCode( i18n::KNumberFormatUsage::TIME );
2499 ImpAdjustFormatCodeDefault( aFormatSeq.getArray(), aFormatSeq.getLength() );
2500
2501 // HH:MM
2502 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_TIME_HHMM );
2503 ImpInsertFormat( aFormatSeq[nIdx],
2504 CLOffset + SetIndexTable( NF_TIME_HHMM, ZF_STANDARD_TIME ));
2505
2506 // HH:MM:SS
2507 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_TIME_HHMMSS );
2508 ImpInsertFormat( aFormatSeq[nIdx],
2509 CLOffset + SetIndexTable( NF_TIME_HHMMSS, ZF_STANDARD_TIME+1 ));
2510
2511 // HH:MM AM/PM
2512 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_TIME_HHMMAMPM );
2513 ImpInsertFormat( aFormatSeq[nIdx],
2514 CLOffset + SetIndexTable( NF_TIME_HHMMAMPM, ZF_STANDARD_TIME+2 ));
2515
2516 // HH:MM:SS AM/PM
2517 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_TIME_HHMMSSAMPM );
2518 ImpInsertFormat( aFormatSeq[nIdx],
2519 CLOffset + SetIndexTable( NF_TIME_HHMMSSAMPM, ZF_STANDARD_TIME+3 ));
2520
2521 // [HH]:MM:SS
2522 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_TIME_HH_MMSS );
2523 ImpInsertFormat( aFormatSeq[nIdx],
2524 CLOffset + SetIndexTable( NF_TIME_HH_MMSS, ZF_STANDARD_TIME+4 ));
2525
2526 // MM:SS,00
2527 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_TIME_MMSS00 );
2528 ImpInsertFormat( aFormatSeq[nIdx],
2529 CLOffset + SetIndexTable( NF_TIME_MMSS00, ZF_STANDARD_TIME+5 ));
2530
2531 // [HH]:MM:SS,00
2532 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_TIME_HH_MMSS00 );
2533 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2534 CLOffset + SetIndexTable( NF_TIME_HH_MMSS00, ZF_STANDARD_TIME+6 ),
2535 SV_NUMBERFORMATTER_VERSION_NF_TIME_HH_MMSS00 );
2536
2537
2538
2539 // DateTime
2540 aFormatSeq = aNumberFormatCode.getAllFormatCode( i18n::KNumberFormatUsage::DATE_TIME );
2541 ImpAdjustFormatCodeDefault( aFormatSeq.getArray(), aFormatSeq.getLength() );
2542
2543 // DD.MM.YY HH:MM System
2544 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATETIME_SYSTEM_SHORT_HHMM );
2545 ImpInsertFormat( aFormatSeq[nIdx],
2546 CLOffset + SetIndexTable( NF_DATETIME_SYSTEM_SHORT_HHMM, ZF_STANDARD_DATETIME ));
2547
2548 // DD.MM.YYYY HH:MM:SS System
2549 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_DATETIME_SYS_DDMMYYYY_HHMMSS );
2550 ImpInsertNewStandardFormat( aFormatSeq[nIdx],
2551 CLOffset + SetIndexTable( NF_DATETIME_SYS_DDMMYYYY_HHMMSS, ZF_STANDARD_DATETIME+1 ),
2552 SV_NUMBERFORMATTER_VERSION_NF_DATETIME_SYS_DDMMYYYY_HHMMSS );
2553
2554
2555
2556 // Scientific number
2557 aFormatSeq = aNumberFormatCode.getAllFormatCode( i18n::KNumberFormatUsage::SCIENTIFIC_NUMBER );
2558 ImpAdjustFormatCodeDefault( aFormatSeq.getArray(), aFormatSeq.getLength() );
2559
2560 // 0.00E+000
2561 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_SCIENTIFIC_000E000 );
2562 ImpInsertFormat( aFormatSeq[nIdx],
2563 CLOffset + SetIndexTable( NF_SCIENTIFIC_000E000, ZF_STANDARD_SCIENTIFIC ));
2564
2565 // 0.00E+00
2566 nIdx = ImpGetFormatCodeIndex( aFormatSeq, NF_SCIENTIFIC_000E00 );
2567 ImpInsertFormat( aFormatSeq[nIdx],
2568 CLOffset + SetIndexTable( NF_SCIENTIFIC_000E00, ZF_STANDARD_SCIENTIFIC+1 ));
2569
2570
2571
2572 // Fraction number (no default option)
2573 i18n::NumberFormatCode aSingleFormatCode;
2574
2575 // # ?/?
2576 aSingleFormatCode.Code = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "# ?/?" ) );
2577 String s25( RTL_CONSTASCII_USTRINGPARAM( "# ?/?" ) ); // # ?/?
2578 ImpInsertFormat( aSingleFormatCode,
2579 CLOffset + SetIndexTable( NF_FRACTION_1, ZF_STANDARD_FRACTION ));
2580
2581 // # ??/??
2582 //! "??/" would be interpreted by the compiler as a trigraph for '\'
2583 aSingleFormatCode.Code = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "# ?\?/?\?" ) );
2584 ImpInsertFormat( aSingleFormatCode,
2585 CLOffset + SetIndexTable( NF_FRACTION_2, ZF_STANDARD_FRACTION+1 ));
2586
2587 // Week of year must be appended here because of nNewExtended
2588 const NfKeywordTable & rKeyword = pFormatScanner->GetKeywords();
2589 aSingleFormatCode.Code = rKeyword[NF_KEY_WW];
2590 ImpInsertNewStandardFormat( aSingleFormatCode,
2591 CLOffset + SetIndexTable( NF_DATE_WW, nNewExtended++ ),
2592 SV_NUMBERFORMATTER_VERSION_NF_DATE_WW );
2593
2594
2595
2596 bIndexTableInitialized = sal_True;
2597 DBG_ASSERT( nNewExtended <= ZF_STANDARD_NEWEXTENDEDMAX,
2598 "ImpGenerateFormats: overflow of nNewExtended standard formats" );
2599
2600 // Now all additional format codes provided by I18N, but only if not
2601 // loading from old SO5 file format, then they are appended last.
2602 if ( !bLoadingSO5 )
2603 ImpGenerateAdditionalFormats( CLOffset, aNumberFormatCode, sal_False );
2604
2605 if (bOldConvertMode)
2606 pFormatScanner->SetConvertMode(sal_True);
2607 }
2608
2609
ImpGenerateAdditionalFormats(sal_uInt32 CLOffset,NumberFormatCodeWrapper & rNumberFormatCode,sal_Bool bAfterLoadingSO5)2610 void SvNumberFormatter::ImpGenerateAdditionalFormats( sal_uInt32 CLOffset,
2611 NumberFormatCodeWrapper& rNumberFormatCode, sal_Bool bAfterLoadingSO5 )
2612 {
2613 using namespace ::com::sun::star;
2614
2615 SvNumberformat* pStdFormat =
2616 (SvNumberformat*) aFTable.Get( CLOffset + ZF_STANDARD );
2617 if ( !pStdFormat )
2618 {
2619 DBG_ERRORFILE( "ImpGenerateAdditionalFormats: no GENERAL format" );
2620 return ;
2621 }
2622 sal_uInt32 nPos = CLOffset + pStdFormat->GetLastInsertKey();
2623 rNumberFormatCode.setLocale( GetLocale() );
2624 sal_Int32 j;
2625
2626 // All currencies, this time with [$...] which was stripped in
2627 // ImpGenerateFormats for old "automatic" currency formats.
2628 uno::Sequence< i18n::NumberFormatCode > aFormatSeq =
2629 rNumberFormatCode.getAllFormatCode( i18n::KNumberFormatUsage::CURRENCY );
2630 i18n::NumberFormatCode * pFormatArr = aFormatSeq.getArray();
2631 sal_Int32 nCodes = aFormatSeq.getLength();
2632 ImpAdjustFormatCodeDefault( aFormatSeq.getArray(), nCodes );
2633 for ( j = 0; j < nCodes; j++ )
2634 {
2635 if ( nPos - CLOffset >= SV_COUNTRY_LANGUAGE_OFFSET )
2636 {
2637 DBG_ERRORFILE( "ImpGenerateAdditionalFormats: too many formats" );
2638 break; // for
2639 }
2640 if ( pFormatArr[j].Index < NF_INDEX_TABLE_ENTRIES &&
2641 pFormatArr[j].Index != NF_CURRENCY_1000DEC2_CCC )
2642 { // Insert only if not already inserted, but internal index must be
2643 // above so ImpInsertFormat can distinguish it.
2644 sal_Int16 nOrgIndex = pFormatArr[j].Index;
2645 pFormatArr[j].Index = sal::static_int_cast< sal_Int16 >(
2646 pFormatArr[j].Index + nCodes + NF_INDEX_TABLE_ENTRIES);
2647 //! no default on currency
2648 sal_Bool bDefault = aFormatSeq[j].Default;
2649 aFormatSeq[j].Default = sal_False;
2650 if ( ImpInsertNewStandardFormat( pFormatArr[j], nPos+1,
2651 SV_NUMBERFORMATTER_VERSION_ADDITIONAL_I18N_FORMATS,
2652 bAfterLoadingSO5, nOrgIndex ) )
2653 nPos++;
2654 pFormatArr[j].Index = nOrgIndex;
2655 aFormatSeq[j].Default = bDefault;
2656 }
2657 }
2658
2659 // all additional format codes provided by I18N that are not old standard index
2660 aFormatSeq = rNumberFormatCode.getAllFormatCodes();
2661 nCodes = aFormatSeq.getLength();
2662 if ( nCodes )
2663 {
2664 pFormatArr = aFormatSeq.getArray();
2665 // don't check ALL
2666 sal_Int32 nDef = ImpAdjustFormatCodeDefault( pFormatArr, nCodes, sal_False);
2667 // don't have any defaults here
2668 pFormatArr[nDef].Default = sal_False;
2669 for ( j = 0; j < nCodes; j++ )
2670 {
2671 if ( nPos - CLOffset >= SV_COUNTRY_LANGUAGE_OFFSET )
2672 {
2673 DBG_ERRORFILE( "ImpGenerateAdditionalFormats: too many formats" );
2674 break; // for
2675 }
2676 if ( pFormatArr[j].Index >= NF_INDEX_TABLE_ENTRIES )
2677 if ( ImpInsertNewStandardFormat( pFormatArr[j], nPos+1,
2678 SV_NUMBERFORMATTER_VERSION_ADDITIONAL_I18N_FORMATS,
2679 bAfterLoadingSO5 ) )
2680 nPos++;
2681 }
2682 }
2683
2684 pStdFormat->SetLastInsertKey( (sal_uInt16)(nPos - CLOffset) );
2685 }
2686
2687
ImpGetPosCurrFormat(String & sPosStr,const String & rCurrSymbol)2688 void SvNumberFormatter::ImpGetPosCurrFormat( String& sPosStr, const String& rCurrSymbol )
2689 {
2690 NfCurrencyEntry::CompletePositiveFormatString( sPosStr,
2691 rCurrSymbol, xLocaleData->getCurrPositiveFormat() );
2692 }
2693
ImpGetNegCurrFormat(String & sNegStr,const String & rCurrSymbol)2694 void SvNumberFormatter::ImpGetNegCurrFormat( String& sNegStr, const String& rCurrSymbol )
2695 {
2696 NfCurrencyEntry::CompleteNegativeFormatString( sNegStr,
2697 rCurrSymbol, xLocaleData->getCurrNegativeFormat() );
2698 }
2699
GenerateFormat(String & sString,sal_uInt32 nIndex,LanguageType eLnge,sal_Bool bThousand,sal_Bool IsRed,sal_uInt16 nPrecision,sal_uInt16 nAnzLeading)2700 void SvNumberFormatter::GenerateFormat(String& sString,
2701 sal_uInt32 nIndex,
2702 LanguageType eLnge,
2703 sal_Bool bThousand,
2704 sal_Bool IsRed,
2705 sal_uInt16 nPrecision,
2706 sal_uInt16 nAnzLeading)
2707 {
2708 if (eLnge == LANGUAGE_DONTKNOW)
2709 eLnge = IniLnge;
2710 short eType = GetType(nIndex);
2711 sal_uInt16 i;
2712 ImpGenerateCL(eLnge); // ggfs. neu Standard-
2713 // formate anlegen
2714 sString.Erase();
2715
2716 utl::DigitGroupingIterator aGrouping( xLocaleData->getDigitGrouping());
2717 const xub_StrLen nDigitsInFirstGroup = static_cast<xub_StrLen>(aGrouping.get());
2718 const String& rThSep = GetNumThousandSep();
2719 if (nAnzLeading == 0)
2720 {
2721 if (!bThousand)
2722 sString += '#';
2723 else
2724 {
2725 sString += '#';
2726 sString += rThSep;
2727 sString.Expand( sString.Len() + nDigitsInFirstGroup, '#' );
2728 }
2729 }
2730 else
2731 {
2732 for (i = 0; i < nAnzLeading; i++)
2733 {
2734 if (bThousand && i > 0 && i == aGrouping.getPos())
2735 {
2736 sString.Insert( rThSep, 0 );
2737 aGrouping.advance();
2738 }
2739 sString.Insert('0',0);
2740 }
2741 if (bThousand && nAnzLeading < nDigitsInFirstGroup + 1)
2742 {
2743 for (i = nAnzLeading; i < nDigitsInFirstGroup + 1; i++)
2744 {
2745 if (bThousand && i % nDigitsInFirstGroup == 0)
2746 sString.Insert( rThSep, 0 );
2747 sString.Insert('#',0);
2748 }
2749 }
2750 }
2751 if (nPrecision > 0)
2752 {
2753 sString += GetNumDecimalSep();
2754 sString.Expand( sString.Len() + nPrecision, '0' );
2755 }
2756 if (eType == NUMBERFORMAT_PERCENT)
2757 sString += '%';
2758 else if (eType == NUMBERFORMAT_CURRENCY)
2759 {
2760 String sNegStr = sString;
2761 String aCurr;
2762 const NfCurrencyEntry* pEntry;
2763 sal_Bool bBank;
2764 if ( GetNewCurrencySymbolString( nIndex, aCurr, &pEntry, &bBank ) )
2765 {
2766 if ( pEntry )
2767 {
2768 sal_uInt16 nPosiForm = NfCurrencyEntry::GetEffectivePositiveFormat(
2769 xLocaleData->getCurrPositiveFormat(),
2770 pEntry->GetPositiveFormat(), bBank );
2771 sal_uInt16 nNegaForm = NfCurrencyEntry::GetEffectiveNegativeFormat(
2772 xLocaleData->getCurrNegativeFormat(),
2773 pEntry->GetNegativeFormat(), bBank );
2774 pEntry->CompletePositiveFormatString( sString, bBank,
2775 nPosiForm );
2776 pEntry->CompleteNegativeFormatString( sNegStr, bBank,
2777 nNegaForm );
2778 }
2779 else
2780 { // assume currency abbreviation (AKA banking symbol), not symbol
2781 sal_uInt16 nPosiForm = NfCurrencyEntry::GetEffectivePositiveFormat(
2782 xLocaleData->getCurrPositiveFormat(),
2783 xLocaleData->getCurrPositiveFormat(), sal_True );
2784 sal_uInt16 nNegaForm = NfCurrencyEntry::GetEffectiveNegativeFormat(
2785 xLocaleData->getCurrNegativeFormat(),
2786 xLocaleData->getCurrNegativeFormat(), sal_True );
2787 NfCurrencyEntry::CompletePositiveFormatString( sString, aCurr,
2788 nPosiForm );
2789 NfCurrencyEntry::CompleteNegativeFormatString( sNegStr, aCurr,
2790 nNegaForm );
2791 }
2792 }
2793 else
2794 { // "automatic" old style
2795 String aSymbol, aAbbrev;
2796 GetCompatibilityCurrency( aSymbol, aAbbrev );
2797 ImpGetPosCurrFormat( sString, aSymbol );
2798 ImpGetNegCurrFormat( sNegStr, aSymbol );
2799 }
2800 if (IsRed)
2801 {
2802 sString += ';';
2803 sString += '[';
2804 sString += pFormatScanner->GetRedString();
2805 sString += ']';
2806 }
2807 else
2808 sString += ';';
2809 sString += sNegStr;
2810 }
2811 if (IsRed && eType != NUMBERFORMAT_CURRENCY)
2812 {
2813 String sTmpStr = sString;
2814 sTmpStr += ';';
2815 sTmpStr += '[';
2816 sTmpStr += pFormatScanner->GetRedString();
2817 sTmpStr += ']';
2818 sTmpStr += '-';
2819 sTmpStr +=sString;
2820 sString = sTmpStr;
2821 }
2822 }
2823
IsUserDefined(const String & sStr,LanguageType eLnge)2824 sal_Bool SvNumberFormatter::IsUserDefined(const String& sStr,
2825 LanguageType eLnge)
2826 {
2827 if (eLnge == LANGUAGE_DONTKNOW)
2828 eLnge = IniLnge;
2829 sal_uInt32 CLOffset = ImpGenerateCL(eLnge); // ggfs. neu Standard-
2830 // formate anlegen
2831 eLnge = ActLnge;
2832 sal_uInt32 nKey = ImpIsEntry(sStr, CLOffset, eLnge);
2833 if (nKey == NUMBERFORMAT_ENTRY_NOT_FOUND)
2834 return sal_True;
2835 SvNumberformat* pEntry = aFTable.Get(nKey);
2836 if ( pEntry && ((pEntry->GetType() & NUMBERFORMAT_DEFINED) != 0) )
2837 return sal_True;
2838 return sal_False;
2839 }
2840
GetEntryKey(const String & sStr,LanguageType eLnge)2841 sal_uInt32 SvNumberFormatter::GetEntryKey(const String& sStr,
2842 LanguageType eLnge)
2843 {
2844 if (eLnge == LANGUAGE_DONTKNOW)
2845 eLnge = IniLnge;
2846 sal_uInt32 CLOffset = ImpGenerateCL(eLnge); // ggfs. neu Standard-
2847 // formate anlegen
2848 return ImpIsEntry(sStr, CLOffset, eLnge);
2849 }
2850
GetStandardIndex(LanguageType eLnge)2851 sal_uInt32 SvNumberFormatter::GetStandardIndex(LanguageType eLnge)
2852 {
2853 if (eLnge == LANGUAGE_DONTKNOW)
2854 eLnge = IniLnge;
2855 return GetStandardFormat(NUMBERFORMAT_NUMBER, eLnge);
2856 }
2857
GetType(sal_uInt32 nFIndex)2858 short SvNumberFormatter::GetType(sal_uInt32 nFIndex)
2859 {
2860 short eType;
2861 SvNumberformat* pFormat = (SvNumberformat*) aFTable.Get(nFIndex);
2862 if (!pFormat)
2863 eType = NUMBERFORMAT_UNDEFINED;
2864 else
2865 {
2866 eType = pFormat->GetType() &~NUMBERFORMAT_DEFINED;
2867 if (eType == 0)
2868 eType = NUMBERFORMAT_DEFINED;
2869 }
2870 return eType;
2871 }
2872
ClearMergeTable()2873 void SvNumberFormatter::ClearMergeTable()
2874 {
2875 if ( pMergeTable )
2876 {
2877 sal_uInt32* pIndex = (sal_uInt32*) pMergeTable->First();
2878 while (pIndex)
2879 {
2880 delete pIndex;
2881 pIndex = pMergeTable->Next();
2882 }
2883 pMergeTable->Clear();
2884 }
2885 }
2886
MergeFormatter(SvNumberFormatter & rTable)2887 SvNumberFormatterIndexTable* SvNumberFormatter::MergeFormatter(SvNumberFormatter& rTable)
2888 {
2889 if ( pMergeTable )
2890 ClearMergeTable();
2891 else
2892 pMergeTable = new SvNumberFormatterIndexTable;
2893 sal_uInt32 nCLOffset = 0;
2894 sal_uInt32 nOldKey, nOffset, nNewKey;
2895 sal_uInt32* pNewIndex;
2896 SvNumberformat* pNewEntry;
2897 SvNumberformat* pFormat = rTable.aFTable.First();
2898 while (pFormat)
2899 {
2900 nOldKey = rTable.aFTable.GetCurKey();
2901 nOffset = nOldKey % SV_COUNTRY_LANGUAGE_OFFSET; // relativIndex
2902 if (nOffset == 0) // 1. Format von CL
2903 nCLOffset = ImpGenerateCL(pFormat->GetLanguage());
2904
2905 if (nOffset <= SV_MAX_ANZ_STANDARD_FORMATE) // Std.form.
2906 {
2907 nNewKey = nCLOffset + nOffset;
2908 if (!aFTable.Get(nNewKey)) // noch nicht da
2909 {
2910 // pNewEntry = new SvNumberformat(*pFormat); // Copy reicht nicht !!!
2911 pNewEntry = new SvNumberformat( *pFormat, *pFormatScanner );
2912 if (!aFTable.Insert(nNewKey, pNewEntry))
2913 delete pNewEntry;
2914 }
2915 if (nNewKey != nOldKey) // neuer Index
2916 {
2917 pNewIndex = new sal_uInt32(nNewKey);
2918 if (!pMergeTable->Insert(nOldKey,pNewIndex))
2919 delete pNewIndex;
2920 }
2921 }
2922 else // benutzerdef.
2923 {
2924 // pNewEntry = new SvNumberformat(*pFormat); // Copy reicht nicht !!!
2925 pNewEntry = new SvNumberformat( *pFormat, *pFormatScanner );
2926 nNewKey = ImpIsEntry(pNewEntry->GetFormatstring(),
2927 nCLOffset,
2928 pFormat->GetLanguage());
2929 if (nNewKey != NUMBERFORMAT_ENTRY_NOT_FOUND) // schon vorhanden
2930 delete pNewEntry;
2931 else
2932 {
2933 SvNumberformat* pStdFormat =
2934 (SvNumberformat*) aFTable.Get(nCLOffset + ZF_STANDARD);
2935 sal_uInt32 nPos = nCLOffset + pStdFormat->GetLastInsertKey();
2936 nNewKey = nPos+1;
2937 if (nPos - nCLOffset >= SV_COUNTRY_LANGUAGE_OFFSET)
2938 {
2939 DBG_ERROR(
2940 "SvNumberFormatter:: Zu viele Formate pro CL");
2941 delete pNewEntry;
2942 }
2943 else if (!aFTable.Insert(nNewKey, pNewEntry))
2944 delete pNewEntry;
2945 else
2946 pStdFormat->SetLastInsertKey((sal_uInt16) (nNewKey - nCLOffset));
2947 }
2948 if (nNewKey != nOldKey) // neuer Index
2949 {
2950 pNewIndex = new sal_uInt32(nNewKey);
2951 if (!pMergeTable->Insert(nOldKey,pNewIndex))
2952 delete pNewIndex;
2953 }
2954 }
2955 pFormat = rTable.aFTable.Next();
2956 }
2957 return pMergeTable;
2958 }
2959
2960
ConvertMergeTableToMap()2961 SvNumberFormatterMergeMap SvNumberFormatter::ConvertMergeTableToMap()
2962 {
2963 if (!HasMergeFmtTbl())
2964 return SvNumberFormatterMergeMap();
2965
2966 SvNumberFormatterMergeMap aMap;
2967 for (sal_uInt32* pIndex = pMergeTable->First(); pIndex; pIndex = pMergeTable->Next())
2968 {
2969 sal_uInt32 nOldKey = pMergeTable->GetCurKey();
2970 aMap.insert( SvNumberFormatterMergeMap::value_type( nOldKey, *pIndex));
2971 }
2972 ClearMergeTable();
2973 return aMap;
2974 }
2975
2976
GetFormatForLanguageIfBuiltIn(sal_uInt32 nFormat,LanguageType eLnge)2977 sal_uInt32 SvNumberFormatter::GetFormatForLanguageIfBuiltIn( sal_uInt32 nFormat,
2978 LanguageType eLnge )
2979 {
2980 if ( eLnge == LANGUAGE_DONTKNOW )
2981 eLnge = IniLnge;
2982 if ( nFormat < SV_COUNTRY_LANGUAGE_OFFSET && eLnge == IniLnge )
2983 return nFormat; // es bleibt wie es ist
2984 sal_uInt32 nOffset = nFormat % SV_COUNTRY_LANGUAGE_OFFSET; // relativIndex
2985 if ( nOffset > SV_MAX_ANZ_STANDARD_FORMATE )
2986 return nFormat; // kein eingebautes Format
2987 sal_uInt32 nCLOffset = ImpGenerateCL(eLnge); // ggbf. generieren
2988 return nCLOffset + nOffset;
2989 }
2990
2991
GetFormatIndex(NfIndexTableOffset nTabOff,LanguageType eLnge)2992 sal_uInt32 SvNumberFormatter::GetFormatIndex( NfIndexTableOffset nTabOff,
2993 LanguageType eLnge )
2994 {
2995 if ( nTabOff >= NF_INDEX_TABLE_ENTRIES
2996 || theIndexTable[nTabOff] == NUMBERFORMAT_ENTRY_NOT_FOUND )
2997 return NUMBERFORMAT_ENTRY_NOT_FOUND;
2998 if ( eLnge == LANGUAGE_DONTKNOW )
2999 eLnge = IniLnge;
3000 sal_uInt32 nCLOffset = ImpGenerateCL(eLnge); // ggbf. generieren
3001 return nCLOffset + theIndexTable[nTabOff];
3002 }
3003
3004
GetIndexTableOffset(sal_uInt32 nFormat) const3005 NfIndexTableOffset SvNumberFormatter::GetIndexTableOffset( sal_uInt32 nFormat ) const
3006 {
3007 sal_uInt32 nOffset = nFormat % SV_COUNTRY_LANGUAGE_OFFSET; // relativIndex
3008 if ( nOffset > SV_MAX_ANZ_STANDARD_FORMATE )
3009 return NF_INDEX_TABLE_ENTRIES; // kein eingebautes Format
3010 for ( sal_uInt16 j = 0; j < NF_INDEX_TABLE_ENTRIES; j++ )
3011 {
3012 if ( theIndexTable[j] == nOffset )
3013 return (NfIndexTableOffset) j;
3014 }
3015 return NF_INDEX_TABLE_ENTRIES; // bad luck
3016 }
3017
3018
SetYear2000(sal_uInt16 nVal)3019 void SvNumberFormatter::SetYear2000( sal_uInt16 nVal )
3020 {
3021 pStringScanner->SetYear2000( nVal );
3022 }
3023
3024
GetYear2000() const3025 sal_uInt16 SvNumberFormatter::GetYear2000() const
3026 {
3027 return pStringScanner->GetYear2000();
3028 }
3029
3030
ExpandTwoDigitYear(sal_uInt16 nYear) const3031 sal_uInt16 SvNumberFormatter::ExpandTwoDigitYear( sal_uInt16 nYear ) const
3032 {
3033 if ( nYear < 100 )
3034 return SvNumberFormatter::ExpandTwoDigitYear( nYear,
3035 pStringScanner->GetYear2000() );
3036 return nYear;
3037 }
3038
3039
3040 // static
GetYear2000Default()3041 sal_uInt16 SvNumberFormatter::GetYear2000Default()
3042 {
3043 return (sal_uInt16) ::utl::MiscCfg().GetYear2000();
3044 }
3045
GetTrueString()3046 const String& SvNumberFormatter::GetTrueString(){return pFormatScanner->GetTrueString();}
GetFalseString()3047 const String& SvNumberFormatter::GetFalseString(){return pFormatScanner->GetFalseString();}
3048
3049 // static
GetTheCurrencyTable()3050 const NfCurrencyTable& SvNumberFormatter::GetTheCurrencyTable()
3051 {
3052 ::osl::MutexGuard aGuard( GetMutex() );
3053 while ( !bCurrencyTableInitialized )
3054 ImpInitCurrencyTable();
3055 return theCurrencyTable::get();
3056 }
3057
3058
3059 // static
MatchSystemCurrency()3060 const NfCurrencyEntry* SvNumberFormatter::MatchSystemCurrency()
3061 {
3062 // MUST call GetTheCurrencyTable() before accessing nSystemCurrencyPosition
3063 const NfCurrencyTable& rTable = GetTheCurrencyTable();
3064 return nSystemCurrencyPosition ? rTable[nSystemCurrencyPosition] : NULL;
3065 }
3066
3067
3068 // static
GetCurrencyEntry(LanguageType eLang)3069 const NfCurrencyEntry& SvNumberFormatter::GetCurrencyEntry( LanguageType eLang )
3070 {
3071 if ( eLang == LANGUAGE_SYSTEM )
3072 {
3073 const NfCurrencyEntry* pCurr = MatchSystemCurrency();
3074 return pCurr ? *pCurr : *(GetTheCurrencyTable()[0]);
3075 }
3076 else
3077 {
3078 eLang = MsLangId::getRealLanguage( eLang );
3079 const NfCurrencyTable& rTable = GetTheCurrencyTable();
3080 sal_uInt16 nCount = rTable.Count();
3081 const NfCurrencyEntryPtr* ppData = rTable.GetData();
3082 for ( sal_uInt16 j = 0; j < nCount; j++, ppData++ )
3083 {
3084 if ( (*ppData)->GetLanguage() == eLang )
3085 return **ppData;
3086 }
3087 return *(rTable[0]);
3088 }
3089 }
3090
3091
3092 // static
GetCurrencyEntry(const String & rAbbrev,LanguageType eLang)3093 const NfCurrencyEntry* SvNumberFormatter::GetCurrencyEntry(
3094 const String& rAbbrev, LanguageType eLang )
3095 {
3096 eLang = MsLangId::getRealLanguage( eLang );
3097 const NfCurrencyTable& rTable = GetTheCurrencyTable();
3098 sal_uInt16 nCount = rTable.Count();
3099 const NfCurrencyEntryPtr* ppData = rTable.GetData();
3100 for ( sal_uInt16 j = 0; j < nCount; j++, ppData++ )
3101 {
3102 if ( (*ppData)->GetLanguage() == eLang &&
3103 (*ppData)->GetBankSymbol() == rAbbrev )
3104 return *ppData;
3105 }
3106 return NULL;
3107 }
3108
3109
3110 // static
GetLegacyOnlyCurrencyEntry(const String & rSymbol,const String & rAbbrev)3111 const NfCurrencyEntry* SvNumberFormatter::GetLegacyOnlyCurrencyEntry(
3112 const String& rSymbol, const String& rAbbrev )
3113 {
3114 if (!bCurrencyTableInitialized)
3115 GetTheCurrencyTable(); // just for initialization
3116 const NfCurrencyTable& rTable = theLegacyOnlyCurrencyTable::get();
3117 sal_uInt16 nCount = rTable.Count();
3118 const NfCurrencyEntryPtr* ppData = rTable.GetData();
3119 for ( sal_uInt16 j = 0; j < nCount; j++, ppData++ )
3120 {
3121 if ( (*ppData)->GetSymbol() == rSymbol &&
3122 (*ppData)->GetBankSymbol() == rAbbrev )
3123 return *ppData;
3124 }
3125 return NULL;
3126 }
3127
3128
3129 // static
IMPL_STATIC_LINK_NOINSTANCE(SvNumberFormatter,CurrencyChangeLink,void *,EMPTYARG)3130 IMPL_STATIC_LINK_NOINSTANCE( SvNumberFormatter, CurrencyChangeLink, void*, EMPTYARG )
3131 {
3132 ::osl::MutexGuard aGuard( GetMutex() );
3133 String aAbbrev;
3134 LanguageType eLang = LANGUAGE_SYSTEM;
3135 SvtSysLocaleOptions().GetCurrencyAbbrevAndLanguage( aAbbrev, eLang );
3136 SetDefaultSystemCurrency( aAbbrev, eLang );
3137 return 0;
3138 }
3139
3140
3141 // static
SetDefaultSystemCurrency(const String & rAbbrev,LanguageType eLang)3142 void SvNumberFormatter::SetDefaultSystemCurrency( const String& rAbbrev, LanguageType eLang )
3143 {
3144 ::osl::MutexGuard aGuard( GetMutex() );
3145 if ( eLang == LANGUAGE_SYSTEM )
3146 eLang = SvtSysLocale().GetLanguage();
3147 const NfCurrencyTable& rTable = GetTheCurrencyTable();
3148 sal_uInt16 nCount = rTable.Count();
3149 const NfCurrencyEntryPtr* ppData = rTable.GetData();
3150 if ( rAbbrev.Len() )
3151 {
3152 for ( sal_uInt16 j = 0; j < nCount; j++, ppData++ )
3153 {
3154 if ( (*ppData)->GetLanguage() == eLang && (*ppData)->GetBankSymbol() == rAbbrev )
3155 {
3156 nSystemCurrencyPosition = j;
3157 return ;
3158 }
3159 }
3160 }
3161 else
3162 {
3163 for ( sal_uInt16 j = 0; j < nCount; j++, ppData++ )
3164 {
3165 if ( (*ppData)->GetLanguage() == eLang )
3166 {
3167 nSystemCurrencyPosition = j;
3168 return ;
3169 }
3170 }
3171 }
3172 nSystemCurrencyPosition = 0; // not found => simple SYSTEM
3173 }
3174
3175
ResetDefaultSystemCurrency()3176 void SvNumberFormatter::ResetDefaultSystemCurrency()
3177 {
3178 nDefaultSystemCurrencyFormat = NUMBERFORMAT_ENTRY_NOT_FOUND;
3179 }
3180
3181
ImpGetDefaultSystemCurrencyFormat()3182 sal_uInt32 SvNumberFormatter::ImpGetDefaultSystemCurrencyFormat()
3183 {
3184 if ( nDefaultSystemCurrencyFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
3185 {
3186 xub_StrLen nCheck;
3187 short nType;
3188 NfWSStringsDtor aCurrList;
3189 sal_uInt16 nDefault = GetCurrencyFormatStrings( aCurrList,
3190 GetCurrencyEntry( LANGUAGE_SYSTEM ), sal_False );
3191 DBG_ASSERT( aCurrList.Count(), "where is the NewCurrency System standard format?!?" );
3192 // if already loaded or user defined nDefaultSystemCurrencyFormat
3193 // will be set to the right value
3194 PutEntry( *aCurrList.GetObject( nDefault ), nCheck, nType,
3195 nDefaultSystemCurrencyFormat, LANGUAGE_SYSTEM );
3196 DBG_ASSERT( nCheck == 0, "NewCurrency CheckError" );
3197 DBG_ASSERT( nDefaultSystemCurrencyFormat != NUMBERFORMAT_ENTRY_NOT_FOUND,
3198 "nDefaultSystemCurrencyFormat == NUMBERFORMAT_ENTRY_NOT_FOUND" );
3199 }
3200 return nDefaultSystemCurrencyFormat;
3201 }
3202
3203
ImpGetDefaultCurrencyFormat()3204 sal_uInt32 SvNumberFormatter::ImpGetDefaultCurrencyFormat()
3205 {
3206 sal_uInt32 CLOffset = ImpGetCLOffset( ActLnge );
3207 sal_uInt32 nDefaultCurrencyFormat =
3208 (sal_uInt32)(sal_uLong) aDefaultFormatKeys.Get( CLOffset + ZF_STANDARD_CURRENCY );
3209 if ( !nDefaultCurrencyFormat )
3210 nDefaultCurrencyFormat = NUMBERFORMAT_ENTRY_NOT_FOUND;
3211 if ( nDefaultCurrencyFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
3212 {
3213 // look for a defined standard
3214 sal_uInt32 nStopKey = CLOffset + SV_COUNTRY_LANGUAGE_OFFSET;
3215 sal_uInt32 nKey;
3216 aFTable.Seek( CLOffset );
3217 while ( (nKey = aFTable.GetCurKey()) >= CLOffset && nKey < nStopKey )
3218 {
3219 const SvNumberformat* pEntry =
3220 (const SvNumberformat*) aFTable.GetCurObject();
3221 if ( pEntry->IsStandard() && (pEntry->GetType() & NUMBERFORMAT_CURRENCY) )
3222 {
3223 nDefaultCurrencyFormat = nKey;
3224 break; // while
3225 }
3226 aFTable.Next();
3227 }
3228
3229 if ( nDefaultCurrencyFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
3230 { // none found, create one
3231 xub_StrLen nCheck;
3232 short nType;
3233 NfWSStringsDtor aCurrList;
3234 sal_uInt16 nDefault = GetCurrencyFormatStrings( aCurrList,
3235 GetCurrencyEntry( ActLnge ), sal_False );
3236 DBG_ASSERT( aCurrList.Count(), "where is the NewCurrency standard format?" );
3237 if ( aCurrList.Count() )
3238 {
3239 // if already loaded or user defined nDefaultSystemCurrencyFormat
3240 // will be set to the right value
3241 PutEntry( *aCurrList.GetObject( nDefault ), nCheck, nType,
3242 nDefaultCurrencyFormat, ActLnge );
3243 DBG_ASSERT( nCheck == 0, "NewCurrency CheckError" );
3244 DBG_ASSERT( nDefaultCurrencyFormat != NUMBERFORMAT_ENTRY_NOT_FOUND,
3245 "nDefaultCurrencyFormat == NUMBERFORMAT_ENTRY_NOT_FOUND" );
3246 }
3247 // old automatic currency format as a last resort
3248 if ( nDefaultCurrencyFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
3249 nDefaultCurrencyFormat = CLOffset + ZF_STANDARD_CURRENCY+3;
3250 else
3251 { // mark as standard so that it is found next time
3252 SvNumberformat* pEntry = aFTable.Get( nDefaultCurrencyFormat );
3253 if ( pEntry )
3254 pEntry->SetStandard();
3255 }
3256 }
3257 aDefaultFormatKeys.Insert( CLOffset + ZF_STANDARD_CURRENCY,
3258 (void*) nDefaultCurrencyFormat );
3259 }
3260 return nDefaultCurrencyFormat;
3261 }
3262
3263
3264 // static
3265 // try to make it inline if possible since this a loop body
3266 // sal_True: continue; sal_False: break loop, if pFoundEntry==NULL dupe found
3267 #ifndef DBG_UTIL
3268 inline
3269 #endif
ImpLookupCurrencyEntryLoopBody(const NfCurrencyEntry * & pFoundEntry,sal_Bool & bFoundBank,const NfCurrencyEntry * pData,sal_uInt16 nPos,const String & rSymbol)3270 sal_Bool SvNumberFormatter::ImpLookupCurrencyEntryLoopBody(
3271 const NfCurrencyEntry*& pFoundEntry, sal_Bool& bFoundBank,
3272 const NfCurrencyEntry* pData, sal_uInt16 nPos, const String& rSymbol )
3273 {
3274 sal_Bool bFound;
3275 if ( pData->GetSymbol() == rSymbol )
3276 {
3277 bFound = sal_True;
3278 bFoundBank = sal_False;
3279 }
3280 else if ( pData->GetBankSymbol() == rSymbol )
3281 {
3282 bFound = sal_True;
3283 bFoundBank = sal_True;
3284 }
3285 else
3286 bFound = sal_False;
3287 if ( bFound )
3288 {
3289 if ( pFoundEntry && pFoundEntry != pData )
3290 {
3291 pFoundEntry = NULL;
3292 return sal_False; // break loop, not unique
3293 }
3294 if ( nPos == 0 )
3295 { // first entry is SYSTEM
3296 pFoundEntry = MatchSystemCurrency();
3297 if ( pFoundEntry )
3298 return sal_False; // break loop
3299 // even if there are more matching entries
3300 // this one is probably the one we are looking for
3301 else
3302 pFoundEntry = pData;
3303 }
3304 else
3305 pFoundEntry = pData;
3306 }
3307 return sal_True;
3308 }
3309
3310
GetNewCurrencySymbolString(sal_uInt32 nFormat,String & rStr,const NfCurrencyEntry ** ppEntry,sal_Bool * pBank) const3311 sal_Bool SvNumberFormatter::GetNewCurrencySymbolString( sal_uInt32 nFormat,
3312 String& rStr, const NfCurrencyEntry** ppEntry /* = NULL */,
3313 sal_Bool* pBank /* = NULL */ ) const
3314 {
3315 rStr.Erase();
3316 if ( ppEntry )
3317 *ppEntry = NULL;
3318 if ( pBank )
3319 *pBank = sal_False;
3320 SvNumberformat* pFormat = (SvNumberformat*) aFTable.Get( nFormat );
3321 if ( pFormat )
3322 {
3323 String aSymbol, aExtension;
3324 if ( pFormat->GetNewCurrencySymbol( aSymbol, aExtension ) )
3325 {
3326 if ( ppEntry )
3327 {
3328 sal_Bool bFoundBank = sal_False;
3329 // we definitely need an entry matching the format code string
3330 const NfCurrencyEntry* pFoundEntry = GetCurrencyEntry(
3331 bFoundBank, aSymbol, aExtension, pFormat->GetLanguage(),
3332 sal_True );
3333 if ( pFoundEntry )
3334 {
3335 *ppEntry = pFoundEntry;
3336 if ( pBank )
3337 *pBank = bFoundBank;
3338 pFoundEntry->BuildSymbolString( rStr, bFoundBank );
3339 }
3340 }
3341 if ( !rStr.Len() )
3342 { // analog zu BuildSymbolString
3343 rStr = '[';
3344 rStr += '$';
3345 if ( aSymbol.Search( '-' ) != STRING_NOTFOUND ||
3346 aSymbol.Search( ']' ) != STRING_NOTFOUND )
3347 {
3348 rStr += '"';
3349 rStr += aSymbol;
3350 rStr += '"';
3351 }
3352 else
3353 rStr += aSymbol;
3354 if ( aExtension.Len() )
3355 rStr += aExtension;
3356 rStr += ']';
3357 }
3358 return sal_True;
3359 }
3360 }
3361 return sal_False;
3362 }
3363
3364
3365 // static
GetCurrencyEntry(sal_Bool & bFoundBank,const String & rSymbol,const String & rExtension,LanguageType eFormatLanguage,sal_Bool bOnlyStringLanguage)3366 const NfCurrencyEntry* SvNumberFormatter::GetCurrencyEntry( sal_Bool & bFoundBank,
3367 const String& rSymbol, const String& rExtension,
3368 LanguageType eFormatLanguage, sal_Bool bOnlyStringLanguage )
3369 {
3370 xub_StrLen nExtLen = rExtension.Len();
3371 LanguageType eExtLang;
3372 if ( nExtLen )
3373 {
3374 sal_Int32 nExtLang = ::rtl::OUString( rExtension ).toInt32( 16 );
3375 if ( !nExtLang )
3376 eExtLang = LANGUAGE_DONTKNOW;
3377 else
3378 eExtLang = (LanguageType) ((nExtLang < 0) ?
3379 -nExtLang : nExtLang);
3380 }
3381 else
3382 eExtLang = LANGUAGE_DONTKNOW;
3383 const NfCurrencyEntry* pFoundEntry = NULL;
3384 const NfCurrencyTable& rTable = GetTheCurrencyTable();
3385 sal_uInt16 nCount = rTable.Count();
3386 sal_Bool bCont = sal_True;
3387
3388 // first try with given extension language/country
3389 if ( nExtLen )
3390 {
3391 const NfCurrencyEntryPtr* ppData = rTable.GetData();
3392 for ( sal_uInt16 j = 0; j < nCount && bCont; j++, ppData++ )
3393 {
3394 LanguageType eLang = (*ppData)->GetLanguage();
3395 if ( eLang == eExtLang ||
3396 ((eExtLang == LANGUAGE_DONTKNOW) &&
3397 (eLang == LANGUAGE_SYSTEM))
3398 )
3399 {
3400 bCont = ImpLookupCurrencyEntryLoopBody( pFoundEntry, bFoundBank,
3401 *ppData, j, rSymbol );
3402 }
3403 }
3404 }
3405
3406 // ok?
3407 if ( pFoundEntry || !bCont || (bOnlyStringLanguage && nExtLen) )
3408 return pFoundEntry;
3409
3410 if ( !bOnlyStringLanguage )
3411 {
3412 // now try the language/country of the number format
3413 const NfCurrencyEntryPtr* ppData = rTable.GetData();
3414 for ( sal_uInt16 j = 0; j < nCount && bCont; j++, ppData++ )
3415 {
3416 LanguageType eLang = (*ppData)->GetLanguage();
3417 if ( eLang == eFormatLanguage ||
3418 ((eFormatLanguage == LANGUAGE_DONTKNOW) &&
3419 (eLang == LANGUAGE_SYSTEM))
3420 )
3421 {
3422 bCont = ImpLookupCurrencyEntryLoopBody( pFoundEntry, bFoundBank,
3423 *ppData, j, rSymbol );
3424 }
3425 }
3426
3427 // ok?
3428 if ( pFoundEntry || !bCont )
3429 return pFoundEntry;
3430 }
3431
3432 // then try without language/country if no extension specified
3433 if ( !nExtLen )
3434 {
3435 const NfCurrencyEntryPtr* ppData = rTable.GetData();
3436 for ( sal_uInt16 j = 0; j < nCount && bCont; j++, ppData++ )
3437 {
3438 bCont = ImpLookupCurrencyEntryLoopBody( pFoundEntry, bFoundBank,
3439 *ppData, j, rSymbol );
3440 }
3441 }
3442
3443 return pFoundEntry;
3444 }
3445
3446
GetCompatibilityCurrency(String & rSymbol,String & rAbbrev) const3447 void SvNumberFormatter::GetCompatibilityCurrency( String& rSymbol, String& rAbbrev ) const
3448 {
3449 ::com::sun::star::uno::Sequence< ::com::sun::star::i18n::Currency2 >
3450 xCurrencies = xLocaleData->getAllCurrencies();
3451 sal_Int32 nCurrencies = xCurrencies.getLength();
3452 sal_Int32 j;
3453 for ( j=0; j < nCurrencies; ++j )
3454 {
3455 if ( xCurrencies[j].UsedInCompatibleFormatCodes )
3456 {
3457 rSymbol = xCurrencies[j].Symbol;
3458 rAbbrev = xCurrencies[j].BankSymbol;
3459 break;
3460 }
3461 }
3462 if ( j >= nCurrencies )
3463 {
3464 if (LocaleDataWrapper::areChecksEnabled())
3465 {
3466 String aMsg( RTL_CONSTASCII_USTRINGPARAM(
3467 "GetCompatibilityCurrency: none?"));
3468 LocaleDataWrapper::outputCheckMessage(
3469 xLocaleData->appendLocaleInfo( aMsg));
3470 }
3471 rSymbol = xLocaleData->getCurrSymbol();
3472 rAbbrev = xLocaleData->getCurrBankSymbol();
3473 }
3474 }
3475
3476
lcl_CheckCurrencySymbolPosition(const NfCurrencyEntry & rCurr)3477 void lcl_CheckCurrencySymbolPosition( const NfCurrencyEntry& rCurr )
3478 {
3479 short nPos = -1; // -1:=unknown, 0:=vorne, 1:=hinten
3480 short nNeg = -1;
3481 switch ( rCurr.GetPositiveFormat() )
3482 {
3483 case 0: // $1
3484 nPos = 0;
3485 break;
3486 case 1: // 1$
3487 nPos = 1;
3488 break;
3489 case 2: // $ 1
3490 nPos = 0;
3491 break;
3492 case 3: // 1 $
3493 nPos = 1;
3494 break;
3495 default:
3496 LocaleDataWrapper::outputCheckMessage(
3497 "lcl_CheckCurrencySymbolPosition: unknown PositiveFormat");
3498 break;
3499 }
3500 switch ( rCurr.GetNegativeFormat() )
3501 {
3502 case 0: // ($1)
3503 nNeg = 0;
3504 break;
3505 case 1: // -$1
3506 nNeg = 0;
3507 break;
3508 case 2: // $-1
3509 nNeg = 0;
3510 break;
3511 case 3: // $1-
3512 nNeg = 0;
3513 break;
3514 case 4: // (1$)
3515 nNeg = 1;
3516 break;
3517 case 5: // -1$
3518 nNeg = 1;
3519 break;
3520 case 6: // 1-$
3521 nNeg = 1;
3522 break;
3523 case 7: // 1$-
3524 nNeg = 1;
3525 break;
3526 case 8: // -1 $
3527 nNeg = 1;
3528 break;
3529 case 9: // -$ 1
3530 nNeg = 0;
3531 break;
3532 case 10: // 1 $-
3533 nNeg = 1;
3534 break;
3535 case 11: // $ -1
3536 nNeg = 0;
3537 break;
3538 case 12 : // $ 1-
3539 nNeg = 0;
3540 break;
3541 case 13 : // 1- $
3542 nNeg = 1;
3543 break;
3544 case 14 : // ($ 1)
3545 nNeg = 0;
3546 break;
3547 case 15 : // (1 $)
3548 nNeg = 1;
3549 break;
3550 default:
3551 LocaleDataWrapper::outputCheckMessage(
3552 "lcl_CheckCurrencySymbolPosition: unknown NegativeFormat");
3553 break;
3554 }
3555 if ( nPos >= 0 && nNeg >= 0 && nPos != nNeg )
3556 {
3557 ByteString aStr( "positions of currency symbols differ\nLanguage: " );
3558 aStr += ByteString::CreateFromInt32( rCurr.GetLanguage() );
3559 aStr += " <";
3560 aStr += ByteString( rCurr.GetSymbol(), RTL_TEXTENCODING_UTF8 );
3561 aStr += "> positive: ";
3562 aStr += ByteString::CreateFromInt32( rCurr.GetPositiveFormat() );
3563 aStr += ( nPos ? " (postfix)" : " (prefix)" );
3564 aStr += ", negative: ";
3565 aStr += ByteString::CreateFromInt32( rCurr.GetNegativeFormat() );
3566 aStr += ( nNeg ? " (postfix)" : " (prefix)" );
3567 #if 0
3568 // seems that there really are some currencies which differ, e.g. YugoDinar
3569 DBG_ERRORFILE( aStr.GetBuffer() );
3570 #endif
3571 }
3572 }
3573
3574
3575 // static
ImpInitCurrencyTable()3576 void SvNumberFormatter::ImpInitCurrencyTable()
3577 {
3578 // racing condition possible:
3579 // ::osl::MutexGuard aGuard( GetMutex() );
3580 // while ( !bCurrencyTableInitialized )
3581 // ImpInitCurrencyTable();
3582 static sal_Bool bInitializing = sal_False;
3583 if ( bCurrencyTableInitialized || bInitializing )
3584 return ;
3585 bInitializing = sal_True;
3586
3587 RTL_LOGFILE_CONTEXT_AUTHOR( aTimeLog, "svl", "er93726", "SvNumberFormatter::ImpInitCurrencyTable" );
3588
3589 LanguageType eSysLang = SvtSysLocale().GetLanguage();
3590 LocaleDataWrapper* pLocaleData = new LocaleDataWrapper(
3591 ::comphelper::getProcessServiceFactory(),
3592 MsLangId::convertLanguageToLocale( eSysLang ) );
3593 // get user configured currency
3594 String aConfiguredCurrencyAbbrev;
3595 LanguageType eConfiguredCurrencyLanguage = LANGUAGE_SYSTEM;
3596 SvtSysLocaleOptions().GetCurrencyAbbrevAndLanguage(
3597 aConfiguredCurrencyAbbrev, eConfiguredCurrencyLanguage );
3598 sal_uInt16 nSecondarySystemCurrencyPosition = 0;
3599 sal_uInt16 nMatchingSystemCurrencyPosition = 0;
3600 NfCurrencyEntryPtr pEntry;
3601
3602 // first entry is SYSTEM
3603 pEntry = new NfCurrencyEntry( *pLocaleData, LANGUAGE_SYSTEM );
3604 theCurrencyTable::get().Insert( pEntry, 0 );
3605 sal_uInt16 nCurrencyPos = 1;
3606
3607 ::com::sun::star::uno::Sequence< ::com::sun::star::lang::Locale > xLoc =
3608 LocaleDataWrapper::getInstalledLocaleNames();
3609 sal_Int32 nLocaleCount = xLoc.getLength();
3610 RTL_LOGFILE_CONTEXT_TRACE1( aTimeLog, "number of locales: %ld", nLocaleCount );
3611 Locale const * const pLocales = xLoc.getConstArray();
3612 NfCurrencyTable &rCurrencyTable = theCurrencyTable::get();
3613 NfCurrencyTable &rLegacyOnlyCurrencyTable = theLegacyOnlyCurrencyTable::get();
3614 sal_uInt16 nLegacyOnlyCurrencyPos = 0;
3615 for ( sal_Int32 nLocale = 0; nLocale < nLocaleCount; nLocale++ )
3616 {
3617 LanguageType eLang = MsLangId::convertLocaleToLanguage(
3618 pLocales[nLocale]);
3619 #if OSL_DEBUG_LEVEL > 1
3620 LanguageType eReal = MsLangId::getRealLanguage( eLang );
3621 if ( eReal != eLang ) {
3622 sal_Bool bBreak;
3623 bBreak = sal_True;
3624 }
3625 #endif
3626 pLocaleData->setLocale( pLocales[nLocale] );
3627 Sequence< Currency2 > aCurrSeq = pLocaleData->getAllCurrencies();
3628 sal_Int32 nCurrencyCount = aCurrSeq.getLength();
3629 Currency2 const * const pCurrencies = aCurrSeq.getConstArray();
3630
3631 // one default currency for each locale, insert first so it is found first
3632 sal_Int32 nDefault;
3633 for ( nDefault = 0; nDefault < nCurrencyCount; nDefault++ )
3634 {
3635 if ( pCurrencies[nDefault].Default )
3636 break;
3637 }
3638 if ( nDefault < nCurrencyCount )
3639 pEntry = new NfCurrencyEntry( pCurrencies[nDefault], *pLocaleData, eLang );
3640 else
3641 pEntry = new NfCurrencyEntry( *pLocaleData, eLang ); // first or ShellsAndPebbles
3642
3643 if (LocaleDataWrapper::areChecksEnabled())
3644 lcl_CheckCurrencySymbolPosition( *pEntry );
3645
3646 rCurrencyTable.Insert( pEntry, nCurrencyPos++ );
3647 if ( !nSystemCurrencyPosition && (aConfiguredCurrencyAbbrev.Len() ?
3648 pEntry->GetBankSymbol() == aConfiguredCurrencyAbbrev &&
3649 pEntry->GetLanguage() == eConfiguredCurrencyLanguage : sal_False) )
3650 nSystemCurrencyPosition = nCurrencyPos-1;
3651 if ( !nMatchingSystemCurrencyPosition &&
3652 pEntry->GetLanguage() == eSysLang )
3653 nMatchingSystemCurrencyPosition = nCurrencyPos-1;
3654
3655 // all remaining currencies for each locale
3656 if ( nCurrencyCount > 1 )
3657 {
3658 sal_Int32 nCurrency;
3659 for ( nCurrency = 0; nCurrency < nCurrencyCount; nCurrency++ )
3660 {
3661 if (pCurrencies[nCurrency].LegacyOnly)
3662 {
3663 pEntry = new NfCurrencyEntry( pCurrencies[nCurrency], *pLocaleData, eLang );
3664 rLegacyOnlyCurrencyTable.Insert( pEntry, nLegacyOnlyCurrencyPos++ );
3665 }
3666 else if ( nCurrency != nDefault )
3667 {
3668 pEntry = new NfCurrencyEntry( pCurrencies[nCurrency], *pLocaleData, eLang );
3669 // no dupes
3670 sal_Bool bInsert = sal_True;
3671 NfCurrencyEntry const * const * pData = rCurrencyTable.GetData();
3672 sal_uInt16 n = rCurrencyTable.Count();
3673 pData++; // skip first SYSTEM entry
3674 for ( sal_uInt16 j=1; j<n; j++ )
3675 {
3676 if ( *(*pData++) == *pEntry )
3677 {
3678 bInsert = sal_False;
3679 break; // for
3680 }
3681 }
3682 if ( !bInsert )
3683 delete pEntry;
3684 else
3685 {
3686 rCurrencyTable.Insert( pEntry, nCurrencyPos++ );
3687 if ( !nSecondarySystemCurrencyPosition &&
3688 (aConfiguredCurrencyAbbrev.Len() ?
3689 pEntry->GetBankSymbol() == aConfiguredCurrencyAbbrev :
3690 pEntry->GetLanguage() == eConfiguredCurrencyLanguage) )
3691 nSecondarySystemCurrencyPosition = nCurrencyPos-1;
3692 if ( !nMatchingSystemCurrencyPosition &&
3693 pEntry->GetLanguage() == eSysLang )
3694 nMatchingSystemCurrencyPosition = nCurrencyPos-1;
3695 }
3696 }
3697 }
3698 }
3699 }
3700 if ( !nSystemCurrencyPosition )
3701 nSystemCurrencyPosition = nSecondarySystemCurrencyPosition;
3702 if ((aConfiguredCurrencyAbbrev.Len() && !nSystemCurrencyPosition) &&
3703 LocaleDataWrapper::areChecksEnabled())
3704 LocaleDataWrapper::outputCheckMessage(
3705 "SvNumberFormatter::ImpInitCurrencyTable: configured currency not in I18N locale data.");
3706 // match SYSTEM if no configured currency found
3707 if ( !nSystemCurrencyPosition )
3708 nSystemCurrencyPosition = nMatchingSystemCurrencyPosition;
3709 if ((!aConfiguredCurrencyAbbrev.Len() && !nSystemCurrencyPosition) &&
3710 LocaleDataWrapper::areChecksEnabled())
3711 LocaleDataWrapper::outputCheckMessage(
3712 "SvNumberFormatter::ImpInitCurrencyTable: system currency not in I18N locale data.");
3713 delete pLocaleData;
3714 SvtSysLocaleOptions::SetCurrencyChangeLink(
3715 STATIC_LINK( NULL, SvNumberFormatter, CurrencyChangeLink ) );
3716 bInitializing = sal_False;
3717 bCurrencyTableInitialized = sal_True;
3718 }
3719
3720
GetCurrencyFormatStrings(NfWSStringsDtor & rStrArr,const NfCurrencyEntry & rCurr,sal_Bool bBank) const3721 sal_uInt16 SvNumberFormatter::GetCurrencyFormatStrings( NfWSStringsDtor& rStrArr,
3722 const NfCurrencyEntry& rCurr, sal_Bool bBank ) const
3723 {
3724 sal_uInt16 nDefault = 0;
3725 if ( bBank )
3726 { // nur Bankensymbole
3727 String aPositiveBank, aNegativeBank;
3728 rCurr.BuildPositiveFormatString( aPositiveBank, sal_True, *xLocaleData, 1 );
3729 rCurr.BuildNegativeFormatString( aNegativeBank, sal_True, *xLocaleData, 1 );
3730
3731 WSStringPtr pFormat1 = new String( aPositiveBank );
3732 *pFormat1 += ';';
3733 WSStringPtr pFormat2 = new String( *pFormat1 );
3734
3735 String aRed( '[' );
3736 aRed += pFormatScanner->GetRedString();
3737 aRed += ']';
3738
3739 *pFormat2 += aRed;
3740
3741 *pFormat1 += aNegativeBank;
3742 *pFormat2 += aNegativeBank;
3743
3744 rStrArr.Insert( pFormat1, rStrArr.Count() );
3745 rStrArr.Insert( pFormat2, rStrArr.Count() );
3746 nDefault = rStrArr.Count() - 1;
3747 }
3748 else
3749 { // gemischte Formate wie in SvNumberFormatter::ImpGenerateFormats
3750 // aber keine doppelten, wenn keine Nachkommastellen in Waehrung
3751 String aPositive, aNegative, aPositiveNoDec, aNegativeNoDec,
3752 aPositiveDashed, aNegativeDashed;
3753 WSStringPtr pFormat1, pFormat2, pFormat3, pFormat4, pFormat5;
3754
3755 String aRed( '[' );
3756 aRed += pFormatScanner->GetRedString();
3757 aRed += ']';
3758
3759 rCurr.BuildPositiveFormatString( aPositive, sal_False, *xLocaleData, 1 );
3760 rCurr.BuildNegativeFormatString( aNegative, sal_False, *xLocaleData, 1 );
3761 if ( rCurr.GetDigits() )
3762 {
3763 rCurr.BuildPositiveFormatString( aPositiveNoDec, sal_False, *xLocaleData, 0 );
3764 rCurr.BuildNegativeFormatString( aNegativeNoDec, sal_False, *xLocaleData, 0 );
3765 rCurr.BuildPositiveFormatString( aPositiveDashed, sal_False, *xLocaleData, 2 );
3766 rCurr.BuildNegativeFormatString( aNegativeDashed, sal_False, *xLocaleData, 2 );
3767
3768 pFormat1 = new String( aPositiveNoDec );
3769 *pFormat1 += ';';
3770 pFormat3 = new String( *pFormat1 );
3771 pFormat5 = new String( aPositiveDashed );
3772 *pFormat5 += ';';
3773
3774 *pFormat1 += aNegativeNoDec;
3775
3776 *pFormat3 += aRed;
3777 *pFormat5 += aRed;
3778
3779 *pFormat3 += aNegativeNoDec;
3780 *pFormat5 += aNegativeDashed;
3781 }
3782 else
3783 {
3784 pFormat1 = NULL;
3785 pFormat3 = NULL;
3786 pFormat5 = NULL;
3787 }
3788
3789 pFormat2 = new String( aPositive );
3790 *pFormat2 += ';';
3791 pFormat4 = new String( *pFormat2 );
3792
3793 *pFormat2 += aNegative;
3794
3795 *pFormat4 += aRed;
3796 *pFormat4 += aNegative;
3797
3798 if ( pFormat1 )
3799 rStrArr.Insert( pFormat1, rStrArr.Count() );
3800 rStrArr.Insert( pFormat2, rStrArr.Count() );
3801 if ( pFormat3 )
3802 rStrArr.Insert( pFormat3, rStrArr.Count() );
3803 rStrArr.Insert( pFormat4, rStrArr.Count() );
3804 nDefault = rStrArr.Count() - 1;
3805 if ( pFormat5 )
3806 rStrArr.Insert( pFormat5, rStrArr.Count() );
3807 }
3808 return nDefault;
3809 }
3810
3811
3812 //--- NfCurrencyEntry ----------------------------------------------------
3813
NfCurrencyEntry()3814 NfCurrencyEntry::NfCurrencyEntry()
3815 : eLanguage( LANGUAGE_DONTKNOW ),
3816 nPositiveFormat(3),
3817 nNegativeFormat(8),
3818 nDigits(2),
3819 cZeroChar('0')
3820 {
3821 }
3822
3823
NfCurrencyEntry(const LocaleDataWrapper & rLocaleData,LanguageType eLang)3824 NfCurrencyEntry::NfCurrencyEntry( const LocaleDataWrapper& rLocaleData, LanguageType eLang )
3825 {
3826 aSymbol = rLocaleData.getCurrSymbol();
3827 aBankSymbol = rLocaleData.getCurrBankSymbol();
3828 eLanguage = eLang;
3829 nPositiveFormat = rLocaleData.getCurrPositiveFormat();
3830 nNegativeFormat = rLocaleData.getCurrNegativeFormat();
3831 nDigits = rLocaleData.getCurrDigits();
3832 cZeroChar = rLocaleData.getCurrZeroChar();
3833 }
3834
3835
NfCurrencyEntry(const::com::sun::star::i18n::Currency & rCurr,const LocaleDataWrapper & rLocaleData,LanguageType eLang)3836 NfCurrencyEntry::NfCurrencyEntry( const ::com::sun::star::i18n::Currency & rCurr,
3837 const LocaleDataWrapper& rLocaleData, LanguageType eLang )
3838 {
3839 aSymbol = rCurr.Symbol;
3840 aBankSymbol = rCurr.BankSymbol;
3841 eLanguage = eLang;
3842 nPositiveFormat = rLocaleData.getCurrPositiveFormat();
3843 nNegativeFormat = rLocaleData.getCurrNegativeFormat();
3844 nDigits = rCurr.DecimalPlaces;
3845 cZeroChar = rLocaleData.getCurrZeroChar();
3846 }
3847
3848
operator ==(const NfCurrencyEntry & r) const3849 sal_Bool NfCurrencyEntry::operator==( const NfCurrencyEntry& r ) const
3850 {
3851 return aSymbol == r.aSymbol
3852 && aBankSymbol == r.aBankSymbol
3853 && eLanguage == r.eLanguage
3854 ;
3855 }
3856
3857
SetEuro()3858 void NfCurrencyEntry::SetEuro()
3859 {
3860 aSymbol = NfCurrencyEntry::GetEuroSymbol();
3861 aBankSymbol.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "EUR" ) );
3862 eLanguage = LANGUAGE_DONTKNOW;
3863 nPositiveFormat = 3;
3864 nNegativeFormat = 8;
3865 nDigits = 2;
3866 cZeroChar = '0';
3867 }
3868
3869
IsEuro() const3870 sal_Bool NfCurrencyEntry::IsEuro() const
3871 {
3872 if ( aBankSymbol.EqualsAscii( "EUR" ) )
3873 return sal_True;
3874 String aEuro( NfCurrencyEntry::GetEuroSymbol() );
3875 return aSymbol == aEuro;
3876 }
3877
3878
ApplyVariableInformation(const NfCurrencyEntry & r)3879 void NfCurrencyEntry::ApplyVariableInformation( const NfCurrencyEntry& r )
3880 {
3881 nPositiveFormat = r.nPositiveFormat;
3882 nNegativeFormat = r.nNegativeFormat;
3883 cZeroChar = r.cZeroChar;
3884 }
3885
3886
BuildSymbolString(String & rStr,sal_Bool bBank,sal_Bool bWithoutExtension) const3887 void NfCurrencyEntry::BuildSymbolString( String& rStr, sal_Bool bBank,
3888 sal_Bool bWithoutExtension ) const
3889 {
3890 rStr = '[';
3891 rStr += '$';
3892 if ( bBank )
3893 rStr += aBankSymbol;
3894 else
3895 {
3896 if ( aSymbol.Search( '-' ) != STRING_NOTFOUND || aSymbol.Search( ']' ) != STRING_NOTFOUND )
3897 {
3898 rStr += '"';
3899 rStr += aSymbol;
3900 rStr += '"';
3901 }
3902 else
3903 rStr += aSymbol;
3904 if ( !bWithoutExtension && eLanguage != LANGUAGE_DONTKNOW && eLanguage != LANGUAGE_SYSTEM )
3905 {
3906 rStr += '-';
3907 rStr += String::CreateFromInt32( sal_Int32( eLanguage ), 16 ).ToUpperAscii();
3908 }
3909 }
3910 rStr += ']';
3911 }
3912
3913
Impl_BuildFormatStringNumChars(String & rStr,const LocaleDataWrapper & rLoc,sal_uInt16 nDecimalFormat) const3914 void NfCurrencyEntry::Impl_BuildFormatStringNumChars( String& rStr,
3915 const LocaleDataWrapper& rLoc, sal_uInt16 nDecimalFormat ) const
3916 {
3917 rStr.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "###0" ) );
3918 rStr.Insert( rLoc.getNumThousandSep(), 1 );
3919 if ( nDecimalFormat && nDigits )
3920 {
3921 rStr += rLoc.getNumDecimalSep();
3922 rStr.Expand( rStr.Len() + nDigits, (nDecimalFormat == 2 ? '-' : cZeroChar) );
3923 }
3924 }
3925
3926
BuildPositiveFormatString(String & rStr,sal_Bool bBank,const LocaleDataWrapper & rLoc,sal_uInt16 nDecimalFormat) const3927 void NfCurrencyEntry::BuildPositiveFormatString( String& rStr, sal_Bool bBank,
3928 const LocaleDataWrapper& rLoc, sal_uInt16 nDecimalFormat ) const
3929 {
3930 Impl_BuildFormatStringNumChars( rStr, rLoc, nDecimalFormat );
3931 sal_uInt16 nPosiForm = NfCurrencyEntry::GetEffectivePositiveFormat(
3932 rLoc.getCurrPositiveFormat(), nPositiveFormat, bBank );
3933 CompletePositiveFormatString( rStr, bBank, nPosiForm );
3934 }
3935
3936
BuildNegativeFormatString(String & rStr,sal_Bool bBank,const LocaleDataWrapper & rLoc,sal_uInt16 nDecimalFormat) const3937 void NfCurrencyEntry::BuildNegativeFormatString( String& rStr, sal_Bool bBank,
3938 const LocaleDataWrapper& rLoc, sal_uInt16 nDecimalFormat ) const
3939 {
3940 Impl_BuildFormatStringNumChars( rStr, rLoc, nDecimalFormat );
3941 sal_uInt16 nNegaForm = NfCurrencyEntry::GetEffectiveNegativeFormat(
3942 rLoc.getCurrNegativeFormat(), nNegativeFormat, bBank );
3943 CompleteNegativeFormatString( rStr, bBank, nNegaForm );
3944 }
3945
3946
CompletePositiveFormatString(String & rStr,sal_Bool bBank,sal_uInt16 nPosiForm) const3947 void NfCurrencyEntry::CompletePositiveFormatString( String& rStr, sal_Bool bBank,
3948 sal_uInt16 nPosiForm ) const
3949 {
3950 String aSymStr;
3951 BuildSymbolString( aSymStr, bBank );
3952 NfCurrencyEntry::CompletePositiveFormatString( rStr, aSymStr, nPosiForm );
3953 }
3954
3955
CompleteNegativeFormatString(String & rStr,sal_Bool bBank,sal_uInt16 nNegaForm) const3956 void NfCurrencyEntry::CompleteNegativeFormatString( String& rStr, sal_Bool bBank,
3957 sal_uInt16 nNegaForm ) const
3958 {
3959 String aSymStr;
3960 BuildSymbolString( aSymStr, bBank );
3961 NfCurrencyEntry::CompleteNegativeFormatString( rStr, aSymStr, nNegaForm );
3962 }
3963
3964
3965 // static
CompletePositiveFormatString(String & rStr,const String & rSymStr,sal_uInt16 nPositiveFormat)3966 void NfCurrencyEntry::CompletePositiveFormatString( String& rStr,
3967 const String& rSymStr, sal_uInt16 nPositiveFormat )
3968 {
3969 switch( nPositiveFormat )
3970 {
3971 case 0: // $1
3972 rStr.Insert( rSymStr , 0 );
3973 break;
3974 case 1: // 1$
3975 rStr += rSymStr;
3976 break;
3977 case 2: // $ 1
3978 {
3979 rStr.Insert( ' ', 0 );
3980 rStr.Insert( rSymStr, 0 );
3981 }
3982 break;
3983 case 3: // 1 $
3984 {
3985 rStr += ' ';
3986 rStr += rSymStr;
3987 }
3988 break;
3989 default:
3990 DBG_ERROR("NfCurrencyEntry::CompletePositiveFormatString: unknown option");
3991 break;
3992 }
3993 }
3994
3995
3996 // static
CompleteNegativeFormatString(String & rStr,const String & rSymStr,sal_uInt16 nNegativeFormat)3997 void NfCurrencyEntry::CompleteNegativeFormatString( String& rStr,
3998 const String& rSymStr, sal_uInt16 nNegativeFormat )
3999 {
4000 switch( nNegativeFormat )
4001 {
4002 case 0: // ($1)
4003 {
4004 rStr.Insert( rSymStr, 0);
4005 rStr.Insert('(',0);
4006 rStr += ')';
4007 }
4008 break;
4009 case 1: // -$1
4010 {
4011 rStr.Insert( rSymStr, 0);
4012 rStr.Insert('-',0);
4013 }
4014 break;
4015 case 2: // $-1
4016 {
4017 rStr.Insert('-',0);
4018 rStr.Insert( rSymStr, 0);
4019 }
4020 break;
4021 case 3: // $1-
4022 {
4023 rStr.Insert( rSymStr, 0);
4024 rStr += '-';
4025 }
4026 break;
4027 case 4: // (1$)
4028 {
4029 rStr.Insert('(',0);
4030 rStr += rSymStr;
4031 rStr += ')';
4032 }
4033 break;
4034 case 5: // -1$
4035 {
4036 rStr += rSymStr;
4037 rStr.Insert('-',0);
4038 }
4039 break;
4040 case 6: // 1-$
4041 {
4042 rStr += '-';
4043 rStr += rSymStr;
4044 }
4045 break;
4046 case 7: // 1$-
4047 {
4048 rStr += rSymStr;
4049 rStr += '-';
4050 }
4051 break;
4052 case 8: // -1 $
4053 {
4054 rStr += ' ';
4055 rStr += rSymStr;
4056 rStr.Insert('-',0);
4057 }
4058 break;
4059 case 9: // -$ 1
4060 {
4061 rStr.Insert(' ',0);
4062 rStr.Insert( rSymStr, 0);
4063 rStr.Insert('-',0);
4064 }
4065 break;
4066 case 10: // 1 $-
4067 {
4068 rStr += ' ';
4069 rStr += rSymStr;
4070 rStr += '-';
4071 }
4072 break;
4073 case 11: // $ -1
4074 {
4075 String aTmp( rSymStr );
4076 aTmp += ' ';
4077 aTmp += '-';
4078 rStr.Insert( aTmp, 0 );
4079 }
4080 break;
4081 case 12 : // $ 1-
4082 {
4083 rStr.Insert(' ', 0);
4084 rStr.Insert( rSymStr, 0);
4085 rStr += '-';
4086 }
4087 break;
4088 case 13 : // 1- $
4089 {
4090 rStr += '-';
4091 rStr += ' ';
4092 rStr += rSymStr;
4093 }
4094 break;
4095 case 14 : // ($ 1)
4096 {
4097 rStr.Insert(' ',0);
4098 rStr.Insert( rSymStr, 0);
4099 rStr.Insert('(',0);
4100 rStr += ')';
4101 }
4102 break;
4103 case 15 : // (1 $)
4104 {
4105 rStr.Insert('(',0);
4106 rStr += ' ';
4107 rStr += rSymStr;
4108 rStr += ')';
4109 }
4110 break;
4111 default:
4112 DBG_ERROR("NfCurrencyEntry::CompleteNegativeFormatString: unknown option");
4113 break;
4114 }
4115 }
4116
4117
4118 // static
GetEffectivePositiveFormat(sal_uInt16 nIntlFormat,sal_uInt16 nCurrFormat,sal_Bool bBank)4119 sal_uInt16 NfCurrencyEntry::GetEffectivePositiveFormat( sal_uInt16
4120 #if ! NF_BANKSYMBOL_FIX_POSITION
4121 nIntlFormat
4122 #endif
4123 , sal_uInt16 nCurrFormat, sal_Bool bBank )
4124 {
4125 if ( bBank )
4126 {
4127 #if NF_BANKSYMBOL_FIX_POSITION
4128 return 3;
4129 #else
4130 switch ( nIntlFormat )
4131 {
4132 case 0: // $1
4133 nIntlFormat = 2; // $ 1
4134 break;
4135 case 1: // 1$
4136 nIntlFormat = 3; // 1 $
4137 break;
4138 case 2: // $ 1
4139 break;
4140 case 3: // 1 $
4141 break;
4142 default:
4143 DBG_ERROR("NfCurrencyEntry::GetEffectivePositiveFormat: unknown option");
4144 break;
4145 }
4146 return nIntlFormat;
4147 #endif
4148 }
4149 else
4150 return nCurrFormat;
4151 }
4152
4153
4154 // nur aufrufen, wenn nCurrFormat wirklich mit Klammern ist
lcl_MergeNegativeParenthesisFormat(sal_uInt16 nIntlFormat,sal_uInt16 nCurrFormat)4155 sal_uInt16 lcl_MergeNegativeParenthesisFormat( sal_uInt16 nIntlFormat, sal_uInt16 nCurrFormat )
4156 {
4157 short nSign = 0; // -1:=Klammer 0:=links, 1:=mitte, 2:=rechts
4158 switch ( nIntlFormat )
4159 {
4160 case 0: // ($1)
4161 case 4: // (1$)
4162 case 14 : // ($ 1)
4163 case 15 : // (1 $)
4164 return nCurrFormat;
4165 case 1: // -$1
4166 case 5: // -1$
4167 case 8: // -1 $
4168 case 9: // -$ 1
4169 nSign = 0;
4170 break;
4171 case 2: // $-1
4172 case 6: // 1-$
4173 case 11 : // $ -1
4174 case 13 : // 1- $
4175 nSign = 1;
4176 break;
4177 case 3: // $1-
4178 case 7: // 1$-
4179 case 10: // 1 $-
4180 case 12 : // $ 1-
4181 nSign = 2;
4182 break;
4183 default:
4184 DBG_ERROR("lcl_MergeNegativeParenthesisFormat: unknown option");
4185 break;
4186 }
4187
4188 switch ( nCurrFormat )
4189 {
4190 case 0: // ($1)
4191 switch ( nSign )
4192 {
4193 case 0:
4194 return 1; // -$1
4195 case 1:
4196 return 2; // $-1
4197 case 2:
4198 return 3; // $1-
4199 }
4200 break;
4201 case 4: // (1$)
4202 switch ( nSign )
4203 {
4204 case 0:
4205 return 5; // -1$
4206 case 1:
4207 return 6; // 1-$
4208 case 2:
4209 return 7; // 1$-
4210 }
4211 break;
4212 case 14 : // ($ 1)
4213 switch ( nSign )
4214 {
4215 case 0:
4216 return 9; // -$ 1
4217 case 1:
4218 return 11; // $ -1
4219 case 2:
4220 return 12; // $ 1-
4221 }
4222 break;
4223 case 15 : // (1 $)
4224 switch ( nSign )
4225 {
4226 case 0:
4227 return 8; // -1 $
4228 case 1:
4229 return 13; // 1- $
4230 case 2:
4231 return 10; // 1 $-
4232 }
4233 break;
4234 }
4235 return nCurrFormat;
4236 }
4237
4238
4239 // static
GetEffectiveNegativeFormat(sal_uInt16 nIntlFormat,sal_uInt16 nCurrFormat,sal_Bool bBank)4240 sal_uInt16 NfCurrencyEntry::GetEffectiveNegativeFormat( sal_uInt16 nIntlFormat,
4241 sal_uInt16 nCurrFormat, sal_Bool bBank )
4242 {
4243 if ( bBank )
4244 {
4245 #if NF_BANKSYMBOL_FIX_POSITION
4246 return 8;
4247 #else
4248 switch ( nIntlFormat )
4249 {
4250 case 0: // ($1)
4251 // nIntlFormat = 14; // ($ 1)
4252 nIntlFormat = 9; // -$ 1
4253 break;
4254 case 1: // -$1
4255 nIntlFormat = 9; // -$ 1
4256 break;
4257 case 2: // $-1
4258 nIntlFormat = 11; // $ -1
4259 break;
4260 case 3: // $1-
4261 nIntlFormat = 12; // $ 1-
4262 break;
4263 case 4: // (1$)
4264 // nIntlFormat = 15; // (1 $)
4265 nIntlFormat = 8; // -1 $
4266 break;
4267 case 5: // -1$
4268 nIntlFormat = 8; // -1 $
4269 break;
4270 case 6: // 1-$
4271 nIntlFormat = 13; // 1- $
4272 break;
4273 case 7: // 1$-
4274 nIntlFormat = 10; // 1 $-
4275 break;
4276 case 8: // -1 $
4277 break;
4278 case 9: // -$ 1
4279 break;
4280 case 10: // 1 $-
4281 break;
4282 case 11: // $ -1
4283 break;
4284 case 12 : // $ 1-
4285 break;
4286 case 13 : // 1- $
4287 break;
4288 case 14 : // ($ 1)
4289 // nIntlFormat = 14; // ($ 1)
4290 nIntlFormat = 9; // -$ 1
4291 break;
4292 case 15 : // (1 $)
4293 // nIntlFormat = 15; // (1 $)
4294 nIntlFormat = 8; // -1 $
4295 break;
4296 default:
4297 DBG_ERROR("NfCurrencyEntry::GetEffectiveNegativeFormat: unknown option");
4298 break;
4299 }
4300 #endif
4301 }
4302 else if ( nIntlFormat != nCurrFormat )
4303 {
4304 switch ( nCurrFormat )
4305 {
4306 case 0: // ($1)
4307 nIntlFormat = lcl_MergeNegativeParenthesisFormat(
4308 nIntlFormat, nCurrFormat );
4309 break;
4310 case 1: // -$1
4311 nIntlFormat = nCurrFormat;
4312 break;
4313 case 2: // $-1
4314 nIntlFormat = nCurrFormat;
4315 break;
4316 case 3: // $1-
4317 nIntlFormat = nCurrFormat;
4318 break;
4319 case 4: // (1$)
4320 nIntlFormat = lcl_MergeNegativeParenthesisFormat(
4321 nIntlFormat, nCurrFormat );
4322 break;
4323 case 5: // -1$
4324 nIntlFormat = nCurrFormat;
4325 break;
4326 case 6: // 1-$
4327 nIntlFormat = nCurrFormat;
4328 break;
4329 case 7: // 1$-
4330 nIntlFormat = nCurrFormat;
4331 break;
4332 case 8: // -1 $
4333 nIntlFormat = nCurrFormat;
4334 break;
4335 case 9: // -$ 1
4336 nIntlFormat = nCurrFormat;
4337 break;
4338 case 10: // 1 $-
4339 nIntlFormat = nCurrFormat;
4340 break;
4341 case 11: // $ -1
4342 nIntlFormat = nCurrFormat;
4343 break;
4344 case 12 : // $ 1-
4345 nIntlFormat = nCurrFormat;
4346 break;
4347 case 13 : // 1- $
4348 nIntlFormat = nCurrFormat;
4349 break;
4350 case 14 : // ($ 1)
4351 nIntlFormat = lcl_MergeNegativeParenthesisFormat(
4352 nIntlFormat, nCurrFormat );
4353 break;
4354 case 15 : // (1 $)
4355 nIntlFormat = lcl_MergeNegativeParenthesisFormat(
4356 nIntlFormat, nCurrFormat );
4357 break;
4358 default:
4359 DBG_ERROR("NfCurrencyEntry::GetEffectiveNegativeFormat: unknown option");
4360 break;
4361 }
4362 }
4363 return nIntlFormat;
4364 }
4365
4366
4367 // we only support default encodings here
4368 // static
GetEuroSymbol(rtl_TextEncoding eTextEncoding)4369 sal_Char NfCurrencyEntry::GetEuroSymbol( rtl_TextEncoding eTextEncoding )
4370 {
4371 switch ( eTextEncoding )
4372 {
4373 case RTL_TEXTENCODING_MS_1252 : // WNT Ansi
4374 case RTL_TEXTENCODING_ISO_8859_1 : // UNX for use with TrueType fonts
4375 return '\x80';
4376 case RTL_TEXTENCODING_ISO_8859_15 : // UNX real
4377 return '\xA4';
4378 case RTL_TEXTENCODING_IBM_850 : // OS2
4379 return '\xD5';
4380 case RTL_TEXTENCODING_APPLE_ROMAN : // MAC
4381 return '\xDB';
4382 default: // default system
4383 #if WNT
4384 return '\x80';
4385 #elif OS2
4386 return '\xD5';
4387 #elif UNX
4388 // return '\xA4'; // #56121# 0xA4 wäre korrekt für iso-8859-15
4389 return '\x80'; // aber Windows-Code für die konvertierten TrueType-Fonts
4390 #else
4391 #error EuroSymbol is what?
4392 return '\x80';
4393 #endif
4394 }
4395 return '\x80';
4396 }
4397
4398 /* vim: set noet sw=4 ts=4: */
4399