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