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