1 /*
   2  * Copyright (c) 2011, 2017, 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.macosx;
  27 
  28 import java.awt.Color;
  29 import java.awt.Component;
  30 import java.awt.DefaultKeyboardFocusManager;
  31 import java.awt.Dialog;
  32 import java.awt.Dialog.ModalityType;
  33 import java.awt.Font;
  34 import java.awt.FontMetrics;
  35 import java.awt.Frame;
  36 import java.awt.GraphicsDevice;
  37 import java.awt.Insets;
  38 import java.awt.MenuBar;
  39 import java.awt.Point;
  40 import java.awt.Rectangle;
  41 import java.awt.Toolkit;
  42 import java.awt.Window;
  43 import java.awt.event.FocusEvent;
  44 import java.awt.event.WindowEvent;
  45 import java.beans.PropertyChangeEvent;
  46 import java.beans.PropertyChangeListener;
  47 import java.lang.reflect.InvocationTargetException;
  48 import java.util.ArrayList;
  49 import java.util.Arrays;
  50 import java.util.Comparator;
  51 import java.util.concurrent.atomic.AtomicBoolean;
  52 import java.util.concurrent.atomic.AtomicLong;
  53 import java.util.concurrent.atomic.AtomicReference;
  54 
  55 import javax.swing.JRootPane;
  56 import javax.swing.RootPaneContainer;
  57 import javax.swing.SwingUtilities;
  58 
  59 import com.apple.laf.ClientPropertyApplicator;
  60 import com.apple.laf.ClientPropertyApplicator.Property;
  61 import sun.awt.AWTAccessor;
  62 import sun.awt.AWTAccessor.ComponentAccessor;
  63 import sun.awt.AWTAccessor.WindowAccessor;
  64 import sun.java2d.SurfaceData;
  65 import sun.java2d.opengl.CGLSurfaceData;
  66 import sun.lwawt.LWLightweightFramePeer;
  67 import sun.lwawt.LWToolkit;
  68 import sun.lwawt.LWWindowPeer;
  69 import sun.lwawt.LWWindowPeer.PeerType;
  70 import sun.lwawt.PlatformWindow;
  71 import sun.util.logging.PlatformLogger;
  72 
  73 public class CPlatformWindow extends CFRetainedResource implements PlatformWindow {
  74     private native long nativeCreateNSWindow(long nsViewPtr,long ownerPtr, long styleBits, double x, double y, double w, double h);
  75     private static native void nativeSetNSWindowStyleBits(long nsWindowPtr, int mask, int data);
  76     private static native void nativeSetNSWindowMenuBar(long nsWindowPtr, long menuBarPtr);
  77     private static native Insets nativeGetNSWindowInsets(long nsWindowPtr);
  78     private static native void nativeSetNSWindowBounds(long nsWindowPtr, double x, double y, double w, double h);
  79     private static native void nativeSetNSWindowLocationByPlatform(long nsWindowPtr);
  80     private static native void nativeSetNSWindowStandardFrame(long nsWindowPtr,
  81             double x, double y, double w, double h);
  82     private static native void nativeSetNSWindowMinMax(long nsWindowPtr, double minW, double minH, double maxW, double maxH);
  83     private static native void nativePushNSWindowToBack(long nsWindowPtr);
  84     private static native void nativePushNSWindowToFront(long nsWindowPtr);
  85     private static native void nativeSetNSWindowTitle(long nsWindowPtr, String title);
  86     private static native void nativeRevalidateNSWindowShadow(long nsWindowPtr);
  87     private static native void nativeSetNSWindowMinimizedIcon(long nsWindowPtr, long nsImage);
  88     private static native void nativeSetNSWindowRepresentedFilename(long nsWindowPtr, String representedFilename);
  89     private static native void nativeSetEnabled(long nsWindowPtr, boolean isEnabled);
  90     private static native void nativeSynthesizeMouseEnteredExitedEvents();
  91     private static native void nativeSynthesizeMouseEnteredExitedEvents(long nsWindowPtr, int eventType);
  92     private static native void nativeDispose(long nsWindowPtr);
  93     private static native void nativeEnterFullScreenMode(long nsWindowPtr);
  94     private static native void nativeExitFullScreenMode(long nsWindowPtr);
  95     static native CPlatformWindow nativeGetTopmostPlatformWindowUnderMouse();
  96 
  97     // Loger to report issues happened during execution but that do not affect functionality
  98     private static final PlatformLogger logger = PlatformLogger.getLogger("sun.lwawt.macosx.CPlatformWindow");
  99     private static final PlatformLogger focusLogger = PlatformLogger.getLogger("sun.lwawt.macosx.focus.CPlatformWindow");
 100 
 101     // for client properties
 102     public static final String WINDOW_BRUSH_METAL_LOOK = "apple.awt.brushMetalLook";
 103     public static final String WINDOW_DRAGGABLE_BACKGROUND = "apple.awt.draggableWindowBackground";

 104 
 105     public static final String WINDOW_ALPHA = "Window.alpha";
 106     public static final String WINDOW_SHADOW = "Window.shadow";
 107 
 108     public static final String WINDOW_STYLE = "Window.style";
 109     public static final String WINDOW_SHADOW_REVALIDATE_NOW = "apple.awt.windowShadow.revalidateNow";
 110 
 111     public static final String WINDOW_DOCUMENT_MODIFIED = "Window.documentModified";
 112     public static final String WINDOW_DOCUMENT_FILE = "Window.documentFile";
 113 
 114     public static final String WINDOW_CLOSEABLE = "Window.closeable";
 115     public static final String WINDOW_MINIMIZABLE = "Window.minimizable";
 116     public static final String WINDOW_ZOOMABLE = "Window.zoomable";
 117     public static final String WINDOW_HIDES_ON_DEACTIVATE="Window.hidesOnDeactivate";
 118 
 119     public static final String WINDOW_DOC_MODAL_SHEET = "apple.awt.documentModalSheet";
 120     public static final String WINDOW_FADE_DELEGATE = "apple.awt._windowFadeDelegate";
 121     public static final String WINDOW_FADE_IN = "apple.awt._windowFadeIn";
 122     public static final String WINDOW_FADE_OUT = "apple.awt._windowFadeOut";
 123     public static final String WINDOW_FULLSCREENABLE = "apple.awt.fullscreenable";
 124 
 125 
 126     // Yeah, I know. But it's easier to deal with ints from JNI
 127     static final int MODELESS = 0;
 128     static final int DOCUMENT_MODAL = 1;
 129     static final int APPLICATION_MODAL = 2;
 130     static final int TOOLKIT_MODAL = 3;
 131 
 132     // window style bits
 133     static final int _RESERVED_FOR_DATA = 1 << 0;
 134 
 135     // corresponds to native style mask bits
 136     static final int DECORATED = 1 << 1;
 137     static final int TEXTURED = 1 << 2;
 138     static final int UNIFIED = 1 << 3;
 139     static final int UTILITY = 1 << 4;
 140     static final int HUD = 1 << 5;
 141     static final int SHEET = 1 << 6;
 142 
 143     static final int CLOSEABLE = 1 << 7;
 144     static final int MINIMIZABLE = 1 << 8;
 145 
 146     static final int RESIZABLE = 1 << 9; // both a style bit and prop bit
 147     static final int NONACTIVATING = 1 << 24;
 148     static final int IS_DIALOG = 1 << 25;
 149     static final int IS_MODAL = 1 << 26;
 150     static final int IS_POPUP = 1 << 27;

 151 
 152     static final int _STYLE_PROP_BITMASK = DECORATED | TEXTURED | UNIFIED | UTILITY | HUD | SHEET | CLOSEABLE | MINIMIZABLE | RESIZABLE;
 153 
 154     // corresponds to method-based properties
 155     static final int HAS_SHADOW = 1 << 10;
 156     static final int ZOOMABLE = 1 << 11;
 157 
 158     static final int ALWAYS_ON_TOP = 1 << 15;
 159     static final int HIDES_ON_DEACTIVATE = 1 << 17;
 160     static final int DRAGGABLE_BACKGROUND = 1 << 19;
 161     static final int DOCUMENT_MODIFIED = 1 << 21;
 162     static final int FULLSCREENABLE = 1 << 23;
 163 
 164     static final int _METHOD_PROP_BITMASK = RESIZABLE | HAS_SHADOW | ZOOMABLE | ALWAYS_ON_TOP | HIDES_ON_DEACTIVATE | DRAGGABLE_BACKGROUND | DOCUMENT_MODIFIED | FULLSCREENABLE;
 165 
 166     // corresponds to callback-based properties
 167     static final int SHOULD_BECOME_KEY = 1 << 12;
 168     static final int SHOULD_BECOME_MAIN = 1 << 13;
 169     static final int MODAL_EXCLUDED = 1 << 16;
 170 
 171     static final int _CALLBACK_PROP_BITMASK = SHOULD_BECOME_KEY | SHOULD_BECOME_MAIN | MODAL_EXCLUDED;
 172 
 173     static int SET(final int bits, final int mask, final boolean value) {
 174         if (value) return (bits | mask);
 175         return bits & ~mask;
 176     }
 177 
 178     static boolean IS(final int bits, final int mask) {
 179         return (bits & mask) != 0;
 180     }
 181 
 182     @SuppressWarnings({"unchecked", "rawtypes"})
 183     static ClientPropertyApplicator<JRootPane, CPlatformWindow> CLIENT_PROPERTY_APPLICATOR = new ClientPropertyApplicator<JRootPane, CPlatformWindow>(new Property[] {
 184         new Property<CPlatformWindow>(WINDOW_DOCUMENT_MODIFIED) { public void applyProperty(final CPlatformWindow c, final Object value) {
 185             c.setStyleBits(DOCUMENT_MODIFIED, value == null ? false : Boolean.parseBoolean(value.toString()));
 186         }},
 187         new Property<CPlatformWindow>(WINDOW_BRUSH_METAL_LOOK) { public void applyProperty(final CPlatformWindow c, final Object value) {
 188             c.setStyleBits(TEXTURED, Boolean.parseBoolean(value.toString()));
 189         }},
 190         new Property<CPlatformWindow>(WINDOW_ALPHA) { public void applyProperty(final CPlatformWindow c, final Object value) {
 191             c.target.setOpacity(value == null ? 1.0f : Float.parseFloat(value.toString()));
 192         }},
 193         new Property<CPlatformWindow>(WINDOW_SHADOW) { public void applyProperty(final CPlatformWindow c, final Object value) {
 194             c.setStyleBits(HAS_SHADOW, value == null ? true : Boolean.parseBoolean(value.toString()));
 195         }},
 196         new Property<CPlatformWindow>(WINDOW_MINIMIZABLE) { public void applyProperty(final CPlatformWindow c, final Object value) {
 197             c.setStyleBits(MINIMIZABLE, Boolean.parseBoolean(value.toString()));
 198         }},
 199         new Property<CPlatformWindow>(WINDOW_CLOSEABLE) { public void applyProperty(final CPlatformWindow c, final Object value) {
 200             c.setStyleBits(CLOSEABLE, Boolean.parseBoolean(value.toString()));
 201         }},
 202         new Property<CPlatformWindow>(WINDOW_ZOOMABLE) { public void applyProperty(final CPlatformWindow c, final Object value) {
 203             boolean zoomable = Boolean.parseBoolean(value.toString());
 204             if (c.target instanceof RootPaneContainer
 205                     && c.getPeer().getPeerType() == PeerType.FRAME) {
 206                 if (c.isInFullScreen && !zoomable) {
 207                     c.toggleFullScreen();
 208                 }
 209             }
 210             c.setStyleBits(ZOOMABLE, zoomable);
 211         }},
 212         new Property<CPlatformWindow>(WINDOW_FULLSCREENABLE) { public void applyProperty(final CPlatformWindow c, final Object value) {
 213             boolean fullscrenable = Boolean.parseBoolean(value.toString());
 214             if (c.target instanceof RootPaneContainer
 215                     && c.getPeer().getPeerType() == PeerType.FRAME) {
 216                 if (c.isInFullScreen && !fullscrenable) {
 217                     c.toggleFullScreen();
 218                 }
 219             }
 220             c.setStyleBits(FULLSCREENABLE, fullscrenable);
 221         }},
 222         new Property<CPlatformWindow>(WINDOW_SHADOW_REVALIDATE_NOW) { public void applyProperty(final CPlatformWindow c, final Object value) {
 223             c.execute(ptr -> nativeRevalidateNSWindowShadow(ptr));
 224         }},
 225         new Property<CPlatformWindow>(WINDOW_DOCUMENT_FILE) { public void applyProperty(final CPlatformWindow c, final Object value) {
 226             if (value == null || !(value instanceof java.io.File)) {
 227                 c.execute(ptr->nativeSetNSWindowRepresentedFilename(ptr, null));
 228                 return;
 229             }
 230 
 231             final String filename = ((java.io.File)value).getAbsolutePath();
 232             c.execute(ptr->nativeSetNSWindowRepresentedFilename(ptr, filename));
 233         }}



 234     }) {
 235         @SuppressWarnings("deprecation")
 236         public CPlatformWindow convertJComponentToTarget(final JRootPane p) {
 237             Component root = SwingUtilities.getRoot(p);
 238             final ComponentAccessor acc = AWTAccessor.getComponentAccessor();
 239             if (root == null || acc.getPeer(root) == null) return null;
 240             return (CPlatformWindow)((LWWindowPeer)acc.getPeer(root)).getPlatformWindow();
 241         }
 242     };
 243     private final Comparator<Window> siblingsComparator = (w1, w2) -> {
 244         if (w1 == w2) {
 245             return 0;
 246         }
 247         ComponentAccessor componentAccessor = AWTAccessor.getComponentAccessor();
 248         Object p1 = componentAccessor.getPeer(w1);
 249         Object p2 = componentAccessor.getPeer(w2);
 250         if (p1 instanceof LWWindowPeer && p2 instanceof LWWindowPeer) {
 251             return Long.compare(
 252                     ((CPlatformWindow) (((LWWindowPeer) p1).getPlatformWindow())).lastBecomeMainTime,
 253                     ((CPlatformWindow) (((LWWindowPeer) p2).getPlatformWindow())).lastBecomeMainTime);
 254         }
 255         return 0;
 256     };
 257 
 258     // Bounds of the native widget but in the Java coordinate system.
 259     // In order to keep it up-to-date we will update them on
 260     // 1) setting native bounds via nativeSetBounds() call
 261     // 2) getting notification from the native level via deliverMoveResizeEvent()
 262     private Rectangle nativeBounds = new Rectangle(0, 0, 0, 0);
 263     private volatile boolean isFullScreenMode;
 264     private boolean isFullScreenAnimationOn;
 265 
 266     private volatile boolean isInFullScreen;
 267     private volatile boolean isIconifyAnimationActive;
 268     private volatile boolean isZoomed;
 269 
 270     private Window target;
 271     private LWWindowPeer peer;
 272     protected CPlatformView contentView;
 273     protected CPlatformWindow owner;
 274     protected boolean visible = false; // visibility status from native perspective
 275     private boolean undecorated; // initialized in getInitialStyleBits()
 276     private Rectangle normalBounds = null; // not-null only for undecorated maximized windows
 277     private CPlatformResponder responder;
 278     private long lastBecomeMainTime; // this is necessary to preserve right siblings order
 279 
 280     public CPlatformWindow() {
 281         super(0, true);
 282     }
 283 
 284     /*
 285      * Delegate initialization (create native window and all the
 286      * related resources).
 287      */
 288     @Override // PlatformWindow
 289     public void initialize(Window _target, LWWindowPeer _peer, PlatformWindow _owner) {
 290         initializeBase(_target, _peer, _owner, new CPlatformView());
 291 
 292         final int styleBits = getInitialStyleBits();
 293 
 294         responder = createPlatformResponder();
 295         contentView = createContentView();
 296         contentView.initialize(peer, responder);
 297 
 298         Rectangle bounds;
 299         if (!IS(DECORATED, styleBits)) {
 300             // For undecorated frames the move/resize event does not come if the frame is centered on the screen
 301             // so we need to set a stub location to force an initial move/resize. Real bounds would be set later.
 302             bounds = new Rectangle(0, 0, 1, 1);
 303         } else {
 304             bounds = _peer.constrainBounds(_target.getBounds());
 305         }
 306         AtomicLong ref = new AtomicLong();
 307         contentView.execute(viewPtr -> {
 308             boolean hasOwnerPtr = false;
 309 
 310             if (owner != null) {
 311                 hasOwnerPtr = 0L != owner.executeGet(ownerPtr -> {
 312                     ref.set(nativeCreateNSWindow(viewPtr, ownerPtr, styleBits,
 313                                                     bounds.x, bounds.y,
 314                                                     bounds.width, bounds.height));
 315                     return 1;
 316                 });
 317             }
 318 
 319             if (!hasOwnerPtr) {
 320                 ref.set(nativeCreateNSWindow(viewPtr, 0,
 321                                              styleBits, bounds.x, bounds.y,
 322                                              bounds.width, bounds.height));
 323             }
 324         });
 325         setPtr(ref.get());
 326 
 327         if (target instanceof javax.swing.RootPaneContainer) {
 328             final javax.swing.JRootPane rootpane = ((javax.swing.RootPaneContainer)target).getRootPane();
 329             if (rootpane != null) rootpane.addPropertyChangeListener("ancestor", new PropertyChangeListener() {
 330                 public void propertyChange(final PropertyChangeEvent evt) {
 331                     CLIENT_PROPERTY_APPLICATOR.attachAndApplyClientProperties(rootpane);
 332                     rootpane.removePropertyChangeListener("ancestor", this);
 333                 }
 334             });
 335         }
 336 
 337         validateSurface();
 338     }
 339 
 340     protected void initializeBase(Window target, LWWindowPeer peer, PlatformWindow owner, CPlatformView view) {
 341         this.peer = peer;
 342         this.target = target;
 343         if (owner instanceof CPlatformWindow) {
 344             this.owner = (CPlatformWindow)owner;
 345         }
 346         this.contentView = view;
 347     }
 348 
 349     protected CPlatformResponder createPlatformResponder() {
 350         return new CPlatformResponder(peer, false);
 351     }
 352 
 353     protected CPlatformView createContentView() {
 354         return new CPlatformView();
 355     }
 356 
 357     protected int getInitialStyleBits() {
 358         // defaults style bits
 359         int styleBits = DECORATED | HAS_SHADOW | CLOSEABLE | MINIMIZABLE | ZOOMABLE | RESIZABLE;
 360 
 361         if (isNativelyFocusableWindow()) {
 362             styleBits = SET(styleBits, SHOULD_BECOME_KEY, true);
 363             styleBits = SET(styleBits, SHOULD_BECOME_MAIN, true);
 364         }
 365 
 366         final boolean isFrame = (target instanceof Frame);
 367         final boolean isDialog = (target instanceof Dialog);
 368         final boolean isPopup = (target.getType() == Window.Type.POPUP);
 369         if (isDialog) {
 370             styleBits = SET(styleBits, MINIMIZABLE, false);
 371         }
 372 
 373         // Either java.awt.Frame or java.awt.Dialog can be undecorated, however java.awt.Window always is undecorated.
 374         {
 375             this.undecorated = isFrame ? ((Frame)target).isUndecorated() : (isDialog ? ((Dialog)target).isUndecorated() : true);
 376             if (this.undecorated) styleBits = SET(styleBits, DECORATED, false);
 377         }
 378 
 379         // Either java.awt.Frame or java.awt.Dialog can be resizable, however java.awt.Window is never resizable
 380         {
 381             final boolean resizable = isFrame ? ((Frame)target).isResizable() : (isDialog ? ((Dialog)target).isResizable() : false);
 382             styleBits = SET(styleBits, RESIZABLE, resizable);
 383             if (!resizable) {
 384                 styleBits = SET(styleBits, ZOOMABLE, false);
 385             }
 386         }
 387 
 388         if (target.isAlwaysOnTop()) {
 389             styleBits = SET(styleBits, ALWAYS_ON_TOP, true);
 390         }
 391 
 392         if (target.getModalExclusionType() == Dialog.ModalExclusionType.APPLICATION_EXCLUDE) {
 393             styleBits = SET(styleBits, MODAL_EXCLUDED, true);
 394         }
 395 
 396         // If the target is a dialog, popup or tooltip we want it to ignore the brushed metal look.
 397         if (isPopup) {
 398             styleBits = SET(styleBits, TEXTURED, false);
 399             // Popups in applets don't activate applet's process
 400             styleBits = SET(styleBits, NONACTIVATING, true);
 401             styleBits = SET(styleBits, IS_POPUP, true);
 402         }
 403 
 404         if (Window.Type.UTILITY.equals(target.getType())) {
 405             styleBits = SET(styleBits, UTILITY, true);
 406         }
 407 
 408         if (target instanceof javax.swing.RootPaneContainer) {
 409             javax.swing.JRootPane rootpane = ((javax.swing.RootPaneContainer)target).getRootPane();
 410             Object prop = null;
 411 
 412             prop = rootpane.getClientProperty(WINDOW_BRUSH_METAL_LOOK);
 413             if (prop != null) {
 414                 styleBits = SET(styleBits, TEXTURED, Boolean.parseBoolean(prop.toString()));
 415             }
 416 
 417             if (isDialog && ((Dialog)target).getModalityType() == ModalityType.DOCUMENT_MODAL) {
 418                 prop = rootpane.getClientProperty(WINDOW_DOC_MODAL_SHEET);
 419                 if (prop != null) {
 420                     styleBits = SET(styleBits, SHEET, Boolean.parseBoolean(prop.toString()));
 421                 }
 422             }
 423 
 424             prop = rootpane.getClientProperty(WINDOW_STYLE);
 425             if (prop != null) {
 426                 if ("small".equals(prop))  {
 427                     styleBits = SET(styleBits, UTILITY, true);
 428                     if (target.isAlwaysOnTop() && rootpane.getClientProperty(WINDOW_HIDES_ON_DEACTIVATE) == null) {
 429                         styleBits = SET(styleBits, HIDES_ON_DEACTIVATE, true);
 430                     }
 431                 }
 432                 if ("textured".equals(prop)) styleBits = SET(styleBits, TEXTURED, true);
 433                 if ("unified".equals(prop)) styleBits = SET(styleBits, UNIFIED, true);
 434                 if ("hud".equals(prop)) styleBits = SET(styleBits, HUD, true);
 435             }
 436 
 437             prop = rootpane.getClientProperty(WINDOW_HIDES_ON_DEACTIVATE);
 438             if (prop != null) {
 439                 styleBits = SET(styleBits, HIDES_ON_DEACTIVATE, Boolean.parseBoolean(prop.toString()));
 440             }
 441 
 442             prop = rootpane.getClientProperty(WINDOW_CLOSEABLE);
 443             if (prop != null) {
 444                 styleBits = SET(styleBits, CLOSEABLE, Boolean.parseBoolean(prop.toString()));
 445             }
 446 
 447             prop = rootpane.getClientProperty(WINDOW_MINIMIZABLE);
 448             if (prop != null) {
 449                 styleBits = SET(styleBits, MINIMIZABLE, Boolean.parseBoolean(prop.toString()));
 450             }
 451 
 452             prop = rootpane.getClientProperty(WINDOW_ZOOMABLE);
 453             if (prop != null) {
 454                 styleBits = SET(styleBits, ZOOMABLE, Boolean.parseBoolean(prop.toString()));
 455             }
 456 
 457             prop = rootpane.getClientProperty(WINDOW_FULLSCREENABLE);
 458             if (prop != null) {
 459                 styleBits = SET(styleBits, FULLSCREENABLE, Boolean.parseBoolean(prop.toString()));
 460             }
 461 
 462             prop = rootpane.getClientProperty(WINDOW_SHADOW);
 463             if (prop != null) {
 464                 styleBits = SET(styleBits, HAS_SHADOW, Boolean.parseBoolean(prop.toString()));
 465             }
 466 
 467             prop = rootpane.getClientProperty(WINDOW_DRAGGABLE_BACKGROUND);
 468             if (prop != null) {
 469                 styleBits = SET(styleBits, DRAGGABLE_BACKGROUND, Boolean.parseBoolean(prop.toString()));
 470             }





 471         }
 472 
 473         if (isDialog) {
 474             styleBits = SET(styleBits, IS_DIALOG, true);
 475             if (((Dialog) target).isModal()) {
 476                 styleBits = SET(styleBits, IS_MODAL, true);
 477             }
 478         }
 479 
 480         peer.setTextured(IS(TEXTURED, styleBits));
 481 
 482         return styleBits;
 483     }
 484 
 485     // this is the counter-point to -[CWindow _nativeSetStyleBit:]
 486     private void setStyleBits(final int mask, final boolean value) {
 487         execute(ptr -> nativeSetNSWindowStyleBits(ptr, mask, value ? mask : 0));
 488     }
 489 
 490     private native void _toggleFullScreenMode(final long model);
 491 
 492     public void toggleFullScreen() {
 493         execute(this::_toggleFullScreenMode);
 494     }
 495 
 496     @Override // PlatformWindow
 497     public void setMenuBar(MenuBar mb) {
 498         CMenuBar mbPeer = (CMenuBar)LWToolkit.targetToPeer(mb);
 499         execute(nsWindowPtr->{
 500             if (mbPeer != null) {
 501                 mbPeer.execute(ptr -> nativeSetNSWindowMenuBar(nsWindowPtr, ptr));
 502             } else {
 503                 nativeSetNSWindowMenuBar(nsWindowPtr, 0);
 504             }
 505         });
 506     }
 507 
 508     @Override // PlatformWindow
 509     public void dispose() {
 510         contentView.dispose();
 511         execute(CPlatformWindow::nativeDispose);
 512         CPlatformWindow.super.dispose();
 513     }
 514 
 515     @Override // PlatformWindow
 516     public FontMetrics getFontMetrics(Font f) {
 517         // TODO: not implemented
 518         (new RuntimeException("unimplemented")).printStackTrace();
 519         return null;
 520     }
 521 
 522     @Override // PlatformWindow
 523     public Insets getInsets() {
 524         AtomicReference<Insets> ref = new AtomicReference<>();
 525         execute(ptr -> {
 526             ref.set(nativeGetNSWindowInsets(ptr));
 527         });
 528         return ref.get() != null ? ref.get() : new Insets(0, 0, 0, 0);
 529     }
 530 
 531     @Override // PlatformWindow
 532     public Point getLocationOnScreen() {
 533         return new Point(nativeBounds.x, nativeBounds.y);
 534     }
 535 
 536     @Override
 537     public GraphicsDevice getGraphicsDevice() {
 538         return contentView.getGraphicsDevice();
 539     }
 540 
 541     @Override // PlatformWindow
 542     public SurfaceData getScreenSurface() {
 543         // TODO: not implemented
 544         return null;
 545     }
 546 
 547     @Override // PlatformWindow
 548     public SurfaceData replaceSurfaceData() {
 549         return contentView.replaceSurfaceData();
 550     }
 551 
 552     @Override // PlatformWindow
 553     public void setBounds(int x, int y, int w, int h) {
 554         execute(ptr -> nativeSetNSWindowBounds(ptr, x, y, w, h));
 555     }
 556 
 557     public void setMaximizedBounds(int x, int y, int w, int h) {
 558         execute(ptr -> nativeSetNSWindowStandardFrame(ptr, x, y, w, h));
 559     }
 560 
 561     private boolean isMaximized() {
 562         return undecorated ? this.normalBounds != null
 563                 : isZoomed;
 564     }
 565 
 566     private void maximize() {
 567         if (peer == null || isMaximized()) {
 568             return;
 569         }
 570         if (!undecorated) {
 571             execute(CWrapper.NSWindow::zoom);
 572         } else {
 573             deliverZoom(true);
 574 
 575             // We need an up to date size of the peer, so we flush the native events
 576             // to be sure that there are no setBounds requests in the queue.
 577             LWCToolkit.flushNativeSelectors();
 578             this.normalBounds = peer.getBounds();
 579             Rectangle maximizedBounds = peer.getMaximizedBounds();
 580             setBounds(maximizedBounds.x, maximizedBounds.y,
 581                     maximizedBounds.width, maximizedBounds.height);
 582         }
 583     }
 584 
 585     private void unmaximize() {
 586         if (!isMaximized()) {
 587             return;
 588         }
 589         if (!undecorated) {
 590             execute(CWrapper.NSWindow::zoom);
 591         } else {
 592             deliverZoom(false);
 593 
 594             Rectangle toBounds = this.normalBounds;
 595             this.normalBounds = null;
 596             setBounds(toBounds.x, toBounds.y, toBounds.width, toBounds.height);
 597         }
 598     }
 599 
 600     public boolean isVisible() {
 601         return this.visible;
 602     }
 603 
 604     @Override // PlatformWindow
 605     public void setVisible(boolean visible) {
 606         // Configure stuff
 607         updateIconImages();
 608         updateFocusabilityForAutoRequestFocus(false);
 609 
 610         boolean wasMaximized = isMaximized();
 611 
 612         if (visible && target.isLocationByPlatform()) {
 613             execute(CPlatformWindow::nativeSetNSWindowLocationByPlatform);
 614         }
 615 
 616         // Actually show or hide the window
 617         LWWindowPeer blocker = (peer == null)? null : peer.getBlocker();
 618         if (blocker == null || !visible) {
 619             // If it ain't blocked, or is being hidden, go regular way
 620             if (visible) {
 621                 contentView.execute(viewPtr -> {
 622                     execute(ptr -> CWrapper.NSWindow.makeFirstResponder(ptr,
 623                                                                         viewPtr));
 624                 });
 625 
 626                 boolean isPopup = (target.getType() == Window.Type.POPUP);
 627                 execute(ptr -> {
 628                     if (isPopup) {
 629                         // Popups in applets don't activate applet's process
 630                         CWrapper.NSWindow.orderFrontRegardless(ptr);
 631                     } else {
 632                         CWrapper.NSWindow.orderFront(ptr);
 633                     }
 634 
 635                     boolean isKeyWindow = CWrapper.NSWindow.isKeyWindow(ptr);
 636                     if (!isKeyWindow) {
 637                         CWrapper.NSWindow.makeKeyWindow(ptr);
 638                     }
 639 
 640                     if (owner != null
 641                             && owner.getPeer() instanceof LWLightweightFramePeer) {
 642                         LWLightweightFramePeer peer =
 643                                 (LWLightweightFramePeer) owner.getPeer();
 644 
 645                         long ownerWindowPtr = peer.getOverriddenWindowHandle();
 646                         if (ownerWindowPtr != 0) {
 647                             //Place window above JavaFX stage
 648                             CWrapper.NSWindow.addChildWindow(
 649                                     ownerWindowPtr, ptr,
 650                                     CWrapper.NSWindow.NSWindowAbove);
 651                         }
 652                     }
 653                 });
 654             } else {
 655                 execute(ptr->{
 656                     // immediately hide the window
 657                     CWrapper.NSWindow.orderOut(ptr);
 658                     // process the close
 659                     CWrapper.NSWindow.close(ptr);
 660                 });
 661             }
 662         } else {
 663             // otherwise, put it in a proper z-order
 664             CPlatformWindow bw
 665                     = (CPlatformWindow) blocker.getPlatformWindow();
 666             bw.execute(blockerPtr -> {
 667                 execute(ptr -> {
 668                     CWrapper.NSWindow.orderWindow(ptr,
 669                                                   CWrapper.NSWindow.NSWindowBelow,
 670                                                   blockerPtr);
 671                 });
 672             });
 673         }
 674         this.visible = visible;
 675 
 676         // Manage the extended state when showing
 677         if (visible) {
 678             /* Frame or Dialog should be set property WINDOW_FULLSCREENABLE to true if the
 679             Frame or Dialog is resizable.
 680             **/
 681             final boolean resizable = (target instanceof Frame) ? ((Frame)target).isResizable() :
 682             ((target instanceof Dialog) ? ((Dialog)target).isResizable() : false);
 683             if (resizable) {
 684                 setCanFullscreen(true);
 685             }
 686 
 687             // Apply the extended state as expected in shared code
 688             if (target instanceof Frame) {
 689                 if (!wasMaximized && isMaximized()) {
 690                     // setVisible could have changed the native maximized state
 691                     deliverZoom(true);
 692                 } else {
 693                     int frameState = ((Frame)target).getExtendedState();
 694                     if ((frameState & Frame.ICONIFIED) != 0) {
 695                         // Treat all state bit masks with ICONIFIED bit as ICONIFIED state.
 696                         frameState = Frame.ICONIFIED;
 697                     }
 698                     switch (frameState) {
 699                         case Frame.ICONIFIED:
 700                             execute(CWrapper.NSWindow::miniaturize);
 701                             break;
 702                         case Frame.MAXIMIZED_BOTH:
 703                             maximize();
 704                             break;
 705                         default: // NORMAL
 706                             unmaximize(); // in case it was maximized, otherwise this is a no-op
 707                             break;
 708                     }
 709                 }
 710             }
 711         }
 712 
 713         nativeSynthesizeMouseEnteredExitedEvents();
 714 
 715         // Configure stuff #2
 716         updateFocusabilityForAutoRequestFocus(true);
 717 
 718         // Manage parent-child relationship when showing
 719         final ComponentAccessor acc = AWTAccessor.getComponentAccessor();
 720 
 721         if (visible) {
 722             // Order myself above my parent
 723             if (owner != null && owner.isVisible()) {
 724                 owner.execute(ownerPtr -> {
 725                     execute(ptr -> {
 726                         CWrapper.NSWindow.orderWindow(ptr, CWrapper.NSWindow.NSWindowAbove, ownerPtr);
 727                     });
 728                 });
 729                 execute(CWrapper.NSWindow::orderFront);
 730                 applyWindowLevel(target);
 731             }
 732 
 733             // Order my own children above myself
 734             for (Window w : target.getOwnedWindows()) {
 735                 final Object p = acc.getPeer(w);
 736                 if (p instanceof LWWindowPeer) {
 737                     CPlatformWindow pw = (CPlatformWindow)((LWWindowPeer)p).getPlatformWindow();
 738                     if (pw != null && pw.isVisible()) {
 739                         pw.execute(childPtr -> {
 740                             execute(ptr -> {
 741                                 CWrapper.NSWindow.orderWindow(childPtr, CWrapper.NSWindow.NSWindowAbove, ptr);
 742                             });
 743                         });
 744                         pw.applyWindowLevel(w);
 745                     }
 746                 }
 747             }
 748         }
 749 
 750         // Deal with the blocker of the window being shown
 751         if (blocker != null && visible) {
 752             // Make sure the blocker is above its siblings
 753             ((CPlatformWindow)blocker.getPlatformWindow()).orderAboveSiblings();
 754         }
 755     }
 756 
 757     @Override // PlatformWindow
 758     public void setTitle(String title) {
 759         execute(ptr -> nativeSetNSWindowTitle(ptr, title));
 760     }
 761 
 762     // Should be called on every window key property change.
 763     @Override // PlatformWindow
 764     public void updateIconImages() {
 765         final CImage cImage = getImageForTarget();
 766         execute(ptr -> {
 767             if (cImage == null) {
 768                 nativeSetNSWindowMinimizedIcon(ptr, 0L);
 769             } else {
 770                 cImage.execute(imagePtr -> {
 771                     nativeSetNSWindowMinimizedIcon(ptr, imagePtr);
 772                 });
 773             }
 774         });
 775     }
 776 
 777     public SurfaceData getSurfaceData() {
 778         return contentView.getSurfaceData();
 779     }
 780 
 781     @Override  // PlatformWindow
 782     public void toBack() {
 783         execute(CPlatformWindow::nativePushNSWindowToBack);
 784     }
 785 
 786     @Override  // PlatformWindow
 787     public void toFront() {
 788         LWCToolkit lwcToolkit = (LWCToolkit) Toolkit.getDefaultToolkit();
 789         Window w = DefaultKeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow();
 790         final ComponentAccessor acc = AWTAccessor.getComponentAccessor();
 791         if( w != null && acc.getPeer(w) != null
 792                 && ((LWWindowPeer)acc.getPeer(w)).getPeerType() == LWWindowPeer.PeerType.EMBEDDED_FRAME
 793                 && !lwcToolkit.isApplicationActive()) {
 794             lwcToolkit.activateApplicationIgnoringOtherApps();
 795         }
 796         updateFocusabilityForAutoRequestFocus(false);
 797         execute(CPlatformWindow::nativePushNSWindowToFront);
 798         updateFocusabilityForAutoRequestFocus(true);
 799     }
 800 
 801     private void setCanFullscreen(final boolean canFullScreen) {
 802         if (target instanceof RootPaneContainer
 803                 && getPeer().getPeerType() == PeerType.FRAME) {
 804 
 805             if (isInFullScreen && !canFullScreen) {
 806                 toggleFullScreen();
 807             }
 808 
 809             final RootPaneContainer rpc = (RootPaneContainer) target;
 810             rpc.getRootPane().putClientProperty(
 811                     CPlatformWindow.WINDOW_FULLSCREENABLE, canFullScreen);
 812         }
 813     }
 814 
 815     @Override
 816     public void setResizable(final boolean resizable) {
 817         setCanFullscreen(resizable);
 818         setStyleBits(RESIZABLE, resizable);
 819         setStyleBits(ZOOMABLE, resizable);
 820     }
 821 
 822     @Override
 823     public void setSizeConstraints(int minW, int minH, int maxW, int maxH) {
 824         execute(ptr -> nativeSetNSWindowMinMax(ptr, minW, minH, maxW, maxH));
 825     }
 826 
 827     @Override
 828     public boolean rejectFocusRequest(FocusEvent.Cause cause) {
 829         // Cross-app activation requests are not allowed.
 830         if (cause != FocusEvent.Cause.MOUSE_EVENT &&
 831             !((LWCToolkit)Toolkit.getDefaultToolkit()).isApplicationActive())
 832         {
 833             focusLogger.fine("the app is inactive, so the request is rejected");
 834             return true;
 835         }
 836         return false;
 837     }
 838 
 839     @Override
 840     public boolean requestWindowFocus() {
 841         execute(ptr -> {
 842             if (CWrapper.NSWindow.canBecomeMainWindow(ptr)) {
 843                 CWrapper.NSWindow.makeMainWindow(ptr);
 844             }
 845             CWrapper.NSWindow.makeKeyAndOrderFront(ptr);
 846         });
 847         return true;
 848     }
 849 
 850     @Override
 851     public boolean isActive() {
 852         AtomicBoolean ref = new AtomicBoolean();
 853         execute(ptr -> {
 854             ref.set(CWrapper.NSWindow.isKeyWindow(ptr));
 855         });
 856         return ref.get();
 857     }
 858 
 859     @Override
 860     public void updateFocusableWindowState() {
 861         final boolean isFocusable = isNativelyFocusableWindow();
 862         setStyleBits(SHOULD_BECOME_KEY | SHOULD_BECOME_MAIN | RESIZABLE, isFocusable); // set bits at once
 863     }
 864 
 865     @Override
 866     public void setAlwaysOnTop(boolean isAlwaysOnTop) {
 867         setStyleBits(ALWAYS_ON_TOP, isAlwaysOnTop);
 868     }
 869 
 870     @Override
 871     public void setOpacity(float opacity) {
 872         execute(ptr -> CWrapper.NSWindow.setAlphaValue(ptr, opacity));
 873     }
 874 
 875     @Override
 876     public void setOpaque(boolean isOpaque) {
 877         execute(ptr -> CWrapper.NSWindow.setOpaque(ptr, isOpaque));
 878         boolean isTextured = (peer == null) ? false : peer.isTextured();
 879         if (!isTextured) {
 880             if (!isOpaque) {
 881                 execute(ptr -> CWrapper.NSWindow.setBackgroundColor(ptr, 0));
 882             } else if (peer != null) {
 883                 Color color = peer.getBackground();
 884                 if (color != null) {
 885                     int rgb = color.getRGB();
 886                     execute(ptr->CWrapper.NSWindow.setBackgroundColor(ptr, rgb));
 887                 }
 888             }
 889         }
 890 
 891         //This is a temporary workaround. Looks like after 7124236 will be fixed
 892         //the correct place for invalidateShadow() is CGLayer.drawInCGLContext.
 893         SwingUtilities.invokeLater(this::invalidateShadow);
 894     }
 895 
 896     @Override
 897     public void enterFullScreenMode() {
 898         isFullScreenMode = true;
 899         execute(CPlatformWindow::nativeEnterFullScreenMode);
 900     }
 901 
 902     @Override
 903     public void exitFullScreenMode() {
 904         execute(CPlatformWindow::nativeExitFullScreenMode);
 905         isFullScreenMode = false;
 906     }
 907 
 908     @Override
 909     public boolean isFullScreenMode() {
 910         return isFullScreenMode;
 911     }
 912 
 913     @Override
 914     public void setWindowState(int windowState) {
 915         if (peer == null || !peer.isVisible()) {
 916             // setVisible() applies the state
 917             return;
 918         }
 919 
 920         int prevWindowState = peer.getState();
 921         if (prevWindowState == windowState) return;
 922 
 923         if ((windowState & Frame.ICONIFIED) != 0) {
 924             // Treat all state bit masks with ICONIFIED bit as ICONIFIED state.
 925             windowState = Frame.ICONIFIED;
 926         }
 927         switch (windowState) {
 928             case Frame.ICONIFIED:
 929                 if (prevWindowState == Frame.MAXIMIZED_BOTH) {
 930                     // let's return into the normal states first
 931                     // the zoom call toggles between the normal and the max states
 932                     unmaximize();
 933                 }
 934                 execute(CWrapper.NSWindow::miniaturize);
 935                 break;
 936             case Frame.MAXIMIZED_BOTH:
 937                 if (prevWindowState == Frame.ICONIFIED) {
 938                     // let's return into the normal states first
 939                     execute(CWrapper.NSWindow::deminiaturize);
 940                 }
 941                 maximize();
 942                 break;
 943             case Frame.NORMAL:
 944                 if (prevWindowState == Frame.ICONIFIED) {
 945                     execute(CWrapper.NSWindow::deminiaturize);
 946                 } else if (prevWindowState == Frame.MAXIMIZED_BOTH) {
 947                     // the zoom call toggles between the normal and the max states
 948                     unmaximize();
 949                 }
 950                 break;
 951             default:
 952                 throw new RuntimeException("Unknown window state: " + windowState);
 953         }
 954 
 955         // NOTE: the SWP.windowState field gets updated to the newWindowState
 956         //       value when the native notification comes to us
 957     }
 958 
 959     @Override
 960     public void setModalBlocked(boolean blocked) {
 961         if (target.getModalExclusionType() == Dialog.ModalExclusionType.APPLICATION_EXCLUDE) {
 962             return;
 963         }
 964 
 965         if (blocked) {
 966             // We are going to show a modal window. Previously displayed window will be
 967             // blocked/disabled. So we have to send mouse exited event to it now, since
 968             // all mouse events are discarded for blocked/disabled windows.
 969             execute(ptr -> nativeSynthesizeMouseEnteredExitedEvents(ptr, CocoaConstants.NSMouseExited));
 970         }
 971 
 972         execute(ptr -> nativeSetEnabled(ptr, !blocked));
 973         checkBlockingAndOrder();
 974     }
 975 
 976     public final void invalidateShadow() {
 977         execute(ptr -> nativeRevalidateNSWindowShadow(ptr));
 978     }
 979 
 980     // ----------------------------------------------------------------------
 981     //                          UTILITY METHODS
 982     // ----------------------------------------------------------------------
 983 
 984     /**
 985      * Find image to install into Title or into Application icon. First try
 986      * icons installed for toplevel. Null is returned, if there is no icon and
 987      * default Duke image should be used.
 988      */
 989     private CImage getImageForTarget() {
 990         CImage icon = null;
 991         try {
 992             icon = CImage.getCreator().createFromImages(target.getIconImages());
 993         } catch (Exception ignored) {
 994             // Perhaps the icon passed into Java is broken. Skipping this icon.
 995         }
 996         return icon;
 997     }
 998 
 999     /*
1000      * Returns LWWindowPeer associated with this delegate.
1001      */
1002     @Override
1003     public LWWindowPeer getPeer() {
1004         return peer;
1005     }
1006 
1007     @Override
1008     public boolean isUnderMouse() {
1009         return contentView.isUnderMouse();
1010     }
1011 
1012     public CPlatformView getContentView() {
1013         return contentView;
1014     }
1015 
1016     @Override
1017     public long getLayerPtr() {
1018         return contentView.getWindowLayerPtr();
1019     }
1020 
1021     private void validateSurface() {
1022         SurfaceData surfaceData = getSurfaceData();
1023         if (surfaceData instanceof CGLSurfaceData) {
1024             ((CGLSurfaceData)surfaceData).validate();
1025         }
1026     }
1027 
1028     void flushBuffers() {
1029         if (isVisible() && !nativeBounds.isEmpty() && !isFullScreenMode) {
1030             try {
1031                 LWCToolkit.invokeAndWait(new Runnable() {
1032                     @Override
1033                     public void run() {
1034                         //Posting an empty to flush the EventQueue without blocking the main thread
1035                     }
1036                 }, target);
1037             } catch (InvocationTargetException e) {
1038                 e.printStackTrace();
1039             }
1040         }
1041     }
1042 
1043     /**
1044      * Helper method to get a pointer to the native view from the PlatformWindow.
1045      */
1046     static long getNativeViewPtr(PlatformWindow platformWindow) {
1047         long nativePeer = 0L;
1048         if (platformWindow instanceof CPlatformWindow) {
1049             nativePeer = ((CPlatformWindow) platformWindow).getContentView().getAWTView();
1050         } else if (platformWindow instanceof CViewPlatformEmbeddedFrame){
1051             nativePeer = ((CViewPlatformEmbeddedFrame) platformWindow).getNSViewPtr();
1052         }
1053         return nativePeer;
1054     }
1055 
1056     /*************************************************************
1057      * Callbacks from the AWTWindow and AWTView objc classes.
1058      *************************************************************/
1059     private void deliverWindowFocusEvent(boolean gained, CPlatformWindow opposite){
1060         // Fix for 7150349: ingore "gained" notifications when the app is inactive.
1061         if (gained && !((LWCToolkit)Toolkit.getDefaultToolkit()).isApplicationActive()) {
1062             focusLogger.fine("the app is inactive, so the notification is ignored");
1063             return;
1064         }
1065 
1066         LWWindowPeer oppositePeer = (opposite == null)? null : opposite.getPeer();
1067         responder.handleWindowFocusEvent(gained, oppositePeer);
1068     }
1069 
1070     protected void deliverMoveResizeEvent(int x, int y, int width, int height,
1071                                         boolean byUser) {
1072         AtomicBoolean ref = new AtomicBoolean();
1073         execute(ptr -> {
1074             ref.set(CWrapper.NSWindow.isZoomed(ptr));
1075         });
1076         isZoomed = ref.get();
1077         checkZoom();
1078 
1079         final Rectangle oldB = nativeBounds;
1080         nativeBounds = new Rectangle(x, y, width, height);
1081         if (peer != null) {
1082             peer.notifyReshape(x, y, width, height);
1083             // System-dependent appearance optimization.
1084             if ((byUser && !oldB.getSize().equals(nativeBounds.getSize()))
1085                     || isFullScreenAnimationOn) {
1086                 flushBuffers();
1087             }
1088         }
1089     }
1090 
1091     private void deliverWindowClosingEvent() {
1092         if (peer != null && peer.getBlocker() == null) {
1093             peer.postEvent(new WindowEvent(target, WindowEvent.WINDOW_CLOSING));
1094         }
1095     }
1096 
1097     private void deliverIconify(final boolean iconify) {
1098         if (peer != null) {
1099             peer.notifyIconify(iconify);
1100         }
1101         if (iconify) {
1102             isIconifyAnimationActive = false;
1103         }
1104     }
1105 
1106     private void deliverZoom(final boolean isZoomed) {
1107         if (peer != null) {
1108             peer.notifyZoom(isZoomed);
1109         }
1110     }
1111 
1112     private void checkZoom() {
1113         if (peer != null) {
1114             int state = peer.getState();
1115             if (state != Frame.MAXIMIZED_BOTH && isMaximized()) {
1116                 deliverZoom(true);
1117             } else if (state == Frame.MAXIMIZED_BOTH && !isMaximized()) {
1118                 deliverZoom(false);
1119             }
1120         }
1121     }
1122 
1123     private void deliverNCMouseDown() {
1124         if (peer != null) {
1125             peer.notifyNCMouseDown();
1126         }
1127     }
1128 
1129     /*
1130      * Our focus model is synthetic and only non-simple window
1131      * may become natively focusable window.
1132      */
1133     private boolean isNativelyFocusableWindow() {
1134         if (peer == null) {
1135             return false;
1136         }
1137 
1138         return !peer.isSimpleWindow() && target.getFocusableWindowState();
1139     }
1140 
1141     private boolean isBlocked() {
1142         LWWindowPeer blocker = (peer != null) ? peer.getBlocker() : null;
1143         return (blocker != null);
1144     }
1145 
1146     /*
1147      * An utility method for the support of the auto request focus.
1148      * Updates the focusable state of the window under certain
1149      * circumstances.
1150      */
1151     private void updateFocusabilityForAutoRequestFocus(boolean isFocusable) {
1152         if (target.isAutoRequestFocus() || !isNativelyFocusableWindow()) return;
1153         setStyleBits(SHOULD_BECOME_KEY | SHOULD_BECOME_MAIN, isFocusable); // set both bits at once
1154     }
1155 
1156     private boolean checkBlockingAndOrder() {
1157         LWWindowPeer blocker = (peer == null)? null : peer.getBlocker();
1158         if (blocker == null) {
1159             return false;
1160         }
1161 
1162         if (blocker instanceof CPrinterDialogPeer) {
1163             return true;
1164         }
1165 
1166         CPlatformWindow pWindow = (CPlatformWindow)blocker.getPlatformWindow();
1167 
1168         pWindow.orderAboveSiblings();
1169 
1170         pWindow.execute(ptr -> {
1171             CWrapper.NSWindow.orderFrontRegardless(ptr);
1172             CWrapper.NSWindow.makeKeyAndOrderFront(ptr);
1173             CWrapper.NSWindow.makeMainWindow(ptr);
1174         });
1175         return true;
1176     }
1177 
1178     private boolean isIconified() {
1179         boolean isIconified = false;
1180         if (target instanceof Frame) {
1181             int state = ((Frame)target).getExtendedState();
1182             if ((state & Frame.ICONIFIED) != 0) {
1183                 isIconified = true;
1184             }
1185         }
1186         return isIconifyAnimationActive || isIconified;
1187     }
1188 
1189     private boolean isOneOfOwnersOrSelf(CPlatformWindow window) {
1190         while (window != null) {
1191             if (this == window) {
1192                 return true;
1193             }
1194             window = window.owner;
1195         }
1196         return false;
1197     }
1198 
1199     private CPlatformWindow getRootOwner() {
1200         CPlatformWindow rootOwner = this;
1201         while (rootOwner.owner != null) {
1202             rootOwner = rootOwner.owner;
1203         }
1204         return rootOwner;
1205     }
1206 
1207     private void orderAboveSiblings() {
1208         // Recursively pop up the windows from the very bottom, (i.e. root owner) so that
1209         // the windows are ordered above their nearest owner; ancestors of the window,
1210         // which is going to become 'main window', are placed above their siblings.
1211         CPlatformWindow rootOwner = getRootOwner();
1212         if (rootOwner.isVisible() && !rootOwner.isIconified()) {
1213             rootOwner.execute(CWrapper.NSWindow::orderFront);
1214         }
1215         // Do not order child windows of iconified owner.
1216         if (!rootOwner.isIconified()) {
1217             final WindowAccessor windowAccessor = AWTAccessor.getWindowAccessor();
1218             orderAboveSiblingsImpl(windowAccessor.getOwnedWindows(rootOwner.target));
1219         }
1220     }
1221 
1222     private void orderAboveSiblingsImpl(Window[] windows) {
1223         ArrayList<Window> childWindows = new ArrayList<Window>();
1224 
1225         final ComponentAccessor componentAccessor = AWTAccessor.getComponentAccessor();
1226         final WindowAccessor windowAccessor = AWTAccessor.getWindowAccessor();
1227         Arrays.sort(windows, siblingsComparator);
1228         // Go through the list of windows and perform ordering.
1229         CPlatformWindow pwUnder = null;
1230         for (Window w : windows) {
1231             boolean iconified = false;
1232             final Object p = componentAccessor.getPeer(w);
1233             if (p instanceof LWWindowPeer) {
1234                 CPlatformWindow pw = (CPlatformWindow)((LWWindowPeer)p).getPlatformWindow();
1235                 iconified = isIconified();
1236                 if (pw != null && pw.isVisible() && !iconified) {
1237                     // If the window is one of ancestors of 'main window' or is going to become main by itself,
1238                     // the window should be ordered above its siblings; otherwise the window is just ordered
1239                     // above its nearest parent.
1240                     if (pw.isOneOfOwnersOrSelf(this)) {
1241                         pw.execute(CWrapper.NSWindow::orderFront);
1242                     } else {
1243                         if (pwUnder == null) {
1244                             pwUnder = pw.owner;
1245                         }
1246                         pwUnder.execute(underPtr -> {
1247                             pw.execute(ptr -> {
1248                                 CWrapper.NSWindow.orderWindow(ptr, CWrapper.NSWindow.NSWindowAbove, underPtr);
1249                             });
1250                         });
1251                         pwUnder = pw;
1252                     }
1253                     pw.applyWindowLevel(w);
1254                 }
1255             }
1256             // Retrieve the child windows for each window from the list except iconified ones
1257             // and store them for future use.
1258             // Note: we collect data about child windows even for invisible owners, since they may have
1259             // visible children.
1260             if (!iconified) {
1261                 childWindows.addAll(Arrays.asList(windowAccessor.getOwnedWindows(w)));
1262             }
1263         }
1264         // If some windows, which have just been ordered, have any child windows, let's start new iteration
1265         // and order these child windows.
1266         if (!childWindows.isEmpty()) {
1267             orderAboveSiblingsImpl(childWindows.toArray(new Window[0]));
1268         }
1269     }
1270 
1271     protected void applyWindowLevel(Window target) {
1272         if (target.isAlwaysOnTop() && target.getType() != Window.Type.POPUP) {
1273             execute(ptr->CWrapper.NSWindow.setLevel(ptr, CWrapper.NSWindow.NSFloatingWindowLevel));
1274         } else if (target.getType() == Window.Type.POPUP) {
1275             execute(ptr->CWrapper.NSWindow.setLevel(ptr, CWrapper.NSWindow.NSPopUpMenuWindowLevel));
1276         }
1277     }
1278 
1279     // ----------------------------------------------------------------------
1280     //                          NATIVE CALLBACKS
1281     // ----------------------------------------------------------------------
1282 
1283     private void windowWillMiniaturize() {
1284         isIconifyAnimationActive = true;
1285     }
1286 
1287     private void windowDidBecomeMain() {
1288         lastBecomeMainTime = System.currentTimeMillis();
1289         if (checkBlockingAndOrder()) return;
1290         // If it's not blocked, make sure it's above its siblings
1291         orderAboveSiblings();
1292     }
1293 
1294     private void windowWillEnterFullScreen() {
1295         isFullScreenAnimationOn = true;
1296     }
1297 
1298     private void windowDidEnterFullScreen() {
1299         isInFullScreen = true;
1300         isFullScreenAnimationOn = false;
1301     }
1302 
1303     private void windowWillExitFullScreen() {
1304         isFullScreenAnimationOn = true;
1305     }
1306 
1307     private void windowDidExitFullScreen() {
1308         isInFullScreen = false;
1309         isFullScreenAnimationOn = false;
1310     }
1311 }
--- EOF ---