diff options
Diffstat (limited to 'sw/source/core/docnode/node2lay.cxx')
| -rw-r--r-- | sw/source/core/docnode/node2lay.cxx | 244 |
1 files changed, 122 insertions, 122 deletions
diff --git a/sw/source/core/docnode/node2lay.cxx b/sw/source/core/docnode/node2lay.cxx index b000d243748c..d73858662279 100644 --- a/sw/source/core/docnode/node2lay.cxx +++ b/sw/source/core/docnode/node2lay.cxx @@ -36,27 +36,27 @@ */ class SwNode2LayImpl { - SwIterator<SwFrm,SwModify>* pIter; + SwIterator<SwFrame,SwModify>* pIter; SwModify* pMod; - std::vector<SwFrm*>* pUpperFrms; // To collect the Upper + std::vector<SwFrame*>* pUpperFrames; // To collect the Upper sal_uLong nIndex; // The Index of the to-be-inserted Nodes bool bMaster : 1; // true => only Master, false => only Frames without Follow bool bInit : 1; // Did we already call First() at SwClient? public: SwNode2LayImpl( const SwNode& rNode, sal_uLong nIdx, bool bSearch ); - ~SwNode2LayImpl() { delete pIter; delete pUpperFrms; } - SwFrm* NextFrm(); // Returns the next "useful" Frame - SwLayoutFrm* UpperFrm( SwFrm* &rpFrm, const SwNode &rNode ); - void SaveUpperFrms(); // Saves (and locks if needed) the pUpper + ~SwNode2LayImpl() { delete pIter; delete pUpperFrames; } + SwFrame* NextFrame(); // Returns the next "useful" Frame + SwLayoutFrame* UpperFrame( SwFrame* &rpFrame, const SwNode &rNode ); + void SaveUpperFrames(); // Saves (and locks if needed) the pUpper // Inserts a Frame under every pUpper of the array - void RestoreUpperFrms( SwNodes& rNds, sal_uLong nStt, sal_uLong nEnd ); + void RestoreUpperFrames( SwNodes& rNds, sal_uLong nStt, sal_uLong nEnd ); - SwFrm* GetFrm( const Point* pDocPos = nullptr, + SwFrame* GetFrame( const Point* pDocPos = nullptr, const SwPosition *pPos = nullptr, - const bool bCalcFrm = true ) const; + const bool bCalcFrame = true ) const; }; -SwNode* GoNextWithFrm(const SwNodes& rNodes, SwNodeIndex *pIdx) +SwNode* GoNextWithFrame(const SwNodes& rNodes, SwNodeIndex *pIdx) { if( pIdx->GetIndex() >= rNodes.Count() - 1 ) return nullptr; @@ -68,9 +68,9 @@ SwNode* GoNextWithFrm(const SwNodes& rNodes, SwNodeIndex *pIdx) pNd = &aTmp.GetNode(); bool bFound = false; if ( pNd->IsContentNode() ) - bFound = SwIterator<SwFrm,SwContentNode>(*static_cast<SwContentNode*>(pNd)).First(); + bFound = SwIterator<SwFrame,SwContentNode>(*static_cast<SwContentNode*>(pNd)).First(); else if ( pNd->IsTableNode() ) - bFound = SwIterator<SwFrm,SwFormat>(*static_cast<SwTableNode*>(pNd)->GetTable().GetFrameFormat()).First() ; + bFound = SwIterator<SwFrame,SwFormat>(*static_cast<SwTableNode*>(pNd)->GetTable().GetFrameFormat()).First() ; else if( pNd->IsEndNode() && !pNd->StartOfSectionNode()->IsSectionNode() ) { pNd = nullptr; @@ -88,7 +88,7 @@ SwNode* GoNextWithFrm(const SwNodes& rNodes, SwNodeIndex *pIdx) return pNd; } -SwNode* GoPreviousWithFrm(SwNodeIndex *pIdx) +SwNode* GoPreviousWithFrame(SwNodeIndex *pIdx) { if( !pIdx->GetIndex() ) return nullptr; @@ -100,9 +100,9 @@ SwNode* GoPreviousWithFrm(SwNodeIndex *pIdx) pNd = &aTmp.GetNode(); bool bFound = false; if ( pNd->IsContentNode() ) - bFound = SwIterator<SwFrm,SwContentNode>(*static_cast<SwContentNode*>(pNd)).First(); + bFound = SwIterator<SwFrame,SwContentNode>(*static_cast<SwContentNode*>(pNd)).First(); else if ( pNd->IsTableNode() ) - bFound = SwIterator<SwFrm,SwFormat>(*static_cast<SwTableNode*>(pNd)->GetTable().GetFrameFormat()).First(); + bFound = SwIterator<SwFrame,SwFormat>(*static_cast<SwTableNode*>(pNd)->GetTable().GetFrameFormat()).First(); else if( pNd->IsStartNode() && !pNd->IsSectionNode() ) { pNd = nullptr; @@ -130,7 +130,7 @@ SwNode* GoPreviousWithFrm(SwNodeIndex *pIdx) * We insert before or after it. */ SwNode2LayImpl::SwNode2LayImpl( const SwNode& rNode, sal_uLong nIdx, bool bSearch ) - : pUpperFrms( nullptr ), nIndex( nIdx ), bInit( false ) + : pUpperFrames( nullptr ), nIndex( nIdx ), bInit( false ) { const SwNode* pNd; if( bSearch || rNode.IsSectionNode() ) @@ -140,7 +140,7 @@ SwNode2LayImpl::SwNode2LayImpl( const SwNode& rNode, sal_uLong nIdx, bool bSearc if( !bSearch && rNode.GetIndex() < nIndex ) { SwNodeIndex aTmp( *rNode.EndOfSectionNode(), +1 ); - pNd = GoPreviousWithFrm( &aTmp ); + pNd = GoPreviousWithFrame( &aTmp ); if( !bSearch && pNd && rNode.GetIndex() > pNd->GetIndex() ) pNd = nullptr; // Do not go over the limits bMaster = false; @@ -148,7 +148,7 @@ SwNode2LayImpl::SwNode2LayImpl( const SwNode& rNode, sal_uLong nIdx, bool bSearc else { SwNodeIndex aTmp( rNode, -1 ); - pNd = GoNextWithFrm( rNode.GetNodes(), &aTmp ); + pNd = GoNextWithFrame( rNode.GetNodes(), &aTmp ); bMaster = true; if( !bSearch && pNd && rNode.EndOfSectionIndex() < pNd->GetIndex() ) pNd = nullptr; // Do not go over the limits @@ -168,7 +168,7 @@ SwNode2LayImpl::SwNode2LayImpl( const SwNode& rNode, sal_uLong nIdx, bool bSearc OSL_ENSURE( pNd->IsTableNode(), "For Tablenodes only" ); pMod = pNd->GetTableNode()->GetTable().GetFrameFormat(); } - pIter = new SwIterator<SwFrm,SwModify>( *pMod ); + pIter = new SwIterator<SwFrame,SwModify>( *pMod ); } else { @@ -187,13 +187,13 @@ SwNode2LayImpl::SwNode2LayImpl( const SwNode& rNode, sal_uLong nIdx, bool bSearc * When inserting after it, we find and return the last Follow starting * from the Master. * - * If the Frame is located in a SectionFrm, we check to see whether the + * If the Frame is located in a SectionFrame, we check to see whether the * SectionFrame is the suitable return value (instead of the Frame itself). * This is the case if the to-be-inserted Node is outside of the Section. */ -SwFrm* SwNode2LayImpl::NextFrm() +SwFrame* SwNode2LayImpl::NextFrame() { - SwFrm* pRet; + SwFrame* pRet; if( !pIter ) return nullptr; if( !bInit ) @@ -205,7 +205,7 @@ SwFrm* SwNode2LayImpl::NextFrm() pRet = pIter->Next(); while( pRet ) { - SwFlowFrm* pFlow = SwFlowFrm::CastFlowFrm( pRet ); + SwFlowFrame* pFlow = SwFlowFrame::CastFlowFrame( pRet ); OSL_ENSURE( pFlow, "Content or Table expected?!" ); // Follows are pretty volatile, thus we ignore them. // Even if we insert after the Frame, we start from the Master @@ -216,16 +216,16 @@ SwFrm* SwNode2LayImpl::NextFrm() { while( pFlow->HasFollow() ) pFlow = pFlow->GetFollow(); - pRet = &(pFlow->GetFrm()); + pRet = &(pFlow->GetFrame()); } if( pRet->IsInSct() ) { - SwSectionFrm* pSct = pRet->FindSctFrm(); + SwSectionFrame* pSct = pRet->FindSctFrame(); // ATTENTION: If we are in a Footnote, from a Layout point of view // it could be located in a Section with columns, although it // should be outside of it when looking at the Nodes. // Thus, when dealing with Footnotes, we need to check whether the - // SectionFrm is also located within the Footnote and not outside of it. + // SectionFrame is also located within the Footnote and not outside of it. if( !pRet->IsInFootnote() || pSct->IsInFootnote() ) { OSL_ENSURE( pSct && pSct->GetSection(), "Where's my section?" ); @@ -233,7 +233,7 @@ SwFrm* SwNode2LayImpl::NextFrm() OSL_ENSURE( pNd, "Lost SectionNode" ); // If the result Frame is located within a Section Frame // whose Section does not contain the Node, we return with - // the SectionFrm, else we return with the Content/TabFrm + // the SectionFrame, else we return with the Content/TabFrame if( bMaster ) { if( pNd->GetIndex() >= nIndex ) @@ -250,24 +250,24 @@ SwFrm* SwNode2LayImpl::NextFrm() return nullptr; } -void SwNode2LayImpl::SaveUpperFrms() +void SwNode2LayImpl::SaveUpperFrames() { - pUpperFrms = new std::vector<SwFrm*>; - SwFrm* pFrm; - while( nullptr != (pFrm = NextFrm()) ) + pUpperFrames = new std::vector<SwFrame*>; + SwFrame* pFrame; + while( nullptr != (pFrame = NextFrame()) ) { - SwFrm* pPrv = pFrm->GetPrev(); - pFrm = pFrm->GetUpper(); - if( pFrm ) + SwFrame* pPrv = pFrame->GetPrev(); + pFrame = pFrame->GetUpper(); + if( pFrame ) { - if( pFrm->IsFootnoteFrm() ) - static_cast<SwFootnoteFrm*>(pFrm)->ColLock(); - else if( pFrm->IsInSct() ) - pFrm->FindSctFrm()->ColLock(); - if( pPrv && pPrv->IsSctFrm() ) - static_cast<SwSectionFrm*>(pPrv)->LockJoin(); - pUpperFrms->push_back( pPrv ); - pUpperFrms->push_back( pFrm ); + if( pFrame->IsFootnoteFrame() ) + static_cast<SwFootnoteFrame*>(pFrame)->ColLock(); + else if( pFrame->IsInSct() ) + pFrame->FindSctFrame()->ColLock(); + if( pPrv && pPrv->IsSctFrame() ) + static_cast<SwSectionFrame*>(pPrv)->LockJoin(); + pUpperFrames->push_back( pPrv ); + pUpperFrames->push_back( pFrame ); } } delete pIter; @@ -275,149 +275,149 @@ void SwNode2LayImpl::SaveUpperFrms() pMod = nullptr; } -SwLayoutFrm* SwNode2LayImpl::UpperFrm( SwFrm* &rpFrm, const SwNode &rNode ) +SwLayoutFrame* SwNode2LayImpl::UpperFrame( SwFrame* &rpFrame, const SwNode &rNode ) { - rpFrm = NextFrm(); - if( !rpFrm ) + rpFrame = NextFrame(); + if( !rpFrame ) return nullptr; - SwLayoutFrm* pUpper = rpFrm->GetUpper(); - if( rpFrm->IsSctFrm() ) + SwLayoutFrame* pUpper = rpFrame->GetUpper(); + if( rpFrame->IsSctFrame() ) { const SwNode* pNode = rNode.StartOfSectionNode(); if( pNode->IsSectionNode() ) { - SwFrm* pFrm = bMaster ? rpFrm->FindPrev() : rpFrm->FindNext(); - if( pFrm && pFrm->IsSctFrm() ) + SwFrame* pFrame = bMaster ? rpFrame->FindPrev() : rpFrame->FindNext(); + if( pFrame && pFrame->IsSctFrame() ) { - // pFrm could be a "dummy"-section - if( static_cast<SwSectionFrm*>(pFrm)->GetSection() && + // pFrame could be a "dummy"-section + if( static_cast<SwSectionFrame*>(pFrame)->GetSection() && (&static_cast<const SwSectionNode*>(pNode)->GetSection() == - static_cast<SwSectionFrm*>(pFrm)->GetSection()) ) + static_cast<SwSectionFrame*>(pFrame)->GetSection()) ) { // #i22922# - consider columned sections // 'Go down' the section frame as long as the layout frame // is found, which would contain content. - while ( pFrm->IsLayoutFrm() && - static_cast<SwLayoutFrm*>(pFrm)->Lower() && - !static_cast<SwLayoutFrm*>(pFrm)->Lower()->IsFlowFrm() && - static_cast<SwLayoutFrm*>(pFrm)->Lower()->IsLayoutFrm() ) + while ( pFrame->IsLayoutFrame() && + static_cast<SwLayoutFrame*>(pFrame)->Lower() && + !static_cast<SwLayoutFrame*>(pFrame)->Lower()->IsFlowFrame() && + static_cast<SwLayoutFrame*>(pFrame)->Lower()->IsLayoutFrame() ) { - pFrm = static_cast<SwLayoutFrm*>(pFrm)->Lower(); + pFrame = static_cast<SwLayoutFrame*>(pFrame)->Lower(); } - OSL_ENSURE( pFrm->IsLayoutFrm(), - "<SwNode2LayImpl::UpperFrm(..)> - expected upper frame isn't a layout frame." ); - rpFrm = bMaster ? nullptr - : static_cast<SwLayoutFrm*>(pFrm)->Lower(); - OSL_ENSURE( !rpFrm || rpFrm->IsFlowFrm(), - "<SwNode2LayImpl::UpperFrm(..)> - expected sibling isn't a flow frame." ); - return static_cast<SwLayoutFrm*>(pFrm); + OSL_ENSURE( pFrame->IsLayoutFrame(), + "<SwNode2LayImpl::UpperFrame(..)> - expected upper frame isn't a layout frame." ); + rpFrame = bMaster ? nullptr + : static_cast<SwLayoutFrame*>(pFrame)->Lower(); + OSL_ENSURE( !rpFrame || rpFrame->IsFlowFrame(), + "<SwNode2LayImpl::UpperFrame(..)> - expected sibling isn't a flow frame." ); + return static_cast<SwLayoutFrame*>(pFrame); } - pUpper = new SwSectionFrm(const_cast<SwSectionNode*>(static_cast<const SwSectionNode*>(pNode))->GetSection(), rpFrm); - pUpper->Paste( rpFrm->GetUpper(), - bMaster ? rpFrm : rpFrm->GetNext() ); - static_cast<SwSectionFrm*>(pUpper)->Init(); - rpFrm = nullptr; + pUpper = new SwSectionFrame(const_cast<SwSectionNode*>(static_cast<const SwSectionNode*>(pNode))->GetSection(), rpFrame); + pUpper->Paste( rpFrame->GetUpper(), + bMaster ? rpFrame : rpFrame->GetNext() ); + static_cast<SwSectionFrame*>(pUpper)->Init(); + rpFrame = nullptr; // 'Go down' the section frame as long as the layout frame // is found, which would contain content. while ( pUpper->Lower() && - !pUpper->Lower()->IsFlowFrm() && - pUpper->Lower()->IsLayoutFrm() ) + !pUpper->Lower()->IsFlowFrame() && + pUpper->Lower()->IsLayoutFrame() ) { - pUpper = static_cast<SwLayoutFrm*>(pUpper->Lower()); + pUpper = static_cast<SwLayoutFrame*>(pUpper->Lower()); } return pUpper; } } } if( !bMaster ) - rpFrm = rpFrm->GetNext(); + rpFrame = rpFrame->GetNext(); return pUpper; } -void SwNode2LayImpl::RestoreUpperFrms( SwNodes& rNds, sal_uLong nStt, sal_uLong nEnd ) +void SwNode2LayImpl::RestoreUpperFrames( SwNodes& rNds, sal_uLong nStt, sal_uLong nEnd ) { - OSL_ENSURE( pUpperFrms, "RestoreUpper without SaveUpper?" ); + OSL_ENSURE( pUpperFrames, "RestoreUpper without SaveUpper?" ); SwNode* pNd; SwDoc *pDoc = rNds.GetDoc(); bool bFirst = true; for( ; nStt < nEnd; ++nStt ) { - SwFrm* pNew = nullptr; - SwFrm* pNxt; - SwLayoutFrm* pUp; + SwFrame* pNew = nullptr; + SwFrame* pNxt; + SwLayoutFrame* pUp; if( (pNd = rNds[nStt])->IsContentNode() ) - for( std::vector<SwFrm*>::size_type n = 0; n < pUpperFrms->size(); ) + for( std::vector<SwFrame*>::size_type n = 0; n < pUpperFrames->size(); ) { - pNxt = (*pUpperFrms)[n++]; - if( bFirst && pNxt && pNxt->IsSctFrm() ) - static_cast<SwSectionFrm*>(pNxt)->UnlockJoin(); - pUp = static_cast<SwLayoutFrm*>((*pUpperFrms)[n++]); + pNxt = (*pUpperFrames)[n++]; + if( bFirst && pNxt && pNxt->IsSctFrame() ) + static_cast<SwSectionFrame*>(pNxt)->UnlockJoin(); + pUp = static_cast<SwLayoutFrame*>((*pUpperFrames)[n++]); if( pNxt ) pNxt = pNxt->GetNext(); else pNxt = pUp->Lower(); - pNew = static_cast<SwContentNode*>(pNd)->MakeFrm( pUp ); + pNew = static_cast<SwContentNode*>(pNd)->MakeFrame( pUp ); pNew->Paste( pUp, pNxt ); - (*pUpperFrms)[n-2] = pNew; + (*pUpperFrames)[n-2] = pNew; } else if( pNd->IsTableNode() ) - for( std::vector<SwFrm*>::size_type x = 0; x < pUpperFrms->size(); ) + for( std::vector<SwFrame*>::size_type x = 0; x < pUpperFrames->size(); ) { - pNxt = (*pUpperFrms)[x++]; - if( bFirst && pNxt && pNxt->IsSctFrm() ) - static_cast<SwSectionFrm*>(pNxt)->UnlockJoin(); - pUp = static_cast<SwLayoutFrm*>((*pUpperFrms)[x++]); + pNxt = (*pUpperFrames)[x++]; + if( bFirst && pNxt && pNxt->IsSctFrame() ) + static_cast<SwSectionFrame*>(pNxt)->UnlockJoin(); + pUp = static_cast<SwLayoutFrame*>((*pUpperFrames)[x++]); if( pNxt ) pNxt = pNxt->GetNext(); else pNxt = pUp->Lower(); - pNew = static_cast<SwTableNode*>(pNd)->MakeFrm( pUp ); - OSL_ENSURE( pNew->IsTabFrm(), "Table expected" ); + pNew = static_cast<SwTableNode*>(pNd)->MakeFrame( pUp ); + OSL_ENSURE( pNew->IsTabFrame(), "Table expected" ); pNew->Paste( pUp, pNxt ); - static_cast<SwTabFrm*>(pNew)->RegistFlys(); - (*pUpperFrms)[x-2] = pNew; + static_cast<SwTabFrame*>(pNew)->RegistFlys(); + (*pUpperFrames)[x-2] = pNew; } else if( pNd->IsSectionNode() ) { nStt = pNd->EndOfSectionIndex(); - for( std::vector<SwFrm*>::size_type x = 0; x < pUpperFrms->size(); ) + for( std::vector<SwFrame*>::size_type x = 0; x < pUpperFrames->size(); ) { - pNxt = (*pUpperFrms)[x++]; - if( bFirst && pNxt && pNxt->IsSctFrm() ) - static_cast<SwSectionFrm*>(pNxt)->UnlockJoin(); - pUp = static_cast<SwLayoutFrm*>((*pUpperFrms)[x++]); - OSL_ENSURE( pUp->GetUpper() || pUp->IsFlyFrm(), "Lost Upper" ); + pNxt = (*pUpperFrames)[x++]; + if( bFirst && pNxt && pNxt->IsSctFrame() ) + static_cast<SwSectionFrame*>(pNxt)->UnlockJoin(); + pUp = static_cast<SwLayoutFrame*>((*pUpperFrames)[x++]); + OSL_ENSURE( pUp->GetUpper() || pUp->IsFlyFrame(), "Lost Upper" ); ::_InsertCnt( pUp, pDoc, pNd->GetIndex(), false, nStt+1, pNxt ); pNxt = pUp->GetLastLower(); - (*pUpperFrms)[x-2] = pNxt; + (*pUpperFrames)[x-2] = pNxt; } } bFirst = false; } - for( std::vector<SwFrm*>::size_type x = 0; x < pUpperFrms->size(); ++x ) + for( std::vector<SwFrame*>::size_type x = 0; x < pUpperFrames->size(); ++x ) { - SwFrm* pTmp = (*pUpperFrms)[++x]; - if( pTmp->IsFootnoteFrm() ) - static_cast<SwFootnoteFrm*>(pTmp)->ColUnlock(); + SwFrame* pTmp = (*pUpperFrames)[++x]; + if( pTmp->IsFootnoteFrame() ) + static_cast<SwFootnoteFrame*>(pTmp)->ColUnlock(); else if ( pTmp->IsInSct() ) { - SwSectionFrm* pSctFrm = pTmp->FindSctFrm(); - pSctFrm->ColUnlock(); + SwSectionFrame* pSctFrame = pTmp->FindSctFrame(); + pSctFrame->ColUnlock(); // #i18103# - invalidate size of section in order to // assure, that the section is formatted, unless it was 'Collocked' // from its 'collection' until its 'restoration'. - pSctFrm->_InvalidateSize(); + pSctFrame->_InvalidateSize(); } } } -SwFrm* SwNode2LayImpl::GetFrm( const Point* pDocPos, +SwFrame* SwNode2LayImpl::GetFrame( const Point* pDocPos, const SwPosition *pPos, - const bool bCalcFrm ) const + const bool bCalcFrame ) const { // test if change of member pIter -> pMod broke anything - return pMod ? ::GetFrmOfModify( nullptr, *pMod, USHRT_MAX, pDocPos, pPos, bCalcFrm ) : nullptr; + return pMod ? ::GetFrameOfModify( nullptr, *pMod, USHRT_MAX, pDocPos, pPos, bCalcFrame ) : nullptr; } SwNode2Layout::SwNode2Layout( const SwNode& rNd, sal_uLong nIdx ) @@ -428,34 +428,34 @@ SwNode2Layout::SwNode2Layout( const SwNode& rNd, sal_uLong nIdx ) SwNode2Layout::SwNode2Layout( const SwNode& rNd ) : pImpl( new SwNode2LayImpl( rNd, rNd.GetIndex(), true ) ) { - pImpl->SaveUpperFrms(); + pImpl->SaveUpperFrames(); } -void SwNode2Layout::RestoreUpperFrms( SwNodes& rNds, sal_uLong nStt, sal_uLong nEnd ) +void SwNode2Layout::RestoreUpperFrames( SwNodes& rNds, sal_uLong nStt, sal_uLong nEnd ) { - OSL_ENSURE( pImpl, "RestoreUpperFrms without SaveUpperFrms" ); - pImpl->RestoreUpperFrms( rNds, nStt, nEnd ); + OSL_ENSURE( pImpl, "RestoreUpperFrames without SaveUpperFrames" ); + pImpl->RestoreUpperFrames( rNds, nStt, nEnd ); } -SwFrm* SwNode2Layout::NextFrm() +SwFrame* SwNode2Layout::NextFrame() { - return pImpl->NextFrm(); + return pImpl->NextFrame(); } -SwLayoutFrm* SwNode2Layout::UpperFrm( SwFrm* &rpFrm, const SwNode &rNode ) +SwLayoutFrame* SwNode2Layout::UpperFrame( SwFrame* &rpFrame, const SwNode &rNode ) { - return pImpl->UpperFrm( rpFrm, rNode ); + return pImpl->UpperFrame( rpFrame, rNode ); } SwNode2Layout::~SwNode2Layout() { } -SwFrm* SwNode2Layout::GetFrm( const Point* pDocPos, +SwFrame* SwNode2Layout::GetFrame( const Point* pDocPos, const SwPosition *pPos, - const bool bCalcFrm ) const + const bool bCalcFrame ) const { - return pImpl->GetFrm( pDocPos, pPos, bCalcFrm ); + return pImpl->GetFrame( pDocPos, pPos, bCalcFrame ); } /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |