| /************************************************************** |
| * |
| * 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 <hintids.hxx> |
| #include <editeng/frmdiritem.hxx> |
| #include <editeng/protitem.hxx> |
| #include <com/sun/star/i18n/CharacterIteratorMode.hdl> |
| #include <fmtcntnt.hxx> |
| #include <fmtanchr.hxx> |
| #include <frmfmt.hxx> |
| #include <txtftn.hxx> |
| #include <ftnfrm.hxx> |
| #include <doc.hxx> |
| #include <docary.hxx> |
| #include <node.hxx> |
| #include <ndindex.hxx> |
| #include <numrule.hxx> |
| #include <swtable.hxx> |
| #include <ndtxt.hxx> |
| #include <pam.hxx> |
| #include <swcache.hxx> |
| #include <section.hxx> |
| #include <cntfrm.hxx> |
| #include <flyfrm.hxx> |
| #include <txtfrm.hxx> |
| #include <tabfrm.hxx> // SwTabFrm |
| #include <viewsh.hxx> |
| #include <paratr.hxx> |
| #include <ftnidx.hxx> |
| #include <fmtftn.hxx> |
| #include <fmthdft.hxx> |
| #include <frmatr.hxx> |
| #include <fmtautofmt.hxx> |
| #include <frmtool.hxx> |
| #include <pagefrm.hxx> |
| #include <node2lay.hxx> |
| #include <pagedesc.hxx> |
| #include <fmtpdsc.hxx> |
| #include <breakit.hxx> |
| #include <crsskip.hxx> |
| #include <SwStyleNameMapper.hxx> |
| #include <scriptinfo.hxx> |
| #include <rootfrm.hxx> |
| #include <istyleaccess.hxx> |
| #include <IDocumentListItems.hxx> |
| #include <switerator.hxx> |
| #include "ndole.hxx" |
| |
| using namespace ::com::sun::star::i18n; |
| |
| TYPEINIT2( SwCntntNode, SwModify, SwIndexReg ) |
| |
| /* |
| * Some local helper functions for the attribute set handle of a content node. |
| * Since the attribute set of a content node may not be modified directly, |
| * we always have to create a new SwAttrSet, do the modifications, and get |
| * a new handle from the style access |
| */ |
| |
| namespace AttrSetHandleHelper |
| { |
| |
| void GetNewAutoStyle( boost::shared_ptr<const SfxItemSet>& mrpAttrSet, |
| const SwCntntNode& rNode, |
| SwAttrSet& rNewAttrSet ) |
| { |
| const SwAttrSet* pAttrSet = static_cast<const SwAttrSet*>(mrpAttrSet.get()); |
| if( rNode.GetModifyAtAttr() ) |
| const_cast<SwAttrSet*>(pAttrSet)->SetModifyAtAttr( 0 ); |
| IStyleAccess& rSA = pAttrSet->GetPool()->GetDoc()->GetIStyleAccess(); |
| mrpAttrSet = rSA.getAutomaticStyle( rNewAttrSet, rNode.IsTxtNode() ? |
| IStyleAccess::AUTO_STYLE_PARA : |
| IStyleAccess::AUTO_STYLE_NOTXT ); |
| const bool bSetModifyAtAttr = ((SwAttrSet*)mrpAttrSet.get())->SetModifyAtAttr( &rNode ); |
| rNode.SetModifyAtAttr( bSetModifyAtAttr ); |
| } |
| |
| |
| void SetParent( boost::shared_ptr<const SfxItemSet>& mrpAttrSet, |
| const SwCntntNode& rNode, |
| const SwFmt* pParentFmt, |
| const SwFmt* pConditionalFmt ) |
| { |
| const SwAttrSet* pAttrSet = static_cast<const SwAttrSet*>(mrpAttrSet.get()); |
| ASSERT( pAttrSet, "no SwAttrSet" ) |
| ASSERT( pParentFmt || !pConditionalFmt, "ConditionalFmt without ParentFmt?" ) |
| |
| const SwAttrSet* pParentSet = pParentFmt ? &pParentFmt->GetAttrSet() : 0; |
| |
| if ( pParentSet != pAttrSet->GetParent() ) |
| { |
| SwAttrSet aNewSet( *pAttrSet ); |
| aNewSet.SetParent( pParentSet ); |
| aNewSet.ClearItem( RES_FRMATR_STYLE_NAME ); |
| aNewSet.ClearItem( RES_FRMATR_CONDITIONAL_STYLE_NAME ); |
| String sVal; |
| |
| if ( pParentFmt ) |
| { |
| SwStyleNameMapper::FillProgName( pParentFmt->GetName(), sVal, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True ); |
| const SfxStringItem aAnyFmtColl( RES_FRMATR_STYLE_NAME, sVal ); |
| aNewSet.Put( aAnyFmtColl ); |
| |
| if ( pConditionalFmt != pParentFmt ) |
| SwStyleNameMapper::FillProgName( pConditionalFmt->GetName(), sVal, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True ); |
| |
| const SfxStringItem aFmtColl( RES_FRMATR_CONDITIONAL_STYLE_NAME, sVal ); |
| aNewSet.Put( aFmtColl ); |
| } |
| |
| GetNewAutoStyle( mrpAttrSet, rNode, aNewSet ); |
| } |
| } |
| |
| const SfxPoolItem* Put( boost::shared_ptr<const SfxItemSet>& mrpAttrSet, |
| const SwCntntNode& rNode, |
| const SfxPoolItem& rAttr ) |
| { |
| SwAttrSet aNewSet( (SwAttrSet&)*mrpAttrSet ); |
| const SfxPoolItem* pRet = aNewSet.Put( rAttr ); |
| if ( pRet ) |
| GetNewAutoStyle( mrpAttrSet, rNode, aNewSet ); |
| return pRet; |
| } |
| |
| int Put( boost::shared_ptr<const SfxItemSet>& mrpAttrSet, const SwCntntNode& rNode, |
| const SfxItemSet& rSet ) |
| { |
| SwAttrSet aNewSet( (SwAttrSet&)*mrpAttrSet ); |
| |
| // --> FME 2007-4-12 #i76273# Robust: Save the style name items: |
| SfxItemSet* pStyleNames = 0; |
| if ( SFX_ITEM_SET == rSet.GetItemState( RES_FRMATR_STYLE_NAME, sal_False ) ) |
| { |
| pStyleNames = new SfxItemSet( *aNewSet.GetPool(), RES_FRMATR_STYLE_NAME, RES_FRMATR_CONDITIONAL_STYLE_NAME ); |
| pStyleNames->Put( aNewSet ); |
| } |
| // <-- |
| |
| const int nRet = aNewSet.Put( rSet ); |
| |
| // --> FME 2007-4-12 #i76273# Robust: Save the style name items: |
| if ( pStyleNames ) |
| { |
| aNewSet.Put( *pStyleNames ); |
| delete pStyleNames; |
| } |
| // <-- |
| |
| if ( nRet ) |
| GetNewAutoStyle( mrpAttrSet, rNode, aNewSet ); |
| |
| return nRet; |
| } |
| |
| int Put_BC( boost::shared_ptr<const SfxItemSet>& mrpAttrSet, |
| const SwCntntNode& rNode, const SfxPoolItem& rAttr, |
| SwAttrSet* pOld, SwAttrSet* pNew ) |
| { |
| SwAttrSet aNewSet( (SwAttrSet&)*mrpAttrSet ); |
| |
| // for a correct broadcast, we need to do a SetModifyAtAttr with the items |
| // from aNewSet. The 'regular' SetModifyAtAttr is done in GetNewAutoStyle |
| if( rNode.GetModifyAtAttr() ) |
| aNewSet.SetModifyAtAttr( &rNode ); |
| |
| const int nRet = aNewSet.Put_BC( rAttr, pOld, pNew ); |
| |
| if ( nRet ) |
| GetNewAutoStyle( mrpAttrSet, rNode, aNewSet ); |
| |
| return nRet; |
| } |
| |
| int Put_BC( boost::shared_ptr<const SfxItemSet>& mrpAttrSet, |
| const SwCntntNode& rNode, const SfxItemSet& rSet, |
| SwAttrSet* pOld, SwAttrSet* pNew ) |
| { |
| SwAttrSet aNewSet( (SwAttrSet&)*mrpAttrSet ); |
| |
| // --> FME 2007-4-12 #i76273# Robust: Save the style name items: |
| SfxItemSet* pStyleNames = 0; |
| if ( SFX_ITEM_SET == rSet.GetItemState( RES_FRMATR_STYLE_NAME, sal_False ) ) |
| { |
| pStyleNames = new SfxItemSet( *aNewSet.GetPool(), RES_FRMATR_STYLE_NAME, RES_FRMATR_CONDITIONAL_STYLE_NAME ); |
| pStyleNames->Put( aNewSet ); |
| } |
| // <-- |
| |
| // for a correct broadcast, we need to do a SetModifyAtAttr with the items |
| // from aNewSet. The 'regular' SetModifyAtAttr is done in GetNewAutoStyle |
| if( rNode.GetModifyAtAttr() ) |
| aNewSet.SetModifyAtAttr( &rNode ); |
| |
| const int nRet = aNewSet.Put_BC( rSet, pOld, pNew ); |
| |
| // --> FME 2007-4-12 #i76273# Robust: Save the style name items: |
| if ( pStyleNames ) |
| { |
| aNewSet.Put( *pStyleNames ); |
| delete pStyleNames; |
| } |
| // <-- |
| |
| if ( nRet ) |
| GetNewAutoStyle( mrpAttrSet, rNode, aNewSet ); |
| |
| return nRet; |
| } |
| |
| sal_uInt16 ClearItem_BC( boost::shared_ptr<const SfxItemSet>& mrpAttrSet, |
| const SwCntntNode& rNode, sal_uInt16 nWhich, |
| SwAttrSet* pOld, SwAttrSet* pNew ) |
| { |
| SwAttrSet aNewSet( (SwAttrSet&)*mrpAttrSet ); |
| if( rNode.GetModifyAtAttr() ) |
| aNewSet.SetModifyAtAttr( &rNode ); |
| const sal_uInt16 nRet = aNewSet.ClearItem_BC( nWhich, pOld, pNew ); |
| if ( nRet ) |
| GetNewAutoStyle( mrpAttrSet, rNode, aNewSet ); |
| return nRet; |
| } |
| |
| sal_uInt16 ClearItem_BC( boost::shared_ptr<const SfxItemSet>& mrpAttrSet, |
| const SwCntntNode& rNode, |
| sal_uInt16 nWhich1, sal_uInt16 nWhich2, |
| SwAttrSet* pOld, SwAttrSet* pNew ) |
| { |
| SwAttrSet aNewSet( (SwAttrSet&)*mrpAttrSet ); |
| if( rNode.GetModifyAtAttr() ) |
| aNewSet.SetModifyAtAttr( &rNode ); |
| const sal_uInt16 nRet = aNewSet.ClearItem_BC( nWhich1, nWhich2, pOld, pNew ); |
| if ( nRet ) |
| GetNewAutoStyle( mrpAttrSet, rNode, aNewSet ); |
| return nRet; |
| } |
| |
| } |
| |
| /******************************************************************* |
| |* |
| |* SwNode::GetSectionLevel |
| |* |
| |* Beschreibung |
| |* Die Funktion liefert den Sectionlevel an der durch |
| |* aIndex bezeichneten Position. |
| |* |
| |* Die Logik ist wie folgt: ( S -> Start, E -> End, C -> CntntNode) |
| |* Level 0 E |
| |* 1 S E |
| |* 2 SC |
| |* |
| |* alle EndNodes der GrundSection haben den Level 0 |
| |* alle StartNodes der GrundSection haben den Level 1 |
| |* |
| |* Ersterstellung |
| |* VER0100 vb 901214 |
| |* |
| |* Aenderung: JP 11.08.93 |
| |* keine Rekursion mehr !! |
| |* |
| *******************************************************************/ |
| |
| |
| sal_uInt16 SwNode::GetSectionLevel() const |
| { |
| // EndNode einer Grund-Section ?? diese sind immer 0 !! |
| if( IsEndNode() && 0 == pStartOfSection->StartOfSectionIndex() ) |
| return 0; |
| |
| sal_uInt16 nLevel; |
| const SwNode* pNode = IsStartNode() ? this : pStartOfSection; |
| for( nLevel = 1; 0 != pNode->StartOfSectionIndex(); ++nLevel ) |
| pNode = pNode->pStartOfSection; |
| return IsEndNode() ? nLevel-1 : nLevel; |
| } |
| |
| /******************************************************************* |
| |* |
| |* SwNode::SwNode |
| |* |
| |* Beschreibung |
| |* Konstruktor; dieser fuegt einen Node in das Array rNodes |
| |* an der Position rWhere ein. Dieser bekommt als |
| |* theEndOfSection den EndOfSection-Index des Nodes |
| |* unmittelbar vor ihm. Falls er sich an der Position 0 |
| |* innerhalb des variablen Arrays befindet, wird |
| |* theEndOfSection 0 (der neue selbst). |
| |* |
| |* Parameter |
| |* IN |
| |* rNodes bezeichnet das variable Array, in das der Node |
| |* eingefuegt werden soll |
| |* IN |
| |* rWhere bezeichnet die Position innerhalb dieses Arrays, |
| |* an der der Node eingefuegt werden soll |
| |* |
| |* Ersterstellung |
| |* VER0100 vb 901214 |
| |* |
| |* Stand |
| |* VER0100 vb 901214 |
| |* |
| *******************************************************************/ |
| |
| #ifdef DBG_UTIL |
| long SwNode::nSerial = 0; |
| #endif |
| |
| SwNode::SwNode( const SwNodeIndex &rWhere, const sal_uInt8 nNdType ) |
| : nNodeType( nNdType ), pStartOfSection( 0 ) |
| { |
| bSetNumLSpace = bIgnoreDontExpand = sal_False; |
| nAFmtNumLvl = 0; |
| |
| SwNodes& rNodes = (SwNodes&)rWhere.GetNodes(); |
| SwNode* pInsNd = this; // der MAC kann this nicht einfuegen !! |
| if( rWhere.GetIndex() ) |
| { |
| SwNode* pNd = rNodes[ rWhere.GetIndex() -1 ]; |
| rNodes.InsertNode( pInsNd, rWhere ); |
| if( 0 == ( pStartOfSection = pNd->GetStartNode()) ) |
| { |
| pStartOfSection = pNd->pStartOfSection; |
| if( pNd->GetEndNode() ) // EndNode ? Section ueberspringen! |
| { |
| pNd = pStartOfSection; |
| pStartOfSection = pNd->pStartOfSection; |
| } |
| } |
| } |
| else |
| { |
| rNodes.InsertNode( pInsNd, rWhere ); |
| pStartOfSection = (SwStartNode*)this; |
| } |
| |
| #ifdef DBG_UTIL |
| nMySerial = nSerial; |
| nSerial++; |
| #endif |
| } |
| |
| SwNode::SwNode( SwNodes& rNodes, sal_uLong nPos, const sal_uInt8 nNdType ) |
| : nNodeType( nNdType ), pStartOfSection( 0 ) |
| { |
| bSetNumLSpace = bIgnoreDontExpand = sal_False; |
| nAFmtNumLvl = 0; |
| |
| SwNode* pInsNd = this; // der MAC kann this nicht einfuegen !! |
| if( nPos ) |
| { |
| SwNode* pNd = rNodes[ nPos - 1 ]; |
| rNodes.InsertNode( pInsNd, nPos ); |
| if( 0 == ( pStartOfSection = pNd->GetStartNode()) ) |
| { |
| pStartOfSection = pNd->pStartOfSection; |
| if( pNd->GetEndNode() ) // EndNode ? Section ueberspringen! |
| { |
| pNd = pStartOfSection; |
| pStartOfSection = pNd->pStartOfSection; |
| } |
| } |
| } |
| else |
| { |
| rNodes.InsertNode( pInsNd, nPos ); |
| pStartOfSection = (SwStartNode*)this; |
| } |
| |
| #ifdef DBG_UTIL |
| nMySerial = nSerial; |
| nSerial++; |
| #endif |
| } |
| |
| SwNode::~SwNode() |
| { |
| } |
| |
| // suche den TabellenNode, in dem dieser steht. Wenn in keiner |
| // Tabelle wird 0 returnt. |
| |
| |
| SwTableNode* SwNode::FindTableNode() |
| { |
| if( IsTableNode() ) |
| return GetTableNode(); |
| SwStartNode* pTmp = pStartOfSection; |
| while( !pTmp->IsTableNode() && pTmp->GetIndex() ) |
| #if defined( ALPHA ) && defined( UNX ) |
| pTmp = ((SwNode*)pTmp)->pStartOfSection; |
| #else |
| pTmp = pTmp->pStartOfSection; |
| #endif |
| return pTmp->GetTableNode(); |
| } |
| |
| |
| // liegt der Node im Sichtbarenbereich der Shell ? |
| sal_Bool SwNode::IsInVisibleArea( ViewShell* pSh ) const |
| { |
| sal_Bool bRet = sal_False; |
| const SwCntntNode* pNd; |
| |
| if( ND_STARTNODE & nNodeType ) |
| { |
| SwNodeIndex aIdx( *this ); |
| pNd = GetNodes().GoNext( &aIdx ); |
| } |
| else if( ND_ENDNODE & nNodeType ) |
| { |
| SwNodeIndex aIdx( *EndOfSectionNode() ); |
| pNd = GetNodes().GoPrevious( &aIdx ); |
| } |
| else |
| pNd = GetCntntNode(); |
| |
| if( !pSh ) |
| // dann die Shell vom Doc besorgen: |
| GetDoc()->GetEditShell( &pSh ); |
| |
| if( pSh ) |
| { |
| const SwFrm* pFrm; |
| if( pNd && 0 != ( pFrm = pNd->getLayoutFrm( pSh->GetLayout(), 0, 0, sal_False ) ) ) |
| { |
| |
| if ( pFrm->IsInTab() ) |
| pFrm = pFrm->FindTabFrm(); |
| |
| if( !pFrm->IsValid() ) |
| do |
| { pFrm = pFrm->FindPrev(); |
| } while ( pFrm && !pFrm->IsValid() ); |
| |
| if( !pFrm || pSh->VisArea().IsOver( pFrm->Frm() ) ) |
| bRet = sal_True; |
| } |
| } |
| |
| return bRet; |
| } |
| |
| sal_Bool SwNode::IsInProtectSect() const |
| { |
| const SwNode* pNd = ND_SECTIONNODE == nNodeType ? pStartOfSection : this; |
| const SwSectionNode* pSectNd = pNd->FindSectionNode(); |
| return pSectNd && pSectNd->GetSection().IsProtectFlag(); |
| } |
| |
| // befindet sich der Node in irgendetwas geschuetzten ? |
| // (Bereich/Rahmen/Tabellenzellen/... incl. des Ankers bei |
| // Rahmen/Fussnoten/..) |
| sal_Bool SwNode::IsProtect() const |
| { |
| const SwNode* pNd = ND_SECTIONNODE == nNodeType ? pStartOfSection : this; |
| const SwStartNode* pSttNd = pNd->FindSectionNode(); |
| if( pSttNd && ((SwSectionNode*)pSttNd)->GetSection().IsProtectFlag() ) |
| return sal_True; |
| |
| if( 0 != ( pSttNd = FindTableBoxStartNode() ) ) |
| { |
| SwCntntFrm* pCFrm; |
| if( IsCntntNode() && 0 != (pCFrm = ((SwCntntNode*)this)->getLayoutFrm( GetDoc()->GetCurrentLayout() ) )) |
| return pCFrm->IsProtected(); |
| |
| const SwTableBox* pBox = pSttNd->FindTableNode()->GetTable(). |
| GetTblBox( pSttNd->GetIndex() ); |
| //Robust #149568 |
| if( pBox && pBox->GetFrmFmt()->GetProtect().IsCntntProtected() ) |
| return sal_True; |
| } |
| |
| SwFrmFmt* pFlyFmt = GetFlyFmt(); |
| if( pFlyFmt ) |
| { |
| if( pFlyFmt->GetProtect().IsCntntProtected() ) |
| return sal_True; |
| const SwFmtAnchor& rAnchor = pFlyFmt->GetAnchor(); |
| return rAnchor.GetCntntAnchor() |
| ? rAnchor.GetCntntAnchor()->nNode.GetNode().IsProtect() |
| : sal_False; |
| } |
| |
| if( 0 != ( pSttNd = FindFootnoteStartNode() ) ) |
| { |
| const SwTxtFtn* pTFtn = GetDoc()->GetFtnIdxs().SeekEntry( |
| SwNodeIndex( *pSttNd ) ); |
| if( pTFtn ) |
| return pTFtn->GetTxtNode().IsProtect(); |
| } |
| |
| return sal_False; |
| } |
| |
| // suche den PageDesc, mit dem dieser Node formatiert ist. Wenn das |
| // Layout vorhanden ist wird ueber das gesucht, ansonsten gibt es nur |
| // die harte Tour ueber die Nodes nach vorne suchen!! |
| const SwPageDesc* SwNode::FindPageDesc( sal_Bool bCalcLay, |
| sal_uInt32* pPgDescNdIdx ) const |
| { |
| // OD 18.03.2003 #106329# |
| if ( !GetNodes().IsDocNodes() ) |
| { |
| return 0; |
| } |
| |
| const SwPageDesc* pPgDesc = 0; |
| |
| const SwCntntNode* pNode; |
| if( ND_STARTNODE & nNodeType ) |
| { |
| SwNodeIndex aIdx( *this ); |
| pNode = GetNodes().GoNext( &aIdx ); |
| } |
| else if( ND_ENDNODE & nNodeType ) |
| { |
| SwNodeIndex aIdx( *EndOfSectionNode() ); |
| pNode = GetNodes().GoPrevious( &aIdx ); |
| } |
| else |
| { |
| pNode = GetCntntNode(); |
| if( pNode ) |
| pPgDesc = ((SwFmtPageDesc&)pNode->GetAttr( RES_PAGEDESC )).GetPageDesc(); |
| } |
| |
| // geht es uebers Layout? |
| if( !pPgDesc ) |
| { |
| const SwFrm* pFrm; |
| const SwPageFrm* pPage; |
| if( pNode && 0 != ( pFrm = pNode->getLayoutFrm( pNode->GetDoc()->GetCurrentLayout(), 0, 0, bCalcLay ) ) && |
| 0 != ( pPage = pFrm->FindPageFrm() ) ) |
| { |
| pPgDesc = pPage->GetPageDesc(); |
| // OD 18.03.2003 #106329# |
| if ( pPgDescNdIdx ) |
| { |
| *pPgDescNdIdx = pNode->GetIndex(); |
| } |
| } |
| } |
| |
| if( !pPgDesc ) |
| { |
| // dann also uebers Nodes-Array |
| const SwDoc* pDoc = GetDoc(); |
| const SwNode* pNd = this; |
| const SwStartNode* pSttNd; |
| if( pNd->GetIndex() < GetNodes().GetEndOfExtras().GetIndex() && |
| 0 != ( pSttNd = pNd->FindFlyStartNode() ) ) |
| { |
| // dann erstmal den richtigen Anker finden |
| const SwFrmFmt* pFmt = 0; |
| const SwSpzFrmFmts& rFmts = *pDoc->GetSpzFrmFmts(); |
| sal_uInt16 n; |
| |
| for( n = 0; n < rFmts.Count(); ++n ) |
| { |
| SwFrmFmt* pFrmFmt = rFmts[ n ]; |
| const SwFmtCntnt& rCntnt = pFrmFmt->GetCntnt(); |
| if( rCntnt.GetCntntIdx() && |
| &rCntnt.GetCntntIdx()->GetNode() == (SwNode*)pSttNd ) |
| { |
| pFmt = pFrmFmt; |
| break; |
| } |
| } |
| |
| if( pFmt ) |
| { |
| const SwFmtAnchor* pAnchor = &pFmt->GetAnchor(); |
| if ((FLY_AT_PAGE != pAnchor->GetAnchorId()) && |
| pAnchor->GetCntntAnchor() ) |
| { |
| pNd = &pAnchor->GetCntntAnchor()->nNode.GetNode(); |
| const SwNode* pFlyNd = pNd->FindFlyStartNode(); |
| while( pFlyNd ) |
| { |
| // dann ueber den Anker nach oben "hangeln" |
| for( n = 0; n < rFmts.Count(); ++n ) |
| { |
| const SwFrmFmt* pFrmFmt = rFmts[ n ]; |
| const SwNodeIndex* pIdx = pFrmFmt->GetCntnt(). |
| GetCntntIdx(); |
| if( pIdx && pFlyNd == &pIdx->GetNode() ) |
| { |
| if( pFmt == pFrmFmt ) |
| { |
| pNd = pFlyNd; |
| pFlyNd = 0; |
| break; |
| } |
| pAnchor = &pFrmFmt->GetAnchor(); |
| if ((FLY_AT_PAGE == pAnchor->GetAnchorId()) || |
| !pAnchor->GetCntntAnchor() ) |
| { |
| pFlyNd = 0; |
| break; |
| } |
| |
| pFlyNd = pAnchor->GetCntntAnchor()->nNode. |
| GetNode().FindFlyStartNode(); |
| break; |
| } |
| } |
| if( n >= rFmts.Count() ) |
| { |
| ASSERT( !this, "Fly-Section but no format found" ); |
| return NULL; |
| } |
| } |
| } |
| } |
| // in pNd sollte jetzt der richtige Anker Node stehen oder |
| // immer noch der this |
| } |
| |
| if( pNd->GetIndex() < GetNodes().GetEndOfExtras().GetIndex() ) |
| { |
| if( pNd->GetIndex() > GetNodes().GetEndOfAutotext().GetIndex() ) |
| { |
| pPgDesc = &pDoc->GetPageDesc( 0 ); |
| pNd = 0; |
| } |
| else |
| { |
| // suche den Body Textnode |
| if( 0 != ( pSttNd = pNd->FindHeaderStartNode() ) || |
| 0 != ( pSttNd = pNd->FindFooterStartNode() )) |
| { |
| // dann in den PageDescs diesen StartNode suchen |
| sal_uInt16 nId; |
| UseOnPage eAskUse; |
| if( SwHeaderStartNode == pSttNd->GetStartNodeType()) |
| { |
| nId = RES_HEADER; |
| eAskUse = nsUseOnPage::PD_HEADERSHARE; |
| } |
| else |
| { |
| nId = RES_FOOTER; |
| eAskUse = nsUseOnPage::PD_FOOTERSHARE; |
| } |
| |
| for( sal_uInt16 n = pDoc->GetPageDescCnt(); n && !pPgDesc; ) |
| { |
| const SwPageDesc& rPgDsc = pDoc->GetPageDesc( --n ); |
| const SwFrmFmt* pFmt = &rPgDsc.GetMaster(); |
| int nStt = 0, nLast = 1; |
| if( !( eAskUse & rPgDsc.ReadUseOn() )) ++nLast; |
| |
| for( ; nStt < nLast; ++nStt, pFmt = &rPgDsc.GetLeft() ) |
| { |
| const SwFmtHeader& rHdFt = (SwFmtHeader&) |
| pFmt->GetFmtAttr( nId ); |
| if( rHdFt.GetHeaderFmt() ) |
| { |
| const SwFmtCntnt& rCntnt = |
| rHdFt.GetHeaderFmt()->GetCntnt(); |
| if( rCntnt.GetCntntIdx() && |
| &rCntnt.GetCntntIdx()->GetNode() == |
| (SwNode*)pSttNd ) |
| { |
| pPgDesc = &rPgDsc; |
| break; |
| } |
| } |
| } |
| } |
| |
| if( !pPgDesc ) |
| pPgDesc = &pDoc->GetPageDesc( 0 ); |
| pNd = 0; |
| } |
| else if( 0 != ( pSttNd = pNd->FindFootnoteStartNode() )) |
| { |
| // der Anker kann nur im Bodytext sein |
| const SwTxtFtn* pTxtFtn; |
| const SwFtnIdxs& rFtnArr = pDoc->GetFtnIdxs(); |
| for( sal_uInt16 n = 0; n < rFtnArr.Count(); ++n ) |
| if( 0 != ( pTxtFtn = rFtnArr[ n ])->GetStartNode() && |
| (SwNode*)pSttNd == |
| &pTxtFtn->GetStartNode()->GetNode() ) |
| { |
| pNd = &pTxtFtn->GetTxtNode(); |
| break; |
| } |
| } |
| else |
| { |
| // kann jetzt nur noch ein Seitengebundener Fly sein |
| // oder irgendetwas neueres. |
| // Hier koennen wir nur noch den Standard returnen |
| ASSERT( pNd->FindFlyStartNode(), |
| "wo befindet sich dieser Node?" ); |
| |
| pPgDesc = &pDoc->GetPageDesc( 0 ); |
| pNd = 0; |
| } |
| } |
| } |
| |
| if( pNd ) |
| { |
| SwFindNearestNode aInfo( *pNd ); |
| // dann ueber alle Nodes aller PageDesc |
| const SfxPoolItem* pItem; |
| sal_uInt32 i, nMaxItems = pDoc->GetAttrPool().GetItemCount2( RES_PAGEDESC ); |
| for( i = 0; i < nMaxItems; ++i ) |
| if( 0 != (pItem = pDoc->GetAttrPool().GetItem2( RES_PAGEDESC, i ) ) && |
| ((SwFmtPageDesc*)pItem)->GetDefinedIn() ) |
| { |
| const SwModify* pMod = ((SwFmtPageDesc*)pItem)->GetDefinedIn(); |
| if( pMod->ISA( SwCntntNode ) ) |
| aInfo.CheckNode( *(SwCntntNode*)pMod ); |
| else if( pMod->ISA( SwFmt )) |
| ((SwFmt*)pMod)->GetInfo( aInfo ); |
| } |
| |
| if( 0 != ( pNd = aInfo.GetFoundNode() )) |
| { |
| if( pNd->IsCntntNode() ) |
| pPgDesc = ((SwFmtPageDesc&)pNd->GetCntntNode()-> |
| GetAttr( RES_PAGEDESC )).GetPageDesc(); |
| else if( pNd->IsTableNode() ) |
| pPgDesc = pNd->GetTableNode()->GetTable(). |
| GetFrmFmt()->GetPageDesc().GetPageDesc(); |
| else if( pNd->IsSectionNode() ) |
| pPgDesc = pNd->GetSectionNode()->GetSection(). |
| GetFmt()->GetPageDesc().GetPageDesc(); |
| // OD 18.03.2003 #106329# |
| if ( pPgDescNdIdx ) |
| { |
| *pPgDescNdIdx = pNd->GetIndex(); |
| } |
| } |
| if( !pPgDesc ) |
| pPgDesc = &pDoc->GetPageDesc( 0 ); |
| } |
| } |
| return pPgDesc; |
| } |
| |
| |
| // falls der Node in einem Fly steht, dann wird das entsprechende Format |
| // returnt |
| SwFrmFmt* SwNode::GetFlyFmt() const |
| { |
| SwFrmFmt* pRet = 0; |
| const SwNode* pSttNd = FindFlyStartNode(); |
| if( pSttNd ) |
| { |
| if( IsCntntNode() ) |
| { |
| SwCntntFrm* pFrm = SwIterator<SwCntntFrm,SwCntntNode>::FirstElement( *(SwCntntNode*)this ); |
| if( pFrm ) |
| pRet = pFrm->FindFlyFrm()->GetFmt(); |
| } |
| if( !pRet ) |
| { |
| // dann gibts noch harten steinigen Weg uebers Dokument: |
| const SwSpzFrmFmts& rFrmFmtTbl = *GetDoc()->GetSpzFrmFmts(); |
| for( sal_uInt16 n = 0; n < rFrmFmtTbl.Count(); ++n ) |
| { |
| SwFrmFmt* pFmt = rFrmFmtTbl[n]; |
| const SwFmtCntnt& rCntnt = pFmt->GetCntnt(); |
| if( rCntnt.GetCntntIdx() && |
| &rCntnt.GetCntntIdx()->GetNode() == pSttNd ) |
| { |
| pRet = pFmt; |
| break; |
| } |
| } |
| } |
| } |
| return pRet; |
| } |
| |
| SwTableBox* SwNode::GetTblBox() const |
| { |
| SwTableBox* pBox = 0; |
| const SwNode* pSttNd = FindTableBoxStartNode(); |
| if( pSttNd ) |
| pBox = (SwTableBox*)pSttNd->FindTableNode()->GetTable().GetTblBox( |
| pSttNd->GetIndex() ); |
| return pBox; |
| } |
| |
| SwStartNode* SwNode::FindSttNodeByType( SwStartNodeType eTyp ) |
| { |
| SwStartNode* pTmp = IsStartNode() ? (SwStartNode*)this : pStartOfSection; |
| |
| while( eTyp != pTmp->GetStartNodeType() && pTmp->GetIndex() ) |
| #if defined( ALPHA ) && defined( UNX ) |
| pTmp = ((SwNode*)pTmp)->pStartOfSection; |
| #else |
| pTmp = pTmp->pStartOfSection; |
| #endif |
| return eTyp == pTmp->GetStartNodeType() ? pTmp : 0; |
| } |
| |
| const SwTxtNode* SwNode::FindOutlineNodeOfLevel( sal_uInt8 nLvl ) const |
| { |
| const SwTxtNode* pRet = 0; |
| const SwOutlineNodes& rONds = GetNodes().GetOutLineNds(); |
| if( MAXLEVEL > nLvl && rONds.Count() ) |
| { |
| sal_uInt16 nPos; |
| SwNode* pNd = (SwNode*)this; |
| sal_Bool bCheckFirst = sal_False; |
| if( !rONds.Seek_Entry( pNd, &nPos )) |
| { |
| if( nPos ) |
| nPos = nPos-1; |
| else |
| bCheckFirst = sal_True; |
| } |
| |
| if( bCheckFirst ) |
| { |
| // der 1.GliederungsNode liegt hinter dem Fragenden. Dann |
| // teste mal, ob dieser auf der gleichen Seite steht. Wenn |
| // nicht, ist das ein ungueltiger. Bug 61865 |
| pRet = rONds[0]->GetTxtNode(); |
| |
| const SwCntntNode* pCNd = GetCntntNode(); |
| |
| Point aPt( 0, 0 ); |
| const SwFrm* pFrm = pRet->getLayoutFrm( pRet->GetDoc()->GetCurrentLayout(), &aPt, 0, sal_False ), |
| * pMyFrm = pCNd ? pCNd->getLayoutFrm( pCNd->GetDoc()->GetCurrentLayout(), &aPt, 0, sal_False ) : 0; |
| const SwPageFrm* pPgFrm = pFrm ? pFrm->FindPageFrm() : 0; |
| if( pPgFrm && pMyFrm && |
| pPgFrm->Frm().Top() > pMyFrm->Frm().Top() ) |
| { |
| // der Fragende liegt vor der Seite, also ist er ungueltig |
| pRet = 0; |
| } |
| } |
| else |
| { |
| // oder ans Feld und von dort holen !! |
| while( nPos && |
| nLvl < ( pRet = rONds[nPos]->GetTxtNode() ) |
| //->GetTxtColl()->GetOutlineLevel() )//#outline level,zhaojianwei |
| ->GetAttrOutlineLevel() - 1 ) //<-end,zhaojianwei |
| --nPos; |
| |
| if( !nPos ) // bei 0 gesondert holen !! |
| pRet = rONds[0]->GetTxtNode(); |
| } |
| } |
| return pRet; |
| } |
| |
| inline sal_Bool IsValidNextPrevNd( const SwNode& rNd ) |
| { |
| return ND_TABLENODE == rNd.GetNodeType() || |
| ( ND_CONTENTNODE & rNd.GetNodeType() ) || |
| ( ND_ENDNODE == rNd.GetNodeType() && rNd.StartOfSectionNode() && |
| ND_TABLENODE == rNd.StartOfSectionNode()->GetNodeType() ); |
| } |
| |
| sal_uInt8 SwNode::HasPrevNextLayNode() const |
| { |
| // assumption: <this> node is a node inside the document nodes array section. |
| |
| sal_uInt8 nRet = 0; |
| if( IsValidNextPrevNd( *this )) |
| { |
| SwNodeIndex aIdx( *this, -1 ); |
| // --> OD 2007-06-04 #i77805# |
| // skip section start and end nodes |
| while ( aIdx.GetNode().IsSectionNode() || |
| ( aIdx.GetNode().IsEndNode() && |
| aIdx.GetNode().StartOfSectionNode()->IsSectionNode() ) ) |
| { |
| --aIdx; |
| } |
| // <-- |
| if( IsValidNextPrevNd( aIdx.GetNode() )) |
| nRet |= ND_HAS_PREV_LAYNODE; |
| // --> OD 2007-06-04 #i77805# |
| // skip section start and end nodes |
| // aIdx += 2; |
| aIdx = SwNodeIndex( *this, +1 ); |
| while ( aIdx.GetNode().IsSectionNode() || |
| ( aIdx.GetNode().IsEndNode() && |
| aIdx.GetNode().StartOfSectionNode()->IsSectionNode() ) ) |
| { |
| ++aIdx; |
| } |
| // <-- |
| if( IsValidNextPrevNd( aIdx.GetNode() )) |
| nRet |= ND_HAS_NEXT_LAYNODE; |
| } |
| return nRet; |
| } |
| |
| /******************************************************************* |
| |* |
| |* SwNode::StartOfSection |
| |* |
| |* Beschreibung |
| |* Die Funktion liefert die StartOfSection des Nodes. |
| |* |
| |* Parameter |
| |* IN |
| |* rNodes bezeichnet das variable Array, in dem sich der Node |
| |* befindet |
| |* Ersterstellung |
| |* VER0100 vb 901214 |
| |* |
| |* Stand |
| |* VER0100 vb 901214 |
| |* |
| *******************************************************************/ |
| |
| |
| SwStartNode::SwStartNode( const SwNodeIndex &rWhere, const sal_uInt8 nNdType, |
| SwStartNodeType eSttNd ) |
| : SwNode( rWhere, nNdType ), eSttNdTyp( eSttNd ) |
| { |
| // erstmal temporaer, bis der EndNode eingefuegt wird. |
| pEndOfSection = (SwEndNode*)this; |
| } |
| |
| SwStartNode::SwStartNode( SwNodes& rNodes, sal_uLong nPos ) |
| : SwNode( rNodes, nPos, ND_STARTNODE ), eSttNdTyp( SwNormalStartNode ) |
| { |
| // erstmal temporaer, bis der EndNode eingefuegt wird. |
| pEndOfSection = (SwEndNode*)this; |
| } |
| |
| |
| void SwStartNode::CheckSectionCondColl() const |
| { |
| //FEATURE::CONDCOLL |
| SwNodeIndex aIdx( *this ); |
| sal_uLong nEndIdx = EndOfSectionIndex(); |
| const SwNodes& rNds = GetNodes(); |
| SwCntntNode* pCNd; |
| while( 0 != ( pCNd = rNds.GoNext( &aIdx )) && pCNd->GetIndex() < nEndIdx ) |
| pCNd->ChkCondColl(); |
| //FEATURE::CONDCOLL |
| } |
| |
| /******************************************************************* |
| |* |
| |* SwEndNode::SwEndNode |
| |* |
| |* Beschreibung |
| |* Konstruktor; dieser fuegt einen Node in das Array rNodes |
| |* an der Position aWhere ein. Der |
| |* theStartOfSection-Pointer wird entsprechend gesetzt, |
| |* und der EndOfSection-Pointer des zugehoerigen |
| |* Startnodes -- durch rStartOfSection bezeichnet -- |
| |* wird auf diesen Node gesetzt. |
| |* |
| |* Parameter |
| |* IN |
| |* rNodes bezeichnet das variable Array, in das der Node |
| |* eingefuegt werden soll |
| |* IN |
| |* aWhere bezeichnet die Position innerhalb dieses Arrays, |
| |* an der der Node eingefuegt werden soll |
| |* !!!!!!!!!!!! |
| |* Es wird eine Kopie uebergeben! |
| |* |
| |* Ersterstellung |
| |* VER0100 vb 901214 |
| |* |
| |* Stand |
| |* VER0100 vb 901214 |
| |* |
| *******************************************************************/ |
| |
| |
| SwEndNode::SwEndNode( const SwNodeIndex &rWhere, SwStartNode& rSttNd ) |
| : SwNode( rWhere, ND_ENDNODE ) |
| { |
| pStartOfSection = &rSttNd; |
| pStartOfSection->pEndOfSection = this; |
| } |
| |
| SwEndNode::SwEndNode( SwNodes& rNds, sal_uLong nPos, SwStartNode& rSttNd ) |
| : SwNode( rNds, nPos, ND_ENDNODE ) |
| { |
| pStartOfSection = &rSttNd; |
| pStartOfSection->pEndOfSection = this; |
| } |
| |
| |
| |
| // -------------------- |
| // SwCntntNode |
| // -------------------- |
| |
| |
| SwCntntNode::SwCntntNode( const SwNodeIndex &rWhere, const sal_uInt8 nNdType, |
| SwFmtColl *pColl ) |
| : SwModify( pColl ), // CrsrsShell, FrameFmt, |
| SwNode( rWhere, nNdType ), |
| pCondColl( 0 ), |
| mbSetModifyAtAttr( false ) |
| #ifdef OLD_INDEX |
| ,SwIndexReg(2) |
| #endif |
| { |
| } |
| |
| |
| SwCntntNode::~SwCntntNode() |
| { |
| // Die Basisklasse SwClient vom SwFrm nimmt sich aus |
| // der Abhaengikeitsliste raus! |
| // Daher muessen alle Frames in der Abhaengigkeitsliste geloescht werden. |
| if( GetDepends() ) |
| DelFrms(sal_True, sal_False); |
| |
| if( pCondColl ) |
| delete pCondColl; |
| |
| if ( mpAttrSet.get() && mbSetModifyAtAttr ) |
| ((SwAttrSet*)mpAttrSet.get())->SetModifyAtAttr( 0 ); |
| } |
| |
| void SwCntntNode::Modify( const SfxPoolItem* pOldValue, const SfxPoolItem* pNewValue ) |
| { |
| sal_uInt16 nWhich = pOldValue ? pOldValue->Which() : |
| pNewValue ? pNewValue->Which() : 0 ; |
| |
| switch( nWhich ) |
| { |
| case RES_OBJECTDYING : |
| { |
| SwFmt * pFmt = (SwFmt *) ((SwPtrMsgPoolItem *)pNewValue)->pObject; |
| |
| // nicht umhaengen wenn dieses das oberste Format ist !! |
| if( GetRegisteredIn() == pFmt ) |
| { |
| if( pFmt->GetRegisteredIn() ) |
| { |
| // wenn Parent, dann im neuen Parent wieder anmelden |
| ((SwModify*)pFmt->GetRegisteredIn())->Add( this ); |
| if ( GetpSwAttrSet() ) |
| AttrSetHandleHelper::SetParent( mpAttrSet, *this, GetFmtColl(), GetFmtColl() ); |
| } |
| else |
| { |
| // sonst auf jeden Fall beim sterbenden abmelden |
| ((SwModify*)GetRegisteredIn())->Remove( this ); |
| if ( GetpSwAttrSet() ) |
| AttrSetHandleHelper::SetParent( mpAttrSet, *this, 0, 0 ); |
| } |
| } |
| } |
| break; |
| |
| |
| case RES_FMT_CHG: |
| // falls mein Format Parent umgesetzt wird, dann melde ich |
| // meinen Attrset beim Neuen an. |
| |
| // sein eigenes Modify ueberspringen !! |
| if( GetpSwAttrSet() && |
| ((SwFmtChg*)pNewValue)->pChangedFmt == GetRegisteredIn() ) |
| { |
| // den Set an den neuen Parent haengen |
| AttrSetHandleHelper::SetParent( mpAttrSet, *this, GetFmtColl(), GetFmtColl() ); |
| } |
| break; |
| //FEATURE::CONDCOLL |
| case RES_CONDCOLL_CONDCHG: |
| if( ((SwCondCollCondChg*)pNewValue)->pChangedFmt == GetRegisteredIn() && |
| &GetNodes() == &GetDoc()->GetNodes() ) |
| { |
| ChkCondColl(); |
| } |
| return ; // nicht an die Basisklasse / Frames weitergeben |
| //FEATURE::CONDCOLL |
| |
| case RES_ATTRSET_CHG: |
| if( GetNodes().IsDocNodes() && IsTxtNode() ) |
| { |
| if( SFX_ITEM_SET == ((SwAttrSetChg*)pOldValue)->GetChgSet()->GetItemState( |
| RES_CHRATR_HIDDEN, sal_False ) ) |
| { |
| ((SwTxtNode*)this)->SetCalcHiddenCharFlags(); |
| } |
| } |
| break; |
| |
| case RES_UPDATE_ATTR: |
| if( GetNodes().IsDocNodes() && IsTxtNode() ) |
| { |
| const sal_uInt16 nTmp = ((SwUpdateAttr*)pNewValue)->nWhichAttr; |
| if ( RES_ATTRSET_CHG == nTmp ) |
| { |
| // anybody wants to do some optimization here? |
| ((SwTxtNode*)this)->SetCalcHiddenCharFlags(); |
| } |
| } |
| break; |
| } |
| |
| NotifyClients( pOldValue, pNewValue ); |
| } |
| |
| sal_Bool SwCntntNode::InvalidateNumRule() |
| { |
| SwNumRule* pRule = 0; |
| const SfxPoolItem* pItem; |
| if( GetNodes().IsDocNodes() && |
| 0 != ( pItem = GetNoCondAttr( RES_PARATR_NUMRULE, sal_True )) && |
| ((SwNumRuleItem*)pItem)->GetValue().Len() && |
| 0 != (pRule = GetDoc()->FindNumRulePtr( |
| ((SwNumRuleItem*)pItem)->GetValue() ) ) ) |
| { |
| pRule->SetInvalidRule( sal_True ); |
| } |
| return 0 != pRule; |
| } |
| |
| SwCntntFrm *SwCntntNode::getLayoutFrm( const SwRootFrm* _pRoot, |
| const Point* pPoint, const SwPosition *pPos, const sal_Bool bCalcFrm ) const |
| { |
| return (SwCntntFrm*) ::GetFrmOfModify( _pRoot, *(SwModify*)this, FRM_CNTNT, |
| pPoint, pPos, bCalcFrm ); |
| } |
| |
| SwRect SwCntntNode::FindLayoutRect( const sal_Bool bPrtArea, const Point* pPoint, |
| const sal_Bool bCalcFrm ) const |
| { |
| SwRect aRet; |
| SwCntntFrm* pFrm = (SwCntntFrm*)::GetFrmOfModify( 0, *(SwModify*)this, |
| FRM_CNTNT, pPoint, 0, bCalcFrm ); |
| if( pFrm ) |
| aRet = bPrtArea ? pFrm->Prt() : pFrm->Frm(); |
| return aRet; |
| } |
| |
| SwRect SwCntntNode::FindPageFrmRect( const sal_Bool bPrtArea, const Point* pPoint, |
| const sal_Bool bCalcFrm ) const |
| { |
| SwRect aRet; |
| SwFrm* pFrm = ::GetFrmOfModify( 0, *(SwModify*)this, |
| FRM_CNTNT, pPoint, 0, bCalcFrm ); |
| if( pFrm && 0 != ( pFrm = pFrm->FindPageFrm() )) |
| aRet = bPrtArea ? pFrm->Prt() : pFrm->Frm(); |
| return aRet; |
| } |
| |
| xub_StrLen SwCntntNode::Len() const { return 0; } |
| |
| |
| |
| SwFmtColl *SwCntntNode::ChgFmtColl( SwFmtColl *pNewColl ) |
| { |
| ASSERT( pNewColl, "Collectionpointer ist 0." ); |
| SwFmtColl *pOldColl = GetFmtColl(); |
| |
| if( pNewColl != pOldColl ) |
| { |
| pNewColl->Add( this ); |
| |
| // setze den Parent von unseren Auto-Attributen auf die neue |
| // Collection: |
| if( GetpSwAttrSet() ) |
| AttrSetHandleHelper::SetParent( mpAttrSet, *this, pNewColl, pNewColl ); |
| |
| //FEATURE::CONDCOLL |
| // HACK: hier muss die entsprechend der neuen Vorlage die Bedingungen |
| // neu ueberprueft werden! |
| if( sal_True /*pNewColl */ ) |
| { |
| SetCondFmtColl( 0 ); |
| } |
| //FEATURE::CONDCOLL |
| |
| if( !IsModifyLocked() ) |
| { |
| SwFmtChg aTmp1( pOldColl ); |
| SwFmtChg aTmp2( pNewColl ); |
| SwCntntNode::Modify( &aTmp1, &aTmp2 ); |
| } |
| } |
| if ( IsInCache() ) |
| { |
| SwFrm::GetCache().Delete( this ); |
| SetInCache( sal_False ); |
| } |
| return pOldColl; |
| } |
| |
| |
| sal_Bool SwCntntNode::GoNext(SwIndex * pIdx, sal_uInt16 nMode ) const |
| { |
| sal_Bool bRet = sal_True; |
| if( pIdx->GetIndex() < Len() ) |
| { |
| if( !IsTxtNode() ) |
| (*pIdx)++; |
| else |
| { |
| const SwTxtNode& rTNd = *GetTxtNode(); |
| xub_StrLen nPos = pIdx->GetIndex(); |
| if( pBreakIt->GetBreakIter().is() ) |
| { |
| sal_Int32 nDone = 0; |
| sal_uInt16 nItrMode = ( CRSR_SKIP_CELLS & nMode ) ? |
| CharacterIteratorMode::SKIPCELL : |
| CharacterIteratorMode::SKIPCONTROLCHARACTER; |
| nPos = (xub_StrLen)pBreakIt->GetBreakIter()->nextCharacters( rTNd.GetTxt(), nPos, |
| pBreakIt->GetLocale( rTNd.GetLang( nPos ) ), |
| nItrMode, 1, nDone ); |
| |
| // Check if nPos is inside hidden text range: |
| if ( CRSR_SKIP_HIDDEN & nMode ) |
| { |
| xub_StrLen nHiddenStart; |
| xub_StrLen nHiddenEnd; |
| SwScriptInfo::GetBoundsOfHiddenRange( rTNd, nPos, nHiddenStart, nHiddenEnd ); |
| if ( nHiddenStart != STRING_LEN && nHiddenStart != nPos ) |
| nPos = nHiddenEnd; |
| } |
| |
| if( 1 == nDone ) |
| *pIdx = nPos; |
| else |
| bRet = sal_False; |
| } |
| else if( nPos < rTNd.GetTxt().Len() ) |
| (*pIdx)++; |
| else |
| bRet = sal_False; |
| } |
| } |
| else |
| bRet = sal_False; |
| return bRet; |
| } |
| |
| |
| sal_Bool SwCntntNode::GoPrevious(SwIndex * pIdx, sal_uInt16 nMode ) const |
| { |
| sal_Bool bRet = sal_True; |
| if( pIdx->GetIndex() > 0 ) |
| { |
| if( !IsTxtNode() ) |
| (*pIdx)--; |
| else |
| { |
| const SwTxtNode& rTNd = *GetTxtNode(); |
| xub_StrLen nPos = pIdx->GetIndex(); |
| if( pBreakIt->GetBreakIter().is() ) |
| { |
| sal_Int32 nDone = 0; |
| sal_uInt16 nItrMode = ( CRSR_SKIP_CELLS & nMode ) ? |
| CharacterIteratorMode::SKIPCELL : |
| CharacterIteratorMode::SKIPCONTROLCHARACTER; |
| nPos = (xub_StrLen)pBreakIt->GetBreakIter()->previousCharacters( rTNd.GetTxt(), nPos, |
| pBreakIt->GetLocale( rTNd.GetLang( nPos ) ), |
| nItrMode, 1, nDone ); |
| |
| // Check if nPos is inside hidden text range: |
| if ( CRSR_SKIP_HIDDEN & nMode ) |
| { |
| xub_StrLen nHiddenStart; |
| xub_StrLen nHiddenEnd; |
| SwScriptInfo::GetBoundsOfHiddenRange( rTNd, nPos, nHiddenStart, nHiddenEnd ); |
| if ( nHiddenStart != STRING_LEN ) |
| nPos = nHiddenStart; |
| } |
| |
| if( 1 == nDone ) |
| *pIdx = nPos; |
| else |
| bRet = sal_False; |
| } |
| else if( nPos ) |
| (*pIdx)--; |
| else |
| bRet = sal_False; |
| } |
| } |
| else |
| bRet = sal_False; |
| return bRet; |
| } |
| |
| |
| /* |
| * Methode erzeugt fuer den vorhergehenden Node alle Ansichten vom |
| * Dokument. Die erzeugten Contentframes werden in das entsprechende |
| * Layout gehaengt. |
| */ |
| |
| |
| void SwCntntNode::MakeFrms( SwCntntNode& rNode ) |
| { |
| ASSERT( &rNode != this, |
| "Kein Contentnode oder Copy-Node und neuer Node identisch." ); |
| |
| if( !GetDepends() || &rNode == this ) // gibt es ueberhaupt Frames ?? |
| return; |
| |
| SwFrm *pFrm, *pNew; |
| SwLayoutFrm *pUpper; |
| // Frames anlegen fuer Nodes, die vor oder hinter der Tabelle stehen ?? |
| ASSERT( FindTableNode() == rNode.FindTableNode(), "Table confusion" ) |
| |
| SwNode2Layout aNode2Layout( *this, rNode.GetIndex() ); |
| |
| while( 0 != (pUpper = aNode2Layout.UpperFrm( pFrm, rNode )) ) |
| { |
| pNew = rNode.MakeFrm( pUpper ); |
| pNew->Paste( pUpper, pFrm ); |
| // --> OD 2005-12-01 #i27138# |
| // notify accessibility paragraphs objects about changed |
| // CONTENT_FLOWS_FROM/_TO relation. |
| // Relation CONTENT_FLOWS_FROM for next paragraph will change |
| // and relation CONTENT_FLOWS_TO for previous paragraph will change. |
| if ( pNew->IsTxtFrm() ) |
| { |
| ViewShell* pViewShell( pNew->getRootFrm()->GetCurrShell() ); |
| if ( pViewShell && pViewShell->GetLayout() && |
| pViewShell->GetLayout()->IsAnyShellAccessible() ) |
| { |
| pViewShell->InvalidateAccessibleParaFlowRelation( |
| dynamic_cast<SwTxtFrm*>(pNew->FindNextCnt( true )), |
| dynamic_cast<SwTxtFrm*>(pNew->FindPrevCnt( true )) ); |
| } |
| } |
| // <-- |
| } |
| } |
| |
| /* |
| * Methode loescht fuer den Node alle Ansichten vom |
| * Dokument. Die Contentframes werden aus dem entsprechenden |
| * Layout ausgehaengt. |
| */ |
| |
| |
| //Solution:Add a input param to identify if the acc table should be disposed. |
| //add a flag(bNeedDel) to indicate whether to del corresponding frm even in doc loading process, |
| //void SwCntntNode::DelFrms() |
| void SwCntntNode::DelFrms( sal_Bool /* bNeedDel */, sal_Bool bIsDisposeAccTable ) |
| { |
| if( !GetDepends() ) |
| return; |
| |
| SwClientIter aIter( *this ); |
| SwCntntFrm *pFrm; |
| |
| for( pFrm = (SwCntntFrm*)aIter.First( TYPE(SwCntntFrm)); pFrm; |
| pFrm = (SwCntntFrm*)aIter.Next() ) |
| { |
| // --> OD 2005-12-01 #i27138# |
| // notify accessibility paragraphs objects about changed |
| // CONTENT_FLOWS_FROM/_TO relation. |
| // Relation CONTENT_FLOWS_FROM for current next paragraph will change |
| // and relation CONTENT_FLOWS_TO for current previous paragraph will change. |
| if ( pFrm->IsTxtFrm() ) |
| { |
| ViewShell* pViewShell( pFrm->getRootFrm()->GetCurrShell() ); |
| if ( pViewShell && pViewShell->GetLayout() && |
| pViewShell->GetLayout()->IsAnyShellAccessible() ) |
| { |
| pViewShell->InvalidateAccessibleParaFlowRelation( |
| dynamic_cast<SwTxtFrm*>(pFrm->FindNextCnt( true )), |
| dynamic_cast<SwTxtFrm*>(pFrm->FindPrevCnt( true )) ); |
| } |
| } |
| // <-- |
| if( pFrm->HasFollow() ) |
| pFrm->GetFollow()->_SetIsFollow( pFrm->IsFollow() ); |
| if( pFrm->IsFollow() ) |
| { |
| SwCntntFrm* pMaster = (SwTxtFrm*)pFrm->FindMaster(); |
| pMaster->SetFollow( pFrm->GetFollow() ); |
| pFrm->_SetIsFollow( sal_False ); |
| } |
| pFrm->SetFollow( 0 );//Damit er nicht auf dumme Gedanken kommt. |
| //Andernfalls kann es sein, dass ein Follow |
| //vor seinem Master zerstoert wird, der Master |
| //greift dann ueber den ungueltigen |
| //Follow-Pointer auf fremdes Memory zu. |
| //Die Kette darf hier zerknauscht werden, weil |
| //sowieso alle zerstoert werden. |
| if( pFrm->GetUpper() && pFrm->IsInFtn() && !pFrm->GetIndNext() && |
| !pFrm->GetIndPrev() ) |
| { |
| SwFtnFrm *pFtn = pFrm->FindFtnFrm(); |
| ASSERT( pFtn, "You promised a FtnFrm?" ); |
| SwCntntFrm* pCFrm; |
| if( !pFtn->GetFollow() && !pFtn->GetMaster() && |
| 0 != ( pCFrm = pFtn->GetRefFromAttr()) && pCFrm->IsFollow() ) |
| { |
| ASSERT( pCFrm->IsTxtFrm(), "NoTxtFrm has Footnote?" ); |
| ((SwTxtFrm*)pCFrm->FindMaster())->Prepare( PREP_FTN_GONE ); |
| } |
| } |
| //Solution:Set acc table dispose state |
| pFrm->SetAccTableDispose( bIsDisposeAccTable ); |
| //End Added |
| pFrm->Cut(); |
| //Solution:Set acc table dispose state to default value |
| pFrm->SetAccTableDispose( sal_True ); |
| delete pFrm; |
| } |
| if( IsTxtNode() ) |
| { |
| ((SwTxtNode*)this)->SetWrong( NULL ); |
| ((SwTxtNode*)this)->SetWrongDirty( true ); |
| |
| ((SwTxtNode*)this)->SetGrammarCheck( NULL ); |
| ((SwTxtNode*)this)->SetGrammarCheckDirty( true ); |
| // SMARTTAGS |
| ((SwTxtNode*)this)->SetSmartTags( NULL ); |
| ((SwTxtNode*)this)->SetSmartTagDirty( true ); |
| |
| ((SwTxtNode*)this)->SetWordCountDirty( true ); |
| ((SwTxtNode*)this)->SetAutoCompleteWordDirty( true ); |
| } |
| } |
| |
| |
| SwCntntNode *SwCntntNode::JoinNext() |
| { |
| return this; |
| } |
| |
| |
| SwCntntNode *SwCntntNode::JoinPrev() |
| { |
| return this; |
| } |
| |
| |
| |
| // erfrage vom Modify Informationen |
| sal_Bool SwCntntNode::GetInfo( SfxPoolItem& rInfo ) const |
| { |
| switch( rInfo.Which() ) |
| { |
| case RES_AUTOFMT_DOCNODE: |
| if( &GetNodes() == ((SwAutoFmtGetDocNode&)rInfo).pNodes ) |
| { |
| ((SwAutoFmtGetDocNode&)rInfo).pCntntNode = this; |
| return sal_False; |
| } |
| break; |
| // --> OD 2008-02-19 #refactorlists# |
| // case RES_GETNUMNODES: |
| // // #111955# only numbered nodes in rInfo |
| // if( IsTxtNode()) |
| // { |
| // SwTxtNode * pTxtNode = (SwTxtNode*)this; |
| // pItem = (SwNumRuleItem*)GetNoCondAttr(RES_PARATR_NUMRULE, sal_True ); |
| |
| // if (0 != pItem && |
| // pItem->GetValue().Len() && |
| // pItem->GetValue() == ((SwNumRuleInfo&)rInfo).GetName() && |
| // GetNodes().IsDocNodes()) |
| // { |
| // ((SwNumRuleInfo&)rInfo).AddNode( *pTxtNode ); |
| // } |
| // } |
| |
| // return sal_True; |
| // <-- |
| |
| case RES_FINDNEARESTNODE: |
| if( ((SwFmtPageDesc&)GetAttr( RES_PAGEDESC )).GetPageDesc() ) |
| ((SwFindNearestNode&)rInfo).CheckNode( *this ); |
| return sal_True; |
| |
| case RES_CONTENT_VISIBLE: |
| { |
| ((SwPtrMsgPoolItem&)rInfo).pObject = |
| SwIterator<SwFrm,SwCntntNode>::FirstElement(*this); |
| } |
| return sal_False; |
| } |
| |
| return SwModify::GetInfo( rInfo ); |
| } |
| |
| |
| // setze ein Attribut |
| sal_Bool SwCntntNode::SetAttr(const SfxPoolItem& rAttr ) |
| { |
| if( !GetpSwAttrSet() ) // lasse von den entsprechenden Nodes die |
| NewAttrSet( GetDoc()->GetAttrPool() ); // AttrSets anlegen |
| |
| ASSERT( GetpSwAttrSet(), "warum wurde kein AttrSet angelegt?" ); |
| |
| if ( IsInCache() ) |
| { |
| SwFrm::GetCache().Delete( this ); |
| SetInCache( sal_False ); |
| } |
| |
| sal_Bool bRet = sal_False; |
| // wenn Modify gelockt ist, werden keine Modifies verschickt |
| if( IsModifyLocked() || |
| ( !GetDepends() && RES_PARATR_NUMRULE != rAttr.Which() )) |
| { |
| bRet = 0 != AttrSetHandleHelper::Put( mpAttrSet, *this, rAttr ); |
| } |
| else |
| { |
| SwAttrSet aOld( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() ), |
| aNew( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() ); |
| if( 0 != ( bRet = 0 != AttrSetHandleHelper::Put_BC( mpAttrSet, *this, rAttr, &aOld, &aNew ) )) |
| { |
| SwAttrSetChg aChgOld( *GetpSwAttrSet(), aOld ); |
| SwAttrSetChg aChgNew( *GetpSwAttrSet(), aNew ); |
| ModifyNotification( &aChgOld, &aChgNew ); // alle veraenderten werden verschickt |
| } |
| } |
| return bRet; |
| } |
| #include <svl/itemiter.hxx> |
| |
| sal_Bool SwCntntNode::SetAttr( const SfxItemSet& rSet ) |
| { |
| if ( IsInCache() ) |
| { |
| SwFrm::GetCache().Delete( this ); |
| SetInCache( sal_False ); |
| } |
| |
| const SfxPoolItem* pFnd = 0; |
| if( SFX_ITEM_SET == rSet.GetItemState( RES_AUTO_STYLE, sal_False, &pFnd ) ) |
| { |
| ASSERT( rSet.Count() == 1, "SetAutoStyle mixed with other attributes?!" ); |
| const SwFmtAutoFmt* pTmp = static_cast<const SwFmtAutoFmt*>(pFnd); |
| |
| // If there already is an attribute set (usually containing a numbering |
| // item), we have to merge the attribute of the new set into the old set: |
| bool bSetParent = true; |
| if ( GetpSwAttrSet() ) |
| { |
| bSetParent = false; |
| AttrSetHandleHelper::Put( mpAttrSet, *this, *pTmp->GetStyleHandle() ); |
| } |
| else |
| { |
| mpAttrSet = pTmp->GetStyleHandle(); |
| } |
| |
| if ( bSetParent ) |
| { |
| // If the content node has a conditional style, we have to set the |
| // string item containing the correct conditional style name (the |
| // style name property has already been set during the import!) |
| // In case we do not have a conditional style, we make use of the |
| // fact that nobody else uses the attribute set behind the handle. |
| // FME 2007-07-10 #i78124# If autostyle does not have a parent, |
| // the string is empty. |
| const SfxPoolItem* pNameItem = 0; |
| if ( 0 != GetCondFmtColl() || |
| SFX_ITEM_SET != mpAttrSet->GetItemState( RES_FRMATR_STYLE_NAME, sal_False, &pNameItem ) || |
| 0 == static_cast<const SfxStringItem*>(pNameItem)->GetValue().Len() ) |
| AttrSetHandleHelper::SetParent( mpAttrSet, *this, &GetAnyFmtColl(), GetFmtColl() ); |
| else |
| const_cast<SfxItemSet*>(mpAttrSet.get())->SetParent( &GetFmtColl()->GetAttrSet() ); |
| } |
| |
| return sal_True; |
| } |
| |
| if( !GetpSwAttrSet() ) // lasse von den entsprechenden Nodes die |
| NewAttrSet( GetDoc()->GetAttrPool() ); // AttrSets anlegen |
| |
| sal_Bool bRet = sal_False; |
| // wenn Modify gelockt ist, werden keine Modifies verschickt |
| if ( IsModifyLocked() || |
| ( !GetDepends() && |
| SFX_ITEM_SET != rSet.GetItemState( RES_PARATR_NUMRULE, sal_False ) ) ) |
| { |
| // einige Sonderbehandlungen fuer Attribute |
| bRet = 0 != AttrSetHandleHelper::Put( mpAttrSet, *this, rSet ); |
| } |
| else |
| { |
| SwAttrSet aOld( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() ), |
| aNew( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() ); |
| if( 0 != (bRet = 0 != AttrSetHandleHelper::Put_BC( mpAttrSet, *this, rSet, &aOld, &aNew )) ) |
| { |
| // einige Sonderbehandlungen fuer Attribute |
| SwAttrSetChg aChgOld( *GetpSwAttrSet(), aOld ); |
| SwAttrSetChg aChgNew( *GetpSwAttrSet(), aNew ); |
| ModifyNotification( &aChgOld, &aChgNew ); // alle veraenderten werden verschickt |
| } |
| } |
| return bRet; |
| } |
| |
| // Nimmt den Hint mit nWhich aus dem Delta-Array |
| |
| |
| sal_Bool SwCntntNode::ResetAttr( sal_uInt16 nWhich1, sal_uInt16 nWhich2 ) |
| { |
| if( !GetpSwAttrSet() ) |
| return sal_False; |
| |
| if ( IsInCache() ) |
| { |
| SwFrm::GetCache().Delete( this ); |
| SetInCache( sal_False ); |
| } |
| |
| // wenn Modify gelockt ist, werden keine Modifies verschickt |
| if( IsModifyLocked() ) |
| { |
| sal_uInt16 nDel = 0; |
| if ( !nWhich2 || nWhich2 < nWhich1 ) |
| { |
| std::vector<sal_uInt16> aClearWhichIds; |
| aClearWhichIds.push_back( nWhich1 ); |
| nDel = ClearItemsFromAttrSet( aClearWhichIds ); |
| } |
| else |
| nDel = AttrSetHandleHelper::ClearItem_BC( mpAttrSet, *this, nWhich1, nWhich2, 0, 0 ); |
| |
| if( !GetpSwAttrSet()->Count() ) // leer, dann loeschen |
| mpAttrSet.reset();//DELETEZ( mpAttrSet ); |
| return 0 != nDel; |
| } |
| |
| // sollte kein gueltiger Bereich definiert sein ? |
| if( !nWhich2 || nWhich2 < nWhich1 ) |
| nWhich2 = nWhich1; // dann setze auf 1. Id, nur dieses Item |
| |
| SwAttrSet aOld( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() ), |
| aNew( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() ); |
| sal_Bool bRet = 0 != AttrSetHandleHelper::ClearItem_BC( mpAttrSet, *this, nWhich1, nWhich2, &aOld, &aNew ); |
| |
| if( bRet ) |
| { |
| SwAttrSetChg aChgOld( *GetpSwAttrSet(), aOld ); |
| SwAttrSetChg aChgNew( *GetpSwAttrSet(), aNew ); |
| ModifyNotification( &aChgOld, &aChgNew ); // alle veraenderten werden verschickt |
| |
| if( !GetpSwAttrSet()->Count() ) // leer, dann loeschen |
| mpAttrSet.reset();//DELETEZ( mpAttrSet ); |
| } |
| return bRet; |
| } |
| sal_Bool SwCntntNode::ResetAttr( const SvUShorts& rWhichArr ) |
| { |
| if( !GetpSwAttrSet() ) |
| return sal_False; |
| |
| if ( IsInCache() ) |
| { |
| SwFrm::GetCache().Delete( this ); |
| SetInCache( sal_False ); |
| } |
| |
| // wenn Modify gelockt ist, werden keine Modifies verschickt |
| sal_uInt16 nDel = 0; |
| if( IsModifyLocked() ) |
| { |
| std::vector<sal_uInt16> aClearWhichIds; |
| for( sal_uInt16 n = 0, nEnd = rWhichArr.Count(); n < nEnd; ++n ) |
| aClearWhichIds.push_back( rWhichArr[ n ] ); |
| |
| nDel = ClearItemsFromAttrSet( aClearWhichIds ); |
| } |
| else |
| { |
| SwAttrSet aOld( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() ), |
| aNew( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() ); |
| |
| for( sal_uInt16 n = 0, nEnd = rWhichArr.Count(); n < nEnd; ++n ) |
| if( AttrSetHandleHelper::ClearItem_BC( mpAttrSet, *this, rWhichArr[ n ], &aOld, &aNew )) |
| ++nDel; |
| |
| if( nDel ) |
| { |
| SwAttrSetChg aChgOld( *GetpSwAttrSet(), aOld ); |
| SwAttrSetChg aChgNew( *GetpSwAttrSet(), aNew ); |
| ModifyNotification( &aChgOld, &aChgNew ); // alle veraenderten werden verschickt |
| } |
| } |
| if( !GetpSwAttrSet()->Count() ) // leer, dann loeschen |
| mpAttrSet.reset();//DELETEZ( mpAttrSet ); |
| return 0 != nDel ; |
| } |
| |
| |
| sal_uInt16 SwCntntNode::ResetAllAttr() |
| { |
| if( !GetpSwAttrSet() ) |
| return 0; |
| |
| if ( IsInCache() ) |
| { |
| SwFrm::GetCache().Delete( this ); |
| SetInCache( sal_False ); |
| } |
| |
| // wenn Modify gelockt ist, werden keine Modifies verschickt |
| if( IsModifyLocked() ) |
| { |
| std::vector<sal_uInt16> aClearWhichIds; |
| aClearWhichIds.push_back(0); |
| sal_uInt16 nDel = ClearItemsFromAttrSet( aClearWhichIds ); |
| if( !GetpSwAttrSet()->Count() ) // leer, dann loeschen |
| mpAttrSet.reset(); // DELETEZ( mpAttrSet ); |
| return nDel; |
| } |
| |
| SwAttrSet aOld( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() ), |
| aNew( *GetpSwAttrSet()->GetPool(), GetpSwAttrSet()->GetRanges() ); |
| sal_Bool bRet = 0 != AttrSetHandleHelper::ClearItem_BC( mpAttrSet, *this, 0, &aOld, &aNew ); |
| |
| if( bRet ) |
| { |
| SwAttrSetChg aChgOld( *GetpSwAttrSet(), aOld ); |
| SwAttrSetChg aChgNew( *GetpSwAttrSet(), aNew ); |
| ModifyNotification( &aChgOld, &aChgNew ); // alle veraenderten werden verschickt |
| |
| if( !GetpSwAttrSet()->Count() ) // leer, dann loeschen |
| mpAttrSet.reset();//DELETEZ( mpAttrSet ); |
| } |
| return aNew.Count(); |
| } |
| |
| |
| sal_Bool SwCntntNode::GetAttr( SfxItemSet& rSet, sal_Bool bInParent ) const |
| { |
| if( rSet.Count() ) |
| rSet.ClearItem(); |
| |
| const SwAttrSet& rAttrSet = GetSwAttrSet(); |
| if( bInParent ) |
| return rSet.Set( rAttrSet, sal_True ) ? sal_True : sal_False; |
| |
| rSet.Put( rAttrSet ); |
| return rSet.Count() ? sal_True : sal_False; |
| } |
| |
| sal_uInt16 SwCntntNode::ClearItemsFromAttrSet( const std::vector<sal_uInt16>& rWhichIds ) |
| { |
| sal_uInt16 nRet = 0; |
| if ( 0 == rWhichIds.size() ) |
| return nRet; |
| |
| ASSERT( GetpSwAttrSet(), "no item set" ) |
| SwAttrSet aNewAttrSet( *GetpSwAttrSet() ); |
| for ( std::vector<sal_uInt16>::const_iterator aIter = rWhichIds.begin(); |
| aIter != rWhichIds.end(); |
| ++aIter ) |
| { |
| nRet = nRet + aNewAttrSet.ClearItem( *aIter ); |
| } |
| if ( nRet ) |
| AttrSetHandleHelper::GetNewAutoStyle( mpAttrSet, *this, aNewAttrSet ); |
| |
| return nRet; |
| } |
| |
| const SfxPoolItem* SwCntntNode::GetNoCondAttr( sal_uInt16 nWhich, |
| sal_Bool bInParents ) const |
| { |
| const SfxPoolItem* pFnd = 0; |
| if( pCondColl && pCondColl->GetRegisteredIn() ) |
| { |
| if( !GetpSwAttrSet() || ( SFX_ITEM_SET != GetpSwAttrSet()->GetItemState( |
| nWhich, sal_False, &pFnd ) && bInParents )) |
| ((SwFmt*)GetRegisteredIn())->GetItemState( nWhich, bInParents, &pFnd ); |
| } |
| // --> OD 2005-10-25 #126347# - undo change of issue #i51029# |
| // Note: <GetSwAttrSet()> returns <mpAttrSet>, if set, otherwise it returns |
| // the attribute set of the paragraph style, which is valid for the |
| // content node - see file <node.hxx> |
| else |
| // <-- |
| { |
| GetSwAttrSet().GetItemState( nWhich, bInParents, &pFnd ); |
| } |
| return pFnd; |
| } |
| |
| // koennen 2 Nodes zusammengefasst werden ? |
| // in pIdx kann die 2. Position returnt werden. |
| int SwCntntNode::CanJoinNext( SwNodeIndex* pIdx ) const |
| { |
| const SwNodes& rNds = GetNodes(); |
| sal_uInt8 nNdType = GetNodeType(); |
| SwNodeIndex aIdx( *this, 1 ); |
| |
| const SwNode* pNd = this; |
| while( aIdx < rNds.Count()-1 && |
| (( pNd = &aIdx.GetNode())->IsSectionNode() || |
| ( pNd->IsEndNode() && pNd->StartOfSectionNode()->IsSectionNode() ))) |
| aIdx++; |
| |
| if( pNd->GetNodeType() != nNdType || rNds.Count()-1 == aIdx.GetIndex() ) |
| return sal_False; |
| if( IsTxtNode() ) |
| { // Do not merge strings if the result exceeds the allowed string length |
| const SwTxtNode* pTxtNd = static_cast<const SwTxtNode*>(this); |
| sal_uInt64 nSum = pTxtNd->GetTxt().Len(); |
| pTxtNd = static_cast<const SwTxtNode*>(pNd); |
| nSum += pTxtNd->GetTxt().Len(); |
| if( nSum > STRING_LEN ) |
| return sal_False; |
| } |
| if( pIdx ) |
| *pIdx = aIdx; |
| return sal_True; |
| } |
| |
| |
| // koennen 2 Nodes zusammengefasst werden ? |
| // in pIdx kann die 2. Position returnt werden. |
| int SwCntntNode::CanJoinPrev( SwNodeIndex* pIdx ) const |
| { |
| sal_uInt8 nNdType = GetNodeType(); |
| SwNodeIndex aIdx( *this, -1 ); |
| |
| const SwNode* pNd = this; |
| while( aIdx.GetIndex() && |
| (( pNd = &aIdx.GetNode())->IsSectionNode() || |
| ( pNd->IsEndNode() && pNd->StartOfSectionNode()->IsSectionNode() ))) |
| aIdx--; |
| |
| if( pNd->GetNodeType() != nNdType || 0 == aIdx.GetIndex() ) |
| return sal_False; |
| if( pIdx ) |
| *pIdx = aIdx; |
| return sal_True; |
| } |
| |
| |
| //FEATURE::CONDCOLL |
| |
| |
| void SwCntntNode::SetCondFmtColl( SwFmtColl* pColl ) |
| { |
| if( (!pColl && pCondColl) || ( pColl && !pCondColl ) || |
| ( pColl && pColl != pCondColl->GetRegisteredIn() ) ) |
| { |
| SwFmtColl* pOldColl = GetCondFmtColl(); |
| delete pCondColl; |
| if( pColl ) |
| pCondColl = new SwDepend( this, pColl ); |
| else |
| pCondColl = 0; |
| |
| if( GetpSwAttrSet() ) |
| { |
| AttrSetHandleHelper::SetParent( mpAttrSet, *this, &GetAnyFmtColl(), GetFmtColl() ); |
| } |
| |
| if( !IsModifyLocked() ) |
| { |
| SwFmtChg aTmp1( pOldColl ? pOldColl : GetFmtColl() ); |
| SwFmtChg aTmp2( pColl ? pColl : GetFmtColl() ); |
| NotifyClients( &aTmp1, &aTmp2 ); |
| } |
| if( IsInCache() ) |
| { |
| SwFrm::GetCache().Delete( this ); |
| SetInCache( sal_False ); |
| } |
| } |
| } |
| |
| |
| sal_Bool SwCntntNode::IsAnyCondition( SwCollCondition& rTmp ) const |
| { |
| const SwNodes& rNds = GetNodes(); |
| { |
| int nCond = 0; |
| const SwStartNode* pSttNd = StartOfSectionNode(); |
| while( pSttNd ) |
| { |
| switch( pSttNd->GetNodeType() ) |
| { |
| case ND_TABLENODE: nCond = PARA_IN_TABLEBODY; break; |
| case ND_SECTIONNODE: nCond = PARA_IN_SECTION; break; |
| |
| default: |
| switch( pSttNd->GetStartNodeType() ) |
| { |
| case SwTableBoxStartNode: |
| { |
| nCond = PARA_IN_TABLEBODY; |
| const SwTableNode* pTblNd = pSttNd->FindTableNode(); |
| const SwTableBox* pBox; |
| if( pTblNd && 0 != ( pBox = pTblNd->GetTable(). |
| GetTblBox( pSttNd->GetIndex() ) ) && pBox && |
| pBox->IsInHeadline( &pTblNd->GetTable() ) ) |
| nCond = PARA_IN_TABLEHEAD; |
| } |
| break; |
| case SwFlyStartNode: nCond = PARA_IN_FRAME; break; |
| case SwFootnoteStartNode: |
| { |
| nCond = PARA_IN_FOOTENOTE; |
| const SwFtnIdxs& rFtnArr = rNds.GetDoc()->GetFtnIdxs(); |
| const SwTxtFtn* pTxtFtn; |
| const SwNode* pSrchNd = pSttNd; |
| |
| for( sal_uInt16 n = 0; n < rFtnArr.Count(); ++n ) |
| if( 0 != ( pTxtFtn = rFtnArr[ n ])->GetStartNode() && |
| pSrchNd == &pTxtFtn->GetStartNode()->GetNode() ) |
| { |
| if( pTxtFtn->GetFtn().IsEndNote() ) |
| nCond = PARA_IN_ENDNOTE; |
| break; |
| } |
| } |
| break; |
| case SwHeaderStartNode: nCond = PARA_IN_HEADER; break; |
| case SwFooterStartNode: nCond = PARA_IN_FOOTER; break; |
| case SwNormalStartNode: break; |
| } |
| } |
| |
| if( nCond ) |
| { |
| rTmp.SetCondition( (Master_CollConditions)nCond, 0 ); |
| return sal_True; |
| } |
| pSttNd = pSttNd->GetIndex() |
| ? pSttNd->StartOfSectionNode() |
| : 0; |
| } |
| } |
| |
| { |
| sal_uInt16 nPos; |
| const SwOutlineNodes& rOutlNds = rNds.GetOutLineNds(); |
| if( rOutlNds.Count() ) |
| { |
| if( !rOutlNds.Seek_Entry( (SwCntntNode*)this, &nPos ) && nPos ) |
| --nPos; |
| if( nPos < rOutlNds.Count() && |
| rOutlNds[ nPos ]->GetIndex() < GetIndex() ) |
| { |
| SwTxtNode* pOutlNd = rOutlNds[ nPos ]->GetTxtNode(); |
| |
| if( pOutlNd->IsOutline()) |
| { |
| rTmp.SetCondition( PARA_IN_OUTLINE, pOutlNd->GetAttrOutlineLevel() - 1 ); |
| return sal_True; |
| } |
| } |
| } |
| } |
| |
| return sal_False; |
| } |
| |
| |
| void SwCntntNode::ChkCondColl() |
| { |
| // zur Sicherheit abfragen |
| if( RES_CONDTXTFMTCOLL == GetFmtColl()->Which() ) |
| { |
| SwCollCondition aTmp( 0, 0, 0 ); |
| const SwCollCondition* pCColl; |
| |
| bool bDone = false; |
| |
| if( IsAnyCondition( aTmp )) |
| { |
| pCColl = static_cast<SwConditionTxtFmtColl*>(GetFmtColl()) |
| ->HasCondition( aTmp ); |
| |
| if (pCColl) |
| { |
| SetCondFmtColl( pCColl->GetTxtFmtColl() ); |
| bDone = true; |
| } |
| } |
| |
| if (!bDone) |
| { |
| if( IsTxtNode() && ((SwTxtNode*)this)->GetNumRule()) |
| { |
| // steht in einer Numerierung |
| // welcher Level? |
| aTmp.SetCondition( PARA_IN_LIST, |
| ((SwTxtNode*)this)->GetActualListLevel() ); |
| pCColl = ((SwConditionTxtFmtColl*)GetFmtColl())-> |
| HasCondition( aTmp ); |
| } |
| else |
| pCColl = 0; |
| |
| if( pCColl ) |
| SetCondFmtColl( pCColl->GetTxtFmtColl() ); |
| else if( pCondColl ) |
| SetCondFmtColl( 0 ); |
| } |
| } |
| } |
| |
| // --> OD 2005-02-21 #i42921# |
| short SwCntntNode::GetTextDirection( const SwPosition& rPos, |
| const Point* pPt ) const |
| { |
| short nRet = -1; |
| |
| Point aPt; |
| if( pPt ) |
| aPt = *pPt; |
| |
| // --> OD 2007-01-10 #i72024# |
| // No format of the frame, because this can cause recursive layout actions |
| SwFrm* pFrm = getLayoutFrm( GetDoc()->GetCurrentLayout(), &aPt, &rPos, sal_False ); |
| // <-- |
| |
| if ( pFrm ) |
| { |
| if ( pFrm->IsVertical() ) |
| { |
| if ( pFrm->IsRightToLeft() ) |
| nRet = FRMDIR_VERT_TOP_LEFT; |
| else |
| nRet = FRMDIR_VERT_TOP_RIGHT; |
| } |
| else |
| { |
| if ( pFrm->IsRightToLeft() ) |
| nRet = FRMDIR_HORI_RIGHT_TOP; |
| else |
| nRet = FRMDIR_HORI_LEFT_TOP; |
| } |
| } |
| |
| |
| return nRet; |
| } |
| // <-- |
| |
| SwOLENodes* SwCntntNode::CreateOLENodesArray( const SwFmtColl& rColl, bool bOnlyWithInvalidSize ) |
| { |
| SwOLENodes *pNodes = 0; |
| SwIterator<SwCntntNode,SwFmtColl> aIter( rColl ); |
| for( SwCntntNode* pNd = aIter.First(); pNd; pNd = aIter.Next() ) |
| { |
| SwOLENode *pONd = pNd->GetOLENode(); |
| if ( pONd && (!bOnlyWithInvalidSize || pONd->IsOLESizeInvalid()) ) |
| { |
| if ( !pNodes ) |
| pNodes = new SwOLENodes; |
| pNodes->Insert( pONd, pNodes->Count() ); |
| } |
| } |
| |
| return pNodes; |
| } |
| |
| //FEATURE::CONDCOLL |
| // Metoden aus Node.hxx - erst hier ist der TxtNode bekannt !! |
| // os: nur fuer ICC, da der zum optimieren zu dumm ist |
| #ifdef ICC |
| SwTxtNode *SwNode::GetTxtNode() |
| { |
| return ND_TEXTNODE == nNodeType ? (SwTxtNode*)this : 0; |
| } |
| const SwTxtNode *SwNode::GetTxtNode() const |
| { |
| return ND_TEXTNODE == nNodeType ? (const SwTxtNode*)this : 0; |
| } |
| #endif |
| |
| /* |
| * Document Interface Access |
| */ |
| const IDocumentSettingAccess* SwNode::getIDocumentSettingAccess() const { return GetDoc(); } |
| const IDocumentDeviceAccess* SwNode::getIDocumentDeviceAccess() const { return GetDoc(); } |
| const IDocumentMarkAccess* SwNode::getIDocumentMarkAccess() const { return GetDoc()->getIDocumentMarkAccess(); } |
| const IDocumentRedlineAccess* SwNode::getIDocumentRedlineAccess() const { return GetDoc(); } |
| const IDocumentStylePoolAccess* SwNode::getIDocumentStylePoolAccess() const { return GetDoc(); } |
| const IDocumentLineNumberAccess* SwNode::getIDocumentLineNumberAccess() const { return GetDoc(); } |
| const IDocumentDrawModelAccess* SwNode::getIDocumentDrawModelAccess() const { return GetDoc(); } |
| const IDocumentLayoutAccess* SwNode::getIDocumentLayoutAccess() const { return GetDoc(); } |
| IDocumentLayoutAccess* SwNode::getIDocumentLayoutAccess() { return GetDoc(); } |
| const IDocumentLinksAdministration* SwNode::getIDocumentLinksAdministration() const { return GetDoc(); } |
| IDocumentLinksAdministration* SwNode::getIDocumentLinksAdministration() { return GetDoc(); } |
| const IDocumentFieldsAccess* SwNode::getIDocumentFieldsAccess() const { return GetDoc(); } |
| IDocumentFieldsAccess* SwNode::getIDocumentFieldsAccess() { return GetDoc(); } |
| IDocumentContentOperations* SwNode::getIDocumentContentOperations() { return GetDoc(); } |
| IStyleAccess& SwNode::getIDocumentStyleAccess() { return GetDoc()->GetIStyleAccess(); } |
| // --> OD 2007-10-31 #i83479# |
| IDocumentListItems& SwNode::getIDocumentListItems() |
| { |
| return *GetDoc(); |
| } |
| // <-- |
| |
| sal_Bool SwNode::IsInRedlines() const |
| { |
| const SwDoc * pDoc = GetDoc(); |
| sal_Bool bResult = sal_False; |
| |
| if (pDoc != NULL) |
| bResult = pDoc->IsInRedlines(*this); |
| |
| return bResult; |
| } |
