home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1998 February / VPR9802A.ISO / APP_DEMO / VC / MAIN.BIN / Checkbox.java < prev    next >
Text File  |  1997-10-27  |  9KB  |  338 lines
  1. /*
  2.  * @(#)Checkbox.java    1.35 97/03/03
  3.  * 
  4.  * Copyright (c) 1995, 1996 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.  * CopyrightVersion 1.1_beta
  20.  * 
  21.  */
  22. package java.awt;
  23.  
  24. import java.awt.peer.CheckboxPeer;
  25. import java.awt.event.*;
  26. import java.io.ObjectOutputStream;
  27. import java.io.ObjectInputStream;
  28. import java.io.IOException;
  29.  
  30.  
  31. /**
  32.  * A Checkbox object is a graphical user interface element that has a boolean 
  33.  * state.
  34.  *
  35.  * @version    1.35 03/03/97
  36.  * @author     Sami Shaio
  37.  */
  38. public class Checkbox extends Component implements ItemSelectable {
  39.     /**
  40.      * The label of the Checkbox.
  41.      */
  42.     String label;
  43.  
  44.     /**
  45.      * The state of the Checkbox.
  46.      */
  47.     boolean state;
  48.  
  49.     /**
  50.      * The check box group.
  51.      */
  52.     CheckboxGroup group;
  53.  
  54.     transient ItemListener itemListener;
  55.  
  56.     private static final String base = "checkbox";
  57.     private static int nameCounter = 0;
  58.  
  59.     /*
  60.      * JDK 1.1 serialVersionUID 
  61.      */
  62.     private static final long serialVersionUID = 7270714317450821763L;
  63.  
  64.     /**
  65.      * Helper function for setState and CheckboxGroup.setSelectedCheckbox
  66.      * Should remain package-private.
  67.      */
  68.     synchronized void setStateInternal(boolean state) {
  69.     this.state = state;
  70.     CheckboxPeer peer = (CheckboxPeer)this.peer;
  71.     if (peer != null) {
  72.         peer.setState(state);
  73.     }
  74.     }
  75.  
  76.     /**
  77.      * Constructs a Checkbox with an empty label.  The check box starts in a
  78.      * false state and is not part of any check box group.
  79.      */
  80.     public Checkbox() {
  81.         this("", false, null);
  82.     }
  83.  
  84.     /**
  85.      * Constructs a Checkbox with the specified label.  The check box
  86.      * starts in a false state and is not part of any check box group.
  87.      * @param label the label on the Checkbox
  88.      */
  89.     public Checkbox(String label) {
  90.     this(label, false, null);
  91.     }
  92.  
  93.     /**
  94.      * Constructs a Checkbox with the specified label.  The check box
  95.      * starts in the specified state and is not part of any check box
  96.      * group. 
  97.      * @param label the label on the Checkbox
  98.      * @param state is the initial state of this Checkbox
  99.      * @param group the CheckboxGroup this Checkbox is in
  100.      */
  101.     public Checkbox(String label, boolean state) {
  102.         this(label, state, null);
  103.     }
  104.  
  105.     /**
  106.      * Constructs a Checkbox with the specified label, set to the
  107.      * specified state, and in the specified check box group.
  108.      * @param label the label on the Checkbox
  109.      * @param state is the initial state of this Checkbox
  110.      * @param group the CheckboxGroup this Checkbox is in
  111.      */
  112.     public Checkbox(String label, boolean state, CheckboxGroup group) {
  113.     this.name = base + nameCounter++;        
  114.     this.label = label;
  115.     this.state = state;
  116.     this.group = group;
  117.     if (state && (group != null)) {
  118.         group.setSelectedCheckbox(this);
  119.     }
  120.     }
  121.  
  122.     /**
  123.      * Constructs a Checkbox with the specified label, set to the
  124.      * specified state, and in the specified check box group.
  125.      */
  126.     public Checkbox(String label, CheckboxGroup group, boolean state) {
  127.         this(label, state, group);
  128.     }
  129.  
  130.     /**
  131.      * Creates the peer of the Checkbox. The peer allows you to change the
  132.      * look of the Checkbox without changing its functionality.
  133.      */
  134.     public void addNotify() {
  135.     peer = getToolkit().createCheckbox(this);
  136.     super.addNotify();
  137.     }
  138.  
  139.     /**
  140.      * Gets the label of the check box.
  141.      * @see #setLabel
  142.      */
  143.     public String getLabel() {
  144.     return label;
  145.     }
  146.  
  147.     /**
  148.      * Sets this check box's label to be the specified string.
  149.      * @param label the label of the button
  150.      * @see #getLabel
  151.      */
  152.     public synchronized void setLabel(String label) {
  153.     this.label = label;
  154.     CheckboxPeer peer = (CheckboxPeer)this.peer;
  155.     if (peer != null) {
  156.         peer.setLabel(label);
  157.     }
  158.     }
  159.  
  160.     /** 
  161.      * Returns the boolean state of the Checkbox. 
  162.      * @see #setState
  163.      */
  164.     public boolean getState() {
  165.     return state;
  166.     }
  167.     
  168.     /** 
  169.      * Sets the Checkbox to the specifed boolean state.
  170.      * @param state the boolean state 
  171.      * @see #getState
  172.      */
  173.     public void setState(boolean state) {
  174.     /* Cannot hold check box lock when calling group.setSelectedCheckbox. */
  175.         CheckboxGroup group = this.group;
  176.     if (group != null) {
  177.         if (state) {
  178.         group.setSelectedCheckbox(this);
  179.         } else if (group.getSelectedCheckbox() == this) {
  180.         state = true;
  181.         }
  182.     }
  183.     setStateInternal(state);
  184.     }
  185.  
  186.     /**
  187.      * Returns the an array (length 1) containing the checkbox
  188.      * label or null if the checkbox is not selected.
  189.      * @see ItemSelectable
  190.      */
  191.     public Object[] getSelectedObjects() {
  192.         if (state) {
  193.             Object[] items = new Object[1];
  194.             items[0] = label;
  195.             return items;
  196.         }
  197.         return null;
  198.     }
  199.  
  200.     /**
  201.      * Returns the checkbox group.
  202.      * @see #setCheckboxGroup
  203.      */
  204.     public CheckboxGroup getCheckboxGroup() {
  205.     return group;
  206.     }
  207.  
  208.     /**
  209.      * Sets the CheckboxGroup to the specified group.
  210.      * @param g the new CheckboxGroup
  211.      * @see #getCheckboxGroup
  212.      */
  213.     public void setCheckboxGroup(CheckboxGroup g) {
  214.         CheckboxGroup group = this.group;
  215.     if (group != null) {
  216.         group.setSelectedCheckbox(null);
  217.     }
  218.     /* Locking check box above could cause deadlock with
  219.      * CheckboxGroup's setSelectedCheckbox method.
  220.      */
  221.     synchronized (this) {
  222.         this.group = g;
  223.         CheckboxPeer peer = (CheckboxPeer)this.peer;
  224.         if (peer != null) {
  225.         peer.setCheckboxGroup(g);
  226.         }
  227.     }
  228.     }
  229.  
  230.     /**
  231.      * Adds the specified item listener to recieve item events from
  232.      * this checkbox.
  233.      * @param l the item listener
  234.      */ 
  235.     public synchronized void addItemListener(ItemListener l) {
  236.         itemListener = AWTEventMulticaster.add(itemListener, l);
  237.         newEventsOnly = true;
  238.     }
  239.  
  240.     /**
  241.      * Removes the specified item listener so that it no longer
  242.      * receives item events from this checkbox.
  243.      * @param l the item listener
  244.      */ 
  245.     public synchronized void removeItemListener(ItemListener l) {
  246.         itemListener = AWTEventMulticaster.remove(itemListener, l);
  247.     }
  248.  
  249.     // REMIND: remove when filtering is done at lower level
  250.     boolean eventEnabled(AWTEvent e) {
  251.         if (e.id == ItemEvent.ITEM_STATE_CHANGED) {
  252.             if ((eventMask & AWTEvent.ITEM_EVENT_MASK) != 0 ||
  253.                 itemListener != null) {
  254.                 return true;
  255.             }             
  256.             return false;
  257.         }
  258.         return super.eventEnabled(e);
  259.     }          
  260.  
  261.     /**
  262.      * Processes events on this checkbox. If the event is an ItemEvent,
  263.      * it invokes the handleItemEvent method, else it calls its
  264.      * superclass's processEvent.
  265.      * @param e the event
  266.      */
  267.     protected void processEvent(AWTEvent e) {
  268.         if (e instanceof ItemEvent) {
  269.             processItemEvent((ItemEvent)e);
  270.             return;
  271.         }
  272.     super.processEvent(e);
  273.     }
  274.  
  275.     /** 
  276.      * Processes item events occurring on this checkbox by
  277.      * dispatching them to any registered ItemListener objects.
  278.      * NOTE: This method will not be called unless item events
  279.      * are enabled for this component; this happens when one of the
  280.      * following occurs:
  281.      * a) An ItemListener object is registered via addItemListener()
  282.      * b) Item events are enabled via enableEvents()
  283.      * @see Component#enableEvents
  284.      * @param e the item event
  285.      */  
  286.     protected void processItemEvent(ItemEvent e) {
  287.         if (itemListener != null) {
  288.             itemListener.itemStateChanged(e);
  289.         }
  290.     }
  291.  
  292.     /**
  293.      * Returns the parameter String of this Checkbox.
  294.      */
  295.     protected String paramString() {
  296.     String str = super.paramString();
  297.     String label = this.label;
  298.     if (label != null) {
  299.         str += ",label=" + label;
  300.     }
  301.     return str + ",state=" + state;
  302.     }
  303.  
  304.  
  305.     /* Serialization support. 
  306.      */
  307.  
  308.     private int checkboxSerializedDataVersion = 1;
  309.  
  310.  
  311.     private void writeObject(ObjectOutputStream s)
  312.       throws java.io.IOException 
  313.     {
  314.       s.defaultWriteObject();
  315.  
  316.       AWTEventMulticaster.save(s, itemListenerK, itemListener);
  317.       s.writeObject(null);
  318.     }
  319.  
  320.  
  321.     private void readObject(ObjectInputStream s)
  322.       throws ClassNotFoundException, IOException 
  323.     {
  324.       s.defaultReadObject();
  325.  
  326.       Object keyOrNull;
  327.       while(null != (keyOrNull = s.readObject())) {
  328.     String key = ((String)keyOrNull).intern();
  329.  
  330.     if (itemListenerK == key) 
  331.       addItemListener((ItemListener)(s.readObject()));
  332.  
  333.     else // skip value for unrecognized key
  334.       s.readObject();
  335.       }
  336.     }
  337. }
  338.