I'm trying to Slice an image to show on a screen.
For example if I change the right margin to 20 of the flower picture on the left and the bottom margin of the flower picture in the right to 20 they should behave as follow:
(the original pictures are shown in the first column)
enter image description here
ViewPort method does exactly what I want, cutting the image and leaving the margin empty but it uses image's original size displaying a zoom effect as it says in the javafx website:
"The rectangular viewport into the image. The viewport is specified in the coordinates of the image, prior to scaling or any other transformations.
If viewport is null, the entire image is displayed. If viewport is non-null, only the portion of the image which falls within the viewport will be displayed. If the image does not fully cover the viewport then any remaining area of the viewport will be empty."
I already tried to use imageView.resize(screenWidth, screenHeight) before setting the viewport but it doesn't work.
Also tried to imageView.setFitWidth(screenWidth), imageView.setFitHeight(screenHeight)
Is it possible to rescale the image so it's displayed as described?
Or any other work-around?
Here is my code for left margin as an example:
mediaContent.resize(screenWidth, screen.getHeight());
// mediaContent.setFitWidth(screenWidth);
// mediaContent.setFitHeight(screen.getHeight());
mediaContent.setViewport(new Rectangle2D(screenWidth-dXLeft, 0, screenWidth, screen.getHeight()));
Update: Tried setting setFitWidth and setFitHeightas suggested stills displays the image zoomed in
`imageView.setFitWidth(space.getX());
imageView.setFitHeight(space.getY());
imageView.setViewport(new Rectangle2D(screen.getWidth()-space.getX(), 0, screen.getWidth(), screen.getHeight()));
imageView.setFitWidth(space.getX());
imageView.setFitHeight(space.getY());
return imageView;`
This is the result when I use the setViewport method when not
setting margins: enter image description here
How it should be when not setting margins: enter image description here
Update 2: Example (modified from java-buddy) zooming in
package javafx_imageview_viewport;
import javafx.application.Application;
import javafx.beans.value.ObservableValue;
import javafx.geometry.Rectangle2D;
import javafx.scene.Scene;
import javafx.scene.control.Slider;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.layout.StackPane;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
/**
* #web http://java-buddy.blogspot.com/
*/
public class JavaFX_ImageView_Viewport extends Application {
#Override
public void start(Stage primaryStage) {
ImageView imageView1 = new ImageView(new Image("https://i.imgur.com/6Zl0eQB.jpg"));
imageView1.setFitWidth(150);
imageView1.setFitHeight(100);
//Example to rotate ImageView
Image image2 = new Image("https://i.imgur.com/6Zl0eQB.jpg");
Rectangle2D viewportRect2 = new Rectangle2D(
image2.getWidth()/4,
image2.getHeight()/4,
image2.getWidth()*3/4,
image2.getHeight()*3/4);
ImageView imageView2 = new ImageView(image2);
imageView2.setFitWidth(150);
imageView2.setFitHeight(100);
imageView2.setViewport(viewportRect2);
Slider sliderRotate = new Slider();
sliderRotate.setMin(0);
sliderRotate.setMax(360);
sliderRotate.setValue(0);
sliderRotate.valueProperty().addListener(
(ObservableValue<? extends Number> observable,
Number oldValue, Number newValue) -> {
imageView2.setRotate((double)newValue);
});
//Example to change ViewPort
Image image3 = new Image("https://i.imgur.com/6Zl0eQB.jpg");
Rectangle2D viewportRect3 = new Rectangle2D(
0,
0,
image3.getWidth(),
image3.getHeight());
ImageView imageView3 = new ImageView(image3);
imageView3.setFitWidth(150);
imageView3.setFitHeight(100);
imageView3.setViewport(viewportRect3);
Slider sliderViewPort = new Slider();
sliderViewPort.setMin(0);
sliderViewPort.setMax(1.0);
sliderViewPort.setValue(1.0);
sliderViewPort.valueProperty().addListener(
(ObservableValue<? extends Number> observable,
Number oldValue, Number newValue) -> {
Rectangle2D newViewportRect3 = new Rectangle2D(
0,
0,
(double)newValue*image3.getWidth(),
(double)newValue*image3.getHeight());
imageView3.setViewport(newViewportRect3);
});
VBox vBox = new VBox();
vBox.getChildren().addAll(imageView1,
imageView2, sliderRotate,
imageView3, sliderViewPort);
StackPane root = new StackPane();
root.getChildren().add(vBox);
Scene scene = new Scene(root, 300, 350);
primaryStage.setTitle("java-buddy: ImageVIew ViewPort");
primaryStage.setScene(scene);
primaryStage.show();
}
/**
* #param args the command line arguments
*/
public static void main(String[] args) {
launch(args);
}
}
Example 2 from java-buddy how I want it to behave, cutting the image:
package javafx_imageview_viewport;
import javafx.application.Application;
import javafx.beans.value.ObservableValue;
import javafx.geometry.Rectangle2D;
import javafx.scene.Scene;
import javafx.scene.control.Slider;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.layout.StackPane;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
/**
* #web http://java-buddy.blogspot.com/
*/
public class JavaFX_ImageView_Viewport extends Application {
#Override
public void start(Stage primaryStage) {
ImageView imageView1 = new ImageView(new Image("https://i.imgur.com/294AEFU.png"));
//Example to rotate ImageView
Image image2 = new Image("https://i.imgur.com/294AEFU.png");
Rectangle2D viewportRect2 = new Rectangle2D(
image2.getWidth()/4,
image2.getHeight()/4,
image2.getWidth()*3/4,
image2.getHeight()*3/4);
ImageView imageView2 = new ImageView(image2);
imageView2.setViewport(viewportRect2);
Slider sliderRotate = new Slider();
sliderRotate.setMin(0);
sliderRotate.setMax(360);
sliderRotate.setValue(0);
sliderRotate.valueProperty().addListener(
(ObservableValue<? extends Number> observable,
Number oldValue, Number newValue) -> {
imageView2.setRotate((double)newValue);
});
//Example to change ViewPort
Image image3 = new Image("https://i.imgur.com/294AEFU.png");
Rectangle2D viewportRect3 = new Rectangle2D(
0,
0,
image3.getWidth(),
image3.getHeight());
ImageView imageView3 = new ImageView(image3);
imageView3.setViewport(viewportRect3);
Slider sliderViewPort = new Slider();
sliderViewPort.setMin(0);
sliderViewPort.setMax(1.0);
sliderViewPort.setValue(1.0);
sliderViewPort.valueProperty().addListener(
(ObservableValue<? extends Number> observable,
Number oldValue, Number newValue) -> {
Rectangle2D newViewportRect3 = new Rectangle2D(
0,
0,
(double)newValue*image3.getWidth(),
(double)newValue*image3.getHeight());
imageView3.setViewport(newViewportRect3);
});
VBox vBox = new VBox();
vBox.getChildren().addAll(imageView1,
imageView2, sliderRotate,
imageView3, sliderViewPort);
StackPane root = new StackPane();
root.getChildren().add(vBox);
Scene scene = new Scene(root, 300, 350);
primaryStage.setTitle("java-buddy: ImageVIew ViewPort");
primaryStage.setScene(scene);
primaryStage.show();
}
/**
* #param args the command line arguments
*/
public static void main(String[] args) {
launch(args);
}
}
It seems that what I wanted does not make sense.
If I want the image to fit the screen I have to use fitScreenWidth(screenWidth)and fitScreenHeight(screenHeight) but it does not make sense to use viewPort method in this case since the image has been resized already.
viewPort method should be used only with the original image's dimensions.
Related
I have an AnchorPane which contains a clipped circle. I set a maximum height to the anchorpane, so that if the circle's y position is high, the circle won't be displayed. The problem is that when the circle goes to the lower part of the anchorpane, it increases it's height. This should not be happening.
This happens even before the clipped element reaches the lower part of the anchorpane. Once the "invisible" part of the circle reaches the lower part, it starts increasing it's height.
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.layout.AnchorPane;
import javafx.scene.paint.Color;
import javafx.scene.paint.CycleMethod;
import javafx.scene.paint.RadialGradient;
import javafx.scene.paint.Stop;
import javafx.scene.shape.Circle;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage;
public class Init extends Application {
private AnchorPane canvasContainer;
private AnchorPane mainPane;
#Override
public void start(Stage stage) throws Exception {
canvasContainer = new AnchorPane();
mainPane = new AnchorPane();
Scene scene = new Scene(mainPane, 800, 700);
stage.setScene(scene);
canvasContainer.setPrefWidth(600.0d);
canvasContainer.setPrefHeight(500.0d);
//IGNORED
canvasContainer.setMaxHeight(canvasContainer.getPrefHeight());
canvasContainer.setLayoutX(14.0d);
canvasContainer.setLayoutY(14.0d);
canvasContainer.setStyle("-fx-border-color: black; -fx-border-width: 1 1 1 1;");
RadialGradient gradient = new RadialGradient(0, 0, 0.5, 0.5, 1, true, CycleMethod.NO_CYCLE, new Stop[] {
new Stop(0, Color.ORANGE),
new Stop(0.2, Color.YELLOW),
new Stop(0.5, Color.TRANSPARENT)
});
//I AM MODIFYING THIS VALUE
int y = 500;
Circle circleGradient = new Circle(200, y, 50);
circleGradient.setFill(gradient);
Rectangle rect = new Rectangle(200 - 50, y - 50, 1000, 50/2);
circleGradient.setClip(rect);
canvasContainer.getChildren().addAll(circleGradient);
mainPane.getChildren().add(canvasContainer);
stage.show();
}
public static void main(String[] args) {
launch(args);
}
}
I had the same issue when I was trying to make a circle grow so it would fill a rectangle which was a small area of my Scene. The filling animation worked great but the maxHeight and maxWidth of your canvasContainer are ignored. In my case that ended up with the area growing and destroying everything nearby.
Solution : add the circle to the mainPane and not canvasContainer
is there any way to determine the bounds (especially height and width) of a node which is already attached to a scene but set to invisible?
I want to show a label on screen only if its width exceeds 100px... but it is always 0:
#Override
public void start(Stage primaryStage) {
Group root = new Group();
Scene scene = new Scene(root, 500, 500, Color.BLACK);
primaryStage.setScene(scene);
primaryStage.show();
Label n = new Label();
n.setVisible(false);
n.setStyle("-fx-background-color: red;");
root.getChildren()
.addAll(n);
n.textProperty()
.addListener((v, ov, nv) -> {
System.out.println(n.getBoundsInParent());
n.setVisible(n.getWidth() > 100);
});
n.setText("TEST11111111111111111111111");
}
The result of the sysout: (also n.getWidth() is no better)
BoundingBox [minX:0.0, minY:0.0, minZ:0.0, width:0.0, height:0.0, depth:0.0, maxX:0.0, maxY:0.0, maxZ:0.0]
Is there any trick ?
Thanks all!
Your problem is that you are listening for changes to the text property and expecting the width of the node to be updated at that time - but it's not. The width of nodes are only calculated and set during a render pass which consists of an applyCSS and layout routine (see: Get the height of a node in JavaFX (generate a layout pass)). Your code incorrectly sets the node to invisible before the updated size of the node is calculated.
Instead of using a listener on the text property to determine visibility of the node, I suggest that you use a binding expression to create a direct binding on the visibility property to the desired width property. An example of this approach is provided below. You can see that the label only displays when the text to display is longer than the required width (in this case 100 pixels).
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.layout.Pane;
import javafx.stage.Stage;
public class BoundSample extends Application {
public static void main(String[] args) {
launch(args);
}
#Override
public void start(Stage primaryStage) {
Pane root = new Pane();
Scene scene = new Scene(root, 200, 100);
primaryStage.setScene(scene);
primaryStage.show();
Label n = new Label();
n.setVisible(false);
n.visibleProperty().bind(n.widthProperty().greaterThan(100));
TextField textField = new TextField("TEST11111111111111111111111");
n.textProperty().bind(textField.textProperty());
textField.relocate(0, 50);
root.getChildren().addAll(n, textField);
}
}
I would like to show a photo as an ImageView in a ScrollPane with an ZoomIn and ZoomOut Function. But if I reduce by means of scale the imageview, an undesirable empty edge is created in the ScrollPane. How can you make sure that the ScrollPane is always the size of the scaled ImageView?
See the following example. For simplicity, I replaced the ImageView with a rectangle.
import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.ScrollPane;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage;
public class ScrollPaneDemo extends Application {
double scale;
Pane contPane = new Pane();
#Override
public void start(Stage primaryStage) {
BorderPane pane = new BorderPane();
ScrollPane sp = new ScrollPane();
sp.setContent(contPane);
sp.setVvalue(0.5);
sp.setHvalue(0.5);
Rectangle rec = new Rectangle(2820, 1240,Color.RED);
scale = 0.2;
contPane.setScaleX(scale);
contPane.setScaleY(scale);
contPane.getChildren().add(rec);
Button but1 = new Button("+");
but1.setOnAction((ActionEvent event) -> {
scale*=2;
contPane.setScaleX(scale);
contPane.setScaleY(scale);
});
Button but2 = new Button("-");
but2.setOnAction((ActionEvent event) -> {
scale/=2;
contPane.setScaleX(scale);
contPane.setScaleY(scale);
});
HBox buttons = new HBox(but1, but2);
pane.setTop(buttons);
pane.setCenter(sp);
Scene scene = new Scene(pane, 800, 600);
primaryStage.setScene(scene);
primaryStage.show();
}
public static void main(String[] args) {
launch(args);
}
}
contPane scaled by using transform don't change its layoutBounds automatically. If you want not to make empty space in contPane, you'd better wrap the node in Group.
See this post. Layout using the transformed bounds
sp.setContent(new Group(contPane));
In addition, if you don't want to make empty space in ScrollPane, limit minimum scale to rate which width or height of the content fits viewport's one.
Button but1 = new Button("+");
but1.setOnAction((ActionEvent event) -> {
updateScale(scale * 2.0d);
});
Button but2 = new Button("-");
but2.setOnAction((ActionEvent event) -> {
updateScale(scale / 2.0d);
});
HBox buttons = new HBox(but1, but2);
pane.setTop(buttons);
pane.setCenter(sp);
Scene scene = new Scene(pane, 800, 600);
primaryStage.setScene(scene);
primaryStage.show();
updateScale(0.2d);
private void updateScale(double newScale) {
scale = Math.max(newScale, Math.max(sp.getViewportBounds().getWidth() / rec.getWidth(), sp.getViewportBounds().getHeight() / rec.getHeight()));
contPane.setScaleX(scale);
contPane.setScaleY(scale);
}
Consider a case of the image is smaller than ScrollPane's viewport. Because for showing no empty space, this code will stretch contents when it doesn't have enough size.
In a case of huge images, TravisF's comment helps you.
How can I keep an element always visible even after scrolling in a scrollPane, that means the node should be immovable after a horizontal scrolling.its position should be fixed. I have tried this but it doesn't work for my case , the elements still moving with scrolling, I'm adding a scrollPane which contains all the elements to an AnchorPane.
Just use a stack pane and add the fixed elements after the ScrollPane.
Depending on what scrolling you do not want to allow just comment out the "scrollProperty" listener that I added - if you want the element completely fixed - remove them both:
import javafx.application.Application;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.control.ScrollPane;
import javafx.scene.layout.Pane;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;
public class Main extends Application {
public static void main(String[] args) {
launch(args);
}
#Override
public void start(Stage primaryStage) throws Exception {
StackPane root = new StackPane();
root.setAlignment(Pos.TOP_LEFT);
ScrollPane scrollPane = new ScrollPane();
Pane pane = new Pane();
pane.setMinHeight(1000);
pane.setMinWidth(1000);
scrollPane.setContent(pane);
root.getChildren().add(scrollPane);
Label fixed = new Label("Fixed");
root.getChildren().add(fixed);
// Allow vertical scrolling of fixed element:
scrollPane.hvalueProperty().addListener( (observable, oldValue, newValue) -> {
double xTranslate = newValue.doubleValue() * (scrollPane.getViewportBounds().getWidth() - fixed.getWidth());
fixed.translateXProperty().setValue(-xTranslate);
});
// Allow horizontal scrolling of fixed element:
scrollPane.vvalueProperty().addListener( (observable, oldValue, newValue) -> {
double yTranslate = newValue.doubleValue() * (scrollPane.getViewportBounds().getHeight() - fixed.getWidth());
fixed.translateYProperty().setValue(-yTranslate);
});
Scene scene = new Scene(root, 500, 500);
primaryStage.setScene(scene);
primaryStage.show();
}
}
I have a simple JavaFX application with a Canvas and a ScrollBar.
The Canvas acts as a virtualized canvas whose contents can be scrolled with the ScrollBar.
The width of the Canvas is 500 pixels but the logical width of the Canvas is 1000 pixels.
I've set the ScrollBar's max to 1000 and the ScrollBar's visible amount to 500.
The problem is that when the ScrollBar is scrolled all the way to the right the value of the
ScrollBar is 1000, not 500.
Logically when a ScrollBar is scrolled all the way to the right there should be some way to determine the actual scrolled offset and that does not seem possible.
Please suggest how the amount of scroll required can be obtained. Thank you
Here is the example scrolled all the way to the left.
The scrollbar looks good. Its visible width is 50% of the window size.
Here is the example scrolled halfway to the right.
Here the problem is clear. The Canvas has been scrolled 500 pixels to the right, but if the Canvas was correctly scrolled halfway it would be scrolled only 250 pixels.
Here is the example scrolled all the way to the right.
import javafx.application.Application;
import javafx.beans.value.*;
import javafx.scene.Scene;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.control.ScrollBar;
import javafx.scene.layout.*;
import javafx.scene.paint.Color;
import javafx.scene.paint.CycleMethod;
import javafx.scene.paint.LinearGradient;
import javafx.scene.paint.Stop;
import javafx.stage.Stage;
public class Sc extends Application {
public ScrollBar scrollBar;
double scrolled;
Canvas canvas;
#Override
public void start(Stage stage) {
VBox vbox = new VBox();
Scene scene = new Scene(vbox);
stage.setScene(scene);
canvas = new Canvas(500, 100);
scrollBar = new ScrollBar();
scrollBar.setMin(0);
scrollBar.setMax(1000);
scrollBar.setVisibleAmount(500);
vbox.getChildren().addAll(canvas, scrollBar);
draw();
scrollBar.valueProperty().addListener(new ChangeListener<Number>() {
public void changed(ObservableValue<? extends Number> ov,
Number old_val, Number new_val) {
scrolled = new_val.doubleValue();
draw();
}
});
stage.show();
}
private void draw()
{
GraphicsContext graphics = canvas.getGraphicsContext2D();
graphics.clearRect(0, 0, canvas.getWidth(), canvas.getHeight());
Stop[] stops = new Stop[] { new Stop(0, Color.BLACK), new Stop(1, Color.RED)};
LinearGradient lg = new LinearGradient(0, 0, 1, 0, true, CycleMethod.NO_CYCLE, stops);
graphics.setFill(lg);
graphics.fillRect(0-scrolled, 30, 1000, 40);
}
public static void main(String[] args) {
launch(args);
}
}
Think of it this way:
min, max, and value are the logical values of the scrollbar. value ranges between min and max, and is equal to min if and only if the scrollbar is scrolled all the way to the left (or top, for a vertical scrollbar). It is equal to max if and only if the scrollbar is scrolled as far as possible to the right (or bottom).
The visibleAmount property is really just a visual property that determines the size of the "thumb". The relationship is something like
thumbSize / trackSize = visibleAmount / (max - min)
The visibleAmount will affect the relationship between actual pixels and "logical units"; however it will not change the fact that value can vary along the full range of [min, max].
So the only change you need to make to your code is to set the maximum value of the scrollbar to the maximum it can be scrolled by (not the size of the image you are drawing), which is 1000 - canvas.getWidth():
import javafx.application.Application;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.scene.Scene;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.control.ScrollBar;
import javafx.scene.layout.VBox;
import javafx.scene.paint.Color;
import javafx.scene.paint.CycleMethod;
import javafx.scene.paint.LinearGradient;
import javafx.scene.paint.Stop;
import javafx.stage.Stage;
public class ScrollBarExample extends Application {
private final static double TOTAL_WIDTH = 1000 ;
#Override
public void start(Stage stage) {
VBox vbox = new VBox();
Scene scene = new Scene(vbox, 500, 130);
stage.setScene(scene);
Canvas canvas = new Canvas(500, 100);
ScrollBar scrollBar = new ScrollBar();
scrollBar.setMin(0);
scrollBar.setMax(TOTAL_WIDTH - canvas.getWidth());
scrollBar.setVisibleAmount(scrollBar.getMax() * canvas.getWidth() / TOTAL_WIDTH);
vbox.getChildren().addAll(canvas, scrollBar);
draw(canvas, scrollBar.getValue());
scrollBar.valueProperty().addListener(new ChangeListener<Number>() {
#Override
public void changed(ObservableValue<? extends Number> ov,
Number old_val, Number new_val) {
draw(canvas, scrollBar.getValue());
}
});
stage.show();
}
private void draw(Canvas canvas, double scrollAmount)
{
GraphicsContext graphics = canvas.getGraphicsContext2D();
graphics.clearRect(0, 0, canvas.getWidth(), canvas.getHeight());
Stop[] stops = new Stop[] { new Stop(0, Color.BLACK), new Stop(1, Color.RED)};
LinearGradient lg = new LinearGradient(0, 0, 1, 0, true, CycleMethod.NO_CYCLE, stops);
graphics.setFill(lg);
graphics.fillRect(0-scrollAmount, 30, TOTAL_WIDTH, 40);
}
public static void main(String[] args) {
launch(args);
}
}