Anchor Docking: what changed

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

Old	New		Line
1	1		About docking in general see [[Docking]].
2	2
3	3		## Overview
4	4
5	5		Docking allows you to combine forms, or to treat controls as forms. You use the mouse to drag and dock forms together or undock (split) them. The basic dragging, docking and undocking functionality is provided by the LCL. But you need a docking manager to add splitters and grab zones, and to save and restore layouts.
6	6
7	7		Anchor docking has been implemented since version 0.9.29 in the package anchordocking.lpk for use in your own Lazarus applications, and AnchorDockingDsgn.lpk if you wish to make the Lazarus IDE windows dockable. It is easy to use, and provides many features and options not available in earlier docking packages.
8	8
9	9		You will find a code example at: components/anchordocking/miniide/miniide1.lpi
10	10
11	11		This means that the earlier TLazDockingManager and unit LDockCtrl are obsolete and now deprecated.
12	12
13	13		### Features
14	14
15	15		- Drag and dock: Headers are added that can be dragged to dock controls with the mouse. Preview rectangles will show where and how a control is docked.
16	16		- Any layout: By using the LCL's anchors almost any layout is possible. You can dock to left, right, top, bottom, inside or outside or as page like in a TPageControl. You can enlarge docked controls via the popup menu. No need to undock your whole layout.
17	17		- What you see is how it is structured: There are no hidden panels to align controls in rows and columns. Anchor docking makes sure forms do not overlap.
18	18		- Splitters are automatically inserted between docked forms to allow resizing.
19	19		- Page docking. Forms can be docked not only left/right/above/below, but in pages too. A TPageControl is automatically created for native look and feel. A page can contain arbitrary docked forms too, including paged docked forms, allowing nested pages and layouts. When a page is undocked the pagecontrol is automatically removed. You can drag and drop the tabs or use the popup menu to move pages.
20	20		- Easy use: With one line of code you can make a form or control dockable. Just give them unique names.
21	21		- Not only forms, but any TWinControl can be made dockable.
22	22		- Can save/load layouts. The layout information is stored for each dockable control and old layout files will still work even when the application gets more dockable controls or some are removed. The information is stored in the abstract class LCL TConfigStorage. So you can use for example TXMLConfigStorage to store layouts in xml files or you can write your own storage to store it wherever you want.
23	23		- Each docked form is put into a docksite providing an optional header. The header shows the caption of the docked form and contains a close button. You can drag the header to drag the form and undock it or to dock it at another position. The header can be at any of the four sides and moves by default automatically to the smaller side to save space. You can customize this. The header shows a customizable hint allowing to read long captions.
24	24		- When a docksite is resized the child sites are automatically scaled. You can turn this off.
25	25		- Preserve size of forms. For instance when docking a form to a left side of a site the width of the docked form is kept. The same for the other sides and the same for undocking.
26	26		- Flickerless: The restore tries to reuse existing sites and splitters to reduce creation and flickering of forms and to preserve the Z order of forms. This allows to quickly switch between layouts.
27	27		- Header popup menu:
28	28		- lock/unlock (disable dragging)
29	29		- header position (auto, left, top, right, bottom), this is saved/restored with the layout
30	30		- merge (for example after moving a dock page into a layout)
31	31		- undock (needed if no place to undock on screen)
32	32		- enlarge side to left, top, right, bottom
33	33		- close
34	34		- options
35	35		- Page popup menu:
36	36		- lock/unlock (disable dragging)
37	37		- undock (needed if no place to undock on screen)
38	38		- tab position for pagecontrol (top,bottom, left, right), this is saved/restored with the layout
39	39		- move page to the left, right, leftmost, rightmost
40	40		- close
41	41		- options
42	42		- Forms can be made dock sites. Then they can dock at one side. But they can not be docked itself.
43	43		- close button automatically saves a layout
44	44		- Powerful functions to alter the layout. You can use D&D to move a form and you can undock and dock in one move. There are functions to enlarge forms and shrinking others. These functions are available via the header popup menu as well. See below.
45	45		- There is an IDE package which makes the Lazarus IDE dockable. It is called anchordockingdsgn.lpk. Make sure you only install one docking package. Do not install the easydockmgr at the same time!
46	46
47	47		### ToDos
48	48
49	49		- Design time package: Add all layout files to menu
50	50		- simple way to make forms dockable at designtime (that means without writing any code)
51	51		- minimize button and Hide
52	52		- on show again: restore a default layout
53	53		- close button for pages
54	54		- Implement automatic menu merging in the LCL (when two forms with main menus are docked).
55	55
56	56		## Usage I. (Add docking support to the Lazarus IDE)
57	57
58	58		If you don't like the default "separate windows" look of the Lazarus IDE and prefer a single window (e.g., like RAD Studio™), you can install a package called [[AnchorDockingDsgn]] (lazarus/components/anchordocking/design/anchordockingdsgn.lpk). This package makes the IDE windows dockable.
59	59
60	60		### Important to macOS users
61	61
62	62		Before Lazarus 3.0, there are many bugs related to docking.
63	63
64	64		If "anchordockingdsgn" has been installed before Lazarus 3.0, the wrong configuration may be saved and needs to be reset first.
65	65
66	66		The configuration is saved in environmentoptions.xml, which usually located in ~/.lazarus
67	67
68	68		Close the IDE, locate environmentoptions.xml, delete the content between \<AnchorDocking\> and \</AnchorDocking\>, and the initial setting of anchordockingdsgn will be automatically set when the IDE is started again.
69	69
70	70		### Installation
71	71
72	72		Uninstall any other docking managers (e.g., easydockmgrdsgn). From the Lazarus menu bar pick "Package" - "Install/Uninstall Packages" and install the "anchordockingdsgn" package.
73	73
74	74		After you have successfully installed the package and restarted the IDE, the IDE starts with a default docked layout like shown below. Note that AnchorDocking headers and splitters have been added to all dockable windows of the IDE. In case the headers don't get visible, see the section "Options" below on how to enable/disable them.
75	75
76	76		![](/wiki-images/a/ac/2021-12-02_10_21_07-Debian_10.8_Buster_-_VMware_Workstation.png)
77	77
78	78		You can change the layout by grabbing a dockable window by the Anchordocking header and drag and dock it anywhere else, or resize docked windows via splitters added to the window borders. You can right-click on the headers too for other options, for example, to change the look of the headers, as shown farther down below.
79	79
80	80		You can save the layout via the menu item Tools / Save window layout as default. This saves to ~/.lazarus/anchordocklayout.xml and restores it when the IDE starts up.
81	81
82	82		You can also save the layout to a file and load them later.
83	83
84	84		Since Lazarus 1.1 you can pass a command line parameter
85	85
86		-	~~`./lazarus --anchordocklayout=<filename>`~~
	86	+	```
	87	+	./lazarus --anchordocklayout=<filename>
	88	+	```
87	89
88	90		The look (like the headers) can be further tweaked by right-clicking on them.
89	91
90	92		![](/wiki-images/8/8a/Docking_headers.gif)
91	93
92	94		### Options
93	95
94	96		After the successful installation of the AnchorDockingDsgn package, an additional configuration menu is added to the Lazarus options dialog ("Tools" - "Options" - "Environment")
95	97
96	98		![](/wiki-images/3/3a/Anchordocking_options.png)
97	99
98	100		#### Scale on resize
99	101
100	102		When resizing a window, all docked forms inside are scaled by the same percentage.
101	103
102	104		#### Show headers
103	105
104	106		To dock/undock a window, you need to enable this option.
105	107
106	108		#### Flatten headers
107	109
108	110		No 3d frame in headers.
109	111
110	112		#### Header align top/left
111	113
112	114		Headers are automatically put at top or left depending on these two values:
113	115
114	116		- Move header to top, when (width/height)*100\<=HeaderAlignTop, default 80
115	117		- Move header to left, when (width/height)*100\>=HeaderAlignLeft, default 120
116	118		- Otherwise keep the header at the current position.
117	119
118	120		Which means the header is by default put at the smaller side of a docked control. When the control is resized, the header switches to the smaller side.
119	121
120	122		#### Allow dock sites to be minimized
121	123
122	124		A extra minimize button is added, so a site can be minimized. Then sites next to it get more space. If needed, the minimized site then can easy be opened.
123	125
124	126		#### Multine Tabs
125	127
126	128		Feature added in Lazarus 2.2. If a OS support multiline tabs (like Windows), if there are no many tabs, they are shown in multiple lines.
127	129
128	130		#### Floating windows on top
129	131
130	132		Feature added in Lazarus 2.2. If there are undocked windows shown, show these on top of main window. In a own application, there can be set DockMaster.MainDockForm, then all floating windows are shown on top of it. If MainDockForm is not set, Application.MainForm is used.
131	133
132	134		## Usage II. (Add docking support to your own applications)
133	135
134	136		### Quick start
135	137
136	138		Add the package AnchorDocking to the required packages in the project inspector.
137	139
138	140		Then add the unit AnchorDocking to the uses section of your main unit (the unit with your main form).
139	141
140	142		Add to the FormCreate of your main form:
141	143
142	144		``` pascal
143	145		DockMaster.MakeDockSite(Self,[akBottom],admrpChild);
144	146		```
145	147
146	148		For the other dockable forms replace all calls of Show and ShowOnTop with
147	149
148	150		``` pascal
149	151		DockMaster.MakeDockable(Form1,true,true);
150	152		```
151	153
152	154		For the other dockable forms replace all calls of Visible:=true with
153	155
154	156		``` pascal
155	157		DockMaster.MakeDockable(Form1,true);
156	158		```
157	159
158	160		Remove or comment all Hide, Visible:=false, WindowState:= calls.
159	161
160	162		### Prerequisites
161	163
162	164		- Your project must use the package AnchorDocking.
163	165		- All dockable forms must be shown with MakeDockable or MakeDockSite. Do not use Show, BringToFront, ShowOnTop, Visible:=true. Of course you can have some non dockable forms, like hints or splashscreens.
164	166		- All dockable forms must be free resizable, that means no constraints, no BorderStyle bsDialog.
165	167		- No other docking system. AnchorDocking is incompatible with EasyDockMgr.
166	168
167	169		### Making forms dockable
168	170
169	171		There are two ways to make a form dockable. You can use DockMaster.MakeDockable to wrap a form into a dock site. Then your form can dock and be docked completely free. You will use that for the biggest part of your forms, except for the MainForm, because this is only supported for the MainForm on gtk2 and qt. The second way is to use DockMaster.MakeDockSite. The form can dock other sites, but can not be docked itself. You might want to use MakeDockSite for the MainForm. For most other forms you probably want to use this:
170	172
171	173		``` pascal
172	174		// shows YourForm
173	175		// if not already done, wrap the form into a dock site
174	176		DockMaster.MakeDockable(YourForm);
175	177		```
176	178
177	179		Here are some examples how a form looks like that was made dockable with DockMaster.MakeDockable:
178	180
179	181		![](/wiki-images/b/bc/Docksite1.png) ![](/wiki-images/c/c6/Docksite2.png)
180	182
181	183		The header position is normally done automatically and the user can with a right click put it to any of the four sides.
182	184
183	185		### Example: miniide1
184	186
185	187		The example can be found in lazarus/components/anchordocking/miniide/miniide1.lpi. It has a mainform in unit unit1.pas with a main menu which works as a docksite and several forms that are dockable.
186	188
187	189		![](/wiki-images/a/a5/Anchordocking_miniide1.png)
188	190
189	191		### Making the main form a dock site
190	192
191	193		In the TMainIDE.FormCreate the main form MainIDE is turned into a docksite:
192	194
193	195		``` pascal
194	196		DockMaster.MakeDockSite(Self,[akBottom],admrpChild);
195	197		```
196	198
197	199		The parameter \[akBottom\] allows to dock other sites at the bottom of MainIDE. The parameter admrpChild tells the DockMaster that when the MainIDE is enlarged the extra space is distributed to the docked sites.
198	200
199	201		When the user docks a site to the bottom of MainIDE the site is put onto MainIDE (Site.Parent:=MainIDE) with Site.Align=alBottom. The other controls on MainIDE must be compatible to this. MainIDE for example has a BtnPanel with Align=alLeft and a TNoteBook with Align=alClient. See [[Autosize / Layout\|here]] how Align works.
200	202
201	203		The DockMaster adds automatically a splitter:
202	204
203	205		![](/wiki-images/c/ca/Anchordocking_miniide_dockedse1.png)
204	206
205	207		As soon as a dockable form is docked its caption is shown in the dock header.
206	208
207	209		#### Requirements for a custom dock site
208	210
209	211		As long as nothing is docked into a custom dock site, your form can do everything as a normal form. But when a site is docked to it, some properties and methods need special care:
210	212
211	213		- AutoSize=true may result in an endless loop. Disable it or override DoAutoSize/CalculatePreferredSize and take special care.
212	214		- Constraints: The DockMaster clears the maximum Constraints and will restore them on undock.
213	215		- Child controls anchored to the aligned site may overlap. See [[Autosize / Layout\|here]] how Align works.
214	216		- ChildSizing: The spacing properties like LeftRightSpacing, TopBottomSpacing may interfere with the docking layout.
215	217
216	218		### Procedure to create all other forms by name
217	219
218	220		The MainIDE sets the DockMaster.OnCreateControl event, to enable the DockMaster to create forms by name. This is needed to restore layouts.
219	221
220	222		``` pascal
221	223		DockMaster.OnCreateControl:=@DockMasterCreateControl;
222	224		```
223	225
224	226		``` pascal
225	227		procedure TMainIDE.DockMasterCreateControl(Sender: TObject; aName: string; var
226	228		AControl: TControl; DoDisableAutoSizing: boolean);
227	229
228	230		procedure CreateForm(Caption: string; NewBounds: TRect);
229	231		begin
230	232		AControl:=CreateSimpleForm(aName,Caption,NewBounds,DoDisableAutoSizing);
231	233		end;
232	234
233	235		begin
234	236		// first check if the form already exists
235	237		// the LCL Screen has a list of all existing forms.
236	238		// Note: Remember that the LCL allows as form names only standard
237	239		// pascal identifiers and compares them case insensitive
238	240		AControl:=Screen.FindForm(aName);
239	241		if AControl<>nil then begin
240	242		// if it already exists, just disable autosizing if requested
241	243		if DoDisableAutoSizing then
242	244		AControl.DisableAutoSizing;
243	245		exit;
244	246		end;
245	247		// if the form does not yet exist, create it
246	248		if aName='CodeExplorer' then
247	249		CreateForm('Code Explorer',Bounds(700,230,100,250))
248	250		...
249	251		else if aName='DebugOutput' then
250	252		CreateForm('Debug Output',Bounds(400,400,350,150));
251	253		end;
252	254		```
253	255
254	256		Creating a form can be as simple as this:
255	257
256	258		``` pascal
257	259		MyForm:=TMyForm.Create(Self);
258	260		if DoDisableAutoSizing then
259	261		MyForm.DisableAutoSizing;
260	262		```
261	263
262	264		But of course you can put there all kind of initialization code.
263	265
264	266		The DisableAutoSizing reduces flickering. Make sure your forms Visible property is set to false.
265	267
266	268		Remember to call DisableAutoSizing for the form if the parameter DoDisableAutoSizing is set to true, because Disable- and EnableAutosizing calls must be balanced. If you miss the DisableAutosizing, the LCL will raise an exception later:
267	269
268		-	~~`TControl.EnableAutoSizing SourceEditor1:TSimpleForm: missing DisableAutoSizing`~~
	270	+	```
	271	+	TControl.EnableAutoSizing SourceEditor1:TSimpleForm: missing DisableAutoSizing
	272	+	```
269	273
270	274		![](/wiki-images/8/8e/MissingDisableAutoSizing.png)
271	275
272	276		If you call DisableAutoSizing too much, your forms will not appear and/or not resize properly as the LCL is waiting for the EnableAutoSizing call that never comes.
273	277
274	278		### Showing forms
275	279
276	280		When a form should be shown, you have probably used something like 'MyForm.Show. Instead you should now use
277	281
278	282		``` pascal
279	283		DockMaster.MakeDockable(MyForm);
280	284		```
281	285
282	286		This will wrap MyForm in a dock site and show it. It is clever enough to figure out if the form is already wrapped in a dock site.
283	287
284	288		If you set the DockMaster.OnCreateControl event you can use this:
285	289
286	290		``` pascal
287	291		DockMaster.ShowControl('MyForm',true);
288	292		```
289	293
290	294		### Docking manually, via code
291	295
292	296		Use the procedure DockMaster.ManualDock to dock a site to or into another.
293	297
294	298		``` pascal
295	299		procedure ManualDock(SrcSite, TargetSite: TAnchorDockHostSite; Align: TAlign; TargetControl: TControl = nil);
296	300		```
297	301
298	302		- SrcSite is the site to be docked. If SrcSite was docked it will be undocked first.
299	303		- TargetSite is the site where SrcSite will be docked into or docked as neighbor.
300	304		- TargetControl specifies if docking as neighbor (=nil), as inside neighbor (=TargetSide) or in front of a page (=a TAnchorDockPage).
301	305
302	306		### Undocking manually, via code
303	307
304	308		Use the procedure DockMaster.ManualFloat to undock a site from its neighbors and create a flotaing top level form. The embedded control stays embedded into a TAnchorDockHostSite.
305	309
306	310		``` pascal
307	311		procedure ManualFloat(AControl: TControl);
308	312		```
309	313
310	314		You can give as parameter a TAnchorDockHostSite or a control embedded into a TAnchorDockHostSite (for example a form made dockable with MakeDockable). The site will be put at the same screen location.
311	315
312	316		### Save layout
313	317
314	318		The DockMaster allows to save the current layout to a TConfigStorage. The miniide example uses the xml version:
315	319
316	320		``` pascal
317	321		procedure TMainIDE.SaveLayout(Filename: string);
318	322		var
319	323		XMLConfig: TXMLConfigStorage;
320	324		begin
321	325		try
322	326		// create a new xml config file
323	327		XMLConfig:=TXMLConfigStorage.Create(Filename,false);
324	328		try
325	329		// save the current layout of all forms
326	330		DockMaster.SaveLayoutToConfig(XMLConfig);
327	331		XMLConfig.WriteToDisk;
328	332		finally
329	333		XMLConfig.Free;
330	334		end;
331	335		except
332	336		on E: Exception do begin
333	337		MessageDlg('Error',
334	338		'Error saving layout to file '+Filename+':'#13+E.Message,mtError,
335	339		[mbCancel],0);
336	340		end;
337	341		end;
338	342		end;
339	343		```
340	344
341	345		### Load layout
342	346
343	347		``` pascal
344	348		procedure TMainIDE.LoadLayout(Filename: string);
345	349		var
346	350		XMLConfig: TXMLConfigStorage;
347	351		begin
348	352		try
349	353		// load the xml config file
350	354		XMLConfig:=TXMLConfigStorage.Create(Filename,True);
351	355		try
352	356		// restore the layout
353	357		// this will close unneeded forms and call OnCreateControl for all needed
354	358		DockMaster.LoadLayoutFromConfig(XMLConfig);
355	359		finally
356	360		XMLConfig.Free;
357	361		end;
358	362		except
359	363		on E: Exception do begin
360	364		MessageDlg('Error',
361	365		'Error loading layout from file '+Filename+':'#13+E.Message,mtError,
362	366		[mbCancel],0);
363	367		end;
364	368		end;
365	369		end;
366	370		```
367	371
368	372		### Enlarge/Shrink
369	373
370	374		The anchor docking manager can enlarge/shrink docked neighbors. This is done via the popup menu of the dock header or in code with the function DockMaster.ManualEnlarge:
371	375
372	376		``` pascal
373	377		function ManualEnlarge(Site: TAnchorDockHostSite; Side: TAnchorKind; OnlyCheckIfPossible: boolean): boolean;
374	378		```
375	379
376	380		Site is a child site, Side the side of Site to expand. If you only want to test if enlarge is possible set OnlyCheckIfPossible to true.
377	381
378	382		### Enlarge one, shrink another
379	383
380	384		Shrink neighbor Object Inspector, enlarge Messages: Right click on the header of Messages and click on Enlarge right side. Two splitters are resized.
381	385
382	386		![](/wiki-images/1/15/Anchordocking_before_enlarge1.png) enlarging Messages to the right side: ![](/wiki-images/f/f8/Anchordocking_after_enlarge1.png)
383	387
384	388		### Enlarge one, shrink many
385	389
386	390		Shrink splitter at one side, enlarge both neighbor splitters, rotate the splitter behind, enlarge Control, shrink controls at rotate splitter. Right click on header of Source Editor 1 then click on Enlarge bottom side.
387	391
388	392		![](/wiki-images/c/cb/Anchordocking_before_enlarge2.png) becomes ![](/wiki-images/4/42/Anchordocking_after_enlarge2.png)
389	393
390	394		### General docking options
391	395
392	396		The AnchorDocking package provides a dialog to setup some of the properties of the DockMaster. The dialog is in the unit AnchorDockOptionsDlg and you can use it simply:
393	397
394	398		``` pascal
395	399		uses ... AnchorDockOptionsDlg;
396	400		...
397	401		procedure TMainIDE.FormCreate(Sender: TObject);
398	402		...
399	403		begin
400	404		...
401	405		DockMaster.OnShowOptions:=@ShowAnchorDockOptions;
402	406		...
403	407		end;
404	408		```
405	409
406	410		This will add a new menu item to the popup menus of the dock headers and pages called Docking options.
407	411
408	412		## Why use Anchors instead of Align?
409	413
410	414		Anchors allow to create any possible rectangular layout. Align is limited. Align with Panels can theoretically create a lot of layouts, but still not all. And some operations like enlarge/shrink are more complicated using Align/Panels than using Anchors. Align works good for a few forms, but the more forms are docked, the more the disadvantages of Align become visible.
411	415
412	416		### Layouts that can be created with Align
413	417
414	418		Align can only create the following layouts:
415	419
416	420		![](/wiki-images/1/13/Anchordocking_align_layout1.png)
417	421
418	422		The alTop controls are always at the top, filling the whole horizontal width. That's because the LCL first aligns all controls with alTop, then all alBottom, then alLeft, then alRight and finally alClient.
419	423
420	424		### Layouts that can be created with Align and Panels
421	425
422	426		It is possible to nest Align layouts by using hidden panels. Then any layout that can be recursively splitted in halves can be created. Then you can create for example:
423	427
424	428		![](/wiki-images/0/0e/Anchordocking_align_panels_layout1.png)
425	429
426	430		This requires only one hidden panel.
427	431
428	432		### Changing Layouts
429	433
430	434		Now the user wants to enlarge the FPDocEditor horizontally (and shrink CodeExplorer). With the AnchorDocking you can simply right click on the FPDocEditor header and click Enlarge right side.
431	435
432	436		![](/wiki-images/8/88/Anchordocking_align_panels_layout2.png)
433	437
434	438		Other docking engines need at least 2 panels. One for SrcEditor,Messages,FPDocEdit,CodeExpl and one for SrcEdit and Messages. Most docking layouters do not even provide a simple way to change the layout in this way. An algorithm to allow this layout change, must analyze the whole structure as if there were no panels and must reparent a lot of things. Basically the algorithm must do the same as the anchor docking algorithm, but with the extra work of translating the layout into Align plus hidden panels.
435	439
436	440		### Layouts that are impossible with Align and Panels
437	441
438	442		Now the user wants to enlarge SourceEditor1 horizontally (and shrink ObjectInspector):
439	443
440	444		![](/wiki-images/e/e9/Anchordocking_impossible_with_align_panels1.png)
441	445
442	446		This layout is impossible with Align and panels, because you can not cut it in two halves. The same with
443	447
444	448		![](/wiki-images/1/1e/Anchordocking_impossible_with_align_panels2.png)
445	449
446	450		### Conclusion
447	451
448	452		Align with hidden panels allows you to easily create a simple docking manager that works well for a few forms, but it will always limit the user. Align is useful for row and column layouts, not for tables. Anchor docking works even for complex forms.
449	453
450	454		## Old/deprecated anchor docking
451	455
452	456		### Create a TLazDockingManager
453	457
454	458		``` pascal
455	459		DockingManager:=TLazDockingManager.Create(Self);
456	460		```
457	461
458	462		The Self as parameter is only used as Owner. That means, when the mainform is freed, the DockingManager is freed too. You can use nil and free the DockingManager yourself.
459	463
460	464		### Optional: Loading a configuration
461	465
462	466		You can load the user configuration from disk.
463	467
464	468		``` pascal
465	469		Config:=TXMLConfigStorage.Create('config.xml',true);
466	470		DockingManager.LoadFromConfig(Config);
467	471		Config.Free;
468	472		```
469	473
470	474		This loads the file config.xml. The config can be created by the SaveToConfig function. See below.
471	475
472	476		### Make a form/control dockable
473	477
474	478		Create a TLazControlDocker for each form/control that should be dockable
475	479
476	480		``` pascal
477	481		ControlDocker1:=TLazControlDocker.Create(Self);
478	482		ControlDocker1.Name:='DockerForm1';
479	483		ControlDocker1.Manager:=DockingManager;
480	484		```
481	485
482	486		### Optional: Saving the user configuration to disk
483	487
484	488		When the program is closed you can save the user configuration to disk
485	489
486	490		``` pascal
487	491		Config:=TXMLConfigStorage.Create('config.xml',true);
488	492		DockingManager.SaveToConfig(Config);
489	493		Config.WriteToDisk;
490	494		Config.Free;
491	495		```
492	496
493	497		## See also
494	498
495	499		- [[AnchorDockingDsgn]] AnchorDocking in the Lazarus IDE
496	500		- [[Anchor Docking Step by step example\|Anchor Docking: A Step by step example]]
497	501		- [[Docking]] in general
498	502		- [[EasyDockingManager]] - an alternative docking implementation with a simpler layout engine and fewer options.
499	503
500	504		---
501	505		From the Free Pascal wiki, page "Anchor Docking", as it stood on 2024-01-27 after a change by Rich2014, 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).
502	506		Category: Docking
503	507		Category: Lazarus IDE plugins

Back to history