/*

 * Copyright (c) 1997, 2015, 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.VolatileImage;

import java.security.AccessControlContext;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.*;

import java.util.concurrent.atomic.AtomicInteger;

import java.applet.*;

import jdk.internal.misc.JavaSecurityAccess;

import jdk.internal.misc.SharedSecrets;

import sun.awt.AWTAccessor;

import sun.awt.AppContext;

import sun.awt.DisplayChangedListener;

import sun.awt.SunToolkit;

import sun.java2d.SunGraphicsEnvironment;

import sun.security.action.GetPropertyAction;

import com.sun.java.swing.SwingUtilities3;

import java.awt.geom.AffineTransform;

import sun.java2d.SunGraphics2D;

import sun.java2d.pipe.Region;

import sun.swing.SwingAccessor;

import sun.swing.SwingUtilities2;

import sun.swing.SwingUtilities2.RepaintListener;

/**

 * This class manages repaint requests, allowing the number

 * of repaints to be minimized, for example by collapsing multiple

 * requests into a single repaint for members of a component tree.

 * <p>

 * As of 1.6 <code>RepaintManager</code> handles repaint requests

 * for Swing's top level components (<code>JApplet</code>,

 * <code>JWindow</code>, <code>JFrame</code> and <code>JDialog</code>).

 * Any calls to <code>repaint</code> on one of these will call into the

 * appropriate <code>addDirtyRegion</code> method.

 *

 * @author Arnaud Weber

 * @since 1.2

 */

public class RepaintManager

{

    /**

     * Whether or not the RepaintManager should handle paint requests

     * for top levels.

     */

    static final boolean HANDLE_TOP_LEVEL_PAINT;

    private static final short BUFFER_STRATEGY_NOT_SPECIFIED = 0;

    private static final short BUFFER_STRATEGY_SPECIFIED_ON = 1;

    private static final short BUFFER_STRATEGY_SPECIFIED_OFF = 2;

    private static final short BUFFER_STRATEGY_TYPE;

    /**

     * Maps from GraphicsConfiguration to VolatileImage.

     */

    private Map<GraphicsConfiguration,VolatileImage> volatileMap = new

                        HashMap<GraphicsConfiguration,VolatileImage>(1);

    //

    // As of 1.6 Swing handles scheduling of paint events from native code.

    // That is, SwingPaintEventDispatcher is invoked on the toolkit thread,

    // which in turn invokes nativeAddDirtyRegion.  Because this is invoked

    // from the native thread we can not invoke any public methods and so

    // we introduce these added maps.  So, any time nativeAddDirtyRegion is

    // invoked the region is added to hwDirtyComponents and a work request

    // is scheduled.  When the work request is processed all entries in

    // this map are pushed to the real map (dirtyComponents) and then

    // painted with the rest of the components.

    //

    private Map<Container,Rectangle> hwDirtyComponents;

    private Map<Component,Rectangle> dirtyComponents;

    private Map<Component,Rectangle> tmpDirtyComponents;

    private java.util.List<Component> invalidComponents;

    // List of Runnables that need to be processed before painting from AWT.

    private java.util.List<Runnable> runnableList;

    boolean   doubleBufferingEnabled = true;

    private Dimension doubleBufferMaxSize;

    // Support for both the standard and volatile offscreen buffers exists to

    // provide backwards compatibility for the [rare] programs which may be

    // calling getOffScreenBuffer() and not expecting to get a VolatileImage.

    // Swing internally is migrating to use *only* the volatile image buffer.

    // Support for standard offscreen buffer

    //

    DoubleBufferInfo standardDoubleBuffer;

    /**

     * Object responsible for hanlding core paint functionality.

     */

    private PaintManager paintManager;

    private static final Object repaintManagerKey = RepaintManager.class;

    // Whether or not a VolatileImage should be used for double-buffered painting

    static boolean volatileImageBufferEnabled = true;

    /**

     * Type of VolatileImage which should be used for double-buffered

     * painting.

     */

    private static final int volatileBufferType;

    /**

     * Value of the system property awt.nativeDoubleBuffering.

     */

    private static boolean nativeDoubleBuffering;

    // The maximum number of times Swing will attempt to use the VolatileImage

    // buffer during a paint operation.

    private static final int VOLATILE_LOOP_MAX = 2;

    /**

     * Number of <code>beginPaint</code> that have been invoked.

     */

    private int paintDepth = 0;

    /**

     * Type of buffer strategy to use.  Will be one of the BUFFER_STRATEGY_

     * constants.

     */

    private short bufferStrategyType;

    //

    // BufferStrategyPaintManager has the unique characteristic that it

    // must deal with the buffer being lost while painting to it.  For

    // example, if we paint a component and show it and the buffer has

    // become lost we must repaint the whole window.  To deal with that

    // the PaintManager calls into repaintRoot, and if we're still in

    // the process of painting the repaintRoot field is set to the JRootPane

    // and after the current JComponent.paintImmediately call finishes

    // paintImmediately will be invoked on the repaintRoot.  In this

    // way we don't try to show garbage to the screen.

    //

    /**

     * True if we're in the process of painting the dirty regions.  This is

     * set to true in <code>paintDirtyRegions</code>.

     */

    private boolean painting;

    /**

     * If the PaintManager calls into repaintRoot during painting this field

     * will be set to the root.

     */

    private JComponent repaintRoot;

    /**

     * The Thread that has initiated painting.  If null it

     * indicates painting is not currently in progress.

     */

    private Thread paintThread;

    /**

     * Runnable used to process all repaint/revalidate requests.

     */

    private final ProcessingRunnable processingRunnable;

    private static final JavaSecurityAccess javaSecurityAccess =

            SharedSecrets.getJavaSecurityAccess();

    /**

     * Listener installed to detect display changes. When display changes,

     * schedules a callback to notify all RepaintManagers of the display

     * changes.

     */

    private static final DisplayChangedListener displayChangedHandler =

            new DisplayChangedHandler();

    static {

        SwingAccessor.setRepaintManagerAccessor(new SwingAccessor.RepaintManagerAccessor() {

            @Override

            public void addRepaintListener(RepaintManager rm, RepaintListener l) {

                rm.addRepaintListener(l);

            }

            @Override

            public void removeRepaintListener(RepaintManager rm, RepaintListener l) {

                rm.removeRepaintListener(l);

            }

        });

        volatileImageBufferEnabled = "true".equals(AccessController.

                doPrivileged(new GetPropertyAction(

                "swing.volatileImageBufferEnabled", "true")));

        boolean headless = GraphicsEnvironment.isHeadless();

        if (volatileImageBufferEnabled && headless) {

            volatileImageBufferEnabled = false;

        }

        nativeDoubleBuffering = "true".equals(AccessController.doPrivileged(

                    new GetPropertyAction("awt.nativeDoubleBuffering")));

        String bs = AccessController.doPrivileged(

                          new GetPropertyAction("swing.bufferPerWindow"));

        if (headless) {

            BUFFER_STRATEGY_TYPE = BUFFER_STRATEGY_SPECIFIED_OFF;

        }

        else if (bs == null) {

            BUFFER_STRATEGY_TYPE = BUFFER_STRATEGY_NOT_SPECIFIED;

        }

        else if ("true".equals(bs)) {

            BUFFER_STRATEGY_TYPE = BUFFER_STRATEGY_SPECIFIED_ON;

        }

        else {

            BUFFER_STRATEGY_TYPE = BUFFER_STRATEGY_SPECIFIED_OFF;

        }

        HANDLE_TOP_LEVEL_PAINT = "true".equals(AccessController.doPrivileged(

               new GetPropertyAction("swing.handleTopLevelPaint", "true")));

        GraphicsEnvironment ge = GraphicsEnvironment.

                getLocalGraphicsEnvironment();

        if (ge instanceof SunGraphicsEnvironment) {

            ((SunGraphicsEnvironment) ge).addDisplayChangedListener(

                    displayChangedHandler);

        }

        Toolkit tk = Toolkit.getDefaultToolkit();

        if ((tk instanceof SunToolkit)

                && ((SunToolkit) tk).isSwingBackbufferTranslucencySupported()) {

            volatileBufferType = Transparency.TRANSLUCENT;

        } else {

            volatileBufferType = Transparency.OPAQUE;

        }

    }

    /**

     * Return the RepaintManager for the calling thread given a Component.

     *

     * @param c a Component -- unused in the default implementation, but could

     *          be used by an overridden version to return a different RepaintManager

     *          depending on the Component

     * @return the RepaintManager object

     */

    public static RepaintManager currentManager(Component c) {

        // Note: DisplayChangedRunnable passes in null as the component, so if

        // component is ever used to determine the current

        // RepaintManager, DisplayChangedRunnable will need to be modified

        // accordingly.

        return currentManager(AppContext.getAppContext());

    }

    /**

     * Returns the RepaintManager for the specified AppContext.  If

     * a RepaintManager has not been created for the specified

     * AppContext this will return null.

     */

    static RepaintManager currentManager(AppContext appContext) {

        RepaintManager rm = (RepaintManager)appContext.get(repaintManagerKey);

        if (rm == null) {

            rm = new RepaintManager(BUFFER_STRATEGY_TYPE);

            appContext.put(repaintManagerKey, rm);

        }

        return rm;

    }

    /**

     * Return the RepaintManager for the calling thread given a JComponent.

     * <p>

    * Note: This method exists for backward binary compatibility with earlier

     * versions of the Swing library. It simply returns the result returned by

     * {@link #currentManager(Component)}.

     *

     * @param c a JComponent -- unused

     * @return the RepaintManager object

     */

    public static RepaintManager currentManager(JComponent c) {

        return currentManager((Component)c);

    }

    /**

     * Set the RepaintManager that should be used for the calling

     * thread. <b>aRepaintManager</b> will become the current RepaintManager

     * for the calling thread's thread group.

     * @param aRepaintManager  the RepaintManager object to use

     */

    public static void setCurrentManager(RepaintManager aRepaintManager) {

        if (aRepaintManager != null) {

            SwingUtilities.appContextPut(repaintManagerKey, aRepaintManager);

        } else {

            SwingUtilities.appContextRemove(repaintManagerKey);

        }

    }

    /**

     * Create a new RepaintManager instance. You rarely call this constructor.

     * directly. To get the default RepaintManager, use

     * RepaintManager.currentManager(JComponent) (normally "this").

     */

    public RepaintManager() {

        // Because we can't know what a subclass is doing with the

        // volatile image we immediately punt in subclasses.  If this

        // poses a problem we'll need a more sophisticated detection algorithm,

        // or API.

        this(BUFFER_STRATEGY_SPECIFIED_OFF);

    }

    private RepaintManager(short bufferStrategyType) {

        // If native doublebuffering is being used, do NOT use

        // Swing doublebuffering.

        doubleBufferingEnabled = !nativeDoubleBuffering;

        synchronized(this) {

            dirtyComponents = new IdentityHashMap<Component,Rectangle>();

            tmpDirtyComponents = new IdentityHashMap<Component,Rectangle>();

            this.bufferStrategyType = bufferStrategyType;

            hwDirtyComponents = new IdentityHashMap<Container,Rectangle>();

        }

        processingRunnable = new ProcessingRunnable();

    }

    private void displayChanged() {

        clearImages();

    }

    /**

     * Mark the component as in need of layout and queue a runnable

     * for the event dispatching thread that will validate the components

     * first isValidateRoot() ancestor.

     *

     * @param invalidComponent a component

     * @see JComponent#isValidateRoot

     * @see #removeInvalidComponent

     */

    public synchronized void addInvalidComponent(JComponent invalidComponent)

    {

        RepaintManager delegate = getDelegate(invalidComponent);

        if (delegate != null) {

            delegate.addInvalidComponent(invalidComponent);

            return;

        }

        Component validateRoot =

            SwingUtilities.getValidateRoot(invalidComponent, true);

        if (validateRoot == null) {

            return;

        }

        /* Lazily create the invalidateComponents vector and add the

         * validateRoot if it's not there already.  If this validateRoot

         * is already in the vector, we're done.

         */

        if (invalidComponents == null) {

            invalidComponents = new ArrayList<Component>();

        }

        else {

            int n = invalidComponents.size();

            for(int i = 0; i < n; i++) {

                if(validateRoot == invalidComponents.get(i)) {

                    return;

                }

            }

        }

        invalidComponents.add(validateRoot);

        // Queue a Runnable to invoke paintDirtyRegions and

        // validateInvalidComponents.

        scheduleProcessingRunnable(SunToolkit.targetToAppContext(invalidComponent));

    }

    /**

     * Remove a component from the list of invalid components.

     *

     * @param component a component

     * @see #addInvalidComponent

     */

    public synchronized void removeInvalidComponent(JComponent component) {

        RepaintManager delegate = getDelegate(component);

        if (delegate != null) {

            delegate.removeInvalidComponent(component);

            return;

        }

        if(invalidComponents != null) {

            int index = invalidComponents.indexOf(component);

            if(index != -1) {

                invalidComponents.remove(index);

            }

        }

    }

    /**

     * Add a component in the list of components that should be refreshed.

     * If <i>c</i> already has a dirty region, the rectangle <i>(x,y,w,h)</i>

     * will be unioned with the region that should be redrawn.

     *

     * @see JComponent#repaint

     */

    @SuppressWarnings("deprecation")

    private void addDirtyRegion0(Container c, int x, int y, int w, int h) {

        /* Special cases we don't have to bother with.

         */

        if ((w <= 0) || (h <= 0) || (c == null)) {

            return;

        }

        if ((c.getWidth() <= 0) || (c.getHeight() <= 0)) {

            return;

        }

        if (extendDirtyRegion(c, x, y, w, h)) {

            // Component was already marked as dirty, region has been

            // extended, no need to continue.

            return;

        }

        /* Make sure that c and all it ancestors (up to an Applet or

         * Window) are visible.  This loop has the same effect as

         * checking c.isShowing() (and note that it's still possible

         * that c is completely obscured by an opaque ancestor in

         * the specified rectangle).

         */

        Component root = null;

        // Note: We can't synchronize around this, Frame.getExtendedState

        // is synchronized so that if we were to synchronize around this

        // it could lead to the possibility of getting locks out

        // of order and deadlocking.

        for (Container p = c; p != null; p = p.getParent()) {

            if (!p.isVisible() || !p.isDisplayable()) {

                return;

            }

            if ((p instanceof Window) || (p instanceof Applet)) {

                // Iconified frames are still visible!

                if (p instanceof Frame &&

                        (((Frame)p).getExtendedState() & Frame.ICONIFIED) ==

                                    Frame.ICONIFIED) {

                    return;

                }

                root = p;

                break;

            }

        }

        if (root == null) return;

        synchronized(this) {

            if (extendDirtyRegion(c, x, y, w, h)) {

                // In between last check and this check another thread

                // queued up runnable, can bail here.

                return;

            }

            dirtyComponents.put(c, new Rectangle(x, y, w, h));

        }

        // Queue a Runnable to invoke paintDirtyRegions and

        // validateInvalidComponents.

        scheduleProcessingRunnable(SunToolkit.targetToAppContext(c));

    }

    /**

     * Add a component in the list of components that should be refreshed.

     * If <i>c</i> already has a dirty region, the rectangle <i>(x,y,w,h)</i>

     * will be unioned with the region that should be redrawn.

     *

     * @param c Component to repaint, null results in nothing happening.

     * @param x X coordinate of the region to repaint

     * @param y Y coordinate of the region to repaint

     * @param w Width of the region to repaint

     * @param h Height of the region to repaint

     * @see JComponent#repaint

     */

    public void addDirtyRegion(JComponent c, int x, int y, int w, int h)

    {

        RepaintManager delegate = getDelegate(c);

        if (delegate != null) {

            delegate.addDirtyRegion(c, x, y, w, h);

            return;

        }

        addDirtyRegion0(c, x, y, w, h);

    }

    /**

     * Adds <code>window</code> to the list of <code>Component</code>s that

     * need to be repainted.

     *

     * @param window Window to repaint, null results in nothing happening.

     * @param x X coordinate of the region to repaint

     * @param y Y coordinate of the region to repaint

     * @param w Width of the region to repaint

     * @param h Height of the region to repaint

     * @see JFrame#repaint

     * @see JWindow#repaint

     * @see JDialog#repaint

     * @since 1.6

     */

    public void addDirtyRegion(Window window, int x, int y, int w, int h) {

        addDirtyRegion0(window, x, y, w, h);

    }

    /**

     * Adds <code>applet</code> to the list of <code>Component</code>s that

     * need to be repainted.