juce_ARAModelObjects.h

Go to the documentation of this file.

/*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2022 - Raw Material Software Limited
 
   JUCE is an open source library subject to commercial or open-source
   licensing.
 
   By using JUCE, you agree to the terms of both the JUCE 7 End-User License
   Agreement and JUCE Privacy Policy.
 
   End User License Agreement: www.juce.com/juce-7-licence
   Privacy Policy: www.juce.com/juce-privacy-policy
 
   Or: You may also use this code under the terms of the GPL v3 (see
   www.gnu.org/licenses).
 
   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
   DISCLAIMED.
 
  ==============================================================================
*/
 
#pragma once
 
namespace juce
{
 
class ARADocumentController;
class ARADocument;
class ARAMusicalContext;
class ARARegionSequence;
class ARAAudioSource;
class ARAAudioModification;
class ARAPlaybackRegion;

template <class ListenerType>
class JUCE_API  ARAListenableModelClass
{
public:
    ARAListenableModelClass() = default;

    virtual ~ARAListenableModelClass() = default;

    void addListener (ListenerType* l) { listeners.add (l); }

    void removeListener (ListenerType* l) { listeners.remove (l); }

    template <typename Callback>
    void notifyListeners (Callback&& callback)
    {
        listeners.call (callback);
    }
 
private:
    ListenerList<ListenerType> listeners;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ARAListenableModelClass)
};

class ARAObjectVisitor
{
public:
    virtual ~ARAObjectVisitor() = default;

    virtual void visitDocument (juce::ARADocument&) {}

    virtual void visitMusicalContext (juce::ARAMusicalContext&) {}

    virtual void visitRegionSequence (juce::ARARegionSequence&) {}

    virtual void visitPlaybackRegion (juce::ARAPlaybackRegion&) {}

    virtual void visitAudioModification (juce::ARAAudioModification&) {}

    virtual void visitAudioSource (juce::ARAAudioSource&) {}
};

class ARAObject
{
public:
    virtual ~ARAObject() = default;

    virtual size_t getNumChildren() const noexcept = 0;

    virtual ARAObject* getChild (size_t index) = 0;

    virtual ARAObject* getParent() = 0;

    template <typename Fn>
    void traverse (Fn&& fn)
    {
        fn (*this);
 
        for (size_t i = 0; i < getNumChildren(); ++i)
        {
            getChild (i)->traverse (fn);
        }
    }

    virtual void visit (ARAObjectVisitor& visitor) = 0;
};

class JUCE_API  ARADocumentListener
{
public:
    virtual ~ARADocumentListener() = default;
 
   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_BEGIN

    virtual void willBeginEditing (ARADocument* document)
    {
        ignoreUnused (document);
    }

    virtual void didEndEditing (ARADocument* document)
    {
        ignoreUnused (document);
    }

    virtual void willNotifyModelUpdates (ARADocument* document)
    {
        ignoreUnused (document);
    }

    virtual void didNotifyModelUpdates (ARADocument* document)
    {
        ignoreUnused (document);
    }

    virtual void willUpdateDocumentProperties (ARADocument* document,
                                               ARA::PlugIn::PropertiesPtr<ARA::ARADocumentProperties> newProperties)
    {
        ignoreUnused (document, newProperties);
    }

    virtual void didUpdateDocumentProperties (ARADocument* document)
    {
        ignoreUnused (document);
    }

    virtual void didAddMusicalContextToDocument (ARADocument* document, ARAMusicalContext* musicalContext)
    {
        ignoreUnused (document, musicalContext);
    }

    virtual void willRemoveMusicalContextFromDocument (ARADocument* document,
                                                       ARAMusicalContext* musicalContext)
    {
        ignoreUnused (document, musicalContext);
    }

    virtual void didReorderMusicalContextsInDocument (ARADocument* document)
    {
        ignoreUnused (document);
    }

    virtual void didAddRegionSequenceToDocument (ARADocument* document, ARARegionSequence* regionSequence)
    {
        ignoreUnused (document, regionSequence);
    }

    virtual void willRemoveRegionSequenceFromDocument (ARADocument* document,
                                                       ARARegionSequence* regionSequence)
    {
        ignoreUnused (document, regionSequence);
    }

    virtual void didReorderRegionSequencesInDocument (ARADocument* document)
    {
        ignoreUnused (document);
    }

    virtual void didAddAudioSourceToDocument (ARADocument* document, ARAAudioSource* audioSource)
    {
        ignoreUnused (document, audioSource);
    }

    virtual void willRemoveAudioSourceFromDocument (ARADocument* document, ARAAudioSource* audioSource)
    {
        ignoreUnused (document, audioSource);
    }

    virtual void willDestroyDocument (ARADocument* document)
    {
        ignoreUnused (document);
    }
 
   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_END
};
 
//==============================================================================
class JUCE_API  ARADocument   : public ARA::PlugIn::Document,
                                public ARAListenableModelClass<ARADocumentListener>,
                                public ARAObject
{
public:
    using PropertiesPtr = ARA::PlugIn::PropertiesPtr<ARA::ARADocumentProperties>;
    using Listener = ARADocumentListener;
 
    using ARA::PlugIn::Document::Document;

    template <typename AudioSource_t = ARAAudioSource>
    const std::vector<AudioSource_t*>& getAudioSources() const noexcept
    {
        return ARA::PlugIn::Document::getAudioSources<AudioSource_t>();
    }

    template <typename MusicalContext_t = ARAMusicalContext>
    const std::vector<MusicalContext_t*>& getMusicalContexts() const noexcept
    {
        return ARA::PlugIn::Document::getMusicalContexts<MusicalContext_t>();
    }

    template <typename RegionSequence_t = ARARegionSequence>
    const std::vector<RegionSequence_t*>& getRegionSequences() const noexcept
    {
        return ARA::PlugIn::Document::getRegionSequences<RegionSequence_t>();
    }
 
    size_t getNumChildren() const noexcept override;
 
    ARAObject* getChild (size_t index) override;
 
    ARAObject* getParent() override { return nullptr; }
 
    void visit (ARAObjectVisitor& visitor) override { visitor.visitDocument (*this); }
};

class JUCE_API  ARAMusicalContextListener
{
public:
    virtual ~ARAMusicalContextListener() = default;
 
   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_BEGIN

    virtual void willUpdateMusicalContextProperties (ARAMusicalContext* musicalContext,
                                                     ARA::PlugIn::PropertiesPtr<ARA::ARAMusicalContextProperties> newProperties)
    {
        ignoreUnused (musicalContext, newProperties);
    }

    virtual void didUpdateMusicalContextProperties (ARAMusicalContext* musicalContext)
    {
        ignoreUnused (musicalContext);
    }

    virtual void doUpdateMusicalContextContent (ARAMusicalContext* musicalContext,
                                                ARAContentUpdateScopes scopeFlags)
    {
        ignoreUnused (musicalContext, scopeFlags);
    }

    virtual void didAddRegionSequenceToMusicalContext (ARAMusicalContext* musicalContext,
                                                       ARARegionSequence* regionSequence)
    {
        ignoreUnused (musicalContext, regionSequence);
    }

    virtual void willRemoveRegionSequenceFromMusicalContext (ARAMusicalContext* musicalContext,
                                                             ARARegionSequence* regionSequence)
    {
        ignoreUnused (musicalContext, regionSequence);
    }

    virtual void didReorderRegionSequencesInMusicalContext (ARAMusicalContext* musicalContext)
    {
        ignoreUnused (musicalContext);
    }

    virtual void willDestroyMusicalContext (ARAMusicalContext* musicalContext)
    {
        ignoreUnused (musicalContext);
    }
 
   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_END
};
 
//==============================================================================
class JUCE_API  ARAMusicalContext     : public ARA::PlugIn::MusicalContext,
                                        public ARAListenableModelClass<ARAMusicalContextListener>,
                                        public ARAObject
{
public:
    using PropertiesPtr = ARA::PlugIn::PropertiesPtr<ARA::ARAMusicalContextProperties>;
    using Listener = ARAMusicalContextListener;
 
    using ARA::PlugIn::MusicalContext::MusicalContext;

    template <typename Document_t = ARADocument>
    Document_t* getDocument() const noexcept
    {
        return ARA::PlugIn::MusicalContext::getDocument<Document_t>();
    }

    template <typename RegionSequence_t = ARARegionSequence>
    const std::vector<RegionSequence_t*>& getRegionSequences() const noexcept
    {
        return ARA::PlugIn::MusicalContext::getRegionSequences<RegionSequence_t>();
    }
 
    size_t getNumChildren() const noexcept override { return 0; }
 
    ARAObject* getChild (size_t) override { return nullptr; }
 
    ARAObject* getParent() override { return getDocument(); }
 
    void visit (ARAObjectVisitor& visitor) override { visitor.visitMusicalContext (*this); }
};

class JUCE_API  ARAPlaybackRegionListener
{
public:
    virtual ~ARAPlaybackRegionListener() = default;
 
   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_BEGIN

    virtual void willUpdatePlaybackRegionProperties (ARAPlaybackRegion* playbackRegion,
                                                     ARA::PlugIn::PropertiesPtr<ARA::ARAPlaybackRegionProperties> newProperties)
    {
        ignoreUnused (playbackRegion, newProperties);
    }

    virtual void didUpdatePlaybackRegionProperties (ARAPlaybackRegion* playbackRegion)
    {
        ignoreUnused (playbackRegion);
    }

    virtual void didUpdatePlaybackRegionContent (ARAPlaybackRegion* playbackRegion,
                                                 ARAContentUpdateScopes scopeFlags)
    {
        ignoreUnused (playbackRegion, scopeFlags);
    }

    virtual void willDestroyPlaybackRegion (ARAPlaybackRegion* playbackRegion)
    {
        ignoreUnused (playbackRegion);
    }
 
   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_END
};
 
//==============================================================================
class JUCE_API  ARAPlaybackRegion     : public ARA::PlugIn::PlaybackRegion,
                                        public ARAListenableModelClass<ARAPlaybackRegionListener>,
                                        public ARAObject
{
public:
    using PropertiesPtr = ARA::PlugIn::PropertiesPtr<ARA::ARAPlaybackRegionProperties>;
    using Listener = ARAPlaybackRegionListener;
 
    using ARA::PlugIn::PlaybackRegion::PlaybackRegion;

    template <typename AudioModification_t = ARAAudioModification>
    AudioModification_t* getAudioModification() const noexcept
    {
        return ARA::PlugIn::PlaybackRegion::getAudioModification<AudioModification_t>();
    }

    template <typename RegionSequence_t = ARARegionSequence>
    RegionSequence_t* getRegionSequence() const noexcept
    {
        return ARA::PlugIn::PlaybackRegion::getRegionSequence<RegionSequence_t>();
    }
 
    size_t getNumChildren() const noexcept override { return 0; }
 
    ARAObject* getChild (size_t) override { return nullptr; }
 
    ARAObject* getParent() override;
 
    void visit (ARAObjectVisitor& visitor) override { visitor.visitPlaybackRegion (*this); }

    enum class IncludeHeadAndTail { no, yes };

    Range<double> getTimeRange (IncludeHeadAndTail includeHeadAndTail = IncludeHeadAndTail::no) const;

    Range<int64> getSampleRange (double sampleRate, IncludeHeadAndTail includeHeadAndTail = IncludeHeadAndTail::no) const;

    double getHeadTime() const;

    double getTailTime() const;

    void notifyContentChanged (ARAContentUpdateScopes scopeFlags, bool notifyARAHost);
};

class JUCE_API  ARARegionSequenceListener
{
public:
    virtual ~ARARegionSequenceListener() = default;
 
   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_BEGIN

    virtual void willUpdateRegionSequenceProperties (ARARegionSequence* regionSequence,
                                                     ARA::PlugIn::PropertiesPtr<ARA::ARARegionSequenceProperties> newProperties)
    {
        ignoreUnused (regionSequence, newProperties);
    }

    virtual void didUpdateRegionSequenceProperties (ARARegionSequence* regionSequence)
    {
        ignoreUnused (regionSequence);
    }

    virtual void willRemovePlaybackRegionFromRegionSequence (ARARegionSequence* regionSequence,
                                                             ARAPlaybackRegion* playbackRegion)
    {
        ignoreUnused (regionSequence, playbackRegion);
    }

    virtual void didAddPlaybackRegionToRegionSequence (ARARegionSequence* regionSequence,
                                                       ARAPlaybackRegion* playbackRegion)
    {
        ignoreUnused (regionSequence, playbackRegion);
    }

    virtual void willDestroyRegionSequence (ARARegionSequence* regionSequence)
    {
        ignoreUnused (regionSequence);
    }
 
   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_END
};
 
//==============================================================================
class JUCE_API  ARARegionSequence     : public ARA::PlugIn::RegionSequence,
                                        public ARAListenableModelClass<ARARegionSequenceListener>,
                                        public ARAObject
{
public:
    using PropertiesPtr = ARA::PlugIn::PropertiesPtr<ARA::ARARegionSequenceProperties>;
    using Listener = ARARegionSequenceListener;
 
    using ARA::PlugIn::RegionSequence::RegionSequence;

    template <typename Document_t = ARADocument>
    Document_t* getDocument() const noexcept
    {
        return ARA::PlugIn::RegionSequence::getDocument<Document_t>();
    }

    template <typename MusicalContext_t = ARAMusicalContext>
    MusicalContext_t* getMusicalContext() const noexcept
    {
        return ARA::PlugIn::RegionSequence::getMusicalContext<MusicalContext_t>();
    }

    template <typename PlaybackRegion_t = ARAPlaybackRegion>
    const std::vector<PlaybackRegion_t*>& getPlaybackRegions() const noexcept
    {
        return ARA::PlugIn::RegionSequence::getPlaybackRegions<PlaybackRegion_t>();
    }
 
    size_t getNumChildren() const noexcept override;
 
    ARAObject* getChild (size_t index) override;
 
    ARAObject* getParent () override { return getDocument(); }
 
    void visit (ARAObjectVisitor& visitor) override { visitor.visitRegionSequence (*this); }

    Range<double> getTimeRange (ARAPlaybackRegion::IncludeHeadAndTail includeHeadAndTail = ARAPlaybackRegion::IncludeHeadAndTail::no) const;

    double getCommonSampleRate() const;
};

class JUCE_API  ARAAudioSourceListener
{
public:
    virtual ~ARAAudioSourceListener() = default;
 
   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_BEGIN

    virtual void willUpdateAudioSourceProperties (ARAAudioSource* audioSource,
                                                  ARA::PlugIn::PropertiesPtr<ARA::ARAAudioSourceProperties> newProperties)
    {
        ignoreUnused (audioSource, newProperties);
    }

    virtual void didUpdateAudioSourceProperties (ARAAudioSource* audioSource)
    {
        ignoreUnused (audioSource);
    }

    virtual void doUpdateAudioSourceContent (ARAAudioSource* audioSource, ARAContentUpdateScopes scopeFlags)
    {
        ignoreUnused (audioSource, scopeFlags);
    }

    virtual void didUpdateAudioSourceAnalysisProgress (ARAAudioSource* audioSource,
                                                       ARA::ARAAnalysisProgressState state,
                                                       float progress)
    {
        ignoreUnused (audioSource, state, progress);
    }

    virtual void willEnableAudioSourceSamplesAccess (ARAAudioSource* audioSource, bool enable)
    {
        ignoreUnused (audioSource, enable);
    }

    virtual void didEnableAudioSourceSamplesAccess (ARAAudioSource* audioSource, bool enable)
    {
        ignoreUnused (audioSource, enable);
    }

    virtual void willDeactivateAudioSourceForUndoHistory (ARAAudioSource* audioSource, bool deactivate)
    {
        ignoreUnused (audioSource, deactivate);
    }

    virtual void didDeactivateAudioSourceForUndoHistory (ARAAudioSource* audioSource, bool deactivate)
    {
        ignoreUnused (audioSource, deactivate);
    }

    virtual void didAddAudioModificationToAudioSource (ARAAudioSource* audioSource,
                                                       ARAAudioModification* audioModification)
    {
        ignoreUnused (audioSource, audioModification);
    }

    virtual void willRemoveAudioModificationFromAudioSource (ARAAudioSource* audioSource,
                                                             ARAAudioModification* audioModification)
    {
        ignoreUnused (audioSource, audioModification);
    }

    virtual void willDestroyAudioSource (ARAAudioSource* audioSource)
    {
        ignoreUnused (audioSource);
    }
 
   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_END
};
 
//==============================================================================
class JUCE_API  ARAAudioSource    : public ARA::PlugIn::AudioSource,
                                    public ARAListenableModelClass<ARAAudioSourceListener>,
                                    public ARAObject
{
public:
    using PropertiesPtr = ARA::PlugIn::PropertiesPtr<ARA::ARAAudioSourceProperties>;
    using ARAAnalysisProgressState = ARA::ARAAnalysisProgressState;
    using Listener = ARAAudioSourceListener;
 
    using ARA::PlugIn::AudioSource::AudioSource;

    template <typename Document_t = ARADocument>
    Document_t* getDocument() const noexcept
    {
        return ARA::PlugIn::AudioSource::getDocument<Document_t>();
    }

    template <typename AudioModification_t = ARAAudioModification>
    const std::vector<AudioModification_t*>& getAudioModifications() const noexcept
    {
        return ARA::PlugIn::AudioSource::getAudioModifications<AudioModification_t>();
    }
 
    size_t getNumChildren() const noexcept override;
 
    ARAObject* getChild (size_t index) override;
 
    ARAObject* getParent() override { return getDocument(); }
 
    void visit (ARAObjectVisitor& visitor) override { visitor.visitAudioSource (*this); }

    void notifyAnalysisProgressStarted();

    void notifyAnalysisProgressUpdated (float progress);

    void notifyAnalysisProgressCompleted();

    void notifyContentChanged (ARAContentUpdateScopes scopeFlags, bool notifyARAHost);
 
public:
    friend ARADocumentController;
    ARA::PlugIn::AnalysisProgressTracker internalAnalysisProgressTracker;
};

class JUCE_API  ARAAudioModificationListener
{
public:
    virtual ~ARAAudioModificationListener() = default;
 
   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_BEGIN

    virtual void willUpdateAudioModificationProperties (ARAAudioModification* audioModification,
                                                        ARA::PlugIn::PropertiesPtr<ARA::ARAAudioModificationProperties> newProperties)
    {
        ignoreUnused (audioModification, newProperties);
    }

    virtual void didUpdateAudioModificationProperties (ARAAudioModification* audioModification)
    {
        ignoreUnused (audioModification);
    }

    virtual void didUpdateAudioModificationContent (ARAAudioModification* audioModification, ARAContentUpdateScopes scopeFlags)
    {
        ignoreUnused (audioModification, scopeFlags);
    }

    virtual void willDeactivateAudioModificationForUndoHistory (ARAAudioModification* audioModification, bool deactivate)
    {
        ignoreUnused (audioModification, deactivate);
    }

    virtual void didDeactivateAudioModificationForUndoHistory (ARAAudioModification* audioModification, bool deactivate)
    {
        ignoreUnused (audioModification, deactivate);
    }

    virtual void didAddPlaybackRegionToAudioModification (ARAAudioModification* audioModification,
                                                          ARAPlaybackRegion* playbackRegion)
    {
        ignoreUnused (audioModification, playbackRegion);
    }

    virtual void willRemovePlaybackRegionFromAudioModification (ARAAudioModification* audioModification,
                                                                ARAPlaybackRegion* playbackRegion)
    {
        ignoreUnused (audioModification, playbackRegion);
    }

    virtual void willDestroyAudioModification (ARAAudioModification* audioModification)
    {
        ignoreUnused (audioModification);
    }
 
   ARA_DISABLE_UNREFERENCED_PARAMETER_WARNING_END
};
 
//==============================================================================
class JUCE_API  ARAAudioModification  : public ARA::PlugIn::AudioModification,
                                        public ARAListenableModelClass<ARAAudioModificationListener>,
                                        public ARAObject
{
public:
    using PropertiesPtr = ARA::PlugIn::PropertiesPtr<ARA::ARAAudioModificationProperties>;
    using Listener = ARAAudioModificationListener;
 
    using ARA::PlugIn::AudioModification::AudioModification;

    template <typename AudioSource_t = ARAAudioSource>
    AudioSource_t* getAudioSource() const noexcept
    {
        return ARA::PlugIn::AudioModification::getAudioSource<AudioSource_t>();
    }

    template <typename PlaybackRegion_t = ARAPlaybackRegion>
    const std::vector<PlaybackRegion_t*>& getPlaybackRegions() const noexcept
    {
        return ARA::PlugIn::AudioModification::getPlaybackRegions<PlaybackRegion_t>();
    }
 
    size_t getNumChildren() const noexcept override;
 
    ARAObject* getChild (size_t index) override;
 
    ARAObject* getParent() override { return getAudioSource(); }
 
    void visit (ARAObjectVisitor& visitor) override { visitor.visitAudioModification (*this); }

    void notifyContentChanged (ARAContentUpdateScopes scopeFlags, bool notifyARAHost);
};
 
} // namespace juce