diff -r 000000000000 -r 2f259fa3e83a lafagnosticuifoundation/bmpanimation/src/bmpancli.cpp --- /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& 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 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& 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 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 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 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 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 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& 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 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)); + }