JavaFX Falscher Wert getLayoutBounds? + Tipps zum Code-Aufbau?

[Tenecius]

Servus,

ich bin derzeit dabei mir JavaFX anzueignen und habe mal drauf los geschrieben. Habe jetzt ein Problem, welches ich nicht durch Google lösen konnte. (hoffe ich habe hier im Forum nichts übersehen)
Außerdem wollte ich fragen, ob jemand Tipps bezüglich CodeAufbau hat und Tipps/Verbesserungen zu meiner Umsetzung.

Habe hier einen Screenshots meiner kleinen Spielerei beigefügt. Das Problem seht ihr bei dem gelb markierten Viereck.

Um die Slider zu begrenzen möchte ich die Größen des Center-Panes haben. Da diese von Screen zu Screen variabel sind, bin ich mit pane.getLayoutBounds.getWidth() und .getHeight() an die Sache gegangen.
Mit getWidth() klappt alles und der Slider ist richtig begrenzt.
Bei getHeight() werden allerdings ein paar Pixel zu viel angegeben und ich weiß nicht, wo der Fehler liegt. Wenn ich dem Pane Borders hinzufüge, dann werden diese richtig angezeigt. Bewege ich nun ein Objekt mit den Slidern, geht dieses aber über die Border hinaus. Woran liegt das denn?
Mir ist aufgefallen, dass der Wert auch variiert, je nachdem welche prefHeight ich dem Top und Bottom Element des BorderPanes gebe. Normal sollte das doch aber keinen Einfluss haben(?)
Ich habe derzeit bei Top und Bottom eine prefHeight von 30 eingestellt, dann passt es mit 3*radius bei der Y-Koordinate. Normal sollte es doch aber 2*radius sein. Und bei anderen Werten passt das 3*radius dann auch nicht mehr.
Eigentlich wollte ich nur, dass die Objekte nicht übers Ziel hinaus verschoben werden können. Kann ich glaub ich auch irgendwie anders mit der Borderberührung regeln, aber damit ist dieses Problem hier ja nicht gelöst, sondern ihm nur aus dem Weg gegangen.

Hier der Code, falls jemand mal drüber schauen möchte. Für Tipps bin ich dankbar.
Die setStyle Sachen könnte ich noch in eine CSS umlagern, das wollte ich jetzt aber am Anfang erstmal vermeiden.
Wie ich alles in eigene Klassen verlagere, muss ich noch schauen. Hab das anfangs versucht, aber dann funktionierte das Neuzeichnen der Objekte nicht.
Bei Swing gibt es dafür eine update und repaint Methode, hier habe ich aber nichts vergleichbares gefunden?

Spoiler: Programm

package application;

import javafx.application.Application;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.geometry.Rectangle2D;
import javafx.stage.Screen;
import javafx.stage.Stage;
import javafx.util.StringConverter;
import javafx.scene.Node;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.Slider;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Pane;
import javafx.scene.layout.VBox;
import javafx.scene.paint.Color;
import javafx.scene.shape.Circle;
import javafx.scene.shape.Rectangle;
import javafx.scene.shape.Shape;
import javafx.scene.text.Font;
import javafx.scene.text.Text;

public class Main extends Application {
   
   
    // ____________________________________________________________________________
    // Set Panels - Bord=Window, vBoxPosition=bord.left, vBoxColor=bord.right, hBoxNode=bord.top,
    // hBoxBottom=bord.bottm, paneCenter=bord.paneCenterter
    // ____________________________________________________________________________
    private BorderPane root = new BorderPane();
    private VBox vBoxPosition = new VBox();
    private VBox vBoxColor = new VBox();
    private HBox hBoxNode = new HBox();
    private HBox hBoxBottom = new HBox();
    private Pane paneCenter = new Pane();
   
   
    // ____________________________________________________________________________
    // Active Objekt(Circle or Rectangle...)
    // ____________________________________________________________________________
    private Node activenode;
    // ____________________________________________________________________________
    // Create Color.
    // ____________________________________________________________________________
    private Color color;
    private double rot;
    private double grün;
    private double blau;
   
   
    // ____________________________________________________________________________
    // Create panels for inside Bord.left
    // -x = Label+SliderXposi, -y = Label+SliderZposi, -z = Label+SliderZposi,
    // ____________________________________________________________________________
    private VBox paneXPos = new VBox();
    private VBox paneYPos = new VBox();
    private VBox paneZPos = new VBox();
    // ____________________________________________________________________________
    private HBox paneButtonPos = new HBox();
   
   
    // ____________________________________________________________________________
    // Create panels for inside Bord.right
    // -r = Label+SliderColR, -g = Label+SliderColG, -b = Label+SliderColB,
    // ____________________________________________________________________________
    private VBox paneColRed = new VBox();
    private VBox paneColGreen = new VBox();
    private VBox paneColBlue = new VBox();
    // ____________________________________________________________________________
    private HBox paneButtonCol = new HBox();
   
   
    // ____________________________________________________________________________
    // Create panels for inside Bord.top
    // panelNode = Slider - Nodes
    // ____________________________________________________________________________
    private Pane panelNode = new VBox();
    private Slider sliderNode;

    private Pane platzhalter = new Pane();
    // Platzhalter
    Label labelb = new Label("Ich putz hier nur.");

   
    // ____________________________________________________________________________
    // Create Labels for Sliders - Position and Color.
    // ____________________________________________________________________________
    private Label labelXPos;
    private Label labelYPos;
    private Label labelZPos;
    // ____________________________________________________________________________
    private Label labelColRed;
    private Label labelColGreen;
    private Label labelColBlue;
    // ____________________________________________________________________________
    // Create Slider for Position and Color.
    // ____________________________________________________________________________
    private Slider sliderXPos;
    private Slider sliderYPos;
    private Slider sliderZPos;
    // ____________________________________________________________________________
    private Slider sliderRed = new Slider(0, 1, 0);
    private Slider sliderGreen = new Slider(0, 1, 0);
    private Slider sliderBlue = new Slider(0, 1, 0);
    // ____________________________________________________________________________
    private Button buttonSliderCur = new Button("ResetCur");
    private Button buttonSliderAll = new Button("ResetAll");
    private Button buttonColorCur = new Button("ResetCur");
    private Button buttonColorAll = new Button("ResetAll");
   
   
    // ____________________________________________________________________________
    // Create the Objects/Nodes/Shapes...
    // ____________________________________________________________________________
    private double radius = 20.0;
    private Circle circle = new Circle();
    private Rectangle rect = new Rectangle();
    private Text texti = new Text();

    private Node[] nodelist = { circle, rect, texti };
   
   
    // ____________________________________________________________________________
    // Create Array for old Values.
    // ____________________________________________________________________________
    private double[][] position = new double[3][3]; // 0 0 = circle X, 1 0 = rect X, 2 0 = text X
    private double[][] colorVals = new double[3][3]; // 0 0 = circle R, 1 0 = rect R, 2 0 = text R
   
   
    // ____________________________________________________________________________
    // Initialize most of the created Variables.
    // ____________________________________________________________________________
    private void setStyle() {
        // ____________________________________________________________________________
        // ____________________________________________________________________________
        double paneCenterWidth = paneCenter.getLayoutBounds().getWidth();
        double paneCenterHeight = paneCenter.getLayoutBounds().getHeight();
        sliderXPos = new Slider(0, paneCenterWidth - 2 * radius, 0);
        sliderYPos = new Slider(0, paneCenterHeight - 3 * radius, 0);
        sliderZPos = new Slider(0, 100, 0);
        System.out.println("\n\nLayoutBonds:" + paneCenter.getLayoutBounds());
        // ____________________________________________________________________________
        sliderXPos.setPadding(new Insets(5, 5, 5, 5)); // Distance top, right, bottom, left
        sliderXPos.setShowTickMarks(true);
        sliderXPos.setShowTickLabels(true);
        sliderXPos.setMajorTickUnit(260);
        sliderXPos.setMinorTickCount(2);
        // ____________________________________________________________________________
        sliderYPos.setPadding(new Insets(5, 5, 5, 5));
        sliderYPos.setShowTickMarks(true);
        sliderYPos.setShowTickLabels(true);
        sliderYPos.setMajorTickUnit(200);
        sliderYPos.setMinorTickCount(2);
        // ____________________________________________________________________________
        sliderZPos.setDisable(true);
        sliderZPos.setPadding(new Insets(5, 5, 5, 5));
        sliderZPos.setShowTickMarks(true);
        sliderZPos.setShowTickLabels(true);
        sliderZPos.setMajorTickUnit(20);
        sliderZPos.setMinorTickCount(2);
        // ____________________________________________________________________________
        sliderRed.setShowTickMarks(true);
        sliderRed.setShowTickLabels(true);
        sliderRed.setMajorTickUnit(0.25);
        sliderRed.setMinorTickCount(1);
        // ____________________________________________________________________________
        sliderGreen.setShowTickMarks(true);
        sliderGreen.setShowTickLabels(true);
        sliderGreen.setMajorTickUnit(0.25);
        sliderGreen.setMinorTickCount(1);
        // ____________________________________________________________________________
        sliderBlue.setShowTickMarks(true);
        sliderBlue.setShowTickLabels(true);
        sliderBlue.setMajorTickUnit(0.25);
        sliderBlue.setMinorTickCount(1);
        // ____________________________________________________________________________
        sliderNode = new Slider(0, 3, 0);
        sliderNode.setPrefWidth(hBoxNode.getLayoutBounds().getWidth() * 0.75);
        sliderNode.setPadding(new Insets(5, 5, 5, 5));
        sliderNode.setShowTickMarks(true);
        sliderNode.setShowTickLabels(true);
        sliderNode.setSnapToTicks(true);
        sliderNode.setMajorTickUnit(1);
        sliderNode.setMinorTickCount(0);
       
       
        // ____________________________________________________________________________
        // Transform the Mark from Number to Label .
        // ____________________________________________________________________________
        sliderNode.setLabelFormatter(new StringConverter<Double>() {
            @Override
            public String toString(Double n) {
                if (n == 0)
                    return "None";
                if (n == 1)
                    return "Circle";
                if (n == 2)
                    return "Rectangle";
                else if (n == 3)
                    return "Text";
                else
                    return null;
            }

            @Override
            public Double fromString(String s) {
                switch (s) {
                case "None":
                    return 0d;
                case "Circle":
                    return 1d;
                case "Rectangle":
                    return 2d;
                case "Text":
                    return 3d;
                default:
                    return null;
                }
            }
        });
       
       
        // ____________________________________________________________________________
        // Initialize the Labels for Position and Color.
        // ____________________________________________________________________________
        labelXPos = new Label("X-Posi:");
        labelXPos.setPadding(new Insets(5, 5, 5, 5));
        labelYPos = new Label("Y-Posi:");
        labelYPos.setPadding(new Insets(5, 5, 5, 5));
        labelZPos = new Label("Z-Posi:");
        labelZPos.setPadding(new Insets(5, 5, 5, 5));
        // ____________________________________________________________________________
        labelColRed = new Label("Rot:");
        labelColRed.setPadding(new Insets(5, 5, 5, 5));
        labelColGreen = new Label("Grün:");
        labelColGreen.setPadding(new Insets(5, 5, 5, 5));
        labelColBlue = new Label("Blau:");
        labelColBlue.setPadding(new Insets(5, 5, 5, 5));
       
       
        // ____________________________________________________________________________
        // Adding the Labels and Slider to the Panels.
        // -x,y,z at Bord.left; -r,g,b at Bord.right; Node at Bord.top
        // ____________________________________________________________________________
        paneXPos.getChildren().addAll(labelXPos, sliderXPos);
        paneXPos.setStyle("-fx-border-style: solid; -fx-border-color: black; -fx-border-width: 0 0 1 0;");
        paneYPos.getChildren().addAll(labelYPos, sliderYPos);
        paneYPos.setStyle("-fx-border-style: solid; -fx-border-color: black; -fx-border-width: 0 0 1 0;");
        paneZPos.getChildren().addAll(labelZPos, sliderZPos);
        paneZPos.setStyle("-fx-border-style: solid; -fx-border-color: black; -fx-border-width: 0 0 1 0;");
        // ____________________________________________________________________________
        paneButtonPos.getChildren().addAll(buttonSliderCur, buttonSliderAll);
        paneButtonPos.setStyle("-fx-padding: 5 0 5 25;");
        // ____________________________________________________________________________
        paneColRed.getChildren().addAll(labelColRed, sliderRed);
        paneColRed.setStyle("-fx-border-style: solid; -fx-border-color: black; -fx-border-width: 0 0 1 0;");
        paneColGreen.getChildren().addAll(labelColGreen, sliderGreen);
        paneColGreen.setStyle("-fx-border-style: solid; -fx-border-color: black; -fx-border-width: 0 0 1 0;");
        paneColBlue.getChildren().addAll(labelColBlue, sliderBlue);
        paneColBlue.setStyle("-fx-border-style: solid; -fx-border-color: black; -fx-border-width: 0 0 1 0;");
        paneButtonCol.getChildren().addAll(buttonColorCur, buttonColorAll);
        paneButtonCol.setStyle("-fx-border-style: solid; -fx-border-color: black; -fx-border-width: 0 0 1 0;"
                + "-fx-padding: 5 0 5 25;");
        // ____________________________________________________________________________
        panelNode.getChildren().addAll(sliderNode);
        // ____________________________________________________________________________
        platzhalter.getChildren().add(labelb);
        labelb.setStyle("-fx-font: 30px Serif");

       
        // Creating the Shapes
        // ____________________________________________________________________________
        color = new Color(0, 0, 0, 1.0);
        circle.setRadius(20.0);
        circle.setCenterX(20.0);
        circle.setCenterY(20.0);
        circle.setFill(color);
        // ____________________________________________________________________________
        rect.setWidth(2 * radius);
        rect.setHeight(2 * radius);
        rect.setFill(color);
        rect.setStroke(Color.BLACK);
        // ____________________________________________________________________________
        texti.setText("Christbaumwerfer");
        texti.setFont(new Font(20));
    }
   
   
    // ____________________________________________________________________________
    // Creating the Methods for Translation and Color Change.
    // ____________________________________________________________________________
    private void transX(Node node, double valx) {
        labelXPos.setText("X-Posi: " + round(sliderXPos.getValue()));
        try {
            node.setTranslateX(valx);
        } catch (Exception e) {
        }
    }

    // ____________________________________________________________________________
    private void transY(Node node, double valy) {
        labelYPos.setText("Y-Posi: " + round(sliderYPos.getValue()));
        try {
            node.setTranslateY(valy);
        } catch (Exception e) {
        }
    }

    // ____________________________________________________________________________
    private void transZ(Node node, double valz) {
        labelZPos.setText("Z-Posi: " + round(sliderZPos.getValue()));
        try {
            node.setTranslateZ(valz);
        } catch (Exception e) {
        }
    }

    // ____________________________________________________________________________
    public void repaintt(Node node) {
        color = new Color(rot, grün, blau, 1.0);
        try {
            ((Shape) node).setFill(color);
        } catch (Exception e) {
        }
    }
   

    // ____________________________________________________________________________
    // Setter for old Values of the Sliders - Position and Color.
    // ____________________________________________________________________________
    public void setOldSliderPos(Node node, double oldX, double oldY, double oldZ) {
        if (node == circle) {
            position[0][0] = oldX;
            position[0][1] = oldY;
            position[0][2] = oldZ;
        }
        if (node == rect) {
            position[1][0] = oldX;
            position[1][1] = oldY;
            position[1][2] = oldZ;
        }
        if (node == texti) {
            position[2][0] = oldX;
            position[2][1] = oldY;
            position[2][2] = oldZ;
        }
    }

    // ____________________________________________________________________________
    public void setOldCol(Node node, double oldR, double oldG, double oldB) {
        if (node == circle) {
            colorVals[0][0] = oldR;
            colorVals[0][1] = oldG;
            colorVals[0][2] = oldB;
        }
        if (node == rect) {
            colorVals[1][0] = oldR;
            colorVals[1][1] = oldG;
            colorVals[1][2] = oldB;
        }
        if (node == texti) {
            colorVals[2][0] = oldR;
            colorVals[2][1] = oldG;
            colorVals[2][2] = oldB;
        }
    }

   
    // ____________________________________________________________________________
    // Getter for old Values of the Objects/Nodes/Shapes.
    // Get the old Value and change the current Value of the Slider to the old.
    // ____________________________________________________________________________
    public void getOldSliderPos() {
        if (activenode == circle) {
            sliderXPos.setValue(position[0][0]);
            sliderYPos.setValue(position[0][1]);
            sliderZPos.setValue(position[0][2]);
        } else if (activenode == rect) {
            sliderXPos.setValue(position[1][0]);
            sliderYPos.setValue(position[1][1]);
            sliderZPos.setValue(position[1][2]);
        } else if (activenode == texti) {
            sliderXPos.setValue(position[2][0]);
            sliderYPos.setValue(position[2][1]);
            sliderZPos.setValue(position[2][2]);
        }
    }

    // ____________________________________________________________________________
    public void getOldCol() {
        if (activenode == circle) {
            sliderRed.setValue(colorVals[0][0]);
            sliderGreen.setValue(colorVals[0][1]);
            sliderBlue.setValue(colorVals[0][2]);
        } else if (activenode == rect) {
            sliderRed.setValue(colorVals[1][0]);
            sliderGreen.setValue(colorVals[1][1]);
            sliderBlue.setValue(colorVals[1][2]);
        } else if (activenode == texti) {
            sliderRed.setValue(colorVals[2][0]);
            sliderGreen.setValue(colorVals[2][1]);
            sliderBlue.setValue(colorVals[2][2]);
        }
    }
   
   
    // ____________________________________________________________________________
    // Resetmethods Position and Color
    // ____________________________________________________________________________
    public void resetPos(Node node, double mod) {
        if (mod == 1) {
            for (int i = 0; i < nodelist.length; i++) {
                node = nodelist[i];
                setOldSliderPos(node, 0, 0, 0);
                getOldSliderPos();
                transX(node, 0);
                transY(node, 0);
                transZ(node, 0);
            }
        } else {
            setOldSliderPos(node, 0, 0, 0);
            getOldSliderPos();
            transX(node, 0);
            transY(node, 0);
            transZ(node, 0);
        }
    }

    public void resetCol(Node node, double mod) {
        if (mod == 1) {
            for (int i = 0; i < nodelist.length; i++) {
                node = nodelist[i];
                setOldCol(node, 0, 0, 0);
                getOldCol();
                ((Shape) node).setFill(Color.BLACK);
            }
        } else {
            setOldCol(node, 0, 0, 0);
            getOldCol();
            ((Shape) node).setFill(Color.BLACK);
        }
    }
   

    // ____________________________________________________________________________
    // round 1,1234 -> 1,12 and 1,4 -> 1
    // ____________________________________________________________________________
    public double round(final double value) {
        return Math.round(100.0 * value) / 100.0;
    }

    // ____________________________________________________________________________
    public double roundi(final double value) {
        return Math.round(10.0 * value) / 10.0;
    }
   
    // ____________________________________________________________________________
    // Check Bounds to identify collisions with other Shapes
    // ____________________________________________________________________________
    public void checkBounds(Node node) {
        boolean collision = false;
        for (Node static_sblock : nodelist) {
            if (static_sblock != node) {
                if (node.getBoundsInParent().intersects(static_sblock.getBoundsInParent())) {
                    collision = true;
                }
            }
        }
        if (collision) {
            ((Shape) node).setFill(Color.GREEN);
        } else {
            ((Shape) node).setFill(color);
        }
    }
   
   
   
   


    // ____________________________________________________________________________
    // Now get it started. start.method creates the Stage/Window.
    // ____________________________________________________________________________
    @Override
    public void start(Stage primaryStage) {
        // ____________________________________________________________________________
        // First create a Rectangle to get the size of the screen.
        // ____________________________________________________________________________
        Rectangle2D screen = Screen.getPrimary().getVisualBounds();
        Scene scene = new Scene(root, screen.getWidth() / 2, screen.getHeight() / 2);
       
        // ____________________________________________________________________________
        // ____________________________________________________________________________
        // Adding big panels to greater Panels.
        // Greater Panels will be added to Bord for better Placement.
        // ____________________________________________________________________________
        vBoxPosition.getChildren().addAll(paneXPos, paneYPos, paneZPos, paneButtonPos);
        vBoxPosition.setPrefWidth(200);
        vBoxColor.getChildren().addAll(paneColRed, paneColGreen, paneColBlue, paneButtonCol);
        vBoxColor.setPrefWidth(200);
        hBoxNode.getChildren().addAll(panelNode);
        hBoxNode.setAlignment(Pos.CENTER);
        hBoxNode.setPrefHeight(30);
        hBoxBottom.getChildren().add(platzhalter);
        hBoxBottom.setAlignment(Pos.CENTER);
        hBoxBottom.setPrefHeight(30);
        paneCenter.getChildren().addAll(circle, rect, texti);
        root.setCenter(paneCenter);
        root.setLeft(vBoxPosition);
        root.setRight(vBoxColor);
        root.setTop(hBoxNode);
        root.setBottom(hBoxBottom);
        root.layout(); // With this I get the Width and Height even before the Stage is build.
       
       
        // ____________________________________________________________________________
        // Call setStyle() to initialize all the Labels and Sliders etc.
        // ____________________________________________________________________________
        setStyle();
        // ____________________________________________________________________________
       

        // ____________________________________________________________________________
        // Style the greater Panels, Border and Color(Color change thumbs of the
        // Slider - why?).
        // ____________________________________________________________________________
        vBoxPosition.setStyle("-fx-border-style: solid; -fx-border-width: 0 1 0 1; -fx-color: Red;");
        vBoxColor.setStyle("-fx-border-style: solid; -fx-border-width: 0 1 0 1; -fx-color: Blue;");
        hBoxNode.setStyle("-fx-border-style: solid; -fx-border-width: 1 1 1 1");
        hBoxBottom.setStyle("-fx-border-style: solid; -fx-border-width: 1 1 1 1");
       
       
        // ____________________________________________________________________________
        // Adding the greater Panels to Board and place them at the right Position.
        // ____________________________________________________________________________

       
        // ____________________________________________________________________________
        // ChangeListener for the Slider.
        // MainListener is the Node_Slider. When Node is chosen we can add the Listeners
        // to the other Sliders - Position and Color. But first ask whether the Node
        // has CHANGED. Not a normal Listener for the Node_Slider!
        // ____________________________________________________________________________

        sliderNode.valueChangingProperty().addListener(new ChangeListener<Boolean>() {
            // ____________________________________________________________________________
            // Set the activenode and get the old Values for Position and Color.
            // ____________________________________________________________________________
            @Override
            public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
                if (Math.round(sliderNode.getValue()) == 1) {
                    activenode = circle;
                    getOldSliderPos();
                    getOldCol();
                } else if (Math.round(sliderNode.getValue()) == 2) {
                    activenode = rect;
                    getOldSliderPos();
                    getOldCol();
                } else if (Math.round(sliderNode.getValue()) == 3) {
                    activenode = texti;
                    getOldSliderPos();
                    getOldCol();
                } else
                    ;
               
               
                // ____________________________________________________________________________
                // Now add a Listener to the Slider. Normal one, because we want to repaint our
                // Object while changing the Slider. Send new Coords and activenode for Change.
                // ____________________________________________________________________________
                sliderXPos.valueProperty().addListener(new ChangeListener<Number>() {
                    @Override
                    public void changed(ObservableValue<? extends Number> observable, Number oldv, Number newv) {
                        transX(activenode, (double) newv);
                        checkBounds(activenode);
                    }
                });
               
               
                // ____________________________________________________________________________
                // Now the HAS_CHANGED_LISTENER because we want to save the last Value of the
                // Slider. So we can change the Object/Node and still have the Values of the
                // previous Object.
                // ____________________________________________________________________________
                sliderXPos.valueChangingProperty().addListener(new ChangeListener<Boolean>() {
                    @Override
                    public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue,
                            Boolean newValue) {
                        setOldSliderPos(activenode, sliderXPos.getValue(), sliderYPos.getValue(),
                                sliderZPos.getValue());
                    }
                });
               
               
                // ____________________________________________________________________________
                // Just repeat for every Slider - Position and Color.
                // ____________________________________________________________________________
                sliderYPos.valueProperty().addListener(new ChangeListener<Number>() {
                    @Override
                    public void changed(ObservableValue<? extends Number> observable, Number oldv, Number newv) {
                        transY(activenode, (double) newv);
                        checkBounds(activenode);
                    }
                });
                sliderYPos.valueChangingProperty().addListener(new ChangeListener<Boolean>() {
                    @Override
                    public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue,
                            Boolean newValue) {
                        setOldSliderPos(activenode, sliderXPos.getValue(), sliderYPos.getValue(),
                                sliderZPos.getValue());
                    }
                });
                // ____________________________________________________________________________
                sliderZPos.valueProperty().addListener(new ChangeListener<Number>() {
                    @Override
                    public void changed(ObservableValue<? extends Number> observable, Number oldv, Number newv) {
                        transZ(activenode, (double) newv);
                    }
                });
                sliderZPos.valueChangingProperty().addListener(new ChangeListener<Boolean>() {
                    @Override
                    public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue,
                            Boolean newValue) {
                        setOldSliderPos(activenode, sliderXPos.getValue(), sliderYPos.getValue(),
                                sliderZPos.getValue());
                    }
                });
                // ____________________________________________________________________________
                // Color
                // ____________________________________________________________________________
                sliderRed.valueProperty().addListener(new ChangeListener<Number>() {
                    @Override
                    public void changed(ObservableValue<? extends Number> observable, Number oldv, Number newv) {
                        rot = (double) newv;
                        repaintt(activenode);
                    }
                });
                sliderRed.valueChangingProperty().addListener(new ChangeListener<Boolean>() {
                    @Override
                    public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue,
                            Boolean newValue) {
                        setOldCol(activenode, sliderRed.getValue(), sliderGreen.getValue(), sliderBlue.getValue());
                    }
                });
                // ____________________________________________________________________________
                sliderGreen.valueProperty().addListener(new ChangeListener<Number>() {
                    @Override
                    public void changed(ObservableValue<? extends Number> observable, Number oldv, Number newv) {
                        grün = (double) newv;
                        repaintt(activenode);
                    }
                });
                sliderGreen.valueChangingProperty().addListener(new ChangeListener<Boolean>() {
                    @Override
                    public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue,
                            Boolean newValue) {
                        setOldCol(activenode, sliderRed.getValue(), sliderGreen.getValue(), sliderBlue.getValue());
                    }
                });
                // ____________________________________________________________________________
                sliderBlue.valueProperty().addListener(new ChangeListener<Number>() {
                    @Override
                    public void changed(ObservableValue<? extends Number> observable, Number oldv, Number newv) {
                        blau = (double) newv;
                        repaintt(activenode);
                    }
                });
                sliderBlue.valueChangingProperty().addListener(new ChangeListener<Boolean>() {
                    @Override
                    public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue,
                            Boolean newValue) {
                        setOldCol(activenode, sliderRed.getValue(), sliderGreen.getValue(), sliderBlue.getValue());
                    }
                });
                // ____________________________________________________________________________
                buttonSliderCur.setOnAction(event -> {
                    resetPos(activenode, 0);
                });
                buttonColorCur.setOnAction(event -> {
                    resetCol(activenode, 0);
                });
                buttonSliderAll.setOnAction(event -> {
                    resetPos(activenode, 1);
                });
                buttonColorAll.setOnAction(event -> {
                    resetCol(activenode, 1);
                });
                // ____________________________________________________________________________
                //
                // ____________________________________________________________________________
                if (activenode != null) {
                    activenode.setOnMousePressed(eventP -> {
                        activenode.setOnMouseDragged(eventD -> {
                            sliderXPos.setValue(sliderXPos.getValue() + eventD.getX());
                            sliderYPos.setValue(sliderYPos.getValue() + eventD.getY());
                        });
                    });
                    activenode.setOnMouseReleased(eventO -> {
                        setOldSliderPos(activenode, sliderXPos.getValue(), sliderYPos.getValue(),
                                sliderZPos.getValue());
                    });
                }

            }
        });
        // ____________________________________________________________________________
        // Try to create the Window.
        // ____________________________________________________________________________

        try {
            primaryStage.setScene(scene);
            primaryStage.show();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

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

Auf jeden Fall schonmal danke fürs Durchlesen.
Ich hoffe, ihr könnt mir helfen.

 

[Tenecius]

Habe mal den entsprechenden Code rausgesucht bzgl dem getHeight() Problem. Vielleicht kann man das dann besser sehen.

    private BorderPane root = new BorderPane();
    private VBox vBoxPosition = new VBox();
    private VBox vBoxColor = new VBox();
    private HBox hBoxNode = new HBox();
    private HBox hBoxBottom = new HBox();
    private Pane paneCenter = new Pane();
// _________________________
// ...
// _________________________
        double paneCenterWidth = paneCenter.getLayoutBounds().getWidth();
        double paneCenterHeight = paneCenter.getLayoutBounds().getHeight();
        sliderXPos = new Slider(0, paneCenterWidth - 2 * radius, 0);
        sliderYPos = new Slider(0, paneCenterHeight - 3 * radius, 0);
// _________________________
// ...
// _________________________
        screen = Screen.getPrimary().getVisualBounds();
        Scene scene = new Scene(root, screen.getWidth() / 2, screen.getHeight() / 2);
// _________________________
// ...
// _________________________

        vBoxPosition.setPrefWidth(200);
        vBoxColor.setPrefWidth(200);
        hBoxNode.setPrefHeight(30);
        hBoxBottom.setPrefHeight(30);
        paneCenter.getChildren().addAll(circle, rect, texti);
        root.setCenter(paneCenter);
        root.setLeft(vBoxPosition);
        root.setRight(vBoxColor);
        root.setTop(hBoxNode);
        root.setBottom(hBoxBottom);
        root.layout();
// _________________________
// ...
// _________________________
        try {
            primaryStage.setScene(scene);
            primaryStage.show();
        } catch (Exception e) {
            e.printStackTrace();
        }

 

[dzim]

Als erstes: Respekt, dass du so etwas komplexes als blutiger Anfänger hinbekommen hast!

Zum Problem: Es mit absoluten Werten zu beschreiben birgt natürlich immer das Problem, dass es dann davon abhängt, welchen Wert es zum Start des Programms/UI-Teils es gab.
Ich hab es kurz ausprobiert: Beim Verkleinern wird dein Slider nicht kleiner und verschwindet teilweise.
Die einfachste Lösung wäre, folgende Zeile anzupassen:

// sliderNode.setPrefWidth(hBoxNode.getLayoutBounds().getWidth() * 0.75);
sliderNode.prefWidthProperty().bind(hBoxNode.widthProperty().multiply(.75));

Was passiert hier? Nun, JavaFX unterstützt von Haus aus Databinding. Ein Feature, dass die in speziellen Situationen den Hintern retten kann. In diesem Fall also sagst du: "Binde die Breite des Sliders and die Breite der HBox multipliziert mit .75". Bei 100 Pixeln also ist der Slider 75px breit, bei 10 nur noch 7.5 (bzw. 8, da JavaFX dann zum nächsten Pixel snapt). Verbietet das Layout, dass die HBox nun leiner als X werden kann, wirkt sich dass auch auf den Slider aus.

Hinweis: Konstruiiere mal ein UI mit dem SceneBuilder. Du musst kein XML-Fan werden, aber das XML bildet 1:1 die Code-Representation ab. Du siehst dann, wie man im Code - so wie du es ja gemacht hast - die Komponenten besser verlinken kann.

Dein Problem ist im Code z.B.: Die VBox, die den Slider enthält hat keine Breite - eigentlich also zwingst du den Slider auf ein anderes Layout (indem du es an den Container der VBox, nämlich die HBox), als der eigentliche Parent des Sliders (die VBox) es vorsieht.
Statt dem Code oben kannst du nun auch einfach folgendes machen (was die saubere Lösung wäre):

// sliderNode.setPrefWidth(hBoxNode.getLayoutBounds().getWidth() * 0.75);
// sliderNode.prefWidthProperty().bind(hBoxNode.widthProperty().multiply(.75));
sliderNode.maxWidth(Double.MAX_VALUE);

// ........

HBox.setHgrow(panelNode, Priority.ALWAYS);
HBox.setMargin(panelNode, new Insets(0.0, 75.0, 0.0, 75.0));
hBoxNode.getChildren().addAll(panelNode);

Damit weisst du dem Slider zu, dass er so breit werden kann, wie er nur will (würdest du noch minWidth setzen, kannst du ebenfalls Werte erzwingen, die vielleicht sonst das Layout nicht vorsieht).
Der VBox wird über die statische Methode der HBox ein Hint angefügt, der der HBox "hBoxNode" sagt, dass das Panel immer den maximal verfügbaren Platz bekommt (bei nur einem Child in der HBox, wie hier, ist es also die volle Breite der HBox).
Ebenfalls setzt du an der VBox den Hint, dass es trotzdem einen fixen Abstand zum Parent haben möchte. Hier jeweils 75px.

Die obere Variante ist gut, wenn du unbedingt einen prozentualen Wert möchtest - nicht bestimmte fixe Pixel. Dennoch würde ich auch da lieber an den direkten Parent binden, als an irgendeinen Parent vom Parent. Also müsste man dennoch den Hint HBox.setHgrow(panelNode, Priority.ALWAYS); setzen.

 

[Tenecius]

Vielen Dank für diese ausführliche Erklärung.

Ich sehe gerade, dass ich wohl den Fokus oben zu sehr auf dem Slider an sich hatte. Mein eigentliches Hauptproblem ist, dass der an den Slider übergebene Wert nicht stimmt.
Also die Größe des Centers von dem BorderPane wird falsch abgeliefert, sodass ich das Objekt über die Grenze des Centers hinaus bewegen kann. (Bei Fullscreen verschwindet das Objekt sogar aus dem Fenster)
Testweise habe ich mir "paneCenter.getLayoutBounds()" ausgeben lassen.
Ergebnis:
LayoutBonds:BoundingBox [minX:0.0, minY:0.0, minZ:0.0, width:320.0, height:352.0, depth:0.0, maxX:320.0, maxY:352.0, maxZ:0.0].
Wenn ich das Objekt jetzt den Wert der Höhe bewege, dann überquert es quasi die Grenze des Centers und ist zu weit im Bereich der hBoxBottom des BorderPanes. Der Wert der Breite stimmt, da bleibt das Objekt quasi an der Grenze zu der vBoxColor stehen.

Also ich komme nicht drauf, wieso der Wert der Höhe einen größeren Wert hat, als er tatsächlich sein sollte, zumindest visuell sollte der Wert kleiner sein.


Das von dir mit dem Slider habe ich direkt ausprobiert, das ist ja genial. Damit kann ich dann bei allen Komponenten nochmal genauer drüber schauen und sie anpassen, sodass dann alles sauberer ist und das Fenster nicht so komisch verzerrt und die Komponenten dennoch komplett sichtbar und verfügbar sind.
Das hilft mir echt weiter, dann muss ich das in Zukunft nicht so kompliziert machen. Bin anfangs schier verzweifelt, weil das Platzieren nicht so geklappt hat etc.
Mit dem Verlinken der einzelnen Komponenten werde ich mich dann auch nochmal genauer befassen.

Von Scenebuilder habe ich schon mal in einem Tutorial gelesen, dann lade ich mir das doch mal runter.
Wollte von klein auf anfangen und habe mir verschiedene Tutorials durchgelesen, die beinhalteten bloß leider wirklich nur das Grundzeug.
Bin jetzt mehrere Tage schon an dem Projekt dran. Die meiste Zeit geht "verloren", weil ich mir erstmal raussuchen muss, was ich alles machen kann und dann rausfinden muss, wie ich es umsetze.
Vor allem die ChangeListener waren ein Problem.
Kurze Frage: Wenn ich in der Start-Methode einen ChangeListener habe, ist dieser immer aktiv und ich kann diesen nicht mit einer if-Abfrage eingrenzen? Habe das versucht, weil ich nicht wollte, dass die Objekte sich bewegen wenn der Node-Slider auf "None" steht. Inzwischen habe ich das Problem gelöst, indem ich alle ChangeListener innerhalb eines try{}- Blocks habe und die NullpointerException damit abgefangen wird. Die saubere Lösung ist dies aber auch nicht oder?^^

Edit: Tut mir leid, dass bei mir so viel zu lesen ist :/

 

[Tenecius]

Habe mir das Problem eben nebenbei nochmal kurz angeschaut und paar Sachen ausprobiert.

Ich weiß nicht genau wie es funktioniert, aber anscheinend hat das mit dem Slider/Pane in der hBoxNode zu tun. Der braucht ja einen gewissen Platz und ich kann die hBoxNode nicht mit setMaxHeight() kleiner machen, als der Slider Platz braucht. Also wenn ich der hBoxNode eine Höhe von 40px gebe, dann hat sie zwar im Programm die Information nur 40px hoch zu sein, aber visuell ist sie größer und hat 50px Höhe.
Demnach rechnet das Programm beim Fensteraufbau mit den 40px und "paneCenter.getLayoutBounds()" spuckt mir die danach berechnete Größe aus, also Höhe=352.0px, obwohl es visuell nur 342.0px sind.

"Gelöst" habe ich jetzt also das Problem, indem ich der hBoxNode mit setPrefHeight() eine Höhe von 50px verpasst habe und die hBoxBottom hat eine Höhe von 40px. Damit rechnet das Programm mit den Werten, die zumindest visuell richtig sind.
Klappt glücklicherweise auch bei jeder Fenstergröße. Auch wenn ich jetzt natürlich nicht genau weiß wie ich es hätte besser lösen können... Also falls doch noch jemand einen Einfall hat, gerne her damit
Ansonsten ist es das erstmal gewesen.

PS: Danke dzim, mit dem SceneBuilder ist das ja ziemlich einfach etwas zu konstruieren und direkt zu sehen, was man alles machen kann.

 

[dzim]

Also ich hab natürlich nur den Slider betrachtet, weil das für mich das einfachste war. Dein Code ist schon etwas zu gross und komplex - so viel Zeit wollte ich mir da nicht nehmen.

Ich würde dir noch raten, das UI in logische Komponenten aufzuteilen (egal ob FXML über SceneBuilder oder rein im Code in eigenen Klassen) und dann in einem Root-Layout alles zu verbinden. Top-, Center-, Left-, Right- und Bottom-Nodes bieten sich an, separiert zu werden.
Dann ist der Code übersichtlicher und die Fehlersuche etwas einfacher.

Die Grössenunterschiede (das was du willst und das, was du bekommst) erklären sich wahrscheinlich eben anhand der min-, max- und pref[Height|Width]. Sagst du dem Container pref wäre 40 und das Child braucht aber mindestens 50, dann wird auch der Container 50 bekommen. Es spielen hier auch Faktoren wie Border, Margin, Padding etc. eine Rolle. Auch mir - als doch recht versierten JavaFX-Nutzer - passieren hier ab und an solche Dinge, die mich dann ein wenig an den Rand des Wahnsinns bringen kann. Aber die "Gefahr" besteht bei so ziemlich jeden UI-Framework, speziell wenn du Pixel-Perfekt arbeiten willst/musst.

 

[Tenecius]

Verständlich
Ja, ist noch etwas unstrukturiert. Ich habe versucht etwas Struktur zu behalten, indem ich die Panes, Labels etc. nacheinander abgearbeitet habe, aber du hast Recht. Da muss ich in Zukunft besser drauf achten und das Ganze umstrukturieren. (Dein Vorschlag klingt ziemlich gut
Im Oktober gehts nächste Semester los und damit auch der Kurs zu JavaFX. Wahrscheinlich lerne ich da dann auch noch einige Kniffe bzgl. Programmaufbau und so.

 

[dzim]

Bin nicht der beste Erklärbär, aber wenn du Fragen hast: Dann immer her damit!

 

[Tenecius]

Okay, dann hätte ich doch tatsächlich noch eine letzte Sache
Hab mich jetzt mal dran gesetzt die Komponenten aufzuteilen und frage mich wie weit ich aufteilen sollte und wie das mit dem Controller aussieht.

Also dass man das BorderPane in Top-, Center-Nodes etc aufteilt klingt logisch. Jetzt müsste ich, doch auch alles andere in eigenen Klassen anlegen.(OOP)
Also habe ich dann zB. :

• Main: vereint Top,Center,Left... zu einem Fenster
• Controller: Steuerung der Komponenten, also zB changelistener auf slider -> bewege circle
• Left,Top,Center...: vereint die jeweiligen "Klein-Komponenten" in einer VBox/HBox oder...
• Slider: Anlegen der Slider(Werte etc)
• Button: Anlegen der Button
• Circle: Anlegen eines Circle

Jetzt habe ich bloß das Problem, dass ich in dem Controller den Changelistener nicht hinbekomme.
Ich habe in LEFT den Slider eingebaut und in CENTER den Kreis. In der MAIN habe ich beides ins BorderLayout eingefügt und von der Main aus kann ich auch darauf zugreifen. Ich habe in der MAIN also den Listener mit:

// Main.java:
//........
        Left lefti = new Left();
        lefti.createUI(pane1);
        Center centri = new Center();
        centri.createUI(pane5);

        leftside.slider.getX().valueProperty().addListener(new ChangeListener<Number>() {
            @Override
            public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
                center.circle.setX((double)newValue);
            }
        });
//........

In Left und Center habe ich jeweils Slider, bzw Circle hinzugefügt über die gleiche Methode.

// Left.java:
    public final Sliders slidd = new Sliders();
    public void createUI(Pane parent) {
            VBox pne = new VBox();
            pne.setStyle("-fx-spacing: 5; -fx-padding: 5;");
            butn = new Buttons();
            butn.createButton(pne);
            slidd.createSlider(pne);
            parent.getChildren().addAll(pne);
        }

// Center.java:__________________________
    public final Objects crcle= new Objects();;
    public Center() {
        Pane pne = new Pane();
        crcle.createObject(pne);
    }
    public void createUI(Pane parent) {
        parent.getChildren().addAll(pne);
    }
}

Allerdings weiß ich nicht, wie ich in Controller darauf zugreife, damit sich der Kreis auch tatsächlich im Fenster bewegt und nicht nur der Wert geändert wird. Der Kreis wird ja quasi in der Main-Klasse erstellt. Wie verbinde ich dann die Main und meinen Controller miteinander?

Oder wie sollte ich das Programm besser aufbauen? Hast du da noch einen letzten Tipp?^^
Danach war es das eigentlich erst einmal. Ich will noch Transfer, Rotation, Skalierung über Matrizen regeln und ein paar weitere Spielereien ausprobieren, die sollten aber hoffentlich eher weniger ein Problem werden.

Finde leider nichts passendes, was mir bei meinem Problem hilft. Wird ja fast nur mit FXML gearbeitet, darauf wollte ich aber vorerst verzichten. Eventuell muss ich mir auch morgen nur mal die Zeit nehmen tiefer zu graben. (Mir ist gerade eingefallen, dass ich ja allgemein mal nach fertigen Programmvorlagen suchen könnte. Vielleicht finde ich ein Programm, bei dem ich mir etwas abschauen kann. Wollte aber trotzdem mal die Frage posten, bevor ich doch nichts dazu finde und es noch viel länger dauern würde^^)