core/text/pormulti.cxx

/**************************************************************
 *
 * 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 <hintids.hxx>

#include <com/sun/star/i18n/ScriptType.hdl>
#include <editeng/twolinesitem.hxx>
#include <editeng/charrotateitem.hxx>
#include <vcl/outdev.hxx>
#include <fmtfld.hxx>
#include <fldbas.hxx>	// SwField
#include <txatbase.hxx>
#include <fmtruby.hxx>	// SwFmtRuby
#include <txtatr.hxx>	// SwTxtRuby
#include <charfmt.hxx>
#include <txtinet.hxx>
#include <fchrfmt.hxx>
#include <layfrm.hxx>		// GetUpper()
#include <SwPortionHandler.hxx>
#include <pormulti.hxx> 	// SwMultiPortion
#include <inftxt.hxx>		// SwTxtSizeInfo
#include <itrpaint.hxx>		// SwTxtPainter
#include <viewopt.hxx>		// SwViewOptions
#include <itrform2.hxx>		// SwTxtFormatter
#include <porfld.hxx>		// SwFldPortion
#include <porglue.hxx>
#include <breakit.hxx>
#include <pagefrm.hxx>
#include <rowfrm.hxx>
#include <pagedesc.hxx>	// SwPageDesc
#include <tgrditem.hxx>
#include <swtable.hxx>
#include <fmtfsize.hxx>

using namespace ::com::sun::star;
extern sal_Bool IsUnderlineBreak( const SwLinePortion& rPor, const SwFont& rFnt );

/*-----------------10.10.00 15:23-------------------
 * class SwMultiPortion
 *
 * A SwMultiPortion is not a simple portion,
 * it's a container, which contains almost a SwLineLayoutPortion.
 * This SwLineLayout could be followed by other textportions via pPortion
 * and by another SwLineLayout via pNext to realize a doubleline portion.
 * --------------------------------------------------*/

SwMultiPortion::~SwMultiPortion()
{
	delete pFldRest;
}

void SwMultiPortion::Paint( const SwTxtPaintInfo & ) const
{
	ASSERT( sal_False,
	"Don't try SwMultiPortion::Paint, try SwTxtPainter::PaintMultiPortion" );
}

/*-----------------13.10.00 16:21-------------------
 * Summarize the internal lines to calculate the (external) size.
 * The internal line has to calculate first.
 * --------------------------------------------------*/

void SwMultiPortion::CalcSize( SwTxtFormatter& rLine, SwTxtFormatInfo &rInf )
{
	Width( 0 );
	Height( 0 );
	SetAscent( 0 );
	SetFlyInCntnt( sal_False );
	SwLineLayout *pLay = &GetRoot();
	do
	{
		pLay->CalcLine( rLine, rInf );
		if( rLine.IsFlyInCntBase() )
			SetFlyInCntnt( sal_True );
		if( IsRuby() && ( OnTop() == ( pLay == &GetRoot() ) ) )
		{
			// An empty phonetic line doesn't need an ascent or a height.
			if( !pLay->Width() )
			{
				pLay->SetAscent( 0 );
				pLay->Height( 0 );
			}
			if( OnTop() )
				SetAscent( GetAscent() + pLay->Height() );
		}
		else
			SetAscent( GetAscent() + pLay->GetAscent() );
		Height( Height() + pLay->Height() );
		if( Width() < pLay->Width() )
			Width( pLay->Width() );
		pLay = pLay->GetNext();
	} while ( pLay );
	if( HasBrackets() )
	{
		KSHORT nTmp = ((SwDoubleLinePortion*)this)->GetBrackets()->nHeight;
		if( nTmp > Height() )
		{
			KSHORT nAdd = ( nTmp - Height() ) / 2;
			GetRoot().SetAscent( GetRoot().GetAscent() + nAdd );
			GetRoot().Height( GetRoot().Height() + nAdd );
			Height( nTmp );
		}
		nTmp = ((SwDoubleLinePortion*)this)->GetBrackets()->nAscent;
		if( nTmp > GetAscent() )
			SetAscent( nTmp );
	}
}

long SwMultiPortion::CalcSpacing( long , const SwTxtSizeInfo & ) const
{
	return 0;
}

sal_Bool SwMultiPortion::ChgSpaceAdd( SwLineLayout*, long ) const
{
	return sal_False;
}

/*************************************************************************
 * virtual SwMultiPortion::HandlePortion()
 *************************************************************************/

void SwMultiPortion::HandlePortion( SwPortionHandler& rPH ) const
{
	rPH.Text( GetLen(), GetWhichPor() );
}

/*-----------------01.11.00 14:21-------------------
 * SwMultiPortion::ActualizeTabulator()
 * sets the tabulator-flag, if there's any tabulator-portion inside.
 * --------------------------------------------------*/

void SwMultiPortion::ActualizeTabulator()
{
	SwLinePortion* pPor = GetRoot().GetFirstPortion();
	// First line
	for( bTab1 = bTab2 = sal_False; pPor; pPor = pPor->GetPortion() )
		if( pPor->InTabGrp() )
			SetTab1( sal_True );
	if( GetRoot().GetNext() )
	{
		// Second line
		pPor = GetRoot().GetNext()->GetFirstPortion();
		do
		{
			if( pPor->InTabGrp() )
				SetTab2( sal_True );
			pPor = pPor->GetPortion();
		} while ( pPor );
	}
}

/*-----------------16.02.01 12:07-------------------
 * SwRotatedPortion::SwRotatedPortion(..)
 * --------------------------------------------------*/

SwRotatedPortion::SwRotatedPortion( const SwMultiCreator& rCreate,
	xub_StrLen nEnd, sal_Bool bRTL ) : SwMultiPortion( nEnd )
{
	const SvxCharRotateItem* pRot = (SvxCharRotateItem*)rCreate.pItem;
	if( !pRot )
	{
		const SwTxtAttr& rAttr = *rCreate.pAttr;
		const SfxPoolItem *const pItem =
				CharFmt::GetItem(rAttr, RES_CHRATR_ROTATE);
		if ( pItem )
		{
			pRot = static_cast<const SvxCharRotateItem*>(pItem);
		}
	}
	if( pRot )
	{
		sal_uInt8 nDir;
		if ( bRTL )
			nDir = pRot->IsBottomToTop() ? 3 : 1;
		else
			nDir = pRot->IsBottomToTop() ? 1 : 3;

		SetDirection( nDir );
	}
}

/*---------------------------------------------------
 * SwBidiPortion::SwBidiPortion(..)
 * --------------------------------------------------*/

SwBidiPortion::SwBidiPortion( xub_StrLen nEnd, sal_uInt8 nLv )
	: SwMultiPortion( nEnd ), nLevel( nLv )
{
	SetBidi();

	if ( nLevel % 2 )
		SetDirection( DIR_RIGHT2LEFT );
	else
		SetDirection( DIR_LEFT2RIGHT );
}


long SwBidiPortion::CalcSpacing( long nSpaceAdd, const SwTxtSizeInfo& rInf ) const
{
	return HasTabulator() ? 0 : GetSpaceCnt(rInf) * nSpaceAdd / SPACING_PRECISION_FACTOR;
}

sal_Bool SwBidiPortion::ChgSpaceAdd( SwLineLayout* pCurr, long nSpaceAdd ) const
{
	sal_Bool bRet = sal_False;
	if( !HasTabulator() && nSpaceAdd > 0 && !pCurr->IsSpaceAdd() )
	{
		pCurr->CreateSpaceAdd();
		pCurr->SetLLSpaceAdd( nSpaceAdd, 0 );
		bRet = sal_True;
	}

	return bRet;
}

xub_StrLen SwBidiPortion::GetSpaceCnt( const SwTxtSizeInfo &rInf ) const
{
	// Calculate number of blanks for justified alignment
	SwLinePortion* pPor = GetRoot().GetFirstPortion();
	xub_StrLen nTmpStart = rInf.GetIdx();
	xub_StrLen nNull = 0;
	xub_StrLen nBlanks;

	for( nBlanks = 0; pPor; pPor = pPor->GetPortion() )
	{
		if( pPor->InTxtGrp() )
			nBlanks = nBlanks + ((SwTxtPortion*)pPor)->GetSpaceCnt( rInf, nNull );
		else if ( pPor->IsMultiPortion() &&
				  ((SwMultiPortion*)pPor)->IsBidi() )
			nBlanks = nBlanks + ((SwBidiPortion*)pPor)->GetSpaceCnt( rInf );

		((SwTxtSizeInfo &)rInf).SetIdx( rInf.GetIdx() + pPor->GetLen() );
	}
	((SwTxtSizeInfo &)rInf).SetIdx( nTmpStart );
	return nBlanks;
}

/*-----------------01.11.00 14:22-------------------
 * SwDoubleLinePortion::SwDoubleLinePortion(..)
 * This constructor is for the continuation of a doubleline portion
 * in the next line.
 * It takes the same brackets and if the original has no content except
 * brackets, these will be deleted.
 * --------------------------------------------------*/

SwDoubleLinePortion::SwDoubleLinePortion( SwDoubleLinePortion& rDouble,
										  xub_StrLen nEnd ) :
	SwMultiPortion( nEnd ),
	pBracket( 0 )
{
	SetDirection( rDouble.GetDirection() );
	SetDouble();
	if( rDouble.GetBrackets() )
	{
		SetBrackets( rDouble );
		// An empty multiportion needs no brackets.
		// Notice: GetLen() might be zero, if the multiportion contains
		// the second part of a field and the width might be zero, if
		// it contains a note only. In this cases the brackets are okay.
		// But if the length and the width are both zero, the portion
		// is really empty.
		if( rDouble.Width() ==	rDouble.BracketWidth() )
			rDouble.ClearBrackets();
	}
}

/*-----------------01.11.00 14:22-------------------
 * SwDoubleLinePortion::SwDoubleLinePortion(..)
 * This constructor uses the textattribut to get the right brackets.
 * The textattribut could be a 2-line-attribute or a character- or
 * internetstyle, which contains the 2-line-attribute.
 * --------------------------------------------------*/

SwDoubleLinePortion::SwDoubleLinePortion( const SwMultiCreator& rCreate,
	xub_StrLen nEnd ) : SwMultiPortion( nEnd ), pBracket( new SwBracket() )
{
	SetDouble();
	const SvxTwoLinesItem* pTwo = (SvxTwoLinesItem*)rCreate.pItem;
	if( pTwo )
		pBracket->nStart = 0;
	else
	{
		const SwTxtAttr& rAttr = *rCreate.pAttr;
		pBracket->nStart = *rAttr.GetStart();

		const SfxPoolItem * const pItem =
			CharFmt::GetItem( rAttr, RES_CHRATR_TWO_LINES );
		if ( pItem )
		{
			pTwo = static_cast<const SvxTwoLinesItem*>(pItem);
		}
	}
	if( pTwo )
	{
		pBracket->cPre = pTwo->GetStartBracket();
		pBracket->cPost = pTwo->GetEndBracket();
	}
	else
	{
		pBracket->cPre = 0;
		pBracket->cPost = 0;
	}
	sal_uInt8 nTmp = SW_SCRIPTS;
	if( pBracket->cPre > 255 )
	{
		String aTxt( pBracket->cPre );
		nTmp = SwScriptInfo::WhichFont( 0, &aTxt, 0 );
	}
	pBracket->nPreScript = nTmp;
	nTmp = SW_SCRIPTS;
	if( pBracket->cPost > 255 )
	{
		String aTxt( pBracket->cPost );
		nTmp = SwScriptInfo::WhichFont( 0, &aTxt, 0 );
	}
	pBracket->nPostScript = nTmp;

	if( !pBracket->cPre && !pBracket->cPost )
	{
		delete pBracket;
		pBracket = 0;
	}

	// double line portions have the same direction as the frame directions
	if ( rCreate.nLevel % 2 )
		SetDirection( DIR_RIGHT2LEFT );
	else
		SetDirection( DIR_LEFT2RIGHT );
}


/*-----------------25.10.00 09:51-------------------
 * SwMultiPortion::PaintBracket paints the wished bracket,
 * if the multiportion has surrounding brackets.
 * The X-position of the SwTxtPaintInfo will be modified:
 * the open bracket sets position behind itself,
 * the close bracket in front of itself.
 * --------------------------------------------------*/

void SwDoubleLinePortion::PaintBracket( SwTxtPaintInfo &rInf,
										long nSpaceAdd,
										sal_Bool bOpen ) const
{
	sal_Unicode cCh = bOpen ? pBracket->cPre : pBracket->cPost;
	if( !cCh )
		return;
	KSHORT nChWidth = bOpen ? PreWidth() : PostWidth();
	if( !nChWidth )
		return;
	if( !bOpen )
		rInf.X( rInf.X() + Width() - PostWidth() +
			( nSpaceAdd > 0 ? CalcSpacing( nSpaceAdd, rInf ) : 0 ) );

	SwBlankPortion aBlank( cCh, sal_True );
	aBlank.SetAscent( pBracket->nAscent );
	aBlank.Width( nChWidth );
	aBlank.Height( pBracket->nHeight );
	{
		SwFont* pTmpFnt = new SwFont( *rInf.GetFont() );
		sal_uInt8 nAct = bOpen ? pBracket->nPreScript : pBracket->nPostScript;
		if( SW_SCRIPTS > nAct )
			pTmpFnt->SetActual( nAct );
		pTmpFnt->SetProportion( 100 );
		SwFontSave aSave( rInf, pTmpFnt );
		aBlank.Paint( rInf );
		delete pTmpFnt;
	}
	if( bOpen )
		rInf.X( rInf.X() + PreWidth() );
}

/*-----------------25.10.00 16:26-------------------
 * SwDoubleLinePortion::SetBrackets creates the bracket-structure
 * and fills it, if not both characters are 0x00.
 * --------------------------------------------------*/

void SwDoubleLinePortion::SetBrackets( const SwDoubleLinePortion& rDouble )
{
	if( rDouble.pBracket )
	{
		pBracket = new SwBracket;
		pBracket->cPre = rDouble.pBracket->cPre;
		pBracket->cPost = rDouble.pBracket->cPost;
		pBracket->nPreScript = rDouble.pBracket->nPreScript;
		pBracket->nPostScript = rDouble.pBracket->nPostScript;
		pBracket->nStart = rDouble.pBracket->nStart;
	}
}

/*-----------------25.10.00 16:29-------------------
 * SwDoubleLinePortion::FormatBrackets
 * calculates the size of the brackets => pBracket,
 * reduces the nMaxWidth-parameter ( minus bracket-width )
 * and moves the rInf-x-position behind the opening bracket.
 * --------------------------------------------------*/

void SwDoubleLinePortion::FormatBrackets( SwTxtFormatInfo &rInf, SwTwips& nMaxWidth )
{
	nMaxWidth -= rInf.X();
	SwFont* pTmpFnt = new SwFont( *rInf.GetFont() );
	pTmpFnt->SetProportion( 100 );
	pBracket->nAscent = 0;
	pBracket->nHeight = 0;
	if( pBracket->cPre )
	{
		String aStr( pBracket->cPre );
		sal_uInt8 nActualScr = pTmpFnt->GetActual();
		if( SW_SCRIPTS > pBracket->nPreScript )
			pTmpFnt->SetActual( pBracket->nPreScript );
		SwFontSave aSave( rInf, pTmpFnt );
		SwPosSize aSize = rInf.GetTxtSize( aStr );
		pBracket->nAscent = rInf.GetAscent();
		pBracket->nHeight = aSize.Height();
		pTmpFnt->SetActual( nActualScr );
		if( nMaxWidth > aSize.Width() )
		{
			pBracket->nPreWidth = aSize.Width();
			nMaxWidth -= aSize.Width();
			rInf.X( rInf.X() + aSize.Width() );
		}
		else
		{
			pBracket->nPreWidth = 0;
			nMaxWidth = 0;
		}
	}
	else
		pBracket->nPreWidth = 0;
	if( pBracket->cPost )
	{
		String aStr( pBracket->cPost );
		if( SW_SCRIPTS > pBracket->nPostScript )
			pTmpFnt->SetActual( pBracket->nPostScript );
		SwFontSave aSave( rInf, pTmpFnt );
		SwPosSize aSize = rInf.GetTxtSize( aStr );
		KSHORT nTmpAsc = rInf.GetAscent();
		if( nTmpAsc > pBracket->nAscent )
		{
			pBracket->nHeight += nTmpAsc - pBracket->nAscent;
			pBracket->nAscent = nTmpAsc;
		}
		if( aSize.Height() > pBracket->nHeight )
			pBracket->nHeight = aSize.Height();
		if( nMaxWidth > aSize.Width() )
		{
			pBracket->nPostWidth = aSize.Width();
			nMaxWidth -= aSize.Width();
		}
		else
		{
			pBracket->nPostWidth = 0;
			nMaxWidth = 0;
		}
	}
	else
		pBracket->nPostWidth = 0;
	nMaxWidth += rInf.X();
}

/*-----------------26.10.00 10:36-------------------
 * SwDoubleLinePortion::CalcBlanks
 * calculates the number of blanks in each line and
 * the difference of the width of the two lines.
 * These results are used from the text adjustment.
 * --------------------------------------------------*/

void SwDoubleLinePortion::CalcBlanks( SwTxtFormatInfo &rInf )
{
	SwLinePortion* pPor = GetRoot().GetFirstPortion();
	xub_StrLen nNull = 0;
	xub_StrLen nStart = rInf.GetIdx();
	SetTab1( sal_False );
	SetTab2( sal_False );
	for( nBlank1 = 0; pPor; pPor = pPor->GetPortion() )
	{
		if( pPor->InTxtGrp() )
			nBlank1 = nBlank1 + ((SwTxtPortion*)pPor)->GetSpaceCnt( rInf, nNull );
		rInf.SetIdx( rInf.GetIdx() + pPor->GetLen() );
		if( pPor->InTabGrp() )
			SetTab1( sal_True );
	}
	nLineDiff = GetRoot().Width();
	if( GetRoot().GetNext() )
	{
		pPor = GetRoot().GetNext()->GetFirstPortion();
		nLineDiff -= GetRoot().GetNext()->Width();
	}
	for( nBlank2 = 0; pPor; pPor = pPor->GetPortion() )
	{
		if( pPor->InTxtGrp() )
			nBlank2 = nBlank2 + ((SwTxtPortion*)pPor)->GetSpaceCnt( rInf, nNull );
		rInf.SetIdx( rInf.GetIdx() + pPor->GetLen() );
		if( pPor->InTabGrp() )
			SetTab2( sal_True );
	}
	rInf.SetIdx( nStart );
}

long SwDoubleLinePortion::CalcSpacing( long nSpaceAdd, const SwTxtSizeInfo & ) const
{
	return HasTabulator() ? 0 : GetSpaceCnt() * nSpaceAdd / SPACING_PRECISION_FACTOR;
}

/*-----------------01.11.00 14:29-------------------
 * SwDoubleLinePortion::ChangeSpaceAdd(..)
 * merges the spaces for text adjustment from the inner and outer part.
 * Inside the doubleline portion the wider line has no spaceadd-array, the
 * smaller line has such an array to reach width of the wider line.
 * If the surrounding line has text adjustment and the doubleline portion
 * contains no tabulator, it is necessary to create/manipulate the inner
 * space arrays.
 * --------------------------------------------------*/

sal_Bool SwDoubleLinePortion::ChgSpaceAdd( SwLineLayout* pCurr,
										   long nSpaceAdd ) const
{
	sal_Bool bRet = sal_False;
	if( !HasTabulator() && nSpaceAdd > 0 )
	{
		if( !pCurr->IsSpaceAdd() )
		{
			// The wider line gets the spaceadd from the surrounding line direct
			pCurr->CreateSpaceAdd();
			pCurr->SetLLSpaceAdd( nSpaceAdd, 0 );
			bRet = sal_True;
		}
		else
		{
			xub_StrLen nMyBlank = GetSmallerSpaceCnt();
			xub_StrLen nOther = GetSpaceCnt();
			SwTwips nMultiSpace = pCurr->GetLLSpaceAdd( 0 ) * nMyBlank + nOther * nSpaceAdd;

			if( nMyBlank )
				nMultiSpace /= nMyBlank;

			if( nMultiSpace < KSHRT_MAX * SPACING_PRECISION_FACTOR )
			{
//				pCurr->SetLLSpaceAdd( nMultiSpace, 0 );
				// --> FME 2006-07-11 #i65711# SetLLSpaceAdd replaces the first value,
				// instead we want to insert a new first value:
				std::vector<long>* pVec = pCurr->GetpLLSpaceAdd();
				pVec->insert( pVec->begin(), nMultiSpace );
				// <--
				bRet = sal_True;
			}
		}
	}
	return bRet;
}
/*-----------------01.11.00 14:29-------------------
 * SwDoubleLinePortion::ResetSpaceAdd(..)
 * cancels the manipulation from SwDoubleLinePortion::ChangeSpaceAdd(..)
 * --------------------------------------------------*/

void SwDoubleLinePortion::ResetSpaceAdd( SwLineLayout* pCurr )
{
	pCurr->RemoveFirstLLSpaceAdd();;
	if( !pCurr->GetLLSpaceAddCount() )
		pCurr->FinishSpaceAdd();
}

SwDoubleLinePortion::~SwDoubleLinePortion()
{
	delete pBracket;
}

/*-----------------13.11.00 14:50-------------------
 * SwRubyPortion::SwRubyPortion(..)
 * constructs a ruby portion, i.e. an additional text is displayed
 * beside the main text, e.g. phonetic characters.
 * --------------------------------------------------*/


SwRubyPortion::SwRubyPortion( const SwRubyPortion& rRuby, xub_StrLen nEnd ) :
	SwMultiPortion( nEnd ),
	nRubyOffset( rRuby.GetRubyOffset() ),
	nAdjustment( rRuby.GetAdjustment() )
{
	SetDirection( rRuby.GetDirection() ),
	SetTop( rRuby.OnTop() );
	SetRuby();
}

/*-----------------13.11.00 14:50-------------------
 * SwRubyPortion::SwRubyPortion(..)
 * constructs a ruby portion, i.e. an additional text is displayed
 * beside the main text, e.g. phonetic characters.
 * --------------------------------------------------*/

SwRubyPortion::SwRubyPortion( const SwMultiCreator& rCreate, const SwFont& rFnt,
							  const IDocumentSettingAccess& rIDocumentSettingAccess,
							   xub_StrLen nEnd, xub_StrLen nOffs,
							  const sal_Bool* pForceRubyPos )
	: SwMultiPortion( nEnd )
{
	SetRuby();
	ASSERT( SW_MC_RUBY == rCreate.nId, "Ruby expected" );
	ASSERT( RES_TXTATR_CJK_RUBY == rCreate.pAttr->Which(), "Wrong attribute" );
	const SwFmtRuby& rRuby = rCreate.pAttr->GetRuby();
	nAdjustment = rRuby.GetAdjustment();
	nRubyOffset = nOffs;

	// in grid mode we force the ruby text to the upper or lower line
	if ( pForceRubyPos )
		SetTop( *pForceRubyPos );
	else
		SetTop( ! rRuby.GetPosition() );

	const SwCharFmt* pFmt = ((SwTxtRuby*)rCreate.pAttr)->GetCharFmt();
	SwFont *pRubyFont;
	if( pFmt )
	{
		const SwAttrSet& rSet = pFmt->GetAttrSet();
	 	pRubyFont = new SwFont( rFnt );
		pRubyFont->SetDiffFnt( &rSet, &rIDocumentSettingAccess );

		// we do not allow a vertical font for the ruby text
		pRubyFont->SetVertical( rFnt.GetOrientation() );
	}
	else
		pRubyFont = NULL;

	String aStr( rRuby.GetText(), nOffs, STRING_LEN );
	SwFldPortion *pFld = new SwFldPortion( aStr, pRubyFont );
	pFld->SetNextOffset( nOffs );
	pFld->SetFollow( sal_True );

	if( OnTop() )
		GetRoot().SetPortion( pFld );
	else
	{
		GetRoot().SetNext( new SwLineLayout() );
		GetRoot().GetNext()->SetPortion( pFld );
	}

	// ruby portions have the same direction as the frame directions
	if ( rCreate.nLevel % 2 )
	{
		// switch right and left ruby adjustment in rtl environment
		if ( 0 == nAdjustment )
			nAdjustment = 2;
		else if ( 2 == nAdjustment )
			nAdjustment = 0;

		SetDirection( DIR_RIGHT2LEFT );
	}
	else
		SetDirection( DIR_LEFT2RIGHT );
}

/*-----------------13.11.00 14:56-------------------
 * SwRubyPortion::_Adjust(..)
 * In ruby portion there are different alignments for
 * the ruby text and the main text.
 * Left, right, centered and two possibilities of block adjustment
 * The block adjustment is realized by spacing between the characters,
 * either with a half space or no space in front of the first letter and
 * a half space at the end of the last letter.
 * Notice: the smaller line will be manipulated, normally it's the ruby line,
 * but it could be the main text, too.
 * If there is a tabulator in smaller line, no adjustment is possible.
 * --------------------------------------------------*/

void SwRubyPortion::_Adjust( SwTxtFormatInfo &rInf )
{
	SwTwips nLineDiff = GetRoot().Width() - GetRoot().GetNext()->Width();
	xub_StrLen nOldIdx = rInf.GetIdx();
	if( !nLineDiff )
		return;
	SwLineLayout *pCurr;
	if( nLineDiff < 0 )
	{ // The first line has to be adjusted.
		if( GetTab1() )
			return;
		pCurr = &GetRoot();
		nLineDiff = -nLineDiff;
	}
	else
	{ // The second line has to be adjusted.
		if( GetTab2() )
			return;
		pCurr = GetRoot().GetNext();
		rInf.SetIdx( nOldIdx + GetRoot().GetLen() );
	}
	KSHORT nLeft = 0;	// the space in front of the first letter
	KSHORT nRight = 0;	// the space at the end of the last letter
	sal_uInt16 nSub = 0;
	switch ( nAdjustment )
	{
		case 1: nRight = static_cast<sal_uInt16>(nLineDiff / 2); // no break
		case 2: nLeft  = static_cast<sal_uInt16>(nLineDiff - nRight); break;
		case 3: nSub   = 1; // no break
		case 4:
		{
			xub_StrLen nCharCnt = 0;
			SwLinePortion *pPor;
			for( pPor = pCurr->GetFirstPortion(); pPor; pPor = pPor->GetPortion() )
			{
				if( pPor->InTxtGrp() )
					((SwTxtPortion*)pPor)->GetSpaceCnt( rInf, nCharCnt );
				rInf.SetIdx( rInf.GetIdx() + pPor->GetLen() );
			}
			if( nCharCnt > nSub )
			{
				SwTwips nCalc = nLineDiff / ( nCharCnt - nSub );
				short nTmp;
				if( nCalc < SHRT_MAX )
					nTmp = -short(nCalc);
				else
					nTmp = SHRT_MIN;

				pCurr->CreateSpaceAdd( SPACING_PRECISION_FACTOR * nTmp );
				nLineDiff -= nCalc * ( nCharCnt - 1 );
			}
			if( nLineDiff > 1 )
			{
				nRight = static_cast<sal_uInt16>(nLineDiff / 2);
				nLeft  = static_cast<sal_uInt16>(nLineDiff - nRight);
			}
			break;
		}
		default: ASSERT( sal_False, "New ruby adjustment" );
	}
	if( nLeft || nRight )
	{
		if( !pCurr->GetPortion() )
			pCurr->SetPortion( new SwTxtPortion( *pCurr ) );
		SwMarginPortion *pMarg = new SwMarginPortion( 0 );
		if( nLeft )
		{
			pMarg->AddPrtWidth( nLeft );
			pMarg->SetPortion( pCurr->GetPortion() );
			pCurr->SetPortion( pMarg );
		}
		if( nRight )
		{
			pMarg = new SwMarginPortion( 0 );
			pMarg->AddPrtWidth( nRight );
			pCurr->FindLastPortion()->Append( pMarg );
		}
	}

	pCurr->Width( Width() );
	rInf.SetIdx( nOldIdx );
}

/*-----------------08.11.00 14:14-------------------
 * CalcRubyOffset()
 * has to change the nRubyOffset, if there's a fieldportion
 * in the phonetic line.
 * The nRubyOffset is the position in the rubystring, where the
 * next SwRubyPortion has start the displaying of the phonetics.
 * --------------------------------------------------*/

void SwRubyPortion::CalcRubyOffset()
{
	const SwLineLayout *pCurr = &GetRoot();
	if( !OnTop() )
	{
		pCurr = pCurr->GetNext();
		if( !pCurr )
			return;
	}
	const SwLinePortion *pPor = pCurr->GetFirstPortion();
	const SwFldPortion *pFld = NULL;
	while( pPor )
	{
		if( pPor->InFldGrp() )
			pFld = (SwFldPortion*)pPor;
		pPor = pPor->GetPortion();
	}
	if( pFld )
	{
		if( pFld->HasFollow() )
			nRubyOffset = pFld->GetNextOffset();
		else
			nRubyOffset = STRING_LEN;
	}
}

/*-----------------13.10.00 16:22-------------------
 * SwTxtSizeInfo::GetMultiCreator(..)
 * If we (e.g. the position rPos) are inside a two-line-attribute or
 * a ruby-attribute, the attribute will be returned in a SwMultiCreator-struct,
 * otherwise the function returns zero.
 * The rPos parameter is set to the end of the multiportion,
 * normally this is the end of the attribute,
 * but sometimes it is the start of another attribute, which finished or
 * interrupts the first attribute.
 * E.g. a ruby portion interrupts a 2-line-attribute, a 2-line-attribute
 * with different brackets interrupts another 2-line-attribute.
 * --------------------------------------------------*/

/*-----------------13.11.00 15:38-------------------
 * lcl_Has2Lines(..)
 * is a little help function for GetMultiCreator(..)
 * It extracts the 2-line-format from a 2-line-attribute or a character style.
 * The rValue is set to sal_True, if the 2-line-attribute's value is set and
 * no 2-line-format reference is passed. If there is a 2-line-format reference,
 * then the rValue is set only, if the 2-line-attribute's value is set _and_
 * the 2-line-formats has the same brackets.
 * --------------------------------------------------*/

sal_Bool lcl_Has2Lines( const SwTxtAttr& rAttr, const SvxTwoLinesItem* &rpRef,
	sal_Bool &rValue )
{
	const SfxPoolItem* pItem = CharFmt::GetItem( rAttr, RES_CHRATR_TWO_LINES );
	if( pItem )
	{
		rValue = ((SvxTwoLinesItem*)pItem)->GetValue();
		if( !rpRef )
			rpRef = (SvxTwoLinesItem*)pItem;
		else if( ((SvxTwoLinesItem*)pItem)->GetEndBracket() !=
					rpRef->GetEndBracket() ||
					((SvxTwoLinesItem*)pItem)->GetStartBracket() !=
					rpRef->GetStartBracket() )
			rValue = sal_False;
		return sal_True;
	}
	return sal_False;
}

/*-----------------16.02.01 16:39-------------------
 * lcl_HasRotation(..)
 * is a little help function for GetMultiCreator(..)
 * It extracts the charrotation from a charrotate-attribute or a character style.
 * The rValue is set to sal_True, if the charrotate-attribute's value is set and
 * no charrotate-format reference is passed.
 * If there is a charrotate-format reference, then the rValue is set only,
 * if the charrotate-attribute's value is set _and_ identical
 * to the charrotate-format's value.
 * --------------------------------------------------*/

sal_Bool lcl_HasRotation( const SwTxtAttr& rAttr,
	const SvxCharRotateItem* &rpRef, sal_Bool &rValue )
{
	const SfxPoolItem* pItem = CharFmt::GetItem( rAttr, RES_CHRATR_ROTATE );
	if ( pItem )
	{
		rValue = 0 != ((SvxCharRotateItem*)pItem)->GetValue();
		if( !rpRef )
			rpRef = (SvxCharRotateItem*)pItem;
		else if( ((SvxCharRotateItem*)pItem)->GetValue() !=
					rpRef->GetValue() )
			rValue = sal_False;
		return sal_True;
	}

	return sal_False;
}

SwMultiCreator* SwTxtSizeInfo::GetMultiCreator( xub_StrLen &rPos,
												SwMultiPortion* pMulti ) const
{
	SwScriptInfo& rSI = ((SwParaPortion*)GetParaPortion())->GetScriptInfo();

	// get the last embedding level
	sal_uInt8 nCurrLevel;
	if ( pMulti )
	{
		ASSERT( pMulti->IsBidi(), "Nested MultiPortion is not BidiPortion" )
		// level associated with bidi-portion;
		nCurrLevel = ((SwBidiPortion*)pMulti)->GetLevel();
	}
	else
		// no nested bidi portion required
		nCurrLevel = GetTxtFrm()->IsRightToLeft() ? 1 : 0;

	// check if there is a field at rPos:
	sal_uInt8 nNextLevel = nCurrLevel;
	sal_Bool bFldBidi = sal_False;

	if ( CH_TXTATR_BREAKWORD == GetChar( rPos ) )
	{
		bFldBidi = sal_True;
/*
		// examining the script of the field text should be sufficient
		// for 99% of all cases
		XubString aTxt = GetTxtFrm()->GetTxtNode()->GetExpandTxt( rPos, 1 );

		if ( pBreakIt->GetBreakIter().is() && aTxt.Len() )
		{
			sal_Bool bFldDir = ( i18n::ScriptType::COMPLEX ==
								 pBreakIt->GetRealScriptOfText( aTxt, 0 ) );
			sal_Bool bCurrDir = ( 0 != ( nCurrLevel % 2 ) );
			if ( bFldDir != bCurrDir )
			{
				nNextLevel = nCurrLevel + 1;
				bFldBidi = sal_True;
			}
		}*/
	}
	else
		nNextLevel = rSI.DirType( rPos );

	if ( GetTxt().Len() != rPos && nNextLevel > nCurrLevel )
	{
		rPos = bFldBidi ? rPos + 1 : rSI.NextDirChg( rPos, &nCurrLevel );
		if ( STRING_LEN == rPos )
			return NULL;
		SwMultiCreator *pRet = new SwMultiCreator;
		pRet->pItem = NULL;
		pRet->pAttr = NULL;
		pRet->nId = SW_MC_BIDI;
		pRet->nLevel = nCurrLevel + 1;
		return pRet;
	}

	// a bidi portion can only contain other bidi portions
	if ( pMulti )
		return NULL;

	const SvxCharRotateItem* pRotate = NULL;
	const SfxPoolItem* pRotItem;
	if( SFX_ITEM_SET == pFrm->GetTxtNode()->GetSwAttrSet().
		GetItemState( RES_CHRATR_ROTATE, sal_True, &pRotItem ) &&
		((SvxCharRotateItem*)pRotItem)->GetValue() )
		pRotate = (SvxCharRotateItem*)pRotItem;
	else
		pRotItem = NULL;
	const SvxTwoLinesItem* p2Lines = NULL;
	const SfxPoolItem* pItem;
	if( SFX_ITEM_SET == pFrm->GetTxtNode()->GetSwAttrSet().
		GetItemState( RES_CHRATR_TWO_LINES, sal_True, &pItem ) &&
		((SvxTwoLinesItem*)pItem)->GetValue() )
		p2Lines = (SvxTwoLinesItem*)pItem;
	else
		pItem = NULL;

	const SwpHints *pHints = pFrm->GetTxtNode()->GetpSwpHints();
	if( !pHints && !p2Lines && !pRotate )
		return NULL;
	const SwTxtAttr *pRuby = NULL;
	sal_Bool bTwo = sal_False;
	sal_Bool bRot = sal_False;
	sal_uInt16 n2Lines = USHRT_MAX;
	sal_uInt16 nRotate = USHRT_MAX;
	sal_uInt16 nCount = pHints ? pHints->Count() : 0;
	sal_uInt16 i;
	for( i = 0; i < nCount; ++i )
	{
		const SwTxtAttr *pTmp = (*pHints)[i];
		xub_StrLen nStart = *pTmp->GetStart();
		if( rPos < nStart )
			break;
		if( *pTmp->GetAnyEnd() > rPos )
		{
			if( RES_TXTATR_CJK_RUBY == pTmp->Which() )
				pRuby = pTmp;
			else
			{
				const SvxCharRotateItem* pRoTmp = NULL;
				if( lcl_HasRotation( *pTmp, pRoTmp, bRot ) )
				{
					nRotate = bRot ? i : nCount;
					pRotate = pRoTmp;
				}
				const SvxTwoLinesItem* p2Tmp = NULL;
				if( lcl_Has2Lines( *pTmp, p2Tmp, bTwo ) )
				{
					n2Lines = bTwo ? i : nCount;
					p2Lines = p2Tmp;
				}
			}
		}
	}
	if( pRuby )
	{	// The winner is ... a ruby attribute and so
		// the end of the multiportion is the end of the ruby attribute.
		rPos = *pRuby->End();
		SwMultiCreator *pRet = new SwMultiCreator;
		pRet->pItem = NULL;
		pRet->pAttr = pRuby;
		pRet->nId = SW_MC_RUBY;
		pRet->nLevel = GetTxtFrm()->IsRightToLeft() ? 1 : 0;
		return pRet;
	}
	if( n2Lines < nCount || ( pItem && pItem == p2Lines &&
		rPos < GetTxt().Len() ) )
	{	// The winner is a 2-line-attribute,
		// the end of the multiportion depends on the following attributes...
		SwMultiCreator *pRet = new SwMultiCreator;

		// We note the endpositions of the 2-line attributes in aEnd as stack
		SvXub_StrLens aEnd;

		// The bOn flag signs the state of the last 2-line attribute in the
		// aEnd-stack, it is compatible with the winner-attribute or
		// it interrupts the other attribute.
		sal_Bool bOn = sal_True;

		if( n2Lines < nCount )
		{
			pRet->pItem = NULL;
			pRet->pAttr = (*pHints)[n2Lines];
			aEnd.push_front( *pRet->pAttr->End() );
			if( pItem )
			{
				aEnd.front() = GetTxt().Len();
				bOn = ((SvxTwoLinesItem*)pItem)->GetEndBracket() ==
						p2Lines->GetEndBracket() &&
					  ((SvxTwoLinesItem*)pItem)->GetStartBracket() ==
						p2Lines->GetStartBracket();
			}
		}
		else
		{
			pRet->pItem = pItem;
			pRet->pAttr = NULL;
			aEnd.push_front( GetTxt().Len() );
		}
		pRet->nId = SW_MC_DOUBLE;
		pRet->nLevel = GetTxtFrm()->IsRightToLeft() ? 1 : 0;

		// n2Lines is the index of the last 2-line-attribute, which contains
		// the actual position.
		i = 0;
		// At this moment we know that at position rPos the "winner"-attribute
		// causes a 2-line-portion. The end of the attribute is the end of the
		// portion, if there's no interrupting attribute.
		// There are two kinds of interruptors:
		// - ruby attributes stops the 2-line-attribute, the end of the
		//	 multiline is the start of the ruby attribute
		// - 2-line-attributes with value "Off" or with different brackets,
		//	 these attributes may interrupt the winner, but they could be
		//	 neutralized by another 2-line-attribute starting at the same
		//	 position with the same brackets as the winner-attribute.

		// In the following loop rPos is the critical position and it will be
		// evaluated, if at rPos starts a interrupting or a maintaining
		// continuity attribute.
		while( i < nCount )
		{
			const SwTxtAttr *pTmp = (*pHints)[i++];
			if( *pTmp->GetAnyEnd() <= rPos )
				continue;
			if( rPos < *pTmp->GetStart() )
			{
				// If bOn is sal_False and the next attribute starts later than rPos
				// the winner attribute is interrupted at rPos.
				// If the start of the next attribute is behind the end of
				// the last attribute on the aEnd-stack, this is the endposition
				// on the stack is the end of the 2-line portion.
				if( !bOn || aEnd.back() < *pTmp->GetStart() )
					break;
				// At this moment, bOn is sal_True and the next attribute starts
				// behind rPos, so we could move rPos to the next startpoint
				rPos = *pTmp->GetStart();
				// We clean up the aEnd-stack, endpositions equal to rPos are
				// superfluous.
				while( !aEnd.empty() && aEnd.back() <= rPos )
				{
					bOn = !bOn;
					aEnd.pop_back();
				}
				// If the endstack is empty, we simulate an attribute with
				// state sal_True and endposition rPos
				if( aEnd.empty() )
				{
					aEnd.push_front( rPos );
					bOn = sal_True;
				}
			}
			// A ruby attribute stops the 2-line immediately
			if( RES_TXTATR_CJK_RUBY == pTmp->Which() )
				return pRet;
			if( lcl_Has2Lines( *pTmp, p2Lines, bTwo ) )
			{ // We have an interesting attribute..
				if( bTwo == bOn )
				{ // ...with the same state, so the last attribute could
					// be continued.
					if( aEnd.back() < *pTmp->End() )
						aEnd.back() = *pTmp->End();
				}
				else
				{ // ...with a different state.
					bOn = bTwo;
					// If this is smaller than the last on the stack, we put
					// it on the stack. If it has the same endposition, the last
					// could be removed.
					if( aEnd.back() > *pTmp->End() )
						aEnd.push_back( *pTmp->End() );
					else if( aEnd.size() > 1 )
						aEnd.pop_back();
					else
						aEnd.back() = *pTmp->End();
				}
			}
		}
		if( bOn && !aEnd.empty() )
			rPos = aEnd.back();
		return pRet;
	}
	if( nRotate < nCount || ( pRotItem && pRotItem == pRotate &&
		rPos < GetTxt().Len() ) )
	{	// The winner is a rotate-attribute,
		// the end of the multiportion depends on the following attributes...
		SwMultiCreator *pRet = new SwMultiCreator;
		pRet->nId = SW_MC_ROTATE;

		// We note the endpositions of the 2-line attributes in aEnd as stack
		SvXub_StrLens aEnd;

		// The bOn flag signs the state of the last 2-line attribute in the
		// aEnd-stack, which could interrupts the winning rotation attribute.
		sal_Bool bOn = pItem ? sal_True : sal_False;
		aEnd.push_front( GetTxt().Len() );
		// n2Lines is the index of the last 2-line-attribute, which contains
		// the actual position.
		i = 0;
		xub_StrLen n2Start = rPos;
		while( i < nCount )
		{
			const SwTxtAttr *pTmp = (*pHints)[i++];
			if( *pTmp->GetAnyEnd() <= n2Start )
				continue;
			if( n2Start < *pTmp->GetStart() )
			{
				if( bOn || aEnd.back() < *pTmp->GetStart() )
					break;
				n2Start = *pTmp->GetStart();
				while( !aEnd.empty() && aEnd.back() <= n2Start )
				{
					bOn = !bOn;
					aEnd.pop_back();
				}
				if( aEnd.empty() )
				{
					aEnd.push_front( n2Start );
					bOn = sal_False;
				}
			}
			// A ruby attribute stops immediately
			if( RES_TXTATR_CJK_RUBY == pTmp->Which() )
			{
				bOn = sal_True;
				break;
			}
			p2Lines = NULL;
			if( lcl_Has2Lines( *pTmp, p2Lines, bTwo ) )
			{
				if( bTwo == bOn )
				{
					if( aEnd.back() < *pTmp->End() )
						aEnd.back() = *pTmp->End();
				}
				else
				{
					bOn = bTwo;
					if( aEnd.back() > *pTmp->End() )
						aEnd.push_back( *pTmp->End() );
					else if( aEnd.size() > 1 )
						aEnd.pop_back();
					else
						aEnd.back() = *pTmp->End();
				}
			}
		}
		if( !bOn && !aEnd.empty() )
			n2Start = aEnd.back();

		if( !aEnd.empty() )
			aEnd.clear();

		bOn = sal_True;
		if( nRotate < nCount )
		{
			pRet->pItem = NULL;
			pRet->pAttr = (*pHints)[nRotate];
			aEnd.push_front( *pRet->pAttr->End() );
			if( pRotItem )
			{
				aEnd.front() = GetTxt().Len();
				bOn = ((SvxCharRotateItem*)pRotItem)->GetValue() ==
						pRotate->GetValue();
			}
		}
		else
		{
			pRet->pItem = pRotItem;
			pRet->pAttr = NULL;
			aEnd.push_front( GetTxt().Len() );
		}
		i = 0;
		while( i < nCount )
		{
			const SwTxtAttr *pTmp = (*pHints)[i++];
			if( *pTmp->GetAnyEnd() <= rPos )
				continue;
			if( rPos < *pTmp->GetStart() )
			{
				if( !bOn || aEnd.back() < *pTmp->GetStart() )
					break;
				rPos = *pTmp->GetStart();
				while( !aEnd.empty() && aEnd.back() <= rPos )
				{
					bOn = !bOn;
					aEnd.pop_back();
				}
				if( aEnd.empty() )
				{
					aEnd.push_front( rPos );
					bOn = sal_True;
				}
			}
			if( RES_TXTATR_CJK_RUBY == pTmp->Which() )
			{
				bOn = sal_False;
				break;
			}
			if( lcl_HasRotation( *pTmp, pRotate, bTwo ) )
			{
				if( bTwo == bOn )
				{
					if( aEnd.back() < *pTmp->End() )
						aEnd.back() = *pTmp->End();
				}
				else
				{
					bOn = bTwo;
					if( aEnd.back() > *pTmp->End() )
						aEnd.push_back( *pTmp->End() );
					else if( aEnd.size() > 1 )
						aEnd.pop_back();
					else
						aEnd.back() = *pTmp->End();
				}
			}
		}
		if( bOn && !aEnd.empty() )
			rPos = aEnd.back();
		if( rPos > n2Start )
			rPos = n2Start;
		return pRet;
	}
	return NULL;
}

/*-----------------01.11.00 14:52-------------------
 * SwSpaceManipulator
 * is a little helper class to manage the spaceadd-arrays of the text adjustment
 * during a PaintMultiPortion.
 * The constructor prepares the array for the first line of multiportion,
 * the SecondLine-function restores the values for the first line and prepares
 * the second line.
 * The destructor restores the values of the last manipulation.
 * --------------------------------------------------*/

class SwSpaceManipulator
{
	SwTxtPaintInfo& rInfo;
	SwMultiPortion& rMulti;
	std::vector<long>* pOldSpaceAdd;
	MSHORT nOldSpIdx;
	long nSpaceAdd;
	sal_Bool bSpaceChg	: 1;
	sal_uInt8 nOldDir	: 2;
public:
	SwSpaceManipulator( SwTxtPaintInfo& rInf, SwMultiPortion& rMult );
	~SwSpaceManipulator();
	void SecondLine();
	inline long GetSpaceAdd() const { return nSpaceAdd; }
};

SwSpaceManipulator::SwSpaceManipulator( SwTxtPaintInfo& rInf,
										SwMultiPortion& rMult ) :
		rInfo( rInf ), rMulti( rMult )
{
	pOldSpaceAdd = rInfo.GetpSpaceAdd();
	nOldSpIdx = rInfo.GetSpaceIdx();
	nOldDir = rInfo.GetDirection();
	rInfo.SetDirection( rMulti.GetDirection() );
	bSpaceChg = sal_False;

	if( rMulti.IsDouble() )
	{
		nSpaceAdd = ( pOldSpaceAdd && !rMulti.HasTabulator() ) ?
					  rInfo.GetSpaceAdd() : 0;
		if( rMulti.GetRoot().IsSpaceAdd() )
		{
			rInfo.SetpSpaceAdd( rMulti.GetRoot().GetpLLSpaceAdd() );
			rInfo.ResetSpaceIdx();
			bSpaceChg = rMulti.ChgSpaceAdd(	&rMulti.GetRoot(), nSpaceAdd );
		}
		else if( rMulti.HasTabulator() )
			rInfo.SetpSpaceAdd( NULL );
	}
	else if ( ! rMulti.IsBidi() )
	{
		rInfo.SetpSpaceAdd( rMulti.GetRoot().GetpLLSpaceAdd() );
		rInfo.ResetSpaceIdx();
	}
}

void SwSpaceManipulator::SecondLine()
{
	if( bSpaceChg )
	{
		rInfo.RemoveFirstSpaceAdd();
		bSpaceChg = sal_False;
	}
	SwLineLayout *pLay = rMulti.GetRoot().GetNext();
	if( pLay->IsSpaceAdd() )
	{
		rInfo.SetpSpaceAdd( pLay->GetpLLSpaceAdd() );
		rInfo.ResetSpaceIdx();
		bSpaceChg = rMulti.ChgSpaceAdd( pLay, nSpaceAdd );
	}
	else
	{
		rInfo.SetpSpaceAdd( (!rMulti.IsDouble() || rMulti.HasTabulator() ) ?
								0 : pOldSpaceAdd );
		rInfo.SetSpaceIdx( nOldSpIdx);
	}
}

SwSpaceManipulator::~SwSpaceManipulator()
{
	if( bSpaceChg )
	{
		rInfo.RemoveFirstSpaceAdd();
		bSpaceChg = sal_False;
	}
	rInfo.SetpSpaceAdd( pOldSpaceAdd );
	rInfo.SetSpaceIdx( nOldSpIdx);
	rInfo.SetDirection( nOldDir );
}

/*-----------------13.10.00 16:24-------------------
 * SwTxtPainter::PaintMultiPortion manages the paint for a SwMultiPortion.
 * External, for the calling function, it seems to be a normal Paint-function,
 * internal it is like a SwTxtFrm::Paint with multiple DrawTextLines
 * --------------------------------------------------*/

void SwTxtPainter::PaintMultiPortion( const SwRect &rPaint,
	SwMultiPortion& rMulti, const SwMultiPortion* pEnvPor )
{
	GETGRID( pFrm->FindPageFrm() )
	const sal_Bool bHasGrid = pGrid && GetInfo().SnapToGrid();
	sal_uInt16 nGridWidth = 0;
	sal_uInt16 nRubyHeight = 0;
	sal_Bool bRubyTop = sal_False;

	if ( bHasGrid )
	{
		nGridWidth = pGrid->GetBaseHeight();
		nRubyHeight = pGrid->GetRubyHeight();
		bRubyTop = ! pGrid->GetRubyTextBelow();
	}

	// do not allow grid mode for first line in ruby portion
	const sal_Bool bRubyInGrid = bHasGrid && rMulti.IsRuby();

	const sal_uInt16 nOldHeight = rMulti.Height();
	const sal_Bool bOldGridModeAllowed = GetInfo().SnapToGrid();

	if ( bRubyInGrid )
	{
		GetInfo().SetSnapToGrid( ! bRubyTop );
		rMulti.Height( pCurr->Height() );
	}

	SwLayoutModeModifier aLayoutModeModifier( *GetInfo().GetOut() );
	sal_uInt8 nEnvDir = 0;
	sal_uInt8 nThisDir = 0;
	sal_uInt8 nFrmDir = 0;
	if ( rMulti.IsBidi() )
	{
		// these values are needed for the calculation of the x coordinate
		// and the layout mode
		ASSERT( ! pEnvPor || pEnvPor->IsBidi(), "I expected a BidiPortion" )
		nFrmDir = GetInfo().GetTxtFrm()->IsRightToLeft() ? 1 : 0;
		nEnvDir = pEnvPor ? ((SwBidiPortion*)pEnvPor)->GetLevel() % 2 : nFrmDir;
		nThisDir = ((SwBidiPortion&)rMulti).GetLevel() % 2;
	}

#if OSL_DEBUG_LEVEL > 1
	// only paint first level bidi portions
	if( rMulti.Width() > 1 && ! pEnvPor )
		GetInfo().DrawViewOpt( rMulti, POR_FLD );
#endif

	if ( bRubyInGrid )
		rMulti.Height( nOldHeight );

	// do we have to repaint a post it portion?
	if( GetInfo().OnWin() && rMulti.GetPortion() &&
		! rMulti.GetPortion()->Width() )
		rMulti.GetPortion()->PrePaint( GetInfo(), &rMulti );

	// old values must be saved and restored at the end
	xub_StrLen nOldLen = GetInfo().GetLen();
	KSHORT nOldX = KSHORT(GetInfo().X());
	long nOldY = GetInfo().Y();
	xub_StrLen nOldIdx = GetInfo().GetIdx();

	SwSpaceManipulator aManip( GetInfo(), rMulti );

	SwFontSave *pFontSave;
	SwFont* pTmpFnt;

	if( rMulti.IsDouble() )
	{
		pTmpFnt = new SwFont( *GetInfo().GetFont() );
		if( rMulti.IsDouble() )
		{
			SetPropFont( 50 );
			pTmpFnt->SetProportion( GetPropFont() );
		}
		pFontSave = new SwFontSave( GetInfo(), pTmpFnt, this );
	}
	else
	{
		pFontSave = NULL;
		pTmpFnt = NULL;
	}

	if( rMulti.HasBrackets() )
	{
		xub_StrLen nTmpOldIdx = GetInfo().GetIdx();
		GetInfo().SetIdx(((SwDoubleLinePortion&)rMulti).GetBrackets()->nStart);
		SeekAndChg( GetInfo() );
		((SwDoubleLinePortion&)rMulti).PaintBracket( GetInfo(), 0, sal_True );
		GetInfo().SetIdx( nTmpOldIdx );
	}

	KSHORT nTmpX = KSHORT(GetInfo().X());

	SwLineLayout* pLay = &rMulti.GetRoot();// the first line of the multiportion
	SwLinePortion* pPor = pLay->GetFirstPortion();//first portion of these line
	SwTwips nOfst = 0;

	// GetInfo().Y() is the baseline from the surrounding line. We must switch
	// this temporary to the baseline of the inner lines of the multiportion.
	if( rMulti.HasRotation() )
	{
		if( rMulti.IsRevers() )
		{
			GetInfo().Y( nOldY - rMulti.GetAscent() );
			nOfst = nTmpX + rMulti.Width();
		}
		else
		{
			GetInfo().Y( nOldY - rMulti.GetAscent() + rMulti.Height() );
			nOfst = nTmpX;
		}
	}
	else if ( rMulti.IsBidi() )
	{
		// does the current bidi portion has the same direction
		// as its environment?
		if ( nEnvDir != nThisDir )
		{
			// different directions, we have to adjust the x coordinate
			SwTwips nMultiWidth = rMulti.Width() +
					rMulti.CalcSpacing( GetInfo().GetSpaceAdd(), GetInfo() );

			if ( nFrmDir == nThisDir )
				GetInfo().X( GetInfo().X() - nMultiWidth );
			else
				GetInfo().X( GetInfo().X() + nMultiWidth );
		}

		nOfst = nOldY - rMulti.GetAscent();

		// set layout mode
		aLayoutModeModifier.Modify( nThisDir );
	}
	else
		nOfst = nOldY - rMulti.GetAscent();

	sal_Bool bRest = pLay->IsRest();
	sal_Bool bFirst = sal_True;

	ASSERT( 0 == GetInfo().GetUnderFnt() || rMulti.IsBidi(),
			" Only BiDi portions are allowed to use the common underlining font" )

	do
	{
		if ( bHasGrid )
		{
			if( rMulti.HasRotation() )
			{
				const sal_uInt16 nAdjustment = ( pLay->Height() - pPor->Height() ) / 2 +
											pPor->GetAscent();
				if( rMulti.IsRevers() )
					GetInfo().X( nOfst - nAdjustment );
				else
					GetInfo().X( nOfst + nAdjustment );
			}
			else
			{
				// special treatment for ruby portions in grid mode
				SwTwips nAdjustment = 0;
				if ( rMulti.IsRuby() )
				{
					if ( bRubyTop != ( pLay == &rMulti.GetRoot() ) )
						// adjust base text
						nAdjustment = ( pCurr->Height() - nRubyHeight - pPor->Height() ) / 2;
					else if ( bRubyTop )
						// adjust upper ruby text
						nAdjustment = nRubyHeight - pPor->Height();
					// else adjust lower ruby text
				}

				GetInfo().Y( nOfst + nAdjustment + pPor->GetAscent() );
			}
		}
		else if( rMulti.HasRotation() )
		{
			if( rMulti.IsRevers() )
				GetInfo().X( nOfst - AdjustBaseLine( *pLay, pPor, 0, 0, sal_True ) );
			else
				GetInfo().X( nOfst + AdjustBaseLine( *pLay, pPor ) );
		}
		else
			GetInfo().Y( nOfst + AdjustBaseLine( *pLay, pPor ) );

		sal_Bool bSeeked = sal_True;
		GetInfo().SetLen( pPor->GetLen() );

		if( bRest && pPor->InFldGrp() && !pPor->GetLen() )
		{
			if(	((SwFldPortion*)pPor)->HasFont() )
		 		bSeeked = sal_False;
			else
				SeekAndChgBefore( GetInfo() );
		}
		else if( pPor->InTxtGrp() || pPor->InFldGrp() || pPor->InTabGrp() )
			SeekAndChg( GetInfo() );
		else if ( !bFirst && pPor->IsBreakPortion() && GetInfo().GetOpt().IsParagraph() )
		{
			if( GetRedln() )
				SeekAndChg( GetInfo() );
			else
				SeekAndChgBefore( GetInfo() );
		}
		else
			bSeeked = sal_False;

		SwLinePortion *pNext = pPor->GetPortion();
		if(GetInfo().OnWin() && pNext && !pNext->Width() )
		{
			if ( !bSeeked )
				SeekAndChg( GetInfo() );
			pNext->PrePaint( GetInfo(), pPor );
		}

		CheckSpecialUnderline( pPor );
		SwUnderlineFont* pUnderLineFnt = GetInfo().GetUnderFnt();
		if ( pUnderLineFnt )
		{
			if ( rMulti.IsDouble() )
				pUnderLineFnt->GetFont().SetProportion( 50 );
			pUnderLineFnt->SetPos( GetInfo().GetPos() );
		}

		if ( rMulti.IsBidi() )
		{
			// we do not allow any rotation inside a bidi portion
			SwFont* pTmpFont = GetInfo().GetFont();
			pTmpFont->SetVertical( 0, GetInfo().GetTxtFrm()->IsVertical() );
		}

		if( pPor->IsMultiPortion() && ((SwMultiPortion*)pPor)->IsBidi() )
		{
			// but we do allow nested bidi portions
			ASSERT( rMulti.IsBidi(), "Only nesting of bidi portions is allowed" )
			PaintMultiPortion( rPaint, (SwMultiPortion&)*pPor, &rMulti );
		}
		else
			pPor->Paint( GetInfo() );

		if( GetFnt()->IsURL() && pPor->InTxtGrp() )
			GetInfo().NotifyURL( *pPor );

		bFirst &= !pPor->GetLen();
		if( pNext || !pPor->IsMarginPortion() )
			pPor->Move( GetInfo() );

		pPor = pNext;

		// If there's no portion left, we go to the next line
		if( !pPor && pLay->GetNext() )
		{
			pLay = pLay->GetNext();
			pPor = pLay->GetFirstPortion();
			bRest = pLay->IsRest();
			aManip.SecondLine();

			// delete underline font
			delete GetInfo().GetUnderFnt();
			GetInfo().SetUnderFnt( 0 );

			if( rMulti.HasRotation() )
			{
				if( rMulti.IsRevers() )
				{
					nOfst += pLay->Height();
					GetInfo().Y( nOldY - rMulti.GetAscent() );
				}
				else
				{
					nOfst -= pLay->Height();
					GetInfo().Y( nOldY - rMulti.GetAscent() + rMulti.Height() );
				}
			}
			else if ( bHasGrid && rMulti.IsRuby() )
			{
				GetInfo().X( nTmpX );
				if ( bRubyTop )
				{
					nOfst += nRubyHeight;
					GetInfo().SetSnapToGrid( sal_True );
				}
				else
				{
					nOfst += pCurr->Height() - nRubyHeight;
					GetInfo().SetSnapToGrid( sal_False );
				}
			} else
			{
				GetInfo().X( nTmpX );
				// We switch to the baseline of the next inner line
				nOfst += rMulti.GetRoot().Height();
			}
		}
	} while( pPor );

	if ( bRubyInGrid )
		GetInfo().SetSnapToGrid( bOldGridModeAllowed );

	// delete underline font
	if ( ! rMulti.IsBidi() )
	{
		delete GetInfo().GetUnderFnt();
		GetInfo().SetUnderFnt( 0 );
	}

	GetInfo().SetIdx( nOldIdx );
	GetInfo().Y( nOldY );

	if( rMulti.HasBrackets() )
	{
		xub_StrLen nTmpOldIdx = GetInfo().GetIdx();
		GetInfo().SetIdx(((SwDoubleLinePortion&)rMulti).GetBrackets()->nStart);
		SeekAndChg( GetInfo() );
		GetInfo().X( nOldX );
		((SwDoubleLinePortion&)rMulti).PaintBracket( GetInfo(),
			aManip.GetSpaceAdd(), sal_False );
		GetInfo().SetIdx( nTmpOldIdx );
	}
	// Restore the saved values
	GetInfo().X( nOldX );
	GetInfo().SetLen( nOldLen );
	delete pFontSave;
	delete pTmpFnt;
	SetPropFont( 0 );
}

sal_Bool lcl_ExtractFieldFollow( SwLineLayout* pLine, SwLinePortion* &rpFld )
{
	SwLinePortion* pLast = pLine;
	rpFld = pLine->GetPortion();
	while( rpFld && !rpFld->InFldGrp() )
	{
		pLast = rpFld;
		rpFld = rpFld->GetPortion();
	}
	sal_Bool bRet = rpFld != 0;
	if( bRet )
	{
		if( ((SwFldPortion*)rpFld)->IsFollow() )
		{
			rpFld->Truncate();
			pLast->SetPortion( NULL );
		}
		else
			rpFld = NULL;
	}
	pLine->Truncate();
	return bRet;
}

/*----------------------------------------------------
 * lcl_TruncateMultiPortion
 * If a multi portion completely has to go to the
 * next line, this function is called to truncate
 * the rest of the remaining multi portion
 * --------------------------------------------------*/

void lcl_TruncateMultiPortion( SwMultiPortion& rMulti, SwTxtFormatInfo& rInf,
							   xub_StrLen nStartIdx )
{
	rMulti.GetRoot().Truncate();
	rMulti.GetRoot().SetLen(0);
	rMulti.GetRoot().Width(0);
//	rMulti.CalcSize( *this, aInf );
	if ( rMulti.GetRoot().GetNext() )
	{
		rMulti.GetRoot().GetNext()->Truncate();
		rMulti.GetRoot().GetNext()->SetLen( 0 );
		rMulti.GetRoot().GetNext()->Width( 0 );
	}
	rMulti.Width( 0 );
	rMulti.SetLen(0);
	rInf.SetIdx( nStartIdx );
}

/*-----------------------------------------------------------------------------
 * SwTxtFormatter::BuildMultiPortion
 * manages the formatting of a SwMultiPortion. External, for the calling
 * function, it seems to be a normal Format-function, internal it is like a
 * SwTxtFrm::_Format with multiple BuildPortions
 *---------------------------------------------------------------------------*/

sal_Bool SwTxtFormatter::BuildMultiPortion( SwTxtFormatInfo &rInf,
	SwMultiPortion& rMulti )
{
	SwTwips nMaxWidth = rInf.Width();
	KSHORT nOldX = 0;

	if( rMulti.HasBrackets() )
	{
		xub_StrLen nOldIdx = rInf.GetIdx();
		rInf.SetIdx( ((SwDoubleLinePortion&)rMulti).GetBrackets()->nStart );
		SeekAndChg( rInf );
		nOldX = KSHORT(GetInfo().X());
		((SwDoubleLinePortion&)rMulti).FormatBrackets( rInf, nMaxWidth );
		rInf.SetIdx( nOldIdx );
	}

	SeekAndChg( rInf );
	SwFontSave *pFontSave;
	if( rMulti.IsDouble() )
	{
		SwFont* pTmpFnt = new SwFont( *rInf.GetFont() );
		if( rMulti.IsDouble() )
		{
			SetPropFont( 50 );
			pTmpFnt->SetProportion( GetPropFont() );
		}
		pFontSave = new SwFontSave( rInf, pTmpFnt, this );
	}
	else
		pFontSave = NULL;

	SwLayoutModeModifier aLayoutModeModifier( *GetInfo().GetOut() );
	if ( rMulti.IsBidi() )
	{
		// set layout mode
		aLayoutModeModifier.Modify( ! rInf.GetTxtFrm()->IsRightToLeft() );
	}

	SwTwips nTmpX = 0;

	if( rMulti.HasRotation() )
	{
		// For nMaxWidth we take the height of the body frame.
		// #i25067#: If the current frame is inside a table, we restrict
		// nMaxWidth to the current frame height, unless the frame size
		// attribute is set to variable size:

		// We set nTmpX (which is used for portion calculating) to the
		// current Y value
		const SwPageFrm* pPage = pFrm->FindPageFrm();
		ASSERT( pPage, "No page in frame!");
		const SwLayoutFrm* pUpperFrm = pPage;

		if ( pFrm->IsInTab() )
		{
			pUpperFrm = pFrm->GetUpper();
			while ( pUpperFrm && !pUpperFrm->IsCellFrm() )
				pUpperFrm = pUpperFrm->GetUpper();
			ASSERT( pUpperFrm, "pFrm is in table but does not have an upper cell frame" )
			const SwTableLine* pLine = ((SwRowFrm*)pUpperFrm->GetUpper())->GetTabLine();
			const SwFmtFrmSize& rFrmFmtSize = pLine->GetFrmFmt()->GetFrmSize();
			if ( ATT_VAR_SIZE == rFrmFmtSize.GetHeightSizeType() )
				pUpperFrm = pPage;
		}
		if ( pUpperFrm == pPage && !pFrm->IsInFtn() )
			pUpperFrm = pPage->FindBodyCont();

		nMaxWidth = pUpperFrm ?
					( rInf.GetTxtFrm()->IsVertical() ?
					  pUpperFrm->Prt().Width() :
					  pUpperFrm->Prt().Height() ) :
					USHRT_MAX;
	}
	else
		nTmpX = rInf.X();

	SwMultiPortion* pOldMulti = pMulti;

	pMulti = &rMulti;
	SwLineLayout *pOldCurr = pCurr;
	xub_StrLen nOldStart = GetStart();
	SwTwips nMinWidth = nTmpX + 1;
	SwTwips nActWidth = nMaxWidth;
	const xub_StrLen nStartIdx = rInf.GetIdx();
	xub_StrLen nMultiLen = rMulti.GetLen();

	SwLinePortion *pFirstRest;
	SwLinePortion *pSecondRest;
	if( rMulti.IsFormatted() )
	{
		if( !lcl_ExtractFieldFollow( &rMulti.GetRoot(), pFirstRest )
			&& rMulti.IsDouble() && rMulti.GetRoot().GetNext() )
			lcl_ExtractFieldFollow( rMulti.GetRoot().GetNext(), pFirstRest );
		if( !rMulti.IsDouble() && rMulti.GetRoot().GetNext() )
			lcl_ExtractFieldFollow( rMulti.GetRoot().GetNext(), pSecondRest );
		else
			pSecondRest = NULL;
	}
	else
	{
		pFirstRest = rMulti.GetRoot().GetPortion();
		pSecondRest = rMulti.GetRoot().GetNext() ?
					  rMulti.GetRoot().GetNext()->GetPortion() : NULL;
		if( pFirstRest )
			rMulti.GetRoot().SetPortion( NULL );
		if( pSecondRest )
			rMulti.GetRoot().GetNext()->SetPortion( NULL );
		rMulti.SetFormatted();
		nMultiLen = nMultiLen - rInf.GetIdx();
	}

	// save some values
	const XubString* pOldTxt = &(rInf.GetTxt());
	const SwTwips nOldPaintOfst = rInf.GetPaintOfst();

	XubString aMultiStr( rInf.GetTxt(), 0, nMultiLen + rInf.GetIdx() );
	rInf.SetTxt( aMultiStr );
	SwTxtFormatInfo aInf( rInf, rMulti.GetRoot(), nActWidth );
	// Do we allow break cuts? The FirstMulti-Flag is evaluated during
	// line break determination.
	sal_Bool bFirstMulti = rInf.GetIdx() != rInf.GetLineStart();

	SwLinePortion *pNextFirst = NULL;
	SwLinePortion *pNextSecond = NULL;
	sal_Bool bRet = sal_False;

	GETGRID( pFrm->FindPageFrm() )
	const sal_Bool bHasGrid = pGrid && GRID_LINES_CHARS == pGrid->GetGridType();

	sal_uInt16 nGridWidth = 0;
	sal_uInt16 nRubyHeight = 0;
	sal_Bool bRubyTop = sal_False;

	if ( bHasGrid )
	{
		nGridWidth = pGrid->GetBaseHeight();
		nRubyHeight = pGrid->GetRubyHeight();
		bRubyTop = ! pGrid->GetRubyTextBelow();
	}

	do
	{
		pCurr = &rMulti.GetRoot();
		nStart = nStartIdx;
		bRet = sal_False;
		FormatReset( aInf );
		aInf.X( nTmpX );
		aInf.Width( KSHORT(nActWidth) );
		aInf.RealWidth( KSHORT(nActWidth) );
		aInf.SetFirstMulti( bFirstMulti );
		aInf.SetNumDone( rInf.IsNumDone() );
		aInf.SetFtnDone( rInf.IsFtnDone() );

		if( pFirstRest )
		{
			ASSERT( pFirstRest->InFldGrp(), "BuildMulti: Fieldrest expected");
			SwFldPortion *pFld =
				((SwFldPortion*)pFirstRest)->Clone(
					((SwFldPortion*)pFirstRest)->GetExp() );
			pFld->SetFollow( sal_True );
			aInf.SetRest( pFld );
		}
		aInf.SetRuby( rMulti.IsRuby() && rMulti.OnTop() );

		// in grid mode we temporarily have to disable the grid for the ruby line
		const sal_Bool bOldGridModeAllowed = GetInfo().SnapToGrid();
		if ( bHasGrid && aInf.IsRuby() && bRubyTop )
			aInf.SetSnapToGrid( sal_False );

		// If there's no more rubytext, then buildportion is forbidden
		if( pFirstRest || !aInf.IsRuby() )
			BuildPortions( aInf );

		aInf.SetSnapToGrid( bOldGridModeAllowed );

		rMulti.CalcSize( *this, aInf );
		pCurr->SetRealHeight( pCurr->Height() );

		if( rMulti.IsBidi() )
		{
			pNextFirst = aInf.GetRest();
			break;
		}

		if( rMulti.HasRotation() && !rMulti.IsDouble() )
			break;
		// second line has to be formatted
		else if( pCurr->GetLen()<nMultiLen || rMulti.IsRuby() || aInf.GetRest())
		{
			xub_StrLen nFirstLen = pCurr->GetLen();
			delete pCurr->GetNext();
			pCurr->SetNext( new SwLineLayout() );
			pCurr = pCurr->GetNext();
			nStart = aInf.GetIdx();
			aInf.X( nTmpX );
			SwTxtFormatInfo aTmp( aInf, *pCurr, nActWidth );
			if( rMulti.IsRuby() )
			{
				aTmp.SetRuby( !rMulti.OnTop() );
				pNextFirst = aInf.GetRest();
				if( pSecondRest )
				{
					ASSERT( pSecondRest->InFldGrp(), "Fieldrest expected");
					SwFldPortion *pFld = ((SwFldPortion*)pSecondRest)->Clone(
									((SwFldPortion*)pSecondRest)->GetExp() );
					pFld->SetFollow( sal_True );
					aTmp.SetRest( pFld );
				}
				if( !rMulti.OnTop() && nFirstLen < nMultiLen )
					bRet = sal_True;
			}
			else
				aTmp.SetRest( aInf.GetRest() );
			aInf.SetRest( NULL );

			// in grid mode we temporarily have to disable the grid for the ruby line
			if ( bHasGrid && aTmp.IsRuby() && ! bRubyTop )
				aTmp.SetSnapToGrid( sal_False );

			BuildPortions( aTmp );

			aTmp.SetSnapToGrid( bOldGridModeAllowed );

			rMulti.CalcSize( *this, aInf );
			rMulti.GetRoot().SetRealHeight( rMulti.GetRoot().Height() );
			pCurr->SetRealHeight( pCurr->Height() );
			if( rMulti.IsRuby() )
			{
				pNextSecond = aTmp.GetRest();
				if( pNextFirst )
					bRet = sal_True;
			}
			else
				pNextFirst = aTmp.GetRest();
			if( ( !aTmp.IsRuby() && nFirstLen + pCurr->GetLen() < nMultiLen )
				|| aTmp.GetRest() )
				// our guess for width of multiportion was too small,
				// text did not fit into multiportion
				bRet = sal_True;
		}
		if( rMulti.IsRuby() )
			break;
		if( bRet )
		{
			// our guess for multiportion width was too small,
			// we set min to act
			nMinWidth = nActWidth;
			nActWidth = ( 3 * nMaxWidth + nMinWidth + 3 ) / 4;
			if ( nActWidth == nMaxWidth && rInf.GetLineStart() == rInf.GetIdx() )
			// we have too less space, we must allow break cuts
			// ( the first multi flag is considered during TxtPortion::_Format() )
				bFirstMulti = sal_False;
			if( nActWidth <= nMinWidth )
				break;
		}
		else
		{
			// For Solaris, this optimization can causes trouble:
			// Setting this to the portion width ( = rMulti.Width() )
			// can make GetTextBreak inside SwTxtGuess::Guess return to small
			// values. Therefore we add some extra twips.
			if( nActWidth > nTmpX + rMulti.Width() + 6 )
				nActWidth = nTmpX + rMulti.Width() + 6;
			nMaxWidth = nActWidth;
			nActWidth = ( 3 * nMaxWidth + nMinWidth + 3 ) / 4;
			if( nActWidth >= nMaxWidth )
				break;
			// we do not allow break cuts during formatting
			bFirstMulti = sal_True;
		}
		delete pNextFirst;
		pNextFirst = NULL;
	} while ( sal_True );

	pMulti = pOldMulti;

	pCurr = pOldCurr;
	nStart = nOldStart;
	SetPropFont( 0 );

	rMulti.SetLen( rMulti.GetRoot().GetLen() + ( rMulti.GetRoot().GetNext() ?
		rMulti.GetRoot().GetNext()->GetLen() : 0 ) );

	if( rMulti.IsDouble() )
	{
		((SwDoubleLinePortion&)rMulti).CalcBlanks( rInf );
		if( ((SwDoubleLinePortion&)rMulti).GetLineDiff() )
		{
			SwLineLayout* pLine = &rMulti.GetRoot();
			if( ((SwDoubleLinePortion&)rMulti).GetLineDiff() > 0 )
			{
				rInf.SetIdx( nStartIdx + pLine->GetLen() );
				pLine = pLine->GetNext();
			}
			if( pLine )
			{
				GetInfo().SetMulti( sal_True );
				CalcNewBlock( pLine, NULL, rMulti.Width() );
				GetInfo().SetMulti( sal_False );
			}
			rInf.SetIdx( nStartIdx );
		}
		if( ((SwDoubleLinePortion&)rMulti).GetBrackets() )
		{
			rMulti.Width( rMulti.Width() +
					((SwDoubleLinePortion&)rMulti).BracketWidth() );
			GetInfo().X( nOldX );
		}
	}
	else
	{
		rMulti.ActualizeTabulator();
		if( rMulti.IsRuby() )
		{
			((SwRubyPortion&)rMulti).Adjust( rInf );
			((SwRubyPortion&)rMulti).CalcRubyOffset();
		}
	}
	if( rMulti.HasRotation() )
	{
		SwTwips nH = rMulti.Width();
		SwTwips nAsc = rMulti.GetAscent() + ( nH - rMulti.Height() )/2;
		if( nAsc > nH )
			nAsc = nH;
		else if( nAsc < 0 )
			nAsc = 0;
		rMulti.Width( rMulti.Height() );
		rMulti.Height( KSHORT(nH) );
		rMulti.SetAscent( KSHORT(nAsc) );
		bRet = ( rInf.GetPos().X() + rMulti.Width() > rInf.Width() ) &&
				 nStartIdx != rInf.GetLineStart();
	}
	else if ( rMulti.IsBidi() )
	{
		bRet = rMulti.GetLen() < nMultiLen || pNextFirst;
	}

	// line break has to be performed!
	if( bRet )
	{
		ASSERT( !pNextFirst || pNextFirst->InFldGrp(),
			"BuildMultiPortion: Surprising restportion, field expected" );
		SwMultiPortion *pTmp;
		if( rMulti.IsDouble() )
			pTmp = new SwDoubleLinePortion( ((SwDoubleLinePortion&)rMulti),
											nMultiLen + rInf.GetIdx() );
		else if( rMulti.IsRuby() )
		{
			ASSERT( !pNextSecond || pNextSecond->InFldGrp(),
				"BuildMultiPortion: Surprising restportion, field expected" );

			if ( rInf.GetIdx() == rInf.GetLineStart() )
			{
				// the ruby portion has to be split in two portions
				pTmp = new SwRubyPortion( ((SwRubyPortion&)rMulti),
										  nMultiLen + rInf.GetIdx() );

				if( pNextSecond )
				{
					pTmp->GetRoot().SetNext( new SwLineLayout() );
					pTmp->GetRoot().GetNext()->SetPortion( pNextSecond );
				}
				pTmp->SetFollowFld();
			}
			else
			{
				// we try to keep our ruby portion together
				lcl_TruncateMultiPortion( rMulti, rInf, nStartIdx );
				pTmp = 0;
			}
		}
		else if( rMulti.HasRotation() )
		{
			// we try to keep our rotated portion together
			lcl_TruncateMultiPortion( rMulti, rInf, nStartIdx );
			pTmp = new SwRotatedPortion( nMultiLen + rInf.GetIdx(),
										 rMulti.GetDirection() );
		}
		// during a recursion of BuildMultiPortions we may not build
		// a new SwBidiPortion, this would cause a memory leak
		else if( rMulti.IsBidi() && ! pMulti )
		{
			if ( ! rMulti.GetLen() )
				lcl_TruncateMultiPortion( rMulti, rInf, nStartIdx );

			// If there is a HolePortion at the end of the bidi portion,
			// it has to be moved behind the bidi portion. Otherwise
			// the visual cursor traveling gets into trouble.
			SwLineLayout& aRoot = rMulti.GetRoot();
			SwLinePortion* pPor = aRoot.GetFirstPortion();
			while ( pPor )
			{
				if ( pPor->GetPortion() && pPor->GetPortion()->IsHolePortion() )
				{
					SwLinePortion* pHolePor = pPor->GetPortion();
					pPor->SetPortion( NULL );
					aRoot.SetLen( aRoot.GetLen() - pHolePor->GetLen() );
					rMulti.SetLen( rMulti.GetLen() - pHolePor->GetLen() );
					rMulti.SetPortion( pHolePor );
					break;
				}
				pPor = pPor->GetPortion();
			}

			pTmp = new SwBidiPortion( nMultiLen + rInf.GetIdx(),
									((SwBidiPortion&)rMulti).GetLevel() );
		}
		else
			pTmp = NULL;

		if ( ! rMulti.GetLen() && rInf.GetLast() )
		{
			SeekAndChgBefore( rInf );
			rInf.GetLast()->FormatEOL( rInf );
		}

		if( pNextFirst && pTmp )
		{
			pTmp->SetFollowFld();
			pTmp->GetRoot().SetPortion( pNextFirst );
		}
		else
			// A follow field portion is still waiting. If nobody wants it,
			// we delete it.
			delete pNextFirst;

		rInf.SetRest( pTmp );
	}

	rInf.SetTxt( *pOldTxt );
	rInf.SetPaintOfst( nOldPaintOfst );
	rInf.SetStop( aInf.IsStop() );
	rInf.SetNumDone( sal_True );
	rInf.SetFtnDone( sal_True );
	SeekAndChg( rInf );
	delete pFirstRest;
	delete pSecondRest;
	delete pFontSave;
	return bRet;
}

/*-----------------08.11.00 09:29-------------------
 * SwTxtFormatter::MakeRestPortion(..)
 * When a fieldportion at the end of line breaks and needs a following
 * fieldportion in the next line, then the "restportion" of the formatinfo
 * has to be set. Normally this happens during the formatting of the first
 * part of the fieldportion.
 * But sometimes the formatting starts at the line with the following part,
 * especially when the following part is on the next page.
 * In this case the MakeRestPortion-function has to create the following part.
 * The first parameter is the line that contains possibly a first part
 * of a field. When the function finds such field part, it creates the right
 * restportion. This may be a multiportion, e.g. if the field is surrounded by
 * a doubleline- or ruby-portion.
 * The second parameter is the start index of the line.
 * --------------------------------------------------*/

SwLinePortion* SwTxtFormatter::MakeRestPortion( const SwLineLayout* pLine,
	xub_StrLen nPosition )
{
	if( !nPosition )
		return NULL;
	xub_StrLen nMultiPos = nPosition - pLine->GetLen();
	const SwMultiPortion *pTmpMulti = NULL;
	const SwMultiPortion *pHelpMulti = NULL;
	const SwLinePortion* pPor = pLine->GetFirstPortion();
	SwFldPortion *pFld = NULL;
	while( pPor )
	{
		if( pPor->GetLen() )
		{
			if( !pHelpMulti )
			{
				nMultiPos = nMultiPos + pPor->GetLen();
				pTmpMulti = NULL;
			}
		}
		if( pPor->InFldGrp() )
		{
			if( !pHelpMulti )
				pTmpMulti = NULL;
			pFld = (SwFldPortion*)pPor;
		}
		else if( pPor->IsMultiPortion() )
		{
			ASSERT( !pHelpMulti || pHelpMulti->IsBidi(),
					"Nested multiportions are forbidden." );

			pFld = NULL;
			pTmpMulti = (SwMultiPortion*)pPor;
		}
		pPor = pPor->GetPortion();
		// If the last portion is a multi-portion, we enter it
		// and look for a field portion inside.
		// If we are already in a multiportion, we could change to the
		// next line
		if( !pPor && pTmpMulti )
		{
			if( pHelpMulti )
			{   // We're already inside the multiportion, let's take the second
				// line, if we are in a double line portion
				if( !pHelpMulti->IsRuby() )
					pPor = pHelpMulti->GetRoot().GetNext();
				pTmpMulti = NULL;
			}
			else
			{   // Now we enter a multiportion, in a ruby portion we take the
				// main line, not the phonetic line, in a doublelineportion we
				// starts with the first line.
				pHelpMulti = pTmpMulti;
				nMultiPos = nMultiPos - pHelpMulti->GetLen();
				if( pHelpMulti->IsRuby() && pHelpMulti->OnTop() )
					pPor = pHelpMulti->GetRoot().GetNext();
				else
					pPor = pHelpMulti->GetRoot().GetFirstPortion();
			}
		}
	}
	if( pFld && !pFld->HasFollow() )
		pFld = NULL;

	SwLinePortion *pRest = NULL;
	if( pFld )
	{
		const SwTxtAttr *pHint = GetAttr( nPosition - 1 );
		if ( pHint
			 && ( pHint->Which() == RES_TXTATR_FIELD
				  || pHint->Which() == RES_TXTATR_ANNOTATION ) )
		{
			pRest = NewFldPortion( GetInfo(), pHint );
			if( pRest->InFldGrp() )
				((SwFldPortion*)pRest)->TakeNextOffset( pFld );
			else
			{
				delete pRest;
				pRest = NULL;
			}
		}
	}
	if( !pHelpMulti )
		return pRest;

	nPosition = nMultiPos + pHelpMulti->GetLen();
	SwMultiCreator* pCreate = GetInfo().GetMultiCreator( nMultiPos, 0 );

	if ( !pCreate )
	{
		ASSERT( !pHelpMulti->GetLen(), "Multiportion without attribut?" );
		if ( nMultiPos )
			--nMultiPos;
		pCreate = GetInfo().GetMultiCreator( --nMultiPos, 0 );
	}

	if( pRest || nMultiPos > nPosition || ( pHelpMulti->IsRuby() &&
		((SwRubyPortion*)pHelpMulti)->GetRubyOffset() < STRING_LEN ) )
	{
		SwMultiPortion* pTmp;
		if( pHelpMulti->IsDouble() )
			pTmp = new SwDoubleLinePortion( *pCreate, nMultiPos );
		else if( pHelpMulti->IsBidi() )
			pTmp = new SwBidiPortion( nMultiPos, pCreate->nLevel );
		else if( pHelpMulti->IsRuby() )
		{
			sal_Bool bRubyTop;
			sal_Bool* pRubyPos = 0;

			if ( GetInfo().SnapToGrid() )
			{
				GETGRID( pFrm->FindPageFrm() )
				if ( pGrid )
				{
					bRubyTop = ! pGrid->GetRubyTextBelow();
					pRubyPos = &bRubyTop;
				}
			}

			pTmp = new SwRubyPortion( *pCreate, *GetInfo().GetFont(),
									  *pFrm->GetTxtNode()->getIDocumentSettingAccess(),
									  nMultiPos, ((SwRubyPortion*)pHelpMulti)->GetRubyOffset(),
									  pRubyPos );
		}
		else if( pHelpMulti->HasRotation() )
			pTmp = new SwRotatedPortion( nMultiPos, pHelpMulti->GetDirection() );
		else
		{
			delete pCreate;
			return pRest;
		}
		delete pCreate;
		pTmp->SetFollowFld();
		if( pRest )
		{
			SwLineLayout *pLay = &pTmp->GetRoot();
			if( pTmp->IsRuby() && pTmp->OnTop() )
			{
				pLay->SetNext( new SwLineLayout() );
				pLay = pLay->GetNext();
			}
			pLay->SetPortion( pRest );
		}
		return pTmp;
	}
	return pRest;
}


/*-----------------23.10.00 10:47-------------------
 * SwTxtCursorSave notes the start and current line of a SwTxtCursor,
 * sets them to the values for GetCrsrOfst inside a multiportion
 * and restores them in the destructor.
 * --------------------------------------------------*/

SwTxtCursorSave::SwTxtCursorSave( SwTxtCursor* pTxtCursor,
								  SwMultiPortion* pMulti,
								  SwTwips nY,
								  sal_uInt16& nX,
								  xub_StrLen nCurrStart,
								  long nSpaceAdd )
{
	pTxtCrsr = pTxtCursor;
	nStart = pTxtCursor->nStart;
	pTxtCursor->nStart = nCurrStart;
	pCurr = pTxtCursor->pCurr;
	pTxtCursor->pCurr = &pMulti->GetRoot();
	while( pTxtCursor->Y() + pTxtCursor->GetLineHeight() < nY &&
		pTxtCursor->Next() )
		; // nothing
	nWidth = pTxtCursor->pCurr->Width();
	nOldProp = pTxtCursor->GetPropFont();

	if ( pMulti->IsDouble() || pMulti->IsBidi() )
	{
		bSpaceChg = pMulti->ChgSpaceAdd( pTxtCursor->pCurr, nSpaceAdd );

		sal_uInt16 nSpaceCnt;
		if ( pMulti->IsDouble() )
		{
			pTxtCursor->SetPropFont( 50 );
			nSpaceCnt = ((SwDoubleLinePortion*)pMulti)->GetSpaceCnt();
		}
		else
		{
			const xub_StrLen nOldIdx = pTxtCursor->GetInfo().GetIdx();
			pTxtCursor->GetInfo().SetIdx ( nCurrStart );
			nSpaceCnt = ((SwBidiPortion*)pMulti)->GetSpaceCnt(pTxtCursor->GetInfo());
			pTxtCursor->GetInfo().SetIdx ( nOldIdx );
		}

		if( nSpaceAdd > 0 && !pMulti->HasTabulator() )
			pTxtCursor->pCurr->Width( static_cast<sal_uInt16>(nWidth + nSpaceAdd * nSpaceCnt / SPACING_PRECISION_FACTOR ) );

		// For a BidiPortion we have to calculate the offset from the
		// end of the portion
		if ( nX && pMulti->IsBidi() )
			nX = pTxtCursor->pCurr->Width() - nX;
	}
	else
		bSpaceChg = sal_False;
}

SwTxtCursorSave::~SwTxtCursorSave()
{
	if( bSpaceChg )
		SwDoubleLinePortion::ResetSpaceAdd( pTxtCrsr->pCurr );
	pTxtCrsr->pCurr->Width( KSHORT(nWidth) );
	pTxtCrsr->pCurr = pCurr;
	pTxtCrsr->nStart = nStart;
	pTxtCrsr->SetPropFont( nOldProp );
}

/* vim: set noet sw=4 ts=4: */