/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* 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.
*/
/**
* 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
*/
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_TYPE;
/**
* Maps from GraphicsConfiguration to VolatileImage.
*/
//
// 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.
//
// List of Runnables that need to be processed before painting from AWT.
boolean doubleBufferingEnabled = true;
// 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
//
/**
* Object responsible for hanlding core paint functionality.
*/
// 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.
/**
* Number of <code>beginPaint</code> that have been invoked.
*/
/**
* 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.
*/
/**
* The Thread that has initiated painting. If null it
* indicates painting is not currently in progress.
*/
/**
* Runnable used to process all repaint/revalidate requests.
*/
static {
"swing.volatileImageBufferEnabled", "true")));
if (volatileImageBufferEnabled && headless) {
volatileImageBufferEnabled = false;
}
new GetPropertyAction("awt.nativeDoubleBuffering")));
new GetPropertyAction("swing.bufferPerWindow"));
if (headless) {
}
}
}
else {
}
if (ge instanceof SunGraphicsEnvironment) {
new DisplayChangedHandler());
}
if ((tk instanceof SunToolkit)
} else {
}
}
/**
* 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
*/
// 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.
}
/**
* Returns the RepaintManager for the specified AppContext. If
* a RepaintManager has not been created for the specified
* AppContext this will return null.
*/
}
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
*/
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
*/
if (aRepaintManager != null) {
} else {
}
}
/**
* 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.
}
// If native doublebuffering is being used, do NOT use
// Swing doublebuffering.
synchronized(this) {
this.bufferStrategyType = bufferStrategyType;
}
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.
*
* @see JComponent#isValidateRoot
* @see #removeInvalidComponent
*/
{
return;
}
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) {
}
else {
int n = invalidComponents.size();
for(int i = 0; i < n; i++) {
return;
}
}
}
// Queue a Runnable to invoke paintDirtyRegions and
// validateInvalidComponents.
}
/**
* Remove a component from the list of invalid components.
*
* @see #addInvalidComponent
*/
return;
}
if(invalidComponents != null) {
if(index != -1) {
}
}
}
/**
* 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
*/
/* Special cases we don't have to bother with.
*/
return;
}
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).
*/
// 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.
return;
}
// Iconified frames are still visible!
if (p instanceof Frame &&
return;
}
root = p;
break;
}
}
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;
}
}
// Queue a Runnable to invoke paintDirtyRegions and
// validateInvalidComponents.
}
/**
* 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
*/
{
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
*/
addDirtyRegion0(window, x, y, w, h);
}
/**
* Adds <code>applet</code> to the list of <code>Component</code>s that
* need to be repainted.
*
* @param applet Applet 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 JApplet#repaint
* @since 1.6
*/
addDirtyRegion0(applet, x, y, w, h);
}
void scheduleHeavyWeightPaints() {
synchronized(this) {
return;
}
}
}
}
else { // SwingHeavyWeight
}
}
}
//
// This is called from the toolkit thread when a native expose is
// received.
//
int x, int y, int w, int h) {
if (w > 0 && h > 0) {
synchronized(this) {
}
else {
x, y, w, h, dirty));
}
}
}
}
//
// This is called from the toolkit thread when awt needs to run a
// Runnable before we paint.
//
{
synchronized(this) {
if (runnableList == null) {
}
public void run() {
r.run();
return null;
}
}
});
}
}
/**
* Extends the dirty region for the specified component to include
* the new region.
*
* @return false if <code>c</code> is not yet marked dirty.
*/
private synchronized boolean extendDirtyRegion(
Component c, int x, int y, int w, int h) {
if (r != null) {
// A non-null r implies c is already marked as dirty,
// and that the parent is valid. Therefore we can
// just union the rect and bail.
SwingUtilities.computeUnion(x, y, w, h, r);
return true;
}
return false;
}
/** Return the current dirty region for a component.
* Return an empty rectangle if the component is not
* dirty.
*/
}
Rectangle r;
synchronized(this) {
}
if(r == null)
else
return new Rectangle(r);
}
/**
* Mark a component completely dirty. <b>aComponent</b> will be
* completely painted during the next paintDirtyRegions() call.
*/
return;
}
}
/**
* Mark a component completely clean. <b>aComponent</b> will not
* get painted during the next paintDirtyRegions() call.
*/
return;
}
synchronized(this) {
}
}
/**
* Convenience method that returns true if <b>aComponent</b> will be completely
* painted during the next paintDirtyRegions(). If computing dirty regions is
* expensive for your component, use this method and avoid computing dirty region
* if it return true.
*/
}
Rectangle r;
r = getDirtyRegion(aComponent);
return true;
else
return false;
}
/**
* Validate all of the components that have been marked invalid.
* @see #addInvalidComponent
*/
public void validateInvalidComponents() {
synchronized(this) {
if (invalidComponents == null) {
return;
}
}
for(int i = 0; i < n; i++) {
new PrivilegedAction<Void>() {
c.validate();
return null;
}
}
}
/**
* This is invoked to process paint requests. It's needed
* for backward compatability in so far as RepaintManager would previously
* not see paint requests for top levels, so, we have to make sure
* a subclass correctly paints any dirty top levels.
*/
private void prePaintDirtyRegions() {
synchronized(this) {
dirtyComponents = this.dirtyComponents;
runnableList = this.runnableList;
this.runnableList = null;
}
if (runnableList != null) {
}
}
// This'll only happen if a subclass isn't correctly dealing
// with toplevels.
}
}
if (!(toolkit instanceof SunToolkit &&
{
return;
}
{
}
}
}
}
boolean isPainting() {
return painting;
}
/**
* Paint all of the components that have been marked dirty.
*
* @see #addDirtyRegion
*/
public void paintDirtyRegions() {
synchronized(this) { // swap for thread safety
}
}
private void paintDirtyRegions(
{
if (tmpDirtyComponents.isEmpty()) {
return;
}
}
painting = true;
try {
final int i = j;
0,
rect);
if (dirtyComponent instanceof JComponent) {
}
else if (dirtyComponent.isShowing()) {
// If the Graphics goes away, it means someone disposed of
// the window, don't do anything.
if (g != null) {
try {
dirtyComponent.paint(g);
} finally {
g.dispose();
}
}
}
// If the repaintRoot has been set, service it now and
// remove any components that are children of repaintRoot.
if (repaintRoot != null) {
paintManager.isRepaintingRoot = true;
repaintRoot.getHeight());
paintManager.isRepaintingRoot = false;
// Only service repaintRoot once.
repaintRoot = null;
}
return null;
}
}
} finally {
painting = false;
}
}
/**
* Removes any components from roots that are children of
* root.
*/
for(;;) {
break;
}
c = c.getParent();
}
if (c == root) {
}
}
}
// Find the highest parent which is dirty. When we get out of this
// rootDx and rootDy will contain the translation from the
// rootDirtyComponent's coordinate system to the coordinates of the
// original dirty component. The tmp Rect is also used to compute the
// visible portion of the dirtyRect.
int x = dirtyComponent.getX();
int y = dirtyComponent.getY();
int w = dirtyComponent.getWidth();
int h = dirtyComponent.getHeight();
// System.out.println("Collect dirty component for bound " + tmp +
// "component bounds is " + cBounds);;
// System.out.println("Empty 1");
return;
}
for(;;) {
if(!(component instanceof JComponent))
break;
break;
dx += x;
dy += y;
// System.out.println("Empty 2");
return;
}
}
}
if (dirtyComponent != rootDirtyComponent) {
Rectangle r;
}
// If we haven't seen this root before, then we need to add it to the
// list of root dirty Views.
}
/**
* Returns a string that displays and identifies this
* object's properties.
*
* @return a String representation of this object
*/
if(dirtyComponents != null)
}
/**
* Return the offscreen buffer that should be used as a double buffer with
* the component <code>c</code>.
* By default there is a double buffer per RepaintManager.
* The buffer might be smaller than <code>(proposedWidth,proposedHeight)</code>
* This happens when the maximum double buffer size as been set for the receiving
* repaint manager.
*/
}
}
/**
* Return a volatile offscreen buffer that should be used as a
* double buffer with the specified component <code>c</code>.
* The image returned will be an instance of VolatileImage, or null
* if a VolatileImage object could not be instantiated.
* This buffer might be smaller than <code>(proposedWidth,proposedHeight)</code>.
* This happens when the maximum double buffer size has been set for this
* repaint manager.
*
* @see java.awt.image.VolatileImage
* @since 1.4
*/
int proposedWidth,int proposedHeight) {
}
// If the window is non-opaque, it's double-buffered at peer's level
if (!w.isOpaque()) {
return null;
}
}
}
}
}
return image;
}
// If the window is non-opaque, it's double-buffered at peer's level
if (!w.isOpaque()) {
return null;
}
}
if (standardDoubleBuffer == null) {
standardDoubleBuffer = new DoubleBufferInfo();
}
doubleBuffer.needsReset = false;
}
}
if (c instanceof JComponent) {
((JComponent)c).setCreatedDoubleBuffer(true);
}
// JComponent will inform us when it is no longer valid
// (via removeNotify) we have no such hook to other components,
// therefore we don't keep a ref to the Component
// (indirectly through the Image) by stashing the image.
}
return result;
}
/** Set the maximum double buffer size. **/
doubleBufferMaxSize = d;
if (doubleBufferMaxSize == null) {
clearImages();
} else {
}
}
private void clearImages() {
}
}
}
// Clear out the VolatileImages
}
}
}
/**
* Returns the maximum double buffer size.
*
* @return a Dimension object representing the maximum size
*/
if (doubleBufferMaxSize == null) {
try {
}
} catch (HeadlessException e) {
}
}
return doubleBufferMaxSize;
}
/**
* Enables or disables double buffering in this RepaintManager.
* CAUTION: The default value for this property is set for optimal
* paint performance on the given platform and it is not recommended
* that programs modify this property directly.
*
* @param aFlag true to activate double buffering
* @see #isDoubleBufferingEnabled
*/
setPaintManager(new PaintManager());
}
}
/**
* Returns true if this RepaintManager is double buffered.
* The default value for this property may vary from platform
* to platform. On platforms where native double buffering
* is supported in the AWT, the default value will be <code>false</code>
* to avoid unnecessary buffering in Swing.
* On platforms where native double buffering is not supported,
* the default value will be <code>true</code>.
*
* @return true if this object is double buffered
*/
public boolean isDoubleBufferingEnabled() {
return doubleBufferingEnabled;
}
/**
* This resets the double buffer. Actually, it marks the double buffer
* as invalid, the double buffer will then be recreated on the next
* invocation of getOffscreenBuffer.
*/
void resetDoubleBuffer() {
if (standardDoubleBuffer != null) {
standardDoubleBuffer.needsReset = true;
}
}
/**
* This resets the volatile double buffer.
*/
}
}
/**
* Returns true if we should use the <code>Image</code> returned
* from <code>getVolatileOffscreenBuffer</code> to do double buffering.
*/
boolean useVolatileDoubleBuffer() {
return volatileImageBufferEnabled;
}
/**
* Returns true if the current thread is the thread painting. This
* will return false if no threads are painting.
*/
private synchronized boolean isPaintingThread() {
}
//
// Paint methods. You very, VERY rarely need to invoke these.
// They are invoked directly from JComponent's painting code and
// when painting happens outside the normal flow: DefaultDesktopManager
// and JViewport. If you end up needing these methods in other places be
// careful that you don't get stuck in a paint loop.
//
/**
* Paints a region of a component
*
* @param paintingComponent Component to paint
* @param bufferComponent Component to obtain buffer for
* @param g Graphics to paint to
* @param x X-coordinate
* @param y Y-coordinate
* @param w Width
* @param h Height
*/
int x, int y, int w, int h) {
if (!isPaintingThread()) {
// We're painting to two threads at once. PaintManager deals
// with this a bit better than BufferStrategyPaintManager, use
// it to avoid possible exceptions/corruption.
paintManager = new PaintManager();
paintManager.repaintManager = this;
}
}
x, y, w, h)) {
g.setClip(x, y, w, h);
paintingComponent.paintToOffscreen(g, x, y, w, h, x + w, y + h);
}
}
/**
* Does a copy area on the specified region.
*
* @param clip Whether or not the copyArea needs to be clipped to the
* Component's bounds.
*/
}
/**
* be followed by an invocation of <code>endPaint</code>.
* <b>WARNING</b>: Callers of this method need to wrap the call
* during the course of painting the RepaintManager may
* be left in a state in which the screen is not updated, eg:
* <pre>
* repaintManager.beginPaint();
* try {
* repaintManager.paint(...);
* } finally {
* repaintManager.endPaint();
* }
* </pre>
*/
void beginPaint() {
boolean multiThreadedPaint = false;
int paintDepth;
synchronized(this) {
paintDepth = this.paintDepth;
this.paintDepth++;
} else {
multiThreadedPaint = true;
}
}
}
}
/**
* Invoked after <code>beginPaint</code> has been invoked.
*/
void endPaint() {
if (isPaintingThread()) {
synchronized(this) {
if (--paintDepth == 0) {
}
}
if (paintManager != null) {
synchronized(this) {
paintThread = null;
}
}
}
}
/**
* If possible this will show a previously rendered portion of
* a Component. If successful, this will return true, otherwise false.
* <p>
* WARNING: This method is invoked from the native toolkit thread, be
* very careful as to what methods this invokes!
*/
return getPaintManager().show(c, x, y, w, h);
}
/**
* Invoked when the doubleBuffered or useTrueDoubleBuffering
* properties of a JRootPane change. This may come in on any thread.
*/
}
/**
* Sets the <code>PaintManager</code> that is used to handle all
* double buffered painting.
*
* @param paintManager The PaintManager to use. Passing in null indicates
* the fallback PaintManager should be used.
*/
if (paintManager == null) {
paintManager = new PaintManager();
}
synchronized(this) {
oldPaintManager = this.paintManager;
this.paintManager = paintManager;
paintManager.repaintManager = this;
}
if (oldPaintManager != null) {
}
}
if (paintManager == null) {
if (doubleBufferingEnabled && !nativeDoubleBuffering) {
switch (bufferStrategyType) {
if (tk instanceof SunToolkit) {
if (stk.useBufferPerWindow()) {
paintManager = new BufferStrategyPaintManager();
}
}
break;
paintManager = new BufferStrategyPaintManager();
break;
default:
break;
}
}
// null case handled in setPaintManager
}
return paintManager;
}
if (processingRunnable.markPending()) {
if (tk instanceof SunToolkit) {
} else {
}
}
}
/**
* PaintManager is used to handle all double buffered painting for
* Swing. Subclasses should call back into the JComponent method
* <code>paintToOffscreen</code> to handle the actual painting.
*/
static class PaintManager {
/**
* RepaintManager the PaintManager has been installed on.
*/
boolean isRepaintingRoot;
/**
* Paints a region of a component
*
* @param paintingComponent Component to paint
* @param bufferComponent Component to obtain buffer for
* @param g Graphics to paint to
* @param x X-coordinate
* @param y Y-coordinate
* @param w Width
* @param h Height
* @return true if painting was successful.
*/
int x, int y, int w, int h) {
// First attempt to use VolatileImage buffer for performance.
// If this fails (which should rarely occur), fallback to a
// standard Image buffer.
boolean paintCompleted = false;
if (repaintManager.useVolatileDoubleBuffer() &&
for (int i = 0; !paintCompleted &&
i < RepaintManager.VOLATILE_LOOP_MAX; i++) {
bufferComponent,w, h);
}
w, h);
}
}
// VolatileImage painting loop failed, fallback to regular
// offscreen buffer
bufferComponent, w, h))) != null) {
h);
paintCompleted = true;
}
return paintCompleted;
}
/**
* Does a copy area on the specified region.
*/
}
/**
* Invoked prior to any calls to paint or copyArea.
*/
public void beginPaint() {
}
/**
* Invoked to indicate painting has been completed.
*/
public void endPaint() {
}
/**
* Shows a region of a previously rendered component. This
* will return true if successful, false otherwise. The default
* implementation returns false.
*/
return false;
}
/**
* Invoked when the doubleBuffered or useTrueDoubleBuffering
* properties of a JRootPane change. This may come in on any thread.
*/
}
/**
* Paints a portion of a component to an offscreen buffer.
*/
try {
&& osg instanceof Graphics2D) {
}
&& g instanceof Graphics2D) {
} else {
}
}
}
} finally {
}
}
/**
* If <code>image</code> is non-null with a positive size it
* is returned, otherwise null is returned.
*/
return image;
}
return null;
}
/**
* Schedules a repaint for the specified component. This differs
* from <code>root.repaint</code> in that if the RepaintManager is
* currently processing paint requests it'll process this request
* with the current set of requests.
*/
if (repaintManager.painting) {
}
else {
}
}
/**
* Returns true if the component being painted is the root component
* that was previously passed to <code>repaintRoot</code>.
*/
protected boolean isRepaintingRoot() {
return isRepaintingRoot;
}
/**
* Cleans up any state. After invoked the PaintManager will no
* longer be used anymore.
*/
protected void dispose() {
}
}
private class DoubleBufferInfo {
public boolean needsReset = false;
}
/**
* Listener installed to detect display changes. When display changes,
* schedules a callback to notify all RepaintManagers of the display
* changes. Only one DisplayChangedHandler is ever installed. The
* singleton instance will schedule notification for all AppContexts.
*/
private static final class DisplayChangedHandler implements
public void displayChanged() {
}
public void paletteChanged() {
}
private void scheduleDisplayChanges() {
// To avoid threading problems, we notify each RepaintManager
// on the thread it was created on.
synchronized(context) {
if (!context.isDisposed()) {
if (eventQueue != null) {
new DisplayChangedRunnable()));
}
}
}
}
}
}
public void run() {
}
}
/**
* Runnable used to process all repaint/revalidate requests.
*/
// If true, we're wainting on the EventQueue.
private boolean pending;
/**
* Marks this processing runnable as pending. If this was not
* already marked as pending, true is returned.
*/
public synchronized boolean markPending() {
if (!pending) {
pending = true;
return true;
}
return false;
}
public void run() {
synchronized (this) {
pending = false;
}
// First pass, flush any heavy paint events into real paint
// events. If there are pending heavy weight requests this will
// result in q'ing this request up one more time. As
// long as no other requests come in between now and the time
// the second one is processed nothing will happen. This is not
// ideal, but the logic needed to suppress the second request is
// more headache than it's worth.
// Do the actual validation and painting.
}
}
if (this == delegate) {
}
return delegate;
}
}