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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #ifndef __GRAPHICSACCELERATOR_H__

    17 #define __GRAPHICSACCELERATOR_H__

    18 

    19 #include <e32std.h>

    20 #include <gdi.h>

    21 

    22 //

    23 // Bitmaps

    24 //

    25 

    26 // Forward references

    27 class CFbsBitmap;

    28 class TAcceleratedBitmapSpec;

    29 

    30 /**

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

    32 

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

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

    35 

    36 @see RHardwareBitmap

    37 @see CFbsBitmap

    38 @see TAcceleratedBitmapSpec::GetInfo() 

    39 @publishedAll

    40 @released

    41 */

    42 class TAcceleratedBitmapInfo

    43 	{

    44 public:

    45 	/** The display mode of the bitmap. */

    46 	TDisplayMode	iDisplayMode;

    47 

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

    49 	TUint8*			iAddress;

    50 	

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

    52 	TSize			iSize;

    53 	

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

    55 	If the bitmap is compressed the line pitch has no meaning so this data

    56 	member is set to the negation of the compression type. In the case of

    57 	an extended bitmap it is -EProprietaryCompression. */

    58 	TInt			iLinePitch;

    59 	

    60 	/** The shift required to obtain the number of bits needed to represent one pixel

    61 	in the bitmap. The number of bits per pixel is calculated as 1 << iPixelShift.

    62 	In the case of an extended bitmap this data member is set to the bitmap type UID. */

    63 	TInt			iPixelShift;

    64 	

    65 	union

    66 		{

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

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

    69 		to hardware graphics accelerators. Invalid in the case of an extended bitmap. */

    70 		TUint8*		iPhysicalAddress;

    71 		/** In the case of an extended bitmap, the size of the raw bitmap data. */

    72 		TInt		iDataSize;

    73 		};

    74 	};

    75 

    76 /**

    77 The interface to a hardware bitmap.

    78 

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

    80 is stored in a contiguous area of physical memory.

    81 

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

    83 

    84 @see CHardwareGraphicsAccelerator::NewL() 

    85 @publishedAll

    86 @released

    87 */

    88 class RHardwareBitmap

    89 	{

    90 	friend class CBitwiseBitmap;

    91 	friend class CFbsScreenDevice;

    92 public:

    93 

    94     /** Default constructor. */

    95 	inline RHardwareBitmap();

    96 

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

    98 	inline RHardwareBitmap(TInt aHandle);

    99 	

   100 	/** 

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

   102 

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

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

   105 	KErrUnknown if the object's type is ENoBitmap. 

   106 	*/

   107 	IMPORT_C TInt GetInfo(TAcceleratedBitmapInfo& aInfo) const;

   108 private:

   109 	IMPORT_C TInt SetAsScreenReference(TInt aScreen=-1);

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

   111 	IMPORT_C void Destroy();

   112 public:

   113 	

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

   115 	the bitmap. */

   116 	TInt iHandle;	// Must be only member data

   117 	};

   118 

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

   120 inline RHardwareBitmap::RHardwareBitmap()

   121 	: iHandle(0)

   122 	{}

   123 

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

   125 	@param aHandle The RHardwareBitmap handle to duplicate. */

   126 inline RHardwareBitmap::RHardwareBitmap(TInt aHandle)

   127 	: iHandle(aHandle)

   128 	{}

   129 

   130 /**

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

   132 object.

   133 

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

   135 

   136 @see TAcceleratedBitmapSpec 

   137 @publishedAll

   138 @released

   139 */

   140 class TBitmapLockCount

   141 	{

   142 	friend class TAcceleratedBitmapSpec;

   143 public:

   144 	

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

   146 	inline TBitmapLockCount() : iCount(0) {}

   147 private:

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

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

   150 private:

   151 	TInt iCount;

   152 	};

   153 

   154 

   155 /**

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

   157 

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

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

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

   161 operation. 

   162 @publishedAll

   163 @released

   164 */

   165 class TAcceleratedBitmapSpec

   166 	{

   167 public:

   168 	// Constructors

   169 	inline TAcceleratedBitmapSpec();

   170 	IMPORT_C TAcceleratedBitmapSpec(CFbsBitmap* aBitmap);

   171 	IMPORT_C TAcceleratedBitmapSpec(RHardwareBitmap aBitmap);

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

   173 	

   174 	IMPORT_C TInt GetInfo(TAcceleratedBitmapInfo& aInfo) const;

   175 	inline void Lock(TBitmapLockCount& aCount);

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

   177 	inline void	Unlock(TBitmapLockCount& aCount);

   178 

   179 	// enums

   180 	/** Identifies the type of the bitmap.

   181 

   182 	Type() returns this value.

   183 

   184 	@see CFbsBitmap */

   185 	enum TAcceleratedBitmapType

   186 		{

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

   188 		ENoBitmap,

   189 	

   190 	/** The bitmap is of type CFbsBitmap.

   191 	

   192 	@see CFbsBitmap */

   193 		EFbsBitmap,

   194 	

   195 	/** The bitmap is of type RHardwareBitmap.

   196 	

   197 	@see RHardwareBitmap */

   198 		EHardwareBitmap,

   199 		};

   200 	enum TAcceleratedBitmapLock

   201 		{

   202 		EBitmapIsStatic,

   203 		EBitmapNeedsLocking,

   204 		};

   205 	// Getters

   206 	inline TAcceleratedBitmapType	Type() const;

   207 	inline TInt						Handle() const;

   208 private:

   209 	IMPORT_C void DoLock(TBitmapLockCount& aCount);

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

   211 	IMPORT_C void DoUnlock(TBitmapLockCount& aCount);

   212 private:

   213 	TUint8	iType;			// TAcceleratedBitmapType

   214 	TUint8	iLockStatus;	// TAcceleratedBitmapLock

   215 	TUint8	iSpare1;

   216 	TUint8	iSpare2;

   217 	TInt	iHandle;

   218 	};

   219 

   220 	/** Default constructor. 

   221 	Use one of the other constructor overloads instead. */

   222 inline TAcceleratedBitmapSpec::TAcceleratedBitmapSpec()

   223 	: iType(ENoBitmap), iLockStatus(EBitmapIsStatic)

   224 	{}

   225 

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

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

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

   229 	recommended that you always do it.

   230 	

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

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

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

   234 	

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

   236 inline void TAcceleratedBitmapSpec::Lock(TBitmapLockCount& aCount)

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

   238 

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

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

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

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

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

   244 	address).

   245 	

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

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

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

   249 	

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

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

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

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

   254 

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

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

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

   258 	be moved in memory again.

   259 	

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

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

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

   263 	

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

   265 inline void	TAcceleratedBitmapSpec::Unlock(TBitmapLockCount& aCount)

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

   267 

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

   269 	

   270 	@return The type of bitmap. */

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

   272 	{ return (TAcceleratedBitmapSpec::TAcceleratedBitmapType)iType; }

   273 

   274 	/** Returns the handle to the bitmap.

   275 	

   276 	@return The handle to the bitmap. */

   277 inline TInt TAcceleratedBitmapSpec::Handle() const

   278 	{ return iHandle; }

   279 

   280 //

   281 // Accelerator capabilities

   282 //

   283 

   284 

   285 /**

   286 Enumerates the four transparency types.

   287 

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

   289 respectively.

   290 

   291 @see TGopTransparency

   292 @see TGraphicsAcceleratorCaps::iTransparency 

   293 @publishedAll

   294 @released

   295 */

   296 enum TTransparencyType

   297 	{

   298 	

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

   300 	ETransparentPixelZero,

   301 	

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

   303 	is treated as transparent. */

   304 	ETransparentPixel,

   305 	

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

   307 	is treated as transparent. */

   308 	ETransparentColor,

   309 	

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

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

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

   313 	ETransparent1555,

   314 	};

   315 

   316 /** 

   317 Stores the capabilities of a graphics accelerator.

   318 

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

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

   321 so its values are mutually exclusive.

   322 

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

   324 or by GenericCapabilities(), which is implemented by CSoftwareGraphicsAccelerator 

   325 and CHardwareGraphicsAccelerator.

   326 

   327 @see CGraphicsAccelerator::Capabilities() 

   328 @publishedAll

   329 @released

   330 */

   331 class TGraphicsAcceleratorCaps

   332 	{

   333 public:

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

   335 

   336     @see CGraphicsAccelerator::Operation() */

   337 	enum TClipCaps	// Bit flags

   338 		{

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

   340 	

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

   342 	    as parameters.

   343 	

   344 	    @see CGraphicsAccelerator::Operation() */

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

   346 		};

   347 

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

   349 for instance TGopBitBltMasked. These are mutually exclusive values used by 

   350 the iMaskType member. */

   351 	enum TMaskBitmapCaps	// Enum

   352 		{

   353 	/** No masked operations are supported. */

   354 		EMaskBitmapNone = 0,

   355 	

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

   357 		EMaskBitmapAnyDisplayMode,

   358 	

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

   360 		EMaskBitmapMatchingDisplayMode,

   361 	

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

   363 		EMaskBitmapGray2,

   364 		};

   365 

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

   367 (TGopBitBltAlphaChannel and TGopScaledBitBltAlphaChannel). These flags are 

   368 used by the iAlphaChannel member. */

   369 	enum TAlphaChannelCaps	//Bit flags

   370     	{

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

   372 	red, green and blue components. */

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

   374 	

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

   376 	red, green and blue components. */

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

   378 	

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

   380 	for the red, green and blue components. */

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

   382 		};

   383 

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

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

   386 iAlphaBitmap member. */

   387 	enum TAlphaBitmapCaps	//Bit flags

   388     	{

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

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

   391 		EAlphaBitmapGray256 = 1,

   392 	

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

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

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

   396 		EAlphaBitmapColor16M = 2,

   397 	

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

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

   400 		};

   401 

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

   403 used in bitmap patterns.

   404 

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

   406 

   407 @see TGopFillPattern */

   408 	enum TPatternSizeCaps	//Bit flags

   409 		{

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

   411 		EPatternSizeAny = 0xFFFFFFFF,

   412 		};

   413 

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

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

   416 iPattern member. */

   417 	enum TPatternCaps	//Bit flags

   418 		{

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

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

   421 	

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

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

   424 	

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

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

   427 		};

   428 		

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

   430 

   431 @see CGraphicsContext::TFillRule */

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

   433 		{

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

   435 		EPolygonFillAlternate = 1,

   436 	

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

   438 	

   439 	@see CGraphicsContext::TFillRule */

   440 		EPolygonFillWinding = 2,

   441 		};

   442 

   443 	 		

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

   445 @see  CFbsBitGc::TGraphicsOrientation */

   446  	enum TOrientationCaps

   447  		{

   448  		/** Normal orientation is supported. */

   449  		EOrientationCapNormal = 1,

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

   451  		EOrientationCapRotated90 = 2,

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

   453  		EOrientationCapRotated180 = 4,

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

   455  		EOrientationCapRotated270 = 8,

   456  		/** All orientations are supported. */ 

   457  		EOrientationCapAll = EOrientationCapNormal|EOrientationCapRotated90|EOrientationCapRotated180|EOrientationCapRotated270

   458  		};

   459 

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

   461 	TInt			iStructureSize;	// The size of this class

   462 	

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

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

   465 	

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

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

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

   469 	TUid			iVendorUid;		// Optional ID

   470 	

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

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

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

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

   475 	

   476 	@see TDisplayMode */

   477 	TUint			iDisplayModes;	// One bit for each TDisplayMode enumeration

   478 	

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

   480 	parameters are supported.

   481 	

   482 	@see TClipCaps */

   483 	TUint			iClipping;		// TClipCaps bit flags

   484 	

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

   486 	exclusive values.

   487 	

   488 	@see TMaskBitmapCaps */

   489 	TMaskBitmapCaps	iMaskType;		// Mask type used

   490 	

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

   492 	supported.

   493 	

   494 	@see TTransparencyType */

   495 	TUint			iTransparency;	// Bit flag for each TTransparencyType supported

   496 	

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

   498 	each TAlphaChannelCaps supported.

   499 	

   500 	@see TAlphaChannelCaps */

   501 	TUint			iAlphaChannel;	// TAlphaChannelCaps bit flags

   502 	

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

   504 	supported.

   505 	

   506 	@see TAlphaBitmapCaps */

   507 	TUint			iAlphaBitmap;	// TAlphaBitmapCaps bit flags

   508 	

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

   510 	

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

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

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

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

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

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

   517 	

   518 	@see TPatternSizeCaps */

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

   520 	

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

   522 	each TPatternCaps supported.

   523 	

   524 	@see TPatternCaps */

   525 	TUint			iPattern;		// TPatternCaps bit flags

   526 	

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

   528 	for each TPolygonCaps supported.

   529 	

   530 	@see TPolygonCaps */

   531 	TUint			iPolygon;		// TPolygonCaps bit flags

   532 	

   533  	/** 

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

   535  	for each TOrientationCaps supported.	

   536  	@see TOrientationCaps 

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

   538  	*/

   539  	TUint			iReserved[4];

   540 	};

   541 

   542 

   543 //

   544 // TGraphicsOperation

   545 //

   546 

   547 /**

   548 Abstract base class for all graphics operations.

   549 

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

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

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

   553 in third party code.

   554 

   555 @see CGraphicsAccelerator::Operation() 

   556 @publishedAll

   557 @released

   558 */

   559 class TGraphicsOperation

   560 	{

   561 public:

   562 	enum TGopFunction

   563 		{								// Require arguments commented below here

   564 

   565 		EFilledRect,					// (TRect,TRgb)

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

   567 		EFilledRectWithPattern,			// (TRect,TGopFillPattern)

   568 		EInvertRect,					// (TRect)

   569 		EFadeRect,						// (TRect,TGopFadeParams)

   570 

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

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

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

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

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

   576 

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

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

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

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

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

   582 

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

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

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

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

   587 		EChunkTest,

   588 		EVirtualAddressTest,

   589 		};

   590 public:

   591 	// Getters

   592 	inline TGopFunction Function() const	{ return iFunction; }

   593 	inline TInt Size() const				{ return iSize; }

   594 	// Utility functions 

   595 	inline TGraphicsOperation* Next() const;

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

   597 protected:

   598 	inline TGraphicsOperation(TGopFunction aFunction, TInt aArgSize);

   599 	inline TGraphicsOperation() {}

   600 protected:

   601 	TGopFunction iFunction;

   602 	TInt iSize;  // Total size of derived class

   603 	};

   604 

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

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

   607 

   608 inline TGraphicsOperation* TGraphicsOperation::Next() const

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

   610 

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

   612 	{

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

   614 	iSize += aNumBytes;

   615 	}

   616 

   617 

   618 //

   619 // Graphics accelerator

   620 //

   621 

   622 /**

   623 Abstract base class for 2D graphics accelerators.

   624 

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

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

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

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

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

   630 may be implemented in software, hardware, or both. 

   631 @publishedAll

   632 @released

   633 */

   634 class CGraphicsAccelerator : public CBase

   635 	{

   636 public:

   637 	// Return the capabilities of this accelerator

   638 	

   639 	/** Returns the capabilities of the graphics accelerator.

   640 	

   641 	@return The capabilities of the accelerator. */

   642 	virtual const TGraphicsAcceleratorCaps* Capabilities() = 0;

   643 

   644 	// Perform a graphics operation

   645 	

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

   647 	

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

   649 	the graphics operation to be performed.

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

   651 	function should return KErrNotSupported if the accelerator does not support 

   652 	the requested operation. */

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

   654 	

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

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

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

   658 	is supported.

   659 	

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

   661 	the graphics operation to be performed.

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

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

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

   665 	function should return KErrNotSupported if the accelerator does not support 

   666 	the requested operation.

   667 	@see TGraphicsAcceleratorCaps::iClipping */

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

   669 	

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

   671 	// one preceding it in the buffer)

   672 	

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

   674 	in a buffer.

   675 	

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

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

   678 	

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

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

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

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

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

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

   685 	

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

   687 	(TGraphicsOperation-derived objects).

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

   689 	function should return KErrNotSupported if the accelerator does not support 

   690 	any of the requested operations. */

   691 	virtual TInt Operation(TDes8& aBuffer) = 0;

   692 	

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

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

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

   696 	is supported.

   697 	

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

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

   700 	

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

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

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

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

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

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

   707 	

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

   709 	(TGraphicsOperation objects).

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

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

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

   713 	function should return KErrNotSupported if the accelerator does not support 

   714 	any of the requested operations.

   715 	@see TGraphicsAcceleratorCaps::iClipping */

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

   717 public:

   718 	// Reserved virtual functions for future use

   719 	virtual void Reserved_1() = 0;

   720 	virtual void Reserved_2() = 0;

   721 	virtual void Reserved_3() = 0;

   722 	virtual void Reserved_4() = 0;

   723 	};

   724 

   725 

   726 

   727 /**

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

   729 are implemented in software.

   730 

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

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

   733 graphics operations. 

   734 @publishedAll

   735 @released

   736 */

   737 class CSoftwareGraphicsAccelerator : public CGraphicsAccelerator

   738 	{

   739 public:

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

   741 	IMPORT_C static CSoftwareGraphicsAccelerator* NewL(CFbsBitmap* aBitmap);

   742 

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

   744 	IMPORT_C static const TGraphicsAcceleratorCaps* GenericCapabilities();

   745 public:

   746 	// From CGraphicsAccelerator

   747 	virtual const TGraphicsAcceleratorCaps* Capabilities() = 0;

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

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

   750 	virtual TInt Operation(TDes8& aBuffer) = 0;

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

   752 	// From CGraphicsAccelerator

   753 	virtual void Reserved_1() = 0;

   754 	virtual void Reserved_2() = 0;

   755 	virtual void Reserved_3() = 0;

   756 	virtual void Reserved_4() = 0;

   757 	};

   758 

   759 

   760 /**

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

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

   763 

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

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

   766 operations.

   767 

   768 @see RHardwareBitmap 

   769 @publishedAll

   770 @released

   771 */

   772 class CHardwareGraphicsAccelerator : public CGraphicsAccelerator

   773 	{

   774 public:

   775 	/**

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

   777 	

   778 	Do not use, link against scdv.lib.

   779 	

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

   781 	               It can be any bitmap.

   782 	@return Reference to hardware graphics accelerator object.

   783 	*/

   784 	IMPORT_C static CHardwareGraphicsAccelerator* NewL(RHardwareBitmap aBitmap);

   785 	

   786 	/**

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

   788 	for the bitmap passed to NewL().

   789 	

   790 	Do not use, link against scdv.lib.

   791 	

   792 	@return Generic capabilities for software graphics accelerators.	

   793 	*/

   794 	IMPORT_C static const TGraphicsAcceleratorCaps* GenericCapabilities();

   795 public:

   796 	// From CGraphicsAccelerator

   797 	virtual const TGraphicsAcceleratorCaps* Capabilities() = 0;

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

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

   800 	virtual TInt Operation(TDes8& aBuffer) = 0;

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

   802 	// From CGraphicsAccelerator

   803 	virtual void Reserved_1() = 0;

   804 	virtual void Reserved_2() = 0;

   805 	virtual void Reserved_3() = 0;

   806 	virtual void Reserved_4() = 0;

   807 	};

   808 

   809 //

   810 // Classes used as arguments to graphics operations

   811 //

   812 

   813 /**

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

   815 fill a rectangle or polygon.

   816 

   817 An object of this class is specified when constructing a TGopFilledRectWithPattern 

   818 or TGopFilledPolygonWithPattern. The types and sizes of fill pattern bitmaps 

   819 supported by the accelerator are given by TGraphicsAcceleratorCaps::iPattern 

   820 and TGraphicsAcceleratorCaps::iPatternSizes respectively.

   821 

   822 @see TGopFilledRectWithPattern

   823 @see TGopFilledPolygonWithPattern

   824 @see TGraphicsAcceleratorCaps::iPatternSizes

   825 @see TGraphicsAcceleratorCaps::iPattern 

   826 @publishedAll

   827 @released

   828 */

   829 class TGopFillPattern

   830 	{

   831 public:

   832 	

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

   834 	TAcceleratedBitmapSpec	iBitmap;

   835 	

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

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

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

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

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

   841 	TPoint					iOrigin;

   842 	};

   843 

   844 /**

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

   846 

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

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

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

   850 or blue value in a TRgb):

   851 

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

   853 

   854 For example:

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

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

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

   858 

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

   860 

   861 @see TGopFadeRect

   862 @publishedAll

   863 @released

   864 */

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

   866 	{

   867 public:

   868 	

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

   870 	TInt iScale;

   871 	

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

   873 	TInt iOffset;

   874 	};

   875 

   876 /**

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

   878 that supports transparency.

   879 

   880 This is used by the TGopBitBltTransparent and TGopScaledBitBltTransparent 

   881 graphics operations.

   882 

   883 For the possible transparency types, see the TTransparencyType enumeration.

   884 

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

   886 TGopScaledBitBltTransparent.

   887 

   888 @see TTransparencyType

   889 @see TGopBitBltTransparent

   890 @see TGopScaledBitBltTransparent 

   891 @publishedAll

   892 @released

   893 */

   894 class TGopTransparency

   895 	{

   896 public:

   897 	

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

   899 	

   900 	@param aType The transparency type. */

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

   902 	

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

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

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

   906 	

   907 	@param aPixelValue The pixel value. */

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

   909 	

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

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

   912 	

   913 	@param aRgb The TRgb value. */

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

   915 	

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

   917 	as a TRgb.

   918 	

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

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

   921 	

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

   923 	is the value of iParam.

   924 	

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

   926 	of the colour as stored in the bitmap. */

   927 	inline TInt Pixel()	const							{ return iParam; }

   928 public:

   929 	

   930 	/** The transparency type. */

   931 	TTransparencyType	iType;

   932 	

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

   934 	TUint32				iParam;

   935 	};

   936 

   937 

   938 //

   939 // Wrapper classes for graphics operation arguments

   940 //

   941 

   942 #ifdef __WINS__

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

   944 #endif

   945 

   946 /**

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

   948 

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

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

   951 or in a buffer. 

   952 @publishedAll

   953 @released

   954 */

   955 class TGopFilledRect : public TGraphicsOperation

   956 	{

   957 public:

   958 	/** Constructor with a rectangle and a colour.

   959 	@param aRect The rectangle to fill.

   960 	@param aColor The fill colour. */

   961 	inline TGopFilledRect(const TRect& aRect,TRgb aColor)

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

   963 public:

   964 	

   965 	/** The rectangle to fill. */

   966 	TRect	iRect;

   967 	

   968 	/** The fill colour. */

   969 	TRgb	iColor;

   970 	};

   971 

   972 /**

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

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

   975 for instance AND, OR, Exclusive OR.

   976 

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

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

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

   980 buffer.

   981 @publishedAll

   982 @released

   983 */

   984 class TGopFilledRectUsingDrawMode : public TGraphicsOperation

   985 	{

   986 public:

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

   988 	@param aRect The rectangle to fill.

   989 	@param aColor The fill colour.

   990 	@param aDrawMode The draw mode. */

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

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

   993 public:

   994 	

   995 	/** The rectangle to fill. */

   996 	TRect						iRect;

   997 	

   998 	/** The fill colour. */

   999 	TRgb						iColor;

  1000 	

  1001 	/** The draw mode. */

  1002 	CGraphicsContext::TDrawMode	iDrawMode;

  1003 	};

  1004 

  1005 /**

  1006 An accelerated graphics operation that fills a rectangular area with a pattern.

  1007 

  1008 The pattern consists of multiple copies of a bitmap, drawn tiled around an 

  1009 origin. Objects of this class can be passed to a graphics accelerator's Operation() 

  1010 function either individually, or in a buffer. 

  1011 

  1012 @see TGopFillPattern

  1013 @publishedAll

  1014 @released

  1015 */

  1016 class TGopFilledRectWithPattern : public TGraphicsOperation

  1017 	{

  1018 public:

  1019 	/** Constructor with a rectangle and a pattern.

  1020 	@param aRect The rectangle to fill.

  1021 	@param aPattern Specifies the handle to the bitmap to use for the pattern, 

  1022 	and the origin for the pattern. */

  1023 	inline TGopFilledRectWithPattern(const TRect& aRect,TGopFillPattern aPattern)

  1024 		: TGraphicsOperation(EFilledRectWithPattern,sizeof(*this)), iRect(aRect) , iPattern(aPattern) {}

  1025 public:

  1026 	

  1027 	/** The rectangle to fill. */

  1028 	TRect			iRect;

  1029 	

  1030 	/** Specifies the handle to the bitmap to use for the pattern and the origin for 

  1031 	the pattern. */

  1032 	TGopFillPattern iPattern;

  1033 	};

  1034 

  1035 /**

  1036 An accelerated graphics operation that inverts the colour of all pixels in 

  1037 a rectangular area.

  1038 

  1039 Objects of this class can be passed to a graphics accelerator's Operation() 

  1040 function either individually, or in a buffer. 

  1041 @publishedAll

  1042 @released

  1043 */

  1044 class TGopInvertRect : public TGraphicsOperation

  1045 	{

  1046 public:

  1047 	/** Constructor with a rectangle.

  1048 	@param aRect The rectangle in which to invert the colours. */

  1049 	inline TGopInvertRect(const TRect& aRect)

  1050 		: TGraphicsOperation(EInvertRect,sizeof(*this)), iRect(aRect) {}

  1051 public:

  1052 	

  1053 	/** The rectangle in which to invert the colours. */

  1054 	TRect	iRect;

  1055 	};

  1056 

  1057 /**

  1058 An accelerated graphics operation that fades the pixels in a rectangular area.

  1059 

  1060 Objects of this class can be passed to a graphics accelerator's Operation() 

  1061 function either individually, or in a buffer. 

  1062 @publishedAll

  1063 @released

  1064 */

  1065 class TGopFadeRect : public TGraphicsOperation

  1066 	{

  1067 public:

  1068 	/** Constructor with a rectangle and fade parameters.

  1069 	@param aRect The rectangle to fade.

  1070 	@param aFade The fade parameters. */

  1071 	inline TGopFadeRect(const TRect& aRect, const TGopFadeParams aFade)

  1072 		: TGraphicsOperation(EFadeRect,sizeof(*this)), iRect(aRect), iFade(aFade) {}

  1073 public:

  1074 	

  1075 	/** The rectangle to fade. */

  1076 	TRect			iRect;

  1077 	

  1078 	/** The fade parameters. */

  1079 	TGopFadeParams	iFade;

  1080 	};

  1081 

  1082 /**

  1083 An accelerated graphics operation that copies a rectangular region of one bitmap 

  1084 into another.

  1085 

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

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

  1088 or in a buffer. 

  1089 @publishedAll

  1090 @released

  1091 */

  1092 class TGopBitBlt : public TGraphicsOperation

  1093 	{

  1094 public:

  1095 	/** Constructor with a position, a source bitmap handle and a rectangle.

  1096 	@param aDestination The destination for the top left hand corner of the portion 

  1097 	of the source bitmap.

  1098 	@param aSourceBitmap A handle to the source bitmap, and other information needed 

  1099 	to draw it.

  1100 	@param aSourceRect A rectangle within the source bitmap. Its coordinates are relative 

  1101 	to the top left of the source bitmap. Defines the part of the source bitmap to be copied. */

  1102 	inline TGopBitBlt(const TPoint& aDestination, TAcceleratedBitmapSpec aSourceBitmap, TRect& aSourceRect)

  1103 		: TGraphicsOperation(EBitBlt,sizeof(*this)), iDestination(aDestination), iSourceBitmap(aSourceBitmap), iSourceRect(aSourceRect) {}

  1104 public:

  1105 	

  1106 	/** The destination for the top left hand corner of the portion of the source bitmap. */

  1107 	TPoint					iDestination;

  1108 	

  1109 	/** A handle to the source bitmap, and other information needed to draw it. */

  1110 	TAcceleratedBitmapSpec	iSourceBitmap;

  1111 	

  1112 	/** A rectangle defining all or a part of the bitmap to be copied. */

  1113 	TRect					iSourceRect;

  1114 	};

  1115 

  1116 /**

  1117 An accelerated graphics operation that copies a rectangular region of one bitmap 

  1118 into another, using a third bitmap as a mask.

  1119 

  1120 The mask must be the same size as the source bitmap. The parts of the source 

  1121 bitmap that are drawn are the areas that are black in the mask.

  1122 

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

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

  1125 or in a buffer.

  1126 

  1127 @see TGraphicsAcceleratorCaps::iMaskType 

  1128 @publishedAll

  1129 @released

  1130 */

  1131 class TGopBitBltMasked : public TGraphicsOperation

  1132 	{

  1133 public:

  1134 	/** Constructor with a position, a source bitmap handle, a rectangle and a mask bitmap handle.

  1135 	@param aDestination The destination for the top left hand corner of the portion