Swing - ustawienie pozycji okien (ramek).

Chodzi mi o to, żeby przy każdym uruchamianiu programu okno (główny JFrame) pojawiało się na środku a nie w lewym górnym rogu, tak samo przy tworzeniu własnego okna dialogowego. Próbuję z opcją :

frame.setLocationByPlatform(true);

ale okno pojawia się tak samo w lewym górnym rogu albo troszkę niżej ale nigdy na środku. Jest na to jakaś fukncja?

możesz użyć java.awt.Toolkit, żeby pobrać wymiary ekranu i wyliczyć gdzie powinien być lewy górny róg jFrame

Dla JFrame setLocationRelativeTo(null)

@bo - oczywiście działa:-)

@notexists - dzięki za to co podałeś, z pewnością kiedyś się przyda;-)

Witam.
A co muszę zrobić żeby znać na bieżąco wymiary JFrame?
Zrobiłem notatnik do programu, który wstawia raporty z dokonanych przez siebie obliczeń.
W moim oknie raporty wstawiam do JTextArea () i teraz chcę aby przy zmianie wielkości okna notatnika (JFrame) zmieniał się odpowiednio wymiar JTextArea ().
Na razie mój notatnik ma stałą wielkość i zablokowaną możliwość zmiany wielkości.

Dziękuje za wszelkie podpowiedzi.
Pozdrawiam Tomasz79

Notyfikować zmiany jego rozmiaru. Używasz listenera. Jak zwykle. To pewny sposób dający pełną kontrolę.

Właśnie nie wiem jakiego Listnera mam użyć, addWindowListener nie reaguje na zmiany wielkości okna?

ComponentListener

Dziękuje za pomoc.

Zaimplementuj interfejs ComponentListener i zarejestruj za pomocą
addComponentListener(ComponentListener l). Wtedy na bieżąco dostajesz zmieniane rozmiary okna (lub dowolnego komponentu)

Poniżej wrzuciłem przykładowy fragment kodu, dzięki któremu można zarządzać rozmieszczeniem okna. Albo przynajmniej zrozumieć co trzeba uwzględnić przy centrowaniu.

 
/** Klasa obsługująca wymiarowanie i centrowanie okna aplikacji */
abstract class Ramka implements Runnable
{
	private boolean zmaksymalizowane = false;
	protected JFrame r;

	protected Ramka(JFrame r)
	{
		updateLF(r);
		this.r = r;
	}

	Ramka(JFrame r, boolean zmaksymalizowane)
	{
		this(r);
		this.zmaksymalizowane = zmaksymalizowane;
	}

	/**
	 * Próbuje ustawić wygląd systemowy
	 */
	final public static void setSystemLF()
	{
		try
		{
			UIManager.setLookAndFeel(
				UIManager.getSystemLookAndFeelClassName());
		}
		catch(Exception e){}
		//UnsupportedLookAndFeelException, ClassNotFoundException
		//InstantiationException, IllegalAccessException*/
	}

	/**
	 * Aktualizuje wygląd całości komponentu ekranowego
	 * W trakcie aktualizacji zmienia kursor na klepsydrę, a po
	 * wykonaniu aktualizacji przywraca poprzedni stan kursora.
	 * @param c komponent do aktualizacji
	 */
	final public static void updateLF(Component c)
	{
		Cursor obecny = c.getCursor();
		c.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
		SwingUtilities.updateComponentTreeUI(c);
		c.validate();
		c.setCursor(obecny);
	}

	/**
	 * Dla r nadaje nazwę, ustawia jako główne okno, ustala wymiary i
	 * położenie, ewentualnie powiększa do maksimum i pokazuje na ekranie
	 */
	@Override public void run()
	{
		r.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		ustalWymiary();
		pozycjonujOkno();
		if(zmaksymalizowane)
			r.setExtendedState(JFrame.MAXIMIZED_BOTH);
		r.setVisible(true);
	}

	abstract protected void ustalWymiary(); //do zdefiniowania. Np. pack, setSize itp.

	/** Ustawia/przywraca początkową pozycję okna */
	protected void pozycjonujOkno()	{ centrujOkno(); }

	private void centrujOkno() { r.setLocation(punktCentrowania(r)); }

	static Point punktCentrowania(Component c)
	{
		//prostokąt ekranu w układzie współrzędnych
		Rectangle ekr = c.getGraphicsConfiguration().getBounds();
		//wielkości marginesów ekranu
		Insets mrgekr = Toolkit.getDefaultToolkit().getScreenInsets(
			c.getGraphicsConfiguration());
		Dimension okno = c.getSize();//wymiary okna
		//nowe miejsce okienka w lewym górnym rogu dostępnego ekranu
		return punktCentrowania(ekr, mrgekr, okno);
	}

	static Point punktCentrowania(final Rectangle ekr,
		final Insets mrgekr, Dimension okno)
	{
		Rectangle ok = new Rectangle(ekr.x, ekr.y, okno.width, okno.height);
		dopasujOkno(ok, ekr, mrgekr, true);
		return new Point(ok.x, ok.y);
	}

	static Rectangle dopasujOkno(Rectangle okno, final Rectangle ekr,
		final Insets mrgekr, boolean centruj)
	{
		final boolean w_poziomie = okno.width < ekr.width - (mrgekr.left + mrgekr.right);
		final boolean w_pionie = okno.height < ekr.height - (mrgekr.top + mrgekr.bottom);
		if(centruj)
			centruj(okno, ekr, w_poziomie, w_pionie);
		//Uwzględnianie marginesów ekranu (mrgekr)
		//ewentualnie przesuwamy początek okna przed l-g marginesy ekranu
		if(okno.x < ekr.x + mrgekr.left)
			okno.x += mrgekr.left;
		if(okno.y < ekr.y + mrgekr.top)
			okno.y += mrgekr.top;
		//Prawy dolny róg ekranu
		Point koniec_ekranu = new Point(
			ekr.x + ekr.width - mrgekr.right,
			ekr.y + ekr.height - mrgekr.bottom);
		//Prawy dolny róg okienka
		Point koniec_okna = new Point(okno.x + okno.width, okno.y + okno.height);
		//ewentualnie przesuwamy koniec okna przed p-d marginesy ekranu
		if(w_poziomie && koniec_ekranu.x < koniec_okna.x)
			okno.x -= koniec_okna.x - koniec_ekranu.x;
		if(w_pionie && koniec_ekranu.y < koniec_okna.y)
			okno.y -= koniec_okna.y - koniec_ekranu.y;
		return okno;
	}

	static void centruj(Rectangle okno, final Rectangle ekr,
	boolean w_poziomie, boolean w_pionie)
	{//nowy punkt zaczepienia okna jeżeli centrowanie nie jest możliwe
		okno.x = ekr.x;
		okno.y = ekr.y;
		//centrujemy pod warunkiem, że rozmiar okna mieści się w 
		//ekranie ograniczonym przez marginesy z obu stron
		if(w_poziomie)
			okno.x += (ekr.width >> 1) - (okno.width >> 1);
		if(w_pionie)
			okno.y += (ekr.height >> 1) - (okno.height >> 1);
	}
}

class RamkaDopasowana extends Ramka
{
	RamkaDopasowana(JFrame r, boolean maks) { super(r, maks); }

	@Override protected void ustalWymiary() { r.pack(); }
}

class RamkaUstalona extends Ramka
{
	RamkaUstalona(JFrame r, int sz, int wy)
	{
		super(r);
		szer = sz;
		wys = wy;
	}

	@Override protected void ustalWymiary() { r.setSize(szer, wys); }

	private int szer, wys;
}

Przecież do tego co chce tomasz79 wystarczy najprostszy zarządca rozkładem.