Node Container that does not resize with Window Resize Event

Question

Hello,
I'm not new to Java but I am new to JavaFX.
I plan to have a container/Canvas with multiple shapes (Lines, Text, Rectangle etc) in it. This Container can be X times in the Szene with different Text Shapes. I need to Zoom and Pan (maybe rotation) the whole Szene and the Containers/Canvas.
So I was playing around with that but I have two issues.
1) all Canvas classes that I found (like Pane for example) do resize with the main window resize event. The content of the canvas isn't centered any more.
2) I added a couple of Rectangles to the canvas and both the rectangles and the canvas have a mouse listener which will rotate the item/canvas. Problem is, that even if I click the rectangle also the underlaying canvas is rotated...I think I need some kind of Z-Info to find out what was clicked.
Here is the little example program, it makes no produktiv sense but it demonstrates my problem.
Does anybody has a tip what canvas class would fit and does not resize with the main window and how to figure out what was clicked?
public class Test extends Application
     Scene mainScene;
     Group root;
     public static void main(String[] args)
        launch(args);
    @Override
    public void init()
        root = new Group();
        int x = 0;
        int y = -100;
        for(int i = 0; i < 5; i++)
             x = 0;
             y = y + 100;
             for (int j = 0; j < 5; j++)
                  final Rectangle rect = new Rectangle(x, y, 30 , 30);
                   final RotateTransition rotateTransition = RotateTransitionBuilder.create()
                         .node(rect)
                         .duration(Duration.seconds(4))
                         .fromAngle(0)
                         .toAngle(720)
                         .cycleCount(Timeline.INDEFINITE)
                         .autoReverse(true)
                         .build();
                 rect.setOnMouseClicked(new EventHandler<MouseEvent>()
                      public void handle(MouseEvent me)
                           if(rotateTransition.getStatus().equals(Animation.Status.RUNNING))
                                rotateTransition.setToAngle(0);
                                rotateTransition.stop();
                                rect.setFill(Color.BLACK);
                                rect.setScaleX(1.0);
                                rect.setScaleY(1.0);
                           else
                                rect.setFill(Color.AQUAMARINE);
                                rect.setScaleX(2.0);
                                rect.setScaleY(2.0);
                                rotateTransition.play();
                  root.getChildren().add(rect);
                  x = x + 100;
    public void start(Stage primaryStage)
         final Pane pane = new Pane();
         pane.setStyle("-fx-background-color: #CCFF99");
         pane.setOnScroll(new EventHandler<ScrollEvent>()
               @Override
               public void handle(ScrollEvent se)
                    if(se.getDeltaY() > 0)
                         pane.setScaleX(pane.getScaleX() + 0.01);
                         pane.setScaleY(pane.getScaleY() + 0.01);
                    else
                         pane.setScaleX(pane.getScaleX() - 0.01);
                         pane.setScaleY(pane.getScaleY() - 0.01);
         pane.getChildren().addAll(root);
         pane.setOnMouseClicked(new EventHandler<MouseEvent>(){
               @Override
               public void handle(MouseEvent event)
                    System.out.println(event.getButton());
                    if(event.getButton().equals(MouseButton.PRIMARY))
                         System.out.println("primary button");
                         final RotateTransition rotateTransition2 = RotateTransitionBuilder.create()
                              .node(pane)
                              .duration(Duration.seconds(10))
                              .fromAngle(0)
                              .toAngle(360)
                              .cycleCount(Timeline.INDEFINITE)
                              .autoReverse(false)
                              .build();
                         rotateTransition2.play();
         mainScene = new Scene(pane, 400, 400);
         primaryStage.setScene(mainScene);
        primaryStage.show();
}Edited by: 953596 on 19.08.2012 12:03

Answer 1

To answer my own Question, it depends how you add childs.
It seems that the "master Container", the one added to the Scene will allways resize with the window. To avoid that you can add a container to the "master Container" and tell it to be
pane.setPrefSize(<child>.getWidth(), <child>.getHeight());
pane.setMaxSize(<child>.getWidth(), <child>.getHeight());
root.getChildren().add(pane);and it will stay the size even if the window is resized.
Here is the modified code. Zooming and panning is working, zomming to window size is not right now. I'll work on that.
import javafx.animation.Animation;
import javafx.animation.ParallelTransition;
import javafx.animation.ParallelTransitionBuilder;
import javafx.animation.RotateTransition;
import javafx.animation.RotateTransitionBuilder;
import javafx.animation.ScaleTransitionBuilder;
import javafx.animation.Timeline;
import javafx.animation.TranslateTransitionBuilder;
import javafx.application.Application;
import javafx.event.EventHandler;
import javafx.geometry.Point2D;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.input.MouseButton;
import javafx.scene.input.MouseEvent;
import javafx.scene.input.ScrollEvent;
import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage;
import javafx.util.Duration;
public class Test extends Application
     Stage primStage;
    Scene mainScene;
     Group root;
     Pane masterPane;
     Point2D dragAnchor;
     double initX;
    double initY;
     public static void main(String[] args)
        launch(args);
    @Override
    public void init()
        root = new Group();
        final Pane pane = new Pane();
        pane.setStyle("-fx-background-color: #CCFF99");
        pane.setOnScroll(new EventHandler<ScrollEvent>()
            @Override
            public void handle(ScrollEvent se)
                if(se.getDeltaY() > 0)
                    pane.setScaleX(pane.getScaleX() + pane.getScaleX()/15);
                    pane.setScaleY(pane.getScaleY() + pane.getScaleY()/15);
                    System.out.println(pane.getScaleX() + " " + pane.getScaleY());
                else
                    pane.setScaleX(pane.getScaleX() - pane.getScaleX()/15);
                    pane.setScaleY(pane.getScaleY() - pane.getScaleY()/15);
                    System.out.println(pane.getScaleX() + " " + pane.getScaleY());
        pane.setOnMousePressed(new EventHandler<MouseEvent>()
            public void handle(MouseEvent me)
                initX = pane.getTranslateX();
                initY = pane.getTranslateY();
                dragAnchor = new Point2D(me.getSceneX(), me.getSceneY());
        pane.setOnMouseDragged(new EventHandler<MouseEvent>()
            public void handle(MouseEvent me) {
                double dragX = me.getSceneX() - dragAnchor.getX();
                double dragY = me.getSceneY() - dragAnchor.getY();
                //calculate new position of the pane
                double newXPosition = initX + dragX;
                double newYPosition = initY + dragY;
                //if new position do not exceeds borders of the rectangle, translate to this position
                pane.setTranslateX(newXPosition);
                pane.setTranslateY(newYPosition);
        int x = 0;
        int y = -100;
        for(int i = 0; i < 5; i++)
             x = 0;
             y = y + 100;
             for (int j = 0; j < 5; j++)
                  final Rectangle rect = new Rectangle(x, y, 30 , 30);
                   final RotateTransition rotateTransition = RotateTransitionBuilder.create()
                         .node(rect)
                         .duration(Duration.seconds(4))
                         .fromAngle(0)
                         .toAngle(720)
                         .cycleCount(Timeline.INDEFINITE)
                         .autoReverse(true)
                         .build();
                 rect.setOnMouseClicked(new EventHandler<MouseEvent>()
                      public void handle(MouseEvent me)
                           if(rotateTransition.getStatus().equals(Animation.Status.RUNNING))
                                rotateTransition.setToAngle(0);
                                rotateTransition.stop();
                                rect.setFill(Color.BLACK);
                                rect.setScaleX(1.0);
                                rect.setScaleY(1.0);
                           else
                                rect.setFill(Color.AQUAMARINE);
                                rect.setScaleX(2.0);
                                rect.setScaleY(2.0);
                                rotateTransition.play();
                  pane.getChildren().add(rect);
                  x = x + 100;
        pane.autosize();
        pane.setPrefSize(pane.getWidth(), pane.getHeight());
        pane.setMaxSize(pane.getWidth(), pane.getHeight());
        root.getChildren().add(pane);
        masterPane = new Pane();
        masterPane.getChildren().add(root);
        masterPane.setStyle("-fx-background-color: #AABBCC");
        masterPane.setOnMousePressed(new EventHandler<MouseEvent>()
           public void handle(MouseEvent me)
               System.out.println(me.getButton());
               if((MouseButton.MIDDLE).equals(me.getButton()))
                   double screenWidth  = masterPane.getWidth();
                   double screenHeight = masterPane.getHeight();
                   System.out.println("screenWidth  " + screenWidth);
                   System.out.println("screenHeight " + screenHeight);
                   System.out.println(screenHeight);
                   double scaleXIs     = pane.getScaleX();
                   double scaleYIs     = pane.getScaleY();
                   double paneWidth    = pane.getWidth()  * scaleXIs;
                   double paneHeight   = pane.getHeight() * scaleYIs;
                   double screenCalc    = screenWidth > screenHeight ? screenHeight : screenWidth;
                   double scaleOperator = screenCalc  / paneWidth;
                   double moveToX       = (screenWidth/2)  - (paneWidth/2);
                   double moveToY       = (screenHeight/2) - (paneHeight/2);
                   System.out.println("movetoX :" + moveToX);
                   System.out.println("movetoY :" + moveToY);
                   //double scaleYTo = screenHeight / paneHeight;
                   ParallelTransition parallelTransition = ParallelTransitionBuilder.create()
                           .node(pane)
                           .children(
                               TranslateTransitionBuilder.create()
                                   .duration(Duration.seconds(2))
                                   .toX(moveToX)
                                   .toY(moveToY)
                                   .build()
                               ScaleTransitionBuilder.create()
                                   .duration(Duration.seconds(2))
                                   .toX(scaleOperator)
                                   .toY(scaleOperator)
                                   .build()
                  .build();
                   parallelTransition.play();
    public void start(Stage primaryStage)
         primStage = primaryStage;
        mainScene = new Scene(masterPane, 430, 430);
         primaryStage.setScene(mainScene);
        primaryStage.show();
}