Keep javafx window inside screen bounds

Question

I'm programming a javafx application, and I'd like to keep my window from going outside the screen bounds, since there isn't much use for this. So, for example, the window shouldn't be able to be dragged so that half of it is off the screen.

public class ui extends Application{
    public static void main (String[] args){
        launch(args);
    }
    public void start(Stage mainStage){
        mainStage.initStyle(StageStyle.DECORATED);
        Rectangle2D mainScreen = Screen.getPrimary().getVisualBounds();
        mainStage.setWidth(mainScreen.getWidth());
        mainStage.setHeight(mainScreen.getHeight());

        BorderPane mainPane = new BorderPane(background);

        Scene mainScene = new Scene(mainPane, Color.BLACK);
        mainStage.setScene(mainScene);

        mainStage.show();
    }
}

If you could throw us some of your code, we would be able to do a lot more for you. Right now, I can only guess what you have... — DreadHeadedDeveloper, Oct 05 '14 at 15:18
@DreadHeadedDeveloper I only need a general solution, so I'm not sure it'll help, but I'll add some code. — LilSweden, Oct 05 '14 at 15:36

score 6 · Accepted Answer · answered Oct 05 '14 at 15:54

There are a lot of reasons not to do this: you need to be careful not to disable functionality the user might expect, such as dragging across an extended desktop (i.e. dragging between multiple physical displays) or moving the window between virtual desktops (such as "Spaces" in Mac OS X, or equivalent systems in Linux).

Probably the best you can do here is to observe the position of the window with a listener, and push it back to the best location if it's outside the desired bounds. This is probably a little unsatisfactory as a user experience, but achieves the functionality you want:

import javafx.application.Application;
import javafx.beans.value.ChangeListener;
import javafx.geometry.BoundingBox;
import javafx.geometry.Bounds;
import javafx.geometry.Rectangle2D;
import javafx.stage.Screen;
import javafx.stage.Stage;

public class ConstrainedWindow extends Application {

    @Override
    public void start(Stage primaryStage) {

        Bounds allScreenBounds = computeAllScreenBounds();
        ChangeListener<Number> boundsListener = (obs, oldValue, newValue) -> {
            double x = primaryStage.getX();
            double y = primaryStage.getY();
            double w = primaryStage.getWidth();
            double h = primaryStage.getHeight();
            if (x < allScreenBounds.getMinX()) {
                primaryStage.setX(allScreenBounds.getMinX());
            }
            if (x + w > allScreenBounds.getMaxX()) {
                primaryStage.setX(allScreenBounds.getMaxX() - w);
            }
            if (y < allScreenBounds.getMinY()) {
                primaryStage.setY(allScreenBounds.getMinY());
            }
            if (y + h > allScreenBounds.getMaxY()) {
                primaryStage.setY(allScreenBounds.getMaxY() - h);
            }
        };
        primaryStage.xProperty().addListener(boundsListener);
        primaryStage.yProperty().addListener(boundsListener);
        primaryStage.widthProperty().addListener(boundsListener);
        primaryStage.heightProperty().addListener(boundsListener);
        primaryStage.show();
    }

    private Bounds computeAllScreenBounds() {
        double minX = Double.POSITIVE_INFINITY ;
        double minY = Double.POSITIVE_INFINITY ;
        double maxX = Double.NEGATIVE_INFINITY ;
        double maxY = Double.NEGATIVE_INFINITY ;
        for (Screen screen : Screen.getScreens()) {
            Rectangle2D screenBounds = screen.getBounds();
            if (screenBounds.getMinX() < minX) {
                minX = screenBounds.getMinX();
            }
            if (screenBounds.getMinY() < minY) {
                minY = screenBounds.getMinY() ;
            }
            if (screenBounds.getMaxX() > maxX) {
                maxX = screenBounds.getMaxX();
            }
            if (screenBounds.getMaxY() > maxY) {
                maxY = screenBounds.getMaxY() ;
            }
        }
        return new BoundingBox(minX, minY, maxX-minX, maxY-minY);
    }

    public static void main(String[] args) {
        launch(args);
    }
}

Just because it wouldn't let me post a comment with fewer than 15 characters, no meaning intended at all :) — James_D, Oct 05 '14 at 16:09

DreadHeadedDeveloper · Answer 2 · 2014-10-05T16:14:46.673

0

Here's a few ideas that may help

public final int width = java.awt.Toolkit.getDefaultToolkit().getScreenSize().width;
public final int height = java.awt.Toolkit.getDefaultToolkit().getScreenSize().height;

These 2 lines of code will allow you to get the length and width of most computer's screen dimensions.

Next, I would set up a method that constantly gets the position of your window, or at least changes value anytime it is moved, and then set restrictions based off of your knowledge of the screen size and you window size. One way to do it would be something like...

if(yWinPos > (height - wHeight))//wHeight is actual height of the window, not the y pos of window
{

//code that prevents it from moving past the bottom part of screen

}

Let me know if this is any help or if it doesn't answer your question, and I'll edit my answer in response.

edited Oct 05 '14 at 16:14

answered Oct 05 '14 at 16:00

DreadHeadedDeveloper

620
5
15

1

Don't mix AWT code with JavaFX code unless you really have to. – James_D Oct 05 '14 at 16:02
@James_D Would it be that bad? We are only using it to get the dimensions of the screen and then we are done with it, simply storing it into an int, and then moving on – DreadHeadedDeveloper Oct 05 '14 at 16:03
3

It's probably fine in this case, but in general you have no real guarantee that there even is an AWT toolkit. Sometimes you have to make that assumption to get the functionality you want (e.g. interacting with the task bar), but when the same thing can be done using just one toolkit, it's always better that way. – James_D Oct 05 '14 at 16:05

Keep javafx window inside screen bounds

2 Answers2