tracktion_EditUtilities.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
{
 
//==============================================================================
// Projects and Files
//==============================================================================
 
Project::Ptr getProjectForEdit (const Edit&);
 
ProjectItem::Ptr getProjectItemForEdit (const Edit&);
 
juce::File getEditFileFromProjectManager (Edit&);
 
bool referencesProjectItem (Edit&, ProjectItemID);
 
 
//==============================================================================
// Edit
//==============================================================================
 
void insertSpaceIntoEdit (Edit&, TimeRange timeRangeToInsert);
 
void insertSpaceIntoEditFromBeatRange (Edit&, BeatRange);
 
//==============================================================================
// Tracks
//==============================================================================
 
juce::Array<Track*> getAllTracks (const Edit&);
 
juce::Array<Track*> getTopLevelTracks (const Edit&);
 
template<typename TrackType>
juce::Array<TrackType*> getTracksOfType (const Edit&, bool recursive);
 
juce::Array<AudioTrack*> getAudioTracks (const Edit&);
 
juce::Array<ClipTrack*> getClipTracks (const Edit&);
 
int getTotalNumTracks (const Edit&);
 
Track* findTrackForID (const Edit&, EditItemID);
 
AudioTrack* findAudioTrackForID (const Edit&, EditItemID);
 
juce::Array<Track*> findTracksForIDs (const Edit&, const juce::Array<EditItemID>&);
 
Track* findTrackForState (const Edit&, const juce::ValueTree&);
 
AudioTrack* getFirstAudioTrack (const Edit&);
 
juce::Array<Track*> findAllTracksContainingSelectedItems (const SelectableList&);
 
ClipTrack* findFirstClipTrackFromSelection (const SelectableList&);
 
bool containsTrack (const Edit&, const Track&);
 
TrackOutput* getTrackOutput (Track&);
 
juce::BigInteger toBitSet (const juce::Array<Track*>&);
 
juce::Array<Track*> toTrackArray (Edit&, const juce::BigInteger&);
 
template<typename TrackItemType>
[[ nodiscard ]] juce::Array<TrackItemType*> getTrackItemsOfType (const Track&);
 
ClipOwner* findClipOwnerForID (const Edit&, EditItemID);
 
 
//==============================================================================
// ClipSlots
//==============================================================================
ClipSlot* findClipSlotForID (const Edit&, EditItemID);
 
int findClipSlotIndex (ClipSlot&);
 
 
//==============================================================================
// Clips
//==============================================================================
 
Clip* findClipForID (const Edit&, EditItemID);
 
Clip* findClipForState (const Edit&, const juce::ValueTree&);
 
bool containsClip (const Edit&, Clip*);
 
Clip::Ptr duplicateClip (const Clip&);
 
void visitAllTrackItems (const Edit&, std::function<bool (TrackItem&)>);
 
TimeRange getTimeRangeForSelectedItems (const SelectableList&);
 
enum class CloseGap
{
    no, 
    yes 
};
 
void deleteRegionOfTracks (Edit&, TimeRange rangeToDelete, bool onlySelectedTracks, CloseGap, SelectionManager*);
 
void deleteRegionOfClip (Clip&, TimeRange rangeToDelete);
 
void deleteRegionOfSelectedClips (SelectionManager&, TimeRange rangeToDelete,
                                  CloseGap, bool moveAllSubsequentClipsOnTrack);
 
SelectableList splitClips (const SelectableList& clips, TimePosition time);
 
enum class MoveClipAction
{
    moveToEndOfLast,
    moveToStartOfNext,
    moveStartToCursor,
    moveEndToCursor
};
 
void moveSelectedClips (const SelectableList&, Edit&, MoveClipAction mode, bool alsoMoveAutomation);
 
SelectableList getClipSelectionWithCollectionClipContents (const SelectableList&);
 
juce::Array<ClipEffect*> getAllClipEffects (Edit& edit);
 
//==============================================================================
// MIDI
//==============================================================================
 
MidiNote* findNoteForState (const Edit&, const juce::ValueTree&);
 
juce::Result mergeMidiClips (juce::Array<MidiClip*>, SelectionManager* sm = nullptr);
 
juce::OwnedArray<MidiList> readFileToMidiList (juce::File midiFile, bool importAsNoteExpression);
 
MidiClip::Ptr createClipFromFile (juce::File midiFile, ClipOwner&, bool importAsNoteExpression);
 
 
//==============================================================================
// Plugins
//==============================================================================
 
Plugin::Array getAllPlugins (const Edit&, bool includeMasterVolume);
 
Plugin::Ptr findPluginForState (const Edit&, const juce::ValueTree&);
 
Plugin::Ptr findPluginForID (const Edit&, EditItemID);
 
Track* getTrackContainingPlugin (const Edit&, const Plugin*);
 
bool areAnyPluginsMissing (const Edit&);
 
juce::Array<RackInstance*> getRackInstancesInEditForType (const RackType&);
 
void muteOrUnmuteAllPlugins (const Edit&);
 
void injectMIDIToAllPlugins (const Edit&, const std::span<juce::MidiMessage>& messagesToSend);
 
void midiPanic (Edit&, bool resetPlugins);
 
 
template<typename PluginType>
juce::ReferenceCountedObjectPtr<PluginType> insertNewPlugin (Track&, int index = 0);
 
//==============================================================================
// Automation and parameters
//==============================================================================
 
juce::Array<AutomatableEditItem*> getAllAutomatableEditItems (const Edit&);
 
void deleteAutomation (const SelectableList& selectedClips);
 
//==============================================================================
// Modifiers
//==============================================================================
 
juce::Array<AutomatableParameter::ModifierSource*> getAllModifierSources (const Edit&);
 
juce::ReferenceCountedArray<Modifier> getAllModifiers (const Edit&);
 
template<typename ModifierType>
typename ModifierType::Ptr findModifierTypeForID (const Edit&, EditItemID);
 
Modifier::Ptr findModifierForID (const Edit&, EditItemID);
 
Modifier::Ptr findModifierForID (const RackType&, EditItemID);
 
Track* getTrackContainingModifier (const Edit&, const Modifier::Ptr&);
 
 
//==============================================================================
// Macros
//==============================================================================
 
juce::Array<MacroParameterList*> getAllMacroParameterLists (const Edit&);
 
juce::Array<MacroParameterElement*> getAllMacroParameterElements (const Edit&);
 
 
//==============================================================================
// Inputs/recording
//==============================================================================
InputDeviceInstance::RecordingParameters getDefaultRecordingParameters (const EditPlaybackContext&,
                                                                        TimePosition playStart,
                                                                        TimePosition punchIn);
 
juce::Result prepareAndPunchRecord (InputDeviceInstance&, EditItemID);
 
tl::expected<Clip::Array, juce::String> punchOutRecording (InputDeviceInstance&);
 
bool isRecording (EditPlaybackContext&);
 
 
//==============================================================================
template<typename PluginType>
inline juce::ReferenceCountedObjectPtr<PluginType> insertNewPlugin (Track& track, int index)
{
    if (auto p = track.edit.getPluginCache().createNewPlugin (PluginType::create()))
    {
        if (auto pluginAsType = dynamic_cast<PluginType*> (p.get()))
        {
            track.pluginList.insertPlugin (*p, index, {});
            return pluginAsType;
        }
    }
 
    return {};
}
 
template<typename TrackType>
inline juce::Array<TrackType*> getTracksOfType (const Edit& edit, bool recursive)
{
    juce::Array<TrackType*> result;
    result.ensureStorageAllocated (32);
 
    edit.visitAllTracks ([&] (Track& t)
                         {
                             if (auto type = dynamic_cast<TrackType*> (&t))
                                 result.add (type);
 
                             return true;
                         }, recursive);
 
    return result;
}
 
template<typename TrackItemType>
inline juce::Array<TrackItemType*> getTrackItemsOfType (const Track& track)
{
    juce::Array<TrackItemType*> items;
    const int numItems = track.getNumTrackItems();
 
    for (int i = 0; i < numItems; ++i)
        if (auto ti = dynamic_cast<TrackItemType*> (track.getTrackItem (i)))
            items.add (ti);
 
    return items;
}
 
template<typename ModifierType>
inline typename ModifierType::Ptr findModifierTypeForID (const Edit& edit, EditItemID id)
{
    for (auto modifier : getAllModifiers (edit))
        if (modifier->itemID == id)
            if (auto asType = dynamic_cast<ModifierType*> (modifier))
                return typename ModifierType::Ptr (asType);
 
    return {};
}
 
}} // namespace tracktion { inline namespace engine