How do I accurately detect overset contents when using tables?

I know this is an old question but I found myself facing the same problem and I think this is a simpler answer. If an insertion point is overset, it's baseline property will not be available. Accessing it throws an error. I'm not sure if there is a way to bypass the error or not, but this seems to work.

To test this, you could create a textbox with a table and type until the table overflows the text box. Then hold shift and hit the back arrow to select one of the overflowing characters

var insertionPoint = app.selection[0].insertionPoints[0];

var isOverset = false;

try { insertionPoint.baseline; }

catch ( error ) { isOverset = true; }

Harbs, you make an excellent point that overwriting the contents could possibly destroy special formatting/objects if it's not plain text. So I revised my code after realizing that manipulating the contents is actually completely unnecessary in the first place. For anyone searching for help on this issue, here is my final summary of the problem and its solution:

Summary of problem:

InDesign treats a table as a single special character, so it does not accurately report the "overflows" property of a text frame containing a table which spills beyond its margins. A text frame will show as not overflowing (i.e. myTextFrame.overflows will return false) if its final table simply begins within its margins--even if most of the table spills well beyond the text frame. So a ten-page table that starts on page one will only considered by InDesign scripting as being one character long (and therefore shown as fitting completely in first frame even when it doesn't). The solution for this, as discovered by Dirk, is to test whether the final cell of the table overflows.

The solution:

If the final cell of the table is overset (outside the margins of its containing text frame) it will be reported as overflowing (i.e. myFinalCell.overflows will return true). So we just access this cell, and check whether it overflows. However, there's a caveat: the final cell will also show as overflowing when the individual cell's contents overflow its own cell boundaries, as of course it should! So if you just test for overflow, you might end up getting a false positive. So we have to find a way to discriminate between the cases.

To do so, we take advantage of another quirk of the way InDesign reports cell contents: if a cell is outside its containing text frame, its contents are considered empty! So all we have to do is test for both conditions, because a cell which is merely overflowing its own boundaries cannot possibly be empty.

So the test to run is this:

var finalCell = myTextFrame.parentStory.tables.lastItem().cells.lastItem();
if(finalCell.overflows && finalCell.contents=='') {  ...your code here...  }

Of course you'll replace myTextFrame with the one you're dealing with in your own script.

Example usage:

This is how I implemented this in my own script. I have an array of text frames which I pass to this function, and by the time I call the function this array contains only one element, just the first large text frame (with my long table already placed inside it). It also relies on a helper function drawTableFrame which is simple and I'll leave out; it just adds a text frame to the new page and sizes it. And of course myDocument I've long ago set to be the document I'm working in.

// Takes array of text frames, checks for overflow, and adds pages as needed
function addOverflowPages(whichFrameArray) {
    var i = 0;
    var finalCell = whichFrameArray[0].parentStory.tables.lastItem().cells.lastItem();
    while (finalCell.overflows && finalCell.contents=='') {
        i++;
        var newpage = myDocument.pages.add(); // add new page
        whichFrameArray.push(drawTableFrame(newpage)); // draw new frame
        whichFrameArray.previousTextFrame = whichFrameArray[i-1]; // link new frame to previous one
        }
    }

I hope that helps someone! Thanks to everyone for pointing me in the right direction.

1. You are going about basic checking for overset text all wrong. Your

method will return that text is overset if you have a story with two

text frames. You should use the TextFrame.overflows property to check

if it overflows.

2. You have found one of the few holes in InDesign's DOM. There is no

simple way to know if a table (or footnote) overflows. You can check

the parentTextFrames length of the insertionPoints in the cells of the

table, but that's not totally reliable because it will return 0 if the

cell is overset, but also if the text in the cell cannot fit within

the cell.

Harbs

Message was edited by: Harbs. for typos