xref: /AOO41X/main/sw/source/core/fields/expfld.cxx (revision 1bf9188d51af09ae398172576afbe6ea8b0dcaa3) 
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