Playlists and Waveform Toggle

Wow! Thank you Chris!

Hey Chris, is there any way to set with a single click, every time I press the shortcut for this this script changes the view option?
example: pressed T = Waveform, pressed again = Volume, pressed again = mute

This needs a slight modification to work correctly since the current display will always cause the index to be the same value. I implemented a search of the current display to see if it loosely matches the value in the displayPaths. If so, we can shift the display path to show the lane of the next one in the array. This way, even if you have volume and volume trim, it will shift to the next. And as per the original logic, if the value is >= to the displayPaths.length, it will shift it to 0.

// Define display values
const displayPaths = ["waveform", "volume", "volume trim"];

sf.ui.proTools.appActivate();

// Get current display
const currentDisplay = sf.ui.proTools.selectedTrack.displaySelectorButton.value.invalidate().value;

// Function to find loosely matching index
function findLooseMatchIndex(array, target) {
    for (let i = 0; i < array.length; i++) {
        if (target.includes(array[i]) || array[i].includes(target)) {
            return i;
        }
    }
    return -1; // Return -1 if no loose match is found
}

// Check current display value to determine new display value
let matchedIndex = findLooseMatchIndex(displayPaths, currentDisplay);
let newDisplayIndex = matchedIndex === -1 ? 0 : matchedIndex + 1;

// Loop back to the first index if it exceeds the array length
if (newDisplayIndex >= displayPaths.length) newDisplayIndex = 0;

// Change display
sf.ui.proTools.selectedTrack.trackDisplaySelect({
    displayPath: [displayPaths[newDisplayIndex]],
    selectForAllSelectedTracks: true
});

Here is a code that will cycle through all the displaypaths we have including sends. If a particular send isnt found on one track using the logic that the send button value of the first track of the selected tracks will not be equal to unassigned, it will check the rest of the tracks in the selection to see if this is the case and then show all the send lanes on the available tracks. It uses the globalState method to store the last value of the displayPaths index it used. Hope it is useful.

const combinedPaths = ["waveform", "mute", "volume", "volume trim", '*(snd a)*', '*(snd b)*', '*(snd c)*', '*(snd d)*', '*(snd e)*', '*(snd f)*', '*(snd g)*', '*(snd h)*', '*(snd i)*', '*(snd j)*'];

// Function to determine if the current path is a send lane
function isSendLane(path) {
    return path.includes('*(snd ');
}

const originalTrackNames = sf.ui.proTools.selectedTrackNames;
sf.ui.proTools.appActivateMainWindow();

// Get the current index from global state, defaulting to 0 if not set
let currentIndex = globalState.combinedPathIndex !== undefined ? globalState.combinedPathIndex : 0;
let pathDisplayed = false;
let sendButtonIndex = globalState.sendButtonValue !== undefined ? globalState.sendButtonValue : 0;
let sendLaneCheckDone = false;

while (!pathDisplayed && originalTrackNames.length > 0) {
    const currentPath = combinedPaths[currentIndex];

    if (isSendLane(currentPath)) {
        let trackFound = false;
        
        for (let i = 0; i < originalTrackNames.length; i++) {
            const trackNameToCheck = originalTrackNames.slice(i);
            try {
                var sendButtonValue = sf.ui.proTools.trackGetByName({ name: trackNameToCheck[0] }).track.sendButtons[sendButtonIndex].value.value;
                if (sendButtonValue !== "unassigned") {
                    sf.ui.proTools.trackSelectByName({ names: trackNameToCheck });
                    sf.ui.proTools.selectedTrack.trackDisplaySelect({
                        displayPath: [currentPath, "level"],
                        selectForAllSelectedTracks: true,
                        useWildcards: true
                    });
                    pathDisplayed = true;
                    trackFound = true;
                    break; // Exit the for loop if a valid send button is found
                }
            } catch (error) {
                // Handle error or continue to the next track
            }
        }

        if (!trackFound) {
            sendButtonIndex = (sendButtonIndex + 1) % 9; // Increment sendButtonIndex if no track with the send is found
        } else {
            sendButtonIndex = (sendButtonIndex + 1) % 9; // Increment sendButtonIndex for the next run after a valid send is found
        }
    } else {
        // Not a send lane
        sf.ui.proTools.trackSelectByName({ names: originalTrackNames });
        sf.ui.proTools.selectedTrack.trackDisplaySelect({
            displayPath: [currentPath],
            selectForAllSelectedTracks: true,
            useWildcards: true
        });
        pathDisplayed = true;
        sendButtonIndex = 0; // Reset sendButtonIndex if not a send lane
    }

    if (!pathDisplayed || pathDisplayed) {
        currentIndex = (currentIndex + 1) % combinedPaths.length;
    }
}


// Update global state for the next run
globalState.sendButtonValue = sendButtonIndex; // Increment or reset sendButtonIndex
globalState.combinedPathIndex = currentIndex;
sf.ui.proTools.trackSelectByName({ names: originalTrackNames });