JFrame Minimalgröße festlegen

[Ulfmann]

Hallo Leute,

ich finde keine (verständliche) Lösung bei folgender Sache. Mein JFrame soll - ausgehend von der Initialgröße - vergrößerbar und verkleinerbar sein. Allerdings soll er nicht beliebig klein gemacht werden können. Die mehrmals beschriebene Variante, dass sich nach dem Resize-Event eine Größe in der Art von setPreferedSize(); einstellt und der JFrame zu dieser Größe "springt" gefällt mir nicht.

Ich würde es schön finden, wenn man den JFrame nur bis zu bestimmten Abmessungen verkleinern kann und weiteres Verkleinern ab da "blockiert" ist. oder - womit ich mich auch anfreunden könnte - dass ab einer bestimmten Größe Scollbalken am Rand des JFrames erscheinen.

Bin für jeden Tipp dankbar.

[speedi]

Falls es mit setMinimumSize nicht funktioniert überschreib doch einfach die setBounds(int x, int y, int width, int height) des JFrames:

public void setBounds(int x, int y, int width, int height){

     if(width < minimumWidth){

           width = minimumWidth;

     }


     if(height < minimumHeight){

           height = minimumHeight;

     }


     super.setBounds(int x, int y, int width, int height);

}

[breeZer87]

Hallo,

ja dieses Problem hatte ich auch letztens. Ich habe es über den ComponentListener gelöst, ist zwar nicht die beste Lösung aber es funktioniert.

Ich schreibe erstmal kein Code hier rein, erstma selber probieren

EDIT: Achso man sollte auch den Text richtig lesen :upps . Ich würde mich auch für eine Lösung interressieren, wo das Fenster "blockiert" wird. Ich hab es bis jetzt nur über die componentResized methode gelöst.

Bearbeitet 21. Januar 2009 von breeZer87

[Ulfmann]

Danke für die schnellen Antworten.

Ich glaub aber, ich bin grad echt zu blöd, bzw. ich check's nicht.

public class MainWindow 

extends JFrame 

{

	int x;

	int y;

	int width;

	int height;

	int minimumWidth = 700;

	int minimumHeight = 700;


	public MainWindow()

	{

		super ("Hauptmenü");

		setBounds(x, y, width, height);

		setLayout(null);

		setJMenuBar (new MainMenuBar());

	}


	public void setBounds(int x, int y, int width, int height)

	{

		x      = 750;

		y      = 70;

		width  = 1000;

		height = 1000;


		if ((width = this.getWidth()) < minimumWidth)

		{

			width = minimumWidth;

		}


		if ((height = this.getHeight()) < minimumHeight)

		{

			height = minimumHeight;

		}


		super.setBounds(x, y, width, height);

	}

}

Jetzt malt er das Fenster in der Größe, in der es mindestens dargestellt werden soll (also 700x700 und nich 1000x1000).

Was ich mich auch noch frage, ob hier nichn Event ausgelöst wird. Also jemand muss doch quasi beobachten, ob der JFrame kleiner geworden is oder nich und dann entsprechend reagieren.

Oder nich ?!

[breeZer87]

public class ComponentHoerer implements ComponentListener {

        public void componentHidden(ComponentEvent e) {

		// TODO Auto-generated method stub


	}


	public void componentMoved(ComponentEvent e) {

		// TODO Auto-generated method stub


	}


	public void componentResized(ComponentEvent e) {

		// TODO Auto-generated method stub}

                hier vergleichst du die aktuelle größe mit der minimalengröße


        }


	public void componentShown(ComponentEvent e) {

		// TODO Auto-generated method stub


	}

wie gesagt hier "springt" das fenster dann zurück sobald du das fenster zu klein machst

achja du musst natürlich noch den listener dem frame hinzufügen

[speedi]

Danke für die schnellen Antworten.

Ich glaub aber, ich bin grad echt zu blöd, bzw. ich check's nicht.

Jetzt malt er das Fenster in der Größe, in der es mindestens dargestellt werden soll (also 700x700 und nich 1000x1000)

klar. Du sagst es ihm ja auch, dass er das machen soll.

Mal abgesehen, davon dass ich mittlerweile herausgefunden habe, dass die Größenänderung mit der Maus bei JFrames leider doch nicht über die setBounds-Methode geht könnte dein Code auch so nicht funktionieren.

du setzt die neue Größe immer 1000x1000 und deine Linke obere Ecke immer auf den Punkt (750|70).

breeZer87 hat eine gute Vriante vorgeschlagen. Einfach die neue größe mit der mindestgröße vergleichen und ggf. über setSize() korrigieren.

Bearbeitet 21. Januar 2009 von speedi

[Ulfmann]

OK cool, vielen Dank!

Ich habs mit der ComponentListener-Variante hinbekommen. Es ist zwar immernoch nicht das, was ich wollte, aber es bringt mich schonmal weiter.

Eine Sache noch: Wenn ich nun meine Anwendung starte und zwischen einzelnen Panels hin und her zappe (die ihrerseits auch wieder einige Komponenten beinhalten), reagiert das Fenster unheimlich träge auf das ComponentEvent und ändert seine Größe entsprechend lahm und verzögert. Ist das jetzt einer der oft kritisierten Nachteile von Swing? Ich mags immer nicht, wenn Java nachgesagt wird, es sei langsam, aber das ist wohl ab einer bestimmten Komplexität nicht mehr zu leugnen.

Seh ich das richtig ?

[Wayne]

Mag sein, dass ich da etwas nicht so ganz verstehe aber warum benutzt du nicht einfach wie von speedi vorgeschlagen setMinimumSize()?

JFrame frame = new JFrame();

frame.setMinimumSize(new Dimension(500,500));

[...]

Somit ist es nicht möglich das Frame kleiner als die von dir gewünschte Größe zu ziehen. Dabei "springt" nichts zurück sondern wie von dir gewünscht blockiert das Frame den Versuch es noch kleiner zu machen.

[Ulfmann]

Hast du das mal getestet? Bei mir passiert dann nichts.

Das Grundprinzip leuchtet mir schon ein, aber dennoch frage ich mich bei deinem Vorschlag, wie der JFrame (bzw. die Komponente, die auf die Größe aufpassen soll) denn wissen soll, dass das Fenster vom Benutzer verkleinert wurde.

Und selbst sowas klappt nich:

	public void componentResized(ComponentEvent c) 

	{

		frame.setMinimumSize(new Dimension(500,500));

	}

Gruß

[Ulfmann]

Dafür hab ich grad folgendes ausprobiert:

	public void componentResized(ComponentEvent c) 

	{

		currentWidth  = this.getWidth();

		currentHeight = this.getHeight();


		if (currentWidth < minimumWidth)

		{

			setResizable(false);


		}

		if (currentHeight < minimumHeight)

		{

			setResizable(false);

		}

		setResizable(true);

	}

Auf diese Weise lässt mein JFrame kein weiteres Verkleinern zu, sobald ich die Minimumgrenzen überschreiten will, was den gewünschten Blockiereffekt auslöst. Was mich daran aber ein wenig stört, ist, dass das Fenster etwas flackert, wenn setResizable() auf false und dann wieder auf true gesetzt wird. Die Idee, war, dass der Benutzer das Fenster ja durchaus wieder vergrößern können soll, auch wenn er die an die Minimumgrenze(n) gestoßen ist und daher setResizable(true); unumgänglich ist.

Was denkt ihr?

Bearbeitet 22. Januar 2009 von Ulfmann

[Wayne]

Versuchs mal damit.

import java.awt.Dimension;

import java.awt.GridLayout;


import javax.swing.JButton;

import javax.swing.JFrame;



public class Fraime {


	/**

	 * @param args

	 */

	public static void main(String[] args) {

		JFrame frame = new JFrame("FrameMyAss");

		frame.setLayout(new GridLayout(0,2));

		frame.setMinimumSize(new Dimension(400,200));

		frame.setPreferredSize(new Dimension(500,500));

		frame.add(new JButton("Klacky"));

		frame.add(new JButton("Klecky"));

		frame.add(new JButton("Klicky"));

		frame.add(new JButton("Klocky"));

		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		frame.pack();

		frame.setVisible(true);

	}


}

[speedi]

Die Variante mit setMinimumSize sollte eigentlich funktionieren.

Bei deiner Variante kannst du auch anders arbeiten als mit setResizable(false):

	public void componentResized(ComponentEvent c) 

	{

		currentWidth  = this.getWidth();

		currentHeight = this.getHeight();


		if (currentWidth < minimumWidth)

		{

			setSize(minimumWidth, getHeight());


		}

		if (currentHeight < minimumHeight)

		{

		        setSize(getWidth(), minimumHeight);

		}

	}

Leider wird die componentResized-Methde erst gerufen, wenn die Größenänderung komplett abgeschlossen ist. Das bedeutet du kannst dein Frame immer noch kleiner ziehen als die Minimalgröße. Sobald du aber die Maus los lässt springt es zurück auf das was es haben soll.

Besser wäre, du findest heraus was du falsch machst, das setMinimumSize bei dir nicht funktioniert. Du rufst du setMinimumSize aber schon von JFrame und nicht vom ConteentPane des JFrames oder?

Bearbeitet 22. Januar 2009 von speedi

[Ulfmann]

@ Wayne: Ich habs so übernommen, wie von dir gepostet.

Was soll da jetzt passieren? Ich kann die Größe beliebig ändern - auch kleiner als (400,200), also die MinimumSize. Er tut nichts, wie auch ohne EventListener ?!

@ Speedi:

Das funktioniert auch, bloß mit dem Unterschied, dass er dann wieder auf die MinimumSize springt und nicht ein weiteres Kleinermachen blockiert. Und ja, ich rufe setminimumSize über den JFrame auf. Wie gesagt, es funktioniert ja, aber nicht so wie ich es mir vorgestellt hab.

Danke aber für eure Beteiligung. Gerne weitere Gedanken dazu.

Bearbeitet 22. Januar 2009 von Ulfmann

[Wayne]

@ Wayne: Ich habs so übernommen, wie von dir gepostet.

Was soll da jetzt passieren? Ich kann die Größe beliebig ändern - auch kleiner als (400,200), also die MinimumSize. Er tut nichts, wie auch ohne EventListener ?!

[...]

Erstell eine neue Klasse. Copy&Paste meine komplette main-Methode in die Klasse. Füge die nötigen imports ein. Führe die Klasse aus.

Wenn es dann immer noch nicht funktioniert, dann ist etwas beim kopieren verloren gegangen, wir verstehen uns grundlegend falsch oder ich hab ein "anderes Java" als du.

Ich bekomme mit dem von mir gezeigten Code den Frame nicht kleiner als die angegebene MinimumSize sogar ohne einen eigenen Listener.

Bearbeitet 22. Januar 2009 von Wayne

[breeZer87]

also es müsste auch mit setMinimumSize() + setPreferredSize() gehen, allerdings glaub ich erst ab java 1.6.

hier auf arbeit hab ich 1.4 und die methoden kennt mein frame garnicht.

[Ulfmann]

Ich arbeite mit Version 1.5.

Ich hab natürlich alles so gemacht, wie von dir beschrieben (alles andere wäre ja Schwachsinn:) ) aber das tut eben nicht das, was ich will.

Mir ist auch noch nicht klar, was gegen die setResizable(false)-Variante spricht. Angenommen ich würde überhaupt nicht wollen, dass man die Fenstergröße ändern kann. In dem Fall würde man ja auch von vornherein unterbinden, dass man's kann und nicht durch setPreferedSize(); Und ich will das eben eingeschränkt, ab nem gewissen Punkt.

[Wayne]

breeZer87 hat Recht und setMiniumSize() ist erst ab Java 6 verfügbar. Java Doc

Und da du sagst, du arbeitest mit Java 5, dürfte der Code gar nicht erst kompilieren. Unter "aber das tut eben nicht das, was ich will" verstehe ich persönlich etwas anderes.

[Edit:]

Ok, offensichtlich gibt es setMinimumSize auch unter Java 5. Java Doc

Scheinbar existieren da Unterschiede. während Java 6 MinimumSize von java.awt.Window kommt ists in Java 5 java.awt.Component. Keine Ahnung wo genau da die Unterschiede bestehen

Bearbeitet 22. Januar 2009 von Wayne