How To Write Lazarus Component/ko: what changed

Revision 2 to 3. 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	7		![](/wiki-images/7/7c/Package_menu.png)
8	8
9	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'.
10	10
11	11		- Congratulations: You have just created your first package!
12	12
13	13		![](/wiki-images/3/37/How_to_write_lazarus_component_package_maker.png)
14	14
15	15		## 단계 2: 유닛 생성
16	16
17	17		You can create a new unit or use an existing file.
18	18
19	19		### 새로운 유닛 생성
20	20
21	21		- Use the Add button \> New component.
22	22
23	23		![](/wiki-images/5/56/Package_new_component.png)
24	24
25	25		- Choose a component like TComboBox.
26	26		- Choose customcontrol1.pas as filename.
27	27		- Click OK.
28	28
29	29		``` pascal
30	30		unit CustomControl1;
31	31
32	32		{$mode objfpc}{$H+}
33	33
34	34		interface
35	35
36	36		uses
37	37		Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, StdCtrls;
38	38
39	39		type
40	40		TCustomControl1 = class(TComboBox)
41	41		private
42	42		{ Private declarations }
43	43		protected
44	44		{ Protected declarations }
45	45		public
46	46		{ Public declarations }
47	47		published
48	48		{ Published declarations }
49	49		end;
50	50
51	51		procedure Register;
52	52
53	53		implementation
54	54
55	55		procedure Register;
56	56		begin
57	57		RegisterComponents('Standard',[TCustomControl1]);
58	58		end;
59	59
60	60		end.
61	61		```
62	62
63	63		- Install the package by clicking the 'install' button at the top of the package editor.
64	64
65	65		![](/wiki-images/3/36/Package_install.png)
66	66
67	67		- Then the IDE will ask you, if the IDE should be rebuilt. Say yes.
68	68
69	69		![](/wiki-images/9/9b/Package_rebuild.png)
70	70
71	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.
72	72
73	73		![](/wiki-images/3/35/Package_installed.png)
74	74
75	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.
76	76
77	77		### 기존 유닛 추가
78	78
79	79		If you already had a unit you can add it to the package:
80	80
81	81		![](/wiki-images/1/11/Package_existing_unit.png)
82	82
83	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.
84	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).
85	85		- Click the Add button again, go to the New Requirement tab, in the Package name select LCL and click OK.
86	86
87	87		End result should look like this:
88	88
89		-	~~![`Package Maker`](/wiki-images/d/d9/How_to_write_lazarus_component_package_maker_done.png)~~
	89	+	```text
	90	+	Package Maker
	91	+	```
90	92
91	93		- Click on under the Files tree in the Package Manager. In the File Properties, make sure Register unit is checked.
92	94		- Click the Options button. Select the IDE Integration tab. At the Package Type make sure Designtime and Runtime is selected.
93	95		- Click the Compile button to check to see if the files compile without errors.
94	96		- Click the Install button, Lazarus will rebuild and restart automatically.
95	97
96	98		The component is created and ready to be used:
97	99
98		-	~~![`Component Created`](/wiki-images/3/3c/How_to_write_lazarus_component_created.png)~~
	100	+	```text
	101	+	Component Created
	102	+	```
99	103
100	104		## 단계 3: 패키지 아이콘 생성
101	105
102	106		아이콘은 PNG 파일로 24x24 사이즈입니다.
103	107
104	108		FPC is capable of using standard resource files `.rc` or compiled resources `.res` since fpc version 2.6
105	109
106	110		The `.lrs`
107	111
108	112		### 라자루스 이미지 에디터 사용
109	113
110	114		You can use [[Lazarus Image Editor]] to create the icons in .lrs format.
111	115
112	116		### lazres 사용
113	117
114	118		`lazres`는 라자루스툴 디렉토리에 있는 located를 사용합니다.
115	119
116	120		You may need to compile lazres at first use. Simply open the lazres.lpi in the IDE and at the menu click run \> build.
117	121
118	122		Create lrs file
119	123
120	124		lrs 파일 생성:
121	125
122	126		`~/lazarus/tools/lazres samplepackage.lrs TMyCom.png`
123	127
124	128		Where samplepackage is the name of your package and TMyCom is the name of your component.
125	129
126	130		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 ...
127	131
128	132		샘플
129	133
130	134		Following is a sample of the resulting samplepackage.lrs file.
131	135
132	136		LazarusResources.Add('TMyCom','PNG',[
133	137		#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
134	138		+#0#0#0#4'gAMA'#0#0#177#143#11#252'a'#5#0#0#0'\|IDAT8O'#237#212#209#10#192' '#8
135	139		+#5'P'#247#231#251's'#215#138#133#164#166'\'#220#195'`'#209'c'#157'L'#173#131
136	140		+#153#169'd4'#168'dP'#137'r_'#235'5'#136'@Zmk'#16'd9'#144#176#232#164'1'#247
137	141		+'I'#8#160'IL'#206'C'#179#144#12#199#140'.'#134#244#141'~'#168#247#209'S~;'#29
138	142		+'V+'#196#201'^'#10#15#150'?'#255#18#227#206'NZ>42'#181#159#226#144#15'@'#201
139	143		+#148#168'e'#224'7f<@4'#130'u_YD'#23#213#131#134'Q]'#158#188#135#0#0#0#0'IEND'
140	144		+#174'B`'#130
141	145		]);
142	146
143	147		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
144	148
145	149		``` pascal
146	150		initialization
147	151		{$I samplepackage.lrs}
148	152		```
149	153
150	154		## 리컴파일링 패키지
151	155
152	156		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.
153	157
154	158		## 패키지 제거
155	159
156	160		- To remove installed components, on the IDE menu, click Package \> Configure installed packages. The following image shows the Installed Packages tool.
157	161
158		-	~~![`Installed Components`](/wiki-images/0/0e/How_to_write_lazarus_component_installed_components.png)~~
	162	+	```text
	163	+	Installed Components
	164	+	```
159	165
160	166		- Select the package you want to uninstall and click Uninstall selection.
161	167
162	168		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.
163	169
164	170		## mycom.pas 개선
165	171
166	172		- 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.
167	173		- OnChange2 이벤트를 만드는 방법을 보여줍니다
168	174		- The OnSample shows how to create custom events
169	175		- MyText and MyText2 shows different ways to write properties.
170	176		- You can use TComboBox instead of TCustomComboBox as the base class, which publishes all properties as TComboBox.
171	177		- 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.
172	178
173	179		``` pascal
174	180		unit mycom;
175	181
176	182		{$mode objfpc}{$H+}
177	183
178	184		interface
179	185
180	186		uses
181	187		Classes, SysUtils, StdCtrls, Forms, Dialogs,
182	188		LCLType,LCLIntf,lresources,LCLProc;
183	189
184	190		type
185	191
186	192		TSampleEvent = procedure(MyText: String) of Object;
187	193
188	194		TMyCom = class (TCustomComboBox)
189	195		private
190	196		FMyText: String;
191	197		FOnChange2: TNotifyEvent;
192	198		FOnSample: TSampleEvent;
193	199		public
194	200		constructor Create(TheOwner: TComponent); override;
195	201		procedure CreateWnd; override;
196	202		procedure Change; override;
197	203		protected
198	204		function GetMyText2: String;
199	205		procedure SetMyText2(MyText: String);
200	206		published
201	207		property MyText: String read FMyText write FMyText;
202	208		property MyText2: String read GetMyText2 write SetMyText2;
203	209		property OnChange2: TNotifyEvent read FOnChange2 write FOnChange2;
204	210		property OnSample: TSampleEvent read FOnSample write FOnSample;
205	211
206	212		// properties from TComboBox
207	213		property Align;
208	214		property Anchors;
209	215		property ArrowKeysTraverseList;
210	216		property AutoComplete;
211	217		property AutoCompleteText;
212	218		property AutoDropDown;
213	219		property AutoSelect;
214	220		property AutoSize;
215	221		property BidiMode;
216	222		property BorderSpacing;
217	223		property CharCase;
218	224		property Color;
219	225		property Ctl3D;
220	226		property Constraints;
221	227		property DragCursor;
222	228		property DragMode;
223	229		property DropDownCount;
224	230		property Enabled;
225	231		property Font;
226	232		property ItemHeight;
227	233		property ItemIndex;
228	234		property Items;
229	235		property ItemWidth;
230	236		property MaxLength;
231	237		property OnChange;
232	238		property OnChangeBounds;
233	239		property OnClick;
234	240		property OnCloseUp;
235	241		property OnContextPopup;
236	242		property OnDblClick;
237	243		property OnDragDrop;
238	244		property OnDragOver;
239	245		property OnDrawItem;
240	246		property OnEndDrag;
241	247		property OnDropDown;
242	248		property OnEditingDone;
243	249		property OnEnter;
244	250		property OnExit;
245	251		property OnGetItems;
246	252		property OnKeyDown;
247	253		property OnKeyPress;
248	254		property OnKeyUp;
249	255		property OnMeasureItem;
250	256		property OnMouseDown;
251	257		property OnMouseMove;
252	258		property OnMouseUp;
253	259		property OnStartDrag;
254	260		property OnSelect;
255	261		property OnUTF8KeyPress;
256	262		property ParentBidiMode;
257	263		property ParentColor;
258	264		property ParentCtl3D;
259	265		property ParentFont;
260	266		property ParentShowHint;
261	267		property PopupMenu;
262	268		property ReadOnly;
263	269		property ShowHint;
264	270		property Sorted;
265	271		property Style;
266	272		property TabOrder;
267	273		property TabStop;
268	274		property Text;
269	275		property Visible;
270	276		end;
271	277
272	278		procedure Register;
273	279
274	280		implementation
275	281
276	282		procedure Register;
277	283		begin
278	284		RegisterComponents('Sample',[TMyCom]);
279	285		end;
280	286
281	287		constructor TMyCom.Create(TheOwner: TComponent);
282	288		begin
283	289		inherited Create(TheOwner);
284	290		Self.Style := csDropDownList;
285	291		end;
286	292
287	293		procedure TMyCom.CreateWnd;
288	294		begin
289	295		inherited CreateWnd;
290	296		Items.Assign(Screen.Fonts);
291	297		end;
292	298
293	299		procedure TMyCom.Change;
294	300		begin
295	301		inherited;
296	302		if Assigned(FOnChange2) then FOnChange2(Self);
297	303		if Assigned(FOnSample) then FOnSample(FMyText);
298	304		end;
299	305
300	306		function TMyCom.GetMyText2: String;
301	307		begin
302	308		Result:=FMyText;
303	309		end;
304	310
305	311		procedure TMyCom.SetMyText2(MyText: String);
306	312		begin
307	313		FMyText:=MyText;
308	314		end;
309	315
310	316		initialization
311	317		{$I samplepackage.lrs}
312	318
313	319		end.
314	320		```
315	321
316	322		## 내장 (시각)컨포넌트 사용
317	323
318	324		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:
319	325
320	326		- Add a private attribute for the label component (FEmbeddedLabel: TLabel;).
321	327		- Add a published read-only property for the label component (property EmbeddedLabel: TLabel read FEmbeddedLabel;)
322	328		- Create the label in the component's (overridden) constructor (FEmbeddedLabel := TLabel.Create(self); )
323	329		- Set the parent of the component (FEmbeddedLabel.Parent := self;)
324	330		- 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);).
325	331
326	332		To sum it up you would get something like this (only the essential parts are shown):
327	333
328	334		``` pascal
329	335		TEnhancedPanel = class(TCustomControl)
330	336		private
331	337		{ The new attribute for the embedded label }
332	338		FEmbeddedLabel: TLabel;
333	339
334	340		public
335	341		{ The constructor must be overriden so the label can be created }
336	342		constructor Create(AOwner: TComponent); override;
337	343
338	344		published
339	345		{ Make the label visible in the IDE }
340	346		property EmbeddedLabel: TLabel read FEmbeddedLabel;
341	347		end;
342	348
343	349		implementation
344	350
345	351		constructor TEnhancedPanel.Create(AOwner: TComponent);
346	352		begin
347	353		inherited Create(AOwner);
348	354
349	355		// Set default width and height
350	356		with GetControlClassDefaultSize do
351	357		SetInitialBounds(0, 0, CX, CY);
352	358
353	359		// Add the embedded label
354	360		FEmbeddedLabel := TLabel.Create(Self); // Add the embedded label
355	361		FEmbeddedLabel.Parent := self; // Show the label in the panel
356	362		FEmbeddedLabel.SetSubComponent(true); // Tell the IDE to store the modified properties
357	363		FLabel.Name := 'EmbeddedLabel';
358	364		FLabel.Caption := 'Howdy World!';
359	365
360	366		// Make sure the embedded label can not be selected/deleted within the IDE
361	367		FLabel.ControlStyle := FLabel.ControlStyle - [csNoDesignSelectable];
362	368
363	369		// Set other properties if necessary
364	370		//...
365	371
366	372		end;
367	373		```
368	374
369	375		## Using custom paint procedure
370	376
371	377		You can always subclass a component inside your program. For example, this implements a custom Paint procedure to a TLabel:
372	378
373	379		``` pascal
374	380		type
375	381		TMyLabel = class(TLabel)
376	382		public
377	383		procedure Paint; override;
378	384		end;
379	385		{...}
380	386		implementation
381	387		{...}
382	388		procedure TMyLabel.Paint;
383	389		begin
384	390		// your code to implement Paint, for example
385	391		Canvas.TextOut(0,0,Caption);
386	392		end;
387	393		```
388	394
389	395		Now you can create a MyLabel inside your program, at run time, with that overridden Paint procedure instead of the standard one.
390	396
391	397		For most components, and for most methods, it would be recommendable to call inherited procedure iniside it:
392	398
393	399		``` pascal
394	400		procedure TMyLabel.Paint;
395	401		begin
396	402
397	403		inherited Paint; /////////////////////
398	404
399	405		// your code to implement Paint, for example
400	406		Canvas.TextOut(0,0,Caption);
401	407		end;
402	408		```
403	409
404	410		But inherited behavior is not desirable in this case, since the second writing action would overlap the first (inherited) one.
405	411
406	412		## IDE와 컴포넌트를 통합
407	413
408	414		### Property Editors
409	415
410	416		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.
411	417
412	418		``` pascal
413	419		TPropertyEditor = class
414	420		public
415	421		function AllEqual: Boolean; Virtual;
416	422		function AutoFill: Boolean; Virtual;
417	423		procedure Edit; Virtual; // Activated by double-clicking the property value
418	424		procedure ShowValue; Virtual; // Activated by control-clicking the property value
419	425		function GetAttributes: TPropertyAttributes; Virtual;
420	426		function GetEditLimit: Integer; Virtual;
421	427		function GetName: ShortString; Virtual;
422	428		procedure GetProperties(Proc: TGetPropEditProc); Virtual;
423	429		function GetHint(HintType: TPropEditHint; x, y: integer): String; Virtual;
424	430		function GetDefaultValue: AnsiString; Virtual;
425	431		procedure GetValues(Proc: TGetStrProc); Virtual;
426	432		procedure SetValue(const NewValue: AnsiString); Virtual;
427	433		procedure UpdateSubProperties; Virtual;
428	434		function SubPropertiesNeedsUpdate: Boolean; Virtual;
429	435		function IsDefaultValue: Boolean; Virtual;
430	436		function IsNotDefaultValue: Boolean; Virtual;
431	437		// ... shortened
432	438		end;
433	439		```
434	440
435	441		A good example for a property editor is the TFont property editor.
436	442
437	443		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:
438	444
439	445		``` pascal
440	446		TClassPropertyEditor = class(TPropertyEditor)
441	447		public
442	448		constructor Create(Hook: TPropertyEditorHook; APropCount: Integer); Override;
443	449		function GetAttributes: TPropertyAttributes; Override;
444	450		procedure GetProperties(Proc: TGetPropEditProc); Override;
445	451		function GetValue: AnsiString; Override;
446	452		property SubPropsTypeFilter: TTypeKinds Read FSubPropsTypeFilter
447	453		Write SetSubPropsTypeFilter
448	454		Default tkAny;
449	455		end;
450	456		```
451	457
452	458		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:
453	459
454	460		``` pascal
455	461		TFontPropertyEditor = class(TClassPropertyEditor)
456	462		public
457	463		procedure Edit; Override;
458	464		function GetAttributes: TPropertyAttributes; Override;
459	465		end;
460	466
461	467		procedure TFontPropertyEditor.Edit;
462	468		var
463	469		FontDialog: TFontDialog;
464	470		begin
465	471		FontDialog := TFontDialog.Create(NIL);
466	472		try
467	473		FontDialog.Font := TFont(GetObjectValue(TFont));
468	474		FontDialog.Options := FontDialog.Options + [fdShowHelp, fdForceFontExist];
469	475		if FontDialog.Execute then SetPtrValue(FontDialog.Font);
470	476		finally
471	477		FontDialog.Free;
472	478		end;
473	479		end;
474	480
475	481		function TFontPropertyEditor.GetAttributes: TPropertyAttributes;
476	482		begin
477	483		Result := [paMultiSelect, paSubProperties, paDialog, paReadOnly];
478	484		end;
479	485		```
480	486
481	487		### 컴포넌트 에디터
482	488
483	489		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:
484	490
485	491		``` pascal
486	492		TBaseComponentEditor = class
487	493		protected
488	494		public
489	495		constructor Create(AComponent: TComponent;
490	496		ADesigner: TComponentEditorDesigner); Virtual;
491	497		procedure Edit; Virtual; Abstract;
492	498		procedure ExecuteVerb(Index: Integer); Virtual; Abstract;
493	499		function GetVerb(Index: Integer): String; Virtual; Abstract;
494	500		function GetVerbCount: Integer; Virtual; Abstract;
495	501		procedure PrepareItem(Index: Integer; const AnItem: TMenuItem); Virtual; Abstract;
496	502		procedure Copy; Virtual; Abstract;
497	503		function IsInInlined: Boolean; Virtual; Abstract;
498	504		function GetComponent: TComponent; Virtual; Abstract;
499	505		function GetDesigner: TComponentEditorDesigner; Virtual; Abstract;
500	506		function GetHook(out Hook: TPropertyEditorHook): Boolean; Virtual; Abstract;
501	507		procedure Modified; Virtual; Abstract;
502	508		end;
503	509		```
504	510
505	511		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.
506	512
507	513		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.
508	514
509	515		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:
510	516
511	517		``` pascal
512	518		TCheckListBoxComponentEditor = class(TComponentEditor)
513	519		protected
514	520		procedure DoShowEditor;
515	521		public
516	522		procedure ExecuteVerb(Index: Integer); override;
517	523		function GetVerb(Index: Integer): String; override;
518	524		function GetVerbCount: Integer; override;
519	525		end;
520	526
521	527		procedure TCheckGroupComponentEditor.DoShowEditor;
522	528		var
523	529		Dlg: TCheckGroupEditorDlg;
524	530		begin
525	531		Dlg := TCheckGroupEditorDlg.Create(NIL);
526	532		try
527	533		// .. shortened
528	534		Dlg.ShowModal;
529	535		// .. shortened
530	536		finally
531	537		Dlg.Free;
532	538		end;
533	539		end;
534	540
535	541		procedure TCheckGroupComponentEditor.ExecuteVerb(Index: Integer);
536	542		begin
537	543		case Index of
538	544		0: DoShowEditor;
539	545		end;
540	546		end;
541	547
542	548		function TCheckGroupComponentEditor.GetVerb(Index: Integer): String;
543	549		begin
544	550		Result := 'CheckBox Editor...';
545	551		end;
546	552
547	553		function TCheckGroupComponentEditor.GetVerbCount: Integer;
548	554		begin
549	555		Result := 1;
550	556		end;
551	557		```
552	558
553	559		## 같이 보기
554	560
555	561		- [[Extending the IDE]]
556	562		- [[Lazarus Packages]] - A guide for creating a package under Lazarus
557	563		- [[Components and Code examples]]
558	564		- [[Lazarus Components]]
559	565		- [[IDE Window: Add to Package]]
560	566
561	567		You can post questions regarding this page [here](http://forum.lazarus.freepascal.org/index.php/topic,5789.0.html)
562	568
563	569		---
564	570		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