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