Remove Inactive Inserts or Sends or both

Hi @Sreejesh_Nair . Very excited to use this - I think the way you've described it working is a really big improvement on previous attempts at scripts like this. I can't get this to work on either my macbook pro or my studio computer (both ventura, 2023.12). I've tried it on new sessions with just inactive sends or inserts or both, and existing, busier sessions with sends, inserts and both. It seems do everything except remove the inserts. As you can see from the screen recording I took, there's nothing obstructing the send/insert buttons, and you've obviously incorporated track height handling. I see that you posted this script a couple of days before 2023.12 was released, and I'm wondering if that ProTools update has made this fail? For context, even though in the video I chose to remove inactive sends and inserts, I got the same result with choosing sends or inserts by themselves. The "Analysing session for inactive plugins/sends. Please wait" and "Analysis complete. Proceeding." messages still get logged. Any ideas what might be causing this?

Thanks!

Hello @Sreejesh_Nair

Thanks for writing/sharing this script. I was looking for ways to make the original remove inactive plugs/sends script faster by option-clicking and found this. You've pulled it off, great job!

I had a few issues running the script above, or the one from your package, perhaps things have changed with PT versions or our workflows are different. The script above breaks when trying to find the track height (line 90), so I replaced the function. I also had issues with line 17, so I've modified the findInactiveItems function. I also included a track filter so it only selects tracks with plugins/sends and brings them into view. Lastly I added some error handling so it restores the track heights if it fails.

This script generally seems to work well for me. Keen to hear if it works for you or @danielkassulke or if any issues? My only issue is that it takes an inordinate amount of time to analyze an entire session (i actually haven't let it run long enough to test it as its +15 minutes). I find it quicker to batch select tracks, so wondering if you have the same issue?

const ignorePlugins = ["Melodyne", "Auto-Tune"]

const proToolsMenuOptions = ["Inserts A-E", "Inserts F-J", "Sends A-E", "Sends F-J"];

function closeDialog() {
    const titles = ['Remove', 'Change'];
    titles.forEach(title => {
        if (sf.ui.proTools.confirmationDialog.invalidate().buttons.whoseTitle.is(title).first.exists) {
            sf.ui.proTools.confirmationDialog.buttons.whoseTitle.is(title).first.elementClick();
            sf.ui.proTools.confirmationDialog.elementWaitFor({ waitType: "Disappear" });
        }
    });
}

function hideAllFloatingWindows() {
    //Hide all floating windows
    sf.ui.proTools.menuClick({
        menuPath: ["Window", "Hide All Floating Windows"],
        targetValue: "Enable",
    });
}

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: selectedTracks })
};


function saveCurrentTrackView() {
    sf.ui.proTools.appActivateMainWindow();
    sf.keyboard.press({
        keys: "numpad enter",
    });
    sf.ui.proTools.newMemoryLocationDialog.elementWaitFor();
    //Wait for the Mem Location dialog to appear and assign it to the memLocDlg variable
    var memLocDlg = sf.ui.proTools.dialogWaitForManual({
        dialogTitle: 'New Memory Location'
    }).dialog;
    // We only want to store the track visibilty so clear all check boxes and then check the appropriate one
    var checkBoxes = memLocDlg.getElements("AXChildren").filter(function (e) { return e.fullRole == "AXCheckBox" });
    for (var i = 0; i < 6; i++) {
        checkBoxes[i].checkboxSet({
            targetValue: "Disable",
        });
    }
    checkBoxes[2].checkboxSet({
        targetValue: "Enable",
    });
    checkBoxes[3].checkboxSet({
        targetValue: "Enable",
    });
    //Name the Location Track Visibilty

    sf.ui.proTools.newMemoryLocationDialog.textFields.allItems[0].elementSetTextFieldWithAreaValue({
        value: "Track Visibility",
    });
    //Get the Location Number and pass it back so we can delete it when we're done
    var locationNumber = sf.ui.proTools.newMemoryLocationDialog.textFields.allItems[1].value.value;

    // Set time Properties to none
    sf.ui.proTools.newMemoryLocationDialog.radioButtons.allItems[2].elementClick();
    //Create the Location
    sf.ui.proTools.newMemoryLocationDialog.buttons.whoseTitle.is('OK').first.elementClick();

    sf.ui.proTools.newMemoryLocationDialog.elementWaitFor({
        waitType: "Disappear",
    });

    return locationNumber;
}

function recallAndDeleteTrackView(locationNumber) {

    sf.ui.proTools.memoryLocationsGoto({
        memoryLocationNumber: Number(locationNumber),
    });

    sf.ui.proTools.memoryLocationsShowWindow();

    sf.ui.proTools.memoryLocationsWindow.popupButtons.whoseTitle.is('Memory Locations').first.popupMenuSelect({
        menuSelector: items => items.filter(i => i.names[0].match(/^Delete \"/))[0]
    });
    sf.ui.proTools.confirmationDialog.buttons.whoseTitle.is("Yes").first.elementClick();


    sf.ui.proTools.confirmationDialog.elementWaitFor({
        waitType: "Disappear",
    });

    sf.ui.proTools.menuClick({
        menuPath: ["Window", "Memory Locations"],
        targetValue: 'Disable'  //or 'Enable' or 'Toggle'
    });
    sf.ui.proTools.memoryLocationsWindow.elementWaitFor({
        waitType: "Disappear",
    });
}


function findInactiveItems(tracks) {
    let map = { inserts: {}, sends: {} };
    let elements = { inserts: [], sends: [] };

    const getFrozenTrackState = (trackName) => {
        const track = sf.ui.proTools.trackGetByName({ name: trackName.normalizedTrackName }).track;
        const freezeBtn = track.buttons.whoseTitle.is("Frozen");
        return freezeBtn ? !freezeBtn.exists : true;
    };

    tracks.forEach(track => {
        if (track && (getFrozenTrackState(track))) {
            for (let i = 0; i < track.insertSelectorButtons.length; i++) {
                const button = track.insertSelectorButtons[i];
                const insertBtn = track.insertButtons[i];
                const plugName = insertBtn.value.invalidate().value;
                let plugExists = ignorePlugins.some(p => plugName.includes(p));
                if (button.exists
                    && button.invalidate().value.value.startsWith("inactive")
                    && (plugExists != true)) {

                    const slot = i + 1;
                    if (!map.inserts[slot]) {
                        map.inserts[slot] = [];
                        elements.inserts.push(slot);
                    }
                    map.inserts[slot].push(track.normalizedTrackName);
                }
            }
        }

        for (let i = 0; i < track.sendSelectorButtons.length; i++) {
            const button = track.sendSelectorButtons[i];
            if (button.exists && button.invalidate().value.value.startsWith("inactive")) {
                const slot = i + 1;
                if (!map.sends[slot]) {
                    map.sends[slot] = [];
                    elements.sends.push(slot);
                }
                map.sends[slot].push(track.normalizedTrackName);
            }
        }
    })

    return { map, elements };
}


function removeItems(names, type, slot) {

    sf.ui.proTools.trackSelectByName({ names: names, deselectOthers: true });
    const original = sf.ui.proTools.selectedTrackNames;
    if (original.length > 0) {
        sf.ui.proTools.trackGetByName({ name: original[0] }).track.trackScrollToView();
    }

    sf.ui.proTools.trackSelectByName({ names: names, deselectOthers: true });
    sf.ui.proTools.selectedTrack.trackInsertOrSendSelect({
        insertOrSend: type,
        pluginNumber: parseInt(slot, 10),
        selectForAllSelectedTracks: true,
        pluginPath: type === 'Insert' ? ['no insert'] : ['no send']
    });
    sf.wait({ intervalMs: 500 });
    closeDialog();
}


function batchRemove(map, elements, option) {

    if (option === "both" || option === "plugins") {
        map.inserts = map.inserts || {};
        elements.inserts.forEach(slot => {
            if (map.inserts[slot]) {
                removeItems(map.inserts[slot], 'Insert', slot);
            }
        });
    }

    if (option === "both" || option === "sends") {
        map.sends = map.sends || {};
        elements.sends.forEach(slot => {
            if (map.sends[slot]) {
                removeItems(map.sends[slot], 'Send', slot);
            }
        });
    }
}


function setTrackHeights(size) {

    const selectedTrackH = sf.ui.proTools.selectedTrackHeaders[0]
    const hasHeaderHeightPopup = selectedTrackH.frame.h <= 79

    try {
        selectedTrackH.popupMenuSelect({
            anchor: "MidRight",
            relativePosition: { x: - 10, y: 0 },
            menuPath: [size],
            isOption: true,
            onError: "Continue",
        })
    } catch (err) {
        // Try header left poput
        if (hasHeaderHeightPopup) {
            sf.ui.proTools.selectedTrack.popupButtons.allItems[2].popupMenuSelect({
                menuPath: ["Track Height", size],
                isOption: true,
            });
        };
    };
};


function activateProToolsMenus(menuOptions) {
    menuOptions.forEach(menuOption => {
        sf.ui.proTools.menuClick({
            menuPath: ["View", "Edit Window Views", menuOption],
            targetValue: "Enable"
        });
    });
}


function selectAllVisibleTracks() {
    sf.ui.proTools.trackDeselectAll();

    const topOfEditWindow = sf.ui.proTools.mainWindow.timelineFocusButton.frame.y;

    const topTrack = sf.ui.proTools.visibleTrackHeaders.filter(h => h.frame.y >= topOfEditWindow)[0];

    topTrack.titleButton.mouseClickElement({ isOption: true });
}


function filterTracks(initialSelection) {

    sf.ui.proTools.appActivateMainWindow();

    //Create array of tracks with Inserts & Sends, from initially selected tracks
    var allVisibleSelectedTracks = initialSelection
        .filter(t => t != null && (
            t.title.value.includes("Audio Track")
            || t.title.value.includes("Aux Track")
            || t.title.value.includes('Inst Track')
            || t.title.value.includes('Routing Folder Track')
            || t.title.value.includes('Master Track'))
        )

    //log(allVisibleSelectedTracks);
    return allVisibleSelectedTracks
}


function onScreenMessage(job, x) {
    sf.interaction.displayDialog({
        prompt: job,
        giveUpAfterSeconds: x
    });
};



function startScript() {
    sf.ui.proTools.appActivate();
    //sf.ui.proTools.mainWindow.invalidate();

    //Get the current window name
    const focusedWindow = sf.ui.proTools.focusedWindow.title.invalidate().value.split(" ", 1)[0].slice(0, -1);

    //If not already in the Edit window, switch to the Edit window
    if (focusedWindow !== 'Edit') {
        try {
            sf.ui.proTools.menuClick({ menuPath: ['Window', 'Edit'] });
        }
        catch (err) { log('Could not focus Edit Window') }
    }

    let userViewNum = saveCurrentTrackView()

    hideAllFloatingWindows()

    let restoreTracks = sf.ui.proTools.selectedTrackHeaders.filter(t => t != null)

    // Check if Track List is Open
    const isTrackListOpen = () => sf.ui.proTools.getMenuItem('View', 'Other Displays', 'Track List').isMenuChecked

    const initialState = isTrackListOpen()

    // // Open Track List
    sf.ui.proTools.menuClick({ menuPath: ['View', 'Other Displays', 'Track List'], targetValue: "Enable" })


    //Ensure Link Track and Edit Selection is enabled
    const wasLinked = sf.ui.proTools.getMenuItem('Options', 'Link Track and Edit Selection').isMenuChecked;
    if (wasLinked) {
        sf.ui.proTools.menuClick({
            menuPath: ["Options", "Link Track and Edit Selection"],
        });
    }


    //Ensure Inserts and Sends are visible in Edit Window
    activateProToolsMenus(proToolsMenuOptions);

    sf.ui.proTools.invalidate();

    //Hide Inactive Tracks for clarity
    sf.ui.proTools.trackOpenListPopupMenu().popupMenu.menuClickPopupMenu({
        menuPath: ["Hide", "Inactive Tracks"],
    });

    //Store initial track selection
    var firstSelection = sf.ui.proTools.invalidate().trackGetSelectedTracks().trackHeaders.filter(t => t != null);

    //If no tracks selected, ask if entire session is to be processed
    if (firstSelection.length == 0) {
        var procSession = sf.interaction.displayDialog({
            buttons: ["Cancel", "Proceed"],
            defaultButton: 'Proceed',
            prompt: "No tracks selected, proceed with entire session?",
        }).button;
        if (procSession == 'Proceed') {

            sf.ui.proTools.trackSelectByName({
                names: sf.ui.proTools.visibleTrackNames
            });

        } else throw 0;

        var firstSelection = sf.ui.proTools.invalidate().trackGetSelectedTracks().trackHeaders.filter(t => t != null);
    }

    try {

        //Find and store tracks that have inactive Inserts and Sends (and isn't Frozen)
        let tracksForProcessing = filterTracks(firstSelection)

        if (tracksForProcessing.length == 0) {
            alert("There was an error, no tracks selected. Script cancelled.");
            throw 0;
        }

        //Select the suitable tracks ready for analysis
        scrollToTrackNamed(tracksForProcessing[0].normalizedTrackName, tracksForProcessing.map(t => t.normalizedTrackName))


        onScreenMessage("Analysing session for inactive plugins/sends. Please wait...", 3);

        const { map, elements } = findInactiveItems(tracksForProcessing);

        onScreenMessage("Analysis complete. Proceeding.", 2);

        //End script if no inactive Inserts or Sends found
        if (elements.inserts.length === 0 && elements.sends.length === 0) {
            onScreenMessage("No inactive plugins or sends found.", 1);

            throw 0;
        }
        //Set track height to small so can visually see more of session - mini is too small
        setTrackHeights('small');

        /////////////////////////////////////////////////////////////////////
        //Currently have removed options to remove only Inserts or only Sends - Script does both.  Plan to update with Command Template
        /////////////////////////////////////////////////////////////////////
        let option;
        /* //if (chosenOption === "Remove all Inactive Plugins and Sends") {
        //  option = "both";
        //} else if (chosenOption === "Remove all Inactive Plugins") {
        if (elements.inserts.length === 0) {
            alert("No inactive plugins found.");
            return;
        }
        //  option = "plugins";
        //} else if (chosenOption === "Remove all Inactive Sends") {
        if (elements.sends.length === 0) {
            alert("No inactive sends found.");
            return;
        }
        //  option = "sends";
        //} */
        option = 'both'

        batchRemove(map, elements, option);

        if (wasLinked) {
            sf.ui.proTools.menuClick({
                menuPath: ["Options", "Link Track and Edit Selection"],
            });
        }
    }
    catch (err) {
        //Handle the error
        log('Could not remove plugins/sends');
    }

    recallAndDeleteTrackView(userViewNum)

    if (restoreTracks.length != 0) {
        scrollToTrackNamed(restoreTracks[0].normalizedTrackName, restoreTracks.map(t => t.normalizedTrackName))
    }
    else { scrollToTrackNamed(firstSelection[0].normalizedTrackName, firstSelection.map(t => t.normalizedTrackName)) }

    // Set Track List to Initial State
    if (initialState != isTrackListOpen()) {
        sf.ui.proTools.menuClick({ menuPath: ['View', 'Other Displays', 'Track List'], targetValue: "Disable" })
    };

    onScreenMessage("Script Finished", 1)
}

startScript()

function batchRemove(map, elements, option) {
    let processedItems = 0, notificationID = sf.system.newGuid().guid, totalItems = elements.inserts.length + elements.sends.length;
    const removeFromSlot = (slot, type, map) => {
        removeItems(map[slot], type, slot);
        // Notify progress of removal
        sf.interaction.notify({ uid: notificationID, title: "Removing Inactive Items", progress: (++processedItems) / totalItems, message: `Removing ${type}s: ${processedItems} of ${totalItems}` });
    };
    if (option === "both" || option === "plugins") elements.inserts.forEach(slot => removeFromSlot(slot, 'Insert', map.inserts, elements.inserts));
    if (option === "both" || option === "sends") elements.sends.forEach(slot => removeFromSlot(slot, 'Send', map.sends, elements.sends));
    sf.interaction.notify({ uid: notificationID, title: "Removing Inactive Items", progress: 100, message: `Removal complete.` });
}

This is the new batch remove that I use with the notification that shows the progress of the removal as well. The option is because I have an interaction list that asks for all, or just sends or plugins.

This is amazing, and thank you to all involved.

I am dedicated to using my mouse as little as possible, as clicking through tiny sub-menus hidden behind tiny little dots in the Pro Tools Edit window is taking its toll on my mousing hand.

One thought/proposal: it would be REALLY nice to have the popup window auto-focus, instead of needing to click on the popup window with my mouse to bring into focus. I am going to dive into this when I have a chance, just wanted to make sure that I am not missing something that has already been implemented.

Which pop up window are you referring to?