2000-09-18 23:08:29 +00:00
|
|
|
/*************************************************************************
|
|
|
|
*
|
2008-04-10 14:44:40 +00:00
|
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
2000-09-18 23:08:29 +00:00
|
|
|
*
|
2010-02-12 15:01:35 +01:00
|
|
|
* Copyright 2000, 2010 Oracle and/or its affiliates.
|
2000-09-18 23:08:29 +00:00
|
|
|
*
|
2008-04-10 14:44:40 +00:00
|
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
2000-09-18 23:08:29 +00:00
|
|
|
*
|
2008-04-10 14:44:40 +00:00
|
|
|
* This file is part of OpenOffice.org.
|
2000-09-18 23:08:29 +00:00
|
|
|
*
|
2008-04-10 14:44:40 +00:00
|
|
|
* OpenOffice.org is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU Lesser General Public License version 3
|
|
|
|
* only, as published by the Free Software Foundation.
|
2000-09-18 23:08:29 +00:00
|
|
|
*
|
2008-04-10 14:44:40 +00:00
|
|
|
* OpenOffice.org is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU Lesser General Public License version 3 for more details
|
|
|
|
* (a copy is included in the LICENSE file that accompanied this code).
|
2000-09-18 23:08:29 +00:00
|
|
|
*
|
2008-04-10 14:44:40 +00:00
|
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
|
|
* version 3 along with OpenOffice.org. If not, see
|
|
|
|
* <http://www.openoffice.org/license.html>
|
|
|
|
* for a copy of the LGPLv3 License.
|
2000-09-18 23:08:29 +00:00
|
|
|
*
|
|
|
|
************************************************************************/
|
|
|
|
|
2006-09-16 20:42:41 +00:00
|
|
|
// MARKER(update_precomp.py): autogen include statement, do not remove
|
|
|
|
#include "precompiled_sw.hxx"
|
|
|
|
|
2000-09-18 23:08:29 +00:00
|
|
|
|
|
|
|
#include "hintids.hxx"
|
|
|
|
|
|
|
|
#include "layfrm.hxx"
|
|
|
|
#include "ftnboss.hxx"
|
|
|
|
#include "ndtxt.hxx"
|
|
|
|
#include "paratr.hxx"
|
2010-01-08 18:32:51 +01:00
|
|
|
#include <editeng/orphitem.hxx>
|
|
|
|
#include <editeng/widwitem.hxx>
|
|
|
|
#include <editeng/keepitem.hxx>
|
|
|
|
#include <editeng/spltitem.hxx>
|
2000-09-18 23:08:29 +00:00
|
|
|
#include <frmatr.hxx>
|
|
|
|
#include <txtftn.hxx>
|
|
|
|
#include <fmtftn.hxx>
|
2004-01-13 10:21:22 +00:00
|
|
|
#include <rowfrm.hxx>
|
2000-09-18 23:08:29 +00:00
|
|
|
|
|
|
|
#include "txtcfg.hxx"
|
|
|
|
#include "widorp.hxx"
|
|
|
|
#include "txtfrm.hxx"
|
|
|
|
#include "itrtxt.hxx"
|
|
|
|
#include "sectfrm.hxx" //SwSectionFrm
|
|
|
|
#include "ftnfrm.hxx"
|
|
|
|
|
|
|
|
#undef WIDOWTWIPS
|
|
|
|
|
|
|
|
|
|
|
|
/*************************************************************************
|
|
|
|
* inline IsNastyFollow()
|
|
|
|
*************************************************************************/
|
|
|
|
// Ein Follow, der auf der selben Seite steht, wie sein Master ist nasty.
|
|
|
|
inline sal_Bool IsNastyFollow( const SwTxtFrm *pFrm )
|
|
|
|
{
|
|
|
|
ASSERT( !pFrm->IsFollow() || !pFrm->GetPrev() ||
|
|
|
|
((const SwTxtFrm*)pFrm->GetPrev())->GetFollow() == pFrm,
|
|
|
|
"IsNastyFollow: Was ist denn hier los?" );
|
|
|
|
return pFrm->IsFollow() && pFrm->GetPrev();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*************************************************************************
|
|
|
|
* SwTxtFrmBreak::SwTxtFrmBreak()
|
|
|
|
*************************************************************************/
|
|
|
|
|
2007-09-27 08:22:05 +00:00
|
|
|
SwTxtFrmBreak::SwTxtFrmBreak( SwTxtFrm *pNewFrm, const SwTwips nRst )
|
|
|
|
: nRstHeight(nRst), pFrm(pNewFrm)
|
2000-09-18 23:08:29 +00:00
|
|
|
{
|
2001-12-05 08:08:20 +00:00
|
|
|
SWAP_IF_SWAPPED( pFrm )
|
|
|
|
SWRECTFN( pFrm )
|
|
|
|
nOrigin = (pFrm->*fnRect->fnGetPrtTop)();
|
2000-09-18 23:08:29 +00:00
|
|
|
SwSectionFrm* pSct;
|
|
|
|
bKeep = !pFrm->IsMoveable() || IsNastyFollow( pFrm ) ||
|
|
|
|
( pFrm->IsInSct() && (pSct=pFrm->FindSctFrm())->Lower()->IsColumnFrm()
|
|
|
|
&& !pSct->MoveAllowed( pFrm ) ) ||
|
|
|
|
!pFrm->GetTxtNode()->GetSwAttrSet().GetSplit().GetValue() ||
|
|
|
|
pFrm->GetTxtNode()->GetSwAttrSet().GetKeep().GetValue();
|
|
|
|
bBreak = sal_False;
|
|
|
|
|
|
|
|
if( !nRstHeight && !pFrm->IsFollow() && pFrm->IsInFtn() && pFrm->HasPara() )
|
|
|
|
{
|
|
|
|
nRstHeight = pFrm->GetFtnFrmHeight();
|
2001-12-05 08:08:20 +00:00
|
|
|
nRstHeight += (pFrm->Prt().*fnRect->fnGetHeight)() -
|
|
|
|
(pFrm->Frm().*fnRect->fnGetHeight)();
|
2000-09-18 23:08:29 +00:00
|
|
|
if( nRstHeight < 0 )
|
|
|
|
nRstHeight = 0;
|
|
|
|
}
|
2001-12-05 08:08:20 +00:00
|
|
|
|
|
|
|
UNDO_SWAP( pFrm )
|
2000-09-18 23:08:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* BP 18.6.93: Widows.
|
|
|
|
* Im Gegensatz zur ersten Implementierung werden die Widows nicht
|
|
|
|
* mehr vorausschauend berechnet, sondern erst beim Formatieren des
|
|
|
|
* gesplitteten Follows festgestellt. Im Master faellt die Widows-
|
|
|
|
* Berechnung also generell weg (nWidows wird manipuliert).
|
|
|
|
* Wenn der Follow feststellt, dass die Widowsregel zutrifft,
|
|
|
|
* verschickt er an seinen Vorgaenger ein Prepare.
|
|
|
|
* Ein besonderes Problem ergibt sich, wenn die Widows zuschlagen,
|
|
|
|
* aber im Master noch ein paar Zeilen zur Verfuegung stehen.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*************************************************************************
|
|
|
|
* SwTxtFrmBreak::IsInside()
|
|
|
|
*************************************************************************/
|
|
|
|
|
|
|
|
/* BP(22.07.92): Berechnung von Witwen und Waisen.
|
|
|
|
* Die Methode liefert sal_True zurueck, wenn eine dieser Regelung zutrifft.
|
|
|
|
*
|
|
|
|
* Eine Schwierigkeit gibt es im Zusammenhang mit Widows und
|
|
|
|
* unterschiedlichen Formaten zwischen Master- und Folgeframes:
|
|
|
|
* Beispiel: Wenn die erste Spalte 3cm und die zweite 4cm breit ist
|
|
|
|
* und Widows auf sagen wir 3 gesetzt ist, so ist erst bei der Formatierung
|
|
|
|
* des Follows entscheidbar, ob die Widowsbedingung einhaltbar ist oder
|
|
|
|
* nicht. Leider ist davon abhaengig, ob der Absatz als Ganzes auf die
|
|
|
|
* naechste Seite rutscht.
|
|
|
|
*/
|
|
|
|
|
2008-10-10 13:02:43 +00:00
|
|
|
sal_Bool SwTxtFrmBreak::IsInside( SwTxtMargin &rLine ) const
|
2000-09-18 23:08:29 +00:00
|
|
|
{
|
2007-09-27 08:22:05 +00:00
|
|
|
sal_Bool bFit = sal_False;
|
2001-12-05 08:08:20 +00:00
|
|
|
|
2001-11-14 10:03:17 +00:00
|
|
|
SWAP_IF_SWAPPED( pFrm )
|
2001-12-05 08:08:20 +00:00
|
|
|
SWRECTFN( pFrm )
|
|
|
|
// nOrigin is an absolut value, rLine referes to the swapped situation.
|
2001-08-31 05:22:48 +00:00
|
|
|
|
2001-12-05 08:08:20 +00:00
|
|
|
SwTwips nTmpY;
|
|
|
|
if ( pFrm->IsVertical() )
|
|
|
|
nTmpY = pFrm->SwitchHorizontalToVertical( rLine.Y() + rLine.GetLineHeight() );
|
|
|
|
else
|
|
|
|
nTmpY = rLine.Y() + rLine.GetLineHeight();
|
|
|
|
|
|
|
|
SwTwips nLineHeight = (*fnRect->fnYDiff)( nTmpY , nOrigin );
|
2000-09-18 23:08:29 +00:00
|
|
|
|
|
|
|
// 7455 und 6114: Raum fuer die Umrandung unten einkalkulieren.
|
2001-12-05 08:08:20 +00:00
|
|
|
nLineHeight += (pFrm->*fnRect->fnGetBottomMargin)();
|
2002-12-12 08:04:44 +00:00
|
|
|
|
2000-09-18 23:08:29 +00:00
|
|
|
if( nRstHeight )
|
|
|
|
bFit = nRstHeight >= nLineHeight;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Der Frm besitzt eine Hoehe, mit der er auf die Seite passt.
|
2001-12-05 08:08:20 +00:00
|
|
|
SwTwips nHeight =
|
2001-12-13 15:02:36 +00:00
|
|
|
(*fnRect->fnYDiff)( (pFrm->GetUpper()->*fnRect->fnGetPrtBottom)(), nOrigin );
|
2000-09-18 23:08:29 +00:00
|
|
|
|
|
|
|
// Wenn sich alles innerhalb des bestehenden Frames abspielt,
|
|
|
|
// ist das Ergebnis sal_True;
|
|
|
|
bFit = nHeight >= nLineHeight;
|
|
|
|
if( !bFit )
|
|
|
|
{
|
|
|
|
// Die LineHeight sprengt die aktuelle Frm-Hoehe.
|
|
|
|
// Nun rufen wir ein Probe-Grow, um zu ermitteln, ob der
|
|
|
|
// Frame um den gewuenschten Bereich wachsen wuerde.
|
|
|
|
nHeight += pFrm->GrowTst( LONG_MAX );
|
|
|
|
|
|
|
|
// Das Grow() returnt die Hoehe, um die der Upper des TxtFrm
|
|
|
|
// den TxtFrm wachsen lassen wuerde.
|
|
|
|
// Der TxtFrm selbst darf wachsen wie er will.
|
|
|
|
bFit = nHeight >= nLineHeight;
|
|
|
|
}
|
|
|
|
}
|
2001-08-31 05:22:48 +00:00
|
|
|
|
2001-11-14 10:03:17 +00:00
|
|
|
UNDO_SWAP( pFrm );
|
2001-08-31 05:22:48 +00:00
|
|
|
|
2000-09-18 23:08:29 +00:00
|
|
|
return bFit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*************************************************************************
|
|
|
|
* SwTxtFrmBreak::IsBreakNow()
|
|
|
|
*************************************************************************/
|
|
|
|
|
|
|
|
sal_Bool SwTxtFrmBreak::IsBreakNow( SwTxtMargin &rLine )
|
|
|
|
{
|
2001-12-05 08:08:20 +00:00
|
|
|
SWAP_IF_SWAPPED( pFrm )
|
|
|
|
|
2000-09-18 23:08:29 +00:00
|
|
|
// bKeep ist staerker als IsBreakNow()
|
|
|
|
// Ist noch genug Platz ?
|
|
|
|
if( bKeep || IsInside( rLine ) )
|
|
|
|
bBreak = sal_False;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Diese Klasse geht davon aus, dass der SwTxtMargin von Top nach Bottom
|
|
|
|
* durchgearbeitet wird. Aus Performancegruenden wird in folgenden
|
|
|
|
* Faellen der Laden fuer das weitere Aufspalten dicht gemacht:
|
|
|
|
* Wenn eine einzige Zeile nicht mehr passt.
|
|
|
|
* Sonderfall: bei DummyPortions ist LineNr == 1, obwohl wir splitten
|
|
|
|
* wollen.
|
|
|
|
*/
|
|
|
|
// 6010: DropLines mit einbeziehen
|
|
|
|
|
|
|
|
sal_Bool bFirstLine = 1 == rLine.GetLineNr() && !rLine.GetPrev();
|
|
|
|
bBreak = sal_True;
|
|
|
|
if( ( bFirstLine && pFrm->GetIndPrev() )
|
|
|
|
|| ( rLine.GetLineNr() <= rLine.GetDropLines() ) )
|
|
|
|
{
|
|
|
|
bKeep = sal_True;
|
|
|
|
bBreak = sal_False;
|
|
|
|
}
|
|
|
|
else if(bFirstLine && pFrm->IsInFtn() && !pFrm->FindFtnFrm()->GetPrev())
|
|
|
|
{
|
|
|
|
SwLayoutFrm* pTmp = pFrm->FindFtnBossFrm()->FindBodyCont();
|
|
|
|
if( !pTmp || !pTmp->Lower() )
|
|
|
|
bBreak = sal_False;
|
|
|
|
}
|
|
|
|
}
|
2001-12-05 08:08:20 +00:00
|
|
|
|
|
|
|
UNDO_SWAP( pFrm )
|
|
|
|
|
2000-09-18 23:08:29 +00:00
|
|
|
return bBreak;
|
|
|
|
}
|
|
|
|
|
2004-03-23 10:26:00 +00:00
|
|
|
// OD 2004-02-27 #106629# - no longer inline
|
|
|
|
void SwTxtFrmBreak::SetRstHeight( const SwTxtMargin &rLine )
|
2000-09-18 23:08:29 +00:00
|
|
|
{
|
2004-03-23 10:26:00 +00:00
|
|
|
// OD, FME 2004-02-27 #106629# - consider bottom margin
|
|
|
|
SWRECTFN( pFrm )
|
|
|
|
nRstHeight = (pFrm->*fnRect->fnGetBottomMargin)();
|
|
|
|
if ( bVert )
|
|
|
|
nRstHeight += nOrigin - pFrm->SwitchHorizontalToVertical( rLine.Y() );
|
|
|
|
else
|
|
|
|
nRstHeight += rLine.Y() - nOrigin;
|
2000-09-18 23:08:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*************************************************************************
|
|
|
|
* WidowsAndOrphans::WidowsAndOrphans()
|
|
|
|
*************************************************************************/
|
|
|
|
|
2007-09-27 08:22:05 +00:00
|
|
|
WidowsAndOrphans::WidowsAndOrphans( SwTxtFrm *pNewFrm, const SwTwips nRst,
|
2000-09-18 23:08:29 +00:00
|
|
|
sal_Bool bChkKeep )
|
2007-09-27 08:22:05 +00:00
|
|
|
: SwTxtFrmBreak( pNewFrm, nRst ), nWidLines( 0 ), nOrphLines( 0 )
|
2000-09-18 23:08:29 +00:00
|
|
|
{
|
2001-12-05 08:08:20 +00:00
|
|
|
SWAP_IF_SWAPPED( pFrm )
|
|
|
|
|
2000-09-18 23:08:29 +00:00
|
|
|
if( bKeep )
|
|
|
|
{
|
|
|
|
// 5652: bei Absaetzen, die zusammengehalten werden sollen und
|
|
|
|
// groesser sind als die Seite wird bKeep aufgehoben.
|
|
|
|
if( bChkKeep && !pFrm->GetPrev() && !pFrm->IsInFtn() &&
|
|
|
|
pFrm->IsMoveable() &&
|
|
|
|
( !pFrm->IsInSct() || pFrm->FindSctFrm()->MoveAllowed(pFrm) ) )
|
|
|
|
bKeep = sal_False;
|
|
|
|
//Auch bei gesetztem Keep muessen Orphans beachtet werden,
|
|
|
|
//z.B. bei verketteten Rahmen erhaelt ein Follow im letzten Rahmen ein Keep,
|
|
|
|
//da er nicht (vorwaerts) Moveable ist,
|
|
|
|
//er darf aber trotzdem vom Master Zeilen anfordern wg. der Orphanregel.
|
|
|
|
if( pFrm->IsFollow() )
|
|
|
|
nWidLines = pFrm->GetTxtNode()->GetSwAttrSet().GetWidows().GetValue();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const SwAttrSet& rSet = pFrm->GetTxtNode()->GetSwAttrSet();
|
|
|
|
const SvxOrphansItem &rOrph = rSet.GetOrphans();
|
|
|
|
if ( rOrph.GetValue() > 1 )
|
|
|
|
nOrphLines = rOrph.GetValue();
|
|
|
|
if ( pFrm->IsFollow() )
|
|
|
|
nWidLines = rSet.GetWidows().GetValue();
|
|
|
|
|
|
|
|
}
|
2004-01-13 10:21:22 +00:00
|
|
|
|
2007-02-28 14:52:19 +00:00
|
|
|
if ( bKeep || nWidLines || nOrphLines )
|
2004-01-13 10:21:22 +00:00
|
|
|
{
|
2007-02-28 14:52:19 +00:00
|
|
|
bool bResetFlags = false;
|
|
|
|
|
|
|
|
if ( pFrm->IsInTab() )
|
2004-01-13 10:21:22 +00:00
|
|
|
{
|
2007-02-28 14:52:19 +00:00
|
|
|
// For compatibility reasons, we disable Keep/Widows/Orphans
|
|
|
|
// inside splittable row frames:
|
|
|
|
if ( pFrm->GetNextCellLeaf( MAKEPAGE_NONE ) || pFrm->IsInFollowFlowRow() )
|
|
|
|
{
|
|
|
|
const SwFrm* pTmpFrm = pFrm->GetUpper();
|
|
|
|
while ( !pTmpFrm->IsRowFrm() )
|
|
|
|
pTmpFrm = pTmpFrm->GetUpper();
|
|
|
|
if ( static_cast<const SwRowFrm*>(pTmpFrm)->IsRowSplitAllowed() )
|
|
|
|
bResetFlags = true;
|
|
|
|
}
|
2004-01-13 10:21:22 +00:00
|
|
|
}
|
|
|
|
|
2007-02-28 14:52:19 +00:00
|
|
|
if( pFrm->IsInFtn() && !pFrm->GetIndPrev() )
|
|
|
|
{
|
|
|
|
// Innerhalb von Fussnoten gibt es gute Gruende, das Keep-Attribut und
|
|
|
|
// die Widows/Orphans abzuschalten.
|
|
|
|
SwFtnFrm *pFtn = pFrm->FindFtnFrm();
|
|
|
|
sal_Bool bFt = !pFtn->GetAttr()->GetFtn().IsEndNote();
|
|
|
|
if( !pFtn->GetPrev() &&
|
|
|
|
pFtn->FindFtnBossFrm( bFt ) != pFtn->GetRef()->FindFtnBossFrm( bFt )
|
|
|
|
&& ( !pFrm->IsInSct() || pFrm->FindSctFrm()->MoveAllowed(pFrm) ) )
|
|
|
|
{
|
|
|
|
bResetFlags = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( bResetFlags )
|
2000-09-18 23:08:29 +00:00
|
|
|
{
|
|
|
|
bKeep = sal_False;
|
|
|
|
nOrphLines = 0;
|
|
|
|
nWidLines = 0;
|
|
|
|
}
|
|
|
|
}
|
2001-12-05 08:08:20 +00:00
|
|
|
|
|
|
|
UNDO_SWAP( pFrm )
|
2000-09-18 23:08:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*************************************************************************
|
|
|
|
* WidowsAndOrphans::FindBreak()
|
|
|
|
*************************************************************************/
|
|
|
|
|
|
|
|
/* Die Find*-Methoden suchen nicht nur, sondern stellen den SwTxtMargin auf
|
|
|
|
* die Zeile ein, wo der Absatz gebrochen werden soll und kuerzen ihn dort.
|
|
|
|
* FindBreak()
|
|
|
|
*/
|
|
|
|
|
2001-05-11 13:01:30 +00:00
|
|
|
sal_Bool WidowsAndOrphans::FindBreak( SwTxtFrm *pFrame, SwTxtMargin &rLine,
|
2000-09-18 23:08:29 +00:00
|
|
|
sal_Bool bHasToFit )
|
|
|
|
{
|
2004-05-03 13:24:13 +00:00
|
|
|
// OD 2004-02-25 #i16128# - Why member <pFrm> _*and*_ parameter <pFrame>??
|
|
|
|
// Thus, assertion on situation, that these are different to figure out why.
|
|
|
|
ASSERT( pFrm == pFrame, "<WidowsAndOrphans::FindBreak> - pFrm != pFrame" );
|
|
|
|
|
2001-12-05 08:08:20 +00:00
|
|
|
SWAP_IF_SWAPPED( pFrm )
|
|
|
|
|
2000-09-18 23:08:29 +00:00
|
|
|
sal_Bool bRet = sal_True;
|
|
|
|
MSHORT nOldOrphans = nOrphLines;
|
|
|
|
if( bHasToFit )
|
|
|
|
nOrphLines = 0;
|
|
|
|
rLine.Bottom();
|
2004-05-03 13:24:13 +00:00
|
|
|
// OD 2004-02-25 #i16128# - method renamed
|
|
|
|
if( !IsBreakNowWidAndOrp( rLine ) )
|
2000-09-18 23:08:29 +00:00
|
|
|
bRet = sal_False;
|
2001-05-11 13:01:30 +00:00
|
|
|
if( !FindWidows( pFrame, rLine ) )
|
2000-09-18 23:08:29 +00:00
|
|
|
{
|
|
|
|
sal_Bool bBack = sal_False;
|
2004-05-03 13:24:13 +00:00
|
|
|
// OD 2004-02-25 #i16128# - method renamed
|
|
|
|
while( IsBreakNowWidAndOrp( rLine ) )
|
2000-09-18 23:08:29 +00:00
|
|
|
{
|
|
|
|
if( rLine.PrevLine() )
|
|
|
|
bBack = sal_True;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// Eigentlich werden bei HasToFit Schusterjungen (Orphans) nicht
|
|
|
|
// beruecksichtigt, wenn allerdings Dummy-Lines im Spiel sind und
|
|
|
|
// die Orphansregel verletzt wird, machen wir mal eine Ausnahme:
|
|
|
|
// Wir lassen einfach eine Dummyline zurueck und wandern mit dem Text
|
|
|
|
// komplett auf die naechste Seite/Spalte.
|
2001-05-11 13:01:30 +00:00
|
|
|
if( rLine.GetLineNr() <= nOldOrphans &&
|
|
|
|
rLine.GetInfo().GetParaPortion()->IsDummy() &&
|
2004-05-03 13:24:13 +00:00
|
|
|
( ( bHasToFit && bRet ) || IsBreakNow( rLine ) ) )
|
2000-09-18 23:08:29 +00:00
|
|
|
rLine.Top();
|
2001-05-11 13:01:30 +00:00
|
|
|
|
2000-09-18 23:08:29 +00:00
|
|
|
rLine.TruncLines( sal_True );
|
|
|
|
bRet = bBack;
|
|
|
|
}
|
|
|
|
nOrphLines = nOldOrphans;
|
2001-12-05 08:08:20 +00:00
|
|
|
|
|
|
|
UNDO_SWAP( pFrm )
|
|
|
|
|
2000-09-18 23:08:29 +00:00
|
|
|
return bRet;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*************************************************************************
|
|
|
|
* WidowsAndOrphans::FindWidows()
|
|
|
|
*************************************************************************/
|
|
|
|
|
|
|
|
/* FindWidows positioniert den SwTxtMargin des Masters auf die umzubrechende
|
|
|
|
* Zeile, indem der Follow formatiert und untersucht wird.
|
|
|
|
* Liefert sal_True zurueck, wenn die Widows-Regelung in Kraft tritt,
|
|
|
|
* d.h. der Absatz _zusammengehalten_ werden soll !
|
|
|
|
*/
|
|
|
|
|
2007-09-27 08:22:05 +00:00
|
|
|
sal_Bool WidowsAndOrphans::FindWidows( SwTxtFrm *pFrame, SwTxtMargin &rLine )
|
2000-09-18 23:08:29 +00:00
|
|
|
{
|
2007-09-27 08:22:05 +00:00
|
|
|
ASSERT( ! pFrame->IsVertical() || ! pFrame->IsSwapped(),
|
2001-12-05 08:08:20 +00:00
|
|
|
"WidowsAndOrphans::FindWidows with swapped frame" )
|
|
|
|
|
2007-09-27 08:22:05 +00:00
|
|
|
if( !nWidLines || !pFrame->IsFollow() )
|
2000-09-18 23:08:29 +00:00
|
|
|
return sal_False;
|
|
|
|
|
|
|
|
rLine.Bottom();
|
|
|
|
|
|
|
|
// Wir koennen noch was abzwacken
|
2007-09-27 08:22:05 +00:00
|
|
|
SwTxtFrm *pMaster = pFrame->FindMaster();
|
2000-09-18 23:08:29 +00:00
|
|
|
ASSERT(pMaster, "+WidowsAndOrphans::FindWidows: Widows in a master?");
|
|
|
|
if( !pMaster )
|
|
|
|
return sal_False;
|
|
|
|
|
|
|
|
// 5156: Wenn die erste Zeile des Follows nicht passt, wird der Master
|
|
|
|
// wohl voll mit Dummies sein. In diesem Fall waere ein PREP_WIDOWS fatal.
|
2007-09-27 08:22:05 +00:00
|
|
|
if( pMaster->GetOfst() == pFrame->GetOfst() )
|
2000-09-18 23:08:29 +00:00
|
|
|
return sal_False;
|
|
|
|
|
|
|
|
// Resthoehe des Masters
|
2007-09-27 08:22:05 +00:00
|
|
|
SWRECTFN( pFrame )
|
2001-12-05 08:08:20 +00:00
|
|
|
|
2007-09-27 08:22:05 +00:00
|
|
|
const SwTwips nDocPrtTop = (pFrame->*fnRect->fnGetPrtTop)();
|
2001-12-05 08:08:20 +00:00
|
|
|
SwTwips nOldHeight;
|
|
|
|
SwTwips nTmpY = rLine.Y() + rLine.GetLineHeight();
|
|
|
|
|
|
|
|
if ( bVert )
|
|
|
|
{
|
2007-09-27 08:22:05 +00:00
|
|
|
nTmpY = pFrame->SwitchHorizontalToVertical( nTmpY );
|
|
|
|
nOldHeight = -(pFrame->Prt().*fnRect->fnGetHeight)();
|
2001-12-05 08:08:20 +00:00
|
|
|
}
|
|
|
|
else
|
2007-09-27 08:22:05 +00:00
|
|
|
nOldHeight = (pFrame->Prt().*fnRect->fnGetHeight)();
|
2001-12-05 08:08:20 +00:00
|
|
|
|
|
|
|
const SwTwips nChg = (*fnRect->fnYDiff)( nTmpY, nDocPrtTop + nOldHeight );
|
2000-09-18 23:08:29 +00:00
|
|
|
|
|
|
|
// Unterhalb der Widows-Schwelle...
|
|
|
|
if( rLine.GetLineNr() >= nWidLines )
|
|
|
|
{
|
|
|
|
// 8575: Follow to Master I
|
|
|
|
// Wenn der Follow *waechst*, so besteht fuer den Master die Chance,
|
|
|
|
// Zeilen entgegenzunehmen, die er vor Kurzem gezwungen war an den
|
|
|
|
// Follow abzugeben: Prepare(Need); diese Abfrage unterhalb von nChg!
|
|
|
|
// (0W, 2O, 2M, 2F) + 1F = 3M, 2F
|
2007-09-27 08:22:05 +00:00
|
|
|
if( rLine.GetLineNr() > nWidLines && pFrame->IsJustWidow() )
|
2000-09-18 23:08:29 +00:00
|
|
|
{
|
|
|
|
// Wenn der Master gelockt ist, so hat er vermutlich gerade erst
|
|
|
|
// eine Zeile an uns abgegeben, diese geben nicht zurueck, nur
|
|
|
|
// weil bei uns daraus mehrere geworden sind (z.B. durch Rahmen).
|
2001-12-05 08:08:20 +00:00
|
|
|
if( !pMaster->IsLocked() && pMaster->GetUpper() )
|
|
|
|
{
|
2007-09-27 08:22:05 +00:00
|
|
|
const SwTwips nTmpRstHeight = (pMaster->Frm().*fnRect->fnBottomDist)
|
2001-12-13 15:02:36 +00:00
|
|
|
( (pMaster->GetUpper()->*fnRect->fnGetPrtBottom)() );
|
2007-09-27 08:22:05 +00:00
|
|
|
if ( nTmpRstHeight >=
|
2001-12-05 08:08:20 +00:00
|
|
|
SwTwips(rLine.GetInfo().GetParaPortion()->Height() ) )
|
|
|
|
{
|
|
|
|
pMaster->Prepare( PREP_ADJUST_FRM );
|
|
|
|
pMaster->_InvalidateSize();
|
|
|
|
pMaster->InvalidatePage();
|
|
|
|
}
|
|
|
|
}
|
2002-12-12 08:04:44 +00:00
|
|
|
|
2007-09-27 08:22:05 +00:00
|
|
|
pFrame->SetJustWidow( sal_False );
|
2000-09-18 23:08:29 +00:00
|
|
|
}
|
|
|
|
return sal_False;
|
|
|
|
}
|
|
|
|
|
|
|
|
// 8575: Follow to Master II
|
|
|
|
// Wenn der Follow *schrumpft*, so besteht fuer den Master die Chance,
|
|
|
|
// den kompletten Orphan zu inhalieren.
|
|
|
|
// (0W, 2O, 2M, 1F) - 1F = 3M, 0F -> PREP_ADJUST_FRM
|
|
|
|
// (0W, 2O, 3M, 2F) - 1F = 2M, 2F -> PREP_WIDOWS
|
|
|
|
|
2001-12-05 08:08:20 +00:00
|
|
|
if( 0 > nChg && !pMaster->IsLocked() && pMaster->GetUpper() )
|
|
|
|
{
|
2007-09-27 08:22:05 +00:00
|
|
|
SwTwips nTmpRstHeight = (pMaster->Frm().*fnRect->fnBottomDist)
|
2001-12-13 15:02:36 +00:00
|
|
|
( (pMaster->GetUpper()->*fnRect->fnGetPrtBottom)() );
|
2007-09-27 08:22:05 +00:00
|
|
|
if( nTmpRstHeight >= SwTwips(rLine.GetInfo().GetParaPortion()->Height() ) )
|
2001-12-05 08:08:20 +00:00
|
|
|
{
|
|
|
|
pMaster->Prepare( PREP_ADJUST_FRM );
|
|
|
|
pMaster->_InvalidateSize();
|
|
|
|
pMaster->InvalidatePage();
|
2007-09-27 08:22:05 +00:00
|
|
|
pFrame->SetJustWidow( sal_False );
|
2001-12-05 08:08:20 +00:00
|
|
|
return sal_False;
|
|
|
|
}
|
|
|
|
}
|
2002-12-12 08:04:44 +00:00
|
|
|
|
|
|
|
// Master to Follow
|
|
|
|
// Wenn der Follow nach seiner Formatierung weniger Zeilen enthaelt
|
|
|
|
// als Widows, so besteht noch die Chance, einige Zeilen des Masters
|
|
|
|
// abzuzwacken. Wenn dadurch die Orphans-Regel des Masters in Kraft
|
|
|
|
// tritt muss im CalcPrep() des Master-Frame der Frame so vergroessert
|
|
|
|
// werden, dass er nicht mehr auf seine urspruengliche Seite passt.
|
|
|
|
// Wenn er noch ein paar Zeilen entbehren kann, dann muss im CalcPrep()
|
|
|
|
// ein Shrink() erfolgen, der Follow mit dem Widows rutscht dann auf
|
|
|
|
// die Seite des Masters, haelt sich aber zusammen, so dass er (endlich)
|
|
|
|
// auf die naechste Seite rutscht. - So die Theorie!
|
|
|
|
|
|
|
|
|
|
|
|
// Wir fordern nur noch ein Zeile zur Zeit an, weil eine Zeile des Masters
|
|
|
|
// bei uns durchaus mehrere Zeilen ergeben koennten.
|
|
|
|
// Dafuer behaelt CalcFollow solange die Kontrolle, bis der Follow alle
|
|
|
|
// notwendigen Zeilen bekommen hat.
|
|
|
|
MSHORT nNeed = 1; // frueher: nWidLines - rLine.GetLineNr();
|
|
|
|
|
|
|
|
// Special case: Master cannot give lines to follow
|
2008-11-19 16:29:07 +00:00
|
|
|
// --> FME 2008-09-16 #i91421#
|
|
|
|
if ( !pMaster->GetIndPrev() )
|
|
|
|
{
|
|
|
|
ULONG nLines = pMaster->GetThisLines();
|
|
|
|
if(nLines == 0 && pMaster->HasPara())
|
|
|
|
{
|
|
|
|
const SwParaPortion *pMasterPara = pMaster->GetPara();
|
|
|
|
if(pMasterPara && pMasterPara->GetNext())
|
|
|
|
nLines = 2;
|
|
|
|
}
|
|
|
|
if( nLines <= nNeed )
|
|
|
|
return sal_False;
|
|
|
|
}
|
2002-12-12 08:04:44 +00:00
|
|
|
|
2000-09-18 23:08:29 +00:00
|
|
|
pMaster->Prepare( PREP_WIDOWS, (void*)&nNeed );
|
|
|
|
return sal_True;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*************************************************************************
|
|
|
|
* WidowsAndOrphans::WouldFit()
|
|
|
|
*************************************************************************/
|
|
|
|
|
2003-09-25 09:49:59 +00:00
|
|
|
sal_Bool WidowsAndOrphans::WouldFit( SwTxtMargin &rLine, SwTwips &rMaxHeight, sal_Bool bTst )
|
2000-09-18 23:08:29 +00:00
|
|
|
{
|
2001-12-05 08:08:20 +00:00
|
|
|
// Here it does not matter, if pFrm is swapped or not.
|
|
|
|
// IsInside() takes care for itself
|
|
|
|
|
2000-09-18 23:08:29 +00:00
|
|
|
// Wir erwarten, dass rLine auf der letzten Zeile steht!!
|
|
|
|
ASSERT( !rLine.GetNext(), "WouldFit: aLine::Bottom missed!" );
|
|
|
|
MSHORT nLineCnt = rLine.GetLineNr();
|
|
|
|
|
|
|
|
// Erstmal die Orphansregel und den Initialenwunsch erfuellen ...
|
|
|
|
const MSHORT nMinLines = Max( GetOrphansLines(), rLine.GetDropLines() );
|
|
|
|
if ( nLineCnt < nMinLines )
|
|
|
|
return sal_False;
|
|
|
|
|
|
|
|
rLine.Top();
|
|
|
|
SwTwips nLineSum = rLine.GetLineHeight();
|
|
|
|
|
|
|
|
while( nMinLines > rLine.GetLineNr() )
|
|
|
|
{
|
|
|
|
DBG_LOOP;
|
|
|
|
if( !rLine.NextLine() )
|
|
|
|
return sal_False;
|
|
|
|
nLineSum += rLine.GetLineHeight();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Wenn wir jetzt schon nicht mehr passen ...
|
|
|
|
if( !IsInside( rLine ) )
|
|
|
|
return sal_False;
|
|
|
|
|
|
|
|
// Jetzt noch die Widows-Regel ueberpruefen
|
|
|
|
if( !nWidLines && !pFrm->IsFollow() )
|
|
|
|
{
|
|
|
|
// I.A. brauchen Widows nur ueberprueft werden, wenn wir ein Follow
|
|
|
|
// sind. Bei WouldFit muss aber auch fuer den Master die Regel ueber-
|
|
|
|
// prueft werden, weil wir ja gerade erst die Trennstelle ermitteln.
|
|
|
|
// Im Ctor von WidowsAndOrphans wurde nWidLines aber nur fuer Follows
|
|
|
|
// aus dem AttrSet ermittelt, deshalb holen wir es hier nach:
|
|
|
|
const SwAttrSet& rSet = pFrm->GetTxtNode()->GetSwAttrSet();
|
|
|
|
nWidLines = rSet.GetWidows().GetValue();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Sind nach Orphans/Initialen noch genug Zeilen fuer die Widows uebrig?
|
2004-03-17 11:51:39 +00:00
|
|
|
// #111937#: If we are currently doing a test formatting, we may not
|
|
|
|
// consider the widows rule for two reasons:
|
|
|
|
// 1. The columns may have different widths.
|
|
|
|
// Widow lines would have wrong width.
|
|
|
|
// 2. Test formatting is only done up to the given space.
|
|
|
|
// we do not have any lines for widows at all.
|
2003-09-25 09:49:59 +00:00
|
|
|
if( bTst || nLineCnt - nMinLines >= GetWidowsLines() )
|
2000-09-18 23:08:29 +00:00
|
|
|
{
|
|
|
|
if( rMaxHeight >= nLineSum )
|
|
|
|
{
|
|
|
|
rMaxHeight -= nLineSum;
|
|
|
|
return sal_True;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return sal_False;
|
|
|
|
}
|
|
|
|
|