void CFpsView::Draw(CBitmapContext& aGc, const TRect& aTargetRect, const TSize& aSize)
{
++iFps;
int nro = iFpsCount;
const TSize sz = iNumbers->SizeInPixels();
TPoint pos(iPos.iX + sz.iWidth * iDigits, iPos.iY);
const TInt height = (sz.iHeight / 10);
do
{
const int digit = nro % 10;
nro /= 10;
TRect rect(0, digit * height, sz.iWidth, digit * height + height);
aGc.BitBlt(pos, iNumbers, rect);
pos.iX -= sz.iWidth;
}while(nro > 0);
}
void CBitmapAnimator::Render(CBitmapContext& aBitmapContext, TInt aFrame) const
{
aBitmapContext.Reset();
const CAnimationFrame& nextFrame = *iFrameArray[aFrame];
const TBool useMask = nextFrame.FrameInfo().iFlags&TFrameInfo::ETransparencyPossible || nextFrame.FrameInfo().iFlags&TFrameInfo::EAlphaChannel;
if (useMask)
{
aBitmapContext.BitBltMasked(nextFrame.FrameInfo().iFrameCoordsInPixels.iTl, nextFrame.Bitmap(), nextFrame.FrameInfo().iOverallSizeInPixels, nextFrame.Mask(), EFalse);
}
else
{
aBitmapContext.BitBlt(nextFrame.FrameInfo().iFrameCoordsInPixels.iTl, nextFrame.Bitmap(), nextFrame.FrameInfo().iOverallSizeInPixels);
}
}
void CCustomControlList::Draw(CBitmapContext& gc)
{
TInt x = iDrawPoint.iX + iDisplayPoint.iX;
TInt x2 = iDrawPoint.iX + iDisplayPoint.iX + 16;
TInt y;
TInt dy = iDrawPoint.iY;
for (TInt i=0; i<iList->Count(); i++)
{
if (dy < 0)
{
dy += iRowHeight;
continue;
}
if (dy >= iDisplaySize.iHeight)
{
break;
}
y = dy + iDisplayPoint.iY;
pListItemStruct item = (*iList)[i];
CGulIcon* icon = (*iIcons)[item->iIconIndex];
CFbsBitmap* bitmap = icon->Bitmap();
gc.BitBlt(TPoint(x, y), bitmap);
gc.UseFont(iFont);
if (i!=iSelectIndex)
{
gc.SetPenColor(iTextColor);
// HBufC* text = item->iShowName;
// gc.DrawText(*(item->iShowName), TPoint(x2, y));
}
else
{
gc.SetPenColor(iSelectTextColor);
// HBufC* text = item->iShowName;
// gc.DrawText(*(item->iShowName), TPoint(x2, y));
}
y += iFontHeight;
gc.DrawText(*(item->iShowName), TPoint(x2, y));
gc.DiscardFont();
dy += iRowHeight;
}
}
void CBitmapAnimator::RenderMask(CBitmapContext& aBitmapContext, TInt aFrame) const
{
aBitmapContext.Reset();
const CAnimationFrame& nextFrame = *iFrameArray[aFrame];
if (aFrame == 0)
{
aBitmapContext.SetBrushColor(KRgbBlack);
aBitmapContext.Clear(iMaxSize);
}
else
{
const CAnimationFrame& currentFrame = *iFrameArray[aFrame - 1];
if (currentFrame.FrameInfo().iFlags & TFrameInfo::ERestoreToBackground)
{
aBitmapContext.SetBrushColor(KRgbBlack);
aBitmapContext.Clear(currentFrame.FrameInfo().iFrameCoordsInPixels);
}
}
const TBool useMask = nextFrame.FrameInfo().iFlags&TFrameInfo::ETransparencyPossible || nextFrame.FrameInfo().iFlags&TFrameInfo::EAlphaChannel;
if (useMask)
{
aBitmapContext.SetDrawMode(CGraphicsContext::EDrawModeOR);
aBitmapContext.BitBlt(nextFrame.FrameInfo().iFrameCoordsInPixels.iTl, nextFrame.Mask(), nextFrame.FrameInfo().iOverallSizeInPixels);
}
else
{
aBitmapContext.SetBrushColor(KRgbWhite);
if (nextFrame.FrameInfo().iOverallSizeInPixels != nextFrame.FrameInfo().iFrameSizeInPixels)
{
// If the frame size smaller than the overall size, the mask shall not take effect later in CBasicAnimation::Draw().
aBitmapContext.Clear(nextFrame.FrameInfo().iOverallSizeInPixels);
}
else
{
aBitmapContext.Clear(nextFrame.FrameInfo().iFrameCoordsInPixels);
}
}
}
TBool CAknAnimationData::ExecutePendingAnimationStep(CBitmapContext& aGc, TAnimMultiStep* aStep)
{
TBool done = EFalse;
switch (aStep->iDrawStep.Type())
{
case EAnimDrawLine:
{
TAnimLineDrawStep* step = (aStep->iDrawStep.LineDrawStep());
if (aStep->iSubStep == step->iSteps -1)
{
done = ETrue;
}
{
TInt diffX = step->iEndX - step->iStartX;
TInt diffY = step->iEndY - step->iStartY;
TInt startX = step->iStartX + (diffX * aStep->iSubStep / step->iSteps);
TInt startY = step->iStartY + (diffY * aStep->iSubStep / step->iSteps);
TInt endX = step->iStartX + (diffX * (aStep->iSubStep+1)/ step->iSteps);
TInt endY = step->iStartY + (diffY * (aStep->iSubStep+1) / step->iSteps);
aGc.SetBrushColor(iDrawColor);
aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
aGc.Clear(TRect(TPoint(startX,startY),TPoint(endX+1, endY+1)));
}
}
break;
case EAnimRevealPartNewViewFromLeft:
{
TAnimBlitStep* step = (aStep->iDrawStep.BlitStep());
TPoint offset((step->iWidth * aStep->iSubStep) / step->iSteps, 0);
TSize size((step->iWidth / step->iSteps)+1, step->iHeight);
aGc.BitBlt(TPoint(step->iDestX, step->iDestY) + offset, iViewBitmap,
TRect(TPoint(step->iSrcX, step->iSrcY) + offset, size));
if (aStep->iSubStep == step->iSteps-1)
done = ETrue;
}
break;
case EAnimRevealPartNewViewFromRight:
{
TAnimBlitStep* step = (aStep->iDrawStep.BlitStep());
TInt thisStep = (step->iSteps - aStep->iSubStep) - 1;
TPoint offset((step->iWidth * thisStep) / step->iSteps, 0);
TSize size((step->iWidth / step->iSteps)+1, step->iHeight);
aGc.BitBlt(TPoint(step->iDestX, step->iDestY) + offset, iViewBitmap,
TRect(TPoint(step->iSrcX, step->iSrcY) + offset, size));
if (aStep->iSubStep == step->iSteps-1)
done = ETrue;
}
break;
case EAnimRevealPartNewViewFromTop:
{
TAnimBlitStep* step = (aStep->iDrawStep.BlitStep());
TPoint offset(0,(step->iHeight * aStep->iSubStep) / step->iSteps);
TSize size(step->iWidth,(step->iHeight / step->iSteps)+1);
aGc.BitBlt(TPoint(step->iDestX, step->iDestY) + offset, iViewBitmap,
TRect(TPoint(step->iSrcX, step->iSrcY) + offset, size));
if (aStep->iSubStep == step->iSteps-1)
done = ETrue;
}
break;
case EAnimRevealPartNewViewFromBottom:
{
TAnimBlitStep* step = (aStep->iDrawStep.BlitStep());
TInt thisStep = (step->iSteps - aStep->iSubStep) - 1;
TPoint offset(0,(step->iHeight * thisStep) / step->iSteps);
TSize size(step->iWidth,(step->iHeight / step->iSteps)+1);
aGc.BitBlt(TPoint(step->iDestX, step->iDestY) + offset, iViewBitmap,
TRect(TPoint(step->iSrcX, step->iSrcY) + offset, size));
if (aStep->iSubStep == step->iSteps-1)
done = ETrue;
}
break;
case EAnimBlitSlideNewView:
// Slide the bitmap between two screen positions
{
TAnimSlideStep* step = (aStep->iDrawStep.SlideStep());
TSize bitmapSize(step->iWidth, step->iHeight);
TInt slideDifferenceX = step->iSlideToX - step->iSlideFromX;
TInt slideDifferenceY = step->iSlideToY - step->iSlideFromY;
TInt slidePosX = step->iSlideFromX + ((slideDifferenceX * aStep->iSubStep) / step->iSteps);
TInt slidePosY = step->iSlideFromY + ((slideDifferenceY * aStep->iSubStep) / step->iSteps);
aGc.BitBlt(TPoint(slidePosX, slidePosY), iViewBitmap,
TRect(TPoint(step->iSrcX, step->iSrcY), bitmapSize));
if (aStep->iSubStep == step->iSteps)
done = ETrue;
}
break;
case EAnimBlitSlideNewViewClearBehind:
// Slide the bitmap between two screen positions, clearing the screen behind it
{
TAnimSlideStep* step = (aStep->iDrawStep.SlideStep());
TSize bitmapSize(step->iWidth, step->iHeight);
TInt slideDifferenceX = step->iSlideToX - step->iSlideFromX;
TInt slideDifferenceY = step->iSlideToY - step->iSlideFromY;
if (aStep->iSubStep > 0)
{
// This is not the first step, so clear over the area of the previous step
TInt slidePosX = step->iSlideFromX + ((slideDifferenceX * (aStep->iSubStep-1)) / step->iSteps);
TInt slidePosY = step->iSlideFromY + ((slideDifferenceY * (aStep->iSubStep-1)) / step->iSteps);
aGc.Clear(TRect(TPoint(slidePosX, slidePosY), bitmapSize));
}
TInt slidePosX = step->iSlideFromX + ((slideDifferenceX * aStep->iSubStep) / step->iSteps);
TInt slidePosY = step->iSlideFromY + ((slideDifferenceY * aStep->iSubStep) / step->iSteps);
aGc.BitBlt(TPoint(slidePosX, slidePosY), iViewBitmap,
TRect(TPoint(step->iSrcX, step->iSrcY), bitmapSize));
if (aStep->iSubStep == step->iSteps)
done = ETrue;
}
break;
default:
done = DrawUserAnimationStep(aGc, *aStep);
break;
}
aStep->iSubStep++;
return done;
}
EXPORT_C TBool CAknAnimationData::DrawNextAnimationStep(CBitmapContext& aGc)
{
if (Count() == 0)
{
// Call the user animation step
TAnimStep step;
TAnimMultiStep nullStep(step);
nullStep.iDrawStep.SetType(EAnimNullStep);
nullStep.iSubStep = (TUint16)iCurrentDrawStep;
TBool done = DrawUserAnimationStep(aGc, nullStep);
iCurrentDrawStep++;
return done;
}
if (iCurrentDrawStep < Count())
{
TInt drawSteps = (*iDrawStepsPerAnimStep)[iCurrentAnimStep];
TInt startingDrawStep = iCurrentDrawStep;
TBool repeatAnimStep = EFalse;
for (TInt ii=0; ii<drawSteps; ii++)
{
TAnimStep* drawStep = &(At(iCurrentDrawStep));
switch (drawStep->Type())
{
case EAnimBlitPreviousView:
{
TAnimBlitStep* step = drawStep->BlitStep();
aGc.BitBlt(TPoint(step->iDestX, step->iDestY), iOldBitmap);
}
break;
case EAnimBlitNewView:
{
TAnimBlitStep* step = drawStep->BlitStep();
aGc.BitBlt(TPoint(step->iDestX, step->iDestY), iViewBitmap);
}
break;
case EAnimBlitPartPreviousView:
{
TAnimBlitStep* step = drawStep->BlitStep();
aGc.BitBlt(TPoint(step->iDestX, step->iDestY), iOldBitmap,
TRect(TPoint(step->iSrcX, step->iSrcY), TSize(step->iWidth, step->iHeight)));
}
break;
case EAnimBlitPartNewView:
{
TAnimBlitStep* step = drawStep->BlitStep();
aGc.BitBlt(TPoint(step->iDestX, step->iDestY), iViewBitmap,
TRect(TPoint(step->iSrcX, step->iSrcY), TSize(step->iWidth, step->iHeight)));
}
break;
case EAnimDrawLine:
case EAnimRevealPartNewViewFromLeft:
case EAnimRevealPartNewViewFromRight:
case EAnimRevealPartNewViewFromTop:
case EAnimRevealPartNewViewFromBottom:
case EAnimBlitSlideNewView:
case EAnimBlitSlideNewViewClearBehind:
{
// Make this a pending step. Cancel the animation if the append fails
TRAPD(err, iPendingSteps->AppendL(TAnimMultiStep(*drawStep)));
if (err != KErrNone)
return ETrue;
}
break;
case EAnimSetColor:
{
TAnimSetColorStep* step = drawStep->SetColorStep();
iDrawColor = TRgb(step->iRed, step->iGreen, step->iBlue);
}
break;
case EAnimDrawRect:
{
TAnimLineDrawStep* step = drawStep->LineDrawStep();
aGc.SetPenColor(iDrawColor);
aGc.SetPenStyle(CGraphicsContext::ESolidPen);
aGc.DrawRect(TRect(TPoint(step->iStartX, step->iStartY),TPoint(step->iEndX, step->iEndY)));
}
break;
case EAnimDrawFilledRect:
{
TAnimLineDrawStep* step = drawStep->LineDrawStep();
aGc.SetBrushColor(iDrawColor);
aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
aGc.SetPenStyle(CGraphicsContext::ENullPen);
aGc.DrawRect(TRect(TPoint(step->iStartX, step->iStartY),TPoint(step->iEndX, step->iEndY)));
}
break;
case EAnimWait:
{
TAnimWaitStep* step = drawStep->WaitStep();
repeatAnimStep = ETrue;
if (step->iSteps > 0)
{
step->iSteps--;
if (step->iSteps == 0)
repeatAnimStep = EFalse;
}
}
break;
case EAnimWaitUntilComplete:
if (iPendingSteps->Count())
repeatAnimStep = ETrue;
break;
default:
// Type is user-defined, so add to the pending steps
TRAPD(err, iPendingSteps->AppendL(TAnimMultiStep(*drawStep)));
if (err != KErrNone)
return ETrue;
break;
}
iCurrentDrawStep++;
}
// If this step needs to be repeated, reset the draw step counter
// otherwise increment the current animation step
if (repeatAnimStep)
{
iCurrentDrawStep = startingDrawStep;
}
else
{
iCurrentAnimStep++;
}
}
TInt done = DrawPendingAnimationSteps(aGc);
if (iCurrentDrawStep == Count() && done)
return ETrue;
return EFalse;
}
