/*
* 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