launchpad-sequencer/PlaybackScreen.cpp

#include "Sequencer.h"
#include "PlaybackScreen.h"
#include "colors.h"
#include <iostream>

PlaybackScreen::PlaybackScreen(Sequencer& seq)
    : parent(seq), beatDisplayOffset(0)
{
}

void PlaybackScreen::enable()
{
    if(sequencer.beats.size() == 0) {
        beatDisplayOffset = 0;
    } else {
        beatDisplayOffset = std::min(
            beatDisplayOffset, 
            (Player::BeatIndex)(sequencer.beats.size() - 1) / beatDisplayWidth * beatDisplayWidth
            );
    }
    refreshAll();
    parent::enable();
}

void PlaybackScreen::beforeBeat(Player::BeatIndex beat)
{
    // std::cout << "before beat #" << beat << std::endl;
    beatDisplayOffset = beat / beatDisplayWidth * beatDisplayWidth;
    refreshAll();
}

void PlaybackScreen::afterBeat(Player::BeatIndex beat)
{
}

void PlaybackScreen::keyPressed(unsigned char x, unsigned char y)
{
    // std::cout << "clicked x=" << (int)x << ", y=" << (int)y << std::endl;

    if(x == 8) { // very right
        if(y < sequencer.messages.size()) {
            std::shared_ptr<midi::Message> msg_ptr = sequencer.messages[y];
            msg_ptr->print(std::cout);
            sequencer.midiOut.sendMessage(*msg_ptr);
        }
    } else if(y == 8) { // very top
        bool playing = sequencer.player.isPlaying();
        switch(x) {
            case 2: // left
                if(!playing && beatDisplayOffset > 0) {
                    beatDisplayOffset = std::max((Player::BeatIndex)0, beatDisplayOffset - beatDisplayWidth);
                }
                break;
            case 3: // right
                if(!playing && (beatDisplayOffset + beatDisplayWidth) < sequencer.beats.size()) {
                    beatDisplayOffset += beatDisplayWidth;
                }
                break;
            case 5: 
                disable();
                sequencer.configScreen.enable();
                break;
            case 7: // start / stop
                if(playing) {
                    sequencer.player.stop();
                } else {
                    sequencer.player.loop();
                }
                break;
        }
    } else {
        Player::BeatIndex beatIndex = x + beatDisplayOffset;
        if(beatIndex < sequencer.beats.size() && y < sequencer.messages.size()) {
            std::shared_ptr<midi::NoteOnMessage> noteOnMessage_ptr
                = std::dynamic_pointer_cast<midi::NoteOnMessage>(sequencer.messages[y]);
            if(noteOnMessage_ptr) {
                toggleOnMessage(noteOnMessage_ptr, beatIndex);
            }
        }
    }

    refreshAll();
}

void PlaybackScreen::keyReleased(unsigned char x, unsigned char y)
{
    refreshAll();
}

void PlaybackScreen::refresh(unsigned char x, unsigned char y)
{
    if(x == 8) { // very right
        if(y < sequencer.messages.size()) {
            setColor(x, y, getKeyPressed(x, y) ? colors::activeOption : colors::inactiveOption);
        } else {
            setColor(x, y, colors::dark);
        }
    } else if(y == 8) { // very top
        bool playing = sequencer.player.isPlaying();
        switch(x) {
            case 2: // left
                if(!playing && beatDisplayOffset > 0) {
                    setColor(x, y, colors::inactiveOption);
                } else {
                    setColor(x, y, colors::dark);
                }
                break;
            case 3: // right
                if(!playing && (beatDisplayOffset + beatDisplayWidth) < sequencer.beats.size()) {
                    setColor(x, y, colors::inactiveOption);
                } else {
                    setColor(x, y, colors::dark);
                }
                break;
            case 5: 
                setColor(x, y, colors::inactiveOption);
                break;
            case 7: // start / stop
                if(playing) {
                    setColor(x, y, colors::activeOption);
                } else {
                    setColor(x, y, colors::inactiveOption);
                }
                break;
        }
    } else {
        Player::BeatIndex beatIndex = x + beatDisplayOffset;
        if(beatIndex < sequencer.beats.size() && y < sequencer.messages.size()) {
            const midi::MessageList& beat = sequencer.beats[beatIndex];
            std::shared_ptr<midi::Message> msg_ptr = sequencer.messages[y];
            if(beat.contains(*msg_ptr)) {
                if(sequencer.player.getNextBeat() == beatIndex) {
                    setColor(x, y, colors::activeMessage);
                } else {
                    setColor(x, y, colors::inactiveMessage);
                }
            } else {
                setColor(x, y, colors::dark);
            }
        } else {
            setColor(x, y, colors::dark);
        }
    }
}
    
void PlaybackScreen::toggleOnMessage(std::shared_ptr<midi::NoteOnMessage> noteOnMessage_ptr, Player::BeatIndex beatIndex)
{
    noteOnMessage_ptr->print(std::cout);

    const midi::MessageList& beat = sequencer.beats[beatIndex];
    midi::MessageList::const_iterator beat_msg_it = beat.find(*noteOnMessage_ptr);
    if(beat_msg_it == beat.end()) {
        // insert message at beat
        sequencer.beats.pushBackMessage(beatIndex, std::dynamic_pointer_cast<midi::Message>(noteOnMessage_ptr));
    } else {
        // remove message from beat
        sequencer.beats.eraseMessage(beatIndex, beat_msg_it);
    }
    sequencer.beats.printRegistry(std::cout);
}