Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <float.h>
21 : #include <rtl/math.hxx>
22 : #include <svl/zforlist.hxx>
23 : #include <svl/zformat.hxx>
24 : #include <editeng/unolingu.hxx>
25 : #include <unofldmid.h>
26 : #include <doc.hxx>
27 : #include <editsh.hxx>
28 : #include <frame.hxx>
29 : #include <fldbas.hxx>
30 : #include <flddat.hxx>
31 : #include <ndtxt.hxx>
32 : #include <fmtfld.hxx>
33 : #include <txtfld.hxx>
34 : #include <pam.hxx>
35 : #include <docfld.hxx>
36 : #include <swtable.hxx>
37 : #include <docufld.hxx>
38 : #include <expfld.hxx>
39 : #include <shellres.hxx>
40 : #include <calc.hxx>
41 : #include <comcore.hrc>
42 : #include <docary.hxx>
43 : #include <authfld.hxx>
44 :
45 : #include <math.h>
46 :
47 : using namespace ::com::sun::star;
48 : using namespace nsSwDocInfoSubType;
49 :
50 154 : static sal_uInt16 lcl_GetLanguageOfFormat( sal_uInt16 nLng, sal_uLong nFmt,
51 : const SvNumberFormatter& rFormatter )
52 : {
53 154 : if( nLng == LANGUAGE_NONE ) // Bug #60010
54 0 : nLng = LANGUAGE_SYSTEM;
55 154 : else if( nLng == ::GetAppLanguage() )
56 36 : switch( rFormatter.GetIndexTableOffset( nFmt ))
57 : {
58 : case NF_NUMBER_SYSTEM:
59 : case NF_DATE_SYSTEM_SHORT:
60 : case NF_DATE_SYSTEM_LONG:
61 : case NF_DATETIME_SYSTEM_SHORT_HHMM:
62 6 : nLng = LANGUAGE_SYSTEM;
63 6 : break;
64 30 : default: break;
65 : }
66 154 : return nLng;
67 : }
68 :
69 : // Globals
70 :
71 : /// field names
72 : std::vector<OUString>* SwFieldType::pFldNames = 0;
73 :
74 : namespace
75 : {
76 :
77 : const sal_uInt16 aTypeTab[] = {
78 : /* RES_DBFLD */ TYP_DBFLD,
79 : /* RES_USERFLD */ TYP_USERFLD,
80 : /* RES_FILENAMEFLD */ TYP_FILENAMEFLD,
81 : /* RES_DBNAMEFLD */ TYP_DBNAMEFLD,
82 : /* RES_DATEFLD */ TYP_DATEFLD,
83 : /* RES_TIMEFLD */ TYP_TIMEFLD,
84 : /* RES_PAGENUMBERFLD */ TYP_PAGENUMBERFLD, // dynamic
85 : /* RES_AUTHORFLD */ TYP_AUTHORFLD,
86 : /* RES_CHAPTERFLD */ TYP_CHAPTERFLD,
87 : /* RES_DOCSTATFLD */ TYP_DOCSTATFLD,
88 : /* RES_GETEXPFLD */ TYP_GETFLD, // dynamic
89 : /* RES_SETEXPFLD */ TYP_SETFLD, // dynamic
90 : /* RES_GETREFFLD */ TYP_GETREFFLD,
91 : /* RES_HIDDENTXTFLD */ TYP_HIDDENTXTFLD,
92 : /* RES_POSTITFLD */ TYP_POSTITFLD,
93 : /* RES_FIXDATEFLD */ TYP_FIXDATEFLD,
94 : /* RES_FIXTIMEFLD */ TYP_FIXTIMEFLD,
95 : /* RES_REGFLD */ 0, // old (no change since 2000)
96 : /* RES_VARREGFLD */ 0, // old (no change since 2000)
97 : /* RES_SETREFFLD */ TYP_SETREFFLD,
98 : /* RES_INPUTFLD */ TYP_INPUTFLD,
99 : /* RES_MACROFLD */ TYP_MACROFLD,
100 : /* RES_DDEFLD */ TYP_DDEFLD,
101 : /* RES_TABLEFLD */ TYP_FORMELFLD,
102 : /* RES_HIDDENPARAFLD */ TYP_HIDDENPARAFLD,
103 : /* RES_DOCINFOFLD */ TYP_DOCINFOFLD,
104 : /* RES_TEMPLNAMEFLD */ TYP_TEMPLNAMEFLD,
105 : /* RES_DBNEXTSETFLD */ TYP_DBNEXTSETFLD,
106 : /* RES_DBNUMSETFLD */ TYP_DBNUMSETFLD,
107 : /* RES_DBSETNUMBERFLD */ TYP_DBSETNUMBERFLD,
108 : /* RES_EXTUSERFLD */ TYP_EXTUSERFLD,
109 : /* RES_REFPAGESETFLD */ TYP_SETREFPAGEFLD,
110 : /* RES_REFPAGEGETFLD */ TYP_GETREFPAGEFLD,
111 : /* RES_INTERNETFLD */ TYP_INTERNETFLD,
112 : /* RES_JUMPEDITFLD */ TYP_JUMPEDITFLD,
113 : /* RES_SCRIPTFLD */ TYP_SCRIPTFLD,
114 : /* RES_DATETIMEFLD */ 0, // dynamic
115 : /* RES_AUTHORITY */ TYP_AUTHORITY,
116 : /* RES_COMBINED_CHARS */ TYP_COMBINED_CHARS,
117 : /* RES_DROPDOWN */ TYP_DROPDOWN
118 : };
119 :
120 : }
121 :
122 24 : OUString SwFieldType::GetTypeStr(sal_uInt16 nTypeId)
123 : {
124 24 : if( !pFldNames )
125 10 : _GetFldName();
126 :
127 24 : if( nTypeId < SwFieldType::pFldNames->size() )
128 24 : return (*SwFieldType::pFldNames)[nTypeId];
129 0 : return OUString();
130 : }
131 :
132 : // each field refences a field type that is unique for each document
133 162060 : SwFieldType::SwFieldType( sal_uInt16 nWhichId )
134 : : SwModify(0),
135 162060 : nWhich( nWhichId )
136 : {
137 162060 : }
138 :
139 48020 : OUString SwFieldType::GetName() const
140 : {
141 48020 : return OUString();
142 : }
143 :
144 0 : bool SwFieldType::QueryValue( uno::Any&, sal_uInt16 ) const
145 : {
146 0 : return false;
147 : }
148 0 : bool SwFieldType::PutValue( const uno::Any& , sal_uInt16 )
149 : {
150 0 : return false;
151 : }
152 :
153 : // Base class for all fields.
154 : // A field (multiple can exist) references a field type (can exists only once)
155 12138 : SwField::SwField(
156 : SwFieldType* pTyp,
157 : sal_uInt32 nFmt,
158 : sal_uInt16 nLng,
159 : bool bUseFieldValueCache )
160 : : m_Cache()
161 : , m_bUseFieldValueCache( bUseFieldValueCache )
162 : , nLang( nLng )
163 : , bIsAutomaticLanguage( true )
164 : , nFormat( nFmt )
165 12138 : , pType( pTyp )
166 : {
167 : OSL_ENSURE( pTyp, "SwField: no SwFieldType" );
168 12138 : }
169 :
170 12126 : SwField::~SwField()
171 : {
172 12126 : }
173 :
174 : // instead of indirectly via the type
175 :
176 : #ifdef DBG_UTIL
177 : sal_uInt16 SwField::Which() const
178 : {
179 : OSL_ENSURE(pType, "SwField: No FieldType");
180 : return pType->Which();
181 : }
182 : #endif
183 :
184 9462 : sal_uInt16 SwField::GetTypeId() const
185 : {
186 :
187 : sal_uInt16 nRet;
188 9462 : switch( pType->Which() )
189 : {
190 : case RES_DATETIMEFLD:
191 48 : if (GetSubType() & FIXEDFLD)
192 0 : nRet = static_cast<sal_uInt16>(GetSubType() & DATEFLD ? TYP_FIXDATEFLD : TYP_FIXTIMEFLD);
193 : else
194 48 : nRet = static_cast<sal_uInt16>(GetSubType() & DATEFLD ? TYP_DATEFLD : TYP_TIMEFLD);
195 48 : break;
196 : case RES_GETEXPFLD:
197 4 : nRet = static_cast<sal_uInt16>(nsSwGetSetExpType::GSE_FORMULA & GetSubType() ? TYP_FORMELFLD : TYP_GETFLD);
198 4 : break;
199 :
200 : case RES_HIDDENTXTFLD:
201 0 : nRet = GetSubType();
202 0 : break;
203 :
204 : case RES_SETEXPFLD:
205 210 : if( nsSwGetSetExpType::GSE_SEQ & GetSubType() )
206 158 : nRet = TYP_SEQFLD;
207 52 : else if( ((SwSetExpField*)this)->GetInputFlag() )
208 16 : nRet = TYP_SETINPFLD;
209 : else
210 36 : nRet = TYP_SETFLD;
211 210 : break;
212 :
213 : case RES_PAGENUMBERFLD:
214 4830 : nRet = GetSubType();
215 4830 : if( PG_NEXT == nRet )
216 0 : nRet = TYP_NEXTPAGEFLD;
217 4830 : else if( PG_PREV == nRet )
218 0 : nRet = TYP_PREVPAGEFLD;
219 : else
220 4830 : nRet = TYP_PAGENUMBERFLD;
221 4830 : break;
222 :
223 : default:
224 4370 : nRet = aTypeTab[ pType->Which() ];
225 : }
226 9462 : return nRet;
227 : }
228 :
229 : /// get name or content
230 0 : OUString SwField::GetFieldName() const
231 : {
232 0 : sal_uInt16 nTypeId = GetTypeId();
233 0 : if (RES_DATETIMEFLD == GetTyp()->Which())
234 : {
235 : nTypeId = static_cast<sal_uInt16>(
236 0 : ((GetSubType() & DATEFLD) != 0) ? TYP_DATEFLD : TYP_TIMEFLD);
237 : }
238 0 : OUString sRet = SwFieldType::GetTypeStr( nTypeId );
239 0 : if (IsFixed())
240 : {
241 0 : sRet += " " + OUString(SwViewShell::GetShellRes()->aFixedStr);
242 : }
243 0 : return sRet;
244 : }
245 :
246 0 : OUString SwField::GetPar1() const
247 : {
248 0 : return OUString();
249 : }
250 :
251 0 : OUString SwField::GetPar2() const
252 : {
253 0 : return OUString();
254 : }
255 :
256 0 : OUString SwField::GetFormula() const
257 : {
258 0 : return GetPar2();
259 : }
260 :
261 0 : void SwField::SetPar1(const OUString& )
262 0 : {}
263 :
264 0 : void SwField::SetPar2(const OUString& )
265 0 : {}
266 :
267 110 : sal_uInt16 SwField::GetSubType() const
268 : {
269 110 : return 0;
270 : }
271 :
272 0 : void SwField::SetSubType(sal_uInt16 )
273 : {
274 0 : }
275 :
276 8 : bool SwField::QueryValue( uno::Any& rVal, sal_uInt16 nWhichId ) const
277 : {
278 8 : switch( nWhichId )
279 : {
280 : case FIELD_PROP_BOOL4:
281 : {
282 8 : sal_Bool bFixed = !bIsAutomaticLanguage;
283 8 : rVal.setValue(&bFixed, ::getCppuBooleanType());
284 : }
285 8 : break;
286 : default:
287 : OSL_FAIL("illegal property");
288 : }
289 8 : return true;
290 : }
291 :
292 0 : bool SwField::PutValue( const uno::Any& rVal, sal_uInt16 nWhichId )
293 : {
294 0 : switch( nWhichId )
295 : {
296 : case FIELD_PROP_BOOL4:
297 : {
298 0 : bool bFixed = false;
299 0 : if(rVal >>= bFixed)
300 0 : bIsAutomaticLanguage = !bFixed;
301 : }
302 0 : break;
303 : default:
304 : OSL_FAIL("illegal property");
305 : }
306 0 : return true;
307 : }
308 :
309 : /** Set a new type
310 : *
311 : * This is needed/used for copying between documents.
312 : * Needs to be always of the same type.
313 : * @param pNewType The new type.
314 : * @return The old type.
315 : */
316 72 : SwFieldType* SwField::ChgTyp( SwFieldType* pNewType )
317 : {
318 : OSL_ENSURE( pNewType && pNewType->Which() == pType->Which(),
319 : "no or different type" );
320 :
321 72 : SwFieldType* pOld = pType;
322 72 : pType = pNewType;
323 72 : return pOld;
324 : }
325 :
326 : /// Does the field have an action on a ClickHandler? (E.g. INetFields,...)
327 0 : bool SwField::HasClickHdl() const
328 : {
329 0 : bool bRet = false;
330 0 : switch( pType->Which() )
331 : {
332 : case RES_INTERNETFLD:
333 : case RES_JUMPEDITFLD:
334 : case RES_GETREFFLD:
335 : case RES_MACROFLD:
336 : case RES_INPUTFLD:
337 : case RES_DROPDOWN :
338 0 : bRet = true;
339 0 : break;
340 :
341 : case RES_SETEXPFLD:
342 0 : bRet = ((SwSetExpField*)this)->GetInputFlag();
343 0 : break;
344 : }
345 0 : return bRet;
346 : }
347 :
348 7942 : void SwField::SetLanguage(sal_uInt16 nLng)
349 : {
350 7942 : nLang = nLng;
351 7942 : }
352 :
353 10 : void SwField::ChangeFormat(sal_uInt32 n)
354 : {
355 10 : nFormat = n;
356 10 : }
357 :
358 764 : bool SwField::IsFixed() const
359 : {
360 764 : bool bRet = false;
361 764 : switch( pType->Which() )
362 : {
363 : case RES_FIXDATEFLD:
364 : case RES_FIXTIMEFLD:
365 0 : bRet = true;
366 0 : break;
367 :
368 : case RES_DATETIMEFLD:
369 290 : bRet = 0 != (GetSubType() & FIXEDFLD);
370 290 : break;
371 :
372 : case RES_EXTUSERFLD:
373 : case RES_AUTHORFLD:
374 156 : bRet = 0 != (GetFormat() & AF_FIXED);
375 156 : break;
376 :
377 : case RES_FILENAMEFLD:
378 172 : bRet = 0 != (GetFormat() & FF_FIXED);
379 172 : break;
380 :
381 : case RES_DOCINFOFLD:
382 146 : bRet = 0 != (GetSubType() & DI_SUB_FIXED);
383 146 : break;
384 : }
385 764 : return bRet;
386 : }
387 :
388 10398 : OUString SwField::ExpandField(bool const bCached, ToxAuthorityField eField) const
389 : {
390 10398 : if ( m_bUseFieldValueCache )
391 : {
392 10258 : if (!bCached) // #i85766# do not expand fields in clipboard documents
393 : {
394 9462 : if (GetTypeId() == TYP_AUTHORITY)
395 : {
396 126 : const SwAuthorityField* pAuthorityField = static_cast<const SwAuthorityField*>(this);
397 126 : m_Cache = pAuthorityField->ConditionalExpand(eField);
398 : }
399 : else
400 9336 : m_Cache = Expand();
401 : }
402 10258 : return m_Cache;
403 : }
404 :
405 140 : return Expand();
406 : }
407 :
408 28 : OUString SwField::ExpandCitation(ToxAuthorityField eField) const
409 : {
410 28 : const SwAuthorityField* pAuthorityField = static_cast<const SwAuthorityField*>(this);
411 28 : return (pAuthorityField ? pAuthorityField->ExpandCitation(eField) : OUString());
412 : }
413 :
414 10100 : SwField * SwField::CopyField() const
415 : {
416 10100 : SwField *const pNew = Copy();
417 : // #i85766# cache expansion of source (for clipboard)
418 : // use this->cache, not this->Expand(): only text formatting calls Expand()
419 10100 : pNew->m_Cache = m_Cache;
420 10100 : pNew->m_bUseFieldValueCache = m_bUseFieldValueCache;
421 :
422 10100 : return pNew;
423 : }
424 :
425 : /// expand numbering
426 5508 : OUString FormatNumber(sal_uInt32 nNum, sal_uInt32 nFormat)
427 : {
428 5508 : if(SVX_NUM_PAGEDESC == nFormat)
429 0 : return OUString::number( nNum );
430 5508 : SvxNumberType aNumber;
431 :
432 : OSL_ENSURE(nFormat != SVX_NUM_NUMBER_NONE, "wrong number format" );
433 :
434 5508 : aNumber.SetNumberingType((sal_Int16)nFormat);
435 5508 : return aNumber.GetNumStr(nNum);
436 : }
437 :
438 40712 : SwValueFieldType::SwValueFieldType( SwDoc* pDocPtr, sal_uInt16 nWhichId )
439 : : SwFieldType(nWhichId),
440 : pDoc(pDocPtr),
441 40712 : bUseFormat(true)
442 : {
443 40712 : }
444 :
445 0 : SwValueFieldType::SwValueFieldType( const SwValueFieldType& rTyp )
446 0 : : SwFieldType(rTyp.Which()),
447 0 : pDoc(rTyp.GetDoc()),
448 0 : bUseFormat(rTyp.UseFormat())
449 : {
450 0 : }
451 :
452 : /// return value formatted as string
453 82 : OUString SwValueFieldType::ExpandValue( const double& rVal,
454 : sal_uInt32 nFmt, sal_uInt16 nLng) const
455 : {
456 82 : if (rVal >= DBL_MAX) // error string for calculator
457 0 : return SwViewShell::GetShellRes()->aCalc_Error;
458 :
459 82 : OUString sExpand;
460 82 : SvNumberFormatter* pFormatter = pDoc->GetNumberFormatter();
461 82 : Color* pCol = 0;
462 :
463 : // Bug #60010
464 82 : sal_uInt16 nFmtLng = ::lcl_GetLanguageOfFormat( nLng, nFmt, *pFormatter );
465 :
466 82 : if( nFmt < SV_COUNTRY_LANGUAGE_OFFSET && LANGUAGE_SYSTEM != nFmtLng )
467 : {
468 14 : short nType = NUMBERFORMAT_DEFINED;
469 : sal_Int32 nDummy;
470 :
471 14 : const SvNumberformat* pEntry = pFormatter->GetEntry(nFmt);
472 :
473 14 : if (pEntry && nLng != pEntry->GetLanguage())
474 : {
475 : sal_uInt32 nNewFormat = pFormatter->GetFormatForLanguageIfBuiltIn(nFmt,
476 14 : (LanguageType)nFmtLng);
477 :
478 14 : if (nNewFormat == nFmt)
479 : {
480 : // probably user-defined format
481 0 : OUString sFmt(pEntry->GetFormatstring());
482 :
483 : pFormatter->PutandConvertEntry(sFmt, nDummy, nType, nFmt,
484 0 : pEntry->GetLanguage(), nFmtLng );
485 : }
486 : else
487 14 : nFmt = nNewFormat;
488 : }
489 : OSL_ENSURE(pEntry, "unknown number format!");
490 : }
491 :
492 82 : if( pFormatter->IsTextFormat( nFmt ) )
493 : {
494 : pFormatter->GetOutputString(DoubleToString(rVal, nFmtLng), nFmt,
495 0 : sExpand, &pCol);
496 : }
497 : else
498 : {
499 82 : pFormatter->GetOutputString(rVal, nFmt, sExpand, &pCol);
500 : }
501 82 : return sExpand;
502 : }
503 :
504 0 : OUString SwValueFieldType::DoubleToString(const double &rVal,
505 : sal_uInt32 nFmt) const
506 : {
507 0 : SvNumberFormatter* pFormatter = pDoc->GetNumberFormatter();
508 0 : const SvNumberformat* pEntry = pFormatter->GetEntry(nFmt);
509 :
510 0 : if (!pEntry)
511 0 : return OUString();
512 :
513 0 : return DoubleToString(rVal, pEntry->GetLanguage());
514 : }
515 :
516 0 : OUString SwValueFieldType::DoubleToString( const double &rVal,
517 : sal_uInt16 nLng ) const
518 : {
519 0 : SvNumberFormatter* pFormatter = pDoc->GetNumberFormatter();
520 :
521 : // Bug #60010
522 0 : if( nLng == LANGUAGE_NONE )
523 0 : nLng = LANGUAGE_SYSTEM;
524 :
525 0 : pFormatter->ChangeIntl( nLng ); // get separator in the correct language
526 : return ::rtl::math::doubleToUString( rVal, rtl_math_StringFormat_F, 12,
527 0 : pFormatter->GetDecSep(), true );
528 : }
529 :
530 1240 : SwValueField::SwValueField( SwValueFieldType* pFldType, sal_uInt32 nFmt,
531 : sal_uInt16 nLng, const double fVal )
532 : : SwField(pFldType, nFmt, nLng),
533 1240 : fValue(fVal)
534 : {
535 1240 : }
536 :
537 0 : SwValueField::SwValueField( const SwValueField& rFld )
538 : : SwField(rFld),
539 0 : fValue(rFld.GetValue())
540 : {
541 0 : }
542 :
543 1234 : SwValueField::~SwValueField()
544 : {
545 1234 : }
546 :
547 : /** Set a new type
548 : *
549 : * This is needed/used for copying between documents.
550 : * Needs to be always of the same type.
551 : * @param pNewType The new type.
552 : * @return The old type.
553 : */
554 44 : SwFieldType* SwValueField::ChgTyp( SwFieldType* pNewType )
555 : {
556 44 : SwDoc* pNewDoc = ((SwValueFieldType *)pNewType)->GetDoc();
557 44 : SwDoc* pDoc = GetDoc();
558 :
559 44 : if( pNewDoc && pDoc && pDoc != pNewDoc)
560 : {
561 18 : SvNumberFormatter* pFormatter = pNewDoc->GetNumberFormatter();
562 :
563 18 : if( pFormatter && pFormatter->HasMergeFmtTbl() &&
564 0 : ((SwValueFieldType *)GetTyp())->UseFormat() )
565 0 : SetFormat(pFormatter->GetMergeFmtIndex( GetFormat() ));
566 : }
567 :
568 44 : return SwField::ChgTyp(pNewType);
569 : }
570 :
571 : /// get format in office language
572 0 : sal_uInt32 SwValueField::GetSystemFormat(SvNumberFormatter* pFormatter, sal_uInt32 nFmt)
573 : {
574 0 : const SvNumberformat* pEntry = pFormatter->GetEntry(nFmt);
575 0 : sal_uInt16 nLng = SvtSysLocale().GetLanguageTag().getLanguageType();
576 :
577 0 : if (pEntry && nLng != pEntry->GetLanguage())
578 : {
579 : sal_uInt32 nNewFormat = pFormatter->GetFormatForLanguageIfBuiltIn(nFmt,
580 0 : (LanguageType)nLng);
581 :
582 0 : if (nNewFormat == nFmt)
583 : {
584 : // probably user-defined format
585 0 : short nType = NUMBERFORMAT_DEFINED;
586 : sal_Int32 nDummy;
587 :
588 0 : OUString sFmt(pEntry->GetFormatstring());
589 :
590 0 : sal_uInt32 nFormat = nFmt;
591 : pFormatter->PutandConvertEntry(sFmt, nDummy, nType,
592 0 : nFormat, pEntry->GetLanguage(), nLng);
593 0 : nFmt = nFormat;
594 : }
595 : else
596 0 : nFmt = nNewFormat;
597 : }
598 :
599 0 : return nFmt;
600 : }
601 :
602 : /// set language of the format
603 582 : void SwValueField::SetLanguage( sal_uInt16 nLng )
604 : {
605 1236 : if( IsAutomaticLanguage() &&
606 654 : ((SwValueFieldType *)GetTyp())->UseFormat() &&
607 72 : GetFormat() != SAL_MAX_UINT32 )
608 : {
609 : // Bug #60010
610 72 : SvNumberFormatter* pFormatter = GetDoc()->GetNumberFormatter();
611 72 : sal_uInt16 nFmtLng = ::lcl_GetLanguageOfFormat( nLng, GetFormat(),
612 72 : *pFormatter );
613 :
614 198 : if( (GetFormat() >= SV_COUNTRY_LANGUAGE_OFFSET ||
615 200 : LANGUAGE_SYSTEM != nFmtLng ) &&
616 64 : !(Which() == RES_USERFLD && (GetSubType()&nsSwExtendedSubType::SUB_CMD) ) )
617 : {
618 64 : const SvNumberformat* pEntry = pFormatter->GetEntry(GetFormat());
619 :
620 64 : if( pEntry && nFmtLng != pEntry->GetLanguage() )
621 : {
622 : sal_uInt32 nNewFormat = pFormatter->GetFormatForLanguageIfBuiltIn(
623 46 : GetFormat(), (LanguageType)nFmtLng );
624 :
625 46 : if( nNewFormat == GetFormat() )
626 : {
627 : // probably user-defined format
628 0 : short nType = NUMBERFORMAT_DEFINED;
629 : sal_Int32 nDummy;
630 0 : OUString sFmt( pEntry->GetFormatstring() );
631 : pFormatter->PutandConvertEntry( sFmt, nDummy, nType,
632 : nNewFormat,
633 0 : pEntry->GetLanguage(),
634 0 : nFmtLng );
635 : }
636 46 : SetFormat( nNewFormat );
637 : }
638 : OSL_ENSURE(pEntry, "unknown number format!");
639 : }
640 : }
641 :
642 582 : SwField::SetLanguage(nLng);
643 582 : }
644 :
645 686 : double SwValueField::GetValue() const
646 : {
647 686 : return fValue;
648 : }
649 :
650 1248 : void SwValueField::SetValue( const double& rVal )
651 : {
652 1248 : fValue = rVal;
653 1248 : }
654 :
655 538 : SwFormulaField::SwFormulaField( SwValueFieldType* pFldType, sal_uInt32 nFmt, const double fVal)
656 538 : : SwValueField(pFldType, nFmt, LANGUAGE_SYSTEM, fVal)
657 : {
658 538 : }
659 :
660 0 : SwFormulaField::SwFormulaField( const SwFormulaField& rFld )
661 0 : : SwValueField((SwValueFieldType *)rFld.GetTyp(), rFld.GetFormat(),
662 0 : rFld.GetLanguage(), rFld.GetValue())
663 : {
664 0 : }
665 :
666 462 : OUString SwFormulaField::GetFormula() const
667 : {
668 462 : return sFormula;
669 : }
670 :
671 554 : void SwFormulaField::SetFormula(const OUString& rStr)
672 : {
673 554 : sFormula = rStr;
674 :
675 554 : sal_uLong nFmt(GetFormat());
676 :
677 554 : if( nFmt && SAL_MAX_UINT32 != nFmt )
678 : {
679 442 : sal_Int32 nPos = 0;
680 : double fTmpValue;
681 442 : if( SwCalc::Str2Double( rStr, nPos, fTmpValue, GetDoc() ) )
682 0 : SwValueField::SetValue( fTmpValue );
683 : }
684 554 : }
685 :
686 0 : void SwFormulaField::SetExpandedFormula( const OUString& rStr )
687 : {
688 0 : sal_uInt32 nFmt(GetFormat());
689 :
690 0 : if (nFmt && nFmt != SAL_MAX_UINT32 && ((SwValueFieldType *)GetTyp())->UseFormat())
691 : {
692 : double fTmpValue;
693 :
694 0 : SvNumberFormatter* pFormatter = GetDoc()->GetNumberFormatter();
695 :
696 0 : if (pFormatter->IsNumberFormat(rStr, nFmt, fTmpValue))
697 : {
698 0 : SwValueField::SetValue(fTmpValue);
699 :
700 0 : sFormula = ((SwValueFieldType *)GetTyp())->DoubleToString(fTmpValue, nFmt);
701 0 : return;
702 : }
703 : }
704 0 : sFormula = rStr;
705 : }
706 :
707 0 : OUString SwFormulaField::GetExpandedFormula() const
708 : {
709 0 : sal_uInt32 nFmt(GetFormat());
710 :
711 0 : if (nFmt && nFmt != SAL_MAX_UINT32 && ((SwValueFieldType *)GetTyp())->UseFormat())
712 : {
713 0 : OUString sFormattedValue;
714 0 : Color* pCol = 0;
715 :
716 0 : SvNumberFormatter* pFormatter = GetDoc()->GetNumberFormatter();
717 :
718 0 : if (pFormatter->IsTextFormat(nFmt))
719 : {
720 0 : OUString sTempIn(((SwValueFieldType *)GetTyp())->DoubleToString(GetValue(), nFmt));
721 0 : pFormatter->GetOutputString(sTempIn, nFmt, sFormattedValue, &pCol);
722 : }
723 : else
724 : {
725 0 : pFormatter->GetOutputString(GetValue(), nFmt, sFormattedValue, &pCol);
726 : }
727 0 : return sFormattedValue;
728 : }
729 : else
730 0 : return GetFormula();
731 : }
732 :
733 46 : OUString SwField::GetDescription() const
734 : {
735 46 : return SW_RES(STR_FIELD);
736 : }
737 :
738 0 : bool SwField::IsClickable() const
739 : {
740 0 : switch (Which())
741 : {
742 : case RES_JUMPEDITFLD:
743 : case RES_MACROFLD:
744 : case RES_GETREFFLD:
745 : case RES_INPUTFLD:
746 : case RES_SETEXPFLD:
747 : case RES_DROPDOWN:
748 0 : return true;
749 : }
750 0 : return false;
751 : }
752 :
753 76 : sal_uInt16 SwFldTypes::GetPos(const SwFieldType* pFieldType) const
754 : {
755 76 : const_iterator it = std::find(begin(), end(), pFieldType);
756 76 : return it == end() ? USHRT_MAX : it - begin();
757 : }
758 :
759 10090 : SwFldTypes::~SwFldTypes()
760 : {
761 166615 : for(const_iterator it = begin(); it != end(); ++it)
762 161570 : delete *it;
763 5315 : }
764 :
765 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
