KwidgetAudioProcessor.cpp

Go to the documentation of this file.

namespace krotos
{
    SettingsFile KwidgetAudioProcessor::settingsFile =
            File(AssetManager::getPluginDirectory().getFullPathName() + File::getSeparatorString() + "settings.json");
 
    const String KwidgetAudioProcessor::autoPlayMaxDuration{"autoplay_max_duration"};
    const String KwidgetAudioProcessor::recorderReleaseTime{"recorder_release_time"};
    const String KwidgetAudioProcessor::DroppedFileNameFormat("dnd_filename_format");
    const String KwidgetAudioProcessor::DefaultDroppedFileNameFormat("KS_%PRESETNAME%_%TAKECOUNT%");
    const String KwidgetAudioProcessor::T2PStrictMode("t2p_strict_mode");
 
    const StringArray KwidgetAudioProcessor::StaticKwidgetTypes = {
            KwidgetFactory::KwidgetType::AudioOut, KwidgetFactory::KwidgetType::Recorder,
            KwidgetFactory::KwidgetType::ConvolutionReverb, KwidgetFactory::KwidgetType::Filter
            // Static kwidgets are flawed and ideally should be deprecated in the future, so think carefully before
            // adding a new one.
    };
 
    const StringArray KwidgetAudioProcessor::StaticKwidgetIDs = {
            KwidgetFactory::KwidgetModifiers::MasterFX + KwidgetFactory::KwidgetType::MacroSlider
            // Static kwidgets are flawed and ideally should be deprecated in the future, so think carefully before
            // adding a new one.
    };
 
    KwidgetAudioProcessor::KwidgetAudioProcessor(const BusesProperties& ioLayouts, size_t numBusses,
                                                 size_t channelsPerStereoBus, size_t numRecorders,
                                                 size_t numInputChannels, size_t numOutputChannels)
        : AudioProcessor(ioLayouts),
          m_autoplay{{"CoreEngine0", false}, {"CoreEngine1", false}, {"CoreEngine2", false}, {"CoreEngine3", false}},
          m_audioOuts(numBusses), m_channelsPerStereoBus(channelsPerStereoBus), m_numRecorders(numRecorders),
          m_numVoices(NUM_VOICES_TOTAL),
          m_mainGraph(m_numVoices, numInputChannels,
                      numOutputChannels), // The main and mod graphs are created with enough voice references to cover
                                          // poly and drone synths
          m_modulatorGraph(m_numVoices, numInputChannels, numOutputChannels),
          m_synthPoly(m_mainGraph, m_modulatorGraph, 0, NUM_VOICES_POLY,
                      numOutputChannels), // The poly synth uses the first NUM_VOICES_POLY voices
          m_synthDrone(m_mainGraph, m_modulatorGraph, NUM_VOICES_POLY, NUM_VOICES_DRONE,
                       numOutputChannels), // then the drone synth uses the remaining NUM_VOICES_DRONE voices
          parameterManager(*this)
    {
        initialiseStateListeners();
 
        m_presetEventMiddleware.addHook(std::make_unique<RelativeSamplePathRewriteHook>());
 
        presetManager.presetChanged = [this](const ValueTree& newState) {
            // try to setState of plugin, but if incoming state load aborted, inform user
            auto setNewStateSuccess = setState(newState);
 
            if (!setNewStateSuccess)
            {
                // inform the user here of failed preset load
                PresetManagerUI::alertStateValidation();
            }
            if (m_globalAutoplayOn) // for autoplay presets we must restore note and recorder after state setting
            {
                triggerRecordingStart();
                m_synthDrone.noteOn(1, MIDI_NOTE_FLAG_DRONE + MIDI_NOTE_NUMBER_C3, /*velocity*/ 1.0f);
            }
        };
 
        initialiseSettingsFileValues();
        initialiseAudioOutConfiguration();
        initialiseMasterFX();
        initialiseRecorders();
 
#if !UNIT_TEST                   // don't look for/load init state/preset when running unit tests
        if (!host.isPluginval()) // pluginval currently not compatible with state loading
            setInitialState();   // load the necessary init state/preset at the end of the constructor
#endif
    }
 
    KwidgetAudioProcessor::~KwidgetAudioProcessor()
    {
        /*  The call to load the init preset happens asynchronously from the constructor.
            In the time between the call being queued and executed, the DAW might have tried to load it's own data.
            m_shouldInit flags whether the init preset should loaded in the async callback.
        */
        m_shouldInit = false;
 
        /*  In certain DAWs (Pro Tools) the KwidgetAudioProcessor may be created and destroyed a number of times,
            therefore it's possible an async call gets executed after the class which queued it has been deleted.
 
            The WeakReference is used to determine whether the caller has been destroyed at the time of execution.
        */
        masterReference.clear();
    }
 
    void KwidgetAudioProcessor::setInitialState()
    {
        try
        {
            m_initPresetPath =
                    presetManager.getInitPresetFile()
                            .getFullPathName(); // if this throws, we are missing the init preset. fails safely.
            m_lastLoadedPresetPath = m_initPresetPath;
 
            // TODO: presetInfoTree/presetMenu should ideally be handled in its own class/functions
            // store the last loaded preset
            presetInfoTree = std::make_unique<ValueTree>(krotos::XmlType::Tag::LastLoadedPreset);
            presetInfoTree->setProperty(krotos::XmlType::Property::LastLoadedPresetName, m_lastLoadedPresetPath,
                                        nullptr);
 
            // Logic AU requires direct setState call for autoplay operation in the initial preset
            if (host.isLogic())
            {
                if (m_shouldInit) // if we are creating a new instance, not recalling a session. new instance check not
                                  // needed here, but just in case!
                {
                    // try to setState of plugin
                    auto setNewStateSuccess =
                            setState(PresetManager::getValueTreeFromFile(File(m_lastLoadedPresetPath)));
 
                    if (setNewStateSuccess)
                    {
                        m_shouldInit = false;
                    }
                    else
                    {
                        // inform the user here of failed state load
                        PresetManagerUI::alertStateValidation();
                    }
                }
            }
            else
            {
                MessageManager::callAsync([this, target = WeakReference<KwidgetAudioProcessor>{this}] {
                    if (target && m_shouldInit)
                    {
                        presetManager.setCurrentPreset(m_lastLoadedPresetPath);
                        m_shouldInit = false;
                    }
                });
            }
        }
        catch (PresetException& ex)
        {
            // in the worst case, where init preset/state is missing - fail safely, without loading any state
            std::cout << ex.what() << std::endl;
        }
    }
 
    void KwidgetAudioProcessor::removeEngines()
    {
        suspendProcessing(true);
        removeKwidgetsOfType({KType::CoreEngine, KType::Reformer});
        suspendProcessing(false);
    }
 
    void KwidgetAudioProcessor::initialiseSettingsFileValues()
    {
        // create and set default setting for autoplay duration
        settingsFile.setDefaultIfVoid(autoPlayMaxDuration, 180); // 3 minutes
 
        // create and set default setting for recorder post roll out duration
        settingsFile.setDefaultIfVoid(recorderReleaseTime, 1.5); // 1.5 seconds
 
        // create and set default setting for the recorder output filename
        settingsFile.setDefaultIfVoid(DroppedFileNameFormat, DefaultDroppedFileNameFormat);
 
        // Default setting for text to preset strict mode: false - always generate
        settingsFile.setDefaultIfVoid(T2PStrictMode, false);
    }
 
    void KwidgetAudioProcessor::initialiseAudioOutConfiguration()
    {
        // Create the audio output Kwidgets, and connect them to the appropriate output nodes
        const int channelIncrement = m_channelsPerStereoBus;
        for (int i = 0; i < m_audioOuts.size(); ++i)
        {
            // Set AudioOut 0 ID to "Master". Name the rest incrementally from 1.
            String audioOutID = i == 0 ? m_masterAudioOutID : KType::AudioOut + String(i);
 
            m_audioOuts[i] = addKwidgetWithID(KType::AudioOut, audioOutID, true);
            m_mainGraph.connectToOutputNode(m_audioOuts[i], i * channelIncrement, m_channelsPerStereoBus);
 
            // Hotfix KST-1903 - Static kwidgets once created must retain the same
            // number of parameters due to a design flaw in the parameter allocation
            // See https://bitbucket.org/krotos/krotos_modules_3/commits/210fc7d7462c69287d5ac50f32bc06e9996fc178
            // Todo: Update once new solution for static kwidgets is found.
            if (i > 0)
            {
                jassert(m_audioOuts[i]->getParameters().size() == 2);
            }
        }
 
        // TODO: This code forces the number of buses and channels to be set at compile time in the PluginProcessor with
        // constexpr Assign master audio out ptr to "Master"
        jassert(m_audioOuts[0] != nullptr);
        m_masterAudioOut = m_audioOuts[0];
 
        // Set up master autoplay parameter which only exists in the "Master" audio out.
        m_masterAudioOut->addParameterCallback(Kwidget_AudioOut::Parameters::Autoplay, [this](float newValue) {
            autoPlayGlobalChanged(newValue > ParameterManager::OnOffThreshold);
        });
 
#if ENABLE_SANDBOX
        // creates the kwidget - adds to main Graph and the lists
        m_audioOutSandBox =
                addKwidgetWithID(KType::AudioOut, KwidgetFactory::KwidgetModifiers::SandBox + KType::AudioOut, true);
#endif
        // Hotfix KST-1903 - Static kwidgets once created must retain the same
        // number of parameters due to backwards compatibility issues with parameter allocation
        // See https://bitbucket.org/krotos/krotos_modules_3/commits/210fc7d7462c69287d5ac50f32bc06e9996fc178
        // Do not add new parameters to static kwidgets until this is addressed.
        // Todo: Update once new solution for static kwidgets is found.
        jassert(m_masterAudioOut->getParameters().size() == 4);
    }
 
    void KwidgetAudioProcessor::initialiseRecorders()
    {
        for (int i = 0; i < m_numRecorders; i++)
        {
            // Set Recorder 0 ID to "Recorder". Name the rest incrementally from 1.
            String recorderID = KType::Recorder + (i > 0 ? String(i) : "");
            std::unique_ptr<Kwidget> m_recorder_tmp = std::make_unique<Kwidget_Recorder>(recorderID);
            m_recorders[i] = std::move(m_recorder_tmp);
            parameterManager.addKwidget(m_recorders[i].get());
            m_kwidgets.add(m_recorders[i].get());
            m_recorderPtrs.add(dynamic_cast<Kwidget_Recorder*>(m_recorders[i].get()));
            m_kwidgetLookup[m_recorders[i]->getKwidgetID()] = m_recorders[i].get();
        }
    }
 
    void KwidgetAudioProcessor::initialiseMasterFX()
    {
        String masterFilterID = KMod::MasterFX + KType::Filter;
        m_masterFilter = std::make_unique<Kwidget_Filter>(masterFilterID);
        parameterManager.addKwidget(m_masterFilter.get(), true, false);
        m_kwidgets.add(m_masterFilter.get());
        m_kwidgetLookup[m_masterFilter->getKwidgetID()] = m_masterFilter.get();
 
        String masterReverbID = KMod::MasterFX + KType::ConvolutionReverb;
        m_masterReverb = std::make_unique<Kwidget_ConvolutionReverb>(masterReverbID);
        parameterManager.addKwidget(m_masterReverb.get(), true, false);
        m_kwidgets.add(m_masterReverb.get());
        m_kwidgetLookup[m_masterReverb->getKwidgetID()] = m_masterReverb.get();
        m_masterReverb->getCustomParameter(Kwidget_ConvolutionReverb::Parameters::ImpulsePath)
                ->setValue(utils::StringsIntoPath(Kwidget_ConvolutionReverb::getDefaultImpulsePath(), "D_Equipment",
                                                  "Classic Hall.wav"));
 
        String macroSliderID = KMod::MasterFX + KType::MacroSlider;
        m_intensityMacro = std::make_unique<Kwidget_MacroSlider>(macroSliderID);
        parameterManager.addKwidget(m_intensityMacro.get(), true, false);
        m_kwidgets.add(m_intensityMacro.get());
        m_kwidgetLookup[m_intensityMacro->getKwidgetID()] = m_intensityMacro.get();
 
        // Hotfix KST-1903 - Static kwidgets once created must retain the same
        // number of parameters due to backwards compatibility issues with parameter allocation
        // See https://bitbucket.org/krotos/krotos_modules_3/commits/210fc7d7462c69287d5ac50f32bc06e9996fc178
        // Do not add new parameters to static kwidgets until this is addressed.
        // Todo: Update once new solution for static kwidgets is found.
        jassert(m_masterReverb->getParameters().size() == 4);
        jassert(m_masterFilter->getParameters().size() == 6);
        jassert(m_intensityMacro->getParameters().size() == 1);
 
        // Set up parameter defaults
        m_masterAudioOut->getParameter(Kwidget_AudioOut::Parameters::FXActivation)->set(0.0f);
 
        // Cache the parameter pointer for the processBlock bypass.
        m_audioOutFxEnabledParameter = m_masterAudioOut->getParameter(Kwidget_AudioOut::Parameters::FXActivation);
 
        // Hardcode modulation destinations for intensity macroSlider
        parameterManager.addModulation(macroSliderID, 0, masterFilterID, Kwidget_Filter::Parameters::Cutoff, -0.8f,
                                       KAttachment::Polarity::Unipolar);
        parameterManager.addModulation(macroSliderID, 0, masterReverbID, Kwidget_ConvolutionReverb::Parameters::Mix,
                                       1.0f, KAttachment::Polarity::Unipolar);
    }
 
    void KwidgetAudioProcessor::soloActivated(Kwidget_CoreEngine* engine)
    {
        soloActivatedAllEngines(engine->getKwidgetID());
    }
 
    void KwidgetAudioProcessor::soloActivated(Kwidget_Reformer* engine)
    {
        soloActivatedAllEngines(engine->getKwidgetID());
    }
 
    void KwidgetAudioProcessor::soloDeActivated(Kwidget_CoreEngine* engine)
    {
        soloDeActivatedAllEngines(engine->getKwidgetID());
    }
 
    void KwidgetAudioProcessor::soloDeActivated(Kwidget_Reformer* engine)
    {
        soloDeActivatedAllEngines(engine->getKwidgetID());
    }
 
    void KwidgetAudioProcessor::soloActivatedAllEngines(const String& callingID)
    {
        // Iterate through all kwidgets, finding Reformers and CoreEngines
        // and setting their mutes and solos appropriately
        // Solo is effectively simply all qualifying kwidgets being muted
        // except for the calling kwidget  [SOLO]
        for (auto& k : m_kwidgets)
        {
            if (k->isAChildKwidget())
            {
                continue; // Ignore child kwidgets
            }
            else if (k->getKwidgetType() == KType::Reformer)
            {
                // ensure calling core engine being soloed is unmuted
                if (k->getKwidgetID() == callingID)
                {
                    k->getParameter(Kwidget_Reformer::Parameters::Mute)->set(0.0f);
                }
                else // mute / unsolo all other core engines
                {
                    k->getParameter(Kwidget_Reformer::Parameters::Mute)->set(1.0f);
                    k->getParameter(Kwidget_Reformer::Parameters::Solo)->set(0.0f);
                }
            }
            else if (k->getKwidgetType() == KType::CoreEngine)
            {
                // ensure calling core engine being soloed is unmuted
                if (k->getKwidgetID() == callingID)
                {
                    k->getParameter(Kwidget_CoreEngine::Parameters::Mute)->set(0.0f);
                }
                else // mute / unsolo all other core engines
                {
                    k->getParameter(Kwidget_CoreEngine::Parameters::Mute)->set(1.0f);
                    k->getParameter(Kwidget_CoreEngine::Parameters::Solo)->set(0.0f);
                }
            }
        }
    }
 
    void KwidgetAudioProcessor::soloDeActivatedAllEngines(const String& callingID)
    {
        // Iterate through all kwidgets, finding Reformers and CoreEngines
        // and unmuting them, except the calling kwidget which by definition, having
        // been previously soloed, will already be unmuted [SOLO]
        for (auto& k : m_kwidgets)
        {
            if (k->isAChildKwidget() || k->getKwidgetID() == callingID)
            {
                continue; // Ignore calling kwidget & child kwidgets
            }
            else if (k->getKwidgetType() == KType::Reformer)
            {
                k->getParameter(Kwidget_Reformer::Parameters::Mute)->set(0.0f);
            }
            else if (k->getKwidgetType() == KType::CoreEngine)
            {
                k->getParameter(Kwidget_CoreEngine::Parameters::Mute)->set(0.0f);
            }
        }
    }
 
    void KwidgetAudioProcessor::triggerRecordingStart()
    {
        if (isTimerRunning() == false)
        {
            // start autoplay limit timer
            auto autoplayMaxDurationValue = settingsFile.getSetting(autoPlayMaxDuration);
 
            // 180 second/3 minute fallback value
            int maxDuration = autoplayMaxDurationValue.isVoid() ? 180 : static_cast<int>(autoplayMaxDurationValue);
 
            startTimer(maxDuration * 1000);
        }
        
        m_recordingTriggerStarted = true;
 
        for (auto& m_recorderTmp : m_recorders)
        {
            m_recorderTmp->getActiveVoice()->noteOn(MIDI_NOTE_NUMBER_C3, 1.0f);
        }
    }
 
    void KwidgetAudioProcessor::triggerRecordingStop()
    {
        m_recordingTriggerStarted = false;
 
        for (auto& m_recorderTmp : m_recorders)
        {
            m_recorderTmp->getActiveVoice()->noteOff(1.0f);
        }
    }
 
    void KwidgetAudioProcessor::parameterValueChanged(int /*parameterIndex*/, float /*newValue*/)
    {
        // TODO: This is a realtime function called on the audio thread when any parameter value changes.
        // It is looking up ALL kwidgets and ALL of their parameters in order to
        // control the xypad trigger behaviour. This is far too much overhead for realtime processing.
        // Refactor with a more efficient approach.
        for (auto* kw : m_kwidgets)
        {
            if (kw->getKwidgetType().contains(KType::XyPad))
            {
                for (auto kwParam : kw->getParameters())
                {
                    if (kwParam->paramID == Kwidget_XyPad::Parameters::toggleOn)
                    {
                        m_xypadTriggerOn = kw->getParameter(Kwidget_XyPad::Parameters::toggleOn)->getValue() >
                                           ParameterManager::OnOffThreshold;
                        break;
                    }
                    if (kwParam->paramID == Kwidget_XyPad::Parameters::onClick)
                    {
                        m_xypadTriggerOn = kw->getParameter(Kwidget_XyPad::Parameters::toggleOn)->getValue() >
                                           ParameterManager::OnOffThreshold;
 
                        if (m_xypadTriggerOn == true && m_globalAutoplayOn == false)
                        {
                            if (kwParam->getValue() > ParameterManager::OnOffThreshold &&
                                m_previousTriggerValue <= ParameterManager::OnOffThreshold)
                            {
                                m_synthPoly.noteOn(1, MIDI_NOTE_NUMBER_C3, 1.0f);
                                triggerRecordingStart();
                            }
                            else if (kwParam->getValue() <= ParameterManager::OnOffThreshold &&
                                     m_previousTriggerValue > ParameterManager::OnOffThreshold)
                            {
                                m_synthPoly.noteOff(1, MIDI_NOTE_NUMBER_C3, 1.0f, true);
                                triggerRecordingStop();
                            }
                            m_previousTriggerValue = kwParam->getValue();
                        }
                        break;
                    }
                }
            }
        }
    }
 
    AudioBuffer<float> KwidgetAudioProcessor::extractStereoBuffer(int numChannel1, int numChannel2,
                                                                  AudioBuffer<float>& multiChannelBuffer)
    {
        float* channels[2] = {multiChannelBuffer.getWritePointer(numChannel1),
                              multiChannelBuffer.getWritePointer(numChannel2)};
        AudioBuffer<float> buffer(channels, 2, 0, multiChannelBuffer.getNumSamples());
        return buffer;
    }
 
    void KwidgetAudioProcessor::autoPlayGlobalChanged(bool enableAutoplay)
    {
        if (m_globalAutoplayOn == enableAutoplay)
            return;
 
        if (enableAutoplay && !m_globalAutoplayOn)
        {
            // start autoplay limit timer
            auto autoplayMaxDurationValue = settingsFile.getSetting(autoPlayMaxDuration);
 
            // 180 second/3 minute fallback value
            int maxDuration = autoplayMaxDurationValue.isVoid() ? 180 : static_cast<int>(autoplayMaxDurationValue);
 
            startTimer(maxDuration * 1000);
 
            triggerRecordingStart();
 
            // trigger drone synth
            m_synthDrone.noteOn(1, MIDI_NOTE_FLAG_DRONE + MIDI_NOTE_NUMBER_C3, 1.0f);
        }
        else if (!enableAutoplay)
        {
            // stop recorder limit timer
            stopTimer();
 
            // Flush any playing drones
            m_synthDrone.noteOn(
                    1, MIDI_NOTE_FLAG_DRONE_NOTEUP + MIDI_NOTE_FLAG_FLUSH + MIDI_NOTE_FLAG_DRONE + MIDI_NOTE_NUMBER_C3,
                    1.0f);
 
            triggerRecordingStop();
        }
 
        m_globalAutoplayOn = enableAutoplay;
    }
 
    void KwidgetAudioProcessor::timerCallback()
    {
        autoPlayGlobalChanged(false);
 
        if (onAutoplayTimerStop != nullptr)
        {
            onAutoplayTimerStop();
        }
    }
 
    void KwidgetAudioProcessor::autoPlayChanged(Kwidget_CoreEngine* engine, float newValue)
    {
        auto thisID = engine->getKwidgetID();
        m_autoplay[thisID.toRawUTF8()] = (bool)(newValue > ParameterManager::OnOffThreshold);
    }
 
    void KwidgetAudioProcessor::loopEnableChanged(Kwidget_CoreEngine* /*engine*/, float /* newValue */) {}
 
    void KwidgetAudioProcessor::addKListener(KListener* l) { m_listeners.add(l); }
 
    void KwidgetAudioProcessor::removeKListener(KListener* l) { m_listeners.remove(l); }
 
    void KwidgetAudioProcessor::prepareToPlay(double sampleRate, int samplesPerBlock)
    {
        m_synthPoly.setCurrentPlaybackSampleRate(sampleRate);
        m_synthPoly.setSamePitchNoteStealingEnable(false);
        m_synthDrone.setCurrentPlaybackSampleRate(sampleRate);
        m_synthDrone.setNoteStealingEnabled(true);
        m_mainGraph.prepareToPlay(sampleRate, samplesPerBlock);
        m_modulatorGraph.prepareToPlay(sampleRate, samplesPerBlock);
        notifyAllKwidgetsParametersListeners(); // Refreshes all params, which will kickstart autoplay where selected
 
        for (auto& m_recorderTmp : m_recorders)
        {
            m_recorderTmp->getActiveVoice()->prepareToPlay(sampleRate, samplesPerBlock);
        }
 
        // prepare the Filter Processor
        m_masterFilter.get()->getActiveVoice()->prepareToPlay(sampleRate, samplesPerBlock);
 
        // prepare the Convolution Reverb Processor
        m_masterReverb.get()->getActiveVoice()->prepareToPlay(sampleRate, samplesPerBlock);
 
        if (m_globalAutoplayOn) // preparing the synth will turn off the note. Restore that now
        {
            m_synthDrone.noteOn(1, MIDI_NOTE_FLAG_DRONE + MIDI_NOTE_NUMBER_C3, /*velocity*/ 1.0f);
        }
    }
 
    void KwidgetAudioProcessor::processBlock(AudioBuffer<float>& buffer, MidiBuffer& midiMessages)
    {
        // We are not expecting audio input, clearing the buffer prevents
        // uninitialised audio buffers from being summed into our output.
        // For reference this was the fix for ticket "Additional output busses unusable/clipping VST3"
        // https://krotosltd.atlassian.net/browse/KST-2467
        buffer.clear();
 
        // render the synth
        m_synthPoly.processBlock(buffer, midiMessages);
 
        if (m_globalAutoplayOn == true) // XYPad and MIDI note
        {
            // clear input MIDIBuffer
            midiMessages.clear();
 
            // render the drone synth
            m_synthDrone.processBlock(buffer, midiMessages);
        }
 
        buffer.applyGain(Decibels::decibelsToGain<float>(
                3.f)); // Compensate for 3dB drop in output KST-824 TODO: Investigate further the root cause of the drop
 
        if (!bypassPostFx && m_audioOutFxEnabledParameter->get() > ParameterManager::OnOffThreshold)
        {
            // TODO: Address this properly by converting all KwidgetProcessors to multichannel instead of hardcoded
            // stereo and make krotos_dsp modules independent of number of channels when possible.
            auto stereoBufferTmp = extractStereoBuffer(0, 1, buffer);
            m_masterFilter.get()->getActiveVoice()->processBlock(stereoBufferTmp, midiMessages);
            m_masterReverb.get()->getActiveVoice()->processBlock(stereoBufferTmp, midiMessages);
        }
 
        // Record
        recordOutput(buffer, midiMessages);
    }
 
    void KwidgetAudioProcessor::recordOutput(AudioBuffer<float>& buffer, MidiBuffer& midiMessages)
    {
        // Split the main 10 channel  Buffer into smaller 5 2-channel Buffers , without copy
        int m_activeRecorders = 1; // just one active recorder (main out)
        for (int i = 0; i < m_activeRecorders; i++)
        {
            int chan = 2 * i;
            auto bufferTmp = extractStereoBuffer(chan, chan + 1, buffer);
            if (i > 1)
            {
                String s = String(KType::CoreEngine) + String(i - 1);
 
                if (m_autoplay[s.toRawUTF8()] == false)
                {
                    bufferTmp.clear();
                }
            }
            Kwidget_Recorder* recorder = m_recorderPtrs[i];
            recorder->handleMidiMessages(midiMessages);
            m_recorders[i]->getActiveVoice()->processBlock(bufferTmp, midiMessages);
        }
    }
 
    Kwidget* KwidgetAudioProcessor::addKwidgetWithID(const String& kwidgetType, const String& kwidgetID,
                                                     bool useEndParams, bool isChildKwidget)
    {
#if ENABLE_SANDBOX
        m_addedFromState = false;
#endif
        auto newKwidget = KwidgetFactory::createKwidget(kwidgetType, kwidgetID);
 
        auto newKwidgetPtr = newKwidget.get();
 
        if (!parameterManager.addKwidget(newKwidgetPtr, useEndParams, isChildKwidget))
            return nullptr;
 
        addKwidgetInternal(std::move(newKwidget));
        return newKwidgetPtr;
    }
 
    Kwidget* KwidgetAudioProcessor::addChildKwidget(const String& kwidgetType, const String& parentID,
                                                    const String& childID, int typeLimit)
    {
#if ENABLE_SANDBOX
        m_addedFromState = false;
#endif
        String baseKwidgetID = parentID + Kwidget::Constants::ChildDelimiter +
                               childID; // ... we indicate that this is a child by prefixing the supplied child ID with
                                        // our parent's ID, seperated by a ":"
        auto autoGeneratedkwidgetID = parameterManager.generateKwidgetID(
                baseKwidgetID, "", typeLimit); // This will modify baseKwidgetID to make it unique
 
        auto newKwidget = KwidgetFactory::createKwidget(kwidgetType, autoGeneratedkwidgetID);
        auto newKwidgetPtr = newKwidget.get();
 
        if (!parameterManager.addKwidget(newKwidgetPtr, false, true))
            return nullptr;
 
        addKwidgetInternal(std::move(newKwidget));
        newKwidgetPtr = m_kwidgets.getLast();
 
        return newKwidgetPtr;
    }
 
    Kwidget* KwidgetAudioProcessor::addUserKwidget(const String& kwidgetType, const String& idModifier,
                                                   int typeInstanceLimit)
    {
#if ENABLE_SANDBOX
        m_addedFromState = false;
#endif
        // Auto generate an ID for this Kwidget, based on its type, and a count of how many times this type has been
        // used
        String kwidgetID = parameterManager.generateKwidgetID(kwidgetType, idModifier, typeInstanceLimit);
 
        if (kwidgetID == "") // If a unique Kwidget ID meeting our requirements couldn't be generated ...
        {
            return nullptr; // ... then we return null kwidget
        }
 
        auto newKwidget = KwidgetFactory::createKwidget(kwidgetType, kwidgetID);
 
        if (newKwidget == nullptr)
        {
            jassertfalse;
            return nullptr; // Failed to create kwidget
        }
 
        auto newKwidgetPtr = newKwidget.get();
 
        if (!parameterManager.addKwidget(newKwidgetPtr))
        {
            jassertfalse;
            return nullptr; // Failed to add kwidget
        }
 
        if (auto coreEngineKwidget = dynamic_cast<Kwidget_CoreEngine*>(newKwidgetPtr))
        {
            coreEngineKwidget->canReadSpecificFiles(m_readSpecificFiles);
        }
        else if (auto reformerKwidget = dynamic_cast<Kwidget_Reformer*>(newKwidgetPtr))
        {
            reformerKwidget->canReadSpecificFiles(m_readSpecificFiles);
        }
 
        addKwidgetInternal(std::move(newKwidget));
 
        // fetch updated ptr after std::move
        newKwidgetPtr = m_kwidgets.getLast();
 
        makeStaticConnectionsForKwidget(newKwidgetPtr);
        // Call this method in the kwidget we just created to allow it to create child kwidgets
        newKwidgetPtr->createNestedKwidgets(*this);
 
        // Register this processor as Listener to the CoreEgine solo
        if (auto coreEngineKwidget = dynamic_cast<Kwidget_CoreEngine*>(newKwidgetPtr))
        {
            // Register the KwidgetAudioProcessor as a Listener to the mute
            coreEngineKwidget->addListener(this);
        }
        else if (auto reformerKwidget = dynamic_cast<Kwidget_Reformer*>(newKwidgetPtr))
        {
            // Register the KwidgetAudioProcessor as a Listener to the mute
            reformerKwidget->addListener(this);
        }
 
        return newKwidgetPtr;
    }
 
    void KwidgetAudioProcessor::removeKwidget(const String& kwidgetID)
    {
        if (m_kwidgetLookup.count(kwidgetID) == 1)
        {
            auto kwidget = m_kwidgetLookup.at(kwidgetID);
 
            // Remove listener from the XyPad's Kwidget_XyPad::Parameters::onClick parameter Listeners list
            if (auto xyPadKwidget = dynamic_cast<Kwidget_XyPad*>(kwidget))
            {
                xyPadKwidget->getParameter(Kwidget_XyPad::Parameters::onClick)->removeListener(this);
                xyPadKwidget->getParameter(Kwidget_XyPad::Parameters::toggleOn)->removeListener(this);
                xyPadKwidget->setKwidgetAudioProcessorReference(nullptr);
            }
            else if (auto triggerButtonKwidget = dynamic_cast<Kwidget_TriggerButton*>(kwidget))
            {
                triggerButtonKwidget->removeListener(this);
            }
 
            // Unregister this processor as listener to the CoreEngine solo
            if (auto coreEngineKwidget = dynamic_cast<Kwidget_CoreEngine*>(kwidget))
                coreEngineKwidget->removeListener(this);
 
            // Remove all the kwidgets children
            std::vector<Kwidget*>& children = kwidget->getChildKwidgets();
 
            // change to remove backwards so that it doesn't fail checking an already deleted kwidget
            for (int i = static_cast<int>(children.size()) - 1; i >= 0; i--)
            {
                removeKwidget(children.at(i)->getKwidgetID());
            }
 
            children.clear(); // Clear the refences as they no longer exist
 
            parameterManager.removeKwidget(kwidgetID);
 
            m_listeners.call([kwidget](KListener& l) { l.kwidgetRemoved(kwidget); });
 
            m_kwidgets.removeFirstMatchingValue(kwidget);
 
            m_kwidgetLookup.erase(kwidgetID);
 
            if (kwidget->isModulator())
                m_modulatorGraph.removeKwidget(kwidget);
            else
                m_mainGraph.removeKwidget(kwidget);
 
            // Tell the host to recheck the names, values, etc. of its parameters
            // to make it stop showing the old Kwidget's parameters.
            updateHostDisplay();
        }
        else
        {
            jassertfalse; // hit this assert trying to remove a kwidget which doesn't exist in m_kwidgetLookup
        }
    }
 
    void KwidgetAudioProcessor::removeDynamicKwidgets() { removeKwidgetsExcluding({}); }
 
    void KwidgetAudioProcessor::removeKwidgetsExcluding(const StringArray& kwidgetsToExclude)
    {
        std::vector<Kwidget*> kwidgetsToRemove;
 
        for (auto& k : m_kwidgets)
        {
            auto id = k->getKwidgetID();
            auto type = k->getKwidgetType();
 
            if (!kwidgetsToExclude.contains(id) && !k->isAChildKwidget() && !isAStaticKwidget(*k))
            {
                // Don't remove excluded or child kwidgets
                kwidgetsToRemove.push_back(k);
            }
        }
 
        for (auto& k : kwidgetsToRemove)
        {
            removeKwidget(k->getKwidgetID());
        }
    }
 
    void KwidgetAudioProcessor::removeKwidgetsOfType(const StringArray& kwidgetTypesToRemove)
    {
        std::vector<Kwidget*> kwidgetsToRemove;
 
        for (auto& k : m_kwidgets)
        {
            auto kType = k->getKwidgetType();
            if ((kwidgetTypesToRemove.contains(kType)) && !isAStaticKwidget(*k) &&
                (!k->isAChildKwidget())) // Don't remove excluded or child kwidgets
                kwidgetsToRemove.push_back(k);
        }
 
        for (auto& k : kwidgetsToRemove)
        {
            removeKwidget(k->getKwidgetID());
        }
    }
 
    const bool KwidgetAudioProcessor::isAStaticKwidget(const Kwidget& kwidget)
    {
        bool isStatic = isAStaticKwidgetType(kwidget.getKwidgetType());
        isStatic |= StaticKwidgetIDs.contains(kwidget.getKwidgetID());
        return isStatic;
    }
 
    bool KwidgetAudioProcessor::addConnection(const String& sourceID, const String& destID)
    {
        if (!m_kwidgetLookup.count(sourceID))
        {
            // Couldn't find source Kwidget
            jassertfalse;
            return false;
        }
 
        if (!m_kwidgetLookup.count(destID))
        {
            // Couldn't find destination Kwidget
            jassertfalse;
            return false;
        }
 
        auto src = m_kwidgetLookup.at(sourceID);
        auto dest = m_kwidgetLookup.at(destID);
 
        // Modulator Kwidgets should not have any audio connections.
        jassert(!src->isModulator() && !dest->isModulator());
 
        if (!m_mainGraph.canConnect(src, dest))
        {
            jassertfalse;
            return false;
        }
 
        parameterManager.addConnection(sourceID, destID);
 
        return true;
    }
 
    bool KwidgetAudioProcessor::makeStaticConnectionsForKwidget(Kwidget* kwidget)
    {
        // Define any static audio connections that a specific kwidget requires here...
 
        bool retVal = true;
 
        if (kwidget != nullptr)
        {
            auto kwidgetID = kwidget->getKwidgetID();
 
            // Core engine multi-out configuration based on "Tab" ID prefix
 
#if ENABLE_SANDBOX
            if (kwidgetID.contains(KwidgetFactory::KwidgetModifiers::SandBox))
                return false;
#endif
#if ENABLE_REFORMER
            if ((kwidget->getKwidgetType() == KType::CoreEngine) || (kwidget->getKwidgetType() == KType::Reformer))
#else
            if (kwidget->getKwidgetType() == KType::CoreEngine)
#endif
            {
                auto masterOutID = m_masterAudioOut->getKwidgetID();
 
                // Kwidget IDs containing a "TabX" prefix are routed to X audio
                // out e.g. "Tab2CoreEngine1" would be routed to audio out 2
                if (kwidgetID.startsWith("Tab"))
                {
                    int tabIndex = kwidgetID.substring(3, 4).getIntValue();
 
                    retVal &= addConnection(kwidgetID, masterOutID); // Connection to main stereo bus
                    retVal &= addConnection(kwidgetID,
                                            m_audioOuts[tabIndex]->getKwidgetID()); // Connection to individual bus
                }
                // Backwards compatability with older presets. As a fallback,
                // route to master and bus 1.
                else
                {
                    retVal &= addConnection(kwidgetID, masterOutID);
                    retVal &= addConnection(kwidgetID, m_audioOuts[1]->getKwidgetID());
                }
            }
        }
        return retVal;
    }
 
    /* TODO: this function is a bit problematic in that its a special case where we don't want to clear modulation for
     QuickFX It would be much better if this was its own contained unit, instead of mixed in with the dynamic
     connections I have added a nullptr check to the QuickFX related Kwidget for now in case it doesn't exist */
    void KwidgetAudioProcessor::clearModulation()
    {
        if (m_intensityMacro != nullptr)
        {
            parameterManager.clearModulationExcept(m_intensityMacro.get()->getKwidgetID());
        }
        else
        {
            parameterManager.clearModulation();
        }
    }
 
    void KwidgetAudioProcessor::loadBundle(const File& bundleDir)
    {
        auto presetFile = PresetBundler::getPresetFromBundleDirectory(bundleDir);
        presetManager.setCurrentPreset(presetFile);
    }
 
    bool KwidgetAudioProcessor::setState(const ValueTree& newState)
    {
        PresetLoadRequest loadRequest;
        loadRequest.newState = const_cast<ValueTree&>(newState);
        loadRequest.presetFile = presetManager.getCurrentPreset().path;
        auto loadResponse = m_presetEventMiddleware.processPresetLoad(loadRequest);
        if (!loadResponse.success)
        {
            DBG(loadResponse.message);
            jassertfalse;
        }
 
        // validate incoming state - aborts detected failed state loads that cannot be repaired
        auto validationSuccess = validateState(newState, /*enable incoming state repair*/ true);
 
        if (!validationSuccess)
            return false;
 
        // stop kwidget_recorder recordings
        for (int i = 0; i < m_numRecorders; i++)
        {
            auto recorderProcessor = dynamic_cast<KwidgetProcessor_Recorder*>(m_recorderPtrs[i]->getActiveVoice());
            recorderProcessor->stopRecording();
        }
 
        suspendProcessing(true);
 
        parameterManager.clearConnections();
        clearModulation();
        removeDynamicKwidgets();
 
        auto kwidgetTree = newState.getChildWithName(XmlType::Tag::kwidgets);
 
        // Cache the master AudioOut tree state for later - this is a static kwidget whose state we do want to recall
        // manually...
        auto masterAudioOutTree =
                kwidgetTree.getChildWithProperty(XmlType::Property::id, m_masterAudioOut->getKwidgetID());
        // cache master Filter tree state for later
        auto masterFilterTree =
                kwidgetTree.getChildWithProperty(XmlType::Property::id, m_masterFilter.get()->getKwidgetID());
        // cache master Reverb tree state for later
        auto masterReverbTree =
                kwidgetTree.getChildWithProperty(XmlType::Property::id, m_masterReverb.get()->getKwidgetID());
 
        // Remove static Kwidgets from the incoming state tree
        for (int i = 0; i < StaticKwidgetTypes.size(); ++i)
        {
            auto staticKwidgetTree = kwidgetTree.getChildWithProperty(XmlType::Property::type, StaticKwidgetTypes[i]);
            kwidgetTree.removeChild(staticKwidgetTree, nullptr);
        }
 
        auto intensityMacroTree =
                kwidgetTree.getChildWithProperty(XmlType::Property::id, m_intensityMacro.get()->getKwidgetID());
        kwidgetTree.removeChild(intensityMacroTree, nullptr);
 
        // PresetMenu last loaded preset logic TODO: this stuff needs its own class/functions, required for KS preset
        // menu!
        ValueTree customDataTree = newState.getChildWithName(XmlType::Tag::customData);
        if (customDataTree.isValid())
        {
            auto lastLoadedPreset = customDataTree.getChildWithName(XmlType::Tag::LastLoadedPreset);
            if (lastLoadedPreset.isValid())
            {
                m_lastLoadedPresetPath =
                        lastLoadedPreset.getProperty(XmlType::Property::LastLoadedPresetName).toString();
                if (m_lastLoadedPresetPath.isEmpty())
                {
                    m_lastLoadedPresetPath = m_initPresetPath;
                }
                presetInfoTree->setProperty(krotos::XmlType::Property::LastLoadedPresetName, m_lastLoadedPresetPath,
                                            nullptr);
            }
        }
 
        parameterManager.getCustomDataTree().copyPropertiesAndChildrenFrom(
                newState.getChildWithName(XmlType::Tag::customData), nullptr);
 
        // Add new Kwidgets for each saved state remaining in the tree
        for (const auto& kwidget : kwidgetTree)
        {
            // TODO: factor out this exception to which kwidgets get added - it's one of those special cases we want to
            // get rid of
 
            String kwidgetType = kwidget.getProperty(XmlType::Property::type);
            // Don't add static kwidgets as these are instantiated manually.
            if (!isAStaticKwidgetType(kwidgetType))
            {
                addKwidgetFromState(kwidget);
            }
        }
 
        parameterManager.setCurrentState(newState);
 
        // Manually set state of master audio out, as it contains the autoplay parameters.
        m_masterAudioOut->setState(masterAudioOutTree, *this);
        m_masterFilter->setState(masterFilterTree, *this);
        m_masterReverb->setState(masterReverbTree, *this);
        m_intensityMacro->setState(intensityMacroTree, *this);
 
#if ENABLE_SANDBOX
        addConnection(m_audioOutSandBox->getKwidgetID(), m_masterAudioOut->getKwidgetID());
#endif
        // Update recorder kwidgets to have the latest preset name for drag and drop file naming
        const String presetName =
                File::createFileWithoutCheckingPath(m_lastLoadedPresetPath).getFileNameWithoutExtension();
        setRecordersNameData(presetName);
 
        // Resume processing
        suspendProcessing(false);
 
        // By the time we get here we have created all the kwidgets which are represented in the state
        // and all the kparams created by these kwidgets will have had their values set from state
        // When the value is set from state a value changed callback will be made to any listeners which have registered
        // The modulation system means that any given kwidget processor may be listening for changes made to parameters
        // owned by another kwidget Kwidgets are created in order - any kwidget processor set up to listen to another
        // kwidget's param will not get the initial value changed callback if it was created after the sending kwidget
        // was created For that reason we send out another value changed message from every param, once all kwidgets and
        // connections are made:
 
        notifyAllKwidgetsParametersListeners();
 
        return true;
    }
 
    bool KwidgetAudioProcessor::validateState(const ValueTree& newState, bool repairEnabled)
    {
        auto paramTreeGeneric = newState.getChildWithName(XmlType::Tag::params);
 
        bool noFailures = parameterManager.initialiseLinkIndexUsageTable(newState, repairEnabled);
 
        noFailures &= parameterManager.initialiseKwidgetIDUsageTable(newState, repairEnabled);
 
        auto kwidgetTree = newState.getChildWithName(XmlType::Tag::kwidgets);
 
        // test that kwidget sub-trees in incoming state are valid
        for (auto kwidget : kwidgetTree)
        {
            noFailures &= parameterManager.validateKwidgetState(kwidget, paramTreeGeneric, repairEnabled);
            auto childKwidgetTree = kwidget.getChildWithName(XmlType::Tag::kwidgets);
            for (auto ckwidget : childKwidgetTree) // For every child kwidget
            {
                noFailures &= parameterManager.validateKwidgetState(ckwidget, paramTreeGeneric, repairEnabled);
            }
        }
 
        return noFailures;
    }
 
    void KwidgetAudioProcessor::notifyAllKwidgetsParametersListeners()
    {
        for (auto& kwidget : m_kwidgets) // For every kwidget ...
        {
            kwidget->notifyAllParametersListeners();
        }
    }
 
    ValueTree KwidgetAudioProcessor::getState()
    {
        for (const auto& k : m_kwidgetLookup)
            k.second->flushState();
 
        m_masterAudioOut->flushState();
 
        return parameterManager.getState().createCopy();
    }
 
    const Array<Kwidget*>& KwidgetAudioProcessor::getKwidgets() { return m_kwidgets; }
 
    Kwidget* KwidgetAudioProcessor::getKwidget(const String& kwidgetID)
    {
        if (kwidgetID.contains(":") == true)
        {
            // this is a child kwidget we must find the parent and then get the kwidget
            int parentIDIndex = kwidgetID.indexOf(Kwidget::Constants::ChildDelimiter);
            if (parentIDIndex > 0)
            {
                String parentID = kwidgetID.substring(0, parentIDIndex);
 
                if (m_kwidgetLookup.count(parentID) > 0)
                {
                    return m_kwidgetLookup.at(parentID)->findChildKwidget(kwidgetID);
                }
            }
        }
        // jassert(m_kwidgetLookup.count(kwidgetID) == 1);
        if (m_kwidgetLookup.count(kwidgetID) > 0)
        {
            return m_kwidgetLookup.at(kwidgetID);
        }
        else
        {
            return nullptr;
        }
    }
 
#if ENABLE_REFORMER
    const Array<Kwidget*> KwidgetAudioProcessor::getKwidgetsOfType(const String kwidgetType)
    {
        Array<Kwidget*> typedKwidgets;
 
        // Loop though all the kwidgets in the system
        for (auto& kwidget : m_kwidgets)
        {
            if (kwidget->getKwidgetType() == kwidgetType)
            {
                typedKwidgets.add(kwidget);
            }
        }
 
        return typedKwidgets;
    }
 
    const Array<Kwidget*> KwidgetAudioProcessor::getKwidgetsOfTypeWithAccessPermission(const StringRef kwidgetType,
                                                                                       const StringRef reqId)
    {
        Array<Kwidget*> typedKwidgets;
 
        // Loop though all the kwidgets in the system
        for (auto& kwidget : m_kwidgets)
        {
            if (kwidget->getKwidgetType() == kwidgetType)
            {
                // If we are graanted access
                if (kwidget->requestAccess(reqId))
                {
                    typedKwidgets.add(kwidget);
                }
            }
        }
 
        return typedKwidgets;
    }
 
    Kwidget* KwidgetAudioProcessor::getKwidgetWithAccessPermission(const String& kwidgetID, const StringRef reqId)
    {
        // Critical section here in case kwidget deleted on another thread before
        // access granted
        const juce::ScopedLock scopedLock(m_lock);
 
        auto kwidget = getKwidget(kwidgetID);
 
        // If the kwidget was found
        if (kwidget != nullptr)
        {
            // And we are graanted access
            if (kwidget->requestAccess(reqId))
            {
                return kwidget;
            }
        }
 
        return nullptr;
    }
#endif
 
    void KwidgetAudioProcessor::getStateInformation(MemoryBlock& destData)
    {
        auto currentState = getState();
 
        // get custom data tree
        auto customData = currentState.getChildWithName(XmlType::Tag::customData);
        if (customData.isValid())
        {
            // see if last preset field exists
            auto lastPresetField = customData.getChildWithName(XmlType::Tag::LastLoadedPreset);
            if (lastPresetField.isValid())
            {
                // update its property
                lastPresetField.setProperty(krotos::XmlType::Property::LastLoadedPresetName, m_lastLoadedPresetPath,
                                            nullptr);
            }
            else
            {
                // inject if does not exist
                if (presetInfoTree != nullptr) // error check in case there is no preset
                {
                    auto m_vtCopy = presetInfoTree->createCopy();
                    m_vtCopy.setProperty(XmlType::Property::LastLoadedPresetName, m_lastLoadedPresetPath, nullptr);
                    customData.appendChild(m_vtCopy, nullptr);
                }
            }
        }
        std::unique_ptr<XmlElement> xml(currentState.createXml());
        copyXmlToBinary(*xml, destData);
    }
 
    void KwidgetAudioProcessor::setStateInformation(const void* incomingData, int sizeInBytes)
    {
        std::unique_ptr<XmlElement> xmlState(getXmlFromBinary(incomingData, sizeInBytes));
        if (xmlState.get() != nullptr)
        {
            auto stateFromXML = ValueTree::fromXml(*xmlState);
 
            auto setNewStateSuccess = setState(stateFromXML);
 
            // lets test incoming state from DAW
            if (!setNewStateSuccess)
            {
                // notify user if session state fails validation
                PresetManagerUI::alertStateValidation();
            }
            else
            {
                // only stop init.ksp loading if validation successful
                m_shouldInit = false;
            }
        }
    }
 
    void KwidgetAudioProcessor::setLastPresetPath(String lastLoadedPresetPath)
    {
        m_lastLoadedPresetPath = lastLoadedPresetPath;
    }
 
    String& KwidgetAudioProcessor::getLastPresetPath() { return m_lastLoadedPresetPath; }
 
    const String KwidgetAudioProcessor::getName() const { return JucePlugin_Name; }
    bool KwidgetAudioProcessor::acceptsMidi() const { return true; }
    bool KwidgetAudioProcessor::producesMidi() const { return true; }
    bool KwidgetAudioProcessor::isMidiEffect() const { return false; }
    double KwidgetAudioProcessor::getTailLengthSeconds() const { return 0.0; }
    int KwidgetAudioProcessor::getNumPrograms() { return 1; }
    int KwidgetAudioProcessor::getCurrentProgram() { return 0; }
    void KwidgetAudioProcessor::setCurrentProgram(int) {}
    const String KwidgetAudioProcessor::getProgramName(int) { return {}; }
    void KwidgetAudioProcessor::changeProgramName(int, const String&) {}
    bool KwidgetAudioProcessor::isBusesLayoutSupported(const BusesLayout&) const { return true; }
 
    Kwidget* KwidgetAudioProcessor::addKwidgetFromState(const ValueTree& kwidgetToAdd)
    {
#if ENABLE_SANDBOX
        m_addedFromState = true;
#endif
        auto kwidgetTree = kwidgetToAdd.createCopy();
 
        KwidgetLoadRequest loadRequest;
        loadRequest.kwidgetTree = kwidgetTree;
        auto loadResponse = m_presetEventMiddleware.processKwidgetLoad(loadRequest);
        if (loadResponse.success)
        {
            kwidgetTree = loadRequest.kwidgetTree;
        }
        else
        {
            DBG("Event middleware failed to execute: \n\t" << loadResponse.message);
            jassertfalse;
        }
 
        String kwidgetType = kwidgetTree[XmlType::Property::type].toString();
 
        // Create the Kwidget object, which will have a default state
        auto kwidgetID = kwidgetTree[XmlType::Property::id].toString();
        auto newKwidget = KwidgetFactory::createKwidget(kwidgetType, kwidgetID);
 
        // Get the raw pointer for use where raw ptrs are required as arguments.
        auto newKwidgetPtr = newKwidget.get();
 
        if (auto coreEngineKwidget = dynamic_cast<Kwidget_CoreEngine*>(newKwidgetPtr))
        {
            coreEngineKwidget->canReadSpecificFiles(m_readSpecificFiles);
        }
        else if (auto reformerKwidget = dynamic_cast<Kwidget_Reformer*>(newKwidgetPtr))
        {
            reformerKwidget->canReadSpecificFiles(m_readSpecificFiles);
        }
 
        // Copy the values from the saved state in to the Kwidget state.
        newKwidget->setState(kwidgetTree, *this);
 
        // Is the Kwidget being added a Kwidget_CoreEngine ?
        if (auto coreEngineKwidget = dynamic_cast<Kwidget_CoreEngine*>(newKwidgetPtr))
        {
            // If so, we register as a Listener to the Kwidget_CoreEngine's solo button [SOLO]
            coreEngineKwidget->addListener(this);
        }
 
        // Is the Kwidget being added a Kwidget_Reformer ?
        if (auto reformerKwidget = dynamic_cast<Kwidget_Reformer*>(newKwidgetPtr))
        {
            // If so, we register as a Listener to the Kwidget_Reformer's solo button [SOLO]
            reformerKwidget->addListener(this);
        }
 
        parameterManager.addKwidget(newKwidgetPtr, false, newKwidget->isAChildKwidget());
 
        // Add to the processor, transferring ownership
        addKwidgetInternal(std::move(newKwidget));
 
        newKwidgetPtr = m_kwidgets.getLast(); // update ptr after move
 
        makeStaticConnectionsForKwidget(newKwidgetPtr);
 
        newKwidgetPtr->createNestedKwidgets(*this);
 
        return newKwidgetPtr;
    }
 
    void KwidgetAudioProcessor::addKwidgetInternal(std::unique_ptr<Kwidget> kwidget)
    {
        auto kwidgetPtr = kwidget.get();
 
        // Set up XY pad listeners for note trigger etc.
        if (kwidget->getKwidgetType().contains(KType::XyPad))
        {
            Kwidget_XyPad* xyPadKwidget = dynamic_cast<Kwidget_XyPad*>(kwidgetPtr);
            xyPadKwidget->getParameter(Kwidget_XyPad::Parameters::onClick)->addListener(this);
            xyPadKwidget->getParameter(Kwidget_XyPad::Parameters::toggleOn)->addListener(this);
            xyPadKwidget->setKwidgetAudioProcessorReference(this);
        }
        else if (kwidget->getKwidgetType().contains(KType::TriggerButton))
        {
            Kwidget_TriggerButton* triggerButton = dynamic_cast<Kwidget_TriggerButton*>(kwidgetPtr);
            triggerButton->addListener(this);
        }
 
        if (kwidget->isModulator())
            m_modulatorGraph.addKwidget(std::move(kwidget));
        else
            m_mainGraph.addKwidget(std::move(kwidget));
 
        m_kwidgets.add(kwidgetPtr);
        m_kwidgetLookup[kwidgetPtr->getKwidgetID()] = kwidgetPtr;
 
        m_listeners.call([kwidgetPtr](KListener& l) { l.kwidgetAdded(kwidgetPtr); });
 
        // Tell the host to recheck the names, values, etc. of its parameters
        // to make it show the new Kwidget's parameters
        updateHostDisplay();
    }
 
    void KwidgetAudioProcessor::initialiseStateListeners()
    {
        const auto& connectionTree = parameterManager.getState().getChildWithName(XmlType::Tag::connections);
 
        m_connectionAttachment.reset(new ValueTreeAttachment(connectionTree));
 
        m_connectionAttachment->onChildAdded = [this](ValueTree& /*parent*/, ValueTree& child) {
            // Connect together the audio from two Kwidgets
 
            auto src = getKwidget(child[XmlType::Property::source].toString());
            auto dest = getKwidget(child[XmlType::Property::destination].toString());
 
            jassert(src != NULL);
            jassert(dest != NULL);
 
            if (MessageManager::getInstance()->isThisTheMessageThread())
            {
                // Connections between kwidgets are implied to be stereo
                // so the number of channels is hardwired here
                // to make this hard wired value appear nearer the start of this chain of events
                // would involve giving the paramter manager knowledge of kwidget channel needs
                // I'm going to leave it here from the moment before I end up refactoring the entire plugin with
                // no design. TODO look at where the number of channels in a kwidget is defined when we do the big
                // refactor
                m_mainGraph.addConnection(src, dest, 0, m_channelsPerStereoBus);
            }
            else
            {
                MessageManager::callAsync(
                        [this, src, dest]() { m_mainGraph.addConnection(src, dest, 0, m_channelsPerStereoBus); });
            }
        };
 
        m_connectionAttachment->onChildRemoved = [this](ValueTree& /*parent*/, ValueTree& child) {
            auto src = getKwidget(child[XmlType::Property::source].toString());
            auto dest = getKwidget(child[XmlType::Property::destination].toString());
            m_mainGraph.removeConnection(src, dest);
        };
 
        const auto& modulationTree = parameterManager.getState().getChildWithName(XmlType::Tag::modulations);
        m_modulationAttachment.reset(new ValueTreeAttachment(modulationTree));
 
        m_modulationAttachment->onChildAdded = [this](ValueTree& /*parent*/, ValueTree& child) {
            auto src = getKwidget(child[XmlType::Property::source].toString());
            auto dest = getKwidget(child[XmlType::Property::destination].toString());
            auto paramID = child[XmlType::Property::param].toString();
            auto idx = int(child[XmlType::Property::modulatorIndex]);
            auto depth = child[XmlType::Property::depth];
            auto polarity = int(child[XmlType::Property::polarity]);
 
            dest->addModulator(paramID, src, idx, depth, static_cast<KAttachment::Polarity>(polarity));
 
            auto depthParam = new CustomParameter(child, XmlType::Property::depth, parameterManager.getUndoManager());
            auto polarityParam =
                    new CustomParameter(child, XmlType::Property::polarity, parameterManager.getUndoManager());
 
            depthParam->valueChanged = [=](const var& newDepth) {
                dest->setModulatorDepth(paramID, src, idx, newDepth);
            };
 
            polarityParam->valueChanged = [=](const var& newPolarity) {
                dest->setModulatorPolarity(paramID, src, idx, static_cast<KAttachment::Polarity>((int)newPolarity));
            };
 
            m_modulationInstances.add(depthParam);
            m_modulationInstances.add(polarityParam);
        };
 
        m_modulationAttachment->onChildRemoved = [this](ValueTree& /*parent*/, ValueTree& child) {
            auto src = getKwidget(child[XmlType::Property::source].toString());
            auto dest = getKwidget(child[XmlType::Property::destination].toString());
            auto paramID = child[XmlType::Property::param].toString();
            auto idx = int(child[XmlType::Property::modulatorIndex]);
 
            for (auto inst : m_modulationInstances)
            {
                if (inst->getParameterTree() == child)
                {
                    m_modulationInstances.removeObject(inst);
                    break;
                }
            }
 
            dest->removeModulator(paramID, src, idx);
        };
    }
 
    bool KwidgetAudioProcessor::isRecording()
    {
        m_isRecording = false;
 
        for (int i = 0; i < m_numRecorders; i++)
        {
            if (m_recorderPtrs[i]->getActive() == true)
            {
                m_isRecording = true;
                break;
            }
        }
        return m_isRecording;
    }
 
    void KwidgetAudioProcessor::onClickChanged(Kwidget_TriggerButton* /*triggerButton*/, float newValue,
                                               MIDIMode midiModeValue)
    {
        if (newValue > ParameterManager::OnOffThreshold)
        {
            // Account for all notes enum value
            m_synthPoly.noteOn(1, MIDI_NOTE_NUMBER_C3 + static_cast<int>(midiModeValue) - 1, 1.0f);
            triggerRecordingStart();
        }
        else
        {
            // Account for all notes enum value
            m_synthPoly.noteOff(1, MIDI_NOTE_NUMBER_C3 + static_cast<int>(midiModeValue) - 1, 1.0f, true);
 
            // only stop recording if autoplay is not currently in use
            if (m_masterAudioOut->getParameter(Kwidget_AudioOut::Parameters::Autoplay)->get() <=
                ParameterManager::OnOffThreshold)
            {
                triggerRecordingStop();
            }
        }
    }
 
    void KwidgetAudioProcessor::setReadSpecificFiles(bool canRead)
    {
        for (auto* kwidget : getKwidgets())
        {
            if (kwidget->getKwidgetType() == KType::CoreEngine)
            {
                dynamic_cast<Kwidget_CoreEngine*>(kwidget)->canReadSpecificFiles(canRead);
            }
#if ENABLE_REFORMER
            else if (kwidget->getKwidgetType() == KType::Reformer)
            {
                dynamic_cast<Kwidget_Reformer*>(kwidget)->canReadSpecificFiles(canRead);
            }
#endif
        }
 
        m_readSpecificFiles = canRead;
    }
 
    void KwidgetAudioProcessor::setRecordersNameData(String newPresetName)
    {
        for (auto& recorder : m_recorderPtrs)
        {
            if (recorder)
            {
                recorder->setPresetName(newPresetName);
            }
        }
    }
} // namespace krotos