@Override
public List<? extends Shape> getHandles(Translate translate, Scale scale, ReadOnlyObjectProperty<Color> colorProperty) {
   List<Shape> handles = new ArrayList<>();

   IntStream.range(0, getPoints().size() / 2).forEach(idx -> {
      Handle handle = new Handle(idx, getPoints());
      handles.add(handle);

      // Maintain constant handle size at different zoom level
      scale.addEventHandler(TransformChangedEvent.TRANSFORM_CHANGED, event -> {
         handle.setRadius(HANDLE_RADIUS / scale.getX());
      });
      handle.fillProperty().bind(colorProperty);
      handle.setRadius(HANDLE_RADIUS / scale.getX());
      handle.getTransforms().addAll(translate, scale);
   });

   return handles;
}
 

@Override
public List<? extends Shape> getHandles(Translate translate, Scale scale, ReadOnlyObjectProperty<Color> colorProperty) {
   // 4 corner resize handles
   List<Rectangle> handles = Arrays.asList(new Rectangle[]{
         createHandle(Location.NW, cursorNW),
         createHandle(Location.NE, cursorNE),
         createHandle(Location.SE, cursorSE),
         createHandle(Location.SW, cursorSW)});

   // Maintain constant handle size at different zoom level
   handles.forEach(handle -> {
      scale.addEventHandler(TransformChangedEvent.TRANSFORM_CHANGED, event -> {
         handle.setWidth(HANDLE_SIZE / scale.getX());
         handle.setHeight(HANDLE_SIZE / scale.getY());
      });
      handle.fillProperty().bind(colorProperty);
      handle.setWidth(HANDLE_SIZE / scale.getX());
      handle.setHeight(HANDLE_SIZE / scale.getY());
      handle.getTransforms().addAll(translate, scale);
   });
   return handles;
}
 

/**
 * Starts the rotation of the plot.
 */
public void handleAnimate() {
  if (!animationRunning) {
    yRotate.setAngle(rotateY.getAngle() + deltaAngle);
    plot.getTransforms().addAll(pivot, yRotate, new Translate(-250, 0, -250));
    rotateAnimationTimeline.play();
    animationRunning = true;
    logger.finest("ANIMATE button clicked.Starting animation.");
  } else {
    plot.getTransforms().remove(yRotate);
    rotateY.setAngle(rotateY.getAngle() + yRotate.getAngle());
    deltaAngle = yRotate.getAngle();
    rotateAnimationTimeline.stop();
    animationRunning = false;
    logger.finest("ANIMATE button clicked.Stopping animation.");
  }
}
 

@Override
public void attachArrow(SmartArrow arrow) {
    this.attachedArrow = arrow;
    
    /* attach arrow to line's endpoint */
    arrow.translateXProperty().bind(endXProperty());
    arrow.translateYProperty().bind(endYProperty());
    
    /* rotate arrow around itself based on this line's angle */
    Rotate rotation = new Rotate();
    rotation.pivotXProperty().bind(translateXProperty());
    rotation.pivotYProperty().bind(translateYProperty());
    rotation.angleProperty().bind( UtilitiesBindings.toDegrees( 
            UtilitiesBindings.atan2( endYProperty().subtract(startYProperty()), 
            endXProperty().subtract(startXProperty()))
    ));
    
    arrow.getTransforms().add(rotation);
    
    /* add translation transform to put the arrow touching the circle's bounds */
    Translate t = new Translate(- outbound.getRadius(), 0);
    arrow.getTransforms().add(t);
    
}
 

@Override
public void attachArrow(SmartArrow arrow) {
    this.attachedArrow = arrow;

    /* attach arrow to line's endpoint */
    arrow.translateXProperty().bind(endXProperty());
    arrow.translateYProperty().bind(endYProperty());

    /* rotate arrow around itself based on this line's angle */
    Rotate rotation = new Rotate();
    rotation.pivotXProperty().bind(translateXProperty());
    rotation.pivotYProperty().bind(translateYProperty());
    rotation.angleProperty().bind(UtilitiesBindings.toDegrees(
            UtilitiesBindings.atan2(endYProperty().subtract(controlY2Property()),
                    endXProperty().subtract(controlX2Property()))
    ));

    arrow.getTransforms().add(rotation);

    /* add translation transform to put the arrow touching the circle's bounds */
    Translate t = new Translate(-outbound.getRadius(), 0);
    arrow.getTransforms().add(t);
}
 

@Override
protected Node initBottomGui() {
	StackPane stack = new StackPane();
	stack.getChildren().setAll(maps.stream().map(map -> map.getScale()).distinct().map(scale -> {
		int size = 128 * (1 << scale);
		Rectangle rect = new Rectangle(size, size, new Color(0.9f, 0.15f, 0.15f, 0.02f));
		rect.setStroke(new Color(0.9f, 0.15f, 0.15f, 0.4f));
		rect.setMouseTransparent(true);
		rect.setPickOnBounds(false);
		getTopGui().hoverProperty().addListener(e -> {
			if (getTopGui().isHover())
				rect.setFill(new Color(0.9f, 0.15f, 0.15f, 0.2f));
			else
				rect.setFill(new Color(0.9f, 0.15f, 0.15f, 0.02f));
		});
		return rect;
	}).collect(Collectors.toList()));
	Translate t = new Translate();
	t.xProperty().bind(stack.widthProperty().multiply(-0.5));
	t.yProperty().bind(stack.heightProperty().multiply(-0.5));
	stack.getTransforms().addAll(t, new Translate(position.x(), position.y()));
	stack.setPickOnBounds(false);
	stack.setMouseTransparent(true);
	stack.setViewOrder(1);
	return stack;
}
 

/**
 * Wrap a given Node (e.g. a Pin button) in a {@link StackPane} to be placed on to the map. Applies a scaling function (used to scales it
 * relative to the current zoom factor) and translations (to keep it at a given world space position and centered).
 */
static StackPane wrapGui(Node node, Vector2dc position, DoubleBinding scale, DisplayViewport viewport) {
	StackPane stack = new StackPane(node);
	Translate center = new Translate();
	center.xProperty().bind(stack.widthProperty().multiply(-0.5));
	center.yProperty().bind(stack.heightProperty().multiply(-0.5));
	if (position != null)
		stack.getTransforms().add(new Translate(position.x(), position.y()));
	if (scale != null) {
		Scale scaleTransform = new Scale();
		scaleTransform.xProperty().bind(scale);
		scaleTransform.yProperty().bind(scale);
		stack.getTransforms().add(scaleTransform);
	}
	stack.getTransforms().add(center);
	stack.setVisible(false);
	stack.setPickOnBounds(false);
	stack.setOpacity(0.0);
	return stack;
}
 

@Test
public void test_translate() {
	Point start = new Point(0, 0);
	Point end = new Point(100, 50);
	Bendable bendable = new Bendable(start, end);
	// check content bend points
	List<BendPoint> contentBendPoints = bendable.getContentBendPoints();
	assertEquals(start, contentBendPoints.get(0).getPosition());
	assertEquals(end, contentBendPoints.get(1).getPosition());
	// check size
	Dimension contentSize = bendable.getContentSize();
	assertEquals(new Rectangle(start, end).getSize(), contentSize);
	// check transform (should equal translation to offset)
	Point contentOffset = new Point(bendable.getContentTransform().getTx(), bendable.getContentTransform().getTy());
	assertEquals(start, contentOffset);
	// apply translation
	Point newStart = start.getTranslated(20, 50);
	Point newEnd = end.getTranslated(20, 50);
	Rectangle newBounds = new Rectangle(newStart, newEnd);
	bendable.setContentTransform(new Affine(new Translate(newStart.x, newStart.y)));
	assertEquals(newBounds.getSize(), bendable.getContentSize());
	contentOffset = new Point(bendable.getContentTransform().getTx(), bendable.getContentTransform().getTy());
	assertEquals(newStart, contentOffset);
}
 

/**
 * Starts the rotation of the plot.
 */
public void handleAnimate() {
    if (!animationRunning) {
        yRotate.setAngle(rotateY.getAngle() + deltaAngle);
        plot.getTransforms().addAll(pivot, yRotate,
                new Translate(-250, 0, -250));
        rotateAnimationTimeline.play();
        animationRunning = true;
        LOG.finest("ANIMATE button clicked.Starting animation.");
    } else {
        plot.getTransforms().remove(yRotate);
        rotateY.setAngle(rotateY.getAngle() + yRotate.getAngle());
        deltaAngle = yRotate.getAngle();
        rotateAnimationTimeline.stop();
        animationRunning = false;
        LOG.finest("ANIMATE button clicked.Stopping animation.");
    }
}
 

public Node toNode(double zoomLevel, boolean infraredOn, boolean effectsOn) {
	if (zoomLevel < MINIMUM_ZOOM_LEVEL)
		return null;

	waveAngle = Angle.normalize(waveAngle + BLOBBING_SPEED);
	shape.setRadiusX(Math.min(getEgg().getAge(), Configuration.EGG_RADIUS + RADIUS_VARIATION * FastMath.sin(waveAngle)));
	shape.setRadiusY(Math.min(getEgg().getAge(), Configuration.EGG_RADIUS + RADIUS_VARIATION * FastMath.cos(waveAngle)));

	shape.setFill(getFillColor(infraredOn));

	if (effectsOn)
		shape.setEffect(getEffects(zoomLevel, infraredOn));

	shape.getTransforms().clear();
	Translate translation = new Translate(getThing().getPosition().x, getThing().getPosition().y);
	shape.getTransforms().add(translation);

	return shape;
}
 

public EyesView(Narjillo narjillo) {
	this.narjillo = narjillo;

	Fiber fiber = narjillo.getBody().getHead().getFiber();
	this.eyeRed = fiber.getPercentOfRed();
	this.eyeGreen = fiber.getPercentOfGreen();
	this.eyeBlue = fiber.getPercentOfBlue();

	// "Random qualities": we want something that looks random across narjillos,
	// but stays the same for the same narjillo even after saving and reloading
	double someRandomQuality = narjillo.getBody().getAdultMass();
	double someOtherRandomQuality = narjillo.getBody().getEnergyToChildren();

	this.eye1 = new Circle(someRandomQuality % 5 + 7);
	this.eye2 = new Circle(someOtherRandomQuality % 5 + 7);
	this.pupil1 = new Circle(Math.min(eye1.getRadius() - 2, someRandomQuality % 6 + 1));
	this.pupil2 = new Circle(Math.min(eye1.getRadius() - 2, someOtherRandomQuality % 6 + 1));

	eyeCenteringTranslation = eye1.getRadius() - eye2.getRadius();
	pupilTranslation = Math.min(eye2.getRadius() - pupil2.getRadius(), eye1.getRadius() - pupil1.getRadius());

	this.eye1.getTransforms().add(new Translate(eyeCenteringTranslation - eye1.getRadius() + 1, 0));
	this.eye2.getTransforms().add(new Translate(eyeCenteringTranslation + eye2.getRadius() - 1, 0));
}
 

private Shape getShape(double zoomLevel, boolean effectsOn) {

		segment.setWidth(organ.getLength() + getOverlap() * 2);
		segment.setHeight(organ.getThickness());

		segment.getTransforms().clear();
		// overlap slightly and shift to center based on thickness
		double widthCenter = organ.getThickness() / 2;
		segment.getTransforms().add(moveToStartPoint());
		segment.getTransforms().add(new Translate(-getOverlap(), -widthCenter));
		segment.getTransforms().add(new Rotate(organ.getAbsoluteAngle(), getOverlap(), widthCenter));

		boolean isHighDetail = hasJoint && zoomLevel >= VERY_HIGH_MAGNIFICATION && effectsOn;

		if (!isHighDetail)
			return segment;

		joint.setRadius(getJointRadius(organ.getThickness()));

		joint.getTransforms().clear();
		joint.getTransforms().add(moveToStartPoint());
		joint.getTransforms().add(new Translate(organ.getLength(), 0));
		joint.getTransforms().add(new Rotate(organ.getAbsoluteAngle(), -organ.getLength(), 0));

		return Path.union(segment, joint);
	}
 

@Override
public Node toNode(double zoomLevel, boolean infraredOn, boolean effectsOn) {
	if (zoomLevel < MINIMUM_ZOOM_LEVEL)
		return null;

	Color color = getColor(zoomLevel, infraredOn);
	for (int i = 0; i < lines.length; i++) {
		lines[i].setStroke(color);
		rotateLine(i);
	}

	Vector position = getNarjillo().getPosition();
	group.getTransforms().clear();
	group.getTransforms().add(new Translate(position.x, position.y));

	return group;
}
 

private void initModel(Annotation model) {
   scale = new Scale(1, 1);
   translate = new Translate(PADDING, PADDING);
   rotate = new Rotate();
   board.getTransforms().setAll(scale, rotate);

   scale.addEventHandler(TransformChangedEvent.TRANSFORM_CHANGED, event -> {
      // Maintain constant padding at different zoom level
      board.setPadding(new Insets(max(PADDING / scale.getX(), PADDING / scale.getY())));

      canvas.setWidth(imageView.getBoundsInLocal().getWidth());
      canvas.setHeight(imageView.getBoundsInLocal().getHeight());
   });

   scale.setX(1);
   scale.setY(1);
   rotate.setAngle(0);
   selectedObjectProperty.setValue(null);
   tagCoordsProperty.set("");
   objectsProperty.clear();
   hintsProperty.clear();
   imageView.setImage(model == null ? null : model.getSize().getImage());
   imageView.setCache(true);
   if (model != null && model.getObjects().size() > 0) {
      model.getObjects().forEach(obj -> createObjectTag(obj));
      statusProperty.set(MessageFormat.format(bundle.getString("msg.objectsCount"), model.getObjects().size()));
   }
   else {
      statusProperty.set(bundle.getString("msg.noObjects"));
   }
   findHints();
}
 

public PinDecoration(DisplayViewport viewport) {
	this.viewport = Objects.requireNonNull(viewport);
	this.viewport.scaleProperty.addListener(new WeakChangeListener<>(this));

	world = new AnchorPane();
	world.getStylesheets().add("/de/piegames/blockmap/gui/decoration/pins.css");
	{
		Scale s = new Scale();
		s.xProperty().bind(viewport.scaleProperty);
		s.yProperty().bind(viewport.scaleProperty);
		Translate t = new Translate();
		t.xProperty().bind(Bindings.createDoubleBinding(() -> viewport.translationProperty.get().x(), viewport.translationProperty));
		t.yProperty().bind(Bindings.createDoubleBinding(() -> viewport.translationProperty.get().y(), viewport.translationProperty));
		world.getTransforms().add(s);
		world.getTransforms().add(t);
	}
	world.setPickOnBounds(false);
	getChildren().add(world);

	setMinSize(0, 0);
	setPrefSize(0, 0);
	setPickOnBounds(false);

	{
		final Rectangle outputClip = new Rectangle();
		this.setClip(outputClip);

		this.layoutBoundsProperty().addListener((ov, oldValue, newValue) -> {
			outputClip.setWidth(newValue.getWidth());
			outputClip.setHeight(newValue.getHeight());
		});
	}

	visiblePins.addListener((InvalidationListener) e -> executeUpdate.requestExecution());
}
 

protected Sample3D(double width, double height) {
    super(width, height);
    Group group3d = new Group(create3dContent());
    group3d.setDepthTest(DepthTest.ENABLE);
    group3d.getTransforms().addAll(
            new Translate(width / 2, height / 2),
            new Rotate(180, Rotate.X_AXIS)
    );
    getChildren().add(group3d);
}
 

protected Sample3D(double width, double height) {
    super(width, height);
    Group group3d = new Group(create3dContent());
    group3d.setDepthTest(DepthTest.ENABLE);
    group3d.getTransforms().addAll(
            new Translate(width / 2, height / 2),
            new Rotate(180, Rotate.X_AXIS)
    );
    getChildren().add(group3d);
}
 

private void init(Stage primaryStage) {
    Group root = new Group();
    root.setDepthTest(DepthTest.ENABLE);
    primaryStage.setResizable(false);
    primaryStage.setScene(new Scene(root, 400, 150, true));
    primaryStage.getScene().setCamera(new PerspectiveCamera());
    root.getTransforms().addAll(
        new Translate(400 / 2, 150 / 2),
        new Rotate(180, Rotate.X_AXIS)
    );
    root.getChildren().add(create3dContent());
}
 

private void init(Stage primaryStage) {
    Group root = new Group();
    root.setDepthTest(DepthTest.ENABLE);
    primaryStage.setResizable(false);
    primaryStage.setScene(new Scene(root, 500, 500, true));
    primaryStage.getScene().setCamera(new PerspectiveCamera());
    root.getTransforms().addAll(
        new Translate(500 / 2, 500 / 2),
        new Rotate(180, Rotate.X_AXIS)
    );
    root.getChildren().add(create3dContent());
}
 

private void init(Stage primaryStage) {
    Group root = new Group();
    root.setDepthTest(DepthTest.ENABLE);
    primaryStage.setResizable(false);
    primaryStage.setScene(new Scene(root, 400, 500, true));
    primaryStage.getScene().setCamera(new PerspectiveCamera());
    root.getTransforms().addAll(
        new Translate(400 / 2, 500 / 2 + 100),
        new Rotate(180, Rotate.X_AXIS)
    );
    root.getChildren().add(create3dContent());
}
 

@Override
public void updateChanges()
{
    super.updateChanges();
    if (dirty_look.checkAndClear())
    {
        boolean horizontal = model_widget.propHorizontal().getValue();
        double width = model_widget.propWidth().getValue();
        double height = model_widget.propHeight().getValue();
        if (!horizontal)
        {
            jfx_node.getTransforms().setAll(
                    new Translate(0, height),
                    new Rotate(-90, 0, 0));
            jfx_node.setPrefSize(height, width);
        }
        else
        {
            jfx_node.getTransforms().clear();
            jfx_node.setPrefSize(width, height);
        }

        // Default 'inset' of .bar uses 7 pixels.
        // A widget sized 15 has 8 pixels left for the bar.
        // Select leaner style where .bar uses full size.
        Styles.update(jfx_node, "SmallBar",
                      Math.min(width, height) <= 15);

        // Could clear style and use setBackground(),
        // but result is very plain.
        // Tweaking the color used by CSS keeps overall style.
        // See also http://stackoverflow.com/questions/13467259/javafx-how-to-change-progressbar-color-dynamically
        final StringBuilder style = new StringBuilder();
        style.append("-fx-accent: ").append(JFXUtil.webRGB(model_widget.propFillColor().getValue())).append(';');
        style.append("-fx-control-inner-background: ").append(JFXUtil.webRGB(model_widget.propBackgroundColor().getValue())).append(';');
        jfx_node.setStyle(style.toString());
    }
    if (dirty_value.checkAndClear())
        jfx_node.setProgress(percentage);
}
 

@Override
public Affine getContentTransform() {
	Point position = ZestProperties.getPosition(getContent());
	if (position == null) {
		position = new Point();
	}
	return new Affine(new Translate(position.x, position.y));
}
 

@Override
public Affine getContentTransform() {
	Point p = getLabelPosition();
	if (p == null) {
		p = new Point();
	}
	return new Affine(new Translate(p.x, p.y));
}
 

/**
 * Adjusts the label's position to fit the given {@link Point}.
 *
 * @param visual
 *            This node's visual.
 * @param position
 *            This node's position.
 */
protected void refreshPosition(Node visual, Point position) {
	if (position != null) {
		// translate using a transform operation
		TransformVisualOperation refreshPositionOp = new TransformVisualOperation(this,
				new Affine(new Translate(position.x, position.y)));
		try {
			refreshPositionOp.execute(null, null);
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
	}
}
 

/**
 * Computes the translation from the given list of
 * {@link IBendableContentPart.BendPoint}s as the offset of the bounds
 * around the unattached bend points.
 *
 * @param bendPoints
 *            The list of {@link IBendableContentPart.BendPoint}s for
 *            which to compute the translation.
 * @return The translation of the bounds around the unattached bend
 *         points.
 */
static Affine computeTranslation(List<BendPoint> bendPoints) {
	// iterate over the unattached bend-points to find the minimum
	Point min = null;
	for (BendPoint bp : bendPoints) {
		if (!bp.isAttached()) {
			Point pos = bp.getPosition();
			if (min == null) {
				// initialize min
				// XXX: copy so it can safely be changed
				min = pos.getCopy();
			} else {
				// adjust min to the given position
				if (min.x > pos.x) {
					min.x = pos.x;
				}
				if (min.y > pos.y) {
					min.y = pos.y;
				}
			}
		}
	}
	// XXX: in case there are no unattached bend-points, an identity
	// transformation is returned
	return min == null ? new Affine()
			: new Affine(new Translate(min.x, min.y));
}
 

/**
 * will retrieve icons from the glyphs map for a certain glyphName
 *
 * @param glyphName the glyph name
 * @return SVGGlyph node
 */
public static SVGGlyph getIcoMoonGlyph(String glyphName) throws Exception{
    SVGGlyphBuilder builder = glyphsMap.get(glyphName);
    if(builder == null) throw new Exception("Glyph '" + glyphName + "' not found!");
    SVGGlyph glyph = builder.build();
    // we need to apply transformation to correct the icon since
    // its being inverted after importing from icomoon
    glyph.getTransforms().add(new Scale(1, -1));
    Translate height = new Translate();
    height.yProperty().bind(Bindings.createDoubleBinding(() -> -glyph.getHeight(), glyph.heightProperty()));
    glyph.getTransforms().add(height);
    return glyph;
}
 

private void resizeMapControl() {
    double scale = Math.min(mapCanvasPane.getWidth() / mapControl.getSize(), mapCanvasPane.getHeight() / mapControl.getSize());

    double sw = mapControl.getSize() * scale;
    double dx = mapCanvasPane.getWidth() - sw;
    double dy = mapCanvasPane.getHeight() - sw;

    mapCanvasPane.getTransforms().clear();
    mapCanvasPane.getTransforms().add(new Scale(scale, scale));
    mapCanvasPane.getTransforms().add(new Translate(0.5 * dx / scale, 0.5 * dy / scale));
}
 

private Scene createScene() {
    Cube cube = new Cube(Color.BLUE);
    snake.getChildren().add(cube);

    moveFood();

    root.getChildren().addAll(snake, food);

    Scene scene = new Scene(root, 1280, 720, true);

    PerspectiveCamera camera = new PerspectiveCamera(true);
    camera.getTransforms().addAll(new Translate(0, -20, -20), new Rotate(-45, Rotate.X_AXIS));

    scene.setCamera(camera);

    timer = new AnimationTimer() {
        @Override
        public void handle(long now) {
            t += 0.016;

            if (t > 0.1) {
                onUpdate();
                t = 0;
            }
        }
    };

    timer.start();

    return scene;
}
 

public Axes(double scale) {
    axisX.getTransforms().addAll(new Rotate(90, Rotate.Z_AXIS), new Translate(0, 30, 0));
    axisX.setMaterial(new PhongMaterial(Color.RED));
    axisY.getTransforms().add(new Translate(0, 30, 0));
    axisY.setMaterial(new PhongMaterial(Color.GREEN));
    axisZ.setMaterial(new PhongMaterial(Color.BLUE));
    axisZ.getTransforms().addAll(new Rotate(90, Rotate.X_AXIS), new Translate(0, 30, 0));
    getChildren().addAll(axisX, axisY, axisZ);
    getTransforms().add(new Scale(scale, scale, scale));
}
 

public void setHeight(double equalHeights) {
    double oldHeight = axisX.getHeight();
    axisX.setHeight(equalHeights);
    axisX.getTransforms().add(new Translate(0, (equalHeights/2.0)-(oldHeight/2.0), 0));
    axisY.setHeight(equalHeights);
    axisY.getTransforms().add(new Translate(0, (equalHeights/2.0)-(oldHeight/2.0), 0));
    axisZ.setHeight(equalHeights);
    axisZ.getTransforms().add(new Translate(0,(equalHeights/2.0)-(oldHeight/2.0), 0));
}