tracktion_TrackUtils.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
namespace tracktion { inline namespace engine
{
 
struct TrackInsertPoint
{
    TrackInsertPoint (Track* parent, Track* preceding);
 
    TrackInsertPoint (EditItemID parentTrackID, EditItemID precedingTrackID);
 
    TrackInsertPoint (Track& currentPos, bool insertBefore);
 
    TrackInsertPoint (const juce::ValueTree&);
 
    EditItemID parentTrackID, precedingTrackID;
};
 
//==============================================================================
struct TrackList    : public ValueTreeObjectList<Track>,
                      private juce::AsyncUpdater
{
    TrackList (Edit&, const juce::ValueTree& parent);
 
    ~TrackList() override;
 
    //==============================================================================
    Track* getTrackFor (const juce::ValueTree&) const;
 
    bool visitAllRecursive (const std::function<bool(Track&)>&) const;
 
    void visitAllTopLevel (const std::function<bool(Track&)>&) const;
 
    void visitAllTracks (const std::function<bool(Track&)>&, bool recursive) const;
 
    //==============================================================================
    static bool isMovableTrack (const juce::ValueTree&) noexcept;
 
    static bool isArrangerTrack (const juce::ValueTree&) noexcept;
 
    static bool isChordTrack (const juce::ValueTree&) noexcept;
 
    static bool isMarkerTrack (const juce::ValueTree&) noexcept;
 
    static bool isTempoTrack (const juce::ValueTree&) noexcept;
 
    static bool isMasterTrack (const juce::ValueTree&) noexcept;
 
    static bool isFixedTrack (const juce::ValueTree&) noexcept;
 
    static bool isTrack (const juce::ValueTree&) noexcept;
 
    static bool isTrack (const juce::Identifier&) noexcept;
 
    static bool hasAnySubTracks (const juce::ValueTree&);
 
    //==============================================================================
    static void sortTracksByType (juce::ValueTree& editState, juce::UndoManager*);
 
    //==============================================================================
    bool isSuitableType (const juce::ValueTree&) const override;
    Track* createNewObject (const juce::ValueTree&) override;
    void deleteObject (Track* t) override;
    void newObjectAdded (Track* t) override;
    void objectRemoved (Track*) override;
    void objectOrderChanged() override;
 
    Edit& edit;
    bool rebuilding = true;
 
private:
    void handleAsyncUpdate() override;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (TrackList)
};
 
//==============================================================================
struct TrackSection
{
    Track* track = nullptr; 
    TimeRange range;        
    bool merge (const TrackItem& c)
    {
        if (c.getTrack() == track
             && c.getEditTimeRange().overlaps (range.expanded (TimeDuration::fromSeconds (0.0001))))
        {
            range = range.getUnionWith (c.getEditTimeRange());
            return true;
        }
 
        return false;
    }
 
    template <typename TrackItemArray>
    static juce::Array<TrackSection> findSections (const TrackItemArray& trackItems)
    {
        juce::Array<TrackSection> result;
 
        for (auto&& c : trackItems)
        {
            bool segFound = false;
 
            for (auto& dstSeg : result)
            {
                if (dstSeg.merge (*c))
                {
                    segFound = true;
                    break;
                }
            }
 
            if (! segFound)
            {
                TrackSection cs;
                cs.range = c->getEditTimeRange();
                cs.track = c->getTrack();
 
                if (cs.track != nullptr)
                    result.add (cs);
            }
        }
 
        return result;
    }
};
 
//==============================================================================
struct TrackAutomationSection
{
    TrackAutomationSection() noexcept = default;
 
    TrackAutomationSection (TrackItem&);
 
    TimeRange position;     
    Track::Ptr src,         
               dst;         
    void mergeIn (const TrackAutomationSection&);
 
    bool overlaps (const TrackAutomationSection&) const;
 
    bool containsParameter (AutomatableParameter*) const;
 
    struct ActiveParameters
    {
        AutomatableParameter::Ptr param;    
        AutomationCurve curve;              
    };
 
    juce::Array<ActiveParameters> activeParameters; 
};
 
void moveAutomation (const juce::Array<TrackAutomationSection>&, TimeDuration offset, bool copy);
 
 
//==============================================================================
template <typename ArrayType>
int findIndexOfNextItemAt (const ArrayType& items, TimePosition time)
{
    for (int i = items.size(); --i >= 0;)
    {
        auto pos = items.getUnchecked (i)->getPosition().time;
 
        if (pos.getStart() < time)
        {
            if (pos.getEnd() > time)
                return i;
 
            return i + 1;
        }
    }
 
    return 0;
}
 
template <typename ArrayType>
TimeRange findUnionOfEditTimeRanges (const ArrayType& items)
{
    TimeRange total;
    bool first = true;
 
    for (auto& item : items)
    {
        auto time = item->getEditTimeRange();
 
        if (first)
        {
            first = false;
            total = time;
        }
        else
        {
            total = total.getUnionWith (time);
        }
    }
 
    return total;
}
 
}} // namespace tracktion { inline namespace engine