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 package sun.lwawt;
  27 
  28 import java.awt.*;
  29 import java.awt.event.*;
  30 import java.awt.image.BufferedImage;
  31 import java.awt.peer.*;
  32 import java.util.List;
  33 
  34 import javax.swing.*;
  35 
  36 import sun.awt.*;
  37 import sun.java2d.*;
  38 import sun.java2d.loops.Blit;
  39 import sun.java2d.loops.CompositeType;
  40 import sun.java2d.pipe.Region;
  41 import sun.lwawt.macosx.CPlatformWindow;
  42 import sun.util.logging.PlatformLogger;
  43 
  44 public class LWWindowPeer
  45     extends LWContainerPeer<Window, JComponent>
  46     implements WindowPeer, FramePeer, DialogPeer, FullScreenCapable
  47 {
  48     public static enum PeerType {
  49         SIMPLEWINDOW,
  50         FRAME,
  51         DIALOG,
  52         EMBEDDEDFRAME
  53     }
  54 
  55     private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.lwawt.focus.LWWindowPeer");
  56 
  57     private PlatformWindow platformWindow;
  58 
  59     // Window bounds reported by the native system (as opposed to
  60     // regular bounds inherited from LWComponentPeer which are
  61     // requested by user and may haven't been applied yet because
  62     // of asynchronous requests to the windowing system)
  63     private int sysX;
  64     private int sysY;
  65     private int sysW;
  66     private int sysH;
  67 
  68     private static final int MINIMUM_WIDTH = 1;
  69     private static final int MINIMUM_HEIGHT = 1;
  70 
  71     private Insets insets = new Insets(0, 0, 0, 0);
  72 
  73     private GraphicsDevice graphicsDevice;
  74     private GraphicsConfiguration graphicsConfig;
  75 
  76     private SurfaceData surfaceData;
  77     private final Object surfaceDataLock = new Object();
  78 
  79     private int backBufferCount;
  80     private BufferCapabilities backBufferCaps;
  81 
  82     // The back buffer is used for two purposes:
  83     // 1. To render all the lightweight peers
  84     // 2. To provide user with a BufferStrategy
  85     // Need to check if a single back buffer can be used for both
  86 // TODO: VolatileImage
  87 //    private VolatileImage backBuffer;
  88     private volatile BufferedImage backBuffer;
  89 
  90     private volatile int windowState = Frame.NORMAL;
  91 
  92     // A peer where the last mouse event came to. Used to generate
  93     // MOUSE_ENTERED/EXITED notifications and by cursor manager to
  94     // find the component under cursor
  95     private static volatile LWComponentPeer lastMouseEventPeer = null;
  96 
  97     // Peers where all dragged/released events should come to,
  98     // depending on what mouse button is being dragged according to Cocoa
  99     private static LWComponentPeer mouseDownTarget[] = new LWComponentPeer[3];
 100 
 101     // A bitmask that indicates what mouse buttons produce MOUSE_CLICKED events
 102     // on MOUSE_RELEASE. Click events are only generated if there were no drag
 103     // events between MOUSE_PRESSED and MOUSE_RELEASED for particular button
 104     private static int mouseClickButtons = 0;
 105 
 106     private volatile boolean isOpaque = true;
 107 
 108     private static final Font DEFAULT_FONT = new Font("Lucida Grande", Font.PLAIN, 13);
 109 
 110     private static LWWindowPeer grabbingWindow;
 111 
 112     private volatile boolean skipNextFocusChange;
 113 
 114     private static final Color nonOpaqueBackground = new Color(0, 0, 0, 0);
 115 
 116     private volatile boolean textured;
 117 
 118     /**
 119      * Current modal blocker or null.
 120      *
 121      * Synchronization: peerTreeLock.
 122      */
 123     private LWWindowPeer blocker;
 124 
 125     public LWWindowPeer(Window target, PlatformComponent platformComponent,
 126                         PlatformWindow platformWindow)
 127     {
 128         super(target, platformComponent);
 129         this.platformWindow = platformWindow;
 130 
 131         Window owner = target.getOwner();
 132         LWWindowPeer ownerPeer = (owner != null) ? (LWWindowPeer)owner.getPeer() : null;
 133         PlatformWindow ownerDelegate = (ownerPeer != null) ? ownerPeer.getPlatformWindow() : null;
 134 
 135         // The delegate.initialize() needs a non-null GC on X11.
 136         GraphicsConfiguration gc = getTarget().getGraphicsConfiguration();
 137         synchronized (getStateLock()) {
 138             // graphicsConfig should be updated according to the real window
 139             // bounds when the window is shown, see 4868278
 140             this.graphicsConfig = gc;
 141         }
 142 
 143         if (!target.isFontSet()) {
 144             target.setFont(DEFAULT_FONT);
 145         }
 146 
 147         if (!target.isBackgroundSet()) {
 148             target.setBackground(SystemColor.window);
 149         } else {
 150             // first we check if user provided alpha for background. This is
 151             // similar to what Apple's Java do.
 152             // Since JDK7 we should rely on setOpacity() only.
 153             // this.opacity = c.getAlpha();
 154         }
 155 
 156         if (!target.isForegroundSet()) {
 157             target.setForeground(SystemColor.windowText);
 158             // we should not call setForeground because it will call a repaint
 159             // which the peer may not be ready to do yet.
 160         }
 161 
 162         platformWindow.initialize(target, this, ownerDelegate);
 163     }
 164 
 165     @Override
 166     void initializeImpl() {
 167         super.initializeImpl();
 168         if (getTarget() instanceof Frame) {
 169             setTitle(((Frame) getTarget()).getTitle());
 170             setState(((Frame) getTarget()).getExtendedState());
 171         } else if (getTarget() instanceof Dialog) {
 172             setTitle(((Dialog) getTarget()).getTitle());
 173         }
 174 
 175         setAlwaysOnTop(getTarget().isAlwaysOnTop());
 176         updateMinimumSize();
 177 
 178         final Shape shape = getTarget().getShape();
 179         if (shape != null) {
 180             applyShape(Region.getInstance(shape, null));
 181         }
 182 
 183         final float opacity = getTarget().getOpacity();
 184         if (opacity < 1.0f) {
 185             setOpacity(opacity);
 186         }
 187 
 188         setOpaque(getTarget().isOpaque());
 189 
 190         updateInsets(platformWindow.getInsets());
 191         if (getSurfaceData() == null) {
 192             replaceSurfaceData(false);
 193         }
 194     }
 195 
 196     // Just a helper method
 197     public PlatformWindow getPlatformWindow() {
 198         return platformWindow;
 199     }
 200 
 201     @Override
 202     protected LWWindowPeer getWindowPeerOrSelf() {
 203         return this;
 204     }
 205 
 206     @Override
 207     protected void initializeContainerPeer() {
 208         // No-op as LWWindowPeer doesn't have any containerPeer
 209     }
 210 
 211     // ---- PEER METHODS ---- //
 212 
 213     @Override
 214     protected void disposeImpl() {
 215         SurfaceData oldData = getSurfaceData();
 216         synchronized (surfaceDataLock){
 217             surfaceData = null;
 218         }
 219         if (oldData != null) {
 220             oldData.invalidate();
 221         }
 222         if (isGrabbing()) {
 223             ungrab();
 224         }
 225         destroyBuffers();
 226         platformWindow.dispose();
 227         super.disposeImpl();
 228     }
 229 
 230     @Override
 231     protected void setVisibleImpl(final boolean visible) {
 232         super.setVisibleImpl(visible);
 233         // TODO: update graphicsConfig, see 4868278
 234         platformWindow.setVisible(visible);
 235         if (isSimpleWindow()) {
 236             LWKeyboardFocusManagerPeer manager = LWKeyboardFocusManagerPeer.
 237                 getInstance(getAppContext());
 238 
 239             if (visible) {
 240                 if (!getTarget().isAutoRequestFocus()) {
 241                     return;
 242                 } else {
 243                     requestWindowFocus(CausedFocusEvent.Cause.ACTIVATION);
 244                 }
 245             // Focus the owner in case this window is focused.
 246             } else if (manager.getCurrentFocusedWindow() == getTarget()) {
 247                 // Transfer focus to the owner.
 248                 LWWindowPeer owner = getOwnerFrameDialog(LWWindowPeer.this);
 249                 if (owner != null) {
 250                     owner.requestWindowFocus(CausedFocusEvent.Cause.ACTIVATION);
 251                 }
 252             }
 253         }
 254     }
 255 
 256     @Override
 257     public GraphicsConfiguration getGraphicsConfiguration() {
 258         return graphicsConfig;
 259     }
 260 
 261     @Override
 262     public boolean updateGraphicsData(GraphicsConfiguration gc) {
 263         setGraphicsConfig(gc);
 264         return false;
 265     }
 266 
 267     protected final Graphics getOnscreenGraphics(Color fg, Color bg, Font f) {
 268         if (getSurfaceData() == null) {
 269             return null;
 270         }
 271         if (fg == null) {
 272             fg = SystemColor.windowText;
 273         }
 274         if (bg == null) {
 275             bg = SystemColor.window;
 276         }
 277         if (f == null) {
 278             f = DEFAULT_FONT;
 279         }
 280         return platformWindow.transformGraphics(new SunGraphics2D(getSurfaceData(), fg, bg, f));
 281     }
 282 
 283     @Override
 284     public void createBuffers(int numBuffers, BufferCapabilities caps)
 285         throws AWTException
 286     {
 287         try {
 288             // Assume this method is never called with numBuffers <= 1, as 0 is
 289             // unsupported, and 1 corresponds to a SingleBufferStrategy which
 290             // doesn't depend on the peer. Screen is considered as a separate
 291             // "buffer", that's why numBuffers - 1
 292             assert numBuffers > 1;
 293 
 294             replaceSurfaceData(numBuffers - 1, caps, false);
 295         } catch (InvalidPipeException z) {
 296             throw new AWTException(z.toString());
 297         }
 298     }
 299 
 300     @Override
 301     public final Image getBackBuffer() {
 302         synchronized (getStateLock()) {
 303             return backBuffer;
 304         }
 305     }
 306 
 307     @Override
 308     public void flip(int x1, int y1, int x2, int y2,
 309                      BufferCapabilities.FlipContents flipAction)
 310     {
 311         platformWindow.flip(x1, y1, x2, y2, flipAction);
 312     }
 313 
 314     @Override
 315     public final void destroyBuffers() {
 316         final Image oldBB = getBackBuffer();
 317         synchronized (getStateLock()) {
 318             backBuffer = null;
 319         }
 320         if (oldBB != null) {
 321             oldBB.flush();
 322         }
 323     }
 324 
 325     @Override
 326     public void setBounds(int x, int y, int w, int h, int op) {
 327         if ((op & SET_CLIENT_SIZE) != 0) {
 328             // SET_CLIENT_SIZE is only applicable to window peers, so handle it here
 329             // instead of pulling 'insets' field up to LWComponentPeer
 330             // no need to add insets since Window's notion of width and height includes insets.
 331             op &= ~SET_CLIENT_SIZE;
 332             op |= SET_SIZE;
 333         }
 334 
 335         if (w < MINIMUM_WIDTH) {
 336             w = MINIMUM_WIDTH;
 337         }
 338         if (h < MINIMUM_HEIGHT) {
 339             h = MINIMUM_HEIGHT;
 340         }
 341 
 342         // Don't post ComponentMoved/Resized and Paint events
 343         // until we've got a notification from the delegate
 344         setBounds(x, y, w, h, op, false, false);
 345         // Get updated bounds, so we don't have to handle 'op' here manually
 346         Rectangle r = getBounds();
 347         platformWindow.setBounds(r.x, r.y, r.width, r.height);
 348     }
 349 
 350     @Override
 351     public Point getLocationOnScreen() {
 352         return platformWindow.getLocationOnScreen();
 353     }
 354 
 355     /**
 356      * Overridden from LWContainerPeer to return the correct insets.
 357      * Insets are queried from the delegate and are kept up to date by
 358      * requiering when needed (i.e. when the window geometry is changed).
 359      */
 360     @Override
 361     public Insets getInsets() {
 362         synchronized (getStateLock()) {
 363             return insets;
 364         }
 365     }
 366 
 367     @Override
 368     public FontMetrics getFontMetrics(Font f) {
 369         // TODO: check for "use platform metrics" settings
 370         return platformWindow.getFontMetrics(f);
 371     }
 372 
 373     @Override
 374     public void toFront() {
 375         platformWindow.toFront();
 376     }
 377 
 378     @Override
 379     public void toBack() {
 380         platformWindow.toBack();
 381     }
 382 
 383     @Override
 384     public void setZOrder(ComponentPeer above) {
 385         throw new RuntimeException("not implemented");
 386     }
 387 
 388     @Override
 389     public void setAlwaysOnTop(boolean value) {
 390         platformWindow.setAlwaysOnTop(value);
 391     }
 392 
 393     @Override
 394     public void updateFocusableWindowState() {
 395         platformWindow.updateFocusableWindowState();
 396     }
 397 
 398     @Override
 399     public void setModalBlocked(Dialog blocker, boolean blocked) {
 400         synchronized (getPeerTreeLock()) {
 401             this.blocker = blocked ? (LWWindowPeer)blocker.getPeer() : null;
 402         }
 403 
 404         platformWindow.setModalBlocked(blocked);
 405     }
 406 
 407     @Override
 408     public void updateMinimumSize() {
 409         Dimension d = null;
 410         if (getTarget().isMinimumSizeSet()) {
 411             d = getTarget().getMinimumSize();
 412         }
 413         if (d == null) {
 414             d = new Dimension(MINIMUM_WIDTH, MINIMUM_HEIGHT);
 415         }
 416         platformWindow.setMinimumSize(d.width, d.height);
 417     }
 418 
 419     @Override
 420     public void updateIconImages() {
 421         getPlatformWindow().updateIconImages();
 422     }
 423 
 424     @Override
 425     public void setOpacity(float opacity) {
 426         getPlatformWindow().setOpacity(opacity);
 427         repaintPeer();
 428     }
 429 
 430     @Override
 431     public final void setOpaque(final boolean isOpaque) {
 432         if (this.isOpaque != isOpaque) {
 433             this.isOpaque = isOpaque;
 434             updateOpaque();
 435         }
 436     }
 437 
 438     private void updateOpaque() {
 439         getPlatformWindow().setOpaque(!isTranslucent());
 440         replaceSurfaceData(false);
 441         repaintPeer();
 442     }
 443 
 444     @Override
 445     public void updateWindow() {
 446     }
 447 
 448     public final boolean isTextured() {
 449         return textured;
 450     }
 451 
 452     public final void setTextured(final boolean isTextured) {
 453         textured = isTextured;
 454     }
 455 
 456     public final boolean isTranslucent() {
 457         synchronized (getStateLock()) {
 458             /*
 459              * Textured window is a special case of translucent window.
 460              * The difference is only in nswindow background. So when we set
 461              * texture property our peer became fully translucent. It doesn't
 462              * fill background, create non opaque backbuffers and layer etc.
 463              */
 464             return !isOpaque || isShaped() || isTextured();
 465         }
 466     }
 467 
 468     @Override
 469     final void applyShapeImpl(final Region shape) {
 470         super.applyShapeImpl(shape);
 471         updateOpaque();
 472     }
 473 
 474     @Override
 475     public void repositionSecurityWarning() {
 476         throw new RuntimeException("not implemented");
 477     }
 478 
 479     // ---- FRAME PEER METHODS ---- //
 480 
 481     @Override // FramePeer and DialogPeer
 482     public void setTitle(String title) {
 483         platformWindow.setTitle(title == null ? "" : title);
 484     }
 485 
 486     @Override
 487     public void setMenuBar(MenuBar mb) {
 488          platformWindow.setMenuBar(mb);
 489     }
 490 
 491     @Override // FramePeer and DialogPeer
 492     public void setResizable(boolean resizable) {
 493         platformWindow.setResizable(resizable);
 494     }
 495 
 496     @Override
 497     public void setState(int state) {
 498         platformWindow.setWindowState(state);
 499     }
 500 
 501     @Override
 502     public int getState() {
 503         return windowState;
 504     }
 505 
 506     @Override
 507     public void setMaximizedBounds(Rectangle bounds) {
 508         // TODO: not implemented
 509     }
 510 
 511     @Override
 512     public void setBoundsPrivate(int x, int y, int width, int height) {
 513         setBounds(x, y, width, height, SET_BOUNDS | NO_EMBEDDED_CHECK);
 514     }
 515 
 516     @Override
 517     public Rectangle getBoundsPrivate() {
 518         throw new RuntimeException("not implemented");
 519     }
 520 
 521     // ---- DIALOG PEER METHODS ---- //
 522 
 523     @Override
 524     public void blockWindows(List<Window> windows) {
 525         //TODO: LWX will probably need some collectJavaToplevels to speed this up
 526         for (Window w : windows) {
 527             WindowPeer wp = (WindowPeer)w.getPeer();
 528             if (wp != null) {
 529                 wp.setModalBlocked((Dialog)getTarget(), true);
 530             }
 531         }
 532     }
 533 
 534     // ---- PEER NOTIFICATIONS ---- //
 535 
 536     public void notifyIconify(boolean iconify) {
 537         //The toplevel target is Frame and states are applicable to it.
 538         //Otherwise, the target is Window and it don't have state property.
 539         //Hopefully, no such events are posted in the queue so consider the
 540         //target as Frame in all cases.
 541 
 542         // REMIND: should we send it anyway if the state not changed since last
 543         // time?
 544         WindowEvent iconifyEvent = new WindowEvent(getTarget(),
 545                 iconify ? WindowEvent.WINDOW_ICONIFIED
 546                         : WindowEvent.WINDOW_DEICONIFIED);
 547         postEvent(iconifyEvent);
 548 
 549         int newWindowState = iconify ? Frame.ICONIFIED : Frame.NORMAL;
 550         postWindowStateChangedEvent(newWindowState);
 551 
 552         // REMIND: RepaintManager doesn't repaint iconified windows and
 553         // hence ignores any repaint request during deiconification.
 554         // So, we need to repaint window explicitly when it becomes normal.
 555         if (!iconify) {
 556             repaintPeer();
 557         }
 558     }
 559 
 560     public void notifyZoom(boolean isZoomed) {
 561         int newWindowState = isZoomed ? Frame.MAXIMIZED_BOTH : Frame.NORMAL;
 562         postWindowStateChangedEvent(newWindowState);
 563     }
 564 
 565     /**
 566      * Called by the delegate when any part of the window should be repainted.
 567      */
 568     public void notifyExpose(final int x, final int y, final int w, final int h) {
 569         // TODO: there's a serious problem with Swing here: it handles
 570         // the exposition internally, so SwingPaintEventDispatcher always
 571         // return null from createPaintEvent(). However, we flush the
 572         // back buffer here unconditionally, so some flickering may appear.
 573         // A possible solution is to split postPaintEvent() into two parts,
 574         // and override that part which is only called after if
 575         // createPaintEvent() returned non-null value and flush the buffer
 576         // from the overridden method
 577         flushOnscreenGraphics();
 578         repaintPeer(new Rectangle(x, y, w, h));
 579     }
 580 
 581     /**
 582      * Called by the delegate when this window is moved/resized by user.
 583      * There's no notifyReshape() in LWComponentPeer as the only
 584      * components which could be resized by user are top-level windows.
 585      */
 586     public final void notifyReshape(int x, int y, int w, int h) {
 587         boolean moved = false;
 588         boolean resized = false;
 589         synchronized (getStateLock()) {
 590             moved = (x != sysX) || (y != sysY);
 591             resized = (w != sysW) || (h != sysH);
 592             sysX = x;
 593             sysY = y;
 594             sysW = w;
 595             sysH = h;
 596         }
 597 
 598         // Check if anything changed
 599         if (!moved && !resized) {
 600             return;
 601         }
 602         // First, update peer's bounds
 603         setBounds(x, y, w, h, SET_BOUNDS, false, false);
 604 
 605         // Second, update the graphics config and surface data
 606         checkIfOnNewScreen();
 607         if (resized) {
 608             replaceSurfaceData();
 609             flushOnscreenGraphics();
 610         }
 611 
 612         // Third, COMPONENT_MOVED/COMPONENT_RESIZED events
 613         if (moved) {
 614             handleMove(x, y, true);
 615         }
 616         if (resized) {
 617             handleResize(w, h,true);
 618         }
 619     }
 620 
 621     private void clearBackground(final int w, final int h) {
 622         final Graphics g = getOnscreenGraphics(getForeground(), getBackground(),
 623                                                getFont());
 624         if (g != null) {
 625             try {
 626                 if (g instanceof Graphics2D) {
 627                     ((Graphics2D) g).setComposite(AlphaComposite.Src);
 628                 }
 629                 if (isTranslucent()) {
 630                     g.setColor(nonOpaqueBackground);
 631                     g.fillRect(0, 0, w, h);
 632                 }
 633                 if (!isTextured()) {
 634                     if (g instanceof SunGraphics2D) {
 635                         SG2DConstraint((SunGraphics2D) g, getRegion());
 636                     }
 637                     g.setColor(getBackground());
 638                     g.fillRect(0, 0, w, h);
 639                 }
 640             } finally {
 641                 g.dispose();
 642             }
 643         }
 644     }
 645 
 646     public void notifyUpdateCursor() {
 647         getLWToolkit().getCursorManager().updateCursorLater(this);
 648     }
 649 
 650     public void notifyActivation(boolean activation) {
 651         changeFocusedWindow(activation);
 652     }
 653 
 654     // MouseDown in non-client area
 655     public void notifyNCMouseDown() {
 656         // Ungrab except for a click on a Dialog with the grabbing owner
 657         if (grabbingWindow != null &&
 658             grabbingWindow != getOwnerFrameDialog(this))
 659         {
 660             grabbingWindow.ungrab();
 661         }
 662     }
 663 
 664     // ---- EVENTS ---- //
 665 
 666     /*
 667      * Called by the delegate to dispatch the event to Java. Event
 668      * coordinates are relative to non-client window are, i.e. the top-left
 669      * point of the client area is (insets.top, insets.left).
 670      */
 671     public void dispatchMouseEvent(int id, long when, int button,
 672                                    int x, int y, int screenX, int screenY,
 673                                    int modifiers, int clickCount, boolean popupTrigger,
 674                                    byte[] bdata)
 675     {
 676         // TODO: fill "bdata" member of AWTEvent
 677         Rectangle r = getBounds();
 678         // findPeerAt() expects parent coordinates
 679         LWComponentPeer targetPeer = findPeerAt(r.x + x, r.y + y);
 680         LWWindowPeer lastWindowPeer =
 681             (lastMouseEventPeer != null) ? lastMouseEventPeer.getWindowPeerOrSelf() : null;
 682         LWWindowPeer curWindowPeer =
 683             (targetPeer != null) ? targetPeer.getWindowPeerOrSelf() : null;
 684 
 685         if (id == MouseEvent.MOUSE_EXITED) {
 686             // We always send the MOUSE_EXITED event to the lastWindowPeer
 687             if (lastWindowPeer != null) {
 688                 if (lastWindowPeer.isEnabled()) {


 689                     Point lp = lastMouseEventPeer.windowToLocal(x, y,
 690                             lastWindowPeer);
 691                     postEvent(new MouseEvent(lastMouseEventPeer.getTarget(),
 692                             MouseEvent.MOUSE_EXITED, when,
 693                             modifiers, lp.x, lp.y, screenX,
 694                             screenY, clickCount, popupTrigger,
 695                             button));
 696                 }
 697                 lastMouseEventPeer = null;
 698             }
 699         } else if(id == MouseEvent.MOUSE_ENTERED) {
 700             if (targetPeer != null) {
 701                 if (targetPeer.isEnabled()) {
 702                     Point lp = targetPeer.windowToLocal(x, y, curWindowPeer);
 703                     postEvent(new MouseEvent(targetPeer.getTarget(),
 704                             MouseEvent.MOUSE_ENTERED, when,
 705                             modifiers, lp.x, lp.y, screenX,
 706                             screenY, clickCount, popupTrigger,
 707                             button));

















 708                 }
 709                 lastMouseEventPeer = targetPeer;
 710             }
 711         } else {
 712             CPlatformWindow topmostPlatforWindow =
 713                     CPlatformWindow.nativeGetTopmostPlatformWindowUnderMouse();
 714             LWWindowPeer topmostWindowPeer =
 715                     topmostPlatforWindow != null ? topmostPlatforWindow.getPeer() : null;
 716 
 717             if (topmostWindowPeer == curWindowPeer) {
 718                 // current window is the topmost window under mouse
 719                 if (targetPeer != lastMouseEventPeer) {
 720                     generateMouseEnterExitEventsForComponents(when, button, x, y,
 721                             screenX, screenY, modifiers, clickCount, popupTrigger,
 722                             lastWindowPeer, curWindowPeer, targetPeer);
 723                 }
 724             } else {
 725                 // the topmost window under mouse is differ from the current window
 726                 LWComponentPeer topmostTargetPeer =
 727                         topmostWindowPeer != null ? topmostWindowPeer.findPeerAt(r.x + x, r.y + y) : null;
 728                 if (topmostTargetPeer != lastMouseEventPeer) {
 729                     generateMouseEnterExitEventsForComponents(when, button, x, y,
 730                             screenX, screenY, modifiers, clickCount, popupTrigger,
 731                             lastWindowPeer, topmostWindowPeer, topmostTargetPeer);
 732                 }

 733             }
 734             // TODO: fill "bdata" member of AWTEvent
 735 
 736             int eventButtonMask = (button > 0)? MouseEvent.getMaskForButton(button) : 0;
 737             int otherButtonsPressed = modifiers & ~eventButtonMask;
 738 
 739             // For pressed/dragged/released events OS X treats other
 740             // mouse buttons as if they were BUTTON2, so we do the same
 741             int targetIdx = (button > 3) ? MouseEvent.BUTTON2 - 1 : button - 1;
 742 
 743             // MOUSE_ENTERED/EXITED are generated for the components strictly under
 744             // mouse even when dragging. That's why we first update lastMouseEventPeer
 745             // based on initial targetPeer value and only then recalculate targetPeer
 746             // for MOUSE_DRAGGED/RELEASED events
 747             if (id == MouseEvent.MOUSE_PRESSED) {
 748 
 749                 // Ungrab only if this window is not an owned window of the grabbing one.
 750                 if (!isGrabbing() && grabbingWindow != null &&
 751                     grabbingWindow != getOwnerFrameDialog(this))
 752                 {
 753                     grabbingWindow.ungrab();
 754                 }
 755                 if (otherButtonsPressed == 0) {
 756                     mouseClickButtons = eventButtonMask;
 757                 } else {
 758                     mouseClickButtons |= eventButtonMask;
 759                 }
 760 
 761                 mouseDownTarget[targetIdx] = targetPeer;
 762             } else if (id == MouseEvent.MOUSE_DRAGGED) {
 763                 // Cocoa dragged event has the information about which mouse
 764                 // button is being dragged. Use it to determine the peer that
 765                 // should receive the dragged event.
 766                 targetPeer = mouseDownTarget[targetIdx];
 767                 mouseClickButtons &= ~modifiers;
 768             } else if (id == MouseEvent.MOUSE_RELEASED) {
 769                 // TODO: currently, mouse released event goes to the same component
 770                 // that received corresponding mouse pressed event. For most cases,
 771                 // it's OK, however, we need to make sure that our behavior is consistent
 772                 // with 1.6 for cases where component in question have been
 773                 // hidden/removed in between of mouse pressed/released events.
 774                 targetPeer = mouseDownTarget[targetIdx];
 775 
 776                 if ((modifiers & eventButtonMask) == 0) {
 777                     mouseDownTarget[targetIdx] = null;
 778                 }
 779 
 780                 // mouseClickButtons is updated below, after MOUSE_CLICK is sent
 781             }
 782 
 783             // check if we receive mouseEvent from outside the window's bounds
 784             // it can be either mouseDragged or mouseReleased
 785             if (curWindowPeer == null) {
 786                 //TODO This can happen if this window is invisible. this is correct behavior in this case?
 787                 curWindowPeer = this;
 788             }
 789             if (targetPeer == null) {
 790                 //TODO This can happen if this window is invisible. this is correct behavior in this case?
 791                 targetPeer = this;
 792             }
 793 
 794 
 795             Point lp = targetPeer.windowToLocal(x, y, curWindowPeer);
 796             if (targetPeer.isEnabled()) {
 797                 MouseEvent event = new MouseEvent(targetPeer.getTarget(), id,
 798                                                   when, modifiers, lp.x, lp.y,
 799                                                   screenX, screenY, clickCount,
 800                                                   popupTrigger, button);
 801                 postEvent(event);
 802             }
 803 
 804             if (id == MouseEvent.MOUSE_RELEASED) {
 805                 if ((mouseClickButtons & eventButtonMask) != 0
 806                     && targetPeer.isEnabled()) {
 807                     postEvent(new MouseEvent(targetPeer.getTarget(),
 808                                              MouseEvent.MOUSE_CLICKED,
 809                                              when, modifiers,
 810                                              lp.x, lp.y, screenX, screenY,
 811                                              clickCount, popupTrigger, button));
 812                 }
 813                 mouseClickButtons &= ~eventButtonMask;
 814             }
 815         }
 816         notifyUpdateCursor();
 817     }
 818 
 819     private void generateMouseEnterExitEventsForComponents(long when,
 820             int button, int x, int y, int screenX, int screenY,
 821             int modifiers, int clickCount, boolean popupTrigger,
 822             LWWindowPeer lastWindowPeer,
 823             LWWindowPeer targetWindowPeer, LWComponentPeer targetPeer) {
 824 
 825         // Generate Mouse Exit for components
 826         if (lastMouseEventPeer != null && lastMouseEventPeer.isEnabled()) {
 827             // Sometimes, MOUSE_EXITED is not sent by delegate (or is sent a bit
 828             // later), in which case lastWindowPeer is another window
 829             if (lastWindowPeer != targetWindowPeer) {
 830                 Point oldp = lastMouseEventPeer.windowToLocal(x, y, lastWindowPeer);
 831                 // Additionally translate from this to lastWindowPeer coordinates
 832                 Rectangle r = getBounds();
 833                 Rectangle lr = lastWindowPeer.getBounds();
 834                 oldp.x += r.x - lr.x;
 835                 oldp.y += r.y - lr.y;
 836                 postEvent(new MouseEvent(lastMouseEventPeer.getTarget(),
 837                         MouseEvent.MOUSE_EXITED,
 838                         when, modifiers,
 839                         oldp.x, oldp.y, screenX, screenY,
 840                         clickCount, popupTrigger, button));
 841             } else {
 842                 Point oldp = lastMouseEventPeer.windowToLocal(x, y, lastWindowPeer);
 843                 postEvent(new MouseEvent(lastMouseEventPeer.getTarget(),
 844                         MouseEvent.MOUSE_EXITED,
 845                         when, modifiers,
 846                         oldp.x, oldp.y, screenX, screenY,
 847                         clickCount, popupTrigger, button));
 848             }
 849         }
 850         lastMouseEventPeer = targetPeer;
 851         // Generate Mouse Enter for components
 852         if (targetPeer != null && targetPeer.isEnabled()) {
 853             Point newp = targetPeer.windowToLocal(x, y, targetWindowPeer);
 854             postEvent(new MouseEvent(targetPeer.getTarget(),
 855                     MouseEvent.MOUSE_ENTERED,
 856                     when, modifiers,
 857                     newp.x, newp.y, screenX, screenY,
 858                     clickCount, popupTrigger, button));
 859         }
 860     }
 861 
 862     public void dispatchMouseWheelEvent(long when, int x, int y, int modifiers,
 863                                         int scrollType, int scrollAmount,
 864                                         int wheelRotation, double preciseWheelRotation,
 865                                         byte[] bdata)
 866     {
 867         // TODO: could we just use the last mouse event target here?
 868         Rectangle r = getBounds();
 869         // findPeerAt() expects parent coordinates
 870         final LWComponentPeer targetPeer = findPeerAt(r.x + x, r.y + y);
 871         if (targetPeer == null || !targetPeer.isEnabled()) {
 872             return;
 873         }
 874 
 875         Point lp = targetPeer.windowToLocal(x, y, this);
 876         // TODO: fill "bdata" member of AWTEvent
 877         // TODO: screenX/screenY
 878         postEvent(new MouseWheelEvent(targetPeer.getTarget(),
 879                                       MouseEvent.MOUSE_WHEEL,
 880                                       when, modifiers,
 881                                       lp.x, lp.y,
 882                                       0, 0, /* screenX, Y */
 883                                       0 /* clickCount */, false /* popupTrigger */,
 884                                       scrollType, scrollAmount,
 885                                       wheelRotation, preciseWheelRotation));
 886     }
 887 
 888     /*
 889      * Called by the delegate when a key is pressed.
 890      */
 891     public void dispatchKeyEvent(int id, long when, int modifiers,
 892                                  int keyCode, char keyChar, int keyLocation)
 893     {
 894         LWComponentPeer focusOwner =
 895             LWKeyboardFocusManagerPeer.getInstance(getAppContext()).
 896                 getFocusOwner();
 897 
 898         // Null focus owner may receive key event when
 899         // application hides the focused window upon ESC press
 900         // (AWT transfers/clears the focus owner) and pending ESC release
 901         // may come to already hidden window. This check eliminates NPE.
 902         if (focusOwner != null) {
 903             KeyEvent event =
 904                 new KeyEvent(focusOwner.getTarget(), id, when, modifiers,
 905                              keyCode, keyChar, keyLocation);
 906             focusOwner.postEvent(event);
 907         }
 908     }
 909 
 910 
 911     // ---- UTILITY METHODS ---- //
 912 
 913     private void postWindowStateChangedEvent(int newWindowState) {
 914         if (getTarget() instanceof Frame) {
 915             AWTAccessor.getFrameAccessor().setExtendedState(
 916                     (Frame)getTarget(), newWindowState);
 917         }
 918         WindowEvent stateChangedEvent = new WindowEvent(getTarget(),
 919                 WindowEvent.WINDOW_STATE_CHANGED,
 920                 windowState, newWindowState);
 921         postEvent(stateChangedEvent);
 922         windowState = newWindowState;
 923     }
 924 
 925     private static int getGraphicsConfigScreen(GraphicsConfiguration gc) {
 926         // TODO: this method can be implemented in a more
 927         // efficient way by forwarding to the delegate
 928         GraphicsDevice gd = gc.getDevice();
 929         GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
 930         GraphicsDevice[] gds = ge.getScreenDevices();
 931         for (int i = 0; i < gds.length; i++) {
 932             if (gds[i] == gd) {
 933                 return i;
 934             }
 935         }
 936         // Should never happen if gc is a screen device config
 937         return 0;
 938     }
 939 
 940     /*
 941      * This method is called when window's graphics config is changed from
 942      * the app code (e.g. when the window is made non-opaque) or when
 943      * the window is moved to another screen by user.
 944      *
 945      * Returns true if the graphics config has been changed, false otherwise.
 946      */
 947     private boolean setGraphicsConfig(GraphicsConfiguration gc) {
 948         synchronized (getStateLock()) {
 949             if (graphicsConfig == gc) {
 950                 return false;
 951             }
 952             // If window's graphics config is changed from the app code, the
 953             // config correspond to the same device as before; when the window
 954             // is moved by user, graphicsDevice is updated in checkIfOnNewScreen().
 955             // In either case, there's nothing to do with screenOn here
 956             graphicsConfig = gc;
 957         }
 958         // SurfaceData is replaced later in updateGraphicsData()
 959         return true;
 960     }
 961 
 962     private void checkIfOnNewScreen() {
 963         GraphicsDevice newGraphicsDevice = platformWindow.getGraphicsDevice();
 964         synchronized (getStateLock()) {
 965             if (graphicsDevice == newGraphicsDevice) {
 966                 return;
 967             }
 968             graphicsDevice = newGraphicsDevice;
 969         }
 970 
 971         // TODO: DisplayChangedListener stuff
 972         final GraphicsConfiguration newGC = newGraphicsDevice.getDefaultConfiguration();
 973 
 974         if (!setGraphicsConfig(newGC)) return;
 975 
 976         SunToolkit.executeOnEventHandlerThread(getTarget(), new Runnable() {
 977             public void run() {
 978                 AWTAccessor.getComponentAccessor().setGraphicsConfiguration(getTarget(), newGC);
 979             }
 980         });
 981     }
 982 
 983     /*
 984      * May be called by delegate to provide SD to Java2D code.
 985      */
 986     public SurfaceData getSurfaceData() {
 987         synchronized (surfaceDataLock) {
 988             return surfaceData;
 989         }
 990     }
 991 
 992     private void replaceSurfaceData() {
 993         replaceSurfaceData(true);
 994     }
 995 
 996     private void replaceSurfaceData(boolean blit) {
 997         replaceSurfaceData(backBufferCount, backBufferCaps, blit);
 998     }
 999 
1000     private void replaceSurfaceData(int newBackBufferCount,
1001                                     BufferCapabilities newBackBufferCaps,
1002                                     boolean blit) {
1003         synchronized (surfaceDataLock) {
1004             final SurfaceData oldData = getSurfaceData();
1005             surfaceData = platformWindow.replaceSurfaceData();
1006             // TODO: volatile image
1007     //        VolatileImage oldBB = backBuffer;
1008             BufferedImage oldBB = backBuffer;
1009             backBufferCount = newBackBufferCount;
1010             backBufferCaps = newBackBufferCaps;
1011             final Rectangle size = getSize();
1012             if (getSurfaceData() != null && oldData != getSurfaceData()) {
1013                 clearBackground(size.width, size.height);
1014             }
1015 
1016             if (blit) {
1017                 blitSurfaceData(oldData, getSurfaceData());
1018             }
1019 
1020             if (oldData != null && oldData != getSurfaceData()) {
1021                 // TODO: drop oldData for D3D/WGL pipelines
1022                 // This can only happen when this peer is being created
1023                 oldData.flush();
1024             }
1025 
1026             // TODO: volatile image
1027     //        backBuffer = (VolatileImage)delegate.createBackBuffer();
1028             backBuffer = (BufferedImage) platformWindow.createBackBuffer();
1029             if (backBuffer != null) {
1030                 Graphics g = backBuffer.getGraphics();
1031                 try {
1032                     Rectangle r = getBounds();
1033                     if (g instanceof Graphics2D) {
1034                         ((Graphics2D) g).setComposite(AlphaComposite.Src);
1035                     }
1036                     g.setColor(nonOpaqueBackground);
1037                     g.fillRect(0, 0, r.width, r.height);
1038                     if (g instanceof SunGraphics2D) {
1039                         SG2DConstraint((SunGraphics2D) g, getRegion());
1040                     }
1041                     if (!isTextured()) {
1042                         g.setColor(getBackground());
1043                         g.fillRect(0, 0, r.width, r.height);
1044                     }
1045                     if (oldBB != null) {
1046                         // Draw the old back buffer to the new one
1047                         g.drawImage(oldBB, 0, 0, null);
1048                         oldBB.flush();
1049                     }
1050                 } finally {
1051                     g.dispose();
1052                 }
1053             }
1054         }
1055     }
1056 
1057     private void blitSurfaceData(final SurfaceData src, final SurfaceData dst) {
1058         //TODO blit. proof-of-concept
1059         if (src != dst && src != null && dst != null
1060             && !(dst instanceof NullSurfaceData)
1061             && !(src instanceof NullSurfaceData)
1062             && src.getSurfaceType().equals(dst.getSurfaceType())) {
1063             final Rectangle size = getSize();
1064             final Blit blit = Blit.locate(src.getSurfaceType(),
1065                                           CompositeType.Src,
1066                                           dst.getSurfaceType());
1067             if (blit != null) {
1068                 blit.Blit(src, dst, AlphaComposite.Src,
1069                           getRegion(), 0, 0, 0, 0, size.width, size.height);
1070             }
1071         }
1072     }
1073 
1074     public int getBackBufferCount() {
1075         return backBufferCount;
1076     }
1077 
1078     public BufferCapabilities getBackBufferCaps() {
1079         return backBufferCaps;
1080     }
1081 
1082     /*
1083      * Request the window insets from the delegate and compares it
1084      * with the current one. This method is mostly called by the
1085      * delegate, e.g. when the window state is changed and insets
1086      * should be recalculated.
1087      *
1088      * This method may be called on the toolkit thread.
1089      */
1090     public boolean updateInsets(Insets newInsets) {
1091         boolean changed = false;
1092         synchronized (getStateLock()) {
1093             changed = (insets.equals(newInsets));
1094             insets = newInsets;
1095         }
1096 
1097         if (changed) {
1098             replaceSurfaceData();
1099             repaintPeer();
1100         }
1101 
1102         return changed;
1103     }
1104 
1105     public static LWWindowPeer getWindowUnderCursor() {
1106         return lastMouseEventPeer != null ? lastMouseEventPeer.getWindowPeerOrSelf() : null;
1107     }
1108 
1109     public static LWComponentPeer<?, ?> getPeerUnderCursor() {
1110         return lastMouseEventPeer;
1111     }
1112 
1113     /*
1114      * Requests platform to set native focus on a frame/dialog.
1115      * In case of a simple window, triggers appropriate java focus change.
1116      */
1117     public boolean requestWindowFocus(CausedFocusEvent.Cause cause) {
1118         if (focusLog.isLoggable(PlatformLogger.FINE)) {
1119             focusLog.fine("requesting native focus to " + this);
1120         }
1121 
1122         if (!focusAllowedFor()) {
1123             focusLog.fine("focus is not allowed");
1124             return false;
1125         }
1126 
1127         if (platformWindow.rejectFocusRequest(cause)) {
1128             return false;
1129         }
1130 
1131         Window currentActive = KeyboardFocusManager.
1132             getCurrentKeyboardFocusManager().getActiveWindow();
1133 
1134         // Make the owner active window.
1135         if (isSimpleWindow()) {
1136             LWWindowPeer owner = getOwnerFrameDialog(this);
1137 
1138             // If owner is not natively active, request native
1139             // activation on it w/o sending events up to java.
1140             if (owner != null && !owner.platformWindow.isActive()) {
1141                 if (focusLog.isLoggable(PlatformLogger.FINE)) {
1142                     focusLog.fine("requesting native focus to the owner " + owner);
1143                 }
1144                 LWWindowPeer currentActivePeer = (currentActive != null ?
1145                     (LWWindowPeer)currentActive.getPeer() : null);
1146 
1147                 // Ensure the opposite is natively active and suppress sending events.
1148                 if (currentActivePeer != null && currentActivePeer.platformWindow.isActive()) {
1149                     if (focusLog.isLoggable(PlatformLogger.FINE)) {
1150                         focusLog.fine("the opposite is " + currentActivePeer);
1151                     }
1152                     currentActivePeer.skipNextFocusChange = true;
1153                 }
1154                 owner.skipNextFocusChange = true;
1155 
1156                 owner.platformWindow.requestWindowFocus();
1157             }
1158 
1159             // DKFM will synthesize all the focus/activation events correctly.
1160             changeFocusedWindow(true);
1161             return true;
1162 
1163         // In case the toplevel is active but not focused, change focus directly,
1164         // as requesting native focus on it will not have effect.
1165         } else if (getTarget() == currentActive && !getTarget().hasFocus()) {
1166 
1167             changeFocusedWindow(true);
1168             return true;
1169         }
1170         return platformWindow.requestWindowFocus();
1171     }
1172 
1173     private boolean focusAllowedFor() {
1174         Window window = getTarget();
1175         // TODO: check if modal blocked
1176         return window.isVisible() && window.isEnabled() && isFocusableWindow();
1177     }
1178 
1179     private boolean isFocusableWindow() {
1180         boolean focusable = getTarget().isFocusableWindow();
1181         if (isSimpleWindow()) {
1182             LWWindowPeer ownerPeer = getOwnerFrameDialog(this);
1183             if (ownerPeer == null) {
1184                 return false;
1185             }
1186             return focusable && ownerPeer.getTarget().isFocusableWindow();
1187         }
1188         return focusable;
1189     }
1190 
1191     public boolean isSimpleWindow() {
1192         Window window = getTarget();
1193         return !(window instanceof Dialog || window instanceof Frame);
1194     }
1195 
1196     /*
1197      * Changes focused window on java level.
1198      */
1199     private void changeFocusedWindow(boolean becomesFocused) {
1200         if (focusLog.isLoggable(PlatformLogger.FINE)) {
1201             focusLog.fine((becomesFocused?"gaining":"loosing") + " focus window: " + this);
1202         }
1203         if (skipNextFocusChange) {
1204             focusLog.fine("skipping focus change");
1205             skipNextFocusChange = false;
1206             return;
1207         }
1208         if (!isFocusableWindow() && becomesFocused) {
1209             focusLog.fine("the window is not focusable");
1210             return;
1211         }
1212         if (becomesFocused) {
1213             synchronized (getPeerTreeLock()) {
1214                 if (blocker != null) {
1215                     if (focusLog.isLoggable(PlatformLogger.FINEST)) {
1216                         focusLog.finest("the window is blocked by " + blocker);
1217                     }
1218                     return;
1219                 }
1220             }
1221         }
1222 
1223         LWKeyboardFocusManagerPeer manager = LWKeyboardFocusManagerPeer.
1224             getInstance(getAppContext());
1225 
1226         Window oppositeWindow = becomesFocused ? manager.getCurrentFocusedWindow() : null;
1227 
1228         // Note, the method is not called:
1229         // - when the opposite (gaining focus) window is an owned/owner window.
1230         // - for a simple window in any case.
1231         if (!becomesFocused &&
1232             (isGrabbing() || getOwnerFrameDialog(grabbingWindow) == this))
1233         {
1234             focusLog.fine("ungrabbing on " + grabbingWindow);
1235             // ungrab a simple window if its owner looses activation.
1236             grabbingWindow.ungrab();
1237         }
1238 
1239         manager.setFocusedWindow(becomesFocused ? LWWindowPeer.this : null);
1240 
1241         int eventID = becomesFocused ? WindowEvent.WINDOW_GAINED_FOCUS : WindowEvent.WINDOW_LOST_FOCUS;
1242         WindowEvent windowEvent = new WindowEvent(getTarget(), eventID, oppositeWindow);
1243 
1244         // TODO: wrap in SequencedEvent
1245         postEvent(windowEvent);
1246     }
1247 
1248     static LWWindowPeer getOwnerFrameDialog(LWWindowPeer peer) {
1249         Window owner = (peer != null ? peer.getTarget().getOwner() : null);
1250         while (owner != null && !(owner instanceof Frame || owner instanceof Dialog)) {
1251             owner = owner.getOwner();
1252         }
1253         return owner != null ? (LWWindowPeer)owner.getPeer() : null;
1254     }
1255 
1256     /**
1257      * Returns the foremost modal blocker of this window, or null.
1258      */
1259     public LWWindowPeer getBlocker() {
1260         synchronized (getPeerTreeLock()) {
1261             LWWindowPeer blocker = this.blocker;
1262             if (blocker == null) {
1263                 return null;
1264             }
1265             while (blocker.blocker != null) {
1266                 blocker = blocker.blocker;
1267             }
1268             return blocker;
1269         }
1270     }
1271 
1272     public void enterFullScreenMode() {
1273         platformWindow.enterFullScreenMode();
1274     }
1275 
1276     public void exitFullScreenMode() {
1277         platformWindow.exitFullScreenMode();
1278     }
1279 
1280     public long getLayerPtr() {
1281         return getPlatformWindow().getLayerPtr();
1282     }
1283 
1284     void grab() {
1285         if (grabbingWindow != null && !isGrabbing()) {
1286             grabbingWindow.ungrab();
1287         }
1288         grabbingWindow = this;
1289     }
1290 
1291     void ungrab() {
1292         if (isGrabbing()) {
1293             grabbingWindow = null;
1294             postEvent(new UngrabEvent(getTarget()));
1295         }
1296     }
1297 
1298     private boolean isGrabbing() {
1299         return this == grabbingWindow;
1300     }
1301 
1302     @Override
1303     public String toString() {
1304         return super.toString() + " [target is " + getTarget() + "]";
1305     }
1306 }
--- EOF ---