JavaFX Fenstergrösse automatisch Speichern und Laden

[sedu]

Guten Tag,
zurzeit arbeite ich an einen Projektarbeit über Notizverwaltung.
Hab schon über Google ect recherchiert, dann kam ich auf euch zu, doch leider nicht den Thema gefunden .
Meine Frage ist, wie kann ich die Fenstergrösse speichern sobald es kleiner/grösser und verschoben wird?

package application;
	
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.util.prefs.Preferences;

import javafx.application.Application;
import javafx.application.Platform;
import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.layout.AnchorPane;
import javafx.fxml.FXMLLoader;


public class Main extends Application {
	
	
	private Stage primaryStage;
	
	@Override
	public void start(Stage primaryStage) {
		try {
			AnchorPane root = (AnchorPane)FXMLLoader.load(getClass().getResource("Note.fxml"));
			Scene scene = new Scene(root);
			scene.getStylesheets().add(getClass().getResource("application.css").toExternalForm());
			
		    Preferences userPrefs = Preferences.userNodeForPackage(getClass());
		    // get window location from user preferences: use x=100, y=100, width=400, height=400 as default
		    double x = userPrefs.getDouble("stage.x", 100);
		    double y = userPrefs.getDouble("stage.y", 100);
		    double w = userPrefs.getDouble("stage.width", 1000);
		    double h = userPrefs.getDouble("stage.height", 750);
			
			primaryStage.setScene(scene);
			 primaryStage.setX(x);
			    primaryStage.setY(y);
			    primaryStage.setWidth(w);
			    primaryStage.setHeight(h);
			primaryStage.show();
		
			
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	
	
	
	@Override
	  public void stop() {
	    Preferences userPrefs = Preferences.userNodeForPackage(getClass());
	    userPrefs.putDouble("stage.x", primaryStage.getX());
	    userPrefs.putDouble("stage.y", primaryStage.getY());
	    userPrefs.putDouble("stage.width", primaryStage.getWidth());
	    userPrefs.putDouble("stage.height", primaryStage.getHeight());
	  }
	
	
	public static void main(String[] args) {
		
		try{
		    RandomAccessFile randomFile = new RandomAccessFile("single.class","rw");

		    FileChannel channel = randomFile.getChannel();

		    if(channel.tryLock() != null)
		    	launch(args);
		    else
		    	Platform.exit();
		}catch( Exception e ) { 
		    System.out.println(e.toString());
		}
		
		
	}
}

 

[wolfgang63]

Ich denke mal das sollte kein Problem sein.
Über Stage.getxxx kannst du jederzeit alle relevanten Daten abfragen und z.B. in einer Propertiedatei auf Platte speichern.
Beim nächsten Start liest du die Werte wieder ein und setzt dein Stage mit den neuen werten.

 

[sedu]

Genau das wäre mein problem, ich wüsste nicht wo/wie ich das verwenden soll.

 

[Ruzmanz]

Sieht ungefähr so aus (, für die Performance kannst du dir selbst was ausdenken):

primaryStage.widthProperty().addListener(new ChangeListener<Number>() {
				@Override
				public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
					System.out.println("Speicher die Breite: " + newValue);
				}
			});

 

[dzim]

Ich habe das im EventHandler, der auf das Beenden der Anwendung hört, erledigt:

private class ExitEventHandler implements EventHandler<WindowEvent> {
		
		private final DesktopDAO dao;
		private final Stage primaryStage;
		
		public ExitEventHandler(final DesktopDAO dao, final Stage primaryStage) {
			this.dao = dao;
			this.primaryStage = primaryStage;
		}
		
		@Override
		public void handle(WindowEvent event) {
			if (ApplicationInfo.getEnvironmentType() == Environment.DESKTOP && dao != null) {
				try {
					// TODO add isMaximized back to the saved values, there is no way in java7 to get the maximized state
					// dao.setPreference(WINDOW_MAXIMIZED, primaryStage.isMaximized() ? Boolean.TRUE : Boolean.FALSE);
					dao.setPreference(WINDOW_WIDTH, new Double(primaryStage.getWidth()));
					dao.setPreference(WINDOW_HEIGHT, new Double(primaryStage.getHeight()));
				} catch (DesktopDAOException e) {
					LOGGER.error("A problem occurred while saving the window preferences.", e);
				}
			}
			Platform.exit();
		}
	}

Verwendet wird das auf der primaryStage:

primaryStage.setOnCloseRequest(new ExitEventHandler(dao, primaryStage));

Das DAO ist mein POJO für die DB Operationen (SQLite).

Und beim Start der Anwendung mache ich folgendes:
- In meiner Main-Klasse habe ich ein paar defaults

	private static final double WINDOW_DEFAULT_WIDTH = 960;
	private static final double WINDOW_DEFAULT_HEIGHT = 450;
	
	private static final double WINDOW_MIN_WIDTH = 825;
	private static final double WINDOW_MIN_HEIGHT = 450;
	
	private static final String WINDOW_MAXIMIZED = "window.maximized";
	private static final String WINDOW_WIDTH = "window.width";
	private static final String WINDOW_HEIGHT = "window.height";

-Hilfsklasse "WindowSetup" wird aus der DB ausgelesen

private class WindowSetup {
		
		protected boolean maximized;
		protected double width;
		protected double height;
		
		protected WindowSetup() {
			maximized = false;
			width = WINDOW_DEFAULT_WIDTH;
			height = WINDOW_DEFAULT_HEIGHT;
		}
	}

- die Werte werden ausgelesen und in ein WindowSetup-Objekt geschrieben

	private void readWindowSetup(DesktopDAO dao, WindowSetup windowSetup) {
		if (dao == null) {
			LOGGER.warn("A problem while creating a DAO occured. It is still not initialized!");
		} else {
			Screen primaryScreen = Screen.getPrimary();
			Rectangle2D visualBounds = primaryScreen.getVisualBounds();
			try {
				Boolean lastMaximized = dao.getPreference(WINDOW_MAXIMIZED);
				Double lastWidth = dao.getPreference(WINDOW_WIDTH);
				if (lastWidth == null) {
					lastWidth = WINDOW_DEFAULT_WIDTH;
				}
				Double lastHeight = dao.getPreference(WINDOW_HEIGHT);
				if (lastHeight == null) {
					lastHeight = WINDOW_DEFAULT_HEIGHT;
				}
				if (visualBounds != null && lastWidth > visualBounds.getWidth() - 100) {
					lastWidth = visualBounds.getWidth() - 100;
				}
				if (visualBounds != null && lastHeight > visualBounds.getHeight() - 100) {
					lastHeight = visualBounds.getHeight() - 100;
				}
				windowSetup.maximized = lastMaximized == null ? false : lastMaximized.booleanValue();
				windowSetup.width = lastWidth == null ? WINDOW_DEFAULT_WIDTH : lastWidth.doubleValue();
				windowSetup.height = lastHeight == null ? WINDOW_DEFAULT_HEIGHT : lastHeight.doubleValue();
			} catch (DesktopDAOException e) {
				LOGGER.error("A problem occurred while reading the window preferences.", e);
			} catch (Exception e) {
				LOGGER.error("An unspecified problem occurred while reading the window preferences.", e);
			}
		}
	}

- während der Initilaisierung wird also folgendes gemacht

WindowSetup windowSetup = new WindowSetup();
readWindowSetup(dao, windowSetup);

Scene scene = new Scene(root, windowSetup.width, windowSetup.height);

Grüsse
dzim


Anmerkung: Die "Preferences" beziehen sich auf eine Key-Value-Tabelle in der DB, daher frage ich sie immer über den Key ab - das ist eher der banale Teil der DB, aber ich wollte nicht DB für Daten und Dateien für Config haben (eher geringe Grösse und Prefs waren ein "Abfallprodukt").