Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <tools/color.hxx>
21 :
22 : #define _SVX_NUMFMTSH_CXX
23 : #include <tools/debug.hxx>
24 : #include <i18npool/mslangid.hxx>
25 :
26 : #include <svl/zforlist.hxx>
27 : #include <svl/zformat.hxx>
28 :
29 : #include <svtools/langtab.hxx>
30 : #include <vcl/svapp.hxx>
31 : #include <comphelper/processfactory.hxx>
32 :
33 : #include <svx/numfmtsh.hxx>
34 :
35 : #include <limits>
36 :
37 : // class SvxNumberFormatShell --------------------------------------------
38 :
39 : const double SvxNumberFormatShell::DEFAULT_NUMVALUE = 1234.56789;
40 :
41 : // -----------------------------------------------------------------------
42 :
43 :
44 :
45 0 : SvxNumberFormatShell* SvxNumberFormatShell::Create( SvNumberFormatter* pNumFormatter,
46 : sal_uInt32 nFormatKey,
47 : SvxNumberValueType eNumValType,
48 : const String& rNumStr )
49 : {
50 : return new SvxNumberFormatShell(pNumFormatter,nFormatKey,
51 0 : eNumValType,rNumStr );
52 : }
53 :
54 0 : SvxNumberFormatShell* SvxNumberFormatShell::Create( SvNumberFormatter* pNumFormatter,
55 : sal_uInt32 nFormatKey,
56 : SvxNumberValueType eNumValType,
57 : double nNumVal,
58 : const String* pNumStr )
59 : {
60 : return new SvxNumberFormatShell(pNumFormatter,nFormatKey,
61 0 : eNumValType,nNumVal,pNumStr );
62 : }
63 :
64 : // -----------------------------------------------------------------------
65 :
66 0 : SvxNumberFormatShell::SvxNumberFormatShell( SvNumberFormatter* pNumFormatter,
67 : sal_uInt32 nFormatKey,
68 : SvxNumberValueType eNumValType,
69 : const String& rNumStr ) :
70 : pFormatter ( pNumFormatter ),
71 : pCurFmtTable ( NULL ),
72 : eValType ( eNumValType ),
73 : bUndoAddList ( true ),
74 : nCurFormatKey ( nFormatKey ),
75 : pCurCurrencyEntry(NULL),
76 : bBankingSymbol (false),
77 : nCurCurrencyEntryPos((sal_uInt16) SELPOS_NONE),
78 0 : bUseStarFormat (false)
79 : {
80 0 : nValNum = DEFAULT_NUMVALUE;
81 :
82 0 : switch ( eValType )
83 : {
84 : case SVX_VALUE_TYPE_STRING:
85 0 : aValStr = rNumStr;
86 0 : break;
87 : case SVX_VALUE_TYPE_NUMBER:
88 : case SVX_VALUE_TYPE_UNDEFINED:
89 : default:
90 0 : aValStr.Erase();
91 : }
92 0 : }
93 :
94 : // -----------------------------------------------------------------------
95 :
96 0 : SvxNumberFormatShell::SvxNumberFormatShell( SvNumberFormatter* pNumFormatter,
97 : sal_uInt32 nFormatKey,
98 : SvxNumberValueType eNumValType,
99 : double nNumVal,
100 : const String* pNumStr ) :
101 : pFormatter ( pNumFormatter ),
102 : pCurFmtTable ( NULL ),
103 : eValType ( eNumValType ),
104 : bUndoAddList ( true ),
105 : nCurFormatKey ( nFormatKey ),
106 : pCurCurrencyEntry(NULL),
107 : bBankingSymbol (false),
108 : nCurCurrencyEntryPos((sal_uInt16) SELPOS_NONE),
109 0 : bUseStarFormat (false)
110 : {
111 : // #50441# When used in Writer, the SvxNumberInfoItem contains the
112 : // original string in addition to the value
113 :
114 0 : if ( pNumStr )
115 0 : aValStr = *pNumStr;
116 :
117 0 : switch ( eValType )
118 : {
119 : case SVX_VALUE_TYPE_NUMBER:
120 0 : nValNum = nNumVal;
121 0 : break;
122 : case SVX_VALUE_TYPE_STRING:
123 : case SVX_VALUE_TYPE_UNDEFINED:
124 : default:
125 0 : nValNum = DEFAULT_NUMVALUE;
126 : }
127 0 : }
128 :
129 : // -----------------------------------------------------------------------
130 :
131 0 : SvxNumberFormatShell::~SvxNumberFormatShell()
132 : {
133 : /*
134 : * An dieser Stelle wird abhaengig davon, ob die
135 : * hinzugefuegten, benutzerdefinierten als gueltig
136 : * erklaert wurden (ValidateNewEntries()), die
137 : * Add-Liste wieder aus dem Zahlenformatierer entfernt.
138 : *
139 : * Loeschen von Formaten aus dem Formatierer passiert
140 : * aus Undo-Gruenden nur in der aufrufenden Instanz.
141 : */
142 :
143 0 : if ( bUndoAddList )
144 : {
145 : // Hinzugefuegte Formate sind nicht gueltig:
146 : // => wieder entfernen:
147 :
148 0 : for ( std::vector<sal_uInt32>::const_iterator it(aAddList.begin()); it != aAddList.end(); ++it )
149 0 : pFormatter->DeleteEntry( *it );
150 : }
151 :
152 0 : for ( std::vector<String*>::const_iterator it(aCurrencyFormatList.begin());
153 0 : it != aCurrencyFormatList.end(); ++it )
154 0 : delete *it;
155 0 : }
156 :
157 : // -----------------------------------------------------------------------
158 :
159 0 : size_t SvxNumberFormatShell::GetUpdateDataCount() const
160 : {
161 0 : return aDelList.size();
162 : }
163 :
164 : // -----------------------------------------------------------------------
165 :
166 0 : void SvxNumberFormatShell::GetUpdateData( sal_uInt32* pDelArray, const sal_uInt32 nSize )
167 : {
168 0 : const size_t nListSize = aDelList.size();
169 :
170 : DBG_ASSERT( pDelArray && ( nSize == nListSize ), "Array nicht initialisiert!" );
171 :
172 0 : if ( pDelArray && ( nSize == nListSize ) )
173 0 : for (std::vector<sal_uInt32>::const_iterator it(aDelList.begin()); it != aDelList.end(); ++it )
174 0 : *pDelArray++ = *it;
175 0 : }
176 :
177 : // -----------------------------------------------------------------------
178 :
179 0 : void SvxNumberFormatShell::CategoryChanged( sal_uInt16 nCatLbPos,
180 : short& rFmtSelPos,
181 : std::vector<String*>& rFmtEntries )
182 : {
183 0 : short nOldCategory = nCurCategory;
184 0 : PosToCategory_Impl( nCatLbPos, nCurCategory );
185 : pCurFmtTable = &( pFormatter->GetEntryTable( nCurCategory,
186 : nCurFormatKey,
187 0 : eCurLanguage ) );
188 : // reinitialize currency if category newly entered
189 0 : if ( nCurCategory == NUMBERFORMAT_CURRENCY && nOldCategory != nCurCategory )
190 0 : pCurCurrencyEntry = NULL;
191 0 : rFmtSelPos = FillEntryList_Impl( rFmtEntries );
192 0 : }
193 :
194 : // -----------------------------------------------------------------------
195 :
196 0 : void SvxNumberFormatShell::LanguageChanged( LanguageType eLangType,
197 : short& rFmtSelPos,
198 : std::vector<String*>& rFmtEntries )
199 : {
200 0 : eCurLanguage = eLangType;
201 : pCurFmtTable = &(pFormatter->ChangeCL( nCurCategory,
202 : nCurFormatKey,
203 0 : eCurLanguage ) );
204 0 : rFmtSelPos = FillEntryList_Impl( rFmtEntries );
205 0 : }
206 :
207 : // -----------------------------------------------------------------------
208 :
209 0 : void SvxNumberFormatShell::FormatChanged( sal_uInt16 nFmtLbPos,
210 : String& rPreviewStr,
211 : Color*& rpFontColor )
212 : {
213 0 : if( static_cast<size_t>(nFmtLbPos) < aCurEntryList.size() )
214 : {
215 0 : nCurFormatKey = aCurEntryList[nFmtLbPos];
216 :
217 0 : if( nCurFormatKey != NUMBERFORMAT_ENTRY_NOT_FOUND )
218 : {
219 0 : GetPreviewString_Impl( rPreviewStr, rpFontColor );
220 : }
221 0 : else if( nCurCategory == NUMBERFORMAT_CURRENCY )
222 : {
223 0 : if( static_cast<size_t>(nFmtLbPos) < aCurrencyFormatList.size() )
224 : {
225 0 : MakePrevStringFromVal(*aCurrencyFormatList[nFmtLbPos],
226 0 : rPreviewStr,rpFontColor,nValNum);
227 : }
228 : }
229 : }
230 0 : }
231 : // -----------------------------------------------------------------------
232 :
233 0 : bool SvxNumberFormatShell::AddFormat( String& rFormat, xub_StrLen& rErrPos,
234 : sal_uInt16& rCatLbSelPos, short& rFmtSelPos,
235 : std::vector<String*>& rFmtEntries )
236 : {
237 0 : bool bInserted = false;
238 0 : sal_uInt32 nAddKey = pFormatter->GetEntryKey( rFormat, eCurLanguage );
239 :
240 0 : if ( nAddKey != NUMBERFORMAT_ENTRY_NOT_FOUND ) // bereits vorhanden?
241 : {
242 0 : ::std::vector<sal_uInt32>::iterator nAt = GetRemoved_Impl( nAddKey );
243 0 : if ( nAt != aDelList.end() )
244 : {
245 0 : aDelList.erase( nAt );
246 0 : bInserted = true;
247 : }
248 : else
249 : {
250 : OSL_FAIL( "Doppeltes Format!" );
251 : }
252 : }
253 : else // neues Format
254 : {
255 0 : OUString sTemp(rFormat);
256 : sal_Int32 nPos;
257 : bInserted = pFormatter->PutEntry( sTemp, nPos,
258 : nCurCategory, nAddKey,
259 0 : eCurLanguage );
260 0 : rErrPos = (nPos >= 0) ? (xub_StrLen)nPos : 0xFFFF;
261 0 : rFormat = sTemp;
262 :
263 0 : if (bInserted)
264 : {
265 : // May be sorted under a different locale if LCID was parsed.
266 0 : const SvNumberformat* pEntry = pFormatter->GetEntry( nAddKey);
267 0 : if (pEntry)
268 : {
269 0 : LanguageType nLang = pEntry->GetLanguage();
270 0 : if (eCurLanguage != nLang)
271 : {
272 : // Current language's list would not show entry, adapt.
273 0 : eCurLanguage = nLang;
274 : }
275 : }
276 0 : }
277 : }
278 :
279 0 : if ( bInserted ) // eingefuegt
280 : {
281 0 : nCurFormatKey = nAddKey;
282 : DBG_ASSERT( !IsAdded_Impl( nCurFormatKey ), "Doppeltes Format!" );
283 0 : aAddList.push_back( nCurFormatKey );
284 :
285 : // aktuelle Tabelle holen
286 : pCurFmtTable = &(pFormatter->GetEntryTable( nCurCategory,
287 : nCurFormatKey,
288 0 : eCurLanguage ));
289 0 : nCurCategory=pFormatter->GetType(nAddKey); //@@ ???
290 0 : CategoryToPos_Impl( nCurCategory, rCatLbSelPos );
291 0 : rFmtSelPos = FillEntryList_Impl( rFmtEntries );
292 : }
293 0 : else if ( rErrPos != 0 ) // Syntaxfehler
294 : {
295 : ;
296 : }
297 : else // Doppelt einfuegen nicht moeglich
298 : {
299 : OSL_FAIL( "Doppeltes Format!" ); // oder doch?
300 : }
301 :
302 0 : return bInserted;
303 : }
304 :
305 : // -----------------------------------------------------------------------
306 :
307 0 : bool SvxNumberFormatShell::RemoveFormat( const String& rFormat,
308 : sal_uInt16& rCatLbSelPos,
309 : short& rFmtSelPos,
310 : std::vector<String*>& rFmtEntries )
311 : {
312 0 : sal_uInt32 nDelKey = pFormatter->GetEntryKey( rFormat, eCurLanguage );
313 :
314 : DBG_ASSERT( nDelKey != NUMBERFORMAT_ENTRY_NOT_FOUND, "Eintrag nicht gefunden!" );
315 : DBG_ASSERT( !IsRemoved_Impl( nDelKey ), "Eintrag bereits geloescht!" );
316 :
317 0 : if ( (nDelKey != NUMBERFORMAT_ENTRY_NOT_FOUND) && !IsRemoved_Impl( nDelKey ) )
318 : {
319 0 : aDelList.push_back( nDelKey );
320 :
321 0 : ::std::vector<sal_uInt32>::iterator nAt = GetAdded_Impl( nDelKey );
322 0 : if( nAt != aAddList.end() )
323 : {
324 0 : aAddList.erase( nAt );
325 : }
326 :
327 0 : nCurCategory=pFormatter->GetType(nDelKey);
328 : pCurFmtTable = &(pFormatter->GetEntryTable( nCurCategory,
329 : nCurFormatKey,
330 0 : eCurLanguage ));
331 :
332 : nCurFormatKey=pFormatter->GetStandardFormat(nCurCategory,
333 0 : eCurLanguage );
334 :
335 0 : CategoryToPos_Impl( nCurCategory, rCatLbSelPos );
336 0 : rFmtSelPos = FillEntryList_Impl( rFmtEntries );
337 : }
338 0 : return true;
339 : }
340 :
341 : // -----------------------------------------------------------------------
342 :
343 0 : void SvxNumberFormatShell::MakeFormat( String& rFormat,
344 : bool bThousand, bool bNegRed,
345 : sal_uInt16 nPrecision, sal_uInt16 nLeadingZeroes,
346 : sal_uInt16 nCurrencyPos)
347 : {
348 0 : if( aCurrencyFormatList.size() > static_cast<size_t>(nCurrencyPos) )
349 : {
350 0 : xub_StrLen rErrPos=0;
351 0 : std::vector<String*> aFmtEList;
352 :
353 0 : sal_uInt32 nFound = pFormatter->TestNewString( *aCurrencyFormatList[nCurrencyPos], eCurLanguage );
354 :
355 0 : if ( nFound == NUMBERFORMAT_ENTRY_NOT_FOUND )
356 : {
357 0 : sal_uInt16 rCatLbSelPos=0;
358 0 : short rFmtSelPos=0;
359 0 : AddFormat( *aCurrencyFormatList[nCurrencyPos],rErrPos,rCatLbSelPos,
360 0 : rFmtSelPos,aFmtEList);
361 : }
362 :
363 0 : if(rErrPos==0)
364 : {
365 : rFormat = pFormatter->GenerateFormat(nCurFormatKey,
366 : eCurLanguage,
367 : bThousand, bNegRed,
368 0 : nPrecision, nLeadingZeroes);
369 : }
370 0 : for ( std::vector<String*>::const_iterator it(aFmtEList.begin()); it != aFmtEList.end(); ++it )
371 0 : delete *it;
372 : }
373 : else
374 : {
375 : rFormat = pFormatter->GenerateFormat(nCurFormatKey,
376 : eCurLanguage,
377 : bThousand, bNegRed,
378 0 : nPrecision, nLeadingZeroes);
379 : }
380 0 : }
381 :
382 : // -----------------------------------------------------------------------
383 :
384 0 : void SvxNumberFormatShell::GetOptions( const String& rFormat,
385 : bool& rThousand,
386 : bool& rNegRed,
387 : sal_uInt16& rPrecision,
388 : sal_uInt16& rLeadingZeroes,
389 : sal_uInt16& rCatLbPos )
390 : {
391 :
392 0 : sal_uInt32 nFmtKey = pFormatter->GetEntryKey( rFormat, eCurLanguage );
393 :
394 0 : if(nFmtKey != NUMBERFORMAT_ENTRY_NOT_FOUND)
395 : {
396 0 : if ( nFmtKey != NUMBERFORMAT_ENTRY_NOT_FOUND )
397 : {
398 : pFormatter->GetFormatSpecialInfo( nFmtKey,
399 : rThousand, rNegRed,
400 0 : rPrecision, rLeadingZeroes );
401 :
402 0 : CategoryToPos_Impl( pFormatter->GetType( nFmtKey ), rCatLbPos );
403 : }
404 : else
405 0 : rCatLbPos = CAT_USERDEFINED;
406 : }
407 : else
408 : {
409 0 : bool bTestBanking = false;
410 0 : sal_uInt16 nPos=FindCurrencyTableEntry(rFormat, bTestBanking );
411 :
412 0 : if(IsInTable(nPos,bTestBanking,rFormat) &&
413 : pFormatter->GetFormatSpecialInfo( rFormat,rThousand, rNegRed,
414 0 : rPrecision, rLeadingZeroes,eCurLanguage)==0)
415 : {
416 0 : rCatLbPos = CAT_CURRENCY;
417 : }
418 : else
419 0 : rCatLbPos = CAT_USERDEFINED;
420 : }
421 :
422 0 : }
423 :
424 : // -----------------------------------------------------------------------
425 :
426 0 : void SvxNumberFormatShell::MakePreviewString( const String& rFormatStr,
427 : String& rPreviewStr,
428 : Color*& rpFontColor )
429 : {
430 0 : rpFontColor = NULL;
431 :
432 0 : sal_uIntPtr nExistingFormat = pFormatter->GetEntryKey( rFormatStr, eCurLanguage );
433 0 : if ( nExistingFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
434 : {
435 : // real preview - not implemented in NumberFormatter for text formats
436 0 : OUString sTempOut(rPreviewStr);
437 :
438 : pFormatter->GetPreviewString( rFormatStr, nValNum, sTempOut,
439 0 : &rpFontColor, eCurLanguage, bUseStarFormat );
440 0 : rPreviewStr = sTempOut;
441 : }
442 : else
443 : {
444 : // format exists
445 :
446 : // #50441# if a string was set in addition to the value, use it for text formats
447 : bool bUseText = ( eValType == SVX_VALUE_TYPE_STRING ||
448 0 : ( aValStr.Len() && ( pFormatter->GetType(nExistingFormat) & NUMBERFORMAT_TEXT ) ) );
449 0 : if ( bUseText )
450 : {
451 0 : OUString sTempIn(aValStr);
452 0 : OUString sTempOut(rPreviewStr);
453 : pFormatter->GetOutputString( sTempIn, nExistingFormat,
454 0 : sTempOut, &rpFontColor );
455 0 : aValStr = sTempIn;
456 0 : rPreviewStr = sTempOut;
457 : }
458 : else
459 : {
460 : pFormatter->GetOutputString( nValNum, nExistingFormat,
461 0 : rPreviewStr, &rpFontColor, bUseStarFormat );
462 : }
463 : }
464 0 : }
465 :
466 : // -----------------------------------------------------------------------
467 :
468 0 : bool SvxNumberFormatShell::IsUserDefined( const String& rFmtString )
469 : {
470 0 : sal_uInt32 nFound = pFormatter->GetEntryKey( rFmtString, eCurLanguage );
471 :
472 0 : bool bFlag=false;
473 0 : if ( nFound != NUMBERFORMAT_ENTRY_NOT_FOUND )
474 : {
475 0 : bFlag=pFormatter->IsUserDefined( rFmtString, eCurLanguage );
476 :
477 0 : if(bFlag)
478 : {
479 0 : const SvNumberformat* pNumEntry = pFormatter->GetEntry(nFound);
480 :
481 0 : if(pNumEntry!=NULL && pNumEntry->HasNewCurrency())
482 : {
483 : bool bTestBanking;
484 0 : sal_uInt16 nPos=FindCurrencyTableEntry(rFmtString,bTestBanking);
485 0 : bFlag=!IsInTable(nPos,bTestBanking,rFmtString);
486 : }
487 : }
488 : }
489 0 : return bFlag;
490 : }
491 :
492 : // -----------------------------------------------------------------------
493 :
494 0 : bool SvxNumberFormatShell::FindEntry( const String& rFmtString, sal_uInt32* pAt /* = NULL */ )
495 : {
496 0 : bool bRes=false;
497 0 : sal_uInt32 nFound = pFormatter->TestNewString( rFmtString, eCurLanguage );
498 :
499 0 : if ( nFound == NUMBERFORMAT_ENTRY_NOT_FOUND )
500 : {
501 0 : bool bTestBanking=false;
502 0 : sal_uInt16 nPos=FindCurrencyTableEntry(rFmtString, bTestBanking );
503 :
504 0 : if(IsInTable(nPos,bTestBanking,rFmtString))
505 : {
506 0 : nFound=NUMBERFORMAT_ENTRY_NEW_CURRENCY;
507 0 : bRes=true;
508 : }
509 : }
510 : else
511 : {
512 0 : bRes=!IsRemoved_Impl( nFound );
513 : }
514 :
515 0 : if ( pAt )
516 0 : *pAt = nFound;
517 :
518 0 : return bRes;
519 : }
520 :
521 :
522 : // -----------------------------------------------------------------------
523 :
524 0 : void SvxNumberFormatShell::GetInitSettings( sal_uInt16& nCatLbPos,
525 : LanguageType& rLangType,
526 : sal_uInt16& nFmtLbSelPos,
527 : std::vector<String*>& rFmtEntries,
528 : String& rPrevString,
529 : Color*& rpPrevColor )
530 : {
531 : // -------------------------------------------------------------------
532 : // Vorbedingung: Zahlenformatierer gefunden
533 : DBG_ASSERT( pFormatter != NULL, "Zahlenformatierer nicht gefunden!" );
534 :
535 : // sal_uInt16 nCount = 0;
536 0 : short nSelPos = SELPOS_NONE;
537 : // SvNumberFormatTable* pFmtTable = NULL;
538 :
539 : // Sonderbehandlung fuer undefiniertes Zahlenformat:
540 0 : if ( (eValType == SVX_VALUE_TYPE_UNDEFINED) && (nCurFormatKey == 0) )
541 0 : PosToCategory_Impl( CAT_ALL, nCurCategory ); // Kategorie = Alle
542 : else
543 0 : nCurCategory = NUMBERFORMAT_UNDEFINED; // Kategorie = Undefiniert
544 :
545 : pCurFmtTable = &(pFormatter->GetFirstEntryTable( nCurCategory,
546 : nCurFormatKey,
547 0 : eCurLanguage ));
548 :
549 :
550 :
551 0 : CategoryToPos_Impl( nCurCategory, nCatLbPos );
552 0 : rLangType = eCurLanguage;
553 :
554 0 : nSelPos = FillEntryList_Impl( rFmtEntries );
555 :
556 : DBG_ASSERT( nSelPos != SELPOS_NONE, "Leere Formatliste!" );
557 :
558 0 : nFmtLbSelPos = (nSelPos != SELPOS_NONE) ? (sal_uInt16)nSelPos : 0;
559 0 : GetPreviewString_Impl( rPrevString, rpPrevColor );
560 0 : }
561 :
562 : // -----------------------------------------------------------------------
563 :
564 0 : short SvxNumberFormatShell::FillEntryList_Impl( std::vector<String*>& rList )
565 : {
566 : /* Erstellen einer aktuellen Liste von Format-Eintraegen.
567 : * Rueckgabewert ist die Listenposition des aktuellen Formates.
568 : * Ist die Liste leer oder gibt es kein aktuelles Format,
569 : * so wird SELPOS_NONE geliefert.
570 : */
571 0 : short nSelPos=0;
572 0 : sal_uInt16 nPrivCat = CAT_CURRENCY;
573 0 : nSelPos=SELPOS_NONE;
574 :
575 0 : aCurEntryList.clear();
576 :
577 0 : if(nCurCategory==NUMBERFORMAT_ALL)
578 : {
579 0 : FillEListWithStd_Impl(rList,CAT_NUMBER,nSelPos);
580 0 : FillEListWithStd_Impl(rList,CAT_PERCENT,nSelPos);
581 0 : FillEListWithStd_Impl(rList,CAT_CURRENCY,nSelPos);
582 0 : FillEListWithStd_Impl(rList,CAT_DATE,nSelPos);
583 0 : FillEListWithStd_Impl(rList,CAT_TIME,nSelPos);
584 0 : FillEListWithStd_Impl(rList,CAT_SCIENTIFIC,nSelPos);
585 0 : FillEListWithStd_Impl(rList,CAT_FRACTION,nSelPos);
586 0 : FillEListWithStd_Impl(rList,CAT_BOOLEAN,nSelPos);
587 0 : FillEListWithStd_Impl(rList,CAT_TEXT,nSelPos);
588 : }
589 : else
590 : {
591 0 : CategoryToPos_Impl(nCurCategory, nPrivCat);
592 0 : FillEListWithStd_Impl(rList,nPrivCat,nSelPos);
593 : }
594 :
595 0 : if( nPrivCat!=CAT_CURRENCY)
596 0 : nSelPos=FillEListWithUsD_Impl(rList,nPrivCat,nSelPos);
597 :
598 0 : return nSelPos;
599 : }
600 :
601 0 : void SvxNumberFormatShell::FillEListWithStd_Impl( std::vector<String*>& rList,
602 : sal_uInt16 nPrivCat,short &nSelPos )
603 : {
604 : /* Erstellen einer aktuellen Liste von Format-Eintraegen.
605 : * Rueckgabewert ist die Listenposition des aktuellen Formates.
606 : * Ist die Liste leer oder gibt es kein aktuelles Format,
607 : * so wird SELPOS_NONE geliefert.
608 : */
609 : DBG_ASSERT( pCurFmtTable != NULL, "Unbekanntes Zahlenformat!" );
610 :
611 0 : for ( std::vector<String*>::const_iterator it(aCurrencyFormatList.begin());
612 0 : it != aCurrencyFormatList.end(); ++it )
613 0 : delete *it;
614 0 : aCurrencyFormatList.clear();
615 :
616 0 : if(nPrivCat==CAT_CURRENCY)
617 : {
618 0 : nSelPos=FillEListWithCurrency_Impl(rList,nSelPos);
619 : }
620 : else
621 : {
622 : NfIndexTableOffset eOffsetStart;
623 : NfIndexTableOffset eOffsetEnd;
624 :
625 0 : switch(nPrivCat)
626 : {
627 0 : case CAT_NUMBER :eOffsetStart=NF_NUMBER_START;
628 0 : eOffsetEnd=NF_NUMBER_END;
629 0 : break;
630 0 : case CAT_PERCENT :eOffsetStart=NF_PERCENT_START;
631 0 : eOffsetEnd=NF_PERCENT_END;
632 0 : break;
633 0 : case CAT_CURRENCY :eOffsetStart=NF_CURRENCY_START;
634 0 : eOffsetEnd=NF_CURRENCY_END;
635 0 : break;
636 0 : case CAT_DATE :eOffsetStart=NF_DATE_START;
637 0 : eOffsetEnd=NF_DATE_END;
638 0 : break;
639 0 : case CAT_TIME :eOffsetStart=NF_TIME_START;
640 0 : eOffsetEnd=NF_TIME_END;
641 0 : break;
642 0 : case CAT_SCIENTIFIC :eOffsetStart=NF_SCIENTIFIC_START;
643 0 : eOffsetEnd=NF_SCIENTIFIC_END;
644 0 : break;
645 0 : case CAT_FRACTION :eOffsetStart=NF_FRACTION_START;
646 0 : eOffsetEnd=NF_FRACTION_END;
647 0 : break;
648 0 : case CAT_BOOLEAN :eOffsetStart=NF_BOOLEAN;
649 0 : eOffsetEnd=NF_BOOLEAN;
650 0 : break;
651 0 : case CAT_TEXT :eOffsetStart=NF_TEXT;
652 0 : eOffsetEnd=NF_TEXT;
653 0 : break;
654 0 : default :return;
655 : }
656 :
657 0 : nSelPos=FillEListWithFormats_Impl(rList,nSelPos,eOffsetStart,eOffsetEnd);
658 :
659 0 : if(nPrivCat==CAT_DATE || nPrivCat==CAT_TIME)
660 : {
661 0 : nSelPos=FillEListWithDateTime_Impl(rList,nSelPos);
662 : //if(nSelPos!=SELPOS_NONE) nSelPos=nTmpPos;
663 : }
664 : }
665 : }
666 :
667 0 : short SvxNumberFormatShell::FillEListWithFormats_Impl( std::vector<String*>& rList,
668 : short nSelPos,
669 : NfIndexTableOffset eOffsetStart,
670 : NfIndexTableOffset eOffsetEnd)
671 : {
672 : /* Erstellen einer aktuellen Liste von Format-Eintraegen.
673 : * Rueckgabewert ist die Listenposition des aktuellen Formates.
674 : * Ist die Liste leer oder gibt es kein aktuelles Format,
675 : * so wird SELPOS_NONE geliefert.
676 : */
677 : sal_uInt16 nMyType;
678 :
679 : DBG_ASSERT( pCurFmtTable != NULL, "Unbekanntes Zahlenformat!" );
680 :
681 0 : const SvNumberformat* pNumEntry = pCurFmtTable->empty() ? 0 : pCurFmtTable->begin()->second;
682 : sal_uInt32 nNFEntry;
683 0 : String aStrComment;
684 0 : String aNewFormNInfo;
685 0 : String aPrevString;
686 0 : String a2PrevString;
687 :
688 0 : short nMyCat = SELPOS_NONE;
689 :
690 : long nIndex;
691 :
692 0 : for(nIndex=eOffsetStart;nIndex<=eOffsetEnd;nIndex++)
693 : {
694 0 : nNFEntry=pFormatter->GetFormatIndex((NfIndexTableOffset)nIndex,eCurLanguage);
695 :
696 0 : pNumEntry = pFormatter->GetEntry(nNFEntry);
697 :
698 0 : if(pNumEntry==NULL) continue;
699 :
700 0 : nMyCat=pNumEntry->GetType() & ~NUMBERFORMAT_DEFINED;
701 0 : aStrComment=pNumEntry->GetComment();
702 0 : CategoryToPos_Impl(nMyCat,nMyType);
703 0 : aNewFormNInfo= pNumEntry->GetFormatstring();
704 :
705 0 : String *const pStr = new String(aNewFormNInfo);
706 :
707 0 : if ( nNFEntry == nCurFormatKey )
708 : {
709 0 : nSelPos = ( !IsRemoved_Impl( nNFEntry ) ) ? aCurEntryList.size() : SELPOS_NONE;
710 : }
711 :
712 0 : rList.push_back( pStr );
713 0 : aCurEntryList.push_back( nNFEntry );
714 : }
715 :
716 0 : return nSelPos;
717 : }
718 :
719 0 : short SvxNumberFormatShell::FillEListWithDateTime_Impl( std::vector<String*>& rList,
720 : short nSelPos)
721 : {
722 : sal_uInt16 nMyType;
723 :
724 : DBG_ASSERT( pCurFmtTable != NULL, "Unbekanntes Zahlenformat!" );
725 :
726 0 : const SvNumberformat* pNumEntry = pCurFmtTable->empty() ? 0 : pCurFmtTable->begin()->second;
727 : sal_uInt32 nNFEntry;
728 0 : String aStrComment;
729 0 : String aNewFormNInfo;
730 0 : String aPrevString;
731 0 : String a2PrevString;
732 :
733 0 : short nMyCat = SELPOS_NONE;
734 :
735 : long nIndex;
736 :
737 0 : for(nIndex=NF_DATETIME_START;nIndex<=NF_DATETIME_END;nIndex++)
738 : {
739 0 : nNFEntry=pFormatter->GetFormatIndex((NfIndexTableOffset)nIndex,eCurLanguage);
740 :
741 0 : pNumEntry = pFormatter->GetEntry(nNFEntry);
742 0 : if(pNumEntry!=NULL)
743 : {
744 0 : nMyCat=pNumEntry->GetType() & ~NUMBERFORMAT_DEFINED;
745 0 : aStrComment=pNumEntry->GetComment();
746 0 : CategoryToPos_Impl(nMyCat,nMyType);
747 0 : aNewFormNInfo= pNumEntry->GetFormatstring();
748 :
749 0 : String *const pStr = new String(aNewFormNInfo);
750 :
751 0 : if ( nNFEntry == nCurFormatKey )
752 : {
753 0 : nSelPos = ( !IsRemoved_Impl( nNFEntry ) ) ? aCurEntryList.size() : SELPOS_NONE;
754 : }
755 :
756 0 : rList.push_back( pStr );
757 0 : aCurEntryList.push_back( nNFEntry );
758 : }
759 : }
760 :
761 0 : return nSelPos;
762 : }
763 :
764 0 : short SvxNumberFormatShell::FillEListWithCurrency_Impl( std::vector<String*>& rList,
765 : short nSelPos)
766 : {
767 : /* Erstellen einer aktuellen Liste von Format-Eintraegen.
768 : * Rueckgabewert ist die Listenposition des aktuellen Formates.
769 : * Ist die Liste leer oder gibt es kein aktuelles Format,
770 : * so wird SELPOS_NONE geliefert.
771 : */
772 : DBG_ASSERT( pCurFmtTable != NULL, "Unbekanntes Zahlenformat!" );
773 :
774 : const NfCurrencyEntry* pTmpCurrencyEntry;
775 : bool bTmpBanking;
776 0 : XubString rSymbol;
777 :
778 : bool bFlag=pFormatter->GetNewCurrencySymbolString(nCurFormatKey,rSymbol,
779 0 : &pTmpCurrencyEntry,&bTmpBanking);
780 :
781 0 : if((!bFlag && pCurCurrencyEntry==NULL) ||
782 0 : (bFlag && pTmpCurrencyEntry==NULL && !rSymbol.Len()) ||
783 : nCurCategory==NUMBERFORMAT_ALL)
784 : {
785 0 : if ( nCurCategory == NUMBERFORMAT_ALL )
786 0 : FillEListWithUserCurrencys(rList,nSelPos);
787 0 : nSelPos=FillEListWithSysCurrencys(rList,nSelPos);
788 : }
789 : else
790 : {
791 0 : nSelPos=FillEListWithUserCurrencys(rList,nSelPos);
792 : }
793 :
794 0 : return nSelPos;
795 : }
796 :
797 :
798 0 : short SvxNumberFormatShell::FillEListWithSysCurrencys( std::vector<String*>& rList,
799 : short nSelPos)
800 : {
801 : /* Erstellen einer aktuellen Liste von Format-Eintraegen.
802 : * Rueckgabewert ist die Listenposition des aktuellen Formates.
803 : * Ist die Liste leer oder gibt es kein aktuelles Format,
804 : * so wird SELPOS_NONE geliefert.
805 : */
806 : sal_uInt16 nMyType;
807 :
808 : DBG_ASSERT( pCurFmtTable != NULL, "Unbekanntes Zahlenformat!" );
809 :
810 0 : const SvNumberformat* pNumEntry = pCurFmtTable->empty() ? 0 : pCurFmtTable->begin()->second;
811 : sal_uInt32 nNFEntry;
812 0 : String aStrComment;
813 0 : String aNewFormNInfo;
814 0 : String aPrevString;
815 0 : String a2PrevString;
816 :
817 0 : nCurCurrencyEntryPos=0;
818 :
819 0 : short nMyCat = SELPOS_NONE;
820 :
821 0 : NfIndexTableOffset eOffsetStart=NF_CURRENCY_START;
822 0 : NfIndexTableOffset eOffsetEnd=NF_CURRENCY_END;
823 : long nIndex;
824 :
825 0 : for(nIndex=eOffsetStart;nIndex<=eOffsetEnd;nIndex++)
826 : {
827 0 : nNFEntry=pFormatter->GetFormatIndex((NfIndexTableOffset)nIndex,eCurLanguage);
828 :
829 0 : pNumEntry = pFormatter->GetEntry(nNFEntry);
830 :
831 0 : if(pNumEntry==NULL) continue;
832 :
833 0 : nMyCat=pNumEntry->GetType() & ~NUMBERFORMAT_DEFINED;
834 0 : aStrComment=pNumEntry->GetComment();
835 0 : CategoryToPos_Impl(nMyCat,nMyType);
836 0 : aNewFormNInfo= pNumEntry->GetFormatstring();
837 :
838 0 : String *const pStr = new String(aNewFormNInfo);
839 :
840 0 : if ( nNFEntry == nCurFormatKey )
841 : {
842 0 : nSelPos = ( !IsRemoved_Impl( nNFEntry ) ) ? aCurEntryList.size() : SELPOS_NONE;
843 : }
844 :
845 0 : rList.push_back( pStr );
846 0 : aCurEntryList.push_back( nNFEntry );
847 : }
848 :
849 0 : if(nCurCategory!=NUMBERFORMAT_ALL)
850 : {
851 0 : SvNumberFormatTable::iterator it = pCurFmtTable->begin();
852 :
853 0 : while ( it != pCurFmtTable->end() )
854 : {
855 0 : sal_uInt32 nKey = it->first;
856 0 : pNumEntry = it->second;
857 :
858 0 : if ( !IsRemoved_Impl( nKey ))
859 : {
860 0 : bool bUserNewCurrency=false;
861 0 : if(pNumEntry->HasNewCurrency())
862 : {
863 : const NfCurrencyEntry* pTmpCurrencyEntry;
864 : bool bTmpBanking;
865 0 : XubString rSymbol;
866 :
867 : pFormatter->GetNewCurrencySymbolString(nKey,rSymbol,
868 0 : &pTmpCurrencyEntry,&bTmpBanking);
869 :
870 0 : bUserNewCurrency=(pTmpCurrencyEntry!=NULL);
871 : }
872 :
873 0 : if(!bUserNewCurrency &&(pNumEntry->GetType() & NUMBERFORMAT_DEFINED))
874 : {
875 0 : nMyCat=pNumEntry->GetType() & ~NUMBERFORMAT_DEFINED;
876 0 : aStrComment=pNumEntry->GetComment();
877 0 : CategoryToPos_Impl(nMyCat,nMyType);
878 0 : aNewFormNInfo= pNumEntry->GetFormatstring();
879 :
880 0 : String *const pStr = new String(aNewFormNInfo);
881 :
882 0 : if ( nKey == nCurFormatKey ) nSelPos =aCurEntryList.size();
883 0 : rList.push_back( pStr );
884 0 : aCurEntryList.push_back( nKey );
885 : }
886 : }
887 0 : ++it;
888 : }
889 : }
890 0 : return nSelPos;
891 : }
892 :
893 0 : short SvxNumberFormatShell::FillEListWithUserCurrencys( std::vector<String*>& rList,
894 : short nSelPos)
895 : {
896 : /* Erstellen einer aktuellen Liste von Format-Eintraegen.
897 : * Rueckgabewert ist die Listenposition des aktuellen Formates.
898 : * Ist die Liste leer oder gibt es kein aktuelles Format,
899 : * so wird SELPOS_NONE geliefert.
900 : */
901 : sal_uInt16 nMyType;
902 :
903 : DBG_ASSERT( pCurFmtTable != NULL, "Unbekanntes Zahlenformat!" );
904 :
905 0 : String aStrComment;
906 0 : String aNewFormNInfo;
907 0 : String aPrevString;
908 0 : String a2PrevString;
909 0 : short nMyCat = SELPOS_NONE;
910 :
911 : const NfCurrencyEntry* pTmpCurrencyEntry;
912 : bool bTmpBanking, bAdaptSelPos;
913 0 : XubString rSymbol;
914 0 : XubString rBankSymbol;
915 :
916 0 : std::vector<String*> aList;
917 0 : std::vector<sal_uInt32> aKeyList;
918 :
919 : pFormatter->GetNewCurrencySymbolString(nCurFormatKey,rSymbol,
920 0 : &pTmpCurrencyEntry,&bTmpBanking);
921 :
922 0 : XubString rShortSymbol;
923 :
924 0 : if(pCurCurrencyEntry==NULL)
925 : {
926 : // #110398# If no currency format was previously selected (we're not
927 : // about to add another currency), try to select the initial currency
928 : // format (nCurFormatKey) that was set in FormatChanged() after
929 : // matching the format string entered in the dialog.
930 0 : bAdaptSelPos = true;
931 0 : pCurCurrencyEntry=(NfCurrencyEntry*)pTmpCurrencyEntry;
932 0 : bBankingSymbol=bTmpBanking;
933 0 : nCurCurrencyEntryPos=FindCurrencyFormat(pTmpCurrencyEntry,bTmpBanking);
934 : }
935 : else
936 : {
937 0 : if (pTmpCurrencyEntry == pCurCurrencyEntry)
938 0 : bAdaptSelPos = true;
939 : else
940 : {
941 0 : bAdaptSelPos = false;
942 0 : pTmpCurrencyEntry = pCurCurrencyEntry;
943 : }
944 0 : bTmpBanking=bBankingSymbol;
945 : }
946 :
947 0 : if(pTmpCurrencyEntry!=NULL)
948 : {
949 0 : rSymbol = pTmpCurrencyEntry->BuildSymbolString(false);
950 0 : rBankSymbol = pTmpCurrencyEntry->BuildSymbolString(true);
951 0 : rShortSymbol = pTmpCurrencyEntry->BuildSymbolString(bTmpBanking,true);
952 : }
953 :
954 0 : SvNumberFormatTable::iterator it = pCurFmtTable->begin();
955 0 : while ( it != pCurFmtTable->end() )
956 : {
957 0 : sal_uInt32 nKey = it->first;
958 0 : const SvNumberformat* pNumEntry = it->second;
959 :
960 0 : if ( !IsRemoved_Impl( nKey ) )
961 : {
962 0 : if( pNumEntry->GetType() & NUMBERFORMAT_DEFINED ||
963 0 : pNumEntry->IsAdditionalStandardDefined() )
964 : {
965 0 : nMyCat=pNumEntry->GetType() & ~NUMBERFORMAT_DEFINED;
966 0 : aStrComment=pNumEntry->GetComment();
967 0 : CategoryToPos_Impl(nMyCat,nMyType);
968 0 : aNewFormNInfo= pNumEntry->GetFormatstring();
969 :
970 0 : bool bInsFlag = false;
971 0 : if ( pNumEntry->HasNewCurrency() )
972 : {
973 0 : bInsFlag = true; // merge locale formats into currency selection
974 : }
975 0 : else if( (!bTmpBanking && aNewFormNInfo.Search(rSymbol)!=STRING_NOTFOUND) ||
976 0 : (bTmpBanking && aNewFormNInfo.Search(rBankSymbol)!=STRING_NOTFOUND) )
977 : {
978 0 : bInsFlag = true;
979 : }
980 0 : else if(aNewFormNInfo.Search(rShortSymbol)!=STRING_NOTFOUND)
981 : {
982 0 : XubString rTstSymbol;
983 : const NfCurrencyEntry* pTstCurrencyEntry;
984 : bool bTstBanking;
985 :
986 : pFormatter->GetNewCurrencySymbolString(nKey,rTstSymbol,
987 0 : &pTstCurrencyEntry,&bTstBanking);
988 :
989 0 : if(pTmpCurrencyEntry==pTstCurrencyEntry && bTstBanking==bTmpBanking)
990 : {
991 0 : bInsFlag = true;
992 0 : }
993 :
994 : }
995 :
996 0 : if(bInsFlag)
997 : {
998 0 : aList.push_back( new String(aNewFormNInfo) );
999 0 : aKeyList.push_back( nKey );
1000 : }
1001 : }
1002 : }
1003 0 : ++it;
1004 : }
1005 :
1006 0 : NfWSStringsDtor aWSStringsDtor;
1007 : sal_uInt16 nDefault;
1008 0 : if ( pTmpCurrencyEntry && nCurCategory != NUMBERFORMAT_ALL )
1009 : {
1010 : nDefault = pFormatter->GetCurrencyFormatStrings(
1011 0 : aWSStringsDtor, *pTmpCurrencyEntry, bTmpBanking );
1012 0 : if ( !bTmpBanking )
1013 : pFormatter->GetCurrencyFormatStrings(
1014 0 : aWSStringsDtor, *pTmpCurrencyEntry, true );
1015 : }
1016 : else
1017 0 : nDefault = 0;
1018 0 : if ( !bTmpBanking && nCurCategory != NUMBERFORMAT_ALL )
1019 : { // append formats for all currencies defined in the current I18N locale
1020 0 : const NfCurrencyTable& rCurrencyTable = SvNumberFormatter::GetTheCurrencyTable();
1021 0 : sal_uInt16 nCurrCount = rCurrencyTable.size();
1022 0 : LanguageType eLang = MsLangId::getRealLanguage( eCurLanguage );
1023 0 : for ( sal_uInt16 i=0; i < nCurrCount; ++i )
1024 : {
1025 0 : const NfCurrencyEntry* pCurr = &rCurrencyTable[i];
1026 0 : if ( pCurr->GetLanguage() == eLang && pTmpCurrencyEntry != pCurr )
1027 : {
1028 0 : pFormatter->GetCurrencyFormatStrings( aWSStringsDtor, *pCurr, false );
1029 0 : pFormatter->GetCurrencyFormatStrings( aWSStringsDtor, *pCurr, true );
1030 : }
1031 : }
1032 : }
1033 :
1034 0 : size_t nOldListCount = rList.size();
1035 0 : for( size_t i = 0, nPos = nOldListCount; i < aWSStringsDtor.size(); ++i )
1036 : {
1037 0 : bool bFlag = true;
1038 0 : String aInsStr(aWSStringsDtor[i]);
1039 : size_t j;
1040 0 : for( j=0; j < aList.size(); ++j )
1041 : {
1042 0 : const String * pTestStr=aList[j];
1043 :
1044 0 : if(*pTestStr==aInsStr)
1045 : {
1046 0 : bFlag = false;
1047 0 : break;
1048 : }
1049 : }
1050 0 : if(bFlag)
1051 : {
1052 0 : rList.push_back( new String(aInsStr) );
1053 0 : aCurEntryList.insert( aCurEntryList.begin() + (nPos++), NUMBERFORMAT_ENTRY_NOT_FOUND);
1054 : }
1055 : else
1056 : {
1057 0 : rList.push_back( aList[j] );
1058 0 : aList.erase( aList.begin()+j );
1059 0 : aCurEntryList.insert( aCurEntryList.begin() + (nPos++), aKeyList[j]);
1060 0 : aKeyList.erase( aKeyList.begin()+j );
1061 : }
1062 0 : }
1063 :
1064 0 : for( size_t i = 0; i < aKeyList.size(); ++i )
1065 : {
1066 0 : if( aKeyList[i] != NUMBERFORMAT_ENTRY_NOT_FOUND )
1067 : {
1068 0 : rList.push_back( aList[i] );
1069 0 : aCurEntryList.push_back( aKeyList[i] );
1070 : }
1071 : }
1072 :
1073 0 : for( size_t i = nOldListCount; i < rList.size(); ++i )
1074 : {
1075 0 : aCurrencyFormatList.push_back( new String(*rList[i]) );
1076 :
1077 0 : if ( nSelPos == SELPOS_NONE && bAdaptSelPos && aCurEntryList[i] == nCurFormatKey )
1078 0 : nSelPos = i;
1079 : }
1080 :
1081 0 : if ( nSelPos == SELPOS_NONE && nCurCategory != NUMBERFORMAT_ALL )
1082 0 : nSelPos = nDefault;
1083 :
1084 0 : return nSelPos;
1085 : }
1086 :
1087 :
1088 0 : short SvxNumberFormatShell::FillEListWithUsD_Impl( std::vector<String*>& rList,
1089 : sal_uInt16 nPrivCat, short nSelPos )
1090 : {
1091 : /* Erstellen einer aktuellen Liste von Format-Eintraegen.
1092 : * Rueckgabewert ist die Listenposition des aktuellen Formates.
1093 : * Ist die Liste leer oder gibt es kein aktuelles Format,
1094 : * so wird SELPOS_NONE geliefert.
1095 : */
1096 : sal_uInt16 nMyType;
1097 :
1098 : DBG_ASSERT( pCurFmtTable != NULL, "Unbekanntes Zahlenformat!" );
1099 :
1100 0 : String aStrComment;
1101 0 : String aNewFormNInfo;
1102 0 : String aPrevString;
1103 0 : String a2PrevString;
1104 :
1105 0 : short nMyCat = SELPOS_NONE;
1106 : bool bAdditional = (nPrivCat != CAT_USERDEFINED &&
1107 0 : nCurCategory != NUMBERFORMAT_ALL);
1108 :
1109 0 : SvNumberFormatTable::iterator it = pCurFmtTable->begin();
1110 0 : while ( it != pCurFmtTable->end() )
1111 : {
1112 0 : sal_uInt32 nKey = it->first;
1113 0 : const SvNumberformat* pNumEntry = it->second;
1114 :
1115 0 : if ( !IsRemoved_Impl( nKey ) )
1116 : {
1117 0 : if( (pNumEntry->GetType() & NUMBERFORMAT_DEFINED) ||
1118 0 : (bAdditional && pNumEntry->IsAdditionalStandardDefined()) )
1119 : {
1120 0 : nMyCat=pNumEntry->GetType() & ~NUMBERFORMAT_DEFINED;
1121 0 : aStrComment=pNumEntry->GetComment();
1122 0 : CategoryToPos_Impl(nMyCat,nMyType);
1123 0 : aNewFormNInfo= pNumEntry->GetFormatstring();
1124 :
1125 0 : bool bFlag=true;
1126 0 : if(pNumEntry->HasNewCurrency())
1127 : {
1128 : bool bTestBanking;
1129 0 : sal_uInt16 nPos=FindCurrencyTableEntry(aNewFormNInfo,bTestBanking);
1130 0 : bFlag=!IsInTable(nPos,bTestBanking,aNewFormNInfo);
1131 : }
1132 0 : if(bFlag)
1133 : {
1134 0 : String *const pStr = new String(aNewFormNInfo);
1135 :
1136 0 : if ( nKey == nCurFormatKey ) nSelPos = aCurEntryList.size();
1137 0 : rList.push_back( pStr );
1138 0 : aCurEntryList.push_back( nKey );
1139 : }
1140 : }
1141 : }
1142 0 : ++it;
1143 : }
1144 0 : return nSelPos;
1145 : }
1146 :
1147 :
1148 : // -----------------------------------------------------------------------
1149 :
1150 0 : void SvxNumberFormatShell::GetPreviewString_Impl( String& rString, Color*& rpColor )
1151 : {
1152 0 : rpColor = NULL;
1153 :
1154 : // #50441# if a string was set in addition to the value, use it for text formats
1155 : bool bUseText = ( eValType == SVX_VALUE_TYPE_STRING ||
1156 0 : ( aValStr.Len() && ( pFormatter->GetType(nCurFormatKey) & NUMBERFORMAT_TEXT ) ) );
1157 :
1158 0 : if ( bUseText )
1159 : {
1160 0 : OUString sTempIn(aValStr);
1161 0 : OUString sTempOut(rString);
1162 0 : pFormatter->GetOutputString( sTempIn, nCurFormatKey, sTempOut, &rpColor );
1163 0 : aValStr = sTempIn;
1164 0 : rString = sTempOut;
1165 : }
1166 : else
1167 : {
1168 0 : pFormatter->GetOutputString( nValNum, nCurFormatKey, rString, &rpColor, bUseStarFormat );
1169 : }
1170 0 : }
1171 :
1172 : // -----------------------------------------------------------------------
1173 :
1174 0 : ::std::vector<sal_uInt32>::iterator SvxNumberFormatShell::GetRemoved_Impl( size_t nKey )
1175 : {
1176 0 : return ::std::find(aDelList.begin(), aDelList.end(), nKey);
1177 : }
1178 :
1179 : // -----------------------------------------------------------------------
1180 :
1181 0 : bool SvxNumberFormatShell::IsRemoved_Impl( size_t nKey )
1182 : {
1183 0 : return GetRemoved_Impl( nKey ) != aDelList.end();
1184 : }
1185 :
1186 : // -----------------------------------------------------------------------
1187 :
1188 0 : ::std::vector<sal_uInt32>::iterator SvxNumberFormatShell::GetAdded_Impl( size_t nKey )
1189 : {
1190 0 : return ::std::find(aAddList.begin(), aAddList.end(), nKey);
1191 : }
1192 :
1193 : //------------------------------------------------------------------------
1194 :
1195 0 : bool SvxNumberFormatShell::IsAdded_Impl( size_t nKey )
1196 : {
1197 0 : return GetAdded_Impl( nKey ) != aAddList.end();
1198 : }
1199 :
1200 : // -----------------------------------------------------------------------
1201 : // Konvertierungs-Routinen:
1202 : // ------------------------
1203 :
1204 0 : void SvxNumberFormatShell::PosToCategory_Impl( sal_uInt16 nPos, short& rCategory )
1205 : {
1206 : // Kategorie ::com::sun::star::form-Positionen abbilden (->Resource)
1207 0 : switch ( nPos )
1208 : {
1209 0 : case CAT_USERDEFINED: rCategory = NUMBERFORMAT_DEFINED; break;
1210 0 : case CAT_NUMBER: rCategory = NUMBERFORMAT_NUMBER; break;
1211 0 : case CAT_PERCENT: rCategory = NUMBERFORMAT_PERCENT; break;
1212 0 : case CAT_CURRENCY: rCategory = NUMBERFORMAT_CURRENCY; break;
1213 0 : case CAT_DATE: rCategory = NUMBERFORMAT_DATE; break;
1214 0 : case CAT_TIME: rCategory = NUMBERFORMAT_TIME; break;
1215 0 : case CAT_SCIENTIFIC: rCategory = NUMBERFORMAT_SCIENTIFIC; break;
1216 0 : case CAT_FRACTION: rCategory = NUMBERFORMAT_FRACTION; break;
1217 0 : case CAT_BOOLEAN: rCategory = NUMBERFORMAT_LOGICAL; break;
1218 0 : case CAT_TEXT: rCategory = NUMBERFORMAT_TEXT; break;
1219 : case CAT_ALL:
1220 0 : default: rCategory = NUMBERFORMAT_ALL; break;
1221 : }
1222 0 : }
1223 :
1224 : // -----------------------------------------------------------------------
1225 :
1226 0 : void SvxNumberFormatShell::CategoryToPos_Impl( short nCategory, sal_uInt16& rPos )
1227 : {
1228 : // Kategorie auf ::com::sun::star::form-Positionen abbilden (->Resource)
1229 0 : switch ( nCategory )
1230 : {
1231 0 : case NUMBERFORMAT_DEFINED: rPos = CAT_USERDEFINED; break;
1232 0 : case NUMBERFORMAT_NUMBER: rPos = CAT_NUMBER; break;
1233 0 : case NUMBERFORMAT_PERCENT: rPos = CAT_PERCENT; break;
1234 0 : case NUMBERFORMAT_CURRENCY: rPos = CAT_CURRENCY; break;
1235 : case NUMBERFORMAT_DATETIME:
1236 0 : case NUMBERFORMAT_DATE: rPos = CAT_DATE; break;
1237 0 : case NUMBERFORMAT_TIME: rPos = CAT_TIME; break;
1238 0 : case NUMBERFORMAT_SCIENTIFIC: rPos = CAT_SCIENTIFIC; break;
1239 0 : case NUMBERFORMAT_FRACTION: rPos = CAT_FRACTION; break;
1240 0 : case NUMBERFORMAT_LOGICAL: rPos = CAT_BOOLEAN; break;
1241 0 : case NUMBERFORMAT_TEXT: rPos = CAT_TEXT; break;
1242 : case NUMBERFORMAT_ALL:
1243 0 : default: rPos = CAT_ALL;
1244 : }
1245 0 : }
1246 :
1247 :
1248 : /*************************************************************************
1249 : #* Member: MakePrevStringFromVal Datum:19.09.97
1250 : #*------------------------------------------------------------------------
1251 : #*
1252 : #* Klasse: SvxNumberFormatShell
1253 : #*
1254 : #* Funktion: Formatiert die Zahl nValue abhaengig von rFormatStr
1255 : #* und speichert das Ergebnis in rPreviewStr.
1256 : #*
1257 : #* Input: FormatString, Farbe, zu formatierende Zahl
1258 : #*
1259 : #* Output: Ausgabestring rPreviewStr
1260 : #*
1261 : #************************************************************************/
1262 :
1263 0 : void SvxNumberFormatShell::MakePrevStringFromVal(
1264 : const String& rFormatStr,
1265 : String& rPreviewStr,
1266 : Color*& rpFontColor,
1267 : double nValue)
1268 : {
1269 0 : rpFontColor = NULL;
1270 0 : OUString sTempOut(rPreviewStr);
1271 0 : pFormatter->GetPreviewString( rFormatStr, nValue, sTempOut, &rpFontColor, eCurLanguage );
1272 0 : rPreviewStr = sTempOut;
1273 0 : }
1274 :
1275 : /*************************************************************************
1276 : #* Member: GetComment4Entry Datum:30.10.97
1277 : #*------------------------------------------------------------------------
1278 : #*
1279 : #* Klasse: SvxNumberFormatShell
1280 : #*
1281 : #* Funktion: Liefert den Kommentar fuer einen gegebenen
1282 : #* Eintrag zurueck.
1283 : #*
1284 : #* Input: Nummer des Eintrags
1285 : #*
1286 : #* Output: Kommentar-String
1287 : #*
1288 : #************************************************************************/
1289 :
1290 0 : void SvxNumberFormatShell::SetComment4Entry(short nEntry,String aEntStr)
1291 : {
1292 : SvNumberformat *pNumEntry;
1293 0 : if(nEntry<0) return;
1294 0 : sal_uInt32 nMyNfEntry=aCurEntryList[nEntry];
1295 0 : pNumEntry = (SvNumberformat*)pFormatter->GetEntry(nMyNfEntry);
1296 0 : if(pNumEntry!=NULL) pNumEntry->SetComment(aEntStr);
1297 : }
1298 :
1299 : /*************************************************************************
1300 : #* Member: GetComment4Entry Datum:30.10.97
1301 : #*------------------------------------------------------------------------
1302 : #*
1303 : #* Klasse: SvxNumberFormatShell
1304 : #*
1305 : #* Funktion: Liefert den Kommentar fuer einen gegebenen
1306 : #* Eintrag zurueck.
1307 : #*
1308 : #* Input: Nummer des Eintrags
1309 : #*
1310 : #* Output: Kommentar-String
1311 : #*
1312 : #************************************************************************/
1313 :
1314 0 : String SvxNumberFormatShell::GetComment4Entry(short nEntry)
1315 : {
1316 0 : if(nEntry < 0)
1317 0 : return String();
1318 :
1319 0 : if( static_cast<size_t>(nEntry) < aCurEntryList.size())
1320 : {
1321 0 : sal_uInt32 nMyNfEntry=aCurEntryList[nEntry];
1322 0 : const SvNumberformat *pNumEntry = pFormatter->GetEntry(nMyNfEntry);
1323 0 : if(pNumEntry!=NULL)
1324 0 : return pNumEntry->GetComment();
1325 : }
1326 :
1327 0 : return String();
1328 : }
1329 :
1330 : /*************************************************************************
1331 : #* Member: GetCategory4Entry Datum:30.10.97
1332 : #*------------------------------------------------------------------------
1333 : #*
1334 : #* Klasse: SvxNumberFormatShell
1335 : #*
1336 : #* Funktion: Liefert die Kategorie- Nummer fuer einen gegebenen
1337 : #* Eintrag zurueck.
1338 : #*
1339 : #* Input: Nummer des Eintrags
1340 : #*
1341 : #* Output: Kategorie- Nummer
1342 : #*
1343 : #************************************************************************/
1344 :
1345 0 : short SvxNumberFormatShell::GetCategory4Entry(short nEntry)
1346 : {
1347 0 : if(nEntry<0) return 0;
1348 :
1349 0 : if( static_cast<size_t>(nEntry) < aCurEntryList.size() )
1350 : {
1351 0 : sal_uInt32 nMyNfEntry=aCurEntryList[nEntry];
1352 :
1353 0 : if(nMyNfEntry!=NUMBERFORMAT_ENTRY_NOT_FOUND)
1354 : {
1355 0 : const SvNumberformat *pNumEntry = pFormatter->GetEntry(nMyNfEntry);
1356 : sal_uInt16 nMyCat,nMyType;
1357 0 : if(pNumEntry!=NULL)
1358 : {
1359 0 : nMyCat=pNumEntry->GetType() & ~NUMBERFORMAT_DEFINED;
1360 0 : CategoryToPos_Impl(nMyCat,nMyType);
1361 :
1362 0 : return (short) nMyType;
1363 : }
1364 0 : return 0;
1365 : }
1366 0 : else if( !aCurrencyFormatList.empty() )
1367 : {
1368 0 : return CAT_CURRENCY;
1369 : }
1370 : }
1371 0 : return 0;
1372 :
1373 : }
1374 :
1375 : /*************************************************************************
1376 : #* Member: GetUserDefined4Entry Datum:31.10.97
1377 : #*------------------------------------------------------------------------
1378 : #*
1379 : #* Klasse: SvxNumberFormatShell
1380 : #*
1381 : #* Funktion: Liefert die Information, ob ein Eintrag
1382 : #* benutzerspezifisch ist zurueck.
1383 : #*
1384 : #* Input: Nummer des Eintrags
1385 : #*
1386 : #* Output: Benutzerspezifisch?
1387 : #*
1388 : #************************************************************************/
1389 :
1390 0 : bool SvxNumberFormatShell::GetUserDefined4Entry(short nEntry)
1391 : {
1392 0 : if(nEntry<0) return false;
1393 :
1394 0 : if( static_cast<size_t>(nEntry) < aCurEntryList.size())
1395 : {
1396 0 : sal_uInt32 nMyNfEntry=aCurEntryList[nEntry];
1397 0 : const SvNumberformat *pNumEntry = pFormatter->GetEntry(nMyNfEntry);
1398 :
1399 0 : if(pNumEntry!=NULL)
1400 : {
1401 0 : if((pNumEntry->GetType() & NUMBERFORMAT_DEFINED)>0)
1402 : {
1403 0 : return true;
1404 : }
1405 : }
1406 : }
1407 0 : return false;
1408 : }
1409 :
1410 :
1411 : /*************************************************************************
1412 : #* Member: GetFormat4Entry Datum:30.10.97
1413 : #*------------------------------------------------------------------------
1414 : #*
1415 : #* Klasse: SvxNumberFormatShell
1416 : #*
1417 : #* Funktion: Liefert den Format- String fuer einen gegebenen
1418 : #* Eintrag zurueck.
1419 : #*
1420 : #* Input: Nummer des Eintrags
1421 : #*
1422 : #* Output: Format- String
1423 : #*
1424 : #************************************************************************/
1425 :
1426 0 : String SvxNumberFormatShell::GetFormat4Entry(short nEntry)
1427 : {
1428 0 : if(nEntry < 0)
1429 0 : return String();
1430 :
1431 0 : if( !aCurrencyFormatList.empty() )
1432 : {
1433 0 : if( aCurrencyFormatList.size() > static_cast<size_t>(nEntry) )
1434 0 : return *aCurrencyFormatList[nEntry];
1435 : }
1436 : else
1437 : {
1438 0 : sal_uInt32 nMyNfEntry=aCurEntryList[nEntry];
1439 0 : const SvNumberformat *pNumEntry = pFormatter->GetEntry(nMyNfEntry);
1440 :
1441 0 : if(pNumEntry!=NULL)
1442 0 : return pNumEntry->GetFormatstring();
1443 : }
1444 0 : return String();
1445 : }
1446 :
1447 : /*************************************************************************
1448 : #* Member: GetListPos4Entry Datum:31.10.97
1449 : #*------------------------------------------------------------------------
1450 : #*
1451 : #* Klasse: SvxNumberFormatShell
1452 : #*
1453 : #* Funktion: Liefert die Listen- Nummer fuer einen gegebenen
1454 : #* Formatindex zurueck.
1455 : #*
1456 : #* Input: Nummer des Eintrags
1457 : #*
1458 : #* Output: Kategorie- Nummer
1459 : #*
1460 : #************************************************************************/
1461 :
1462 0 : short SvxNumberFormatShell::GetListPos4Entry(sal_uInt32 nIdx)
1463 : {
1464 0 : short nSelP=SELPOS_NONE;
1465 :
1466 : // Check list size against return type limit.
1467 0 : if( aCurEntryList.size() <= static_cast<size_t>(::std::numeric_limits< short >::max()) )
1468 : {
1469 0 : for(size_t i=0; i < aCurEntryList.size(); ++i)
1470 : {
1471 0 : if(aCurEntryList[i]==nIdx)
1472 : {
1473 0 : nSelP=i;
1474 0 : break;
1475 : }
1476 : }
1477 : }
1478 : else
1479 : {
1480 : OSL_FAIL("svx::SvxNumberFormatShell::GetListPos4Entry(), list got too large!" );
1481 : }
1482 0 : return nSelP;
1483 : }
1484 :
1485 0 : short SvxNumberFormatShell::GetListPos4Entry( const String& rFmtString )
1486 : {
1487 0 : sal_uInt32 nAt=0;
1488 0 : short nSelP=SELPOS_NONE;
1489 0 : if(FindEntry(rFmtString, &nAt))
1490 : {
1491 0 : if(NUMBERFORMAT_ENTRY_NOT_FOUND!=nAt && NUMBERFORMAT_ENTRY_NEW_CURRENCY!=nAt)
1492 : {
1493 0 : nSelP=GetListPos4Entry(nAt);
1494 : }
1495 : else
1496 : {
1497 0 : for( size_t i=0; i<aCurrencyFormatList.size(); i++ )
1498 : {
1499 0 : if (rFmtString==*aCurrencyFormatList[i])
1500 : {
1501 0 : nSelP = static_cast<short>(i);
1502 0 : break;
1503 : }
1504 : }
1505 : }
1506 : }
1507 0 : return nSelP;
1508 : }
1509 :
1510 0 : String SvxNumberFormatShell::GetStandardName() const
1511 : {
1512 0 : return pFormatter->GetStandardName( eCurLanguage);
1513 : }
1514 :
1515 0 : void SvxNumberFormatShell::GetCurrencySymbols(std::vector<rtl::OUString>& rList, sal_uInt16* pPos)
1516 : {
1517 0 : const NfCurrencyEntry* pTmpCurrencyEntry=SvNumberFormatter::MatchSystemCurrency();
1518 :
1519 0 : bool bFlag=(pTmpCurrencyEntry==NULL);
1520 :
1521 0 : GetCurrencySymbols(rList, bFlag);
1522 :
1523 0 : if(pPos!=NULL)
1524 : {
1525 0 : const NfCurrencyTable& rCurrencyTable=SvNumberFormatter::GetTheCurrencyTable();
1526 0 : sal_uInt16 nTableCount=rCurrencyTable.size();
1527 :
1528 0 : *pPos=0;
1529 0 : size_t nCount=aCurCurrencyList.size();
1530 :
1531 0 : if(bFlag)
1532 : {
1533 0 : *pPos=1;
1534 0 : nCurCurrencyEntryPos=1;
1535 : }
1536 : else
1537 : {
1538 0 : for(size_t i=1;i<nCount;i++)
1539 : {
1540 0 : const sal_uInt16 j = aCurCurrencyList[i];
1541 0 : if (j != (sal_uInt16)-1 && j < nTableCount &&
1542 0 : pTmpCurrencyEntry == &rCurrencyTable[j])
1543 : {
1544 0 : *pPos=static_cast<sal_uInt16>(i);
1545 0 : nCurCurrencyEntryPos=static_cast<sal_uInt16>(i);
1546 0 : break;
1547 : }
1548 : }
1549 : }
1550 : }
1551 :
1552 0 : }
1553 :
1554 0 : void SvxNumberFormatShell::GetCurrencySymbols(std::vector<rtl::OUString>& rList, bool bFlag)
1555 : {
1556 0 : aCurCurrencyList.clear();
1557 :
1558 0 : const NfCurrencyTable& rCurrencyTable=SvNumberFormatter::GetTheCurrencyTable();
1559 0 : sal_uInt16 nCount=rCurrencyTable.size();
1560 :
1561 0 : SvtLanguageTable* pLanguageTable=new SvtLanguageTable;
1562 :
1563 0 : sal_uInt16 nStart=1;
1564 :
1565 0 : XubString aString( ApplyLreOrRleEmbedding( rCurrencyTable[0].GetSymbol()));
1566 0 : aString += sal_Unicode(' ');
1567 0 : aString += ApplyLreOrRleEmbedding( pLanguageTable->GetString( rCurrencyTable[0].GetLanguage()));
1568 :
1569 0 : rList.push_back(aString);
1570 0 : sal_uInt16 nAuto=(sal_uInt16)-1;
1571 0 : aCurCurrencyList.push_back(nAuto);
1572 :
1573 0 : if(bFlag)
1574 : {
1575 0 : rList.push_back(aString);
1576 0 : aCurCurrencyList.push_back(0);
1577 0 : ++nStart;
1578 : }
1579 :
1580 0 : CollatorWrapper aCollator( ::comphelper::getProcessComponentContext());
1581 0 : aCollator.loadDefaultCollator( Application::GetSettings().GetLanguageTag().getLocale(), 0);
1582 :
1583 0 : const String aTwoSpace( RTL_CONSTASCII_USTRINGPARAM( " "));
1584 :
1585 0 : for(sal_uInt16 i = 1; i < nCount; ++i)
1586 : {
1587 0 : XubString aStr( ApplyLreOrRleEmbedding( rCurrencyTable[i].GetBankSymbol()));
1588 0 : aStr += aTwoSpace;
1589 0 : aStr += ApplyLreOrRleEmbedding( rCurrencyTable[i].GetSymbol());
1590 0 : aStr += aTwoSpace;
1591 0 : aStr += ApplyLreOrRleEmbedding( pLanguageTable->GetString( rCurrencyTable[i].GetLanguage()));
1592 :
1593 0 : sal_uInt16 j = nStart;
1594 0 : for(; j < rList.size(); ++j)
1595 0 : if (aCollator.compareString(aStr, rList[j]) < 0)
1596 0 : break; // insert before first greater than
1597 :
1598 0 : rList.insert(rList.begin() + j, aStr);
1599 0 : aCurCurrencyList.insert(aCurCurrencyList.begin() + j, i);
1600 0 : }
1601 :
1602 : // Append ISO codes to symbol list.
1603 : // XXX If this is to be changed, various other places would had to be
1604 : // adapted that assume this order!
1605 0 : sal_uInt16 nCont = rList.size();
1606 :
1607 0 : for(sal_uInt16 i = 1; i < nCount; ++i)
1608 : {
1609 0 : bool bInsert = true;
1610 0 : rtl::OUString aStr(ApplyLreOrRleEmbedding(rCurrencyTable[i].GetBankSymbol()));
1611 :
1612 0 : sal_uInt16 j = nCont;
1613 0 : for(; j < rList.size() && bInsert; ++j)
1614 : {
1615 0 : if(rList[j] == aStr)
1616 0 : bInsert = false;
1617 0 : else if (aCollator.compareString(aStr, rList[j]) < 0)
1618 0 : break; // insert before first greater than
1619 : }
1620 0 : if(bInsert)
1621 : {
1622 0 : rList.insert(rList.begin() + j, aStr);
1623 0 : aCurCurrencyList.insert(aCurCurrencyList.begin()+j, i);
1624 : }
1625 0 : }
1626 :
1627 0 : delete pLanguageTable;
1628 0 : }
1629 :
1630 0 : void SvxNumberFormatShell::SetCurrencySymbol(sal_uInt16 nPos)
1631 : {
1632 0 : const NfCurrencyTable& rCurrencyTable=SvNumberFormatter::GetTheCurrencyTable();
1633 0 : sal_uInt16 nCount=rCurrencyTable.size();
1634 :
1635 0 : bBankingSymbol=(nPos>=nCount);
1636 :
1637 0 : if(nPos<aCurCurrencyList.size())
1638 : {
1639 0 : sal_uInt16 nCurrencyPos=aCurCurrencyList[nPos];
1640 0 : if(nCurrencyPos!=(sal_uInt16)-1)
1641 : {
1642 0 : pCurCurrencyEntry=(NfCurrencyEntry*)&rCurrencyTable[nCurrencyPos];
1643 0 : nCurCurrencyEntryPos=nPos;
1644 : }
1645 : else
1646 : {
1647 0 : pCurCurrencyEntry=NULL;
1648 0 : nCurCurrencyEntryPos=0;
1649 : nCurFormatKey=pFormatter->GetFormatIndex(
1650 0 : NF_CURRENCY_1000DEC2_RED, eCurLanguage);
1651 : }
1652 : }
1653 0 : }
1654 :
1655 0 : sal_uInt32 SvxNumberFormatShell::GetCurrencySymbol()
1656 : {
1657 0 : return nCurCurrencyEntryPos;
1658 : }
1659 :
1660 0 : void SvxNumberFormatShell::SetCurCurrencyEntry(NfCurrencyEntry* pCEntry)
1661 : {
1662 0 : pCurCurrencyEntry=pCEntry;
1663 0 : }
1664 :
1665 0 : bool SvxNumberFormatShell::IsTmpCurrencyFormat( const String& rFmtString )
1666 : {
1667 : sal_uInt32 nFound;
1668 0 : FindEntry(rFmtString, &nFound);
1669 :
1670 0 : if(nFound==NUMBERFORMAT_ENTRY_NEW_CURRENCY)
1671 : {
1672 0 : return true;
1673 : }
1674 0 : return false;
1675 : }
1676 :
1677 0 : sal_uInt16 SvxNumberFormatShell::FindCurrencyFormat( const String& rFmtString )
1678 : {
1679 0 : const NfCurrencyTable& rCurrencyTable=SvNumberFormatter::GetTheCurrencyTable();
1680 0 : sal_uInt16 nCount=rCurrencyTable.size();
1681 :
1682 0 : bool bTestBanking=false;
1683 :
1684 0 : sal_uInt16 nPos=FindCurrencyTableEntry(rFmtString, bTestBanking);
1685 :
1686 0 : if(nPos!=(sal_uInt16)-1)
1687 : {
1688 0 : sal_uInt16 nStart=0;
1689 0 : if(bTestBanking && aCurCurrencyList.size()>nPos)
1690 : {
1691 0 : nStart=nCount;
1692 : }
1693 0 : for(sal_uInt16 j=nStart;j<aCurCurrencyList.size();j++)
1694 : {
1695 0 : if(aCurCurrencyList[j]==nPos) return j;
1696 : }
1697 : }
1698 0 : return (sal_uInt16) -1;
1699 : }
1700 :
1701 0 : sal_uInt16 SvxNumberFormatShell::FindCurrencyTableEntry( const String& rFmtString, bool &bTestBanking )
1702 : {
1703 0 : sal_uInt16 nPos=(sal_uInt16) -1;
1704 :
1705 0 : const NfCurrencyTable& rCurrencyTable=SvNumberFormatter::GetTheCurrencyTable();
1706 0 : sal_uInt16 nCount=rCurrencyTable.size();
1707 :
1708 : const SvNumberformat* pFormat;
1709 0 : OUString aSymbol, aExtension;
1710 0 : sal_uInt32 nFound = pFormatter->TestNewString( rFmtString, eCurLanguage );
1711 0 : if ( nFound != NUMBERFORMAT_ENTRY_NOT_FOUND &&
1712 0 : ((pFormat = pFormatter->GetEntry( nFound )) != 0) &&
1713 0 : pFormat->GetNewCurrencySymbol( aSymbol, aExtension ) )
1714 : { // eventually match with format locale
1715 : const NfCurrencyEntry* pTmpCurrencyEntry =
1716 : SvNumberFormatter::GetCurrencyEntry( bTestBanking, aSymbol, aExtension,
1717 0 : pFormat->GetLanguage() );
1718 0 : if ( pTmpCurrencyEntry )
1719 : {
1720 0 : for(sal_uInt16 i=0;i<nCount;i++)
1721 : {
1722 0 : if(pTmpCurrencyEntry==&rCurrencyTable[i])
1723 : {
1724 0 : nPos=i;
1725 0 : break;
1726 : }
1727 : }
1728 : }
1729 : }
1730 : else
1731 : { // search symbol string only
1732 0 : for(sal_uInt16 i=0;i<nCount;i++)
1733 : {
1734 0 : const NfCurrencyEntry* pTmpCurrencyEntry=&rCurrencyTable[i];
1735 0 : OUString _aSymbol = pTmpCurrencyEntry->BuildSymbolString(false);
1736 0 : OUString aBankSymbol = pTmpCurrencyEntry->BuildSymbolString(true);
1737 :
1738 0 : if(rFmtString.Search(_aSymbol)!=STRING_NOTFOUND)
1739 : {
1740 0 : bTestBanking=false;
1741 0 : nPos=i;
1742 : break;
1743 : }
1744 0 : else if(rFmtString.Search(aBankSymbol)!=STRING_NOTFOUND)
1745 : {
1746 0 : bTestBanking=true;
1747 0 : nPos=i;
1748 : break;
1749 : }
1750 0 : }
1751 : }
1752 :
1753 0 : return nPos;
1754 : }
1755 :
1756 0 : sal_uInt16 SvxNumberFormatShell::FindCurrencyFormat(const NfCurrencyEntry* pTmpCurrencyEntry,bool bTmpBanking)
1757 : {
1758 0 : const NfCurrencyTable& rCurrencyTable=SvNumberFormatter::GetTheCurrencyTable();
1759 0 : sal_uInt16 nCount=rCurrencyTable.size();
1760 :
1761 0 : sal_uInt16 nPos=0;
1762 0 : for(sal_uInt16 i=0;i<nCount;i++)
1763 : {
1764 0 : if(pTmpCurrencyEntry==&rCurrencyTable[i])
1765 : {
1766 0 : nPos=i;
1767 0 : break;
1768 : }
1769 : }
1770 :
1771 0 : sal_uInt16 nStart=0;
1772 0 : if(bTmpBanking && aCurCurrencyList.size()>nPos)
1773 : {
1774 0 : nStart=nCount;
1775 : }
1776 0 : for(sal_uInt16 j=nStart;j<aCurCurrencyList.size();j++)
1777 : {
1778 0 : if(aCurCurrencyList[j]==nPos) return j;
1779 : }
1780 0 : return (sal_uInt16) -1;
1781 : }
1782 :
1783 0 : bool SvxNumberFormatShell::IsInTable(sal_uInt16 const nPos,
1784 : bool const bTmpBanking, ::rtl::OUString const& rFmtString)
1785 : {
1786 0 : bool bFlag=false;
1787 :
1788 0 : if(nPos!=(sal_uInt16)-1)
1789 : {
1790 0 : const NfCurrencyTable& rCurrencyTable=SvNumberFormatter::GetTheCurrencyTable();
1791 0 : sal_uInt16 nCount=rCurrencyTable.size();
1792 :
1793 0 : if(nPos<nCount)
1794 : {
1795 0 : NfWSStringsDtor aWSStringsDtor;
1796 :
1797 0 : const NfCurrencyEntry* pTmpCurrencyEntry=&rCurrencyTable[nPos];
1798 :
1799 0 : if ( pTmpCurrencyEntry!=NULL)
1800 : {
1801 : pFormatter->GetCurrencyFormatStrings( aWSStringsDtor,
1802 0 : *pTmpCurrencyEntry, bTmpBanking );
1803 :
1804 0 : for(sal_uInt16 i=0;i<aWSStringsDtor.size();i++)
1805 : {
1806 0 : if (aWSStringsDtor[i] == rFmtString)
1807 : {
1808 0 : bFlag=true;
1809 0 : break;
1810 : }
1811 : }
1812 0 : }
1813 : }
1814 : }
1815 :
1816 0 : return bFlag;
1817 : }
1818 :
1819 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
