FULL PRODUCT VERSION :


A DESCRIPTION OF THE PROBLEM :
TextLayout.getVisibleAdvance works fine for simple cases but it breaks down when the text has trailing spaces and there is a mixture of left-to-right and right-to-left components. Specifically, when the visual order of the text line components is neither the same as the logical order nor the reverse of the logical order, getVisibleAdvance returns the wrong result.

The problem is in the TextLine class used by TextLayout. The fComponents array contains the text line's components in logical order. The fComponentVisualOrder array, if not-null, is in visual order. fComponentVisualOrder[N] is the logical index of visual component N. (Unfortunately, thoughout this class, fComponentVisualOrder[N] is assigned to a variable called vi, even though the value is a logical index, not a visual index. This confusion perhaps lead to the bug with getVisibleAdvance.)

In a few places (three, by my count), fComponentVisualOrder is misused to turn a logical index into a visual index. This only works in the simplest cases. When there are 3 or more components and the visual order is not the same as the logical order or the reverse of the logical order, the wrong component will be used. For instance, if fComponentVisualOrder is [2, 0, 1], the leftmost visual component is logical component 2. fComponentVisualOrder cannot be subscripted directly to turn logical index 2 into a visual index: fComponentVisualOrder[2] is 1, not 0.

TextLayout.getVisibleAdvance fails because of a bad logical-to-visual conversion in TextLine.fgPosAdvF.computeFunction. I think there are a couple of other bad conversions in TextLine.fgXPositionF.computeFunction and TextLine.getCharBounds. These could cause problems in other methods of TextLayout.

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
Run the attached program with JRE 1.3.x or 1.4.x.
Run it again with JRE 1.5.x or 1.6.x.
Compare the results written to System.out.

EXPECTED VERSUS ACTUAL BEHAVIOR :
EXPECTED -
TextLayout.getVisibleAdvance should return the correct value no matter how complex the text.
ACTUAL -
With Java 1.3.1 and 1.4.2, getVisibleAdvance works fine:

    java.version = 1.4.2_09
    Left-to-right (One style): Advance = 127.30078, Visible advance = 118.30078
    Right-to-left (One style): Advance = 127.30078, Visible advance = 118.30078
    Left-to-right (Multiple styles): Advance = 127.30078, Visible advance = 118.30078
    Right-to-left (Multiple styles): Advance = 127.30078, Visible advance = 118.30078

With Java 1.5.0_12 and 1.6.0, getVisibleAdvance returns a value which is much too small if the text is a mixture of left-to-right and right-to-left text and it has trailing spaces:

    java.version = 1.6.0
    Left-to-right (One style): Advance = 127.30078, Visible advance = 118.30078
    Right-to-left (One style): Advance = 127.30078, Visible advance = 118.30078
    Left-to-right (Multiple styles): Advance = 127.30078, Visible advance = 118.30078
    Right-to-left (Multiple styles): Advance = 127.30078, Visible advance = 31.31836


REPRODUCIBILITY :
This bug can be reproduced always.

---------- BEGIN SOURCE ----------
import java.awt.*;
import java.awt.font.*;
import java.awt.geom.*;
import java.text.*;

public class VisibleAdvance
{
    public static void main (String [] args)
    {
        System.out.println ("java.version = " + System.getProperty ("java.version"));
        
        showAdvance ("Left-to-right (One style): ", getString (TextAttribute.RUN_DIRECTION_LTR, false));
        showAdvance ("Right-to-left (One style): ", getString (TextAttribute.RUN_DIRECTION_RTL, false));
        
        showAdvance ("Left-to-right (Multiple styles): ", getString (TextAttribute.RUN_DIRECTION_LTR, true));
        showAdvance ("Right-to-left (Multiple styles): ", getString (TextAttribute.RUN_DIRECTION_RTL, true));
    }
    
    private static final String textA = "Text with trailing ";
    private static final String textB = "spaces";
    private static final String textC = " ";
    private static final String text = textA + textB + textC;
    
    private static final int startOfTextB = textA.length ();
    private static final int endOfTextB = startOfTextB + textB.length ();
    
    private static final Font font = new Font ("Serif", Font.PLAIN, 12);
    
    private static AttributedString getString (Boolean direction,
                                               boolean multipleStyles)
    {
        AttributedString as = new AttributedString (text);
        as.addAttribute (TextAttribute.FONT, font);
        as.addAttribute (TextAttribute.RUN_DIRECTION, direction);
        
        if (multipleStyles)
            as.addAttribute (TextAttribute.FOREGROUND, Color.RED, startOfTextB, endOfTextB);
        
        return as;
    }
    
    private static FontRenderContext fontRenderContext =
        new FontRenderContext (new AffineTransform (), true, true);
    
    private static void showAdvance (String what,
                                     AttributedString as)
    {
        TextLayout layout = new TextLayout (as.getIterator (), fontRenderContext);
        
        System.out.println (what + "Advance = " + layout.getAdvance () +
                            ", Visible advance = " + layout.getVisibleAdvance ());
    }
}

---------- END SOURCE ----------

Release Regression From : 1.4.2
The above release value was the last known release where this
bug was not reproducible. Since then there has been a regression.