1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
/* * @(#)ActionMap.java 1.16 06/04/07 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package javax.swing; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; import java.util.HashMap; import java.util.Set; /** * <code>ActionMap</code> provides mappings from * <code>Object</code>s * (called <em>keys</em> or <em><code>Action</code> names</em>) * to <code>Action</code>s. * An <code>ActionMap</code> is usually used with an <code>InputMap</code> * to locate a particular action * when a key is pressed. As with <code>InputMap</code>, * an <code>ActionMap</code> can have a parent * that is searched for keys not defined in the <code>ActionMap</code>. * <p>As with <code>InputMap</code> if you create a cycle, eg: * <pre> * ActionMap am = new ActionMap(); * ActionMap bm = new ActionMap(): * am.setParent(bm); * bm.setParent(am); * </pre> * some of the methods will cause a StackOverflowError to be thrown. * * @see InputMap * * @version 1.16 04/07/06 * @author Scott Violet * @since 1.3 */ public class ActionMap implements Serializable { /** Handles the mapping between Action name and Action. */ private transient ArrayTable arrayTable; /** Parent that handles any bindings we don't contain. */ private ActionMap parent; /** * Creates an <code>ActionMap</code> with no parent and no mappings. */ public ActionMap() { } /** * Sets this <code>ActionMap</code>'s parent. * * @param map the <code>ActionMap</code> that is the parent of this one */ public void setParent(ActionMap map) { this.parent = map; } /** * Returns this <code>ActionMap</code>'s parent. * * @return the <code>ActionMap</code> that is the parent of this one, * or null if this <code>ActionMap</code> has no parent */ public ActionMap getParent() { return parent; } /** * Adds a binding for <code>key</code> to <code>action</code>. * If <code>action</code> is null, this removes the current binding * for <code>key</code>. * <p>In most instances, <code>key</code> will be * <code>action.getValue(NAME)</code>. */ public void put(Object key, Action action) { if (key == null) { return; } if (action == null) { remove(key); } else { if (arrayTable == null) { arrayTable = new ArrayTable(); } arrayTable.put(key, action); } } /** * Returns the binding for <code>key</code>, messaging the * parent <code>ActionMap</code> if the binding is not locally defined. */ public Action get(Object key) { Action value = (arrayTable == null) ? null : (Action)arrayTable.get(key); if (value == null) { ActionMap parent = getParent(); if (parent != null) { return parent.get(key); } } return value; } /** * Removes the binding for <code>key</code> from this <code>ActionMap</code>. */ public void remove(Object key) { if (arrayTable != null) { arrayTable.remove(key); } } /** * Removes all the mappings from this <code>ActionMap</code>. */ public void clear() { if (arrayTable != null) { arrayTable.clear(); } } /** * Returns the <code>Action</code> names that are bound in this <code>ActionMap</code>. */ public Object[] keys() { if (arrayTable == null) { return null; } return arrayTable.getKeys(null); } /** * Returns the number of <code>KeyStroke</code> bindings. */ public int size() { if (arrayTable == null) { return 0; } return arrayTable.size(); } /** * Returns an array of the keys defined in this <code>ActionMap</code> and * its parent. This method differs from <code>keys()</code> in that * this method includes the keys defined in the parent. */ public Object[] allKeys() { int count = size(); ActionMap parent = getParent(); if (count == 0) { if (parent != null) { return parent.allKeys(); } return keys(); } if (parent == null) { return keys(); } Object[] keys = keys(); Object[] pKeys = parent.allKeys(); if (pKeys == null) { return keys; } if (keys == null) { // Should only happen if size() != keys.length, which should only // happen if mutated from multiple threads (or a bogus subclass). return pKeys; } HashMap keyMap = new HashMap(); int counter; for (counter = keys.length - 1; counter >= 0; counter--) { keyMap.put(keys[counter], keys[counter]); } for (counter = pKeys.length - 1; counter >= 0; counter--) { keyMap.put(pKeys[counter], pKeys[counter]); } return keyMap.keySet().toArray(); } private void writeObject(ObjectOutputStream s) throws IOException { s.defaultWriteObject(); ArrayTable.writeArrayTable(s, arrayTable); } private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException { s.defaultReadObject(); for (int counter = s.readInt() - 1; counter >= 0; counter--) { put(s.readObject(), (Action)s.readObject()); } } }