LanguageType SwEnhancedPDFExportHelper::eLanguageDefault = 0;

static std::vector< USHORT > aStructStack;

if ( mpPDFExtOutDevData && mpPDFExtOutDevData->GetIsExportTaggedPDF() )

{

sal_Int32 nCurrentStruct = mpPDFExtOutDevData->GetCurrentStructureElement();

lcl_DBGCheckStack();

#endif

else

BeginTag( vcl::PDFWriter::NonStructElement, aEmptyString );

nCurrentStruct = mpPDFExtOutDevData->GetCurrentStructureElement();

lcl_DBGCheckStack();

#endif

{

if ( mpPDFExtOutDevData && mpPDFExtOutDevData->GetIsExportTaggedPDF() )

{

sal_Int32 nCurrentStruct = mpPDFExtOutDevData->GetCurrentStructureElement();

lcl_DBGCheckStack();

#endif

EndStructureElements();

nCurrentStruct = mpPDFExtOutDevData->GetCurrentStructureElement();

lcl_DBGCheckStack();

#endif

{

nRestoreCurrentTag = mpPDFExtOutDevData->GetCurrentStructureElement();

const bool bSuccess = mpPDFExtOutDevData->SetCurrentStructureElement( nReopenTag );

aStructStack.push_back( 99 );

#endif

{

const bool bSuccess = mpPDFExtOutDevData->SetCurrentStructureElement( nRestoreCurrentTag );

(void)bSuccess;

aStructStack.pop_back();

#endif

const sal_Int32 nId = mpPDFExtOutDevData->BeginStructureElement( eType, rtl::OUString( rString ) );

++nEndStructureElement;

aStructStack.push_back( static_cast<USHORT>(eType) );

#endif

{

mpPDFExtOutDevData->EndStructureElement();

aStructStack.pop_back();

#endif

}

if ( bTextIndent )

{

const SvxLRSpaceItem &rSpace =

static_cast<const SwTxtFrm*>(pFrm)->GetTxtNode()->GetSwAttrSet().GetLRSpace();

nVal = rSpace.GetTxtFirstLineOfst();

if ( bTextAlign )

{

const SwAttrSet& aSet = static_cast<const SwTxtFrm*>(pFrm)->GetTxtNode()->GetSwAttrSet();

const SvxAdjust nAdjust = aSet.GetAdjust().GetAdjust();

if ( SVX_ADJUST_BLOCK == nAdjust || SVX_ADJUST_CENTER == nAdjust ||

if ( bAlternateText )

{

const SwFlyFrm* pFly = static_cast<const SwFlyFrm*>(pFrm);

if ( pFly->Lower() && pFly->Lower()->IsNoTxtFrm() )

{

const TableColumnsMapEntry::const_iterator aLeftIter = rCols.find( nLeft );

const TableColumnsMapEntry::const_iterator aRightIter = rCols.find( nRight );

if ( aLeftIter != rCols.end() && aRightIter != rCols.end() )

{

nVal = std::distance( aLeftIter, aRightIter );

*/

void SwTaggedPDFHelper::BeginNumberedListStructureElements()

{

if ( !mpNumInfo )

return;

const SwFrm& rFrm = mpNumInfo->mrFrm;

const SwTxtFrm& rTxtFrm = static_cast<const SwTxtFrm&>(rFrm);

//

nRestoreCurrentTag = mpPDFExtOutDevData->GetCurrentStructureElement();

mpPDFExtOutDevData->SetCurrentStructureElement( nReopenTag );

aStructStack.push_back( 99 );

#endif

}

aNumListBodyIdMap.clear();

aFrmTagIdMap.clear();

aStructStack.clear();

#endif

{

const SwTxtNode* pTNd =

(SwTxtNode*)((SwFmtFld*)pFirst)->GetTxtFld()->GetpTxtNode();

// 1. Check if the whole paragraph is hidden

// 2. Move to the field

for( sal_uInt16 n = 0; n < nHyperLinkCount; ++n )

{

SwGetINetAttr* p = aArr[ n ];

const SwTxtNode* pTNd = p->rINetAttr.GetpTxtNode();

// 1. Check if the whole paragraph is hidden

// 2. Move to the hyperlink

// be deleted again in JumpToSwMark.

SwRects aTmp;

aTmp.Insert( mrSh.SwCrsrShell::_GetCrsr(), 0 );

// Create the destination for internal links:

sal_Int32 nDestId = -1;

{

const SwTxtNode* pTNd =

(SwTxtNode*)((SwFmtFld*)pFirst)->GetTxtFld()->GetpTxtNode();

// 1. Check if the whole paragraph is hidden

// 2. Move to the field

// Link Rectangles

SwRects aTmp;

aTmp.Insert( mrSh.SwCrsrShell::_GetCrsr(), 0 );

mrSh.SwCrsrShell::ClearMark();

// Link Rectangle

SwRects aTmp;

aTmp.Insert( mrSh.SwCrsrShell::_GetCrsr(), 0 );

const SwRect aLinkRect( aTmp[ 0 ] );

mrSh._GetCrsr()->RestoreSavePos();

{

// Check if outline is hidden

const SwTxtNode* pTNd = mrSh.GetNodes().GetOutLineNds()[ i ]->GetTxtNode();

if ( pTNd->IsHidden() ||

// --> FME 2005-01-10 #i40292# Skip empty outlines:

inline const SfxPoolItem& SwAttrHandler::GetDefault( const USHORT nAttribID ) const

{

"this attrib does not ex."

);

return *pDefaultArray[ StackPos[ nAttribID ] ];

}

inline void SwAttrHandler::ResetFont( SwFont& rFnt ) const

{

if ( pFnt )

rFnt = *pFnt;

};

}

}

if ( nPos < nCount )

memmove( pArray + nPos + 1, pArray + nPos,

sal_Bool SwAttrHandler::Push( const SwTxtAttr& rAttr, const SfxPoolItem& rItem )

{

"I do not want this attribute, nWhich >= RES_TXTATR_WITHEND_END" );

// robust

}

USHORT nPos = aAttrStack[ nStack ].Count();

aAttrStack[ nStack ].Insert( rAttr, nPos - 1 );

return sal_False;

}

void SwAttrHandler::Pop( const SwTxtAttr& rAttr )

{

"I do not have this attribute, nWhich >= RES_TXTATR_WITHEND_END" );

if ( rAttr.Which() < RES_TXTATR_WITHEND_END )

*************************************************************************/

void SwAttrHandler::ActivateTop( SwFont& rFnt, const USHORT nAttr )

{

"I cannot activate this attribute, nWhich >= RES_TXTATR_WITHEND_END" );

const USHORT nStackPos = StackPos[ nAttr ];

void SwAttrHandler::GetDefaultAscentAndHeight( ViewShell* pShell, OutputDevice& rOut,

USHORT& nAscent, USHORT& nHeight ) const

{

if ( pFnt )

{

pFrmAtPos->GetFormatted();

pFrmAtPos = pFrmAtPos->FindMaster();

}

}

return pFrmAtPos ? pFrmAtPos : pFrm;

}

sal_Bool lcl_ChangeOffset( SwTxtFrm* pFrm, xub_StrLen nNew )

{

// In Bereichen und ausserhalb von Flies wird nicht mehr gescrollt.

if( pFrm->GetOfst() != nNew && !pFrm->IsInSct() )

{

SwFlyFrm *pFly = pFrm->FindFlyFrm();

sal_Bool SwTxtFrm::GetCharRect( SwRect& rOrig, const SwPosition &rPos,

SwCrsrMoveState *pCMS ) const

{

if( IsLocked() || IsHiddenNow() )

return sal_False;

if( bRet )

{

SwPageFrm *pPage = pFrm->FindPageFrm();

const SwTwips nOrigTop = (rOrig.*fnRect->fnGetTop)();

const SwTwips nPageTop = (pPage->Frm().*fnRect->fnGetTop)();

const SwTwips nPageBott = (pPage->Frm().*fnRect->fnGetBottom)();

aCharBox.Pos().X() = aCharBox.Pos().X() - 150;

// siehe Kommentar in SwTxtFrm::GetCrsrOfst()

const ULONG nOldNode = pPam->GetPoint()->nNode.GetIndex();

#endif

// Der Node soll nicht gewechselt werden

xub_StrLen nTmpOfst = aLine.GetCrsrOfst( pPam->GetPoint(),

aCharBox.Pos(), sal_False );

// 7684: Wir stellen sicher, dass wir uns nach oben bewegen.

if( nTmpOfst >= nStart && nStart && !bSecondOfDouble )

if( pNextLine || bFirstOfDouble )

{

aCharBox.SSize().Width() /= 2;

// siehe Kommentar in SwTxtFrm::GetCrsrOfst()

const ULONG nOldNode = pPam->GetPoint()->nNode.GetIndex();

#endif

xub_StrLen nTmpOfst = aLine.GetCrsrOfst( pPam->GetPoint(),

aCharBox.Pos(), sal_False );

// 7684: Wir stellen sicher, dass wir uns nach unten bewegen.

if( nTmpOfst <= nStart && ! bFirstOfDouble )

ValidateTxt( this );

//MA: mindestens das MustFit-Flag muessen wir retten!

SwParaPortion *pPara = GetPara();

const sal_Bool bMustFit = pPara->IsPrepMustFit();

ResetPreps();

{

SWAP_IF_NOT_SWAPPED( this )

SwTxtSizeInfo aInf( (SwTxtFrm*)this );

SwTxtMargin aLine( (SwTxtFrm*)this, &aInf );

if( aLine.GetDropLines() )

{

SWAP_IF_SWAPPED( this )

SwTxtFrm* pMyFollow = GetFollow();

( pMyFollow->IsVertical() && !pMyFollow->Prt().Width() ) ||

( ! pMyFollow->IsVertical() && !pMyFollow->Prt().Height() ) )

{

const SwFrm *pOldUp = GetUpper();

#endif

pMyFollow->Calc();

// Der Follow merkt anhand seiner Frm().Height(), dass was schief

// gelaufen ist.

if( pMyFollow->GetPrev() )

{

pMyFollow->Prepare( PREP_CLEAR );

pMyFollow->Calc();

}

// OD 14.03.2003 #i11760# - reset control flag for follow format.

pPage->ValidateCntnt();

}

#endif

const long nRemaining =

SwTwips nRstHeight;

if ( IsVertical() )

{

nRstHeight = Frm().Left() + Frm().Width() -

( GetUpper()->Frm().Left() + GetUpper()->Prt().Left() );

}

{

long nAdd = (*fnRect->fnYDiff)( (GetUpper()->Lower()->Frm().*fnRect->fnGetTop)(),

(GetUpper()->*fnRect->fnGetPrtTop)() );

nRstHeight += nAdd;

}

{

if( ((SwTxtFrm*)GetFollow())->IsLocked() )

{

return;

}

JoinFrm();

SwCntntFrm *SwTxtFrm::JoinFrm()

{

SwTxtFrm *pFoll = GetFollow();

SwTxtFrm *pNxt = pFoll->GetFollow();

}

}

else if ( pFoll->GetValidPrtAreaFlag() ||

pFoll->GetValidSizeFlag() )

{

pFoll->CalcFtnFlag();

}

#endif

}

}

else

{

CalcFtnFlag( nTxtPos-1 );

}

#endif

#ifdef DBGTXT

// Es gibt tatsaechlich einen Sonderfall, in dem ein SetOfst(0)

// zulaessig ist: bug 3496

#endif

// Die Invalidierung unseres Follows ist nicht noetig.

sal_Bool SwTxtFrm::CalcPreps()

{

SWRECTFN( this );

SwParaPortion *pPara = GetPara();

{

if( !GetFollow() )

{

return sal_False;

}

}

else

{

"+SwTxtFrm::CalcPrep: wanna shrink" );

nChgHeight = (Prt().*fnRect->fnGetHeight)() - nChgHeight;

sal_Bool SwTxtFrm::FormatLine( SwTxtFormatter &rLine, const sal_Bool bPrev )

{

"SwTxtFrm::FormatLine( rLine, bPrev) with unswapped frame" );

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

// Nach rLine.FormatLine() haelt nStart den neuen Wert,

const xub_StrLen nNewStart = rLine.FormatLine( rLine.GetStart() );

"SwTxtFrm::FormatLine: frame leaves orbit." );

"SwTxtFrm::FormatLine: line height is zero" );

// Das aktuelle Zeilenumbruchobjekt.

void SwTxtFrm::_Format( SwTxtFormatter &rLine, SwTxtFormatInfo &rInf,

const sal_Bool bAdjust )

{

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

rLine.SetUnclipped( sal_False );

const SwLineLayout* pLine;

{

SwTxtFrm *pMaster = FindMaster();

if( !pMaster->HasPara() )

pMaster->GetFormatted();

SwTxtSizeInfo aInf( pMaster );

void SwTxtFrm::FormatOnceMore( SwTxtFormatter &rLine, SwTxtFormatInfo &rInf )

{

"A frame is not swapped in SwTxtFrm::FormatOnceMore" );

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

pPara->SetPrepMustFit( bMustFit );

}

if ( IsVertical() )

SwapWidthAndHeight();

if ( IsVertical() )

SwapWidthAndHeight();

if( 1 < aLine.GetDropLines() )

{

const SwFrm *pDbgFtnCont = (const SwFrm*)(FindPageFrm()->FindFtnCont());

(void)pDbgFtnCont;

// nStopAt laesst sich vom CV bearbeiten.

static MSHORT nStopAt = 0;

if( nStopAt == GetFrmId() )

if( nFtnPageNr > nDbgPageNr )

{

SwTxtFrmLocker aLock(this);

MSHORT i = 0;

}

}

else if( bSetOfst && IsFollow() )

{

SwTxtFrm *pMaster = FindMaster();

if( pMaster )

pMaster->Prepare( PREP_FOLLOW_FOLLOWS );

SwTwips nMaxY = (GetUpper()->*fnRect->fnGetPrtBottom)();

sal_Bool SwTxtFrm::FormatQuick( bool bForceQuickFormat )

{

"SwTxtFrm::FormatQuick with swapped frame" );

DBG_LOOP;

const XubString aXXX = GetTxtNode()->GetTxt();

const SwTwips nDbgY = Frm().Top();

(void)nDbgY;

// nStopAt laesst sich vom CV bearbeiten.

static MSHORT nStopAt = 0;

if( nStopAt == GetFrmId() )

//DBG_LOOP; shadows declaration above.

//resolved into:

#if OSL_DEBUG_LEVEL > 1

DbgLoop aDbgLoop2( (const void*) this );

#endif

#endif

if( !bForceQuickFormat && nNewHeight != nOldHeight && !IsUndersized() )

{

// Achtung: Durch FormatLevel==12 kann diese Situation auftreten, don't panic!

const xub_StrLen nStrt = GetOfst();

_InvalidateRange( SwCharRange( nStrt, nEnd - nStrt) );

return sal_False;

nDivider = rLineInf.GetDivider().Len() ? rLineInf.GetDividerCountBy() : 0;

nX = pFrm->Frm().Left();

SwCharFmt* pFmt = rLineInf.GetCharFmt( const_cast<IDocumentStylePoolAccess&>(*pFrm->GetNode()->getIDocumentStylePoolAccess()) );

pFnt = new SwFont( &pFmt->GetAttrSet(), pFrm->GetTxtNode()->getIDocumentSettingAccess() );

pFnt->Invalidate();

pFnt->ChgPhysFnt( pSh, *pSh->GetOut() );

#endif

// finger layout

SwRect aRet( Prt() );

if ( IsEmpty() || !HasPara() )

//Informationen entzogen hat.

if( !HasPara() )

{

// --> FME 2004-10-29 #i29062# pass info that we are currently

// painting.

}

if( !HasPara() )

{

return;

}

}

// die Laenge ist immer wieder interessant.

// Rectangle

SwRect aOldRect( rRect );

SWAP_IF_NOT_SWAPPED( this )

//DBG_LOOP; shadows declaration above.

//resolved into:

#if OSL_DEBUG_LEVEL > 1

DbgLoop aDbgLoop2( (const void*) this );

#endif

#endif

UNDO_SWAP( this )

(SwRect&)rRect = aOldRect;

}

}

#include <ctype.h>

#include <editeng/unolingu.hxx>

#include <tools/shl.hxx> // needed for SW_MOD() macro

#include <dlelstnr.hxx>

#include <swmodule.hxx>

#include <IDocumentSettingAccess.hxx>

if( !rInf.GetLen() || !rInf.GetTxt().Len() )

return sal_False;

"+SwTxtGuess::Guess: invalid SwTxtFormatInfo" );

USHORT nMinSize;

USHORT nMaxSizeDiff;

{

nCutPos = rInf.GetTxtBreak( nLineWidth, nMaxLen, nMaxComp );

if ( STRING_LEN != nCutPos )

{

rInf.GetTxtSize( &rSI, rInf.GetIdx(), nCutPos - rInf.GetIdx(),

nMaxComp, nMinSize, nMaxSizeDiff );

}

#endif

}

{

USHORT nScript = pBreakIt->GetRealScriptOfText( rInf.GetTxt(),

nLangIndex );

// compare current script with script from last "real" character

if ( nScript - 1 != rInf.GetFont()->GetActual() )

}

else if ( !bHyph && nBreakPos >= rInf.GetLineStart() )

{

// found break position within line

xHyphWord = NULL;

// no line break found, setting nBreakPos to STRING_LEN

// causes a break cut

nBreakPos = STRING_LEN;

nPorLen = nCutPos - rInf.GetIdx();

}

const xub_StrLen nHangingLen = nBreakPos - nCutPos;

SwPosSize aTmpSize = rInf.GetTxtSize( &rSI, nCutPos,

nHangingLen, 0 );

pHanging = new SwHangingPortion( aTmpSize );

pHanging->SetLen( nHangingLen );

nPorLen = nCutPos - rInf.GetIdx();

nBreakPos = nOldIdx - 1;

else if ( STRING_LEN != nBreakPos )

{

nBreakPos = nBreakPos - nFieldDiff;

}

"I've got field trouble, part2!" );

nCutPos = nCutPos - nFieldDiff;

rInf.SetIdx( nOldIdx );

#if OSL_DEBUG_LEVEL > 1

"Somebody, somebody, somebody put something in my string" );

#endif

}

// check, if word has alternative spelling

Reference< XHyphenator > xHyph( ::GetHyphenator() );

//! subtract 1 since the UNO-interface is 0 based

xHyphWord = xHyph->queryAlternativeSpelling( OUString(aTxt),

pBreakIt->GetLocale( rInf.GetFont()->GetLanguage() ),

nTxtStart = pFrm->GetOfst();

if( !pPara )

{

pFrm->Format();

pPara = pFrm->GetPara();

}

{ }

/*************************************************************************

* ChkOutDev()

*************************************************************************/

const OutputDevice* pOut = rInf.GetOut();

const OutputDevice* pRef = rInf.GetRefDev();

}

#endif // PRODUCT

bSnapToGrid( rNew.SnapToGrid() ),

nDirection( rNew.GetDirection() )

{

ChkOutDev( *this );

#endif

}

pRef = pOut;

}

ChkOutDev( *this );

#endif

bSnapToGrid( rNew.SnapToGrid() ),

nDirection( rNew.GetDirection() )

{

ChkOutDev( *this );

#endif

SetLen( GetMinLen( *this ) );

if( OnWin() )

SwRootFrm::FlushVout();

}

/*************************************************************************

const SwScriptInfo& rScriptInfo =

( (SwParaPortion*)GetParaPortion() )->GetScriptInfo();

SwDrawTextInfo aDrawInf( pVsh, *pOut, &rScriptInfo,

*pTxt, GetIdx(), nMaxLen );

aDrawInf.SetFrm( pFrm );

const SwScriptInfo& rScriptInfo =

( (SwParaPortion*)GetParaPortion() )->GetScriptInfo();

SwDrawTextInfo aDrawInf( pVsh, *pOut, &rScriptInfo,

*pTxt, GetIdx(), nMaxLen );

aDrawInf.SetFrm( pFrm );

pGrammarCheckList = NULL;

pSmartTags = NULL; // SMARTTAGS

pBrushItem = ((SvxBrushItem*)-1);

#endif

}

const sal_Bool bTmpGrammarCheck = bGrammarCheck && OnWin() && bCfgIsAutoGrammar && GetOpt().IsOnlineSpell();

const sal_Bool bTmpSmart = bSmartTag && OnWin() && !GetOpt().IsPagePreview() && SwSmartTagMgr::Get().IsSmartTagsEnabled(); // SMARTTAGS

SwDrawTextInfo aDrawInf( pFrm->GetShell(), *pOut, pSI, rText, nStart, nLength,

rPor.Width(), bBullet );

nMaxWidth = rRect.Height();

break;

default:

break;

}

pOut->DrawRect( rRect.SVRect() );

else

{

::DrawGraphic( pBrushItem, pOut, aItemRect, rRect );

}

}

*************************************************************************/

void SwTxtPaintInfo::DrawBackground( const SwLinePortion &rPor ) const

{

SwRect aIntersect;

CalcRect( rPor, 0, &aIntersect );

}

if( !pFnt->GetBackColor() ) return;

SwRect aIntersect;

CalcRect( rPor, 0, &aIntersect );

case POR_BLANK: if ( GetOpt().IsHardBlank())bDraw = sal_True; break;

default:

{

break;

}

}

void SwTxtPaintInfo::_NotifyURL( const SwLinePortion &rPor ) const

{

SwRect aIntersect;

CalcRect( rPor, 0, &aIntersect );

{

if( cTabDec == cPos )

{

if( cPos ) // robust

{

cHookChar = cPos;

void _DrawBackBrush( const SwLinePortion &rPor ) const;

protected:

SwTxtPaintInfo() { pFrm = 0; pWrongList = 0; pGrammarCheckList = 0; pSmartTags = 0; pSpaceAdd = 0;

pBrushItem = ((SvxBrushItem*)-1);}

#endif

public:

SwTxtPaintInfo( const SwTxtPaintInfo &rInf );

inline KSHORT SwTxtSizeInfo::GetAscent() const

{

return ((SwFont*)GetFont())->GetAscent( pVsh, *GetOut() );

}

inline KSHORT SwTxtSizeInfo::GetTxtHeight() const

{

return ((SwFont*)GetFont())->GetHeight( pVsh, *GetOut() );

}

void SwTxtAdjuster::CalcNewBlock( SwLineLayout *pCurrent,

const SwLinePortion *pStopAt, SwTwips nReal, bool bSkipKashida )

{

"CalcNewBlock: Why?" );

pCurrent->InitSpaceAdd();

xub_StrLen nGluePortion = 0;

SwTwips SwTxtAdjuster::CalcKanaAdj( SwLineLayout* pCurrent )

{

SvUShorts *pNewKana = new SvUShorts;

pCurrent->SetKanaComp( pNewKana );

void SwTxtAdjuster::CalcAdjLine( SwLineLayout *pCurrent )

{

pCurrent->SetFormatAdj(sal_False);

void SwTxtAdjuster::CalcDropAdjust()

{

const MSHORT nLineNumber = GetLineNr();

void SwAttrIter::Chg( SwTxtAttr *pHt )

{

if( pRedln && pRedln->IsOn() )

pRedln->ChangeTxtAttr( pFnt, *pHt, sal_True );

else

void SwAttrIter::Rst( SwTxtAttr *pHt )

{

// get top from stack after removing pHt

if( pRedln && pRedln->IsOn() )

pRedln->ChangeTxtAttr( pFnt, *pHt, sal_False );

{

const SwMinMaxNodeArgs *pIn = (const SwMinMaxNodeArgs*)pArgs;

const SwPosition *pPos = rFmtA.GetCntntAnchor();

if (!pPos || !pIn || pIn->nIndx != pPos->nNode.GetIndex())

bCalculate = false;

}

pOut = getIDocumentDeviceAccess()->getReferenceDevice( true );

}

MapMode aOldMap( pOut->GetMapMode() );

pOut->SetMapMode( MapMode( MAP_TWIP ) );

const SwCrsrMoveState& rCMS,

const SwLinePortion& rPor )

{

if ( rPor.InFldGrp() && ((SwFldPortion&)rPor).GetExp().Len() )

{

} while ( TRUE );

USHORT nLen = nCharOfst - nFldIdx + 1;

if ( pString )

case SVX_LINE_SPACE_FIX:

nFirstLineOfs = pSpace->GetLineHeight();

break;

}

switch( pSpace->GetInterLineSpaceRule() )

{

nFirstLineOfs += pSpace->GetInterLineSpace();

break;

}

}

}

}

pCMS->aRealHeight.X() = nTmpAscent - nPorAscent;

else

pCMS->aRealHeight.X() = 0;

pCMS->aRealHeight.Y() = nPorHeight;

}

if( pPor )

{

sal_Bool bEmptyFld = sal_False;

if( pPor->InFldGrp() && pPor->GetLen() )

{

SwLinePortion *pNext = pTmp->GetPortion();

while( pNext && !pNext->InFldGrp() )

{

nAddX = nAddX + pNext->Width();

pNext = pNext->GetPortion();

}

const SwLinePortion *pLast = rLineLayout.FindLastPortion();

if ( pLast->IsMultiPortion() )

{

pOrig->Pos().X() += pLast->Width() +

pLast->CalcSpacing( nSpaceAdd, aInf );

}

pCMS->aRealHeight.X() = nTmpAscent - nPorAscent;

else

pCMS->aRealHeight.X() = 0;

if ( nTmpHeight > nPorHeight )

pCMS->aRealHeight.Y() = nPorHeight;

else

{

const BYTE nExtendRange = pCMS->pSpecialPos->nExtendRange;

// portions which are behind the string

if ( SP_EXTEND_RANGE_BEHIND == nExtendRange )

((SwDropPortion*)pPor)->GetFnt() : NULL );

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

SwDrawTextInfo aDrawInf( aSizeInf.GetVsh(),

*aSizeInf.GetOut(),

if( nStart > GetInfo().GetTxt().Len() )

{

nStart = GetInfo().GetTxt().Len();

}

pTmpPrev->Move( rInf );

rInf.SetLast( pTmpPrev );

pTmpPrev = pTmpPrev->GetPortion();

};

}

pPor = pPor->GetPortion();

}

// Was? Die Unterlaufsituation ist nicht in der Portion-Kette ?

// OD 2004-05-26 #i29529# - correction: no delete of footnotes

// if( rInf.IsFtnInside() && pPor && !rInf.IsQuick() )

void SwTxtFormatter::BuildPortions( SwTxtFormatInfo &rInf )

{

"SwTxtFormatter::BuildPortions: bad text length in info" );

rInf.ChkNoHyph( CntEndHyph(), CntMidHyph() );

rInf.SetLast( pCurr );

rInf.ForcedLeftMargin( 0 );

if( !pCurr->GetAscent() && !pCurr->Height() )

CalcAscent( rInf, pCurr );

SeekAndChg( rInf );

// In CalcFlyWidth wird Width() verkuerzt, wenn eine FlyPortion vorliegt.

CalcFlyWidth( rInf );

SwFlyPortion *pFly = rInf.GetFly();

if( pFly )

while( pPor && !rInf.IsStop() )

{

rInf.GetIdx() <= rInf.GetTxt().Len(),

"SwTxtFormatter::BuildPortions: bad length in info" );

DBG_LOOP;

if ( nRestWidth > 0 && SW_CJK != nCurrScript &&

! rInf.IsUnderFlow() && ( bFull || SW_CJK == nNextScript ) )

{

// calculate size

SwLinePortion* pTmpPor = pGridKernPortion->GetPortion();

nRestWidth );

const USHORT nKernWidth_1 = (USHORT)(nKernWidth / 2);

pGridKernPortion->Width( pGridKernPortion->Width() + nKernWidth_1 );

rInf.X( rInf.X() + nKernWidth_1 );

// 5) Die Fussnotenzahlen

if( !rInf.IsFtnDone() )

{

sal_Bool bFtnNum = pFrm->IsFtnNumFrm();

rInf.GetParaPortion()->SetFtnNum( bFtnNum );

// 7) Die Numerierungen

if( !rInf.IsNumDone() && !pPor )

{

// Wenn wir im Follow stehen, dann natuerlich nicht.

if( GetTxtFrm()->GetTxtNode()->GetNumRule() )

rInf.SetStopUnderFlow( sal_False );

if( rInf.GetUnderFlow() )

{

return UnderFlow( rInf );

}

if ( GetTxtFrm()->GetTxtNode()->getIDocumentSettingAccess()->get(IDocumentSettingAccess::TAB_COMPAT) /*rInf.GetVsh()->IsTabCompat();*/ &&

POR_TABDECIMAL == pLastTabPortion->GetWhichPor() )

{

const USHORT nWidthOfPortionsUpToDecimalPosition = (USHORT)(rInf.X() - pLastTabPortion->Fix() );

static_cast<SwTabDecimalPortion*>(pLastTabPortion)->SetWidthOfPortionsUpToDecimalPosition( nWidthOfPortionsUpToDecimalPosition );

rInf.SetTabDecimal( 0 );

// Werte bereithalten muss:

if( !pCurr->Height() )

{

pCurr->Height( pPor->Height() );

pCurr->SetAscent( pPor->GetAscent() );

}

"SwTxtFormatter::NewPortion: something went wrong");

if( pPor->IsPostItsPortion() && rInf.X() >= rInf.Width() && rInf.GetFly() )

{

xub_StrLen SwTxtFormatter::FormatLine( const xub_StrLen nStartPos )

{

"SwTxtFormatter::FormatLine( nStartPos ) with unswapped frame" );

// For the formatting routines, we set pOut to the reference device.

pInf->GetParaPortion()->SetFixLineHeight();

}

break;

}

if( !IsParaLine() )

switch( pSpace->GetInterLineSpaceRule() )

nLineHeight = nLineHeight + pSpace->GetInterLineSpace();

break;

}

}

}

#if OSL_DEBUG_LEVEL > 1

CH_BLANK == GetInfo().GetChar( nReformat ) )

--nReformat;

SwRect aRect;

// Note: GetChareRect is not const. It definitely changes the

pInf = pNewInf;

SwFont *pMyFnt = GetFnt();

GetInfo().SetFont( pMyFnt );

if( ALIGN_BASELINE != pMyFnt->GetAlign() )

{

"+SwTxtPainter::CTOR: font alignment revolution" );

pMyFnt->SetAlign( ALIGN_BASELINE );

}

Range aRange( 0, GetInfo().GetTxt().Len() );

MultiSelection aUnderMulti( aRange );

const SwFont* pParaFnt = GetAttrHandler().GetFont();

if( pParaFnt && pParaFnt->GetUnderline() == GetFnt()->GetUnderline() )

aUnderMulti.SelectAll();

SwTxtNode *pNode = pNewFrm->GetTxtNode();

CtorInitAttrIter( *pNode, pNewFrm->GetPara()->GetScriptInfo(), pNewFrm );

nOfst = nOfst + nPorAscent;

break;

case SvxParaVertAlignItem::CENTER :

nOfst += ( rLine.Height() - nPorHeight ) / 2 + nPorAscent;

break;

case SvxParaVertAlignItem::BOTTOM :

pOut( rInfo.GetOut() ),

bOnWin( rInfo.OnWin() )

{

// set new values

rInfo.SetOut( rInfo.GetRefDev() );

$(SLO)$/SwGrammarMarkUp.obj \

$(SLO)$/wrong.obj

SLOFILES += \

$(SLO)$/txtio.obj

.ENDIF

void SwNoteURL::FillImageMap( ImageMap *pMap, const Point &rPos,

const MapMode& rMap )

{

MSHORT nCount = Count();

if( nCount )

{

void SwFldPortion::TakeNextOffset( const SwFldPortion* pFld )

{

nNextOffset = pFld->GetNextOffset();

aExpand.Erase( 0, nNextOffset );

bFollow = sal_True;

{

SwFontSave aSave( rInf, pFnt );

if( Width() && ( !bPlaceHolder || rInf.GetOpt().IsShowPlaceHolderFields() ) )

{

// Dies ist eine freizuegige Auslegung der Hintergrundbelegung ...

if( rInf.IsNumDone() )

{

// SetAscent( rInf.GetAscent() );

long nDiff( 0 );

// --> OD 2008-01-23 #newlistlevelattrs#

void SwTxtFrm::StopAnimation( OutputDevice* pOut )

{

if( HasPara() )

{

SwLineLayout *pLine = GetPara();

void SwCombinedPortion::Paint( const SwTxtPaintInfo &rInf ) const

{

if( Width() )

{

rInf.DrawBackBrush( *this );

USHORT nCount = aExpand.Len();

if( !nCount )

return;

// the first character of the second row

USHORT nTop = ( nCount + 1 ) / 2;

return sal_False;

}

// If there are leading "weak"-scripttyped characters in this portion,

// they get the actual scripttype.

USHORT i = 0;

i = 0;

while( i < aExpand.Len() )

{

if( !aWidth[ aScrType[i] ] )

{

rInf.GetOut()->SetFont( rInf.GetFont()->GetFnt( aScrType[i] ) );

*************************************************************************/

sal_Bool SwFlyPortion::Format( SwTxtFormatInfo &rInf )

{

// 8537: Tabs muessen expandiert werden.

if( rInf.GetLastTab() )

((SwLinePortion*)rInf.GetLastTab())->FormatEOL( rInf );

PrtWidth( static_cast<USHORT>(Fix() - rInf.X() + PrtWidth()) );

if( !Width() )

{

Width(1);

}

xub_StrLen SwTxtFrm::CalcFlyPos( SwFrmFmt* pSearch )

{

SwpHints* pHints = GetTxtNode()->GetpSwpHints();

if( !pHints )

return STRING_LEN;

SwTxtAttr* pFound = NULL;

pFound = pHt;

}

}

if( !pFound )

return STRING_LEN;

return *pFound->GetStart();

((SwTxtPaintInfo&)rInf).SelectFont();

// I want to know if this can really happen. So here comes a new

if( rInf.GetVsh() )

((SwTxtPaintInfo&)rInf).SetOut( rInf.GetVsh()->GetOut() );

}

bMax( sal_False ),

nAlign( 0 )

{

nLineLength = 1;

nFlags |= AS_CHAR_ULSPACE | AS_CHAR_INIT;

SetBase( rFrm, rBase, nLnAscent, nLnDescent, nFlyAsc, nFlyDesc, nFlags );

bMax( sal_False ),

nAlign( 0 )

{

if( !pDrawContact->GetAnchorFrm() )

{

// OD 2004-04-01 #i26791# - no direct positioning needed any more

pSdrObj = GetDrawContact()->GetDrawObjectByAnchorFrm( rFrm );

if ( !pSdrObj )

{

pSdrObj = GetDrawContact()->GetMaster();

}

// --> OD 2007-11-29 #i65798#

xub_StrLen SwFlyCntPortion::GetCrsrOfst( const KSHORT nOfst ) const

{

return SwLinePortion::GetCrsrOfst( nOfst );

}

if( rInf.OnWin() && rInf.GetOpt().IsBlank() && rInf.IsNoSymbol() )

{

const xub_Unicode cChar = rInf.GetChar( rInf.GetIdx() );

"SwGluePortion::Paint: blank expected" );

#endif

if( 1 == GetLen() )

while( pPos )

{

DBG_LOOP;

"SwLineLayout::CalcLine: don't use SwLinePortions !" );

// Null-Portions werden eliminiert. Sie koennen entstehen,

KSHORT nPosHeight = pPos->Height();

KSHORT nPosAscent = pPos->GetAscent();

"SwLineLayout::CalcLine: bad ascent or height" );

if( pPos->IsHangingPortion() )

// Robust:

if( nLineWidth < Width() )

Width( nLineWidth );

SetDummy( bTmpDummy );

SetRedline( rLine.GetRedln() &&

rLine.GetRedln()->CheckLine( rLine.GetStart(), rLine.GetEnd() ) );

*************************************************************************/

BYTE SwScriptInfo::WhichFont( xub_StrLen nIdx, const String* pTxt, const SwScriptInfo* pSI )

{

USHORT nScript;

// First we try to use our SwScriptInfo

case i18n::ScriptType::COMPLEX : return SW_CTL;

}

return SW_LATIN;

}

// if change position = 0 we do not use any data from the arrays

// because by deleting all characters of the first group at the beginning

// of a paragraph nScript is set to a wrong value

while( nCnt < CountScriptChg() )

{

if ( nChg > GetScriptChg( nCnt ) )

nScript = (BYTE)GetI18NScriptTypeOfLanguage( (USHORT)GetAppLanguage() );

i18n::ScriptType::ASIAN == nScript ||

i18n::ScriptType::COMPLEX == nScript, "Wrong default language" );

while ( nChg < rTxt.Len() || ( !aScriptChg.Count() && !rTxt.Len() ) )

{

"Inserting WEAK into SwScriptInfo structure" );

xub_StrLen nSearchStt = nChg;

nChg = (xub_StrLen)pBreakIt->GetBreakIter()->endOfScript( rTxt, nSearchStt, nScript );

( isHahChar ( cCh ) && nIdx == nWordLen - 1)) // Hah (dual joining) only at end of word

{

// check if character is connectable to previous character,

if ( lcl_ConnectToPrev( cCh, cPrevCh ) )

{

isGafChar ( cCh ) )

&& nIdx == nWordLen - 1)) // only at end of word

{

// check if character is connectable to previous character,

if ( lcl_ConnectToPrev( cCh, cPrevCh ) )

{

xub_Unicode cNextCh = rWord.GetChar( nIdx + 1 );

if ( isRehChar ( cNextCh ) || isYehChar ( cNextCh ))

{

// check if character is connectable to previous character,

if ( lcl_ConnectToPrev( cCh, cPrevCh ) )

{

isFeChar ( cCh ) ) // Feh (dual joining)

&& nIdx == nWordLen - 1)) // only at end of word

{

// check if character is connectable to previous character,

if ( lcl_ConnectToPrev( cCh, cPrevCh ) )

{

( 0x60C <= cCh && 0x6FE >= cCh // all others

&& nIdx == nWordLen - 1)) // only at end of word

{

// check if character is connectable to previous character,

if ( lcl_ConnectToPrev( cCh, cPrevCh ) )

{

nLastKashida = nChg;

};

// check kashida data

long nTmpKashidaPos = -1;

sal_Bool bWrongKash = sal_False;

}

nTmpKashidaPos = nCurrKashidaPos;

}

#endif

// remove invalid entries from direction information arrays

const xub_StrLen nStartPosOfGroup = nScriptIdx ? GetScriptChg( nScriptIdx - 1 ) : 0;

const BYTE nScriptTypeOfGroup = GetScriptType( nScriptIdx );

// Check if we have to insert a new script change at

// position nStart. If nStartPosOfGroup < nStart,

{

nScriptChg = GetScriptChg( i2 );

nScriptType = GetScriptType( i2 );

nLastScriptChg < nScriptChg,

}

#endif

}

const xub_StrLen nStt, const xub_StrLen nEnd,

const xub_Unicode cChar )

{

PositionList aList;

xub_StrLen nHiddenStart;

const USHORT nCompress, const USHORT nFontHeight,

Point* pPoint ) const

{

USHORT nCompCount = CountCompChg();

// In asian typography, there are full width and half width characters.

{

USHORT nType = GetCompType( nCompIdx );

#if OSL_DEBUG_LEVEL > 1

#endif

nCompLen = nCompLen + nIdx;

if( nCompLen > nLen )

{

while( nIdx < nCompLen )

{

// nLast is width of current character

nLast -= pKernArray[ nI ];

xub_StrLen nLen,

long nSpaceAdd ) const

{

if( !IsKashidaLine(nStt))

return STRING_LEN;

// mark the given character indices as invalid kashida positions

bool SwScriptInfo::MarkKashidasInvalid ( xub_StrLen nCnt, xub_StrLen* pKashidaPositions )

{

USHORT nCntKash = 0;

xub_StrLen nKashidaPosIdx = 0;

xub_StrLen nLen, xub_StrLen nNumberOfBlanks,

long nSpaceAdd )

{

SwTwips nNumOfTwipsToDistribute = nSpaceAdd * nNumberOfBlanks /

SPACING_PRECISION_FACTOR;

SwTwips SwTxtFrm::HangingMargin() const

{

if( !GetPara()->IsMargin() )

return 0;

const SwLineLayout* pLine = GetPara();

const SwLinePortion* _pDontConsiderPortion = NULL,

const bool _bNoFlyCntPorAndLinePor = false ) const;

void DebugPortions( SvStream &rOs, const XubString &rTxt,

const xub_StrLen nStart ); //$ ostream

#endif

#include "porglue.hxx"

#include "inftxt.hxx"

#include "blink.hxx"

sal_Bool ChkChain( SwLinePortion *pStart )

{

while( pPor )

{

++nCount;

"ChkChain(): lost in chains" );

if( nCount >= 200 || pPor == pStart )

{

void SwLinePortion::PrePaint( const SwTxtPaintInfo& rInf,

const SwLinePortion* pLast ) const

{

const KSHORT nViewWidth = GetViewWidth( rInf );

{

SwLinePortion *pPos = pPortion;

do

SwLinePortion *pLast = pPos;

pPos = pPos->GetPortion();

pLast->SetPortion( 0 );

{

pIns->FindLastPortion()->SetPortion( pPortion );

SetPortion( pIns );

ChkChain( this );

#endif

return pIns;

SwLinePortion *pPos = FindLastPortion();

pPos->SetPortion( pIns );

pIns->SetPortion( 0 );

ChkChain( this );

#endif

return pIns;

SwLinePortion *SwLinePortion::Cut( SwLinePortion *pVictim )

{

SwLinePortion *pPrev = pVictim->FindPrevPortion( this );

pPrev->SetPortion( pVictim->GetPortion() );

pVictim->SetPortion(0);

return pVictim;

SwLinePortion *SwLinePortion::FindPrevPortion( const SwLinePortion *pRoot )

{

SwLinePortion *pPos = (SwLinePortion*)pRoot;

while( pPos->GetPortion() && pPos->GetPortion() != this )

{

DBG_LOOP;

pPos = pPos->GetPortion();

}

"SwLinePortion::FindPrevPortion: blowing in the wind");

return pPos;

}

SwPosSize SwLinePortion::GetTxtSize( const SwTxtSizeInfo & ) const

{

"I'm only a stupid SwLinePortion" );

return SwPosSize();

}

/*************************************************************************

* virtual SwLinePortion::Check()

// Das CLASSIO-Makro implementiert die 'freischwebende' Funktion.

// Auf diese Weise erhaelt man beide Vorteile: virtuelle Ausgabeoperatoren

// und allgemeine Verwendbarkeit.

#define OUTPUT_OPERATOR virtual SvStream &operator<<( SvStream & aOs ) const;

#else

#define OUTPUT_OPERATOR

virtual void Paint( const SwTxtPaintInfo &rInf ) const = 0;

void PrePaint( const SwTxtPaintInfo &rInf, const SwLinePortion *pLast ) const;

virtual sal_Bool Check( SvStream &rOs, SwTxtSizeInfo &rInfo ); //$ ostream

#endif

void SwMultiPortion::Paint( const SwTxtPaintInfo & ) const

{

"Don't try SwMultiPortion::Paint, try SwTxtPainter::PaintMultiPortion" );

}

: SwMultiPortion( nEnd )

{

SetRuby();

const SwFmtRuby& rRuby = rCreate.pAttr->GetRuby();

nAdjustment = rRuby.GetAdjustment();

nRubyOffset = nOffs;

}

break;

}

}

if( nLeft || nRight )

{

BYTE nCurrLevel;

if ( pMulti )

{

// level associated with bidi-portion;

nCurrLevel = ((SwBidiPortion*)pMulti)->GetLevel();

}

{

// these values are needed for the calculation of the x coordinate

// and the layout mode

nFrmDir = GetInfo().GetTxtFrm()->IsRightToLeft() ? 1 : 0;

nEnvDir = pEnvPor ? ((SwBidiPortion*)pEnvPor)->GetLevel() % 2 : nFrmDir;

nThisDir = ((SwBidiPortion&)rMulti).GetLevel() % 2;

sal_Bool bRest = pLay->IsRest();

sal_Bool bFirst = sal_True;

do

{

if( pPor->IsMultiPortion() && ((SwMultiPortion*)pPor)->IsBidi() )

{

// but we do allow nested bidi portions

PaintMultiPortion( rPaint, (SwMultiPortion&)*pPor, &rMulti );

}

else

// We set nTmpX (which is used for portion calculating) to the

// current Y value

const SwPageFrm* pPage = pFrm->FindPageFrm();

const SwLayoutFrm* pUpperFrm = pPage;

if ( pFrm->IsInTab() )

pUpperFrm = pFrm->GetUpper();

while ( pUpperFrm && !pUpperFrm->IsCellFrm() )

pUpperFrm = pUpperFrm->GetUpper();

const SwTableLine* pLine = ((SwRowFrm*)pUpperFrm->GetUpper())->GetTabLine();

const SwFmtFrmSize& rFrmFmtSize = pLine->GetFrmFmt()->GetFrmSize();

if ( ATT_VAR_SIZE == rFrmFmtSize.GetHeightSizeType() )

if( pFirstRest )

{

SwFldPortion *pFld =

((SwFldPortion*)pFirstRest)->Clone(

((SwFldPortion*)pFirstRest)->GetExp() );

pNextFirst = aInf.GetRest();

if( pSecondRest )

{

SwFldPortion *pFld = ((SwFldPortion*)pSecondRest)->Clone(

((SwFldPortion*)pSecondRest)->GetExp() );

pFld->SetFollow( sal_True );

// line break has to be performed!

if( bRet )

{

"BuildMultiPortion: Surprising restportion, field expected" );

SwMultiPortion *pTmp;

if( rMulti.IsDouble() )

nMultiLen + rInf.GetIdx() );

else if( rMulti.IsRuby() )

{

"BuildMultiPortion: Surprising restportion, field expected" );

if ( rInf.GetIdx() == rInf.GetLineStart() )

}

else if( pPor->IsMultiPortion() )

{

"Nested multiportions are forbidden." );

pFld = NULL;

if ( !pCreate )

{

if ( nMultiPos )

--nMultiPos;

pCreate = GetInfo().GetMultiCreator( --nMultiPos, 0 );

return 1;

}

}

SwFont *pFnt;

const SwTxtNode& rTxtNode = *GetTxtNode();

sal_Bool SwTxtFrm::FormatEmpty()

{

if ( HasFollow() || GetTxtNode()->GetpSwpHints() ||

0 != GetTxtNode()->GetNumRule() ||

rRegDiff = rSpace.GetLineHeight();

break;

}

}

switch( rSpace.GetInterLineSpaceRule() )

{

nNettoHeight = rRegDiff;

break;

}

}

pDesc->SetRegHeight( rRegDiff );

pDesc->SetRegAscent( rRegDiff - nNettoHeight +

// this should usually be true but

aGuess.AlternativeSpelling( rInf, rInf.GetSoftHyphPos() - 1 );

bFull = CreateHyphen( rInf, aGuess );

}

rInf.ChgHyph( bHyph );

rInf.SetSoftHyphPos( 0 );

SetLen( aGuess.BreakPos() - rInf.GetIdx() );

"Trouble with expanded field portions during line break" );

const xub_StrLen nRealStart = aGuess.BreakStart() - aGuess.FieldDiff();

if( aGuess.BreakPos() < nRealStart && !InExpGrp() )

return sal_True;

}

"SwTxtPortion::Format: missing real width" );

return _Format( rInf );

}

xub_StrLen SwTxtPortion::GetCrsrOfst( const KSHORT nOfst ) const

{

return SwLinePortion::GetCrsrOfst( nOfst );

}

SwIndex aIndex( pNd, rInf.GetIdx( ) );

SwPosition aPosition( *pNd, aIndex );

IFieldmark *pBM = doc->getIDocumentMarkAccess( )->getFieldmarkFor( aPosition );

if ( pBM != NULL )

{

if ( pBM->GetFieldname( ).equalsAscii( ODF_FORMCHECKBOX ) )

aMagicNo[SW_LATIN] = aMagicNo[SW_CJK] = aMagicNo[SW_CTL] = NULL;

// determine script changes if not already done for current paragraph

if ( pScriptInfo->GetInvalidity() != STRING_LEN )

pScriptInfo->InitScriptInfo( rTxtNode, bRTL );

void SwRedlineItr::ChangeTxtAttr( SwFont* pFnt, SwTxtAttr &rHt, sal_Bool bChg )

{

if( !bShow && !pExt )

return;

}

else

{

rAttrHandler.PopAndChg( rHt, *pFnt );

}

}

void SwRedlineItr::_Clear( SwFont* pFnt )

{

bOn = sal_False;

while( aHints.Count() )

{

short SwExtend::Enter( SwFont& rFnt, xub_StrLen nNew )

{

nPos = nNew;

if( Inside() )

{

sal_Bool SwExtend::_Leave( SwFont& rFnt, xub_StrLen nNew )

{

MSHORT nOldAttr = rArr[ nPos - nStart ];

nPos = nNew;

if( Inside() )

{ return pExt->Leave(rFnt, nNew ); }

inline sal_Bool ExtOn() { if( pExt ) return pExt->IsOn(); return sal_False; }

inline void UpdateExtFont( SwFont &rFnt ) {

pExt->UpdateFont( rFnt ); }

};

void SwTxtFrm::ClearPara()

{

if ( !IsLocked() && GetCacheIdx() != MSHRT_MAX )

{

SwTxtLine *pTxtLine = (SwTxtLine*)SwTxtFrm::GetTxtCache()->

}

else

{

nCacheIdx = MSHRT_MAX;

}

}

nCacheIdx = pTxtLine->GetCachePos();

else

{

}

}

}

if ( !((SwTxtFrm*)pLastFrm)->IsEmpty() )

{

const SwParaPortion* pPara = ((SwTxtFrm*)pLastFrm)->GetPara();

if ( pPara )

{

!rInf.GetOpt().IsPagePreview() && !rInf.GetOpt().IsReadonly() && SwViewOption::IsFieldShadings() )

rInf.DrawBackground( *this );

const SwDropPortionPart* pCurrPart = GetPart();

const xub_StrLen nOldLen = GetLen();

{

if( !Next() )

{

break;

}

}

void SwTxtFormatter::GuessDropHeight( const MSHORT nLines )

{

KSHORT nAscent = 0;

KSHORT nHeight = 0;

SetDropLines( nLines );

}

// build DropPortionParts:

xub_StrLen nNextChg = 0;

const SwCharFmt* pFmt = pDropFmt->GetCharFmt();

SwDropPortionPart* pCurrPart = 0;

void SwTxtPainter::PaintDropPortion()

{

const SwDropPortion *pDrop = GetInfo().GetParaPortion()->FindDropPortion();

if( !pDrop )

return;

const void* pFntNo = 0;

MSHORT nTmpIdx = 0;

SwDropPortionPart* pCurrPart = pDrop->GetPart();

const sal_Bool bUseCache = ! pCurrPart->GetFollow();

void SwTxtFormatter::CalcUnclipped( SwTwips& rTop, SwTwips& rBottom )

{

long nFlyAsc, nFlyDesc;

// OD 08.01.2004 #i11859# - use new method <SwLineLayout::MaxAscentDescent(..)>

void SwTxtFormatter::UpdatePos( SwLineLayout *pCurrent, Point aStart,

xub_StrLen nStartIdx, sal_Bool bAllWays ) const

{

if( GetInfo().IsTest() )

return;

}

if( pPos->IsMultiPortion() && ((SwMultiPortion*)pPos)->HasFlyInCntnt() )

{

((SwTxtFormatter*)this)->pMulti = (SwMultiPortion*)pPos;

SwLineLayout *pLay = &GetMulti()->GetRoot();

Point aSt( aTmpInf.X(), aStart.Y() );

if ( GetMulti()->HasBrackets() )

{

aSt.X() += ((SwDoubleLinePortion*)GetMulti())->PreWidth();

}

else if( GetMulti()->HasRotation() )

void SwTxtFormatter::AlignFlyInCntBase( long nBaseLine ) const

{

if( GetInfo().IsTest() )

return;

sal_Bool SwTxtFormatter::ChkFlyUnderflow( SwTxtFormatInfo &rInf ) const

{

if( GetCurr() )

{

// Erst pruefen wir, ob ueberhaupt ein Fly mit der Zeile ueberlappt.

{

SWAP_IF_SWAPPED( pCurrFrm )

SwRect aRect( pCurrFrm->Frm().Pos() + pCurrFrm->Prt().Pos(),

pCurrFrm->Prt().SSize() );

sal_Bool SwTxtFly::IsAnyObj( const SwRect &rRect ) const

{

SwRect aRect( rRect );

if ( aRect.IsEmpty() )

? mpCurrAnchoredObj->GetDrawObj()->GetOrdNum()

: SAL_MAX_UINT32;

// <--

// --> OD 2006-08-15 #i68520#

SwAnchoredObjList::size_type nCount( bOn ? GetAnchoredObjList()->size() : 0 );

const SwTxtPaintInfo &rInf, sal_Bool bNoGraphic )

{

SwRegionRects aRegion( rRect );

// --> OD 2006-08-15 #i68520#

SwAnchoredObjList::size_type nCount( bOn ? GetAnchoredObjList()->size() : 0 );

if ( bOn && nCount > 0 )

pOut->DrawRect( aRegion[i].SVRect() );

else

{

"DrawRect: Uninitialized BrushItem!" );

::DrawGraphic( rInf.GetBrushItem(), pOut, rInf.GetBrushRect(),

aRegion[i] );

// --> OD 2004-10-06 #i26945#

const SwFmtAnchor& rNewA = _pAnchoredObj->GetFrmFmt().GetAnchor();

// <--

"Don't call GetTop with a FlyInCntFrm" );

if (FLY_AT_PAGE == rNewA.GetAnchorId())

return sal_True; // Seitengebundenen wird immer ausgewichen.

// --> OD 2006-08-15 #i68520#

SwAnchoredObjList* SwTxtFly::InitAnchoredObjList()

{

// --> OD 2006-08-15 #i68520#

// <--

SWAP_IF_SWAPPED( pCurrFrm )

void SwContourCache::ClrObject( MSHORT nPos )

{

nPntCnt -= pTextRanger[ nPos ]->GetPointCount();

delete pTextRanger[ nPos ];

--nObjCnt;

* SwContourCache::ShowContour()

* zeichnet die PolyPolygone des Caches zu Debugzwecken.

*************************************************************************/

void SwContourCache::ShowContour( OutputDevice* pOut, const SdrObject* pObj,

const Color& rClosedColor, const Color& rOpenColor )

* SwTxtFly::ShowContour()

* zeichnet die PolyPolygone des Caches zu Debugzwecken.

*************************************************************************/

void SwTxtFly::ShowContour( OutputDevice* pOut )

{

const SwRect &rLine ) const

{

// Normalerweise ist der rechte Rand der rechte Rand der Printarea.

SWRECTFN( pCurrFrm )

// --> OD 2004-12-14 #118796# - correct determination of right of printing area

SwTwips nRight = (pCurrFrm->*fnRect->fnGetPrtRight)();

SwAnchoredObjList::size_type nFlyPos,

const SwRect &rLine ) const

{

SWRECTFN( pCurrFrm )

// --> OD 2004-12-14 #118796# - correct determination of left of printing area

SwTwips nLeft = (pCurrFrm->*fnRect->fnGetPrtLeft)();

SWAP_IF_SWAPPED( pCurrFrm )

const sal_Bool bRet = ForEach( rLine, NULL, sal_False );

UNDO_SWAP( pCurrFrm )

const long nXPos,

const sal_Bool bRight );

// <--

void ShowContour( OutputDevice* pOut, const SdrObject* pObj,

const Color& rClosedColor, const Color& rOpenColor );

#endif

}

// <--

void ShowContour( OutputDevice* pOut );

#endif

};

void SwTxtFrm::Init()

{

if( !IsLocked() )

{

ClearPara();

if( !Frm().Width() && IsValid() && GetUpper()->IsValid() )

//bei Stackueberlauf (StackHack) invalid!

{

return sal_True;

}

void SwTxtFrm::HideHidden()

{

"HideHidden on visible frame of hidden frame has follow" );

const xub_StrLen nEnd = STRING_LEN;

}

else

{

"<SwTxtFrm::HideAndShowObjects()> - object not anchored at/inside paragraph!?" );

}

}

void SwTxtFrm::CalcLineSpace()

{

if( IsLocked() || !HasPara() )

return;

void SwTxtFrm::PrepWidows( const MSHORT nNeed, sal_Bool bNotify )

{

SwParaPortion *pPara = GetPara();

if ( !pPara )

if( !HasPara() && PREP_MUST_FIT != ePrep )

{

SetInvalidVert( TRUE ); // Test

if ( bNotify )

InvalidateSize();

else

// letzte Zeile formatiert werden, damit ggf. die erste Zeile des Follows

// hochrutschen kann, die extra auf die naechste Seite gerutscht war, um mit

// der Fussnote zusammen zu sein, insbesondere bei spaltigen Bereichen.

xub_StrLen nPos = GetFollow()->GetOfst();

if( IsFollow() && GetOfst() == nPos ) // falls wir gar keine Textmasse besitzen,

FindMaster()->Prepare( PREP_FTN_GONE ); // rufen wir das Prepare unseres Masters

if( pVoid )

{

xub_StrLen nWhere = CalcFlyPos( (SwFrmFmt*)pVoid );

InvalidateRange( SwCharRange( nWhere, 1 ) );

return;

}

pOldPara = pFrm->HasPara() ? pFrm->GetPara() : NULL;

pFrm->SetPara( new SwParaPortion(), sal_False );

if ( pFrm->IsVertical() )

pFrm->SwapWidthAndHeight();

if ( pFrm->IsVertical() )

pFrm->SwapWidthAndHeight();

}

SwTestFormat::~SwTestFormat()

sal_Bool SwTxtFrm::WouldFit( SwTwips &rMaxHeight, sal_Bool &bSplit, sal_Bool bTst )

{

"SwTxtFrm::WouldFit with swapped frame" );

SWRECTFN( this );

// In sehr unguenstigen Faellen kann GetPara immer noch 0 sein.

// Dann returnen wir sal_True, um auf der neuen Seite noch einmal

// anformatiert zu werden.

if( !HasPara() || ( !(Frm().*fnRect->fnGetHeight)() && IsHiddenNow() ) )

return sal_True;

KSHORT SwTxtFrm::GetParHeight() const

{

if( !HasPara() )

{ // Fuer nichtleere Absaetze ist dies ein Sonderfall, da koennen wir

// <--

// determine output device

ViewShell* pVsh = GetShell();

// --> OD 2007-07-02 #i78921# - make code robust, according to provided patch

// There could be no <ViewShell> instance in the case of loading a binary

// StarOffice file format containing an embedded Writer document.

{

pOut = GetTxtNode()->getIDocumentDeviceAccess()->getReferenceDevice( true );

}

// --> OD 2007-07-02 #i78921# - make code robust, according to provided patch

if ( !pOut )

{

if ( bCalcHeightOfLastLine )

{

"<SwTxtFrm::_CalcHeightOfLastLine()> - missing paragraph portions." );

const SwLineLayout* pLineLayout = GetPara();

while ( pLineLayout && pLineLayout->GetNext() )

void SwTxtFrm::CalcBaseOfstForFly()

{

const SwNode* pNode = GetTxtNode();

if ( !pNode->getIDocumentSettingAccess()->get(IDocumentSettingAccess::ADD_FLY_OFFSETS) )

* CalcFtnFlag()

*************************************************************************/

#else

#endif

{

bFtn = sal_False;

const USHORT nSize = pHints->Count();

const xub_StrLen nEnd = nStop != STRING_LEN ? nStop

: GetFollow() ? GetFollow()->GetOfst() : STRING_LEN;

#endif

for ( USHORT i = 0; i < nSize; ++i )

sal_Bool SwTxtFrm::CalcPrepFtnAdjust()

{

SwFtnBossFrm *pBoss = FindFtnBossFrm( sal_True );

const SwFtnFrm *pFtn = pBoss->FindFirstFtn( this );

if( pFtn && FTNPOS_CHAPTER != GetNode()->GetDoc()->GetFtnInfo().ePos &&

// containing the footnote.

SWRECTFN( pFrm )

"lcl_GetFtnLower with swapped frame" );

SwTwips nAdd;

pRow = pRow->GetUpper();

const SwTabFrm* pTabFrm = (SwTabFrm*)pRow->GetUpper();

const BOOL bDontSplit = !pTabFrm->IsFollow() &&

!pTabFrm->IsLayoutSplitAllowed();

// #i10770#: If there are fly frames anchored at previous paragraphs,

// the deadline should consider their lower borders.

const SwFrm* pStartFrm = pFrm->GetUpper()->GetLower();

SwTwips nFlyLower = bVert ? LONG_MAX : 0;

while ( pStartFrm != pFrm )

{

if ( pStartFrm->GetDrawObjs() )

{

const SwSortedObjs &rObjs = *pStartFrm->GetDrawObjs();

SwTwips SwTxtFrm::GetFtnLine( const SwTxtFtn *pFtn ) const

{

SwTxtFrm *pThis = (SwTxtFrm*)this;

SwTwips SwTxtFrm::_GetFtnFrmHeight() const

{

const SwFtnFrm *pFtnFrm = FindFtnFrm();

const SwTxtFrm *pRef = (const SwTxtFrm *)pFtnFrm->GetRef();

SwTwips nTmp = (*fnRect->fnYDiff)( (pCont->*fnRect->fnGetPrtBottom)(),

(Frm().*fnRect->fnGetTop)() );

if( nTmp < 0 )

{

sal_Bool bInvalidPos = sal_False;

break;

pTmp = pTmp->GetUpper();

}

}

#endif

// Wir loeschen nicht, sondern wollen die Ftn verschieben.

// Drei Faelle koennen auftreten:

// 1) Es gibt weder Follow noch PrevFollow

// 2) nStart > GetOfst, ich habe einen Follow

// -> Ftn wandert in den Follow

// 3) nStart < GetOfst, ich bin ein Follow

while( pDest->GetFollow() && ((SwTxtFrm*)pDest->

GetFollow())->GetOfst() <= nIdx )

pDest = pDest->GetFollow();

pDest,pFtn),"SwTxtFrm::RemoveFtn: footnote exists");

//Nicht ummelden sondern immer Moven.

}

((SwTxtFrm*)pDest)->SetFtn( sal_True );

pFtn),"SwTxtFrm::RemoveFtn: footnote ChgRef failed");

}

else

else

pFtnBoss->RemoveFtn( this, pFtn );

bRemove = bRemove || !bEndDoc;

!pFtnBoss->FindFtn( this, pFtn ),

"SwTxtFrm::RemoveFtn: can't get off that footnote" );

}

void SwTxtFrm::ConnectFtn( SwTxtFtn *pFtn, const SwTwips nDeadLine )

{

"SwTxtFrm::ConnectFtn with swapped frame" );

bFtn = sal_True;

SwFtnPortion *SwTxtFormatter::NewFtnPortion( SwTxtFormatInfo &rInf,

SwTxtAttr *pHint )

{

"NewFtnPortion with unswapped frame" );

if( !pFrm->IsFtnAllowed() )

SwNumberPortion *SwTxtFormatter::NewFtnNumPortion( SwTxtFormatInfo &rInf ) const

{

"This is the wrong place for a ftnnumber" );

if( rInf.GetTxtStart() != nStart ||

rInf.GetTxtStart() != rInf.GetIdx() )

XubString lcl_GetPageNumber( const SwPageFrm* pPage )

{

MSHORT nVirtNum = pPage->GetVirtPageNum();

const SvxNumberType& rNum = pPage->GetPageDesc()->GetNumType();

return rNum.GetNumStr( nVirtNum );

xub_StrLen SwTxtFormatter::FormatQuoVadis( const xub_StrLen nOffset )

{

"SwTxtFormatter::FormatQuoVadis with swapped frame" );

if( !pFrm->IsInFtn() || pFrm->ImplFindFtnFrm()->GetAttr()->GetFtn().IsEndNote() )

rInf.SetRest( 0 );

pCurrPor->Move( rInf );

// format the rest and append it to the other QuoVadis parts

pFollow->Format( rInf );

#include <guess.hxx> //

#include <splargs.hxx> // SwInterHyphInfo

extern const sal_Char *GetLangName( const MSHORT nLang );

#endif

{

if( rTxt.Len() < 4 || pFnt->IsSymbol(pVsh) )

return 0;

Reference< XHyphenator > xHyph = ::GetHyphenator();

Reference< XHyphenatedWord > xHyphWord;

sal_Bool SwTxtFrm::Hyphenate( SwInterHyphInfo &rHyphInf )

{

if( !pBreakIt->GetBreakIter().is() )

return sal_False;;

// Wir machen den Laden erstmal dicht:

// 4935: Der frame::Frame muss eine gueltige SSize haben!

Calc();

GetFormatted();

void SetParaPortion( SwTxtInfo *pInf, SwParaPortion *pRoot )

{

pInf->pPara = pRoot;

}

SwParaPortion *pPara = new SwParaPortion();

SetParaPortion( &rInf, pPara );

pCurr = pPara;

}

else

pCurr = new SwLineLayout();

if( pOldCurr->IsParaPortion() )

{

SetParaPortion( &rInf, (SwParaPortion*)pOldCurr );

}

if( nWrdStart )

#ifdef DEBUGGY

if( OPTDBG( rInf ) )

{

"!SwTxtFormatter::Hyphenate: different words, different planets" );

aDbstream << "Diff: \"" << aSelTxt.GetStr() << "\" != \""

<< aHyphWord.GetStr() << "\"" << endl;

aDbstream << "Hyphenate: ";

}

#endif

{

Reference< XHyphenatedWord > xHyphWord = rGuess.HyphWord();

if( rInf.IsHyphForbud() ||

pPortion || // robust

{

SvxAlternativeSpelling aAltSpell;

aAltSpell = SvxGetAltSpelling( xHyphWord );

XubString aAltTxt = aAltSpell.aReplacement;

nPorEnd = aAltSpell.nChangedPos + rGuess.BreakStart() - rGuess.FieldDiff();

pFntCache = new SwFntCache; // Cache for SwSubFont -> SwFntObj = { Font aFont, Font* pScrFont, Font* pPrtFont, OutputDevice* pPrinter, ... }

pSwFontCache = new SwFontCache; // Cache for SwTxtFmtColl -> SwFontObj = { SwFont aSwFont, SfxPoolItem* pDefaultArray }

SwCache *pTxtCache = new SwCache( 250, 100 // Cache for SwTxtFrm -> SwTxtLine = { SwParaPortion* pLine }

, "static SwTxtFrm::pTxtCache"

#endif

);

#include "precompiled_sw.hxx"

#endif

#include "viewsh.hxx" // IsDbg()

if( pFrm && pFrm->GetShell() )

return pFrm->GetShell()->GetViewOptions()->IsTest4();

else

return sal_False;

}

{

// wegen PM und BCC

sal_Bool bFalse = sal_False;

}

#define IMPL_OUTOP(class) \

pPREP_UL_SPACE, pPREP_MUST_FIT, pPREP_WIDOWS, pPREP_QUOVADIS,

pPREP_PAGE

};

return( ppNameArr[ePrep] );

}

#endif

}

#if OSL_DEBUG_LEVEL > 1

static sal_Bool bDbg = sal_False;

if( bDbg )

{

Reset();

}

/*************************************************************************

* class SwDbgOut

nNextPos = nForced;

}

nNextPos += bRTL ? nLinePos - nTabLeft : nTabLeft - nLinePos;

nNewTabPos = KSHORT(nNextPos);

}

}

default:

{

"+SwTxtFormatter::NewTabPortion: unknown adjustment" );

pTabPor = new SwTabLeftPortion( nNewTabPos, cFill );

break;

: SwFixPortion( 0, 0 ), nTabPos(nTabPosition), cFill(cFillChar)

{

nLineLength = 1;

if( IsFilled() )

{

}

#endif

SetWhichPor( POR_TAB );

sal_Bool SwTabPortion::PreFormat( SwTxtFormatInfo &rInf )

{

// Hier lassen wir uns nieder...

Fix( static_cast<USHORT>(rInf.X()) );

break;

}

}

}

}

const MSHORT nWhich = GetWhichPor();

const bool bTabCompat = rInf.GetTxtFrm()->GetTxtNode()->getIDocumentSettingAccess()->get(IDocumentSettingAccess::TAB_COMPAT);

// --> FME 2005-12-19 #127428# Abandon dec. tab position if line is full:

void SwTabPortion::Paint( const SwTxtPaintInfo &rInf ) const

{

// Wir wollen uns die Fixbreite anzeigen

if( rInf.OnWin() && OPTDBG( rInf ) &&

!rInf.GetOpt().IsPagePreview() && \

XubString aTxt( cFill );

const KSHORT nCharWidth = rInf.GetTxtSize( aTxt ).Width();

#if OSL_DEBUG_LEVEL > 1

#endif

// robust:

if( nCharWidth )

// Ein Follow, der auf der selben Seite steht, wie sein Master ist nasty.

inline sal_Bool IsNastyFollow( const SwTxtFrm *pFrm )

{

((const SwTxtFrm*)pFrm->GetPrev())->GetFollow() == pFrm,

"IsNastyFollow: Was ist denn hier los?" );

return pFrm->IsFollow() && pFrm->GetPrev();

{

// OD 2004-02-25 #i16128# - Why member <pFrm> _*and*_ parameter <pFrame>??

// Thus, assertion on situation, that these are different to figure out why.

SWAP_IF_SWAPPED( pFrm )

sal_Bool WidowsAndOrphans::FindWidows( SwTxtFrm *pFrame, SwTxtMargin &rLine )

{

if( !nWidLines || !pFrame->IsFollow() )

return sal_False;

// Wir koennen noch was abzwacken

SwTxtFrm *pMaster = pFrame->FindMaster();

if( !pMaster )

return sal_False;

// IsInside() takes care for itself

// Wir erwarten, dass rLine auf der letzten Zeile steht!!

MSHORT nLineCnt = rLine.GetLineNr();

// Erstmal die Orphansregel und den Initialenwunsch erfuellen ...

maList.erase(i1, i2);

#if OSL_DEBUG_LEVEL > 1

#endif

}