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