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