/*

* Copyright (c) 2002-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: 

* Simple stubs for testing purposes

*

*/

#ifndef __TGRAPHICSCONTEXT_H__

#define __TGRAPHICSCONTEXT_H__

#include <w32std.h>

/** Representing a line of displayed data.

@internalComponent */

class TTestGCDisplayLine 

	{

public:

	TPoint iLinePos;

	TBuf16<80> iLineData;

	TTestGCDisplayLine() : iLinePos(0,0) {}

	TTestGCDisplayLine(const TInt aX, const TInt aY, const TDesC16& aLineData) : iLinePos(aX, aY) 

		{

		iLineData = aLineData;

		}

	TTestGCDisplayLine(const TPoint aLinePos, const TDesC16& aLineData) : iLinePos(aLinePos) 

		{

		iLineData = aLineData;

		}

	void Set(const TPoint& aLinePos, const TDesC16& aLineData)

		{

		iLineData = aLineData;

		iLinePos = aLinePos;

		}

	TPtrC16 LineData() const

		{

		return TPtrC16(iLineData.Ptr(), iLineData.Length());

		}

	const TPoint& Position() const

		{

		return iLinePos;

		}

	};

/** Holds a reference-counted array of TTestGCDisplayLines. Copy makes another

reference to the same array, allowing arrays to be shared between graphics

contexts and devices.

@internalComponent

*/

class CLineArray : public CBase

	{

public:

	CLineArray();

	~CLineArray();

	void ConstructL(TInt aGranularity);

	/** Make this refer to the same array as aOther currently does. */

	void Copy(const CLineArray& aOther);

	/** Removes this reference to the array. Deletes the array if all

	references have been removed. */

	void Null();

	void ResetLineArray();

	const TTestGCDisplayLine& Line(TInt aIndex);

	void AddLineL(TTestGCDisplayLine& aLine);

	TInt LinesPresent();

	/** Finds a TTestGCDisplayLine with aText contained somewhere in its data.

	Returns 0 if there is no such line. */

	const TTestGCDisplayLine* Find(const TDesC& aText);

	/** Disables any more adding to the line array, and disables it

	in any CLineArrays copied from this one. */

	void Disable() { iArrayIsEnabled = EFalse; }

	/** Re-enables adding to the line array, and in any CLineArrays copied from

	this one. */

	void Enable() { iArrayIsEnabled = ETrue; }

private:

	// CLineArrays copied from one another form a circular doubly-linked

	// list. This is roughly equivalent to reference-counting; when iPrev and

	// iNext point to 'this', this is the same as the reference count being 1.

	mutable const CLineArray* iPrev;

	mutable const CLineArray* iNext;

	TBool iArrayIsEnabled;

	RArray<TTestGCDisplayLine>* iArray;

	};

class CTestPalette : public CPalette

	{

public:

	enum { KNumEntries = 4 };

	CTestPalette()

		{

		iArray = iRgbArray;

		iNumEntries = KNumEntries;

		}

	~CTestPalette()

		{

		// Stop iRgbArray from being deleted by ~CPalette.

		// Ideally, iRgbArray should be removed in favour of

		// allocating one on the heap.

		iArray = 0;

		}

private:

	TRgb iRgbArray[KNumEntries];

	};

class CTestGraphicsDevice : public CWsScreenDevice

	{

public:

	static CTestGraphicsDevice* NewL(TSize aSizeInPixels, RWsSession* aWsSession);

	CTestGraphicsDevice(TSize aSizeInPixels, RWsSession* aWsSession);

	CTestGraphicsDevice(TSize aSizeInPixels);

	void SetHorizontalTwipsToPixels(TInt aTwipsToPixels);

	void SetVerticalTwipsToPixels(TInt aTwipsToPixels);

	TDisplayMode DisplayMode() const;

	TSize SizeInPixels() const;

	TSize SizeInTwips() const;

	TInt CreateContext(CGraphicsContext*& aGC);

	TInt CreateContext(CWindowGc*& aGC);

	TInt NumTypefaces() const;

	void TypefaceSupport(TTypefaceSupport& aTypefaceSupport,TInt aTypefaceIndex) const;

	TInt FontHeightInTwips(TInt aTypefaceIndex,TInt aHeightIndex) const;

	void PaletteAttributes(TBool& aModifiable,TInt& aNumEntries) const;

	void SetPalette(CPalette* aPalette);

	TInt GetPalette(CPalette*& aPalette) const;

	// from CBitmapDevice

	void GetPixel(TRgb& aColor,const TPoint& aPixel) const;

	void GetScanLine(TDes8& aBuf,const TPoint& aStartPixel,TInt aLength,TDisplayMode aDispMode) const;

	TInt AddFile(const TDesC& aName,TInt& aId);

	void RemoveFile(TInt aId);

	TInt GetNearestFontInPixels(CFont*& aFont,const TFontSpec& aFontSpec);

	TInt FontHeightInPixels(TInt aTypefaceIndex,TInt aHeightIndex) const;

	// from MGraphicsDeviceMap from CBitmapDevice

	TInt HorizontalTwipsToPixels(TInt aTwips) const;

	TInt VerticalTwipsToPixels(TInt aTwips) const;

	TInt HorizontalPixelsToTwips(TInt aPixels) const;

	TInt VerticalPixelsToTwips(TInt aPixels) const;

	TInt GetNearestFontInTwips(CFont*& aFont,const TFontSpec& aFontSpec);

	void ReleaseFont(CFont* aFont);

	// new functions

	void ClearDrawnArea()

		{

		iDrawnArea.iTl.iX = iDrawnArea.iBr.iX = iDrawnArea.iTl.iY = iDrawnArea.iBr.iY = 0;

		}

	TRect DrawnArea() const

		{

		return iDrawnArea;

		}

	void ClearAreaDrawnWithCondition()

		{

		iAreaDrawnWithCondition.iTl.iX = iAreaDrawnWithCondition.iBr.iX

			= iAreaDrawnWithCondition.iTl.iY = iAreaDrawnWithCondition.iBr.iY = 0;

		}

	const TRect& AreaDrawnWithCondition() const

		{

		return iAreaDrawnWithCondition;

		}

	void AddRectToDrawnArea(const TRect& aRect, TBool aCondition);

	CLineArray& LineArray() { return iLineArray; }

	void SetLineArray(const CLineArray& aLineArray)

		{

		iLineArray.Copy(aLineArray);

		}

	// new functions for testing area

	void SetTestingArea(TRect& aTestingArea);

	void AddTestingArea(TRect& moreTestingArea);

	void ClearTestingArea()

		{

		iTestingArea.iTl.iX = iTestingArea.iBr.iX

			= iTestingArea.iTl.iY = iTestingArea.iBr.iY = 0;

		}

	// check if anything has been drawn on testing area

	inline TBool HasDrawnOnTestingArea()

		{

		return iHasDrawnOnTestingArea;

		}

private:

	void Set(TSize aSizeInPixels);

	// a rect of testing area

	TRect iTestingArea;

	TBool iHasDrawnOnTestingArea;

	TRect iDrawnArea;

	TRect iAreaDrawnWithCondition;

	TSize iSize;

	TInt iHorizontalTwipsToPixels;

	TInt iVerticalTwipsToPixels;

	CTestPalette iPalette;

	CLineArray iLineArray;

	};

class CTestGraphicsContext : public CWindowGc

	{

public:

	enum TPanic

		{

		EUnimplemented,

		ETypefaceIndexOutOfRange,

		EUnknownFont,

		EErrorParameter

		};

	static void Panic(TInt aReason);

	CTestGraphicsContext(CTestGraphicsDevice* aGd);

	TInt Construct();

	// from CBitmapContext

	CGraphicsDevice* Device() const;

	void SetOrigin(const TPoint& aPos);

	void SetDrawMode(TDrawMode aDrawingMode);

	void SetClippingRect(const TRect& aRect);

	void CancelClippingRect();

	void Reset();

	void UseFont(const CFont* aFont);

	void DiscardFont();

	void SetUnderlineStyle(TFontUnderline aUnderlineStyle);

	void SetStrikethroughStyle(TFontStrikethrough aStrikethroughStyle);

	void SetWordJustification(TInt aExcessWidth,TInt aNumGaps);

	void SetCharJustification(TInt aExcessWidth,TInt aNumChars);

	void SetPenColor(const TRgb& aColor);

	void SetPenStyle(TPenStyle aPenStyle);

	void SetPenSize(const TSize& aSize);

	void SetBrushColor(const TRgb& aColor);

	void SetBrushStyle(TBrushStyle aBrushStyle);

	void SetBrushOrigin(const TPoint& aOrigin);

	void UseBrushPattern(const CFbsBitmap* aBitmap);

	void DiscardBrushPattern();

	void MoveTo(const TPoint& aPoint);

	void MoveBy(const TPoint& aVector);

	void Plot(const TPoint& aPoint);

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

	void DrawLine(const TPoint& aPoint1,const TPoint& aPoint2);

	void DrawLineTo(const TPoint& aPoint);

	void DrawLineBy(const TPoint& aVector);

	void DrawPolyLine(const CArrayFix<TPoint>* aPointList);

	void DrawPolyLine(const TPoint* aPointList,TInt aNumPoints);

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

	void DrawEllipse(const TRect& aRect);

	void DrawRect(const TRect& aRect);

	void DrawRoundRect(const TRect& aRect,const TSize& aCornerSize);

	TInt DrawPolygon(const CArrayFix<TPoint>* aPointList,TFillRule aFillRule);

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

	void DrawBitmap(const TPoint& aTopLeft,const CFbsBitmap* aSource);

	void DrawBitmap(const TRect& aDestRect,const CFbsBitmap* aSource);

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

	void DrawText(const TDesC& aText,const TPoint& aPosition);

	void DrawText(const TDesC& aText,const TRect& aBox,TInt aBaselineOffset,TTextAlign aAlignment,

		TInt aLeftMargin);

	TInt SetClippingRegion(const TRegion &aRegion);

	void CancelClippingRegion();

	// from CBitmapContext

	void Clear();

	void Clear(const TRect& aRect);

	void CopyRect(const TPoint& aOffset,const TRect& aRect);

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

	void BitBlt(const TPoint& aPoint,const CFbsBitmap* aBitmap,const TRect& aRect);

	void BitBltMasked(const TPoint& aPoint, const CFbsBitmap* aBitmap,

		const TRect& aSourceRect, const CFbsBitmap* aMaskBitmap, TBool aInvertMask);

	void SetFaded(TBool aFaded);

	void SetFadingParameters(TUint8 aBlackMap,TUint8 aWhiteMap);

	// new functions

	void AddRectToDrawnArea(const TRect& aRect);

	void AddPointToDrawnArea(const TPoint& aPoint);

	void DrawText(const TDesC& aText,TTextParameters* aParam,const TPoint& aPosition);

	void DrawText(const TDesC& aText,TTextParameters* aParam,const TRect& aBox,TInt aBaselineOffset,TTextAlign aAlignment,

		TInt aLeftMargin);

protected:	

	TInt APIExtension(TUid aUid, TAny*& aOutput, TAny* aInput);

private:

	CTestGraphicsDevice* iGd;

	TPoint iOrigin;

	TDrawMode iDrawMode;

	const CFont* iFont;

	TSize iPenSize;

	TPoint iCurrentPos;

	TInt iPenColorIndex;

	CLineArray iLineArray;

	};

class CTestFont : public CFont

	{

public:

	/**

	Sample Unicode characters.

	@internalComponent

	*/

	enum

		{

 		/** ESC has no data at all */

 		KEsc = 0x001B,

 		/** Hebrew letter Tav, has right side-bearing */

 		KTav = 0x05EA,

 		/** Arabic Waw has a massive left side-bearing */

 		KArabicWaw = 0x0648,

   		/** ZWNBS has zero width. */

   		KZeroWidthNoBreakSpace = 0xFEFF,

   		/** ZWS has zero width. */

   		KZeroWidthSpace = 0x200B,

   		/** Hair space has one pixel width. */

   		KHairSpace = 0x200A,

   		/** Thin space has two pixel width. */

   		KThinSpace = 0x2009,

   		/** 3-per-em space has three pixel width. */

   		KThreePerEmSpace = 0x2004,

   		/** Full-width solidus has a right side-bearing */

   		KFullWidthSolidus = 0xFF0F

   		};

   	TUid DoTypeUid() const;

   	TInt DoHeightInPixels() const;

   	TInt DoAscentInPixels() const;

   	TInt DoCharWidthInPixels(TChar aChar) const;

   	TInt DoTextWidthInPixels(const TDesC& aText) const;

   	TInt DoBaselineOffsetInPixels() const;

   	TInt DoTextCount(const TDesC& aText,TInt aWidthInPixels) const;

   	TInt DoTextCount(const TDesC& aText,TInt aWidthInPixels,TInt& aExcessWidthInPixels) const;

   	TInt DoMaxCharWidthInPixels() const;

   	TInt DoMaxNormalCharWidthInPixels() const;

   	TFontSpec DoFontSpecInTwips() const;

 	TCharacterDataAvailability DoGetCharacterData(TUint aCode,

 		TOpenFontCharMetrics& aMetrics,

 		const TUint8*& aBitmap, TSize& aBitmapSize) const;

	};

#endif