libjava/javax/swing/ActionMap.java

   1 /* ActionMap.java --
   2    Copyright (C) 2002 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 package javax.swing;
  39
  40 // Imports
  41 import java.io.*;
  42 import java.util.*;
  43
  44 /**
  45  * ActionMap
  46  * @author      Andrew Selkirk
  47  * @version     1.0
  48  */
  49 public class ActionMap implements Serializable
  50 {
  51   static final long serialVersionUID = -6277518704513986346L;
  52
  53         //-------------------------------------------------------------
  54         // Variables --------------------------------------------------
  55         //-------------------------------------------------------------
  56
  57         /**
  58          * actionMap
  59          */
  60         private Map actionMap = new HashMap();
  61
  62         /**
  63          * parent
  64          */
  65         private ActionMap parent = null;
  66
  67
  68         //-------------------------------------------------------------
  69         // Initialization ---------------------------------------------
  70         //-------------------------------------------------------------
  71
  72         /**
  73          * Constructor ActionMap
  74          */
  75         public ActionMap() {
  76         } // ActionMap()
  77
  78
  79         //-------------------------------------------------------------
  80         // Methods ----------------------------------------------------
  81         //-------------------------------------------------------------
  82
  83         /**
  84          * get
  85          * @param key TODO
  86          * @returns Action
  87          */
  88         public Action get(Object key) {
  89
  90                 // Variables
  91                 Object  result;
  92
  93                 // Check Local store
  94                 result = actionMap.get(key);
  95
  96                 // Check Parent
  97                 if (result == null) {
  98                         result = parent.get(key);
  99                 } // if
 100
 101                 return (Action) result;
 102
 103         } // get()
 104
 105         /**
 106          * put
 107          * @param key TODO
 108          * @param action TODO
 109          */
 110         public void put(Object key, Action action) {
 111                 if (action == null) {
 112                         actionMap.remove(key);
 113                 } else {
 114                         actionMap.put(key, action);
 115                 } // if
 116         } // put()
 117
 118         /**
 119          * remove
 120          * @param key TODO
 121          */
 122         public void remove(Object key) {
 123                 actionMap.remove(key);
 124         } // remove()
 125
 126         /**
 127          * getParent
 128          * @returns ActionMap
 129          */
 130         public ActionMap getParent() {
 131                 return parent;
 132         } // getParent()
 133
 134         /**
 135          * setParent
 136          * @param parentMap TODO
 137          */
 138         public void setParent(ActionMap parentMap) {
 139                 parent = parentMap;
 140         } // setParent()
 141
 142         /**
 143          * size
 144          * @returns int
 145          */
 146         public int size() {
 147                 return actionMap.size();
 148         } // size()
 149
 150         /**
 151          * clear
 152          */
 153         public void clear() {
 154                 actionMap.clear();
 155         } // clear()
 156
 157         /**
 158          * keys
 159          * @returns Object[]
 160          */
 161         public Object[] keys() {
 162                 return convertSet(actionMap.keySet());
 163         } // keys()
 164
 165         /**
 166          * allKeys
 167          * @returns Object[]
 168          */
 169         public Object[] allKeys() {
 170
 171                 // Variables
 172                 Set                     set;
 173
 174                 // Initialize
 175                 set = new HashSet();
 176
 177                 // Get Key Sets
 178                 if (parent != null) {
 179                         set.addAll(Arrays.asList(parent.allKeys()));
 180                 } // if
 181                 set.addAll(actionMap.keySet());
 182
 183                 return convertSet(set);
 184
 185         } // allKeys()
 186
 187         private Object[] convertSet(Set set) {
 188
 189                 // Variables
 190                 int                     index;
 191                 Iterator        iterator;
 192                 Object[]        keys;
 193
 194                 // Create Final array
 195                 keys = new Object[set.size()];
 196                 iterator = set.iterator();
 197                 index = 0;
 198                 while (iterator.hasNext()) {
 199                         keys[index++] = iterator.next();
 200                 } // while
 201
 202                 return keys;
 203
 204         } // convertSet()
 205
 206
 207         //-------------------------------------------------------------
 208         // Interface: Serializable ------------------------------------
 209         //-------------------------------------------------------------
 210
 211         /**
 212          * writeObject
 213          * @param stream TODO
 214          * @exception IOException TODO
 215          */
 216         private void writeObject(ObjectOutputStream value0) throws IOException {
 217                 // TODO
 218         } // writeObject()
 219
 220         /**
 221          * readObject
 222          * @param stream TODO
 223          * @exception ClassNotFoundException TODO
 224          * @exception IOException TODO
 225          */
 226         private void readObject(ObjectInputStream value0) throws ClassNotFoundException, IOException {
 227                 // TODO
 228         } // readObject()
 229
 230
 231 } // ActionMap