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 "fldbas.hxx"
21 : #include <fmtfld.hxx>
22 : #include <txtfld.hxx>
23 : #include <txtannotationfld.hxx>
24 : #include <docfld.hxx>
25 : #include <docufld.hxx>
26 : #include <doc.hxx>
27 :
28 : #include "pam.hxx"
29 : #include "reffld.hxx"
30 : #include "ddefld.hxx"
31 : #include "usrfld.hxx"
32 : #include "expfld.hxx"
33 : #include "swfont.hxx"
34 : #include "ndtxt.hxx"
35 : #include "calc.hxx"
36 : #include "hints.hxx"
37 : #include <IDocumentFieldsAccess.hxx>
38 : #include <fieldhint.hxx>
39 : #include <svl/smplhint.hxx>
40 :
41 38747 : TYPEINIT3(SwFormatField, SfxPoolItem, SwModify, SfxBroadcaster)
42 :
43 : // constructor for default item in attribute-pool
44 177 : SwFormatField::SwFormatField( sal_uInt16 nWhich )
45 : : SfxPoolItem( nWhich )
46 : , SwModify(0)
47 : , SfxBroadcaster()
48 : , mpField( NULL )
49 177 : , mpTextField( NULL )
50 : {
51 177 : }
52 :
53 1325 : SwFormatField::SwFormatField( const SwField &rField )
54 : : SfxPoolItem( RES_TXTATR_FIELD )
55 1325 : , SwModify( rField.GetTyp() )
56 : , SfxBroadcaster()
57 1325 : , mpField( rField.CopyField() )
58 3975 : , mpTextField( NULL )
59 : {
60 1325 : if ( GetField()->GetTyp()->Which() == RES_INPUTFLD )
61 : {
62 : // input field in-place editing
63 14 : SetWhich( RES_TXTATR_INPUTFIELD );
64 14 : static_cast<SwInputField*>(GetField())->SetFormatField( *this );
65 : }
66 1311 : else if (GetField()->GetTyp()->Which() == RES_SETEXPFLD)
67 : {
68 : // see SwWrtShell::StartInputFieldDlg
69 62 : static_cast<SwSetExpField *>(GetField())->SetFormatField(*this);
70 : }
71 1249 : else if ( GetField()->GetTyp()->Which() == RES_POSTITFLD )
72 : {
73 : // text annotation field
74 135 : SetWhich( RES_TXTATR_ANNOTATION );
75 : }
76 1325 : }
77 :
78 : // #i24434#
79 : // Since Items are used in ItemPool and in default constructed ItemSets with
80 : // full pool range, all items need to be clonable. Thus, this one needed to be
81 : // corrected
82 5112 : SwFormatField::SwFormatField( const SwFormatField& rAttr )
83 : : SfxPoolItem( RES_TXTATR_FIELD )
84 : , SwModify(0)
85 : , SfxBroadcaster()
86 : , mpField( NULL )
87 5112 : , mpTextField( NULL )
88 : {
89 5112 : if ( rAttr.GetField() )
90 : {
91 5112 : rAttr.GetField()->GetTyp()->Add(this);
92 5112 : mpField = rAttr.GetField()->CopyField();
93 5112 : if ( GetField()->GetTyp()->Which() == RES_INPUTFLD )
94 : {
95 : // input field in-place editing
96 158 : SetWhich( RES_TXTATR_INPUTFIELD );
97 158 : SwInputField *pField = dynamic_cast<SwInputField*>(GetField());
98 : assert(pField);
99 158 : if (pField)
100 158 : pField->SetFormatField( *this );
101 : }
102 4954 : else if (GetField()->GetTyp()->Which() == RES_SETEXPFLD)
103 : {
104 : // see SwWrtShell::StartInputFieldDlg
105 188 : static_cast<SwSetExpField *>(GetField())->SetFormatField(*this);
106 : }
107 4766 : else if ( GetField()->GetTyp()->Which() == RES_POSTITFLD )
108 : {
109 : // text annotation field
110 447 : SetWhich( RES_TXTATR_ANNOTATION );
111 : }
112 : }
113 5112 : }
114 :
115 18535 : SwFormatField::~SwFormatField()
116 : {
117 6603 : SwFieldType* pType = mpField ? mpField->GetTyp() : 0;
118 :
119 6603 : if (pType && pType->Which() == RES_DBFLD)
120 419 : pType = 0; // DB-Feldtypen zerstoeren sich selbst
121 :
122 6603 : Broadcast( SwFormatFieldHint( this, SwFormatFieldHintWhich::REMOVED ) );
123 6603 : delete mpField;
124 :
125 : // bei einige FeldTypen muessen wir den FeldTypen noch loeschen
126 6603 : if( pType && pType->HasOnlyOneListener() )
127 : {
128 403 : bool bDel = false;
129 403 : switch( pType->Which() )
130 : {
131 : case RES_USERFLD:
132 2 : bDel = static_cast<SwUserFieldType*>(pType)->IsDeleted();
133 2 : break;
134 :
135 : case RES_SETEXPFLD:
136 34 : bDel = static_cast<SwSetExpFieldType*>(pType)->IsDeleted();
137 34 : break;
138 :
139 : case RES_DDEFLD:
140 0 : bDel = static_cast<SwDDEFieldType*>(pType)->IsDeleted();
141 0 : break;
142 : }
143 :
144 403 : if( bDel )
145 : {
146 : // vorm loeschen erstmal austragen
147 0 : pType->Remove( this );
148 0 : delete pType;
149 : }
150 : }
151 11932 : }
152 :
153 0 : void SwFormatField::RegisterToFieldType( SwFieldType& rType )
154 : {
155 0 : rType.Add(this);
156 0 : }
157 :
158 : // #111840#
159 0 : void SwFormatField::SetField(SwField * _pField)
160 : {
161 0 : delete mpField;
162 :
163 0 : mpField = _pField;
164 0 : if ( GetField()->GetTyp()->Which() == RES_INPUTFLD )
165 : {
166 0 : static_cast<SwInputField* >(GetField())->SetFormatField( *this );
167 : }
168 0 : else if (GetField()->GetTyp()->Which() == RES_SETEXPFLD)
169 : {
170 : // see SwWrtShell::StartInputFieldDlg
171 0 : static_cast<SwSetExpField *>(GetField())->SetFormatField(*this);
172 : }
173 0 : Broadcast( SwFormatFieldHint( this, SwFormatFieldHintWhich::CHANGED ) );
174 0 : }
175 :
176 2040 : void SwFormatField::SetTextField( SwTextField& rTextField )
177 : {
178 2040 : mpTextField = &rTextField;
179 2040 : }
180 :
181 2031 : void SwFormatField::ClearTextField()
182 : {
183 2031 : mpTextField = NULL;
184 2031 : }
185 :
186 13 : bool SwFormatField::operator==( const SfxPoolItem& rAttr ) const
187 : {
188 : assert(SfxPoolItem::operator==(rAttr));
189 13 : return ( ( mpField && static_cast<const SwFormatField&>(rAttr).GetField()
190 0 : && mpField->GetTyp() == static_cast<const SwFormatField&>(rAttr).GetField()->GetTyp()
191 0 : && mpField->GetFormat() == static_cast<const SwFormatField&>(rAttr).GetField()->GetFormat() ) )
192 26 : || ( !mpField && !static_cast<const SwFormatField&>(rAttr).GetField() );
193 : }
194 :
195 5112 : SfxPoolItem* SwFormatField::Clone( SfxItemPool* ) const
196 : {
197 5112 : return new SwFormatField( *this );
198 : }
199 :
200 2031 : void SwFormatField::InvalidateField()
201 : {
202 : SwPtrMsgPoolItem const item(RES_REMOVE_UNO_OBJECT,
203 2031 : &static_cast<SwModify&>(*this)); // cast to base class (void*)
204 2031 : NotifyClients(&item, &item);
205 2031 : }
206 :
207 1778 : void SwFormatField::SwClientNotify( const SwModify& rModify, const SfxHint& rHint )
208 : {
209 1778 : SwClient::SwClientNotify(rModify, rHint);
210 1778 : if( !mpTextField )
211 1949 : return;
212 :
213 1607 : const SwFieldHint* pHint = dynamic_cast<const SwFieldHint*>( &rHint );
214 1607 : if ( pHint )
215 : {
216 : // replace field content by text
217 0 : SwPaM* pPaM = pHint->GetPaM();
218 0 : SwDoc* pDoc = pPaM->GetDoc();
219 0 : const SwTextNode& rTextNode = mpTextField->GetTextNode();
220 0 : pPaM->GetPoint()->nNode = rTextNode;
221 0 : pPaM->GetPoint()->nContent.Assign( const_cast<SwTextNode*>(&rTextNode), mpTextField->GetStart() );
222 :
223 0 : OUString const aEntry( GetField()->ExpandField( pDoc->IsClipBoard() ) );
224 0 : pPaM->SetMark();
225 0 : pPaM->Move( fnMoveForward );
226 0 : pDoc->getIDocumentContentOperations().DeleteRange( *pPaM );
227 0 : pDoc->getIDocumentContentOperations().InsertString( *pPaM, aEntry );
228 : }
229 : }
230 :
231 1909 : void SwFormatField::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
232 : {
233 1909 : if (pOld && (RES_REMOVE_UNO_OBJECT == pOld->Which()))
234 : { // invalidate cached UNO object
235 0 : SetXTextField(css::uno::Reference<css::text::XTextField>(0));
236 : // ??? why does this Modify method not already do this?
237 0 : NotifyClients(pOld, pNew);
238 0 : return;
239 : }
240 :
241 1909 : if( !mpTextField )
242 171 : return;
243 :
244 : // don't do anything, especially not expand!
245 1738 : if( pNew && pNew->Which() == RES_OBJECTDYING )
246 0 : return;
247 :
248 1738 : SwTextNode* pTextNd = &mpTextField->GetTextNode();
249 : OSL_ENSURE( pTextNd, "wo ist denn mein Node?" );
250 1738 : if( pNew )
251 : {
252 423 : switch( pNew->Which() )
253 : {
254 : case RES_TXTATR_FLDCHG:
255 : // "Farbe hat sich geaendert !"
256 : // this, this fuer "nur Painten"
257 0 : pTextNd->ModifyNotification( this, this );
258 0 : return;
259 : case RES_REFMARKFLD_UPDATE:
260 : // GetReferenz-Felder aktualisieren
261 0 : if( RES_GETREFFLD == GetField()->GetTyp()->Which() )
262 : {
263 : // #i81002#
264 0 : static_cast<SwGetRefField*>(GetField())->UpdateField( mpTextField );
265 : }
266 0 : break;
267 : case RES_DOCPOS_UPDATE:
268 : // Je nach DocPos aktualisieren (SwTextFrm::Modify())
269 396 : pTextNd->ModifyNotification( pNew, this );
270 396 : return;
271 :
272 : case RES_ATTRSET_CHG:
273 : case RES_FMT_CHG:
274 27 : pTextNd->ModifyNotification( pOld, pNew );
275 27 : return;
276 : default:
277 0 : break;
278 : }
279 : }
280 :
281 1315 : switch (GetField()->GetTyp()->Which())
282 : {
283 : case RES_HIDDENPARAFLD:
284 0 : if( !pOld || RES_HIDDENPARA_PRINT != pOld->Which() )
285 0 : break;
286 : case RES_DBSETNUMBERFLD:
287 : case RES_DBNUMSETFLD:
288 : case RES_DBNEXTSETFLD:
289 : case RES_DBNAMEFLD:
290 0 : pTextNd->ModifyNotification( 0, pNew);
291 0 : return;
292 : }
293 :
294 1315 : if( RES_USERFLD == GetField()->GetTyp()->Which() )
295 : {
296 0 : SwUserFieldType* pType = static_cast<SwUserFieldType*>(GetField()->GetTyp());
297 0 : if(!pType->IsValid())
298 : {
299 0 : SwCalc aCalc( *pTextNd->GetDoc() );
300 0 : pType->GetValue( aCalc );
301 : }
302 : }
303 :
304 1315 : const bool bForceNotify = (pOld == NULL) && (pNew == NULL);
305 1315 : mpTextField->ExpandTextField( bForceNotify );
306 : }
307 :
308 23 : bool SwFormatField::GetInfo( SfxPoolItem& rInfo ) const
309 : {
310 : const SwTextNode* pTextNd;
311 69 : if( RES_AUTOFMT_DOCNODE != rInfo.Which() ||
312 69 : !mpTextField || 0 == ( pTextNd = mpTextField->GetpTextNode() ) ||
313 23 : &pTextNd->GetNodes() != static_cast<SwAutoFormatGetDocNode&>(rInfo).pNodes )
314 0 : return true;
315 :
316 23 : static_cast<SwAutoFormatGetDocNode&>(rInfo).pContentNode = pTextNd;
317 23 : return false;
318 : }
319 :
320 1518 : bool SwFormatField::IsFieldInDoc() const
321 : {
322 1518 : return mpTextField != NULL
323 1518 : && mpTextField->IsFieldInDoc();
324 : }
325 :
326 0 : bool SwFormatField::IsProtect() const
327 : {
328 0 : return mpTextField != NULL
329 0 : && mpTextField->GetpTextNode() != NULL
330 0 : && mpTextField->GetpTextNode()->IsProtect();
331 : }
332 :
333 : // class SwTextField ////////////////////////////////////////////////////
334 :
335 2040 : SwTextField::SwTextField(
336 : SwFormatField & rAttr,
337 : sal_Int32 const nStartPos,
338 : bool const bInClipboard)
339 : : SwTextAttr( rAttr, nStartPos )
340 : // fdo#39694 the ExpandField here may not give the correct result in all cases,
341 : // but is better than nothing
342 : , m_aExpand( rAttr.GetField()->ExpandField(bInClipboard) )
343 2040 : , m_pTextNode( NULL )
344 : {
345 2040 : rAttr.SetTextField( *this );
346 2040 : SetHasDummyChar(true);
347 2040 : }
348 :
349 7810 : SwTextField::~SwTextField( )
350 : {
351 2031 : SwFormatField & rFormatField( static_cast<SwFormatField &>(GetAttr()) );
352 2031 : if ( this == rFormatField.GetTextField() )
353 : {
354 2031 : rFormatField.ClearTextField();
355 : }
356 5779 : }
357 :
358 1542 : bool SwTextField::IsFieldInDoc() const
359 : {
360 1542 : return GetpTextNode() != NULL
361 1542 : && GetpTextNode()->GetNodes().IsDocNodes();
362 : }
363 :
364 1561 : void SwTextField::ExpandTextField(const bool bForceNotify) const
365 : {
366 : OSL_ENSURE( m_pTextNode, "SwTextField: where is my TextNode?" );
367 :
368 1561 : const SwField* pField = GetFormatField().GetField();
369 1561 : const OUString aNewExpand( pField->ExpandField(m_pTextNode->GetDoc()->IsClipBoard()) );
370 :
371 1561 : if (aNewExpand == m_aExpand)
372 : {
373 : // Bei Seitennummernfeldern
374 1339 : const sal_uInt16 nWhich = pField->GetTyp()->Which();
375 1339 : if ( RES_CHAPTERFLD != nWhich
376 1339 : && RES_PAGENUMBERFLD != nWhich
377 1294 : && RES_REFPAGEGETFLD != nWhich
378 : // Page count fields to not use aExpand during formatting,
379 : // therefore an invalidation of the text frame has to be triggered even if aNewExpand == aExpand:
380 1294 : && ( RES_DOCSTATFLD != nWhich || DS_PAGE != static_cast<const SwDocStatField*>(pField)->GetSubType() )
381 2578 : && ( RES_GETEXPFLD != nWhich || static_cast<const SwGetExpField*>(pField)->IsInBodyText() ) )
382 : {
383 1239 : if( m_pTextNode->CalcHiddenParaField() )
384 : {
385 0 : m_pTextNode->ModifyNotification( 0, 0 );
386 : }
387 1239 : if ( !bForceNotify )
388 : {
389 : // done, if no further notification forced.
390 1726 : return;
391 : }
392 : }
393 : }
394 :
395 1396 : m_aExpand = aNewExpand;
396 :
397 1396 : const_cast<SwTextField*>(this)->NotifyContentChange( const_cast<SwFormatField&>(GetFormatField()) );
398 : }
399 :
400 53 : void SwTextField::CopyTextField( SwTextField *pDest ) const
401 : {
402 : OSL_ENSURE( m_pTextNode, "SwTextField: where is my TextNode?" );
403 : OSL_ENSURE( pDest->m_pTextNode, "SwTextField: where is pDest's TextNode?" );
404 :
405 53 : IDocumentFieldsAccess* pIDFA = m_pTextNode->getIDocumentFieldsAccess();
406 53 : IDocumentFieldsAccess* pDestIDFA = pDest->m_pTextNode->getIDocumentFieldsAccess();
407 :
408 53 : SwFormatField& rDestFormatField = (SwFormatField&)pDest->GetFormatField();
409 53 : const sal_uInt16 nFieldWhich = rDestFormatField.GetField()->GetTyp()->Which();
410 :
411 53 : if( pIDFA != pDestIDFA )
412 : {
413 : // Die Hints stehen in unterschiedlichen Dokumenten,
414 : // der Feldtyp muss im neuen Dokument angemeldet werden.
415 : // Z.B: Kopieren ins ClipBoard.
416 : SwFieldType* pFieldType;
417 53 : if( nFieldWhich != RES_DBFLD
418 12 : && nFieldWhich != RES_USERFLD
419 12 : && nFieldWhich != RES_SETEXPFLD
420 12 : && nFieldWhich != RES_DDEFLD
421 12 : && RES_AUTHORITY != nFieldWhich )
422 : {
423 12 : pFieldType = pDestIDFA->GetSysFieldType( nFieldWhich );
424 : }
425 : else
426 : {
427 41 : pFieldType = pDestIDFA->InsertFieldType( *rDestFormatField.GetField()->GetTyp() );
428 : }
429 :
430 : // Sonderbehandlung fuer DDE-Felder
431 53 : if( RES_DDEFLD == nFieldWhich )
432 : {
433 0 : if( rDestFormatField.GetTextField() )
434 : {
435 0 : static_cast<SwDDEFieldType*>(rDestFormatField.GetField()->GetTyp())->DecRefCnt();
436 : }
437 0 : static_cast<SwDDEFieldType*>(pFieldType)->IncRefCnt();
438 : }
439 :
440 : OSL_ENSURE( pFieldType, "unbekannter FieldType" );
441 53 : pFieldType->Add( &rDestFormatField ); // ummelden
442 53 : rDestFormatField.GetField()->ChgTyp( pFieldType );
443 : }
444 :
445 : // Expressionfelder Updaten
446 53 : if( nFieldWhich == RES_SETEXPFLD
447 53 : || nFieldWhich == RES_GETEXPFLD
448 53 : || nFieldWhich == RES_HIDDENTXTFLD )
449 : {
450 0 : SwTextField* pField = const_cast<SwTextField*>(this);
451 0 : pDestIDFA->UpdateExpFields( pField, true );
452 : }
453 : // Tabellenfelder auf externe Darstellung
454 53 : else if( RES_TABLEFLD == nFieldWhich
455 53 : && static_cast<SwTableField*>(rDestFormatField.GetField())->IsIntrnlName() )
456 : {
457 : // erzeuge aus der internen (fuer CORE) die externe (fuer UI) Formel
458 0 : const SwTableNode* pTableNd = m_pTextNode->FindTableNode();
459 0 : if( pTableNd ) // steht in einer Tabelle
460 0 : static_cast<SwTableField*>(rDestFormatField.GetField())->PtrToBoxNm( &pTableNd->GetTable() );
461 : }
462 53 : }
463 :
464 1396 : void SwTextField::NotifyContentChange(SwFormatField& rFormatField)
465 : {
466 : //if not in undo section notify the change
467 1396 : if (m_pTextNode && m_pTextNode->GetNodes().IsDocNodes())
468 : {
469 1396 : m_pTextNode->ModifyNotification(0, &rFormatField);
470 : }
471 1396 : }
472 :
473 : /*static*/
474 452 : void SwTextField::GetPamForTextField(
475 : const SwTextField& rTextField,
476 : boost::shared_ptr< SwPaM >& rPamForTextField )
477 : {
478 452 : if (rTextField.GetpTextNode() == NULL)
479 : {
480 : SAL_WARN("sw.core", "<SwTextField::GetPamForField> - missing <SwTextNode>");
481 452 : return;
482 : }
483 :
484 452 : const SwTextNode& rTextNode = rTextField.GetTextNode();
485 :
486 : rPamForTextField.reset( new SwPaM( rTextNode,
487 904 : (rTextField.End() != NULL) ? *(rTextField.End()) : ( rTextField.GetStart() + 1 ),
488 : rTextNode,
489 904 : rTextField.GetStart() ) );
490 :
491 : }
492 :
493 : /*static*/
494 2 : void SwTextField::DeleteTextField( const SwTextField& rTextField )
495 : {
496 2 : if (rTextField.GetpTextNode() != NULL)
497 : {
498 2 : boost::shared_ptr< SwPaM > pPamForTextField;
499 2 : GetPamForTextField(rTextField, pPamForTextField);
500 2 : if (pPamForTextField.get() != NULL)
501 : {
502 2 : rTextField.GetTextNode().GetDoc()->getIDocumentContentOperations().DeleteAndJoin(*pPamForTextField);
503 2 : }
504 : }
505 2 : }
506 :
507 : // class SwTextInputField ///////////////////////////////////////////////
508 :
509 : // input field in-place editing
510 18 : SwTextInputField::SwTextInputField(
511 : SwFormatField & rAttr,
512 : sal_Int32 const nStart,
513 : sal_Int32 const nEnd,
514 : bool const bInClipboard )
515 :
516 : : SwTextAttr( rAttr, nStart )
517 : , SwTextAttrNesting( rAttr, nStart, nEnd )
518 : , SwTextField( rAttr, nStart, bInClipboard )
519 18 : , m_bLockNotifyContentChange( false )
520 : {
521 18 : SetHasDummyChar( false );
522 18 : SetHasContent( true );
523 18 : }
524 :
525 54 : SwTextInputField::~SwTextInputField()
526 : {
527 54 : }
528 :
529 9 : void SwTextInputField::LockNotifyContentChange()
530 : {
531 9 : m_bLockNotifyContentChange = true;
532 9 : }
533 :
534 9 : void SwTextInputField::UnlockNotifyContentChange()
535 : {
536 9 : m_bLockNotifyContentChange = false;
537 9 : }
538 :
539 9 : void SwTextInputField::NotifyContentChange( SwFormatField& rFormatField )
540 : {
541 9 : if ( !m_bLockNotifyContentChange )
542 : {
543 9 : LockNotifyContentChange();
544 :
545 9 : SwTextField::NotifyContentChange( rFormatField );
546 9 : UpdateTextNodeContent( GetFieldContent() );
547 :
548 9 : UnlockNotifyContentChange();
549 : }
550 9 : }
551 :
552 23 : const OUString SwTextInputField::GetFieldContent() const
553 : {
554 23 : return GetFormatField().GetField()->ExpandField(false);
555 : }
556 :
557 16 : void SwTextInputField::UpdateFieldContent()
558 : {
559 32 : if ( IsFieldInDoc()
560 16 : && GetStart() != (*End()) )
561 : {
562 : OSL_ENSURE( (*End()) - GetStart() >= 2,
563 : "<SwTextInputField::UpdateFieldContent()> - Are CH_TXT_ATR_INPUTFIELDSTART and/or CH_TXT_ATR_INPUTFIELDEND missing?" );
564 : // skip CH_TXT_ATR_INPUTFIELDSTART character
565 16 : const sal_Int32 nIdx = GetStart() + 1;
566 : // skip CH_TXT_ATR_INPUTFIELDEND character
567 16 : const sal_Int32 nLen = static_cast<sal_Int32>(std::max<sal_Int32>( 0, ( (*End()) - 1 - nIdx ) ));
568 16 : const OUString aNewFieldContent = GetTextNode().GetExpandText( nIdx, nLen );
569 :
570 16 : const SwInputField* pInputField = dynamic_cast<const SwInputField*>(GetFormatField().GetField());
571 : OSL_ENSURE( pInputField != NULL,
572 : "<SwTextInputField::GetContent()> - Missing <SwInputField> instance!" );
573 16 : if ( pInputField != NULL )
574 : {
575 16 : const_cast<SwInputField*>(pInputField)->applyFieldContent( aNewFieldContent );
576 : // trigger update of fields for scenarios in which the Input Field's content is part of e.g. a table formula
577 16 : GetTextNode().GetDoc()->getIDocumentFieldsAccess().GetUpdateFields().SetFieldsDirty(true);
578 16 : }
579 : }
580 16 : }
581 :
582 9 : void SwTextInputField::UpdateTextNodeContent( const OUString& rNewContent )
583 : {
584 9 : if ( !IsFieldInDoc() )
585 : {
586 : OSL_ENSURE( false, "<SwTextInputField::UpdateTextNodeContent(..)> - misusage as Input Field is not in document content." );
587 9 : return;
588 : }
589 :
590 : OSL_ENSURE( (*End()) - GetStart() >= 2,
591 : "<SwTextInputField::UpdateTextNodeContent(..)> - Are CH_TXT_ATR_INPUTFIELDSTART and/or CH_TXT_ATR_INPUTFIELDEND missing?" );
592 : // skip CH_TXT_ATR_INPUTFIELDSTART character
593 9 : const sal_Int32 nIdx = GetStart() + 1;
594 : // skip CH_TXT_ATR_INPUTFIELDEND character
595 9 : const sal_Int32 nDelLen = std::max<sal_Int32>( 0, ( (*End()) - 1 - nIdx ) );
596 9 : SwIndex aIdx( &GetTextNode(), nIdx );
597 9 : GetTextNode().ReplaceText( aIdx, nDelLen, rNewContent );
598 : }
599 :
600 : // class SwTextAnnotationField //////////////////////////////////////////
601 :
602 : // text annotation field
603 139 : SwTextAnnotationField::SwTextAnnotationField(
604 : SwFormatField & rAttr,
605 : sal_Int32 const nStart,
606 : bool const bInClipboard )
607 : : SwTextAttr( rAttr, nStart )
608 139 : , SwTextField( rAttr, nStart, bInClipboard )
609 : {
610 139 : }
611 :
612 417 : SwTextAnnotationField::~SwTextAnnotationField()
613 : {
614 417 : }
615 :
616 1137 : ::sw::mark::IMark* SwTextAnnotationField::GetAnnotationMark(
617 : SwDoc* pDoc ) const
618 : {
619 1137 : const SwPostItField* pPostItField = dynamic_cast<const SwPostItField*>(GetFormatField().GetField());
620 : OSL_ENSURE( pPostItField != NULL, "<SwTextAnnotationField::GetAnnotationMark()> - field missing" );
621 1137 : if ( pPostItField == NULL )
622 : {
623 0 : return NULL;
624 : }
625 :
626 1137 : if ( pDoc == NULL )
627 : {
628 1137 : pDoc = static_cast<const SwPostItFieldType*>(pPostItField->GetTyp())->GetDoc();
629 : }
630 : OSL_ENSURE( pDoc != NULL, "<SwTextAnnotationField::GetAnnotationMark()> - missing document" );
631 1137 : if ( pDoc == NULL )
632 : {
633 0 : return NULL;
634 : }
635 :
636 1137 : IDocumentMarkAccess* pMarksAccess = pDoc->getIDocumentMarkAccess();
637 1137 : IDocumentMarkAccess::const_iterator_t pMark = pMarksAccess->findAnnotationMark( pPostItField->GetName() );
638 2274 : return pMark != pMarksAccess->getAnnotationMarksEnd()
639 787 : ? pMark->get()
640 1924 : : NULL;
641 177 : }
642 :
643 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
