renderbug/src/Sequencer.cpp

#include "Sequencer.h"
#include <MainLoop.h>
#include "Static.h"

Sequencer::Sequencer() :
  Task("SceneSequencer"),
  m_idx(0)
{
  state = Task::Running;
}

void
Sequencer::Scene::start()
{
    for(const char* pattern : patterns) {
        Log.verbose("Starting pattern task %s", pattern);
        MainLoop::instance()->dispatch(InputEvent{InputEvent::StartThing, pattern});
    }
}

void
Sequencer::Scene::stop()
{
    for(const char* pattern : patterns) {
        Log.verbose("Stopping pattern task %s", pattern);
        MainLoop::instance()->dispatch(InputEvent{InputEvent::StopThing, pattern});
    }
}

void
Sequencer::loop() {}

const char*
Sequencer::currentSceneName()
{
    return m_scenes[m_idx].name;
}

const std::vector<Sequencer::Scene>
Sequencer::scenes() const
{
    return m_scenes;
}

void
Sequencer::onStart()
{
}

void
Sequencer::setScenes(std::vector<Scene> &&scenes)
{
  m_idx = 0;
  m_scenes = scenes;
}

void
Sequencer::handleEvent(const InputEvent& evt)
{
    if (evt.intent == InputEvent::ReadyToRoll && !m_scenes.empty()) {
      Log.notice("Starting pattern %s!", m_scenes[m_idx].name);
      for(const char* pattern : m_scenes[m_idx].patterns) {
          Log.verbose("Starting pattern task %s", pattern);
          MainLoop::instance()->dispatch(InputEvent{InputEvent::StartThing, pattern});
      }
    } else if (evt.intent == InputEvent::SetPattern && evt.asString() == m_scenes[m_idx].name) {
        return;
    } else if (evt.intent == InputEvent::SetPattern || evt.intent ==  InputEvent::NextPattern || evt.intent == InputEvent::PreviousPattern) {
        Log.notice("Switching pattern!");

        m_scenes[m_idx].stop();

        if (evt.intent == InputEvent::NextPattern) {
            m_idx++;
        } else if (evt.intent == InputEvent::PreviousPattern) {
            m_idx--;
        } else {
            for(m_idx = 0; m_idx < m_scenes.size(); m_idx++) {
              if (!strcmp(evt.asString(), m_scenes[m_idx].name)) {
                  break;
              }
            }
        }

        if (m_idx < 0) {
            m_idx = m_scenes.size() - 1;
        }

        if (m_idx >= m_scenes.size()) {
            m_idx = 0;
        }

        m_scenes[m_idx].start();
    }
}

void
doScenes(Args& args, Print& out)
{
  out.println("Available scenes: ");
  for (auto scene : Static<Sequencer>::instance()->scenes()) {
    out.println(scene.name);
  }
}

static String s;

void
doScene(Args& args, Print& out)
{
  s  = args[1];
  MainLoop::instance()->dispatch(InputEvent{InputEvent::SetPattern, s.c_str()});
}

const std::vector<Command> _commands = {
  {"scene", doScene},
  {"scenes", doScenes}
};

const std::vector<Command>&
Sequencer::commands() const
{
  return _commands;
}

STATIC_ALLOC(Sequencer);
STATIC_TASK(Sequencer);