1 /*
2 * Copyright (c) 2010, 2014, 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 javafx.stage;
27
28 import com.sun.javafx.util.Utils;
29 import com.sun.javafx.event.DirectEvent;
30 import java.util.ArrayList;
31 import java.util.List;
32
33 import javafx.beans.InvalidationListener;
34 import javafx.beans.Observable;
35 import javafx.beans.property.BooleanProperty;
36 import javafx.beans.property.BooleanPropertyBase;
37 import javafx.beans.property.ObjectProperty;
38 import javafx.beans.property.ReadOnlyDoubleProperty;
39 import javafx.beans.property.ReadOnlyDoubleWrapper;
40 import javafx.beans.property.SimpleBooleanProperty;
41 import javafx.beans.property.SimpleObjectProperty;
42 import javafx.beans.value.ChangeListener;
43 import javafx.beans.value.ObservableValue;
44 import javafx.collections.ObservableList;
45 import javafx.event.Event;
46 import javafx.event.EventHandler;
47 import javafx.geometry.BoundingBox;
48 import javafx.geometry.Bounds;
49 import javafx.geometry.Rectangle2D;
50 import javafx.scene.Group;
51 import javafx.scene.Node;
52 import javafx.scene.Parent;
53 import javafx.scene.Scene;
54
55 import com.sun.javafx.event.EventHandlerManager;
56 import com.sun.javafx.event.EventRedirector;
57 import com.sun.javafx.event.EventUtil;
58 import com.sun.javafx.perf.PerformanceTracker;
59 import com.sun.javafx.scene.SceneHelper;
60 import com.sun.javafx.stage.FocusUngrabEvent;
61 import com.sun.javafx.stage.PopupWindowPeerListener;
62 import com.sun.javafx.stage.WindowCloseRequestHandler;
63 import com.sun.javafx.stage.WindowEventDispatcher;
64 import com.sun.javafx.tk.Toolkit;
65 import java.security.AllPermission;
66 import javafx.beans.property.ObjectPropertyBase;
67 import javafx.beans.property.ReadOnlyObjectProperty;
68 import javafx.beans.property.ReadOnlyObjectWrapper;
69 import javafx.beans.value.WeakChangeListener;
70 import javafx.event.EventTarget;
71 import javafx.event.EventType;
72 import javafx.scene.input.KeyCombination;
73 import javafx.scene.input.KeyEvent;
74 import javafx.scene.input.MouseEvent;
75 import javafx.scene.input.ScrollEvent;
76 import javafx.scene.layout.Background;
77 import javafx.scene.layout.Pane;
78
79 /**
80 * PopupWindow is the parent for a variety of different types of popup
81 * based windows including {@link Popup} and {@link javafx.scene.control.Tooltip}
82 * and {@link javafx.scene.control.ContextMenu}.
83 * <p>
84 * A PopupWindow is a secondary window which has no window decorations or title bar.
85 * It doesn't show up in the OS as a top-level window. It is typically
86 * used for tool tip like notification, drop down boxes, menus, and so forth.
87 * <p>
88 * The PopupWindow <strong>cannot be shown without an owner</strong>.
89 * PopupWindows require that an owner window exist in order to be shown. However,
90 * it is possible to create a PopupWindow ahead of time and simply set the owner
91 * (or change the owner) before first being made visible. Attempting to change
92 * the owner while the PopupWindow is visible will result in an IllegalStateException.
93 * <p>
94 * The PopupWindow encapsulates much of the behavior and functionality common to popups,
95 * such as the ability to close when the "esc" key is pressed, or the ability to
96 * hide all child popup windows whenever this window is hidden. These abilities can
97 * be enabled or disabled via properties.
98 * @since JavaFX 2.0
99 */
100 public abstract class PopupWindow extends Window {
101 /**
102 * A private list of all child popups.
103 */
104 private final List<PopupWindow> children = new ArrayList<PopupWindow>();
105
106 /**
107 * Keeps track of the bounds of the content, and adjust the position and
108 * size of the popup window accordingly. This way as the popup content
109 * changes, the window will be changed to match.
110 */
111 private final InvalidationListener popupWindowUpdater =
112 new InvalidationListener() {
113 @Override
114 public void invalidated(final Observable observable) {
115 cachedExtendedBounds = null;
116 cachedAnchorBounds = null;
117 updateWindow(getAnchorX(), getAnchorY());
118 }
119 };
120
121 /**
122 * RT-28454: When a parent node or parent window we are associated with is not
123 * visible anymore, possibly because the scene was not valid anymore, we should hide.
124 */
125 private ChangeListener<Boolean> changeListener = (observable, oldValue, newValue) -> {
126 if (oldValue && !newValue) {
127 hide();
128 }
129 };
130
131 private WeakChangeListener<Boolean> weakOwnerNodeListener = new WeakChangeListener(changeListener);
132
133 public PopupWindow() {
134 final Pane popupRoot = new Pane();
135 popupRoot.setBackground(Background.EMPTY);
136 popupRoot.getStyleClass().add("popup");
137
138 final Scene scene = SceneHelper.createPopupScene(popupRoot);
139 scene.setFill(null);
140 super.setScene(scene);
141
142 popupRoot.layoutBoundsProperty().addListener(popupWindowUpdater);
143 popupRoot.boundsInLocalProperty().addListener(popupWindowUpdater);
144 scene.rootProperty().addListener(
145 new InvalidationListener() {
146 private Node oldRoot = scene.getRoot();
147
148 @Override
149 public void invalidated(final Observable observable) {
150 final Node newRoot = scene.getRoot();
151 if (oldRoot != newRoot) {
152 if (oldRoot != null) {
153 oldRoot.layoutBoundsProperty()
154 .removeListener(popupWindowUpdater);
155 oldRoot.boundsInLocalProperty()
156 .removeListener(popupWindowUpdater);
157 oldRoot.getStyleClass().remove("popup");
158 }
159
160 if (newRoot != null) {
161 newRoot.layoutBoundsProperty()
162 .addListener(popupWindowUpdater);
163 newRoot.boundsInLocalProperty()
164 .addListener(popupWindowUpdater);
165 newRoot.getStyleClass().add("popup");
166 }
167
168 oldRoot = newRoot;
169
170 cachedExtendedBounds = null;
171 cachedAnchorBounds = null;
172 updateWindow(getAnchorX(), getAnchorY());
173 }
174 }
175 });
176 }
177
178 /**
179 * Gets the observable, modifiable list of children which are placed in this
180 * PopupWindow.
181 *
182 * @return the PopupWindow content
183 * @treatAsPrivate implementation detail
184 * @deprecated This is an internal API that is not intended for use and will be removed in the next version
185 */
186 @Deprecated
187 protected ObservableList<Node> getContent() {
188 final Parent rootNode = getScene().getRoot();
189 if (rootNode instanceof Group) {
190 return ((Group) rootNode).getChildren();
191 }
192
193 if (rootNode instanceof Pane) {
194 return ((Pane) rootNode).getChildren();
195 }
196
197 throw new IllegalStateException(
198 "The content of the Popup can't be accessed");
199 }
200
201 /**
202 * The window which is the parent of this popup. All popups must have an
203 * owner window.
204 */
205 private ReadOnlyObjectWrapper<Window> ownerWindow =
206 new ReadOnlyObjectWrapper<Window>(this, "ownerWindow");
207 public final Window getOwnerWindow() {
208 return ownerWindow.get();
209 }
210 public final ReadOnlyObjectProperty<Window> ownerWindowProperty() {
211 return ownerWindow.getReadOnlyProperty();
212 }
213
214 /**
215 * The node which is the owner of this popup. All popups must have an
216 * owner window but are not required to be associated with an owner node.
217 * If an autohide Popup has an owner node, mouse press inside the owner node
218 * doesn't cause the Popup to hide.
219 */
220 private ReadOnlyObjectWrapper<Node> ownerNode =
221 new ReadOnlyObjectWrapper<Node>(this, "ownerNode");
222 public final Node getOwnerNode() {
223 return ownerNode.get();
224 }
225 public final ReadOnlyObjectProperty<Node> ownerNodeProperty() {
226 return ownerNode.getReadOnlyProperty();
227 }
228
229 /**
230 * Note to subclasses: the scene used by PopupWindow is very specifically
231 * managed by PopupWindow. This method is overridden to throw
232 * UnsupportedOperationException. You cannot specify your own scene.
233 *
234 * @param scene
235 */
236 @Override protected final void setScene(Scene scene) {
237 throw new UnsupportedOperationException();
238 }
239
240 /**
241 * This convenience variable indicates whether, when the popup is shown,
242 * it should automatically correct its position such that it doesn't end
243 * up positioned off the screen.
244 * @defaultValue true
245 */
246 private BooleanProperty autoFix =
247 new BooleanPropertyBase(true) {
248 @Override
249 protected void invalidated() {
250 handleAutofixActivation(isShowing(), get());
251 }
252
253 @Override
254 public Object getBean() {
255 return PopupWindow.this;
256 }
257
258 @Override
259 public String getName() {
260 return "autoFix";
261 }
262 };
263 public final void setAutoFix(boolean value) { autoFix.set(value); }
264 public final boolean isAutoFix() { return autoFix.get(); }
265 public final BooleanProperty autoFixProperty() { return autoFix; }
266
267 /**
268 * Specifies whether Popups should auto hide. If a popup loses focus and
269 * autoHide is true, then the popup will be hidden automatically.
270 * <p>
271 * The only exception is when owner Node is specified using {@link #show(javafx.scene.Node, double, double)}.
272 * Focusing owner Node will not hide the PopupWindow.
273 * </p>
274 * @defaultValue false
275 */
276 private BooleanProperty autoHide =
277 new BooleanPropertyBase() {
278 @Override
279 protected void invalidated() {
280 handleAutohideActivation(isShowing(), get());
281 }
282
283 @Override
284 public Object getBean() {
285 return PopupWindow.this;
286 }
287
288 @Override
289 public String getName() {
290 return "autoHide";
291 }
292 };
293 public final void setAutoHide(boolean value) { autoHide.set(value); }
294 public final boolean isAutoHide() { return autoHide.get(); }
295 public final BooleanProperty autoHideProperty() { return autoHide; }
296
297 /**
298 * Called after autoHide is run.
299 */
300 private ObjectProperty<EventHandler<Event>> onAutoHide =
301 new SimpleObjectProperty<EventHandler<Event>>(this, "onAutoHide");
302 public final void setOnAutoHide(EventHandler<Event> value) { onAutoHide.set(value); }
303 public final EventHandler<Event> getOnAutoHide() { return onAutoHide.get(); }
304 public final ObjectProperty<EventHandler<Event>> onAutoHideProperty() { return onAutoHide; }
305
306 /**
307 * Specifies whether the PopupWindow should be hidden when an unhandled escape key
308 * is pressed while the popup has focus.
309 * @defaultValue true
310 */
311 private BooleanProperty hideOnEscape =
312 new SimpleBooleanProperty(this, "hideOnEscape", true);
313 public final void setHideOnEscape(boolean value) { hideOnEscape.set(value); }
314 public final boolean isHideOnEscape() { return hideOnEscape.get(); }
315 public final BooleanProperty hideOnEscapeProperty() { return hideOnEscape; }
316
317 /**
318 * Specifies whether the event, which caused the Popup to hide, should be
319 * consumed. Having the event consumed prevents it from triggering some
320 * additional UI response in the Popup's owner window.
321 * @defaultValue true
322 * @since JavaFX 2.2
323 */
324 private BooleanProperty consumeAutoHidingEvents =
325 new SimpleBooleanProperty(this, "consumeAutoHidingEvents",
326 true);
327
328 public final void setConsumeAutoHidingEvents(boolean value) {
329 consumeAutoHidingEvents.set(value);
330 }
331
332 public final boolean getConsumeAutoHidingEvents() {
333 return consumeAutoHidingEvents.get();
334 }
335
336 public final BooleanProperty consumeAutoHidingEventsProperty() {
337 return consumeAutoHidingEvents;
338 }
339
340 /**
341 * Show the popup.
342 * @param owner The owner of the popup. This must not be null.
343 * @throws NullPointerException if owner is null
344 * @throws IllegalArgumentException if the specified owner window would
345 * create cycle in the window hierarchy
346 */
347 public void show(Window owner) {
348 validateOwnerWindow(owner);
349 showImpl(owner);
350 }
351
352 /**
353 * Shows the popup at the specified location on the screen. The popup window
354 * is positioned in such way that its anchor point ({@see #anchorLocation})
355 * is displayed at the specified {@code anchorX} and {@code anchorY}
356 * coordinates.
357 * <p>
358 * The popup is associated with the specified owner node. The {@code Window}
359 * which contains the owner node at the time of the call becomes an owner
360 * window of the displayed popup.
361 * </p>
362 * <p>
363 * Note that when {@link #autoHideProperty()} is set to true, mouse press on the owner Node
364 * will not hide the PopupWindow.
365 * </p>
366 *
367 * @param ownerNode The owner Node of the popup. It must not be null
368 * and must be associated with a Window.
369 * @param anchorX the x position of the popup anchor in screen coordinates
370 * @param anchorY the y position of the popup anchor in screen coordinates
371 * @throws NullPointerException if ownerNode is null
372 * @throws IllegalArgumentException if the specified owner node is not
373 * associated with a Window or when the window would create cycle
374 * in the window hierarchy
375 */
376 public void show(Node ownerNode, double anchorX, double anchorY) {
377 if (ownerNode == null) {
378 throw new NullPointerException("The owner node must not be null");
379 }
380
381 final Scene ownerNodeScene = ownerNode.getScene();
382 if ((ownerNodeScene == null)
383 || (ownerNodeScene.getWindow() == null)) {
384 throw new IllegalArgumentException(
385 "The owner node needs to be associated with a window");
386 }
387
388 final Window newOwnerWindow = ownerNodeScene.getWindow();
389 validateOwnerWindow(newOwnerWindow);
390
391 this.ownerNode.set(ownerNode);
392
393 // RT-28454 PopupWindow should disappear when owner node is not visible
394 if (ownerNode != null) {
395 ownerNode.visibleProperty().addListener(weakOwnerNodeListener);
396 }
397
398 updateWindow(anchorX, anchorY);
399 showImpl(newOwnerWindow);
400 }
401
402 /**
403 * Shows the popup at the specified location on the screen. The popup window
404 * is positioned in such way that its anchor point ({@see #anchorLocation})
405 * is displayed at the specified {@code anchorX} and {@code anchorY}
406 * coordinates.
407 *
408 * @param ownerWindow The owner of the popup. This must not be null.
409 * @param anchorX the x position of the popup anchor in screen coordinates
410 * @param anchorY the y position of the popup anchor in screen coordinates
411 * @throws NullPointerException if ownerWindow is null
412 * @throws IllegalArgumentException if the specified owner window would
413 * create cycle in the window hierarchy
414 */
415 public void show(Window ownerWindow, double anchorX, double anchorY) {
416 validateOwnerWindow(ownerWindow);
417
418 updateWindow(anchorX, anchorY);
419 showImpl(ownerWindow);
420 }
421
422 private void showImpl(final Window owner) {
423 // Update the owner field
424 this.ownerWindow.set(owner);
425 if (owner instanceof PopupWindow) {
426 ((PopupWindow)owner).children.add(this);
427 }
428 // RT-28454 PopupWindow should disappear when owner node is not visible
429 if (owner != null) {
430 owner.showingProperty().addListener(weakOwnerNodeListener);
431 }
432
433 final Scene sceneValue = getScene();
434 SceneHelper.parentEffectiveOrientationInvalidated(sceneValue);
435
436 // RT-28447
437 final Scene ownerScene = getRootWindow(owner).getScene();
438 if (ownerScene != null) {
439 if (ownerScene.getUserAgentStylesheet() != null) {
440 sceneValue.setUserAgentStylesheet(ownerScene.getUserAgentStylesheet());
441 }
442 sceneValue.getStylesheets().setAll(ownerScene.getStylesheets());
443 if (sceneValue.getCursor() == null) {
444 sceneValue.setCursor(ownerScene.getCursor());
445 }
446 }
447
448 // It is required that the root window exist and be visible to show the popup.
449 if (getRootWindow(owner).isShowing()) {
450 // We do show() first so that the width and height of the
451 // popup window are initialized. This way the x,y location of the
452 // popup calculated below uses the right width and height values for
453 // its calculation. (fix for part of RT-10675).
454 show();
455 }
456 }
457
458 /**
459 * Hide this Popup and all its children
460 */
461 @Override public void hide() {
462 for (PopupWindow c : children) {
463 if (c.isShowing()) {
464 c.hide();
465 }
466 }
467 children.clear();
468 super.hide();
469 // RT-28454 when popup hides, remove listeners; these are added when the popup shows.
470 if (getOwnerWindow() != null) getOwnerWindow().showingProperty().removeListener(weakOwnerNodeListener);
471 if (getOwnerNode() != null) getOwnerNode().visibleProperty().removeListener(weakOwnerNodeListener);
472 }
473
474 /**
475 * @treatAsPrivate implementation detail
476 * @deprecated This is an internal API that is not intended for use and will be removed in the next version
477 */
478 @Deprecated
479 @Override protected void impl_visibleChanging(boolean visible) {
480 super.impl_visibleChanging(visible);
481 PerformanceTracker.logEvent("PopupWindow.storeVisible for [PopupWindow]");
482
483 Toolkit toolkit = Toolkit.getToolkit();
484 if (visible && (impl_peer == null)) {
485 // Setup the peer
486 StageStyle popupStyle;
487 try {
488 final SecurityManager securityManager =
489 System.getSecurityManager();
490 if (securityManager != null) {
491 securityManager.checkPermission(new AllPermission());
492 }
493 popupStyle = StageStyle.TRANSPARENT;
494 } catch (final SecurityException e) {
495 popupStyle = StageStyle.UNDECORATED;
496 }
497 impl_peer = toolkit.createTKPopupStage(this, popupStyle, getOwnerWindow().impl_getPeer(), acc);
498 peerListener = new PopupWindowPeerListener(PopupWindow.this);
499 }
500 }
501
502 private Window rootWindow;
503
504 /**
505 * @treatAsPrivate implementation detail
506 * @deprecated This is an internal API that is not intended for use and will be removed in the next version
507 */
508 @Deprecated
509 @Override protected void impl_visibleChanged(boolean visible) {
510 super.impl_visibleChanged(visible);
511
512 final Window ownerWindowValue = getOwnerWindow();
513 if (visible) {
514 rootWindow = getRootWindow(ownerWindowValue);
515
516 startMonitorOwnerEvents(ownerWindowValue);
517 // currently we consider popup window to be focused when it is
518 // visible and its owner window is focused (we need to track
519 // that through listener on owner window focused property)
520 // a better solution would require some focus manager, which can
521 // track focus state across multiple windows
522 bindOwnerFocusedProperty(ownerWindowValue);
523 setFocused(ownerWindowValue.isFocused());
524 handleAutofixActivation(true, isAutoFix());
525 handleAutohideActivation(true, isAutoHide());
526 } else {
527 stopMonitorOwnerEvents(ownerWindowValue);
528 unbindOwnerFocusedProperty(ownerWindowValue);
529 setFocused(false);
530 handleAutofixActivation(false, isAutoFix());
531 handleAutohideActivation(false, isAutoHide());
532 rootWindow = null;
533 }
534
535 PerformanceTracker.logEvent("PopupWindow.storeVisible for [PopupWindow] finished");
536 }
537
538 /**
539 * Specifies the x coordinate of the popup anchor point on the screen. If
540 * the {@code anchorLocation} is set to {@code WINDOW_TOP_LEFT} or
541 * {@code WINDOW_BOTTOM_LEFT} the {@code x} and {@code anchorX} values will
542 * be identical.
543 *
544 * @since JavaFX 8.0
545 */
546 private final ReadOnlyDoubleWrapper anchorX =
547 new ReadOnlyDoubleWrapper(this, "anchorX", Double.NaN);
548
549 public final void setAnchorX(final double value) {
550 updateWindow(value, getAnchorY());
551 }
552 public final double getAnchorX() {
553 return anchorX.get();
554 }
555 public final ReadOnlyDoubleProperty anchorXProperty() {
556 return anchorX.getReadOnlyProperty();
557 }
558
559 /**
560 * Specifies the y coordinate of the popup anchor point on the screen. If
561 * the {@code anchorLocation} is set to {@code WINDOW_TOP_LEFT} or
562 * {@code WINDOW_TOP_RIGHT} the {@code y} and {@code anchorY} values will
563 * be identical.
564 *
565 * @since JavaFX 8.0
566 */
567 private final ReadOnlyDoubleWrapper anchorY =
568 new ReadOnlyDoubleWrapper(this, "anchorY", Double.NaN);
569
570 public final void setAnchorY(final double value) {
571 updateWindow(getAnchorX(), value);
572 }
573 public final double getAnchorY() {
574 return anchorY.get();
575 }
576 public final ReadOnlyDoubleProperty anchorYProperty() {
577 return anchorY.getReadOnlyProperty();
578 }
579
580 /**
581 * Specifies the popup anchor point which is used in popup positioning. The
582 * point can be set to a corner of the popup window or a corner of its
583 * content. In this context the content corners are derived from the popup
584 * root node's layout bounds.
585 * <p>
586 * In general changing of the anchor location won't change the current
587 * window position. Instead of that, the {@code anchorX} and {@code anchorY}
588 * values are recalculated to correspond to the new anchor point.
589 * </p>
590 * @since JavaFX 8.0
591 */
592 private final ObjectProperty<AnchorLocation> anchorLocation =
593 new ObjectPropertyBase<AnchorLocation>(
594 AnchorLocation.WINDOW_TOP_LEFT) {
595 @Override
596 protected void invalidated() {
597 cachedAnchorBounds = null;
598 updateWindow(windowToAnchorX(getX()),
599 windowToAnchorY(getY()));
600 }
601
602 @Override
603 public Object getBean() {
604 return PopupWindow.this;
605 }
606
607 @Override
608 public String getName() {
609 return "anchorLocation";
610 }
611 };
612 public final void setAnchorLocation(final AnchorLocation value) {
613 anchorLocation.set(value);
614 }
615 public final AnchorLocation getAnchorLocation() {
616 return anchorLocation.get();
617 }
618 public final ObjectProperty<AnchorLocation> anchorLocationProperty() {
619 return anchorLocation;
620 }
621
622 /**
623 * Anchor location constants for popup anchor point selection.
624 *
625 * @since JavaFX 8.0
626 */
627 public enum AnchorLocation {
628 /** Represents top left window corner. */
629 WINDOW_TOP_LEFT(0, 0, false),
630 /** Represents top right window corner. */
631 WINDOW_TOP_RIGHT(1, 0, false),
632 /** Represents bottom left window corner. */
633 WINDOW_BOTTOM_LEFT(0, 1, false),
634 /** Represents bottom right window corner. */
635 WINDOW_BOTTOM_RIGHT(1, 1, false),
636 /** Represents top left content corner. */
637 CONTENT_TOP_LEFT(0, 0, true),
638 /** Represents top right content corner. */
639 CONTENT_TOP_RIGHT(1, 0, true),
640 /** Represents bottom left content corner. */
641 CONTENT_BOTTOM_LEFT(0, 1, true),
642 /** Represents bottom right content corner. */
643 CONTENT_BOTTOM_RIGHT(1, 1, true);
644
645 private final double xCoef;
646 private final double yCoef;
647 private final boolean contentLocation;
648
649 private AnchorLocation(final double xCoef, final double yCoef,
650 final boolean contentLocation) {
651 this.xCoef = xCoef;
652 this.yCoef = yCoef;
653 this.contentLocation = contentLocation;
654 }
655
656 double getXCoef() {
657 return xCoef;
658 }
659
660 double getYCoef() {
661 return yCoef;
662 }
663
664 boolean isContentLocation() {
665 return contentLocation;
666 }
667 };
668
669 @Override
670 void setXInternal(final double value) {
671 updateWindow(windowToAnchorX(value), getAnchorY());
672 }
673
674 @Override
675 void setYInternal(final double value) {
676 updateWindow(getAnchorX(), windowToAnchorY(value));
677 }
678
679 @Override
680 void notifyLocationChanged(final double newX, final double newY) {
681 super.notifyLocationChanged(newX, newY);
682 anchorX.set(windowToAnchorX(newX));
683 anchorY.set(windowToAnchorY(newY));
684 }
685
686 private Bounds cachedExtendedBounds;
687 private Bounds cachedAnchorBounds;
688
689 private Bounds getExtendedBounds() {
690 if (cachedExtendedBounds == null) {
691 final Parent rootNode = getScene().getRoot();
692 cachedExtendedBounds = union(rootNode.getLayoutBounds(),
693 rootNode.getBoundsInLocal());
694 }
695
696 return cachedExtendedBounds;
697 }
698
699 private Bounds getAnchorBounds() {
700 if (cachedAnchorBounds == null) {
701 cachedAnchorBounds = getAnchorLocation().isContentLocation()
702 ? getScene().getRoot()
703 .getLayoutBounds()
704 : getExtendedBounds();
705 }
706
707 return cachedAnchorBounds;
708 }
709
710 private void updateWindow(final double newAnchorX,
711 final double newAnchorY) {
712 final AnchorLocation anchorLocationValue = getAnchorLocation();
713 final Parent rootNode = getScene().getRoot();
714 final Bounds extendedBounds = getExtendedBounds();
715 final Bounds anchorBounds = getAnchorBounds();
716
717 final double anchorXCoef = anchorLocationValue.getXCoef();
718 final double anchorYCoef = anchorLocationValue.getYCoef();
719 final double anchorDeltaX = anchorXCoef * anchorBounds.getWidth();
720 final double anchorDeltaY = anchorYCoef * anchorBounds.getHeight();
721 double anchorScrMinX = newAnchorX - anchorDeltaX;
722 double anchorScrMinY = newAnchorY - anchorDeltaY;
723
724 if (autofixActive) {
725 final Screen currentScreen =
726 Utils.getScreenForPoint(newAnchorX, newAnchorY);
727 final Rectangle2D screenBounds =
728 Utils.hasFullScreenStage(currentScreen)
729 ? currentScreen.getBounds()
730 : currentScreen.getVisualBounds();
731
732 if (anchorXCoef <= 0.5) {
733 // left side of the popup is more important, try to keep it
734 // visible if the popup width is larger than screen width
735 anchorScrMinX = Math.min(anchorScrMinX,
736 screenBounds.getMaxX()
737 - anchorBounds.getWidth());
738 anchorScrMinX = Math.max(anchorScrMinX, screenBounds.getMinX());
739 } else {
740 // right side of the popup is more important
741 anchorScrMinX = Math.max(anchorScrMinX, screenBounds.getMinX());
742 anchorScrMinX = Math.min(anchorScrMinX,
743 screenBounds.getMaxX()
744 - anchorBounds.getWidth());
745 }
746
747 if (anchorYCoef <= 0.5) {
748 // top side of the popup is more important
749 anchorScrMinY = Math.min(anchorScrMinY,
750 screenBounds.getMaxY()
751 - anchorBounds.getHeight());
752 anchorScrMinY = Math.max(anchorScrMinY, screenBounds.getMinY());
753 } else {
754 // bottom side of the popup is more important
755 anchorScrMinY = Math.max(anchorScrMinY, screenBounds.getMinY());
756 anchorScrMinY = Math.min(anchorScrMinY,
757 screenBounds.getMaxY()
758 - anchorBounds.getHeight());
759 }
760 }
761
762 final double windowScrMinX =
763 anchorScrMinX - anchorBounds.getMinX()
764 + extendedBounds.getMinX();
765 final double windowScrMinY =
766 anchorScrMinY - anchorBounds.getMinY()
767 + extendedBounds.getMinY();
768
769 // update popup dimensions
770 setWidth(extendedBounds.getWidth());
771 setHeight(extendedBounds.getHeight());
772 // update transform
773 rootNode.setTranslateX(-extendedBounds.getMinX());
774 rootNode.setTranslateY(-extendedBounds.getMinY());
775
776 // update popup position
777 // don't set Window.xExplicit unnecessarily
778 if (!Double.isNaN(windowScrMinX)) {
779 super.setXInternal(windowScrMinX);
780 }
781 // don't set Window.yExplicit unnecessarily
782 if (!Double.isNaN(windowScrMinY)) {
783 super.setYInternal(windowScrMinY);
784 }
785
786 // set anchor x, anchor y
787 anchorX.set(anchorScrMinX + anchorDeltaX);
788 anchorY.set(anchorScrMinY + anchorDeltaY);
789 }
790
791 private Bounds union(final Bounds bounds1, final Bounds bounds2) {
792 final double minX = Math.min(bounds1.getMinX(), bounds2.getMinX());
793 final double minY = Math.min(bounds1.getMinY(), bounds2.getMinY());
794 final double maxX = Math.max(bounds1.getMaxX(), bounds2.getMaxX());
795 final double maxY = Math.max(bounds1.getMaxY(), bounds2.getMaxY());
796
797 return new BoundingBox(minX, minY, maxX - minX, maxY - minY);
798 }
799
800 private double windowToAnchorX(final double windowX) {
801 final Bounds anchorBounds = getAnchorBounds();
802 return windowX - getExtendedBounds().getMinX()
803 + anchorBounds.getMinX()
804 + getAnchorLocation().getXCoef()
805 * anchorBounds.getWidth();
806 }
807
808 private double windowToAnchorY(final double windowY) {
809 final Bounds anchorBounds = getAnchorBounds();
810 return windowY - getExtendedBounds().getMinY()
811 + anchorBounds.getMinY()
812 + getAnchorLocation().getYCoef()
813 * anchorBounds.getHeight();
814 }
815
816 /**
817 *
818 * Gets the root (non PopupWindow) Window for the provided window.
819 *
820 * @param win the Window for which to get the root window
821 */
822 private static Window getRootWindow(Window win) {
823 // should be enough to traverse PopupWindow hierarchy here to get to the
824 // first non-popup focusable window
825 while (win instanceof PopupWindow) {
826 win = ((PopupWindow) win).getOwnerWindow();
827 }
828 return win;
829 }
830
831 void doAutoHide() {
832 // There is a timing problem here. I would like to have this isVisible
833 // check, such that we don't send an onAutoHide event if it was already
834 // invisible. However, visible is already false by the time this method
835 // gets called, when done by certain code paths.
836 // if (isVisible()) {
837 // hide this popup
838 hide();
839 if (getOnAutoHide() != null) {
840 getOnAutoHide().handle(new Event(this, this, Event.ANY));
841 }
842 // }
843 }
844
845 @Override
846 WindowEventDispatcher createInternalEventDispatcher() {
847 return new WindowEventDispatcher(new PopupEventRedirector(this),
848 new WindowCloseRequestHandler(this),
849 new EventHandlerManager(this));
850
851 }
852
853 @Override
854 Window getWindowOwner() {
855 return getOwnerWindow();
856 }
857
858 private void startMonitorOwnerEvents(final Window ownerWindowValue) {
859 final EventRedirector parentEventRedirector =
860 ownerWindowValue.getInternalEventDispatcher()
861 .getEventRedirector();
862 parentEventRedirector.addEventDispatcher(getEventDispatcher());
863 }
864
865 private void stopMonitorOwnerEvents(final Window ownerWindowValue) {
866 final EventRedirector parentEventRedirector =
867 ownerWindowValue.getInternalEventDispatcher()
868 .getEventRedirector();
869 parentEventRedirector.removeEventDispatcher(getEventDispatcher());
870 }
871
872 private ChangeListener<Boolean> ownerFocusedListener;
873
874 private void bindOwnerFocusedProperty(final Window ownerWindowValue) {
875 ownerFocusedListener =
876 (observable, oldValue, newValue) -> setFocused(newValue);
877 ownerWindowValue.focusedProperty().addListener(ownerFocusedListener);
878 }
879
880 private void unbindOwnerFocusedProperty(final Window ownerWindowValue) {
881 ownerWindowValue.focusedProperty().removeListener(ownerFocusedListener);
882 ownerFocusedListener = null;
883 }
884
885 private boolean autofixActive;
886 private void handleAutofixActivation(final boolean visible,
887 final boolean autofix) {
888 final boolean newAutofixActive = visible && autofix;
889 if (autofixActive != newAutofixActive) {
890 autofixActive = newAutofixActive;
891 if (newAutofixActive) {
892 Screen.getScreens().addListener(popupWindowUpdater);
893 updateWindow(getAnchorX(), getAnchorY());
894 } else {
895 Screen.getScreens().removeListener(popupWindowUpdater);
896 }
897 }
898 }
899
900 private boolean autohideActive;
901 private void handleAutohideActivation(final boolean visible,
902 final boolean autohide) {
903 final boolean newAutohideActive = visible && autohide;
904 if (autohideActive != newAutohideActive) {
905 // assert rootWindow != null;
906 autohideActive = newAutohideActive;
907 if (newAutohideActive) {
908 rootWindow.increaseFocusGrabCounter();
909 } else {
910 rootWindow.decreaseFocusGrabCounter();
911 }
912 }
913 }
914
915 private void validateOwnerWindow(final Window owner) {
916 if (owner == null) {
917 throw new NullPointerException("Owner window must not be null");
918 }
919
920 if (wouldCreateCycle(owner, this)) {
921 throw new IllegalArgumentException(
922 "Specified owner window would create cycle"
923 + " in the window hierarchy");
924 }
925
926 if (isShowing() && (getOwnerWindow() != owner)) {
927 throw new IllegalStateException(
928 "Popup is already shown with different owner window");
929 }
930 }
931
932 private static boolean wouldCreateCycle(Window parent, final Window child) {
933 while (parent != null) {
934 if (parent == child) {
935 return true;
936 }
937
938 parent = parent.getWindowOwner();
939 }
940
941 return false;
942 }
943
944 static class PopupEventRedirector extends EventRedirector {
945
946 private static final KeyCombination ESCAPE_KEY_COMBINATION =
947 KeyCombination.keyCombination("Esc");
948 private final PopupWindow popupWindow;
949
950 public PopupEventRedirector(final PopupWindow popupWindow) {
951 super(popupWindow);
952 this.popupWindow = popupWindow;
953 }
954
955 @Override
956 protected void handleRedirectedEvent(final Object eventSource,
957 final Event event) {
958 if (event instanceof KeyEvent) {
959 handleKeyEvent((KeyEvent) event);
960 return;
961 }
962
963 final EventType<?> eventType = event.getEventType();
964
965 if (eventType == MouseEvent.MOUSE_PRESSED
966 || eventType == ScrollEvent.SCROLL) {
967 handleAutoHidingEvents(eventSource, event);
968 return;
969 }
970
971 if (eventType == FocusUngrabEvent.FOCUS_UNGRAB) {
972 handleFocusUngrabEvent();
973 return;
974 }
975 }
976
977 private void handleKeyEvent(final KeyEvent event) {
978 if (event.isConsumed()) {
979 return;
980 }
981
982 final Scene scene = popupWindow.getScene();
983 if (scene != null) {
984 final Node sceneFocusOwner = scene.getFocusOwner();
985 final EventTarget eventTarget =
986 (sceneFocusOwner != null) ? sceneFocusOwner : scene;
987 if (EventUtil.fireEvent(eventTarget, new DirectEvent(event.copyFor(popupWindow, eventTarget)))
988 == null) {
989 event.consume();
990 return;
991 }
992 }
993
994 if ((event.getEventType() == KeyEvent.KEY_PRESSED)
995 && ESCAPE_KEY_COMBINATION.match(event)) {
996 handleEscapeKeyPressedEvent(event);
997 }
998 }
999
1000 private void handleEscapeKeyPressedEvent(final Event event) {
1001 if (popupWindow.isHideOnEscape()) {
1002 popupWindow.doAutoHide();
1003
1004 if (popupWindow.getConsumeAutoHidingEvents()) {
1005 event.consume();
1006 }
1007 }
1008 }
1009
1010 private void handleAutoHidingEvents(final Object eventSource,
1011 final Event event) {
1012 // we handle mouse pressed only for the immediate parent window,
1013 // where we can check whether the mouse press is inside of the owner
1014 // control or not, we will force possible child popups to close
1015 // by sending the FOCUS_UNGRAB event
1016 if (popupWindow.getOwnerWindow() != eventSource) {
1017 return;
1018 }
1019
1020 if (popupWindow.isAutoHide() && !isOwnerNodeEvent(event)) {
1021 // the mouse press is outside of the owner control,
1022 // fire FOCUS_UNGRAB to child popups
1023 Event.fireEvent(popupWindow, new FocusUngrabEvent());
1024
1025 popupWindow.doAutoHide();
1026
1027 if (popupWindow.getConsumeAutoHidingEvents()) {
1028 event.consume();
1029 }
1030 }
1031 }
1032
1033 private void handleFocusUngrabEvent() {
1034 if (popupWindow.isAutoHide()) {
1035 popupWindow.doAutoHide();
1036 }
1037 }
1038
1039 private boolean isOwnerNodeEvent(final Event event) {
1040 final Node ownerNode = popupWindow.getOwnerNode();
1041 if (ownerNode == null) {
1042 return false;
1043 }
1044
1045 final EventTarget eventTarget = event.getTarget();
1046 if (!(eventTarget instanceof Node)) {
1047 return false;
1048 }
1049
1050 Node node = (Node) eventTarget;
1051 do {
1052 if (node == ownerNode) {
1053 return true;
1054 }
1055 node = node.getParent();
1056 } while (node != null);
1057
1058 return false;
1059 }
1060 }
1061 }