Kwidget_Recorder.cpp

Go to the documentation of this file.

namespace krotos
{
    Kwidget_Recorder::Kwidget_Recorder(const String& id) : Kwidget("Recorder", id)
    {
        // CustomParameters can be used to store strings in the Kwidget's state.
        //        auto& param = *createAndAddCustomParameter(Parameters::Custom, "");
        //        param.valueChanged = [this](const var& /*value*/)
        //        {
        //            // do something
        //        };
 
        // This must be called after all custom parameters are added.
        init();
 
        // Parameter callbacks can be added to deal with parameter changes at the Kwidget level, instead
        // of having each KwidgetProcessor voice apply the changes separately. This function must be called
        // after init().
        //        addParameterCallback(Parameters::Example, [this](float /*newValue*/)
        //        {
        //            // do something
        //        });
 
        m_active = false;
        m_draggable = false;
        m_activeVoices = 0;
 
        const String nameFormatSetting(KwidgetAudioProcessor::DroppedFileNameFormat);
        const String nameFormatString = KwidgetAudioProcessor::settingsFile.getSetting(nameFormatSetting);
        m_recordDragAndDropName.setNameFormat(nameFormatString);
    }
 
    void Kwidget_Recorder::addListener(Listener* listenerToAdd) { m_listeners.add(listenerToAdd); }
 
    void Kwidget_Recorder::removeListener(Listener* listenerToRemove)
    {
        if (!m_listeners.contains(listenerToRemove))
            return;
        m_listeners.remove(listenerToRemove);
    }
 
    void Kwidget_Recorder::setPresetName(String newPresetName) { m_recordDragAndDropName.setPresetName(newPresetName); }
 
    void Kwidget_Recorder::setPerformingState(bool isPerforming)
    {
        m_listeners.call([isPerforming](Listener& l) { l.notifyPerformingState(isPerforming); });
    }
 
    void Kwidget_Recorder::setFinishedPerformingState(bool isFinishedPerforming)
    {
        m_listeners.call(
                [isFinishedPerforming](Listener& l) { l.notifyFinishedPerformingState(isFinishedPerforming); });
    }
 
    void Kwidget_Recorder::triggerRecordingStateListenerCallback() { setPerformingState(m_active); }
 
    void Kwidget_Recorder::setActive(bool activeState)
    {
        m_active = activeState;
        setPerformingState(m_active);
    }
 
    void Kwidget_Recorder::setDraggable(bool isDraggable)
    {
        m_draggable = isDraggable;
        setFinishedPerformingState(m_draggable);
    }
 
    std::vector<Kwidget::ParameterInfo> Kwidget_Recorder::createParameters()
    {
        return {
                //            { Parameters::Example, Parameters::Example, { 0.0f, 1.0f }, 0.0f }
        };
    }
 
    std::unique_ptr<KwidgetProcessor> Kwidget_Recorder::createProcessor()
    {
        return std::make_unique<KwidgetProcessor_Recorder>(*this);
    }
 
    std::unique_ptr<KwidgetGUI> Kwidget_Recorder::createGUI() { return std::make_unique<KwidgetGUI_Recorder>(*this); }
 
    String Kwidget_Recorder::getTopFilename()
    {
        if (!m_dragAndDropFilenames.isEmpty())
        {
            return *m_dragAndDropFilenames.getLast();
        }
 
        return "";
    }
 
    void Kwidget_Recorder::handleMidiMessages(MidiBuffer& midiMessages)
    {
        // for (auto metaData : midiMessages.data)
        MidiBufferIterator iter = midiMessages.cbegin();
        while (iter != midiMessages.cend())
        {
            auto metadata = *iter;
            auto m = metadata.getMessage();
            const int channel = m.getChannel();
 
            if (m.isNoteOn())
            {
                getActiveVoice()->noteOn(m.getNoteNumber(), m.getFloatVelocity());
                m_activeVoices++;
            }
            else if (m.isNoteOff())
            {
                getActiveVoice()->noteOff(m.getFloatVelocity());
                m_activeVoices--;
            }
            iter++;
        }
    }
 
    File Kwidget_Recorder::fetchRecordedFile()
    {
        String sourceFilename = getTopFilename();
 
        if (sourceFilename == "")
        {
            // did not return a fileName
            File empty("");
            return empty;
        }
 
        File source(sourceFilename);
 
        // create filename
        const String filename = m_recordDragAndDropName.getNextName();
        String outputFilename = File::addTrailingSeparator(AssetManager::readDragAndDropPath()) + filename;
 
        File outputFile(outputFilename);
 
        source.copyFileTo(outputFile);
        return outputFile;
    }
} // namespace krotos