Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JRE 8 rt.jar - javax.* Package Source Code
JRE 8 rt.jar is the JAR file for JRE 8 RT (Runtime) libraries. JRE (Java Runtime) 8 is the runtime environment included in JDK 8. JRE 8 rt.jar libraries are divided into 6 packages:
com.* - Internal Oracle and Sun Microsystems libraries java.* - Standard Java API libraries. javax.* - Extended Java API libraries. jdk.* - JDK supporting libraries. org.* - Third party libraries. sun.* - Old libraries developed by Sun Microsystems.
JAR File Information:
Directory of C:\fyicenter\jdk-1.8.0_191\jre\lib 63,596,151 rt.jar
Here is the list of Java classes of the javax.* package in JRE 1.8.0_191 rt.jar. Java source codes are also provided.
✍: FYIcenter
⏎ javax/swing/JFormattedTextField.java
/* * Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package javax.swing; import java.awt.*; import java.awt.event.*; import java.awt.im.InputContext; import java.io.*; import java.text.*; import java.util.*; import javax.swing.event.*; import javax.swing.plaf.UIResource; import javax.swing.text.*; /** * <code>JFormattedTextField</code> extends <code>JTextField</code> adding * support for formatting arbitrary values, as well as retrieving a particular * object once the user has edited the text. The following illustrates * configuring a <code>JFormattedTextField</code> to edit dates: * <pre> * JFormattedTextField ftf = new JFormattedTextField(); * ftf.setValue(new Date()); * </pre> * <p> * Once a <code>JFormattedTextField</code> has been created, you can * listen for editing changes by way of adding * a <code>PropertyChangeListener</code> and listening for * <code>PropertyChangeEvent</code>s with the property name <code>value</code>. * <p> * <code>JFormattedTextField</code> allows * configuring what action should be taken when focus is lost. The possible * configurations are: * <table summary="Possible JFormattedTextField configurations and their descriptions"> * <tr><th><p style="text-align:left">Value</p></th><th><p style="text-align:left">Description</p></th></tr> * <tr><td>JFormattedTextField.REVERT * <td>Revert the display to match that of <code>getValue</code>, * possibly losing the current edit. * <tr><td>JFormattedTextField.COMMIT * <td>Commits the current value. If the value being edited * isn't considered a legal value by the * <code>AbstractFormatter</code> that is, a * <code>ParseException</code> is thrown, then the value * will not change, and then edited value will persist. * <tr><td>JFormattedTextField.COMMIT_OR_REVERT * <td>Similar to <code>COMMIT</code>, but if the value isn't * legal, behave like <code>REVERT</code>. * <tr><td>JFormattedTextField.PERSIST * <td>Do nothing, don't obtain a new * <code>AbstractFormatter</code>, and don't update the value. * </table> * The default is <code>JFormattedTextField.COMMIT_OR_REVERT</code>, * refer to {@link #setFocusLostBehavior} for more information on this. * <p> * <code>JFormattedTextField</code> allows the focus to leave, even if * the currently edited value is invalid. To lock the focus down while the * <code>JFormattedTextField</code> is an invalid edit state * you can attach an <code>InputVerifier</code>. The following code snippet * shows a potential implementation of such an <code>InputVerifier</code>: * <pre> * public class FormattedTextFieldVerifier extends InputVerifier { * public boolean verify(JComponent input) { * if (input instanceof JFormattedTextField) { * JFormattedTextField ftf = (JFormattedTextField)input; * AbstractFormatter formatter = ftf.getFormatter(); * if (formatter != null) { * String text = ftf.getText(); * try { * formatter.stringToValue(text); * return true; * } catch (ParseException pe) { * return false; * } * } * } * return true; * } * public boolean shouldYieldFocus(JComponent input) { * return verify(input); * } * } * </pre> * <p> * Alternatively, you could invoke <code>commitEdit</code>, which would also * commit the value. * <p> * <code>JFormattedTextField</code> does not do the formatting it self, * rather formatting is done through an instance of * <code>JFormattedTextField.AbstractFormatter</code> which is obtained from * an instance of <code>JFormattedTextField.AbstractFormatterFactory</code>. * Instances of <code>JFormattedTextField.AbstractFormatter</code> are * notified when they become active by way of the * <code>install</code> method, at which point the * <code>JFormattedTextField.AbstractFormatter</code> can install whatever * it needs to, typically a <code>DocumentFilter</code>. Similarly when * <code>JFormattedTextField</code> no longer * needs the <code>AbstractFormatter</code>, it will invoke * <code>uninstall</code>. * <p> * <code>JFormattedTextField</code> typically * queries the <code>AbstractFormatterFactory</code> for an * <code>AbstractFormat</code> when it gains or loses focus. Although this * can change based on the focus lost policy. If the focus lost * policy is <code>JFormattedTextField.PERSIST</code> * and the <code>JFormattedTextField</code> has been edited, the * <code>AbstractFormatterFactory</code> will not be queried until the * value has been committed. Similarly if the focus lost policy is * <code>JFormattedTextField.COMMIT</code> and an exception * is thrown from <code>stringToValue</code>, the * <code>AbstractFormatterFactory</code> will not be queried when focus is * lost or gained. * <p> * <code>JFormattedTextField.AbstractFormatter</code> * is also responsible for determining when values are committed to * the <code>JFormattedTextField</code>. Some * <code>JFormattedTextField.AbstractFormatter</code>s will make new values * available on every edit, and others will never commit the value. You can * force the current value to be obtained * from the current <code>JFormattedTextField.AbstractFormatter</code> * by way of invoking <code>commitEdit</code>. <code>commitEdit</code> will * be invoked whenever return is pressed in the * <code>JFormattedTextField</code>. * <p> * If an <code>AbstractFormatterFactory</code> has not been explicitly * set, one will be set based on the <code>Class</code> of the value type after * <code>setValue</code> has been invoked (assuming value is non-null). * For example, in the following code an appropriate * <code>AbstractFormatterFactory</code> and <code>AbstractFormatter</code> * will be created to handle formatting of numbers: * <pre> * JFormattedTextField tf = new JFormattedTextField(); * tf.setValue(100); * </pre> * <p> * <strong>Warning:</strong> As the <code>AbstractFormatter</code> will * typically install a <code>DocumentFilter</code> on the * <code>Document</code>, and a <code>NavigationFilter</code> on the * <code>JFormattedTextField</code> you should not install your own. If you do, * you are likely to see odd behavior in that the editing policy of the * <code>AbstractFormatter</code> will not be enforced. * <p> * <strong>Warning:</strong> Swing is not thread safe. For more * information see <a * href="package-summary.html#threading">Swing's Threading * Policy</a>. * <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}. * * @since 1.4 */ public class JFormattedTextField extends JTextField { private static final String uiClassID = "FormattedTextFieldUI"; private static final Action[] defaultActions = { new CommitAction(), new CancelAction() }; /** * Constant identifying that when focus is lost, * <code>commitEdit</code> should be invoked. If in committing the * new value a <code>ParseException</code> is thrown, the invalid * value will remain. * * @see #setFocusLostBehavior */ public static final int COMMIT = 0; /** * Constant identifying that when focus is lost, * <code>commitEdit</code> should be invoked. If in committing the new * value a <code>ParseException</code> is thrown, the value will be * reverted. * * @see #setFocusLostBehavior */ public static final int COMMIT_OR_REVERT = 1; /** * Constant identifying that when focus is lost, editing value should * be reverted to current value set on the * <code>JFormattedTextField</code>. * * @see #setFocusLostBehavior */ public static final int REVERT = 2; /** * Constant identifying that when focus is lost, the edited value * should be left. * * @see #setFocusLostBehavior */ public static final int PERSIST = 3; /** * Factory used to obtain an instance of AbstractFormatter. */ private AbstractFormatterFactory factory; /** * Object responsible for formatting the current value. */ private AbstractFormatter format; /** * Last valid value. */ private Object value; /** * True while the value being edited is valid. */ private boolean editValid; /** * Behavior when focus is lost. */ private int focusLostBehavior; /** * Indicates the current value has been edited. */ private boolean edited; /** * Used to set the dirty state. */ private DocumentListener documentListener; /** * Masked used to set the AbstractFormatterFactory. */ private Object mask; /** * ActionMap that the TextFormatter Actions are added to. */ private ActionMap textFormatterActionMap; /** * Indicates the input method composed text is in the document */ private boolean composedTextExists = false; /** * A handler for FOCUS_LOST event */ private FocusLostHandler focusLostHandler; /** * Creates a <code>JFormattedTextField</code> with no * <code>AbstractFormatterFactory</code>. Use <code>setMask</code> or * <code>setFormatterFactory</code> to configure the * <code>JFormattedTextField</code> to edit a particular type of * value. */ public JFormattedTextField() { super(); enableEvents(AWTEvent.FOCUS_EVENT_MASK); setFocusLostBehavior(COMMIT_OR_REVERT); } /** * Creates a JFormattedTextField with the specified value. This will * create an <code>AbstractFormatterFactory</code> based on the * type of <code>value</code>. * * @param value Initial value for the JFormattedTextField */ public JFormattedTextField(Object value) { this(); setValue(value); } /** * Creates a <code>JFormattedTextField</code>. <code>format</code> is * wrapped in an appropriate <code>AbstractFormatter</code> which is * then wrapped in an <code>AbstractFormatterFactory</code>. * * @param format Format used to look up an AbstractFormatter */ public JFormattedTextField(java.text.Format format) { this(); setFormatterFactory(getDefaultFormatterFactory(format)); } /** * Creates a <code>JFormattedTextField</code> with the specified * <code>AbstractFormatter</code>. The <code>AbstractFormatter</code> * is placed in an <code>AbstractFormatterFactory</code>. * * @param formatter AbstractFormatter to use for formatting. */ public JFormattedTextField(AbstractFormatter formatter) { this(new DefaultFormatterFactory(formatter)); } /** * Creates a <code>JFormattedTextField</code> with the specified * <code>AbstractFormatterFactory</code>. * * @param factory AbstractFormatterFactory used for formatting. */ public JFormattedTextField(AbstractFormatterFactory factory) { this(); setFormatterFactory(factory); } /** * Creates a <code>JFormattedTextField</code> with the specified * <code>AbstractFormatterFactory</code> and initial value. * * @param factory <code>AbstractFormatterFactory</code> used for * formatting. * @param currentValue Initial value to use */ public JFormattedTextField(AbstractFormatterFactory factory, Object currentValue) { this(currentValue); setFormatterFactory(factory); } /** * Sets the behavior when focus is lost. This will be one of * <code>JFormattedTextField.COMMIT_OR_REVERT</code>, * <code>JFormattedTextField.REVERT</code>, * <code>JFormattedTextField.COMMIT</code> or * <code>JFormattedTextField.PERSIST</code> * Note that some <code>AbstractFormatter</code>s may push changes as * they occur, so that the value of this will have no effect. * <p> * This will throw an <code>IllegalArgumentException</code> if the object * passed in is not one of the afore mentioned values. * <p> * The default value of this property is * <code>JFormattedTextField.COMMIT_OR_REVERT</code>. * * @param behavior Identifies behavior when focus is lost * @throws IllegalArgumentException if behavior is not one of the known * values * @beaninfo * enum: COMMIT JFormattedTextField.COMMIT * COMMIT_OR_REVERT JFormattedTextField.COMMIT_OR_REVERT * REVERT JFormattedTextField.REVERT * PERSIST JFormattedTextField.PERSIST * description: Behavior when component loses focus */ public void setFocusLostBehavior(int behavior) { if (behavior != COMMIT && behavior != COMMIT_OR_REVERT && behavior != PERSIST && behavior != REVERT) { throw new IllegalArgumentException("setFocusLostBehavior must be one of: JFormattedTextField.COMMIT, JFormattedTextField.COMMIT_OR_REVERT, JFormattedTextField.PERSIST or JFormattedTextField.REVERT"); } focusLostBehavior = behavior; } /** * Returns the behavior when focus is lost. This will be one of * <code>COMMIT_OR_REVERT</code>, * <code>COMMIT</code>, * <code>REVERT</code> or * <code>PERSIST</code> * Note that some <code>AbstractFormatter</code>s may push changes as * they occur, so that the value of this will have no effect. * * @return returns behavior when focus is lost */ public int getFocusLostBehavior() { return focusLostBehavior; } /** * Sets the <code>AbstractFormatterFactory</code>. * <code>AbstractFormatterFactory</code> is * able to return an instance of <code>AbstractFormatter</code> that is * used to format a value for display, as well an enforcing an editing * policy. * <p> * If you have not explicitly set an <code>AbstractFormatterFactory</code> * by way of this method (or a constructor) an * <code>AbstractFormatterFactory</code> and consequently an * <code>AbstractFormatter</code> will be used based on the * <code>Class</code> of the value. <code>NumberFormatter</code> will * be used for <code>Number</code>s, <code>DateFormatter</code> will * be used for <code>Dates</code>, otherwise <code>DefaultFormatter</code> * will be used. * <p> * This is a JavaBeans bound property. * * @param tf <code>AbstractFormatterFactory</code> used to lookup * instances of <code>AbstractFormatter</code> * @beaninfo * bound: true * attribute: visualUpdate true * description: AbstractFormatterFactory, responsible for returning an * AbstractFormatter that can format the current value. */ public void setFormatterFactory(AbstractFormatterFactory tf) { AbstractFormatterFactory oldFactory = factory; factory = tf; firePropertyChange("formatterFactory", oldFactory, tf); setValue(getValue(), true, false); } /** * Returns the current <code>AbstractFormatterFactory</code>. * * @see #setFormatterFactory * @return <code>AbstractFormatterFactory</code> used to determine * <code>AbstractFormatter</code>s */ public AbstractFormatterFactory getFormatterFactory() { return factory; } /** * Sets the current <code>AbstractFormatter</code>. * <p> * You should not normally invoke this, instead set the * <code>AbstractFormatterFactory</code> or set the value. * <code>JFormattedTextField</code> will * invoke this as the state of the <code>JFormattedTextField</code> * changes and requires the value to be reset. * <code>JFormattedTextField</code> passes in the * <code>AbstractFormatter</code> obtained from the * <code>AbstractFormatterFactory</code>. * <p> * This is a JavaBeans bound property. * * @see #setFormatterFactory * @param format AbstractFormatter to use for formatting * @beaninfo * bound: true * attribute: visualUpdate true * description: TextFormatter, responsible for formatting the current value */ protected void setFormatter(AbstractFormatter format) { AbstractFormatter oldFormat = this.format; if (oldFormat != null) { oldFormat.uninstall(); } setEditValid(true); this.format = format; if (format != null) { format.install(this); } setEdited(false); firePropertyChange("textFormatter", oldFormat, format); } /** * Returns the <code>AbstractFormatter</code> that is used to format and * parse the current value. * * @return AbstractFormatter used for formatting */ public AbstractFormatter getFormatter() { return format; } /** * Sets the value that will be formatted by an * <code>AbstractFormatter</code> obtained from the current * <code>AbstractFormatterFactory</code>. If no * <code>AbstractFormatterFactory</code> has been specified, this will * attempt to create one based on the type of <code>value</code>. * <p> * The default value of this property is null. * <p> * This is a JavaBeans bound property. * * @param value Current value to display * @beaninfo * bound: true * attribute: visualUpdate true * description: The value to be formatted. */ public void setValue(Object value) { if (value != null && getFormatterFactory() == null) { setFormatterFactory(getDefaultFormatterFactory(value)); } setValue(value, true, true); } /** * Returns the last valid value. Based on the editing policy of * the <code>AbstractFormatter</code> this may not return the current * value. The currently edited value can be obtained by invoking * <code>commitEdit</code> followed by <code>getValue</code>. * * @return Last valid value */ public Object getValue() { return value; } /** * Forces the current value to be taken from the * <code>AbstractFormatter</code> and set as the current value. * This has no effect if there is no current * <code>AbstractFormatter</code> installed. * * @throws ParseException if the <code>AbstractFormatter</code> is not able * to format the current value */ public void commitEdit() throws ParseException { AbstractFormatter format = getFormatter(); if (format != null) { setValue(format.stringToValue(getText()), false, true); } } /** * Sets the validity of the edit on the receiver. You should not normally * invoke this. This will be invoked by the * <code>AbstractFormatter</code> as the user edits the value. * <p> * Not all formatters will allow the component to get into an invalid * state, and thus this may never be invoked. * <p> * Based on the look and feel this may visually change the state of * the receiver. * * @param isValid boolean indicating if the currently edited value is * valid. * @beaninfo * bound: true * attribute: visualUpdate true * description: True indicates the edited value is valid */ private void setEditValid(boolean isValid) { if (isValid != editValid) { editValid = isValid; firePropertyChange("editValid", Boolean.valueOf(!isValid), Boolean.valueOf(isValid)); } } /** * Returns true if the current value being edited is valid. The value of * this is managed by the current <code>AbstractFormatter</code>, as such * there is no public setter for it. * * @return true if the current value being edited is valid. */ public boolean isEditValid() { return editValid; } /** * Invoked when the user inputs an invalid value. This gives the * component a chance to provide feedback. The default * implementation beeps. */ protected void invalidEdit() { UIManager.getLookAndFeel().provideErrorFeedback(JFormattedTextField.this); } /** * Processes any input method events, such as * <code>InputMethodEvent.INPUT_METHOD_TEXT_CHANGED</code> or * <code>InputMethodEvent.CARET_POSITION_CHANGED</code>. * * @param e the <code>InputMethodEvent</code> * @see InputMethodEvent */ protected void processInputMethodEvent(InputMethodEvent e) { AttributedCharacterIterator text = e.getText(); int commitCount = e.getCommittedCharacterCount(); // Keep track of the composed text if (text != null) { int begin = text.getBeginIndex(); int end = text.getEndIndex(); composedTextExists = ((end - begin) > commitCount); } else { composedTextExists = false; } super.processInputMethodEvent(e); } /** * Processes any focus events, such as * <code>FocusEvent.FOCUS_GAINED</code> or * <code>FocusEvent.FOCUS_LOST</code>. * * @param e the <code>FocusEvent</code> * @see FocusEvent */ protected void processFocusEvent(FocusEvent e) { super.processFocusEvent(e); // ignore temporary focus event if (e.isTemporary()) { return; } if (isEdited() && e.getID() == FocusEvent.FOCUS_LOST) { InputContext ic = getInputContext(); if (focusLostHandler == null) { focusLostHandler = new FocusLostHandler(); } // if there is a composed text, process it first if ((ic != null) && composedTextExists) { ic.endComposition(); EventQueue.invokeLater(focusLostHandler); } else { focusLostHandler.run(); } } else if (!isEdited()) { // reformat setValue(getValue(), true, true); } } /** * FOCUS_LOST behavior implementation */ private class FocusLostHandler implements Runnable, Serializable { public void run() { int fb = JFormattedTextField.this.getFocusLostBehavior(); if (fb == JFormattedTextField.COMMIT || fb == JFormattedTextField.COMMIT_OR_REVERT) { try { JFormattedTextField.this.commitEdit(); // Give it a chance to reformat. JFormattedTextField.this.setValue( JFormattedTextField.this.getValue(), true, true); } catch (ParseException pe) { if (fb == JFormattedTextField.this.COMMIT_OR_REVERT) { JFormattedTextField.this.setValue( JFormattedTextField.this.getValue(), true, true); } } } else if (fb == JFormattedTextField.REVERT) { JFormattedTextField.this.setValue( JFormattedTextField.this.getValue(), true, true); } } } /** * Fetches the command list for the editor. This is * the list of commands supported by the plugged-in UI * augmented by the collection of commands that the * editor itself supports. These are useful for binding * to events, such as in a keymap. * * @return the command list */ public Action[] getActions() { return TextAction.augmentList(super.getActions(), defaultActions); } /** * Gets the class ID for a UI. * * @return the string "FormattedTextFieldUI" * @see JComponent#getUIClassID */ public String getUIClassID() { return uiClassID; } /** * Associates the editor with a text document. * The currently registered factory is used to build a view for * the document, which gets displayed by the editor after revalidation. * A PropertyChange event ("document") is propagated to each listener. * * @param doc the document to display/edit * @see #getDocument * @beaninfo * description: the text document model * bound: true * expert: true */ public void setDocument(Document doc) { if (documentListener != null && getDocument() != null) { getDocument().removeDocumentListener(documentListener); } super.setDocument(doc); if (documentListener == null) { documentListener = new DocumentHandler(); } doc.addDocumentListener(documentListener); } /* * See readObject and writeObject in JComponent for more * information about serialization in Swing. * * @param s Stream to write to */ private void writeObject(ObjectOutputStream s) throws IOException { s.defaultWriteObject(); if (getUIClassID().equals(uiClassID)) { byte count = JComponent.getWriteObjCounter(this); JComponent.setWriteObjCounter(this, --count); if (count == 0 && ui != null) { ui.installUI(this); } } } /** * Resets the Actions that come from the TextFormatter to * <code>actions</code>. */ private void setFormatterActions(Action[] actions) { if (actions == null) { if (textFormatterActionMap != null) { textFormatterActionMap.clear(); } } else { if (textFormatterActionMap == null) { ActionMap map = getActionMap(); textFormatterActionMap = new ActionMap(); while (map != null) { ActionMap parent = map.getParent(); if (parent instanceof UIResource || parent == null) { map.setParent(textFormatterActionMap); textFormatterActionMap.setParent(parent); break; } map = parent; } } for (int counter = actions.length - 1; counter >= 0; counter--) { Object key = actions[counter].getValue(Action.NAME); if (key != null) { textFormatterActionMap.put(key, actions[counter]); } } } } /** * Does the setting of the value. If <code>createFormat</code> is true, * this will also obtain a new <code>AbstractFormatter</code> from the * current factory. The property change event will be fired if * <code>firePC</code> is true. */ private void setValue(Object value, boolean createFormat, boolean firePC) { Object oldValue = this.value; this.value = value; if (createFormat) { AbstractFormatterFactory factory = getFormatterFactory(); AbstractFormatter atf; if (factory != null) { atf = factory.getFormatter(this); } else { atf = null; } setFormatter(atf); } else { // Assumed to be valid setEditValid(true); } setEdited(false); if (firePC) { firePropertyChange("value", oldValue, value); } } /** * Sets the edited state of the receiver. */ private void setEdited(boolean edited) { this.edited = edited; } /** * Returns true if the receiver has been edited. */ private boolean isEdited() { return edited; } /** * Returns an AbstractFormatterFactory suitable for the passed in * Object type. */ private AbstractFormatterFactory getDefaultFormatterFactory(Object type) { if (type instanceof DateFormat) { return new DefaultFormatterFactory(new DateFormatter ((DateFormat)type)); } if (type instanceof NumberFormat) { return new DefaultFormatterFactory(new NumberFormatter( (NumberFormat)type)); } if (type instanceof Format) { return new DefaultFormatterFactory(new InternationalFormatter( (Format)type)); } if (type instanceof Date) { return new DefaultFormatterFactory(new DateFormatter()); } if (type instanceof Number) { AbstractFormatter displayFormatter = new NumberFormatter(); ((NumberFormatter)displayFormatter).setValueClass(type.getClass()); AbstractFormatter editFormatter = new NumberFormatter( new DecimalFormat("#.#")); ((NumberFormatter)editFormatter).setValueClass(type.getClass()); return new DefaultFormatterFactory(displayFormatter, displayFormatter,editFormatter); } return new DefaultFormatterFactory(new DefaultFormatter()); } /** * Instances of <code>AbstractFormatterFactory</code> are used by * <code>JFormattedTextField</code> to obtain instances of * <code>AbstractFormatter</code> which in turn are used to format values. * <code>AbstractFormatterFactory</code> can return different * <code>AbstractFormatter</code>s based on the state of the * <code>JFormattedTextField</code>, perhaps returning different * <code>AbstractFormatter</code>s when the * <code>JFormattedTextField</code> has focus vs when it * doesn't have focus. * @since 1.4 */ public static abstract class AbstractFormatterFactory { /** * Returns an <code>AbstractFormatter</code> that can handle formatting * of the passed in <code>JFormattedTextField</code>. * * @param tf JFormattedTextField requesting AbstractFormatter * @return AbstractFormatter to handle formatting duties, a null * return value implies the JFormattedTextField should behave * like a normal JTextField */ public abstract AbstractFormatter getFormatter(JFormattedTextField tf); } /** * Instances of <code>AbstractFormatter</code> are used by * <code>JFormattedTextField</code> to handle the conversion both * from an Object to a String, and back from a String to an Object. * <code>AbstractFormatter</code>s can also enforce editing policies, * or navigation policies, or manipulate the * <code>JFormattedTextField</code> in any way it sees fit to * enforce the desired policy. * <p> * An <code>AbstractFormatter</code> can only be active in * one <code>JFormattedTextField</code> at a time. * <code>JFormattedTextField</code> invokes * <code>install</code> when it is ready to use it followed * by <code>uninstall</code> when done. Subclasses * that wish to install additional state should override * <code>install</code> and message super appropriately. * <p> * Subclasses must override the conversion methods * <code>stringToValue</code> and <code>valueToString</code>. Optionally * they can override <code>getActions</code>, * <code>getNavigationFilter</code> and <code>getDocumentFilter</code> * to restrict the <code>JFormattedTextField</code> in a particular * way. * <p> * Subclasses that allow the <code>JFormattedTextField</code> to be in * a temporarily invalid state should invoke <code>setEditValid</code> * at the appropriate times. * @since 1.4 */ public static abstract class AbstractFormatter implements Serializable { private JFormattedTextField ftf; /** * Installs the <code>AbstractFormatter</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. You will only need to invoke this yourself if * you are subclassing <code>JFormattedTextField</code> and * installing/uninstalling <code>AbstractFormatter</code> at a * different time than <code>JFormattedTextField</code> does. * * @param ftf JFormattedTextField to format for, may be null indicating * uninstall from current JFormattedTextField. */ public void install(JFormattedTextField ftf) { if (this.ftf != null) { uninstall(); } this.ftf = ftf; if (ftf != null) { try { ftf.setText(valueToString(ftf.getValue())); } catch (ParseException pe) { ftf.setText(""); setEditValid(false); } installDocumentFilter(getDocumentFilter()); ftf.setNavigationFilter(getNavigationFilter()); ftf.setFormatterActions(getActions()); } } /** * Uninstalls any state the <code>AbstractFormatter</code> may have * installed on the <code>JFormattedTextField</code>. This resets the * <code>DocumentFilter</code>, <code>NavigationFilter</code> * and additional <code>Action</code>s installed on the * <code>JFormattedTextField</code>. */ public void uninstall() { if (this.ftf != null) { installDocumentFilter(null); this.ftf.setNavigationFilter(null); this.ftf.setFormatterActions(null); } } /** * Parses <code>text</code> returning an arbitrary Object. Some * formatters may return null. * * @throws ParseException if there is an error in the conversion * @param text String to convert * @return Object representation of text */ public abstract Object stringToValue(String text) throws ParseException; /** * Returns the string value to display for <code>value</code>. * * @throws ParseException if there is an error in the conversion * @param value Value to convert * @return String representation of value */ public abstract String valueToString(Object value) throws ParseException; /** * Returns the current <code>JFormattedTextField</code> the * <code>AbstractFormatter</code> is installed on. * * @return JFormattedTextField formatting for. */ protected JFormattedTextField getFormattedTextField() { return ftf; } /** * This should be invoked when the user types an invalid character. * This forwards the call to the current JFormattedTextField. */ protected void invalidEdit() { JFormattedTextField ftf = getFormattedTextField(); if (ftf != null) { ftf.invalidEdit(); } } /** * Invoke this to update the <code>editValid</code> property of the * <code>JFormattedTextField</code>. If you an enforce a policy * such that the <code>JFormattedTextField</code> is always in a * valid state, you will never need to invoke this. * * @param valid Valid state of the JFormattedTextField */ protected void setEditValid(boolean valid) { JFormattedTextField ftf = getFormattedTextField(); if (ftf != null) { ftf.setEditValid(valid); } } /** * Subclass and override if you wish to provide a custom set of * <code>Action</code>s. <code>install</code> will install these * on the <code>JFormattedTextField</code>'s <code>ActionMap</code>. * * @return Array of Actions to install on JFormattedTextField */ protected Action[] getActions() { return null; } /** * Subclass and override if you wish to provide a * <code>DocumentFilter</code> to restrict what can be input. * <code>install</code> will install the returned value onto * the <code>JFormattedTextField</code>. * * @return DocumentFilter to restrict edits */ protected DocumentFilter getDocumentFilter() { return null; } /** * Subclass and override if you wish to provide a filter to restrict * where the user can navigate to. * <code>install</code> will install the returned value onto * the <code>JFormattedTextField</code>. * * @return NavigationFilter to restrict navigation */ protected NavigationFilter getNavigationFilter() { return null; } /** * Clones the <code>AbstractFormatter</code>. The returned instance * is not associated with a <code>JFormattedTextField</code>. * * @return Copy of the AbstractFormatter */ protected Object clone() throws CloneNotSupportedException { AbstractFormatter formatter = (AbstractFormatter)super.clone(); formatter.ftf = null; return formatter; } /** * Installs the <code>DocumentFilter</code> <code>filter</code> * onto the current <code>JFormattedTextField</code>. * * @param filter DocumentFilter to install on the Document. */ private void installDocumentFilter(DocumentFilter filter) { JFormattedTextField ftf = getFormattedTextField(); if (ftf != null) { Document doc = ftf.getDocument(); if (doc instanceof AbstractDocument) { ((AbstractDocument)doc).setDocumentFilter(filter); } doc.putProperty(DocumentFilter.class, null); } } } /** * Used to commit the edit. This extends JTextField.NotifyAction * so that <code>isEnabled</code> is true while a JFormattedTextField * has focus, and extends <code>actionPerformed</code> to invoke * commitEdit. */ static class CommitAction extends JTextField.NotifyAction { public void actionPerformed(ActionEvent e) { JTextComponent target = getFocusedComponent(); if (target instanceof JFormattedTextField) { // Attempt to commit the value try { ((JFormattedTextField)target).commitEdit(); } catch (ParseException pe) { ((JFormattedTextField)target).invalidEdit(); // value not committed, don't notify ActionListeners return; } } // Super behavior. super.actionPerformed(e); } public boolean isEnabled() { JTextComponent target = getFocusedComponent(); if (target instanceof JFormattedTextField) { JFormattedTextField ftf = (JFormattedTextField)target; if (!ftf.isEdited()) { return false; } return true; } return super.isEnabled(); } } /** * CancelAction will reset the value in the JFormattedTextField when * <code>actionPerformed</code> is invoked. It will only be * enabled if the focused component is an instance of * JFormattedTextField. */ private static class CancelAction extends TextAction { public CancelAction() { super("reset-field-edit"); } public void actionPerformed(ActionEvent e) { JTextComponent target = getFocusedComponent(); if (target instanceof JFormattedTextField) { JFormattedTextField ftf = (JFormattedTextField)target; ftf.setValue(ftf.getValue()); } } public boolean isEnabled() { JTextComponent target = getFocusedComponent(); if (target instanceof JFormattedTextField) { JFormattedTextField ftf = (JFormattedTextField)target; if (!ftf.isEdited()) { return false; } return true; } return super.isEnabled(); } } /** * Sets the dirty state as the document changes. */ private class DocumentHandler implements DocumentListener, Serializable { public void insertUpdate(DocumentEvent e) { setEdited(true); } public void removeUpdate(DocumentEvent e) { setEdited(true); } public void changedUpdate(DocumentEvent e) {} } }
⏎ javax/swing/JFormattedTextField.java
Or download all of them as a single archive file:
File name: jre-rt-javax-1.8.0_191-src.zip File size: 5381005 bytes Release date: 2018-10-28 Download
⇒ JRE 8 rt.jar - org.* Package Source Code
2024-03-15, 213105👍, 6💬
Popular Posts:
JAX-RPC is an API for building Web services and clients that used remote procedure calls (RPC) and X...
JDK 11 java.rmi.jmod is the JMOD file for JDK 11 RMI (Remote Method Invocation) module. JDK 11 RMI m...
Apache Axis2 is the core engine for Web services. It is a complete re-design and re-write of the wid...
JDK 11 jdk.internal.le.jmod is the JMOD file for JDK 11 Internal Line Editing module. JDK 11 Interna...
The Apache FontBox library is an open source Java tool to obtain low level information from font fil...