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