Form Tutorial/de: what changed

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

Title: Form Tutorial/de

New		Line
1	+	\
2	+	Zurück zu den [[Additional information/de\|Zusätzlichen Informationen]].\
3	+	\
4	+	Eine kleine Einführung, wie man Formulare in Lazarus nutzt.
5	+
6	+	## Was ist ein Formular
7	+
8	+	Das Formular (engl. Form, Klasse [[TForm/de\|TForm]]) wird auch im Deutschen öfters (fälschlicherweise) als Form bezeichnet. Es stellt ein Fenster oder ein Dialogfeld dar, welches die Benutzeroberfläche einer Anwendung bildet. Es ist der Container, auf dem alle weiteren Komponenten (z.B. Buttons, Labels, Edit-Felder, Images etc.) eingefügt werden.
9	+
10	+	## Einstieg, die erste GUI-Anwendung
11	+
12	+	Schon nachdem Sie Lazarus erfolgreich installiert haben, wird nach dem Start von Lazarus ein neues Projekt mit einem leeren Formular Form1 erstellt. Ansonsten können Sie, unter dem Hauptmenueintrag Projekt -\> Neues Projekt -\> Anwendung, eine neue [[Overview of Free Pascal and Lazarus/de\|GUI Anwendung]] erstellen.
13	+
14	+	<figure>
15	+	<img src="NeuesProjekt.png" title="NeuesProjekt.png" />
16	+	<figcaption>NeuesProjekt.png</figcaption>
17	+	</figure>
18	+
19	+	<figure>
20	+	<img src="NeuesProjekt1.png" title="NeuesProjekt1.png" />
21	+	<figcaption>NeuesProjekt1.png</figcaption>
22	+	</figure>
23	+
24	+	Jetzt haben Sie schon ein neues, funktionstüchtiges Projekt mit einem Formular erstellt:
25	+
26	+	<figure>
27	+	<img src="Form1_Designmodus.png" title="Form1_Designmodus.png" />
28	+	<figcaption>Form1_Designmodus.png</figcaption>
29	+	</figure>
30	+
31	+	Um das neu erstellte Projekt zu starten, können Sie einfach die Taste \[F9\] drücken oder mit der Maus auf das Hauptmenu-Symbol ![](/wiki-images/b/b8/Start.png) klicken (oder Hauptmenü: Start -\> Start). Das Projekt wird nun im Normalfall kompiliert und gestartet.
32	+
33	+	Es passiert nichts wirklich aufregendes, das Formular Form1 verändert jedoch geringfügig sein Aussehen und wird die Punkte vom Raster-Gitter (Hilfe für Positionierung einzelner Komponenten) verlieren (solange die Gitterpunkte sichtbar sind, wissen Sie auch, dass Sie sich noch im Entwurfsmodus befinden):
34	+
35	+	![](/wiki-images/7/73/Form1_Designmodus.png) -\> ![](/wiki-images/d/dc/Form1_Runmodus.png)
36	+
37	+	Kehren Sie wieder in den Entwurfsmodus zurück und legen als nächstes ein [[TButton/de\|TButton]] (Schaltknopf) auf dem Formular ab. Dieser soll später das Öffnen eines zweiten Formulars ermöglichen:
38	+
39	+	- Unter der Standard-Komponentenpalette den TButton auswählen
40	+
41	+	<figure>
42	+	<img src="TButtonStandardpalette.png" title="TButtonStandardpalette.png" />
43	+	<figcaption>TButtonStandardpalette.png</figcaption>
44	+	</figure>
45	+
46	+	- auf das Formular klicken: Es wird ein Button auf Form1 abgelegt mit dem Namen und Bezeichnung (Caption) Button1.
47	+
48	+	Damit dieser Button auch einen Sinn bekommt, müssen Sie diesem mitteilen, dass er etwas tun soll, wenn auf ihn geklickt wird. Dieses Klicken kann man vereinfacht als ein [Ereignis](http://de.wikipedia.org/wiki/Ereignis_%28Programmierung%29) (engl. Event) betrachten. Dafür benötigt man [[Event order/de\|Ereignisbehandlungsroutinen]] (engl. listener, observer, event handler), die nach dem Klick aufgerufen werden. Der Eventhandler für ein Mausklick kann recht einfach erreicht werden, indem Sie auf den einfügten Button1 doppelklicken (oder im Objektinspektor -\> Button1 -\> Reiter Ereignisse -\> OnClick auf den Button \[...\] klicken). Es wird nun im Quelltexteditor eine Procedure `TForm1.Button1Click` erstellt, die immer aufgerufen wird (zur Laufzeit, nicht im Desingnmodus), wenn Button1 geklickt wird:
49	+
50	+	<figure>
51	+	<img src="NeuesProjekt2.png" title="NeuesProjekt2.png" />
52	+	<figcaption>NeuesProjekt2.png</figcaption>
53	+	</figure>
54	+
55	+	Damit die Anwendung nach dem Klick von Button1 etwas zu tun bekommt, fügen Sie einfach zwischen begin und end der Procedure TForm1.Button1Click etwas Code, wie
56	+
57	+	``` pascal
58	+	procedure TForm1.Button1Click(Sender: TObject);
59	+	begin
60	+	Caption:='Mein erstes Formular'; //Caption von Form1 wird geändert (Text im Formularkopf)
61	+	//oder
62	+	Button1.Caption:='Hallo'; //Caption vom Button1 wird geändert (angezeigter Text des Buttons)
63	+	end;
64	+	```
65	+
66	+	ein. Jetzt können Sie Ihre Anwendung starten (mit Taste \[F9\]) und sich freuen...
67	+
68	+	Nachdem Sie nun Ihre erste GUI-Anwendung erstellt haben, können Sie nun ein wenig experimentieren und die Standardkomponenten kennen lernen. Für den Einstieg würde ich Ihnen empfehlen, Beispiele folgender Komponenten auszuprobieren:
69	+
70	+	- [[TButton/de\|TButton]]
71	+	- [[TLabel/de\|TLabel]]
72	+	- [[TEdit/de\|TEdit]]
73	+	- [[TMemo/de\|TMemo]]
74	+	- [[TToggleBox/de\|TToggleBox]]
75	+	- [[TRadioButton/de\|TRadioButton]]
76	+	- [[TListBox/de\|TListBox]]
77	+	- [[TComboBox/de\|TComboBox]]
78	+	- [[TScrollBar/de\|TScrollBar]]
79	+
80	+	hilfreiche Informationen finden Sie auch im [[Lazarus Tutorial/de\|Lazarus Tutorial]]
81	+
82	+	## Verwendung eines zweiten Formulars
83	+
84	+	Das Tutorial zeigt, wie Sie mehrere Formulare in einem Projekt nutzen können. Im Beispiel werden nur zwei Formulare (Hauptformular Form1 und Form2) erstellt, für weitere Formulare können Sie analog verfahren.
85	+
86	+	Kongret erstellen Sie eine Hauptformular mit einem Button (Knopf), durch dessen Klicken sich die neues Formular öffnet. Das neue Formular erhält ebenfalls einen Button, durch dessen Klicken sich das neue Formular wieder schließt und Sie zum Hauptformular zurück gelangen.
87	+
88	+	Wenn Sie das Tutorial [[Form Tutorial/de\|Einstieg, die erste GUI-Anwendung]] durchgearbeitet haben, müssten Sie den Code zwischen begin und end der Procedure TForm1.Button1Click löschen. Ansonsten müssten Sie ein neues Projekt (Anwendung) erstellen, einen Button auf dem Formular ablegen und den OnClick-Eventhandler von diesem Button1 erstellen.\
89	+	Diesem Button geben Sie noch eine andere Caption (sichtbarer Text auf dem Button). Dazu den Button anwählen (einfach einmal anklicken) und im Objektinspektor unter Eigenschaften -\> Caption den Text "Form2 öffnen" eingeben.
90	+
91	+	<figure>
92	+	<img src="Objektinspektor.png" title="Objektinspektor.png" />
93	+	<figcaption>Objektinspektor.png</figcaption>
94	+	</figure>
95	+
96	+	Unter dem Hauptmenupunkt Datei -\> neues Formular können Sie nun ein zweites Formular (Form2) dem Projekt hinzufügen. Auf diesem legen Sie ebenfalls einen Button (Button1) ab und erstellen den OnClick-Eventhandler von diesem. Die Caption von diesem Button ändern Sie analog oben zu Schließen.\
97	+	\
98	+	Jetzt hat das Projekt zwei Formulare, welche jeweils mit dem Hauptmenueintrag Projekt -\> Formulare (oder Tastenkombination \[Shift\]+\[F12\]) ausgewählt und angezeigt werden können. Hilfsweise können Sie auch im Quelltexteditor den Reiter der jeweiligen zum Formular zugehörigen [[Unit/de\|Unit]] auswählen und mit \[F12\] das entsprechende Formular anzeigen (mit \[F12\] wechselt man zwischen Quelltexteditor und Formular).
99	+
100	+	Im Quelltexteditor gehen Sie jetzt auf die zu Form1 gehörende [[Unit/de\|Unit]] (Unit1) und fügen der Uses-Klausel Unit2 hinzu:
101	+
102	+	``` pascal
103	+	uses
104	+	Classes, SysUtils, ... , Unit2; //wichtig ist dass die einzelnen Units mit einem Komma voneinander getrennt sind
105	+	//und die Uses-Klausel mit einem Semikolon beendet wird
106	+	```
107	+
108	+	Nun ist Unit2 und damit Form2 von der Unit1 aus aufrufbar.
109	+
110	+	Als nächstes bearbeiten Sie noch die OnClick-Events der Buttons der jeweiligen Formulare:
111	+
112	+	``` pascal
113	+	unit Unit1;
114	+	...
115	+	procedure TForm1.Button1Click(Sender: TObject);
116	+	begin
117	+	Form2.ShowModal; //Zeigt Form2 an, der Focus wird auf Form2 gesetzt
118	+	end;
119	+	```
120	+
121	+	``` pascal
122	+	unit Unit2;
123	+	...
124	+	procedure TForm2.Button1Click(Sender: TObject);
125	+	begin
126	+	Close; //Schließt Form2
127	+	end;
128	+	```
129	+
130	+	Jetzt können Sie das Projekt starten und von Form1 mittels Buttonklick Form2 öffnen.
131	+
132	+	### Unterschied zwischen Show und ShowModal
133	+
134	+	Beide Methoden Show und ShowModal machen ein Formular sichtbar. An einem kleinen Beispiel können Sie erfahren, was der Unterschied dieser ist:
135	+
136	+	- Fügen Sie zu dem vorherigen Beispiel [[Form Tutorial/de\|Verwendung eines zweiten Formulars]] der Form1 noch einen zweiten TButton hinzu.
137	+	- Ändern Sie von Button1 die Eigenschaften Name zu btnShow und Caption zu Show.
138	+	- Ändern Sie von Button2 die Eigenschaften Name zu btnShowModal und Caption zu ShowModal.
139	+	- Erstellen Sie (bzw. ändern Sie) die OnClick-Eventhandler der beiden Buttons wie folgt:
140	+
141	+	``` pascal
142	+	procedure TForm1.btnShowClick(Sender: TObject);
143	+	begin
144	+	Form2.Show;
145	+	ShowMessage('Form2 wurde geöffnet!');
146	+	end;
147	+
148	+	procedure TForm1.btnShowModalClick(Sender: TObject);
149	+	begin
150	+	Form2.ShowModal;
151	+	ShowMessage('Form2 wurde geöffnet und schon wieder geschlossen!');
152	+	end;
153	+	```
154	+
155	+	- Starten und beobachten Sie den Unterschied!\
156	+
157	+	\
158	+	Show:\
159	+	Diese Procedure macht ein Formular sichtbar und arbeitet den Code des aufrufenden Controls (bei uns Form1) weiter ab. In unserem Beispiel wird die Mitteilung (ShowMessage) fast gleichzeitig zur Form2 angezeigt. Sie können auch weiterhin das aufrufende Formular Form1 nutzen, dieses zum Beispiel verschieben oder den Button Show nochmals klicken (jedoch nicht bei ShowModal).\
160	+	Sie könnten statt `<myForm>.Show;` auch `<myForm>.Visible:=True;` schreiben. Die Procedure Show macht nichts anderes:
161	+
162	+	``` pascal
163	+	procedure TCustomForm.Show;
164	+	begin
165	+	Visible := True;
166	+	BringToFront;
167	+	end;
168	+	```
169	+
170	+	Der einzigste Unterschied wäre, falls das Formular von einem anderen überdeckt würde, dieses weiter davor bleiben würde.\
171	+	\
172	+	ShowModal:\
173	+	Durch diese Methode wird die Codeverarbeitung des aufrufende Controls (bei uns Form1) unterbrochen und erst weiter abgearbeitet, wenn das neu geöffnete Formular wieder geschlossen wurde. In unserem Beispiel wird die Mitteilung (ShowMessage) erst ausgegeben, wenn das Formular Form2 wieder geschlossen wurde. Das aufrufende Formular Form1 ist wie eingefroren. Sie können es weder verschieben noch Buttons klicken.\
174	+	ShowModal ist eine Funktion und gibt als Ergebnis einen Integer zurück, siehe [[doc:lcl/forms/tmodalresult.html\|TModalResult]]. Damit können Sie, je nachdem, wie das Formular geschlossen wurde, unterschiedlichen weiteren Code ausführen lassen.\
175	+
176	+	## Zwei Formulare, die sich gegenseitig aufrufen können
177	+
178	+	Generell ist es günstig (gutes Programmdesign), wenn von einem Formular nicht dessen Hauptformular aufgerufen wird. Besser ist es, entsprechend vorherigem Beispiel, von einem Hauptformular aus, immer nachfolgende Formulare aufzurufen und durch das Schließen dieser, wieder zum Hauptformular zurückzukehren. Somit entgeht man dem Problem einer [zirkulären Unit - Referenz](http://de.wikipedia.org/wiki/Zirkul%C3%A4re_Abh%C3%A4ngigkeit). Dass es theoretisch trotzdem geht, sehen Sie hier.
179	+
180	+	Entweder Sie modifizieren die Formulare vom Beispiel [[Form Tutorial/de\|Verwendung eines zweiten Formulars]] oder Sie müssen ein neues Projekt erstellen, mit zwei Formulare und jeweils einem Button (Knopf). Caption von Form1.Button1 sollte Form2 öffnen lauten, die von Form2.Button1 müssten Sie nach Form1 öffnen umändern.
181	+
182	+	Diesmal können Sie nicht einfach in die vorhandene Uses-Clause von Unit2 (wie im vorherigen Beispiel - im Interfaceteil der [[Unit/de\|Unit]]) "Unit1" einfügen, da sonst eine zirkuläre Unit-Referenz entstehen würde. "Unit2" müssten Sie somit auch wieder aus der Interface-Uses-Klausel von Unit1 entfernen.
183	+
184	+	Statt dessen fügen Sie eine Uses-Klausel in den Implementation-Teilen der Units ein:
185	+
186	+	``` pascal
187	+	unit Unit1;
188	+	...
189	+	implementation
190	+
191	+	uses
192	+	Unit2;
193	+	...
194	+	```
195	+
196	+	``` pascal
197	+	unit Unit2;
198	+	...
199	+	implementation
200	+
201	+	uses
202	+	Unit1;
203	+	...
204	+	```
205	+
206	+	Jetzt ändern Sie noch die hinter den OnClick-Events der Buttons befindlichen Eventhandler zu:
207	+
208	+	``` pascal
209	+	unit Unit1;
210	+	...
211	+	procedure TForm1.Button1Click(Sender: TObject);
212	+	begin
213	+	Form2.Show; //Zeigt Form2
214	+	end;
215	+	```
216	+
217	+	``` pascal
218	+	unit Unit2;
219	+	...
220	+	procedure TForm2.Button1Click(Sender: TObject);
221	+	begin
222	+	Form1.Show; //Zeigt Form1
223	+	end;
224	+	```
225	+
226	+	## Übergabe von Variablen in andere Formulare
227	+
228	+	Entsprechend Beispiel [[Form Tutorial/de\|Verwendung eines zweiten Formulars]] könnte man im Interface-Teil der [[Unit/de\|Unit]] Unit2 eine [[Global variables\|globale Variable]] deklarieren. Damit hätte man Zugriff in der Unit1 und Unit2 auf ein und die selbe [[Variable]] (da in der Unit1 unter `uses` die Unit2 mit einbunden wurde, werden alle im Interface-Teil der Unit2 deklarierten Variablen auch in Unit1 nutzbar). Dieses Vorgehen sollten Sie aber auf ein Minimum beschränken, da man bei größeren Projekten schnell nicht mehr weiss, was die einzelnen Variablen für eine Bedeutung haben bzw. wo man überall darauf zugreift (Fehlerquote erhöht sich).
229	+
230	+	Besser ist es lokale Variablen zu nutzen, diese als [[Object Oriented Programming with Free Pascal and Lazarus\|Property]] in einer [[Class/de\|Klasse]] oder hilfsweise als Variable in einer Klasse zu definieren und auf diese zuzugreifen.\
231	+	\
232	+	Im nachfolgenden Projekt wird per Buttonklick ein zweites Formular geöffnet. Dabei wird in der Unit des Hauptformulars gezählt, wie oft dieses angezeigt wurde. In diesem zweiten Formular können Sie sich per Buttonklick zeigen lassen, wie oft es geöffnet wurde:
233	+
234	+	- erstellen Sie ein neues Projekt mit zwei Formularen, jeweils ein Button darauf und die Eventhandler zu deren OnClick-Events
235	+
236	+	- nun erstellen Sie im [[Class/de\|Public-Teil]] der [[Class/de\|Klasse]] TForm2 (Unit2) eine Variable (in diesem Fall eine [[Const/de\|Konstante]], die Sie als definierte Variable missbrauchen) vom Typ Integer mit dem Namen Zaehler:
237	+
238	+	``` pascal
239	+	unit Unit2;
240	+	...
241	+	TForm2 = class(TForm)
242	+	Button1: TButton;
243	+	procedure Button1Click(Sender: TObject);
244	+	private
245	+	{ private declarations }
246	+	public
247	+	{ public declarations }
248	+	const Zaehler: Integer = 0; //hier Zaehler definieren
249	+	end;
250	+	```
251	+
252	+	- jetzt müssen noch die Button-Eventhandler entsprechend anpassen:
253	+
254	+	``` pascal
255	+	unit Unit1;
256	+	...
257	+	procedure TForm1.Button1Click(Sender: TObject);
258	+	begin
259	+	inc(Form2.Zaehler); //Bei jedem Aufruf von Form2 den Zähler um 1 erhöhen
260	+	Form2.ShowModal; //Form2 anzeigen
261	+	end;
262	+	```
263	+
264	+	``` pascal
265	+	unit Unit2;
266	+	...
267	+	procedure TForm2.Button1Click(Sender: TObject);
268	+	begin
269	+	ShowMessage('Form2 wurde insgesamt '+IntToStr(Zaehler)+' mal aufgerufen');
270	+	end;
271	+	```
272	+
273	+	Auf diese Weise können Sie in Unit1 auf alle in Unit2 öffentlichen (public) Variablen/Properties/Funktionen/Proceduren (allgemein Methoden) zugreifen.
274	+
275	+	## Sonstiges im Umgang mit Formularen
276	+
277	+	### Anderes Formular als HauptFormular verwenden
278	+
279	+	Stellen Sie nach einer Weile fest, dass Sie lieber ein anderes oder ein neues Formular zur Ansicht beim Programmstart angezeigt haben wollen, können Sie, unter dem Mainmenu Projekt -\> Projekteinstellungen -\> Formulare, die Reihenfolge der Formulare ändern:
280	+
281	+	<figure>
282	+	<img src="Projekteinstellungen_Formulare.png" title="Projekteinstellungen_Formulare.png" />
283	+	<figcaption>Projekteinstellungen_Formulare.png</figcaption>
284	+	</figure>
285	+
286	+	Alternativ können Sie sich, unter Hauptmenu Projekt -\> .lpr-Datei anzeigen, die Projekt.lpr (Pascal-Quelltext des Hauptprogramms) anzeigen lassen und dort das zuerst anzuzeigende Formular als erstes erstellen lassen:
287	+
288	+	``` pascal
289	+	program Project1;
290	+	...
291	+	Application.CreateForm(TForm2, Form2); //Form2 wird als erstes erstellt und damit beim Start der Anwendung gezeigt
292	+	Application.CreateForm(TForm1, Form1);
293	+	```
294	+
295	+	### Eigenschaft eines Formulars bei Programmende speichern
296	+
297	+	Bei manchen Anwendungen ist es schön, wenn die vom User geänderte Einstellungen bezüglich Position und Größe des Formulars bei Programmende gespeichert werden und bei Programmstart wieder so hergestellt werden. Dafür stellt Ihnen Lazarus von Haus aus eine recht einfache Möglichkeit mittels [[TXMLPropStorage/de\|TXMLPropStorage]] oder [[TINIPropStorage/de\|TIniPropStorage]] zur Verfügung.
298	+
299	+	Ein einfaches Beispiel soll die Funktionsweise verdeutlichen:
300	+
301	+	- neue Anwendung erstellen (Hauptmenu Projekt -\> Neues Projekt -\> Anwendung)
302	+	- eine TXMLPropStorage Komponente auf das Formular ablegen (Zu finden ist sie auf dem Tab Misc in der Komponentenpalette)
303	+
304	+	<figure>
305	+	<img src="KomponentenpaletteTXMLPropStorage.png" title="KomponentenpaletteTXMLPropStorage.png" />
306	+	<figcaption>KomponentenpaletteTXMLPropStorage.png</figcaption>
307	+	</figure>
308	+
309	+	- im Objektinspektor: XMLPropStorage1 -\> FileName auf z.B. "session.xml" setzen
310	+	- im Objektinspektor: Form1 -\> SessionProperties bearbeiten (einfach den Button \[...\] anklicken)
311	+	- nun jeweils die Properties Left;Top;Width;Height von der Komponente Form1 auswählen und den Selected Properties hinzufügen
312	+	- mit OK bestätigen und Projekt starten, das Formular in der Größe verändern und verschieben, beim nächsten Start hat es wieder diese Einstellung
313	+
314	+	Weitere Informationen unter [[TXMLPropStorage/de\|TXMLPropStorage]]
315	+
316	+	## Formular dynamisch erzeugen
317	+
318	+	### Von Lazarus designtes Formular dynamisch erstellen
319	+
320	+	Sie müssen nicht alle Formulare, die während der Laufzeit einer Anwendung möglicherweise aufgerufen werden, immer bei Programmstart erstellen lassen. Manche Entwickler halten generell nichts davon und löschen den, bei Einfügen eines neuen Formulars in ein Projekt automatisch erstellten, Code aus der Projekt.lpr sofort heraus. Sobald Sie z.B. eine Library schreiben wollen, die ein paar GUIs enthält, kommen Sie um die dynamische Erstellung von Formularen nicht herum.
321	+
322	+	Ein Beispiel:
323	+
324	+	- erstellen Sie ein neue Anwendung mit zwei Formularen, fügen Form1 einen TButton hinzu und nehmen in die Uses-Klausel von Unit1, "Unit2" mit auf
325	+	- öffnen Sie die Projekt.lpr (Projekt -\> .lpr-Datei anzeigen)
326	+	- löschen Sie die Zeile " Application.CreateForm(TForm2, Form2);"
327	+	- im OnClick-Ereignis von Form1 Button1 müssten Sie folgenden Code einfügen:
328	+
329	+	``` pascal
330	+	procedure TForm1.Button1Click(Sender: TObject);
331	+	begin
332	+	Form2:=TForm2.Create(Nil); //Form2 wird erstellt
333	+	Form2.ShowModal; //Form2 wird angezeigt
334	+	FreeAndNil(Form2); //Form2 wieder freigeben
335	+	end;
336	+	```
337	+
338	+	- nun können Sie die Anwendung starten
339	+
340	+	### Neues Formular dynamisch erstellen
341	+
342	+	Folgendes Beispiel soll demonstrieren, wie neue Formulare per Hand, ohne den Formulardesigner, erzeugt werden können.
343	+
344	+	Mit einem Buttonklick soll sich ein weiteres Formular öffnen, das einen Button enthält, bei dessen Klick eine Warnmeldung erscheint, dass sich das Formular schließen wird und daraufhin das Formular geschlossen wird.
345	+
346	+	- erstellen Sie eine neue Anwendung mit einem Formular und einem Button
347	+	- im OnClick-Ereignis von Form1 Button1 müssen Sie folgenden Code einfügen:
348	+
349	+	``` pascal
350	+	procedure TForm1.Button1Click(Sender: TObject);
351	+	var
352	+	MyForm: TForm;
353	+	MyButton: TButton;
354	+	begin
355	+	MyForm:=TForm.Create(nil); // Formular erzeugen
356	+	MyForm.SetBounds(100, 100, 220, 150); // Größe des Formulars
357	+	MyForm.Caption:='Mein dynamisch erstelltes Formular';
358	+
359	+	MyButton:=TButton.create(MyForm); // Den Button erstellen, der Owner wird MyForm
360	+	MyButton.Caption:='Schließe meines Formulars';
361	+	MyButton.SetBounds(10, 10, 200, 30);
362	+	MyButton.Parent:=MyForm; // Festlegen, auf welchem Formular der Button platziert wird
363	+
364	+	MyButton.OnClick:=@MyButtonClick; // Wird gleich noch erstellt...
365	+
366	+	MyForm.ShowModal; // MyForm anzeigen
367	+
368	+	FreeAndNil(MyForm); // MyForm (und MyButton) wieder freigeben
369	+	end;
370	+	```
371	+
372	+	> Note: Wenn eine Komponente mit einem Owner erzeugt wurde (TButton.Create(Owner: TComponent)), gehört sie dem Owner, der dann dafür zuständig ist,\
373	+	> die Komponente freizugeben. Somit wird MyButton bei der Freigabe von MyForm automatisch mit freigegeben.
374	+
375	+	- jetzt müssen Sie noch der Eventhandler von MyButtonClick erstellen
376	+	- dazu im private-Abschnitt der Klasse TForm1 folgende Procedure hineinschreiben und \[Strg\]+\[Shift\]+\[C\] (Codevervollständigung) drücken:
377	+
378	+	``` pascal
379	+	TForm1 = class(TForm)
380	+	...
381	+	private
382	+	{ private declarations }
383	+	procedure MyButtonClick(Sender: TObject);
384	+	```
385	+
386	+	- und folgenden Code dort einfügen:
387	+
388	+	``` pascal
389	+	procedure TForm1.MyButtonClick(Sender: TObject);
390	+	begin
391	+	Showmessage('Achtung, mein dynamisch erstelltes Formular wird geschlossen!');
392	+	if Sender is TButton then
393	+	TForm(TButton(Sender).Parent).Close;
394	+	end;
395	+	```
396	+
397	+	- nun können Sie das Projekt kompilieren und starten
398	+
399	+	Ein paar Tipps für die [[LCL Tips/de\|manuelle Erzeugung von Bedienelementen]]
400	+
401	+	## Weitere Informationen
402	+
403	+	- [[LCL Tips/de\|Beispiel, wie Sie eine komplette GUI Anwendung per Code erstellen können]]
404	+	- [[Testing, if form exists/de\|Testen, ob ein Formular existiert]]
405	+	- [[Canvas draw vertical line on form/de\|Eine vertikale Line auf einem Formular zeichnen]]
406	+	- [[Drawing with canvas/de\|Mit Canvas auf einem Formular zeichnen]]
407	+	- [[user should not be able to close form/de\|Verhindern, dass ein Anwender das Formular schliessen kann]]
408	+	- [[LCL Tips/de\|Ein nicht-rechteckiges Fenster oder Steuerelement erstellen]]
409	+
410	+	---
411	+	From the Free Pascal wiki, page "Form Tutorial/de", as it stood on 2020-02-15 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