JPasswordField 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
* How to Use Text Fields,
* a section in The Java Tutorial.
*
* JPasswordField is intended
* to be source-compatible with java.awt.TextField
* used with echoChar set. It is provided separately
* to make it easier to safely change the UI for the
* JTextField without affecting password entries.
*
* NOTE:
* 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, enableInputMethods(true).
*
* Warning: Swing is not thread safe. For more * information see Swing's Threading * Policy. *
* Warning:
* 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 JavaBeansTM
* has been added to the java.beans package.
* Please see {@link java.beans.XMLEncoder}.
*
* @beaninfo
* attribute: isContainer false
* description: Allows the editing of a line of text but doesn't show the characters.
*
* @author Timothy Prinzing
*/
public class JPasswordField extends JTextField {
/**
* Constructs a new JPasswordField,
* with a default document, null starting
* text string, and 0 column width.
*/
public JPasswordField() {
this(null,null,0);
}
/**
* Constructs a new JPasswordField 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, null if none
*/
public JPasswordField(String text) {
this(null, text, 0);
}
/**
* Constructs a new empty JPasswordField with the specified
* number of columns. A default model is created, and the initial string
* is set to null.
*
* @param columns the number of columns >= 0
*/
public JPasswordField(int columns) {
this(null, null, columns);
}
/**
* Constructs a new JPasswordField initialized with
* the specified text and columns. The document model is set to
* the default.
*
* @param text the text to be displayed, null if none
* @param columns the number of columns >= 0
*/
public JPasswordField(String text, int columns) {
this(null, text, columns);
}
/**
* Constructs a new JPasswordField 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
* null, a default one will be created.
*
* @param doc the text storage to use
* @param txt the text to be displayed, null 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
*/
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 JPasswordField.
* 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 JTextField.
*
* @param c the echo character to display
* @see #echoCharIsSet
* @see #getEchoChar
* @beaninfo
* description: character to display in place of the real characters
* attribute: visualUpdate true
*/
public void setEchoChar(char c) {
echoChar = c;
echoCharSet = true;
repaint();
revalidate();
}
/**
* Returns true if this JPasswordField 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 provideErrorFeedback 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 provideErrorFeedback 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 TextComponent.
* If the underlying document is null, will give a
* NullPointerException.
*
* For security reasons, this method is deprecated. Use the
* getPassword method instead.
* @deprecated As of Java 2 platform v1.2,
* replaced by getPassword.
* @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.
*
* For security reasons, this method is deprecated. Use the
* getPassword method instead.
* @deprecated As of Java 2 platform v1.2,
* replaced by getPassword.
* @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 TextComponent.
* If the underlying document is null, will give a
* NullPointerException. For stronger
* security, it is recommended that the returned character array be
* cleared after use by setting each character to zero.
*
* @return the text
*/
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 JPasswordField.
* 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 null.
*
* @return a string representation of this JPasswordField
*/
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 heirarchy
* 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 AccessibleContext associated with this
* JPasswordField. For password fields, the
* AccessibleContext takes the form of an
* AccessibleJPasswordField.
* A new AccessibleJPasswordField instance is created
* if necessary.
*
* @return an AccessibleJPasswordField that serves as the
* AccessibleContext of this
* JPasswordField
*/
public AccessibleContext getAccessibleContext() {
if (accessibleContext == null) {
accessibleContext = new AccessibleJPasswordField();
}
return accessibleContext;
}
/**
* This class implements accessibility support for the
* JPasswordField class. It provides an implementation of the
* Java Accessibility API appropriate to password field user-interface
* elements.
*
* Warning:
* 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 JavaBeansTM
* has been added to the java.beans 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 AccessibleText for the JPasswordField.
* The returned object also implements the
* AccessibleExtendedText interface.
*
* @return AccessibleText 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 String at a given index.
*
* @param part the CHARACTER, WORD or
* SENTENCE to retrieve
* @param index an index within the text
* @return a String if part and
* index are valid.
* Otherwise, null 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 String after a given index.
*
* @param part the CHARACTER, WORD or
* SENTENCE to retrieve
* @param index an index within the text
* @return a String if part and
* index are valid.
* Otherwise, null 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 String before a given index.
*
* @param part the CHARACTER, WORD or
* SENTENCE to retrieve
* @param index an index within the text
* @return a String if part and
* index are valid.
* Otherwise, null 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 indices.
*
* @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, null is returned
*
* @since 1.6
*/
public String getTextRange(int startIndex, int endIndex) {
String str = super.getTextRange(startIndex, endIndex);
return getEchoString(str);
}
/**
* Returns the AccessibleTextSequence at a given
* index.
*
* @param part the CHARACTER, WORD,
* SENTENCE, LINE or ATTRIBUTE_RUN to
* retrieve
* @param index an index within the text
* @return an AccessibleTextSequence specifying the text if
* part and index are valid. Otherwise,
* null 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 AccessibleTextSequence after a given
* index.
*
* @param part the CHARACTER, WORD,
* SENTENCE, LINE or ATTRIBUTE_RUN to
* retrieve
* @param index an index within the text
* @return an AccessibleTextSequence specifying the text if
* part and index are valid. Otherwise,
* null 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 AccessibleTextSequence before a given
* index.
*
* @param part the CHARACTER, WORD,
* SENTENCE, LINE or ATTRIBUTE_RUN to
* retrieve
* @param index an index within the text
* @return an AccessibleTextSequence specifying the text if
* part and index are valid. Otherwise,
* null 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;
}
}
}
}