Informaticasite van het Lauwers College te Buitenpost © R.J. van der Beek

Menu
Delphi Hoofdstuk 1
H2
H3
H4
H5
H6
H7
H8
H9 Overzicht en Opgaven

Delphi Hoofdstuk 1. De start

1.1. De namen van een aantal begrippen.

Delphi is een object-georiënteerde programmeertaal, die ontstaan is uit de programmeertaal Pascal.
Met objecten worden dan bedoeld: (onder anderen) alle onderdelen die op het scherm te zien zijn.
Zo kan bijv. een OK-knop als een object worden opgevat, of bijv. een tekstvenstertje waar je iets in kunt vullen.
En die objecten hebben bepaalde eigenschappen en methoden.
Het heeft een bepaalde kleur (dat is een eigenschap), en misschien kun je er wel in typen of tekenen (dat is een methode)

We gebruiken in deze cursus (Portable) Turbo Delphi Lite, dat is een gratis versie van Delphi.

Als je een programma wilt maken met Delphi, dan gaat dat heel anders dan je gewend bent bij bijv. PASCAL.
(We gaan er bij het bespreken van Delphi van uit dat je de cursus Pascal van deze site hebt doorgewerkt)

Je maakt zo'n programma in drie stappen:

Je "tekent" eerst de objecten, die je in het programma nodig hebt, in het formulier (het venster waarin je programma draait, noem je een formulier).
De eigenschappen van die objecten geef je aan in het "properties-venster, bijv. welke kleur het heeft, welk lettertype er in gebruikt wordt, enz.
Wat er gebeurt als je op een object met de muis klikt, enz. ga je programmeren.

Je begint in Delphi dus niet met het programmeerwerk, je begint aan te geven hoe het scherm er uit moet zien: "je ontwerpt eerst de interface".

Als voorbeeld nemen we een programma, waar in het begin het volgende op het scherm staat:

Je moet in de eerste twee witte hokjes twee getallen in kunnen vullen, en als je dan op de knop met "Reken uit!" klikt dan moet de som, het verschil, het product en het quotient van die twee getallen in de vier hokjes eronder komen.

Je hebt hier drie soorten objecten: 6 labels (links), 1 knop (= command-button) met "Reken uit!" erop en 6 edit-boxen (rechts)
Deze objecten worden ook wel besturingselementen genoemd.

Een label is een hokje waarin een vaste tekst staat. Die tekst wordt (meestal) niet veranderd als het programma loopt.
Een knop of command-button is ook een hokje met een tekst, en het is de bedoeling dat er op die knop geklikt wordt met de muis, en dan moet er iets gebeuren.
Een edit-box (of tekstvenster) is een hokje, waarin (meestal) iets getypt kan worden als het programma loopt, of waarin een tekst verschijnt die tijdens de werking van het programma kan veranderen.

We gaan nu bespreken hoe je zo'n programma maakt.

Start Delphi. Klik op File, en dan op New (dat betekent: ik wil met een nieuw programma beginnen).
In het venster dat dan verschijnt klik je op VCL Forms Application

Je ziet dan in het midden een leeg "formulier", waar je van alles op kunt tekenen.
(bij jou kan het op een andere plaats zitten, je kunt de vensters verschuiven)

Rechtsonder zie je de "toolbox" (Tool palette), waarin allemaal hulpmiddelen om "objecten" te kunnen tekenen.
Linksonder het "properties-venster" (Object Inspector), waarin je de eigenschappen van de objecten in kunt vullen: kleur, lettertype, wat er op het object staat, enz.
Rechtsboven het "project-venster", waarin alle onderdelen van het project (dat is het programma) staan, en waarin je aan kunt geven wat er precies op het scherm moet staan.
Als één van de vensters ontbreekt op het scherm, dan klik je op View, en dan kun je aangeven welke vensters in beeld moeten komen.

1.2. De labels plaatsen

We beginnen nu de dingen, die we op het formulier willen hebben, er in te tekenen.
Allereerst het label waarop "Getal 1" staat. Dat doe je op de volgende manier:

Klik in de toolbox op het pictogram voor een label (zie hiernaast), er staat TLabel bij (bij vrijwel elk object begint de naam met een T, dat is de T van Turbo omdat we met Turbo Delphi werken)

Als je met een andere versie van Delphi werkt dan zien de icoontjes in de toolbox er misschien anders uit (zie links). Dan is het icoontje voor een label de hoofdletter A.

Klik dan op het formulier op de plaats waar de linker-bovenhoek van het label moet komen, en sleep de muis naar de plaats waar de rechter-benedenhoek moet komen.
Zodra je de muisknop loslaat zie je het label verschijnen.
Als je er naast klikt ligt het label voorlopig vast.

Maar je kunt het daarna nog heel gemakkelijk veranderen.
Als je ergens midden in het label klikt dan kun je het label in zijn geheel verplaatsen.
Als je de muisaanwijzer op de blokjes bij het midden van de rand of op de hoek zet (dat noem je de formaatgrepen), dan kun je die rand of hoek verslepen, en zo het label groter of kleiner maken.
Op dezelfde manier kun je het formulier zelf ook groter of kleiner maken.

Als het op de juiste plaats staat dan gaan we daarna het opschrift van het label bepalen.
Klik eerst nog eens in het label, zodat het "geselecteerd" is.
Dan zie je bovenaan in het properties-venster "Label1 TLabel" staan.
Het eerste label wordt altijd "label1" genoemd, het tweede label "label2" enz.
Dat zijn de namen van de labels.
Die namen kun je trouwens veranderen, maar daarover hebben we het in hoofdstuk 2

Klik op Caption (dat is het engelse woord voor: opschrift), en klik dan in het invulvakje rechts ervan, dan kun je daar het opschrift in vullen, dat is Getal 1
Zodra je het hebt ingetypt en op enter hebt gedrukt zie je dat het opschrift in het formulier ook werkelijk Getal 1 wordt.
Klik dan op Autosize, en klik daarna rechts op het pijltje dat achter True staat. Dan kun je kiezen uit True en False. Klik op False. Dan kun je de grootte van het label zelf bepalen, en anders wordt de groote automatisch bepald door de grootte van het opschrift.
Klik dan op Color, en klik daarna rechts op het pijltje dat achter de kleur staat. Dan kun je uit een heleboel achtergrondkleuren kiezen.
Kies de achtergrondkleur uit, die je leuk vindt.
Klik op Forecolor, en kies op dezelfde manier als hierboven de kleur van de tekst uit.
Klik dan op Font, en klik dan rechts daarvan op de drie puntjes.
Er verschijnt een venster, waarin je het lettertype en de grootte uit kunt kiezen.
Kies als grootte 16, en kies als lettertype Arial.
Je kunt in dit venster ook de kleur van de letters bepalen, kies een kleur uit en klik dan op OK.
Klik dan op Alignment, en klik rechts daarvan op het pijltje.
Je kunt dun uitkiezen uit taLeftJustify, taRightJustify en taCenter.
Kies voor taCenter, dan wordt de tekst in het midden van het label geplaatst.

Steeds als je in het properties-venster iets uitkiest zie je dat het ontwerp-formulier ook direkt wordt aangepast.

Zo, nu is het eerste label klaar. Nu kun je het tweede label op dezelfde manier maken, maar het begin kan ook een beetje anders.

Klik in de toolbox op het pictogram voor een label.
Dubbelklik dan ergens in het formulier. Dan verschijnt er een label in het midden van het formulier, en dan kun je het naar de juiste plaats slepen, en ook de juiste afmetingen geven.

Ga daarna het opschrift (dat is -Getal 2-), de kleuren enz. in het properties-venster uitkiezen.
Zorg er wel voor dat je eerst het tweede label hebt geselecteerd door er op te klikken, je ziet dat dan boven in het properties-venster "Label2 TLabel" staat.
Klik op "Caption" en vul als opschrift "Getal 2" in. Kies dan de kleuren enz. uit.

Als dit tweede label klaar is maken we het derde.
Dat doen we op nog weer een andere manier.

Selecteer het eerste label door er op te klikken.
Klik dan in het menu op Edit, en klik op Copy (je kunt ook Ctrl/C intypen, dat gaat sneller).
Dan wordt het geselecteerde label naar het "klembord" gekopieerd, dat is een speciaal stukje van het geheugen.
Klik dan weer in het menu op Edit, en klik op Paste (of gebruik de sneltoets Ctrl/V).
Dan verschijnt er een kopie van het eerste label half over het eerste label heen.
Sleep dat label naar beneden, naar de juiste plaats. Als het geselecteerd is dan zie je boven in het properties-venster "Label3 TLabel" staan, en dan kun je weer de eigenschappen van het label bepalen.
De kleuren enz. hoef je niet meer uit te kiezen, die zijn net zo als die van het eerste label.
Zorg er wel voor dat het opschrift "Som" wordt.

Maak daarna op dezelfde manier nog drie labels, met de opschriften "verschil", "product" en "quotiënt".

1.3. Een knop en edit-boxen plaatsen; het formulier aanpassen

Klik nu in de toolbox op het pictogram met een rechthoekje waarin OK staat (er staat TButton bij), dat wordt een knop of command-button genoemd.

Plaats nu een button in het formulier onder het label met Getal2, en zorg er voor dat het opschrift (dus Caption) "Reken uit! " wordt.
Kies een geschikt lettertype uit.

Nu moeten er nog zes tekstvenstertjes (edit-boxen) komen.

Klik in de toolbox op het rechthoekje met het potloodje (er staat TEdit bij), dat is een edit-box.
Zorg er nu voor dat er in het formulier een edit-box naast het label met het opschrift "Getal1" komt.

Als die er staat kun je weer de eigenschappen (=properties) instellen. Kies een geschikt lettertype uit, en zorg er voor dat er een rand om het tekstvenster zit. Dat doe je door BorderStyle in het properties-venster uit te kiezen, en dan moet je voor bsSingle kiezen (als je voor bsNone kiest zit geen rand om de edit-box)
In de properties-list vind je geen Caption, want zo'n textbox heeft geen vast opschrift.
Wel heb je een eigenschap Text; daar staat de tekst die in het vakje staat als het programma gestart wordt. Dan moet er niets in staan, dus klik op het woord Text in het properties-venster, klik in het invulvak er naast, en verwijder wat daar staat.

Klik op Maxlength, en zet daar 5 neer. Dat heeft dan tot gevolg dat, als het programma loopt, er maar 5 tekens in getypt kunnen worden. Meer is niet nodig, want dan zou het getal veel te groot worden.

Dan is de eerste edit-box klaar. Er moeten nog 5 worden geplaatst. Je hebt nu vast wel in de gaten hoe je dat op de handigste manier kunt doen.

We hebben nu verschillende objecten op het formulier geplaatst, en de eigenschappen van die objecten vastgelegd. Maar je kunt ook de eigenschappen van het formulier zelf aanpassen.

Klik op een leeg gedeelte van het formulier, dan kun je de eigenschappen (=properties) van het formulier instellen.
In het bovenste venstertje van de object-inspector zie je Form1 staan, dat betekent dat je de properties van Form1 kunt aanpassen.
Klik op Caption, en vul daar in: "Het eerste programma". Dat verschijnt dan in de titelbalk van het formulier!
En klik op Color, en kies een geschikte kleur uit. Dat wordt dan de achtergrondkleur van het formulier.

1.4. Het programma laten lopen

Nu is de "interface" klaar.

Je kunt het programma nu ook al "runnen", al gebeurt er dan nog niet helemaal wat de bedoeling is.

Klik in het menu op Run, en klik dan op Run (het gaat sneller door op F9 te drukken, of in de werkbalk op het groene driehoekje).
Dan zie je een nieuw venster, dat er bijna net zo uit ziet als het ontwerpvenster.
Maar je kunt het ontwerp nu niet veranderen. Probeer een label nu maar eens te verplaatsen, of te vergroten. Dat lukt je niet.

Je kunt wel getallen in de tekstvenstertjes invullen. Doe dat maar.
Vul bijv. 14 in het eerste venster, en 23 in het tweede. En klik dan op "Reken uit!".
Er gebeurt niets. En dat is logisch, want dat moeten we nog programmeren, dus intypen.

Maar eerst nog even iets anders. Probeer ook een getal in het derde tekstvenster te typen.
Dat kan ook zonder problemen. Maar eigenlijk is dat niet de bedoeling.
Het is de bedoeling dat in dat venstertje de som van de bovenste getallen verschijnt, en verder niet.

Klik op de sluitknop. Dan stopt het programma. En het ontwerpscherm komt weer te voorschijn.

Klik op het derde tekstvenster, naast "Som". Als het goed is staat in het propertiesvenster bovenaan dan "Edit3 TEdit"
Klik nu op Enabled. En klik op het pijltje rechts ervan. Je kunt dan kiezen uit True en False.
Klik op False.

Klik in de menuregel, bovenaan, nu weer op Run, en Start. Dan start het programma weer.
Probeer nu weer een getal in het derde tekstvenster te typen: het lukt niet !
Dat komt dus doordat je bij Enabled: False hebt gezet!.

1.5. Programmaregels intypen.

We hebben helemaal nog geen programmaregels ingetypt, alleen nog maar getekend, en eigenschappen vastgelegd. Daarom werkt het programma ook nog niet goed.
Daarom gaan we nu bespreken hoe je programmaregels in kunt typen.

Dubbelklik op de knop met "Reken uit!".
Dan verschijnt er een venster, waarin je programmaregels (dat noem je ook wel code) kunt typen.

Bovenin staat in het venster: procedure TForm1.Button1Click(Sender: TObject);
Het voornaamste hierin is Button1Click, dat betekent dat je in dit venster kunt intypen wat er moet gebeuren als je op de knop met de naam Button1 klikt.
In die bovenste regel staat dus dat het een procedure is, die uitgevoerd moet worden als er op Button nr. 1 geklikt wordt.

De code moeten we tussen begin en end; typen, en de variabelen moeten we declareren op de regel voor begin.

Als we de code moeten bedenken dan moeten we bedenken wat er precies moet gebeuren.
Je moet de variabelen op de eerste regel onder de kop declareren. Daarover straks, eerst de rest maar.

Het eerste getal moet worden ingevoerd in de edit-box met de naam Edit1
De inhoud daarvan wordt aangegeven met Edit1.text
De inhoud van de tweede edit-box wordt aangegeven met Edit2.text
Dus eerst de naam van het object, en dan de eigenschap die hoort bij dat object, en gescheiden door een punt.

Als je het getal uit de eerste edit-box in geheugenplaats g1 wilt bewaren, dan is de opdracht daarvoor:
g1 := StrToInt(Edit1.text);
StrToInt is een zogenaamde methode, die een string omzet in een integer (dus een geheel getal).
De inhoud van Edit1.text is een tekst, dus een string. En g1 moet een getal worden, dat moet dus de getalswaarde van die string zijn, vandaar dat er StrToInt voor Edit1.text staat.
Als je het getal, dat in de tweede editbox is ingevoerd, in de variabele g2 wilt zetten, dan wordt de opdracht daarvoor natuurlijk: g2 := StrToInt(Edit2.text);
Vervolgens krijg je de volgende opdrachten, die je waarschijnlijk wel begrijpt:
s := g1 + g2;
v := g1 - g2;
p := g1 * g2;
q := g1 / g2;
Dan moet er voor gezorgd worden dat de waarde van s in de derde editbox wordt geplaatst.
Dan moet het getal s eerst weer worden omgezet in een string, en daarvoor dient de methode IntToStr
De opdracht om de waarde van s in de derde editbox te plaatsen is: Edit3.text := IntToStr(s);
Verder krijg je natuurlijk nog: Edit4.text := IntToStr(v); en Edit5.text := IntToStr(p);
Het antwoord van de deling q := g1 / g2; is waarschijnlijk geen geheel getal, maar een kommagetal.
Daarom bij q geen IntToStr, maar FloatToStr, dus Edit5.text := IntToStr(p);
Meestal worden de opdrachten onder elkaar gezet, met een punt-komma achteraan.
Ze mogen ook wel achterelkaar (op één regel) getypt worden, als elke opdracht maar wordt afgesloten met een punt-komma.
De laatste opdracht kunnen we trouwens beter nog wat veranderen.
Want als g2 gelijk aan 0 is, dan zul je een foutmelding krijgen, omdat delen door 0 niet kan.

I.p.v. q := g1 / g2kunnen we beter typen: If (g2<>0) then q := g1/g2;
En Edit6.text = Str(q) vervangen we door:
If (g2<>0) then Edit6.text := IntToStr(q) else Edit6.text = "kan niet"

Dat heeft tot gevolg dat als g2 gelijk is aan 0 er geen foutmelding komt, maar dat er in het zesde tekstveld "kan niet!" verschijnt.
Dan moeten we de variabelen nog declareren.
Alleen q wordt een kommagetal (dat is in Pascal en ook in Delphi: real) en de rest kunnen gehele getallen zijn (integers).

Je declareert de variabelen net zo als in Pascal, dus:
VAR g1, g2, s, v, p : integer;
q : real;
Deze regels komen voor begin.

De totale procedure wordt dan als volgt, en zó typ je het in:

procedure TForm1.Button1Click(Sender: TObject);

   var g1,g2, s, v, p: integer;
       q: real;

   begin
   g1 := StrToInt(Edit1.text);
   g2 := StrToInt(Edit2.text);
   s := g1 + g2;
   v := g1 - g2; 
   p := g1 * g2; 
   if (g2<>0) then q := g1 / g2;
   Edit3.text := IntToStr(s);
   Edit4.text := IntToStr(v);
   Edit5.text := IntToStr(p);
   If (g2<>0) then 
      Edit6.text := FloatToStr(q) 
   else 
      Edit6.text := 'kan niet!';
   end;

Onder de laatste regel van de procedure (end;) staat nog eens end.
Dat is omdat een deplphi-programma altijd wordt afgesloten met end.
Dat hoeft en mag maar één keer in het programma voorkomen, alleen na de laatste procedure. We hebben nu nog maar één procedure, en dat is dan natuurlijk tegelijk de laatste.

De programmaregels in deze procedure noem je de eventhandler van de bereken-knop. Eventhandler is het engelse woord voor gebeurtenisafhandeling.
Deze programmaregels moeten worden uitgevoerd als er iets gebeurt, namelijk als er op de bereken-knop wordt geklikt.

1.6. Het programma opslaan.

Als je dit alles hebt ingetypt, dan klik je op de sluitknop van het edit-venster.
En dan is het verstandig om het programma eerst op de harde schijf op te slaan.
Dat doe je als volgt:

Klik op File (boven in de menubalk), en klik op Save Project as

Dan moet je eerst een map uitkiezen. Het is verstandig voor elk project een aparte map te maken.

Geef als naam van het project: Les1
Klik dan op OK.

Klik dan ook nog op: Save As ...
Dan wordt de programmacode (dat wordt een unit genoemd) apart opgeslagen. Dat bestand mag niet dezelfde naam hebben als het project, laat de naam unit1 (die standaard wordt gegeven) maar staan.
Dat bestand krijgt de extensie pas, dus het wordt opgeslagen onder de naam unit1.pas. Het formulier wordt dan onder de naam opgeslagen.

Het project krijgt automatisch de extensie bdsproj of bdr, en als je het programma laat lopen (Run, zie volgende alinea), dan wordt het programma gecompileerd en het gecompileerde programma wordt onder de naam Les1.exe opgeslagen, tenminste als je het project Les1 hebt genoemd.
Je kunt het programma dan ook starten door in de verkenner op Les1.exe te dubbelklikken, dan heb je Delphi niet beslist nodig.

Als je het programma wilt laten lopen dan moet je op het groene driehoekje in de werkbalk klikken, of op Run, en dan op Start klikken.
Als er fouten in het programma zitten, dan worden die aangegeven, en dan zul je die eerst moeten verbeteren.

Als het programma is gestart tik je getallen in de bovenste twee tekstvenstertjes en dan klik je op de knop "Reken uit!". Als je het goed hebt gedaan verschijnen de uitkomsten in de venstertjes er onder.

Er zit direkt een herhaling in. Als je de getallen gaat veranderen, en je klikt weer op "Reken uit!", dan krijg je de nieuwe uitkomsten. En dat kun je zo vaak doen als je zelf wilt.

Er kan nog wel iets mis gaan: als je een letter invoert in plaats van een getal, of je voert helemaal niets in, dan komt er een foutmelding op het scherm. Hoe je dat kunt voorkomen wordt besproken in hoofdtuk 4 van Delphi

Het programma stopt pas als je op de sluitknop klikt.
Kijk ook eens wat er gebeurt als je in het tweede venstertje 0 invult. Gaat het goed ?

1.7 Reageren op Change. Objecten verwijderen.

We nemen aan dat je het programma hebt bewaard, en dat je Delphi hebt afgesloten.
Als je Delphi dan opnieuw opstart, dan klik je op File, en dan op Open Project.
Dan moet je eerst de juiste map uitkiezen, en als je dat gedaan hebt dan kun je het project, dus het programma uitkiezen. Laat het programma "Les1" zo opnieuw inlezen.

Misschien zie je dan niet direkt het ontwerpvenster. Waarschijnlijk zie je in ieder geval wel het project-venster. (als dat er ook niet staat dan moet je op Window klikken, en dan het Project-venster openen).

Als je dan klikt op het bestand met de extensie dfm, dan verschijnt het ontwerp-formulier.
Als je klikt op het bestand met de extensie pas, dan verschijnt het programma-venster.
Dat laatste kun je ook krijgen door op een object te dubbelklikken.

Dubbelklik maar eens op de knop "Reken uit!". Dan verschijnt de event-handler voor de bereken-knop.
Die gaan we kopiëren naar een andere plaats.
Je moet de regels dan eerst selecteren, zonder de kopregel. Druk dan op Ctrl/C , of klik op Bewerken en dan Kopiëren.

Dubbelklik dan op de tweede edit-box. Dan verschijnt er een programmavenster voor edit-box2.
Op de eerste regel staat procedure TForm1.Edit2Change(Sender: TObject);

Dan kun je de code voor de procedure invoeren, die aangeeft wat er moet gebeuren als je iets aan de tweede edit-box verandert.

Zet de cursor op de regel onder de kopregel, en druk dan op Ctrl/V, of klik op Bewerken en dan op Plakken.
Dan verschijnen de programmaregels, die je voor de Bereken-button had ingetypt, ook hier.
Verwijder de regels aan het eind met begin en end; , want die staan er nu dubbel in.

Laat het programma nu weer lopen.

Zodra je nu iets in edit-box2 typt (dus iets verandert aan die edit-box), dan komen de uitkomsten van de sommen er onder.
Als je bijv. in de eerste 5 intypt, en in de tweede 13, dan verschijnen de uitkomsten al zodra je de 1 van 13 hebt ingetypt. En als je de 3 intikt van 13 dan verschijnen de nieuwe uitkomsten !

Je hebt de knop, waar "Reken uit!" op staat nu helemaal niet meer nodig. Die kun je dus wel verwijderen.

Stop het programma door op de sluitknop te klikken. Klik dan op het tabblad Design, rechts onder het codevenster. Dan krijg je het ontwerpvenster weer in beeld.
Klik op de knop met "Reken uit!", en druk op Delete. En de knop is weg !

1.8 Reageren op Keypress, de interface in de programmacode.

De uitkomsten worden nu ingevuld zodra je iets typt in het tweede hokje.

Het zou eigenlijk mooier zijn als dat pas gebeurde als je iets hebt ingetypt, en je drukt op de entertoets. Dat kan ook, en wel m.b.v.Keypress.

Klik op de edit-box2, en ga naar de Object Inspector met de properties. Klik (bovenaan) op het tabblad Events, dan kun je uit verschillende events kiezen. Klik op OnKeyPress, en klik op het pijltje er achter. Daar staat nog niets. Vul daar in: Edit2KeyPress, en druk op enter.
Dan springt de cursor naar het programmavenster, en daar staat de kop van een nieuwe procedure:
procedure TForm1.Edit2Keypress(Sender: TObject; var Key: Char);
Deze procedure wordt uitgevoerd zodra er op een toets wordt gedrukt in het Edit2-tekstvenster.
Maar je kunt er dan voor zorgen dat er verschillende dingen gebeuren, afhankelijk van de ingedrukte toets. Want er kan gebruik gemaakt worden van de variabele Key, en die variabele bevat de code van de ingedrukte toets.

Kopieer de programmaregels, die onder de kop TForm1.Edit2Change(Sender: TObject); staan naar de nieuwe procedure.
Maar daar moet je nog iets aan toevoegen:

Onder de declaratieregels typ je het volgende: If (Key = chr(13)) Then begin
en onder de laatste regel typ je: End;

If (Key = chr(13)) betekent: Als de ASC-code van de toets 13 is dan ......
en de ASC-code van de entertoets is 13 !
De totale procedure wordt dan als volgt:

procedure TForm1.Edit2Keypress(Sender: TObject; var Key: Char);

var g1,g2, s, v, p: integer;
   q: real;

begin
if (Key=chr(13)) then
begin
   g1 := StrToInt(Edit1.text);
   g2 := StrToInt(Edit2.text);
   s := g1 + g2;
   v := g1 - g2; 
   p := g1 * g2; 
   if (g2<>0) then q := g1 / g2;
   Edit3.text := IntToStr(s);
   Edit4.text := IntToStr(v);
   Edit5.text := IntToStr(p);
   If (g2<>0) then 
      Edit6.text := FloatToStr(q) 
   else 
      Edit6.text := 'kan niet!';
   end;
end;

De procedure met de kop TForm1.Edit2Change(Sender: TObject); moet je dan nog wel even verwijderen.
En dan moet je nog iets verwijderen:
Als je knoppen enz. toevoegt aan het formulier dan wordt dat automatisch ook in de programmacode vastgelegd.
Als je de eerste regels van het programmavenster bekijkt dan zie je daar o.a. het volgende:

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, 
  Forms, Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
  Label1: TLabel;
  Label2: TLabel;
  Label3: TLabel;
  Label4: TLabel;
  Label5: TLabel;
  Label6: TLabel;
  Edit1: TEdit;
  Edit2: TEdit;
  Edit3: TEdit;
  Edit4: TEdit;
  Edit5: TEdit;
  Edit6: TEdit;
  Button1: TButton;
  procedure Button1Click(Sender: TObject);
  procedure Edit2Change(Sender: TObject);
  procedure Edit2Keypress(Sender: TObject; var Key: Char);

Daar zit ook een regel bij met: procedure Edit2Change(Sender: TObject);
Als je die procedure weghaalt dan moet je deze regel ook verwijderen!

Sla het gewijzigde programma op en probeer het uit. Als het goed is worden de uitkomsten nu getoond als je een getal in het tweede tekstvenstertje hebt ingevoerd en op enter hebt gedrukt!

Opgaven

Opgaven.
Maak nu opgave 1 van de oefenopgaven van delphi