Java tutorial
/* * Copyright (c) 1997, 2018, 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; import javax.swing.text.*; import javax.accessibility.*; import java.beans.JavaBean; import java.beans.BeanProperty; import java.io.ObjectOutputStream; import java.io.IOException; import java.util.Arrays; /** * <code>JPasswordField</code> is a lightweight component that allows * the editing of a single line of text where the view indicates * something was typed, but does not show the original characters. * You can find further information and examples in * <a href="https://docs.oracle.com/javase/tutorial/uiswing/components/textfield.html">How to Use Text Fields</a>, * a section in <em>The Java Tutorial.</em> * <p> * <code>JPasswordField</code> is intended * to be source-compatible with <code>java.awt.TextField</code> * used with <code>echoChar</code> set. It is provided separately * to make it easier to safely change the UI for the * <code>JTextField</code> without affecting password entries. * <p> * <strong>NOTE:</strong> * By default, JPasswordField disables input methods; otherwise, input * characters could be visible while they were composed using input methods. * If an application needs the input methods support, please use the * inherited method, <code>enableInputMethods(true)</code>. * <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}. * * @author Timothy Prinzing * @since 1.2 */ @JavaBean(description = "Allows the editing of a line of text but doesn't show the characters.") @SwingContainer(false) @SuppressWarnings("serial") // Same-version serialization only public class JPasswordField extends JTextField { /** * Constructs a new <code>JPasswordField</code>, * with a default document, <code>null</code> starting * text string, and 0 column width. */ public JPasswordField() { this(null, null, 0); } /** * Constructs a new <code>JPasswordField</code> initialized * with the specified text. The document model is set to the * default, and the number of columns to 0. * * @param text the text to be displayed, <code>null</code> if none */ public JPasswordField(String text) { this(null, text, 0); } /** * Constructs a new empty <code>JPasswordField</code> with the specified * number of columns. A default model is created, and the initial string * is set to <code>null</code>. * * @param columns the number of columns >= 0 */ public JPasswordField(int columns) { this(null, null, columns); } /** * Constructs a new <code>JPasswordField</code> initialized with * the specified text and columns. The document model is set to * the default. * * @param text the text to be displayed, <code>null</code> if none * @param columns the number of columns >= 0 */ public JPasswordField(String text, int columns) { this(null, text, columns); } /** * Constructs a new <code>JPasswordField</code> that uses the * given text storage model and the given number of columns. * This is the constructor through which the other constructors feed. * The echo character is set to '*', but may be changed by the current * Look and Feel. If the document model is * <code>null</code>, a default one will be created. * * @param doc the text storage to use * @param txt the text to be displayed, <code>null</code> if none * @param columns the number of columns to use to calculate * the preferred width >= 0; if columns is set to zero, the * preferred width will be whatever naturally results from * the component implementation */ public JPasswordField(Document doc, String txt, int columns) { super(doc, txt, columns); // We could either leave this on, which wouldn't be secure, // or obscure the composted text, which essentially makes displaying // it useless. Therefore, we turn off input methods. enableInputMethods(false); } /** * Returns the name of the L&F class that renders this component. * * @return the string "PasswordFieldUI" * @see JComponent#getUIClassID * @see UIDefaults#getUI */ @BeanProperty(bound = false) public String getUIClassID() { return uiClassID; } /** * {@inheritDoc} * @since 1.6 */ public void updateUI() { if (!echoCharSet) { echoChar = '*'; } super.updateUI(); } /** * Returns the character to be used for echoing. The default is '*'. * The default may be different depending on the currently running Look * and Feel. For example, Metal/Ocean's default is a bullet character. * * @return the echo character, 0 if unset * @see #setEchoChar * @see #echoCharIsSet */ public char getEchoChar() { return echoChar; } /** * Sets the echo character for this <code>JPasswordField</code>. * Note that this is largely a suggestion, since the * view that gets installed can use whatever graphic techniques * it desires to represent the field. Setting a value of 0 indicates * that you wish to see the text as it is typed, similar to * the behavior of a standard <code>JTextField</code>. * * @param c the echo character to display * @see #echoCharIsSet * @see #getEchoChar */ @BeanProperty(bound = false, visualUpdate = true, description = "character to display in place of the real characters") public void setEchoChar(char c) { echoChar = c; echoCharSet = true; repaint(); revalidate(); } /** * Returns true if this <code>JPasswordField</code> has a character * set for echoing. A character is considered to be set if the echo * character is not 0. * * @return true if a character is set for echoing * @see #setEchoChar * @see #getEchoChar */ public boolean echoCharIsSet() { return echoChar != 0; } // --- JTextComponent methods ---------------------------------- /** * Invokes <code>provideErrorFeedback</code> on the current * look and feel, which typically initiates an error beep. * The normal behavior of transferring the * currently selected range in the associated text model * to the system clipboard, and removing the contents from * the model, is not acceptable for a password field. */ public void cut() { if (getClientProperty("JPasswordField.cutCopyAllowed") != Boolean.TRUE) { UIManager.getLookAndFeel().provideErrorFeedback(this); } else { super.cut(); } } /** * Invokes <code>provideErrorFeedback</code> on the current * look and feel, which typically initiates an error beep. * The normal behavior of transferring the * currently selected range in the associated text model * to the system clipboard, and leaving the contents from * the model, is not acceptable for a password field. */ public void copy() { if (getClientProperty("JPasswordField.cutCopyAllowed") != Boolean.TRUE) { UIManager.getLookAndFeel().provideErrorFeedback(this); } else { super.copy(); } } /** * Returns the text contained in this <code>TextComponent</code>. * If the underlying document is <code>null</code>, will give a * <code>NullPointerException</code>. * <p> * For security reasons, this method is deprecated. Use the <code>* getPassword</code> method instead. * @deprecated As of Java 2 platform v1.2, * replaced by <code>getPassword</code>. * @return the text */ @Deprecated public String getText() { return super.getText(); } /** * Fetches a portion of the text represented by the * component. Returns an empty string if length is 0. * <p> * For security reasons, this method is deprecated. Use the * <code>getPassword</code> method instead. * @deprecated As of Java 2 platform v1.2, * replaced by <code>getPassword</code>. * @param offs the offset >= 0 * @param len the length >= 0 * @return the text * @exception BadLocationException if the offset or length are invalid */ @Deprecated public String getText(int offs, int len) throws BadLocationException { return super.getText(offs, len); } /** * Returns the text contained in this <code>TextComponent</code>. * If the underlying document is <code>null</code>, will give a * <code>NullPointerException</code>. For stronger * security, it is recommended that the returned character array be * cleared after use by setting each character to zero. * * @return the text */ @BeanProperty(bound = false) public char[] getPassword() { Document doc = getDocument(); Segment txt = new Segment(); try { doc.getText(0, doc.getLength(), txt); // use the non-String API } catch (BadLocationException e) { return null; } char[] retValue = new char[txt.count]; System.arraycopy(txt.array, txt.offset, retValue, 0, txt.count); return retValue; } /** * See readObject() and writeObject() in JComponent for more * information about serialization in Swing. */ 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); } } } // --- variables ----------------------------------------------- /** * @see #getUIClassID * @see #readObject */ private static final String uiClassID = "PasswordFieldUI"; private char echoChar; private boolean echoCharSet = false; /** * Returns a string representation of this <code>JPasswordField</code>. * This method is intended to be used only for debugging purposes, and the * content and format of the returned string may vary between * implementations. The returned string may be empty but may not * be <code>null</code>. * * @return a string representation of this <code>JPasswordField</code> */ protected String paramString() { return super.paramString() + ",echoChar=" + echoChar; } /** * This method is a hack to get around the fact that we cannot * directly override setUIProperty because part of the inheritance hierarchy * goes outside of the javax.swing package, and therefore calling a package * private method isn't allowed. This method should return true if the property * was handled, and false otherwise. */ boolean customSetUIProperty(String propertyName, Object value) { if (propertyName == "echoChar") { if (!echoCharSet) { setEchoChar((Character) value); echoCharSet = false; } return true; } return false; } ///////////////// // Accessibility support //////////////// /** * Returns the <code>AccessibleContext</code> associated with this * <code>JPasswordField</code>. For password fields, the * <code>AccessibleContext</code> takes the form of an * <code>AccessibleJPasswordField</code>. * A new <code>AccessibleJPasswordField</code> instance is created * if necessary. * * @return an <code>AccessibleJPasswordField</code> that serves as the * <code>AccessibleContext</code> of this * <code>JPasswordField</code> */ @BeanProperty(bound = false) public AccessibleContext getAccessibleContext() { if (accessibleContext == null) { accessibleContext = new AccessibleJPasswordField(); } return accessibleContext; } /** * This class implements accessibility support for the * <code>JPasswordField</code> class. It provides an implementation of the * Java Accessibility API appropriate to password field user-interface * elements. * <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}. */ protected class AccessibleJPasswordField extends AccessibleJTextField { /** * Gets the role of this object. * * @return an instance of AccessibleRole describing the role of the * object (AccessibleRole.PASSWORD_TEXT) * @see AccessibleRole */ public AccessibleRole getAccessibleRole() { return AccessibleRole.PASSWORD_TEXT; } /** * Gets the <code>AccessibleText</code> for the <code>JPasswordField</code>. * The returned object also implements the * <code>AccessibleExtendedText</code> interface. * * @return <code>AccessibleText</code> for the JPasswordField * @see javax.accessibility.AccessibleContext * @see javax.accessibility.AccessibleContext#getAccessibleText * @see javax.accessibility.AccessibleText * @see javax.accessibility.AccessibleExtendedText * * @since 1.6 */ public AccessibleText getAccessibleText() { return this; } /* * Returns a String filled with password echo characters. The String * contains one echo character for each character (including whitespace) * that the user entered in the JPasswordField. */ private String getEchoString(String str) { if (str == null) { return null; } char[] buffer = new char[str.length()]; Arrays.fill(buffer, getEchoChar()); return new String(buffer); } /** * Returns the <code>String</code> at a given <code>index</code>. * * @param part the <code>CHARACTER</code>, <code>WORD</code> or * <code>SENTENCE</code> to retrieve * @param index an index within the text * @return a <code>String</code> if <code>part</code> and * <code>index</code> are valid. * Otherwise, <code>null</code> is returned * * @see javax.accessibility.AccessibleText#CHARACTER * @see javax.accessibility.AccessibleText#WORD * @see javax.accessibility.AccessibleText#SENTENCE * * @since 1.6 */ public String getAtIndex(int part, int index) { String str = null; if (part == AccessibleText.CHARACTER) { str = super.getAtIndex(part, index); } else { // Treat the text displayed in the JPasswordField // as one word and sentence. char[] password = getPassword(); if (password == null || index < 0 || index >= password.length) { return null; } str = new String(password); } return getEchoString(str); } /** * Returns the <code>String</code> after a given <code>index</code>. * * @param part the <code>CHARACTER</code>, <code>WORD</code> or * <code>SENTENCE</code> to retrieve * @param index an index within the text * @return a <code>String</code> if <code>part</code> and * <code>index</code> are valid. * Otherwise, <code>null</code> is returned * * @see javax.accessibility.AccessibleText#CHARACTER * @see javax.accessibility.AccessibleText#WORD * @see javax.accessibility.AccessibleText#SENTENCE * * @since 1.6 */ public String getAfterIndex(int part, int index) { if (part == AccessibleText.CHARACTER) { String str = super.getAfterIndex(part, index); return getEchoString(str); } else { // There is no word or sentence after the text // displayed in the JPasswordField. return null; } } /** * Returns the <code>String</code> before a given <code>index</code>. * * @param part the <code>CHARACTER</code>, <code>WORD</code> or * <code>SENTENCE</code> to retrieve * @param index an index within the text * @return a <code>String</code> if <code>part</code> and * <code>index</code> are valid. * Otherwise, <code>null</code> is returned * * @see javax.accessibility.AccessibleText#CHARACTER * @see javax.accessibility.AccessibleText#WORD * @see javax.accessibility.AccessibleText#SENTENCE * * @since 1.6 */ public String getBeforeIndex(int part, int index) { if (part == AccessibleText.CHARACTER) { String str = super.getBeforeIndex(part, index); return getEchoString(str); } else { // There is no word or sentence before the text // displayed in the JPasswordField. return null; } } /** * Returns the text between two <code>indices</code>. * * @param startIndex the start index in the text * @param endIndex the end index in the text * @return the text string if the indices are valid. * Otherwise, <code>null</code> is returned * * @since 1.6 */ public String getTextRange(int startIndex, int endIndex) { String str = super.getTextRange(startIndex, endIndex); return getEchoString(str); } /** * Returns the <code>AccessibleTextSequence</code> at a given * <code>index</code>. * * @param part the <code>CHARACTER</code>, <code>WORD</code>, * <code>SENTENCE</code>, <code>LINE</code> or <code>ATTRIBUTE_RUN</code> to * retrieve * @param index an index within the text * @return an <code>AccessibleTextSequence</code> specifying the text if * <code>part</code> and <code>index</code> are valid. Otherwise, * <code>null</code> is returned * * @see javax.accessibility.AccessibleText#CHARACTER * @see javax.accessibility.AccessibleText#WORD * @see javax.accessibility.AccessibleText#SENTENCE * @see javax.accessibility.AccessibleExtendedText#LINE * @see javax.accessibility.AccessibleExtendedText#ATTRIBUTE_RUN * * @since 1.6 */ public AccessibleTextSequence getTextSequenceAt(int part, int index) { if (part == AccessibleText.CHARACTER) { AccessibleTextSequence seq = super.getTextSequenceAt(part, index); if (seq == null) { return null; } return new AccessibleTextSequence(seq.startIndex, seq.endIndex, getEchoString(seq.text)); } else { // Treat the text displayed in the JPasswordField // as one word, sentence, line and attribute run char[] password = getPassword(); if (password == null || index < 0 || index >= password.length) { return null; } String text = new String(password); return new AccessibleTextSequence(0, password.length - 1, getEchoString(text)); } } /** * Returns the <code>AccessibleTextSequence</code> after a given * <code>index</code>. * * @param part the <code>CHARACTER</code>, <code>WORD</code>, * <code>SENTENCE</code>, <code>LINE</code> or <code>ATTRIBUTE_RUN</code> to * retrieve * @param index an index within the text * @return an <code>AccessibleTextSequence</code> specifying the text if * <code>part</code> and <code>index</code> are valid. Otherwise, * <code>null</code> is returned * * @see javax.accessibility.AccessibleText#CHARACTER * @see javax.accessibility.AccessibleText#WORD * @see javax.accessibility.AccessibleText#SENTENCE * @see javax.accessibility.AccessibleExtendedText#LINE * @see javax.accessibility.AccessibleExtendedText#ATTRIBUTE_RUN * * @since 1.6 */ public AccessibleTextSequence getTextSequenceAfter(int part, int index) { if (part == AccessibleText.CHARACTER) { AccessibleTextSequence seq = super.getTextSequenceAfter(part, index); if (seq == null) { return null; } return new AccessibleTextSequence(seq.startIndex, seq.endIndex, getEchoString(seq.text)); } else { // There is no word, sentence, line or attribute run // after the text displayed in the JPasswordField. return null; } } /** * Returns the <code>AccessibleTextSequence</code> before a given * <code>index</code>. * * @param part the <code>CHARACTER</code>, <code>WORD</code>, * <code>SENTENCE</code>, <code>LINE</code> or <code>ATTRIBUTE_RUN</code> to * retrieve * @param index an index within the text * @return an <code>AccessibleTextSequence</code> specifying the text if * <code>part</code> and <code>index</code> are valid. Otherwise, * <code>null</code> is returned * * @see javax.accessibility.AccessibleText#CHARACTER * @see javax.accessibility.AccessibleText#WORD * @see javax.accessibility.AccessibleText#SENTENCE * @see javax.accessibility.AccessibleExtendedText#LINE * @see javax.accessibility.AccessibleExtendedText#ATTRIBUTE_RUN * * @since 1.6 */ public AccessibleTextSequence getTextSequenceBefore(int part, int index) { if (part == AccessibleText.CHARACTER) { AccessibleTextSequence seq = super.getTextSequenceBefore(part, index); if (seq == null) { return null; } return new AccessibleTextSequence(seq.startIndex, seq.endIndex, getEchoString(seq.text)); } else { // There is no word, sentence, line or attribute run // before the text displayed in the JPasswordField. return null; } } } }