/*

 * Copyright (c) 1998, 2015, 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.lang.ref.SoftReference;

import java.security.AccessController;

import java.security.PrivilegedAction;

import javax.swing.event.*;

import static javax.swing.text.PlainView.isFPMethodOverriden;

/**

 * View of plain text (text with only one font and color)

 * that does line-wrapping.  This view expects that its

 * associated element has child elements that represent

 * the lines it should be wrapping.  It is implemented

 * as a vertical box that contains logical line views.

 * The logical line views are nested classes that render

 * the logical line as multiple physical line if the logical

 * line is too wide to fit within the allocation.  The

 * line views draw upon the outer class for its state

 * to reduce their memory requirements.

 * <p>

 * The line views do all of their rendering through the

 * <code>drawLine</code> method which in turn does all of

 * its rendering through the <code>drawSelectedText</code>

 * and <code>drawUnselectedText</code> methods.  This

 * enables subclasses to easily specialize the rendering

 * without concern for the layout aspects.

 *

 * @author  Timothy Prinzing

 * @see     View

 */

public class WrappedPlainView extends BoxView implements TabExpander {

    /**

     * Creates a new WrappedPlainView.  Lines will be wrapped

     * on character boundaries.

     *

     * @param elem the element underlying the view

     */

    public WrappedPlainView(Element elem) {

        this(elem, false);

    }

    /**

     * Creates a new WrappedPlainView.  Lines can be wrapped on

     * either character or word boundaries depending upon the

     * setting of the wordWrap parameter.

     *

     * @param elem the element underlying the view

     * @param wordWrap should lines be wrapped on word boundaries?

     */

    public WrappedPlainView(Element elem, boolean wordWrap) {

        super(elem, Y_AXIS);

        this.wordWrap = wordWrap;

    }

    /**

     * 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 p0 the starting document location to use >= 0

     * @param p1 the ending document location to use >= p1

     * @param g the graphics 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, int, Graphics2D, float, float)}

     */

    @Deprecated(since = "9")

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

        drawLineImpl(p0, p1, g, x, y, false);

    }

    private void drawLineImpl(int p0, int p1, Graphics g, float x, float y,

                              boolean useFPAPI) {

        Element lineMap = getElement();

        Element line = lineMap.getElement(lineMap.getElementIndex(p0));

        Element elem;

        try {

            if (line.isLeaf()) {

                 drawText(line, p0, p1, g, x, y);

            } else {

                // this line contains the composed text.

                int idx = line.getElementIndex(p0);

                int lastIdx = line.getElementIndex(p1);

                for(; idx <= lastIdx; idx++) {

                    elem = line.getElement(idx);

                    int start = Math.max(elem.getStartOffset(), p0);

                    int end = Math.min(elem.getEndOffset(), p1);

                    x = drawText(elem, start, end, g, x, y);

                }

            }

        } catch (BadLocationException e) {

            throw new StateInvariantError("Can't render: " + p0 + "," + p1);

        }

    }

    /**

     * 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 p0 the starting document location to use >= 0

     * @param p1 the ending document location to use >= p1

     * @param g the graphics context

     * @param x the starting X position >= 0

     * @param y the starting Y position >= 0

     * @see #drawUnselectedText

     * @see #drawSelectedText

     *

     * @since 9

     */

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

        drawLineImpl(p0, p1, g, x, y, true);

    }

    private float drawText(Element elem, int p0, int p1, Graphics g,

                           float x, float y)

            throws BadLocationException

    {

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

        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.

     *

     * @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 >= p0

     * @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 segment = SegmentCache.getSharedSegment();

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

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

                                             null, useFPAPI);

        SegmentCache.releaseSharedSegment(segment);

        return ret;

    }

    /**

     * Renders the given range in the model as normal unselected

     * 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 >= p0

     * @return the X location of the end of the range >= 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 >= p0

     * @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);

    }

    private 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 segment = SegmentCache.getSharedSegment();

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

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

                                             null, useFPAPI);

        SegmentCache.releaseSharedSegment(segment);

        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 >= 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 >= p0

     * @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;

    }

    /**

     * This is called by the nested wrapped line

     * views to determine the break location.  This can

     * be reimplemented to alter the breaking behavior.

     * It will either break at word or character boundaries

     * depending upon the break argument given at

     * construction.

     * @param p0 the starting document location

     * @param p1 the ending document location to use

     * @return the break position

     */

    @SuppressWarnings("deprecation")

    protected int calculateBreakPosition(int p0, int p1) {

        int p;

        Segment segment = SegmentCache.getSharedSegment();

        loadText(segment, p0, p1);

        int currentWidth = getWidth();

        if (wordWrap) {

            p = p0 + Utilities.getBreakLocation(segment, metrics,

                                                tabBase, tabBase + currentWidth,

                                                this, p0);

        } else {

            p = p0 + Utilities.getTabbedTextOffset(segment, metrics,

                                                   tabBase, tabBase + currentWidth,

                                                   this, p0, false);

        }

        SegmentCache.releaseSharedSegment(segment);

        return p;

    }

    /**

     * Loads all of the children to initialize the view.

     * This is called by the <code>setParent</code> method.

     * Subclasses can reimplement this to initialize their

     * child views in a different manner.  The default

     * implementation creates a child view for each

     * child element.

     *

     * @param f the view factory

     */

    protected void loadChildren(ViewFactory f) {

        Element e = getElement();

        int n = e.getElementCount();

        if (n > 0) {

            View[] added = new View[n];

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

                added[i] = new WrappedLine(e.getElement(i));

            }

            replace(0, 0, added);

        }

    }

    /**

     * Update the child views in response to a

     * document event.

     */

    void updateChildren(DocumentEvent e, Shape a) {

        Element elem = getElement();

        DocumentEvent.ElementChange ec = e.getChange(elem);

        if (ec != null) {

            // the structure of this element changed.

            Element[] removedElems = ec.getChildrenRemoved();

            Element[] addedElems = ec.getChildrenAdded();

            View[] added = new View[addedElems.length];

            for (int i = 0; i < addedElems.length; i++) {

                added[i] = new WrappedLine(addedElems[i]);

            }

            replace(ec.getIndex(), removedElems.length, added);

            // should damge a little more intelligently.

            if (a != null) {

                preferenceChanged(null, true, true);

                getContainer().repaint();

            }

        }

        // update font metrics which may be used by the child views

        updateMetrics();

    }

    /**

     * Load the text buffer with the given range

     * of text.  This is used by the fragments

     * broken off of this view as well as this

     * view itself.

     */

    final void loadText(Segment segment, int p0, int p1) {

        try {

            Document doc = getDocument();

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

        } catch (BadLocationException bl) {

            throw new StateInvariantError("Can't get line text");

        }

    }

    final void updateMetrics() {

        Component host = getContainer();

        Font f = host.getFont();

        metrics = host.getFontMetrics(f);

        if (useFloatingPointAPI) {

            FontRenderContext frc = metrics.getFontRenderContext();

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

            tabSize = getTabSize() * tabWidth;

        } else {

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

        }

    }

    // --- TabExpander methods ------------------------------------------

    /**

     * Returns the next tab stop position after a given reference position.

     * This implementation does not support things like centering so it

     * ignores the tabOffset argument.

     *

     * @param x the current position >= 0

     * @param tabOffset the position within the text stream

     *   that the tab occurred at >= 0.

     * @return the tab stop, measured in points >= 0

     */

    public float nextTabStop(float x, int tabOffset) {

        if (tabSize == 0)

            return x;

        float ntabs = (x - tabBase) / tabSize;

        return tabBase + ((ntabs + 1) * tabSize);

    }

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

    /**

     * Renders using the given rendering surface and area

     * on that surface.  This is implemented to stash the

     * selection positions, selection colors, and font

     * metrics for the nested lines to use.

     *

     * @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) {

        Rectangle alloc = (Rectangle) a;

        tabBase = alloc.x;

        JTextComponent host = (JTextComponent) getContainer();

        sel0 = host.getSelectionStart();

        sel1 = host.getSelectionEnd();

        unselected = (host.isEnabled()) ?

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

        Caret c = host.getCaret();

        selected = c.isSelectionVisible() && host.getHighlighter() != null ?

                        host.getSelectedTextColor() : unselected;

        g.setFont(host.getFont());

        // superclass paints the children

        super.paint(g, a);

    }

    /**

     * Sets the size of the view.  This should cause

     * layout of the view along the given axis, if it

     * has any layout duties.

     *

     * @param width the width >= 0

     * @param height the height >= 0

     */

    public void setSize(float width, float height) {