Create New Track from Send Menu on Selected Tracks Script Help

Here's a new version, I changed it a bit and fixed the failing when inserts were expanded.

The thing I'm still figuring, and need your help is the behaviour of the closing inserts and sends in the end.
If you always have the same inserts and sends view on both edit and mix windows, the script should be fine. But if you have different views, please explain how you use them so I can think of a solution.

About the moving to edit to do its thing, and going back to mix. It seams to be possible to do how you are asking, but because the edit and mix windows return completely different locations of the elements and have a fairly different behaviour, it would mean a complete and much more complex script just for the mix and this one just for the edit. And it could be much more unstable.

try this and let me know how it works.

/**
* @param {string} sendAssignment
*/
function assignToNewTrack(sendAssignment) {
    const selectedTracks = sf.ui.proTools.selectedTrackNames
    sf.ui.proTools.trackGetByName({ name: selectedTracks[selectedTracks.length - 1] }).track.groups.whoseTitle.is(getGroup("Sends", sendAssignment)).first.buttons.whoseTitle.is(`Send Assignment ${sendAssignment}`).first.popupMenuSelect({
        isShift: true,
        isOption: true,
        menuPath: ["new track..."],
    });
}

function moveSendWinOutOfSlots() {
    sf.ui.proTools.invalidate()

    const sendWin = sf.ui.proTools.mainTrackOutputWindow.elementWaitFor().element
    const sendWinPos = sendWin.position.x
    const sendSlots = sf.ui.proTools.selectedTrack.groups.whoseTitle.is("Inserts A-E").first
    const sendSlotsPos = sendSlots.position.x

    if (sendWinPos - sendSlotsPos < 450 && sendSlotsPos - sendWinPos < 170) {
        sendWin.windowMove({
            position: {
                y: sendWin.position.y,
                x: sendSlotsPos + 450
            }
        })
    }
}

function getFirstFreeSend() {
    const selectedTracks = sf.ui.proTools.selectedTrackHeaders
    const sendLetters = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]
    let sendAssignmentList = []
    for (let i = 0; i < selectedTracks.length; i++) {
        let trackInfo = sf.ui.proTools.trackGetByName({ name: selectedTracks[i].normalizedTrackName })
            .track.sendButtons.filter(x => x.value.invalidate().value != "unassigned").map(x => x.title.invalidate().value.split(" ")[2])
        sendAssignmentList.push(...trackInfo)
    }

    const firstFreeSend = sendLetters.filter(letter => sendAssignmentList.indexOf(letter) === -1)[0]

    if (firstFreeSend) {
        return firstFreeSend
    } else {
        alert("Must have at least one free send, that is the same for all tracks.")
        throw 0
    };
};


/**
* @param {'Insert'|'Send'} slotType
* @param {array} [defaultUsedSlots] = [] - If parameter is not used, default is []
*/
function getFirstFreeInsertOrSend(slotType, defaultUsedSlots) {

    let buttons
    slotType == "Insert" ? buttons = "insertButtons" : buttons = "sendButtons"

    const selectedTracks = sf.ui.proTools.selectedTrackHeaders
    const sendLetters = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]
    let sendAssignmentList = defaultUsedSlots || []
    try {
        for (let i = 0; i < selectedTracks.length; i++) {
            let trackInfo = sf.ui.proTools.trackGetByName({ name: selectedTracks[i].normalizedTrackName })
                // .insertButtons or .sendButtons
                .track[buttons].filter(x => x.value.invalidate().value != "unassigned").map(x => x.title.invalidate().value.split(" ")[2])
            sendAssignmentList.push(...trackInfo)
        }
    } catch (err) { }
    const firstFreeSend = sendLetters.filter(letter => sendAssignmentList.indexOf(letter) === -1)[0]

    if (firstFreeSend) {
        return firstFreeSend
    } else {
        if (slotType == "Insert") { alert(`Must have at least one free ${slotType} slot.`) }
        else if (slotType == "Send") { alert(`Must have at least one free ${slotType} slot, that is the same for selected tracks.`) }
        throw 0
    };
};


/**
* @param {string} sendLetter
* @param {'Inserts'|'Sends'} slotType
*/
function getGroup(slotType, sendLetter) {
    let group
    sendLetter.toLowerCase().charCodeAt(0) - 97 <= 4 ? group = `${slotType} A-E` : group = `${slotType} F-J`
    return group
}



function newTrackSettings() {
    const newTrackWin = sf.ui.proTools.windows.whoseTitle.is("New Track").first.elementWaitFor().element

    const format = newTrackWin.popupButtons.whoseTitle.is("Stereo").first
    const type = newTrackWin.popupButtons.whoseTitle.is("Aux Input").first
    const timeBase = newTrackWin.popupButtons.whoseTitle.is("Samples").first

    if (format.value.invalidate().value != "Stereo") { format.popupMenuSelect({ menuPath: ["Stereo"] }); }
    if (type.value.invalidate().value != "Aux Input") { type.popupMenuSelect({ menuPath: ["Aux Input"] }); }
    if (timeBase.value.invalidate().value != "Samples") { timeBase.popupMenuSelect({ menuPath: ["Samples"] }); }

    newTrackWin.checkBoxes.whoseTitle.is("Create next to current track").first.checkboxSet({ targetValue: "Enable" });

    //  Wait to name track and press ok
    newTrackWin.elementWaitFor({ waitType: "Disappear", timeout: -1 })
    sf.ui.proTools.invalidate()
}

/**
 * @param {'Enable'|'Disable'} targetValue
 * @param {array} [viewsNames] = [] - If parameter is not used, default is set inside
 */
function setWindowViews(targetValue, viewsNames) {
    let views = viewsNames || ["Inserts A-E", "Inserts F-J", "Sends A-E", "Sends F-J"]

    views.forEach(view => {
        sf.ui.proTools.menuClick({ menuPath: ["View", "Edit Window Views", view], targetValue: targetValue })
        // sf.ui.proTools.menuClick({ menuPath: ["View", "Mix Window Views", view], targetValue: targetValue })
    })
}


const getSelectedTrackOut = (trackName) => sf.ui.proTools.trackGetByName({ name: trackName }).track.outputPathButton.title.invalidate().value.split('\n')[1].trim();



let insertSlot
let firstFreeSend
function actions() {

    const originalSelectedTracks = sf.ui.proTools.selectedTrackNames

    // Save first selected track output on variable
    const firstSelectedOut = getSelectedTrackOut(originalSelectedTracks[0])

    //  Get free sends
    firstFreeSend = getFirstFreeInsertOrSend("Send")

    // Assign new send to new track
    assignToNewTrack(firstFreeSend)

    // New track setting and wait for track name
    newTrackSettings()

    // If new send win is blocking the inserts or sends, move win away
    moveSendWinOutOfSlots()

    // Expand created send
    sf.ui.proTools.menuClick({ menuPath: ["View", "Expanded Sends", `Send ${firstFreeSend}`], targetValue: "Enable" })

    // Solo safe new Aux
    const selectedTracks = sf.ui.proTools.selectedTrackNames
    const auxTrack = sf.ui.proTools.trackGetByName({ name: selectedTracks[selectedTracks.length - 1] }).track
    auxTrack.trackSelect()
    auxTrack.trackScrollToView()
    auxTrack.buttons.whoseTitle.is("Solo").first.mouseClickElement({ isCommand: true })

    // set new aux output
    if (getSelectedTrackOut(auxTrack.normalizedTrackName) != firstSelectedOut) {
        auxTrack.trackOutputSelect({ outputSelector: items => items.filter(item => item.element.title.value.includes(firstSelectedOut))[0] })
    }

    // Get free insert slot after A
    insertSlot = getFirstFreeInsertOrSend("Insert", ["A"])


    // Open search...
    auxTrack.groups.whoseTitle.is(getGroup("Inserts", insertSlot)).first
        .buttons.whoseTitle.is(`Insert Assignment ${insertSlot}`)
        .first.popupMenuSelect({
            menuPath: ["search..."],
        });


    // Wait to open new plug
    while (true) {
        const plugIsOpen = auxTrack.groups.whoseTitle.is(getGroup("Inserts", insertSlot)).first
            .buttons.whoseTitle.is(`Insert Assignment ${insertSlot}`).first
            .value.invalidate().value != "unassigned"

        if (!plugIsOpen) {
            sf.wait({ intervalMs: 1000 })
        } else {
            break;
        }
    }
    sf.ui.proTools.trackSelectByName({ names: originalSelectedTracks })
}




function main() {

    sf.ui.proTools.appActivateMainWindow();
    sf.ui.proTools.invalidate();

    // const isActiveInsGroupFMix = sf.ui.proTools.getMenuItem("View", "Mix Window Views", "Inserts F-J").isMenuChecked
    const isActiveInsGroupFEdit = sf.ui.proTools.getMenuItem("View", "Edit Window Views", "Inserts F-J").isMenuChecked

    // const isActiveSendGroupFMix = sf.ui.proTools.getMenuItem("View", "Mix Window Views", "Sends F-J").isMenuChecked
    const isActiveSendGroupFEdit = sf.ui.proTools.getMenuItem("View", "Edit Window Views", "Sends F-J").isMenuChecked


    const isEditWin = sf.ui.proTools.focusedWindow.title.value.startsWith("Edit")
    if (!isEditWin) { sf.ui.proTools.menuClick({ menuPath: ["Window", "Edit"] }) }

    // Close expand created sends
    sf.ui.proTools.menuClick({ menuPath: ["View", "Expanded Sends", "None"], targetValue: "Enable" })

    setWindowViews("Enable")

    try {
        actions()
    } catch (err) { throw err }
    finally {

        //  Go to mix if needed
        if (!isEditWin) { sf.ui.proTools.menuClick({ menuPath: ["Window", "Mix"] }) }

        // Close Inserts Views if not needed
        if (insertSlot.toLowerCase().charCodeAt(0) - 97 <= 4 && (/* !isActiveInsGroupFMix || */ !isActiveInsGroupFEdit)) {
            // if (!isActiveInsGroupFMix) { setWindowViews("Disable", ["Inserts F-J"]) }
            if (!isActiveInsGroupFEdit) { setWindowViews("Disable", ["Inserts F-J"]) }
        }


        // Close Sends F-J if not needed
        if (firstFreeSend.toLowerCase().charCodeAt(0) - 97 <= 4 && (/* !isActiveSendGroupFMix || */ !isActiveSendGroupFEdit)) {
            //  if (!isActiveSendGroupFMix) { setWindowViews("Disable", ["Sends F-J"]) }
            if (!isActiveSendGroupFEdit) { setWindowViews("Disable", ["Sends F-J"]) }
        }

    }
}

main()

UPDATED ABOVE: now it will set the new aux out, the same as the first selected track.

As for the views, as it is now, it will open all sends and inserts and close them if they are not needed, or not close them if they were opened on edit or mix.

Hey Philip,

Not getting the error if slot A is used. But noticed that the send window, when it opens can get on top of the inserts, and in that case, it will fail. I'll try to find a solution.
Send me the error with the line so I try to find it.

About the F-J, if they are open before you start the script, they wont close. They only close if they were not open and the send or insert didn't use any F-J. Are you getting a different behaviour?

Updated above,

Now, If the new send window opens and covers the track header, inserts, sends or i/o, the window will be moved away.

Removed code for opening and closing the sends and inserts on the mix window. Only the edit widow will change now, with the same rules (I hope).

There are a few commented bits on the code, just so you test it, I'll clean it later.

Let me know how it goes.

i requested this and a few people were helping with one but i haven't seen one that works as solidly as this script yet...

Oops that formatting got messed up so you can't see my line numbers, maybe it's readable anyhow?