SampleDataTree.cpp

Go to the documentation of this file.

namespace krotos
{
    const Identifier SamplesTree::Type::Samples{"SAMPLES"};
    const Identifier SamplesTree::Type::Sample{"SAMPLE"};
 
    const Identifier SamplesTree::Property::Name{"name"};
    const Identifier SamplesTree::Property::Path{"path"};
    const Identifier SamplesTree::Property::Selection{"selection"};
    const Identifier SamplesTree::Property::Mute{"mute"};
    const Identifier SamplesTree::Property::Solo{"solo"};
    const Identifier SamplesTree::Property::SampleIndex{"sample_index"};
    const Identifier SamplesTree::Property::SelectedSample{"selected_sample"};
 
    SamplesTree::SamplesTree()
        : CustomParameterTree(Type::Samples),
          sampleIndexValue(m_parameterTree, Property::SampleIndex, getUndoManager()),
          selectedSampleValue(m_parameterTree, Property::SelectedSample, getUndoManager())
    {
    }
 
    SamplesTree::SamplesTree(const Identifier& type)
        : CustomParameterTree(type), sampleIndexValue(m_parameterTree, Property::SampleIndex, getUndoManager()),
          selectedSampleValue(m_parameterTree, Property::SelectedSample, getUndoManager())
    {
    }
 
    SamplesTree::SamplesTree(const SamplesTree& other)
        : CustomParameterTree(other.getParameterTree(), other.getUndoManager()),
          sampleIndexValue(m_parameterTree, Property::SampleIndex, getUndoManager()),
          selectedSampleValue(m_parameterTree, Property::SelectedSample, getUndoManager())
    {
        for (int i = 0; i < m_parameterTree.getNumChildren(); i++)
        {
            m_samples.add(std::make_unique<Sample>(getChild(i), getUndoManager()));
        }
        dropCompleted = other.dropCompleted;
        jassert(m_samples.size() == m_parameterTree.getNumChildren());
    }
 
    SamplesTree::SamplesTree(const ValueTree& other)
        : CustomParameterTree(other), sampleIndexValue(m_parameterTree, Property::SampleIndex, getUndoManager()),
          selectedSampleValue(m_parameterTree, Property::SelectedSample, getUndoManager())
    {
        if (m_parameterTree.getType() != Type::Samples)
        {
            jassertfalse; // Expected Samples Tree, got something else.
            // Init to default, invalid state
            m_parameterTree = ValueTree();
            sampleIndexValue.resetToDefault();
            selectedSampleValue.resetToDefault();
            return;
        }
 
        for (int i = 0; i < m_parameterTree.getNumChildren(); i++)
        {
            if (getChild(i).getType() == Type::Sample)
            {
                m_samples.add(std::make_unique<Sample>(getChild(i), getUndoManager()));
            }
            else
            {
                jassertfalse; // Expected to only contain Sample children
            }
        }
        jassert(m_samples.size() == m_parameterTree.getNumChildren());
    }
 
    SamplesTree& SamplesTree::operator=(const SamplesTree& other)
    {
        m_parameterTree = other.getParameterTree();
        setUndoManager(other.getUndoManager());
 
        for (int i = 0; i < m_parameterTree.getNumChildren(); i++)
        {
            m_samples.add(std::make_unique<Sample>(getChild(i), getUndoManager()));
        }
        dropCompleted = other.dropCompleted;
        jassert(m_samples.size() == m_parameterTree.getNumChildren());
 
        sampleIndexValue.referTo(m_parameterTree, Property::SampleIndex, getUndoManager());
        selectedSampleValue.referTo(m_parameterTree, Property::SelectedSample, getUndoManager());
        return *this;
    }
 
    void SamplesTree::updateSample(const String& name, const String& path)
    {
        if (auto child = m_parameterTree.getChildWithProperty(Property::Name, name); child.isValid())
        {
            child.setProperty(Property::Name, name, getUndoManager());
            child.setProperty(Property::Path, path, getUndoManager());
        }
        else
        {
            addSample(name, path, false);
        }
    }
 
    void SamplesTree::addSample(const String& name, const String& path, bool isMuted)
    {
        ValueTree sample{Type::Sample,
                         {{Property::Name, name},
                          {Property::Path, path},
                          {Property::Selection, rangeToString(Range<int>())},
                          {Property::Mute, isMuted},
                          {Property::Solo, false}}};
 
        addChild(sample);
    }
 
    void SamplesTree::removeSample(int index)
    {
        auto treeToRemove = m_parameterTree.getChild(index);
        removeChild(treeToRemove);
    }
 
    void SamplesTree::removeSample(const String& name)
    {
        auto treeToRemove = m_parameterTree.getChildWithProperty(Property::Name, name);
        removeChild(treeToRemove);
    }
 
    const StringArray SamplesTree::getFiles() const
    {
        StringArray files;
 
        for (int i = 0; i < m_parameterTree.getNumChildren(); i++)
        {
            files.add(getChild(i)[Property::Path].toString());
        }
 
        return files;
    }
 
    void SamplesTree::setSampleSelection(int index, const Range<int> selection)
    {
        jassert(index < m_parameterTree.getNumChildren());
        getChild(index).setProperty(Property::Selection, rangeToString(selection), getUndoManager());
    }
 
    Range<int> SamplesTree::getSampleSelection(int index) const
    {
        return stringToRange(getChild(index)[Property::Selection]);
    }
 
    std::vector<Range<int>> SamplesTree::getSampleSelections() const
    {
        std::vector<Range<int>> selections;
 
        for (int i = 0; i < m_parameterTree.getNumChildren(); i++)
        {
            selections.push_back(stringToRange(getChild(i)[Property::Selection]));
        }
 
        return selections;
    }
 
    void SamplesTree::setSampleSelections(const std::vector<Range<int>>& selections)
    {
        for (int i = 0; i < selections.size(); i++)
        {
            getChild(i).setProperty(Property::Selection, rangeToString(selections[i]), getUndoManager());
        }
    }
 
    String SamplesTree::rangeToString(const Range<int>& range)
    {
        return String(range.getStart()) + m_rangeDelimiter + String(range.getEnd()) + m_rangeDelimiter +
               String(range.getLength());
    }
 
    Range<int> SamplesTree::stringToRange(const String& rangeString)
    {
        auto start = rangeString.upToFirstOccurrenceOf(m_rangeDelimiter, false, false);
        auto end = rangeString.fromFirstOccurrenceOf(m_rangeDelimiter, false, false)
                           .upToFirstOccurrenceOf(m_rangeDelimiter, false, false);
 
        return Range<int>(start.getIntValue(), end.getIntValue());
    }
 
    OwnedArray<SampleBrowser::Sample> SamplesTree::getSampleDataAsBrowserSamples()
    {
        OwnedArray<SampleBrowser::Sample> samples;
 
        for (int i = 0; i < m_parameterTree.getNumChildren(); i++)
        {
            samples.add(new SampleBrowser::Sample(getChild(i)[Property::Name], getChild(i)[Property::Path], i,
                                                  getChild(i).getPropertyAsValue(Property::Mute, nullptr),
                                                  getChild(i).getPropertyAsValue(Property::Solo, nullptr)));
        }
        return std::move(samples);
    }
 
    void SamplesTree::setSampleIndex(int index)
    {
        jassert(index >= 0 && (getNumSamples() == 0 || index < getNumSamples()));
        sampleIndexValue = index;
    }
 
    // =============================================================================================
    // ValueTree listener callbacks
    // =============================================================================================
 
    // Set up the lambda
    void SamplesTree::valueTreeChildAdded(ValueTree& parentTree, ValueTree& childWhichHasBeenAdded)
    {
        int index = parentTree.indexOf(childWhichHasBeenAdded);
        m_samples.add(std::make_unique<Sample>(childWhichHasBeenAdded, getUndoManager()));
        if (sampleAdded)
        {
            jassert(childWhichHasBeenAdded.getType() == Type::Sample);
            sampleAdded(*m_samples.getLast());
        }
    }
 
    void SamplesTree::valueTreeChildRemoved(ValueTree& parentTree, ValueTree& childWhichHasBeenRemoved,
                                            int indexFromWhichChildWasRemoved)
    {
        if (sampleRemoved)
        {
            sampleRemoved(childWhichHasBeenRemoved, indexFromWhichChildWasRemoved);
        }
 
        m_samples.remove(indexFromWhichChildWasRemoved);
    }
 
    void SamplesTree::valueTreeParentChanged(ValueTree& treeWhoseParentHasChanged)
    {
        if (dropCompleted && treeWhoseParentHasChanged == m_parameterTree)
        {
            dropCompleted();
        }
    }
 
    void SamplesTree::valueTreePropertyChanged(ValueTree& treeWhosePropertyHasChanged, const Identifier& property)
    {
        if (property == Property::SampleIndex && sampleIndexChanged)
        {
            sampleIndexChanged(treeWhosePropertyHasChanged[property]);
        }
        else if (property == Property::SelectedSample && selectedSampleChanged)
        {
            selectedSampleChanged(treeWhosePropertyHasChanged[property]);
        }
    }
 
    // ======================================================================================
    SamplesTree::Sample::Sample(ValueTree sampleTree, UndoManager* undoManager)
        : valueTree(sampleTree), m_undoManager(undoManager),
          muteValue(sampleTree, SamplesTree::Property::Mute, undoManager),
          soloValue(sampleTree, SamplesTree::Property::Solo, undoManager),
          pathValue(sampleTree, SamplesTree::Property::Path, undoManager),
          nameValue(sampleTree, SamplesTree::Property::Name, undoManager)
    {
        valueTree.addListener(this);
    }
 
    void SamplesTree::Sample::valueTreePropertyChanged(ValueTree& treeWhosePropertyHasChanged,
                                                       const Identifier& property)
    {
        if (onChanged)
        {
            onChanged(property, treeWhosePropertyHasChanged.getProperty(property));
        }
 
        if (property == SamplesTree::Property::Mute)
        {
            if (muteChanged)
            {
                muteChanged();
            }
        }
        else if (property == SamplesTree::Property::Solo)
        {
            if (soloChanged)
            {
                soloChanged();
            }
        }
    }
 
    Result SamplesTree::rewriteSamplePaths(ValueTree& engine, File newPath)
    {
        auto engineCustomParams = engine.getChildWithName(XmlType::Tag::customParams);
 
        // Clear the legacy sample paths value; It doesn't need to be rewritten and will cause issues if left
        auto deprecatedSamplePaths = engineCustomParams.getChildWithProperty(
                XmlType::Property::id, Kwidget_CoreEngine::Parameters::SamplePaths);
        if (deprecatedSamplePaths.isValid())
        {
            deprecatedSamplePaths.setProperty(XmlType::Property::value, juce::var(), nullptr);
        }
 
        auto samplesTree = engineCustomParams.getChildWithName(SamplesTree::Type::Samples);
        if (samplesTree.hasType(SamplesTree::Type::Samples))
        {
            for (auto sample : samplesTree)
            {
                auto samplePath = sample.getProperty(SamplesTree::Property::Path).toString();
                samplePath = utils::convertFilePathString(samplePath);
 
                sample.setProperty(SamplesTree::Property::Path,
                                   utils::StringsIntoPath(newPath.getFullPathName(), samplePath), nullptr);
            }
            return Result::ok();
        }
        else
        {
            jassertfalse;
            const auto id = engine.getProperty(XmlType::Property::id).toString();
            return Result::fail("Did not rewrite samples paths, no samples tree found in " + id);
        }
    }
 
} // namespace krotos