/*

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

*

*/

#include "TGraphicsContext.h"

#include <e32std.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <graphics/gdi/gdiconsts.h>

#include <graphics/gdi/gdistructs.h>

#endif

_LIT(KTestFontName, "Non Functional Test Font");

// Utility functions to show contents of test data using test.Printf

extern void PrintTestData (const TDesC& aTitle , const TDesC16& aDataBuffer);

extern void PrintTestData(const TDesC& aTitle, const TText16* aDataBuffer, const TInt aSize);

//

//

// CLineArray

//

//

CLineArray::CLineArray() : iArrayIsEnabled(ETrue), iArray(0)

	{

	iPrev = iNext = this;

	}

void CLineArray::Null()

	{

	if (iNext == this && iArray)

		{

		iArray->Close();

		delete iArray;

		}

	iArray = 0;

	iPrev->iNext = iNext;

	iNext->iPrev = iPrev;

	iNext = iPrev = this;

	}

CLineArray::~CLineArray()

	{

	Null();

	}

void CLineArray::ConstructL(TInt aGranularity)

	{

	CLineArray::Null();

	iArray = new (ELeave) RArray<TTestGCDisplayLine>(aGranularity);

	}

void CLineArray::Copy(const CLineArray& aOther)

	{

	CLineArray::Null();

	iNext = &aOther;

	iPrev = aOther.iPrev;

	iPrev->iNext = this;

	aOther.iPrev = this;

	iArray = aOther.iArray;

	iArrayIsEnabled = aOther.iArrayIsEnabled;

	}

void CLineArray::ResetLineArray()

	{

	iArray->Reset();

	}

const TTestGCDisplayLine& CLineArray::Line(TInt aIndex)

	{

	return (*iArray)[aIndex];

	}

const TTestGCDisplayLine* CLineArray::Find(const TDesC& aText)

	{

	TInt count = LinesPresent();

	for (TInt i = 0; i != count; ++i)

		{		

		const TTestGCDisplayLine& line = Line(i);

		if (line.iLineData.Find(aText) != KErrNotFound)

			return &line;

		}

	return 0;

	}

void CLineArray::AddLineL(TTestGCDisplayLine& aLine)

	{

	if (iArrayIsEnabled)

		User::LeaveIfError(iArray->Append(aLine));

	}

TInt CLineArray::LinesPresent()

	{

	return iArray->Count();

	}

//

//

// CTestGraphicsDevice

//

//

CTestGraphicsDevice* CTestGraphicsDevice::NewL(TSize aSizeInPixels, RWsSession* aWsSession)

	{

	CTestGraphicsDevice* r = aWsSession?

		new (ELeave) CTestGraphicsDevice(aSizeInPixels, aWsSession)

		: new (ELeave) CTestGraphicsDevice(aSizeInPixels);

	r->iLineArray.ConstructL(4);

	if (aWsSession && KErrNone != r->Construct())

		{

		delete r;

		return 0;

		}

	return r;

	}

CTestGraphicsDevice::CTestGraphicsDevice(TSize aSizeInPixels, RWsSession* aWsSession)

	: CWsScreenDevice(*aWsSession)

	{

	Set(aSizeInPixels);

	}

CTestGraphicsDevice::CTestGraphicsDevice(TSize aSizeInPixels)

	{

	Set(aSizeInPixels);

	}

void CTestGraphicsDevice::Set(TSize aSizeInPixels)

	{

	iSize = aSizeInPixels;

	iHorizontalTwipsToPixels = 40;

	iVerticalTwipsToPixels = 40;

	iPalette.SetEntry(0, KRgbBlack);

	iPalette.SetEntry(1, KRgbWhite);

	iPalette.SetEntry(2, KRgbMagenta);

	iPalette.SetEntry(3, KRgbCyan);

	}

void CTestGraphicsDevice::SetHorizontalTwipsToPixels(TInt aTwipsToPixels)

	{

	iHorizontalTwipsToPixels = aTwipsToPixels;

	}

void CTestGraphicsDevice::SetVerticalTwipsToPixels(TInt aTwipsToPixels)

	{

	iVerticalTwipsToPixels = aTwipsToPixels;

	}

TDisplayMode CTestGraphicsDevice::DisplayMode() const

	{

	return EColor16M;

	}

TSize CTestGraphicsDevice::SizeInPixels() const

	{

	return iSize;

	}

TSize CTestGraphicsDevice::SizeInTwips() const

	{

	return TSize(iSize.iWidth * iHorizontalTwipsToPixels,

		iSize.iHeight * iVerticalTwipsToPixels);

	}

TInt CTestGraphicsDevice::CreateContext(CWindowGc*& aGC)

	{

	CTestGraphicsContext* r = new CTestGraphicsContext(this);

	if (!r)

		return KErrNoMemory;

	// only contruct if it is a fully-fledged Window Server thing

	if (iBuffer)

		r->Construct();

	aGC = r;

	return KErrNone;

	}

TInt CTestGraphicsDevice::CreateContext(CGraphicsContext*& aGC)

	{

	CWindowGc* p;

	TInt r = CreateContext(p);

	aGC = p;

	return r;

	}

TInt CTestGraphicsDevice::NumTypefaces() const

	{

	return 1;

	}

void CTestGraphicsDevice::TypefaceSupport(TTypefaceSupport& aTypefaceSupport, TInt aTypefaceIndex) const

	{

	// The only font we have at the moment is 10 pixels * 12 pixels for every character

	__ASSERT_ALWAYS(aTypefaceIndex == 0,

		CTestGraphicsContext::Panic(CTestGraphicsContext::ETypefaceIndexOutOfRange));

	aTypefaceSupport.iIsScalable = EFalse;

	aTypefaceSupport.iMaxHeightInTwips = iVerticalTwipsToPixels * 12;

	aTypefaceSupport.iMinHeightInTwips = iVerticalTwipsToPixels * 10;

	aTypefaceSupport.iNumHeights = 1;

	aTypefaceSupport.iTypeface.iName = KTestFontName;

	aTypefaceSupport.iTypeface.SetIsProportional(ETrue); // a bit of a lie

	aTypefaceSupport.iTypeface.SetIsSerif(EFalse);

	aTypefaceSupport.iTypeface.SetIsSymbol(EFalse);

	}

TInt CTestGraphicsDevice::FontHeightInTwips(TInt aTypefaceIndex, TInt aHeightIndex) const

	{

	// The only font we have at the moment is 10 pixels * 12 pixels for every character

	__ASSERT_ALWAYS(aTypefaceIndex == 0,

		CTestGraphicsContext::Panic(CTestGraphicsContext::ETypefaceIndexOutOfRange));

	return iVerticalTwipsToPixels * FontHeightInPixels(aTypefaceIndex, aHeightIndex);

	}

void CTestGraphicsDevice::PaletteAttributes(TBool& aModifiable, TInt& aNumEntries) const

	{

	aModifiable = ETrue;

	aNumEntries = 4;

	}

void CTestGraphicsDevice::SetPalette(CPalette* aPalette)

	{

	for (TInt i = 0; i != CTestPalette::KNumEntries; ++i)

		{

		TRgb col = aPalette->GetEntry(i);

		iPalette.SetEntry(i, col);

		}

	}

TInt CTestGraphicsDevice::GetPalette(CPalette*& aPalette) const

	{

	aPalette = const_cast<CTestPalette*>(&iPalette);

	return KErrNone;

	}

void CTestGraphicsDevice::GetPixel(TRgb& aColor, const TPoint&) const

	{

	aColor = KRgbWhite;

	}

void CTestGraphicsDevice::GetScanLine(TDes8&, const TPoint&, TInt, TDisplayMode) const

	{

	__ASSERT_DEBUG(0, CTestGraphicsContext::Panic(CTestGraphicsContext::EUnimplemented));

	}

TInt CTestGraphicsDevice::AddFile(const TDesC&, TInt&)

	{

	return KErrNotSupported;

	}

void CTestGraphicsDevice::RemoveFile(TInt)

	{

	}

TInt CTestGraphicsDevice::GetNearestFontInPixels(CFont*& aFont, const TFontSpec&)

	{

	CTestFont* font = new CTestFont();

	if (!font)

		return KErrNoMemory;

	aFont = font;

	return KErrNone;

	}

TInt CTestGraphicsDevice::FontHeightInPixels(TInt, TInt) const

	{

	return 12;

	}

TInt CTestGraphicsDevice::HorizontalTwipsToPixels(TInt aTwips) const

	{

	return aTwips / iHorizontalTwipsToPixels;

	}

TInt CTestGraphicsDevice::VerticalTwipsToPixels(TInt aTwips) const

	{

	return aTwips / iVerticalTwipsToPixels;

	}

TInt CTestGraphicsDevice::HorizontalPixelsToTwips(TInt aPixels) const

	{

	return aPixels * iHorizontalTwipsToPixels;

	}

TInt CTestGraphicsDevice::VerticalPixelsToTwips(TInt aPixels) const

	{

	return aPixels * iVerticalTwipsToPixels;

	}

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

	{

	TFontSpec fontSpec = aFontSpec;

	fontSpec.iHeight = VerticalTwipsToPixels(fontSpec.iHeight);

	return GetNearestFontInPixels(aFont, fontSpec);

	}

void CTestGraphicsDevice::ReleaseFont(CFont* aFont)

	{

	__ASSERT_ALWAYS(aFont->TypeUid() == TUid::Uid(12345),

		CTestGraphicsContext::Panic(CTestGraphicsContext::EUnknownFont));

	delete static_cast<CTestFont*>(aFont);

	}

void CTestGraphicsDevice::AddRectToDrawnArea(const TRect& aRect, TBool aCondition)

	{

	// check if the drawing is on testing area

	if (!(iTestingArea.IsEmpty()) &&  	// if testing area has been set

		!iHasDrawnOnTestingArea)		// and nothing hasn't been drawn on it so far

		iHasDrawnOnTestingArea = iTestingArea.Intersects(aRect);

	if (iDrawnArea.IsEmpty())

		iDrawnArea = aRect;

	else

		iDrawnArea.BoundingRect(aRect);

	// only one condition at the moment

	if (aCondition)

		{

		if (iAreaDrawnWithCondition.IsEmpty())

			iAreaDrawnWithCondition = aRect;

		else

			iAreaDrawnWithCondition.BoundingRect(aRect);

		}

	}

void CTestGraphicsDevice::SetTestingArea(TRect& aTestingArea)

	{

	iTestingArea = aTestingArea;

	}

void CTestGraphicsDevice::AddTestingArea(TRect& moreTestingArea)

	{

	if (iTestingArea.IsEmpty())

		iTestingArea = moreTestingArea;

	else

		iTestingArea.BoundingRect(moreTestingArea);

	}

//

//

// CTestGraphicsContext

//

//

void CTestGraphicsContext::Panic(TInt aReason)

	{

	User::Panic(_L("CTestGC"), aReason);

	}

CTestGraphicsContext::CTestGraphicsContext(CTestGraphicsDevice* aGd)

	: CWindowGc(aGd), iGd(aGd), iDrawMode(EDrawModePEN), iPenSize(1,1)

	{

	iLineArray.Copy(aGd->LineArray());

	}

TInt CTestGraphicsContext::Construct()

	{

	return CWindowGc::Construct();

	}

void CTestGraphicsContext::AddRectToDrawnArea(const TRect& aRect)

	{

	TRect drawnRect = aRect;

	drawnRect.Grow(iPenSize);

	iGd->AddRectToDrawnArea(drawnRect,

		iDrawMode == EDrawModeXOR || iDrawMode == EDrawModeNOTSCREEN);

	}

void CTestGraphicsContext::AddPointToDrawnArea(const TPoint& aPoint)

	{

	AddRectToDrawnArea(TRect(aPoint, iPenSize));

	}

CGraphicsDevice* CTestGraphicsContext::Device() const

	{

	return iGd;

	}

void CTestGraphicsContext::SetOrigin(const TPoint& aPos)

	{

	iOrigin = aPos;

	}

void CTestGraphicsContext::SetDrawMode(TDrawMode aDrawingMode)

	{

	iDrawMode = aDrawingMode;

	}

void CTestGraphicsContext::SetClippingRect(const TRect& /*aRect*/)

	{

	}

void CTestGraphicsContext::CancelClippingRect()

	{

	}

TInt CTestGraphicsContext::SetClippingRegion(const TRegion& /*aRegion*/)

	{

	return KErrNone;

	}

void CTestGraphicsContext::CancelClippingRegion()

	{

	}

void CTestGraphicsContext::Reset()

	{

	iDrawMode = EDrawModePEN;

	iFont = 0;

	iPenSize.iWidth = 1;

	iPenSize.iHeight = 1;

	}

void CTestGraphicsContext::UseFont(const CFont* aFont)

	{

	iFont = aFont;

	}

void CTestGraphicsContext::DiscardFont()

	{

	iFont = 0;

	}

void CTestGraphicsContext::SetUnderlineStyle(TFontUnderline /*UnderlineStyle*/)

	{

	}

void CTestGraphicsContext::SetStrikethroughStyle(TFontStrikethrough /*aStrikethroughStyle*/)

	{

	}

void CTestGraphicsContext::SetWordJustification(TInt /*aExcessWidth*/,TInt /*aNumGaps*/)

	{

	}

void CTestGraphicsContext::SetCharJustification(TInt /*aExcessWidth*/,TInt /*aNumChars*/)

	{

	}

void CTestGraphicsContext::SetPenColor(const TRgb& aColor)

	{

	CPalette* palette;

	iGd->GetPalette(palette);

	iPenColorIndex = palette->NearestIndex(aColor);

	}

void CTestGraphicsContext::SetPenStyle(TPenStyle /*aPenStyle*/)

	{

	}

void CTestGraphicsContext::SetPenSize(const TSize& aSize)

	{

	iPenSize = aSize;

	}

void CTestGraphicsContext::SetBrushColor(const TRgb& /*aColor*/)

	{

	}

void CTestGraphicsContext::SetBrushStyle(TBrushStyle /*aBrushStyle*/)

	{

	}

void CTestGraphicsContext::SetBrushOrigin(const TPoint& /*aOrigin*/)

	{

	}

void CTestGraphicsContext::UseBrushPattern(const CFbsBitmap* /*aBitmap*/)

	{

	}

void CTestGraphicsContext::DiscardBrushPattern()

	{

	}

void CTestGraphicsContext::MoveTo(const TPoint& aPoint)

	{

	iCurrentPos = iOrigin + aPoint;

	}

void CTestGraphicsContext::MoveBy(const TPoint& aVector)

	{

	iCurrentPos += aVector;

	}

void CTestGraphicsContext::Plot(const TPoint& aPoint)

	{

	iCurrentPos = iOrigin + aPoint;

	AddPointToDrawnArea(iCurrentPos);

	}

void CTestGraphicsContext::DrawArc(const TRect& aRect,const TPoint& /*aStart*/,const TPoint& aEnd)

	{

	TRect r = aRect;

	r.Move(iOrigin);

	AddRectToDrawnArea(r);

	iCurrentPos = iOrigin + aEnd;

	}

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

	{

	AddPointToDrawnArea(iOrigin + aPoint1);

	iCurrentPos = iOrigin + aPoint2;

	AddPointToDrawnArea(iCurrentPos);

	}

void CTestGraphicsContext::DrawLineTo(const TPoint& aPoint)

	{

	AddPointToDrawnArea(iCurrentPos);

	iCurrentPos = iOrigin + aPoint;

	AddPointToDrawnArea(iCurrentPos);

	}

void CTestGraphicsContext::DrawLineBy(const TPoint& aVector)

	{

	AddPointToDrawnArea(iCurrentPos);

	iCurrentPos += aVector;