xref: /AOO41X/main/sw/source/core/text/itradj.cxx (revision efeef26f81c84063fb0a91bde3856d4a51172d90)

/**************************************************************
 *
 * 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"
#ifndef _COM_SUN_STAR_I18N_SCRIPTTYPE_HDL_
#include <com/sun/star/i18n/ScriptType.hdl>
#endif
#include <vcl/outdev.hxx>
#include <IDocumentSettingAccess.hxx>

#include "frame.hxx"       // CalcFlyAdjust()
#include "paratr.hxx"
#include "txtcfg.hxx"
#include "itrtxt.hxx"
#include "porglue.hxx"
#include "porlay.hxx"
#include "porfly.hxx"       // CalcFlyAdjust()
#include "pordrop.hxx"       // CalcFlyAdjust()
#include "pormulti.hxx"
#include <portab.hxx>

#define MIN_TAB_WIDTH 60

using namespace ::com::sun::star;

/*************************************************************************
 *                    SwTxtAdjuster::FormatBlock()
 *************************************************************************/

void SwTxtAdjuster::FormatBlock( )
{
	// In der letzten Zeile gibt's keinen Blocksatz.
	// Und bei Tabulatoren aus Tradition auch nicht.
	// 7701: wenn Flys im Spiel sind, geht's weiter

	const SwLinePortion *pFly = 0;

	sal_Bool bSkip = !IsLastBlock() &&
		nStart + pCurr->GetLen() >= GetInfo().GetTxt().Len();

	// ????: mehrzeilige Felder sind fies: wir muessen kontrollieren,
	// ob es noch andere Textportions im Absatz gibt.
	if( bSkip )
	{
		const SwLineLayout *pLay = pCurr->GetNext();
		while( pLay && !pLay->GetLen() )
		{
			const SwLinePortion *pPor = pCurr->GetFirstPortion();
			while( pPor && bSkip )
			{
				if( pPor->InTxtGrp() )
					bSkip = sal_False;
				pPor = pPor->GetPortion();
			}
			pLay = bSkip ? pLay->GetNext() : 0;
		}
	}

	if( bSkip )
	{
		if( !GetInfo().GetParaPortion()->HasFly() )
		{
			if( IsLastCenter() )
				CalcFlyAdjust( pCurr );
			pCurr->FinishSpaceAdd();
			return;
		}
		else
		{
			const SwLinePortion *pTmpFly = NULL;

			// 7701: beim letzten Fly soll Schluss sein
			const SwLinePortion *pPos = pCurr->GetFirstPortion();
			while( pPos )
			{
				// Ich suche jetzt den letzten Fly, hinter dem noch Text ist:
				if( pPos->IsFlyPortion() )
					pTmpFly = pPos; // Ein Fly wurde gefunden
				else if ( pTmpFly && pPos->InTxtGrp() )
				{
					pFly = pTmpFly; // Ein Fly mit nachfolgendem Text!
					pTmpFly = NULL;
				}
				pPos = pPos->GetPortion();
			}
			// 8494: Wenn keiner gefunden wurde, ist sofort Schluss!
			if( !pFly )
			{
				if( IsLastCenter() )
					CalcFlyAdjust( pCurr );
				pCurr->FinishSpaceAdd();
				return;
			}
		}
	}

	const xub_StrLen nOldIdx = GetInfo().GetIdx();
	GetInfo().SetIdx( nStart );
	CalcNewBlock( pCurr, pFly );
	GetInfo().SetIdx( nOldIdx );
	GetInfo().GetParaPortion()->GetRepaint()->SetOfst(0);
}

/*************************************************************************
 *                    lcl_CheckKashidaPositions()
 *************************************************************************/
bool lcl_CheckKashidaPositions( SwScriptInfo& rSI, SwTxtSizeInfo& rInf, SwTxtIter& rItr,
                                xub_StrLen& nKashidas, xub_StrLen& nGluePortion )
{
    // i60594 validate Kashida justification
    xub_StrLen nIdx = rItr.GetStart();
    xub_StrLen nEnd = rItr.GetEnd();

    // Note on calling KashidaJustify():
    // Kashida positions may be marked as invalid. Therefore KashidaJustify may return the clean
    // total number of kashida positions, or the number of kashida positions after some positions
    // have been dropped.
    // Here we want the clean total, which is OK: We have called ClearKashidaInvalid() before.
    nKashidas = rSI.KashidaJustify ( 0, 0, rItr.GetStart(), rItr.GetLength(), 0 );

    if (!nKashidas) // nothing to do
        return true;

    // kashida positions found in SwScriptInfo are not necessarily valid in every font
    // if two characters are replaced by a ligature glyph, there will be no place for a kashida
    xub_StrLen* pKashidaPos = new xub_StrLen [ nKashidas ];
    xub_StrLen* pKashidaPosDropped = new xub_StrLen [ nKashidas ];
    rSI.GetKashidaPositions ( nIdx, rItr.GetLength(), pKashidaPos );
    xub_StrLen nKashidaIdx = 0;
    while ( nKashidas && nIdx < nEnd )
    {
        rItr.SeekAndChgAttrIter( nIdx, rInf.GetOut() );
        xub_StrLen nNext = rItr.GetNextAttr();

        // is there also a script change before?
        // if there is, nNext should point to the script change
        xub_StrLen nNextScript = rSI.NextScriptChg( nIdx );
        if( nNextScript < nNext )
            nNext = nNextScript;

        if ( nNext == STRING_LEN || nNext > nEnd )
            nNext = nEnd;
        xub_StrLen nKashidasInAttr = rSI.KashidaJustify ( 0, 0, nIdx, nNext - nIdx );
        if ( nKashidasInAttr )
        {
            xub_StrLen nKashidasDropped = 0;
            if ( !SwScriptInfo::IsArabicText( rInf.GetTxt(), nIdx, nNext - nIdx ) )
            {
                nKashidasDropped = nKashidasInAttr;
                nKashidas -= nKashidasDropped;
            }
            else
            {
                sal_uLong nOldLayout = rInf.GetOut()->GetLayoutMode();
                rInf.GetOut()->SetLayoutMode ( nOldLayout | TEXT_LAYOUT_BIDI_RTL );
                nKashidasDropped = rInf.GetOut()->ValidateKashidas ( rInf.GetTxt(), nIdx, nNext - nIdx,
                                               nKashidasInAttr, pKashidaPos + nKashidaIdx,
                                               pKashidaPosDropped );
                rInf.GetOut()->SetLayoutMode ( nOldLayout );
                if ( nKashidasDropped )
                {
                    rSI.MarkKashidasInvalid ( nKashidasDropped, pKashidaPosDropped );
                    nKashidas -= nKashidasDropped;
                    nGluePortion -= nKashidasDropped;
                }
            }
            nKashidaIdx += nKashidasInAttr;
        }
        nIdx = nNext;
    }
    delete[] pKashidaPos;
    delete[] pKashidaPosDropped;

    // return false if all kashidas have been eliminated
    return (nKashidas > 0);
}

/*************************************************************************
 *                    lcl_CheckKashidaWidth()
 *************************************************************************/
bool lcl_CheckKashidaWidth ( SwScriptInfo& rSI, SwTxtSizeInfo& rInf, SwTxtIter& rItr, xub_StrLen& nKashidas,
                             xub_StrLen& nGluePortion, const long nGluePortionWidth, long& nSpaceAdd )
{
    // check kashida width
    // if width is smaller than minimal kashida width allowed by fonts in the current line
    // drop one kashida after the other until kashida width is OK
    bool bAddSpaceChanged;
    while ( nKashidas )
    {
        bAddSpaceChanged = false;
        xub_StrLen nIdx = rItr.GetStart();
        xub_StrLen nEnd = rItr.GetEnd();
        while ( nIdx < nEnd )
        {
            rItr.SeekAndChgAttrIter( nIdx, rInf.GetOut() );
            xub_StrLen nNext = rItr.GetNextAttr();

            // is there also a script change before?
            // if there is, nNext should point to the script change
            xub_StrLen nNextScript = rSI.NextScriptChg( nIdx );
            if( nNextScript < nNext )
               nNext = nNextScript;

            if ( nNext == STRING_LEN || nNext > nEnd )
                nNext = nEnd;
            xub_StrLen nKashidasInAttr = rSI.KashidaJustify ( 0, 0, nIdx, nNext - nIdx );

            long nFontMinKashida = rInf.GetOut()->GetMinKashida();
            if ( nFontMinKashida && nKashidasInAttr && SwScriptInfo::IsArabicText( rInf.GetTxt(), nIdx, nNext - nIdx ) )
            {
                xub_StrLen nKashidasDropped = 0;
                while ( nKashidas && nGluePortion && nKashidasInAttr &&
                        nSpaceAdd / SPACING_PRECISION_FACTOR < nFontMinKashida )
                {
                    --nGluePortion;
                    --nKashidas;
                    --nKashidasInAttr;
                    ++nKashidasDropped;
                    if( !nKashidas || !nGluePortion ) // nothing left, return false to
                        return false;                 // do regular blank justification

                    nSpaceAdd = nGluePortionWidth / nGluePortion;
                    bAddSpaceChanged = true;
               }
               if( nKashidasDropped )
                   rSI.MarkKashidasInvalid( nKashidasDropped, nIdx, nNext - nIdx );
            }
            if ( bAddSpaceChanged )
                break; // start all over again
            nIdx = nNext;
        }
        if ( !bAddSpaceChanged )
            break; // everything was OK
    }
   return true;
}

/*************************************************************************
 *                    SwTxtAdjuster::CalcNewBlock()
 *
 * CalcNewBlock() darf erst nach CalcLine() gerufen werden !
 * Aufgespannt wird immer zwischen zwei RandPortions oder FixPortions
 * (Tabs und Flys). Dabei werden die Glues gezaehlt und ExpandBlock gerufen.
 *************************************************************************/

void SwTxtAdjuster::CalcNewBlock( SwLineLayout *pCurrent,
                                  const SwLinePortion *pStopAt, SwTwips nReal, bool bSkipKashida )
{
	ASSERT( GetInfo().IsMulti() || SVX_ADJUST_BLOCK == GetAdjust(),
			"CalcNewBlock: Why?" );
    ASSERT( pCurrent->Height(), "SwTxtAdjuster::CalcBlockAdjust: missing CalcLine()" );

    pCurrent->InitSpaceAdd();
    xub_StrLen nGluePortion = 0;
	xub_StrLen nCharCnt = 0;
	MSHORT nSpaceIdx = 0;

    // i60591: hennerdrews
    SwScriptInfo& rSI = GetInfo().GetParaPortion()->GetScriptInfo();
    SwTxtSizeInfo aInf ( GetTxtFrm() );
    SwTxtIter aItr ( GetTxtFrm(), &aInf );

    if ( rSI.CountKashida() )
    {
        while (aItr.GetCurr() != pCurrent && aItr.GetNext())
           aItr.Next();

        if( bSkipKashida )
        {
            rSI.SetNoKashidaLine ( aItr.GetStart(), aItr.GetLength());
        }
        else
        {
            rSI.ClearKashidaInvalid ( aItr.GetStart(), aItr.GetLength() );
            rSI.ClearNoKashidaLine( aItr.GetStart(), aItr.GetLength() );
        }
    }

    // Nicht vergessen:
    // CalcRightMargin() setzt pCurrent->Width() auf die Zeilenbreite !
    if (!bSkipKashida)
        CalcRightMargin( pCurrent, nReal );

    // --> FME 2005-06-08 #i49277#
    const sal_Bool bDoNotJustifyLinesWithManualBreak =
                GetTxtFrm()->GetNode()->getIDocumentSettingAccess()->get(IDocumentSettingAccess::DO_NOT_JUSTIFY_LINES_WITH_MANUAL_BREAK);
    // <--

    SwLinePortion *pPos = pCurrent->GetPortion();

	while( pPos )
	{
        if ( bDoNotJustifyLinesWithManualBreak &&
             pPos->IsBreakPortion() && !IsLastBlock() )
        {
           pCurrent->FinishSpaceAdd();
           break;
        }

        if ( pPos->InTxtGrp() )
			nGluePortion = nGluePortion + ((SwTxtPortion*)pPos)->GetSpaceCnt( GetInfo(), nCharCnt );
		else if( pPos->IsMultiPortion() )
		{
			SwMultiPortion* pMulti = (SwMultiPortion*)pPos;
			// a multiportion with a tabulator inside breaks the text adjustment
			// a ruby portion will not be stretched by text adjustment
			// a double line portion takes additional space for each blank
			// in the wider line
			if( pMulti->HasTabulator() )
			{
                if ( nSpaceIdx == pCurrent->GetLLSpaceAddCount() )
                    pCurrent->SetLLSpaceAdd( 0, nSpaceIdx );

                nSpaceIdx++;
				nGluePortion = 0;
				nCharCnt = 0;
			}
			else if( pMulti->IsDouble() )
				nGluePortion = nGluePortion + ((SwDoubleLinePortion*)pMulti)->GetSpaceCnt();
            else if ( pMulti->IsBidi() )
                nGluePortion = nGluePortion + ((SwBidiPortion*)pMulti)->GetSpaceCnt( GetInfo() );  // i60594
        }

		if( pPos->InGlueGrp() )
		{
			if( pPos->InFixMargGrp() )
			{
                if ( nSpaceIdx == pCurrent->GetLLSpaceAddCount() )
                    pCurrent->SetLLSpaceAdd( 0, nSpaceIdx );

                const long nGluePortionWidth = static_cast<SwGluePortion*>(pPos)->GetPrtGlue() *
                                               SPACING_PRECISION_FACTOR;

                xub_StrLen nKashidas = 0;
                if( nGluePortion && rSI.CountKashida() && !bSkipKashida )
                {
                    // kashida positions found in SwScriptInfo are not necessarily valid in every font
                    // if two characters are replaced by a ligature glyph, there will be no place for a kashida
                    if ( !lcl_CheckKashidaPositions ( rSI, aInf, aItr, nKashidas, nGluePortion ))
                    {
                        // all kashida positions are invalid
                        // do regular blank justification
                        pCurrent->FinishSpaceAdd();
                        GetInfo().SetIdx( nStart );
                        CalcNewBlock( pCurrent, pStopAt, nReal, true );
                        return;
                    }
                }

				if( nGluePortion )
				{
                    long nSpaceAdd = nGluePortionWidth / nGluePortion;

                    // i60594
                    if( rSI.CountKashida() && !bSkipKashida )
                    {
                        if( !lcl_CheckKashidaWidth( rSI, aInf, aItr, nKashidas, nGluePortion, nGluePortionWidth, nSpaceAdd ))
                        {
                            // no kashidas left
                            // do regular blank justification
                            pCurrent->FinishSpaceAdd();
                            GetInfo().SetIdx( nStart );
                            CalcNewBlock( pCurrent, pStopAt, nReal, true );
                            return;
                        }
                    }

                    pCurrent->SetLLSpaceAdd( nSpaceAdd , nSpaceIdx );
                    pPos->Width( ( (SwGluePortion*)pPos )->GetFixWidth() );
				}
				else if ( IsOneBlock() && nCharCnt > 1 )
				{
                    const long nSpaceAdd = - nGluePortionWidth / ( nCharCnt - 1 );
                    pCurrent->SetLLSpaceAdd( nSpaceAdd, nSpaceIdx );
                    pPos->Width( ( (SwGluePortion*)pPos )->GetFixWidth() );
				}

                nSpaceIdx++;
				nGluePortion = 0;
				nCharCnt = 0;
			}
			else
				++nGluePortion;
		}
		GetInfo().SetIdx( GetInfo().GetIdx() + pPos->GetLen() );
		if ( pPos == pStopAt )
		{
            pCurrent->SetLLSpaceAdd( 0, nSpaceIdx );
            break;
		}
		pPos = pPos->GetPortion();
	}
}

/*************************************************************************
 *                    SwTxtAdjuster::CalcKanaAdj()
 *************************************************************************/

SwTwips SwTxtAdjuster::CalcKanaAdj( SwLineLayout* pCurrent )
{
    ASSERT( pCurrent->Height(), "SwTxtAdjuster::CalcBlockAdjust: missing CalcLine()" );
    ASSERT( !pCurrent->GetpKanaComp(), "pKanaComp already exists!!" );

    SvUShorts *pNewKana = new SvUShorts;
    pCurrent->SetKanaComp( pNewKana );

    const sal_uInt16 nNull = 0;
    MSHORT nKanaIdx = 0;
    long nKanaDiffSum = 0;
    SwTwips nRepaintOfst = 0;
    SwTwips nX = 0;
    sal_Bool bNoCompression = sal_False;

    // Nicht vergessen:
    // CalcRightMargin() setzt pCurrent->Width() auf die Zeilenbreite !
    CalcRightMargin( pCurrent, 0 );

    SwLinePortion* pPos = pCurrent->GetPortion();

    while( pPos )
    {
        if ( pPos->InTxtGrp() )
        {
            // get maximum portion width from info structure, calculated
            // during text formatting
            sal_uInt16 nMaxWidthDiff = GetInfo().GetMaxWidthDiff( (sal_uLong)pPos );

            // check, if information is stored under other key
            if ( !nMaxWidthDiff && pPos == pCurrent->GetFirstPortion() )
                nMaxWidthDiff = GetInfo().GetMaxWidthDiff( (sal_uLong)pCurrent );

            // calculate difference between portion width and max. width
            nKanaDiffSum += nMaxWidthDiff;

            // we store the beginning of the first compressable portion
            // for repaint
            if ( nMaxWidthDiff && !nRepaintOfst )
                nRepaintOfst = nX + GetLeftMargin();
        }
        else if( pPos->InGlueGrp() && pPos->InFixMargGrp() )
        {
            if ( nKanaIdx == pCurrent->GetKanaComp().Count() )
                pCurrent->GetKanaComp().Insert( nNull, nKanaIdx );

            sal_uInt16 nRest;

            if ( pPos->InTabGrp() )
            {
                nRest = ! bNoCompression &&
                        ( pPos->Width() > MIN_TAB_WIDTH ) ?
                        pPos->Width() - MIN_TAB_WIDTH :
                        0;

                // for simplifying the handling of left, right ... tabs,
                // we do expand portions, which are lying behind
                // those special tabs
                bNoCompression = !pPos->IsTabLeftPortion();
            }
            else
            {
                nRest = ! bNoCompression ?
                        ((SwGluePortion*)pPos)->GetPrtGlue() :
                        0;

                bNoCompression = sal_False;
            }

            if( nKanaDiffSum )
            {
                sal_uLong nCompress = ( 10000 * nRest ) / nKanaDiffSum;

                if ( nCompress >= 10000 )
                    // kanas can be expanded to 100%, and there is still
                    // some space remaining
                    nCompress = 0;

                else
                    nCompress = 10000 - nCompress;

                ( pCurrent->GetKanaComp() )[ nKanaIdx ] = (sal_uInt16)nCompress;
                nKanaDiffSum = 0;
            }

            nKanaIdx++;
        }

        nX += pPos->Width();
        pPos = pPos->GetPortion();
    }

    // set portion width
    nKanaIdx = 0;
    sal_uInt16 nCompress = ( pCurrent->GetKanaComp() )[ nKanaIdx ];
    pPos = pCurrent->GetPortion();
	long nDecompress = 0;
	nKanaDiffSum = 0;

    while( pPos )
    {
        if ( pPos->InTxtGrp() )
        {
            const sal_uInt16 nMinWidth = pPos->Width();

            // get maximum portion width from info structure, calculated
            // during text formatting
            sal_uInt16 nMaxWidthDiff = GetInfo().GetMaxWidthDiff( (sal_uLong)pPos );

            // check, if information is stored under other key
            if ( !nMaxWidthDiff && pPos == pCurrent->GetFirstPortion() )
                nMaxWidthDiff = GetInfo().GetMaxWidthDiff( (sal_uLong)pCurrent );
            nKanaDiffSum += nMaxWidthDiff;
            pPos->Width( nMinWidth +
                       ( ( 10000 - nCompress ) * nMaxWidthDiff ) / 10000 );
			nDecompress += pPos->Width() - nMinWidth;
        }
        else if( pPos->InGlueGrp() && pPos->InFixMargGrp() )
        {
            if( nCompress )
            {
				nKanaDiffSum *= nCompress;
				nKanaDiffSum /= 10000;
            }

            pPos->Width( static_cast<sal_uInt16>(pPos->Width() - nDecompress) );

            if ( pPos->InTabGrp() )
                // set fix width to width
                ((SwTabPortion*)pPos)->SetFixWidth( pPos->Width() );

            const SvUShorts& rKanaComp = pCurrent->GetKanaComp();
            if ( ++nKanaIdx < rKanaComp.Count() )
                nCompress = ( pCurrent->GetKanaComp() )[ nKanaIdx ];

			nKanaDiffSum = 0;
			nDecompress = 0;
        }
        pPos = pPos->GetPortion();
    }

    return nRepaintOfst;
}

/*************************************************************************
 *                    SwTxtAdjuster::CalcRightMargin()
 *************************************************************************/

SwMarginPortion *SwTxtAdjuster::CalcRightMargin( SwLineLayout *pCurrent,
	SwTwips nReal )
{
	long nRealWidth;
    const sal_uInt16 nRealHeight = GetLineHeight();
    const sal_uInt16 nLineHeight = pCurrent->Height();

    KSHORT nPrtWidth = pCurrent->PrtWidth();
    SwLinePortion *pLast = pCurrent->FindLastPortion();

	if( GetInfo().IsMulti() )
		nRealWidth = nReal;
	else
	{
		nRealWidth = GetLineWidth();
		// Fuer jeden FlyFrm, der in den rechten Rand hineinragt,
		// wird eine FlyPortion angelegt.
		const long nLeftMar = GetLeftMargin();
        SwRect aCurrRect( nLeftMar + nPrtWidth, Y() + nRealHeight - nLineHeight,
                          nRealWidth - nPrtWidth, nLineHeight );

		SwFlyPortion *pFly = CalcFlyPortion( nRealWidth, aCurrRect );
		while( pFly && long( nPrtWidth )< nRealWidth )
		{
			pLast->Append( pFly );
			pLast = pFly;
			if( pFly->Fix() > nPrtWidth )
				pFly->Width( ( pFly->Fix() - nPrtWidth) + pFly->Width() + 1);
			nPrtWidth += pFly->Width() + 1;
			aCurrRect.Left( nLeftMar + nPrtWidth );
			pFly = CalcFlyPortion( nRealWidth, aCurrRect );
		}
		if( pFly )
			delete pFly;
	}

	SwMarginPortion *pRight = new SwMarginPortion( 0 );
	pLast->Append( pRight );

	if( long( nPrtWidth )< nRealWidth )
		pRight->PrtWidth( KSHORT( nRealWidth - nPrtWidth ) );

    // pCurrent->Width() wird auf die reale Groesse gesetzt,
	// da jetzt die MarginPortions eingehaengt sind.
	// Dieser Trick hat wundersame Auswirkungen.
    // Wenn pCurrent->Width() == nRealWidth ist, dann wird das gesamte
	// Adjustment implizit ausgecontert. GetLeftMarginAdjust() und
	// IsBlocksatz() sind der Meinung, sie haetten eine mit Zeichen
	// gefuellte Zeile.

    pCurrent->PrtWidth( KSHORT( nRealWidth ) );
	return pRight;
}

/*************************************************************************
 *                    SwTxtAdjuster::CalcFlyAdjust()
 *************************************************************************/

void SwTxtAdjuster::CalcFlyAdjust( SwLineLayout *pCurrent )
{
	// 1) Es wird ein linker Rand eingefuegt:
    SwMarginPortion *pLeft = pCurrent->CalcLeftMargin();
	SwGluePortion *pGlue = pLeft;       // die letzte GluePortion


	// 2) Es wird ein rechter Rand angehaengt:
	// CalcRightMargin berechnet auch eventuelle Ueberlappungen mit
	// FlyFrms.
    CalcRightMargin( pCurrent );

	SwLinePortion *pPos = pLeft->GetPortion();
	xub_StrLen nLen = 0;

	// Wenn wir nur eine Zeile vorliegen haben und die Textportion zusammen
	// haengend ist und wenn zentriert wird, dann ...

	sal_Bool bComplete = 0 == nStart;
    const sal_Bool bTabCompat = GetTxtFrm()->GetNode()->getIDocumentSettingAccess()->get(IDocumentSettingAccess::TAB_COMPAT);
    sal_Bool bMultiTab = sal_False;

	while( pPos )
	{
        if ( pPos->IsMultiPortion() && ((SwMultiPortion*)pPos)->HasTabulator() )
            bMultiTab = sal_True;
        else if( pPos->InFixMargGrp() &&
               ( bTabCompat ? ! pPos->InTabGrp() : ! bMultiTab ) )
        {
            // in tab compat mode we do not want to change tab portions
            // in non tab compat mode we do not want to change margins if we
            // found a multi portion with tabs
            if( SVX_ADJUST_RIGHT == GetAdjust() )
                ((SwGluePortion*)pPos)->MoveAllGlue( pGlue );
            else
            {
                // Eine schlaue Idee von MA:
                // Fuer die erste Textportion wird rechtsbuendig eingestellt,
                // fuer die letzte linksbuendig.

                // Die erste Textportion kriegt den ganzen Glue
                // Aber nur, wenn wir mehr als eine Zeile besitzen.
                if( bComplete && GetInfo().GetTxt().Len() == nLen )
                    ((SwGluePortion*)pPos)->MoveHalfGlue( pGlue );
                else
                {
                    if ( ! bTabCompat )
                    {
                        if( pLeft == pGlue )
                        {
                            // Wenn es nur einen linken und rechten Rand gibt,
                            // dann teilen sich die Raender den Glue.
                            if( nLen + pPos->GetLen() >= pCurrent->GetLen() )
                                ((SwGluePortion*)pPos)->MoveHalfGlue( pGlue );
                            else
                                ((SwGluePortion*)pPos)->MoveAllGlue( pGlue );
                        }
                        else
                        {
                            // Die letzte Textportion behaelt sein Glue
                         if( !pPos->IsMarginPortion() )
                              ((SwGluePortion*)pPos)->MoveHalfGlue( pGlue );
                         }
                     }
                     else
                        ((SwGluePortion*)pPos)->MoveHalfGlue( pGlue );
                }
            }

            pGlue = (SwFlyPortion*)pPos;
            bComplete = sal_False;
        }
		nLen = nLen + pPos->GetLen();
		pPos = pPos->GetPortion();
     }

     if( ! bTabCompat && ! bMultiTab && SVX_ADJUST_RIGHT == GetAdjust() )
        // portions are moved to the right if possible
        pLeft->AdjustRight( pCurrent );
}

/*************************************************************************
 *                  SwTxtAdjuster::CalcAdjLine()
 *************************************************************************/

void SwTxtAdjuster::CalcAdjLine( SwLineLayout *pCurrent )
{
    ASSERT( pCurrent->IsFormatAdj(), "CalcAdjLine: Why?" );

    pCurrent->SetFormatAdj(sal_False);

    SwParaPortion* pPara = GetInfo().GetParaPortion();

    switch( GetAdjust() )
	{
		case SVX_ADJUST_RIGHT:
		case SVX_ADJUST_CENTER:
		{
            CalcFlyAdjust( pCurrent );
            pPara->GetRepaint()->SetOfst( 0 );
			break;
		}
		case SVX_ADJUST_BLOCK:
		{
            // disabled for #i13507#
            // 8311: In Zeilen mit LineBreaks gibt es keinen Blocksatz!
/*          if( pCurrent->GetLen() &&
                CH_BREAK == GetInfo().GetChar( nStart + pCurrent->GetLen() - 1 ) &&
				!IsLastBlock() )
			{
				if( IsLastCenter() )
				{
                    CalcFlyAdjust( pCurrent );
                    pPara->GetRepaint()->SetOfst( 0 );
					break;
				}
				return;
			}
*/          FormatBlock();
			break;
		}
		default : return;
	}
}

/*************************************************************************
 *                    SwTxtAdjuster::CalcFlyPortion()
 *
 * Die Berechnung hat es in sich: nCurrWidth geibt die Breite _vor_ dem
 * aufaddieren des Wortes das noch auf die Zeile passt! Aus diesem Grund
 * stimmt die Breite der FlyPortion auch, wenn die Blockierungssituation
 * bFirstWord && !WORDFITS eintritt.
 *************************************************************************/

SwFlyPortion *SwTxtAdjuster::CalcFlyPortion( const long nRealWidth,
											 const SwRect &rCurrRect )
{
    SwTxtFly aTxtFly( GetTxtFrm() );

	const KSHORT nCurrWidth = pCurr->PrtWidth();
	SwFlyPortion *pFlyPortion = 0;

    SwRect aLineVert( rCurrRect );
    if ( GetTxtFrm()->IsRightToLeft() )
        GetTxtFrm()->SwitchLTRtoRTL( aLineVert );
    if ( GetTxtFrm()->IsVertical() )
        GetTxtFrm()->SwitchHorizontalToVertical( aLineVert );

    // aFlyRect ist dokumentglobal !
    SwRect aFlyRect( aTxtFly.GetFrm( aLineVert ) );

    if ( GetTxtFrm()->IsRightToLeft() )
        GetTxtFrm()->SwitchRTLtoLTR( aFlyRect );
    if ( GetTxtFrm()->IsVertical() )
        GetTxtFrm()->SwitchVerticalToHorizontal( aFlyRect );

	// Wenn ein Frame ueberlappt, wird eine Portion eroeffnet.
	if( aFlyRect.HasArea() )
	{
		// aLocal ist framelokal
		SwRect aLocal( aFlyRect );
		aLocal.Pos( aLocal.Left() - GetLeftMargin(), aLocal.Top() );
        if( nCurrWidth > aLocal.Left() )
			aLocal.Left( nCurrWidth );

		// Wenn das Rechteck breiter als die Zeile ist, stutzen
		// wir es ebenfalls zurecht.
		KSHORT nLocalWidth = KSHORT( aLocal.Left() + aLocal.Width() );
		if( nRealWidth < long( nLocalWidth ) )
			aLocal.Width( nRealWidth - aLocal.Left() );
		GetInfo().GetParaPortion()->SetFly( sal_True );
		pFlyPortion = new SwFlyPortion( aLocal );
		pFlyPortion->Height( KSHORT( rCurrRect.Height() ) );
		// Die Width koennte kleiner sein als die FixWidth, daher:
		pFlyPortion->AdjFixWidth();
	}
	return pFlyPortion;
}

/*************************************************************************
 *                SwTxtPainter::_CalcDropAdjust()
 *************************************************************************/

// 6721: Drops und Adjustment
// CalcDropAdjust wird ggf. am Ende von Format() gerufen.

void SwTxtAdjuster::CalcDropAdjust()
{
	ASSERT( 1<GetDropLines() && SVX_ADJUST_LEFT!=GetAdjust() && SVX_ADJUST_BLOCK!=GetAdjust(),
			"CalcDropAdjust: No reason for DropAdjustment." )

    const MSHORT nLineNumber = GetLineNr();

	// 1) Dummies ueberspringen
	Top();

	if( !pCurr->IsDummy() || NextLine() )
	{
		// Erst adjustieren.
		GetAdjusted();

		SwLinePortion *pPor = pCurr->GetFirstPortion();

		// 2) Sicherstellen, dass die DropPortion dabei ist.
		// 3) pLeft: Die GluePor vor der DropPor
		if( pPor->InGlueGrp() && pPor->GetPortion()
			  && pPor->GetPortion()->IsDropPortion() )
		{
			const SwLinePortion *pDropPor = (SwDropPortion*) pPor->GetPortion();
			SwGluePortion *pLeft = (SwGluePortion*) pPor;

			// 4) pRight: Die GluePor hinter der DropPor suchen
			pPor = pPor->GetPortion();
			while( pPor && !pPor->InFixMargGrp() )
				pPor = pPor->GetPortion();

			SwGluePortion *pRight = ( pPor && pPor->InGlueGrp() ) ?
									(SwGluePortion*) pPor : 0;
			if( pRight && pRight != pLeft )
			{
				// 5) nMinLeft berechnen. Wer steht am weitesten links?
				const KSHORT nDropLineStart =
					KSHORT(GetLineStart()) + pLeft->Width() + pDropPor->Width();
				KSHORT nMinLeft = nDropLineStart;
				for( MSHORT i = 1; i < GetDropLines(); ++i )
				{
					if( NextLine() )
					{
						// Erst adjustieren.
						GetAdjusted();

						pPor = pCurr->GetFirstPortion();
						const SwMarginPortion *pMar = pPor->IsMarginPortion() ?
													  (SwMarginPortion*)pPor : 0;
						if( !pMar )
							nMinLeft = 0;
						else
						{
							const KSHORT nLineStart =
								KSHORT(GetLineStart()) + pMar->Width();
							if( nMinLeft > nLineStart )
								nMinLeft = nLineStart;
						}
					}
				}

				// 6) Den Glue zwischen pLeft und pRight neu verteilen.
				if( nMinLeft < nDropLineStart )
				{
					// Glue wird immer von pLeft nach pRight abgegeben,
					// damit der Text nach links wandert.
					const short nGlue = nDropLineStart - nMinLeft;
					if( !nMinLeft )
						pLeft->MoveAllGlue( pRight );
					else
						pLeft->MoveGlue( pRight, nGlue );
#ifdef DBGTXT
					aDbstream << "Drop adjusted: " << nGlue << endl;
#endif
				}
			}
		}
	}

    if( nLineNumber != GetLineNr() )
	{
		Top();
        while( nLineNumber != GetLineNr() && Next() )
			;
	}
}

/*************************************************************************
 *                SwTxtAdjuster::CalcDropRepaint()
 *************************************************************************/

void SwTxtAdjuster::CalcDropRepaint()
{
	Top();
	SwRepaint &rRepaint = *GetInfo().GetParaPortion()->GetRepaint();
	if( rRepaint.Top() > Y() )
		rRepaint.Top( Y() );
	for( MSHORT i = 1; i < GetDropLines(); ++i )
		NextLine();
	const SwTwips nBottom = Y() + GetLineHeight() - 1;
	if( rRepaint.Bottom() < nBottom )
		rRepaint.Bottom( nBottom );
}