Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 051910b9 authored by Raph Levien's avatar Raph Levien
Browse files

Clean up dirFlags / bidiFlags confusion 

The dirFlags and bidiFlags enums are distinct, and have different
meanings. The former is a determined direction for a run of text, while
the latter is a request for the bidi algorithm. They have been used
interchangeably, and this has caused some problems, notably running the
bidi algorithm needlessly when the direction for a run is already
determined.

This patch cleans up the confusion, by always naming each occurrence
explicitly "boolean isRtl" or "int bidiFlags" (the previous code often
just used "int flags", which added to the confusion), and converts
between the meanings when a function takes an isRtl argument but passes
it to another function expecting bidiFlags.

Fixes b/15089607 Clean up bidi flag mess

Change-Id: I410b6604376e853dd12c255e7f5a9d2b9a310dd9
parent 5d140e4b

core/java/android/text/GraphicsOperations.java

+3 −3
Original line number Diff line number Diff line
@@ -38,7 +38,7 @@ extends CharSequence 
     * {@hide}

     */

    void drawTextRun(Canvas c, int start, int end, int contextStart, int contextEnd,

            float x, float y, int flags, Paint p);

            float x, float y, boolean isRtl, Paint p);



   /**

     * Just like {@link Paint#measureText}.
@@ -55,12 +55,12 @@ extends CharSequence 
     * @hide

     */

    float getTextRunAdvances(int start, int end, int contextStart, int contextEnd,

            int flags, float[] advances, int advancesIndex, Paint paint);

            boolean isRtl, float[] advances, int advancesIndex, Paint paint);



    /**

     * Just like {@link Paint#getTextRunCursor}.

     * @hide

     */

    int getTextRunCursor(int contextStart, int contextEnd, int flags, int offset,

    int getTextRunCursor(int contextStart, int contextEnd, int dir, int offset,

            int cursorOpt, Paint p);

}

core/java/android/text/MeasuredText.java

+4 −5
Original line number Diff line number Diff line
@@ -159,18 +159,17 @@ class MeasuredText { 
        mPos = p + len;



        if (mEasy) {

            int flags = mDir == Layout.DIR_LEFT_TO_RIGHT

                ? Canvas.DIRECTION_LTR : Canvas.DIRECTION_RTL;

            return paint.getTextRunAdvances(mChars, p, len, p, len, flags, mWidths, p);

            boolean isRtl = mDir != Layout.DIR_LEFT_TO_RIGHT;

            return paint.getTextRunAdvances(mChars, p, len, p, len, isRtl, mWidths, p);

        }



        float totalAdvance = 0;

        int level = mLevels[p];

        for (int q = p, i = p + 1, e = p + len;; ++i) {

            if (i == e || mLevels[i] != level) {

                int flags = (level & 0x1) == 0 ? Canvas.DIRECTION_LTR : Canvas.DIRECTION_RTL;

                boolean isRtl = (level & 0x1) != 0;

                totalAdvance +=

                        paint.getTextRunAdvances(mChars, q, i - q, q, i - q, flags, mWidths, q);

                        paint.getTextRunAdvances(mChars, q, i - q, q, i - q, isRtl, mWidths, q);

                if (i == e) {

                    break;

                }

core/java/android/text/SpannableStringBuilder.java

+15 −15
Original line number Diff line number Diff line
@@ -1117,20 +1117,20 @@ public class SpannableStringBuilder implements CharSequence, GetChars, Spannable 
     * {@hide}

     */

    public void drawTextRun(Canvas c, int start, int end, int contextStart, int contextEnd,

            float x, float y, int flags, Paint p) {

            float x, float y, boolean isRtl, Paint p) {

        checkRange("drawTextRun", start, end);



        int contextLen = contextEnd - contextStart;

        int len = end - start;

        if (contextEnd <= mGapStart) {

            c.drawTextRun(mText, start, len, contextStart, contextLen, x, y, flags, p);

            c.drawTextRun(mText, start, len, contextStart, contextLen, x, y, isRtl, p);

        } else if (contextStart >= mGapStart) {

            c.drawTextRun(mText, start + mGapLength, len, contextStart + mGapLength,

                    contextLen, x, y, flags, p);

                    contextLen, x, y, isRtl, p);

        } else {

            char[] buf = TextUtils.obtain(contextLen);

            getChars(contextStart, contextEnd, buf, 0);

            c.drawTextRun(buf, start - contextStart, len, 0, contextLen, x, y, flags, p);

            c.drawTextRun(buf, start - contextStart, len, 0, contextLen, x, y, isRtl, p);

            TextUtils.recycle(buf);

        }

    }
@@ -1187,7 +1187,7 @@ public class SpannableStringBuilder implements CharSequence, GetChars, Spannable 
     * Don't call this yourself -- exists for Paint to use internally.

     * {@hide}

     */

    public float getTextRunAdvances(int start, int end, int contextStart, int contextEnd, int flags,

    public float getTextRunAdvances(int start, int end, int contextStart, int contextEnd, boolean isRtl,

            float[] advances, int advancesPos, Paint p) {



        float ret;
@@ -1197,15 +1197,15 @@ public class SpannableStringBuilder implements CharSequence, GetChars, Spannable 


        if (end <= mGapStart) {

            ret = p.getTextRunAdvances(mText, start, len, contextStart, contextLen,

                    flags, advances, advancesPos);

                    isRtl, advances, advancesPos);

        } else if (start >= mGapStart) {

            ret = p.getTextRunAdvances(mText, start + mGapLength, len,

                    contextStart + mGapLength, contextLen, flags, advances, advancesPos);

                    contextStart + mGapLength, contextLen, isRtl, advances, advancesPos);

        } else {

            char[] buf = TextUtils.obtain(contextLen);

            getChars(contextStart, contextEnd, buf, 0);

            ret = p.getTextRunAdvances(buf, start - contextStart, len,

                    0, contextLen, flags, advances, advancesPos);

                    0, contextLen, isRtl, advances, advancesPos);

            TextUtils.recycle(buf);

        }
@@ -1228,7 +1228,7 @@ public class SpannableStringBuilder implements CharSequence, GetChars, Spannable 
     *

     * @param contextStart the start index of the context

     * @param contextEnd the (non-inclusive) end index of the context

     * @param flags either DIRECTION_RTL or DIRECTION_LTR

     * @param dir either DIRECTION_RTL or DIRECTION_LTR

     * @param offset the cursor position to move from

     * @param cursorOpt how to move the cursor, one of CURSOR_AFTER,

     * CURSOR_AT_OR_AFTER, CURSOR_BEFORE,
@@ -1238,7 +1238,7 @@ public class SpannableStringBuilder implements CharSequence, GetChars, Spannable 
     * @deprecated This is an internal method, refrain from using it in your code

     */

    @Deprecated

    public int getTextRunCursor(int contextStart, int contextEnd, int flags, int offset,

    public int getTextRunCursor(int contextStart, int contextEnd, int dir, int offset,

            int cursorOpt, Paint p) {



        int ret;
@@ -1246,15 +1246,15 @@ public class SpannableStringBuilder implements CharSequence, GetChars, Spannable 
        int contextLen = contextEnd - contextStart;

        if (contextEnd <= mGapStart) {

            ret = p.getTextRunCursor(mText, contextStart, contextLen,

                    flags, offset, cursorOpt);

                    dir, offset, cursorOpt);

        } else if (contextStart >= mGapStart) {

            ret = p.getTextRunCursor(mText, contextStart + mGapLength, contextLen,

                    flags, offset + mGapLength, cursorOpt) - mGapLength;

                    dir, offset + mGapLength, cursorOpt) - mGapLength;

        } else {

            char[] buf = TextUtils.obtain(contextLen);

            getChars(contextStart, contextEnd, buf, 0);

            ret = p.getTextRunCursor(buf, 0, contextLen,

                    flags, offset - contextStart, cursorOpt) + contextStart;

                    dir, offset - contextStart, cursorOpt) + contextStart;

            TextUtils.recycle(buf);

        }

core/java/android/text/TextLine.java

+7 −9
Original line number Diff line number Diff line
@@ -664,14 +664,14 @@ class TextLine { 
            }

        }



        int flags = runIsRtl ? Paint.DIRECTION_RTL : Paint.DIRECTION_LTR;

        int dir = runIsRtl ? Paint.DIRECTION_RTL : Paint.DIRECTION_LTR;

        int cursorOpt = after ? Paint.CURSOR_AFTER : Paint.CURSOR_BEFORE;

        if (mCharsValid) {

            return wp.getTextRunCursor(mChars, spanStart, spanLimit - spanStart,

                    flags, offset, cursorOpt);

                    dir, offset, cursorOpt);

        } else {

            return wp.getTextRunCursor(mText, mStart + spanStart,

                    mStart + spanLimit, flags, mStart + offset, cursorOpt) - mStart;

                    mStart + spanLimit, dir, mStart + offset, cursorOpt) - mStart;

        }

    }
@@ -738,15 +738,14 @@ class TextLine { 


        int contextLen = contextEnd - contextStart;

        if (needWidth || (c != null && (wp.bgColor != 0 || wp.underlineColor != 0 || runIsRtl))) {

            int flags = runIsRtl ? Paint.DIRECTION_RTL : Paint.DIRECTION_LTR;

            if (mCharsValid) {

                ret = wp.getTextRunAdvances(mChars, start, runLen,

                        contextStart, contextLen, flags, null, 0);

                        contextStart, contextLen, runIsRtl, null, 0);

            } else {

                int delta = mStart;

                ret = wp.getTextRunAdvances(mText, delta + start,

                        delta + end, delta + contextStart, delta + contextEnd,

                        flags, null, 0);

                        runIsRtl, null, 0);

            }

        }
@@ -977,16 +976,15 @@ class TextLine { 
    private void drawTextRun(Canvas c, TextPaint wp, int start, int end,

            int contextStart, int contextEnd, boolean runIsRtl, float x, int y) {



        int flags = runIsRtl ? Canvas.DIRECTION_RTL : Canvas.DIRECTION_LTR;

        if (mCharsValid) {

            int count = end - start;

            int contextCount = contextEnd - contextStart;

            c.drawTextRun(mChars, start, count, contextStart, contextCount,

                    x, y, flags, wp);

                    x, y, runIsRtl, wp);

        } else {

            int delta = mStart;

            c.drawTextRun(mText, delta + start, delta + end,

                    delta + contextStart, delta + contextEnd, x, y, flags, wp);

                    delta + contextStart, delta + contextEnd, x, y, runIsRtl, wp);

        }

    }

core/java/android/view/GLES20Canvas.java

+38 −42
Original line number Diff line number Diff line
@@ -997,49 +997,45 @@ class GLES20Canvas extends HardwareCanvas { 


    @Override

    public void drawTextRun(char[] text, int index, int count, int contextIndex, int contextCount,

            float x, float y, int dir, Paint paint) {

            float x, float y, boolean isRtl, Paint paint) {

        if ((index | count | text.length - index - count) < 0) {

            throw new IndexOutOfBoundsException();

        }

        if (dir != DIRECTION_LTR && dir != DIRECTION_RTL) {

            throw new IllegalArgumentException("Unknown direction: " + dir);

        }



        nDrawTextRun(mRenderer, text, index, count, contextIndex, contextCount, x, y, dir,

        nDrawTextRun(mRenderer, text, index, count, contextIndex, contextCount, x, y, isRtl,

                paint.mNativePaint, paint.mNativeTypeface);

    }



    private static native void nDrawTextRun(long renderer, char[] text, int index, int count,

            int contextIndex, int contextCount, float x, float y, int dir, long nativePaint, long nativeTypeface);

            int contextIndex, int contextCount, float x, float y, boolean isRtl, long nativePaint, long nativeTypeface);



    @Override

    public void drawTextRun(CharSequence text, int start, int end, int contextStart, int contextEnd,

            float x, float y, int dir, Paint paint) {

            float x, float y, boolean isRtl, Paint paint) {

        if ((start | end | end - start | text.length() - end) < 0) {

            throw new IndexOutOfBoundsException();

        }



        int flags = dir == 0 ? 0 : 1;

        if (text instanceof String || text instanceof SpannedString ||

                text instanceof SpannableString) {

            nDrawTextRun(mRenderer, text.toString(), start, end, contextStart,

                    contextEnd, x, y, flags, paint.mNativePaint, paint.mNativeTypeface);

                    contextEnd, x, y, isRtl, paint.mNativePaint, paint.mNativeTypeface);

        } else if (text instanceof GraphicsOperations) {

            ((GraphicsOperations) text).drawTextRun(this, start, end,

                    contextStart, contextEnd, x, y, flags, paint);

                    contextStart, contextEnd, x, y, isRtl, paint);

        } else {

            int contextLen = contextEnd - contextStart;

            int len = end - start;

            char[] buf = TemporaryBuffer.obtain(contextLen);

            TextUtils.getChars(text, contextStart, contextEnd, buf, 0);

            nDrawTextRun(mRenderer, buf, start - contextStart, len, 0, contextLen,

                    x, y, flags, paint.mNativePaint, paint.mNativeTypeface);

                    x, y, isRtl, paint.mNativePaint, paint.mNativeTypeface);

            TemporaryBuffer.recycle(buf);

        }

    }



    private static native void nDrawTextRun(long renderer, String text, int start, int end,

            int contextStart, int contextEnd, float x, float y, int flags, long nativePaint, long nativeTypeface);

            int contextStart, int contextEnd, float x, float y, boolean isRtl, long nativePaint, long nativeTypeface);



    @Override

    public void drawVertices(VertexMode mode, int vertexCount, float[] verts, int vertOffset,