/* * Copyright (c) 2007, 2008, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package sun.java2d.pipe.hw; import java.util.Collections;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Set; /** * This class is used to notify listeners about accelerated device's * events such as device reset or dispose that are about to occur. */public class AccelDeviceEventNotifier {     private static AccelDeviceEventNotifier theInstance;     /**     * A device is about to be reset. The listeners have to release all     * resources associated with the device which are required for the device     * to be reset.     */    public static final int DEVICE_RESET = 0;     /**     * A device is about to be disposed. The listeners have to release all     * resources associated with the device.     */    public static final int DEVICE_DISPOSED = 1;     private final Map<AccelDeviceEventListener, Integer> listeners;     private AccelDeviceEventNotifier() {        listeners = Collections.synchronizedMap(            new HashMap<AccelDeviceEventListener, Integer>(1));    }     /**     * Returns a singleton of AccelDeviceEventNotifier if it exists. If the     * passed boolean is false and singleton doesn't exist yet, null is     * returned. If the passed boolean is {@code true} and singleton doesn't     * exist it will be created and returned.     *     * @param create whether to create a singleton instance if doesn't yet     * exist     * @return a singleton instance or null     */    private static synchronized        AccelDeviceEventNotifier getInstance(boolean create)    {        if (theInstance == null && create) {            theInstance = new AccelDeviceEventNotifier();        }        return theInstance;    }     /**     * Called to indicate that a device event had occured.     * If a singleton exists, the listeners (those associated with     * the device) will be notified.     *     * @param screen a screen number of the device which is a source of     * the event     * @param eventType a type of the event     * @see #DEVICE_DISPOSED     * @see #DEVICE_RESET     */    public static final void eventOccured(int screen, int eventType) {        AccelDeviceEventNotifier notifier = getInstance(false);        if (notifier != null) {            notifier.notifyListeners(eventType, screen);        }    }     /**     * Adds the listener associated with a device on particular screen.     *     * Note: the listener must be removed as otherwise it will forever     * be referenced by the notifier.     *     * @param l the listener     * @param screen the screen number indicating which device the listener is     * interested in.     */    public static final void addListener(AccelDeviceEventListener l,int screen){        getInstance(true).add(l, screen);    }     /**     * Removes the listener.     *     * @param l the listener     */    public static final void removeListener(AccelDeviceEventListener l) {        getInstance(true).remove(l);    }     private final void add(AccelDeviceEventListener theListener, int screen) {        listeners.put(theListener, screen);    }    private final void remove(AccelDeviceEventListener theListener) {        listeners.remove(theListener);    }     /**     * Notifies the listeners associated with the screen's device about the     * event.     *     * Implementation note: the current list of listeners is first duplicated     * which allows the listeners to remove themselves during the iteration.     *     * @param screen a screen number with which the device which is a source of     * the event is associated with     * @param eventType a type of the event     * @see #DEVICE_DISPOSED     * @see #DEVICE_RESET     */    private final void notifyListeners(int deviceEventType, int screen) {        HashMap<AccelDeviceEventListener, Integer> listClone;        Set<AccelDeviceEventListener> cloneSet;         synchronized(listeners) {            listClone =                new HashMap<AccelDeviceEventListener, Integer>(listeners);        }         cloneSet = listClone.keySet();        Iterator<AccelDeviceEventListener> itr = cloneSet.iterator();        while (itr.hasNext()) {            AccelDeviceEventListener current = itr.next();            Integer i = listClone.get(current);            // only notify listeners which are interested in this device            if (i != null && i.intValue() != screen) {                continue;            }            if (deviceEventType == DEVICE_RESET) {                current.onDeviceReset();            } else if (deviceEventType == DEVICE_DISPOSED) {                current.onDeviceDispose();            }        }    }}