/*

 * Copyright (c) 1997, 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.util.Vector;

import java.util.Properties;

import java.awt.*;

import javax.swing.event.*;

/**

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

    }

    /**

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

     *

     * @implSpec This implementation calls {@link #getTabSize() getTabSize()}.

     *

     * @return the tab size

     */

    protected float getFractionalTabSize() {

        return getTabSize();

    }

    /**

     * 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

     */

    protected void drawLine(int lineIndex, Graphics g, int x, int 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.

     *

     * @implSpec This implementation calls

     * {@link #drawLine(int, Graphics, int, int)

     * drawLine(lineIndex, (Graphics)g, (int) x, (int) y)}.

     *

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

     */

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

        drawLine(lineIndex, (Graphics)g, (int) x, (int) y);

    }

    private int drawElement(int lineIndex, Element elem, Graphics g, int x, int 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 = drawUnselectedText(g, x, y, p0, p1);

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

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

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

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

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

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

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

                } else {

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

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

                }

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

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

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

            } else {

                x = drawUnselectedText(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

     */

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

                                     int p0, int p1) throws BadLocationException {

        g.setColor(unselected);

        Document doc = getDocument();

        Segment s = SegmentCache.getSharedSegment();

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

        int ret = Utilities.drawTabbedText(this, s, x, y, g, this, p0);

        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.

     *

     * @implSpec This implementation calls

     * {@link #drawUnselectedText(Graphics, int, int, int, int)

     * drawUnselectedText((Graphics)g, (int) x, (int) y, p0, p1)}.

     *

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

     */

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

                                       int p0, int p1) throws BadLocationException {

        return drawUnselectedText((Graphics)g, (int) x, (int) y, p0, p1);

    }

    /**

     * 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

     */

    protected int drawSelectedText(Graphics g, int x,

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

        g.setColor(selected);

        Document doc = getDocument();

        Segment s = SegmentCache.getSharedSegment();

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

        int ret = Utilities.drawTabbedText(this, s, x, y, g, this, p0);

        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.

     *

     * @implSpec This implementation calls

     * {@link #drawSelectedText(Graphics, int, int, int, int)

     * drawSelectedText((Graphics)g, (int) x, (int) y, p0, p1)}.

     *

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

     */

    protected float drawSelectedText(Graphics2D g, float x,

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

        return drawSelectedText((Graphics)g, (int) x, (int) y, p0, p1);

    }

    /**

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

            // The font changed, we need to recalculate the

            // longest line.

            calculateLongestLine();

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

                }

            }

            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

     */

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

        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.

     *

     * @param fx the X coordinate >= 0

     * @param fy the Y coordinate >= 0

     * @param a the allocated region to render into

     * @return the location within the model that best represents the

     *  given point in the view >= 0

     * @see View#viewToModel

     */

    public int viewToModel(float fx, float fy, Shape a, Position.Bias[] bias) {

        // PENDING(prinz) properly calculate bias

        bias[0] = Position.Bias.Forward;

        Rectangle alloc = a.getBounds();

        Document doc = getDocument();

        int x = (int) fx;

        int y = (int) fy;

        if (y < alloc.y) {

            // above the area covered by this icon, so the position

            // is assumed to be the start of the coverage for this view.

            return getStartOffset();

        } else if (y > alloc.y + alloc.height) {

            // below the area covered by this icon, so the position

            // is assumed to be the end of the coverage for this view.

            return getEndOffset() - 1;

        } else {

            // positioned within the coverage of this view vertically,

            // so we figure out which line the point corresponds to.

            // if the line is greater than the number of lines contained, then

            // simply use the last line as it represents the last possible place

            // we can position to.

            Element map = doc.getDefaultRootElement();

            int fontHeight = metrics.getHeight();

            int lineIndex = (fontHeight > 0 ?

                                Math.abs((y - alloc.y) / fontHeight) :

                                map.getElementCount() - 1);

            if (lineIndex >= map.getElementCount()) {

                return getEndOffset() - 1;

            }

            Element line = map.getElement(lineIndex);

            int dx = 0;

            if (lineIndex == 0) {

                alloc.x += firstLineOffset;

                alloc.width -= firstLineOffset;

            }

            if (x < alloc.x) {

                // point is to the left of the line

                return line.getStartOffset();

            } else if (x > alloc.x + alloc.width) {

                // point is to the right of the line

                return line.getEndOffset() - 1;

            } else {

                // Determine the offset into the text

                try {

                    int p0 = line.getStartOffset();

                    int p1 = line.getEndOffset() - 1;

                    Segment s = SegmentCache.getSharedSegment();

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

                    tabBase = alloc.x;

                    int offs = p0 + Utilities.getTabbedTextOffset(s, metrics,

                                                                  tabBase, x, this, p0);

                    SegmentCache.releaseSharedSegment(s);

                    return offs;

                } catch (BadLocationException e) {

                    // should not happen

                    return -1;

                }

            }

        }

    }