xref: /aoo41x/main/sw/source/filter/html/htmldraw.cxx (revision 5222b95b)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sw.hxx"


#include "hintids.hxx"
#include <vcl/svapp.hxx>
#include <vcl/wrkwin.hxx>
#include <svx/svdmodel.hxx>
#include <svx/svdpage.hxx>
#include <svx/svdobj.hxx>
#include <svx/svdotext.hxx>
#include <editeng/eeitem.hxx>

#ifndef _OUTLINER_HXX //autogen
#define _EEITEMID_HXX
#include <editeng/outliner.hxx>
#endif
#include <svx/xfillit.hxx>
#include <editeng/colritem.hxx>
#include <editeng/brshitem.hxx>
#include <editeng/lrspitem.hxx>
#include <editeng/ulspitem.hxx>
#include <svl/itemiter.hxx>
#include <svl/whiter.hxx>
#include <svtools/htmlout.hxx>
#include <svtools/htmltokn.h>
#include <svtools/htmlkywd.hxx>
#include <svx/svdpool.hxx>


#include "charatr.hxx"
#include <frmfmt.hxx>
#include <fmtanchr.hxx>
#include <fmtsrnd.hxx>
#include "ndtxt.hxx"
#include "doc.hxx"
#include "dcontact.hxx"
#include "poolfmt.hxx"
#include "swcss1.hxx"
#include "swhtml.hxx"
#include "wrthtml.hxx"

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


const sal_uInt32 HTML_FRMOPTS_MARQUEE 	=
	HTML_FRMOPT_ALIGN |
	HTML_FRMOPT_SPACE;

const sal_uInt32 HTML_FRMOPTS_MARQUEE_CSS1 	=
	HTML_FRMOPT_S_ALIGN |
	HTML_FRMOPT_S_SPACE;

static HTMLOptionEnum __FAR_DATA aHTMLMarqBehaviorTable[] =
{
	{ OOO_STRING_SVTOOLS_HTML_BEHAV_scroll,		SDRTEXTANI_SCROLL		},
	{ OOO_STRING_SVTOOLS_HTML_BEHAV_alternate,	SDRTEXTANI_ALTERNATE	},
	{ OOO_STRING_SVTOOLS_HTML_BEHAV_slide,		SDRTEXTANI_SLIDE		},
	{ 0,						0						}
};

static HTMLOptionEnum __FAR_DATA aHTMLMarqDirectionTable[] =
{
	{ OOO_STRING_SVTOOLS_HTML_AL_left,			SDRTEXTANI_LEFT			},
	{ OOO_STRING_SVTOOLS_HTML_AL_right,			SDRTEXTANI_RIGHT		},
	{ 0,						0						}
};

/*  */
void SwHTMLParser::InsertDrawObject( SdrObject* pNewDrawObj,
									 const Size& rPixSpace,
                                     sal_Int16 eVertOri,
                                     sal_Int16 eHoriOri,
									 SfxItemSet& rCSS1ItemSet,
									 SvxCSS1PropertyInfo& rCSS1PropInfo,
									 sal_Bool bHidden )
{
    // always on top of text.
    // OD 02.07.2003 #108784# but in invisible layer. <ConnectToLayout> will
    // move the object to the visible layer.
    pNewDrawObj->SetLayer( pDoc->GetInvisibleHeavenId() );

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

	sal_uInt16 nLeftSpace = 0, nRightSpace = 0, nUpperSpace = 0, nLowerSpace = 0;
	if( (rPixSpace.Width() || rPixSpace.Height()) && Application::GetDefaultDevice() )
	{
		Size aTwipSpc( rPixSpace.Width(), rPixSpace.Height() );
		aTwipSpc =
			Application::GetDefaultDevice()->PixelToLogic( aTwipSpc,
												MapMode(MAP_TWIP) );
		nLeftSpace = nRightSpace = (sal_uInt16)aTwipSpc.Width();
		nUpperSpace = nLowerSpace = (sal_uInt16)aTwipSpc.Height();
	}

	// linken/rechten Rand setzen
	const SfxPoolItem *pItem;
	if( SFX_ITEM_SET==rCSS1ItemSet.GetItemState( RES_LR_SPACE, sal_True, &pItem ) )
	{
		// Ggf. den Erstzeilen-Einzug noch plaetten
		const SvxLRSpaceItem *pLRItem = (const SvxLRSpaceItem *)pItem;
		SvxLRSpaceItem aLRItem( *pLRItem );
		aLRItem.SetTxtFirstLineOfst( 0 );
		if( rCSS1PropInfo.bLeftMargin )
		{
            nLeftSpace = static_cast< sal_uInt16 >(aLRItem.GetLeft());
			rCSS1PropInfo.bLeftMargin = sal_False;
		}
		if( rCSS1PropInfo.bRightMargin )
		{
            nRightSpace = static_cast< sal_uInt16 >(aLRItem.GetRight());
			rCSS1PropInfo.bRightMargin = sal_False;
		}
		rCSS1ItemSet.ClearItem( RES_LR_SPACE );
	}
	if( nLeftSpace || nRightSpace )
	{
        SvxLRSpaceItem aLRItem( RES_LR_SPACE );
		aLRItem.SetLeft( nLeftSpace );
		aLRItem.SetRight( nRightSpace );
		aFrmSet.Put( aLRItem );
	}

	// oberen/unteren Rand setzen
	if( SFX_ITEM_SET==rCSS1ItemSet.GetItemState( RES_UL_SPACE, sal_True, &pItem ) )
	{
		// Ggf. den Erstzeilen-Einzug noch plaetten
		const SvxULSpaceItem *pULItem = (const SvxULSpaceItem *)pItem;
		if( rCSS1PropInfo.bTopMargin )
		{
			nUpperSpace = pULItem->GetUpper();
			rCSS1PropInfo.bTopMargin = sal_False;
		}
		if( rCSS1PropInfo.bBottomMargin )
		{
			nLowerSpace = pULItem->GetLower();
			rCSS1PropInfo.bBottomMargin = sal_False;
		}

		rCSS1ItemSet.ClearItem( RES_UL_SPACE );
	}
	if( nUpperSpace || nLowerSpace )
	{
        SvxULSpaceItem aULItem( RES_UL_SPACE );
		aULItem.SetUpper( nUpperSpace );
		aULItem.SetLower( nLowerSpace );
		aFrmSet.Put( aULItem );
	}

    SwFmtAnchor aAnchor( FLY_AS_CHAR );
	if( SVX_CSS1_POS_ABSOLUTE == rCSS1PropInfo.ePosition &&
		SVX_CSS1_LTYPE_TWIP == rCSS1PropInfo.eLeftType &&
		SVX_CSS1_LTYPE_TWIP	== rCSS1PropInfo.eTopType )
	{
		const SwStartNode *pFlySttNd =
            pPam->GetPoint()->nNode.GetNode().FindFlyStartNode();

		if( pFlySttNd )
		{
			aAnchor.SetType( FLY_AT_FLY );
			SwPosition aPos( *pFlySttNd );
			aAnchor.SetAnchor( &aPos );
		}
		else
        {
            aAnchor.SetType( FLY_AT_PAGE );
        }
        // OD 2004-04-13 #i26791# - direct positioning for <SwDoc::Insert(..)>
        pNewDrawObj->SetRelativePos( Point(rCSS1PropInfo.nLeft + nLeftSpace,
										   rCSS1PropInfo.nTop + nUpperSpace) );
		aFrmSet.Put( SwFmtSurround(SURROUND_THROUGHT) );
	}
	else if( SVX_ADJUST_LEFT == rCSS1PropInfo.eFloat ||
             text::HoriOrientation::LEFT == eHoriOri )
    {
        aAnchor.SetType( FLY_AT_PARA );
		aFrmSet.Put( SwFmtSurround(bHidden ? SURROUND_THROUGHT
											 : SURROUND_RIGHT) );
        // OD 2004-04-13 #i26791# - direct positioning for <SwDoc::Insert(..)>
		pNewDrawObj->SetRelativePos( Point(nLeftSpace, nUpperSpace) );
	}
    else if( text::VertOrientation::NONE != eVertOri )
	{
		aFrmSet.Put( SwFmtVertOrient( 0, eVertOri ) );
	}

    if (FLY_AT_PAGE == aAnchor.GetAnchorId())
    {
		aAnchor.SetPageNum( 1 );
    }
	else if( FLY_AT_FLY != aAnchor.GetAnchorId() )
    {
		aAnchor.SetAnchor( pPam->GetPoint() );
    }
	aFrmSet.Put( aAnchor );

	pDoc->InsertDrawObj( *pPam, *pNewDrawObj, aFrmSet );
}

/*  */

static void PutEEPoolItem( SfxItemSet &rEEItemSet,
						   const SfxPoolItem& rSwItem )
{

	sal_uInt16 nEEWhich = 0;

	switch( rSwItem.Which() )
	{
	case RES_CHRATR_COLOR:			nEEWhich = EE_CHAR_COLOR; break;
	case RES_CHRATR_CROSSEDOUT:		nEEWhich = EE_CHAR_STRIKEOUT; break;
	case RES_CHRATR_ESCAPEMENT:		nEEWhich = EE_CHAR_ESCAPEMENT; break;
	case RES_CHRATR_FONT:			nEEWhich = EE_CHAR_FONTINFO; break;
	case RES_CHRATR_CJK_FONT:		nEEWhich = EE_CHAR_FONTINFO_CJK; break;
	case RES_CHRATR_CTL_FONT:		nEEWhich = EE_CHAR_FONTINFO_CTL; break;
	case RES_CHRATR_FONTSIZE:		nEEWhich = EE_CHAR_FONTHEIGHT; break;
	case RES_CHRATR_CJK_FONTSIZE:	nEEWhich = EE_CHAR_FONTHEIGHT_CJK; break;
	case RES_CHRATR_CTL_FONTSIZE:	nEEWhich = EE_CHAR_FONTHEIGHT_CTL; break;
	case RES_CHRATR_KERNING: 		nEEWhich = EE_CHAR_KERNING; break;
	case RES_CHRATR_POSTURE: 		nEEWhich = EE_CHAR_ITALIC; break;
	case RES_CHRATR_CJK_POSTURE: 	nEEWhich = EE_CHAR_ITALIC_CJK; break;
	case RES_CHRATR_CTL_POSTURE: 	nEEWhich = EE_CHAR_ITALIC_CTL; break;
	case RES_CHRATR_UNDERLINE:		nEEWhich = EE_CHAR_UNDERLINE; break;
	case RES_CHRATR_WEIGHT:   		nEEWhich = EE_CHAR_WEIGHT; break;
	case RES_CHRATR_CJK_WEIGHT:   	nEEWhich = EE_CHAR_WEIGHT_CJK; break;
	case RES_CHRATR_CTL_WEIGHT:   	nEEWhich = EE_CHAR_WEIGHT_CTL; break;
	case RES_BACKGROUND:
	case RES_CHRATR_BACKGROUND:
		{
			const SvxBrushItem& rBrushItem = (const SvxBrushItem&)rSwItem;
			rEEItemSet.Put( XFillStyleItem(XFILL_SOLID) );
			rEEItemSet.Put( XFillColorItem(aEmptyStr,
							rBrushItem.GetColor()) );
		}
		break;
	}

	if( nEEWhich )
	{
		SfxPoolItem *pEEItem = rSwItem.Clone();
		pEEItem->SetWhich( nEEWhich );
		rEEItemSet.Put( *pEEItem );
		delete pEEItem;
	}
}

void SwHTMLParser::NewMarquee( HTMLTable *pCurTable )
{

	ASSERT( !pMarquee, "Marquee in Marquee???" );
	aContents.Erase();

	String aId, aStyle, aClass;

	long nWidth=0, nHeight=0;
	sal_Bool bPrcWidth = sal_False, bDirection = sal_False, bBGColor = sal_False;
	Size aSpace( 0, 0 );
    sal_Int16 eVertOri = text::VertOrientation::TOP;
    sal_Int16 eHoriOri = text::HoriOrientation::NONE;
	SdrTextAniKind eAniKind = SDRTEXTANI_SCROLL;
	SdrTextAniDirection eAniDir = SDRTEXTANI_LEFT;
	sal_uInt16 nCount = 0, nDelay = 60;
	sal_Int16 nAmount = -6;
	Color aBGColor;

	const HTMLOptions *pHTMLOptions = GetOptions();
	sal_uInt16 nArrLen = pHTMLOptions->Count();
	for ( sal_uInt16 i=0; i<nArrLen; i++ )
	{
		const HTMLOption *pOption = (*pHTMLOptions)[i];
		switch( pOption->GetToken() )
		{
			case HTML_O_ID:
				aId = pOption->GetString();
				break;
			case HTML_O_STYLE:
				aStyle = pOption->GetString();
				break;
			case HTML_O_CLASS:
				aClass = pOption->GetString();
				break;

			case HTML_O_BEHAVIOR:
				eAniKind =
					(SdrTextAniKind)pOption->GetEnum( aHTMLMarqBehaviorTable,
                                                      static_cast< sal_uInt16 >(eAniKind) );
				break;

			case HTML_O_BGCOLOR:
				pOption->GetColor( aBGColor );
				bBGColor = sal_True;
				break;

			case HTML_O_DIRECTION:
				eAniDir =
					(SdrTextAniDirection)pOption->GetEnum( aHTMLMarqDirectionTable,
                                                      static_cast< sal_uInt16 >(eAniDir) );
				bDirection = sal_True;
				break;

			case HTML_O_LOOP:
				if( pOption->GetString().
						EqualsIgnoreCaseAscii(OOO_STRING_SVTOOLS_HTML_LOOP_infinite) )
				{
					nCount = 0;
				}
				else
				{
					sal_uInt32 nLoop = pOption->GetSNumber();
					nCount = (sal_uInt16)(nLoop>0 ? nLoop : 0 );
				}
				break;

			case HTML_O_SCROLLAMOUNT:
				nAmount = -((sal_Int16)pOption->GetNumber());
				break;

			case HTML_O_SCROLLDELAY:
				nDelay = (sal_uInt16)pOption->GetNumber();
				break;

			case HTML_O_WIDTH:
				// erstmal nur als Pixelwerte merken!
				nWidth = pOption->GetNumber();
				bPrcWidth = pOption->GetString().Search('%') != STRING_NOTFOUND;
				if( bPrcWidth && nWidth>100 )
					nWidth = 100;
				break;

			case HTML_O_HEIGHT:
				// erstmal nur als Pixelwerte merken!
				nHeight = pOption->GetNumber();
				if( pOption->GetString().Search('%') != STRING_NOTFOUND )
					nHeight = 0;
				break;

			case HTML_O_HSPACE:
				// erstmal nur als Pixelwerte merken!
				aSpace.Height() = pOption->GetNumber();
				break;

			case HTML_O_VSPACE:
				// erstmal nur als Pixelwerte merken!
				aSpace.Width() = pOption->GetNumber();
				break;

			case HTML_O_ALIGN:
				eVertOri =
                    pOption->GetEnum( aHTMLImgVAlignTable,
                                                    text::VertOrientation::TOP );
				eHoriOri =
                    pOption->GetEnum( aHTMLImgHAlignTable,
                                                    text::HoriOrientation::NONE );
				break;
		}
	}

	// Ein DrawTxtobj anlegen
    // --> OD 2005-08-08 #i52858# - method name changed
    SdrModel* pModel = pDoc->GetOrCreateDrawModel();
    // <--
	SdrPage* pPg = pModel->GetPage( 0 );
	pMarquee = SdrObjFactory::MakeNewObject( SdrInventor,
											 OBJ_TEXT, pPg, pModel );
	if( !pMarquee )
		return;

	pPg->InsertObject( pMarquee );

	if( aId.Len() )
		InsertBookmark( aId );

	// (Nur) Alternate leueft per Default von links nach rechts
	if( SDRTEXTANI_ALTERNATE==eAniKind && !bDirection )
		eAniDir = SDRTEXTANI_RIGHT;

	// die fuer das Scrollen benoetigten Attribute umsetzen
	sal_uInt16 aWhichMap[7] =	{ XATTR_FILL_FIRST,	  XATTR_FILL_LAST,
							  SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST,
							  EE_CHAR_START,	  EE_CHAR_END,
							  0	};
	SfxItemSet aItemSet( pModel->GetItemPool(), aWhichMap );
	aItemSet.Put( SdrTextAutoGrowWidthItem( sal_False ) );
	aItemSet.Put( SdrTextAutoGrowHeightItem( sal_True ) );
	aItemSet.Put( SdrTextAniKindItem( eAniKind ) );
	aItemSet.Put( SdrTextAniDirectionItem( eAniDir ) );
	aItemSet.Put( SdrTextAniCountItem( nCount ) );
	aItemSet.Put( SdrTextAniDelayItem( nDelay ) );
	aItemSet.Put( SdrTextAniAmountItem( nAmount ) );
	if( SDRTEXTANI_ALTERNATE==eAniKind )
	{
		// (Nur) Alternate startet und stoppt per default Inside
		aItemSet.Put( SdrTextAniStartInsideItem(sal_True) );
		aItemSet.Put( SdrTextAniStopInsideItem(sal_True) );
		if( SDRTEXTANI_LEFT==eAniDir )
			aItemSet.Put( SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT) );
	}

	// die Default-Farbe (aus der Standard-Vorlage) setzen, damit ueberhaupt
	// eine sinnvolle Farbe gesetzt ist.
	const Color& rDfltColor =
		pCSS1Parser->GetTxtCollFromPool( RES_POOLCOLL_STANDARD )
			->GetColor().GetValue();
	aItemSet.Put( SvxColorItem( rDfltColor, EE_CHAR_COLOR ) );

	// Die Attribute der aktuellen Absatzvorlage setzen
	sal_uInt16 nWhichIds[] =
	{
		RES_CHRATR_COLOR,   RES_CHRATR_CROSSEDOUT, RES_CHRATR_ESCAPEMENT,
		RES_CHRATR_FONT,    RES_CHRATR_FONTSIZE,   RES_CHRATR_KERNING,
		RES_CHRATR_POSTURE, RES_CHRATR_UNDERLINE,  RES_CHRATR_WEIGHT,
		RES_CHRATR_BACKGROUND,
		RES_CHRATR_CJK_FONT, RES_CHRATR_CJK_FONTSIZE,
		RES_CHRATR_CJK_POSTURE, RES_CHRATR_CJK_WEIGHT,
		RES_CHRATR_CTL_FONT, RES_CHRATR_CTL_FONTSIZE,
		RES_CHRATR_CTL_POSTURE, RES_CHRATR_CTL_WEIGHT,
		0
	};
    SwTxtNode const*const pTxtNd =
        pPam->GetPoint()->nNode.GetNode().GetTxtNode();
	if( pTxtNd )
	{
		const SfxItemSet& rItemSet = pTxtNd->GetAnyFmtColl().GetAttrSet();
		const SfxPoolItem *pItem;
		for( sal_uInt16 i=0; nWhichIds[i]; i++ )
		{
			if( SFX_ITEM_SET == rItemSet.GetItemState( nWhichIds[i], sal_True, &pItem ) )
				PutEEPoolItem( aItemSet, *pItem );
		}
	}

	// die Attribute der Umgebung am Draw-Objekt setzen
	_HTMLAttr** pTbl = (_HTMLAttr**)&aAttrTab;
	for( sal_uInt16 nCnt = sizeof( _HTMLAttrTable ) / sizeof( _HTMLAttr* );
		 nCnt--; ++pTbl )
	{
		_HTMLAttr *pAttr = *pTbl;
		if( pAttr )
			PutEEPoolItem( aItemSet, pAttr->GetItem() );
	}

	if( bBGColor )
	{
		aItemSet.Put( XFillStyleItem(XFILL_SOLID) );
		aItemSet.Put( XFillColorItem(aEmptyStr, aBGColor) );
	}

	// Styles parsen (funktioniert hier nur fuer Attribute, die auch
	// am Zeichen-Objekt gesetzt werden koennen)
	SfxItemSet aStyleItemSet( pDoc->GetAttrPool(),
							  pCSS1Parser->GetWhichMap() );
	SvxCSS1PropertyInfo aPropInfo;
	if( HasStyleOptions( aStyle, aId, aClass )  &&
		ParseStyleOptions( aStyle, aId, aClass, aStyleItemSet, aPropInfo ) )
	{
		SfxItemIter aIter( aStyleItemSet );

		const SfxPoolItem *pItem = aIter.FirstItem();
		while( pItem )
		{
			PutEEPoolItem( aItemSet, *pItem );
			pItem = aIter.NextItem();
		}
	}

	// jetzt noch die Groesse setzen
	Size aTwipSz( bPrcWidth ? 0 : nWidth, nHeight );
	if( (aTwipSz.Width() || aTwipSz.Height()) && Application::GetDefaultDevice() )
	{
		aTwipSz = Application::GetDefaultDevice()
					->PixelToLogic( aTwipSz, MapMode( MAP_TWIP ) );
	}

	if( SVX_CSS1_LTYPE_TWIP== aPropInfo.eWidthType )
	{
		aTwipSz.Width() = aPropInfo.nWidth;
		nWidth = 1; // != 0;
		bPrcWidth = sal_False;
	}
	if( SVX_CSS1_LTYPE_TWIP== aPropInfo.eHeightType )
		aTwipSz.Height() = aPropInfo.nHeight;

	bFixMarqueeWidth = sal_False;
	if( !nWidth || bPrcWidth )
	{
		if( pTable )
		{
			if( !pCurTable )
			{
				// Die Laufschrift steht in einer Tabelle, aber nicht
				// in einer Zelle. Da jetzt keine vernuenftige Zuordung
				// zu einer Zelle moeglich ist, passen wir hir die
				// Breite dem Inhalt der Laufschrift an.
				bFixMarqueeWidth = sal_True;
			}
			else if( !nWidth )
			{
				// Da wir wissen, in welcher Zelle die Laufschrift ist,
				// koennen wir die Breite auch anpassen. Keine Breitenangabe
				// wird wie 100% behandelt.
				nWidth = 100;
				bPrcWidth = sal_True;
			}
			aTwipSz.Width() = MINLAY;
		}
		else
		{
			long nBrowseWidth = GetCurrentBrowseWidth();
			aTwipSz.Width() = !nWidth ? nBrowseWidth
									  : (nWidth*nBrowseWidth) / 100;
		}
	}

	// Die Hoehe ist nur eine Mindest-Hoehe
	if( aTwipSz.Height() < MINFLY )
		aTwipSz.Height() = MINFLY;
	aItemSet.Put( SdrTextMinFrameHeightItem( aTwipSz.Height() ) );

	pMarquee->SetMergedItemSetAndBroadcast(aItemSet);

	if( aTwipSz.Width() < MINFLY )
		aTwipSz.Width() = MINFLY;
	pMarquee->SetLogicRect( Rectangle( 0, 0, aTwipSz.Width(), aTwipSz.Height() ) );

	// und das Objekt in das Dok einfuegen
	InsertDrawObject( pMarquee, aSpace, eVertOri, eHoriOri, aStyleItemSet,
					  aPropInfo	);

	// Das Zeichen-Objekt der Tabelle bekanntmachen. Ist ein bisserl
	// umstaendlich, weil noch ueber den Parser gegangen wird, obwohl die
	// Tabelle bekannt ist, aber anderenfalls muesste man die Tabelle
	// oeffentlich machen, und das ist auch nicht schoen. Das globale
	// pTable kann uebrigens auch nicht verwendet werden, denn die
	// Laufschrift kann sich auch mal in einer Sub-Tabelle befinden.
	if( pCurTable && bPrcWidth)
		RegisterDrawObjectToTable( pCurTable, pMarquee, (sal_uInt8)nWidth );
}

void SwHTMLParser::EndMarquee()
{
	ASSERT( pMarquee && OBJ_TEXT==pMarquee->GetObjIdentifier(),
			"kein Marquee oder falscher Typ" );

	if( bFixMarqueeWidth )
	{
		// Da es keine fixe Hoehe gibt, das Text-Objekt erstmal breiter
		// als den Text machen, damit nicht umgebrochen wird.
		const Rectangle& rOldRect = pMarquee->GetLogicRect();
		pMarquee->SetLogicRect( Rectangle( rOldRect.TopLeft(),
										   Size( USHRT_MAX, 240 ) ) );
	}

	// den gesammelten Text einfuegen
	((SdrTextObj*)pMarquee)->SetText( aContents );
	pMarquee->SetMergedItemSetAndBroadcast( pMarquee->GetMergedItemSet() );

	if( bFixMarqueeWidth )
	{
		// die Groesse dem Text anpassen.
		((SdrTextObj*)pMarquee)->FitFrameToTextSize();
	}

	aContents.Erase();
	pMarquee = 0;
}

void SwHTMLParser::InsertMarqueeText()
{
	ASSERT( pMarquee && OBJ_TEXT==pMarquee->GetObjIdentifier(),
			"kein Marquee oder falscher Typ" );

	// das akteulle Textstueck an den Text anhaengen
	aContents += aToken;
}

void SwHTMLParser::ResizeDrawObject( SdrObject* pObj, SwTwips nWidth )
{
	ASSERT( OBJ_TEXT==pObj->GetObjIdentifier(),
			"kein Marquee oder falscher Typ" );

	if( OBJ_TEXT!=pObj->GetObjIdentifier() )
		return;

	// die alte Groesse
	const Rectangle& rOldRect = pObj->GetLogicRect();
	Size aNewSz( nWidth, rOldRect.GetSize().Height() );
	pObj->SetLogicRect( Rectangle( rOldRect.TopLeft(), aNewSz ) );
}

/*  */

const SdrObject *SwHTMLWriter::GetMarqueeTextObj( const SwDrawFrmFmt& rFmt )
{
	const SdrObject* pObj = rFmt.FindSdrObject();
	return (pObj && ::IsMarqueeTextObj( *pObj )) ? pObj : 0;
}

void SwHTMLWriter::GetEEAttrsFromDrwObj( SfxItemSet& rItemSet,
										 const SdrObject *pObj,
										 sal_Bool bSetDefaults )
{
    // die Edit script::Engine-Attribute aus dem Objekt holen
	SfxItemSet rObjItemSet = pObj->GetMergedItemSet();

    // ueber die Edit script::Engine-Attribute iterieren und die Attribute
	// in SW-Attrs wandeln bzw. default setzen
	SfxWhichIter aIter( rObjItemSet );
	sal_uInt16 nEEWhich = aIter.FirstWhich();
	while( nEEWhich )
	{
		const SfxPoolItem *pEEItem;
		sal_Bool bSet = SFX_ITEM_SET == rObjItemSet.GetItemState( nEEWhich, sal_False,
															  &pEEItem );

		if( bSet || bSetDefaults )
		{
			sal_uInt16 nSwWhich = 0;
			switch( nEEWhich )
			{
			case EE_CHAR_COLOR:			nSwWhich = RES_CHRATR_COLOR;		break;
			case EE_CHAR_STRIKEOUT: 	nSwWhich = RES_CHRATR_CROSSEDOUT;	break;
			case EE_CHAR_ESCAPEMENT:	nSwWhich = RES_CHRATR_ESCAPEMENT;	break;
			case EE_CHAR_FONTINFO: 		nSwWhich = RES_CHRATR_FONT;		    break;
			case EE_CHAR_FONTINFO_CJK: 	nSwWhich = RES_CHRATR_CJK_FONT;	    break;
			case EE_CHAR_FONTINFO_CTL: 	nSwWhich = RES_CHRATR_CTL_FONT;		break;
			case EE_CHAR_FONTHEIGHT:	nSwWhich = RES_CHRATR_FONTSIZE;	    break;
			case EE_CHAR_FONTHEIGHT_CJK:nSwWhich = RES_CHRATR_CJK_FONTSIZE; break;
			case EE_CHAR_FONTHEIGHT_CTL:nSwWhich = RES_CHRATR_CTL_FONTSIZE; break;
			case EE_CHAR_KERNING: 		nSwWhich = RES_CHRATR_KERNING; 	    break;
			case EE_CHAR_ITALIC: 		nSwWhich = RES_CHRATR_POSTURE; 	    break;
			case EE_CHAR_ITALIC_CJK:	nSwWhich = RES_CHRATR_CJK_POSTURE;  break;
			case EE_CHAR_ITALIC_CTL:	nSwWhich = RES_CHRATR_CTL_POSTURE;  break;
			case EE_CHAR_UNDERLINE: 	nSwWhich = RES_CHRATR_UNDERLINE;	break;
			case EE_CHAR_WEIGHT: 		nSwWhich = RES_CHRATR_WEIGHT;   	break;
			case EE_CHAR_WEIGHT_CJK: 	nSwWhich = RES_CHRATR_CJK_WEIGHT;  	break;
			case EE_CHAR_WEIGHT_CTL: 	nSwWhich = RES_CHRATR_CTL_WEIGHT;  	break;
			}

			if( nSwWhich )
			{
				// wenn das Item nicht gesetzt ist nehmen wir ggf. das
				// Default-Item
				if( !bSet )
					pEEItem = &rObjItemSet.GetPool()->GetDefaultItem(nEEWhich);

				// jetzt Clonen wir das Item mit der Which-Id des Writers
				SfxPoolItem *pSwItem = pEEItem->Clone();
				pSwItem->SetWhich( nSwWhich );
				rItemSet.Put( *pSwItem );
				delete pSwItem;
			}
		}

		nEEWhich = aIter.NextWhich();
	}
}


Writer& OutHTML_DrawFrmFmtAsMarquee( Writer& rWrt,
									 const SwDrawFrmFmt& rFmt,
									 const SdrObject& rSdrObject )
{
	SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;

	ASSERT( rWrt.pDoc->GetDrawModel(), "Da gibt's ein Draw-Obj ohne ein Draw-Model zu haben?" );
	const SdrTextObj *pTextObj = (const SdrTextObj *)&rSdrObject;

	// Gibt es ueberhaupt auszugebenden Text
	const OutlinerParaObject *pOutlinerParaObj =
		pTextObj->GetOutlinerParaObject();
	if( !pOutlinerParaObj )
		return rWrt;

	ByteString sOut( '<' );
	sOut += OOO_STRING_SVTOOLS_HTML_marquee;

	// Die Attribute des Objektd holen
	const SfxItemSet& rItemSet = pTextObj->GetMergedItemSet();

	// BEHAVIOUR
	SdrTextAniKind eAniKind = pTextObj->GetTextAniKind();
	ASSERT( SDRTEXTANI_SCROLL==eAniKind ||
			SDRTEXTANI_ALTERNATE==eAniKind ||
			SDRTEXTANI_SLIDE==eAniKind,
			"Text-Draw-Objekt nicht fuer Marquee geeignet" )

	const sal_Char *pStr = 0;
	switch( eAniKind )
	{
	case SDRTEXTANI_SCROLL:		pStr = OOO_STRING_SVTOOLS_HTML_BEHAV_scroll;		break;
	case SDRTEXTANI_SLIDE:		pStr = OOO_STRING_SVTOOLS_HTML_BEHAV_slide;		break;
	case SDRTEXTANI_ALTERNATE:	pStr = OOO_STRING_SVTOOLS_HTML_BEHAV_alternate;	break;
	default:
		;
	}

	if( pStr )
		(((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_behavior) += '=') += pStr;

	// DIRECTION
	pStr = 0;
	SdrTextAniDirection eAniDir = pTextObj->GetTextAniDirection();
	switch( eAniDir )
	{
	case SDRTEXTANI_LEFT:		pStr = OOO_STRING_SVTOOLS_HTML_AL_left;		break;
	case SDRTEXTANI_RIGHT:		pStr = OOO_STRING_SVTOOLS_HTML_AL_right;		break;
	default:
		;
	}

	if( pStr )
		(((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_direction) += '=') += pStr;

	// LOOP
	sal_Int32 nCount =
		((const SdrTextAniCountItem&)rItemSet.Get( SDRATTR_TEXT_ANICOUNT ))
											 .GetValue();
	if( 0==nCount )
		nCount = SDRTEXTANI_SLIDE==eAniKind ? 1 : -1;
	(((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_loop) += '=')
		+= ByteString::CreateFromInt32( nCount );

	// SCROLLDELAY
	sal_uInt16 nDelay =
		((const SdrTextAniDelayItem&)rItemSet.Get( SDRATTR_TEXT_ANIDELAY ))
											.GetValue();
	(((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_scrolldelay) += '=')
		+= ByteString::CreateFromInt32( nDelay );

	// SCROLLAMOUNT
	sal_Int16 nAmount =
		((const SdrTextAniAmountItem&)rItemSet.Get( SDRATTR_TEXT_ANIAMOUNT ))
											 .GetValue();
	if( nAmount < 0 )
	{
		nAmount = -nAmount;
	}
	else if( nAmount && Application::GetDefaultDevice() )
	{
		nAmount = (sal_uInt16)(Application::GetDefaultDevice()
							->LogicToPixel( Size(nAmount,0),
											MapMode(MAP_TWIP) ).Width());
	}
	if( nAmount )
		(((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_scrollamount) += '=')
			+= ByteString::CreateFromInt32( nAmount );

	Size aTwipSz( pTextObj->GetLogicRect().GetSize() );
	if( pTextObj->IsAutoGrowWidth() )
		aTwipSz.Width() = 0;
	// Die Hoehe ist bei MS eine Mindesthoehe, also geben wir auch die
	// Mindestheoehe aus, wenn es sie gibt. Da eine Mindesthoehe MINFLY
	// mit hoher Wahrscheinlichkeit vom Import kommt, wird sie nicht mit
	// ausgegeben. Falsch machen kann man da nichst, denn jeder Font ist
	// hoeher.
	if( pTextObj->IsAutoGrowHeight() )
	{
		aTwipSz.Height() = pTextObj->GetMinTextFrameHeight();
		if( MINFLY==aTwipSz.Height() )
			aTwipSz.Height() = 0;
	}

	if( (aTwipSz.Width() || aTwipSz.Height()) &&
		Application::GetDefaultDevice() )
	{
		Size aPixelSz =
			Application::GetDefaultDevice()->LogicToPixel( aTwipSz,
												MapMode(MAP_TWIP) );
		if( !aPixelSz.Width() && aTwipSz.Width() )
			aPixelSz.Width() = 1;
		if( !aPixelSz.Height() && aTwipSz.Height() )
			aPixelSz.Height() = 1;

		if( aPixelSz.Width() )
			(((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_width) += '=')
				+= ByteString::CreateFromInt32( aPixelSz.Width() );

		if( aPixelSz.Height() )
			(((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_height) += '=')
				+= ByteString::CreateFromInt32( aPixelSz.Height() );
	}

	// BGCOLOR
	XFillStyle eFillStyle =
		((const XFillStyleItem&)rItemSet.Get(XATTR_FILLSTYLE)).GetValue();
	if( XFILL_SOLID==eFillStyle )
	{
		const Color& rFillColor =
			((const XFillColorItem&)rItemSet.Get(XATTR_FILLCOLOR)).GetColorValue();

		((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_bgcolor) += '=';
		rWrt.Strm() << sOut.GetBuffer();
		HTMLOutFuncs::Out_Color( rWrt.Strm(), rFillColor, rHTMLWrt.eDestEnc );
		sOut.Erase();
	}

	if( sOut.Len() )
		rWrt.Strm() << sOut.GetBuffer();

	// und nun noch ALIGN, HSPACE und VSPACE
	ByteString aEndTags;
	sal_uInt32 nFrmFlags = HTML_FRMOPTS_MARQUEE;
	if( rHTMLWrt.IsHTMLMode( HTMLMODE_ABS_POS_DRAW ) )
		nFrmFlags |= HTML_FRMOPTS_MARQUEE_CSS1;
	rHTMLWrt.OutFrmFmtOptions( rFmt, aEmptyStr, aEndTags, nFrmFlags );
	if( rHTMLWrt.IsHTMLMode( HTMLMODE_ABS_POS_DRAW ) )
		rHTMLWrt.OutCSS1_FrmFmtOptions( rFmt, nFrmFlags, &rSdrObject );


	rWrt.Strm() << '>';

	// Was jetzt kommt ist das Gegenstueck zu SdrTextObjectt::SetText()
	Outliner aOutliner(0, OUTLINERMODE_TEXTOBJECT);
	aOutliner.SetUpdateMode( sal_False );
	aOutliner.SetText( *pOutlinerParaObj );
	String aText( aOutliner.GetText( aOutliner.GetParagraph(0),
									 aOutliner.GetParagraphCount() ) );
	HTMLOutFuncs::Out_String( rWrt.Strm(), aText,
						  	  rHTMLWrt.eDestEnc, &rHTMLWrt.aNonConvertableCharacters );

	HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_marquee, sal_False );

	if( aEndTags.Len() )
		rWrt.Strm() << aEndTags.GetBuffer();

	return rWrt;
}