Persist sequencer state.

Author: Archie3d

Source/PluginEditor.cpp

@@ -114,8 +114,10 @@ AeolusAudioProcessorEditor::AeolusAudioProcessorEditor (AeolusAudioProcessor& p)
         for (auto* divisionView : _divisionViews) {
             divisionView->cancelAllStops();
             divisionView->cancelAllLinks();
+            divisionView->cancelTremulant();
         }
     };
+
     addAndMakeVisible(_cancelButton);
 
     addAndMakeVisible(_divisionsViewport);

Source/aeolus/division.cpp

@@ -133,7 +133,6 @@ void Division::initFromVar(const var& v)
 
 var Division::getPersistentState() const
 {
-    // Per division, but we have only one so far
     auto* divisionObj = new DynamicObject();
 
     divisionObj->setProperty("midi_channel", getMIDIChannel());

Source/aeolus/engine.cpp

@@ -388,23 +388,29 @@ var Engine::getPersistentState() const
 {
     auto* obj = new DynamicObject();
 
+    // Save the IR.
     int irNum = _selectedIR;
     obj->setProperty("ir", irNum);
 
+    // Save divisions.
     Array<var> divisions;
 
     for (auto* division : _divisions)
         divisions.add(division->getPersistentState());
 
     obj->setProperty("divisions", divisions);
 
+    // Make sure to capture current configuration into the sequencer's step.
+    _sequencer->captureCurrentStep();
+    obj->setProperty("sequencer", _sequencer->getPersistentState());
+
     return var{obj};
 }
 
 void Engine::setPersistentState(const var& state)
 {
     if (const auto* obj = state.getDynamicObject()) {
-
+        // Restore the IR
         int irNum = obj->getProperty("ir");
 
         if (MessageManager::getInstance()->isThisTheMessageThread())
@@ -414,6 +420,11 @@ void Engine::setPersistentState(const var& state)
 
         postReverbIR(irNum);
 
+        // Restore the sequencer
+        _sequencer->setPersistentState(obj->getProperty("sequencer"));
+
+        // Restore the divisions after the sequencer (in case we are restoring
+        // from a state that did not have a sequencer before).
         if (const auto* divisions = obj->getProperty("divisions").getArray()) {
 
             if (divisions->size() != _divisions.size()) {
@@ -426,6 +437,7 @@ void Engine::setPersistentState(const var& state)
                 division->setPersistentState(divisions->getReference(divIdx));
             }
         }
+
     }
 }
 

Source/aeolus/sequencer.cpp

@@ -25,28 +25,134 @@ using namespace juce;
 
 AEOLUS_NAMESPACE_BEGIN
 
+//==============================================================================
+
+var Sequencer::DivisionState::getPersistentState() const
+{
+    auto* obj = new DynamicObject();
+
+    Array<var> stopsArr;
+
+    for (const auto& s : stops)
+        stopsArr.add(s);
+
+    obj->setProperty("stops", stopsArr);
+    obj->setProperty("tremulant", tremulant);
+
+    return var{obj};
+}
+
+void Sequencer::DivisionState::setPersistentState(const var& v)
+{
+    if (const auto* obj = v.getDynamicObject()) {
+        if (const auto* stopsArr = obj->getProperty("stops").getArray()) {
+            if (stopsArr->size() == stops.size()) {
+                for (int i = 0; i < stops.size(); ++i)
+                    stops[i] = stopsArr->getUnchecked(i);
+            }
+        }
+
+        tremulant = obj->getProperty("tremulant");
+    }
+}
+
+//==============================================================================
+
+var Sequencer::OrganState::getPersistentState() const
+{
+    auto* obj = new DynamicObject();
+
+    Array<var> divisionsArr;
+
+    for (const auto& division : divisions)
+        divisionsArr.add(division.getPersistentState());
+
+    obj->setProperty("divisions", divisionsArr);
+
+    return var{obj};
+}
+
+void Sequencer::OrganState::setPersistentState(const var& v)
+{
+    if (const auto* obj = v.getDynamicObject()) {
+        if (const auto* divisionsArr = obj->getProperty("divisions").getArray()) {
+            if (divisionsArr->size() == divisions.size()) {
+                for (int i = 0; i < divisions.size(); ++i)
+                    divisions[i].setPersistentState(divisionsArr->getUnchecked(i));
+            }
+        }
+    }
+}
+
+//==============================================================================
+
 Sequencer::Sequencer(Engine& engine, int numSteps)
     : _engine{engine}
     , _steps(numSteps)
     , _currentStep{0}
+    , _listeners{}
 {
     jassert(_steps.size() > 0);
 
     initFromEngine();
 }
 
+var Sequencer::getPersistentState() const
+{
+    auto* sequencerObj = new DynamicObject();
+
+    Array<var> stepsArr;
+
+    for (int stepIdx = 0; stepIdx < _steps.size(); ++stepIdx)
+        stepsArr.add(_steps[stepIdx].getPersistentState());
+
+    sequencerObj->setProperty("steps", stepsArr);
+    sequencerObj->setProperty("current_step", _currentStep);
+
+    return var{sequencerObj};
+}
+
+void Sequencer::setPersistentState(const var& v)
+{
+    if (auto* sequencerObj = v.getDynamicObject()) {
+
+        if (auto* stepsArr = sequencerObj->getProperty("steps").getArray()) {
+            if (stepsArr->size() == _steps.size()) {
+                for (int stepIdx = 0; stepIdx < _steps.size(); ++stepIdx)
+                    _steps[stepIdx].setPersistentState(stepsArr->getUnchecked(stepIdx));
+            }
+        }
+
+        const int currentStep = sequencerObj->getProperty("current_step");
+
+        if (currentStep >= 0 && currentStep < (int)_steps.size()) {
+            // Don't capture current state as it is unititialised
+            // and should not go into the sequencer.
+            setStep(currentStep, false);
+        }
+    }
+}
+
 void Sequencer::captureCurrentStep()
 {
     captureState(_steps[_currentStep]);
 }
 
-void Sequencer::setStep(int index)
+void Sequencer::setStep(int index, bool captureCurrentState)
 {
     jassert(index >= 0 && index < (int)_steps.size());
 
-    captureCurrentStep();
-    _currentStep = index;
-    recallState(_steps[_currentStep]);
+    if (index != _currentStep) {
+        if (captureCurrentState)
+            captureCurrentStep();
+
+        _currentStep = index;
+        recallState(_steps[_currentStep]);
+
+        _listeners.call([index](Listener& listener) {
+                listener.sequencerStepChanged(index);
+            });
+    }
 }
 
 void Sequencer::stepForward()

Source/aeolus/sequencer.h

@@ -38,11 +38,24 @@ class Sequencer
     {
         std::vector<bool> stops;    ///< Stops enablement mask.
         bool tremulant;             ///< Tremulant enablement.
+
+        juce::var getPersistentState() const;
+        void setPersistentState(const juce::var& v);
     };
 
     struct OrganState
     {
         std::vector<DivisionState> divisions;
+
+        juce::var getPersistentState() const;
+        void setPersistentState(const juce::var& v);
+    };
+
+    class Listener
+    {
+    public:
+        virtual ~Listener() {};
+        virtual void sequencerStepChanged(int step) = 0;
     };
 
     Sequencer() = delete;
@@ -51,12 +64,18 @@ class Sequencer
     int getStepsCount() const noexcept { return (int)_steps.size(); }
     int getCurrentStep() const noexcept { return _currentStep; }
 
+    void addListener(Listener* listener) { _listeners.add(listener); }
+    void removeListener(Listener* listener) { _listeners.remove(listener); }
+
+    juce::var getPersistentState() const;
+    void setPersistentState(const juce::var& v);
+
     /**
      * Capture the organ state from the engine into the current step.
      */
     void captureCurrentStep();
 
-    void setStep(int index);
+    void setStep(int index, bool captureCurrentState = true);
 
     void stepForward();
 
@@ -70,6 +89,8 @@ class Sequencer
     std::vector<OrganState> _steps;
     int _currentStep;
 
+    juce::ListenerList<Listener> _listeners;
+
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(Sequencer)
 };
 

Source/ui/DivisionView.cpp

@@ -57,8 +57,7 @@ DivisionView::DivisionView(aeolus::Division* division)
 
 void DivisionView::cancelAllStops()
 {
-    if (_division == nullptr)
-        return;
+    jassert(_division != nullptr);
 
     for (int i = 0; i < _division->getStopsCount(); ++i) {
         auto& stop = _division->getStopByIndex(i);
@@ -72,15 +71,21 @@ void DivisionView::cancelAllStops()
 
 void DivisionView::cancelAllLinks()
 {
-    if (_division == nullptr)
-        return;
+    jassert(_division != nullptr);
 
     _division->cancelAllLinks();
 
     for (auto& button : _linkButtons)
         button->setToggleState(false, dontSendNotification);
 }
 
+void DivisionView::cancelTremulant()
+{
+    jassert(_division != nullptr);
+
+    _division->setTremulantEnabled(false);
+}
+
 constexpr int controlPanelWidth = 130;
 
 int DivisionView::getEstimatedHeightForWidth(int width) const

Source/ui/DivisionView.h

@@ -35,6 +35,7 @@ class DivisionView : public juce::Component
 
     void cancelAllStops();
     void cancelAllLinks();
+    void cancelTremulant();
 
     int getEstimatedHeightForWidth(int width) const;
 

Source/ui/SequencerView.cpp

@@ -27,9 +27,23 @@ SequencerView::SequencerView(aeolus::Sequencer* sequencer)
     : Component{}
     , _sequencer{sequencer}
     , _stepButtons{}
+    , _advanceButton{">>"}
 {
     jassert(sequencer != nullptr);
     populateStepButtons();
+
+    _advanceButton.setColour(TextButton::buttonColourId, Colour(0x46, 0x60, 0x16));
+    _advanceButton.onClick = [this]() {
+            _sequencer->stepForward();
+        };
+    addAndMakeVisible(_advanceButton);
+
+    _sequencer->addListener(this);
+}
+
+SequencerView::~SequencerView()
+{
+    _sequencer->removeListener(this);
 }
 
 void SequencerView::resized()
@@ -40,12 +54,25 @@ void SequencerView::resized()
     int buttonsWidth = buttonWidth * _sequencer->getStepsCount()
         + buttonPadding * (_sequencer->getStepsCount() - 1);
 
+    // Account for the advance button
+    buttonsWidth += 2 * (buttonWidth + buttonPadding);
+
     int x = (getWidth() - buttonsWidth) / 2;
 
     for (auto* button : _stepButtons) {
         button->setBounds(x, buttonPadding, buttonWidth, getHeight() - 2 * buttonPadding);
         x += buttonWidth + buttonPadding;
     }
+
+    x += buttonPadding;
+
+    _advanceButton.setBounds(x, buttonPadding, 2 * buttonWidth, getHeight() - 2 * buttonPadding);
+}
+
+void SequencerView::sequencerStepChanged(int step)
+{
+    if (step >= 0 && step < _stepButtons.size())
+        _stepButtons[step]->setToggleState(true, juce::dontSendNotification);
 }
 
 void SequencerView::populateStepButtons()
@@ -54,6 +81,20 @@ void SequencerView::populateStepButtons()
 
     for (int i = 0; i < numSteps; ++i) {
         auto button = std::make_unique<TextButton>(String(i + 1));
+        button->setClickingTogglesState(true);
+        button->setColour(TextButton::buttonColourId, Colour(0x40, 0x33, 0x33));
+        button->setColour(TextButton::buttonOnColourId, Colour(0xDF, 0xC0, 0x36));
+        button->setRadioGroupId(radioGroupId);
+
+        if (_sequencer->getCurrentStep() == i)
+            button->setToggleState(true, juce::dontSendNotification);
+
+        button->onClick = [ptr=button.get(), index = i, this]() {
+            if (ptr->getToggleState()) {
+                _sequencer->setStep(index);
+            }
+        };
+
         addAndMakeVisible(button.get());
         _stepButtons.add(button.release());
     }