1 files changed, 194 insertions, 0 deletions
diff --git a/awt/org/apache/harmony/awt/ListenerList.java b/awt/org/apache/harmony/awt/ListenerList.java
new file mode 100644
index 0000000..f5c55f1
--- /dev/null
+++ b/awt/org/apache/harmony/awt/ListenerList.java
@@ -0,0 +1,194 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package org.apache.harmony.awt;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EventListener;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * List of AWT listeners. It is for 3 purposes.
+ * 1. To support list modification from listeners
+ * 2. To ensure call for all listeners as atomic operation
+ * 3. To support system listeners that are needed for built-in AWT components
+ */
+public class ListenerList<T extends EventListener> implements Serializable {
+    private static final long serialVersionUID = 9180703263299648154L;
+
+    private transient ArrayList<T> systemList;
+    private transient ArrayList<T> userList;
+    
+    public ListenerList() {
+        super();
+    }
+
+    /**
+     * Adds system listener to this list.
+     *
+     * @param listener - listener to be added.
+     */
+    public void addSystemListener(T listener) {
+        if (systemList == null) {
+            systemList = new ArrayList<T>();
+        }
+        systemList.add(listener);
+    }
+
+    /**
+     * Adds user (public) listener to this list.
+     *
+     * @param listener - listener to be added.
+     */
+    public void addUserListener(T listener) {
+        if (listener == null) {
+            return;
+        }
+        // transactionally replace old list
+        synchronized (this) {
+            if (userList == null) {
+                userList = new ArrayList<T>();
+                userList.add(listener);
+                return;
+            }
+            ArrayList<T> newList = new ArrayList<T>(userList);
+            newList.add(listener);
+            userList = newList;
+        }
+    }
+
+    /**
+     * Removes user (public) listener to this list.
+     *
+     * @param listener - listener to be removed.
+     */
+    public void removeUserListener(Object listener) {
+        if (listener == null) {
+            return;
+        }
+        // transactionally replace old list
+        synchronized (this) {
+            if (userList == null || !userList.contains(listener)) {
+                return;
+            }
+            ArrayList<T> newList = new ArrayList<T>(userList);
+            newList.remove(listener);
+            userList = (newList.size() > 0 ? newList : null);
+        }
+    }
+
+    /**
+     * Gets all user (public) listeners in one array.
+     *
+     * @param emptyArray - empty array, it's for deriving particular listeners class.
+     * @return array of all user listeners.
+     */
+    public <AT> AT[] getUserListeners(AT[] emptyArray){
+        synchronized (this) {
+            return (userList != null ? userList.toArray(emptyArray) : emptyArray);
+
+        }
+    }
+
+    /**
+     * Gets all user (public) listeners in one list.
+     *
+     * @return list of all user listeners.
+     */
+    public List<T> getUserListeners() {
+        synchronized (this) {
+            if (userList == null || userList.isEmpty()) {
+                return Collections.emptyList();
+            }
+            return new ArrayList<T>(userList);
+        }
+    }
+    
+    public List<T> getSystemListeners() {
+        synchronized (this) {
+            if (systemList == null || systemList.isEmpty()) {
+                return Collections.emptyList();
+            }
+            return new ArrayList<T>(systemList);
+        }
+    }
+
+    /**
+     * Gets iterator for user listeners.
+     *
+     * @return iterator for user listeners.
+     */
+    public Iterator<T> getUserIterator() {
+        synchronized (this) {
+            if (userList == null) {
+                List<T> emptyList = Collections.emptyList();
+                return emptyList.iterator();
+            }
+            return new ReadOnlyIterator<T>(userList.iterator());
+        }
+    }
+
+    /**
+     * Gets iterator for system listeners.
+     *
+     * @return iterator for system listeners.
+     */
+    public Iterator<T> getSystemIterator() {
+        return systemList.iterator();
+    }
+
+    private static ArrayList<?> getOnlySerializable(ArrayList<?> list) {
+        if (list == null) {
+            return null;
+        }
+
+        ArrayList<Object> result = new ArrayList<Object>();
+        for (Iterator<?> it = list.iterator(); it.hasNext();) {
+            Object obj = it.next();
+            if (obj instanceof Serializable) {
+                result.add(obj);
+            }
+        }
+
+        return (result.size() != 0) ? result : null;
+    }
+
+    private void writeObject(ObjectOutputStream stream) throws IOException {
+
+        stream.defaultWriteObject();
+
+        stream.writeObject(getOnlySerializable(systemList));
+        stream.writeObject(getOnlySerializable(userList));
+    }
+
+    @SuppressWarnings("unchecked")
+    private void readObject(ObjectInputStream stream)
+            throws IOException, ClassNotFoundException {
+
+        stream.defaultReadObject();
+
+        systemList = (ArrayList<T>)stream.readObject();
+        userList = (ArrayList<T>)stream.readObject();
+    }
+
+}