xref: /aoo42x/main/sw/source/core/fields/fldbas.cxx (revision cdf0e10c) 
1 /*************************************************************************
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * Copyright 2000, 2010 Oracle and/or its affiliates.
6  *
7  * OpenOffice.org - a multi-platform office productivity suite
8  *
9  * This file is part of OpenOffice.org.
10  *
11  * OpenOffice.org is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License version 3
13  * only, as published by the Free Software Foundation.
14  *
15  * OpenOffice.org is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License version 3 for more details
19  * (a copy is included in the LICENSE file that accompanied this code).
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * version 3 along with OpenOffice.org.  If not, see
23  * <http://www.openoffice.org/license.html>
24  * for a copy of the LGPLv3 License.
25  *
26  ************************************************************************/
27 
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_sw.hxx"
30 
31 #include <float.h>
32 #include <rtl/math.hxx>
33 #include <svl/zforlist.hxx>
34 #include <svl/zformat.hxx>
35 #include <editeng/unolingu.hxx>
36 #include <unofldmid.h>
37 #include <doc.hxx>
38 #include <editsh.hxx>
39 #include <frame.hxx>
40 #include <fldbas.hxx>
41 #include <flddat.hxx>
42 #include <ndtxt.hxx>
43 #include <fmtfld.hxx>
44 #include <txtfld.hxx>
45 #include <pam.hxx>
46 #include <docfld.hxx>
47 #include <swtable.hxx>
48 #include <docufld.hxx>
49 #include <expfld.hxx>
50 #include <shellres.hxx>
51 #include <calc.hxx>
52 #include <comcore.hrc>
53 
54 #include <math.h>
55 #include <float.h>
56 
57 using namespace ::com::sun::star;
58 using namespace nsSwDocInfoSubType;
59 
60 sal_uInt16 lcl_GetLanguageOfFormat( sal_uInt16 nLng, sal_uLong nFmt,
61 								const SvNumberFormatter& rFormatter )
62 {
63 	if( nLng == LANGUAGE_NONE )	// wegen Bug #60010
64 		nLng = LANGUAGE_SYSTEM;
65 	else if( nLng == ::GetAppLanguage() )
66 		switch( rFormatter.GetIndexTableOffset( nFmt ))
67 		{
68 		case NF_NUMBER_SYSTEM:
69 		case NF_DATE_SYSTEM_SHORT:
70 		case NF_DATE_SYSTEM_LONG:
71 		case NF_DATETIME_SYSTEM_SHORT_HHMM:
72 			nLng = LANGUAGE_SYSTEM;
73 			break;
74         default: break;
75 		}
76 	return nLng;
77 }
78 
79 /*--------------------------------------------------------------------
80 	Beschreibung: Globals
81  --------------------------------------------------------------------*/
82 // Array der Feldname
83 
84 SvStringsDtor* SwFieldType::pFldNames = 0;
85 
86 DBG_NAME(SwFieldType)
87 
88 	sal_uInt16 __FAR_DATA aTypeTab[] = {
89 	/* RES_DBFLD			*/		TYP_DBFLD,
90 	/* RES_USERFLD			*/		TYP_USERFLD,
91 	/* RES_FILENAMEFLD		*/		TYP_FILENAMEFLD,
92 	/* RES_DBNAMEFLD		*/		TYP_DBNAMEFLD,
93 	/* RES_DATEFLD	   		*/		TYP_DATEFLD,
94 	/* RES_TIMEFLD			*/		TYP_TIMEFLD,
95 	/* RES_PAGENUMBERFLD	*/		TYP_PAGENUMBERFLD,	// dynamisch
96 	/* RES_AUTHORFLD		*/		TYP_AUTHORFLD,
97 	/* RES_CHAPTERFLD		*/		TYP_CHAPTERFLD,
98 	/* RES_DOCSTATFLD		*/		TYP_DOCSTATFLD,
99 	/* RES_GETEXPFLD		*/		TYP_GETFLD,			// dynamisch
100 	/* RES_SETEXPFLD		*/		TYP_SETFLD,			// dynamisch
101 	/* RES_GETREFFLD		*/		TYP_GETREFFLD,
102 	/* RES_HIDDENTXTFLD		*/		TYP_HIDDENTXTFLD,
103 	/* RES_POSTITFLD		*/		TYP_POSTITFLD,
104 	/* RES_FIXDATEFLD		*/		TYP_FIXDATEFLD,
105 	/* RES_FIXTIMEFLD		*/		TYP_FIXTIMEFLD,
106 	/* RES_REGFLD			*/		0,					// alt
107 	/* RES_VARREGFLD		*/		0,					// alt
108 	/* RES_SETREFFLD		*/		TYP_SETREFFLD,
109 	/* RES_INPUTFLD			*/		TYP_INPUTFLD,
110 	/* RES_MACROFLD			*/		TYP_MACROFLD,
111 	/* RES_DDEFLD			*/		TYP_DDEFLD,
112 	/* RES_TABLEFLD			*/		TYP_FORMELFLD,
113 	/* RES_HIDDENPARAFLD	*/		TYP_HIDDENPARAFLD,
114 	/* RES_DOCINFOFLD		*/		TYP_DOCINFOFLD,
115 	/* RES_TEMPLNAMEFLD		*/		TYP_TEMPLNAMEFLD,
116 	/* RES_DBNEXTSETFLD		*/		TYP_DBNEXTSETFLD,
117 	/* RES_DBNUMSETFLD		*/		TYP_DBNUMSETFLD,
118 	/* RES_DBSETNUMBERFLD	*/		TYP_DBSETNUMBERFLD,
119 	/* RES_EXTUSERFLD		*/		TYP_EXTUSERFLD,
120 	/* RES_REFPAGESETFLD	*/		TYP_SETREFPAGEFLD,
121 	/* RES_REFPAGEGETFLD    */		TYP_GETREFPAGEFLD,
122 	/* RES_INTERNETFLD		*/ 		TYP_INTERNETFLD,
123 	/* RES_JUMPEDITFLD		*/		TYP_JUMPEDITFLD,
124 	/* RES_SCRIPTFLD		*/		TYP_SCRIPTFLD,
125 	/* RES_DATETIMEFLD		*/		0,					// dynamisch
126 	/* RES_AUTHORITY		*/		TYP_AUTHORITY,
127 	/* RES_COMBINED_CHARS	*/		TYP_COMBINED_CHARS,
128     /* RES_DROPDOWN         */      TYP_DROPDOWN
129 	};
130 		// ????? TYP_USRINPFLD,
131 
132 
133 
134 const String& SwFieldType::GetTypeStr(sal_uInt16 nTypeId)
135 {
136 	if( !pFldNames )
137 		_GetFldName();
138 
139 	if( nTypeId < SwFieldType::pFldNames->Count() )
140 		return *SwFieldType::pFldNames->GetObject( nTypeId );
141 	else
142 		return aEmptyStr;
143 }
144 
145 
146 /*---------------------------------------------------
147  Jedes Feld referenziert einen Feldtypen, der fuer
148  jedes Dokument einmalig ist.
149  --------------------------------------------------*/
150 
151 SwFieldType::SwFieldType( sal_uInt16 nWhichId )
152 	: SwModify(0),
153 	nWhich( nWhichId )
154 {
155 	DBG_CTOR( SwFieldType, 0 );
156 }
157 
158 #ifdef DBG_UTIL
159 
160 SwFieldType::~SwFieldType()
161 {
162 	DBG_DTOR( SwFieldType, 0 );
163 }
164 
165 #endif
166 
167 const String& SwFieldType::GetName() const
168 {
169 	return aEmptyStr;
170 }
171 
172 sal_Bool SwFieldType::QueryValue( uno::Any&, sal_uInt16 ) const
173 {
174 	return sal_False;
175 }
176 sal_Bool SwFieldType::PutValue( const uno::Any& , sal_uInt16 )
177 {
178 	return sal_False;
179 }
180 
181 /*--------------------------------------------------------------------
182 	Beschreibung:	Basisklasse aller Felder
183 					Felder referenzieren einen Feldtyp
184 					Felder sind n-mal vorhanden, Feldtypen nur einmal
185  --------------------------------------------------------------------*/
186 
187 SwField::SwField(SwFieldType* pTyp, sal_uInt32 nFmt, sal_uInt16 nLng) :
188     nLang(nLng),
189     bIsAutomaticLanguage(sal_True),
190 	nFormat(nFmt)
191 {
192 	ASSERT( pTyp, "SwField: ungueltiger SwFieldType" );
193 	pType = pTyp;
194 }
195 
196 SwField::~SwField()
197 {
198 }
199 
200 /*--------------------------------------------------------------------
201 	Beschreibung: Statt Umweg ueber den Typ
202  --------------------------------------------------------------------*/
203 
204 #ifdef DBG_UTIL
205 sal_uInt16 SwField::Which() const
206 {
207 	ASSERT(pType, "Kein Typ vorhanden");
208 	return pType->Which();
209 }
210 #endif
211 
212 /*--------------------------------------------------------------------
213 	Beschreibung:
214  --------------------------------------------------------------------*/
215 
216 sal_uInt16 SwField::GetTypeId() const
217 {
218 
219 	sal_uInt16 nRet;
220 	switch( pType->Which() )
221 	{
222 	case RES_DATETIMEFLD:
223 		if (GetSubType() & FIXEDFLD)
224 			nRet = static_cast<sal_uInt16>(GetSubType() & DATEFLD ? TYP_FIXDATEFLD : TYP_FIXTIMEFLD);
225 		else
226 			nRet = static_cast<sal_uInt16>(GetSubType() & DATEFLD ? TYP_DATEFLD : TYP_TIMEFLD);
227 		break;
228 	case RES_GETEXPFLD:
229 		nRet = static_cast<sal_uInt16>(nsSwGetSetExpType::GSE_FORMULA & GetSubType() ? TYP_FORMELFLD : TYP_GETFLD);
230 		break;
231 
232 	case RES_HIDDENTXTFLD:
233 		nRet = GetSubType();
234 		break;
235 
236 	case RES_SETEXPFLD:
237 		if( nsSwGetSetExpType::GSE_SEQ & GetSubType() )
238 			nRet = TYP_SEQFLD;
239 		else if( ((SwSetExpField*)this)->GetInputFlag() )
240 			nRet = TYP_SETINPFLD;
241 		else
242 			nRet = TYP_SETFLD;
243 		break;
244 
245 	case RES_PAGENUMBERFLD:
246 		nRet = GetSubType();
247 		if( PG_NEXT == nRet )
248 			nRet = TYP_NEXTPAGEFLD;
249 		else if( PG_PREV == nRet )
250 			nRet = TYP_PREVPAGEFLD;
251 		else
252 			nRet = TYP_PAGENUMBERFLD;
253 		break;
254 
255 	default:
256 		nRet = aTypeTab[ pType->Which() ];
257 	}
258 	return nRet;
259 }
260 
261 
262 /*--------------------------------------------------------------------
263 	Beschreibung: liefert den Namen oder den Inhalt
264  --------------------------------------------------------------------*/
265 
266 String SwField::GetFieldName() const
267 {
268     sal_uInt16 nTypeId = GetTypeId();
269     if (RES_DATETIMEFLD == GetTyp()->Which())
270     {
271         nTypeId = static_cast<sal_uInt16>(
272             ((GetSubType() & DATEFLD) != 0) ? TYP_DATEFLD : TYP_TIMEFLD);
273     }
274     String sRet = SwFieldType::GetTypeStr( nTypeId );
275     if (IsFixed())
276     {
277         sRet += ' ';
278         sRet += ViewShell::GetShellRes()->aFixedStr;
279     }
280 	return sRet;
281 }
282 
283 /*--------------------------------------------------------------------
284 	Beschreibung: Parameter setzen auslesen
285  --------------------------------------------------------------------*/
286 
287 const String& SwField::GetPar1() const
288 {
289 	return aEmptyStr;
290 }
291 
292 String SwField::GetPar2() const
293 {
294 	return aEmptyStr;
295 }
296 
297 String SwField::GetFormula() const
298 {
299 	return GetPar2();
300 }
301 
302 void SwField::SetPar1(const String& )
303 {}
304 
305 void SwField::SetPar2(const String& )
306 {}
307 
308 sal_uInt16 SwField::GetSubType() const
309 {
310 //	ASSERT(0, "Sorry Not implemented");
311 	return 0;
312 }
313 
314 void SwField::SetSubType(sal_uInt16 )
315 {
316 //	ASSERT(0, "Sorry Not implemented");
317 }
318 
319 sal_Bool  SwField::QueryValue( uno::Any& rVal, sal_uInt16 nWhichId ) const
320 {
321     switch( nWhichId )
322     {
323         case FIELD_PROP_BOOL4:
324         {
325             sal_Bool bFixed = !bIsAutomaticLanguage;
326             rVal.setValue(&bFixed, ::getCppuBooleanType());
327         }
328         break;
329         default:
330             DBG_ERROR("illegal property");
331     }
332     return sal_True;
333 }
334 sal_Bool SwField::PutValue( const uno::Any& rVal, sal_uInt16 nWhichId )
335 {
336     switch( nWhichId )
337     {
338         case FIELD_PROP_BOOL4:
339         {
340             sal_Bool bFixed = sal_False;
341             if(rVal >>= bFixed)
342                 bIsAutomaticLanguage = !bFixed;
343         }
344         break;
345         default:
346             DBG_ERROR("illegal property");
347     }
348     return sal_True;
349 }
350 
351 
352 /*--------------------------------------------------------------------
353 	Beschreibung: 	neuen Typ setzen
354 					(wird fuer das Kopieren zwischen Dokumenten benutzt)
355 					muss immer vom gleichen Typ sein.
356  --------------------------------------------------------------------*/
357 
358 SwFieldType* SwField::ChgTyp( SwFieldType* pNewType )
359 {
360 	ASSERT( pNewType && pNewType->Which() == pType->Which(),
361 			"kein Typ oder ungleiche Typen" );
362 
363 	SwFieldType* pOld = pType;
364 	pType = pNewType;
365 	return pOld;
366 }
367 
368 	// hat das Feld eine Action auf dem ClickHandler ? (z.B. INetFelder,..)
369 sal_Bool SwField::HasClickHdl() const
370 {
371 	sal_Bool bRet = sal_False;
372 	switch( pType->Which() )
373 	{
374 	case RES_INTERNETFLD:
375 	case RES_JUMPEDITFLD:
376 	case RES_GETREFFLD:
377 	case RES_MACROFLD:
378 	case RES_INPUTFLD:
379     case RES_DROPDOWN :
380 		bRet = sal_True;
381 		break;
382 
383 	case RES_SETEXPFLD:
384 		bRet = ((SwSetExpField*)this)->GetInputFlag();
385 		break;
386 	}
387 	return bRet;
388 }
389 
390 void SwField::SetLanguage(sal_uInt16 nLng)
391 {
392 	nLang = nLng;
393 }
394 
395 void SwField::ChangeFormat(sal_uInt32 n)
396 {
397 	nFormat = n;
398 }
399 
400 sal_Bool SwField::IsFixed() const
401 {
402 	sal_Bool bRet = sal_False;
403 	switch( pType->Which() )
404 	{
405 	case RES_FIXDATEFLD:
406 	case RES_FIXTIMEFLD:
407 		bRet = sal_True;
408 		break;
409 
410 	case RES_DATETIMEFLD:
411 		bRet = 0 != (GetSubType() & FIXEDFLD);
412 		break;
413 
414 	case RES_EXTUSERFLD:
415 	case RES_AUTHORFLD:
416 		bRet = 0 != (GetFormat() & AF_FIXED);
417 		break;
418 
419 	case RES_FILENAMEFLD:
420 		bRet = 0 != (GetFormat() & FF_FIXED);
421 		break;
422 
423 	case RES_DOCINFOFLD:
424 		bRet = 0 != (GetSubType() & DI_SUB_FIXED);
425 		break;
426 	}
427 	return bRet;
428 }
429 
430 String SwField::ExpandField(bool const bCached) const
431 {
432     if (!bCached) // #i85766# do not expand fields in clipboard documents
433     {
434         m_Cache = Expand();
435     }
436     return m_Cache;
437 }
438 
439 SwField * SwField::CopyField() const
440 {
441     SwField *const pNew = Copy();
442     // #i85766# cache expansion of source (for clipboard)
443     // use this->cache, not this->Expand(): only text formatting calls Expand()
444     pNew->m_Cache = m_Cache;
445     return pNew;
446 }
447 
448 /*--------------------------------------------------------------------
449 	Beschreibung: Numerierung expandieren
450  --------------------------------------------------------------------*/
451 
452 String FormatNumber(sal_uInt16 nNum, sal_uInt32 nFormat)
453 {
454     if(SVX_NUM_PAGEDESC == nFormat)
455         return  String::CreateFromInt32( nNum );
456     SvxNumberType aNumber;
457 
458 	ASSERT(nFormat != SVX_NUM_NUMBER_NONE, "Falsches Nummern-Format" );
459 
460 	aNumber.SetNumberingType((sal_Int16)nFormat);
461 	return aNumber.GetNumStr(nNum);
462 }
463 
464 /*--------------------------------------------------------------------
465 	Beschreibung: CTOR SwValueFieldType
466  --------------------------------------------------------------------*/
467 
468 SwValueFieldType::SwValueFieldType( SwDoc* pDocPtr, sal_uInt16 nWhichId )
469 	: SwFieldType(nWhichId),
470 	pDoc(pDocPtr),
471 	bUseFormat(sal_True)
472 {
473 }
474 
475 SwValueFieldType::SwValueFieldType( const SwValueFieldType& rTyp )
476 	: SwFieldType(rTyp.Which()),
477 	pDoc(rTyp.GetDoc()),
478 	bUseFormat(rTyp.UseFormat())
479 {
480 }
481 
482 /*--------------------------------------------------------------------
483 	Beschreibung: Wert formatiert als String zurueckgeben
484  --------------------------------------------------------------------*/
485 
486 String SwValueFieldType::ExpandValue( const double& rVal,
487 										sal_uInt32 nFmt, sal_uInt16 nLng) const
488 {
489 	if (rVal >= DBL_MAX)		// FehlerString fuer Calculator
490 		return ViewShell::GetShellRes()->aCalc_Error;
491 
492 	String sExpand;
493 	SvNumberFormatter* pFormatter = pDoc->GetNumberFormatter();
494 	Color* pCol = 0;
495 
496 	// wegen Bug #60010
497 	sal_uInt16 nFmtLng = ::lcl_GetLanguageOfFormat( nLng, nFmt, *pFormatter );
498 
499 	if( nFmt < SV_COUNTRY_LANGUAGE_OFFSET && LANGUAGE_SYSTEM != nFmtLng )
500 	{
501 		short nType = NUMBERFORMAT_DEFINED;
502 		xub_StrLen nDummy;
503 
504 		const SvNumberformat* pEntry = pFormatter->GetEntry(nFmt);
505 
506 		if (pEntry && nLng != pEntry->GetLanguage())
507 		{
508 			sal_uInt32 nNewFormat = pFormatter->GetFormatForLanguageIfBuiltIn(nFmt,
509 													(LanguageType)nFmtLng);
510 
511 			if (nNewFormat == nFmt)
512 			{
513 				// Warscheinlich benutzerdefiniertes Format
514 				String sFmt(pEntry->GetFormatstring());
515 
516 				pFormatter->PutandConvertEntry(sFmt, nDummy, nType, nFmt,
517 										pEntry->GetLanguage(), nFmtLng );
518 			}
519 			else
520 				nFmt = nNewFormat;
521 		}
522 		ASSERT(pEntry, "Unbekanntes Zahlenformat!");
523 	}
524 
525 	if( pFormatter->IsTextFormat( nFmt ) )
526 	{
527 		String sValue;
528 		DoubleToString(sValue, rVal, nFmtLng);
529 		pFormatter->GetOutputString(sValue, nFmt, sExpand, &pCol);
530 	}
531 	else
532 		pFormatter->GetOutputString(rVal, nFmt, sExpand, &pCol);
533 
534 	return sExpand;
535 }
536 
537 /*--------------------------------------------------------------------
538 	Beschreibung:
539  --------------------------------------------------------------------*/
540 
541 void SwValueFieldType::DoubleToString( String &rValue, const double &rVal,
542 										sal_uInt32 nFmt) const
543 {
544 	SvNumberFormatter* pFormatter = pDoc->GetNumberFormatter();
545 	const SvNumberformat* pEntry = pFormatter->GetEntry(nFmt);
546 
547 	if (pEntry)
548 		DoubleToString(rValue, rVal, pEntry->GetLanguage());
549 }
550 
551 /*--------------------------------------------------------------------
552 	Beschreibung:
553  --------------------------------------------------------------------*/
554 
555 void SwValueFieldType::DoubleToString( String &rValue, const double &rVal,
556 										sal_uInt16 nLng ) const
557 {
558 	SvNumberFormatter* pFormatter = pDoc->GetNumberFormatter();
559 
560 	// wegen Bug #60010
561 	if( nLng == LANGUAGE_NONE )	// wegen Bug #60010
562 		nLng = LANGUAGE_SYSTEM;
563 
564 	pFormatter->ChangeIntl( nLng );	// Separator in der richtigen Sprache besorgen
565 	rValue = ::rtl::math::doubleToUString( rVal, rtl_math_StringFormat_F, 12,
566 									pFormatter->GetDecSep(), true );
567 }
568 
569 /*--------------------------------------------------------------------
570 	Beschreibung: CTOR SwValueField
571  --------------------------------------------------------------------*/
572 
573 SwValueField::SwValueField( SwValueFieldType* pFldType, sal_uInt32 nFmt,
574 							sal_uInt16 nLng, const double fVal )
575 	: SwField(pFldType, nFmt, nLng),
576 	fValue(fVal)
577 {
578 }
579 
580 SwValueField::SwValueField( const SwValueField& rFld )
581 	: SwField(rFld),
582 	fValue(rFld.GetValue())
583 {
584 }
585 
586 SwValueField::~SwValueField()
587 {
588 }
589 /*--------------------------------------------------------------------
590 	Beschreibung: 	neuen Typ setzen
591 					(wird fuer das Kopieren zwischen Dokumenten benutzt)
592 					muss immer vom gleichen Typ sein.
593  --------------------------------------------------------------------*/
594 
595 SwFieldType* SwValueField::ChgTyp( SwFieldType* pNewType )
596 {
597 	SwDoc* pNewDoc = ((SwValueFieldType *)pNewType)->GetDoc();
598 	SwDoc* pDoc    = GetDoc();
599 
600 	if( pNewDoc && pDoc && pDoc != pNewDoc)
601 	{
602 		SvNumberFormatter* pFormatter = pNewDoc->GetNumberFormatter();
603 
604 		if( pFormatter && pFormatter->HasMergeFmtTbl() &&
605 			((SwValueFieldType *)GetTyp())->UseFormat() )
606 			SetFormat(pFormatter->GetMergeFmtIndex( GetFormat() ));
607 	}
608 
609 	return SwField::ChgTyp(pNewType);
610 }
611 
612 /*--------------------------------------------------------------------
613 	Beschreibung: Format in Office-Sprache ermitteln
614  --------------------------------------------------------------------*/
615 
616 sal_uInt32 SwValueField::GetSystemFormat(SvNumberFormatter* pFormatter, sal_uInt32 nFmt)
617 {
618 	const SvNumberformat* pEntry = pFormatter->GetEntry(nFmt);
619 	sal_uInt16 nLng = SvxLocaleToLanguage( SvtSysLocale().GetLocaleData().getLocale() );
620 
621 	if (pEntry && nLng != pEntry->GetLanguage())
622 	{
623 		sal_uInt32 nNewFormat = pFormatter->GetFormatForLanguageIfBuiltIn(nFmt,
624 														(LanguageType)nLng);
625 
626 		if (nNewFormat == nFmt)
627 		{
628 			// Warscheinlich benutzerdefiniertes Format
629 			short nType = NUMBERFORMAT_DEFINED;
630 			xub_StrLen nDummy;
631 
632 			String sFmt(pEntry->GetFormatstring());
633 
634 			sal_uInt32 nFormat = nFmt;
635 			pFormatter->PutandConvertEntry(sFmt, nDummy, nType,
636 								nFormat, pEntry->GetLanguage(), nLng);
637 			nFmt = nFormat;
638 		}
639 		else
640 			nFmt = nNewFormat;
641 	}
642 
643 	return nFmt;
644 }
645 
646 /*--------------------------------------------------------------------
647 	Beschreibung: Sprache im Format anpassen
648  --------------------------------------------------------------------*/
649 
650 void SwValueField::SetLanguage( sal_uInt16 nLng )
651 {
652     if( IsAutomaticLanguage() &&
653             ((SwValueFieldType *)GetTyp())->UseFormat() &&
654 		GetFormat() != SAL_MAX_UINT32 )
655 	{
656 		// wegen Bug #60010
657 		SvNumberFormatter* pFormatter = GetDoc()->GetNumberFormatter();
658 		sal_uInt16 nFmtLng = ::lcl_GetLanguageOfFormat( nLng, GetFormat(),
659 													*pFormatter );
660 
661 		if( (GetFormat() >= SV_COUNTRY_LANGUAGE_OFFSET ||
662 			 LANGUAGE_SYSTEM != nFmtLng ) &&
663 			!(Which() == RES_USERFLD && (GetSubType()&nsSwExtendedSubType::SUB_CMD) ) )
664 		{
665 			const SvNumberformat* pEntry = pFormatter->GetEntry(GetFormat());
666 
667 			if( pEntry && nFmtLng != pEntry->GetLanguage() )
668 			{
669 				sal_uInt32 nNewFormat = pFormatter->GetFormatForLanguageIfBuiltIn(
670 										GetFormat(), (LanguageType)nFmtLng );
671 
672 				if( nNewFormat == GetFormat() )
673 				{
674 					// Warscheinlich benutzerdefiniertes Format
675 					short nType = NUMBERFORMAT_DEFINED;
676 					xub_StrLen nDummy;
677 					String sFmt( pEntry->GetFormatstring() );
678 					pFormatter->PutandConvertEntry( sFmt, nDummy, nType,
679 													nNewFormat,
680 													pEntry->GetLanguage(),
681 													nFmtLng );
682 				}
683 				SetFormat( nNewFormat );
684 			}
685 			ASSERT(pEntry, "Unbekanntes Zahlenformat!");
686 		}
687 	}
688 
689 	SwField::SetLanguage(nLng);
690 }
691 
692 /*--------------------------------------------------------------------
693 	Beschreibung:
694  --------------------------------------------------------------------*/
695 
696 double SwValueField::GetValue() const
697 {
698 	return fValue;
699 }
700 
701 void SwValueField::SetValue( const double& rVal )
702 {
703 	fValue = rVal;
704 }
705 
706 /*--------------------------------------------------------------------
707 	Beschreibung: SwFormulaField
708  --------------------------------------------------------------------*/
709 
710 SwFormulaField::SwFormulaField( SwValueFieldType* pFldType, sal_uInt32 nFmt, const double fVal)
711 	: SwValueField(pFldType, nFmt, LANGUAGE_SYSTEM, fVal)
712 {
713 }
714 
715 SwFormulaField::SwFormulaField( const SwFormulaField& rFld )
716 	: SwValueField((SwValueFieldType *)rFld.GetTyp(), rFld.GetFormat(),
717 					rFld.GetLanguage(), rFld.GetValue())
718 {
719 }
720 
721 /*--------------------------------------------------------------------
722 	Beschreibung:
723  --------------------------------------------------------------------*/
724 
725 String SwFormulaField::GetFormula() const
726 {
727 	return sFormula;
728 }
729 
730 /*--------------------------------------------------------------------
731 	Beschreibung:
732  --------------------------------------------------------------------*/
733 
734 void SwFormulaField::SetFormula(const String& rStr)
735 {
736 	sFormula = rStr;
737 
738 	sal_uLong nFmt(GetFormat());
739 
740 	if( nFmt && SAL_MAX_UINT32 != nFmt )
741 	{
742 		xub_StrLen nPos = 0;
743 		double fTmpValue;
744 		if( SwCalc::Str2Double( rStr, nPos, fTmpValue, GetDoc() ) )
745 			SwValueField::SetValue( fTmpValue );
746 	}
747 }
748 
749 /*--------------------------------------------------------------------
750 	Beschreibung:
751  --------------------------------------------------------------------*/
752 
753 void SwFormulaField::SetExpandedFormula( const String& rStr )
754 {
755 	sal_uInt32 nFmt(GetFormat());
756 
757 	if (nFmt && nFmt != SAL_MAX_UINT32 && ((SwValueFieldType *)GetTyp())->UseFormat())
758 	{
759 		double fTmpValue;
760 
761 		SvNumberFormatter* pFormatter = GetDoc()->GetNumberFormatter();
762 
763 		if (pFormatter->IsNumberFormat(rStr, nFmt, fTmpValue))
764 		{
765 			SwValueField::SetValue(fTmpValue);
766 			sFormula.Erase();
767 
768 			((SwValueFieldType *)GetTyp())->DoubleToString(sFormula, fTmpValue, nFmt);
769 			return;
770 		}
771 	}
772 	sFormula = rStr;
773 }
774 
775 /*--------------------------------------------------------------------
776 	Beschreibung:
777  --------------------------------------------------------------------*/
778 
779 String SwFormulaField::GetExpandedFormula() const
780 {
781 	sal_uInt32 nFmt(GetFormat());
782 
783 	if (nFmt && nFmt != SAL_MAX_UINT32 && ((SwValueFieldType *)GetTyp())->UseFormat())
784 	{
785 		String sFormattedValue;
786 		Color* pCol = 0;
787 
788 		SvNumberFormatter* pFormatter = GetDoc()->GetNumberFormatter();
789 
790 		if (pFormatter->IsTextFormat(nFmt))
791 		{
792 			String sValue;
793 			((SwValueFieldType *)GetTyp())->DoubleToString(sValue, GetValue(), nFmt);
794 			pFormatter->GetOutputString(sValue, nFmt, sFormattedValue, &pCol);
795 		}
796 		else
797 			pFormatter->GetOutputString(GetValue(), nFmt, sFormattedValue, &pCol);
798 
799 		return sFormattedValue;
800 	}
801 	else
802 		return GetFormula();
803 }
804 
805 String SwField::GetDescription() const
806 {
807     return SW_RES(STR_FIELD);
808 }
809