TBool CTestContainer::CompareScreenContentWithTestBitmapL(const CBitmapFrameData& aBkgdFrame, const CBitmapFrameData& aFrame1, const TPoint& aPos)
{
TSize size = aFrame1.Bitmap()->SizeInPixels();
// Create test bitmap for comparison
CFbsBitmap* testBitmap = new (ELeave) CFbsBitmap;
CleanupStack::PushL(testBitmap);
User::LeaveIfError( testBitmap->Create(size, iEikonEnv->DefaultDisplayMode()));
CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(testBitmap);
CleanupStack::PushL(bitmapDevice);
CFbsBitGc* bitmapGc = CFbsBitGc::NewL();
CleanupStack::PushL(bitmapGc);
bitmapGc->Activate(bitmapDevice);
// Blit the background bitmap
bitmapGc->BitBlt(aPos, aBkgdFrame.Bitmap());
// Blit the frame bitmap with mask
bitmapGc->BitBltMasked(aPos, aFrame1.Bitmap(), size, aFrame1.Mask(), ETrue);
// Create bitmap and blit the screen contents into it for comparing it with test bitmap created above
TRect rect(aPos,size);
CFbsBitmap* scrBitmap = new (ELeave) CFbsBitmap;
CleanupStack::PushL(scrBitmap);
User::LeaveIfError(scrBitmap->Create(size, iEikonEnv->DefaultDisplayMode()) );
User::LeaveIfError( iEikonEnv->ScreenDevice()->CopyScreenToBitmap(scrBitmap,rect) );
TBool ret=CompareBitmapsL(testBitmap,scrBitmap);
CleanupStack::PopAndDestroy(4); //scrBitmap, bitmapGc, bitmapDevice, testBitmap
return ret;
}
// ----------------------------------------------------------------------------
// CSysApShutdownImage::ShowShutdownImage()
// ----------------------------------------------------------------------------
CFbsBitmap* CSysApShutdownImage::ReadSVGL (TFileName aFileName)
{
TRACES( RDebug::Print(_L("CSysApShutdownImage::ReadSVGL:start" ) ) );
TFontSpec fontspec;
TDisplayMode mode = EColor16MA;
TInt SIZE_X(360), SIZE_Y(360);
TSize size(SIZE_X, SIZE_Y);
//if ( mode >= (TDisplayMode)13 ) { mode = EColor16MA; }
CFbsBitmap* frameBuffer = new ( ELeave ) CFbsBitmap;
CleanupStack::PushL( frameBuffer );
frameBuffer->Create( size, mode );
CSvgEngineInterfaceImpl* svgEngine = NULL;
svgEngine = CSvgEngineInterfaceImpl::NewL(frameBuffer, NULL, fontspec );
if (svgEngine == NULL)
{
TRACES( RDebug::Print(_L("CSysApShutdownImage::ReadSVGL:SVG engine creation failed" ) ) );
}
CleanupStack::PushL( svgEngine );
TInt domHandle = 0;
svgEngine->PrepareDom( aFileName, domHandle ) ;
if (domHandle == 0)
{
TRACES( RDebug::Print(_L("CSysApShutdownImage::ReadSVGL():DOM handle creation failed" ) ) );
}
CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;
CleanupStack::PushL( bitmap );
User::LeaveIfError( bitmap->Create( size, EColor64K ) );
svgEngine->UseDom( domHandle, bitmap, NULL ) ;
MSvgError* err;
svgEngine->Start( err );
if (err->HasError())
{
TRACES( RDebug::Print(_L("CSysApShutdownImage::ReadSVGL(): SVG Engine Start failed" ) ) );
}
svgEngine->DeleteDom( domHandle );
CleanupStack::Pop( bitmap );
CleanupStack::PopAndDestroy( svgEngine );
CleanupStack::PopAndDestroy( frameBuffer );
TRACES( RDebug::Print(_L("CSysApShutdownImage::ReadSVGL:End" ) ) );
return bitmap;
}
void WindowSurfaceImpl::handleSymbianWindowVisibilityChange(bool aVisible)
{
if(mPaintingStarted)
{
// TODO window getting invisible in the middle of paint
return;
}
if (!aVisible)
{
// Switch to sw rendering
if(!isLocalSurfaceValid())
{
if(mMainSurface.localSurfaceInUse)
{
deleteLocalSurface();
}
CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;
CleanupStack::PushL(bitmap);
int err = bitmap->Create(TSize(mMainSurface.widget->width(), mMainSurface.widget->height()),
CCoeEnv::Static()->ScreenDevice()->DisplayMode());
eglCopyBuffers(mEgl.display, mEgl.readSurface, bitmap);
mMainSurface.localSurface = new QImage(QPixmap::fromSymbianCFbsBitmap(bitmap).toImage());
CleanupStack::Pop(bitmap);
mMainSurface.qSurface = NULL;
mMainSurface.device = mMainSurface.localSurface;
mMainSurface.type = WsTypeQtImage;
mMainSurface.localSurfaceInUse = true;
}
}
// Otherwise updateSurfaceData() will switch back to hw rendering
}
void CSliderControl::LoadPicture()
{
CFbsBitmap* BitMap = new (ELeave) CFbsBitmap();
BitMap->Create(Size(),EColor16M);
CAknsBasicBackgroundControlContext* iContext =
CAknsBasicBackgroundControlContext::NewL(KAknsIIDQsnBgAreaMain,Rect(),ETrue);
CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(BitMap);
CBitmapContext* bitGc = NULL;
bitmapDevice->CreateBitmapContext(bitGc);
///
CleanupStack::PushL(iContext);
CleanupStack::PushL(bitmapDevice);
CleanupStack::PushL(bitGc);
AknsDrawUtils::DrawBackground(AknsUtils::SkinInstance(),iContext,NULL,*bitGc,TPoint(0,0),Rect(),0);
CleanupStack::PopAndDestroy(3);
iIcon=BitMap;
/*
CFbsBitmap* mask;
CFbsBitmap* icon;
_LIT(KPath,"\\resource\\apps\\TweakS_ui.mif");
AknIconUtils::CreateIconL(icon,mask,KPath,EMbmTweaks_uiButton_dlg_bg,EMbmTweaks_uiButton_dlg_bg_mask);
AknIconUtils::SetSize(icon,Size(),EAspectRatioNotPreserved);
AknIconUtils::SetSize(mask,Size(),EAspectRatioNotPreserved);
iIcon=CGulIcon::NewL(icon,mask);
*/
}
CGulIcon* CTap2MenuAppUi::LoadAppIconHard(TUid aUid)
{
RApaLsSession ls;
ls.Connect();
CGulIcon *retval = NULL;
CArrayFixFlat<TSize> *array = new CArrayFixFlat<TSize>(3);
CleanupStack::PushL(array);
TInt err = ls.GetAppIconSizes(aUid, *array);
if(err == KErrNone && array->Count() > 0)
{
CApaMaskedBitmap *bitmap = CApaMaskedBitmap::NewLC();
err = ls.GetAppIcon(aUid, (*array)[0], *bitmap);
if(err == KErrNone)
{
CFbsBitmap* bmp = new (ELeave) CFbsBitmap();
CleanupStack::PushL(bmp);
CFbsBitmap* bmp_mask = new (ELeave) CFbsBitmap();
CleanupStack::PushL(bmp_mask);
User::LeaveIfError(bmp->Create(bitmap->SizeInPixels(), bitmap->DisplayMode()));
User::LeaveIfError(bmp_mask->Create(bitmap->Mask()->SizeInPixels(), bitmap->Mask()->DisplayMode()));
CopyBitmapL(bitmap, bmp);
CopyBitmapL(bitmap->Mask(), bmp_mask);
retval = CGulIcon::NewL(bmp, bmp_mask);
CleanupStack::Pop(2); // bmp, bmp_mask
}
CleanupStack::PopAndDestroy(bitmap);
}
CleanupStack::PopAndDestroy(array);
ls.Close();
return retval;
}
void tst_QVolatileImage::sharing()
{
QVolatileImage img1(100, 100, QImage::Format_ARGB32);
QVolatileImage img2 = img1;
img1.beginDataAccess();
img2.beginDataAccess();
QVERIFY(img1.constBits() == img2.constBits());
img2.endDataAccess();
img1.endDataAccess();
img1.imageRef(); // non-const call, should detach
img1.beginDataAccess();
img2.beginDataAccess();
QVERIFY(img1.constBits() != img2.constBits());
img2.endDataAccess();
img1.endDataAccess();
// toImage() should return a copy of the internal QImage.
// imageRef() is a reference to the internal QImage.
QVERIFY(img1.imageRef().constBits() != img1.toImage().constBits());
#ifdef Q_OS_SYMBIAN
CFbsBitmap *bmp = new CFbsBitmap;
QVERIFY(bmp->Create(TSize(100, 50), EColor16MAP) == KErrNone);
QVolatileImage bmpimg(bmp);
QVolatileImage bmpimg2;
bmpimg2 = bmpimg;
QCOMPARE(bmpimg.constBits(), (const uchar *) bmp->DataAddress());
QCOMPARE(bmpimg2.constBits(), (const uchar *) bmp->DataAddress());
// Now force a detach, which should copy the pixel data under-the-hood.
bmpimg.imageRef();
QVERIFY(bmpimg.constBits() != (const uchar *) bmp->DataAddress());
QCOMPARE(bmpimg2.constBits(), (const uchar *) bmp->DataAddress());
delete bmp;
#endif
}
static CFbsBitmap* createBlitCopy(CFbsBitmap* bitmap)
{
CFbsBitmap *copy = q_check_ptr(new CFbsBitmap);
if(!copy)
return 0;
if (copy->Create(bitmap->SizeInPixels(), bitmap->DisplayMode()) != KErrNone) {
delete copy;
copy = 0;
return 0;
}
CFbsBitmapDevice* bitmapDevice = 0;
CFbsBitGc *bitmapGc = 0;
QT_TRAP_THROWING(bitmapDevice = CFbsBitmapDevice::NewL(copy));
QT_TRAP_THROWING(bitmapGc = CFbsBitGc::NewL());
bitmapGc->Activate(bitmapDevice);
bitmapGc->BitBlt(TPoint(), bitmap);
delete bitmapGc;
delete bitmapDevice;
return copy;
}
// --------------------------------------------------------------------------
// Ctestpubscalableicons::TestAknIconUtilsScaleBitmapL
// --------------------------------------------------------------------------
//
TInt Ctestpubscalableicons::TestAknIconUtilsScaleBitmapL( CStifItemParser& /*aItem*/ )
{
_LIT(Kctestpubscalableicons, "Ctestpubscalableicons");
_LIT(Ktestakniconutilsscalebitmapl, "In TestAknIconUtilsScaleBitmapL");
TestModuleIf().Printf(0, Kctestpubscalableicons, Ktestakniconutilsscalebitmapl);
iLog->Log(Ktestakniconutilsscalebitmapl);
TFileName file( KMbmFile );
User::LeaveIfError( CompleteWithAppPath( file ) );
CFbsBitmap* aSrcBitmap = AknIconUtils::CreateIconL( file, EMbmAvkonQgn_indi_mic );
CleanupStack::PushL( aSrcBitmap );
TRect aTrgRect( TSize( KWidth, KHeight ) );
CFbsBitmap* aTrgBitmap = new( ELeave ) CFbsBitmap;
aTrgBitmap->Create(TSize( KWidth, KHeight), ENone );
AknIconUtils::ScaleBitmapL( aTrgRect, aTrgBitmap, aSrcBitmap );
STIF_ASSERT_NOT_NULL( aTrgBitmap );
CleanupStack::PopAndDestroy( aSrcBitmap );
return KErrNone;
}
void CAlfPerfAppAvkonTestCaseBasic::ConstructL(
CAlfEnv& aEnv, TInt aCaseId, const TRect& aVisibleArea )
{
CAlfPerfAppBaseTestCaseControl::ConstructL( aEnv, aCaseId, aVisibleArea );
iWinRect = aVisibleArea;
iAvkonControl = new(ELeave) CAvkonTestCoeControl();
iAvkonControl->ConstructL(iWinRect);
iAnimTimer = CPeriodic::NewL(CActive::EPriorityStandard);
TFontSpec myFontSpec(_L("Arial"), 3*120);
CCoeEnv::Static()->ScreenDevice()->GetNearestFontInTwips(iFont, myFontSpec);
// Find my private path
TFileName pathWithoutDrive;
TFileName driveAndPath;
CEikonEnv::Static()->FsSession().PrivatePath( pathWithoutDrive );
driveAndPath.Copy(CEikonEnv::Static()->EikAppUi()->Application()->AppFullName().Left(2));
driveAndPath.Append(pathWithoutDrive);
// Create pictures
iPictureBm = new(ELeave) CFbsBitmap;
driveAndPath.Append(_L("alfperfapp_test1.mbm"));
User::LeaveIfError(iPictureBm->Load(driveAndPath));
iMaskBm = new(ELeave) CFbsBitmap;
User::LeaveIfError(iMaskBm->Create(iPictureBm->SizeInPixels(), EGray256));
iTestCaseStartTime_ys.UniversalTime();
iTestCaseFrameCount = 0;
}
/**
Creates a bitmap for given size and display mode and leaves it on the cleanup stack
@return pointer to a created CFbsBitmap
*/
CFbsBitmap* CTe_graphicsperformanceSuiteStepBase::CreateSoftwareBitmapLC(const TSize& aSize, TDisplayMode aMode)
{
CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
CleanupStack::PushL(bitmap);
User::LeaveIfError(bitmap->Create(aSize, aMode));
return bitmap;
}
/**
Create a checked board
@param aPixelFormat The pixel format for create the target bitmap
@param aSize The size of the bitmap
@param aChecksPerAxis Number of checks on X and Y.
*/
CFbsBitmap* CTe_graphicsperformanceSuiteStepBase::CreateCheckedBoardL(TDisplayMode aDisplayMode, TSize aSize, TSize aChecksPerAxis) const
{
CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
CleanupStack::PushL(bitmap);
bitmap->Create(aSize, aDisplayMode);
CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmap);
CleanupStack::PushL(bitmapDevice);
CFbsBitGc* bitGc = NULL;
User::LeaveIfError(bitmapDevice->CreateContext(bitGc));
CleanupStack::PushL(bitGc);
bitGc->Clear();
bitGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
bitGc->SetPenStyle(CGraphicsContext::ENullPen);
TPoint point(0,0);
const TSize checkerSize((TReal)aSize.iWidth/aChecksPerAxis.iWidth,(TReal)aSize.iHeight/aChecksPerAxis.iHeight);
TInt brushColour = 0;
for(point.iY = 0; point.iY < aSize.iHeight; point.iY += checkerSize.iHeight)
{
for(point.iX = 0; point.iX < aSize.iWidth; point.iX += checkerSize.iWidth)
{
bitGc->SetBrushColor(KColor16Table[brushColour++ & 0x0F]);
TRect rect(point, checkerSize);
bitGc->DrawRect(rect);
}
}
CleanupStack::PopAndDestroy(2, bitmapDevice);
CleanupStack::Pop(bitmap);
return bitmap;
}
/**
* Runs the test in a second thread.
*
* @param aFunctionIndex The drawing function command to be executed. All commands are defined in TestFunctionIndex.
*/
TInt CTW32CmdBuf::DoTestCmdBufFunctionL(TTestFunctionIndex aFunctionIndex)
{
RWsSession session;
User::LeaveIfError(session.Connect());
CleanupClosePushL(session);
CWsScreenDevice *device = new(ELeave) CWsScreenDevice(session);
CleanupStack::PushL(device);
User::LeaveIfError(device->Construct(CTestBase::iScreenNo));
CWindowGc* gc;
User::LeaveIfError(device->CreateContext(gc));
CleanupStack::PushL(gc);
RWindowGroup group(session);
User::LeaveIfError(group.Construct(1, EFalse));
CleanupClosePushL(group);
RWindow window(session);
User::LeaveIfError(window.Construct(group, 2));
CleanupClosePushL(window);
window.SetExtent(TPoint(0,0), TSize(200, 200));
User::LeaveIfError(window.SetRequiredDisplayMode(EColor64K));
window.Activate();
gc->Activate(window);
session.SetAutoFlush(EFalse);
window.Invalidate();
window.BeginRedraw();
for(TInt i=KMinTestIterations; i<KMaxTestIterations; ++i)
{
for(TInt j=0; j<i; ++j)
{
gc->Clear();
}
CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;
CleanupStack::PushL(bitmap);
User::LeaveIfError(bitmap->Create(TSize(100, 100), EColor64K));
CFbsBitmap* mask = new(ELeave) CFbsBitmap;
CleanupStack::PushL(mask);
User::LeaveIfError(mask->Create(TSize(100, 100), EColor64K));
KTestFunctions[aFunctionIndex](gc, bitmap, mask);
CleanupStack::PopAndDestroy(2);
session.Flush();
}
window.EndRedraw();
gc->Deactivate();
CleanupStack::PopAndDestroy(5);
return KErrNone;
}
CFbsBitmap* AknBitmapMirrorUtils::CreateBitmapL(CFbsBitmap* aSourceBitmap, TInt aMirrorDirection)
{
User::LeaveIfNull(aSourceBitmap);
CFbsBitmap* destinationBitmap = new (ELeave) CFbsBitmap();
CleanupStack::PushL(destinationBitmap);
TSize sourceBitmapSize = aSourceBitmap->SizeInPixels();
TRect sourceRect = TRect(TPoint(0,0), sourceBitmapSize);
TSize destinationBitmapSize(sourceRect.Width(), sourceRect.Height());
User::LeaveIfError(destinationBitmap->Create(destinationBitmapSize, aSourceBitmap->DisplayMode()));
CFbsBitmapDevice* destinationDevice = CFbsBitmapDevice::NewL( destinationBitmap );
CleanupStack::PushL(destinationDevice);
CFbsBitGc* destinationGc;
User::LeaveIfError( destinationDevice->CreateContext( destinationGc ) );
switch (aMirrorDirection)
{
case EAknVerticalMirroring:
{
TRect sourceBitmapBlittingRect( sourceRect.iTl.iX,sourceRect.iTl.iY,sourceRect.iBr.iX,sourceRect.iTl.iY + 1 );
for ( TInt yPos=destinationBitmapSize.iHeight-1; yPos >= 0; yPos-- )
{
destinationGc->BitBlt( TPoint(0,yPos), aSourceBitmap, sourceBitmapBlittingRect );
sourceBitmapBlittingRect.iTl.iY++;
sourceBitmapBlittingRect.iBr.iY++;
}
break;
}
case EAknHorizontalMirroring:
{
TRect sourceBitmapBlittingRect( sourceRect.iTl.iX,sourceRect.iTl.iY,sourceRect.iTl.iX + 1,sourceRect.iBr.iY );
for ( TInt xPos=destinationBitmapSize.iWidth-1; xPos >= 0; xPos-- )
{
destinationGc->BitBlt( TPoint(xPos,0), aSourceBitmap, sourceBitmapBlittingRect );
sourceBitmapBlittingRect.iTl.iX++;
sourceBitmapBlittingRect.iBr.iX++;
}
break;
}
default:
{
destinationGc->BitBlt( TPoint(0,0), aSourceBitmap, sourceRect );
break;
}
}
delete destinationGc;
CleanupStack::Pop(2); // destinationBitmap, destinationDevice
delete destinationDevice;
return destinationBitmap;
}
/**
Creates and destroys bitmaps of the same size KIterationsToTest times.
@param aWidth The width of the created bitmaps.
@param aHeight The height of the created bitmaps.
@param aDisplayMode The display mode to create bitmaps with.
@param aTestDescription The description of the test.
*/
void CTFbsBitmapHandlePerf::BitmapCreationSimpleL(const TInt aWidth, const TInt aHeight, const TDisplayMode aDisplayMode, const TDesC& aTestDescription)
{
iProfiler->InitResults();
for (TInt count = KIterationsToTest; count > 0; --count)
{
CFbsBitmap bitmap;
TInt err = bitmap.Create(TSize(aWidth, aHeight), aDisplayMode);
User::LeaveIfError(err);
iProfiler->MarkResultSetL();
}
iProfiler->ResultsAnalysis(aTestDescription, aDisplayMode, 0, 0, KIterationsToTest);
}
//-----------------------------------------------------------------------------
// CBrowserViewImagesListBox::CreatePlaceholderIconL()
//-----------------------------------------------------------------------------
//
CGulIcon* CBrowserViewImagesListBox::CreatePlaceholderIconL()
{
CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;
CleanupStack::PushL(bitmap);
if(KErrNone != bitmap->Create(TSize(42,32), EColor16M))
User::Leave(KErrNoMemory);
// create icon
CGulIcon* icon = CGulIcon::NewL(bitmap); // bitmap is owned, no mask used
CleanupStack::Pop(); // bitmap
return icon;
}
int CAfStorageClient::getThumbnail(const TDesC &imagePath, void *userData)
{
lastMethodCalled = CAfStorageClient::GetThumbnailMethod;
delete lastCallThumbnailPath;
lastCallThumbnailPath = imagePath.Alloc();
lastCallUserData = userData;
CFbsBitmap *bitmap = new (ELeave)CFbsBitmap();
CleanupStack::PushL(bitmap);
User::LeaveIfError(bitmap->Create(TSize(128, 128), EColor4K));
mObserver.getThumbnailRequestCompleted(CAfStorageClient::expectedReturnCode, bitmap->Handle(), userData);
CleanupStack::PopAndDestroy(bitmap);
return CAfStorageClient::expectedReturnCode;
}
// -----------------------------------------------------------------------------
// CAknsTemporaryBitmap::ActivateGcL
// -----------------------------------------------------------------------------
//
CFbsBitGc* CAknsTemporaryBitmap::ActivateGcL(
const TDisplayMode aMode, const TBool aMask )
{
CFbsBitmap* bmp = NULL;
if( !aMask )
{
bmp = new (ELeave) CFbsBitmap();
CleanupStack::PushL( bmp );
User::LeaveIfError( bmp->Create( iSize, aMode ) );
CleanupStack::Pop( bmp );
iData->DestroyAndSetBitmap( bmp );
}
else
{
bmp = new (ELeave) CFbsBitmap();
CleanupStack::PushL( bmp );
User::LeaveIfError( bmp->Create( iSize, aMode ) );
CleanupStack::Pop( bmp );
iData->DestroyAndSetMask( bmp );
}
if ( iDev )
{
delete iDev;
iDev = NULL;
}
iDev = CFbsBitmapDevice::NewL( bmp );
iDev->Resize( iSize );
if ( iGc )
{
delete iGc;
iGc = NULL;
}
iGc = CFbsBitGc::NewL();
iGc->Activate( iDev );
return iGc;
}
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CMaskedBitmap::CopyBitmap
// -----------------------------------------------------------------------------
TInt BitmapUtil::CopyBitmap( const CFbsBitmap& aSource, CFbsBitmap& aDestination )
{
TSize size( aSource.SizeInPixels() );
TDisplayMode displayMode( aSource.DisplayMode() );
TInt err( aDestination.Create( size, displayMode ) );
if( !err )
{
err = BitmapUtil::CopyBitmapData( aSource, aDestination, size, displayMode );
if( err )
{
aDestination.Reset();
}
}
return err;
}
// -----------------------------------------------------------------------------
// CSatSIconConverter::CreateBitmapL
// Creates the bitmap.
// -----------------------------------------------------------------------------
//
CFbsBitmap* CSatSIconConverter::CreateBitmapL(
TUint8 aWidth,
TUint8 aHeight,
TDisplayMode aDisplayMode ) const
{
LOG( SIMPLE, "SATENGINE: CSatSIconConverter::CreateBitmapL calling" )
CFbsBitmap* bitmap = new( ELeave )CFbsBitmap();
CleanupStack::PushL( bitmap );
User::LeaveIfError(
bitmap->Create( TSize( aWidth, aHeight ), aDisplayMode ) );
CleanupStack::Pop( bitmap );
LOG( SIMPLE, "SATENGINE: CSatSIconConverter::CreateBitmapL exiting" )
return bitmap;
}
void CUploadContainer::MiuoOpenComplete(TInt aError)
{
CALLSTACKITEM_N(_CL("CUploadContainer"), _CL("MiuoOpenComplete"));
if (aError!=KErrNone) {
TBuf<40> msg;
msg.Format(_L("error opening pic %d"), aError);
iImgPlaceHolder->SetTextL(msg);
} else {
TFrameInfo frameInfo;
iFileUtil->FrameInfo(0, frameInfo);
iOrigBitmap=new (ELeave) CFbsBitmap;
iOrigBitmap->Create(frameInfo.iOverallSizeInPixels, EColor4K);
iFileUtil->ConvertL(*iOrigBitmap);
}
}
void AknBitmapMirrorUtils::LoadPartialBitmapL(CFbsBitmap* aBitmap, const TDesC& aFileName,TInt32 aId, TRect aRect, TBool aMirrorHorizontally)
{
CFbsBitmap* destinationBitmap = aBitmap;
User::LeaveIfNull(destinationBitmap);
CFbsBitmap* sourceBitmap = new (ELeave) CFbsBitmap();
CleanupStack::PushL(sourceBitmap);
User::LeaveIfError(sourceBitmap->Load(aFileName, aId, ETrue));
TSize sourceBitmapSize = sourceBitmap->SizeInPixels();
TRect sourceRect = TRect(aRect);
if (sourceRect == KWholeBitmapRect)
{
sourceRect.iTl.iX = 0;
sourceRect.iTl.iY = 0;
sourceRect.iBr.iX = sourceBitmapSize.iWidth;
sourceRect.iBr.iY = sourceBitmapSize.iHeight;
}
TSize destinationBitmapSize(sourceRect.Width(), sourceRect.Height());
User::LeaveIfError(destinationBitmap->Create(destinationBitmapSize, sourceBitmap->DisplayMode()));
CFbsBitmapDevice* destinationDevice = CFbsBitmapDevice::NewL( destinationBitmap );
CleanupStack::PushL(destinationDevice);
CFbsBitGc* destinationGc;
User::LeaveIfError( destinationDevice->CreateContext( destinationGc ) );
if (aMirrorHorizontally)
{
TRect sourceBitmapBlittingRect( sourceRect.iTl.iX,sourceRect.iTl.iY,sourceRect.iTl.iX + 1,sourceRect.iBr.iY );
for ( TInt xPos=destinationBitmapSize.iWidth-1; xPos >= 0; xPos-- )
{
destinationGc->BitBlt( TPoint(xPos,0), sourceBitmap, sourceBitmapBlittingRect );
sourceBitmapBlittingRect.iTl.iX++;
sourceBitmapBlittingRect.iBr.iX++;
}
}
else
{
destinationGc->BitBlt( TPoint(0,0), sourceBitmap, sourceRect );
}
delete destinationGc;
CleanupStack::PopAndDestroy(2); // sourceBitmap, destinationDevice
}
/**
Copy a source bitmap into a new bitmap with the specified display mode
*/
CFbsBitmap* CTe_graphicsperformanceSuiteStepBase::CopyIntoNewBitmapL(CFbsBitmap* aSrc, TDisplayMode aDisplayMode)
{
CFbsBitmap* dstBmp = new(ELeave) CFbsBitmap;
CleanupStack::PushL(dstBmp);
TInt ret=dstBmp->Create(aSrc->SizeInPixels(), aDisplayMode);
User::LeaveIfError(ret);
CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(dstBmp);
CleanupStack::PushL(bitmapDevice);
CFbsBitGc* gc;
ret = bitmapDevice->CreateContext(gc);
User::LeaveIfError(ret);
CleanupStack::PushL(gc);
gc->BitBlt(TPoint(0,0), aSrc);
CleanupStack::PopAndDestroy(2, bitmapDevice); // gc, bitmapDevice
CleanupStack::Pop(dstBmp);
return dstBmp;
}
QS60WindowSurface::QS60WindowSurface(QWidget* widget)
: QWindowSurface(widget), d_ptr(new QS60WindowSurfacePrivate)
{
QWidgetPrivate *widgetPrivate = qt_widget_private(widget);
const bool opaque = widgetPrivate->isOpaque && !blitWriteAlpha(widgetPrivate);
TDisplayMode mode = displayMode(opaque);
// We create empty CFbsBitmap here -> it will be resized in setGeometry
CFbsBitmap *bitmap = new CFbsBitmap; // CBase derived object needs check on new
Q_CHECK_PTR(bitmap);
qt_symbian_throwIfError( bitmap->Create( TSize(0, 0), mode ) );
QSymbianRasterPixmapData *data = new QSymbianRasterPixmapData(QPixmapData::PixmapType);
if (data) {
data->fromSymbianBitmap(bitmap, true);
d_ptr->device = QPixmap(data);
}
}
/**
Compare the window with the bitmap.
@param aScreen The screen device object
@param aBitmap The bitmap object for comparison
@return ETrue if the window and the bitmap is identified. Otherwise return EFalse.
*/
TBool CT_WServGenericpluginStepLoad::CompareDisplayL(CWsScreenDevice* aScreen, CFbsBitmap* aBitmap)
{
// Capture window display to bitmap
CFbsBitmap* screenBitmap = new(ELeave) CFbsBitmap();
CleanupStack::PushL(screenBitmap);
User::LeaveIfError(screenBitmap->Create(KWinRect.Size(), iDisplayMode));
User::LeaveIfError(aScreen->CopyScreenToBitmap(screenBitmap, KWinRect));
//Compare the window bitmap with the bitmap pass in for comparison
TBool ret = ETrue;
const TReal KErrorLimit = 0.05;
TInt mismatchedPixels = 0;
TRgb testWinPix = TRgb(0,0,0,0);
TRgb checkWinPix = TRgb(0,0,0,0);
for (TInt x = 0; x < KWinRect.Width(); x++)
{
for (TInt y = 0; y < KWinRect.Height(); y++)
{
screenBitmap->GetPixel(testWinPix, TPoint(x,y));
aBitmap->GetPixel(checkWinPix, TPoint(x,y));
//check if there are differeces between test Window colors and check Window colors
if(((TReal)abs(testWinPix.Red() - checkWinPix.Red())/255) > KErrorLimit ||
((TReal)abs(testWinPix.Blue() - checkWinPix.Blue())/255) > KErrorLimit ||
((TReal)abs(testWinPix.Green() - checkWinPix.Green())/255) > KErrorLimit ||
((TReal)abs(testWinPix.Alpha() - checkWinPix.Alpha())/255) > KErrorLimit)
{
mismatchedPixels++; // -- Useful for debugging
ret = EFalse;
break;
}
}
}
/* INFO_PRINTF2(_L("Number of different pixels: %i"), mismatchedPixels); */ // -- Useful for debugging
CleanupStack::PopAndDestroy(screenBitmap);
return ret;
}
void CTestCamSnapshot::DoStartSnapshotL()
{
CFbsBitmap* snapshot = new(ELeave) CFbsBitmap;
CleanupStack::PushL(snapshot);
User::LeaveIfError(snapshot->Create(iSnapshotImageRect.Size(), iSnapshotImage->DisplayMode()));
CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL(snapshot);
CleanupStack::PushL(dev);
CFbsBitGc* gc = NULL;
User::LeaveIfError(dev->CreateContext(gc));
CleanupStack::Pop(dev);
CleanupStack::Pop(snapshot);
iSnapshot = snapshot;
iSnapshotDev = dev;
iSnapshotGc = gc;
iSnapshotActive = ETrue;
}
/**
Auxilary function called to Copy the screen to bitmap (mbm) file.
@param aHashIndex contains hashID. Bitmap is created with the aHashIndex as name
*/
EXPORT_C void CTHashReferenceImages::CopyScreenToBitmapL(const TDesC& aHashIndex)
{
CFbsBitmap *bitmap = new(ELeave)CFbsBitmap();
CleanupStack::PushL(bitmap);
User::LeaveIfError(bitmap->Create(iBitmapDevice->SizeInPixels(), iBitmapDevice->DisplayMode()));
TRect rect = TRect(iBitmapDevice->SizeInPixels());
CFbsBitmapDevice *device=CFbsBitmapDevice::NewL(bitmap);
CleanupStack::PushL(device);
CFbsBitGc *gc;
User::LeaveIfError(device->CreateContext(gc));
gc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
gc->BitBlt(TPoint(), iBitmap, rect);
TFileName mbmFile;
mbmFile.Format(iPath->Des(), &aHashIndex);
bitmap->Save(mbmFile);
delete gc;
CleanupStack::PopAndDestroy(2);
}
void tst_QVolatileImage::create()
{
QVolatileImage nullImg;
QVERIFY(nullImg.isNull());
QVolatileImage img(100, 200, QImage::Format_ARGB32);
QVERIFY(!img.isNull());
QCOMPARE(img.width(), 100);
QCOMPARE(img.height(), 200);
QCOMPARE(img.format(), QImage::Format_ARGB32);
QCOMPARE(img.byteCount(), img.bytesPerLine() * img.height());
QCOMPARE(img.hasAlphaChannel(), true);
QCOMPARE(img.depth(), 32);
QImage source(12, 23, QImage::Format_ARGB32_Premultiplied);
img = QVolatileImage(source);
QVERIFY(!img.isNull());
QCOMPARE(img.width(), 12);
QCOMPARE(img.height(), 23);
QCOMPARE(img.format(), source.format());
QCOMPARE(img.byteCount(), img.bytesPerLine() * img.height());
QVERIFY(img.imageRef() == source);
QVERIFY(img.toImage() == source);
QCOMPARE(img.hasAlphaChannel(), true);
QCOMPARE(img.hasAlphaChannel(), img.imageRef().hasAlphaChannel());
QCOMPARE(img.hasAlphaChannel(), img.toImage().hasAlphaChannel());
QCOMPARE(img.depth(), 32);
#ifdef Q_OS_SYMBIAN
CFbsBitmap *bmp = new CFbsBitmap;
QVERIFY(bmp->Create(TSize(100, 50), EColor16MAP) == KErrNone);
QVolatileImage bmpimg(bmp);
QVERIFY(!bmpimg.isNull());
QCOMPARE(bmpimg.width(), 100);
QCOMPARE(bmpimg.height(), 50);
// Verify that we only did handle duplication, not pixel data copying.
QCOMPARE(bmpimg.constBits(), (const uchar *) bmp->DataAddress());
delete bmp;
// Check if content is still valid.
QImage copyimg = bmpimg.toImage();
QCOMPARE(copyimg.format(), QImage::Format_ARGB32_Premultiplied);
#endif
}
void tst_QVolatileImage::ensureFormat()
{
QImage source(12, 23, QImage::Format_ARGB32_Premultiplied);
QVolatileImage img(source);
QVERIFY(!img.isNull());
QVERIFY(img.imageRef() == source);
QVERIFY(img.toImage() == source);
QVERIFY(img.ensureFormat(QImage::Format_ARGB32_Premultiplied)); // no-op
QVERIFY(img.imageRef() == source);
QVERIFY(img.toImage() == source);
QVERIFY(img.format() == QImage::Format_ARGB32_Premultiplied);
QVERIFY(img.ensureFormat(QImage::Format_RGB32)); // new data under-the-hood
QVERIFY(img.imageRef() != source);
QVERIFY(img.toImage() != source);
QVERIFY(img.format() == QImage::Format_RGB32);
#ifdef Q_OS_SYMBIAN
CFbsBitmap *bmp = new CFbsBitmap;
QVERIFY(bmp->Create(TSize(100, 50), EColor16MAP) == KErrNone);
QVolatileImage bmpimg(bmp);
QVERIFY(bmpimg.ensureFormat(QImage::Format_ARGB32_Premultiplied)); // no-op
QCOMPARE(bmpimg.constBits(), (const uchar *) bmp->DataAddress());
// A different format should cause data copying.
QVERIFY(bmpimg.ensureFormat(QImage::Format_RGB32));
QVERIFY(bmpimg.constBits() != (const uchar *) bmp->DataAddress());
const uchar *prevBits = bmpimg.constBits();
QVERIFY(bmpimg.ensureFormat(QImage::Format_RGB16));
QVERIFY(bmpimg.constBits() != (const uchar *) bmp->DataAddress());
QVERIFY(bmpimg.constBits() != prevBits);
prevBits = bmpimg.constBits();
QVERIFY(bmpimg.ensureFormat(QImage::Format_MonoLSB));
QVERIFY(bmpimg.constBits() != (const uchar *) bmp->DataAddress());
QVERIFY(bmpimg.constBits() != prevBits);
delete bmp;
#endif
}
QS60WindowSurface::QS60WindowSurface(QWidget* widget)
: QWindowSurface(widget), d_ptr(new QS60WindowSurfacePrivate)
{
TDisplayMode mode = S60->screenDevice()->DisplayMode();
bool isOpaque = qt_widget_private(widget)->isOpaque;
if (mode == EColor16MA && isOpaque)
mode = EColor16MU; // Faster since 16MU -> 16MA is typically accelerated
else if (mode == EColor16MU && !isOpaque)
mode = EColor16MA; // Try for transparency anyway
// We create empty CFbsBitmap here -> it will be resized in setGeometry
CFbsBitmap *bitmap = q_check_ptr(new CFbsBitmap); // CBase derived object needs check on new
qt_symbian_throwIfError( bitmap->Create( TSize(0, 0), mode ) );
QS60PixmapData *data = new QS60PixmapData(QPixmapData::PixmapType);
data->fromSymbianBitmap(bitmap);
d_ptr->device = QPixmap(data);
setStaticContentsSupport(true);
}
//-----------------------------------------------------------------------------
// CBrowserViewImagesListBox::CreateIconL(
// CFbsBitmap* aBitmap, TBool aShrinkIt )
//-----------------------------------------------------------------------------
//
CGulIcon* CBrowserViewImagesListBox::CreateIconL(
CFbsBitmap* aBitmap, TBool aShrinkIt)
{
CGulIcon* icon = NULL;
// create icon
if(aShrinkIt)
{
CFbsBitmap* bmp = new(ELeave)CFbsBitmap;
CleanupStack::PushL(bmp);
User::LeaveIfError(bmp->Create(TSize(42,32), EColor16M));
// create bitmap device
CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL(bmp);
CleanupStack::PushL(dev);
// create graphics context for bitmap device
CGraphicsContext* ctx = NULL;
User::LeaveIfError( dev->CreateContext(ctx) );
CleanupStack::PushL(ctx);
// calculate aspect ratio
TSize targetSize = Fit(aBitmap->SizeInPixels(), bmp->SizeInPixels());
// copy bitmap to temporary bitmap
ctx->DrawBitmap(TRect(TPoint(0,0), targetSize), aBitmap, TRect(TPoint(0,0), aBitmap->SizeInPixels()));
CleanupStack::PopAndDestroy(2); // ctx, dev
icon = CGulIcon::NewL(bmp); // bmp is owned, no mask used
CleanupStack::Pop(); // bmp
delete aBitmap;
}
else
{
icon = CGulIcon::NewL(aBitmap); // bitmap is owned, no mask used
}
return icon;
}