Skip to content

C
core
Kaydet (Commit) 7caa7ae8 authored tarafından Philipp Weissenbacher's avatar Philipp Weissenbacher
Dosyalara gözat
Seçenekler

Translate German comments

üst ae62f61a
Show whitespace changes
Inline Side-by-side
Showing with 138 additions and 146 deletions
sw/source/core/text/txtfly.cxx
Dosyayı görüntüle @ 7caa7ae8
......@@ -74,7 +74,7 @@
#include "doc.hxx"
#ifdef DBG_UTIL
#include "viewopt.hxx" // SwViewOptions, nur zum Testen (Test2)
#include "viewopt.hxx" // SwViewOptions, only for testing (Test2)
#include "doc.hxx"
#endif
......@@ -82,37 +82,34 @@
using namespace ::com::sun::star;
/*****************************************************************************
* Beschreibung:
* Die Klasse SwTxtFly soll die Universalschnittstelle zwischen der
* Formatierung/Textausgabe und den u.U. ueberlappenden freifliegenden
* Frames sein.
* Waehrend der Formatierung erkundigt sich der Formatierer beim SwTxtFly,
* ob ein bestimmter Bereich durch die Attribute eines ueberlappenden
* Frames vorliegt. Solche Bereiche werden in Form von Dummy-Portions
* abgebildet.
* Die gesamte Textausgabe und Retusche wird ebenfalls an ein SwTxtFly
* weitergeleitet. Dieser entscheidet, ob Textteile geclippt werden muessen
* und zerteilt z.B. die Bereiche bei einem DrawRect.
* Zu beachten ist, dass alle freifliegenden Frames in einem nach TopLeft
* sortiertem PtrArray an der Seite zu finden sind. Intern wird immer nur
* in dokumentglobalen Werten gerechnet. Die IN- und OUT-Parameter sind
* jedoch in den meisten Faellen an die Beduerfnisse des LineIters
* zugeschnitten, d.h. sie werden in frame- oder windowlokalen Koordinaten
* konvertiert.
* Wenn mehrere Frames mit Umlaufattributen in einer Zeile liegen,
* ergeben sich unterschiedliche Auswirkungen fuer den Textfluss:
* Description:
* SwTxtFly's purpose is to be the universal interface between
* formatting/text output and the possibly overlapping free-flying frames.
* During formatting the formatter gets the information from SwTxtFly, whether
* a certain area is present by the attributes of an overlapping frame.
* Such areas are represented by dummy portions.
* The whole text output and touch-up is, again, forwarded to a SwTxtFly.
* This one decides, whether parts of the text need to be clipped and splits
* the areas for e.g. a DrawRect.
* Please note that all free-flying frames are located in a PtrArray, sorted
* by TopLeft.
* Internally we always use document-global values. The IN and OUT parameters
* are, however, adjusted to the needs of the LineIter most of the time. That
* is: they are converted to frame- and window-local coordinates.
* If multiple frames with wrap attributes are located on the same line, we get
* the following settings for the text flow:
*
* L/R P L R K
* P -P-P- -P-L -P R- -P K
* L -L P- -L L -L R- -L K
* R R-P- R-L R R- R K
* K K P- K L K R- K K
* L/R P L R N
* P -P-P- -P-L -P R- -P N
* L -L P- -L L -L R- -L N
* R R-P- R-L R R- R N
* N N P- N L N R- N N
*
* (P=parallel, L=links, R=rechts, K=kein Umlauf)
* (P=parallel, L=left, R=right, N=no wrap)
*
* Das Verhalten so beschreiben:
* Jeder Rahmen kann Text verdraengen, wobei der Einfluss allerdings nur
* bis zum naechsten Rahmen reicht.
* We can describe the behaviour as follows:
* Every frame can push away text, with the restriction that it only has influence
* until the next frame.
*****************************************************************************/
void SwTxtFormatter::CalcUnclipped( SwTwips& rTop, SwTwips& rBottom )
......@@ -128,9 +125,10 @@ void SwTxtFormatter::CalcUnclipped( SwTwips& rTop, SwTwips& rBottom )
}
/*************************************************************************
* SwTxtFormatter::UpdatePos() aktualisiert die Referenzpunkte der zeichengeb.
* Objekte, z. B. nach Adjustierung ( rechtsbuendig, Blocksatz etc. )
* ( hauptsaechlich Korrrektur der X-Position )
* SwTxtFormatter::UpdatePos()
* Updates the reference points of the character anchored objects,
* e.g. after adjusting right-aligned, justified etc.
* (That's mainly to correct the x position)
*************************************************************************/
void SwTxtFormatter::UpdatePos( SwLineLayout *pCurrent, Point aStart,
......@@ -149,7 +147,7 @@ void SwTxtFormatter::UpdatePos( SwLineLayout *pCurrent, Point aStart,
aTmpInf.SetKanaComp( pCurrent->GetpKanaComp() );
aTmpInf.ResetKanaIdx();
// Die Groesse des Frames
// The frame's size
aTmpInf.SetIdx( nStartIdx );
aTmpInf.SetPos( aStart );
......@@ -185,9 +183,9 @@ void SwTxtFormatter::UpdatePos( SwLineLayout *pCurrent, Point aStart,
while( pPos )
{
// bislang ist mir nur ein Fall bekannt, wo die Positionsaenderung
// (verursacht durch das Adjustment) fuer eine Portion wichtig
// sein koennte: Bei FlyCntPortions muss ein SetRefPoint erfolgen.
// We only know one case where changing the position (caused by the
// adjustment) could be relevant for a portion: We need to SetRefPoint
// for FlyCntPortions.
if( ( pPos->IsFlyCntPortion() || pPos->IsGrfNumPortion() )
&& ( bAllWays || !IsQuick() ) )
{
......@@ -257,7 +255,7 @@ void SwTxtFormatter::UpdatePos( SwLineLayout *pCurrent, Point aStart,
/*************************************************************************
* SwTxtFormatter::AlignFlyInCntBase()
* richtet die zeichengeb. Objekte in Y-Richtung ggf. neu aus.
* If needed, re-adjusts the character anchored objects to the y axis.
*************************************************************************/
void SwTxtFormatter::AlignFlyInCntBase( long nBaseLine ) const
......@@ -309,11 +307,11 @@ void SwTxtFormatter::AlignFlyInCntBase( long nBaseLine ) const
/*************************************************************************
* SwTxtFly::ChkFlyUnderflow()
* This is called after the real height of the line has been calculated
* This is called after the real height of the line has been calculated.
* Therefore it is possible, that more flys from below intersect with the
* line, or that flys from above do not intersect with the line anymore
* We check this and return true if so, meaning that the line has to be
* formatted again
* line, or that flys from above do not intersect with the line anymore.
* We check this and return true, meaning that the line has to be
* formatted again.
*************************************************************************/
sal_Bool SwTxtFormatter::ChkFlyUnderflow( SwTxtFormatInfo &rInf ) const
......@@ -321,7 +319,7 @@ sal_Bool SwTxtFormatter::ChkFlyUnderflow( SwTxtFormatInfo &rInf ) const
OSL_ENSURE( rInf.GetTxtFly()->IsOn(), "SwTxtFormatter::ChkFlyUnderflow: why?" );
if( GetCurr() )
{
// Erst pruefen wir, ob ueberhaupt ein Fly mit der Zeile ueberlappt.
// First we check, whether a fly overlaps with the line.
// = GetLineHeight()
const long nHeight = GetCurr()->GetRealHeight();
SwRect aLine( GetLeftMargin(), Y(), rInf.RealWidth(), nHeight );
......@@ -336,8 +334,8 @@ sal_Bool SwTxtFormatter::ChkFlyUnderflow( SwTxtFormatInfo &rInf ) const
if( !aInter.HasArea() )
return sal_False;
// Nun ueberpruefen wir jede Portion, die sich haette senken koennen,
// ob sie mit dem Fly ueberlappt.
// We now check every portion that could have lowered for overlapping
// with the fly.
const SwLinePortion *pPos = GetCurr()->GetFirstPortion();
aLine.Pos().Y() = Y() + GetCurr()->GetRealHeight() - GetCurr()->Height();
aLine.Height( GetCurr()->Height() );
......@@ -353,7 +351,7 @@ sal_Bool SwTxtFormatter::ChkFlyUnderflow( SwTxtFormatInfo &rInf ) const
if ( pFrm->IsVertical() )
pFrm->SwitchVerticalToHorizontal( aInter );
// new flys from below?
// New flys from below?
if( !pPos->IsFlyPortion() )
{
if( aInter.IsOver( aLine ) )
......@@ -361,7 +359,7 @@ sal_Bool SwTxtFormatter::ChkFlyUnderflow( SwTxtFormatInfo &rInf ) const
aInter._Intersection( aLine );
if( aInter.HasArea() )
{
// to be evaluated during reformat of this line:
// To be evaluated during reformat of this line:
// RealHeight including spacing
rInf.SetLineHeight( KSHORT(nHeight) );
// Height without extra spacing
......@@ -372,7 +370,7 @@ sal_Bool SwTxtFormatter::ChkFlyUnderflow( SwTxtFormatInfo &rInf ) const
}
else
{
// the fly portion is not anylonger intersected by a fly
// The fly portion is not intersected by a fly anymore
if ( ! aInter.IsOver( aLine ) )
{
rInf.SetLineHeight( KSHORT(nHeight) );
......@@ -383,10 +381,10 @@ sal_Bool SwTxtFormatter::ChkFlyUnderflow( SwTxtFormatInfo &rInf ) const
{
aInter._Intersection( aLine );
// no area means a fly has become invalid because of
// lowering the line => reformat the line
// we also have to reformat the line, if the fly size
// differs from the intersection intervals size
// No area means a fly has become invalid because of
// lowering the line => reformat the line.
// We also have to reformat the line, if the fly size
// differs from the intersection interval's size.
if( ! aInter.HasArea() ||
((SwFlyPortion*)pPos)->GetFixWidth() != aInter.Width() )
{
......@@ -406,12 +404,12 @@ sal_Bool SwTxtFormatter::ChkFlyUnderflow( SwTxtFormatInfo &rInf ) const
/*************************************************************************
* SwTxtFormatter::CalcFlyWidth()
* ermittelt das naechste Objekt, das in die restliche Zeile ragt und
* konstruiert die zugehoerige FlyPortion.
* Dazu wird SwTxtFly.GetFrm(..) benutzt.
* Determines the next object, that reaches into the rest of the line and
* constructs the appropriate FlyPortion.
* We use SwTxtFly.GetFrm(..) for that.
*************************************************************************/
// Durch Flys kann sich der rechte Rand verkuerzen.
// The right margin can be shortened by Flys.
void SwTxtFormatter::CalcFlyWidth( SwTxtFormatInfo &rInf )
{
......@@ -430,7 +428,7 @@ void SwTxtFormatter::CalcFlyWidth( SwTxtFormatInfo &rInf )
if( rInf.GetLineHeight() )
{
// real line height has already been calculated, we only have to
// Real line height has already been calculated, we only have to
// search for intersections in the lower part of the strip
nAscent = pCurr->GetAscent();
nHeight = rInf.GetLineNettoHeight();
......@@ -441,14 +439,14 @@ void SwTxtFormatter::CalcFlyWidth( SwTxtFormatInfo &rInf )
nAscent = pLast->GetAscent();
nHeight = pLast->Height();
// we make a first guess for the lines real height
// We make a first guess for the line's real height
if ( ! pCurr->GetRealHeight() )
CalcRealHeight();
if ( pCurr->GetRealHeight() > nHeight )
nTop += pCurr->GetRealHeight() - nHeight;
else
// important for fixed space between lines
// Important for fixed space between lines
nHeight = pCurr->GetRealHeight();
}
......@@ -495,10 +493,9 @@ void SwTxtFormatter::CalcFlyWidth( SwTxtFormatInfo &rInf )
nAddMar = nLeftMar - nFrmLeft;
aInter.Width( aInter.Width() + nAddMar );
// Bei negativem Erstzeileneinzug setzen wir das Flag,
// um anzuzeigen, dass der Einzug/Rand verschoben wurde
// Dies muss beim DefaultTab an der Nullposition beruecksichtigt
// werden.
// For a negative first line indent, we set this flag to show
// that the indentation/margin has been moved.
// This needs to be respected by the DefaultTab at the zero position.
if( IsFirstTxtLine() && HasNegFirst() )
bForced = sal_True;
}
......@@ -509,17 +506,16 @@ void SwTxtFormatter::CalcFlyWidth( SwTxtFormatInfo &rInf )
const sal_Bool bFullLine = aLine.Left() == aInter.Left() &&
aLine.Right() == aInter.Right();
// Obwohl kein Text mehr da ist, muss eine weitere Zeile
// formatiert werden, weil auch leere Zeilen einem Fly
// ohne Umlauf ausweichen muessen.
// Although no text is left, we need to format another line,
// because also empty lines need to avoid a Fly with no wrapping.
if( bFullLine && rInf.GetIdx() == rInf.GetTxt().Len() )
{
rInf.SetNewLine( sal_True );
// 8221: Dummies erkennt man an Ascent == Height
// 8221: We know that for dummies, it holds ascent == height
pCurr->SetDummy(sal_True);
}
// aInter wird framelokal
// aInter becomes frame-local
aInter.Pos().X() -= nLeftMar;
SwFlyPortion *pFly = new SwFlyPortion( aInter );
if( bForced )
......@@ -530,24 +526,23 @@ void SwTxtFormatter::CalcFlyWidth( SwTxtFormatInfo &rInf )
if( bFullLine )
{
// 8110: wir muessen um Einheiten von Zeilenhoehen anwachsen,
// um nebeneinanderliegende Flys mit unterschiedlichen
// Umlaufattributen angemessen zu umfliessen.
// Die letzte ausweichende Zeile, sollte in der Hoehe angepasst
// sein, damit nicht der Eindruck von "Rahmenabstaenden" aufkommt.
// 8221: Wichtig ist, dass Ascent == Height ist, weil die FlyPortionWerte
// im CalcLine in pCurr uebertragen werden und IsDummy() darauf
// angewiesen ist.
// Es gibt meines Wissens nur zwei Stellen, in denen DummyLines
// entstehen koennen: hier und in MakeFlyDummies.
// Ausgewertet wird IsDummy() in IsFirstTxtLine() und
// beim Zeilenwandern und im Zusammenhang mit DropCaps.
// 8110: In order to properly flow around Flys with different
// wrapping attributes, we need to increase by units of line height.
// The last avoiding line should be adjusted in height, so that
// we don't get a frame spacing effect.
// 8221: It is important that ascent == height, because the FlyPortion
// values are transferred to pCurr in CalcLine and IsDummy() relies
// on this behaviour.
// To my knowledge we only have two places where DummyLines can be
// created: here and in MakeFlyDummies.
// IsDummy() is evaluated in IsFirstTxtLine(), when moving lines
// and in relation with DropCaps.
pFly->Height( KSHORT(aInter.Height()) );
// In nNextTop steckt jetzt die Unterkante des Rahmens, dem wir
// ausweichen oder die Oberkante des naechsten Rahmens, den wir
// beachten muessen. Wir koennen also jetzt getrost bis zu diesem
// Wert anwachsen, so sparen wir einige Leerzeilen.
// nNextTop now contains the margin's bottom edge, which we avoid
// or the next margin's top edge, which we need to respect.
// That means we can comfortably grow up to this value; that's how
// we save a few empty lines.
long nNextTop = pTxtFly->GetNextTop();
if ( pFrm->IsVertical() )
nNextTop = pFrm->SwitchVerticalToHorizontal( nNextTop );
......@@ -566,7 +561,7 @@ void SwTxtFormatter::CalcFlyWidth( SwTxtFormatInfo &rInf )
{
if( rInf.GetIdx() == rInf.GetTxt().Len() )
{
// Nicht nHeight nehmen, sonst haben wir einen Riesendescent
// Don't use nHeight, or we have a huge descent
pFly->Height( pLast->Height() );
pFly->SetAscent( pLast->GetAscent() );
}
......@@ -598,7 +593,7 @@ void SwTxtFormatter::CalcFlyWidth( SwTxtFormatInfo &rInf )
(pPageFrm->*fnRect->fnGetPrtLeft)();
const SwDoc *pDoc = rInf.GetTxtFrm()->GetNode()->GetDoc();
const sal_uInt16 nGridWidth = GETGRIDWIDTH( pGrid, pDoc); //for textgrid refactor
const sal_uInt16 nGridWidth = GETGRIDWIDTH( pGrid, pDoc); // For textgrid refactor
SwTwips nStartX = GetLeftMargin();
if ( bVert )
......@@ -624,7 +619,7 @@ void SwTxtFormatter::CalcFlyWidth( SwTxtFormatInfo &rInf )
/*****************************************************************************
* SwTxtFormatter::NewFlyCntPortion
* legt eine neue Portion fuer ein zeichengebundenes Objekt an.
* Creates a new portion for a character anchored object.
*****************************************************************************/
SwFlyCntPortion *SwTxtFormatter::NewFlyCntPortion( SwTxtFormatInfo &rInf,
......@@ -639,11 +634,9 @@ SwFlyCntPortion *SwTxtFormatter::NewFlyCntPortion( SwTxtFormatInfo &rInf,
pFly = ((SwTxtFlyCnt*)pHint)->GetFlyFrm(pFrame);
else
pFly = NULL;
// aBase bezeichnet die dokumentglobale Position,
// ab der die neue Extraportion plaziert wird.
// aBase.X() = Offset in der Zeile,
// hinter der aktuellen Portion
// aBase.Y() = LineIter.Y() + Ascent der aktuellen Portion
// aBase is the document-global position, from which the new extra portion is placed
// aBase.X() = Offset in in the line after the current position
// aBase.Y() = LineIter.Y() + Ascent of the current position
long nTmpAscent, nTmpDescent, nFlyAsc, nFlyDesc;
// OD 08.01.2004 #i11859# - use new method <SwLineLayout::MaxAscentDescent(..)>
......@@ -651,11 +644,10 @@ SwFlyCntPortion *SwTxtFormatter::NewFlyCntPortion( SwTxtFormatInfo &rInf,
//lcl_MaxAscDescent( pPos, nTmpAscent, nTmpDescent, nFlyAsc, nFlyDesc );
pCurr->MaxAscentDescent( nTmpAscent, nTmpDescent, nFlyAsc, nFlyDesc );
// Wenn der Ascent des Rahmens groesser als der Ascent der akt. Portion
// ist, wird dieser bei der Base-Berechnung verwendet, sonst wuerde
// der Rahmen zunaechst zu weit nach oben gesetzt, um dann doch wieder
// nach unten zu rutschen und dabei ein Repaint in einem Bereich ausloesen,
// indem er niemals wirklich war.
// If the ascent of the frame is larger than the ascent of the current position,
// we use this one when calculating the base, or the frame would be positioned
// too much to the top, sliding down after all causing a repaint in an area
// he actually never was in.
KSHORT nAscent = 0;
const bool bTxtFrmVertical = GetInfo().GetTxtFrm()->IsVertical();
......@@ -670,7 +662,7 @@ SwFlyCntPortion *SwTxtFormatter::NewFlyCntPortion( SwTxtFormatInfo &rInf,
pFly->GetRelPos().X() :
pFly->GetRelPos().Y() ) ) );
// check if be prefer to use the ascent of the last portion:
// Check if we prefer to use the ascent of the last portion:
if ( IsQuick() ||
!bUseFlyAscent ||
nAscent < rInf.GetLast()->GetAscent() )
......@@ -697,11 +689,11 @@ SwFlyCntPortion *SwTxtFormatter::NewFlyCntPortion( SwTxtFormatInfo &rInf,
{
pRet = new SwFlyCntPortion( *GetInfo().GetTxtFrm(), pFly, aTmpBase,
nTmpAscent, nTmpDescent, nFlyAsc, nFlyDesc, nMode );
// Wir muessen sicherstellen, dass unser Font wieder im OutputDevice
// steht. Es koennte sein, dass der FlyInCnt frisch eingefuegt wurde,
// dann hat GetFlyFrm dazu gefuehrt, dass er neu angelegt wird.
// Dessen Frames werden sofort formatiert, die verstellen den Font
// und schon haben wir den Salat (3322).
// We need to make sure that our font is set again in the OutputDevice
// It could be that the FlyInCnt was added anew and GetFlyFrm() would
// in turn cause, that it'd be created anew again.
// This one's frames get formatted right away, which change the font and
// we have a bug (3322).
rInf.SelectFont();
if( pRet->GetAscent() > nAscent )
{
......@@ -770,11 +762,11 @@ void SwTxtFly::CtorInitTxtFly( const SwTxtFrm *pFrm )
pMaster = pCurrFrm->IsFollow() ? NULL : pCurrFrm;
// #i68520#
mpAnchoredObjList = NULL;
// Wenn wir nicht von einem Frame ueberlappt werden, oder wenn
// es gar keine FlyCollection gibt, dann schaltet wir uns fuer immer ab.
// Aber es koennte sein, dass waehrend der Formatierung eine Zeile
// hinzukommt, die in einen Frame hineinragt. Deswegen keine Optimierung
// per bOn = pSortedFlys && IsAnyFrm();
// If we're not overlapped by a frame or if a FlyCollection does not exist
// at all, we switch off forever.
// It could be, however, that a line is added while formatting, that
// extends into a frame.
// That's why we do not optimize for: bOn = pSortedFlys && IsAnyFrm();
bOn = pPage->GetSortedObjs() != 0;
bTopRule = sal_True;
bLeftSide = sal_False;
......@@ -785,11 +777,12 @@ void SwTxtFly::CtorInitTxtFly( const SwTxtFrm *pFrm )
/*************************************************************************
* SwTxtFly::_GetFrm()
*
* IN: dokumentglobal (rRect)
* OUT: framelokal (return-Wert)
* Diese Methode wird waehrend der Formatierung vom LineIter gerufen.
* 1. um die naechste FlyPortion vorzubereiten
* 2. um nach Aenderung der Zeilenhoehe neue Ueberlappungen festzustellen
* IN: document-global (rRect)
* OUT: frame-local (return value)
*
* This method is called during formatting of LineIter in order to:
* 1. prepare the next FlyPortion
* 2. remember new overlappings after changes to the line height
*************************************************************************/
SwRect SwTxtFly::_GetFrm( const SwRect &rRect, sal_Bool bTop ) const
......@@ -801,7 +794,7 @@ SwRect SwTxtFly::_GetFrm( const SwRect &rRect, sal_Bool bTop ) const
if( bTop )
(aRet.*fnRect->fnSetTop)( (rRect.*fnRect->fnGetTop)() );
// 8110: Bottom nicht immer anpassen.
// 8110: Do not always adapt the bottom
const SwTwips nRetBottom = (aRet.*fnRect->fnGetBottom)();
const SwTwips nRectBottom = (rRect.*fnRect->fnGetBottom)();
if ( (*fnRect->fnYDiff)( nRetBottom, nRectBottom ) > 0 ||
......@@ -814,10 +807,10 @@ SwRect SwTxtFly::_GetFrm( const SwRect &rRect, sal_Bool bTop ) const
/*************************************************************************
* SwTxtFly::IsAnyFrm()
*
* IN: dokumentglobal
* fuer die Printarea des aktuellen Frame
* IN: document-global
* for the print area of the current frame
*
* dient zum Abschalten des SwTxtFly, wenn keine Objekte ueberlappen (Relax)
* Is used to disable the SwTxtFly if no objects overlap (relax)
*
*************************************************************************/
......@@ -837,11 +830,11 @@ sal_Bool SwTxtFly::IsAnyFrm() const
/*************************************************************************
* SwTxtFly::IsAnyObj()
*
* IN: dokumentglobal
* OUT: sal_True Wenn ein Rahmen oder DrawObj beruecksichtigt werden muss
* Nur wenn IsAnyObj sal_False liefert, koennen Optimierungen benutzt werden
* wie Paint/FormatEmpty fuer leere Absaetze
* und auch das virtuelle Outputdevice.
* IN: document-global
* OUT: sal_True If a frame or DrawObj needs to be respected
*
* Only if this method returns sal_False, we can use optimizations like
* Paint/FormatEmpty for empty paragraphs and also the virtual OutputDevice.
*************************************************************************/
sal_Bool SwTxtFly::IsAnyObj( const SwRect &rRect ) const
......@@ -854,8 +847,8 @@ sal_Bool SwTxtFly::IsAnyObj( const SwRect &rRect ) const
pCurrFrm->Prt().SSize() );
const SwSortedObjs *pSorted = pPage->GetSortedObjs();
if( pSorted ) // Eigentlich ist durch bOn sichergestellt, dass es an der
// Seite Objekte gibt, aber wer weiss, wer inzwischen etwas geloescht hat.
if( pSorted ) // bOn actually makes sure that we have objects on the side,
// but who knows who deleted somehting in the meantime?
{
for ( MSHORT i = 0; i < pSorted->Count(); ++i )
{
......@@ -863,7 +856,7 @@ sal_Bool SwTxtFly::IsAnyObj( const SwRect &rRect ) const
const SwRect aBound( pObj->GetObjRectWithSpaces() );
// Optimierung
// Optimization
if( pObj->GetObjRect().Left() > aRect.Right() )
continue;
......@@ -886,12 +879,13 @@ const SwCntntFrm* SwTxtFly::_GetMaster()
/*************************************************************************
* SwTxtFly::DrawTextOpaque()
*
* IN: dokumentglobal
* DrawTextOpaque() wird von DrawText() gerufen.
* Die Clipregions werden so gesetzt, dass nur die Teile ausgegeben werden,
* die nicht in den Bereichen von FlyFrms liegen, die undurchsichtig und
* ueber dem aktuellen Frame liegen.
* Die On-Optimierung uebernimmt DrawText()!
* IN: document-global
*
* DrawTextOpaque() is called by DrawText().
* The ClipRegions are placed int a way, that only those parts are displayed
* which are not within the areas of FlyFrms which are opaque and above the
* current Frame.
* DrawText() takes over the on optimization!
*************************************************************************/
sal_Bool SwTxtFly::DrawTextOpaque( SwDrawTextInfo &rInf )
......@@ -952,7 +946,7 @@ sal_Bool SwTxtFly::DrawTextOpaque( SwDrawTextInfo &rInf )
const SwFrmFmt *pFmt = pFly->GetFmt();
const SwFmtSurround &rSur = pFmt->GetSurround();
const SwFmtAnchor& rAnchor = pFmt->GetAnchor();
//Nur undurchsichtige und weiter oben liegende.
// Only the ones who are opaque and more to the top
if( !( pFly->IsBackgroundTransparent()
|| pFly->IsShadowTransparent() ) &&
SURROUND_THROUGHT == rSur.GetSurround() &&
......@@ -968,7 +962,7 @@ sal_Bool SwTxtFly::DrawTextOpaque( SwDrawTextInfo &rInf )
nCurrOrd < pTmpAnchoredObj->GetDrawObj()->GetOrdNum()
)
{
//Ausser der Inhalt ist Transparent
// Except for the content is transparent
const SwNoTxtFrm *pNoTxt =
pFly->Lower() && pFly->Lower()->IsNoTxtFrm()
? (SwNoTxtFrm*)pFly->Lower()
......@@ -1000,7 +994,7 @@ sal_Bool SwTxtFly::DrawTextOpaque( SwDrawTextInfo &rInf )
}
else if( aRegion.Count() )
{
// Was fuer ein Aufwand ...
// What a huge effort ...
SwSaveClip aClipVout( rInf.GetpOut() );
for( MSHORT i = 0; i < aRegion.Count(); ++i )
{
......@@ -1020,10 +1014,10 @@ sal_Bool SwTxtFly::DrawTextOpaque( SwDrawTextInfo &rInf )
/*************************************************************************
* SwTxtFly::DrawFlyRect()
*
* IN: windowlokal
* Zwei Feinheiten gilt es zu beachten:
* 1) DrawRect() oberhalb des ClipRects sind erlaubt !
* 2) FlyToRect() liefert groessere Werte als die Framedaten !
* IN: window-local
* We need to keep two subtelties in mind:
* 1) DrawRect() above the ClipRect are allowed!
* 2) FlyToRect() returns larger values than the frame data!
*************************************************************************/
void SwTxtFly::DrawFlyRect( OutputDevice* pOut, const SwRect &rRect,
......@@ -1151,7 +1145,7 @@ sal_Bool SwTxtFly::GetTop( const SwAnchoredObject* _pAnchoredObj,
bEvade = sal_True;
else
{
// innerhalb von verketteten Flys wird nur Lowern ausgewichen
// Within chained Flys we only avoid Lower
// #i68520#
const SwFmtChain &rChain = mpCurrAnchoredObj->GetFrmFmt().GetChain();
if ( !rChain.GetPrev() && !rChain.GetNext() )
......@@ -1180,11 +1174,11 @@ sal_Bool SwTxtFly::GetTop( const SwAnchoredObject* _pAnchoredObj,
return sal_False;
}
else if (FLY_AT_PAGE == rCurrA.GetAnchorId())
return sal_False; // Seitengebundene weichen nur seitengeb. aus
return sal_False; // Page anchored ones only avoid page anchored ones
else if (FLY_AT_FLY == rNewA.GetAnchorId())
bEvade = sal_True; // Nicht seitengeb. weichen Rahmengeb. aus
bEvade = sal_True; // Non-page anchored ones avoid frame anchored ones
else if( FLY_AT_FLY == rCurrA.GetAnchorId() )
return sal_False; // Rahmengebundene weichen abs.geb. nicht aus
return sal_False; // Frame anchored ones do not avoid paragraph anchored ones
// #i57062#
// In order to avoid loop situation, it's decided to adjust
// the wrapping behaviour of content of at-paragraph/at-character
......@@ -1196,9 +1190,7 @@ sal_Bool SwTxtFly::GetTop( const SwAnchoredObject* _pAnchoredObj,
}
}
// aber: es wird niemals einem hierarchisch untergeordnetem
// ausgewichen und ausserdem braucht nur bei Ueberlappung
// ausgewichen werden.
// But: we never avoid a subordinate one and additionally we only avoid when overlapping.
// #i68520#
bEvade &= ( mpCurrAnchoredObj->GetDrawObj()->GetOrdNum() < pNew->GetOrdNum() );
if( bEvade )
......@@ -1217,7 +1209,7 @@ sal_Bool SwTxtFly::GetTop( const SwAnchoredObject* _pAnchoredObj,
OSL_ENSURE( FLY_AS_CHAR != rNewA.GetAnchorId(),
"Don't call GetTop with a FlyInCntFrm" );
if (FLY_AT_PAGE == rNewA.GetAnchorId())
return sal_True; // Seitengebundenen wird immer ausgewichen.
return sal_True; // We always avoid page anchored ones
// Wenn absatzgebundene Flys in einem FlyCnt gefangen sind, so
// endet deren Einflussbereich an den Grenzen des FlyCnt!
......@@ -2171,7 +2163,7 @@ SwSurround SwTxtFly::_GetSurroundForTextWrap( const SwAnchoredObject* pAnchoredO
/*************************************************************************
* SwTxtFly::IsAnyFrm( SwRect )
*
* IN: dokumentglobal
* IN: document-global
*
* dient zum Abschalten des SwTxtFly, wenn keine Objekte ueberlappen (Relax)
*
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment