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