1 /*
   2  * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 
  27 package sun.lwawt;
  28 
  29 import java.awt.*;
  30 
  31 import java.awt.dnd.DropTarget;
  32 import java.awt.dnd.peer.DropTargetPeer;
  33 import java.awt.event.*;
  34 
  35 import java.awt.image.ColorModel;
  36 import java.awt.image.ImageObserver;
  37 import java.awt.image.ImageProducer;
  38 import java.awt.image.VolatileImage;
  39 
  40 import java.awt.peer.ComponentPeer;
  41 import java.awt.peer.ContainerPeer;
  42 
  43 import java.util.concurrent.atomic.AtomicBoolean;
  44 import java.lang.reflect.Field;
  45 import java.security.AccessController;
  46 import java.security.PrivilegedAction;
  47 
  48 import sun.awt.*;
  49 
  50 import sun.awt.event.IgnorePaintEvent;
  51 
  52 import sun.awt.image.SunVolatileImage;
  53 import sun.awt.image.ToolkitImage;
  54 
  55 import sun.java2d.SunGraphics2D;
  56 import sun.java2d.opengl.OGLRenderQueue;
  57 import sun.java2d.pipe.Region;
  58 
  59 import sun.util.logging.PlatformLogger;
  60 
  61 import javax.swing.JComponent;
  62 import javax.swing.SwingUtilities;
  63 import javax.swing.RepaintManager;
  64 
  65 import sun.lwawt.macosx.CDropTarget;
  66 
  67 import com.sun.java.swing.SwingUtilities3;
  68 
  69 public abstract class LWComponentPeer<T extends Component, D extends JComponent>
  70     implements ComponentPeer, DropTargetPeer
  71 {
  72     private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.lwawt.focus.LWComponentPeer");
  73 
  74     // State lock is to be used for modifications to this
  75     // peer's fields (e.g. bounds, background, font, etc.)
  76     // It should be the last lock in the lock chain
  77     private final Object stateLock =
  78             new StringBuilder("LWComponentPeer.stateLock");
  79 
  80     // The lock to operate with the peers hierarchy. AWT tree
  81     // lock is not used as there are many peers related ops
  82     // to be done on the toolkit thread, and we don't want to
  83     // depend on a public lock on this thread
  84     private final static Object peerTreeLock =
  85             new StringBuilder("LWComponentPeer.peerTreeLock");
  86 
  87     /**
  88      * A custom tree-lock used for the hierarchy of the delegate Swing
  89      * components.
  90      * The lock synchronizes access to the delegate
  91      * internal state. Think of it as a 'virtual EDT'.
  92      */
  93 //    private final Object delegateTreeLock =
  94 //        new StringBuilder("LWComponentPeer.delegateTreeLock");
  95 
  96     private T target;
  97 
  98     // Container peer. It may not be the peer of the target's direct
  99     // parent, for example, in the case of hw/lw mixing. However,
 100     // let's skip this scenario for the time being. We also assume
 101     // the container peer is not null, which might also be false if
 102     // addNotify() is called for a component outside of the hierarchy.
 103     // The exception is LWWindowPeers: their parents are always null
 104     private LWContainerPeer containerPeer;
 105 
 106     // Handy reference to the top-level window peer. Window peer is
 107     // borrowed from the containerPeer in constructor, and should also
 108     // be updated when the component is reparented to another container
 109     private LWWindowPeer windowPeer;
 110 
 111     private AtomicBoolean disposed = new AtomicBoolean(false);
 112 
 113     // Bounds are relative to parent peer
 114     private Rectangle bounds = new Rectangle();
 115     private Region region;
 116 
 117     // Component state. Should be accessed under the state lock
 118     private boolean visible = false;
 119     private boolean enabled = true;
 120 
 121     private Color background;
 122     private Color foreground;
 123     private Font font;
 124 
 125     // Paint area to coalesce all the paint events and store
 126     // the target dirty area
 127     private RepaintArea targetPaintArea;
 128 
 129     //   private volatile boolean paintPending;
 130     private volatile boolean isLayouting;
 131 
 132     private D delegate = null;
 133     private Container delegateContainer;
 134     private Component delegateDropTarget;
 135     private final Object dropTargetLock = new Object();
 136 
 137     private int fNumDropTargets = 0;
 138     private CDropTarget fDropTarget = null;
 139 
 140     private PlatformComponent platformComponent;
 141 
 142     private final class DelegateContainer extends Container {
 143         {
 144             enableEvents(0xFFFFFFFF);
 145         }
 146 
 147         DelegateContainer() {
 148             super();
 149         }
 150 
 151         @Override
 152         public boolean isLightweight() {
 153             return false;
 154         }
 155 
 156         @Override
 157         public Point getLocation() {
 158             return getLocationOnScreen();
 159         }
 160 
 161         @Override
 162         public Point getLocationOnScreen() {
 163             return LWComponentPeer.this.getLocationOnScreen();
 164         }
 165 
 166         @Override
 167         public int getX() {
 168             return getLocation().x;
 169         }
 170 
 171         @Override
 172         public int getY() {
 173             return getLocation().y;
 174         }
 175     }
 176 
 177     public LWComponentPeer(T target, PlatformComponent platformComponent) {
 178         this.target = target;
 179         this.platformComponent = platformComponent;
 180 
 181         initializeContainerPeer();
 182         // Container peer is always null for LWWindowPeers, so
 183         // windowPeer is always null for them as well. On the other
 184         // hand, LWWindowPeer shouldn't use windowPeer at all
 185         if (containerPeer != null) {
 186             windowPeer = containerPeer.getWindowPeerOrSelf();
 187         }
 188         // don't bother about z-order here as updateZOrder()
 189         // will be called from addNotify() later anyway
 190         if (containerPeer != null) {
 191             containerPeer.addChildPeer(this);
 192         }
 193 
 194         // the delegate must be created after the target is set
 195         AWTEventListener toolkitListener = null;
 196         synchronized (Toolkit.getDefaultToolkit()) {
 197             try {
 198                 toolkitListener = getToolkitAWTEventListener();
 199                 setToolkitAWTEventListener(null);
 200 
 201                 synchronized (getDelegateLock()) {
 202                     delegate = createDelegate();
 203                     if (delegate != null) {
 204                         delegateContainer = new DelegateContainer();
 205                         delegateContainer.add(delegate);
 206                         delegateContainer.addNotify();
 207                         delegate.addNotify();
 208                     } else {
 209                         return;
 210                     }
 211                 }
 212 
 213             } finally {
 214                 setToolkitAWTEventListener(toolkitListener);
 215             }
 216 
 217             // todo swing: later on we will probably have one global RM
 218             SwingUtilities3.setDelegateRepaintManager(delegate, new RepaintManager() {
 219                 @Override
 220                 public void addDirtyRegion(final JComponent c, final int x, final int y, final int w, final int h) {
 221                     repaintPeer(SwingUtilities.convertRectangle(
 222                             c, new Rectangle(x, y, w, h), getDelegate()));
 223                 }
 224             });
 225         }
 226     }
 227 
 228     /**
 229      * This method must be called under Toolkit.getDefaultToolkit() lock
 230      * and followed by setToolkitAWTEventListener()
 231      */
 232     protected final AWTEventListener getToolkitAWTEventListener() {
 233         return AccessController.doPrivileged(new PrivilegedAction<AWTEventListener>() {
 234             public AWTEventListener run() {
 235                 Toolkit toolkit = Toolkit.getDefaultToolkit();
 236                 try {
 237                     Field field = Toolkit.class.getDeclaredField("eventListener");
 238                     field.setAccessible(true);
 239                     return (AWTEventListener) field.get(toolkit);
 240                 } catch (Exception e) {
 241                     throw new InternalError(e.toString());
 242                 }
 243             }
 244         });
 245     }
 246 
 247     protected final void setToolkitAWTEventListener(final AWTEventListener listener) {
 248         AccessController.doPrivileged(new PrivilegedAction<Void>() {
 249             public Void run() {
 250                 Toolkit toolkit = Toolkit.getDefaultToolkit();
 251                 try {
 252                     Field field = Toolkit.class.getDeclaredField("eventListener");
 253                     field.setAccessible(true);
 254                     field.set(toolkit, listener);
 255                 } catch (Exception e) {
 256                     throw new InternalError(e.toString());
 257                 }
 258                 return null;
 259             }
 260         });
 261     }
 262 
 263     /**
 264      * This method is called under getDelegateLock().
 265      * Overridden in subclasses.
 266      */
 267     protected D createDelegate() {
 268         return null;
 269     }
 270 
 271     protected final D getDelegate() {
 272         synchronized (getStateLock()) {
 273             return delegate;
 274         }
 275     }
 276 
 277     protected Component getDelegateFocusOwner() {
 278         return getDelegate();
 279     }
 280 
 281     /*
 282      * Initializes this peer by fetching all the properties from the target.
 283      * The call to initialize() is not placed to LWComponentPeer ctor to
 284      * let the subclass ctor to finish completely first. Instead, it's the
 285      * LWToolkit object who is responsible for initialization.
 286      */
 287     public void initialize() {
 288         platformComponent.initialize(target, this, getPlatformWindow());
 289         targetPaintArea = new LWRepaintArea();
 290         if (getDelegate() != null) {
 291             synchronized (getDelegateLock()) {
 292                 resetColorsAndFont(delegate);
 293                 getDelegate().setOpaque(true);
 294             }
 295         }
 296         setBackground(target.getBackground());
 297         setForeground(target.getForeground());
 298         setFont(target.getFont());
 299         setBounds(target.getBounds());
 300         setEnabled(target.isEnabled());
 301         setVisible(target.isVisible());
 302     }
 303 
 304     private static void resetColorsAndFont(final Container c) {
 305         c.setBackground(null);
 306         c.setForeground(null);
 307         c.setFont(null);
 308         for (int i = 0; i < c.getComponentCount(); i++) {
 309             resetColorsAndFont((Container) c.getComponent(i));
 310         }
 311     }
 312 
 313     final Object getStateLock() {
 314         return stateLock;
 315     }
 316 
 317     // Synchronize all operations with the Swing delegates under
 318     // AWT tree lock, using a new separate lock to synchronize
 319     // access to delegates may lead deadlocks
 320     final Object getDelegateLock() {
 321         //return delegateTreeLock;
 322         return getTarget().getTreeLock();
 323     }
 324 
 325     protected final static Object getPeerTreeLock() {
 326         return peerTreeLock;
 327     }
 328 
 329     final T getTarget() {
 330         return target;
 331     }
 332 
 333     // Just a helper method
 334     // Returns the window peer or null if this is a window peer
 335     protected final LWWindowPeer getWindowPeer() {
 336         return windowPeer;
 337     }
 338 
 339     // Returns the window peer or 'this' if this is a window peer
 340     protected LWWindowPeer getWindowPeerOrSelf() {
 341         return getWindowPeer();
 342     }
 343 
 344     // Just a helper method
 345     protected final LWContainerPeer getContainerPeer() {
 346         return containerPeer;
 347     }
 348 
 349     // Just a helper method
 350     // Overridden in LWWindowPeer to skip containerPeer initialization
 351     protected void initializeContainerPeer() {
 352         Container parent = LWToolkit.getNativeContainer(target);
 353         if (parent != null) {
 354             containerPeer = (LWContainerPeer) LWToolkit.targetToPeer(parent);
 355         }
 356     }
 357 
 358     public PlatformWindow getPlatformWindow() {
 359         LWWindowPeer windowPeer = getWindowPeer();
 360         return windowPeer.getPlatformWindow();
 361     }
 362 
 363     protected AppContext getAppContext() {
 364         return SunToolkit.targetToAppContext(getTarget());
 365     }
 366 
 367     // ---- PEER METHODS ---- //
 368 
 369     @Override
 370     public Toolkit getToolkit() {
 371         return LWToolkit.getLWToolkit();
 372     }
 373 
 374     // Just a helper method
 375     public LWToolkit getLWToolkit() {
 376         return LWToolkit.getLWToolkit();
 377     }
 378 
 379     @Override
 380     public final void dispose() {
 381         if (disposed.compareAndSet(false, true)) {
 382             disposeImpl();
 383         }
 384     }
 385 
 386     protected void disposeImpl() {
 387         LWContainerPeer cp = getContainerPeer();
 388         if (cp != null) {
 389             cp.removeChildPeer(this);
 390         }
 391         platformComponent.dispose();
 392         LWToolkit.targetDisposedPeer(getTarget(), this);
 393     }
 394 
 395     public final boolean isDisposed() {
 396         return disposed.get();
 397     }
 398 
 399     /*
 400      * GraphicsConfiguration is borrowed from the parent peer. The
 401      * return value must not be null.
 402      *
 403      * Overridden in LWWindowPeer.
 404      */
 405     @Override
 406     public GraphicsConfiguration getGraphicsConfiguration() {
 407         // Don't check windowPeer for null as it can only happen
 408         // for windows, but this method is overridden in
 409         // LWWindowPeer and doesn't call super()
 410         return getWindowPeer().getGraphicsConfiguration();
 411     }
 412 
 413     /*
 414      * Overridden in LWWindowPeer to replace its surface
 415      * data and back buffer.
 416      */
 417     @Override
 418     public boolean updateGraphicsData(GraphicsConfiguration gc) {
 419         // TODO: not implemented
 420 //        throw new RuntimeException("Has not been implemented yet.");
 421         return false;
 422     }
 423 
 424     @Override
 425     public final Graphics getGraphics() {
 426         Graphics g = getWindowPeerOrSelf().isOpaque() ? getOnscreenGraphics()
 427                                                       : getOffscreenGraphics();
 428         if (g != null) {
 429             synchronized (getPeerTreeLock()){
 430                 applyConstrain(g);
 431             }
 432         }
 433         return g;
 434     }
 435 
 436     /*
 437      * Peer Graphics is borrowed from the parent peer, while
 438      * foreground and background colors and font are specific to
 439      * this peer.
 440      */
 441     public final Graphics getOnscreenGraphics() {
 442         final LWWindowPeer wp = getWindowPeerOrSelf();
 443         return wp.getOnscreenGraphics(getForeground(), getBackground(),
 444                                       getFont());
 445     }
 446 
 447     public final Graphics getOffscreenGraphics() {
 448         final LWWindowPeer wp = getWindowPeerOrSelf();
 449 
 450         return wp.getOffscreenGraphics(getForeground(), getBackground(),
 451                                        getFont());
 452     }
 453 
 454     private void applyConstrain(final Graphics g) {
 455         final SunGraphics2D sg2d = (SunGraphics2D) g;
 456         final Rectangle constr = localToWindow(getSize());
 457         // translate and set rectangle constrain.
 458         sg2d.constrain(constr.x, constr.y, constr.width, constr.height);
 459         // set region constrain.
 460         //sg2d.constrain(getVisibleRegion());
 461         SG2DConstraint(sg2d, getVisibleRegion());
 462     }
 463 
 464     //TODO Move this method to SG2D?
 465     private void SG2DConstraint(final SunGraphics2D sg2d, Region r) {
 466         sg2d.constrainX = sg2d.transX;
 467         sg2d.constrainY = sg2d.transY;
 468 
 469         Region c = sg2d.constrainClip;
 470         if ((sg2d.constrainX | sg2d.constrainY) != 0) {
 471             r = r.getTranslatedRegion(sg2d.constrainX, sg2d.constrainY);
 472         }
 473         if (c == null) {
 474             c = r;
 475         } else {
 476             c = c.getIntersection(r);
 477             if (c == sg2d.constrainClip) {
 478                 // Common case to ignore
 479                 return;
 480             }
 481         }
 482         sg2d.constrainClip = c;
 483         //validateCompClip() forced call.
 484         sg2d.setDevClip(r.getLoX(), r.getLoY(), r.getWidth(), r.getHeight());
 485     }
 486 
 487     public Region getVisibleRegion() {
 488         return computeVisibleRect(this, getRegion());
 489     }
 490 
 491     static final Region computeVisibleRect(LWComponentPeer c, Region region) {
 492         final LWContainerPeer p = c.getContainerPeer();
 493         if (p != null) {
 494             final Rectangle r = c.getBounds();
 495             region = region.getTranslatedRegion(r.x, r.y);
 496             region = region.getIntersection(p.getRegion());
 497             region = region.getIntersection(p.getContentSize());
 498             region = p.cutChildren(region, c);
 499             region = computeVisibleRect(p, region);
 500             region = region.getTranslatedRegion(-r.x, -r.y);
 501         }
 502         return region;
 503     }
 504 
 505     @Override
 506     public ColorModel getColorModel() {
 507         // Is it a correct implementation?
 508         return getGraphicsConfiguration().getColorModel();
 509     }
 510 
 511     @Override
 512     public void createBuffers(int numBuffers, BufferCapabilities caps)
 513             throws AWTException {
 514         throw new AWTException("Back buffers are only supported for " +
 515                 "Window or Canvas components.");
 516     }
 517 
 518     /*
 519      * To be overridden in LWWindowPeer and LWCanvasPeer.
 520      */
 521     @Override
 522     public Image getBackBuffer() {
 523         // Return null or throw AWTException?
 524         return null;
 525     }
 526 
 527     @Override
 528     public void flip(int x1, int y1, int x2, int y2,
 529                      BufferCapabilities.FlipContents flipAction) {
 530         // Skip silently or throw AWTException?
 531     }
 532 
 533     @Override
 534     public void destroyBuffers() {
 535         // Do nothing
 536     }
 537 
 538     // Helper method
 539     public void setBounds(Rectangle r) {
 540         setBounds(r.x, r.y, r.width, r.height, SET_BOUNDS);
 541     }
 542 
 543     /**
 544      * This method could be called on the toolkit thread.
 545      */
 546     @Override
 547     public void setBounds(int x, int y, int w, int h, int op) {
 548         setBounds(x, y, w, h, op, true, false);
 549     }
 550 
 551     protected void setBounds(int x, int y, int w, int h, int op, boolean notify,
 552                              final boolean updateTarget) {
 553         Rectangle oldBounds;
 554         synchronized (getStateLock()) {
 555             oldBounds = new Rectangle(bounds);
 556             if ((op & (SET_LOCATION | SET_BOUNDS)) != 0) {
 557                 bounds.x = x;
 558                 bounds.y = y;
 559             }
 560             if ((op & (SET_SIZE | SET_BOUNDS)) != 0) {
 561                 bounds.width = w;
 562                 bounds.height = h;
 563             }
 564         }
 565         boolean moved = (oldBounds.x != x) || (oldBounds.y != y);
 566         boolean resized = (oldBounds.width != w) || (oldBounds.height != h);
 567         if (!moved && !resized) {
 568             return;
 569         }
 570         final D delegate = getDelegate();
 571         if (delegate != null) {
 572             synchronized (getDelegateLock()) {
 573                 delegateContainer.setBounds(0, 0, w, h);
 574                 delegate.setBounds(delegateContainer.getBounds());
 575                 // TODO: the following means that the delegateContainer NEVER gets validated. That's WRONG!
 576                 delegate.validate();
 577             }
 578         }
 579 
 580         final Point locationInWindow = localToWindow(0, 0);
 581         platformComponent.setBounds(locationInWindow.x, locationInWindow.y, w,
 582                                     h);
 583         if (notify) {
 584             repaintOldNewBounds(oldBounds);
 585             if (resized) {
 586                 handleResize(w, h, updateTarget);
 587             }
 588             if (moved) {
 589                 handleMove(x, y, updateTarget);
 590             }
 591         }
 592     }
 593 
 594     public final Rectangle getBounds() {
 595         synchronized (getStateLock()) {
 596             // Return a copy to prevent subsequent modifications
 597             return bounds.getBounds();
 598         }
 599     }
 600 
 601     public final Rectangle getSize() {
 602         synchronized (getStateLock()) {
 603             // Return a copy to prevent subsequent modifications
 604             return new Rectangle(bounds.width, bounds.height);
 605         }
 606     }
 607 
 608     @Override
 609     public Point getLocationOnScreen() {
 610         Point windowLocation = getWindowPeer().getLocationOnScreen();
 611         Point locationInWindow = localToWindow(0, 0);
 612         return new Point(windowLocation.x + locationInWindow.x,
 613                 windowLocation.y + locationInWindow.y);
 614     }
 615 
 616     @Override
 617     public void setBackground(final Color c) {
 618         final Color oldBg = getBackground();
 619         if (oldBg == c || (oldBg != null && oldBg.equals(c))) {
 620             return;
 621         }
 622         synchronized (getStateLock()) {
 623             background = c;
 624         }
 625         final D delegate = getDelegate();
 626         if (delegate != null) {
 627             synchronized (getDelegateLock()) {
 628                 // delegate will repaint the target
 629                 delegate.setBackground(c);
 630             }
 631         } else {
 632             repaintPeer();
 633         }
 634     }
 635 
 636     protected final Color getBackground() {
 637         synchronized (getStateLock()) {
 638             return background;
 639         }
 640     }
 641 
 642     @Override
 643     public void setForeground(final Color c) {
 644         final Color oldFg = getForeground();
 645         if (oldFg == c || (oldFg != null && oldFg.equals(c))) {
 646             return;
 647         }
 648         synchronized (getStateLock()) {
 649             foreground = c;
 650         }
 651         final D delegate = getDelegate();
 652         if (delegate != null) {
 653             synchronized (getDelegateLock()) {
 654                 // delegate will repaint the target
 655                 delegate.setForeground(c);
 656             }
 657         } else {
 658             repaintPeer();
 659         }
 660     }
 661 
 662     protected final Color getForeground() {
 663         synchronized (getStateLock()) {
 664             return foreground;
 665         }
 666     }
 667 
 668     @Override
 669     public void setFont(final Font f) {
 670         final Font oldF = getFont();
 671         if (oldF == f || (oldF != null && oldF.equals(f))) {
 672             return;
 673         }
 674         synchronized (getStateLock()) {
 675             font = f;
 676         }
 677         final D delegate = getDelegate();
 678         if (delegate != null) {
 679             synchronized (getDelegateLock()) {
 680                 // delegate will repaint the target
 681                 delegate.setFont(f);
 682             }
 683         } else {
 684             repaintPeer();
 685         }
 686     }
 687 
 688     protected final Font getFont() {
 689         synchronized (getStateLock()) {
 690             return font;
 691         }
 692     }
 693 
 694     @Override
 695     public FontMetrics getFontMetrics(Font f) {
 696         // Borrow the metrics from the top-level window
 697 //        return getWindowPeer().getFontMetrics(f);
 698         // Obtain the metrics from the offscreen window where this peer is
 699         // mostly drawn to.
 700         // TODO: check for "use platform metrics" settings
 701         Graphics g = getWindowPeer().getOffscreenGraphics();
 702         try {
 703             if (g != null) {
 704                 return g.getFontMetrics(f);
 705             } else {
 706                 synchronized (getDelegateLock()) {
 707                     return delegateContainer.getFontMetrics(f);
 708                 }
 709             }
 710         } finally {
 711             if (g != null) {
 712                 g.dispose();
 713             }
 714         }
 715     }
 716 
 717     @Override
 718     public void setEnabled(final boolean e) {
 719         boolean status = e;
 720         final LWComponentPeer cp = getContainerPeer();
 721         if (cp != null) {
 722             status &= cp.isEnabled();
 723         }
 724         synchronized (getStateLock()) {
 725             if (enabled == status) {
 726                 return;
 727             }
 728             enabled = status;
 729         }
 730 
 731         final D delegate = getDelegate();
 732 
 733         if (delegate != null) {
 734             synchronized (getDelegateLock()) {
 735                 delegate.setEnabled(status);
 736             }
 737         } else {
 738             repaintPeer();
 739         }
 740     }
 741 
 742     // Helper method
 743     public final boolean isEnabled() {
 744         synchronized (getStateLock()) {
 745             return enabled;
 746         }
 747     }
 748 
 749     @Override
 750     public void setVisible(boolean v) {
 751         synchronized (getStateLock()) {
 752             if (visible == v) {
 753                 return;
 754             }
 755             visible = v;
 756         }
 757 
 758         final D delegate = getDelegate();
 759 
 760         if (delegate != null) {
 761             synchronized (getDelegateLock()) {
 762                 delegate.setVisible(v);
 763             }
 764         }
 765         if (visible) {
 766             repaintPeer();
 767         } else {
 768             repaintParent(getBounds());
 769         }
 770     }
 771 
 772     // Helper method
 773     public final boolean isVisible() {
 774         synchronized (getStateLock()) {
 775             return visible;
 776         }
 777     }
 778 
 779     @Override
 780     public void paint(final Graphics g) {
 781         getTarget().paint(g);
 782     }
 783 
 784     @Override
 785     public void print(final Graphics g) {
 786         getTarget().print(g);
 787     }
 788 
 789     @Override
 790     public void reparent(ContainerPeer newContainer) {
 791         // TODO: not implemented
 792         throw new UnsupportedOperationException("ComponentPeer.reparent()");
 793     }
 794 
 795     @Override
 796     public boolean isReparentSupported() {
 797         // TODO: not implemented
 798         return false;
 799     }
 800 
 801     @Override
 802     public void setZOrder(ComponentPeer above) {
 803         LWContainerPeer cp = getContainerPeer();
 804         // Don't check containerPeer for null as it can only happen
 805         // for windows, but this method is overridden in
 806         // LWWindowPeer and doesn't call super()
 807         cp.setChildPeerZOrder(this, (LWComponentPeer) above);
 808     }
 809 
 810     @Override
 811     public void coalescePaintEvent(PaintEvent e) {
 812         if (!(e instanceof IgnorePaintEvent)) {
 813             Rectangle r = e.getUpdateRect();
 814             if ((r != null) && !r.isEmpty()) {
 815                 targetPaintArea.add(r, e.getID());
 816             }
 817         }
 818     }
 819 
 820     /*
 821      * Should be overridden in subclasses which use complex Swing components.
 822      */
 823     @Override
 824     public void layout() {
 825         // TODO: not implemented
 826     }
 827 
 828     @Override
 829     public boolean isObscured() {
 830         // TODO: not implemented
 831         return false;
 832     }
 833 
 834     @Override
 835     public boolean canDetermineObscurity() {
 836         // TODO: not implemented
 837         return false;
 838     }
 839 
 840     /**
 841      * Should be overridden in subclasses to forward the request
 842      * to the Swing helper component, if required.
 843      */
 844     @Override
 845     public Dimension getPreferredSize() {
 846         // It looks like a default implementation for all toolkits
 847         return getMinimumSize();
 848     }
 849 
 850     /*
 851      * Should be overridden in subclasses to forward the request
 852      * to the Swing helper component.
 853      */
 854     @Override
 855     public Dimension getMinimumSize() {
 856         D delegate = getDelegate();
 857 
 858         if (delegate == null) {
 859             // Is it a correct default value?
 860             return getBounds().getSize();
 861         } else {
 862             synchronized (getDelegateLock()) {
 863                 return delegate.getMinimumSize();
 864             }
 865         }
 866     }
 867 
 868     @Override
 869     public void updateCursorImmediately() {
 870         getLWToolkit().getCursorManager().updateCursor();
 871     }
 872 
 873     @Override
 874     public boolean isFocusable() {
 875         // Overridden in focusable subclasses like buttons
 876         return false;
 877     }
 878 
 879     @Override
 880     public boolean requestFocus(Component lightweightChild, boolean temporary,
 881                                 boolean focusedWindowChangeAllowed, long time,
 882                                 CausedFocusEvent.Cause cause)
 883     {
 884         if (focusLog.isLoggable(PlatformLogger.FINEST)) {
 885             focusLog.finest("lightweightChild=" + lightweightChild + ", temporary=" + temporary +
 886                             ", focusedWindowChangeAllowed=" + focusedWindowChangeAllowed +
 887                             ", time= " + time + ", cause=" + cause);
 888         }
 889         if (LWKeyboardFocusManagerPeer.getInstance(getAppContext()).
 890                 processSynchronousLightweightTransfer(getTarget(), lightweightChild, temporary,
 891                         focusedWindowChangeAllowed, time)) {
 892             return true;
 893         }
 894 
 895         int result = LWKeyboardFocusManagerPeer.getInstance(getAppContext()).
 896                 shouldNativelyFocusHeavyweight(getTarget(), lightweightChild, temporary,
 897                         focusedWindowChangeAllowed, time, cause);
 898         switch (result) {
 899             case LWKeyboardFocusManagerPeer.SNFH_FAILURE:
 900                 return false;
 901             case LWKeyboardFocusManagerPeer.SNFH_SUCCESS_PROCEED:
 902                 Window parentWindow = SunToolkit.getContainingWindow(getTarget());
 903                 if (parentWindow == null) {
 904                     focusLog.fine("request rejected, parentWindow is null");
 905                     LWKeyboardFocusManagerPeer.removeLastFocusRequest(getTarget());
 906                     return false;
 907                 }
 908                 LWWindowPeer parentPeer = (LWWindowPeer) parentWindow.getPeer();
 909                 if (parentPeer == null) {
 910                     focusLog.fine("request rejected, parentPeer is null");
 911                     LWKeyboardFocusManagerPeer.removeLastFocusRequest(getTarget());
 912                     return false;
 913                 }
 914 
 915                 // A fix for 7145768. Ensure the parent window is currently natively focused.
 916                 // The more evident place to perform this check is in KFM.shouldNativelyFocusHeavyweight,
 917                 // however that is the shared code and this particular problem's reproducibility has
 918                 // platform specifics. So, it was decided to narrow down the fix to lwawt (OSX) in
 919                 // current release. TODO: consider fixing it in the shared code.
 920                 if (!focusedWindowChangeAllowed) {
 921                     LWWindowPeer decoratedPeer = parentPeer.isSimpleWindow() ?
 922                         LWWindowPeer.getOwnerFrameDialog(parentPeer) : parentPeer;
 923 
 924                     if (decoratedPeer == null || !decoratedPeer.getPlatformWindow().isActive()) {
 925                         if (focusLog.isLoggable(PlatformLogger.FINE)) {
 926                             focusLog.fine("request rejected, focusedWindowChangeAllowed==false, " +
 927                                           "decoratedPeer is inactive: " + decoratedPeer);
 928                         }
 929                         LWKeyboardFocusManagerPeer.removeLastFocusRequest(getTarget());
 930                         return false;
 931                     }
 932                 }
 933 
 934                 boolean res = parentPeer.requestWindowFocus(cause);
 935                 // If parent window can be made focused and has been made focused (synchronously)
 936                 // then we can proceed with children, otherwise we retreat
 937                 if (!res || !parentWindow.isFocused()) {
 938                     if (focusLog.isLoggable(PlatformLogger.FINE)) {
 939                         focusLog.fine("request rejected, res= " + res + ", parentWindow.isFocused()=" +
 940                                       parentWindow.isFocused());
 941                     }
 942                     LWKeyboardFocusManagerPeer.removeLastFocusRequest(getTarget());
 943                     return false;
 944                 }
 945 
 946                 LWComponentPeer focusOwnerPeer =
 947                     LWKeyboardFocusManagerPeer.getInstance(getAppContext()).
 948                         getFocusOwner();
 949                 Component focusOwner = (focusOwnerPeer != null) ? focusOwnerPeer.getTarget() : null;
 950                 return LWKeyboardFocusManagerPeer.deliverFocus(lightweightChild,
 951                         getTarget(), temporary,
 952                         focusedWindowChangeAllowed,
 953                         time, cause, focusOwner);
 954             case LWKeyboardFocusManagerPeer.SNFH_SUCCESS_HANDLED:
 955                 return true;
 956         }
 957 
 958         return false;
 959     }
 960 
 961     @Override
 962     public Image createImage(ImageProducer producer) {
 963         return new ToolkitImage(producer);
 964     }
 965 
 966     @Override
 967     public Image createImage(int w, int h) {
 968         CGraphicsConfig gc = (CGraphicsConfig)getGraphicsConfiguration();
 969         return gc.createAcceleratedImage(getTarget(), w, h);
 970     }
 971 
 972     @Override
 973     public VolatileImage createVolatileImage(int w, int h) {
 974         // TODO: is it a right/complete implementation?
 975         return new SunVolatileImage(getTarget(), w, h);
 976     }
 977 
 978     @Override
 979     public boolean prepareImage(Image img, int w, int h, ImageObserver o) {
 980         // TODO: is it a right/complete implementation?
 981         return getToolkit().prepareImage(img, w, h, o);
 982     }
 983 
 984     @Override
 985     public int checkImage(Image img, int w, int h, ImageObserver o) {
 986         // TODO: is it a right/complete implementation?
 987         return getToolkit().checkImage(img, w, h, o);
 988     }
 989 
 990     @Override
 991     public boolean handlesWheelScrolling() {
 992         // TODO: not implemented
 993         return false;
 994     }
 995 
 996     @Override
 997     public final void applyShape(final Region shape) {
 998         synchronized (getStateLock()) {
 999             region = shape;
1000         }
1001         repaintParent(getBounds());
1002     }
1003 
1004     protected final Region getRegion() {
1005         synchronized (getStateLock()) {
1006             return region == null ? Region.getInstance(getSize()) : region;
1007         }
1008     }
1009 
1010     // DropTargetPeer Method
1011     @Override
1012     public void addDropTarget(DropTarget dt) {
1013         LWWindowPeer winPeer = getWindowPeerOrSelf();
1014         if (winPeer != null && winPeer != this) {
1015             // We need to register the DropTarget in the
1016             // peer of the window ancestor of the component
1017             winPeer.addDropTarget(dt);
1018         } else {
1019             synchronized (dropTargetLock) {
1020                 // 10-14-02 VL: Windows WComponentPeer would add (or remove) the drop target only
1021                 // if it's the first (or last) one for the component. Otherwise this call is a no-op.
1022                 if (++fNumDropTargets == 1) {
1023                     // Having a non-null drop target would be an error but let's check just in case:
1024                     if (fDropTarget != null)
1025                         System.err.println("CComponent.addDropTarget(): current drop target is non-null.");
1026 
1027                     // Create a new drop target:
1028                     fDropTarget = CDropTarget.createDropTarget(dt, target, this);
1029                 }
1030             }
1031         }
1032     }
1033 
1034     // DropTargetPeer Method
1035     @Override
1036     public void removeDropTarget(DropTarget dt) {
1037         LWWindowPeer winPeer = getWindowPeerOrSelf();
1038         if (winPeer != null && winPeer != this) {
1039             // We need to unregister the DropTarget in the
1040             // peer of the window ancestor of the component
1041             winPeer.removeDropTarget(dt);
1042         } else {
1043             synchronized (dropTargetLock){
1044                 // 10-14-02 VL: Windows WComponentPeer would add (or remove) the drop target only
1045                 // if it's the first (or last) one for the component. Otherwise this call is a no-op.
1046                 if (--fNumDropTargets == 0) {
1047                     // Having a null drop target would be an error but let's check just in case:
1048                     if (fDropTarget != null) {
1049                         // Dispose of the drop target:
1050                         fDropTarget.dispose();
1051                         fDropTarget = null;
1052                     } else
1053                         System.err.println("CComponent.removeDropTarget(): current drop target is null.");
1054                 }
1055             }
1056         }
1057     }
1058 
1059     // ---- PEER NOTIFICATIONS ---- //
1060 
1061     /**
1062      * Called when this peer's location has been changed either as a result
1063      * of target.setLocation() or as a result of user actions (window is
1064      * dragged with mouse).
1065      *
1066      * To be overridden in LWWindowPeer to update its GraphicsConfig.
1067      *
1068      * This method could be called on the toolkit thread.
1069      */
1070     protected final void handleMove(final int x, final int y,
1071                                     final boolean updateTarget) {
1072         if (updateTarget) {
1073             AWTAccessor.getComponentAccessor().setLocation(getTarget(), x, y);
1074         }
1075         postEvent(new ComponentEvent(getTarget(),
1076                                      ComponentEvent.COMPONENT_MOVED));
1077     }
1078 
1079     /**
1080      * Called when this peer's size has been changed either as a result of
1081      * target.setSize() or as a result of user actions (window is resized).
1082      *
1083      * To be overridden in LWWindowPeer to update its SurfaceData and
1084      * GraphicsConfig.
1085      *
1086      * This method could be called on the toolkit thread.
1087      */
1088     protected final void handleResize(final int w, final int h,
1089                                       final boolean updateTarget) {
1090         if (updateTarget) {
1091             AWTAccessor.getComponentAccessor().setSize(getTarget(), w, h);
1092         }
1093         postEvent(new ComponentEvent(getTarget(),
1094                                      ComponentEvent.COMPONENT_RESIZED));
1095     }
1096 
1097     protected final void repaintOldNewBounds(final Rectangle oldB) {
1098         repaintParent(oldB);
1099         repaintPeer(getSize());
1100     }
1101 
1102     protected final void repaintParent(final Rectangle oldB) {
1103         final LWContainerPeer cp = getContainerPeer();
1104         if (cp != null) {
1105             // Repaint unobscured part of the parent
1106             cp.repaintPeer(cp.getContentSize().intersection(oldB));
1107         }
1108     }
1109 
1110     // ---- EVENTS ---- //
1111 
1112     /**
1113      * Post an event to the proper Java EDT.
1114      */
1115     public void postEvent(AWTEvent event) {
1116         SunToolkit.postEvent(getAppContext(), event);
1117     }
1118 
1119     protected void postPaintEvent(int x, int y, int w, int h) {
1120         // TODO: call getIgnoreRepaint() directly with the right ACC
1121         if (AWTAccessor.getComponentAccessor().getIgnoreRepaint(target)) {
1122             return;
1123         }
1124         PaintEvent event = PaintEventDispatcher.getPaintEventDispatcher().
1125                 createPaintEvent(getTarget(), x, y, w, h);
1126         if (event != null) {
1127             postEvent(event);
1128         }
1129     }
1130 
1131     /*
1132      * Gives a chance for the peer to handle the event after it's been
1133      * processed by the target.
1134      */
1135     @Override
1136     public void handleEvent(AWTEvent e) {
1137         if ((e instanceof InputEvent) && ((InputEvent) e).isConsumed()) {
1138             return;
1139         }
1140         switch (e.getID()) {
1141             case FocusEvent.FOCUS_GAINED:
1142             case FocusEvent.FOCUS_LOST:
1143                 handleJavaFocusEvent((FocusEvent) e);
1144                 break;
1145             case PaintEvent.PAINT:
1146                 // Got a native paint event
1147 //                paintPending = false;
1148                 // fall through to the next statement
1149             case PaintEvent.UPDATE:
1150                 handleJavaPaintEvent();
1151                 break;
1152             case MouseEvent.MOUSE_PRESSED:
1153                 handleJavaMouseEvent((MouseEvent)e);
1154         }
1155 
1156         sendEventToDelegate(e);
1157     }
1158 
1159     protected void sendEventToDelegate(final AWTEvent e) {
1160         synchronized (getDelegateLock()) {
1161             if (getDelegate() == null || !isShowing() || !isEnabled()) {
1162                 return;
1163             }
1164             AWTEvent delegateEvent = createDelegateEvent(e);
1165             if (delegateEvent != null) {
1166                 AWTAccessor.getComponentAccessor()
1167                         .processEvent((Component) delegateEvent.getSource(),
1168                                 delegateEvent);
1169                 if (delegateEvent instanceof KeyEvent) {
1170                     KeyEvent ke = (KeyEvent) delegateEvent;
1171                     SwingUtilities.processKeyBindings(ke);
1172                 }
1173             }
1174         }
1175     }
1176 
1177     protected AWTEvent createDelegateEvent(AWTEvent e) {
1178         AWTEvent delegateEvent = null;
1179         if (e instanceof MouseWheelEvent) {
1180             MouseWheelEvent me = (MouseWheelEvent) e;
1181             delegateEvent = new MouseWheelEvent(
1182                     delegate, me.getID(), me.getWhen(),
1183                     me.getModifiers(),
1184                     me.getX(), me.getY(),
1185                     me.getClickCount(),
1186                     me.isPopupTrigger(),
1187                     me.getScrollType(),
1188                     me.getScrollAmount(),
1189                     me.getWheelRotation());
1190         } else if (e instanceof MouseEvent) {
1191             MouseEvent me = (MouseEvent) e;
1192 
1193             Component eventTarget = SwingUtilities.getDeepestComponentAt(delegate, me.getX(), me.getY());
1194 
1195             if (me.getID() == MouseEvent.MOUSE_DRAGGED) {
1196                 if (delegateDropTarget == null) {
1197                     delegateDropTarget = eventTarget;
1198                 } else {
1199                     eventTarget = delegateDropTarget;
1200                 }
1201             }
1202             if (me.getID() == MouseEvent.MOUSE_RELEASED && delegateDropTarget != null) {
1203                 eventTarget = delegateDropTarget;
1204                 delegateDropTarget = null;
1205             }
1206             if (eventTarget == null) {
1207                 eventTarget = delegate;
1208             }
1209             delegateEvent = SwingUtilities.convertMouseEvent(getTarget(), me, eventTarget);
1210         } else if (e instanceof KeyEvent) {
1211             KeyEvent ke = (KeyEvent) e;
1212             delegateEvent = new KeyEvent(getDelegateFocusOwner(), ke.getID(), ke.getWhen(),
1213                     ke.getModifiers(), ke.getKeyCode(), ke.getKeyChar(), ke.getKeyLocation());
1214         } else if (e instanceof FocusEvent) {
1215             FocusEvent fe = (FocusEvent) e;
1216             delegateEvent = new FocusEvent(getDelegateFocusOwner(), fe.getID(), fe.isTemporary());
1217         }
1218         return delegateEvent;
1219     }
1220 
1221     protected void handleJavaMouseEvent(MouseEvent e) {
1222         Component target = getTarget();
1223         assert (e.getSource() == target);
1224 
1225         if (!target.isFocusOwner() && LWKeyboardFocusManagerPeer.shouldFocusOnClick(target)) {
1226             LWKeyboardFocusManagerPeer.requestFocusFor(target, CausedFocusEvent.Cause.MOUSE_EVENT);
1227         } else {
1228             // Anyway request focus to the toplevel.
1229             getWindowPeerOrSelf().requestWindowFocus(CausedFocusEvent.Cause.MOUSE_EVENT);
1230         }
1231     }
1232 
1233     /**
1234      * Handler for FocusEvents.
1235      */
1236     protected void handleJavaFocusEvent(FocusEvent e) {
1237         // Note that the peer receives all the FocusEvents from
1238         // its lightweight children as well
1239         LWKeyboardFocusManagerPeer.getInstance(getAppContext()).
1240                 setFocusOwner(e.getID() == FocusEvent.FOCUS_GAINED ? this : null);
1241     }
1242 
1243     /**
1244      * All peers should clear background before paint.
1245      *
1246      * @return false on components that DO NOT require a clearRect() before
1247      *         painting.
1248      */
1249     protected final boolean shouldClearRectBeforePaint() {
1250         // TODO: sun.awt.noerasebackground
1251         return true;
1252     }
1253 
1254     /**
1255      * Handler for PAINT and UPDATE PaintEvents.
1256      */
1257     private void handleJavaPaintEvent() {
1258         // Skip all painting while layouting and all UPDATEs
1259         // while waiting for native paint
1260 //        if (!isLayouting && !paintPending) {
1261         if (!isLayouting()) {
1262             targetPaintArea.paint(getTarget(), shouldClearRectBeforePaint());
1263         }
1264     }
1265 
1266     // ---- UTILITY METHODS ---- //
1267 
1268     /**
1269      * Finds a top-most visible component for the given point. The location is
1270      * specified relative to the peer's parent.
1271      */
1272     public LWComponentPeer findPeerAt(final int x, final int y) {
1273         final Rectangle r = getBounds();
1274         final Region sh = getRegion();
1275         final boolean found = isVisible() && sh.contains(x - r.x, y - r.y);
1276         return found ? this : null;
1277     }
1278 
1279     /*
1280      * Translated the given point in Window coordinates to the point in
1281      * coordinates local to this component. The given window peer must be
1282      * the window where this component is in.
1283      */
1284     public Point windowToLocal(int x, int y, LWWindowPeer wp) {
1285         return windowToLocal(new Point(x, y), wp);
1286     }
1287 
1288     public Point windowToLocal(Point p, LWWindowPeer wp) {
1289         LWComponentPeer cp = this;
1290         while (cp != wp) {
1291             Rectangle cpb = cp.getBounds();
1292             p.x -= cpb.x;
1293             p.y -= cpb.y;
1294             cp = cp.getContainerPeer();
1295         }
1296         // Return a copy to prevent subsequent modifications
1297         return new Point(p);
1298     }
1299 
1300     public Rectangle windowToLocal(Rectangle r, LWWindowPeer wp) {
1301         Point p = windowToLocal(r.getLocation(), wp);
1302         return new Rectangle(p, r.getSize());
1303     }
1304 
1305     public Point localToWindow(int x, int y) {
1306         return localToWindow(new Point(x, y));
1307     }
1308 
1309     public Point localToWindow(Point p) {
1310         LWComponentPeer cp = getContainerPeer();
1311         Rectangle r = getBounds();
1312         while (cp != null) {
1313             p.x += r.x;
1314             p.y += r.y;
1315             r = cp.getBounds();
1316             cp = cp.getContainerPeer();
1317         }
1318         // Return a copy to prevent subsequent modifications
1319         return new Point(p);
1320     }
1321 
1322     public Rectangle localToWindow(Rectangle r) {
1323         Point p = localToWindow(r.getLocation());
1324         return new Rectangle(p, r.getSize());
1325     }
1326 
1327     public final void repaintPeer() {
1328         repaintPeer(getSize());
1329     }
1330 
1331     public void repaintPeer(final Rectangle r) {
1332         final Rectangle toPaint = getSize().intersection(r);
1333         if (!isShowing() || toPaint.isEmpty()) {
1334             return;
1335         }
1336 
1337         postPaintEvent(toPaint.x, toPaint.y, toPaint.width, toPaint.height);
1338     }
1339 
1340     /**
1341      * Determines whether this peer is showing on screen. This means that the
1342      * peer must be visible, and it must be in a container that is visible and
1343      * showing.
1344      *
1345      * @see #isVisible()
1346      */
1347     protected boolean isShowing() {
1348         synchronized (getPeerTreeLock()) {
1349             if (isVisible()) {
1350                 final LWContainerPeer container = getContainerPeer();
1351                 return (container == null) || container.isShowing();
1352             }
1353         }
1354         return false;
1355     }
1356 
1357     /**
1358      * Paints the peer. Overridden in subclasses to delegate the actual painting
1359      * to Swing components.
1360      */
1361     protected final void paintPeer(final Graphics g) {
1362         final D delegate = getDelegate();
1363         if (delegate != null) {
1364             if (!SwingUtilities.isEventDispatchThread()) {
1365                 throw new InternalError("Painting must be done on EDT");
1366             }
1367             synchronized (getDelegateLock()) {
1368                 // JComponent.print() is guaranteed to not affect the double buffer
1369                 getDelegate().print(g);
1370             }
1371         }
1372     }
1373 
1374     // Just a helper method, thus final
1375     protected final void flushOffscreenGraphics() {
1376         flushOffscreenGraphics(getSize());
1377     }
1378 
1379     protected static final void flushOnscreenGraphics(){
1380         final OGLRenderQueue rq = OGLRenderQueue.getInstance();
1381         rq.lock();
1382         try {
1383             rq.flushNow();
1384         } finally {
1385             rq.unlock();
1386         }
1387     }
1388 
1389     /*
1390      * Flushes the given rectangle from the back buffer to the screen.
1391      */
1392     protected void flushOffscreenGraphics(Rectangle r) {
1393         flushOffscreenGraphics(r.x, r.y, r.width, r.height);
1394     }
1395 
1396     private void flushOffscreenGraphics(int x, int y, int width, int height) {
1397         Image bb = getWindowPeerOrSelf().getBackBuffer();
1398         if (bb != null) {
1399             // g is a screen Graphics from the delegate
1400             final Graphics g = getOnscreenGraphics();
1401 
1402             if (g != null && g instanceof Graphics2D) {
1403                 try {
1404                     Graphics2D g2d = (Graphics2D)g;
1405                     Point p = localToWindow(new Point(0, 0));
1406                     Composite composite = g2d.getComposite();
1407                     g2d.setComposite(AlphaComposite.Src);
1408                     g.drawImage(bb, x, y, x + width, y + height, p.x + x,
1409                             p.y + y, p.x + x + width, p.y + y + height,
1410                             null);
1411                     g2d.setComposite(composite);
1412                 } finally {
1413                     g.dispose();
1414                 }
1415             }
1416         }
1417     }
1418 
1419     /**
1420      * Used by ContainerPeer to skip all the paint events during layout.
1421      *
1422      * @param isLayouting layouting state.
1423      */
1424     protected final void setLayouting(final boolean isLayouting) {
1425         this.isLayouting = isLayouting;
1426     }
1427 
1428     /**
1429      * Returns layouting state. Used by ComponentPeer to skip all the paint
1430      * events during layout.
1431      *
1432      * @return true during layout, false otherwise.
1433      */
1434     private final boolean isLayouting() {
1435         return isLayouting;
1436     }
1437 }