--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lafagnosticuifoundation/bmpanimation/src/bmpancli.cpp	Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,770 @@
+// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include "bmpansrv.h"	// for the structures definition used for the packaging
+#include "bmpanpan.h"	// for panics
+
+
+const TInt KFrameDataArrayGranularity = 5;
+const TInt KDefaultFrameIntervalInMilliSeconds = 0;
+
+
+/**
+ class CBitmapFrameData
+*/
+
+CBitmapFrameData::CBitmapFrameData() 
+	: iBitmapsOwnedExternally(EFalse)
+	{
+	}
+
+
+/**
+ Destructor.
+
+It deletes the bitmap and mask objects owned by the frame unless the "owned 
+externally" (SetBitmapsOwnedExternally()) flag is set. 
+*/
+EXPORT_C CBitmapFrameData::~CBitmapFrameData()
+
+	{
+	if(!iBitmapsOwnedExternally)
+		{
+		if(iMaskBitmap != iBitmap)
+			{
+			delete iMaskBitmap;
+			}
+
+		delete iBitmap;
+		}
+	}
+
+
+
+/**
+ Creates a new empty frame object.
+
+@return New CBitmapFrameData object 
+*/
+EXPORT_C CBitmapFrameData* CBitmapFrameData::NewL()
+	{
+	CBitmapFrameData* self = new (ELeave) CBitmapFrameData();
+	return self;
+	}
+
+
+
+/**
+ Creates a new frame object with a specified bitmap and (optionally) a mask. 
+
+The object takes ownership of the specified bitmap and mask.
+
+@param aBitmap A pointer to the bitmap to use in the new frame
+@param aMask If non-NULL, a pointer to the mask to use in the new frame
+@return New CBitmapFrameData object 
+*/
+EXPORT_C CBitmapFrameData* CBitmapFrameData::NewL(CFbsBitmap* aBitmap,CFbsBitmap* aMask)
+	{
+	__ASSERT_DEBUG(aBitmap, Panic(EAnimationClientPanicNullPointer));
+
+	CBitmapFrameData* self = NewL();
+	CleanupStack::PushL(self);	// 
+	self->SetBitmap(aBitmap);
+	self->SetMask(aMask);
+	CleanupStack::Pop();	// self
+
+	return self;
+	}
+
+
+
+/**
+ Creates a new frame object.
+
+It takes ownership of the specified bitmap and mask (if specified), and 
+is assigned the frame duration and position.
+
+@param aBitmap A pointer to the bitmap to use in the frame. 
+@param aMask If non-NULL, a pointer to the mask to use in the frame. 
+@param aIntervalInMilliSeconds The frame's duration in milliseconds. 
+@param aPosition The frame's position relative to the animation window. 
+@return New CBitmapFrameData object 
+*/
+EXPORT_C CBitmapFrameData* CBitmapFrameData::NewL(CFbsBitmap* aBitmap,CFbsBitmap* aMask, TInt aIntervalInMilliSeconds, TPoint aPosition)
+	{
+	__ASSERT_DEBUG(aBitmap, Panic(EAnimationClientPanicNullPointer));
+
+	CBitmapFrameData* self = NewL();
+	CleanupStack::PushL(self);	// 
+	self->SetBitmap(aBitmap);
+	self->SetMask(aMask);
+	self->SetPosition(aPosition);
+	self->SetInterval(aIntervalInMilliSeconds);
+	CleanupStack::Pop();	// self
+
+	return self;
+	}
+
+
+/**
+ Sets the frame bitmap.
+
+Unless the "owned externally" (SetBitmapsOwnedExternally()) flag is set, it 
+deletes any existing frame bitmap and takes ownership of the new bitmap.
+
+@param aBitmap The frame bitmap 
+*/
+EXPORT_C void CBitmapFrameData::SetBitmap(CFbsBitmap* aBitmap)
+	{
+	__ASSERT_DEBUG(aBitmap, Panic(EAnimationClientPanicNullPointer));
+
+	if(!iBitmapsOwnedExternally && iBitmap != iMaskBitmap)
+		{
+		delete iBitmap;
+		}
+
+	iBitmap = aBitmap;
+	}
+
+
+
+/**
+ Gets the frame's bitmap. 
+
+This does not affect ownership of the bitmap.
+
+@return The frame's bitmap 
+*/
+EXPORT_C CFbsBitmap* CBitmapFrameData::Bitmap() const
+	{
+	return iBitmap;
+	}
+
+
+
+/**
+ Sets the frame mask.
+
+Unless the "owned externally" (SetBitmapsOwnedExternally()) flag is set, it 
+deletes any existing mask bitmap and takes ownership of the new bitmap.
+
+@param aMask Mask to use in the frame 
+*/
+EXPORT_C void CBitmapFrameData::SetMask(CFbsBitmap* aMask)
+	{
+	if(!iBitmapsOwnedExternally && iBitmap != iMaskBitmap)
+		{
+		delete iMaskBitmap;
+		}
+
+	iMaskBitmap = aMask;
+	}
+
+
+
+/**
+ Gets the frame's mask. 
+
+This does not affect ownership of the bitmap.
+
+@return The frame's mask 
+*/
+EXPORT_C CFbsBitmap* CBitmapFrameData::Mask() const
+	{
+	return iMaskBitmap;
+	}
+
+
+
+/**
+ Sets the frame's duration in milliseconds. 
+
+You can alternatively set the interval for a complete animation using CBitmapAnimClientData::SetFrameInterval(). 
+However, an interval set for an individual frame overrides any interval set 
+at the animation level.
+
+@param aIntervalInMilliSeconds The number of milliseconds to display the frame 
+*/
+EXPORT_C void CBitmapFrameData::SetInterval(TInt aIntervalInMilliSeconds)
+	{
+	iIntervalInMilliSeconds = aIntervalInMilliSeconds;
+	}
+
+
+
+/**
+ Gets the frame's duration in milliseconds.
+
+@return The number of milliseconds for which the frame is displayed 
+*/
+EXPORT_C TInt CBitmapFrameData::IntervalInMilliSeconds() const
+	{
+	return iIntervalInMilliSeconds;
+	}
+
+
+
+/**
+ Sets the frame's position relative to the animation window.
+
+@param aPosition The frame's position relative to the animation window 
+*/
+EXPORT_C void CBitmapFrameData::SetPosition(TPoint aPosition)
+	{
+	iPosition = aPosition;
+	}
+
+
+
+/**
+ Gets the frame's position, relative to the animation window.
+
+@return The frame's position, relative to the animation window. 
+*/
+EXPORT_C TPoint CBitmapFrameData::Position() const
+	{
+	return iPosition;
+	}
+
+
+
+/**
+ Sets whether the bitmap and mask are owned by the frame.
+
+@param aOwnedExternally If ETrue, the bitmap and mask are specified as being 
+owned externally and the CBitmapFrameData destructor is NOT responsible for destroying the bitmap.
+If EFalse, the CBitmapFrameData destructor is responsible for destroying the bitmap.
+*/
+EXPORT_C void CBitmapFrameData::SetBitmapsOwnedExternally(TBool aOwnedExternally)
+	{
+	iBitmapsOwnedExternally = aOwnedExternally ? ETrue : EFalse;
+	}
+
+
+
+/**
+ Tests whether the frame owns the bitmap and mask.
+
+@return ETrue if the bitmap is owned externally, EFalse  otherwise. 
+*/
+EXPORT_C TBool CBitmapFrameData::BitmapsOwnedExternally() const
+	{
+	return iBitmapsOwnedExternally;
+	}
+
+
+
+
+/**
+ class CBitmapAnimClientData
+*/
+CBitmapAnimClientData::CBitmapAnimClientData() :
+	iFlash(EFalse),
+	iPlayMode(EPlay),
+	iFrameIntervalInMilliSeconds(KDefaultFrameIntervalInMilliSeconds),
+	iFrameArray(KFrameDataArrayGranularity)
+	{
+	}
+
+
+
+/**
+ Destructor.
+
+ It deletes the background frame and destroys the contents of the frame array. 
+*/
+EXPORT_C CBitmapAnimClientData::~CBitmapAnimClientData()
+	{
+	delete iBackgroundFrame;
+	iFrameArray.ResetAndDestroy();
+	}
+
+
+
+/**
+ Allocates and constructs a new CBitmapAnimClientData object.
+
+@return New CBitmapAnimClientData object 
+*/
+EXPORT_C CBitmapAnimClientData* CBitmapAnimClientData::NewL()
+	{
+	CBitmapAnimClientData* self = new (ELeave) CBitmapAnimClientData;
+	return self;
+	}
+
+
+
+/**
+ Appends a new frame to the array of frames. 
+
+The array takes ownership of the new frame.
+
+@param aFrame A pointer to the frame to add to the array of frames 
+*/
+EXPORT_C void CBitmapAnimClientData::AppendFrameL(CBitmapFrameData* aFrame)
+	{
+	iFrameArray.AppendL(aFrame);
+	}
+
+
+
+/**
+ Gets the animation frame array.
+
+@return Animation frame array 
+*/
+EXPORT_C const CArrayPtrFlat<CBitmapFrameData>& CBitmapAnimClientData::FrameArray() const
+	{
+
+	return iFrameArray;
+	}
+
+
+
+/**
+ Resets and destroys the frame array's contents. 
+*/
+EXPORT_C void CBitmapAnimClientData::ResetFrameArray()
+	{
+	iFrameArray.ResetAndDestroy();
+	}
+
+
+
+/**
+ Sets the background frame and takes ownership of it.
+
+Any previous background frame, and mask if one is included, is deleted from 
+memory. The frame is redrawn in the animation window in order to clear the 
+current frame before drawing the next one.
+
+@param aBackgroundFrame The bitmap to use as the background frame 
+*/
+EXPORT_C void CBitmapAnimClientData::SetBackgroundFrame(CBitmapFrameData* aBackgroundFrame)
+	{
+
+	if(iBackgroundFrame)
+		{
+		delete iBackgroundFrame;
+		}
+
+	iBackgroundFrame = aBackgroundFrame;
+	}
+
+
+
+/**
+ Gets the background frame bitmap.
+
+@return Background frame bitmap 
+*/
+EXPORT_C CBitmapFrameData* CBitmapAnimClientData::BackgroundFrame() const
+	{
+	return iBackgroundFrame;
+	}
+
+
+
+/**
+ Sets or unsets the animation's flash state.
+
+@param aFlash ETrue for the animation to flash, otherwise EFalse 
+*/
+EXPORT_C void CBitmapAnimClientData::SetFlash(TBool aFlash)
+	{
+	iFlash = aFlash;
+	}
+
+
+
+/**
+ Gets the animation's flash setting.
+
+@return ETrue if the animation is flashing, otherwise EFalse 
+*/
+EXPORT_C TBool CBitmapAnimClientData::Flash() const
+	{
+	return iFlash;
+	}
+
+
+
+/**
+ Specifies for how many milliseconds each frame in the animation is displayed. 
+
+This is not used for any frames in the animation that specify their own interval.
+
+@param aFrameIntervalInMilliSeconds The number of milliseconds for which each 
+frame in the animation is displayed 
+*/
+EXPORT_C void CBitmapAnimClientData::SetFrameInterval(TInt aFrameIntervalInMilliSeconds)
+	{
+	__ASSERT_DEBUG(aFrameIntervalInMilliSeconds >= 0, Panic(EAnimationClientPanicFrameIntervalNegative));
+	iFrameIntervalInMilliSeconds = aFrameIntervalInMilliSeconds;
+	}
+
+
+
+/**
+ Gets the default animation frame interval in milliseconds.
+
+@return Default animation frame interval in milliseconds 
+*/
+EXPORT_C TInt CBitmapAnimClientData::FrameIntervalInMilliSeconds() const
+	{
+	return iFrameIntervalInMilliSeconds;
+	}
+
+
+
+/**
+ Sets the play mode so that the animation plays once or continuously.
+
+@param aPlayMode The animation play mode 
+*/
+EXPORT_C void CBitmapAnimClientData::SetPlayMode(TPlayMode aPlayMode)
+	{
+	iPlayMode = aPlayMode;
+	}
+
+
+
+/**
+ Gets the animation's play mode.
+
+@return Animation's play mode 
+*/
+EXPORT_C CBitmapAnimClientData::TPlayMode CBitmapAnimClientData::PlayMode() const
+	{
+	return iPlayMode;
+	}
+
+
+
+/**
+ Gets the display size required to show the entire animation.
+
+@return Display size 
+*/
+EXPORT_C TSize CBitmapAnimClientData::Size() const
+	{
+	TSize size;
+	TSize frameSize;
+	const TInt count = iFrameArray.Count();
+	CBitmapFrameData* frame;
+	CFbsBitmap* bitmap;
+
+	TInt index = 0;
+
+	for (index=0; index < count; index++)
+		{
+		frame = iFrameArray.At(index);
+		bitmap = frame->Bitmap();
+		if (bitmap)
+			{
+			frameSize = frame->Bitmap()->SizeInPixels() + frame->Position().AsSize();
+			}
+
+		size.iHeight = Max(size.iHeight, frameSize.iHeight);
+		size.iWidth = Max(size.iWidth, frameSize.iWidth);
+		}
+	// for the background frame
+	if (iBackgroundFrame && iBackgroundFrame->Bitmap())
+		{
+		frameSize = iBackgroundFrame->Bitmap()->SizeInPixels() + iBackgroundFrame->Position().AsSize();
+		size.iHeight = Max(size.iHeight, frameSize.iHeight);
+		size.iWidth = Max(size.iWidth, frameSize.iWidth);
+		}
+
+	return size;
+	}
+
+
+
+
+/**
+ Gets the time required to display the entire sequence of frames that comprise 
+the animation. 
+
+This time is expressed in milliseconds.
+
+@return Animation duration 
+*/
+EXPORT_C TInt CBitmapAnimClientData::DurationInMilliSeconds() const
+	{
+	TInt time = 0;
+	TInt frameInterval;
+	const TInt count = iFrameArray.Count();
+
+	TInt index = 0;
+
+	for (index = 0; index < count; index++)
+		{
+		frameInterval = iFrameArray.At(index)->IntervalInMilliSeconds();
+
+		if (frameInterval < 0)
+			{
+			frameInterval = ((iFrameIntervalInMilliSeconds > 0) ? iFrameIntervalInMilliSeconds : KDefaultFrameIntervalInMilliSeconds);
+			}
+
+		time += frameInterval;
+		}
+
+	return time;
+	}
+
+
+
+/**
+ class RBitmapAnim
+*/
+
+/**
+ Constructor.
+
+@param aAnimDll A reference to the DLL that runs the animation 
+*/
+EXPORT_C RBitmapAnim::RBitmapAnim(RAnimDll& aAnimDll)
+	:RAnim(aAnimDll)
+	{
+	}
+
+
+
+/**
+ Completes construction of an animation object. 
+
+This must be done after calling RBitmapAnim(), and before an application attempts 
+any other communication with the server.
+
+@param aWindow A reference to the container control window that will hold 
+the animation. 
+*/
+EXPORT_C void RBitmapAnim::ConstructL(const RWindowBase& aDevice)
+	{
+	TPtrC8 des(NULL,0);
+	User::LeaveIfError(RAnim::Construct(aDevice, 0, des));
+	}
+
+
+
+/**
+ Sets the animation frame to display.
+
+How it appears depends on whether the animation is already running. If the 
+animation is running, the animation jumps to the specified frame, then 
+continues playing. If the animation is not running, the animation is played, 
+starting with the specified frame
+
+@param aIndex The frame to display. 
+*/
+EXPORT_C void RBitmapAnim::DisplayFrameL(TInt aIndex)
+	{
+	TPckgBuf<SBitmapAnimIndexFrame> bitmapAnimIndexFrame;
+	bitmapAnimIndexFrame().iIndex = aIndex;
+	User::LeaveIfError(CommandReply(EBitmapAnimCommandSetFrameIndex, bitmapAnimIndexFrame));
+	}
+
+
+
+
+/**
+ Specifies the animation object to play and sends it to the animation server.
+
+To start the animation, you must subsequently call StartL().
+Calling this method while an animation is running will stop the animation.
+
+@param aBitmapAnimData The animation object to play 
+*/
+EXPORT_C void RBitmapAnim::SetBitmapAnimDataL(const CBitmapAnimClientData& aBitmapAnimData)
+	{
+	SetAttributesL(aBitmapAnimData);
+
+	const CArrayPtrFlat<CBitmapFrameData>& frameArray = aBitmapAnimData.FrameArray();
+	SetFrameArrayL(frameArray);
+
+	CBitmapFrameData* frameData = aBitmapAnimData.BackgroundFrame();
+	
+	if (frameData)
+		{
+		SetBackgroundFrameL(*frameData);
+		}
+	}
+
+
+
+/**
+ Sets or unsets the animation to be drawn flashing.
+
+@param aFlash ETrue to draw the animation flashing, otherwise EFalse. 
+*/
+EXPORT_C void RBitmapAnim::SetFlashL(TBool aFlash)
+	{
+	TPckgBuf<TBmpAnimAttributes> bitmapAnimFlash;
+	bitmapAnimFlash().iFlash = aFlash;
+	User::LeaveIfError(CommandReply(EBitmapAnimCommandSetFlash, bitmapAnimFlash));
+	}
+
+
+
+/**
+ Specifies the number of milliseconds for which each frame in the animation 
+is displayed. 
+
+This is not used for any frames in the animation that specify their own interval.
+
+@param aFrameIntervalInMilliSeconds The number of milliseconds for which each 
+frame in the animation is displayed 
+*/
+EXPORT_C void RBitmapAnim::SetFrameIntervalL(TInt aFrameIntervalInMilliSeconds)
+	{
+	__ASSERT_DEBUG(aFrameIntervalInMilliSeconds >= 0, Panic(EAnimationClientPanicFrameIntervalNegative));
+	TPckgBuf<TBmpAnimAttributes> bitmapAnimFrameInterval;
+	bitmapAnimFrameInterval().iFrameIntervalInMilliSeconds = aFrameIntervalInMilliSeconds;
+	User::LeaveIfError(CommandReply(EBitmapAnimCommandSetFrameInterval, bitmapAnimFrameInterval));
+	}
+
+
+
+/**
+ Sets how many times the animation is played. 
+
+If the play mode is CBitmapAnimClientData::EBounce, the number of cycles must 
+be at least two to ensure a complete animation routine is played.
+
+@param aNumberOfCycles The number of times to play the animation. 
+*/
+EXPORT_C void RBitmapAnim::SetNumberOfCyclesL(TInt aNumberOfCycles)
+	{
+	TPckgBuf<SBitmapAnimNumberOfCycles> bitmapAnimNumberOfCycles;
+	bitmapAnimNumberOfCycles().iCycles = aNumberOfCycles;
+	User::LeaveIfError(CommandReply(EBitmapAnimCommandSetNumberOfCycles, bitmapAnimNumberOfCycles));
+	}
+
+
+
+/**
+ Sets the current animation's play mode.
+
+@param aPlayMode The animation's play mode. 
+*/
+EXPORT_C void RBitmapAnim::SetPlayModeL(CBitmapAnimClientData::TPlayMode aPlayMode)
+	{
+	TPckgBuf<TBmpAnimAttributes> bitmapAnimPlayMode;
+	bitmapAnimPlayMode().iPlayMode = aPlayMode;
+	User::LeaveIfError(CommandReply(EBitmapAnimCommandSetPlayMode, bitmapAnimPlayMode));
+	}
+
+
+
+/**
+ Sets the animation's position relative to the animation window.
+
+@param aPosition The animation's position relative to the animation window 
+*/
+EXPORT_C void RBitmapAnim::SetPositionL(const TPoint aPosition)
+	{
+	TPckgBuf<SBitmapAnimNewPosition> bitmapAnimNewPosition;
+	bitmapAnimNewPosition().iPosition = aPosition;
+	User::LeaveIfError(CommandReply(EBitmapAnimCommandSetPosition, bitmapAnimNewPosition));
+	}
+
+
+
+/** 
+ Starts the animation. 
+
+You must first specify an animation with SetBitmapAnimDataL().
+
+If you have specified CBitmapAnimClientData::ECycle or CBitmapAnimClientData::EBounce 
+as the animation's play mode, but have not specified the number of cycles 
+using SetNumberOfCyclesL(), you must call StopL() to stop the animation. 
+*/
+EXPORT_C void RBitmapAnim::StartL()
+	{
+	User::LeaveIfError(CommandReply(EBitmapAnimCommandStartAnimation));
+	}
+
+
+
+/** 
+ Stops the animation. 
+*/
+EXPORT_C void RBitmapAnim::StopL()
+	{
+	User::LeaveIfError(CommandReply(EBitmapAnimCommandStopAnimation));
+	}
+
+
+
+/** 
+ Sets the general attributes of the animation. 
+*/
+void RBitmapAnim::SetAttributesL(const CBitmapAnimClientData& aBitmapAnimData)
+	{
+	SetFlashL(aBitmapAnimData.Flash());
+	SetFrameIntervalL(aBitmapAnimData.FrameIntervalInMilliSeconds());
+	SetPlayModeL(aBitmapAnimData.PlayMode());
+	}
+
+
+/**
+ Sets the animation frames to the player.
+*/
+void RBitmapAnim::SetFrameArrayL(const CArrayPtrFlat<CBitmapFrameData>& aFrameArray)
+	{
+	const TInt count = aFrameArray.Count();
+
+	if (count > 0)
+		{
+		User::LeaveIfError(CommandReply(EBitmapAnimCommandResetFrameArray));
+		CBitmapFrameData* frameData;
+		User::LeaveIfError(CommandReply(EBitmapAnimCommandClearDataFrames));
+
+		TInt index = 0;
+
+		for (index = 0; index < count; index++)
+			{
+			frameData = aFrameArray.At(index);
+			SetFrameL(*frameData, EBitmapAnimCommandSetDataFrame);
+			}
+		}
+	}
+
+
+
+/**
+ Sets the background frame, aFrameData, to the player.
+*/
+void RBitmapAnim::SetBackgroundFrameL(const CBitmapFrameData& aFrameData)
+	{
+	SetFrameL(aFrameData, EBitmapAnimCommandSetBackgroundFrame);
+	}
+
+
+/**
+ Extracts data from aFrameData, packs them and then it sends this package to the player
+*/
+void RBitmapAnim::SetFrameL(const CBitmapFrameData& aFrameData, TInt aOpCode)
+	{
+	TPckgBuf<TFrameData> dataFrameArg;
+	CFbsBitmap* bitmap = aFrameData.Bitmap();
+	dataFrameArg().iBitmapHandle=( (bitmap) ? bitmap->Handle() : 0 );
+	CFbsBitmap* mask = aFrameData.Mask();
+	dataFrameArg().iMaskBitmapHandle=( (mask) ? mask->Handle() : 0 );
+	dataFrameArg().iIntervalInMilliSeconds=aFrameData.IntervalInMilliSeconds();
+	dataFrameArg().iPosition=aFrameData.Position();
+	User::LeaveIfError(CommandReply(aOpCode, dataFrameArg));
+	}