/*

 * Copyright 2003-2007 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package sun.awt.image;

import java.awt.Color;

import java.awt.GraphicsEnvironment;

import java.awt.GraphicsConfiguration;

import java.awt.Image;

import java.awt.ImageCapabilities;

import java.awt.image.BufferedImage;

import java.util.concurrent.ConcurrentHashMap;

import java.util.Iterator;

import sun.java2d.SurfaceData;

import sun.java2d.SurfaceDataProxy;

import sun.java2d.loops.CompositeType;

/**

 * The abstract base class that manages the various SurfaceData objects that

 * represent an Image's contents.  Subclasses can customize how the surfaces

 * are organized, whether to cache the original contents in an accelerated

 * surface, and so on.

 * <p>

 * The SurfaceManager also maintains an arbitrary "cache" mechanism which

 * allows other agents to store data in it specific to their use of this

 * image.  The most common use of the caching mechanism is for destination

 * SurfaceData objects to store cached copies of the source image.

 */

public abstract class SurfaceManager {

    public static abstract class ImageAccessor {

        public abstract SurfaceManager getSurfaceManager(Image img);

        public abstract void setSurfaceManager(Image img, SurfaceManager mgr);

    }

    private static ImageAccessor imgaccessor;

    public static void setImageAccessor(ImageAccessor ia) {

        if (imgaccessor != null) {

            throw new InternalError("Attempt to set ImageAccessor twice");

        }

        imgaccessor = ia;

    }

    /**

     * Returns the SurfaceManager object contained within the given Image.

     */

    public static SurfaceManager getManager(Image img) {

        SurfaceManager sMgr = imgaccessor.getSurfaceManager(img);

        if (sMgr == null) {

            /*

             * In practice only a BufferedImage will get here.

             */

            try {

                BufferedImage bi = (BufferedImage) img;

                sMgr = new BufImgSurfaceManager(bi);

                setManager(bi, sMgr);

            } catch (ClassCastException e) {

                throw new IllegalArgumentException("Invalid Image variant");

            }

        }

        return sMgr;

    }

    public static void setManager(Image img, SurfaceManager mgr) {

        imgaccessor.setSurfaceManager(img, mgr);

    }

    private ConcurrentHashMap cacheMap;

    /**

     * Return an arbitrary cached object for an arbitrary cache key.

     * Other objects can use this mechanism to store cached data about

     * the source image that will let them save time when using or

     * manipulating the image in the future.

     * <p>

     * Note that the cache is maintained as a simple Map with no

     * attempts to keep it up to date or invalidate it so any data

     * stored here must either not be dependent on the state of the

     * image or it must be individually tracked to see if it is

     * outdated or obsolete.

     * <p>

     * The SurfaceData object of the primary (destination) surface

     * has a StateTracker mechanism which can help track the validity

     * and "currentness" of any data stored here.

     * For convenience and expediency an object stored as cached

     * data may implement the FlushableCacheData interface specified

     * below so that it may be notified immediately if the flush()

     * method is ever called.

     */

    public Object getCacheData(Object key) {

        return (cacheMap == null) ? null : cacheMap.get(key);

    }

    /**

     * Store an arbitrary cached object for an arbitrary cache key.

     * See the getCacheData() method for notes on tracking the

     * validity of data stored using this mechanism.

     */

    public void setCacheData(Object key, Object value) {

        if (cacheMap == null) {

            synchronized (this) {

                if (cacheMap == null) {

                    cacheMap = new ConcurrentHashMap(2);

                }

            }

        }

        cacheMap.put(key, value);

    }

    /**

     * Returns the main SurfaceData object that "owns" the pixels for

     * this SurfaceManager.  This SurfaceData is used as the destination

     * surface in a rendering operation and is the most authoritative

     * storage for the current state of the pixels, though other

     * versions might be cached in other locations for efficiency.

     */

    public abstract SurfaceData getPrimarySurfaceData();

    /**

     * Restores the primary surface being managed, and then returns the

     * replacement surface.  This is called when an accelerated surface has

     * been "lost", in an attempt to auto-restore its contents.

     */

    public abstract SurfaceData restoreContents();

    /**

     * Notification that any accelerated surfaces associated with this manager

     * have been "lost", which might mean that they need to be manually

     * restored or recreated.

     *

     * The default implementation does nothing, but platform-specific

     * variants which have accelerated surfaces should perform any necessary

     * actions.

     */

    public void acceleratedSurfaceLost() {}

    /**

     * Returns an ImageCapabilities object which can be

     * inquired as to the specific capabilities of this

     * Image.  The capabilities object will return true for

     * isAccelerated() if the image has a current and valid

     * SurfaceDataProxy object cached for the specified

     * GraphicsConfiguration parameter.

     * <p>

     * This class provides a default implementation of the

     * ImageCapabilities that will try to determine if there

     * is an associated SurfaceDataProxy object and if it is

     * up to date, but only works for GraphicsConfiguration

     * objects which implement the ProxiedGraphicsConfig

     * interface defined below.  In practice, all configs

     * which can be accelerated are currently implementing

     * that interface.

     * <p>

     * A null GraphicsConfiguration returns a value based on whether the

     * image is currently accelerated on its default GraphicsConfiguration.

     *

     * @see java.awt.Image#getCapabilities

     * @since 1.5

     */

    public ImageCapabilities getCapabilities(GraphicsConfiguration gc) {

        return new ImageCapabilitiesGc(gc);

    }

    class ImageCapabilitiesGc extends ImageCapabilities {

        GraphicsConfiguration gc;

        public ImageCapabilitiesGc(GraphicsConfiguration gc) {

            super(false);

            this.gc = gc;

        }

        public boolean isAccelerated() {

            // Note that when img.getAccelerationPriority() gets set to 0

            // we remove SurfaceDataProxy objects from the cache and the

            // answer will be false.

            GraphicsConfiguration tmpGc = gc;

            if (tmpGc == null) {

                tmpGc = GraphicsEnvironment.getLocalGraphicsEnvironment().

                    getDefaultScreenDevice().getDefaultConfiguration();

            }

            if (tmpGc instanceof ProxiedGraphicsConfig) {

                Object proxyKey =

                    ((ProxiedGraphicsConfig) tmpGc).getProxyKey();

                if (proxyKey != null) {

                    SurfaceDataProxy sdp =

                        (SurfaceDataProxy) getCacheData(proxyKey);

                    return (sdp != null && sdp.isAccelerated());

                }

            }

            return false;

        }

    }

    /**

     * An interface for GraphicsConfiguration objects to implement if

     * their surfaces accelerate images using SurfaceDataProxy objects.

     *

     * Implementing this interface facilitates the default

     * implementation of getImageCapabilities() above.

     */

    public static interface ProxiedGraphicsConfig {

        /**

         * Return the key that destination surfaces created on the

         * given GraphicsConfiguration use to store SurfaceDataProxy

         * objects for their cached copies.

         */

        public Object getProxyKey();

    }

    /**

     * Releases system resources in use by ancillary SurfaceData objects,

     * such as surfaces cached in accelerated memory.  Subclasses should

     * override to release any of their flushable data.

     * <p>

     * The default implementation will visit all of the value objects

     * in the cacheMap and flush them if they implement the

     * FlushableCacheData interface.

     */

    public synchronized void flush() {

        flush(false);

    }

    synchronized void flush(boolean deaccelerate) {

        if (cacheMap != null) {

            Iterator i = cacheMap.values().iterator();

            while (i.hasNext()) {

                Object o = i.next();

                if (o instanceof FlushableCacheData) {

                    if (((FlushableCacheData) o).flush(deaccelerate)) {

                        i.remove();

                    }

                }

            }

        }

    }

    /**

     * An interface for Objects used in the SurfaceManager cache

     * to implement if they have data that should be flushed when

     * the Image is flushed.

     */

    public static interface FlushableCacheData {

        /**

         * Flush all cached resources.

         * The deaccelerated parameter indicates if the flush is

         * happening because the associated surface is no longer

         * being accelerated (for instance the acceleration priority

         * is set below the threshold needed for acceleration).

         * Returns a boolean that indicates if the cached object is

         * no longer needed and should be removed from the cache.

         */

        public boolean flush(boolean deaccelerated);

    }

    /**

     * Called when image's acceleration priority is changed.

     * <p>

     * The default implementation will visit all of the value objects

     * in the cacheMap when the priority gets set to 0.0 and flush them

     * if they implement the FlushableCacheData interface.

     */

    public void setAccelerationPriority(float priority) {

        if (priority == 0.0f) {

            flush(true);

        }

    }

}