The purpose of this class is to serve as a facade over a number of * classes which collectively represent the semantics of a button: the * button's model, its listeners, its action, and its look and feel. Some * parts of a button's state are stored explicitly in this class, other * parts are delegates to the model. Some methods related to buttons are * implemented in this class, other methods pass through to the current * model or look and feel.
* *Furthermore 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.
* *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 time in miliseconds 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);
/** 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()
{
}
public AccessibleStateSet getAccessibleStateSet()
{
return null; // TODO
}
public String getAccessibleName()
{
return null; // TODO
}
public AccessibleIcon[] getAccessibleIcon()
{
return null; // TODO
}
public AccessibleRelationSet getAccessibleRelationSet()
{
return null; // TODO
}
public AccessibleAction getAccessibleAction()
{
return null; // TODO
}
public AccessibleValue getAccessibleValue()
{
return null; // TODO
}
public int getAccessibleActionCount()
{
return 0; // TODO
}
public String getAccessibleActionDescription(int value0)
{
return null; // TODO
}
public boolean doAccessibleAction(int value0)
{
return false; // TODO
}
public Number getCurrentAccessibleValue()
{
return null; // TODO
}
public boolean setCurrentAccessibleValue(Number value0)
{
return false; // TODO
}
public Number getMinimumAccessibleValue()
{
return null; // TODO
}
public Number getMaximumAccessibleValue()
{
return null; // TODO
}
public AccessibleText getAccessibleText()
{
return null; // TODO
}
public int getIndexAtPoint(Point value0)
{
return 0; // TODO
}
public Rectangle getCharacterBounds(int value0)
{
return null; // TODO
}
public int getCharCount()
{
return 0; // TODO
}
public int getCaretPosition()
{
return 0; // TODO
}
public String getAtIndex(int value0, int value1)
{
return null; // TODO
}
public String getAfterIndex(int value0, int value1)
{
return null; // TODO
}
public String getBeforeIndex(int value0, int value1)
{
return null; // TODO
}
public AttributeSet getCharacterAttribute(int value0)
{
return null; // TODO
}
public int getSelectionStart()
{
return 0; // TODO
}
public int getSelectionEnd()
{
return 0; // TODO
}
public String getSelectedText()
{
return null; // TODO
}
private Rectangle getTextRectangle()
{
return null; // TODO
}
}
/**
* Creates a new AbstractButton object.
*/
public AbstractButton()
{
this("",null);
}
/**
* Creates a new AbstractButton object.
*
* @param txt Value to use for the button's "text" property
* @param icon Value to use for the button's "defaultIcon" property
*/
AbstractButton(String txt, Icon icon)
{
init (txt, icon);
updateUI();
}
/**
* 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);
model.removeChangeListener(changeListener);
model.removeItemListener(itemListener);
}
ButtonModel old = model;
model = newModel;
if (model != null)
{
model.addActionListener(actionListener);
model.addChangeListener(changeListener);
model.addItemListener(itemListener);
}
firePropertyChange(MODEL_CHANGED_PROPERTY, old, model);
revalidate();
repaint();
}
protected void init(String text, Icon icon)
{
this.text = text;
default_icon = icon;
actionListener = createActionListener();
changeListener = createChangeListener();
itemListener = createItemListener();
horizontalAlignment = CENTER;
horizontalTextPosition = TRAILING;
verticalAlignment = CENTER;
verticalTextPosition = CENTER;
borderPainted = true;
contentAreaFilled = true;
focusPainted = true;
setFocusable(true);
setAlignmentX(LEFT_ALIGNMENT);
setAlignmentY(CENTER_ALIGNMENT);
setDisplayedMnemonicIndex(-1);
}
/**
* Get the action command string for this button's model.
*
* @return The current action command string from the button's model
*/
public String getActionCommand()
{
return getModel().getActionCommand();
}
/**
* Set the action command string for this button's model.
*
* @param aCommand The new action command string to set in the button's
* model.
*/
public void setActionCommand(String aCommand)
{
getModel().setActionCommand(aCommand);
}
/**
* Adds an ActionListener to the button's listener list. When the
* button's model is clicked it fires an ActionEvent, and these
* listeners will be called.
*
* @param l The new listener to add
*/
public void addActionListener(ActionListener l)
{
listenerList.add(ActionListener.class, l);
}
/**
* Removes an ActionListener from the button's listener list.
*
* @param l The listener to remove
*/
public void removeActionListener(ActionListener l)
{
listenerList.remove(ActionListener.class, l);
}
/**
* Returns all added 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)
{
e.setSource(this);
ActionListener[] listeners = getActionListeners();
for (int i = 0; i < listeners.length; i++)
listeners[i].actionPerformed(e);
}
/**
* Calls {@link ChangeEvent.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()
{
return getModel().getMnemonic();
}
/**
* 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)
{
int old = getModel().getMnemonic();
if (old != mne)
{
getModel().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)
{
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)
{
getModel().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()
{
return getModel().isSelected();
}
/**
* 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)
{
super.setEnabled(b);
getModel().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
* RIGHT.
*
* @return The current horizontal alignment
*/
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
* RIGHT.
*
* @param a The new horizontal alignment
* @throws IllegalArgumentException If alignment is not one of the legal
* constants.
*/
public void setHorizontalAlignment(int a)
{
if (horizontalAlignment == a)
return;
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;
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
*/
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.
*/
public void setVerticalAlignment(int a)
{
if (verticalAlignment == a)
return;
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;
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)
{
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
*/
public void setIconTextGap(int i)
{
if (iconTextGap == i)
return;
int old = iconTextGap;
iconTextGap = i;
fireStateChanged();
revalidate();
repaint();
}
/**
* Get the value of the {@link #iconTextGap} property.
*
* @return The current value of the property
*/
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 (disabeldIcon == null
&& default_icon instanceof ImageIcon)
disabeldIcon = new ImageIcon(GrayFilter.createDisabledImage(((ImageIcon) default_icon).getImage()));
return disabeldIcon;
}
/**
* 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 disabledIcon The new "disabledIcon" property
*/
public void setDisabledIcon(Icon d)
{
disabeldIcon = 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 b 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()
* @see setHorizontalAlignment()
*/
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()
* @see setVerticalAlignment()
*/
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 new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
AbstractButton.this.fireItemStateChanged(e);
}
};
}
/**
* 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)
{
getModel().setArmed(true);
getModel().setPressed(true);
try
{
java.lang.Thread.sleep(pressTime);
}
catch (java.lang.InterruptedException e)
{
// probably harmless
}
getModel().setPressed(false);
getModel().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. 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 rolloverIcon 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);
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. 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 rolloverSelectedIcon 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);
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 selectedIcon 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)
{
if (contentAreaFilled == b)
return;
boolean old = contentAreaFilled;
contentAreaFilled = b;
firePropertyChange(CONTENT_AREA_FILLED_CHANGED_PROPERTY, old, b);
revalidate();
repaint();
}
/**
* 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()
{
}
/**
* 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;
}
}