LCOV - code coverage report
Current view: top level - sw/source/core/txtnode - atrfld.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 254 0.0 %
Date: 2014-04-14 Functions: 0 47 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10