My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/javax/swing/AbstractButton.java (1 of 18352 files). Show all

Unified · Split

java/pkg/javax/swing/AbstractButton.java+3101−0

@@ -0,0 +1,3101 @@
	1	+/*
	2	+ * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+package javax.swing;
	26	+
	27	+import java.awt.*;
	28	+import java.awt.event.*;
	29	+import java.awt.image.*;
	30	+import java.text.*;
	31	+import java.awt.geom.*;
	32	+import java.beans.PropertyChangeEvent;
	33	+import java.beans.PropertyChangeListener;
	34	+import java.beans.Transient;
	35	+import java.util.Enumeration;
	36	+import java.util.Vector;
	37	+import java.io.Serializable;
	38	+import javax.swing.event.*;
	39	+import javax.swing.border.*;
	40	+import javax.swing.plaf.*;
	41	+import javax.accessibility.*;
	42	+import javax.swing.text.*;
	43	+import javax.swing.text.html.*;
	44	+import javax.swing.plaf.basic.*;
	45	+import java.util.*;
	46	+
	47	+/**
	48	+ * Defines common behaviors for buttons and menu items.
	49	+ * <p>
	50	+ * Buttons can be configured, and to some degree controlled, by
	51	+ * <code><a href="Action.html">Action</a></code>s. Using an
	52	+ * <code>Action</code> with a button has many benefits beyond directly
	53	+ * configuring a button. Refer to <a href="Action.html#buttonActions">
	54	+ * Swing Components Supporting <code>Action</code></a> for more
	55	+ * details, and you can find more information in <a
	56	+ * href="http://java.sun.com/docs/books/tutorial/uiswing/misc/action.html">How
	57	+ * to Use Actions</a>, a section in <em>The Java Tutorial</em>.
	58	+ * <p>
	59	+ * For further information see
	60	+ * <a
	61	+ href="http://java.sun.com/docs/books/tutorial/uiswing/components/button.html">How to Use Buttons, Check Boxes, and Radio Buttons</a>,
	62	+ * a section in <em>The Java Tutorial</em>.
	63	+ * <p>
	64	+ * <strong>Warning:</strong>
	65	+ * Serialized objects of this class will not be compatible with
	66	+ * future Swing releases. The current serialization support is
	67	+ * appropriate for short term storage or RMI between applications running
	68	+ * the same version of Swing. As of 1.4, support for long term storage
	69	+ * of all JavaBeans<sup><font size="-2">TM</font></sup>
	70	+ * has been added to the <code>java.beans</code> package.
	71	+ * Please see {@link java.beans.XMLEncoder}.
	72	+ *
	73	+ * @author Jeff Dinkins
	74	+ */
	75	+public abstract class AbstractButton extends JComponent implements ItemSelectable, SwingConstants {
	76	+
	77	+ // *********************************
	78	+ // ***** Button properties *****
	79	+ // *********************************
	80	+
	81	+ /** Identifies a change in the button model. */
	82	+ public static final String MODEL_CHANGED_PROPERTY = "model";
	83	+ /** Identifies a change in the button's text. */
	84	+ public static final String TEXT_CHANGED_PROPERTY = "text";
	85	+ /** Identifies a change to the button's mnemonic. */
	86	+ public static final String MNEMONIC_CHANGED_PROPERTY = "mnemonic";
	87	+
	88	+ // Text positioning and alignment
	89	+ /** Identifies a change in the button's margins. */
	90	+ public static final String MARGIN_CHANGED_PROPERTY = "margin";
	91	+ /** Identifies a change in the button's vertical alignment. */
	92	+ public static final String VERTICAL_ALIGNMENT_CHANGED_PROPERTY = "verticalAlignment";
	93	+ /** Identifies a change in the button's horizontal alignment. */
	94	+ public static final String HORIZONTAL_ALIGNMENT_CHANGED_PROPERTY = "horizontalAlignment";
	95	+
	96	+ /** Identifies a change in the button's vertical text position. */
	97	+ public static final String VERTICAL_TEXT_POSITION_CHANGED_PROPERTY = "verticalTextPosition";
	98	+ /** Identifies a change in the button's horizontal text position. */
	99	+ public static final String HORIZONTAL_TEXT_POSITION_CHANGED_PROPERTY = "horizontalTextPosition";
	100	+
	101	+ // Paint options
	102	+ /**
	103	+ * Identifies a change to having the border drawn,
	104	+ * or having it not drawn.
	105	+ */
	106	+ public static final String BORDER_PAINTED_CHANGED_PROPERTY = "borderPainted";
	107	+ /**
	108	+ * Identifies a change to having the border highlighted when focused,
	109	+ * or not.
	110	+ */
	111	+ public static final String FOCUS_PAINTED_CHANGED_PROPERTY = "focusPainted";
	112	+ /**
	113	+ * Identifies a change from rollover enabled to disabled or back
	114	+ * to enabled.
	115	+ */
	116	+ public static final String ROLLOVER_ENABLED_CHANGED_PROPERTY = "rolloverEnabled";
	117	+ /**
	118	+ * Identifies a change to having the button paint the content area.
	119	+ */
	120	+ public static final String CONTENT_AREA_FILLED_CHANGED_PROPERTY = "contentAreaFilled";
	121	+
	122	+ // Icons
	123	+ /** Identifies a change to the icon that represents the button. */
	124	+ public static final String ICON_CHANGED_PROPERTY = "icon";
	125	+
	126	+ /**
	127	+ * Identifies a change to the icon used when the button has been
	128	+ * pressed.
	129	+ */
	130	+ public static final String PRESSED_ICON_CHANGED_PROPERTY = "pressedIcon";
	131	+ /**
	132	+ * Identifies a change to the icon used when the button has
	133	+ * been selected.
	134	+ */
	135	+ public static final String SELECTED_ICON_CHANGED_PROPERTY = "selectedIcon";
	136	+
	137	+ /**
	138	+ * Identifies a change to the icon used when the cursor is over
	139	+ * the button.
	140	+ */
	141	+ public static final String ROLLOVER_ICON_CHANGED_PROPERTY = "rolloverIcon";
	142	+ /**
	143	+ * Identifies a change to the icon used when the cursor is
	144	+ * over the button and it has been selected.
	145	+ */
	146	+ public static final String ROLLOVER_SELECTED_ICON_CHANGED_PROPERTY = "rolloverSelectedIcon";
	147	+
	148	+ /**
	149	+ * Identifies a change to the icon used when the button has
	150	+ * been disabled.
	151	+ */
	152	+ public static final String DISABLED_ICON_CHANGED_PROPERTY = "disabledIcon";
	153	+ /**
	154	+ * Identifies a change to the icon used when the button has been
	155	+ * disabled and selected.
	156	+ */
	157	+ public static final String DISABLED_SELECTED_ICON_CHANGED_PROPERTY = "disabledSelectedIcon";
	158	+
	159	+
	160	+ /** The data model that determines the button's state. */
	161	+ protected ButtonModel model = null;
	162	+
	163	+ private String text = ""; // for BeanBox
	164	+ private Insets margin = null;
	165	+ private Insets defaultMargin = null;
	166	+
	167	+ // Button icons
	168	+ // PENDING(jeff) - hold icons in an array
	169	+ private Icon defaultIcon = null;
	170	+ private Icon pressedIcon = null;
	171	+ private Icon disabledIcon = null;
	172	+
	173	+ private Icon selectedIcon = null;
	174	+ private Icon disabledSelectedIcon = null;
	175	+
	176	+ private Icon rolloverIcon = null;
	177	+ private Icon rolloverSelectedIcon = null;
	178	+
	179	+ // Display properties
	180	+ private boolean paintBorder = true;
	181	+ private boolean paintFocus = true;
	182	+ private boolean rolloverEnabled = false;
	183	+ private boolean contentAreaFilled = true;
	184	+
	185	+ // Icon/Label Alignment
	186	+ private int verticalAlignment = CENTER;
	187	+ private int horizontalAlignment = CENTER;
	188	+
	189	+ private int verticalTextPosition = CENTER;
	190	+ private int horizontalTextPosition = TRAILING;
	191	+
	192	+ private int iconTextGap = 4;
	193	+
	194	+ private int mnemonic;
	195	+ private int mnemonicIndex = -1;
	196	+
	197	+ private long multiClickThreshhold = 0;
	198	+
	199	+ private boolean borderPaintedSet = false;
	200	+ private boolean rolloverEnabledSet = false;
	201	+ private boolean iconTextGapSet = false;
	202	+ private boolean contentAreaFilledSet = false;
	203	+
	204	+ // Whether or not we've set the LayoutManager.
	205	+ private boolean setLayout = false;
	206	+
	207	+ // This is only used by JButton, promoted to avoid an extra
	208	+ // boolean field in JButton
	209	+ boolean defaultCapable = true;
	210	+
	211	+ /**
	212	+ * Combined listeners: ActionListener, ChangeListener, ItemListener.
	213	+ */
	214	+ private Handler handler;
	215	+
	216	+ /**
	217	+ * The button model's <code>changeListener</code>.
	218	+ */
	219	+ protected ChangeListener changeListener = null;
	220	+ /**
	221	+ * The button model's <code>ActionListener</code>.
	222	+ */
	223	+ protected ActionListener actionListener = null;
	224	+ /**
	225	+ * The button model's <code>ItemListener</code>.
	226	+ */
	227	+ protected ItemListener itemListener = null;
	228	+
	229	+ /**
	230	+ * Only one <code>ChangeEvent</code> is needed per button
	231	+ * instance since the
	232	+ * event's only state is the source property. The source of events
	233	+ * generated is always "this".
	234	+ */
	235	+ protected transient ChangeEvent changeEvent;
	236	+
	237	+ private boolean hideActionText = false;
	238	+
	239	+ /**
	240	+ * Sets the <code>hideActionText</code> property, which determines
	241	+ * whether the button displays text from the <code>Action</code>.
	242	+ * This is useful only if an <code>Action</code> has been
	243	+ * installed on the button.
	244	+ *
	245	+ * @param hideActionText <code>true</code> if the button's
	246	+ * <code>text</code> property should not reflect
	247	+ * that of the <code>Action</code>; the default is
	248	+ * <code>false</code>
	249	+ * @see <a href="Action.html#buttonActions">Swing Components Supporting
	250	+ * <code>Action</code></a>
	251	+ * @since 1.6
	252	+ * @beaninfo
	253	+ * bound: true
	254	+ * expert: true
	255	+ * description: Whether the text of the button should come from
	256	+ * the <code>Action</code>.
	257	+ */
	258	+ public void setHideActionText(boolean hideActionText) {
	259	+ if (hideActionText != this.hideActionText) {
	260	+ this.hideActionText = hideActionText;
	261	+ if (getAction() != null) {
	262	+ setTextFromAction(getAction(), false);
	263	+ }
	264	+ firePropertyChange("hideActionText", !hideActionText,
	265	+ hideActionText);
	266	+ }
	267	+ }
	268	+
	269	+ /**
	270	+ * Returns the value of the <code>hideActionText</code> property, which
	271	+ * determines whether the button displays text from the
	272	+ * <code>Action</code>. This is useful only if an <code>Action</code>
	273	+ * has been installed on the button.
	274	+ *
	275	+ * @return <code>true</code> if the button's <code>text</code>
	276	+ * property should not reflect that of the
	277	+ * <code>Action</code>; the default is <code>false</code>
	278	+ * @since 1.6
	279	+ */
	280	+ public boolean getHideActionText() {
	281	+ return hideActionText;
	282	+ }
	283	+
	284	+ /**
	285	+ * Returns the button's text.
	286	+ * @return the buttons text
	287	+ * @see #setText
	288	+ */
	289	+ public String getText() {
	290	+ return text;
	291	+ }
	292	+
	293	+ /**
	294	+ * Sets the button's text.
	295	+ * @param text the string used to set the text
	296	+ * @see #getText
	297	+ * @beaninfo
	298	+ * bound: true
	299	+ * preferred: true
	300	+ * attribute: visualUpdate true
	301	+ * description: The button's text.
	302	+ */
	303	+ public void setText(String text) {
	304	+ String oldValue = this.text;
	305	+ this.text = text;
	306	+ firePropertyChange(TEXT_CHANGED_PROPERTY, oldValue, text);
	307	+ updateDisplayedMnemonicIndex(text, getMnemonic());
	308	+
	309	+ if (accessibleContext != null) {
	310	+ accessibleContext.firePropertyChange(
	311	+ AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
	312	+ oldValue, text);
	313	+ }
	314	+ if (text == null \|\| oldValue == null \|\| !text.equals(oldValue)) {
	315	+ revalidate();
	316	+ repaint();
	317	+ }
	318	+ }
	319	+
	320	+
	321	+ /**
	322	+ * Returns the state of the button. True if the
	323	+ * toggle button is selected, false if it's not.
	324	+ * @return true if the toggle button is selected, otherwise false
	325	+ */
	326	+ public boolean isSelected() {
	327	+ return model.isSelected();
	328	+ }
	329	+
	330	+ /**
	331	+ * Sets the state of the button. Note that this method does not
	332	+ * trigger an <code>actionEvent</code>.
	333	+ * Call <code>doClick</code> to perform a programatic action change.
	334	+ *
	335	+ * @param b true if the button is selected, otherwise false
	336	+ */
	337	+ public void setSelected(boolean b) {
	338	+ boolean oldValue = isSelected();
	339	+
	340	+ // TIGER - 4840653
	341	+ // Removed code which fired an AccessibleState.SELECTED
	342	+ // PropertyChangeEvent since this resulted in two
	343	+ // identical events being fired since
	344	+ // AbstractButton.fireItemStateChanged also fires the
	345	+ // same event. This caused screen readers to speak the
	346	+ // name of the item twice.
	347	+
	348	+ model.setSelected(b);
	349	+ }
	350	+
	351	+ /**
	352	+ * Programmatically perform a "click". This does the same
	353	+ * thing as if the user had pressed and released the button.
	354	+ */
	355	+ public void doClick() {
	356	+ doClick(68);
	357	+ }
	358	+
	359	+ /**
	360	+ * Programmatically perform a "click". This does the same
	361	+ * thing as if the user had pressed and released the button.
	362	+ * The button stays visually "pressed" for <code>pressTime</code>
	363	+ * milliseconds.
	364	+ *
	365	+ * @param pressTime the time to "hold down" the button, in milliseconds
	366	+ */
	367	+ public void doClick(int pressTime) {
	368	+ Dimension size = getSize();
	369	+ model.setArmed(true);
	370	+ model.setPressed(true);
	371	+ paintImmediately(new Rectangle(0,0, size.width, size.height));
	372	+ try {
	373	+ Thread.currentThread().sleep(pressTime);
	374	+ } catch(InterruptedException ie) {
	375	+ }
	376	+ model.setPressed(false);
	377	+ model.setArmed(false);
	378	+ }
	379	+
	380	+ /**
	381	+ * Sets space for margin between the button's border and
	382	+ * the label. Setting to <code>null</code> will cause the button to
	383	+ * use the default margin. The button's default <code>Border</code>
	384	+ * object will use this value to create the proper margin.
	385	+ * However, if a non-default border is set on the button,
	386	+ * it is that <code>Border</code> object's responsibility to create the
	387	+ * appropriate margin space (else this property will
	388	+ * effectively be ignored).
	389	+ *
	390	+ * @param m the space between the border and the label
	391	+ *
	392	+ * @beaninfo
	393	+ * bound: true
	394	+ * attribute: visualUpdate true
	395	+ * description: The space between the button's border and the label.
	396	+ */
	397	+ public void setMargin(Insets m) {
	398	+ // Cache the old margin if it comes from the UI
	399	+ if(m instanceof UIResource) {
	400	+ defaultMargin = m;
	401	+ } else if(margin instanceof UIResource) {
	402	+ defaultMargin = margin;
	403	+ }
	404	+
	405	+ // If the client passes in a null insets, restore the margin
	406	+ // from the UI if possible
	407	+ if(m == null && defaultMargin != null) {
	408	+ m = defaultMargin;
	409	+ }
	410	+
	411	+ Insets old = margin;
	412	+ margin = m;
	413	+ firePropertyChange(MARGIN_CHANGED_PROPERTY, old, m);
	414	+ if (old == null \|\| !old.equals(m)) {
	415	+ revalidate();
	416	+ repaint();
	417	+ }
	418	+ }
	419	+
	420	+ /**
	421	+ * Returns the margin between the button's border and
	422	+ * the label.
	423	+ *
	424	+ * @return an <code>Insets</code> object specifying the margin
	425	+ * between the botton's border and the label
	426	+ * @see #setMargin
	427	+ */
	428	+ public Insets getMargin() {
	429	+ return (margin == null) ? null : (Insets) margin.clone();
	430	+ }
	431	+
	432	+ /**
	433	+ * Returns the default icon.
	434	+ * @return the default <code>Icon</code>
	435	+ * @see #setIcon
	436	+ */
	437	+ public Icon getIcon() {
	438	+ return defaultIcon;
	439	+ }
	440	+
	441	+ /**
	442	+ * Sets the button's default icon. This icon is
	443	+ * also used as the "pressed" and "disabled" icon if
	444	+ * there is no explicitly set pressed icon.
	445	+ *
	446	+ * @param defaultIcon the icon used as the default image
	447	+ * @see #getIcon
	448	+ * @see #setPressedIcon
	449	+ * @beaninfo
	450	+ * bound: true
	451	+ * attribute: visualUpdate true
	452	+ * description: The button's default icon
	453	+ */
	454	+ public void setIcon(Icon defaultIcon) {
	455	+ Icon oldValue = this.defaultIcon;
	456	+ this.defaultIcon = defaultIcon;
	457	+
	458	+ /* If the default icon has really changed and we had
	459	+ * generated the disabled icon for this component,
	460	+ * (i.e. setDisabledIcon() was never called) then
	461	+ * clear the disabledIcon field.
	462	+ */
	463	+ if (defaultIcon != oldValue && (disabledIcon instanceof UIResource)) {
	464	+ disabledIcon = null;
	465	+ }
	466	+
	467	+ firePropertyChange(ICON_CHANGED_PROPERTY, oldValue, defaultIcon);
	468	+ if (accessibleContext != null) {
	469	+ accessibleContext.firePropertyChange(
	470	+ AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
	471	+ oldValue, defaultIcon);
	472	+ }
	473	+ if (defaultIcon != oldValue) {
	474	+ if (defaultIcon == null \|\| oldValue == null \|\|
	475	+ defaultIcon.getIconWidth() != oldValue.getIconWidth() \|\|
	476	+ defaultIcon.getIconHeight() != oldValue.getIconHeight()) {
	477	+ revalidate();
	478	+ }
	479	+ repaint();
	480	+ }
	481	+ }
	482	+
	483	+ /**
	484	+ * Returns the pressed icon for the button.
	485	+ * @return the <code>pressedIcon</code> property
	486	+ * @see #setPressedIcon
	487	+ */
	488	+ public Icon getPressedIcon() {
	489	+ return pressedIcon;
	490	+ }
	491	+
	492	+ /**
	493	+ * Sets the pressed icon for the button.
	494	+ * @param pressedIcon the icon used as the "pressed" image
	495	+ * @see #getPressedIcon
	496	+ * @beaninfo
	497	+ * bound: true
	498	+ * attribute: visualUpdate true
	499	+ * description: The pressed icon for the button.
	500	+ */
	501	+ public void setPressedIcon(Icon pressedIcon) {
	502	+ Icon oldValue = this.pressedIcon;
	503	+ this.pressedIcon = pressedIcon;
	504	+ firePropertyChange(PRESSED_ICON_CHANGED_PROPERTY, oldValue, pressedIcon);
	505	+ if (accessibleContext != null) {
	506	+ accessibleContext.firePropertyChange(
	507	+ AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
	508	+ oldValue, pressedIcon);
	509	+ }
	510	+ if (pressedIcon != oldValue) {
	511	+ if (getModel().isPressed()) {
	512	+ repaint();
	513	+ }
	514	+ }
	515	+ }
	516	+
	517	+ /**
	518	+ * Returns the selected icon for the button.
	519	+ * @return the <code>selectedIcon</code> property
	520	+ * @see #setSelectedIcon
	521	+ */
	522	+ public Icon getSelectedIcon() {
	523	+ return selectedIcon;
	524	+ }
	525	+
	526	+ /**
	527	+ * Sets the selected icon for the button.
	528	+ * @param selectedIcon the icon used as the "selected" image
	529	+ * @see #getSelectedIcon
	530	+ * @beaninfo
	531	+ * bound: true
	532	+ * attribute: visualUpdate true
	533	+ * description: The selected icon for the button.
	534	+ */
	535	+ public void setSelectedIcon(Icon selectedIcon) {
	536	+ Icon oldValue = this.selectedIcon;
	537	+ this.selectedIcon = selectedIcon;
	538	+
	539	+ /* If the default selected icon has really changed and we had
	540	+ * generated the disabled selected icon for this component,
	541	+ * (i.e. setDisabledSelectedIcon() was never called) then
	542	+ * clear the disabledSelectedIcon field.
	543	+ */
	544	+ if (selectedIcon != oldValue &&
	545	+ disabledSelectedIcon instanceof UIResource) {
	546	+
	547	+ disabledSelectedIcon = null;
	548	+ }
	549	+
	550	+ firePropertyChange(SELECTED_ICON_CHANGED_PROPERTY, oldValue, selectedIcon);
	551	+ if (accessibleContext != null) {
	552	+ accessibleContext.firePropertyChange(
	553	+ AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
	554	+ oldValue, selectedIcon);
	555	+ }
	556	+ if (selectedIcon != oldValue) {
	557	+ if (isSelected()) {
	558	+ repaint();
	559	+ }
	560	+ }
	561	+ }
	562	+
	563	+ /**
	564	+ * Returns the rollover icon for the button.
	565	+ * @return the <code>rolloverIcon</code> property
	566	+ * @see #setRolloverIcon
	567	+ */
	568	+ public Icon getRolloverIcon() {
	569	+ return rolloverIcon;
	570	+ }
	571	+
	572	+ /**
	573	+ * Sets the rollover icon for the button.
	574	+ * @param rolloverIcon the icon used as the "rollover" image
	575	+ * @see #getRolloverIcon
	576	+ * @beaninfo
	577	+ * bound: true
	578	+ * attribute: visualUpdate true
	579	+ * description: The rollover icon for the button.
	580	+ */
	581	+ public void setRolloverIcon(Icon rolloverIcon) {
	582	+ Icon oldValue = this.rolloverIcon;
	583	+ this.rolloverIcon = rolloverIcon;
	584	+ firePropertyChange(ROLLOVER_ICON_CHANGED_PROPERTY, oldValue, rolloverIcon);
	585	+ if (accessibleContext != null) {
	586	+ accessibleContext.firePropertyChange(
	587	+ AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
	588	+ oldValue, rolloverIcon);
	589	+ }
	590	+ setRolloverEnabled(true);
	591	+ if (rolloverIcon != oldValue) {
	592	+ // No way to determine whether we are currently in
	593	+ // a rollover state, so repaint regardless
	594	+ repaint();
	595	+ }
	596	+
	597	+ }
	598	+
	599	+ /**
	600	+ * Returns the rollover selection icon for the button.
	601	+ * @return the <code>rolloverSelectedIcon</code> property
	602	+ * @see #setRolloverSelectedIcon
	603	+ */
	604	+ public Icon getRolloverSelectedIcon() {
	605	+ return rolloverSelectedIcon;
	606	+ }
	607	+
	608	+ /**
	609	+ * Sets the rollover selected icon for the button.
	610	+ * @param rolloverSelectedIcon the icon used as the
	611	+ * "selected rollover" image
	612	+ * @see #getRolloverSelectedIcon
	613	+ * @beaninfo
	614	+ * bound: true
	615	+ * attribute: visualUpdate true
	616	+ * description: The rollover selected icon for the button.
	617	+ */
	618	+ public void setRolloverSelectedIcon(Icon rolloverSelectedIcon) {
	619	+ Icon oldValue = this.rolloverSelectedIcon;
	620	+ this.rolloverSelectedIcon = rolloverSelectedIcon;
	621	+ firePropertyChange(ROLLOVER_SELECTED_ICON_CHANGED_PROPERTY, oldValue, rolloverSelectedIcon);
	622	+ if (accessibleContext != null) {
	623	+ accessibleContext.firePropertyChange(
	624	+ AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
	625	+ oldValue, rolloverSelectedIcon);
	626	+ }
	627	+ setRolloverEnabled(true);
	628	+ if (rolloverSelectedIcon != oldValue) {
	629	+ // No way to determine whether we are currently in
	630	+ // a rollover state, so repaint regardless
	631	+ if (isSelected()) {
	632	+ repaint();
	633	+ }
	634	+ }
	635	+ }
	636	+
	637	+ /**
	638	+ * Returns the icon used by the button when it's disabled.
	639	+ * If no disabled icon has been set this will forward the call to
	640	+ * the look and feel to construct an appropriate disabled Icon.
	641	+ * <p>
	642	+ * Some look and feels might not render the disabled Icon, in which
	643	+ * case they will ignore this.
	644	+ *
	645	+ * @return the <code>disabledIcon</code> property
	646	+ * @see #getPressedIcon
	647	+ * @see #setDisabledIcon
	648	+ * @see javax.swing.LookAndFeel#getDisabledIcon
	649	+ */
	650	+ @Transient
	651	+ public Icon getDisabledIcon() {
	652	+ if (disabledIcon == null) {
	653	+ disabledIcon = UIManager.getLookAndFeel().getDisabledIcon(this, getIcon());
	654	+ if (disabledIcon != null) {
	655	+ firePropertyChange(DISABLED_ICON_CHANGED_PROPERTY, null, disabledIcon);
	656	+ }
	657	+ }
	658	+ return disabledIcon;
	659	+ }
	660	+
	661	+ /**
	662	+ * Sets the disabled icon for the button.
	663	+ * @param disabledIcon the icon used as the disabled image
	664	+ * @see #getDisabledIcon
	665	+ * @beaninfo
	666	+ * bound: true
	667	+ * attribute: visualUpdate true
	668	+ * description: The disabled icon for the button.
	669	+ */
	670	+ public void setDisabledIcon(Icon disabledIcon) {
	671	+ Icon oldValue = this.disabledIcon;
	672	+ this.disabledIcon = disabledIcon;
	673	+ firePropertyChange(DISABLED_ICON_CHANGED_PROPERTY, oldValue, disabledIcon);
	674	+ if (accessibleContext != null) {
	675	+ accessibleContext.firePropertyChange(
	676	+ AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
	677	+ oldValue, disabledIcon);
	678	+ }
	679	+ if (disabledIcon != oldValue) {
	680	+ if (!isEnabled()) {
	681	+ repaint();
	682	+ }
	683	+ }
	684	+ }
	685	+
	686	+ /**
	687	+ * Returns the icon used by the button when it's disabled and selected.
	688	+ * If no disabled selection icon has been set, this will forward
	689	+ * the call to the LookAndFeel to construct an appropriate disabled
	690	+ * Icon from the selection icon if it has been set and to
	691	+ * <code>getDisabledIcon()</code> otherwise.
	692	+ * <p>
	693	+ * Some look and feels might not render the disabled selected Icon, in
	694	+ * which case they will ignore this.
	695	+ *
	696	+ * @return the <code>disabledSelectedIcon</code> property
	697	+ * @see #getDisabledIcon
	698	+ * @see #setDisabledSelectedIcon
	699	+ * @see javax.swing.LookAndFeel#getDisabledSelectedIcon
	700	+ */
	701	+ public Icon getDisabledSelectedIcon() {
	702	+ if (disabledSelectedIcon == null) {
	703	+ if (selectedIcon != null) {
	704	+ disabledSelectedIcon = UIManager.getLookAndFeel().
	705	+ getDisabledSelectedIcon(this, getSelectedIcon());
	706	+ } else {
	707	+ return getDisabledIcon();
	708	+ }
	709	+ }
	710	+ return disabledSelectedIcon;
	711	+ }
	712	+
	713	+ /**
	714	+ * Sets the disabled selection icon for the button.
	715	+ * @param disabledSelectedIcon the icon used as the disabled
	716	+ * selection image
	717	+ * @see #getDisabledSelectedIcon
	718	+ * @beaninfo
	719	+ * bound: true
	720	+ * attribute: visualUpdate true
	721	+ * description: The disabled selection icon for the button.
	722	+ */
	723	+ public void setDisabledSelectedIcon(Icon disabledSelectedIcon) {
	724	+ Icon oldValue = this.disabledSelectedIcon;
	725	+ this.disabledSelectedIcon = disabledSelectedIcon;
	726	+ firePropertyChange(DISABLED_SELECTED_ICON_CHANGED_PROPERTY, oldValue, disabledSelectedIcon);
	727	+ if (accessibleContext != null) {
	728	+ accessibleContext.firePropertyChange(
	729	+ AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
	730	+ oldValue, disabledSelectedIcon);
	731	+ }
	732	+ if (disabledSelectedIcon != oldValue) {
	733	+ if (disabledSelectedIcon == null \|\| oldValue == null \|\|
	734	+ disabledSelectedIcon.getIconWidth() != oldValue.getIconWidth() \|\|
	735	+ disabledSelectedIcon.getIconHeight() != oldValue.getIconHeight()) {
	736	+ revalidate();
	737	+ }
	738	+ if (!isEnabled() && isSelected()) {
	739	+ repaint();
	740	+ }
	741	+ }
	742	+ }
	743	+
	744	+ /**
	745	+ * Returns the vertical alignment of the text and icon.
	746	+ *
	747	+ * @return the <code>verticalAlignment</code> property, one of the
	748	+ * following values:
	749	+ * <ul>
	750	+ * <li>{@code SwingConstants.CENTER} (the default)
	751	+ * <li>{@code SwingConstants.TOP}
	752	+ * <li>{@code SwingConstants.BOTTOM}
	753	+ * </ul>
	754	+ */
	755	+ public int getVerticalAlignment() {
	756	+ return verticalAlignment;
	757	+ }
	758	+
	759	+ /**
	760	+ * Sets the vertical alignment of the icon and text.
	761	+ * @param alignment one of the following values:
	762	+ * <ul>
	763	+ * <li>{@code SwingConstants.CENTER} (the default)
	764	+ * <li>{@code SwingConstants.TOP}
	765	+ * <li>{@code SwingConstants.BOTTOM}
	766	+ * </ul>
	767	+ * @throws IllegalArgumentException if the alignment is not one of the legal
	768	+ * values listed above
	769	+ * @beaninfo
	770	+ * bound: true
	771	+ * enum: TOP SwingConstants.TOP
	772	+ * CENTER SwingConstants.CENTER
	773	+ * BOTTOM SwingConstants.BOTTOM
	774	+ * attribute: visualUpdate true
	775	+ * description: The vertical alignment of the icon and text.
	776	+ */
	777	+ public void setVerticalAlignment(int alignment) {
	778	+ if (alignment == verticalAlignment) return;
	779	+ int oldValue = verticalAlignment;
	780	+ verticalAlignment = checkVerticalKey(alignment, "verticalAlignment");
	781	+ firePropertyChange(VERTICAL_ALIGNMENT_CHANGED_PROPERTY, oldValue, verticalAlignment); repaint();
	782	+ }
	783	+
	784	+ /**
	785	+ * Returns the horizontal alignment of the icon and text.
	786	+ * {@code AbstractButton}'s default is {@code SwingConstants.CENTER},
	787	+ * but subclasses such as {@code JCheckBox} may use a different default.
	788	+ *
	789	+ * @return the <code>horizontalAlignment</code> property,
	790	+ * one of the following values:
	791	+ * <ul>
	792	+ * <li>{@code SwingConstants.RIGHT}
	793	+ * <li>{@code SwingConstants.LEFT}
	794	+ * <li>{@code SwingConstants.CENTER}
	795	+ * <li>{@code SwingConstants.LEADING}
	796	+ * <li>{@code SwingConstants.TRAILING}
	797	+ * </ul>
	798	+ */
	799	+ public int getHorizontalAlignment() {
	800	+ return horizontalAlignment;
	801	+ }
	802	+
	803	+ /**
	804	+ * Sets the horizontal alignment of the icon and text.
	805	+ * {@code AbstractButton}'s default is {@code SwingConstants.CENTER},
	806	+ * but subclasses such as {@code JCheckBox} may use a different default.
	807	+ *
	808	+ * @param alignment the alignment value, one of the following values:
	809	+ * <ul>
	810	+ * <li>{@code SwingConstants.RIGHT}
	811	+ * <li>{@code SwingConstants.LEFT}
	812	+ * <li>{@code SwingConstants.CENTER}
	813	+ * <li>{@code SwingConstants.LEADING}
	814	+ * <li>{@code SwingConstants.TRAILING}
	815	+ * </ul>
	816	+ * @throws IllegalArgumentException if the alignment is not one of the
	817	+ * valid values
	818	+ * @beaninfo
	819	+ * bound: true
	820	+ * enum: LEFT SwingConstants.LEFT
	821	+ * CENTER SwingConstants.CENTER
	822	+ * RIGHT SwingConstants.RIGHT
	823	+ * LEADING SwingConstants.LEADING
	824	+ * TRAILING SwingConstants.TRAILING
	825	+ * attribute: visualUpdate true
	826	+ * description: The horizontal alignment of the icon and text.
	827	+ */
	828	+ public void setHorizontalAlignment(int alignment) {
	829	+ if (alignment == horizontalAlignment) return;
	830	+ int oldValue = horizontalAlignment;
	831	+ horizontalAlignment = checkHorizontalKey(alignment,
	832	+ "horizontalAlignment");
	833	+ firePropertyChange(HORIZONTAL_ALIGNMENT_CHANGED_PROPERTY,
	834	+ oldValue, horizontalAlignment);
	835	+ repaint();
	836	+ }
	837	+
	838	+
	839	+ /**
	840	+ * Returns the vertical position of the text relative to the icon.
	841	+ * @return the <code>verticalTextPosition</code> property,
	842	+ * one of the following values:
	843	+ * <ul>
	844	+ * <li>{@code SwingConstants.CENTER} (the default)
	845	+ * <li>{@code SwingConstants.TOP}
	846	+ * <li>{@code SwingConstants.BOTTOM}
	847	+ * </ul>
	848	+ */
	849	+ public int getVerticalTextPosition() {
	850	+ return verticalTextPosition;
	851	+ }
	852	+
	853	+ /**
	854	+ * Sets the vertical position of the text relative to the icon.
	855	+ * @param textPosition one of the following values:
	856	+ * <ul>
	857	+ * <li>{@code SwingConstants.CENTER} (the default)
	858	+ * <li>{@code SwingConstants.TOP}
	859	+ * <li>{@code SwingConstants.BOTTOM}
	860	+ * </ul>
	861	+ * @beaninfo
	862	+ * bound: true
	863	+ * enum: TOP SwingConstants.TOP
	864	+ * CENTER SwingConstants.CENTER
	865	+ * BOTTOM SwingConstants.BOTTOM
	866	+ * attribute: visualUpdate true
	867	+ * description: The vertical position of the text relative to the icon.
	868	+ */
	869	+ public void setVerticalTextPosition(int textPosition) {
	870	+ if (textPosition == verticalTextPosition) return;
	871	+ int oldValue = verticalTextPosition;
	872	+ verticalTextPosition = checkVerticalKey(textPosition, "verticalTextPosition");
	873	+ firePropertyChange(VERTICAL_TEXT_POSITION_CHANGED_PROPERTY, oldValue, verticalTextPosition);
	874	+ revalidate();
	875	+ repaint();
	876	+ }
	877	+
	878	+ /**
	879	+ * Returns the horizontal position of the text relative to the icon.
	880	+ * @return the <code>horizontalTextPosition</code> property,
	881	+ * one of the following values:
	882	+ * <ul>
	883	+ * <li>{@code SwingConstants.RIGHT}
	884	+ * <li>{@code SwingConstants.LEFT}
	885	+ * <li>{@code SwingConstants.CENTER}
	886	+ * <li>{@code SwingConstants.LEADING}
	887	+ * <li>{@code SwingConstants.TRAILING} (the default)
	888	+ * </ul>
	889	+ */
	890	+ public int getHorizontalTextPosition() {
	891	+ return horizontalTextPosition;
	892	+ }
	893	+
	894	+ /**
	895	+ * Sets the horizontal position of the text relative to the icon.
	896	+ * @param textPosition one of the following values:
	897	+ * <ul>
	898	+ * <li>{@code SwingConstants.RIGHT}
	899	+ * <li>{@code SwingConstants.LEFT}
	900	+ * <li>{@code SwingConstants.CENTER}
	901	+ * <li>{@code SwingConstants.LEADING}
	902	+ * <li>{@code SwingConstants.TRAILING} (the default)
	903	+ * </ul>
	904	+ * @exception IllegalArgumentException if <code>textPosition</code>
	905	+ * is not one of the legal values listed above
	906	+ * @beaninfo
	907	+ * bound: true
	908	+ * enum: LEFT SwingConstants.LEFT
	909	+ * CENTER SwingConstants.CENTER
	910	+ * RIGHT SwingConstants.RIGHT
	911	+ * LEADING SwingConstants.LEADING
	912	+ * TRAILING SwingConstants.TRAILING
	913	+ * attribute: visualUpdate true
	914	+ * description: The horizontal position of the text relative to the icon.
	915	+ */
	916	+ public void setHorizontalTextPosition(int textPosition) {
	917	+ if (textPosition == horizontalTextPosition) return;
	918	+ int oldValue = horizontalTextPosition;
	919	+ horizontalTextPosition = checkHorizontalKey(textPosition,
	920	+ "horizontalTextPosition");
	921	+ firePropertyChange(HORIZONTAL_TEXT_POSITION_CHANGED_PROPERTY,
	922	+ oldValue,
	923	+ horizontalTextPosition);
	924	+ revalidate();
	925	+ repaint();
	926	+ }
	927	+
	928	+ /**
	929	+ * Returns the amount of space between the text and the icon
	930	+ * displayed in this button.
	931	+ *
	932	+ * @return an int equal to the number of pixels between the text
	933	+ * and the icon.
	934	+ * @since 1.4
	935	+ * @see #setIconTextGap
	936	+ */
	937	+ public int getIconTextGap() {
	938	+ return iconTextGap;
	939	+ }
	940	+
	941	+ /**
	942	+ * If both the icon and text properties are set, this property
	943	+ * defines the space between them.
	944	+ * <p>
	945	+ * The default value of this property is 4 pixels.
	946	+ * <p>
	947	+ * This is a JavaBeans bound property.
	948	+ *
	949	+ * @since 1.4
	950	+ * @see #getIconTextGap
	951	+ * @beaninfo
	952	+ * bound: true
	953	+ * attribute: visualUpdate true
	954	+ * description: If both the icon and text properties are set, this
	955	+ * property defines the space between them.
	956	+ */
	957	+ public void setIconTextGap(int iconTextGap) {
	958	+ int oldValue = this.iconTextGap;
	959	+ this.iconTextGap = iconTextGap;
	960	+ iconTextGapSet = true;
	961	+ firePropertyChange("iconTextGap", oldValue, iconTextGap);
	962	+ if (iconTextGap != oldValue) {
	963	+ revalidate();
	964	+ repaint();
	965	+ }
	966	+ }
	967	+
	968	+ /**
	969	+ * Verify that the {@code key} argument is a legal value for the
	970	+ * {@code horizontalAlignment} and {@code horizontalTextPosition}
	971	+ * properties. Valid values are:
	972	+ * <ul>
	973	+ * <li>{@code SwingConstants.RIGHT}
	974	+ * <li>{@code SwingConstants.LEFT}
	975	+ * <li>{@code SwingConstants.CENTER}
	976	+ * <li>{@code SwingConstants.LEADING}
	977	+ * <li>{@code SwingConstants.TRAILING}
	978	+ * </ul>
	979	+ *
	980	+ * @param key the property value to check
	981	+ * @param exception the message to use in the
	982	+ * {@code IllegalArgumentException} that is thrown for an invalid
	983	+ * value
	984	+ * @exception IllegalArgumentException if key is not one of the legal
	985	+ * values listed above
	986	+ * @see #setHorizontalTextPosition
	987	+ * @see #setHorizontalAlignment
	988	+ */
	989	+ protected int checkHorizontalKey(int key, String exception) {
	990	+ if ((key == LEFT) \|\|
	991	+ (key == CENTER) \|\|
	992	+ (key == RIGHT) \|\|
	993	+ (key == LEADING) \|\|
	994	+ (key == TRAILING)) {
	995	+ return key;
	996	+ } else {
	997	+ throw new IllegalArgumentException(exception);
	998	+ }
	999	+ }
	1000	+
	1001	+ /**
	1002	+ * Verify that the {@code key} argument is a legal value for the
	1003	+ * vertical properties. Valid values are:
	1004	+ * <ul>
	1005	+ * <li>{@code SwingConstants.CENTER}
	1006	+ * <li>{@code SwingConstants.TOP}
	1007	+ * <li>{@code SwingConstants.BOTTOM}
	1008	+ * </ul>
	1009	+ *
	1010	+ * @param key the property value to check
	1011	+ * @param exception the message to use in the
	1012	+ * {@code IllegalArgumentException} that is thrown for an invalid
	1013	+ * value
	1014	+ * @exception IllegalArgumentException if key is not one of the legal
	1015	+ * values listed above
	1016	+ */
	1017	+ protected int checkVerticalKey(int key, String exception) {
	1018	+ if ((key == TOP) \|\| (key == CENTER) \|\| (key == BOTTOM)) {
	1019	+ return key;
	1020	+ } else {
	1021	+ throw new IllegalArgumentException(exception);
	1022	+ }
	1023	+ }
	1024	+
	1025	+ /**
	1026	+ *{@inheritDoc}
	1027	+ *
	1028	+ * @since 1.6
	1029	+ */
	1030	+ public void removeNotify() {
	1031	+ super.removeNotify();
	1032	+ if(isRolloverEnabled()) {
	1033	+ getModel().setRollover(false);
	1034	+ }
	1035	+ }
	1036	+
	1037	+ /**
	1038	+ * Sets the action command for this button.
	1039	+ * @param actionCommand the action command for this button
	1040	+ */
	1041	+ public void setActionCommand(String actionCommand) {
	1042	+ getModel().setActionCommand(actionCommand);
	1043	+ }
	1044	+
	1045	+ /**
	1046	+ * Returns the action command for this button.
	1047	+ * @return the action command for this button
	1048	+ */
	1049	+ public String getActionCommand() {
	1050	+ String ac = getModel().getActionCommand();
	1051	+ if(ac == null) {
	1052	+ ac = getText();
	1053	+ }
	1054	+ return ac;
	1055	+ }
	1056	+
	1057	+ private Action action;
	1058	+ private PropertyChangeListener actionPropertyChangeListener;
	1059	+
	1060	+ /**
	1061	+ * Sets the <code>Action</code>.
	1062	+ * The new <code>Action</code> replaces any previously set
	1063	+ * <code>Action</code> but does not affect <code>ActionListeners</code>
	1064	+ * independently added with <code>addActionListener</code>.
	1065	+ * If the <code>Action</code> is already a registered
	1066	+ * <code>ActionListener</code> for the button, it is not re-registered.
	1067	+ * <p>
	1068	+ * Setting the <code>Action</code> results in immediately changing
	1069	+ * all the properties described in <a href="Action.html#buttonActions">
	1070	+ * Swing Components Supporting <code>Action</code></a>.
	1071	+ * Subsequently, the button's properties are automatically updated
	1072	+ * as the <code>Action</code>'s properties change.
	1073	+ * <p>
	1074	+ * This method uses three other methods to set
	1075	+ * and help track the <code>Action</code>'s property values.
	1076	+ * It uses the <code>configurePropertiesFromAction</code> method
	1077	+ * to immediately change the button's properties.
	1078	+ * To track changes in the <code>Action</code>'s property values,
	1079	+ * this method registers the <code>PropertyChangeListener</code>
	1080	+ * returned by <code>createActionPropertyChangeListener</code>. The
	1081	+ * default {@code PropertyChangeListener} invokes the
	1082	+ * {@code actionPropertyChanged} method when a property in the
	1083	+ * {@code Action} changes.
	1084	+ *
	1085	+ * @param a the <code>Action</code> for the <code>AbstractButton</code>,
	1086	+ * or <code>null</code>
	1087	+ * @since 1.3
	1088	+ * @see Action
	1089	+ * @see #getAction
	1090	+ * @see #configurePropertiesFromAction
	1091	+ * @see #createActionPropertyChangeListener
	1092	+ * @see #actionPropertyChanged
	1093	+ * @beaninfo
	1094	+ * bound: true
	1095	+ * attribute: visualUpdate true
	1096	+ * description: the Action instance connected with this ActionEvent source
	1097	+ */
	1098	+ public void setAction(Action a) {
	1099	+ Action oldValue = getAction();
	1100	+ if (action==null \|\| !action.equals(a)) {
	1101	+ action = a;
	1102	+ if (oldValue!=null) {
	1103	+ removeActionListener(oldValue);
	1104	+ oldValue.removePropertyChangeListener(actionPropertyChangeListener);
	1105	+ actionPropertyChangeListener = null;
	1106	+ }
	1107	+ configurePropertiesFromAction(action);
	1108	+ if (action!=null) {
	1109	+ // Don't add if it is already a listener
	1110	+ if (!isListener(ActionListener.class, action)) {
	1111	+ addActionListener(action);
	1112	+ }
	1113	+ // Reverse linkage:
	1114	+ actionPropertyChangeListener = createActionPropertyChangeListener(action);
	1115	+ action.addPropertyChangeListener(actionPropertyChangeListener);
	1116	+ }
	1117	+ firePropertyChange("action", oldValue, action);
	1118	+ }
	1119	+ }
	1120	+
	1121	+ private boolean isListener(Class c, ActionListener a) {
	1122	+ boolean isListener = false;
	1123	+ Object[] listeners = listenerList.getListenerList();
	1124	+ for (int i = listeners.length-2; i>=0; i-=2) {
	1125	+ if (listeners[i]==c && listeners[i+1]==a) {
	1126	+ isListener=true;
	1127	+ }
	1128	+ }
	1129	+ return isListener;
	1130	+ }
	1131	+
	1132	+ /**
	1133	+ * Returns the currently set <code>Action</code> for this
	1134	+ * <code>ActionEvent</code> source, or <code>null</code>
	1135	+ * if no <code>Action</code> is set.
	1136	+ *
	1137	+ * @return the <code>Action</code> for this <code>ActionEvent</code>
	1138	+ * source, or <code>null</code>
	1139	+ * @since 1.3
	1140	+ * @see Action
	1141	+ * @see #setAction
	1142	+ */
	1143	+ public Action getAction() {
	1144	+ return action;
	1145	+ }
	1146	+
	1147	+ /**
	1148	+ * Sets the properties on this button to match those in the specified
	1149	+ * <code>Action</code>. Refer to <a href="Action.html#buttonActions">
	1150	+ * Swing Components Supporting <code>Action</code></a> for more
	1151	+ * details as to which properties this sets.
	1152	+ *
	1153	+ * @param a the <code>Action</code> from which to get the properties,
	1154	+ * or <code>null</code>
	1155	+ * @since 1.3
	1156	+ * @see Action
	1157	+ * @see #setAction
	1158	+ */
	1159	+ protected void configurePropertiesFromAction(Action a) {
	1160	+ setMnemonicFromAction(a);
	1161	+ setTextFromAction(a, false);
	1162	+ AbstractAction.setToolTipTextFromAction(this, a);
	1163	+ setIconFromAction(a);
	1164	+ setActionCommandFromAction(a);
	1165	+ AbstractAction.setEnabledFromAction(this, a);
	1166	+ if (AbstractAction.hasSelectedKey(a) &&
	1167	+ shouldUpdateSelectedStateFromAction()) {
	1168	+ setSelectedFromAction(a);
	1169	+ }
	1170	+ setDisplayedMnemonicIndexFromAction(a, false);
	1171	+ }
	1172	+
	1173	+ void clientPropertyChanged(Object key, Object oldValue,
	1174	+ Object newValue) {
	1175	+ if (key == "hideActionText") {
	1176	+ boolean current = (newValue instanceof Boolean) ?
	1177	+ (Boolean)newValue : false;
	1178	+ if (getHideActionText() != current) {
	1179	+ setHideActionText(current);
	1180	+ }
	1181	+ }
	1182	+ }
	1183	+
	1184	+ /**
	1185	+ * Button subclasses that support mirroring the selected state from
	1186	+ * the action should override this to return true. AbstractButton's
	1187	+ * implementation returns false.
	1188	+ */
	1189	+ boolean shouldUpdateSelectedStateFromAction() {
	1190	+ return false;
	1191	+ }
	1192	+
	1193	+ /**
	1194	+ * Updates the button's state in response to property changes in the
	1195	+ * associated action. This method is invoked from the
	1196	+ * {@code PropertyChangeListener} returned from
	1197	+ * {@code createActionPropertyChangeListener}. Subclasses do not normally
	1198	+ * need to invoke this. Subclasses that support additional {@code Action}
	1199	+ * properties should override this and
	1200	+ * {@code configurePropertiesFromAction}.
	1201	+ * <p>
	1202	+ * Refer to the table at <a href="Action.html#buttonActions">
	1203	+ * Swing Components Supporting <code>Action</code></a> for a list of
	1204	+ * the properties this method sets.
	1205	+ *
	1206	+ * @param action the <code>Action</code> associated with this button
	1207	+ * @param propertyName the name of the property that changed
	1208	+ * @since 1.6
	1209	+ * @see Action
	1210	+ * @see #configurePropertiesFromAction
	1211	+ */
	1212	+ protected void actionPropertyChanged(Action action, String propertyName) {
	1213	+ if (propertyName == Action.NAME) {
	1214	+ setTextFromAction(action, true);
	1215	+ } else if (propertyName == "enabled") {
	1216	+ AbstractAction.setEnabledFromAction(this, action);
	1217	+ } else if (propertyName == Action.SHORT_DESCRIPTION) {
	1218	+ AbstractAction.setToolTipTextFromAction(this, action);
	1219	+ } else if (propertyName == Action.SMALL_ICON) {
	1220	+ smallIconChanged(action);
	1221	+ } else if (propertyName == Action.MNEMONIC_KEY) {
	1222	+ setMnemonicFromAction(action);
	1223	+ } else if (propertyName == Action.ACTION_COMMAND_KEY) {
	1224	+ setActionCommandFromAction(action);
	1225	+ } else if (propertyName == Action.SELECTED_KEY &&
	1226	+ AbstractAction.hasSelectedKey(action) &&
	1227	+ shouldUpdateSelectedStateFromAction()) {
	1228	+ setSelectedFromAction(action);
	1229	+ } else if (propertyName == Action.DISPLAYED_MNEMONIC_INDEX_KEY) {
	1230	+ setDisplayedMnemonicIndexFromAction(action, true);
	1231	+ } else if (propertyName == Action.LARGE_ICON_KEY) {
	1232	+ largeIconChanged(action);
	1233	+ }
	1234	+ }
	1235	+
	1236	+ private void setDisplayedMnemonicIndexFromAction(
	1237	+ Action a, boolean fromPropertyChange) {
	1238	+ Integer iValue = (a == null) ? null :
	1239	+ (Integer)a.getValue(Action.DISPLAYED_MNEMONIC_INDEX_KEY);
	1240	+ if (fromPropertyChange \|\| iValue != null) {
	1241	+ int value;
	1242	+ if (iValue == null) {
	1243	+ value = -1;
	1244	+ } else {
	1245	+ value = iValue;
	1246	+ String text = getText();
	1247	+ if (text == null \|\| value >= text.length()) {
	1248	+ value = -1;
	1249	+ }
	1250	+ }
	1251	+ setDisplayedMnemonicIndex(value);
	1252	+ }
	1253	+ }
	1254	+
	1255	+ private void setMnemonicFromAction(Action a) {
	1256	+ Integer n = (a == null) ? null :
	1257	+ (Integer)a.getValue(Action.MNEMONIC_KEY);
	1258	+ setMnemonic((n == null) ? '\0' : n);
	1259	+ }
	1260	+
	1261	+ private void setTextFromAction(Action a, boolean propertyChange) {
	1262	+ boolean hideText = getHideActionText();
	1263	+ if (!propertyChange) {
	1264	+ setText((a != null && !hideText) ?
	1265	+ (String)a.getValue(Action.NAME) : null);
	1266	+ }
	1267	+ else if (!hideText) {
	1268	+ setText((String)a.getValue(Action.NAME));
	1269	+ }
	1270	+ }
	1271	+
	1272	+ void setIconFromAction(Action a) {
	1273	+ Icon icon = null;
	1274	+ if (a != null) {
	1275	+ icon = (Icon)a.getValue(Action.LARGE_ICON_KEY);
	1276	+ if (icon == null) {
	1277	+ icon = (Icon)a.getValue(Action.SMALL_ICON);
	1278	+ }
	1279	+ }
	1280	+ setIcon(icon);
	1281	+ }
	1282	+
	1283	+ void smallIconChanged(Action a) {
	1284	+ if (a.getValue(Action.LARGE_ICON_KEY) == null) {
	1285	+ setIconFromAction(a);
	1286	+ }
	1287	+ }
	1288	+
	1289	+ void largeIconChanged(Action a) {
	1290	+ setIconFromAction(a);
	1291	+ }
	1292	+
	1293	+ private void setActionCommandFromAction(Action a) {
	1294	+ setActionCommand((a != null) ?
	1295	+ (String)a.getValue(Action.ACTION_COMMAND_KEY) :
	1296	+ null);
	1297	+ }
	1298	+
	1299	+ /**
	1300	+ * Sets the seleted state of the button from the action. This is defined
	1301	+ * here, but not wired up. Subclasses like JToggleButton and
	1302	+ * JCheckBoxMenuItem make use of it.
	1303	+ *
	1304	+ * @param a the Action
	1305	+ */
	1306	+ private void setSelectedFromAction(Action a) {
	1307	+ boolean selected = false;
	1308	+ if (a != null) {
	1309	+ selected = AbstractAction.isSelected(a);
	1310	+ }
	1311	+ if (selected != isSelected()) {
	1312	+ // This won't notify ActionListeners, but that should be
	1313	+ // ok as the change is coming from the Action.
	1314	+ setSelected(selected);
	1315	+ // Make sure the change actually took effect
	1316	+ if (!selected && isSelected()) {
	1317	+ if (getModel() instanceof DefaultButtonModel) {
	1318	+ ButtonGroup group = ((DefaultButtonModel)getModel()).getGroup();
	1319	+ if (group != null) {
	1320	+ group.clearSelection();
	1321	+ }
	1322	+ }
	1323	+ }
	1324	+ }
	1325	+ }
	1326	+
	1327	+ /**
	1328	+ * Creates and returns a <code>PropertyChangeListener</code> that is
	1329	+ * responsible for listening for changes from the specified
	1330	+ * <code>Action</code> and updating the appropriate properties.
	1331	+ * <p>
	1332	+ * <b>Warning:</b> If you subclass this do not create an anonymous
	1333	+ * inner class. If you do the lifetime of the button will be tied to
	1334	+ * that of the <code>Action</code>.
	1335	+ *
	1336	+ * @param a the button's action
	1337	+ * @since 1.3
	1338	+ * @see Action
	1339	+ * @see #setAction
	1340	+ */
	1341	+ protected PropertyChangeListener createActionPropertyChangeListener(Action a) {
	1342	+ return createActionPropertyChangeListener0(a);
	1343	+ }
	1344	+
	1345	+
	1346	+ PropertyChangeListener createActionPropertyChangeListener0(Action a) {
	1347	+ return new ButtonActionPropertyChangeListener(this, a);
	1348	+ }
	1349	+
	1350	+ private static class ButtonActionPropertyChangeListener
	1351	+ extends ActionPropertyChangeListener<AbstractButton> {
	1352	+ ButtonActionPropertyChangeListener(AbstractButton b, Action a) {
	1353	+ super(b, a);
	1354	+ }
	1355	+ protected void actionPropertyChanged(AbstractButton button,
	1356	+ Action action,
	1357	+ PropertyChangeEvent e) {
	1358	+ if (AbstractAction.shouldReconfigure(e)) {
	1359	+ button.configurePropertiesFromAction(action);
	1360	+ } else {
	1361	+ button.actionPropertyChanged(action, e.getPropertyName());
	1362	+ }
	1363	+ }
	1364	+ }
	1365	+
	1366	+ /**
	1367	+ * Gets the <code>borderPainted</code> property.
	1368	+ *
	1369	+ * @return the value of the <code>borderPainted</code> property
	1370	+ * @see #setBorderPainted
	1371	+ */
	1372	+ public boolean isBorderPainted() {
	1373	+ return paintBorder;
	1374	+ }
	1375	+
	1376	+ /**
	1377	+ * Sets the <code>borderPainted</code> property.
	1378	+ * If <code>true</code> and the button has a border,
	1379	+ * the border is painted. The default value for the
	1380	+ * <code>borderPainted</code> property is <code>true</code>.
	1381	+ * <p/>
	1382	+ * Some look and feels might not support
	1383	+ * the <code>borderPainted</code> property,
	1384	+ * in which case they ignore this.
	1385	+ *
	1386	+ * @param b if true and border property is not <code>null</code>,
	1387	+ * the border is painted
	1388	+ * @see #isBorderPainted
	1389	+ * @beaninfo
	1390	+ * bound: true
	1391	+ * attribute: visualUpdate true
	1392	+ * description: Whether the border should be painted.
	1393	+ */
	1394	+ public void setBorderPainted(boolean b) {
	1395	+ boolean oldValue = paintBorder;
	1396	+ paintBorder = b;
	1397	+ borderPaintedSet = true;
	1398	+ firePropertyChange(BORDER_PAINTED_CHANGED_PROPERTY, oldValue, paintBorder);
	1399	+ if (b != oldValue) {
	1400	+ revalidate();
	1401	+ repaint();
	1402	+ }
	1403	+ }
	1404	+
	1405	+ /**
	1406	+ * Paint the button's border if <code>BorderPainted</code>
	1407	+ * property is true and the button has a border.
	1408	+ * @param g the <code>Graphics</code> context in which to paint
	1409	+ *
	1410	+ * @see #paint
	1411	+ * @see #setBorder
	1412	+ */
	1413	+ protected void paintBorder(Graphics g) {
	1414	+ if (isBorderPainted()) {
	1415	+ super.paintBorder(g);
	1416	+ }
	1417	+ }
	1418	+
	1419	+ /**
	1420	+ * Gets the <code>paintFocus</code> property.
	1421	+ *
	1422	+ * @return the <code>paintFocus</code> property
	1423	+ * @see #setFocusPainted
	1424	+ */
	1425	+ public boolean isFocusPainted() {
	1426	+ return paintFocus;
	1427	+ }
	1428	+
	1429	+ /**
	1430	+ * Sets the <code>paintFocus</code> property, which must
	1431	+ * be <code>true</code> for the focus state to be painted.
	1432	+ * The default value for the <code>paintFocus</code> property
	1433	+ * is <code>true</code>.
	1434	+ * Some look and feels might not paint focus state;
	1435	+ * they will ignore this property.
	1436	+ *
	1437	+ * @param b if <code>true</code>, the focus state should be painted
	1438	+ * @see #isFocusPainted
	1439	+ * @beaninfo
	1440	+ * bound: true
	1441	+ * attribute: visualUpdate true
	1442	+ * description: Whether focus should be painted
	1443	+ */
	1444	+ public void setFocusPainted(boolean b) {
	1445	+ boolean oldValue = paintFocus;
	1446	+ paintFocus = b;
	1447	+ firePropertyChange(FOCUS_PAINTED_CHANGED_PROPERTY, oldValue, paintFocus);
	1448	+ if (b != oldValue && isFocusOwner()) {
	1449	+ revalidate();
	1450	+ repaint();
	1451	+ }
	1452	+ }
	1453	+
	1454	+ /**
	1455	+ * Gets the <code>contentAreaFilled</code> property.
	1456	+ *
	1457	+ * @return the <code>contentAreaFilled</code> property
	1458	+ * @see #setContentAreaFilled
	1459	+ */
	1460	+ public boolean isContentAreaFilled() {
	1461	+ return contentAreaFilled;
	1462	+ }
	1463	+
	1464	+ /**
	1465	+ * Sets the <code>contentAreaFilled</code> property.
	1466	+ * If <code>true</code> the button will paint the content
	1467	+ * area. If you wish to have a transparent button, such as
	1468	+ * an icon only button, for example, then you should set
	1469	+ * this to <code>false</code>. Do not call <code>setOpaque(false)</code>.
	1470	+ * The default value for the the <code>contentAreaFilled</code>
	1471	+ * property is <code>true</code>.
	1472	+ * <p>
	1473	+ * This function may cause the component's opaque property to change.
	1474	+ * <p>
	1475	+ * The exact behavior of calling this function varies on a
	1476	+ * component-by-component and L&F-by-L&F basis.
	1477	+ *
	1478	+ * @param b if true, the content should be filled; if false
	1479	+ * the content area is not filled
	1480	+ * @see #isContentAreaFilled
	1481	+ * @see #setOpaque
	1482	+ * @beaninfo
	1483	+ * bound: true
	1484	+ * attribute: visualUpdate true
	1485	+ * description: Whether the button should paint the content area
	1486	+ * or leave it transparent.
	1487	+ */
	1488	+ public void setContentAreaFilled(boolean b) {
	1489	+ boolean oldValue = contentAreaFilled;
	1490	+ contentAreaFilled = b;
	1491	+ contentAreaFilledSet = true;
	1492	+ firePropertyChange(CONTENT_AREA_FILLED_CHANGED_PROPERTY, oldValue, contentAreaFilled);
	1493	+ if (b != oldValue) {
	1494	+ repaint();
	1495	+ }
	1496	+ }
	1497	+
	1498	+ /**
	1499	+ * Gets the <code>rolloverEnabled</code> property.
	1500	+ *
	1501	+ * @return the value of the <code>rolloverEnabled</code> property
	1502	+ * @see #setRolloverEnabled
	1503	+ */
	1504	+ public boolean isRolloverEnabled() {
	1505	+ return rolloverEnabled;
	1506	+ }
	1507	+
	1508	+ /**
	1509	+ * Sets the <code>rolloverEnabled</code> property, which
	1510	+ * must be <code>true</code> for rollover effects to occur.
	1511	+ * The default value for the <code>rolloverEnabled</code>
	1512	+ * property is <code>false</code>.
	1513	+ * Some look and feels might not implement rollover effects;
	1514	+ * they will ignore this property.
	1515	+ *
	1516	+ * @param b if <code>true</code>, rollover effects should be painted
	1517	+ * @see #isRolloverEnabled
	1518	+ * @beaninfo
	1519	+ * bound: true
	1520	+ * attribute: visualUpdate true
	1521	+ * description: Whether rollover effects should be enabled.
	1522	+ */
	1523	+ public void setRolloverEnabled(boolean b) {
	1524	+ boolean oldValue = rolloverEnabled;
	1525	+ rolloverEnabled = b;
	1526	+ rolloverEnabledSet = true;
	1527	+ firePropertyChange(ROLLOVER_ENABLED_CHANGED_PROPERTY, oldValue, rolloverEnabled);
	1528	+ if (b != oldValue) {
	1529	+ repaint();
	1530	+ }
	1531	+ }
	1532	+
	1533	+ /**
	1534	+ * Returns the keyboard mnemonic from the the current model.
	1535	+ * @return the keyboard mnemonic from the model
	1536	+ */
	1537	+ public int getMnemonic() {
	1538	+ return mnemonic;
	1539	+ }
	1540	+
	1541	+ /**
	1542	+ * Sets the keyboard mnemonic on the current model.
	1543	+ * The mnemonic is the key which when combined with the look and feel's
	1544	+ * mouseless modifier (usually Alt) will activate this button
	1545	+ * if focus is contained somewhere within this button's ancestor
	1546	+ * window.
	1547	+ * <p>
	1548	+ * A mnemonic must correspond to a single key on the keyboard
	1549	+ * and should be specified using one of the <code>VK_XXX</code>
	1550	+ * keycodes defined in <code>java.awt.event.KeyEvent</code>.
	1551	+ * These codes and the wider array of codes for international
	1552	+ * keyboards may be obtained through
	1553	+ * <code>java.awt.event.KeyEvent.getExtendedKeyCodeForChar</code>.
	1554	+ * Mnemonics are case-insensitive, therefore a key event
	1555	+ * with the corresponding keycode would cause the button to be
	1556	+ * activated whether or not the Shift modifier was pressed.
	1557	+ * <p>
	1558	+ * If the character defined by the mnemonic is found within
	1559	+ * the button's label string, the first occurrence of it
	1560	+ * will be underlined to indicate the mnemonic to the user.
	1561	+ *
	1562	+ * @param mnemonic the key code which represents the mnemonic
	1563	+ * @see java.awt.event.KeyEvent
	1564	+ * @see #setDisplayedMnemonicIndex
	1565	+ *
	1566	+ * @beaninfo
	1567	+ * bound: true
	1568	+ * attribute: visualUpdate true
	1569	+ * description: the keyboard character mnemonic
	1570	+ */
	1571	+ public void setMnemonic(int mnemonic) {
	1572	+ int oldValue = getMnemonic();
	1573	+ model.setMnemonic(mnemonic);
	1574	+ updateMnemonicProperties();
	1575	+ }
	1576	+
	1577	+ /**
	1578	+ * This method is now obsolete, please use <code>setMnemonic(int)</code>
	1579	+ * to set the mnemonic for a button. This method is only designed
	1580	+ * to handle character values which fall between 'a' and 'z' or
	1581	+ * 'A' and 'Z'.
	1582	+ *
	1583	+ * @param mnemonic a char specifying the mnemonic value
	1584	+ * @see #setMnemonic(int)
	1585	+ * @beaninfo
	1586	+ * bound: true
	1587	+ * attribute: visualUpdate true
	1588	+ * description: the keyboard character mnemonic
	1589	+ */
	1590	+ public void setMnemonic(char mnemonic) {
	1591	+ int vk = (int) mnemonic;
	1592	+ if(vk >= 'a' && vk <='z')
	1593	+ vk -= ('a' - 'A');
	1594	+ setMnemonic(vk);
	1595	+ }
	1596	+
	1597	+ /**
	1598	+ * Provides a hint to the look and feel as to which character in the
	1599	+ * text should be decorated to represent the mnemonic. Not all look and
	1600	+ * feels may support this. A value of -1 indicates either there is no
	1601	+ * mnemonic, the mnemonic character is not contained in the string, or
	1602	+ * the developer does not wish the mnemonic to be displayed.
	1603	+ * <p>
	1604	+ * The value of this is updated as the properties relating to the
	1605	+ * mnemonic change (such as the mnemonic itself, the text...).
	1606	+ * You should only ever have to call this if
	1607	+ * you do not wish the default character to be underlined. For example, if
	1608	+ * the text was 'Save As', with a mnemonic of 'a', and you wanted the 'A'
	1609	+ * to be decorated, as 'Save <u>A</u>s', you would have to invoke
	1610	+ * <code>setDisplayedMnemonicIndex(5)</code> after invoking
	1611	+ * <code>setMnemonic(KeyEvent.VK_A)</code>.
	1612	+ *
	1613	+ * @since 1.4
	1614	+ * @param index Index into the String to underline
	1615	+ * @exception IllegalArgumentException will be thrown if <code>index</code>
	1616	+ * is >= length of the text, or < -1
	1617	+ * @see #getDisplayedMnemonicIndex
	1618	+ *
	1619	+ * @beaninfo
	1620	+ * bound: true
	1621	+ * attribute: visualUpdate true
	1622	+ * description: the index into the String to draw the keyboard character
	1623	+ * mnemonic at
	1624	+ */
	1625	+ public void setDisplayedMnemonicIndex(int index)
	1626	+ throws IllegalArgumentException {
	1627	+ int oldValue = mnemonicIndex;
	1628	+ if (index == -1) {
	1629	+ mnemonicIndex = -1;
	1630	+ } else {
	1631	+ String text = getText();
	1632	+ int textLength = (text == null) ? 0 : text.length();
	1633	+ if (index < -1 \|\| index >= textLength) { // index out of range
	1634	+ throw new IllegalArgumentException("index == " + index);
	1635	+ }
	1636	+ }
	1637	+ mnemonicIndex = index;
	1638	+ firePropertyChange("displayedMnemonicIndex", oldValue, index);
	1639	+ if (index != oldValue) {
	1640	+ revalidate();
	1641	+ repaint();
	1642	+ }
	1643	+ }
	1644	+
	1645	+ /**
	1646	+ * Returns the character, as an index, that the look and feel should
	1647	+ * provide decoration for as representing the mnemonic character.
	1648	+ *
	1649	+ * @since 1.4
	1650	+ * @return index representing mnemonic character
	1651	+ * @see #setDisplayedMnemonicIndex
	1652	+ */
	1653	+ public int getDisplayedMnemonicIndex() {
	1654	+ return mnemonicIndex;
	1655	+ }
	1656	+
	1657	+ /**
	1658	+ * Update the displayedMnemonicIndex property. This method
	1659	+ * is called when either text or mnemonic changes. The new
	1660	+ * value of the displayedMnemonicIndex property is the index
	1661	+ * of the first occurrence of mnemonic in text.
	1662	+ */
	1663	+ private void updateDisplayedMnemonicIndex(String text, int mnemonic) {
	1664	+ setDisplayedMnemonicIndex(
	1665	+ SwingUtilities.findDisplayedMnemonicIndex(text, mnemonic));
	1666	+ }
	1667	+
	1668	+ /**
	1669	+ * Brings the mnemonic property in accordance with model's mnemonic.
	1670	+ * This is called when model's mnemonic changes. Also updates the
	1671	+ * displayedMnemonicIndex property.
	1672	+ */
	1673	+ private void updateMnemonicProperties() {
	1674	+ int newMnemonic = model.getMnemonic();
	1675	+ if (mnemonic != newMnemonic) {
	1676	+ int oldValue = mnemonic;
	1677	+ mnemonic = newMnemonic;
	1678	+ firePropertyChange(MNEMONIC_CHANGED_PROPERTY,
	1679	+ oldValue, mnemonic);
	1680	+ updateDisplayedMnemonicIndex(getText(), mnemonic);
	1681	+ revalidate();
	1682	+ repaint();
	1683	+ }
	1684	+ }
	1685	+
	1686	+ /**
	1687	+ * Sets the amount of time (in milliseconds) required between
	1688	+ * mouse press events for the button to generate the corresponding
	1689	+ * action events. After the initial mouse press occurs (and action
	1690	+ * event generated) any subsequent mouse press events which occur
	1691	+ * on intervals less than the threshhold will be ignored and no
	1692	+ * corresponding action event generated. By default the threshhold is 0,
	1693	+ * which means that for each mouse press, an action event will be
	1694	+ * fired, no matter how quickly the mouse clicks occur. In buttons
	1695	+ * where this behavior is not desirable (for example, the "OK" button
	1696	+ * in a dialog), this threshhold should be set to an appropriate
	1697	+ * positive value.
	1698	+ *
	1699	+ * @see #getMultiClickThreshhold
	1700	+ * @param threshhold the amount of time required between mouse
	1701	+ * press events to generate corresponding action events
	1702	+ * @exception IllegalArgumentException if threshhold < 0
	1703	+ * @since 1.4
	1704	+ */
	1705	+ public void setMultiClickThreshhold(long threshhold) {
	1706	+ if (threshhold < 0) {
	1707	+ throw new IllegalArgumentException("threshhold must be >= 0");
	1708	+ }
	1709	+ this.multiClickThreshhold = threshhold;
	1710	+ }
	1711	+
	1712	+ /**
	1713	+ * Gets the amount of time (in milliseconds) required between
	1714	+ * mouse press events for the button to generate the corresponding
	1715	+ * action events.
	1716	+ *
	1717	+ * @see #setMultiClickThreshhold
	1718	+ * @return the amount of time required between mouse press events
	1719	+ * to generate corresponding action events
	1720	+ * @since 1.4
	1721	+ */
	1722	+ public long getMultiClickThreshhold() {
	1723	+ return multiClickThreshhold;
	1724	+ }
	1725	+
	1726	+ /**
	1727	+ * Returns the model that this button represents.
	1728	+ * @return the <code>model</code> property
	1729	+ * @see #setModel
	1730	+ */
	1731	+ public ButtonModel getModel() {
	1732	+ return model;
	1733	+ }
	1734	+
	1735	+ /**
	1736	+ * Sets the model that this button represents.
	1737	+ * @param newModel the new <code>ButtonModel</code>
	1738	+ * @see #getModel
	1739	+ * @beaninfo
	1740	+ * bound: true
	1741	+ * description: Model that the Button uses.
	1742	+ */
	1743	+ public void setModel(ButtonModel newModel) {
	1744	+
	1745	+ ButtonModel oldModel = getModel();
	1746	+
	1747	+ if (oldModel != null) {
	1748	+ oldModel.removeChangeListener(changeListener);
	1749	+ oldModel.removeActionListener(actionListener);
	1750	+ oldModel.removeItemListener(itemListener);
	1751	+ changeListener = null;
	1752	+ actionListener = null;
	1753	+ itemListener = null;
	1754	+ }
	1755	+
	1756	+ model = newModel;
	1757	+
	1758	+ if (newModel != null) {
	1759	+ changeListener = createChangeListener();
	1760	+ actionListener = createActionListener();
	1761	+ itemListener = createItemListener();
	1762	+ newModel.addChangeListener(changeListener);
	1763	+ newModel.addActionListener(actionListener);
	1764	+ newModel.addItemListener(itemListener);
	1765	+
	1766	+ updateMnemonicProperties();
	1767	+ //We invoke setEnabled() from JComponent
	1768	+ //because setModel() can be called from a constructor
	1769	+ //when the button is not fully initialized
	1770	+ super.setEnabled(newModel.isEnabled());
	1771	+
	1772	+ } else {
	1773	+ mnemonic = '\0';
	1774	+ }
	1775	+
	1776	+ updateDisplayedMnemonicIndex(getText(), mnemonic);
	1777	+
	1778	+ firePropertyChange(MODEL_CHANGED_PROPERTY, oldModel, newModel);
	1779	+ if (newModel != oldModel) {
	1780	+ revalidate();
	1781	+ repaint();
	1782	+ }
	1783	+ }
	1784	+
	1785	+
	1786	+ /**
	1787	+ * Returns the L&F object that renders this component.
	1788	+ * @return the ButtonUI object
	1789	+ * @see #setUI
	1790	+ */
	1791	+ public ButtonUI getUI() {
	1792	+ return (ButtonUI) ui;
	1793	+ }
	1794	+
	1795	+
	1796	+ /**
	1797	+ * Sets the L&F object that renders this component.
	1798	+ * @param ui the <code>ButtonUI</code> L&F object
	1799	+ * @see #getUI
	1800	+ * @beaninfo
	1801	+ * bound: true
	1802	+ * hidden: true
	1803	+ * attribute: visualUpdate true
	1804	+ * description: The UI object that implements the LookAndFeel.
	1805	+ */
	1806	+ public void setUI(ButtonUI ui) {
	1807	+ super.setUI(ui);
	1808	+ // disabled icons are generated by the LF so they should be unset here
	1809	+ if (disabledIcon instanceof UIResource) {
	1810	+ setDisabledIcon(null);
	1811	+ }
	1812	+ if (disabledSelectedIcon instanceof UIResource) {
	1813	+ setDisabledSelectedIcon(null);
	1814	+ }
	1815	+ }
	1816	+
	1817	+
	1818	+ /**
	1819	+ * Resets the UI property to a value from the current look
	1820	+ * and feel. Subtypes of <code>AbstractButton</code>
	1821	+ * should override this to update the UI. For
	1822	+ * example, <code>JButton</code> might do the following:
	1823	+ * <pre>
	1824	+ * setUI((ButtonUI)UIManager.getUI(
	1825	+ * "ButtonUI", "javax.swing.plaf.basic.BasicButtonUI", this));
	1826	+ * </pre>
	1827	+ */
	1828	+ public void updateUI() {
	1829	+ }
	1830	+
	1831	+ /**
	1832	+ * Adds the specified component to this container at the specified
	1833	+ * index, refer to
	1834	+ * {@link java.awt.Container#addImpl(Component, Object, int)}
	1835	+ * for a complete description of this method.
	1836	+ *
	1837	+ * @param comp the component to be added
	1838	+ * @param constraints an object expressing layout constraints
	1839	+ * for this component
	1840	+ * @param index the position in the container's list at which to
	1841	+ * insert the component, where <code>-1</code>
	1842	+ * means append to the end
	1843	+ * @exception IllegalArgumentException if <code>index</code> is invalid
	1844	+ * @exception IllegalArgumentException if adding the container's parent
	1845	+ * to itself
	1846	+ * @exception IllegalArgumentException if adding a window to a container
	1847	+ * @since 1.5
	1848	+ */
	1849	+ protected void addImpl(Component comp, Object constraints, int index) {
	1850	+ if (!setLayout) {
	1851	+ setLayout(new OverlayLayout(this));
	1852	+ }
	1853	+ super.addImpl(comp, constraints, index);
	1854	+ }
	1855	+
	1856	+ /**
	1857	+ * Sets the layout manager for this container, refer to
	1858	+ * {@link java.awt.Container#setLayout(LayoutManager)}
	1859	+ * for a complete description of this method.
	1860	+ *
	1861	+ * @param mgr the specified layout manager
	1862	+ * @since 1.5
	1863	+ */
	1864	+ public void setLayout(LayoutManager mgr) {
	1865	+ setLayout = true;
	1866	+ super.setLayout(mgr);
	1867	+ }
	1868	+
	1869	+ /**
	1870	+ * Adds a <code>ChangeListener</code> to the button.
	1871	+ * @param l the listener to be added
	1872	+ */
	1873	+ public void addChangeListener(ChangeListener l) {
	1874	+ listenerList.add(ChangeListener.class, l);
	1875	+ }
	1876	+
	1877	+ /**
	1878	+ * Removes a ChangeListener from the button.
	1879	+ * @param l the listener to be removed
	1880	+ */
	1881	+ public void removeChangeListener(ChangeListener l) {
	1882	+ listenerList.remove(ChangeListener.class, l);
	1883	+ }
	1884	+
	1885	+ /**
	1886	+ * Returns an array of all the <code>ChangeListener</code>s added
	1887	+ * to this AbstractButton with addChangeListener().
	1888	+ *
	1889	+ * @return all of the <code>ChangeListener</code>s added or an empty
	1890	+ * array if no listeners have been added
	1891	+ * @since 1.4
	1892	+ */
	1893	+ public ChangeListener[] getChangeListeners() {
	1894	+ return listenerList.getListeners(ChangeListener.class);
	1895	+ }
	1896	+
	1897	+ /**
	1898	+ * Notifies all listeners that have registered interest for
	1899	+ * notification on this event type. The event instance
	1900	+ * is lazily created.
	1901	+ * @see EventListenerList
	1902	+ */
	1903	+ protected void fireStateChanged() {
	1904	+ // Guaranteed to return a non-null array
	1905	+ Object[] listeners = listenerList.getListenerList();
	1906	+ // Process the listeners last to first, notifying
	1907	+ // those that are interested in this event
	1908	+ for (int i = listeners.length-2; i>=0; i-=2) {
	1909	+ if (listeners[i]==ChangeListener.class) {
	1910	+ // Lazily create the event:
	1911	+ if (changeEvent == null)
	1912	+ changeEvent = new ChangeEvent(this);
	1913	+ ((ChangeListener)listeners[i+1]).stateChanged(changeEvent);
	1914	+ }
	1915	+ }
	1916	+ }
	1917	+
	1918	+ /**
	1919	+ * Adds an <code>ActionListener</code> to the button.
	1920	+ * @param l the <code>ActionListener</code> to be added
	1921	+ */
	1922	+ public void addActionListener(ActionListener l) {
	1923	+ listenerList.add(ActionListener.class, l);
	1924	+ }
	1925	+
	1926	+ /**
	1927	+ * Removes an <code>ActionListener</code> from the button.
	1928	+ * If the listener is the currently set <code>Action</code>
	1929	+ * for the button, then the <code>Action</code>
	1930	+ * is set to <code>null</code>.
	1931	+ *
	1932	+ * @param l the listener to be removed
	1933	+ */
	1934	+ public void removeActionListener(ActionListener l) {
	1935	+ if ((l != null) && (getAction() == l)) {
	1936	+ setAction(null);
	1937	+ } else {
	1938	+ listenerList.remove(ActionListener.class, l);
	1939	+ }
	1940	+ }
	1941	+
	1942	+ /**
	1943	+ * Returns an array of all the <code>ActionListener</code>s added
	1944	+ * to this AbstractButton with addActionListener().
	1945	+ *
	1946	+ * @return all of the <code>ActionListener</code>s added or an empty
	1947	+ * array if no listeners have been added
	1948	+ * @since 1.4
	1949	+ */
	1950	+ public ActionListener[] getActionListeners() {
	1951	+ return listenerList.getListeners(ActionListener.class);
	1952	+ }
	1953	+
	1954	+ /**
	1955	+ * Subclasses that want to handle <code>ChangeEvents</code> differently
	1956	+ * can override this to return another <code>ChangeListener</code>
	1957	+ * implementation.
	1958	+ *
	1959	+ * @return the new <code>ChangeListener</code>
	1960	+ */
	1961	+ protected ChangeListener createChangeListener() {
	1962	+ return getHandler();
	1963	+ }
	1964	+
	1965	+ /**
	1966	+ * Extends <code>ChangeListener</code> to be serializable.
	1967	+ * <p>
	1968	+ * <strong>Warning:</strong>
	1969	+ * Serialized objects of this class will not be compatible with
	1970	+ * future Swing releases. The current serialization support is
	1971	+ * appropriate for short term storage or RMI between applications running
	1972	+ * the same version of Swing. As of 1.4, support for long term storage
	1973	+ * of all JavaBeans<sup><font size="-2">TM</font></sup>
	1974	+ * has been added to the <code>java.beans</code> package.
	1975	+ * Please see {@link java.beans.XMLEncoder}.
	1976	+ */
	1977	+ protected class ButtonChangeListener implements ChangeListener, Serializable {
	1978	+ // NOTE: This class is NOT used, instead the functionality has
	1979	+ // been moved to Handler.
	1980	+ ButtonChangeListener() {
	1981	+ }
	1982	+
	1983	+ public void stateChanged(ChangeEvent e) {
	1984	+ getHandler().stateChanged(e);
	1985	+ }
	1986	+ }
	1987	+
	1988	+
	1989	+ /**
	1990	+ * Notifies all listeners that have registered interest for
	1991	+ * notification on this event type. The event instance
	1992	+ * is lazily created using the <code>event</code>
	1993	+ * parameter.
	1994	+ *
	1995	+ * @param event the <code>ActionEvent</code> object
	1996	+ * @see EventListenerList
	1997	+ */
	1998	+ protected void fireActionPerformed(ActionEvent event) {
	1999	+ // Guaranteed to return a non-null array
	2000	+ Object[] listeners = listenerList.getListenerList();
	2001	+ ActionEvent e = null;
	2002	+ // Process the listeners last to first, notifying
	2003	+ // those that are interested in this event
	2004	+ for (int i = listeners.length-2; i>=0; i-=2) {
	2005	+ if (listeners[i]==ActionListener.class) {
	2006	+ // Lazily create the event:
	2007	+ if (e == null) {
	2008	+ String actionCommand = event.getActionCommand();
	2009	+ if(actionCommand == null) {
	2010	+ actionCommand = getActionCommand();
	2011	+ }
	2012	+ e = new ActionEvent(AbstractButton.this,
	2013	+ ActionEvent.ACTION_PERFORMED,
	2014	+ actionCommand,
	2015	+ event.getWhen(),
	2016	+ event.getModifiers());
	2017	+ }
	2018	+ ((ActionListener)listeners[i+1]).actionPerformed(e);
	2019	+ }
	2020	+ }
	2021	+ }
	2022	+
	2023	+ /**
	2024	+ * Notifies all listeners that have registered interest for
	2025	+ * notification on this event type. The event instance
	2026	+ * is lazily created using the <code>event</code> parameter.
	2027	+ *
	2028	+ * @param event the <code>ItemEvent</code> object
	2029	+ * @see EventListenerList
	2030	+ */
	2031	+ protected void fireItemStateChanged(ItemEvent event) {
	2032	+ // Guaranteed to return a non-null array
	2033	+ Object[] listeners = listenerList.getListenerList();
	2034	+ ItemEvent e = null;
	2035	+ // Process the listeners last to first, notifying
	2036	+ // those that are interested in this event
	2037	+ for (int i = listeners.length-2; i>=0; i-=2) {
	2038	+ if (listeners[i]==ItemListener.class) {
	2039	+ // Lazily create the event:
	2040	+ if (e == null) {
	2041	+ e = new ItemEvent(AbstractButton.this,
	2042	+ ItemEvent.ITEM_STATE_CHANGED,
	2043	+ AbstractButton.this,
	2044	+ event.getStateChange());
	2045	+ }
	2046	+ ((ItemListener)listeners[i+1]).itemStateChanged(e);
	2047	+ }
	2048	+ }
	2049	+ if (accessibleContext != null) {
	2050	+ if (event.getStateChange() == ItemEvent.SELECTED) {
	2051	+ accessibleContext.firePropertyChange(
	2052	+ AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
	2053	+ null, AccessibleState.SELECTED);
	2054	+ accessibleContext.firePropertyChange(
	2055	+ AccessibleContext.ACCESSIBLE_VALUE_PROPERTY,
	2056	+ Integer.valueOf(0), Integer.valueOf(1));
	2057	+ } else {
	2058	+ accessibleContext.firePropertyChange(
	2059	+ AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
	2060	+ AccessibleState.SELECTED, null);
	2061	+ accessibleContext.firePropertyChange(
	2062	+ AccessibleContext.ACCESSIBLE_VALUE_PROPERTY,
	2063	+ Integer.valueOf(1), Integer.valueOf(0));
	2064	+ }
	2065	+ }
	2066	+ }
	2067	+
	2068	+
	2069	+ protected ActionListener createActionListener() {
	2070	+ return getHandler();
	2071	+ }
	2072	+
	2073	+
	2074	+ protected ItemListener createItemListener() {
	2075	+ return getHandler();
	2076	+ }
	2077	+
	2078	+
	2079	+ /**
	2080	+ * Enables (or disables) the button.
	2081	+ * @param b true to enable the button, otherwise false
	2082	+ */
	2083	+ public void setEnabled(boolean b) {
	2084	+ if (!b && model.isRollover()) {
	2085	+ model.setRollover(false);
	2086	+ }
	2087	+ super.setEnabled(b);
	2088	+ model.setEnabled(b);
	2089	+ }
	2090	+
	2091	+ // * Deprecated java.awt.Button APIs below * //
	2092	+
	2093	+ /**
	2094	+ * Returns the label text.
	2095	+ *
	2096	+ * @return a <code>String</code> containing the label
	2097	+ * @deprecated - Replaced by <code>getText</code>
	2098	+ */
	2099	+ @Deprecated
	2100	+ public String getLabel() {
	2101	+ return getText();
	2102	+ }
	2103	+
	2104	+ /**
	2105	+ * Sets the label text.
	2106	+ *
	2107	+ * @param label a <code>String</code> containing the text
	2108	+ * @deprecated - Replaced by <code>setText(text)</code>
	2109	+ * @beaninfo
	2110	+ * bound: true
	2111	+ * description: Replace by setText(text)
	2112	+ */
	2113	+ @Deprecated
	2114	+ public void setLabel(String label) {
	2115	+ setText(label);
	2116	+ }
	2117	+
	2118	+ /**
	2119	+ * Adds an <code>ItemListener</code> to the <code>checkbox</code>.
	2120	+ * @param l the <code>ItemListener</code> to be added
	2121	+ */
	2122	+ public void addItemListener(ItemListener l) {
	2123	+ listenerList.add(ItemListener.class, l);
	2124	+ }
	2125	+
	2126	+ /**
	2127	+ * Removes an <code>ItemListener</code> from the button.
	2128	+ * @param l the <code>ItemListener</code> to be removed
	2129	+ */
	2130	+ public void removeItemListener(ItemListener l) {
	2131	+ listenerList.remove(ItemListener.class, l);
	2132	+ }
	2133	+
	2134	+ /**
	2135	+ * Returns an array of all the <code>ItemListener</code>s added
	2136	+ * to this AbstractButton with addItemListener().
	2137	+ *
	2138	+ * @return all of the <code>ItemListener</code>s added or an empty
	2139	+ * array if no listeners have been added
	2140	+ * @since 1.4
	2141	+ */
	2142	+ public ItemListener[] getItemListeners() {
	2143	+ return listenerList.getListeners(ItemListener.class);
	2144	+ }
	2145	+
	2146	+ /**
	2147	+ * Returns an array (length 1) containing the label or
	2148	+ * <code>null</code> if the button is not selected.
	2149	+ *
	2150	+ * @return an array containing 1 Object: the text of the button,
	2151	+ * if the item is selected; otherwise <code>null</code>
	2152	+ */
	2153	+ public Object[] getSelectedObjects() {
	2154	+ if (isSelected() == false) {
	2155	+ return null;
	2156	+ }
	2157	+ Object[] selectedObjects = new Object[1];
	2158	+ selectedObjects[0] = getText();
	2159	+ return selectedObjects;
	2160	+ }
	2161	+
	2162	+ protected void init(String text, Icon icon) {
	2163	+ if(text != null) {
	2164	+ setText(text);
	2165	+ }
	2166	+
	2167	+ if(icon != null) {
	2168	+ setIcon(icon);
	2169	+ }
	2170	+
	2171	+ // Set the UI
	2172	+ updateUI();
	2173	+
	2174	+ setAlignmentX(LEFT_ALIGNMENT);
	2175	+ setAlignmentY(CENTER_ALIGNMENT);
	2176	+ }
	2177	+
	2178	+
	2179	+ /**
	2180	+ * This is overridden to return false if the current <code>Icon</code>'s
	2181	+ * <code>Image</code> is not equal to the
	2182	+ * passed in <code>Image</code> <code>img</code>.
	2183	+ *
	2184	+ * @param img the <code>Image</code> to be compared
	2185	+ * @param infoflags flags used to repaint the button when the image
	2186	+ * is updated and which determine how much is to be painted
	2187	+ * @param x the x coordinate
	2188	+ * @param y the y coordinate
	2189	+ * @param w the width
	2190	+ * @param h the height
	2191	+ * @see java.awt.image.ImageObserver
	2192	+ * @see java.awt.Component#imageUpdate(java.awt.Image, int, int, int, int, int)
	2193	+ */
	2194	+ public boolean imageUpdate(Image img, int infoflags,
	2195	+ int x, int y, int w, int h) {
	2196	+ Icon iconDisplayed = getIcon();
	2197	+ if (iconDisplayed == null) {
	2198	+ return false;
	2199	+ }
	2200	+
	2201	+ if (!model.isEnabled()) {
	2202	+ if (model.isSelected()) {
	2203	+ iconDisplayed = getDisabledSelectedIcon();
	2204	+ } else {
	2205	+ iconDisplayed = getDisabledIcon();
	2206	+ }
	2207	+ } else if (model.isPressed() && model.isArmed()) {
	2208	+ iconDisplayed = getPressedIcon();
	2209	+ } else if (isRolloverEnabled() && model.isRollover()) {
	2210	+ if (model.isSelected()) {
	2211	+ iconDisplayed = getRolloverSelectedIcon();
	2212	+ } else {
	2213	+ iconDisplayed = getRolloverIcon();
	2214	+ }
	2215	+ } else if (model.isSelected()) {
	2216	+ iconDisplayed = getSelectedIcon();
	2217	+ }
	2218	+
	2219	+ if (!SwingUtilities.doesIconReferenceImage(iconDisplayed, img)) {
	2220	+ // We don't know about this image, disable the notification so
	2221	+ // we don't keep repainting.
	2222	+ return false;
	2223	+ }
	2224	+ return super.imageUpdate(img, infoflags, x, y, w, h);
	2225	+ }
	2226	+
	2227	+ void setUIProperty(String propertyName, Object value) {
	2228	+ if (propertyName == "borderPainted") {
	2229	+ if (!borderPaintedSet) {
	2230	+ setBorderPainted(((Boolean)value).booleanValue());
	2231	+ borderPaintedSet = false;
	2232	+ }
	2233	+ } else if (propertyName == "rolloverEnabled") {
	2234	+ if (!rolloverEnabledSet) {
	2235	+ setRolloverEnabled(((Boolean)value).booleanValue());
	2236	+ rolloverEnabledSet = false;
	2237	+ }
	2238	+ } else if (propertyName == "iconTextGap") {
	2239	+ if (!iconTextGapSet) {
	2240	+ setIconTextGap(((Number)value).intValue());
	2241	+ iconTextGapSet = false;
	2242	+ }
	2243	+ } else if (propertyName == "contentAreaFilled") {
	2244	+ if (!contentAreaFilledSet) {
	2245	+ setContentAreaFilled(((Boolean)value).booleanValue());
	2246	+ contentAreaFilledSet = false;
	2247	+ }
	2248	+ } else {
	2249	+ super.setUIProperty(propertyName, value);
	2250	+ }
	2251	+ }
	2252	+
	2253	+ /**
	2254	+ * Returns a string representation of this <code>AbstractButton</code>.
	2255	+ * This method
	2256	+ * is intended to be used only for debugging purposes, and the
	2257	+ * content and format of the returned string may vary between
	2258	+ * implementations. The returned string may be empty but may not
	2259	+ * be <code>null</code>.
	2260	+ * <P>
	2261	+ * Overriding <code>paramString</code> to provide information about the
	2262	+ * specific new aspects of the JFC components.
	2263	+ *
	2264	+ * @return a string representation of this <code>AbstractButton</code>
	2265	+ */
	2266	+ protected String paramString() {
	2267	+ String defaultIconString = ((defaultIcon != null)
	2268	+ && (defaultIcon != this) ?
	2269	+ defaultIcon.toString() : "");
	2270	+ String pressedIconString = ((pressedIcon != null)
	2271	+ && (pressedIcon != this) ?
	2272	+ pressedIcon.toString() : "");
	2273	+ String disabledIconString = ((disabledIcon != null)
	2274	+ && (disabledIcon != this) ?
	2275	+ disabledIcon.toString() : "");
	2276	+ String selectedIconString = ((selectedIcon != null)
	2277	+ && (selectedIcon != this) ?
	2278	+ selectedIcon.toString() : "");
	2279	+ String disabledSelectedIconString = ((disabledSelectedIcon != null) &&
	2280	+ (disabledSelectedIcon != this) ?
	2281	+ disabledSelectedIcon.toString()
	2282	+ : "");
	2283	+ String rolloverIconString = ((rolloverIcon != null)
	2284	+ && (rolloverIcon != this) ?
	2285	+ rolloverIcon.toString() : "");
	2286	+ String rolloverSelectedIconString = ((rolloverSelectedIcon != null) &&
	2287	+ (rolloverSelectedIcon != this) ?
	2288	+ rolloverSelectedIcon.toString()
	2289	+ : "");
	2290	+ String paintBorderString = (paintBorder ? "true" : "false");
	2291	+ String paintFocusString = (paintFocus ? "true" : "false");
	2292	+ String rolloverEnabledString = (rolloverEnabled ? "true" : "false");
	2293	+
	2294	+ return super.paramString() +
	2295	+ ",defaultIcon=" + defaultIconString +
	2296	+ ",disabledIcon=" + disabledIconString +
	2297	+ ",disabledSelectedIcon=" + disabledSelectedIconString +
	2298	+ ",margin=" + margin +
	2299	+ ",paintBorder=" + paintBorderString +
	2300	+ ",paintFocus=" + paintFocusString +
	2301	+ ",pressedIcon=" + pressedIconString +
	2302	+ ",rolloverEnabled=" + rolloverEnabledString +
	2303	+ ",rolloverIcon=" + rolloverIconString +
	2304	+ ",rolloverSelectedIcon=" + rolloverSelectedIconString +
	2305	+ ",selectedIcon=" + selectedIconString +
	2306	+ ",text=" + text;
	2307	+ }
	2308	+
	2309	+
	2310	+ private Handler getHandler() {
	2311	+ if (handler == null) {
	2312	+ handler = new Handler();
	2313	+ }
	2314	+ return handler;
	2315	+ }
	2316	+
	2317	+
	2318	+ //
	2319	+ // Listeners that are added to model
	2320	+ //
	2321	+ class Handler implements ActionListener, ChangeListener, ItemListener,
	2322	+ Serializable {
	2323	+ //
	2324	+ // ChangeListener
	2325	+ //
	2326	+ public void stateChanged(ChangeEvent e) {
	2327	+ Object source = e.getSource();
	2328	+
	2329	+ updateMnemonicProperties();
	2330	+ if (isEnabled() != model.isEnabled()) {
	2331	+ setEnabled(model.isEnabled());
	2332	+ }
	2333	+ fireStateChanged();
	2334	+ repaint();
	2335	+ }
	2336	+
	2337	+ //
	2338	+ // ActionListener
	2339	+ //
	2340	+ public void actionPerformed(ActionEvent event) {
	2341	+ fireActionPerformed(event);
	2342	+ }
	2343	+
	2344	+ //
	2345	+ // ItemListener
	2346	+ //
	2347	+ public void itemStateChanged(ItemEvent event) {
	2348	+ fireItemStateChanged(event);
	2349	+ if (shouldUpdateSelectedStateFromAction()) {
	2350	+ Action action = getAction();
	2351	+ if (action != null && AbstractAction.hasSelectedKey(action)) {
	2352	+ boolean selected = isSelected();
	2353	+ boolean isActionSelected = AbstractAction.isSelected(
	2354	+ action);
	2355	+ if (isActionSelected != selected) {
	2356	+ action.putValue(Action.SELECTED_KEY, selected);
	2357	+ }
	2358	+ }
	2359	+ }
	2360	+ }
	2361	+ }
	2362	+
	2363	+///////////////////
	2364	+// Accessibility support
	2365	+///////////////////
	2366	+ /**
	2367	+ * This class implements accessibility support for the
	2368	+ * <code>AbstractButton</code> class. It provides an implementation of the
	2369	+ * Java Accessibility API appropriate to button and menu item
	2370	+ * user-interface elements.
	2371	+ * <p>
	2372	+ * <strong>Warning:</strong>
	2373	+ * Serialized objects of this class will not be compatible with
	2374	+ * future Swing releases. The current serialization support is
	2375	+ * appropriate for short term storage or RMI between applications running
	2376	+ * the same version of Swing. As of 1.4, support for long term storage
	2377	+ * of all JavaBeans<sup><font size="-2">TM</font></sup>
	2378	+ * has been added to the <code>java.beans</code> package.
	2379	+ * Please see {@link java.beans.XMLEncoder}.
	2380	+ * @since 1.4
	2381	+ */
	2382	+ protected abstract class AccessibleAbstractButton
	2383	+ extends AccessibleJComponent implements AccessibleAction,
	2384	+ AccessibleValue, AccessibleText, AccessibleExtendedComponent {
	2385	+
	2386	+ /**
	2387	+ * Returns the accessible name of this object.
	2388	+ *
	2389	+ * @return the localized name of the object -- can be
	2390	+ * <code>null</code> if this
	2391	+ * object does not have a name
	2392	+ */
	2393	+ public String getAccessibleName() {
	2394	+ String name = accessibleName;
	2395	+
	2396	+ if (name == null) {
	2397	+ name = (String)getClientProperty(AccessibleContext.ACCESSIBLE_NAME_PROPERTY);
	2398	+ }
	2399	+ if (name == null) {
	2400	+ name = AbstractButton.this.getText();
	2401	+ }
	2402	+ if (name == null) {
	2403	+ name = super.getAccessibleName();
	2404	+ }
	2405	+ return name;
	2406	+ }
	2407	+
	2408	+ /**
	2409	+ * Get the AccessibleIcons associated with this object if one
	2410	+ * or more exist. Otherwise return null.
	2411	+ * @since 1.3
	2412	+ */
	2413	+ public AccessibleIcon [] getAccessibleIcon() {
	2414	+ Icon defaultIcon = getIcon();
	2415	+
	2416	+ if (defaultIcon instanceof Accessible) {
	2417	+ AccessibleContext ac =
	2418	+ ((Accessible)defaultIcon).getAccessibleContext();
	2419	+ if (ac != null && ac instanceof AccessibleIcon) {
	2420	+ return new AccessibleIcon[] { (AccessibleIcon)ac };
	2421	+ }
	2422	+ }
	2423	+ return null;
	2424	+ }
	2425	+
	2426	+ /**
	2427	+ * Get the state set of this object.
	2428	+ *
	2429	+ * @return an instance of AccessibleState containing the current state
	2430	+ * of the object
	2431	+ * @see AccessibleState
	2432	+ */
	2433	+ public AccessibleStateSet getAccessibleStateSet() {
	2434	+ AccessibleStateSet states = super.getAccessibleStateSet();
	2435	+ if (getModel().isArmed()) {
	2436	+ states.add(AccessibleState.ARMED);
	2437	+ }
	2438	+ if (isFocusOwner()) {
	2439	+ states.add(AccessibleState.FOCUSED);
	2440	+ }
	2441	+ if (getModel().isPressed()) {
	2442	+ states.add(AccessibleState.PRESSED);
	2443	+ }
	2444	+ if (isSelected()) {
	2445	+ states.add(AccessibleState.CHECKED);
	2446	+ }
	2447	+ return states;
	2448	+ }
	2449	+
	2450	+ /**
	2451	+ * Get the AccessibleRelationSet associated with this object if one
	2452	+ * exists. Otherwise return null.
	2453	+ * @see AccessibleRelation
	2454	+ * @since 1.3
	2455	+ */
	2456	+ public AccessibleRelationSet getAccessibleRelationSet() {
	2457	+
	2458	+ // Check where the AccessibleContext's relation
	2459	+ // set already contains a MEMBER_OF relation.
	2460	+ AccessibleRelationSet relationSet
	2461	+ = super.getAccessibleRelationSet();
	2462	+
	2463	+ if (!relationSet.contains(AccessibleRelation.MEMBER_OF)) {
	2464	+ // get the members of the button group if one exists
	2465	+ ButtonModel model = getModel();
	2466	+ if (model != null && model instanceof DefaultButtonModel) {
	2467	+ ButtonGroup group = ((DefaultButtonModel)model).getGroup();
	2468	+ if (group != null) {
	2469	+ // set the target of the MEMBER_OF relation to be
	2470	+ // the members of the button group.
	2471	+ int len = group.getButtonCount();
	2472	+ Object [] target = new Object[len];
	2473	+ Enumeration elem = group.getElements();
	2474	+ for (int i = 0; i < len; i++) {
	2475	+ if (elem.hasMoreElements()) {
	2476	+ target[i] = elem.nextElement();
	2477	+ }
	2478	+ }
	2479	+ AccessibleRelation relation =
	2480	+ new AccessibleRelation(AccessibleRelation.MEMBER_OF);
	2481	+ relation.setTarget(target);
	2482	+ relationSet.add(relation);
	2483	+ }
	2484	+ }
	2485	+ }
	2486	+ return relationSet;
	2487	+ }
	2488	+
	2489	+ /**
	2490	+ * Get the AccessibleAction associated with this object. In the
	2491	+ * implementation of the Java Accessibility API for this class,
	2492	+ * return this object, which is responsible for implementing the
	2493	+ * AccessibleAction interface on behalf of itself.
	2494	+ *
	2495	+ * @return this object
	2496	+ */
	2497	+ public AccessibleAction getAccessibleAction() {
	2498	+ return this;
	2499	+ }
	2500	+
	2501	+ /**
	2502	+ * Get the AccessibleValue associated with this object. In the
	2503	+ * implementation of the Java Accessibility API for this class,
	2504	+ * return this object, which is responsible for implementing the
	2505	+ * AccessibleValue interface on behalf of itself.
	2506	+ *
	2507	+ * @return this object
	2508	+ */
	2509	+ public AccessibleValue getAccessibleValue() {
	2510	+ return this;
	2511	+ }
	2512	+
	2513	+ /**
	2514	+ * Returns the number of Actions available in this object. The
	2515	+ * default behavior of a button is to have one action - toggle
	2516	+ * the button.
	2517	+ *
	2518	+ * @return 1, the number of Actions in this object
	2519	+ */
	2520	+ public int getAccessibleActionCount() {
	2521	+ return 1;
	2522	+ }
	2523	+
	2524	+ /**
	2525	+ * Return a description of the specified action of the object.
	2526	+ *
	2527	+ * @param i zero-based index of the actions
	2528	+ */
	2529	+ public String getAccessibleActionDescription(int i) {
	2530	+ if (i == 0) {
	2531	+ return UIManager.getString("AbstractButton.clickText");
	2532	+ } else {
	2533	+ return null;
	2534	+ }
	2535	+ }
	2536	+
	2537	+ /**
	2538	+ * Perform the specified Action on the object
	2539	+ *
	2540	+ * @param i zero-based index of actions
	2541	+ * @return true if the the action was performed; else false.
	2542	+ */
	2543	+ public boolean doAccessibleAction(int i) {
	2544	+ if (i == 0) {
	2545	+ doClick();
	2546	+ return true;
	2547	+ } else {
	2548	+ return false;
	2549	+ }
	2550	+ }
	2551	+
	2552	+ /**
	2553	+ * Get the value of this object as a Number.
	2554	+ *
	2555	+ * @return An Integer of 0 if this isn't selected or an Integer of 1 if
	2556	+ * this is selected.
	2557	+ * @see AbstractButton#isSelected
	2558	+ */
	2559	+ public Number getCurrentAccessibleValue() {
	2560	+ if (isSelected()) {
	2561	+ return Integer.valueOf(1);
	2562	+ } else {
	2563	+ return Integer.valueOf(0);
	2564	+ }
	2565	+ }
	2566	+
	2567	+ /**
	2568	+ * Set the value of this object as a Number.
	2569	+ *
	2570	+ * @return True if the value was set.
	2571	+ */
	2572	+ public boolean setCurrentAccessibleValue(Number n) {
	2573	+ // TIGER - 4422535
	2574	+ if (n == null) {
	2575	+ return false;
	2576	+ }
	2577	+ int i = n.intValue();
	2578	+ if (i == 0) {
	2579	+ setSelected(false);
	2580	+ } else {
	2581	+ setSelected(true);
	2582	+ }
	2583	+ return true;
	2584	+ }
	2585	+
	2586	+ /**
	2587	+ * Get the minimum value of this object as a Number.
	2588	+ *
	2589	+ * @return an Integer of 0.
	2590	+ */
	2591	+ public Number getMinimumAccessibleValue() {
	2592	+ return Integer.valueOf(0);
	2593	+ }
	2594	+
	2595	+ /**
	2596	+ * Get the maximum value of this object as a Number.
	2597	+ *
	2598	+ * @return An Integer of 1.
	2599	+ */
	2600	+ public Number getMaximumAccessibleValue() {
	2601	+ return Integer.valueOf(1);
	2602	+ }
	2603	+
	2604	+
	2605	+ /* AccessibleText ---------- */
	2606	+
	2607	+ public AccessibleText getAccessibleText() {
	2608	+ View view = (View)AbstractButton.this.getClientProperty("html");
	2609	+ if (view != null) {
	2610	+ return this;
	2611	+ } else {
	2612	+ return null;
	2613	+ }
	2614	+ }
	2615	+
	2616	+ /**
	2617	+ * Given a point in local coordinates, return the zero-based index
	2618	+ * of the character under that Point. If the point is invalid,
	2619	+ * this method returns -1.
	2620	+ *
	2621	+ * Note: the AbstractButton must have a valid size (e.g. have
	2622	+ * been added to a parent container whose ancestor container
	2623	+ * is a valid top-level window) for this method to be able
	2624	+ * to return a meaningful value.
	2625	+ *
	2626	+ * @param p the Point in local coordinates
	2627	+ * @return the zero-based index of the character under Point p; if
	2628	+ * Point is invalid returns -1.
	2629	+ * @since 1.3
	2630	+ */
	2631	+ public int getIndexAtPoint(Point p) {
	2632	+ View view = (View) AbstractButton.this.getClientProperty("html");
	2633	+ if (view != null) {
	2634	+ Rectangle r = getTextRectangle();
	2635	+ if (r == null) {
	2636	+ return -1;
	2637	+ }
	2638	+ Rectangle2D.Float shape =
	2639	+ new Rectangle2D.Float(r.x, r.y, r.width, r.height);
	2640	+ Position.Bias bias[] = new Position.Bias[1];
	2641	+ return view.viewToModel(p.x, p.y, shape, bias);
	2642	+ } else {
	2643	+ return -1;
	2644	+ }
	2645	+ }
	2646	+
	2647	+ /**
	2648	+ * Determine the bounding box of the character at the given
	2649	+ * index into the string. The bounds are returned in local
	2650	+ * coordinates. If the index is invalid an empty rectangle is
	2651	+ * returned.
	2652	+ *
	2653	+ * Note: the AbstractButton must have a valid size (e.g. have
	2654	+ * been added to a parent container whose ancestor container
	2655	+ * is a valid top-level window) for this method to be able
	2656	+ * to return a meaningful value.
	2657	+ *
	2658	+ * @param i the index into the String
	2659	+ * @return the screen coordinates of the character's the bounding box,
	2660	+ * if index is invalid returns an empty rectangle.
	2661	+ * @since 1.3
	2662	+ */
	2663	+ public Rectangle getCharacterBounds(int i) {
	2664	+ View view = (View) AbstractButton.this.getClientProperty("html");
	2665	+ if (view != null) {
	2666	+ Rectangle r = getTextRectangle();
	2667	+ if (r == null) {
	2668	+ return null;
	2669	+ }
	2670	+ Rectangle2D.Float shape =
	2671	+ new Rectangle2D.Float(r.x, r.y, r.width, r.height);
	2672	+ try {
	2673	+ Shape charShape =
	2674	+ view.modelToView(i, shape, Position.Bias.Forward);
	2675	+ return charShape.getBounds();
	2676	+ } catch (BadLocationException e) {
	2677	+ return null;
	2678	+ }
	2679	+ } else {
	2680	+ return null;
	2681	+ }
	2682	+ }
	2683	+
	2684	+ /**
	2685	+ * Return the number of characters (valid indicies)
	2686	+ *
	2687	+ * @return the number of characters
	2688	+ * @since 1.3
	2689	+ */
	2690	+ public int getCharCount() {
	2691	+ View view = (View) AbstractButton.this.getClientProperty("html");
	2692	+ if (view != null) {
	2693	+ Document d = view.getDocument();
	2694	+ if (d instanceof StyledDocument) {
	2695	+ StyledDocument doc = (StyledDocument)d;
	2696	+ return doc.getLength();
	2697	+ }
	2698	+ }
	2699	+ return accessibleContext.getAccessibleName().length();
	2700	+ }
	2701	+
	2702	+ /**
	2703	+ * Return the zero-based offset of the caret.
	2704	+ *
	2705	+ * Note: That to the right of the caret will have the same index
	2706	+ * value as the offset (the caret is between two characters).
	2707	+ * @return the zero-based offset of the caret.
	2708	+ * @since 1.3
	2709	+ */
	2710	+ public int getCaretPosition() {
	2711	+ // There is no caret.
	2712	+ return -1;
	2713	+ }
	2714	+
	2715	+ /**
	2716	+ * Returns the String at a given index.
	2717	+ *
	2718	+ * @param part the AccessibleText.CHARACTER, AccessibleText.WORD,
	2719	+ * or AccessibleText.SENTENCE to retrieve
	2720	+ * @param index an index within the text >= 0
	2721	+ * @return the letter, word, or sentence,
	2722	+ * null for an invalid index or part
	2723	+ * @since 1.3
	2724	+ */
	2725	+ public String getAtIndex(int part, int index) {
	2726	+ if (index < 0 \|\| index >= getCharCount()) {
	2727	+ return null;
	2728	+ }
	2729	+ switch (part) {
	2730	+ case AccessibleText.CHARACTER:
	2731	+ try {
	2732	+ return getText(index, 1);
	2733	+ } catch (BadLocationException e) {
	2734	+ return null;
	2735	+ }
	2736	+ case AccessibleText.WORD:
	2737	+ try {
	2738	+ String s = getText(0, getCharCount());
	2739	+ BreakIterator words = BreakIterator.getWordInstance(getLocale());
	2740	+ words.setText(s);
	2741	+ int end = words.following(index);
	2742	+ return s.substring(words.previous(), end);
	2743	+ } catch (BadLocationException e) {
	2744	+ return null;
	2745	+ }
	2746	+ case AccessibleText.SENTENCE:
	2747	+ try {
	2748	+ String s = getText(0, getCharCount());
	2749	+ BreakIterator sentence =
	2750	+ BreakIterator.getSentenceInstance(getLocale());
	2751	+ sentence.setText(s);
	2752	+ int end = sentence.following(index);
	2753	+ return s.substring(sentence.previous(), end);
	2754	+ } catch (BadLocationException e) {
	2755	+ return null;
	2756	+ }
	2757	+ default:
	2758	+ return null;
	2759	+ }
	2760	+ }
	2761	+
	2762	+ /**
	2763	+ * Returns the String after a given index.
	2764	+ *
	2765	+ * @param part the AccessibleText.CHARACTER, AccessibleText.WORD,
	2766	+ * or AccessibleText.SENTENCE to retrieve
	2767	+ * @param index an index within the text >= 0
	2768	+ * @return the letter, word, or sentence, null for an invalid
	2769	+ * index or part
	2770	+ * @since 1.3
	2771	+ */
	2772	+ public String getAfterIndex(int part, int index) {
	2773	+ if (index < 0 \|\| index >= getCharCount()) {
	2774	+ return null;
	2775	+ }
	2776	+ switch (part) {
	2777	+ case AccessibleText.CHARACTER:
	2778	+ if (index+1 >= getCharCount()) {
	2779	+ return null;
	2780	+ }
	2781	+ try {
	2782	+ return getText(index+1, 1);
	2783	+ } catch (BadLocationException e) {
	2784	+ return null;
	2785	+ }
	2786	+ case AccessibleText.WORD:
	2787	+ try {
	2788	+ String s = getText(0, getCharCount());
	2789	+ BreakIterator words = BreakIterator.getWordInstance(getLocale());
	2790	+ words.setText(s);
	2791	+ int start = words.following(index);
	2792	+ if (start == BreakIterator.DONE \|\| start >= s.length()) {
	2793	+ return null;
	2794	+ }
	2795	+ int end = words.following(start);
	2796	+ if (end == BreakIterator.DONE \|\| end >= s.length()) {
	2797	+ return null;
	2798	+ }
	2799	+ return s.substring(start, end);
	2800	+ } catch (BadLocationException e) {
	2801	+ return null;
	2802	+ }
	2803	+ case AccessibleText.SENTENCE:
	2804	+ try {
	2805	+ String s = getText(0, getCharCount());
	2806	+ BreakIterator sentence =
	2807	+ BreakIterator.getSentenceInstance(getLocale());
	2808	+ sentence.setText(s);
	2809	+ int start = sentence.following(index);
	2810	+ if (start == BreakIterator.DONE \|\| start > s.length()) {
	2811	+ return null;
	2812	+ }
	2813	+ int end = sentence.following(start);
	2814	+ if (end == BreakIterator.DONE \|\| end > s.length()) {
	2815	+ return null;
	2816	+ }
	2817	+ return s.substring(start, end);
	2818	+ } catch (BadLocationException e) {
	2819	+ return null;
	2820	+ }
	2821	+ default:
	2822	+ return null;
	2823	+ }
	2824	+ }
	2825	+
	2826	+ /**
	2827	+ * Returns the String before a given index.
	2828	+ *
	2829	+ * @param part the AccessibleText.CHARACTER, AccessibleText.WORD,
	2830	+ * or AccessibleText.SENTENCE to retrieve
	2831	+ * @param index an index within the text >= 0
	2832	+ * @return the letter, word, or sentence, null for an invalid index
	2833	+ * or part
	2834	+ * @since 1.3
	2835	+ */
	2836	+ public String getBeforeIndex(int part, int index) {
	2837	+ if (index < 0 \|\| index > getCharCount()-1) {
	2838	+ return null;
	2839	+ }
	2840	+ switch (part) {
	2841	+ case AccessibleText.CHARACTER:
	2842	+ if (index == 0) {
	2843	+ return null;
	2844	+ }
	2845	+ try {
	2846	+ return getText(index-1, 1);
	2847	+ } catch (BadLocationException e) {
	2848	+ return null;
	2849	+ }
	2850	+ case AccessibleText.WORD:
	2851	+ try {
	2852	+ String s = getText(0, getCharCount());
	2853	+ BreakIterator words = BreakIterator.getWordInstance(getLocale());
	2854	+ words.setText(s);
	2855	+ int end = words.following(index);
	2856	+ end = words.previous();
	2857	+ int start = words.previous();
	2858	+ if (start == BreakIterator.DONE) {
	2859	+ return null;
	2860	+ }
	2861	+ return s.substring(start, end);
	2862	+ } catch (BadLocationException e) {
	2863	+ return null;
	2864	+ }
	2865	+ case AccessibleText.SENTENCE:
	2866	+ try {
	2867	+ String s = getText(0, getCharCount());
	2868	+ BreakIterator sentence =
	2869	+ BreakIterator.getSentenceInstance(getLocale());
	2870	+ sentence.setText(s);
	2871	+ int end = sentence.following(index);
	2872	+ end = sentence.previous();
	2873	+ int start = sentence.previous();
	2874	+ if (start == BreakIterator.DONE) {
	2875	+ return null;
	2876	+ }
	2877	+ return s.substring(start, end);
	2878	+ } catch (BadLocationException e) {
	2879	+ return null;
	2880	+ }
	2881	+ default:
	2882	+ return null;
	2883	+ }
	2884	+ }
	2885	+
	2886	+ /**
	2887	+ * Return the AttributeSet for a given character at a given index
	2888	+ *
	2889	+ * @param i the zero-based index into the text
	2890	+ * @return the AttributeSet of the character
	2891	+ * @since 1.3
	2892	+ */
	2893	+ public AttributeSet getCharacterAttribute(int i) {
	2894	+ View view = (View) AbstractButton.this.getClientProperty("html");
	2895	+ if (view != null) {
	2896	+ Document d = view.getDocument();
	2897	+ if (d instanceof StyledDocument) {
	2898	+ StyledDocument doc = (StyledDocument)d;
	2899	+ Element elem = doc.getCharacterElement(i);
	2900	+ if (elem != null) {
	2901	+ return elem.getAttributes();
	2902	+ }
	2903	+ }
	2904	+ }
	2905	+ return null;
	2906	+ }
	2907	+
	2908	+ /**
	2909	+ * Returns the start offset within the selected text.
	2910	+ * If there is no selection, but there is
	2911	+ * a caret, the start and end offsets will be the same.
	2912	+ *
	2913	+ * @return the index into the text of the start of the selection
	2914	+ * @since 1.3
	2915	+ */
	2916	+ public int getSelectionStart() {
	2917	+ // Text cannot be selected.
	2918	+ return -1;
	2919	+ }
	2920	+
	2921	+ /**
	2922	+ * Returns the end offset within the selected text.
	2923	+ * If there is no selection, but there is
	2924	+ * a caret, the start and end offsets will be the same.
	2925	+ *
	2926	+ * @return the index into teh text of the end of the selection
	2927	+ * @since 1.3
	2928	+ */
	2929	+ public int getSelectionEnd() {
	2930	+ // Text cannot be selected.
	2931	+ return -1;
	2932	+ }
	2933	+
	2934	+ /**
	2935	+ * Returns the portion of the text that is selected.
	2936	+ *
	2937	+ * @return the String portion of the text that is selected
	2938	+ * @since 1.3
	2939	+ */
	2940	+ public String getSelectedText() {
	2941	+ // Text cannot be selected.
	2942	+ return null;
	2943	+ }
	2944	+
	2945	+ /*
	2946	+ * Returns the text substring starting at the specified
	2947	+ * offset with the specified length.
	2948	+ */
	2949	+ private String getText(int offset, int length)
	2950	+ throws BadLocationException {
	2951	+
	2952	+ View view = (View) AbstractButton.this.getClientProperty("html");
	2953	+ if (view != null) {
	2954	+ Document d = view.getDocument();
	2955	+ if (d instanceof StyledDocument) {
	2956	+ StyledDocument doc = (StyledDocument)d;
	2957	+ return doc.getText(offset, length);
	2958	+ }
	2959	+ }
	2960	+ return null;
	2961	+ }
	2962	+
	2963	+ /*
	2964	+ * Returns the bounding rectangle for the component text.
	2965	+ */
	2966	+ private Rectangle getTextRectangle() {
	2967	+
	2968	+ String text = AbstractButton.this.getText();
	2969	+ Icon icon = (AbstractButton.this.isEnabled()) ? AbstractButton.this.getIcon() : AbstractButton.this.getDisabledIcon();
	2970	+
	2971	+ if ((icon == null) && (text == null)) {
	2972	+ return null;
	2973	+ }
	2974	+
	2975	+ Rectangle paintIconR = new Rectangle();
	2976	+ Rectangle paintTextR = new Rectangle();
	2977	+ Rectangle paintViewR = new Rectangle();
	2978	+ Insets paintViewInsets = new Insets(0, 0, 0, 0);
	2979	+
	2980	+ paintViewInsets = AbstractButton.this.getInsets(paintViewInsets);
	2981	+ paintViewR.x = paintViewInsets.left;
	2982	+ paintViewR.y = paintViewInsets.top;
	2983	+ paintViewR.width = AbstractButton.this.getWidth() - (paintViewInsets.left + paintViewInsets.right);
	2984	+ paintViewR.height = AbstractButton.this.getHeight() - (paintViewInsets.top + paintViewInsets.bottom);
	2985	+
	2986	+ String clippedText = SwingUtilities.layoutCompoundLabel(
	2987	+ AbstractButton.this,
	2988	+ getFontMetrics(getFont()),
	2989	+ text,
	2990	+ icon,
	2991	+ AbstractButton.this.getVerticalAlignment(),
	2992	+ AbstractButton.this.getHorizontalAlignment(),
	2993	+ AbstractButton.this.getVerticalTextPosition(),
	2994	+ AbstractButton.this.getHorizontalTextPosition(),
	2995	+ paintViewR,
	2996	+ paintIconR,
	2997	+ paintTextR,
	2998	+ 0);
	2999	+
	3000	+ return paintTextR;
	3001	+ }
	3002	+
	3003	+ // ----- AccessibleExtendedComponent
	3004	+
	3005	+ /**
	3006	+ * Returns the AccessibleExtendedComponent
	3007	+ *
	3008	+ * @return the AccessibleExtendedComponent
	3009	+ */
	3010	+ AccessibleExtendedComponent getAccessibleExtendedComponent() {
	3011	+ return this;
	3012	+ }
	3013	+
	3014	+ /**
	3015	+ * Returns the tool tip text
	3016	+ *
	3017	+ * @return the tool tip text, if supported, of the object;
	3018	+ * otherwise, null
	3019	+ * @since 1.4
	3020	+ */
	3021	+ public String getToolTipText() {
	3022	+ return AbstractButton.this.getToolTipText();
	3023	+ }
	3024	+
	3025	+ /**
	3026	+ * Returns the titled border text
	3027	+ *
	3028	+ * @return the titled border text, if supported, of the object;
	3029	+ * otherwise, null
	3030	+ * @since 1.4
	3031	+ */
	3032	+ public String getTitledBorderText() {
	3033	+ return super.getTitledBorderText();
	3034	+ }
	3035	+
	3036	+ /**
	3037	+ * Returns key bindings associated with this object
	3038	+ *
	3039	+ * @return the key bindings, if supported, of the object;
	3040	+ * otherwise, null
	3041	+ * @see AccessibleKeyBinding
	3042	+ * @since 1.4
	3043	+ */
	3044	+ public AccessibleKeyBinding getAccessibleKeyBinding() {
	3045	+ int mnemonic = AbstractButton.this.getMnemonic();
	3046	+ if (mnemonic == 0) {
	3047	+ return null;
	3048	+ }
	3049	+ return new ButtonKeyBinding(mnemonic);
	3050	+ }
	3051	+
	3052	+ class ButtonKeyBinding implements AccessibleKeyBinding {
	3053	+ int mnemonic;
	3054	+
	3055	+ ButtonKeyBinding(int mnemonic) {
	3056	+ this.mnemonic = mnemonic;
	3057	+ }
	3058	+
	3059	+ /**
	3060	+ * Returns the number of key bindings for this object
	3061	+ *
	3062	+ * @return the zero-based number of key bindings for this object
	3063	+ */
	3064	+ public int getAccessibleKeyBindingCount() {
	3065	+ return 1;
	3066	+ }
	3067	+
	3068	+ /**
	3069	+ * Returns a key binding for this object. The value returned is an
	3070	+ * java.lang.Object which must be cast to appropriate type depending
	3071	+ * on the underlying implementation of the key. For example, if the
	3072	+ * Object returned is a javax.swing.KeyStroke, the user of this
	3073	+ * method should do the following:
	3074	+ * <nf><code>
	3075	+ * Component c = <get the component that has the key bindings>
	3076	+ * AccessibleContext ac = c.getAccessibleContext();
	3077	+ * AccessibleKeyBinding akb = ac.getAccessibleKeyBinding();
	3078	+ * for (int i = 0; i < akb.getAccessibleKeyBindingCount(); i++) {
	3079	+ * Object o = akb.getAccessibleKeyBinding(i);
	3080	+ * if (o instanceof javax.swing.KeyStroke) {
	3081	+ * javax.swing.KeyStroke keyStroke = (javax.swing.KeyStroke)o;
	3082	+ * <do something with the key binding>
	3083	+ * }
	3084	+ * }
	3085	+ * </code></nf>
	3086	+ *
	3087	+ * @param i zero-based index of the key bindings
	3088	+ * @return a javax.lang.Object which specifies the key binding
	3089	+ * @exception IllegalArgumentException if the index is
	3090	+ * out of bounds
	3091	+ * @see #getAccessibleKeyBindingCount
	3092	+ */
	3093	+ public java.lang.Object getAccessibleKeyBinding(int i) {
	3094	+ if (i != 0) {
	3095	+ throw new IllegalArgumentException();
	3096	+ }
	3097	+ return KeyStroke.getKeyStroke(mnemonic, 0);
	3098	+ }
	3099	+ }
	3100	+ }
	3101	+}