// Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <fbs.h>

#include <hal.h>

#include "WMFCodec.h"

/*

Not supported:

0) Misc

	// 0x0105 - SETRELABS

	// 0x0231 - SETMAPPERFLAGS

	// 0x0419 - FLOODFILL

	// 0x0548 - EXTFLOODFILL

	// 0x0626 - ESCAPE

	// 0x0830 - CHORD

1) Blitting

	// 0x0107 - SETSTRETCHBLTMODE

	// 0x0922 - BITBLT

	// 0x0940 - DIBBITBLT

	// 0x0b23 - STRETCHBLT

	// 0x0d33 - SETDIBTODEV

2) Clipping

	// 0x0220 - OFFSETCLIPRGN

	// 0x0415 - EXCLUDECLIPRECT

3) Palettes

	// 0x0035 - REALIZEPALETTE

	// 0x0037 - SETPALENTRIES

	// 0x00f7 - CREATEPALETTE

	// 0x0139 - RESIZEPALETTE

	// 0x0234 - SELECTPALETTE

	// 0x0436 - ANIMATEPALETTE

*/

const TInt KFontNormalWeightLimit = 550;	// Halfway between FW_NORMAL and FW_BOLD

const TInt KFontFixedPitch = 1;				// FIXED_PITCH

const TInt KFontFamilyRoman = 1;			// FF_ROMAN

const TInt KFontFamilySwiss = 2;			// FF_SWISS

const TInt KFontFamilyMono = 3;				// FF_MODERN

const TInt KFontFamilyScript = 4;			// FF_SCRIPT

const TInt KFontFamilyDecorative = 5;		// FF_DECORATIVE

const TInt KExtTextOutFlagClipped = 4;		// ETO_CLIPPED

//const TInt KTextAlignFlagNoUpdateCP = 0;	// EABI warning removal

//const TInt KTextAlignFlagUpdateCP = 1; // Not supported		// EABI warning removal

//const TInt KTextAlignFlagLeft = 0;		// EABI warning removal

const TInt KTextAlignFlagRight = 2;

const TInt KTextAlignFlagCenter = 6;

//const TInt KTextAlignFlagTop = 0;			// EABI warning removal

const TInt KTextAlignFlagBottom = 8;

const TInt KTextAlignFlagBaseline = 24;

const TInt KTextAlignMaskHorz = 6;

const TInt KTextAlignMaskVert = 24;

const TUint KMaxProcessTime = 175000; //limit DoProcessL() to 175ms for liveliness

// Wrapper class for drawing to the bitmap.

// All drawing operations go through this class.

CFbsBitGcWrapper* CFbsBitGcWrapper::NewL(CFbsDevice& aDevice, CFbsBitGcWrapper* aGc)

	{

	CFbsBitGcWrapper* self = new(ELeave) CFbsBitGcWrapper;

	CleanupStack::PushL(self);

	self->ConstructL(aDevice, aGc);

	CleanupStack::Pop(self);

	return self;

	}

CFbsBitGcWrapper::CFbsBitGcWrapper():

	iBrushColor(KRgbWhite),

	iBrushStyle(CGraphicsContext::ENullBrush),

	iPenColor(KRgbBlack),

	iPenStyle(CGraphicsContext::ESolidPen),

	iPenSize(1,1),

	iTextColor(KRgbBlack),

	iBackgroundColor(KRgbWhite)

	{}

void CFbsBitGcWrapper::ConstructL(CFbsDevice& aDevice, CFbsBitGcWrapper* aGc)

	{

	User::LeaveIfError(aDevice.CreateContext(iGc));

	User::LeaveIfError(aDevice.CreateContext(iPolygonGc));

	if (aGc)

		{

		iGc->CopySettings(*(aGc->iGc));

		iGc->CancelClippingRegion();

		iPolygonGc->CopySettings(*(aGc->iGc));

		iPolygonGc->CancelClippingRegion();

		iBrushColor = aGc->iBrushColor;

		iBrushStyle = aGc->iBrushStyle;

		iPenColor = aGc->iPenColor;

		iPenStyle = aGc->iPenStyle;

		iPenSize = aGc->iPenSize;

		iTextColor = aGc->iTextColor;

		iBackgroundColor = aGc->iBackgroundColor;

		iPatternBrush = aGc->iPatternBrush;

		}

	}

CFbsBitGcWrapper::~CFbsBitGcWrapper()

	{

	delete iGc;

	delete iPolygonGc;

	}

void CFbsBitGcWrapper::SetPen(const CPen& aPen)

	{

	iPenStyle = aPen.iStyle;

	iPenSize = aPen.iSize;

	iPenColor = aPen.iColor;

	iGc->SetPenStyle(iPenStyle);

	iGc->SetPenSize(iPenSize);

	iGc->SetPenColor(iPenColor);

	}

void CFbsBitGcWrapper::SetBrush(CBrush& aBrush)

	{

	iBrushColor = aBrush.iColor;

	iBrushStyle = aBrush.iStyle;

	iPatternBrush = (iBrushStyle == CGraphicsContext::EPatternedBrush) ? static_cast<CPatternBrush*> (&aBrush) : NULL;

	iGc->SetBrushStyle(iBrushStyle);

	iGc->SetBrushColor(iBrushColor);

	}

void CFbsBitGcWrapper::RestorePenAndBrush()

	{

	iGc->SetPenStyle(iPenStyle);

	iGc->SetPenSize(iPenSize);

	iGc->SetPenColor(iPenColor);

	iGc->SetBrushStyle(iBrushStyle);

	iGc->SetBrushColor(iBrushColor);

	}

void CFbsBitGcWrapper::DrawPolygonL(const TPoint* aPointList,TInt aNumPoints,CGraphicsContext::TFillRule aFillRule)

	{

	RealizeBrush();

	if (iPenStyle == CGraphicsContext::ENullPen || iPenSize.iWidth == 0)

		{

		if (iBrushStyle != CGraphicsContext::ENullBrush)

			{

			iPolygonGc->CopySettings(*iGc);

			iPolygonGc->CancelClippingRegion();

			iPolygonGc->SetPenStyle(CGraphicsContext::ESolidPen);

			iPolygonGc->SetPenSize(TSize(1,1));

			iPolygonGc->SetPenColor(iBrushColor);

			User::LeaveIfError(iPolygonGc->DrawPolygon(aPointList,aNumPoints,aFillRule));

			}

		}

	else

		User::LeaveIfError(iGc->DrawPolygon(aPointList,aNumPoints,aFillRule));

	}

const CFbsFont* CFbsBitGcWrapper::CurrentFont()

	{

	return iCurrentFont;

	}

void CFbsBitGcWrapper::Clear()

	{

	iGc->Clear();

	}

void CFbsBitGcWrapper::SetUnderlineStyle(TFontUnderline aUnderlineStyle)

	{

	iGc->SetUnderlineStyle(aUnderlineStyle);

	}

void CFbsBitGcWrapper::SetStrikethroughStyle(TFontStrikethrough aStrikethroughStyle)

	{

	iGc->SetStrikethroughStyle(aStrikethroughStyle);

	}

void CFbsBitGcWrapper::UseFont(const CFbsFont* aFont)

	{

	iGc->UseFont(aFont);

	iCurrentFont = aFont;

	}

void CFbsBitGcWrapper::SetClippingRegion(const TRegion* aRegion)

	{

	iGc->SetClippingRegion(aRegion);

	}

void CFbsBitGcWrapper::SetCharJustification(TInt aExcessWidth, TInt aNumGaps)

	{

	iGc->SetCharJustification(aExcessWidth, aNumGaps);

	}

void CFbsBitGcWrapper::SetWordJustification(TInt aExcessWidth, TInt aNumChars)

	{

	iGc->SetWordJustification(aExcessWidth, aNumChars);

	}

void CFbsBitGcWrapper::DrawLineTo(const TPoint& aPoint)

	{

	iGc->DrawLineTo(aPoint);

	}

void CFbsBitGcWrapper::MoveTo(const TPoint& aPoint)

	{

	iGc->MoveTo(aPoint);

	}

void CFbsBitGcWrapper::DrawPolyLine(const TPoint* aPointList, TInt aNumPoints)

	{

	iGc->DrawPolyLine(aPointList, aNumPoints);

	}

void CFbsBitGcWrapper::DrawEllipse(const TRect& aRect)

	{

	RealizeBrush();

	iGc->DrawEllipse(aRect);

	}

void CFbsBitGcWrapper::DrawRect(const TRect& aRect)

	{

	RealizeBrush();

	iGc->DrawRect(aRect);

	}

void CFbsBitGcWrapper::DrawRoundRect(const TRect& aRect, const TSize& aEllipse)

	{

	RealizeBrush();

	iGc->DrawRoundRect(aRect, aEllipse);

	}

void CFbsBitGcWrapper::SetPenStyle(CGraphicsContext::TPenStyle aPenStyle)

	{

	iGc->SetPenStyle(aPenStyle);

	}

void CFbsBitGcWrapper::SetBrushStyle(CGraphicsContext::TBrushStyle aBrushStyle)

	{

	iGc->SetBrushStyle(aBrushStyle);

	}

void CFbsBitGcWrapper::SetBrushColor(const TRgb& aColor)

	{

	iGc->SetBrushColor(aColor);

	}

void CFbsBitGcWrapper::SetDrawMode(CGraphicsContext::TDrawMode aDrawMode)

	{

	iGc->SetDrawMode(aDrawMode);

	}

void CFbsBitGcWrapper::SetPenColor(const TRgb& aColor)

	{

	iGc->SetPenColor(aColor);

	}

void CFbsBitGcWrapper::SetTextPenColor()

	{

	iGc->SetPenColor(iTextColor);

	}

void CFbsBitGcWrapper::Plot(const TPoint& aPoint)

	{

	iGc->Plot(aPoint);

	}

void CFbsBitGcWrapper::SetPenSize(const TSize& aSize)

	{

	iGc->SetPenSize(aSize);

	}

void CFbsBitGcWrapper::DrawArc(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)

	{

	iGc->DrawArc(aRect, aStart, aEnd);

	}

void CFbsBitGcWrapper::DrawPie(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)

	{

	RealizeBrush();

	iGc->DrawPie(aRect, aStart, aEnd);

	}

void CFbsBitGcWrapper::DrawBitmap(const TRect& aDestRect, const CFbsBitmap* aSource, const TRect& aSourceRect)

	{

	iGc->DrawBitmap(aDestRect, aSource, aSourceRect);

	}

void CFbsBitGcWrapper::DrawText(const TDesC& aText,const TPoint& aPosition)

	{

	iGc->DrawText(aText, aPosition);

	}

void CFbsBitGcWrapper::UseBrushPattern(const CFbsBitmap* aPatternBitmap)

	{

	iGc->UseBrushPattern(aPatternBitmap);

	}

void CFbsBitGcWrapper::SetBackgroundColor(TRgb aBackgroundColor)

	{

	iBackgroundColor = aBackgroundColor;

	}

void CFbsBitGcWrapper::SetTextColor(TRgb aTextColor)

	{

	iTextColor = aTextColor;

	}

void CFbsBitGcWrapper::RealizeBrush()

	{

	if (iPatternBrush)

		iPatternBrush->RealizeBrush(iTextColor, iBackgroundColor);

	}

// Wrapper class for drawing to the bitmap and mask.

// All drawing operations are performed through this class when mask generation is requested.

CFbsBitGcMaskWrapper* CFbsBitGcMaskWrapper::NewL(CFbsDevice& aDevice, CFbsDevice& aMaskDevice, CFbsBitGcMaskWrapper* aGc)

	{

	CFbsBitGcMaskWrapper* self = new(ELeave) CFbsBitGcMaskWrapper;

	CleanupStack::PushL(self);

	self->ConstructL(aDevice, aMaskDevice, aGc);

	CleanupStack::Pop(self);

	return self;

	}

CFbsBitGcMaskWrapper::CFbsBitGcMaskWrapper()

	{

	}

void CFbsBitGcMaskWrapper::ConstructL(CFbsDevice& aDevice, CFbsDevice& aMaskDevice, CFbsBitGcMaskWrapper* aGc)

	{

	CFbsBitGcWrapper::ConstructL(aDevice, aGc);

	User::LeaveIfError(aMaskDevice.CreateContext(iMaskGc));

	User::LeaveIfError(aMaskDevice.CreateContext(iPolygonMaskGc));

	if (aGc)

		{

		iMaskGc->CopySettings(*(aGc->iMaskGc));

		iMaskGc->CancelClippingRegion();

		iPolygonMaskGc->CopySettings(*(aGc->iMaskGc));

		iPolygonMaskGc->CancelClippingRegion();

		}

	// Set the pen color to white.

	// (Ensures that all drawing operations will set pixels on the mask)

	iMaskGc->SetPenColor(KRgbWhite);

	iPolygonMaskGc->SetPenColor(KRgbWhite);

	}

CFbsBitGcMaskWrapper::~CFbsBitGcMaskWrapper()

	{

	delete iMaskGc;

	delete iPolygonMaskGc;

	}

void CFbsBitGcMaskWrapper::SetPen(const CPen& aPen)

	{

	CFbsBitGcWrapper::SetPen(aPen);

	iMaskGc->SetPenStyle(iPenStyle);

	iMaskGc->SetPenSize(iPenSize);

	}

void CFbsBitGcMaskWrapper::SetBrush(CBrush& aBrush)

	{

	CFbsBitGcWrapper::SetBrush(aBrush);

	if (!iPatternBrush)

		iMaskGc->SetBrushStyle(iBrushStyle);

	else

		iMaskGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	}

void CFbsBitGcMaskWrapper::DrawPolygonL(const TPoint* aPointList,TInt aNumPoints,CGraphicsContext::TFillRule aFillRule)

	{

	CFbsBitGcWrapper::DrawPolygonL(aPointList, aNumPoints, aFillRule);

	if (iPenStyle == CGraphicsContext::ENullPen || iPenSize.iWidth == 0)

		{

		if (iBrushStyle != CGraphicsContext::ENullBrush)

			{

			iPolygonMaskGc->CopySettings(*iMaskGc);

			iPolygonMaskGc->CancelClippingRegion();

			iPolygonMaskGc->SetPenStyle(CGraphicsContext::ESolidPen);

			iPolygonMaskGc->SetPenSize(TSize(1,1));

			User::LeaveIfError(iPolygonMaskGc->DrawPolygon(aPointList,aNumPoints,aFillRule));

			}

		}

	else

		User::LeaveIfError(iMaskGc->DrawPolygon(aPointList,aNumPoints,aFillRule));

	}

void CFbsBitGcMaskWrapper::Clear()

	{

	CFbsBitGcWrapper::Clear();

	// Clear the mask to black.

	iMaskGc->SetBrushColor(KRgbBlack);

	iMaskGc->Clear();

	// Reset the brush color to white.

	iMaskGc->SetBrushColor(KRgbWhite);

	}

void CFbsBitGcMaskWrapper::SetUnderlineStyle(TFontUnderline aUnderlineStyle)

	{

	CFbsBitGcWrapper::SetUnderlineStyle(aUnderlineStyle);

	iMaskGc->SetUnderlineStyle(aUnderlineStyle);

	}

void CFbsBitGcMaskWrapper::SetStrikethroughStyle(TFontStrikethrough aStrikethroughStyle)

	{

	CFbsBitGcWrapper::SetStrikethroughStyle(aStrikethroughStyle);

	iMaskGc->SetStrikethroughStyle(aStrikethroughStyle);

	}

void CFbsBitGcMaskWrapper::UseFont(const CFbsFont* aFont)

	{

	CFbsBitGcWrapper::UseFont(aFont);

	iMaskGc->UseFont(aFont);

	}

void CFbsBitGcMaskWrapper::SetClippingRegion(const TRegion* aRegion)

	{

	CFbsBitGcWrapper::SetClippingRegion(aRegion);

	iMaskGc->SetClippingRegion(aRegion);

	}

void CFbsBitGcMaskWrapper::SetCharJustification(TInt aExcessWidth, TInt aNumGaps)

	{

	CFbsBitGcWrapper::SetCharJustification(aExcessWidth, aNumGaps);

	iMaskGc->SetCharJustification(aExcessWidth, aNumGaps);

	}

void CFbsBitGcMaskWrapper::SetWordJustification(TInt aExcessWidth, TInt aNumChars)

	{

	CFbsBitGcWrapper::SetWordJustification(aExcessWidth, aNumChars);

	iMaskGc->SetWordJustification(aExcessWidth, aNumChars);

	}

void CFbsBitGcMaskWrapper::DrawLineTo(const TPoint& aPoint)

	{

	CFbsBitGcWrapper::DrawLineTo(aPoint);

	iMaskGc->DrawLineTo(aPoint);

	}

void CFbsBitGcMaskWrapper::MoveTo(const TPoint& aPoint)

	{

	CFbsBitGcWrapper::MoveTo(aPoint);

	iMaskGc->MoveTo(aPoint);

	}

void CFbsBitGcMaskWrapper::DrawPolyLine(const TPoint* aPointList, TInt aNumPoints)

	{

	CFbsBitGcWrapper::DrawPolyLine(aPointList, aNumPoints);

	iMaskGc->DrawPolyLine(aPointList, aNumPoints);

	}

void CFbsBitGcMaskWrapper::DrawEllipse(const TRect& aRect)

	{

	CFbsBitGcWrapper::DrawEllipse(aRect);

	iMaskGc->DrawEllipse(aRect);

	}

void CFbsBitGcMaskWrapper::DrawRect(const TRect& aRect)

	{

	CFbsBitGcWrapper::DrawRect(aRect);

	iMaskGc->DrawRect(aRect);

	}

void CFbsBitGcMaskWrapper::DrawRoundRect(const TRect& aRect, const TSize& aEllipse)

	{

	CFbsBitGcWrapper::DrawRoundRect(aRect, aEllipse);

	iMaskGc->DrawRoundRect(aRect, aEllipse);

	}

void CFbsBitGcMaskWrapper::SetPenStyle(CGraphicsContext::TPenStyle aPenStyle)

	{

	CFbsBitGcWrapper::SetPenStyle(aPenStyle);

	iMaskGc->SetPenStyle(aPenStyle);

	}

void CFbsBitGcMaskWrapper::SetBrushStyle(CGraphicsContext::TBrushStyle aBrushStyle)

	{

	CFbsBitGcWrapper::SetBrushStyle(aBrushStyle);

	iMaskGc->SetBrushStyle(aBrushStyle);

	}

void CFbsBitGcMaskWrapper::SetDrawMode(CGraphicsContext::TDrawMode aDrawMode)

	{

	CFbsBitGcWrapper::SetDrawMode(aDrawMode);

	}

void CFbsBitGcMaskWrapper::Plot(const TPoint& aPoint)

	{

	CFbsBitGcWrapper::Plot(aPoint);

	iMaskGc->Plot(aPoint);

	}

void CFbsBitGcMaskWrapper::SetPenSize(const TSize& aSize)

	{

	CFbsBitGcWrapper::SetPenSize(aSize);

	iMaskGc->SetPenSize(aSize);

	}

void CFbsBitGcMaskWrapper::DrawArc(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)

	{

	CFbsBitGcWrapper::DrawArc(aRect, aStart, aEnd);

	iMaskGc->DrawArc(aRect, aStart, aEnd);