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; }
// CFepLayoutChoiceList::DrawChoiceListBackground // Draw choice list background. // (other items were commented in a header). // --------------------------------------------------------------------------- // void CFepLayoutChoiceList::DrawChoiceListBackground(const TRect& aRect)//, TBool aDrawBorder) { if( iBackgroundSkinID.iMajor != EAknsMajorNone && iBackgroundSkinID.iMinor != EAknsMinorNone ) { //draw bitmap DrawOpaqueMaskBackground( aRect ); TRect rtInnerRect( aRect ); rtInnerRect.Shrink( 1, 1 ); CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc()); gc->Activate( BitmapDevice() ); AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(), *gc, aRect, rtInnerRect, iBackgroundSkinID, KAknsIIDDefault ); } else { //draw bitmap DrawOpaqueMaskBackground(); //front bitmaps------- DrawBackground(); } }
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; }
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; }
// CFepLayoutChoiceList::DrawBitmap // Draw bitmap helper function. // (other items were commented in a header). // --------------------------------------------------------------------------- // void CFepLayoutChoiceList::DrawBitmap(const TRect& aDestRect, const TRect& aSrcRect, CFbsBitmap* aBmp, TBool aFast) { CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc()); if( aFast ) { gc->BitBlt(aDestRect.iTl, aBmp, aSrcRect); } else { gc->DrawBitmap(aDestRect, aBmp, aSrcRect); } }
void CEmTubeSplashViewContainer::ConstructL(const TRect& aRect) { iAlpha = KAlphaMax; iAppUi = STATIC_CAST(CEmTubeAppUi*, CEikonEnv::Static()->EikAppUi()); CreateWindowL(); TSize size( KBitmapSize, KBitmapSize ); CFbsBitmap *bmp = AknIconUtils::CreateIconL( KBitmapFileName, EMbmOpenvideohubLogo_white ); CleanupStack::PushL( bmp ); AknIconUtils::SetSize( bmp, size ); iBitmap = new (ELeave) CFbsBitmap(); iBitmap->Create( size, EColor16MU ); CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL( iBitmap ); CleanupStack::PushL( bitmapDevice ); CFbsBitGc* bitmapGc = CFbsBitGc::NewL(); CleanupStack::PushL( bitmapGc ); bitmapGc->Activate( bitmapDevice ); bitmapGc->DrawBitmap( size, bmp ); CleanupStack::PopAndDestroy( bitmapGc ); CleanupStack::PopAndDestroy( bitmapDevice ); CleanupStack::PopAndDestroy( bmp ); iTmpBitmap = new (ELeave) CFbsBitmap; iTmpBitmap->Create( TSize(KBitmapSize, KBitmapSize), EColor16MU ); SetRect(aRect); iClientRect = aRect; ActivateL(); SetExtentToWholeScreen(); iAppUi->StopDisplayingPopupToolbar(); iFadeTimer = CEmTubeTimeOutTimer::NewL( *this ); iFadeTimer->After( KFadePeriod, ECommandFadeIn ); iTimer = CEmTubeTimeOutTimer::NewL( *this ); iTimer->After( KSplashTime, ECommandFinish ); #ifdef __S60_50__ MTouchFeedback* feedback = MTouchFeedback::Instance(); if ( feedback ) { feedback->EnableFeedbackForControl( this, ETrue ); } #endif }
/** Draws a stretched bitmap with or without a mask. @param aUseMask set to ETrue to use a alpha mask. Normally used for 16MU display modes that do not store the alpha. @param aSrcMode is the source display mode @param aDstMode is the destination display mode @param aSession is the windows server session @param aWindow is a reference to the window @param aGc is the graphics context of the window @param aNumIterations is the number of iterations to run the test */ void CAlphaBlendTest::DoDrawBitmapL(TBool aUseMask, TDisplayMode aSrcMode, TDisplayMode aDstMode, RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, TInt aNumIterations) { const TSize bitmapSize = aWindow.Size(); // Construct target bitmap. CFbsBitmap* bitmapTarget = CreateSoftwareBitmapLC(bitmapSize, aDstMode); CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmapTarget); CleanupStack::PushL(bitmapDevice); // Construct GC. CFbsBitGc* bitmapGc = NULL; User::LeaveIfError(bitmapDevice->CreateContext(bitmapGc)); CleanupStack::PushL(bitmapGc); // Construct source bitmap. TSize smallerSize(bitmapSize.iWidth/2, bitmapSize.iHeight/2); CFbsBitmap* source = CreateSoftwareBitmapLC(smallerSize, aSrcMode); VerticalGradientAlphaL(source, TRgb(0x00000000), TRgb(0xffffffff)); CFbsBitmap* sourceAlpha = CreateSoftwareBitmapLC(smallerSize, EGray256); // match size to src VerticalGradientAlphaL(sourceAlpha, TRgb(0x01010101), TRgb(0xfefefefe)); bitmapGc->SetBrushStyle(CGraphicsContext::ENullBrush); bitmapGc->SetBrushColor(TRANSPARENT_BLACK); bitmapGc->Clear(); bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN); aGc->Activate(aWindow); TPoint point(0,0); bitmapGc->BitBlt(point, bitmapTarget); aGc->Deactivate(); aSession.Flush(); TBuf <20> testName; if (!aUseMask) { testName=_L("DrawBitmap"); iProfiler->InitResults(); for(int i=0; i<aNumIterations; i++) { bitmapGc->DrawBitmap(TRect(point, bitmapSize), source); iProfiler->MarkResultSetL(); } } else { testName=_L("DrawBitmapMasked"); iProfiler->InitResults(); for(int i=0; i<aNumIterations; i++) { bitmapGc->DrawBitmapMasked(TRect(point, bitmapSize), source,TRect(point, smallerSize), sourceAlpha, EFalse); iProfiler->MarkResultSetL(); } } INFO_PRINTF4(_L("%S(Stretched) with src = %S, dst = %S"), &testName, &ColorModeName(aSrcMode), &ColorModeName(aDstMode)); iProfiler->ResultsAnalysis(testName, 0, aSrcMode, aDstMode, aNumIterations); // copy up to screen for sanity check BitBlt(aSession, aWindow, aGc, *bitmapTarget); CleanupStack::PopAndDestroy(5, bitmapTarget); }
void CTap2MenuAppUi::CopyBitmapL(CFbsBitmap *aSource, CFbsBitmap *aTarget) { if(aSource != NULL && aTarget != NULL) { if(aSource->SizeInPixels() != aTarget->SizeInPixels() || aSource->DisplayMode() != aTarget->DisplayMode()) {User::Leave(KErrArgument);} CFbsBitmapDevice* device = CFbsBitmapDevice::NewL(aTarget); CleanupStack::PushL(device); CFbsBitGc* gc = NULL; User::LeaveIfError(device->CreateContext(gc)); CleanupStack::PushL(gc); gc->BitBlt(TPoint(0, 0), aSource); CleanupStack::PopAndDestroy(gc); CleanupStack::PopAndDestroy(device); } }
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 }
// ----------------------------------------------------------------------------- // CMaskedBitmap::TileInBitmapRect // ----------------------------------------------------------------------------- void CMaskedBitmap::TileInBitmapRect( CFbsBitGc& gc, const TRect& bmpRect, const TPoint& srcPt ) { if (!HasMask()) { TRAP_IGNORE( CFbsBitGc* copy = CFbsBitGc::NewL(); CleanupStack::PushL( copy ); copy->Activate( (CFbsDevice*) gc.Device() ); copy->CopySettings( gc ); copy->UseBrushPattern(iBitmap); copy->SetPenStyle(CGraphicsContext::ENullPen); copy->SetBrushStyle(CGraphicsContext::EPatternedBrush); copy->SetBrushOrigin(srcPt); copy->DrawRect(bmpRect); copy->DiscardBrushPattern(); CleanupStack::PopAndDestroy( copy ); );
/** 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; }
class CFbsBitmap* WFBitmapUtil::CopyBitmapL(class CFbsBitmap* aBitmap) { if (!aBitmap) { return NULL; } class CFbsBitmap* copiedBitmap = new (ELeave) CFbsBitmap(); copiedBitmap->Create(aBitmap->SizeInPixels(), aBitmap->DisplayMode()); CFbsBitmapDevice* fbsdev = CFbsBitmapDevice::NewL(copiedBitmap); CleanupStack::PushL(fbsdev); CFbsBitGc* fbsgc = CFbsBitGc::NewL(); CleanupStack::PushL(fbsgc); fbsgc->Activate(fbsdev); fbsgc->BitBlt(TPoint(0,0),aBitmap); CleanupStack::PopAndDestroy(2); return copiedBitmap; }
// --------------------------------------------------------------------------- // CFepUiLayoutRootCtrl::DrawFrame // Draw moving frame // (other items were commented in a header). // --------------------------------------------------------------------------- // TRect CFepUiLayoutRootCtrl::DrawFrame(const TRect& aFrameRect, TBool aDrawFlag) { //clear shadow when moving TBool updateShadowArea = EFalse; TRect dirtyRect; if(iShadowShown) { ClearRect(iShadowRect); iShadowShown = EFalse; updateShadowArea = ETrue; } TRect bmpRect; TPoint bmpPos; CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc()); //draw mask background TRgb maskPenCol = aDrawFlag ? TRgb(KOpaqueColor) : TRgb(KTransparentColor); DrawBackgroundToDevice(aFrameRect,MaskBitmapDevice(), 0, //TRgb(KTransparentColor), TRgb(KOpaqueColor),EFalse); TRgb(KTransparentColor), maskPenCol,EFalse); //draw background TRgb penCor = aDrawFlag ? KRgbBlack : KRgbWhite; TAknsQsnOtherColorsIndex clrIndex; clrIndex = EAknsCIQsnOtherColorsCG9; if ( AknsUtils::AvkonSkinEnabled() ) { AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), penCor, KAknsIIDQsnTextColors, clrIndex ); } DrawBackgroundToDevice(aFrameRect,BitmapDevice(),0,TRgb(KRgbWhite),penCor,EFalse); gc->RectDrawnTo(dirtyRect); if(updateShadowArea) return iShadowRect; else return dirtyRect; }
/** Copy a bitmap into another bitmap (generally in a different displaymode) tiles destination bitmap with source */ void CTe_graphicsperformanceSuiteStepBase::CopyBitmapL(CFbsBitmap* aDst, CFbsBitmap* aSrc) { TSize srcSize = aSrc->SizeInPixels(); TSize dstSize = aDst->SizeInPixels(); CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL(aDst); CleanupStack::PushL(dev); CFbsBitGc* gc = NULL; if ( 0 == dev->CreateContext(gc) ) { CleanupStack::PushL(gc); TPoint point; gc->SetBrushColor(TRANSPARENT_BLACK); gc->SetBrushStyle(CGraphicsContext::ENullBrush); gc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha); gc->Clear(); gc->SetDrawMode(CGraphicsContext::EDrawModePEN); for(point.iY=0; point.iY<dstSize.iHeight; point.iY+=srcSize.iHeight) { for(point.iX=0; point.iX<dstSize.iWidth; point.iX+=srcSize.iWidth) { gc->BitBlt(point, aSrc); } } CleanupStack::PopAndDestroy(gc); } CleanupStack::PopAndDestroy(dev); }
/** 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 CTransparentBitmap::Draw(CFbsBitGc& gc,TInt aX, TInt aY) { // gc.BitBlt(TPoint(aX,aY),iMaskBitmap); if (iSrcBitmap && iMaskBitmap) { TRect sourceRect( TPoint( 0,0 ),iSrcBitmap->SizeInPixels() ); gc.BitBltMasked(TPoint(aX,aY),iSrcBitmap,sourceRect,iMaskBitmap,ETrue); } }
// ----------------------------------------------------------------------------- // CMaskedBitmap::BitBlt // ----------------------------------------------------------------------------- void CMaskedBitmap::BitBlt( CFbsBitGc& aContext, const TPoint& aPoint ) const { TSize s(iBitmap->SizeInPixels()); if (!(s.iWidth>0 && s.iHeight>0)) { return; } if( iBitmap->Handle() ) { if( iMask->Handle() ) { aContext.BitBltMasked( aPoint, iBitmap, s, iMask, iInvertMask ); } else { aContext.BitBlt( aPoint, iBitmap, s ); } } }
// ----------------------------------------------------------------------------- // CMaskedBitmap::BitBlt // ----------------------------------------------------------------------------- void CMaskedBitmap::BitBlt( CFbsBitGc& aContext, const TPoint& aPoint, const TRect& aSource ) const { if (!(aSource.Width()>0 && aSource.Height()>0)) { return; } if( iBitmap->Handle() ) { if( iMask->Handle() ) { aContext.BitBltMasked( aPoint, iBitmap, aSource, iMask, iInvertMask ); } else { aContext.BitBlt( aPoint, iBitmap, aSource ); } } }
// ----------------------------------------------------------------------------- // CMaskedBitmap::DrawBitmap // ----------------------------------------------------------------------------- void CMaskedBitmap::DrawBitmap( CFbsBitGc& aContext, const TRect& aTarget, const TRect& aSource) const { if (!(aSource.Width()>0 && aSource.Height()>0 && aTarget.Width()>0 && aTarget.Height()>0)) { return; } if( iBitmap->Handle() ) { // ### FIXME DrawBitmapMasked is too buggy to use 2.8/week52, so no transparency with scaling if( iMask->Handle() ) { aContext.DrawBitmapMasked( aTarget, iBitmap, aSource, iMask, iInvertMask ); } else { aContext.DrawBitmap( aTarget, iBitmap, aSource ); } } }
// ----------------------------------------------------------------------------- // CMaskedBitmap::DrawBitmap // ----------------------------------------------------------------------------- void CMaskedBitmap::DrawBitmap( CFbsBitGc& aContext, const TRect& aTarget ) const { TSize s(iBitmap->SizeInPixels()); if (!(aTarget.Width()>0 && aTarget.Height()>0 && s.iWidth>0 && s.iHeight>0)) { return; } if( iBitmap->Handle() ) { // ### FIXME DrawBitmapMasked is too buggy to use 2.8/week52, so no transparency with scaling if( iMask->Handle() ) { aContext.DrawBitmapMasked( aTarget, iBitmap, s, iMask, iInvertMask ); } else { aContext.DrawBitmap( aTarget, iBitmap ); } } }
// ============================================================================ // CIconConverter::DoIconStoreL() // Store icon and mask files // // @since 3.1 // ============================================================================ void CIconConverter::DoIconStoreL() { // Store the icon and its mask in temporary files until we are ready // to create the final icon // Icon is stored at index n, mask at index n+1 TInt iconIndex = iCurrentSizeIndex * 2; TFileName iconFile = *iTempPath; GetTempIconName( iconIndex++, iconFile ); TFileName maskFile = *iTempPath; GetTempIconName( iconIndex, maskFile ); // invert the masks before saving CFbsBitmapDevice* device = CFbsBitmapDevice::NewL( iTempBitmapMask ); CleanupStack::PushL( device ); CFbsBitGc* gc; User::LeaveIfError( device->CreateContext( gc ) ); gc->SetDrawMode( CGraphicsContext::EDrawModeNOTSCREEN ); gc->Clear(); delete gc; CleanupStack::PopAndDestroy( device ); // save the bitmaps User::LeaveIfError( iTempBitmap->Save( iconFile ) ); User::LeaveIfError( iTempBitmapMask->Save( maskFile ) ); if ( ++iCurrentSizeIndex < iIconSizes->Count() ) { // do the next icon size DoIconScalingL(); } else { DoCreateFinalIconL(); } }
EXPORT_C void THuiFont::RasterizeLineL(const TDesC& aTextString, CFbsBitGc& aTargetContext) { // Retrieve the CFont object used when rasterizing this text mesh. CFont* font = NearestFontL(); // Draw the text aTargetContext.UseFont(font); TInt avkonMaxAscent = 0; if (CCoeEnv::Static()) { const CAknLayoutFont* layoutFont = CAknLayoutFont::AsCAknLayoutFontOrNull( font ); avkonMaxAscent = layoutFont->MaxAscent() + KHuiFontVerticalShiftInPixels; } else { avkonMaxAscent = iTextPaneHeight; } aTargetContext.DrawText(aTextString, TPoint(0, avkonMaxAscent )); aTargetContext.DiscardFont(); }
/** 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; }
// ============================================================================ // CIconConverter::DoProcessMaskL() // process the bitmap mask // // @since 3.1 // ============================================================================ void CIconConverter::DoProcessMaskL() { // we use white to mean transparent at this stage, simply for efficiency // since all the canvases we will copy in to begin as white if ( iOriginalBitmapMask->Handle() == 0 ) { // Create a mask that shows the whole bitmap as an icon // (all black) User::LeaveIfError( iOriginalBitmapMask->Create( iOriginalBitmap->SizeInPixels(), EGray2 ) ); CFbsBitmapDevice* device = CFbsBitmapDevice::NewL( iOriginalBitmapMask ); CleanupStack::PushL( device ); CFbsBitGc* gc; User::LeaveIfError( device->CreateContext( gc ) ); gc->SetBrushStyle( CGraphicsContext::ESolidBrush ); gc->SetDrawMode( CGraphicsContext::EDrawModePEN ); gc->SetBrushColor( KRgbBlack ); // Create a big black image gc->Clear(); delete gc; CleanupStack::PopAndDestroy( device ); } else { // Invert the mask obtained from the PNG CFbsBitmapDevice* device = CFbsBitmapDevice::NewL( iOriginalBitmapMask ); CleanupStack::PushL(device); CFbsBitGc* gc; User::LeaveIfError( device->CreateContext( gc ) ); gc->SetDrawMode( CGraphicsContext::EDrawModeNOTSCREEN ); gc->Clear(); delete gc; CleanupStack::PopAndDestroy( device ); } // Scale the icon to the sizes required iCurrentSizeIndex = 0; DoIconScalingL(); }
/* ------------------------------------------------------------------------------- internal icon re-sizer function ------------------------------------------------------------------------------- */ CGulIcon* CYBRecognizer1::GetListIconL(const TDesC& aFileName,TInt aImage,TInt aMask, TSize aSize) { CGulIcon* RetIcon(NULL); TBool OkToAdd(EFalse); CFbsBitmap* MyBitmap = new(ELeave)CFbsBitmap(); CleanupStack::PushL(MyBitmap); CFbsBitmap* MyMask = new(ELeave)CFbsBitmap(); CleanupStack::PushL(MyMask); if(KErrNone == MyBitmap->Load(aFileName,aImage)) { if(KErrNone == MyMask->Load(aFileName,aMask)) { OkToAdd = ETrue; } } if(OkToAdd) { TSize ImgSiz = MyBitmap->SizeInPixels(); if(aSize.iWidth != ImgSiz.iWidth || aSize.iHeight!= ImgSiz.iHeight) { CFbsBitmap* TmpBackBitmap = new(ELeave)CFbsBitmap(); CleanupStack::PushL(TmpBackBitmap); if(KErrNone == TmpBackBitmap->Create(aSize,MyBitmap->DisplayMode())) { CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(TmpBackBitmap); CleanupStack::PushL(bitmapDevice); CFbsBitGc* graphicsContext = NULL; User::LeaveIfError(bitmapDevice->CreateContext(graphicsContext)); CleanupStack::PushL(graphicsContext); graphicsContext->DrawBitmap(TRect(0,0,aSize.iWidth,aSize.iHeight),MyBitmap); CleanupStack::PopAndDestroy(2);//graphicsContext,bitmapDevice, } CFbsBitmap* TmpBackMask = new(ELeave)CFbsBitmap(); CleanupStack::PushL(TmpBackMask); if(KErrNone == TmpBackMask->Create(aSize,MyMask->DisplayMode())) { CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(TmpBackMask); CleanupStack::PushL(bitmapDevice); CFbsBitGc* graphicsContext = NULL; User::LeaveIfError(bitmapDevice->CreateContext(graphicsContext)); CleanupStack::PushL(graphicsContext); graphicsContext->DrawBitmap(TRect(0,0,aSize.iWidth,aSize.iHeight),MyMask); CleanupStack::PopAndDestroy(2);//graphicsContext,bitmapDevice, } CleanupStack::Pop(2);//TmpBackBitmap, TmpBackMask RetIcon = CGulIcon::NewL(TmpBackBitmap, TmpBackMask); } } if(!RetIcon && OkToAdd) { CleanupStack::Pop(2);//MyBitmap, MyMask RetIcon = CGulIcon::NewL(MyBitmap, MyMask); } else { CleanupStack::PopAndDestroy(2);//MyBitmap, MyMask } return RetIcon; }
EXPORT_C void CBubbleCtrl::Draw() { if(!AbleToDraw() || iFreeze ) //|| !iShowing ) { return; } CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc()); //mask bitmaps DrawOpaqueMaskBackground(); TRect rect = Rect(); TRect innerRect = rect; if ( ( iLeftDiff == 0 ) && ( iTopDiff == 0 ) && ( iRightDiff == 0 ) && ( iBottomDiff == 0 ) ) { innerRect.Shrink( KShrinkSize, 0 ); } else { innerRect.iTl.iX = innerRect.iTl.iX + iLeftDiff; innerRect.iTl.iY = innerRect.iTl.iY + iTopDiff; innerRect.iBr.iX = innerRect.iBr.iX - iRightDiff; innerRect.iBr.iY = innerRect.iBr.iY - iBottomDiff; } // ----- draw bitmaps ----- gc->Activate( BitmapDevice() ); //gc->Clear(rect); // Draw background if ( iBgSkinId.iMajor ) { AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(), *gc, rect, innerRect, iBgSkinId, KAknsIIDDefault ); } else if( iFirstBmpId.iMajor && iMiddleBmpId.iMajor && iLastBmpId.iMajor ) { AknPenInputDrawUtils::Draw3PiecesFrame( AknsUtils::SkinInstance(), *gc, rect, innerRect, iFirstBmpId, iMiddleBmpId, iLastBmpId); } else { DrawBackground(); } if ( iForgroundBmp ) { if( iForgroundBmp->SizeInPixels() != innerRect.Size() ) { AknIconUtils::SetSize( iForgroundBmp, innerRect.Size(), EAspectRatioNotPreserved ); } TRect srcRect( TPoint( 0, 0 ), iForgroundBmp->SizeInPixels() ); if( iForgroundBmpMask ) { if( iForgroundBmpMask->SizeInPixels() != innerRect.Size() ) { AknIconUtils::SetSize( iForgroundBmpMask, innerRect.Size(), EAspectRatioNotPreserved); } gc->BitBltMasked( innerRect.iTl, iForgroundBmp, srcRect, iForgroundBmpMask, EFalse); } else { gc->BitBlt( innerRect.iTl, iForgroundBmp, srcRect ); } } if ( iText ) { gc->SetBrushStyle( CGraphicsContext::ENullBrush ); TAknLayoutText textLayout; textLayout.LayoutText(Rect(), iTextFormat); TRgb color( KRgbBlack ); // sane default for nonskinned case if ( AknsUtils::AvkonSkinEnabled() ) { AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), color, KAknsIIDQsnTextColors, iTextColorIndex ); } textLayout.DrawText(*gc, *iText, EFalse, color); } }
// --------------------------------------------------------------------------- // CMMACameraWindow::DrawViewFinderError() // Draws the error message to specified area. // Used in cases when viewfinder is unable to start. // --------------------------------------------------------------------------- // void CMMACameraWindow::DrawViewFinderErrorL( const TInt /*aError*/, const TRect& aDrawRect) { ASSERT(iDirectAccess); TInt dcError = KErrNone; if (!iDirectAccess->IsActive()) { TRAP(dcError, iDirectAccess->StartL()); } TRect drawRect(aDrawRect); if (dcError == KErrNone) { drawRect.Intersection(iClientRect); drawRect.Move(-iWindow->AbsPosition()); CFbsBitGc* directGc = iDirectAccess->Gc(); directGc->SetClippingRect(drawRect); directGc->SetBrushColor(TRgb(128,128,128)); directGc->SetPenColor(TRgb(128,0,0)); directGc->SetBrushStyle(CGraphicsContext::ESolidBrush); directGc->SetPenStyle(CGraphicsContext::ESolidPen); directGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha); directGc->DrawRect(drawRect); if (!iErrorIconBitmap || !iErrorIconMaskBitmap) { if (iErrorIconBitmap) { delete iErrorIconBitmap; iErrorIconBitmap = NULL; } if (iErrorIconMaskBitmap) { delete iErrorIconMaskBitmap; iErrorIconMaskBitmap = NULL; } /* AknsUtils::CreateIconL( AknsUtils::SkinInstance(), KAknsIIDQgnIndiCam4Camera, iErrorIconBitmap, iErrorIconMaskBitmap, KCameraAppBitmapFile, EMbmCameraappQgn_indi_cam4_camera, EMbmCameraappQgn_indi_cam4_camera_mask ); */ } //TRect iconRect drawRect.iTl.iX += KErrorIconMargin; drawRect.iTl.iY += KErrorIconMargin; drawRect.iBr.iX -= KErrorIconMargin; drawRect.iBr.iY -= KErrorIconMargin; if (iErrorIconBitmap->SizeInPixels() != drawRect.Size()) { AknIconUtils::SetSize(iErrorIconBitmap, drawRect.Size()); AknIconUtils::SetSize(iErrorIconMaskBitmap, drawRect.Size()); } directGc->BitBltMasked( drawRect.iTl, iErrorIconBitmap, TRect(iErrorIconBitmap->SizeInPixels()), iErrorIconMaskBitmap, EFalse); iDirectAccess->ScreenDevice()->Update(); } }
TBool CHuiRasterizedTextMesh::RasterizePictographLineL(const TDesC& aTextLine, CFont* aFont, SRasterizedLine & aLineOut) { if(iUsingPreRasterizedMesh) { return EFalse; } // Retrieve the used text style. THuiTextStyle* textStyle = CHuiStatic::Env().TextStyleManager().TextStyle(iTextStyleId); // Calculate line extents and assign it to texture size. TSize textureSize = textStyle->LineExtentsL(aTextLine); if(textureSize.iWidth == 0 || !iPictographInterface || !iPictographInterface->Interface()->ContainsPictographs(aTextLine)) { // This is an empty string or it does not contain pictographs. We will not rasterize it. // Just add a gap. aLineOut.iTexture = NULL; aLineOut.iGap = textureSize.iHeight; return !IsMaxLineCountReached(); } // store the actual size to be assigned as the textures logical size TSize actualsize(textureSize); if (aLineOut.iTexture == NULL) { // Create a texture for storing the pictographs into. aLineOut.iTexture = CHuiTexture::NewL(); HUI_DEBUG1(_L("CHuiRasterizedTextMesh::RasterizePictographLineL() - Registering self (0x%x) as a texture content observer."), this); // Register one content observer for the first texture that // is able to restore all lines in a single run if (iLines.Count()==1) { aLineOut.iTexture->iContentObservers.AppendL(*this); } aLineOut.iGap = 0; } // set a name for the texture // @todo is this needed, what names to use aLineOut.iTexture->SetImageFileNameL(_L("Pictographs")); TSize maxTextureSize = aLineOut.iTexture->MaxTextureSize(); textureSize.iWidth = Min(textureSize.iWidth, maxTextureSize.iWidth); textureSize.iHeight = Min(textureSize.iHeight, maxTextureSize.iHeight); if((textureSize.iWidth == 0) || (textureSize.iHeight == 0)) { // Cannot draw into this tiny texture, so leave. HUI_DEBUG2(_L("CHuiRasterizedTextMesh::RasterizePictographLineL() - texture size was too small to draw into (%i, %i)."), textureSize.iWidth, textureSize.iHeight); User::Leave(KErrAbort); } User::LeaveIfError( iPictographBitmap->Resize(textureSize) ); CFbsBitmapDevice* device = CFbsBitmapDevice::NewL(iPictographBitmap); CleanupStack::PushL(device); CFbsBitGc* gc = 0; User::LeaveIfError( device->CreateContext(gc) ); CleanupStack::PushL(gc); // Prepare the bitmap for drawing...set drawmode because of EColor16MA mode... gc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha); TRgb color = KRgbWhite; color.SetAlpha(0x00); gc->SetBrushColor(color); gc->Clear(); gc->UseFont(aFont); // Draw pictorgraphs iPictographInterface->Interface()->DrawPictographsInText( *gc, *aFont, aTextLine, TPoint(0, aFont->FontMaxAscent())); CleanupStack::PopAndDestroy(gc); CleanupStack::PopAndDestroy(device); aLineOut.iTexture->UploadL(*iPictographBitmap, NULL, EHuiTextureUploadFlagRetainResolution); aLineOut.iTexture->SetSize(actualsize); return !IsMaxLineCountReached(); }
// ----------------------------------------------------------------------------- // CAknsAlEffectContext::CreateIfNeededL // ----------------------------------------------------------------------------- // void CAknsAlEffectContext::CreateIfNeededL( const TInt aLayerIndex, const TInt aLayerStatus, const TBool aInitialize ) { if( ( aLayerIndex < 0 ) || ( aLayerIndex >= KAknsAlEffectContextLayerN ) ) { User::Leave( KAknsRlErrBadLayerIndex ); } /*lint -save -e661 */ // Index is boundary checked above if( iLayers[aLayerIndex].iRGBBitmap && iLayers[aLayerIndex].iAlphaBitmap ) return; if( iLayers[aLayerIndex].iRGBBitmap || iLayers[aLayerIndex].iAlphaBitmap ) User::Leave( KAknsRlErrInternalState ); TSize size = LayerSize(); CFbsBitmap* bitmap = new (ELeave) CFbsBitmap(); CleanupStack::PushL( bitmap ); User::LeaveIfError( bitmap->Create( size, iRgbMode ) ); CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL( bitmap ); CleanupStack::PushL( dev ); CFbsBitGc* gc = CFbsBitGc::NewL(); CleanupStack::PushL( gc ); gc->Activate( dev ); iLayers[aLayerIndex].iRGBBitmap = bitmap; iLayers[aLayerIndex].iRGBDevice = dev; iLayers[aLayerIndex].iRGBGc = gc; CleanupStack::Pop(3); // gc, dev, bitmap bitmap = new (ELeave) CFbsBitmap(); CleanupStack::PushL( bitmap ); User::LeaveIfError( bitmap->Create( size, EGray256 ) ); dev = CFbsBitmapDevice::NewL( bitmap ); CleanupStack::PushL( dev ); gc = CFbsBitGc::NewL(); CleanupStack::PushL( gc ); gc->Activate( dev ); iLayers[aLayerIndex].iAlphaBitmap = bitmap; iLayers[aLayerIndex].iAlphaDevice = dev; iLayers[aLayerIndex].iAlphaGc = gc; CleanupStack::Pop(3); // gc, dev, bitmap if( aInitialize ) { switch( aLayerStatus ) { case KAknsRlLayerRGBOnly: iLayers[aLayerIndex].iRGBGc->SetBrushColor( KRgbBlack ); iLayers[aLayerIndex].iRGBGc->Clear(); iLayers[aLayerIndex].iAlphaGc->SetBrushColor( KRgbWhite ); iLayers[aLayerIndex].iAlphaGc->Clear(); break; default: iLayers[aLayerIndex].iRGBGc->SetBrushColor( KRgbBlack ); iLayers[aLayerIndex].iRGBGc->Clear(); iLayers[aLayerIndex].iAlphaGc->SetBrushColor( KRgbBlack ); iLayers[aLayerIndex].iAlphaGc->Clear(); break; } } /*lint -restore */ }//lint !e661 Layer index is boundary checked
// --------------------------------------------------------------------------- // CAknDiscreetPopupDrawer::CreatePopupBitmap // --------------------------------------------------------------------------- // void CAknDiscreetPopupDrawer::CreatePopupBitmapL( const TRect& aRect ) { delete iPopupBitmap; iPopupBitmap = NULL; // create a bitmap to draw to CFbsBitmap* bitmap = new ( ELeave ) CFbsBitmap; CleanupStack::PushL( bitmap ); bitmap->Create( aRect.Size(), CCoeEnv::Static()->ScreenDevice()->DisplayMode() ); CFbsBitGc* fbsBitGc = CFbsBitGc::NewL(); CleanupStack::PushL( fbsBitGc ); CFbsBitmapDevice* bmpDevice = CFbsBitmapDevice::NewL( bitmap ); CleanupStack::PushL( bmpDevice ); fbsBitGc->Activate( bmpDevice ); // draw background of the popup MAknsSkinInstance* skin = AknsUtils::SkinInstance(); AknsDrawUtils::DrawFrame( skin, *fbsBitGc, aRect, aRect, KAknsIIDQsnFrPopupPreview, KAknsIIDDefault, KAknsDrawParamDefault ); // Draw the texts TRgb textColor( EikonEnv()->ControlColor( EColorControlText, *iControl ) ); if ( iAction ) { fbsBitGc->SetUnderlineStyle( EUnderlineOn ); AknsUtils::GetCachedColor( skin, textColor, KAknsIIDQsnHighlightColors, EAknsCIQsnHighlightColorsCG3 ); } else { AknsUtils::GetCachedColor( skin, textColor, KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG55 ); } fbsBitGc->SetPenColor( textColor ); DrawTexts( fbsBitGc ); fbsBitGc->SetUnderlineStyle( EUnderlineOff ); // draw the icon if ( iIcon && iIcon->Bitmap() && iIcon->Mask() ) { fbsBitGc->BitBltMasked( iIconRect.iTl, iIcon->Bitmap(), iIcon->Bitmap()->SizeInPixels(), iIcon->Mask(), EFalse ); } else if( iIcon && iIcon->Bitmap() ) { fbsBitGc->BitBlt( iIconRect.iTl, iIcon->Bitmap() ); } CleanupStack::PopAndDestroy( bmpDevice ); CleanupStack::PopAndDestroy( fbsBitGc ); CleanupStack::Pop( bitmap ); iPopupBitmap = bitmap; }