/*

 * 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 sun.reflect.misc.ReflectUtil;

import sun.swing.SwingUtilities2;

import java.io.Serializable;

import java.lang.reflect.*;

import java.text.ParseException;

import javax.swing.*;

import javax.swing.text.*;

/**

 * <code>DefaultFormatter</code> formats arbitrary objects. Formatting is done

 * by invoking the <code>toString</code> method. In order to convert the

 * value back to a String, your class must provide a constructor that

 * takes a String argument. If no single argument constructor that takes a

 * String is found, the returned value will be the String passed into

 * <code>stringToValue</code>.

 * <p>

 * Instances of <code>DefaultFormatter</code> can not be used in multiple

 * instances of <code>JFormattedTextField</code>. To obtain a copy of

 * an already configured <code>DefaultFormatter</code>, use the

 * <code>clone</code> method.

 * <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 javax.swing.JFormattedTextField.AbstractFormatter

 *

 * @since 1.4

 */

public class DefaultFormatter extends JFormattedTextField.AbstractFormatter

                    implements Cloneable, Serializable {

    /** Indicates if the value being edited must match the mask. */

    private boolean allowsInvalid;

    /** If true, editing mode is in overwrite (or strikethough). */

    private boolean overwriteMode;

    /** If true, any time a valid edit happens commitEdit is invoked. */

    private boolean commitOnEdit;

    /** Class used to create new instances. */

    private Class<?> valueClass;

    /** NavigationFilter that forwards calls back to DefaultFormatter. */

    private NavigationFilter navigationFilter;

    /** DocumentFilter that forwards calls back to DefaultFormatter. */

    private DocumentFilter documentFilter;

    /** Used during replace to track the region to replace. */

    transient ReplaceHolder replaceHolder;

    /**

     * Creates a DefaultFormatter.

     */

    public DefaultFormatter() {

        overwriteMode = true;

        allowsInvalid = true;

    }

    /**

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

        positionCursorAtInitialLocation();

    }

    /**

     * Sets when edits are published back to the

     * <code>JFormattedTextField</code>. If true, <code>commitEdit</code>

     * is invoked after every valid edit (any time the text is edited). On

     * the other hand, if this is false than the <code>DefaultFormatter</code>

     * does not publish edits back to the <code>JFormattedTextField</code>.

     * As such, the only time the value of the <code>JFormattedTextField</code>

     * will change is when <code>commitEdit</code> is invoked on

     * <code>JFormattedTextField</code>, typically when enter is pressed

     * or focus leaves the <code>JFormattedTextField</code>.

     *

     * @param commit Used to indicate when edits are committed back to the

     *               JTextComponent

     */

    public void setCommitsOnValidEdit(boolean commit) {

        commitOnEdit = commit;

    }

    /**

     * Returns when edits are published back to the

     * <code>JFormattedTextField</code>.

     *

     * @return true if edits are committed after every valid edit

     */

    public boolean getCommitsOnValidEdit() {

        return commitOnEdit;

    }

    /**

     * Configures the behavior when inserting characters. If

     * <code>overwriteMode</code> is true (the default), new characters

     * overwrite existing characters in the model.

     *

     * @param overwriteMode Indicates if overwrite or overstrike mode is used

     */

    public void setOverwriteMode(boolean overwriteMode) {

        this.overwriteMode = overwriteMode;

    }

    /**

     * Returns the behavior when inserting characters.

     *

     * @return true if newly inserted characters overwrite existing characters

     */

    public boolean getOverwriteMode() {

        return overwriteMode;

    }

    /**

     * Sets whether or not the value being edited is allowed to be invalid

     * for a length of time (that is, <code>stringToValue</code> throws

     * a <code>ParseException</code>).

     * It is often convenient to allow the user to temporarily input an

     * invalid value.

     *

     * @param allowsInvalid Used to indicate if the edited value must always

     *        be valid

     */

    public void setAllowsInvalid(boolean allowsInvalid) {

        this.allowsInvalid = allowsInvalid;

    }

    /**

     * Returns whether or not the value being edited is allowed to be invalid

     * for a length of time.

     *

     * @return false if the edited value must always be valid

     */

    public boolean getAllowsInvalid() {

        return allowsInvalid;

    }

    /**

     * Sets that class that is used to create new Objects. If the

     * passed in class does not have a single argument constructor that

     * takes a String, String values will be used.

     *

     * @param valueClass Class used to construct return value from

     *        stringToValue

     */

    public void setValueClass(Class<?> valueClass) {

        this.valueClass = valueClass;

    }

    /**

     * Returns that class that is used to create new Objects.

     *

     * @return Class used to construct return value from stringToValue

     */

    public Class<?> getValueClass() {

        return valueClass;

    }

    /**

     * Converts the passed in String into an instance of

     * <code>getValueClass</code> by way of the constructor that

     * takes a String argument. If <code>getValueClass</code>

     * returns null, the Class of the current value in the

     * <code>JFormattedTextField</code> will be used. If this is null, a

     * String will be returned. If the constructor throws an exception, a

     * <code>ParseException</code> will be thrown. If there is no single

     * argument String constructor, <code>string</code> will be returned.

     *

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

     * @param string String to convert

     * @return Object representation of text

     */

    public Object stringToValue(String string) throws ParseException {

        Class<?> vc = getValueClass();

        JFormattedTextField ftf = getFormattedTextField();

        if (vc == null && ftf != null) {

            Object value = ftf.getValue();

            if (value != null) {

                vc = value.getClass();

            }

        }

        if (vc != null) {

            Constructor cons;

            try {

                ReflectUtil.checkPackageAccess(vc);

                SwingUtilities2.checkAccess(vc.getModifiers());

                cons = vc.getConstructor(new Class[]{String.class});

            } catch (NoSuchMethodException nsme) {

                cons = null;

            }

            if (cons != null) {

                try {

                    SwingUtilities2.checkAccess(cons.getModifiers());

                    return cons.newInstance(new Object[] { string });

                } catch (Throwable ex) {

                    throw new ParseException("Error creating instance", 0);

                }

            }

        }

        return string;

    }

    /**

     * Converts the passed in Object into a String by way of the

     * <code>toString</code> method.

     *

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

        }

        return value.toString();

    }

    /**

     * Returns the <code>DocumentFilter</code> used to restrict the characters

     * that can be input into the <code>JFormattedTextField</code>.

     *

     * @return DocumentFilter to restrict edits

     */

    protected DocumentFilter getDocumentFilter() {

        if (documentFilter == null) {

            documentFilter = new DefaultDocumentFilter();

        }

        return documentFilter;

    }

    /**

     * Returns the <code>NavigationFilter</code> used to restrict where the

     * cursor can be placed.

     *

     * @return NavigationFilter to restrict navigation

     */

    protected NavigationFilter getNavigationFilter() {

        if (navigationFilter == null) {

            navigationFilter = new DefaultNavigationFilter();

        }

        return navigationFilter;

    }

    /**

     * Creates a copy of the DefaultFormatter.

     *

     * @return copy of the DefaultFormatter

     */

    public Object clone() throws CloneNotSupportedException {

        DefaultFormatter formatter = (DefaultFormatter)super.clone();

        formatter.navigationFilter = null;

        formatter.documentFilter = null;

        formatter.replaceHolder = null;

        return formatter;

    }

    /**

     * Positions the cursor at the initial location.

     */

    void positionCursorAtInitialLocation() {

        JFormattedTextField ftf = getFormattedTextField();

        if (ftf != null) {

            ftf.setCaretPosition(getInitialVisualPosition());

        }

    }

    /**

     * Returns the initial location to position the cursor at. This forwards

     * the call to <code>getNextNavigatableChar</code>.

     */

    int getInitialVisualPosition() {

        return getNextNavigatableChar(0, 1);

    }

    /**

     * Subclasses should override this if they want cursor navigation

     * to skip certain characters. A return value of false indicates

     * the character at <code>offset</code> should be skipped when

     * navigating throught the field.

     */

    boolean isNavigatable(int offset) {

        return true;

    }

    /**

     * Returns true if the text in <code>text</code> can be inserted.  This

     * does not mean the text will ultimately be inserted, it is used if

     * text can trivially reject certain characters.

     */

    boolean isLegalInsertText(String text) {

        return true;

    }

    /**

     * Returns the next editable character starting at offset incrementing

     * the offset by <code>direction</code>.

     */

    private int getNextNavigatableChar(int offset, int direction) {

        int max = getFormattedTextField().getDocument().getLength();

        while (offset >= 0 && offset < max) {

            if (isNavigatable(offset)) {

                return offset;

            }

            offset += direction;

        }

        return offset;

    }

    /**

     * A convenience methods to return the result of deleting

     * <code>deleteLength</code> characters at <code>offset</code>

     * and inserting <code>replaceString</code> at <code>offset</code>

     * in the current text field.

     */

    String getReplaceString(int offset, int deleteLength,

                            String replaceString) {

        String string = getFormattedTextField().getText();

        String result;

        result = string.substring(0, offset);

        if (replaceString != null) {

            result += replaceString;

        }

        if (offset + deleteLength < string.length()) {

            result += string.substring(offset + deleteLength);

        }

        return result;

    }

    /*

     * Returns true if the operation described by <code>rh</code> will

     * result in a legal edit.  This may set the <code>value</code>

     * field of <code>rh</code>.

     */

    boolean isValidEdit(ReplaceHolder rh) {

        if (!getAllowsInvalid()) {

            String newString = getReplaceString(rh.offset, rh.length, rh.text);

            try {

                rh.value = stringToValue(newString);

                return true;

            } catch (ParseException pe) {

                return false;

            }

        }

        return true;

    }

    /**

     * Invokes <code>commitEdit</code> on the JFormattedTextField.

     */

    void commitEdit() throws ParseException {

        JFormattedTextField ftf = getFormattedTextField();

        if (ftf != null) {

            ftf.commitEdit();

        }

    }

    /**

     * Pushes the value to the JFormattedTextField if the current value

     * is valid and invokes <code>setEditValid</code> based on the

     * validity of the value.

     */

    void updateValue() {

        updateValue(null);

    }

    /**

     * Pushes the <code>value</code> to the editor if we are to

     * commit on edits. If <code>value</code> is null, the current value

     * will be obtained from the text component.

     */

    void updateValue(Object value) {

        try {

            if (value == null) {

                String string = getFormattedTextField().getText();

                value = stringToValue(string);

            }

            if (getCommitsOnValidEdit()) {

                commitEdit();

            }

            setEditValid(true);

        } catch (ParseException pe) {

            setEditValid(false);

        }

    }

    /**

     * Returns the next cursor position from offset by incrementing

     * <code>direction</code>. This uses

     * <code>getNextNavigatableChar</code>

     * as well as constraining the location to the max position.

     */

    int getNextCursorPosition(int offset, int direction) {

        int newOffset = getNextNavigatableChar(offset, direction);

        int max = getFormattedTextField().getDocument().getLength();

        if (!getAllowsInvalid()) {

            if (direction == -1 && offset == newOffset) {

                // Case where hit backspace and only characters before

                // offset are fixed.

                newOffset = getNextNavigatableChar(newOffset, 1);

                if (newOffset >= max) {

                    newOffset = offset;

                }

            }

            else if (direction == 1 && newOffset >= max) {

                // Don't go beyond last editable character.

                newOffset = getNextNavigatableChar(max - 1, -1);

                if (newOffset < max) {

                    newOffset++;

                }

            }

        }

        return newOffset;

    }

    /**

     * Resets the cursor by using getNextCursorPosition.

     */

    void repositionCursor(int offset, int direction) {

        getFormattedTextField().getCaret().setDot(getNextCursorPosition

                                                  (offset, direction));

    }

    /**

     * Finds the next navigable character.

     */

    int getNextVisualPositionFrom(JTextComponent text, int pos,

                                  Position.Bias bias, int direction,

                                  Position.Bias[] biasRet)

                                           throws BadLocationException {

        int value = text.getUI().getNextVisualPositionFrom(text, pos, bias,

                                                           direction, biasRet);

        if (value == -1) {

            return -1;

        }

        if (!getAllowsInvalid() && (direction == SwingConstants.EAST ||

                                    direction == SwingConstants.WEST)) {

            int last = -1;

            while (!isNavigatable(value) && value != last) {

                last = value;

                value = text.getUI().getNextVisualPositionFrom(

                              text, value, bias, direction,biasRet);

            }

            int max = getFormattedTextField().getDocument().getLength();