This class is supposed to serve as a base class for * several kinds of buttons with similar but non-identical semantics: * toggle buttons (radio buttons and checkboxes), simple push buttons, * menu items, etc.
* *Buttons have many properties, some of which are stored in this class * while others are delegated to the button's model. The following properties * are available:
* *| Property | Stored in | Bound? |
|---|---|---|
| action | button | no |
| actionCommand | model | no |
| borderPainted | button | yes |
| contentAreaFilled | button | yes |
| disabledIcon | button | yes |
| disabledSelectedIcon | button | yes |
| displayedMnemonicIndex | button | no |
| enabled | model | no |
| focusPainted | button | yes |
| horizontalAlignment | button | yes |
| horizontalTextPosition | button | yes |
| icon | button | yes |
| iconTextGap | button | no |
| label (same as text) | model | yes |
| margin | button | yes |
| multiClickThreshold | button | no |
| pressedIcon | button | yes |
| rolloverEnabled | button | yes |
| rolloverIcon | button | yes |
| rolloverSelectedIcon | button | yes |
| selected | model | no |
| selectedIcon | button | yes |
| selectedObjects | button | no |
| text | model | yes |
| UI | button | yes |
| verticalAlignment | button | yes |
| verticalTextPosition | button | yes |
The various behavioral aspects of these properties follows:
* *true, the model will fire an ActionEvent to its
* ActionListeners, which include the button. The button will propagate
* this ActionEvent to its ActionListeners, with the ActionEvent's "source"
* property set to refer to the button, rather than the model.null.
*/
int iconTextGap;
/** The vertical alignment of the button's text and icon. */
int verticalAlignment;
/** The horizontal alignment of the button's text and icon. */
int horizontalAlignment;
/** The horizontal position of the button's text relative to its icon. */
int horizontalTextPosition;
/** The vertical position of the button's text relative to its icon. */
int verticalTextPosition;
/** Whether or not the button paints its border. */
boolean borderPainted;
/** Whether or not the button paints its focus state. */
boolean focusPainted;
/** Whether or not the button fills its content area. */
boolean contentAreaFilled;
/** Whether rollover is enabled. */
boolean rollOverEnabled;
/** The action taken when the button is clicked. */
Action action;
/** The button's current state. */
protected ButtonModel model;
/** The margin between the button's border and its label. */
Insets margin;
/**
* A hint to the look and feel class, suggesting which character in the
* button's label should be underlined when drawing the label.
*/
int mnemonicIndex;
/**
* Listener the button uses to receive ActionEvents from its model.
*/
protected ActionListener actionListener;
/**
* Listener the button uses to receive ItemEvents from its model.
*/
protected ItemListener itemListener;
/**
* Listener the button uses to receive ChangeEvents from its model.
*/
protected ChangeListener changeListener;
/**
* The event handler for ActionEvent, ItemEvent and ChangeEvent.
* This replaces the above three handlers and combines them
* into one for efficiency.
*/
private EventHandler eventHandler;
/**
* The time in milliseconds in which clicks get coalesced into a single
* ActionEvent.
*/
long multiClickThreshhold;
/**
* Listener the button uses to receive PropertyChangeEvents from its
* Action.
*/
PropertyChangeListener actionPropertyChangeListener;
/** ChangeEvent that is fired to button's ChangeEventListeners */
protected ChangeEvent changeEvent = new ChangeEvent(this);
/**
* Indicates if the borderPainted property has been set by a client
* program or by the UI.
*
* @see #setUIProperty(String, Object)
* @see LookAndFeel#installProperty(JComponent, String, Object)
*/
private boolean clientBorderPaintedSet = false;
/**
* Indicates if the rolloverEnabled property has been set by a client
* program or by the UI.
*
* @see #setUIProperty(String, Object)
* @see LookAndFeel#installProperty(JComponent, String, Object)
*/
private boolean clientRolloverEnabledSet = false;
/**
* Indicates if the iconTextGap property has been set by a client
* program or by the UI.
*
* @see #setUIProperty(String, Object)
* @see LookAndFeel#installProperty(JComponent, String, Object)
*/
private boolean clientIconTextGapSet = false;
/**
* Indicates if the contentAreaFilled property has been set by a client
* program or by the UI.
*
* @see #setUIProperty(String, Object)
* @see LookAndFeel#installProperty(JComponent, String, Object)
*/
private boolean clientContentAreaFilledSet = false;
/**
* Fired in a PropertyChangeEvent when the "borderPainted" property changes.
*/
public static final String BORDER_PAINTED_CHANGED_PROPERTY = "borderPainted";
/**
* Fired in a PropertyChangeEvent when the "contentAreaFilled" property
* changes.
*/
public static final String CONTENT_AREA_FILLED_CHANGED_PROPERTY =
"contentAreaFilled";
/**
* Fired in a PropertyChangeEvent when the "disabledIcon" property changes.
*/
public static final String DISABLED_ICON_CHANGED_PROPERTY = "disabledIcon";
/**
* Fired in a PropertyChangeEvent when the "disabledSelectedIcon" property
* changes.
*/
public static final String DISABLED_SELECTED_ICON_CHANGED_PROPERTY =
"disabledSelectedIcon";
/**
* Fired in a PropertyChangeEvent when the "focusPainted" property changes.
*/
public static final String FOCUS_PAINTED_CHANGED_PROPERTY = "focusPainted";
/**
* Fired in a PropertyChangeEvent when the "horizontalAlignment" property
* changes.
*/
public static final String HORIZONTAL_ALIGNMENT_CHANGED_PROPERTY =
"horizontalAlignment";
/**
* Fired in a PropertyChangeEvent when the "horizontalTextPosition" property
* changes.
*/
public static final String HORIZONTAL_TEXT_POSITION_CHANGED_PROPERTY =
"horizontalTextPosition";
/**
* Fired in a PropertyChangeEvent when the "icon" property changes. */
public static final String ICON_CHANGED_PROPERTY = "icon";
/** Fired in a PropertyChangeEvent when the "margin" property changes. */
public static final String MARGIN_CHANGED_PROPERTY = "margin";
/** Fired in a PropertyChangeEvent when the "mnemonic" property changes. */
public static final String MNEMONIC_CHANGED_PROPERTY = "mnemonic";
/** Fired in a PropertyChangeEvent when the "model" property changes. */
public static final String MODEL_CHANGED_PROPERTY = "model";
/** Fired in a PropertyChangeEvent when the "pressedIcon" property changes. */
public static final String PRESSED_ICON_CHANGED_PROPERTY = "pressedIcon";
/**
* Fired in a PropertyChangeEvent when the "rolloverEnabled" property
* changes.
*/
public static final String ROLLOVER_ENABLED_CHANGED_PROPERTY =
"rolloverEnabled";
/**
* Fired in a PropertyChangeEvent when the "rolloverIcon" property changes.
*/
public static final String ROLLOVER_ICON_CHANGED_PROPERTY = "rolloverIcon";
/**
* Fired in a PropertyChangeEvent when the "rolloverSelectedIcon" property
* changes.
*/
public static final String ROLLOVER_SELECTED_ICON_CHANGED_PROPERTY =
"rolloverSelectedIcon";
/**
* Fired in a PropertyChangeEvent when the "selectedIcon" property changes.
*/
public static final String SELECTED_ICON_CHANGED_PROPERTY = "selectedIcon";
/** Fired in a PropertyChangeEvent when the "text" property changes. */
public static final String TEXT_CHANGED_PROPERTY = "text";
/**
* Fired in a PropertyChangeEvent when the "verticalAlignment" property
* changes.
*/
public static final String VERTICAL_ALIGNMENT_CHANGED_PROPERTY =
"verticalAlignment";
/**
* Fired in a PropertyChangeEvent when the "verticalTextPosition" property
* changes.
*/
public static final String VERTICAL_TEXT_POSITION_CHANGED_PROPERTY =
"verticalTextPosition";
/**
* A Java Accessibility extension of the AbstractButton.
*/
protected abstract class AccessibleAbstractButton
extends AccessibleJComponent implements AccessibleAction, AccessibleValue,
AccessibleText
{
private static final long serialVersionUID = -5673062525319836790L;
protected AccessibleAbstractButton()
{
// Nothing to do here yet.
}
/**
* Returns the accessible state set of this object. In addition to the
* superclass's states, the AccessibleAbstractButton
* supports the following states: {@link AccessibleState#ARMED},
* {@link AccessibleState#FOCUSED}, {@link AccessibleState#PRESSED} and
* {@link AccessibleState#CHECKED}.
*
* @return the current state of this accessible object
*/
public AccessibleStateSet getAccessibleStateSet()
{
AccessibleStateSet state = super.getAccessibleStateSet();
if (getModel().isArmed())
state.add(AccessibleState.ARMED);
if (getModel().isPressed())
state.add(AccessibleState.PRESSED);
if (isSelected())
state.add(AccessibleState.CHECKED);
return state;
}
/**
* Returns the accessible name for the button.
*/
public String getAccessibleName()
{
String result = super.getAccessibleName();
if (result == null)
result = text;
return result;
}
/**
* Returns the accessible icons of this object. If the AbstractButton's
* icon is an Accessible, and it's AccessibleContext is an AccessibleIcon,
* then this AccessibleIcon is returned, otherwise null.
*
* @return the accessible icons of this object, or null if
* there is no accessible icon
*/
public AccessibleIcon[] getAccessibleIcon()
{
AccessibleIcon[] ret = null;
Icon icon = getIcon();
if (icon instanceof Accessible)
{
AccessibleContext ctx = ((Accessible) icon).getAccessibleContext();
if (ctx instanceof AccessibleIcon)
{
ret = new AccessibleIcon[]{ (AccessibleIcon) ctx };
}
}
return ret;
}
/**
* Returns the accessible relations of this AccessibleAbstractButton.
* If the AbstractButton is part of a ButtonGroup, then all the buttons
* in this button group are added as targets in a MEMBER_OF relation,
* otherwise an empty relation set is returned (from super).
*
* @return the accessible relations of this AccessibleAbstractButton
*/
public AccessibleRelationSet getAccessibleRelationSet()
{
AccessibleRelationSet relations = super.getAccessibleRelationSet();
ButtonModel model = getModel();
if (model instanceof DefaultButtonModel)
{
ButtonGroup group = ((DefaultButtonModel) model).getGroup();
if (group != null)
{
Object[] target = new Object[group.getButtonCount()];
Enumeration els = group.getElements();
for (int index = 0; els.hasMoreElements(); ++index)
{
target[index] = els.nextElement();
}
AccessibleRelation rel =
new AccessibleRelation(AccessibleRelation.MEMBER_OF);
rel.setTarget(target);
relations.add(rel);
}
}
return relations;
}
/**
* Returns the accessible action associated with this object. For buttons,
* this will be this.
*
* @return this
*/
public AccessibleAction getAccessibleAction()
{
return this;
}
/**
* Returns the accessible value of this AccessibleAbstractButton, which
* is always this.
*
* @return the accessible value of this AccessibleAbstractButton, which
* is always this
*/
public AccessibleValue getAccessibleValue()
{
return this;
}
/**
* Returns the number of accessible actions that are supported by this
* object. Buttons support one action by default ('press button'), so this
* method always returns 1.
*
* @return 1, the number of supported accessible actions
*/
public int getAccessibleActionCount()
{
return 1;
}
/**
* Returns a description for the action with the specified index or
* null if such action does not exist.
*
* @param actionIndex the zero based index to the actions
*
* @return a description for the action with the specified index or
* null if such action does not exist
*/
public String getAccessibleActionDescription(int actionIndex)
{
String descr = null;
if (actionIndex == 0)
{
// FIXME: Supply localized descriptions in the UIDefaults.
descr = UIManager.getString("AbstractButton.clickText");
}
return descr;
}
/**
* Performs the acccessible action with the specified index on this object.
* Since buttons have only one action by default (which is to press the
* button), this method performs a 'press button' when the specified index
* is 0 and nothing otherwise.
*
* @param actionIndex a zero based index into the actions of this button
*
* @return true if the specified action has been performed
* successfully, false otherwise
*/
public boolean doAccessibleAction(int actionIndex)
{
boolean retVal = false;
if (actionIndex == 0)
{
doClick();
retVal = true;
}
return retVal;
}
/**
* Returns the current value of this object as a number. This
* implementation returns an Integer(1) if the button is
* selected, Integer(0) if the button is not selected.
*
* @return the current value of this object as a number
*/
public Number getCurrentAccessibleValue()
{
Integer retVal;
if (isSelected())
retVal = new Integer(1);
else
retVal = new Integer(0);
return retVal;
}
/**
* Sets the current accessible value as object. If the specified number
* is 0 the button will be deselected, otherwise the button will
* be selected.
*
* @param value 0 for deselected button, other for selected button
*
* @return true if the value has been set, false
* otherwise
*/
public boolean setCurrentAccessibleValue(Number value)
{
boolean retVal = false;
if (value != null)
{
if (value.intValue() == 0)
setSelected(false);
else
setSelected(true);
retVal = true;
}
return retVal;
}
/**
* Returns the minimum accessible value for the AccessibleAbstractButton,
* which is 0.
*
* @return the minimimum accessible value for the AccessibleAbstractButton,
* which is 0
*/
public Number getMinimumAccessibleValue()
{
return new Integer(0);
}
/**
* Returns the maximum accessible value for the AccessibleAbstractButton,
* which is 1.
*
* @return the maximum accessible value for the AccessibleAbstractButton,
* which is 1
*/
public Number getMaximumAccessibleValue()
{
return new Integer(1);
}
/**
* Returns the accessible text for this AccessibleAbstractButton. This
* will be null if the button has a non-HTML label, otherwise
* this.
*
* @return the accessible text for this AccessibleAbstractButton
*/
public AccessibleText getAccessibleText()
{
AccessibleText accessibleText = null;
if (getClientProperty(BasicHTML.propertyKey) != null)
accessibleText = this;
return accessibleText;
}
/**
* Returns the index of the label's character at the specified point,
* relative to the local bounds of the button. This only works for
* HTML labels.
*
* @param p the point, relative to the buttons local bounds
*
* @return the index of the label's character at the specified point
*/
public int getIndexAtPoint(Point p)
{
int index = -1;
View view = (View) getClientProperty(BasicHTML.propertyKey);
if (view != null)
{
Rectangle shape = new Rectangle(0, 0, getWidth(), getHeight());
index = view.viewToModel(p.x, p.y, shape, new Position.Bias[1]);
}
return index;
}
/**
* Returns the bounds of the character at the specified index of the
* button's label. This will only work for HTML labels.
*
* @param i the index of the character of the label
*
* @return the bounds of the character at the specified index of the
* button's label
*/
public Rectangle getCharacterBounds(int i)
{
Rectangle rect = null;
View view = (View) getClientProperty(BasicHTML.propertyKey);
if (view != null)
{
Rectangle shape = new Rectangle(0, 0, getWidth(), getHeight());
try
{
Shape s = view.modelToView(i, shape, Position.Bias.Forward);
rect = s.getBounds();
}
catch (BadLocationException ex)
{
rect = null;
}
}
return rect;
}
/**
* Returns the number of characters in the button's label.
*
* @return the bounds of the character at the specified index of the
* button's label
*/
public int getCharCount()
{
int charCount;
View view = (View) getClientProperty(BasicHTML.propertyKey);
if (view != null)
{
charCount = view.getDocument().getLength();
}
else
{
charCount = getAccessibleName().length();
}
return charCount;
}
/**
* This always returns -1 since there is no caret in a button.
*
* @return -1 since there is no caret in a button
*/
public int getCaretPosition()
{
return -1;
}
/**
* Returns the character, word or sentence at the specified index. The
* part parameter determines what is returned, the character,
* word or sentence after the index.
*
* @param part one of {@link AccessibleText#CHARACTER},
* {@link AccessibleText#WORD} or
* {@link AccessibleText#SENTENCE}, specifying what is returned
* @param index the index
*
* @return the character, word or sentence after index
*/
public String getAtIndex(int part, int index)
{
String result = "";
int startIndex = -1;
int endIndex = -1;
switch(part)
{
case AccessibleText.CHARACTER:
result = String.valueOf(text.charAt(index));
break;
case AccessibleText.WORD:
startIndex = text.lastIndexOf(' ', index);
endIndex = text.indexOf(' ', startIndex + 1);
if (endIndex == -1)
endIndex = startIndex + 1;
result = text.substring(startIndex + 1, endIndex);
break;
case AccessibleText.SENTENCE:
default:
startIndex = text.lastIndexOf('.', index);
endIndex = text.indexOf('.', startIndex + 1);
if (endIndex == -1)
endIndex = startIndex + 1;
result = text.substring(startIndex + 1, endIndex);
break;
}
return result;
}
/**
* Returns the character, word or sentence after the specified index. The
* part parameter determines what is returned, the character,
* word or sentence after the index.
*
* @param part one of {@link AccessibleText#CHARACTER},
* {@link AccessibleText#WORD} or
* {@link AccessibleText#SENTENCE}, specifying what is returned
* @param index the index
*
* @return the character, word or sentence after index
*/
public String getAfterIndex(int part, int index)
{
String result = "";
int startIndex = -1;
int endIndex = -1;
switch(part)
{
case AccessibleText.CHARACTER:
result = String.valueOf(text.charAt(index + 1));
break;
case AccessibleText.WORD:
startIndex = text.indexOf(' ', index);
endIndex = text.indexOf(' ', startIndex + 1);
if (endIndex == -1)
endIndex = startIndex + 1;
result = text.substring(startIndex + 1, endIndex);
break;
case AccessibleText.SENTENCE:
default:
startIndex = text.indexOf('.', index);
endIndex = text.indexOf('.', startIndex + 1);
if (endIndex == -1)
endIndex = startIndex + 1;
result = text.substring(startIndex + 1, endIndex);
break;
}
return result;
}
/**
* Returns the character, word or sentence before the specified index. The
* part parameter determines what is returned, the character,
* word or sentence before the index.
*
* @param part one of {@link AccessibleText#CHARACTER},
* {@link AccessibleText#WORD} or
* {@link AccessibleText#SENTENCE}, specifying what is returned
* @param index the index
*
* @return the character, word or sentence before index
*/
public String getBeforeIndex(int part, int index)
{
String result = "";
int startIndex = -1;
int endIndex = -1;
switch(part)
{
case AccessibleText.CHARACTER:
result = String.valueOf(text.charAt(index - 1));
break;
case AccessibleText.WORD:
endIndex = text.lastIndexOf(' ', index);
if (endIndex == -1)
endIndex = 0;
startIndex = text.lastIndexOf(' ', endIndex - 1);
result = text.substring(startIndex + 1, endIndex);
break;
case AccessibleText.SENTENCE:
default:
endIndex = text.lastIndexOf('.', index);
if (endIndex == -1)
endIndex = 0;
startIndex = text.lastIndexOf('.', endIndex - 1);
result = text.substring(startIndex + 1, endIndex);
break;
}
return result;
}
/**
* Returns the text attribute for the character at the specified character
* index.
*
* @param i the character index
*
* @return the character attributes for the specified character or
* null if the character has no attributes
*/
public AttributeSet getCharacterAttribute(int i)
{
AttributeSet atts = null;
View view = (View) getClientProperty(BasicHTML.propertyKey);
if (view != null)
{
Document doc = view.getDocument();
if (doc instanceof StyledDocument)
{
StyledDocument sDoc = (StyledDocument) doc;
Element charEl = sDoc.getCharacterElement(i);
if (charEl != null)
atts = charEl.getAttributes();
}
}
return atts;
}
/**
* This always returns -1 since
* button labels can't be selected.
*
* @return -1, button labels can't be selected
*/
public int getSelectionStart()
{
return -1;
}
/**
* This always returns -1 since
* button labels can't be selected.
*
* @return -1, button labels can't be selected
*/
public int getSelectionEnd()
{
return -1;
}
/**
* Returns the selected text. This always returns null since
* button labels can't be selected.
*
* @return null, button labels can't be selected
*/
public String getSelectedText()
{
return null;
}
}
/**
* Creates a new AbstractButton object. Subclasses should call the following
* sequence in their constructor in order to initialize the button correctly:
* * super(); * init(text, icon); ** * The {@link #init(String, Icon)} method is not called automatically by this * constructor. * * @see #init(String, Icon) */ public AbstractButton() { horizontalAlignment = CENTER; horizontalTextPosition = TRAILING; verticalAlignment = CENTER; verticalTextPosition = CENTER; borderPainted = true; contentAreaFilled = true; focusPainted = true; setFocusable(true); setAlignmentX(CENTER_ALIGNMENT); setAlignmentY(CENTER_ALIGNMENT); setDisplayedMnemonicIndex(-1); setOpaque(true); text = ""; // testing on JRE1.5 shows that the iconTextGap default value is // hard-coded here and the 'Button.iconTextGap' setting in the // UI defaults is ignored, at least by the MetalLookAndFeel iconTextGap = 4; } /** * Get the model the button is currently using. * * @return The current model */ public ButtonModel getModel() { return model; } /** * Set the model the button is currently using. This un-registers all * listeners associated with the current model, and re-registers them * with the new model. * * @param newModel The new model */ public void setModel(ButtonModel newModel) { if (newModel == model) return; if (model != null) { model.removeActionListener(actionListener); actionListener = null; model.removeChangeListener(changeListener); changeListener = null; model.removeItemListener(itemListener); itemListener = null; } ButtonModel old = model; model = newModel; if (model != null) { actionListener = createActionListener(); model.addActionListener(actionListener); changeListener = createChangeListener(); model.addChangeListener(changeListener); itemListener = createItemListener(); model.addItemListener(itemListener); } firePropertyChange(MODEL_CHANGED_PROPERTY, old, model); revalidate(); repaint(); } protected void init(String text, Icon icon) { // If text is null, we fall back to the empty // string (which is set using AbstractButton's // constructor). // This way the behavior of the JDK is matched. if(text != null) setText(text); if (icon != null) default_icon = icon; updateUI(); } /** *
Returns the action command string for this button's model.
* *If the action command was set to null, the button's
* text (label) is returned instead.
ActionListener objects.
*
* @return an array of listeners
*
* @since 1.4
*/
public ActionListener[] getActionListeners()
{
return (ActionListener[]) listenerList.getListeners(ActionListener.class);
}
/**
* Adds an ItemListener to the button's listener list. When the button's
* model changes state (between any of ARMED, ENABLED, PRESSED, ROLLOVER
* or SELECTED) it fires an ItemEvent, and these listeners will be
* called.
*
* @param l The new listener to add
*/
public void addItemListener(ItemListener l)
{
listenerList.add(ItemListener.class, l);
}
/**
* Removes an ItemListener from the button's listener list.
*
* @param l The listener to remove
*/
public void removeItemListener(ItemListener l)
{
listenerList.remove(ItemListener.class, l);
}
/**
* Returns all added ItemListener objects.
*
* @return an array of listeners
*
* @since 1.4
*/
public ItemListener[] getItemListeners()
{
return (ItemListener[]) listenerList.getListeners(ItemListener.class);
}
/**
* Adds a ChangeListener to the button's listener list. When the button's
* model changes any of its (non-bound) properties, these listeners will be
* called.
*
* @param l The new listener to add
*/
public void addChangeListener(ChangeListener l)
{
listenerList.add(ChangeListener.class, l);
}
/**
* Removes a ChangeListener from the button's listener list.
*
* @param l The listener to remove
*/
public void removeChangeListener(ChangeListener l)
{
listenerList.remove(ChangeListener.class, l);
}
/**
* Returns all added ChangeListener objects.
*
* @return an array of listeners
*
* @since 1.4
*/
public ChangeListener[] getChangeListeners()
{
return (ChangeListener[]) listenerList.getListeners(ChangeListener.class);
}
/**
* Calls {@link ItemListener#itemStateChanged} on each ItemListener in
* the button's listener list.
*
* @param e The event signifying that the button's model changed state
*/
protected void fireItemStateChanged(ItemEvent e)
{
e.setSource(this);
ItemListener[] listeners = getItemListeners();
for (int i = 0; i < listeners.length; i++)
listeners[i].itemStateChanged(e);
}
/**
* Calls {@link ActionListener#actionPerformed} on each {@link
* ActionListener} in the button's listener list.
*
* @param e The event signifying that the button's model was clicked
*/
protected void fireActionPerformed(ActionEvent e)
{
// Dispatch a copy of the given ActionEvent in order to
// set the source and action command correctly.
ActionEvent ae = new ActionEvent(
this,
e.getID(),
getActionCommand(),
e.getWhen(),
e.getModifiers());
ActionListener[] listeners = getActionListeners();
for (int i = 0; i < listeners.length; i++)
listeners[i].actionPerformed(ae);
}
/**
* Calls {@link ChangeListener#stateChanged} on each {@link ChangeListener}
* in the button's listener list.
*/
protected void fireStateChanged()
{
ChangeListener[] listeners = getChangeListeners();
for (int i = 0; i < listeners.length; i++)
listeners[i].stateChanged(changeEvent);
}
/**
* Get the current keyboard mnemonic value. This value corresponds to a
* single key code (one of the {@link java.awt.event.KeyEvent} VK_*
* codes) and is used to activate the button when pressed in conjunction
* with the "mouseless modifier" of the button's look and feel class, and
* when focus is in one of the button's ancestors.
*
* @return The button's current keyboard mnemonic
*/
public int getMnemonic()
{
ButtonModel mod = getModel();
if (mod != null)
return mod.getMnemonic();
return -1;
}
/**
* Set the current keyboard mnemonic value. This value corresponds to a
* single key code (one of the {@link java.awt.event.KeyEvent} VK_*
* codes) and is used to activate the button when pressed in conjunction
* with the "mouseless modifier" of the button's look and feel class, and
* when focus is in one of the button's ancestors.
*
* @param mne A new mnemonic to use for the button
*/
public void setMnemonic(char mne)
{
setMnemonic((int) mne);
}
/**
* Set the current keyboard mnemonic value. This value corresponds to a
* single key code (one of the {@link java.awt.event.KeyEvent} VK_*
* codes) and is used to activate the button when pressed in conjunction
* with the "mouseless modifier" of the button's look and feel class, and
* when focus is in one of the button's ancestors.
*
* @param mne A new mnemonic to use for the button
*/
public void setMnemonic(int mne)
{
ButtonModel mod = getModel();
int old = -1;
if (mod != null)
old = mod.getMnemonic();
if (old != mne)
{
if (mod != null)
mod.setMnemonic(mne);
if (text != null && !text.equals(""))
{
// Since lower case char = upper case char for
// mnemonic, we will convert both text and mnemonic
// to upper case before checking if mnemonic character occurs
// in the menu item text.
int upperCaseMne = Character.toUpperCase((char) mne);
String upperCaseText = text.toUpperCase();
setDisplayedMnemonicIndex(upperCaseText.indexOf(upperCaseMne));
}
firePropertyChange(MNEMONIC_CHANGED_PROPERTY, old, mne);
revalidate();
repaint();
}
}
/**
* Sets the button's mnemonic index. The mnemonic index is a hint to the
* look and feel class, suggesting which character in the button's label
* should be underlined when drawing the label. If the mnemonic index is
* -1, no mnemonic will be displayed.
*
* If no mnemonic index is set, the button will choose a mnemonic index
* by default, which will be the first occurrence of the mnemonic
* character in the button's text.
*
* @param index An offset into the "text" property of the button
* @throws IllegalArgumentException If index is not within the
* range of legal offsets for the "text" property of the button.
* @since 1.4
*/
public void setDisplayedMnemonicIndex(int index)
{
if (index < -1 || (text != null && index >= text.length()))
throw new IllegalArgumentException();
mnemonicIndex = index;
}
/**
* Get the button's mnemonic index, which is an offset into the button's
* "text" property. The character specified by this offset should be
* underlined when the look and feel class draws this button.
*
* @return An index into the button's "text" property
*/
public int getDisplayedMnemonicIndex()
{
return mnemonicIndex;
}
/**
* Set the "rolloverEnabled" property. When rollover is enabled, and the
* look and feel supports it, the button will change its icon to
* rolloverIcon, when the mouse passes over it.
*
* @param r Whether or not to enable rollover icon changes
*/
public void setRolloverEnabled(boolean r)
{
clientRolloverEnabledSet = true;
if (rollOverEnabled != r)
{
rollOverEnabled = r;
firePropertyChange(ROLLOVER_ENABLED_CHANGED_PROPERTY, !r, r);
revalidate();
repaint();
}
}
/**
* Returns whether or not rollover icon changes are enabled on the
* button.
*
* @return The state of the "rolloverEnabled" property
*/
public boolean isRolloverEnabled()
{
return rollOverEnabled;
}
/**
* Set the value of the button's "selected" property. Selection is only
* meaningful for toggle-type buttons (check boxes, radio buttons).
*
* @param s New value for the property
*/
public void setSelected(boolean s)
{
ButtonModel mod = getModel();
if (mod != null)
mod.setSelected(s);
}
/**
* Get the value of the button's "selected" property. Selection is only
* meaningful for toggle-type buttons (check boxes, radio buttons).
*
* @return The value of the property
*/
public boolean isSelected()
{
ButtonModel mod = getModel();
if (mod != null)
return mod.isSelected();
return false;
}
/**
* Enables or disables the button. A button will neither be selectable
* nor preform any actions unless it is enabled.
*
* @param b Whether or not to enable the button
*/
public void setEnabled(boolean b)
{
// Do nothing if state does not change.
if (b == isEnabled())
return;
super.setEnabled(b);
setFocusable(b);
ButtonModel mod = getModel();
if (mod != null)
mod.setEnabled(b);
}
/**
* Set the horizontal alignment of the button's text and icon. The
* alignment is a numeric constant from {@link SwingConstants}. It must
* be one of: RIGHT, LEFT, CENTER,
* LEADING or TRAILING. The default is
* CENTER.
*
* @return The current horizontal alignment
*
* @see #setHorizontalAlignment(int)
*/
public int getHorizontalAlignment()
{
return horizontalAlignment;
}
/**
* Set the horizontal alignment of the button's text and icon. The
* alignment is a numeric constant from {@link SwingConstants}. It must
* be one of: RIGHT, LEFT, CENTER,
* LEADING or TRAILING. The default is
* CENTER.
*
* @param a The new horizontal alignment
* @throws IllegalArgumentException If alignment is not one of the legal
* constants.
*
* @see #getHorizontalAlignment()
*/
public void setHorizontalAlignment(int a)
{
if (horizontalAlignment == a)
return;
if (a != LEFT && a != CENTER && a != RIGHT && a != LEADING
&& a != TRAILING)
throw new IllegalArgumentException("Invalid alignment.");
int old = horizontalAlignment;
horizontalAlignment = a;
firePropertyChange(HORIZONTAL_ALIGNMENT_CHANGED_PROPERTY, old, a);
revalidate();
repaint();
}
/**
* Get the horizontal position of the button's text relative to its
* icon. The position is a numeric constant from {@link
* SwingConstants}. It must be one of: RIGHT,
* LEFT, CENTER, LEADING or
* TRAILING. The default is TRAILING.
*
* @return The current horizontal text position
*/
public int getHorizontalTextPosition()
{
return horizontalTextPosition;
}
/**
* Set the horizontal position of the button's text relative to its
* icon. The position is a numeric constant from {@link
* SwingConstants}. It must be one of: RIGHT,
* LEFT, CENTER, LEADING or
* TRAILING. The default is TRAILING.
*
* @param t The new horizontal text position
* @throws IllegalArgumentException If position is not one of the legal
* constants.
*/
public void setHorizontalTextPosition(int t)
{
if (horizontalTextPosition == t)
return;
if (t != LEFT && t != CENTER && t != RIGHT && t != LEADING
&& t != TRAILING)
throw new IllegalArgumentException("Invalid alignment.");
int old = horizontalTextPosition;
horizontalTextPosition = t;
firePropertyChange(HORIZONTAL_TEXT_POSITION_CHANGED_PROPERTY, old, t);
revalidate();
repaint();
}
/**
* Get the vertical alignment of the button's text and icon. The
* alignment is a numeric constant from {@link SwingConstants}. It must
* be one of: CENTER, TOP, or
* BOTTOM. The default is CENTER.
*
* @return The current vertical alignment
*
* @see #setVerticalAlignment(int)
*/
public int getVerticalAlignment()
{
return verticalAlignment;
}
/**
* Set the vertical alignment of the button's text and icon. The
* alignment is a numeric constant from {@link SwingConstants}. It must
* be one of: CENTER, TOP, or
* BOTTOM. The default is CENTER.
*
* @param a The new vertical alignment
* @throws IllegalArgumentException If alignment is not one of the legal
* constants.
*
* @see #getVerticalAlignment()
*/
public void setVerticalAlignment(int a)
{
if (verticalAlignment == a)
return;
if (a != TOP && a != CENTER && a != BOTTOM)
throw new IllegalArgumentException("Invalid alignment.");
int old = verticalAlignment;
verticalAlignment = a;
firePropertyChange(VERTICAL_ALIGNMENT_CHANGED_PROPERTY, old, a);
revalidate();
repaint();
}
/**
* Get the vertical position of the button's text relative to its
* icon. The alignment is a numeric constant from {@link
* SwingConstants}. It must be one of: CENTER,
* TOP, or BOTTOM. The default is
* CENTER.
*
* @return The current vertical position
*/
public int getVerticalTextPosition()
{
return verticalTextPosition;
}
/**
* Set the vertical position of the button's text relative to its
* icon. The alignment is a numeric constant from {@link
* SwingConstants}. It must be one of: CENTER,
* TOP, or BOTTOM. The default is
* CENTER.
*
* @param t The new vertical position
* @throws IllegalArgumentException If position is not one of the legal
* constants.
*/
public void setVerticalTextPosition(int t)
{
if (verticalTextPosition == t)
return;
if (t != TOP && t != CENTER && t != BOTTOM)
throw new IllegalArgumentException("Invalid alignment.");
int old = verticalTextPosition;
verticalTextPosition = t;
firePropertyChange(VERTICAL_TEXT_POSITION_CHANGED_PROPERTY, old, t);
revalidate();
repaint();
}
/**
* Set the value of the "borderPainted" property. If set to
* false, the button's look and feel class should not paint
* a border for the button. The default is true.
*
* @return The current value of the property.
*/
public boolean isBorderPainted()
{
return borderPainted;
}
/**
* Set the value of the "borderPainted" property. If set to
* false, the button's look and feel class should not paint
* a border for the button. The default is true.
*
* @param b The new value of the property.
*/
public void setBorderPainted(boolean b)
{
clientBorderPaintedSet = true;
if (borderPainted == b)
return;
boolean old = borderPainted;
borderPainted = b;
firePropertyChange(BORDER_PAINTED_CHANGED_PROPERTY, old, b);
revalidate();
repaint();
}
/**
* Get the value of the "action" property.
*
* @return The current value of the "action" property
*/
public Action getAction()
{
return action;
}
/**
* Set the button's "action" property, subscribing the new action to the * button, as an ActionListener, if it is not already subscribed. The old * Action, if it exists, is unsubscribed, and the button is unsubscribed * from the old Action if it was previously subscribed as a * PropertyChangeListener.
* *This method also configures several of the button's properties from * the Action, by calling {@link #configurePropertiesFromAction}, and * subscribes the button to the Action as a PropertyChangeListener. * Subsequent changes to the Action will thus reconfigure the button * automatically.
* * @param a The new value of the "action" property */ public void setAction(Action a) { if (action != null) { action.removePropertyChangeListener(actionPropertyChangeListener); removeActionListener(action); if (actionPropertyChangeListener != null) { action.removePropertyChangeListener(actionPropertyChangeListener); actionPropertyChangeListener = null; } } Action old = action; action = a; configurePropertiesFromAction(action); if (action != null) { actionPropertyChangeListener = createActionPropertyChangeListener(a); action.addPropertyChangeListener(actionPropertyChangeListener); addActionListener(action); } } /** * Return the button's default "icon" property. * * @return The current default icon */ public Icon getIcon() { return default_icon; } /** * Set the button's default "icon" property. This icon is used as a basis * for the pressed and disabled icons, if none are explicitly set. * * @param i The new default icon */ public void setIcon(Icon i) { if (default_icon == i) return; Icon old = default_icon; default_icon = i; firePropertyChange(ICON_CHANGED_PROPERTY, old, i); revalidate(); repaint(); } /** * Return the button's "text" property. This property is synonymous with * the "label" property. * * @return The current "text" property */ public String getText() { return text; } /** * Set the button's "label" property. This property is synonymous with the * "text" property. * * @param label The new "label" property * * @deprecated usesetText(text)
*/
public void setLabel(String label)
{
setText(label);
}
/**
* Return the button's "label" property. This property is synonymous with
* the "text" property.
*
* @return The current "label" property
*
* @deprecated use getText()
*/
public String getLabel()
{
return getText();
}
/**
* Set the button's "text" property. This property is synonymous with the
* "label" property.
*
* @param t The new "text" property
*/
public void setText(String t)
{
if (text == t)
return;
String old = text;
text = t;
firePropertyChange(TEXT_CHANGED_PROPERTY, old, t);
revalidate();
repaint();
}
/**
* Set the value of the {@link #iconTextGap} property.
*
* @param i The new value of the property
*
* @since 1.4
*/
public void setIconTextGap(int i)
{
clientIconTextGapSet = true;
if (iconTextGap == i)
return;
int old = iconTextGap;
iconTextGap = i;
firePropertyChange("iconTextGap", new Integer(old), new Integer(i));
revalidate();
repaint();
}
/**
* Get the value of the {@link #iconTextGap} property.
*
* @return The current value of the property
*
* @since 1.4
*/
public int getIconTextGap()
{
return iconTextGap;
}
/**
* Return the button's "margin" property, which is an {@link Insets} object
* describing the distance between the button's border and its text and
* icon.
*
* @return The current "margin" property
*/
public Insets getMargin()
{
return margin;
}
/**
* Set the button's "margin" property, which is an {@link Insets} object
* describing the distance between the button's border and its text and
* icon.
*
* @param m The new "margin" property
*/
public void setMargin(Insets m)
{
if (margin == m)
return;
Insets old = margin;
margin = m;
firePropertyChange(MARGIN_CHANGED_PROPERTY, old, m);
revalidate();
repaint();
}
/**
* Return the button's "pressedIcon" property. The look and feel class
* should paint this icon when the "pressed" property of the button's
* {@link ButtonModel} is true. This property may be
* null, in which case the default icon is used.
*
* @return The current "pressedIcon" property
*/
public Icon getPressedIcon()
{
return pressed_icon;
}
/**
* Set the button's "pressedIcon" property. The look and feel class
* should paint this icon when the "pressed" property of the button's
* {@link ButtonModel} is true. This property may be
* null, in which case the default icon is used.
*
* @param pressedIcon The new "pressedIcon" property
*/
public void setPressedIcon(Icon pressedIcon)
{
if (pressed_icon == pressedIcon)
return;
Icon old = pressed_icon;
pressed_icon = pressedIcon;
firePropertyChange(PRESSED_ICON_CHANGED_PROPERTY, old, pressed_icon);
revalidate();
repaint();
}
/**
* Return the button's "disabledIcon" property. The look and feel class
* should paint this icon when the "enabled" property of the button's
* {@link ButtonModel} is false. This property may be
* null, in which case an icon is constructed, based on the
* default icon.
*
* @return The current "disabledIcon" property
*/
public Icon getDisabledIcon()
{
if (disabledIcon == null && default_icon instanceof ImageIcon)
{
Image iconImage = ((ImageIcon) default_icon).getImage();
Image grayImage = GrayFilter.createDisabledImage(iconImage);
disabledIcon = new ImageIcon(grayImage);
}
return disabledIcon;
}
/**
* Set the button's "disabledIcon" property. The look and feel class should
* paint this icon when the "enabled" property of the button's {@link
* ButtonModel} is false. This property may be
* null, in which case an icon is constructed, based on the
* default icon.
*
* @param d The new "disabledIcon" property
*/
public void setDisabledIcon(Icon d)
{
if (disabledIcon == d)
return;
Icon old = disabledIcon;
disabledIcon = d;
firePropertyChange(DISABLED_ICON_CHANGED_PROPERTY, old, d);
revalidate();
repaint();
}
/**
* Return the button's "paintFocus" property. This property controls
* whether or not the look and feel class will paint a special indicator
* of focus state for the button. If it is false, the button still paints
* when focused, but no special decoration is painted to indicate the
* presence of focus.
*
* @return The current "paintFocus" property
*/
public boolean isFocusPainted()
{
return focusPainted;
}
/**
* Set the button's "paintFocus" property. This property controls whether
* or not the look and feel class will paint a special indicator of focus
* state for the button. If it is false, the button still paints when
* focused, but no special decoration is painted to indicate the presence
* of focus.
*
* @param p The new "paintFocus" property
*/
public void setFocusPainted(boolean p)
{
if (focusPainted == p)
return;
boolean old = focusPainted;
focusPainted = p;
firePropertyChange(FOCUS_PAINTED_CHANGED_PROPERTY, old, p);
revalidate();
repaint();
}
/**
* Verifies that a particular key is one of the valid constants used for
* describing horizontal alignment and positioning. The valid constants
* are the following members of {@link SwingConstants}:
* RIGHT, LEFT, CENTER,
* LEADING or TRAILING.
*
* @param key The key to check
* @param exception A message to include in an IllegalArgumentException
*
* @return the value of key
*
* @throws IllegalArgumentException If key is not one of the valid constants
*
* @see #setHorizontalTextPosition(int)
* @see #setHorizontalAlignment(int)
*/
protected int checkHorizontalKey(int key, String exception)
{
switch (key)
{
case SwingConstants.RIGHT:
case SwingConstants.LEFT:
case SwingConstants.CENTER:
case SwingConstants.LEADING:
case SwingConstants.TRAILING:
break;
default:
throw new IllegalArgumentException(exception);
}
return key;
}
/**
* Verifies that a particular key is one of the valid constants used for
* describing vertical alignment and positioning. The valid constants are
* the following members of {@link SwingConstants}: TOP,
* BOTTOM or CENTER.
*
* @param key The key to check
* @param exception A message to include in an IllegalArgumentException
*
* @return the value of key
*
* @throws IllegalArgumentException If key is not one of the valid constants
*
* @see #setVerticalTextPosition(int)
* @see #setVerticalAlignment(int)
*/
protected int checkVerticalKey(int key, String exception)
{
switch (key)
{
case SwingConstants.TOP:
case SwingConstants.BOTTOM:
case SwingConstants.CENTER:
break;
default:
throw new IllegalArgumentException(exception);
}
return key;
}
/**
* Configure various properties of the button by reading properties
* of an {@link Action}. The mapping of properties is as follows:
*
* | Action keyed property | AbstractButton property |
|---|---|
| NAME | text |
| SMALL_ICON | icon |
| SHORT_DESCRIPTION | toolTipText |
| MNEMONIC_KEY | mnemonic |
| ACTION_COMMAND_KEY | actionCommand |
In addition, this method always sets the button's "enabled" property to * the value of the Action's "enabled" property.
* *If the provided Action is null, the text, icon, and
* toolTipText properties of the button are set to null, and
* the "enabled" property is set to true; the mnemonic and
* actionCommand properties are unchanged.
A factory method which should return an {@link ActionListener} that * propagates events from the button's {@link ButtonModel} to any of the * button's ActionListeners. By default, this is an inner class which * calls {@link AbstractButton#fireActionPerformed} with a modified copy * of the incoming model {@link ActionEvent}.
* *The button calls this method during construction, stores the
* resulting ActionListener in its actionListener member
* field, and subscribes it to the button's model. If the button's model
* is changed, this listener is unsubscribed from the old model and
* subscribed to the new one.
A factory method which should return a {@link PropertyChangeListener} * that accepts changes to the specified {@link Action} and reconfigure * the {@link AbstractButton}, by default using the {@link * #configurePropertiesFromAction} method.
* *The button calls this method whenever a new Action is assigned to
* the button's "action" property, via {@link #setAction}, and stores the
* resulting PropertyChangeListener in its
* actionPropertyChangeListener member field. The button
* then subscribes the listener to the button's new action. If the
* button's action is changed subsequently, the listener is unsubscribed
* from the old action and subscribed to the new one.
Factory method which creates a {@link ChangeListener}, used to * subscribe to ChangeEvents from the button's model. Subclasses of * AbstractButton may wish to override the listener used to subscribe to * such ChangeEvents. By default, the listener just propagates the * {@link ChangeEvent} to the button's ChangeListeners, via the {@link * AbstractButton#fireStateChanged} method.
* *The button calls this method during construction, stores the
* resulting ChangeListener in its changeListener member
* field, and subscribes it to the button's model. If the button's model
* is changed, this listener is unsubscribed from the old model and
* subscribed to the new one.
Factory method which creates a {@link ItemListener}, used to * subscribe to ItemEvents from the button's model. Subclasses of * AbstractButton may wish to override the listener used to subscribe to * such ItemEvents. By default, the listener just propagates the * {@link ItemEvent} to the button's ItemListeners, via the {@link * AbstractButton#fireItemStateChanged} method.
* *The button calls this method during construction, stores the
* resulting ItemListener in its changeListener member
* field, and subscribes it to the button's model. If the button's model
* is changed, this listener is unsubscribed from the old model and
* subscribed to the new one.
Note that ItemEvents are only generated from the button's model
* when the model's selected property changes. If you want to
* subscribe to other properties of the model, you must subscribe to
* ChangeEvents.
*
* @return The new ItemListener
*/
protected ItemListener createItemListener()
{
return getEventHandler();
}
/**
* Programmatically perform a "click" on the button: arming, pressing,
* waiting, un-pressing, and disarming the model.
*/
public void doClick()
{
doClick(100);
}
/**
* Programmatically perform a "click" on the button: arming, pressing,
* waiting, un-pressing, and disarming the model.
*
* @param pressTime The number of milliseconds to wait in the pressed state
*/
public void doClick(int pressTime)
{
ButtonModel mod = getModel();
if (mod != null)
{
mod.setArmed(true);
mod.setPressed(true);
try
{
java.lang.Thread.sleep(pressTime);
}
catch (java.lang.InterruptedException e)
{
// probably harmless
}
mod.setPressed(false);
mod.setArmed(false);
}
}
/**
* Return the button's disabled selected icon. The look and feel class
* should paint this icon when the "enabled" property of the button's model
* is false and its "selected" property is
* true. This icon can be null, in which case
* it is synthesized from the button's selected icon.
*
* @return The current disabled selected icon
*/
public Icon getDisabledSelectedIcon()
{
return disabledSelectedIcon;
}
/**
* Set the button's disabled selected icon. The look and feel class
* should paint this icon when the "enabled" property of the button's model
* is false and its "selected" property is
* true. This icon can be null, in which case
* it is synthesized from the button's selected icon.
*
* @param icon The new disabled selected icon
*/
public void setDisabledSelectedIcon(Icon icon)
{
if (disabledSelectedIcon == icon)
return;
Icon old = disabledSelectedIcon;
disabledSelectedIcon = icon;
firePropertyChange(DISABLED_SELECTED_ICON_CHANGED_PROPERTY, old, icon);
revalidate();
repaint();
}
/**
* Return the button's rollover icon. The look and feel class should
* paint this icon when the "rolloverEnabled" property of the button is
* true and the mouse rolls over the button.
*
* @return The current rollover icon
*/
public Icon getRolloverIcon()
{
return rolloverIcon;
}
/**
* Set the button's rollover icon and sets the rolloverEnabled
* property to true. The look and feel class should
* paint this icon when the "rolloverEnabled" property of the button is
* true and the mouse rolls over the button.
*
* @param r The new rollover icon
*/
public void setRolloverIcon(Icon r)
{
if (rolloverIcon == r)
return;
Icon old = rolloverIcon;
rolloverIcon = r;
firePropertyChange(ROLLOVER_ICON_CHANGED_PROPERTY, old, rolloverIcon);
setRolloverEnabled(true);
revalidate();
repaint();
}
/**
* Return the button's rollover selected icon. The look and feel class
* should paint this icon when the "rolloverEnabled" property of the button
* is true, the "selected" property of the button's model is
* true, and the mouse rolls over the button.
*
* @return The current rollover selected icon
*/
public Icon getRolloverSelectedIcon()
{
return rolloverSelectedIcon;
}
/**
* Set the button's rollover selected icon and sets the
* rolloverEnabled property to true. The look and
* feel class should paint this icon when the "rolloverEnabled" property of
* the button is true, the "selected" property of the button's
* model is true, and the mouse rolls over the button.
*
* @param r The new rollover selected icon.
*/
public void setRolloverSelectedIcon(Icon r)
{
if (rolloverSelectedIcon == r)
return;
Icon old = rolloverSelectedIcon;
rolloverSelectedIcon = r;
firePropertyChange(ROLLOVER_SELECTED_ICON_CHANGED_PROPERTY, old, r);
setRolloverEnabled(true);
revalidate();
repaint();
}
/**
* Return the button's selected icon. The look and feel class should
* paint this icon when the "selected" property of the button's model is
* true, and either the "rolloverEnabled" property of the
* button is false or the mouse is not currently rolled
* over the button.
*
* @return The current selected icon
*/
public Icon getSelectedIcon()
{
return selectedIcon;
}
/**
* Set the button's selected icon. The look and feel class should
* paint this icon when the "selected" property of the button's model is
* true, and either the "rolloverEnabled" property of the
* button is false or the mouse is not currently rolled
* over the button.
*
* @param s The new selected icon
*/
public void setSelectedIcon(Icon s)
{
if (selectedIcon == s)
return;
Icon old = selectedIcon;
selectedIcon = s;
firePropertyChange(SELECTED_ICON_CHANGED_PROPERTY, old, s);
revalidate();
repaint();
}
/**
* Returns an single-element array containing the "text" property of the
* button if the "selected" property of the button's model is
* true, otherwise returns null.
*
* @return The button's "selected object" array
*/
public Object[] getSelectedObjects()
{
if (isSelected())
{
Object[] objs = new Object[1];
objs[0] = getText();
return objs;
}
else
{
return null;
}
}
/**
* Called when image data becomes available for one of the button's icons.
*
* @param img The image being updated
* @param infoflags One of the constant codes in {@link ImageObserver} used
* to describe updated portions of an image.
* @param x X coordinate of the region being updated
* @param y Y coordinate of the region being updated
* @param w Width of the region beign updated
* @param h Height of the region being updated
*
* @return true if img is equal to the button's current icon,
* otherwise false
*/
public boolean imageUpdate(Image img, int infoflags, int x, int y, int w,
int h)
{
return current_icon == img;
}
/**
* Returns the value of the button's "contentAreaFilled" property. This
* property indicates whether the area surrounding the text and icon of
* the button should be filled by the look and feel class. If this
* property is false, the look and feel class should leave
* the content area transparent.
*
* @return The current value of the "contentAreaFilled" property
*/
public boolean isContentAreaFilled()
{
return contentAreaFilled;
}
/**
* Sets the value of the button's "contentAreaFilled" property. This
* property indicates whether the area surrounding the text and icon of
* the button should be filled by the look and feel class. If this
* property is false, the look and feel class should leave
* the content area transparent.
*
* @param b The new value of the "contentAreaFilled" property
*/
public void setContentAreaFilled(boolean b)
{
clientContentAreaFilledSet = true;
if (contentAreaFilled == b)
return;
// The JDK sets the opaque property to the value of the contentAreaFilled
// property, so should we do.
setOpaque(b);
boolean old = contentAreaFilled;
contentAreaFilled = b;
firePropertyChange(CONTENT_AREA_FILLED_CHANGED_PROPERTY, old, b);
}
/**
* Paints the button's border, if the button's "borderPainted" property is
* true, by out calling to the button's look and feel class.
*
* @param g The graphics context used to paint the border
*/
protected void paintBorder(Graphics g)
{
if (isBorderPainted())
super.paintBorder(g);
}
/**
* Returns a string, used only for debugging, which identifies or somehow
* represents this button. The exact value is implementation-defined.
*
* @return A string representation of the button
*/
protected String paramString()
{
StringBuffer sb = new StringBuffer();
sb.append(super.paramString());
sb.append(",defaultIcon=");
if (getIcon() != null)
sb.append(getIcon());
sb.append(",disabledIcon=");
if (getDisabledIcon() != null)
sb.append(getDisabledIcon());
sb.append(",disabledSelectedIcon=");
if (getDisabledSelectedIcon() != null)
sb.append(getDisabledSelectedIcon());
sb.append(",margin=");
if (getMargin() != null)
sb.append(getMargin());
sb.append(",paintBorder=").append(isBorderPainted());
sb.append(",paintFocus=").append(isFocusPainted());
sb.append(",pressedIcon=");
if (getPressedIcon() != null)
sb.append(getPressedIcon());
sb.append(",rolloverEnabled=").append(isRolloverEnabled());
sb.append(",rolloverIcon=");
if (getRolloverIcon() != null)
sb.append(getRolloverIcon());
sb.append(",rolloverSelected=");
if (getRolloverSelectedIcon() != null)
sb.append(getRolloverSelectedIcon());
sb.append(",selectedIcon=");
if (getSelectedIcon() != null)
sb.append(getSelectedIcon());
sb.append(",text=");
if (getText() != null)
sb.append(getText());
return sb.toString();
}
/**
* Set the "UI" property of the button, which is a look and feel class
* responsible for handling the button's input events and painting it.
*
* @param ui The new "UI" property
*/
public void setUI(ButtonUI ui)
{
super.setUI(ui);
}
/**
* Set the "UI" property of the button, which is a look and feel class
* responsible for handling the button's input events and painting it.
*
* @return The current "UI" property
*/
public ButtonUI getUI()
{
return (ButtonUI) ui;
}
/**
* Set the "UI" property to a class constructed, via the {@link
* UIManager}, from the current look and feel. This should be overridden
* for each subclass of AbstractButton, to retrieve a suitable {@link
* ButtonUI} look and feel class.
*/
public void updateUI()
{
// TODO: What to do here?
}
/**
* Returns the current time in milliseconds in which clicks gets coalesced
* into a single ActionEvent.
*
* @return the time in milliseconds
*
* @since 1.4
*/
public long getMultiClickThreshhold()
{
return multiClickThreshhold;
}
/**
* Sets the time in milliseconds in which clicks gets coalesced into a single
* ActionEvent.
*
* @param threshhold the time in milliseconds
*
* @since 1.4
*/
public void setMultiClickThreshhold(long threshhold)
{
if (threshhold < 0)
throw new IllegalArgumentException();
multiClickThreshhold = threshhold;
}
/**
* Adds the specified component to this AbstractButton. This overrides the
* default in order to install an {@link OverlayLayout} layout manager
* before adding the component. The layout manager is only installed if
* no other layout manager has been installed before.
*
* @param comp the component to be added
* @param constraints constraints for the layout manager
* @param index the index at which the component is added
*
* @since 1.5
*/
protected void addImpl(Component comp, Object constraints, int index)
{
// We use a client property here, so that no extra memory is used in
// the common case with no layout manager.
if (getClientProperty("AbstractButton.customLayoutSet") == null)
setLayout(new OverlayLayout(this));
super.addImpl(comp, constraints, index);
}
/**
* Sets a layout manager on this AbstractButton. This is overridden in order
* to detect if the application sets a custom layout manager. If no custom
* layout manager is set, {@link #addImpl(Component, Object, int)} installs
* an OverlayLayout before adding a component.
*
* @param layout the layout manager to install
*
* @since 1.5
*/
public void setLayout(LayoutManager layout)
{
// We use a client property here, so that no extra memory is used in
// the common case with no layout manager.
putClientProperty("AbstractButton.customLayoutSet", Boolean.TRUE);
super.setLayout(layout);
}
/**
* Helper method for
* {@link LookAndFeel#installProperty(JComponent, String, Object)}.
*
* @param propertyName the name of the property
* @param value the value of the property
*
* @throws IllegalArgumentException if the specified property cannot be set
* by this method
* @throws ClassCastException if the property value does not match the
* property type
* @throws NullPointerException if c or
* propertyValue is null
*/
void setUIProperty(String propertyName, Object value)
{
if (propertyName.equals("borderPainted"))
{
if (! clientBorderPaintedSet)
{
setBorderPainted(((Boolean) value).booleanValue());
clientBorderPaintedSet = false;
}
}
else if (propertyName.equals("rolloverEnabled"))
{
if (! clientRolloverEnabledSet)
{
setRolloverEnabled(((Boolean) value).booleanValue());
clientRolloverEnabledSet = false;
}
}
else if (propertyName.equals("iconTextGap"))
{
if (! clientIconTextGapSet)
{
setIconTextGap(((Integer) value).intValue());
clientIconTextGapSet = false;
}
}
else if (propertyName.equals("contentAreaFilled"))
{
if (! clientContentAreaFilledSet)
{
setContentAreaFilled(((Boolean) value).booleanValue());
clientContentAreaFilledSet = false;
}
}
else
{
super.setUIProperty(propertyName, value);
}
}
/**
* Returns the combined event handler. The instance is created if
* necessary.
*
* @return the combined event handler
*/
EventHandler getEventHandler()
{
if (eventHandler == null)
eventHandler = new EventHandler();
return eventHandler;
}
}