1 /*

     2 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 /**

    19 @test

    20 @internalComponent

    21 v

    22 This contains CT_DataFbsBitmap

    23 */

    24 

    25 //	User includes

    26 #include "T_DataFbsBitmap.h"

    27 #include "T_GraphicsUtil.h"

    28 

    29 //	EPOC includes

    30 #include <graphics\bitmapuid.h>

    31 

    32 /*@{*/

    33 ///	Parameters

    34 _LIT(KAlways,								"always");

    35 _LIT(KBitmapId,								"bitmap_id");

    36 _LIT(KBuffLength,							"buff_length");

    37 _LIT(KDitherOffsetX,						"dither_offset_x");

    38 _LIT(KDitherOffsetY,						"dither_offset_y");

    39 _LIT(KExpectedBool,							"expected_bool");

    40 _LIT(KExpectedInt,							"expected_int");

    41 _LIT(KFbsBitmapName,						"fbs_bitmap_name");

    42 _LIT(KFileName,								"file_name");

    43 _LIT(KFileOffset,							"file_offset");

    44 _LIT(KHeight,								"height");

    45 _LIT(KHandle,								"handle");

    46 _LIT(KWidth,								"width");

    47 _LIT(KLength,								"length");

    48 _LIT(KNullExpected,							"null_expected");

    49 _LIT(KDevice,								"device");

    50 _LIT(KNumberOfSources,						"number_of_sources");

    51 _LIT(KPixels,								"pixels");

    52 _LIT(KPointX,								"point_x");

    53 _LIT(KPointY,								"point_y");

    54 _LIT(KRectTlX,								"rect_tl_x");

    55 _LIT(KRectTlY,								"rect_tl_y");

    56 _LIT(KRectBrX,								"rect_br_x");

    57 _LIT(KRectBrY,								"rect_br_y");

    58 _LIT(KScanLineCoord,						"scan_line_coord");

    59 _LIT(KSourceFileName0,						"source_file_name_0"); // we don't need more than 3 sources for our test anyway.

    60 _LIT(KSourceFileName1,						"source_file_name_1"); // So that this solution is ok

    61 _LIT(KSourceFileName2,						"source_file_name_2");

    62 _LIT(KSourceBitmapId0,						"source_bitmap_id_0");

    63 _LIT(KSourceBitmapId1,						"source_bitmap_id_1");

    64 _LIT(KSourceBitmapId2,						"source_bitmap_id_2");

    65 _LIT(KShareIfLoaded,						"share_if_loaded");

    66 _LIT(KTwips,								"twips");

    67 _LIT(KUseDitherOffset,						"use_dither_offset");

    68 _LIT(KUseRFile,								"use_rfile");

    69 _LIT(KUseClosedRFile,						"use_closed_rfile");

    70 _LIT(KUseClosedStream,						"use_closed_stream");

    71 _LIT(KUseRequestStatus,						"use_request_status");

    72 _LIT(KUid,									"uid");

    73 _LIT(KPalette,								"palette");

    74 _LIT(KModifiable,							"modifiable");

    75 _LIT(KEntries,								"entries");

    76 _LIT(KRed,									"red");

    77 _LIT(KGreen,								"green");

    78 _LIT(KBlue,									"blue");

    79 _LIT(KDisplayMode,							"displaymode");

    80 _LIT(KBitmapfileCompressionScheme,			"bitmap_compression_scheme");

    81 

    82 ///	Commands

    83 _LIT(KCmdDisown,								"disown");

    84 _LIT(KCmdNew,								"new");

    85 _LIT(KCmdDestructor,						"~");

    86 _LIT(KCmdCompress,							"Compress");

    87 _LIT(KCmdCompressInBackground,				"CompressInBackground");

    88 _LIT(KCmdCreate,							"Create");

    89 _LIT(KCmdCreateHardwareBitmap,				"CreateHardwareBitmap");

    90 _LIT(KCmdDataAddress,						"DataAddress");

    91 _LIT(KCmdDataStride,						"DataStride");

    92 _LIT(KCmdDisplayMode,						"DisplayMode");

    93 _LIT(KCmdDuplicate,							"Duplicate");

    94 _LIT(KCmdExternalizeL,						"ExternalizeL");

    95 _LIT(KCmdExternalizeRectangleL,				"ExternalizeRectangleL");

    96 _LIT(KCmdGetPalette,						"GetPalette");

    97 _LIT(KCmdGetPixel,							"GetPixel");

    98 _LIT(KCmdGetScanLine,						"GetScanLine");

    99 _LIT(KCmdGetVerticalScanLine,				"GetVerticalScanLine");

   100 _LIT(KCmdHandle,							"Handle");

   101 _LIT(KCmdHardwareBitmapHandle,				"HardwareBitmapHandle");

   102 _LIT(KCmdHeader,							"Header");

   103 _LIT(KCmdHorizontalPixelsToTwips,			"HorizontalPixelsToTwips");

   104 _LIT(KCmdHorizontalTwipsToPixels,			"HorizontalTwipsToPixels");

   105 _LIT(KCmdInitialDisplayMode,				"InitialDisplayMode");

   106 _LIT(KCmdInternalizeL,						"InternalizeL");

   107 _LIT(KCmdIsCompressedInRAM,					"IsCompressedInRAM");

   108 _LIT(KCmdIsFileInRom,						"IsFileInRom");

   109 _LIT(KCmdIsLargeBitmap,						"IsLargeBitmap");

   110 _LIT(KCmdIsMonochrome,						"IsMonochrome");

   111 _LIT(KCmdIsRomBitmap,						"IsRomBitmap");

   112 _LIT(KCmdLoad,								"Load");

   113 _LIT(KCmdLoadAndCompress,					"LoadAndCompress");

   114 _LIT(KCmdLockHeap,							"LockHeap");

   115 _LIT(KCmdLockHeapLC,						"LockHeapLC");

   116 _LIT(KCmdPaletteAttributes,					"PaletteAttributes");

   117 _LIT(KCmdReset,								"Reset");

   118 _LIT(KCmdResize,							"Resize");

   119 _LIT(KCmdSave,								"Save");

   120 _LIT(KCmdScanLineLength,					"ScanLineLength");

   121 _LIT(KCmdSetDisplayMode,					"SetDisplayMode");

   122 _LIT(KCmdSetPalette,						"SetPalette");

   123 _LIT(KCmdSetRomBitmapL,						"SetRomBitmapL");

   124 _LIT(KCmdSetScanLine,						"SetScanLine");

   125 _LIT(KCmdSetSizeInTwips,					"SetSizeInTwips");

   126 _LIT(KCmdSizeInPixels,						"SizeInPixels");

   127 _LIT(KCmdSizeInTwips,						"SizeInTwips");

   128 _LIT(KCmdStoreL,							"StoreL");

   129 _LIT(KCmdSwapWidthAndHeight,				"SwapWidthAndHeight");

   130 _LIT(KCmdUnlockHeap,						"UnlockHeap");

   131 _LIT(KCmdVerticalPixelsToTwips,				"VerticalPixelsToTwips");

   132 _LIT(KCmdVerticalTwipsToPixels,				"VerticalTwipsToPixels");

   133 

   134 //??	SetRomBitmapL

   135 //	Begin

   136 //	End

   137 //	GetDecompressionBuffer

   138 //	GetAllBitmapHandles

   139 /*@}*/

   140 

   141 /**

   142 * Two phase constructor

   143 */

   144 CT_DataFbsBitmap* CT_DataFbsBitmap::NewL()

   145 	{

   146 	CT_DataFbsBitmap* ret = new (ELeave) CT_DataFbsBitmap();

   147 	CleanupStack::PushL(ret);

   148 	ret->ConstructL();

   149 	CleanupStack::Pop(ret);

   150 	return ret;

   151 	}

   152 

   153 /**

   154 * Protected constructor. First phase construction

   155 */

   156 CT_DataFbsBitmap::CT_DataFbsBitmap()

   157 :	CDataWrapperBase()

   158 ,	iFbsBitmap(NULL)

   159 ,	iDisplayMode(ENone)

   160 ,	iPopWhenUnlocking(EFalse)

   161 ,	iCompressFailed(EFalse)

   162 ,	iActiveCompressInBackground(NULL)

   163 	{

   164 	}

   165 

   166 /**

   167 * Protected constructor. Second phase construction

   168 */

   169 void CT_DataFbsBitmap::ConstructL()

   170 	{

   171 	iActiveCompressInBackground=CActiveCallback::NewL(*this);

   172 	}

   173 

   174 /**

   175 * Destructor.

   176 */

   177 CT_DataFbsBitmap::~CT_DataFbsBitmap()

   178 	{

   179 	DestroyData();

   180 	delete iActiveCompressInBackground;

   181 	iActiveCompressInBackground=NULL;

   182 	}

   183 

   184 /**

   185 * Contains cleanup implementation

   186 */

   187 void CT_DataFbsBitmap::DestroyData()

   188 	{

   189 	delete iFbsBitmap;

   190 	iFbsBitmap=NULL;

   191 	}

   192 

   193 /**

   194 * Return a pointer to the object that the data wraps

   195 *

   196 * @return pointer to the object that the data wraps

   197 */

   198 TAny* CT_DataFbsBitmap::GetObject()

   199 	{

   200 	return iFbsBitmap;

   201 	}

   202 

   203 void CT_DataFbsBitmap::SetObjectL(TAny* aAny)

   204     {

   205     DestroyData();

   206     iFbsBitmap=static_cast<CFbsBitmap*> (aAny);

   207     }

   208 

   209 void CT_DataFbsBitmap::DisownObjectL()

   210 	{

   211 	iFbsBitmap=NULL;

   212 	}

   213 

   214 CFbsBitmap* CT_DataFbsBitmap::GetFbsBitmap() const

   215 	{

   216 	return iFbsBitmap;

   217 	}

   218 

   219 /**

   220 * Process a command read from the ini file

   221 *

   222 * @param aDataWrapper	test step requiring command to be processed

   223 * @param aCommand	the command to process

   224 * @param aSection		the entry in the ini file requiring the command to be processed

   225 *

   226 * @return ETrue if the command is processed

   227 */

   228 TBool CT_DataFbsBitmap::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)

   229 	{

   230 	TBool	retVal = ETrue;

   231 

   232 	if (aCommand == KCmdNew)

   233 		{

   234 		DoCmdNewL();

   235 		}

   236 	else if (aCommand == KCmdDestructor)

   237 		{

   238 		DoCmdDestructor();

   239 		}

   240 	else if (aCommand == KCmdCompress)

   241 		{

   242 		DoCmdCompress(aSection);

   243 		}

   244 	else if (aCommand == KCmdCompressInBackground)

   245 		{

   246 		DoCmdCompressInBackground(aSection, aAsyncErrorIndex);

   247 		}

   248 	else if (aCommand == KCmdCreate)

   249 		{

   250 		DoCmdCreate(aSection);

   251 		}

   252 	else if (aCommand == KCmdCreateHardwareBitmap)

   253 		{

   254 		DoCmdCreateHardwareBitmap(aSection);

   255 		}

   256 	else if (aCommand == KCmdDataAddress)

   257 		{

   258 		DoCmdDataAddress(aSection);

   259 		}

   260 	else if (aCommand == KCmdDataStride)

   261 		{

   262 		DoCmdDataStride(aSection);

   263 		}

   264 	else if (aCommand == KCmdDisplayMode)

   265 		{

   266 		DoCmdDisplayMode(aSection);

   267 		}

   268 	else if (aCommand == KCmdDuplicate)

   269 		{

   270 		DoCmdDuplicateL(aSection);

   271 		}

   272 	else if (aCommand == KCmdExternalizeL)

   273 		{

   274 		DoCmdExternalizeL(aSection);

   275 		}

   276 	else if (aCommand == KCmdExternalizeRectangleL)

   277 		{

   278 		DoCmdExternalizeRectangleL(aSection);

   279 		}

   280 	else if (aCommand == KCmdGetPalette)

   281 		{

   282 		DoCmdGetPaletteL(aSection);

   283 		}

   284 	else if (aCommand == KCmdGetPixel)

   285 		{

   286 		DoCmdGetPixel(aSection);

   287 		}

   288 	else if (aCommand == KCmdGetScanLine)

   289 		{

   290 		DoCmdGetScanLineL(aSection);

   291 		}

   292 	else if (aCommand == KCmdGetVerticalScanLine)

   293 		{

   294 		DoCmdGetVerticalScanLineL(aSection);

   295 		}

   296 	else if (aCommand == KCmdHandle)

   297 		{

   298 		DoCmdHandle(aSection);

   299 		}

   300 	else if (aCommand == KCmdHardwareBitmapHandle)

   301 		{

   302 		DoCmdHardwareBitmapHandle(aSection);

   303 		}

   304 	else if (aCommand == KCmdHeader)

   305 		{

   306 		DoCmdHeader();

   307 		}

   308 	else if (aCommand == KCmdHorizontalPixelsToTwips)

   309 		{

   310 		DoCmdHorizontalPixelsToTwips(aSection);

   311 		}

   312 	else if (aCommand == KCmdHorizontalTwipsToPixels)

   313 		{

   314 		DoCmdHorizontalTwipsToPixels(aSection);

   315 		}

   316 	else if (aCommand == KCmdInitialDisplayMode)

   317 		{

   318 		DoCmdInitialDisplayMode(aSection);

   319 		}

   320 	else if (aCommand == KCmdInternalizeL)

   321 		{

   322 		DoCmdInternalizeL(aSection);

   323 		}

   324 	else if (aCommand == KCmdIsCompressedInRAM)

   325 		{

   326 		DoCmdIsCompressedInRAM(aSection);

   327 		}

   328 	else if (aCommand == KCmdIsFileInRom)

   329 		{

   330 		DoCmdIsFileInRom(aSection);

   331 		}

   332 	else if (aCommand == KCmdIsLargeBitmap)

   333 		{

   334 		DoCmdIsLargeBitmap(aSection);

   335 		}

   336 	else if (aCommand == KCmdIsMonochrome)

   337 		{

   338 		DoCmdIsMonochrome(aSection);

   339 		}

   340 	else if (aCommand == KCmdIsRomBitmap)

   341 		{

   342 		DoCmdIsRomBitmap(aSection);

   343 		}

   344 	else if (aCommand == KCmdLoad)

   345 		{

   346 		DoCmdLoadL(aSection);

   347 		}

   348 	else if (aCommand == KCmdLoadAndCompress)

   349 		{

   350 		DoCmdLoadAndCompressL(aSection);

   351 		}

   352 	else if (aCommand == KCmdLockHeap)

   353 		{

   354 		DoCmdLockHeap(aSection);

   355 		}

   356 	else if (aCommand == KCmdLockHeapLC)

   357 		{

   358 		DoCmdLockHeapLC(aSection);

   359 		}

   360 	else if (aCommand == KCmdPaletteAttributes)

   361 		{

   362 		DoCmdPaletteAttributes(aSection);

   363 		}

   364 	else if (aCommand == KCmdReset)

   365 		{

   366 		DoCmdReset();

   367 		}

   368 	else if (aCommand == KCmdResize)

   369 		{

   370 		DoCmdResize(aSection);

   371 		}

   372 	else if (aCommand == KCmdSave)

   373 		{

   374 		DoCmdSave(aSection);

   375 		}

   376 	else if (aCommand == KCmdScanLineLength)

   377 		{

   378 		DoCmdScanLineLength(aSection);

   379 		}

   380 	else if (aCommand == KCmdSetDisplayMode)

   381 		{

   382 		DoCmdSetDisplayMode(aSection);

   383 		}

   384 	else if (aCommand == KCmdSetPalette)

   385 		{

   386 		DoCmdSetPaletteL(aSection);

   387 		}

   388 	else if (aCommand == KCmdSetRomBitmapL)

   389 		{

   390 		DoCmdSetRomBitmapL(aSection);

   391 		}

   392 	else if (aCommand == KCmdSetScanLine)

   393 		{

   394 		DoCmdSetScanLineL(aSection);

   395 		}

   396 	else if (aCommand == KCmdSetSizeInTwips)

   397 		{

   398 		DoCmdSetSizeInTwipsL(aSection);

   399 		}

   400 	else if (aCommand == KCmdSizeInPixels)

   401 		{

   402 		DoCmdSizeInPixels(aSection);

   403 		}

   404 	else if (aCommand == KCmdSizeInTwips)

   405 		{

   406 		DoCmdSizeInTwips(aSection);

   407 		}

   408 	else if (aCommand == KCmdStoreL)

   409 		{

   410 		DoCmdStoreL(aSection);

   411 		}

   412 	else if (aCommand == KCmdSwapWidthAndHeight)

   413 		{

   414 		DoCmdSwapWidthAndHeight();

   415 		}

   416 	else if (aCommand == KCmdUnlockHeap)

   417 		{

   418 		DoCmdUnlockHeapL(aSection);

   419 		}

   420 	else if (aCommand == KCmdVerticalPixelsToTwips)

   421 		{

   422 		DoCmdVerticalPixelsToTwips(aSection);

   423 		}

   424 	else if (aCommand == KCmdVerticalTwipsToPixels)

   425 		{

   426 		DoCmdVerticalTwipsToPixels(aSection);

   427 		}

   428 	else if (aCommand == KCmdDisown)

   429    {

   430    DisownObjectL();

   431    }

   432 	else

   433 		{

   434 		retVal=EFalse;

   435 		}

   436 

   437 	return retVal;

   438 	}

   439 

   440 

   441 /** Creates new CFbsBitmap class instance */

   442 void CT_DataFbsBitmap::DoCmdNewL()

   443 	{

   444 	INFO_PRINTF1(_L("Creates new CFbsBitmap class instance"));

   445 

   446 	// cleanup if already created

   447     DestroyData();

   448 	iFbsBitmap=new (ELeave) CFbsBitmap();

   449 	}

   450 

   451 /** Calls static CFbsBitmap destructor */

   452 void CT_DataFbsBitmap::DoCmdDestructor()

   453 	{

   454 	DestroyData();

   455 	}

   456 

   457 /** Calls CFbsBitmap::Compress() */

   458 void CT_DataFbsBitmap::DoCmdCompress(const TDesC& aSection)

   459 	{

   460 	INFO_PRINTF1(_L("Calls CFbsBitmap::Compress()"));

   461 

   462 	TInt							err=KErrNone;

   463 	TBitmapfileCompressionScheme	compressionScheme;

   464 	if ( CT_GraphicsUtil::ReadBitmapfileCompressionScheme(*this, aSection, KBitmapfileCompressionScheme(), compressionScheme) )

   465 		{

   466 		err=GetFbsBitmap()->Compress(compressionScheme);

   467 		}

   468 	else

   469 		{

   470 		// call Compress()

   471 		err=GetFbsBitmap()->Compress();

   472 		}

   473 	// check error code

   474 	if ( err!=KErrNone )

   475 		{

   476 		ERR_PRINTF2(_L("Compress error: %d"), err);

   477 		SetError(err);

   478 		iCompressFailed = ETrue;

   479 		}

   480 	else

   481 	    {

   482 	    iCompressFailed = EFalse;

   483 	    };

   484 	}

   485 

   486 /** Calls CFbsBitmap::CompressInBackground() */

   487 void CT_DataFbsBitmap::DoCmdCompressInBackground(const TDesC& aSection, const TInt aAsyncErrorIndex)

   488 	{

   489 	INFO_PRINTF1(_L("Calls CFbsBitmap::CompressInBackground()"));

   490 

   491 	// get a flag if to use requset status from parameters

   492 	TBool	useRequestStatus = EFalse;

   493 	GetBoolFromConfig(aSection, KUseRequestStatus(), useRequestStatus);

   494 

   495 	TBitmapfileCompressionScheme	compressionScheme;

   496 	TBool							hasCompressionScheme=CT_GraphicsUtil::ReadBitmapfileCompressionScheme(*this, aSection, KBitmapfileCompressionScheme(), compressionScheme);

   497 

   498 	// call CompressInBackground()

   499 	if ( useRequestStatus )

   500 		{

   501 		if ( hasCompressionScheme )

   502 			{

   503 			GetFbsBitmap()->CompressInBackground(iActiveCompressInBackground->iStatus, compressionScheme);

   504 			}

   505 		else

   506 			{

   507 			GetFbsBitmap()->CompressInBackground(iActiveCompressInBackground->iStatus);

   508 			}

   509 		iActiveCompressInBackground->Activate(aAsyncErrorIndex);

   510 		IncOutstanding();

   511 		}

   512 	else

   513 		{

   514 		TInt	err = KErrNone;

   515 

   516 		if ( hasCompressionScheme )

   517 			{

   518 			err=GetFbsBitmap()->CompressInBackground(compressionScheme);

   519 			}

   520 		else

   521 			{

   522 			err=GetFbsBitmap()->CompressInBackground();

   523 			}

   524 

   525 		// check error code

   526 		if ( err != KErrNone )

   527 			{

   528 			ERR_PRINTF2(_L("Compress in background error: %d"), err);

   529 			SetError(err);

   530 			iCompressFailed = ETrue;

   531 			}

   532 		else

   533 		    {

   534 		    iCompressFailed = EFalse;

   535 		    }

   536 		}

   537 	}

   538 

   539 /** Calls CFbsBitmap::Create() */

   540 void CT_DataFbsBitmap::DoCmdCreate(const TDesC& aSection)

   541 	{

   542 	INFO_PRINTF1(_L("Calls CFbsBitmap::Create()"));

   543 

   544 	// get size height from parameters

   545 	TInt	height;

   546 	if(!GetIntFromConfig(aSection, KHeight(), height))

   547 		{

   548 		ERR_PRINTF2(_L("No %S"), &KHeight());

   549 		SetBlockResult(EFail);

   550 		}

   551 

   552 	// get size width from parameters

   553 	TInt	width;

   554 	if(!GetIntFromConfig(aSection, KWidth(), width))

   555 		{

   556 		ERR_PRINTF2(_L("No %S"), &KWidth());

   557 		SetBlockResult(EFail);

   558 		}

   559 

   560 	// get display mode from parameters

   561 

   562 	TDisplayMode	displayMode;

   563 	if ( !CT_GraphicsUtil::ReadDisplayMode(*this, aSection, KDisplayMode(), displayMode) )

   564 		{

   565 		ERR_PRINTF1(_L("No display mode"));

   566 		SetBlockResult(EFail);

   567 		}

   568 	else

   569 		{

   570 		// call Create()

   571 		TInt	err = GetFbsBitmap()->Create(TSize(width, height), displayMode);

   572 

   573 		// check error code

   574 		if (err != KErrNone)

   575 			{

   576 			ERR_PRINTF2(_L("Creation error: %d"), err);

   577 			SetError(err);

   578 			}

   579 		}

   580 	}

   581 

   582 /** Calls CFbsBitmap::CreateHardwareBitmap() */

   583 void CT_DataFbsBitmap::DoCmdCreateHardwareBitmap(const TDesC& aSection)

   584 	{

   585 	INFO_PRINTF1(_L("Calls CFbsBitmap::CreateHardwareBitmap()"));

   586 

   587 	// get size height from parameters

   588 	TInt	height;

   589 	if(!GetIntFromConfig(aSection, KHeight(), height))

   590 		{

   591 		ERR_PRINTF2(_L("No %S"), &KHeight());

   592 		SetBlockResult(EFail);

   593 		}

   594 

   595 	// get size width from parameters

   596 	TInt	width;

   597 	if(!GetIntFromConfig(aSection, KWidth(), width))

   598 		{

   599 		ERR_PRINTF2(_L("No %S"), &KWidth());

   600 		SetBlockResult(EFail);

   601 		}

   602 

   603 	// get display mode from parameters

   604 	TDisplayMode	displayMode;

   605 	if ( !CT_GraphicsUtil::ReadDisplayMode(*this, aSection, KDisplayMode(), displayMode) )

   606 		{

   607 		ERR_PRINTF1(_L("No display mode"));

   608 		SetBlockResult(EFail);

   609 		}

   610 

   611 	// get application uid from parameters

   612 	TInt	uidInt;

   613 	if(!GetIntFromConfig(aSection, KUid(), uidInt))

   614 		{

   615 		ERR_PRINTF2(_L("No %S"), &KUid());

   616 		SetBlockResult(EFail);

   617 		}

   618 

   619 	// call Create()

   620 	TInt	err = GetFbsBitmap()->CreateHardwareBitmap(TSize(width, height), displayMode, TUid::Uid(uidInt));

   621 

   622 	// check error code

   623 	if ( err != KErrNone )

   624 		{

   625 		ERR_PRINTF2(_L("Hardware bitmap creation error: %d"), err);

   626 		SetError(err);

   627 		}

   628 	}

   629 

   630 /** Calls CFbsBitmap::DataAddress() locking and unlocking heap by defined in parameters means */

   631 void CT_DataFbsBitmap::DoCmdDataAddress(const TDesC& aSection)

   632 	{

   633 	// call DataAddress()

   634 	TUint32*	address=GetFbsBitmap()->DataAddress();

   635 	INFO_PRINTF2(_L("DataAddress %d"), address);

   636 

   637 	// validate returned value if needed

   638 	TInt	expectedValue;

   639 	if(GetIntFromConfig(aSection, KExpectedInt(), expectedValue))

   640 		{

   641 		if (expectedValue != (TInt)address)

   642 			{

   643 			ERR_PRINTF1(_L("The returned value is not as expected"));

   644 			SetBlockResult(EFail);

   645 			}

   646 		}

   647 	}

   648 

   649 /** Calls CFbsBitmap::DataStride() */

   650 void CT_DataFbsBitmap::DoCmdDataStride(const TDesC& aSection)

   651 	{

   652 	INFO_PRINTF1(_L("Calls CFbsBitmap::DataStride()"));

   653 	

   654 	// call DataStride()

   655 	TInt value = GetFbsBitmap()->DataStride();

   656 	INFO_PRINTF2(_L("Data stride: %d"), value);

   657 

   658 	// validate returned value if needed

   659 	TInt expectedValue;

   660 	if(GetIntFromConfig(aSection, KExpectedInt(), expectedValue))

   661 		{

   662 		if (expectedValue != value)

   663 			{

   664 			ERR_PRINTF3(_L("The returned value is not as expected, expected: %d, actual: %d"), expectedValue, value);

   665 			SetBlockResult(EFail);

   666 			}

   667 		}

   668 

   669 	// check the value is not NULL

   670 	if (value <= 0)

   671 		{

   672 		ERR_PRINTF2(_L("The data stride is not expected zero or less, value: %d"), value);

   673 		SetBlockResult(EFail);

   674 		}

   675 	}

   676 

   677 /** Checks CFbsBitmap::DisplayMode() value */

   678 void CT_DataFbsBitmap::DoCmdDisplayMode(const TDesC& aSection)

   679 	{

   680 	INFO_PRINTF1(_L("Checks CFbsBitmap::DisplayMode() value"));

   681 

   682 	// call DisplayMode()

   683 	iDisplayMode=GetFbsBitmap()->DisplayMode();

   684 	INFO_PRINTF2(_L("Display Mode %d"), iDisplayMode);

   685 

   686 	// get display mode from parameters

   687 	TDisplayMode	expectedValue;

   688 	if ( CT_GraphicsUtil::ReadDisplayMode(*this, aSection, KDisplayMode(), expectedValue) )

   689 		{

   690 		// check value against NULL

   691 		if ( iDisplayMode!=expectedValue )

   692 			{

   693 			ERR_PRINTF3(_L("The value is not as expected! expected: %d, actual: %d"), expectedValue, iDisplayMode);

   694 			SetBlockResult(EFail);

   695 			}

   696 		}

   697 	}

   698 

   699 /** Calls CFbsBitmap::Duplicate() */

   700 void CT_DataFbsBitmap::DoCmdDuplicateL(const TDesC& aSection)

   701 	{

   702 	INFO_PRINTF1(_L("Calls CFbsBitmap::Duplicate()"));

   703 	TInt	handle=GetHandle();

   704 	TPtrC	objectName;

   705 	if ( GetStringFromConfig(aSection, KFbsBitmapName(), objectName) )

   706 		{

   707 		CDataWrapperBase*	wrapper=static_cast<CDataWrapperBase*>(GetDataWrapperL(objectName));

   708 		handle=wrapper->GetHandle();

   709 		}

   710 	else

   711 		{

   712 		GetIntFromConfig(aSection, KHandle(), handle);

   713 		}

   714 

   715 	// call Duplicate()

   716 	TInt	err = GetFbsBitmap()->Duplicate(handle);

   717 	if (err != KErrNone)

   718 		{

   719 		ERR_PRINTF2(_L("Duplicate error: %d"), err);

   720 		SetError(err);

   721 		}

   722 	}

   723 

   724 /** Calls CFbsBitmap::ExternalizeL() */

   725 void CT_DataFbsBitmap::DoCmdExternalizeL(const TDesC& aSection)

   726 	{

   727 	INFO_PRINTF1(_L("Calls CFbsBitmap::ExternalizeL()"));

   728 	ExternalizeImplL(aSection, TRect(), EFalse);

   729 	}

   730 

   731 /** Calls CFbsBitmap::ExternalizeRectangleL() */

   732 void CT_DataFbsBitmap::DoCmdExternalizeRectangleL(const TDesC& aSection)

   733 	{

   734 	INFO_PRINTF1(_L("Calls CFbsBitmap::ExternalizeRectangleL()"));

   735 

   736 	// get rectangle top left x-coordinate from parameters

   737 	TInt	tlx;

   738 	if(!GetIntFromConfig(aSection, KRectTlX(), tlx))

   739 		{

   740 		ERR_PRINTF2(_L("No %S"), &KRectTlX());

   741 		SetBlockResult(EFail);

   742 		}

   743 

   744 	// get rectangle top left x-coordinate from parameters

   745 	TInt	tly;

   746 	if(!GetIntFromConfig(aSection, KRectTlY(), tly))

   747 		{

   748 		ERR_PRINTF2(_L("No %S"), &KRectTlY());

   749 		SetBlockResult(EFail);

   750 		}

   751 

   752 	// get rectangle top left x-coordinate from parameters

   753 	TInt	brx;

   754 	if(!GetIntFromConfig(aSection, KRectBrX(), brx))

   755 		{

   756 		ERR_PRINTF2(_L("No %S"), &KRectBrX());

   757 		SetBlockResult(EFail);

   758 		}

   759 

   760 	// get rectangle top left x-coordinate from parameters

   761 	TInt	bry;

   762 	if(!GetIntFromConfig(aSection, KRectBrY(), bry))

   763 		{

   764 		ERR_PRINTF2(_L("No %S"), &KRectBrY());

   765 		SetBlockResult(EFail);

   766 		}

   767 

   768 	ExternalizeImplL(aSection, TRect(tlx, tly, brx, bry), ETrue);

   769 	}

   770 

   771 /** Calls CFbsBitmap::GetPalette() */

   772 void CT_DataFbsBitmap::DoCmdGetPaletteL(const TDesC& aSection)

   773 	{

   774 	// call GetPalette()

   775 	CPalette*	palette = NULL;

   776 	TInt		err = GetFbsBitmap()->GetPalette(palette);

   777 	INFO_PRINTF2(_L("Calls CFbsBitmap::GetPalette() %d"), palette);

   778 

   779 	// check error code

   780 	if (err != KErrNone)

   781 		{

   782 		ERR_PRINTF2(_L("GetPalette error: %d"), err);

   783 		SetError(err);

   784 		}

   785 	else

   786 		{

   787 		//	Verify palette

   788 		CPalette*	expectedPalette = NULL;

   789 

   790 		if ( CT_GraphicsUtil::GetPaletteL(*this, aSection, KPalette(), expectedPalette) )

   791 			{

   792 			if ( palette != expectedPalette )

   793 				{

   794 				ERR_PRINTF3(_L("GetPalette palette %d not the expected palette %d"), palette, expectedPalette);

   795 				SetBlockResult(EFail);

   796 				}

   797 			}

   798 		}

   799 	}

   800 

   801 /** Calls CFbsBitmap::GetPixel() */

   802 void CT_DataFbsBitmap::DoCmdGetPixel(const TDesC& aSection)

   803 	{

   804 	INFO_PRINTF1(_L("Calls CFbsBitmap::GetPixel()"));

   805 

   806 	// get point x-coordinate from parameters

   807 	TInt	pointX;

   808 	if(!GetIntFromConfig(aSection, KPointX(), pointX))

   809 		{

   810 		ERR_PRINTF2(_L("No %S"), &KPointX());

   811 		SetBlockResult(EFail);

   812 		}

   813 

   814 	// get point y-coordinate from parameters

   815 	TInt	pointY;

   816 	if(!GetIntFromConfig(aSection, KPointY(), pointY))

   817 		{

   818 		ERR_PRINTF2(_L("No %S"), &KPointY());

   819 		SetBlockResult(EFail);

   820 		}

   821 

   822 	// call GetPixel()

   823 	TRgb	color;

   824 	GetFbsBitmap()->GetPixel(color, TPoint(pointX, pointY));

   825 

   826 	INFO_PRINTF2(_L("Red    %d"), color.Red());

   827 	INFO_PRINTF2(_L("Green  %d"), color.Green());

   828 	INFO_PRINTF2(_L("Blue   %d"), color.Blue());

   829 

   830 	TInt	actual;

   831 	TInt	expected;

   832 

   833 	if(GetIntFromConfig(aSection, KRed(), expected))

   834 		{

   835 		actual=color.Red();

   836 		if ( expected != actual )

   837 			{

   838 			ERR_PRINTF3(_L("Expected Red %d does not match actual %d"), expected, actual);

   839 			SetBlockResult(EFail);

   840 			}

   841 		}

   842 

   843 	if(GetIntFromConfig(aSection, KGreen(), expected))

   844 		{

   845 		actual=color.Green();

   846 		if ( expected != actual )

   847 			{

   848 			ERR_PRINTF3(_L("Expected Green %d does not match actual %d"), expected, actual);

   849 			SetBlockResult(EFail);

   850 			}

   851 		}

   852 	

   853 	if(GetIntFromConfig(aSection, KBlue(), expected))

   854 		{

   855 		actual=color.Blue();

   856 		if ( expected != actual )

   857 			{

   858 			ERR_PRINTF3(_L("Expected Blue %d does not match actual %d"), expected, actual);

   859 			SetBlockResult(EFail);

   860 			}

   861 		}

   862 	}

   863 

   864 /** Calls CFbsBitmap::GetScanLine() */

   865 void CT_DataFbsBitmap::DoCmdGetScanLineL(const TDesC& aSection)

   866 	{

   867 	INFO_PRINTF1(_L("Calls CFbsBitmap::GetScanLine()"));

   868 	TBool								dataOk=ETrue;

   869 

   870 	// get point x coordinate from parameters

   871 	TInt	pointX = 0;

   872 	if(!GetIntFromConfig(aSection, KPointX(), pointX))

   873 		{

   874 		ERR_PRINTF2(_L("No %S"), &KPointX());

   875 		SetBlockResult(EFail);

   876 		dataOk=EFalse;

   877 		}

   878 

   879 	// get point y coordinate from parameters

   880 	TInt	pointY = 0;

   881 	if(!GetIntFromConfig(aSection, KPointY(), pointY))

   882 		{

   883 		ERR_PRINTF2(_L("No %S"), &KPointY());

   884 		SetBlockResult(EFail);

   885 		dataOk=EFalse;

   886 		}

   887 

   888 	// get length from parameters

   889 	TInt	length = 0;

   890 	if(!GetIntFromConfig(aSection, KLength(), length))

   891 		{

   892 		ERR_PRINTF2(_L("No %S"), &KLength());

   893 		SetBlockResult(EFail);

   894 		dataOk=EFalse;

   895 		}

   896 

   897 	// get buffer length from parameters

   898 	TInt	buffLength = 0;

   899 	if(!GetIntFromConfig(aSection, KBuffLength(), buffLength))

   900 		{

   901 		ERR_PRINTF2(_L("No %S"), &KBuffLength());

   902 		SetBlockResult(EFail);

   903 		dataOk=EFalse;

   904 		}

   905 

   906 	// get display mode from parameters

   907 	TDisplayMode	displayMode;

   908 	if ( !CT_GraphicsUtil::ReadDisplayMode(*this, aSection, KDisplayMode(), displayMode) )

   909 		{

   910 		ERR_PRINTF1(_L("No display mode"));

   911 		SetBlockResult(EFail);

   912 		dataOk=EFalse;

   913 		}

   914 

   915 	if ( dataOk )

   916 		{

   917 		// call GetScanLine()

   918 		TUint8*	buffer = new (ELeave) TUint8[buffLength];

   919 		TPtr8	scanline(buffer, buffLength, buffLength);

   920 

   921 		GetFbsBitmap()->GetScanLine(scanline, TPoint(pointX, pointY), length, displayMode);

   922 

   923 		delete [] buffer;

   924 		}

   925 	}

   926 

   927 /** Calls CFbsBitmap::GetVerticalScanLine() */

   928 void CT_DataFbsBitmap::DoCmdGetVerticalScanLineL(const TDesC& aSection)

   929 	{

   930 	INFO_PRINTF1(_L("Calls CFbsBitmap::GetVerticalScanLine()"));

   931 	TBool								dataOk=ETrue;

   932 

   933 	// get point x coordinate from parameters

   934 	TInt	pointX = 0;

   935 	if(!GetIntFromConfig(aSection, KPointX(), pointX))

   936 		{

   937 		ERR_PRINTF2(_L("No %S"), &KPointX());

   938 		SetBlockResult(EFail);

   939 		dataOk=EFalse;

   940 		}

   941 

   942 	// get if to use dither offset flag from parameters

   943 	TBool	useDitherOffset = EFalse;

   944 	if(!GetBoolFromConfig(aSection, KUseDitherOffset(), useDitherOffset))

   945 		{

   946 		ERR_PRINTF2(_L("No %S"), &KUseDitherOffset());

   947 		SetBlockResult(EFail);

   948 		dataOk=EFalse;

   949 		}

   950 

   951 	// get dither offset x coordinate from parameters

   952 	TInt	ditherOffsetX = 0;

   953 	if(useDitherOffset && !GetIntFromConfig(aSection, KDitherOffsetX(), ditherOffsetX))

   954 		{

   955 		ERR_PRINTF2(_L("No %S"), &KDitherOffsetX());

   956 		SetBlockResult(EFail);

   957 		dataOk=EFalse;

   958 		}

   959 

   960 	// get dither offset y coordinate from parameters

   961 	TInt	ditherOffsetY = 0;

   962 	if(useDitherOffset && !GetIntFromConfig(aSection, KDitherOffsetY(), ditherOffsetY))

   963 		{

   964 		ERR_PRINTF2(_L("No %S"), &KDitherOffsetY());

   965 		SetBlockResult(EFail);

   966 		dataOk=EFalse;

   967 		}

   968 

   969 	// get buffer length from parameters

   970 	TInt	buffLength = 0;

   971 	if(!GetIntFromConfig(aSection, KBuffLength(), buffLength))

   972 		{

   973 		ERR_PRINTF2(_L("No %S"), &KBuffLength());

   974 		SetBlockResult(EFail);

   975 		dataOk=EFalse;

   976 		}

   977 

   978 	// get display mode from parameters

   979 	TDisplayMode	displayMode;

   980 	if ( !CT_GraphicsUtil::ReadDisplayMode(*this, aSection, KDisplayMode(), displayMode) )

   981 		{

   982 		ERR_PRINTF1(_L("No display mode"));

   983 		SetBlockResult(EFail);

   984 		dataOk=EFalse;

   985 		}

   986 

   987 	if ( dataOk )

   988 		{

   989 		// call GetVerticalScanLine()

   990 		TUint8*	buffer = new (ELeave) TUint8[buffLength];

   991 		TPtr8 	scanline(buffer, buffLength, buffLength);

   992 

   993 		if (useDitherOffset)

   994 			{

   995 			GetFbsBitmap()->GetVerticalScanLine(scanline, pointX, displayMode);

   996 			}

   997 		else

   998 			{

   999 			GetFbsBitmap()->GetVerticalScanLine(scanline, pointX, TPoint(ditherOffsetX, ditherOffsetY), displayMode);

  1000 			}

  1001 

  1002 		delete [] buffer;

  1003 		}

  1004 	}

  1005 

  1006 /** Calls CFbsBitmap::Handle() */

  1007 void CT_DataFbsBitmap::DoCmdHandle(const TDesC& aSection)

  1008 	{

  1009 	

  1010 	// call Handle()

  1011 	TInt	handle=GetFbsBitmap()->Handle();

  1012 	INFO_PRINTF2(_L("Calls CFbsBitmap::Handle() %d"), handle);

  1013 	SetHandle(handle);

  1014 

  1015 	// validate returned value if needed

  1016 	TInt	expectedValue;

  1017 	if(GetIntFromConfig(aSection, KExpectedInt(), expectedValue))

  1018 		{

  1019 		if (expectedValue != handle)

  1020 			{

  1021 			ERR_PRINTF3(_L("The returned value is not as expected, expected: %d, actual: %d"), expectedValue, handle);

  1022 			SetBlockResult(EFail);

  1023 			}

  1024 		}

  1025 	}

  1026 

  1027 /** Checks CFbsBitmap::HardwareBitmapHandle() */

  1028 void CT_DataFbsBitmap::DoCmdHardwareBitmapHandle(const TDesC& aSection)

  1029 	{

  1030 	// call HardwareBitmapHandle()

  1031 	TInt	handle=GetFbsBitmap()->HardwareBitmapHandle();

  1032 	INFO_PRINTF2(_L("CFbsBitmap::HardwareBitmapHandle() %d"), handle);

  1033 	SetHandle(handle);

  1034 

  1035 	// get if null expected flag from parameters

  1036 	TBool	nullExpected = EFalse;

  1037 	if ( GetBoolFromConfig(aSection, KNullExpected(), nullExpected) )

  1038 		{

  1039 		// check value againts NULL

  1040 		if ( (handle == NULL) != nullExpected )

  1041 			{

  1042 			ERR_PRINTF2(_L("The value is not as expected! value: %d"), handle);

  1043 			SetBlockResult(EFail);

  1044 			}

  1045 		}

  1046 	}

  1047 

  1048 /** Calls CFbsBitmap::Header() */

  1049 void CT_DataFbsBitmap::DoCmdHeader()

  1050 	{

  1051 	INFO_PRINTF1(_L("Calls CFbsBitmap::Header()"));

  1052 

  1053 	// call Header()

  1054 	SEpocBitmapHeader	header=GetFbsBitmap()->Header();

  1055 	INFO_PRINTF2(_L("Header iBitmapSize     &d"), header.iBitmapSize);

  1056 	INFO_PRINTF2(_L("Header iBitsPerPixel   &d"), header.iBitsPerPixel);

  1057 	INFO_PRINTF2(_L("Header iColor          &d"), header.iColor);

  1058 	INFO_PRINTF2(_L("Header iCompression    &d"), header.iCompression);

  1059 	INFO_PRINTF2(_L("Header iPaletteEntries &d"), header.iPaletteEntries);

  1060 	INFO_PRINTF3(_L("Header iSizeInPixels   &d %d"), header.iSizeInPixels.iWidth, header.iSizeInPixels.iHeight);

  1061 	INFO_PRINTF3(_L("Header iSizeInTwips    &d %d"), header.iSizeInTwips.iWidth, header.iSizeInTwips.iHeight);

  1062 	INFO_PRINTF2(_L("Header iStructSize     &d"), header.iStructSize);

  1063 	}

  1064 

  1065 /** Calls CFbsBitmap::HorizontalPixelsToTwips() */

  1066 void CT_DataFbsBitmap::DoCmdHorizontalPixelsToTwips(const TDesC& aSection)

  1067 	{

  1068 	INFO_PRINTF1(_L("Calls CFbsBitmap::HorizontalPixelsToTwips()"));

  1069 

  1070 	// get pixels from parameters

  1071 	TInt	pixels;

  1072 	if(!GetIntFromConfig(aSection, KPixels(), pixels))

  1073 		{

  1074 		ERR_PRINTF2(_L("No %S"), &KPixels());

  1075 		SetBlockResult(EFail);

  1076 		}

  1077 

  1078 	// call HorizontalPixelsToTwips()

  1079 	TInt	value = GetFbsBitmap()->HorizontalPixelsToTwips(pixels);

  1080 	INFO_PRINTF2(_L("Twips: %d"), value);

  1081 

  1082 	// validate returned value if needed

  1083 	TInt	expectedValue;

  1084 	if(GetIntFromConfig(aSection, KExpectedInt(), expectedValue))

  1085 		{

  1086 		if (expectedValue != value)

  1087 			{

  1088 			ERR_PRINTF3(_L("The returned value is not as expected, expected: %d, actual: %d"), expectedValue, value);

  1089 			SetBlockResult(EFail);

  1090 			}

  1091 		}

  1092 	}

  1093 

  1094 /** Calls CFbsBitmap::HorizontalTwipsToPixels() */

  1095 void CT_DataFbsBitmap::DoCmdHorizontalTwipsToPixels(const TDesC& aSection)

  1096 	{

  1097 	INFO_PRINTF1(_L("Calls CFbsBitmap::HorizontalTwipsToPixels()"));

  1098 

  1099 	// get twips from parameters

  1100 	TInt	twips;

  1101 	if(!GetIntFromConfig(aSection, KTwips(), twips))

  1102 		{

  1103 		ERR_PRINTF2(_L("No %S"), &KTwips());

  1104 		SetBlockResult(EFail);

  1105 		}

  1106 

  1107 	// call HorizontalTwipsToPixels()

  1108 	TInt	value = GetFbsBitmap()->HorizontalTwipsToPixels(twips);

  1109 	INFO_PRINTF2(_L("Pixels: %d"), value);

  1110 

  1111 	// validate returned value if needed

  1112 	TInt	expectedValue;

  1113 	if(GetIntFromConfig(aSection, KExpectedInt(), expectedValue))

  1114 		{

  1115 		if (expectedValue != value)

  1116 			{

  1117 			ERR_PRINTF3(_L("The returned value is not as expected, expected: %d, actual: %d"), expectedValue, value);

  1118 			SetBlockResult(EFail);

  1119 			}

  1120 		}

  1121 	}

  1122 

  1123 /** Checks CFbsBitmap::InitialDisplayMode() value */

  1124 void CT_DataFbsBitmap::DoCmdInitialDisplayMode(const TDesC& aSection)

  1125 	{

  1126 	INFO_PRINTF1(_L("Checks CFbsBitmap::InitialDisplayMode() value"));

  1127 

  1128 	// call InitialDisplayMode()

  1129 	TInt	actualValue = GetFbsBitmap()->InitialDisplayMode();

  1130 	INFO_PRINTF2(_L("Initial Display Mode %d"), actualValue);

  1131 

  1132 	// get display mode from parameters

  1133 	TDisplayMode	expectedValue;

  1134 	if ( CT_GraphicsUtil::ReadDisplayMode(*this, aSection, KDisplayMode(), expectedValue) )