/*

 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package javax.swing.text;

import java.awt.*;

import java.awt.font.FontRenderContext;

import java.awt.geom.Rectangle2D;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.Objects;

import javax.swing.event.*;

import java.lang.ref.SoftReference;

import java.util.HashMap;

/**

 * Implements View interface for a simple multi-line text view

 * that has text in one font and color.  The view represents each

 * child element as a line of text.

 *

 * @author  Timothy Prinzing

 * @see     View

 */

public class PlainView extends View implements TabExpander {

    /**

     * Constructs a new PlainView wrapped on an element.

     *

     * @param elem the element

     */

    public PlainView(Element elem) {

        super(elem);

    }

    /**

     * Returns the tab size set for the document, defaulting to 8.

     *

     * @return the tab size

     */

    protected int getTabSize() {

        Integer i = (Integer) getDocument().getProperty(PlainDocument.tabSizeAttribute);

        int size = (i != null) ? i.intValue() : 8;

        return size;

    }

    /**

     * Renders a line of text, suppressing whitespace at the end

     * and expanding any tabs.  This is implemented to make calls

     * to the methods <code>drawUnselectedText</code> and

     * <code>drawSelectedText</code> so that the way selected and

     * unselected text are rendered can be customized.

     *

     * @param lineIndex the line to draw >= 0

     * @param g the <code>Graphics</code> context

     * @param x the starting X position >= 0

     * @param y the starting Y position >= 0

     * @see #drawUnselectedText

     * @see #drawSelectedText

     *

     * @deprecated replaced by

     *     {@link #drawLine(int, Graphics2D, float, float)}

     */

    @Deprecated(since = "9")

    protected void drawLine(int lineIndex, Graphics g, int x, int y) {

        drawLineImpl(lineIndex, g, x, y);

    }

    private void drawLineImpl(int lineIndex, Graphics g, float x, float y) {

        Element line = getElement().getElement(lineIndex);

        Element elem;

        try {

            if (line.isLeaf()) {

                drawElement(lineIndex, line, g, x, y);

            } else {

                // this line contains the composed text.

                int count = line.getElementCount();

                for(int i = 0; i < count; i++) {

                    elem = line.getElement(i);

                    x = drawElement(lineIndex, elem, g, x, y);

                }

            }

        } catch (BadLocationException e) {

            throw new StateInvariantError("Can't render line: " + lineIndex);

        }

    }

    /**

     * Renders a line of text, suppressing whitespace at the end

     * and expanding any tabs.  This is implemented to make calls

     * to the methods {@code drawUnselectedText} and

     * {@code drawSelectedText} so that the way selected and

     * unselected text are rendered can be customized.

     *

     * @param lineIndex the line to draw {@code >= 0}

     * @param g the {@code Graphics} context

     * @param x the starting X position {@code >= 0}

     * @param y the starting Y position {@code >= 0}

     * @see #drawUnselectedText

     * @see #drawSelectedText

     *

     * @since 9

     */

    protected void drawLine(int lineIndex, Graphics2D g, float x, float y) {

        drawLineImpl(lineIndex, g, x, y);

    }

    private float drawElement(int lineIndex, Element elem, Graphics g,

                              float x, float y)

                              throws BadLocationException

    {

        int p0 = elem.getStartOffset();

        int p1 = elem.getEndOffset();

        p1 = Math.min(getDocument().getLength(), p1);

        if (lineIndex == 0) {

            x += firstLineOffset;

        }

        AttributeSet attr = elem.getAttributes();

        if (Utilities.isComposedTextAttributeDefined(attr)) {

            g.setColor(unselected);

            x = Utilities.drawComposedText(this, attr, g, x, y,

                                        p0-elem.getStartOffset(),

                                        p1-elem.getStartOffset());

        } else {

            if (sel0 == sel1 || selected == unselected) {

                // no selection, or it is invisible

                x = callDrawUnselectedText(g, x, y, p0, p1);

            } else if ((p0 >= sel0 && p0 <= sel1) && (p1 >= sel0 && p1 <= sel1)) {

                x = callDrawSelectedText(g, x, y, p0, p1);

            } else if (sel0 >= p0 && sel0 <= p1) {

                if (sel1 >= p0 && sel1 <= p1) {

                    x = callDrawUnselectedText(g, x, y, p0, sel0);

                    x = callDrawSelectedText(g, x, y, sel0, sel1);

                    x = callDrawUnselectedText(g, x, y, sel1, p1);

                } else {

                    x = callDrawUnselectedText(g, x, y, p0, sel0);

                    x = callDrawSelectedText(g, x, y, sel0, p1);

                }

            } else if (sel1 >= p0 && sel1 <= p1) {

                x = callDrawSelectedText(g, x, y, p0, sel1);

                x = callDrawUnselectedText(g, x, y, sel1, p1);

            } else {

                x = callDrawUnselectedText(g, x, y, p0, p1);

            }

        }

        return x;

    }

    /**

     * Renders the given range in the model as normal unselected

     * text.  Uses the foreground or disabled color to render the text.

     *

     * @param g the graphics context

     * @param x the starting X coordinate >= 0

     * @param y the starting Y coordinate >= 0

     * @param p0 the beginning position in the model >= 0

     * @param p1 the ending position in the model >= 0

     * @return the X location of the end of the range >= 0

     * @exception BadLocationException if the range is invalid

     *

     * @deprecated replaced by

     *     {@link #drawUnselectedText(Graphics2D, float, float, int, int)}

     */

    @Deprecated(since = "9")

    protected int drawUnselectedText(Graphics g, int x, int y,

                                     int p0, int p1) throws BadLocationException {

        return (int) drawUnselectedTextImpl(g, x, y, p0, p1, false);

    }

    private float callDrawUnselectedText(Graphics g, float x, float y,

                                         int p0, int p1)

                                         throws BadLocationException

    {

        return drawUnselectedTextOverridden && (g instanceof Graphics2D)

                ? drawUnselectedText((Graphics2D) g, x, y, p0, p1)

                : drawUnselectedText(g, (int) x, (int) y, p0, p1);

    }

    private float drawUnselectedTextImpl(Graphics g, float x, float y,

                                         int p0, int p1,

                                         boolean useFPAPI)

            throws BadLocationException

    {

        g.setColor(unselected);

        Document doc = getDocument();

        Segment s = SegmentCache.getSharedSegment();

        doc.getText(p0, p1 - p0, s);

        float ret = Utilities.drawTabbedText(this, s, x, y, g, this, p0, null,

                                             useFPAPI);

        SegmentCache.releaseSharedSegment(s);

        return ret;

    }

    /**

     * Renders the given range in the model as normal unselected

     * text.  Uses the foreground or disabled color to render the text.

     *

     * @param g the graphics context

     * @param x the starting X coordinate {@code >= 0}

     * @param y the starting Y coordinate {@code >= 0}

     * @param p0 the beginning position in the model {@code >= 0}

     * @param p1 the ending position in the model {@code >= 0}

     * @return the X location of the end of the range {@code >= 0}

     * @exception BadLocationException if the range is invalid

     *

     * @since 9

     */

    protected float drawUnselectedText(Graphics2D g, float x, float y,

                                       int p0, int p1) throws BadLocationException {

        return drawUnselectedTextImpl(g, x, y, p0, p1, true);

    }

    /**

     * Renders the given range in the model as selected text.  This

     * is implemented to render the text in the color specified in

     * the hosting component.  It assumes the highlighter will render

     * the selected background.

     *

     * @param g the graphics context

     * @param x the starting X coordinate >= 0

     * @param y the starting Y coordinate >= 0

     * @param p0 the beginning position in the model >= 0

     * @param p1 the ending position in the model >= 0

     * @return the location of the end of the range

     * @exception BadLocationException if the range is invalid

     *

     * @deprecated replaced by

     *     {@link #drawSelectedText(Graphics2D, float, float, int, int)}

     */

    @Deprecated(since = "9")

    protected int drawSelectedText(Graphics g, int x,

                                   int y, int p0, int p1)

                                   throws BadLocationException

    {

        return (int) drawSelectedTextImpl(g, x, y, p0, p1, false);

    }

    float callDrawSelectedText(Graphics g, float x, float y,

                               int p0, int p1)

                               throws BadLocationException

    {

        return drawSelectedTextOverridden && g instanceof Graphics2D

                ? drawSelectedText((Graphics2D) g, x, y, p0, p1)

                : drawSelectedText(g, (int) x, (int) y, p0, p1);

    }

    private float drawSelectedTextImpl(Graphics g, float x, float y,

                                       int p0, int p1,

                                       boolean useFPAPI)

            throws BadLocationException

    {

        g.setColor(selected);

        Document doc = getDocument();

        Segment s = SegmentCache.getSharedSegment();

        doc.getText(p0, p1 - p0, s);

        float ret = Utilities.drawTabbedText(this, s, x, y, g, this, p0, null,

                                             useFPAPI);

        SegmentCache.releaseSharedSegment(s);

        return ret;

    }

    /**

     * Renders the given range in the model as selected text.  This

     * is implemented to render the text in the color specified in

     * the hosting component.  It assumes the highlighter will render

     * the selected background.

     *

     * @param g the graphics context

     * @param x the starting X coordinate {@code >= 0}

     * @param y the starting Y coordinate {@code >= 0}

     * @param p0 the beginning position in the model {@code >= 0}

     * @param p1 the ending position in the model {@code >= 0}

     * @return the location of the end of the range

     * @exception BadLocationException if the range is invalid

     *

     * @since 9

     */

    protected float drawSelectedText(Graphics2D g, float x,

                                     float y, int p0, int p1) throws BadLocationException {

        return drawSelectedTextImpl(g, x, y, p0, p1, true);

    }

    /**

     * Gives access to a buffer that can be used to fetch

     * text from the associated document.

     *

     * @return the buffer

     */

    protected final Segment getLineBuffer() {

        if (lineBuffer == null) {

            lineBuffer = new Segment();

        }

        return lineBuffer;

    }

    /**

     * Checks to see if the font metrics and longest line

     * are up-to-date.

     *

     * @since 1.4

     */

    protected void updateMetrics() {

        Component host = getContainer();

        Font f = host.getFont();

        FontMetrics fm = (font == null) ? null : host.getFontMetrics(font);

        if (font != f || !Objects.equals(metrics, fm)) {

            // The font changed, we need to recalculate the

            // longest line.

            calculateLongestLine();

            if (useFloatingPointAPI) {

                FontRenderContext frc = metrics.getFontRenderContext();

                float tabWidth = (float) font.getStringBounds("m", frc).getWidth();

                tabSize = getTabSize() * tabWidth;

            } else {

                tabSize = getTabSize() * metrics.charWidth('m');

            }

        }

    }

    // ---- View methods ----------------------------------------------------

    /**

     * Determines the preferred span for this view along an

     * axis.

     *

     * @param axis may be either View.X_AXIS or View.Y_AXIS

     * @return   the span the view would like to be rendered into >= 0.

     *           Typically the view is told to render into the span

     *           that is returned, although there is no guarantee.

     *           The parent may choose to resize or break the view.

     * @exception IllegalArgumentException for an invalid axis

     */

    public float getPreferredSpan(int axis) {

        updateMetrics();

        switch (axis) {

        case View.X_AXIS:

            return getLineWidth(longLine);

        case View.Y_AXIS:

            return getElement().getElementCount() * metrics.getHeight();

        default:

            throw new IllegalArgumentException("Invalid axis: " + axis);

        }

    }

    /**

     * Renders using the given rendering surface and area on that surface.

     * The view may need to do layout and create child views to enable

     * itself to render into the given allocation.

     *

     * @param g the rendering surface to use

     * @param a the allocated region to render into

     *

     * @see View#paint

     */

    public void paint(Graphics g, Shape a) {

        Shape originalA = a;

        a = adjustPaintRegion(a);

        Rectangle alloc = (Rectangle) a;

        tabBase = alloc.x;

        JTextComponent host = (JTextComponent) getContainer();

        Highlighter h = host.getHighlighter();

        g.setFont(host.getFont());

        sel0 = host.getSelectionStart();

        sel1 = host.getSelectionEnd();

        unselected = (host.isEnabled()) ?

            host.getForeground() : host.getDisabledTextColor();

        Caret c = host.getCaret();

        selected = c.isSelectionVisible() && h != null ?

                       host.getSelectedTextColor() : unselected;

        updateMetrics();

        // If the lines are clipped then we don't expend the effort to

        // try and paint them.  Since all of the lines are the same height

        // with this object, determination of what lines need to be repainted

        // is quick.

        Rectangle clip = g.getClipBounds();

        int fontHeight = metrics.getHeight();

        int heightBelow = (alloc.y + alloc.height) - (clip.y + clip.height);

        int heightAbove = clip.y - alloc.y;

        int linesBelow, linesAbove, linesTotal;

        if (fontHeight > 0) {

            linesBelow = Math.max(0, heightBelow / fontHeight);

            linesAbove = Math.max(0, heightAbove / fontHeight);

            linesTotal = alloc.height / fontHeight;

            if (alloc.height % fontHeight != 0) {

                linesTotal++;

            }

        } else {

            linesBelow = linesAbove = linesTotal = 0;

        }

        // update the visible lines

        Rectangle lineArea = lineToRect(a, linesAbove);

        int y = lineArea.y + metrics.getAscent();

        int x = lineArea.x;

        Element map = getElement();

        int lineCount = map.getElementCount();

        int endLine = Math.min(lineCount, linesTotal - linesBelow);

        lineCount--;

        LayeredHighlighter dh = (h instanceof LayeredHighlighter) ?

                           (LayeredHighlighter)h : null;

        for (int line = linesAbove; line < endLine; line++) {

            if (dh != null) {

                Element lineElement = map.getElement(line);

                if (line == lineCount) {

                    dh.paintLayeredHighlights(g, lineElement.getStartOffset(),

                                              lineElement.getEndOffset(),

                                              originalA, host, this);

                }

                else {

                    dh.paintLayeredHighlights(g, lineElement.getStartOffset(),

                                              lineElement.getEndOffset() - 1,

                                              originalA, host, this);

                }

            }

            if (drawLineOverridden && (g instanceof Graphics2D)) {

                drawLine(line, (Graphics2D) g, (float) x, (float) y);

            } else {

                drawLine(line, g, x, y);

            }

            y += fontHeight;

            if (line == 0) {

                // This should never really happen, in so far as if

                // firstLineOffset is non 0, there should only be one

                // line of text.

                x -= firstLineOffset;

            }

        }

    }

    /**

     * Should return a shape ideal for painting based on the passed in

     * Shape <code>a</code>. This is useful if painting in a different

     * region. The default implementation returns <code>a</code>.

     */

    Shape adjustPaintRegion(Shape a) {

        return a;

    }

    /**

     * Provides a mapping from the document model coordinate space

     * to the coordinate space of the view mapped to it.

     *

     * @param pos the position to convert >= 0

     * @param a the allocated region to render into

     * @return the bounding box of the given position

     * @exception BadLocationException  if the given position does not

     *   represent a valid location in the associated document

     * @see View#modelToView

     */

    @SuppressWarnings("deprecation")

    public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException {

        // line coordinates

        Document doc = getDocument();

        Element map = getElement();

        int lineIndex = map.getElementIndex(pos);

        if (lineIndex < 0) {

            return lineToRect(a, 0);

        }

        Rectangle lineArea = lineToRect(a, lineIndex);

        // determine span from the start of the line

        tabBase = lineArea.x;

        Element line = map.getElement(lineIndex);

        int p0 = line.getStartOffset();

        Segment s = SegmentCache.getSharedSegment();

        doc.getText(p0, pos - p0, s);

        if (useFloatingPointAPI) {

            float xOffs = Utilities.getTabbedTextWidth(s, metrics, (float) tabBase, this, p0);

            SegmentCache.releaseSharedSegment(s);

            return new Rectangle2D.Float(lineArea.x + xOffs, lineArea.y, 1, metrics.getHeight());

        }

        int xOffs = Utilities.getTabbedTextWidth(s, metrics, tabBase, this,p0);

        SegmentCache.releaseSharedSegment(s);

        // fill in the results and return

        lineArea.x += xOffs;

        lineArea.width = 1;

        lineArea.height = metrics.getHeight();

        return lineArea;

    }

    /**

     * Provides a mapping from the view coordinate space to the logical

     * coordinate space of the model.