From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- .../classpath/javax/swing/DefaultButtonModel.java | 578 +++++++++++++++++++++ 1 file changed, 578 insertions(+) create mode 100644 libjava/classpath/javax/swing/DefaultButtonModel.java (limited to 'libjava/classpath/javax/swing/DefaultButtonModel.java') diff --git a/libjava/classpath/javax/swing/DefaultButtonModel.java b/libjava/classpath/javax/swing/DefaultButtonModel.java new file mode 100644 index 000000000..d29a23ed3 --- /dev/null +++ b/libjava/classpath/javax/swing/DefaultButtonModel.java @@ -0,0 +1,578 @@ +/* DefaultButtonModel.java -- + Copyright (C) 2002, 2004, 2006, Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package javax.swing; + +import java.awt.ItemSelectable; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.ItemEvent; +import java.awt.event.ItemListener; +import java.awt.event.KeyEvent; +import java.io.Serializable; +import java.util.EventListener; + +import javax.swing.event.ChangeEvent; +import javax.swing.event.ChangeListener; +import javax.swing.event.EventListenerList; + +/** + * The default implementation of {@link ButtonModel}. + * The purpose of this class is to model the dynamic state of an abstract + * button. The concrete button type holding this state may be a a "toggle" + * button (checkbox, radio button) or a "push" button (menu button, button). + * If the model is disabled, only the "selected" property can be changed. An + * attempt to change the "armed", "rollover" or "pressed" properties while + * the model is disabled will be blocked. Any successful (non-blocked) change + * to the model's properties will trigger the firing of a ChangeEvent. Any + * change to the "selected" property will trigger the firing of an ItemEvent + * in addition to ChangeEvent. This is true whether the model is enabled or + * not. One other state change is special: the transition from "enabled, + * armed and pressed" to "enabled, armed and not-pressed". This is considered + * the "trailing edge" of a successful mouse click, and therefore fires an + * ActionEvent in addition to a ChangeEvent. In all other respects this class + * is just a container of boolean flags. + * + * @author Graydon Hoare (graydon_at_redhat.com) + */ +public class DefaultButtonModel implements ButtonModel, Serializable +{ + /** DOCUMENT ME! */ + private static final long serialVersionUID = -5342609566534980231L; + + /** + * Indicates that the button is partially committed to being + * pressed, but not entirely. This usually happens when a user has pressed + * but not yet released the mouse button. + */ + public static final int ARMED = 1; + + /** + * State constant indicating that the button is enabled. Buttons cannot be + * pressed or selected unless they are enabled. + */ + public static final int ENABLED = 8; + + /** + * State constant indicating that the user is holding down the button. When + * this transitions from true to false, an ActionEvent may be fired, + * depending on the value of the "armed" property. + */ + public static final int PRESSED = 4; + + /** + * State constant indicating that the mouse is currently positioned over the + * button. + */ + public static final int ROLLOVER = 16; + + /** + * State constant indicating that the button is selected. This constant is + * only meaningful for toggle-type buttons (radio buttons, checkboxes). + */ + public static final int SELECTED = 2; + + /** + * Represents the "state properties" (armed, enabled, pressed, rollover and + * selected) by a bitwise combination of integer constants. + */ + protected int stateMask = ENABLED; + + /** + * List of ItemListeners, ChangeListeners, and ActionListeners registered on + * this model. + */ + protected EventListenerList listenerList = new EventListenerList(); + + /** The single ChangeEvent this model (re)uses to call its ChangeListeners. */ + protected ChangeEvent changeEvent = new ChangeEvent(this); + + /** + * The group this model belongs to. Only one button in a group may be + * selected at any given time. + */ + protected ButtonGroup group; + + /** + * The key code (one of {@link java.awt.event.KeyEvent} VK_) used to press + * this button via a keyboard interface. + */ + protected int mnemonic = KeyEvent.VK_UNDEFINED; + + /** + * The string used as the "command" property of any ActionEvent this model + * sends. + */ + protected String actionCommand; + + /** + * Creates a new DefaultButtonModel object. + */ + public DefaultButtonModel() + { + // Nothing to do here. + } + + /** + * Return null. Use {@link AbstractButton} if you wish to + * interface with a button via an {@link ItemSelectable} interface. + * + * @return null + */ + public Object[] getSelectedObjects() + { + return null; + } + + /** + * Returns a specified class of listeners. + * + * @param listenerType the type of listener to return + * + * @return array of listeners + */ + public T[] getListeners(Class listenerType) + { + return listenerList.getListeners(listenerType); + } + + /** + * Add an ActionListener to the model. Usually only called to subscribe an + * AbstractButton's listener to the model. + * + * @param l The listener to add + */ + public void addActionListener(ActionListener l) + { + listenerList.add(ActionListener.class, l); + } + + /** + * Remove an ActionListener to the model. Usually only called to unsubscribe + * an AbstractButton's listener to the model. + * + * @param l The listener to remove + */ + public void removeActionListener(ActionListener l) + { + listenerList.remove(ActionListener.class, l); + } + + /** + * Returns all registered ActionListener objects. + * + * @return array of ActionListener objects + */ + public ActionListener[] getActionListeners() + { + return (ActionListener[]) listenerList.getListeners(ActionListener.class); + } + + /** + * Add an ItemListener to the model. Usually only called to subscribe an + * AbstractButton's listener to the model. + * + * @param l The listener to add + */ + public void addItemListener(ItemListener l) + { + listenerList.add(ItemListener.class, l); + } + + /** + * Remove an ItemListener to the model. Usually only called to unsubscribe + * an AbstractButton's listener to the model. + * + * @param l The listener to remove + */ + public void removeItemListener(ItemListener l) + { + listenerList.remove(ItemListener.class, l); + } + + /** + * Returns all registered ItemListener objects. + * + * @return array of ItemListener objects + */ + public ItemListener[] getItemListeners() + { + return (ItemListener[]) listenerList.getListeners(ItemListener.class); + } + + /** + * Add a ChangeListener to the model. Usually only called to subscribe an + * AbstractButton's listener to the model. + * + * @param l The listener to add + */ + public void addChangeListener(ChangeListener l) + { + listenerList.add(ChangeListener.class, l); + } + + /** + * Remove a ChangeListener to the model. Usually only called to unsubscribe + * an AbstractButton's listener to the model. + * + * @param l The listener to remove + */ + public void removeChangeListener(ChangeListener l) + { + listenerList.remove(ChangeListener.class, l); + } + + /** + * Returns all registered ChangeListener objects. + * + * @return array of ChangeListener objects + */ + public ChangeListener[] getChangeListeners() + { + return (ChangeListener[]) listenerList.getListeners(ChangeListener.class); + } + + /** + * Inform each ItemListener in the {@link #listenerList} that an ItemEvent + * has occurred. This happens in response to any change to the {@link + * #stateMask} field. + * + * @param e The ItemEvent to fire + */ + protected void fireItemStateChanged(ItemEvent e) + { + ItemListener[] ll = getItemListeners(); + + for (int i = 0; i < ll.length; i++) + ll[i].itemStateChanged(e); + } + + /** + * Inform each ActionListener in the {@link #listenerList} that an + * ActionEvent has occurred. This happens in response to the any change to + * the {@link #stateMask} field which makes the enabled, armed and pressed + * properties all simultaneously true. + * + * @param e The ActionEvent to fire + */ + protected void fireActionPerformed(ActionEvent e) + { + ActionListener[] ll = getActionListeners(); + + for (int i = 0; i < ll.length; i++) + ll[i].actionPerformed(e); + } + + /** + * Inform each ChangeListener in the {@link #listenerList} that a ChangeEvent + * has occurred. This happens in response to the any change to a property + * of the model. + */ + protected void fireStateChanged() + { + ChangeListener[] ll = getChangeListeners(); + + for (int i = 0; i < ll.length; i++) + ll[i].stateChanged(changeEvent); + } + + /** + * Get the value of the model's "armed" property. + * + * @return The current "armed" property + */ + public boolean isArmed() + { + return (stateMask & ARMED) == ARMED; + } + + /** + * Set the value of the model's "armed" property. + * + * @param a The new "armed" property + */ + public void setArmed(boolean a) + { + // if this call does not represent a CHANGE in state, then return + if ((a && isArmed()) || (!a && !isArmed())) + return; + + // cannot change ARMED state unless button is enabled + if (!isEnabled()) + return; + + // make the change + if (a) + stateMask = stateMask | ARMED; + else + stateMask = stateMask & (~ARMED); + + // notify interested ChangeListeners + fireStateChanged(); + } + + /** + * Get the value of the model's "enabled" property. + * + * @return The current "enabled" property. + */ + public boolean isEnabled() + { + return (stateMask & ENABLED) == ENABLED; + } + + /** + * Set the value of the model's "enabled" property. + * + * @param e The new "enabled" property + */ + public void setEnabled(boolean e) + { + // if this call does not represent a CHANGE in state, then return + if ((e && isEnabled()) || (!e && !isEnabled())) + return; + + // make the change + if (e) + stateMask = stateMask | ENABLED; + else + stateMask = stateMask & (~ENABLED) & (~ARMED) & (~PRESSED); + + // notify interested ChangeListeners + fireStateChanged(); + } + + /** + * Set the value of the model's "pressed" property. + * + * @param p The new "pressed" property + */ + public void setPressed(boolean p) + { + // if this call does not represent a CHANGE in state, then return + if ((p && isPressed()) || (!p && !isPressed())) + return; + + // cannot changed PRESSED state unless button is enabled + if (!isEnabled()) + return; + + // make the change + if (p) + stateMask = stateMask | PRESSED; + else + stateMask = stateMask & (~PRESSED); + + // if button is armed and was released, fire action event + if (!p && isArmed()) + fireActionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, + actionCommand)); + + // notify interested ChangeListeners + fireStateChanged(); + } + + /** + * Get the value of the model's "pressed" property. + * + * @return The current "pressed" property + */ + public boolean isPressed() + { + return (stateMask & PRESSED) == PRESSED; + } + + /** + * Set the value of the model's "rollover" property. + * + * @param r The new "rollover" property + */ + public void setRollover(boolean r) + { + // if this call does not represent a CHANGE in state, then return + if (r == isRollover()) + return; + + // cannot set ROLLOVER property unless button is enabled + if (!isEnabled()) + return; + + // make the change + if (r) + stateMask = stateMask | ROLLOVER; + else + stateMask = stateMask & (~ROLLOVER); + + // notify interested ChangeListeners + fireStateChanged(); + } + + /** + * Set the value of the model's "selected" property. + * + * @param s The new "selected" property + */ + public void setSelected(boolean s) + { + // if this call does not represent a CHANGE in state, then return + if ((s && isSelected()) || (!s && !isSelected())) + return; + + // make the change + if (s) + stateMask = stateMask | SELECTED; + else + stateMask = stateMask & (~SELECTED); + + // notify interested ChangeListeners + fireStateChanged(); + + // fire ItemStateChanged events + if (s) + { + fireItemStateChanged(new ItemEvent(this, ItemEvent.ITEM_STATE_CHANGED, + this, ItemEvent.SELECTED)); + if (group != null) + group.setSelected(this, true); + } + else + { + fireItemStateChanged(new ItemEvent(this, ItemEvent.ITEM_STATE_CHANGED, + this, ItemEvent.DESELECTED)); + if (group != null) + group.setSelected(this, false); + } + } + + /** + * Get the value of the model's "selected" property. + * + * @return The current "selected" property + */ + public boolean isSelected() + { + return (stateMask & SELECTED) == SELECTED; + } + + /** + * Get the value of the model's "rollover" property. + * + * @return The current "rollover" property + */ + public boolean isRollover() + { + return (stateMask & ROLLOVER) == ROLLOVER; + } + + /** + * Get the value of the model's "mnemonic" property. + * + * @return The current "mnemonic" property + */ + public int getMnemonic() + { + return mnemonic; + } + + /** + * Set the value of the model's "mnemonic" property. + * + * @param key The new "mnemonic" property + */ + public void setMnemonic(int key) + { + if (mnemonic != key) + { + mnemonic = key; + fireStateChanged(); + } + } + + /** + * Set the value of the model's "actionCommand" property. This property is + * used as the "command" property of the {@link ActionEvent} fired from the + * model. + * + * @param s The new "actionCommand" property. + */ + public void setActionCommand(String s) + { + if (actionCommand != s) + { + actionCommand = s; + fireStateChanged(); + } + } + + /** + * Returns the current value of the model's "actionCommand" property. + * + * @return The current "actionCommand" property + */ + public String getActionCommand() + { + return actionCommand; + } + + /** + * Set the value of the model's "group" property. The model is said to be a + * member of the {@link ButtonGroup} held in its "group" property, and only + * one model in a given group can have their "selected" property be + * true at a time. + * + * @param g The new "group" property (null permitted). + * + * @see #getGroup() + */ + public void setGroup(ButtonGroup g) + { + group = g; + } + + /** + * Returns the current value of the model's "group" property. + * + * @return The value of the "group" property + * + * @see #setGroup(ButtonGroup) + */ + public ButtonGroup getGroup() + { + return group; + } +} -- cgit v1.2.3