Resolve anchored object position with ExtendScript

Hi Andrii,

That's indeed a bug, which probably comes from CS6's changes in coordinate management, or maybe CS5. (Things work fine in CS4.)

It is well-known that an anchored object (AO) belongs to a Story, which is not a geometric object. When an AO is visible (that is, when the associated anchor character is not in an overset region), its natural parent is the particular TextFrame that owns the anchor character. But this is not the actual parent of the AO in terms of coordinate spaces.

Unlike nested objects ('pasted into') which have a true parent space, AOs need a kind of bridge to fit into the hierarchy of coordinate spaces. Unfortunately, this 'patch' fails to connect AOs to regular Spread coordinate spaces in InDesign CS6 and later. The code

myAO.resolve( AnchorPoint.BOTTOM_LEFT_ANCHOR, CoordinateSpaces.SPREAD_COORDINATES )[0]

typically returns [0,0] whatever the location of the AO in the layout. So it seems that a fake coordinate space is created, based on the bottom-left corner of the AO's bounding box. [That's just my interpretation of what we can see, not a documented assertion.]

Of course you still have the option to use myAO.geometricBounds and make cautious calculations from those data, noting that resolve(...) is powerful enough to interpret ruler coordinates.

[EDIT: 20-July-2019]

The following lines are only of historical interest. A much better solution is to be proposed next.

I would suggest a different workaround. It is based on a strange but promising discovery. Apparently, AOs are associated to a more reliable structure at the PARENT_COORDINATES level. Here again, I don't think that's a true coordinate space, but since its origin coincides with the TOP-LEFT corner of the TextFrame container (for whatever reason!) we should be able to work from there.

Note. — Contrary to what one might think, the so-called 'parent space' of the AO is not the canonical inner space of the TextFrame. There are two noticeable hints about regular TextFrame spaces:

• Unlike usual PageItem spaces, their origin is *initialized* at the center location of the bounding box: myTextFrame.resolve(AnchorPoint.CENTER_ANCHOR, CoordinateSpaces.INNER_COORDINATES)[0] returns [0,0] as long as the geometry of the frame is not altered.
• Also, the space origin "follows the movement" of the text frame, that is, its coordinates relative to the pasteboard evolves in a way that preserves the inner coordinates of anchor points.

Anyway, the query

myAO.resolve( anyAnchorPoint, CoordinateSpaces.PARENT_COORDINATES )[0]

reveals the [x,y] coordinates of anyAnchorPoint in a coordinate system whose origin is the top-left corner of the TextFrame (not its center point). This coordinate system also seems to match the transform state of the TextFrame. Thus, what is left to us is to recover the TextFrame object from the AO and take advantage of transformation matrices to draw a 'coordinate path' up to the Spread origin.

Schematically, we have the following information:

1. [x,y] in the 'fake space',
2. The origin of the fake space (i.e top-left anchor) in the TextFrame space,
3. The matrix that maps the TextFrame space to the Spread space.

From this we derive the coordinates of anyAnchorPoint relative to the Spread coordinate space.

Note that (3) is not necessarily a simple TRANSLATION, the parent text frame may undergo complex transformations relative to the spread.

Suggested code:

function inSpreadCoords(/*AnchoredObj*/obj,  txf,xy,t,mx)
//----------------------------------
// Given an anchored object `obj`, return the [x,y] coords of its
// center point in spread coordinate space. This function corrects
// the malfunction of `obj.resolve(<anchor>,<spreadCS>)` in CS6/CC.
{
    const CS=CoordinateSpaces, AP=AnchorPoint;
    // Get the parent TextFrame of obj.
    // ---
    txf = obj.parent.parentTextFrames[0];
    
    // Coords of the center anchor in txf's 'TopLeftCorner' system (TLC)
    // (You can specify another ANCHOR if needed ;-)
    // ---
    xy = obj.resolve( AP.CENTER_ANCHOR, CS.PARENT_COORDINATES )[0];
    // Coords of TLC's origin in the actual TextFrame space (TXF)
    // --> `t` reflects the translation TLC->TXF.
    // ---
    t = txf.resolve( AP.TOP_LEFT_ANCHOR, CS.INNER_COORDINATES )[0];
    // TLC->SPD  :=  TLC->TXF × TXF->SPD
    // ---
    mx = app.transformationMatrices.add(1,1,0,0,t[0],t[1]).               //   TLC->TXF
         catenateMatrix(txf.transformValuesOf(CS.SPREAD_COORDINATES)[0]); // × TXF->SPD
    // Apply mx to xy.
    // ---
    return mx.changeCoordinates(xy);
}
// Test.
// ---
alert( inSpreadCoords(app.selection[0]) );

HTH,

Marc