libjava/javax/swing/AbstractAction.java

   1 /* AbstractAction.java --
   2    Copyright (C) 2002, 2004, 2005  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package javax.swing;
  40
  41 import java.beans.PropertyChangeListener;
  42 import java.io.IOException;
  43 import java.io.ObjectInputStream;
  44 import java.io.ObjectOutputStream;
  45 import java.io.Serializable;
  46 import java.util.HashMap;
  47
  48 import javax.swing.event.SwingPropertyChangeSupport;
  49
  50 /**
  51  * AbstractAction
  52  * @author      Andrew Selkirk
  53  * @version     1.0
  54  */
  55 public abstract class AbstractAction
  56   implements Action, Cloneable, Serializable
  57 {
  58   private static final long serialVersionUID = -6803159439231523484L;
  59
  60   /**
  61    * enabled
  62    */
  63   protected boolean enabled = true;
  64
  65   /**
  66    * changeSupport
  67    */
  68   protected SwingPropertyChangeSupport changeSupport =
  69     new SwingPropertyChangeSupport(this);
  70
  71   /**
  72    * store
  73    */
  74   private transient HashMap store = new HashMap();
  75
  76   /**
  77    * Constructor AbstractAction
  78    */
  79   public AbstractAction()
  80   {
  81     this(""); // TODO: default name
  82   }
  83
  84   /**
  85    * Constructor AbstractAction
  86    *
  87    * @param name TODO
  88    */
  89   public AbstractAction(String name)
  90   {
  91     this(name, null); // TODO: default icon??
  92   }
  93
  94   /**
  95    * Constructor AbstractAction
  96    *
  97    * @param name TODO
  98    * @param icon TODO
  99    */
 100   public AbstractAction(String name, Icon icon)
 101   {
 102     putValue(NAME, name);
 103     putValue(SMALL_ICON, icon);
 104   }
 105
 106   /**
 107    * readObject
 108    *
 109    * @param stream the stream to read from
 110    *
 111    * @exception ClassNotFoundException TODO
 112    * @exception IOException if an error occurs
 113    */
 114   private void readObject(ObjectInputStream stream)
 115     throws ClassNotFoundException, IOException
 116   {
 117     // TODO
 118   }
 119
 120   /**
 121    * writeObject
 122    *
 123    * @param stream the stream to write to
 124    *
 125    * @exception IOException if an error occurs
 126    */
 127   private void writeObject(ObjectOutputStream stream) throws IOException
 128   {
 129     // TODO
 130   }
 131
 132   /**
 133    * clone
 134    *
 135    * @return Object
 136    *
 137    * @exception CloneNotSupportedException TODO
 138    */
 139   protected Object clone() throws CloneNotSupportedException
 140   {
 141     AbstractAction copy = (AbstractAction) super.clone();
 142     copy.store = (HashMap) store.clone();
 143     return copy;
 144   }
 145
 146   /**
 147    * Returns a value for a given key from the built-in store.
 148    *
 149    * @param key the key to get the value for
 150    *
 151    * @return Object
 152    */
 153   public Object getValue(String key)
 154   {
 155     return store.get(key);
 156   }
 157
 158   /**
 159    * Puts a key/value pair into the built-in store.
 160    *
 161    * @param key the key
 162    * @param value the value
 163    */
 164   public void putValue(String key, Object value)
 165   {
 166     Object old = getValue(key);
 167     if (old != value)
 168     {
 169       store.put(key, value);
 170       firePropertyChange(key, old, value);
 171     }
 172   }
 173
 174   /**
 175    * isEnabled
 176    *
 177    * @return boolean
 178    */
 179   public boolean isEnabled()
 180   {
 181     return enabled;
 182   }
 183
 184   /**
 185    * setEnabled
 186    *
 187    * @param enabled TODO
 188    */
 189   public void setEnabled(boolean enabled)
 190   {
 191     if (enabled != this.enabled)
 192     {
 193       this.enabled = enabled;
 194       firePropertyChange("enabled", !this.enabled, this.enabled);
 195     }
 196   }
 197
 198   /**
 199    * getKeys
 200    * @returns Object[]
 201    */
 202   public Object[] getKeys()
 203   {
 204     return store.keySet().toArray();
 205   }
 206
 207   /**
 208    * This method fires a PropertyChangeEvent given the propertyName
 209    * and the old and new values.
 210    *
 211    * @param propertyName The property that changed.
 212    * @param oldValue The old value of the property.
 213    * @param newValue The new value of the property.
 214    */
 215   protected void firePropertyChange(String propertyName, Object oldValue,
 216                                     Object newValue)
 217   {
 218     changeSupport.firePropertyChange(propertyName, oldValue, newValue);
 219   }
 220
 221   /**
 222    * This convenience method fires a PropertyChangeEvent given
 223    * the propertyName and the old and new values.
 224    *
 225    * @param propertyName The property that changed.
 226    * @param oldValue The old value of the property.
 227    * @param newValue The new value of the property.
 228    */
 229   private void firePropertyChange(String propertyName, boolean oldValue, boolean newValue)
 230   {
 231     changeSupport.firePropertyChange(propertyName, oldValue, newValue);
 232   }
 233
 234   /**
 235    * addPropertyChangeListener
 236    *
 237    * @param listener the listener to add
 238    */
 239   public void addPropertyChangeListener(PropertyChangeListener listener)
 240   {
 241     changeSupport.addPropertyChangeListener(listener);
 242   }
 243
 244   /**
 245    * removePropertyChangeListener
 246    *
 247    * @param listener the listener to remove
 248    */
 249   public void removePropertyChangeListener(PropertyChangeListener listener)
 250   {
 251     changeSupport.removePropertyChangeListener(listener);
 252   }
 253
 254   /**
 255    * Returns all registered listeners.
 256    *
 257    * @return array of listeners.
 258    *
 259    * @since 1.4
 260    */
 261   public PropertyChangeListener[] getPropertyChangeListeners()
 262   {
 263     return changeSupport.getPropertyChangeListeners();
 264   }
 265 }