Timeline.h

#ifndef _TIMELINE_H_
#define _TIMELINE_H_

#pragma once

#include "LumiverseCore.h"
#include "Keyframe.h"

namespace Lumiverse {
namespace ShowControl {

class Timeline {
public:
  Timeline();

  Timeline(JSONNode data);

  Timeline(const Timeline& other);

  void operator=(const Timeline& other);

  virtual ~Timeline();

  string getTimelineKey(Device* d, string paramName);

  string getTimelineKey(string id, string paramName);

  Keyframe getKeyframe(string identifier, size_t time);

  map<string, Keyframe> getKeyframes(Device* d, size_t time);

  map<string, map<size_t, Keyframe> >& getAllKeyframes();

  void setKeyframe(string identifier, size_t time, LumiverseType* data, bool ucs = false);

  void setKeyframe(Device* d, size_t time, bool ucs = false);

  void setKeyframe(Rig* rig, size_t time, bool ucs = false);

  void setKeyframe(DeviceSet devices, size_t time, bool ucs = false);

  void setKeyframe(string identifier, size_t time, string timelineID, size_t offset = 0);

  void setKeyframe(Device* d, size_t time, string timelineID, size_t offset = 0);

  void setKeyframe(DeviceSet devices, size_t time, string timelineID, size_t offset = 0);

  void deleteKeyframe(string identifier, size_t time);

  void deleteKeyframe(Device* d, size_t time);

  void deleteKeyframe(DeviceSet devices, size_t time);

  void moveKeyframe(string id, size_t oldTime, size_t newTime);

  void deleteKeyframesAfter(string id, size_t start);

  void deleteKeyframesBetween(size_t start, size_t end);

  bool addEndEvent(string id, shared_ptr<Event> e);

  void deleteEndEvent(string id);

  bool addEvent(size_t time, shared_ptr<Event> e);

  void deleteEvent(size_t time, string id = "");

  vector<shared_ptr<Event> > getEvents(size_t time, string id = "");

  shared_ptr<Event> getEndEvent(string id);

  multimap<size_t, shared_ptr<Event> >& getAllEvents();

  map<string, shared_ptr<Event> >& getAllEndEvents();

  virtual shared_ptr<LumiverseType> getValueAtTime(string id, string paramName, LumiverseType* currentVal, size_t time, map<string, shared_ptr<Timeline> >& tls);

  virtual void executeEvents(size_t prevTime, size_t currentTime);

  virtual void executeEndEvents();

  virtual int getLoops();

  virtual void setLoops(int loops);

  virtual size_t getLength();

  virtual size_t getLoopLength();

  virtual JSONNode toJSON();

  virtual bool isDone(size_t time, map<string, shared_ptr<Timeline> >& tls);

  virtual void setCurrentState(map<string, map<string, LumiverseType*> >& state, shared_ptr<Timeline> active, size_t time);

  Keyframe getPreviousKeyframe(string identifier, size_t time);

  virtual size_t getLoopTime(size_t time);

  virtual string getTimelineTypeName() { return "timeline"; }

protected:
  size_t _length;

  size_t _loopLength;
  
  int _loops;

  bool _lengthIsUpdated;

  bool _loopLengthIsUpdated;

  // right so the map should at some point be changed to a specialized data structure that meets
  // the following properties:
  // -given a time, can find the first and next keyframes (if they exist) as quickly as possible
  // -can handle insertions and deletions quickly (doesn't have to be as fast as possible)
  map<string, map<size_t, Keyframe> > _timelineData;

  multimap<size_t, shared_ptr<Event> > _events;

  map<string, shared_ptr<Event> > _endEvents;

  void updateKeyframeState(string id, string paramName, LumiverseType* param, shared_ptr<Timeline> tl, size_t time);

  void loadJSON(JSONNode node);
};

}
}
#endif