1 /*
   2  * Copyright (c) 2011, 2016, 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 com.apple.eawt.FullScreenAdapter;
  29 import com.apple.eawt.FullScreenUtilities;
  30 import com.apple.eawt.event.FullScreenEvent;
  31 import java.awt.*;
  32 import java.awt.Dialog.ModalityType;
  33 import java.awt.event.*;
  34 import java.beans.*;
  35 import java.lang.reflect.InvocationTargetException;
  36 import java.util.ArrayList;
  37 import java.util.Arrays;
  38 
  39 import javax.swing.*;
  40 
  41 import sun.awt.*;
  42 import sun.awt.AWTAccessor.ComponentAccessor;
  43 import sun.java2d.SurfaceData;
  44 import sun.java2d.opengl.CGLSurfaceData;
  45 import sun.lwawt.*;
  46 import sun.util.logging.PlatformLogger;
  47 
  48 import com.apple.laf.*;
  49 import com.apple.laf.ClientPropertyApplicator.Property;
  50 import com.sun.awt.AWTUtilities;
  51 import sun.lwawt.LWWindowPeer.PeerType;
  52 
  53 public class CPlatformWindow extends CFRetainedResource implements PlatformWindow {
  54     private native long nativeCreateNSWindow(long nsViewPtr,long ownerPtr, long styleBits, double x, double y, double w, double h);
  55     private static native void nativeSetNSWindowStyleBits(long nsWindowPtr, int mask, int data);
  56     private static native void nativeSetNSWindowMenuBar(long nsWindowPtr, long menuBarPtr);
  57     private static native Insets nativeGetNSWindowInsets(long nsWindowPtr);
  58     private static native void nativeSetNSWindowBounds(long nsWindowPtr, double x, double y, double w, double h);
  59     private static native void nativeSetNSWindowLocationByPlatform(long nsWindowPtr);
  60     private static native void nativeSetNSWindowStandardFrame(long nsWindowPtr,
  61             double x, double y, double w, double h);
  62     private static native void nativeSetNSWindowMinMax(long nsWindowPtr, double minW, double minH, double maxW, double maxH);
  63     private static native void nativePushNSWindowToBack(long nsWindowPtr);
  64     private static native void nativePushNSWindowToFront(long nsWindowPtr);
  65     private static native void nativeSetNSWindowTitle(long nsWindowPtr, String title);
  66     private static native void nativeRevalidateNSWindowShadow(long nsWindowPtr);
  67     private static native void nativeSetNSWindowMinimizedIcon(long nsWindowPtr, long nsImage);
  68     private static native void nativeSetNSWindowRepresentedFilename(long nsWindowPtr, String representedFilename);
  69     private static native void nativeSetEnabled(long nsWindowPtr, boolean isEnabled);
  70     private static native void nativeSynthesizeMouseEnteredExitedEvents();
  71     private static native void nativeSynthesizeMouseEnteredExitedEvents(long nsWindowPtr, int eventType);
  72     private static native void nativeDispose(long nsWindowPtr);
  73     private static native void nativeEnterFullScreenMode(long nsWindowPtr);
  74     private static native void nativeExitFullScreenMode(long nsWindowPtr);
  75     static native CPlatformWindow nativeGetTopmostPlatformWindowUnderMouse();
  76 
  77     // Loger to report issues happened during execution but that do not affect functionality
  78     private static final PlatformLogger logger = PlatformLogger.getLogger("sun.lwawt.macosx.CPlatformWindow");
  79     private static final PlatformLogger focusLogger = PlatformLogger.getLogger("sun.lwawt.macosx.focus.CPlatformWindow");
  80 
  81     // for client properties
  82     public static final String WINDOW_BRUSH_METAL_LOOK = "apple.awt.brushMetalLook";
  83     public static final String WINDOW_DRAGGABLE_BACKGROUND = "apple.awt.draggableWindowBackground";
  84 
  85     public static final String WINDOW_ALPHA = "Window.alpha";
  86     public static final String WINDOW_SHADOW = "Window.shadow";
  87 
  88     public static final String WINDOW_STYLE = "Window.style";
  89     public static final String WINDOW_SHADOW_REVALIDATE_NOW = "apple.awt.windowShadow.revalidateNow";
  90 
  91     public static final String WINDOW_DOCUMENT_MODIFIED = "Window.documentModified";
  92     public static final String WINDOW_DOCUMENT_FILE = "Window.documentFile";
  93 
  94     public static final String WINDOW_CLOSEABLE = "Window.closeable";
  95     public static final String WINDOW_MINIMIZABLE = "Window.minimizable";
  96     public static final String WINDOW_ZOOMABLE = "Window.zoomable";
  97     public static final String WINDOW_HIDES_ON_DEACTIVATE="Window.hidesOnDeactivate";
  98 
  99     public static final String WINDOW_DOC_MODAL_SHEET = "apple.awt.documentModalSheet";
 100     public static final String WINDOW_FADE_DELEGATE = "apple.awt._windowFadeDelegate";
 101     public static final String WINDOW_FADE_IN = "apple.awt._windowFadeIn";
 102     public static final String WINDOW_FADE_OUT = "apple.awt._windowFadeOut";
 103     public static final String WINDOW_FULLSCREENABLE = "apple.awt.fullscreenable";
 104 
 105 
 106     // Yeah, I know. But it's easier to deal with ints from JNI
 107     static final int MODELESS = 0;
 108     static final int DOCUMENT_MODAL = 1;
 109     static final int APPLICATION_MODAL = 2;
 110     static final int TOOLKIT_MODAL = 3;
 111 
 112     // window style bits
 113     static final int _RESERVED_FOR_DATA = 1 << 0;
 114 
 115     // corresponds to native style mask bits
 116     static final int DECORATED = 1 << 1;
 117     static final int TEXTURED = 1 << 2;
 118     static final int UNIFIED = 1 << 3;
 119     static final int UTILITY = 1 << 4;
 120     static final int HUD = 1 << 5;
 121     static final int SHEET = 1 << 6;
 122 
 123     static final int CLOSEABLE = 1 << 7;
 124     static final int MINIMIZABLE = 1 << 8;
 125 
 126     static final int RESIZABLE = 1 << 9; // both a style bit and prop bit
 127     static final int NONACTIVATING = 1 << 24;
 128     static final int IS_DIALOG = 1 << 25;
 129     static final int IS_MODAL = 1 << 26;
 130     static final int IS_POPUP = 1 << 27;
 131 
 132     static final int _STYLE_PROP_BITMASK = DECORATED | TEXTURED | UNIFIED | UTILITY | HUD | SHEET | CLOSEABLE | MINIMIZABLE | RESIZABLE;
 133 
 134     // corresponds to method-based properties
 135     static final int HAS_SHADOW = 1 << 10;
 136     static final int ZOOMABLE = 1 << 11;
 137 
 138     static final int ALWAYS_ON_TOP = 1 << 15;
 139     static final int HIDES_ON_DEACTIVATE = 1 << 17;
 140     static final int DRAGGABLE_BACKGROUND = 1 << 19;
 141     static final int DOCUMENT_MODIFIED = 1 << 21;
 142     static final int FULLSCREENABLE = 1 << 23;
 143 
 144     static final int _METHOD_PROP_BITMASK = RESIZABLE | HAS_SHADOW | ZOOMABLE | ALWAYS_ON_TOP | HIDES_ON_DEACTIVATE | DRAGGABLE_BACKGROUND | DOCUMENT_MODIFIED | FULLSCREENABLE;
 145 
 146     // corresponds to callback-based properties
 147     static final int SHOULD_BECOME_KEY = 1 << 12;
 148     static final int SHOULD_BECOME_MAIN = 1 << 13;
 149     static final int MODAL_EXCLUDED = 1 << 16;
 150 
 151     static final int _CALLBACK_PROP_BITMASK = SHOULD_BECOME_KEY | SHOULD_BECOME_MAIN | MODAL_EXCLUDED;
 152 
 153     static int SET(final int bits, final int mask, final boolean value) {
 154         if (value) return (bits | mask);
 155         return bits & ~mask;
 156     }
 157 
 158     static boolean IS(final int bits, final int mask) {
 159         return (bits & mask) != 0;
 160     }
 161 
 162     @SuppressWarnings({"unchecked", "rawtypes"})
 163     static ClientPropertyApplicator<JRootPane, CPlatformWindow> CLIENT_PROPERTY_APPLICATOR = new ClientPropertyApplicator<JRootPane, CPlatformWindow>(new Property[] {
 164         new Property<CPlatformWindow>(WINDOW_DOCUMENT_MODIFIED) { public void applyProperty(final CPlatformWindow c, final Object value) {
 165             c.setStyleBits(DOCUMENT_MODIFIED, value == null ? false : Boolean.parseBoolean(value.toString()));
 166         }},
 167         new Property<CPlatformWindow>(WINDOW_BRUSH_METAL_LOOK) { public void applyProperty(final CPlatformWindow c, final Object value) {
 168             c.setStyleBits(TEXTURED, Boolean.parseBoolean(value.toString()));
 169         }},
 170         new Property<CPlatformWindow>(WINDOW_ALPHA) { public void applyProperty(final CPlatformWindow c, final Object value) {
 171             AWTUtilities.setWindowOpacity(c.target, value == null ? 1.0f : Float.parseFloat(value.toString()));
 172         }},
 173         new Property<CPlatformWindow>(WINDOW_SHADOW) { public void applyProperty(final CPlatformWindow c, final Object value) {
 174             c.setStyleBits(HAS_SHADOW, value == null ? true : Boolean.parseBoolean(value.toString()));
 175         }},
 176         new Property<CPlatformWindow>(WINDOW_MINIMIZABLE) { public void applyProperty(final CPlatformWindow c, final Object value) {
 177             c.setStyleBits(MINIMIZABLE, Boolean.parseBoolean(value.toString()));
 178         }},
 179         new Property<CPlatformWindow>(WINDOW_CLOSEABLE) { public void applyProperty(final CPlatformWindow c, final Object value) {
 180             c.setStyleBits(CLOSEABLE, Boolean.parseBoolean(value.toString()));
 181         }},
 182         new Property<CPlatformWindow>(WINDOW_ZOOMABLE) { public void applyProperty(final CPlatformWindow c, final Object value) {
 183             boolean zoomable = Boolean.parseBoolean(value.toString());
 184             if (c.target instanceof RootPaneContainer
 185                     && c.getPeer().getPeerType() == PeerType.FRAME) {
 186                 if (c.isInFullScreen && !zoomable) {
 187                     c.toggleFullScreen();
 188                 }
 189             }
 190             c.setStyleBits(ZOOMABLE, zoomable);
 191         }},
 192         new Property<CPlatformWindow>(WINDOW_FULLSCREENABLE) { public void applyProperty(final CPlatformWindow c, final Object value) {
 193             boolean fullscrenable = Boolean.parseBoolean(value.toString());
 194             if (c.target instanceof RootPaneContainer
 195                     && c.getPeer().getPeerType() == PeerType.FRAME) {
 196                 if (c.isInFullScreen && !fullscrenable) {
 197                     c.toggleFullScreen();
 198                 }
 199             }
 200             c.setStyleBits(FULLSCREENABLE, fullscrenable);
 201         }},
 202         new Property<CPlatformWindow>(WINDOW_SHADOW_REVALIDATE_NOW) { public void applyProperty(final CPlatformWindow c, final Object value) {
 203             nativeRevalidateNSWindowShadow(c.getNSWindowPtr());
 204         }},
 205         new Property<CPlatformWindow>(WINDOW_DOCUMENT_FILE) { public void applyProperty(final CPlatformWindow c, final Object value) {
 206             if (value == null || !(value instanceof java.io.File)) {
 207                 nativeSetNSWindowRepresentedFilename(c.getNSWindowPtr(), null);
 208                 return;
 209             }
 210 
 211             final String filename = ((java.io.File)value).getAbsolutePath();
 212             nativeSetNSWindowRepresentedFilename(c.getNSWindowPtr(), filename);
 213         }}
 214     }) {
 215         @SuppressWarnings("deprecation")
 216         public CPlatformWindow convertJComponentToTarget(final JRootPane p) {
 217             Component root = SwingUtilities.getRoot(p);
 218             final ComponentAccessor acc = AWTAccessor.getComponentAccessor();
 219             if (root == null || acc.getPeer(root) == null) return null;
 220             return (CPlatformWindow)((LWWindowPeer)acc.getPeer(root)).getPlatformWindow();
 221         }
 222     };
 223 
 224     // Bounds of the native widget but in the Java coordinate system.
 225     // In order to keep it up-to-date we will update them on
 226     // 1) setting native bounds via nativeSetBounds() call
 227     // 2) getting notification from the native level via deliverMoveResizeEvent()
 228     private Rectangle nativeBounds = new Rectangle(0, 0, 0, 0);
 229     private volatile boolean isFullScreenMode;
 230     private boolean isFullScreenAnimationOn;
 231 
 232     private volatile boolean isInFullScreen;
 233 
 234     private Window target;
 235     private LWWindowPeer peer;
 236     protected CPlatformView contentView;
 237     protected CPlatformWindow owner;
 238     protected boolean visible = false; // visibility status from native perspective
 239     private boolean undecorated; // initialized in getInitialStyleBits()
 240     private Rectangle normalBounds = null; // not-null only for undecorated maximized windows
 241     private CPlatformResponder responder;
 242 
 243     public CPlatformWindow() {
 244         super(0, true);
 245     }
 246 
 247     /*
 248      * Delegate initialization (create native window and all the
 249      * related resources).
 250      */
 251     @Override // PlatformWindow
 252     public void initialize(Window _target, LWWindowPeer _peer, PlatformWindow _owner) {
 253         initializeBase(_target, _peer, _owner, new CPlatformView());
 254 
 255         final int styleBits = getInitialStyleBits();
 256 
 257         responder = createPlatformResponder();
 258         contentView = createContentView();
 259         contentView.initialize(peer, responder);
 260 
 261         final long ownerPtr = owner != null ? owner.getNSWindowPtr() : 0L;
 262         Rectangle bounds;
 263         if (!IS(DECORATED, styleBits)) {
 264             // For undecorated frames the move/resize event does not come if the frame is centered on the screen
 265             // so we need to set a stub location to force an initial move/resize. Real bounds would be set later.
 266             bounds = new Rectangle(0, 0, 1, 1);
 267         } else {
 268             bounds = _peer.constrainBounds(_target.getBounds());
 269         }
 270         final long nativeWindowPtr = nativeCreateNSWindow(contentView.getAWTView(),
 271                 ownerPtr, styleBits, bounds.x, bounds.y, bounds.width, bounds.height);
 272         setPtr(nativeWindowPtr);
 273 
 274         if (target instanceof javax.swing.RootPaneContainer) {
 275             final javax.swing.JRootPane rootpane = ((javax.swing.RootPaneContainer)target).getRootPane();
 276             if (rootpane != null) rootpane.addPropertyChangeListener("ancestor", new PropertyChangeListener() {
 277                 public void propertyChange(final PropertyChangeEvent evt) {
 278                     CLIENT_PROPERTY_APPLICATOR.attachAndApplyClientProperties(rootpane);
 279                     rootpane.removePropertyChangeListener("ancestor", this);
 280                 }
 281             });
 282         }
 283 
 284         validateSurface();
 285     }
 286 
 287     protected void initializeBase(Window target, LWWindowPeer peer, PlatformWindow owner, CPlatformView view) {
 288         this.peer = peer;
 289         this.target = target;
 290         if (owner instanceof CPlatformWindow) {
 291             this.owner = (CPlatformWindow)owner;
 292         }
 293         this.contentView = view;
 294     }
 295 
 296     protected CPlatformResponder createPlatformResponder() {
 297         return new CPlatformResponder(peer, false);
 298     }
 299 
 300     protected CPlatformView createContentView() {
 301         return new CPlatformView();
 302     }
 303 
 304     protected int getInitialStyleBits() {
 305         // defaults style bits
 306         int styleBits = DECORATED | HAS_SHADOW | CLOSEABLE | MINIMIZABLE | ZOOMABLE | RESIZABLE;
 307 
 308         if (isNativelyFocusableWindow()) {
 309             styleBits = SET(styleBits, SHOULD_BECOME_KEY, true);
 310             styleBits = SET(styleBits, SHOULD_BECOME_MAIN, true);
 311         }
 312 
 313         final boolean isFrame = (target instanceof Frame);
 314         final boolean isDialog = (target instanceof Dialog);
 315         final boolean isPopup = (target.getType() == Window.Type.POPUP);
 316         if (isDialog) {
 317             styleBits = SET(styleBits, MINIMIZABLE, false);
 318         }
 319 
 320         // Either java.awt.Frame or java.awt.Dialog can be undecorated, however java.awt.Window always is undecorated.
 321         {
 322             this.undecorated = isFrame ? ((Frame)target).isUndecorated() : (isDialog ? ((Dialog)target).isUndecorated() : true);
 323             if (this.undecorated) styleBits = SET(styleBits, DECORATED, false);
 324         }
 325 
 326         // Either java.awt.Frame or java.awt.Dialog can be resizable, however java.awt.Window is never resizable
 327         {
 328             final boolean resizable = isFrame ? ((Frame)target).isResizable() : (isDialog ? ((Dialog)target).isResizable() : false);
 329             styleBits = SET(styleBits, RESIZABLE, resizable);
 330             if (!resizable) {
 331                 styleBits = SET(styleBits, ZOOMABLE, false);
 332             } else {
 333                 setCanFullscreen(true);
 334             }
 335         }
 336 
 337         if (target.isAlwaysOnTop()) {
 338             styleBits = SET(styleBits, ALWAYS_ON_TOP, true);
 339         }
 340 
 341         if (target.getModalExclusionType() == Dialog.ModalExclusionType.APPLICATION_EXCLUDE) {
 342             styleBits = SET(styleBits, MODAL_EXCLUDED, true);
 343         }
 344 
 345         // If the target is a dialog, popup or tooltip we want it to ignore the brushed metal look.
 346         if (isPopup) {
 347             styleBits = SET(styleBits, TEXTURED, false);
 348             // Popups in applets don't activate applet's process
 349             styleBits = SET(styleBits, NONACTIVATING, true);
 350             styleBits = SET(styleBits, IS_POPUP, true);
 351         }
 352 
 353         if (Window.Type.UTILITY.equals(target.getType())) {
 354             styleBits = SET(styleBits, UTILITY, true);
 355         }
 356 
 357         if (target instanceof javax.swing.RootPaneContainer) {
 358             javax.swing.JRootPane rootpane = ((javax.swing.RootPaneContainer)target).getRootPane();
 359             Object prop = null;
 360 
 361             prop = rootpane.getClientProperty(WINDOW_BRUSH_METAL_LOOK);
 362             if (prop != null) {
 363                 styleBits = SET(styleBits, TEXTURED, Boolean.parseBoolean(prop.toString()));
 364             }
 365 
 366             if (isDialog && ((Dialog)target).getModalityType() == ModalityType.DOCUMENT_MODAL) {
 367                 prop = rootpane.getClientProperty(WINDOW_DOC_MODAL_SHEET);
 368                 if (prop != null) {
 369                     styleBits = SET(styleBits, SHEET, Boolean.parseBoolean(prop.toString()));
 370                 }
 371             }
 372 
 373             prop = rootpane.getClientProperty(WINDOW_STYLE);
 374             if (prop != null) {
 375                 if ("small".equals(prop))  {
 376                     styleBits = SET(styleBits, UTILITY, true);
 377                     if (target.isAlwaysOnTop() && rootpane.getClientProperty(WINDOW_HIDES_ON_DEACTIVATE) == null) {
 378                         styleBits = SET(styleBits, HIDES_ON_DEACTIVATE, true);
 379                     }
 380                 }
 381                 if ("textured".equals(prop)) styleBits = SET(styleBits, TEXTURED, true);
 382                 if ("unified".equals(prop)) styleBits = SET(styleBits, UNIFIED, true);
 383                 if ("hud".equals(prop)) styleBits = SET(styleBits, HUD, true);
 384             }
 385 
 386             prop = rootpane.getClientProperty(WINDOW_HIDES_ON_DEACTIVATE);
 387             if (prop != null) {
 388                 styleBits = SET(styleBits, HIDES_ON_DEACTIVATE, Boolean.parseBoolean(prop.toString()));
 389             }
 390 
 391             prop = rootpane.getClientProperty(WINDOW_CLOSEABLE);
 392             if (prop != null) {
 393                 styleBits = SET(styleBits, CLOSEABLE, Boolean.parseBoolean(prop.toString()));
 394             }
 395 
 396             prop = rootpane.getClientProperty(WINDOW_MINIMIZABLE);
 397             if (prop != null) {
 398                 styleBits = SET(styleBits, MINIMIZABLE, Boolean.parseBoolean(prop.toString()));
 399             }
 400 
 401             prop = rootpane.getClientProperty(WINDOW_ZOOMABLE);
 402             if (prop != null) {
 403                 styleBits = SET(styleBits, ZOOMABLE, Boolean.parseBoolean(prop.toString()));
 404             }
 405 
 406             prop = rootpane.getClientProperty(WINDOW_FULLSCREENABLE);
 407             if (prop != null) {
 408                 styleBits = SET(styleBits, FULLSCREENABLE, Boolean.parseBoolean(prop.toString()));
 409             }
 410 
 411             prop = rootpane.getClientProperty(WINDOW_SHADOW);
 412             if (prop != null) {
 413                 styleBits = SET(styleBits, HAS_SHADOW, Boolean.parseBoolean(prop.toString()));
 414             }
 415 
 416             prop = rootpane.getClientProperty(WINDOW_DRAGGABLE_BACKGROUND);
 417             if (prop != null) {
 418                 styleBits = SET(styleBits, DRAGGABLE_BACKGROUND, Boolean.parseBoolean(prop.toString()));
 419             }
 420         }
 421 
 422         if (isDialog) {
 423             styleBits = SET(styleBits, IS_DIALOG, true);
 424             if (((Dialog) target).isModal()) {
 425                 styleBits = SET(styleBits, IS_MODAL, true);
 426             }
 427         }
 428 
 429         peer.setTextured(IS(TEXTURED, styleBits));
 430 
 431         return styleBits;
 432     }
 433 
 434     // this is the counter-point to -[CWindow _nativeSetStyleBit:]
 435     private void setStyleBits(final int mask, final boolean value) {
 436         nativeSetNSWindowStyleBits(getNSWindowPtr(), mask, value ? mask : 0);
 437     }
 438 
 439     private native void _toggleFullScreenMode(final long model);
 440 
 441     public void toggleFullScreen() {
 442         _toggleFullScreenMode(getNSWindowPtr());
 443     }
 444 
 445     @Override // PlatformWindow
 446     public void setMenuBar(MenuBar mb) {
 447         final long nsWindowPtr = getNSWindowPtr();
 448         CMenuBar mbPeer = (CMenuBar)LWToolkit.targetToPeer(mb);
 449         if (mbPeer != null) {
 450             nativeSetNSWindowMenuBar(nsWindowPtr, mbPeer.getModel());
 451         } else {
 452             nativeSetNSWindowMenuBar(nsWindowPtr, 0);
 453         }
 454     }
 455 
 456     @Override // PlatformWindow
 457     public void dispose() {
 458         contentView.dispose();
 459         nativeDispose(getNSWindowPtr());
 460         CPlatformWindow.super.dispose();
 461     }
 462 
 463     @Override // PlatformWindow
 464     public FontMetrics getFontMetrics(Font f) {
 465         // TODO: not implemented
 466         (new RuntimeException("unimplemented")).printStackTrace();
 467         return null;
 468     }
 469 
 470     @Override // PlatformWindow
 471     public Insets getInsets() {
 472         return nativeGetNSWindowInsets(getNSWindowPtr());
 473     }
 474 
 475     @Override // PlatformWindow
 476     public Point getLocationOnScreen() {
 477         return new Point(nativeBounds.x, nativeBounds.y);
 478     }
 479 
 480     @Override
 481     public GraphicsDevice getGraphicsDevice() {
 482         return contentView.getGraphicsDevice();
 483     }
 484 
 485     @Override // PlatformWindow
 486     public SurfaceData getScreenSurface() {
 487         // TODO: not implemented
 488         return null;
 489     }
 490 
 491     @Override // PlatformWindow
 492     public SurfaceData replaceSurfaceData() {
 493         return contentView.replaceSurfaceData();
 494     }
 495 
 496     @Override // PlatformWindow
 497     public void setBounds(int x, int y, int w, int h) {
 498         nativeSetNSWindowBounds(getNSWindowPtr(), x, y, w, h);
 499     }
 500 
 501     public void setMaximizedBounds(int x, int y, int w, int h) {
 502         nativeSetNSWindowStandardFrame(getNSWindowPtr(), x, y, w, h);
 503     }
 504 
 505     private boolean isMaximized() {
 506         return undecorated ? this.normalBounds != null
 507                 : CWrapper.NSWindow.isZoomed(getNSWindowPtr());
 508     }
 509 
 510     private void maximize() {
 511         if (peer == null || isMaximized()) {
 512             return;
 513         }
 514         if (!undecorated) {
 515             CWrapper.NSWindow.zoom(getNSWindowPtr());
 516         } else {
 517             deliverZoom(true);
 518 
 519             // We need an up to date size of the peer, so we flush the native events
 520             // to be sure that there are no setBounds requests in the queue.
 521             LWCToolkit.flushNativeSelectors();
 522             this.normalBounds = peer.getBounds();
 523             Rectangle maximizedBounds = peer.getMaximizedBounds();
 524             setBounds(maximizedBounds.x, maximizedBounds.y,
 525                     maximizedBounds.width, maximizedBounds.height);
 526         }
 527     }
 528 
 529     private void unmaximize() {
 530         if (!isMaximized()) {
 531             return;
 532         }
 533         if (!undecorated) {
 534             CWrapper.NSWindow.zoom(getNSWindowPtr());
 535         } else {
 536             deliverZoom(false);
 537 
 538             Rectangle toBounds = this.normalBounds;
 539             this.normalBounds = null;
 540             setBounds(toBounds.x, toBounds.y, toBounds.width, toBounds.height);
 541         }
 542     }
 543 
 544     public boolean isVisible() {
 545         return this.visible;
 546     }
 547 
 548     @Override // PlatformWindow
 549     public void setVisible(boolean visible) {
 550         final long nsWindowPtr = getNSWindowPtr();
 551 
 552         // Configure stuff
 553         updateIconImages();
 554         updateFocusabilityForAutoRequestFocus(false);
 555 
 556         boolean wasMaximized = isMaximized();
 557 
 558         if (visible && target.isLocationByPlatform()) {
 559             nativeSetNSWindowLocationByPlatform(getNSWindowPtr());
 560         }
 561 
 562         // Actually show or hide the window
 563         LWWindowPeer blocker = (peer == null)? null : peer.getBlocker();
 564         if (blocker == null || !visible) {
 565             // If it ain't blocked, or is being hidden, go regular way
 566             if (visible) {
 567                 CWrapper.NSWindow.makeFirstResponder(nsWindowPtr, contentView.getAWTView());
 568 
 569                 boolean isPopup = (target.getType() == Window.Type.POPUP);
 570                 if (isPopup) {
 571                     // Popups in applets don't activate applet's process
 572                     CWrapper.NSWindow.orderFrontRegardless(nsWindowPtr);
 573                 } else {
 574                     CWrapper.NSWindow.orderFront(nsWindowPtr);
 575                 }
 576 
 577                 boolean isKeyWindow = CWrapper.NSWindow.isKeyWindow(nsWindowPtr);
 578                 if (!isKeyWindow) {
 579                     CWrapper.NSWindow.makeKeyWindow(nsWindowPtr);
 580                 }
 581             } else {
 582                 // immediately hide the window
 583                 CWrapper.NSWindow.orderOut(nsWindowPtr);
 584                 // process the close
 585                 CWrapper.NSWindow.close(nsWindowPtr);
 586             }
 587         } else {
 588             // otherwise, put it in a proper z-order
 589             CWrapper.NSWindow.orderWindow(nsWindowPtr, CWrapper.NSWindow.NSWindowBelow,
 590                     ((CPlatformWindow)blocker.getPlatformWindow()).getNSWindowPtr());
 591         }
 592         this.visible = visible;
 593 
 594         // Manage the extended state when showing
 595         if (visible) {
 596             // Apply the extended state as expected in shared code
 597             if (target instanceof Frame) {
 598                 if (!wasMaximized && isMaximized()) {
 599                     // setVisible could have changed the native maximized state
 600                     deliverZoom(true);
 601                 } else {
 602                     int frameState = ((Frame)target).getExtendedState();
 603                     if ((frameState & Frame.ICONIFIED) != 0) {
 604                         // Treat all state bit masks with ICONIFIED bit as ICONIFIED state.
 605                         frameState = Frame.ICONIFIED;
 606                     }
 607                     switch (frameState) {
 608                         case Frame.ICONIFIED:
 609                             CWrapper.NSWindow.miniaturize(nsWindowPtr);
 610                             break;
 611                         case Frame.MAXIMIZED_BOTH:
 612                             maximize();
 613                             break;
 614                         default: // NORMAL
 615                             unmaximize(); // in case it was maximized, otherwise this is a no-op
 616                             break;
 617                     }
 618                 }
 619             }
 620         }
 621 
 622         nativeSynthesizeMouseEnteredExitedEvents();
 623 
 624         // Configure stuff #2
 625         updateFocusabilityForAutoRequestFocus(true);
 626 
 627         // Manage parent-child relationship when showing
 628         final ComponentAccessor acc = AWTAccessor.getComponentAccessor();
 629 
 630         if (visible) {
 631             // Order myself above my parent
 632             if (owner != null && owner.isVisible()) {
 633                 CWrapper.NSWindow.orderWindow(nsWindowPtr, CWrapper.NSWindow.NSWindowAbove, owner.getNSWindowPtr());
 634                 applyWindowLevel(target);
 635             }
 636 
 637             // Order my own children above myself
 638             for (Window w : target.getOwnedWindows()) {
 639                 final Object p = acc.getPeer(w);
 640                 if (p instanceof LWWindowPeer) {
 641                     CPlatformWindow pw = (CPlatformWindow)((LWWindowPeer)p).getPlatformWindow();
 642                     if (pw != null && pw.isVisible()) {
 643                         CWrapper.NSWindow.orderWindow(pw.getNSWindowPtr(), CWrapper.NSWindow.NSWindowAbove, nsWindowPtr);
 644                         pw.applyWindowLevel(w);
 645                     }
 646                 }
 647             }
 648         }
 649 
 650         // Deal with the blocker of the window being shown
 651         if (blocker != null && visible) {
 652             // Make sure the blocker is above its siblings
 653             ((CPlatformWindow)blocker.getPlatformWindow()).orderAboveSiblings();
 654         }
 655     }
 656 
 657     @Override // PlatformWindow
 658     public void setTitle(String title) {
 659         nativeSetNSWindowTitle(getNSWindowPtr(), title);
 660     }
 661 
 662     // Should be called on every window key property change.
 663     @Override // PlatformWindow
 664     public void updateIconImages() {
 665         final long nsWindowPtr = getNSWindowPtr();
 666         final CImage cImage = getImageForTarget();
 667         nativeSetNSWindowMinimizedIcon(nsWindowPtr, cImage == null ? 0L : cImage.ptr);
 668     }
 669 
 670     public long getNSWindowPtr() {
 671         final long nsWindowPtr = ptr;
 672         if (nsWindowPtr == 0L) {
 673             if(logger.isLoggable(PlatformLogger.Level.FINE)) {
 674                 logger.fine("NSWindow already disposed?", new Exception("Pointer to native NSWindow is invalid."));
 675             }
 676         }
 677         return nsWindowPtr;
 678     }
 679 
 680     public SurfaceData getSurfaceData() {
 681         return contentView.getSurfaceData();
 682     }
 683 
 684     @Override  // PlatformWindow
 685     public void toBack() {
 686         final long nsWindowPtr = getNSWindowPtr();
 687         nativePushNSWindowToBack(nsWindowPtr);
 688     }
 689 
 690     @Override  // PlatformWindow
 691     public void toFront() {
 692         final long nsWindowPtr = getNSWindowPtr();
 693         LWCToolkit lwcToolkit = (LWCToolkit) Toolkit.getDefaultToolkit();
 694         Window w = DefaultKeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow();
 695         final ComponentAccessor acc = AWTAccessor.getComponentAccessor();
 696         if( w != null && acc.getPeer(w) != null
 697                 && ((LWWindowPeer)acc.getPeer(w)).getPeerType() == LWWindowPeer.PeerType.EMBEDDED_FRAME
 698                 && !lwcToolkit.isApplicationActive()) {
 699             lwcToolkit.activateApplicationIgnoringOtherApps();
 700         }
 701         updateFocusabilityForAutoRequestFocus(false);
 702         nativePushNSWindowToFront(nsWindowPtr);
 703         updateFocusabilityForAutoRequestFocus(true);
 704     }
 705 
 706     private void setCanFullscreen(final boolean canFullScreen) {
 707         if (target instanceof RootPaneContainer
 708                 && getPeer().getPeerType() == PeerType.FRAME) {
 709 
 710             if (isInFullScreen && !canFullScreen) {
 711                 toggleFullScreen();
 712             }
 713 
 714             final RootPaneContainer rpc = (RootPaneContainer) target;
 715             rpc.getRootPane().putClientProperty(
 716                     CPlatformWindow.WINDOW_FULLSCREENABLE, canFullScreen);
 717         }
 718     }
 719 
 720     @Override
 721     public void setResizable(final boolean resizable) {
 722         setCanFullscreen(resizable);
 723         setStyleBits(RESIZABLE, resizable);
 724         setStyleBits(ZOOMABLE, resizable);
 725     }
 726 
 727     @Override
 728     public void setSizeConstraints(int minW, int minH, int maxW, int maxH) {
 729         nativeSetNSWindowMinMax(getNSWindowPtr(), minW, minH, maxW, maxH);
 730     }
 731 
 732     @Override
 733     public boolean rejectFocusRequest(FocusEvent.Cause cause) {
 734         // Cross-app activation requests are not allowed.
 735         if (cause != FocusEvent.Cause.MOUSE_EVENT &&
 736             !((LWCToolkit)Toolkit.getDefaultToolkit()).isApplicationActive())
 737         {
 738             focusLogger.fine("the app is inactive, so the request is rejected");
 739             return true;
 740         }
 741         return false;
 742     }
 743 
 744     @Override
 745     public boolean requestWindowFocus() {
 746 
 747         long ptr = getNSWindowPtr();
 748         if (CWrapper.NSWindow.canBecomeMainWindow(ptr)) {
 749             CWrapper.NSWindow.makeMainWindow(ptr);
 750         }
 751         CWrapper.NSWindow.makeKeyAndOrderFront(ptr);
 752         return true;
 753     }
 754 
 755     @Override
 756     public boolean isActive() {
 757         long ptr = getNSWindowPtr();
 758         return CWrapper.NSWindow.isKeyWindow(ptr);
 759     }
 760 
 761     @Override
 762     public void updateFocusableWindowState() {
 763         final boolean isFocusable = isNativelyFocusableWindow();
 764         setStyleBits(SHOULD_BECOME_KEY | SHOULD_BECOME_MAIN, isFocusable); // set both bits at once
 765     }
 766 
 767     @Override
 768     public void setAlwaysOnTop(boolean isAlwaysOnTop) {
 769         setStyleBits(ALWAYS_ON_TOP, isAlwaysOnTop);
 770     }
 771 
 772     @Override
 773     public void setOpacity(float opacity) {
 774         CWrapper.NSWindow.setAlphaValue(getNSWindowPtr(), opacity);
 775     }
 776 
 777     @Override
 778     public void setOpaque(boolean isOpaque) {
 779         CWrapper.NSWindow.setOpaque(getNSWindowPtr(), isOpaque);
 780         boolean isTextured = (peer == null) ? false : peer.isTextured();
 781         if (!isTextured) {
 782             if (!isOpaque) {
 783                 CWrapper.NSWindow.setBackgroundColor(getNSWindowPtr(), 0);
 784             } else if (peer != null) {
 785                 Color color = peer.getBackground();
 786                 if (color != null) {
 787                     int rgb = color.getRGB();
 788                     CWrapper.NSWindow.setBackgroundColor(getNSWindowPtr(), rgb);
 789                 }
 790             }
 791         }
 792 
 793         //This is a temporary workaround. Looks like after 7124236 will be fixed
 794         //the correct place for invalidateShadow() is CGLayer.drawInCGLContext.
 795         SwingUtilities.invokeLater(this::invalidateShadow);
 796     }
 797 
 798     @Override
 799     public void enterFullScreenMode() {
 800         isFullScreenMode = true;
 801         nativeEnterFullScreenMode(getNSWindowPtr());
 802     }
 803 
 804     @Override
 805     public void exitFullScreenMode() {
 806         nativeExitFullScreenMode(getNSWindowPtr());
 807         isFullScreenMode = false;
 808     }
 809 
 810     @Override
 811     public boolean isFullScreenMode() {
 812         return isFullScreenMode;
 813     }
 814 
 815     @Override
 816     public void setWindowState(int windowState) {
 817         if (peer == null || !peer.isVisible()) {
 818             // setVisible() applies the state
 819             return;
 820         }
 821 
 822         int prevWindowState = peer.getState();
 823         if (prevWindowState == windowState) return;
 824 
 825         final long nsWindowPtr = getNSWindowPtr();
 826         if ((windowState & Frame.ICONIFIED) != 0) {
 827             // Treat all state bit masks with ICONIFIED bit as ICONIFIED state.
 828             windowState = Frame.ICONIFIED;
 829         }
 830         switch (windowState) {
 831             case Frame.ICONIFIED:
 832                 if (prevWindowState == Frame.MAXIMIZED_BOTH) {
 833                     // let's return into the normal states first
 834                     // the zoom call toggles between the normal and the max states
 835                     unmaximize();
 836                 }
 837                 CWrapper.NSWindow.miniaturize(nsWindowPtr);
 838                 break;
 839             case Frame.MAXIMIZED_BOTH:
 840                 if (prevWindowState == Frame.ICONIFIED) {
 841                     // let's return into the normal states first
 842                     CWrapper.NSWindow.deminiaturize(nsWindowPtr);
 843                 }
 844                 maximize();
 845                 break;
 846             case Frame.NORMAL:
 847                 if (prevWindowState == Frame.ICONIFIED) {
 848                     CWrapper.NSWindow.deminiaturize(nsWindowPtr);
 849                 } else if (prevWindowState == Frame.MAXIMIZED_BOTH) {
 850                     // the zoom call toggles between the normal and the max states
 851                     unmaximize();
 852                 }
 853                 break;
 854             default:
 855                 throw new RuntimeException("Unknown window state: " + windowState);
 856         }
 857 
 858         // NOTE: the SWP.windowState field gets updated to the newWindowState
 859         //       value when the native notification comes to us
 860     }
 861 
 862     @Override
 863     public void setModalBlocked(boolean blocked) {
 864         if (target.getModalExclusionType() == Dialog.ModalExclusionType.APPLICATION_EXCLUDE) {
 865             return;
 866         }
 867 
 868         if (blocked) {
 869             // We are going to show a modal window. Previously displayed window will be
 870             // blocked/disabled. So we have to send mouse exited event to it now, since
 871             // all mouse events are discarded for blocked/disabled windows.
 872             nativeSynthesizeMouseEnteredExitedEvents(getNSWindowPtr(), CocoaConstants.NSMouseExited);
 873         }
 874 
 875         nativeSetEnabled(getNSWindowPtr(), !blocked);
 876         checkBlockingAndOrder();
 877     }
 878 
 879     public final void invalidateShadow(){
 880         nativeRevalidateNSWindowShadow(getNSWindowPtr());
 881     }
 882 
 883     // ----------------------------------------------------------------------
 884     //                          UTILITY METHODS
 885     // ----------------------------------------------------------------------
 886 
 887     /**
 888      * Find image to install into Title or into Application icon. First try
 889      * icons installed for toplevel. Null is returned, if there is no icon and
 890      * default Duke image should be used.
 891      */
 892     private CImage getImageForTarget() {
 893         CImage icon = null;
 894         try {
 895             icon = CImage.getCreator().createFromImages(target.getIconImages());
 896         } catch (Exception ignored) {
 897             // Perhaps the icon passed into Java is broken. Skipping this icon.
 898         }
 899         return icon;
 900     }
 901 
 902     /*
 903      * Returns LWWindowPeer associated with this delegate.
 904      */
 905     @Override
 906     public LWWindowPeer getPeer() {
 907         return peer;
 908     }
 909 
 910     @Override
 911     public boolean isUnderMouse() {
 912         return contentView.isUnderMouse();
 913     }
 914 
 915     public CPlatformView getContentView() {
 916         return contentView;
 917     }
 918 
 919     @Override
 920     public long getLayerPtr() {
 921         return contentView.getWindowLayerPtr();
 922     }
 923 
 924     private void validateSurface() {
 925         SurfaceData surfaceData = getSurfaceData();
 926         if (surfaceData instanceof CGLSurfaceData) {
 927             ((CGLSurfaceData)surfaceData).validate();
 928         }
 929     }
 930 
 931     void flushBuffers() {
 932         if (isVisible() && !nativeBounds.isEmpty() && !isFullScreenMode) {
 933             try {
 934                 LWCToolkit.invokeAndWait(new Runnable() {
 935                     @Override
 936                     public void run() {
 937                         //Posting an empty to flush the EventQueue without blocking the main thread
 938                     }
 939                 }, target);
 940             } catch (InvocationTargetException e) {
 941                 e.printStackTrace();
 942             }
 943         }
 944     }
 945 
 946     /**
 947      * Helper method to get a pointer to the native view from the PlatformWindow.
 948      */
 949     static long getNativeViewPtr(PlatformWindow platformWindow) {
 950         long nativePeer = 0L;
 951         if (platformWindow instanceof CPlatformWindow) {
 952             nativePeer = ((CPlatformWindow) platformWindow).getContentView().getAWTView();
 953         } else if (platformWindow instanceof CViewPlatformEmbeddedFrame){
 954             nativePeer = ((CViewPlatformEmbeddedFrame) platformWindow).getNSViewPtr();
 955         }
 956         return nativePeer;
 957     }
 958 
 959     /*************************************************************
 960      * Callbacks from the AWTWindow and AWTView objc classes.
 961      *************************************************************/
 962     private void deliverWindowFocusEvent(boolean gained, CPlatformWindow opposite){
 963         // Fix for 7150349: ingore "gained" notifications when the app is inactive.
 964         if (gained && !((LWCToolkit)Toolkit.getDefaultToolkit()).isApplicationActive()) {
 965             focusLogger.fine("the app is inactive, so the notification is ignored");
 966             return;
 967         }
 968 
 969         LWWindowPeer oppositePeer = (opposite == null)? null : opposite.getPeer();
 970         responder.handleWindowFocusEvent(gained, oppositePeer);
 971     }
 972 
 973     protected void deliverMoveResizeEvent(int x, int y, int width, int height,
 974                                         boolean byUser) {
 975         checkZoom();
 976 
 977         final Rectangle oldB = nativeBounds;
 978         nativeBounds = new Rectangle(x, y, width, height);
 979         if (peer != null) {
 980             peer.notifyReshape(x, y, width, height);
 981             // System-dependent appearance optimization.
 982             if ((byUser && !oldB.getSize().equals(nativeBounds.getSize()))
 983                     || isFullScreenAnimationOn) {
 984                 flushBuffers();
 985             }
 986         }
 987     }
 988 
 989     private void deliverWindowClosingEvent() {
 990         if (peer != null && peer.getBlocker() == null) {
 991             peer.postEvent(new WindowEvent(target, WindowEvent.WINDOW_CLOSING));
 992         }
 993     }
 994 
 995     private void deliverIconify(final boolean iconify) {
 996         if (peer != null) {
 997             peer.notifyIconify(iconify);
 998         }
 999     }
1000 
1001     private void deliverZoom(final boolean isZoomed) {
1002         if (peer != null) {
1003             peer.notifyZoom(isZoomed);
1004         }
1005     }
1006 
1007     private void checkZoom() {
1008         if (peer != null) {
1009             int state = peer.getState();
1010             if (state != Frame.MAXIMIZED_BOTH && isMaximized()) {
1011                 deliverZoom(true);
1012             } else if (state == Frame.MAXIMIZED_BOTH && !isMaximized()) {
1013                 deliverZoom(false);
1014             }
1015         }
1016     }
1017 
1018     private void deliverNCMouseDown() {
1019         if (peer != null) {
1020             peer.notifyNCMouseDown();
1021         }
1022     }
1023 
1024     /*
1025      * Our focus model is synthetic and only non-simple window
1026      * may become natively focusable window.
1027      */
1028     private boolean isNativelyFocusableWindow() {
1029         if (peer == null) {
1030             return false;
1031         }
1032 
1033         return !peer.isSimpleWindow() && target.getFocusableWindowState();
1034     }
1035 
1036     /*
1037      * An utility method for the support of the auto request focus.
1038      * Updates the focusable state of the window under certain
1039      * circumstances.
1040      */
1041     private void updateFocusabilityForAutoRequestFocus(boolean isFocusable) {
1042         if (target.isAutoRequestFocus() || !isNativelyFocusableWindow()) return;
1043         setStyleBits(SHOULD_BECOME_KEY | SHOULD_BECOME_MAIN, isFocusable); // set both bits at once
1044     }
1045 
1046     private boolean checkBlockingAndOrder() {
1047         LWWindowPeer blocker = (peer == null)? null : peer.getBlocker();
1048         if (blocker == null) {
1049             return false;
1050         }
1051 
1052         if (blocker instanceof CPrinterDialogPeer) {
1053             return true;
1054         }
1055 
1056         CPlatformWindow pWindow = (CPlatformWindow)blocker.getPlatformWindow();
1057 
1058         pWindow.orderAboveSiblings();
1059 
1060         final long nsWindowPtr = pWindow.getNSWindowPtr();
1061         CWrapper.NSWindow.orderFrontRegardless(nsWindowPtr);
1062         CWrapper.NSWindow.makeKeyAndOrderFront(nsWindowPtr);
1063         CWrapper.NSWindow.makeMainWindow(nsWindowPtr);
1064 
1065         return true;
1066     }
1067 
1068     private boolean isOneOfOwnersOrSelf(CPlatformWindow window) {
1069         while (window != null) {
1070             if (this == window) {
1071                 return true;
1072             }
1073             window = window.owner;
1074         }
1075         return false;
1076     }
1077 
1078     private CPlatformWindow getRootOwner() {
1079         CPlatformWindow rootOwner = this;
1080         while (rootOwner.owner != null) {
1081             rootOwner = rootOwner.owner;
1082         }
1083         return rootOwner;









1084     }
1085 
1086     private void orderAboveSiblings() {
1087         // Recursively pop up the windows from the very bottom, (i.e. root owner) so that
1088         // the windows are ordered above their nearest owner; ancestors of the window,
1089         // which is going to become 'main window', are placed above their siblings.
1090         CPlatformWindow rootOwner = getRootOwner();
1091         if (rootOwner.isVisible()) {
1092             CWrapper.NSWindow.orderFront(rootOwner.getNSWindowPtr());
1093         }
1094         orderAboveSiblingsImpl(rootOwner.target.getOwnedWindows());
1095     }
1096 
1097     private void orderAboveSiblingsImpl(Window[] windows) {
1098         ArrayList<Window> childWindows = new ArrayList<Window>();
1099 
1100         final ComponentAccessor acc = AWTAccessor.getComponentAccessor();
1101 
1102         // Go through the list of windows and perform ordering.
1103         for (Window w : windows) {
1104             final Object p = acc.getPeer(w);
1105             if (p instanceof LWWindowPeer) {
1106                 CPlatformWindow pw = (CPlatformWindow)((LWWindowPeer)p).getPlatformWindow();
1107                 if (pw != null && pw.isVisible()) {
1108                     // If the window is one of ancestors of 'main window' or is going to become main by itself,
1109                     // the window should be ordered above its siblings; otherwise the window is just ordered
1110                     // above its nearest parent.
1111                     if (pw.isOneOfOwnersOrSelf(this)) {
1112                         CWrapper.NSWindow.orderFront(pw.getNSWindowPtr());
1113                     } else {
1114                         CWrapper.NSWindow.orderWindow(pw.getNSWindowPtr(), CWrapper.NSWindow.NSWindowAbove,
1115                                 pw.owner.getNSWindowPtr());
1116                     }
1117                     pw.applyWindowLevel(w);
1118                 }
1119             }
1120             // Retrieve the child windows for each window from the list and store them for future use.
1121             // Note: we collect data about child windows even for invisible owners, since they may have
1122             // visible children.
1123             java.util.List<Window> pwChildWindows = new ArrayList<Window>(Arrays.asList(w.getOwnedWindows()));
1124             childWindows.addAll(pwChildWindows);
1125         }
1126         // If some windows, which have just been ordered, have any child windows, let's start new iteration
1127         // and order these child windows.
1128         if (!childWindows.isEmpty()) {
1129             orderAboveSiblingsImpl(childWindows.toArray(new Window[childWindows.size()]));
1130         }
1131     }
1132 
1133     protected void applyWindowLevel(Window target) {
1134         if (target.isAlwaysOnTop() && target.getType() != Window.Type.POPUP) {
1135             CWrapper.NSWindow.setLevel(getNSWindowPtr(), CWrapper.NSWindow.NSFloatingWindowLevel);
1136         } else if (target.getType() == Window.Type.POPUP) {
1137             CWrapper.NSWindow.setLevel(getNSWindowPtr(), CWrapper.NSWindow.NSPopUpMenuWindowLevel);
1138         }
1139     }
1140 
1141     // ----------------------------------------------------------------------
1142     //                          NATIVE CALLBACKS
1143     // ----------------------------------------------------------------------
1144 
1145     private void windowDidBecomeMain() {
1146         if (checkBlockingAndOrder()) return;
1147         // If it's not blocked, make sure it's above its siblings
1148         orderAboveSiblings();
1149     }
1150 
1151     private void windowWillEnterFullScreen() {
1152         isFullScreenAnimationOn = true;
1153     }
1154 
1155     private void windowDidEnterFullScreen() {
1156         isInFullScreen = true;
1157         isFullScreenAnimationOn = false;
1158     }
1159 
1160     private void windowWillExitFullScreen() {
1161         isFullScreenAnimationOn = true;
1162     }
1163 
1164     private void windowDidExitFullScreen() {
1165         isInFullScreen = false;
1166         isFullScreenAnimationOn = false;
1167     }
1168 }
--- EOF ---