1 /*

     2  * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

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

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 package javax.swing;

    26 

    27 

    28 import java.awt.*;

    29 import java.awt.event.*;

    30 import java.awt.image.VolatileImage;

    31 import java.security.AccessControlContext;

    32 import java.security.AccessController;

    33 import java.security.PrivilegedAction;

    34 import java.util.*;

    35 import java.util.concurrent.atomic.AtomicInteger;

    36 import java.applet.*;

    37 

    38 import jdk.internal.misc.JavaSecurityAccess;

    39 import jdk.internal.misc.SharedSecrets;

    40 import sun.awt.AWTAccessor;

    41 import sun.awt.AppContext;

    42 import sun.awt.DisplayChangedListener;

    43 import sun.awt.SunToolkit;

    44 import sun.java2d.SunGraphicsEnvironment;

    45 import sun.security.action.GetPropertyAction;

    46 

    47 import com.sun.java.swing.SwingUtilities3;

    48 import java.awt.geom.AffineTransform;

    49 import sun.java2d.SunGraphics2D;

    50 import sun.java2d.pipe.Region;

    51 import sun.swing.SwingAccessor;

    52 import sun.swing.SwingUtilities2;

    53 import sun.swing.SwingUtilities2.RepaintListener;

    54 

    55 /**

    56  * This class manages repaint requests, allowing the number

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

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

    59  * <p>

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

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

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

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

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

    65  *

    66  * @author Arnaud Weber

    67  * @since 1.2

    68  */

    69 public class RepaintManager

    70 {

    71     /**

    72      * Whether or not the RepaintManager should handle paint requests

    73      * for top levels.

    74      */

    75     static final boolean HANDLE_TOP_LEVEL_PAINT;

    76 

    77     private static final short BUFFER_STRATEGY_NOT_SPECIFIED = 0;

    78     private static final short BUFFER_STRATEGY_SPECIFIED_ON = 1;

    79     private static final short BUFFER_STRATEGY_SPECIFIED_OFF = 2;

    80 

    81     private static final short BUFFER_STRATEGY_TYPE;

    82 

    83     /**

    84      * Maps from GraphicsConfiguration to VolatileImage.

    85      */

    86     private Map<GraphicsConfiguration,VolatileImage> volatileMap = new

    87                         HashMap<GraphicsConfiguration,VolatileImage>(1);

    88 

    89     //

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

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

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

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

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

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

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

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

    98     // painted with the rest of the components.

    99     //

   100     private Map<Container,Rectangle> hwDirtyComponents;

   101 

   102     private Map<Component,Rectangle> dirtyComponents;

   103     private Map<Component,Rectangle> tmpDirtyComponents;

   104     private java.util.List<Component> invalidComponents;

   105 

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

   107     private java.util.List<Runnable> runnableList;

   108 

   109     boolean   doubleBufferingEnabled = true;

   110 

   111     private Dimension doubleBufferMaxSize;

   112 

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

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

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

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

   117 

   118     // Support for standard offscreen buffer

   119     //

   120     DoubleBufferInfo standardDoubleBuffer;

   121 

   122     /**

   123      * Object responsible for hanlding core paint functionality.

   124      */

   125     private PaintManager paintManager;

   126 

   127     private static final Object repaintManagerKey = RepaintManager.class;

   128 

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

   130     static boolean volatileImageBufferEnabled = true;

   131     /**

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

   133      * painting.

   134      */

   135     private static final int volatileBufferType;

   136     /**

   137      * Value of the system property awt.nativeDoubleBuffering.

   138      */

   139     private static boolean nativeDoubleBuffering;

   140 

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

   142     // buffer during a paint operation.

   143     private static final int VOLATILE_LOOP_MAX = 2;

   144 

   145     /**

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

   147      */

   148     private int paintDepth = 0;

   149 

   150     /**

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

   152      * constants.

   153      */

   154     private short bufferStrategyType;

   155 

   156     //

   157     // BufferStrategyPaintManager has the unique characteristic that it

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

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

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

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

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

   163     // and after the current JComponent.paintImmediately call finishes

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

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

   166     //

   167     /**

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

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

   170      */

   171     private boolean painting;

   172     /**

   173      * If the PaintManager calls into repaintRoot during painting this field

   174      * will be set to the root.

   175      */

   176     private JComponent repaintRoot;

   177 

   178     /**

   179      * The Thread that has initiated painting.  If null it

   180      * indicates painting is not currently in progress.

   181      */

   182     private Thread paintThread;

   183 

   184     /**

   185      * Runnable used to process all repaint/revalidate requests.

   186      */

   187     private final ProcessingRunnable processingRunnable;

   188 

   189     private static final JavaSecurityAccess javaSecurityAccess =

   190             SharedSecrets.getJavaSecurityAccess();

   191 

   192     /**

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

   194      * schedules a callback to notify all RepaintManagers of the display

   195      * changes.

   196      */

   197     private static final DisplayChangedListener displayChangedHandler =

   198             new DisplayChangedHandler();

   199 

   200     static {

   201         SwingAccessor.setRepaintManagerAccessor(new SwingAccessor.RepaintManagerAccessor() {

   202             @Override

   203             public void addRepaintListener(RepaintManager rm, RepaintListener l) {

   204                 rm.addRepaintListener(l);

   205             }

   206             @Override

   207             public void removeRepaintListener(RepaintManager rm, RepaintListener l) {

   208                 rm.removeRepaintListener(l);

   209             }

   210         });

   211 

   212         volatileImageBufferEnabled = "true".equals(AccessController.

   213                 doPrivileged(new GetPropertyAction(

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

   215         boolean headless = GraphicsEnvironment.isHeadless();

   216         if (volatileImageBufferEnabled && headless) {

   217             volatileImageBufferEnabled = false;

   218         }

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

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

   221         String bs = AccessController.doPrivileged(

   222                           new GetPropertyAction("swing.bufferPerWindow"));

   223         if (headless) {

   224             BUFFER_STRATEGY_TYPE = BUFFER_STRATEGY_SPECIFIED_OFF;

   225         }

   226         else if (bs == null) {

   227             BUFFER_STRATEGY_TYPE = BUFFER_STRATEGY_NOT_SPECIFIED;

   228         }

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

   230             BUFFER_STRATEGY_TYPE = BUFFER_STRATEGY_SPECIFIED_ON;

   231         }

   232         else {

   233             BUFFER_STRATEGY_TYPE = BUFFER_STRATEGY_SPECIFIED_OFF;

   234         }

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

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

   237         GraphicsEnvironment ge = GraphicsEnvironment.

   238                 getLocalGraphicsEnvironment();

   239         if (ge instanceof SunGraphicsEnvironment) {

   240             ((SunGraphicsEnvironment) ge).addDisplayChangedListener(

   241                     displayChangedHandler);

   242         }

   243         Toolkit tk = Toolkit.getDefaultToolkit();

   244         if ((tk instanceof SunToolkit)

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

   246             volatileBufferType = Transparency.TRANSLUCENT;

   247         } else {

   248             volatileBufferType = Transparency.OPAQUE;

   249         }

   250     }

   251 

   252     /**

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

   254      *

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

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

   257      *          depending on the Component

   258      * @return the RepaintManager object

   259      */

   260     public static RepaintManager currentManager(Component c) {

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

   262         // component is ever used to determine the current

   263         // RepaintManager, DisplayChangedRunnable will need to be modified

   264         // accordingly.

   265         return currentManager(AppContext.getAppContext());

   266     }

   267 

   268     /**

   269      * Returns the RepaintManager for the specified AppContext.  If

   270      * a RepaintManager has not been created for the specified

   271      * AppContext this will return null.

   272      */

   273     static RepaintManager currentManager(AppContext appContext) {

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

   275         if (rm == null) {

   276             rm = new RepaintManager(BUFFER_STRATEGY_TYPE);

   277             appContext.put(repaintManagerKey, rm);

   278         }

   279         return rm;

   280     }

   281 

   282     /**

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

   284      * <p>

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

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

   287      * {@link #currentManager(Component)}.

   288      *

   289      * @param c a JComponent -- unused

   290      * @return the RepaintManager object

   291      */

   292     public static RepaintManager currentManager(JComponent c) {

   293         return currentManager((Component)c);

   294     }

   295 

   296 

   297     /**

   298      * Set the RepaintManager that should be used for the calling

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

   300      * for the calling thread's thread group.

   301      * @param aRepaintManager  the RepaintManager object to use

   302      */

   303     public static void setCurrentManager(RepaintManager aRepaintManager) {

   304         if (aRepaintManager != null) {

   305             SwingUtilities.appContextPut(repaintManagerKey, aRepaintManager);

   306         } else {

   307             SwingUtilities.appContextRemove(repaintManagerKey);

   308         }

   309     }

   310 

   311     /**

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

   313      * directly. To get the default RepaintManager, use

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

   315      */

   316     public RepaintManager() {

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

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

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

   320         // or API.

   321         this(BUFFER_STRATEGY_SPECIFIED_OFF);

   322     }

   323 

   324     private RepaintManager(short bufferStrategyType) {

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

   326         // Swing doublebuffering.

   327         doubleBufferingEnabled = !nativeDoubleBuffering;

   328         synchronized(this) {

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

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

   331             this.bufferStrategyType = bufferStrategyType;

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

   333         }

   334         processingRunnable = new ProcessingRunnable();

   335     }

   336 

   337     private void displayChanged() {

   338         clearImages();

   339     }

   340 

   341     /**

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

   343      * for the event dispatching thread that will validate the components

   344      * first isValidateRoot() ancestor.

   345      *

   346      * @param invalidComponent a component

   347      * @see JComponent#isValidateRoot

   348      * @see #removeInvalidComponent

   349      */

   350     public synchronized void addInvalidComponent(JComponent invalidComponent)

   351     {

   352         RepaintManager delegate = getDelegate(invalidComponent);

   353         if (delegate != null) {

   354             delegate.addInvalidComponent(invalidComponent);

   355             return;

   356         }

   357         Component validateRoot =

   358             SwingUtilities.getValidateRoot(invalidComponent, true);

   359 

   360         if (validateRoot == null) {

   361             return;

   362         }

   363 

   364         /* Lazily create the invalidateComponents vector and add the

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

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

   367          */

   368         if (invalidComponents == null) {

   369             invalidComponents = new ArrayList<Component>();

   370         }

   371         else {

   372             int n = invalidComponents.size();

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

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

   375                     return;

   376                 }

   377             }

   378         }

   379         invalidComponents.add(validateRoot);

   380 

   381         // Queue a Runnable to invoke paintDirtyRegions and

   382         // validateInvalidComponents.

   383         scheduleProcessingRunnable(SunToolkit.targetToAppContext(invalidComponent));

   384     }

   385 

   386 

   387     /**

   388      * Remove a component from the list of invalid components.

   389      *

   390      * @param component a component

   391      * @see #addInvalidComponent

   392      */

   393     public synchronized void removeInvalidComponent(JComponent component) {

   394         RepaintManager delegate = getDelegate(component);

   395         if (delegate != null) {

   396             delegate.removeInvalidComponent(component);

   397             return;

   398         }

   399         if(invalidComponents != null) {

   400             int index = invalidComponents.indexOf(component);

   401             if(index != -1) {

   402                 invalidComponents.remove(index);

   403             }

   404         }

   405     }

   406 

   407 

   408     /**

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

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

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

   412      *

   413      * @see JComponent#repaint

   414      */

   415     @SuppressWarnings("deprecation")

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

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

   418          */

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

   420             return;

   421         }

   422 

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

   424             return;

   425         }

   426 

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

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

   429             // extended, no need to continue.

   430             return;

   431         }

   432 

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

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

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

   436          * that c is completely obscured by an opaque ancestor in

   437          * the specified rectangle).

   438          */

   439         Component root = null;

   440 

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

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

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

   444         // of order and deadlocking.

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

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

   447                 return;

   448             }

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

   450                 // Iconified frames are still visible!

   451                 if (p instanceof Frame &&

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

   453                                     Frame.ICONIFIED) {

   454                     return;

   455                 }

   456                 root = p;

   457                 break;

   458             }

   459         }

   460 

   461         if (root == null) return;

   462 

   463         synchronized(this) {

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

   465                 // In between last check and this check another thread

   466                 // queued up runnable, can bail here.

   467                 return;

   468             }

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

   470         }

   471 

   472         // Queue a Runnable to invoke paintDirtyRegions and

   473         // validateInvalidComponents.

   474         scheduleProcessingRunnable(SunToolkit.targetToAppContext(c));

   475     }

   476 

   477     /**

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

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

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

   481      *

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

   483      * @param x X coordinate of the region to repaint

   484      * @param y Y coordinate of the region to repaint

   485      * @param w Width of the region to repaint

   486      * @param h Height of the region to repaint

   487      * @see JComponent#repaint

   488      */

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

   490     {

   491         RepaintManager delegate = getDelegate(c);

   492         if (delegate != null) {

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

   494             return;

   495         }

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

   497     }

   498 

   499     /**

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

   501      * need to be repainted.

   502      *

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

   504      * @param x X coordinate of the region to repaint

   505      * @param y Y coordinate of the region to repaint

   506      * @param w Width of the region to repaint

   507      * @param h Height of the region to repaint

   508      * @see JFrame#repaint

   509      * @see JWindow#repaint

   510      * @see JDialog#repaint

   511      * @since 1.6

   512      */

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

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

   515     }

   516 

   517     /**

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

   519      * need to be repainted.

   520      *

   521      * @param applet Applet to repaint, null results in nothing happening.

   522      * @param x X coordinate of the region to repaint

   523      * @param y Y coordinate of the region to repaint

   524      * @param w Width of the region to repaint

   525      * @param h Height of the region to repaint

   526      * @see JApplet#repaint

   527      * @since 1.6

   528      *

   529      * @deprecated The Applet API is deprecated. See the

   530      * <a href="../../java/applet/package-summary.html"> java.applet package

   531      * documentation</a> for further information.

   532      */

   533     @Deprecated(since = "9")

   534     public void addDirtyRegion(Applet applet, int x, int y, int w, int h) {

   535         addDirtyRegion0(applet, x, y, w, h);

   536     }

   537 

   538     @SuppressWarnings("deprecation")

   539     void scheduleHeavyWeightPaints() {

   540         Map<Container,Rectangle> hws;

   541 

   542         synchronized(this) {

   543             if (hwDirtyComponents.size() == 0) {

   544                 return;

   545             }

   546             hws = hwDirtyComponents;

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

   548         }

   549         for (Container hw : hws.keySet()) {

   550             Rectangle dirty = hws.get(hw);

   551             if (hw instanceof Window) {

   552                 addDirtyRegion((Window)hw, dirty.x, dirty.y,

   553                                dirty.width, dirty.height);

   554             }

   555             else if (hw instanceof Applet) {

   556                 addDirtyRegion((Applet)hw, dirty.x, dirty.y,

   557                                dirty.width, dirty.height);

   558             }

   559             else { // SwingHeavyWeight

   560                 addDirtyRegion0(hw, dirty.x, dirty.y,

   561                                 dirty.width, dirty.height);

   562             }

   563         }

   564     }

   565 

   566     //

   567     // This is called from the toolkit thread when a native expose is

   568     // received.

   569     //

   570     void nativeAddDirtyRegion(AppContext appContext, Container c,

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

   572         if (w > 0 && h > 0) {

   573             synchronized(this) {

   574                 Rectangle dirty = hwDirtyComponents.get(c);

   575                 if (dirty == null) {

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

   577                 }

   578                 else {

   579                     hwDirtyComponents.put(c, SwingUtilities.computeUnion(

   580                                               x, y, w, h, dirty));

   581                 }

   582             }

   583             scheduleProcessingRunnable(appContext);

   584         }

   585     }

   586 

   587     //

   588     // This is called from the toolkit thread when awt needs to run a

   589     // Runnable before we paint.

   590     //

   591     void nativeQueueSurfaceDataRunnable(AppContext appContext,

   592                                         final Component c, final Runnable r)

   593     {

   594         synchronized(this) {

   595             if (runnableList == null) {

   596                 runnableList = new LinkedList<Runnable>();

   597             }

   598             runnableList.add(new Runnable() {

   599                 public void run() {

   600                     AccessControlContext stack = AccessController.getContext();

   601                     AccessControlContext acc =

   602                         AWTAccessor.getComponentAccessor().getAccessControlContext(c);

   603                     javaSecurityAccess.doIntersectionPrivilege(new PrivilegedAction<Void>() {

   604                         public Void run() {

   605                             r.run();

   606                             return null;

   607                         }

   608                     }, stack, acc);

   609                 }

   610             });

   611         }

   612         scheduleProcessingRunnable(appContext);

   613     }

   614 

   615     /**

   616      * Extends the dirty region for the specified component to include

   617      * the new region.

   618      *

   619      * @return false if <code>c</code> is not yet marked dirty.

   620      */

   621     private synchronized boolean extendDirtyRegion(

   622         Component c, int x, int y, int w, int h) {

   623         Rectangle r = dirtyComponents.get(c);

   624         if (r != null) {

   625             // A non-null r implies c is already marked as dirty,

   626             // and that the parent is valid. Therefore we can

   627             // just union the rect and bail.

   628             SwingUtilities.computeUnion(x, y, w, h, r);

   629             return true;

   630         }

   631         return false;

   632     }

   633 

   634     /**

   635      * Return the current dirty region for a component.

   636      * Return an empty rectangle if the component is not

   637      * dirty.

   638      *

   639      * @param aComponent a component

   640      * @return the region

   641      */

   642     public Rectangle getDirtyRegion(JComponent aComponent) {

   643         RepaintManager delegate = getDelegate(aComponent);

   644         if (delegate != null) {

   645             return delegate.getDirtyRegion(aComponent);

   646         }

   647         Rectangle r;

   648         synchronized(this) {

   649             r = dirtyComponents.get(aComponent);

   650         }

   651         if(r == null)

   652             return new Rectangle(0,0,0,0);

   653         else

   654             return new Rectangle(r);

   655     }

   656 

   657     /**

   658      * Mark a component completely dirty. <b>aComponent</b> will be

   659      * completely painted during the next paintDirtyRegions() call.

   660      *

   661      * @param aComponent a component

   662      */

   663     public void markCompletelyDirty(JComponent aComponent) {

   664         RepaintManager delegate = getDelegate(aComponent);

   665         if (delegate != null) {

   666             delegate.markCompletelyDirty(aComponent);

   667             return;

   668         }

   669         addDirtyRegion(aComponent,0,0,Integer.MAX_VALUE,Integer.MAX_VALUE);

   670     }

   671 

   672     /**

   673      * Mark a component completely clean. <b>aComponent</b> will not

   674      * get painted during the next paintDirtyRegions() call.

   675      *

   676      * @param aComponent a component

   677      */

   678     public void markCompletelyClean(JComponent aComponent) {

   679         RepaintManager delegate = getDelegate(aComponent);

   680         if (delegate != null) {

   681             delegate.markCompletelyClean(aComponent);

   682             return;

   683         }

   684         synchronized(this) {

   685                 dirtyComponents.remove(aComponent);

   686         }

   687     }

   688 

   689     /**

   690      * Convenience method that returns true if <b>aComponent</b> will be completely

   691      * painted during the next paintDirtyRegions(). If computing dirty regions is

   692      * expensive for your component, use this method and avoid computing dirty region

   693      * if it return true.

   694      *

   695      * @param aComponent a component

   696      * @return {@code true} if <b>aComponent</b> will be completely

   697      *         painted during the next paintDirtyRegions().

   698      */

   699     public boolean isCompletelyDirty(JComponent aComponent) {

   700         RepaintManager delegate = getDelegate(aComponent);

   701         if (delegate != null) {

   702             return delegate.isCompletelyDirty(aComponent);

   703         }

   704         Rectangle r;

   705 

   706         r = getDirtyRegion(aComponent);

   707         if(r.width == Integer.MAX_VALUE &&

   708            r.height == Integer.MAX_VALUE)

   709             return true;

   710         else

   711             return false;

   712     }

   713 

   714 

   715     /**

   716      * Validate all of the components that have been marked invalid.

   717      * @see #addInvalidComponent

   718      */

   719     public void validateInvalidComponents() {

   720         final java.util.List<Component> ic;

   721         synchronized(this) {

   722             if (invalidComponents == null) {

   723                 return;

   724             }

   725             ic = invalidComponents;

   726             invalidComponents = null;

   727         }

   728         int n = ic.size();

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

   730             final Component c = ic.get(i);

   731             AccessControlContext stack = AccessController.getContext();

   732             AccessControlContext acc =

   733                 AWTAccessor.getComponentAccessor().getAccessControlContext(c);

   734             javaSecurityAccess.doIntersectionPrivilege(

   735                 new PrivilegedAction<Void>() {

   736                     public Void run() {

   737                         c.validate();

   738                         return null;

   739                     }

   740                 }, stack, acc);

   741         }

   742     }

   743 

   744 

   745     /**

   746      * This is invoked to process paint requests.  It's needed

   747      * for backward compatibility in so far as RepaintManager would previously

   748      * not see paint requests for top levels, so, we have to make sure

   749      * a subclass correctly paints any dirty top levels.

   750      */

   751     private void prePaintDirtyRegions() {

   752         Map<Component,Rectangle> dirtyComponents;

   753         java.util.List<Runnable> runnableList;

   754         synchronized(this) {

   755             dirtyComponents = this.dirtyComponents;

   756             runnableList = this.runnableList;

   757             this.runnableList = null;

   758         }

   759         if (runnableList != null) {

   760             for (Runnable runnable : runnableList) {

   761                 runnable.run();

   762             }

   763         }

   764         paintDirtyRegions();

   765         if (dirtyComponents.size() > 0) {

   766             // This'll only happen if a subclass isn't correctly dealing

   767             // with toplevels.

   768             paintDirtyRegions(dirtyComponents);

   769         }

   770     }

   771 

   772     private void updateWindows(Map<Component,Rectangle> dirtyComponents) {

   773         Toolkit toolkit = Toolkit.getDefaultToolkit();

   774         if (!(toolkit instanceof SunToolkit &&

   775               ((SunToolkit)toolkit).needUpdateWindow()))

   776         {

   777             return;

   778         }

   779 

   780         Set<Window> windows = new HashSet<Window>();

   781         Set<Component> dirtyComps = dirtyComponents.keySet();

   782         for (Iterator<Component> it = dirtyComps.iterator(); it.hasNext();) {

   783             Component dirty = it.next();

   784             Window window = dirty instanceof Window ?

   785                 (Window)dirty :

   786                 SwingUtilities.getWindowAncestor(dirty);

   787             if (window != null &&

   788                 !window.isOpaque())

   789             {

   790                 windows.add(window);

   791             }

   792         }

   793 

   794         for (Window window : windows) {

   795             AWTAccessor.getWindowAccessor().updateWindow(window);

   796         }

   797     }

   798 

   799     boolean isPainting() {

   800         return painting;

   801     }

   802 

   803     /**

   804      * Paint all of the components that have been marked dirty.

   805      *

   806      * @see #addDirtyRegion

   807      */

   808     public void paintDirtyRegions() {

   809         synchronized(this) {  // swap for thread safety

   810             Map<Component,Rectangle> tmp = tmpDirtyComponents;

   811             tmpDirtyComponents = dirtyComponents;

   812             dirtyComponents = tmp;

   813             dirtyComponents.clear();

   814         }

   815         paintDirtyRegions(tmpDirtyComponents);

   816     }

   817 

   818     private void paintDirtyRegions(

   819         final Map<Component,Rectangle> tmpDirtyComponents)

   820     {

   821         if (tmpDirtyComponents.isEmpty()) {

   822             return;

   823         }

   824 

   825         final java.util.List<Component> roots =

   826             new ArrayList<Component>(tmpDirtyComponents.size());

   827         for (Component dirty : tmpDirtyComponents.keySet()) {

   828             collectDirtyComponents(tmpDirtyComponents, dirty, roots);

   829         }

   830 

   831         final AtomicInteger count = new AtomicInteger(roots.size());

   832         painting = true;

   833         try {

   834             for (int j=0 ; j < count.get(); j++) {

   835                 final int i = j;

   836                 final Component dirtyComponent = roots.get(j);

   837                 AccessControlContext stack = AccessController.getContext();

   838                 AccessControlContext acc =

   839                     AWTAccessor.getComponentAccessor().getAccessControlContext(dirtyComponent);

   840                 javaSecurityAccess.doIntersectionPrivilege(new PrivilegedAction<Void>() {

   841                     public Void run() {

   842                         Rectangle rect = tmpDirtyComponents.get(dirtyComponent);

   843                         // Sometimes when RepaintManager is changed during the painting

   844                         // we may get null here, see #6995769 for details

   845                         if (rect == null) {

   846                             return null;

   847                         }

   848 

   849                         int localBoundsH = dirtyComponent.getHeight();

   850                         int localBoundsW = dirtyComponent.getWidth();

   851                         SwingUtilities.computeIntersection(0,

   852                                                            0,

   853                                                            localBoundsW,

   854                                                            localBoundsH,

   855                                                            rect);

   856                         if (dirtyComponent instanceof JComponent) {

   857                             ((JComponent)dirtyComponent).paintImmediately(

   858                                 rect.x,rect.y,rect.width, rect.height);

   859                         }

   860                         else if (dirtyComponent.isShowing()) {

   861                             Graphics g = JComponent.safelyGetGraphics(

   862                                     dirtyComponent, dirtyComponent);

   863                             // If the Graphics goes away, it means someone disposed of

   864                             // the window, don't do anything.

   865                             if (g != null) {

   866                                 g.setClip(rect.x, rect.y, rect.width, rect.height);

   867                                 try {

   868                                     dirtyComponent.paint(g);

   869                                 } finally {

   870                                     g.dispose();

   871                                 }

   872                             }

   873                         }

   874                         // If the repaintRoot has been set, service it now and

   875                         // remove any components that are children of repaintRoot.

   876                         if (repaintRoot != null) {

   877                             adjustRoots(repaintRoot, roots, i + 1);

   878                             count.set(roots.size());

   879                             paintManager.isRepaintingRoot = true;

   880                             repaintRoot.paintImmediately(0, 0, repaintRoot.getWidth(),

   881                                                          repaintRoot.getHeight());

   882                             paintManager.isRepaintingRoot = false;

   883                             // Only service repaintRoot once.

   884                             repaintRoot = null;

   885                         }

   886 

   887                         return null;

   888                     }

   889                 }, stack, acc);

   890             }

   891         } finally {

   892             painting = false;

   893         }

   894 

   895         updateWindows(tmpDirtyComponents);

   896 

   897         tmpDirtyComponents.clear();

   898     }

   899 

   900 

   901     /**

   902      * Removes any components from roots that are children of

   903      * root.

   904      */

   905     private void adjustRoots(JComponent root,

   906                              java.util.List<Component> roots, int index) {

   907         for (int i = roots.size() - 1; i >= index; i--) {

   908             Component c = roots.get(i);

   909             for(;;) {

   910                 if (c == root || c == null || !(c instanceof JComponent)) {

   911                     break;

   912                 }

   913                 c = c.getParent();

   914             }

   915             if (c == root) {

   916                 roots.remove(i);

   917             }

   918         }

   919     }

   920 

   921     Rectangle tmp = new Rectangle();

   922 

   923     void collectDirtyComponents(Map<Component,Rectangle> dirtyComponents,

   924                                 Component dirtyComponent,

   925                                 java.util.List<Component> roots) {

   926         int dx, dy, rootDx, rootDy;

   927         Component component, rootDirtyComponent,parent;

   928         Rectangle cBounds;

   929 

   930         // Find the highest parent which is dirty.  When we get out of this

   931         // rootDx and rootDy will contain the translation from the

   932         // rootDirtyComponent's coordinate system to the coordinates of the

   933         // original dirty component.  The tmp Rect is also used to compute the

   934         // visible portion of the dirtyRect.

   935 

   936         component = rootDirtyComponent = dirtyComponent;

   937 

   938         int x = dirtyComponent.getX();

   939         int y = dirtyComponent.getY();

   940         int w = dirtyComponent.getWidth();

   941         int h = dirtyComponent.getHeight();

   942 

   943         dx = rootDx = 0;

   944         dy = rootDy = 0;

   945         tmp.setBounds(dirtyComponents.get(dirtyComponent));

   946 

   947         // System.out.println("Collect dirty component for bound " + tmp +

   948         //                                   "component bounds is " + cBounds);;

   949         SwingUtilities.computeIntersection(0,0,w,h,tmp);

   950 

   951         if (tmp.isEmpty()) {

   952             // System.out.println("Empty 1");

   953             return;

   954         }

   955 

   956         for(;;) {

   957             if(!(component instanceof JComponent))

   958                 break;

   959 

   960             parent = component.getParent();

   961             if(parent == null)

   962                 break;

   963 

   964             component = parent;

   965 

   966             dx += x;

   967             dy += y;

   968             tmp.setLocation(tmp.x + x, tmp.y + y);

   969 

   970             x = component.getX();

   971             y = component.getY();

   972             w = component.getWidth();

   973             h = component.getHeight();

   974             tmp = SwingUtilities.computeIntersection(0,0,w,h,tmp);

   975 

   976             if (tmp.isEmpty()) {

   977                 // System.out.println("Empty 2");

   978                 return;

   979             }

   980 

   981             if (dirtyComponents.get(component) != null) {

   982                 rootDirtyComponent = component;

   983                 rootDx = dx;

   984                 rootDy = dy;

   985             }

   986         }

   987 

   988         if (dirtyComponent != rootDirtyComponent) {

   989             Rectangle r;

   990             tmp.setLocation(tmp.x + rootDx - dx,

   991                             tmp.y + rootDy - dy);

   992             r = dirtyComponents.get(rootDirtyComponent);

   993             SwingUtilities.computeUnion(tmp.x,tmp.y,tmp.width,tmp.height,r);

   994         }

   995 

   996         // If we haven't seen this root before, then we need to add it to the

   997         // list of root dirty Views.

   998 

   999         if (!roots.contains(rootDirtyComponent))

  1000             roots.add(rootDirtyComponent);

  1001     }

  1002 

  1003 

  1004     /**

  1005      * Returns a string that displays and identifies this

  1006      * object's properties.

  1007      *

  1008      * @return a String representation of this object

  1009      */

  1010     public synchronized String toString() {

  1011         StringBuilder sb = new StringBuilder();

  1012         if(dirtyComponents != null)

  1013             sb.append("" + dirtyComponents);

  1014         return sb.toString();

  1015     }

  1016 

  1017 

  1018     /**

  1019      * Return the offscreen buffer that should be used as a double buffer with

  1020      * the component <code>c</code>.

  1021      * By default there is a double buffer per RepaintManager.

  1022      * The buffer might be smaller than <code>(proposedWidth,proposedHeight)</code>

  1023      * This happens when the maximum double buffer size as been set for the receiving

  1024      * repaint manager.

  1025      *

  1026      * @param c the component

  1027      * @param proposedWidth the width of the buffer

  1028      * @param proposedHeight the height of the buffer

  1029      *

  1030      * @return the image

  1031      */

  1032     public Image getOffscreenBuffer(Component c,int proposedWidth,int proposedHeight) {

  1033         RepaintManager delegate = getDelegate(c);

  1034         if (delegate != null) {

  1035             return delegate.getOffscreenBuffer(c, proposedWidth, proposedHeight);

  1036         }

  1037         return _getOffscreenBuffer(c, proposedWidth, proposedHeight);

  1038     }

  1039 

  1040     /**

  1041      * Return a volatile offscreen buffer that should be used as a

  1042      * double buffer with the specified component <code>c</code>.

  1043      * The image returned will be an instance of VolatileImage, or null

  1044      * if a VolatileImage object could not be instantiated.

  1045      * This buffer might be smaller than <code>(proposedWidth,proposedHeight)</code>.

  1046      * This happens when the maximum double buffer size has been set for this

  1047      * repaint manager.

  1048      *

  1049      * @param c the component

  1050      * @param proposedWidth the width of the buffer

  1051      * @param proposedHeight the height of the buffer

  1052      *

  1053      * @return the volatile image

  1054      * @see java.awt.image.VolatileImage

  1055      * @since 1.4

  1056      */

  1057     public Image getVolatileOffscreenBuffer(Component c,

  1058                                             int proposedWidth,int proposedHeight) {

  1059         RepaintManager delegate = getDelegate(c);

  1060         if (delegate != null) {

  1061             return delegate.getVolatileOffscreenBuffer(c, proposedWidth,

  1062                                                         proposedHeight);

  1063         }

  1064 

  1065         // If the window is non-opaque, it's double-buffered at peer's level

  1066         Window w = (c instanceof Window) ? (Window)c : SwingUtilities.getWindowAncestor(c);

  1067         if (!w.isOpaque()) {

  1068             Toolkit tk = Toolkit.getDefaultToolkit();

  1069             if ((tk instanceof SunToolkit) && (((SunToolkit)tk).needUpdateWindow())) {

  1070                 return null;

  1071             }

  1072         }

  1073 

  1074         GraphicsConfiguration config = c.getGraphicsConfiguration();

  1075         if (config == null) {

  1076             config = GraphicsEnvironment.getLocalGraphicsEnvironment().

  1077                             getDefaultScreenDevice().getDefaultConfiguration();

  1078         }

  1079         Dimension maxSize = getDoubleBufferMaximumSize();

  1080         int width = proposedWidth < 1 ? 1 :

  1081             (proposedWidth > maxSize.width? maxSize.width : proposedWidth);

  1082         int height = proposedHeight < 1 ? 1 :

  1083             (proposedHeight > maxSize.height? maxSize.height : proposedHeight);

  1084         VolatileImage image = volatileMap.get(config);

  1085         if (image == null || image.getWidth() < width ||

  1086                              image.getHeight() < height) {

  1087             if (image != null) {

  1088                 image.flush();

  1089             }

  1090             image = config.createCompatibleVolatileImage(width, height,

  1091                                                          volatileBufferType);

  1092             volatileMap.put(config, image);

  1093         }

  1094         return image;

  1095     }

  1096 

  1097     private Image _getOffscreenBuffer(Component c, int proposedWidth, int proposedHeight) {

  1098         Dimension maxSize = getDoubleBufferMaximumSize();

  1099         DoubleBufferInfo doubleBuffer;

  1100         int width, height;

  1101 

  1102         // If the window is non-opaque, it's double-buffered at peer's level

  1103         Window w = (c instanceof Window) ? (Window)c : SwingUtilities.getWindowAncestor(c);

  1104         if (!w.isOpaque()) {

  1105             Toolkit tk = Toolkit.getDefaultToolkit();

  1106             if ((tk instanceof SunToolkit) && (((SunToolkit)tk).needUpdateWindow())) {

  1107                 return null;

  1108             }

  1109         }

  1110 

  1111         if (standardDoubleBuffer == null) {

  1112             standardDoubleBuffer = new DoubleBufferInfo();

  1113         }

  1114         doubleBuffer = standardDoubleBuffer;

  1115 

  1116         width = proposedWidth < 1? 1 :

  1117                   (proposedWidth > maxSize.width? maxSize.width : proposedWidth);

  1118         height = proposedHeight < 1? 1 :

  1119                   (proposedHeight > maxSize.height? maxSize.height : proposedHeight);

  1120 

  1121         if (doubleBuffer.needsReset || (doubleBuffer.image != null &&

  1122                                         (doubleBuffer.size.width < width ||

  1123                                          doubleBuffer.size.height < height))) {

  1124             doubleBuffer.needsReset = false;

  1125             if (doubleBuffer.image != null) {

  1126                 doubleBuffer.image.flush();

  1127                 doubleBuffer.image = null;

  1128             }

  1129             width = Math.max(doubleBuffer.size.width, width);

  1130             height = Math.max(doubleBuffer.size.height, height);

  1131         }

  1132 

  1133         Image result = doubleBuffer.image;

  1134