core/txtnode/atrfld.cxx

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sw.hxx"

#include "fldbas.hxx"          // fuer FieldType
#include <fmtfld.hxx>
#include <txtfld.hxx>
#include <txtannotationfld.hxx>
#include <docfld.hxx>
#include <docufld.hxx>
#include <doc.hxx>

#include "reffld.hxx"
#include "ddefld.hxx"
#include "usrfld.hxx"
#include "expfld.hxx"
#include "swfont.hxx"       // fuer GetFldsColor
#include "ndtxt.hxx"        // SwTxtNode
#include "calc.hxx"         // Update fuer UserFields
#include "hints.hxx"
#include <IDocumentFieldsAccess.hxx>
#include <fieldhint.hxx>
#include <svl/smplhint.hxx>

TYPEINIT3( SwFmtFld, SfxPoolItem, SwClient,SfxBroadcaster)
TYPEINIT1(SwFmtFldHint, SfxHint);

/****************************************************************************
 *
 *  class SwFmtFld
 *
 ****************************************************************************/

// constructor for default item in attribute-pool
SwFmtFld::SwFmtFld( sal_uInt16 nWhich )
    : SfxPoolItem( nWhich )
    , SwClient()
    , SfxBroadcaster()
    , mpField( NULL )
    , mpTxtFld( NULL )
{
}

SwFmtFld::SwFmtFld( const SwField &rFld )
    : SfxPoolItem( RES_TXTATR_FIELD )
    , SwClient( rFld.GetTyp() )
    , SfxBroadcaster()
    , mpField( rFld.CopyField() )
    , mpTxtFld( NULL )
{
    if ( GetField()->GetTyp()->Which() == RES_INPUTFLD )
    {
        // input field in-place editing
        SetWhich( RES_TXTATR_INPUTFIELD );
        dynamic_cast<SwInputField*>(GetField())->SetFmtFld( *this );
    }
    else if ( GetField()->GetTyp()->Which() == RES_POSTITFLD )
    {
        // text annotation field
        SetWhich( RES_TXTATR_ANNOTATION );
    }
}

// #i24434#
// Since Items are used in ItemPool and in default constructed ItemSets with
// full pool range, all items need to be clonable. Thus, this one needed to be
// corrected
SwFmtFld::SwFmtFld( const SwFmtFld& rAttr )
    : SfxPoolItem( RES_TXTATR_FIELD )
    , SwClient()
    , SfxBroadcaster()
    , mpField( NULL )
    , mpTxtFld( NULL )
{
    if ( rAttr.GetField() )
    {
        rAttr.GetField()->GetTyp()->Add(this);
        mpField = rAttr.GetField()->CopyField();
        if ( GetField()->GetTyp()->Which() == RES_INPUTFLD )
        {
            // input field in-place editing
            SetWhich( RES_TXTATR_INPUTFIELD );
            dynamic_cast<SwInputField*>(GetField())->SetFmtFld( *this );
        }
        else if ( GetField()->GetTyp()->Which() == RES_POSTITFLD )
        {
            // text annotation field
            SetWhich( RES_TXTATR_ANNOTATION );
        }
    }
}

SwFmtFld::~SwFmtFld()
{
	SwFieldType* pType = mpField ? mpField->GetTyp() : 0;

	if (pType && pType->Which() == RES_DBFLD)
		pType = 0;	// DB-Feldtypen zerstoeren sich selbst

	Broadcast( SwFmtFldHint( this, SWFMTFLD_REMOVED ) );
	delete mpField;

	// bei einige FeldTypen muessen wir den FeldTypen noch loeschen
	if( pType && pType->IsLastDepend() )
	{
		sal_Bool bDel = sal_False;
		switch( pType->Which() )
		{
		case RES_USERFLD:
			bDel = ((SwUserFieldType*)pType)->IsDeleted();
			break;

		case RES_SETEXPFLD:
			bDel = ((SwSetExpFieldType*)pType)->IsDeleted();
			break;

		case RES_DDEFLD:
			bDel = ((SwDDEFieldType*)pType)->IsDeleted();
			break;
		}

		if( bDel )
		{
			// vorm loeschen erstmal austragen
			pType->Remove( this );
			delete pType;
		}
	}
}

void SwFmtFld::RegisterToFieldType( SwFieldType& rType )
{
    rType.Add(this);
}


// #111840#
void SwFmtFld::SetField(SwField * _pField)
{
    if (NULL != mpField)
        delete mpField;

    mpField = _pField;
    if ( GetField()->GetTyp()->Which() == RES_INPUTFLD )
    {
        dynamic_cast<SwInputField* >(GetField())->SetFmtFld( *this );
    }
    Broadcast( SwFmtFldHint( this, SWFMTFLD_CHANGED ) );
}

void SwFmtFld::SetTxtFld( SwTxtFld& rTxtFld )
{
    mpTxtFld = &rTxtFld;
}

void SwFmtFld::ClearTxtFld()
{
    mpTxtFld = NULL;
}

int SwFmtFld::operator==( const SfxPoolItem& rAttr ) const
{
	ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
    return ( ( mpField && ((SwFmtFld&)rAttr).GetField()
               && mpField->GetTyp() == ((SwFmtFld&)rAttr).GetField()->GetTyp()
               && mpField->GetFormat() == ((SwFmtFld&)rAttr).GetField()->GetFormat() ) )
             || ( !mpField && !((SwFmtFld&)rAttr).GetField() );
}

SfxPoolItem* SwFmtFld::Clone( SfxItemPool* ) const
{
	return new SwFmtFld( *this );
}

void SwFmtFld::SwClientNotify( const SwModify&, const SfxHint& rHint )
{
    if( !mpTxtFld )
        return;

    const SwFieldHint* pHint = dynamic_cast<const SwFieldHint*>( &rHint );
    if ( pHint )
    {
        // replace field content by text
        SwPaM* pPaM = pHint->GetPaM();
        SwDoc* pDoc = pPaM->GetDoc();
        const SwTxtNode& rTxtNode = mpTxtFld->GetTxtNode();
        pPaM->GetPoint()->nNode = rTxtNode;
        pPaM->GetPoint()->nContent.Assign( (SwTxtNode*)&rTxtNode, *mpTxtFld->GetStart() );

        String const aEntry( GetField()->ExpandField( pDoc->IsClipBoard() ) );
        pPaM->SetMark();
        pPaM->Move( fnMoveForward );
        pDoc->DeleteRange( *pPaM );
        pDoc->InsertString( *pPaM, aEntry );
    }
}

void SwFmtFld::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
{
    if ( mpTxtFld == NULL )
        return;

    if( pNew != NULL
        && pNew->Which() == RES_OBJECTDYING )
    {
        // don't do anything, especially not expand!
        return;
    }

    SwTxtNode* pTxtNd = (SwTxtNode*) &mpTxtFld->GetTxtNode();
    ASSERT( pTxtNd, "wo ist denn mein Node?" );
    if ( pNew )
    {
        switch (pNew->Which())
        {
        case RES_TXTATR_FLDCHG:
            // "Farbe hat sich geaendert !"
            // this, this fuer "nur Painten"
            pTxtNd->ModifyNotification( this, this );
            return;

        case RES_REFMARKFLD_UPDATE:
            // GetReferenz-Felder aktualisieren
            if ( RES_GETREFFLD == GetField()->GetTyp()->Which() )
            {
                dynamic_cast<SwGetRefField*>(GetField())->UpdateField( mpTxtFld );
            }
            break;

        case RES_DOCPOS_UPDATE:
            // Je nach DocPos aktualisieren (SwTxtFrm::Modify())
            pTxtNd->ModifyNotification( pNew, this );
            return;

        case RES_ATTRSET_CHG:
            case RES_FMT_CHG:
            pTxtNd->ModifyNotification( pOld, pNew );
            return;

            default:
            break;
        }
    }

    switch (GetField()->GetTyp()->Which())
    {
    case RES_HIDDENPARAFLD:
        if ( !pOld || RES_HIDDENPARA_PRINT != pOld->Which() )
            break;
    case RES_DBSETNUMBERFLD:
    case RES_DBNUMSETFLD:
    case RES_DBNEXTSETFLD:
    case RES_DBNAMEFLD:
        pTxtNd->ModifyNotification( 0, pNew );
        return;
    }

    if ( RES_USERFLD == GetField()->GetTyp()->Which() )
    {
        SwUserFieldType* pType = (SwUserFieldType*) GetField()->GetTyp();
        if ( !pType->IsValid() )
        {
            SwCalc aCalc( *pTxtNd->GetDoc() );
            pType->GetValue( aCalc );
        }
    }

    const bool bForceNotify = (pOld == NULL) && (pNew == NULL);
    mpTxtFld->ExpandTxtFld( bForceNotify );
}

sal_Bool SwFmtFld::GetInfo( SfxPoolItem& rInfo ) const
{
	const SwTxtNode* pTxtNd;
	if( RES_AUTOFMT_DOCNODE != rInfo.Which() ||
		!mpTxtFld || 0 == ( pTxtNd = mpTxtFld->GetpTxtNode() ) ||
		&pTxtNd->GetNodes() != ((SwAutoFmtGetDocNode&)rInfo).pNodes )
		return sal_True;

	((SwAutoFmtGetDocNode&)rInfo).pCntntNode = pTxtNd;
	return sal_False;
}


bool SwFmtFld::IsFldInDoc() const
{
    return mpTxtFld != NULL
           && mpTxtFld->IsFldInDoc();
}

sal_Bool SwFmtFld::IsProtect() const
{
    return mpTxtFld != NULL
           && mpTxtFld->GetpTxtNode() != NULL
           && mpTxtFld->GetpTxtNode()->IsProtect();
}


SwTxtFld::SwTxtFld(
    SwFmtFld & rAttr,
    xub_StrLen const nStartPos,
    const bool bIsClipboardDoc )
    : SwTxtAttr( rAttr, nStartPos )
    , m_aExpand( rAttr.GetField()->ExpandField( bIsClipboardDoc ) )
    , m_pTxtNode( NULL )
{
    rAttr.SetTxtFld( *this );
    SetHasDummyChar(true);
}

SwTxtFld::~SwTxtFld( )
{
    SwFmtFld & rFmtFld( static_cast<SwFmtFld &>(GetAttr()) );
    if ( this == rFmtFld.GetTxtFld() )
    {
        rFmtFld.ClearTxtFld();
    }
}


bool SwTxtFld::IsFldInDoc() const
{
    return GetpTxtNode() != NULL
           && GetpTxtNode()->GetNodes().IsDocNodes();
}

void SwTxtFld::ExpandTxtFld( const bool bForceNotify ) const
{
    ASSERT( m_pTxtNode, "SwTxtFld: where is my TxtNode?" );

    const SwField* pFld = GetFmtFld().GetField();
    const XubString aNewExpand( pFld->ExpandField(m_pTxtNode->GetDoc()->IsClipBoard()) );

    if ( !bForceNotify &&
         aNewExpand == m_aExpand )
    {
        // Bei Seitennummernfeldern
        const sal_uInt16 nWhich = pFld->GetTyp()->Which();
        if ( RES_CHAPTERFLD != nWhich
             && RES_PAGENUMBERFLD != nWhich
             && RES_REFPAGEGETFLD != nWhich
             // Page count fields to not use aExpand during formatting,
             // therefore an invalidation of the text frame has to be triggered even if aNewExpand == aExpand:
             && ( RES_DOCSTATFLD != nWhich || DS_PAGE != static_cast<const SwDocStatField*>(pFld)->GetSubType() )
             && ( RES_GETEXPFLD != nWhich || ((SwGetExpField*)pFld)->IsInBodyTxt() ) )
        {
            if( m_pTxtNode->CalcHiddenParaField() )
            {
                m_pTxtNode->ModifyNotification( 0, 0 );
            }
            return;
        }
    }

    m_aExpand = aNewExpand;

    const_cast<SwTxtFld*>(this)->NotifyContentChange( const_cast<SwFmtFld&>(GetFmtFld()) );
}


void SwTxtFld::CopyTxtFld( SwTxtFld *pDest ) const
{
    ASSERT( m_pTxtNode, "SwTxtFld: where is my TxtNode?" );
    ASSERT( pDest->m_pTxtNode, "SwTxtFld: where is pDest's TxtNode?" );

    IDocumentFieldsAccess* pIDFA = m_pTxtNode->getIDocumentFieldsAccess();
    IDocumentFieldsAccess* pDestIDFA = pDest->m_pTxtNode->getIDocumentFieldsAccess();

    SwFmtFld& rDestFmtFld = (SwFmtFld&)pDest->GetFmtFld();
    const sal_uInt16 nFldWhich = rDestFmtFld.GetField()->GetTyp()->Which();

    if( pIDFA != pDestIDFA )
    {
        // Die Hints stehen in unterschiedlichen Dokumenten,
        // der Feldtyp muss im neuen Dokument angemeldet werden.
        // Z.B: Kopieren ins ClipBoard.
        SwFieldType* pFldType;
        if( nFldWhich != RES_DBFLD
            && nFldWhich != RES_USERFLD
            && nFldWhich != RES_SETEXPFLD
            && nFldWhich != RES_DDEFLD
            && RES_AUTHORITY != nFldWhich )
        {
            pFldType = pDestIDFA->GetSysFldType( nFldWhich );
        }
        else
        {
            pFldType = pDestIDFA->InsertFldType( *rDestFmtFld.GetField()->GetTyp() );
        }

        // Sonderbehandlung fuer DDE-Felder
        if( RES_DDEFLD == nFldWhich )
        {
            if( rDestFmtFld.GetTxtFld() )
            {
                ((SwDDEFieldType*)rDestFmtFld.GetField()->GetTyp())->DecRefCnt();
            }
            ((SwDDEFieldType*)pFldType)->IncRefCnt();
        }

        ASSERT( pFldType, "unbekannter FieldType" );
        pFldType->Add( &rDestFmtFld );          // ummelden
        rDestFmtFld.GetField()->ChgTyp( pFldType );
    }

    // Expressionfelder Updaten
    if( nFldWhich == RES_SETEXPFLD
        || nFldWhich == RES_GETEXPFLD
        || nFldWhich == RES_HIDDENTXTFLD )
    {
        SwTxtFld* pFld = (SwTxtFld*)this;
        pDestIDFA->UpdateExpFlds( pFld, true );
    }
    // Tabellenfelder auf externe Darstellung
    else if( RES_TABLEFLD == nFldWhich
             && ((SwTblField*)rDestFmtFld.GetField())->IsIntrnlName() )
    {
        // erzeuge aus der internen (fuer CORE) die externe (fuer UI) Formel
        const SwTableNode* pTblNd = m_pTxtNode->FindTableNode();
        if( pTblNd )		// steht in einer Tabelle
            ((SwTblField*)rDestFmtFld.GetField())->PtrToBoxNm( &pTblNd->GetTable() );
    }
}


void SwTxtFld::NotifyContentChange(SwFmtFld& rFmtFld)
{
    //if not in undo section notify the change
    if (m_pTxtNode && m_pTxtNode->GetNodes().IsDocNodes())
    {
        m_pTxtNode->ModifyNotification(0, &rFmtFld);
    }
}


/*static*/
void SwTxtFld::GetPamForTxtFld(
    const SwTxtFld& rTxtFld,
    boost::shared_ptr< SwPaM >& rPamForTxtFld )
{
    if ( rTxtFld.GetpTxtNode() == NULL )
    {
        ASSERT( false, "<SwTxtFld::GetPamForField> - missing <SwTxtNode>" );
        return;
    }

    const SwTxtNode& rTxtNode = rTxtFld.GetTxtNode();

    rPamForTxtFld.reset( new SwPaM( rTxtNode,
                                    ( (rTxtFld.End() != NULL) ? *(rTxtFld.End()) : ( *(rTxtFld.GetStart()) + 1 ) ),
                                    rTxtNode,
                                    *(rTxtFld.GetStart()) ) );

}


/*static*/
void SwTxtFld::DeleteTxtFld( const SwTxtFld& rTxtFld )
{
    if ( rTxtFld.GetpTxtNode() != NULL )
    {
        boost::shared_ptr< SwPaM > pPamForTxtFld;
        GetPamForTxtFld( rTxtFld, pPamForTxtFld );
        if ( pPamForTxtFld.get() != NULL )
        {
            rTxtFld.GetTxtNode().GetDoc()->DeleteAndJoin( *pPamForTxtFld );
        }
    }
}


// input field in-place editing
SwTxtInputFld::SwTxtInputFld(
    SwFmtFld & rAttr,
    xub_StrLen const nStart,
    xub_StrLen const nEnd,
    const bool bIsClipboardDoc )

    : SwTxtFld( rAttr, nStart, bIsClipboardDoc )
    , m_nEnd( nEnd )
    , m_bLockNotifyContentChange( false )
{
    SetHasDummyChar( false );
    SetHasContent( true );

    SetDontExpand( true );
    SetLockExpandFlag( true );
    SetDontExpandStartAttr( true );

    SetNesting( true );
}

SwTxtInputFld::~SwTxtInputFld()
{
}

xub_StrLen* SwTxtInputFld::GetEnd()
{
    return &m_nEnd;
}


void SwTxtInputFld::LockNotifyContentChange()
{
    m_bLockNotifyContentChange = true;
}


void SwTxtInputFld::UnlockNotifyContentChange()
{
    m_bLockNotifyContentChange = false;
}


void SwTxtInputFld::NotifyContentChange( SwFmtFld& rFmtFld )
{
    if ( !m_bLockNotifyContentChange )
    {
        LockNotifyContentChange();

        SwTxtFld::NotifyContentChange( rFmtFld );
        UpdateTextNodeContent( GetFieldContent() );

        UnlockNotifyContentChange();
    }
}

const String SwTxtInputFld::GetFieldContent() const
{
    return GetFmtFld().GetField()->ExpandField(false);
}

void SwTxtInputFld::UpdateFieldContent()
{
    if ( IsFldInDoc()
         && (*GetStart()) != (*End()) )
    {
        ASSERT( (*End()) - (*GetStart()) >= 2,
                "<SwTxtInputFld::UpdateFieldContent()> - Are CH_TXT_ATR_INPUTFIELDSTART and/or CH_TXT_ATR_INPUTFIELDEND missing?" );
        // skip CH_TXT_ATR_INPUTFIELDSTART character
        const xub_StrLen nIdx = (*GetStart()) + 1;
        // skip CH_TXT_ATR_INPUTFIELDEND character
        const xub_StrLen nLen = static_cast<xub_StrLen>(std::max( 0, ( (*End()) - 1 - nIdx ) ));
        const String aNewFieldContent = GetTxtNode().GetExpandTxt( nIdx, nLen );

        const SwInputField* pInputFld = dynamic_cast<const SwInputField*>(GetFmtFld().GetField());
        ASSERT( pInputFld != NULL,
                "<SwTxtInputFld::GetContent()> - Missing <SwInputFld> instance!" );
        if ( pInputFld != NULL )
        {
            const_cast<SwInputField*>(pInputFld)->applyFieldContent( aNewFieldContent );
            // trigger update of fields for scenarios in which the Input Field's content is part of e.g. a table formula
            GetTxtNode().GetDoc()->GetUpdtFlds().SetFieldsDirty( sal_True );
        }
    }
}

void SwTxtInputFld::UpdateTextNodeContent( const String& rNewContent )
{
    if ( !IsFldInDoc() )
    {
        ASSERT( false, "<SwTxtInputFld::UpdateTextNodeContent(..)> - misusage as Input Field is not in document content." );
        return;
    }

    ASSERT( (*End()) - (*GetStart()) >= 2,
            "<SwTxtInputFld::UpdateTextNodeContent(..)> - Are CH_TXT_ATR_INPUTFIELDSTART and/or CH_TXT_ATR_INPUTFIELDEND missing?" );
    // skip CH_TXT_ATR_INPUTFIELDSTART character
    const xub_StrLen nIdx = (*GetStart()) + 1;
    // skip CH_TXT_ATR_INPUTFIELDEND character
    const xub_StrLen nDelLen = static_cast<xub_StrLen>(std::max( 0, ( (*End()) - 1 - nIdx ) ));
    SwIndex aIdx( &GetTxtNode(), nIdx );
    GetTxtNode().ReplaceText( aIdx, nDelLen, rNewContent );
}


// text annotation field
SwTxtAnnotationFld::SwTxtAnnotationFld(
    SwFmtFld & rAttr,
    xub_StrLen const nStart,
    const bool bIsClipboardDoc )
    : SwTxtFld( rAttr, nStart, bIsClipboardDoc )
{
}

SwTxtAnnotationFld::~SwTxtAnnotationFld()
{
}


::sw::mark::IMark* SwTxtAnnotationFld::GetAnnotationMark(
    SwDoc* pDoc ) const
{
    const SwPostItField* pPostItField = dynamic_cast<const SwPostItField*>(GetFmtFld().GetField());
    ASSERT( pPostItField != NULL, "<SwTxtAnnotationFld::GetAnnotationMark()> - field missing" );
    if ( pPostItField == NULL )
    {
        return NULL;
    }

    if ( pDoc == NULL )
    {
        pDoc = static_cast<const SwPostItFieldType*>(pPostItField->GetTyp())->GetDoc();
    }
    ASSERT( pDoc != NULL, "<SwTxtAnnotationFld::GetAnnotationMark()> - missing document" );
    if ( pDoc == NULL )
    {
        return NULL;
    }

    IDocumentMarkAccess* pMarksAccess = pDoc->getIDocumentMarkAccess();
    IDocumentMarkAccess::const_iterator_t pMark = pMarksAccess->findAnnotationMark( pPostItField->GetName() );
    return pMark != pMarksAccess->getAnnotationMarksEnd()
           ? pMark->get()
           : NULL;
}