// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#ifndef __GRAPHICSACCELERATOR_H__

#define __GRAPHICSACCELERATOR_H__

#include <e32std.h>

#include <gdi.h>

//

// Bitmaps

//

// Forward references

class CFbsBitmap;

class TAcceleratedBitmapSpec;

/**

A data structure that holds the information needed to directly access a bitmap.

The bitmap can be a hardware bitmap (RHardwareBitmap), or an ordinary bitmap 

(CFbsBitmap). An object of this class is filled by calling TAcceleratedBitmapSpec::GetInfo().

@see RHardwareBitmap

@see CFbsBitmap

@see TAcceleratedBitmapSpec::GetInfo() 

@publishedAll

@released

*/

class TAcceleratedBitmapInfo

	{

public:

    /** The bitmap's display mode. */

	TDisplayMode	iDisplayMode;

	/** The address of the start of the bitmap. */

	TUint8*			iAddress;

	/** The width and height of the bitmap in pixels. */

	TSize			iSize;

	/** The address offset (in bytes) between successive lines in a bitmap. */

	TInt			iLinePitch;

	/** The shift required to obtain the number of bits needed to represent one pixel in the bitmap.

	The number of bits per pixel is calculated as 1 << iPixelShift */

	TInt			iPixelShift;

	/** The physical address of the start of the bitmap. This is the address which a 

	hardware graphics accelerator will use and is zero if the bitmap is not accessible 

	to hardware graphics accelerators. */

	TUint8*			iPhysicalAddress;

	};

/**

The interface to a hardware bitmap.

This is a bitmap that can be drawn to by graphics acceleration hardware. It 

is stored in a contiguous area of physical memory.

After creating the hardware bitmap, it can be passed to CHardwareGraphicsAccelerator::NewL().

@see CHardwareGraphicsAccelerator::NewL() 

@publishedAll

@released

*/

class RHardwareBitmap

	{

	friend class CBitwiseBitmap;

	friend class CFbsScreenDevice;

public:

    /** Default constructor. */

	inline RHardwareBitmap();

    /** Constructor taking the handle of an existing RHardwareBitmap to duplicate it. */

	inline RHardwareBitmap(TInt aHandle);

	/** 

	Gets the information needed for accessing a bitmap directly into TAcceleratedBitmapInfo structure.

	@param aInfo On return, holds the information needed to directly access the	bitmap.

	@return KErrNone if sucessful, otherwise one of the system error codes, including 

	KErrUnknown if the object's type is ENoBitmap. 

	*/

	IMPORT_C TInt GetInfo(TAcceleratedBitmapInfo& aInfo) const;

private:

	IMPORT_C TInt SetAsScreenReference(TInt aScreen=-1);

	IMPORT_C TInt Create(TDisplayMode aDisplayMode, TSize aSize, TUid aCreatorUid);

	IMPORT_C void Destroy();

public:

	/** The bitmap's handle; assigned during construction. This is used to identify 

	the bitmap. */

	TInt iHandle;	// Must be only member data

	};

	/** Default constructor. Initialises the handle to zero. */

inline RHardwareBitmap::RHardwareBitmap()

	: iHandle(0)

	{}

	/** Constructor taking the handle of an existing RHardwareBitmap to duplicate.

	@param aHandle The RHardwareBitmap handle to duplicate. */

inline RHardwareBitmap::RHardwareBitmap(TInt aHandle)

	: iHandle(aHandle)

	{}

/**

Maintains a count of the number of locks made on a bitmap through a TAcceleratedBitmapSpec 

object.

Passed as a parameter to TAcceleratedBitmapSpec::Lock() and TAcceleratedBitmapSpec::Unlock().

@see TAcceleratedBitmapSpec 

@publishedAll

@released

*/

class TBitmapLockCount

	{

	friend class TAcceleratedBitmapSpec;

public:

	/** Default constructor. Initialises the lock count to zero. */

	inline TBitmapLockCount() : iCount(0) {}

private:

	inline TInt Inc() { return iCount++; }

	inline TInt Dec() { return --iCount; }

private:

	TInt iCount;

	};

/**

A utility class that provides access to the contents of a bitmap.

The bitmap can be a hardware bitmap (RHardwareBitmap), or an ordinary bitmap 

(CFbsBitmap). An object of this class is used as a parameter by several accelerated 

graphics operations, e.g. TGopBitBlt, to specify the source bitmap for the 

operation. 

@publishedAll

@released

*/

class TAcceleratedBitmapSpec

	{

public:

	// Constructors

	inline TAcceleratedBitmapSpec();

	IMPORT_C TAcceleratedBitmapSpec(CFbsBitmap* aBitmap);

	IMPORT_C TAcceleratedBitmapSpec(RHardwareBitmap aBitmap);

	// Bitmap access (use with caution, see documentation)

	IMPORT_C TInt GetInfo(TAcceleratedBitmapInfo& aInfo) const;

	inline void Lock(TBitmapLockCount& aCount);

	inline void Lock(TBitmapLockCount& aCount,TAcceleratedBitmapInfo& aInfo);

	inline void	Unlock(TBitmapLockCount& aCount);

	// enums

	/** Identifies the type of the bitmap.

	Type() returns this value.

	@see CFbsBitmap */

	enum TAcceleratedBitmapType

		{

	/** The object was created using the default constructor, and has no type. */

		ENoBitmap,

	/** The bitmap is of type CFbsBitmap.

	@see CFbsBitmap */

		EFbsBitmap,

	/** The bitmap is of type RHardwareBitmap.

	@see RHardwareBitmap */

		EHardwareBitmap,

		};

	enum TAcceleratedBitmapLock

		{

		EBitmapIsStatic,

		EBitmapNeedsLocking,

		};

	// Getters

	inline TAcceleratedBitmapType	Type() const;

	inline TInt						Handle() const;

private:

	IMPORT_C void DoLock(TBitmapLockCount& aCount);

	IMPORT_C void DoLock(TBitmapLockCount& aCount,TAcceleratedBitmapInfo& aInfo);

	IMPORT_C void DoUnlock(TBitmapLockCount& aCount);

private:

	TUint8	iType;			// TAcceleratedBitmapType

	TUint8	iLockStatus;	// TAcceleratedBitmapLock

	TUint8	iSpare1;

	TUint8	iSpare2;

	TInt	iHandle;

	};

	/** Default constructor. 

	Use one of the other constructor overloads instead. */

inline TAcceleratedBitmapSpec::TAcceleratedBitmapSpec()

	: iType(ENoBitmap), iLockStatus(EBitmapIsStatic)

	{}

	/** Prevents a bitmap from moving in memory. Lock() should be called before accessing 

	the bitmap and Unlock() immediately afterwards. Although it is not necessary 

	to lock and unlock some types of bitmap, it is a small overhead, and it is 

	recommended that you always do it.

	If a bitmap is already locked, all uses of the Lock() and Unlock() methods 

	within the same thread must use the same TBitmapLockCount object, even if 

	Lock() and Unlock() are called by different instances of TAcceleratedBitmapSpec.

	@param aCount Maintains a count of the number of locks made on the bitmap. */

inline void TAcceleratedBitmapSpec::Lock(TBitmapLockCount& aCount)

	{ if(iLockStatus==EBitmapNeedsLocking) DoLock(aCount); }

	/** Prevents a bitmap from moving in memory. Lock() should be called before accessing 

	the bitmap and Unlock() immediately afterwards. Although it is not necessary 

	to lock and unlock some types of bitmap, it is a small overhead, and it is 

	recommended that you always do it. Also updates a TAcceleratedBitmapInfo structure 

	with any information that may have changed, (typically the bitmap's memory 

	address).

	If a bitmap is already locked, all uses of the Lock() and Unlock() methods 

	within the same thread must use the same TBitmapLockCount object, even if 

	Lock() and Unlock() are called by different instances of TAcceleratedBitmapSpec.

	@param aCount Maintains a count of the number of locks made on the bitmap.

	@param aInfo On return, contains the new address of the start of the bitmap. */

inline void TAcceleratedBitmapSpec::Lock(TBitmapLockCount& aCount,TAcceleratedBitmapInfo& aInfo)

	{ if(iLockStatus==EBitmapNeedsLocking) DoLock(aCount,aInfo); }

	/** Frees a bitmap after a call to Lock().  A call to Unlock() must be made for each corresponding

	call to Lock(). This function should be called as soon as any bitmap access has finished. If, after

	the Unlock() operation, no more calls to Lock() are outstanding on the bitmap, the bitmap is free to

	be moved in memory again.

	If a bitmap is already locked, all uses of the Lock() and Unlock() methods 

	within the same thread must use the same TBitmapLockCount object, even if 

	Lock() and Unlock() are called by different instances of TAcceleratedBitmapSpec.

	@param aCount Maintains a count of the number of locks made on the bitmap. */

inline void	TAcceleratedBitmapSpec::Unlock(TBitmapLockCount& aCount)

	{ if(iLockStatus==EBitmapNeedsLocking) DoUnlock(aCount); }

	/** Returns the type of the bitmap. The type is assigned during construction.

	@return The type of bitmap. */

inline TAcceleratedBitmapSpec::TAcceleratedBitmapType TAcceleratedBitmapSpec::Type() const

	{ return (TAcceleratedBitmapSpec::TAcceleratedBitmapType)iType; }

	/** Returns the handle to the bitmap.

	@return The handle to the bitmap. */

inline TInt TAcceleratedBitmapSpec::Handle() const

	{ return iHandle; }

//

// Accelerator capabilities

//

/**

Enumerates the four transparency types.

ETransparentPixel and ETransparentColor are used with a pixel value or a TRgb 

respectively.

@see TGopTransparency

@see TGraphicsAcceleratorCaps::iTransparency 

@publishedAll

@released

*/

enum TTransparencyType

	{

	/** Any pixel that has all bits equal to zero is treated as transparent. */

	ETransparentPixelZero,

	/** Any pixel that is equal to the pixel value passed to the TGopTransparency constructor 

	is treated as transparent. */

	ETransparentPixel,

	/** Any pixel that is equal to the TRgb value passed to the TGopTransparency constructor 

	is treated as transparent. */

	ETransparentColor,

	/** In 16 bits per pixel display mode, which uses 5 bits each for red, green and 

	blue, the most significant bit is an Alpha value. Alpha=0 means the pixel 

	is transparent, Alpha=1 means the pixel is fully opaque. */

	ETransparent1555,

	};

/** 

Stores the capabilities of a graphics accelerator.

All of the member enums except TMaskBitmapCaps define flags that are stored 

as public data of type TUint. Only TMaskBitmapCaps takes sequential values, 

so its values are mutually exclusive.

An object of this class is returned by CGraphicsAccelerator::Capabilities() 

or by GenericCapabilities(), which is implemented by CSoftwareGraphicsAccelerator 

and CHardwareGraphicsAccelerator.

@see CGraphicsAccelerator::Capabilities() 

@publishedAll

@released

*/

class TGraphicsAcceleratorCaps

	{

public:

    /** Clipping capabilities. Used by the iClipping member.

    @see CGraphicsAccelerator::Operation() */

	enum TClipCaps	// Bit flags

		{

		EClipToBitmap = 1,	// Will always clip all operations to the bitmap

	    /** The accelerator supports the Operation() methods which take clipping rectangles 

	    as parameters.

	    @see CGraphicsAccelerator::Operation() */

		EClipping = 2		// Is able to clip operations to a region

		};

/** Enumerates the capabilities relating to operations taking a bitmap mask parameter, 

for instance TGopBitBltMasked. These are mutually exclusive values used by 

the iMaskType member. */

	enum TMaskBitmapCaps	// Enum

		{

	/** No masked operations are supported. */

		EMaskBitmapNone = 0,

	/** The mask bitmap can be in any display mode at all. */

		EMaskBitmapAnyDisplayMode,

	/** The mask bitmap must be in the same display mode as the destination bitmap. */

		EMaskBitmapMatchingDisplayMode,

	/** The mask bitmap must be in EGray2 display mode. */

		EMaskBitmapGray2,

		};

/** Bit flags for the capabilities relating to operations that use an alpha channel 

(TGopBitBltAlphaChannel and TGopScaledBitBltAlphaChannel). These flags are 

used by the iAlphaChannel member. */

	enum TAlphaChannelCaps	//Bit flags

    	{

	/** The accelerator can draw bitmaps with 4 bits each for the alpha value and the 

	red, green and blue components. */

		EAlpha4444 = 1,	// Bitmaps with 4 bits for Alpha value and Red, Green, Blue components

	/** The accelerator can draw bitmaps with 8 bits each for the alpha value and the 

	red, green and blue components. */

		EAlpha8888 = 2, // Bitmaps with 8 bits for Alpha value and Red, Green, Blue components

	/** The accelerator can draw bitmaps with 1 bit for the alpha value and and 5 bits 

	for the red, green and blue components. */

		EAlpha1555 = 4, // Bitmaps with 1 bit for Alpha value and 5 bits for Red, Green, and Blue

		};

/** Bit flags for the capabilities relating to operations which take an alpha bitmap 

parameter, for instance TGopBitBltAlphaBitmap. These flags are used by the 

iAlphaBitmap member. */

	enum TAlphaBitmapCaps	//Bit flags

    	{

	/** For 256 greyscale bitmaps, the value of each pixel in the alpha bitmap (from 

	0 to 255) is used as the alpha value. */

		EAlphaBitmapGray256 = 1,

	/** An EColor16M bitmap may be used as the alpha bitmap. The red, green and blue 

	values for each pixel in this bitmap are used as the alpha values for the 

	red, green and blue components of the corresponding pixel in the source bitmap. */

		EAlphaBitmapColor16M = 2,

	/** The alpha bitmap must have the same display mode as the source bitmap. */

		EAlphaBitmapMatchingMode = 4,	// Alpha bitmap must be same mode as source

		};

/** Indicates whether there is a restriction on the sizes of bitmaps that can be 

used in bitmap patterns.

This is one of the possible values for the iPatternSizes member.

@see TGopFillPattern */

	enum TPatternSizeCaps	//Bit flags

		{

	/** There is no restriction on the dimensions of bitmap patterns. */

		EPatternSizeAny = 0xFFFFFFFF,

		};

/** Bit flags for the capabilities relating to operations that draw a fill pattern 

using a bitmap, for instance TGopFilledRectWithPatern. They are used in the 

iPattern member. */

	enum TPatternCaps	//Bit flags

		{

	/** The pattern bitmap can be in any display mode. */

		EPatternAnyDisplayMode = 1,			// Patterns can be in any supported display mode

	/** The pattern bitmap must be in the same display mode as the destination. */

		EPatternMatchingDisplayMode = 2,	// Pattern must be in same displ mode as target

	/** The pattern bitmap must be square (width==height). */

		EPatternMustBeSquare = 4,			// The pattern must be square (width==height)

		};

/** Bit flags for how self-crossing polygons are filled.

@see CGraphicsContext::TFillRule */

	enum TPolygonCaps	// Bit flags for fill rules (see CGraphicsContext::TFillRule)

		{

	/** Only areas with odd winding numbers are filled. */

		EPolygonFillAlternate = 1,

	/** All areas with a winding number greater than zero are filled.

	@see CGraphicsContext::TFillRule */

		EPolygonFillWinding = 2,

		};

/** Bit flags for the specifying the supported rendering orientations. 

@see  CFbsBitGc::TGraphicsOrientation */

	enum TOrientationCaps

		{

		/** Normal orientation is supported. */

		EOrientationCapNormal = 1,

		/** A 90 degree rotation is supported. */

		EOrientationCapRotated90 = 2,

		/** A 180 degree rotation is supported. */

		EOrientationCapRotated180 = 4,

		/** A 270 degree rotation is supported. */

		EOrientationCapRotated270 = 8,

		/** All orientations are supported. */ 

		EOrientationCapAll = EOrientationCapNormal|EOrientationCapRotated90|EOrientationCapRotated180|EOrientationCapRotated270,

		};

	/** The size of this class in bytes. */

	TInt			iStructureSize;	// The size of this class

	/** The version number of the API. */

	TInt			iVersion;		// == 1 to specify current API

	/** Optional UID to identify the vendor of the graphics accelerator. This UID can 

	be used to recognise a particular accelerator, enabling code to use any custom 

	graphics operations and capabilities that it knows the accelerator provides. */

	TUid			iVendorUid;		// Optional ID

	/** A bit mask of the supported display modes for the bitmap passed to the graphics 

	accelerator's NewL(). Uses the least significant 11 bits as flags for each 

	TDisplayMode supported. For instance, to check whether the EColor256 display 

	mode is available, use the expression iDisplayModes & (1 << EColor256).

	@see TDisplayMode */

	TUint			iDisplayModes;	// One bit for each TDisplayMode enumeration

	/** Indicates whether the Operation() methods which take clipping rectangles as 

	parameters are supported.

	@see TClipCaps */

	TUint			iClipping;		// TClipCaps bit flags

	/** Specifies the display mode restrictions for bitmap masks. These are mutually 

	exclusive values.

	@see TMaskBitmapCaps */

	TMaskBitmapCaps	iMaskType;		// Mask type used

	/** Specifies the transparency types supported. Uses a bit flag for each TTransparencyType 

	supported.

	@see TTransparencyType */

	TUint			iTransparency;	// Bit flag for each TTransparencyType supported

	/** Specifies the capabilities relating to operations that use an alpha channel. Uses a bit flag for

	each TAlphaChannelCaps supported.

	@see TAlphaChannelCaps */

	TUint			iAlphaChannel;	// TAlphaChannelCaps bit flags

	/** Specifies the supported alpha bitmap types. Uses a bit flag for each TAlphaBitmapCaps 

	supported.

	@see TAlphaBitmapCaps */

	TUint			iAlphaBitmap;	// TAlphaBitmapCaps bit flags

	/** Specifies the sizes of bitmaps that can be used in bitmap patterns.

	This is a bitmask for each power of 2, or EPatternSizeAny. For example, if 

	bitmaps used in patterns can only have a width or height of 16 pixels then 

	this value should be set to 16. If patterns can have dimensions of 16, 32, 

	64, 128 or 256, then this value would equal the sum of these, (i.e. bits 4, 

	5, 6, 7 and 8 would be set).  If this value is equal to EPatternSizeAny, there

	are no restrictions on the size of patterns that can be used.

	@see TPatternSizeCaps */

	TUint			iPatternSizes;	// a mask bit for each power of 2, or EPatternSizeAny

	/** Specifies the supported bitmap types for fill patterns. Uses a bit flag for 

	each TPatternCaps supported.

	@see TPatternCaps */

	TUint			iPattern;		// TPatternCaps bit flags

	/** Specifies the supported fill rules for self crossing polygons. Uses a bit flag 

	for each TPolygonCaps supported.

	@see TPolygonCaps */

	TUint			iPolygon;		// TPolygonCaps bit flags

	/** 

	iReserved[0] specifies the supported rendering orientations.Uses a bit flags

	for each TOrientationCaps supported.	

	@see TOrientationCaps 

	iReserved[1]-iReserved[3] are reserved for future use. All should be set to zero.

	*/

	TUint			iReserved[4];

	};

//

// TGraphicsOperation

//

/**

Abstract base class for all graphics operations.

Derived classes encapsulate all the arguments needed by a given graphics operation. 

An object of one of the derived classes is passed as a parameter to CGraphicsAccelerator::Operation(). 

The member functions and enum defined in this class are not used directly 

in third party code.

@see CGraphicsAccelerator::Operation() 

@publishedAll

@released

*/

class TGraphicsOperation

	{

public:

	enum TGopFunction

		{								// Require arguments commented below here

		EFilledRect,					// (TRect,TRgb)

		EFilledRectUsingDrawMode,		// (TRect,TRgb,CGraphicsContext:TDrawMode)

		EFilledRectWithPattern,			// (TRect,TGopFillPattern)

		EInvertRect,					// (TRect)

		EFadeRect,						// (TRect,TGopFadeParams)

		EBitBlt,						// (TPoint,TAcceleratedBitmapSpec,TRect&)

		EBitBltMasked,					// (TPoint,TAcceleratedBitmapSpec,TRect&,TAcceleratedBitmapSpec aMask)

		EBitBltTransparent,				// (TPoint,TAcceleratedBitmapSpec,TRect&,TGopTransparency)

		EBitBltAlphaChannel,			// (TPoint,TAcceleratedBitmapSpec,TRect&)

		EBitBltAlphaBitmap,				// (TPoint,TAcceleratedBitmapSpec,TRect&,TAcceleratedBitmapSpec aAlpha)

		EScaledBitBlt,					// (TRect,TAcceleratedBitmapSpec,TRect&)

		EScaledBitBltMasked,			// (TRect,TAcceleratedBitmapSpec,TRect&,TAcceleratedBitmapSpec aMask)

		EScaledBitBltTransparent,		// (TRect,TAcceleratedBitmapSpec,TRect&,TGopTransparency)

		EScaledBitBltAlphaChannel,		// (TRect,TAcceleratedBitmapSpec,TRect&)

		EScaledBitBltAlphaBitmap,		// (TRect,TAcceleratedBitmapSpec,TRect&,TAcceleratedBitmapSpec aAlpha)

		EFilledPolygon,					// (TRGb aColor,CGraphicsContext::TFillRule aFillRule,TInt aNumPoints,TPoint[])

		EFilledPolygonWithPattern,		// (TGopFillPattern,CGraphicsContext::TFillRule aFillRule,TInt aNumPoints,TPoint[])

		EAlphaBlendTwoBitmaps,			// (TPoint,TAcceleratedBitmapSpec aSrce1,TAcceleratedBitmapSpec aSrce2,TRect&,TAcceleratedBitmapSpec aAlpha)

		EAlphaBlendOneBitmap,			// (TPoint,TAcceleratedBitmapSpec aSrce,TRect&,TAcceleratedBitmapSpec aAlpha)

		EChunkTest,

		EVirtualAddressTest,

		};

public:

	// Getters

	inline TGopFunction Function() const	{ return iFunction; }

	inline TInt Size() const				{ return iSize; }

	// Utility functions 

	inline TGraphicsOperation* Next() const;

	inline void Append(TInt aNumBytes,TAny* aData);

protected:

	inline TGraphicsOperation(TGopFunction aFunction, TInt aArgSize);

	inline TGraphicsOperation() {}

protected:

	TGopFunction iFunction;

	TInt iSize;  // Total size of derived class

	};

inline TGraphicsOperation::TGraphicsOperation(TGopFunction aFunction, TInt aSize)

	: iFunction(aFunction) , iSize(aSize) {}

inline TGraphicsOperation* TGraphicsOperation::Next() const

	{ return (TGraphicsOperation*)((TUint8*)this+iSize); }

inline void TGraphicsOperation::Append(TInt aNumBytes,TAny* aData)

	{

	Mem::Copy(Next(),aData,aNumBytes);

	iSize += aNumBytes;

	}

//

// Graphics accelerator

//

/**

Abstract base class for 2D graphics accelerators.

This class can be derived from to provide accelerated implementations of some 

common 2D graphics algorithms. Support for accelerated 2D graphics has been 

integrated into existing classes in the Graphics API for instance CFbsBitGc, 

so that existing code does not need to be altered, but a graphics accelerator 

can be used directly by applications. The accelerated 2D graphics operations 

may be implemented in software, hardware, or both. 

@publishedAll

@released

*/

class CGraphicsAccelerator : public CBase

	{

public:

	// Return the capabilities of this accelerator

	/** Returns the capabilities of the graphics accelerator.

	@return The capabilities of the accelerator. */

	virtual const TGraphicsAcceleratorCaps* Capabilities() = 0;

	// Perform a graphics operation

	/** Requests the graphics accelerator to perform a single graphics operation.

	@param aOperation An instance of a TGraphicsOperation-derived class that identifies 

	the graphics operation to be performed.

	@return KErrNone if successful, otherwise one of the system error codes. The 

	function should return KErrNotSupported if the accelerator does not support 

	the requested operation. */

	virtual TInt Operation(const TGraphicsOperation& aOperation) = 0;

	/** Requests the graphics accelerator perform a single graphics operation within 

	a clipping region.  This version is of Operation() is only usable if the 

	accelerator capabilities returned by Capabilities() indicate that clipping to a region

	is supported.

	@param aOperation An instance of a TGraphicsOperation-derived class that identifies 

	the graphics operation to be performed.

	@param aNumClipRects The number of rectangles in the clipping region.

	@param aClipRects A pointer to the first rectangle in the clipping region.

	@return KErrNone if successful, otherwise one of the system error codes. The 

	function should return KErrNotSupported if the accelerator does not support 

	the requested operation.

	@see TGraphicsAcceleratorCaps::iClipping */

	virtual TInt Operation(const TGraphicsOperation& aOperation,TInt aNumClipRects,TRect* aClipRects) = 0;

	// Process a buffer of TGraphicsOperation. (Each operation immediately follows the

	// one preceding it in the buffer)

	/** Requests the graphics accelerator perform one or more graphics operations contained 

	in a buffer.

	The underlying implementation may be able to process a group of graphics operations 

	more efficiently than if Operation() was called for each individually.

	This function should be implemented as if Operation() was called in turn for 

	each operation contained in the buffer. Each operation should be carried out 

	immediately after the one preceding it. If a method returns an error, the 

	length of aBuffer should be set to indicate the number of operations that 

	have been successfully processed. In this case, the operation in which the 

	error occurred will be indicated by the memory address &aBuffer[aBuffer.Length()].

	@param aBuffer A descriptor which holds a concatenation of graphics operations 

	(TGraphicsOperation-derived objects).

	@return KErrNone if successful, otherwise one of the system error codes. The 

	function should return KErrNotSupported if the accelerator does not support 

	any of the requested operations. */

	virtual TInt Operation(TDes8& aBuffer) = 0;

	/** Requests the graphics accelerator perform one or more graphics operations within 

	a clipping region.  This version is of Operation() is only usable if the 

	accelerator capabilities returned by Capabilities() indicate that clipping to a region

	is supported.

	The underlying implementation may be able to process a group of graphics operations 

	more efficiently than if Operation() was called for each individually.

	This function should be implemented as if Operation() was called in turn for 

	each operation contained in the buffer. Each operation should be carried out 

	immediately after the one preceding it. If a method returns an error, the 

	length of aBuffer should be set to indicate the number of operations that 

	have been successfully processed. In this case, the operation in which the 

	error occurred will be indicated by the memory address &aBuffer[aBuffer.Length()].

	@param aBuffer A descriptor which holds a concatenation of graphics operations 

	(TGraphicsOperation objects).

	@param aNumClipRects The number of rectangles in the clipping region.

	@param aClipRects A pointer to the first rectangle in the clipping region.

	@return KErrNone if successful, otherwise one of the system error codes. The 

	function should return KErrNotSupported if the accelerator does not support 

	any of the requested operations.

	@see TGraphicsAcceleratorCaps::iClipping */

	virtual TInt Operation(TDes8& aBuffer,TInt aNumClipRects,TRect* aClipRects) = 0;

public:

	// Reserved virtual functions for future use

	virtual void Reserved_1() = 0;

	virtual void Reserved_2() = 0;

	virtual void Reserved_3() = 0;

	virtual void Reserved_4() = 0;

	};

/**

A factory for creating 2D graphics accelerator objects whose graphics operations 

are implemented in software.

Objects of derived classes can write to all types of bitmap, not just hardware 

bitmaps. Note that graphics accelerators may support only a subset of all 

graphics operations. 

@publishedAll

@released

*/

class CSoftwareGraphicsAccelerator : public CGraphicsAccelerator

	{

public:

	// Create a new CSoftwareGraphicsAccelerator for use with a given bitmap

	IMPORT_C static CSoftwareGraphicsAccelerator* NewL(CFbsBitmap* aBitmap);

	// Get the non-bitmap-specific capabilities of the hardware accelerator.

	IMPORT_C static const TGraphicsAcceleratorCaps* GenericCapabilities();

public:

	// From CGraphicsAccelerator

	virtual const TGraphicsAcceleratorCaps* Capabilities() = 0;

	virtual TInt Operation(const TGraphicsOperation& aOperation) = 0;

	virtual TInt Operation(const TGraphicsOperation& aOperation,TInt aNumClipRects,TRect* aClipRects) = 0;

	virtual TInt Operation(TDes8& aBuffer) = 0;

	virtual TInt Operation(TDes8& aBuffer,TInt aNumClipRects,TRect* aClipRects) = 0;

	// From CGraphicsAccelerator

	virtual void Reserved_1() = 0;

	virtual void Reserved_2() = 0;

	virtual void Reserved_3() = 0;

	virtual void Reserved_4() = 0;

	};

/**

A factory for creating 2D graphics accelerator objects whose graphics operations 

are implemented in hardware, software or a mixture of both.

Objects of derived classes can only write to hardware bitmaps (RHardwareBitmap). 

Note that graphics accelerators may support only a subset of all graphics 

operations.

@see RHardwareBitmap 

@publishedAll

@released

*/

class CHardwareGraphicsAccelerator : public CGraphicsAccelerator

	{

public:

	/**

	Create a new CHardwareGraphicsAccelerator for use with a given hardware bitmap.

	Do not use, link against scdv.lib.

	@param aBitmap A bitmap that can be drawn by graphics acceleration hardware. 

	               It can be any bitmap.

	@return Reference to hardware graphics accelerator object.

	*/

	IMPORT_C static CHardwareGraphicsAccelerator* NewL(RHardwareBitmap aBitmap);

	/**

	Gets the generic capabilities of the accelerator, including the supported display modes 

	for the bitmap passed to NewL().

	Do not use, link against scdv.lib.

	@return Generic capabilities for software graphics accelerators.	

	*/

	IMPORT_C static const TGraphicsAcceleratorCaps* GenericCapabilities();

public:

	// From CGraphicsAccelerator

	virtual const TGraphicsAcceleratorCaps* Capabilities() = 0;

	virtual TInt Operation(const TGraphicsOperation& aOperation) = 0;

	virtual TInt Operation(const TGraphicsOperation& aOperation,TInt aNumClipRects,TRect* aClipRects) = 0;

	virtual TInt Operation(TDes8& aBuffer) = 0;

	virtual TInt Operation(TDes8& aBuffer,TInt aNumClipRects,TRect* aClipRects) = 0;

	// From CGraphicsAccelerator

	virtual void Reserved_1() = 0;

	virtual void Reserved_2() = 0;

	virtual void Reserved_3() = 0;

	virtual void Reserved_4() = 0;

	};

//

// Classes used as arguments to graphics operations

//

/**

A pattern represented by a bitmap that is used by a graphics accelerator to 

fill a rectangle or polygon.

An object of this class is specified when constructing a TGopFilledRectWithPattern 

or TGopFilledPolygonWithPattern. The types and sizes of fill pattern bitmaps 

supported by the accelerator are given by TGraphicsAcceleratorCaps::iPattern 

and TGraphicsAcceleratorCaps::iPatternSizes respectively.

@see TGopFilledRectWithPattern

@see TGopFilledPolygonWithPattern

@see TGraphicsAcceleratorCaps::iPatternSizes

@see TGraphicsAcceleratorCaps::iPattern 

@publishedAll

@released

*/

class TGopFillPattern

	{

public:

	/** Provides a handle to the bitmap, and other information needed to draw it. */

	TAcceleratedBitmapSpec	iBitmap;

	/** The origin of the pattern. This is the position at which to draw the pixel at 

	the top left hand corner of the bitmap around which copies of the bitmap are 

	"tiled" to form the pattern. It is relative to the top left hand corner of 

	the rectangle being filled, so specify 0,0 if you want the bitmaps drawn flush 

	with the top and left hand sides of the rectangle. */

	TPoint					iOrigin;

	};

/**

Specifies the amount of fading for all the pixels in a rectangular area.

Fading changes colours so that they are closer to white or closer to black. 

To make colours whiter, increase iOffset; to use a smaller range of colours, 

reduce iScale. Fading uses the following formula (where C is a red, green 

or blue value in a TRgb):

colour component C = ( ( iScale * C ) / 256 )+iOffset;

For example:

- to fade to white, specify iScale=128, iOffset=128

- to fade to black, specify iScale=128, iOffset=0

- for no change, specify iScale=256, iOffset=0

An object of this class is specified when constructing a TGopFadeRect.

@see TGopFadeRect

@publishedAll

@released

*/

class TGopFadeParams	// color component C = ( ( iScale * C ) >> 8 )+iOffset;

	{

public:

	/** Specifies the degree of fading, maximum=256. */

	TInt iScale;

	/** The fading offset. Specifies whether to fade to black or to white. */

	TInt iOffset;

	};

/**

Specifies which pixels should be treated as transparent in a bitblt operation 

that supports transparency.

This is used by the TGopBitBltTransparent and TGopScaledBitBltTransparent 

graphics operations.

For the possible transparency types, see the TTransparencyType enumeration.

An object of this class is specified when constructing a TGopBitBltTransparent or

TGopScaledBitBltTransparent.

@see TTransparencyType

@see TGopBitBltTransparent

@see TGopScaledBitBltTransparent 

@publishedAll

@released

*/

class TGopTransparency

	{

public:

	/** Constructor with a transparency type. iParam is initialised to zero.

	@param aType The transparency type. */

	inline TGopTransparency(TTransparencyType aType)	: iType(aType), iParam(0) {}

	/** Constructor with a pixel value. The type is initialised to ETransparentPixel. 

	Any pixel that has a value equal to aPixelValue is treated as transparent. 

	aPixelValue is the bit pattern of the pixel as stored in the bitmap.

	@param aPixelValue The pixel value. */

	inline TGopTransparency(TInt aPixelValue)			: iType(ETransparentPixel), iParam(aPixelValue) {}

	/** Constructor with a TRgb value. The type is initialised to ETransparentColor. 

	Any pixel that has a color of aRgb is treated as transparent.

	@param aRgb The TRgb value. */

	inline TGopTransparency(TRgb aRgb)					: iType(ETransparentColor), iParam(aRgb.Value()) {}

	/** Gets the colour that is treated as transparent. This is the value of iParam 

	as a TRgb.

	@return The colour that is treated as transparent. */

	inline TRgb Color()	const							{ return TRgb(iParam); }

	/** Gets the value of the colour as a TInt that is treated as transparent. This 

	is the value of iParam.

	@return The colour that is treated as transparent. This is the bit pattern 

	of the colour as stored in the bitmap. */

	inline TInt Pixel()	const							{ return iParam; }

public:

	/** The transparency type. */

	TTransparencyType	iType;

	/** Holds the value of the colour/pixel that is treated as transparent. */

	TUint32				iParam;

	};

//

// Wrapper classes for graphics operation arguments

//

#ifdef __WINS__

#pragma warning(disable : 4355) // Disable warning - 'this' : used in base member initializer list

#endif

/**

An accelerated graphics operation that fills a rectangular area with a colour.

The data members are all initialised on construction. Objects of this class 

can be passed to a graphics accelerator's Operation() function either individually, 

or in a buffer. 

@publishedAll

@released

*/

class TGopFilledRect : public TGraphicsOperation

	{

public:

	/** Constructor with a rectangle and a colour.

	@param aRect The rectangle to fill.

	@param aColor The fill colour. */

	inline TGopFilledRect(const TRect& aRect,TRgb aColor)

			: TGraphicsOperation(EFilledRect,sizeof(*this)), iRect(aRect) , iColor(aColor) {}

public:

	/** The rectangle to fill. */

	TRect	iRect;

	/** The fill colour. */

	TRgb	iColor;

	};

/**

An accelerated graphics operation that fills a rectangular area with a colour, 

whilst performing a bitwise logical operation with the pixels in the region, 

for instance AND, OR, Exclusive OR.

The bitwise logical operation is specified in the draw mode. The data members 

are all initialised on construction. Objects of this class can be passed to 

a graphics accelerator's Operation() function either individually, or in a 

buffer.

@publishedAll

@released

*/

class TGopFilledRectUsingDrawMode : public TGraphicsOperation

	{

public:

	/** Constructor with a rectangle, a colour and a draw mode.

	@param aRect The rectangle to fill.

	@param aColor The fill colour.

	@param aDrawMode The draw mode. */

	inline TGopFilledRectUsingDrawMode(const TRect& aRect,TRgb aColor,CGraphicsContext::TDrawMode aDrawMode)

		: TGraphicsOperation(EFilledRectUsingDrawMode,sizeof(*this)), iRect(aRect) , iColor(aColor) , iDrawMode(aDrawMode) {}

public:

	/** The rectangle to fill. */

	TRect						iRect;

	/** The fill colour. */

	TRgb						iColor;

	/** The draw mode. */

	CGraphicsContext::TDrawMode	iDrawMode;