// Copyright (c) 2005-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:

// Testing of GC behaviour overrides

// This class map a CWindowGc to a CFbsBitGc class. The majority of these functions are one to one mappings, 

// with the exception  of "application specific" implementations.

// 

//

/**

 @file

 @internalComponent - Internal Symbian test code 

*/

#include "TTransGc.h"

#define KAlphaOpaque 255

EXPORT_C CTransGc* CTransGc::NewL(CWsScreenDevice& aDevice,CFbsBitGc& aFbsBitGc)

	{

	CTransGc* self = new(ELeave) CTransGc(aDevice,aFbsBitGc);

	return self;

	}

CTransGc::~CTransGc()

	{

	}

//====================Functions from GDI.H===============================

CGraphicsDevice* CTransGc::Device() const

	{

	return (iFbsBitGc.Device());

	}

void CTransGc::SetOrigin(const TPoint &aPoint)

	{

	iFbsBitGc.SetOrigin(aPoint);

	}

void CTransGc::SetClippingRect(const TRect& aRect)

	{

	iFbsBitGc.SetClippingRect(aRect);

	}

void CTransGc::CancelClippingRect()

	{

	iFbsBitGc.CancelClippingRect();

	}

TInt CTransGc::SetClippingRegion(const TRegion &aRegion)

	{

	iFbsBitGc.SetClippingRegion(&aRegion);

	return 0;

	}

void CTransGc::CancelClippingRegion()

	{

	iFbsBitGc.CancelClippingRegion();

	}

void CTransGc::SetDrawMode(TDrawMode aDrawingMode)

	{

	iFbsBitGc.SetDrawMode(aDrawingMode);

	}

void CTransGc::UseFont(const CFont *aFont)

	{

	iFbsBitGc.UseFont(aFont);

	}

void CTransGc::DiscardFont()

	{

	iFbsBitGc.DiscardFont();

	}

void CTransGc::SetUnderlineStyle(TFontUnderline aUnderlineStyle)

	{

	iFbsBitGc.SetUnderlineStyle(aUnderlineStyle);

	}

void CTransGc::SetStrikethroughStyle(TFontStrikethrough aStrikethroughStyle)

	{

	iFbsBitGc.SetStrikethroughStyle(aStrikethroughStyle);

	}

void CTransGc::SetWordJustification(TInt aExcessWidth,TInt aNumGaps)

	{

	iFbsBitGc.SetWordJustification(aExcessWidth,aNumGaps);

	}

void CTransGc::SetCharJustification(TInt aExcessWidth,TInt aNumChars)

	{

	iFbsBitGc.SetCharJustification(aExcessWidth,aNumChars);

	}

void CTransGc::SetPenStyle(TPenStyle aPenStyle)

	{

	iFbsBitGc.SetPenStyle(aPenStyle);

	}

void CTransGc::SetPenSize(const TSize& aSize)

	{

	iFbsBitGc.SetPenSize(aSize);

	}

void CTransGc::SetBrushStyle(TBrushStyle aBrushStyle)

	{

	iFbsBitGc.SetBrushStyle(aBrushStyle);

	}

void CTransGc::SetBrushOrigin(const TPoint &aOrigin)

	{

	iFbsBitGc.SetBrushOrigin(aOrigin);

	}

void CTransGc::UseBrushPattern(const CFbsBitmap *aDevice)

	{

	iFbsBitGc.UseBrushPattern(aDevice);

	}

void CTransGc::DiscardBrushPattern()

	{

	iFbsBitGc.DiscardBrushPattern();

	}

void CTransGc::Plot(const TPoint &aPoint)

	{

	iFbsBitGc.Plot(aPoint);

	}

void CTransGc::DrawLine(const TPoint &aPoint1,const TPoint &aPoint2)

	{

	iFbsBitGc.DrawLine(aPoint1,aPoint2);

	}

void CTransGc::MoveTo(const TPoint &aPoint)

	{

	iFbsBitGc.MoveTo(aPoint);

	}

void CTransGc::MoveBy(const TPoint &aPoint)

	{

	iFbsBitGc.MoveBy(aPoint);

	}

void CTransGc::DrawLineTo(const TPoint &aPoint)

	{

	iFbsBitGc.DrawLineTo(aPoint);

	}

void CTransGc::DrawLineBy(const TPoint &aPoint)

	{

	iFbsBitGc.DrawLineBy(aPoint);

	}

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

	{

	iFbsBitGc.DrawPolyLine(aPointList,aNumPoints);

	}

void CTransGc::DrawPolyLine(const CArrayFix<TPoint> *aPointArray)

	{

	iFbsBitGc.DrawPolyLine(aPointArray);

	}

TInt CTransGc::DrawPolygon(const TPoint* aPointList,TInt aNumPoints,TFillRule aFillRule)

	{

	return (iFbsBitGc.DrawPolygon(aPointList,aNumPoints,aFillRule));

	}

TInt CTransGc::DrawPolygon(const CArrayFix<TPoint> *aPointArray,TFillRule aFillRule)

	{

	return (iFbsBitGc.DrawPolygon(aPointArray,aFillRule));

	}

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

	{

	iFbsBitGc.DrawArc(aRect,aStart,aEnd);

	}

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

	{

	iFbsBitGc.DrawPie(aRect,aStart,aEnd);

	}

void CTransGc::DrawEllipse(const TRect &aRect)

	{

	iFbsBitGc.DrawEllipse(aRect);

	}

void CTransGc::DrawRect(const TRect &aRect)

	{

	iFbsBitGc.DrawRect(aRect);

	}

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

	{

	iFbsBitGc.DrawRoundRect(aRect,aEllipse);

	}

void CTransGc::DrawBitmap(const TPoint &aTopLeft, const CFbsBitmap *aDevice)

	{

	iFbsBitGc.DrawBitmap(aTopLeft,aDevice);

	}

void CTransGc::DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice)

	{

	iFbsBitGc.DrawBitmap(aDestRect,aDevice);

	}

void CTransGc::DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice, const TRect &aSourceRect)

	{

	iFbsBitGc.DrawBitmap(aDestRect,aDevice,aSourceRect);

	}

void CTransGc::DrawText(const TDesC &aBuf, const TPoint &aPos)

	{

	iFbsBitGc.DrawText(aBuf,aPos);

	}

void CTransGc::DrawText(const TDesC &aBuf,const TRect &aBox,TInt aBaselineOffset,TTextAlign aHoriz,TInt aLeftMrg)

	{

	iFbsBitGc.DrawText(aBuf,aBox,aBaselineOffset,aHoriz,aLeftMrg);

	}

void CTransGc::DrawTextVertical(const TDesC& aText,const TPoint& aPos,TBool aUp)

	{

	iFbsBitGc.DrawTextVertical(aText,aPos,aUp);

	}

void CTransGc::DrawTextVertical(const TDesC& aText,const TRect& aBox,TInt aBaselineOffset,TBool aUp,TTextAlign aVert,TInt aMargin)

	{

	iFbsBitGc.DrawTextVertical(aText,aBox,aBaselineOffset,aUp,aVert,aMargin);

	}

//========================Extra functions============================

void CTransGc::CopyRect(const TPoint &anOffset,const TRect &aRect)

	{

	iFbsBitGc.CopyRect(anOffset,aRect);

	}

void CTransGc::BitBlt(const TPoint &aPoint, const CFbsBitmap *aBitmap)

	{

	iFbsBitGc.BitBlt(aPoint,aBitmap);

	}

void CTransGc::BitBlt(const TPoint &aDestination,const CFbsBitmap *aBitmap,const TRect &aSource)

	{

	iFbsBitGc.BitBlt(aDestination,aBitmap,aSource);

	}

void CTransGc::BitBltMasked(const TPoint& aPoint,const CFbsBitmap* aBitmap,const TRect& aSourceRect,const CFbsBitmap* aMaskBitmap,TBool aInvertMask)

	{

	iFbsBitGc.BitBltMasked(aPoint,aBitmap,aSourceRect,aMaskBitmap,aInvertMask);

	}

void CTransGc::BitBlt(const TPoint &aPoint, const CWsBitmap *aBitmap)

	{

	iFbsBitGc.BitBlt(aPoint,aBitmap);

	}

void CTransGc::BitBlt(const TPoint &aDestination,const CWsBitmap  *aBitmap,const TRect &aSource)

	{

	iFbsBitGc.BitBlt(aDestination,aBitmap,aSource);

	}

void CTransGc::BitBltMasked(const TPoint& aPoint,const CWsBitmap * aBitmap,const TRect& aSourceRect,const CWsBitmap * aMaskBitmap,TBool aInvertMask)

	{

	iFbsBitGc.BitBltMasked(aPoint,aBitmap,aSourceRect,aMaskBitmap,aInvertMask);

	}

void CTransGc::MapColors(const TRect &aRect,const TRgb *aColors,TInt aNumPairs,TBool aMapForwards)

	{

	iFbsBitGc.MapColors(aRect,aColors,aNumPairs,aMapForwards);

	}

void CTransGc::Clear(const TRect &aRect)

	{

	iFbsBitGc.Clear(aRect);

	}

void CTransGc::Clear()

	{

	iFbsBitGc.Clear();

	}

void CTransGc::SetDitherOrigin(const TPoint& aPoint)

	{

	iFbsBitGc.SetDitherOrigin(aPoint);

	}

void CTransGc::SetFaded(TBool aFaded)

	{

	iFbsBitGc.SetFaded(aFaded);

	}

void CTransGc::SetFadingParameters(TUint8 aBlackMap,TUint8 aWhiteMap)

	{

	iFbsBitGc.SetFadingParameters(aBlackMap,aWhiteMap);

	}

/** Application specific */

CTransGc::CTransGc(CWsScreenDevice& aDevice, CFbsBitGc& aFbsBitGc)

		: CWindowGc(&aDevice), iFbsBitGc(aFbsBitGc)

	{

		//Default alpha value is opaque

		iAlpha = KAlphaOpaque; 

	}

void CTransGc::SetWindowOrigin(TPoint aOrigin)

{

	//The window origin is reference offset so that multiple windows can composite into an offscreen Gc 

	iWindowOrigin = aOrigin;

}

//The Gc activate function ensures the correct window refreshing (clearing) and relative placement of origin for offscreen

//bitmap images.

void CTransGc::Activate(RDrawableWindow& aWindow)

	{				

		CancelClippingRect();

		//Alpha clear the redraw rect;

		iFbsBitGc.SetBrushColor(TRgb(0,0,0,0)); //Alpha transparent 			

		SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);	

		//The new Gc Origin is the current window position relative to our main iWindowOrigin

		TPoint p = aWindow.AbsPosition();	

		p -= iWindowOrigin;

		iGcOrigin = p;

		//ensure the drawing functions to draw to the correct origin

		iFbsBitGc.SetOrigin(p);

		//Only clear this Gc if a new window (and hence different rect) is applied 

		if (iWin!=&aWindow)		

			{

			//Save the window 

			iWin = &aWindow;

			TRect rect;

			//Get the redraw rectangle

			rect = aWindow.GetDrawRect();		

			//Clear the drawing region

			Clear(rect); 

			}			

		SetDrawMode(CGraphicsContext::EDrawModePEN);		

	}

void CTransGc::Reset()

	{	

		iFbsBitGc.Reset();

		//Make sure the current origin is maintained.

		iFbsBitGc.SetOrigin(iGcOrigin);

	}

void CTransGc::Deactivate()

	{	

		CancelClippingRect();

	}

//Set the current alpha level component

void CTransGc::SetAlphaLevel(TInt aAlpha)

	{

	iAlpha = aAlpha;

	}

//Ensure the pen colour is set in the bitmap with the correct alpha blending level

void CTransGc::SetPenColor(const TRgb &aColor)

	{

	TRgb Color = aColor;

	Color.SetAlpha(iAlpha);

	iFbsBitGc.SetPenColor(Color);

	}

//Ensure the brush colour is set in the bitmap with the correct alpha blending level

void CTransGc::SetBrushColor(const TRgb &aColor)

	{

	TRgb Color = aColor;

	Color.SetAlpha(iAlpha);

	iFbsBitGc.SetBrushColor(Color);

	}