Java Examples for javafx.scene.SubScene

public Scene initScene(City city, PerspectiveCamera camera, String cityName) {
    Group root = new Group();
    buildCamera(root, camera);
    root.getTransforms().addAll(rxBox, ryBox, rzBox);
    subScene = new SubScene(root, SCENE_WIDTH, SCENE_HEIGHT, true, SceneAntialiasing.BALANCED);
    subScene.setCamera(camera);
    root.getChildren().add(city);
    // 2D
    BorderPane pane = new BorderPane();
    Pane toolBar = null;
    try {
        toolBar = new CityToolBarService().load(cityName);
    } catch (IOException e) {
        e.printStackTrace();
    }
    pane.setBottom(subScene);
    pane.setTop(toolBar);
    Scene scene = new Scene(pane, SCENE_WIDTH, SCENE_HEIGHT);
    subScene.heightProperty().bind(scene.heightProperty());
    subScene.widthProperty().bind(scene.widthProperty());
    return scene;
}

public Parent createContent() {
    BorderPane p = new BorderPane();
    HBox btBox = new HBox(50, leftBt, lookLeftBt, forwardBt, upBt, downBt, backBt, lookRightBt, rightBt);
    btBox.alignmentProperty().set(Pos.CENTER);
    p.setBottom(btBox);
    setUpButtons();
    PerspectiveCamera camera = new PerspectiveCamera(true);
    camera.getTransforms().add(cameraTranslate);
    camera.getTransforms().add(cameraRotate);
    camera.setFieldOfView(50);
    camera.setFarClip(10000);
    camera.setNearClip(1);
    p.setDepthTest(DepthTest.ENABLE);
    BorderPane cirmLiveUI = cirmLive.createSceneContent();
    cirmLiveUI.setCache(true);
    cirmLiveUI.setCacheShape(true);
    cirmLiveUI.setCacheHint(CacheHint.QUALITY);
    //cirmLiveUI.setSsetAlignment(camera, Pos.CENTER);
    //cirmLiveUI.setTranslateZ(500);
    //TODO root.getChildren().addAll(c, c2, c3);
    SubScene subScene = new SubScene(cirmLiveUI, 1600, 900, true, SceneAntialiasing.BALANCED);
    subScene.setFill(Color.CORAL);
    subScene.setCamera(camera);
    p.setCenter(subScene);
    return p;
}

@PostConstruct
public void createUI() {
    Group sceneRoot = new Group();
    SubScene scene = new SubScene(sceneRoot, sceneWidth, sceneHeight);
    scene.setFill(Color.GREEN);
    camera = new PerspectiveCamera(true);
    camera.setNearClip(0.1);
    camera.setFarClip(10000.0);
    camera.setTranslateZ(-1000);
    scene.setCamera(camera);
    Rotate xRotate = new Rotate(0, 0, 0, 0, Rotate.X_AXIS);
    Rotate yRotate = new Rotate(0, 0, 0, 0, Rotate.Y_AXIS);
    Rotate zRotate = new Rotate(0, 0, 0, 0, Rotate.Z_AXIS);
    camera.getTransforms().addAll(xRotate, yRotate, zRotate);
    scene.addEventHandler(MouseEvent.ANY,  event -> {
        double mouseXnew = event.getSceneX();
        double mouseYnew = event.getSceneY();
        if (event.getEventType() == MouseEvent.MOUSE_DRAGGED) {
            double pitchRotate = xRotate.getAngle() + (mouseYnew - mouseYold) / rotateModifier;
            pitchRotate = pitchRotate > cameraYLimit ? cameraYLimit : pitchRotate;
            pitchRotate = pitchRotate < -cameraYLimit ? -cameraYLimit : pitchRotate;
            xRotate.setAngle(pitchRotate);
            double yawRotate = yRotate.getAngle() - (mouseXnew - mouseXold) / rotateModifier;
            yRotate.setAngle(yawRotate);
        }
        mouseXold = mouseXnew;
        mouseYold = mouseYnew;
    });
    final Cylinder cylinder = new Cylinder(50, 100);
    cylinder.setRotationAxis(Rotate.X_AXIS);
    cylinder.setRotate(45);
    cylinder.setTranslateZ(-200);
    final PhongMaterial greenMaterial = new PhongMaterial();
    greenMaterial.setDiffuseColor(Color.DARKGREEN);
    greenMaterial.setSpecularColor(Color.GREEN);
    final Box cube = new Box(50, 50, 50);
    cube.setMaterial(greenMaterial);
    final PhongMaterial redMaterial = new PhongMaterial();
    redMaterial.setDiffuseColor(Color.DARKRED);
    redMaterial.setSpecularColor(Color.RED);
    final Sphere sphere = new Sphere(50);
    sphere.setMaterial(redMaterial);
    cube.setRotationAxis(Rotate.Y_AXIS);
    cube.setRotate(45);
    cube.setTranslateX(-150);
    cube.setTranslateY(-150);
    cube.setTranslateZ(-150);
    sphere.setTranslateX(150);
    sphere.setTranslateY(150);
    sphere.setTranslateZ(-150);
    scene.addEventHandler(MouseEvent.ANY,  event -> {
        if (event.getEventType() == MouseEvent.MOUSE_PRESSED && event.isAltDown()) {
            PickResult pickResult = event.getPickResult();
            if (pickResult != null) {
                Node node = pickResult.getIntersectedNode();
                if (node != null) {
                    node.setVisible(false);
                }
            }
        }
    });
    final PhongMaterial blueMetal = new PhongMaterial();
    blueMetal.setDiffuseColor(Color.DARKBLUE);
    blueMetal.setSpecularColor(Color.BLUE);
    cylinder.setMaterial(blueMetal);
    scene.setOnKeyPressed( event -> {
        double change = cameraQuantity;
        KeyCode keycode = event.getCode();
        if (keycode == KeyCode.W) {
            camera.setTranslateZ(camera.getTranslateZ() + change);
        }
        if (keycode == KeyCode.S) {
            camera.setTranslateZ(camera.getTranslateZ() - change);
        }
        if (keycode == KeyCode.A) {
            camera.setTranslateX(camera.getTranslateX() - change);
        }
        if (keycode == KeyCode.D) {
            camera.setTranslateX(camera.getTranslateX() + change);
        }
        if (keycode == KeyCode.SPACE) {
            sphere.setVisible(true);
            cube.setVisible(true);
            cylinder.setVisible(true);
        }
    });
    sceneRoot.getChildren().addAll(cylinder, cube, sphere);
    tab.getChildren().add(scene);
    this.log.info("run on start of Demo4Component ");
}

private void buildSubScene() {
    subScene = new SubScene(root, sceneWidth, sceneHeight, true, SceneAntialiasing.BALANCED);
    //Color.web("#0d0d0d"));        
    subScene.setFill(Color.TRANSPARENT);
    subScene.setCamera(camera);
    subScene.setFocusTraversable(false);
    //First person shooter keyboard movement 
    subScene.setOnKeyPressed( event -> {
        double change = 10.0;
        if (event.isShiftDown()) {
            change = 50.0;
        }
        KeyCode keycode = event.getCode();
        if (keycode == KeyCode.W) {
            camera.setTranslateZ(camera.getTranslateZ() + change);
        }
        if (keycode == KeyCode.S) {
            camera.setTranslateZ(camera.getTranslateZ() - change);
        }
        if (keycode == KeyCode.A) {
            camera.setTranslateX(camera.getTranslateX() - change);
        }
        if (keycode == KeyCode.D) {
            camera.setTranslateX(camera.getTranslateX() + change);
        }
    });
    subScene.setOnMousePressed((MouseEvent me) -> {
        mousePosX = me.getSceneX();
        mousePosY = me.getSceneY();
        mouseOldX = me.getSceneX();
        mouseOldY = me.getSceneY();
        PickResult pr = me.getPickResult();
        if (pr != null && pr.getIntersectedNode() != null && pr.getIntersectedNode() instanceof Sphere && pr.getIntersectedNode().getId().equals("knot")) {
            distance = pr.getIntersectedDistance();
            sphere = (Sphere) pr.getIntersectedNode();
            isPicking.set(true);
            vecIni = unProjectDirection(mousePosX, mousePosY, subScene.getWidth(), subScene.getHeight());
        }
    });
    subScene.setOnMouseDragged((MouseEvent me) -> {
        mouseOldX = mousePosX;
        mouseOldY = mousePosY;
        mousePosX = me.getSceneX();
        mousePosY = me.getSceneY();
        mouseDeltaX = (mousePosX - mouseOldX);
        mouseDeltaY = (mousePosY - mouseOldY);
        if (isPicking.get()) {
            double modifier = (me.isControlDown() ? 0.01 : me.isAltDown() ? 1.0 : 0.1) * (30d / camera.getFieldOfView());
            modifier *= (30d / camera.getFieldOfView());
            vecPos = unProjectDirection(mousePosX, mousePosY, subScene.getWidth(), subScene.getHeight());
            Point3D p = new Point3D(distance * (vecPos.x - vecIni.x), distance * (vecPos.y - vecIni.y), distance * (vecPos.z - vecIni.z));
            sphere.getTransforms().add(new Translate(modifier * p.getX(), modifier * p.getY(), modifier * p.getZ()));
            vecIni = vecPos;
        } else {
            double modifier = 10.0;
            double modifierFactor = 0.1;
            if (me.isControlDown()) {
                modifier = 0.1;
            }
            if (me.isShiftDown()) {
                modifier = 50.0;
            }
            if (me.isPrimaryButtonDown()) {
                // +
                cameraTransform.ry.setAngle(((cameraTransform.ry.getAngle() + mouseDeltaX * modifierFactor * modifier * 2.0) % 360 + 540) % 360 - 180);
                // -
                cameraTransform.rx.setAngle(((cameraTransform.rx.getAngle() - mouseDeltaY * modifierFactor * modifier * 2.0) % 360 + 540) % 360 - 180);
            } else if (me.isSecondaryButtonDown()) {
                double z = camera.getTranslateZ();
                double newZ = z + mouseDeltaX * modifierFactor * modifier;
                camera.setTranslateZ(newZ);
            } else if (me.isMiddleButtonDown()) {
                // -
                cameraTransform.t.setX(cameraTransform.t.getX() + mouseDeltaX * modifierFactor * modifier * 0.3);
                // -
                cameraTransform.t.setY(cameraTransform.t.getY() + mouseDeltaY * modifierFactor * modifier * 0.3);
            }
        }
    });
    subScene.setOnMouseReleased((MouseEvent me) -> {
        if (isPicking.get()) {
            isPicking.set(false);
        }
    });
}

private void createSubscene() {
    subScene = new SubScene(root, 800, 600, true, SceneAntialiasing.BALANCED);
    camera = new PerspectiveCamera(true);
    cameraTransform.setTranslate(0, 0, 0);
    cameraTransform.getChildren().addAll(camera);
    camera.setNearClip(0.1);
    camera.setFarClip(100000.0);
    camera.setFieldOfView(35);
    camera.setTranslateZ(-cameraDistance);
    cameraTransform.ry.setAngle(-45.0);
    cameraTransform.rx.setAngle(-10.0);
    //add a Point Light for better viewing of the grid coordinate system
    PointLight light = new PointLight(Color.WHITE);
    cameraTransform.getChildren().add(light);
    light.setTranslateX(camera.getTranslateX());
    light.setTranslateY(camera.getTranslateY());
    light.setTranslateZ(camera.getTranslateZ());
    root.getChildren().add(cameraTransform);
    subScene.setCamera(camera);
    initFirstPersonControls(subScene);
    skyBox = new Skybox(new Image("http://www.zfight.com/misc/images/textures/envmaps/violentdays_large.jpg"), 100000, camera);
    //Make a bunch of semi random Torusesessses(toroids?) and stuff : from torustest
    Group torusGroup = new Group();
    for (int i = 0; i < 10; i++) {
        Random r = new Random();
        //A lot of magic numbers in here that just artificially constrain the math
        float randomRadius = (float) ((r.nextFloat() * 300) + 50);
        float randomTubeRadius = (float) ((r.nextFloat() * 100) + 1);
        int randomTubeDivisions = (int) ((r.nextFloat() * 64) + 1);
        int randomRadiusDivisions = (int) ((r.nextFloat() * 64) + 1);
        Color randomColor = new Color(r.nextDouble(), r.nextDouble(), r.nextDouble(), r.nextDouble());
        boolean ambientRandom = r.nextBoolean();
        boolean fillRandom = r.nextBoolean();
        if (i == 0) {
            torusGroup.getChildren().add(bill);
        }
        TorusMesh torus = new TorusMesh(randomTubeDivisions, randomRadiusDivisions, randomRadius, randomTubeRadius);
        double translationX = Math.random() * 1024 * 1.95;
        if (Math.random() >= 0.5) {
            translationX *= -1;
        }
        double translationY = Math.random() * 1024 * 1.95;
        if (Math.random() >= 0.5) {
            translationY *= -1;
        }
        double translationZ = Math.random() * 1024 * 1.95;
        if (Math.random() >= 0.5) {
            translationZ *= -1;
        }
        Translate translate = new Translate(translationX, translationY, translationZ);
        Rotate rotateX = new Rotate(Math.random() * 360, Rotate.X_AXIS);
        Rotate rotateY = new Rotate(Math.random() * 360, Rotate.Y_AXIS);
        Rotate rotateZ = new Rotate(Math.random() * 360, Rotate.Z_AXIS);
        torus.getTransforms().addAll(translate, rotateX, rotateY, rotateZ);
        //torus.getTransforms().add(translate);
        torusGroup.getChildren().add(torus);
    }
    root.getChildren().addAll(skyBox, torusGroup);
    rootPane.getChildren().add(subScene);
    //Enable subScene resizing
    subScene.widthProperty().bind(rootPane.widthProperty());
    subScene.heightProperty().bind(rootPane.heightProperty());
    subScene.setFocusTraversable(true);
}

/**
     * Initializes the controller class.
     *
     * @param url
     * @param rb
     */
@Override
public void initialize(URL url, ResourceBundle rb) {
    //
    codeArea.textProperty().addListener(( ov,  oldText,  newText) -> {
        Matcher matcher = KEYWORD_PATTERN.matcher(newText);
        int lastKwEnd = 0;
        StyleSpansBuilder<Collection<String>> spansBuilder = new StyleSpansBuilder<>();
        while (matcher.find()) {
            spansBuilder.add(Collections.emptyList(), matcher.start() - lastKwEnd);
            spansBuilder.add(Collections.singleton("keyword"), matcher.end() - matcher.start());
            lastKwEnd = matcher.end();
        }
        spansBuilder.add(Collections.emptyList(), newText.length() - lastKwEnd);
        codeArea.setStyleSpans(0, spansBuilder.create());
    });
    EventStream<Change<String>> textEvents = EventStreams.changesOf(codeArea.textProperty());
    textEvents.reduceSuccessions(( a,  b) -> b, Duration.ofMillis(500)).subscribe( code -> {
        if (autoCompile) {
            compile(code.getNewValue());
        }
    });
    codeArea.replaceText("CSG cube = new Cube(2).toCSG()\n" + "CSG sphere = new Sphere(1.25).toCSG()\n" + "\n" + "cube.difference(sphere)");
    editorContainer.setContent(codeArea);
    subScene = new SubScene(viewGroup, 100, 100, true, SceneAntialiasing.BALANCED);
    subScene.widthProperty().bind(viewContainer.widthProperty());
    subScene.heightProperty().bind(viewContainer.heightProperty());
    PerspectiveCamera subSceneCamera = new PerspectiveCamera(false);
    subScene.setCamera(subSceneCamera);
    viewContainer.getChildren().add(subScene);
}

@Override
public void start(Stage primaryStage) {
    listener = new LeapListener();
    controller = new Controller();
    controller.addListener(listener);
    AnchorPane pane = new AnchorPane();
    Scene scene = new Scene(pane, 800, 600, Color.BEIGE);
    final PerspectiveCamera camera = new PerspectiveCamera();
    camera.setFieldOfView(60);
    camera.getTransforms().addAll(cameraXRotate, cameraYRotate, cameraPosition);
    material = new PhongMaterial();
    material.setDiffuseColor(Color.GAINSBORO);
    material.setSpecularColor(Color.rgb(30, 30, 30));
    sphereMaterial = new PhongMaterial();
    sphereMaterial.setDiffuseColor(Color.GAINSBORO);
    sphereMaterial.setSpecularColor(Color.rgb(30, 30, 30));
    sphereMaterial.setSelfIlluminationMap(new Image(getClass().getResource("red.png").toExternalForm()));
    meshView = new Shape3D[3];
    meshView[0] = new MeshView(buildTriangleMesh(20, 20, 30, true));
    meshView[1] = new MeshView(buildTriangleMesh(20, 20, 30, false));
    for (int i = 0; i < 2; i++) {
        meshView[i].setMaterial(material);
        meshView[i].setTranslateX(300);
        meshView[i].setTranslateY(i == 0 ? -300 : 0);
        meshView[i].setTranslateZ(i == 0 ? 0 : -300);
        meshView[i].setDrawMode(DrawMode.LINE);
        meshView[i].setCullFace(CullFace.NONE);
    }
    meshView[2] = new Sphere(60);
    meshView[2].setMaterial(material);
    meshView[2].setDrawMode(DrawMode.FILL);
    meshView[2].setCullFace(CullFace.BACK);
    meshView[2].setTranslateX(160);
    meshView[2].setTranslateY(-60);
    meshView[2].setTranslateZ(-160);
    sphereBounds = meshView[2].localToScene(meshView[2].getBoundsInLocal());
    System.out.println("s0: " + meshView[2].getBoundsInLocal());
    System.out.println("s: " + sphereBounds);
    final Group parent = new Group(meshView);
    root.getChildren().addAll(parent);
    final PointLight pointLight = new PointLight(Color.ANTIQUEWHITE);
    pointLight.setTranslateX(0);
    pointLight.setTranslateY(-800);
    pointLight.setTranslateZ(-600);
    Cylinder axisX = new Cylinder(5, 700);
    axisX.setRotationAxis(Rotate.Z_AXIS);
    axisX.setRotate(90d);
    axisX.setTranslateX(250d);
    root.getChildren().add(axisX);
    Cylinder axisY = new Cylinder(5, 700);
    axisY.setTranslateY(-250d);
    root.getChildren().add(axisY);
    Cylinder axisZ = new Cylinder(5, 700);
    axisZ.setRotationAxis(Rotate.X_AXIS);
    axisZ.setRotate(90d);
    axisZ.setTranslateZ(-250d);
    root.getChildren().add(axisZ);
    root.getChildren().addAll(pointLight);
    Group root3D = new Group();
    root3D.getChildren().addAll(camera, root);
    SubScene subScene = new SubScene(root3D, 800, 600, true, SceneAntialiasing.BALANCED);
    subScene.setCamera(camera);
    pane.getChildren().addAll(subScene);
    final int minRoot = root.getChildren().size();
    final PhongMaterial materialFinger = new PhongMaterial();
    materialFinger.setDiffuseColor(Color.GOLDENROD);
    materialFinger.setSpecularColor(Color.rgb(50, 50, 50));
    final PhongMaterial materialArm = new PhongMaterial();
    materialArm.setDiffuseColor(Color.CORNSILK);
    materialArm.setSpecularColor(Color.rgb(30, 30, 30));
    listener.doneListProperty().addListener(( ov,  b,  b1) -> {
        if (b1) {
            // First, get a fresh copy of the bones, arms & joints collection
            List<Bone> bones = listener.getBones();
            List<Arm> arms = listener.getArms();
            List<Pair> joints = listener.getJoints();
            touch.set(false);
            Platform.runLater(() -> {
                // Now, on the JavaFX thread
                if (root.getChildren().size() > minRoot) {
                    // clean old bones
                    root.getChildren().remove(minRoot, root.getChildren().size() - 1);
                }
                // Iterate over the list adding the bones to the scene
                // If the collection changes there won't be any concurrent exception
                // as we are iterating over its copy.
                bones.stream().filter(( bone) -> (bone.isValid() && bone.length() > 0)).forEach(( bone) -> {
                    final Vector p = bone.center();
                    // create bone as a vertical cylinder and locate it at its center position
                    Cylinder c = new Cylinder(bone.width() / 2, bone.length());
                    c.setMaterial(materialFinger);
                    // translate and rotate the cylinder towards its direction
                    final Vector v = bone.direction();
                    Vector cross = (new Vector(v.getX(), -v.getY(), -v.getZ())).cross(new Vector(0, -1, 0));
                    double ang = (new Vector(v.getX(), -v.getY(), -v.getZ())).angleTo(new Vector(0, -1, 0));
                    c.getTransforms().addAll(new Translate(200 + p.getX(), -p.getY(), -p.getZ()), new Rotate(-Math.toDegrees(ang), 0, 0, 0, new Point3D(cross.getX(), -cross.getY(), cross.getZ())));
                    // add bone to scene
                    root.getChildren().add(c);
                    Sphere s = new Sphere(bone.width() / 2f * 1.2);
                    s.setMaterial(materialFinger);
                    s.getTransforms().addAll(new Translate(200 + p.getX(), -p.getY() + bone.length() / 2d, -p.getZ()), new Rotate(-Math.toDegrees(ang), 0, -bone.length() / 2d, 0, new Point3D(cross.getX(), -cross.getY(), cross.getZ())));
                    // add bone to scene
                    root.getChildren().add(s);
                    Sphere s2 = new Sphere(bone.width() / 2f * 1.2);
                    s2.setMaterial(materialFinger);
                    s2.getTransforms().addAll(new Translate(200 + p.getX(), -p.getY() - bone.length() / 2d, -p.getZ()), new Rotate(-Math.toDegrees(ang), 0, bone.length() / 2d, 0, new Point3D(cross.getX(), -cross.getY(), cross.getZ())));
                    // add bone to scene
                    root.getChildren().add(s2);
                    if (sphereBounds.intersects(s.localToScene(s.getBoundsInLocal())) || sphereBounds.intersects(s.localToScene(s2.getBoundsInLocal()))) {
                        touch.set(true);
                    }
                });
                if (touch.get()) {
                    meshView[2].setMaterial(sphereMaterial);
                } else if (((PhongMaterial) meshView[2].getMaterial()).getSelfIlluminationMap() != null) {
                    meshView[2].setMaterial(material);
                }
                arms.stream().filter( arm -> arm.isValid()).forEach( arm -> {
                    final Vector p = arm.center();
                    Cylinder c = new Cylinder(arm.width() / 2, arm.elbowPosition().minus(arm.wristPosition()).magnitude());
                    c.setMaterial(materialArm);
                    final Vector v = arm.direction();
                    Vector cross = (new Vector(v.getX(), -v.getY(), -v.getZ())).cross(new Vector(0, -1, 0));
                    double ang = (new Vector(v.getX(), -v.getY(), -v.getZ())).angleTo(new Vector(0, -1, 0));
                    c.getTransforms().addAll(new Translate(200 + p.getX(), -p.getY(), -p.getZ()), new Rotate(-Math.toDegrees(ang), 0, 0, 0, new Point3D(cross.getX(), -cross.getY(), cross.getZ())));
                    root.getChildren().add(c);
                });
                joints.stream().forEach( joint -> {
                    double length = joint.getV0().distanceTo(joint.getV1());
                    Cylinder c = new Cylinder(bones.get(0).width() / 4, length);
                    c.setMaterial(materialArm);
                    final Vector p = joint.getCenter();
                    final Vector v = joint.getDirection();
                    Vector cross = (new Vector(v.getX(), -v.getY(), -v.getZ())).cross(new Vector(0, -1, 0));
                    double ang = (new Vector(v.getX(), -v.getY(), -v.getZ())).angleTo(new Vector(0, -1, 0));
                    c.getTransforms().addAll(new Translate(200 + p.getX(), -p.getY(), -p.getZ()), new Rotate(-Math.toDegrees(ang), 0, 0, 0, new Point3D(cross.getX(), -cross.getY(), cross.getZ())));
                    root.getChildren().add(c);
                });
            });
        }
    });
    scene.addEventHandler(MouseEvent.ANY,  event -> {
        if (event.getEventType() == MouseEvent.MOUSE_PRESSED) {
            dragStartX = event.getSceneX();
            dragStartY = event.getSceneY();
            dragStartRotateX = cameraXRotate.getAngle();
            dragStartRotateY = cameraYRotate.getAngle();
        } else if (event.getEventType() == MouseEvent.MOUSE_DRAGGED) {
            double xDelta = event.getSceneX() - dragStartX;
            double yDelta = event.getSceneY() - dragStartY;
            cameraXRotate.setAngle(dragStartRotateX - (yDelta * 0.7));
            cameraYRotate.setAngle(dragStartRotateY + (xDelta * 0.7));
        }
    });
    primaryStage.setTitle("Skeletal Tracking with Leap Motion v2 and JavaFX 3D");
    primaryStage.setScene(scene);
    primaryStage.show();
}

public SubScene getSubScene() {
    return this.mainView;
}

/**
     * Sets the sub-scene to be displayed inside this container.
     * 
     * @param subScene the {@link SubScene} of this container
     */
public void setSubScene(final SubScene subScene) {
    this.subScene = subScene;
    getChildren().add(subScene);
}

public SubScene getSubScene() {
    return content.getSubScene();
}

/**
     * 建立新的{@link javafx.scene.SubScene}建構器。
     *
     * @return 新的{@link javafx.scene.SubSceneMaker}
     */
@SuppressWarnings({ "rawtypes", "unchecked" })
public static javafx.scene.SubSceneMaker<javafx.scene.SubScene, ?> subScene() {
    return new javafx.scene.SubSceneMaker();
}