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

//

#ifndef __BMDRAW_H__

#define __BMDRAW_H__

#include <gdi.h>

#include <bitdraw.h>

#include "BitDrawScaling.h"

#include "BitDrawOrigin.h"

#include "BmAlphaBlend.h"

#include "BitDrawOrientation.h"

#ifdef __ARMCC__

	#define FORCEINLINE __forceinline

#else

	#define FORCEINLINE inline

#endif

/**

Outline colour index used to get percentage of outline colour to be used to get 

the final colour from lookup table

@internalComponent

*/

const TInt KOutlineColorIndex = 0;

/**

Shadow colour index used to get percentage of shadow colour to be used to get 

the final colour from lookup table

@internalComponent

*/

const TInt KShadowColorIndex = 1;

/**

Fill colour index used to get percentage of fill colour to be used to get 

the final colour from lookup table

@internalComponent

*/

const TInt KFillColorIndex = 2;

/**

Background colour index used to get percentage of background colour to be used to get 

the final colour from lookup table

@internalComponent

*/

const TInt KBackgroundColorIndex = 3;

/**

Lookup table used for outline and shadow fonts.

@internalComponent

*/

GLREF_D const TInt FourColorBlendLookup[256][4];

TRgb AlphaBlend(TRgb aPrimary, TRgb aSecondary, TInt aAlphaValue);

 //Scaling settings. MScalingSettings interface operates with them.

struct TScalingSettings

	{

	inline TScalingSettings() :

		iFactorX(1),

		iFactorY(1),

		iDivisorX(1),

		iDivisorY(1)

		{

		}

	TInt iFactorX;

	TInt iFactorY;

	TInt iDivisorX;

	TInt iDivisorY;

	};

 // Drawing device origin. MDrawDeviceOrigin interface operates with it.

typedef TPoint TOrigin;

//This class is used as a template argument by CDrawEightBppBitmapCommon::SetPixels()

//and CDrawSixteenBppBitmapCommon::SetPixels()

//Each of its methods (EvalInc() and EvalDec()) has two arguments -

//aAddr and aValue, and it is used to set *aAddr with aValue and to increment/decrement

//respectively aAddr.

template <class TPixelType> class TPixelSet

	{

public:

	inline void EvalInc(TPixelType*& aAddr, TPixelType aValue) const

		{

		*aAddr++ = aValue;

		}

	inline void EvalDec(TPixelType*& aAddr, TPixelType aValue) const

		{

		*aAddr-- = aValue;

		}

	};

//This class is used as a template argument by CDrawEightBppBitmapCommon::XORPixels().

//and CDrawSixteenBppBitmapCommon::XORPixels()

//Each of its methods (EvalInc() and EvalDec()) has two arguments -

//aAddr and aValue, and it is used to XOR *aAddr with aValue and to increment/decrement

//respectively aAddr.

template <class TPixelType> class TPixelXor

	{

public:

	inline void EvalInc(TPixelType*& aAddr, TPixelType aValue) const

		{

		*aAddr++ ^= aValue;

		}

	inline void EvalDec(TPixelType*& aAddr, TPixelType aValue) const

		{

		*aAddr-- ^= aValue;

		}

	};

//This class is used as a template argument by CDrawEightBppBitmapCommon::ANDPixels().

//and CDrawSixteenBppBitmapCommon::ANDPixels()

//Each of its methods (EvalInc() and EvalDec()) has two arguments -

//aAddr and aValue, and it is used to AND *aAddr with aValue and to increment/decrement

//respectively aAddr.

template <class TPixelType> class TPixelAnd

	{

public:

	inline void EvalInc(TPixelType*& aAddr, TPixelType aValue) const

		{

		*aAddr++ &= aValue;

		}

	inline void EvalDec(TPixelType*& aAddr, TPixelType aValue) const

		{

		*aAddr-- &= aValue;

		}

	};

//This class is used as a template argument by CDrawEightBppBitmapCommon::ORPixels().

//and CDrawSixteenBppBitmapCommon::ORPixels()

//Each of its methods (EvalInc() and EvalDec()) has two arguments -

//aAddr and aValue, and it is used to OR *aAddr with aValue and to increment/decrement

//respectively aAddr.

template <class TPixelType> class TPixelOr

	{

public:

	inline void EvalInc(TPixelType*& aAddr, TPixelType aValue) const

		{

		*aAddr++ |= aValue;

		}

	inline void EvalDec(TPixelType*& aAddr, TPixelType aValue) const

		{

		*aAddr-- |= aValue;

		}

	};

//This template function should be used every time when a rectangle has to be drawn instead of

//a single pixel in EColor256/EColor64K scaled device.

//aPixelPtr - points to the pixel memory address, which contains top-left corner of the rectangle.

//aValue - the pixel value - EColor256.

//aPixelPtrRowLimit - the right end address of the scalline.

//aBitsStart - beginning address of the pixel memory.

//aBitsEnd - end address of the pixel memory.

//aLongWidth - aligned scanline width in pixels.

//aFx - X-axis scaling factor.

//aFy - Y-axis scaling factor.

//aOrientation - device's orientation.

//aOp - the operation, which must be applied to every pixel from the rectangle - template parameter.

template <class TPixelOp, class TPixelType>

inline void FillScaledRect(TPixelType* aPixelPtr,

						   const TPixelType aValue,

						   const TPixelType* aPixelPtrRowLimit,

						   const TPixelType* aBitsStart,

						   const TPixelType* aBitsEnd,

						   const TInt aLongWidth,

						   TInt aFx,

						   TInt aFy,

						   const CFbsDrawDevice::TOrientation aOrientation,

						   const TPixelOp& aOp)

	{

	if(aOrientation == CFbsDrawDevice::EOrientationNormal)

		{

		//for example: if aFx = 3 and aFy = 2 then

		//the following pixel values have to be evaluated:

		// (aPixelPtr), (aPixelPtr + 1),  (aPixelPtr + 2)

		// (aPixelPtr + aLongWidth), (aPixelPtr + 1 + aLongWidth), (aPixelPtr + 2 + aLongWidth)

		const TPixelType* nextStop = aPixelPtr + aFx;//the address of next scaled pixel value

		if(nextStop > aPixelPtrRowLimit)

			{//If the address is after the end of the current row, set it to the end of row.

			nextStop = aPixelPtrRowLimit;

			}

		do  //Fill pixel rectangle [aFx,aFy]

			{

			while(aPixelPtr < nextStop)

				{//Fill a row of up to aFx pixels.

				aOp.EvalInc(aPixelPtr, aValue);

				}

			aPixelPtr += (aLongWidth - aFx);//Move aPixelPtr to the next row

			if(aPixelPtr >= aBitsEnd)

				{//If aPixelPtr points after the end of video memory - stop the operation!

				break;

				}

			nextStop += aLongWidth;//Move nextPixelAddr to the next row

			}

		while(--aFy);

		return;

		}

	if(aOrientation == CFbsDrawDevice::EOrientationRotated90)

		{

		//for example: if aFy = 3 and aFx = 2 then

		//the following pixel values have to be evaluated:

		// (aPixelPtr), (aPixelPtr - 1),

		// (aPixelPtr + aLongWidth), (aPixelPtr - 1 + aLongWidth),

		// (aPixelPtr + 2 * aLongWidth), (aPixelPtr - 1 + 2 * aLongWidth),

		const TPixelType* pixelPtrPrevRowLimit = aPixelPtrRowLimit - aLongWidth;

		const TPixelType* nextStop = aPixelPtr - aFx;//the address of next scaled pixel value

		if(nextStop < pixelPtrPrevRowLimit)

			{//If the address is before the beginning of the current row, set it to the beginning of row.

			nextStop = pixelPtrPrevRowLimit;

			}

		do  //Fill pixel rectangle [aFx,aFy]

			{

			while(aPixelPtr > nextStop)

				{//Fill a row of up to aFy pixels.

				aOp.EvalDec(aPixelPtr, aValue);

				}

			aPixelPtr += (aLongWidth + aFx);//Move aPixelPtr to the next row

			if(aPixelPtr >= aBitsEnd)

				{//If aPixelPtr points after the end of video memory - stop the operation!

				break;

				}

			nextStop += aLongWidth;//Move nextPixelAddr to the next row

			}

		while(--aFy);

		return;

		}

	if(aOrientation == CFbsDrawDevice::EOrientationRotated180)

		{

		//for example: if aFx = 3 and aFy = 2 then

		//the following pixel values have to be evaluated:

		// (aPixelPtr), (aPixelPtr - 1),  (aPixelPtr - 2)

		// (aPixelPtr - aLongWidth), (aPixelPtr + 1 - aLongWidth), (aPixelPtr + 2 - aLongWidth)

		const TPixelType* pixelPtrPrevRowLimit = aPixelPtrRowLimit - aLongWidth;

		const TPixelType* nextStop = aPixelPtr - aFx;//the address of next scaled pixel value

		if(nextStop < pixelPtrPrevRowLimit)

			{//If the address is before the beginning of the current row, set it to the beginning of row.

			nextStop = pixelPtrPrevRowLimit;

			}

		do  //Fill pixel rectangle [aFx,aFy]

			{

			while(aPixelPtr > nextStop)

				{//Fill a row of up to aFx pixels.

				aOp.EvalDec(aPixelPtr, aValue);

				}

			aPixelPtr -= (aLongWidth - aFx);//Move aPixelPtr to the prev row

			if(aPixelPtr < aBitsStart)

				{//If aPixelPtr points before the beginning of video memory - stop the operation!

				break;

				}

			nextStop -= aLongWidth;//Move nextPixelAddr to the prev row

			}

		while(--aFy);

		return;

		}

	else //if(aOrientation == CFbsDrawDevice::EOrientationRotated270)

		{

		//for example: if aFy = 3 and aFx = 2 then

		//the following pixel values have to be evaluated:

		// (aPixelPtr), (aPixelPtr + 1)

		// (aPixelPtr - aLongWidth), (aPixelPtr + 1 - aLongWidth)

		// (aPixelPtr - 2 * aLongWidth), (aPixelPtr + 1 - 2 * aLongWidth)

		const TPixelType* nextStop = aPixelPtr + aFx;//the address of next scaled pixel value

		if(nextStop > aPixelPtrRowLimit)

			{//If the address is after the end of the current row, set it to the end of row.

			nextStop = aPixelPtrRowLimit;

			}

		do  //Fill pixel rectangle [aFx,aFy]

			{

			while(aPixelPtr < nextStop)

				{//Fill a row of up to aFy pixels.

				aOp.EvalInc(aPixelPtr, aValue);

				}

			aPixelPtr += (-aLongWidth - aFx);//Move aPixelPtr to the prev row

			if(aPixelPtr < aBitsStart)

				{//If aPixelPtr points befor the beginning of video memory - stop the operation!

				break;

				}

			nextStop -= aLongWidth;//Move nextPixelAddr to the prev row

			}

		while(--aFy);

		return;

		}

	}

/**

@publishedPartner

*/

NONSHARABLE_CLASS(CDrawBitmap) : public CFbsDrawDevice,

                                 public MScalingSettings,

                                 public MDrawDeviceOrigin,

                                 public MAlphaBlend,

                                 public MOutlineAndShadowBlend,

                                 public MDrawDeviceOrientation,

								 public MFastBlend

	{

public:

	virtual ~CDrawBitmap();

	// From CFbsDrawDevice

	virtual TDisplayMode DisplayMode() const { return iDispMode; }

	virtual TInt LongWidth() const;

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

	virtual TRgb ReadPixel(TInt aX,TInt aY) const;

	virtual void ReadLine(TInt aX,TInt aY,TInt aLength,TAny* aBuffer,TDisplayMode aDispMode) const;

	virtual TUint32* ScanLineBuffer() const;

	virtual TInt ScanLineBytes() const;

	virtual TDisplayMode ScanLineDisplayMode() const { return iDispMode; }

	virtual TSize SizeInPixels() const;

	virtual TInt HorzTwipsPerThousandPixels() const { return 0; }

	virtual TInt VertTwipsPerThousandPixels() const { return 0; }

	virtual void OrientationsAvailable(TBool aOrientation[4]);

	virtual void WriteRgb(TInt aX,TInt aY,TRgb aColor,CGraphicsContext::TDrawMode aDrawMode);

	virtual void WriteBinary(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,TInt aHeight,TRgb aColor,CGraphicsContext::TDrawMode aDrawMode);

	virtual void WriteBinaryLine(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,TRgb aColor,CGraphicsContext::TDrawMode aDrawMode);

	virtual void WriteBinaryLineVertical(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,TRgb aColor,CGraphicsContext::TDrawMode aDrawMode,TBool aUp);

	virtual void WriteLine(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer ,CGraphicsContext::TDrawMode);

	virtual void WriteRgbMulti(TInt aX,TInt aY,TInt aWidth,TInt aLength,TRgb aColor,CGraphicsContext::TDrawMode);

	virtual void SetBits(TAny* aBits);

	virtual void SetDitherOrigin(const TPoint& aPoint);

	virtual void SetShadowMode(TShadowMode aShadowMode) { iShadowMode = aShadowMode; }

	virtual void SetFadingParameters(TUint8 aBlackMap,TUint8 aWhiteMap);

	virtual void SetUserDisplayMode(TDisplayMode aDisplayMode) { iUserDispMode = aDisplayMode; }

	virtual TBool SetOrientation(TOrientation aOrientation);

	virtual void WriteRgbAlphaLine(TInt aX,TInt aY,TInt aLength,

                                   TUint8* aRgbBuffer, TUint8* aMaskBuffer,

                                   CGraphicsContext::TDrawMode aDrawMode);

	virtual void WriteRgbAlphaLine(TInt aX,TInt aY,TInt aLength,

								const TUint8* aRgbBuffer1,

								const TUint8* aBuffer2,

								const TUint8* aMaskBuffer,

								CGraphicsContext::TDrawMode aDrawMode);

	virtual TInt GetInterface(TInt aInterfaceId, TAny*& aInterface);

	virtual void GetDrawRect(TRect& aDrawRect) const;

	virtual void SwapWidthAndHeight();

	// From MScalingSettings

	virtual TInt Set(TInt aFactorX, TInt aFactorY, TInt aDivisorX, TInt aDivisorY);

	virtual void Get(TInt& aFactorX, TInt& aFactorY, TInt& aDivisorX, TInt& aDivisorY);

	virtual TBool IsScalingOff();

	// From MDrawDeviceOrigin

	virtual TInt Set(const TPoint& aOrigin);

	virtual void Get(TPoint& aOrigin);

	// From MDrawDeviceOrientation

	virtual CFbsDrawDevice::TOrientation Orientation();	

	// From MFastBlend

	virtual TInt FastBlendBitmap(const TPoint& aDest,CFbsDrawDevice* aSrcDrawDevice, const TRect& aSrcRect, CGraphicsContext::TDrawMode aDrawMode, TInt aShadowMode);

	virtual TInt FastBlendBitmap(const TPoint& aDest,const TUint32* aSrcBase, TInt aSrcStride, const TSize& aSrcSize, const TRect& aSrcRect, TDisplayMode aDisplayMode, CGraphicsContext::TDrawMode aDrawMode, TInt aShadowMode);

	virtual TInt FastBlendBitmapMasked(const TPoint& aDest, const TUint32* aSrcBase, TInt aSrcStride,

							const TSize& aSrcSize, const TRect& aSrcRect, TDisplayMode aSrcDisplayMode,

							const TUint32* aMaskBase, TInt aMaskStride, TDisplayMode aMaskDisplayMode, const TSize &aMaskSize,const TPoint &aMaskSrcPos,TBool aInvertMask,

							CGraphicsContext::TDrawMode aDrawMode, TInt aShadowMode);

	virtual TInt FastBlendBitmapScaled(const TRect &aClipRect, const TRect& aDest, const TRect& aSrcRect, const TUint32 *aSrcBase, TInt aSrcLinePitch, TDisplayMode aSrcDisplayMode, const TSize &aSrcSize, CGraphicsContext::TDrawMode aDrawMode, TInt aShadowMode);

	virtual TInt FastBlendBitmapMaskedScaled(const TRect &aClipRect, const TRect& aDest,

							const TRect& aSrcRect, const TUint32 *aSrcBase, TInt aSrcLinePitch,

							TDisplayMode aSrcDisplayMode, const TSize &aSrcSize,

							const TUint32* aMaskBase, TInt aMaskStride, TDisplayMode aMaskDisplayMode, const TSize &aMaskSize,TBool aInvertMask,

							CGraphicsContext::TDrawMode aDrawMode, TInt aShadowMode);

protected:

	CDrawBitmap();

	static TInt BitsPerPixel(TDisplayMode aDispMode);

	void Clear();

	void CopyOldSettings(CFbsDrawDevice* aDrawDevice);

	void DeOrientate(TInt& aX,TInt& aY) const;

	TPoint DeOrientate(const TPoint& aPoint) const;

	TRect DeOrientate(const TRect& aRect) const;

	virtual void Shadow(TRgb& aColor) = 0;

	TRgb FadeRgb(TRgb aColor);

	TUint32 FadeRgb(TUint32 aColor);

	void FadeRgb(TInt& aRed, TInt& aGreen, TInt& aBlue);

	TUint8 FadeGray(TInt aGray256);

	TUint32 Hash(TUint32 aValue,TInt aX,TInt aY) const;

	TUint32 PasteInt(TUint32 aFirst,TUint32 aSecond,TInt aOffset) const;

	static TAny* CopyOffset(TAny* aDestination,const TAny* aSource,TInt aWordsToCopy,TInt aSourceBitOffset);

	static void ReadLineCommon(TUint32* aPixelPtr,TUint32* aBufferPtr,TInt aWordsCnt,TInt aRestPixels,TInt aBytesCnt,TInt aStartDiffBits);

	virtual void SetSize(const TSize& aSize);

	// Scaling related

	TBool CanBeScaled() const;

	TInt PixelAddressIncrement() const;

	TInt LogicalPixelAddressIncrement() const;

	void SetPixelInc(TInt& aPixelInc, TInt& aRowInc) const;

	void IncScaledY(TInt& aY) const;

	void IncScaledY(TInt& aY, TInt aYOrg) const;

	//Generic set pixels operations, has to be defined here to make it compiled in VC++6.0

	template <class TPixelType>

	void SetPixels(TPixelType* aPixelPtr, TPixelType aValue, const TPixelType* aPixelPtrRowLimit,

				   const TPixelType* aBitsStart, const TPixelType* aBitsEnd) const

		{

		TPixelSet<TPixelType> op;

		::FillScaledRect(aPixelPtr, aValue, aPixelPtrRowLimit, aBitsStart, aBitsEnd, iLongWidth,

						 iScalingSettings.iFactorX, iScalingSettings.iFactorY, iOrientation, op);

		}

	template <class TPixelType>

	void XORPixels(TPixelType* aPixelPtr, TPixelType aValue, const TPixelType* aPixelPtrRowLimit,

				   const TPixelType* aBitsStart, const TPixelType* aBitsEnd) const

		{

		TPixelXor<TPixelType> op;

		::FillScaledRect(aPixelPtr, aValue, aPixelPtrRowLimit, aBitsStart, aBitsEnd, iLongWidth,

						 iScalingSettings.iFactorX, iScalingSettings.iFactorY, iOrientation, op);

		}

	template <class TPixelType>

	void ANDPixels(TPixelType* aPixelPtr, TPixelType aValue, const TPixelType* aPixelPtrRowLimit,

				   const TPixelType* aBitsStart, const TPixelType* aBitsEnd) const

		{

		TPixelAnd<TPixelType> op;

		::FillScaledRect(aPixelPtr, aValue, aPixelPtrRowLimit, aBitsStart, aBitsEnd, iLongWidth,

						 iScalingSettings.iFactorX, iScalingSettings.iFactorY, iOrientation, op);

		}

	template <class TPixelType>

	void ORPixels(TPixelType* aPixelPtr, TPixelType aValue, const TPixelType* aPixelPtrRowLimit,

				  const TPixelType* aBitsStart, const TPixelType* aBitsEnd) const

		{

		TPixelOr<TPixelType> op;

		::FillScaledRect(aPixelPtr, aValue, aPixelPtrRowLimit, aBitsStart, aBitsEnd, iLongWidth,

						 iScalingSettings.iFactorX, iScalingSettings.iFactorY, iOrientation, op);

		}

	//Origin related

	TBool CanOriginBeMoved() const;

	void MapColorToUserDisplayMode(TInt& red,TInt& green,TInt& blue);

protected:

	virtual void InvertBuffer(TInt aLength,TUint32* aBuffer) = 0;

	virtual TRgb ReadRgbNormal(TInt aX,TInt aY) const = 0;

	virtual void ReadLine(TInt aX,TInt aY,TInt aLength,TAny* aBuffer) const = 0;

	virtual TUint32* ScanLine(TInt aY) const;

	virtual void WriteRgbMultiXOR(TInt aX,TInt aY,TInt aWidth,TInt aLength,TRgb aColor) = 0;

	virtual void WriteRgbMultiAND(TInt aX,TInt aY,TInt aWidth,TInt aLength,TRgb aColor) = 0;

	virtual void WriteRgbMultiOR(TInt aX,TInt aY,TInt aWidth,TInt aLength,TRgb aColor) = 0;

	virtual void WriteLineXOR(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer) = 0;

	virtual void WriteLineAND(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer) = 0;

	virtual void WriteLineOR(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer) = 0;

	virtual void WriteRgb(TInt aX,TInt aY,TRgb aColor) = 0;

	virtual void WriteBinary(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,TInt aHeight,TRgb aColor) = 0;

	virtual void WriteBinaryOp(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,TInt aHeight,TRgb aColor,CGraphicsContext::TDrawMode aDrawMode) = 0;

	virtual void WriteBinaryLineVertical(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,TRgb aColor,TBool aUp) = 0;

	virtual void WriteRgbMulti(TInt aX,TInt aY,TInt aWidth,TInt aLength,TRgb aColor) = 0;

	virtual void BlendRgbMulti(TInt aX,TInt aY,TInt aWidth,TInt aLength,TRgb aColor);

	virtual void WriteLine(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer) = 0;

	virtual void BlendLine(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer);

	virtual void MapColorToUserDisplayMode(TRgb& /*aColor*/) {}

	virtual void MapBufferToUserDisplayMode(TInt /*aLength*/,TUint32* /*aBuffer*/) {}

private:

	void GetBlendPosAndRect(TRect &aSrcRect, const TRect &aSrcRectIn, const TSize &aSrcSize, const TPoint &aDestOffset);

	void GetBlendPosAndRect(TRect &aDstRect, TRect &aSrcRect, const TRect &aDestRectIn, const TRect &aSrcRectIn, const TSize &aSrcSize);

	TBool FastBlendSupported(TDisplayMode aSrcDisplayMode, CGraphicsContext::TDrawMode aDrawMode, TInt aShadowMode, TInt aSrcLinePitch);

	TBool FastBlendMaskSupported(TDisplayMode aMaskDisplayMode, TInt aMaskStride);

	void DoCopyOldSettings(CFbsDrawDevice* aDrawDevice);

	TInt DoFastBlendBitmap(const TPoint &aDest, const TRect& aSrcRect, const TUint8 *aSrcBase, TInt aSrcLinePitch, TDisplayMode aSrcDisplayMode, const TSize &aSrcSize);

	// Scaling related

	void InitLogicalCoordinates();

	void PreWriteRgb(TInt& aWidth, TInt& aHeight, TInt& aX, TInt& aY, CGraphicsContext::TDrawMode aDrawMode);

	void WriteRgb(TInt& aWidth, TInt& aHeight, TInt& aX, TInt& aY, TRgb aColor, CGraphicsContext::TDrawMode aDrawMode);

	void SetDefaults();

	inline TInt Origin(TInt aPhysOrg, TInt aScale) const;

	inline TInt OtherSide(TInt aPhysOrg, TInt aPhysSize, TInt aScale) const;

protected:

	TDisplayMode iDispMode;

	TInt iLongWidth; // aligned scanline width in pixels

	TPoint iDitherOrigin;

	TUint32* iScanLineBuffer;

	TInt iScanLineWords;

	TShadowMode iShadowMode;

	TSize iSize; // (0, 0, iSize.iWidth, iSize.iHeight) - drawing rectangle - physical coordinates

	TUint32* iBits;

	TDisplayMode iUserDispMode;

	TOrientation iOrientation; // 0, 90, 180, 270 degrees

	TInt iFadeMapFactor;

	TInt iFadeMapOffset;

	TScalingSettings iScalingSettings; // X-axis and Y-axis scaling factors

	TOrigin iOrigin; // drawing device origin

	TBool iScalingOff; // ETrue, if the scaling is off.

	TBool iOriginIsZero; // ETrue, if the origin is (0, 0).

	TRect iDrawRect; // drawing rectangle - logical coordinates

    MAlphaBlend* iAlphaBlend; // Alphablending interface

	};

/**

@publishedPartner

*/

NONSHARABLE_CLASS(CDrawOneBppBitmap) : public CDrawBitmap

	{

public:

	TInt Construct(TSize aSize);

	TInt Construct(TSize aSize, TInt aStride);

	virtual void InvertBuffer(TInt aLength,TUint32* aBuffer);

	virtual TRgb ReadRgbNormal(TInt aX,TInt aY) const;

	virtual void ShadowArea(const TRect& aRect);

	virtual void WriteRgbMultiXOR(TInt aX,TInt aY,TInt aWidth,TInt aLength,TRgb aColor);

	virtual void WriteRgbMultiAND(TInt aX,TInt aY,TInt aWidth,TInt aLength,TRgb aColor);

	virtual void WriteRgbMultiOR(TInt aX,TInt aY,TInt aWidth,TInt aLength,TRgb aColor);

	virtual void WriteLineXOR(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer);

	virtual void WriteLineAND(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer);

	virtual void WriteLineOR(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer);

	virtual void WriteRgb(TInt aX,TInt aY,TRgb aColor);

	virtual void WriteBinary(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,TInt aHeight,TRgb aColor);

	virtual void WriteBinaryOp(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,TInt aHeight,TRgb aColor,CGraphicsContext::TDrawMode aDrawMode);

	virtual void WriteBinaryLineVertical(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,TRgb aColor,TBool aUp);

	virtual void WriteRgbMulti(TInt aX,TInt aY,TInt aWidth,TInt aLength,TRgb aColor);

	virtual void WriteLine(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer);

	virtual void WriteRgbAlphaMulti(TInt aX,TInt aY,TInt aLength,TRgb aColor,const TUint8* aMaskBuffer);

protected:

	virtual void SetSize(const TSize& aSize);

	virtual void ReadLine(TInt aX,TInt aY,TInt aLength,TAny* aBuffer) const;

	virtual void Shadow(TRgb& aColor);

	void ShadowBuffer(TInt aLength,TUint32* aBuffer);

private:

	TUint32 ColorWord(TRgb aColor) const;

	virtual void WriteRgbAlphaLine(TInt aX,

                                   TInt aY,

                                   TInt aLength,

                                   const TUint8* aRgbBuffer,

                                   const TUint8* aMaskBuffer,

                                   MAlphaBlend::TShadowing aShadowing,

                                   CGraphicsContext::TDrawMode aDrawMode);

	// From MOutlineAndShadowBlend

	virtual TInt WriteRgbOutlineAndShadow(TInt aX, TInt aY, const TInt aLength, 

	                                   TUint32 aOutlinePenColor, TUint32 aShadowColor, 

	                                   TUint32 aFillColor, const TUint8* aDataBuffer);

	};