Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sw / source / core / layout / ftnfrm.cxx
blob: 24be205560ba236656b41f3c24b1473268d32e49 [file] [log] [blame]
/**************************************************************
*
* 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 <txtftn.hxx>
#include <fmtftn.hxx>
#include <ftnidx.hxx>
#include <pagefrm.hxx>
#include <colfrm.hxx>
#include <rootfrm.hxx>
#include <cntfrm.hxx>
#include <doc.hxx>
#include <ndtxt.hxx>
#include <frmtool.hxx>
#include <swtable.hxx>
#include <ftnfrm.hxx>
#include <txtfrm.hxx>
#include <tabfrm.hxx>
#include <pagedesc.hxx>
#include <ftninfo.hxx>
#include <ndindex.hxx>
#include <sectfrm.hxx>
#include <pam.hxx>
#include <objectformatter.hxx>
#include "viewopt.hxx"
#include "viewsh.hxx"
#include <switerator.hxx>
/*************************************************************************
|*
|* lcl_FindFtnPos() Sucht die Position des Attributes im FtnArray am
|* Dokument, dort stehen die Fussnoten gluecklicherweise nach ihrem
|* Index sortiert.
|*
|*************************************************************************/
#define ENDNOTE 0x80000000
sal_uLong MA_FASTCALL lcl_FindFtnPos( const SwDoc *pDoc, const SwTxtFtn *pAttr )
{
const SwFtnIdxs &rFtnIdxs = pDoc->GetFtnIdxs();
#ifdef MA_DEBUG
//Wenn das Array nicht stimmt haben wir ein Problem, denn viele
//Ftn-Functions bauen auf dem Array auf.
for ( sal_uInt16 k = 0; k+1 < rFtnIdxs.Count(); ++k )
{
SwIndex aIdx1(&pDoc->GetNodes());
SwIndex aIdx2(&pDoc->GetNodes());
rFtnIdxs[k]->pFtn-> GetTxtNode().GetIndex(aIdx1);
rFtnIdxs[k+1]->pFtn->GetTxtNode().GetIndex(aIdx2);
if ( aIdx1.GetIndex() > aIdx2.GetIndex() )
{
ASSERT( !rFtnIdxs.Count(), "FtnIdxs not up to date" );
}
else if ( aIdx1.GetIndex() == aIdx2.GetIndex() )
{
SwTxtFtn *p1 = rFtnIdxs[k];
SwTxtFtn *p2 = rFtnIdxs[k+1];
ASSERT( *p1->GetStart() < *p2->GetStart(),
"FtnIdxs not up to date" );
}
}
#endif
sal_uInt16 nRet;
SwTxtFtnPtr pBla = (SwTxtFtn*)pAttr;
if ( rFtnIdxs.Seek_Entry( pBla, &nRet ) )
{
if( pAttr->GetFtn().IsEndNote() )
return sal_uLong(nRet) + ENDNOTE;
return nRet;
}
ASSERT( !pDoc, "FtnPos not found." );
return 0;
}
sal_Bool SwFtnFrm::operator<( const SwTxtFtn* pTxtFtn ) const
{
const SwDoc* pDoc = GetFmt()->GetDoc();
ASSERT( pDoc, "SwFtnFrm: Missing doc!" );
return lcl_FindFtnPos( pDoc, GetAttr() ) <
lcl_FindFtnPos( pDoc, pTxtFtn );
}
/*************************************************************************
|*
|* sal_Bool lcl_NextFtnBoss( SwFtnBossFrm* pBoss, SwPageFrm* pPage)
|* setzt pBoss auf den naechsten SwFtnBossFrm, das kann entweder eine Spalte
|* oder eine Seite (ohne Spalten) sein. Wenn die Seite dabei gewechselt wird
|* enthaelt pPage die neue Seite und die Funktion liefert sal_True.
|*
|*************************************************************************/
sal_Bool lcl_NextFtnBoss( SwFtnBossFrm* &rpBoss, SwPageFrm* &rpPage,
sal_Bool bDontLeave )
{
if( rpBoss->IsColumnFrm() )
{
if( rpBoss->GetNext() )
{
rpBoss = (SwFtnBossFrm*)rpBoss->GetNext(); //naechste Spalte
return sal_False;
}
if( rpBoss->IsInSct() )
{
SwSectionFrm* pSct = rpBoss->FindSctFrm()->GetFollow();
if( pSct )
{
ASSERT( pSct->Lower() && pSct->Lower()->IsColumnFrm(),
"Where's the column?" );
rpBoss = (SwColumnFrm*)pSct->Lower();
SwPageFrm* pOld = rpPage;
rpPage = pSct->FindPageFrm();
return pOld != rpPage;
}
else if( bDontLeave )
{
rpPage = NULL;
rpBoss = NULL;
return sal_False;
}
}
}
rpPage = (SwPageFrm*)rpPage->GetNext(); // naechste Seite
rpBoss = rpPage;
if( rpPage )
{
SwLayoutFrm* pBody = rpPage->FindBodyCont();
if( pBody && pBody->Lower() && pBody->Lower()->IsColumnFrm() )
rpBoss = (SwFtnBossFrm*)pBody->Lower(); // erste Spalte
}
return sal_True;
}
/*************************************************************************
|*
|* sal_uInt16 lcl_ColumnNum( SwFrm* pBoss )
|* liefert die Spaltennummer, wenn pBoss eine Spalte ist,
|* sonst eine Null (bei Seiten).
|*
|*************************************************************************/
sal_uInt16 lcl_ColumnNum( const SwFrm* pBoss )
{
sal_uInt16 nRet = 0;
if( !pBoss->IsColumnFrm() )
return 0;
const SwFrm* pCol;
if( pBoss->IsInSct() )
{
pCol = pBoss->GetUpper()->FindColFrm();
if( pBoss->GetNext() || pBoss->GetPrev() )
{
while( pBoss )
{
++nRet; // Section columns
pBoss = pBoss->GetPrev();
}
}
}
else
pCol = pBoss;
while( pCol )
{
nRet += 256; // Page columns
pCol = pCol->GetPrev();
}
return nRet;
}
/*************************************************************************
|*
|* SwFtnContFrm::SwFtnContFrm()
|*
|*************************************************************************/
SwFtnContFrm::SwFtnContFrm( SwFrmFmt *pFmt, SwFrm* pSib ):
SwLayoutFrm( pFmt, pSib )
{
nType = FRMC_FTNCONT;
}
// lcl_Undersize(..) klappert einen SwFrm und dessen Inneres ab
// und liefert die Summe aller TxtFrm-Vergroesserungswuensche
long lcl_Undersize( const SwFrm* pFrm )
{
long nRet = 0;
SWRECTFN( pFrm )
if( pFrm->IsTxtFrm() )
{
if( ((SwTxtFrm*)pFrm)->IsUndersized() )
{
// Dieser TxtFrm waere gern ein bisschen groesser
nRet = ((SwTxtFrm*)pFrm)->GetParHeight() -
(pFrm->Prt().*fnRect->fnGetHeight)();
if( nRet < 0 )
nRet = 0;
}
}
else if( pFrm->IsLayoutFrm() )
{
const SwFrm* pNxt = ((SwLayoutFrm*)pFrm)->Lower();
while( pNxt )
{
nRet += lcl_Undersize( pNxt );
pNxt = pNxt->GetNext();
}
}
return nRet;
}
/*************************************************************************
|*
|* SwFtnContFrm::Format()
|*
|* Beschreibung: "Formatiert" den Frame;
|* Die Fixsize wird hier nicht eingestellt.
|*
|*************************************************************************/
void SwFtnContFrm::Format( const SwBorderAttrs * )
{
//GesamtBorder ermitteln, es gibt nur einen Abstand nach oben.
const SwPageFrm* pPage = FindPageFrm();
const SwPageFtnInfo &rInf = pPage->GetPageDesc()->GetFtnInfo();
const SwTwips nBorder = rInf.GetTopDist() + rInf.GetBottomDist() +
rInf.GetLineWidth();
SWRECTFN( this )
if ( !bValidPrtArea )
{
bValidPrtArea = sal_True;
(Prt().*fnRect->fnSetTop)( nBorder );
(Prt().*fnRect->fnSetWidth)( (Frm().*fnRect->fnGetWidth)() );
(Prt().*fnRect->fnSetHeight)((Frm().*fnRect->fnGetHeight)() - nBorder );
if( (Prt().*fnRect->fnGetHeight)() < 0 && !pPage->IsFtnPage() )
bValidSize = sal_False;
}
if ( !bValidSize )
{
bool bGrow = pPage->IsFtnPage();
if( bGrow )
{
const ViewShell *pSh = getRootFrm() ? getRootFrm()->GetCurrShell() : 0;
if( pSh && pSh->GetViewOptions()->getBrowseMode() )
bGrow = false;
}
if( bGrow )
Grow( LONG_MAX, sal_False );
else
{
//Die Groesse in der VarSize wird durch den Inhalt plus den
//Raendern bestimmt.
SwTwips nRemaining = 0;
SwFrm *pFrm = pLower;
while ( pFrm )
{ // lcl_Undersize(..) beruecksichtigt (rekursiv) TxtFrms, die gerne
// groesser waeren. Diese entstehen insbesondere in spaltigen Rahmen,
// wenn diese noch nicht ihre maximale Groesse haben.
nRemaining += (pFrm->Frm().*fnRect->fnGetHeight)()
+ lcl_Undersize( pFrm );
pFrm = pFrm->GetNext();
}
//Jetzt noch den Rand addieren
nRemaining += nBorder;
SwTwips nDiff;
if( IsInSct() )
{
nDiff = -(Frm().*fnRect->fnBottomDist)(
(GetUpper()->*fnRect->fnGetPrtBottom)() );
if( nDiff > 0 )
{
if( nDiff > (Frm().*fnRect->fnGetHeight)() )
nDiff = (Frm().*fnRect->fnGetHeight)();
(Frm().*fnRect->fnAddBottom)( -nDiff );
(Prt().*fnRect->fnAddHeight)( -nDiff );
}
}
nDiff = (Frm().*fnRect->fnGetHeight)() - nRemaining;
if ( nDiff > 0 )
Shrink( nDiff );
else if ( nDiff < 0 )
{
Grow( -nDiff );
//Es kann passieren, dass weniger Platz zur Verfuegung steht,
//als der bereits der Border benoetigt - die Groesse der
//PrtArea wird dann negativ.
SwTwips nPrtHeight = (Prt().*fnRect->fnGetHeight)();
if( nPrtHeight < 0 )
{
const SwTwips nTmpDiff = Max( (Prt().*fnRect->fnGetTop)(),
-nPrtHeight );
(Prt().*fnRect->fnSubTop)( nTmpDiff );
}
}
}
bValidSize = sal_True;
}
}
/*************************************************************************
|*
|* SwFtnContFrm::GrowFrm(), ShrinkFrm()
|*
|*************************************************************************/
SwTwips SwFtnContFrm::GrowFrm( SwTwips nDist, sal_Bool bTst, sal_Bool )
{
//Keine Pruefung ob FixSize oder nicht, die FtnContainer sind immer bis
//zur Maximalhoehe variabel.
//Wenn die Maximalhoehe LONG_MAX ist, so nehmen wir uns soviel Platz wie eben
//moeglich.
//Wenn die Seite eine spezielle Fussnotenseite ist, so nehmen wir uns auch
//soviel Platz wie eben moeglich.
#ifdef DBG_UTIL
if ( !GetUpper() || !GetUpper()->IsFtnBossFrm() )
{ ASSERT( !this, "Keine FtnBoss." );
return 0;
}
#endif
SWRECTFN( this )
if( (Frm().*fnRect->fnGetHeight)() > 0 &&
nDist > ( LONG_MAX - (Frm().*fnRect->fnGetHeight)() ) )
nDist = LONG_MAX - (Frm().*fnRect->fnGetHeight)();
SwFtnBossFrm *pBoss = (SwFtnBossFrm*)GetUpper();
if( IsInSct() )
{
SwSectionFrm* pSect = FindSctFrm();
ASSERT( pSect, "GrowFrm: Missing SectFrm" );
// In a section, which has to maximize, a footnotecontainer is allowed
// to grow, when the section can't grow anymore.
if( !bTst && !pSect->IsColLocked() &&
pSect->ToMaximize( sal_False ) && pSect->Growable() )
{
pSect->InvalidateSize();
return 0;
}
}
const ViewShell *pSh = getRootFrm() ? getRootFrm()->GetCurrShell() : 0;
const sal_Bool bBrowseMode = pSh && pSh->GetViewOptions()->getBrowseMode();
SwPageFrm *pPage = pBoss->FindPageFrm();
if ( bBrowseMode || !pPage->IsFtnPage() )
{
if ( pBoss->GetMaxFtnHeight() != LONG_MAX )
{
nDist = Min( nDist, pBoss->GetMaxFtnHeight()
- (Frm().*fnRect->fnGetHeight)() );
if ( nDist <= 0 )
return 0L;
}
//Der FtnBoss will bezueglich des MaxWerts auch noch mitreden.
if( !IsInSct() )
{
const SwTwips nMax = pBoss->GetVarSpace();
if ( nDist > nMax )
nDist = nMax;
if ( nDist <= 0 )
return 0L;
}
}
else if( nDist > (GetPrev()->Frm().*fnRect->fnGetHeight)() )
//aber mehr als der Body kann koennen und wollen wir nun auch wieder
//nicht herausruecken.
nDist = (GetPrev()->Frm().*fnRect->fnGetHeight)();
long nAvail = 0;
if ( bBrowseMode )
{
nAvail = GetUpper()->Prt().Height();
const SwFrm *pAvail = GetUpper()->Lower();
do
{ nAvail -= pAvail->Frm().Height();
pAvail = pAvail->GetNext();
} while ( pAvail );
if ( nAvail > nDist )
nAvail = nDist;
}
if ( !bTst )
{
(Frm().*fnRect->fnSetHeight)( (Frm().*fnRect->fnGetHeight)() + nDist );
//Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin
if( IsVertical() && !IsVertLR() && !IsReverse() )
Frm().Pos().X() -= nDist;
}
long nGrow = nDist - nAvail,
nReal = 0;
if ( nGrow > 0 )
{
sal_uInt8 nAdjust = pBoss->NeighbourhoodAdjustment( this );
if( NA_ONLY_ADJUST == nAdjust )
nReal = AdjustNeighbourhood( nGrow, bTst );
else
{
if( NA_GROW_ADJUST == nAdjust )
{
SwFrm* pFtn = Lower();
if( pFtn )
{
while( pFtn->GetNext() )
pFtn = pFtn->GetNext();
if( ((SwFtnFrm*)pFtn)->GetAttr()->GetFtn().IsEndNote() )
{
nReal = AdjustNeighbourhood( nGrow, bTst );
nAdjust = NA_GROW_SHRINK; // no more AdjustNeighbourhood
}
}
}
nReal += pBoss->Grow( nGrow - nReal, bTst );
if( ( NA_GROW_ADJUST == nAdjust || NA_ADJUST_GROW == nAdjust )
&& nReal < nGrow )
nReal += AdjustNeighbourhood( nGrow - nReal, bTst );
}
}
nReal += nAvail;
if ( !bTst )
{
if ( nReal != nDist )
{
nDist -= nReal;
//Den masslosen Wunsch koennen wir leider nur in Grenzen erfuellen.
Frm().SSize().Height() -= nDist;
//Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin
if( IsVertical() && !IsVertLR() && !IsReverse() )
Frm().Pos().X() += nDist;
}
//Nachfolger braucht nicht invalidiert werden, denn wir wachsen
//immer nach oben.
if( nReal )
{
_InvalidateSize();
_InvalidatePos();
InvalidatePage( pPage );
}
}
return nReal;
}
SwTwips SwFtnContFrm::ShrinkFrm( SwTwips nDiff, sal_Bool bTst, sal_Bool bInfo )
{
SwPageFrm *pPage = FindPageFrm();
bool bShrink = false;
if ( pPage )
{
if( !pPage->IsFtnPage() )
bShrink = true;
else
{
const ViewShell *pSh = getRootFrm()->GetCurrShell();
if( pSh && pSh->GetViewOptions()->getBrowseMode() )
bShrink = true;
}
}
if( bShrink )
{
SwTwips nRet = SwLayoutFrm::ShrinkFrm( nDiff, bTst, bInfo );
if( IsInSct() && !bTst )
FindSctFrm()->InvalidateNextPos();
if ( !bTst && nRet )
{
_InvalidatePos();
InvalidatePage( pPage );
}
return nRet;
}
return 0;
}
/*************************************************************************
|*
|* SwFtnFrm::SwFtnFrm()
|*
|*************************************************************************/
SwFtnFrm::SwFtnFrm( SwFrmFmt *pFmt, SwFrm* pSib, SwCntntFrm *pCnt, SwTxtFtn *pAt ):
SwLayoutFrm( pFmt, pSib ),
pFollow( 0 ),
pMaster( 0 ),
pRef( pCnt ),
pAttr( pAt ),
bBackMoveLocked( sal_False ),
// --> OD 2005-08-11 #i49383#
mbUnlockPosOfLowerObjs( true )
// <--
{
nType = FRMC_FTN;
}
/*************************************************************************
|*
|* SwFtnFrm::InvalidateNxtFtnCnts()
|*
|*************************************************************************/
void SwFtnFrm::InvalidateNxtFtnCnts( SwPageFrm *pPage )
{
if ( GetNext() )
{
SwFrm *pCnt = ((SwLayoutFrm*)GetNext())->ContainsAny();
if( pCnt )
{
pCnt->InvalidatePage( pPage );
pCnt->_InvalidatePrt();
do
{ pCnt->_InvalidatePos();
if( pCnt->IsSctFrm() )
{
SwFrm* pTmp = ((SwSectionFrm*)pCnt)->ContainsAny();
if( pTmp )
pTmp->_InvalidatePos();
}
pCnt->GetUpper()->_InvalidateSize();
pCnt = pCnt->FindNext();
} while ( pCnt && GetUpper()->IsAnLower( pCnt ) );
}
}
}
#ifdef DBG_UTIL
SwTwips SwFtnFrm::GrowFrm( SwTwips nDist, sal_Bool bTst, sal_Bool bInfo )
{
#if OSL_DEBUG_LEVEL > 1
static sal_uInt16 nNum = USHRT_MAX;
SwTxtFtn* pTxtFtn = GetAttr();
if ( pTxtFtn->GetFtn().GetNumber() == nNum )
{
int bla = 5;
(void)bla;
}
#endif
return SwLayoutFrm::GrowFrm( nDist, bTst, bInfo );
}
SwTwips SwFtnFrm::ShrinkFrm( SwTwips nDist, sal_Bool bTst, sal_Bool bInfo )
{
#if OSL_DEBUG_LEVEL > 1
static sal_uInt16 nNum = USHRT_MAX;
if( nNum != USHRT_MAX )
{
SwTxtFtn* pTxtFtn = GetAttr();
if( &pTxtFtn->GetAttr() && pTxtFtn->GetFtn().GetNumber() == nNum )
{
int bla = 5;
(void)bla;
}
}
#endif
return SwLayoutFrm::ShrinkFrm( nDist, bTst, bInfo );
}
#endif
/*************************************************************************
|*
|* SwFtnFrm::Cut()
|*
|*************************************************************************/
void SwFtnFrm::Cut()
{
if ( GetNext() )
GetNext()->InvalidatePos();
else if ( GetPrev() )
GetPrev()->SetRetouche();
//Erst removen, dann Upper Shrinken.
SwLayoutFrm *pUp = GetUpper();
//Verkettung korrigieren.
SwFtnFrm *pFtn = (SwFtnFrm*)this;
if ( pFtn->GetFollow() )
pFtn->GetFollow()->SetMaster( pFtn->GetMaster() );
if ( pFtn->GetMaster() )
pFtn->GetMaster()->SetFollow( pFtn->GetFollow() );
pFtn->SetFollow( 0 );
pFtn->SetMaster( 0 );
// Alle Verbindungen kappen.
Remove();
if ( pUp )
{
//Die letzte Fussnote nimmt ihren Container mit.
if ( !pUp->Lower() )
{
SwPageFrm *pPage = pUp->FindPageFrm();
if ( pPage )
{
SwLayoutFrm *pBody = pPage->FindBodyCont();
if( pBody && !pBody->ContainsCntnt() )
pPage->getRootFrm()->SetSuperfluous();
}
SwSectionFrm* pSect = pUp->FindSctFrm();
pUp->Cut();
delete pUp;
// Wenn der letzte Fussnotencontainer aus einem spaltigen Bereich verschwindet,
// so kann dieser, falls er keinen Follow besitzt, zusammenschrumpfen.
if( pSect && !pSect->ToMaximize( sal_False ) && !pSect->IsColLocked() )
pSect->_InvalidateSize();
}
else
{ if ( Frm().Height() )
pUp->Shrink( Frm().Height() );
pUp->SetCompletePaint();
pUp->InvalidatePage();
}
}
}
/*************************************************************************
|*
|* SwFtnFrm::Paste()
|*
|*************************************************************************/
void SwFtnFrm::Paste( SwFrm* pParent, SwFrm* pSibling )
{
ASSERT( pParent, "Kein Parent fuer Paste." );
ASSERT( pParent->IsLayoutFrm(), "Parent ist CntntFrm." );
ASSERT( pParent != this, "Bin selbst der Parent." );
ASSERT( pSibling != this, "Bin mein eigener Nachbar." );
ASSERT( !GetPrev() && !GetNext() && !GetUpper(),
"Bin noch irgendwo angemeldet." );
//In den Baum einhaengen.
InsertBefore( (SwLayoutFrm*)pParent, pSibling );
SWRECTFN( this )
if( (Frm().*fnRect->fnGetWidth)()!=(pParent->Prt().*fnRect->fnGetWidth)() )
_InvalidateSize();
_InvalidatePos();
SwPageFrm *pPage = FindPageFrm();
InvalidatePage( pPage );
if ( GetNext() )
GetNext()->_InvalidatePos();
if( (Frm().*fnRect->fnGetHeight)() )
pParent->Grow( (Frm().*fnRect->fnGetHeight)() );
//Wenn mein Vorgaenger mein Master ist und/oder wenn mein Nachfolger mein
//Follow ist so kann ich deren Inhalt uebernehmen und sie vernichten.
if ( GetPrev() && GetPrev() == GetMaster() )
{ ASSERT( SwFlowFrm::CastFlowFrm( GetPrev()->GetLower() ),
"Fussnote ohne Inhalt?" );
(SwFlowFrm::CastFlowFrm( GetPrev()->GetLower()))->
MoveSubTree( this, GetLower() );
SwFrm *pDel = GetPrev();
pDel->Cut();
delete pDel;
}
if ( GetNext() && GetNext() == GetFollow() )
{ ASSERT( SwFlowFrm::CastFlowFrm( GetNext()->GetLower() ),
"Fussnote ohne Inhalt?" );
(SwFlowFrm::CastFlowFrm( GetNext()->GetLower()))->MoveSubTree( this );
SwFrm *pDel = GetNext();
pDel->Cut();
delete pDel;
}
#ifdef DBG_UTIL
SwDoc *pDoc = GetFmt()->GetDoc();
if ( GetPrev() )
{
ASSERT( lcl_FindFtnPos( pDoc, ((SwFtnFrm*)GetPrev())->GetAttr() ) <=
lcl_FindFtnPos( pDoc, GetAttr() ), "Prev ist not FtnPrev" );
}
if ( GetNext() )
{
ASSERT( lcl_FindFtnPos( pDoc, GetAttr() ) <=
lcl_FindFtnPos( pDoc, ((SwFtnFrm*)GetNext())->GetAttr() ),
"Next is not FtnNext" );
}
#endif
InvalidateNxtFtnCnts( pPage );
}
/*************************************************************************
|*
|* SwFrm::GetNextFtnLeaf()
|*
|* Beschreibung Liefert das naechste LayoutBlatt in den das
|* Frame gemoved werden kann.
|* Neue Seiten werden nur dann erzeugt, wenn der Parameter sal_True ist.
|*
|*************************************************************************/
SwLayoutFrm *SwFrm::GetNextFtnLeaf( MakePageType eMakePage )
{
SwFtnBossFrm *pOldBoss = FindFtnBossFrm();
SwPageFrm* pOldPage = pOldBoss->FindPageFrm();
SwPageFrm* pPage;
SwFtnBossFrm *pBoss = pOldBoss->IsColumnFrm() ?
(SwFtnBossFrm*)pOldBoss->GetNext() : 0; // naechste Spalte, wenn vorhanden
if( pBoss )
pPage = NULL;
else
{
if( pOldBoss->GetUpper()->IsSctFrm() )
{ // Das kann nur in einem spaltigen Bereich sein
SwLayoutFrm* pNxt = pOldBoss->GetNextSctLeaf( eMakePage );
if( pNxt )
{
ASSERT( pNxt->IsColBodyFrm(), "GetNextFtnLeaf: Funny Leaf" );
pBoss = (SwFtnBossFrm*)pNxt->GetUpper();
pPage = pBoss->FindPageFrm();
}
else
return 0;
}
else
{
// naechste Seite
pPage = (SwPageFrm*)pOldPage->GetNext();
// Leerseiten ueberspringen
if( pPage && pPage->IsEmptyPage() )
pPage = (SwPageFrm*)pPage->GetNext();
pBoss = pPage;
}
}
// Was haben wir jetzt?
// pBoss != NULL, pPage==NULL => pBoss ist die auf der gleichen Seite folgende Spalte
// pBoss != NULL, pPage!=NULL => pBoss und pPage sind die folgende Seite (Empty uebersprungen)
// pBoss == NULL => pPage == NULL, es gibt keine folgende Seite
//Wenn die Fussnote bereits einen Follow hat brauchen wir nicht zu suchen.
//Wenn allerdings zwischen Ftn und Follow unerwuenschte Leerseiten/spalten
//herumlungern, so legen wir auf der naechstbesten Seite/Spalte einen weiteren
//Follow an, der Rest wird sich schon finden.
SwFtnFrm *pFtn = FindFtnFrm();
if ( pFtn && pFtn->GetFollow() )
{
SwFtnBossFrm* pTmpBoss = pFtn->GetFollow()->FindFtnBossFrm();
// Folgende Faelle werden hier erkannt und akzeptiert
// 1. Die FtnBosse sind benachbarte Seiten oder benachbarte Spalten
// 2. Der neue ist die erste Spalte der benachbarten Seite
// 3. Der neue ist die erste Spalte in einem Bereich in der naechsten Spalte/Seite
while( pTmpBoss != pBoss && pTmpBoss && !pTmpBoss->GetPrev() )
pTmpBoss = pTmpBoss->GetUpper()->FindFtnBossFrm();
if( pTmpBoss == pBoss )
return pFtn->GetFollow();
}
// Wenn wir keinen pBoss gefunden haben oder es sich um eine "falsche" Seite handelt,
// muss eine neue Seite her
if ( !pBoss || ( pPage && pPage->IsEndNotePage() && !pOldPage->IsEndNotePage() ) )
{
if ( eMakePage == MAKEPAGE_APPEND || eMakePage == MAKEPAGE_INSERT )
{
pBoss = InsertPage( pOldPage, pOldPage->IsFtnPage() );
((SwPageFrm*)pBoss)->SetEndNotePage( pOldPage->IsEndNotePage() );
}
else
return 0;
}
if( pBoss->IsPageFrm() )
{ // Wenn wir auf einer spaltigen Seite gelandet sind,
// gehen wir in die erste Spalte
SwLayoutFrm* pLay = pBoss->FindBodyCont();
if( pLay && pLay->Lower() && pLay->Lower()->IsColumnFrm() )
pBoss = (SwFtnBossFrm*)pLay->Lower();
}
//Seite/Spalte gefunden, da schummeln wir uns doch gleich mal 'rein
SwFtnContFrm *pCont = pBoss->FindFtnCont();
if ( !pCont && pBoss->GetMaxFtnHeight() &&
( eMakePage == MAKEPAGE_APPEND || eMakePage == MAKEPAGE_INSERT ) )
pCont = pBoss->MakeFtnCont();
return pCont;
}
/*************************************************************************
|*
|* SwFrm::GetPrevFtnLeaf()
|*
|* Beschreibung Liefert das vorhergehende LayoutBlatt in das der
|* Frame gemoved werden kann.
|*
|*************************************************************************/
SwLayoutFrm *SwFrm::GetPrevFtnLeaf( MakePageType eMakeFtn )
{
//Der Vorgaenger fuer eine Fussnote ist falls moeglich der Master
//in der Fussnoteneigenen Verkettung.
SwLayoutFrm *pRet = 0;
SwFtnFrm *pFtn = FindFtnFrm();
pRet = pFtn->GetMaster();
SwFtnBossFrm* pOldBoss = FindFtnBossFrm();
SwPageFrm *pOldPage = pOldBoss->FindPageFrm();
if ( !pOldBoss->GetPrev() && !pOldPage->GetPrev() )
return pRet; // es gibt weder eine Spalte noch eine Seite vor uns
if ( !pRet )
{
bool bEndn = pFtn->GetAttr()->GetFtn().IsEndNote();
SwFrm* pTmpRef = NULL;
if( bEndn && pFtn->IsInSct() )
{
SwSectionFrm* pSect = pFtn->FindSctFrm();
if( pSect->IsEndnAtEnd() )
pTmpRef = pSect->FindLastCntnt( FINDMODE_LASTCNT );
}
if( !pTmpRef )
pTmpRef = pFtn->GetRef();
SwFtnBossFrm* pStop = pTmpRef->FindFtnBossFrm( !bEndn );
const sal_uInt16 nNum = pStop->GetPhyPageNum();
//Wenn die Fussnoten am Dokumentende angezeigt werden, so verlassen wir
//die Entsprechenden Seiten nicht.
//Selbiges gilt analog fuer die Endnotenseiten.
const sal_Bool bEndNote = pOldPage->IsEndNotePage();
const sal_Bool bFtnEndDoc = pOldPage->IsFtnPage();
SwFtnBossFrm* pNxtBoss = pOldBoss;
SwSectionFrm *pSect = pNxtBoss->GetUpper()->IsSctFrm() ?
(SwSectionFrm*)pNxtBoss->GetUpper() : 0;
do
{
if( pNxtBoss->IsColumnFrm() && pNxtBoss->GetPrev() )
pNxtBoss = (SwFtnBossFrm*)pNxtBoss->GetPrev(); // eine Spalte zurueck
else // oder eine Seite zurueck
{
SwLayoutFrm* pBody = 0;
if( pSect )
{
if( pSect->IsFtnLock() )
{
if( pNxtBoss == pOldBoss )
return 0;
pStop = pNxtBoss;
}
else
{
pSect = (SwSectionFrm*)pSect->FindMaster();
if( !pSect || !pSect->Lower() )
return 0;
ASSERT( pSect->Lower()->IsColumnFrm(),
"GetPrevFtnLeaf: Where's the column?" );
pNxtBoss = (SwFtnBossFrm*)pSect->Lower();
pBody = pSect;
}
}
else
{
SwPageFrm* pPage = (SwPageFrm*)pNxtBoss->FindPageFrm()->GetPrev();
if( !pPage || pPage->GetPhyPageNum() < nNum ||
bEndNote != pPage->IsEndNotePage() || bFtnEndDoc != pPage->IsFtnPage() )
return NULL; // Keine in Frage kommende Seite mehr gefunden
pNxtBoss = pPage;
pBody = pPage->FindBodyCont();
}
// Die vorherige Seite haben wir nun, ggf. sollten wir in die letzte Spalte
// der Seite wechseln
if( pBody )
{
if ( pBody->Lower() && pBody->Lower()->IsColumnFrm() )
{
pNxtBoss = static_cast<SwFtnBossFrm*>(pBody->GetLastLower());
}
}
}
SwFtnContFrm *pCont = pNxtBoss->FindFtnCont();
if ( pCont )
{
pRet = pCont;
break;
}
if ( pStop == pNxtBoss )
{ //Die Seite/Spalte auf der sich auch die Referenz tummelt, ist erreicht.
//Wir koennen jetzt probehalber mal einen Container erzeugen und
//uns hineinpasten.
if ( eMakeFtn == MAKEPAGE_FTN && pNxtBoss->GetMaxFtnHeight() )
pRet = pNxtBoss->MakeFtnCont();
break;
}
} while( !pRet );
}
if ( pRet )
{
const SwFtnBossFrm* pNewBoss = pRet->FindFtnBossFrm();
sal_Bool bJump = sal_False;
if( pOldBoss->IsColumnFrm() && pOldBoss->GetPrev() ) // es gibt eine vorherige Spalte
bJump = pOldBoss->GetPrev() != (SwFrm*)pNewBoss; // sind wir darin gelandet?
else if( pNewBoss->IsColumnFrm() && pNewBoss->GetNext() )
bJump = sal_True; // es gibt hinter dem neuen Boss noch eine Spalte, die aber nicht
// der alte Boss sein kann, das haben wir ja bereits geprueft.
else // hier landen wir nur, wenn neuer und alter Boss entweder Seiten oder letzte (neu)
{ // bzw. erste (alt) Spalten einer Seite sind. In diesem Fall muss noch geprueft
// werden, ob Seiten ueberspringen wurden.
sal_uInt16 nDiff = pOldPage->GetPhyPageNum() - pRet->FindPageFrm()->GetPhyPageNum();
if ( nDiff > 2 ||
(nDiff > 1 && !((SwPageFrm*)pOldPage->GetPrev())->IsEmptyPage()) )
bJump = sal_True;
}
if( bJump )
SwFlowFrm::SetMoveBwdJump( sal_True );
}
return pRet;
}
/*************************************************************************
|*
|* SwFrm::IsFtnAllowed()
|*
|*************************************************************************/
sal_Bool SwFrm::IsFtnAllowed() const
{
if ( !IsInDocBody() )
return sal_False;
if ( IsInTab() )
{
//Keine Ftns in wiederholten Headlines.
const SwTabFrm *pTab = ((SwFrm*)this)->ImplFindTabFrm();
if ( pTab->IsFollow() )
return !pTab->IsInHeadline( *this );
}
return sal_True;
}
/*************************************************************************
|*
|* SwRootFrm::UpdateFtnNums()
|*
|*************************************************************************/
void SwRootFrm::UpdateFtnNums()
{
//Seitenweise Numerierung nur wenn es am Dokument so eingestellt ist.
if ( GetFmt()->GetDoc()->GetFtnInfo().eNum == FTNNUM_PAGE )
{
SwPageFrm *pPage = (SwPageFrm*)Lower();
while ( pPage && !pPage->IsFtnPage() )
{
pPage->UpdateFtnNum();
pPage = (SwPageFrm*)pPage->GetNext();
}
}
}
/*************************************************************************
|*
|* RemoveFtns() Entfernen aller Fussnoten (nicht etwa die Referenzen)
|* und Entfernen aller Fussnotenseiten.
|*
|*************************************************************************/
void lcl_RemoveFtns( SwFtnBossFrm* pBoss, sal_Bool bPageOnly, sal_Bool bEndNotes )
{
do
{
SwFtnContFrm *pCont = pBoss->FindFtnCont();
if ( pCont )
{
SwFtnFrm *pFtn = (SwFtnFrm*)pCont->Lower();
ASSERT( pFtn, "FtnCont ohne Ftn." );
if ( bPageOnly )
while ( pFtn->GetMaster() )
pFtn = pFtn->GetMaster();
do
{
SwFtnFrm *pNxt = (SwFtnFrm*)pFtn->GetNext();
if ( !pFtn->GetAttr()->GetFtn().IsEndNote() ||
bEndNotes )
{
pFtn->GetRef()->Prepare( PREP_FTN, (void*)pFtn->GetAttr() );
if ( bPageOnly && !pNxt )
pNxt = pFtn->GetFollow();
pFtn->Cut();
delete pFtn;
}
pFtn = pNxt;
} while ( pFtn );
}
if( !pBoss->IsInSct() )
{
// A sectionframe with the Ftn/EndnAtEnd-flags may contain
// foot/endnotes. If the last lower frame of the bodyframe is
// a multicolumned sectionframe, it may contain footnotes, too.
SwLayoutFrm* pBody = pBoss->FindBodyCont();
if( pBody && pBody->Lower() )
{
SwFrm* pLow = pBody->Lower();
while( pLow->GetNext() )
{
if( pLow->IsSctFrm() && ( !pLow->GetNext() ||
((SwSectionFrm*)pLow)->IsAnyNoteAtEnd() ) &&
((SwSectionFrm*)pLow)->Lower() &&
((SwSectionFrm*)pLow)->Lower()->IsColumnFrm() )
lcl_RemoveFtns( (SwColumnFrm*)((SwSectionFrm*)pLow)->Lower(),
bPageOnly, bEndNotes );
pLow = pLow->GetNext();
}
}
}
// noch 'ne Spalte?
pBoss = pBoss->IsColumnFrm() ? (SwColumnFrm*)pBoss->GetNext() : NULL;
} while( pBoss );
}
void SwRootFrm::RemoveFtns( SwPageFrm *pPage, sal_Bool bPageOnly, sal_Bool bEndNotes )
{
if ( !pPage )
pPage = (SwPageFrm*)Lower();
do
{ // Bei spaltigen Seiten muessen wir in allen Spalten aufraeumen
SwFtnBossFrm* pBoss;
SwLayoutFrm* pBody = pPage->FindBodyCont();
if( pBody && pBody->Lower() && pBody->Lower()->IsColumnFrm() )
pBoss = (SwFtnBossFrm*)pBody->Lower(); // die erste Spalte
else
pBoss = pPage; // keine Spalten
lcl_RemoveFtns( pBoss, bPageOnly, bEndNotes );
if ( !bPageOnly )
{
if ( pPage->IsFtnPage() &&
(!pPage->IsEndNotePage() || bEndNotes) )
{
SwFrm *pDel = pPage;
pPage = (SwPageFrm*)pPage->GetNext();
pDel->Cut();
delete pDel;
}
else
pPage = (SwPageFrm*)pPage->GetNext();
}
else
break;
} while ( pPage );
}
/*************************************************************************
|*
|* SetFtnPageDescs() Seitenvorlagen der Fussnotenseiten aendern
|*
|*************************************************************************/
void SwRootFrm::CheckFtnPageDescs( sal_Bool bEndNote )
{
SwPageFrm *pPage = (SwPageFrm*)Lower();
while ( pPage && !pPage->IsFtnPage() )
pPage = (SwPageFrm*)pPage->GetNext();
while ( pPage && pPage->IsEndNotePage() != bEndNote )
pPage = (SwPageFrm*)pPage->GetNext();
if ( pPage )
SwFrm::CheckPageDescs( pPage, sal_False );
}
/*************************************************************************
|*
|* SwFtnBossFrm::MakeFtnCont()
|*
|*************************************************************************/
SwFtnContFrm *SwFtnBossFrm::MakeFtnCont()
{
//Einfuegen eines Fussnotencontainers. Der Fussnotencontainer sitzt
//immer direkt hinter dem Bodytext.
//Sein FrmFmt ist immer das DefaultFrmFmt.
#ifdef DBG_UTIL
if ( FindFtnCont() )
{ ASSERT( !this, "Fussnotencontainer bereits vorhanden." );
return 0;
}
#endif
SwFtnContFrm *pNew = new SwFtnContFrm( GetFmt()->GetDoc()->GetDfltFrmFmt(), this );
SwLayoutFrm *pLay = FindBodyCont();
pNew->Paste( this, pLay->GetNext() );
return pNew;
}
/*************************************************************************
|*
|* SwFtnBossFrm::FindFtnCont()
|*
|*************************************************************************/
SwFtnContFrm *SwFtnBossFrm::FindFtnCont()
{
SwFrm *pFrm = Lower();
while( pFrm && !pFrm->IsFtnContFrm() )
pFrm = pFrm->GetNext();
#ifdef DBG_UTIL
if ( pFrm )
{
SwFrm *pFtn = pFrm->GetLower();
ASSERT( pFtn, "Cont ohne Fussnote." );
while ( pFtn )
{
ASSERT( pFtn->IsFtnFrm(), "Nachbar von Fussnote keine Fussnote." );
pFtn = pFtn->GetNext();
}
}
#endif
return (SwFtnContFrm*)pFrm;
}
/*************************************************************************
|*
|* SwFtnBossFrm::FindNearestFtnCont() Sucht den naechst greifbaren Fussnotencontainer.
|*
|*************************************************************************/
SwFtnContFrm *SwFtnBossFrm::FindNearestFtnCont( sal_Bool bDontLeave )
{
SwFtnContFrm *pCont = 0;
if ( GetFmt()->GetDoc()->GetFtnIdxs().Count() )
{
pCont = FindFtnCont();
if ( !pCont )
{
SwPageFrm *pPage = FindPageFrm();
SwFtnBossFrm* pBoss = this;
sal_Bool bEndNote = pPage->IsEndNotePage();
do
{
sal_Bool bChgPage = lcl_NextFtnBoss( pBoss, pPage, bDontLeave );
// Haben wir noch einen Boss gefunden? Bei einem Seitenwechsel muss
// zudem noch das EndNotenFlag uebereinstimmen
if( pBoss && ( !bChgPage || pPage->IsEndNotePage() == bEndNote ) )
pCont = pBoss->FindFtnCont();
} while ( !pCont && pPage );
}
}
return pCont;
}
/*************************************************************************
|*
|* SwFtnBossFrm::FindFirstFtn()
|*
|* Beschreibung Erste Fussnote des Fussnotenbosses suchen.
|*
|*************************************************************************/
SwFtnFrm *SwFtnBossFrm::FindFirstFtn()
{
//Erstmal den naechsten FussnotenContainer suchen.
SwFtnContFrm *pCont = FindNearestFtnCont();
if ( !pCont )
return 0;
//Ab der ersten Fussnote im Container die erste suchen, die
//von der aktuellen Spalte (bzw. einspaltigen Seite) referenziert wird.
SwFtnFrm *pRet = (SwFtnFrm*)pCont->Lower();
const sal_uInt16 nRefNum = FindPageFrm()->GetPhyPageNum();
const sal_uInt16 nRefCol = lcl_ColumnNum( this );
sal_uInt16 nPgNum, nColNum; //Seitennummer, Spaltennummer
SwFtnBossFrm* pBoss;
SwPageFrm* pPage;
if( pRet )
{
pBoss = pRet->GetRef()->FindFtnBossFrm();
ASSERT( pBoss, "FindFirstFtn: No boss found" );
if( !pBoss )
return NULL; // ?There must be a bug, but no GPF
pPage = pBoss->FindPageFrm();
nPgNum = pPage->GetPhyPageNum();
if ( nPgNum == nRefNum )
{
nColNum = lcl_ColumnNum( pBoss );
if( nColNum == nRefCol )
return pRet; //hat ihn.
else if( nColNum > nRefCol )
return NULL; //mind. eine Spalte zu weit.
}
else if ( nPgNum > nRefNum )
return NULL; //mind. eine Seite zu weit.
}
else
return NULL;
// Ende, wenn Ref auf einer spaeteren Seite oder auf der gleichen Seite in einer
// spaeteren Spalte liegt
do
{
while ( pRet->GetFollow() )
pRet = pRet->GetFollow();
SwFtnFrm *pNxt = (SwFtnFrm*)pRet->GetNext();
if ( !pNxt )
{
pBoss = pRet->FindFtnBossFrm();
pPage = pBoss->FindPageFrm();
lcl_NextFtnBoss( pBoss, pPage, sal_False ); // naechster FtnBoss
pCont = pBoss ? pBoss->FindNearestFtnCont() : 0;
if ( pCont )
pNxt = (SwFtnFrm*)pCont->Lower();
}
if ( pNxt )
{
pRet = pNxt;
pBoss = pRet->GetRef()->FindFtnBossFrm();
pPage = pBoss->FindPageFrm();
nPgNum = pPage->GetPhyPageNum();
if ( nPgNum == nRefNum )
{
nColNum = lcl_ColumnNum( pBoss );
if( nColNum == nRefCol )
break; //hat ihn.
else if( nColNum > nRefCol )
pRet = 0; //mind. eine Spalte zu weit.
}
else if ( nPgNum > nRefNum )
pRet = 0; //mind. eine Seite zu weit.
}
else
pRet = 0; //Gibt eben keinen.
} while( pRet );
return pRet;
}
/*************************************************************************
|*
|* SwFtnBossFrm::FindFirstFtn()
|*
|* Beschreibunt Erste Fussnote zum Cnt suchen.
|*
|*************************************************************************/
const SwFtnFrm *SwFtnBossFrm::FindFirstFtn( SwCntntFrm *pCnt ) const
{
const SwFtnFrm *pRet = ((SwFtnBossFrm*)this)->FindFirstFtn();
if ( pRet )
{
const sal_uInt16 nColNum = lcl_ColumnNum( this ); //Spaltennummer
const sal_uInt16 nPageNum = GetPhyPageNum();
while ( pRet && (pRet->GetRef() != pCnt) )
{
while ( pRet->GetFollow() )
pRet = pRet->GetFollow();
if ( pRet->GetNext() )
pRet = (const SwFtnFrm*)pRet->GetNext();
else
{ SwFtnBossFrm *pBoss = (SwFtnBossFrm*)pRet->FindFtnBossFrm();
SwPageFrm *pPage = pBoss->FindPageFrm();
lcl_NextFtnBoss( pBoss, pPage, sal_False ); // naechster FtnBoss
SwFtnContFrm *pCont = pBoss ? pBoss->FindNearestFtnCont() : 0;
pRet = pCont ? (SwFtnFrm*)pCont->Lower() : 0;
}
if ( pRet )
{
const SwFtnBossFrm* pBoss = pRet->GetRef()->FindFtnBossFrm();
if( pBoss->GetPhyPageNum() != nPageNum ||
nColNum != lcl_ColumnNum( pBoss ) )
pRet = 0;
}
}
}
return pRet;
}
/*************************************************************************
|*
|* SwFtnBossFrm::ResetFtn()
|*
|*************************************************************************/
void SwFtnBossFrm::ResetFtn( const SwFtnFrm *pCheck )
{
//Vernichten der Inkarnationen von Fussnoten zum Attribut, wenn sie nicht
//zu pAssumed gehoeren.
ASSERT( !pCheck->GetMaster(), "Master not an Master." );
SwNodeIndex aIdx( *pCheck->GetAttr()->GetStartNode(), 1 );
SwCntntNode *pNd = aIdx.GetNode().GetCntntNode();
if ( !pNd )
pNd = pCheck->GetFmt()->GetDoc()->
GetNodes().GoNextSection( &aIdx, sal_True, sal_False );
SwIterator<SwFrm,SwCntntNode> aIter( *pNd );
SwFrm* pFrm = aIter.First();
while( pFrm )
{
if( pFrm->getRootFrm() == pCheck->getRootFrm() )
{
SwFrm *pTmp = pFrm->GetUpper();
while ( pTmp && !pTmp->IsFtnFrm() )
pTmp = pTmp->GetUpper();
SwFtnFrm *pFtn = (SwFtnFrm*)pTmp;
while ( pFtn && pFtn->GetMaster() )
pFtn = pFtn->GetMaster();
if ( pFtn != pCheck )
{
while ( pFtn )
{
SwFtnFrm *pNxt = pFtn->GetFollow();
pFtn->Cut();
delete pFtn;
pFtn = pNxt;
}
}
}
pFrm = aIter.Next();
}
}
/*************************************************************************
|*
|* SwFtnBossFrm::InsertFtn()
|*
|*************************************************************************/
void SwFtnBossFrm::InsertFtn( SwFtnFrm* pNew )
{
#if (OSL_DEBUG_LEVEL > 1) && defined(DBG_UTIL)
static sal_uInt16 nStop = 0;
if ( nStop == pNew->GetFrmId() )
{
int bla = 5;
(void)bla;
}
#endif
//Die Fussnote haben wir, sie muss jetzt nur noch irgendwo
//hin und zwar vor die Fussnote, deren Attribut vor das
//der neuen zeigt (Position wird ueber das Doc ermittelt)
//Gibt es in diesem Fussnotenboss noch keine Fussnoten, so muss eben ein
//Container erzeugt werden.
//Gibt es bereits einen Container aber noch keine Fussnote zu diesem
//Fussnotenboss, so muss die Fussnote hinter die letzte Fussnote der dichtesten
//Vorseite/spalte.
ResetFtn( pNew );
SwFtnFrm *pSibling = FindFirstFtn();
sal_Bool bDontLeave = sal_False;
// Ok, a sibling has been found, but is the sibling in an acceptable
// environment?
if( IsInSct() )
{
SwSectionFrm* pMySect = ImplFindSctFrm();
bool bEndnt = pNew->GetAttr()->GetFtn().IsEndNote();
if( bEndnt )
{
const SwSectionFmt* pEndFmt = pMySect->GetEndSectFmt();
bDontLeave = 0 != pEndFmt;
if( pSibling )
{
if( pEndFmt )
{
if( !pSibling->IsInSct() ||
!pSibling->ImplFindSctFrm()->IsDescendantFrom( pEndFmt ) )
pSibling = NULL;
}
else if( pSibling->IsInSct() )
pSibling = NULL;
}
}
else
{
bDontLeave = pMySect->IsFtnAtEnd();
if( pSibling )
{
if( pMySect->IsFtnAtEnd() )
{
if( !pSibling->IsInSct() ||
!pMySect->IsAnFollow( pSibling->ImplFindSctFrm() ) )
pSibling = NULL;
}
else if( pSibling->IsInSct() )
pSibling = NULL;
}
}
}
if( pSibling && pSibling->FindPageFrm()->IsEndNotePage() !=
FindPageFrm()->IsEndNotePage() )
pSibling = NULL;
//Damit die Position herausgefunden werden kann.
SwDoc *pDoc = GetFmt()->GetDoc();
const sal_uLong nStPos = ::lcl_FindFtnPos( pDoc, pNew->GetAttr() );
sal_uLong nCmpPos = 0;
sal_uLong nLastPos = 0;
SwFtnContFrm *pParent = 0;
if( pSibling )
{
nCmpPos = ::lcl_FindFtnPos( pDoc, pSibling->GetAttr() );
if( nCmpPos > nStPos )
pSibling = NULL;
}
if ( !pSibling )
{ pParent = FindFtnCont();
if ( !pParent )
{
//Es gibt noch keinen FussnotenContainer, also machen wir einen.
//HAAAAAAAALT! So einfach ist das leider mal wieder nicht: Es kann
//sein, dass irgendeine naechste Fussnote existiert die vor der
//einzufuegenden zu stehen hat, weil z.B. eine Fussnote ueber zig
//Seiten aufgespalten ist usw.
pParent = FindNearestFtnCont( bDontLeave );
if ( pParent )
{
SwFtnFrm *pFtn = (SwFtnFrm*)pParent->Lower();
if ( pFtn )
{
nCmpPos = ::lcl_FindFtnPos( pDoc, pFtn->GetAttr() );
if ( nCmpPos > nStPos )
pParent = 0;
}
else
pParent = 0;
}
}
if ( !pParent )
//Jetzt kann aber ein Fussnotencontainer gebaut werden.
pParent = MakeFtnCont();
else
{
//Ausgehend von der ersten Fussnote unterhalb des Parents wird die
//erste Fussnote gesucht deren Index hinter dem Index der
//einzufuegenden liegt; vor dieser kann der neue dann gepastet
//werden.
pSibling = (SwFtnFrm*)pParent->Lower();
if ( !pSibling )
{ ASSERT( !this, "Keinen Platz fuer Fussnote gefunden.");
return;
}
nCmpPos = ::lcl_FindFtnPos( pDoc, pSibling->GetAttr() );
SwFtnBossFrm *pNxtB = this; //Immer den letzten merken, damit wir nicht
SwFtnFrm *pLastSib = 0; //ueber das Ziel hinausschiessen.
while ( pSibling && nCmpPos <= nStPos )
{
pLastSib = pSibling; // der kommt schon mal in Frage
nLastPos = nCmpPos;
while ( pSibling->GetFollow() )
pSibling = pSibling->GetFollow();
if ( pSibling->GetNext() )
{
pSibling = (SwFtnFrm*)pSibling->GetNext();
ASSERT( !pSibling->GetMaster() || ( ENDNOTE > nStPos &&
pSibling->GetAttr()->GetFtn().IsEndNote() ),
"InsertFtn: Master expected I" );
}
else
{
pNxtB = pSibling->FindFtnBossFrm();
SwPageFrm *pSibPage = pNxtB->FindPageFrm();
sal_Bool bEndNote = pSibPage->IsEndNotePage();
sal_Bool bChgPage = lcl_NextFtnBoss( pNxtB, pSibPage, bDontLeave );
// Bei Seitenwechsel muss das EndNoteFlag ueberprueft werden.
SwFtnContFrm *pCont = pNxtB && ( !bChgPage ||
pSibPage->IsEndNotePage() == bEndNote )
? pNxtB->FindNearestFtnCont( bDontLeave ) : 0;
if( pCont )
pSibling = (SwFtnFrm*)pCont->Lower();
else // kein weiterer FtnContainer, dann werden wir uns wohl hinter
break; // pSibling haengen
}
if ( pSibling )
{
nCmpPos = ::lcl_FindFtnPos( pDoc, pSibling->GetAttr() );
ASSERT( nCmpPos > nLastPos, "InsertFtn: Order of FtnFrm's buggy" );
}
}
// pLastSib ist jetzt die letzte Fussnote vor uns,
// pSibling leer oder die erste nach uns.
if ( pSibling && pLastSib && (pSibling != pLastSib) )
{ //Sind wir vielleicht bereits ueber das Ziel hinausgeschossen?
if ( nCmpPos > nStPos )
pSibling = pLastSib;
}
else if ( !pSibling )
{ //Eine Chance haben wir noch: wir nehmen einfach die letzte
//Fussnote im Parent. Ein Sonderfall, der z.B. beim
//zurueckfliessen von Absaetzen mit mehreren Fussnoten
//vorkommt.
//Damit wir nicht die Reihenfolge verwuerfeln muessen wir den
//Parent der letzten Fussnote, die wir an der Hand hatten benutzen.
pSibling = pLastSib;
while( pSibling->GetFollow() )
pSibling = pSibling->GetFollow();
ASSERT( !pSibling->GetNext(), "InsertFtn: Who's that guy?" );
}
}
}
else
{ //Die erste Fussnote der Spalte/Seite haben wir an der Hand, jetzt ausgehend
//von dieser die erste zur selben Spalte/Seite suchen deren Index hinter
//den uebergebenen zeigt, die letzte, die wir an der Hand hatten, ist
//dann der Vorgaenger.
SwFtnBossFrm* pBoss = pNew->GetRef()->FindFtnBossFrm(
!pNew->GetAttr()->GetFtn().IsEndNote() );
sal_uInt16 nRefNum = pBoss->GetPhyPageNum(); // Die Seiten- und
sal_uInt16 nRefCol = lcl_ColumnNum( pBoss ); // Spaltennummer der neuen Fussnote
sal_Bool bEnd = sal_False;
SwFtnFrm *pLastSib = 0;
while ( pSibling && !bEnd && (nCmpPos <= nStPos) )
{
pLastSib = pSibling;
nLastPos = nCmpPos;
while ( pSibling->GetFollow() )
pSibling = pSibling->GetFollow();
SwFtnFrm *pFoll = (SwFtnFrm*)pSibling->GetNext();
if ( pFoll )
{
pBoss = pSibling->GetRef()->FindFtnBossFrm( !pSibling->
GetAttr()->GetFtn().IsEndNote() );
sal_uInt16 nTmpRef;
if( nStPos >= ENDNOTE ||
(nTmpRef = pBoss->GetPhyPageNum()) < nRefNum ||
( nTmpRef == nRefNum && lcl_ColumnNum( pBoss ) <= nRefCol ))
pSibling = pFoll;
else
bEnd = sal_True;
}
else
{
SwFtnBossFrm* pNxtB = pSibling->FindFtnBossFrm();
SwPageFrm *pSibPage = pNxtB->FindPageFrm();
sal_Bool bEndNote = pSibPage->IsEndNotePage();
sal_Bool bChgPage = lcl_NextFtnBoss( pNxtB, pSibPage, bDontLeave );
// Bei Seitenwechsel muss das EndNoteFlag ueberprueft werden.
SwFtnContFrm *pCont = pNxtB && ( !bChgPage ||
pSibPage->IsEndNotePage() == bEndNote )
? pNxtB->FindNearestFtnCont( bDontLeave ) : 0;
if ( pCont )
pSibling = (SwFtnFrm*)pCont->Lower();
else
bEnd = sal_True;
}
if ( !bEnd && pSibling )
nCmpPos = ::lcl_FindFtnPos( pDoc, pSibling->GetAttr() );
if ( pSibling && pLastSib && (pSibling != pLastSib) )
{ //Sind wir vielleicht bereits ueber das Ziel hinausgeschossen?
if ( (nLastPos < nCmpPos) && (nCmpPos > nStPos) )
{
pSibling = pLastSib;
bEnd = sal_True;
}
}
}
}
if ( pSibling )
{
nCmpPos = ::lcl_FindFtnPos( pDoc, pSibling->GetAttr() );
if ( nCmpPos < nStPos )
{
while ( pSibling->GetFollow() )
pSibling = pSibling->GetFollow();
pParent = (SwFtnContFrm*)pSibling->GetUpper();
pSibling = (SwFtnFrm*)pSibling->GetNext();
}
else
{
if( pSibling->GetMaster() )
{
if( ENDNOTE > nCmpPos || nStPos >= ENDNOTE )
{
ASSERT( sal_False, "InsertFtn: Master expected II" );
do
pSibling = pSibling->GetMaster();
while ( pSibling->GetMaster() );
}
}
pParent = (SwFtnContFrm*)pSibling->GetUpper();
}
}
ASSERT( pParent, "paste in space?" );
pNew->Paste( pParent, pSibling );
}
/*************************************************************************
|*
|* SwFtnBossFrm::AppendFtn()
|*
|*************************************************************************/
void SwFtnBossFrm::AppendFtn( SwCntntFrm *pRef, SwTxtFtn *pAttr )
{
//Wenn es die Fussnote schon gibt tun wir nix.
if ( FindFtn( pRef, pAttr ) )
return;
//Wenn Fussnoten am Dokumentende eingestellt sind, so brauchen wir 'eh erst
//ab der entsprechenden Seite zu suchen.
//Wenn es noch keine gibt, muss eben eine erzeugt werden.
//Wenn es sich um eine Endnote handelt, muss eine Endnotenseite gesucht
//bzw. erzeugt werden.
SwDoc *pDoc = GetFmt()->GetDoc();
SwFtnBossFrm *pBoss = this;
SwPageFrm *pPage = FindPageFrm();
SwPageFrm *pMyPage = pPage;
sal_Bool bChgPage = sal_False;
sal_Bool bEnd = sal_False;
if ( pAttr->GetFtn().IsEndNote() )
{
bEnd = sal_True;
if( GetUpper()->IsSctFrm() &&
((SwSectionFrm*)GetUpper())->IsEndnAtEnd() )
{
SwFrm* pLast =
((SwSectionFrm*)GetUpper())->FindLastCntnt( FINDMODE_ENDNOTE );
if( pLast )
{
pBoss = pLast->FindFtnBossFrm();
pPage = pBoss->FindPageFrm();
}
}
else
{
while ( pPage->GetNext() && !pPage->IsEndNotePage() )
{
pPage = (SwPageFrm*)pPage->GetNext();
bChgPage = sal_True;
}
if ( !pPage->IsEndNotePage() )
{
SwPageDesc *pDesc = pDoc->GetEndNoteInfo().GetPageDesc( *pDoc );
pPage = ::InsertNewPage( *pDesc, pPage->GetUpper(),
!pPage->OnRightPage(), sal_False, sal_True, 0 );
pPage->SetEndNotePage( sal_True );
bChgPage = sal_True;
}
else
{
//Wir koennen wenigstens schon mal ungefaehr die richtige Seite
//suchen. Damit stellen wir sicher das wir auch bei hunderten
//Fussnoten noch in endlicher Zeit fertig werden.
SwPageFrm *pNxt = (SwPageFrm*)pPage->GetNext();
const sal_uLong nStPos = ::lcl_FindFtnPos( pDoc, pAttr );
while ( pNxt && pNxt->IsEndNotePage() )
{
SwFtnContFrm *pCont = pNxt->FindFtnCont();
if ( pCont && pCont->Lower() )
{
ASSERT( pCont->Lower()->IsFtnFrm(), "Keine Ftn im Container" );
if ( nStPos > ::lcl_FindFtnPos( pDoc,
((SwFtnFrm*)pCont->Lower())->GetAttr()))
{
pPage = pNxt;
pNxt = (SwPageFrm*)pPage->GetNext();
continue;
}
}
break;
}
}
}
}
else if( FTNPOS_CHAPTER == pDoc->GetFtnInfo().ePos && ( !GetUpper()->
IsSctFrm() || !((SwSectionFrm*)GetUpper())->IsFtnAtEnd() ) )
{
while ( pPage->GetNext() && !pPage->IsFtnPage() &&
!((SwPageFrm*)pPage->GetNext())->IsEndNotePage() )
{
pPage = (SwPageFrm*)pPage->GetNext();
bChgPage = sal_True;
}
if ( !pPage->IsFtnPage() )
{
SwPageDesc *pDesc = pDoc->GetFtnInfo().GetPageDesc( *pDoc );
pPage = ::InsertNewPage( *pDesc, pPage->GetUpper(),
!pPage->OnRightPage(), sal_False, sal_True, pPage->GetNext() );
bChgPage = sal_True;
}
else
{
//Wir koennen wenigstens schon mal ungefaehr die richtige Seite
//suchen. Damit stellen wir sicher das wir auch bei hunderten
//Fussnoten noch in endlicher Zeit fertig werden.
SwPageFrm *pNxt = (SwPageFrm*)pPage->GetNext();
const sal_uLong nStPos = ::lcl_FindFtnPos( pDoc, pAttr );
while ( pNxt && pNxt->IsFtnPage() && !pNxt->IsEndNotePage() )
{
SwFtnContFrm *pCont = pNxt->FindFtnCont();
if ( pCont && pCont->Lower() )
{
ASSERT( pCont->Lower()->IsFtnFrm(), "Keine Ftn im Container" );
if ( nStPos > ::lcl_FindFtnPos( pDoc,
((SwFtnFrm*)pCont->Lower())->GetAttr()))
{
pPage = pNxt;
pNxt = (SwPageFrm*)pPage->GetNext();
continue;
}
}
break;
}
}
}
//Erstmal eine Fussnote und die benoetigten CntntFrms anlegen.
if ( !pAttr->GetStartNode() )
{ ASSERT( !this, "Kein Fussnoteninhalt." );
return;
}
// Wenn es auf der Seite/Spalte bereits einen FtnCont gibt,
// kann in einen spaltigen Bereich keiner erzeugt werden.
if( pBoss->IsInSct() && pBoss->IsColumnFrm() && !pPage->IsFtnPage() )
{
SwSectionFrm* pSct = pBoss->FindSctFrm();
if( bEnd ? !pSct->IsEndnAtEnd() : !pSct->IsFtnAtEnd() )
{
SwFtnContFrm* pFtnCont = pSct->FindFtnBossFrm(!bEnd)->FindFtnCont();
if( pFtnCont )
{
SwFtnFrm* pTmp = (SwFtnFrm*)pFtnCont->Lower();
if( bEnd )
while( pTmp && !pTmp->GetAttr()->GetFtn().IsEndNote() )
pTmp = (SwFtnFrm*)pTmp->GetNext();
if( pTmp && *pTmp < pAttr )
return;
}
}
}
SwFtnFrm *pNew = new SwFtnFrm( pDoc->GetDfltFrmFmt(), this, pRef, pAttr );
{
SwNodeIndex aIdx( *pAttr->GetStartNode(), 1 );
::_InsertCnt( pNew, pDoc, aIdx.GetIndex() );
}
// Wenn die Seite gewechselt (oder gar neu angelegt) wurde,
// muessen wir uns dort in die erste Spalte setzen
if( bChgPage )
{
SwLayoutFrm* pBody = pPage->FindBodyCont();
ASSERT( pBody, "AppendFtn: NoPageBody?" );
if( pBody->Lower() && pBody->Lower()->IsColumnFrm() )
pBoss = (SwFtnBossFrm*)pBody->Lower();
else
pBoss = pPage; // bei nichtspaltigen Seiten auf die Seite selbst
}
pBoss->InsertFtn( pNew );
if ( pNew->GetUpper() ) //Eingesetzt oder nicht?
{
::RegistFlys( pNew->FindPageFrm(), pNew );
SwSectionFrm* pSect = FindSctFrm();
// Der Inhalt des FtnContainers in einem (spaltigen) Bereich
// braucht nur kalkuliert zu werden,
// wenn der Bereich bereits bis zur Unterkante seines Uppers geht.
if( pSect && !pSect->IsJoinLocked() && ( bEnd ? !pSect->IsEndnAtEnd() :
!pSect->IsFtnAtEnd() ) && pSect->Growable() )
pSect->InvalidateSize();
else
{
// --> OD 2005-05-18 #i49383# - disable unlock of position of
// lower objects during format of footnote content.
const bool bOldFtnFrmLocked( pNew->IsColLocked() );
pNew->ColLock();
pNew->KeepLockPosOfLowerObjs();
// --> OD 2006-02-02 #i57914# - adjust fix #i49383#
// no extra notify for footnote frame
// SwLayNotify* pFtnFrmNotitfy = new SwLayNotify( pNew );
// <--
SwCntntFrm *pCnt = pNew->ContainsCntnt();
while ( pCnt && pCnt->FindFtnFrm()->GetAttr() == pAttr )
{
pCnt->Calc();
// --> OD 2005-05-17 #i49383# - format anchored objects
if ( pCnt->IsTxtFrm() && pCnt->IsValid() )
{
if ( !SwObjectFormatter::FormatObjsAtFrm( *pCnt,
*(pCnt->FindPageFrm()) ) )
{
// restart format with first content
pCnt = pNew->ContainsCntnt();
continue;
}
}
// <--
pCnt = (SwCntntFrm*)pCnt->FindNextCnt();
}
// --> OD 2005-05-18 #i49383#
if ( !bOldFtnFrmLocked )
{
pNew->ColUnlock();
}
// --> OD 2006-02-02 #i57914# - adjust fix #i49383#
// enable lock of lower object position before format of footnote frame.
pNew->UnlockPosOfLowerObjs();
// <--
pNew->Calc();
// --> OD 2006-02-02 #i57914# - adjust fix #i49383#
// no extra notify for footnote frame
// pNew->UnlockPosOfLowerObjs();
// delete pFtnFrmNotitfy;
// <--
if ( !bOldFtnFrmLocked && !pNew->GetLower() &&
!pNew->IsColLocked() && !pNew->IsBackMoveLocked() )
{
pNew->Cut();
delete pNew;
}
// <--
}
pMyPage->UpdateFtnNum();
}
else
delete pNew;
}
/*************************************************************************
|*
|* SwFtnBossFrm::FindFtn()
|*
|*************************************************************************/
SwFtnFrm *SwFtnBossFrm::FindFtn( const SwCntntFrm *pRef, const SwTxtFtn *pAttr )
{
//Der einfachste und sicherste Weg geht ueber das Attribut.
ASSERT( pAttr->GetStartNode(), "FtnAtr ohne StartNode." );
SwNodeIndex aIdx( *pAttr->GetStartNode(), 1 );
SwCntntNode *pNd = aIdx.GetNode().GetCntntNode();
if ( !pNd )
pNd = pRef->GetAttrSet()->GetDoc()->
GetNodes().GoNextSection( &aIdx, sal_True, sal_False );
if ( !pNd )
return 0;
SwIterator<SwFrm,SwCntntNode> aIter( *pNd );
SwFrm* pFrm = aIter.First();
if( pFrm )
do
{
pFrm = pFrm->GetUpper();
// #i28500#, #i27243# Due to the endnode collector, there are
// SwFtnFrms, which are not in the layout. Therefore the
// bInfFtn flags are not set correctly, and a cell of FindFtnFrm
// would return 0. Therefore we better call ImplFindFtnFrm().
SwFtnFrm *pFtn = pFrm->ImplFindFtnFrm();
if ( pFtn && pFtn->GetRef() == pRef )
{
// The following condition becomes true, if the whole
// footnotecontent is a section. While no frames exist,
// the HiddenFlag of the section is set, this causes
// the GoNextSection-function leaves the footnote.
if( pFtn->GetAttr() != pAttr )
return 0;
while ( pFtn && pFtn->GetMaster() )
pFtn = pFtn->GetMaster();
return pFtn;
}
} while ( 0 != (pFrm = aIter.Next()) );
return 0;
}
/*************************************************************************
|*
|* SwFtnBossFrm::RemoveFtn()
|*
|*************************************************************************/
void SwFtnBossFrm::RemoveFtn( const SwCntntFrm *pRef, const SwTxtFtn *pAttr,
sal_Bool bPrep )
{
SwFtnFrm *pFtn = FindFtn( pRef, pAttr );
if( pFtn )
{
do
{
SwFtnFrm *pFoll = pFtn->GetFollow();
pFtn->Cut();
delete pFtn;
pFtn = pFoll;
} while ( pFtn );
if( bPrep && pRef->IsFollow() )
{
ASSERT( pRef->IsTxtFrm(), "NoTxtFrm has Footnote?" );
SwTxtFrm* pMaster = (SwTxtFrm*)pRef->FindMaster();
if( !pMaster->IsLocked() )
pMaster->Prepare( PREP_FTN_GONE );
}
}
FindPageFrm()->UpdateFtnNum();
}
/*************************************************************************
|*
|* SwFtnBossFrm::ChangeFtnRef()
|*
|*************************************************************************/
void SwFtnBossFrm::ChangeFtnRef( const SwCntntFrm *pOld, const SwTxtFtn *pAttr,
SwCntntFrm *pNew )
{
SwFtnFrm *pFtn = FindFtn( pOld, pAttr );
while ( pFtn )
{
pFtn->SetRef( pNew );
pFtn = pFtn->GetFollow();
}
}
/*************************************************************************
|*
|* SwFtnBossFrm::CollectFtns()
|*
|*************************************************************************/
/// OD 03.04.2003 #108446# - add parameter <_bCollectOnlyPreviousFtns> in
/// order to control, if only footnotes, which are positioned before the
/// footnote boss frame <this> have to be collected.
void SwFtnBossFrm::CollectFtns( const SwCntntFrm* _pRef,
SwFtnBossFrm* _pOld,
SvPtrarr& _rFtnArr,
const sal_Bool _bCollectOnlyPreviousFtns )
{
SwFtnFrm *pFtn = _pOld->FindFirstFtn();
while( !pFtn )
{
if( _pOld->IsColumnFrm() )
{ // Spalten abklappern
while ( !pFtn && _pOld->GetPrev() )
{
//Wenn wir keine Fussnote gefunden haben, ist noch nicht alles zu
//spaet. Die Schleife wird beim Aufnehmen von Follow-Zeilen durch
//Tabellen benoetigt. Fuer alle anderen Faelle ist sie in der Lage
//'krumme' Verhaeltnisse zu korrigieren.
_pOld = (SwFtnBossFrm*)_pOld->GetPrev();
pFtn = _pOld->FindFirstFtn();
}
}
if( !pFtn )
{
// vorherige Seite
SwPageFrm* pPg;
for ( SwFrm* pTmp = _pOld;
0 != ( pPg = (SwPageFrm*)pTmp->FindPageFrm()->GetPrev())
&& pPg->IsEmptyPage() ;
)
{
pTmp = pPg;
}
if( !pPg )
return;
SwLayoutFrm* pBody = pPg->FindBodyCont();
if( pBody->Lower() && pBody->Lower()->IsColumnFrm() )
{
// mehrspaltige Seite => letzte Spalte suchen
_pOld = static_cast<SwFtnBossFrm*>(pBody->GetLastLower());
}
else
_pOld = pPg; // einspaltige Seite
pFtn = _pOld->FindFirstFtn();
}
}
// OD 03.04.2003 #108446# - consider new parameter <_bCollectOnlyPreviousFtns>
SwFtnBossFrm* pRefBossFrm = NULL;
if ( _bCollectOnlyPreviousFtns )
{
pRefBossFrm = this;
}
_CollectFtns( _pRef, pFtn, _rFtnArr, _bCollectOnlyPreviousFtns, pRefBossFrm );
}
/*************************************************************************
|*
|* SwFtnBossFrm::_CollectFtns()
|*
|*************************************************************************/
inline void FtnInArr( SvPtrarr& rFtnArr, SwFtnFrm* pFtn )
{
if ( USHRT_MAX == rFtnArr.GetPos( (VoidPtr)pFtn ) )
rFtnArr.Insert( (VoidPtr)pFtn, rFtnArr.Count() );
}
/// OD 03.04.2003 #108446# - add parameters <_bCollectOnlyPreviousFtns> and
/// <_pRefFtnBossFrm> in order to control, if only footnotes, which are positioned
/// before the given reference footnote boss frame have to be collected.
/// Note: if parameter <_bCollectOnlyPreviousFtns> is true, then parameter
/// <_pRefFtnBossFrm> have to be referenced to an object.
/// Adjust parameter names.
void SwFtnBossFrm::_CollectFtns( const SwCntntFrm* _pRef,
SwFtnFrm* _pFtn,
SvPtrarr& _rFtnArr,
sal_Bool _bCollectOnlyPreviousFtns,
const SwFtnBossFrm* _pRefFtnBossFrm)
{
// OD 03.04.2003 #108446# - assert, that no reference footnote boss frame
// is set, in spite of the order, that only previous footnotes has to be
// collected.
ASSERT( !_bCollectOnlyPreviousFtns || _pRefFtnBossFrm,
"<SwFtnBossFrm::_CollectFtns(..)> - No reference footnote boss frame for collecting only previous footnotes set.\nCrash will be caused!" );
//Alle Fussnoten die von pRef referenziert werden nacheinander
//einsammeln (Attribut fuer Attribut), zusammengefuegen
//(der Inhalt zu einem Attribut kann ueber mehrere Seiten verteilt sein)
//und ausschneiden.
SvPtrarr aNotFtnArr( 20, 20 ); //Zur Robustheit werden hier die nicht
//dazugehoerigen Fussnoten eingetragen.
//Wenn eine Fussnote zweimal angefasst wird
//ists vorbei! So kommt die Funktion auch
//noch mit einem kaputten Layout
//einigermassen (ohne Schleife und Absturz)
//"klar".
//Hier sollte keiner mit einer Follow-Ftn ankommen, es sei denn er hat
//ernste Absichten (:-)); spricht er kommt mit einer Ftn an die vor der
//ersten der Referenz liegt.
ASSERT( !_pFtn->GetMaster() || _pFtn->GetRef() != _pRef, "FollowFtn moven?" );
while ( _pFtn->GetMaster() )
_pFtn = _pFtn->GetMaster();
sal_Bool bFound = sal_False;
while ( _pFtn )
{
//Erstmal die naechste Fussnote der Spalte/Seite suchen, damit wir nicht
//nach dem Cut jeder Fussnote von vorn anfangen muessen.
SwFtnFrm *pNxtFtn = _pFtn;
while ( pNxtFtn->GetFollow() )
pNxtFtn = pNxtFtn->GetFollow();
pNxtFtn = (SwFtnFrm*)pNxtFtn->GetNext();
if ( !pNxtFtn )
{
SwFtnBossFrm* pBoss = _pFtn->FindFtnBossFrm();
SwPageFrm* pPage = pBoss->FindPageFrm();
do
{
lcl_NextFtnBoss( pBoss, pPage, sal_False );
if( pBoss )
{
SwLayoutFrm* pCont = pBoss->FindFtnCont();
if( pCont )
{
pNxtFtn = (SwFtnFrm*)pCont->Lower();
if( pNxtFtn )
{
while( pNxtFtn->GetMaster() )
pNxtFtn = pNxtFtn->GetMaster();
if( pNxtFtn == _pFtn )
pNxtFtn = NULL;
}
}
}
} while( !pNxtFtn && pBoss );
}
else if( !pNxtFtn->GetAttr()->GetFtn().IsEndNote() )
{ ASSERT( !pNxtFtn->GetMaster(), "_CollectFtn: Master exspected" );
while ( pNxtFtn->GetMaster() )
pNxtFtn = pNxtFtn->GetMaster();
}
if ( pNxtFtn == _pFtn )
{
ASSERT( sal_False, "_CollectFtn: Devil's circle" );
pNxtFtn = 0;
}
// OD 03.04.2003 #108446# - determine, if found footnote has to be collected.
sal_Bool bCollectFoundFtn = sal_False;
if ( _pFtn->GetRef() == _pRef && !_pFtn->GetAttr()->GetFtn().IsEndNote() )
{
if ( _bCollectOnlyPreviousFtns )
{
SwFtnBossFrm* pBossOfFoundFtn = _pFtn->FindFtnBossFrm( sal_True );
ASSERT( pBossOfFoundFtn,
"<SwFtnBossFrm::_CollectFtns(..)> - footnote boss frame of found footnote frame missing.\nWrong layout!" );
if ( !pBossOfFoundFtn || // don't crash, if no footnote boss is found.
pBossOfFoundFtn->IsBefore( _pRefFtnBossFrm )
)
{
bCollectFoundFtn = sal_True;
}
}
else
{
bCollectFoundFtn = sal_True;
}
}
if ( bCollectFoundFtn )
{
ASSERT( !_pFtn->GetMaster(), "FollowFtn moven?" );
SwFtnFrm *pNxt = _pFtn->GetFollow();
while ( pNxt )
{
SwFrm *pCnt = pNxt->ContainsAny();
if ( pCnt )
{ //Unterwegs wird der Follow zerstoert weil er leer wird!
do
{ SwFrm *pNxtCnt = pCnt->GetNext();
pCnt->Cut();
pCnt->Paste( _pFtn );
pCnt = pNxtCnt;
} while ( pCnt );
}
else
{ ASSERT( !pNxt, "Fussnote ohne Inhalt?" );
pNxt->Cut();
delete pNxt;
}
pNxt = _pFtn->GetFollow();
}
_pFtn->Cut();
FtnInArr( _rFtnArr, _pFtn );
bFound = sal_True;
}
else
{
FtnInArr( aNotFtnArr, _pFtn );
if( bFound )
break;
}
if ( pNxtFtn &&
USHRT_MAX == _rFtnArr.GetPos( (VoidPtr)pNxtFtn ) &&
USHRT_MAX == aNotFtnArr.GetPos( (VoidPtr)pNxtFtn ) )
_pFtn = pNxtFtn;
else
break;
}
}
/*************************************************************************
|*
|* SwFtnBossFrm::_MoveFtns()
|*
|*************************************************************************/
void SwFtnBossFrm::_MoveFtns( SvPtrarr &rFtnArr, sal_Bool bCalc )
{
//Alle Fussnoten die von pRef referenziert werden muessen von der
//aktuellen Position, die sich durch die alte Spalte/Seite ergab, auf eine
//neue Position, bestimmt durch die neue Spalte/Seite, gemoved werden.
const sal_uInt16 nMyNum = FindPageFrm()->GetPhyPageNum();
const sal_uInt16 nMyCol = lcl_ColumnNum( this );
SWRECTFN( this )
// --> OD 2004-06-11 #i21478# - keep last inserted footnote in order to
// format the content of the following one.
SwFtnFrm* pLastInsertedFtn = 0L;
for ( sal_uInt16 i = 0; i < rFtnArr.Count(); ++i )
{
SwFtnFrm *pFtn = (SwFtnFrm*)rFtnArr[i];
SwFtnBossFrm* pRefBoss = pFtn->GetRef()->FindFtnBossFrm( sal_True );
if( pRefBoss != this )
{
const sal_uInt16 nRefNum = pRefBoss->FindPageFrm()->GetPhyPageNum();
const sal_uInt16 nRefCol = lcl_ColumnNum( this );
if( nRefNum < nMyNum || ( nRefNum == nMyNum && nRefCol <= nMyCol ) )
pRefBoss = this;
}
pRefBoss->InsertFtn( pFtn );
if ( pFtn->GetUpper() ) //Robust, z.B. bei doppelten
{
// Damit FtnFrms, die nicht auf die Seite passen, nicht fuer zuviel
// Unruhe sorgen (Loop 66312), wird ihr Inhalt zunaechst zusammengestaucht.
// Damit wird der FtnCont erst gegrowt, wenn der Inhalt formatiert wird
// und feststellt, dass er auf die Seite passt.
SwFrm *pCnt = pFtn->ContainsAny();
while( pCnt )
{
if( pCnt->IsLayoutFrm() )
{
SwFrm* pTmp = ((SwLayoutFrm*)pCnt)->ContainsAny();
while( pTmp && ((SwLayoutFrm*)pCnt)->IsAnLower( pTmp ) )
{
pTmp->Prepare( PREP_MOVEFTN );
(pTmp->Frm().*fnRect->fnSetHeight)(0);
(pTmp->Prt().*fnRect->fnSetHeight)(0);
pTmp = pTmp->FindNext();
}
}
else
pCnt->Prepare( PREP_MOVEFTN );
(pCnt->Frm().*fnRect->fnSetHeight)(0);
(pCnt->Prt().*fnRect->fnSetHeight)(0);
pCnt = pCnt->GetNext();
}
(pFtn->Frm().*fnRect->fnSetHeight)(0);
(pFtn->Prt().*fnRect->fnSetHeight)(0);
pFtn->Calc();
pFtn->GetUpper()->Calc();
if( bCalc )
{
SwTxtFtn *pAttr = pFtn->GetAttr();
pCnt = pFtn->ContainsAny();
sal_Bool bUnlock = !pFtn->IsBackMoveLocked();
pFtn->LockBackMove();
// --> OD 2005-05-18 #i49383# - disable unlock of position of
// lower objects during format of footnote content.
pFtn->KeepLockPosOfLowerObjs();
// --> OD 2006-02-02 #i57914# - adjust fix #i49383#
// no extra notify for footnote frame
// SwLayNotify aFtnFrmNotitfy( pFtn );
// <--
while ( pCnt && pCnt->FindFtnFrm()->GetAttr() == pAttr )
{
pCnt->_InvalidatePos();
pCnt->Calc();
// --> OD 2005-05-17 #i49383# - format anchored objects
if ( pCnt->IsTxtFrm() && pCnt->IsValid() )
{
if ( !SwObjectFormatter::FormatObjsAtFrm( *pCnt,
*(pCnt->FindPageFrm()) ) )
{
// restart format with first content
pCnt = pFtn->ContainsAny();
continue;
}
}
// <--
if( pCnt->IsSctFrm() )
{ // Wenn es sich um einen nichtleeren Bereich handelt,
// iterieren wir auch ueber seinen Inhalt
SwFrm* pTmp = ((SwSectionFrm*)pCnt)->ContainsAny();
if( pTmp )
pCnt = pTmp;
else
pCnt = pCnt->FindNext();
}
else
pCnt = pCnt->FindNext();
}
if( bUnlock )
{
pFtn->UnlockBackMove();
if( !pFtn->ContainsAny() && !pFtn->IsColLocked() )
{
pFtn->Cut();
delete pFtn;
// --> OD 2004-06-10 #i21478#
pFtn = 0L;
}
}
// --> OD 2005-05-18 #i49383#
if ( pFtn )
{
// --> OD 2006-02-02 #i57914# - adjust fix #i49383#
// enable lock of lower object position before format of footnote frame.
pFtn->UnlockPosOfLowerObjs();
pFtn->Calc();
// pFtn->UnlockPosOfLowerObjs();
// <--
}
// --> OD 2006-02-02 #i57914# - adjust fix #i49383#
// no extra notify for footnote frame
// else
// {
// aFtnFrmNotitfy.FrmDeleted();
// }
// <--
}
}
else
{ ASSERT( !pFtn->GetMaster() && !pFtn->GetFollow(),
"DelFtn und Master/Follow?" );
delete pFtn;
// --> OD 2004-06-10 #i21478#
pFtn = 0L;
}
// --> OD 2004-06-10 #i21478#
if ( pFtn )
{
pLastInsertedFtn = pFtn;
}
}
// --> OD 2004-06-10 #i21478# - format content of footnote following
// the new inserted ones.
if ( bCalc && pLastInsertedFtn )
{
if ( pLastInsertedFtn->GetNext() )
{
SwFtnFrm* pNextFtn = static_cast<SwFtnFrm*>(pLastInsertedFtn->GetNext());
SwTxtFtn* pAttr = pNextFtn->GetAttr();
SwFrm* pCnt = pNextFtn->ContainsAny();
sal_Bool bUnlock = !pNextFtn->IsBackMoveLocked();
pNextFtn->LockBackMove();
// --> OD 2005-05-18 #i49383# - disable unlock of position of
// lower objects during format of footnote content.
pNextFtn->KeepLockPosOfLowerObjs();
// --> OD 2006-02-02 #i57914# - adjust fix #i49383#
// no extra notify for footnote frame
// SwLayNotify aFtnFrmNotitfy( pNextFtn );
// <--
while ( pCnt && pCnt->FindFtnFrm()->GetAttr() == pAttr )
{
pCnt->_InvalidatePos();
pCnt->Calc();
// --> OD 2005-05-17 #i49383# - format anchored objects
if ( pCnt->IsTxtFrm() && pCnt->IsValid() )
{
if ( !SwObjectFormatter::FormatObjsAtFrm( *pCnt,
*(pCnt->FindPageFrm()) ) )
{
// restart format with first content
pCnt = pNextFtn->ContainsAny();
continue;
}
}
// <--
if( pCnt->IsSctFrm() )
{ // Wenn es sich um einen nichtleeren Bereich handelt,
// iterieren wir auch ueber seinen Inhalt
SwFrm* pTmp = ((SwSectionFrm*)pCnt)->ContainsAny();
if( pTmp )
pCnt = pTmp;
else
pCnt = pCnt->FindNext();
}
else
pCnt = pCnt->FindNext();
}
if( bUnlock )
{
pNextFtn->UnlockBackMove();
}
// --> OD 2005-05-18 #i49383#
// --> OD 2006-02-02 #i57914# - adjust fix #i49383#
// enable lock of lower object position before format of footnote frame.
pNextFtn->UnlockPosOfLowerObjs();
pNextFtn->Calc();
// pNextFtn->UnlockPosOfLowerObjs();
// <--
}
}
}
/*************************************************************************
|*
|* SwFtnBossFrm::MoveFtns()
|*
|*************************************************************************/
void SwFtnBossFrm::MoveFtns( const SwCntntFrm *pSrc, SwCntntFrm *pDest,
SwTxtFtn *pAttr )
{
if( ( GetFmt()->GetDoc()->GetFtnInfo().ePos == FTNPOS_CHAPTER &&
(!GetUpper()->IsSctFrm() || !((SwSectionFrm*)GetUpper())->IsFtnAtEnd()))
|| pAttr->GetFtn().IsEndNote() )
return;
ASSERT( this == pSrc->FindFtnBossFrm( sal_True ),
"SwPageFrm::MoveFtns: source frame isn't on that FtnBoss" );
SwFtnFrm *pFtn = FindFirstFtn();
if( pFtn )
{
ChangeFtnRef( pSrc, pAttr, pDest );
SwFtnBossFrm *pDestBoss = pDest->FindFtnBossFrm( sal_True );
ASSERT( pDestBoss, "+SwPageFrm::MoveFtns: no destination boss" );
if( pDestBoss ) // robust
{
SvPtrarr aFtnArr( 5, 5 );
pDestBoss->_CollectFtns( pDest, pFtn, aFtnArr );
if ( aFtnArr.Count() )
{
pDestBoss->_MoveFtns( aFtnArr, sal_True );
SwPageFrm* pSrcPage = FindPageFrm();
SwPageFrm* pDestPage = pDestBoss->FindPageFrm();
// Nur beim Seitenwechsel FtnNum Updaten
if( pSrcPage != pDestPage )
{
if( pSrcPage->GetPhyPageNum() > pDestPage->GetPhyPageNum() )
pSrcPage->UpdateFtnNum();
pDestPage->UpdateFtnNum();
}
}
}
}
}
/*************************************************************************
|*
|* SwFtnBossFrm::RearrangeFtns()
|*
|*************************************************************************/
void SwFtnBossFrm::RearrangeFtns( const SwTwips nDeadLine, const sal_Bool bLock,
const SwTxtFtn *pAttr )
{
//Alle Fussnoten der Spalte/Seite dergestalt anformatieren,
//dass sie ggf. die Spalte/Seite wechseln.
SwSaveFtnHeight aSave( this, nDeadLine );
SwFtnFrm *pFtn = FindFirstFtn();
if( pFtn && pFtn->GetPrev() && bLock )
{
SwFtnFrm* pFirst = (SwFtnFrm*)pFtn->GetUpper()->Lower();
SwFrm* pCntnt = pFirst->ContainsAny();
if( pCntnt )
{
sal_Bool bUnlock = !pFirst->IsBackMoveLocked();
pFirst->LockBackMove();
pFirst->Calc();
pCntnt->Calc();
// --> OD 2005-05-17 #i49383# - format anchored objects
if ( pCntnt->IsTxtFrm() && pCntnt->IsValid() )
{
SwObjectFormatter::FormatObjsAtFrm( *pCntnt,
*(pCntnt->FindPageFrm()) );
}
// <--
if( bUnlock )
pFirst->UnlockBackMove();
}
pFtn = FindFirstFtn();
}
SwDoc *pDoc = GetFmt()->GetDoc();
const sal_uLong nFtnPos = pAttr ? ::lcl_FindFtnPos( pDoc, pAttr ) : 0;
SwFrm *pCnt = pFtn ? pFtn->ContainsAny() : 0;
if ( pCnt )
{
sal_Bool bMore = sal_True;
sal_Bool bStart = pAttr == 0; // wenn kein Attribut uebergeben wird, alle bearbeiten
// --> OD 2005-05-18 #i49383# - disable unlock of position of
// lower objects during format of footnote and footnote content.
SwFtnFrm* pLastFtnFrm( 0L );
// --> OD 2006-02-02 #i57914# - adjust fix #i49383#
// no extra notify for footnote frame
// SwLayNotify* pFtnFrmNotify( 0L );
// footnote frame needs to be locked, if <bLock> isn't set.
bool bUnlockLastFtnFrm( false );
// <--
do
{
if( !bStart )
bStart = ::lcl_FindFtnPos( pDoc, pCnt->FindFtnFrm()->GetAttr() )
== nFtnPos;
if( bStart )
{
pCnt->_InvalidatePos();
pCnt->_InvalidateSize();
pCnt->Prepare( PREP_ADJUST_FRM );
SwFtnFrm* pFtnFrm = pCnt->FindFtnFrm();
// --> OD 2005-05-18 #i49383#
if ( pFtnFrm != pLastFtnFrm )
{
if ( pLastFtnFrm )
{
if ( !bLock && bUnlockLastFtnFrm )
{
pLastFtnFrm->ColUnlock();
}
// --> OD 2006-02-02 #i57914# - adjust fix #i49383#
// enable lock of lower object position before format of footnote frame.
pLastFtnFrm->UnlockPosOfLowerObjs();
pLastFtnFrm->Calc();
// pLastFtnFrm->UnlockPosOfLowerObjs();
// no extra notify for footnote frame
// delete pFtnFrmNotify;
// <--
if ( !bLock && bUnlockLastFtnFrm &&
!pLastFtnFrm->GetLower() &&
!pLastFtnFrm->IsColLocked() &&
!pLastFtnFrm->IsBackMoveLocked() )
{
pLastFtnFrm->Cut();
delete pLastFtnFrm;
pLastFtnFrm = 0L;
}
}
if ( !bLock )
{
bUnlockLastFtnFrm = !pFtnFrm->IsColLocked();
pFtnFrm->ColLock();
}
pFtnFrm->KeepLockPosOfLowerObjs();
pLastFtnFrm = pFtnFrm;
// --> OD 2006-02-02 #i57914# - adjust fix #i49383#
// no extra notify for footnote frame
// pFtnFrmNotify = new SwLayNotify( pLastFtnFrm );
// <--
}
// <--
// OD 30.10.2002 #97265# - invalidate position of footnote
// frame, if it's below its footnote container, in order to
// assure its correct position, probably calculating its previous
// footnote frames.
{
SWRECTFN( this );
SwFrm* aFtnContFrm = pFtnFrm->GetUpper();
if ( (pFtnFrm->Frm().*fnRect->fnTopDist)((aFtnContFrm->*fnRect->fnGetPrtBottom)()) > 0 )
{
pFtnFrm->_InvalidatePos();
}
}
if ( bLock )
{
sal_Bool bUnlock = !pFtnFrm->IsBackMoveLocked();
pFtnFrm->LockBackMove();
pFtnFrm->Calc();
pCnt->Calc();
// --> OD 2005-05-17 #i49383# - format anchored objects
if ( pCnt->IsTxtFrm() && pCnt->IsValid() )
{
if ( !SwObjectFormatter::FormatObjsAtFrm( *pCnt,
*(pCnt->FindPageFrm()) ) )
{
// restart format with first content
pCnt = pFtn->ContainsAny();
continue;
}
}
// <--
if( bUnlock )
{
pFtnFrm->UnlockBackMove();
if( !pFtnFrm->Lower() &&
!pFtnFrm->IsColLocked() )
{
// --> OD 2005-08-10 #i49383#
ASSERT( pLastFtnFrm == pFtnFrm,
"<SwFtnBossFrm::RearrangeFtns(..)> - <pLastFtnFrm> != <pFtnFrm>" );
pLastFtnFrm = 0L;
// --> OD 2006-02-02 #i57914# - adjust fix #i49383#
// no extra notify for footnote frame
// pFtnFrmNotify->FrmDeleted();
// delete pFtnFrmNotify;
// <--
pFtnFrm->Cut();
delete pFtnFrm;
}
}
}
else
{
pFtnFrm->Calc();
pCnt->Calc();
// --> OD 2005-05-17 #i49383# - format anchored objects
if ( pCnt->IsTxtFrm() && pCnt->IsValid() )
{
if ( !SwObjectFormatter::FormatObjsAtFrm( *pCnt,
*(pCnt->FindPageFrm()) ) )
{
// restart format with first content
pCnt = pFtn->ContainsAny();
continue;
}
}
// <--
}
}
SwSectionFrm *pDel = NULL;
if( pCnt->IsSctFrm() )
{
SwFrm* pTmp = ((SwSectionFrm*)pCnt)->ContainsAny();
if( pTmp )
{
pCnt = pTmp;
continue;
}
pDel = (SwSectionFrm*)pCnt;
}
if ( pCnt->GetNext() )
pCnt = pCnt->GetNext();
else
{
pCnt = pCnt->FindNext();
if ( pCnt )
{
SwFtnFrm* pFtnFrm = pCnt->FindFtnFrm();
if( pFtnFrm->GetRef()->FindFtnBossFrm(
pFtnFrm->GetAttr()->GetFtn().IsEndNote() ) != this )
bMore = sal_False;
}
else
bMore = sal_False;
}
if( pDel )
{
pDel->Cut();
delete pDel;
}
if ( bMore )
{
//Nicht weiter als bis zur angegebenen Fussnote, falls eine
//angegeben wurde.
if ( pAttr &&
(::lcl_FindFtnPos( pDoc,
pCnt->FindFtnFrm()->GetAttr()) > nFtnPos ) )
bMore = sal_False;
}
} while ( bMore );
// --> OD 2005-05-18 #i49383#
if ( pLastFtnFrm )
{
if ( !bLock && bUnlockLastFtnFrm )
{
pLastFtnFrm->ColUnlock();
}
// --> OD 2006-02-02 #i57914# - adjust fix #i49383#
// enable lock of lower object position before format of footnote frame.
pLastFtnFrm->UnlockPosOfLowerObjs();
pLastFtnFrm->Calc();
// pLastFtnFrm->UnlockPosOfLowerObjs();
// no extra notify for footnote frame
// delete pFtnFrmNotify;
// <--
if ( !bLock && bUnlockLastFtnFrm &&
!pLastFtnFrm->GetLower() &&
!pLastFtnFrm->IsColLocked() &&
!pLastFtnFrm->IsBackMoveLocked() )
{
pLastFtnFrm->Cut();
delete pLastFtnFrm;
}
}
// <--
}
}
/*************************************************************************
|*
|* SwPageFrm::UpdateFtnNum()
|*
|*************************************************************************/
void SwPageFrm::UpdateFtnNum()
{
//Seitenweise Numerierung nur wenn es am Dokument so eingestellt ist.
if ( GetFmt()->GetDoc()->GetFtnInfo().eNum != FTNNUM_PAGE )
return;
SwLayoutFrm* pBody = FindBodyCont();
if( !pBody || !pBody->Lower() )
return;
SwCntntFrm* pCntnt = pBody->ContainsCntnt();
sal_uInt16 nNum = 0;
while( pCntnt && pCntnt->FindPageFrm() == this )
{
if( ((SwTxtFrm*)pCntnt)->HasFtn() )
{
SwFtnBossFrm* pBoss = pCntnt->FindFtnBossFrm( sal_True );
if( pBoss->GetUpper()->IsSctFrm() &&
((SwSectionFrm*)pBoss->GetUpper())->IsOwnFtnNum() )
pCntnt = ((SwSectionFrm*)pBoss->GetUpper())->FindLastCntnt();
else
{
SwFtnFrm* pFtn = (SwFtnFrm*)pBoss->FindFirstFtn( pCntnt );
while( pFtn )
{
SwTxtFtn* pTxtFtn = pFtn->GetAttr();
if( !pTxtFtn->GetFtn().IsEndNote() &&
!pTxtFtn->GetFtn().GetNumStr().Len() &&
!pFtn->GetMaster() &&
(pTxtFtn->GetFtn().GetNumber() != ++nNum) )
pTxtFtn->SetNumber( nNum );
if ( pFtn->GetNext() )
pFtn = (SwFtnFrm*)pFtn->GetNext();
else
{
SwFtnBossFrm* pTmpBoss = pFtn->FindFtnBossFrm( sal_True );
SwPageFrm* pPage = pTmpBoss->FindPageFrm();
pFtn = NULL;
lcl_NextFtnBoss( pTmpBoss, pPage, sal_False );
if( pTmpBoss )
{
SwFtnContFrm *pCont = pTmpBoss->FindNearestFtnCont();
if ( pCont )
pFtn = (SwFtnFrm*)pCont->Lower();
}
}
if( pFtn && pFtn->GetRef() != pCntnt )
pFtn = NULL;
}
}
}
pCntnt = pCntnt->FindNextCnt();
}
}
/*************************************************************************
|*
|* SwFtnBossFrm::SetFtnDeadLine()
|*
|*************************************************************************/
void SwFtnBossFrm::SetFtnDeadLine( const SwTwips nDeadLine )
{
SwFrm *pBody = FindBodyCont();
pBody->Calc();
SwFrm *pCont = FindFtnCont();
const SwTwips nMax = nMaxFtnHeight;//Aktuelle MaxHeight nicht ueberschreiten.
SWRECTFN( this )
if ( pCont )
{
pCont->Calc();
nMaxFtnHeight = -(pCont->Frm().*fnRect->fnBottomDist)( nDeadLine );
}
else
nMaxFtnHeight = -(pBody->Frm().*fnRect->fnBottomDist)( nDeadLine );
const ViewShell *pSh = getRootFrm() ? getRootFrm()->GetCurrShell() : 0;
if( pSh && pSh->GetViewOptions()->getBrowseMode() )
nMaxFtnHeight += pBody->Grow( LONG_MAX, sal_True );
if ( IsInSct() )
nMaxFtnHeight += FindSctFrm()->Grow( LONG_MAX, sal_True );
if ( nMaxFtnHeight < 0 )
nMaxFtnHeight = 0;
if ( nMax != LONG_MAX && nMaxFtnHeight > nMax )
nMaxFtnHeight = nMax;
}
/*************************************************************************
|*
|* SwFtnBossFrm::GetVarSpace()
|*
|*************************************************************************/
SwTwips SwFtnBossFrm::GetVarSpace() const
{
//Fuer Seiten soll ein Wert von 20% der Seitenhoehe nicht unterschritten
//werden (->AMA: was macht MS da?)
//->AMA: Was ist da fuer Bereiche sinnvoll (und kompatibel zu MS ;-)?
//AMA: MS kennt scheinbar kein Begrenzung, die Fussnoten nehmen durchaus
// die ganze Seite/Spalte ein.
const SwPageFrm* pPg = FindPageFrm();
ASSERT( pPg || IsInSct(), "Footnote lost page" );
const SwFrm *pBody = FindBodyCont();
SwTwips nRet;
if( pBody )
{
SWRECTFN( this )
if( IsInSct() )
{
nRet = 0;
SwTwips nTmp = (*fnRect->fnYDiff)( (pBody->*fnRect->fnGetPrtTop)(),
(Frm().*fnRect->fnGetTop)() );
const SwSectionFrm* pSect = FindSctFrm();
// Endnotes in a ftncontainer causes a deadline:
// the bottom of the last contentfrm
if( pSect->IsEndnAtEnd() ) // endnotes allowed?
{
ASSERT( !Lower() || !Lower()->GetNext() || Lower()->GetNext()->
IsFtnContFrm(), "FtnContainer exspected" );
const SwFtnContFrm* pCont = Lower() ?
(SwFtnContFrm*)Lower()->GetNext() : 0;
if( pCont )
{
SwFtnFrm* pFtn = (SwFtnFrm*)pCont->Lower();
while( pFtn)
{
if( pFtn->GetAttr()->GetFtn().IsEndNote() )
{ // endnote found
SwFrm* pFrm = ((SwLayoutFrm*)Lower())->Lower();
if( pFrm )
{
while( pFrm->GetNext() )
pFrm = pFrm->GetNext(); // last cntntfrm
nTmp += (*fnRect->fnYDiff)(
(Frm().*fnRect->fnGetTop)(),
(pFrm->Frm().*fnRect->fnGetBottom)() );
}
break;
}
pFtn = (SwFtnFrm*)pFtn->GetNext();
}
}
}
if( nTmp < nRet )
nRet = nTmp;
}
else
nRet = - (pPg->Prt().*fnRect->fnGetHeight)()/5;
nRet += (pBody->Frm().*fnRect->fnGetHeight)();
if( nRet < 0 )
nRet = 0;
}
else
nRet = 0;
if ( IsPageFrm() )
{
const ViewShell *pSh = getRootFrm() ? getRootFrm()->GetCurrShell() : 0;
if( pSh && pSh->GetViewOptions()->getBrowseMode() )
nRet += BROWSE_HEIGHT - Frm().Height();
}
return nRet;
}
/*************************************************************************
|*
|* SwFtnBossFrm::NeighbourhoodAdjustment(SwFrm*)
|*
|* gibt Auskunft, ob die Groessenveraenderung von pFrm von AdjustNeighbourhood(...)
|* oder von Grow/Shrink(..) verarbeitet werden sollte.
|* Bei einem PageFrm oder in Spalten direkt unterhalb der Seite muss AdjustNei..
|* gerufen werden, in Rahmenspalten Grow/Shrink.
|* Spannend sind die spaltigen Bereiche: Wenn es in der Spalte einen Fussnotencontainer
|* gibt und die Fussnoten nicht vom Bereich eingesammelt werden, ist ein Adjust..,
|* ansonsten ein Grow/Shrink notwendig.
|*
|*************************************************************************/
sal_uInt8 SwFtnBossFrm::_NeighbourhoodAdjustment( const SwFrm* ) const
{
sal_uInt8 nRet = NA_ONLY_ADJUST;
if( GetUpper() && !GetUpper()->IsPageBodyFrm() )
{
// Spaltige Rahmen erfordern Grow/Shrink
if( GetUpper()->IsFlyFrm() )
nRet = NA_GROW_SHRINK;
else
{
ASSERT( GetUpper()->IsSctFrm(), "NeighbourhoodAdjustment: Unexspected Upper" );
if( !GetNext() && !GetPrev() )
nRet = NA_GROW_ADJUST; // section with a single column (FtnAtEnd)
else
{
const SwFrm* pTmp = Lower();
ASSERT( pTmp, "NeighbourhoodAdjustment: Missing Lower()" );
if( !pTmp->GetNext() )
nRet = NA_GROW_SHRINK;
else if( !GetUpper()->IsColLocked() )
nRet = NA_ADJUST_GROW;
ASSERT( !pTmp->GetNext() || pTmp->GetNext()->IsFtnContFrm(),
"NeighbourhoodAdjustment: Who's that guy?" );
}
}
}
return nRet;
}
/*************************************************************************
|*
|* SwPageFrm::SetColMaxFtnHeight()
|*
|*************************************************************************/
void SwPageFrm::SetColMaxFtnHeight()
{
SwLayoutFrm *pBody = FindBodyCont();
if( pBody && pBody->Lower() && pBody->Lower()->IsColumnFrm() )
{
SwColumnFrm* pCol = (SwColumnFrm*)pBody->Lower();
do
{
pCol->SetMaxFtnHeight( GetMaxFtnHeight() );
pCol = (SwColumnFrm*)pCol->GetNext();
} while ( pCol );
}
}
/*************************************************************************
|*
|* SwLayoutFrm::MoveLowerFtns
|*
|*************************************************************************/
sal_Bool SwLayoutFrm::MoveLowerFtns( SwCntntFrm *pStart, SwFtnBossFrm *pOldBoss,
SwFtnBossFrm *pNewBoss, const sal_Bool bFtnNums )
{
SwDoc *pDoc = GetFmt()->GetDoc();
if ( !pDoc->GetFtnIdxs().Count() )
return sal_False;
if( pDoc->GetFtnInfo().ePos == FTNPOS_CHAPTER &&
( !IsInSct() || !FindSctFrm()->IsFtnAtEnd() ) )
return sal_True;
if ( !pNewBoss )
pNewBoss = FindFtnBossFrm( sal_True );
if ( pNewBoss == pOldBoss )
return sal_False;
sal_Bool bMoved = sal_False;
if( !pStart )
pStart = ContainsCntnt();
SvPtrarr aFtnArr( 5, 5 );
while ( IsAnLower( pStart ) )
{
if ( ((SwTxtFrm*)pStart)->HasFtn() )
{
// OD 03.04.2003 #108446# - To avoid unnecessary moves of footnotes
// use new parameter <_bCollectOnlyPreviousFtn> (4th parameter of
// method <SwFtnBossFrm::CollectFtn(..)>) to control, that only
// footnotes have to be collected, that are positioned before the
// new dedicated footnote boss frame.
pNewBoss->CollectFtns( pStart, pOldBoss, aFtnArr, sal_True );
}
pStart = pStart->GetNextCntntFrm();
}
ASSERT( pOldBoss->IsInSct() == pNewBoss->IsInSct(),
"MoveLowerFtns: Section confusion" );
SvPtrarr *pFtnArr;
SwLayoutFrm* pNewChief = 0;
SwLayoutFrm* pOldChief = 0;
if( pStart && pOldBoss->IsInSct() && ( pOldChief = pOldBoss->FindSctFrm() )
!= ( pNewChief = pNewBoss->FindSctFrm() ) )
{
pFtnArr = new SvPtrarr( 5, 5 );
pOldChief = pOldBoss->FindFtnBossFrm( sal_True );
pNewChief = pNewBoss->FindFtnBossFrm( sal_True );
while( pOldChief->IsAnLower( pStart ) )
{
if ( ((SwTxtFrm*)pStart)->HasFtn() )
((SwFtnBossFrm*)pNewChief)->CollectFtns( pStart,
(SwFtnBossFrm*)pOldBoss, *pFtnArr );
pStart = pStart->GetNextCntntFrm();
}
if( !pFtnArr->Count() )
{
delete pFtnArr;
pFtnArr = NULL;
}
}
else
pFtnArr = NULL;
if ( aFtnArr.Count() || pFtnArr )
{
if( aFtnArr.Count() )
pNewBoss->_MoveFtns( aFtnArr, sal_True );
if( pFtnArr )
{
((SwFtnBossFrm*)pNewChief)->_MoveFtns( *pFtnArr, sal_True );
delete pFtnArr;
}
bMoved = sal_True;
// Nur bei einem Seitenwechsel muss die FtnNum neu berechnet werden
if ( bFtnNums )
{
SwPageFrm* pOldPage = pOldBoss->FindPageFrm();
SwPageFrm* pNewPage =pNewBoss->FindPageFrm();
if( pOldPage != pNewPage )
{
pOldPage->UpdateFtnNum();
pNewPage->UpdateFtnNum();
}
}
}
return bMoved;
}
/*************************************************************************
|*
|* SwLayoutFrm::MoveFtnCntFwd()
|*
|*************************************************************************/
sal_Bool SwCntntFrm::MoveFtnCntFwd( sal_Bool bMakePage, SwFtnBossFrm *pOldBoss )
{
ASSERT( IsInFtn(), "Keine Ftn." );
SwLayoutFrm *pFtn = FindFtnFrm();
// The first paragraph in the first footnote in the first column in the
// sectionfrm at the top of the page has not to move forward, if the
// columnbody is empty.
if( pOldBoss->IsInSct() && !pOldBoss->GetIndPrev() && !GetIndPrev() &&
!pFtn->GetPrev() )
{
SwLayoutFrm* pBody = pOldBoss->FindBodyCont();
if( !pBody || !pBody->Lower() )
return sal_True;
}
//fix(9538): Wenn die Ftn noch Nachbarn hinter sich hat, so muessen
//diese ersteinmal verschwinden.
SwLayoutFrm *pNxt = (SwLayoutFrm*)pFtn->GetNext();
SwLayoutFrm *pLst = 0;
while ( pNxt )
{
while ( pNxt->GetNext() )
pNxt = (SwLayoutFrm*)pNxt->GetNext();
if ( pNxt == pLst )
pNxt = 0;
else
{ pLst = pNxt;
SwCntntFrm *pCnt = pNxt->ContainsCntnt();
if( pCnt )
pCnt->MoveFtnCntFwd( sal_True, pOldBoss );
pNxt = (SwLayoutFrm*)pFtn->GetNext();
}
}
sal_Bool bSamePage = sal_True;
SwLayoutFrm *pNewUpper =
GetLeaf( bMakePage ? MAKEPAGE_INSERT : MAKEPAGE_NONE, sal_True );
if ( pNewUpper )
{
sal_Bool bSameBoss = sal_True;
SwFtnBossFrm * const pNewBoss = pNewUpper->FindFtnBossFrm();
//Wechseln wir die Spalte/Seite?
if ( sal_False == ( bSameBoss = pNewBoss == pOldBoss ) )
{
bSamePage = pOldBoss->FindPageFrm() == pNewBoss->FindPageFrm(); // Seitenwechsel?
pNewUpper->Calc();
}
//Das Layoutblatt, dass wir fuer Fussnoten bekommen ist entweder
//ein Fussnotencontainer oder eine Fussnote
//Wenn es eine Fussnote ist, und sie die gleiche Fussnotenreferez
//wie der alte Upper hat, so moven wir uns direkt hinein.
//Ist die Referenz einen andere oder ist es ein Container, so wird
//eine neue Fussnote erzeugt und in den Container gestellt.
// Wenn wir in einem Bereich innerhalb der Fussnote sind, muss
// SectionFrame noch angelegt werden.
SwFtnFrm* pTmpFtn = pNewUpper->IsFtnFrm() ? ((SwFtnFrm*)pNewUpper) : 0;
if( !pTmpFtn )
{
ASSERT( pNewUpper->IsFtnContFrm(), "Neuer Upper kein FtnCont.");
SwFtnContFrm *pCont = (SwFtnContFrm*)pNewUpper;
//Fussnote erzeugen.
SwFtnFrm *pOld = FindFtnFrm();
pTmpFtn = new SwFtnFrm( pOld->GetFmt()->GetDoc()->GetDfltFrmFmt(),
pOld, pOld->GetRef(), pOld->GetAttr() );
//Verkettung der Fussnoten.
if ( pOld->GetFollow() )
{
pTmpFtn->SetFollow( pOld->GetFollow() );
pOld->GetFollow()->SetMaster( pTmpFtn );
}
pOld->SetFollow( pTmpFtn );
pTmpFtn->SetMaster( pOld );
SwFrm* pNx = pCont->Lower();
if( pNx && pTmpFtn->GetAttr()->GetFtn().IsEndNote() )
while(pNx && !((SwFtnFrm*)pNx)->GetAttr()->GetFtn().IsEndNote())
pNx = pNx->GetNext();
pTmpFtn->Paste( pCont, pNx );
pTmpFtn->Calc();
}
ASSERT( pTmpFtn->GetAttr() == FindFtnFrm()->GetAttr(), "Wrong Footnote!" );
// Bereiche in Fussnoten beduerfen besonderer Behandlung
SwLayoutFrm *pNewUp = pTmpFtn;
if( IsInSct() )
{
SwSectionFrm* pSect = FindSctFrm();
// Bereich in Fussnote (oder nur Fussnote in Bereich)?
if( pSect->IsInFtn() )
{
if( pTmpFtn->Lower() && pTmpFtn->Lower()->IsSctFrm() &&
pSect->GetFollow() == (SwSectionFrm*)pTmpFtn->Lower() )
pNewUp = (SwSectionFrm*)pTmpFtn->Lower();
else
{
pNewUp = new SwSectionFrm( *pSect, sal_False );
pNewUp->InsertBefore( pTmpFtn, pTmpFtn->Lower() );
static_cast<SwSectionFrm*>(pNewUp)->Init();
pNewUp->Frm().Pos() = pTmpFtn->Frm().Pos();
pNewUp->Frm().Pos().Y() += 1; //wg. Benachrichtigungen.
// Wenn unser Bereichsframe einen Nachfolger hat, so muss dieser
// umgehaengt werden hinter den neuen Follow der Bereichsframes.
SwFrm* pTmp = pSect->GetNext();
if( pTmp )
{
SwFlowFrm* pTmpNxt;
if( pTmp->IsCntntFrm() )
pTmpNxt = (SwCntntFrm*)pTmp;
else if( pTmp->IsSctFrm() )
pTmpNxt = (SwSectionFrm*)pTmp;
else
{
ASSERT( pTmp->IsTabFrm(), "GetNextSctLeaf: Wrong Type" );
pTmpNxt = (SwTabFrm*)pTmp;
}
pTmpNxt->MoveSubTree( pTmpFtn, pNewUp->GetNext() );
}
}
}
}
MoveSubTree( pNewUp, pNewUp->Lower() );
if( !bSameBoss )
Prepare( PREP_BOSS_CHGD );
}
return bSamePage;
}
/*************************************************************************
|*
|* class SwSaveFtnHeight
|*
|*************************************************************************/
SwSaveFtnHeight::SwSaveFtnHeight( SwFtnBossFrm *pBs, const SwTwips nDeadLine ) :
pBoss( pBs ),
nOldHeight( pBs->GetMaxFtnHeight() )
{
pBoss->SetFtnDeadLine( nDeadLine );
nNewHeight = pBoss->GetMaxFtnHeight();
}
SwSaveFtnHeight::~SwSaveFtnHeight()
{
//Wenn zwischendurch jemand an der DeadLine gedreht hat, so lassen wir
//ihm seinen Spass!
if ( nNewHeight == pBoss->GetMaxFtnHeight() )
pBoss->nMaxFtnHeight = nOldHeight;
}
#ifdef DBG_UTIL
//JP 15.10.2001: in a non pro version test if the attribute has the same
// meaning which his reference is
// Normally, the pRef member and the GetRefFromAttr() result has to be
// identically. Sometimes footnote will be moved from a master to its follow,
// but the GetRef() is called first, so we have to ignore a master/follow
// mismatch.
const SwCntntFrm* SwFtnFrm::GetRef() const
{
const SwCntntFrm* pRefAttr = GetRefFromAttr();
ASSERT( pRef == pRefAttr || pRef->IsAnFollow( pRefAttr )
|| pRefAttr->IsAnFollow( pRef ),
"access to deleted Frame? pRef != pAttr->GetRef()" );
return pRef;
}
SwCntntFrm* SwFtnFrm::GetRef()
{
const SwCntntFrm* pRefAttr = GetRefFromAttr();
ASSERT( pRef == pRefAttr || pRef->IsAnFollow( pRefAttr )
|| pRefAttr->IsAnFollow( pRef ),
"access to deleted Frame? pRef != pAttr->GetRef()" );
return pRef;
}
#endif
const SwCntntFrm* SwFtnFrm::GetRefFromAttr() const
{
SwFtnFrm* pThis = (SwFtnFrm*)this;
return pThis->GetRefFromAttr();
}
SwCntntFrm* SwFtnFrm::GetRefFromAttr()
{
ASSERT( pAttr, "invalid Attribute" );
SwTxtNode& rTNd = (SwTxtNode&)pAttr->GetTxtNode();
SwPosition aPos( rTNd, SwIndex( &rTNd, *pAttr->GetStart() ));
SwCntntFrm* pCFrm = rTNd.getLayoutFrm( getRootFrm(), 0, &aPos, sal_False );
return pCFrm;
}
/** search for last content in the current footnote frame
OD 2005-12-02 #i27138#
@author OD
*/
SwCntntFrm* SwFtnFrm::FindLastCntnt()
{
SwCntntFrm* pLastCntntFrm( 0L );
// find last lower, which is a content frame or contains content.
// hidden text frames, empty sections and empty tables have to be skipped.
SwFrm* pLastLowerOfFtn( GetLower() );
SwFrm* pTmpLastLower( pLastLowerOfFtn );
while ( pTmpLastLower && pTmpLastLower->GetNext() )
{
pTmpLastLower = pTmpLastLower->GetNext();
if ( ( pTmpLastLower->IsTxtFrm() &&
!static_cast<SwTxtFrm*>(pTmpLastLower)->IsHiddenNow() ) ||
( pTmpLastLower->IsSctFrm() &&
static_cast<SwSectionFrm*>(pTmpLastLower)->GetSection() &&
static_cast<SwSectionFrm*>(pTmpLastLower)->ContainsCntnt() ) ||
( pTmpLastLower->IsTabFrm() &&
static_cast<SwTabFrm*>(pTmpLastLower)->ContainsCntnt() ) )
{
pLastLowerOfFtn = pTmpLastLower;
}
}
// determine last content frame depending on type of found last lower.
if ( pLastLowerOfFtn && pLastLowerOfFtn->IsTabFrm() )
{
pLastCntntFrm = static_cast<SwTabFrm*>(pLastLowerOfFtn)->FindLastCntnt();
}
else if ( pLastLowerOfFtn && pLastLowerOfFtn->IsSctFrm() )
{
pLastCntntFrm = static_cast<SwSectionFrm*>(pLastLowerOfFtn)->FindLastCntnt();
}
else
{
pLastCntntFrm = dynamic_cast<SwCntntFrm*>(pLastLowerOfFtn);
}
return pLastCntntFrm;
}