/* RepaintManager.java --
   Copyright (C) 2002, 2004, 2005  Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath 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 for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
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.Graphics;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Window;
import java.awt.image.VolatileImage;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;

/**
 * <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>See <a
 * href="http://java.sun.com/products/jfc/tsc/articles/painting/index.html">this
 * document</a> for more details.</p>
 *
 * @author Roman Kennke (kennke@aicas.com)
 * @author Graydon Hoare (graydon@redhat.com)
 * @author Audrius Meskauskas (audriusa@bioinformatics.org)
 */
public class RepaintManager
{
  /**
   * The current repaint managers, indexed by their ThreadGroups.
   */
  static WeakHashMap currentRepaintManagers;

  /**
   * A rectangle object to be reused in damaged regions calculation.
   */
  private static Rectangle rectCache = new Rectangle();

  /**
   * <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>
   */
  private 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()
    {
      try
        {
          ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
          RepaintManager rm =
            (RepaintManager) currentRepaintManagers.get(threadGroup);
          rm.validateInvalidComponents();
          rm.paintDirtyRegions();
        }
      finally
        {
          setLive(false);
        }
    }

  }

  /** 
   * 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.
   *
   * This is package private to avoid a synthetic accessor method in inner
   * class.
   *
   * @see #addDirtyRegion
   * @see #getDirtyRegion
   * @see #isCompletelyDirty
   * @see #markCompletelyClean
   * @see #markCompletelyDirty
   */
  private HashMap dirtyComponents;

  /**
   * The dirtyComponents which is used in paintDiryRegions to avoid unnecessary
   * locking.
   */
  private HashMap dirtyComponentsWork;

  /**
   * 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
   */
  private 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
   */
  private ArrayList 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 #isDoubleBufferingEnabled
   * @see #setDoubleBufferingEnabled
   */
  private boolean doubleBufferingEnabled;

  /**
   * The offscreen buffers. This map holds one offscreen buffer per
   * Window/Applet and releases them as soon as the Window/Applet gets garbage
   * collected.
   */
  private WeakHashMap offscreenBuffers;

  /**
   * Indicates if the RepaintManager is currently repainting an area.
   */
  private boolean repaintUnderway;

  /**
   * This holds buffer commit requests when the RepaintManager is working.
   * This maps Component objects (the top level components) to Rectangle
   * objects (the area of the corresponding buffer that must be blitted on
   * the component).
   */
  private HashMap commitRequests;

  /**
   * The maximum width and height to allocate as a double buffer. Requests
   * beyond this size are ignored.
   *
   * @see #paintDirtyRegions
   * @see #getDoubleBufferMaximumSize
   * @see #setDoubleBufferMaximumSize
   */
  private Dimension doubleBufferMaximumSize;


  /**
   * Create a new RepaintManager object.
   */
  public RepaintManager()
  {
    dirtyComponents = new HashMap();
    dirtyComponentsWork = new HashMap();
    invalidComponents = new ArrayList();
    repaintWorker = new RepaintWorker();
    doubleBufferMaximumSize = new Dimension(2000,2000);
    doubleBufferingEnabled = true;
    offscreenBuffers = new WeakHashMap();
    repaintUnderway = false;
    commitRequests = new HashMap();
  }

  /**
   * Returns the <code>RepaintManager</code> for the current thread's
   * thread group. The default implementation ignores the
   * <code>component</code> parameter and returns the same repaint manager
   * for all components.
   *
   * @param component a component to look up the manager of
   *
   * @return the current repaint manager for the calling thread's thread group
   *         and the specified component
   *
   * @see #setCurrentManager
   */
  public static RepaintManager currentManager(Component component)
  {
    if (currentRepaintManagers == null)
      currentRepaintManagers = new WeakHashMap();
    ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
    RepaintManager currentManager =
      (RepaintManager) currentRepaintManagers.get(threadGroup);
    if (currentManager == null)
      {
        currentManager = new RepaintManager();
        currentRepaintManagers.put(threadGroup, currentManager);
      }
    return currentManager;
  }

  /**
   * Returns the <code>RepaintManager</code> for the current thread's
   * thread group. The default implementation ignores the
   * <code>component</code> parameter and returns the same repaint manager
   * for all components.
   *
   * This method is only here for backwards compatibility with older versions
   * of Swing and simply forwards to {@link #currentManager(Component)}.
   *
   * @param component a component to look up the manager of
   *
   * @return the current repaint manager for the calling thread's thread group
   *         and the specified component
   *
   * @see #setCurrentManager
   */
  public static RepaintManager currentManager(JComponent component)
  {
    return currentManager((Component)component);
  }

  /**
   * Sets the repaint manager for the calling thread's thread group.
   *
   * @param manager the repaint manager to set for the current thread's thread
   *        group
   *
   * @see #currentManager(Component)
   */
  public static void setCurrentManager(RepaintManager manager)
  {
    if (currentRepaintManagers == null)
      currentRepaintManagers = new WeakHashMap();

    ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
    currentRepaintManagers.put(threadGroup, 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 void addInvalidComponent(JComponent component)
  {
    Component validateRoot = null;
    Component c = component;
    while (c != null)
      {
        // Special cases we don't bother validating are when the invalidated
        // component (or any of it's ancestors) is inside a CellRendererPane
        // or if it doesn't have a peer yet (== not displayable).
        if (c instanceof CellRendererPane || ! c.isDisplayable())
          return;
        if (c instanceof JComponent && ((JComponent) c).isValidateRoot())
          {
            validateRoot = c;
            break;
          }

        c = c.getParent();
      }

    // If we didn't find a validate root, then we don't validate.
    if (validateRoot == null)
      return;

    // Make sure the validate root and all of it's ancestors are visible.
    c = validateRoot;
    while (c != null)
      {
        if (! c.isVisible() || ! c.isDisplayable())
          return;
        c = c.getParent();
      }

    if (invalidComponents.contains(validateRoot))
      return;

    //synchronized (invalidComponents)
    //  {
        invalidComponents.add(validateRoot);
    //  }

    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 void removeInvalidComponent(JComponent component)
  {
    synchronized (invalidComponents)
      {
        invalidComponents.remove(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 void addDirtyRegion(JComponent component, int x, int y,
                             int w, int h)
  {
    if (w <= 0 || h <= 0 || !component.isShowing())
      return;

    Component parent = component.getParent();
    
    component.computeVisibleRect(rectCache);
    SwingUtilities.computeIntersection(x, y, w, h, rectCache);

    if (! rectCache.isEmpty())
      {
        if (dirtyComponents.containsKey(component))
          {
            SwingUtilities.computeUnion(rectCache.x, rectCache.y,
                                        rectCache.width, rectCache.height,
                                   (Rectangle) dirtyComponents.get(component));
          }
        else
          {
            synchronized (dirtyComponents)
              {
                dirtyComponents.put(component, rectCache.getBounds());
              }
          }

        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)
  {
    Rectangle dirty = (Rectangle) dirtyComponents.get(component);
    if (dirty == null)
      dirty = new Rectangle();
    return dirty;
  }
  
  /**
   * 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)
  {
    addDirtyRegion(component, 0, 0, Integer.MAX_VALUE, Integer.MAX_VALUE);
  }

  /**
   * 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)
  {
    synchronized (dirtyComponents)
      {
        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)
  {
    boolean dirty = false;
    Rectangle r = getDirtyRegion(component);
    if(r.width == Integer.MAX_VALUE && r.height == Integer.MAX_VALUE)
      dirty = true;
    return dirty;
  }

  /**
   * Validate all components which have been marked invalid in the {@link
   * #invalidComponents} vector.
   */
  public void validateInvalidComponents()
  {
    // We don't use an iterator here because that would fail when there are
    // components invalidated during the validation of others, which happens
    // quite frequently. Instead we synchronize the access a little more.
    while (invalidComponents.size() > 0)
      {
        Component comp;
        synchronized (invalidComponents)
          {
            comp = (Component) invalidComponents.remove(0);
          }
        // Validate the validate component.
        if (! (comp.isVisible() && comp.isShowing()))
          continue;
        comp.validate();
      }
  }

  /**
   * Repaint all regions of all components which have been marked dirty in the
   * {@link #dirtyComponents} table.
   */
  public void paintDirtyRegions()
  {
    // Short cicuit if there is nothing to paint.
    if (dirtyComponents.size() == 0)
      return;

    // Swap dirtyRegions with dirtyRegionsWork to avoid locking.
    synchronized (dirtyComponents)
      {
        HashMap swap = dirtyComponents;
        dirtyComponents = dirtyComponentsWork;
        dirtyComponentsWork = swap;
      }

    // Compile a set of repaint roots.
    HashSet repaintRoots = new HashSet();
    Set components = dirtyComponentsWork.keySet();
    for (Iterator i = components.iterator(); i.hasNext();)
      {
        JComponent dirty = (JComponent) i.next();
        compileRepaintRoots(dirtyComponentsWork, dirty, repaintRoots);
      }

    repaintUnderway = true;
    for (Iterator i = repaintRoots.iterator(); i.hasNext();)
      {
        JComponent comp = (JComponent) i.next();
        Rectangle damaged = (Rectangle) dirtyComponentsWork.remove(comp);
        if (damaged == null || damaged.isEmpty())
          continue;
        comp.paintImmediately(damaged);
      }
    dirtyComponentsWork.clear();
    repaintUnderway = false;
    commitRemainingBuffers();
  }
  
  /**
   * Compiles a list of components that really get repainted. This is called
   * once for each component in the dirtyComponents HashMap, each time with
   * another <code>dirty</code> parameter. This searches up the component
   * hierarchy of <code>dirty</code> to find the highest parent that is also
   * marked dirty and merges the dirty regions.
   *
   * @param dirtyRegions the dirty regions 
   * @param dirty the component for which to find the repaint root
   * @param roots the list to which new repaint roots get appended
   */
  private void compileRepaintRoots(HashMap dirtyRegions, JComponent dirty,
                                   HashSet roots)
  {
    Component current = dirty;
    Component root = dirty;

    // Search the highest component that is also marked dirty.
    Component parent;
    while (true)
      {
        parent = current.getParent();
        if (parent == null || !(parent instanceof JComponent))
          break;

        current = parent;
        // We can skip to the next up when this parent is not dirty.
        if (dirtyRegions.containsKey(parent))
          {
            root = current;
          }
      }

    // Merge the rectangles of the root and the requested component if
    // the are different.
    if (root != dirty)
      {
        Rectangle dirtyRect = (Rectangle) dirtyRegions.get(dirty);
        dirtyRect = SwingUtilities.convertRectangle(dirty, dirtyRect, root);
        Rectangle rootRect = (Rectangle) dirtyRegions.get(root);
        SwingUtilities.computeUnion(dirtyRect.x, dirtyRect.y, dirtyRect.width,
                                    dirtyRect.height, rootRect);
      }

    // Adds the root to the roots set.
    roots.add(root);
  }

  /**
   * 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
   */
  public Image getOffscreenBuffer(Component component, int proposedWidth,
                                  int proposedHeight)
  {
    Component root = SwingUtilities.getWindowAncestor(component);
    Image buffer = (Image) offscreenBuffers.get(root);
    if (buffer == null 
        || buffer.getWidth(null) < proposedWidth 
        || buffer.getHeight(null) < proposedHeight)
      {
        int width = Math.max(proposedWidth, root.getWidth());
        width = Math.min(doubleBufferMaximumSize.width, width);
        int height = Math.max(proposedHeight, root.getHeight());
        height = Math.min(doubleBufferMaximumSize.height, height);
        buffer = root.createImage(width, height);
        offscreenBuffers.put(root, buffer);
      }
    return buffer;
  }

  /**
   * Blits the back buffer of the specified root component to the screen. If
   * the RepaintManager is currently working on a paint request, the commit
   * requests are queued up and committed at once when the paint request is
   * done (by {@link #commitRemainingBuffers}). This is package private because
   * it must get called by JComponent.
   *
   * @param comp the component to be painted
   * @param area the area to paint on screen, in comp coordinates
   */
  void commitBuffer(Component comp, Rectangle area)
  {
    // Determine the component that we finally paint the buffer upon.
    // We need to paint on the nearest heavyweight component, so that Swing
    // hierarchies inside (non-window) heavyweights get painted correctly.
    // Otherwise we would end up blitting the backbuffer behind the heavyweight
    // which is wrong.
    Component root = getHeavyweightParent(comp);
    // FIXME: Optimize this.
    Rectangle rootRect = SwingUtilities.convertRectangle(comp, area, root);

    // We synchronize on dirtyComponents here because that is what
    // paintDirtyRegions also synchronizes on while painting.
    synchronized (dirtyComponents)
      {
        // If the RepaintManager is not currently painting, then directly
        // blit the requested buffer on the screen.
        if (true || ! repaintUnderway)
          {
            blitBuffer(root, rootRect);
          }

        // Otherwise queue this request up, until all the RepaintManager work
        // is done.
        else
          {
            if (commitRequests.containsKey(root))
              SwingUtilities.computeUnion(rootRect.x, rootRect.y,
                                          rootRect.width, rootRect.height,
                                         (Rectangle) commitRequests.get(root));
            else
              commitRequests.put(root, rootRect);
          }
      }
  }

  /**
   * Copies the buffer to the screen. Note that the root component here is
   * not necessarily the component with which the offscreen buffer is
   * associated. The offscreen buffers are always allocated for the toplevel
   * windows. However, painted is performed on lower-level heavyweight
   * components too, if they contain Swing components.
   *
   * @param root the heavyweight component to blit upon
   * @param rootRect the rectangle in the root component's coordinate space
   */
  private void blitBuffer(Component root, Rectangle rootRect)
  {
    if (! root.isShowing())
      return;

    // Find the Window from which we use the backbuffer.
    Component bufferRoot = root;
    Rectangle bufferRect = rootRect.getBounds();
    if (!(bufferRoot instanceof Window))
      {
        bufferRoot = SwingUtilities.getWindowAncestor(bufferRoot);
        SwingUtilities.convertRectangleToAncestor(root, rootRect, bufferRoot);
      }

    Graphics g = root.getGraphics();
    Image buffer = (Image) offscreenBuffers.get(bufferRoot);

    // Make sure we have a sane clip at this point.
    g.clipRect(rootRect.x, rootRect.y, rootRect.width, rootRect.height);
    g.drawImage(buffer, rootRect.x - bufferRect.x, rootRect.y - bufferRect.y,
                root);
    g.dispose();

  }

  /**
   * Finds and returns the nearest heavyweight parent for the specified
   * component. If the component isn't contained inside a heavyweight parent,
   * this returns null.
   *
   * @param comp the component
   *
   * @return the nearest heavyweight parent for the specified component or
   *         null if the component has no heavyweight ancestor
   */
  private Component getHeavyweightParent(Component comp)
  {
    while (comp != null && comp.isLightweight())
      comp = comp.getParent();
    return comp;
  }

  /**
   * Commits the queued up back buffers to screen all at once.
   */
  private void commitRemainingBuffers()
  {
    // We synchronize on dirtyComponents here because that is what
    // paintDirtyRegions also synchronizes on while painting.
    synchronized (dirtyComponents)
      {
        Set entrySet = commitRequests.entrySet();
        Iterator i = entrySet.iterator();
        while (i.hasNext())
          {
            Map.Entry entry = (Map.Entry) i.next();
            Component root = (Component) entry.getKey();
            Rectangle area = (Rectangle) entry.getValue();
            blitBuffer(root, area);
            i.remove();
          }
      }
  }

  /**
   * Creates and returns a volatile offscreen buffer for the specified
   * component that can be used as a double buffer. The returned image
   * is a {@link VolatileImage}. Its size will be <code>(proposedWidth,
   * proposedHeight)</code> except when the maximum double buffer size
   * has been set in this RepaintManager.
   *
   * @param comp the Component for which to create a volatile buffer
   * @param proposedWidth the proposed width of the buffer
   * @param proposedHeight the proposed height of the buffer
   *
   * @since 1.4
   *
   * @see VolatileImage
   */
  public Image getVolatileOffscreenBuffer(Component comp, int proposedWidth,
                                          int proposedHeight)
  {
    Component root = SwingUtilities.getWindowAncestor(comp);
    Image buffer = (Image) offscreenBuffers.get(root);
    if (buffer == null 
        || buffer.getWidth(null) < proposedWidth 
        || buffer.getHeight(null) < proposedHeight
        || !(buffer instanceof VolatileImage))
      {
        int width = Math.max(proposedWidth, root.getWidth());
        width = Math.min(doubleBufferMaximumSize.width, width);
        int height = Math.max(proposedHeight, root.getHeight());
        height = Math.min(doubleBufferMaximumSize.height, height);
        buffer = root.createVolatileImage(width, height);
        if (buffer != null)
          offscreenBuffers.put(root, buffer);
      }
    return buffer;
  }
  

  /**
   * 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 #isDoubleBufferingEnabled
   */
  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";
  }
}