How to automatically highlight Justification Alternate words

That's bad. I mentioned earlier that it could be a bug in the composer, but since I used the same composer (even though my installed ID is the standard English one) that's not likely to be the case. It may be a bug in the ME version of InDesign. Anyway, it works for me, but not for you. I'm afraid I have no other ideas to offer.

You can submit a bug report at https://indesign.uservoice.com. Include the script, your file (as the result) and the screenshot I sent (as the expected result).

That's strange. If I take your test_jalt.indd and run the script, it highlights various words -- though not all, some because of edge cases (see below).

But that document has various overrides, in some places those overrides disable otfJustificationAlternate. When you remove those overrides you get this:

Then when I run the (updated) script I get this:

So it gets some words (the green ones), but not all (those remaining red). I've no idea why. If you flip just alt on those red words nothing happens. So although InDesign flagged them, no alternates were used for them. Maybe it's a bug, I don't know.  The world-ready composers are known to be buggy. Changing the composer to the WR paragraph composer (you use the line composer) makes no difference.

Now for the updated script. Checking just the endHorizontalOffsets of the words before and after changing just alt produces false negatives for words at the end of a line. So you have to look at the length of words, not just where they end:

myWords = app.activeDocument.stories.everyItem()
  .words.everyItem().getElements();

for (i=0;i<myWords.length;i++) {
  if (!myWords[i].otfJustificationAlternate) {
    continue;
  }
  w1 = myWords[i].endHorizontalOffset - myWords[i].horizontalOffset;
  myWords[i].otfJustificationAlternate = false;
  w2 = myWords[i].endHorizontalOffset - myWords[i].horizontalOffset;
  if (w1 != w2) {
    myWords[i].fillColor = "green";
  }
  myWords[i].otfJustificationAlternate = true;
}

You should leave the paragraph justification alone. Instead, use each word's otfJustificationAlternate property. Also, you can get the document's words in one go:

myWords = app.activeDocument.stories.everyItem()
  .words.everyItem().getElements();

for (i=0;i<myWords.length;i++) {
  if (!myWords[i].otfJustificationAlternate) {
    continue;
  }
  hfb = myWords[i].endHorizontalOffset;
  myWords[i].otfJustificationAlternate = false;
  hfa = myWords[i].endHorizontalOffset;
  if (hfb < hfa) {
    myWords[i].fillColor ="green";
  }
  myWords[i].otfJustificationAlternate = true;
}

(This one ignores footnotes and tables.)

> I tried that but it didn't work.

What did you try? There have been numerous suggestions by now. @Robert at ID-Tasker suggested someting in the first reply in this post, there were some other suggestions, and what I came up with is basically an explanation of Robert's rather compact suggestion.

It can be done with a script, though it'll be horribly slow:

Find all words that have just alt set. Then with each word:

– take its width

– disable just alt

– take the word's width again

If the two widths are the same (or differ by half a point or less to account for rounding differences and other minor inaccuracies) then the word is not an alternate.

Then re-enable just alt on the word.

The problem, of course, is that all that en-/re-enabling can cause reflow. You can't control that. The results should be compared carefully.

There are all kinds of challenges. First, in your sample text, just. alt. is applied to some words but also to phrases, parts of sentences. To see where just alt was applied, run this one-liner to set just alt in your Find/Change window (from Pickory's script):

app.findTextPreferences.otfJustificationAlternate = true;

Now search the document: each instance of just alt will be highlighted in succession. When you apply highlighting you see this:

Second, even if just. alt. was applied to a word doesn't mean that the alternates will actually be used: they may not be necessary for some words.

To see what difference the use of just alt makes, copy the frame on p. 1, move it to the left out of the way so that the duplicate sits next to the original. Then remove all just alt from the duplicated frame. Run another one-liner to prime the F/C window:

app.changeTextPreferences.otfJustificationAlternate = false;

 Select the duplicated story, then set the F/C window to search in the story only, and click Change All.

You can already see the differences. You can then move the duplicated frame back over the original and the differences become even clearer:

Hello,

Where do you set 'Justification Alternate (Naskh) '

Would you have a sample document that I could look at.

P.

Edited to say:

This looks like it is an attribute added to the text. It would be possible to detect the attribute and highlight from an PlugIn. Or, even better, if the attribute is a style override you could switch on style override highlighter.

Script could compare HorizontalOffset of the InsertionPoints before and after the substituted Character - but script would need access to the "original" text.