home *** CD-ROM | disk | FTP | other *** search
/ Java 1.2 How-To / JavaHowTo.iso / 3rdParty / jbuilder / unsupported / JDK1.2beta3 / SOURCE / SRC.ZIP / java / awt / swing / DefaultButtonModel.java < prev    next >
Encoding:
Java Source  |  1998-03-20  |  11.0 KB  |  388 lines
  1. /*
  2.  * @(#)DefaultButtonModel.java    1.21 98/02/02
  3.  * 
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  */
  20. package java.awt.swing;
  21.  
  22. import java.awt.*;
  23. import java.awt.event.*;
  24. import java.awt.image.*;
  25. import java.io.Serializable;
  26. import java.util.EventListener;
  27. import java.awt.swing.event.*;
  28.  
  29. /**
  30.  * The default implementation of a Button component's
  31.  * data model.
  32.  * <p>
  33.  * Warning: serialized objects of this class will not be compatible with
  34.  * future swing releases.  The current serialization support is appropriate 
  35.  * for short term storage or RMI between Swing1.0 applications.  It will
  36.  * not be possible to load serialized Swing1.0 objects with future releases
  37.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  38.  * baseline for the serialized form of Swing objects.
  39.  *
  40.  * @version 1.21 02/02/98
  41.  * @author Jeff Dinkins
  42.  */
  43. public class DefaultButtonModel implements ButtonModel, Serializable {
  44.  
  45.     protected int stateMask = 0;
  46.     protected String actionCommand = null;
  47.     protected ButtonGroup group = null;
  48.         
  49.     protected int mnemonic = 0;
  50.  
  51.     /**
  52.      * Only one ChangeEvent is needed per button model instance since the
  53.      * event's only state is the source property.  The source of events
  54.      * generated is always "this".
  55.      */
  56.     protected transient ChangeEvent changeEvent = null;
  57.     protected EventListenerList listenerList = new EventListenerList();
  58.     
  59.         
  60.     /**
  61.      * Constructs a JButtonModel
  62.      *
  63.      */
  64.     public DefaultButtonModel() {
  65.         stateMask = 0;
  66.         setEnabled(true);
  67.     }
  68.         
  69.     /**
  70.      * Indicates if the button can be selected or not by
  71.      * an input device (such as a mouse pointer).
  72.      *
  73.      * @see ButtonModel#setArmed
  74.      */
  75.     public final static int ARMED = 1 << 0;
  76.         
  77.     /**
  78.      * Indicates if the button has been selected. Only needed for
  79.      * certain types of buttons - such as RadioButton or Checkbox.
  80.      */
  81.     public final static int SELECTED = 1 << 1;
  82.         
  83.     /**
  84.      * Indicates partial commitment towards choosing the
  85.      * button.
  86.      */
  87.     public final static int PRESSED = 1 << 2;
  88.         
  89.     /**
  90.      * Indicates whether the button is currently enabled.
  91.      */
  92.     public final static int ENABLED = 1 << 3;
  93.  
  94.     /**
  95.      * Indicates that the mouse is over the button.
  96.      */
  97.     public final static int ROLLOVER = 1 << 4;
  98.         
  99.     /**
  100.      * Sets the actionCommand that gets sent when the putton is pressed.
  101.      */
  102.     public void setActionCommand(String actionCommand) {
  103.         this.actionCommand = actionCommand;
  104.     }
  105.         
  106.     /**
  107.      * Returns the action command for this button. 
  108.      */
  109.     public String getActionCommand() {
  110.         return actionCommand;
  111.     }
  112.  
  113.     /**
  114.      * Returns whether the button is "armed".
  115.      * 
  116.      * @return true if the button is armed, and it can be selected
  117.      * @see ButtonModel#setArmed
  118.      */
  119.     public boolean isArmed() {
  120.         return (stateMask & ARMED) != 0;
  121.     }
  122.         
  123.     /**
  124.      * Checks if the button is selected.
  125.      */
  126.     public boolean isSelected() {
  127.         return (stateMask & SELECTED) != 0;
  128.     }
  129.         
  130.     /**
  131.      * Checks if the button is disabled.
  132.      */
  133.     public boolean isEnabled() {
  134.         return (stateMask & ENABLED) != 0;
  135.     }
  136.         
  137.     /**
  138.      * Checks if the button is pressed.
  139.      */
  140.     public boolean isPressed() {
  141.         return (stateMask & PRESSED) != 0;
  142.     }
  143.         
  144.     /**
  145.      * Checks if the button is rolled over.
  146.      */
  147.     public boolean isRollover() {
  148.         return (stateMask & ROLLOVER) != 0;
  149.     }
  150.         
  151.     /**
  152.      * Identifies the button as "armed". 
  153.      *
  154.      * @param b true to arm the button so it can be selected
  155.      * @see ButtonModel#setArmed
  156.      */
  157.     public void setArmed(boolean b) {
  158.         if((isArmed() == b) || !isEnabled()) {
  159.             return;
  160.         }
  161.             
  162.         if (b) {
  163.             stateMask |= ARMED;
  164.         } else {
  165.             stateMask &= ~ARMED;
  166.         }
  167.             
  168.         fireStateChanged();
  169.     }
  170.  
  171.     /**
  172.      * Sets the button to be enabled or disabled state
  173.      */
  174.     public void setEnabled(boolean b) {
  175.         if(isEnabled() == b) {
  176.             return;
  177.         }
  178.             
  179.         if (b) {
  180.             stateMask |= ENABLED;
  181.         } else {
  182.             stateMask &= ~ENABLED;
  183.         }
  184.             
  185.         fireStateChanged();
  186.     }
  187.         
  188.     /**
  189.      * Sets the selected state of the button.
  190.      * @param b true selects the toggle button,
  191.      *          false deselects the toggle button.
  192.      */
  193.     public void setSelected(boolean b) {
  194.         if (this.isSelected() == b) {
  195.             return;
  196.         }
  197.  
  198.         if (b) {
  199.             stateMask |= SELECTED;
  200.         } else {
  201.             stateMask &= ~SELECTED;
  202.         }
  203.  
  204.         fireItemStateChanged(
  205.                 new ItemEvent(this,
  206.                               ItemEvent.ITEM_STATE_CHANGED,
  207.                               this,
  208.                               b ?  ItemEvent.SELECTED : ItemEvent.DESELECTED));
  209.         
  210.         fireStateChanged();
  211.         
  212.     }
  213.         
  214.         
  215.     /**
  216.      * Sets the button to pressed state
  217.      */
  218.     public void setPressed(boolean b) {
  219.         if((isPressed() == b) || !isEnabled()) {
  220.             return;
  221.         }
  222.         
  223.         if (b) {
  224.             stateMask |= PRESSED;
  225.         } else {
  226.             stateMask &= ~PRESSED;
  227.         }
  228.  
  229.         if(!isPressed() && isArmed()) {
  230.             fireActionPerformed(
  231.                 new ActionEvent(this, ActionEvent.ACTION_PERFORMED,
  232.                                 getActionCommand())
  233.                 );
  234.         }
  235.             
  236.         fireStateChanged();
  237.     }   
  238.  
  239.     /**
  240.      * Sets the button to the rollover state
  241.      */
  242.     public void setRollover(boolean b) {
  243.         if((isRollover() == b) || !isEnabled()) {
  244.             return;
  245.         }
  246.         
  247.         if (b) {
  248.             stateMask |= ROLLOVER;
  249.         } else {
  250.             stateMask &= ~ROLLOVER;
  251.         }
  252.  
  253.         fireStateChanged();
  254.     }
  255.  
  256.     /**
  257.      * Sets the keyboard mnemonic for this model
  258.      */    
  259.     public void setMnemonic(int key) {
  260.     mnemonic = key;
  261.     fireStateChanged();
  262.     }
  263.  
  264.     /**
  265.      * Gets the keyboard mnemonic for this model
  266.      */
  267.     public int getMnemonic() {
  268.     return mnemonic;
  269.     }
  270.  
  271.     /**
  272.      * Adds a ChangeListener to the button.
  273.      */
  274.     public void addChangeListener(ChangeListener l) {
  275.         listenerList.add(ChangeListener.class, l);
  276.     }
  277.     
  278.     /**
  279.      * Removes a ChangeListener from the button.
  280.      */
  281.     public void removeChangeListener(ChangeListener l) {
  282.         listenerList.remove(ChangeListener.class, l);
  283.     }
  284.  
  285.     /*
  286.      * Notify all listeners that have registered interest for
  287.      * notification on this event type.  The event instance 
  288.      * is lazily created using the parameters passed into 
  289.      * the fire method.
  290.      * @see EventListenerList
  291.      */
  292.     protected void fireStateChanged() {
  293.         // Guaranteed to return a non-null array
  294.         Object[] listeners = listenerList.getListenerList();
  295.         // Process the listeners last to first, notifying
  296.         // those that are interested in this event
  297.         for (int i = listeners.length-2; i>=0; i-=2) {
  298.             if (listeners[i]==ChangeListener.class) {
  299.                 // Lazily create the event:
  300.                 if (changeEvent == null)
  301.                     changeEvent = new ChangeEvent(this);
  302.                 ((ChangeListener)listeners[i+1]).stateChanged(changeEvent);
  303.             }          
  304.         }
  305.     }   
  306.     
  307.     /**
  308.      * adds an ActionListener to the button
  309.      */
  310.     public void addActionListener(ActionListener l) {
  311.         listenerList.add(ActionListener.class, l);
  312.     }
  313.         
  314.     /**
  315.      * removes an ActionListener from the button
  316.      */
  317.     public void removeActionListener(ActionListener l) {
  318.         listenerList.remove(ActionListener.class, l);
  319.     }
  320.  
  321.     /*
  322.      * Notify all listeners that have registered interest for
  323.      * notification on this event type.  The event instance 
  324.      * is lazily created using the parameters passed into 
  325.      * the fire method.
  326.      * @see EventListenerList
  327.      */
  328.     protected void fireActionPerformed(ActionEvent e) {
  329.         // Guaranteed to return a non-null array
  330.         Object[] listeners = listenerList.getListenerList();
  331.         // Process the listeners last to first, notifying
  332.         // those that are interested in this event
  333.         for (int i = listeners.length-2; i>=0; i-=2) {
  334.             if (listeners[i]==ActionListener.class) {
  335.                 // Lazily create the event:
  336.                 // if (changeEvent == null)
  337.                 // changeEvent = new ChangeEvent(this);
  338.                 ((ActionListener)listeners[i+1]).actionPerformed(e);
  339.             }          
  340.         }
  341.     }   
  342.  
  343.     /**
  344.      * adds an ItemListener to the button
  345.      */
  346.     public void addItemListener(ItemListener l) {
  347.         listenerList.add(ItemListener.class, l);
  348.     }
  349.         
  350.     /**
  351.      * removes an ItemListener from the button
  352.      */
  353.     public void removeItemListener(ItemListener l) {
  354.         listenerList.remove(ItemListener.class, l);
  355.     }
  356.  
  357.     /*
  358.      * Notify all listeners that have registered interest for
  359.      * notification on this event type.  The event instance 
  360.      * is lazily created using the parameters passed into 
  361.      * the fire method.
  362.      * @see EventListenerList
  363.      */
  364.     protected void fireItemStateChanged(ItemEvent e) {
  365.         // Guaranteed to return a non-null array
  366.         Object[] listeners = listenerList.getListenerList();
  367.         // Process the listeners last to first, notifying
  368.         // those that are interested in this event
  369.         for (int i = listeners.length-2; i>=0; i-=2) {
  370.             if (listeners[i]==ItemListener.class) {
  371.                 // Lazily create the event:
  372.                 // if (changeEvent == null)
  373.                 // changeEvent = new ChangeEvent(this);
  374.                 ((ItemListener)listeners[i+1]).itemStateChanged(e);
  375.             }          
  376.         }
  377.     }   
  378.  
  379.     public Object[] getSelectedObjects() {
  380.         return null; 
  381.     }
  382.  
  383.     public void setGroup(ButtonGroup group) {
  384.         this.group = group;
  385.     }
  386.  
  387. }
  388.