simplemidi/include/InputAction.h

/*
 * InputActions.h
 *
 *  Created on: 5 déc. 2020
 *      Author: fanch
 */

#ifndef SRC_INPUTACTIONS_H_
#define SRC_INPUTACTIONS_H_


#include "InputAction.h"

#include "MidiMessage.h"
#include "MidiPort.h"


/**
 * @brief Classe qui représente un message Midi prédéfinie avec des paramètres (channel, key, velocity)
 * soit défini en dure soit en reprennant les valeur du bouton.
 */
class InputAction
{
    public:
        InputAction() : m_name(""), m_message(new NoteOn(1,0,0)), m_current(new NoteOn(1,0,0))
        {
            m_key=-1;
            m_channel=-1;
            m_velocity=-1;
        }
        virtual ~InputAction(){
            if(m_message) delete m_message;
            if(m_current) delete m_current;
        }
        InputAction(const InputAction& c) : m_name(c.m_name)
        {
            this->operator=(c);
        }

        InputAction(const std::string& name, MidiMessage* m)
        {
            m_name=name;
            m_message=m_current=NULL;
            m_key=-1;
            m_channel=-1;
            m_velocity=-1;
            set_message(m);
        }


        InputAction(const std::string& name, Json::Value& v)
        {
            m_name=name;
            m_message=m_current=NULL;
            m_key=-1;
            m_channel=-1;
            m_velocity=-1;
            set_message(MidiMessage::parse(v), false);
        }

        const InputAction& operator=(const InputAction& c)
        {
            m_message=c.m_message->copy();
            m_current=c.m_current->copy();
            m_key=c.m_key;
            m_channel=c.m_channel;
            m_velocity=c.m_velocity;
            return *this;
        }


        void set_message(MidiMessage* m, bool copy=true)
        {
            if(m_message)
            {
                delete m_message;
                m_message=NULL;
            }
            if(m_current)
            {
                delete m_current;
                m_current=NULL;
            }
            m_current = m->copy();
            m_message = copy?m->copy():m;
            if(m_key>=0) set_key(m_key);
            if(m_channel>=0) set_channel(m_channel);
            if(m_velocity>=0) set_velocity(m_velocity);
        }

        void set_key(int k) {
            m_key=k;
            switch(m_message->type){
                case MidiMessage::NOTE_ON:
                case MidiMessage::CONTROLLER_CHANGE:
                case MidiMessage::NOTE_OFF:
                    (dynamic_cast<Note*>(m_current))->key=k;
                    break;

            }
        }

        void set_channel(int k) {
            m_channel=k;
            switch(m_message->type){
                case MidiMessage::NOTE_ON:
                case MidiMessage::CONTROLLER_CHANGE:
                case MidiMessage::NOTE_OFF:
                    (dynamic_cast<Note*>(m_current))->channel=k;
                    break;

            }
        }

        void set_velocity(int k) {
            m_velocity=k;
            switch(m_message->type){
                case MidiMessage::NOTE_ON:
                case MidiMessage::CONTROLLER_CHANGE:
                case MidiMessage::NOTE_OFF:
                    (dynamic_cast<Note* >(m_current))->velocity=k;
                    break;

            }

        }

        MidiMessage* get_message() const {return m_message; }
        const std::string& get_name() const {return m_name; }

    protected:
        std::string             m_name;
        MidiMessage*            m_message;
        MidiMessage*            m_current;

        int                     m_channel;
        int                     m_key;
        int                     m_velocity;

		friend class PadDefinition;
};


class InputActionList : public std::vector<InputAction*>
{
    public:
        InputActionList() : std::vector<InputAction*>(){}
        InputActionList(const std::string& n, InputAction* i) : std::vector<InputAction*>()
        {
            push_back(i);
            name=n;
        }
        InputActionList(const InputActionList& v) : std::vector<InputAction*>(){operator=(v);}
        InputActionList(const std::string& n, Json::Value& v) : std::vector<InputAction*>(){
            name=n;
            add(v);
        }

        void add(Json::Value& v){
            int s = v.size();
            if(s && v[0].isString())
            {
                push_back(new InputAction("", v));
            }else{
                for(int i=0; i<s; i++)
                    push_back(new InputAction("", v[i]));
            }
        }

        virtual ~InputActionList()
        {
            clear();
        }

        void clear()
        {
            int s = size();
            for(int i=0; i<s; i++) delete at(i);
            std::vector<InputAction*>::clear();
        }

        const InputActionList& operator=(const InputActionList& l){
            std::vector<InputAction*>::operator=(l);
            name=l.name;
            return l;
        }

        MidiMessageList* get_messages()
        {
            m_midi.clear();
            for(int i=0; i<size(); i++)
                m_midi.push_back(at(i)->get_message());
            return &m_midi;
        }

        const std::string& get_name() const {return name;}
        std::string name;
        MidiMessageList m_midi;
};


#endif /* SRC_INPUTACTIONS_H_ */