--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uifw/AvKon/src/aknAnimData.cpp	Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,543 @@
+/*
+* Copyright (c) 2002 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:  Anim Data
+*
+*/
+
+// AknAnimData.CPP
+//
+// Copyright (c) 1997-1999 Symbian Ltd.  All rights reserved.
+//
+
+// Animation Data class
+
+
+#include "aknanimdata.h"
+#include "aknanim.hrh"
+#include "AknPanic.h"
+#include <barsread.h>
+#include <eikenv.h>
+
+
+const TInt KAnimStepGranularity=5;
+
+
+
+EXPORT_C CAknAnimationData::CAknAnimationData()
+:CArrayFixFlat<TAnimStep>(KAnimStepGranularity)
+	{
+	}
+
+EXPORT_C CAknAnimationData::~CAknAnimationData()
+	{
+	delete iDrawStepsPerAnimStep;
+	delete iPendingSteps;
+	}
+
+
+EXPORT_C void CAknAnimationData::ConstructL()
+	{
+	if (!iPendingSteps)
+		{
+		iPendingSteps = new(ELeave)CArrayFixFlat<TAnimMultiStep>(KAnimStepGranularity);
+		}
+	if (!iDrawStepsPerAnimStep)
+		{
+		iDrawStepsPerAnimStep = new(ELeave)CArrayFixFlat<TUint8>(KAnimStepGranularity);
+		}
+	}
+
+
+EXPORT_C void CAknAnimationData::ConstructFromResourceL(TInt aResourceId)
+	{
+	ConstructL();
+	TResourceReader reader;	
+	CEikonEnv::Static()->CreateResourceReaderLC(reader, aResourceId);
+
+	iFlags = (TUint16)reader.ReadInt16();
+	iInterval = reader.ReadInt32();
+	TInt sections = reader.ReadInt16();
+	TResourceReader sectionReader;
+	for (TInt sectionCount=0; sectionCount<sections; sectionCount++)
+		{
+		CEikonEnv::Static()->CreateResourceReaderLC(sectionReader, reader.ReadInt32());		
+		TInt animSteps = sectionReader.ReadInt16();
+		for (TInt stepCount=0; stepCount<animSteps; stepCount++)
+			{
+			ReadAnimStepL(sectionReader);
+			}
+		CleanupStack::PopAndDestroy();	//sectionReader
+		if (WaitBetweenSections())
+			{
+			// Append a wait step between each loaded section
+			TAnimStep drawStep;
+			drawStep.SetType(EAnimWaitUntilComplete);
+			AppendL(drawStep);
+			iDrawStepsPerAnimStep->AppendL(1);
+			}
+		}
+	if (WaitForeverAtEnd())
+		{
+		// Append a wait-forever step at end of animation
+		// (Wait-forever is set by a wait step with zero steps)
+		TAnimStep drawStep;
+		drawStep.SetType(EAnimWait);
+		(drawStep.WaitStep())->iSteps = 0;
+		AppendL(drawStep);
+		iDrawStepsPerAnimStep->AppendL(1);
+		}
+
+	CleanupStack::PopAndDestroy();	//reader
+	}
+
+void CAknAnimationData::ReadAnimStepL(TResourceReader& aReader)
+	{
+	TInt drawSteps = aReader.ReadInt16();
+	iDrawStepsPerAnimStep->AppendL((TUint8)drawSteps);
+	for (TInt stepCount=0; stepCount<drawSteps; stepCount++)
+		{
+		TAnimStep drawStep;
+		TUint8 type = (TUint8)aReader.ReadInt8();
+		drawStep.SetType(type);
+		switch(type)
+			{
+			case EAnimBlitPreviousView:
+			case EAnimBlitNewView:
+				{
+				TAnimBlitStep* step = drawStep.BlitStep();
+				step->iDestX = (TInt16)aReader.ReadInt16();
+				step->iDestY = (TInt16)aReader.ReadInt16();
+				}
+				break;
+			case EAnimBlitPartPreviousView:
+				{
+				TAnimBlitStep* step = drawStep.BlitStep();
+				step->iSrcX = (TInt16)aReader.ReadInt16();
+				step->iSrcY = (TInt16)aReader.ReadInt16();
+				step->iWidth = (TUint16)aReader.ReadInt16();
+				step->iHeight = (TUint16)aReader.ReadInt16();
+				step->iDestX = (TInt16)aReader.ReadInt16();
+				step->iDestY = (TInt16)aReader.ReadInt16();
+				}
+			case EAnimBlitPartNewView:
+			case EAnimRevealPartNewViewFromLeft:
+			case EAnimRevealPartNewViewFromRight:
+			case EAnimRevealPartNewViewFromTop:
+			case EAnimRevealPartNewViewFromBottom:
+				{
+				TAnimBlitStep* step = drawStep.BlitStep();
+				step->iSteps = (TUint16)aReader.ReadInt16();
+				step->iSrcX = (TInt16)aReader.ReadInt16();
+				step->iSrcY = (TInt16)aReader.ReadInt16();
+				step->iWidth = (TUint16)aReader.ReadInt16();
+				step->iHeight = (TUint16)aReader.ReadInt16();
+				step->iDestX = (TInt16)aReader.ReadInt16();
+				step->iDestY = (TInt16)aReader.ReadInt16();
+				if (step->iDestX == -32760) step->iDestX = step->iSrcX;
+				if (step->iDestY == -32760) step->iDestY = step->iSrcY;
+				}
+				break;
+			case EAnimBlitSlideNewView:
+			case EAnimBlitSlideNewViewClearBehind:
+				{
+				TAnimSlideStep* step = drawStep.SlideStep();
+				step->iSteps = (TUint16)aReader.ReadInt16();
+				step->iSrcX = (TInt16)aReader.ReadInt16();
+				step->iSrcY = (TInt16)aReader.ReadInt16();
+				step->iWidth = (TUint16)aReader.ReadInt16();
+				step->iHeight = (TUint16)aReader.ReadInt16();
+				step->iSlideToX = (TInt16)aReader.ReadInt16();
+				step->iSlideToY = (TInt16)aReader.ReadInt16();
+				step->iSlideFromX = (TInt16)aReader.ReadInt16();
+				step->iSlideFromY = (TInt16)aReader.ReadInt16();
+				}
+				break;
+			case EAnimWait:
+				{
+				TAnimWaitStep* step = drawStep.WaitStep();
+				step->iSteps = (TUint16)aReader.ReadInt16();
+				}
+				break;
+			case EAnimSetColor:
+				{
+				TAnimSetColorStep* step = drawStep.SetColorStep();
+				step->iRed = (TUint8)aReader.ReadUint8();
+				step->iGreen = (TUint8)aReader.ReadUint8();
+				step->iBlue = (TUint8)aReader.ReadUint8();
+				}
+				break;
+			case EAnimDrawLine:
+			case EAnimDrawRect:
+			case EAnimDrawFilledRect:
+				{
+				TAnimLineDrawStep* step = drawStep.LineDrawStep();
+				step->iSteps = (TUint16)aReader.ReadInt16();
+				step->iStartX = (TInt16)aReader.ReadInt16();
+				step->iStartY = (TInt16)aReader.ReadInt16();
+				step->iEndX = (TInt16)aReader.ReadInt16();
+				step->iEndY = (TInt16)aReader.ReadInt16();
+				}
+				break;
+			case EAnimWaitUntilComplete:
+				// No parameters to be read
+				break;
+			default:
+				ConstructUserAnimationStepL(drawStep, aReader);
+				break;
+			}
+		AppendL(drawStep);
+		}
+	}
+
+EXPORT_C void CAknAnimationData::ConstructUserAnimationStepL(TAnimStep& /*aAnimStep*/, TResourceReader& /*aReader*/)
+	{
+	Panic(EAknPanicUnknownAnimationType);
+	}
+
+
+
+EXPORT_C TBool CAknAnimationData::DrawUserAnimationStep(CBitmapContext& /*aGc*/, TAnimMultiStep& /*aAnimStep*/)
+	{
+	Panic(EAknPanicNoUserAnimation);
+	return ETrue;
+	}
+
+
+EXPORT_C void CAknAnimationData::SetScreenSize(TSize aSize)
+	{
+	iScreenSize = aSize;
+	}
+
+EXPORT_C void CAknAnimationData::SetViewBitmap(CFbsBitmap* aViewBitmap)
+	{
+	iViewBitmap = aViewBitmap;
+	}
+
+EXPORT_C void CAknAnimationData::SetOldBitmap(CFbsBitmap* aOldBitmap)
+	{
+	iOldBitmap = aOldBitmap;
+	}
+
+
+EXPORT_C void CAknAnimationData::SetClearOldView()
+	{
+	iFlags |= EAnimClearScreen;
+	}
+
+EXPORT_C TBool CAknAnimationData::ClearOldView()
+	{
+	return iFlags & EAnimClearScreen;
+	}
+
+EXPORT_C TBool CAknAnimationData::WaitBetweenSections()
+	{
+	return iFlags & EAnimWaitBetweenSections;
+	}
+
+
+EXPORT_C void CAknAnimationData::SetWaitForeverAtEnd()
+	{
+	iFlags |= EAnimClearScreen;	
+	}
+
+EXPORT_C TBool CAknAnimationData::WaitForeverAtEnd()
+	{
+	return iFlags & EAnimWaitForeverAtEnd;
+	}
+
+EXPORT_C TInt CAknAnimationData::Interval()
+	{
+	return iInterval;
+	}
+
+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;
+	}
+
+
+TBool CAknAnimationData::DrawPendingAnimationSteps(CBitmapContext& aGc)
+	{
+	TBool finished = ETrue;
+	TInt count = iPendingSteps->Count();
+	for (TInt ii=0; ii<count; ii++)
+		{
+		TAnimMultiStep* drawStep = &(*iPendingSteps)[ii];
+		TBool done = ExecutePendingAnimationStep(aGc, drawStep);
+		if (!done)
+			{
+			finished = EFalse;
+			}
+		else
+			{
+			// Remove step from pending list
+			iPendingSteps->Delete(ii);
+			ii--;
+			count--;
+			}
+		}
+	return finished;
+	}
+
+
+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;
+	}
+
+// End of File