DiagonalLayout - Versionsgeschichte

L-ectron-X am 2. April 2018 um 16:04 Uhr

2018-04-02T16:04:07Z

← Nächstältere Version		Version vom 2. April 2018, 16:04 Uhr
Zeile 423:		Zeile 423:
	*[[LayoutManager der Standard-Java-API]]		*[[LayoutManager der Standard-Java-API]]

	[[Kategorie:~~Java~~]]		[[Kategorie:LayoutManager]]
	[[Kategorie:Tutorials (Java)]]		[[Kategorie:Tutorials (Java)]]
	[[Kategorie:Swing]]		[[Kategorie:Swing]]

	--[[Benutzer:Volvagia\|Volvagia]] (06.11.2012, 04:01 Uhr)		--[[Benutzer:Volvagia\|Volvagia]] (06.11.2012, 04:01 Uhr)

L-ectron-X am 15. März 2018 um 17:25 Uhr

2018-03-15T17:25:19Z

Änderungen zeigen

L-ectron-x: /* Quellen und Weiterführendes Material */

2017-07-06T06:34:14Z

Quellen und Weiterführendes Material

← Nächstältere Version		Version vom 6. Juli 2017, 06:34 Uhr
Zeile 421:		Zeile 421:
	=Quellen und Weiterführendes Material=		=Quellen und Weiterführendes Material=
	*http://docs.oracle.com/javase/tutorial/uiswing/layout/custom.html		*http://docs.oracle.com/javase/tutorial/uiswing/layout/custom.html
	*[LayoutManager]		*[[LayoutManager der Standard-Java-API]]

	[[Kategorie:Java]]		[[Kategorie:Java]]

L-ectron-x: /* Quellen und Weiterführendes Material */

2017-07-06T06:33:06Z

Quellen und Weiterführendes Material

← Nächstältere Version		Version vom 6. Juli 2017, 06:33 Uhr
Zeile 421:		Zeile 421:
	=Quellen und Weiterführendes Material=		=Quellen und Weiterführendes Material=
	*http://docs.oracle.com/javase/tutorial/uiswing/layout/custom.html		*http://docs.oracle.com/javase/tutorial/uiswing/layout/custom.html
			*[LayoutManager]

	[[Kategorie:Java]]		[[Kategorie:Java]]

L-ectron-x am 27. April 2014 um 16:56 Uhr

2014-04-27T16:56:28Z

← Nächstältere Version		Version vom 27. April 2014, 16:56 Uhr
Zeile 421:		Zeile 421:
	=Quellen und Weiterführendes Material=		=Quellen und Weiterführendes Material=
	*http://docs.oracle.com/javase/tutorial/uiswing/layout/custom.html		*http://docs.oracle.com/javase/tutorial/uiswing/layout/custom.html

			[[Kategorie:Java]]
			[[Kategorie:Tutorials (Java)]]
			[[Kategorie:Swing]]

	--[[Benutzer:Volvagia\|Volvagia]] (06.11.2012, 04:01 Uhr)		--[[Benutzer:Volvagia\|Volvagia]] (06.11.2012, 04:01 Uhr)

L-ectron-x: /* Praxis - LayoutManager */

2014-04-27T16:49:08Z

Praxis - LayoutManager

← Nächstältere Version		Version vom 27. April 2014, 16:49 Uhr
Zeile 64:		Zeile 64:
	=Praxis - LayoutManager=		=Praxis - LayoutManager=

	Ich habe mich für einen LayoutManager entschieden, der die Compontents diagional anordnet (DiagonalLayout). Das heißt, der nächste Component wird genau ein Pixel weiter unten/rechts als die untere rechte Ecke des vorherigen platziert. Da dieser Manager keine ~~{{JAPI\|~~Constraints}} abspeichert, implementieren wir das Interface LayoutManager . Da die add()-Methode des LayoutManagers nur in seltensten Fällen sinnvoll ist, holen wir die Components direkt vom Parent.		Ich habe mich für einen LayoutManager entschieden, der die Compontents diagional anordnet (DiagonalLayout). Das heißt, der nächste Component wird genau ein Pixel weiter unten/rechts als die untere rechte Ecke des vorherigen platziert. Da dieser Manager keine Constraints abspeichert, implementieren wir das Interface LayoutManager . Da die add()-Methode des LayoutManagers nur in seltensten Fällen sinnvoll ist, holen wir die Components direkt vom Parent.

	Zuerst müssen wir einmal wissen, was genau geschrieben werden soll. Wir überlegen also, was in den verschiedenen Methoden wie gemacht werden soll:		Zuerst müssen wir einmal wissen, was genau geschrieben werden soll. Wir überlegen also, was in den verschiedenen Methoden wie gemacht werden soll:

L-ectron-x: /* Theorie */

2014-04-27T16:47:24Z

Theorie

← Nächstältere Version		Version vom 27. April 2014, 16:47 Uhr
Zeile 1:		Zeile 1:
	=Theorie=		=Theorie=
	Es besteht neben den vordefinierten {{JAPI\|LayoutManager}}n der JRE-Standartbibliothek und externen APIs natürlich die Möglichkeit, eigene Manager zu entwickeln. Jeder, der schon einmal mit "Null-Layout" gearbeitet hat, weiß, dass ~~{{JAPI\|Component}}s~~ mit den [[Methode\|Methoden]] <code>setLocation()</code> und <code>setSize()</code> bzw. gleichzeitig per <code>setBounds()</code> ihre Position und Größe vorgegeben werden. Der LayoutManager macht das Selbe mit dem Unterschied, dass er von den Komponenten auf dem er sitzt entkoppelt ist und so leicht wiederverwendet werden kann. Etwas ähnliches könnte man eigendlich nur mit einem {{JAPI\|ComponentListener}} erreichen, der dafür bei Weitem nicht optimal ist.		Es besteht neben den vordefinierten {{JAPI\|LayoutManager}}n der JRE-Standartbibliothek und externen APIs natürlich die Möglichkeit, eigene Manager zu entwickeln. Jeder, der schon einmal mit "Null-Layout" gearbeitet hat, weiß, dass Components mit den [[Methode\|Methoden]] <code>setLocation()</code> und <code>setSize()</code> bzw. gleichzeitig per <code>setBounds()</code> ihre Position und Größe vorgegeben werden. Der LayoutManager macht das Selbe mit dem Unterschied, dass er von den Komponenten auf dem er sitzt entkoppelt ist und so leicht wiederverwendet werden kann. Etwas ähnliches könnte man eigendlich nur mit einem {{JAPI\|ComponentListener}} erreichen, der dafür bei Weitem nicht optimal ist.

	Um einen LayoutManager zu schreiben, gibt es prinzipiell 2 Wege:<br>		Um einen LayoutManager zu schreiben, gibt es prinzipiell 2 Wege:<br>
	Man implementiert das Interface {{JAPI\|LayoutManager}} oder {{JAPI\|LayoutManager2}}. Dabei wird '''LayoutManager''' benutzt, falls das Hinzufügen ohne Parameter stattfindet. Ein Beispiel wäre das [[FlowLayout]], welches einfach der Reihe nach anordnet. Diese holen sich die Components direkt vom Parent, da sie keine weiteren Informationen abspeichern müssen. Hingegen wird '''LayoutManager2''' benutzt, falls ein Parameter (genannt ~~{{JAPI\|~~Constraints}}) wärend des Hinzufügens übergeben werden soll. Ein Beispiel wäre das [[BorderLayout]], welches mit 5 Strings arbeitet, um die Position des Components anzugeben. Für den Parent des '''LayoutManager'''s spielt es keine Rolle, welches [[Interface]] benutzt wird. Es wird meistens von dem Component auf dem das Layout sitzt geprüft, um welches Interface es sich handelt und so die demensprechende Action durchgeführt. '''LayoutManager2''' erweitert '''LayoutManager''' und hat so auch Methoden, die es eigendlich nicht benötigt.		Man implementiert das Interface {{JAPI\|LayoutManager}} oder {{JAPI\|LayoutManager2}}. Dabei wird '''LayoutManager''' benutzt, falls das Hinzufügen ohne Parameter stattfindet. Ein Beispiel wäre das [[FlowLayout]], welches einfach der Reihe nach anordnet. Diese holen sich die Components direkt vom Parent, da sie keine weiteren Informationen abspeichern müssen. Hingegen wird '''LayoutManager2''' benutzt, falls ein Parameter (genannt Constraints) wärend des Hinzufügens übergeben werden soll. Ein Beispiel wäre das [[BorderLayout]], welches mit 5 Strings arbeitet, um die Position des Components anzugeben. Für den Parent des '''LayoutManager'''s spielt es keine Rolle, welches [[Interface]] benutzt wird. Es wird meistens von dem Component auf dem das Layout sitzt geprüft, um welches Interface es sich handelt und so die demensprechende Action durchgeführt. '''LayoutManager2''' erweitert '''LayoutManager''' und hat so auch Methoden, die es eigendlich nicht benötigt.

	==Methoden von {{JAPI\|LayoutManager}}==		==Methoden von {{JAPI\|LayoutManager}}==

L-ectron-x: /* Theorie */

2014-04-27T16:43:53Z

Theorie

← Nächstältere Version		Version vom 27. April 2014, 16:43 Uhr
Zeile 3:		Zeile 3:

	Um einen LayoutManager zu schreiben, gibt es prinzipiell 2 Wege:<br>		Um einen LayoutManager zu schreiben, gibt es prinzipiell 2 Wege:<br>
	Man implementiert das Interface {{JAPI\|LayoutManager}} oder {{JAPI\|LayoutManager2}}. Dabei wird '''LayoutManager''' benutzt, falls das Hinzufügen ohne Parameter stattfindet. Ein Beispiel wäre das [[FlowLayout]], welches einfach der Reihe nach anordnet. Diese holen sich die Components direkt vom Parent, da sie keine weiteren Informationen abspeichern müssen. Hingegen wird '''LayoutManager2''' benutzt, falls ein Parameter (genannt {{JAPI\|~~Constraint~~}}) wärend des Hinzufügens übergeben werden soll. Ein Beispiel wäre das [[BorderLayout]], welches mit 5 Strings arbeitet, um die Position des Components anzugeben. Für den Parent des '''LayoutManager'''s spielt es keine Rolle, welches [[Interface]] benutzt wird. Es wird meistens von dem Component auf dem das Layout sitzt geprüft, um welches Interface es sich handelt und so die demensprechende Action durchgeführt. '''LayoutManager2''' erweitert '''LayoutManager''' und hat so auch Methoden, die es eigendlich nicht benötigt.		Man implementiert das Interface {{JAPI\|LayoutManager}} oder {{JAPI\|LayoutManager2}}. Dabei wird '''LayoutManager''' benutzt, falls das Hinzufügen ohne Parameter stattfindet. Ein Beispiel wäre das [[FlowLayout]], welches einfach der Reihe nach anordnet. Diese holen sich die Components direkt vom Parent, da sie keine weiteren Informationen abspeichern müssen. Hingegen wird '''LayoutManager2''' benutzt, falls ein Parameter (genannt {{JAPI\|Constraints}}) wärend des Hinzufügens übergeben werden soll. Ein Beispiel wäre das [[BorderLayout]], welches mit 5 Strings arbeitet, um die Position des Components anzugeben. Für den Parent des '''LayoutManager'''s spielt es keine Rolle, welches [[Interface]] benutzt wird. Es wird meistens von dem Component auf dem das Layout sitzt geprüft, um welches Interface es sich handelt und so die demensprechende Action durchgeführt. '''LayoutManager2''' erweitert '''LayoutManager''' und hat so auch Methoden, die es eigendlich nicht benötigt.

	==Methoden von {{JAPI\|LayoutManager}}==		==Methoden von {{JAPI\|LayoutManager}}==
Zeile 61:		Zeile 61:
	/Wird immer aufgerufen, wenn der Parent als invalid gekenntzeichnet wird, also es einer neuen Anordnung bedarf./		/Wird immer aufgerufen, wenn der Parent als invalid gekenntzeichnet wird, also es einer neuen Anordnung bedarf./
	invalidateLayout(Container target)</code=java>		invalidateLayout(Container target)</code=java>


	=Praxis - LayoutManager=		=Praxis - LayoutManager=

L-ectron-x: /* Praxis - LayoutManager */

2014-04-27T16:42:06Z

Praxis - LayoutManager

← Nächstältere Version		Version vom 27. April 2014, 16:42 Uhr
Zeile 65:		Zeile 65:
	=Praxis - LayoutManager=		=Praxis - LayoutManager=

	Ich habe mich für einen LayoutManager entschieden, der die Compontents diagional anordnet (DiagonalLayout). Das heißt, der nächste Component wird genau ein Pixel weiter unten/rechts als die untere rechte Ecke des vorherigen platziert. Da dieser Manager keine Constraints abspeichert, implementieren wir das Interface LayoutManager . Da die add-Methode des LayoutManagers nur in seltensten Fällen sinnvoll ist, holen wir die Components direkt vom Parent.		Ich habe mich für einen LayoutManager entschieden, der die Compontents diagional anordnet (DiagonalLayout). Das heißt, der nächste Component wird genau ein Pixel weiter unten/rechts als die untere rechte Ecke des vorherigen platziert. Da dieser Manager keine {{JAPI\|Constraints}} abspeichert, implementieren wir das Interface LayoutManager . Da die add()-Methode des LayoutManagers nur in seltensten Fällen sinnvoll ist, holen wir die Components direkt vom Parent.

	Zuerst müssen wir einmal wissen, was genau geschrieben werden soll. Wir überlegen also, was in den verschiedenen Methoden wie gemacht werden soll:		Zuerst müssen wir einmal wissen, was genau geschrieben werden soll. Wir überlegen also, was in den verschiedenen Methoden wie gemacht werden soll:

	<code=java>addLayoutComponent(String, Component)</code=java>		<code=java>addLayoutComponent(String, Component)</code=java>
	Da wir keinen String oder ~~Constrains~~ übergeben, wird dazu eigendlich nur add(Component) verwendet. Da die Methode da nicht aufgerufen wir implementieren wir sie leer.		Da wir keinen {{JAPI\|String}} oder {{JAPI\|Constraints}} übergeben, wird dazu eigendlich nur <code>add(Component)</code> verwendet. Da die Methode da nicht aufgerufen wir implementieren wir sie leer.


Zeile 78:		Zeile 78:

	<code=java>layoutContainer(Container)</code=java>		<code=java>layoutContainer(Container)</code=java>
	Hier werden wie gesagt die ~~Componenten~~ angeordnet. Dazu wird zuerst eine Variable definiert, um die aktuelle Position der Anordnung zu speichern. Danach werden die ~~Component en~~ des Parents durchgelaufen, an die aktuelle Position gesetzt und die Position wird um die ~~Preferred Size~~ nach rechts unten verschoben.		Hier werden wie gesagt die Components angeordnet. Dazu wird zuerst eine Variable definiert, um die aktuelle Position der Anordnung zu speichern. Danach werden die Components des Parents durchgelaufen, an die aktuelle Position gesetzt und die Position wird um die PreferredSize nach rechts unten verschoben.


Zeile 85:		Zeile 85:


	</code=java>minimumLayoutSize(Container)</code=java>		<code=java>minimumLayoutSize(Container)</code=java>
	Da ich keinen Grund sehe eine minimale Größe festzulegen, wird hier 0/0 zurückgegeben.		Da ich keinen Grund sehe, eine minimale Größe festzulegen, wird hier 0/0 zurückgegeben.


Zeile 115:		Zeile 115:
	}		}
	</code=java>		</code=java>
	Ok. Nun müssen wir die ~~Componenten~~ erstmal anordnen. Als erstes (was ich allzu gerne vergesse) ist die Breite des Rahmens. Auch mit Rahmen ist 0/0 ganz links oben (bei normaler Ausrichtung), die ~~Component en~~ würde als über den Rahmen gezeichnet werden. Die Größe des Rahmens wird in den Insets genannten Objekt von ~~einen~~ Component geliefert:		Ok. Nun müssen wir die Components erstmal anordnen. Als erstes (was ich allzu gerne vergesse) ist die Breite des Rahmens. Auch mit Rahmen ist 0/0 ganz links oben (bei normaler Ausrichtung), die Components würde als über den Rahmen gezeichnet werden. Die Größe des Rahmens wird in den Insets genannten Objekt von einem Component geliefert:
	<code=java>		<code=java>
	public void layoutContainer(Container parent) {		public void layoutContainer(Container parent) {
Zeile 128:		Zeile 128:
	}		}
	</code=java>		</code=java>
	Ein Point ist einfach ein ~~Wrappler~~ für 2 int's, in der Regel gibt er einen Punkt auf ~~einen~~ 2-Dimensionalen Raster an. (Die Variablen sind public und heißen x und y.)		Ein {{JAPI\|Point}} ist einfach ein Wrapper für 2 int's, in der Regel gibt er einen Punkt auf einem 2-Dimensionalen Raster an. (Die Variablen sind public und heißen x und y.)

	Nun müssen wir in einer kleinen Schleife nur alle ~~Componenten~~ durchgehen und an die linke untere Ecke des letzten ~~Component s~~ setzen. Dazu müssen wir nur die Größe auf die eigene bevorzugte Größe setzen und diese zu den Koordinaten (offs) addieren. Außerdem überspringen wir unsichtbare ~~Component s~~, da sonst Lücken entstehen würden.		Nun müssen wir in einer kleinen Schleife nur alle Components durchgehen und an die linke untere Ecke des letzten Components setzen. Dazu müssen wir nur die Größe auf die eigene bevorzugte Größe setzen und diese zu den Koordinaten (offs) addieren. Außerdem überspringen wir unsichtbare Components, da sonst Lücken entstehen würden.
	<code=java>		<code=java>
	public void layoutContainer(Container parent) {		public void layoutContainer(Container parent) {
Zeile 176:		Zeile 176:
	}		}
	</code=java>		</code=java>
	Statt einen Point verwenden wir nun eine Dimension , da wir die Größe und keine Position speichern wollen. Außerdem addieren wir zu der optimalen Größe noch die untere Höhe und rechte Breite des Rahmens hinzu.		Statt einen {{JAPI\|Point}} verwenden wir nun eine {{JAPI\|Dimension}} , da wir die Größe und keine Position speichern wollen. Außerdem addieren wir zu der optimalen Größe noch die untere Höhe und rechte Breite des Rahmens hinzu.

	Nun schreiben wir uns noch eine kurze ~~Main~~-Methode, um das Layout auch testen zu können:		Nun schreiben wir uns noch eine kurze main()-Methode, um das Layout auch testen zu können:
	<code=java>		<code=java>
	public static void main(String[] args) {		public static void main(String[] args) {
Zeile 206:		Zeile 206:
	}		}
	</code=java>		</code=java>
	Durch die pref. Size des ContentPanes setzt das JFrame auch die richtige Größe, und zeigt wie erwartet alle ~~Component s~~ in einer diagionalen Linie an:		Durch die pref. Size des ContentPanes setzt das {{JAPI\|JFrame}} auch die richtige Größe, und zeigt wie erwartet alle Components in einer diagionalen Linie an:

	[[Datei:DiagonalLayout.png]]		[[Datei:DiagonalLayout.png]]
Zeile 215:		Zeile 215:
	offs.setLocation(offs.x + j, offs.y + j);		offs.setLocation(offs.x + j, offs.y + j);
	</code=java>		</code=java>
	Aber da es sich um mathematische Grundlagen handelt und solange es nicht wirklich zu kompliziert wird (sollte das der Fall sein denkt darüber nach, ob sich 2 verschaltete ~~Component s~~ mit unterschiedlichen ~~Layout s~~ nicht besser eignen würden) sollte es jeden einfach fallen, sein Layout seinen Wünschen anzupassen.		Aber da es sich um mathematische Grundlagen handelt und solange es nicht wirklich zu kompliziert wird (sollte das der Fall sein denkt darüber nach, ob sich 2 verschaltete Components mit unterschiedlichen Layouts nicht besser eignen würden) sollte es jeden einfach fallen, sein Layout seinen Wünschen anzupassen.


	=Praxis - LayoutManager2=		=Praxis - LayoutManager2=

L-ectron-x am 27. April 2014 um 16:35 Uhr

2014-04-27T16:35:07Z

Änderungen zeigen