svx/source/items/numfmtsh.cxx

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