JavaFX Undecorated window resizing

[Kevin Ferreira]

So i have a problem trying to fix the resizing system that is possible on undecorated window in JavaFX because i just have it lagged, it's not convenient at all the results you reach with inbuilt JavaFX functions.

I tried some libraries but couldn't run properly and some of them also doesn't support such functionality so my question is: what's the best solution for making a resizing undecorated window on JavaFX?

Check part of the code i have:

scene.setOnMouseDragged(event -> {
                 if (resizingLeft) {
                     
                     
                     double newWidth = stage.getWidth() - (event.getScreenX() - stage.getX());
                     if (newWidth > stage.getMinWidth()) {
                     stage.setWidth(newWidth);
                     stage.setX(event.getScreenX());
                     }
                      
                        
                 } else if (resizingRight) {
                     double newWidth = stage.getWidth() + (event.getSceneX() - startX);
                     stage.setWidth(newWidth);
                     startX = event.getSceneX();
                 } else if (resizingTop) {
                    
                    
                     double deltaY = event.getScreenY() - startY;
                     double newHeight = stage.getHeight() - deltaY;
                     stage.setHeight(newHeight);
                     startY = event.getScreenY();
                     
                     
                } else if (resizingBottom) {
                     double newHeight = stage.getHeight() + (event.getSceneY() - startY);
                     stage.setHeight(newHeight);
                     startY = event.getSceneY();
                 } else if (resizingNW) {
                     
                     double newWidth = stage.getWidth() - (event.getSceneX() - startX);
                     double newHeight = stage.getHeight() - (event.getSceneY() - startY);
                     double newTranslateX = stage.getX() + event.getSceneX() - startX;
                     double newTranslateY = stage.getY() + event.getSceneY() - startY;
                     stage.setWidth(newWidth);
                     stage.setHeight(newHeight);
                     stage.setX(newTranslateX);
                     stage.setY(newTranslateY);
                     startX = event.getSceneX();
                     startY = event.getSceneY();
                     
                 } else if (resizingNE) {
                     
                     double newWidth = stage.getWidth() + (event.getSceneX() - startX);
                     double newHeight = stage.getHeight() - (event.getSceneY() - startY);
                     double newTranslateY = stage.getY() + event.getSceneY() - startY;
                     stage.setWidth(newWidth);
                     stage.setHeight(newHeight);
                     stage.setY(newTranslateY);
                     startX = event.getSceneX();
                     startY = event.getSceneY();
                     
                 } else if (resizingSE) {
                     
                     double newWidth = stage.getWidth() + (event.getSceneX() - startX);
                     double newHeight = stage.getHeight() + (event.getSceneY() - startY);
                     stage.setWidth(newWidth);
                     stage.setHeight(newHeight);
                     startX = event.getSceneX();
                     startY = event.getSceneY();
                     
                 } else if (resizingSW) {
                                         
                        double deltaX = event.getSceneX() - startX;
                        double deltaY = event.getSceneY() - startY;

                        double newWidth = stage.getWidth() - deltaX;
                        double newHeight = stage.getHeight() + deltaY;
                        
                        double newTranslateX = stage.getX() + deltaX;

                        stage.setWidth(newWidth);
                        stage.setHeight(newHeight);
                        stage.setX(newTranslateX);

                        startX = event.getSceneX();
                        startY = event.getSceneY();
                                            
                       }
             });

             scene.setOnMouseReleased(event -> {
                 resizingLeft = false;
                 resizingRight = false;
                 resizingTop = false;
                 resizingBottom = false;
                 resizingNW = false;
                 resizingNE = false;
                 resizingSE = false;
                 resizingSW = false;
             });
             
             
             

As you can see the problem with this resizing system is that it doesn't resize on the NW and NE direction and it lags while resizing on W.

[Lou Hamers]

Yeah... this is unfortunate. I've seen similar problems and I'm not sure there's really a solution to make this work well in all cases. It may be related to the version of Java/JavaFX also (I don't remember issues with doing this on 8).

I did have a "frameless" project, but I can't remember what the issues were. I'll have to go take a look at it, but I'm not optimistic that I found a perfect solution to this problem. I also saw similar problems with some of the frameless implementations that others have published.

I recommend sticking to a decorated stage if you have the option. I'll post here if I find anything that might work better.

[Kevin Ferreira]

Lou Hamers wrote:Yeah... this is unfortunate. I've seen similar problems and I'm not sure there's really a solution to make this work well in all cases. It may be related to the version of Java/JavaFX also (I don't remember issues with doing this on 8).

I did have a "frameless" project, but I can't remember what the issues were. I'll have to go take a look at it, but I'm not optimistic that I found a perfect solution to this problem. I also saw similar problems with some of the frameless implementations that others have published.

I recommend sticking to a decorated stage if you have the option. I'll post here if I find anything that might work better.

can't work with decorated window since the program im making is a web browser  ;/

is wrapping swing for swing solutions a fine alternative to this problem?

i also tried the Borderless Scene and UndecoratorBis libs but couldn't use it properly, i don't know if it's updated you know

[Lou Hamers]

Oh, because of the need to have tabs on the very top pixel of the screen? Yeah that is important.

Using FX alongside Swing has been done before and is probably fine, especially if you limit it to just the "frame". But I don't have a ton of experience with that configuration so I can't say too much on it. Whether you "should" try that is probably going to depend on who you ask. If it works, you do what you have to do to get it done! Do be aware that Swing and JFX run on entirely different background threads, the "EDT" (Event Dispatch Thread) and the "JavaFx Application Thread", so that's where you might hit a complication. But it might be perfectly fine too...

I've definitely seen Undecorator and the other sounds familiar. Undecorator worked fine on Java 8, so maybe it's a newer JDK issue.

I found one of my projects experimenting with this stuff, with this note at the top from when I took a break to work on something else:

    /**
     * Experimental non-native window frame, still a WIP due to performance and multi monitor issues similar to issues
     * also seen in a number of other JFX undecorated libs...
     */

I think it worked OK, but not as well as I'd have liked. Unfortunately I also left it in a non-working state.

I remember seeing two performance issues. One was an initial white background (the scene "fill" background color) that briefly flashed sometimes. I mitigated that by just setting the fill color to a background similar enough to the theme color:

        //Setting fill background mitigates a rendering issue (possibly OS or hardware specific) where
        //resizing a window larger momentarily shows an annoying white background...
        scene.setFill(settings.getConfigColor("sceneBackgroundFillColor")); //This is just a web hex color string like #111111

The other more annoying problem was component size "flickering", as containers tried to resize and catch up with the stage resizing. The multi-monitor issue IIRC was relating to resizing the edge of the window into another monitor/display, but I believe that was a solvable problem.

Not total show stoppers maybe but annoying enough that I wasn't happy with it. I definitely wasn't at a "giving up" point though. We might be able to find ways to mitigate or solve these glitches (perhaps just find a good way to throttle or slightly time-delay the stage size changes), I just found a different project I wanted to focus on more and put this on hold.

Are those the performance issues you're seeing, or are you seeing something else? Your code is doing pretty much what mine does and I don't think you're doing anything "wrong".

[Lou Hamers]

Oh, one more thing - if you're seeing other performance issues, the complexity of your scene graph is going to be a factor too. So reducing the complexity of your UI "tree" may help (or maybe some performance "tricks").

[Kevin Ferreira]

Lou Hamers wrote:Oh, because of the need to have tabs on the very top pixel of the screen? Yeah that is important.

Using FX alongside Swing has been done before and is probably fine, especially if you limit it to just the "frame". But I don't have a ton of experience with that configuration so I can't say too much on it. Whether you "should" try that is probably going to depend on who you ask. If it works, you do what you have to do to get it done! Do be aware that Swing and JFX run on entirely different background threads, the "EDT" (Event Dispatch Thread) and the "JavaFx Application Thread", so that's where you might hit a complication. But it might be perfectly fine too...

I've definitely seen Undecorator and the other sounds familiar. Undecorator worked fine on Java 8, so maybe it's a newer JDK issue.

I found one of my projects experimenting with this stuff, with this note at the top from when I took a break to work on something else:

    /**
     * Experimental non-native window frame, still a WIP due to performance and multi monitor issues similar to issues
     * also seen in a number of other JFX undecorated libs...
     */

I think it worked OK, but not as well as I'd have liked. Unfortunately I also left it in a non-working state.

I remember seeing two performance issues. One was an initial white background (the scene "fill" background color) that briefly flashed sometimes. I mitigated that by just setting the fill color to a background similar enough to the theme color:

        //Setting fill background mitigates a rendering issue (possibly OS or hardware specific) where
        //resizing a window larger momentarily shows an annoying white background...
        scene.setFill(settings.getConfigColor("sceneBackgroundFillColor")); //This is just a web hex color string like #111111

The other more annoying problem was component size "flickering", as containers tried to resize and catch up with the stage resizing. The multi-monitor issue IIRC was relating to resizing the edge of the window into another monitor/display, but I believe that was a solvable problem.

Not total show stoppers maybe but annoying enough that I wasn't happy with it. I definitely wasn't at a "giving up" point though. We might be able to find ways to mitigate or solve these glitches (perhaps just find a good way to throttle or slightly time-delay the stage size changes), I just found a different project I wanted to focus on more and put this on hold.

Are those the performance issues you're seeing, or are you seeing something else? Your code is doing pretty much what mine does and I don't think you're doing anything "wrong".

The problem itself is that such resizing system is not usable, like the funny part is that to the right and bottom it works great but when it comes to a logic for the left and top its very bad and t rembling, i think 'vanilla' javafx hardly can handle such implementation for undecorated. I couldn't understand your project but you can put the code part on pastemyst (https://paste.myst.rs/)  so i try to check...

[Lou Hamers]

Yeah the left and right "resizes" are really a window move AND a resize.
It looks like your code link is incomplete, BTW.

One strategy you could try, if you can accept any downsides, would be to see if you can remove most or all of the scene temporarily during the resize drags (it could be replaced with a nice "resizing" placeholder graphic), and then re-add it all back when done. There is some cost to doing that, but if it's just at the start/end it might be okay.

You will need to make sure you maintain good view/model separation if you do that, of course. But I always recommend keeping that in focus anyway.

[Kevin Ferreira]

Lou Hamers wrote:Yeah the left and right "resizes" are really a window move AND a resize.
It looks like your code link is incomplete, BTW.

One strategy you could try, if you can accept any downsides, would be to see if you can remove most or all of the scene temporarily during the resize drags (it could be replaced with a nice "resizing" placeholder graphic), and then re-add it all back when done. There is some cost to doing that, but if it's just at the start/end it might be okay.

You will need to make sure you maintain good view/model separation if you do that, of course. But I always recommend keeping that in focus anyway.

what you mean removing the scene temporarily will result into? the effect itself that code into the left resizing is moving the borders while dragging, that looks so bad, don't know if it is an 'animation' issue only, you know? i am basicly open for ANYTHING that would result in a similar effect as the inbuilt DECORATED resizing system

[Lou Hamers]

Actually I spent a few minutes messing with this old code. This is quite possibly environment specific (I'm on Linux KDE Plasma), but I had an issue where I needed to call BOTH setWidth() and setHeight() when resizing the Stage, even if one of them weren't changing.

Once I fixed that in resizeStageWidth()/resizeStageHeight(), it seems to be working ok for me. Still just a little bit of flickering sometimes when doing those left/top drags, but not horrible. There's likely more optimizations and improvements possible too.

It's a little experimental code I never cleaned up and you won't be able to copy/paste this as-is, but it might give you some ideas I guess. It also gives you some hints of some other issues you might run into, such as preventing window drags off the edge of the screen. You can steal whatever you want, you may prefer that DragDirection enum to all those boolean flags. Let me know if it helps at all!

import javafx.application.Platform;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.collections.ObservableList;
import javafx.geometry.Pos;
import javafx.scene.control.Hyperlink;
import javafx.scene.control.Label;
import javafx.scene.input.MouseButton;
import javafx.scene.layout.*;
import javafx.scene.paint.Paint;
import javafx.scene.shape.Line;
import javafx.stage.Screen;
import javafx.stage.Stage;
import net.jfxkit.config.internal.Settings;
import net.jfxkit.util.MathUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class WindowFrame {

    private final Stage stage;
    private final BorderPane framePane;
    private final Pane rootPane;
    private final StringProperty windowTitle;
    private final long titleBarHeight;
    private final String titleBarAlignment;
    private final long borderThickness;
    private final long borderThicknessX5;
    private final double buttonStrokeThickness;
    private final Paint buttonStrokeColor;
    private final boolean showMinimizeButton;
    private final boolean showMaximizeButton;
    private final boolean showCloseButton;
    private static final Logger log = LoggerFactory.getLogger(WindowFrame.class);
    private boolean maximized;
    private boolean minimized;
    private double monitorMaxWidth;
    private double monitorMaxHeight;
    private double dragOffsetX;
    private double dragOffsetY;
    private double dragStartScreenX;
    private double dragStartScreenY;
    private double targetStageWidth;
    private double targetStageHeight;

    /**
     * Experimental non-native window frame, still a WIP due to performance and multi monitor issues similar to issues
     * also seen in a number of other JFX undecorated libs...
     */
    public WindowFrame(Stage stage, Settings settings, BorderPane framePane, Pane rootPane) {
        this.stage = stage;
        this.framePane = framePane;
        this.rootPane = rootPane;
        windowTitle = new SimpleStringProperty();
        titleBarHeight = settings.getConfigLong("titleBarHeight");
        titleBarAlignment = settings.getConfigStr("titleBarAlignment");
        borderThickness = settings.getConfigLong("borderThickness");
        borderThicknessX5 = borderThickness * 5;
        maximized = settings.getConfigBool("startMaximized");
        minimized = settings.getConfigBool("startMinimized");
        showMinimizeButton = settings.getConfigBool("showMinimizeButton");
        showMaximizeButton = settings.getConfigBool("showMaximizeButton");
        showCloseButton = settings.getConfigBool("showCloseButton");
        buttonStrokeThickness = settings.getConfigDbl("buttonStrokeThickness");
        buttonStrokeColor = settings.getConfigColor("buttonStrokeColor");
    }

    public void setWindowTitle(String windowTitle) {
        this.windowTitle.set(windowTitle);
    }

    public void init() {
        //TODO: Not ideal for constraining window position if screen resolutions vary, but ok for now
        ObservableList<Screen> screens = Screen.getScreens();
        for (Screen s : screens) {
            double mx = s.getBounds().getMaxX();
            double my = s.getBounds().getMaxY();
            monitorMaxWidth = Math.max(mx, monitorMaxWidth);
            monitorMaxHeight = Math.max(my, monitorMaxHeight);
        }
        
        Pane titleBar = createTitleBar();

        VBox center = new VBox(titleBar, rootPane);
        VBox.setVgrow(rootPane, Priority.ALWAYS);

        HBox topEdge = createTopEdge();
        VBox rightEdge = createRightEdge();
        HBox bottomEdge = createBottomEdge();
        VBox leftEdge = createLeftEdge();

        framePane.setTop(topEdge);
        framePane.setRight(rightEdge);
        framePane.setCenter(center);
        framePane.setBottom(bottomEdge);
        framePane.setLeft(leftEdge);
    }

    private Pane createTitleBar() {
        StackPane titleBar = new StackPane();
        titleBar.getStyleClass().add("jfxkTitleBar");
        titleBar.setMinHeight(titleBarHeight);
        titleBar.setOnMousePressed(event -> {
            if (event.isPrimaryButtonDown()) {
                dragOffsetX = event.getX();
                dragOffsetY = event.getY();
            }
        });
        titleBar.setOnMouseDragged(event -> {
            if (event.isPrimaryButtonDown()) {
                stage.setX(event.getScreenX() - dragOffsetX);
                stage.setY(event.getScreenY() - dragOffsetY);
                constrainWindowBounds();
            }
        });

        Pos alignment = Pos.valueOf(titleBarAlignment);
        titleBar.setAlignment(alignment);
        Label title = new Label();
        title.textProperty().bind(windowTitle);

        HBox buttonHb = new HBox();
        buttonHb.setAlignment(Pos.CENTER_RIGHT);
        HBox.setHgrow(buttonHb, Priority.ALWAYS);
        Hyperlink minimize = new Hyperlink("", getMinIcon());
        minimize.setOnAction(event -> toggleMinimize());
        Hyperlink maximize = new Hyperlink("", getMaxIcon());
        maximize.setOnAction(event -> toggleMaximize());
        Hyperlink close = new Hyperlink("", getCloseIcon());
        close.setOnAction(event -> requestClose());

        titleBar.getChildren().add(title);
        if (showMinimizeButton) {
            buttonHb.getChildren().add(minimize);
        }
        if (showMaximizeButton) {
            buttonHb.getChildren().add(maximize);
        }
        if (showCloseButton) {
            buttonHb.getChildren().add(close);
        }
        titleBar.getChildren().add(buttonHb);
        titleBar.setOnMouseClicked(mouseEvent -> {
            if ((mouseEvent.getButton().equals(MouseButton.PRIMARY)) && (mouseEvent.getClickCount() == 2)) {
                toggleMaximize();
            }
        });
        return titleBar;
    }

    private void constrainWindowBounds() {
        double x = MathUtils.clamp(stage.getX(), -stage.getWidth() * 0.7, monitorMaxWidth - stage.getWidth() * 0.3);
        double y = MathUtils.clamp(stage.getY(), 0, monitorMaxHeight - titleBarHeight);
        stage.setX(x);
        stage.setY(y);
    }

    private void requestClose() {
        Platform.exit();
    }

    private Pane getMinIcon() {
        Pane p = new Pane();
        p.getStyleClass().add("jfxkTitleBarMinIcon");
        p.setPrefHeight(titleBarHeight);
        p.setPrefWidth(titleBarHeight);
        drawLine(p, 0.7, 0.7, 0.3, 0.7);
        return p;
    }

    private Pane getMaxIcon() {
        Pane p = new Pane();
        p.getStyleClass().add("jfxkTitleBarMaxIcon");
        p.setPrefHeight(titleBarHeight);
        p.setPrefWidth(titleBarHeight);
        drawLine(p, 0.3, 0.3, 0.7, 0.3);
        drawLine(p, 0.7, 0.3, 0.7, 0.7);
        drawLine(p, 0.7, 0.7, 0.3, 0.7);
        drawLine(p, 0.3, 0.7, 0.3, 0.3);
        return p;
    }

    private Pane getCloseIcon() {
        Pane p = new Pane();
        p.getStyleClass().add("jfxkTitleBarCloseIcon");
        p.setPrefHeight(titleBarHeight);
        p.setPrefWidth(titleBarHeight);
        drawLine(p, 0.3, 0.3, 0.7, 0.7);
        drawLine(p, 0.7, 0.3, 0.3, 0.7);
        return p;
    }

    private void drawLine(Pane p, double x1, double y1, double x2, double y2) {
        Line l1 = new Line();
        l1.startXProperty().bind(p.widthProperty().multiply(x1));
        l1.startYProperty().bind(p.heightProperty().multiply(y1));
        l1.endXProperty().bind(p.widthProperty().multiply(x2));
        l1.endYProperty().bind(p.heightProperty().multiply(y2));
        l1.setStroke(buttonStrokeColor);
        l1.setStrokeWidth(buttonStrokeThickness);
        p.getChildren().add(l1);
    }

    private void toggleMaximize() {
        maximized = !stage.isMaximized();
        stage.setMaximized(maximized);
    }

    private void toggleMinimize() {
        minimized = !stage.isIconified();
        stage.setIconified(minimized);
    }

    private HBox createTopEdge() {
        HBox topLeftBorder = new HBox();
        topLeftBorder.getStyleClass().add("jfxkBorderNW");
        topLeftBorder.setPrefWidth(borderThicknessX5);
        setResizeHandlers(topLeftBorder, DragDirection.NW);

        HBox topMiddleBorder = new HBox();
        topMiddleBorder.getStyleClass().add("jfxkBorderN");
        HBox.setHgrow(topMiddleBorder, Priority.ALWAYS);
        setResizeHandlers(topMiddleBorder, DragDirection.N);

        HBox topRightBorder = new HBox();
        topRightBorder.getStyleClass().add("jfxkBorderNE");
        topRightBorder.setPrefWidth(borderThicknessX5);
        setResizeHandlers(topRightBorder, DragDirection.NE);

        HBox topEdge = new HBox(topLeftBorder, topMiddleBorder, topRightBorder);
        topEdge.setMinHeight(borderThickness);
        return topEdge;
    }

    private VBox createRightEdge() {
        VBox rightTopBorder = new VBox();
        rightTopBorder.getStyleClass().add("jfxkBorderNE");
        rightTopBorder.setPrefHeight(borderThicknessX5);
        setResizeHandlers(rightTopBorder, DragDirection.NE);

        VBox rightMiddleBorder = new VBox();
        rightMiddleBorder.getStyleClass().add("jfxkBorderE");
        VBox.setVgrow(rightMiddleBorder, Priority.ALWAYS);
        setResizeHandlers(rightMiddleBorder, DragDirection.E);

        VBox rightBottomBorder = new VBox();
        rightBottomBorder.getStyleClass().add("jfxkBorderSE");
        rightBottomBorder.setPrefHeight(borderThicknessX5);
        setResizeHandlers(rightBottomBorder, DragDirection.SE);

        VBox rightEdge = new VBox(rightTopBorder, rightMiddleBorder, rightBottomBorder);
        rightEdge.setMinWidth(borderThickness);
        return rightEdge;
    }

    private HBox createBottomEdge() {
        HBox bottomLeftBorder = new HBox();
        bottomLeftBorder.getStyleClass().add("jfxkBorderSW");
        bottomLeftBorder.setPrefWidth(borderThicknessX5);
        setResizeHandlers(bottomLeftBorder, DragDirection.SW);

        HBox bottomMiddleBorder = new HBox();
        bottomMiddleBorder.getStyleClass().add("jfxkBorderS");
        HBox.setHgrow(bottomMiddleBorder, Priority.ALWAYS);
        setResizeHandlers(bottomMiddleBorder, DragDirection.S);

        HBox bottomRightBorder = new HBox();
        bottomRightBorder.getStyleClass().add("jfxkBorderSE");
        bottomRightBorder.setPrefWidth(borderThicknessX5);
        setResizeHandlers(bottomRightBorder, DragDirection.SE);

        HBox bottomEdge = new HBox(bottomLeftBorder, bottomMiddleBorder, bottomRightBorder);
        bottomEdge.setMinHeight(borderThickness);
        return bottomEdge;
    }

    private VBox createLeftEdge() {
        VBox leftTopBorder = new VBox();
        leftTopBorder.getStyleClass().add("jfxkBorderNW");
        leftTopBorder.setPrefHeight(borderThicknessX5);
        setResizeHandlers(leftTopBorder, DragDirection.NW);

        VBox leftMiddleBorder = new VBox();
        leftMiddleBorder.getStyleClass().add("jfxkBorderW");
        VBox.setVgrow(leftMiddleBorder, Priority.ALWAYS);
        setResizeHandlers(leftMiddleBorder, DragDirection.W);

        VBox leftBottomBorder = new VBox();
        leftBottomBorder.getStyleClass().add("jfxkBorderSW");
        leftBottomBorder.setPrefHeight(borderThicknessX5);
        setResizeHandlers(leftBottomBorder, DragDirection.SW);

        VBox leftEdge = new VBox(leftTopBorder, leftMiddleBorder, leftBottomBorder);
        leftEdge.setMinWidth(borderThickness);
        return leftEdge;
    }

    private void setResizeHandlers(Pane pane, DragDirection dragDirection) {
        pane.setOnMousePressed(event -> {
            if (event.isPrimaryButtonDown()) {
                dragStartScreenX = event.getScreenX();
                dragStartScreenY = event.getScreenY();
                targetStageWidth = stage.getWidth();
                targetStageHeight = stage.getHeight();
                event.consume();
            }
        });

        pane.setOnMouseDragged(event -> {
            if (!event.isPrimaryButtonDown()) {
                return;
            }

            double mouseScreenX = event.getScreenX();
            double mouseScreenY = event.getScreenY();
            double deltaX = mouseScreenX - dragStartScreenX;
            double deltaY = mouseScreenY - dragStartScreenY;
            dragStartScreenX = mouseScreenX;
            dragStartScreenY = mouseScreenY;
            
            if (deltaX == 0 && deltaY ==0) {
                return;
            }

            log.debug("mouseScreenX={} mouseScreenY={}\ndeltaX={} deltaY={} stageX={} stageY={} " +
                            "stageW={} stageH={} sceneX={} sceneY={} targetStageWidth={} targetStageHeight={}",
                    mouseScreenX, mouseScreenY, deltaX, deltaY, stage.getX(), stage.getY(),
                    stage.getWidth(), stage.getHeight(), event.getSceneX(), event.getSceneY(),
                    targetStageWidth,targetStageHeight);

            switch (dragDirection) {
                case N:
                    if (mouseScreenY < stage.getY() + stage.getHeight() - stage.getMinHeight()) {
                        stage.setY(mouseScreenY);
                        resizeStageHeight(-deltaY);
                    }
                    break;
                case NE:
                    if (mouseScreenY < stage.getY() + stage.getHeight() - stage.getMinHeight()) {
                        stage.setY(mouseScreenY);
                        resizeStageHeight(-deltaY);
                    }
                    resizeStageWidth(deltaX);
                    break;
                case E:
                    resizeStageWidth(deltaX);
                    break;
                case SE:
                    resizeStageHeight(deltaY);
                    resizeStageWidth(deltaX);
                    break;
                case S:
                    resizeStageHeight(deltaY);
                    break;
                case SW:
                    if (mouseScreenX < stage.getX() + stage.getWidth() - stage.getMinWidth()) {
                        stage.setX(mouseScreenX);
                        resizeStageWidth(-deltaX);
                    }
                    resizeStageHeight(deltaY);
                    break;
                case W:
                    if (mouseScreenX < stage.getX() + stage.getWidth() - stage.getMinWidth()) {
                        stage.setX(mouseScreenX);
                        resizeStageWidth(-deltaX);
                    }
                    break;
                case NW:
                    if (mouseScreenY < stage.getY() + stage.getHeight() - stage.getMinHeight()) {
                        stage.setY(mouseScreenY);
                        resizeStageHeight(-deltaY);
                    }
                    if (mouseScreenX < stage.getX() + stage.getWidth() - stage.getMinWidth()) {
                        stage.setX(mouseScreenX);
                        resizeStageWidth(-deltaX);
                    }
                    break;
            }
            event.consume();
        });
    }

    private void resizeStageWidth(double deltaX) {
        double newWidth = targetStageWidth + deltaX;

        if (newWidth >= stage.getMinWidth() && newWidth <= stage.getMaxWidth()) {
            targetStageWidth = newWidth;
            stage.setWidth(newWidth);
            stage.setHeight(targetStageHeight);
        }
    }

    private void resizeStageHeight(double deltaY) {
        double newHeight = targetStageHeight + deltaY;

        if (newHeight >= stage.getMinHeight() && newHeight <= stage.getMaxHeight()) {
            targetStageHeight = newHeight;
            stage.setHeight(newHeight);
            stage.setWidth(targetStageWidth);
        }
    }

    private enum DragDirection {
        N, NE, E, SE, S, SW, W, NW
    }
}

[Lou Hamers]

Kevin Ferreira wrote:
what you mean removing the scene temporarily will result into? the effect itself that code into the left resizing is moving the borders while dragging, that looks so bad, don't know if it is an 'animation' issue only, you know? i am basicly open for ANYTHING that would result in a similar effect as the inbuilt DECORATED resizing system

Yeah I am still seeing that a little bit, I think I know what you mean. The severity is quite possibly hardware performance dependent too.

What I meant by removing part of the scene is using scene.getChildren().clear() (or removing some specific children) during the drag, and then re-add those children (basically re-adding your entire UI, or most of it) back to the scene after the drag is done.



I THINK you should be able to do that without issues. You might have to re-initialize all the view stuff when you add it back into the scene (Possibly not though! You can try re-adding the old children.). That'd be highly design dependent. I'm uncertain if that would work out without causing another problem, but it's an idea that I was thinking of trying as a last resort. Ideally things should just resize with the window, but I have seen some applications here and there use this trick. It's even a performance optimization setting that some OSes support natively, when resizing or dragging windows.

If you try that and it does solve the glitchyness, you can try adding a simple container or an image to the stage which serves as an indicator to the user that they're resizing the window, which gets replaced with the real UI once the resize is done. That'd look a lot better than a blank screen during the resize, anyway.

[Kevin Ferreira]

i will study your last posts this week, but if you allow me to ask, how can i initialize the entire code of a Stack Over Flow user that posted a solution about it for JavaFX, let me show you his code:

https://paste.myst.rs/9hc26guh

i struggle to initialize the method addListenerDeeply because i call it this way ResizeHelperAlexander.addListenerDeeply(node, listener); and it doesn't recognize node or listener, can you give me a tip about it?

[Lou Hamers]

It looks like what you typed (calling it as a public static method) should work. So I guess I don't understand the error you're getting.
(I don't think I'd use a static method for that and I don't see the need for what it's doing, but technically I don't notice an issue.)

By the way, you can add code here directly easier if you click the "Code" button above and put it between the tags. Plus it ensures people coming later can see what was being discussed, in case the link breaks. But just IMO, I don't think I would use any of this code or use that addListenerDeeply() method.

I've pasted it below (with slight changes so it would build for me).

package org.example;

import javafx.application.Application;
import javafx.collections.ObservableList;
import javafx.event.EventHandler;
import javafx.event.EventType;
import javafx.scene.Cursor;
import javafx.scene.Node;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.BorderPane;
import javafx.stage.Stage;

/**
 * Util class to handle window resizing when a stage style set to StageStyle.UNDECORATED.
 * Includes dragging of the stage.
 * Original on 6/13/14.
 * Updated on 8/15/17.
 * Updated on 12/19/19.
 *
 * @author Alexander.Berg
 * @author Evgenii Kanivets
 * @author Zachary Perales
 */

public class Main extends Application {
    
    @Override
    public void start(Stage stage) {
        BorderPane root = new BorderPane();
        Scene scene = new Scene(root, 800, 600);
        stage.setScene(scene);
        //stage.setTitle("Resizable Stage Example");
        System.out.println("Hello");
        // Call addResizeListener() from Main and pass primaryStage
        Main.addResizeListener(stage);
        
        stage.show();
    }
    
    public static void addResizeListener(Stage stage) {
        System.out.println("Hello2");
        addResizeListener(stage, 1, 1, Double.MAX_VALUE, Double.MAX_VALUE);
    }
    
    public static void addResizeListener(Stage stage, double minWidth, double minHeight, double maxWidth, double maxHeight) {
        
        ResizeListener resizeListener = new ResizeListener(stage);
        stage.getScene().addEventHandler(MouseEvent.MOUSE_MOVED, resizeListener);
        stage.getScene().addEventHandler(MouseEvent.MOUSE_PRESSED, resizeListener);
        stage.getScene().addEventHandler(MouseEvent.MOUSE_DRAGGED, resizeListener);
        stage.getScene().addEventHandler(MouseEvent.MOUSE_EXITED, resizeListener);
        stage.getScene().addEventHandler(MouseEvent.MOUSE_EXITED_TARGET, resizeListener);
        
        resizeListener.setMinWidth(minWidth);
        resizeListener.setMinHeight(minHeight);
        resizeListener.setMaxWidth(maxWidth);
        resizeListener.setMaxHeight(maxHeight);
        
        ObservableList<Node> children = stage.getScene().getRoot().getChildrenUnmodifiable();
        for (Node child : children) {
            addListenerDeeply(child, resizeListener);
        }
        System.out.println("Hello3");
    }
    
    
    public static void addListenerDeeply(Node node, EventHandler<MouseEvent> listener) {
        System.out.println("Hello4");
        node.addEventHandler(MouseEvent.MOUSE_MOVED, listener);
        node.addEventHandler(MouseEvent.MOUSE_PRESSED, listener);
        node.addEventHandler(MouseEvent.MOUSE_DRAGGED, listener);
        node.addEventHandler(MouseEvent.MOUSE_EXITED, listener);
        node.addEventHandler(MouseEvent.MOUSE_EXITED_TARGET, listener);
        if (node instanceof Parent) {
            Parent parent = (Parent) node;
            ObservableList<Node> children = parent.getChildrenUnmodifiable();
            for (Node child : children) {
                addListenerDeeply(child, listener);
            }
        }
        System.out.println("Hello4");
    }
    
    
    static class ResizeListener implements EventHandler<MouseEvent> {
        private Stage stage;
        private Cursor cursorEvent = Cursor.DEFAULT;
        private boolean resizing = true;
        private int border = 4;
        private double startX = 0;
        private double startY = 0;
        private double screenOffsetX = 0;
        private double screenOffsetY = 0;
        
        // Max and min sizes for controlled stage
        private double minWidth;
        private double maxWidth;
        private double minHeight;
        private double maxHeight;
        
        public ResizeListener(Stage stage) {
            this.stage = stage;
        }
        
        public void setMinWidth(double minWidth) {
            this.minWidth = minWidth;
        }
        
        public void setMaxWidth(double maxWidth) {
            this.maxWidth = maxWidth;
        }
        
        public void setMinHeight(double minHeight) {
            this.minHeight = minHeight;
        }
        
        public void setMaxHeight(double maxHeight) {
            this.maxHeight = maxHeight;
        }
        
        @Override
        public void handle(MouseEvent mouseEvent) {
            System.out.println("Hello6");
            EventType<? extends MouseEvent> mouseEventType = mouseEvent.getEventType();
            Scene scene = stage.getScene();
            
            double mouseEventX = mouseEvent.getSceneX(),
                    mouseEventY = mouseEvent.getSceneY(),
                    sceneWidth = scene.getWidth(),
                    sceneHeight = scene.getHeight();
            
            if (MouseEvent.MOUSE_MOVED.equals(mouseEventType)) {
                if (mouseEventX < border && mouseEventY < border) {
                    cursorEvent = Cursor.NW_RESIZE;
                } else if (mouseEventX < border && mouseEventY > sceneHeight - border) {
                    cursorEvent = Cursor.SW_RESIZE;
                } else if (mouseEventX > sceneWidth - border && mouseEventY < border) {
                    cursorEvent = Cursor.NE_RESIZE;
                } else if (mouseEventX > sceneWidth - border && mouseEventY > sceneHeight - border) {
                    cursorEvent = Cursor.SE_RESIZE;
                } else if (mouseEventX < border) {
                    cursorEvent = Cursor.W_RESIZE;
                } else if (mouseEventX > sceneWidth - border) {
                    cursorEvent = Cursor.E_RESIZE;
                } else if (mouseEventY < border) {
                    cursorEvent = Cursor.N_RESIZE;
                } else if (mouseEventY > sceneHeight - border) {
                    cursorEvent = Cursor.S_RESIZE;
                } else {
                    cursorEvent = Cursor.DEFAULT;
                }
                scene.setCursor(cursorEvent);
            } else if (MouseEvent.MOUSE_EXITED.equals(mouseEventType) || MouseEvent.MOUSE_EXITED_TARGET.equals(mouseEventType)) {
                scene.setCursor(Cursor.DEFAULT);
            } else if (MouseEvent.MOUSE_PRESSED.equals(mouseEventType)) {
                startX = stage.getWidth() - mouseEventX;
                startY = stage.getHeight() - mouseEventY;
            } else if (MouseEvent.MOUSE_DRAGGED.equals(mouseEventType)) {
                if (!Cursor.DEFAULT.equals(cursorEvent)) {
                    resizing = true;
                    if (!Cursor.W_RESIZE.equals(cursorEvent) && !Cursor.E_RESIZE.equals(cursorEvent)) {
                        double minHeight = stage.getMinHeight() > (border * 2) ? stage.getMinHeight() : (border * 2);
                        if (Cursor.NW_RESIZE.equals(cursorEvent) || Cursor.N_RESIZE.equals(cursorEvent)
                                || Cursor.NE_RESIZE.equals(cursorEvent)) {
                            if (stage.getHeight() > minHeight || mouseEventY < 0) {
                                setStageHeight(stage.getY() - mouseEvent.getScreenY() + stage.getHeight());
                                stage.setY(mouseEvent.getScreenY() );
                            }
                        } else {
                            if (stage.getHeight() > minHeight || mouseEventY + startY - stage.getHeight() > 0) {
                                setStageHeight(mouseEventY + startY);
                            }
                        }
                    }
                    
                    if (!Cursor.N_RESIZE.equals(cursorEvent) && !Cursor.S_RESIZE.equals(cursorEvent)) {
                        double minWidth = stage.getMinWidth() > (border * 2) ? stage.getMinWidth() : (border * 2);
                        if (Cursor.NW_RESIZE.equals(cursorEvent) || Cursor.W_RESIZE.equals(cursorEvent)
                                || Cursor.SW_RESIZE.equals(cursorEvent)) {
                            if (stage.getWidth() > minWidth || mouseEventX < 0) {
                                setStageWidth(stage.getX() - mouseEvent.getScreenX() + stage.getWidth());
                                stage.setX(mouseEvent.getScreenX());
                            }
                        } else {
                            if (stage.getWidth() > minWidth || mouseEventX + startX - stage.getWidth() > 0) {
                                setStageWidth(mouseEventX + startX);
                            }
                        }
                    }
                    resizing = false;
                }
            }
            
            if (MouseEvent.MOUSE_PRESSED.equals(mouseEventType) && Cursor.DEFAULT.equals(cursorEvent)) {
                resizing = false;
                screenOffsetX = stage.getX() - mouseEvent.getScreenX();
                screenOffsetY = stage.getY() - mouseEvent.getScreenY();
            }
            
            if (MouseEvent.MOUSE_DRAGGED.equals(mouseEventType) && Cursor.DEFAULT.equals(cursorEvent) && resizing == false) {
                stage.setX(mouseEvent.getScreenX() + screenOffsetX);
                stage.setY(mouseEvent.getScreenY() + screenOffsetY);
            }
            
        }
        
        private void setStageWidth(double width) {
            width = Math.min(width, maxWidth);
            width = Math.max(width, minWidth);
            stage.setWidth(width);
        }
        
        private void setStageHeight(double height) {
            height = Math.min(height, maxHeight);
            height = Math.max(height, minHeight);
            stage.setHeight(height);
        }
        
    }
}

[Lou Hamers]

What operating system are you on, by the way? And GPU type?

For the window flickering issue, it's possible there may just be no fix without filing a good bug report. But it would need to be a very good one which is reproducible, because I've seen some past reports for this issue that have been dismissed for one reason or another.

[Kevin Ferreira]

Lou Hamers wrote:What operating system are you on, by the way? And GPU type?

For the window flickering issue, it's possible there may just be no fix without filing a good bug report. But it would need to be a very good one which is reproducible, because I've seen some past reports for this issue that have been dismissed for one reason or another.

What you mean by reproducible? because this is what i will make since i don't want this small bug mess with my dream. I will probably share my report here so people can help me.

I use windows 10 with HP Inbuilt GPU = Intel Graphics 520

Gotta realize that it's not only about it flickering but the resizing itself moves the border and trembles, thats why i think it has to do with JavaFX inbuilt functionality not any graphics GPU issue.

Have you ever tried some libraries? i say this because i also struggle to implement them and couldn't success with these version of so called Borderless Scene lib, could you test it on latest JavaFX version? (There's three different versions)
I have built the path of lib and implemented so while executing its function it always has some errors, apparently followed the steps of documentation but as you are more experienced you might know how to do so, i'd be thankful if you help me.

Check the variations of Borderless Scene:

https://github.com/CatWithAWand/BorderlessSceneFX
https://github.com/goxr3plus/FX-BorderlessScene
https://github.com/NicolasSenetLarson/BorderlessScene

[Lou Hamers]

Yeah, if you try submitting a bug report, let's see if any of the ranchers here are willing to help out.

By reproducible I just mean that I've seen a lot of similar bugs filed against JFX, and the devs end up closing it without any real resolution, because they couldn't see the problem themselves. So we need a good concise example to attach, and pictures/video showing the glitches.

I'm on Linux here and I've seen this stuff happen on NVidia and AMD. So we pretty much cover everything assuming we're talking about the same glitches.

Kevin Ferreira wrote:
Gotta realize that it's not only about it flickering but the resizing itself moves the border and trembles, thats why i think it has to do with JavaFX inbuilt functionality not any graphics GPU issue.

Yes the window resizing stuff won't be GPU related (flickering, maybe), but there could be two different issues combining here.

I've used at least one and maybe two of those libs before. Not sure about a third. When I get a chance I'll see if any of those try a different approach, but I suspect not.