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