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