Extending the IDE/es: what changed

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

Old	New		Line
1	1		# Extendiendo el IDE
2	2
3	3		## Visión general
4	4
5	5		El IDE de Lazarus soporta varios tipos de plugins:
6	6
7	7		Componentes
8	8		Estos son los elementos que se encuentrar en la Paleta de Componentes. Por ejemplo, TButton (que se encuentra en la solapa Standard) que se utiliza para crear Buttons.
9	9
10	10		Component Editors
11	11		Cuando haces doble click sobre un componente en el Diseñador, se invoka un editor de componente. El editor de componente puede además añadir un elemento extra al menú emergente (accedido cuando haces click en el pulsador derecho en un componente dentro del Diseñador).
12	12
13	13		Property Editors
14	14		Cada fila en la sección de la rejilla (grid) del Inspector de Objetos utiliza un editor de propiedades que permite establecer o alterar el valor de su propiedad.
15	15
16	16		Experts
17	17		Experts abarca todos los demás tipos de plugin. Pueden registrar nuevos elementos de menú, registrar atajos (short cuts), o extender otras características del IDE.
18	18
19	19		Hay dos maneras posibles de añadir tus propios plugins al IDE de Lazarus:
20	20
21	21		1. Escribir un paquete, instalarlo y registrar tu plugin(s) en el procedimiento 'Register' procedure de una unit.
22	22		2. Extender el cógigo de Lazarus, y enviar tu svn diff a la lista de correo de Lazarus.
23	23
24	24		## Paquetes y Dependencias MakeFile
25	25
26	26		Los siguientes pasos son necesarios para añadir nuevas dependencias de paquete.
27	27
28	28		- Crear/Actualizar el MakeFile para el paquete vía Editor de Paquete / Más ... / Crear Makefile.
29	29		- Corregir todas las dependencias. Ver tools/updatemakefiles.lpi
30	30
31	31		# Elementos del Menú
32	32
33	33		Puedes añadir nuevos elementos al menú, ocultar o mover los existentes y añadir sub menús y secciones. Puedes registrar TMainMenu/TPopupMenu para tus propios formularios de forma que otros paquetes puedan extender más tu formulario. La unidad MenuIntf del paquete IDEIntf contiene todos todos los registros para menús y algunos elementos menú estandar del propio IDE.
34	34
35	35		## Añadiendo un elemento al menú
36	36
37	37		Un simple elemento de menú tal como 'View Object Inspector' se llama TIDEMenuCommand. Puedes crear uno con RegisterIDEMenuCommand, que tiene dos fomas con un montón de parámetros:
38	38
39	39		``` pascal
40	40
41	41		function RegisterIDEMenuCommand(Parent: TIDEMenuSection;
42	42		const Name, Caption: string;
43	43		const OnClickMethod: TNotifyEvent = nil;
44	44		const OnClickProc: TNotifyProcedure = nil;
45	45		const Command: TIDECommand = nil;
46	46		const ResourceName: String = ''
47	47		): TIDEMenuCommand; overload;
48	48		function RegisterIDEMenuCommand(const Path, Name, Caption: string;
49	49		const OnClickMethod: TNotifyEvent = nil;
50	50		const OnClickProc: TNotifyProcedure = nil;
51	51		const Command: TIDECommand = nil;
52	52		const ResourceName: String = ''
53	53		): TIDEMenuCommand; overload;
54	54		```
55	55
56	56		La diferencia entre los dos consiste solamente en como se especifica la sección padre del menú. Puedes dar la sección del menú directamente o bien indirectamente a través de su trayecto. Algunas secciones estandar las puedes encontrar en la unidad MenuIntf Por ejemplo, la sección mnuTools, la cual es el menú Tools de la barra principal del IDE. Contiene una secciónon itmSecondaryTools, que es la sección recomendada para utilidades de terceros.
57	57
58	58		Lo siguiente registra un nuevo mandato de menú con el nombre 'MyTool', el caption 'Arranca mi utilidad' y cuando es clickeada ejecuta el procedimiento StartMyTool:
59	59
60	60		``` pascal
61	61		procedure StartMyTool;
62	62		begin
63	63		...ejecutada cuando el elemento del menú es clickeado...
64	64		end;
65	65
66	66		procedure Register;
67	67		begin
68	68		RegisterIDEMenuCommand(itmSecondaryTools, 'MyTool','Aranca mi utilidad',nil,@StartMyTool);
69	69		end;
70	70		```
71	71
72	72		If you want to call a method instead of a procedure use the OnClickMethod parameter.
73	73
74	74		Este elemento de menú no tiene un atajo. En caso de necesitar uno debes crear un TIDECommand y pasarlo en el parámetro Command. Por ejemplo:
75	75
76	76		``` pascal
77	77		uses ... IDECommands, MenuIntf;
78	78		...
79	79		var
80	80		Key: TIDEShortCut;
81	81		Cat: TIDECommandCategory;
82	82		CmdMyTool: TIDECommand;
83	83		begin
84	84		// register IDE shortcut and menu item
85	85		Key := IDEShortCut(VK_UNKNOWN,[],VK_UNKNOWN,[]);
86	86		Cat:=IDECommandList.FindCategoryByName(CommandCategoryToolMenuName);
87	87		CmdMyTool := RegisterIDECommand(Cat,'Start my tool', 'Starts my tool to do some stuff', Key, nil, @StartMyTool);
88	88		RegisterIDEMenuCommand(itmSecondaryTools, 'MyTool', 'Start my tool', nil, nil, CmdMyTool);
89	89		end;
90	90		```
91	91
92	92		# Atajos (Shortcuts)
93	93
94	94		Todos los atajos (teclas que invocan alguna acción) se encuentran registradas en el IDECommandList. Este es un ejemplo sobre como encontrar todos los mandatos que reaccionan a la pulsación de Ctrl-D o la combinación de teclas pulsadas que comiencen por Ctrl-D:
95	95
96	96		``` pascal
97	97		uses
98	98		Classes, SysUtils, LCLProc, IDECommands;
99	99
100	100		procedure ListCtrlD;
101	101		// Lista todos los idecommands con el atajo Ctrl-D
102	102		var
103	103		i: integer;
104	104		Cmd: TIDECommand;
105	105		Commands: TFPList;
106	106		begin
107	107		Commands:=IDECommandList.FindCommandsByShortCut(IDEShortCut(VK_D,[],VK_UNKNOWN,[])); // VK = Virtual Key
108	108		try
109	109		for i:=0 to Commands.Count-1 do begin
110	110		Cmd:=TIDECommand(Commands[i]);
111	111		writeln('Cmd: ',Cmd.Name,
112	112		' A=',dbgs(Cmd.ShortcutA.Shift1),'-',Cmd.ShortcutA.Key1,
113	113		',',dbgs(Cmd.ShortcutA.Shift2),'-',Cmd.ShortcutA.Key2,
114	114		' B=',dbgs(Cmd.ShortcutB.Shift1),'-',Cmd.ShortcutB.Key1,
115	115		',',dbgs(Cmd.ShortcutB.Shift2),'-',Cmd.ShortcutB.Key2
116	116		);
117	117		end;
118	118		finally
119	119		Commands.Free;
120	120		end;
121	121		end;
122	122		```
123	123
124	124		# Config files
125	125
126	126		## Cargar/Salvar configuraciones
127	127
128	128		Todos los ficheros de configuración del IDE se encuentran almacenados en un directorio como ficheros xml. Los paquetes también también pueden añadir sus propios ficheros en dicho directorio. El [[pcp\|primary config path]] se puede leer con:
129	129
130	130		``` pascal
131	131		uses LazIDEIntf;
132	132		...
133	133		Directory := LazarusIDE.GetPrimaryConfigPath;
134	134		```
135	135
136	136		Los paquetes pueden crear su propios ficheros xml con:
137	137
138	138		``` pascal
139	139		uses
140	140		..., LCLProc, BaseIDEIntf, LazConfigStorage;
141	141
142	142		const
143	143		Version = 1;
144	144		var
145	145		Config: TConfigStorage;
146	146		SomeValue: String;
147	147		SomeInteger: Integer;
148	148		SomeBoolean: Boolean;
149	149		FileVersion: LongInt;
150	150		begin
151	151		SomeValue:='Default';
152	152		SomeInteger:=3;
153	153		SomeBoolean:=true;
154	154
155	155		// Salva configuraciones.
156	156		try
157	157		Config:=GetIDEConfigStorage('mysettings.xml',false);
158	158		try
159	159		// Almacena el número de versión de forma que las extensiones futuras puedan manejar ficheros de configuración antiguos.
160	160		Config.SetDeleteValue('Path/To/The/Version',Version,0);
161	161		// Almacena la variable de cadena "SomeValue".
162	162		// Si SomeValue tiene el valor por defecto entonces la entrada no se almacena,
163	163		// de forma que únicamente se almacena las diferencias al valor por defecto.
164	164		// Así el xml se mantiene pequeño y su valor por defecto puede cambiar en el futuro.
165	165		Config.SetDeleteValue('Path/To/Some/Value',SomeValue,'Default');
166	166		Config.SetDeleteValue('Path/To/Some/Integer',SomeInteger,3);
167	167		Config.SetDeleteValue('Path/To/Some/Boolean',SomeBoolean,true);
168	168		// there are more overloads for SetDeleteValue, find out with Ctrl+Space
169	169		finally
170	170		Config.Free;
171	171		end;
172	172
173	173		except
174	174		on E: Exception do begin
175	175		DebugLn(['Saving mysettings.xml failed: ',E.Message]);
176	176		end;
177	177		end;
178	178
179	179		// load settings
180	180		try
181	181		Config:=GetIDEConfigStorage('mysettings.xml',true);
182	182		try
183	183		// read the version of the config
184	184		FileVersion:=Config.GetValue('Path/To/The/Version',0);
185	185		// read a string variable "SomeValue". If the entry does not exist, use
186	186		// the Default
187	187		SomeValue:=Config.GetValue('Path/To/Some/Value','Default');
188	188		SomeInteger:=Config.GetValue('Path/To/Some/Integer',3);
189	189		SomeBoolean:=Config.GetValue('Path/To/Some/Boolean',true);
190	190		finally
191	191		Config.Free;
192	192		end;
193	193		except
194	194		on E: Exception do begin
195	195		DebugLn(['Loading mysettings.xml failed: ',E.Message]);
196	196		end;
197	197		end;
198	198		end;
199	199		```
200	200
201	201		Notes:
202	202
203	203		- Every IDE plugin should use its own config file. Especially you must not use the standard IDE option files like [[editoroptions.xml]] or [[environmentoptions.xml]].
204	204		- GetIDEConfigStorage when loading checks if the file exists and if not it will copy the template from the secondary config directory.
205	205		- Since 0.9.31 you can use this function to load a file outside the primary config directory.
206	206
207	207		# Components
208	208
209	209		## Extending existing components
210	210
211	211		Source: [1](http://lazarus.freepascal.org/index.php/topic,17733.msg98425.html#msg98425) It is straightforward to customise existing LCL components, e.g. if you want to add properties.
212	212
213	213		Add the properties you need with appropriate setter and getter methods and storage fields.
214	214
215	215		Then instantiate them 'by hand', giving an owner component (to handle later destruction), and set Parent and possibly Top and Left and any other defaults your component needs when initialized.
216	216
217	217		When you are satisfied that your customised component is debugged, add a RegisterComponent() call to stick it on the IDE Component Palette and save you having to do the setup code 'by hand' (look at any component's source to see how to do this).
218	218
219	219		Here is a simple example:
220	220
221	221		``` pascal
222	222		unit Unit1;
223	223
224	224		{$mode objfpc}{$H+}
225	225
226	226		interface
227	227
228	228		uses
229	229		Classes, SysUtils, Forms, StdCtrls;
230	230
231	231		type
232	232		TEdX = class(TEdit)
233	233		private
234	234		FNewIntProp: integer;
235	235		FNewStrProp: string;
236	236		procedure SetNewIntProp(AValue: integer);
237	237		procedure SetNewStrProp(AValue: string);
238	238		public
239	239		constructor Create(theComponent: TComponent); override;
240	240		property NewIntProp: integer read FNewIntProp write SetNewIntProp;
241	241		property NewStrProp: string read FNewStrProp write SetNewStrProp;
242	242		end;
243	243
244	244		TForm1 = class(TForm)
245	245		procedure FormCreate(Sender: TObject);
246	246		private
247	247		edX: TEdX;
248	248		public
249	249		end;
250	250
251	251		var
252	252		Form1: TForm1;
253	253
254	254		implementation
255	255
256	256		{ TForm1 }
257	257
258	258		procedure TForm1.FormCreate(Sender: TObject);
259	259		begin
260	260		edX:= TEdX.Create(Self);
261	261		edX.Parent:= Self;
262	262		edX.Caption:= IntToStr(edX.NewIntProp);
263	263		Caption:= edX.NewStrProp;
264	264		end;
265	265
266	266		{$R *.lfm}
267	267
268	268		{ TEdX }
269	269
270	270		procedure TEdX.SetNewIntProp(AValue: integer);
271	271		begin
272	272		if FNewIntProp=AValue then Exit;
273	273		FNewIntProp:=AValue;
274	274		// add custom code here
275	275		end;
276	276
277	277		procedure TEdX.SetNewStrProp(AValue: string);
278	278		begin
279	279		if FNewStrProp=AValue then Exit;
280	280		FNewStrProp:=AValue;
281	281		// add custom code here
282	282		end;
283	283
284	284		constructor TEdX.Create(theComponent: TComponent);
285	285		begin
286	286		inherited Create(theComponent);
287	287		FNewStrProp:= 'new string property value';
288	288		FNewIntProp:= 99;
289	289		end;
290	290
291	291		end.
292	292		```
293	293
294	294		## Writing components
295	295
296	296		Main article: [[How To Write Lazarus Component]]
297	297
298	298		You can create new components via the package editor.
299	299
300	300		Create or open a package, click on add, click on New Component, fill in the items: Ancestor Type = TButton, New class name = TMyButton, palette page = Misc, Unit file name = mybutton.pas (this file will be created), unit name MyButton and click ok.
301	301
302	302		### Giving a new component an icon for the component palette
303	303
304	304		Create an image file of the format .bmp, .xpm or .png with the same name as the component class. For example tmybutton.png and save it in the package source directory. The image can be created by any graphic program (e.g. gimp) and should be no bigger than 24x24 pixel. Then convert the image to a resource file with the lazres tool, which can be found in the lazarus/tools directory:
305	305
306	306		``` bash
307	307		~/lazarus/tools/lazres mybutton.lrs tmybutton.png
308	308		# note: Laz trunk/1.4+? uses .res resource files instead of .lrs files:
309	309		~/lazarus/tools/lazres mybutton.res tmybutton.png
310	310		```
311	311
312	312		This creates an pascal include file, which is used in the initialization section of mybutton.pas:
313	313
314	314		``` pascal
315	315		initialization
316	316		{$I mybutton.lrs}
317	317		// or in newer Lazarus version - to docheck syntax
318	318		{$R mybutton.res}
319	319		```
320	320
321	321		Install the package.
322	322
323	323		### Hiding a component in the component palette
324	324
325	325		Package IDEIntf, unit componentreg:
326	326
327		-	~~`IDEComponentPalette.FindComponent('TButton').Visible:=false;`~~
	327	+	``` pascal
	328	+	IDEComponentPalette.FindComponent('TButton').Visible:=false;
	329	+	```
328	330
329	331		## Writing component editors
330	332
331	333		A component editor handles things like double clicking on a component in a designer or adding menu items when right clicking on a component. Writing a component editor is easy. See the unit componenteditors.pas of the package IDEIntf for lots of examples. For instance to show an editor when double clicking see TCheckListBoxComponentEditor.
332	334
333	335		## Writing property editors
334	336
335	337		Each type of property (integer, string, TFont, ...) in the Object Inspector needs a property editor. If your component has a property Password of type string, then you can define a property editor for your specific component class, with a property named Password of type string. The unit propedits.pp of the package IDEIntf contains many of the standard property editors used by the IDE itself. For example the TStringPropertyEditor is the default property editor for all strings, while TComponentNamePropertyEditor is more specific and handles only TComponent.Name. See the unit for plenty of examples.
336	338
337	339		### Hiding a property in the Object Inspector
338	340
339	341		There is a special property editor for hiding:
340	342
341	343		` RegisterPropertyEditor(TypeInfo(TAnchorSide), TControl, 'AnchorSideLeft', THiddenPropertyEditor);`
342	344
343	345		# Forms
344	346
345	347		The IDE allows to easily create descendants of forms and frames. These forms can have new published components and new published methods. But you when you add new published properties, they are not accessible via the Object Inspector. They work only at runtime. The methods in the IDE are fake, they can not be executed. The IDE can create the components, because their classes are registered in the component palette. Your new properties only exist in your source code. The IDE can not fake them yet. That's why you have to register the new class. That means:
346	348
347	349		- create a design time package (or extend an existing one)
348	350		- your form must be in a unit of this package
349	351
350	352		``` pascal
351	353		...
352	354		interface
353	355
354	356		uses FormEditingIntf, Forms;
355	357
356	358		type
357	359		TYourForm = class(TForm)
358	360		private
359	361		FYourProperty: integer;
360	362		published
361	363		property YourProperty: integer read FYourProperty write FYourProperty;
362	364		end;
363	365
364	366		procedure Register;
365	367
366	368		implementation
367	369
368	370		procedure Register;
369	371		begin
370	372		FormEditingHook.RegisterDesignerBaseClass(TYourForm);
371	373		end;
372	374		...
373	375		```
374	376
375	377		- check the "Register" in the package editor for this unit.
376	378		- Install the package in the IDE
377	379
378	380		# Designer
379	381
380	382		## Writing a designer mediator
381	383
382	384		The standard designer allows to visually edit LCL controls, while all others are shown as icons(like TOpenDialog or TDataSource). To visually edit non LCL control, you need to create a designer mediator. This can be used to design webpages, UML diagrams or other widgetsets like [[fpGUI]]. There is a complete example in examples/designnonlcl/.
383	385
384	386		- Install the example package examples/designnonlcl/notlcldesigner.lpk and restart the IDE. This will register the designer mediator for TMyWidget components and add the new components TMyButton, TMyGroupBox to the component palette.
385	387		- Open the the example project examples/designnonlcl/project/NonLCL1.lpi.
386	388		- Open the unit1.pas and show the designer form (F12). You should see the components as red rectangles, which can be selected, moved and resized like LCL controls.
387	389
388	390		## Create a new unique component name
389	391
390	392		``` pascal
391	393		uses FormEditingIntf;
392	394
393	395		...
394	396
395	397		NewName:=FormEditingHook.CreateUniqueComponentName(AComponent);
396	398
397	399		// Or if you need to create the name before creating the component:
398	400
399	401		NewName:=FormEditingHook.CreateUniqueComponentName(ComponentClassName,OwnerComponent);
400	402		// ComponentClassName will be used as prefix, without a leading T.
401	403		// OwnerComponent is the new owner of the new component.
402	404		```
403	405
404	406		## Select a component in the designer/object inspector
405	407
406	408		``` pascal
407	409		uses propedits;
408	410		..
409	411		GlobalDesignHook.SelectOnlyThis(AComponent);
410	412		```
411	413
412	414		## Get unit, designer, form of a file
413	415
414	416		``` pascal
415	417		uses ProjectIntf, LazIDEIntf, ComponentEditors;
416	418		...
417	419		// open file
418	420		if LazarusIDE.DoOpenEditorFile(Filename,-1,-1,[ofAddToRecent])<>mrOk then exit;
419	421		// get file interface
420	422		aFile:=LazarusIDE.ActiveProject.FindFile(Filename,[]);
421	423		// get designer
422	424		aDesigner:=TComponentEditorDesigner(LazarusIDE.GetDesignerWithProjectFile(AFile,true));
423	425		if aDesigner=nil then
424	426		exit; // this unit has no resource (form, frame, datamodule, etc.)
425	427		// get form
426	428		aForm:=aDesigner.Form;
427	429		```
428	430
429	431		## Save unit, designer form
430	432
431	433		``` pascal
432	434		uses LazIDEIntf;
433	435		...
434	436		if LazarusIDE.DoSaveEditorFile(Filename,[])<>mrOk then exit;
435	437		```
436	438
437	439		# Event handlers
438	440
439	441		There are several events in the IDE, for which plugins can add their own handlers.
440	442
441	443		## Designer events
442	444
443	445		In propedits.pp there is a "GlobalDesignHook" object, which maintains several events for designing. Each event calls a list of handlers. The default handlers are added by the IDE. You can add your own handlers with the AddHandlerXXX and RemoveHandlerXXX methods. They will be called before the default handlers.
444	446
445	447		Examples:
446	448
447	449		- Adding your handler (this is normally done in the constructor of your object):
448	450
449		-	~~` GlobalDesignHook.AddHandlerPersistentAdded(@YourOnPersistentAdded);`~~
	451	+	```text
	452	+	GlobalDesignHook.AddHandlerPersistentAdded(@YourOnPersistentAdded);
	453	+	```
450	454
451	455		- Removing your handler:
452	456
453		-	~~` GlobalDesignHook.RemoveHandlerPersistentAdded(@YourOnPersistentAdded);`~~
	457	+	```text
	458	+	GlobalDesignHook.RemoveHandlerPersistentAdded(@YourOnPersistentAdded);
	459	+	```
454	460
455	461		- You can remove all handlers at once. For example, it is a good idea to add this line in the destructor of your object:
456	462
457		-	~~` GlobalDesignHook.RemoveAllHandlersForObject(Self);`~~
	463	+	```text
	464	+	GlobalDesignHook.RemoveAllHandlersForObject(Self);
	465	+	```
458	466
459	467		The handlers of GlobalDesignHook:
460	468
461	469		- Lookup root
462	470		- ChangeLookupRoot - Called when the "LookupRoot" changed. The "LookupRoot" is the owner object of the currently selected components. Normally this is a TForm.
463	471		- Methods
464	472		- CreateMethod
465	473		- GetMethodName
466	474		- GetMethods
467	475		- MethodExists
468	476		- RenameMethod
469	477		- ShowMethod
470	478		- MethodFromAncestor
471	479		- ChainCall
472	480		- Components
473	481		- GetComponent
474	482		- GetComponentName
475	483		- GetComponentNames
476	484		- GetRootClassName
477	485		- AddClicked - Called when the user selected a component class and clicked on the designer to add a new component. You can change the component class and the parent.
478	486		- ComponentRenamed - Called when a component was renamed
479	487		- TPersistent objects
480	488		- PersistentAdded - Called when a new TPersistent was added to the LookupRoot
481	489		- PersistentDeleting - Called before a TPersistent is freed.
482	490		- DeletePersistent - Called by the IDE to delete a TPersistent.
483	491		- GetSelectedPersistents - Called when getting the current selection of TPersistent.
484	492		- SetSelectedPersistents - Called when setting the current selection of TPersistent.
485	493		- GetObject
486	494		- GetObjectName
487	495		- GetObjectNames
488	496		- Modifing
489	497		- Modified
490	498		- Revert
491	499		- RefreshPropertyValues
492	500		- Selection
493	501		- SetSelection
494	502		- GetSelection
495	503
496	504		### Examples for designer events
497	505
498	506		#### Example: When dropping a new component move control to a child
499	507
500	508		``` pascal
501	509		...
502	510		type
503	511		TYourDesignerExtension = class
504	512		private
505	513		function AddClicked(ADesigner: TIDesigner;
506	514		MouseDownComponent: TComponent; Button: TMouseButton;
507	515		Shift: TShiftState; X, Y: Integer;
508	516		var AComponentClass: TComponentClass;
509	517		var NewParent: TComponent): boolean of object;
510	518		public
511	519		constructor Create;
512	520		destructor Destroy; override;
513	521		end;
514	522
515	523		...
516	524		constructor TYourDesignerExtension.Create;
517	525		begin
518	526		// register your handler
519	527		GlobalDesignHook.AddHandlerAddClicked(@AddClicked);
520	528		end;
521	529
522	530		destructor TYourDesignerExtension.Destroy;
523	531		begin
524	532		// remove your handler:
525	533		GlobalDesignHook.RemoveHandlerAddClicked(@AddClicked);
526	534		end;
527	535
528	536		function TYourDesignerExtension.AddClicked(ADesigner: TIDesigner;
529	537		MouseDownComponent: TComponent; Button: TMouseButton;
530	538		Shift: TShiftState; X, Y: Integer;
531	539		var AComponentClass: TComponentClass;
532	540		var NewParent: TComponent): boolean of object;
533	541		begin
534	542		// in this example TYourControl is a custom control with a ChildControl.
535	543		// Whenever the user drops a control on the TYourControl instead of adding
536	544		// the new control to the TYourControl, the new control is added as child
537	545		// of ChildControl.
538	546		// created
539	547		if MouseDownComponent is TYourControl then
540	548		NewParent:=TYourControl(MouseDownComponent).ChildControl;
541	549		Result:=true;
542	550		end;
543	551		```
544	552
545	553		### Disabling the designer mouse handler
546	554
547	555		Normally the designer catches all mouse events of a component. If your custom control should handle the mouse events handle you can either set the csDesignInteractive ControlStyle or you can fine control it via the message CM_DESIGNHITTEST in your control:
548	556
549	557		``` pascal
550	558		type
551	559		TYourControl = class(TCustomControl)
552	560		protected
553	561		procedure CMDesignHitTest(var Message: TLMessage); message CM_DESIGNHITTEST;
554	562		end;
555	563		...
556	564		procedure TYourControl.CMDesignHitTest(var Message: TLMessage);
557	565		var
558	566		p: TSmallPoint;
559	567		aShiftState: TShiftState;
560	568		begin
561	569		aShiftState:=KeysToShiftState(PtrUInt(Message.WParam));
562	570		p:=TSmallPoint(longint(Message.LParam));
563	571		debugln(['TForm1.CMDesignHitTest ShiftState=',dbgs(aShiftState),' x=',p.x,' y=',p.y]);
564	572		if SkipDesignerMouseHandler then
565	573		Message.Result:=1; // now the designer calls the normal MouseUp, MouseMove and MouseDown methods.
566	574		end;
567	575		```
568	576
569	577		## Getting notified when a designer form is modified
570	578
571	579		Every designed LCL form has a Designer of type TIDesigner. The IDE creates designers of type TComponentEditorDesigner defined in the IDEIntf unit componenteditors. For example:
572	580
573	581		``` pascal
574	582		procedure TYourAddOn.OnDesignerModified(Sender: TObject);
575	583		var
576	584		IDEDesigner: TComponentEditorDesigner;
577	585		begin
578	586		IDEDesigner:=TComponentEditorDesigner(Sender);
579	587		...
580	588		end;
581	589
582	590		procedure TYourAddOn.ConnectDesignerForm(Form1: TCustomForm);
583	591		var
584	592		IDEDesigner: TComponentEditorDesigner;
585	593		begin
586	594		IDEDesigner:=TComponentEditorDesigner(Form1.Designer);
587	595		IDEDesigner.AddHandlerModified(@OnDesignerModified);
588	596		end;
589	597		```
590	598
591	599		## Project events
592	600
593	601		These events are defined in unit LazIDEIntf.
594	602
595	603		- LazarusIDE.AddHandlerOnProjectClose: called before a project is closed
596	604		- LazarusIDE.AddHandlerOnProjectOpened: called after the project was completely opened (for example all required packages were loaded, units were opened in the source editor)
597	605		- LazarusIDE.AddHandlerOnSavingAll: called before IDE saves everything
598	606		- LazarusIDE.AddHandlerOnSavedAll: called after IDE saved everything
599	607		- LazarusIDE.AddHandlerOnProjectBuilding: called before IDE builds the project
600	608		- LazarusIDE.AddHandlerOnProjectDependenciesCompiling: called before IDE compiles package dependencies of project
601	609		- LazarusIDE.AddHandlerOnProjectDependenciesCompiled: called after IDE compiled package dependencies of project
602	610		- LazarusIDE.AddHandlerOnProjectBuildingFinished: called after IDE built the project (successful or not) (since 1.5)
603	611
604	612		## Other IDE events
605	613
606	614		uses LazIDEIntf;
607	615
608	616		Call these in the Register procedure of your package:
609	617
610	618		- LazarusIDE.AddHandlerOnIDERestoreWindows: called when IDE is restores its windows (before opening the first project)
611	619		- LazarusIDE.AddHandlerOnIDEClose: called when IDE is shutting down (after closequery, so no more interactivity)
612	620		- LazarusIDE.AddHandlerOnQuickSyntaxCheck: called when the menu item or the shortcut for Quick syntax check is executed
613	621		- LazarusIDE.AddHandlerOnLazarusBuilding: // called before IDE builds Lazarus IDE (since 1.5)
614	622		- LazarusIDE.AddHandlerOnLazarusBuildingFinished: // called after IDE builds Lazarus IDE (since 1.5)
615	623		- LazarusIDE.AddHandlerGetFPCFrontEndParams: // called when the IDE gets the parameters of the 'fpc' front end tool (since 1.5)
616	624		- LazarusIDE.AddHandlerGetFPCFrontEndPath: // called when the IDE gets the path of the 'fpc' front end tool (since 1.5)
617	625		- LazarusIDE.AddHandlerOnUpdateIDEComponentPalette: ?
618	626		- LazarusIDE.AddHandlerOnUpdateComponentPageControl: ?
619	627		- LazarusIDE.AddHandlerOnShowDesignerFormOfSource: // called after showing a designer form for code editor (AEditor can be nil!) (since 1.5)
620	628		- LazarusIDE.AddHandlerOnShowSourceOfActiveDesignerForm: // called after showing a code of designer form (since 1.5)
621	629		- LazarusIDE.AddHandlerOnChangeToolStatus: //called when IDEToolStatus has changed (e.g. itNone-\>itBuilder etc.) (since 1.5)
622	630
623	631		Call these in the initialization section of one of your units:
624	632
625	633		- AddBootHandler
626	634		- AddBootHandler(libhTransferMacrosCreated,@YourProc): called after IDEMacros were created (since 1.3)
627	635		- AddBootHandler(libhEnvironmentOptionsLoaded,@YourProc): called after environment options were loaded (since 1.3)
628	636
629	637		# Project
630	638
631	639		## Current Project
632	640
633	641		The current main project can be obtained by LazarusIDE.ActiveProject. (unit LazIDEIntf)
634	642
635	643		## All units of current project
636	644
637	645		Note that the term "units of project" is ambiguous.
638	646
639	647		- The project inspector shows the list of the .lpi file. The project might not use all these units on all platforms and maybe the developer forgot to add all used units.
640	648		- Units from used packages are not project units.
641	649
642	650		### All units of the project inspector
643	651
644	652		To iterate through all pascal units listed in the project inspector you can use for example:
645	653
646	654		``` pascal
647	655		uses
648	656		LCLProc, FileUtil, LazIDEIntf, ProjectIntf;
649	657
650	658		procedure ListProjectUnits;
651	659		var
652	660		LazProject: TLazProject;
653	661		i: Integer;
654	662		LazFile: TLazProjectFile;
655	663		begin
656	664		LazProject:=LazarusIDE.ActiveProject;
657	665		if LazProject<>nil then
658	666		for i:=0 to LazProject.FileCount-1 do
659	667		begin
660	668		LazFile:=LazProject.Files[i];
661	669		if LazFile.IsPartOfProject
662	670		and FilenameIsPascalUnit(LazFile.Filename)
663	671		then
664	672		debugln(LazFile.Filename);
665	673		end;
666	674		end;
667	675		```
668	676
669	677		### All used units of project
670	678
671	679		To find all currently used units of a project/package you can use the following. Note that the IDE needs to parse all units, so it can take some time.
672	680
673	681		``` pascal
674	682		uses
675	683		LazLoggerBase, LazIDEIntf, ProjectIntf;
676	684
677	685		procedure ListProjectUnits;
678	686		var
679	687		LazProject: TLazProject;
680	688		i: Integer;
681	689		begin
682	690		LazProject:=LazarusIDE.ActiveProject;
683	691		if LazProject<>nil then
684	692		begin
685	693		Units:=LazarusIDE.FindUnitsOfOwner(LazProject,[fuooListed,fuooUsed]); // add fuooPackages to include units from packages
686	694		try
687	695		for i:=0 to Units.Count-1 do
688	696		debugln('Filename=',Units[i]);
689	697		finally
690	698		Units.Free;
691	699		end;
692	700		end;
693	701		end;
694	702		```
695	703
696	704		## The .lpr, .lpi and .lps file of a project
697	705
698	706		``` pascal
699	707		uses
700	708		LCLProc, FileUtil, ProjectIntf, LazIDEIntf;
701	709		var
702	710		LazProject: TLazProject;
703	711		begin
704	712		LazProject:=LazarusIDE.ActiveProject;
705	713		// every project has a .lpi file:
706	714		DebugLn(['Project'' lpi file: ',LazProject.ProjectInfoFile]);
707	715
708	716		// if the project session information is stored in a separate .lps file:
709	717		if LazProject.SessionStorage<>pssNone then
710	718		DebugLn(['Project'' lps file: ',LazProject.ProjectSessionFile]);
711	719
712	720		// If the project has a .lpr file it is the main source file:
713	721		if (LazProject.MainFile<>nil)
714	722		and (CompareFileExt(LazProject.MainFile.Filename,'lpr')=0) then
715	723		DebugLn(['Project has lpr file: ',LazProject.MainFile.Filename]);
716	724		end;
717	725		```
718	726
719	727		## The executable / target file name of a project
720	728
721	729		There is a macro \$(TargetFile), which can be used in paths and external tools. You can query the macro in code:
722	730
723	731		``` pascal
724	732		uses MacroIntf;
725	733
726	734		function MyGetProjectTargetFile: string;
727	735		begin
728	736		Result:='$(TargetFile)';
729	737		if not IDEMacros.SubstituteMacros(Result) then
730	738		raise Exception.Create('unable to retrieve target file of project');
731	739		end;
732	740		```
733	741
734	742		See here for more macros: [[IDE Macros in paths and filenames]].
735	743
736	744		## Add your own project type
737	745
738	746		You can add items to the 'New ...' dialog:
739	747
740	748		- See the unit ProjectIntf of the package IDEIntf.
741	749		- See the [[Project Templates]]
742	750
743	751		## Add your own file type
744	752
745	753		You can add items to the 'New ...' dialog:
746	754
747	755		- See the unit ProjectIntf of the package IDEIntf.
748	756		- Choose a base class TFileDescPascalUnit for normal units or TFileDescPascalUnitWithResource for a new form/datamodule.
749	757
750	758		### Add a new file type
751	759
752	760		``` pascal
753	761		uses ProjectIntf;
754	762		...
755	763		{ TFileDescText }
756	764
757	765		TFileDescMyText = class(TProjectFileDescriptor)
758	766		public
759	767		constructor Create; override;
760	768		function GetLocalizedName: string; override;
761	769		function GetLocalizedDescription: string; override;
762	770		end;
763	771		...
764	772
765	773		procedure Register;
766	774
767	775		implementation
768	776
769	777		procedure Register;
770	778		begin
771	779		RegisterProjectFileDescriptor(TFileDescMyText.Create,FileDescGroupName);
772	780		end;
773	781
774	782		{ TFileDescMyText }
775	783
776	784		constructor TFileDescMyText.Create;
777	785		begin
778	786		inherited Create;
779	787		Name:='MyText'; // do not translate this
780	788		DefaultFilename:='text.txt';
781	789		AddToProject:=false;
782	790		end;
783	791
784	792		function TFileDescText.GetLocalizedName: string;
785	793		begin
786	794		Result:='My Text'; // replace this with a resourcestring
787	795		end;
788	796
789	797		function TFileDescText.GetLocalizedDescription: string;
790	798		begin
791	799		Result:='An empty text file';
792	800		end;
793	801		```
794	802
795	803		### Add a new form type
796	804
797	805		``` pascal
798	806		uses ProjectIntf;
799	807
800	808		...
801	809		TFileDescPascalUnitWithMyForm = class(TFileDescPascalUnitWithResource)
802	810		public
803	811		constructor Create; override;
804	812		function GetInterfaceUsesSection: string; override;
805	813		function GetLocalizedName: string; override;
806	814		function GetLocalizedDescription: string; override;
807	815		end;
808	816		...
809	817
810	818		procedure Register;
811	819
812	820		implementation
813	821
814	822		procedure Register;
815	823		begin
816	824		RegisterProjectFileDescriptor(TFileDescPascalUnitWithMyForm.Create,FileDescGroupName);
817	825		end;
818	826
819	827		{ TFileDescPascalUnitWithMyForm }
820	828
821	829		constructor TFileDescPascalUnitWithMyForm.Create;
822	830		begin
823	831		inherited Create;
824	832		Name:='MyForm'; // do not translate this
825	833		ResourceClass:=TMyForm;
826	834		UseCreateFormStatements:=true;
827	835		end;
828	836
829	837		function TFileDescPascalUnitWithMyForm.GetInterfaceUsesSection: string;
830	838		begin
831	839		Result:='Classes, SysUtils, MyWidgetSet';
832	840		end;
833	841
834	842		function TFileDescPascalUnitWithForm.GetLocalizedName: string;
835	843		begin
836	844		Result:='MyForm'; // replace this with a resourcestring
837	845		end;
838	846
839	847		function TFileDescPascalUnitWithForm.GetLocalizedDescription: string;
840	848		begin
841	849		Result:='Create a new MyForm from example package NotLCLDesigner';
842	850		end;
843	851		```
844	852
845	853		# Packages
846	854
847	855		You can perform various actions with [[Lazarus Packages\|Packages]]:
848	856
849	857		## Search in all packages
850	858
851	859		Iterate all packages loaded in the IDE (since 0.9.29).
852	860
853	861		``` pascal
854	862		uses PackageIntf;
855	863		...
856	864		for i:=0 to PackageEditingInterface.GetPackageCount-1 do
857	865		writeln(PackageEditingInterface.GetPackages(i).Name);
858	866		```
859	867
860	868		## Search a package with a name
861	869
862	870		``` pascal
863	871		uses PackageIntf;
864	872		...
865	873		var
866	874		Pkg: TIDEPackage;
867	875		begin
868	876		Pkg:=PackageEditingInterface.FindPackageWithName('LCL');
869	877		if Pkg<>nil then
870	878		...
871	879		end;
872	880		```
873	881
874	882		Note: FindPackageWithName does not open the package editor. For that use DoOpenPackageWithName.
875	883
876	884		## Obtener el nombre de fichero .lpk de un paquete instalado
877	885
878	886		``` pascal
879	887		uses PackageIntf;
880	888		...
881	889		var
882	890		Pkg: TIDEPackage;
883	891		begin
884	892		Pkg:=PackageEditingInterface.FindPackageWithName('LCL');
885	893		if Pkg<>nil then
886	894		LPKFilename:=Pkg.Filename;
887	895		end;
888	896		```
889	897
890	898		## Instalar paquetes
891	899
892	900		Note: Instalar únicamente paquetes con plugins IDE. Instalar otros paquetes puede hacer el IDE inestable.
893	901
894	902		``` pascal
895	903		uses PackageIntf, contnrs;
896	904		...
897	905		PkgList:=TObjectList.create(true);
898	906		try
899	907		Pkg:=TLazPackageID.Create;
900	908		Pkg.Name:='Cody';
901	909		PkgList.Add(Pkg);
902	910		// Chequear si el IDE puede encontrar cody.lpk y todas las dependencias.
903	911		// El IDE will muestra algunas advertencias/confirmaciones si algo parece extraño.
904	912		if not PackageEditingInterface.CheckInstallPackageList(PkgList,[]) then
905	913		exit;
906	914		// in this example we have checked already, so skip the warnings
907	915		// and rebuild the IDE
908	916		if PackageEditingInterface.InstallPackages(PkgList,[piiifSkipChecks,piiifRebuildIDE])<>mrOK then
909	917		exit;
910	918		finally
911	919		PkgList.Free;
912	920		end;
913	921		```
914	922
915	923		## Abrir un fichero de paquete (lpk)
916	924
917	925		``` pascal
918	926		uses PackageIntf, FileUtil;
919	927		...
920	928		var
921	929		pkg: TIDEPackage;
922	930		begin
923	931		if PackageEditingInterface.DoOpenPackageFile(LPKFilename,[pofAddToRecent],false)<>mrOk then
924	932		exit;
925	933		Pkg:=PackageEditingInterface.FindPackageWithName(ExtractFilenameOnly(LPKFilename));
926	934		...
927	935		end;
928	936		```
929	937
930	938		> Warning: El IDE cierra automáticamentes paquetes no utilizados on idle. Nunca mantener referencias a un TIDEPackage.
931	939
932	940		## Find the package(s) of a unit
933	941
934	942		You have the file name of a unit, e.g. '/home/user/unit.pas', and you want to know to which package(s) and project(s) it belongs use this:
935	943
936	944		``` pascal
937	945		uses Classes, PackageIntf, ProjectIntf;
938	946		...
939	947		var
940	948		Owners: TFPList;
941	949		i: Integer;
942	950		o: TObject;
943	951		begin
944	952		Owners:=PackageEditingInterface.GetPossibleOwnersOfUnit('/full/path/of/unit.pas',[]);
945	953		if Owners=nil then begin
946	954		// unit is not directly associated with a project/package
947	955		// maybe the unit was for some reason not added, but is reachable
948	956		// search in all unit paths of all projects/packages
949	957		// Beware: This can lead to false hits
950	958		Owners:=PackageEditingInterface.GetPossibleOwnersOfUnit('/full/path/of/unit.pas',
951	959		[piosfExcludeOwned,piosfIncludeSourceDirectories]);
952	960		end;
953	961		if Owners=nil then exit;
954	962		try
955	963		for i:=0 to Owners.Count-1 do begin
956	964		o:=TObject(Owners[i]);
957	965		if o is TIDEPackage then begin
958	966		writeln('Owner is package ',TIDEPackage(o).Name);
959	967		end else if o is TLazProject then begin
960	968		writeln('Owner is project ',TLazProject(o).ProjectInfoFile);
961	969		end;
962	970		end;
963	971		finally
964	972		Owners.Free;
965	973		end;
966	974		```
967	975
968	976		# Ventanas
969	977
970	978		Hay básicamente cuatro tipos de ventandas del IDE:
971	979
972	980		- La barra principal del IDE bar que es Application.MainForm. Siempre está presente.
973	981		- Ventanas flotantes/acoplables tales como el editor del código fuente, the Object Inspectors and Messages.
974	982		- Fomas modales, tales como los diálogos de búsqueda, opciones y preguntas.
975	983		- Sugerencias y formas de completado.
976	984
977	985		## Añadiendo una nueva ventana de acoplado en el IDE
978	986
979	987		Que es una ventana del IDE acoplable: Ventanas tales como el Editor de Código Fuente o el Inspector de Objetos son ventanas flotantes que se pueden acoplar si se instala un paquete de acoplamiento, y su estado, posición y tamaño se almacena y restaura en el siguiente inicio del IDE. En orden a restaurar una ventana el IDE necesita un creador como se definie en la unidad IDEWindowIntf del paquete IDEIntf. Cada ventana acoplable debe tener un único nombre. No usar por tanto nombres genéricos como 'FileBrowser' porque haría que entre fácilmente en conflicto con otros paquetes. Y no usar nombres cortos como 'XYZ' porque el creador es responsable de todas las formas que comiencen con dicho nombre.
980	988
981	989		### Como registrar una ventana acoplable del IDE
982	990
983	991		Recuerda utilizar un nombre largo única que sea un identificador pascal válido. Tus ventanas pueden tener cualquier caption que necesites.
984	992
985	993		``` pascal
986	994		uses SysUtils, IDEWindowIntf;
987	995		...
988	996		var MyIDEWindow: TMyIDEWindow = nil;
989	997
990	998		procedure CreateMyIDEWindow(Sender: TObject; aFormName: string; var AForm: TCustomForm; DoDisableAutoSizing: boolean);
991	999		begin
992	1000		// check the name
993	1001		if CompareText(aFormName,MyIDEWindowName)<>0 then exit;
994	1002		// create the form if not already done and disable autosizing
995	1003		IDEWindowCreators.CreateForm(MyIDEWindow,TMyIDEWindowm,DoDisableAutosizing,Application);
996	1004		... init the window ...
997	1005		AForm:=MyIDEWindow;
998	1006		end;
999	1007
1000	1008		procedure Register;
1001	1009		begin
1002	1010		IDEWindowCreators.Add('MyIDEWindow',@CreateMyIDEWindow,nil,'100','50%','+300','+20%');
1003	1011		// the default boundsrect of the form is:
1004	1012		// Left=100, Top=50% of Screen.Height, Width=300, Height=20% of Screen.Height
1005	1013		// when the IDE needs an instance of this window it calls the procedure CreateMyIDEWindow.
1006	1014		end;
1007	1015		```
1008	1016
1009	1017		### Showing an IDE window
1010	1018
1011	1019		Do not use Show. Use:
1012	1020
1013	1021		``` pascal
1014	1022		IDEWindowCreators.ShowForm(MyIDEWindow,false);
1015	1023		```
1016	1024
1017	1025		This will work with docking. The docking system might wrap the form into a docking site. The BringToFront parameter tells the docking system to make the form and all its parent sites visible and bring the top level site to the front.
1018	1026
1019	1027		### Notes about IDEWindowCreators and SimpleLayoutStorage
1020	1028
1021	1029		The IDEWindowCreators.SimpleLayoutStorage simply stores the BoundsRect and WindowState of all forms that were once opened. It is used as fallback if no dockmaster is installed. It stores the state even if a DockMaster is installed, so that when the dockmaster is uninstalled the forms bounds are restored.
1022	1030
1023	1031		The IDEWindowCreators is used by all dockable forms to register themselves and to show forms. When showing a form the Creator checks if a IDEDockMaster is installed and will delegate the showing to it. If no IDEDockMaster is installed it simply shows the form. The IDEDockMaster can use the information in the IDEWindowCreators to create forms by names and get an idea where to place a form when showing it for the first time. For more details see the packages AnchorDockingDsgn and EasyDockMgDsgn.
1024	1032
1025	1033		# CodeTools
1026	1034
1027	1035		The CodeTools is a package providing a vast amount of functions to parse, search and change pascal sources and some basic functions for other languages as well. You can use them without the IDE too. It is recommended that you read first about the CodeTools in general before using them in the IDE: [[Codetools]].
1028	1036
1029	1037		Before calling any of the CodeTools functions in the IDE you should commit the current changes of the source editor to the CodeTools buffers:
1030	1038
1031	1039		``` pascal
1032	1040		uses LazIDEIntf;
1033	1041		...
1034	1042		// save changes in source editor to codetools
1035	1043		LazarusIDE.SaveSourceEditorChangesToCodeCache(-1); // -1: commit all source editors
1036	1044		```
1037	1045
1038	1046		## Adding a resource directive to a file
1039	1047
1040	1048		This adds a {\$R example.res} to a pascal unit:
1041	1049
1042	1050		``` pascal
1043	1051		procedure AddResourceDirectiveToPascalSource(const Filename: string);
1044	1052		var
1045	1053		ExpandedFilename: String;
1046	1054		CodeBuf: TCodeBuffer;
1047	1055		begin
1048	1056		// make sure the filename is trimmed and contains a full path
1049	1057		ExpandedFilename:=CleanAndExpandFilename(Filename);
1050	1058
1051	1059		// save changes in source editor to codetools
1052	1060		LazarusIDE.SaveSourceEditorChangesToCodeCache(-1);
1053	1061
1054	1062		// load the file
1055	1063		CodeBuf:=CodeToolBoss.LoadFile(ExpandedFilename,true,false);
1056	1064
1057	1065		// add the resource directive
1058	1066		if not CodeToolBoss.AddResourceDirective(CodeBuf,'example.res') then
1059	1067		LazarusIDE.DoJumpToCodeToolBossError;
1060	1068		end;
1061	1069		```
1062	1070
1063	1071		The codetools provides also functions like FindResourceDirective and RemoveDirective.
1064	1072
1065	1073		## Getting the search paths for units and include files
1066	1074
1067	1075		There are many different search paths in the IDE from projects, packages, the fpc and lazarus directory and there are many types of paths: before or after resolving macros, with or without inherited search paths, as relative or absolute paths. All files in a directory share the same set of search paths. You can get the search paths for each directory fully resolved by asking the codetools:
1068	1076
1069	1077		``` pascal
1070	1078		uses CodeToolManager;
1071	1079		...
1072	1080
1073	1081		Dir:=''; // the empty directory is for new files and has the same settings as the project directory
1074	1082
1075	1083		// Getting the search paths for include files:
1076	1084		Path:=CodeToolBoss.GetIncludePathForDirectory(Dir);
1077	1085
1078	1086		// Getting the search paths for units:
1079	1087		// This search path is passed to the compiler.
1080	1088		// It contains the package output directories, but not the package source directories.
1081	1089		Path:=CodeToolBoss.GetUnitPathForDirectory(Dir);
1082	1090
1083	1091		// There can be additional unit search paths for the IDE only (not passed to the compiler)
1084	1092		Path:=CodeToolBoss.GetSrcPathForDirectory(Dir);
1085	1093
1086	1094		// The complete search path contains also all package source paths for units:
1087	1095		Path:=CodeToolBoss.GetCompleteSrcPathForDirectory(Dir);
1088	1096		```
1089	1097
1090	1098		# Source Editor
1091	1099
1092	1100		## Active source editor
1093	1101
1094	1102		``` pascal
1095	1103		uses SrcEditorIntf;
1096	1104		...
1097	1105		Editor:=SourceEditorManagerIntf.ActiveEditor;
1098	1106		if Editor=nil then exit;
1099	1107		Filename:=Editor.FileName;
1100	1108		ScreenPos:=Editor.CursorScreenXY;
1101	1109		TextPos:=Editor.CursorTextXY;
1102	1110		```
1103	1111
1104	1112		# SynEdit
1105	1113
1106	1114		## Getting the settings for a TSynEdit
1107	1115
1108	1116		When you have a dialog using a TSynEdit and you want to use the same font and settings like the source editor use:
1109	1117
1110	1118		``` pascal
1111	1119		uses SrcEditorIntf;
1112	1120		...
1113	1121		SourceEditorManagerIntf.GetEditorControlSettings(ASynEdit);
1114	1122		```
1115	1123
1116	1124		## Getting the settings for a SynEdit highlighter
1117	1125
1118	1126		When you have a dialog using a TSynEdit with a highlighter and you want to use the same colors like the source editor highlighter for this language use:
1119	1127
1120	1128		``` pascal
1121	1129		uses SrcEditorIntf;
1122	1130		...
1123	1131		SourceEditorManagerIntf.GetHighlighterSettings(ASynHighlighter);
1124	1132		```
1125	1133
1126	1134		See for an example: TSQLStringsPropertyEditorDlg.Create in the unit [SQLStringsPropertyEditorDlg](http://svn.freepascal.org/svn/lazarus/trunk/components/sqldb/sqlstringspropertyeditordlg.pas).
1127	1135
1128	1136		# Help
1129	1137
1130	1138		## Adding help for sources
1131	1139
1132	1140		First create a THelpDatabase:
1133	1141
1134	1142		``` pascal
1135	1143		HelpDB := TFPDocHTMLHelpDatabase(
1136	1144		HelpDatabases.CreateHelpDatabase('ANameOfYourChoiceForTheDatabase',
1137	1145		TFPDocHTMLHelpDatabase,true));
1138	1146		HelpDB.DefaultBaseURL := 'http://your.help.org/';
1139	1147
1140	1148		FPDocNode := THelpNode.CreateURL(HelpDB,
1141	1149		'Package1 - A new package',
1142	1150		'file://index.html');
1143	1151		HelpDB.TOCNode := THelpNode.Create(HelpDB,FPDocNode);// once as TOC
1144	1152		DirectoryItem := THelpDBISourceDirectory.Create(FPDocNode,'$(PkgDir)/lcl',
1145	1153		'.pp;.pas',false);// and once as normal page
1146	1154		HelpDB.RegisterItem(DirectoryItem);
1147	1155		```
1148	1156
1149	1157		## Adding lines to the messages window
1150	1158
1151	1159		``` pascal
1152	1160		unit IDEMsgIntf;
1153	1161		...
1154	1162		var Dir: String;
1155	1163		begin
1156	1164		Dir:=GetCurrentDir;
1157	1165		IDEMessagesWindow.BeginBlock;
1158	1166		IDEMessagesWindow.AddMsg('unit1.pas(30,4) Error: Identifier not found "a"',Dir,0);
1159	1167		IDEMessagesWindow.EndBlock;
1160	1168		end;
1161	1169		```
1162	1170
1163	1171		# Miscellaneous
1164	1172
1165	1173		## Adding a macro
1166	1174
1167	1175		You can add your own IDE macros:
1168	1176
1169	1177		``` pascal
1170	1178		uses MacroIntf, MacroDefIntf;
1171	1179
1172	1180		procedure Register;
1173	1181		begin
1174	1182		// registering a Macro with a fixed value:
1175	1183		IDEMacros.Add(TTransferMacro.Create('MyMacro1','Value','Description',nil,[]));
1176	1184		end;
1177	1185
1178	1186		// registering a Macro with a dynamic value requires a method of an object
1179	1187		procedure TForm1.Init;
1180	1188		begin
1181	1189		IDEMacros.Add(TTransferMacro.Create('MyMacro','Value','Description',@OnResolveMyMacro,[]));
1182	1190		end;
1183	1191
1184	1192		function TForm1.OnResolveMyMacro(const s: string; const Data: PtrInt;
1185	1193		var Abort: boolean): string;
1186	1194		// s is the parameter. For example $MyMacro(parameter)
1187	1195		// Data is the querying instance. Can be nil.
1188	1196		// If there is an error set Abort to true.
1189	1197		// The result string can contain macros. For example Result:='$(FPCVer)/$(TargetOS)';
1190	1198		begin
1191	1199		Result:='MyValue';
1192	1200		end;
1193	1201		```
1194	1202
1195	1203		## Depurando el IDE
1196	1204
1197	1205		- Compila el IDE como habitualmente e.g. via Tools/Build de Lazarus. Asegúrate de establecer los flags de depuración tales como -g o -gw2. Lo mejor es utilizar el profile "Debug IDE" que contiene algunos flags útiles para depuración.
1198	1206		- Abre el proyecto ide\lazarus.lpi. No se puede compilar directamente este proyecto.
1199	1207		- Establece los puntos de ruptura (breakpoints) acorde a tus necesidades etc y ejecuta el proyecto.
1200	1208
1201	1209		## See also
1202	1210
1203	1211		- [[Creating IDE Help]]
1204	1212		- [[Help protocol]]
1205	1213		- [[How To Write Lazarus Component]]
1206	1214
1207	1215		---
1208	1216		From the Free Pascal wiki, page "Extending the IDE/es", as it stood on 2020-02-14 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