tracktion_Track.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
{
 
class Track   : public EditItem,
                public Selectable,
                public juce::ReferenceCountedObject,
                protected juce::ValueTree::Listener,
                protected juce::AsyncUpdater
{
public:
    Track (Edit&, const juce::ValueTree&, bool hasModifierList);
 
    ~Track() override;
 
    using Ptr   = juce::ReferenceCountedObjectPtr<Track>;
    using Array = juce::ReferenceCountedArray<Track>;
 
    //==============================================================================
    virtual void initialise();
 
    virtual void flushStateToValueTree();
 
    void refreshCurrentAutoParam();
 
    //==============================================================================
    juce::String getName() const override                       { return trackName; }
 
    void setName (const juce::String&);
 
    void resetName();
 
    virtual void sanityCheckName()                              {}
 
    //==============================================================================
    virtual bool isAudioTrack() const                           { return false; }
 
    virtual bool isAutomationTrack() const                      { return false; }
 
    virtual bool isFolderTrack() const                          { return false; }
 
    virtual bool isMarkerTrack() const                          { return false; }
 
    virtual bool isTempoTrack() const                           { return false; }
 
    virtual bool isChordTrack() const                           { return false; }
 
    virtual bool isArrangerTrack() const                        { return false; }
 
    virtual bool isMasterTrack() const                          { return false; }
 
    //==============================================================================
    bool canContainMarkers() const                              { return isMarkerTrack(); }
 
    bool canContainMIDI() const                                 { return isAudioTrack(); }
 
    bool canContainAudio() const                                { return isAudioTrack(); }
 
    bool canContainEditClips() const                            { return isAudioTrack(); }
 
    bool canContainPlugins() const                              { return isAudioTrack() || isFolderTrack() || isMasterTrack(); }
 
    bool isMovable() const                                      { return isAudioTrack() || isFolderTrack(); }
 
    bool acceptsInput() const                                   { return isAudioTrack(); }
 
    bool createsOutput() const                                  { return isAudioTrack(); }
 
    bool wantsAutomation() const                                { return ! (isMarkerTrack() || isChordTrack() || isArrangerTrack());  }
 
    virtual bool canContainPlugin (Plugin*) const = 0;
 
    //==============================================================================
    enum FreezeType
    {
        groupFreeze = 0,    
        individualFreeze,   
        anyFreeze           
    };
 
    virtual bool isFrozen (FreezeType) const                    { return false; }
 
    virtual void setFrozen (bool /*shouldBeFrozen*/, FreezeType){}
 
    bool isHidden() const                                       { return hidden; }
 
    void setHidden (bool h)                                     { hidden = h; }
 
    bool isProcessing (bool includeParents) const;
 
    void setProcessing (bool p)                                 { processing = p; }
 
    virtual bool processAudioNodesWhileMuted() const            { return false; }
 
    virtual juce::Array<Track*> getInputTracks() const          { return {}; }
 
    //==============================================================================
    juce::Array<Track*> getAllSubTracks (bool recursive) const;
 
    juce::Array<AudioTrack*> getAllAudioSubTracks (bool recursive) const;
 
    TrackList* getSubTrackList() const                          { return trackList.get(); }
 
    bool hasSubTracks() const                                   { return trackList != nullptr; }
 
    virtual Clip* findClipForID (EditItemID) const;
 
    Track* getSiblingTrack (int delta, bool keepWithinSameParent) const;
 
    //==============================================================================
    virtual int getNumTrackItems() const                        { return 0; }
 
    virtual TrackItem* getTrackItem (int /*index*/) const       { return {}; }
 
    virtual int indexOfTrackItem (TrackItem*) const             { return -1; }
 
    virtual int getIndexOfNextTrackItemAt (TimePosition)        { return -1; }
 
    virtual TrackItem* getNextTrackItemAt (TimePosition)        { return {}; }
 
    //==============================================================================
    virtual void insertSpaceIntoTrack (TimePosition, TimeDuration);
 
    //==============================================================================
    juce::ValueTree getParentTrackTree() const;
 
    Track* getParentTrack() const                               { return cachedParentTrack; }
 
    FolderTrack* getParentFolderTrack() const                   { return cachedParentFolderTrack; }
 
    bool isAChildOf (const Track& possibleParent) const;
 
    bool isPartOfSubmix() const;
 
    int getIndexInEditTrackList() const;
 
    int getTrackDepth() const;
 
    //==============================================================================
    virtual bool isMuted (bool /*includeMutingByDestination*/) const    { return false; }
 
    virtual bool isSolo (bool /*includeIndirectSolo*/) const            { return false; }
 
    virtual bool isSoloIsolate (bool /*includeIndirectSolo*/) const     { return false; }
 
    virtual void setMute (bool)                                         {}
 
    virtual void setSolo (bool)                                         {}
 
    virtual void setSoloIsolate (bool)                                  {}
 
    enum MuteAndSoloLightState
    {
        soloLit         = 1,    
        soloFlashing    = 2,    
        soloIsolate     = 4,    
        muteLit         = 8,    
        muteFlashing    = 16    
    };
 
    MuteAndSoloLightState getMuteAndSoloLightState() const;
 
    bool shouldBePlayed() const noexcept                                { return isAudible; }
 
    void updateAudibility (bool areAnyTracksSolo);
 
    //==============================================================================
    juce::Array<AutomatableParameter*> getAllAutomatableParams() const;
 
    void visitAllAutomatableParams (const std::function<void(AutomatableParameter&)>&) const;
 
    AutomatableParameter* getCurrentlyShownAutoParam() const noexcept;
 
    void setCurrentlyShownAutoParam (const AutomatableParameter::Ptr&);
 
    void hideAutomatableParametersForSource (EditItemID pluginOrParameterID);
 
    //==============================================================================
    virtual bool containsPlugin (const Plugin*) const;
 
    bool hasFreezePointPlugin() const;
 
    juce::Array<AutomatableEditItem*> getAllAutomatableEditItems() const;
 
    virtual Plugin::Array getAllPlugins() const;
 
    virtual void sendMirrorUpdateToAllPlugins (Plugin& changedPlugin) const;
 
    void flipAllPluginsEnablement();
 
    //==============================================================================
    ModifierList* getModifierList() const                   { return modifierList.get(); }
 
    //==============================================================================
    static const int minTrackHeightForDetail = 10;  
    static const int trackHeightForEditor = 180;    
    static const int frozenTrackHeight = 15;        
    //==============================================================================
    void setColour (juce::Colour newColour)                 { colour = newColour; }
 
    juce::Colour getColour() const                          { return colour; }
 
    //==============================================================================
    bool canShowImage() const;
 
    void setTrackImage (const juce::String& idOrData);
 
    juce::String getTrackImage() const                      { return imageIdOrData; }
 
    bool imageHasChanged();
 
    void setTags (const juce::StringArray&);
 
    juce::String getTags() const                            { return tags.get(); }
 
    const juce::StringArray& getTagsArray() const noexcept  { return tagsArray; }
 
    //==============================================================================
    juce::ValueTree state;  
    PluginList pluginList;  
protected:
    void valueTreePropertyChanged (juce::ValueTree&, const juce::Identifier&) override;
    void valueTreeChildAdded (juce::ValueTree&, juce::ValueTree&) override;
    void valueTreeChildRemoved (juce::ValueTree&, juce::ValueTree&, int) override;
    void valueTreeChildOrderChanged (juce::ValueTree&, int, int) override {}
    void valueTreeParentChanged (juce::ValueTree&) override;
    void handleAsyncUpdate() override;
 
    virtual bool isTrackAudible (bool areAnyTracksSolo) const;
 
private:
    juce::WeakReference<Selectable> currentAutoParam;
    std::unique_ptr<TrackList> trackList;
    std::unique_ptr<ModifierList> modifierList;
 
    juce::CachedValue<juce::String> trackName;
    juce::CachedValue<bool> hidden, processing;
 
    juce::CachedValue<EditItemID> currentAutoParamPlugin;
    juce::CachedValue<juce::String> currentAutoParamID;
 
    juce::CachedValue<juce::Colour> colour;
    juce::CachedValue<juce::String> imageIdOrData, tags;
    juce::StringArray tagsArray;
 
    bool imageChanged = false;
    std::atomic<bool> isAudible { true };
 
    SafeSelectable<Track> cachedParentTrack;
    SafeSelectable<FolderTrack> cachedParentFolderTrack;
 
    //==============================================================================
    void updateTrackList();
    void updateCachedParent();
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Track)
};
 
}} // namespace tracktion { inline namespace engine