android-11.0.0_r1/s

/*
 * Copyright (C) 2013 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.graphics;

import com.android.ide.common.rendering.api.LayoutLog;
import com.android.layoutlib.bridge.Bridge;

import android.annotation.NonNull;
import android.annotation.Nullable;
import android.graphics.Paint_Delegate.FontInfo;
import android.icu.lang.UScriptRun;
import android.icu.text.Bidi;
import android.icu.text.BidiRun;

import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Toolkit;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

/**
 * Render the text by breaking it into various scripts and using the right font for each script.
 * Can be used to measure the text without actually drawing it.
 */
@SuppressWarnings("deprecation")
public class BidiRenderer {
    private static final String JETBRAINS_VENDOR_ID = "JetBrains s.r.o";
    private static final String JAVA_VENDOR = System.getProperty("java.vendor");
    /** When scaleX is bigger than this, we need to apply the workaround for http://b.android.com/211659 */
    private static final double SCALEX_WORKAROUND_LIMIT = 9;

    private static class ScriptRun {
        private final int start;
        private final int limit;
        private final Font font;

        private ScriptRun(int start, int limit, @NonNull Font font) {
            this.start = start;
            this.limit = limit;
            this.font = font;
        }
    }

    private final Graphics2D mGraphics;
    private final Paint_Delegate mPaint;
    private char[] mText;
    // Bounds of the text drawn so far.
    private RectF mBounds;
    private float mBaseline;
    private final Bidi mBidi = new Bidi();


    /**
     * @param graphics May be null.
     * @param paint The Paint to use to get the fonts. Should not be null.
     * @param text Unidirectional text. Should not be null.
     */
    public BidiRenderer(Graphics2D graphics, Paint_Delegate paint, char[] text) {
        assert (paint != null);
        mGraphics = graphics;
        mPaint = paint;
        mText = text;
        mBounds = new RectF();
    }

    /**
     *
     * @param x The x-coordinate of the left edge of where the text should be drawn on the given
     *            graphics.
     * @param y The y-coordinate at which to draw the text on the given mGraphics.
     *
     */
    public BidiRenderer setRenderLocation(float x, float y) {
        mBounds.set(x, y, x, y);
        mBaseline = y;
        return this;
    }

    /**
     * Perform Bidi Analysis on the text and then render it.
     * <p/>
     * To skip the analysis and render unidirectional text, see {@link
     * #renderText(int, int, boolean, float[], int, boolean)}
     */
    public RectF renderText(int start, int limit, int bidiFlags, float[] advances,
            int advancesIndex, boolean draw) {
        mBidi.setPara(Arrays.copyOfRange(mText, start, limit), (byte)getIcuFlags(bidiFlags), null);
        mText = mBidi.getText();
        for (int i = 0; i < mBidi.countRuns(); i++) {
            BidiRun visualRun = mBidi.getVisualRun(i);
            boolean isRtl = visualRun.getDirection() == Bidi.RTL;
            renderText(visualRun.getStart(), visualRun.getLimit(), isRtl, advances,
                    advancesIndex, draw);
        }
        return mBounds;
    }

    /**
     * Render unidirectional text.
     * <p/>
     * This method can also be used to measure the width of the text without actually drawing it.
     * <p/>
     * @param start index of the first character
     * @param limit index of the first character that should not be rendered.
     * @param isRtl is the text right-to-left
     * @param advances If not null, then advances for each character to be rendered are returned
     *            here.
     * @param advancesIndex index into advances from where the advances need to be filled.
     * @param draw If true and {@code graphics} is not null, draw the rendered text on the graphics
     *            at the given co-ordinates
     * @return A rectangle specifying the bounds of the text drawn.
     */
    public RectF renderText(int start, int limit, boolean isRtl, float[] advances,
            int advancesIndex, boolean draw) {
        // We break the text into scripts and then select font based on it and then render each of
        // the script runs.
        for (ScriptRun run : getScriptRuns(mText, start, limit, mPaint.getFonts())) {
            int flag = Font.LAYOUT_NO_LIMIT_CONTEXT | Font.LAYOUT_NO_START_CONTEXT;
            flag |= isRtl ? Font.LAYOUT_RIGHT_TO_LEFT : Font.LAYOUT_LEFT_TO_RIGHT;
            renderScript(run.start, run.limit, run.font, flag, advances, advancesIndex, draw);
            advancesIndex += run.limit - run.start;
        }
        return mBounds;
    }

    /**
     * Render a script run to the right of the bounds passed. Use the preferred font to render as
     * much as possible. This also implements a fallback mechanism to render characters that cannot
     * be drawn using the preferred font.
     */
    private void renderScript(int start, int limit, Font preferredFont, int flag,
            float[] advances, int advancesIndex, boolean draw) {
        if (mPaint.getFonts().size() == 0 || preferredFont == null) {
            return;
        }

        while (start < limit) {
            int canDisplayUpTo = preferredFont.canDisplayUpTo(mText, start, limit);
            if (canDisplayUpTo == -1) {
                // We can draw all characters in the text.
                render(start, limit, preferredFont, flag, advances, advancesIndex, draw);
                return;
            }
            if (canDisplayUpTo > start) {
                // We can draw something.
                render(start, canDisplayUpTo, preferredFont, flag, advances, advancesIndex, draw);
                advancesIndex += canDisplayUpTo - start;
                start = canDisplayUpTo;
            } else {
                // We can display everything with the preferred font. Search for the font that
                // allows us to display the maximum number of chars
                List<FontInfo> fontInfos = mPaint.getFonts();
                Font bestFont = null;
                int highestUpTo = canDisplayUpTo;
                //noinspection ForLoopReplaceableByForEach
                for (int i = 0; i < fontInfos.size(); i++) {
                    Font font = fontInfos.get(i).mFont;

                    if (preferredFont == font) {
                        // We know this font won't work since we've already tested it at the
                        // beginning of the loop
                        continue;
                    }

                    if (font == null) {
                        logFontWarning();
                        continue;
                    }

                    canDisplayUpTo = font.canDisplayUpTo(mText, start, limit);
                    if (canDisplayUpTo == -1) {
                        // This font can dis
                        highestUpTo = limit;
                        bestFont = font;
                        break;
                    } else if (canDisplayUpTo > highestUpTo) {
                        highestUpTo = canDisplayUpTo;
                        bestFont = font;
                        // Keep searching in case there is a font that allows to display even
                        // more text
                    }
                }

                if (bestFont != null) {
                    render(start, highestUpTo, bestFont, flag, advances, advancesIndex, draw);
                    advancesIndex += highestUpTo - start;
                    start = highestUpTo;
                } else {
                    int charCount = Character.isHighSurrogate(mText[start]) ? 2 : 1;

                    // No font can display this char. Use the preferred font and skip this char.
                    // The char will most probably appear as a box or a blank space. We could,
                    // probably, use some heuristics and break the character into the base
                    // character and diacritics and then draw it, but it's probably not worth the
                    // effort.
                    render(start, start + charCount, preferredFont, flag, advances, advancesIndex,
                            draw);
                    start += charCount;
                    advancesIndex += charCount;
                }
            }
        }
    }

    private static void logFontWarning() {
        Bridge.getLog().fidelityWarning(LayoutLog.TAG_BROKEN,
                "Some fonts could not be loaded. The rendering may not be perfect.", null, null,
                null);
    }

    /**
     * Renders the text to the right of the bounds with the given font.
     * @param font The font to render the text with.
     */
    private void render(int start, int limit, Font font, int flag, float[] advances,
            int advancesIndex, boolean draw) {
        FontRenderContext frc = mGraphics != null ? mGraphics.getFontRenderContext() :
                    Toolkit.getDefaultToolkit().getFontMetrics(font).getFontRenderContext();

        boolean frcIsAntialiased = frc.isAntiAliased();
        boolean useAntialiasing = mPaint.isAntiAliased();

        if (frcIsAntialiased) {
            if (!useAntialiasing) {
                // The context has antialiasing enabled but the paint does not. We need to
                // disable it
                frc = new FontRenderContext(font.getTransform(), false,
                        frc.usesFractionalMetrics());
            } else {
                // In this case both the paint and the context antialising match but we need
                // to check for a bug in the JDK
                // Workaround for http://b.android.com/211659 (disable antialiasing)
                if (font.isTransformed()) {
                    AffineTransform transform = font.getTransform();
                    if (transform.getScaleX() >= SCALEX_WORKAROUND_LIMIT &&
                            JETBRAINS_VENDOR_ID.equals(JAVA_VENDOR)) {
                        frc = new FontRenderContext(transform, false, frc.usesFractionalMetrics());
                    }
                }
            }
        } else if (useAntialiasing) {
            // The context does not have antialiasing enabled but the paint does. We need to
            // enable it unless we need to avoid the JDK bug

            AffineTransform transform = font.getTransform();
            // Workaround for http://b.android.com/211659 (disable antialiasing)
            if (transform.getScaleX() < SCALEX_WORKAROUND_LIMIT ||
                    !JETBRAINS_VENDOR_ID.equals(JAVA_VENDOR)) {
                frc = new FontRenderContext(font.getTransform(), true, frc.usesFractionalMetrics());
            }
        }

        GlyphVector gv = font.layoutGlyphVector(frc, mText, start, limit, flag);
        int ng = gv.getNumGlyphs();
        int[] ci = gv.getGlyphCharIndices(0, ng, null);
        if (advances != null) {
            for (int i = 0; i < ng; i++) {
                if (mText[ci[i]] == '\uFEFF') {
                    // Workaround for bug in JetBrains JDK
                    // where the character \uFEFF is associated a glyph with non-zero width
                    continue;
                }
                int adv_idx = advancesIndex + ci[i];
                advances[adv_idx] += gv.getGlyphMetrics(i).getAdvanceX();
            }
        }
        if (draw && mGraphics != null) {
            mGraphics.drawGlyphVector(gv, mBounds.right, mBaseline);
        }

        // Update the bounds.
        Rectangle2D awtBounds = gv.getLogicalBounds();
        // If the width of the bounds is zero, no text had been drawn earlier. Hence, use the
        // coordinates from the bounds as an offset.
        if (Math.abs(mBounds.right - mBounds.left) == 0) {
            mBounds = awtRectToAndroidRect(awtBounds, mBounds.right, mBaseline, mBounds);
        } else {
            mBounds.union(awtRectToAndroidRect(awtBounds, mBounds.right, mBaseline, null));
        }
    }

    // --- Static helper methods ---

    private static RectF awtRectToAndroidRect(Rectangle2D awtRec, float offsetX, float offsetY,
            @Nullable RectF destination) {
        float left = (float) awtRec.getX();
        float top = (float) awtRec.getY();
        float right = (float) (left + awtRec.getWidth());
        float bottom = (float) (top + awtRec.getHeight());
        if (destination != null) {
            destination.set(left, top, right, bottom);
        } else {
            destination = new RectF(left, top, right, bottom);
        }
        destination.offset(offsetX, offsetY);
        return destination;
    }

    private static List<ScriptRun> getScriptRuns(char[] text, int start, int limit, List<FontInfo> fonts) {
        LinkedList<ScriptRun> scriptRuns = new LinkedList<>();

        int count = limit - start;
        UScriptRun uScriptRun = new UScriptRun(text, start, count);
        while (uScriptRun.next()) {
            int scriptStart = uScriptRun.getScriptStart();
            int scriptLimit = uScriptRun.getScriptLimit();
            ScriptRun run = new ScriptRun(
                    scriptStart, scriptLimit,
                    getScriptFont(text, scriptStart, scriptLimit, fonts));
            scriptRuns.add(run);
        }
        return scriptRuns;
    }

    // TODO: Replace this method with one which returns the font based on the scriptCode.
    @NonNull
    private static Font getScriptFont(char[] text, int start, int limit, List<FontInfo> fonts) {
        if (fonts.isEmpty()) {
            logFontWarning();
            // Fallback font in case no font can be loaded
            return Font.getFont(Font.SERIF);
        }

        // From all the fonts, select the one that can display the highest number of characters
        Font bestFont = fonts.get(0).mFont;
        int bestFontCount = 0;
        for (FontInfo fontInfo : fonts) {
            int count = fontInfo.mFont.canDisplayUpTo(text, start, limit);
            if (count == -1) {
                // This font can display everything, return this one
                return fontInfo.mFont;
            }

            if (count > bestFontCount) {
                bestFontCount = count;
                bestFont = fontInfo.mFont;
            }
        }

        return bestFont;
    }

    private static int getIcuFlags(int bidiFlag) {
        switch (bidiFlag) {
            case Paint.BIDI_LTR:
            case Paint.BIDI_FORCE_LTR:
                return Bidi.DIRECTION_LEFT_TO_RIGHT;
            case Paint.BIDI_RTL:
            case Paint.BIDI_FORCE_RTL:
                return Bidi.DIRECTION_RIGHT_TO_LEFT;
            case Paint.BIDI_DEFAULT_LTR:
                return Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT;
            case Paint.BIDI_DEFAULT_RTL:
                return Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT;
            default:
                assert false;
                return Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT;
        }
    }
}