RepaintManager.java 26.5 KB
Newer Older
Tom Tromey committed
1
/* RepaintManager.java --
2
   Copyright (C) 2002, 2004, 2005  Free Software Foundation, Inc.
Tom Tromey committed
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

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;

41 42 43 44
import gnu.classpath.SystemProperties;
import gnu.java.awt.LowPriorityEvent;

import java.applet.Applet;
Tom Tromey committed
45 46
import java.awt.Component;
import java.awt.Dimension;
47
import java.awt.EventQueue;
48
import java.awt.Graphics;
Tom Tromey committed
49 50
import java.awt.Image;
import java.awt.Rectangle;
51
import java.awt.Toolkit;
52
import java.awt.Window;
53
import java.awt.event.InvocationEvent;
Tom Tromey committed
54
import java.awt.image.VolatileImage;
55
import java.util.ArrayList;
Tom Tromey committed
56
import java.util.HashMap;
57
import java.util.HashSet;
Tom Tromey committed
58
import java.util.Iterator;
59
import java.util.Set;
60
import java.util.WeakHashMap;
Tom Tromey committed
61

62 63
import javax.swing.text.JTextComponent;

Tom Tromey committed
64 65 66 67 68 69 70 71
/**
 * <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>
 *
72
 * <p>See <a
Tom Tromey committed
73 74
 * href="http://java.sun.com/products/jfc/tsc/articles/painting/index.html">this
 * document</a> for more details.</p>
75
 * document</a> for more details.</p>
Tom Tromey committed
76
 *
77
 * @author Roman Kennke (kennke@aicas.com)
Tom Tromey committed
78
 * @author Graydon Hoare (graydon@redhat.com)
79
 * @author Audrius Meskauskas (audriusa@bioinformatics.org)
Tom Tromey committed
80 81 82
 */
public class RepaintManager
{
83
  /**
84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
   * An InvocationEvent subclass that implements LowPriorityEvent. This is used
   * to defer the execution of RepaintManager requests as long as possible on
   * the event queue. This way we make sure that all available input is
   * processed before getting active with the RepaintManager. This allows
   * for better optimization (more validate and repaint requests can be
   * coalesced) and thus has a positive effect on performance for GUI
   * applications under heavy load.
   */
  private static class RepaintWorkerEvent
    extends InvocationEvent
    implements LowPriorityEvent
  {

    /**
     * Creates a new RepaintManager event.
     *
     * @param source the source
     * @param runnable the runnable to execute
     */
    public RepaintWorkerEvent(Object source, Runnable runnable,
                              Object notifier, boolean catchEx)
    {
      super(source, runnable, notifier, catchEx);
    }

    /**
     * An application that I met implements its own event dispatching and
     * calls dispatch() via reflection, and only checks declared methods,
     * that is, it expects this method to be in the event's class, not
     * in a superclass. So I put this in here... sigh.
     */
    public void dispatch()
    {
      super.dispatch();
    }
  }
  
  /**
122 123
   * The current repaint managers, indexed by their ThreadGroups.
   */
124
  static WeakHashMap currentRepaintManagers;
125 126 127 128 129 130

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

Tom Tromey committed
131 132 133 134 135 136
  /**
   * <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
Tom Tromey committed
137
   * not it inserts one using {@link SwingUtilities#invokeLater}.</p>
Tom Tromey committed
138 139 140 141 142 143
   *
   * <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>
   */
144
  private class RepaintWorker
Tom Tromey committed
145 146
    implements Runnable
  {
147

Tom Tromey committed
148
    boolean live;
149

Tom Tromey committed
150 151 152 153
    public RepaintWorker()
    {
      live = false;
    }
154

Tom Tromey committed
155 156 157 158
    public synchronized void setLive(boolean b) 
    {
      live = b;
    }
159

Tom Tromey committed
160 161 162 163
    public synchronized boolean isLive()
    {
      return live;
    }
164

Tom Tromey committed
165 166
    public void run()
    {
167 168 169 170 171 172 173 174 175 176 177 178
      try
        {
          ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
          RepaintManager rm =
            (RepaintManager) currentRepaintManagers.get(threadGroup);
          rm.validateInvalidComponents();
          rm.paintDirtyRegions();
        }
      finally
        {
          setLive(false);
        }
Tom Tromey committed
179
    }
180 181 182

  }

Tom Tromey committed
183 184 185 186 187 188
  /** 
   * 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.
   *
189 190 191
   * This is package private to avoid a synthetic accessor method in inner
   * class.
   *
Tom Tromey committed
192 193 194 195 196 197
   * @see #addDirtyRegion
   * @see #getDirtyRegion
   * @see #isCompletelyDirty
   * @see #markCompletelyClean
   * @see #markCompletelyDirty
   */
198
  private HashMap dirtyComponents;
199 200

  /**
201 202 203
   * The dirtyComponents which is used in paintDiryRegions to avoid unnecessary
   * locking.
   */
204
  private HashMap dirtyComponentsWork;
Tom Tromey committed
205 206 207 208 209 210 211 212 213 214

  /**
   * 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
   */
215
  private RepaintWorker repaintWorker;
Tom Tromey committed
216 217 218 219 220 221 222 223 224 225 226

  /** 
   * 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
   */
227
  private ArrayList invalidComponents;
Tom Tromey committed
228 229 230 231 232 233

  /** 
   * 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.
   * 
234
   * @see #isDoubleBufferingEnabled
Tom Tromey committed
235 236
   * @see #setDoubleBufferingEnabled
   */
237
  private boolean doubleBufferingEnabled;
Tom Tromey committed
238

239 240 241 242
  /**
   * The offscreen buffers. This map holds one offscreen buffer per
   * Window/Applet and releases them as soon as the Window/Applet gets garbage
   * collected.
Tom Tromey committed
243
   */
244 245 246
  private WeakHashMap offscreenBuffers;

  /**
Tom Tromey committed
247 248 249 250 251 252 253
   * The maximum width and height to allocate as a double buffer. Requests
   * beyond this size are ignored.
   *
   * @see #paintDirtyRegions
   * @see #getDoubleBufferMaximumSize
   * @see #setDoubleBufferMaximumSize
   */
254
  private Dimension doubleBufferMaximumSize;
Tom Tromey committed
255 256 257 258 259 260 261


  /**
   * Create a new RepaintManager object.
   */
  public RepaintManager()
  {
262
    dirtyComponents = new HashMap();
263
    dirtyComponentsWork = new HashMap();
264
    invalidComponents = new ArrayList();
Tom Tromey committed
265 266
    repaintWorker = new RepaintWorker();
    doubleBufferMaximumSize = new Dimension(2000,2000);
267 268 269
    doubleBufferingEnabled =
      SystemProperties.getProperty("gnu.swing.doublebuffering", "true")
                      .equals("true");
270
    offscreenBuffers = new WeakHashMap();
Tom Tromey committed
271 272 273
  }

  /**
274 275 276 277
   * 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.
Tom Tromey committed
278
   *
279
   * @param component a component to look up the manager of
Tom Tromey committed
280
   *
281 282
   * @return the current repaint manager for the calling thread's thread group
   *         and the specified component
Tom Tromey committed
283 284 285 286 287
   *
   * @see #setCurrentManager
   */
  public static RepaintManager currentManager(Component component)
  {
288
    if (currentRepaintManagers == null)
289
      currentRepaintManagers = new WeakHashMap();
290 291 292 293 294 295 296 297 298
    ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
    RepaintManager currentManager =
      (RepaintManager) currentRepaintManagers.get(threadGroup);
    if (currentManager == null)
      {
        currentManager = new RepaintManager();
        currentRepaintManagers.put(threadGroup, currentManager);
      }
    return currentManager;
Tom Tromey committed
299 300 301
  }

  /**
302 303 304 305 306 307 308
   * 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)}.
Tom Tromey committed
309
   *
310
   * @param component a component to look up the manager of
Tom Tromey committed
311
   *
312 313
   * @return the current repaint manager for the calling thread's thread group
   *         and the specified component
Tom Tromey committed
314 315 316 317 318 319 320 321 322
   *
   * @see #setCurrentManager
   */
  public static RepaintManager currentManager(JComponent component)
  {
    return currentManager((Component)component);
  }

  /**
323
   * Sets the repaint manager for the calling thread's thread group.
Tom Tromey committed
324
   *
325 326
   * @param manager the repaint manager to set for the current thread's thread
   *        group
Tom Tromey committed
327
   *
328
   * @see #currentManager(Component)
Tom Tromey committed
329 330 331
   */
  public static void setCurrentManager(RepaintManager manager)
  {
332
    if (currentRepaintManagers == null)
333
      currentRepaintManagers = new WeakHashMap();
334 335 336

    ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
    currentRepaintManagers.put(threadGroup, manager);
Tom Tromey committed
337 338 339 340 341 342 343 344 345 346 347
  }

  /**
   * 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
   */
348
  public void addInvalidComponent(JComponent component)
Tom Tromey committed
349
  {
350 351 352 353 354 355 356 357 358 359 360 361 362 363
    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;
          }
Tom Tromey committed
364

365 366
        c = c.getParent();
      }
Tom Tromey committed
367

368 369
    // If we didn't find a validate root, then we don't validate.
    if (validateRoot == null)
Tom Tromey committed
370 371
      return;

372 373 374
    // Make sure the validate root and all of it's ancestors are visible.
    c = validateRoot;
    while (c != null)
375
      {
376 377 378
        if (! c.isVisible() || ! c.isDisplayable())
          return;
        c = c.getParent();
379 380
      }

381 382 383 384 385 386 387 388
    if (invalidComponents.contains(validateRoot))
      return;

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

Tom Tromey committed
389 390 391
    if (! repaintWorker.isLive())
      {
        repaintWorker.setLive(true);
392
        invokeLater(repaintWorker);
Tom Tromey committed
393 394 395 396 397 398 399 400 401 402
      }
  }

  /**
   * Remove a component from the {@link #invalidComponents} vector.
   *
   * @param component The component to remove
   *
   * @see #addInvalidComponent
   */
403
  public void removeInvalidComponent(JComponent component)
Tom Tromey committed
404
  {
405 406 407 408
    synchronized (invalidComponents)
      {
        invalidComponents.remove(component);
      }
Tom Tromey committed
409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
  }

  /**
   * 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
   */
429 430
  public void addDirtyRegion(JComponent component, int x, int y,
                             int w, int h)
Tom Tromey committed
431
  {
432
    if (w <= 0 || h <= 0 || !component.isShowing())
Tom Tromey committed
433
      return;
434 435 436 437
    component.computeVisibleRect(rectCache);
    SwingUtilities.computeIntersection(x, y, w, h, rectCache);

    if (! rectCache.isEmpty())
Tom Tromey committed
438
      {
439
        synchronized (dirtyComponents)
440
          {
441 442 443 444 445 446 447 448
            Rectangle dirtyRect = (Rectangle)dirtyComponents.get(component);
            if (dirtyRect != null)
              {
                SwingUtilities.computeUnion(rectCache.x, rectCache.y,
                                            rectCache.width, rectCache.height,
                                            dirtyRect);
              }
            else
449 450 451 452 453 454 455 456
              {
                dirtyComponents.put(component, rectCache.getBounds());
              }
          }

        if (! repaintWorker.isLive())
          {
            repaintWorker.setLive(true);
457
            invokeLater(repaintWorker);
458
          }
Tom Tromey committed
459 460
      }
  }
461 462

  /**
Tom Tromey committed
463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
   * 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)
  {
478 479 480 481
    Rectangle dirty = (Rectangle) dirtyComponents.get(component);
    if (dirty == null)
      dirty = new Rectangle();
    return dirty;
Tom Tromey committed
482 483 484 485 486 487 488 489 490 491 492 493 494 495 496
  }
  
  /**
   * 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)
  {
497
    addDirtyRegion(component, 0, 0, Integer.MAX_VALUE, Integer.MAX_VALUE);
Tom Tromey committed
498 499 500 501 502 503 504 505 506 507 508 509 510 511 512
  }

  /**
   * 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)
  {
513
    synchronized (dirtyComponents)
514 515 516
      {
        dirtyComponents.remove(component);
      }
Tom Tromey committed
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
  }

  /**
   * 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)
  {
535 536 537 538 539
    boolean dirty = false;
    Rectangle r = getDirtyRegion(component);
    if(r.width == Integer.MAX_VALUE && r.height == Integer.MAX_VALUE)
      dirty = true;
    return dirty;
Tom Tromey committed
540 541 542 543 544 545 546 547
  }

  /**
   * Validate all components which have been marked invalid in the {@link
   * #invalidComponents} vector.
   */
  public void validateInvalidComponents()
  {
548 549 550 551
    // 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)
Tom Tromey committed
552
      {
553 554 555 556 557 558
        Component comp;
        synchronized (invalidComponents)
          {
            comp = (Component) invalidComponents.remove(0);
          }
        // Validate the validate component.
Tom Tromey committed
559 560 561 562 563 564 565
        if (! (comp.isVisible() && comp.isShowing()))
          continue;
        comp.validate();
      }
  }

  /**
566 567
   * Repaint all regions of all components which have been marked dirty in the
   * {@link #dirtyComponents} table.
Tom Tromey committed
568
   */
569
  public void paintDirtyRegions()
Tom Tromey committed
570
  {
571
    // Short circuit if there is nothing to paint.
572 573 574
    if (dirtyComponents.size() == 0)
      return;

575
    // Swap dirtyRegions with dirtyRegionsWork to avoid locking.
576
    synchronized (dirtyComponents)
Tom Tromey committed
577
      {
578 579 580
        HashMap swap = dirtyComponents;
        dirtyComponents = dirtyComponentsWork;
        dirtyComponentsWork = swap;
Tom Tromey committed
581
      }
582

583 584 585 586 587 588 589 590
    // 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);
      }
591

592
    for (Iterator i = repaintRoots.iterator(); i.hasNext();)
593 594 595 596 597 598 599
      {
        JComponent comp = (JComponent) i.next();
        Rectangle damaged = (Rectangle) dirtyComponentsWork.remove(comp);
        if (damaged == null || damaged.isEmpty())
          continue;
        comp.paintImmediately(damaged);
      }
600
    dirtyComponentsWork.clear();
Tom Tromey committed
601
  }
602

603 604
  /**
   * Compiles a list of components that really get repainted. This is called
605
   * once for each component in the dirtyRegions HashMap, each time with
606 607 608 609 610 611 612 613 614 615 616 617 618 619
   * 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;

620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
    // This will contain the dirty region in the root coordinate system,
    // possibly clipped by ancestor's bounds.
    Rectangle originalDirtyRect = (Rectangle) dirtyRegions.get(dirty); 
    rectCache.setBounds(originalDirtyRect);

    // The bounds of the current component.
    int x = dirty.getX();
    int y = dirty.getY();
    int w = dirty.getWidth();
    int h = dirty.getHeight();

    // Do nothing if dirty region is clipped away by the component's bounds.
    rectCache = SwingUtilities.computeIntersection(0, 0, w, h, rectCache);
    if (rectCache.isEmpty())
      return;

    // The cumulated offsets. 
    int dx = 0;
    int dy = 0;
    // The actual offset for the found root.
    int rootDx = 0;
    int rootDy = 0;

643 644 645 646 647 648 649 650 651
    // 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;
652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
        // Update the offset.
        dx += x;
        dy += y;
        rectCache.x += x;
        rectCache.y += y;
        
        x = current.getX();
        y = current.getY();
        w = current.getWidth();
        h = current.getHeight();
        rectCache = SwingUtilities.computeIntersection(0, 0, w, h, rectCache);

        // Don't paint if the dirty regions is clipped away by any of
        // its ancestors.
        if (rectCache.isEmpty())
          return;

669 670 671 672
        // We can skip to the next up when this parent is not dirty.
        if (dirtyRegions.containsKey(parent))
          {
            root = current;
673 674
            rootDx = dx;
            rootDy = dy;
675 676 677 678 679 680 681
          }
      }

    // Merge the rectangles of the root and the requested component if
    // the are different.
    if (root != dirty)
      {
682 683 684 685 686
        rectCache.x += rootDx - dx;
        rectCache.y += rootDy - dy;
        Rectangle dirtyRect = (Rectangle) dirtyRegions.get(root);
        SwingUtilities.computeUnion(rectCache.x, rectCache.y, rectCache.width,
                                    rectCache.height, dirtyRect);
687 688 689
      }

    // Adds the root to the roots set.
690 691
    if (! roots.contains(root))
      roots.add(root);
692
  }
Tom Tromey committed
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707

  /**
   * 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)
  {
708
    Component root = SwingUtilities.getWindowAncestor(component);
709 710 711 712 713 714 715 716 717
    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);
718
        buffer = component.createImage(width, height);
719 720 721 722
        offscreenBuffers.put(root, buffer);
      }
    return buffer;
  }
723

724
  /**
725 726
   * Blits the back buffer of the specified root component to the screen.
   * This is package private because it must get called by JComponent.
727
   *
728
   * @param comp the component to be painted
729 730 731 732
   * @param x the area to paint on screen, in comp coordinates
   * @param y the area to paint on screen, in comp coordinates
   * @param w the area to paint on screen, in comp coordinates
   * @param h the area to paint on screen, in comp coordinates
733
   */
734
  void commitBuffer(Component comp, int x, int y, int w, int h)
735
  {
736 737 738
    Component root = comp;
    while (root != null
	   && ! (root instanceof Window || root instanceof Applet))
739
      {
740 741 742
	x += root.getX();
	y += root.getY();
	root = root.getParent();
743 744
      }

745
    if (root != null)
Tom Tromey committed
746
      {
747 748 749
        Graphics g = root.getGraphics();
        Image buffer = (Image) offscreenBuffers.get(root);
        if (buffer != null)
750
          {
751 752 753 754
            // Make sure we have a sane clip at this point.
            g.clipRect(x, y, w, h);
            g.drawImage(buffer, 0, 0, root);
            g.dispose();
755
          }
Tom Tromey committed
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771
      }
  }

  /**
   * 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
   *
Tom Tromey committed
772
   * @see VolatileImage
Tom Tromey committed
773 774 775 776
   */
  public Image getVolatileOffscreenBuffer(Component comp, int proposedWidth,
                                          int proposedHeight)
  {
777
    Component root = SwingUtilities.getWindowAncestor(comp);
778 779 780 781 782 783 784 785 786 787 788 789 790 791 792
    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;
Tom Tromey committed
793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824
  }
  

  /**
   * 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
   *
Tom Tromey committed
825
   * @see #isDoubleBufferingEnabled
Tom Tromey committed
826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847
   */
  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";
  }
848 849 850 851 852 853 854 855 856 857 858 859 860 861

  /**
   * Sends an RepaintManagerEvent to the event queue with the specified
   * runnable. This is similar to SwingUtilities.invokeLater(), only that the
   * event is a low priority event in order to defer the execution a little
   * more.
   */
  private void invokeLater(Runnable runnable)
  {
    Toolkit tk = Toolkit.getDefaultToolkit();
    EventQueue evQueue = tk.getSystemEventQueue();
    InvocationEvent ev = new RepaintWorkerEvent(evQueue, runnable, null, false);
    evQueue.postEvent(ev);
  }
Tom Tromey committed
862
}