"Track Scroll To View" with multiple Track selections

I noticed you found this getMenuItems() function, to set the menus back to original you can use it this way:

// set original views
menuClick(viewMenu.menuAllEnabled, "Enable")
menuClick(viewMenu.menuAllDisabled, "Disable")

Hi, Samuel!

I tried inserting what you told me between "// Open search ..." and "// Wait to open new plug", but it didn't work.
When I press the Esc key to close the plugin search window, the soundflow process doesn't end there, and it doesn't go any further, so I have to manually run the stop all command.

sf.ui.proTools.appActivateMainWindow();

///Close Output Window_First
if (sf.ui.proTools.mainTrackOutputWindow.exists) {
    sf.ui.proTools.mainTrackOutputWindow.windowClose();
}

//memory original window
let originalWin = sf.ui.proTools.focusedWindow.title.value.split(":").slice(0, 1).join(":")

// Get originally selected tracks and first orig selected track
const origSelectedTracks = sf.ui.proTools.selectedTrackNames;
const firstSelectedTrack = origSelectedTracks[0];

/**
* @param {string} trackName
* @param {string[]} selectedTracks
*/
function scrollToTrackNamed(trackName, selectedTracks) {
    // Open scroll to track dialog and enter track name
    sf.ui.proTools.menuClick({ menuPath: ['Track', 'Scroll to Track...'] });
    var confirmationDialogWin = sf.ui.proTools.confirmationDialog;

    confirmationDialogWin.elementWaitFor();

    confirmationDialogWin.textFields.first.elementSetTextFieldWithAreaValue({ value: trackName });

    confirmationDialogWin.buttons.whoseTitle.is('OK').first.elementClick();

    confirmationDialogWin.elementWaitFor({ waitType: 'Disappear' });

    //Re-select originally selected tracks
    sf.ui.proTools.trackSelectByName({ names: origSelectedTracks })
};

scrollToTrackNamed(firstSelectedTrack, origSelectedTracks);


/**
 * @param {array} path - menu full path
 * @param {'Enable'|'Disable'} targetValue
 */
function menuClick(path, targetValue) {
    sf.ui.proTools.menuClick({ menuPath: path, targetValue: targetValue });
}



/**
* @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 })
    //Track Color
    sf.ui.proTools.colorsSelect({
        colorNumber: 20,
    });


    // 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 while search is open
    while (true) {
        const searchWin = sf.ui.proTools.invalidate().windows.whoseTitle.startsWith("Search Inserts").exists

        if (searchWin) {
            sf.wait({ intervalMs: 1000 })
        } else {
            break;
        }
    }

    // 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 {



        // 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()

//show original window
sf.ui.proTools.menuClick({ menuPath: ["Window", originalWin] });

log("Create New AUX DONE!!!")

I want to do either of the following.

(a). Pressing the Esc key while the plug-in search window is displayed cancels the script
or
(b). Press the Esc key while the plug-in search window is displayed to skip the plug-in insert and proceed to "function main ()"

Maybe this script will wait for the plugin window to appear even if it goes through the plugin search window, so I'm trying various things to add the command "press Esc to exit the script". (I didn't know how to jump to a different location in the script like (b)...)

While researching Java, I thought that something like the following would suit my purpose, but it seems that something is wrong, doesn't work as expected. (the plugin search window closes automatically, or immediately stops after launching the plugin from the plugin search window. )

if (sf.keyboard.press({
    keys: "escape",
})) {
    log('Cancelled');
    throw 0;
}

or

while (true) {
    const searchWin = sf.ui.proTools.invalidate().windows.whoseTitle.startsWith("Search Inserts").exists

    if (searchWin) {
        sf.wait({ intervalMs: 1000 })
    } else if (sf.keyboard.press({
        keys: "escape",
    })) {
        log('Cancelled');
        throw 0;
    } else {
        break;
    }
}

Can you point out some mistakes or give me some advice?