/* * Copyright (c) 2003, 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.awt.image; import java.awt.Color;import java.awt.Graphics;import java.awt.GraphicsConfiguration;import java.awt.GraphicsEnvironment;import java.awt.ImageCapabilities;import java.awt.image.BufferedImage;import java.awt.image.VolatileImage;import sun.awt.DisplayChangedListener;import sun.awt.image.SunVolatileImage;import sun.java2d.SunGraphicsEnvironment;import sun.java2d.SurfaceData;import sun.java2d.loops.CompositeType;import static sun.java2d.pipe.hw.AccelSurface.*; /** * This SurfaceManager variant manages an accelerated volatile surface, if it * is possible to create that surface.  If there is limited accelerated * memory, or if the volatile surface disappears due to an operating system * event, the VolatileSurfaceManager will attempt to restore the * accelerated surface.  If that fails, a system memory surface will be * created in its place. */public abstract class VolatileSurfaceManager    extends SurfaceManager    implements DisplayChangedListener{    /**     * A reference to the VolatileImage whose contents are being managed.     */    protected SunVolatileImage vImg;     /**     * The accelerated SurfaceData object.     */    protected SurfaceData sdAccel;     /**     * The software-based SurfaceData object.  Only create when first asked     * to (otherwise it is a waste of memory as it will only be used in     * situations of surface loss).     */    protected SurfaceData sdBackup;     /**     * The current SurfaceData object.     */    protected SurfaceData sdCurrent;     /**     * A record-keeping object.  This keeps track of which SurfaceData was     * in use during the last call to validate().  This lets us see whether     * the SurfaceData object has changed since then and allows us to return     * the correct returnCode to the user in the validate() call.     */    protected SurfaceData sdPrevious;     /**     * Tracks loss of surface contents; queriable by user to see whether     * contents need to be restored.     */    protected boolean lostSurface;     /**     * Context for extra initialization parameters.     */    protected Object context;     protected VolatileSurfaceManager(SunVolatileImage vImg, Object context) {        this.vImg = vImg;        this.context = context;         GraphicsEnvironment ge =            GraphicsEnvironment.getLocalGraphicsEnvironment();        // We could have a HeadlessGE at this point, so double-check before        // assuming anything.        if (ge instanceof SunGraphicsEnvironment) {            ((SunGraphicsEnvironment)ge).addDisplayChangedListener(this);        }    }     /**     * This init function is separate from the constructor because the     * things we are doing here necessitate the object's existence.     * Otherwise, we end up calling into a subclass' overridden method     * during construction, before that subclass is completely constructed.     */    public void initialize() {        if (isAccelerationEnabled()) {            sdAccel = initAcceleratedSurface();            if (sdAccel != null) {                sdCurrent = sdAccel;            }        }        // only initialize the backup surface for images with unforced        // acceleration type        if (sdCurrent == null &&            vImg.getForcedAccelSurfaceType() == UNDEFINED)        {            sdCurrent = getBackupSurface();        }    }     public SurfaceData getPrimarySurfaceData() {        return sdCurrent;    }     /**     * Returns true if acceleration is enabled.  If not, we simply use the     * backup SurfaceData object and return quickly from most methods     * in this class.     */    protected abstract boolean isAccelerationEnabled();     /**     * Get the image ready for rendering.  This method is called to make     * sure that the accelerated SurfaceData exists and is     * ready to be used.  Users call this method prior to any set of     * rendering to or from the image, to make sure the image is ready     * and compatible with the given GraphicsConfiguration.     *     * The image may not be "ready" if either we had problems creating     * it in the first place (e.g., there was no space in vram) or if     * the surface became lost (e.g., some other app or the OS caused     * vram surfaces to be removed).     *     * Note that we want to return RESTORED in any situation where the     * SurfaceData is different than it was last time.  So whether it's     * software or hardware, if we have a different SurfaceData object,     * then the contents have been altered and we must reflect that     * change to the user.     */    public int validate(GraphicsConfiguration gc) {        int returnCode = VolatileImage.IMAGE_OK;        boolean lostSurfaceTmp = lostSurface;        lostSurface = false;         if (isAccelerationEnabled()) {            if (!isConfigValid(gc)) {                // If we're asked to render to a different device than the                // one we were created under, return INCOMPATIBLE error code.                // Note that a null gc simply ignores the incompatibility                // issue                returnCode = VolatileImage.IMAGE_INCOMPATIBLE;            } else if (sdAccel == null) {                // We either had problems creating the surface or the display                // mode changed and we nullified the old one.  Try it again.                sdAccel = initAcceleratedSurface();                if (sdAccel != null) {                    // set the current SurfaceData to accelerated version                    sdCurrent = sdAccel;                    // we don't need the system memory surface anymore, so                    // let's release it now (it can always be restored later)                    sdBackup = null;                    returnCode = VolatileImage.IMAGE_RESTORED;                } else {                    sdCurrent = getBackupSurface();                }            } else if (sdAccel.isSurfaceLost()) {                try {                    restoreAcceleratedSurface();                    // set the current SurfaceData to accelerated version                    sdCurrent = sdAccel;                    // restoration successful: accel surface no longer lost                    sdAccel.setSurfaceLost(false);                    // we don't need the system memory surface anymore, so                    // let's release it now (it can always be restored later)                    sdBackup = null;                    returnCode = VolatileImage.IMAGE_RESTORED;                } catch (sun.java2d.InvalidPipeException e) {                    // Set the current SurfaceData to software version so that                    // drawing can continue.  Note that we still have                    // the lostAccelSurface flag set so that we will continue                    // to attempt to restore the accelerated surface.                    sdCurrent = getBackupSurface();                }            } else if (lostSurfaceTmp) {                // Something else triggered this loss/restoration.  Could                // be a palette change that didn't require a SurfaceData                // recreation but merely a re-rendering of the pixels.                returnCode = VolatileImage.IMAGE_RESTORED;            }        } else if (sdAccel != null) {            // if the "acceleration enabled" state changed to disabled,            // switch to software surface            sdCurrent = getBackupSurface();            sdAccel = null;            returnCode = VolatileImage.IMAGE_RESTORED;        }         if ((returnCode != VolatileImage.IMAGE_INCOMPATIBLE) &&            (sdCurrent != sdPrevious))        {            // contents have changed - return RESTORED to user            sdPrevious = sdCurrent;            returnCode = VolatileImage.IMAGE_RESTORED;        }         if (returnCode == VolatileImage.IMAGE_RESTORED) {            // clear the current surface with the background color,            // only if the surface has been restored            initContents();        }         return returnCode;    }     /**     * Returns true if rendering data was lost since the last validate call.     *     * @see java.awt.image.VolatileImage#contentsLost     */    public boolean contentsLost() {        return lostSurface;    }     /**     * Creates a new accelerated surface that is compatible with the     * current GraphicsConfiguration.  Returns the new accelerated     * SurfaceData object, or null if the surface creation was not successful.     *     * Platform-specific subclasses should initialize an accelerated     * surface (e.g. a DirectDraw surface on Windows, an OpenGL pbuffer,     * or an X11 pixmap).     */    protected abstract SurfaceData initAcceleratedSurface();     /**     * Creates a software-based surface (of type BufImgSurfaceData).     * The software representation is only created when needed, which     * is only during some situation in which the hardware surface     * cannot be allocated.  This allows apps to at least run,     * albeit more slowly than they would otherwise.     */    protected SurfaceData getBackupSurface() {        if (sdBackup == null) {            BufferedImage bImg = vImg.getBackupImage();            // Sabotage the acceleration capabilities of the BufImg surface            SunWritableRaster.stealTrackable(bImg                                             .getRaster()                                             .getDataBuffer()).setUntrackable();            sdBackup = BufImgSurfaceData.createData(bImg);        }        return sdBackup;    }     /**     * Set contents of the current SurfaceData to default state (i.e. clear     * the background).     */    public void initContents() {        // images with forced acceleration type may have a null sdCurrent        // because we do not create a backup surface for them        if (sdCurrent != null) {            Graphics g = vImg.createGraphics();            g.clearRect(0, 0, vImg.getWidth(), vImg.getHeight());            g.dispose();        }    }     /**     * Called from a SurfaceData object, indicating that our     * accelerated surface has been lost and should be restored (perhaps     * using a backup system memory surface).  Returns the newly restored     * primary SurfaceData object.     */    public SurfaceData restoreContents() {        return getBackupSurface();    }     /**     * If the accelerated surface is the current SurfaceData for this manager,     * sets the variable lostSurface to true, which indicates that something     * happened to the image under management.  This variable is used in the     * validate method to tell the caller that the surface contents need to     * be restored.     */    public void acceleratedSurfaceLost() {        if (isAccelerationEnabled() && (sdCurrent == sdAccel)) {            lostSurface = true;        }    }     /**     * Restore sdAccel in case it was lost.  Do nothing in this     * default case; platform-specific implementations may do more in     * this situation as appropriate.     */    protected void restoreAcceleratedSurface() {    }     /**     * Called from SunGraphicsEnv when there has been a display mode change.     * Note that we simply invalidate hardware surfaces here; we do not     * attempt to recreate or re-render them.  This is to avoid threading     * conflicts with the native toolkit and associated threads.  Instead,     * we just nullify the old surface data object and wait for a future     * method in the rendering process to recreate the surface.     */    public void displayChanged() {        if (!isAccelerationEnabled()) {            return;        }        lostSurface = true;        if (sdAccel != null) {            // First, nullify the software surface.  This guards against            // using a SurfaceData that was created in a different            // display mode.            sdBackup = null;            sdCurrent = getBackupSurface();            // Now, invalidate the old hardware-based SurfaceData            SurfaceData oldData = sdAccel;            sdAccel = null;            oldData.invalidate();        }        // Update graphicsConfig for the vImg in case it changed due to        // this display change event        vImg.updateGraphicsConfig();    }     /**     * When device palette changes, need to force a new copy     * of the image into our hardware cache to update the     * color indices of the pixels (indexed mode only).     */    public void paletteChanged() {        lostSurface = true;    }     /**     * Called by validate() to see whether the GC passed in is ok for     * rendering to.  This generic implementation checks to see     * whether the GC is either null or is from the same     * device as the one that this image was created on.  Platform-     * specific implementations may perform other checks as     * appropriate.     */    protected boolean isConfigValid(GraphicsConfiguration gc) {        return ((gc == null) ||                (gc.getDevice() == vImg.getGraphicsConfig().getDevice()));    }     @Override    public ImageCapabilities getCapabilities(GraphicsConfiguration gc) {        if (isConfigValid(gc)) {            return isAccelerationEnabled() ?                new AcceleratedImageCapabilities() :                new ImageCapabilities(false);        }        return super.getCapabilities(gc);    }     private class AcceleratedImageCapabilities        extends ImageCapabilities    {        AcceleratedImageCapabilities() {            super(false);        }        @Override        public boolean isAccelerated() {            return (sdCurrent == sdAccel);        }        @Override        public boolean isTrueVolatile() {            return isAccelerated();        }    }     /**     * Releases any associated hardware memory for this image by     * calling flush on sdAccel.  This method forces a lostSurface     * situation so any future operations on the image will need to     * revalidate the image first.     */    public void flush() {        lostSurface = true;        SurfaceData oldSD = sdAccel;        sdAccel = null;        if (oldSD != null) {            oldSD.flush();        }    }}