// Copyright (c) 1997-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 <bitstd.h>

#include <bitdev.h>

#include <bitdraw.h>

#include <bitdrawscaling.h>

#include <bitdrawinterfaceid.h>

#include "BITPANIC.H"

#include <s32mem.h>

#include <shapeinfo.h>

#include "bitgcextradata.h"

#define KDefaultShadowColor KRgbGray

//CFbsBitGc streams - version numbers.

//Add new version numbers here. A reason of adding new version numbers may be adding new 

//CFbsBitGc data members, which may have to be externalized/internalized. When that happens:

//1.Put a new enum item (like EFbsBitGc_Ver01) with a version number, which is greater than

//  the last version number, which was used. 

//2.Comment the new enum item.

//3.Update KFbsBitGc_VerNo value to be the last enum item value.

//4.Update InternalizeL/ExternalizeL methods after adding the new version number.

//  For example: If a new member is added to the class - TInt iSmth, when InternalizeL

//  is called to operate on older archive, iSmth member won't be in the archive!

//  So, in InternalizeL, there should be a check, something like:

//	TUint16 archiveVerNo = 0;

//	aReadStream >> archiveVerNo;

//  .......................

//  if(archiveVerNo < EFbsBitGc_Ver03)   //EFbsBitGc_Ver03 has been added, when iSmth has been added

//		{

//      //Do nothing - iSmth is not in the archive

//      //Initialize it with some default value

//      iSmth = KDefVal;

//		}

//	else

//		{

//		aReadStream >> iSmth;

//		}

enum

	{

	EFbsBitGc_Ver01 = 1, //Base version number, when InternalizeL/ExternalizeL were added

	EFbsBitGc_Ver02 = 2, //Supports InternalizeL/ExternalizeL for ShadowColor. 

	};

LOCAL_D const TUint16 KFbsBitGc_VerNo = EFbsBitGc_Ver02;

// Global panic functions

void Panic(TBitgdiPanic aPanicCode)

	{

	_LIT(KBitgdiPanicCategory,"BITGDI");

	User::Panic(KBitgdiPanicCategory,aPanicCode);

	}

_LIT(KBITGDIPanicDesc1,"BitGdi internal Panic %S, in file %S @ line %i");

_LIT(KBITGDIPanicDesc2,"Assert condition = \"%S\"");

_LIT(KBITGDIPanicDesc3, "BitGdi internal Invariant, in file %S @ line %i");

void PanicWithInfo(TBitgdiPanic aPanic, const TDesC& aFileName, const TDesC& aPanicName, TInt aLine)

	{

	TBuf<256> buf;

	buf.Format(KBITGDIPanicDesc1, &aPanicName, &aFileName, aLine);

	RDebug::Print(buf);

	Panic(aPanic);

	}

void PanicWithCondAndInfo(TBitgdiPanic aPanic, const TDesC& aCondition, const TDesC& aFileName, const TDesC& aPanicName, TInt aLine)

	{

	TBuf<256> buf;

	buf.Format(KBITGDIPanicDesc1, &aPanicName, &aFileName, aLine);

	RDebug::Print(buf);

	buf.Format(KBITGDIPanicDesc2, &aCondition);

	RDebug::Print(buf);

	Panic(aPanic);

	}

void InvariantWithCondAndInfo(const TDesC& aCondition, const TDesC& aFileName, TInt aLine)

	{

	TBuf<256> buf;

	buf.Format(KBITGDIPanicDesc3, &aFileName, aLine);

	RDebug::Print(buf);

	buf.Format(KBITGDIPanicDesc2, &aCondition);

	RDebug::Print(buf);

	User::Invariant();

	}

//

// CFbsBitGc

//

/** Factory function for creating a CFbsBitGc object

The object is then ready for a call to Activate().

@return A pointer to the newly created object. */

EXPORT_C CFbsBitGc* CFbsBitGc::NewL()

	{

	CFbsBitGc* bitGc = new(ELeave) CFbsBitGc;

	CleanupStack::PushL(bitGc);

	bitGc->iFbsBitGcExtraData = new(ELeave) CFbsBitGcExtraData;

	CleanupStack::Pop(bitGc);

	return bitGc;

	}

CFbsBitGc::CFbsBitGc():

	CBitmapContext(),

	iBrushBitmap(),

	iBrushUsed(EFalse),

	iBrushColor(KRgbWhite),

	iBrushOrigin(TPoint(0,0)),

	iBrushStyle(ENullBrush),

	iClipRect(TRect(0,0,0,0)),

	iDefaultRegion(),

	iDefaultRegionPtr(NULL),

	iUserClipRect(TRect(0,0,0,0)),

	iDevice(NULL),

	iDitherOrigin(TPoint(0,0)),

	iDotLength(0),

	iDotMask(0),

	iDotParam(0),

	iDotDirection(1),

	iDrawMode(EDrawModePEN),

	iFont(),

	iCharJustExcess(0),

	iCharJustNum(0),

	iWordJustExcess(0),

	iWordJustNum(0),

	iLastPrintPosition(TPoint(0,0)),

	iLinePosition(TPoint(0,0)),

	iOrigin(TPoint(0,0)),

	iPenColor(KRgbBlack),

	iPenStyle(ESolidPen),

	iPenSize(TSize(1,1)),

	iShadowMode(CFbsDrawDevice::ENoShadow),

	iAutoUpdateJustification(ETrue),

	iFadeBlackMap(128),

	iFadeWhiteMap(255),

	iStrikethrough(EStrikethroughOff),

	iUnderline(EUnderlineOff),

	iUserDisplayMode(ENone)

	{}

/** Frees all resources owned by the object. */

EXPORT_C CFbsBitGc::~CFbsBitGc()

	{

	Reset();

	iBrushBitmap.Reset();

	iClippingRegion.Close();

	delete iFbsBitGcExtraData;

	}

/** Sets the object to draw to a particular device

@param aDevice The target device. */

EXPORT_C void CFbsBitGc::Activate(CFbsDevice* aDevice)

	{

	if (!aDevice)

		return;

	iDevice = aDevice;

	TRect deviceRect;

	iDevice->iDrawDevice->GetDrawRect(deviceRect);

	iDefaultRegion.Clear();

	iDefaultRegion.AddRect(deviceRect);

	iDefaultRegionPtr = &iDefaultRegion;

	iUserClipRect = deviceRect;

	iDrawnTo.SetWidth(0);

	iDrawnTo.SetHeight(0);

	iAutoUpdateJustification = ETrue;

	}

/** Sets the object to draw to a particular device but doesn't 'use up' 

justification settings when drawing text.

This is similar to Activate().

@param aDevice The target device. */

EXPORT_C void CFbsBitGc::ActivateNoJustAutoUpdate(CFbsDevice* aDevice)

	{

	Activate(aDevice);

	iAutoUpdateJustification = EFalse;

	}

void CFbsBitGc::SetupDevice() const

	{

	CFbsDrawDevice* drawDevice = iDevice->iDrawDevice;

	drawDevice->SetDitherOrigin(iDitherOrigin);

	drawDevice->SetShadowMode(CFbsDrawDevice::TShadowMode(iShadowMode));

	drawDevice->SetFadingParameters(iFadeBlackMap,iFadeWhiteMap);

	drawDevice->SetUserDisplayMode(iUserDisplayMode);

	}

void CFbsBitGc::CheckDevice() const

	{

	BG_ASSERT_ALWAYS(iDevice,EBitgdiPanicNoDevicePresent);

	}

TBool CFbsBitGc::CheckDevice(const TRect& aRect) const

	{

	BG_ASSERT_ALWAYS(iDevice,EBitgdiPanicNoDevicePresent);

	return aRect.IsEmpty();

	}

/** Externalizes an object of this class to a write stream.

It is important that the brush bitmap of the GC is maintained between calls

to externalize and internalize.  The brush bitmap handle is externalized,

not the bitmap data.  This is done for performance.

@param aWriteStream Stream to which the object should be externalized.

@internalAll */

EXPORT_C void CFbsBitGc::ExternalizeL(RWriteStream& aWriteStream)

	{

	aWriteStream << KFbsBitGc_VerNo;

	TInt bitmapHandle=iBrushBitmap.Handle();

	aWriteStream.WriteInt32L(bitmapHandle);

	iBrushColor.ExternalizeL(aWriteStream);

	aWriteStream.WriteInt8L(iBrushUsed);

	aWriteStream << iBrushOrigin;

	aWriteStream.WriteUint8L(iBrushStyle);

	aWriteStream << iDitherOrigin;

	aWriteStream << iUserClipRect;

	aWriteStream << iDrawnTo;

	aWriteStream.WriteUint32L(iDotLength);

	aWriteStream.WriteUint32L(iDotMask);

	aWriteStream.WriteUint32L(iDotParam);

	aWriteStream.WriteUint32L(iDotDirection); 

	aWriteStream.WriteUint8L(iDrawMode); 

	aWriteStream.WriteUint32L(iCharJustExcess);

	aWriteStream.WriteUint32L(iCharJustNum);

	aWriteStream.WriteUint32L(iWordJustExcess);

	aWriteStream.WriteUint32L(iWordJustNum);

	aWriteStream << iLastPrintPosition;

	aWriteStream << iLinePosition;

	aWriteStream << iOrigin; 

	iPenColor.ExternalizeL(aWriteStream); 

	aWriteStream.WriteUint8L(iPenStyle);   

	aWriteStream << iPenSize;

	aWriteStream << iShadowMode;

	aWriteStream << iAutoUpdateJustification;

	aWriteStream << iFadeBlackMap;

	aWriteStream << iFadeWhiteMap;

	aWriteStream.WriteUint8L(iStrikethrough); 

	aWriteStream.WriteUint8L(iUnderline);

	const TFontSpec fontSpec=iFont.FontSpecInTwips();

	fontSpec.ExternalizeL(aWriteStream);

	aWriteStream.WriteUint8L(iUserDisplayMode);

	iFbsBitGcExtraData->ShadowColor().ExternalizeL(aWriteStream);

	}

/** Internalizes an object of this class from a read stream.

It is important that the brush bitmap of the GC is maintained between calls

to externalize and internalize.  The brush bitmap handle is internalized,

not the bitmap data.

@param aReadStream Stream from which the object is to be internalized.

@internalAll */

EXPORT_C void CFbsBitGc::InternalizeL(RReadStream& aReadStream)

	{

	TUint16 archiveVerNo = 0;

	aReadStream >> archiveVerNo;

	TInt bitmapHandle=aReadStream.ReadInt32L();

	if (bitmapHandle)

		{

		UseBrushPattern(bitmapHandle);

		}

	iBrushColor.InternalizeL(aReadStream);

	iBrushUsed=aReadStream.ReadInt8L();

	aReadStream >> iBrushOrigin;

	iBrushStyle=(TBrushStyle)aReadStream.ReadUint8L();

	aReadStream >> iDitherOrigin;

	aReadStream >> iUserClipRect;

	aReadStream >> iDrawnTo;

	iDotLength=aReadStream.ReadUint32L();

	iDotMask=aReadStream.ReadUint32L();

	iDotParam=aReadStream.ReadUint32L();

	iDotDirection=aReadStream.ReadUint32L(); 

	iDrawMode=(TDrawMode)aReadStream.ReadUint8L(); 

	iCharJustExcess=aReadStream.ReadUint32L();

	iCharJustNum=aReadStream.ReadUint32L();

	iWordJustExcess=aReadStream.ReadUint32L();

	iWordJustNum=aReadStream.ReadUint32L();

	aReadStream >> iLastPrintPosition;

	aReadStream >> iLinePosition;

	aReadStream >> iOrigin; 

	iPenColor.InternalizeL(aReadStream); 

	iPenStyle=(TPenStyle)aReadStream.ReadUint8L();   

	aReadStream >> iPenSize;

	SetPenSize(iPenSize);

	aReadStream >> iShadowMode;

	aReadStream >> iAutoUpdateJustification;

	aReadStream >> iFadeBlackMap;

	aReadStream >> iFadeWhiteMap;

	iStrikethrough=(TFontStrikethrough)aReadStream.ReadUint8L(); 

	iUnderline=(TFontUnderline)aReadStream.ReadUint8L();

	TFontSpec fontSpec;

	fontSpec.InternalizeL(aReadStream);

	if (fontSpec.iHeight != 0)

		{

		CFbsFont* font = NULL;

		User::LeaveIfError(iDevice->GetNearestFontToDesignHeightInTwips(font,fontSpec));

		TInt err = iFont.Duplicate(font->Handle());

		iDevice->ReleaseFont(font);

		User::LeaveIfError(err);

		UseFont(iFont.Handle());

		}

	iUserDisplayMode=(TDisplayMode)aReadStream.ReadUint8L();

	if(archiveVerNo < EFbsBitGc_Ver02)  //Without shadowcolor

		{

		//Initialize it with the default value

		iFbsBitGcExtraData->SetShadowColor(KDefaultShadowColor);

		}

	else  //With shadowcolor

		{

		TRgb shadowColor;

		shadowColor.InternalizeL(aReadStream);

		iFbsBitGcExtraData->SetShadowColor(shadowColor);	

		}

	}

/** Copies all settings from the specified bitmap graphics context.

@param aGc The bitmap graphics context whose settings are to be copied. */

EXPORT_C void CFbsBitGc::CopySettings(const CFbsBitGc& aGc)

	{

	iBrushColor = aGc.iBrushColor;

	iBrushUsed = aGc.iBrushUsed;

	iBrushOrigin = aGc.iBrushOrigin;

	iBrushStyle = aGc.iBrushStyle;

	iDefaultRegionPtr = aGc.iDefaultRegionPtr;

	iDitherOrigin = aGc.iDitherOrigin;

	iDotLength = aGc.iDotLength;

	iDotMask = aGc.iDotMask;

	iDotParam = aGc.iDotParam;

	iDotDirection = aGc.iDotDirection;

	iDrawMode = aGc.iDrawMode;

	iCharJustExcess = aGc.iCharJustExcess;

	iCharJustNum = aGc.iCharJustNum;

	iWordJustExcess = aGc.iWordJustExcess;

	iWordJustNum = aGc.iWordJustNum;

	iLastPrintPosition = aGc.iLastPrintPosition;

	iLinePosition = aGc.iLinePosition;

	iOrigin = aGc.iOrigin;

	iPenColor = aGc.iPenColor;

	iPenStyle = aGc.iPenStyle;

	SetPenSize(aGc.iPenSize);

	iShadowMode = aGc.iShadowMode;

	iStrikethrough = aGc.iStrikethrough;

	iUnderline = aGc.iUnderline;

	iUserDisplayMode = aGc.iUserDisplayMode;

	if(aGc.iFont.Handle())

		UseFont(aGc.iFont.Handle());

	if(aGc.iBrushBitmap.Handle())

		UseBrushPattern(aGc.iBrushBitmap.Handle());

	iFbsBitGcExtraData->SetShadowColor(aGc.iFbsBitGcExtraData->ShadowColor());

	}

/** Gets a pointer to the graphics device for the graphics context.

The graphics device is the device currently being drawn to. 

The function provides a concrete implementation of the pure virtual function 

CGraphicsContext::Device(). The function behaviour is the same as documented 

in that class. 

@see CGraphicsContext::Device() */

EXPORT_C CGraphicsDevice* CFbsBitGc::Device() const

	{

	return iDevice;

	}

/** Discards a non-built-in brush pattern.

The function provides a concrete implementation of the pure virtual function 

CGraphicsContext::DiscardBrushPattern(). The function behaviour is the same 

as documented in that class. 

@see CGraphicsContext::DiscardBrushPattern() */

EXPORT_C void CFbsBitGc::DiscardBrushPattern()

	{

	iBrushBitmap.Reset();

	iBrushUsed = EFalse;

	if (iBrushStyle == EPatternedBrush)

		iBrushStyle = ENullBrush;

	}

/** Discards a selected device font.

The function provides a concrete implementation of the pure virtual function 

CGraphicsContext::DiscardFont(). The function behaviour is the same as documented 

in that class. 

@see CGraphicsContext::DiscardFont() */

EXPORT_C void CFbsBitGc::DiscardFont()

	{

	iFont.Reset();

	}

/** Maps pixels in the specified rectangle.

The function tries to match the colour of a pixel with one of the RGB values 

in an array of RGB pairs. If there is a match, the colour is changed to the 

value specified in the other RGB in the RGB pair.

@param aRect The rectangle in which pixels are to be mapped.

@param aColors A pointer to a set of RGB pairs. 

@param aNumPairs The number of pairs 

@param aMapForwards ETrue, mapping is done from the first RGB to the second 

RGB in the pair; EFalse, mapping is done from the second RGB to the first 

RGB in the pair. */

EXPORT_C void CFbsBitGc::MapColors(const TRect& aRect,

								   const TRgb* aColors,

								   TInt aNumPairs,

								   TBool aMapForwards)

	{

	if (CheckDevice(aRect) || !aColors)

		return;

	TRect rcpy(aRect);

	rcpy.Move(iOrigin);

	AddRect(rcpy);

	if (UserClipRect(rcpy))

		return;

	SetupDevice();

	iDevice->DrawingBegin();

	CFbsDrawDevice* drawDevice = iDevice->iDrawDevice;

#if defined(_DEBUG)

	TRect deviceRect;

	drawDevice->GetDrawRect(deviceRect);

#endif

	const TInt limit = iDefaultRegionPtr->Count();

	for (TInt count = 0; count < limit; count++)

		{

		iClipRect = (*iDefaultRegionPtr)[count];

		if (!iClipRect.Intersects(rcpy))

			continue;

		iClipRect.Intersection(rcpy);

		BG_ASSERT_DEBUG(iClipRect.iTl.iX >= deviceRect.iTl.iX, EBitgdiPanicOutOfBounds);

		BG_ASSERT_DEBUG(iClipRect.iTl.iY >= deviceRect.iTl.iY, EBitgdiPanicOutOfBounds);

		BG_ASSERT_DEBUG(iClipRect.iBr.iX <= deviceRect.iBr.iX, EBitgdiPanicOutOfBounds);

		BG_ASSERT_DEBUG(iClipRect.iBr.iY <= deviceRect.iBr.iY, EBitgdiPanicOutOfBounds);

		drawDevice->MapColors(iClipRect,aColors,aNumPairs,aMapForwards);

		drawDevice->UpdateRegion(iClipRect);

		}

	iDevice->DrawingEnd();

	}

/** Sets the internal drawing position relative to the co-ordinate origin.

A subsequent call to DrawLineTo() or DrawLineBy() uses the new drawing point

as the start point for the line drawn.The function provides a concrete

implementation of the pure virtual function CGraphicsContext::MoveTo(). 

The function behaviour is the same as documented in that class. */

EXPORT_C void CFbsBitGc::MoveTo(const TPoint& aPoint)

    {

	iLinePosition = aPoint;

	}

/** Sets the drawing point relative to the current co-ordinates.

The function provides a concrete implementation of the pure virtual

function CGraphicsContext::MoveBy(). The function behaviour 

is the same as documented in that class. */

EXPORT_C void CFbsBitGc::MoveBy(const TPoint& aVector)

   {

	iLinePosition += aVector;

	}

/** Resets the graphics context to its default settings.

The function provides a concrete implementation of the pure virtual function 

CGraphicsContext::Reset(). The function behaviour is the same as documented 

in that class. 

@see CGraphicsContext::Reset() */

EXPORT_C void CFbsBitGc::Reset()

	{

	iDefaultRegionPtr = &iDefaultRegion;

	if (iDefaultRegion.Count() == 0)

		iUserClipRect = TRect(0,0,0,0);

	else

		iUserClipRect = iDefaultRegion[0];

	iLastPrintPosition.SetXY(0,0);

	if(iFbsBitGcExtraData)

		{

		iFbsBitGcExtraData->Reset();	

		}

	iPenColor = KRgbBlack;

	iPenStyle = ESolidPen;

	iPenSize.SetSize(1,1);

	iDrawMode = EDrawModePEN;

	iFont.Reset();

	iLinePosition.SetXY(0,0);

	iOrigin.SetXY(0,0);

	iBrushUsed = EFalse;

	iBrushColor = KRgbWhite;

	iBrushOrigin.SetXY(0,0);

	iBrushStyle = ENullBrush;

	iCharJustExcess = 0;

	iCharJustNum = 0;

	iWordJustExcess = 0;

	iWordJustNum = 0;

	iDitherOrigin.SetXY(0,0);

	iDotLength = 0;

	iDotMask = 0;

	iDotParam = 0;

	iDotDirection = 1;

	iShadowMode = CFbsDrawDevice::ENoShadow;

	iStrikethrough = EStrikethroughOff;

	iUnderline = EUnderlineOff;

	iUserDisplayMode = ENone;

	}

/** Needs to be called if the device is resized.

This only applies to devices of type CFbsBitmapDevice. */

EXPORT_C void CFbsBitGc::Resized()

	{

	CheckDevice();

	TRect deviceRect;

	iDevice->iDrawDevice->GetDrawRect(deviceRect);