AnimationInstance.h

/***********************************************************************
    created:    7/8/2010
    author:     Martin Preisler

    purpose:    Defines the interface for the AnimationInstance class
*************************************************************************/
/***************************************************************************
 *   Copyright (C) 2004 - 2010 Paul D Turner & The CEGUI Development Team
 *
 *   Permission is hereby granted, free of charge, to any person obtaining
 *   a copy of this software and associated documentation files (the
 *   "Software"), to deal in the Software without restriction, including
 *   without limitation the rights to use, copy, modify, merge, publish,
 *   distribute, sublicense, and/or sell copies of the Software, and to
 *   permit persons to whom the Software is furnished to do so, subject to
 *   the following conditions:
 *
 *   The above copyright notice and this permission notice shall be
 *   included in all copies or substantial portions of the Software.
 *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *   OTHER DEALINGS IN THE SOFTWARE.
 ***************************************************************************/
#ifndef _CEGUIAnimationInstance_h_
#define _CEGUIAnimationInstance_h_

#include "CEGUI/EventArgs.h"
#include "CEGUI/Event.h"
#include <map>
#include <vector>

#if defined(_MSC_VER)
#   pragma warning(push)
#   pragma warning(disable : 4251)
#endif

// Start of CEGUI namespace section
namespace CEGUI
{

class CEGUIEXPORT AnimationEventArgs : public EventArgs
{
public:
    AnimationEventArgs(AnimationInstance* inst) : instance(inst) {}
    AnimationInstance* instance;
};

class CEGUIEXPORT AnimationInstance :
    public AllocatedObject<AnimationInstance>
{
public:
    static const String EventNamespace;

    static const String EventAnimationStarted;
    static const String EventAnimationStopped;
    static const String EventAnimationPaused;
    static const String EventAnimationUnpaused;
    static const String EventAnimationEnded;
    static const String EventAnimationLooped;

    AnimationInstance(Animation* definition);

    ~AnimationInstance(void);

    Animation* getDefinition() const;

    void setTarget(PropertySet* target);

    PropertySet* getTarget() const;

    void setEventReceiver(EventSet* receiver);

    EventSet* getEventReceiver() const;

    void setEventSender(EventSet* sender);

    EventSet* getEventSender() const;

    void setTargetWindow(Window* target);

    void setPosition(float position);

    float getPosition() const;

    void setSpeed(float speed);

    float getSpeed() const;

    void setSkipNextStep(bool skip);

    bool getSkipNextStep() const;

    void setMaxStepDeltaSkip(float maxDelta);

    float getMaxStepDeltaSkip() const;

    void setMaxStepDeltaClamp(float maxDelta);

    float getMaxStepDeltaClamp() const;

    void start(bool skipNextStep = true);

    void stop();

    void pause();

    void unpause(bool skipNextStep = true);

    void togglePause(bool skipNextStep = true);

    bool isRunning() const;

    void setAutoSteppingEnabled(bool enabled);

    bool isAutoSteppingEnabled() const;

    void step(float delta);

    bool handleStart(const CEGUI::EventArgs& e);

    bool handleStop(const CEGUI::EventArgs& e);

    bool handlePause(const CEGUI::EventArgs& e);

    bool handleUnpause(const CEGUI::EventArgs& e);

    bool handleTogglePause(const CEGUI::EventArgs& e);

    void savePropertyValue(const String& propertyName);

    void purgeSavedPropertyValues(void);

    const String& getSavedPropertyValue(const String& propertyName);

    void addAutoConnection(Event::Connection conn);

    void unsubscribeAutoConnections();

    void apply();

private:
    void onAnimationStarted();
    void onAnimationStopped();
    void onAnimationPaused();
    void onAnimationUnpaused();

    void onAnimationEnded();
    void onAnimationLooped();

    Animation* d_definition;

    PropertySet* d_target;
    EventSet* d_eventReceiver;
    EventSet* d_eventSender;

    float d_position;
    float d_speed;
    bool d_bounceBackwards;
    bool d_running;
    bool d_skipNextStep;
    float d_maxStepDeltaSkip;
    float d_maxStepDeltaClamp;
    bool d_autoSteppingEnabled;

    typedef std::map<String, String, std::less<String>
        CEGUI_MAP_ALLOC(String, String)> PropertyValueMap;
    PropertyValueMap d_savedPropertyValues;

    typedef std::vector<Event::Connection
        CEGUI_VECTOR_ALLOC(Event::Connection)> ConnectionTracker;
    ConnectionTracker d_autoConnections;
};

} // End of  CEGUI namespace section

#if defined(_MSC_VER)
#   pragma warning(pop)
#endif

#endif  // end of guard _CEGUIAnimationInstance_h_