1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 package org.apache.harmony.awt; 19 20 import java.io.IOException; 21 import java.io.ObjectInputStream; 22 import java.io.ObjectOutputStream; 23 import java.io.Serializable; 24 import java.util.ArrayList; 25 import java.util.Collections; 26 import java.util.EventListener; 27 import java.util.Iterator; 28 import java.util.List; 29 30 /** 31 * List of AWT listeners. It is for 3 purposes. 32 * 1. To support list modification from listeners 33 * 2. To ensure call for all listeners as atomic operation 34 * 3. To support system listeners that are needed for built-in AWT components 35 */ 36 public class ListenerList<T extends EventListener> implements Serializable { 37 private static final long serialVersionUID = 9180703263299648154L; 38 39 private transient ArrayList<T> systemList; 40 private transient ArrayList<T> userList; 41 ListenerList()42 public ListenerList() { 43 super(); 44 } 45 46 /** 47 * Adds system listener to this list. 48 * 49 * @param listener - listener to be added. 50 */ addSystemListener(T listener)51 public void addSystemListener(T listener) { 52 if (systemList == null) { 53 systemList = new ArrayList<T>(); 54 } 55 systemList.add(listener); 56 } 57 58 /** 59 * Adds user (public) listener to this list. 60 * 61 * @param listener - listener to be added. 62 */ addUserListener(T listener)63 public void addUserListener(T listener) { 64 if (listener == null) { 65 return; 66 } 67 // transactionally replace old list 68 synchronized (this) { 69 if (userList == null) { 70 userList = new ArrayList<T>(); 71 userList.add(listener); 72 return; 73 } 74 ArrayList<T> newList = new ArrayList<T>(userList); 75 newList.add(listener); 76 userList = newList; 77 } 78 } 79 80 /** 81 * Removes user (public) listener to this list. 82 * 83 * @param listener - listener to be removed. 84 */ removeUserListener(Object listener)85 public void removeUserListener(Object listener) { 86 if (listener == null) { 87 return; 88 } 89 // transactionally replace old list 90 synchronized (this) { 91 if (userList == null || !userList.contains(listener)) { 92 return; 93 } 94 ArrayList<T> newList = new ArrayList<T>(userList); 95 newList.remove(listener); 96 userList = (newList.size() > 0 ? newList : null); 97 } 98 } 99 100 /** 101 * Gets all user (public) listeners in one array. 102 * 103 * @param emptyArray - empty array, it's for deriving particular listeners class. 104 * @return array of all user listeners. 105 */ getUserListeners(AT[] emptyArray)106 public <AT> AT[] getUserListeners(AT[] emptyArray){ 107 synchronized (this) { 108 return (userList != null ? userList.toArray(emptyArray) : emptyArray); 109 110 } 111 } 112 113 /** 114 * Gets all user (public) listeners in one list. 115 * 116 * @return list of all user listeners. 117 */ getUserListeners()118 public List<T> getUserListeners() { 119 synchronized (this) { 120 if (userList == null || userList.isEmpty()) { 121 return Collections.emptyList(); 122 } 123 return new ArrayList<T>(userList); 124 } 125 } 126 getSystemListeners()127 public List<T> getSystemListeners() { 128 synchronized (this) { 129 if (systemList == null || systemList.isEmpty()) { 130 return Collections.emptyList(); 131 } 132 return new ArrayList<T>(systemList); 133 } 134 } 135 136 /** 137 * Gets iterator for user listeners. 138 * 139 * @return iterator for user listeners. 140 */ getUserIterator()141 public Iterator<T> getUserIterator() { 142 synchronized (this) { 143 if (userList == null) { 144 List<T> emptyList = Collections.emptyList(); 145 return emptyList.iterator(); 146 } 147 return new ReadOnlyIterator<T>(userList.iterator()); 148 } 149 } 150 151 /** 152 * Gets iterator for system listeners. 153 * 154 * @return iterator for system listeners. 155 */ getSystemIterator()156 public Iterator<T> getSystemIterator() { 157 return systemList.iterator(); 158 } 159 getOnlySerializable(ArrayList<?> list)160 private static ArrayList<?> getOnlySerializable(ArrayList<?> list) { 161 if (list == null) { 162 return null; 163 } 164 165 ArrayList<Object> result = new ArrayList<Object>(); 166 for (Iterator<?> it = list.iterator(); it.hasNext();) { 167 Object obj = it.next(); 168 if (obj instanceof Serializable) { 169 result.add(obj); 170 } 171 } 172 173 return (result.size() != 0) ? result : null; 174 } 175 writeObject(ObjectOutputStream stream)176 private void writeObject(ObjectOutputStream stream) throws IOException { 177 178 stream.defaultWriteObject(); 179 180 stream.writeObject(getOnlySerializable(systemList)); 181 stream.writeObject(getOnlySerializable(userList)); 182 } 183 184 @SuppressWarnings("unchecked") readObject(ObjectInputStream stream)185 private void readObject(ObjectInputStream stream) 186 throws IOException, ClassNotFoundException { 187 188 stream.defaultReadObject(); 189 190 systemList = (ArrayList<T>)stream.readObject(); 191 userList = (ArrayList<T>)stream.readObject(); 192 } 193 194 } 195