Python InDesign scripting: Get overflowing textbox from preflight for automatic resizing

If all you need is to find and to fix the overset errors I'd propose this solution:

Here is the simple Extendscript to fix the text overset error. It decreases the font size in the all overflowed text frames in active document:

var doc = app.activeDocument;

var frames = doc.textFrames.everyItem().getElements();
var f = frames.length

while(f--) {
    var frame = frames[f];
    if (frame.overflows) resize_font(frame)
}

function resize_font(frame) {
    app.scriptPreferences.enableRedraw = false;
    while (frame.overflows) {
        var texts = frame.parentStory.texts.everyItem().getElements();
        var t = texts.length;
        while(t--) {
            var characters = texts[t].characters.everyItem().getElements();
            var c = characters.length;
            while (c--) characters[c].pointSize = characters[c].pointSize * .99;
        }
    }
    app.scriptPreferences.enableRedraw = true;
}

You can save it in any folder and run it by the Python script:

import win32com.client

app = win32com.client.Dispatch('InDesign.Application.CS6')
doc = app.Open(r'd:\temp\test.indd')

profile = app.PreflightProfiles.Item('Stackoverflow Profile')
print('Profile name:', profile.name)

process = app.PreflightProcesses.Add(doc, profile)
process.WaitForProcess()
errors = process.processResults
print('Errors:', errors)

if errors[:4] != 'None':
    script = r'd:\temp\fix_overset.jsx'  # <-- here is the script to fix overset
    print('Run script', script)
    app.DoScript(script, 1246973031)     # run the jsx script

    # 1246973031 --> ScriptLanguage.JAVASCRIPT
    # https://www.indesignjs.de/extendscriptAPI/indesign-latest/#ScriptLanguage.html

    process = app.PreflightProcesses.Add(doc, profile)
    process.WaitForProcess()
    errors = process.processResults
    print('Errors:', errors)             # it should print 'None'
    if errors[:4] == 'None':
        doc.Save()

doc.Close()

input('\nDone... Press <ENTER> to close the window')

Thanks to the exellent answer of Yuri I was able solve my problem, although there are still some shortcomings.

In Python, I load my documents and check if there are any problems detected during the preflight. If so, I move on to adjusting the text frames.

myDoc = app.Open(input_file_path)

profile = app.PreflightProfiles.Item(1)
process = app.PreflightProcesses.Add(myDoc, profile)
process.WaitForProcess()
results = process.processResults

if "None" not in results:
    # Fix errors
    script = open("data/script.jsx")
    app.DoScript(script.read(), 1246973031, variables.resize_array)

    process.WaitForProcess()
    results = process.processResults

    # Check if problems were resolved
    if "None" not in results:
        info_fail(card.name, "Error while running preflight")
        myDoc.Close(1852776480)
        return FLAG_PREFLIGHT_FAIL

I load the JavaScript file stored in script.jsx, that consists of several components. I start by extracting the arguments and loading all the pages, since I want to handle them individually. I then collect all text frames on the page in an array.

var doc = app.activeDocument;
var pages = doc.pages;
var resizeGroup = arguments[0];
var condenseGroup = arguments[1];

// Loop over all available pages separately
for (var pageIndex = 0; pageIndex < pages.length; pageIndex++) {
    var page = pages[pageIndex];
    var pageItems = page.allPageItems;
    var textFrames = [];

    // Collect all TextFrames in an array
    for (var pageItemIndex = 0; pageItemIndex < pageItems.length; pageItemIndex++) {
        var candidate = pageItems[pageItemIndex];
        if (candidate instanceof TextFrame) {
            textFrames.push(candidate);
        }
    }

What I wanted to achieve was a setting where if one of a group of text frames was overflowing, the text size of all the text frames in this group are adjusted as well. E.g. text frame 1 overflows when set to size 8, no longer when set to size 6. Since text frame 1 is in the same group as text frame 2, both of them will be adjusted to size 6 (assuming the second frame does not overflow at this size).

In order to handle this, I pass an array containing the groups. I now check if the text frame is contained in one of these groups (which is rather tedious, I had to write my own methods since InDesign does not support modern functions like filter() as far as I am concerned...).

// Check if TextFrame overflows, if so add all TextFrames that should be the same size
    for (var textFrameIndex = 0; textFrameIndex < textFrames.length; textFrameIndex++) {
        var textFrame = textFrames[textFrameIndex];

        // If text frame overflows, adjust it and all the frames that are supposed to be of the same size
        if (textFrame.overflows) {
            var foundResizeGroup = filterArrayWithString(resizeGroup, textFrame.name);
            var foundCondenseGroup = filterArrayWithString(condenseGroup, textFrame.name);
            var process = false;
            var chosenGroup, type;

            if (foundResizeGroup.length > 0) {
                chosenGroup = foundResizeGroup;
                type = "resize";
                process = true;
            } else if (foundCondenseGroup.length > 0) {
                chosenGroup = foundCondenseGroup;
                type = "condense";
                process = true;
            }

            if (process) {
                var foundFrames = findTextFramesFromNames(textFrames, chosenGroup);
                adjustTextFrameGroup(foundFrames, type);
            }
        }
    }

If this is the case, I adjust either the text size or the second axis of the text (which condenses the text for my variable font). This is done using the following functions:

function adjustTextFrameGroup(resizeGroup, type) {
    // Check if some overflowing textboxes
    if (!someOverflowing(resizeGroup)) {
        return;
    }

    app.scriptPreferences.enableRedraw = false;

    while (someOverflowing(resizeGroup)) {
        for (var textFrameIndex = 0; textFrameIndex < resizeGroup.length; textFrameIndex++) {
            var textFrame = resizeGroup[textFrameIndex];
            if (type === "resize") decreaseFontSize(textFrame);
            else if (type === "condense") condenseFont(textFrame);
            else alert("Unknown operation");
        }
    }

    app.scriptPreferences.enableRedraw = true;
}

function someOverflowing(textFrames) {
    for (var textFrameIndex = 0; textFrameIndex < textFrames.length; textFrameIndex++) {
        var textFrame = textFrames[textFrameIndex];
        if (textFrame.overflows) {
            return true;
        }
    }

    return false;
}

function decreaseFontSize(frame) {
    var texts = frame.parentStory.texts.everyItem().getElements();
    for (var textIndex = 0; textIndex < texts.length; textIndex++) {
        var characters = texts[textIndex].characters.everyItem().getElements();
        for (var characterIndex = 0; characterIndex < characters.length; characterIndex++) {
            characters[characterIndex].pointSize = characters[characterIndex].pointSize - 0.25;
        }
    }
}

function condenseFont(frame) {
    var texts = frame.parentStory.texts.everyItem().getElements();
    for (var textIndex = 0; textIndex < texts.length; textIndex++) {
        var characters = texts[textIndex].characters.everyItem().getElements();
        for (var characterIndex = 0; characterIndex < characters.length; characterIndex++) {
            characters[characterIndex].setNthDesignAxis(1, characters[characterIndex].designAxes[1] - 5)
        }
    }
}

I know that this code can be improved upon (and am open to feedback), for example if a group consists of multiple text frames, the procedure will run for all of them, even though it need only be run once. I was getting pretty frustrated with the old JavaScript, and the impact is negligible. The rest of the functions are also only helper functions, which I'd like to replace with more modern version. Sadly and as already stated, I think that they are simply not available.

Thanks once again to Yuri, who helped me immensely!