Attachment #12832 for issue #15020

View | Details | Raw Unified | Return to issue 15020
Collapse All | Expand All




 *
 *  $RCSfile: rtffly.cxx,v $
 *
 *  $Revision: 1.12.120.4 $
 *
 *  last change: $Author: cmc $ $Date: 2004/01/23 15:10:30 $
 *
 *  The Contents of this file are made available subject to the terms of
 *  either of the following licenses

#ifndef _FLTINI_HXX
#include <fltini.hxx>
#endif
#ifndef _TBLSEL_HXX
#include <tblsel.hxx>
#endif
#include <swcrsr.hxx>

#include <deque>
#include <map>
#endif
#ifndef __SGI_STL_UTILITY
#include <utility>
#include <stack>

#define ANCHOR(p) 	((SwFmtAnchor*)p)


SV_IMPL_PTRARR( SwFlySaveArr, SwFlySave* )

inline const SwFmtFrmSize GetFrmSize(const SfxItemSet& rSet, BOOL bInP=TRUE)
	{ return (const SwFmtFrmSize&)rSet.Get( RES_FRM_SIZE,bInP); }


rtfFrame::rtfFrame(const SwPaM &rPaM)
    : mnSttNd(rPaM.GetPoint()->nNode), mnEndNd(mnSttNd), 
    mnSttCnt(rPaM.GetPoint()->nContent.GetIndex()), mnEndCnt(mnSttCnt)
{
}

void rtfFrame::setend(const SwPaM &rPaM, const APOProperties &rApoProps) 
{
    maApoProps = rApoProps;
    mnEndNd = rPaM.GetPoint()->nNode;
    mnEndCnt = rPaM.GetPoint()->nContent.GetIndex();
}

void rtfFrame::ConvertToItemSet(SfxItemSet &rSet) const
{
    /*
    A positive number indicates the minimum height of the frame and a negative
    number indicates the exact height of the frame.
    */
    SwTwips nHeight = maApoProps.absh;
    SwFrmSize eSize = maApoProps.absh < 0 ? ATT_FIX_SIZE : ATT_MIN_SIZE;
    if (eSize == ATT_FIX_SIZE)
        nHeight = -nHeight;

    /*
    A value of zero indicates that the height of the frame adjusts to the
    contents of the frame. This is the default for frames where no height is
    given.
    */
    if (nHeight < MINFLY)
        nHeight = MINFLY;
    rSet.Put(SwFmtFrmSize(eSize, maApoProps.absw, nHeight));

    SwRelationOrient eHoriRel;
    switch (maApoProps.eHoriRel)
    {
        case phmrg:
            //Use the margin as the horizontal reference frame.
            eHoriRel = REL_PG_PRTAREA;
            break;
        case phpg:
            //Use the page as the horizontal reference frame.
            eHoriRel = REL_PG_FRAME;
            break;
            //Use the column as the horizontal reference frame, This is the
            //default if no horizontal reference frame is given.
        case phcol:
        default:
            eHoriRel = PRTAREA;
            break;
    }

    SwHoriOrient eHoriOri;
    switch (maApoProps.eHoriOri)
    {
        case posxnone:
            eHoriOri = HORI_NONE;
            break;
        case posxc:
            //Centers the frame horizontally within the reference frame.
            eHoriOri = HORI_CENTER;
            break;
        case posxi:
            //Positions the paragraph horizontally inside the reference frame.
            eHoriOri = HORI_LEFT;
            break;
        case posxo:
            //Positions the paragraph horizontally outside the reference frame.
            eHoriOri = HORI_RIGHT;
            break;
        case posxr:
            //Positions the paragraph to the right within the reference frame.
            eHoriOri = HORI_RIGHT;
            break;
        case posxl:
        default:
            //Positions the paragraph to the left within the reference frame.
            //This is the default if no horizontal positioning information is
            //given.
            eHoriOri = HORI_LEFT;
            break;
    }

    using namespace sw::util;
	rSet.Put(SwFmtHoriOrient(MakeSafePositioningValue(maApoProps.posx), 
        eHoriOri, eHoriRel));

    SwRelationOrient eVertRel;
    switch (maApoProps.eVertRel)
    {
        case pvmrg:
        default:
            //Positions the reference frame vertically relative to the margin.
            //This is the default if no vertical frame positioning information
            //is given.
            eVertRel = REL_PG_PRTAREA;
            break;
        case pvpg:
            //Positions the reference frame vertically relative to the page.
            eVertRel = REL_PG_FRAME;
            break;
        case pvpara:
            //Positions the reference frame vertically relative to the top left
            //corner of the next unframed paragraph in the RTF stream.
            eVertRel = PRTAREA;
            break;
    }

    SwVertOrient eVertOri;
    switch (maApoProps.eVertOri)
    {
        case posynone:
            eVertOri = VERT_NONE;
            break;
        case posyil:
            //Positions the paragraph vertically to be in-line.
            eVertOri = VERT_NONE; /*???*/
            break;
        case posyt:
            //Positions the paragraph at the top of the reference frame.
            eVertOri = VERT_TOP;
            break;
        case posyc:
            //Centers the paragraph vertically within the reference frame.
            eVertOri = VERT_CENTER;
            break;
        case posyb:
            //Positions the paragraph at the bottom of the reference frame.
            eVertOri = VERT_BOTTOM;
            break ;
        case posyin:
            //Positions the paragraph vertically inside the reference frame.
            eVertOri = VERT_TOP;
            break;
        case posyout:
            //Positions the paragraph vertically outside the reference frame.
            eVertOri = VERT_BOTTOM;
            break;
    }
    
	rSet.Put(SwFmtVertOrient(MakeSafePositioningValue(maApoProps.posy), 
        eVertOri, eVertRel));

    //Prevents text from flowing around the positioned object.
    if (maApoProps.nowrap)
        rSet.Put(SwFmtSurround(SURROUND_NONE));

    //horizontal distance in twips from text on both sides of the frame.
    rSet.Put(SvxLRSpaceItem(maApoProps.dfrmtxtx, maApoProps.dfrmtxtx));
    //vertical distance in twips from text on both sides of the frame.
    rSet.Put(SvxULSpaceItem(maApoProps.dfrmtxty, maApoProps.dfrmtxty));

    SvxFrameDirection eDir;
    switch (maApoProps.eFlow)
    {
        case frmtxlrtb:
        default:
            //Frame box flows from left to right and top to bottom (default).
            eDir = FRMDIR_HORI_LEFT_TOP;
            break;
        case frmtxtbrl:
            //Frame box flows right to left and top to bottom.
            eDir = FRMDIR_HORI_RIGHT_TOP;
            break;
        case frmtxbtlr:
            //Frame box flows left to right and bottom to top.
            eDir = FRMDIR_HORI_LEFT_TOP; /*???*/
            break;
        case frmtxlrtbv:
            //Frame box flows left to right and top to bottom, vertical.
            eDir = FRMDIR_VERT_TOP_LEFT;
            break;
        case frmtxtbrlv:
            //Frame box flows top to bottom and right to left, vertical.
            eDir = FRMDIR_VERT_TOP_RIGHT;
            break;
    }
	rSet.Put(SvxFrameDirectionItem(eDir));
}

SwFlySave::SwFlySave( const SwPaM& rPam, SfxItemSet& rSet )
	: aFlySet( rSet ),
	nSttNd( rPam.GetPoint()->nNode ), nEndNd( nSttNd ),
	nEndCnt( 0 ), nPageWidth( ATT_MIN_SIZE ),
	nDropLines( 0 ), nDropAnchor( 0 )
{
}


	}
}

void rtfFrameManager::MakeFlyFrames(const SwRTFParser &rReader) const
{
    bool bHack = false;
    bHack = bHack;
    if (bHack)
        return;

    //No paragraphs in document at all
    mycIter aEnd = maFrames.end();
    mycIter aIter = maFrames.begin();
    if (aIter == aEnd)
        return;

    APOProperties aNone;    //Default Ctor for APO is "No apo properties"

    SwPosition aAnchorPos(*rReader.pPam->GetPoint());
    for (; aIter != aEnd; ++aIter)
    {
        //Find the first not apo paragraph to make as the default anchor
        //location, if no others will be found
        if (aIter->maApoProps == aNone)
        {
            aAnchorPos = SwPosition(aIter->mnSttNd);
            break;
        }
    }

    SwFrmFmt* pParent = rReader.pDoc->GetFrmFmtFromPool(RES_POOLFRM_FRAME);
    std::stack<SwNodeIndex> aToRemove;
    for (aIter = maFrames.begin(); aIter != aEnd; ++aIter)
    {
        if (aIter->maApoProps == aNone)
            continue;

        //Find the next non apo paragraph to use an an anchor if one exists
        for (mycIter aNext = aIter+1; aNext != aEnd; ++aNext)
        {
            if (aNext->maApoProps == aNone && aNext->mnSttNd.GetNode().IsTxtNode())
            {
                aAnchorPos = SwPosition(aNext->mnSttNd);
                break;
            }
        }

        //Nothing here to make into a frame, i.e. final txtnode was deleted
        if (!aIter->mnSttNd.GetNode().IsTxtNode())
            continue;

        SwPaM aSelection(aIter->mnSttNd, aIter->mnSttCnt, aIter->mnEndNd, 
            aIter->mnEndCnt);

        SfxItemSet aSet(rReader.pDoc->GetAttrPool(), RES_FRMATR_BEGIN, 
            RES_FRMATR_END-1);
        if (!rReader.IsNewDoc())
            Reader::ResetFrmFmtAttrs(aSet);

        aIter->ConvertToItemSet(aSet);

#if 0
        SwCntntNode *pStartNd = aSelection.GetCntntNode();      //Point
        SwCntntFrm *pStart = pStartNd->GetFrm();
        SwCntntNode *pMarkNd = aSelection.GetCntntNode(false);  //Mark
        SwCntntFrm *pMark = pMarkNd->GetFrm();

        SwSelBoxes aBoxes;
        GetTblSel(pStart, pMark, aBoxes);


        SwFlyFrmFmt* pFmt = rReader.pDoc->MakeFlyAndMove(aSelection, aSet, 
            &aBoxes, pParent);

#else
#if 0
        SwTableCursor aTest(*aSelection.GetPoint());
        const SwSelBoxes &rBoxes = aTest.GetBoxes();

        SwFlyFrmFmt* pFmt = rReader.pDoc->MakeFlyAndMove(aSelection, aSet, 
            &rBoxes, pParent);
#else
        const SwTableSortBoxes *pBoxes = 0;
        if (SwTableNode* pTblNd = aSelection.GetNode()->FindTableNode())
        {
            pTblNd->DelFrms();
            SwNodeIndex aIdx(*pTblNd->EndOfSectionNode(), 1);
            pTblNd->MakeFrms(&aIdx );

            pBoxes = &(pTblNd->GetTable().GetTabSortBoxes());
        }
        SwFlyFrmFmt* pFmt = rReader.pDoc->MakeFlyAndMove(aSelection, aSet, 
            (const SwSelBoxes*)pBoxes, pParent);
#endif
#endif
        ASSERT(pFmt, "inserting a frame failed!");
        if (!pFmt)
            continue;

        SwFmtAnchor aAnchor(FLY_AUTO_CNTNT);
        aAnchor.SetAnchor(&aAnchorPos);
        pFmt->SetAttr(aAnchor);
        aToRemove.push(aIter->mnSttNd);

        if (aIter->maApoProps.absw == 0)
        {
            SfxItemSet aFlySet(pFmt->GetAttrSet());
            SwFmtFrmSize aSize((const SwFmtFrmSize&)(aFlySet.Get(RES_FRM_SIZE)));
            aFlySet.ClearItem(RES_FRM_SIZE);

            Size aPgSize;
            rReader.GetPageSize(aPgSize);

            CalculateFlySize(aFlySet, aAnchorPos.nNode, aPgSize.Width());

            SwFmtFrmSize aNewSize((const SwFmtFrmSize&)(aFlySet.Get(RES_FRM_SIZE)));
            aSize.SetWidth(aNewSize.GetWidth());
            pFmt->SetAttr(aSize);
        }
    }
    
    bHack = bHack;
    if (bHack)
        return;

    while (!aToRemove.empty())
    {
        SwPaM aPaM(aToRemove.top());
        rReader.pDoc->DelFullPara(aPaM);
        aToRemove.pop();
    }
}

void SwRTFParser::SetFlysInDoc()
{
	SwFrmFmt* pParent = pDoc->GetFrmFmtFromPool(RES_POOLFRM_FRAME);
	for (USHORT n = 0; n < aFlyArr.Count(); ++n)
	{
		SwFlySave* pFlySave = aFlyArr[n];

		ASSERT( !pFlySave->nSttNd.GetNode().FindFlyStartNode(),
				"Content vom Fly steht in einem Fly" );

		//				Absatz das Absatz Attribut setzen. Ggfs noch die
		//				FontSize zuruecksetzen, damit das DropCap nicht zu
		//				groá wird.
		if (pFlySave->nDropAnchor)
		{
			SwTxtNode* pSttNd = pFlySave->nSttNd.GetNode().GetTxtNode(),
					 * pEndNd = pFlySave->nEndNd.GetNode().GetTxtNode();
			if (pSttNd && pEndNd &&
				pSttNd->GetIndex() + 1 == pEndNd->GetIndex())
			{
				bool bJoined;
				{
					SwPaM aTmp( *pEndNd, 0, *pSttNd, pSttNd->GetTxt().Len() );
					bJoined = pDoc->DeleteAndJoin( aTmp );
				}
				if (bJoined)
				{
					SwFmtDrop aDropCap;
					aDropCap.GetLines() = (BYTE)pFlySave->nDropLines;

			continue;
		}

        SwPosition aPos(pFlySave->nSttNd);
        SwFmtAnchor aAnchor((const SwFmtAnchor&)pFlySave->aFlySet.Get(RES_ANCHOR));
        aAnchor.SetAnchor(&aPos);
        pFlySave->aFlySet.Put(aAnchor);
		{
			SwCntntNode* pCNd = rNds[ pFlySave->nEndNd ]->GetCntntNode();
			if( pCNd )
			{
				SwPosition aPos( pFlySave->nEndNd,
								SwIndex( pCNd, pFlySave->nEndCnt ));
				pDoc->SplitNode( aPos );
				pFlySave->nEndNd--;
			}
			else
				pFlySave->nEndCnt = 0;
		}

		// verschiebe den Inhalt von diesem Anchor in den Auto-TextBereich
		// und erzeuge dadurch den richtigen SwG-Rahmen
		SwNodeRange aRg(pFlySave->nSttNd, 0, pFlySave->nEndNd, 0);
        //Make a new section, unless there is no content at all
		bool bMakeEmptySection = aRg.aStart < aRg.aEnd || ((aRg.aStart == aRg.aEnd) && pFlySave->nEndCnt);

		{
			// Nur TextNodes koennen in Tabellen stehen !!
			const SwNode* pNd = &pFlySave->nSttNd.GetNode();
			if( pNd->IsNoTxtNode() )
			{
				// die Size muss noch korrigiert werden!
				nAktPageDesc = 0;		// Standart PageDesc
				if( SFX_ITEM_SET != pFlySave->aFlySet.GetItemState(
					RES_FRM_SIZE, FALSE ) )
					_SetPictureSize( *(SwNoTxtNode*)pNd, aRg.aStart,
									pFlySave->aFlySet );
				if( 0 != ( pNd = pNd->FindTableNode() ) )
					pFlySave->SetFlySize( *(SwTableNode*)pNd );
			}
			else
			{
				// TabelleNodes beachten
				pNd = pNd->FindTableNode();
				if( pNd )	// am Anfang eine Tabelle, -> Bereich auf TabStart
					aRg.aStart = *pNd;

				if( bMakeEmptySection )
				{
					pNd = &aRg.aEnd.GetNode();
					ULONG nSectEnd = pNd->EndOfSectionIndex()+1;

					if (!pNd->IsTableNode() && (pNd = pNd->FindTableNode()))
					{
						const SwNode* pTblBxNd;
						// Ende der Tabelle ist hinter dieser Box ??
						if( pNd->EndOfSectionIndex() == nSectEnd )
							aRg.aEnd = nSectEnd+1;
						// is the end in the first box of the table, then
						// move before the table (Bug 67663)
						else if( 0 != ( pTblBxNd = aRg.aEnd.GetNode().
												FindTableBoxStartNode()) &&
								 pTblBxNd->GetIndex() - 1 == pNd->GetIndex())
							aRg.aEnd = *pNd;
						else
						{
							// Tabelle ist noch groesser, also splitte sie hier.
							rNds.SplitTable( aRg.aEnd, TRUE );
							aRg.aEnd = pNd->EndOfSectionIndex() + 1;
						}
					}
				}
			}
		}

		// vorm verschieben muss sich der Index auf die alte Position
		// gemerkt werden, der Index wird mit verschoben !!!

		SwNodeIndex aTmpIdx( rNds.GetEndOfAutotext() );
		SwStartNode* pSttNd = bMakeEmptySection
				? rNds.MakeEmptySection( aTmpIdx, SwFlyStartNode )
				: rNds.MakeTextSection( aTmpIdx, SwFlyStartNode,
						(SwTxtFmtColl*)pDoc->GetDfltTxtFmtColl() );

		// das ist die Verankerungs-Position (fuers Layout!)
		pFlySave->nSttNd = aRg.aStart.GetIndex()-1;
		if( bMakeEmptySection )
		{
			// check: the move does not clear the surrounded section. If all
			// nodes moved away, then create a new TxtNode
			{
				SwNodeIndex aPrev( aRg.aStart, -1 );
				if( aPrev.GetNode().IsStartNode() &&
					aPrev.GetNode().EndOfSectionNode() == &aRg.aEnd.GetNode())
				{
					// create new txtnode, because the section does never be empty
					pDoc->GetNodes().MakeTxtNode( aRg.aEnd,
							(SwTxtFmtColl*)pDoc->GetDfltTxtFmtColl() );
					aRg.aEnd--;
				}
			}
			aTmpIdx = *pSttNd->EndOfSectionNode();
			pDoc->Move( aRg, aTmpIdx );
		}

		pFlySave->aFlySet.Put( SwFmtCntnt( pSttNd ));

		CalculateFlySize( pFlySave->aFlySet, pFlySave->nSttNd,
						  pFlySave->nPageWidth );

        SwFlyFrmFmt* pFmt = 0;
		// border or backgorund, then put it to the frame
		// Not in our own RTF-Format!
		if( pSttNd->GetIndex() + 2 == pSttNd->EndOfSectionIndex() &&
			!bSwPageDesc )
		{
			SwTxtNode* pSrcNd = pDoc->GetNodes()[ pSttNd->GetIndex() + 1 ]
									->GetTxtNode();
			if( pSrcNd && pSrcNd->GetpSwAttrSet() )
			{
				SfxItemSet aTmpSet( pDoc->GetAttrPool(),
									RES_BACKGROUND, RES_BOX );
				aTmpSet.Put( *pSrcNd->GetpSwAttrSet() );
				if( aTmpSet.Count() )
				{
					pFlySave->aFlySet.Put( aTmpSet );
					pSrcNd->ResetAttr( RES_BACKGROUND, RES_BOX );
				}
			}
		}

		SwFlyFrmFmt* pFmt = pDoc->MakeFlyFrmFmt( aEmptyStr, pParent );
		pFmt->SetAttr( pFlySave->aFlySet );
		const SwFmtAnchor& rAnchor = pFmt->GetAnchor();
		if( FLY_IN_CNTNT != rAnchor.GetAnchorId() )
		{
			// korrigiere noch den Absatz, ist immer der vorhergehende !
			// JP 20.09.95: wenn es diesen gibt! (DocAnfang!)

			//JP 02.08.99: that is wrong. The anchor is ever the NEXT!
			//JP 05.08.99: there are an Bug in the ExportFilter which will
			//				be fixed in the Version 517 - by SWG-Export
			//				the fly will be after the paragraph - but in RTF
			// 				the	flys will be before the paragraph.
			if( !bSwPageDesc || 5430 < GetVersionNo() )
				pFlySave->nSttNd++;

//            if( !pFlySave->nSttNd.GetNode().IsCntntNode() )
			{
				// Seitenumbrueche in den Bodybereich verschieben!
				SwCntntNode* pSrcNd = aRg.aStart.GetNode().GetCntntNode();
				SwCntntNode* pDstNd = pFlySave->nSttNd.GetNode().GetCntntNode();
				if( !pDstNd )
					pDstNd = pDoc->GetNodes().GoNext( &pFlySave->nSttNd );

				::lcl_CpyBreakAttrs( pSrcNd, pDstNd, &pFlySave->nSttNd );
			}

            const SwNodeIndex aSttNd(*pSttNd);
            SwNodeIndex aEndNd(*pSttNd->EndOfSectionNode());
            aEndNd--;

            SwPosition aPos( pFlySave->nSttNd );
            SwFmtAnchor aAnchor(rAnchor);
            aAnchor.SetAnchor(&aPos);

            const SwNode *pCurrentAnchor = &(pFlySave->nSttNd.GetNode());
            aPrevFmts[pCurrentAnchor].push_back(frameEntry(pFmt, aAnchor));

            while (aEndNd > aSttNd)
            {
                typedef rtfframesAtIndex::iterator myIter;
                rtfframesAtIndex &rDeque = aPrevFmts[&(aEndNd.GetNode())];
                myIter aEnd = rDeque.end();
                for (myIter aIter = rDeque.begin(); aIter != aEnd; ++aIter)
                {
                    aIter->second.SetAnchor(&aPos);
                    aPrevFmts[pCurrentAnchor].push_back(*aIter);
                }
                rDeque.clear();
                aEndNd--;
           }
		}
		delete pFlySave;
	}

    typedef rtfFmtMap::reverse_iterator myriter;
    myriter aEnd = aPrevFmts.rend();
    for(myriter aIter = aPrevFmts.rbegin(); aIter != aEnd; ++aIter)
    {
        rtfframesAtIndex &rDeque = aIter->second;
        typedef rtfframesAtIndex::iterator myIter;
        myIter aQEnd = rDeque.end();
        for (myIter aQIter = rDeque.begin(); aQIter != aQEnd; ++aQIter)
        {
            SwPaM aRegion(pFlySave->nSttNd, 0, pFlySave->nEndNd, pFlySave->nEndCnt);
            pFmt = pDoc->MakeFlyAndMove(aRegion, pFlySave->aFlySet, 0, pParent);
            SwFmtAnchor &rAnchor = rEntry.second;
            pFrm->SetAttr(rAnchor);
        }
        ASSERT(pFmt, "Format missing");
        if (pFmt)
        {
            SwAttrSet aFlySet(pFmt->GetAttrSet());
            CalculateFlySize(aFlySet, pFlySave->nSttNd,	pFlySave->nPageWidth );
            pFmt->SetAttr(aFlySet);
        }
		delete pFlySave;
	}

    aFlyArr.Remove(0, aFlyArr.Count());
}

bool APOProperties::HandleToken(int nToken, long nTokenValue)
long SwRTFParser::GetSafePos(long nPos)
{
    bool bHandled = true;
    switch (nToken)
    {
        case RTF_ABSW:
            absw = nTokenValue;
            break;
        case RTF_ABSH:
            absh = nTokenValue;
            break;
        case RTF_PHMRG:
            eHoriRel = phmrg;
            break;
        case RTF_PHPG:
            eHoriRel = phpg;
            break;
        case RTF_PHCOL:
            eHoriRel = phcol;
            break;
        case RTF_POSX:
        case RTF_POSNEGX:
            eHoriOri = posxnone;
            posx = nTokenValue;
            break;
        case RTF_POSXC:
            eHoriOri = posxc;
            break;
        case RTF_POSXI:
            eHoriOri = posxi;
            break;
        case RTF_POSXO:
            eHoriOri = posxo;
            break;
        case RTF_POSXR:
            eHoriOri = posxr;
        case RTF_POSXL:
            eHoriOri = posxl;
            break;
        case RTF_PVMRG:
            eVertRel = pvmrg;
            break;
        case RTF_PVPG:
            eVertRel = pvpg;
            break;
        case RTF_PVPARA:
            eVertRel = pvpara;
            break;
        case RTF_POSY:
        case RTF_POSNEGY:
            posy = nTokenValue;
            break;
        case RTF_POSYIL:
            eVertOri = posyil;
            break;
        case RTF_POSYT: 
            eVertOri = posyt;
            break;
        case RTF_POSYC:
            eVertOri = posyc;
            break;
        case RTF_POSYB:	
            eVertOri = posyb;
            break;
        case RTF_POSYIN:
            eVertOri = posyin;
            break;
        case RTF_POSYOUT:
            eVertOri = posyout;
            break;
        case RTF_ABSLOCK:
            abslock = nTokenValue ? true : false;
            break;
        case RTF_NOWRAP:
            nowrap = true;
            break;
        case RTF_DXFRTEXT:
            dfrmtxtx = dfrmtxty = nTokenValue;
            break;
        case RTF_DFRMTXTX:
            dfrmtxtx = nTokenValue;
            break;
        case RTF_DFRMTXTY:
            dfrmtxty = nTokenValue;
            break;
        case RTF_DROPCAPLI:
            dropcapli = nTokenValue;
            break;
        case RTF_DROPCAPT:
            dropcapt = static_cast<dropcap>(nTokenValue);
            break;
        case RTF_ABSNOOVRLP:
            absnoovrlp = nTokenValue ? true : false;
            break;
        case RTF_FRMTXLRTB:
            eFlow = frmtxlrtb;
            break;
        case RTF_FRMTXTBRL:
            eFlow = frmtxtbrl;
            break;
        case RTF_FRMTXBTLR:
            eFlow = frmtxbtlr;
            break;
        case RTF_FRMTXLRTBV:
            eFlow = frmtxlrtbv;
            break;
        case RTF_FRMTXTBRLV:
            eFlow = frmtxtbrlv;
            break;
        default:
            bHandled = false;
            break;
    }
    return bHandled;
}

#if 0

void SwRTFParser::ReadFly( int nToken, SfxItemSet* pSet )
{
	// ein Set fuer die FrmFmt-Attribute

	// RTF-Defaults setzen:
	SwFmtAnchor aAnchor(FLY_PAGE);

	SwFmtHoriOrient aHori( 0, HORI_LEFT, REL_PG_PRTAREA );
	SwFmtVertOrient aVert( 0, VERT_TOP, REL_PG_PRTAREA );
	SvxFrameDirectionItem aFrmDir( FRMDIR_HORI_LEFT_TOP );



		case RTF_POSNEGX:
		case RTF_POSX:		aHori.SetHoriOrient( HORI_NONE );
							aHori.SetPos(MakeSafePositioningValue(nTokenValue));
							break;
		case RTF_POSXC:     aHori.SetHoriOrient( HORI_CENTER );		break;
		case RTF_POSXI:		aHori.SetHoriOrient( HORI_LEFT );


		case RTF_POSNEGY:
		case RTF_POSY:		aVert.SetVertOrient( VERT_NONE );
							aVert.SetPos(MakeSafePositioningValue(nTokenValue));
							break;
		case RTF_POSYT:     aVert.SetVertOrient( VERT_TOP );	break;
		case RTF_POSYB:		aVert.SetVertOrient( VERT_BOTTOM );	break;

			nToken = GetNextToken();
	} while( bWeiter && IsParserWorking() );

#if 0
	if( !bReadSwFly && ( FRAME == aVert.GetRelationOrient() ||
		//JP 21.07.99: for Bug 67630 - it read into Header od Footer, set
		// 				never the anchor to Page. Because it is then only
		//              on the first used page .
		( FLY_PAGE == aAnchor.GetAnchorId() &&
		  pPam->GetPoint()->nNode < pDoc->GetNodes().GetEndOfExtras() &&
		  ( pPam->GetNode()->FindHeaderStartNode() ||
			pPam->GetNode()->FindFooterStartNode() )) ))
		aAnchor.SetType( FLY_AT_CNTNT );
#endif

    pSet->Put( aAnchor );
	pSet->Put( aHori );
	pSet->Put( aVert );

				nTmp *= USHRT_MAX;
				nTmp /= nWidth;
				pCol->SetWishWidth( USHORT(nTmp) );
/*
	JP 07.07.95: der Dialog kennt nur eine Breite fuer alle Spalten
				 darum hier nicht weiter beachten
				nTmp = aColumns[ n+1 ];
				if( nTmp )
					pCol->SetRight( USHORT(nTmp) );
				else
					pCol->SetRight( 0 );
				pCol->SetLeft( 0 );
*/
			}
		}
		pSet->Put( aCol );

    
    // ein neues FlyFormat anlegen oder das alte benutzen ?
    // (teste ob es die selben Attribute besitzt!)
    SwFlySave* pFlySave;
    USHORT nFlyArrCnt = aFlyArr.Count();
    SwFlySave* pFlySavePrev = nFlyArrCnt ? aFlyArr[nFlyArrCnt-1] : 0;
    SwFlySave* pFlySave = pFlySavePrev;
    /*
    #i5263# 
    There were not enough frame properties found to actually justify creating

    */
    if (nAppliedProps)
    {
        if (!pFlySavePrev || !pFlySavePrev->IsEqualFly(*pPam, aSet))
            !( pFlySave = aFlyArr[ nFlyArrCnt-1 ])->IsEqualFly( *pPam, aSet ))
        {
            pFlySave = new SwFlySave(*pPam, aSet);
            Size aPgSize;
            GetPageSize( aPgSize );
            pFlySave->nPageWidth = aPgSize.Width();
            if(nDropCapAnchor)
            if( nDropCapAnchor )
            {
                pFlySave->nDropAnchor = nDropCapAnchor;
                pFlySave->nDropLines = nDropCapLines;
            } 
            if (pFlySavePrev)
            {
                if (pFlySave->nSttNd.GetIndex() < pFlySavePrev->nEndNd.GetIndex())
                {
                 	pFlySavePrev->nEndNd=pFlySave->nSttNd;
                }
            }
            aFlyArr.Insert(pFlySave, nFlyArrCnt++);
        }
    }

    if (pFlySave)
	const SwTableNode* pTblNd = pPam->GetNode()->FindTableNode();

	while( !IsPardTokenRead() && IsParserWorking() )
	{
		if( RTF_PARD == nToken || nOpenBrakets > GetOpenBrakets() )
			break;

		NextToken( nToken );

		if( !IsPardTokenRead() )
		{
			nToken = GetNextToken();

			// BUG 22036: kommt zwischen Fly-Attributen ein unbekanntes,
			//				dann erzeuge nie 2 FlyFrames, sondern fasse
			//				beide zusammen !!!
			while( RTF_APOCTL == ( nToken & ~(0xff | RTF_SWGDEFS) ))
			{
				if( RTF_FLY_INPARA == nToken )
					break;

				if( RTF_IGNOREFLAG == SkipToken( -1 ) )
				{
					if( '{' == SkipToken( -1 ) )
						nToken = '{';
					else
						SkipToken( 2 );
				}
				else
					SkipToken( 1 );

                ReadFly( nToken, pFlySave ? &pFlySave->aFlySet : 0);
				nToken = GetNextToken();
			}
		}
	}

    /*
    #i5263# 
    There were enough frame properties found to actually justify creating
    an absolutely positioned frame.
    */
    if (!nAppliedProps)
    {
        pFlySave->nEndNd = pPam->GetPoint()->nNode;
        pFlySave->nEndCnt = pPam->GetPoint()->nContent.GetIndex();
        return;
    }
	bReadSwFly = false;
	SkipToken(-1);
		pTblNd->EndOfSectionIndex() + 1 ==
			pPam->GetPoint()->nNode.GetIndex() )
	{
		// nicht mehr in der Tabelle, sondern dahinter ?
		// Dann aber wieder zurueck in die Tabelle
		pPam->Move( fnMoveBackward );
	}
	else
		pTblNd = 0;

	// wurde garnichts eingefuegt?
	if( !pTblNd &&
		pPam->GetPoint()->nNode == pFlySave->nSttNd &&
		!pPam->GetPoint()->nContent.GetIndex() )
	{
//		// dann erzeuge mindestens einen leeren TextNode
//		pDoc->AppendTxtNode(*pPam);
		// dann zerstoere den FlySave wieder.
		aFlyArr.DeleteAndDestroy( --nFlyArrCnt );

	}
	else
	{
		FASTBOOL bMovePaM = 0 != pTblNd;

		pFlySave->nEndNd = pPam->GetPoint()->nNode;
		pFlySave->nEndCnt = pPam->GetPoint()->nContent.GetIndex();

		if( bMovePaM )
			pPam->Move( fnMoveForward );

		pTblNd = pFlySave->nSttNd.GetNode().FindTableNode();
		if( pTblNd && !pFlySave->nEndCnt &&
			pTblNd == pFlySave->nEndNd.GetNode().FindTableNode() )
		{
			// dann teste mal, ob das \pard nicht zu spaet kam und
			// eigentlich in die vorherige Zelle gehoert
			const SwStartNode* pSttBoxNd = pFlySave->nSttNd.GetNode().
											FindTableBoxStartNode(),
							* pEndBoxNd = pFlySave->nEndNd.GetNode().
											FindTableBoxStartNode();
			if( pSttBoxNd && pEndBoxNd &&
				bMovePaM ? ( pSttBoxNd == pEndBoxNd )
						 : ( pSttBoxNd->EndOfSectionIndex() + 1 ==
								pEndBoxNd->GetIndex() &&
								pEndBoxNd->GetIndex() + 1 ==
								pFlySave->nEndNd.GetIndex() ))
			{
				// dann gehoert das Ende in die vorherige Box!
				SwPosition aPos( *pPam->GetPoint() );
				pPam->GetPoint()->nNode = *pSttBoxNd->EndOfSectionNode();
				pPam->Move( fnMoveBackward, fnGoNode );

				DelLastNode();

				pPam->GetPoint()->nNode = *pSttBoxNd->EndOfSectionNode();
				pPam->Move( fnMoveBackward, fnGoNode );

				pFlySave->nEndNd = pPam->GetPoint()->nNode;
				pFlySave->nEndCnt = pPam->GetPoint()->nContent.GetIndex();

				*pPam->GetPoint() = aPos;
			}
		}
		else if( !bReadSwFly && !pFlySave->nEndCnt &&
			pFlySave->nSttNd.GetIndex() + 1 == pFlySave->nEndNd.GetIndex() &&
			pFlySave->nSttNd.GetNode().IsTxtNode() )
		{

			SwTxtNode* pTxtNd = pFlySave->nSttNd.GetNode().GetTxtNode();
			SwTxtFlyCnt* pFlyCnt;
			if( 1 == pTxtNd->GetTxt().Len() &&
				0 != ( pFlyCnt = (SwTxtFlyCnt*)pTxtNd->GetTxtAttr(
												0, RES_TXTATR_FLYCNT )) &&
				pFlyCnt->GetFlyCnt().GetFrmFmt() )
			{
				// then move the content into the surrounded fly
				SwFrmFmt* pFlyFmt = pFlyCnt->GetFlyCnt().GetFrmFmt();
				const SwNodeIndex* pFlySNd = pFlyFmt->GetCntnt().GetCntntIdx();
				SwNodeRange aRg( *pFlySNd, 1,
								 *pFlySNd->GetNode().EndOfSectionNode(), 0 );

				// merge the itemsets
				SwFmtFrmSize aSz1( (SwFmtFrmSize&)pFlyFmt->GetAttrSet().
												Get( RES_FRM_SIZE ));
				SwFmtFrmSize aSz2( (SwFmtFrmSize&)pFlySave->aFlySet.
												Get( RES_FRM_SIZE ));
				// if
				if( !aRg.aStart.GetNode().IsNoTxtNode() ||
					!aSz1.GetHeight() || !aSz1.GetWidth() ||
					!aSz2.GetHeight() || !aSz2.GetWidth() ||
					( aSz1.GetHeight() == aSz2.GetHeight() &&
					  aSz1.GetWidth() == aSz2.GetWidth() ) )
				{
					SfxItemSet aDiffs( pFlyFmt->GetAttrSet() );
					aDiffs.ClearItem( RES_ANCHOR );
					aDiffs.ClearItem( RES_FRM_SIZE );
					aDiffs.ClearItem( RES_CNTNT );
					aDiffs.Differentiate( pFlySave->aFlySet );
					pFlySave->aFlySet.Put( aDiffs );

					BOOL bSet = FALSE;
					if( aSz1.GetHeight() && !aSz2.GetHeight() )
					{
						bSet = TRUE;
						aSz2.SetHeight( aSz1.GetHeight() );
					}
					if( aSz1.GetWidth() && !aSz2.GetWidth() )
					{
						bSet = TRUE;
						aSz2.SetWidth( aSz1.GetWidth() );
					}
					if( bSet )
						pFlySave->aFlySet.Put( aSz2 );

					// move any PageBreak/Desc Attr to the next Para
					{
						SwCntntNode* pSrcNd = pFlySave->nSttNd.GetNode().GetCntntNode();
						SwCntntNode* pDstNd = pFlySave->nEndNd.GetNode().GetCntntNode();

						::lcl_CpyBreakAttrs( pSrcNd, pDstNd, &pFlySave->nEndNd );
					}

					// create new txtnode, because the section does never be empty
					pDoc->GetNodes().MakeTxtNode( aRg.aStart,
								(SwTxtFmtColl*)pDoc->GetDfltTxtFmtColl() );

					SwNodeIndex aTmp( pFlySave->nSttNd, +1 );
					pDoc->Move( aRg, aTmp );

					// now delete the redundant txtnode
					pDoc->GetNodes().Delete( pFlySave->nSttNd, 1 );
				}
			}
		}
	}

	bReadSwFly = FALSE;
	SkipToken( -1 );
}
#endif

void SwRTFParser::InsPicture( const String& rGrfNm, const Graphic* pGrf,
								const SvxRTFPictureType* pPicType )

	rSet.Put( SwFmtFrmSize( ATT_FIX_SIZE, aSize.Width(), aSize.Height() ));
}

void SwRTFParser::GetPageSize(Size& rSize) const
{
    ASSERT(!maSegments.empty(), "not possible");
    if (maSegments.empty())

Lines 2-10 Link Here

(-)rtftbl.cxx (-2 / +5 lines)
2	*	2	*
3	* $RCSfile: rtftbl.cxx,v $	3	* $RCSfile: rtftbl.cxx,v $
4	*	4	*
5	* $Revision: 1.21 $	5	* $Revision: 1.19.30.2 $
6	*	6	*
7	* last change: $Author: obo $ $Date: 2004/01/13 16:50:52 $	7	* last change: $Author: cmc $ $Date: 2004/01/22 17:17:32 $
8	*	8	*
9	* The Contents of this file are made available subject to the terms of	9	* The Contents of this file are made available subject to the terms of
10	* either of the following licenses	10	* either of the following licenses
Lines 857-864 Link Here
857	{	857	{
858	if (const SwEndNode *pEnd = pStart->EndOfSectionNode())	858	if (const SwEndNode *pEnd = pStart->EndOfSectionNode())
859	{	859	{
		860	SwNodeIndex aOld(pPam->GetPoint()->nNode);
860	pPam->GetPoint()->nNode = *pEnd;	861	pPam->GetPoint()->nNode = *pEnd;
861	pPam->Move( fnMoveBackward, fnGoCntnt );	862	pPam->Move( fnMoveBackward, fnGoCntnt );
		863	SwNodeIndex aNew(pPam->GetPoint()->nNode);
		864	maFrameManager.MoveStart(aOld, aNew);
862	bFailure = false;	865	bFailure = false;
863	}	866	}
864	}	867	}




 *
 *  $RCSfile: swparrtf.cxx,v $
 *
 *  $Revision: 1.34.14.2 $
 *
 *  last change: $Author: cmc $ $Date: 2004/01/22 17:17:44 $
 *
 *  The Contents of this file are made available subject to the terms of
 *  either of the following licenses

#include <SwStyleNameMapper.hxx>
#endif

#ifndef SW_MS_MSFILTER_HXX
#include <msfilter.hxx>
#endif
#ifndef WW_WWSTYLES_HXX
#   include <wwstyles.hxx>
#endif
// einige Hilfs-Funktionen
// char

	SetReadDocInfo( TRUE );

	// diese sollen zusaetzlich ueber \pard zurueck gesetzt werden
	AddPlainAttr(RES_TXTATR_CHARFMT);
	AddPardAttr(RES_PAGEDESC);
	AddPardAttr(RES_BREAK);
	AddPardAttr(RES_PARATR_NUMRULE);
	AddPardAttr(FN_PARAM_NUM_LEVEL);

    maFrameManager.StartPara(*pPam);
}

//The defaults according to the RTF 1.6 Specification with a little obvious
//extrapolation from section "Positioned Objects and Frames"
APOProperties::APOProperties()
    : absh(0), absw(0), eHoriRel(phcol), posx(0), eHoriOri(posxl),
    eVertRel(pvmrg), posy(0), eVertOri(posynone), abslock(false), nowrap(false),
    dfrmtxtx(0), dfrmtxty(0), overlay(false), dropcapli(0), dropcapt(none),
    absnoovrlp(false), eFlow(frmtxlrtb)
{
}

bool APOProperties::operator==(const APOProperties& rOther) const
{
    return 
    (
        absw == rOther.absw &&
        absh == rOther.absh &&
        eHoriRel == rOther.eHoriRel &&
        posx == rOther.posx && 
        eHoriOri == rOther.eHoriOri &&
        eVertRel == rOther.eVertRel &&
        posy == rOther.posy &&
        eVertOri == rOther.eVertOri &&
        abslock == rOther.abslock &&
        nowrap == rOther.nowrap &&
        dfrmtxtx == rOther.dfrmtxtx &&
        dfrmtxty == rOther.dfrmtxty &&
        overlay == rOther.overlay &&
        dropcapli == rOther.dropcapli &&
        dropcapt == rOther.dropcapt &&
        absnoovrlp == rOther.absnoovrlp &&
        eFlow == rOther.eFlow
    );
}

void SwRTFParser::EnterEnvironment()
{
    maFrameManager.EnterEnvironment();
}

void SwRTFParser::LeaveEnvironment()
{
    maFrameManager.LeaveEnvironment();
}

void SwRTFParser::ResetPard()
{
    maFrameManager.ResetCurrentEnvironment();
}

void SwRTFParser::InsertText()
{
    bContainsPara = false;      
	// dann fuege den String ein, ohne das Attribute am Ende
	// aufgespannt werden.
	CheckInsNewTblLine();
	pDoc->Insert( *pPam, aToken );
}

// Aufruf des Parsers

		else if( GetDocInfo() )
			// evt. eingelesen DocInfo setzen
			pDoc->SetInfo( *GetDocInfo() );

        maFrameManager.MakeFlyFrames(*this);
	}
	delete pSttNdIdx, pSttNdIdx = 0;
	delete pRegionEndIdx, pRegionEndIdx = 0;

			// Tabelle nicht mehr vorhanden ?
			if (USHRT_MAX != nInsTblRow && !pTableNode)
				NewTblLine();				// evt. Line copieren
            maFrameManager.EndPara(*pPam);
			GotoNextBox();
            maFrameManager.StartPara(*pPam);
		}
		break;


// RTF_SUBENTRYINDEX

	default:
        {
            /* Just to break this into its logical handlers we'll split the
             * remainder of the tokens into seperate handlers */
            bool bHandled = maFrameManager.HandleToken(nToken, nTokenValue);
            if (!bHandled)
            {
                //Legacy messy code
                switch( nToken & ~(0xff | RTF_SWGDEFS) )
                {
                case RTF_DOCFMT:
                    ReadDocControls( nToken );
                    break;
                case RTF_SECTFMT:
                    ReadSectControls( nToken );
                    break;
                case RTF_BRDRDEF | RTF_TABLEDEF:
                case RTF_SHADINGDEF | RTF_TABLEDEF:
                case RTF_TABLEDEF:
                    ReadTable( nToken );
                    break;

                case RTF_INFO:
                    ReadInfo();
                    break;
                }
            }

            if (!bHandled)
            {
                if( USHRT_MAX != nInsTblRow &&
                    (nInsTblRow > GetOpenBrakets() || IsPardTokenRead() ))
                    nInsTblRow = USHRT_MAX;

                SvxRTFParser::NextToken( nToken );
            }
        }
		break;
	}
	if( USHRT_MAX != nInsTblRow &&
		(nInsTblRow > GetOpenBrakets() || IsPardTokenRead() ))
		nInsTblRow = USHRT_MAX;
}

void rtfFrameManager::EndPara(const SwPaM &rPaM)
{
    ASSERT(!maFrames.empty(), "called without any paragraphs");
    if (!maFrames.empty())
    {
        if (maFrames.size() > 1)
        {
            //Consecutive paragraphs with the same frame 
            //formatting are considered part of the same frame.
            myrIter aRIter = maFrames.rbegin();
            ++aRIter;
            if (aRIter->maApoProps == CurrentAPO())
                maFrames.pop_back();
        }

        maFrames.back().setend(rPaM, CurrentAPO());
    }
}

void rtfFrameManager::MoveStart(const SwNodeIndex &rOld, 
    const SwNodeIndex &rNew)
{
    if (!maFrames.empty())
    {
        if (maFrames.back().mnSttNd == rOld)
            maFrames.back().mnSttNd = rNew;
    }
}

void rtfFrameManager::StartPara(const SwPaM &rPaM)
{
    maFrames.push_back(rtfFrame(rPaM));
}

APOProperties &rtfFrameManager::CurrentAPO() 
{ 
    ASSERT(!maProps.empty(), "called without any paragraphs");
    //throw something
    return maProps.top();
}

void rtfFrameManager::ResetCurrentEnvironment()
{
    ASSERT(!maFrames.empty(), "called without any paragraphs");
    CurrentAPO() = APOProperties();
}

bool rtfFrameManager::HandleToken(int nToken, long nTokenValue)
{
    return CurrentAPO().HandleToken(nToken, nTokenValue);
}

void rtfFrameManager::EnterEnvironment()
{
    if (maProps.empty())
        maProps.push(APOProperties());
    else
        maProps.push(maProps.top());
}

void rtfFrameManager::LeaveEnvironment()
{
    ASSERT(!maProps.empty(), "should not be empty");
    if (!maProps.empty())
        maProps.pop();
}

rtfFrameManager::rtfFrameManager()
{
    EnterEnvironment();
}

rtfFrameManager::~rtfFrameManager()
{
    ASSERT(maProps.size() == 1, "Expected only 1 environment at dtor, no problem though");
    while (!maProps.empty())
        maProps.pop();
}

void SwRTFParser::InsertPara()
{
    bContainsPara = true;
	CheckInsNewTblLine();
    maFrameManager.EndPara(*pPam);
	pDoc->AppendTxtNode(*pPam->GetPoint());
    maFrameManager.StartPara(*pPam);

	// setze das default Style
	if( !bStyleTabValid )


	::SetProgressState( rInput.Tell(), pDoc->GetDocShell() );
}



void SwRTFParser::MovePos( int bForward )
{




 *
 *  $RCSfile: swparrtf.hxx,v $
 *
 *  $Revision: 1.14.14.2 $
 *
 *  last change: $Author: cmc $ $Date: 2004/01/22 17:17:56 $
 *
 *  The Contents of this file are made available subject to the terms of
 *  either of the following licenses

#ifndef _SWPARRTF_HXX
#define _SWPARRTF_HXX

#ifndef __SGI_STL_MAP
#include <map>
#endif
#ifndef __SGI_STL_DEQUE
#include <deque>
#include <stack>
#ifndef __SGI_STL_VECTOR
#include <vector>
#endif

#ifndef _SVSTDARR_HXX
#define _SVSTDARR_BOOLS

#endif

#ifndef SW_MS_MSFILTER_HXX
#include <msfilter.hxx>
#endif

extern void GetLineIndex(SvxBoxItem &rBox, short nLineThickness, short nSpace, BYTE nCol, short nIdx,

    bool IsLandScape() const { return maPageInfo.mbLndscpsxn; }
};

class TokenHandler
{
public:
    virtual bool HandleToken(int nToken, long nTokenValue) = 0;
};

enum horirel {phmrg, phpg, phcol};
enum horiori {posxnone, posxc, posxi, posxo, posxr, posxl};
enum vertrel {pvmrg, pvpg, pvpara};
enum vertori {posynone, posyil, posyt, posyc, posyb, posyin, posyout};
enum dropcap {none = 0, intext = 1, margin = 2};
enum textflow {frmtxlrtb, frmtxtbrl, frmtxbtlr, frmtxlrtbv, frmtxtbrlv};

//See RTF Specification 1.6 Section "Positioned Objects and Frames" for details
class APOProperties : public TokenHandler
{
public:
    //Frame Size
    long absw;
    long absh;
    //Horizontal Position
    horirel eHoriRel;   //phmrg, phpg, phcol
    long posx;          //posx, posnegx
    horiori eHoriOri;   //posxc, posxi, posxo, posxr, posxl
    //Vertical Position
    vertrel eVertRel;   //pvmrg, pvpg, pvpara
    long posy;          //posy, posnegy
    vertori eVertOri;   //posyil, posyt, posyc, posyb, posyin, posyout
    bool abslock;
    //Text Wrapping
    bool nowrap;
    long dfrmtxtx;      //dfrmtxtx, dxfrtext
    long dfrmtxty;      //dfrmtxty, dxfrtext
    bool overlay;
    //Drop Caps
    long dropcapli;
    dropcap dropcapt;
    //Overlap
    bool absnoovrlp;
    //Text Flow
    textflow eFlow;    //frmtxlrtb, frmtxtbrl, frmtxbtlr, frmtxlrtbv, frmtxtbrlv

    APOProperties();
    bool HandleToken(int nToken, long nTokenValue);
    bool operator==(const APOProperties& rOther) const;
};

class rtfFrame
{
public:
    APOProperties maApoProps;
    SwNodeIndex mnSttNd, mnEndNd;
    xub_StrLen  mnSttCnt, mnEndCnt;
    rtfFrame(const SwPaM &rPaM);
    void setend(const SwPaM &rPaM, const APOProperties &rApoProperties);
    void ConvertToItemSet(SfxItemSet &rSet) const;
};

/*
 A lot of the current code in the filter sees a token of e.g. frame type and
 loops through all the following tokens until it sees one it doesn't know and
 considers that the end of all the frame positioning tokens. This is clearly
 rubbish, as the spec clearly says "These control words can appear anywhere in
 the body of the paragraph, not just at the beginning." Instead we should
 gather this information inside the range in which it has an effect and make
 our decisions when we leave that environment and know at that stage that we
 have seen all the possible tokens that will affect our decision

 In other words the rtfFrameManager and related classes are right, nearly
 everthing else is probably wrong :-(. But one step at a time
*/
class rtfFrameManager : public TokenHandler
{
private:
    std::stack<APOProperties> maProps;
    std::deque<rtfFrame> maFrames;
    typedef std::deque<rtfFrame>::const_iterator mycIter;
    typedef std::deque<rtfFrame>::reverse_iterator myrIter;
public:
    APOProperties &CurrentAPO();

    void EnterEnvironment();
    void ResetCurrentEnvironment();
    void LeaveEnvironment();

    void StartPara(const SwPaM &rPaM);
    void MoveStart(const SwNodeIndex &rOld, const SwNodeIndex &rNew);
    void EndPara(const SwPaM &rPaM);

    bool HandleToken(int nToken, long nTokenValue);

    void MakeFlyFrames(const SwRTFParser &rReader) const;

    rtfFrameManager();
    ~rtfFrameManager();
};

class rtfSections
{
private:

    */
    sw::util::ParaStyleMapper maParaStyleMapper;
    sw::util::CharStyleMapper maCharStyleMapper;

    /*
     The default page settings
    */
    DocPageInformation maPageDefaults;

    /*
     All the sections which are inserted into the document
    */
    friend class rtfSections;
    rtfSections maSegments;

    /*
     All the frames (Absolutely Positioned Objects) which are inserted into the
     document
    */
    friend class rtfFrameManager;
    rtfFrameManager maFrameManager;
    virtual void EnterEnvironment();
    virtual void LeaveEnvironment();
    virtual void ResetPard();
	virtual void InsertPara();
    
    std::map<SwTableNode *, SwNodeIndex *> maTables;
	SwRTFStyleTbl aTxtCollTbl;
	SwRTFCharStyleTbl aCharFmtTbl;

    */
    bool CantUseTables() const { return mbReadNoTbl || mbIsFootnote; }

	virtual void InsertPara();
	virtual void InsertText();
	virtual void MovePos( int bForward = TRUE );
	virtual void SetEndPrevPara( SvxNodeIdx*& rpNodePos, xub_StrLen& rCntPos );

							SfxItemSet& rSet, const SvxRTFPictureType* = 0  );

	void SetFlysInDoc();
	void GetPageSize(Size& rSize) const;		// Groesse der PagePrintArea

	// fuers Einlesen von Tabellen
	void GotoNextBox();

								const SwNodeIndex& rEnd );
	void SetNumLSpace( SwTxtNode& rNd, const SwNodeNum& rNum,
								const SwNumRule& rRule );
    long GetSafePos(long nPos);

protected:
	// wird fuer jedes Token gerufen, das in CallParser erkannt wird
	virtual void NextToken( int nToken );

	void SetPageInformationAsDefault(const DocPageInformation &rInfo);
	void ReadSectControls( int nToken );
	void DoHairyWriterPageDesc(int nToken);
	bool ReadFly(int nToken);
	void ReadTable( int nToken );
	void ReadPageDescTbl();


Return to issue 15020

Lines 2-10 Link Here

(-)swparrtf.cxx (-48 / +184 lines)
2	*	2	*
3	* $RCSfile: swparrtf.cxx,v $	3	* $RCSfile: swparrtf.cxx,v $
4	*	4	*
5	* $Revision: 1.35 $	5	* $Revision: 1.34.14.2 $
6	*	6	*
7	* last change: $Author: obo $ $Date: 2004/01/13 16:51:23 $	7	* last change: $Author: cmc $ $Date: 2004/01/22 17:17:44 $
8	*	8	*
9	* The Contents of this file are made available subject to the terms of	9	* The Contents of this file are made available subject to the terms of
10	* either of the following licenses	10	* either of the following licenses
Lines 250-260 Link Here
250	#include <SwStyleNameMapper.hxx>	250	#include <SwStyleNameMapper.hxx>
251	#endif	251	#endif
252		252
253	#ifndef SW_MS_MSFILTER_HXX
254	#include <msfilter.hxx>
255	#endif
256	#ifndef WW_WWSTYLES_HXX	253	#ifndef WW_WWSTYLES_HXX
257	#include "../inc/wwstyles.hxx"	254	# include <wwstyles.hxx>
258	#endif	255	#endif
259	// einige Hilfs-Funktionen	256	// einige Hilfs-Funktionen
260	// char	257	// char
Lines 323-334 Link Here
323	SetReadDocInfo( TRUE );	320	SetReadDocInfo( TRUE );
324		321
325	// diese sollen zusaetzlich ueber \pard zurueck gesetzt werden	322	// diese sollen zusaetzlich ueber \pard zurueck gesetzt werden
326	USHORT temp;	323	AddPlainAttr(RES_TXTATR_CHARFMT);
327	temp = RES_TXTATR_CHARFMT; AddPlainAttr( temp );	324	AddPardAttr(RES_PAGEDESC);
328	temp = RES_PAGEDESC; AddPardAttr( temp );	325	AddPardAttr(RES_BREAK);
329	temp = RES_BREAK; AddPardAttr( temp );	326	AddPardAttr(RES_PARATR_NUMRULE);
330	temp = RES_PARATR_NUMRULE; AddPardAttr( temp );	327	AddPardAttr(FN_PARAM_NUM_LEVEL);
331	temp = FN_PARAM_NUM_LEVEL; AddPardAttr( temp );	328
		329	maFrameManager.StartPara(*pPam);
		330	}
		331
		332	//The defaults according to the RTF 1.6 Specification with a little obvious
		333	//extrapolation from section "Positioned Objects and Frames"
		334	APOProperties::APOProperties()
		335	: absh(0), absw(0), eHoriRel(phcol), posx(0), eHoriOri(posxl),
		336	eVertRel(pvmrg), posy(0), eVertOri(posynone), abslock(false), nowrap(false),
		337	dfrmtxtx(0), dfrmtxty(0), overlay(false), dropcapli(0), dropcapt(none),
		338	absnoovrlp(false), eFlow(frmtxlrtb)
		339	{
		340	}
		341
		342	bool APOProperties::operator==(const APOProperties& rOther) const
		343	{
		344	return
		345	(
		346	absw == rOther.absw &&
		347	absh == rOther.absh &&
		348	eHoriRel == rOther.eHoriRel &&
		349	posx == rOther.posx &&
		350	eHoriOri == rOther.eHoriOri &&
		351	eVertRel == rOther.eVertRel &&
		352	posy == rOther.posy &&
		353	eVertOri == rOther.eVertOri &&
		354	abslock == rOther.abslock &&
		355	nowrap == rOther.nowrap &&
		356	dfrmtxtx == rOther.dfrmtxtx &&
		357	dfrmtxty == rOther.dfrmtxty &&
		358	overlay == rOther.overlay &&
		359	dropcapli == rOther.dropcapli &&
		360	dropcapt == rOther.dropcapt &&
		361	absnoovrlp == rOther.absnoovrlp &&
		362	eFlow == rOther.eFlow
		363	);
		364	}
		365
		366	void SwRTFParser::EnterEnvironment()
		367	{
		368	maFrameManager.EnterEnvironment();
		369	}
		370
		371	void SwRTFParser::LeaveEnvironment()
		372	{
		373	maFrameManager.LeaveEnvironment();
		374	}
		375
		376	void SwRTFParser::ResetPard()
		377	{
		378	maFrameManager.ResetCurrentEnvironment();
		379	}
		380
		381	void SwRTFParser::InsertText()
		382	{
		383	bContainsPara = false;
		384	// dann fuege den String ein, ohne das Attribute am Ende
		385	// aufgespannt werden.
		386	CheckInsNewTblLine();
		387	pDoc->Insert( *pPam, aToken );
332	}	388	}
333		389
334	// Aufruf des Parsers	390	// Aufruf des Parsers
Lines 574-579 Link Here
574	else if( GetDocInfo() )	630	else if( GetDocInfo() )
575	// evt. eingelesen DocInfo setzen	631	// evt. eingelesen DocInfo setzen
576	pDoc->SetInfo( *GetDocInfo() );	632	pDoc->SetInfo( *GetDocInfo() );
		633
		634	maFrameManager.MakeFlyFrames(*this);
577	}	635	}
578	delete pSttNdIdx, pSttNdIdx = 0;	636	delete pSttNdIdx, pSttNdIdx = 0;
579	delete pRegionEndIdx, pRegionEndIdx = 0;	637	delete pRegionEndIdx, pRegionEndIdx = 0;
Lines 1309-1315 Link Here
1309	// Tabelle nicht mehr vorhanden ?	1367	// Tabelle nicht mehr vorhanden ?
1310	if (USHRT_MAX != nInsTblRow && !pTableNode)	1368	if (USHRT_MAX != nInsTblRow && !pTableNode)
1311	NewTblLine(); // evt. Line copieren	1369	NewTblLine(); // evt. Line copieren
		1370	maFrameManager.EndPara(*pPam);
1312	GotoNextBox();	1371	GotoNextBox();
		1372	maFrameManager.StartPara(*pPam);
1313	}	1373	}
1314	break;	1374	break;
1315		1375
Lines 1468-1524 Link Here
1468	// RTF_SUBENTRYINDEX	1528	// RTF_SUBENTRYINDEX
1469		1529
1470	default:	1530	default:
1471	switch( nToken & ~(0xff \| RTF_SWGDEFS) )	1531	{
1472	{	1532	/* Just to break this into its logical handlers we'll split the
1473	case RTF_DOCFMT:	1533	* remainder of the tokens into seperate handlers */
1474	ReadDocControls( nToken );	1534	bool bHandled = maFrameManager.HandleToken(nToken, nTokenValue);
1475	break;	1535	if (!bHandled)
1476	case RTF_SECTFMT:	1536	{
1477	ReadSectControls( nToken );	1537	//Legacy messy code
1478	break;	1538	switch( nToken & ~(0xff \| RTF_SWGDEFS) )
1479	case RTF_APOCTL:	1539	{
1480	ReadFly( nToken );	1540	case RTF_DOCFMT:
1481	break;	1541	ReadDocControls( nToken );
1482	case RTF_BRDRDEF \| RTF_TABLEDEF:	1542	break;
1483	case RTF_SHADINGDEF \| RTF_TABLEDEF:	1543	case RTF_SECTFMT:
1484	case RTF_TABLEDEF:	1544	ReadSectControls( nToken );
1485	ReadTable( nToken );	1545	break;
1486	break;	1546	case RTF_BRDRDEF \| RTF_TABLEDEF:
1487		1547	case RTF_SHADINGDEF \| RTF_TABLEDEF:
1488	case RTF_INFO:	1548	case RTF_TABLEDEF:
1489	ReadInfo();	1549	ReadTable( nToken );
1490	break;	1550	break;
1491		1551
1492	default:	1552	case RTF_INFO:
1493	if( USHRT_MAX != nInsTblRow &&	1553	ReadInfo();
1494	(nInsTblRow > GetOpenBrakets() \|\| IsPardTokenRead() ))	1554	break;
1495	nInsTblRow = USHRT_MAX;	1555	}
		1556	}
1496		1557
1497	SvxRTFParser::NextToken( nToken );	1558	if (!bHandled)
1498	break;	1559	{
1499	}	1560	if( USHRT_MAX != nInsTblRow &&
		1561	(nInsTblRow > GetOpenBrakets() \|\| IsPardTokenRead() ))
		1562	nInsTblRow = USHRT_MAX;
		1563
		1564	SvxRTFParser::NextToken( nToken );
		1565	}
		1566	}
		1567	break;
1500	}	1568	}
1501	if( USHRT_MAX != nInsTblRow &&	1569	if( USHRT_MAX != nInsTblRow &&
1502	(nInsTblRow > GetOpenBrakets() \|\| IsPardTokenRead() ))	1570	(nInsTblRow > GetOpenBrakets() \|\| IsPardTokenRead() ))
1503	nInsTblRow = USHRT_MAX;	1571	nInsTblRow = USHRT_MAX;
1504	}	1572	}
1505		1573
		1574	void rtfFrameManager::EndPara(const SwPaM &rPaM)
		1575	{
		1576	ASSERT(!maFrames.empty(), "called without any paragraphs");
		1577	if (!maFrames.empty())
		1578	{
		1579	if (maFrames.size() > 1)
		1580	{
		1581	//Consecutive paragraphs with the same frame
		1582	//formatting are considered part of the same frame.
		1583	myrIter aRIter = maFrames.rbegin();
		1584	++aRIter;
		1585	if (aRIter->maApoProps == CurrentAPO())
		1586	maFrames.pop_back();
		1587	}
1506		1588
1507	void SwRTFParser::InsertText()	1589	maFrames.back().setend(rPaM, CurrentAPO());
		1590	}
		1591	}
		1592
		1593	void rtfFrameManager::MoveStart(const SwNodeIndex &rOld,
		1594	const SwNodeIndex &rNew)
1508	{	1595	{
1509	bContainsPara = false;	1596	if (!maFrames.empty())
1510	// dann fuege den String ein, ohne das Attribute am Ende	1597	{
1511	// aufgespannt werden.	1598	if (maFrames.back().mnSttNd == rOld)
1512	CheckInsNewTblLine();	1599	maFrames.back().mnSttNd = rNew;
1513	pDoc->Insert( *pPam, aToken );	1600	}
1514	}	1601	}
1515		1602
		1603	void rtfFrameManager::StartPara(const SwPaM &rPaM)
		1604	{
		1605	maFrames.push_back(rtfFrame(rPaM));
		1606	}
		1607
		1608	APOProperties &rtfFrameManager::CurrentAPO()
		1609	{
		1610	ASSERT(!maProps.empty(), "called without any paragraphs");
		1611	//throw something
		1612	return maProps.top();
		1613	}
		1614
		1615	void rtfFrameManager::ResetCurrentEnvironment()
		1616	{
		1617	ASSERT(!maFrames.empty(), "called without any paragraphs");
		1618	CurrentAPO() = APOProperties();
		1619	}
		1620
		1621	bool rtfFrameManager::HandleToken(int nToken, long nTokenValue)
		1622	{
		1623	return CurrentAPO().HandleToken(nToken, nTokenValue);
		1624	}
		1625
		1626	void rtfFrameManager::EnterEnvironment()
		1627	{
		1628	if (maProps.empty())
		1629	maProps.push(APOProperties());
		1630	else
		1631	maProps.push(maProps.top());
		1632	}
		1633
		1634	void rtfFrameManager::LeaveEnvironment()
		1635	{
		1636	ASSERT(!maProps.empty(), "should not be empty");
		1637	if (!maProps.empty())
		1638	maProps.pop();
		1639	}
		1640
		1641	rtfFrameManager::rtfFrameManager()
		1642	{
		1643	EnterEnvironment();
		1644	}
		1645
		1646	rtfFrameManager::~rtfFrameManager()
		1647	{
		1648	ASSERT(maProps.size() == 1, "Expected only 1 environment at dtor, no problem though");
		1649	while (!maProps.empty())
		1650	maProps.pop();
		1651	}
1516		1652
1517	void SwRTFParser::InsertPara()	1653	void SwRTFParser::InsertPara()
1518	{	1654	{
1519	bContainsPara = true;	1655	bContainsPara = true;
1520	CheckInsNewTblLine();	1656	CheckInsNewTblLine();
		1657	maFrameManager.EndPara(*pPam);
1521	pDoc->AppendTxtNode(*pPam->GetPoint());	1658	pDoc->AppendTxtNode(*pPam->GetPoint());
		1659	maFrameManager.StartPara(*pPam);
1522		1660
1523	// setze das default Style	1661	// setze das default Style
1524	if( !bStyleTabValid )	1662	if( !bStyleTabValid )
Lines 1531-1538 Link Here
1531		1669
1532	::SetProgressState( rInput.Tell(), pDoc->GetDocShell() );	1670	::SetProgressState( rInput.Tell(), pDoc->GetDocShell() );
1533	}	1671	}
1534
1535
1536		1672
1537	void SwRTFParser::MovePos( int bForward )	1673	void SwRTFParser::MovePos( int bForward )
1538	{	1674	{

Lines 2-10 Link Here

(-)swparrtf.hxx (-16 / +123 lines)
2	*	2	*
3	* $RCSfile: swparrtf.hxx,v $	3	* $RCSfile: swparrtf.hxx,v $
4	*	4	*
5	* $Revision: 1.15 $	5	* $Revision: 1.14.14.2 $
6	*	6	*
7	* last change: $Author: obo $ $Date: 2004/01/13 16:51:53 $	7	* last change: $Author: cmc $ $Date: 2004/01/22 17:17:56 $
8	*	8	*
9	* The Contents of this file are made available subject to the terms of	9	* The Contents of this file are made available subject to the terms of
10	* either of the following licenses	10	* either of the following licenses
Lines 64-78 Link Here
64	#ifndef _SWPARRTF_HXX	64	#ifndef _SWPARRTF_HXX
65	#define _SWPARRTF_HXX	65	#define _SWPARRTF_HXX
66		66
67	#ifndef __SGI_STL_MAP
68	#include <map>	67	#include <map>
69	#endif
70	#ifndef __SGI_STL_DEQUE
71	#include <deque>	68	#include <deque>
72	#endif	69	#include <stack>
73	#ifndef __SGI_STL_VECTOR
74	#include <vector>	70	#include <vector>
75	#endif
76		71
77	#ifndef _SVSTDARR_HXX	72	#ifndef _SVSTDARR_HXX
78	#define _SVSTDARR_BOOLS	73	#define _SVSTDARR_BOOLS
Lines 93-99 Link Here
93	#endif	88	#endif
94		89
95	#ifndef SW_MS_MSFILTER_HXX	90	#ifndef SW_MS_MSFILTER_HXX
96	#include "../inc/msfilter.hxx"	91	#include <msfilter.hxx>
97	#endif	92	#endif
98		93
99	extern void GetLineIndex(SvxBoxItem &rBox, short nLineThickness, short nSpace, BYTE nCol, short nIdx,	94	extern void GetLineIndex(SvxBoxItem &rBox, short nLineThickness, short nSpace, BYTE nCol, short nIdx,
Lines 273-278 Link Here
273	bool IsLandScape() const { return maPageInfo.mbLndscpsxn; }	268	bool IsLandScape() const { return maPageInfo.mbLndscpsxn; }
274	};	269	};
275		270
		271	class TokenHandler
		272	{
		273	public:
		274	virtual bool HandleToken(int nToken, long nTokenValue) = 0;
		275	};
		276
		277	enum horirel {phmrg, phpg, phcol};
		278	enum horiori {posxnone, posxc, posxi, posxo, posxr, posxl};
		279	enum vertrel {pvmrg, pvpg, pvpara};
		280	enum vertori {posynone, posyil, posyt, posyc, posyb, posyin, posyout};
		281	enum dropcap {none = 0, intext = 1, margin = 2};
		282	enum textflow {frmtxlrtb, frmtxtbrl, frmtxbtlr, frmtxlrtbv, frmtxtbrlv};
		283
		284	//See RTF Specification 1.6 Section "Positioned Objects and Frames" for details
		285	class APOProperties : public TokenHandler
		286	{
		287	public:
		288	//Frame Size
		289	long absw;
		290	long absh;
		291	//Horizontal Position
		292	horirel eHoriRel; //phmrg, phpg, phcol
		293	long posx; //posx, posnegx
		294	horiori eHoriOri; //posxc, posxi, posxo, posxr, posxl
		295	//Vertical Position
		296	vertrel eVertRel; //pvmrg, pvpg, pvpara
		297	long posy; //posy, posnegy
		298	vertori eVertOri; //posyil, posyt, posyc, posyb, posyin, posyout
		299	bool abslock;
		300	//Text Wrapping
		301	bool nowrap;
		302	long dfrmtxtx; //dfrmtxtx, dxfrtext
		303	long dfrmtxty; //dfrmtxty, dxfrtext
		304	bool overlay;
		305	//Drop Caps
		306	long dropcapli;
		307	dropcap dropcapt;
		308	//Overlap
		309	bool absnoovrlp;
		310	//Text Flow
		311	textflow eFlow; //frmtxlrtb, frmtxtbrl, frmtxbtlr, frmtxlrtbv, frmtxtbrlv
		312
		313	APOProperties();
		314	bool HandleToken(int nToken, long nTokenValue);
		315	bool operator==(const APOProperties& rOther) const;
		316	};
		317
		318	class rtfFrame
		319	{
		320	public:
		321	APOProperties maApoProps;
		322	SwNodeIndex mnSttNd, mnEndNd;
		323	xub_StrLen mnSttCnt, mnEndCnt;
		324	rtfFrame(const SwPaM &rPaM);
		325	void setend(const SwPaM &rPaM, const APOProperties &rApoProperties);
		326	void ConvertToItemSet(SfxItemSet &rSet) const;
		327	};
		328
		329	/*
		330	A lot of the current code in the filter sees a token of e.g. frame type and
		331	loops through all the following tokens until it sees one it doesn't know and
		332	considers that the end of all the frame positioning tokens. This is clearly
		333	rubbish, as the spec clearly says "These control words can appear anywhere in
		334	the body of the paragraph, not just at the beginning." Instead we should
335	gather this information inside the range in which it has an effect and make
336	our decisions when we leave that environment and know at that stage that we
337	have seen all the possible tokens that will affect our decision
338
339	In other words the rtfFrameManager and related classes are right, nearly
340	everthing else is probably wrong :-(. But one step at a time
341	*/
342	class rtfFrameManager : public TokenHandler
343	{
344	private:
345	std::stack<APOProperties> maProps;
346	std::deque<rtfFrame> maFrames;
347	typedef std::deque<rtfFrame>::const_iterator mycIter;
348	typedef std::deque<rtfFrame>::reverse_iterator myrIter;
349	public:
350	APOProperties &CurrentAPO();
351
352	void EnterEnvironment();
353	void ResetCurrentEnvironment();
354	void LeaveEnvironment();
355
356	void StartPara(const SwPaM &rPaM);
357	void MoveStart(const SwNodeIndex &rOld, const SwNodeIndex &rNew);
358	void EndPara(const SwPaM &rPaM);
359
360	bool HandleToken(int nToken, long nTokenValue);
361
362	void MakeFlyFrames(const SwRTFParser &rReader) const;
363
364	rtfFrameManager();
365	~rtfFrameManager();
366	};
367
276	class rtfSections	368	class rtfSections
277	{	369	{
278	private:	370	private:
Lines 323-333 Link Here
323	*/	415	*/
324	sw::util::ParaStyleMapper maParaStyleMapper;	416	sw::util::ParaStyleMapper maParaStyleMapper;
325	sw::util::CharStyleMapper maCharStyleMapper;	417	sw::util::CharStyleMapper maCharStyleMapper;
326		418
327	friend class rtfSections;	419	/*
		420	The default page settings
		421	*/
328	DocPageInformation maPageDefaults;	422	DocPageInformation maPageDefaults;
		423
		424	/*
		425	All the sections which are inserted into the document
		426	*/
		427	friend class rtfSections;
329	rtfSections maSegments;	428	rtfSections maSegments;
330		429
		430	/*
		431	All the frames (Absolutely Positioned Objects) which are inserted into the
		432	document
		433	*/
		434	friend class rtfFrameManager;
		435	rtfFrameManager maFrameManager;
		436	virtual void EnterEnvironment();
		437	virtual void LeaveEnvironment();
		438	virtual void ResetPard();
		439	virtual void InsertPara();
		440
331	std::map<SwTableNode , SwNodeIndex > maTables;	441	std::map<SwTableNode , SwNodeIndex > maTables;
332	SwRTFStyleTbl aTxtCollTbl;	442	SwRTFStyleTbl aTxtCollTbl;
333	SwRTFCharStyleTbl aCharFmtTbl;	443	SwRTFCharStyleTbl aCharFmtTbl;
Lines 368-374 Link Here
368	*/	478	*/
369	bool CantUseTables() const { return mbReadNoTbl \|\| mbIsFootnote; }	479	bool CantUseTables() const { return mbReadNoTbl \|\| mbIsFootnote; }
370		480
371	virtual void InsertPara();
372	virtual void InsertText();	481	virtual void InsertText();
373	virtual void MovePos( int bForward = TRUE );	482	virtual void MovePos( int bForward = TRUE );
374	virtual void SetEndPrevPara( SvxNodeIdx*& rpNodePos, xub_StrLen& rCntPos );	483	virtual void SetEndPrevPara( SvxNodeIdx*& rpNodePos, xub_StrLen& rCntPos );
Lines 415-421 Link Here
415	SfxItemSet& rSet, const SvxRTFPictureType* = 0 );	524	SfxItemSet& rSet, const SvxRTFPictureType* = 0 );
416		525
417	void SetFlysInDoc();	526	void SetFlysInDoc();
418	void GetPageSize( Size& rSize ); // Groesse der PagePrintArea	527	void GetPageSize(Size& rSize) const; // Groesse der PagePrintArea
419		528
420	// fuers Einlesen von Tabellen	529	// fuers Einlesen von Tabellen
421	void GotoNextBox();	530	void GotoNextBox();
Lines 429-436 Link Here
429	const SwNodeIndex& rEnd );	538	const SwNodeIndex& rEnd );
430	void SetNumLSpace( SwTxtNode& rNd, const SwNodeNum& rNum,	539	void SetNumLSpace( SwTxtNode& rNd, const SwNodeNum& rNum,
431	const SwNumRule& rRule );	540	const SwNumRule& rRule );
432	long GetSafePos(long nPos);
433
434	protected:	541	protected:
435	// wird fuer jedes Token gerufen, das in CallParser erkannt wird	542	// wird fuer jedes Token gerufen, das in CallParser erkannt wird
436	virtual void NextToken( int nToken );	543	virtual void NextToken( int nToken );
Lines 452-458 Link Here
452	void SetPageInformationAsDefault(const DocPageInformation &rInfo);	559	void SetPageInformationAsDefault(const DocPageInformation &rInfo);
453	void ReadSectControls( int nToken );	560	void ReadSectControls( int nToken );
454	void DoHairyWriterPageDesc(int nToken);	561	void DoHairyWriterPageDesc(int nToken);
455	void ReadFly( int nToken, SfxItemSet* pFillSet = 0 );	562	bool ReadFly(int nToken);
456	void ReadTable( int nToken );	563	void ReadTable( int nToken );
457	void ReadPageDescTbl();	564	void ReadPageDescTbl();
458		565