/*

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

 */

package javax.swing.text;

import java.awt.event.ActionEvent;

import java.io.*;

import java.text.*;

import java.text.AttributedCharacterIterator.Attribute;

import java.util.*;

import javax.swing.*;

/**

 * <code>InternationalFormatter</code> extends <code>DefaultFormatter</code>,

 * using an instance of <code>java.text.Format</code> to handle the

 * conversion to a String, and the conversion from a String.

 * <p>

 * If <code>getAllowsInvalid()</code> is false, this will ask the

 * <code>Format</code> to format the current text on every edit.

 * <p>

 * You can specify a minimum and maximum value by way of the

 * <code>setMinimum</code> and <code>setMaximum</code> methods. In order

 * for this to work the values returned from <code>stringToValue</code> must be

 * comparable to the min/max values by way of the <code>Comparable</code>

 * interface.

 * <p>

 * Be careful how you configure the <code>Format</code> and the

 * <code>InternationalFormatter</code>, as it is possible to create a

 * situation where certain values can not be input. Consider the date

 * format 'M/d/yy', an <code>InternationalFormatter</code> that is always

 * valid (<code>setAllowsInvalid(false)</code>), is in overwrite mode

 * (<code>setOverwriteMode(true)</code>) and the date 7/1/99. In this

 * case the user will not be able to enter a two digit month or day of

 * month. To avoid this, the format should be 'MM/dd/yy'.

 * <p>

 * If <code>InternationalFormatter</code> is configured to only allow valid

 * values (<code>setAllowsInvalid(false)</code>), every valid edit will result

 * in the text of the <code>JFormattedTextField</code> being completely reset

 * from the <code>Format</code>.

 * The cursor position will also be adjusted as literal characters are

 * added/removed from the resulting String.

 * <p>

 * <code>InternationalFormatter</code>'s behavior of

 * <code>stringToValue</code> is  slightly different than that of

 * <code>DefaultTextFormatter</code>, it does the following:

 * <ol>

 *   <li><code>parseObject</code> is invoked on the <code>Format</code>

 *       specified by <code>setFormat</code>

 *   <li>If a Class has been set for the values (<code>setValueClass</code>),

 *       supers implementation is invoked to convert the value returned

 *       from <code>parseObject</code> to the appropriate class.

 *   <li>If a <code>ParseException</code> has not been thrown, and the value

 *       is outside the min/max a <code>ParseException</code> is thrown.

 *   <li>The value is returned.

 * </ol>

 * <code>InternationalFormatter</code> implements <code>stringToValue</code>

 * in this manner so that you can specify an alternate Class than

 * <code>Format</code> may return.

 * <p>

 * <strong>Warning:</strong>

 * Serialized objects of this class will not be compatible with

 * future Swing releases. The current serialization support is

 * appropriate for short term storage or RMI between applications running

 * the same version of Swing.  As of 1.4, support for long term storage

 * of all JavaBeans™

 * has been added to the <code>java.beans</code> package.

 * Please see {@link java.beans.XMLEncoder}.

 *

 * @see java.text.Format

 * @see java.lang.Comparable

 *

 * @since 1.4

 */

@SuppressWarnings("serial") // Same-version serialization only

public class InternationalFormatter extends DefaultFormatter {

    /**

     * Used by <code>getFields</code>.

     */

    private static final Format.Field[] EMPTY_FIELD_ARRAY =new Format.Field[0];

    /**

     * Object used to handle the conversion.

     */

    private Format format;

    /**

     * Can be used to impose a maximum value.

     */

    private Comparable max;

    /**

     * Can be used to impose a minimum value.

     */

    private Comparable min;

    /**

     * <code>InternationalFormatter</code>'s behavior is dicatated by a

     * <code>AttributedCharacterIterator</code> that is obtained from

     * the <code>Format</code>. On every edit, assuming

     * allows invalid is false, the <code>Format</code> instance is invoked

     * with <code>formatToCharacterIterator</code>. A <code>BitSet</code> is

     * also kept upto date with the non-literal characters, that is

     * for every index in the <code>AttributedCharacterIterator</code> an

     * entry in the bit set is updated based on the return value from

     * <code>isLiteral(Map)</code>. <code>isLiteral(int)</code> then uses

     * this cached information.

     * <p>

     * If allowsInvalid is false, every edit results in resetting the complete

     * text of the JTextComponent.

     * <p>

     * InternationalFormatterFilter can also provide two actions suitable for

     * incrementing and decrementing. To enable this a subclass must

     * override <code>getSupportsIncrement</code> to return true, and

     * override <code>adjustValue</code> to handle the changing of the

     * value. If you want to support changing the value outside of

     * the valid FieldPositions, you will need to override

     * <code>canIncrement</code>.

     */

    /**

     * A bit is set for every index identified in the

     * AttributedCharacterIterator that is not considered decoration.

     * This should only be used if validMask is true.

     */

    private transient BitSet literalMask;

    /**

     * Used to iterate over characters.

     */

    private transient AttributedCharacterIterator iterator;

    /**

     * True if the Format was able to convert the value to a String and

     * back.

     */

    private transient boolean validMask;

    /**

     * Current value being displayed.

     */

    private transient String string;

    /**

     * If true, DocumentFilter methods are unconditionally allowed,

     * and no checking is done on their values. This is used when

     * incrementing/decrementing via the actions.

     */

    private transient boolean ignoreDocumentMutate;

    /**

     * Creates an <code>InternationalFormatter</code> with no

     * <code>Format</code> specified.

     */

    public InternationalFormatter() {

        setOverwriteMode(false);

    }

    /**

     * Creates an <code>InternationalFormatter</code> with the specified

     * <code>Format</code> instance.

     *

     * @param format Format instance used for converting from/to Strings

     */

    public InternationalFormatter(Format format) {

        this();

        setFormat(format);

    }

    /**

     * Sets the format that dictates the legal values that can be edited

     * and displayed.

     *

     * @param format <code>Format</code> instance used for converting

     * from/to Strings

     */

    public void setFormat(Format format) {

        this.format = format;

    }

    /**

     * Returns the format that dictates the legal values that can be edited

     * and displayed.

     *

     * @return Format instance used for converting from/to Strings

     */

    public Format getFormat() {

        return format;

    }

    /**

     * Sets the minimum permissible value. If the <code>valueClass</code> has

     * not been specified, and <code>minimum</code> is non null, the

     * <code>valueClass</code> will be set to that of the class of

     * <code>minimum</code>.

     *

     * @param minimum Minimum legal value that can be input

     * @see #setValueClass

     */

    public void setMinimum(Comparable minimum) {

        if (getValueClass() == null && minimum != null) {

            setValueClass(minimum.getClass());

        }

        min = minimum;

    }

    /**

     * Returns the minimum permissible value.

     *

     * @return Minimum legal value that can be input

     */

    public Comparable getMinimum() {

        return min;

    }

    /**

     * Sets the maximum permissible value. If the <code>valueClass</code> has

     * not been specified, and <code>max</code> is non null, the

     * <code>valueClass</code> will be set to that of the class of

     * <code>max</code>.

     *

     * @param max Maximum legal value that can be input

     * @see #setValueClass

     */

    public void setMaximum(Comparable max) {

        if (getValueClass() == null && max != null) {

            setValueClass(max.getClass());

        }

        this.max = max;

    }

    /**

     * Returns the maximum permissible value.

     *

     * @return Maximum legal value that can be input

     */

    public Comparable getMaximum() {

        return max;

    }

    /**

     * Installs the <code>DefaultFormatter</code> onto a particular

     * <code>JFormattedTextField</code>.

     * This will invoke <code>valueToString</code> to convert the

     * current value from the <code>JFormattedTextField</code> to

     * a String. This will then install the <code>Action</code>s from

     * <code>getActions</code>, the <code>DocumentFilter</code>

     * returned from <code>getDocumentFilter</code> and the

     * <code>NavigationFilter</code> returned from

     * <code>getNavigationFilter</code> onto the

     * <code>JFormattedTextField</code>.

     * <p>

     * Subclasses will typically only need to override this if they

     * wish to install additional listeners on the

     * <code>JFormattedTextField</code>.

     * <p>

     * If there is a <code>ParseException</code> in converting the

     * current value to a String, this will set the text to an empty

     * String, and mark the <code>JFormattedTextField</code> as being

     * in an invalid state.

     * <p>

     * While this is a public method, this is typically only useful

     * for subclassers of <code>JFormattedTextField</code>.

     * <code>JFormattedTextField</code> will invoke this method at

     * the appropriate times when the value changes, or its internal

     * state changes.

     *

     * @param ftf JFormattedTextField to format for, may be null indicating

     *            uninstall from current JFormattedTextField.

     */

    public void install(JFormattedTextField ftf) {

        super.install(ftf);

        updateMaskIfNecessary();

        // invoked again as the mask should now be valid.

        positionCursorAtInitialLocation();

    }

    /**

     * Returns a String representation of the Object <code>value</code>.

     * This invokes <code>format</code> on the current <code>Format</code>.

     *

     * @throws ParseException if there is an error in the conversion

     * @param value Value to convert

     * @return String representation of value

     */

    public String valueToString(Object value) throws ParseException {

        if (value == null) {

            return "";

        }

        Format f = getFormat();

        if (f == null) {

            return value.toString();

        }

        return f.format(value);

    }

    /**

     * Returns the <code>Object</code> representation of the

     * <code>String</code> <code>text</code>.

     *

     * @param text <code>String</code> to convert

     * @return <code>Object</code> representation of text

     * @throws ParseException if there is an error in the conversion

     */

    public Object stringToValue(String text) throws ParseException {

        Object value = stringToValue(text, getFormat());

        // Convert to the value class if the Value returned from the

        // Format does not match.

        if (value != null && getValueClass() != null &&

                             !getValueClass().isInstance(value)) {

            value = super.stringToValue(value.toString());

        }

        try {

            if (!isValidValue(value, true)) {

                throw new ParseException("Value not within min/max range", 0);

            }

        } catch (ClassCastException cce) {

            throw new ParseException("Class cast exception comparing values: "

                                     + cce, 0);

        }

        return value;

    }

    /**

     * Returns the <code>Format.Field</code> constants associated with

     * the text at <code>offset</code>. If <code>offset</code> is not

     * a valid location into the current text, this will return an

     * empty array.

     *

     * @param offset offset into text to be examined

     * @return Format.Field constants associated with the text at the

     *         given position.

     */

    public Format.Field[] getFields(int offset) {

        if (getAllowsInvalid()) {

            // This will work if the currently edited value is valid.

            updateMask();

        }

        Map<Attribute, Object> attrs = getAttributes(offset);

        if (attrs != null && attrs.size() > 0) {

            ArrayList<Attribute> al = new ArrayList<Attribute>();

            al.addAll(attrs.keySet());

            return al.toArray(EMPTY_FIELD_ARRAY);

        }

        return EMPTY_FIELD_ARRAY;

    }

    /**

     * Creates a copy of the DefaultFormatter.

     *

     * @return copy of the DefaultFormatter

     */

    public Object clone() throws CloneNotSupportedException {

        InternationalFormatter formatter = (InternationalFormatter)super.

                                           clone();

        formatter.literalMask = null;

        formatter.iterator = null;

        formatter.validMask = false;

        formatter.string = null;

        return formatter;

    }

    /**

     * If <code>getSupportsIncrement</code> returns true, this returns

     * two Actions suitable for incrementing/decrementing the value.

     */

    protected Action[] getActions() {

        if (getSupportsIncrement()) {

            return new Action[] { new IncrementAction("increment", 1),

                                  new IncrementAction("decrement", -1) };

        }

        return null;

    }

    /**

     * Invokes <code>parseObject</code> on <code>f</code>, returning

     * its value.

     */

    Object stringToValue(String text, Format f) throws ParseException {

        if (f == null) {

            return text;

        }

        return f.parseObject(text);

    }

    /**

     * Returns true if <code>value</code> is between the min/max.

     *

     * @param wantsCCE If false, and a ClassCastException is thrown in

     *                 comparing the values, the exception is consumed and

     *                 false is returned.

     */

    boolean isValidValue(Object value, boolean wantsCCE) {

        Comparable min = getMinimum();

        try {

            if (min != null && min.compareTo(value) > 0) {

                return false;

            }

        } catch (ClassCastException cce) {

            if (wantsCCE) {

                throw cce;

            }

            return false;

        }

        Comparable max = getMaximum();

        try {

            if (max != null && max.compareTo(value) < 0) {

                return false;

            }

        } catch (ClassCastException cce) {

            if (wantsCCE) {

                throw cce;

            }

            return false;

        }

        return true;

    }

    /**

     * Returns a Set of the attribute identifiers at <code>index</code>.

     */

    Map<Attribute, Object> getAttributes(int index) {

        if (isValidMask()) {

            AttributedCharacterIterator iterator = getIterator();

            if (index >= 0 && index <= iterator.getEndIndex()) {

                iterator.setIndex(index);

                return iterator.getAttributes();

            }

        }

        return null;

    }

    /**

     * Returns the start of the first run that contains the attribute

     * <code>id</code>. This will return <code>-1</code> if the attribute

     * can not be found.

     */

    int getAttributeStart(AttributedCharacterIterator.Attribute id) {

        if (isValidMask()) {

            AttributedCharacterIterator iterator = getIterator();

            iterator.first();

            while (iterator.current() != CharacterIterator.DONE) {

                if (iterator.getAttribute(id) != null) {

                    return iterator.getIndex();

                }

                iterator.next();

            }

        }

        return -1;

    }

    /**

     * Returns the <code>AttributedCharacterIterator</code> used to

     * format the last value.

     */

    AttributedCharacterIterator getIterator() {

        return iterator;

    }

    /**

     * Updates the AttributedCharacterIterator and bitset, if necessary.

     */

    void updateMaskIfNecessary() {

        if (!getAllowsInvalid() && (getFormat() != null)) {

            if (!isValidMask()) {

                updateMask();

            }

            else {

                String newString = getFormattedTextField().getText();

                if (!newString.equals(string)) {

                    updateMask();

                }

            }

        }

    }

    /**

     * Updates the AttributedCharacterIterator by invoking

     * <code>formatToCharacterIterator</code> on the <code>Format</code>.

     * If this is successful,

     * <code>updateMask(AttributedCharacterIterator)</code>

     * is then invoked to update the internal bitmask.

     */

    void updateMask() {

        if (getFormat() != null) {

            Document doc = getFormattedTextField().getDocument();

            validMask = false;

            if (doc != null) {

                try {

                    string = doc.getText(0, doc.getLength());

                } catch (BadLocationException ble) {

                    string = null;

                }

                if (string != null) {

                    try {

                        Object value = stringToValue(string);

                        AttributedCharacterIterator iterator = getFormat().

                                  formatToCharacterIterator(value);