/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the LibreOffice project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. * * This file incorporates work covered by the following license notice: * * 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 .
*/
/// @return true if any follow has the JoinLocked flag bool SwFlowFrame::HasLockedFollow() const
{ const SwFlowFrame* pFrame = GetFollow(); while( pFrame )
{ if( pFrame->IsJoinLocked() ) returntrue;
pFrame = pFrame->GetFollow();
} returnfalse;
}
bool SwFlowFrame::IsKeepFwdMoveAllowed( bool bIgnoreMyOwnKeepValue )
{ // If all the predecessors up to the first of the chain have // the 'keep' attribute set, and the first of the chain's // IsFwdMoveAllowed returns false, then we're not allowed to move.
SwFrame *pFrame = &m_rThis; if ( !pFrame->IsInFootnote() ) { if ( bIgnoreMyOwnKeepValue && pFrame->GetIndPrev() )
pFrame = pFrame->GetIndPrev(); do
{ if (pFrame->GetAttrSet()->GetKeep().GetValue()
|| pFrame->IsHiddenNow())
pFrame = pFrame->GetIndPrev(); else returntrue;
} while ( pFrame );
} //See IsFwdMoveAllowed() bool bRet = false; if ( pFrame && pFrame->GetIndPrev() )
bRet = true; return bRet;
}
void SwFlowFrame::CheckKeep()
{ // Kick off the "last" predecessor with a 'keep' attribute, because // it's possible for the whole troop to move back.
SwFrame *pPre = m_rThis.GetIndPrev();
assert(pPre); while (pPre && pPre->IsHiddenNow())
{
pPre = pPre->GetIndPrev();
} if (!pPre)
{ return;
} if( pPre->IsSctFrame() )
{
SwFrame *pLast = static_cast<SwSectionFrame*>(pPre)->FindLastContent(); while (pLast && pLast->IsHiddenNow())
{
pLast = pLast->GetIndPrev();
} if( pLast && pLast->FindSctFrame() == pPre )
pPre = pLast; else return;
}
SwFrame* pTmp{pPre}; bool bKeep; while ( (bKeep = pPre->GetAttrSet()->GetKeep().GetValue()) &&
nullptr != (pTmp = pTmp->GetIndPrev()) )
{ if (pTmp->IsHiddenNow())
{ continue;
} if( pTmp->IsSctFrame() )
{
SwFrame *pLast = static_cast<SwSectionFrame*>(pTmp)->FindLastContent(); while (pLast && pLast->IsHiddenNow())
{
pLast = pLast->GetIndPrev();
} if( pLast && pLast->FindSctFrame() == pTmp )
pTmp = pLast; else break;
}
pPre = pTmp;
} if ( bKeep )
pPre->InvalidatePos();
}
namespace
{ /** * Determines if the next content frame after rThis will require the full area of the parent body * frame.
*/ bool IsNextContentFullPage(const SwFrame& rThis)
{ const SwFrame* pNext = rThis.FindNextCnt(); if (!pNext)
{ returnfalse;
}
// At this point the height of the draw object will use all the vertical available space, // and also no wrapping will be performed, so all horizontal space will be taken as well. returntrue;
}
returnfalse;
}
}
bool SwFlowFrame::IsKeep(SvxFormatKeepItem const& rKeep,
SvxFormatBreakItem const& rBreak, boolconst bCheckIfLastRowShouldKeep) const
{
assert(m_rThis.IsTextFrame() ? !static_cast<SwTextFrame const&>(m_rThis).IsHiddenNowImpl() : !m_rThis.IsHiddenNow()); // check it before? // 1. The keep attribute is ignored inside footnotes // 2. For compatibility reasons, the keep attribute is // ignored for frames inside table cells // 3. If bBreakCheck is set to true, this function only checks // if there are any break after attributes set at rAttrs // or break before attributes set for the next content (or next table) // 4. Keep is ignored if the next frame will require its own page. bool bKeep = bCheckIfLastRowShouldKeep ||
( !m_rThis.IsInFootnote() &&
( !m_rThis.IsInTab() || m_rThis.IsTabFrame() ) &&
rKeep.GetValue() && !IsNextContentFullPage(m_rThis));
if (bKeep && m_rThis.IsTextFrame())
{ auto& rTextFrame = static_cast<SwTextFrame&>(m_rThis); if (rTextFrame.HasNonLastSplitFlyDrawObj())
{ // Allow split for the non-last anchors of a split fly, even if rKeep.GetValue() is // true.
bKeep = false;
}
}
OSL_ENSURE( !bCheckIfLastRowShouldKeep || m_rThis.IsTabFrame(), "IsKeep with bCheckIfLastRowShouldKeep should only be used for tabfrms" );
// Ignore keep attribute if there are break situations: if ( bKeep )
{ switch (rBreak.GetBreak())
{ case SvxBreak::ColumnAfter: case SvxBreak::ColumnBoth: case SvxBreak::PageAfter: case SvxBreak::PageBoth:
{
bKeep = false; break;
} default: break;
} if ( bKeep )
{
SwFrame *pNxt; if( nullptr != (pNxt = m_rThis.FindNextCnt()) &&
(!m_pFollow || pNxt != &m_pFollow->GetFrame()))
{ // The last row of a table only keeps with the next content // it they are in the same section: if ( bCheckIfLastRowShouldKeep )
{ const SwSection* pThisSection = nullptr; const SwSection* pNextSection = nullptr; const SwSectionFrame* pThisSectionFrame = m_rThis.FindSctFrame(); const SwSectionFrame* pNextSectionFrame = pNxt->FindSctFrame();
if ( pThisSectionFrame )
pThisSection = pThisSectionFrame->GetSection();
if ( pNextSectionFrame )
pNextSection = pNextSectionFrame->GetSection();
if ( pThisSection != pNextSection )
bKeep = false;
}
if (pPageDesc->GetPageDesc())
bKeep = false; elseswitch (pBreak->GetBreak())
{ case SvxBreak::ColumnBefore: case SvxBreak::ColumnBoth: case SvxBreak::PageBefore: case SvxBreak::PageBoth:
bKeep = false; break; default: break;
}
}
}
}
} return bKeep;
}
SwFrame * SwFlowFrame::FindPrevIgnoreHidden() const
{
SwFrame * pRet{m_rThis.FindPrev()}; while (pRet && pRet->IsHiddenNow())
{
pRet = pRet->FindPrev();
} return pRet;
}
SwFrame * SwFlowFrame::FindNextIgnoreHidden() const
{
SwFrame * pRet{m_rThis.FindNext()}; while (pRet && pRet->IsHiddenNow())
{
pRet = pRet->FindNext();
} return pRet;
}
sal_uInt8 SwFlowFrame::BwdMoveNecessary( const SwPageFrame *pPage, const SwRect &rRect )
{ // The return value helps deciding whether we need to flow back (3), // or whether we can use the good old WouldFit (0, 1), or if // it's reasonable to relocate and test-format (2).
// Bit 1 in this case means that there are objects anchored to myself, // bit 2 means that I have to evade other objects.
// If a SurroundObj that desires to be wrapped around overlaps with the // Rect, it's required to flow (because we can't guess the relationships). // However it's possible for a test formatting to happen. // If the SurroundObj is a Fly and I'm a Lower, or the Fly is a Lower of // mine, then it doesn't matter. // If the SurroundObj is anchored in a character bound Fly, and I'm not // a Lower of that character bound Fly myself, then the Fly doesn't matter.
// If the object is anchored with me, i can ignore it, because // it's likely that it will follow me with the flow. A test formatting is // not allowed in that case, however!
sal_uInt8 nRet = 0;
SwFlowFrame *pTmp = this; do
{ // If there are objects hanging either on me or on a follow, we can't // do a test formatting, because paragraph bound objects wouldn't // be properly considered, and character bound objects shouldn't // be test formatted at all. if( pTmp->GetFrame().GetDrawObjs() )
nRet = 1;
pTmp = pTmp->GetFollow();
} while ( !nRet && pTmp ); const SwSortedObjs *pObjs = pPage ? pPage->GetSortedObjs() : nullptr; if (pObjs)
{
const SwSortedObjs &rObjs = *pObjs;
SwNodeOffset nIndex = NODE_OFFSET_MAX; for ( size_t i = 0; nRet < 3 && i < rObjs.size(); ++i )
{
// Don't do this if the object is anchored behind me in the text // flow, because then I wouldn't evade it. if ( ::IsFrameInSameContext( pAnchor, &m_rThis ) )
{ if ( pFormat->GetAnchor().GetAnchorId() == RndStdIds::FLY_AT_PARA )
{ // The index of the other one can be retrieved using the anchor attribute.
SwNodeOffset nTmpIndex = pFormat->GetAnchor().GetAnchorNode()->GetIndex(); // Now we're going to check whether the current paragraph before // the anchor of the displacing object sits in the text. If this // is the case, we don't try to evade it. // The index is being determined via SwFormatAnchor, because it's // getting quite expensive otherwise. if( NODE_OFFSET_MAX == nIndex )
{ const SwNode *pNode; if (m_rThis.IsTextFrame())
pNode = static_cast<SwTextFrame&>(m_rThis).GetTextNodeFirst(); elseif (m_rThis.IsNoTextFrame())
pNode = static_cast<SwNoTextFrame&>(m_rThis).GetNode(); elseif( m_rThis.IsSctFrame() )
pNode = static_cast<SwSectionFormat*>(static_cast<SwSectionFrame&>(m_rThis).
GetFormat())->GetSectionNode(); else
{
assert(!m_rThis.IsContentFrame());
OSL_ENSURE( m_rThis.IsTabFrame(), "new FowFrame?" );
pNode = static_cast<SwTabFrame&>(m_rThis).GetTable()->
GetTabSortBoxes()[0]->GetSttNd()->FindTableNode();
}
nIndex = pNode->GetIndex();
} if (nIndex < nTmpIndex &&
(!m_rThis.IsTextFrame() ||
!FrameContainsNode(static_cast<SwTextFrame&>(m_rThis), nTmpIndex)))
{ continue;
}
}
} else continue;
nRet |= 2;
}
}
} return nRet;
}
/// A specialized form of Cut(), which relocates a whole chain (this and the following, /// in particular). During this process, only the minimum operations and notifications are done.
SwLayoutFrame *SwFlowFrame::CutTree( SwFrame *pStart )
{ // Cut the Start and all the neighbours; they are chained together and // a handle to the first one is returned. Residuals are invalidated // as appropriate.
SwLayoutFrame *pLay = pStart->GetUpper(); if ( pLay->IsInFootnote() )
pLay = pLay->FindFootnoteFrame();
// i#58846 // <pPrepare( PrepareHint::QuoVadis )> only for frames in footnotes if( pStart->IsInFootnote() )
{
SwFrame* pTmp = pStart->GetIndPrev(); if( pTmp )
pTmp->Prepare( PrepareHint::QuoVadis );
}
// Just cut quickly and take care that we don't cause problems with the // left-behinds. The pointers of the chain being cut can point who-knows where. if ( pStart == pStart->GetUpper()->Lower() )
pStart->GetUpper()->m_pLower = nullptr; if ( pStart->GetPrev() )
{
pStart->GetPrev()->mpNext = nullptr;
pStart->mpPrev = nullptr;
}
if ( pLay->IsFootnoteFrame() )
{ if ( !pLay->Lower() && !pLay->IsColLocked() &&
!static_cast<SwFootnoteFrame*>(pLay)->IsBackMoveLocked() )
{ // tdf#101821 don't delete it while iterating over it if (!pLay->IsDeleteForbidden())
{
pLay->Cut();
SwFrame::DestroyFrame(pLay);
} // else: assume there is code on the stack to clean up empty // footnote frames // (don't go into the else branch below, it produces a disconnected // footnote with null upper that can be returned by // SwFootnoteBossFrame::FindFootnote() causing null pointer deref // in SwTextFrame::ConnectFootnote()
} else
{ bool bUnlock = !static_cast<SwFootnoteFrame*>(pLay)->IsBackMoveLocked(); static_cast<SwFootnoteFrame*>(pLay)->LockBackMove();
pLay->InvalidateSize();
pLay->Calc(pLay->getRootFrame()->GetCurrShell()->GetOut());
SwContentFrame *pCnt = pLay->ContainsContent(); while ( pCnt && pLay->IsAnLower( pCnt ) )
{ // It's possible for the ContentFrame to be locked, and we don't want // to end up in an endless page migration, so we're not even // going to call Calc!
OSL_ENSURE( pCnt->IsTextFrame(), "The Graphic has landed." ); if ( static_cast<SwTextFrame*>(pCnt)->IsLocked() || static_cast<SwTextFrame*>(pCnt)->GetFollow() == pStart ) break;
pCnt->Calc(pCnt->getRootFrame()->GetCurrShell()->GetOut());
pCnt = pCnt->GetNextContentFrame();
} if( bUnlock ) static_cast<SwFootnoteFrame*>(pLay)->UnlockBackMove();
}
pLay = nullptr;
} return pLay;
}
/// A specialized form of Paste(), which relocates a whole chain (this and the following, /// in particular). During this process, only the minimum operations and notifications are done. bool SwFlowFrame::PasteTree( SwFrame *pStart, SwLayoutFrame *pParent, SwFrame *pSibling,
SwFrame *pOldParent )
{ // returns true if there's a LayoutFrame in the chain. bool bRet = false;
// The chain beginning with pStart is inserted before pSibling // under the parent. We take care to invalidate as required.
// I'm receiving a finished chain. We need to update the pointers for // the beginning of the chain, then all the uppers and finally the end. // On the way there, we invalidate as required. if ( pSibling )
{
pStart->mpPrev = pSibling->GetPrev(); if ( nullptr != pStart->mpPrev )
pStart->GetPrev()->mpNext = pStart; else
pParent->m_pLower = pStart;
pSibling->InvalidatePos_();
pSibling->InvalidatePrt_();
} else
{
pStart->mpPrev = pParent->Lower(); if ( nullptr == pStart->mpPrev )
pParent->m_pLower = pStart; else //i#100782 //If the pParent has more than 1 child nodes, former design will //ignore them directly without any collection work. It will make some //dangling pointers. This lead the crash... //The new design will find the last child of pParent in loop way, and //add the pStart after the last child. // pParent->Lower()->pNext = pStart;
{
SwFrame* pTemp = pParent->m_pLower; while (pTemp)
{ if (pTemp->mpNext)
pTemp = pTemp->mpNext; else
{
pStart->mpPrev = pTemp;
pTemp->mpNext = pStart; break;
}
}
}
// i#27145 if ( pParent->IsSctFrame() )
{ // We have no sibling because pParent is a section frame and // has just been created to contain some content. The printing // area of the frame behind pParent has to be invalidated, so // that the correct distance between pParent and the next frame // can be calculated.
pParent->InvalidateNextPrtArea();
}
}
SwFrame *pFloat = pStart;
SwFrame *pLst = nullptr;
SwRectFnSet aRectFnSet(pParent);
SwTwips nGrowVal = 0; do
{ pFloat->mpUpper = pParent;
pFloat->InvalidateAll_();
pFloat->InvalidateInfFlags();
pFloat->CheckDirChange();
// I'm a friend of the TextFrame and thus am allowed to do many things. // The CacheIdx idea seems to be a bit risky! if ( pFloat->IsTextFrame() )
{ if ( static_cast<SwTextFrame*>(pFloat)->GetCacheIdx() != USHRT_MAX ) static_cast<SwTextFrame*>(pFloat)->Init(); // I'm his friend.
} else
bRet = true;
SwIterator<SwTabFrame,SwFormat> aIter( *GetTable()->GetFrameFormat() );
SwTabFrame* pTab = aIter.First(); while ( pTab )
{ if ( bFirstMaster )
{ // Optimization. This makes code like this obsolete: // while ( pTab->IsFollow() ) // pTab = pTab->FindMaster();
if ( !pTab->IsFollow() )
{
SwTabFrame* pNxt = pTab; while ( pNxt )
{ if ( pNxt->GetFollow() == this ) return pTab;
pNxt = pNxt->GetFollow();
}
}
} else
{ if ( pTab->GetFollow() == this ) return pTab;
}
pTab = aIter.Next();
}
OSL_FAIL( "Follow is lost in Space." ); return nullptr;
}
/** * Returns the next/previous Layout leaf that's NOT below this (or even is this itself). * Also, that leaf must be in the same text flow as the pAnch origin frame (Body, Footnote)
*/ const SwLayoutFrame *SwFrame::GetLeaf( MakePageType eMakePage, bool bFwd, const SwFrame *pAnch ) const
{ // No flow, no joy... if ( !(IsInDocBody() || IsInFootnote() || IsInFly()) ) return nullptr;
const SwFrame *pLeaf = this; bool bFound = false;
do
{ pLeaf = const_cast<SwFrame*>(pLeaf)->GetLeaf( eMakePage, bFwd );
// i#53323 // A frame could be inside a table AND inside a section. // Thus, it has to be determined, which is the first parent. bool bInTab( IsInTab() ); bool bInSct( IsInSct() ); if ( bInTab && bInSct )
{ const SwFrame* pUpperFrame( GetUpper() ); while ( pUpperFrame )
{ if ( pUpperFrame->IsTabFrame() )
{ // the table is the first.
bInSct = false; break;
} elseif ( pUpperFrame->IsSctFrame() )
{ // the section is the first.
bInTab = false; break;
}
pUpperFrame = pUpperFrame->GetUpper();
}
}
if ( bInTab && ( !IsTabFrame() || GetUpper()->IsCellFrame() ) ) // TABLE IN TABLE return bFwd ? GetNextCellLeaf() : GetPrevCellLeaf();
bool SwFrame::WrongPageDesc( SwPageFrame* pNew )
{ // Now it's getting a bit complicated:
// Maybe I'm bringing a Pagedesc myself; in that case, // the pagedesc of the next page needs to correspond. // Otherwise, I'll have to dig a bit deeper to see where // the following Pagedesc is coming from. // If the following page itself tells me that it's pagedesc // is wrong, I can happily exchange it. // If the page however thinks that it's pagedesc is correct, // this doesn't mean it's useful to me: // If the first BodyContent asks for a PageDesc or a PageBreak, // I'll have to insert a new page - except the desired page is // the correct one. // If I inserted a new page, the problems only get started: // because then it's likely for the next page to have been // wrong and having been swapped because of that. // This in turn means that I have a new (and correct) page, // but the conditions to swap still apply. // Way out of the situation: Try to preliminarily insert a // new page once (empty pages are already inserted by InsertPage() // if required)
// Does the Content bring a Pagedesc or do we need the // virtual page number of the new layout leaf? // PageDesc isn't allowed with Follows constbool isRightPage = oTmp ? sw::IsRightPageByNumber(*mpRoot, *oTmp) : pNew->OnRightPage(); if ( !pDesc )
pDesc = pNew->FindPageDesc();
/// Returns the next layout leaf in which we can move the frame.
SwLayoutFrame *SwFrame::GetNextLeaf( MakePageType eMakePage )
{
OSL_ENSURE( !IsInFootnote(), "GetNextLeaf(), don't call me for Footnote." );
OSL_ENSURE( !IsInSct(), "GetNextLeaf(), don't call me for Sections." );
constbool bBody = IsInDocBody(); // If I'm coming from the DocBody, // I want to end up in the body.
// It doesn't make sense to insert pages, as we only want to search the // chain. if( IsInFly() )
eMakePage = MAKEPAGE_NONE;
// For tables, we just take the big leap. A simple GetNext would // iterate through the first cells and, in turn, all other cells.
SwLayoutFrame *pLayLeaf = nullptr; if ( IsTabFrame() )
{
SwFrame *const pTmp = static_cast<SwTabFrame*>(this)->FindLastContentOrTable(); if ( pTmp )
pLayLeaf = pTmp->GetUpper();
} if ( !pLayLeaf )
pLayLeaf = GetNextLayoutLeaf();
SwLayoutFrame *pOldLayLeaf = nullptr; // Make sure that we don't have to // start searching from top when we // have a freshly created page. bool bNewPg = false; // Only insert a new page once.
while ( true )
{ if ( pLayLeaf )
{ // There's yet another LayoutFrame. Let's see if it's ready to host // me as well. // It only needs to be of the same kind like my starting point // (DocBody or Footnote respectively) if ( pLayLeaf->FindPageFrame()->IsFootnotePage() )
{ // If I ended up at the end note pages, we're done.
pLayLeaf = nullptr; continue;
} if ( (bBody && !pLayLeaf->IsInDocBody()) || pLayLeaf->IsInTab()
|| pLayLeaf->IsInSct() )
{ // They don't want me! Try again
pOldLayLeaf = pLayLeaf;
pLayLeaf = pLayLeaf->GetNextLayoutLeaf(); continue;
}
// I'm wanted, therefore I'm done. However, it may still be that, // during a page break, the page type isn't the desired one. In that // case we have to insert a page of the correct type.
SwPageFrame *pNew = pLayLeaf->FindPageFrame(); const SwViewShell *pSh = getRootFrame()->GetCurrShell(); // The pagedesc check does not make sense for frames in fly frames if ( pNew != FindPageFrame() && !bNewPg && !IsInFly() && // i#46683 // Do not consider page descriptions in browse mode (since // MoveBwd ignored them)
!(pSh && pSh->GetViewOptions()->getBrowseMode() ) )
{ if( WrongPageDesc( pNew ) )
{
SwFootnoteContFrame *pCont = pNew->FindFootnoteCont(); if( pCont )
{ // If the reference of the first footnote of this page // lies before the page, we'd rather not insert a new page.
SwFootnoteFrame *pFootnote = static_cast<SwFootnoteFrame*>(pCont->Lower()); if( pFootnote && pFootnote->GetRef() )
{ const sal_uInt16 nRefNum = pNew->GetPhyPageNum(); if( pFootnote->GetRef()->GetPhyPageNum() < nRefNum ) break;
}
} //Gotcha! The following page is wrong, therefore we need to //insert a new one. if ( eMakePage == MAKEPAGE_INSERT )
{
bNewPg = true;
SwPageFrame *pPg = pOldLayLeaf ?
pOldLayLeaf->FindPageFrame() : nullptr; if ( pPg && pPg->IsEmptyPage() ) // Don't insert behind. Insert before the EmptyPage.
pPg = static_cast<SwPageFrame*>(pPg->GetPrev());
if ( !pPg || pPg == pNew )
pPg = FindPageFrame();
InsertPage( pPg, false );
pLayLeaf = GetNextLayoutLeaf();
pOldLayLeaf = nullptr; continue;
} else
pLayLeaf = nullptr;
}
} break;
} else
{ // There's no other matching LayoutFrame, so we have to insert // a new page. if ( eMakePage == MAKEPAGE_APPEND || eMakePage == MAKEPAGE_INSERT )
{
InsertPage(
pOldLayLeaf ? pOldLayLeaf->FindPageFrame() : FindPageFrame(), false );
// And again from the start.
pLayLeaf = pOldLayLeaf ? pOldLayLeaf : GetNextLayoutLeaf();
} else break;
}
} return pLayLeaf;
}
/// Returns the previous layout leaf where we can move the frame.
SwLayoutFrame *SwFrame::GetPrevLeaf()
{
OSL_ENSURE( !IsInFootnote(), "GetPrevLeaf(), don't call me for Footnote." );
constbool bBody = IsInDocBody(); // If I'm coming from the DocBody, // I want to end up in the body. constbool bFly = IsInFly();
while ( pLayLeaf )
{ if ( pLayLeaf->IsInTab() || // Never go into tables.
pLayLeaf->IsInSct() ) // Same goes for sections!
pLayLeaf = pLayLeaf->GetPrevLayoutLeaf(); elseif ( bBody && pLayLeaf->IsInDocBody() )
{ if ( pLayLeaf->Lower() ) break;
pPrevLeaf = pLayLeaf;
pLayLeaf = pLayLeaf->GetPrevLayoutLeaf(); if ( pLayLeaf )
SwFlowFrame::SetMoveBwdJump( true );
} elseif ( bFly ) break; //Contents in Flys should accept any layout leaf. else
pLayLeaf = pLayLeaf->GetPrevLayoutLeaf();
} return pLayLeaf ? pLayLeaf : pPrevLeaf;
}
bool SwFlowFrame::IsPrevObjMove() const
{ // true: The FlowFrame must respect the a border of the predecessor, also needs // to insert a break if required.
if ( pPre && pPre->GetDrawObjs() )
{
OSL_ENSURE( SwFlowFrame::CastFlowFrame( pPre ), "new flowfrm?" ); if( SwFlowFrame::CastFlowFrame( pPre )->IsAnFollow( this ) ) returnfalse; if (SwFlowFrame::CastFlowFrame(pPre)->IsJoinLocked())
{
SwBorderAttrAccess baa(SwFrame::GetCache(), pPre);
SwBorderAttrs const& rAttrs(*baa.Get()); if (SwFlowFrame::CastFlowFrame(pPre)->IsKeep(rAttrs.GetAttrSet().GetKeep(), pPre->GetBreakItem()))
{ // pPre is currently being formatted - maybe it moved back but // its objects still have the old page's body as // mpVertPosOrientFrame and SwContentFrame::MakeAll() is calling // pNxt->Calc() in this case so allow this frame to move back returnfalse; // too, else pPre is forced to move forward again.
}
}
SwLayoutFrame* pPreUp = pPre->GetUpper(); // If the upper is a SectionFrame, or a column of a SectionFrame, we're // allowed to protrude out of it. However, we need to respect the // Upper of the SectionFrame. if( pPreUp->IsInSct() )
{ if( pPreUp->IsSctFrame() )
pPreUp = pPreUp->GetUpper(); elseif( pPreUp->IsColBodyFrame() &&
pPreUp->GetUpper()->GetUpper()->IsSctFrame() )
pPreUp = pPreUp->GetUpper()->GetUpper()->GetUpper();
} // i#26945 - re-factoring // use <GetVertPosOrientFrame()> to determine, if object has followed the // text flow to the next layout frame for (SwAnchoredObject* pObj : *pPre->GetDrawObjs())
{ const SwFrameFormat* pObjFormat = pObj->GetFrameFormat(); // Do not consider hidden objects // i#26945 - do not consider object, which // doesn't follow the text flow. if ( pObjFormat->GetDoc().getIDocumentDrawModelAccess().IsVisibleLayerId(
pObj->GetDrawObj()->GetLayer() ) &&
pObjFormat->GetFollowTextFlow().GetValue() )
{ const SwLayoutFrame* pVertPosOrientFrame = pObj->GetVertPosOrientFrame(); if ( pVertPosOrientFrame &&
pPreUp != pVertPosOrientFrame &&
!pPreUp->IsAnLower( pVertPosOrientFrame ) )
{ returntrue;
}
}
}
} returnfalse;
}
/** |* If there's a hard page break before the Frame AND there's a |* predecessor on the same page, true is returned (we need to create a |* new PageBreak). Otherwise, returns false. |* If bAct is set to true, this function returns true if |* there's a PageBreak. |* Of course, we don't evaluate the hard page break for follows. |* The page break is in its own FrameFormat (BEFORE) or in the FrameFormat of the |* predecessor (AFTER). If there's no predecessor on the page, we don't |* need to think further. |* Also, a page break (or the need for one) is also present if |* the FrameFormat contains a PageDesc. |* The implementation works only on ContentFrames! - the definition |* of the predecessor is not clear for LayoutFrames.
|*/ bool SwFlowFrame::IsPageBreak( bool bAct ) const
{ if ( !IsFollow() && m_rThis.IsInDocBody() &&
( !m_rThis.IsInTab() || ( m_rThis.IsTabFrame() && !m_rThis.GetUpper()->IsInTab() ) ) ) // i66968
{ const SwViewShell *pSh = m_rThis.getRootFrame()->GetCurrShell(); if( pSh && pSh->GetViewOptions()->getBrowseMode() ) returnfalse;
/** |* If there's a hard column break before the Frame AND there is |* a predecessor in the same column, we return true (we need to create |* a ColBreak). Otherwise, we return false. |* If bAct is set to true, we return true if there's a ColBreak. |* Of course, we don't evaluate the hard column break for follows. |* |* The column break is in its own FrameFormat (BEFORE) or in the FrameFormat of the |* predecessor (AFTER). If there's no predecessor in the column, we don't |* need to think further. |* The implementation works only on ContentFrames! - the definition |* of the predecessor is not clear for LayoutFrames.
|*/ bool SwFlowFrame::IsColBreak( bool bAct ) const
{ if ( !IsFollow() && (m_rThis.IsMoveable() || bAct) )
{ const SwFrame *pCol = m_rThis.FindColFrame(); if ( pCol )
{ // Determine predecessor const SwFrame *pPrev = m_rThis.FindPrev(); while( pPrev && ( ( !pPrev->IsInDocBody() && !m_rThis.IsInFly() && !m_rThis.FindFooterOrHeader() ) ||
pPrev->IsHiddenNow() ) )
pPrev = pPrev->FindPrev();
if ( pPrev )
{ if ( bAct )
{ if ( pCol == pPrev->FindColFrame() ) returnfalse;
} else
{ if ( pCol != pPrev->FindColFrame() ) returnfalse;
}
// Skip hidden paragraphs and empty sections staticconst SwFrame* skipHiddenFrames_(const SwFrame* pFrame)
{ do
{
pFrame = skipHiddenSiblingFrames_(pFrame); if (!pFrame || !pFrame->IsSctFrame()) return pFrame; // Special case: found previous frame is a section // Search for the last content in the section auto pSectFrame = static_cast<const SwSectionFrame*>(pFrame);
pFrame = pSectFrame->FindLastContent(); // If the last content is in a table _inside_ the section, // take the table herself. // Correction: Check directly, if table is inside table, instead of indirectly // by checking, if section isn't inside a table if (pFrame && pFrame->IsInTab())
{ const SwTabFrame* pTableFrame = pFrame->FindTabFrame(); if (pSectFrame->IsAnLower(pTableFrame)) return pTableFrame;
}
} while (true);
}
/** helper method to determine previous frame for calculation of the upper space
// Special case: no direct previous frame is found but frame is in footnote // Search for a previous frame in previous footnote, // if frame isn't in a section, which is also in the footnote const SwFootnoteFrame* pPrevFootnoteFrame = static_cast<const SwFootnoteFrame*>(m_rThis.FindFootnoteFrame()->GetPrev()); if ( pPrevFootnoteFrame ) return skipHiddenFrames_(pPrevFootnoteFrame->GetLastLower());
return nullptr;
}
// This should be renamed to something like lcl_UseULSpacing /// Compare styles attached to these text frames. staticbool lcl_IdenticalStyles(const SwFrame* pPrevFrame, const SwFrame* pFrame, bool bAllowAcrossSections = false)
{ if (!pFrame || !pFrame->IsTextFrame()) returnfalse;
// Identical styles only applies if "the paragraphs belong to the same content area". if (!bAllowAcrossSections && pPrevFrame && pPrevFrame->FindSctFrame() != pFrame->FindSctFrame()) returnfalse;
// are we even allowed to consolidate the below and above spacing between paragraphs? if (rIDSA.get(DocumentSettingId::PARA_SPACE_MAX)) // DontUseHTMLAutoSpacing return;
// Anything related to tables is skipped simply to avoid potential disaster if (!pPrevPara || pPrevPara->IsInTab()) return;
// MSO skips space between same-style paragraphs even at a sectionPageBreak. constbool bContextualSpacing = pTextFrame->GetAttrSet()->GetULSpace().GetContext(); constbool bIdenticalStyles
= bContextualSpacing
&& lcl_IdenticalStyles(pPrevPara, pTextFrame, /*AllowAcrossSections*/ true); if (bIdenticalStyles)
rUpper = 0; else
{ // MSO is also hyper-consistent about consolidating // the lower-space from the previous paragraph // with the upper spacing of this paragraph const SwTwips nPrevLowerSpace
= pPrevPara->GetAttrSet()->GetULSpace().GetLower();
rUpper = std::max<SwTwips>(rUpper - nPrevLowerSpace, 0);
}
}
// tdf#125893 always ignore own top margin setting of the actual paragraph // with contextual spacing, if the previous paragraph is identical constbool bHalfContextualSpacing = !bContextualSpacing
&& bContextualSpacingThis
&& !bContextualSpacingPrev
&& bIdenticalStyles;
// tdf#134463 always ignore own bottom margin setting of the previous paragraph // with contextual spacing, if the actual paragraph is identical constbool bHalfContextualSpacingPrev = !bContextualSpacing
&& !bContextualSpacingThis
&& bContextualSpacingPrev
&& bIdenticalStyles;
// i#11860 - use new method to determine needed spacing // values of found previous frame and use these values.
SwTwips nPrevLowerSpace = 0;
SwTwips nPrevLineSpacing = 0; // i#102458 bool bPrevLineSpacingProportional = false;
GetSpacingValuesOfFrame( (*pPrevFrame),
nPrevLowerSpace, nPrevLineSpacing,
bPrevLineSpacingProportional,
bIdenticalStyles); if( rIDSA.get(DocumentSettingId::PARA_SPACE_MAX) )
{ // FIXME: apply bHalfContextualSpacing for better portability?
nUpper = bContextualSpacing ? 0 : nPrevLowerSpace + pAttrs->GetULSpace().GetUpper();
SwTwips nAdd = nPrevLineSpacing; // i#11859 - consideration of the line spacing // for the upper spacing of a text frame if ( bUseFormerLineSpacing )
{ // former consideration if ( pOwn->IsTextFrame() )
{
nAdd = std::max( nAdd, SwTwips(static_cast<SwTextFrame*>(pOwn)->GetLineSpace()) );
}
nUpper += nAdd;
} else
{ // new consideration: // Only the proportional line spacing of the previous // text frame is considered for the upper spacing and // the line spacing values are add up instead of // building its maximum. if ( pOwn->IsTextFrame() )
{ // i#102458 // Correction: // A proportional line spacing of the previous text frame // is added up to an own leading line spacing. // Otherwise, the maximum of the leading line spacing // of the previous text frame and the own leading line // spacing is built. if ( bPrevLineSpacingProportional )
{
nAdd += static_cast<SwTextFrame*>(pOwn)->GetLineSpace( true );
} else
{
nAdd = std::max( nAdd, SwTwips(static_cast<SwTextFrame*>(pOwn)->GetLineSpace( true )) );
}
}
nUpper += nAdd;
}
} else
{
nUpper = bContextualSpacing ? 0 : std::max(
bHalfContextualSpacingPrev ? 0 : static_cast<tools::Long>(nPrevLowerSpace),
bHalfContextualSpacing ? 0 : static_cast<tools::Long>(pAttrs->GetULSpace().GetUpper()) );
// i#11859 - consideration of the line spacing // for the upper spacing of a text frame if ( bUseFormerLineSpacing )
{ // former consideration if ( pOwn->IsTextFrame() )
nUpper = std::max( nUpper, SwTwips(static_cast<SwTextFrame*>(pOwn)->GetLineSpace()) ); if ( nPrevLineSpacing != 0 )
{
nUpper = std::max( nUpper, nPrevLineSpacing );
}
} else
{ // new consideration: // Only the proportional line spacing of the previous // text frame is considered for the upper spacing and // the line spacing values are add up and added to // the paragraph spacing instead of building the // maximum of the line spacings and the paragraph spacing.
SwTwips nAdd = nPrevLineSpacing; if ( pOwn->IsTextFrame() )
{ // i#102458 // Correction: // A proportional line spacing of the previous text frame // is added up to an own leading line spacing. // Otherwise, the maximum of the leading line spacing // of the previous text frame and the own leading line // spacing is built. if ( bPrevLineSpacingProportional )
{
nAdd += static_cast<SwTextFrame*>(pOwn)->GetLineSpace( true );
} else
{
nAdd = std::max( nAdd, SwTwips(static_cast<SwTextFrame*>(pOwn)->GetLineSpace( true )) );
}
}
nUpper += nAdd;
}
}
} elseif ( rIDSA.get(DocumentSettingId::PARA_SPACE_MAX_AT_PAGES) &&
CastFlowFrame( pOwn )->HasParaSpaceAtPages( m_rThis.IsSctFrame() ) )
{
nUpper = pAttrs->GetULSpace().GetUpper();
// i#25029 - pass previous frame <pPrevFrame> // to method <GetTopLine(..)>, if parameter <pPr> is set. // Note: parameter <pPr> is set, if method is called from <SwTextFrame::WouldFit(..)>
nUpper += pAttrs->GetTopLine( m_rThis, (pPr ? pPrevFrame : nullptr) );
// i#11860 - consider value of new parameter <_bConsiderGrid> // and use new method <GetUpperSpaceAmountConsideredForPageGrid(..)>
/** method to determine the upper space amount, which is considered for the previous frame and the page grid, if option 'Use former object positioning' is OFF
if (_pAttrs)
{
nAdditionalLowerSpace += _pAttrs->GetULSpace().GetLower();
if (rIDSA.get(DocumentSettingId::ADD_PARA_LINE_SPACING_TO_TABLE_CELLS))
{
nAdditionalLowerSpace += _pAttrs->CalcLineSpacing();
}
}
}
return nAdditionalLowerSpace;
}
/// Moves the Frame forward if it seems necessary regarding the current conditions and attributes. bool SwFlowFrame::CheckMoveFwd( bool& rbMakePage, bool bKeep, bool bIgnoreMyOwnKeepValue )
{ if (m_rThis.IsHiddenNow()) returnfalse; const SwFrame* pNxt = m_rThis.GetIndNext();
/// Return value guarantees that a new page was not created, /// although false does not NECESSARILY indicate that a new page was created. /// Either false or true(MoveFootnoteCntFwd) can be returned if no changes were made bool SwFlowFrame::MoveFwd( bool bMakePage, bool bPageBreak, bool bMoveAlways )
{ //!!!!MoveFootnoteCntFwd might need to be updated as well.
SwFootnoteBossFrame *pOldBoss = m_rThis.FindFootnoteBossFrame(); if (m_rThis.IsInFootnote())
{
assert(!ForbiddenForFootnoteCntFwd()); // prevented by IsMoveable() if (!m_rThis.IsContentFrame() || !pOldBoss)
{
SAL_WARN("sw.core", "Tables in footnotes are not truly supported"); returnfalse;
} returnstatic_cast<SwContentFrame&>(m_rThis).MoveFootnoteCntFwd( bMakePage, pOldBoss );
}
// Allow the MoveFwd even if we do not have an IndPrev in these cases: if ( m_rThis.IsInTab() &&
( !m_rThis.IsTabFrame() ||
m_rThis.GetUpper()->IsInTab() ) &&
nullptr != m_rThis.GetNextCellLeaf() )
{
bNoFwd = false;
}
if( bNoFwd )
{ // It's allowed to move PageBreaks if the Frame isn't the first // one on the page. if ( !bPageBreak ) returnfalse;
if ( pNewUpper )
{
PROTOCOL_ENTER( &m_rThis, PROT::MoveFwd, DbgAction::NONE, nullptr );
SwPageFrame *pOldPage = pOldBoss->FindPageFrame(); // We move ourself and all the direct successors before the // first ContentFrame below the new Upper.
// If our NewUpper lies in a SectionFrame, we need to make sure // that it won't destroy itself in Calc.
SwSectionFrame* pSect = pNewUpper->FindSctFrame(); if( pSect )
{ // If we only switch column within our SectionFrame, we better don't // call Calc, as this would format the SectionFrame, which in turn would // call us again, etc. if( pSect != m_rThis.FindSctFrame() )
{ bool bUnlock = !pSect->IsColLocked();
pSect->ColLock();
pNewUpper->Calc(m_rThis.getRootFrame()->GetCurrShell()->GetOut()); if( bUnlock )
pSect->ColUnlock();
}
} // Do not calculate split cell frames. elseif ( !pNewUpper->IsCellFrame() || pNewUpper->Lower() )
pNewUpper->Calc(m_rThis.getRootFrame()->GetCurrShell()->GetOut());
// First, we move the footnotes. bool bFootnoteMoved = false;
// i#26831 // If pSect has just been created, the printing area of pSect has // been calculated based on the first content of its follow. // In this case we prefer to call a SimpleFormat for this new // section after we inserted the contents. Otherwise the section // frame will invalidate its lowers, if its printing area changes // in SwSectionFrame::Format, which can cause loops. constbool bForceSimpleFormat = pSect && pSect->HasFollow() &&
!pSect->ContainsAny();
if ( pNewBoss != pOldBoss )
{
pNewPage = pNewBoss->FindPageFrame();
bSamePage = pNewPage == pOldPage; // Set deadline, so the footnotes don't think up // silly things...
SwRectFnSet aRectFnSet(pOldBoss);
SwSaveFootnoteHeight aHeight( pOldBoss,
aRectFnSet.GetBottom(pOldBoss->getFrameArea()) );
SwContentFrame* pStart = m_rThis.IsContentFrame() ? static_cast<SwContentFrame*>(&m_rThis) : static_cast<SwLayoutFrame&>(m_rThis).ContainsContent();
OSL_ENSURE( pStart || ( m_rThis.IsTabFrame() && !static_cast<SwTabFrame&>(m_rThis).Lower() ), "MoveFwd: Missing Content" );
SwLayoutFrame* pBody = pStart ? ( pStart->IsTextFrame() ? const_cast<SwBodyFrame *>(static_cast<SwTextFrame*>(pStart)->FindBodyFrame()) : nullptr ) : nullptr; if( pBody )
bFootnoteMoved = pBody->MoveLowerFootnotes( pStart, pOldBoss, pNewBoss, false);
} // It's possible when dealing with SectionFrames that we have been moved // by pNewUpper->Calc(), for instance into the pNewUpper. // MoveSubTree or PasteTree respectively is not prepared to handle such a // situation. if( pNewUpper != m_rThis.GetUpper() )
{ // i#27145
SwSectionFrame* pOldSct = nullptr; if ( m_rThis.GetUpper()->IsSctFrame() )
{
pOldSct = static_cast<SwSectionFrame*>(m_rThis.GetUpper());
}
MoveSubTree( pNewUpper, pNewUpper->Lower() );
// i#27145 if ( pOldSct && pOldSct->GetSection() )
{ // Prevent loops by setting the new height at // the section frame if footnotes have been moved. // Otherwise the call of SwLayNotify::~SwLayNotify() for // the (invalid) section frame will invalidate the first // lower of its follow, because it grows due to the removed // footnotes. // Note: If pOldSct has become empty during MoveSubTree, it // has already been scheduled for removal. No SimpleFormat // for these.
pOldSct->SimpleFormat();
}
// i#26831 if ( bForceSimpleFormat )
{
pSect->SimpleFormat();
}
if ( bFootnoteMoved && !bSamePage )
{
pOldPage->UpdateFootnoteNum();
pNewPage->UpdateFootnoteNum();
}
if( bBossChg )
{
m_rThis.Prepare( PrepareHint::BossChanged, nullptr, false ); if( !bSamePage )
{
SwViewShell *pSh = m_rThis.getRootFrame()->GetCurrShell(); if ( pSh && !pSh->Imp()->IsUpdateExpFields() )
pSh->GetDoc()->getIDocumentFieldsAccess().SetNewFieldLst(true); // Will be done by CalcLayout() later on!
pNewPage->InvalidateSpelling();
pNewPage->InvalidateSmartTags();
pNewPage->InvalidateAutoCompleteWords();
pNewPage->InvalidateWordCount();
}
}
} // No <CheckPageDesc(..)> in online layout const SwViewShell *pSh = m_rThis.getRootFrame()->GetCurrShell();
if ( !( pSh && pSh->GetViewOptions()->getBrowseMode() ) )
{ // i#106452 // check page description not only in situation with sections. if ( !bSamePage &&
((!IsFollow() && m_rThis.GetPageDescItem().GetPageDesc()) ||
pOldPage->GetPageDesc()->GetFollow() != pNewPage->GetPageDesc() ) )
{
SwFrame::CheckPageDescs( pNewPage, false );
}
}
} return bSamePage;
}
/** Return value tells whether any changes have been made. * If true, the frame has moved backwards to an earlier column/section/frame/page etc. * * @note This should be called by derived classes. * @note The actual moving must be implemented in the subclasses via Cut()/Paste().
*/ bool SwFlowFrame::MoveBwd( bool &rbReformat )
{
SwFlowFrame::SetMoveBwdJump( false );
// Text frames, which are directly inside // tables aren't allowed to move backward. if ( m_rThis.IsTextFrame() && m_rThis.IsInTab() )
{ const SwLayoutFrame* pUpperFrame = m_rThis.GetUpper(); while ( pUpperFrame )
{ if ( pUpperFrame->IsTabFrame() || pUpperFrame->IsRowFrame() )
{ returnfalse;
} // If the text frame is a follow-section-in-table, that can move // backward as well. bool bIsFollowSection = pUpperFrame->IsSctFrame() && static_cast<const SwSectionFrame*>(pUpperFrame)->GetPrecede();
// If the text frame is a follow-in-table, that can move // backward as well. bool bIsFollow = const_cast<SwLayoutFrame*>(pUpperFrame)->GetPrevCellLeaf();
if ( pFootnote )
{ // If the footnote already sits on the same page/column as the reference, // we can't flow back. The breaks don't need to be checked for footnotes.
// i#37084 FindLastContent does not necessarily // have to have a result != 0
SwFrame* pRef = nullptr; constbool bEndnote = pFootnote->GetAttr()->GetFootnote().IsEndNote(); const IDocumentSettingAccess& rSettings
= pFootnote->GetAttrSet()->GetDoc().getIDocumentSettingAccess(); bool bContEndnotes = rSettings.get(DocumentSettingId::CONTINUOUS_ENDNOTES); if( bEndnote && pFootnote->IsInSct() && !bContEndnotes)
{
SwSectionFrame* pSect = pFootnote->FindSctFrame(); if( pSect->IsEndnAtEnd() ) // Endnotes at the end of the section.
pRef = pSect->FindLastContent( SwFindMode::LastCnt );
} elseif (bEndnote && bContEndnotes)
{ // Endnotes at the end of the document.
SwSectionFrame* pSect = pFootnote->FindSctFrame(); if (!pSect->GetPrev() && !pSect->FindMaster())
{ // The section is at the top of the page, and is not a follow of a master section. // See if there is a previous body frame.
SwLayoutFrame* pPrev = pSect->GetPrevLayoutLeaf(); if (pPrev && pPrev->IsBodyFrame())
{ // There is, then see if that's on a different page.
SwPageFrame* pSectPage = pSect->FindPageFrame();
SwPageFrame* pPage = pPrev->FindPageFrame(); if (pPage != pSectPage)
{ // It is, then create a new section frame at the end of that previous body // frame. auto pNew = new SwSectionFrame(*pSect, /*bMaster=*/true);
pNew->InsertBehind(pPage->FindBodyCont(), pPage->FindLastBodyContent());
pNew->Init();
SwFrame* pLower = pNew->GetLower(); if (pLower->IsColumnFrame())
{
pRef = pLower;
}
}
}
} else
{
pRef = pFootnote->FindFootnoteBossFrame();
}
} if( !pRef ) // Endnotes on a separate page.
pRef = pFootnote->GetRef();
OSL_ENSURE( pRef, "MoveBwd: Endnote for an empty section?" );
( !bEndnote ||
pRefBoss->IsBefore( pOldBoss ) )
)
pNewUpper = m_rThis.GetLeaf( MAKEPAGE_FTN, false );
} // Do we have to respect a PageBreak? elseif (IsPageBreak(true) && (!m_rThis.IsInSct() || !m_rThis.FindSctFrame()->IsHiddenNow()))
{ // If the previous page doesn't have a Frame in the body, // flowing back makes sense despite the PageBreak (otherwise, // we'd get an empty page). // Of course we need to overlook empty pages! const SwFrame *pFlow = &m_rThis; do
{
pFlow = pFlow->FindPrev();
} while ( pFlow &&
( pFlow->FindPageFrame() == pOldPage ||
!pFlow->IsInDocBody() ) ); if ( pFlow )
{
tools::Long nDiff = pOldPage->GetPhyPageNum() - pFlow->GetPhyPageNum(); if ( nDiff > 1 )
{ if ( static_cast<SwPageFrame*>(pOldPage->GetPrev())->IsEmptyPage() )
nDiff -= 1; if ( nDiff > 1 )
{
pNewUpper = m_rThis.GetLeaf( MAKEPAGE_NONE, false ); // * i#53139: Now <pNewUpper> is a previous layout frame, which contains // content. But the new upper layout frame has to be the next one. // * Check for wrong page description before using next new upper. // * i#66051: Check for correct type of new next upper layout frame // * Assumption, that in all cases <pNewUpper> is a previous // layout frame, which contains content, is wrong. // * Beside type check, check also, if proposed new next upper // frame is inside the same frame types. // * i#73194: Assure that the new next upper layout frame doesn't // equal the current one. // E.g.: content is on page 3, on page 2 is only a 'ghost' // section and on page 1 is normal content. Method <FindPrev(..)> // will find the last content of page 1, but <GetLeaf(..)> // returns new upper on page 2. if (pNewUpper && pNewUpper->Lower())
{
SwLayoutFrame* pNewNextUpper = pNewUpper->GetLeaf( MAKEPAGE_NONE, true ); if ( pNewNextUpper &&
pNewNextUpper != m_rThis.GetUpper() &&
pNewNextUpper->GetType() == pNewUpper->GetType() &&
pNewNextUpper->IsInDocBody() == pNewUpper->IsInDocBody() &&
pNewNextUpper->IsInFootnote() == pNewUpper->IsInFootnote() &&
pNewNextUpper->IsInTab() == pNewUpper->IsInTab() &&
pNewNextUpper->IsInSct() == pNewUpper->IsInSct() &&
!m_rThis.WrongPageDesc( pNewNextUpper->FindPageFrame() ) )
{
pNewUpper = pNewNextUpper;
bCheckPageDescOfNextPage = true;
}
}
bCheckPageDescs = true;
}
}
}
} elseif (IsColBreak(true))
{ // If the previous column doesn't contain a ContentFrame, flowing back // makes sense despite the ColumnBreak, as otherwise we'd get // an empty column. if( m_rThis.IsInSct() )
{
pNewUpper = m_rThis.GetLeaf( MAKEPAGE_NONE, false ); if( pNewUpper && !SwFlowFrame::IsMoveBwdJump() &&
( pNewUpper->ContainsContent() ||
( ( !pNewUpper->IsColBodyFrame() ||
!pNewUpper->GetUpper()->GetPrev() ) &&
!pNewUpper->FindSctFrame()->GetPrev() ) ) )
{
pNewUpper = nullptr;
} // i#53139 // i#69409 - check <pNewUpper> // i#71065 - check <SwFlowFrame::IsMoveBwdJump()> elseif ( pNewUpper && !SwFlowFrame::IsMoveBwdJump() )
{ // Now <pNewUpper> is a previous layout frame, which // contains content. But the new upper layout frame // has to be the next one. // Correct fix for i53139 // Check for wrong page description before using next new upper. // i#66051 - further correction of fix for i53139 // Check for correct type of new next upper layout frame // Another correction of fix for i53139 // Beside type check, check also, if proposed new next upper // frame is inside the same frame types.
SwLayoutFrame* pNewNextUpper = pNewUpper->GetLeaf( MAKEPAGE_NOSECTION, true ); if ( pNewNextUpper &&
pNewNextUpper->GetType() == pNewUpper->GetType() &&
pNewNextUpper->IsInDocBody() == pNewUpper->IsInDocBody() &&
pNewNextUpper->IsInFootnote() == pNewUpper->IsInFootnote() &&
pNewNextUpper->IsInTab() == pNewUpper->IsInTab() &&
pNewNextUpper->IsInSct() == pNewUpper->IsInSct() &&
!m_rThis.WrongPageDesc( pNewNextUpper->FindPageFrame() ) )
{
pNewUpper = pNewNextUpper;
}
}
} else
{ const SwFrame *pCol = m_rThis.FindColFrame();
assert(pCol); bool bGoOn = true; bool bJump = false; do
{ if ( pCol->GetPrev() )
pCol = pCol->GetPrev(); else
{
bGoOn = false;
pCol = m_rThis.GetLeaf( MAKEPAGE_NONE, false );
} if ( pCol )
{ // ColumnFrames now with BodyFrame
SwLayoutFrame* pColBody = pCol->IsColumnFrame() ? const_cast<SwLayoutFrame*>(static_cast<const SwLayoutFrame*>(static_cast<const SwLayoutFrame*>(pCol)->Lower())) : const_cast<SwLayoutFrame*>(static_cast<const SwLayoutFrame*>(pCol)); if ( pColBody->ContainsContent() )
{
bGoOn = false; // We have content here! we accept this // only if GetLeaf() has set the MoveBwdJump. if( SwFlowFrame::IsMoveBwdJump() )
{
pNewUpper = pColBody; // i#53139 // Now <pNewUpper> is a previous layout frame, which // contains content. But the new upper layout frame // has to be the next one. // Correct fix for i53139 // Check for wrong page description before using next new upper. // i#66051 - further correction of fix for i53139 // Check for correct type of new next upper layout frame // Another correction of fix for i53139 // Beside type check, check also, if proposed new next upper // frame is inside the same frame types. // i#71065 // Check that the proposed new next upper layout // frame isn't the current one.
SwLayoutFrame* pNewNextUpper = pNewUpper->GetLeaf( MAKEPAGE_NONE, true ); if ( pNewNextUpper &&
pNewNextUpper != m_rThis.GetUpper() &&
pNewNextUpper->GetType() == pNewUpper->GetType() &&
pNewNextUpper->IsInDocBody() == pNewUpper->IsInDocBody() &&
pNewNextUpper->IsInFootnote() == pNewUpper->IsInFootnote() &&
pNewNextUpper->IsInTab() == pNewUpper->IsInTab() &&
pNewNextUpper->IsInSct() == pNewUpper->IsInSct() &&
!m_rThis.WrongPageDesc( pNewNextUpper->FindPageFrame() ) )
{
pNewUpper = pNewNextUpper;
}
}
} else
{ if( pNewUpper ) // We already had an empty column, in other
bJump = true; // words we skipped one.
pNewUpper = pColBody; // this empty column could be considered, // but we continue searching nevertheless.
}
}
} while( bGoOn ); if( bJump )
SwFlowFrame::SetMoveBwdJump( true );
}
} else// No breaks - we can flow back.
pNewUpper = m_rThis.GetLeaf( MAKEPAGE_NONE, false );
// i#27801 - no move backward of 'master' text frame, // if - due to its object positioning - it isn't allowed to be on the new page frame // i#44049 - add another condition for not moving backward // If one of its objects has restarted the layout process, moving backward // isn't sensible either. // i#47697 - refine condition made for issue i44049 // - allow move backward as long as the anchored object is only temporarily // positions considering its wrapping style. if ( pNewUpper &&
m_rThis.IsTextFrame() && !IsFollow() )
{
sal_uInt32 nToPageNum( 0 ); constbool bMoveFwdByObjPos = SwLayouter::FrameMovedFwdByObjPos(
pOldPage->GetFormat()->GetDoc(), static_cast<SwTextFrame&>(m_rThis),
nToPageNum ); if ( bMoveFwdByObjPos &&
pNewUpper->FindPageFrame()->GetPhyPageNum() < nToPageNum )
{
pNewUpper = nullptr;
} // i#44049 - check, if one of its anchored objects // has restarted the layout process. elseif ( m_rThis.GetDrawObjs() )
{ for (SwAnchoredObject* pAnchoredObj : *m_rThis.GetDrawObjs())
{ // i#47697 - refine condition - see above if ( pAnchoredObj->RestartLayoutProcess() &&
!pAnchoredObj->IsTmpConsiderWrapInfluence() )
{
pNewUpper = nullptr; break;
}
}
}
}
// With Follows, it's only allowed to flow back if there's no neighbor // in the new environment (because that would be the Master). // (6677) If however we skipped empty pages, we still have to move. if ( pNewUpper && IsFollow() && pNewUpper->Lower() )
{ // i#79774 // neglect empty sections in proposed new upper frame bool bProposedNewUpperContainsOnlyEmptySections( true );
{ const SwFrame* pLower( pNewUpper->Lower() ); while ( pLower )
{ if ( pLower->IsSctFrame() &&
!dynamic_cast<const SwSectionFrame&>(*pLower).GetSection() )
{
pLower = pLower->GetNext(); continue;
} else
{
bProposedNewUpperContainsOnlyEmptySections = false; break;
}
}
} if ( !bProposedNewUpperContainsOnlyEmptySections )
{ if ( SwFlowFrame::IsMoveBwdJump() )
{ // Don't move after the Master, but into the next empty page.
SwFrame *pFrame = pNewUpper->Lower(); while ( pFrame->GetNext() )
pFrame = pFrame->GetNext();
pNewUpper = pFrame->GetLeaf( MAKEPAGE_INSERT, true ); if( pNewUpper == m_rThis.GetUpper() ) // Did we end up in the same place?
pNewUpper = nullptr; // If so, moving is not needed.
} else
pNewUpper = nullptr;
}
} if ( pNewUpper && !ShouldBwdMoved( pNewUpper, rbReformat ) )
{ if( !pNewUpper->Lower() )
{ if( pNewUpper->IsFootnoteContFrame() )
{
pNewUpper->Cut();
SwFrame::DestroyFrame(pNewUpper);
} else
{
SwSectionFrame* pSectFrame = pNewUpper->FindSctFrame();
// i#21478 - don't move backward, if flow frame wants to // keep with next frame and next frame is locked. if ( pNewUpper && !IsFollow() && !m_rThis.IsHiddenNow() &&
m_rThis.GetAttrSet()->GetKeep().GetValue() && m_rThis.GetIndNext() )
{
SwFrame* pIndNext = m_rThis.GetIndNext(); // get first content of section, while empty sections are skipped while ( pIndNext && pIndNext->IsSctFrame() )
{ if( static_cast<SwSectionFrame*>(pIndNext)->GetSection() )
{
SwFrame* pTmp = static_cast<SwSectionFrame*>(pIndNext)->ContainsAny(); if ( pTmp )
{
pIndNext = pTmp; break;
}
}
pIndNext = pIndNext->GetIndNext();
}
OSL_ENSURE(!pIndNext || dynamic_cast<const SwTextFrame*>(pIndNext)
|| dynamic_cast<const SwTabFrame*>(pIndNext), "<SwFlowFrame::MovedBwd(..)> - incorrect next found." ); if ( pIndNext && pIndNext->IsFlowFrame() &&
SwFlowFrame::CastFlowFrame(pIndNext)->IsJoinLocked() )
{
pNewUpper = nullptr;
}
}
// i#65250 // layout loop control for flowing content again and again moving // backward under the same layout condition. if ( pNewUpper && !IsFollow() &&
pNewUpper != m_rThis.GetUpper() &&
SwLayouter::MoveBwdSuppressed( pOldPage->GetFormat()->GetDoc(),
*this, *pNewUpper ) )
{
SwLayoutFrame* pNextNewUpper = pNewUpper->GetLeaf(
( !m_rThis.IsSctFrame() && m_rThis.IsInSct() )
? MAKEPAGE_NOSECTION
: MAKEPAGE_NONE, true ); // i#73194 - make code robust
OSL_ENSURE( pNextNewUpper, "<SwFlowFrame::MoveBwd(..)> - missing next new upper" ); if ( pNextNewUpper &&
( pNextNewUpper == m_rThis.GetUpper() ||
pNextNewUpper->GetType() != m_rThis.GetUpper()->GetType() ) )
{ // tdf#107398 do not leave empty footnote container around if (!pNewUpper->Lower() && pNewUpper->IsFootnoteContFrame())
{
pNewUpper->Cut();
SwFrame::DestroyFrame(pNewUpper);
}
pNewUpper = nullptr;
OSL_FAIL( "<SwFlowFrame::MoveBwd(..)> - layout loop control for layout action <Move Backward> applied!" );
}
}
OSL_ENSURE( pNewUpper != m_rThis.GetUpper(), "<SwFlowFrame::MoveBwd(..)> - moving backward to the current upper frame!?" ); if ( pNewUpper )
{
PROTOCOL_ENTER( &m_rThis, PROT::MoveBack, DbgAction::NONE, nullptr ); if ( pNewUpper->IsFootnoteContFrame() )
{ // I may have gotten a Container
SwFootnoteFrame *pNew = SwFootnoteContFrame::PrependChained(&m_rThis, false);
pNew->Paste( pNewUpper );
pNewUpper = pNew;
} if( pNewUpper->IsFootnoteFrame() && m_rThis.IsInSct() )
{
SwSectionFrame* pSct = m_rThis.FindSctFrame(); // If we're in a section of a footnote, we may need to create // a SwSectionFrame in the new upper if( pSct->IsInFootnote() )
{
SwFrame* pTmp = pNewUpper->Lower(); if( pTmp )
{ while( pTmp->GetNext() )
pTmp = pTmp->GetNext(); if( !pTmp->IsSctFrame() || static_cast<SwSectionFrame*>(pTmp)->GetFollow() != pSct )
pTmp = nullptr;
} if( pTmp )
pNewUpper = static_cast<SwSectionFrame*>(pTmp); else
{
pSct = new SwSectionFrame( *pSct, true );
pSct->Paste( pNewUpper );
pSct->Init();
pNewUpper = pSct;
pSct->SimpleFormat();
}
}
} bool bUnlock = false; bool bFollow = false; // Lock section. Otherwise, it could get destroyed if the only Content // moves e.g. from the second into the first column.
SwSectionFrame* pSect = pNewUpper->FindSctFrame(); if( pSect )
{
bUnlock = !pSect->IsColLocked();
pSect->ColLock();
bFollow = pSect->HasFollow();
}
{ autoconst pOld = m_rThis.GetUpper();
::std::optional<SwFrameDeleteGuard> g; if (m_rThis.GetUpper()->IsCellFrame())
{ // note: IsFollowFlowRow() is never set for new-style tables
SwTabFrame const*const pTabFrame(m_rThis.FindTabFrame()); if ( pTabFrame->IsFollow()
&& static_cast<SwTabFrame const*>(pTabFrame->GetPrecede())->HasFollowFlowLine()
&& pTabFrame->GetFirstNonHeadlineRow() == m_rThis.GetUpper()->GetUpper())
{ // lock follow-flow-row (similar to sections above)
g.emplace(m_rThis.GetUpper()->GetUpper());
assert(m_rThis.GetUpper()->GetUpper()->IsDeleteForbidden());
}
}
pNewUpper->Calc(m_rThis.getRootFrame()->GetCurrShell()->GetOut());
SAL_WARN_IF(pOld != m_rThis.GetUpper(), "sw.core", "MoveBwd(): pNewUpper->Calc() moved this frame?");
}
m_rThis.Cut();
// optimization: format section, if its size is invalidated and if it's // the new parent of moved backward frame. bool bFormatSect( false ); if( bUnlock )
{
pSect->ColUnlock(); if( pSect->HasFollow() != bFollow )
{
pSect->InvalidateSize(); // - optimization if ( pSect == pNewUpper )
bFormatSect = true;
}
}
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
