How To Write Lazarus Component/ko: what changed

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

Old	New		Line
1	1		컴포넌츠 빌드방법에 대한 기본 안내서이다. 윈도우7 라자루스 0.9.30버전에서 테스트 되었다.
2	2
3	3		## 단계 1: 패키지 생성
4	4
5	5		- On the Lazarus IDE menu, click Package \> New Package to run the Package Manager.
6	6
7		-	~~<figure>~~
8		-	~~<img src="package_menu.png" title="package_menu.png" />~~
9		-	~~<figcaption>package_menu.png</figcaption>~~
10		-	~~</figure>~~
	7	+	![](/wiki-images/7/7c/Package_menu.png)
11	8
12	9		- A Save dialog file will appear. Chose a folder and a filename and press save. If the IDE prompts for using lowercase filenames press 'yes'.
13	10
14	11		- Congratulations: You have just created your first package!
15	12
16		-	~~<figure>~~
17		-	~~<img src="How_to_write_lazarus_component_package_maker.png" title="Package Maker" />~~
18		-	~~<figcaption>Package Maker</figcaption>~~
19		-	~~</figure>~~
	13	+	![](/wiki-images/3/37/How_to_write_lazarus_component_package_maker.png)
20	14
21	15		## 단계 2: 유닛 생성
22	16
23	17		You can create a new unit or use an existing file.
24	18
25	19		### 새로운 유닛 생성
26	20
27	21		- Use the Add button \> New component.
28	22
29		-	~~<figure>~~
30		-	~~<img src="package_new_component.png" title="package_new_component.png" />~~
31		-	~~<figcaption>package_new_component.png</figcaption>~~
32		-	~~</figure>~~
	23	+	![](/wiki-images/5/56/Package_new_component.png)
33	24
34	25		- Choose a component like TComboBox.
35	26		- Choose customcontrol1.pas as filename.
36	27		- Click OK.
37	28
38	29		``` pascal
39	30		unit CustomControl1;
40	31
41	32		{$mode objfpc}{$H+}
42	33
43	34		interface
44	35
45	36		uses
46	37		Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, StdCtrls;
47	38
48	39		type
49	40		TCustomControl1 = class(TComboBox)
50	41		private
51	42		{ Private declarations }
52	43		protected
53	44		{ Protected declarations }
54	45		public
55	46		{ Public declarations }
56	47		published
57	48		{ Published declarations }
58	49		end;
59	50
60	51		procedure Register;
61	52
62	53		implementation
63	54
64	55		procedure Register;
65	56		begin
66	57		RegisterComponents('Standard',[TCustomControl1]);
67	58		end;
68	59
69	60		end.
70	61		```
71	62
72	63		- Install the package by clicking the 'install' button at the top of the package editor.
73	64
74		-	~~<figure>~~
75		-	~~<img src="package_install.png" title="package_install.png" />~~
76		-	~~<figcaption>package_install.png</figcaption>~~
77		-	~~</figure>~~
	65	+	![](/wiki-images/3/36/Package_install.png)
78	66
79	67		- Then the IDE will ask you, if the IDE should be rebuilt. Say yes.
80	68
81		-	~~<figure>~~
82		-	~~<img src="package_rebuild.png" title="package_rebuild.png" />~~
83		-	~~<figcaption>package_rebuild.png</figcaption>~~
84		-	~~</figure>~~
	69	+	![](/wiki-images/9/9b/Package_rebuild.png)
85	70
86	71		- Restart Lazarus and see your new component in the component palette. Congratulations: You have just installed your first package with your first package component.
87	72
88		-	~~<figure>~~
89		-	~~<img src="package_installed.png" title="package_installed.png" />~~
90		-	~~<figcaption>package_installed.png</figcaption>~~
91		-	~~</figure>~~
	73	+	![](/wiki-images/3/35/Package_installed.png)
92	74
93	75		> Note: If you do not see your new component in the component palette, it is most likely that you are not running the re-compiled version of Lazarus. You can set where Lazarus builds to in: Tools -\> Options -\> Files -\> Lazarus directory. Instead of calling lazarus directly, you also can use startlazarus, which starts the newly created lazarus, for example the lazarus executable in the ~/.lazarus directory, if you don't have write access to the directory lazarus was installed into.
94	76
95	77		### 기존 유닛 추가
96	78
97	79		If you already had a unit you can add it to the package:
98	80
99		-	~~<figure>~~
100		-	~~<img src="package_existing_unit.png" title="package_existing_unit.png" />~~
101		-	~~<figcaption>package_existing_unit.png</figcaption>~~
102		-	~~</figure>~~
	81	+	![](/wiki-images/1/11/Package_existing_unit.png)
103	82
104	83		- Click the Add button, go to the Add Files tab. At the Unit file name, browse to your existing file. Click the Add files to package. If the packet manager complains that the unit is not in the unitpath, click yes to add the directory to the unit path.
105	84		- Click the Add button again, go to the Add Files tab and browse to the .lrs file and click OK (See Step 3 about creating this icon file).
106	85		- Click the Add button again, go to the New Requirement tab, in the Package name select LCL and click OK.
107	86
108	87		End result should look like this:
109	88
110	89		![`Package Maker`](/wiki-images/d/d9/How_to_write_lazarus_component_package_maker_done.png)
111	90
112	91		- Click on under the Files tree in the Package Manager. In the File Properties, make sure Register unit is checked.
113	92		- Click the Options button. Select the IDE Integration tab. At the Package Type make sure Designtime and Runtime is selected.
114	93		- Click the Compile button to check to see if the files compile without errors.
115	94		- Click the Install button, Lazarus will rebuild and restart automatically.
116	95
117	96		The component is created and ready to be used:
118	97
119	98		![`Component Created`](/wiki-images/3/3c/How_to_write_lazarus_component_created.png)
120	99
121	100		## 단계 3: 패키지 아이콘 생성
122	101
123	102		아이콘은 PNG 파일로 24x24 사이즈입니다.
124	103
125	104		FPC is capable of using standard resource files `.rc` or compiled resources `.res` since fpc version 2.6
126	105
127	106		The `.lrs`
128	107
129	108		### 라자루스 이미지 에디터 사용
130	109
131	110		You can use [[Lazarus Image Editor]] to create the icons in .lrs format.
132	111
133	112		### lazres 사용
134	113
135	114		`lazres`는 라자루스툴 디렉토리에 있는 located를 사용합니다.
136	115
137	116		You may need to compile lazres at first use. Simply open the lazres.lpi in the IDE and at the menu click run \> build.
138	117
139	118		Create lrs file
140	119
141	120		lrs 파일 생성:
142	121
143	122		`~/lazarus/tools/lazres samplepackage.lrs TMyCom.png`
144	123
145	124		Where samplepackage is the name of your package and TMyCom is the name of your component.
146	125
147	126		You can add more than one image to the lrs file by appending the image filename at the end. Eg. ~/lazarus/tools/lazres samplepackage.lrs TMyCom.png TMyOtherCom.png ...
148	127
149	128		샘플
150	129
151	130		Following is a sample of the resulting samplepackage.lrs file.
152	131
153	132		LazarusResources.Add('TMyCom','PNG',[
154	133		#137'PNG'#13#10#26#10#0#0#0#13'IHDR'#0#0#0#24#0#0#0#24#8#2#0#0#0'o'#21#170#175
155	134		+#0#0#0#4'gAMA'#0#0#177#143#11#252'a'#5#0#0#0'\|IDAT8O'#237#212#209#10#192' '#8
156	135		+#5'P'#247#231#251's'#215#138#133#164#166'\'#220#195'`'#209'c'#157'L'#173#131
157	136		+#153#169'd4'#168'dP'#137'r_'#235'5'#136'@Zmk'#16'd9'#144#176#232#164'1'#247
158	137		+'I'#8#160'IL'#206'C'#179#144#12#199#140'.'#134#244#141'~'#168#247#209'S~;'#29
159	138		+'V+'#196#201'^'#10#15#150'?'#255#18#227#206'NZ>42'#181#159#226#144#15'@'#201
160	139		+#148#168'e'#224'7f<@4'#130'u_YD'#23#213#131#134'Q]'#158#188#135#0#0#0#0'IEND'
161	140		+#174'B`'#130
162	141		]);
163	142
164	143		Make sure to include your resource file in your new component source by adding the following at the bottom your component's unit and including "LResources" in the uses clause
165	144
166	145		``` pascal
167	146		initialization
168	147		{$I samplepackage.lrs}
169	148		```
170	149
171	150		## 리컴파일링 패키지
172	151
173	152		You need to rebuild the package everytime you make changes to the mycom.pas file. To rebuild the package, open the samplepackage.lpk file in the Package Manager and click the Install button.
174	153
175	154		## 패키지 제거
176	155
177	156		- To remove installed components, on the IDE menu, click Package \> Configure installed packages. The following image shows the Installed Packages tool.
178	157
179	158		![`Installed Components`](/wiki-images/0/0e/How_to_write_lazarus_component_installed_components.png)
180	159
181	160		- Select the package you want to uninstall and click Uninstall selection.
182	161
183	162		If something goes wrong with a package (e.g. package directory is deleted without first uninstalling it), Lazarus may not allow you to uninstall packages. To fix the problem, at the IDE menu click Tools \> Build Lazarus. Lazarus will rebuild all packages and restart. You should now be able to uninstall problematic packages.
184	163
185	164		## mycom.pas 개선
186	165
187	166		- The codes in mycom.pas above gives you the basics on what you need to create a component. The following is an enhanced version with some tips on how to write procedures and events for components.
188	167		- OnChange2 이벤트를 만드는 방법을 보여줍니다
189	168		- The OnSample shows how to create custom events
190	169		- MyText and MyText2 shows different ways to write properties.
191	170		- You can use TComboBox instead of TCustomComboBox as the base class, which publishes all properties as TComboBox.
192	171		- If TCustomComboBox is used as the base class, you'll notice a lot of properties and events will be missing at the Object Inspector in the IDE. To add those properties and events just copy and paste the properties as listed below // properties from TComboBox. These list of properties can be got from the TComboBox declaration in the StdCtrls unit. Omit any property which you want to handle yourself.
193	172
194	173		``` pascal
195	174		unit mycom;
196	175
197	176		{$mode objfpc}{$H+}
198	177
199	178		interface
200	179
201	180		uses
202	181		Classes, SysUtils, StdCtrls, Forms, Dialogs,
203	182		LCLType,LCLIntf,lresources,LCLProc;
204	183
205	184		type
206	185
207	186		TSampleEvent = procedure(MyText: String) of Object;
208	187
209	188		TMyCom = class (TCustomComboBox)
210	189		private
211	190		FMyText: String;
212	191		FOnChange2: TNotifyEvent;
213	192		FOnSample: TSampleEvent;
214	193		public
215	194		constructor Create(TheOwner: TComponent); override;
216	195		procedure CreateWnd; override;
217	196		procedure Change; override;
218	197		protected
219	198		function GetMyText2: String;
220	199		procedure SetMyText2(MyText: String);
221	200		published
222	201		property MyText: String read FMyText write FMyText;
223	202		property MyText2: String read GetMyText2 write SetMyText2;
224	203		property OnChange2: TNotifyEvent read FOnChange2 write FOnChange2;
225	204		property OnSample: TSampleEvent read FOnSample write FOnSample;
226	205
227	206		// properties from TComboBox
228	207		property Align;
229	208		property Anchors;
230	209		property ArrowKeysTraverseList;
231	210		property AutoComplete;
232	211		property AutoCompleteText;
233	212		property AutoDropDown;
234	213		property AutoSelect;
235	214		property AutoSize;
236	215		property BidiMode;
237	216		property BorderSpacing;
238	217		property CharCase;
239	218		property Color;
240	219		property Ctl3D;
241	220		property Constraints;
242	221		property DragCursor;
243	222		property DragMode;
244	223		property DropDownCount;
245	224		property Enabled;
246	225		property Font;
247	226		property ItemHeight;
248	227		property ItemIndex;
249	228		property Items;
250	229		property ItemWidth;
251	230		property MaxLength;
252	231		property OnChange;
253	232		property OnChangeBounds;
254	233		property OnClick;
255	234		property OnCloseUp;
256	235		property OnContextPopup;
257	236		property OnDblClick;
258	237		property OnDragDrop;
259	238		property OnDragOver;
260	239		property OnDrawItem;
261	240		property OnEndDrag;
262	241		property OnDropDown;
263	242		property OnEditingDone;
264	243		property OnEnter;
265	244		property OnExit;
266	245		property OnGetItems;
267	246		property OnKeyDown;
268	247		property OnKeyPress;
269	248		property OnKeyUp;
270	249		property OnMeasureItem;
271	250		property OnMouseDown;
272	251		property OnMouseMove;
273	252		property OnMouseUp;
274	253		property OnStartDrag;
275	254		property OnSelect;
276	255		property OnUTF8KeyPress;
277	256		property ParentBidiMode;
278	257		property ParentColor;
279	258		property ParentCtl3D;
280	259		property ParentFont;
281	260		property ParentShowHint;
282	261		property PopupMenu;
283	262		property ReadOnly;
284	263		property ShowHint;
285	264		property Sorted;
286	265		property Style;
287	266		property TabOrder;
288	267		property TabStop;
289	268		property Text;
290	269		property Visible;
291	270		end;
292	271
293	272		procedure Register;
294	273
295	274		implementation
296	275
297	276		procedure Register;
298	277		begin
299	278		RegisterComponents('Sample',[TMyCom]);
300	279		end;
301	280
302	281		constructor TMyCom.Create(TheOwner: TComponent);
303	282		begin
304	283		inherited Create(TheOwner);
305	284		Self.Style := csDropDownList;
306	285		end;
307	286
308	287		procedure TMyCom.CreateWnd;
309	288		begin
310	289		inherited CreateWnd;
311	290		Items.Assign(Screen.Fonts);
312	291		end;
313	292
314	293		procedure TMyCom.Change;
315	294		begin
316	295		inherited;
317	296		if Assigned(FOnChange2) then FOnChange2(Self);
318	297		if Assigned(FOnSample) then FOnSample(FMyText);
319	298		end;
320	299
321	300		function TMyCom.GetMyText2: String;
322	301		begin
323	302		Result:=FMyText;
324	303		end;
325	304
326	305		procedure TMyCom.SetMyText2(MyText: String);
327	306		begin
328	307		FMyText:=MyText;
329	308		end;
330	309
331	310		initialization
332	311		{$I samplepackage.lrs}
333	312
334	313		end.
335	314		```
336	315
337	316		## 내장 (시각)컨포넌트 사용
338	317
339	318		It's possible to use standard components embedded in your own components (look for example at TLabeledEdit or TButtonPanel). Let's say you want to create a custom panel with a TLabel on it. With the steps described above the base package and source files can be created. Now to add a TLabel to the component, do the following:
340	319
341	320		- Add a private attribute for the label component (FEmbeddedLabel: TLabel;).
342	321		- Add a published read-only property for the label component (property EmbeddedLabel: TLabel read FEmbeddedLabel;)
343	322		- Create the label in the component's (overridden) constructor (FEmbeddedLabel := TLabel.Create(self); )
344	323		- Set the parent of the component (FEmbeddedLabel.Parent := self;)
345	324		- If the component to be embedded is not a 'subcomponent' by default (like TBoundLabel, TPanelBitBtn etc.) then add the call to SetSubComponent. This is necessary for the IDE so it knows that it has to store the properties of the embedded component as well. TLabel is not a subcomponent by default so the call to the method must be added (FEmbeddedLabel.SetSubComponent(true);).
346	325
347	326		To sum it up you would get something like this (only the essential parts are shown):
348	327
349	328		``` pascal
350	329		TEnhancedPanel = class(TCustomControl)
351	330		private
352	331		{ The new attribute for the embedded label }
353	332		FEmbeddedLabel: TLabel;
354	333
355	334		public
356	335		{ The constructor must be overriden so the label can be created }
357	336		constructor Create(AOwner: TComponent); override;
358	337
359	338		published
360	339		{ Make the label visible in the IDE }
361	340		property EmbeddedLabel: TLabel read FEmbeddedLabel;
362	341		end;
363	342
364	343		implementation
365	344
366	345		constructor TEnhancedPanel.Create(AOwner: TComponent);
367	346		begin
368	347		inherited Create(AOwner);
369	348
370	349		// Set default width and height
371	350		with GetControlClassDefaultSize do
372	351		SetInitialBounds(0, 0, CX, CY);
373	352
374	353		// Add the embedded label
375	354		FEmbeddedLabel := TLabel.Create(Self); // Add the embedded label
376	355		FEmbeddedLabel.Parent := self; // Show the label in the panel
377	356		FEmbeddedLabel.SetSubComponent(true); // Tell the IDE to store the modified properties
378	357		FLabel.Name := 'EmbeddedLabel';
379	358		FLabel.Caption := 'Howdy World!';
380	359
381	360		// Make sure the embedded label can not be selected/deleted within the IDE
382	361		FLabel.ControlStyle := FLabel.ControlStyle - [csNoDesignSelectable];
383	362
384	363		// Set other properties if necessary
385	364		//...
386	365
387	366		end;
388	367		```
389	368
390	369		## Using custom paint procedure
391	370
392	371		You can always subclass a component inside your program. For example, this implements a custom Paint procedure to a TLabel:
393	372
394	373		``` pascal
395	374		type
396	375		TMyLabel = class(TLabel)
397	376		public
398	377		procedure Paint; override;
399	378		end;
400	379		{...}
401	380		implementation
402	381		{...}
403	382		procedure TMyLabel.Paint;
404	383		begin
405	384		// your code to implement Paint, for example
406	385		Canvas.TextOut(0,0,Caption);
407	386		end;
408	387		```
409	388
410	389		Now you can create a MyLabel inside your program, at run time, with that overridden Paint procedure instead of the standard one.
411	390
412	391		For most components, and for most methods, it would be recommendable to call inherited procedure iniside it:
413	392
414	393		``` pascal
415	394		procedure TMyLabel.Paint;
416	395		begin
417	396
418	397		inherited Paint; /////////////////////
419	398
420	399		// your code to implement Paint, for example
421	400		Canvas.TextOut(0,0,Caption);
422	401		end;
423	402		```
424	403
425	404		But inherited behavior is not desirable in this case, since the second writing action would overlap the first (inherited) one.
426	405
427	406		## IDE와 컴포넌트를 통합
428	407
429	408		### Property Editors
430	409
431	410		Property editors provide custom dialogs to edit properties in the object inspector. For most properties, like strings, string lists, images, enumerated types and others, there are already default property editors, but if a custom component has a special kind of property it may require a custom dialog to edit the property. Each property editor is a class, which should descend from TPropertyEditor or one of it's descendents and implement methods from this base class. They should be registered in the 'Register' procedure by using the function RegisterPropertyEditor from the unit PropEdits. It is a standard to name property editors with the property name followed by 'Property', for example TFieldProperty for the property editor of the TField property.
432	411
433	412		``` pascal
434	413		TPropertyEditor = class
435	414		public
436	415		function AllEqual: Boolean; Virtual;
437	416		function AutoFill: Boolean; Virtual;
438	417		procedure Edit; Virtual; // Activated by double-clicking the property value
439	418		procedure ShowValue; Virtual; // Activated by control-clicking the property value
440	419		function GetAttributes: TPropertyAttributes; Virtual;
441	420		function GetEditLimit: Integer; Virtual;
442	421		function GetName: ShortString; Virtual;
443	422		procedure GetProperties(Proc: TGetPropEditProc); Virtual;
444	423		function GetHint(HintType: TPropEditHint; x, y: integer): String; Virtual;
445	424		function GetDefaultValue: AnsiString; Virtual;
446	425		procedure GetValues(Proc: TGetStrProc); Virtual;
447	426		procedure SetValue(const NewValue: AnsiString); Virtual;
448	427		procedure UpdateSubProperties; Virtual;
449	428		function SubPropertiesNeedsUpdate: Boolean; Virtual;
450	429		function IsDefaultValue: Boolean; Virtual;
451	430		function IsNotDefaultValue: Boolean; Virtual;
452	431		// ... shortened
453	432		end;
454	433		```
455	434
456	435		A good example for a property editor is the TFont property editor.
457	436
458	437		One of the most common cases for property editors is properties which are classes, because classes have many fields and can have a variety of formats, it's not possible for Lazarus to have the object inspector edit field able to edit it, like is done for strings and numeric types. For classes a convention is to have the value field show permanently the name of the class in parentheses, for example „(TFont)“ and the „...“ button shows a dialog to edit this class. This behavior, except for the dialog, is implemented by a standard property editor for classes called TClassPropertyEditor, which can be inherited from when writing property editors for classes:
459	438
460	439		``` pascal
461	440		TClassPropertyEditor = class(TPropertyEditor)
462	441		public
463	442		constructor Create(Hook: TPropertyEditorHook; APropCount: Integer); Override;
464	443		function GetAttributes: TPropertyAttributes; Override;
465	444		procedure GetProperties(Proc: TGetPropEditProc); Override;
466	445		function GetValue: AnsiString; Override;
467	446		property SubPropsTypeFilter: TTypeKinds Read FSubPropsTypeFilter
468	447		Write SetSubPropsTypeFilter
469	448		Default tkAny;
470	449		end;
471	450		```
472	451
473	452		Going back to the TFont example, inheriting from TClassPropertyEditor already offers part of the desired behavior and then the TFontPropertyEditor class only needs to implement showing the dialog in the Edit method and set the attributes for the editor:
474	453
475	454		``` pascal
476	455		TFontPropertyEditor = class(TClassPropertyEditor)
477	456		public
478	457		procedure Edit; Override;
479	458		function GetAttributes: TPropertyAttributes; Override;
480	459		end;
481	460
482	461		procedure TFontPropertyEditor.Edit;
483	462		var
484	463		FontDialog: TFontDialog;
485	464		begin
486	465		FontDialog := TFontDialog.Create(NIL);
487	466		try
488	467		FontDialog.Font := TFont(GetObjectValue(TFont));
489	468		FontDialog.Options := FontDialog.Options + [fdShowHelp, fdForceFontExist];
490	469		if FontDialog.Execute then SetPtrValue(FontDialog.Font);
491	470		finally
492	471		FontDialog.Free;
493	472		end;
494	473		end;
495	474
496	475		function TFontPropertyEditor.GetAttributes: TPropertyAttributes;
497	476		begin
498	477		Result := [paMultiSelect, paSubProperties, paDialog, paReadOnly];
499	478		end;
500	479		```
501	480
502	481		### 컴포넌트 에디터
503	482
504	483		Component editors control the behavior of right-clicking and double clicking components in the form designer. Each component editor is a class, which should descend from TComponentEditor or one of it's descendents and implement methods from this base class. They should be registered in the 'Register' procedure by using the function RegisterComponentEditor from the unit ComponentEditors. It is a standard to name component editors with the component name followed by 'Editor', for example TStringGridComponentEditor for the property editor of the TStringGrid component. Although user component editors should be based in TComponentEditor, most of it's methods are actually from an ancestor, so it is necessary to also know TBaseComponentEditor:
505	484
506	485		``` pascal
507	486		TBaseComponentEditor = class
508	487		protected
509	488		public
510	489		constructor Create(AComponent: TComponent;
511	490		ADesigner: TComponentEditorDesigner); Virtual;
512	491		procedure Edit; Virtual; Abstract;
513	492		procedure ExecuteVerb(Index: Integer); Virtual; Abstract;
514	493		function GetVerb(Index: Integer): String; Virtual; Abstract;
515	494		function GetVerbCount: Integer; Virtual; Abstract;
516	495		procedure PrepareItem(Index: Integer; const AnItem: TMenuItem); Virtual; Abstract;
517	496		procedure Copy; Virtual; Abstract;
518	497		function IsInInlined: Boolean; Virtual; Abstract;
519	498		function GetComponent: TComponent; Virtual; Abstract;
520	499		function GetDesigner: TComponentEditorDesigner; Virtual; Abstract;
521	500		function GetHook(out Hook: TPropertyEditorHook): Boolean; Virtual; Abstract;
522	501		procedure Modified; Virtual; Abstract;
523	502		end;
524	503		```
525	504
526	505		The most important method of a component editor is Edit, which is called when the component is double clicked. When the context menu for the component is invoked the GetVerbCount and GetVerb methods are called to build the menu. If one of the verbs (which means menu items in this case) are selected, ExecuteVerb is called. There is a default component editor (TDefaultEditor) which implements Edit to search the properties of the component for the most appropriate one to be edited. It usually chooses an event, which is edited by adding it's skeleton code in the code editor and setting the cursor to be in place to add code for it.
527	506
528	507		Other important methods from TBasComponentEditor are: ExecuteVerb(Index), which executes one of the extra menu items placed on the right-click popup menu; GetVerb – To return the name of each extra popup menu item. Note that t is the responsibility of the component editor to place special menu item caption characters like & to create a keyboard accelerator and “-” to create a separator; GetVerbCount – Returns the amount of items to be added to the popup menu. The index for the routines GetVerb and ExecuteVerb is zero based, going from 0 to GetVerbCount – 1; PrepareItem – Called for each verb after the menu item was created. Allows the menu item to be customized such as by adding subitems, adding a checkbox or even hiding it by setting Visible to false; Copy - Called when the component is being copied to the clipboard. The component data for use by Lazarus will always be added and cannot be modified. This method is instead for adding a different kind of clipboard information to paste the component in other applications, but which won't affect the Lazarus paste.
529	508
530	509		A simple and interesting example is the TCheckListBox component editor which creates a dialog to edit. More convenient then implementing all methods from TBaseComponentEditor is inheriting from TComponentEditor, and this is what TCheckListBoxEditor does. This base class adds empty implementations for most methods and some default ones for others. For Edit it calls ExecuteVerb(0), so if the first item will be identical to the double-click action, which is a convention for editor, there is no need to implement Edit. This basic action for the double-click and first menu item is often a dialog, and for TCheckListBox this is also done:
531	510
532	511		``` pascal
533	512		TCheckListBoxComponentEditor = class(TComponentEditor)
534	513		protected
535	514		procedure DoShowEditor;
536	515		public
537	516		procedure ExecuteVerb(Index: Integer); override;
538	517		function GetVerb(Index: Integer): String; override;
539	518		function GetVerbCount: Integer; override;
540	519		end;
541	520
542	521		procedure TCheckGroupComponentEditor.DoShowEditor;
543	522		var
544	523		Dlg: TCheckGroupEditorDlg;
545	524		begin
546	525		Dlg := TCheckGroupEditorDlg.Create(NIL);
547	526		try
548	527		// .. shortened
549	528		Dlg.ShowModal;
550	529		// .. shortened
551	530		finally
552	531		Dlg.Free;
553	532		end;
554	533		end;
555	534
556	535		procedure TCheckGroupComponentEditor.ExecuteVerb(Index: Integer);
557	536		begin
558	537		case Index of
559	538		0: DoShowEditor;
560	539		end;
561	540		end;
562	541
563	542		function TCheckGroupComponentEditor.GetVerb(Index: Integer): String;
564	543		begin
565	544		Result := 'CheckBox Editor...';
566	545		end;
567	546
568	547		function TCheckGroupComponentEditor.GetVerbCount: Integer;
569	548		begin
570	549		Result := 1;
571	550		end;
572	551		```
573	552
574	553		## 같이 보기
575	554
576	555		- [[Extending the IDE]]
577	556		- [[Lazarus Packages]] - A guide for creating a package under Lazarus
578	557		- [[Components and Code examples]]
579	558		- [[Lazarus Components]]
580	559		- [[IDE Window: Add to Package]]
581	560
582	561		You can post questions regarding this page [here](http://forum.lazarus.freepascal.org/index.php/topic,5789.0.html)
583	562
584	563		---
585	564		From the Free Pascal wiki, page "How To Write Lazarus Component/ko", as it stood on 2020-02-17 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