/*

 * Copyright (c) 2005, 2014, 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 javax.swing;

import java.awt.*;

import java.awt.event.*;

import java.awt.image.*;

import java.lang.ref.WeakReference;

import java.util.*;

import com.sun.java.swing.SwingUtilities3;

import sun.awt.AWTAccessor;

import sun.awt.SubRegionShowable;

import sun.java2d.SunGraphics2D;

import sun.java2d.pipe.hw.ExtendedBufferCapabilities;

import sun.awt.SunToolkit;

import sun.util.logging.PlatformLogger;

/**

 * A PaintManager implementation that uses a BufferStrategy for

 * rendering.

 *

 * @author Scott Violet

 */

class BufferStrategyPaintManager extends RepaintManager.PaintManager {

    //

    // All drawing is done to a BufferStrategy.  At the end of painting

    // (endPaint) the region that was painted is flushed to the screen

    // (using BufferStrategy.show).

    //

    // PaintManager.show is overriden to show directly from the

    // BufferStrategy (when using blit), if successful true is

    // returned and a paint event will not be generated.  To avoid

    // showing from the buffer while painting a locking scheme is

    // implemented.  When beginPaint is invoked the field painting is

    // set to true.  If painting is true and show is invoked we

    // immediately return false.  This is done to avoid blocking the

    // toolkit thread while painting happens.  In a similar way when

    // show is invoked the field showing is set to true, beginPaint

    // will then block until showing is true.  This scheme ensures we

    // only ever have one thread using the BufferStrategy and it also

    // ensures the toolkit thread remains as responsive as possible.

    //

    // If we're using a flip strategy the contents of the backbuffer may

    // have changed and so show only attempts to show from the backbuffer

    // if we get a blit strategy.

    //

    private static final PlatformLogger LOGGER = PlatformLogger.getLogger(

                           "javax.swing.BufferStrategyPaintManager");

    /**

     * List of BufferInfos.  We don't use a Map primarily because

     * there are typically only a handful of top level components making

     * a Map overkill.

     */

    private ArrayList<BufferInfo> bufferInfos;

    /**

     * Indicates <code>beginPaint</code> has been invoked.  This is

     * set to true for the life of beginPaint/endPaint pair.

     */

    private boolean painting;

    /**

     * Indicates we're in the process of showing.  All painting, on the EDT,

     * is blocked while this is true.

     */

    private boolean showing;

    //

    // Region that we need to flush.  When beginPaint is called these are

    // reset and any subsequent calls to paint/copyArea then update these

    // fields accordingly.  When endPaint is called we then try and show

    // the accumulated region.

    // These fields are in the coordinate system of the root.

    //

    private int accumulatedX;

    private int accumulatedY;

    private int accumulatedMaxX;

    private int accumulatedMaxY;

    //

    // The following fields are set by prepare

    //

    /**

     * Farthest JComponent ancestor for the current paint/copyArea.

     */

    private JComponent rootJ;

    /**

     * Location of component being painted relative to root.

     */

    private int xOffset;

    /**

     * Location of component being painted relative to root.

     */

    private int yOffset;

    /**

     * Graphics from the BufferStrategy.

     */

    private Graphics bsg;

    /**

     * BufferStrategy currently being used.

     */

    private BufferStrategy bufferStrategy;

    /**

     * BufferInfo corresponding to root.

     */

    private BufferInfo bufferInfo;

    /**

     * Set to true if the bufferInfo needs to be disposed when current

     * paint loop is done.

     */

    private boolean disposeBufferOnEnd;

    BufferStrategyPaintManager() {

        bufferInfos = new ArrayList<BufferInfo>(1);

    }

    //

    // PaintManager methods

    //

    /**

     * Cleans up any created BufferStrategies.

     */

    protected void dispose() {

        // dipose can be invoked at any random time. To avoid

        // threading dependancies we do the actual diposing via an

        // invokeLater.

        SwingUtilities.invokeLater(new Runnable() {

            public void run() {

                java.util.List<BufferInfo> bufferInfos;

                synchronized(BufferStrategyPaintManager.this) {

                    while (showing) {

                        try {

                            BufferStrategyPaintManager.this.wait();

                        } catch (InterruptedException ie) {

                        }

                    }

                    bufferInfos = BufferStrategyPaintManager.this.bufferInfos;

                    BufferStrategyPaintManager.this.bufferInfos = null;

                }

                dispose(bufferInfos);

            }

        });

    }

    private void dispose(java.util.List<BufferInfo> bufferInfos) {

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

            LOGGER.finer("BufferStrategyPaintManager disposed",

                         new RuntimeException());

        }

        if (bufferInfos != null) {

            for (BufferInfo bufferInfo : bufferInfos) {

                bufferInfo.dispose();

            }

        }

    }

    /**

     * Shows the specified region of the back buffer.  This will return

     * true if successful, false otherwise.  This is invoked on the

     * toolkit thread in response to an expose event.

     */

    public boolean show(Container c, int x, int y, int w, int h) {

        synchronized(this) {

            if (painting) {

                // Don't show from backbuffer while in the process of

                // painting.

                return false;

            }

            showing = true;

        }

        try {

            BufferInfo info = getBufferInfo(c);

            BufferStrategy bufferStrategy;

            if (info != null && info.isInSync() &&

                (bufferStrategy = info.getBufferStrategy(false)) != null) {

                SubRegionShowable bsSubRegion =

                        (SubRegionShowable)bufferStrategy;

                boolean paintAllOnExpose = info.getPaintAllOnExpose();

                info.setPaintAllOnExpose(false);

                if (bsSubRegion.showIfNotLost(x, y, (x + w), (y + h))) {

                    return !paintAllOnExpose;

                }

                // Mark the buffer as needing to be repainted.  We don't

                // immediately do a repaint as this method will return false

                // indicating a PaintEvent should be generated which will

                // trigger a complete repaint.

                bufferInfo.setContentsLostDuringExpose(true);

            }

        }

        finally {

            synchronized(this) {

                showing = false;

                notifyAll();

            }

        }

        return false;

    }

    public boolean paint(JComponent paintingComponent,

                         JComponent bufferComponent, Graphics g,

                         int x, int y, int w, int h) {

        Container root = fetchRoot(paintingComponent);

        if (prepare(paintingComponent, root, true, x, y, w, h)) {

            if ((g instanceof SunGraphics2D) &&

                    ((SunGraphics2D)g).getDestination() == root) {

                // BufferStrategy may have already constrained the Graphics. To

                // account for that we revert the constrain, then apply a

                // constrain for Swing on top of that.

                int cx = ((SunGraphics2D)bsg).constrainX;

                int cy = ((SunGraphics2D)bsg).constrainY;

                if (cx != 0 || cy != 0) {

                    bsg.translate(-cx, -cy);

                }

                ((SunGraphics2D)bsg).constrain(xOffset + cx, yOffset + cy,

                                               x + w, y + h);

                bsg.setClip(x, y, w, h);

                paintingComponent.paintToOffscreen(bsg, x, y, w, h,

                                                   x + w, y + h);

                accumulate(xOffset + x, yOffset + y, w, h);

                return true;

            } else {

                // Assume they are going to eventually render to the screen.

                // This disables showing from backbuffer until a complete

                // repaint occurs.

                bufferInfo.setInSync(false);

                // Fall through to old rendering.

            }

        }

        // Invalid root, do what Swing has always done.

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

            LOGGER.finer("prepare failed");

        }

        return super.paint(paintingComponent, bufferComponent, g, x, y, w, h);

    }

    public void copyArea(JComponent c, Graphics g, int x, int y, int w, int h,

                         int deltaX, int deltaY, boolean clip) {

        // Note: this method is only called internally and we know that

        // g is from a heavyweight Component, so no check is necessary as

        // it is in paint() above.

        //

        // If the buffer isn't in sync there is no point in doing a copyArea,

        // it has garbage.

        Container root = fetchRoot(c);

        if (prepare(c, root, false, 0, 0, 0, 0) && bufferInfo.isInSync()) {

            if (clip) {

                Rectangle cBounds = c.getVisibleRect();

                int relX = xOffset + x;

                int relY = yOffset + y;

                bsg.clipRect(xOffset + cBounds.x,

                             yOffset + cBounds.y,

                             cBounds.width, cBounds.height);

                bsg.copyArea(relX, relY, w, h, deltaX, deltaY);

            }

            else {

                bsg.copyArea(xOffset + x, yOffset + y, w, h, deltaX,

                             deltaY);

            }

            accumulate(x + xOffset + deltaX, y + yOffset + deltaY, w, h);

        } else {

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

                LOGGER.finer("copyArea: prepare failed or not in sync");

            }

            // Prepare failed, or not in sync. By calling super.copyArea

            // we'll copy on screen. We need to flush any pending paint to

            // the screen otherwise we'll do a copyArea on the wrong thing.

            if (!flushAccumulatedRegion()) {

                // Flush failed, copyArea will be copying garbage,

                // force repaint of all.

                rootJ.repaint();

            } else {

                super.copyArea(c, g, x, y, w, h, deltaX, deltaY, clip);

            }

        }

    }

    public void beginPaint() {

        synchronized(this) {

            painting = true;

            // Make sure another thread isn't attempting to show from

            // the back buffer.

            while(showing) {

                try {

                    wait();

                } catch (InterruptedException ie) {

                }

            }

        }

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

            LOGGER.finest("beginPaint");

        }

        // Reset the area that needs to be painted.

        resetAccumulated();

    }

    public void endPaint() {

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

            LOGGER.finest("endPaint: region " + accumulatedX + " " +

                       accumulatedY + " " +  accumulatedMaxX + " " +

                       accumulatedMaxY);

        }

        if (painting) {

            if (!flushAccumulatedRegion()) {

                if (!isRepaintingRoot()) {

                    repaintRoot(rootJ);

                }

                else {

                    // Contents lost twice in a row, punt.

                    resetDoubleBufferPerWindow();

                    // In case we've left junk on the screen, force a repaint.

                    rootJ.repaint();

                }

            }

        }

        BufferInfo toDispose = null;

        synchronized(this) {

            painting = false;

            if (disposeBufferOnEnd) {

                disposeBufferOnEnd = false;

                toDispose = bufferInfo;

                bufferInfos.remove(toDispose);

            }

        }

        if (toDispose != null) {

            toDispose.dispose();

        }

    }

    /**

     * Renders the BufferStrategy to the screen.

     *

     * @return true if successful, false otherwise.

     */

    private boolean flushAccumulatedRegion() {

        boolean success = true;

        if (accumulatedX != Integer.MAX_VALUE) {

            SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy;

            boolean contentsLost = bufferStrategy.contentsLost();

            if (!contentsLost) {

                bsSubRegion.show(accumulatedX, accumulatedY,

                                 accumulatedMaxX, accumulatedMaxY);

                contentsLost = bufferStrategy.contentsLost();

            }

            if (contentsLost) {

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

                    LOGGER.finer("endPaint: contents lost");

                }

                // Shown region was bogus, mark buffer as out of sync.

                bufferInfo.setInSync(false);

                success = false;

            }

        }

        resetAccumulated();

        return success;

    }

    private void resetAccumulated() {

        accumulatedX = Integer.MAX_VALUE;

        accumulatedY = Integer.MAX_VALUE;

        accumulatedMaxX = 0;

        accumulatedMaxY = 0;

    }

    /**

     * Invoked when the double buffering or useTrueDoubleBuffering

     * changes for a JRootPane.  If the rootpane is not double

     * buffered, or true double buffering changes we throw out any

     * cache we may have.

     */

    public void doubleBufferingChanged(final JRootPane rootPane) {

        if ((!rootPane.isDoubleBuffered() ||

                !rootPane.getUseTrueDoubleBuffering()) &&

                rootPane.getParent() != null) {

            if (!SwingUtilities.isEventDispatchThread()) {

                Runnable updater = new Runnable() {

                    public void run() {

                        doubleBufferingChanged0(rootPane);

                    }

                };

                SwingUtilities.invokeLater(updater);

            }

            else {

                doubleBufferingChanged0(rootPane);

            }

        }

    }

    /**

     * Does the work for doubleBufferingChanged.

     */

    private void doubleBufferingChanged0(JRootPane rootPane) {

        // This will only happen on the EDT.

        BufferInfo info;

        synchronized(this) {

            // Make sure another thread isn't attempting to show from

            // the back buffer.

            while(showing) {

                try {

                    wait();

                } catch (InterruptedException ie) {

                }

            }

            info = getBufferInfo(rootPane.getParent());

            if (painting && bufferInfo == info) {

                // We're in the process of painting and the user grabbed

                // the Graphics. If we dispose now, endPaint will attempt

                // to show a bogus BufferStrategy. Set a flag so that

                // endPaint knows it needs to dispose this buffer.

                disposeBufferOnEnd = true;

                info = null;

            } else if (info != null) {

                bufferInfos.remove(info);

            }

        }

        if (info != null) {

            info.dispose();

        }

    }

    /**

     * Calculates information common to paint/copyArea.

     *

     * @return true if should use buffering per window in painting.

     */

    private boolean prepare(JComponent c, Container root, boolean isPaint, int x, int y,

                            int w, int h) {

        if (bsg != null) {

            bsg.dispose();

            bsg = null;

        }

        bufferStrategy = null;

        if (root != null) {

            boolean contentsLost = false;

            BufferInfo bufferInfo = getBufferInfo(root);

            if (bufferInfo == null) {

                contentsLost = true;

                bufferInfo = new BufferInfo(root);

                bufferInfos.add(bufferInfo);

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

                    LOGGER.finer("prepare: new BufferInfo: " + root);

                }

            }

            this.bufferInfo = bufferInfo;

            if (!bufferInfo.hasBufferStrategyChanged()) {

                bufferStrategy = bufferInfo.getBufferStrategy(true);

                if (bufferStrategy != null) {

                    bsg = bufferStrategy.getDrawGraphics();

                    if (bufferStrategy.contentsRestored()) {

                        contentsLost = true;

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

                            LOGGER.finer("prepare: contents restored in prepare");

                        }

                    }

                }

                else {

                    // Couldn't create BufferStrategy, fallback to normal

                    // painting.

                    return false;

                }

                if (bufferInfo.getContentsLostDuringExpose()) {

                    contentsLost = true;

                    bufferInfo.setContentsLostDuringExpose(false);

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

                        LOGGER.finer("prepare: contents lost on expose");

                    }

                }

                if (isPaint && c == rootJ && x == 0 && y == 0 &&

                      c.getWidth() == w && c.getHeight() == h) {

                    bufferInfo.setInSync(true);

                }

                else if (contentsLost) {

                    // We either recreated the BufferStrategy, or the contents

                    // of the buffer strategy were restored.  We need to

                    // repaint the root pane so that the back buffer is in sync

                    // again.

                    bufferInfo.setInSync(false);

                    if (!isRepaintingRoot()) {

                        repaintRoot(rootJ);

                    }

                    else {

                        // Contents lost twice in a row, punt

                        resetDoubleBufferPerWindow();

                    }

                }

                return (bufferInfos != null);

            }

        }

        return false;

    }

    private Container fetchRoot(JComponent c) {

        boolean encounteredHW = false;