/*

 * Copyright (c) 1998, 2014, 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.

 */

/*

 *

 * (C) Copyright IBM Corp. 1998, All Rights Reserved

 */

package sun.font;

import java.awt.BasicStroke;

import java.awt.Graphics2D;

import java.awt.Shape;

import java.awt.Stroke;

import java.awt.geom.GeneralPath;

import java.awt.geom.Line2D;

import java.awt.font.TextAttribute;

import java.util.concurrent.ConcurrentHashMap;

/**

 * This class provides drawing and bounds-measurement of

 * underlines.  Additionally, it has a factory method for

 * obtaining underlines from values of underline attributes.

 */

abstract class Underline {

    /**

     * Draws the underline into g2d.  The thickness should be obtained

     * from a LineMetrics object.  Note that some underlines ignore the

     * thickness parameter.

     * The underline is drawn from (x1, y) to (x2, y).

     */

    abstract void drawUnderline(Graphics2D g2d,

                                float thickness,

                                float x1,

                                float x2,

                                float y);

    /**

     * Returns the bottom of the bounding rectangle for this underline.

     */

    abstract float getLowerDrawLimit(float thickness);

    /**

     * Returns a Shape representing the underline.  The thickness should be obtained

     * from a LineMetrics object.  Note that some underlines ignore the

     * thickness parameter.

     */

    abstract Shape getUnderlineShape(float thickness,

                                     float x1,

                                     float x2,

                                     float y);

     // Implementation of underline for standard and Input Method underlines.

     // These classes are private.

    // IM Underlines ignore thickness param, and instead use

    // DEFAULT_THICKNESS

    private static final float DEFAULT_THICKNESS = 1.0f;

    // StandardUnderline's constructor takes a boolean param indicating

    // whether to override the default thickness.  These values clarify

    // the semantics of the parameter.

    private static final boolean USE_THICKNESS = true;

    private static final boolean IGNORE_THICKNESS = false;

    // Implementation of standard underline and all input method underlines

    // except UNDERLINE_LOW_GRAY.

    private static final class StandardUnderline extends Underline {

        // the amount by which to move the underline

        private float shift;

        // the actual line thickness is this value times

        // the requested thickness

        private float thicknessMultiplier;

        // if non-null, underline is drawn with a BasicStroke

        // with this dash pattern

        private float[] dashPattern;

        // if false, all underlines are DEFAULT_THICKNESS thick

        // if true, use thickness param

        private boolean useThickness;

        // cached BasicStroke

        private BasicStroke cachedStroke;

        StandardUnderline(float shift,

                          float thicknessMultiplier,

                          float[] dashPattern,

                          boolean useThickness) {

            this.shift = shift;

            this.thicknessMultiplier = thicknessMultiplier;

            this.dashPattern = dashPattern;

            this.useThickness = useThickness;

            this.cachedStroke = null;

        }

        private BasicStroke createStroke(float lineThickness) {

            if (dashPattern == null) {

                return new BasicStroke(lineThickness,

                                       BasicStroke.CAP_BUTT,

                                       BasicStroke.JOIN_MITER);

            }

            else {

                return new BasicStroke(lineThickness,

                                       BasicStroke.CAP_BUTT,

                                       BasicStroke.JOIN_MITER,

                                       10.0f,

                                       dashPattern,

                                       0);

            }

        }

        private float getLineThickness(float thickness) {

            if (useThickness) {

                return thickness * thicknessMultiplier;

            }

            else {

                return DEFAULT_THICKNESS * thicknessMultiplier;

            }

        }

        private Stroke getStroke(float thickness) {

            float lineThickness = getLineThickness(thickness);

            BasicStroke stroke = cachedStroke;

            if (stroke == null ||

                    stroke.getLineWidth() != lineThickness) {

                stroke = createStroke(lineThickness);

                cachedStroke = stroke;

            }

            return stroke;

        }

        void drawUnderline(Graphics2D g2d,

                           float thickness,

                           float x1,

                           float x2,

                           float y) {

            Stroke saveStroke = g2d.getStroke();

            g2d.setStroke(getStroke(thickness));

            g2d.draw(new Line2D.Float(x1, y + shift, x2, y + shift));

            g2d.setStroke(saveStroke);

        }

        float getLowerDrawLimit(float thickness) {

            return shift + getLineThickness(thickness);

        }

        Shape getUnderlineShape(float thickness,

                                float x1,

                                float x2,

                                float y) {

            Stroke ulStroke = getStroke(thickness);

            Line2D line = new Line2D.Float(x1, y + shift, x2, y + shift);

            return ulStroke.createStrokedShape(line);

        }

    }

    // Implementation of UNDERLINE_LOW_GRAY.

    private static class IMGrayUnderline extends Underline {

        private BasicStroke stroke;

        IMGrayUnderline() {

            stroke = new BasicStroke(DEFAULT_THICKNESS,

                                     BasicStroke.CAP_BUTT,

                                     BasicStroke.JOIN_MITER,

                                     10.0f,

                                     new float[] {1, 1},

                                     0);

        }

        void drawUnderline(Graphics2D g2d,

                           float thickness,

                           float x1,

                           float x2,

                           float y) {

            Stroke saveStroke = g2d.getStroke();

            g2d.setStroke(stroke);

            Line2D.Float drawLine = new Line2D.Float(x1, y, x2, y);

            g2d.draw(drawLine);

            drawLine.y1 += DEFAULT_THICKNESS;

            drawLine.y2 += DEFAULT_THICKNESS;

            drawLine.x1 += DEFAULT_THICKNESS;

            g2d.draw(drawLine);

            g2d.setStroke(saveStroke);

        }

        float getLowerDrawLimit(float thickness) {

            return DEFAULT_THICKNESS * 2;

        }

        Shape getUnderlineShape(float thickness,

                                float x1,

                                float x2,

                                float y) {

            GeneralPath gp = new GeneralPath();

            Line2D.Float line = new Line2D.Float(x1, y, x2, y);

            gp.append(stroke.createStrokedShape(line), false);

            line.y1 += DEFAULT_THICKNESS;

            line.y2 += DEFAULT_THICKNESS;

            line.x1 += DEFAULT_THICKNESS;

            gp.append(stroke.createStrokedShape(line), false);

            return gp;

        }

    }

     // Keep a map of underlines, one for each type

     // of underline.  The Underline objects are Flyweights

     // (shared across multiple clients), so they should be immutable.

     // If this implementation changes then clone underline

     // instances in getUnderline before returning them.

    private static final ConcurrentHashMap<Object, Underline>

        UNDERLINES = new ConcurrentHashMap<Object, Underline>(6);

    private static final Underline[] UNDERLINE_LIST;

    static {

        Underline[] uls = new Underline[6];

        uls[0] = new StandardUnderline(0, 1, null, USE_THICKNESS);

        UNDERLINES.put(TextAttribute.UNDERLINE_ON, uls[0]);

        uls[1] = new StandardUnderline(1, 1, null, IGNORE_THICKNESS);

        UNDERLINES.put(TextAttribute.UNDERLINE_LOW_ONE_PIXEL, uls[1]);

        uls[2] = new StandardUnderline(1, 2, null, IGNORE_THICKNESS);

        UNDERLINES.put(TextAttribute.UNDERLINE_LOW_TWO_PIXEL, uls[2]);

        uls[3] = new StandardUnderline(1, 1, new float[] { 1, 1 }, IGNORE_THICKNESS);

        UNDERLINES.put(TextAttribute.UNDERLINE_LOW_DOTTED, uls[3]);

        uls[4] = new IMGrayUnderline();

        UNDERLINES.put(TextAttribute.UNDERLINE_LOW_GRAY, uls[4]);

        uls[5] = new StandardUnderline(1, 1, new float[] { 4, 4 }, IGNORE_THICKNESS);

        UNDERLINES.put(TextAttribute.UNDERLINE_LOW_DASHED, uls[5]);

        UNDERLINE_LIST = uls;

    }

    /**

     * Return the Underline for the given value of

     * TextAttribute.INPUT_METHOD_UNDERLINE or

     * TextAttribute.UNDERLINE.

     * If value is not an input method underline value or

     * TextAttribute.UNDERLINE_ON, null is returned.

     */

    static Underline getUnderline(Object value) {

        if (value == null) {

            return null;

        }

        return UNDERLINES.get(value);

    }

    static Underline getUnderline(int index) {

        return index < 0 ? null : UNDERLINE_LIST[index];

    }

}