diff options
Diffstat (limited to 'libjava/javax/swing/RepaintManager.java')
| -rw-r--r-- | libjava/javax/swing/RepaintManager.java | 716 |
1 files changed, 482 insertions, 234 deletions
diff --git a/libjava/javax/swing/RepaintManager.java b/libjava/javax/swing/RepaintManager.java index 55d62ae..ace19cb2 100644 --- a/libjava/javax/swing/RepaintManager.java +++ b/libjava/javax/swing/RepaintManager.java @@ -35,248 +35,496 @@ this exception to your version of the library, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version. */ - package javax.swing; import java.awt.Component; import java.awt.Dimension; import java.awt.Image; import java.awt.Rectangle; +import java.util.AbstractMap; +import java.util.Enumeration; import java.util.Hashtable; +import java.util.HashMap; +import java.util.Iterator; import java.util.Vector; + /** - * RepaintManager - * @author Andrew Selkirk - * @version 1.0 + * <p>The repaint manager holds a set of dirty regions, invalid components, + * and a double buffer surface. The dirty regions and invalid components + * are used to coalesce multiple revalidate() and repaint() calls in the + * component tree into larger groups to be refreshed "all at once"; the + * double buffer surface is used by root components to paint + * themselves.</p> + * + * <p>In general, painting is very confusing in swing. see <a + * href="http://java.sun.com/products/jfc/tsc/articles/painting/index.html">this + * document</a> for more details.</p> + * + * @author Graydon Hoare (graydon@redhat.com) */ -public class RepaintManager { - - //------------------------------------------------------------- - // Variables -------------------------------------------------- - //------------------------------------------------------------- - - /** - * dirtyComponents - */ - Hashtable dirtyComponents; - - /** - * tmpDirtyComponents - */ - Hashtable tmpDirtyComponents; - - /** - * invalidComponents - */ - Vector invalidComponents; - - /** - * doubleBufferingEnabled - */ - boolean doubleBufferingEnabled; - - /** - * doubleBuffer - */ - Image doubleBuffer; - - /** - * doubleBufferSize - */ - Dimension doubleBufferSize; - - /** - * doubleBufferMaxSize - */ - private Dimension doubleBufferMaxSize; - - /** - * resetDoubleBuffer - */ - private boolean resetDoubleBuffer; - - /** - * repaintManagerKey - */ - private static final Object repaintManagerKey = null; // TODO - - /** - * tmp - */ - Rectangle tmp; - - - //------------------------------------------------------------- - // Initialization --------------------------------------------- - //------------------------------------------------------------- - - /** - * Constructor RepaintManager - */ - public RepaintManager() { - // TODO - } // RepaintManager() - - - //------------------------------------------------------------- - // Methods ---------------------------------------------------- - //------------------------------------------------------------- - - /** - * toString - * @returns String - */ - public synchronized String toString() { - return null; // TODO - } // toString() - - /** - * currentManager - * @param component TODO - * @returns RepaintManager - */ - public static RepaintManager currentManager(Component component) { - return null; // TODO - } // currentManager() - - /** - * currentManager - * @param component TODO - * @returns RepaintManager - */ - public static RepaintManager currentManager(JComponent component) { - return null; // TODO - } // currentManager() - - /** - * setCurrentManager - * @param manager TODO - */ - public static void setCurrentManager(RepaintManager manager) { - // TODO - } // setCurrentManager() - - /** - * addInvalidComponent - * @param component TODO - */ - public synchronized void addInvalidComponent(JComponent component) { - // TODO - } // addInvalidComponent() - - /** - * removeInvalidComponent - * @param component TODO - */ - public synchronized void removeInvalidComponent(JComponent component) { - // TODO - } // removeInvalidComponent() - - /** - * addDirtyRegion - * @param component TODO - * @param x TODO - * @param y TODO - * @param w TODO - * @param h TODO - */ - public synchronized void addDirtyRegion(JComponent component, int x, - int y, int w, int h) { - // TODO - } // addDirtyRegion() - - /** - * getDirtyRegion - * @param component TODO - * @returns Rectangle - */ - public Rectangle getDirtyRegion(JComponent component) { - return null; // TODO - } // getDirtyRegion() - - /** - * markCompletelyDirty - * @param component TODO - */ - public void markCompletelyDirty(JComponent component) { - // TODO - } // markCompletelyDirty() - - /** - * markCompletelyClean - * @param component TODO - */ - public void markCompletelyClean(JComponent component) { - // TODO - } // markCompletelyClean() - - /** - * isCompletelyDirty - * @param component TODO - * @returns boolean - */ - public boolean isCompletelyDirty(JComponent component) { - return false; // TODO - } // isCompletelyDirty() - - /** - * validateInvalidComponents - */ - public void validateInvalidComponents() { - // TODO - } // validateInvalidComponents() - - /** - * paintDirtyRegions - */ - public void paintDirtyRegions() { - // TODO - } // paintDirtyRegions() - - /** - * getOffscreenBuffer - * @param component TODO - * @param proposedWidth TODO - * @param proposedHeight TODO - * @returns Image - */ - public Image getOffscreenBuffer(Component component, - int proposedWidth, int proposedHeight) { - return null; // TODO - } // getOffscreenBuffer() - - /** - * getDoubleBufferMaximumSize - * @returns Dimension - */ - public Dimension getDoubleBufferMaximumSize() { - return null; // TODO - } // getDoubleBufferMaximumSize() - - /** - * setDoubleBufferMaximumSize - * @param size TODO - */ - public void setDoubleBufferMaximumSize(Dimension size) { - // TODO - } // setDoubleBufferMaximumSize() - - /** - * setDoubleBufferingEnabled - * @param buffer TODO - */ - public void setDoubleBufferingEnabled(boolean buffer) { - // TODO - } // setDoubleBufferingEnabled() - - /** - * isDoubleBufferingEnabled - * @returns boolean - */ - public boolean isDoubleBufferingEnabled() { - return false; // TODO - } // isDoubleBufferingEnabled() - - -} // RepaintManager +public class RepaintManager +{ + + /** + * <p>A helper class which is placed into the system event queue at + * various times in order to facilitate repainting and layout. There is + * typically only one of these objects active at any time. When the + * {@link RepaintManager} is told to queue a repaint, it checks to see if + * a {@link RepaintWorker} is "live" in the system event queue, and if + * not it inserts one using {@link SwingUtilities.invokeLater}.</p> + * + * <p>When the {@link RepaintWorker} comes to the head of the system + * event queue, its {@link RepaintWorker#run} method is executed by the + * swing paint thread, which revalidates all invalid components and + * repaints any damage in the swing scene.</p> + */ + + protected class RepaintWorker + implements Runnable + { + boolean live; + public RepaintWorker() + { + live = false; + } + public synchronized void setLive(boolean b) + { + live = b; + } + public synchronized boolean isLive() + { + return live; + } + public void run() + { + RepaintManager rm = RepaintManager.globalManager; + setLive(false); + rm.validateInvalidComponents(); + rm.paintDirtyRegions(); + } + } + + + /** + * A table storing the dirty regions of components. The keys of this + * table are components, the values are rectangles. Each component maps + * to exactly one rectangle. When more regions are marked as dirty on a + * component, they are union'ed with the existing rectangle. + * + * @see #addDirtyRegion + * @see #getDirtyRegion + * @see #isCompletelyDirty + * @see #markCompletelyClean + * @see #markCompletelyDirty + */ + Hashtable dirtyComponents; + + /** + * A single, shared instance of the helper class. Any methods which mark + * components as invalid or dirty eventually activate this instance. It + * is added to the event queue if it is not already active, otherwise + * reused. + * + * @see #addDirtyRegion + * @see #addInvalidComponent + */ + RepaintWorker repaintWorker; + + /** + * The set of components which need revalidation, in the "layout" sense. + * There is no additional information about "what kind of layout" they + * need (as there is with dirty regions), so it is just a vector rather + * than a table. + * + * @see #addInvalidComponent + * @see #removeInvalidComponent + * @see #validateInvalidComponents + */ + Vector invalidComponents; + + /** + * Whether or not double buffering is enabled on this repaint + * manager. This is merely a hint to clients; the RepaintManager will + * always return an offscreen buffer when one is requested. + * + * @see #getDoubleBufferingEnabled + * @see #setDoubleBufferingEnabled + */ + boolean doubleBufferingEnabled; + + /** + * The current offscreen buffer. This is reused for all requests for + * offscreen drawing buffers. It grows as necessary, up to {@link + * #doubleBufferMaximumSize}, but there is only one shared instance. + * + * @see #getOffscreenBuffer + * @see #doubleBufferMaximumSize + */ + Image doubleBuffer; + + /** + * The maximum width and height to allocate as a double buffer. Requests + * beyond this size are ignored. + * + * @see #paintDirtyRegions + * @see #getDoubleBufferMaximumSize + * @see #setDoubleBufferMaximumSize + */ + Dimension doubleBufferMaximumSize; + + + /** + * The global, shared RepaintManager instance. This is reused for all + * components in all windows. + * + * @see #currentManager + * @see #setCurrentManager + */ + private static RepaintManager globalManager; + + /** + * Create a new RepaintManager object. + */ + public RepaintManager() + { + dirtyComponents = new Hashtable(); + invalidComponents = new Vector(); + repaintWorker = new RepaintWorker(); + doubleBufferMaximumSize = new Dimension(2000,2000); + doubleBufferingEnabled = true; + } + + /** + * Get the value of the shared {@link #globalManager} instance, possibly + * returning a special manager associated with the specified + * component. The default implementaiton ignores the component parameter. + * + * @param component A component to look up the manager of + * + * @return The current repaint manager + * + * @see #setCurrentManager + */ + public static RepaintManager currentManager(Component component) + { + if (globalManager == null) + globalManager = new RepaintManager(); + return globalManager; + } + + /** + * Get the value of the shared {@link #globalManager} instance, possibly + * returning a special manager associated with the specified + * component. The default implementaiton ignores the component parameter. + * + * @param component A component to look up the manager of + * + * @return The current repaint manager + * + * @see #setCurrentManager + */ + public static RepaintManager currentManager(JComponent component) + { + return currentManager((Component)component); + } + + /** + * Set the value of the shared {@link #globalManager} instance. + * + * @param manager The new value of the shared instance + * + * @see #currentManager + */ + public static void setCurrentManager(RepaintManager manager) + { + globalManager = manager; + } + + /** + * Add a component to the {@link #invalidComponents} vector. If the + * {@link #repaintWorker} class is not active, insert it in the system + * event queue. + * + * @param component The component to add + * + * @see #removeInvalidComponent + */ + public synchronized void addInvalidComponent(JComponent component) + { + while ((component.getParent() != null) + && (component.getParent() instanceof JComponent) + && (component.isValidateRoot())) + component = (JComponent) component.getParent(); + + if (invalidComponents.contains(component)) + return; + + invalidComponents.add(component); + component.invalidate(); + + if (! repaintWorker.isLive()) + { + repaintWorker.setLive(true); + SwingUtilities.invokeLater(repaintWorker); + } + } + + /** + * Remove a component from the {@link #invalidComponents} vector. + * + * @param component The component to remove + * + * @see #addInvalidComponent + */ + public synchronized void removeInvalidComponent(JComponent component) + { + invalidComponents.removeElement(component); + } + + /** + * Add a region to the set of dirty regions for a specified component. + * This involves union'ing the new region with any existing dirty region + * associated with the component. If the {@link #repaintWorker} class + * is not active, insert it in the system event queue. + * + * @param component The component to add a dirty region for + * @param x The left x coordinate of the new dirty region + * @param y The top y coordinate of the new dirty region + * @param w The width of the new dirty region + * @param h The height of the new dirty region + * + * @see #addDirtyRegion + * @see #getDirtyRegion + * @see #isCompletelyDirty + * @see #markCompletelyClean + * @see #markCompletelyDirty + */ + public synchronized void addDirtyRegion(JComponent component, int x, int y, + int w, int h) + { + Rectangle r = new Rectangle(x, y, w, h); + if (dirtyComponents.containsKey(component)) + r = r.union((Rectangle)dirtyComponents.get(component)); + dirtyComponents.put(component, r); + if (! repaintWorker.isLive()) + { + repaintWorker.setLive(true); + SwingUtilities.invokeLater(repaintWorker); + } + } + + /** + * Get the dirty region associated with a component, or <code>null</code> + * if the component has no dirty region. + * + * @param component The component to get the dirty region of + * + * @return The dirty region of the component + * + * @see #dirtyComponents + * @see #addDirtyRegion + * @see #isCompletelyDirty + * @see #markCompletelyClean + * @see #markCompletelyDirty + */ + public Rectangle getDirtyRegion(JComponent component) + { + return (Rectangle) dirtyComponents.get(component); + } + + /** + * Mark a component as dirty over its entire bounds. + * + * @param component The component to mark as dirty + * + * @see #dirtyComponents + * @see #addDirtyRegion + * @see #getDirtyRegion + * @see #isCompletelyDirty + * @see #markCompletelyClean + */ + public void markCompletelyDirty(JComponent component) + { + Rectangle r = component.getBounds(); + addDirtyRegion(component, r.x, r.y, r.width, r.height); + } + + /** + * Remove all dirty regions for a specified component + * + * @param component The component to mark as clean + * + * @see #dirtyComponents + * @see #addDirtyRegion + * @see #getDirtyRegion + * @see #isCompletelyDirty + * @see #markCompletelyDirty + */ + public void markCompletelyClean(JComponent component) + { + dirtyComponents.remove(component); + } + + /** + * Return <code>true</code> if the specified component is completely + * contained within its dirty region, otherwise <code>false</code> + * + * @param component The component to check for complete dirtyness + * + * @return Whether the component is completely dirty + * + * @see #dirtyComponents + * @see #addDirtyRegion + * @see #getDirtyRegion + * @see #isCompletelyDirty + * @see #markCompletelyClean + */ + public boolean isCompletelyDirty(JComponent component) + { + Rectangle dirty = (Rectangle) dirtyComponents.get(component); + if (dirty == null) + return false; + Rectangle r = component.getBounds(); + if (r == null) + return true; + return dirty.contains(r); + } + + /** + * Validate all components which have been marked invalid in the {@link + * #invalidComponents} vector. + */ + public void validateInvalidComponents() + { + for (Enumeration e = invalidComponents.elements(); e.hasMoreElements(); ) + { + JComponent comp = (JComponent) e.nextElement(); + if (! (comp.isVisible() && comp.isShowing())) + continue; + comp.validate(); + } + invalidComponents.clear(); + } + + /** + * Repaint all regions of all components which have been marked dirty in + * the {@link #dirtyComponents} table. + */ + public void paintDirtyRegions() + { + // step 1: pull out roots and calculate spanning damage + + HashMap roots = new HashMap(); + for (Enumeration e = dirtyComponents.keys(); e.hasMoreElements(); ) + { + JComponent comp = (JComponent) e.nextElement(); + if (! (comp.isVisible() && comp.isShowing())) + continue; + Rectangle damaged = getDirtyRegion(comp); + if (damaged.width == 0 || damaged.height == 0) + continue; + JRootPane root = comp.getRootPane(); + Rectangle rootDamage = SwingUtilities.convertRectangle(comp, damaged, root); + if (! roots.containsKey(root)) + { + roots.put(root, rootDamage); + } + else + { + roots.put(root, ((Rectangle)roots.get(root)).union(rootDamage)); + } + } + dirtyComponents.clear(); + + // step 2: paint those roots + Iterator i = roots.iterator(AbstractMap.ENTRIES); + while(i.hasNext()) + { + AbstractMap.BasicMapEntry ent = (AbstractMap.BasicMapEntry) i.next(); + JRootPane root = (JRootPane) ent.getKey(); + Rectangle rect = (Rectangle) ent.getValue(); + root.paintImmediately(rect); + } + } + + /** + * Get an offscreen buffer for painting a component's image. This image + * may be smaller than the proposed dimensions, depending on the value of + * the {@link #doubleBufferMaximumSize} property. + * + * @param component The component to return an offscreen buffer for + * @param proposedWidth The proposed width of the offscreen buffer + * @param proposedHeight The proposed height of the offscreen buffer + * + * @return A shared offscreen buffer for painting + * + * @see #doubleBuffer + */ + public Image getOffscreenBuffer(Component component, int proposedWidth, + int proposedHeight) + { + if (doubleBuffer == null + || (((doubleBuffer.getWidth(null) < proposedWidth) + || (doubleBuffer.getHeight(null) < proposedHeight)) + && (proposedWidth < doubleBufferMaximumSize.width) + && (proposedHeight < doubleBufferMaximumSize.height))) + { + doubleBuffer = component.createImage(proposedWidth, proposedHeight); + } + return doubleBuffer; + } + + /** + * Get the value of the {@link #doubleBufferMaximumSize} property. + * + * @return The current value of the property + * + * @see #setDoubleBufferMaximumSize + */ + public Dimension getDoubleBufferMaximumSize() + { + return doubleBufferMaximumSize; + } + + /** + * Set the value of the {@link #doubleBufferMaximumSize} property. + * + * @param size The new value of the property + * + * @see #getDoubleBufferMaximumSize + */ + public void setDoubleBufferMaximumSize(Dimension size) + { + doubleBufferMaximumSize = size; + } + + /** + * Set the value of the {@link #doubleBufferingEnabled} property. + * + * @param buffer The new value of the property + * + * @see #getDoubleBufferingEnabled + */ + public void setDoubleBufferingEnabled(boolean buffer) + { + doubleBufferingEnabled = buffer; + } + + /** + * Get the value of the {@link #doubleBufferingEnabled} property. + * + * @return The current value of the property + * + * @see #setDoubleBufferingEnabled + */ + public boolean isDoubleBufferingEnabled() + { + return doubleBufferingEnabled; + } + + public String toString() + { + return "RepaintManager"; + } +} |