Autosize / Layout/zh TW: what changed

Revision 2 to 3. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		# 概述
2	2
3	3		LCL 會自動修改 controls 的大小和位置，所以它會根據字體，主題，文字和其他內容來自動適應。如果你想讓你的程式在多個平台上執行，或者程式裡的 captions 有多個語言。那麼，你的 controls 需要正確地適應本地環境. LCL 不僅允許你用快速的第一設計模式（用滑鼠在 form 上移動 controls），也允許你之後再改動一些主要的屬性來使得 controls 自動適應後來的內容變動。
4	4
5	5		- Fixed design: 當在 designer 裡放置好 control 後，它就預設地啟用. Control 的位置相對它的父組件是固定的. Control 的大小和位置(Left, Top)可以被程式員改變。你可以自由地用滑鼠移動 control 或改變其大小。
6	6		- Aligned: 對齊的 controls 會根據設定填充父組件的頂部，底部，左邊，右邊的剩餘空間或者整個剩餘空間。
7	7		- Anchored: 你可以在 control 的邊上(left, top, right, bottom)拋錨，錨住父組件或者另一個 control. 一旦錨住後, LCL 就會使得拋錨的那個邊和被錨住的組件的距離固定。
8	8		- Layout: controls 可以自動地依據行列對齊(例如 TRadioGroup)
9	9		- Custom via OnResize: 自己處理 OnResize, OnChangeBounds 事件，你就可以自己安排 controls 了。
10	10		- Custom controls: 自己寫 controls, 那麼你就可以按你需要覆寫幾乎所有 LCL 行為了。
11	11
12	12		## 優先級規則
13	13
14	14		1. Constraints
15	15		2. Align
16	16		3. Anchors
17	17		4. ChildSizing.Layout
18	18		5. AutoSize
19	19		6. OnResize, OnChangeBounds - 要注意的是，如果你設定的 bounds 和上述規則有衝突，那麼程式會進入無窮迴圈。
20	20
21	21		## 常用屬性
22	22
23	23		一些用來配置 autosizeing 的重要屬性：
24	24
25	25		- Left, Top, Width, Height
26	26		- AutoSize: autosize 另 LCL 自動地更改 control 的寬和高。
27	27		- Anchors: 創建一個錨。例如，將一個 ComboBox 錨在一個 Label 的右邊。
28	28		- Align
29	29		- Constraints: 設定寬和高的最小值和最大值。
30	30		- BorderSpacing: 設定被錨住的 control 之間的空間。
31	31		- ChildSizing: 設定子 control 的 layout 和空間。
32	32
33	33		上述法則的內部原理在此有描述： [[LCL AutoSizing]].
34	34
35	35		# Fixed design
36	36
37	37		這是預設設定. Anchors 屬性會被設定成 \[akLeft, akTop\], 也就是說, LCL 不會改變 Left, Top. 如果 AutoSize 為 false, 那麼 Width 和 Height 也會保持不便。如果 AutoSize 為 true, 那麼 Width 和 Height 會改動以適用內容。例如, TLabel.AutoSize 預設是 true, 因此，改變 Caption 就會重設 label 的大小. TButton.AutoSize 預設為 false, 所以改變 Caption 不會重設按鈕的大小。當你將 Button.AutoSize 設成 true 後，這個按鈕會在每次 Caption, 字體，主題改變後縮小或增大。要注意的是，這種改變不總是立即進行的。例如，在 FormCreate 時，所有 autosizing 動作會懸掛。你可以在任何時候改變 Left, Top, Width, Height 屬性。
38	38
39	39		# AutoSize
40	40
41	41		`AutoSize` 這個布林屬性出現在許多類中；它允許 control 自動進行大小的調整以適應它包含的文本或圖形，也允許最有效地使用可用的空間。這是創建跨平台窗體的一個非常重要的機制。
42	42
43	43		通常, AutoSize=true 後，會為可見 control:
44	44
45	45		- 如果可能，它改變 control 的大小到 preferred size. 例如，一個 TButton 的寬度和高度被改變大小以適應它的 caption, 而對於 TEdit, 只改變高度. TEdit 的寬度不會自動改變大小。你可以手工改變它。可參考下 GetPreferredSize.
46	46		- 它同時移動所有固定位置的子 control。最左邊的子 control 會移到 Left=0 (依賴於 BoarderSpacing), 最上邊的子 control 會移到 Top=0.
47	47
48	48		## Difference to Delphi
49	49
50	50		Delphi 的 AutoSize 僅在特定的屬性改變時作用。例如，當 TLabel 的 Font 被改變時. LCL 的 AutoSize 總是有效的。例如，在 Delphi 裡，一個 AutoSize=true 的 Label 仍然可以設置大小(可能造成部分或全部 Caption 無法顯示), 這在 LCL 中是不會出現的，因為 AutoSize 總是起作用。另外，隱藏的 controls 不會被改變大小。
51	51
52	52		## AutoSize and resizing the control
53	53
54	54		當 AutoSize=false 按鈕就會呈現固定的大小。
55	55
56	56		![](/wiki-images/1/1f/Autosize1.png)
57	57
58	58		當對 button 設置 AutoSize=true, 那麼這些 buttons 就會被增大或縮小以適應文字或主題框架。
59	59
60	60		![](/wiki-images/7/75/Autosize_on.png)
61	61
62	62		如上圖的 OK 按鈕所示, AutoSize 並不會將按鈕縮小到儘可能小。它使用GetPreferredSize 來獲取建議大小，這個函數又會調用 CalculatePreferredSize. 預設的 TWinControl 實作會查詢 widgetset, 它可能設定了建議的 width 和 height. 每個 control 都能覆寫 CalculatePreferredSize. 例如， TImage 就覆寫它並返回圖片的大小。如果沒有沒有建議的 width(或 height), 那麼就返回 0, LCL 會保持 width(height), 除非 ControlStyle 標記 csAutoSize0x0 被設置(這個標記當前只被 TPanel 使用).
63	63
64	64		TWinControl 計算它所有的 controls 的大小，然後利用這個值來計算它自己的建議大小。
65	65
66	66		當一個 control 的左錨和右錨都錨到其他對象，那麼它的寬度就是固定的(動態的固定，依錨住的對象的位置變動而改變)。例如，當 Align=alTop(Align 屬性可看作一個快速設置錨的屬性，會覆蓋錨的設置), 這個 control 就的左錨就錨住它的父對象的到左邊界，右錨就錨住它的父對象的右邊界。之後它的寬度就隨父對象而改變了。如果 Parent.AutoSize 是 true 的話，那麼 Parent 將會實用這個 control 的建議寬度來計算它自己的建議寬度，參閱 [[Autosize / Layout\|Align and AutoSize]]. 如果沒有可用的建議寬度，那麼就使用最後設置的邊界(BaseBounds 或者 ReadBounds). 如果邊界為設置，那麼就調用 GetControlClassDefaultSize 方法。對於 Height 也是同樣的機制。
67	67
68	68		Constraints(約束)總是起作用，且優先級更高。
69	69
70	70		## AutoSize and moving child controls
71	71
72	72		When AutoSize=false you can place and move controls freely:
73	73
74	74		![](/wiki-images/7/75/Autosize_on.png)
75	75
76	76		When AutoSize=true child controls with fixed positions are moved to fit.
77	77
78	78		![](/wiki-images/d/d9/Autosize_panel_on.png)
79	79
80	80		Both buttons on the panel were moved by the same amount to top and left, so that there is no space left to the left and top. If the buttons would have BorderSpacing\>0 or the Panel.ChildSizing.LeftRightSpacing\>0 the buttons would be moved so that the defined space is used.
81	81
82	82		Only child controls with the following values are moved:
83	83
84	84		- Anchors=\[akLeft,akRight\]
85	85		- AnchorSide\[akLeft\].Control=nil
86	86		- AnchorSide\[akTop\].Control=nil
87	87		- Align=alNone
88	88
89	89		The moving of the child controls depend on the propert [[Autosize / Layout\|ChildSizing.Layout]]. The layout is applied in the method TWinControl.AlignControls which can be overridden. For example TToolBar overrides that and defines a flow layout where controls that do not fit are put into subsequent lines.
90	90
91	91		Controls can disable the moving of child controls by setting the ControlStyle flag csAutoSizeKeepChildLeft and csAutoSizeKeepChildTop (since 0.9.29).
92	92
93	93		## AutoSize and Forms
94	94
95	95		Forms without Parent are controlled by the window manager and can therefore not be placed or resized freely. Setting the size is only a recommendation and might be ignored by the window manager. For example you might set the Width of a Form to 1000 and the widgetset might answer with a resize to 800. If you set the Width in OnResize you might create an endless loop. That's why the LCL TForm disables AutoSize when the widgetset resizes the form.
96	96
97	97		That means AutoSize for forms stops when the user resizes the form or if the window manager does not like the bounds. For example some Linux window managers have features like magnetic sides which resizes windows in relationship to other windows.
98	98
99	99		### Force an auto sizing of a form
100	100
101	101		You can start/execute a new AutoSize by doing:
102	102
103	103		``` pascal
104	104		Form1.AutoSize := False;
105	105		Form1.AutoSize := True;
106	106		```
107	107
108	108		### Compute the size of an autosized form in advance
109	109
110	110		When placing an autosized form you might need the size of the form before showing it. Autosizing requires the handle. You can compute the size of a form before showing it with:
111	111
112	112		``` pascal
113	113		From1.HandleNeeded;
114	114		Form1.GetPreferredSize(PreferredWidth,PreferredHeight);
115	115		```
116	116
117	117		Note: The window manager and form events might change the size. The preferred size does not include the form's window borders. This is a planned feature.
118	118
119	119		# Anchor Sides
120	120
121	121		Controls have four sides: akLeft, akTop, akRight and akBottom. Each side can be anchored to the parent or the side of another sibling (a control with the same parent). Anchoring means keeping the distance. The default is Anchors=\[akLeft,akTop\]. Vertical anchors are independent of horizontal anchors. Some properties like Align and Parent.AutoSize have higher precedence and can change the behaviour.
122	122
123	123		## Anchored to Parent or Nil
124	124
125	125		Anchoring to Nil (the default) has almost the same effect as anchoring to the Parent. Both try to keep the distance to a side of the Parent's client area. Anchoring to Nil uses the distance of the last SetBounds call, while Anchoring to Parent uses the BorderSpacing value.
126	126
127	127		There are four combinations of akLeft,akRight (akTop,akBottom):
128	128
129	129		- akLeft, no akRight: the control's Left is fixed and not changed by the LCL. The right side is not anchored, so it follows the left side. That means the Width is kept too.
130	130		- akLeft and akRight: the control's Left is fixed and not changed by the LCL. The right side is anchored to the Parent's right side. That means if the Parent is enlarged by 100pixel then the control's Width is enlarged by 100pixel too.
131	131		- akRight, no akLeft: the control's left side is not anchored, so it will follow its right side. The right side is anchored. That means if the parent is enlarged by 100pixel then the control is moved to the right by 100pixel.
132	132		- no akLeft and no akRight: neither sides are anchored. The position of the center of the control scales with the parent. For example if the control is in the middle of the parent and the parent is enlarged by 100 pixel, then the control is moved 50pixel to the right.
133	133
134	134		### Changing the size of the parent of an anchored control
135	135
136	136		A GroupBox with a Button: ![](/wiki-images/6/60/Anchors1.png)
137	137
138	138		When the GroupBox is enlarged the distance of the anchored side is kept:
139	139
140	140		With akLeft, no akRight: ![](/wiki-images/0/05/Anchors_akLeft.png)
141	141
142	142		With akLeft and akRight: ![](/wiki-images/6/66/Anchors_akLeft_akRight.png)
143	143
144	144		With akRight, no akLeft: ![](/wiki-images/d/d3/Anchors_akRight_no_akLeft.png)
145	145
146	146		Three buttons in a groupbox: ![](/wiki-images/4/48/Anchors_no_akLeft_no_akRight_small.png)
147	147
148	148		With no akLeft and no akRight their centers are scaled: ![](/wiki-images/7/7b/Anchors_no_akLeft_no_akRight_big.png)
149	149
150	150		### Changing the size of an anchored control
151	151
152	152		When changing the Width of an anchored control, for example via the Object Inspector or via code Button1.Width:=3, you can see the difference between anchoring to Parent and anchoring to Nil. Anchoring to Parent will resize and move the Button1, while anchoring to Nil will only resize. For example:
153	153
154	154		#### Anchored to nil
155	155
156	156		![](/wiki-images/b/bd/Anchored_right_nil_resize1.png) A Button1 anchored \[akTop,akRight\], AnchorSide\[akRight\].Control=nil
157	157
158	158		![](/wiki-images/a/a0/Anchored_right_nil_resize2.png) Setting the Width to a smaller value will shrink the button, keeping the button's Left, increasing the distance of the right side.
159	159
160	160		![](/wiki-images/1/16/Anchored_right_nil_resize3.png) When the Groupbox is resized the button will keep the new distance.
161	161
162	162		Explanation: setting the Width is equivalent to calling SetBounds(Left,Top,NewWidth,Height). That's why the Left is kept. This is Delphi compatible.
163	163
164	164		#### Anchored to Parent
165	165
166	166		![](/wiki-images/4/45/Anchored_right_parent_resize1.png) A Button1 anchored \[akTop,akRight\], AnchorSide\[akRight\].Control=Button1.Parent
167	167
168	168		![](/wiki-images/0/04/Anchored_right_parent_resize2.png) Setting the Width to a smaller value will shrink the button, keeping the right distance, changing the button's Left.
169	169
170	170		## Anchored to sibling
171	171
172	172		You can anchor to neighbor controls. The following example shows:
173	173
174	174		- you can anchor a label's left to the left of a button
175	175		- anchor a label's top to the bottom of a button
176	176		- anchor the center of a label to the center of a button
177	177
178	178		![](/wiki-images/e/ee/Anchorsides_example1.png)
179	179
180	180		![](/wiki-images/b/ba/Anchorside_example2.png)
181	181
182	182		For more details and how to setup anchors see: [[Anchor Sides]].
183	183
184	184		![](/wiki-images/6/6d/Anchoreditor.png)
185	185
186	186		## BorderSpacing
187	187
188	188		The BorderSpacing properties controls the minimum amount of space around a control. The properties are:
189	189
190	190		- Around: this amount in pixel is added to Left, Top, Right, Bottom.
191	191		- Left: space in pixel on the left side of the control
192	192		- Top: space in pixel above the control
193	193		- Right: space in pixel on the right side of the control
194	194		- Bottom: space in pixel below the control
195	195		- InnerBorder: this amount in pixel is added twice to the preferred width and height. Some controls override the calculation and ignore this property. An example where it works is TButton. With InnerBorder you can make a button bigger than needed.
196	196		- CellAlignHorizontal: This is used in table layouts like ChildSizing.Layout=cclLeftToRightThenTopToBottom. If the control is smaller than the table cell, this property defines where to align the control: to the left ccaLeftTop, to the right ccaRightBottom or in the middle ccaCenter.
197	197		- CellAlignVertical: same as CellAlignHorizontal but for vertical alignment.
198	198
199	199		### BorderSpacing rules
200	200
201	201		- Around is added to Left,Top,Right,Bottom
202	202		- The horizontal space between two controls (LeftControl, RightControl on Parent) is the maximum of
203	203		- LeftControl.BorderSpacing.Right + LeftControl.BorderSpacing.Around
204	204		- RightControl.BorderSpacing.Left + RightControl.BorderSpacing.Around
205	205		- Parent.ChildSizing.HorizontalSpacing
206	206
207	207		For instance if LeftControl.BorderSpacing.Right = 3 and LeftControl.BorderSpacing.Around = 4, then there is at least 7 pixel space between the two controls. If RightControl.BorderSpacing.Left = 4 and RightControl.BorderSpacing.Around = 4 then the space will be at least 8. If Parent.ChildSizing.HorizontalSpacing = 10 then the space will be at least 10.
208	208
209	209		Note: The space can be even bigger, if the controls have constraints that don't allow to expand.
210	210
211	211		A common example is anchoring a Label to an Edit.
212	212
213	213		![](/wiki-images/1/1e/BorderSpacing_Anchors.png)
214	214
215	215		The Label center is vertically anchored to the Edit. The Edit's left side is anchored to the right side of the Label. Both have BorderSpacing.Around=6. This results in 6 pixel space between the Label and the Edit and 6 pixel space left of the Label and 6 pixel space right of the Edit. There is 6 pixel space above and below the Edit as well.
216	216
217	217		- The left space between a control and its parent (Label1 on GroupBox1) is the maximum of
218	218		- Label1.BorderSpacing.Left + Label1.BorderSpacing.Around
219	219		- GroupBox1.ChildSizing.LeftTopSpacing
220	220
221	221		- The right space between a control and its parent (Edit1 on GroupBox1) is the maximum of
222	222		- Edit1.BorderSpacing.Right + Edit1.BorderSpacing.Around
223	223		- GroupBox1.ChildSizing.RightBottomSpacing
224	224
225	225		- When a control's center is anchored to another control, for example the above Label is centered vertically to the Edit1, then all spacings are ignored.
226	226
227	227		- When a control's left side is anchored to the left side of another control (i.e. they are aligned with the left side), then the space is the maximum of
228	228		- Control1.BorderSpacing.Left + Control1.BorderSpacing.Around
229	229		- Control2.BorderSpacing.Left + Control2.BorderSpacing.Around
230	230
231	231		Here is a more complex example:
232	232
233	233		![](/wiki-images/9/9c/Borderspacing_anchors2.png)
234	234
235	235		The important parts of the lfm code:
236	236
237	237		``` pascal
238	238		object GroupBox1: TGroupBox
239	239		AutoSize = True
240	240		Caption = 'GroupBox1'
241	241		TabOrder = 0
242	242		object Label1: TLabel
243	243		AnchorSideLeft.Control = GroupBox1
244	244		AnchorSideTop.Control = Edit1
245	245		AnchorSideTop.Side = asrCenter
246	246		BorderSpacing.Around = 6
247	247		Caption = 'Label1'
248	248		end
249	249		object Edit1: TEdit
250	250		AnchorSideLeft.Control = Label1
251	251		AnchorSideLeft.Side = asrBottom
252	252		AnchorSideTop.Control = GroupBox1
253	253		AnchorSideRight.Control = GroupBox1
254	254		AnchorSideRight.Side = asrBottom
255	255		Anchors = [akTop, akLeft, akRight]
256	256		BorderSpacing.Around = 6
257	257		TabOrder = 0
258	258		Text = 'Edit1'
259	259		end
260	260		object Label2: TLabel
261	261		AnchorSideLeft.Control = GroupBox1
262	262		AnchorSideTop.Control = Edit1
263	263		AnchorSideTop.Side = asrBottom
264	264		BorderSpacing.Around = 6
265	265		Caption = 'Label2'
266	266		end
267	267		object ComboBox1: TComboBox
268	268		AnchorSideLeft.Control = Label2
269	269		AnchorSideTop.Control = Label2
270	270		AnchorSideTop.Side = asrBottom
271	271		AnchorSideRight.Control = GroupBox1
272	272		AnchorSideRight.Side = asrBottom
273	273		Anchors = [akTop, akLeft, akRight]
274	274		BorderSpacing.Right = 6
275	275		TabOrder = 1
276	276		Text = 'ComboBox1'
277	277		end
278	278		object CheckBox1: TCheckBox
279	279		AnchorSideLeft.Control = GroupBox1
280	280		AnchorSideTop.Control = ComboBox1
281	281		AnchorSideTop.Side = asrBottom
282	282		BorderSpacing.Around = 6
283	283		Caption = 'CheckBox1'
284	284		TabOrder = 2
285	285		end
286	286		object Label3: TLabel
287	287		AnchorSideLeft.Control = GroupBox1
288	288		AnchorSideTop.Control = Edit2
289	289		AnchorSideTop.Side = asrCenter
290	290		BorderSpacing.Around = 6
291	291		Caption = 'Label3'
292	292		end
293	293		object Edit2: TEdit
294	294		AnchorSideLeft.Control = Label3
295	295		AnchorSideLeft.Side = asrBottom
296	296		AnchorSideTop.Control = CheckBox1
297	297		AnchorSideTop.Side = asrBottom
298	298		BorderSpacing.Around = 6
299	299		TabOrder = 3
300	300		Text = 'Edit2'
301	301		end
302	302		end
303	303		```
304	304
305	305		### BorderSpacing and Align
306	306
307	307		BorderSpacing works with Align. In the example below there is a Memo1 with Align=alTop and a Memo2 with Align=alCLient.
308	308
309	309		- Normally the two Memos would fill the whole GroupBox.
310	310		- But the Memo1 has BorderSpacing.Around=10, so there 10 pixel space around Memo1.
311	311		- The Memo2 has BorderSpacing.Top=20. The space between Memo1 and Memo2 is the maximum, which is the 20 from Memo2.
312	312		- Memo2 has also BorderSpacing.Right=50 so there is 50 Pixel space right of Memo2.
313	313		- The GroupBox can define default space for all its child controls via ChildSizing.LeftRightSpacing/VerticalSpacing/HorizontalSpacing. In this example it does not (all 0).
314	314
315	315		![](/wiki-images/1/13/Borderspacing_align1.png)
316	316
317	317		# Align
318	318
319	319		The Align property works pretty much like in Delphi and can be used to quickly fill an area. For example to let a TListBox fill the entire area of its Parent, set ListBox1.Align=alClient. The align values alTop, alBottom, alLeft and alRight will place controls without overlapping if possible. That means all controls with Align in alLeft,alTop,alBottom,alRight will not overlap if there is enough space.
320	320
321	321		The algorithm works as follows:
322	322
323	323		- First all controls with alTop are put to the top of the client area. If there are several controls with alTop the last added/moved will be put topmost. The algorithm will try to avoid overlapping and keep the height of the control, while expanding the width to maximum. AnchorSides of the left, top and right sides are ignored. The bottom AnchorSide works normal. Borderspacing and Parent.ChildSizing spaces are considered, so you can define space around each aligned control.
324	324		- Then all controls with alBottom are put to the bottom of the client area. Otherwise it works analog to alTop.
325	325		- Then all controls with alLeft are put to the left of the client area between the alTop and alBottom controls. Otherwise it works analog to alTop.
326	326		- Then all controls with alRight are put to the right of the client area between the alTop and alBottom controls. Otherwise it works analog to alTop.
327	327		- If there is a control with alClient it will fill the remaining client.
328	328		- If there is more than one control with alClient they will be placed at the same position, overlapping each other. Use the Visibility property to define which one is shown.
329	329
330	330		![](/wiki-images/e/e6/Autosize_align.png)
331	331
332	332		## Align and BorderSpacing
333	333
334	334		The space of BorderSpacing and of the parent's ChildSizing is applied to aligned controls. The memo below has Align=alClient.
335	335
336	336		![](/wiki-images/b/b4/Autosize_align_borderspacing.png)
337	337
338	338		## Align and Anchoring
339	339
340	340		The free side of an aligned control (e.g. the right side of a Align=alLeft) follows the anchoring rules. If the anchor is not set, then the control will keep its Width. If the anchor is set, then the Width will change.
341	341
342	342		## Align and AutoSize
343	343
344	344		A control aligned with alLeft or alRight expands vertically, and will use its designed width. If AutoSize is set to true, then the Width will be the preferred width. The button below has Align=alRight and AutoSize=true.
345	345
346	346		![](/wiki-images/3/35/Autosize_align_autosize.png)
347	347
348	348		## Align and parent AutoSize
349	349
350	350		A control aligned with alClient fills the remaining space. A parent control with AutoSize=true will expand or shrink to enclose its children exactly. What happens if you combine these two properties? Say you put a button with Align=alClient into a groupbox with AutoSize=true?
351	351
352	352		![](/wiki-images/b/b1/Autosize_nested1.png)
353	353
354	354		The LCL uses the preferred size of the buttons and expands or shrinks the groupbox accordingly:
355	355
356	356		![](/wiki-images/2/28/Autosize_nested2.png)
357	357
358	358		## alCustom
359	359
360	360		This Align value exists for custom AutoSize algorithms and is treated by the LCL almost like alNone. Controls with alCustom are not moved by the LCL but by your custom control. You have to override CalculatePreferredSize and DoAutoSize.
361	361
362	362		## Order of controls with same Align
363	363
364	364		Controls with same Align are added in the following order. On alLeft the control with the lowest Left wins, for alTop the lowest Top, for alRight the biggest Left+Width, for alBottom the biggest Top+Height. If two controls have the same coordinate the one last moved (calls to SetBounds or SetParent) wins. Controls can override CreateControlAlignList to change the order or override DoAlignChildControls to handle the whole Align.
365	365
366	366		Note: Before 0.9.29 controls at the same coordinate were put in Z order. This resulted in reordering in some cases and had to be fixed. There is one incompatibility: If you added several controls with alTop or alLeft without specifying bounds the controls are put at 0,0 and therefore the last added wins, where formerly the first won.
367	367
368	368		# Layout
369	369
370	370		## Rows, columns and lines
371	371
372	372		You can align child controls in rows and columns using the ChildSizing properties. For example:
373	373
374	374		- ChildSizing.Layout=cclLeftToRightThenTopToBottom
375	375		- ChildSizing.ControlsPerLine=3
376	376		- AutoSize=false (the groupbox does not fit the childs)
377	377
378	378		![](/wiki-images/1/10/Autosize_layout_lefttoright.png)
379	379
380	380		The Layout property defaults to cclNone. If you set Layout to another value, every child, that has normal anchors, will be aligned. Normal anchors means:
381	381
382	382		- Anchors=\[akLeft,akTop\]
383	383		- AnchorSide\[akLeft\].Control=nil
384	384		- AnchorSide\[akTop\].Control=nil
385	385		- Align=alNone
386	386
387	387		The value cclLeftToRightThenTopToBottom will put the first child at top, left, the second to the right, and so forth. This is a line. The property ControlsPerLine defines when a new line is started. In the above example each line (row) has 3 controls. There are 12 controls, so there are 4 lines (rows) each with 3 controls (columns). If ControlsPerLine is 0 it means unlimited controls per line - there would be only one row with all childs.
388	388
389	389		You can see that the rows have different sizes, each row has the size of the biggest control and that the controls are resized to column width. There is no space between the rows. The space in the image comes from the used theme, not from the LCL.
390	390
391	391		## Fixed space between rows and columns
392	392
393	393		You can add space between with these properties:
394	394
395	395		- ChildSizing.VerticalSpacing - Space between rows
396	396		- ChildSizing.HorizontalSpacing - Space between columns
397	397		- ChildSizing.LeftRightSpacing - Space on the left and right of all columns
398	398		- ChildSizing.TopBottomSpacing - Space above and below of all columns
399	399
400	400		The above example with ChildSizing.VerticalSpacing=6, ChildSizing.HorizontalSpacing=15, ChildSizing.LeftRightSpacing=30, ChildSizing.TopBottomSpacing=10, AutoSize=true
401	401
402	402		![](/wiki-images/a/a9/Autosize_layout_parentspacing.png)
403	403
404	404		Additionally you can add individual space for each control with its BorderSpacing properties.
405	405
406	406		## Enlarge
407	407
408	408		The above example resized the GroupBox to the needed space. If your GroupBox has a fixed size or if it is not freely resizable, for instance if the GroupBox should fill the whole width of the form, then the childs should enlarge. There are several modes. The default mode ChildSizing.EnlargeHorizontal=crsAnchorAligning is to not enlarge anything. The space on the right side will be unused.
409	409
410	410		- crsAnchorAligning - do not use the extra space
411	411		- crsScaleChilds - multiply the width/height with the same factor
412	412		- crsHomogeneousChildResize - add to each width/height the same amount
413	413		- crsHomogeneousSpaceResize - add to each space between the childs the same amount
414	414
415	415		### crsScaleChilds
416	416
417	417		ChildSizing.EnlargeHorizontal=crsScaleChilds, ChildSizing.EnlargeVertical=crsScaleChilds, AutoSize=false
418	418
419	419		![](/wiki-images/b/b0/Autosize_layout_scalechilds.png)
420	420
421	421		For example if the ClientWidth is twice as big as needed, then every child will be twice as big.
422	422
423	423		### crsHomogeneousChildResize
424	424
425	425		ChildSizing.EnlargeHorizontal=crsHomogeneousChildResize, ChildSizing.EnlargeVertical=crsHomogeneousChildResize, AutoSize=false
426	426
427	427		![](/wiki-images/3/39/Autosize_layout_homogeneouschildresize.png)
428	428
429	429		For example if the ClientWidth is 30 pixel bigger than needed, then every child will be 10 pixel broader.
430	430
431	431		### crsHomogeneousSpaceResize
432	432
433	433		ChildSizing.EnlargeHorizontal=crsHomogeneousSpaceResize, ChildSizing.EnlargeVertical=crsHomogeneousSpaceResize, AutoSize=false
434	434
435	435		![](/wiki-images/9/96/Autosize_layout_homogeneousspaceresize.png)
436	436
437	437		For example if the ClientWidth is 40 pixel bigger than needed, there will be 10 pixel space on the left, right and between each child.
438	438
439	439		## Shrink
440	440
441	441		Shrinking works similar to enlarging. You can set different modes if there is not enough space for controls. ShrinkHorizontal, ShrinkVertical.
442	442
443	443		## Individual cells
444	444
445	445		In the above examples all controls were resized the same, each filled the whole cell. A cell is the space in a specific row and column. Normally a control fills the whole cell space. This can be changed with the properties BorderSpacing.CellAlignHorizontal and BorderSpacing.CellAlignVertical.
446	446
447	447		For example set the BorderSpacing.CellAlignHorizontal of the fifth button to caCenter you will get this:
448	448
449	449		![](/wiki-images/d/d3/Autosize_layout_cellhorizontal_cacenter.png)
450	450
451	451		There are four possible values for CellAlignHorizontal/CellAlignVertical:
452	452
453	453		- caFill: the child control fills the whole width (height) of the cell
454	454		- caCenter: the child control uses its preferred width (height) and will be centered in the cell
455	455		- caLeftTop: the child control uses its preferred width (height) and will be leftaligned in the cell
456	456		- caRightBottom: the child control uses its preferred width (height) and will be rightaligned in the cell
457	457
458	458		![](/wiki-images/c/c0/Autosize_layout_cellalign.png)
459	459
460	460		# Custom layout with OnResize / OnChangeBounds
461	461
462	462		Sometimes the LCL layout is not sufficient. The below example shows a GroupBox1 with a ListBox1 and a Memo1. The ListBox1 should fill one third of the space, the Memo1 takes the rest.
463	463
464	464		![](/wiki-images/4/4b/Autosize_onresize.png)
465	465
466	466		Whenever the GroupBox is resized the ListBox1.Width should be one third. To achieve this set the OnResize event of the GroupBox1 to:
467	467
468	468		``` pascal
469	469		procedure TForm1.GroupBox1Resize(Sender: TObject);
470	470		begin
471	471		ListBox1.Width := GroupBox1.ClientWidth div 3;
472	472		end;
473	473		```
474	474
475	475		### Common mistake: Wrong OnResize event
476	476
477	477		Do not put all your resizing code into the Form OnResize event. The Form OnResize event is only called when the Form was resized. The child controls (e.g. a GroupBox1) is resized later, so the GroupBox1.ClientWidth has still the old value during the FormResize event. You must use the GroupBox1.OnResize event to react to changes of GroupBox1.ClientWidth.
478	478
479	479		### Common mistake: Width instead of ClientWidth, AdjustClientRect
480	480
481	481		The Width is the size including the frame. The ClientWidth is the inner Width without the frame. Some controls like the TPanel paints a further frame. Then you have to use AdjustClientRect. The same example, but instead of a GroupBox1 the ListBox1 is in a Panel1:
482	482
483	483		``` pascal
484	484		procedure TForm1.Panel1Resize(Sender: TObject);
485	485		var
486	486		r: TRect;
487	487		begin
488	488		r := Panel1.ClientRect;
489	489		Panel1.AdjustClientRect(r);
490	490		ListBox1.Width := (r.Right - r.Left) div 3;
491	491		end;
492	492		```
493	493
494	494		# Custom Controls
495	495
496	496		When you write your own control, you can override and fine tune many parts of the LCL autosizing.
497	497
498	498		## SetBounds, ChangeBounds, DoSetBounds
499	499
500	500		SetBounds is called when the properties Left, Top, Width, Height, BoundsRect is set or the user calls it directly. SetBounds updates the BaseBounds and BaseParentClientSize, which are used by anchoring to keep the distance. For example loading a Form with TMemo and the lfm contains TMemo's Left and Width, then SetBounds is called two times for the memo. When the user maximizes a window, SetBounds is called for the form, but not for the Memo, keeping the BaseBounds of the Memo. If the Memo is anchored to the right, the Width of the Memo is changed based on the BaseBounds and BaseParentClientSize. Keep in mind that the given aLeft, aTop, aWidth, aHeight might not be valid and will be changed by the LCL before applied. Delphi calls SetBounds more often. SetBounds calls ChangeBounds with KeepBase=false.
501	501
502	502		ChangeBounds is called whenever the position or size of the control is set, either via the properties or by the layouter of the LCL. SetBounds calls internally ChangeBounds with KeepBase=false, while the LCL layouter calls it with KeepBase=true. Override this for code that might change the preferred size or resizes other controls. Keep in mind that the given aLeft, aTop, aWidth, aHeight might not be valid and will be changed by the LCL before applied. You can call this function.
503	503
504	504		DoSetBounds is a low level function to set the private variables FLeft, FTop, FWidth, FHeight. Do not call this function, only the LCL calls it. It also updates FClientWidth and FClientHeight accordingly. Override this to update the content layout of the control, for example scroll bars. As always: do not paint here, but call Invalidate and paint in OnPaint or override Paint.
505	505
506	506		DoAdjustClientRectChange is called by the LCL and the LCL interface, when the ClientRect has changed and the Width and Height were kept.
507	507
508	508		WMSize exists for Delphi/VCL compatibility. It is called by the LCL interface and on every change of bounds.
509	509
510	510		## AdjustClientRect
511	511
512	512		The method AdjustClientRect can be overriden by your custom controls and affects Align, ChildSizing.Layout and AnchorSides. It does not affect the meaning of Left, Top and does not affect normal anchoring (for example setting).
513	513
514	514		When you want to draw your own frame, then the child controls should be aligned within these frames. For example TPanel draws a frame and reduces the client area by overriding the method AdjustClientRect:
515	515
516	516		``` pascal
517	517		TCustomPanel = class(TCustomControl)
518	518		...
519	519		protected
520	520		...
521	521		procedure AdjustClientRect(var aRect: TRect); override;
522	522		...
523	523
524	524		procedure TCustomPanel.AdjustClientRect(var aRect: TRect);
525	525		var
526	526		BevelSize: Integer;
527	527		begin
528	528		inherited AdjustClientRect(aRect);
529	529
530	530		BevelSize := BorderWidth;
531	531		if (BevelOuter <> bvNone) then
532	532		inc(BevelSize, BevelWidth);
533	533		if (BevelInner <> bvNone) then
534	534		inc(BevelSize, BevelWidth);
535	535
536	536		InflateRect(aRect, -BevelSize, -BevelSize);
537	537		end;
538	538		```
539	539
540	540		### AdjustClientRect and Align
541	541
542	542		AdjustClientRect can be used to reduce the client area used by all autosize operations. For example TPanel uses AdjustClientRect to reduce the client area by the borderwidth:
543	543
544	544		![](/wiki-images/c/ca/Adjustclientrect_align.png)
545	545
546	546		The Button1 in the screenshot was created with Align=alClient. ChildSizing.Layout is affected too.
547	547
548	548		When anchoring to a parent via AnchorSides the AdjustClientRect is used too:
549	549
550	550		``` pascal
551	551		Button1.AnchorParallel(akTop,0,Button1.Parent);
552	552		```
553	553
554	554		The Button1's top side is anchored to the top side of the parent's client area. If the AdjustClientRect adds 3 to the Top the Button1.Top will be 3 (3 plus 0).
555	555
556	556		## Own AutoSize
557	557
558	558		When AutoSize is set to true the control should be resized to the preferred size if possible.
559	559
560	560		### Preferred Size
561	561
562	562		The new size is fetched by the LCL via GetPreferredSize which calls CalculatePreferredSize, which can be overridden. For example let's write a TQuadrat, which is a TShape, but its height should equal its width:
563	563
564	564		``` pascal
565	565		TQuadrat = class(TShape)
566	566		protected
567	567		procedure CalculatePreferredSize(var PreferredWidth,
568	568		PreferredHeight: integer; WithThemeSpace: Boolean); override;
569	569		end;
570	570		...
571	571		procedure TQuadrat.CalculatePreferredSize(var PreferredWidth,
572	572		PreferredHeight: integer; WithThemeSpace: Boolean);
573	573		begin
574	574		PreferredHeight:=Width;
575	575		end;
576	576		```
577	577
578	578		The method CalculatePreferredSize gets two var parameters: PreferredWidth and PreferredHeight. They default to 0 which means: there is no preferred size, so the LCL will not change the size. The above function sets PreferredHeight to the current Width. The boolean parameter WithThemeSpace is deprecated and always false.
579	579
580	580		Important: CalculatePreferredSize must not change the bounds or any other value of the control that can trigger an autosize. Doing so will create a loop.
581	581
582	582		Computing the PreferredWidth/Height can be expensive. Therefore the LCL caches the result until InvalidatePreferredSize is called for the control. In our example the PreferredHeight depends on the Width, so we must invalidate when the Width changes:
583	583
584	584		``` pascal
585	585		TQuadrat = class(TShape)
586	586		protected
587	587		...
588	588		procedure DoSetBounds(ALeft, ATop, AWidth, AHeight: integer); override;
589	589		end;
590	590		...
591	591		procedure TQuadrat.DoSetBounds(ALeft, ATop, AWidth, AHeight: integer);
592	592		begin
593	593		inherited DoSetBounds(ALeft, ATop, AWidth, AHeight);
594	594		InvalidatePreferredSize;
595	595		// Note: The AdjustSize can be omitted here, because the LCL does that after calling DoSetBounds.
596	596		end;
597	597		```
598	598
599	599		The LCL will automatically trigger the autosizing when the bounds have changed, so the example is complete.
600	600
601	601		The default TWinControl implementation of CalculatePreferredSize queries the widgetset, which might return a preferred width and/or height. Each control can override the CalculatePreferredSize method. For example TImage overrides it and returns the size of the Picture. If no preferred width (height) is available the returned value is 0 and the LCL will keep the current Width (Height). If 0 is a valid size for your control, you must set the ControlStyle flag csAutoSize0x0 (ControlStyle:=ControlStyle+\[csAutoSize0x0\];). An example is the LCL control TPanel.
602	602
603	603		### AdjustSize
604	604
605	605		When the preferred size depends on a new property, then every time the property changes the auto sizing must be triggered. For example:
606	606
607	607		``` pascal
608	608		procedure TQuadrat.SetSubTitle(const AValue: string);
609	609		begin
610	610		if FSubTitle = AValue then exit;
611	611		FSubTitle := AValue;
612	612		InvalidatePreferredSize;
613	613		AdjustSize;
614	614		end;
615	615		```
616	616
617	617		# Reduce overhead with DisableAutoSizing, EnableAutoSizing
618	618
619	619		Since Lazarus 0.9.29 there is a new autosizing algorithm, that reduces the overhead and allows deep nested dependencies. Up to 0.9.28 DisableAlign/EnableAlign and Disable/EnableAutoSizing worked only for one control and its direct childs.
620	620
621	621		Each time you change a property the LCL triggers a recompute of the layout:
622	622
623	623		``` pascal
624	624		Label1.Caption := 'A'; // first recompute
625	625		Label2.Caption := 'B'; // second recompute
626	626		```
627	627
628	628		The recompute will trigger events and send messages. To reduce the overhead you can suspend the autosizing:
629	629
630	630		``` pascal
631	631		DisableAutoSizing;
632	632		try
633	633		Label1.Caption := 'A'; // no recompute
634	634		Label2.Caption := 'B'; // no recompute
635	635		finally
636	636		EnableAutoSizing; // one recompute
637	637		end;
638	638		```
639	639
640	640		The calls of Disable/EnableAutoSizing must be balanced. Only when EnableAutoSizing was called the same time as DisableAutoSizing the autosizing will start.
641	641
642	642		Since 0.9.29 the Disable/EnableAutoSizing work for the whole form. This means every call of DisableAutoSizing suspends the autosizing for all controls on the same form. If you write your own control you can now use the following:
643	643
644	644		``` pascal
645	645		procedure TMyRadioGroup.DoSomething;
646	646		begin
647	647		DisableAutoSizing; // disables not only TMyRadioGroup, but the whole form
648	648		try
649	649		// delete items ...
650	650		// add, reorder items ...
651	651		// change item captions ...
652	652		finally
653	653		EnableAutoSizing; // recompute
654	654		end;
655	655		end;
656	656		```
657	657
658	658		Which basically means: you do not have to care. Just call Disable/EnableAutoSizing.
659	659
660	660		Note: this is wrong:
661	661
662	662		``` pascal
663	663		Button1.DisableAutoSizing;
664	664		Label1.EnableAutoSizing; // wrong: every control has its own counter
665	665		```
666	666
667	667		## DisableAutoSizing and Form bounds
668	668
669	669		DisableAutoSizing has another useful effect under asynchronous Window Managers like the ones under Linux. Each time a form is resized or moved the bounds are sent to the widgetset (DoSendBoundsToInterface). Even if the form is not shown the Handle is resized. The window manager often treats these bounds only as proposal, the window manager has its own logic and often only the first bounds sent are used. The second, third or further moves may be ignored. With DisableAutoSizing you can make sure that only the final bounds are sent to the widgetset making the form bounds more reliable.
670	670
671	671		# Example: a button panel
672	672
673	673		This example combines several of the LCL layout mechanisms to create a panel with three buttons: a Help button to the left and Ok and Cancel buttons to the right. We want the panel to be at the bottom of the form filling the entire width. The buttons and the panel are autosized to fit all fonts and themes.
674	674
675	675		Step 1: Create the panel and set its Align property to alBottom. Add three TBitBtns.
676	676
677	677		![](/wiki-images/7/7e/Autosize_example_buttonpanel1.png)
678	678
679	679		Set the Kind properties of the BitBtns to show the glyphs. You might need to set GlyphShowMode to gsmAlways to see them on your platform. Set the BitBtn's AutoSize property to True, which will shrink/enlarge the buttons to fit perfectly around the glyphs and text. Depending on your theme and platform you might notice that the buttons have different heights.
680	680
681	681		![](/wiki-images/4/49/Autosize_example_buttonpanel2.png)
682	682
683	683		Set the Align property of the help button to alLeft and set the other two buttons' Align property to alRight. This will enlarge the buttons vertically and move them to the far left/right. alLeft/alRight has no effect on the width, so the buttons use their preferred width.
684	684
685	685		![](/wiki-images/b/b6/Autosize_example_buttonpanel3.png)
686	686
687	687		The Panel height is still fixed. Now set the panel AutoSize property to True. The panel now shrinks vertically to fit the tallest button.
688	688
689	689		![](/wiki-images/3/36/Autosize_example_buttonpanel4.png)
690	690
691	691		The Ok button has a short caption, so the button is very small. Set the button's Constraints.MinWidth to 75. The button will now enlarge somewhat.
692	692
693	693		![](/wiki-images/3/32/Autosize_example_buttonpanel5.png)
694	694
695	695		Now add some space around the buttons. Set the panel's ChildSizing.LeftTopSpacing/RightBottomSpacing/HorizontalSpacing to 6.
696	696
697	697		![](/wiki-images/4/46/Autosize_example_buttonpanel6.png)
698	698
699	699		Finally clear the Caption of the panel and set its BevelOuter to bvNone.
700	700
701	701		![](/wiki-images/4/4e/Autosize_example_buttonpanel7.png)
702	702
703	703		# Scrolling
704	704
705	705		Some LCL controls like TScrollBox, TForm, TFrame allows to show scrollbars if the child controls do not fit. They inherit the behavior from their ancestor TScrollingWinControl.
706	706
707	707		On a scrolling control the logical client area can be bigger than the visible client area. The visible client area is ClientRect. It always starts at 0,0 and its width and height is the inner area. For example in a TGroupBox it is the size of the area inside the frame. So the following is always true:
708	708
709	709		``` pascal
710	710		ClientWidth <= Width
711	711		ClientHeight <= Height
712	712		```
713	713
714	714		The logical client area is defined by the method GetLogicalClientRect. By default it is the same as ClientRect. When a child control is anchored to the right side, it uses the logical client area. TScrollingWinControl overrides this method and returns the Range of the scrollbars if they are bigger than the ClientRect. The Range can be set manually or automatically with AutoScroll=true. An example for AutoScroll=true:
715	715
716	716		![](/wiki-images/d/db/Autoscroll_all_fit1.png)
717	717
718	718		The upper button has a fixed Width of 200. The lower button is anchored to the right side of the panel. Therefore the child controls have a preferred width of 200. Because the panel is bigger than 200 the logical client area is bigger too and the lower button expands.
719	719
720	720		Now the panel is shrinked, so that the ClientWidth gets lower than 200:
721	721
722	722		![](/wiki-images/2/27/Autoscroll_not_fit1.png)
723	723
724	724		The preferred width is still 200, so the logical client area is now 200 and bigger than the visible client area. The lower button has now a Width of 200 and the panel shows a horizontal scrollbar.
725	725
726	726		## Scroll Position
727	727
728	728		Changing the Position of a scrollbar does not change the Left, Top of child controls, does not change the logical client area and has no effect on autosizing. The child controls are only virtually moved.
729	729
730	730		## Scrolling and AutoSize
731	731
732	732		When AutoSize=true the LCL will expand the control to fit all child controls and no scrollbars are needed. If the control can not be expanded, then only the second action of AutoSize is executed: moving the child controls.
733	733
734	734		# Docking
735	735
736	736		Docking uses the described methods and properties of this page, see [[Docking]].
737	737
738	738		# Splitter
739	739
740	740		See [[TSplitter]].
741	741
742	742		# TLabel.WordWrap
743	743
744	744		TLabel.WordWrap changes the behavior of the preferred size of the label. WordWrap=true requires that the Width of the label is fixed, for example by anchoring the left and right size of the label. The preferred height of the label is then computed by breaking the Caption into multiple lines.
745	745
746	746		# DPI auto-adjustment and absolute layout auto-adjustment
747	747
748	748		Historically the LCL has been utilized mostly to design absolute layouts, despite the huge amount of options which Lazarus offers for flexible layouts, like Align, Anchors, etc, as described on the rest of this article. On top of that, it has also historically ignored the DPI of the target and instead utilized values in pixels to measure the left, top, width and height properties of controls. For desktop platforms and Windows CE this has worked reasonably ok, but with the advent of LCL support for Android this could no longer be ignored. Starts in Lazarus 0.9.31 the LCL can reinterprete the LCL absolute layout in pixels as a flexible grid. There are multiple modes to choose from and they will allow to reinterprete the pixel values as either really absolute, or as in being adjusted for the DPI or as in being considered simply a fraction of the form size.
749	749
750	750		It is important to note that these new rules affect only controls which are positioned without Align and with the most standard Anchors only.
751	751
752	752		In the case where the values will be adjusted for DPI, there is a new property: TCustomForm.DesignTimeDPI which should store the DPI value of the system where the form was designed. The positoning values will be expanded when the target DPI is larger then the design time DPI or reduced otherwise. The common value for desktop DPIs is 96 and is the default value given.
753	753
754	754		property DesignTimeDPI: Integer read FDesignTimeDPI write FDesignTimeDPI;
755	755
756	756		The way in which the layout is adjusted can be controlled with the property TApplication.LayoutAdjustmentPolicy
757	757
758		-	~~` TLayoutAdjustmentPolicy = (`\~~
759		-	~~` lapDefault, // widgetset dependent`\~~
760		-	~~` lapFixedLayout, // A fixed absolute layout in all platforms`\~~
761		-	~~` lapAutoAdjustWithoutHorizontalScrolling, // Smartphone platforms use this one,`\~~
762		-	~~` // the x axis is stretched to fill the screen and`\~~
763		-	~~` // the y is scaled to fit the DPI`\~~
764		-	~~` lapAutoAdjustForDPI // For desktops using High DPI, scale x and y to fit the DPI`\~~
765		-	~~` );`~~
	758	+	```
	759	+	TLayoutAdjustmentPolicy = (
	760	+	lapDefault, // widgetset dependent
	761	+	lapFixedLayout, // A fixed absolute layout in all platforms
	762	+	lapAutoAdjustWithoutHorizontalScrolling, // Smartphone platforms use this one,
	763	+	// the x axis is stretched to fill the screen and
	764	+	// the y is scaled to fit the DPI
	765	+	lapAutoAdjustForDPI // For desktops using High DPI, scale x and y to fit the DPI
	766	+	);
	767	+	```
766	768
767	769		And the following new methods in TControl allow to force a layout-autoadjustment in a particular control and all its children or to control how particular descendents of TControl react to this:
768	770
769	771		``` pascal
770	772		TControl = class
771	773		public
772	774		...
773	775		procedure AutoAdjustLayout(AMode: TLayoutAdjustmentPolicy;
774	776		const AFromDPI, AToDPI, AOldFormWidth, ANewFormWidth: Integer); virtual;
775	777		function ShouldAutoAdjustLeftAndTop: Boolean; virtual;
776	778		function ShouldAutoAdjustWidthAndHeight: Boolean; virtual;
777	779		```
778	780
779	781		LCL-CustomDrawn-Android will call AutoAdjustLayout when the screen rotates, for example.
780	782
781	783		# More details
782	784
783	785		Many controls override TControl.DoAutoSize to perform the actual auto-sizing.
784	786
785	787		IMPORTANT: Many Delphi controls override this method and many call this method directly after setting some properties.
786	788
787	789		During handle creation not all interfaces can create complete Device Contexts which are needed to calculate things like text size.
788	790
789	791		That's why you should always call AdjustSize instead of `DoAutoSize`.
790	792
791	793		`TControl.AdjustSize` calls `DoAutoSize` in a smart fashion.
792	794
793	795		During loading and handle creation the calls are delayed.
794	796
795	797		This method initially does the same as TWinControl.DoAutoSize. But since `DoAutoSize` is commonly overriden by descendant components, it is not useful to perform all tests, which can result in too much overhead. To reduce this the LCL calls `AdjustSize` instead.
796	798
797	799		When setting AutoSize = true the LCL autosizes the control in width and height. This is one of the most complex parts of the LCL, because the result depends on nearly a hundred properties. Let's start simple:
798	800
799	801		The LCL will only autosize the Width (Height) if it is free to resize. In other words - the width is not autosized if:
800	802
801	803		- the left and right side is anchored. You can anchor the sides with the Anchors property or by setting the Align property to alTop, alBottom or alClient.
802	804		- the Width is bound by the Constraints properties. The Contraints can also be overriden by the widgetset. For example the winapi does not allow resizing the height of a combobox. And the gtk widgetset does not allow resizing the width of a vertical scrollbar.
803	805
804	806		Same for Height.
805	807
806	808		The new size is calculated by the protected method TControl.CalculatePreferredSize. This method asks the widgetset for an appropriate Width and Height. For example a TButton has preferred Width and Height. A TComboBox has only a preferred Height. The preferred Width is returned as 0 and so the LCL does not autosize the Width - it keeps the width unaltered. Finally a TMemo has no preferred Width or Height. Therefore AutoSize has no effect on a TMemo.
807	809
808	810		Some controls override this method. For example the TGraphicControl descendants like TLabel have no window handle and so cannot query the widgetset. They must calculate their preferred Width and Height themselves.
809	811
810	812		The widgetsets must override the GetPreferredSize method for each widget class that has a preferred size (Width or Height or both).
811	813
812	814		## Parent.AutoSize
813	815
814	816		The above described the simple explanation. The real algorithm provides far more possibilities and is therefore far more complex.
815	817
816	818		## Properties / Methods
817	819
818	820		- Left
819	821		- Top
820	822
821	823		If Parent\<\>nil then Left, Top are the pixel distance to the top, left pixel of the parent's client area (not scrolled). Remember the client area is always without the frame and scrollbars of the parent. For Delphi users: Some VCL controls like TGroupbox define the client area as the whole control including the frame and some not - the LCL is more consistent, and therefore Delphi incompatible. Left and Top can be negative or bigger than the client area. Some widgetsets define a minimum/maximum somewhere around 10.000 or more.
822	824
823	825		When the client area is scrolled the Left and Top are kept unchanged.
824	826
825	827		During resizing/moving Left and Top are not always in sync with the coordinates of the Handle object.
826	828
827	829		If Parent=nil then Left, Top depend on the widgetset and the window manager. Till Lazarus 0.9.25 this is typically the screen coordinate of the left,top of the client area of the form. This is Delphi incompatible. It is planned to change this to the Left, Top of the window.
828	830
829	831		Hint: Each time you change Left and Top the LCL moves instantly and recomputes the whole layout. If you want to change Left and Top use instead:
830	832
831	833		``` pascal
832	834		with Button1 do
833	835		SetBounds(NewLeft, NewTop, Width, Height);
834	836		```
835	837
836	838		- Width
837	839		- Height
838	840
839	841		The Size in pixels must not be negative, and most widgetsets do not allow Width=0 and/or Height=0. Some controls on some platforms define a bigger minimum constraint in Constraints.MinInterfaceWidth/Height. Instead of sizing a control to Width=0 and/or Height=0, set Visible=false or Parent=nil. During resizing/moving Width and Height are not always in sync with the size of the Handle object.
840	842
841	843		- BoundsRect
842	844
843	845		Same as Bounds(Left, Top, Width, Height).
844	846
845	847		Common newbie mistake:
846	848
847	849		``` pascal
848	850		BoundsRect.Left := 3; // WRONG: common newbie mistake
849	851		```
850	852
851	853		This has no effect, because reading BoundsRect is a function. It creates a temporary TRect on the stack. The above is the same as
852	854
853	855		``` pascal
854	856		var
855	857		r: TRect;
856	858		begin
857	859		r := BoundsRect; // fetch the bounds
858	860		r.Left := 3; // change a value on the stack
859	861		end; // no change
860	862		```
861	863
862	864		- ClientRect
863	865
864	866		Left and Top are always 0,0. Width and Height are the visible size in pixels of the client area. Remember the client area is without the frame and without scrollbars. In a scrollable client area the logical client area can be bigger than the visible.
865	867
866	868		- ClientOrigin
867	869
868	870		Returns the screen coordinate of the topleft coordinate 0,0 of the client area. Note that this value is the position as stored in the interface and is not always in sync with the LCL. When a control is moved, the LCL sets the bounds to the desired position and sends a move message to the interface. It is up to the interface to handle moves instantly or queued.
869	871
870	872		- LCLIntf.GetClientBounds
871	873
872	874		Returns the client bounds of a control. Like ClientRect, but Left and Top are the pixel distances to the control's left, top. For example on a TGroupBox the Left, Top are the width and height of the left and top frame border. Scrolling has no effect on GetClientBounds.
873	875
874	876		- LCLIntf.GetWindowRect
875	877
876	878		After the call, ARect will be the control area in screen coordinates. That means, Left and Top will be the screen coordinate of the TopLeft pixel of the Handle object and Right and Bottom will be the screen coordinate of the BottomRight pixel.
877	879
878	880		- FBaseBoundsLock: integer
879	881
880	882		Increased/Decreased by LockBaseBounds/UnlockBaseBounds. Used to keep FBaseBounds during SetBounds calls.
881	883
882	884		- FBaseParentClientSize: TPoint
883	885
884	886		The Parent.ClientRect size valid for the FBaseBounds. FBaseBounds and FBaseParentClientSize are used to calculate the distance for akRight (akBottom). When the parent is resized, the LCL knows what distance to keep.
885	887
886	888		- FBoundsRectForNewParent: TRect
887	889
888	890		When changing the Parent of a control the Handle is recreated and many things can happen. Especially for docking forms the process is too unreliable. Therefore the BoundsRect is saved. The VCL uses a similar mechanism.
889	891
890	892		- fLastAlignedBounds: TRect
891	893
892	894		See TControl.SetAlignedBounds for an explanation. In short: It stops some circles between interface and LCL autosizing.
893	895
894	896		- FLastChangebounds: TRect
895	897
896	898		Used to stop calling ChangeBounds with the same coordinates. This happens very often.
897	899
898	900		- FLastDoChangeBounds: TRect
899	901
900	902		Used to avoid calling OnChangeBounds with the same coordinates. This reduces user defined autosizing.
901	903
902	904		- FLastResizeClientHeight: integer
903	905		- FLastResizeClientWidth: integer
904	906		- FLastResizeHeight: integer
905	907		- FLastResizeWidth: integer
906	908
907	909		Used to avoid calling OnResize with the same coordinates. This reduces user defined autosizing.
908	910
909	911		- FLoadedClientSize: TPoint
910	912
911	913		During loading many things are delayed and many things are set and worse: in the wrong order. That's why SetClientWidth/SetClientHeight calls are stored and set at end of loading again. This way the LCL can restore the distances (e.g. akRight) used during designing.
912	914
913	915		- FReadBounds: TRect
914	916
915	917		Same as FLoadedClientSize, but for SetLeft, SetTop, SetWidth, SetHeight.
916	918
917	919		- procedure SetBoundsRectForNewParent(const AValue: TRect);
918	920
919	921		Used to set FBoundsRectForNewParent. See above.
920	922
921	923		- procedure SetAlignedBounds(aLeft, aTop, aWidth, aHeight: integer); virtual;
922	924
923	925		As SetBounds but without changing the default sizes.
924	926
925	927		- procedure SetInitialBounds(aLeft, aTop, aWidth, aHeight: integer); virtual;
926	928
927	929		A smart version of SetBounds, reducing overhead during creation and loading.
928	930
929	931		- procedure UpdateBaseBounds(StoreBounds, StoreParentClientSize, UseLoadedValues: boolean); virtual;
930	932
931	933		Commit current bounds to base bounds.
932	934
933	935		- procedure SetClientHeight(Value: Integer);
934	936		- procedure SetClientSize(Value: TPoint);
935	937		- procedure SetClientWidth(Value: Integer);
936	938
937	939		Exists for Delphi compatibility too. Resizes the control, to get the wanted ClientRect size.
938	940
939	941		- procedure ChangeBounds(ALeft, ATop, AWidth, AHeight: integer); virtual;
940	942
941	943		This is the internal SetBounds. Applies constraints, updates base bounds, calls OnChangeBound, OnResize, locks bounds.
942	944
943	945		- procedure DoSetBounds(ALeft, ATop, AWidth, AHeight: integer); virtual;
944	946
945	947		This really sets the FLeft, FTop, FWidth, FHeight private variables.
946	948
947	949		- procedure SetBounds(aLeft, aTop, aWidth, aHeight: integer); virtual;
948	950
949	951		This is the standard procedure overriden by many Delphi controls. TWinControl overrides it too.
950	952
951	953		- - ignores calls when bounds are locked
952	954		- lock the FBoundsRealized to avoid overhead to the interface during auto sizing.
953	955
954	956		ChangeBounds is not locked this way.
955	957
956	958		- Function GetClientOrigin: TPoint; virtual;
957	959
958	960		Screen coordinate of Left, Top of client area.
959	961
960	962		- Function GetClientRect: TRect; virtual;
961	963
962	964		Size of client area. (always Left=0, Top=0)
963	965
964	966		- Function GetScrolledClientRect: TRect; virtual;
965	967
966	968		Visible client area in ClientRect.
967	969
968	970		- function GetChildsRect(Scrolled: boolean): TRect; virtual;
969	971
970	972		Returns the Client rectangle relative to the control's Left, Top. If Scrolled is true, the rectangle is moved by the current scrolling values (for an example see TScrollingWincontrol).
971	973
972	974		- function GetClientScrollOffset: TPoint; virtual;
973	975
974	976		Returns the scrolling offset of the client area.
975	977
976	978		- function GetControlOrigin: TPoint; virtual;
977	979
978	980		Returns the screen coordinate of the topleft coordinate 0,0 of the control area. (The topleft pixel of the control on the screen) Note that this value is the position as stored in the interface and is not always in sync with the LCL. When a control is moved, the LCL sets the bounds to the wanted position and sends a move message to the interface. It is up to the interface to handle moves instantly or queued.
979	981
980	982		# FAQ
981	983
982	984		## Why does AutoSize not work in the designer properly?
983	985
984	986		In the designer controls can be dragged around and properties can be set in almost any order. To allow this and avoid possible conflicts, the AutoSizing is not updated on every change at design time.
985	987
986	988		## Why does TForm.AutoSize not work when something changes?
987	989
988	990		See [[Autosize / Layout\|AutoSize and Forms]]
989	991
990	992		## Do I need to call Application.ProcessMessages when creating lots of controls?
991	993
992	994		Application.ProcessMessages is called by the LCL automatically after every message (e.g. after every event like OnClick). Calling it yourself is only needed if the changes should become visible to the user immediately. For example:
993	995
994	996		\<DELPHI\>procedure TFrom.Button1Click(Sender: TObject); begin
995	997
996		-	~~` // change width of a control`\~~
997		-	~~` Button1.Width := Button1.Width + 10;`\~~
998		-	~~` // apply any needed changes and repaint the button`\~~
999		-	~~` Application.ProcessMessages;`\~~
1000		-	~~` // do a lot of things that takes a long time`\~~
1001		-	~~` ...`\~~
1002		-	~~` // after leaving the OnClick the LCL automatically processes messages`~~
	998	+	``` pascal
	999	+	// change width of a control
	1000	+	Button1.Width := Button1.Width + 10;
	1001	+	// apply any needed changes and repaint the button
	1002	+	Application.ProcessMessages;
	1003	+	// do a lot of things that takes a long time
	1004	+	...
	1005	+	// after leaving the OnClick the LCL automatically processes messages
	1006	+	```
1003	1007
1004	1008		end;\</DELPHI\>
1005	1009
1006	1010		## When enabling Anchors at runtime the control resizes, does not use the current values. Why?
1007	1011
1008	1012		akBottom means: keep a distance to the bottom side of the parent. The distance to keep is defined by the base bounds. They are set at designtime or by runtime calls of SetBounds or UpdateBaseBounds.
1009	1013
1010	1014		For example: A TListBox (Anchors=\[akLeft,aTop\]) at designtime has a bottom distance of 100 pixel. And a button to enable/disable the akBottom of the TListBox. Now start the application and press the button to enable akBottom. The 100 pixel distance will be activated, because this was the last time the programmer defined the base bounds of the TListBox. All other resizes were done by the LCL and are irrelevant. The programmers base bounds rules. You can resize the form and the 100 pixel will be kept. In order to use the current bounds as base bounds use:
1011	1015
1012	1016		``` pascal
1013	1017		ListBox1.UpdateBaseBounds(true, true, false);
1014	1018		ListBox1.Anchors := ListBox1.Anchors + [akBottom];
1015	1019		```
1016	1020
1017	1021		Setting Anchors does not automatically call UpdateBaseBounds, because this would destroy the ability to change properties independently.
1018	1022
1019	1023		## Resizing stringgrid columns in form's OnResize event does not work
1020	1024
1021	1025		The Form's OnResize is triggered when the Form's Width, Height, ClientWidth or ClientHeight changes. This is per se independent of TStringGrid. Of course it often happens that both the Form and the TStringGrid are resized. This means using forms OnResize will often work, but not always. A prominent example where it always fails is when the theme is changed and you have a TStringGrid in a TGroupBox in a TForm. When the theme changed the form size is kept, so no Forms OnResize is triggered. But the TGroupBox changed, so the TStringGrid should be resized.
1022	1026
1023	1027		Solution: Use the TStringGrid's OnResize.
1024	1028
1025	1029		## Why is TForm.Width equal to TForm.ClientWidth?
1026	1030
1027	1031		Mattias' notes:
1028	1032
1029	1033		"There are historical and technical reasons.
1030	1034
1031	1035		For forms without parent the Clientwidth equals the Width, because the real Width including the frame was not available on Linux ten years ago (at least not reliable on various window managers). I didn't test, but I heard it is now possible with gtk2. The main problem is the autosizing, because this needs the frame sizes before the form is mapped to the screen. It might be, that this is only available after an event, which means that you have to wait for it, which means trouble for ShowModal. Changing this breaks compatibility with a lot of existing LCL code, but for this we added the LCLVersion in the lfm files.
1032	1036
1033	1037		For all other controls the rules is ClientWidth\<=Width. The Width is the ClientWidth plus the widget frame. The question is if the scrollbars belong to the frame. I would say yes and it was implemented that way some time ago. Apparently this has changed. See the current cursor problem on synedit."
1034	1038
1035	1039		## I get an infinite loop / How to debug autosizing?
1036	1040
1037	1041		Here are some notes, what other users made wrong and how to find out:
1038	1042
1039	1043		### Differences to Delphi
1040	1044
1041	1045		For Delphi users: Please read: [[Autosize / Layout\|Difference to Delphi]]
1042	1046
1043	1047		### Overriding a LCL method and triggering a recompute
1044	1048
1045	1049		You override a method and tell the LCL to compute again, even if nothing changed. Check for AdjustSize, Realign, AlignControls, InvalidatePreferredSize. For example:
1046	1050
1047	1051		``` pascal
1048	1052		procedure TMainForm.SetBounds(ALeft, ATop, AWidth, AHeight: integer);
1049	1053		begin
1050	1054		// This will create an endless loop
1051	1055		InvalidatePreferredSize;
1052	1056
1053	1057		// This will create an endless loop too:
1054	1058		OtherComponent.Left:=10;
1055	1059		OtherComponent.Left:=20;
1056	1060
1057	1061		inherited SetBounds(ALeft, ATop, AWidth, AHeight);
1058	1062		end;
1059	1063		```
1060	1064
1061	1065		Explanation: The SetBounds method is called often, even without changing anything. For example a "Left:=30;" will do so.
1062	1066
1063	1067		Remedy: Check for changes:
1064	1068
1065	1069		``` pascal
1066	1070		procedure TMainForm.SetBounds(ALeft, ATop, AWidth, AHeight: integer);
1067	1071		begin
1068	1072		if (Left <> ALeft) or (Top <> ATop) or (Width <> AWidth) or (Height <> AHeight) then
1069	1073		InvalidatePreferredSize;
1070	1074		inherited SetBounds(ALeft, ATop, AWidth, AHeight);
1071	1075		end;
1072	1076		```
1073	1077
1074	1078		### OnResize/OnChangeBounds conflict with LCL properties
1075	1079
1076	1080		You set bounds that bite the LCL properties. For example a TLabel.AutoSize is true by default. If you set the Label1.Width in an OnResize event, the LCL will recompute, resize the Label1 and call the OnResize again. Start your application in the debugger and reproduce the bug. When it enters the loop, pause the application and see the call stack. If you see one of your events or your methods start searching there. For example:
1077	1081
1078	1082		``` pascal
1079	1083		procedure TMainForm.FormResize(Sender: TObject);
1080	1084		begin
1081	1085		// if Button1 is anchored or AutoSize=true then the following might create an endless loop:
1082	1086		Button1.Width:=100;
1083	1087		end;
1084	1088		```
1085	1089
1086	1090		### LCL interface bug, custom widget
1087	1091
1088	1092		Sometimes the LCL interface or your custom control has a bug and undoes the LCL bounds. Compile the LCL with -dVerboseIntfSizing. This will write the communication between LCL and the LCL interface. If a widget does not allow free resizing, it must tell the LCL via the Constraints. Search for SetInterfaceConstraints in the various LCL interfaces and TWSControlClass.ConstraintWidth/Height.
1089	1093
1090	1094		### alCustom
1091	1095
1092	1096		You use alCustom. This was only half implemented in earlier Lazarus versions, but some clever programmers used it to create some special effects. Now it is implemented and your program does not work anymore. Please see here what alCustom does: [[Autosize / Layout\|alCustom]].
1093	1097
1094	1098		# See also
1095	1099
1096	1100		- [[Docking]]
1097	1101		- [[Anchor Sides]]
1098	1102
1099	1103		---
1100	1104		From the Free Pascal wiki, page "Autosize / Layout/zh TW", as it stood on 2020-02-09 after a change by Trev, 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).

Back to history