// Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//
#include <graphicsaccelerator.h>
#include "TAccelerator.h"
#include <graphics/fbsdefs.h>
class TAcceleratedBitmapSpecTest : public TAcceleratedBitmapSpec
{
// Provides public access to TAcceleratedBitmapSpec
public:
inline TAcceleratedBitmapSpecTest() : TAcceleratedBitmapSpec() {}
inline TAcceleratedBitmapSpecTest(CFbsBitmap* aBitmap) : TAcceleratedBitmapSpec(aBitmap) {}
inline TAcceleratedBitmapSpecTest(RHardwareBitmap aBitmap) : TAcceleratedBitmapSpec(aBitmap) {}
//
inline TInt GetInfo(TAcceleratedBitmapInfo& aInfo) const { return TAcceleratedBitmapSpec::GetInfo(aInfo); }
inline void Lock(TBitmapLockCount& aCount) { TAcceleratedBitmapSpec::Lock(aCount); }
inline void Lock(TBitmapLockCount& aCount,TAcceleratedBitmapInfo& aInfo) { TAcceleratedBitmapSpec::Lock(aCount,aInfo); }
inline void Unlock(TBitmapLockCount& aCount) { TAcceleratedBitmapSpec::Unlock(aCount); }
};
const TInt KNumDisplayModes = 13;
static struct
{
TDisplayMode iMode;
TBool iEnabled;
TInt iPixelShift;
} TestDisplayModes[KNumDisplayModes] =
{
{EGray2,EFalse,0},
{EGray4,EFalse,1},
{EGray16,EFalse,2},
{EGray256,EFalse,3},
{EColor16,EFalse,2},
{EColor256,EFalse,3},
{EColor64K,EFalse,4},
{EColor16M,EFalse,5},
{ERgb,EFalse,5},
{EColor4K,EFalse,4},
{EColor16MU,EFalse,5},
{EColor16MA,EFalse,5},
{EColor16MAP,EFalse,5}
};
_LIT(KRam32BitmapOnZ, "z:\\system\\data\\32RAM.mbm");
_LIT(KRamC24BitmapOnZ, "z:\\system\\data\\24RAMC.mbm");
_LIT(KRomC24Bitmap, "z:\\system\\data\\24ROMC.mbm");
//
// CTestBitmap
//
TInt CTestBitmap::ConstructL(TDisplayMode aDisplayMode,TSize aSize,TBool aHWBitmap)
{
Reset();
iBitmap = new CFbsBitmap;
if(iBitmap==NULL)
User::Panic(_L("Bitmap not created"),KErrGeneral);
TInt ret;
if(aHWBitmap)
ret = iBitmap->CreateHardwareBitmap(aSize,aDisplayMode,TUid());
else
ret = iBitmap->Create(aSize,aDisplayMode);
if (ret == KErrNotSupported)
{
Reset();
return ret;
}
User::LeaveIfError(ret);
TRAPD(err,iDevice = CFbsBitmapDevice::NewL(iBitmap));
if(err)
User::Panic(_L("BitmapDevice not created"),err);
err = iDevice->CreateContext(iGc);
if(err)
User::Panic(_L("BitmapDevice not created"),err);
return KErrNone;
}
void CTestBitmap::Reset()
{
delete iGc;
iGc = 0;
delete iDevice;
iDevice = 0;
delete iBitmap;
iBitmap = 0;
}
CTestBitmap::~CTestBitmap()
{
Reset();
}
TBool CTestBitmap::Compare(CTestBitmap* aBitmap2)
{
TInt width=iBitmap->SizeInPixels().iWidth;
TInt pitch = iBitmap->DataStride();
TInt height=iBitmap->SizeInPixels().iHeight;
for(TInt yLoop=0;yLoop<height;yLoop++)
{
TInt offset=yLoop*pitch;
TUint8* data1 = ((TUint8*)iBitmap->DataAddress())+offset;
TUint8* data2 = ((TUint8*)aBitmap2->iBitmap->DataAddress())+offset;
TUint8* dataLimit = data1 + CFbsBitmap::ScanLineLength(width, iBitmap->DisplayMode());
while(data1<dataLimit)
{
if(*(data1++)!=*(data2++))
{
iBitmap->Save(_L("C:\\Compare1.mbm"));
aBitmap2->iBitmap->Save(_L("C:\\Compare2.mbm"));
return EFalse;
}
}
}
return(ETrue);
}
//
// CTAccelerator
//
CTAccelerator::CTAccelerator(CTestStep* aStep):
CTGraphicsBase(aStep),
iRandomSeed(1),
iGraphicsAccelerator1(0),
iGraphicsAccelerator2(0),
iHwScreenDevice(0),
iScreenGc(0)
{
TInt i;
for(i=0;i<9;i++)
iFixedRegion.AddRect(TRect(i*16,i*8,i*16+32,i*8+32));
for(i=0;i<9;i++)
iFixedRegion.AddRect(TRect(183-(i*16),i*8,199-(i*16),i*8+32));
iDefaultRegion.AddRect(TRect(0,0,199,99));
INFO_PRINTF1(_L("Graphics Accelerator Testing"));
}
void CTAccelerator::Cleanup()
{
delete iGraphicsAccelerator1;
iGraphicsAccelerator1 = 0;
delete iGraphicsAccelerator2;
iGraphicsAccelerator2 = 0;
if(iHwScreenDevice)
{
delete iHwScreenDevice;
iHwScreenDevice = 0;
}
if(iScreenGc)
{
delete iScreenGc;
iScreenGc = 0;
}
iBitmap1.Reset();
iBitmap2.Reset();
iBitmap3.Reset();
iBitmap4.Reset();
iBitmap5.Reset();
iBitmap6.Reset();
iBitmap7.Reset();
iTileBitmap.Reset();
iAlphaBitmap.Reset();
}
TInt CTAccelerator::Random(TInt aMax) // aMax <= 0xFFFF
{
iRandomSeed *= 69069;
TUint r = ((iRandomSeed>>16)*aMax)>>16;
return r;
}
void CTAccelerator::RunTestCaseL(TInt aCurTestCase)
{
TInt i;
((CTAcceleratorStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
switch(aCurTestCase)
{
case 1:
((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0021"));
INFO_PRINTF1(_L("Testing TAcceleratedBitmapSpec with software bitmaps."));
for(i=0; i<KNumDisplayModes; i++)
if (TestDisplayModes[i].iEnabled)
{
TestAcceleratedBitmapSpecL(TestDisplayModes[i].iMode,EFalse);
}
break;
case 2:
((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0022"));
INFO_PRINTF1(_L("Testing graphics operations with software bitmaps."));
for(i=0; i<KNumDisplayModes; i++)
if (TestDisplayModes[i].iEnabled)
{
TestGraphicsOperations(TestDisplayModes[i].iMode,EFalse);
}
break;
case 3:
((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0021"));
INFO_PRINTF1(_L("Testing TAcceleratedBitmapSpec with hardware bitmaps."));
for(i=0; i<KNumDisplayModes; i++)
if (TestDisplayModes[i].iEnabled)
{
TestAcceleratedBitmapSpecL(TestDisplayModes[i].iMode,ETrue);
}
break;
case 4:
((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0022"));
INFO_PRINTF1(_L("Testing graphics operations with hardware bitmaps."));
for(i=0; i<KNumDisplayModes; i++)
if (TestDisplayModes[i].iEnabled)
{
TestGraphicsOperations(TestDisplayModes[i].iMode,ETrue);
}
break;
case 5:
((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0023"));
INFO_PRINTF1(_L("Testing graphics operations with hardware bitmap as screen."));
for(i=0; i<KNumDisplayModes; i++)
if (TestDisplayModes[i].iEnabled)
{
TestGraphicsOperationsWithScreenL(TestDisplayModes[i].iMode,ETrue);
}
break;
case 6:
/**
@SYMTestCaseID GRAPHICS-BITGDI-0112
*/
((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0112"));
INFO_PRINTF1(_L("Testing passing of compressed info to accelerator"));
TestAcceleratorInfo();
break;
case 7:
/**
@SYMTestCaseID GRAPHICS-BITGDI-0113
*/
((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0113"));
INFO_PRINTF1(_L("Testing GetInfo() with an extended bitmap"));
TestAcceleratorInfoForExtendedBitmapL();
break;
case 8:
((CTAcceleratorStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
((CTAcceleratorStep*)iStep)->CloseTMSGraphicsStep();
TestComplete();
break;
}
((CTAcceleratorStep*)iStep)->RecordTestResultL();
}
const TSize TestBitmapSize = TSize(199,99);
TSize TestScreenSize;
const TSize TestBitmapSize1 = TSize(165,53);
/**
@SYMTestCaseID GRAPHICS-BITGDI-0021
@SYMCreationDate 21/11/2008
@SYMAuthor douglashetherington
@SYMTestStatus 3. Released
@SYMTestPriority High
@SYMTestCaseDesc Checks that TAcceleratedBitmapSpec does not change the underlaying bitmaps data
@SYMTestExpectedResults The bitmap data is not changed
@SYMTestActions Creates a bitmap, puts it into a TAcceleratedBitmapSpec then checks the pixel data is unchanged
@SYMDEF
*/
void CTAccelerator::TestAcceleratedBitmapSpecL(TDisplayMode aDisplayMode,TBool aHWBitmap)
{
TInt ret=0;
INFO_PRINTF2(_L(" DisplayMode=%d"),aDisplayMode);
// Create bitmap
ret = iBitmap1.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap);
INFO_PRINTF2(_L(" TestAcceleratedBitmapSpecL ret=%d"),ret);
if(ret!=KErrNone)
{
WARN_PRINTF1(_L(" Not Supported."));
return;
}
TAcceleratedBitmapSpecTest bitmapSpec(iBitmap1.iBitmap);
TAcceleratedBitmapInfo info;
// Check correct size
bitmapSpec.Lock(iBitmapLockCount);
User::LeaveIfError(bitmapSpec.GetInfo(info));
TEST(info.iSize==iBitmap1.iBitmap->SizeInPixels());
INFO_PRINTF3(_L("Test Display Modes , Expected iPixelShift : %d, Actual iPixelShift: %d"),TestDisplayModes[aDisplayMode-1].iPixelShift,info.iPixelShift);
TEST(info.iPixelShift == TestDisplayModes[aDisplayMode-1].iPixelShift);
bitmapSpec.Unlock(iBitmapLockCount);
TInt scanLineLength = iBitmap1.iBitmap->ScanLineLength(TestBitmapSize.iWidth,aDisplayMode);
HBufC8* scanLineBuffer = HBufC8::NewMaxLC(scanLineLength);
TPtr8 scanLine(scanLineBuffer->Des());
TInt y,x;
// fill bitmap with test data
for(y=info.iSize.iHeight-1; y>=0; y--)
{
TUint8* ptr = &(scanLine)[0];
TUint8* ptrLimit = ptr+scanLineLength;
x = 42;
while(ptr<ptrLimit)
*(ptr++) = (TUint8)(y^(x++));
iBitmap1.iBitmap->SetScanLine(scanLine,y);
}
// use TAcceleratedBitmapSpec to check contents
bitmapSpec.Lock(iBitmapLockCount,info);
for(y=0; y<info.iSize.iHeight; y++)
{
TUint8* ptr = info.iAddress+y*info.iLinePitch;
TUint8* ptrLimit = ptr+scanLineLength;
x = 42;
while(ptr<ptrLimit)
if(*(ptr++) != (TUint8)(y^(x++)))
{
ERR_PRINTF2(_L("!!! Failed at compare A, line %d"),y);
User::Leave(KErrGeneral);
}
}
bitmapSpec.Unlock(iBitmapLockCount);
// fill bitmap with test data (inverse of previous)
for(y=info.iSize.iHeight-1; y>=0; y--)
{
TUint8* ptr = &(scanLine)[0];
TUint8* ptrLimit = ptr+scanLineLength;
x = 42;
while(ptr<ptrLimit)
*(ptr++) = (TUint8)~(y^(x++));
iBitmap1.iBitmap->SetScanLine(scanLine,y);
}
// use TAcceleratedBitmapSpec to check contents
bitmapSpec.Lock(iBitmapLockCount,info);
for(y=0; y<info.iSize.iHeight; y++)
{
TUint8* ptr = info.iAddress+y*info.iLinePitch;
TUint8* ptrLimit = ptr+scanLineLength;
x = 42;
while(ptr<ptrLimit)
if(*(ptr++) != (TUint8)~(y^(x++)))
{
ERR_PRINTF2(_L("!!! Failed at compare B, line %d"),y);
User::Leave(KErrGeneral);
}
}
bitmapSpec.Unlock(iBitmapLockCount);
// End
CleanupStack::PopAndDestroy(); //scanLineBuffer
Cleanup();
INFO_PRINTF1(_L(" OK"));
}
class CTestFbsDevice : public CFbsDevice
{
public:
inline CGraphicsAccelerator* StealGraphicsAccelerator()
{ CGraphicsAccelerator* acc = iGraphicsAccelerator; iGraphicsAccelerator = 0; return acc; };
};
/**
@SYMTestCaseID GRAPHICS-BITGDI-0022
@SYMCreationDate 21/11/2008
@SYMAuthor douglashetherington
@SYMTestStatus 3. Released
@SYMTestPriority High
@SYMTestCaseDesc Tests various basic graphic operations
@SYMTestExpectedResults Tests should perform graphics operations succesfully.
@SYMTestActions Creates a number of bitmaps then uses them in various graphic operations
@SYMDEF
*/
void CTAccelerator::TestGraphicsOperations(TDisplayMode aDisplayMode,TBool aHWBitmap)
{
TInt ret=0;
INFO_PRINTF2(_L(" DisplayMode=%d"),aDisplayMode);
TRAPD(errCode, ret = iBitmap1.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));
if((ret!=KErrNone) || (errCode !=KErrNone) || (!iBitmap1.iDevice->GraphicsAccelerator()))
{
WARN_PRINTF1(_L(" Not Supported."));
return;
}
iGraphicsAccelerator1 = ((CTestFbsDevice*)iBitmap1.iDevice)->StealGraphicsAccelerator();
delete iGraphicsAccelerator1;
iGraphicsAccelerator1 = 0;
if(!iSubRegion.IsEmpty())
iSubRegion.Clear();
iSubRegion.AddRect(iBitmap1.iBitmap->SizeInPixels());
iSubRegion.SubRegion(iFixedRegion);
iSubRegionPtr = &iSubRegion;
TRAP(errCode, ret = iBitmap2.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));
TEST(errCode== KErrNone);
if(ret!=KErrNone)
User::Panic(_L("Bitmap not created"),ret);
TRAP(errCode, ret = iBitmap3.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));
TEST(errCode== KErrNone);
if(ret!=KErrNone)
User::Panic(_L("Bitmap not created"),ret);
iGraphicsAccelerator1 = ((CTestFbsDevice*)iBitmap3.iDevice)->StealGraphicsAccelerator();
TRAP(errCode, ret = iBitmap4.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));
TEST(errCode== KErrNone);
if(ret!=KErrNone)
User::Panic(_L("Bitmap not created"),ret);
TRAP(errCode, ret = iBitmap5.ConstructL(aDisplayMode,TestBitmapSize1,aHWBitmap));
TEST(errCode== KErrNone);
if(ret!=KErrNone)
User::Panic(_L("Bitmap not created"),ret);
TRAP(errCode, ret = iBitmap6.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));
TEST(errCode== KErrNone);
if(ret!=KErrNone)
User::Panic(_L("Bitmap not created"),ret);
TRAP(errCode, ret = iBitmap7.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));
TEST(errCode== KErrNone);
if(ret!=KErrNone)
User::Panic(_L("Bitmap not created"),ret);
TRAP(errCode, ret = iBitmap8.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));
TEST(errCode== KErrNone);
if(ret!=KErrNone)
User::Panic(_L("Bitmap not created"),ret);
//BrushBitmap
CFbsBitmap* iTile = new CFbsBitmap();
TEST(iTile!=NULL);
ret = iTile->Load(_L("z:\\system\\data\\tile.mbm"),0,aHWBitmap);
TEST(ret==KErrNone);
TSize tileSize = iTile->SizeInPixels();
TDisplayMode tileDisplayMode = iTile->DisplayMode();
TRAP(errCode, ret = iTileBitmap.ConstructL(tileDisplayMode,tileSize,aHWBitmap));
TEST(errCode== KErrNone);
if(ret== KErrNotSupported)
{
WARN_PRINTF1(_L(" Not Supported."));
delete iTile;
iTile = NULL;
return;
}
iTileBitmap.iGc->BitBlt(TPoint(0,0),iTile);
delete iTile;
iTile = NULL;
//Alpha bitmap
TRAP(errCode, ret = iAlphaBitmap.ConstructL(EGray256,TestBitmapSize,aHWBitmap));
TEST(errCode== KErrNone);
if(ret!=KErrNone)
User::Panic(_L("Bitmap not created"),ret);
iGraphicsAccelerator2 = ((CTestFbsDevice*)iBitmap4.iDevice)->StealGraphicsAccelerator();
INFO_PRINTF1(_L("FilledRect"));
TestFilledRect();
resetColorBitmaps();
INFO_PRINTF1(_L("FilledRectWithPattern "));
TestFilledRectWithPattern();
resetColorBitmaps();
INFO_PRINTF1(_L("InvertRect"));
TestInvertRect();
resetColorBitmaps();
INFO_PRINTF1(_L("FadeRect "));
TestFadeRect();
resetColorBitmaps();
INFO_PRINTF1(_L("BitBlt "));
TestBitBlt();
resetColorBitmaps();
INFO_PRINTF1(_L("BitBltMasked "));
TestBitBltMasked();
resetColorBitmaps();
INFO_PRINTF1(_L("BitBltAlphaBitmap"));
TestBitBltAlphaBitmap();
resetColorBitmaps();
INFO_PRINTF1(_L("AlphaBlendTwoBitmaps "));
TestAlphaBlendTwoBitmaps();
resetColorBitmaps();
INFO_PRINTF1(_L("AlphaBlendOneBitmap "));
TestAlphaBlendOneBitmap();
resetColorBitmaps();
Cleanup();
}
/**
@SYMTestCaseID GRAPHICS-BITGDI-0023
@SYMCreationDate 21/11/2008
@SYMAuthor douglashetherington
@SYMTestStatus 3. Released
@SYMTestPriority High
@SYMTestCaseDesc Tests various basic graphic operations draw directly to the screen device
@SYMTestExpectedResults Tests should perform graphics operations succesfully.
@SYMTestActions Creates a number of bitmaps then uses them in various graphic operations drawing directly to the screen gc
@SYMDEF
*/
void CTAccelerator::TestGraphicsOperationsWithScreenL(TDisplayMode aDisplayMode,TBool aHWBitmap)
{
TInt ret;
INFO_PRINTF2(_L(" DisplayMode=%d."),aDisplayMode);
ret = iBitmap1.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap);
if((ret!=KErrNone) || (!iBitmap1.iDevice->GraphicsAccelerator()))
{
WARN_PRINTF1(_L(" Not Supported."));
return;
}
TRAPD(err,iHwScreenDevice = CFbsScreenDevice::NewL(_L(""),aDisplayMode));
if(err)
User::Panic(_L("BitmapDevice not created"),err);
iHwScreenDevice->ChangeScreenDevice(NULL);
err = iHwScreenDevice->CreateContext(iScreenGc);
if(err)
User::Panic(_L("BitmapDevice not created"),err);
TestScreenSize.SetSize(iHwScreenDevice->SizeInPixels().iWidth,iHwScreenDevice->SizeInPixels().iHeight);
iDefaultScreenRegion.AddRect(TestScreenSize);
iBitmap1.Reset();
iBitmap1.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);
iGraphicsAccelerator1 = ((CTestFbsDevice*)iBitmap1.iDevice)->StealGraphicsAccelerator();
delete iGraphicsAccelerator1;
iGraphicsAccelerator1 = 0;
if(!iSubRegion.IsEmpty())
iSubRegion.Clear();
iSubRegion.AddRect(iBitmap1.iBitmap->SizeInPixels());
iSubRegion.SubRegion(iFixedRegion);
iSubRegionPtr = &iSubRegion;
ret = iBitmap2.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);
if(ret!=KErrNone)
User::Panic(_L("Bitmap not created"),ret);
ret = iBitmap3.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);
if(ret!=KErrNone)
User::Panic(_L("Bitmap not created"),ret);
iGraphicsAccelerator1 = ((CTestFbsDevice*)iBitmap3.iDevice)->StealGraphicsAccelerator();
ret = iBitmap4.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);
if(ret!=KErrNone)
User::Panic(_L("Bitmap not created"),ret);
ret = iBitmap5.ConstructL(aDisplayMode,TestBitmapSize1,aHWBitmap);
if(ret!=KErrNone)
User::Panic(_L("Bitmap not created"),ret);
ret = iBitmap6.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);
if(ret!=KErrNone)
User::Panic(_L("Bitmap not created"),ret);
ret = iBitmap7.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);
if(ret!=KErrNone)
User::Panic(_L("Bitmap not created"),ret);
//BrushBitmap
CFbsBitmap* iTile = new CFbsBitmap();
TEST(iTile!=NULL);
ret = iTile->Load(_L("z:\\system\\data\\tile.mbm"),0,aHWBitmap);
TEST(ret==KErrNone);
TSize tileSize = iTile->SizeInPixels();
TDisplayMode tileDisplayMode = iTile->DisplayMode();
ret= iTileBitmap.ConstructL(tileDisplayMode,tileSize,aHWBitmap);
if(ret == KErrNotSupported)
{
WARN_PRINTF1(_L(" Not Supported."));
delete iTile;
iTile = NULL;
return;
}
iTileBitmap.iGc->BitBlt(TPoint(0,0),iTile);
delete iTile;
iTile = NULL;
//Alpha bitmap
ret = iAlphaBitmap.ConstructL(EGray256,TestBitmapSize,aHWBitmap);
if(ret!=KErrNone)
User::Panic(_L("Bitmap not created"),ret);
iGraphicsAccelerator2 = ((CTestFbsDevice*)iBitmap4.iDevice)->StealGraphicsAccelerator();
resetColorBitmaps();
INFO_PRINTF1(_L("FilledRect in the screen"));
TestScreenFilledRect();
resetColorBitmaps();
INFO_PRINTF1(_L("FilledRectWithPattern in the screen"));
TestScreenFilledRectWithPattern();
resetColorBitmaps();
INFO_PRINTF1(_L("InvertRect in the screen"));
TestScreenInvertRect();
resetColorBitmaps();
INFO_PRINTF1(_L("FadeRect in the screen"));
TestScreenFadeRect();
resetColorBitmaps();
INFO_PRINTF1(_L("BitBlt in the screen"));
TestScreenBitBlt();
resetColorBitmaps();
INFO_PRINTF1(_L("BitBltMasked in the screen"));
TestScreenBitBltMasked();
resetColorBitmaps();
INFO_PRINTF1(_L("BitBltAlphaBitmap in the screen"));
TestScreenBitBltAlphaBitmap();
resetColorBitmaps();
INFO_PRINTF1(_L("AlphaBlendTwoBitmaps in the screen"));
TestScreenAlphaBlendTwoBitmaps();
resetColorBitmaps();
INFO_PRINTF1(_L("AlphaBlendOneBitmap in the screen"));
TestScreenAlphaBlendOneBitmap();
resetColorBitmaps();
INFO_PRINTF1(_L("Rotating the screen"));
TestScreenRotation();
resetColorBitmaps();
INFO_PRINTF1(_L("Changing user display mode"));
TestUserDisplayMode();
resetColorBitmaps();
Cleanup();
}
void CTAccelerator::TestAcceleratorInfo()
{
TInt errCode;
TInt ret=0;
iBitmap5.iBitmap=new CFbsBitmap();
TRAP(errCode, ret=iBitmap5.iBitmap->Load(KRam32BitmapOnZ,0));
TEST(errCode==KErrNone);
TEST(ret==KErrNone);
TAcceleratedBitmapSpec spec(iBitmap5.iBitmap);
TAcceleratedBitmapInfo info;
iBitmap5.iBitmap->LockHeap();
spec.GetInfo(info);
iBitmap5.iBitmap->UnlockHeap();
TEST(info.iLinePitch==iBitmap5.iBitmap->Header().iSizeInPixels.iWidth*iBitmap5.iBitmap->Header().iBitsPerPixel/8);
TRAP(errCode, ret=iBitmap5.iBitmap->Compress());
TEST(errCode==KErrNone);
TEST(ret==KErrNone);
iBitmap5.iBitmap->LockHeap();
spec.GetInfo(info);
iBitmap5.iBitmap->UnlockHeap();
TEST(info.iLinePitch==-iBitmap5.iBitmap->Header().iCompression);
TUint32* romAddress = NULL;
if(CFbsBitmap::IsFileInRom(KRomC24Bitmap, romAddress))
{
TRAP(errCode, ret=iBitmap5.iBitmap->Load(KRomC24Bitmap,0));
TEST(errCode==KErrNone);
TEST(ret==KErrNone);
iBitmap5.iBitmap->LockHeap();
spec.GetInfo(info);
iBitmap5.iBitmap->UnlockHeap();
TEST(info.iLinePitch==-iBitmap5.iBitmap->Header().iCompression);
}
else
{
INFO_PRINTF2(_L("Skipping ROM bitmap test since file \"%S\" is reported to not be a ROM bitmap."),
&KRomC24Bitmap);
INFO_PRINTF1(_L("This should only occur on non-XIP ROMs, e.g. NAND ROMs, where ROM bitmaps aren't supported."));
}
TRAP(errCode, ret=iBitmap5.iBitmap->LoadAndCompress(KRamC24BitmapOnZ,0));
TEST(errCode==KErrNone);
TEST(ret==KErrNone);
iBitmap5.iBitmap->LockHeap();
spec.GetInfo(info);
iBitmap5.iBitmap->UnlockHeap();
TEST(info.iLinePitch==-iBitmap5.iBitmap->Header().iCompression);
Cleanup();
}
void CTAccelerator::TestAcceleratorInfoForExtendedBitmapL()
{
const TSize KSizeInPixels(64,65);
const TDisplayMode KDisplayMode = EColor64K;
const TUid KExtendedBitmapUid = {0x87654321};
const TUint8 KTestData[] = "Extended bitmap test data 123456";
const TInt KTestDataSize = sizeof(KTestData);
CFbsBitmap* exBmp = new (ELeave) CFbsBitmap;
CleanupStack::PushL(exBmp);
TInt err = exBmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KExtendedBitmapUid, KTestData, KTestDataSize);
TEST(err == KErrNone);
TAcceleratedBitmapSpec exSpec(exBmp);
TAcceleratedBitmapInfo info;
exBmp->LockHeap();
err = exSpec.GetInfo(info);
TEST(err == KErrNone);
exBmp->UnlockHeap();
TEST(info.iDisplayMode == KDisplayMode);
TEST(info.iSize == KSizeInPixels);
TEST(info.iLinePitch == -EProprietaryCompression);
TEST(info.iPixelShift == KExtendedBitmapUid.iUid);
TEST(info.iDataSize == KTestDataSize);
CleanupStack::PopAndDestroy(exBmp);
}
const TInt KNumTestFilledRect = 100;
const TInt KNumTestInvertRect = 100;
const TInt KNumTestBitBlt = 100;
const TInt KNumTestFadeRect= 1000;
const TInt KNumTestBitBltMasked= 100;
const TInt KNumTestBitBltAlphaBitmap= 100;
const TInt KNumTestAlphaBlendBitmaps= 100;
void CTAccelerator::TestFilledRect()
{
TInt gopBufferSize = KNumTestFilledRect*sizeof(TGopFilledRect);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iBitmap2.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);
TRgb white;
iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap3.iGc->SetBrushColor(white);
iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);
iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap4.iGc->SetBrushColor(white);
iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);
for(TInt n=0; n<100; n++)
{
rect.iTl.iX = Random(TestBitmapSize.iWidth+20)-10;
rect.iTl.iY = Random(TestBitmapSize.iHeight+20)-10;
rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth+20);
rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight+20);
TRgb colorRect(Random(256),Random(256),Random(256));
iBitmap1.iGc->SetBrushColor(colorRect);
iBitmap1.iGc->DrawRect(rect);
iBitmap2.iGc->SetBrushColor(colorRect);
iBitmap2.iGc->DrawRect(rect);
TEST(iBitmap1.Compare(&iBitmap2));
rect.Intersection(bitmapRect);
if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))
{
TGopFilledRect gop(rect,colorRect);
gopDes.Append((TUint8*)&gop,sizeof(gop));
TInt error = iGraphicsAccelerator1->Operation(gop);
if(error == KErrNotSupported)
{
delete gopBuffer;
WARN_PRINTF1(_L(" Not Supported."));
return;
}
}
iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());
TEST(iBitmap3.Compare(&iBitmap4));
delete gopBuffer;
}
void CTAccelerator::TestFilledRectWithPattern()
{
TInt gopBufferSize = KNumTestInvertRect*sizeof(TGopFilledRectWithPattern);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap1.iGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);
iBitmap1.iGc->UseBrushPattern(iTileBitmap.iBitmap);
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iBitmap2.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap2.iGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);
iBitmap2.iGc->UseBrushPattern(iTileBitmap.iBitmap);
iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);
TRgb white;
iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap3.iGc->SetBrushColor(white);
iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);
iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap4.iGc->SetBrushColor(white);
iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);
TAcceleratedBitmapSpec patternBitmapSpec(iTileBitmap.iBitmap);
TGopFillPattern gopFillPattern;
gopFillPattern.iBitmap = patternBitmapSpec;
for(TInt n=0; n<100; n++)
{
rect.iTl.iX = Random(TestBitmapSize.iWidth);
rect.iTl.iY = Random(TestBitmapSize.iHeight);
rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth);
rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight);
TPoint brushOrigin(Random(TestBitmapSize.iWidth -5),Random(TestBitmapSize.iHeight-5));
iBitmap1.iGc->SetBrushOrigin(brushOrigin);
iBitmap1.iGc->DrawRect(rect);
iBitmap2.iGc->SetBrushOrigin(brushOrigin);
iBitmap2.iGc->DrawRect(rect);
TEST(iBitmap1.Compare(&iBitmap2));
rect.Intersection(bitmapRect);
if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))
{
gopFillPattern.iOrigin = brushOrigin;
TGopFilledRectWithPattern gop(rect,gopFillPattern);
gopDes.Append((TUint8*)&gop,sizeof(gop));
TInt error = iGraphicsAccelerator1->Operation(gop);
if(error == KErrNotSupported)
{
delete gopBuffer;
WARN_PRINTF1(_L(" Not Supported."));
return;
}
}
iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());
TEST(iBitmap3.Compare(&iBitmap4));
iBitmap1.iGc->DiscardBrushPattern();
delete gopBuffer;
}
void CTAccelerator::TestInvertRect()
{
TInt gopBufferSize = KNumTestInvertRect*sizeof(TGopInvertRect);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap1.iGc->SetDrawMode(CGraphicsContext::EDrawModeNOTSCREEN);
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iBitmap2.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap2.iGc->SetDrawMode(CGraphicsContext::EDrawModeNOTSCREEN);
iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);
TRgb white;
iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap3.iGc->SetBrushColor(white);
iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);
iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap4.iGc->SetBrushColor(white);
iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);
for(TInt n=0; n<100; n++)
{
rect.iTl.iX = Random(TestBitmapSize.iWidth+20)-10;
rect.iTl.iY = Random(TestBitmapSize.iHeight+20)-10;
rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth+20);
rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight+20);
iBitmap1.iGc->DrawRect(rect);
iBitmap2.iGc->DrawRect(rect);
TEST(iBitmap1.Compare(&iBitmap2));
rect.Intersection(bitmapRect);
if((rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))
{
TGopInvertRect gop(rect);
gopDes.Append((TUint8*)&gop,sizeof(gop));
TInt error = iGraphicsAccelerator1->Operation(gop);
if(error == KErrNotSupported)
{
delete gopBuffer;
WARN_PRINTF1(_L(" Not Supported."));
return;
}
}
iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());
TEST(iBitmap3.Compare(&iBitmap4));
delete gopBuffer;
}
void CTAccelerator::TestFadeRect()
{
TInt gopBufferSize = KNumTestFadeRect*sizeof(TGopFadeRect);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap1.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iBitmap2.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap2.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);
for(TInt n=0; n<100; n++)
{
rect.iTl.iX = Random(TestBitmapSize.iWidth);
rect.iTl.iY = Random(TestBitmapSize.iHeight);
rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth);
rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight);
TUint8 blackMap = (TUint8)Random(256);
TUint8 whiteMap = (TUint8)Random(256);
RRegion region(rect);
iBitmap1.iGc->SetFaded(ETrue);
iBitmap1.iGc->SetFadingParameters(blackMap,whiteMap);
iBitmap1.iGc->FadeArea((TRegion*)®ion);
iBitmap2.iGc->SetFaded(ETrue);
iBitmap2.iGc->SetFadingParameters(blackMap,whiteMap);
iBitmap2.iGc->FadeArea((TRegion*)®ion);
region.Close();
TEST(iBitmap1.Compare(&iBitmap2));
TGopFadeParams fadeParams;
fadeParams.iScale = whiteMap - blackMap + 1;
fadeParams.iOffset = blackMap;
rect.Intersection(bitmapRect);
if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))
{
TGopFadeRect gop(rect,fadeParams);
gopDes.Append((TUint8*)&gop,sizeof(gop));
TInt error = iGraphicsAccelerator1->Operation(gop);
if(error == KErrNotSupported)
{
WARN_PRINTF1(_L(" Not Supported."));
goto quitFade2;
}
}
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
TEST(iBitmap3.Compare(&iBitmap4));
quitFade2:
delete gopBuffer;
iBitmap1.iGc->SetFaded(EFalse);
iBitmap2.iGc->SetFaded(EFalse);
}
void CTAccelerator::TestBitBlt()
{
TInt gopBufferSize = KNumTestBitBlt*sizeof(TGopBitBlt);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
//dest bitmap has different size
TRect bitmapRect1(0,0,TestBitmapSize1.iWidth,TestBitmapSize1.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);
TRgb white;
iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap3.iGc->SetBrushColor(white);
iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);
iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap4.iGc->SetBrushColor(white);
iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);
TRgb color1(Random(256),Random(256),Random(256));
iBitmap5.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap5.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap5.iGc->SetBrushColor(color1);
iBitmap5.iGc->DrawRect(bitmapRect1);
for(TInt n=0; n<100; n++)
{
rect.iTl.iX = Random(TestBitmapSize1.iWidth);
rect.iTl.iY = Random(TestBitmapSize1.iHeight);
rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize1.iWidth);
rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize1.iHeight);
TPoint pointDest(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));
//bitblt with GC
iBitmap1.iGc->BitBlt(pointDest,iBitmap5.iBitmap,rect);
iBitmap2.iGc->BitBlt(pointDest,iBitmap5.iBitmap,rect);
TEST(iBitmap1.Compare(&iBitmap2));
rect.Intersection(bitmapRect1);
TSize maxSize=TestBitmapSize-pointDest;
if (rect.Width()>maxSize.iWidth)
rect.iBr.iX=rect.iTl.iX+maxSize.iWidth;
if (rect.Height()>maxSize.iHeight)
rect.iBr.iY=rect.iTl.iY+maxSize.iHeight;
if(rect.IsEmpty())
continue;
if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))
{
TAcceleratedBitmapSpec bitmap5Spec(iBitmap5.iBitmap);
TGopBitBlt gopBitBlt(pointDest,bitmap5Spec,rect);
gopDes.Append((TUint8*)&gopBitBlt,sizeof(gopBitBlt));
TInt error = iGraphicsAccelerator1->Operation(gopBitBlt);
if(error == KErrNotSupported)
{
delete gopBuffer;
WARN_PRINTF1(_L(" Not Supported."));
return;
}
}
iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());
TEST(iBitmap3.Compare(&iBitmap4));
delete gopBuffer;
}
void CTAccelerator::TestBitBltMasked()
{
TInt gopBufferSize = KNumTestBitBltMasked*sizeof(TGopBitBltMasked);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);
TRgb white;
iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap3.iGc->SetBrushColor(white);
iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);
iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap4.iGc->SetBrushColor(white);
iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);
//Mask bitmap
iBitmap6.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap6.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
TRgb color1(Random(256),Random(256),Random(256));
//Source bitmap
iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap7.iGc->SetBrushColor(color1);
iBitmap7.iGc->DrawRect(bitmapRect);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);
TAcceleratedBitmapSpec bitmap6Spec(iBitmap6.iBitmap);
TPoint dest;
TRect rectMask;
//clear the mask bitmap with white
iBitmap6.iGc->SetBrushColor(TRgb(255,255,255));
iBitmap6.iGc->DrawRect(bitmapRect);
//Put randomly in the Bitmap Mask a numbers of black rects
iBitmap6.iGc->SetBrushColor(TRgb(0,0,0));
for(TInt n=0; n<10; n++)
{
rectMask.iTl.iX = Random(TestBitmapSize1.iWidth);
rectMask.iTl.iY = Random(TestBitmapSize1.iHeight);
rectMask.iBr.iX = rectMask.iTl.iX+1+Random(TestBitmapSize1.iWidth);
rectMask.iBr.iY = rectMask.iTl.iY+1+Random(TestBitmapSize1.iHeight);
iBitmap6.iGc->DrawRect(rectMask);
}
for(TInt i=0; i<100; i++)
{
//random rect to blit
rect.iTl.iX = Random(TestBitmapSize1.iWidth);
rect.iTl.iY = Random(TestBitmapSize1.iHeight);
rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize1.iWidth);
rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize1.iHeight);
//random point destination
dest.iX = Random(TestBitmapSize1.iWidth);
dest.iY = Random(TestBitmapSize1.iHeight);
//do BitBltMasked with graphics contex
iBitmap1.iGc->BitBltMasked(dest,iBitmap7.iBitmap,rect,iBitmap6.iBitmap,ETrue);
iBitmap2.iGc->BitBltMasked(dest,iBitmap7.iBitmap,rect,iBitmap6.iBitmap,ETrue);
TEST(iBitmap1.Compare(&iBitmap2));
rect.Intersection(bitmapRect);
if(rect.IsEmpty())
continue;
if((rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))
{
TGopBitBltMasked gopBitBltMasked(dest,bitmap7Spec,rect,bitmap6Spec);
gopDes.Append((TUint8*)&gopBitBltMasked,sizeof(gopBitBltMasked));
TInt error = iGraphicsAccelerator1->Operation(gopBitBltMasked);
if(error == KErrNotSupported)
{
delete gopBuffer;
WARN_PRINTF1(_L(" Not Supported."));
return;
}
}
iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());
TEST(iBitmap3.Compare(&iBitmap4));
delete gopBuffer;
}
void CTAccelerator::TestBitBltAlphaBitmap()
{
TInt gopBufferSize = KNumTestBitBltAlphaBitmap*sizeof(TGopBitBltAlphaBitmap);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);
TRgb white;
iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap3.iGc->SetBrushColor(white);
iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);
iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap4.iGc->SetBrushColor(white);
iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);
TRgb color = TRgb(Random(256),Random(256),Random(256));
//Source bitmap
iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap7.iGc->SetBrushColor(color);
iBitmap7.iGc->DrawRect(bitmapRect);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
iAlphaBitmap.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
//create 10 gray level for the alpha bitmap
for(TInt i=0; i<10;i++)
{
TRect tmpRect(0,10*i,200,10+10*i);
TInt index = 255-(20*i);
TRgb tmpRgb;
iAlphaBitmap.iGc->SetBrushColor(tmpRgb.Gray256(index));
iAlphaBitmap.iGc->DrawRect(tmpRect);
}
TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);
TAcceleratedBitmapSpec alphaBitmapSpec(iAlphaBitmap.iBitmap);
iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
for(TInt n=0; n<100; n++)
{
rect.iTl.iX = Random(TestBitmapSize.iWidth);
rect.iTl.iY = Random(TestBitmapSize.iHeight);
rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth);
rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight);
//Random destination point
TPoint pointDest(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));
//alpha blitting with Graphics Contex
iBitmap1.iGc->BitBltMasked(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,ETrue);
iBitmap2.iGc->BitBltMasked(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,ETrue);
TEST(iBitmap1.Compare(&iBitmap2));
rect.Intersection(bitmapRect);
//alpha blitting with Graphics accelerator
TGopBitBltAlphaBitmap gopBitBltAlphaBitmap(pointDest,bitmap7Spec,rect,alphaBitmapSpec);
gopDes.Append((TUint8*)&gopBitBltAlphaBitmap,sizeof(gopBitBltAlphaBitmap));
TInt error = iGraphicsAccelerator1->Operation(gopBitBltAlphaBitmap);
if(error == KErrNotSupported)
{
WARN_PRINTF1(_L(" Not Supported."));
goto done;
}
iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());
TEST(iBitmap3.Compare(&iBitmap4));
done:
delete gopBuffer;
}
void CTAccelerator::TestAlphaBlendTwoBitmaps()
{
TInt gopBufferSize = KNumTestAlphaBlendBitmaps*sizeof(TGopAlphaBlendTwoBitmaps);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);
TRgb white;
iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap3.iGc->SetBrushColor(white);
iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);
iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap4.iGc->SetBrushColor(white);
iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);
TRgb color = TRgb(Random(256),Random(256),Random(256));
// First Source bitmap
iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap7.iGc->SetBrushColor(color);
iBitmap7.iGc->DrawRect(bitmapRect);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
// Get a new random color
color = TRgb(Random(256),Random(256),Random(256));
// Second Source bitmap
iBitmap8.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap8.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap8.iGc->SetBrushColor(color);
iBitmap8.iGc->DrawRect(bitmapRect);
iBitmap8.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
iAlphaBitmap.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
//create 10 gray level for the alpha bitmap
for(TInt i=0; i<10;i++)
{
TRect tmpRect(0,10*i,200,10+10*i);
TInt index = 255-(20*i);
TRgb tmpRgb;
iAlphaBitmap.iGc->SetBrushColor(tmpRgb.Gray256(index));
iAlphaBitmap.iGc->DrawRect(tmpRect);
}
TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);
TAcceleratedBitmapSpec bitmap8Spec(iBitmap8.iBitmap);
TAcceleratedBitmapSpec alphaBitmapSpec(iAlphaBitmap.iBitmap);
iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
for(TInt n=0; n<100; n++)
{
rect.iTl.iX = Random(TestBitmapSize.iWidth - 1);
rect.iTl.iY = Random(TestBitmapSize.iHeight - 1);
rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth - rect.iTl.iX);
rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight - rect.iTl.iY);
TPoint pointDest(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));
TPoint pointSource(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));
TPoint pointAlpha(Random(TestBitmapSize.iWidth - rect.Width() - 1),Random(TestBitmapSize.iHeight - rect.Height() - 1));
//alpha blending Graphics Context - invalid parameter causes skip to next test
TInt rc = iBitmap1.iGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,iBitmap8.iBitmap,rect,pointSource,iAlphaBitmap.iBitmap,pointAlpha);
if(rc!=KErrNone)
{
continue;
}
iBitmap2.iGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,iBitmap8.iBitmap,rect,pointSource,iAlphaBitmap.iBitmap,pointAlpha);
TEST(iBitmap1.Compare(&iBitmap2));
rect.Intersection(bitmapRect);
//alpha blending with Graphics accelerator
TGopAlphaBlendTwoBitmaps gopAlphaBlendTwoBitmaps(pointDest,bitmap7Spec,bitmap8Spec,rect,pointSource,alphaBitmapSpec,pointAlpha);
gopDes.Append((TUint8*)&gopAlphaBlendTwoBitmaps,sizeof(gopAlphaBlendTwoBitmaps));
TInt error = iGraphicsAccelerator1->Operation(gopAlphaBlendTwoBitmaps);
if(error == KErrNotSupported)
{
WARN_PRINTF1(_L(" Not Supported."));
goto done;
}
iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());
TEST(iBitmap3.Compare(&iBitmap4));
done:
delete gopBuffer;
}
void CTAccelerator::TestAlphaBlendOneBitmap()
{
TInt gopBufferSize = KNumTestAlphaBlendBitmaps*sizeof(TGopAlphaBlendOneBitmap);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);
TRgb white;
iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap3.iGc->SetBrushColor(white);
iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);
iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap4.iGc->SetBrushColor(white);
iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);
TRgb color = TRgb(Random(256),Random(256),Random(256));
// First Source bitmap
iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap7.iGc->SetBrushColor(color);
iBitmap7.iGc->DrawRect(bitmapRect);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
// Get a new random color
color = TRgb(Random(256),Random(256),Random(256));
iAlphaBitmap.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
//create 10 gray level for the alpha bitmap
for(TInt i=0; i<10;i++)
{
TRect tmpRect(0,10*i,200,10+10*i);
TInt index = 255-(20*i);
TRgb tmpRgb;
iAlphaBitmap.iGc->SetBrushColor(tmpRgb.Gray256(index));
iAlphaBitmap.iGc->DrawRect(tmpRect);
}
TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);
TAcceleratedBitmapSpec alphaBitmapSpec(iAlphaBitmap.iBitmap);
iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
for(TInt n=0; n<100; n++)
{
rect.iTl.iX = Random(TestBitmapSize.iWidth - 1);
rect.iTl.iY = Random(TestBitmapSize.iHeight - 1);
rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth - rect.iTl.iX);
rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight - rect.iTl.iY);
TPoint pointDest(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));
TPoint pointAlpha(Random(TestBitmapSize.iWidth - rect.Width()),Random(TestBitmapSize.iHeight - rect.Height()));
iBitmap1.iGc->DrawRect(iBitmap1.iBitmap->SizeInPixels());
//alpha blending Graphics Context - wrong argument cause skip to next test
TInt rc = iBitmap1.iGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,pointAlpha);
if(rc!=KErrNone)
{
continue;
}
iBitmap2.iGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,pointAlpha);
TEST(iBitmap1.Compare(&iBitmap2));
rect.Intersection(bitmapRect);
//alpha blending with Graphics accelerator
TGopAlphaBlendOneBitmap gopAlphaBlendOneBitmap(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,pointAlpha);
gopDes.Append((TUint8*)&gopAlphaBlendOneBitmap,sizeof(gopAlphaBlendOneBitmap));
TInt error = iGraphicsAccelerator1->Operation(gopAlphaBlendOneBitmap);
if(error == KErrNotSupported)
{
WARN_PRINTF1(_L(" Not Supported."));
goto done;
}
iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());
TEST(iBitmap3.Compare(&iBitmap4));
done:
delete gopBuffer;
}
void CTAccelerator::TestScreenFilledRect()
{
TInt gopBufferSize = KNumTestFilledRect*sizeof(TGopFilledRect);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
TRect screenRect(0,0,TestScreenSize.iWidth,TestScreenSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
//used with GC
iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iScreenGc->SetPenStyle(CGraphicsContext::ENullPen);
iScreenGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iScreenGc->SetClippingRegion(iFixedRegionPtr);
TRgb white;
iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap3.iGc->SetBrushColor(white);
iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);
iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap4.iGc->SetBrushColor(white);
iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);
for(TInt n=0; n<100; n++)
{
rect.iTl.iX = Random(TestScreenSize.iWidth+20)-10;
rect.iTl.iY = Random(TestScreenSize.iHeight+20)-10;
rect.iBr.iX = rect.iTl.iX+1+Random(TestScreenSize.iWidth+20);
rect.iBr.iY = rect.iTl.iY+1+Random(TestScreenSize.iHeight+20);
TRgb colorRect(Random(256),Random(256),Random(256));
iBitmap1.iGc->SetBrushColor(colorRect);
iBitmap1.iGc->DrawRect(rect);
iScreenGc->SetBrushColor(colorRect);
iScreenGc->DrawRect(rect);
iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);
TEST(iBitmap1.Compare(&iBitmap2));
rect.Intersection(screenRect);
if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))
{
TGopFilledRect gop(rect,colorRect);
gopDes.Append((TUint8*)&gop,sizeof(gop));
TInt error = iGraphicsAccelerator1->Operation(gop);
if(error == KErrNotSupported)
{
delete gopBuffer;
WARN_PRINTF1(_L(" Not Supported."));
return;
}
}
iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());
TEST(iBitmap3.Compare(&iBitmap4));
delete gopBuffer;
}
void CTAccelerator::TestScreenFilledRectWithPattern()
{
TInt gopBufferSize = KNumTestInvertRect*sizeof(TGopFilledRectWithPattern);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
TRect screenRect(0,0,TestScreenSize.iWidth,TestScreenSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
//used with GC
iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap1.iGc->UseBrushPattern(iTileBitmap.iBitmap);
iBitmap1.iGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iScreenGc->SetPenStyle(CGraphicsContext::ENullPen);
iScreenGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iScreenGc->UseBrushPattern(iTileBitmap.iBitmap);
iScreenGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);
iScreenGc->SetClippingRegion(iFixedRegionPtr);
TRgb white;
iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap3.iGc->SetBrushColor(white);
iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);
iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap4.iGc->SetBrushColor(white);
iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);
TAcceleratedBitmapSpec patternBitmapSpec(iTileBitmap.iBitmap);
TGopFillPattern gopFillPattern;
gopFillPattern.iBitmap = patternBitmapSpec;
for(TInt n=0; n<100; n++)
{
rect.iTl.iX = Random(TestScreenSize.iWidth);
rect.iTl.iY = Random(TestScreenSize.iHeight);
rect.iBr.iX = rect.iTl.iX+1+Random(TestScreenSize.iWidth);
rect.iBr.iY = rect.iTl.iY+1+Random(TestScreenSize.iHeight);
TPoint brushOrigin(Random(TestScreenSize.iWidth -5),Random(TestScreenSize.iHeight-5));
iBitmap1.iGc->SetBrushOrigin(brushOrigin);
iBitmap1.iGc->DrawRect(rect);
iScreenGc->SetBrushOrigin(brushOrigin);
iScreenGc->DrawRect(rect);
iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);
TEST(iBitmap1.Compare(&iBitmap2));
rect.Intersection(screenRect);
if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))
{
gopFillPattern.iOrigin = brushOrigin;
TGopFilledRectWithPattern gop(rect,gopFillPattern);
gopDes.Append((TUint8*)&gop,sizeof(gop));
TInt error = iGraphicsAccelerator1->Operation(gop);
if(error == KErrNotSupported)
{
delete gopBuffer;
WARN_PRINTF1(_L(" Not Supported."));
return;
}
}
iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());
TEST(iBitmap3.Compare(&iBitmap4));
iBitmap1.iGc->DiscardBrushPattern();
delete gopBuffer;
}
void CTAccelerator::TestScreenInvertRect()
{
TInt gopBufferSize = KNumTestInvertRect*sizeof(TGopInvertRect);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
TRect screenRect(0,0,TestScreenSize.iWidth,TestScreenSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap1.iGc->SetDrawMode(CGraphicsContext::EDrawModeNOTSCREEN);
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iScreenGc->SetPenStyle(CGraphicsContext::ENullPen);
iScreenGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iScreenGc->SetDrawMode(CGraphicsContext::EDrawModeNOTSCREEN);
iScreenGc->SetClippingRegion(iFixedRegionPtr);
TRgb white;
iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap3.iGc->SetBrushColor(white);
iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);
iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap4.iGc->SetBrushColor(white);
iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);
for(TInt n=0; n<100; n++)
{
rect.iTl.iX = Random(TestScreenSize.iWidth+20)-10;
rect.iTl.iY = Random(TestScreenSize.iHeight+20)-10;
rect.iBr.iX = rect.iTl.iX+1+Random(TestScreenSize.iWidth+20);
rect.iBr.iY = rect.iTl.iY+1+Random(TestScreenSize.iHeight+20);
iBitmap1.iGc->DrawRect(rect);
iScreenGc->DrawRect(rect);
iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);
TEST(iBitmap1.Compare(&iBitmap2));
rect.Intersection(screenRect);
if((rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))
{
TGopInvertRect gop(rect);
gopDes.Append((TUint8*)&gop,sizeof(gop));
TInt error = iGraphicsAccelerator1->Operation(gop);
if(error == KErrNotSupported)
{
delete gopBuffer;
WARN_PRINTF1(_L(" Not Supported."));
return;
}
}
iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());
TEST(iBitmap3.Compare(&iBitmap4));
delete gopBuffer;
}
void CTAccelerator::TestScreenFadeRect()
{
TInt gopBufferSize = KNumTestFadeRect*sizeof(TGopFadeRect);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
TRect screenRect(0,0,TestScreenSize.iWidth,TestScreenSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap1.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iScreenGc->SetPenStyle(CGraphicsContext::ENullPen);
iScreenGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iScreenGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
iScreenGc->SetClippingRegion(iFixedRegionPtr);
for(TInt n=0; n<100; n++)
{
rect.iTl.iX = Random(TestScreenSize.iWidth);
rect.iTl.iY = Random(TestScreenSize.iHeight);
rect.iBr.iX = rect.iTl.iX+1+Random(TestScreenSize.iWidth);
rect.iBr.iY = rect.iTl.iY+1+Random(TestScreenSize.iHeight);
TUint8 blackMap = (TUint8)Random(256);
TUint8 whiteMap = (TUint8)Random(256);
RRegion region(rect);
iBitmap1.iGc->SetFaded(ETrue);
iBitmap1.iGc->SetFadingParameters(blackMap,whiteMap);
iBitmap1.iGc->FadeArea((TRegion*)®ion);
iScreenGc->SetFaded(ETrue);
iScreenGc->SetFadingParameters(blackMap,whiteMap);
iScreenGc->FadeArea((TRegion*)®ion);
iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);
region.Close();
TEST(iBitmap1.Compare(&iBitmap2));
TGopFadeParams fadeParams;
fadeParams.iScale = whiteMap - blackMap + 1;
fadeParams.iOffset = blackMap;
rect.Intersection(screenRect);
if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))
{
TGopFadeRect gop(rect,fadeParams);
gopDes.Append((TUint8*)&gop,sizeof(gop));
TInt error = iGraphicsAccelerator1->Operation(gop);
if(error == KErrNotSupported)
{
WARN_PRINTF1(_L(" Not Supported."));
goto quitFade;
}
}
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
TEST(iBitmap3.Compare(&iBitmap4));
quitFade:
delete gopBuffer;
iBitmap1.iGc->SetFaded(EFalse);
iScreenGc->SetFaded(EFalse);
}
void CTAccelerator::TestScreenBitBlt()
{
TInt gopBufferSize = KNumTestBitBlt*sizeof(TGopBitBlt);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
TRect screenRect(0,0,TestScreenSize.iWidth,TestScreenSize.iHeight);
//dest bitmap has different size
TRect bitmapRect1(0,0,TestBitmapSize1.iWidth,TestBitmapSize1.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iScreenGc->SetClippingRegion(iFixedRegionPtr);
TRgb white;
iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap3.iGc->SetBrushColor(white);
iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);
iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap4.iGc->SetBrushColor(white);
iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);
TRgb color1(Random(256),Random(256),Random(256));
iBitmap5.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap5.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap5.iGc->SetBrushColor(color1);
iBitmap5.iGc->DrawRect(bitmapRect1);
for(TInt n=0; n<100; n++)
{
rect.iTl.iX = Random(TestBitmapSize1.iWidth);
rect.iTl.iY = Random(TestBitmapSize1.iHeight);
rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize1.iWidth);
rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize1.iHeight);
TPoint pointDest(Random(TestScreenSize.iWidth),Random(TestScreenSize.iHeight));
//bitblt with GC
iBitmap1.iGc->BitBlt(pointDest,iBitmap5.iBitmap,rect);
iScreenGc->BitBlt(pointDest,iBitmap5.iBitmap,rect);
iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);
TEST(iBitmap1.Compare(&iBitmap2));
TInt extraWidth=(pointDest.iX+rect.Width())-TestScreenSize.iWidth;
if (extraWidth>0)
rect.iBr.iX-=extraWidth;
TInt extraHeight=(pointDest.iY+rect.Height())-TestScreenSize.iHeight;
if (extraHeight>0)
rect.iBr.iY-=extraHeight;
rect.Intersection(bitmapRect1);
TSize maxSize=TestBitmapSize-pointDest;
if (rect.Width()>maxSize.iWidth)
rect.iBr.iX=rect.iTl.iX+maxSize.iWidth;
if (rect.Height()>maxSize.iHeight)
rect.iBr.iY=rect.iTl.iY+maxSize.iHeight;
if(rect.IsEmpty())
continue;
if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))
{
TAcceleratedBitmapSpec bitmap5Spec(iBitmap5.iBitmap);
TGopBitBlt gopBitBlt(pointDest,bitmap5Spec,rect);
gopDes.Append((TUint8*)&gopBitBlt,sizeof(gopBitBlt));
TInt error = iGraphicsAccelerator1->Operation(gopBitBlt);
if(error == KErrNotSupported)
{
delete gopBuffer;
WARN_PRINTF1(_L(" Not Supported."));
return;
}
}
iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());
TEST(iBitmap3.Compare(&iBitmap4));
delete gopBuffer;
}
void CTAccelerator::TestScreenBitBltMasked()
{
TInt gopBufferSize = KNumTestBitBltMasked*sizeof(TGopBitBltMasked);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
TRect screenRect(0,0,TestScreenSize.iWidth,TestScreenSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iScreenGc->SetClippingRegion(iFixedRegionPtr);
TRgb white;
iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap3.iGc->SetBrushColor(white);
iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);
iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap4.iGc->SetBrushColor(white);
iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);
//Mask bitmap
iBitmap6.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap6.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
TRgb color1(Random(256),Random(256),Random(256));
//Source bitmap
iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap7.iGc->SetBrushColor(color1);
iBitmap7.iGc->DrawRect(iBitmap7.iBitmap->SizeInPixels());
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);
TAcceleratedBitmapSpec bitmap6Spec(iBitmap6.iBitmap);
TPoint dest;
TRect rectMask;
//Put randomly in the Bitmap Mask a numbers of black rects
iBitmap6.iGc->SetBrushColor(TRgb(0,0,0));
for(TInt n=0; n<3; n++)
{
rectMask.iTl.iX = Random(TestScreenSize.iWidth);
rectMask.iTl.iY = Random(TestScreenSize.iHeight);
rectMask.iBr.iX = rectMask.iTl.iX+1+Random(TestScreenSize.iWidth);
rectMask.iBr.iY = rectMask.iTl.iY+1+Random(TestScreenSize.iHeight);
iBitmap6.iGc->DrawRect(rectMask);
}
for(TInt i=0; i<100; i++)
{
//random rect to blit
rect.iTl.iX = Random(TestScreenSize.iWidth);
rect.iTl.iY = Random(TestScreenSize.iHeight);
rect.iBr.iX = rect.iTl.iX+1+Random(TestScreenSize.iWidth);
rect.iBr.iY = rect.iTl.iY+1+Random(TestScreenSize.iHeight);
//random point destination
dest.iX = Random(TestScreenSize.iWidth);
dest.iY = Random(TestScreenSize.iHeight);
iBitmap1.iGc->BitBltMasked(dest,iBitmap7.iBitmap,rect,iBitmap6.iBitmap,ETrue);
iScreenGc->BitBltMasked(dest,iBitmap7.iBitmap,rect,iBitmap6.iBitmap,ETrue);
iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);
TEST(iBitmap1.Compare(&iBitmap2));
rect.Intersection(screenRect);
if(rect.IsEmpty())
continue;
if((rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))
{
TGopBitBltMasked gopBitBltMasked(dest,bitmap7Spec,rect,bitmap6Spec);
gopDes.Append((TUint8*)&gopBitBltMasked,sizeof(gopBitBltMasked));
TInt error = iGraphicsAccelerator1->Operation(gopBitBltMasked);
if(error == KErrNotSupported)
{
delete gopBuffer;
WARN_PRINTF1(_L(" Not Supported."));
return;
}
}
iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());
TEST(iBitmap3.Compare(&iBitmap4));
delete gopBuffer;
}
void CTAccelerator::TestScreenBitBltAlphaBitmap()
{
TInt gopBufferSize = KNumTestBitBltAlphaBitmap*sizeof(TGopBitBltAlphaBitmap);
TUint8* gopBuffer = new TUint8[gopBufferSize];
TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);
TRect screenRect(0,0,TestScreenSize.iWidth,TestScreenSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iScreenGc->SetClippingRegion(iFixedRegionPtr);
TRgb white;
iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap3.iGc->SetBrushColor(white);
iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);
iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap4.iGc->SetBrushColor(white);
iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);
TRgb color = TRgb(Random(256),Random(256),Random(256));
//Source bitmap
iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap7.iGc->SetBrushColor(color);
iBitmap7.iGc->DrawRect(iBitmap7.iBitmap->SizeInPixels());
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
iAlphaBitmap.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
//create 10 gray level for the alpha bitmap
for(TInt i=0; i<10;i++)
{
TRect tmpRect(0,10*i,200,10+10*i);
TInt index = 255-(20*i);
TRgb tmpRgb;
iAlphaBitmap.iGc->SetBrushColor(tmpRgb.Gray256(index));
iAlphaBitmap.iGc->DrawRect(tmpRect);
}
TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);
TAcceleratedBitmapSpec alphaBitmapSpec(iAlphaBitmap.iBitmap);
iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
for(TInt n=0; n<100; n++)
{
rect.iTl.iX = Random(TestBitmapSize.iWidth);
rect.iTl.iY = Random(TestBitmapSize.iHeight);
rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth);
rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight);
//Random destination point
TPoint pointDest(Random(TestScreenSize.iWidth),Random(TestScreenSize.iHeight));
//alpha blitting with Graphics Contex
iBitmap1.iGc->BitBltMasked(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,ETrue);
iScreenGc->BitBltMasked(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,ETrue);
iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);
TEST(iBitmap1.Compare(&iBitmap2));
rect.Intersection(screenRect);
//alpha blitting with Graphics accelerator
TGopBitBltAlphaBitmap gopBitBltAlphaBitmap(pointDest,bitmap7Spec,rect,alphaBitmapSpec);
gopDes.Append((TUint8*)&gopBitBltAlphaBitmap,sizeof(gopBitBltAlphaBitmap));
TInt error = iGraphicsAccelerator1->Operation(gopBitBltAlphaBitmap);
if(error == KErrNotSupported)
{
WARN_PRINTF1(_L(" Not Supported."));
goto done;
}
iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());
TEST(iBitmap2.Compare(&iBitmap3));
}
iGraphicsAccelerator2->Operation(gopDes);
iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());
TEST(iBitmap3.Compare(&iBitmap4));
done:
delete gopBuffer;
}
void CTAccelerator::TestScreenAlphaBlendTwoBitmaps()
{
TRect screenRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);
TRgb color = TRgb(Random(256),Random(256),Random(256));
// First Source bitmap
iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap7.iGc->SetBrushColor(color);
iBitmap7.iGc->DrawRect(screenRect);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
// Get a new random color
color = TRgb(Random(256),Random(256),Random(256));
// Second Source bitmap
iBitmap8.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap8.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap8.iGc->SetBrushColor(color);
iBitmap8.iGc->DrawRect(screenRect);
iBitmap8.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
iAlphaBitmap.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
//create 10 gray level for the alpha bitmap
for(TInt i=0; i<10;i++)
{
TRect tmpRect(0,10*i,200,10+10*i);
TInt index = 255-(20*i);
TRgb tmpRgb;
iAlphaBitmap.iGc->SetBrushColor(tmpRgb.Gray256(index));
iAlphaBitmap.iGc->DrawRect(tmpRect);
}
TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);
TAcceleratedBitmapSpec bitmap8Spec(iBitmap8.iBitmap);
TAcceleratedBitmapSpec alphaBitmapSpec(iAlphaBitmap.iBitmap);
iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
for(TInt n=0; n<100; n++)
{
rect.iTl.iX = Random(TestBitmapSize.iWidth - 1);
rect.iTl.iY = Random(TestBitmapSize.iHeight - 1);
rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth - rect.iTl.iX);
rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight - rect.iTl.iY);
TPoint pointDest(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));
TPoint pointSource(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));
TPoint pointAlpha(Random(TestBitmapSize.iWidth - rect.Width()),Random(TestBitmapSize.iHeight - rect.Height()));
//alpha blending Graphics Context - wrong argument cause skip to next test
TInt error = iBitmap1.iGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,iBitmap8.iBitmap,rect,pointSource,iAlphaBitmap.iBitmap,pointAlpha);
// AlphaBlendBitmaps can return KErrArgument based on the input data - in that case, continue
if(error!=KErrNone)
{
continue;
}
iScreenGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,iBitmap8.iBitmap,rect,pointSource,iAlphaBitmap.iBitmap,pointAlpha);
iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);
TEST(iBitmap1.Compare(&iBitmap2));
}
}
void CTAccelerator::TestScreenAlphaBlendOneBitmap()
{
TRect screenRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);
TRect rect;
iFixedRegionPtr = &iFixedRegion;
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);
TRgb color = TRgb(Random(256),Random(256),Random(256));
// First Source bitmap
iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap7.iGc->SetBrushColor(color);
iBitmap7.iGc->DrawRect(screenRect);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
// Get a new random color
color = TRgb(Random(256),Random(256),Random(256));
iAlphaBitmap.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
//create 10 gray level for the alpha bitmap
for(TInt i=0; i<10;i++)
{
TRect tmpRect(0,10*i,200,10+10*i);
TInt index = 255-(20*i);
TRgb tmpRgb;
iAlphaBitmap.iGc->SetBrushColor(tmpRgb.Gray256(index));
iAlphaBitmap.iGc->DrawRect(tmpRect);
}
TAcceleratedBitmapSpec bitmap7Spec(iBitmap7.iBitmap);
TAcceleratedBitmapSpec alphaBitmapSpec(iAlphaBitmap.iBitmap);
iAlphaBitmap.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
for(TInt n=0; n<100; n++)
{
if(n==0) continue;
rect.iTl.iX = Random(TestBitmapSize.iWidth - 1);
rect.iTl.iY = Random(TestBitmapSize.iHeight - 1);
rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth - rect.iTl.iX);
rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight - rect.iTl.iY);
TPoint pointDest(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));
TPoint pointAlpha(Random(TestBitmapSize.iWidth - rect.Width() - 1),Random(TestBitmapSize.iHeight - rect.Height() - 1));
//alpha blending Graphics Context - wrong argument cause skip to next test
TInt rc = iBitmap1.iGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,pointAlpha);
if(rc!=KErrNone)
{
continue;
}
iScreenGc->AlphaBlendBitmaps(pointDest,iBitmap7.iBitmap,rect,iAlphaBitmap.iBitmap,pointAlpha);
iBitmap2.iGc->BitBlt(TPoint(0,0),*iScreenGc,screenRect);
TEST(iBitmap1.Compare(&iBitmap2));
}
}
void CTAccelerator::resetColorBitmaps()
{
TRgb color;
iFixedRegionPtr = &iDefaultRegion;
if(iHwScreenDevice)
{
iFixedRegionPtr = &iDefaultScreenRegion;
iScreenGc->SetPenStyle(CGraphicsContext::ENullPen);
iScreenGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iScreenGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
iScreenGc->SetClippingRegion(iFixedRegionPtr);
iScreenGc->SetBrushColor(color);
iScreenGc->DrawRect(TestScreenSize);
iScreenGc->SetBrushStyle(CGraphicsContext::ENullBrush);
}
iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap1.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);
iBitmap1.iGc->SetBrushColor(color);
TRect rect1(iBitmap1.iBitmap->SizeInPixels());
iBitmap1.iGc->DrawRect(rect1);
iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
iBitmap2.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap2.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);
iBitmap2.iGc->SetBrushColor(color);
TRect rect2(iBitmap2.iBitmap->SizeInPixels());
iBitmap2.iGc->DrawRect(rect2);
iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
//GA1
iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap3.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
iBitmap3.iGc->SetClippingRegion(iFixedRegionPtr);
iBitmap3.iGc->SetBrushColor(color);
TRect rect3(iBitmap3.iBitmap->SizeInPixels());
iBitmap3.iGc->DrawRect(rect3);
iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
//GA2
iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap4.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
iBitmap4.iGc->SetClippingRegion(iFixedRegionPtr);
iBitmap4.iGc->SetBrushColor(color);
TRect rect4(iBitmap4.iBitmap->SizeInPixels());
iBitmap4.iGc->DrawRect(rect4);
iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
iBitmap5.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap5.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap5.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
iBitmap5.iGc->SetBrushColor(color);
TRect rect5(iBitmap5.iBitmap->SizeInPixels());
iBitmap5.iGc->DrawRect(rect5);
iBitmap5.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
iBitmap6.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap6.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap6.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
iBitmap6.iGc->SetBrushColor(color);
TRect rect6(iBitmap6.iBitmap->SizeInPixels());
iBitmap6.iGc->DrawRect(rect6);
iBitmap6.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
iBitmap7.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap7.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
iBitmap7.iGc->SetBrushColor(color);
TRect rect7(iBitmap7.iBitmap->SizeInPixels());
iBitmap7.iGc->DrawRect(rect7);
iBitmap7.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
iBitmap8.iGc->SetPenStyle(CGraphicsContext::ENullPen);
iBitmap8.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
iBitmap8.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);
iBitmap8.iGc->SetBrushColor(color);
TRect rect8(iBitmap8.iBitmap->SizeInPixels());
iBitmap8.iGc->DrawRect(rect8);
iBitmap8.iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
}
void CTAccelerator::TestScreenRotation()
{
// Checks that clearing a rotated screen doesn't blow-up
iScreenGc->SetOrientation(CFbsBitGc::EGraphicsOrientationRotated90);
iScreenGc->Reset();
// fill screen using graphics accelerator
iScreenGc->SetBrushStyle(CFbsBitGc::ESolidBrush);
iScreenGc->SetPenStyle(CFbsBitGc::ENullPen);
iScreenGc->DrawRect(TRect(0,0,KMaxTInt/2,KMaxTInt/2));
// restore orientation
iScreenGc->SetOrientation(CFbsBitGc::EGraphicsOrientationNormal);
iScreenGc->Reset();
}
void CTAccelerator::TestUserDisplayMode()
{
iScreenGc->Reset();
// Change to Gray4 mode
iScreenGc->SetUserDisplayMode(EGray4);
// fill screen using graphics accelerator
iScreenGc->SetBrushStyle(CFbsBitGc::ESolidBrush);
iScreenGc->SetBrushColor(TRgb(0x44,0x44,0x44)); // should get 'rounded up' to 0x55,0x55,0x55 when drawn
iScreenGc->SetPenStyle(CFbsBitGc::ENullPen);
iScreenGc->DrawRect(TRect(0,0,KMaxTInt/2,KMaxTInt/2));
TRgb pixel;
iHwScreenDevice->GetPixel(pixel,TPoint(0,0));
TRgb checkValue(0x555555,0xff);
if (iHwScreenDevice->DisplayMode()==EColor64K)
checkValue=TRgb::Color64K(checkValue.Color64K());
TEST(pixel==checkValue); // check pixel color is that of a Gray4 one
// Restore user display mode
iScreenGc->Reset();
}
static void CheckDisplayMode()
{
TInt i;
for(i=0; i<KNumDisplayModes; ++i)
{
TDisplayMode mode = TestDisplayModes[i].iMode;
CFbsScreenDevice* device = NULL;
TInt err = KErrNone;
TRAP(err, device = CFbsScreenDevice::NewL(_L("scdv"), mode));
if (err == KErrNone)
{
TestDisplayModes[i].iEnabled = ETrue;
delete device;
}
}
}
//--------------
__CONSTRUCT_STEP__(Accelerator)
void CTAcceleratorStep::TestSetupL()
{
FbsStartup();
User::LeaveIfError(RFbsSession::Connect());
CheckDisplayMode();
}
void CTAcceleratorStep::TestClose()
{
RFbsSession::Disconnect();
}