LCL Tips/de: what changed

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

Old	New		Line
1	1		## GUI Anwendung per Code erstellen
2	2
3	3		Es ist möglich eine [[Overview of Free Pascal and Lazarus/de\|GUI Anwendung]] (Graphical User Interface) vollständig durch Pascalcode in Lazarus zu erstellen. Alles, was von der IDE aus möglich ist, ist auch per Code umsetzbar. Die nachfolgenden Beispieldateien für die Programm- und Unitdateien (codegui.lpr und mainform.pas) können Sie als Vorlage verwenden, die Sie anpassen können. Das wichtigste ist, nicht zu vergessen die [[Parent/de\|Parent]]-Eigenschaft der Komponenten festzulegen. Die Erstellung von Steuerelementen innerhalb des Formulars erfolgt am besten im Konstruktor des Formulars:
4	4
5	5		Hauptprogrammdatei:
6	6
7	7		``` pascal
8	8		program codedgui;
9	9
10	10		{$MODE DELPHI}{$H+}
11	11
12	12		uses
13	13		Interfaces, Forms, StdCtrls,
14	14		MainForm;
15	15
16	16		var
17	17		MyForm: TMyForm;
18	18		begin
19	19		Application.Initialize;
20	20		Application.CreateForm(TMyForm, MyForm);
21	21		Application.Run;
22	22		end.
23	23		```
24	24
25	25		Die Unit, die das Formular beinhaltet:
26	26
27	27		``` pascal
28	28		unit mainform;
29	29
30	30		{$MODE DELPHI}{$H+}
31	31
32	32		interface
33	33
34	34		uses Forms, StdCtrls;
35	35
36	36		type
37	37		TMyForm = class(TForm)
38	38		public
39	39		MyButton: TButton;
40	40		procedure ButtonClick(ASender: TObject);
41	41		constructor Create(AOwner: TComponent); override;
42	42		end;
43	43
44	44		implementation
45	45
46	46		procedure TMyForm.ButtonClick(ASender:TObject);
47	47		begin
48	48		Close;
49	49		end;
50	50
51	51		constructor TMyForm.Create(AOwner: TComponent);
52	52		begin
53	53		inherited Create(AOwner);
54	54		//Hint: FormCreate() is called BEFORE Create() !
55	55		//so You can also put this code into FormCreate()
56	56		//(This is not the case when creating components ..)
57	57
58	58		Position := poScreenCenter;
59	59		Height := 400;
60	60		Width := 400;
61	61
62	62		VertScrollBar.Visible := False;
63	63		HorzScrollBar.Visible := False;
64	64
65	65		MyButton := TButton.Create(Self);
66	66		with MyButton do
67	67		begin
68	68		Height := 30;
69	69		Left := 100;
70	70		Top := 100;
71	71		Width := 100;
72	72		Caption := 'Close';
73	73		OnClick := ButtonClick;
74	74		Parent := Self;
75	75		end;
76	76
77	77		// Erstellen Sie hier noch weitere Komponenten
78	78		end;
79	79
80	80		end.
81	81		```
82	82
83	83		## Bedienelemente manuell erzeugen ohne Overhead
84	84
85	85		### Parent zuletzt setzen
86	86
87	87		Für Delphianer: Im Gegensatz zu Delphi erlaubt die LCL beinahe alle Eigenschaften in beliebiger Reihenfolge zu setzen. Zum Beispiel unter Delphi können sie ein Bedienelement nicht ohne a parent positionieren. Die LCL erlaubt dies und dieses Feature kann benutzt werden, den Overhead zu reduzieren.
88	88
89		-	~~` with TButton.Create(Form1) do begin`\~~
90		-	~~` // 1. Erzeugen eines button setzt die Vorgabegröße`\~~
91		-	~~` // 2. Ändern der Position. Keine Randeffekte, weil Parent=nil`\~~
92		-	~~` SetBounds(10,10,Width,Height);`\~~
93		-	~~` // 3. Ändern der Größe abhängig vom Thema. Noch nicht, weil Parent=nil`\~~
94		-	~~` AutoSize:=true;`\~~
95		-	~~` // 4. Ändern der Größe wegen AutoSize=true. Noch nicht, weil Parent=nil`\~~
96		-	~~` Caption:='Ok';`\~~
97		-	~~` // 5. Setzen sie Parent. Jetzt geschieht all das obige, aber in einer einzigen Aktion.`\~~
98		-	~~` Parent:=Form1;`\~~
99		-	~~` end;`~~
	89	+	``` pascal
	90	+	with TButton.Create(Form1) do begin
	91	+	// 1. Erzeugen eines button setzt die Vorgabegröße
	92	+	// 2. Ändern der Position. Keine Randeffekte, weil Parent=nil
	93	+	SetBounds(10,10,Width,Height);
	94	+	// 3. Ändern der Größe abhängig vom Thema. Noch nicht, weil Parent=nil
	95	+	AutoSize:=true;
	96	+	// 4. Ändern der Größe wegen AutoSize=true. Noch nicht, weil Parent=nil
	97	+	Caption:='Ok';
	98	+	// 5. Setzen sie Parent. Jetzt geschieht all das obige, aber in einer einzigen Aktion.
	99	+	Parent:=Form1;
	100	+	end;
	101	+	```
100	102
101	103		Wenn ein Bedienelement a Parent hat, dann werden alle Eigenschaften unverzüglich wirksam. Ohne a Parent tun viele Eigenschaften nicht mehr, als den Wert zu speichern. Und sobald the Parent gesetzt ist, wird jede Eigenschaft angewendet. Das trifft besonders für grand children zu:
102	104
103		-	~~` GroupBox1:=TGroupBox.Create(Self);`\~~
104		-	~~` with GroupBox1 do begin`\~~
105		-	~~` with TButton1.Create(Self) do begin`\~~
106		-	~~` AutoSize:=true;`\~~
107		-	~~` Caption:='Click me';`\~~
108		-	~~` Parent:=GroupBox1;`\~~
109		-	~~` end;`\~~
110		-	~~` Parent:=Form1;`\~~
111		-	~~` end;`\~~
112		-	~~` Form1.Show;`~~
	105	+	``` pascal
	106	+	GroupBox1:=TGroupBox.Create(Self);
	107	+	with GroupBox1 do begin
	108	+	with TButton1.Create(Self) do begin
	109	+	AutoSize:=true;
	110	+	Caption:='Click me';
	111	+	Parent:=GroupBox1;
	112	+	end;
	113	+	Parent:=Form1;
	114	+	end;
	115	+	Form1.Show;
	116	+	```
113	117
114	118		Autosizing startet nicht bevor jeder parent eingerichtet ist und das Formular sichtbar wird.
115	119
116	120		### Vermeiden sie eine frühe Handle Erzeugung
117	121
118	122		Sobald das Handle eines TWinControl erzeugt ist, ändert jede Änderung einer Eigenschaft the visual thing (called the widget), sogar wenn ein Bedienelement nicht sichtbar ist. Wenn es ein Handle hat, sind Änderungen dennoch aufwändig.
119	123
120	124		### Verwenden sie SetBounds anstelle von Left, Top, Width, Height
121	125
122	126		Anstelle von
123	127
124		-	~~` with Button1 do begin`\~~
125		-	~~` Left:=10;`\~~
126		-	~~` Top:=10;`\~~
127		-	~~` Width:=100;`\~~
128		-	~~` Height:=25;`\~~
129		-	~~` end;`~~
	128	+	``` pascal
	129	+	with Button1 do begin
	130	+	Left:=10;
	131	+	Top:=10;
	132	+	Width:=100;
	133	+	Height:=25;
	134	+	end;
	135	+	```
130	136
131	137		verwenden sie
132	138
133		-	~~` with Button1 do begin`\~~
134		-	~~` SetBounds(10,10,100,25);`\~~
135		-	~~` end;`~~
	139	+	``` pascal
	140	+	with Button1 do begin
	141	+	SetBounds(10,10,100,25);
	142	+	end;
	143	+	```
136	144
137	145		Left, Top, Width, Height rufen SetBounds auf. Und jede Änderung der Position oder Größe ruft die Neuberechnung aller sibling Bedienelemente und eventuell rekursiv die der parent und/oder der grandchild Bedienelemente auf.
138	146
139	147		## DisableAlign / EnableAlign
140	148
141	149		Wenn sie viele Bedienelemente positionieren, ist es eine gute Idee, die Neuberechnungvon all auto sizing, aligning, anchoring zu deaktivieren.
142	150
143		-	~~` DisableAlign;`\~~
144		-	~~` try`\~~
145		-	~~` ListBox1.Width:=ClientWidth div 3;`\~~
146		-	~~` ListBox2.Width:=ClientWidth div 3;`\~~
147		-	~~` ListBox3.Width:=ClientWidth div 3;`\~~
148		-	~~` finally`\~~
149		-	~~` EnableAlign;`\~~
150		-	~~` end;`~~
	151	+	``` pascal
	152	+	DisableAlign;
	153	+	try
	154	+	ListBox1.Width:=ClientWidth div 3;
	155	+	ListBox2.Width:=ClientWidth div 3;
	156	+	ListBox3.Width:=ClientWidth div 3;
	157	+	finally
	158	+	EnableAlign;
	159	+	end;
	160	+	```
151	161
152	162		Anmerkung: Jeder DisableAlign Aufruf benötigt einen EnableAlign Aufruf. Zum Beispiel wenn sie DisableAlign zweimal aufrufen, müssen sie auch EnableAlign zweimal aufrufen.
153	163
154	164		Für Delphianer: Dies funktioniert rekursiv. Das bedeutet, DisableAlign stoppt aligning in allen childs und grand childs.
155	165
156	166		## Ein nicht-rechteckiges Fenster oder Steuerelement erstellen
157	167
158	168		Sie können mit Lazarus recht einfach nicht rechteckige Fenster oder Steuerelemente erstellen. Hierzu können Sie einfach TWinControl.SetShape aufrufen, mit den sichtbaren Bereichen als ein Parameter. Hinweis: dies funktioniert für Fenster und Steuerelemente, wie TCustomForm und TCustomControl, die von TWinControl abgeleitet sind. Sie können LCLIntf-Routine SetWindowRgn aufrufen, die vollständig dem Aufruf der SetShape-Methode entspricht.
159	169
160	170		Mit SetWindowRgn wird der Code wie folgt aussehen:
161	171
162	172		``` pascal
163	173		uses LCLIntf, LCLType;
164	174
165	175		procedure TForm1.FormCreate(Sender: TObject);
166	176		var
167	177		MyRegion: HRGN;
168	178		begin
169	179		MyRegion := CreateRectRgn(0, 0, 100, 100);
170	180		SetWindowRgn(Handle, MyRegion, True);
171	181		DeleteObject(MyRegion);
172	182		end;
173	183		```
174	184
175	185		Nachfolg ein entsprechender Code, welcher ein, eine Ebene höheres, TRegion-Objekt verwendet, verfügbar in Lazarus 0.9.31+ (Hinweis: auch die vorherige Vorgehensweise wird in Zukunft weiterhin unterstützt werden):
176	186
177	187		``` pascal
178	188		uses Graphics;
179	189
180	190		procedure TForm1.FormCreate(Sender: TObject);
181	191		var
182	192		MyRegion: TRegion;
183	193		begin
184	194		MyRegion := TRegion.Create;
185	195		try
186	196		MyRegion.AddRectangle(0, 0, 100, 100);
187	197		Self.SetShape(MyRegion);
188	198		finally
189	199		MyRegion.Free;
190	200		end;
191	201		end;
192	202		```
193	203
194	204		Ein Ergebnis dieses Vorgehens, bei einem Fenster auf einem Mac OS X, welches das Qt Widgetset genutzt hat, sehen Sie hier:
195	205
196	206		![](/wiki-images/7/72/Non_rectangular_window.png)
197	207
198	208		Beachten Sie, dass SetShape auch ein TBitmap nutzen kann, um eine transparente Region zu beschreiben.
199	209
200	210		Siehe auch:
201	211
202	212		- [[LCL Internals\|LCL_Internals#Shaped_Windows]]
203	213
204	214		Dokumentationen:
205	215
206	216		- <http://lazarus-ccr.sourceforge.net/docs/lcl/lclintf/setwindowrgn.html>
207	217		- <http://lazarus-ccr.sourceforge.net/docs/lcl/controls/twincontrol.setshape.html>
208	218
209	219		Einschränkungen:
210	220
211	221		In Gtk2 kann eine Region erst festgelegt werden, nachdem ein Fenster erstellt wurde. SetWindowRgn im OnShow-Ereignishandler aufzurufen funktioniert nicht, die einzige Möglichkeit scheint der Einsatz eines Timers zu sein, der nach einem Intervall von 1 ms aufgerufen wird. Aktivieren Sie den Timer in Form.OnShow und deaktivieren Sie ihn im OnTimer-Handler.
212	222
213	223		## Simulation von Maus- and Tastatureingaben
214	224
215	225		Sie können sehr einfach Maus- und Tastatureingaben mit der LCL simulieren. Nutzen Sie dazu einfach die Routinen aus der Unit LCLMessageGlue wie es alle Widgetset Schnittstellen tun. Diese Unit verfügt über Routinen wie:
216	226
217	227		``` pascal
218	228		unit LCLMessageGlue;
219	229
220	230		function LCLSendMouseMoveMsg(const Target: TControl; XPos, YPos: smallint;
221	231		ShiftState: TShiftState = []): PtrInt;
222	232		function LCLSendMouseDownMsg(const Target: TControl; XPos, YPos: smallint;
223	233		Button: TMouseButton; ShiftState: TShiftState = []): PtrInt;
224	234		function LCLSendMouseUpMsg(const Target: TControl; XPos, YPos: smallint;
225	235		Button: TMouseButton; ShiftState: TShiftState = []): PtrInt;
226	236		function LCLSendMouseWheelMsg(const Target: TControl; XPos, YPos, WheelDelta: smallint;
227	237		ShiftState: TShiftState = []): PtrInt;
228	238		function LCLSendCaptureChangedMsg(const Target: TControl): PtrInt;
229	239		function LCLSendSelectionChangedMsg(const Target: TControl): PtrInt;
230	240		function LCLSendClickedMsg(const Target: TControl): PtrInt;
231	241		function LCLSendMouseEnterMsg(const Target: TControl): PtrInt;
232	242		function LCLSendMouseLeaveMsg(const Target: TControl): PtrInt;
233	243		...
234	244		function LCLSendKeyDownEvent(const Target: TControl; var CharCode: word;
235	245		KeyData: PtrInt; BeforeEvent, IsSysKey: boolean): PtrInt;
236	246		function LCLSendKeyUpEvent(const Target: TControl; var CharCode: word;
237	247		KeyData: PtrInt; BeforeEvent, IsSysKey: boolean): PtrInt;
238	248		```
239	249
240	250		## Die virtuelle Tastatur auf Smartphones/Tablets zeigen
241	251
242	252		Um die virtuelle Tastatur anzuzeigen, wenn ein Steuerelement den Fokus erhält, können Sie einfach csRequiresKeyboardInput ControlStyle hinzufügen:
243	253
244	254		``` pascal
245	255		constructor TMyTextEditor.Create(AOwner : TComponent);
246	256		begin
247	257		inherited Create(AOwner);
248	258		ControlStyle := ControlStyle + [csRequiresKeyboardInput];
249	259		...
250	260		end;
251	261		```
252	262
253	263		![](/wiki-images/2/29/Virtual_keyboard.png)
254	264
255	265		## Alle untergeordneten Controls von einem TWinControl durchlaufen
256	266
257	267		Dies ist sehr einfach zu realisieren. Benutzen Sie einfach eine Schleife. Der Index ist nullbasiert, TWinControl.ControlCount gibt die Anzahl an und TWinControl.Controls\[Index\] das entspechende Steuerelement.
258	268
259	269		``` pascal
260	270		procedure TWinControl.WriteLayoutDebugReport(const Prefix: string);
261	271		var
262	272		i: Integer;
263	273		begin
264	274		inherited WriteLayoutDebugReport(Prefix);
265	275		for i:=0 to ControlCount-1 do
266	276		Controls[i].WriteLayoutDebugReport(Prefix+' ');
267	277		end;
268	278		```
269	279
270	280		---
271	281		From the Free Pascal wiki, page "LCL Tips/de", as it stood on 2020-02-19 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