1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski
24*b1cdbd2cSJim Jagielski // MARKER(update_precomp.py): autogen include statement, do not remove
25*b1cdbd2cSJim Jagielski #include "precompiled_basic.hxx"
26*b1cdbd2cSJim Jagielski #include <tools/errcode.hxx>
27*b1cdbd2cSJim Jagielski #include <basic/sbx.hxx>
28*b1cdbd2cSJim Jagielski #include "sbxconv.hxx"
29*b1cdbd2cSJim Jagielski
30*b1cdbd2cSJim Jagielski #include "unotools/syslocale.hxx"
31*b1cdbd2cSJim Jagielski
32*b1cdbd2cSJim Jagielski #if defined ( UNX )
33*b1cdbd2cSJim Jagielski #include <stdlib.h>
34*b1cdbd2cSJim Jagielski #endif
35*b1cdbd2cSJim Jagielski
36*b1cdbd2cSJim Jagielski #ifndef _APP_HXX //autogen
37*b1cdbd2cSJim Jagielski #include <vcl/svapp.hxx>
38*b1cdbd2cSJim Jagielski #endif
39*b1cdbd2cSJim Jagielski #include <math.h>
40*b1cdbd2cSJim Jagielski #include <string.h>
41*b1cdbd2cSJim Jagielski #include <ctype.h>
42*b1cdbd2cSJim Jagielski
43*b1cdbd2cSJim Jagielski #include "sbxres.hxx"
44*b1cdbd2cSJim Jagielski #include <basic/sbxbase.hxx>
45*b1cdbd2cSJim Jagielski #include <basic/sbxform.hxx>
46*b1cdbd2cSJim Jagielski #include <svtools/svtools.hrc>
47*b1cdbd2cSJim Jagielski
48*b1cdbd2cSJim Jagielski #include "basrid.hxx"
49*b1cdbd2cSJim Jagielski #include "runtime.hxx"
50*b1cdbd2cSJim Jagielski
51*b1cdbd2cSJim Jagielski #include <svl/zforlist.hxx>
52*b1cdbd2cSJim Jagielski #include <comphelper/processfactory.hxx>
53*b1cdbd2cSJim Jagielski
54*b1cdbd2cSJim Jagielski
ImpGetIntntlSep(sal_Unicode & rcDecimalSep,sal_Unicode & rcThousandSep)55*b1cdbd2cSJim Jagielski void ImpGetIntntlSep( sal_Unicode& rcDecimalSep, sal_Unicode& rcThousandSep )
56*b1cdbd2cSJim Jagielski {
57*b1cdbd2cSJim Jagielski SvtSysLocale aSysLocale;
58*b1cdbd2cSJim Jagielski const LocaleDataWrapper& rData = aSysLocale.GetLocaleData();
59*b1cdbd2cSJim Jagielski rcDecimalSep = rData.getNumDecimalSep().GetBuffer()[0];
60*b1cdbd2cSJim Jagielski rcThousandSep = rData.getNumThousandSep().GetBuffer()[0];
61*b1cdbd2cSJim Jagielski }
62*b1cdbd2cSJim Jagielski
63*b1cdbd2cSJim Jagielski // Scannen eines Strings nach BASIC-Konventionen
64*b1cdbd2cSJim Jagielski // Dies entspricht den ueblichen Konventionen, nur dass der Exponent
65*b1cdbd2cSJim Jagielski // auch ein D sein darf, was den Datentyp auf SbxDOUBLE festlegt.
66*b1cdbd2cSJim Jagielski // Die Routine versucht, den Datentyp so klein wie moeglich zu gestalten.
67*b1cdbd2cSJim Jagielski // Das ganze gibt auch noch einen Konversionsfehler, wenn der Datentyp
68*b1cdbd2cSJim Jagielski // Fixed ist und das ganze nicht hineinpasst!
69*b1cdbd2cSJim Jagielski
ImpScan(const::rtl::OUString & rWSrc,double & nVal,SbxDataType & rType,sal_uInt16 * pLen,sal_Bool bAllowIntntl,sal_Bool bOnlyIntntl)70*b1cdbd2cSJim Jagielski SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType,
71*b1cdbd2cSJim Jagielski sal_uInt16* pLen, sal_Bool bAllowIntntl, sal_Bool bOnlyIntntl )
72*b1cdbd2cSJim Jagielski {
73*b1cdbd2cSJim Jagielski ::rtl::OString aBStr( ::rtl::OUStringToOString( rWSrc, RTL_TEXTENCODING_ASCII_US ) );
74*b1cdbd2cSJim Jagielski
75*b1cdbd2cSJim Jagielski // Bei International Komma besorgen
76*b1cdbd2cSJim Jagielski char cIntntlComma, cIntntl1000;
77*b1cdbd2cSJim Jagielski char cNonIntntlComma = '.';
78*b1cdbd2cSJim Jagielski
79*b1cdbd2cSJim Jagielski sal_Unicode cDecimalSep, cThousandSep = 0;
80*b1cdbd2cSJim Jagielski if( bAllowIntntl || bOnlyIntntl )
81*b1cdbd2cSJim Jagielski {
82*b1cdbd2cSJim Jagielski ImpGetIntntlSep( cDecimalSep, cThousandSep );
83*b1cdbd2cSJim Jagielski cIntntlComma = (char)cDecimalSep;
84*b1cdbd2cSJim Jagielski cIntntl1000 = (char)cThousandSep;
85*b1cdbd2cSJim Jagielski }
86*b1cdbd2cSJim Jagielski // Sonst einfach auch auf . setzen
87*b1cdbd2cSJim Jagielski else
88*b1cdbd2cSJim Jagielski {
89*b1cdbd2cSJim Jagielski cIntntlComma = cNonIntntlComma;
90*b1cdbd2cSJim Jagielski cIntntl1000 = cNonIntntlComma; // Unschaedlich machen
91*b1cdbd2cSJim Jagielski }
92*b1cdbd2cSJim Jagielski // Nur International -> IntnlComma uebernehmen
93*b1cdbd2cSJim Jagielski if( bOnlyIntntl )
94*b1cdbd2cSJim Jagielski {
95*b1cdbd2cSJim Jagielski cNonIntntlComma = cIntntlComma;
96*b1cdbd2cSJim Jagielski cIntntl1000 = (char)cThousandSep;
97*b1cdbd2cSJim Jagielski }
98*b1cdbd2cSJim Jagielski
99*b1cdbd2cSJim Jagielski const char* pStart = aBStr.getStr();
100*b1cdbd2cSJim Jagielski const char* p = pStart;
101*b1cdbd2cSJim Jagielski char buf[ 80 ], *q = buf;
102*b1cdbd2cSJim Jagielski sal_Bool bRes = sal_True;
103*b1cdbd2cSJim Jagielski sal_Bool bMinus = sal_False;
104*b1cdbd2cSJim Jagielski nVal = 0;
105*b1cdbd2cSJim Jagielski SbxDataType eScanType = SbxSINGLE;
106*b1cdbd2cSJim Jagielski // Whitespace wech
107*b1cdbd2cSJim Jagielski while( *p &&( *p == ' ' || *p == '\t' ) ) p++;
108*b1cdbd2cSJim Jagielski // Zahl? Dann einlesen und konvertieren.
109*b1cdbd2cSJim Jagielski if( *p == '-' )
110*b1cdbd2cSJim Jagielski p++, bMinus = sal_True;
111*b1cdbd2cSJim Jagielski if( isdigit( *p ) ||( (*p == cNonIntntlComma || *p == cIntntlComma ||
112*b1cdbd2cSJim Jagielski *p == cIntntl1000) && isdigit( *(p+1 ) ) ) )
113*b1cdbd2cSJim Jagielski {
114*b1cdbd2cSJim Jagielski short exp = 0; // >0: Exponentteil
115*b1cdbd2cSJim Jagielski short comma = 0; // >0: Nachkomma
116*b1cdbd2cSJim Jagielski short ndig = 0; // Anzahl Ziffern
117*b1cdbd2cSJim Jagielski short ncdig = 0; // Anzahl Ziffern nach Komma
118*b1cdbd2cSJim Jagielski ByteString aSearchStr( "0123456789DEde" );
119*b1cdbd2cSJim Jagielski // Kommas ergaenzen
120*b1cdbd2cSJim Jagielski aSearchStr += cNonIntntlComma;
121*b1cdbd2cSJim Jagielski if( cIntntlComma != cNonIntntlComma )
122*b1cdbd2cSJim Jagielski aSearchStr += cIntntlComma;
123*b1cdbd2cSJim Jagielski if( bOnlyIntntl )
124*b1cdbd2cSJim Jagielski aSearchStr += cIntntl1000;
125*b1cdbd2cSJim Jagielski const char* pSearchStr = aSearchStr.GetBuffer();
126*b1cdbd2cSJim Jagielski while( strchr( pSearchStr, *p ) && *p )
127*b1cdbd2cSJim Jagielski {
128*b1cdbd2cSJim Jagielski // 1000er-Trenner ueberlesen
129*b1cdbd2cSJim Jagielski if( bOnlyIntntl && *p == cIntntl1000 )
130*b1cdbd2cSJim Jagielski {
131*b1cdbd2cSJim Jagielski p++;
132*b1cdbd2cSJim Jagielski continue;
133*b1cdbd2cSJim Jagielski }
134*b1cdbd2cSJim Jagielski
135*b1cdbd2cSJim Jagielski // Komma oder Exponent?
136*b1cdbd2cSJim Jagielski if( *p == cNonIntntlComma || *p == cIntntlComma )
137*b1cdbd2cSJim Jagielski {
138*b1cdbd2cSJim Jagielski // Immer '.' einfuegen, damit atof funktioniert
139*b1cdbd2cSJim Jagielski p++;
140*b1cdbd2cSJim Jagielski if( ++comma > 1 )
141*b1cdbd2cSJim Jagielski continue;
142*b1cdbd2cSJim Jagielski else
143*b1cdbd2cSJim Jagielski *q++ = '.';
144*b1cdbd2cSJim Jagielski }
145*b1cdbd2cSJim Jagielski else if( strchr( "DdEe", *p ) )
146*b1cdbd2cSJim Jagielski {
147*b1cdbd2cSJim Jagielski if( ++exp > 1 )
148*b1cdbd2cSJim Jagielski {
149*b1cdbd2cSJim Jagielski p++; continue;
150*b1cdbd2cSJim Jagielski }
151*b1cdbd2cSJim Jagielski if( toupper( *p ) == 'D' )
152*b1cdbd2cSJim Jagielski eScanType = SbxDOUBLE;
153*b1cdbd2cSJim Jagielski *q++ = 'E'; p++;
154*b1cdbd2cSJim Jagielski // Vorzeichen hinter Exponent?
155*b1cdbd2cSJim Jagielski if( *p == '+' )
156*b1cdbd2cSJim Jagielski p++;
157*b1cdbd2cSJim Jagielski else
158*b1cdbd2cSJim Jagielski if( *p == '-' )
159*b1cdbd2cSJim Jagielski *q++ = *p++;
160*b1cdbd2cSJim Jagielski }
161*b1cdbd2cSJim Jagielski else
162*b1cdbd2cSJim Jagielski {
163*b1cdbd2cSJim Jagielski *q++ = *p++;
164*b1cdbd2cSJim Jagielski if( comma && !exp ) ncdig++;
165*b1cdbd2cSJim Jagielski }
166*b1cdbd2cSJim Jagielski if( !exp ) ndig++;
167*b1cdbd2cSJim Jagielski }
168*b1cdbd2cSJim Jagielski *q = 0;
169*b1cdbd2cSJim Jagielski // Komma, Exponent mehrfach vorhanden?
170*b1cdbd2cSJim Jagielski if( comma > 1 || exp > 1 )
171*b1cdbd2cSJim Jagielski bRes = sal_False;
172*b1cdbd2cSJim Jagielski // Kann auf Integer gefaltet werden?
173*b1cdbd2cSJim Jagielski if( !comma && !exp )
174*b1cdbd2cSJim Jagielski {
175*b1cdbd2cSJim Jagielski if( nVal >= SbxMININT && nVal <= SbxMAXINT )
176*b1cdbd2cSJim Jagielski eScanType = SbxINTEGER;
177*b1cdbd2cSJim Jagielski else if( nVal >= SbxMINLNG && nVal <= SbxMAXLNG )
178*b1cdbd2cSJim Jagielski eScanType = SbxLONG;
179*b1cdbd2cSJim Jagielski }
180*b1cdbd2cSJim Jagielski
181*b1cdbd2cSJim Jagielski nVal = atof( buf );
182*b1cdbd2cSJim Jagielski ndig = ndig - comma;
183*b1cdbd2cSJim Jagielski // zu viele Zahlen fuer SINGLE?
184*b1cdbd2cSJim Jagielski if( ndig > 15 || ncdig > 6 )
185*b1cdbd2cSJim Jagielski eScanType = SbxDOUBLE;
186*b1cdbd2cSJim Jagielski
187*b1cdbd2cSJim Jagielski // Typkennung?
188*b1cdbd2cSJim Jagielski if( strchr( "%!&#", *p ) && *p ) p++;
189*b1cdbd2cSJim Jagielski }
190*b1cdbd2cSJim Jagielski // Hex/Oktalzahl? Einlesen und konvertieren:
191*b1cdbd2cSJim Jagielski else if( *p == '&' )
192*b1cdbd2cSJim Jagielski {
193*b1cdbd2cSJim Jagielski p++;
194*b1cdbd2cSJim Jagielski eScanType = SbxLONG;
195*b1cdbd2cSJim Jagielski const char *cmp = "0123456789ABCDEF";
196*b1cdbd2cSJim Jagielski char base = 16;
197*b1cdbd2cSJim Jagielski char ndig = 8;
198*b1cdbd2cSJim Jagielski char xch = *p++;
199*b1cdbd2cSJim Jagielski switch( toupper( xch ) )
200*b1cdbd2cSJim Jagielski {
201*b1cdbd2cSJim Jagielski case 'O': cmp = "01234567"; base = 8; ndig = 11; break;
202*b1cdbd2cSJim Jagielski case 'H': break;
203*b1cdbd2cSJim Jagielski default : bRes = sal_False;
204*b1cdbd2cSJim Jagielski }
205*b1cdbd2cSJim Jagielski long l = 0;
206*b1cdbd2cSJim Jagielski int i;
207*b1cdbd2cSJim Jagielski while( isalnum( *p ) )
208*b1cdbd2cSJim Jagielski {
209*b1cdbd2cSJim Jagielski char ch = sal::static_int_cast< char >( toupper( *p ) );
210*b1cdbd2cSJim Jagielski p++;
211*b1cdbd2cSJim Jagielski if( strchr( cmp, ch ) ) *q++ = ch;
212*b1cdbd2cSJim Jagielski else bRes = sal_False;
213*b1cdbd2cSJim Jagielski }
214*b1cdbd2cSJim Jagielski *q = 0;
215*b1cdbd2cSJim Jagielski for( q = buf; *q; q++ )
216*b1cdbd2cSJim Jagielski {
217*b1cdbd2cSJim Jagielski i =( *q & 0xFF ) - '0';
218*b1cdbd2cSJim Jagielski if( i > 9 ) i -= 7;
219*b1cdbd2cSJim Jagielski l =( l * base ) + i;
220*b1cdbd2cSJim Jagielski if( !ndig-- )
221*b1cdbd2cSJim Jagielski bRes = sal_False;
222*b1cdbd2cSJim Jagielski }
223*b1cdbd2cSJim Jagielski if( *p == '&' ) p++;
224*b1cdbd2cSJim Jagielski nVal = (double) l;
225*b1cdbd2cSJim Jagielski if( l >= SbxMININT && l <= SbxMAXINT )
226*b1cdbd2cSJim Jagielski eScanType = SbxINTEGER;
227*b1cdbd2cSJim Jagielski }
228*b1cdbd2cSJim Jagielski else if ( SbiRuntime::isVBAEnabled() )
229*b1cdbd2cSJim Jagielski {
230*b1cdbd2cSJim Jagielski OSL_TRACE("Reporting error converting");
231*b1cdbd2cSJim Jagielski return SbxERR_CONVERSION;
232*b1cdbd2cSJim Jagielski }
233*b1cdbd2cSJim Jagielski if( pLen )
234*b1cdbd2cSJim Jagielski *pLen = (sal_uInt16) ( p - pStart );
235*b1cdbd2cSJim Jagielski if( !bRes )
236*b1cdbd2cSJim Jagielski return SbxERR_CONVERSION;
237*b1cdbd2cSJim Jagielski if( bMinus )
238*b1cdbd2cSJim Jagielski nVal = -nVal;
239*b1cdbd2cSJim Jagielski rType = eScanType;
240*b1cdbd2cSJim Jagielski return SbxERR_OK;
241*b1cdbd2cSJim Jagielski }
242*b1cdbd2cSJim Jagielski
243*b1cdbd2cSJim Jagielski // Schnittstelle fuer CDbl im Basic
ScanNumIntnl(const String & rSrc,double & nVal,sal_Bool bSingle)244*b1cdbd2cSJim Jagielski SbxError SbxValue::ScanNumIntnl( const String& rSrc, double& nVal, sal_Bool bSingle )
245*b1cdbd2cSJim Jagielski {
246*b1cdbd2cSJim Jagielski SbxDataType t;
247*b1cdbd2cSJim Jagielski sal_uInt16 nLen = 0;
248*b1cdbd2cSJim Jagielski SbxError nRetError = ImpScan( rSrc, nVal, t, &nLen,
249*b1cdbd2cSJim Jagielski /*bAllowIntntl*/sal_False, /*bOnlyIntntl*/sal_True );
250*b1cdbd2cSJim Jagielski // Komplett gelesen?
251*b1cdbd2cSJim Jagielski if( nRetError == SbxERR_OK && nLen != rSrc.Len() )
252*b1cdbd2cSJim Jagielski nRetError = SbxERR_CONVERSION;
253*b1cdbd2cSJim Jagielski
254*b1cdbd2cSJim Jagielski if( bSingle )
255*b1cdbd2cSJim Jagielski {
256*b1cdbd2cSJim Jagielski SbxValues aValues( nVal );
257*b1cdbd2cSJim Jagielski nVal = (double)ImpGetSingle( &aValues ); // Hier Error bei Overflow
258*b1cdbd2cSJim Jagielski }
259*b1cdbd2cSJim Jagielski return nRetError;
260*b1cdbd2cSJim Jagielski }
261*b1cdbd2cSJim Jagielski
262*b1cdbd2cSJim Jagielski ////////////////////////////////////////////////////////////////////////////
263*b1cdbd2cSJim Jagielski
264*b1cdbd2cSJim Jagielski static double roundArray[] = {
265*b1cdbd2cSJim Jagielski 5.0e+0, 0.5e+0, 0.5e-1, 0.5e-2, 0.5e-3, 0.5e-4, 0.5e-5, 0.5e-6, 0.5e-7,
266*b1cdbd2cSJim Jagielski 0.5e-8, 0.5e-9, 0.5e-10,0.5e-11,0.5e-12,0.5e-13,0.5e-14,0.5e-15 };
267*b1cdbd2cSJim Jagielski
268*b1cdbd2cSJim Jagielski /***************************************************************************
269*b1cdbd2cSJim Jagielski |*
270*b1cdbd2cSJim Jagielski |* void myftoa( double, char *, short, short, sal_Bool, sal_Bool )
271*b1cdbd2cSJim Jagielski |*
272*b1cdbd2cSJim Jagielski |* Beschreibung: Konversion double --> ASCII
273*b1cdbd2cSJim Jagielski |* Parameter: double die Zahl.
274*b1cdbd2cSJim Jagielski |* char * der Zielpuffer
275*b1cdbd2cSJim Jagielski |* short Anzahl Nachkommastellen
276*b1cdbd2cSJim Jagielski |* short Weite des Exponenten( 0=kein E )
277*b1cdbd2cSJim Jagielski |* sal_Bool sal_True: mit 1000er Punkten
278*b1cdbd2cSJim Jagielski |* sal_Bool sal_True: formatfreie Ausgabe
279*b1cdbd2cSJim Jagielski |*
280*b1cdbd2cSJim Jagielski ***************************************************************************/
281*b1cdbd2cSJim Jagielski
myftoa(double nNum,char * pBuf,short nPrec,short nExpWidth,sal_Bool bPt,sal_Bool bFix,sal_Unicode cForceThousandSep=0)282*b1cdbd2cSJim Jagielski static void myftoa( double nNum, char * pBuf, short nPrec, short nExpWidth,
283*b1cdbd2cSJim Jagielski sal_Bool bPt, sal_Bool bFix, sal_Unicode cForceThousandSep = 0 )
284*b1cdbd2cSJim Jagielski {
285*b1cdbd2cSJim Jagielski
286*b1cdbd2cSJim Jagielski short nExp = 0; // Exponent
287*b1cdbd2cSJim Jagielski short nDig = nPrec + 1; // Anzahl Digits in Zahl
288*b1cdbd2cSJim Jagielski short nDec; // Anzahl Vorkommastellen
289*b1cdbd2cSJim Jagielski register int i, digit;
290*b1cdbd2cSJim Jagielski
291*b1cdbd2cSJim Jagielski // Komma besorgen
292*b1cdbd2cSJim Jagielski sal_Unicode cDecimalSep, cThousandSep;
293*b1cdbd2cSJim Jagielski ImpGetIntntlSep( cDecimalSep, cThousandSep );
294*b1cdbd2cSJim Jagielski if( cForceThousandSep )
295*b1cdbd2cSJim Jagielski cThousandSep = cForceThousandSep;
296*b1cdbd2cSJim Jagielski
297*b1cdbd2cSJim Jagielski // Exponentberechnung:
298*b1cdbd2cSJim Jagielski nExp = 0;
299*b1cdbd2cSJim Jagielski if( nNum > 0.0 )
300*b1cdbd2cSJim Jagielski {
301*b1cdbd2cSJim Jagielski while( nNum < 1.0 ) nNum *= 10.0, nExp--;
302*b1cdbd2cSJim Jagielski while( nNum >= 10.0 ) nNum /= 10.0, nExp++;
303*b1cdbd2cSJim Jagielski }
304*b1cdbd2cSJim Jagielski if( !bFix && !nExpWidth )
305*b1cdbd2cSJim Jagielski nDig = nDig + nExp;
306*b1cdbd2cSJim Jagielski else if( bFix && !nPrec )
307*b1cdbd2cSJim Jagielski nDig = nExp + 1;
308*b1cdbd2cSJim Jagielski
309*b1cdbd2cSJim Jagielski // Zahl runden:
310*b1cdbd2cSJim Jagielski if( (nNum += roundArray [( nDig > 16 ) ? 16 : nDig] ) >= 10.0 )
311*b1cdbd2cSJim Jagielski {
312*b1cdbd2cSJim Jagielski nNum = 1.0;
313*b1cdbd2cSJim Jagielski ++nExp;
314*b1cdbd2cSJim Jagielski if( !nExpWidth ) ++nDig;
315*b1cdbd2cSJim Jagielski }
316*b1cdbd2cSJim Jagielski
317*b1cdbd2cSJim Jagielski // Bestimmung der Vorkommastellen:
318*b1cdbd2cSJim Jagielski if( !nExpWidth )
319*b1cdbd2cSJim Jagielski {
320*b1cdbd2cSJim Jagielski if( nExp < 0 )
321*b1cdbd2cSJim Jagielski {
322*b1cdbd2cSJim Jagielski // #41691: Auch bei bFix eine 0 spendieren
323*b1cdbd2cSJim Jagielski *pBuf++ = '0';
324*b1cdbd2cSJim Jagielski if( nPrec ) *pBuf++ = (char)cDecimalSep;
325*b1cdbd2cSJim Jagielski i = -nExp - 1;
326*b1cdbd2cSJim Jagielski if( nDig <= 0 ) i = nPrec;
327*b1cdbd2cSJim Jagielski while( i-- ) *pBuf++ = '0';
328*b1cdbd2cSJim Jagielski nDec = 0;
329*b1cdbd2cSJim Jagielski }
330*b1cdbd2cSJim Jagielski else
331*b1cdbd2cSJim Jagielski nDec = nExp+1;
332*b1cdbd2cSJim Jagielski }
333*b1cdbd2cSJim Jagielski else
334*b1cdbd2cSJim Jagielski nDec = 1;
335*b1cdbd2cSJim Jagielski
336*b1cdbd2cSJim Jagielski // Zahl ausgeben:
337*b1cdbd2cSJim Jagielski if( nDig > 0 )
338*b1cdbd2cSJim Jagielski {
339*b1cdbd2cSJim Jagielski for( i = 0 ; ; ++i )
340*b1cdbd2cSJim Jagielski {
341*b1cdbd2cSJim Jagielski if( i < 16 )
342*b1cdbd2cSJim Jagielski {
343*b1cdbd2cSJim Jagielski digit = (int) nNum;
344*b1cdbd2cSJim Jagielski *pBuf++ = sal::static_int_cast< char >(digit + '0');
345*b1cdbd2cSJim Jagielski nNum =( nNum - digit ) * 10.0;
346*b1cdbd2cSJim Jagielski } else
347*b1cdbd2cSJim Jagielski *pBuf++ = '0';
348*b1cdbd2cSJim Jagielski if( --nDig == 0 ) break;
349*b1cdbd2cSJim Jagielski if( nDec )
350*b1cdbd2cSJim Jagielski {
351*b1cdbd2cSJim Jagielski nDec--;
352*b1cdbd2cSJim Jagielski if( !nDec )
353*b1cdbd2cSJim Jagielski *pBuf++ = (char)cDecimalSep;
354*b1cdbd2cSJim Jagielski else if( !(nDec % 3 ) && bPt )
355*b1cdbd2cSJim Jagielski *pBuf++ = (char)cThousandSep;
356*b1cdbd2cSJim Jagielski }
357*b1cdbd2cSJim Jagielski }
358*b1cdbd2cSJim Jagielski }
359*b1cdbd2cSJim Jagielski
360*b1cdbd2cSJim Jagielski // Exponent ausgeben:
361*b1cdbd2cSJim Jagielski if( nExpWidth )
362*b1cdbd2cSJim Jagielski {
363*b1cdbd2cSJim Jagielski if( nExpWidth < 3 ) nExpWidth = 3;
364*b1cdbd2cSJim Jagielski nExpWidth -= 2;
365*b1cdbd2cSJim Jagielski *pBuf++ = 'E';
366*b1cdbd2cSJim Jagielski *pBuf++ =( nExp < 0 ) ?( (nExp = -nExp ), '-' ) : '+';
367*b1cdbd2cSJim Jagielski while( nExpWidth > 3 ) *pBuf++ = '0', nExpWidth--;
368*b1cdbd2cSJim Jagielski if( nExp >= 100 || nExpWidth == 3 )
369*b1cdbd2cSJim Jagielski {
370*b1cdbd2cSJim Jagielski *pBuf++ = sal::static_int_cast< char >(nExp/100 + '0');
371*b1cdbd2cSJim Jagielski nExp %= 100;
372*b1cdbd2cSJim Jagielski }
373*b1cdbd2cSJim Jagielski if( nExp/10 || nExpWidth >= 2 )
374*b1cdbd2cSJim Jagielski *pBuf++ = sal::static_int_cast< char >(nExp/10 + '0');
375*b1cdbd2cSJim Jagielski *pBuf++ = sal::static_int_cast< char >(nExp%10 + '0');
376*b1cdbd2cSJim Jagielski }
377*b1cdbd2cSJim Jagielski *pBuf = 0;
378*b1cdbd2cSJim Jagielski }
379*b1cdbd2cSJim Jagielski
380*b1cdbd2cSJim Jagielski // Die Zahl wird unformatiert mit der angegebenen Anzahl NK-Stellen
381*b1cdbd2cSJim Jagielski // aufbereitet. Evtl. wird ein Minus vorangestellt.
382*b1cdbd2cSJim Jagielski // Diese Routine ist public, weil sie auch von den Put-Funktionen
383*b1cdbd2cSJim Jagielski // der Klasse SbxImpSTRING verwendet wird.
384*b1cdbd2cSJim Jagielski
385*b1cdbd2cSJim Jagielski #ifdef _MSC_VER
386*b1cdbd2cSJim Jagielski #pragma optimize( "", off )
387*b1cdbd2cSJim Jagielski #pragma warning(disable: 4748) // "... because optimizations are disabled ..."
388*b1cdbd2cSJim Jagielski #endif
389*b1cdbd2cSJim Jagielski
ImpCvtNum(double nNum,short nPrec,::rtl::OUString & rRes,sal_Bool bCoreString)390*b1cdbd2cSJim Jagielski void ImpCvtNum( double nNum, short nPrec, ::rtl::OUString& rRes, sal_Bool bCoreString )
391*b1cdbd2cSJim Jagielski {
392*b1cdbd2cSJim Jagielski char *q;
393*b1cdbd2cSJim Jagielski char cBuf[ 40 ], *p = cBuf;
394*b1cdbd2cSJim Jagielski
395*b1cdbd2cSJim Jagielski sal_Unicode cDecimalSep, cThousandSep;
396*b1cdbd2cSJim Jagielski ImpGetIntntlSep( cDecimalSep, cThousandSep );
397*b1cdbd2cSJim Jagielski if( bCoreString )
398*b1cdbd2cSJim Jagielski cDecimalSep = '.';
399*b1cdbd2cSJim Jagielski
400*b1cdbd2cSJim Jagielski if( nNum < 0.0 ) {
401*b1cdbd2cSJim Jagielski nNum = -nNum;
402*b1cdbd2cSJim Jagielski *p++ = '-';
403*b1cdbd2cSJim Jagielski }
404*b1cdbd2cSJim Jagielski double dMaxNumWithoutExp = (nPrec == 6) ? 1E6 : 1E14;
405*b1cdbd2cSJim Jagielski myftoa( nNum, p, nPrec,( nNum &&( nNum < 1E-1 || nNum >= dMaxNumWithoutExp ) ) ? 4:0,
406*b1cdbd2cSJim Jagielski sal_False, sal_True, cDecimalSep );
407*b1cdbd2cSJim Jagielski // Trailing Zeroes weg:
408*b1cdbd2cSJim Jagielski for( p = cBuf; *p &&( *p != 'E' ); p++ ) {}
409*b1cdbd2cSJim Jagielski q = p; p--;
410*b1cdbd2cSJim Jagielski while( nPrec && *p == '0' ) nPrec--, p--;
411*b1cdbd2cSJim Jagielski if( *p == cDecimalSep ) p--;
412*b1cdbd2cSJim Jagielski while( *q ) *++p = *q++;
413*b1cdbd2cSJim Jagielski *++p = 0;
414*b1cdbd2cSJim Jagielski rRes = ::rtl::OUString::createFromAscii( cBuf );
415*b1cdbd2cSJim Jagielski }
416*b1cdbd2cSJim Jagielski
417*b1cdbd2cSJim Jagielski #ifdef _MSC_VER
418*b1cdbd2cSJim Jagielski #pragma optimize( "", on )
419*b1cdbd2cSJim Jagielski #endif
420*b1cdbd2cSJim Jagielski
ImpConvStringExt(::rtl::OUString & rSrc,SbxDataType eTargetType)421*b1cdbd2cSJim Jagielski sal_Bool ImpConvStringExt( ::rtl::OUString& rSrc, SbxDataType eTargetType )
422*b1cdbd2cSJim Jagielski {
423*b1cdbd2cSJim Jagielski // Merken, ob ueberhaupt was geaendert wurde
424*b1cdbd2cSJim Jagielski sal_Bool bChanged = sal_False;
425*b1cdbd2cSJim Jagielski ::rtl::OUString aNewString;
426*b1cdbd2cSJim Jagielski
427*b1cdbd2cSJim Jagielski // Nur Spezial-F�lle behandeln, als Default tun wir nichts
428*b1cdbd2cSJim Jagielski switch( eTargetType )
429*b1cdbd2cSJim Jagielski {
430*b1cdbd2cSJim Jagielski // Bei Fliesskomma International beruecksichtigen
431*b1cdbd2cSJim Jagielski case SbxSINGLE:
432*b1cdbd2cSJim Jagielski case SbxDOUBLE:
433*b1cdbd2cSJim Jagielski case SbxCURRENCY:
434*b1cdbd2cSJim Jagielski {
435*b1cdbd2cSJim Jagielski ::rtl::OString aBStr( ::rtl::OUStringToOString( rSrc, RTL_TEXTENCODING_ASCII_US ) );
436*b1cdbd2cSJim Jagielski
437*b1cdbd2cSJim Jagielski // Komma besorgen
438*b1cdbd2cSJim Jagielski sal_Unicode cDecimalSep, cThousandSep;
439*b1cdbd2cSJim Jagielski ImpGetIntntlSep( cDecimalSep, cThousandSep );
440*b1cdbd2cSJim Jagielski aNewString = rSrc;
441*b1cdbd2cSJim Jagielski
442*b1cdbd2cSJim Jagielski // Ersetzen, wenn DecimalSep kein '.' (nur den ersten)
443*b1cdbd2cSJim Jagielski if( cDecimalSep != (sal_Unicode)'.' )
444*b1cdbd2cSJim Jagielski {
445*b1cdbd2cSJim Jagielski sal_Int32 nPos = aNewString.indexOf( cDecimalSep );
446*b1cdbd2cSJim Jagielski if( nPos != -1 )
447*b1cdbd2cSJim Jagielski {
448*b1cdbd2cSJim Jagielski sal_Unicode* pStr = (sal_Unicode*)aNewString.getStr();
449*b1cdbd2cSJim Jagielski pStr[nPos] = (sal_Unicode)'.';
450*b1cdbd2cSJim Jagielski bChanged = sal_True;
451*b1cdbd2cSJim Jagielski }
452*b1cdbd2cSJim Jagielski }
453*b1cdbd2cSJim Jagielski break;
454*b1cdbd2cSJim Jagielski }
455*b1cdbd2cSJim Jagielski
456*b1cdbd2cSJim Jagielski // Bei sal_Bool sal_True und sal_False als String pruefen
457*b1cdbd2cSJim Jagielski case SbxBOOL:
458*b1cdbd2cSJim Jagielski {
459*b1cdbd2cSJim Jagielski if( rSrc.equalsIgnoreAsciiCaseAscii( "true" ) )
460*b1cdbd2cSJim Jagielski {
461*b1cdbd2cSJim Jagielski aNewString = ::rtl::OUString::valueOf( (sal_Int32)SbxTRUE );
462*b1cdbd2cSJim Jagielski bChanged = sal_True;
463*b1cdbd2cSJim Jagielski }
464*b1cdbd2cSJim Jagielski else
465*b1cdbd2cSJim Jagielski if( rSrc.equalsIgnoreAsciiCaseAscii( "false" ) )
466*b1cdbd2cSJim Jagielski {
467*b1cdbd2cSJim Jagielski aNewString = ::rtl::OUString::valueOf( (sal_Int32)SbxFALSE );
468*b1cdbd2cSJim Jagielski bChanged = sal_True;
469*b1cdbd2cSJim Jagielski }
470*b1cdbd2cSJim Jagielski break;
471*b1cdbd2cSJim Jagielski }
472*b1cdbd2cSJim Jagielski default: break;
473*b1cdbd2cSJim Jagielski }
474*b1cdbd2cSJim Jagielski // String bei Aenderung uebernehmen
475*b1cdbd2cSJim Jagielski if( bChanged )
476*b1cdbd2cSJim Jagielski rSrc = aNewString;
477*b1cdbd2cSJim Jagielski return bChanged;
478*b1cdbd2cSJim Jagielski }
479*b1cdbd2cSJim Jagielski
480*b1cdbd2cSJim Jagielski
481*b1cdbd2cSJim Jagielski // Formatierte Zahlenausgabe
482*b1cdbd2cSJim Jagielski // Der Returnwert ist die Anzahl Zeichen, die aus dem
483*b1cdbd2cSJim Jagielski // Format verwendt wurden.
484*b1cdbd2cSJim Jagielski
485*b1cdbd2cSJim Jagielski #ifdef _old_format_code_
486*b1cdbd2cSJim Jagielski // lasse diesen Code vorl"aufig drin, zum 'abgucken'
487*b1cdbd2cSJim Jagielski // der bisherigen Implementation
488*b1cdbd2cSJim Jagielski
printfmtnum(double nNum,XubString & rRes,const XubString & rWFmt)489*b1cdbd2cSJim Jagielski static sal_uInt16 printfmtnum( double nNum, XubString& rRes, const XubString& rWFmt )
490*b1cdbd2cSJim Jagielski {
491*b1cdbd2cSJim Jagielski const String& rFmt = rWFmt;
492*b1cdbd2cSJim Jagielski char cFill = ' '; // Fuellzeichen
493*b1cdbd2cSJim Jagielski char cPre = 0; // Startzeichen( evtl. "$" )
494*b1cdbd2cSJim Jagielski short nExpDig= 0; // Anzahl Exponentstellen
495*b1cdbd2cSJim Jagielski short nPrec = 0; // Anzahl Nachkommastellen
496*b1cdbd2cSJim Jagielski short nWidth = 0; // Zahlenweite gesamnt
497*b1cdbd2cSJim Jagielski short nLen; // Laenge konvertierte Zahl
498*b1cdbd2cSJim Jagielski sal_Bool bPoint = sal_False; // sal_True: mit 1000er Kommas
499*b1cdbd2cSJim Jagielski sal_Bool bTrail = sal_False; // sal_True, wenn folgendes Minus
500*b1cdbd2cSJim Jagielski sal_Bool bSign = sal_False; // sal_True: immer mit Vorzeichen
501*b1cdbd2cSJim Jagielski sal_Bool bNeg = sal_False; // sal_True: Zahl ist negativ
502*b1cdbd2cSJim Jagielski char cBuf [1024]; // Zahlenpuffer
503*b1cdbd2cSJim Jagielski char * p;
504*b1cdbd2cSJim Jagielski const char* pFmt = rFmt;
505*b1cdbd2cSJim Jagielski rRes.Erase();
506*b1cdbd2cSJim Jagielski // $$ und ** abfangen. Einfach wird als Zeichen ausgegeben.
507*b1cdbd2cSJim Jagielski if( *pFmt == '$' )
508*b1cdbd2cSJim Jagielski if( *++pFmt != '$' ) rRes += '$';
509*b1cdbd2cSJim Jagielski if( *pFmt == '*' )
510*b1cdbd2cSJim Jagielski if( *++pFmt != '*' ) rRes += '*';
511*b1cdbd2cSJim Jagielski
512*b1cdbd2cSJim Jagielski switch( *pFmt++ )
513*b1cdbd2cSJim Jagielski {
514*b1cdbd2cSJim Jagielski case 0:
515*b1cdbd2cSJim Jagielski break;
516*b1cdbd2cSJim Jagielski case '+':
517*b1cdbd2cSJim Jagielski bSign = sal_True; nWidth++; break;
518*b1cdbd2cSJim Jagielski case '*':
519*b1cdbd2cSJim Jagielski nWidth++; cFill = '*';
520*b1cdbd2cSJim Jagielski if( *pFmt == '$' ) nWidth++, pFmt++, cPre = '$';
521*b1cdbd2cSJim Jagielski break;
522*b1cdbd2cSJim Jagielski case '$':
523*b1cdbd2cSJim Jagielski nWidth++; cPre = '$'; break;
524*b1cdbd2cSJim Jagielski case '#':
525*b1cdbd2cSJim Jagielski case '.':
526*b1cdbd2cSJim Jagielski case ',':
527*b1cdbd2cSJim Jagielski pFmt--; break;
528*b1cdbd2cSJim Jagielski }
529*b1cdbd2cSJim Jagielski // Vorkomma:
530*b1cdbd2cSJim Jagielski for( ;; )
531*b1cdbd2cSJim Jagielski {
532*b1cdbd2cSJim Jagielski while( *pFmt == '#' ) pFmt++, nWidth++;
533*b1cdbd2cSJim Jagielski // 1000er Kommas?
534*b1cdbd2cSJim Jagielski if( *pFmt == ',' )
535*b1cdbd2cSJim Jagielski {
536*b1cdbd2cSJim Jagielski nWidth++; pFmt++; bPoint = sal_True;
537*b1cdbd2cSJim Jagielski } else break;
538*b1cdbd2cSJim Jagielski }
539*b1cdbd2cSJim Jagielski // Nachkomma:
540*b1cdbd2cSJim Jagielski if( *pFmt == '.' )
541*b1cdbd2cSJim Jagielski {
542*b1cdbd2cSJim Jagielski while( *++pFmt == '#' ) nPrec++;
543*b1cdbd2cSJim Jagielski nWidth += nPrec + 1;
544*b1cdbd2cSJim Jagielski }
545*b1cdbd2cSJim Jagielski // Exponent:
546*b1cdbd2cSJim Jagielski while( *pFmt == '^' )
547*b1cdbd2cSJim Jagielski pFmt++, nExpDig++, nWidth++;
548*b1cdbd2cSJim Jagielski // Folgendes Minus:
549*b1cdbd2cSJim Jagielski if( !bSign && *pFmt == '-' )
550*b1cdbd2cSJim Jagielski pFmt++, bTrail = sal_True;
551*b1cdbd2cSJim Jagielski
552*b1cdbd2cSJim Jagielski // Zahl konvertieren:
553*b1cdbd2cSJim Jagielski if( nPrec > 15 ) nPrec = 15;
554*b1cdbd2cSJim Jagielski if( nNum < 0.0 ) nNum = -nNum, bNeg = sal_True;
555*b1cdbd2cSJim Jagielski p = cBuf;
556*b1cdbd2cSJim Jagielski if( bSign ) *p++ = bNeg ? '-' : '+';
557*b1cdbd2cSJim Jagielski myftoa( nNum, p, nPrec, nExpDig, bPoint, sal_False );
558*b1cdbd2cSJim Jagielski nLen = strlen( cBuf );
559*b1cdbd2cSJim Jagielski
560*b1cdbd2cSJim Jagielski // Ueberlauf?
561*b1cdbd2cSJim Jagielski if( cPre ) nLen++;
562*b1cdbd2cSJim Jagielski if( nLen > nWidth ) rRes += '%';
563*b1cdbd2cSJim Jagielski else {
564*b1cdbd2cSJim Jagielski nWidth -= nLen;
565*b1cdbd2cSJim Jagielski while( nWidth-- ) rRes += (xub_Unicode)cFill;
566*b1cdbd2cSJim Jagielski if( cPre ) rRes += (xub_Unicode)cPre;
567*b1cdbd2cSJim Jagielski }
568*b1cdbd2cSJim Jagielski rRes += (xub_Unicode*)&(cBuf[0]);
569*b1cdbd2cSJim Jagielski if( bTrail )
570*b1cdbd2cSJim Jagielski rRes += bNeg ? '-' : ' ';
571*b1cdbd2cSJim Jagielski
572*b1cdbd2cSJim Jagielski return (sal_uInt16) ( pFmt - (const char*) rFmt );
573*b1cdbd2cSJim Jagielski }
574*b1cdbd2cSJim Jagielski
575*b1cdbd2cSJim Jagielski #endif //_old_format_code_
576*b1cdbd2cSJim Jagielski
printfmtstr(const XubString & rStr,XubString & rRes,const XubString & rFmt)577*b1cdbd2cSJim Jagielski static sal_uInt16 printfmtstr( const XubString& rStr, XubString& rRes, const XubString& rFmt )
578*b1cdbd2cSJim Jagielski {
579*b1cdbd2cSJim Jagielski const xub_Unicode* pStr = rStr.GetBuffer();
580*b1cdbd2cSJim Jagielski const xub_Unicode* pFmtStart = rFmt.GetBuffer();
581*b1cdbd2cSJim Jagielski const xub_Unicode* pFmt = pFmtStart;
582*b1cdbd2cSJim Jagielski rRes.Erase();
583*b1cdbd2cSJim Jagielski switch( *pFmt )
584*b1cdbd2cSJim Jagielski {
585*b1cdbd2cSJim Jagielski case '!':
586*b1cdbd2cSJim Jagielski rRes += *pStr++; pFmt++; break;
587*b1cdbd2cSJim Jagielski case '\\':
588*b1cdbd2cSJim Jagielski do
589*b1cdbd2cSJim Jagielski {
590*b1cdbd2cSJim Jagielski rRes += *pStr ? *pStr++ : static_cast< xub_Unicode >(' ');
591*b1cdbd2cSJim Jagielski pFmt++;
592*b1cdbd2cSJim Jagielski } while( *pFmt != '\\' );
593*b1cdbd2cSJim Jagielski rRes += *pStr ? *pStr++ : static_cast< xub_Unicode >(' ');
594*b1cdbd2cSJim Jagielski pFmt++; break;
595*b1cdbd2cSJim Jagielski case '&':
596*b1cdbd2cSJim Jagielski rRes = rStr;
597*b1cdbd2cSJim Jagielski pFmt++; break;
598*b1cdbd2cSJim Jagielski default:
599*b1cdbd2cSJim Jagielski rRes = rStr;
600*b1cdbd2cSJim Jagielski break;
601*b1cdbd2cSJim Jagielski }
602*b1cdbd2cSJim Jagielski return (sal_uInt16) ( pFmt - pFmtStart );
603*b1cdbd2cSJim Jagielski }
604*b1cdbd2cSJim Jagielski
605*b1cdbd2cSJim Jagielski /////////////////////////////////////////////////////////////////////////
606*b1cdbd2cSJim Jagielski
Scan(const XubString & rSrc,sal_uInt16 * pLen)607*b1cdbd2cSJim Jagielski sal_Bool SbxValue::Scan( const XubString& rSrc, sal_uInt16* pLen )
608*b1cdbd2cSJim Jagielski {
609*b1cdbd2cSJim Jagielski SbxError eRes = SbxERR_OK;
610*b1cdbd2cSJim Jagielski if( !CanWrite() )
611*b1cdbd2cSJim Jagielski eRes = SbxERR_PROP_READONLY;
612*b1cdbd2cSJim Jagielski else
613*b1cdbd2cSJim Jagielski {
614*b1cdbd2cSJim Jagielski double n;
615*b1cdbd2cSJim Jagielski SbxDataType t;
616*b1cdbd2cSJim Jagielski eRes = ImpScan( rSrc, n, t, pLen );
617*b1cdbd2cSJim Jagielski if( eRes == SbxERR_OK )
618*b1cdbd2cSJim Jagielski {
619*b1cdbd2cSJim Jagielski if( !IsFixed() )
620*b1cdbd2cSJim Jagielski SetType( t );
621*b1cdbd2cSJim Jagielski PutDouble( n );
622*b1cdbd2cSJim Jagielski }
623*b1cdbd2cSJim Jagielski }
624*b1cdbd2cSJim Jagielski if( eRes )
625*b1cdbd2cSJim Jagielski {
626*b1cdbd2cSJim Jagielski SetError( eRes ); return sal_False;
627*b1cdbd2cSJim Jagielski }
628*b1cdbd2cSJim Jagielski else
629*b1cdbd2cSJim Jagielski return sal_True;
630*b1cdbd2cSJim Jagielski }
631*b1cdbd2cSJim Jagielski
632*b1cdbd2cSJim Jagielski
implGetResMgr(void)633*b1cdbd2cSJim Jagielski ResMgr* implGetResMgr( void )
634*b1cdbd2cSJim Jagielski {
635*b1cdbd2cSJim Jagielski static ResMgr* pResMgr = NULL;
636*b1cdbd2cSJim Jagielski if( !pResMgr )
637*b1cdbd2cSJim Jagielski {
638*b1cdbd2cSJim Jagielski ::com::sun::star::lang::Locale aLocale = Application::GetSettings().GetUILocale();
639*b1cdbd2cSJim Jagielski pResMgr = ResMgr::CreateResMgr(CREATEVERSIONRESMGR_NAME(sb), aLocale );
640*b1cdbd2cSJim Jagielski }
641*b1cdbd2cSJim Jagielski return pResMgr;
642*b1cdbd2cSJim Jagielski }
643*b1cdbd2cSJim Jagielski
644*b1cdbd2cSJim Jagielski class SbxValueFormatResId : public ResId
645*b1cdbd2cSJim Jagielski {
646*b1cdbd2cSJim Jagielski public:
SbxValueFormatResId(sal_uInt16 nId)647*b1cdbd2cSJim Jagielski SbxValueFormatResId( sal_uInt16 nId )
648*b1cdbd2cSJim Jagielski : ResId( nId, *implGetResMgr() )
649*b1cdbd2cSJim Jagielski {}
650*b1cdbd2cSJim Jagielski };
651*b1cdbd2cSJim Jagielski
652*b1cdbd2cSJim Jagielski
653*b1cdbd2cSJim Jagielski enum VbaFormatType
654*b1cdbd2cSJim Jagielski {
655*b1cdbd2cSJim Jagielski VBA_FORMAT_TYPE_OFFSET, // standard number format
656*b1cdbd2cSJim Jagielski VBA_FORMAT_TYPE_USERDEFINED, // user defined number format
657*b1cdbd2cSJim Jagielski VBA_FORMAT_TYPE_NULL
658*b1cdbd2cSJim Jagielski };
659*b1cdbd2cSJim Jagielski
660*b1cdbd2cSJim Jagielski struct VbaFormatInfo
661*b1cdbd2cSJim Jagielski {
662*b1cdbd2cSJim Jagielski VbaFormatType meType;
663*b1cdbd2cSJim Jagielski const char* mpVbaFormat; // Format string in vba
664*b1cdbd2cSJim Jagielski NfIndexTableOffset meOffset; // SvNumberFormatter format index, if meType = VBA_FORMAT_TYPE_OFFSET
665*b1cdbd2cSJim Jagielski const char* mpOOoFormat; // if meType = VBA_FORMAT_TYPE_USERDEFINED
666*b1cdbd2cSJim Jagielski };
667*b1cdbd2cSJim Jagielski
668*b1cdbd2cSJim Jagielski #define VBA_FORMAT_OFFSET( pcUtf8, eOffset ) \
669*b1cdbd2cSJim Jagielski { VBA_FORMAT_TYPE_OFFSET, pcUtf8, eOffset, 0 }
670*b1cdbd2cSJim Jagielski
671*b1cdbd2cSJim Jagielski #define VBA_FORMAT_USERDEFINED( pcUtf8, pcDefinedUtf8 ) \
672*b1cdbd2cSJim Jagielski { VBA_FORMAT_TYPE_USERDEFINED, pcUtf8, NF_NUMBER_STANDARD, pcDefinedUtf8 }
673*b1cdbd2cSJim Jagielski
674*b1cdbd2cSJim Jagielski static VbaFormatInfo pFormatInfoTable[] =
675*b1cdbd2cSJim Jagielski {
676*b1cdbd2cSJim Jagielski VBA_FORMAT_OFFSET( "Long Date", NF_DATE_SYSTEM_LONG ),
677*b1cdbd2cSJim Jagielski VBA_FORMAT_USERDEFINED( "Medium Date", "DD-MMM-YY" ),
678*b1cdbd2cSJim Jagielski VBA_FORMAT_OFFSET( "Short Date", NF_DATE_SYSTEM_SHORT ),
679*b1cdbd2cSJim Jagielski VBA_FORMAT_USERDEFINED( "Long Time", "H:MM:SS AM/PM" ),
680*b1cdbd2cSJim Jagielski VBA_FORMAT_OFFSET( "Medium Time", NF_TIME_HHMMAMPM ),
681*b1cdbd2cSJim Jagielski VBA_FORMAT_OFFSET( "Short Time", NF_TIME_HHMM ),
682*b1cdbd2cSJim Jagielski VBA_FORMAT_OFFSET( "ddddd", NF_DATE_SYSTEM_SHORT ),
683*b1cdbd2cSJim Jagielski VBA_FORMAT_OFFSET( "dddddd", NF_DATE_SYSTEM_LONG ),
684*b1cdbd2cSJim Jagielski VBA_FORMAT_USERDEFINED( "ttttt", "H:MM:SS AM/PM" ),
685*b1cdbd2cSJim Jagielski VBA_FORMAT_OFFSET( "ww", NF_DATE_WW ),
686*b1cdbd2cSJim Jagielski { VBA_FORMAT_TYPE_NULL, 0, NF_INDEX_TABLE_ENTRIES, 0 }
687*b1cdbd2cSJim Jagielski };
688*b1cdbd2cSJim Jagielski
getFormatInfo(const String & rFmt)689*b1cdbd2cSJim Jagielski VbaFormatInfo* getFormatInfo( const String& rFmt )
690*b1cdbd2cSJim Jagielski {
691*b1cdbd2cSJim Jagielski VbaFormatInfo* pInfo = NULL;
692*b1cdbd2cSJim Jagielski sal_Int16 i = 0;
693*b1cdbd2cSJim Jagielski while( (pInfo = pFormatInfoTable + i )->mpVbaFormat != NULL )
694*b1cdbd2cSJim Jagielski {
695*b1cdbd2cSJim Jagielski if( rFmt.EqualsIgnoreCaseAscii( pInfo->mpVbaFormat ) )
696*b1cdbd2cSJim Jagielski break;
697*b1cdbd2cSJim Jagielski i++;
698*b1cdbd2cSJim Jagielski }
699*b1cdbd2cSJim Jagielski return pInfo;
700*b1cdbd2cSJim Jagielski }
701*b1cdbd2cSJim Jagielski
702*b1cdbd2cSJim Jagielski #define VBAFORMAT_GENERALDATE "General Date"
703*b1cdbd2cSJim Jagielski #define VBAFORMAT_C "c"
704*b1cdbd2cSJim Jagielski #define VBAFORMAT_N "n"
705*b1cdbd2cSJim Jagielski #define VBAFORMAT_NN "nn"
706*b1cdbd2cSJim Jagielski #define VBAFORMAT_W "w"
707*b1cdbd2cSJim Jagielski #define VBAFORMAT_Y "y"
708*b1cdbd2cSJim Jagielski #define VBAFORMAT_LOWERCASE "<"
709*b1cdbd2cSJim Jagielski #define VBAFORMAT_UPPERCASE ">"
710*b1cdbd2cSJim Jagielski
711*b1cdbd2cSJim Jagielski // From methods1.cxx
712*b1cdbd2cSJim Jagielski sal_Int16 implGetWeekDay( double aDate, bool bFirstDayParam = false, sal_Int16 nFirstDay = 0 );
713*b1cdbd2cSJim Jagielski // from methods.cxx
714*b1cdbd2cSJim Jagielski sal_Int16 implGetMinute( double dDate );
715*b1cdbd2cSJim Jagielski sal_Int16 implGetDateYear( double aDate );
716*b1cdbd2cSJim Jagielski sal_Bool implDateSerial( sal_Int16 nYear, sal_Int16 nMonth, sal_Int16 nDay, double& rdRet );
717*b1cdbd2cSJim Jagielski
Format(XubString & rRes,const XubString * pFmt) const718*b1cdbd2cSJim Jagielski void SbxValue::Format( XubString& rRes, const XubString* pFmt ) const
719*b1cdbd2cSJim Jagielski {
720*b1cdbd2cSJim Jagielski short nComma = 0;
721*b1cdbd2cSJim Jagielski double d = 0;
722*b1cdbd2cSJim Jagielski
723*b1cdbd2cSJim Jagielski // pflin, It is better to use SvNumberFormatter to handle the date/time/number format.
724*b1cdbd2cSJim Jagielski // the SvNumberFormatter output is mostly compatible with
725*b1cdbd2cSJim Jagielski // VBA output besides the OOo-basic output
726*b1cdbd2cSJim Jagielski if( pFmt && !SbxBasicFormater::isBasicFormat( *pFmt ) )
727*b1cdbd2cSJim Jagielski {
728*b1cdbd2cSJim Jagielski String aStr = GetString();
729*b1cdbd2cSJim Jagielski
730*b1cdbd2cSJim Jagielski SvtSysLocale aSysLocale;
731*b1cdbd2cSJim Jagielski const CharClass& rCharClass = aSysLocale.GetCharClass();
732*b1cdbd2cSJim Jagielski
733*b1cdbd2cSJim Jagielski if( pFmt->EqualsIgnoreCaseAscii( VBAFORMAT_LOWERCASE ) )
734*b1cdbd2cSJim Jagielski {
735*b1cdbd2cSJim Jagielski rCharClass.toLower( aStr );
736*b1cdbd2cSJim Jagielski rRes = aStr;
737*b1cdbd2cSJim Jagielski return;
738*b1cdbd2cSJim Jagielski }
739*b1cdbd2cSJim Jagielski if( pFmt->EqualsIgnoreCaseAscii( VBAFORMAT_UPPERCASE ) )
740*b1cdbd2cSJim Jagielski {
741*b1cdbd2cSJim Jagielski rCharClass.toUpper( aStr );
742*b1cdbd2cSJim Jagielski rRes = aStr;
743*b1cdbd2cSJim Jagielski return;
744*b1cdbd2cSJim Jagielski }
745*b1cdbd2cSJim Jagielski
746*b1cdbd2cSJim Jagielski LanguageType eLangType = GetpApp()->GetSettings().GetLanguage();
747*b1cdbd2cSJim Jagielski com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >
748*b1cdbd2cSJim Jagielski xFactory = comphelper::getProcessServiceFactory();
749*b1cdbd2cSJim Jagielski SvNumberFormatter aFormatter( xFactory, eLangType );
750*b1cdbd2cSJim Jagielski
751*b1cdbd2cSJim Jagielski sal_uInt32 nIndex;
752*b1cdbd2cSJim Jagielski xub_StrLen nCheckPos = 0;
753*b1cdbd2cSJim Jagielski short nType;
754*b1cdbd2cSJim Jagielski double nNumber;
755*b1cdbd2cSJim Jagielski Color* pCol;
756*b1cdbd2cSJim Jagielski
757*b1cdbd2cSJim Jagielski sal_Bool bSuccess = aFormatter.IsNumberFormat( aStr, nIndex, nNumber );
758*b1cdbd2cSJim Jagielski
759*b1cdbd2cSJim Jagielski // number format, use SvNumberFormatter to handle it.
760*b1cdbd2cSJim Jagielski if( bSuccess )
761*b1cdbd2cSJim Jagielski {
762*b1cdbd2cSJim Jagielski String aFmtStr = *pFmt;
763*b1cdbd2cSJim Jagielski VbaFormatInfo* pInfo = getFormatInfo( aFmtStr );
764*b1cdbd2cSJim Jagielski if( pInfo && pInfo->meType != VBA_FORMAT_TYPE_NULL )
765*b1cdbd2cSJim Jagielski {
766*b1cdbd2cSJim Jagielski if( pInfo->meType == VBA_FORMAT_TYPE_OFFSET )
767*b1cdbd2cSJim Jagielski {
768*b1cdbd2cSJim Jagielski nIndex = aFormatter.GetFormatIndex( pInfo->meOffset, eLangType );
769*b1cdbd2cSJim Jagielski }
770*b1cdbd2cSJim Jagielski else
771*b1cdbd2cSJim Jagielski {
772*b1cdbd2cSJim Jagielski aFmtStr.AssignAscii( pInfo->mpOOoFormat );
773*b1cdbd2cSJim Jagielski aFormatter.PutandConvertEntry( aFmtStr, nCheckPos, nType, nIndex, LANGUAGE_ENGLISH, eLangType );
774*b1cdbd2cSJim Jagielski }
775*b1cdbd2cSJim Jagielski aFormatter.GetOutputString( nNumber, nIndex, rRes, &pCol );
776*b1cdbd2cSJim Jagielski }
777*b1cdbd2cSJim Jagielski else if( aFmtStr.EqualsIgnoreCaseAscii( VBAFORMAT_GENERALDATE )
778*b1cdbd2cSJim Jagielski || aFmtStr.EqualsIgnoreCaseAscii( VBAFORMAT_C ))
779*b1cdbd2cSJim Jagielski {
780*b1cdbd2cSJim Jagielski if( nNumber <=-1.0 || nNumber >= 1.0 )
781*b1cdbd2cSJim Jagielski {
782*b1cdbd2cSJim Jagielski // short date
783*b1cdbd2cSJim Jagielski nIndex = aFormatter.GetFormatIndex( NF_DATE_SYSTEM_SHORT, eLangType );
784*b1cdbd2cSJim Jagielski aFormatter.GetOutputString( nNumber, nIndex, rRes, &pCol );
785*b1cdbd2cSJim Jagielski
786*b1cdbd2cSJim Jagielski // long time
787*b1cdbd2cSJim Jagielski if( floor( nNumber ) != nNumber )
788*b1cdbd2cSJim Jagielski {
789*b1cdbd2cSJim Jagielski aFmtStr.AssignAscii( "H:MM:SS AM/PM" );
790*b1cdbd2cSJim Jagielski aFormatter.PutandConvertEntry( aFmtStr, nCheckPos, nType, nIndex, LANGUAGE_ENGLISH, eLangType );
791*b1cdbd2cSJim Jagielski String aTime;
792*b1cdbd2cSJim Jagielski aFormatter.GetOutputString( nNumber, nIndex, aTime, &pCol );
793*b1cdbd2cSJim Jagielski rRes.AppendAscii(" ");
794*b1cdbd2cSJim Jagielski rRes += aTime;
795*b1cdbd2cSJim Jagielski }
796*b1cdbd2cSJim Jagielski }
797*b1cdbd2cSJim Jagielski else
798*b1cdbd2cSJim Jagielski {
799*b1cdbd2cSJim Jagielski // long time only
800*b1cdbd2cSJim Jagielski aFmtStr.AssignAscii( "H:MM:SS AM/PM" );
801*b1cdbd2cSJim Jagielski aFormatter.PutandConvertEntry( aFmtStr, nCheckPos, nType, nIndex, LANGUAGE_ENGLISH, eLangType );
802*b1cdbd2cSJim Jagielski aFormatter.GetOutputString( nNumber, nIndex, rRes, &pCol );
803*b1cdbd2cSJim Jagielski }
804*b1cdbd2cSJim Jagielski }
805*b1cdbd2cSJim Jagielski else if( aFmtStr.EqualsIgnoreCaseAscii( VBAFORMAT_N )
806*b1cdbd2cSJim Jagielski || aFmtStr.EqualsIgnoreCaseAscii( VBAFORMAT_NN ))
807*b1cdbd2cSJim Jagielski {
808*b1cdbd2cSJim Jagielski sal_Int32 nMin = implGetMinute( nNumber );
809*b1cdbd2cSJim Jagielski if( nMin < 10 && aFmtStr.EqualsIgnoreCaseAscii( VBAFORMAT_NN ) )
810*b1cdbd2cSJim Jagielski {
811*b1cdbd2cSJim Jagielski // Minute in two digits
812*b1cdbd2cSJim Jagielski sal_Unicode* p = rRes.AllocBuffer( 2 );
813*b1cdbd2cSJim Jagielski *p++ = '0';
814*b1cdbd2cSJim Jagielski *p = sal_Unicode( '0' + nMin );
815*b1cdbd2cSJim Jagielski }
816*b1cdbd2cSJim Jagielski else
817*b1cdbd2cSJim Jagielski {
818*b1cdbd2cSJim Jagielski rRes = String::CreateFromInt32( nMin );
819*b1cdbd2cSJim Jagielski }
820*b1cdbd2cSJim Jagielski }
821*b1cdbd2cSJim Jagielski else if( aFmtStr.EqualsIgnoreCaseAscii( VBAFORMAT_W ))
822*b1cdbd2cSJim Jagielski {
823*b1cdbd2cSJim Jagielski sal_Int32 nWeekDay = implGetWeekDay( nNumber );
824*b1cdbd2cSJim Jagielski rRes = String::CreateFromInt32( nWeekDay );
825*b1cdbd2cSJim Jagielski }
826*b1cdbd2cSJim Jagielski else if( aFmtStr.EqualsIgnoreCaseAscii( VBAFORMAT_Y ))
827*b1cdbd2cSJim Jagielski {
828*b1cdbd2cSJim Jagielski sal_Int16 nYear = implGetDateYear( nNumber );
829*b1cdbd2cSJim Jagielski double dBaseDate;
830*b1cdbd2cSJim Jagielski implDateSerial( nYear, 1, 1, dBaseDate );
831*b1cdbd2cSJim Jagielski sal_Int32 nYear32 = 1 + sal_Int32( nNumber - dBaseDate );
832*b1cdbd2cSJim Jagielski rRes = String::CreateFromInt32( nYear32 );
833*b1cdbd2cSJim Jagielski }
834*b1cdbd2cSJim Jagielski else
835*b1cdbd2cSJim Jagielski {
836*b1cdbd2cSJim Jagielski aFormatter.PutandConvertEntry( aFmtStr, nCheckPos, nType, nIndex, LANGUAGE_ENGLISH, eLangType );
837*b1cdbd2cSJim Jagielski aFormatter.GetOutputString( nNumber, nIndex, rRes, &pCol );
838*b1cdbd2cSJim Jagielski }
839*b1cdbd2cSJim Jagielski
840*b1cdbd2cSJim Jagielski return;
841*b1cdbd2cSJim Jagielski }
842*b1cdbd2cSJim Jagielski }
843*b1cdbd2cSJim Jagielski
844*b1cdbd2cSJim Jagielski SbxDataType eType = GetType();
845*b1cdbd2cSJim Jagielski switch( eType )
846*b1cdbd2cSJim Jagielski {
847*b1cdbd2cSJim Jagielski case SbxCHAR:
848*b1cdbd2cSJim Jagielski case SbxBYTE:
849*b1cdbd2cSJim Jagielski case SbxINTEGER:
850*b1cdbd2cSJim Jagielski case SbxUSHORT:
851*b1cdbd2cSJim Jagielski case SbxLONG:
852*b1cdbd2cSJim Jagielski case SbxULONG:
853*b1cdbd2cSJim Jagielski case SbxINT:
854*b1cdbd2cSJim Jagielski case SbxUINT:
855*b1cdbd2cSJim Jagielski case SbxNULL: // #45929 NULL mit durchschummeln
856*b1cdbd2cSJim Jagielski nComma = 0; goto cvt;
857*b1cdbd2cSJim Jagielski case SbxSINGLE:
858*b1cdbd2cSJim Jagielski nComma = 6; goto cvt;
859*b1cdbd2cSJim Jagielski case SbxDOUBLE:
860*b1cdbd2cSJim Jagielski nComma = 14;
861*b1cdbd2cSJim Jagielski
862*b1cdbd2cSJim Jagielski cvt:
863*b1cdbd2cSJim Jagielski if( eType != SbxNULL )
864*b1cdbd2cSJim Jagielski d = GetDouble();
865*b1cdbd2cSJim Jagielski
866*b1cdbd2cSJim Jagielski // #45355 weiterer Einsprungpunkt fuer isnumeric-String
867*b1cdbd2cSJim Jagielski cvt2:
868*b1cdbd2cSJim Jagielski if( pFmt )
869*b1cdbd2cSJim Jagielski {
870*b1cdbd2cSJim Jagielski // hole die 'statischen' Daten f"ur Sbx
871*b1cdbd2cSJim Jagielski SbxAppData* pData = GetSbxData_Impl();
872*b1cdbd2cSJim Jagielski
873*b1cdbd2cSJim Jagielski LanguageType eLangType = GetpApp()->GetSettings().GetLanguage();
874*b1cdbd2cSJim Jagielski if( pData->pBasicFormater )
875*b1cdbd2cSJim Jagielski {
876*b1cdbd2cSJim Jagielski if( pData->eBasicFormaterLangType != eLangType )
877*b1cdbd2cSJim Jagielski {
878*b1cdbd2cSJim Jagielski delete pData->pBasicFormater;
879*b1cdbd2cSJim Jagielski pData->pBasicFormater = NULL;
880*b1cdbd2cSJim Jagielski }
881*b1cdbd2cSJim Jagielski }
882*b1cdbd2cSJim Jagielski pData->eBasicFormaterLangType = eLangType;
883*b1cdbd2cSJim Jagielski
884*b1cdbd2cSJim Jagielski // falls bisher noch kein BasicFormater-Objekt
885*b1cdbd2cSJim Jagielski // existiert, so erzeuge dieses
886*b1cdbd2cSJim Jagielski if( !pData->pBasicFormater )
887*b1cdbd2cSJim Jagielski {
888*b1cdbd2cSJim Jagielski SvtSysLocale aSysLocale;
889*b1cdbd2cSJim Jagielski const LocaleDataWrapper& rData = aSysLocale.GetLocaleData();
890*b1cdbd2cSJim Jagielski sal_Unicode cComma = rData.getNumDecimalSep().GetBuffer()[0];
891*b1cdbd2cSJim Jagielski sal_Unicode c1000 = rData.getNumThousandSep().GetBuffer()[0];
892*b1cdbd2cSJim Jagielski String aCurrencyStrg = rData.getCurrSymbol();
893*b1cdbd2cSJim Jagielski
894*b1cdbd2cSJim Jagielski // Initialisierung des Basic-Formater-Hilfsobjekts:
895*b1cdbd2cSJim Jagielski // hole die Resourcen f"ur die vordefinierten Ausgaben
896*b1cdbd2cSJim Jagielski // des Format()-Befehls, z.B. f"ur "On/Off".
897*b1cdbd2cSJim Jagielski String aOnStrg = String( SbxValueFormatResId(
898*b1cdbd2cSJim Jagielski STR_BASICKEY_FORMAT_ON ) );
899*b1cdbd2cSJim Jagielski String aOffStrg = String( SbxValueFormatResId(
900*b1cdbd2cSJim Jagielski STR_BASICKEY_FORMAT_OFF) );
901*b1cdbd2cSJim Jagielski String aYesStrg = String( SbxValueFormatResId(
902*b1cdbd2cSJim Jagielski STR_BASICKEY_FORMAT_YES) );
903*b1cdbd2cSJim Jagielski String aNoStrg = String( SbxValueFormatResId(
904*b1cdbd2cSJim Jagielski STR_BASICKEY_FORMAT_NO) );
905*b1cdbd2cSJim Jagielski String aTrueStrg = String( SbxValueFormatResId(
906*b1cdbd2cSJim Jagielski STR_BASICKEY_FORMAT_TRUE) );
907*b1cdbd2cSJim Jagielski String aFalseStrg = String( SbxValueFormatResId(
908*b1cdbd2cSJim Jagielski STR_BASICKEY_FORMAT_FALSE) );
909*b1cdbd2cSJim Jagielski String aCurrencyFormatStrg = String( SbxValueFormatResId(
910*b1cdbd2cSJim Jagielski STR_BASICKEY_FORMAT_CURRENCY) );
911*b1cdbd2cSJim Jagielski // erzeuge das Basic-Formater-Objekt
912*b1cdbd2cSJim Jagielski pData->pBasicFormater
913*b1cdbd2cSJim Jagielski = new SbxBasicFormater( cComma,c1000,aOnStrg,aOffStrg,
914*b1cdbd2cSJim Jagielski aYesStrg,aNoStrg,aTrueStrg,aFalseStrg,
915*b1cdbd2cSJim Jagielski aCurrencyStrg,aCurrencyFormatStrg );
916*b1cdbd2cSJim Jagielski }
917*b1cdbd2cSJim Jagielski // Bem.: Aus Performance-Gr"unden wird nur EIN BasicFormater-
918*b1cdbd2cSJim Jagielski // Objekt erzeugt und 'gespeichert', dadurch erspart man
919*b1cdbd2cSJim Jagielski // sich das teure Resourcen-Laden (f"ur landesspezifische
920*b1cdbd2cSJim Jagielski // vordefinierte Ausgaben, z.B. "On/Off") und die st"andige
921*b1cdbd2cSJim Jagielski // String-Erzeugungs Operationen.
922*b1cdbd2cSJim Jagielski // ABER: dadurch ist dieser Code NICHT multithreading f"ahig !
923*b1cdbd2cSJim Jagielski
924*b1cdbd2cSJim Jagielski // hier gibt es Probleme mit ;;;Null, da diese Methode nur aufgerufen
925*b1cdbd2cSJim Jagielski // wird, wenn der SbxValue eine Zahl ist !!!
926*b1cdbd2cSJim Jagielski // dazu koennte: pData->pBasicFormater->BasicFormatNull( *pFmt ); aufgerufen werden !
927*b1cdbd2cSJim Jagielski if( eType != SbxNULL )
928*b1cdbd2cSJim Jagielski {
929*b1cdbd2cSJim Jagielski rRes = pData->pBasicFormater->BasicFormat( d ,*pFmt );
930*b1cdbd2cSJim Jagielski }
931*b1cdbd2cSJim Jagielski else
932*b1cdbd2cSJim Jagielski {
933*b1cdbd2cSJim Jagielski rRes = pData->pBasicFormater->BasicFormatNull( *pFmt );
934*b1cdbd2cSJim Jagielski }
935*b1cdbd2cSJim Jagielski
936*b1cdbd2cSJim Jagielski // Die alte Implementierung:
937*b1cdbd2cSJim Jagielski //old: printfmtnum( GetDouble(), rRes, *pFmt );
938*b1cdbd2cSJim Jagielski }
939*b1cdbd2cSJim Jagielski else
940*b1cdbd2cSJim Jagielski {
941*b1cdbd2cSJim Jagielski ::rtl::OUString aTmpString( rRes );
942*b1cdbd2cSJim Jagielski ImpCvtNum( GetDouble(), nComma, aTmpString );
943*b1cdbd2cSJim Jagielski rRes = aTmpString;
944*b1cdbd2cSJim Jagielski }
945*b1cdbd2cSJim Jagielski break;
946*b1cdbd2cSJim Jagielski case SbxSTRING:
947*b1cdbd2cSJim Jagielski if( pFmt )
948*b1cdbd2cSJim Jagielski {
949*b1cdbd2cSJim Jagielski // #45355 wenn es numerisch ist, muss gewandelt werden
950*b1cdbd2cSJim Jagielski if( IsNumericRTL() )
951*b1cdbd2cSJim Jagielski {
952*b1cdbd2cSJim Jagielski ScanNumIntnl( GetString(), d, /*bSingle*/sal_False );
953*b1cdbd2cSJim Jagielski goto cvt2;
954*b1cdbd2cSJim Jagielski }
955*b1cdbd2cSJim Jagielski else
956*b1cdbd2cSJim Jagielski {
957*b1cdbd2cSJim Jagielski // Sonst String-Formatierung
958*b1cdbd2cSJim Jagielski printfmtstr( GetString(), rRes, *pFmt );
959*b1cdbd2cSJim Jagielski }
960*b1cdbd2cSJim Jagielski }
961*b1cdbd2cSJim Jagielski else
962*b1cdbd2cSJim Jagielski rRes = GetString();
963*b1cdbd2cSJim Jagielski break;
964*b1cdbd2cSJim Jagielski default:
965*b1cdbd2cSJim Jagielski rRes = GetString();
966*b1cdbd2cSJim Jagielski }
967*b1cdbd2cSJim Jagielski }
968*b1cdbd2cSJim Jagielski
969*b1cdbd2cSJim Jagielski
970