Importing to Mix Template in Logic Pro - assistance required

Unhelpful post from me, but interested in what you/others find. I've looked into macros for importing into a template several times but have not had any luck with streamlining the process. I think some of the problems is that there are no real keyboard shortcuts in Logic for this process so it relies on mouse position/clicks and Logic has no real function to get track names. And if you are anything like me, you'll have tracks in the recording project that you don't import into the mix template.
I'm wondering if looking at the import in the opposite way might be easier .... as in import template tracks / busses etc into the recording project. I would still require manual shuffling though.

My current process is I'll import tracks into the template all in one go, manually move each track to the right spot and then have a bunch of SF buttons that can change the output , colour etc

Hi @Mr_Jake_E_Skinner & @Matthew_Brabender

This is a really cool workflow idea that I should investigate. I'll take a look at this later in the week and see if it's possible. :-)

And Jake, thanks for the video, it was really helpful.

Bump this thread on Monday if you don't hear from me.

Hi @Mr_Jake_E_Skinner, @Matthew_Brabender & @Alex_Oldroyd8

I'm making progress... But still need to do a bit of work to make it robust... thought I'd share my progress in case you thought I'd forgotten about it.

Here is a video of it in action... Select the matching track name in the Mixing project that matches a track name in the Tracking project. Then run the script.

Will hopefully have more time to get this over the line next week.
Woo!

Awesome Kitch! I can't wait to try this out!

Would it work the other way round too? I.e selecting the tracks that you want to import and have them automatically go to the correct tracks in the template?

Hi @Mr_Jake_E_Skinner, @Matthew_Brabender & @Alex_Oldroyd8,

Select the tracks (in the tracks area) that you want to import matching tracks to, then run the script.

The script will ask for the location of the session you want to import from, and then it will proceed to import the tracks.

It will no doubt need some work, but here it is for now.

const logic = sf.ui.logic;
logic.appActivateMainWindow();

const mainWindow = logic.mainWindow;
mainWindow.invalidate();

const sessionName = mainWindow.getString("AXTitle");
const sessionPath = decodeURIComponent(mainWindow.getString("AXDocument")).slice(0, -1);
const sessionDirectory = sessionPath.split("/").slice(0, -1).join("/") + "/";

const browsersGroup = mainWindow.groups.allItems[3].groups.whoseDescription.is("All Files").first;
const browsersPanel = browsersGroup.groups.whoseDescription.is("All Files").first;

function getSessionDirectoryPath() {
    try {
        // Session Path
        const sessionDirectoryPath = decodeURIComponent(mainWindow.invalidate().getString("AXDocument")).slice(0, -1).replace("file://", "");
        return sessionDirectoryPath;

    } catch (err) {
        throw `There was an error fetching the Session Directory Path`;
    }
}

function getLogicRowElementByTrackName(trackName, column) {
    const allFilesTable = browsersPanel.scrollAreas.first.tables.first;
    const rows = allFilesTable.children.whoseRole.is("AXRow");

    const rowTitles = allFilesTable.groups.first.children;
    const columnLookupTable = rowTitles.map(c => c.title.value);

    const targetRow = rows.find(c => c.textFields[columnLookupTable.indexOf("Name")].value.value === trackName);

    return targetRow.children[columnLookupTable.indexOf(column)];
}

function getTrackName(track) {
    try {
        const trackDescription = track.getString("AXDescription");
        const trackName = trackDescription.match(/“([^"]+)”/)[1];

        return trackName;
    } catch (err) {
        throw err
    }
}

function getSelectedTracks() {
    const trackHeadersGroup = mainWindow.invalidate().trackHeadersGroup;
    return trackHeadersGroup.getElements('AXSelectedChildren');
}

function focusTrack(track) {
    const hasFocusBtn = track.radioButtons.first;

    // Focus track
    hasFocusBtn.elementSetAttributeValue({
        attributeName: "AXFocused",
        attributeValue: true
    });

    hasFocusBtn.elementClick();
}

function doForEachSelectedTrack({ action }) {
    const selectedTracks = getSelectedTracks();
    const firstSelectedTrack = selectedTracks[0];

    selectedTracks.forEach(track => {
        focusTrack(track);// Focus track

        try {
            action(track);
        } catch (err) {
            throw err;
        } finally {
            focusTrack(track); // Refocus Track
        }
    });

    focusTrack(firstSelectedTrack); // Focus first track
}

function trackFunction(track) {
    try {
        const trackName = getTrackName(track);
        const contentCheckbox = getLogicRowElementByTrackName(trackName, "Content");
        const replaceButton = browsersPanel.buttons.whoseTitle.is("Replace").first;

        // Enable focus for checkbox
        contentCheckbox.elementSetAttributeValue({
            attributeName: "AXFocused",
            attributeValue: true
        });

        // Enable Content Checkbox
        contentCheckbox.elementClick({ actionName: "AXPress", onError: "Continue" });
        sf.waitFor({
            callback: () => contentCheckbox.invalidate().value.intValue === 1, // Wait for checkbox to becom active
            timeout: 1000
        }, `Failed waiting for checkbox to be selected`);



        replaceButton.elementClick({ actionName: "AXPress" });

    } catch (err) {
        throw err
    }
}

function refreshAllFilesPanel() {
    const allFilesRadioButton = mainWindow.radioGroups.first.radioButtons.whoseDescription.is("All Files").first;

    const allFilesGroup = mainWindow.groups.find(g => {
        return g.children.first.getString("AXDescription") === "All Files"
    }).getFirstWithDescription("All Files");

    const allFilesSubGroup = allFilesGroup && allFilesGroup.groups.whoseDescription.is("All Files").first;
    const computerBtn = allFilesSubGroup.groups.find(g => g.buttons.first.getString("AXHelp") === "Computer").buttons.first

    if (computerBtn.exists) {
        computerBtn.elementClick();
    }
}

function navigateToTargetProjectPath({ targetProjectPath }) {
    // try {
    const logic = sf.ui.logic;
    logic.appActivateMainWindow();

    logic.menuClick({ menuPath: ["File", "Import", "Logic Projects…"] });

    const importWindow = logic.windows.whoseTitle.is("Import").first;

    sf.waitFor({
        callback: () => importWindow.invalidate().exists,
        timeout: 1000
    }, `Failed waiting for`);

    sf.wait({ intervalMs: 200 });

    const importButton = importWindow.buttons.whoseTitle.is("Import").first;

    sf.keyboard.press({ keys: "slash" });

    // Required wait for "Go To" Sheet.
    sf.wait({ intervalMs: 100 });

    const sheet = importWindow.sheets.first;

    sheet.elementWaitFor();

    const goToTextField = sheet.textFields.first

    goToTextField.elementWaitFor({}, `There was an error opening the go to sheet`);

    // Set the Text Field 
    goToTextField.elementSetTextFieldWithAreaValue({ value: targetProjectPath }, `Could not set the directory path in "Go To" text field. Path: ${targetProjectPath}`);

    sf.waitFor({
        callback: () => goToTextField.value.invalidate().value === targetProjectPath,
        timeout: 2000,
    }, `Could not update the path text field`);

    // Accept/Close the sheet
    sf.keyboard.press({ keys: "return" });

    sheet.elementWaitFor({ waitForNoElement: true }, `Failed waiting for Go To Sheet to disappear`);

    sf.wait({ intervalMs: 200 });

    importButton.elementWaitFor();

    importButton.elementClick();

    importButton.elementWaitFor({ waitForNoElement: true }, `Failed waiting import window to dissapear`);
    /*     } catch (err) {
            throw `There was an error selecting the project path: "${targetProjectPath}" ${err}`;
        } */
}

function checkForTrackNumbers(trackNames) {
    const trackArea = mainWindow.getFirstWithDescription('Tracks').groups.whoseDescription.is('Tracks');
    const trackHeaders = trackArea.allItems[1].splitGroups.first.splitGroups.allItems[1].scrollAreas.first.groups.whoseDescription.is('Tracks header').first;
    const selectedTrackNames = trackHeaders.getElements('AXSelectedChildren').map(trackHeader => trackHeader.getString("AXDescription").match(/“(.*)”/)[1]);

    const seen = new Set();
    for (const trackName of selectedTrackNames) {
        if (seen.has(trackName)) {
            // Duplicate found
            throw `Duplicate track name found: "${trackName}"`;
        }
        seen.add(trackName);
    }
    return false; // No duplicates found
}

function importAudio() {
    sf.interaction.displayDialog({
        buttons: ["Cancel", "Proceed"],
        cancelButton: "Cancel",
        defaultButton: "Proceed",
        prompt: `For this script to work correctly please make sure that...\n• Track control surface bars are hidden.\n• Track numbers are visible`
    });

    refreshAllFilesPanel();

    // Check selected track names for duplicates
    checkForTrackNumbers();

    // Get the session directory path
    const sessionDirectoryPath = getSessionDirectoryPath();

    // Ask user to select the project they's like to import
    const targetProjectPath = sf.interaction.selectFile({
        prompt: `Please select the Logic Project that you'd like to import tracks from.`,
        allowedFileTypes: ["logicx"],
        defaultLocation: sessionDirectoryPath,
    }).path;

    navigateToTargetProjectPath({ targetProjectPath });

    doForEachSelectedTrack({ action: trackFunction, });

    sf.interaction.displayDialog({
        giveUpAfterSeconds: 2,
        prompt: "Track import complete"
    });
}

importAudio();

It may take me some time to get this working in the reverse order where you select the tracks from the browser instead, but will keep you posted if/when I make any progress.

Rock on!