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

#define ENABLE_BYTESTRING_STREAM_OPERATORS

#include <algorithm>
#include <string.h>
#include <tools/stream.hxx>
#include <tools/vcompat.hxx>
#include <vcl/outdev.hxx>
#include <vcl/salbtype.hxx>
#include <vcl/metaact.hxx>
#include <vcl/graphictools.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>
#include <vcl/dibtools.hxx>

// ========================================================================

inline void ImplScalePoint( Point& rPt, double fScaleX, double fScaleY )
{
	rPt.X() = FRound( fScaleX * rPt.X() );
	rPt.Y() = FRound( fScaleY * rPt.Y() );
}

// ------------------------------------------------------------------------

inline void ImplScaleRect( Rectangle& rRect, double fScaleX, double fScaleY )
{
	Point aTL( rRect.TopLeft() );
	Point aBR( rRect.BottomRight() );

	ImplScalePoint( aTL, fScaleX, fScaleY );
	ImplScalePoint( aBR, fScaleX, fScaleY );

	rRect = Rectangle( aTL, aBR );
    rRect.Justify();
}

// ------------------------------------------------------------------------

inline void ImplScalePoly( Polygon& rPoly, double fScaleX, double fScaleY )
{
	for( sal_uInt16 i = 0, nCount = rPoly.GetSize(); i < nCount; i++ )
		ImplScalePoint( rPoly[ i ], fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

inline void ImplScaleLineInfo( LineInfo& rLineInfo, double fScaleX, double fScaleY )
{
	if( !rLineInfo.IsDefault() )
	{
		const double fScale = ( fabs(fScaleX) + fabs(fScaleY) ) * 0.5;

		rLineInfo.SetWidth( FRound( fScale * rLineInfo.GetWidth() ) );
		rLineInfo.SetDashLen( FRound( fScale * rLineInfo.GetDashLen() ) );
		rLineInfo.SetDotLen( FRound( fScale * rLineInfo.GetDotLen() ) );
		rLineInfo.SetDistance( FRound( fScale * rLineInfo.GetDistance() ) );
	}
}

// ========================================================================

#define COMPAT( _def_rIStm ) VersionCompat aCompat( ( _def_rIStm ), STREAM_READ );
#define COMPAT_VERSION() aCompat.GetVersion()
#define WRITE_BASE_COMPAT( _def_rOStm, _def_nVer, _pWriteData ) 		\
	MetaAction::Write( ( _def_rOStm ), _pWriteData );					\
	VersionCompat aCompat( ( _def_rOStm ), STREAM_WRITE, ( _def_nVer ) );

// ========================================================================

MetaAction::MetaAction() :
	mnRefCount( 1 ),
	mnType( META_NULL_ACTION )
{
}

// ------------------------------------------------------------------------

MetaAction::MetaAction( sal_uInt16 nType ) :
	mnRefCount( 1 ),
	mnType( nType )
{
}

// ------------------------------------------------------------------------

MetaAction::~MetaAction()
{
}

// ------------------------------------------------------------------------

void MetaAction::Execute( OutputDevice* )
{
}

// ------------------------------------------------------------------------

MetaAction* MetaAction::Clone()
{
	return new MetaAction;
}

// ------------------------------------------------------------------------

void MetaAction::Move( long, long )
{
}

// ------------------------------------------------------------------------

void MetaAction::Scale( double, double )
{
}

// ------------------------------------------------------------------------

sal_Bool MetaAction::Compare( const MetaAction& ) const
{
	return sal_True;
}

// ------------------------------------------------------------------------

sal_Bool MetaAction::IsEqual( const MetaAction& rMetaAction ) const
{
	if ( mnType != rMetaAction.mnType )
		return sal_False;
	else
		return Compare( rMetaAction );
}

// ------------------------------------------------------------------------

void MetaAction::Write( SvStream& rOStm, ImplMetaWriteData* )
{
	rOStm << mnType;
}

// ------------------------------------------------------------------------

void MetaAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	rIStm >> mnType;
}

// ------------------------------------------------------------------------

MetaAction* MetaAction::ReadMetaAction( SvStream& rIStm, ImplMetaReadData* pData )
{
	MetaAction* pAction = NULL;
	sal_uInt16		nType;

	rIStm >> nType;

	switch( nType )
	{
		case( META_NULL_ACTION ): pAction = new MetaAction; break;
		case( META_PIXEL_ACTION ): pAction = new MetaPixelAction; break;
		case( META_POINT_ACTION ): pAction = new MetaPointAction; break;
		case( META_LINE_ACTION ): pAction = new MetaLineAction; break;
		case( META_RECT_ACTION ): pAction = new MetaRectAction; break;
		case( META_ROUNDRECT_ACTION ): pAction = new MetaRoundRectAction; break;
		case( META_ELLIPSE_ACTION ): pAction = new MetaEllipseAction; break;
		case( META_ARC_ACTION ): pAction = new MetaArcAction; break;
		case( META_PIE_ACTION ): pAction = new MetaPieAction; break;
		case( META_CHORD_ACTION ): pAction = new MetaChordAction; break;
		case( META_POLYLINE_ACTION ): pAction = new MetaPolyLineAction; break;
		case( META_POLYGON_ACTION ): pAction = new MetaPolygonAction; break;
		case( META_POLYPOLYGON_ACTION ): pAction = new MetaPolyPolygonAction; break;
		case( META_TEXT_ACTION ): pAction = new MetaTextAction; break;
		case( META_TEXTARRAY_ACTION ): pAction = new MetaTextArrayAction; break;
		case( META_STRETCHTEXT_ACTION ): pAction = new MetaStretchTextAction; break;
		case( META_TEXTRECT_ACTION ): pAction = new MetaTextRectAction; break;
		case( META_TEXTLINE_ACTION ): pAction = new MetaTextLineAction; break;
		case( META_BMP_ACTION ): pAction = new MetaBmpAction; break;
		case( META_BMPSCALE_ACTION ): pAction = new MetaBmpScaleAction; break;
		case( META_BMPSCALEPART_ACTION ): pAction = new MetaBmpScalePartAction; break;
		case( META_BMPEX_ACTION ): pAction = new MetaBmpExAction; break;
		case( META_BMPEXSCALE_ACTION ): pAction = new MetaBmpExScaleAction; break;
		case( META_BMPEXSCALEPART_ACTION ): pAction = new MetaBmpExScalePartAction; break;
		case( META_MASK_ACTION ): pAction = new MetaMaskAction; break;
		case( META_MASKSCALE_ACTION ): pAction = new MetaMaskScaleAction; break;
		case( META_MASKSCALEPART_ACTION ): pAction = new MetaMaskScalePartAction; break;
		case( META_GRADIENT_ACTION ): pAction = new MetaGradientAction; break;
		case( META_GRADIENTEX_ACTION ): pAction = new MetaGradientExAction; break;
		case( META_HATCH_ACTION ): pAction = new MetaHatchAction; break;
		case( META_WALLPAPER_ACTION ): pAction = new MetaWallpaperAction; break;
		case( META_CLIPREGION_ACTION ): pAction = new MetaClipRegionAction; break;
		case( META_ISECTRECTCLIPREGION_ACTION ): pAction = new MetaISectRectClipRegionAction; break;
		case( META_ISECTREGIONCLIPREGION_ACTION ): pAction = new MetaISectRegionClipRegionAction; break;
		case( META_MOVECLIPREGION_ACTION ): pAction = new MetaMoveClipRegionAction; break;
		case( META_LINECOLOR_ACTION ): pAction = new MetaLineColorAction; break;
		case( META_FILLCOLOR_ACTION ): pAction = new MetaFillColorAction; break;
		case( META_TEXTCOLOR_ACTION ): pAction = new MetaTextColorAction; break;
		case( META_TEXTFILLCOLOR_ACTION ): pAction = new MetaTextFillColorAction; break;
		case( META_TEXTLINECOLOR_ACTION ): pAction = new MetaTextLineColorAction; break;
		case( META_OVERLINECOLOR_ACTION ): pAction = new MetaOverlineColorAction; break;
		case( META_TEXTALIGN_ACTION ): pAction = new MetaTextAlignAction; break;
		case( META_MAPMODE_ACTION ): pAction = new MetaMapModeAction; break;
		case( META_FONT_ACTION ): pAction = new MetaFontAction; break;
		case( META_PUSH_ACTION ): pAction = new MetaPushAction; break;
		case( META_POP_ACTION ): pAction = new MetaPopAction; break;
		case( META_RASTEROP_ACTION ): pAction = new MetaRasterOpAction; break;
		case( META_TRANSPARENT_ACTION ): pAction = new MetaTransparentAction; break;
		case( META_FLOATTRANSPARENT_ACTION ): pAction = new MetaFloatTransparentAction; break;
		case( META_EPS_ACTION ): pAction = new MetaEPSAction; break;
		case( META_REFPOINT_ACTION ): pAction = new MetaRefPointAction; break;
		case( META_COMMENT_ACTION ): pAction = new MetaCommentAction; break;
		case( META_LAYOUTMODE_ACTION ): pAction = new MetaLayoutModeAction; break;
		case( META_TEXTLANGUAGE_ACTION ): pAction = new MetaTextLanguageAction; break;

		default:
		{
			// Action ueberlesen durch Kombination Ctor/Dtor,
			// new/delete, weil Compiler sonst vielleicht wegoptimieren
			delete ( new VersionCompat( rIStm, STREAM_READ ) );
		}
		break;
	}

	if( pAction )
		pAction->Read( rIStm, pData );

	return pAction;
}

// ========================================================================

IMPL_META_ACTION( Pixel, META_PIXEL_ACTION )

// ------------------------------------------------------------------------

MetaPixelAction::MetaPixelAction( const Point& rPt, const Color& rColor ) :
	MetaAction	( META_PIXEL_ACTION ),
	maPt		( rPt ),
	maColor 	( rColor )
{
}

// ------------------------------------------------------------------------

void MetaPixelAction::Execute( OutputDevice* pOut )
{
	pOut->DrawPixel( maPt, maColor );
}

// ------------------------------------------------------------------------

MetaAction* MetaPixelAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaPixelAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaPixelAction::Move( long nHorzMove, long nVertMove )
{
	maPt.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaPixelAction::Scale( double fScaleX, double fScaleY )
{
	ImplScalePoint( maPt, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaPixelAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maPt == ((MetaPixelAction&)rMetaAction).maPt ) &&
		   ( maColor == ((MetaPixelAction&)rMetaAction).maColor );
}

// ------------------------------------------------------------------------

void MetaPixelAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maPt;
	maColor.Write( rOStm, sal_True );
}

// ------------------------------------------------------------------------

void MetaPixelAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maPt;
	maColor.Read( rIStm, sal_True );
}

// ========================================================================

IMPL_META_ACTION( Point, META_POINT_ACTION )

// ------------------------------------------------------------------------

MetaPointAction::MetaPointAction( const Point& rPt ) :
	MetaAction	( META_POINT_ACTION ),
	maPt		( rPt )
{
}

// ------------------------------------------------------------------------

void MetaPointAction::Execute( OutputDevice* pOut )
{
	pOut->DrawPixel( maPt );
}

// ------------------------------------------------------------------------

MetaAction* MetaPointAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaPointAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaPointAction::Move( long nHorzMove, long nVertMove )
{
	maPt.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaPointAction::Scale( double fScaleX, double fScaleY )
{
	ImplScalePoint( maPt, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaPointAction::Compare( const MetaAction& rMetaAction ) const
{
	return maPt == ((MetaPointAction&)rMetaAction).maPt;
}

// ------------------------------------------------------------------------

void MetaPointAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maPt;
}

// ------------------------------------------------------------------------

void MetaPointAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maPt;
}

// ========================================================================

IMPL_META_ACTION( Line, META_LINE_ACTION )

// ------------------------------------------------------------------------

MetaLineAction::MetaLineAction( const Point& rStart, const Point& rEnd ) :
	MetaAction	( META_LINE_ACTION ),
	maStartPt	( rStart ),
	maEndPt 	( rEnd )
{
}

// ------------------------------------------------------------------------

MetaLineAction::MetaLineAction( const Point& rStart, const Point& rEnd,
								const LineInfo& rLineInfo ) :
	MetaAction	( META_LINE_ACTION ),
	maLineInfo	( rLineInfo ),
	maStartPt	( rStart ),
	maEndPt 	( rEnd )
{
}

// ------------------------------------------------------------------------

void MetaLineAction::Execute( OutputDevice* pOut )
{
	if( maLineInfo.IsDefault() )
		pOut->DrawLine( maStartPt, maEndPt );
	else
		pOut->DrawLine( maStartPt, maEndPt, maLineInfo );
}

// ------------------------------------------------------------------------

MetaAction* MetaLineAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaLineAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaLineAction::Move( long nHorzMove, long nVertMove )
{
	maStartPt.Move( nHorzMove, nVertMove );
	maEndPt.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaLineAction::Scale( double fScaleX, double fScaleY )
{
	ImplScalePoint( maStartPt, fScaleX, fScaleY );
	ImplScalePoint( maEndPt, fScaleX, fScaleY );
	ImplScaleLineInfo( maLineInfo, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaLineAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maLineInfo == ((MetaLineAction&)rMetaAction).maLineInfo ) &&
	       ( maStartPt == ((MetaLineAction&)rMetaAction).maStartPt ) &&
		   ( maEndPt == ((MetaLineAction&)rMetaAction).maEndPt );
}

// ------------------------------------------------------------------------

void MetaLineAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 2, pData );

	rOStm << maStartPt << maEndPt;	// Version 1
	rOStm << maLineInfo;			// Version 2
}

// ------------------------------------------------------------------------

void MetaLineAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );

	// Version 1
	rIStm >> maStartPt >> maEndPt;

	// Version 2
	if( aCompat.GetVersion() >= 2 )
	{
		rIStm >> maLineInfo;
	}
}

// ========================================================================

IMPL_META_ACTION( Rect, META_RECT_ACTION )

// ------------------------------------------------------------------------

MetaRectAction::MetaRectAction( const Rectangle& rRect ) :
	MetaAction	( META_RECT_ACTION ),
	maRect		( rRect )
{
}

// ------------------------------------------------------------------------

void MetaRectAction::Execute( OutputDevice* pOut )
{
	pOut->DrawRect( maRect );
}

// ------------------------------------------------------------------------

MetaAction* MetaRectAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaRectAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaRectAction::Move( long nHorzMove, long nVertMove )
{
	maRect.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaRectAction::Scale( double fScaleX, double fScaleY )
{
	ImplScaleRect( maRect, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaRectAction::Compare( const MetaAction& rMetaAction ) const
{
	return maRect == ((MetaRectAction&)rMetaAction).maRect;
}

// ------------------------------------------------------------------------

void MetaRectAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maRect;
}

// ------------------------------------------------------------------------

void MetaRectAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maRect;
}

// ========================================================================

IMPL_META_ACTION( RoundRect, META_ROUNDRECT_ACTION )

// ------------------------------------------------------------------------

MetaRoundRectAction::MetaRoundRectAction( const Rectangle& rRect,
										  sal_uInt32 nHorzRound, sal_uInt32 nVertRound ) :
	MetaAction	( META_ROUNDRECT_ACTION ),
	maRect		( rRect ),
	mnHorzRound ( nHorzRound ),
	mnVertRound ( nVertRound )
{
}

// ------------------------------------------------------------------------

void MetaRoundRectAction::Execute( OutputDevice* pOut )
{
	pOut->DrawRect( maRect, mnHorzRound, mnVertRound );
}

// ------------------------------------------------------------------------

MetaAction* MetaRoundRectAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaRoundRectAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaRoundRectAction::Move( long nHorzMove, long nVertMove )
{
	maRect.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaRoundRectAction::Scale( double fScaleX, double fScaleY )
{
	ImplScaleRect( maRect, fScaleX, fScaleY );
	mnHorzRound = FRound( mnHorzRound * fabs(fScaleX) );
	mnVertRound = FRound( mnVertRound * fabs(fScaleY) );
}

// ------------------------------------------------------------------------

sal_Bool MetaRoundRectAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maRect == ((MetaRoundRectAction&)rMetaAction).maRect ) &&
		   ( mnHorzRound == ((MetaRoundRectAction&)rMetaAction).mnHorzRound ) &&
		   ( mnVertRound == ((MetaRoundRectAction&)rMetaAction).mnVertRound );
}

// ------------------------------------------------------------------------

void MetaRoundRectAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maRect << mnHorzRound << mnVertRound;
}

// ------------------------------------------------------------------------

void MetaRoundRectAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maRect >> mnHorzRound >> mnVertRound;
}

// ========================================================================

IMPL_META_ACTION( Ellipse, META_ELLIPSE_ACTION )

// ------------------------------------------------------------------------

MetaEllipseAction::MetaEllipseAction( const Rectangle& rRect ) :
	MetaAction	( META_ELLIPSE_ACTION ),
	maRect		( rRect )
{
}

// ------------------------------------------------------------------------

void MetaEllipseAction::Execute( OutputDevice* pOut )
{
	pOut->DrawEllipse( maRect );
}

// ------------------------------------------------------------------------

MetaAction* MetaEllipseAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaEllipseAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaEllipseAction::Move( long nHorzMove, long nVertMove )
{
	maRect.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaEllipseAction::Scale( double fScaleX, double fScaleY )
{
	ImplScaleRect( maRect, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaEllipseAction::Compare( const MetaAction& rMetaAction ) const
{
	return maRect == ((MetaEllipseAction&)rMetaAction).maRect;
}

// ------------------------------------------------------------------------

void MetaEllipseAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maRect;
}

// ------------------------------------------------------------------------

void MetaEllipseAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maRect;
}

// ========================================================================

IMPL_META_ACTION( Arc, META_ARC_ACTION )

// ------------------------------------------------------------------------

MetaArcAction::MetaArcAction( const Rectangle& rRect,
							  const Point& rStart, const Point& rEnd ) :
	MetaAction	( META_ARC_ACTION ),
	maRect		( rRect ),
	maStartPt	( rStart ),
	maEndPt 	( rEnd )
{
}

// ------------------------------------------------------------------------

void MetaArcAction::Execute( OutputDevice* pOut )
{
	pOut->DrawArc( maRect, maStartPt, maEndPt );
}

// ------------------------------------------------------------------------

MetaAction* MetaArcAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaArcAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaArcAction::Move( long nHorzMove, long nVertMove )
{
	maRect.Move(  nHorzMove, nVertMove );
	maStartPt.Move(  nHorzMove, nVertMove );
	maEndPt.Move(  nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaArcAction::Scale( double fScaleX, double fScaleY )
{
	ImplScaleRect( maRect, fScaleX, fScaleY );
	ImplScalePoint( maStartPt, fScaleX, fScaleY );
	ImplScalePoint( maEndPt, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaArcAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maRect == ((MetaArcAction&)rMetaAction).maRect ) &&
		   ( maStartPt == ((MetaArcAction&)rMetaAction).maStartPt ) &&
		   ( maEndPt == ((MetaArcAction&)rMetaAction).maEndPt );
}

// ------------------------------------------------------------------------

void MetaArcAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maRect << maStartPt << maEndPt;
}

// ------------------------------------------------------------------------

void MetaArcAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maRect >> maStartPt >> maEndPt;
}

// ========================================================================

IMPL_META_ACTION( Pie, META_PIE_ACTION )

// ------------------------------------------------------------------------

MetaPieAction::MetaPieAction( const Rectangle& rRect,
							  const Point& rStart, const Point& rEnd ) :
	MetaAction	( META_PIE_ACTION ),
	maRect		( rRect ),
	maStartPt	( rStart ),
	maEndPt 	( rEnd )
{
}

// ------------------------------------------------------------------------

void MetaPieAction::Execute( OutputDevice* pOut )
{
	pOut->DrawPie( maRect, maStartPt, maEndPt );
}

// ------------------------------------------------------------------------

MetaAction* MetaPieAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaPieAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaPieAction::Move( long nHorzMove, long nVertMove )
{
	maRect.Move(  nHorzMove, nVertMove );
	maStartPt.Move(  nHorzMove, nVertMove );
	maEndPt.Move(  nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaPieAction::Scale( double fScaleX, double fScaleY )
{
	ImplScaleRect( maRect, fScaleX, fScaleY );
	ImplScalePoint( maStartPt, fScaleX, fScaleY );
	ImplScalePoint( maEndPt, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaPieAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maRect == ((MetaPieAction&)rMetaAction).maRect ) &&
		   ( maStartPt == ((MetaPieAction&)rMetaAction).maStartPt ) &&
		   ( maEndPt == ((MetaPieAction&)rMetaAction).maEndPt );
}

// ------------------------------------------------------------------------

void MetaPieAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maRect << maStartPt << maEndPt;
}

// ------------------------------------------------------------------------

void MetaPieAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maRect >> maStartPt >> maEndPt;
}

// ========================================================================

IMPL_META_ACTION( Chord, META_CHORD_ACTION )

// ------------------------------------------------------------------------

MetaChordAction::MetaChordAction( const Rectangle& rRect,
								  const Point& rStart, const Point& rEnd ) :
	MetaAction	( META_CHORD_ACTION ),
	maRect		( rRect ),
	maStartPt	( rStart ),
	maEndPt 	( rEnd )
{
}

// ------------------------------------------------------------------------

void MetaChordAction::Execute( OutputDevice* pOut )
{
	pOut->DrawChord( maRect, maStartPt, maEndPt );
}

// ------------------------------------------------------------------------

MetaAction* MetaChordAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaChordAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaChordAction::Move( long nHorzMove, long nVertMove )
{
	maRect.Move(  nHorzMove, nVertMove );
	maStartPt.Move(  nHorzMove, nVertMove );
	maEndPt.Move(  nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaChordAction::Scale( double fScaleX, double fScaleY )
{
	ImplScaleRect( maRect, fScaleX, fScaleY );
	ImplScalePoint( maStartPt, fScaleX, fScaleY );
	ImplScalePoint( maEndPt, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaChordAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maRect == ((MetaChordAction&)rMetaAction).maRect ) &&
		   ( maStartPt == ((MetaChordAction&)rMetaAction).maStartPt ) &&
		   ( maEndPt == ((MetaChordAction&)rMetaAction).maEndPt );
}

// ------------------------------------------------------------------------

void MetaChordAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maRect << maStartPt << maEndPt;
}

// ------------------------------------------------------------------------

void MetaChordAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maRect >> maStartPt >> maEndPt;
}

// ========================================================================

IMPL_META_ACTION( PolyLine, META_POLYLINE_ACTION )

// ------------------------------------------------------------------------

MetaPolyLineAction::MetaPolyLineAction( const Polygon& rPoly ) :
	MetaAction	( META_POLYLINE_ACTION ),
	maPoly		( rPoly )
{
}

// ------------------------------------------------------------------------

MetaPolyLineAction::MetaPolyLineAction( const Polygon& rPoly, const LineInfo& rLineInfo ) :
	MetaAction	( META_POLYLINE_ACTION ),
	maLineInfo	( rLineInfo ),
	maPoly		( rPoly )
{
}

// ------------------------------------------------------------------------

void MetaPolyLineAction::Execute( OutputDevice* pOut )
{
	if( maLineInfo.IsDefault() )
		pOut->DrawPolyLine( maPoly );
	else
		pOut->DrawPolyLine( maPoly, maLineInfo );
}

// ------------------------------------------------------------------------

MetaAction* MetaPolyLineAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaPolyLineAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaPolyLineAction::Move( long nHorzMove, long nVertMove )
{
	maPoly.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaPolyLineAction::Scale( double fScaleX, double fScaleY )
{
	ImplScalePoly( maPoly, fScaleX, fScaleY );
	ImplScaleLineInfo( maLineInfo, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaPolyLineAction::Compare( const MetaAction& rMetaAction ) const
{
	sal_Bool bIsEqual = sal_True;;
	if ( maLineInfo != ((MetaPolyLineAction&)rMetaAction).maLineInfo )
		bIsEqual = sal_False;
	else
		bIsEqual = maPoly.IsEqual(((MetaPolyLineAction&)rMetaAction).maPoly );
	return bIsEqual;

}

// ------------------------------------------------------------------------

void MetaPolyLineAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 3, pData );

	Polygon aSimplePoly;
	maPoly.AdaptiveSubdivide( aSimplePoly );

	rOStm << aSimplePoly;								// Version 1
	rOStm << maLineInfo;								// Version 2

	sal_uInt8 bHasPolyFlags = maPoly.HasFlags();		// Version 3
	rOStm << bHasPolyFlags;
	if ( bHasPolyFlags )
		maPoly.Write( rOStm );
}

// ------------------------------------------------------------------------

void MetaPolyLineAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );

	// Version 1
	rIStm >> maPoly;

	// Version 2
	if( aCompat.GetVersion() >= 2 )
		rIStm >> maLineInfo;
	if ( aCompat.GetVersion() >= 3 )
	{
		sal_uInt8 bHasPolyFlags;
		rIStm >> bHasPolyFlags;
		if ( bHasPolyFlags )
			maPoly.Read( rIStm );
	}
}

// ========================================================================

IMPL_META_ACTION( Polygon, META_POLYGON_ACTION )

// ------------------------------------------------------------------------

MetaPolygonAction::MetaPolygonAction( const Polygon& rPoly ) :
	MetaAction	( META_POLYGON_ACTION ),
	maPoly		( rPoly )
{
}

// ------------------------------------------------------------------------

void MetaPolygonAction::Execute( OutputDevice* pOut )
{
	pOut->DrawPolygon( maPoly );
}

// ------------------------------------------------------------------------

MetaAction* MetaPolygonAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaPolygonAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaPolygonAction::Move( long nHorzMove, long nVertMove )
{
	maPoly.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaPolygonAction::Scale( double fScaleX, double fScaleY )
{
	ImplScalePoly( maPoly, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaPolygonAction::Compare( const MetaAction& rMetaAction ) const
{
	return maPoly.IsEqual(((MetaPolygonAction&)rMetaAction).maPoly );
}

// ------------------------------------------------------------------------

void MetaPolygonAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 2, pData );

	Polygon aSimplePoly;							// Version 1
	maPoly.AdaptiveSubdivide( aSimplePoly );
	rOStm << aSimplePoly;

	sal_uInt8 bHasPolyFlags = maPoly.HasFlags();	// Version 2
	rOStm << bHasPolyFlags;
	if ( bHasPolyFlags )
		maPoly.Write( rOStm );
}

// ------------------------------------------------------------------------

void MetaPolygonAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );

	rIStm >> maPoly;					// Version 1

	if( aCompat.GetVersion() >= 2 )		// Version 2
	{
		sal_uInt8 bHasPolyFlags;
		rIStm >> bHasPolyFlags;
		if ( bHasPolyFlags )
			maPoly.Read( rIStm );
	}
}

// ========================================================================

IMPL_META_ACTION( PolyPolygon, META_POLYPOLYGON_ACTION )

// ------------------------------------------------------------------------

MetaPolyPolygonAction::MetaPolyPolygonAction( const PolyPolygon& rPolyPoly ) :
	MetaAction	( META_POLYPOLYGON_ACTION ),
	maPolyPoly	( rPolyPoly )
{
}

// ------------------------------------------------------------------------

void MetaPolyPolygonAction::Execute( OutputDevice* pOut )
{
	pOut->DrawPolyPolygon( maPolyPoly );
}

// ------------------------------------------------------------------------

MetaAction* MetaPolyPolygonAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaPolyPolygonAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaPolyPolygonAction::Move( long nHorzMove, long nVertMove )
{
	maPolyPoly.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaPolyPolygonAction::Scale( double fScaleX, double fScaleY )
{
	for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ )
		ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaPolyPolygonAction::Compare( const MetaAction& rMetaAction ) const
{
	return maPolyPoly.IsEqual(((MetaPolyPolygonAction&)rMetaAction).maPolyPoly );
}

// ------------------------------------------------------------------------

void MetaPolyPolygonAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 2, pData );

	sal_uInt16 nNumberOfComplexPolygons = 0;
	sal_uInt16 i, nPolyCount = maPolyPoly.Count();

	Polygon aSimplePoly;								// Version 1
	rOStm << nPolyCount;
	for ( i = 0; i < nPolyCount; i++ )
	{
		const Polygon& rPoly = maPolyPoly.GetObject( i );
		if ( rPoly.HasFlags() )
			nNumberOfComplexPolygons++;
		rPoly.AdaptiveSubdivide( aSimplePoly );
		rOStm << aSimplePoly;
	}

	rOStm << nNumberOfComplexPolygons;					// Version 2
	for ( i = 0; nNumberOfComplexPolygons && ( i < nPolyCount ); i++ )
	{
		const Polygon& rPoly = maPolyPoly.GetObject( i );
		if ( rPoly.HasFlags() )
		{
			rOStm << i;
			rPoly.Write( rOStm );

			nNumberOfComplexPolygons--;
		}
	}
}

// ------------------------------------------------------------------------

void MetaPolyPolygonAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maPolyPoly;				// Version 1

	if ( aCompat.GetVersion() >= 2 )	// Version 2
	{
		sal_uInt16 i, nIndex, nNumberOfComplexPolygons;
		rIStm >> nNumberOfComplexPolygons;
		for ( i = 0; i < nNumberOfComplexPolygons; i++ )
		{
			rIStm >> nIndex;
			Polygon aPoly;
			aPoly.Read( rIStm );
			maPolyPoly.Replace( aPoly, nIndex );
		}
	}
}

// ========================================================================

IMPL_META_ACTION( Text, META_TEXT_ACTION )

// ------------------------------------------------------------------------

MetaTextAction::MetaTextAction( const Point& rPt, const XubString& rStr,
								sal_uInt16 nIndex, sal_uInt16 nLen ) :
	MetaAction	( META_TEXT_ACTION ),
	maPt		( rPt ),
	maStr		( rStr ),
	mnIndex 	( nIndex ),
	mnLen		( nLen )
{
}

// ------------------------------------------------------------------------

void MetaTextAction::Execute( OutputDevice* pOut )
{
	pOut->DrawText( maPt, maStr, mnIndex, mnLen );
}

// ------------------------------------------------------------------------

MetaAction* MetaTextAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaTextAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaTextAction::Move( long nHorzMove, long nVertMove )
{
	maPt.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaTextAction::Scale( double fScaleX, double fScaleY )
{
	ImplScalePoint( maPt, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaTextAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maPt == ((MetaTextAction&)rMetaAction).maPt ) &&
		   ( maStr == ((MetaTextAction&)rMetaAction).maStr ) &&
		   ( mnIndex == ((MetaTextAction&)rMetaAction).mnIndex ) &&
		   ( mnLen == ((MetaTextAction&)rMetaAction).mnLen );
}

// ------------------------------------------------------------------------

void MetaTextAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 2, pData );
	rOStm	<< maPt;
	rOStm.WriteByteString( maStr, pData->meActualCharSet );
	rOStm	<< mnIndex;
	rOStm	<< mnLen;

	sal_uInt16 i, nLen = maStr.Len();							// version 2
	rOStm << nLen;
	for ( i = 0; i < nLen; i++ )
	{
		sal_Unicode nUni = maStr.GetChar( i );
		rOStm << nUni;
	}
}

// ------------------------------------------------------------------------

void MetaTextAction::Read( SvStream& rIStm, ImplMetaReadData* pData )
{
	COMPAT( rIStm );
	rIStm	>> maPt;
	rIStm.ReadByteString( maStr, pData->meActualCharSet );
	rIStm	>> mnIndex;
	rIStm	>> mnLen;

	if ( aCompat.GetVersion() >= 2 )							// Version 2
	{
		sal_uInt16 nLen;
		rIStm >> nLen;
		sal_Unicode* pBuffer = maStr.AllocBuffer( nLen );
		while ( nLen-- )
			rIStm >> *pBuffer++;
	}
}

// ========================================================================

MetaTextArrayAction::MetaTextArrayAction() :
	MetaAction	( META_TEXTARRAY_ACTION ),
	mpDXAry 	( NULL ),
	mnIndex 	( 0 ),
	mnLen		( 0 )
{
}

// ------------------------------------------------------------------------

MetaTextArrayAction::MetaTextArrayAction( const MetaTextArrayAction& rAction ) :
	MetaAction	( META_TEXTARRAY_ACTION ),
	maStartPt	( rAction.maStartPt ),
	maStr		( rAction.maStr ),
	mnIndex 	( rAction.mnIndex ),
	mnLen		( rAction.mnLen )
{
	if( rAction.mpDXAry )
	{
		const sal_uLong nAryLen = mnLen;

		mpDXAry = new sal_Int32[ nAryLen ];
		memcpy( mpDXAry, rAction.mpDXAry, nAryLen * sizeof( sal_Int32 ) );
	}
	else
		mpDXAry = NULL;
}

// ------------------------------------------------------------------------

MetaTextArrayAction::MetaTextArrayAction( const Point& rStartPt,
										  const XubString& rStr,
										  const sal_Int32* pDXAry,
										  sal_uInt16 nIndex,
										  sal_uInt16 nLen ) :
	MetaAction	( META_TEXTARRAY_ACTION ),
	maStartPt	( rStartPt ),
	maStr		( rStr ),
	mnIndex 	( nIndex ),
	mnLen		( ( nLen == STRING_LEN ) ? rStr.Len() : nLen )
{
    const sal_uLong nAryLen = pDXAry ? mnLen : 0;

	if( nAryLen )
	{
		mpDXAry = new sal_Int32[ nAryLen ];
		memcpy( mpDXAry, pDXAry, nAryLen * sizeof( sal_Int32 ) );
	}
	else
		mpDXAry = NULL;
}

// ------------------------------------------------------------------------

MetaTextArrayAction::~MetaTextArrayAction()
{
	delete[] mpDXAry;
}

// ------------------------------------------------------------------------

void MetaTextArrayAction::Execute( OutputDevice* pOut )
{
	pOut->DrawTextArray( maStartPt, maStr, mpDXAry, mnIndex, mnLen );
}

// ------------------------------------------------------------------------

MetaAction* MetaTextArrayAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaTextArrayAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaTextArrayAction::Move( long nHorzMove, long nVertMove )
{
	maStartPt.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaTextArrayAction::Scale( double fScaleX, double fScaleY )
{
	ImplScalePoint( maStartPt, fScaleX, fScaleY );

	if ( mpDXAry && mnLen )
	{
		for ( sal_uInt16 i = 0, nCount = mnLen; i < nCount; i++ )
			mpDXAry[ i ] = FRound( mpDXAry[ i ] * fabs(fScaleX) );
	}
}

// ------------------------------------------------------------------------

sal_Bool MetaTextArrayAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maStartPt == ((MetaTextArrayAction&)rMetaAction).maStartPt ) &&
		   ( maStr == ((MetaTextArrayAction&)rMetaAction).maStr ) &&
		   ( mnIndex == ((MetaTextArrayAction&)rMetaAction).mnIndex ) &&
		   ( mnLen == ((MetaTextArrayAction&)rMetaAction).mnLen ) &&
		   ( memcmp( mpDXAry, ((MetaTextArrayAction&)rMetaAction).mpDXAry, mnLen ) == 0 );
}

// ------------------------------------------------------------------------

void MetaTextArrayAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
    const sal_uInt32 nAryLen = mpDXAry ? mnLen : 0;

	WRITE_BASE_COMPAT( rOStm, 2, pData );
	rOStm	<< maStartPt;
	rOStm.WriteByteString( maStr, pData->meActualCharSet );
	rOStm	<< mnIndex;
	rOStm	<< mnLen;
	rOStm	<< nAryLen;

	for( sal_uLong i = 0UL; i < nAryLen; i++ )
		rOStm << mpDXAry[ i ];

	sal_uInt16 j, nLen = maStr.Len();							// version 2
	rOStm << nLen;
	for ( j = 0; j < nLen; j++ )
	{
		sal_Unicode nUni = maStr.GetChar( j );
		rOStm << nUni;
	}
}

// ------------------------------------------------------------------------

void MetaTextArrayAction::Read( SvStream& rIStm, ImplMetaReadData* pData )
{
	sal_uInt32 nAryLen;

	delete[] mpDXAry;

	COMPAT( rIStm );
	rIStm	>> maStartPt;
	rIStm.ReadByteString( maStr, pData->meActualCharSet );
	rIStm	>> mnIndex;
	rIStm	>> mnLen;
	rIStm	>> nAryLen;

	if ( mnIndex + mnLen > maStr.Len() )
	{
		mnIndex = 0;
		mpDXAry = 0;
		return;
	}

	if( nAryLen )
	{
        // #i9762#, #106172# Ensure that DX array is at least mnLen entries long
		if ( mnLen >= nAryLen )
		{
			mpDXAry = new (std::nothrow)sal_Int32[ mnLen ];
			if ( mpDXAry )
			{
	       		sal_uLong i;
				for( i = 0UL; i < nAryLen; i++ )
					rIStm >> mpDXAry[ i ];

				// #106172# setup remainder
				for( ; i < mnLen; i++ )
					mpDXAry[ i ] = 0;
			}
		}
		else
		{
			mpDXAry = NULL;
			return;
		}
	}
	else
		mpDXAry = NULL;

	if ( aCompat.GetVersion() >= 2 )							// Version 2
	{
		sal_uInt16 nLen;
		rIStm >> nLen;
		sal_Unicode* pBuffer = maStr.AllocBuffer( nLen );
		while ( nLen-- )
			rIStm >> *pBuffer++;

		if ( mnIndex + mnLen > maStr.Len() )
		{
			mnIndex = 0;
			delete[] mpDXAry, mpDXAry = NULL;
		}
	}
}

// ========================================================================

IMPL_META_ACTION( StretchText, META_STRETCHTEXT_ACTION )

// ------------------------------------------------------------------------

MetaStretchTextAction::MetaStretchTextAction( const Point& rPt, sal_uInt32 nWidth,
											  const XubString& rStr,
											  sal_uInt16 nIndex, sal_uInt16 nLen ) :
	MetaAction	( META_STRETCHTEXT_ACTION ),
	maPt		( rPt ),
	maStr		( rStr ),
	mnWidth 	( nWidth ),
	mnIndex 	( nIndex ),
	mnLen		( nLen )
{
}

// ------------------------------------------------------------------------

void MetaStretchTextAction::Execute( OutputDevice* pOut )
{
	pOut->DrawStretchText( maPt, mnWidth, maStr, mnIndex, mnLen );
}

// ------------------------------------------------------------------------

MetaAction* MetaStretchTextAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaStretchTextAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaStretchTextAction::Move( long nHorzMove, long nVertMove )
{
	maPt.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaStretchTextAction::Scale( double fScaleX, double fScaleY )
{
	ImplScalePoint( maPt, fScaleX, fScaleY );
	mnWidth = (sal_uLong)FRound( mnWidth * fabs(fScaleX) );
}

// ------------------------------------------------------------------------

sal_Bool MetaStretchTextAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maPt == ((MetaStretchTextAction&)rMetaAction).maPt ) &&
		   ( maStr == ((MetaStretchTextAction&)rMetaAction).maStr ) &&
		   ( mnWidth == ((MetaStretchTextAction&)rMetaAction).mnWidth ) &&
		   ( mnIndex == ((MetaStretchTextAction&)rMetaAction).mnIndex ) &&
		   ( mnLen == ((MetaStretchTextAction&)rMetaAction).mnLen );
}

// ------------------------------------------------------------------------

void MetaStretchTextAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 2, pData );
	rOStm	<< maPt;
	rOStm.WriteByteString( maStr, pData->meActualCharSet );
	rOStm	<< mnWidth;
	rOStm	<< mnIndex;
	rOStm	<< mnLen;

	sal_uInt16 i, nLen = maStr.Len();							// version 2
	rOStm << nLen;
	for ( i = 0; i < nLen; i++ )
	{
		sal_Unicode nUni = maStr.GetChar( i );
		rOStm << nUni;
	}
}

// ------------------------------------------------------------------------

void MetaStretchTextAction::Read( SvStream& rIStm, ImplMetaReadData* pData )
{
	COMPAT( rIStm );
	rIStm	>> maPt;
	rIStm.ReadByteString( maStr, pData->meActualCharSet );
	rIStm	>> mnWidth;
	rIStm	>> mnIndex;
	rIStm	>> mnLen;

	if ( aCompat.GetVersion() >= 2 )							// Version 2
	{
		sal_uInt16 nLen;
		rIStm >> nLen;
		sal_Unicode* pBuffer = maStr.AllocBuffer( nLen );
		while ( nLen-- )
			rIStm >> *pBuffer++;
	}
}

// ========================================================================

IMPL_META_ACTION( TextRect, META_TEXTRECT_ACTION )

// ------------------------------------------------------------------------

MetaTextRectAction::MetaTextRectAction( const Rectangle& rRect,
										const XubString& rStr, sal_uInt16 nStyle ) :
	MetaAction	( META_TEXTRECT_ACTION ),
	maRect		( rRect ),
	maStr		( rStr ),
	mnStyle 	( nStyle )
{
}

// ------------------------------------------------------------------------

void MetaTextRectAction::Execute( OutputDevice* pOut )
{
	pOut->DrawText( maRect, maStr, mnStyle );
}

// ------------------------------------------------------------------------

MetaAction* MetaTextRectAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaTextRectAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaTextRectAction::Move( long nHorzMove, long nVertMove )
{
	maRect.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaTextRectAction::Scale( double fScaleX, double fScaleY )
{
	ImplScaleRect( maRect, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaTextRectAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maRect == ((MetaTextRectAction&)rMetaAction).maRect ) &&
		   ( maStr == ((MetaTextRectAction&)rMetaAction).maStr ) &&
		   ( mnStyle == ((MetaTextRectAction&)rMetaAction).mnStyle );
}

// ------------------------------------------------------------------------

void MetaTextRectAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 2, pData );
	rOStm	<< maRect;
	rOStm.WriteByteString( maStr, pData->meActualCharSet );
	rOStm	<< mnStyle;

	sal_uInt16 i, nLen = maStr.Len();							// version 2
	rOStm << nLen;
	for ( i = 0; i < nLen; i++ )
	{
		sal_Unicode nUni = maStr.GetChar( i );
		rOStm << nUni;
	}
}

// ------------------------------------------------------------------------

void MetaTextRectAction::Read( SvStream& rIStm, ImplMetaReadData* pData )
{
	COMPAT( rIStm );
	rIStm	>> maRect;
	rIStm.ReadByteString( maStr, pData->meActualCharSet );
	rIStm	>> mnStyle;

	if ( aCompat.GetVersion() >= 2 )							// Version 2
	{
		sal_uInt16 nLen;
		rIStm >> nLen;
		sal_Unicode* pBuffer = maStr.AllocBuffer( nLen );
		while ( nLen-- )
			rIStm >> *pBuffer++;
	}
}

// ========================================================================

IMPL_META_ACTION( TextLine, META_TEXTLINE_ACTION )

// ------------------------------------------------------------------------

MetaTextLineAction::MetaTextLineAction( const Point& rPos, long nWidth,
										FontStrikeout eStrikeout,
										FontUnderline eUnderline,
										FontUnderline eOverline ) :
	MetaAction	( META_TEXTLINE_ACTION ),
	maPos		( rPos ),
	mnWidth 	( nWidth ),
	meStrikeout ( eStrikeout ),
	meUnderline ( eUnderline ),
	meOverline  ( eOverline )
{
}

// ------------------------------------------------------------------------

void MetaTextLineAction::Execute( OutputDevice* pOut )
{
	pOut->DrawTextLine( maPos, mnWidth, meStrikeout, meUnderline, meOverline );
}

// ------------------------------------------------------------------------

MetaAction* MetaTextLineAction::Clone()
{
	MetaAction* pClone = (MetaAction*)new MetaTextLineAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaTextLineAction::Move( long nHorzMove, long nVertMove )
{
	maPos.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaTextLineAction::Scale( double fScaleX, double fScaleY )
{
	ImplScalePoint( maPos, fScaleX, fScaleY );
	mnWidth = FRound( mnWidth * fabs(fScaleX) );
}

// ------------------------------------------------------------------------

sal_Bool MetaTextLineAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maPos == ((MetaTextLineAction&)rMetaAction).maPos ) &&
		   ( mnWidth == ((MetaTextLineAction&)rMetaAction).mnWidth ) &&
		   ( meStrikeout == ((MetaTextLineAction&)rMetaAction).meStrikeout ) &&
		   ( meUnderline == ((MetaTextLineAction&)rMetaAction).meUnderline ) &&
		   ( meOverline  == ((MetaTextLineAction&)rMetaAction).meOverline );
}

// ------------------------------------------------------------------------

void MetaTextLineAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 2, pData );

	rOStm << maPos;
	rOStm << mnWidth;
	rOStm << static_cast<sal_uInt32>(meStrikeout);
	rOStm << static_cast<sal_uInt32>(meUnderline);
    // new in version 2
	rOStm << static_cast<sal_uInt32>(meOverline);
}

// ------------------------------------------------------------------------

void MetaTextLineAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );

	sal_uInt32 nTemp;
	rIStm >> maPos;
	rIStm >> mnWidth;
	rIStm >> nTemp;
	meStrikeout = (FontStrikeout)nTemp;
	rIStm >> nTemp;
	meUnderline = (FontUnderline)nTemp;
    if ( aCompat.GetVersion() >= 2 ) {
        rIStm >> nTemp;
        meUnderline = (FontUnderline)nTemp;
    }
}

// ========================================================================

IMPL_META_ACTION( Bmp, META_BMP_ACTION )

// ------------------------------------------------------------------------

MetaBmpAction::MetaBmpAction( const Point& rPt, const Bitmap& rBmp ) :
	MetaAction	( META_BMP_ACTION ),
	maBmp		( rBmp ),
	maPt		( rPt )
{
}

// ------------------------------------------------------------------------

void MetaBmpAction::Execute( OutputDevice* pOut )
{
	pOut->DrawBitmap( maPt, maBmp );
}

// ------------------------------------------------------------------------

MetaAction* MetaBmpAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaBmpAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaBmpAction::Move( long nHorzMove, long nVertMove )
{
	maPt.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaBmpAction::Scale( double fScaleX, double fScaleY )
{
	ImplScalePoint( maPt, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaBmpAction::Compare( const MetaAction& rMetaAction ) const
{
	return maBmp.IsEqual(((MetaBmpAction&)rMetaAction).maBmp ) &&
		   ( maPt == ((MetaBmpAction&)rMetaAction).maPt );
}

// ------------------------------------------------------------------------

void MetaBmpAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	if( !!maBmp )
	{
		WRITE_BASE_COMPAT( rOStm, 1, pData );
        WriteDIB(maBmp, rOStm, false, true);
		rOStm << maPt;
	}
}

// ------------------------------------------------------------------------

void MetaBmpAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
    ReadDIB(maBmp, rIStm, true);
	rIStm >> maPt;
}

// ========================================================================

IMPL_META_ACTION( BmpScale, META_BMPSCALE_ACTION )

// ------------------------------------------------------------------------

MetaBmpScaleAction::MetaBmpScaleAction( const Point& rPt, const Size& rSz,
										const Bitmap& rBmp ) :
	MetaAction	( META_BMPSCALE_ACTION ),
	maBmp		( rBmp ),
	maPt		( rPt ),
	maSz		( rSz )
{
}

// ------------------------------------------------------------------------

void MetaBmpScaleAction::Execute( OutputDevice* pOut )
{
	pOut->DrawBitmap( maPt, maSz, maBmp );
}

// ------------------------------------------------------------------------

MetaAction* MetaBmpScaleAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaBmpScaleAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaBmpScaleAction::Move( long nHorzMove, long nVertMove )
{
	maPt.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaBmpScaleAction::Scale( double fScaleX, double fScaleY )
{
    Rectangle aRectangle(maPt, maSz);
	ImplScaleRect( aRectangle, fScaleX, fScaleY );
    maPt = aRectangle.TopLeft();
    maSz = aRectangle.GetSize();
}

// ------------------------------------------------------------------------

sal_Bool MetaBmpScaleAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maBmp.IsEqual(((MetaBmpScaleAction&)rMetaAction).maBmp )) &&
		   ( maPt == ((MetaBmpScaleAction&)rMetaAction).maPt ) &&
		   ( maSz == ((MetaBmpScaleAction&)rMetaAction).maSz );
}

// ------------------------------------------------------------------------

void MetaBmpScaleAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	if( !!maBmp )
	{
		WRITE_BASE_COMPAT( rOStm, 1, pData );
        WriteDIB(maBmp, rOStm, false, true);
		rOStm << maPt << maSz;
	}
}

// ------------------------------------------------------------------------

void MetaBmpScaleAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
    ReadDIB(maBmp, rIStm, true);
	rIStm >> maPt >> maSz;
}

// ========================================================================

IMPL_META_ACTION( BmpScalePart, META_BMPSCALEPART_ACTION )

// ------------------------------------------------------------------------

MetaBmpScalePartAction::MetaBmpScalePartAction( const Point& rDstPt, const Size& rDstSz,
												const Point& rSrcPt, const Size& rSrcSz,
												const Bitmap& rBmp ) :
	MetaAction	( META_BMPSCALEPART_ACTION ),
	maBmp		( rBmp ),
	maDstPt 	( rDstPt ),
	maDstSz 	( rDstSz ),
	maSrcPt 	( rSrcPt ),
	maSrcSz 	( rSrcSz )
{
}

// ------------------------------------------------------------------------

void MetaBmpScalePartAction::Execute( OutputDevice* pOut )
{
	pOut->DrawBitmap( maDstPt, maDstSz, maSrcPt, maSrcSz, maBmp );
}

// ------------------------------------------------------------------------

MetaAction* MetaBmpScalePartAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaBmpScalePartAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaBmpScalePartAction::Move( long nHorzMove, long nVertMove )
{
	maDstPt.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaBmpScalePartAction::Scale( double fScaleX, double fScaleY )
{
    Rectangle aRectangle(maDstPt, maDstSz);
	ImplScaleRect( aRectangle, fScaleX, fScaleY );
    maDstPt = aRectangle.TopLeft();
    maDstSz = aRectangle.GetSize();
}

// ------------------------------------------------------------------------

sal_Bool MetaBmpScalePartAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maBmp.IsEqual(((MetaBmpScalePartAction&)rMetaAction).maBmp )) &&
		   ( maDstPt == ((MetaBmpScalePartAction&)rMetaAction).maDstPt ) &&
		   ( maDstSz == ((MetaBmpScalePartAction&)rMetaAction).maDstSz ) &&
		   ( maSrcPt == ((MetaBmpScalePartAction&)rMetaAction).maSrcPt ) &&
		   ( maSrcSz == ((MetaBmpScalePartAction&)rMetaAction).maSrcSz );
}

// ------------------------------------------------------------------------

void MetaBmpScalePartAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	if( !!maBmp )
	{
		WRITE_BASE_COMPAT( rOStm, 1, pData );
        WriteDIB(maBmp, rOStm, false, true);
		rOStm << maDstPt << maDstSz << maSrcPt << maSrcSz;
	}
}

// ------------------------------------------------------------------------

void MetaBmpScalePartAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
    ReadDIB(maBmp, rIStm, true);
	rIStm >> maDstPt >> maDstSz >> maSrcPt >> maSrcSz;
}

// ========================================================================

IMPL_META_ACTION( BmpEx, META_BMPEX_ACTION )

// ------------------------------------------------------------------------

MetaBmpExAction::MetaBmpExAction( const Point& rPt, const BitmapEx& rBmpEx ) :
	MetaAction	( META_BMPEX_ACTION ),
	maBmpEx 	( rBmpEx ),
	maPt		( rPt )
{
}

// ------------------------------------------------------------------------

void MetaBmpExAction::Execute( OutputDevice* pOut )
{
	pOut->DrawBitmapEx( maPt, maBmpEx );
}

// ------------------------------------------------------------------------

MetaAction* MetaBmpExAction::Clone()
{
	MetaBmpExAction* pClone = new MetaBmpExAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaBmpExAction::Move( long nHorzMove, long nVertMove )
{
	maPt.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaBmpExAction::Scale( double fScaleX, double fScaleY )
{
	ImplScalePoint( maPt, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaBmpExAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maBmpEx.IsEqual(((MetaBmpExAction&)rMetaAction).maBmpEx )) &&
		   ( maPt == ((MetaBmpExAction&)rMetaAction).maPt );
}

// ------------------------------------------------------------------------

void MetaBmpExAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	if( !!maBmpEx.GetBitmap() )
	{
		WRITE_BASE_COMPAT( rOStm, 1, pData );
        WriteDIBBitmapEx(maBmpEx, rOStm);
		rOStm << maPt;
	}
}

// ------------------------------------------------------------------------

void MetaBmpExAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
    ReadDIBBitmapEx(maBmpEx, rIStm);
	rIStm >> maPt;
}

// ========================================================================

IMPL_META_ACTION( BmpExScale, META_BMPEXSCALE_ACTION )

// ------------------------------------------------------------------------

MetaBmpExScaleAction::MetaBmpExScaleAction( const Point& rPt, const Size& rSz,
											const BitmapEx& rBmpEx ) :
	MetaAction	( META_BMPEXSCALE_ACTION ),
	maBmpEx 	( rBmpEx ),
	maPt		( rPt ),
	maSz		( rSz )
{
}

// ------------------------------------------------------------------------

void MetaBmpExScaleAction::Execute( OutputDevice* pOut )
{
	pOut->DrawBitmapEx( maPt, maSz, maBmpEx );
}

// ------------------------------------------------------------------------

MetaAction* MetaBmpExScaleAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaBmpExScaleAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaBmpExScaleAction::Move( long nHorzMove, long nVertMove )
{
	maPt.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaBmpExScaleAction::Scale( double fScaleX, double fScaleY )
{
    Rectangle aRectangle(maPt, maSz);
	ImplScaleRect( aRectangle, fScaleX, fScaleY );
    maPt = aRectangle.TopLeft();
    maSz = aRectangle.GetSize();
}

// ------------------------------------------------------------------------

sal_Bool MetaBmpExScaleAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maBmpEx.IsEqual(((MetaBmpExScaleAction&)rMetaAction).maBmpEx )) &&
		   ( maPt == ((MetaBmpExScaleAction&)rMetaAction).maPt ) &&
		   ( maSz == ((MetaBmpExScaleAction&)rMetaAction).maSz );
}

// ------------------------------------------------------------------------

void MetaBmpExScaleAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	if( !!maBmpEx.GetBitmap() )
	{
		WRITE_BASE_COMPAT( rOStm, 1, pData );
        WriteDIBBitmapEx(maBmpEx, rOStm);
		rOStm << maPt << maSz;
	}
}

// ------------------------------------------------------------------------

void MetaBmpExScaleAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
    ReadDIBBitmapEx(maBmpEx, rIStm);
	rIStm >> maPt >> maSz;
}

// ========================================================================

IMPL_META_ACTION( BmpExScalePart, META_BMPEXSCALEPART_ACTION )

// ------------------------------------------------------------------------

MetaBmpExScalePartAction::MetaBmpExScalePartAction( const Point& rDstPt, const Size& rDstSz,
													const Point& rSrcPt, const Size& rSrcSz,
													const BitmapEx& rBmpEx ) :
	MetaAction	( META_BMPEXSCALEPART_ACTION ),
	maBmpEx 	( rBmpEx ),
	maDstPt 	( rDstPt ),
	maDstSz 	( rDstSz ),
	maSrcPt 	( rSrcPt ),
	maSrcSz 	( rSrcSz )
{
}

// ------------------------------------------------------------------------

void MetaBmpExScalePartAction::Execute( OutputDevice* pOut )
{
	pOut->DrawBitmapEx( maDstPt, maDstSz, maSrcPt, maSrcSz, maBmpEx );
}

// ------------------------------------------------------------------------

MetaAction* MetaBmpExScalePartAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaBmpExScalePartAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaBmpExScalePartAction::Move( long nHorzMove, long nVertMove )
{
	maDstPt.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaBmpExScalePartAction::Scale( double fScaleX, double fScaleY )
{
    Rectangle aRectangle(maDstPt, maDstSz);
	ImplScaleRect( aRectangle, fScaleX, fScaleY );
    maDstPt = aRectangle.TopLeft();
    maDstSz = aRectangle.GetSize();
}

// ------------------------------------------------------------------------

sal_Bool MetaBmpExScalePartAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maBmpEx.IsEqual(((MetaBmpExScalePartAction&)rMetaAction).maBmpEx )) &&
		   ( maDstPt == ((MetaBmpExScalePartAction&)rMetaAction).maDstPt ) &&
		   ( maDstSz == ((MetaBmpExScalePartAction&)rMetaAction).maDstSz ) &&
		   ( maSrcPt == ((MetaBmpExScalePartAction&)rMetaAction).maSrcPt ) &&
		   ( maSrcSz == ((MetaBmpExScalePartAction&)rMetaAction).maSrcSz );
}

// ------------------------------------------------------------------------

void MetaBmpExScalePartAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	if( !!maBmpEx.GetBitmap() )
	{
		WRITE_BASE_COMPAT( rOStm, 1, pData );
        WriteDIBBitmapEx(maBmpEx, rOStm);
		rOStm << maDstPt << maDstSz << maSrcPt << maSrcSz;
	}
}

// ------------------------------------------------------------------------

void MetaBmpExScalePartAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
    ReadDIBBitmapEx(maBmpEx, rIStm);
	rIStm >> maDstPt >> maDstSz >> maSrcPt >> maSrcSz;
}

// ========================================================================

IMPL_META_ACTION( Mask, META_MASK_ACTION )

// ------------------------------------------------------------------------

MetaMaskAction::MetaMaskAction( const Point& rPt,
								const Bitmap& rBmp,
								const Color& rColor ) :
	MetaAction	( META_MASK_ACTION ),
	maBmp		( rBmp ),
	maColor 	( rColor ),
	maPt		( rPt )
{
}

// ------------------------------------------------------------------------

void MetaMaskAction::Execute( OutputDevice* pOut )
{
	pOut->DrawMask( maPt, maBmp, maColor );
}

// ------------------------------------------------------------------------

MetaAction* MetaMaskAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaMaskAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaMaskAction::Move( long nHorzMove, long nVertMove )
{
	maPt.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaMaskAction::Scale( double fScaleX, double fScaleY )
{
	ImplScalePoint( maPt, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaMaskAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maBmp.IsEqual(((MetaMaskAction&)rMetaAction).maBmp )) &&
		   ( maColor == ((MetaMaskAction&)rMetaAction).maColor ) &&
		   ( maPt == ((MetaMaskAction&)rMetaAction).maPt );
}

// ------------------------------------------------------------------------

void MetaMaskAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	if( !!maBmp )
	{
		WRITE_BASE_COMPAT( rOStm, 1, pData );
        WriteDIB(maBmp, rOStm, false, true);
		rOStm << maPt;
	}
}

// ------------------------------------------------------------------------

void MetaMaskAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
    ReadDIB(maBmp, rIStm, true);
	rIStm >> maPt;
}

// ========================================================================

IMPL_META_ACTION( MaskScale, META_MASKSCALE_ACTION )

// ------------------------------------------------------------------------

MetaMaskScaleAction::MetaMaskScaleAction( const Point& rPt, const Size& rSz,
										  const Bitmap& rBmp,
										  const Color& rColor ) :
	MetaAction	( META_MASKSCALE_ACTION ),
	maBmp		( rBmp ),
	maColor 	( rColor ),
	maPt		( rPt ),
	maSz		( rSz )
{
}

// ------------------------------------------------------------------------

void MetaMaskScaleAction::Execute( OutputDevice* pOut )
{
	pOut->DrawMask( maPt, maSz, maBmp, maColor );
}

// ------------------------------------------------------------------------

MetaAction* MetaMaskScaleAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaMaskScaleAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaMaskScaleAction::Move( long nHorzMove, long nVertMove )
{
	maPt.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaMaskScaleAction::Scale( double fScaleX, double fScaleY )
{
    Rectangle aRectangle(maPt, maSz);
	ImplScaleRect( aRectangle, fScaleX, fScaleY );
    maPt = aRectangle.TopLeft();
    maSz = aRectangle.GetSize();
}

// ------------------------------------------------------------------------

sal_Bool MetaMaskScaleAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maBmp.IsEqual(((MetaMaskScaleAction&)rMetaAction).maBmp )) &&
		   ( maColor == ((MetaMaskScaleAction&)rMetaAction).maColor ) &&
		   ( maPt == ((MetaMaskScaleAction&)rMetaAction).maPt ) &&
		   ( maSz == ((MetaMaskScaleAction&)rMetaAction).maSz );
}

// ------------------------------------------------------------------------

void MetaMaskScaleAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	if( !!maBmp )
	{
		WRITE_BASE_COMPAT( rOStm, 1, pData );
        WriteDIB(maBmp, rOStm, false, true);
		rOStm << maPt << maSz;
	}
}

// ------------------------------------------------------------------------

void MetaMaskScaleAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
    ReadDIB(maBmp, rIStm, true);
	rIStm >> maPt >> maSz;
}

// ========================================================================

IMPL_META_ACTION( MaskScalePart, META_MASKSCALEPART_ACTION )

// ------------------------------------------------------------------------

MetaMaskScalePartAction::MetaMaskScalePartAction( const Point& rDstPt, const Size& rDstSz,
												  const Point& rSrcPt, const Size& rSrcSz,
												  const Bitmap& rBmp,
												  const Color& rColor ) :
	MetaAction	( META_MASKSCALEPART_ACTION ),
	maBmp		( rBmp ),
	maColor 	( rColor ),
	maDstPt 	( rDstPt ),
	maDstSz 	( rDstSz ),
	maSrcPt 	( rSrcPt ),
	maSrcSz 	( rSrcSz )
{
}

// ------------------------------------------------------------------------

void MetaMaskScalePartAction::Execute( OutputDevice* pOut )
{
	pOut->DrawMask( maDstPt, maDstSz, maSrcPt, maSrcSz, maBmp, maColor );
}

// ------------------------------------------------------------------------

MetaAction* MetaMaskScalePartAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaMaskScalePartAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaMaskScalePartAction::Move( long nHorzMove, long nVertMove )
{
	maDstPt.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaMaskScalePartAction::Scale( double fScaleX, double fScaleY )
{
    Rectangle aRectangle(maDstPt, maDstSz);
	ImplScaleRect( aRectangle, fScaleX, fScaleY );
    maDstPt = aRectangle.TopLeft();
    maDstSz = aRectangle.GetSize();
}

// ------------------------------------------------------------------------

sal_Bool MetaMaskScalePartAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maBmp.IsEqual(((MetaMaskScalePartAction&)rMetaAction).maBmp )) &&
		   ( maColor == ((MetaMaskScalePartAction&)rMetaAction).maColor ) &&
		   ( maDstPt == ((MetaMaskScalePartAction&)rMetaAction).maDstPt ) &&
		   ( maDstSz == ((MetaMaskScalePartAction&)rMetaAction).maDstSz ) &&
		   ( maSrcPt == ((MetaMaskScalePartAction&)rMetaAction).maSrcPt ) &&
		   ( maSrcSz == ((MetaMaskScalePartAction&)rMetaAction).maSrcSz );
}

// ------------------------------------------------------------------------

void MetaMaskScalePartAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	if( !!maBmp )
	{
		WRITE_BASE_COMPAT( rOStm, 1, pData );
        WriteDIB(maBmp, rOStm, false, true);
		maColor.Write( rOStm, sal_True );
		rOStm << maDstPt << maDstSz << maSrcPt << maSrcSz;
	}
}

// ------------------------------------------------------------------------

void MetaMaskScalePartAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
    ReadDIB(maBmp, rIStm, true);
	maColor.Read( rIStm, sal_True );
	rIStm >> maDstPt >> maDstSz >> maSrcPt >> maSrcSz;
}

// ========================================================================

IMPL_META_ACTION( Gradient, META_GRADIENT_ACTION )

// ------------------------------------------------------------------------

MetaGradientAction::MetaGradientAction( const Rectangle& rRect, const Gradient& rGradient ) :
	MetaAction	( META_GRADIENT_ACTION ),
	maRect		( rRect ),
	maGradient	( rGradient )
{
}

// ------------------------------------------------------------------------

void MetaGradientAction::Execute( OutputDevice* pOut )
{
	pOut->DrawGradient( maRect, maGradient );
}

// ------------------------------------------------------------------------

MetaAction* MetaGradientAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaGradientAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaGradientAction::Move( long nHorzMove, long nVertMove )
{
	maRect.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaGradientAction::Scale( double fScaleX, double fScaleY )
{
	ImplScaleRect( maRect, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaGradientAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maRect == ((MetaGradientAction&)rMetaAction).maRect ) &&
		   ( maGradient == ((MetaGradientAction&)rMetaAction).maGradient );
}

// ------------------------------------------------------------------------

void MetaGradientAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maRect << maGradient;
}

// ------------------------------------------------------------------------

void MetaGradientAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maRect >> maGradient;
}

// ========================================================================

MetaGradientExAction::MetaGradientExAction() :
	MetaAction	( META_GRADIENTEX_ACTION )
{
}

// ------------------------------------------------------------------------

MetaGradientExAction::MetaGradientExAction( const PolyPolygon& rPolyPoly, const Gradient& rGradient ) :
	MetaAction	( META_GRADIENTEX_ACTION ),
	maPolyPoly	( rPolyPoly ),
	maGradient	( rGradient )
{
}

// ------------------------------------------------------------------------

MetaGradientExAction::~MetaGradientExAction()
{
}

// ------------------------------------------------------------------------

void MetaGradientExAction::Execute( OutputDevice* pOut )
{
	if( pOut->GetConnectMetaFile() )
    {
        Duplicate();
		pOut->GetConnectMetaFile()->AddAction( this );
    }
}

// ------------------------------------------------------------------------

MetaAction* MetaGradientExAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaGradientExAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaGradientExAction::Move( long nHorzMove, long nVertMove )
{
	maPolyPoly.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaGradientExAction::Scale( double fScaleX, double fScaleY )
{
	for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ )
		ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaGradientExAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maPolyPoly == ((MetaGradientExAction&)rMetaAction).maPolyPoly ) &&
		   ( maGradient == ((MetaGradientExAction&)rMetaAction).maGradient );
}

// ------------------------------------------------------------------------

void MetaGradientExAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );

    // #i105373# see comment at MetaTransparentAction::Write
    PolyPolygon aNoCurvePolyPolygon;
    maPolyPoly.AdaptiveSubdivide(aNoCurvePolyPolygon);

    rOStm << aNoCurvePolyPolygon;
    rOStm << maGradient;
}

// ------------------------------------------------------------------------

void MetaGradientExAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maPolyPoly >> maGradient;
}

// ========================================================================

IMPL_META_ACTION( Hatch, META_HATCH_ACTION )

// ------------------------------------------------------------------------

MetaHatchAction::MetaHatchAction( const PolyPolygon& rPolyPoly, const Hatch& rHatch ) :
	MetaAction	( META_HATCH_ACTION ),
	maPolyPoly	( rPolyPoly ),
	maHatch 	( rHatch )
{
}

// ------------------------------------------------------------------------

void MetaHatchAction::Execute( OutputDevice* pOut )
{
	pOut->DrawHatch( maPolyPoly, maHatch );
}

// ------------------------------------------------------------------------

MetaAction* MetaHatchAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaHatchAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaHatchAction::Move( long nHorzMove, long nVertMove )
{
	maPolyPoly.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaHatchAction::Scale( double fScaleX, double fScaleY )
{
	for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ )
		ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaHatchAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maPolyPoly == ((MetaHatchAction&)rMetaAction).maPolyPoly ) &&
		   ( maHatch == ((MetaHatchAction&)rMetaAction).maHatch );
}

// ------------------------------------------------------------------------

void MetaHatchAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );

    // #i105373# see comment at MetaTransparentAction::Write
    PolyPolygon aNoCurvePolyPolygon;
    maPolyPoly.AdaptiveSubdivide(aNoCurvePolyPolygon);

    rOStm << aNoCurvePolyPolygon;
    rOStm << maHatch;
}

// ------------------------------------------------------------------------

void MetaHatchAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maPolyPoly >> maHatch;
}

// ========================================================================

IMPL_META_ACTION( Wallpaper, META_WALLPAPER_ACTION )

// ------------------------------------------------------------------------

MetaWallpaperAction::MetaWallpaperAction( const Rectangle& rRect,
										  const Wallpaper& rPaper ) :
	MetaAction	( META_WALLPAPER_ACTION ),
	maRect		( rRect ),
	maWallpaper ( rPaper )
{
}

// ------------------------------------------------------------------------

void MetaWallpaperAction::Execute( OutputDevice* pOut )
{
	pOut->DrawWallpaper( maRect, maWallpaper );
}

// ------------------------------------------------------------------------

MetaAction* MetaWallpaperAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaWallpaperAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaWallpaperAction::Move( long nHorzMove, long nVertMove )
{
	maRect.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaWallpaperAction::Scale( double fScaleX, double fScaleY )
{
	ImplScaleRect( maRect, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaWallpaperAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maRect == ((MetaWallpaperAction&)rMetaAction).maRect ) &&
		   ( maWallpaper == ((MetaWallpaperAction&)rMetaAction).maWallpaper );
}

// ------------------------------------------------------------------------

void MetaWallpaperAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maWallpaper;
}

// ------------------------------------------------------------------------

void MetaWallpaperAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maWallpaper;
}

// ========================================================================

IMPL_META_ACTION( ClipRegion, META_CLIPREGION_ACTION )

// ------------------------------------------------------------------------

MetaClipRegionAction::MetaClipRegionAction( const Region& rRegion, sal_Bool bClip ) :
	MetaAction	( META_CLIPREGION_ACTION ),
	maRegion	( rRegion ),
	mbClip		( bClip )
{
}

// ------------------------------------------------------------------------

void MetaClipRegionAction::Execute( OutputDevice* pOut )
{
	if( mbClip )
		pOut->SetClipRegion( maRegion );
	else
		pOut->SetClipRegion();
}

// ------------------------------------------------------------------------

MetaAction* MetaClipRegionAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaClipRegionAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaClipRegionAction::Move( long nHorzMove, long nVertMove )
{
	maRegion.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaClipRegionAction::Scale( double fScaleX, double fScaleY )
{
	maRegion.Scale( fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaClipRegionAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maRegion == ((MetaClipRegionAction&)rMetaAction).maRegion ) &&
		   ( mbClip == ((MetaClipRegionAction&)rMetaAction).mbClip );
}

// ------------------------------------------------------------------------

void MetaClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maRegion << mbClip;
}

// ------------------------------------------------------------------------

void MetaClipRegionAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maRegion >> mbClip;
}

// ========================================================================

IMPL_META_ACTION( ISectRectClipRegion, META_ISECTRECTCLIPREGION_ACTION )

// ------------------------------------------------------------------------

MetaISectRectClipRegionAction::MetaISectRectClipRegionAction( const Rectangle& rRect ) :
	MetaAction	( META_ISECTRECTCLIPREGION_ACTION ),
	maRect		( rRect )
{
}

// ------------------------------------------------------------------------

void MetaISectRectClipRegionAction::Execute( OutputDevice* pOut )
{
	pOut->IntersectClipRegion( maRect );
}

// ------------------------------------------------------------------------

MetaAction* MetaISectRectClipRegionAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaISectRectClipRegionAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaISectRectClipRegionAction::Move( long nHorzMove, long nVertMove )
{
	maRect.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaISectRectClipRegionAction::Scale( double fScaleX, double fScaleY )
{
	ImplScaleRect( maRect, fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaISectRectClipRegionAction::Compare( const MetaAction& rMetaAction ) const
{
	return maRect == ((MetaISectRectClipRegionAction&)rMetaAction).maRect;
}

// ------------------------------------------------------------------------

void MetaISectRectClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maRect;
}

// ------------------------------------------------------------------------

void MetaISectRectClipRegionAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maRect;
}

// ========================================================================

IMPL_META_ACTION( ISectRegionClipRegion, META_ISECTREGIONCLIPREGION_ACTION )

// ------------------------------------------------------------------------

MetaISectRegionClipRegionAction::MetaISectRegionClipRegionAction( const Region& rRegion ) :
	MetaAction	( META_ISECTREGIONCLIPREGION_ACTION ),
	maRegion	( rRegion )
{
}

// ------------------------------------------------------------------------

void MetaISectRegionClipRegionAction::Execute( OutputDevice* pOut )
{
	pOut->IntersectClipRegion( maRegion );
}

// ------------------------------------------------------------------------

MetaAction* MetaISectRegionClipRegionAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaISectRegionClipRegionAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaISectRegionClipRegionAction::Move( long nHorzMove, long nVertMove )
{
	maRegion.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaISectRegionClipRegionAction::Scale( double fScaleX, double fScaleY )
{
	maRegion.Scale( fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaISectRegionClipRegionAction::Compare( const MetaAction& rMetaAction ) const
{
	return maRegion == ((MetaISectRegionClipRegionAction&)rMetaAction).maRegion;
}

// ------------------------------------------------------------------------

void MetaISectRegionClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maRegion;
}

// ------------------------------------------------------------------------

void MetaISectRegionClipRegionAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maRegion;
}

// ========================================================================

IMPL_META_ACTION( MoveClipRegion, META_MOVECLIPREGION_ACTION )

// ------------------------------------------------------------------------

MetaMoveClipRegionAction::MetaMoveClipRegionAction( long nHorzMove, long nVertMove ) :
	MetaAction	( META_MOVECLIPREGION_ACTION ),
	mnHorzMove	( nHorzMove ),
	mnVertMove	( nVertMove )
{
}

// ------------------------------------------------------------------------

void MetaMoveClipRegionAction::Execute( OutputDevice* pOut )
{
	pOut->MoveClipRegion( mnHorzMove, mnVertMove );
}

// ------------------------------------------------------------------------

MetaAction* MetaMoveClipRegionAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaMoveClipRegionAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaMoveClipRegionAction::Scale( double fScaleX, double fScaleY )
{
	mnHorzMove = FRound( mnHorzMove * fScaleX );
	mnVertMove = FRound( mnVertMove * fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaMoveClipRegionAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( mnHorzMove == ((MetaMoveClipRegionAction&)rMetaAction).mnHorzMove ) &&
		   ( mnVertMove == ((MetaMoveClipRegionAction&)rMetaAction).mnVertMove );
}

// ------------------------------------------------------------------------

void MetaMoveClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << mnHorzMove << mnVertMove;
}

// ------------------------------------------------------------------------

void MetaMoveClipRegionAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> mnHorzMove >> mnVertMove;
}

// ========================================================================

IMPL_META_ACTION( LineColor, META_LINECOLOR_ACTION )

// ------------------------------------------------------------------------

MetaLineColorAction::MetaLineColorAction( const Color& rColor, sal_Bool bSet ) :
	MetaAction	( META_LINECOLOR_ACTION ),
	maColor 	( rColor ),
	mbSet		( bSet )
{
}

// ------------------------------------------------------------------------

void MetaLineColorAction::Execute( OutputDevice* pOut )
{
	if( mbSet )
		pOut->SetLineColor( maColor );
	else
		pOut->SetLineColor();
}

// ------------------------------------------------------------------------

MetaAction* MetaLineColorAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaLineColorAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

sal_Bool MetaLineColorAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maColor == ((MetaLineColorAction&)rMetaAction).maColor ) &&
		   ( mbSet == ((MetaLineColorAction&)rMetaAction).mbSet );
}

// ------------------------------------------------------------------------

void MetaLineColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	maColor.Write( rOStm, sal_True );
	rOStm << mbSet;
}

// ------------------------------------------------------------------------

void MetaLineColorAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	maColor.Read( rIStm, sal_True );
	rIStm >> mbSet;
}

// ========================================================================

IMPL_META_ACTION( FillColor, META_FILLCOLOR_ACTION )

// ------------------------------------------------------------------------

MetaFillColorAction::MetaFillColorAction( const Color& rColor, sal_Bool bSet ) :
	MetaAction	( META_FILLCOLOR_ACTION ),
	maColor 	( rColor ),
	mbSet		( bSet )
{
}

// ------------------------------------------------------------------------

void MetaFillColorAction::Execute( OutputDevice* pOut )
{
	if( mbSet )
		pOut->SetFillColor( maColor );
	else
		pOut->SetFillColor();
}

// ------------------------------------------------------------------------

MetaAction* MetaFillColorAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaFillColorAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

sal_Bool MetaFillColorAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maColor == ((MetaFillColorAction&)rMetaAction).maColor ) &&
		   ( mbSet == ((MetaFillColorAction&)rMetaAction).mbSet );
}

// ------------------------------------------------------------------------

void MetaFillColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	maColor.Write( rOStm, sal_True );
	rOStm << mbSet;
}

// ------------------------------------------------------------------------

void MetaFillColorAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	maColor.Read( rIStm, sal_True );
	rIStm >> mbSet;
}

// ========================================================================

IMPL_META_ACTION( TextColor, META_TEXTCOLOR_ACTION )

// ------------------------------------------------------------------------

MetaTextColorAction::MetaTextColorAction( const Color& rColor ) :
	MetaAction	( META_TEXTCOLOR_ACTION ),
	maColor 	( rColor )
{
}

// ------------------------------------------------------------------------

void MetaTextColorAction::Execute( OutputDevice* pOut )
{
	pOut->SetTextColor( maColor );
}

// ------------------------------------------------------------------------

MetaAction* MetaTextColorAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaTextColorAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

sal_Bool MetaTextColorAction::Compare( const MetaAction& rMetaAction ) const
{
	return maColor == ((MetaTextColorAction&)rMetaAction).maColor;
}

// ------------------------------------------------------------------------

void MetaTextColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	maColor.Write( rOStm, sal_True );
}

// ------------------------------------------------------------------------

void MetaTextColorAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	maColor.Read( rIStm, sal_True );
}

// ========================================================================

IMPL_META_ACTION( TextFillColor, META_TEXTFILLCOLOR_ACTION )

// ------------------------------------------------------------------------

MetaTextFillColorAction::MetaTextFillColorAction( const Color& rColor, sal_Bool bSet ) :
	MetaAction	( META_TEXTFILLCOLOR_ACTION ),
	maColor 	( rColor ),
	mbSet		( bSet )
{
}

// ------------------------------------------------------------------------

void MetaTextFillColorAction::Execute( OutputDevice* pOut )
{
	if( mbSet )
		pOut->SetTextFillColor( maColor );
	else
		pOut->SetTextFillColor();
}

// ------------------------------------------------------------------------

MetaAction* MetaTextFillColorAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaTextFillColorAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

sal_Bool MetaTextFillColorAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maColor == ((MetaTextFillColorAction&)rMetaAction).maColor ) &&
		   ( mbSet == ((MetaTextFillColorAction&)rMetaAction).mbSet );
}

// ------------------------------------------------------------------------

void MetaTextFillColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	maColor.Write( rOStm, sal_True );
	rOStm << mbSet;
}

// ------------------------------------------------------------------------

void MetaTextFillColorAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	maColor.Read( rIStm, sal_True );
	rIStm >> mbSet;
}

// ========================================================================

IMPL_META_ACTION( TextLineColor, META_TEXTLINECOLOR_ACTION )

// ------------------------------------------------------------------------

MetaTextLineColorAction::MetaTextLineColorAction( const Color& rColor, sal_Bool bSet ) :
	MetaAction	( META_TEXTLINECOLOR_ACTION ),
	maColor 	( rColor ),
	mbSet		( bSet )
{
}

// ------------------------------------------------------------------------

void MetaTextLineColorAction::Execute( OutputDevice* pOut )
{
	if( mbSet )
		pOut->SetTextLineColor( maColor );
	else
		pOut->SetTextLineColor();
}

// ------------------------------------------------------------------------

MetaAction* MetaTextLineColorAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaTextLineColorAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

sal_Bool MetaTextLineColorAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maColor == ((MetaTextLineColorAction&)rMetaAction).maColor ) &&
		   ( mbSet == ((MetaTextLineColorAction&)rMetaAction).mbSet );
}

// ------------------------------------------------------------------------

void MetaTextLineColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	maColor.Write( rOStm, sal_True );
	rOStm << mbSet;
}

// ------------------------------------------------------------------------

void MetaTextLineColorAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	maColor.Read( rIStm, sal_True );
	rIStm >> mbSet;
}

// ========================================================================

IMPL_META_ACTION( OverlineColor, META_OVERLINECOLOR_ACTION )

// ------------------------------------------------------------------------

MetaOverlineColorAction::MetaOverlineColorAction( const Color& rColor, sal_Bool bSet ) :
	MetaAction	( META_OVERLINECOLOR_ACTION ),
	maColor 	( rColor ),
	mbSet		( bSet )
{
}

// ------------------------------------------------------------------------

void MetaOverlineColorAction::Execute( OutputDevice* pOut )
{
	if( mbSet )
		pOut->SetOverlineColor( maColor );
	else
		pOut->SetOverlineColor();
}

// ------------------------------------------------------------------------

MetaAction* MetaOverlineColorAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaOverlineColorAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

sal_Bool MetaOverlineColorAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maColor == ((MetaOverlineColorAction&)rMetaAction).maColor ) &&
		   ( mbSet == ((MetaOverlineColorAction&)rMetaAction).mbSet );
}

// ------------------------------------------------------------------------

void MetaOverlineColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	maColor.Write( rOStm, sal_True );
	rOStm << mbSet;
}

// ------------------------------------------------------------------------

void MetaOverlineColorAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	maColor.Read( rIStm, sal_True );
	rIStm >> mbSet;
}

// ========================================================================

IMPL_META_ACTION( TextAlign, META_TEXTALIGN_ACTION )

// ------------------------------------------------------------------------

MetaTextAlignAction::MetaTextAlignAction( TextAlign aAlign ) :
	MetaAction	( META_TEXTALIGN_ACTION ),
	maAlign 	( aAlign )
{
}

// ------------------------------------------------------------------------

void MetaTextAlignAction::Execute( OutputDevice* pOut )
{
	pOut->SetTextAlign( maAlign );
}

// ------------------------------------------------------------------------

MetaAction* MetaTextAlignAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaTextAlignAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

sal_Bool MetaTextAlignAction::Compare( const MetaAction& rMetaAction ) const
{
	return maAlign == ((MetaTextAlignAction&)rMetaAction).maAlign;
}

// ------------------------------------------------------------------------

void MetaTextAlignAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << (sal_uInt16) maAlign;
}

// ------------------------------------------------------------------------

void MetaTextAlignAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	sal_uInt16 nTmp16;

	COMPAT( rIStm );
	rIStm >> nTmp16; maAlign = (TextAlign) nTmp16;
}

// ========================================================================

IMPL_META_ACTION( MapMode, META_MAPMODE_ACTION )

// ------------------------------------------------------------------------

MetaMapModeAction::MetaMapModeAction( const MapMode& rMapMode ) :
	MetaAction	( META_MAPMODE_ACTION ),
	maMapMode	( rMapMode )
{
}

// ------------------------------------------------------------------------

void MetaMapModeAction::Execute( OutputDevice* pOut )
{
	pOut->SetMapMode( maMapMode );
}

// ------------------------------------------------------------------------

MetaAction* MetaMapModeAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaMapModeAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaMapModeAction::Scale( double fScaleX, double fScaleY )
{
	Point aPoint( maMapMode.GetOrigin() );

	ImplScalePoint( aPoint, fScaleX, fScaleY );
	maMapMode.SetOrigin( aPoint );
}

// ------------------------------------------------------------------------

sal_Bool MetaMapModeAction::Compare( const MetaAction& rMetaAction ) const
{
	return maMapMode == ((MetaMapModeAction&)rMetaAction).maMapMode;
}

// ------------------------------------------------------------------------

void MetaMapModeAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maMapMode;
}

// ------------------------------------------------------------------------

void MetaMapModeAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maMapMode;
}

// ========================================================================

IMPL_META_ACTION( Font, META_FONT_ACTION )

// ------------------------------------------------------------------------

MetaFontAction::MetaFontAction( const Font& rFont ) :
	MetaAction	( META_FONT_ACTION ),
	maFont		( rFont )
{
    // #96876: because RTL_TEXTENCODING_SYMBOL is often set at the StarSymbol font,
    // we change the textencoding to RTL_TEXTENCODING_UNICODE here, which seems
    // to be the right way; changing the textencoding at other sources
    // is too dangerous at the moment
    if( ( ( maFont.GetName().SearchAscii( "StarSymbol" ) != STRING_NOTFOUND )
       || ( maFont.GetName().SearchAscii( "OpenSymbol" ) != STRING_NOTFOUND ) )
     && ( maFont.GetCharSet() != RTL_TEXTENCODING_UNICODE ) )
    {
        maFont.SetCharSet( RTL_TEXTENCODING_UNICODE );
    }
}

// ------------------------------------------------------------------------

void MetaFontAction::Execute( OutputDevice* pOut )
{
	pOut->SetFont( maFont );
}

// ------------------------------------------------------------------------

MetaAction* MetaFontAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaFontAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaFontAction::Scale( double fScaleX, double fScaleY )
{
	const Size aSize(
        FRound(maFont.GetSize().Width() * fabs(fScaleX)),
        FRound(maFont.GetSize().Height() * fabs(fScaleY)));
	maFont.SetSize( aSize );
}

// ------------------------------------------------------------------------

sal_Bool MetaFontAction::Compare( const MetaAction& rMetaAction ) const
{
	return maFont == ((MetaFontAction&)rMetaAction).maFont;
}

// ------------------------------------------------------------------------

void MetaFontAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maFont;
	pData->meActualCharSet = maFont.GetCharSet();
	if ( pData->meActualCharSet == RTL_TEXTENCODING_DONTKNOW )
		pData->meActualCharSet = gsl_getSystemTextEncoding();
}

// ------------------------------------------------------------------------

void MetaFontAction::Read( SvStream& rIStm, ImplMetaReadData* pData )
{
	COMPAT( rIStm );
	rIStm >> maFont;
	pData->meActualCharSet = maFont.GetCharSet();
	if ( pData->meActualCharSet == RTL_TEXTENCODING_DONTKNOW )
		pData->meActualCharSet = gsl_getSystemTextEncoding();
}

// ========================================================================

IMPL_META_ACTION( Push, META_PUSH_ACTION )

// ------------------------------------------------------------------------

MetaPushAction::MetaPushAction( sal_uInt16 nFlags ) :
	MetaAction	( META_PUSH_ACTION ),
	mnFlags 	( nFlags )
{
}

// ------------------------------------------------------------------------

void MetaPushAction::Execute( OutputDevice* pOut )
{
	pOut->Push( mnFlags );
}

// ------------------------------------------------------------------------

MetaAction* MetaPushAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaPushAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

sal_Bool MetaPushAction::Compare( const MetaAction& rMetaAction ) const
{
	return mnFlags == ((MetaPushAction&)rMetaAction).mnFlags;
}

// ------------------------------------------------------------------------

void MetaPushAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << mnFlags;
}

// ------------------------------------------------------------------------

void MetaPushAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> mnFlags;
}

// ========================================================================

IMPL_META_ACTION( Pop, META_POP_ACTION )

// ------------------------------------------------------------------------

void MetaPopAction::Execute( OutputDevice* pOut )
{
	pOut->Pop();
}

// ------------------------------------------------------------------------

MetaAction* MetaPopAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaPopAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaPopAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
}

// ------------------------------------------------------------------------

void MetaPopAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
}

// ========================================================================

IMPL_META_ACTION( RasterOp, META_RASTEROP_ACTION )

// ------------------------------------------------------------------------

MetaRasterOpAction::MetaRasterOpAction( RasterOp eRasterOp ) :
	MetaAction	( META_RASTEROP_ACTION ),
	meRasterOp	( eRasterOp )
{
}

// ------------------------------------------------------------------------

void MetaRasterOpAction::Execute( OutputDevice* pOut )
{
	pOut->SetRasterOp( meRasterOp );
}

// ------------------------------------------------------------------------

MetaAction* MetaRasterOpAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaRasterOpAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

sal_Bool MetaRasterOpAction::Compare( const MetaAction& rMetaAction ) const
{
	return meRasterOp == ((MetaRasterOpAction&)rMetaAction).meRasterOp;
}

// ------------------------------------------------------------------------

void MetaRasterOpAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << (sal_uInt16) meRasterOp;
}

// ------------------------------------------------------------------------

void MetaRasterOpAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	sal_uInt16 nTmp16;

	COMPAT( rIStm );
	rIStm >> nTmp16; meRasterOp = (RasterOp) nTmp16;
}

// ========================================================================

IMPL_META_ACTION( Transparent, META_TRANSPARENT_ACTION )

// ------------------------------------------------------------------------

MetaTransparentAction::MetaTransparentAction( const PolyPolygon& rPolyPoly, sal_uInt16 nTransPercent ) :
	MetaAction		( META_TRANSPARENT_ACTION ),
	maPolyPoly		( rPolyPoly ),
	mnTransPercent	( nTransPercent )
{
}

// ------------------------------------------------------------------------

void MetaTransparentAction::Execute( OutputDevice* pOut )
{
	pOut->DrawTransparent( maPolyPoly, mnTransPercent );
}

// ------------------------------------------------------------------------

MetaAction* MetaTransparentAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaTransparentAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaTransparentAction::Move( long nHorzMove, long nVertMove )
{
	maPolyPoly.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaTransparentAction::Scale( double fScaleX, double fScaleY )
{
	for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ )
		ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY );
}

// ------------------------------------------------------------------------

sal_Bool MetaTransparentAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maPolyPoly == ((MetaTransparentAction&)rMetaAction).maPolyPoly ) &&
		   ( mnTransPercent == ((MetaTransparentAction&)rMetaAction).mnTransPercent );
}

// ------------------------------------------------------------------------

void MetaTransparentAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );

    // #i105373# The PolyPolygon in this action may be a curve; this
    // was ignored until now what is an error. To make older office
    // versions work with MetaFiles, i opt for applying AdaptiveSubdivide
    // to the PolyPoylgon.
    // The alternative would be to really write the curve information
    // like in MetaPolyPolygonAction::Write (where someone extended it
    // correctly, but not here :-( ).
    // The golden solution would be to combine both, but i think it's
    // not necessary; a good subdivision will be sufficient.
    PolyPolygon aNoCurvePolyPolygon;
    maPolyPoly.AdaptiveSubdivide(aNoCurvePolyPolygon);

    rOStm << aNoCurvePolyPolygon;
	rOStm << mnTransPercent;
}

// ------------------------------------------------------------------------

void MetaTransparentAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maPolyPoly;
	rIStm >> mnTransPercent;
}

// ========================================================================

IMPL_META_ACTION( FloatTransparent, META_FLOATTRANSPARENT_ACTION )

// ------------------------------------------------------------------------

MetaFloatTransparentAction::MetaFloatTransparentAction( const GDIMetaFile& rMtf, const Point& rPos,
														const Size& rSize, const Gradient& rGradient ) :
	MetaAction		( META_FLOATTRANSPARENT_ACTION ),
	maMtf			( rMtf ),
	maPoint 		( rPos ),
	maSize			( rSize ),
	maGradient		( rGradient )
{
}

// ------------------------------------------------------------------------

void MetaFloatTransparentAction::Execute( OutputDevice* pOut )
{
	pOut->DrawTransparent( maMtf, maPoint, maSize, maGradient );
}

// ------------------------------------------------------------------------

MetaAction* MetaFloatTransparentAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaFloatTransparentAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaFloatTransparentAction::Move( long nHorzMove, long nVertMove )
{
	maPoint.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaFloatTransparentAction::Scale( double fScaleX, double fScaleY )
{
    Rectangle aRectangle(maPoint, maSize);
	ImplScaleRect( aRectangle, fScaleX, fScaleY );
    maPoint = aRectangle.TopLeft();
    maSize = aRectangle.GetSize();
}

// ------------------------------------------------------------------------

sal_Bool MetaFloatTransparentAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maMtf == ((MetaFloatTransparentAction&)rMetaAction).maMtf ) &&
		   ( maPoint == ((MetaFloatTransparentAction&)rMetaAction).maPoint ) &&
		   ( maSize == ((MetaFloatTransparentAction&)rMetaAction).maSize ) &&
		   ( maGradient == ((MetaFloatTransparentAction&)rMetaAction).maGradient );
}

// ------------------------------------------------------------------------

void MetaFloatTransparentAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );

	maMtf.Write( rOStm );
	rOStm << maPoint << maSize << maGradient;
}

// ------------------------------------------------------------------------

void MetaFloatTransparentAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maMtf >> maPoint >> maSize >> maGradient;
}

// ========================================================================

IMPL_META_ACTION( EPS, META_EPS_ACTION )

// ------------------------------------------------------------------------

MetaEPSAction::MetaEPSAction( const Point& rPoint, const Size& rSize,
							  const GfxLink& rGfxLink, const GDIMetaFile& rSubst ) :
	MetaAction	( META_EPS_ACTION ),
	maGfxLink	( rGfxLink ),
	maSubst 	( rSubst ),
	maPoint 	( rPoint ),
	maSize		( rSize )
{
}

// ------------------------------------------------------------------------

void MetaEPSAction::Execute( OutputDevice* pOut )
{
	pOut->DrawEPS( maPoint, maSize, maGfxLink, &maSubst );
}

// ------------------------------------------------------------------------

MetaAction* MetaEPSAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaEPSAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

void MetaEPSAction::Move( long nHorzMove, long nVertMove )
{
	maPoint.Move( nHorzMove, nVertMove );
}

// ------------------------------------------------------------------------

void MetaEPSAction::Scale( double fScaleX, double fScaleY )
{
    Rectangle aRectangle(maPoint, maSize);
	ImplScaleRect( aRectangle, fScaleX, fScaleY );
    maPoint = aRectangle.TopLeft();
    maSize = aRectangle.GetSize();
}

// ------------------------------------------------------------------------

sal_Bool MetaEPSAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maGfxLink.IsEqual(((MetaEPSAction&)rMetaAction).maGfxLink )) &&
		   ( maSubst == ((MetaEPSAction&)rMetaAction).maSubst ) &&
		   ( maPoint == ((MetaEPSAction&)rMetaAction).maPoint ) &&
		   ( maSize == ((MetaEPSAction&)rMetaAction).maSize );
}

// ------------------------------------------------------------------------

void MetaEPSAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maGfxLink;
	rOStm << maPoint;
	rOStm << maSize;
	maSubst.Write( rOStm );
}

// ------------------------------------------------------------------------

void MetaEPSAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maGfxLink;
	rIStm >> maPoint;
	rIStm >> maSize;
	rIStm >> maSubst;
}

// ========================================================================

IMPL_META_ACTION( RefPoint, META_REFPOINT_ACTION )

// ------------------------------------------------------------------------

MetaRefPointAction::MetaRefPointAction( const Point& rRefPoint, sal_Bool bSet ) :
	MetaAction	( META_REFPOINT_ACTION ),
	maRefPoint	( rRefPoint ),
	mbSet		( bSet )
{
}

// ------------------------------------------------------------------------

void MetaRefPointAction::Execute( OutputDevice* pOut )
{
	if( mbSet )
		pOut->SetRefPoint( maRefPoint );
	else
		pOut->SetRefPoint();
}

// ------------------------------------------------------------------------

MetaAction* MetaRefPointAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaRefPointAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

sal_Bool MetaRefPointAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maRefPoint == ((MetaRefPointAction&)rMetaAction).maRefPoint ) &&
		   ( mbSet == ((MetaRefPointAction&)rMetaAction).mbSet );
}

// ------------------------------------------------------------------------

void MetaRefPointAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maRefPoint << mbSet;
}

// ------------------------------------------------------------------------

void MetaRefPointAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maRefPoint >> mbSet;
}

// ========================================================================

MetaCommentAction::MetaCommentAction( sal_Int32 nValue ) :
	MetaAction	( META_COMMENT_ACTION ),
	mnValue 	( nValue )
{
	ImplInitDynamicData( NULL, 0UL );
}

// ------------------------------------------------------------------------

MetaCommentAction::MetaCommentAction( const MetaCommentAction& rAct ) :
	MetaAction	( META_COMMENT_ACTION ),
	maComment	( rAct.maComment ),
	mnValue 	( rAct.mnValue )
{
	ImplInitDynamicData( rAct.mpData, rAct.mnDataSize );
}

// ------------------------------------------------------------------------

MetaCommentAction::MetaCommentAction( const ByteString& rComment, sal_Int32 nValue, const sal_uInt8* pData, sal_uInt32 nDataSize ) :
	MetaAction	( META_COMMENT_ACTION ),
	maComment	( rComment ),
	mnValue 	( nValue )
{
	ImplInitDynamicData( pData, nDataSize );
}

// ------------------------------------------------------------------------

MetaCommentAction::MetaCommentAction( const sal_uInt8* pData, sal_uInt32 nDataSize ) :
	MetaAction	( META_COMMENT_ACTION ),
	mnValue 	( 0L )
{
	ImplInitDynamicData( pData, nDataSize );
}

// ------------------------------------------------------------------------

MetaCommentAction::~MetaCommentAction()
{
	if ( mpData )
		delete[] mpData;
}

// ------------------------------------------------------------------------

void MetaCommentAction::ImplInitDynamicData( const sal_uInt8* pData, sal_uInt32 nDataSize )
{
	if ( nDataSize && pData )
	{
		mnDataSize = nDataSize, mpData = new sal_uInt8[ mnDataSize ];
		memcpy( mpData, pData, mnDataSize );
	}
	else
	{
		mnDataSize = 0;
		mpData = NULL;
	}
}

// ------------------------------------------------------------------------

void MetaCommentAction::Execute( OutputDevice* pOut )
{
	if ( pOut->GetConnectMetaFile() )
    {
        Duplicate();
		pOut->GetConnectMetaFile()->AddAction( this );
    }
}

// ------------------------------------------------------------------------

MetaAction* MetaCommentAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaCommentAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

void MetaCommentAction::Move( long nXMove, long nYMove )
{
	if ( nXMove || nYMove )
	{
		if ( mnDataSize && mpData )
		{
			sal_Bool bPathStroke = maComment.Equals( "XPATHSTROKE_SEQ_BEGIN" );
			if ( bPathStroke || maComment.Equals( "XPATHFILL_SEQ_BEGIN" ) )
			{
				SvMemoryStream	aMemStm( (void*)mpData, mnDataSize, STREAM_READ );
				SvMemoryStream	aDest;
				if ( bPathStroke )
				{
					SvtGraphicStroke aStroke;
					aMemStm >> aStroke;
					Polygon aPath;
					aStroke.getPath( aPath );
					aPath.Move( nXMove, nYMove );
					aStroke.setPath( aPath );
					aDest << aStroke;
				}
				else
				{
					SvtGraphicFill aFill;
					aMemStm >> aFill;
					PolyPolygon aPath;
					aFill.getPath( aPath );
					aPath.Move( nXMove, nYMove );
					aFill.setPath( aPath );
					aDest << aFill;
				}
				delete[] mpData;
				ImplInitDynamicData( static_cast<const sal_uInt8*>( aDest.GetData() ), aDest.Tell() );
			}
		}
	}
}

// ------------------------------------------------------------------------
// SJ: 25.07.06 #i56656# we are not able to mirrorcertain kind of
// comments properly, especially the XPATHSTROKE and XPATHFILL lead to
// problems, so it is better to remove these comments when mirroring
void MetaCommentAction::Scale( double fXScale, double fYScale )
{
	if ( ( fXScale != 1.0 ) || ( fYScale != 1.0 ) )
	{
		if ( mnDataSize && mpData )
		{
			sal_Bool bPathStroke = maComment.Equals( "XPATHSTROKE_SEQ_BEGIN" );
			if ( bPathStroke || maComment.Equals( "XPATHFILL_SEQ_BEGIN" ) )
			{
				SvMemoryStream	aMemStm( (void*)mpData, mnDataSize, STREAM_READ );
				SvMemoryStream	aDest;
				if ( bPathStroke )
				{
					SvtGraphicStroke aStroke;
					aMemStm >> aStroke;
					Polygon aPath;
					aStroke.getPath( aPath );
					aPath.Scale( fXScale, fYScale );
					aStroke.setPath( aPath );
					aDest << aStroke;
				}
				else
				{
					SvtGraphicFill aFill;
					aMemStm >> aFill;
					PolyPolygon aPath;
					aFill.getPath( aPath );
					aPath.Scale( fXScale, fYScale );
					aFill.setPath( aPath );
					aDest << aFill;
				}
				delete[] mpData;
				ImplInitDynamicData( static_cast<const sal_uInt8*>( aDest.GetData() ), aDest.Tell() );
			}
		}
	}
}

// ------------------------------------------------------------------------

sal_Bool MetaCommentAction::Compare( const MetaAction& rMetaAction ) const
{
	return ( maComment == ((MetaCommentAction&)rMetaAction).maComment ) &&
		   ( mnValue == ((MetaCommentAction&)rMetaAction).mnValue ) &&
		   ( mnDataSize == ((MetaCommentAction&)rMetaAction).mnDataSize ) &&
		   ( memcmp( mpData, ((MetaCommentAction&)rMetaAction).mpData, mnDataSize ) == 0 );
}

// ------------------------------------------------------------------------

void MetaCommentAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << maComment << mnValue << mnDataSize;

	if ( mnDataSize )
		rOStm.Write( mpData, mnDataSize );
}

// ------------------------------------------------------------------------

void MetaCommentAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> maComment >> mnValue >> mnDataSize;

	if( mpData )
		delete[] mpData;

	if( mnDataSize )
	{
		mpData = new sal_uInt8[ mnDataSize ];
		rIStm.Read( mpData, mnDataSize );
	}
	else
		mpData = NULL;
}

// ========================================================================

IMPL_META_ACTION( LayoutMode, META_LAYOUTMODE_ACTION )

// ------------------------------------------------------------------------

MetaLayoutModeAction::MetaLayoutModeAction( sal_uInt32 nLayoutMode ) :
	MetaAction	( META_LAYOUTMODE_ACTION ),
	mnLayoutMode( nLayoutMode )
{
}

// ------------------------------------------------------------------------

void MetaLayoutModeAction::Execute( OutputDevice* pOut )
{
	pOut->SetLayoutMode( mnLayoutMode );
}

// ------------------------------------------------------------------------

MetaAction* MetaLayoutModeAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaLayoutModeAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

sal_Bool MetaLayoutModeAction::Compare( const MetaAction& rMetaAction ) const
{
	return mnLayoutMode == ((MetaLayoutModeAction&)rMetaAction).mnLayoutMode;
}

// ------------------------------------------------------------------------

void MetaLayoutModeAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << mnLayoutMode;
}

// ------------------------------------------------------------------------

void MetaLayoutModeAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> mnLayoutMode;
}

// ========================================================================

IMPL_META_ACTION( TextLanguage, META_TEXTLANGUAGE_ACTION )

// ------------------------------------------------------------------------

MetaTextLanguageAction::MetaTextLanguageAction( LanguageType eTextLanguage ) :
	MetaAction	( META_TEXTLANGUAGE_ACTION ),
	meTextLanguage( eTextLanguage )
{
}

// ------------------------------------------------------------------------

void MetaTextLanguageAction::Execute( OutputDevice* pOut )
{
	pOut->SetDigitLanguage( meTextLanguage );
}

// ------------------------------------------------------------------------

MetaAction* MetaTextLanguageAction::Clone()
{
	MetaAction* pClone = (MetaAction*) new MetaTextLanguageAction( *this );
	pClone->ResetRefCount();
	return pClone;
}

// ------------------------------------------------------------------------

sal_Bool MetaTextLanguageAction::Compare( const MetaAction& rMetaAction ) const
{
	return meTextLanguage == ((MetaTextLanguageAction&)rMetaAction).meTextLanguage;
}

// ------------------------------------------------------------------------

void MetaTextLanguageAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
{
	WRITE_BASE_COMPAT( rOStm, 1, pData );
	rOStm << meTextLanguage;
}

// ------------------------------------------------------------------------

void MetaTextLanguageAction::Read( SvStream& rIStm, ImplMetaReadData* )
{
	COMPAT( rIStm );
	rIStm >> meTextLanguage;
}

// eof