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

Delphi Hoofdstuk 9: Overzicht

  9.1. Variabelen en constanten

Als je een bepaalde variabele gebruikt moet je die eerst declareren, en ook als je een constante gebruikt moet je die declareren.
Bijvoorbeeld:
var x, y: integer;
      naam: string;

const aantal_ploegen = 32;
      wk-land: 'Zuid-Afrika';

Als je de variabelen declareert in de eerste regels van een procedure dan zijn het lokale variabelen. Die houden hun waarden alleeen vast tijdens de procedure. Is de procedure afgelopen dan is de variabele er ook niet meer.
Als je de variabelen declareert boven Implementation, onder de declaratie van het formulier, dan zijn het globale variabelen. Die houden hun waarde vast in het formulier waarin ze gedeclareerd worden.

Je hebt ook ingebouwde constanten, bijv. pi, clRed, enz

Typen van variabelen:

byte 8-bit integers: 0 t/m 255
shortint 16-bit integers: -32768 t/m 32767
integer 32-bit integers: -2147483648 t/m 2147483647
single 32-bit floating-point getal, 7 significante cijfers
double 64-bit floating-point getal, 15 significante cijfers
char één teken (1 byte)
widechar één teken, een unicode-teken (2 bytes)
shortstring String van maximaal 255 tekens
string String, het aantal tekens is onbeperkt
string String van maximaal 63000 karakters
boolean true of false
date datum
arraybijvoorbeeld: array: woord[1..100] of string

Numerieke operatoren:

+ optellen (getallen) of aan elkaar plakken (strings)
- aftrekken
* vermenigvuldigen
/ delen, bijv. 9 / 4 = 2.25
divdelen van gehelen (het aantal helen van de deling), bijv. 9 div 4 = 2
mod de rest bij een deling van gehele getallen, bijv. 9 mod 4 = 1

Conversie:

StrToIntconversie van een getallenstring naar een getal van het type integer
StrToFloatconversie van een getallenstring naar een getal van het type float
IntToStrconversie van een integer naar een string
FloatToStrconversie van een getal van het type float naar een string
Formatconversie van getal naar string, waarbij je zelf kunt bepalen hoe het wordt afgedrukt
 Voorbeelden: als g = -258.34891 dan wordt afgedrukt:
Format('%d', g); -258 (d van decimal)
Format('%f', g); -258.35 (f van fixed)
Format('%g', g); -258.34891 (g van general)
Format('%e', g); -2.5834891E+002 (e van exponent (=scientific)
Format('%d', u); 258 (u van unsigned decimal)
Format('%d', g); -258 (d van decimal)
Format('%x', h); 8C (als h=140         x van hexadecimal)

  9.2 Het formulier

In een project kun je met verschillende formulieren werken.
Als je in het menu van Delphi klikt op Project en dan op Options, dan kun je onder MainForm opgeven met welk formulier er gestart wordt.
Standaard is dat Form1.

Als je wilt dat er bepaalde opdrachten worden uitgevoerd zodra het formulier wordt gestart dan moet je die in de procedure procedure TForm1.FormActivate(Sender: TObject); zetten.

De belangrijkste methoden van een formulier (neem aan dat de naam van het formulier Form1 is) zijn:

Form1.ShowModal Het formulier wordt getoond, andere formulieren worden geblokkeerd totdat dit formulier wordt gesloten
Form1:=TForm.Create(Self);laad het formulier in het geheugen, het wordt nog niet getoond
Form1.Close;Het formulier wordt verwijderd van het scherm. Het blijft wel in het werkgeheugen staan
Form1.Free;Het formulier wordt verwijderd uit het werkgeheugen
Form1.Caption := 'Test';In de titelbalk van het formulier verschijnt Test
Form1.Left := (Screen.Width - Form1.Width) div 2;Het formulier verschijnt (horizontaal) in het midden
Form1.Top := (Screen.Height - Form1.Height) div 2; Het formulier verschijnt (vertikaal) in het midden

  9.3 Editbox

In een editbox kan tekst worden getypt. Er kan maar één regel tekst worden ingevoerd van maximaal 32766 tekens; wil je meer regels dan moet je voor een memobox kiezen.

De belangrijkste methoden van een editbox (neem aan dat de naam van de editbox Edit1 is) zijn:

Edit1.Text := "test" Het woordje Test verschijnt in de editbox
Edit1.Text := IntToStr(g);Als g een variabele is voor een getal dan wordt dat getal in de editbox getoond.
Edit1.Text := '';De editbox wordt leeg gemaakt
t := Edit1.Text;De string-variabele t krijgt de inhoud van de editbox
g := StrToInt(Edit1.Text);De getal-variabele g krijgt de getalswaarde van de inhoud van de editbox
Edit1.Enabled := False;De gebruiker kan niets aan de tekst in de editbox veranderen
Edit1.Visible := False;De editbox wordt onzichtbaar, verdwijnt dus
Edit1.Font.Name := 'Arial';Het lettertype van de editbox wordt Arial
Edit1.Font.Size := 12;De grootte van het lettertype wordt 12 punten
Edit1.Font.Style := Edit1.Font.Style+[fsBold];De tekens worden vet
Edit1.Font.Color := clBlack;De kleur van de letters wordt zwart
Edit1.Color := clYellow;De achtergrondkleur wordt geel
Edit1.Setfocus;De cursor wordt in de editbox gezet. Kan niet als Enabled op False staat, en kan ook niet in de Form_load-procedure worden gezet.

De focus kun je ook op een andere manier aan een object geven.
De volgende opdracht zorgt er voor dat het volgende object de focus krijgt:
self.SelectNext(TCustomEdit(Sender), true, true) ;

M.b.v. de volgende opdracht kun je er voor zorgen dat het volgende object de focus krijgt als je op de entertoets drukt:
If Key = #13 Then Begin begin
      SelectNext(Sender as TWinControl,True,True);
      Key := #0;
end;

  9.4 Label

Een label is een venster met een (vast) opschrift.

Een paar methoden van een label (neem aan dat de naam ervan Label1 is) zijn:

Label1.Caption := 'Test';Het opschrift van het label wordt Test
Label1.Alignment := "Tacenter"Het opschrift van het label wordt gecentreerd
Label1.autosize:=false;Het formaat van het label wordt niet automatisch aangepast aan de grootte van het opschrift

Verder heb je ook de eigenschappen Visible, Font.Name, Font.Size, Font.Color, Color enz. Zie daarvoor bij de eigenschappen van een editbox

  9.5 Button (of knop of commandbutton)

Een button is een knop waarop geklikt kan worden om er voor te zorgen dat een opdracht wordt uitgevoerd.
De kleur van zo'n knop is altijd grijs.

Een paar methoden van een button (neem aan dat de naam ervan Button1 is) zijn:

Button1.Caption := 'Test';Het opschrift van de knop wordt Test
Button1.Setfocus;De knop krijgt de focus, als je op enter drukt wordt de bijbehorende opdracht uitgevoerd

Verder heb je ook de eigenschappen Visible, Font.Name, Font.Size, Font.Color enz. Zie daarvoor bij de eigenschappen van een editbox

  9.6 Imagebox en picturebox

Een imagebox is een venster waarin een plaatje getoond kan worden, waarin getekend kan worden, en waarin tekst getoond kan worden.
En met een picturebox kun je hetzelfde. Overal waar in deze paragraaf imagebox staat mag je ook picturebox lezen.

Je kunt een plaatje in een imagebox zetten door de volgende programmacode in de procedure FormCreate te zetten:
Als de naam van de imagebox Image1 is en je wilt het plaatje 'school.bmp' er in tonen dan kan dat m.b.v. de opdracht
Image1.Canvas.Draw(0,0,foto);
Je moet dan wel van tevoren geheugenruimte voor de foto gereserveerd hebben met de opdracht
foto := TBitmap.Create;
En je moet er voor zorgen dat de foto wordt ingelezen van de harde schijf, en in het geheugen geplaatst. Dat gaat m.b.v. de opdracht: foto.LoadFromFile('school.bmp');

M.b.v. Image1.Canvas.Copymode kun je bepalen hoe de kleuren, die over elkaar vallen, worden behandeld.
Image1.Canvas.Copymode := normal;
Standaard, er wordt gewoon getekend met de voorgrondkleur, en waar getekend wordt verdwijnt de achtergrondkleur dus.
Image1.Canvas.Copymode := xor;
Gebruik de kleuren die in voor- of achtergrondkleur voorkomen maar niet in beide
Image1.Canvas.Copymode := inverse;
Gebruik het tegengestelde van de voorgrondkleur

M.b.v. Image1.Canvas.Pen.Style kun je bepalen hoe lijnen worden getekend.
Image1.Canvas.Pen.Style := solid; : normaal
Image1.Canvas.Pen.Style := dashed; : streepjes
Image1.Canvas.Pen.Style := dotted; : puntjes
Image1.Canvas.Pen.Style := dash-dot; : wisselend streepjes en puntjes

Een paar methoden van een imagebox (neem aan dat de naam ervan Image1 is) zijn:

Image1.Canvas.textout(X, Y, 'Test');Op de plaats (X,Y) wordt het woord Test afgedrukt
Image1.Canvas.Moveto(X, Y);De coördinaten van de cursor worden X en Y
Image1.Canvas.PenPos;Geeft de coördinaten van de cursor
Image1.Canvas.Pen.Color:=clYellow;De penkleur wordt geel
Image1.Canvas.Pen.Color:=RGB(100, 200, 100);De penkleur wordt de RGB-kleur R=100, G=200, B=100
Image1.Canvas.Brush.Color:=clRed;De achtergrondkleur wordt geel
Image1.Canvas.Brush.Style:=bsClear;De achtergrond wordt transparant
Image1.Canvas.Pen.Width:=5;De dikte van de pen wordt hiermee bepaald
Image1.Canvas.Pen.Style:=dotted;De lijnstijl wordt hiermee bepaald
Image1.Canvas.Floodfill;Kleurt de figuur in
Image1.Canvas.Lineto(200,300)Teken een lijn naar (200,300)
Image1.Canvas.Rectangle(20,30,50,160);Teken een rechthoek met (20,30) als hoekpunt linksboven en (50,160) als hoekpunt rechtsonder
Image1.Canvas.Roundrect(20,30,50,160);Teken een rechthoek met ronde hoeken, en ingekleurd
Image1.Canvas.Ellipse(20,30,50,160);Teken een ellips in een rechthoek met (20,30) als hoekpunt linksboven en (50,160) als hoekpunt rechtsonder
Image1.Canvas.Ellipse(x,y,x+50,y+50);Teken een cirkel in een vierkant met (x,y) en (x+50, y+50) als hoekpunten, dus met diameter 50
Image1.Canvas.Pie(x, y, x+diameter,y+diameter, xext2, yext2, beginhoek, eindhoek); Teken een taartpunt

Verder heb je ook de eigenschappen Visible, Font.Name, Font.Size, enz. Zie daarvoor bij de eigenschappen van een editbox.

  9.7 Listbox

Een listbox is een venster waarin een lijst wordt getoond waaruit iets gekozen kan worden door er op te klikken.
Een paar methoden van een listbox (neem aan dat de naam ervan List1 is) zijn:

List1.List1.Items.Add ('Test');Aan de lijst wordt het woord Test (onderaan) toegevoegd
List1.Items.Insert(3,'Test');Aan de lijst wordt het woord Test (op de vierde plaats, de eerste plaats heeft nummer 0) toegevoegd
g := List1.Items.Count;g bevat het aantal elementen in de lijst
t := List1.Items[5];List(5)t bevat de tekst van het zesde element van de lijst (de eerste heeft nummer 0 !)
List1.Items.Delete (5);; Het zesde element van de lijst wordt verwijderd
g := List1.ItemIndex; g bevat het nummer van de lijst waarop geklikt is (als er op de zesde geklikt is heeft g de waarde 5), als nergens op geklikt is heeft g de waarde -1
List1.Selected(5) := true; Het zesde element van de lijst wordt blauw gekleurd, is geselecteerd
List1.Clear;De lijst wordt gewist

Verder heb je ook de eigenschappen Visible, Font.Name, Font.Size, Color enz. Zie daarvoor bij de eigenschappen van een editbox

  9.8 Checkbox

Een checkbox is een vierkant hokje waarin een vinkje verschijnt (of juist weer verdwijnt) als je er op klikt.
Meestal heb je een aantal checkboxen onder elkaar waarin je dingen aan kunt vinken.
Je kunt meer dan één checkbox tegelijk aanvinken (bij radiobuttons of radiobuttons kan er maar één worden aangevinkt).
Een paar methoden van een checkbox (neem aan dat de naam ervan Checkbox1 is) zijn:

Checkbox1.Checked := true;De checkbox is aangevinkt
Checkbox1.Checked := false;De checkbox is niet aangevinkt
Checkbox1.Enabled := false;De checkbox is (tijdelijk) niet beschikbaar
Checkbox1.Caption := 'Bijschrift';Het bijschrift bij de checkbox

Verder heb je ook de eigenschappen Visible, Font.Name, Font.Size, Color enz. Zie daarvoor bij de eigenschappen van een editbox

  9.9 Radiobutton

Een radiobutton is een rondje waarin een stip verschijnt (of juist weer verdwijnt) als je er op klikt.
Een radiobutton wordt zo genoemd, omdat het net zo werkt als bij een knop op de radio: als je de ene indrukt komt de andere weer omhoog, er kan maar één tegelijk actief zijn.
Meestal heb je een aantal radiobuttons onder- of naast elkaar waarvan je er één kunt selecteren.
Denk goed om het verschil met checkboxen, bij checkboxen kun je meer dan één aanvinken).
Een paar methoden van een radiobutton (neem aan dat de naam ervan Radiobutton1 is) zijn:

Radiobutton1.Checked := TrueDe radiobutton is aangevinkt
Radiobutton1.Checked := FalseDe radiobutton is niet aangevinkt
Radiobutton1.Caption := 'Bijschrift';Het bijschrift bij de radiobutton

Verder heb je ook de eigenschappen Visible, Font.Name, Font.Size, Color enz. Zie daarvoor bij de eigenschappen van een editbox

Meestal heb je een array van radiobuttons, een aantal radiobuttons die bij elkaar horen.
Als je er bijv. 10 hebt en je wilt weten welke van de tien is aangeklikt, dan kan dat m.b.v. de volgende code:
gekozen := -1;
For i := 0 to 9 do
if (radiobutton[i] = true) then gekozen := i;


Als de variabele gekozen daarna de waarde -1 heeft dan betekent dat dat er op geen enkele radiobutton is geklikt, en anders bevat de variabele gekozen het nummer van de radiobutton waarop is geklikt.

Als je verschillende groepen radiobuttons wilt maken dan moet je ze per groep in een radiogroep plaatsen.

  9.10 Scrollbar

Een scrollbar (schuifbalk) lijkt een beetje op een volumeknop van een stero-installatie.
Door het blokje te verschuiven geef je een groter of kleiner getal aan.
Met behulp van min en max in het propertiesvenster kun je bepalen welk getal wordt aangegeven als het blokje helemaal links (of onder) c.q. helemaal rechts (of boven) zit.
.
Een paar methoden van een scrollbar (neem aan dat de naam ervan Scrollbar1 is) zijn:

x := Scrollbar1.Position; x bevat het getal dat de schuifbalk aangeeft
Scrollbar1.Max := 255;als de schuifbalk helemaal open staat geeft hij het getal 255 aan
Scrollbar1.Min := 0;als de schuifbalk helemaal dicht staat geeft hij het getal 0 aan
Scrollbar1.Largechange := 20;als het schuifblokje een beetje verschoven wordt wordt de waarde met 20 vermeerderd of verminderd
Scrollbar1.Smallchange := 5als er op de schuifpijl aan het uiteinde van de schuifbalk wordt geklikt wordt de waarde met 5 vermeerderd of verminderd.

Verder heb je ook de eigenschappen Visible, Enabled, Width enz. Zie daarvoor bij de eigenschappen van een editbox

  9.11 Messagebox en Inputbox

De meest eenvoudige messagebox-opdracht is bijvoorbeeld: ShowMessage("Je moet wel een land en een hoofdstad invoeren")
dan verschijnt er een berichtvenster met daarin "Je moet wel een land en een hoofdstad invoeren" en een OK-knop er onder (en de naam van het project in de titelbalk), en dan kan de gebruiker niet eerder verder dan wanneer hij of zij op OK heeft geklikt. Daarna verdwijnt het berichtvenster en kan de gebruiker weer verder. Maar zolang er niet op geklikt is kan de gebruiker niets anders, alle vensters zijn "bevroren" totdat er op het berichtvenster is gereageerd.
Hoe groot de messagebox is en waar hij verschijnt bepaalt Delphi, daar kun je zelf niets aan veranderen.
Maar er is een andere versie, waarmee je wel de plaats op het scherm kunt bepalen: ShowMessagePos

Er is ook een uitgebreidere vorm van die opdracht mogelijk, in het algemeen is de syntax van de MessageDlg-functie als volgt:
resultaat := MessageDlg (Boodschap, Style, Buttons, help-id);
Zoals je ziet zijn er vier dingen (attributen) die tussen de haakjes ingevuld moeten worden. Dat zijn:
  1. De boodschap mag uit maximaal 1024 tekens bestaan, en je kunt er voor zorgen dat er een aantal regels onder elkaar komen door + chr(13) + tussen de regels te zetten.
  2. Style : Het tweede attribuut geeft aan of er een extra teken in het venstertje verschijnt.
    Je kunt daarbij kiezen uit:
    • mtWarning (er verschijnt een uitroepteken),
    • mtConfirmation (er verschijnt een vraagteken),
    • mtError (er verschijnt een rode X),
    • mtInformation (er verschijnt een i) of
    • mtCustom ((er verschijnt geen extra teken).
  3. Met het derde attribuut wordt bepaald welke buttons in het venstertje verschijnen. De codes voor die buttons noteer je achter elkaar, met komma's er tussen, en het geheel tussen vierkante haken.
    De codes voor de verschillende buttons zijn:
    • mbYes (Yes-button),
    • mbNo (No-button),
    • mbOK (OK-button),
    • mbCancel (Cancel-button),
    • mbAbort (Abort-button),
    • mbRetry (Retry-button),
    • mbIgnore (Ignore-button),
    • mbAll (All-button),
    • mbNoToAll (No to all-button),
    • mbYesToAll (Yes to all-button),
    • mbHelp (Help-button)
    Voor een aantal combinaties kun je een speciale code gebruiken, de meest gebruikte zijn:
    mbYesNoCancel = [mbYes,mbNO,mbCancel] en mbOKCancel =[mbOK,mbCancel]
  4. Het vierde attribuut is een integer, en dat wordt alleen gebruikt bij de Help-button. Dat laten we buiten beschouwing. Meestal wordt daar een 0 neergezet, maar als er geen Help-button is maakt het eigenlijk niets uit welk getal er staat.
Voorbeeld 1:
b := MessageDlg('Dit is de boodschap',mtError, [mbYes,mbNO,mbCancel], 0);
Je mag deze opdracht ook als volgt schrijven:
b := MessageDlg('Dit is de boodschap',mtError, mbYesNoCancel, 0);
Dus mbYesNoCancel is een 'afkorting' voor [mbYes,mbNO,mbCancel]


De waarde van de variabele, die aangeeft op welke knop is geklikt (hierboven a of resultaat genoemd), is als volgt:
(En je kunt ook constanten gebruiken, die de betreffende waarde hebben. De staan onder de getallen)

OKCancelAbortRetryIgnoreYesNoAllNoToAllYesToAll
  1     2   3   4   5   6   7   8   9   10
mrOK mrCancel mrAbort mrRetry mrIgnore mrYes mrNo mrAll mrNoToAll mrYesToAll

Het drukken op de escape-toets heeft hetzelfde effect als het klikken op de cancel-knop.

Een InputBbox is net zoiets als een messagebox, met het verschil dat er in een inputbox nog tekst kan worden ingevoerd.
Als je bijv. de opdracht x := InputBox('Geef je naam', 'Dit staat in de titelbalk','xxx'); geeft dan verschijnt er een berichtvenster met daarin "Geef je naam" en daaronder een tekstvenster waarin die naam kan worden ingevoerd, en een OK-knop er onder.
Het tweede attribuut staat in de titelbalk, het derde attribuut staat alvast in het invoervenstertje.
De variabele x bevat het woord dat is ingevoerd.

  9.12 Herhalingen, If-Then

Als je de volgende programmaregels invoert:

For i := 1 to 20 do
begin
...................................
...................................
end;

dan worden de opdrachten op de stippeltjes 20 keer uitgevoerd, en i doorloopt daarbij achtereenvolgens de waarden 1 tot en met 20

Dat kun je gebruiken als je precies weet hoe vaak het moet gebeuren.

Als je de volgende programmaregels invoert:

For i := 10 downto 1 step -1 do
begin
...................................
...................................
end;

dan worden de opdrachten op de stippeltjes 10 keer uitgevoerd, en i doorloopt daarbij achtereenvolgens de waarden 10 tot en met 1

Als je de volgende programmaregels invoert:

WHILE (xxxxxxxxxxxxxx) do
begin
...................................
...................................
end;

dan worden de opdrachten op de stippeltjes net zo lang uitgevoerd als de voorwaarde op xxxxxxxxxxxxxx geldt.
Er wordt dus pas gestopt als de voorwaarde op xxxxxxxxxxxxxx niet meer geldt.
Denk er om dat de voorwaarde altijd tussen haakjes moet staan.

Als je de volgende programmaregels invoert:

REPEAT
...................................
...................................
UNTIL (xxxxxxxxxxxxxx);

dan worden de opdrachten op de stippeltjes net zo lang uitgevoerd tot de voorwaarde op xxxxxxxxxxxxxx niet meer geldt.

Als je de volgende programmaregels invoert:

IF (xxxxxxxxxxxxxx) THEN
begin
...................................
...................................
end
ELSE
begin
...................................
...................................
end;

dan worden de opdrachten op de eerste stippeltjesregels uitgevoerd als xxxxxxxxxxxxxx waar is en anders worden de opdrachten op de tweede stippeltjesregels uitgevoerd.

Als je de volgende programmaregels invoert:

CASE cijfer OF
1: showmessage('Je had niets goed');
2: showmessage('Bedroevend');
3: showmessage('Volgende keer beter');
4: showmessage('Niet zo best');
5: showmessage('Bijna voldoende');
else showmessage('Voldoende');
end;


dan worden de opdrachten na cijfer 1 uitgevoerd als cijfer de waarde 1 heeft, de opdrachten na cijfer 2 worden uitgevoerd als cijfer=2 waar is, enz. En anders worden de opdrachten na else uitgevoerd.

  9.13 Bestand lezen en /of schrijven

Als je iets uit een bestand, dat op de schijf staat en dat "bestand.txt" heet, wilt inlezen begin je met de opdrachten:
assignFile(f,'bestand.txt');
reset(f);

Je moet f ook nog als tekstfile declareren: var f:textFile;

Als je daarna een regel wilt inlezen uit het bestand dan regel je dat m.b.v. de opdracht:
readln(f, r);
De variabele r bevat dan die regel.
Als je daarna die opdracht readln(f, r); nog eens geeft dan wordt de volgende regel ingelezen.
Als je klaar bent met inlezen moet je nog de opdracht closefile(f); geven.

Als je alle regels wilt inlezen, en bewaren in het array r[i] dan kan dat m.b.v. de opdrachten:

assignFile(f,'bestand.txt');
reset(f);
i:=1;
While not eof(f) do
begin
      readln(f, r[i]);
      i:=i+1;
end;
closefile(f);

Het kan ook heel anders, m.b.v. de opdracht LoadFromFile(bestandsnaam);
Verder moet je dan een zogenaamde StringList hebben, dat is een array waarin de regels van het bestand worden opgeslagen.

Als je alle regels wilt inlezen op deze manier, en bewaren in het array regels[i], en in een memobox wilt laten zien, dan kan dat m.b.v. de opdrachten:

// de array moet worden gedeclareerd
var regels : TStringList;
// de stringlist regels moet worden gemaakt
regels := TstringList.Create;
// de gegevens worden gelezen vanaf de harde schijf
regels.LoadFromFile('test.txt');
// de regels worden in de memobox getoond
memo1.Text := regels.Text;
// het aantal regels vastleggen
a := regels.Count;
// in een listbox tonen
for i := 1 to a do listbox1.Items.Add(regels[i-1]);

Als je iets naar een bestand (bijv. met de naam "test.txt") wilt schrijven dan kan dat m.b.v. de opdrachten:

assignFile(f,'bestand.txt');
rewrite(f);
WRITELN(f, regel);
...............
closefile(f);

Als je een aantal regels, die je in een array hebt, wilt wegschrijven, dan kan het ook heel anders, m.b.v. de opdracht SaveToFile(bestandsnaam);
Verder moet je dan ook weer een zogenaamde StringList hebben, dat is een array waarin de regels van het bestand worden opgeslagen.

Als je de regels niet in een stringlist hebt, maar in een gewone array r[i], dan kan dat m.b.v. de opdrachten:

// de stringlist moet worden gedeclareerd
var regels : TStringList;
// de stringlist regels moet worden gemaakt
regels := TstringList.Create;
// de gegevens worden in de stringlist gezet
for i := 1 to a do regels.Add(r[i]);
// bewaren op schijf
regels.SaveToFile('test.txt');

  9.14 Kleuren

Je kunt in Delphi op twee manieren kleuren aangeven.
M.b.v. RGB en clColor.
Met clColor heb je de keuze uit maar 16 kleuren, die allemaal met een constante worden aangegeven.
Voorbeeld:
Edit1.Font.Color := clRed; zorgt er voor dat de tekstkleur rood wordt
Label1.Color := clGray; zorgt er voor dat de achtergrondkleur grijs wordt

Je kunt de volgende namen gebruiken.
Eigenlijk zijn het constanten, die een waarde hebben die berekend kan worden met de RGB-code (zie verder).
clBlack heeft bijv. de waarde 0, en clRed de waarde 255.

clAqua clBlack clBlue clDkGray clFuchsia clGray
clLime clLtGray clMaroon clNavy clOlive clPurple
clRed clSilver clTeal clWhite clYellow. clGreen

Met RGB heb je de keuze uit meer dan 16 miljoen kleuren, die je m.b.v. drie getallen tussen 0 en 255 aan kunt geven. Het eerste getal geeft de hoeveelheid rood aan, het tweede getal de hoeveel groen en het derde getal de hoeveelheid blauw.
Voorbeeld:
Edit1.Font.Color := RGB(255,0,0); zorgt er voor dat de tekstkleur rood wordt
Label1.Color := RGB(100,100,100) zorgt er voor dat de achtergrondkleur grijs wordt