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