xref: /aoo41x/main/sw/source/core/fields/expfld.cxx (revision 1bf9188d)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26 
27 #include <hintids.hxx>
28 #include <unotools/collatorwrapper.hxx>
29 #include <unotools/charclass.hxx>
30 #include <editeng/unolingu.hxx>
31 #include <svx/pageitem.hxx>
32 #include <editeng/langitem.hxx>
33 #include <editeng/fontitem.hxx>
34 #include <com/sun/star/text/SetVariableType.hpp>
35 #include <unofield.hxx>
36 #include <frmfmt.hxx>
37 #include <fmtfld.hxx>
38 #include <txtfld.hxx>
39 #include <fmtanchr.hxx>
40 #include <txtftn.hxx>
41 #include <doc.hxx>
42 #include <layfrm.hxx>
43 #include <pagefrm.hxx>
44 #include <cntfrm.hxx>
45 #include <rootfrm.hxx>
46 #include <tabfrm.hxx>
47 #include <flyfrm.hxx>
48 #include <ftnfrm.hxx>
49 #include <rowfrm.hxx>
50 #include <expfld.hxx>
51 #include <usrfld.hxx>
52 #include <ndtxt.hxx>
53 #include <calc.hxx>
54 #include <pam.hxx>
55 #include <docfld.hxx>
56 #include <swcache.hxx>
57 #include <swtable.hxx>
58 #include <breakit.hxx>
59 #include <SwStyleNameMapper.hxx>
60 #include <unofldmid.h>
61 #include <numrule.hxx>
62 #include <switerator.hxx>
63 
64 using namespace ::com::sun::star;
65 using namespace ::com::sun::star::text;
66 using ::rtl::OUString;
67 
SV_IMPL_PTRARR(_SwSeqFldList,_SeqFldLstElem *)68 SV_IMPL_PTRARR( _SwSeqFldList, _SeqFldLstElem* )
69 
70 //-----------------------------------------------------------------------------
71 sal_Int16 lcl_SubTypeToAPI(sal_uInt16 nSubType)
72 {
73 		sal_Int16 nRet = 0;
74 		switch(nSubType)
75 		{
76 			case nsSwGetSetExpType::GSE_EXPR:
77                 nRet = SetVariableType::VAR;      // 0
78                 break;
79 			case nsSwGetSetExpType::GSE_SEQ:
80                 nRet = SetVariableType::SEQUENCE; // 1
81                 break;
82 			case nsSwGetSetExpType::GSE_FORMULA:
83                 nRet = SetVariableType::FORMULA;  // 2
84                 break;
85 			case nsSwGetSetExpType::GSE_STRING:
86                 nRet = SetVariableType::STRING;   // 3
87                 break;
88 		}
89 		return nRet;
90 }
91 //-----------------------------------------------------------------------------
lcl_APIToSubType(const uno::Any & rAny)92 sal_Int32 lcl_APIToSubType(const uno::Any& rAny)
93 {
94 		sal_Int16 nVal = 0;
95 		rAny >>= nVal;
96 		sal_Int32 nSet = 0;
97 		switch(nVal)
98 		{
99 			case SetVariableType::VAR:		nSet = nsSwGetSetExpType::GSE_EXPR;  break;
100 			case SetVariableType::SEQUENCE: nSet = nsSwGetSetExpType::GSE_SEQ;  break;
101 			case SetVariableType::FORMULA:  nSet = nsSwGetSetExpType::GSE_FORMULA; break;
102 			case SetVariableType::STRING:	nSet = nsSwGetSetExpType::GSE_STRING;	break;
103 			default:
104 				DBG_ERROR("wrong value");
105 				nSet = -1;
106 		}
107 		return nSet;
108 }
109 
110 //-----------------------------------------------------------------------------
111 
ReplacePoint(String & rTmpName,sal_Bool bWithCommandType)112 void ReplacePoint( String& rTmpName, sal_Bool bWithCommandType )
113 {
114     // replace first and last (if bWithCommandType: last two) dot Ersten und letzten Punkt ersetzen, da in Tabellennamen Punkte erlaubt sind
115     // since table names may contain dots
116 
117 	xub_StrLen nLen = rTmpName.Len();
118 	sal_Unicode *pStr = rTmpName.GetBufferAccess(), *pBackStr = pStr + nLen;
119 
120     long nBackCount = bWithCommandType ? 2 : 1;
121     xub_StrLen i;
122 
123     for( i = nLen; i; --i, pBackStr-- )
124 		if( '.' == *pBackStr )
125 		{
126 			*pBackStr = DB_DELIM;
127             if(!--nBackCount)
128                 break;
129 		}
130 	for( i = 0; i < nLen; ++i, ++pStr )
131 		if( '.' == *pStr )
132 		{
133 			*pStr = DB_DELIM;
134 			break;
135 		}
136 }
137 
GetFirstTxtNode(const SwDoc & rDoc,SwPosition & rPos,const SwCntntFrm * pCFrm,Point & rPt)138 SwTxtNode* GetFirstTxtNode( const SwDoc& rDoc, SwPosition& rPos,
139 							const SwCntntFrm *pCFrm, Point &rPt )
140 {
141 	SwTxtNode* pTxtNode = 0;
142 	if ( !pCFrm )
143 	{
144         const SwNodes& rNodes = rDoc.GetNodes();
145         rPos.nNode = *rNodes.GetEndOfContent().StartOfSectionNode();
146 		SwCntntNode* pCNd;
147         while( 0 != (pCNd = rNodes.GoNext( &rPos.nNode ) ) &&
148 				0 == ( pTxtNode = pCNd->GetTxtNode() ) )
149 						;
150 		ASSERT( pTxtNode, "wo ist der 1.TextNode" );
151 		rPos.nContent.Assign( pTxtNode, 0 );
152 	}
153 	else if ( !pCFrm->IsValid() )
154 	{
155 		pTxtNode = (SwTxtNode*)pCFrm->GetNode();
156 		rPos.nNode = *pTxtNode;
157 		rPos.nContent.Assign( pTxtNode, 0 );
158 	}
159 	else
160 	{
161 		pCFrm->GetCrsrOfst( &rPos, rPt );
162 		pTxtNode = rPos.nNode.GetNode().GetTxtNode();
163 	}
164 	return pTxtNode;
165 }
166 
GetBodyTxtNode(const SwDoc & rDoc,SwPosition & rPos,const SwFrm & rFrm)167 const SwTxtNode* GetBodyTxtNode( const SwDoc& rDoc, SwPosition& rPos,
168 								const SwFrm& rFrm )
169 {
170 	const SwLayoutFrm* pLayout = (SwLayoutFrm*)rFrm.GetUpper();
171 	const SwTxtNode* pTxtNode = 0;
172 
173 	while( pLayout )
174 	{
175 		if( pLayout->IsFlyFrm() )
176 		{
177 			// hole das FlyFormat
178 			SwFrmFmt* pFlyFmt = ((SwFlyFrm*)pLayout)->GetFmt();
179 			ASSERT( pFlyFmt, "kein FlyFormat gefunden, wo steht das Feld" );
180 
181 			const SwFmtAnchor &rAnchor = pFlyFmt->GetAnchor();
182 
183 			if( FLY_AT_FLY == rAnchor.GetAnchorId() )
184 			{
185 				// und der Fly muss irgendwo angehaengt sein, also
186 				// den befragen
187                 pLayout = (SwLayoutFrm*)((SwFlyFrm*)pLayout)->GetAnchorFrm();
188 				continue;
189 			}
190             else if ((FLY_AT_PARA == rAnchor.GetAnchorId()) ||
191                      (FLY_AT_CHAR == rAnchor.GetAnchorId()) ||
192                      (FLY_AS_CHAR == rAnchor.GetAnchorId()))
193 			{
194 				ASSERT( rAnchor.GetCntntAnchor(), "keine gueltige Position" );
195 				rPos = *rAnchor.GetCntntAnchor();
196 				pTxtNode = rPos.nNode.GetNode().GetTxtNode();
197                 if ( FLY_AT_PARA == rAnchor.GetAnchorId() )
198                 {
199                     const_cast<SwTxtNode*>(pTxtNode)->MakeStartIndex(
200                             &rPos.nContent );
201 // oder doch besser das Ende vom (Anker-)TextNode nehmen ??
202 //					((SwTxtNode*)pTxtNode)->MakeEndIndex( &rPos.nContent );
203                 }
204 
205 				// noch nicht abbrechen, kann ja auch noch im
206 				// Header/Footer/Footnote/Fly stehen !!
207                 pLayout = ((SwFlyFrm*)pLayout)->GetAnchorFrm()
208                             ? ((SwFlyFrm*)pLayout)->GetAnchorFrm()->GetUpper() : 0;
209 				continue;
210 			}
211 			else
212 			{
213 				pLayout->FindPageFrm()->GetCntntPosition(
214 												pLayout->Frm().Pos(), rPos );
215 				pTxtNode = rPos.nNode.GetNode().GetTxtNode();
216 			}
217 		}
218 		else if( pLayout->IsFtnFrm() )
219 		{
220 			// hole den Node vom Anker
221 			const SwTxtFtn* pFtn = ((SwFtnFrm*)pLayout)->GetAttr();
222 			pTxtNode = &pFtn->GetTxtNode();
223 			rPos.nNode = *pTxtNode;
224 			rPos.nContent = *pFtn->GetStart();
225 		}
226 		else if( pLayout->IsHeaderFrm() || pLayout->IsFooterFrm() )
227 		{
228 			const SwCntntFrm* pCntFrm;
229 			const SwPageFrm* pPgFrm = pLayout->FindPageFrm();
230 			if( pLayout->IsHeaderFrm() )
231 			{
232 				const SwTabFrm *pTab;
233 				if( 0 != ( pCntFrm = pPgFrm->FindFirstBodyCntnt()) &&
234 					0 != (pTab = pCntFrm->FindTabFrm()) && pTab->IsFollow() &&
235                     pTab->GetTable()->GetRowsToRepeat() > 0 &&
236                     pTab->IsInHeadline( *pCntFrm ) )
237                 {
238 					// take the next line
239                     const SwLayoutFrm* pRow = pTab->GetFirstNonHeadlineRow();
240                     pCntFrm = pRow->ContainsCntnt();
241 				}
242 			}
243 			else
244 				pCntFrm = pPgFrm->FindLastBodyCntnt();
245 
246 			if( pCntFrm )
247 			{
248 				pTxtNode = pCntFrm->GetNode()->GetTxtNode();
249 				rPos.nNode = *pTxtNode;
250 				((SwTxtNode*)pTxtNode)->MakeEndIndex( &rPos.nContent );
251 			}
252 			else
253 			{
254 				Point aPt( pLayout->Frm().Pos() );
255 				aPt.Y()++;		// aus dem Header raus
256 				pCntFrm = pPgFrm->GetCntntPos( aPt, sal_False, sal_True, sal_False );
257 				pTxtNode = GetFirstTxtNode( rDoc, rPos, pCntFrm, aPt );
258 			}
259 		}
260 		else
261 		{
262 			pLayout = pLayout->GetUpper();
263 			continue;
264 		}
265 		break;		// gefunden und beende die Schleife
266 	}
267 	return pTxtNode;
268 }
269 
270 /*--------------------------------------------------------------------
271 	Beschreibung: SwSetExpFieldType by JP
272  --------------------------------------------------------------------*/
273 
SwGetExpFieldType(SwDoc * pDc)274 SwGetExpFieldType::SwGetExpFieldType(SwDoc* pDc)
275 	: SwValueFieldType( pDc, RES_GETEXPFLD )
276 {
277 }
278 
Copy() const279 SwFieldType* SwGetExpFieldType::Copy() const
280 {
281 	return new SwGetExpFieldType(GetDoc());
282 }
283 
Modify(const SfxPoolItem *,const SfxPoolItem * pNew)284 void SwGetExpFieldType::Modify( const SfxPoolItem*, const SfxPoolItem* pNew )
285 {
286 	if( pNew && RES_DOCPOS_UPDATE == pNew->Which() )
287 		NotifyClients( 0, pNew );
288 	// sonst nichts weiter expandieren
289 }
290 
291 /*--------------------------------------------------------------------
292 	Beschreibung: SwGetExpField by JP
293  --------------------------------------------------------------------*/
294 
SwGetExpField(SwGetExpFieldType * pTyp,const String & rFormel,sal_uInt16 nSub,sal_uLong nFmt)295 SwGetExpField::SwGetExpField(SwGetExpFieldType* pTyp, const String& rFormel,
296 							sal_uInt16 nSub, sal_uLong nFmt)
297 	: SwFormulaField( pTyp, nFmt, 0.0 ),
298 	bIsInBodyTxt( sal_True ),
299     nSubType(nSub),
300 	bLateInitialization( false )
301 {
302 	SetFormula( rFormel );
303 }
304 
Expand() const305 String SwGetExpField::Expand() const
306 {
307 	if(nSubType & nsSwExtendedSubType::SUB_CMD)
308 		return GetFormula();
309 	else
310 		return sExpand;
311 }
312 
GetFieldName() const313 String SwGetExpField::GetFieldName() const
314 {
315     String aStr( SwFieldType::GetTypeStr(
316         static_cast<sal_uInt16>(((nsSwGetSetExpType::GSE_FORMULA & nSubType) != 0)
317                                             ? TYP_FORMELFLD
318                                             : TYP_GETFLD ) ));
319     aStr += ' ';
320     aStr += GetFormula();
321     return aStr;
322 }
323 
Copy() const324 SwField* SwGetExpField::Copy() const
325 {
326 	SwGetExpField *pTmp = new SwGetExpField((SwGetExpFieldType*)GetTyp(),
327 											GetFormula(), nSubType, GetFormat());
328 	pTmp->SetLanguage(GetLanguage());
329 	pTmp->SwValueField::SetValue(GetValue());
330 	pTmp->sExpand 		= sExpand;
331 	pTmp->bIsInBodyTxt 	= bIsInBodyTxt;
332     pTmp->SetAutomaticLanguage(IsAutomaticLanguage());
333 	if( bLateInitialization )
334 		pTmp->SetLateInitialization();
335 
336 	return pTmp;
337 }
338 
ChangeExpansion(const SwFrm & rFrm,const SwTxtFld & rFld)339 void SwGetExpField::ChangeExpansion( const SwFrm& rFrm, const SwTxtFld& rFld )
340 {
341 	if( bIsInBodyTxt )		// nur Felder in Footer, Header, FootNote, Flys
342 		return;
343 
344 	ASSERT( !rFrm.IsInDocBody(), "Flag ist nicht richtig, Frame steht im DocBody" );
345 
346 	// bestimme mal das Dokument (oder geht es noch einfacher?)
347 	const SwTxtNode* pTxtNode = &rFld.GetTxtNode();
348 	SwDoc& rDoc = *(SwDoc*)pTxtNode->GetDoc();
349 
350 	// einen Index fuers bestimmen vom TextNode anlegen
351 	SwPosition aPos( SwNodeIndex( rDoc.GetNodes() ) );
352 	pTxtNode = GetBodyTxtNode( rDoc, aPos, rFrm );
353 
354 	// Wenn kein Layout vorhanden, kommt es in Kopf und Fusszeilen dazu
355 	// das ChnageExpansion uebers Layout-Formatieren aufgerufen wird
356 	// aber kein TxtNode vorhanden ist
357 	//
358 	if(!pTxtNode)
359 		return;
360 	// #i82544#
361     if( bLateInitialization )
362 	{
363 		SwFieldType* pSetExpFld = rDoc.GetFldType(RES_SETEXPFLD, GetFormula(), sal_False);
364 		if( pSetExpFld )
365 		{
366 			bLateInitialization = false;
367 			if( !(GetSubType() & nsSwGetSetExpType::GSE_STRING) &&
368 				static_cast< SwSetExpFieldType* >(pSetExpFld)->GetType() == nsSwGetSetExpType::GSE_STRING )
369 			SetSubType( nsSwGetSetExpType::GSE_STRING );
370 		}
371 	}
372 
373 	_SetGetExpFld aEndFld( aPos.nNode, &rFld, &aPos.nContent );
374 	if(GetSubType() & nsSwGetSetExpType::GSE_STRING)
375 	{
376 		SwHash** ppHashTbl;
377 		sal_uInt16 nSize;
378 		rDoc.FldsToExpand( ppHashTbl, nSize, aEndFld );
379 		LookString( ppHashTbl, nSize, GetFormula(), sExpand );
380 		::DeleteHashTable( ppHashTbl, nSize );		// HashTabelle loeschen
381 	}
382 	else
383 	{
384 		// fuelle den Calculator mit den Werten
385 		SwCalc aCalc( rDoc );
386 		rDoc.FldsToCalc(aCalc, aEndFld);
387 
388 		// Wert berechnen
389 		SetValue(aCalc.Calculate(GetFormula()).GetDouble());
390 
391 		// Auswertung nach Format
392 		sExpand = ((SwValueFieldType*)GetTyp())->ExpandValue(
393 								GetValue(), GetFormat(), GetLanguage());
394 	}
395 }
396 
GetPar2() const397 String SwGetExpField::GetPar2() const
398 {
399 	return GetFormula();
400 }
401 
SetPar2(const String & rStr)402 void SwGetExpField::SetPar2(const String& rStr)
403 {
404 	SetFormula(rStr);
405 }
406 
GetSubType() const407 sal_uInt16 SwGetExpField::GetSubType() const
408 {
409 	return nSubType;
410 }
411 
SetSubType(sal_uInt16 nType)412 void SwGetExpField::SetSubType(sal_uInt16 nType)
413 {
414 	nSubType = nType;
415 }
416 
SetLanguage(sal_uInt16 nLng)417 void SwGetExpField::SetLanguage(sal_uInt16 nLng)
418 {
419 	if (nSubType & nsSwExtendedSubType::SUB_CMD)
420 		SwField::SetLanguage(nLng);
421 	else
422 		SwValueField::SetLanguage(nLng);
423 }
424 
QueryValue(uno::Any & rAny,sal_uInt16 nWhichId) const425 sal_Bool SwGetExpField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
426 {
427     switch( nWhichId )
428 	{
429 	case FIELD_PROP_DOUBLE:
430 		rAny <<= GetValue();
431 		break;
432 	case FIELD_PROP_FORMAT:
433 		rAny <<= (sal_Int32)GetFormat();
434 		break;
435 	case FIELD_PROP_USHORT1:
436 		 rAny <<= (sal_Int16)nSubType;
437 		break;
438 	case FIELD_PROP_PAR1:
439 	 	rAny <<= OUString( GetFormula() );
440 		break;
441 	case FIELD_PROP_SUBTYPE:
442 		{
443 			sal_Int16 nRet = lcl_SubTypeToAPI(GetSubType() & 0xff);
444 			rAny <<= nRet;
445 		}
446 		break;
447 	case FIELD_PROP_BOOL2:
448 		{
449 			sal_Bool bTmp = 0 != (nSubType & nsSwExtendedSubType::SUB_CMD);
450 			rAny.setValue(&bTmp, ::getBooleanCppuType());
451 		}
452 		break;
453 	case FIELD_PROP_PAR4:
454 		rAny <<= rtl::OUString(GetExpStr());
455 		break;
456 	default:
457         return SwField::QueryValue(rAny, nWhichId);
458     }
459 	return sal_True;
460 }
461 
PutValue(const uno::Any & rAny,sal_uInt16 nWhichId)462 sal_Bool SwGetExpField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
463 {
464 	sal_Int32 nTmp = 0;
465 	String sTmp;
466     switch( nWhichId )
467 	{
468 	case FIELD_PROP_DOUBLE:
469 		SwValueField::SetValue(*(double*) rAny.getValue());
470 		break;
471 	case FIELD_PROP_FORMAT:
472 		rAny >>= nTmp;
473 		SetFormat(nTmp);
474 		break;
475 	case FIELD_PROP_USHORT1:
476 		 rAny >>= nTmp;
477 		 nSubType = static_cast<sal_uInt16>(nTmp);
478 		break;
479 	case FIELD_PROP_PAR1:
480 	 	SetFormula( ::GetString( rAny, sTmp ));
481 		break;
482 	case FIELD_PROP_SUBTYPE:
483 		nTmp = lcl_APIToSubType(rAny);
484 		if( nTmp >=0 )
485 			SetSubType( static_cast<sal_uInt16>((GetSubType() & 0xff00) | nTmp));
486 		break;
487 	case FIELD_PROP_BOOL2:
488 		if(*(sal_Bool*) rAny.getValue())
489 			nSubType |= nsSwExtendedSubType::SUB_CMD;
490 		else
491 			nSubType &= (~nsSwExtendedSubType::SUB_CMD);
492 		break;
493 	case FIELD_PROP_PAR4:
494 		ChgExpStr(::GetString( rAny, sTmp ));
495 		break;
496 	default:
497         return SwField::PutValue(rAny, nWhichId);
498     }
499 	return sal_True;
500 }
501 
SwSetExpFieldType(SwDoc * pDc,const String & rName,sal_uInt16 nTyp)502 SwSetExpFieldType::SwSetExpFieldType( SwDoc* pDc, const String& rName, sal_uInt16 nTyp )
503 	: SwValueFieldType( pDc, RES_SETEXPFLD ),
504 	sName( rName ),
505 	pOutlChgNd( 0 ),
506 	sDelim( String::CreateFromAscii( "." ) ),
507 	nType(nTyp), nLevel( UCHAR_MAX ),
508 	bDeleted( sal_False )
509 {
510 	if( ( nsSwGetSetExpType::GSE_SEQ | nsSwGetSetExpType::GSE_STRING ) & nType )
511 		EnableFormat(sal_False);	// Numberformatter nicht einsetzen
512 }
513 
Copy() const514 SwFieldType* SwSetExpFieldType::Copy() const
515 {
516 	SwSetExpFieldType* pNew = new SwSetExpFieldType(GetDoc(), sName, nType);
517 	pNew->bDeleted = bDeleted;
518 	pNew->sDelim = sDelim;
519 	pNew->nLevel = nLevel;
520 
521 	return pNew;
522 }
523 
GetName() const524 const String& SwSetExpFieldType::GetName() const
525 {
526 	return sName;
527 }
528 
Modify(const SfxPoolItem *,const SfxPoolItem *)529 void SwSetExpFieldType::Modify( const SfxPoolItem*, const SfxPoolItem* )
530 {
531 	return;		// nicht weiter expandieren
532 }
533 
SetSeqFormat(sal_uLong nFmt)534 void SwSetExpFieldType::SetSeqFormat(sal_uLong nFmt)
535 {
536 	SwIterator<SwFmtFld,SwFieldType> aIter(*this);
537 	for( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() )
538 		pFmtFld->GetField()->ChangeFormat( nFmt );
539 }
540 
GetSeqFormat()541 sal_uLong SwSetExpFieldType::GetSeqFormat()
542 {
543 	if( !GetDepends() )
544 		return SVX_NUM_ARABIC;
545 
546 	SwField *pFld = ((SwFmtFld*)GetDepends())->GetField();
547 	return pFld->GetFormat();
548 }
549 
SetSeqRefNo(SwSetExpField & rFld)550 sal_uInt16 SwSetExpFieldType::SetSeqRefNo( SwSetExpField& rFld )
551 {
552 	if( !GetDepends() || !(nsSwGetSetExpType::GSE_SEQ & nType) )
553 		return USHRT_MAX;
554 
555 extern void InsertSort( SvUShorts& rArr, sal_uInt16 nIdx, sal_uInt16* pInsPos = 0 );
556 	SvUShorts aArr( 64 );
557 
558 	sal_uInt16 n;
559 
560 	// dann testmal, ob die Nummer schon vergeben ist oder ob eine neue
561 	// bestimmt werden muss.
562 	SwIterator<SwFmtFld,SwFieldType> aIter( *this );
563 	const SwTxtNode* pNd;
564 	for( SwFmtFld* pF = aIter.First(); pF; pF = aIter.Next() )
565 		if( pF->GetField() != &rFld && pF->GetTxtFld() &&
566 			0 != ( pNd = pF->GetTxtFld()->GetpTxtNode() ) &&
567 			pNd->GetNodes().IsDocNodes() )
568 			InsertSort( aArr, ((SwSetExpField*)pF->GetField())->GetSeqNumber() );
569 
570 
571 	// teste erstmal ob die Nummer schon vorhanden ist:
572 	sal_uInt16 nNum = rFld.GetSeqNumber();
573 	if( USHRT_MAX != nNum )
574 	{
575 		for( n = 0; n < aArr.Count(); ++n )
576 			if( aArr[ n ] > nNum )
577 				return nNum;			// nicht vorhanden -> also benutzen
578 			else if( aArr[ n ] == nNum )
579 				break;					// schon vorhanden -> neue erzeugen
580 
581 		if( n == aArr.Count() )
582 			return nNum;			// nicht vorhanden -> also benutzen
583 	}
584 
585 	// alle Nummern entsprechend geflag, also bestimme die richtige Nummer
586 	for( n = 0; n < aArr.Count(); ++n )
587 		if( n != aArr[ n ] )
588 			break;
589 
590 	rFld.SetSeqNumber( n );
591 	return n;
592 }
593 
GetSeqFldList(SwSeqFldList & rList)594 sal_uInt16 SwSetExpFieldType::GetSeqFldList( SwSeqFldList& rList )
595 {
596 	if( rList.Count() )
597 		rList.Remove( 0, rList.Count() );
598 
599 	SwIterator<SwFmtFld,SwFieldType> aIter( *this );
600 	const SwTxtNode* pNd;
601 	for( SwFmtFld* pF = aIter.First(); pF; pF = aIter.Next() )
602 		if( pF->GetTxtFld() &&
603 			0 != ( pNd = pF->GetTxtFld()->GetpTxtNode() ) &&
604 			pNd->GetNodes().IsDocNodes() )
605 		{
606             _SeqFldLstElem* pNew = new _SeqFldLstElem(
607                     pNd->GetExpandTxt( 0, (*pF->GetTxtFld()->GetStart()) + 1 ),
608                     ((SwSetExpField*)pF->GetField())->GetSeqNumber() );
609 			rList.InsertSort( pNew );
610 		}
611 
612 	return rList.Count();
613 }
614 
615 
SetChapter(SwSetExpField & rFld,const SwNode & rNd)616 void SwSetExpFieldType::SetChapter( SwSetExpField& rFld, const SwNode& rNd )
617 {
618 	const SwTxtNode* pTxtNd = rNd.FindOutlineNodeOfLevel( nLevel );
619 	if( pTxtNd )
620 	{
621         SwNumRule * pRule = pTxtNd->GetNumRule();
622 
623         if (pRule)
624         {
625             // --> OD 2005-11-02 #i51089 - TUNING#
626             if ( pTxtNd->GetNum() )
627             {
628                 const SwNodeNum & aNum = *(pTxtNd->GetNum());
629 
630                 // nur die Nummer besorgen, ohne Pre-/Post-fixstrings
631                 String sNumber( pRule->MakeNumString(aNum, sal_False ));
632 
633                 if( sNumber.Len() )
634                     rFld.ChgExpStr(  ( sNumber += sDelim ) += rFld.GetExpStr() );
635             }
636             else
637             {
638                 ASSERT( false,
639                         "<SwSetExpFieldType::SetChapter(..)> - text node with numbering rule, but without number. This is a serious defect -> inform OD" );
640             }
641         }
642 	}
643 }
644 
QueryValue(uno::Any & rAny,sal_uInt16 nWhichId) const645 sal_Bool SwSetExpFieldType::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
646 {
647     switch( nWhichId )
648 	{
649 	case FIELD_PROP_SUBTYPE:
650 		{
651 			sal_Int16 nRet = lcl_SubTypeToAPI(GetType());
652 			rAny <<= nRet;
653 		}
654 		break;
655 	case FIELD_PROP_PAR2:
656 		rAny <<= OUString(GetDelimiter());
657 		break;
658 	case FIELD_PROP_SHORT1:
659 		{
660 			sal_Int8 nRet = nLevel < MAXLEVEL? nLevel : -1;
661 			rAny <<= nRet;
662 		}
663 		break;
664 	default:
665 		DBG_ERROR("illegal property");
666 	}
667 	return sal_True;
668 }
669 
PutValue(const uno::Any & rAny,sal_uInt16 nWhichId)670 sal_Bool SwSetExpFieldType::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
671 {
672     switch( nWhichId )
673 	{
674 	case FIELD_PROP_SUBTYPE:
675 		{
676 			sal_Int32 nSet = lcl_APIToSubType(rAny);
677 			if(nSet >=0)
678 				SetType(static_cast<sal_uInt16>(nSet));
679 		}
680 		break;
681 	case FIELD_PROP_PAR2:
682 		{
683 			String sTmp;
684 			if( ::GetString( rAny, sTmp ).Len() )
685 //				SetDelimiter( sTmp.GetChar( 0 ));
686 				SetDelimiter( sTmp );
687 			else
688 				SetDelimiter(String::CreateFromAscii( " "));
689 		}
690 		break;
691 	case FIELD_PROP_SHORT1:
692 		{
693 			sal_Int8 nLvl = 0;
694 			rAny >>= nLvl;
695 			if(nLvl < 0 || nLvl >= MAXLEVEL)
696 				SetOutlineLvl(UCHAR_MAX);
697 			else
698 				SetOutlineLvl(nLvl);
699 		}
700 		break;
701 	default:
702 		DBG_ERROR("illegal property");
703 	}
704 	return sal_True;
705 }
706 
InsertSort(_SeqFldLstElem * pNew)707 sal_Bool SwSeqFldList::InsertSort( _SeqFldLstElem* pNew )
708 {
709 	sal_Unicode* p = pNew->sDlgEntry.GetBufferAccess();
710 	while( *p )
711 	{
712 		if( *p < 0x20 )
713 			*p = 0x20;
714 		++p;
715 	}
716 
717 	sal_uInt16 nPos;
718 	sal_Bool bRet = SeekEntry( *pNew, &nPos );
719 	if( !bRet )
720 		C40_INSERT( _SeqFldLstElem, pNew, nPos );
721 	return bRet;
722 }
723 
SeekEntry(const _SeqFldLstElem & rNew,sal_uInt16 * pP)724 sal_Bool SwSeqFldList::SeekEntry( const _SeqFldLstElem& rNew, sal_uInt16* pP )
725 {
726 	sal_uInt16 nO = Count(), nM, nU = 0;
727 	if( nO > 0 )
728 	{
729 		CollatorWrapper & rCaseColl = ::GetAppCaseCollator(),
730 						& rColl = ::GetAppCollator();
731 		const CharClass& rCC = GetAppCharClass();
732 
733 		//#59900# Die Sortierung soll die Nummer korrekt einordnen
734 		//also "10" nach "9" und nicht "10" nach "1"
735 		const String& rTmp2 = rNew.sDlgEntry;
736 		xub_StrLen nFndPos2 = 0;
737 		String sNum2( rTmp2.GetToken( 0, ' ', nFndPos2 ));
738 		sal_Bool bIsNum2IsNumeric = rCC.isAsciiNumeric( sNum2 );
739 		sal_Int32 nNum2 = bIsNum2IsNumeric ? sNum2.ToInt32() : 0;
740 
741 		nO--;
742 		while( nU <= nO )
743 		{
744 			nM = nU + ( nO - nU ) / 2;
745 
746 			//#59900# Die Sortierung soll die Nummer korrekt einordnen
747 			//also "10" nach "9" und nicht "10" nach "1"
748 			const String& rTmp1 = (*((_SeqFldLstElem**)pData + nM))->sDlgEntry;
749 			xub_StrLen nFndPos1 = 0;
750 			String sNum1( rTmp1.GetToken( 0, ' ', nFndPos1 ));
751 			sal_Int32 nCmp;
752 
753 			if( bIsNum2IsNumeric && rCC.isNumeric( sNum1 ) )
754 			{
755 				sal_Int32 nNum1 = sNum1.ToInt32();
756 				nCmp = nNum2 - nNum1;
757 				if( 0 == nCmp )
758 					nCmp = rCaseColl.compareString( rTmp2.Copy( nFndPos2 ),
759 										 			  rTmp1.Copy( nFndPos1 ));
760 			}
761 			else
762 				nCmp = rColl.compareString( rTmp2, rTmp1 );
763 
764 			if( 0 == nCmp )
765 			{
766 				if( pP ) *pP = nM;
767 				return sal_True;
768 			}
769 			else if( 0 < nCmp )
770 				nU = nM + 1;
771 			else if( nM == 0 )
772 				break;
773 			else
774 				nO = nM - 1;
775 		}
776 	}
777 	if( pP ) *pP = nU;
778 	return sal_False;
779 }
780 
781 /*--------------------------------------------------------------------
782 	Beschreibung: SwSetExpField by JP
783  --------------------------------------------------------------------*/
784 
SwSetExpField(SwSetExpFieldType * pTyp,const String & rFormel,sal_uLong nFmt)785 SwSetExpField::SwSetExpField(SwSetExpFieldType* pTyp, const String& rFormel,
786 										sal_uLong nFmt)
787 	: SwFormulaField( pTyp, nFmt, 0.0 ), nSeqNo( USHRT_MAX ),
788 	nSubType(0)
789 {
790 	SetFormula(rFormel);
791 	// SubType ignorieren !!!
792 	bInput = sal_False;
793 	if( IsSequenceFld() )
794 	{
795 		SwValueField::SetValue(1.0);
796 		if( !rFormel.Len() )
797 		{
798 			String sFormel(rFormel);
799 			sFormel += pTyp->GetName();
800 			sFormel += '+';
801 			sFormel += '1';
802 			SetFormula(sFormel);
803 		}
804 	}
805 }
806 
Expand() const807 String SwSetExpField::Expand() const
808 {
809 	String aStr;
810 	if (nSubType & nsSwExtendedSubType::SUB_CMD)
811 	{	// Der CommandString ist gefragt
812 		aStr = GetTyp()->GetName();
813 		aStr.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " = " ));
814 		aStr += GetFormula();
815 	}
816 	else if(!(nSubType & nsSwExtendedSubType::SUB_INVISIBLE))
817 	{   // Der Wert ist sichtbar
818 		aStr = sExpand;
819 	}
820 	return aStr;
821 }
822 
823 /*--------------------------------------------------------------------
824 	@return the field name
825  --------------------------------------------------------------------*/
826 
GetFieldName() const827 String SwSetExpField::GetFieldName() const
828 {
829     SwFldTypesEnum const nStrType( (IsSequenceFld())
830                             ? TYP_SEQFLD
831                             : (bInput)
832                                 ? TYP_SETINPFLD
833                                 : TYP_SETFLD   );
834 
835     String aStr( SwFieldType::GetTypeStr( static_cast<sal_uInt16>(nStrType) ) );
836     aStr += ' ';
837     aStr += GetTyp()->GetName();
838 
839     // Sequence: without formula
840     if (TYP_SEQFLD != nStrType)
841     {
842         aStr.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " = " ) );
843         aStr += GetFormula();
844     }
845     return aStr;
846 }
847 
Copy() const848 SwField* SwSetExpField::Copy() const
849 {
850 	SwSetExpField *pTmp = new SwSetExpField((SwSetExpFieldType*)GetTyp(),
851 											GetFormula(), GetFormat());
852 	pTmp->SwValueField::SetValue(GetValue());
853 	pTmp->sExpand   	= sExpand;
854     pTmp->SetAutomaticLanguage(IsAutomaticLanguage());
855     pTmp->SetLanguage(GetLanguage());
856 	pTmp->aPText		= aPText;
857 	pTmp->bInput		= bInput;
858 	pTmp->nSeqNo		= nSeqNo;
859 	pTmp->SetSubType(GetSubType());
860 
861 	return pTmp;
862 }
863 
SetSubType(sal_uInt16 nSub)864 void SwSetExpField::SetSubType(sal_uInt16 nSub)
865 {
866 	((SwSetExpFieldType*)GetTyp())->SetType(nSub & 0xff);
867 	nSubType = nSub & 0xff00;
868 
869 	DBG_ASSERT( (nSub & 0xff) != 3, "SubType ist illegal!" );
870 }
871 
GetSubType() const872 sal_uInt16 SwSetExpField::GetSubType() const
873 {
874 	return ((SwSetExpFieldType*)GetTyp())->GetType() | nSubType;
875 }
876 
SetValue(const double & rAny)877 void SwSetExpField::SetValue( const double& rAny )
878 {
879 	SwValueField::SetValue(rAny);
880 
881 	if( IsSequenceFld() )
882 		sExpand = FormatNumber( (sal_uInt16)GetValue(), GetFormat() );
883 	else
884 		sExpand = ((SwValueFieldType*)GetTyp())->ExpandValue( rAny,
885 												GetFormat(), GetLanguage());
886 }
887 
SetValue(const double & rAny)888 void SwGetExpField::SetValue( const double& rAny )
889 {
890 	SwValueField::SetValue(rAny);
891 	sExpand = ((SwValueFieldType*)GetTyp())->ExpandValue( rAny, GetFormat(),
892 															GetLanguage());
893 }
894 /* -------------------------------------------------
895 	Description: Find the index of the reference text
896 	following the current field
897  --------------------------------------------------*/
GetReferenceTextPos(const SwFmtFld & rFmt,SwDoc & rDoc)898 xub_StrLen SwGetExpField::GetReferenceTextPos( const SwFmtFld& rFmt, SwDoc& rDoc)
899 {
900 	//
901 	const SwTxtFld* pTxtFld = rFmt.GetTxtFld();
902 	const SwTxtNode& rTxtNode = pTxtFld->GetTxtNode();
903 	//
904 	xub_StrLen nRet = *pTxtFld->GetStart() + 1;
905 	String sNodeText = rTxtNode.GetTxt();
906 	sNodeText.Erase(0, nRet);
907 	if(sNodeText.Len())
908 	{
909 		//now check if sNodeText starts with a non-alphanumeric character plus a blank
910 		sal_uInt16 nSrcpt = pBreakIt->GetRealScriptOfText( sNodeText, 0 );
911 
912 		static sal_uInt16 nIds[] =
913 		{
914 			RES_CHRATR_LANGUAGE, RES_CHRATR_LANGUAGE,
915 			RES_CHRATR_FONT, RES_CHRATR_FONT,
916 			RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CJK_LANGUAGE,
917 			RES_CHRATR_CJK_FONT, RES_CHRATR_CJK_FONT,
918 			RES_CHRATR_CTL_LANGUAGE, RES_CHRATR_CTL_LANGUAGE,
919 			RES_CHRATR_CTL_FONT, RES_CHRATR_CTL_FONT,
920 			0, 0
921 		};
922 		SwAttrSet aSet(rDoc.GetAttrPool(), nIds);
923 		rTxtNode.GetAttr(aSet, nRet, nRet+1);
924 
925 		if( RTL_TEXTENCODING_SYMBOL != ((SvxFontItem&)aSet.Get(
926 				GetWhichOfScript( RES_CHRATR_FONT, nSrcpt )) ).GetCharSet() )
927 		{
928 			LanguageType eLang = ((SvxLanguageItem&)aSet.Get(
929 				GetWhichOfScript( RES_CHRATR_LANGUAGE, nSrcpt )) ).GetLanguage();
930 			CharClass aCC( SvxCreateLocale( eLang ));
931 			sal_Unicode c0 = sNodeText.GetChar(0);
932 			sal_Bool bIsAlphaNum = aCC.isAlphaNumeric( sNodeText, 0 );
933 			if( !bIsAlphaNum ||
934 				(c0 == ' ' || c0 == '\t'))
935 			{
936 				nRet++;
937 				if( sNodeText.Len() > 1 &&
938 					(sNodeText.GetChar(1) == ' ' ||
939 					 sNodeText.GetChar(1) == '\t'))
940 					nRet++;
941 			}
942 		}
943 	}
944 	return nRet;
945 }
946 
947 
948 /*--------------------------------------------------------------------
949 	Beschreibung: Parameter setzen
950  --------------------------------------------------------------------*/
951 
GetPar1() const952 const String& SwSetExpField::GetPar1() const
953 {
954 	return ((SwSetExpFieldType*)GetTyp())->GetName();
955 }
956 
GetPar2() const957 String SwSetExpField::GetPar2() const
958 {
959 	sal_uInt16 nType = ((SwSetExpFieldType*)GetTyp())->GetType();
960 
961 	if (nType & nsSwGetSetExpType::GSE_STRING)
962 		return GetFormula();
963 	return GetExpandedFormula();
964 }
965 
SetPar2(const String & rStr)966 void SwSetExpField::SetPar2(const String& rStr)
967 {
968 	sal_uInt16 nType = ((SwSetExpFieldType*)GetTyp())->GetType();
969 
970 	if( !(nType & nsSwGetSetExpType::GSE_SEQ) || rStr.Len() )
971 	{
972 		if (nType & nsSwGetSetExpType::GSE_STRING)
973 			SetFormula(rStr);
974 		else
975 			SetExpandedFormula(rStr);
976 	}
977 }
978 
979 
PutValue(const uno::Any & rAny,sal_uInt16 nWhichId)980 sal_Bool SwSetExpField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
981 {
982 	sal_Int32 nTmp32 = 0;
983 	sal_Int16 nTmp16 = 0;
984 	String sTmp;
985     switch( nWhichId )
986 	{
987 	case FIELD_PROP_BOOL2:
988 		if(*(sal_Bool*)rAny.getValue())
989 			nSubType &= ~nsSwExtendedSubType::SUB_INVISIBLE;
990 		else
991 			nSubType |= nsSwExtendedSubType::SUB_INVISIBLE;
992 		break;
993 	case FIELD_PROP_FORMAT:
994 		rAny >>= nTmp32;
995 		SetFormat(nTmp32);
996 		break;
997 	case FIELD_PROP_USHORT2:
998 		{
999 			rAny >>= nTmp16;
1000 			if(nTmp16 <= SVX_NUMBER_NONE )
1001 				SetFormat(nTmp16);
1002 			else {
1003 				//exception(wrong_value)
1004 				;
1005             }
1006 		}
1007 		break;
1008 	case FIELD_PROP_USHORT1:
1009 		rAny >>= nTmp16;
1010 		nSeqNo = nTmp16;
1011 		break;
1012 	case FIELD_PROP_PAR1:
1013 		SetPar1( SwStyleNameMapper::GetUIName(
1014 							::GetString( rAny, sTmp ), nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL ) );
1015 		break;
1016 	case FIELD_PROP_PAR2:
1017 		{
1018 			OUString uTmp;
1019 			rAny >>= uTmp;
1020 			//I18N - if the formula contains only "TypeName+1"
1021 			//and it's one of the initially created sequence fields
1022 			//then the localized names has to be replaced by a programmatic name
1023 			OUString sMyFormula = SwXFieldMaster::LocalizeFormula(*this, uTmp, sal_False);
1024 			SetFormula( sMyFormula );
1025 		}
1026 		break;
1027 	case FIELD_PROP_DOUBLE:
1028 		{
1029 			double fVal = 0.0;
1030 			rAny >>= fVal;
1031 			SetValue(fVal);
1032 		}
1033 		break;
1034 	case FIELD_PROP_SUBTYPE:
1035 		nTmp32 = lcl_APIToSubType(rAny);
1036 		if(nTmp32 >= 0)
1037 			SetSubType(static_cast<sal_uInt16>((GetSubType() & 0xff00) | nTmp32));
1038 		break;
1039 	case FIELD_PROP_PAR3:
1040 		::GetString( rAny, aPText );
1041 		break;
1042 	case FIELD_PROP_BOOL3:
1043 		if(*(sal_Bool*) rAny.getValue())
1044 			nSubType |= nsSwExtendedSubType::SUB_CMD;
1045 		else
1046 			nSubType &= (~nsSwExtendedSubType::SUB_CMD);
1047 		break;
1048 	case FIELD_PROP_BOOL1:
1049 		SetInputFlag(*(sal_Bool*) rAny.getValue());
1050 		break;
1051 	case FIELD_PROP_PAR4:
1052 		ChgExpStr( ::GetString( rAny, sTmp ));
1053 		break;
1054 	default:
1055         return SwField::PutValue(rAny, nWhichId);
1056     }
1057 	return sal_True;
1058 }
1059 
1060 
QueryValue(uno::Any & rAny,sal_uInt16 nWhichId) const1061 sal_Bool SwSetExpField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
1062 {
1063     switch( nWhichId )
1064 	{
1065 	case FIELD_PROP_BOOL2:
1066 		{
1067 			sal_Bool bVal = 0 == (nSubType & nsSwExtendedSubType::SUB_INVISIBLE);
1068 			rAny.setValue(&bVal, ::getBooleanCppuType());
1069 		}
1070 		break;
1071 	case FIELD_PROP_FORMAT:
1072 		rAny <<= (sal_Int32)GetFormat();
1073 		break;
1074 	case FIELD_PROP_USHORT2:
1075 		rAny <<= (sal_Int16)GetFormat();
1076 		break;
1077 	case FIELD_PROP_USHORT1:
1078 		rAny <<= (sal_Int16)nSeqNo;
1079 		break;
1080 	case FIELD_PROP_PAR1:
1081 		rAny <<= OUString ( SwStyleNameMapper::GetProgName(GetPar1(), nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL ) );
1082 		break;
1083 	case FIELD_PROP_PAR2:
1084 		{
1085 			//I18N - if the formula contains only "TypeName+1"
1086 			//and it's one of the initially created sequence fields
1087 			//then the localized names has to be replaced by a programmatic name
1088 			OUString sMyFormula = SwXFieldMaster::LocalizeFormula(*this, GetFormula(), sal_True);
1089 			rAny <<= OUString( sMyFormula );
1090 		}
1091 		break;
1092 	case FIELD_PROP_DOUBLE:
1093 		rAny <<= (double)GetValue();
1094 		break;
1095 	case FIELD_PROP_SUBTYPE:
1096 		{
1097 			sal_Int16 nRet = 0;
1098 				nRet = lcl_SubTypeToAPI(GetSubType() & 0xff);
1099 			rAny <<= nRet;
1100 		}
1101 		break;
1102 	case FIELD_PROP_PAR3:
1103 		rAny <<= OUString( aPText );
1104 		break;
1105 	case FIELD_PROP_BOOL3:
1106 		{
1107 			sal_Bool bTmp = 0 != (nSubType & nsSwExtendedSubType::SUB_CMD);
1108 			rAny.setValue(&bTmp, ::getBooleanCppuType());
1109 		}
1110 		break;
1111 	case FIELD_PROP_BOOL1:
1112 		{
1113 			sal_Bool bTmp = GetInputFlag();
1114 			rAny.setValue(&bTmp, ::getBooleanCppuType());
1115 		}
1116 		break;
1117 	case FIELD_PROP_PAR4:
1118 		rAny <<= rtl::OUString(GetExpStr());
1119 		break;
1120 	default:
1121         return SwField::QueryValue(rAny, nWhichId);
1122     }
1123 	return sal_True;
1124 }
1125 
1126 
1127 
1128 /*--------------------------------------------------------------------
1129 	Beschreibung: Eingabefeld Type
1130  ---------------------------------------------------------------------*/
1131 
SwInputFieldType(SwDoc * pD)1132 SwInputFieldType::SwInputFieldType( SwDoc* pD )
1133     : SwFieldType( RES_INPUTFLD )
1134     , pDoc( pD )
1135 {
1136 }
1137 
Copy() const1138 SwFieldType* SwInputFieldType::Copy() const
1139 {
1140     SwInputFieldType* pType = new SwInputFieldType( pDoc );
1141     return pType;
1142 }
1143 
1144 /*--------------------------------------------------------------------
1145 	Beschreibung: Eingabefeld
1146  --------------------------------------------------------------------*/
1147 
SwInputField(SwInputFieldType * pFieldType,const String & rContent,const String & rPrompt,sal_uInt16 nSub,sal_uLong nFmt,bool bIsFormField)1148 SwInputField::SwInputField( SwInputFieldType* pFieldType,
1149                             const String& rContent,
1150                             const String& rPrompt,
1151                             sal_uInt16 nSub,
1152                             sal_uLong nFmt,
1153                             bool bIsFormField )
1154     : SwField( pFieldType, nFmt, LANGUAGE_SYSTEM, false )
1155     , aContent(rContent)
1156     , aPText(rPrompt)
1157     , nSubType(nSub)
1158     , mbIsFormField( bIsFormField )
1159     , mpFmtFld( NULL )
1160 {
1161 }
1162 
~SwInputField()1163 SwInputField::~SwInputField()
1164 {
1165 }
1166 
1167 
SetFmtFld(SwFmtFld & rFmtFld)1168 void SwInputField::SetFmtFld( SwFmtFld& rFmtFld )
1169 {
1170     mpFmtFld = &rFmtFld;
1171 }
1172 
GetFmtFld()1173 SwFmtFld* SwInputField::GetFmtFld()
1174 {
1175     return mpFmtFld;
1176 }
1177 
1178 
getContent() const1179 const String& SwInputField::getContent() const
1180 {
1181     return aContent;
1182 }
1183 
1184 
LockNotifyContentChange()1185 void SwInputField::LockNotifyContentChange()
1186 {
1187     if ( GetFmtFld() != NULL )
1188     {
1189         SwTxtInputFld* pTxtInputFld = dynamic_cast< SwTxtInputFld* >(GetFmtFld()->GetTxtFld());
1190         if ( pTxtInputFld != NULL )
1191         {
1192             pTxtInputFld->LockNotifyContentChange();
1193         }
1194     }
1195 }
1196 
1197 
UnlockNotifyContentChange()1198 void SwInputField::UnlockNotifyContentChange()
1199 {
1200     if ( GetFmtFld() != NULL )
1201     {
1202         SwTxtInputFld* pTxtInputFld = dynamic_cast< SwTxtInputFld* >(GetFmtFld()->GetTxtFld());
1203         if ( pTxtInputFld != NULL )
1204         {
1205             pTxtInputFld->UnlockNotifyContentChange();
1206         }
1207     }
1208 }
1209 
applyFieldContent(const String & rNewFieldContent)1210 void SwInputField::applyFieldContent( const String& rNewFieldContent )
1211 {
1212     if ( (nSubType & 0x00ff) == INP_TXT )
1213     {
1214         aContent = rNewFieldContent;
1215     }
1216     else if( (nSubType & 0x00ff) == INP_USR )
1217     {
1218         SwUserFieldType* pUserTyp = static_cast<SwUserFieldType*>(
1219             static_cast<SwInputFieldType*>(GetTyp())->GetDoc()->GetFldType( RES_USERFLD, getContent(), false ) );
1220         if( pUserTyp )
1221         {
1222             pUserTyp->SetContent( rNewFieldContent );
1223 
1224             // trigger update of the corresponding User Fields and other related Input Fields
1225             {
1226                 LockNotifyContentChange();
1227                 pUserTyp->UpdateFlds();
1228                 UnlockNotifyContentChange();
1229             }
1230         }
1231     }
1232 }
1233 
GetFieldName() const1234 String SwInputField::GetFieldName() const
1235 {
1236     String aStr(SwField::GetFieldName());
1237     if ((nSubType & 0x00ff) == INP_USR)
1238     {
1239         aStr += GetTyp()->GetName();
1240         aStr += ' ';
1241         aStr += getContent();
1242     }
1243     return aStr;
1244 }
1245 
Copy() const1246 SwField* SwInputField::Copy() const
1247 {
1248     SwInputField* pFld =
1249         new SwInputField(
1250             static_cast<SwInputFieldType*>(GetTyp()),
1251             getContent(),
1252             aPText,
1253             GetSubType(),
1254             GetFormat(),
1255             mbIsFormField );
1256 
1257     pFld->SetHelp( aHelp );
1258     pFld->SetToolTip( aToolTip );
1259 
1260     pFld->SetAutomaticLanguage(IsAutomaticLanguage());
1261     return pFld;
1262 }
1263 
Expand() const1264 String SwInputField::Expand() const
1265 {
1266     String sRet;
1267     if ( (nSubType & 0x00ff) == INP_TXT )
1268     {
1269         sRet = getContent();
1270     }
1271     else if( (nSubType & 0x00ff) == INP_USR )
1272     {
1273         SwUserFieldType* pUserTyp = static_cast<SwUserFieldType*>(
1274             static_cast<SwInputFieldType*>(GetTyp())->GetDoc()->GetFldType( RES_USERFLD, getContent(), false ) );
1275         if( pUserTyp )
1276             sRet = pUserTyp->GetContent();
1277     }
1278     return sRet;
1279 }
1280 
1281 
isFormField() const1282 bool SwInputField::isFormField() const
1283 {
1284     return mbIsFormField
1285            || aHelp.Len() > 0
1286            || aToolTip.Len() > 0;
1287 }
1288 
1289 
QueryValue(uno::Any & rAny,sal_uInt16 nWhichId) const1290 sal_Bool SwInputField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
1291 {
1292     switch( nWhichId )
1293     {
1294     case FIELD_PROP_PAR1:
1295         rAny <<= OUString( getContent() );
1296         break;
1297     case FIELD_PROP_PAR2:
1298         rAny <<= OUString( aPText );
1299         break;
1300     case FIELD_PROP_PAR3:
1301         rAny <<= OUString( aHelp );
1302         break;
1303     case FIELD_PROP_PAR4:
1304         rAny <<= OUString( aToolTip );
1305         break;
1306     default:
1307         DBG_ERROR("illegal property");
1308     }
1309     return sal_True;
1310 }
1311 
PutValue(const uno::Any & rAny,sal_uInt16 nWhichId)1312 sal_Bool SwInputField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
1313 {
1314     switch( nWhichId )
1315     {
1316     case FIELD_PROP_PAR1:
1317         {
1318             ::GetString( rAny, aContent );
1319         }
1320         break;
1321     case FIELD_PROP_PAR2:
1322         ::GetString( rAny, aPText );
1323         break;
1324     case FIELD_PROP_PAR3:
1325         ::GetString( rAny, aHelp );
1326         break;
1327     case FIELD_PROP_PAR4:
1328         ::GetString( rAny, aToolTip );
1329         break;
1330     default:
1331         DBG_ERROR("illegal property");
1332     }
1333     return sal_True;
1334 }
1335 
1336 
SetPar1(const String & rStr)1337 void SwInputField::SetPar1(const String& rStr)
1338 {
1339     aContent = rStr;
1340 }
1341 
GetPar1() const1342 const String& SwInputField::GetPar1() const
1343 {
1344     return getContent();
1345 }
1346 
1347 
SetPar2(const String & rStr)1348 void SwInputField::SetPar2(const String& rStr)
1349 {
1350 	aPText = rStr;
1351 }
1352 
GetPar2() const1353 String SwInputField::GetPar2() const
1354 {
1355 	return aPText;
1356 }
1357 
SetHelp(const String & rStr)1358 void SwInputField::SetHelp(const String & rStr)
1359 {
1360     aHelp = rStr;
1361 }
1362 
GetHelp() const1363 String SwInputField::GetHelp() const
1364 {
1365     return aHelp;
1366 }
1367 
SetToolTip(const String & rStr)1368 void SwInputField::SetToolTip(const String & rStr)
1369 {
1370     aToolTip = rStr;
1371 }
1372 
GetToolTip() const1373 String SwInputField::GetToolTip() const
1374 {
1375     return aToolTip;
1376 }
1377 
GetSubType() const1378 sal_uInt16 SwInputField::GetSubType() const
1379 {
1380 	return nSubType;
1381 }
1382 
SetSubType(sal_uInt16 nSub)1383 void SwInputField::SetSubType(sal_uInt16 nSub)
1384 {
1385 	nSubType = nSub;
1386 }
1387 
1388