/*

 * Copyright (c) 2000, 2013, 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.awt;

import java.awt.IllegalComponentStateException;

import java.util.Collections;

import java.util.Iterator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import java.util.WeakHashMap;

import sun.util.logging.PlatformLogger;

/**

 * This class is used to aid in keeping track of DisplayChangedListeners and

 * notifying them when a display change has taken place. DisplayChangedListeners

 * are notified when the display's bit depth is changed, or when a top-level

 * window has been dragged onto another screen.

 *

 * It is safe for a DisplayChangedListener to be added while the list is being

 * iterated.

 *

 * The displayChanged() call is propagated after some occurrence (either

 * due to user action or some other application) causes the display mode

 * (e.g., depth or resolution) to change.  All heavyweight components need

 * to know when this happens because they need to create new surfaceData

 * objects based on the new depth.

 *

 * displayChanged() is also called on Windows when they are moved from one

 * screen to another on a system equipped with multiple displays.

 */

public class SunDisplayChanger {

    private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.multiscreen.SunDisplayChanger");

    // Create a new synchronized map with initial capacity of one listener.

    // It is asserted that the most common case is to have one GraphicsDevice

    // and one top-level Window.

    private Map<DisplayChangedListener, Void> listeners =

        Collections.synchronizedMap(new WeakHashMap<DisplayChangedListener, Void>(1));

    public SunDisplayChanger() {}

    /*

     * Add a DisplayChangeListener to this SunDisplayChanger so that it is

     * notified when the display is changed.

     */

    public void add(DisplayChangedListener theListener) {

        if (log.isLoggable(PlatformLogger.Level.FINE)) {

            if (theListener == null) {

                log.fine("Assertion (theListener != null) failed");

            }

        }

        if (log.isLoggable(PlatformLogger.Level.FINER)) {

            log.finer("Adding listener: " + theListener);

        }

        listeners.put(theListener, null);

    }

    /*

     * Remove the given DisplayChangeListener from this SunDisplayChanger.

     */

    public void remove(DisplayChangedListener theListener) {

        if (log.isLoggable(PlatformLogger.Level.FINE)) {

            if (theListener == null) {

                log.fine("Assertion (theListener != null) failed");

            }

        }

        if (log.isLoggable(PlatformLogger.Level.FINER)) {

            log.finer("Removing listener: " + theListener);

        }

        listeners.remove(theListener);

    }

    /*

     * Notify our list of DisplayChangedListeners that a display change has

     * taken place by calling their displayChanged() methods.

     */

    public void notifyListeners() {

        if (log.isLoggable(PlatformLogger.Level.FINEST)) {

            log.finest("notifyListeners");

        }

    // This method is implemented by making a clone of the set of listeners,

    // and then iterating over the clone.  This is because during the course

    // of responding to a display change, it may be appropriate for a

    // DisplayChangedListener to add or remove itself from a SunDisplayChanger.

    // If the set itself were iterated over, rather than a clone, it is

    // trivial to get a ConcurrentModificationException by having a

    // DisplayChangedListener remove itself from its list.

    // Because all display change handling is done on the event thread,

    // synchronization provides no protection against modifying the listener

    // list while in the middle of iterating over it.  -bchristi 7/10/2001

        Set<DisplayChangedListener> cloneSet;

        synchronized(listeners) {

            cloneSet = new HashSet<DisplayChangedListener>(listeners.keySet());

        }

        Iterator<DisplayChangedListener> itr = cloneSet.iterator();

        while (itr.hasNext()) {

            DisplayChangedListener current = itr.next();

            try {

                if (log.isLoggable(PlatformLogger.Level.FINEST)) {

                    log.finest("displayChanged for listener: " + current);

                }

                current.displayChanged();

            } catch (IllegalComponentStateException e) {

                // This DisplayChangeListener is no longer valid.  Most

                // likely, a top-level window was dispose()d, but its

                // Java objects have not yet been garbage collected.  In any

                // case, we no longer need to track this listener, though we

                // do need to remove it from the original list, not the clone.

                listeners.remove(current);

            }

        }

    }

    /*

     * Notify our list of DisplayChangedListeners that a palette change has

     * taken place by calling their paletteChanged() methods.

     */

    public void notifyPaletteChanged() {

        if (log.isLoggable(PlatformLogger.Level.FINEST)) {

            log.finest("notifyPaletteChanged");

        }

    // This method is implemented by making a clone of the set of listeners,

    // and then iterating over the clone.  This is because during the course

    // of responding to a display change, it may be appropriate for a

    // DisplayChangedListener to add or remove itself from a SunDisplayChanger.

    // If the set itself were iterated over, rather than a clone, it is

    // trivial to get a ConcurrentModificationException by having a

    // DisplayChangedListener remove itself from its list.

    // Because all display change handling is done on the event thread,

    // synchronization provides no protection against modifying the listener

    // list while in the middle of iterating over it.  -bchristi 7/10/2001

        Set<DisplayChangedListener> cloneSet;

        synchronized (listeners) {

            cloneSet = new HashSet<DisplayChangedListener>(listeners.keySet());

        }

        Iterator<DisplayChangedListener> itr = cloneSet.iterator();

        while (itr.hasNext()) {

            DisplayChangedListener current = itr.next();

            try {

                if (log.isLoggable(PlatformLogger.Level.FINEST)) {

                    log.finest("paletteChanged for listener: " + current);

                }

                current.paletteChanged();

            } catch (IllegalComponentStateException e) {

                // This DisplayChangeListener is no longer valid.  Most

                // likely, a top-level window was dispose()d, but its

                // Java objects have not yet been garbage collected.  In any

                // case, we no longer need to track this listener, though we

                // do need to remove it from the original list, not the clone.

                listeners.remove(current);

            }

        }

    }

}