CCBAnimationManager

#ifndef __CCB_CCBANIMATION_MANAGER_H__

#define __CCB_CCBANIMATION_MANAGER_H__

#include "cocos2d.h"

#include "ExtensionMacros.h"

#include "CCBSequence.h"

#include "CCBValue.h"

#include "CCBSequenceProperty.h"

NS_CC_EXT_BEGIN

class CCBAnimationManagerDelegate

{

public:

    virtual void completedAnimationSequenceNamed(const char *name) = 0;

};

class CCBAnimationManager : public CCObject

{

private:

    CCArray *mSequences;

    CCDictionary *mNodeSequences;

    CCDictionary *mBaseValues;

    int mAutoPlaySequenceId;

    CCNode *mRootNode;

    CCSize mRootContainerSize;

    CCBAnimationManagerDelegate *mDelegate;

    CCBSequence *mRunningSequence;

    CCArray *mDocumentOutletNames;

    CCArray *mDocumentOutletNodes;

    CCArray *mDocumentCallbackNames;

    CCArray *mDocumentCallbackNodes;

    CCArray *mKeyframeCallbacks;

    CCDictionary *mKeyframeCallFuncs;

    std::string mDocumentControllerName;

    std::string lastCompletedSequenceName;

    SEL_CallFunc mAnimationCompleteCallbackFunc;

    CCObject *mTarget;

public:

    bool jsControlled;

    CCBAnimationManager();

    ~CCBAnimationManager();

    CCObject *mOwner;

    virtual bool init();

    CCArray* getSequences();

    void setSequences(CCArray* seq);

    int getAutoPlaySequenceId();

    void setAutoPlaySequenceId(int autoPlaySequenceId);

    CCNode* getRootNode();

    void setRootNode(CCNode* pRootNode); // weak reference    

    void addDocumentCallbackNode(CCNode *node);

    void addDocumentCallbackName(std::string name);

    void addDocumentOutletNode(CCNode *node);

    void addDocumentOutletName(std::string name);

    void setDocumentControllerName(const std::string &name);

    std::string getDocumentControllerName();

    CCArray* getDocumentCallbackNames();

    CCArray* getDocumentCallbackNodes();

    CCArray* getDocumentOutletNames();

    CCArray* getDocumentOutletNodes();

    std::string getLastCompletedSequenceName();

    CCArray* getKeyframeCallbacks();

    const CCSize& getRootContainerSize();

    void setRootContainerSize(const CCSize &rootContainerSize);

    CCBAnimationManagerDelegate* getDelegate();

    void setDelegate(CCBAnimationManagerDelegate* pDelegate); // retain

    const char* getRunningSequenceName();

    const CCSize& getContainerSize(CCNode* pNode);

    void addNode(CCNode *pNode, CCDictionary *pSeq);

    void setBaseValue(CCObject *pValue, CCNode *pNode, const char *pPropName);

    void moveAnimationsFromNode(CCNode* fromNode, CCNode* toNode);

    /** @deprecated This interface will be deprecated sooner or later.*/

    CC_DEPRECATED_ATTRIBUTE void runAnimations(const char *pName, float fTweenDuration);

    /** @deprecated This interface will be deprecated sooner or later.*/

    CC_DEPRECATED_ATTRIBUTE void runAnimations(const char *pName);

    /** @deprecated This interface will be deprecated sooner or later.*/

    CC_DEPRECATED_ATTRIBUTE void runAnimations(int nSeqId, float fTweenDuraiton);

    void runAnimationsForSequenceNamedTweenDuration(const char *pName, float fTweenDuration);

    void runAnimationsForSequenceNamed(const char *pName);

    void runAnimationsForSequenceIdTweenDuration(int nSeqId, float fTweenDuraiton);

    void setAnimationCompletedCallback(CCObject *target, SEL_CallFunc callbackFunc);

    void debug();

    void setCallFunc(CCCallFunc *callFunc, const std::string &callbackNamed);

    CCObject* actionForCallbackChannel(CCBSequenceProperty* channel);

    CCObject* actionForSoundChannel(CCBSequenceProperty* channel);

private:

    CCObject* getBaseValue(CCNode *pNode, const char* pPropName);

    int getSequenceId(const char* pSequenceName);

    CCBSequence* getSequence(int nSequenceId);

    CCActionInterval* getAction(CCBKeyframe *pKeyframe0, CCBKeyframe *pKeyframe1, const char *pPropName, CCNode *pNode);

    void setAnimatedProperty(const char *pPropName, CCNode *pNode, CCObject *pValue, float fTweenDuraion);

    void setFirstFrame(CCNode *pNode, CCBSequenceProperty *pSeqProp, float fTweenDuration);

    CCActionInterval* getEaseAction(CCActionInterval *pAction, int nEasingType, float fEasingOpt);

    void runAction(CCNode *pNode, CCBSequenceProperty *pSeqProp, float fTweenDuration);

    void sequenceCompleted();

};

class CCBSetSpriteFrame : public CCActionInstant

{

private:

    CCSpriteFrame *mSpriteFrame;

public:

    ~CCBSetSpriteFrame();

    /** creates a Place action with a position */

    static CCBSetSpriteFrame* create(CCSpriteFrame *pSpriteFrame);

    bool initWithSpriteFrame(CCSpriteFrame *pSpriteFrame);

    virtual void update(float time);

    virtual CCObject* copyWithZone(CCZone *pZone);

};

class CCBSoundEffect : public CCActionInstant

{

private:

  std::string mSoundFile;

  float mPitch, mPan, mGain;

public:

    ~CCBSoundEffect();

    static CCBSoundEffect* actionWithSoundFile(const std::string &file, float pitch, float pan, float gain);

    bool initWithSoundFile(const std::string &file, float pitch, float pan, float gain);

    virtual void update(float time);

    virtual CCObject* copyWithZone(CCZone *pZone);

};

class CCBRotateTo : public CCActionInterval

{

private:

    float mStartAngle;

    float mDstAngle;

    float mDiffAngle;

public:

    static CCBRotateTo* create(float fDuration, float fAngle);

    bool initWithDuration(float fDuration, float fAngle);

    virtual void update(float time);

    virtual CCObject* copyWithZone(CCZone *pZone);

    virtual void startWithTarget(CCNode *pNode);

};

class CCBRotateXTo: public CCActionInterval {

private:

    float mStartAngle;

    float mDstAngle;

    float mDiffAngle;

public:

    static CCBRotateXTo* create(float fDuration, float fAngle);

    bool initWithDuration(float fDuration, float fAngle);

    virtual void startWithTarget(CCNode *pNode);

    virtual CCObject* copyWithZone(CCZone *pZone);

    virtual void update(float time);

};

class CCBRotateYTo: public CCActionInterval {

private:

    float mStartAngle;

    float mDstAngle;

    float mDiffAngle;

public:

    static CCBRotateYTo* create(float fDuration, float fAngle);

    bool initWithDuration(float fDuration, float fAngle);

    virtual void startWithTarget(CCNode *pNode);

    virtual CCObject* copyWithZone(CCZone *pZone);

    virtual void update(float time);

};

class CCBEaseInstant : public CCActionEase

{

public:

    static CCBEaseInstant* create(CCActionInterval *pAction);

    virtual void update(float dt);

};

NS_CC_EXT_END

#endif // __CCB_CCBANIMATION_MANAGER_H__