Anchor Sides/de: what changed

Revision 5 to 6. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		Es gibt einige neue Eigenschaften und Methoden für das automatische Layout von Steuerelementen. Sie können jetzt Bedienelemente so einstellen, dass sie einen bestimmten Abstand zu anderen Bedienelementen einhalten, oder relativ zu anderen Bedienelementen zentrieren. Siehe unten für Beispiele.
2	2
3	3		Jede der vier Seiten eines Bedienelements (Left, Top, Right, Bottom) kann jetzt verankert/angebunden werden an der Seite eines anderen Bedienelements. Zum Beispiel können Sie jetzt die linke Seite eines TEdit an der rechten Seite eines TLabel verankern. Jedes Mal, wenn das Label bewegt wird oder in der Größe angepasst wird, dann wird die linke Seite des Edit folgen, was normalerweise zu einer Bewegung des Edit parallel zum Label führt.
4	4
5	5		# Beispiel 1
6	6
7		-	~~```~~
	7	+	```text
8	8		+--------+ +-------+
9	9		\| Label1 \| \| Edit1 \|
10	10		+--------+ \| \|
11	11		+-------+
12	12		```
13	13
14	14		## Im Code
15	15
16	16		``` pascal
17	17		Edit1.AnchorSide[akLeft].Side:=asrRight;
18	18		Edit1.AnchorSide[akLeft].Control:=Label1;
19	19		Edit1.Anchors:=Edit1.Anchors+[akLeft];
20	20		```
21	21
22	22		Sie können den Abstand mit den Eigenschaften von BorderSpacing definieren:
23	23
24	24		``` pascal
25	25		Edit1.BorderSpacing.Left:=10;
26	26		```
27	27
28	28		Das selbe kann mit der Methode gemacht werden:
29	29
30	30		``` pascal
31	31		Edit1.AnchorToNeighbour(akLeft,10,Label1);
32	32		```
33	33
34	34		## Anmerkungen
35	35
36	36		Edit1.Left wird Label1.Left+Label1.Width folgen, nicht umgekehrt. Das bedeutet, dass eine Bewegung von Label1 auch Edit1 bewegen wird. Aber eine Bewegung von Edit1 wird von der LCL annulliert. Wenn Sie auch die rechte Seite von Label1 an der linken Seite von Edit1 verankern, dann erzeugen sie einen Kreis. Dies kann zusammen mit einigen anderen Autosize-Eigenschaften eine Endlosschleife verursachen. Ist Parent.AutoSize auf true gesetzt, wird dies von der LCL ignoriert oder automatisch repariert.
37	37
38	38		## Mittels des Ankereditors
39	39
40	40		Der Ankereditor ist ein schwebendes Fenster, den Sie erreichen über das Menü Ansicht / Ankereditor anzeigen oder über die Schaltfläche in der Eigenschaft Anchors des Objektinspektors.
41	41
42	42		![](/wiki-images/d/dd/Anchor_Editor_de.png)
43	43
44	44		# Beispiel 2
45	45
46	46		Sie können die obere Seite von Edit1 so verankern, dass sie der oberen Seite von Label1 folgt:
47	47
48	48		+--------+ +-------+
49	49		\| Label1 \| \| Edit1 \|
50	50		+--------+ \| \|
51	51		+-------+
52	52
53	53		``` pascal
54	54		Edit1.AnchorSide[akTop].Side:=asrTop;
55	55		Edit1.AnchorSide[akTop].Control:=Label1;
56	56		Edit1.Anchors:=Edit1.Anchors+[akTop];
57	57		```
58	58
59	59		Das selbe kann mit der Methode gemacht werden:
60	60
61	61		``` pascal
62	62		Edit1.AnchorParallel(akTop,0,Label1);
63	63		```
64	64
65	65		# Beispiel 3
66	66
67	67		Vertikale Zentrierung von Label1 an Edit1:
68	68
69	69		+-------+
70	70		+--------+ \| \|
71	71		\| Label1 \| \| Edit1 \|
72	72		+--------+ \| \|
73	73		+-------+
74	74
75	75		``` pascal
76	76		Edit1.AnchorSide[akTop].Side:=asrCenter;
77	77		Edit1.AnchorSide[akTop].Control:=Label1;
78	78		Edit1.Anchors:=Edit1.Anchors+[akTop]-[akBottom];
79	79		```
80	80
81	81		Das selbe kann mit der Methode gemacht werden:
82	82
83	83		``` pascal
84	84		Edit1.AnchorVerticalCenterTo(Label1);
85	85		```
86	86
87	87		Offensichtlich ist die Verankerung der unteren Seite von Edit1 bei einer Zentrierung nicht sinnvoll.
88	88
89	89		# Neue Eigenschaft
90	90
91	91		``` pascal
92	92		property AnchorSide[Kind: TAnchorKind]: TAnchorSide read GetAnchorSide;
93	93		```
94	94
95	95		Dies wird nicht im Objektinspektor veröffentlicht. Sie können sie zur Entwicklungszeit mit dem Ankereditor bearbeiten (Menü: Ansicht -\> Ankereditor anzeigen, oder auf den Button der 'Anchors' Eigenschaft klicken).
96	96
97	97		# Neue Methoden zur einfachen Konfiguration eines gebräuchlichen Layouts
98	98
99	99		``` pascal
100	100		procedure AnchorToNeighbour(Side: TAnchorKind; Space: integer;
101	101		Sibling: TControl);
102	102		procedure AnchorParallel(Side: TAnchorKind; Space: integer;
103	103		Sibling: TControl);
104	104		procedure AnchorHorizontalCenterTo(Sibling: TControl);
105	105		procedure AnchorVerticalCenterTo(Sibling: TControl);
106	106		procedure AnchorAsAlign(TheAlign: TAlign; Space: Integer);
107	107		```
108	108
109	109		AnchorVerticalCenterTo arbetet auch mit Eltern. Dann wird auf den Client-Bereich zentriert, das bedeutet die Mitte des Steuerelements ist bei ClientHeight div 2.
110	110
111	111		Das zentrierte Verankern ist noch nicht vollständig unterstützt für die Berechnung der Größe der Eltern. Wenn Sie beispielsweise ein Label in einer Groupbox1 zentriert verankern und Groupbox1.AutoSize auf true setzen, dann schrumpft die Höhe der Groupbox1 und läßt keinen Platz für das Label. Die Lösung besteht darin, auf ein Steuerelement zu zentrieren, das selbst nicht zentriert ist. Zum Beispiel zentriere ein Label1 auf eine ComboBox und nimm für die ComboBox die vorgegebenen Anker (Anchors=\[akLeft,akTop\]).
112	112
113	113		# Verankern an unsichtbaren Kontrollelementen
114	114
115	115		Ab Version 0.9.25 rev 12800 wurde das Verankern an unsichtbaren Kontrollelemente geändert, damit es intuitiver arbeitet. Beispiel: Die Kontrollelemente A, B und C sind wie folgt verankert (C.Left an B.Right und B.Left an A.Right):
116	116
117		-	~~```~~
	117	+	```text
118	118		+---+ +---+ +---+
119	119		\| A \| \| B \| \| C \|
120	120		+---+ +---+ +---+
121	121		```
122	122
123	123		Ist B unsichtbar (Visible:=false), wird C.Left B überspringen und sich an der rechten Seite von A verankern, womit das Ganze dann so aussieht:
124	124
125		-	~~```~~
	125	+	```text
126	126		+---+ +---+
127	127		\| A \| \| C \|
128	128		+---+ +---+
129	129		```
130	130
131	131		# Zirkuläre Bezüge
132	132
133	133		Sie erhalten einen Zirkularbezug, wenn Sie zwei Seiten an der jeweils anderen verankern. Dies liefert eine unmögliche Verankerung. Die LCL bemerkt das, löst aber keine Exception aus, weil es sich um einen temporären Kreis handeln könnte. Zum Beispiel: Eine Reihe von Schaltflächen. Button1 ist links von Button2, Button2 ist links von Button3. Jetzt verändern wir die Reihenfolge zu: Button3, Button1, Button2. Wenn die Verankerung mit Button3 startet, entsteht ein temporärer Kreis der aufgelöst wird, wenn das Umordnen abgeschlossen ist. Die LCL entdeckt Kreise und wird den Button nicht verschieben. Kreise sind nicht die einzige Anomalie.
134	134
135	135		Es gibt eine Ausnahme zu dieser Regel. Wenn Parent.AutoSize wahr ist, dann bricht die LCL beim Autosize Kreise automatisch auf und schreibt eine Warnung über debugln (Windows: --debug-log.txt, Linux, et al: stdout). Welcher Anker aufgebrochen wird hängt von der Reihenfolge der Steuerelemente und der Seiten ab. Deshalb sind temporäre Kreise erlaubt mit AutoSize:=true wenn Sie die Änderungen einschließen in
136	136
137	137		``` pascal
138	138		Parent.DisableAutosizing;
139	139		try
140	140		// change anchors, aligns, bounds...
141	141		finally
142	142		Parent.EnableAutosizing;
143	143		end;
144	144		```
145	145
146	146		Der AutoSize-Algorithmus bricht nicht nur Kreisbezüge auf, sondern beseitigt auch Inkonsistenzen mit Align/AnchorSide.
147	147
148	148		Eventuell wäre es günstig, im Designer Hinweise darauf einzufügen oder ein Werkzeug zum Auflisten der Kreisbezüge und Inkonsistenzen.
149	149
150	150		# Siehe auch
151	151
152	152		- [[Autosize / Layout]]
153	153		- [[LCL AutoSizing]]
154	154		- [[Example: Anchors. How to reliably align dynamically created controls under changing visibility]]
155	155
156	156		---
157	157		From the Free Pascal wiki, page "Anchor Sides/de", as it stood on 2020-02-06 after a change by GAN, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).
158	158		Category: Lazarus/de

Back to history