This enhancement allows `Stage` to be placed on the screen similar to a popup
window, where a user-specified positioning anchors defines a point on the stage
that should coincide with a given location on the screen. For this purpose, the
following new methods are added to `Stage`:
public class Stage {
public void relocate(AnchorPoint screenAnchor, AnchorPoint stageAnchor);
public void relocate(AnchorPoint screenAnchor, Insets screenPadding,
AnchorPoint stageAnchor, AnchorPolicy);
public void relocate(Screen, AnchorPoint screenAnchor, Insets
screenPadding, AnchorPoint stageAnchor, AnchorPolicy);
}
## AnchorPoint
`AnchorPoint` is a point that is either specified in absolute coordinates, or
relative to the screen or stage:
var anchor1 = AnchorPoint.proportional(0.5, 0.5); // center of the screen/stage
var anchor2 = AnchorPoint.absolute(100, 100); // absolute coordinates within
screen/stage
For example, a stage that sits flush with the bottom-right corner of the screen
can be shown as follows:
var screenAnchor = AnchorPoint.proportional(1, 1); // or use the
AnchorPoint.BOTTOM_RIGHT constant
var stageAnchor = AnchorPoint.proportional(1, 1);
stage.relocate(screenAnchor, stageAnchor);
stage.show();
## AnchorPolicy
`AnchorPolicy` controls how the anchor may be adjusted when the preferred
placement doesn't fit within the screen bounds:
public enum AnchorPolicy {
FIXED,
FLIP_HORIZONTAL,
FLIP_VERTICAL,
AUTO
}
* `FIXED`: always use the provided anchor; only adjust the resulting position
to fit within the screen.
* `FLIP_HORIZONTAL`: if the preferred placement violates horizontal
constraints, try a horizontally flipped anchor (e.g. top-left to top-right)
before falling back to the original anchor.
* `FLIP_VERTICAL`: likewise for vertical constraints.
* `AUTO`: automatically choose the most suitable flip:
if only horizontal constraints are violated, acts like `FLIP_HORIZONTAL`;
if only vertical constraints are violated, acts like `FLIP_VERTICAL`;
if both are violated, try a diagonally flipped anchor (both axes) and pick
the placement that requires the least adjustment.
This is useful for popup-like behavior where you have a preferred "opening
direction", but want the window to flip to the opposite side of the reference
point when there isn’t enough space (e.g. "prefer below, but open above if
below doesn’t fit").
### PopupWindow support
The new `PopupWindow.anchorPolicy` property adds the same "flip the anchor when
it would go off-screen" capability for popups. This complements the existing
`PopupWindow.anchorLocation` / `PopupWindow.autoFix` behavior: applications can
keep using `PopupWindow.anchorLocation` to express the preferred anchor, while
`PopupWindow.anchorPolicy` controls how the popup may flip that anchor as a
fallback when the preferred placement wouldn't fit within screen bounds.
## Edge constraints
`screenPadding` specifies per-edge padding relative to the screen, expressed as
an `Insets`:
* An inset value >= 0 enables a constraint for that edge and specifies the
minimum distance in pixels that the stage must keep from that screen edge.
* An inset value < 0 disables the constraint for that edge.
Enabled constraints effectively shrink the usable screen area by the given
insets.
-------------
Commit messages:
- add relocate() overload that accepts Screen
- refactor
- small changes
- doc fixes
- tweaks
- refactor everything
- javadocs
- ensure screenPadding is not negative
- add clampPolicy and screenPadding
- update tests
- ... and 2 more: https://git.openjdk.org/jfx/compare/43d39204...e5dfb0eb
Changes: https://git.openjdk.org/jfx/pull/1986/files
Webrev: https://webrevs.openjdk.org/?repo=jfx&pr=1986&range=00
Issue: https://bugs.openjdk.org/browse/JDK-8372530
Stats: 1654 lines in 10 files changed: 1565 ins; 54 del; 35 mod
Patch: https://git.openjdk.org/jfx/pull/1986.diff
Fetch: git fetch https://git.openjdk.org/jfx.git pull/1986/head:pull/1986
PR: https://git.openjdk.org/jfx/pull/1986
