Delphi Hoofdstuk 4. Bestanden lezen en schrijven; herhalen.
We gaan op deze pagina bekijken hoe je een tekstbestand op de schijf kunt opslaan,
en ook weer op kunt vragen.
Verder gaan we bespreken op welke manieren je een tekstbestand op het scherm kunt laten zien:
- In een memobox
- In een imagebox
4.1. Een tekstbestand maken.
Begin met een nieuw project, het formulier moet er uitzien zoals hiernaast.
Zet dus bovenaan een label met het opschrift : "Naam bestand ", en daarnaast een tekstbox
waar de naam kan worden ingevoerd.
Geef het label de naam lblBestand en geef het tekstvenster de naam txtBestand
Zet daaronder een button met het opschrift "Maak bestand aan", geef de button als naam
cmdMaakbestand
Een eindje daaronder komt nog een editbox, waarin tekst kan worden ingevoerd,
die dan in het bestand moet worden opgeslagen.
Geef dat tekstvenster als naam txtRegel
Daar weer onder een button met het opschrift "Voeg deze regel toe aan bestand" en dan nog
een button met het opschrift "Sluit af".
De namen van deze buttons luiden cmdVoegtoe en cmdSluitaf
De laatste drie objecten moeten in het begin eigenlijk nog niet op het scherm staan.
Want eerst moet er ruimte voor het bestand gemaakt worden op de schijf,
voordat er echt iets in gezet kan worden.
Daarom zet je in de procedure bij Form_Create het volgende :
procedure TForm1.FormCreate(Sender: TObject);
begin
txtRegel.Visible := False;
cmdVoegtoe.Visible := False;
cmdSluitaf.Visible := False;
end;
Verder is het de bedoeling dat er, als er op de button met "Maak bestand aan" wordt geklikt, er op de schijf
ruimte wordt gecreëerd voor het bestand, en dat er ook op de schijf wordt aangegeven wat de
naam van dat bestand is (het is de bedoeling dat die naam in het tekstvenster er boven
is ingevoerd), zodat er echt iets in dat bestand geplaatst kan worden.
Als de naam van het bestand "PROEF.TXT" moet zijn dan is de opdracht die dat verzorgt het volgende :
ASSIGN(f,'PROEF.TXT');
Wij kennen de naam echter nog niet, dat hangt er vanaf wat er in het tekstvenster wordt ingevoerd.
Daarom wordt die naam in een variabele vastgelegd, die ik "bestandsnaam" heb genoemd.
Door de opdracht bestandsnaam := txtBestand.Text + '.TXT';
wordt er nog .TXT aan de naam, die in de editbox is ingevoerd, toegevoegd.
Verder kunnen dan de eerste drie objecten verdwijnen, en de laatsten moeten zichtbaar worden,
daarom moeten er een aantal opdrachten met "visible" worden toegevoegd.
Dubbelklik op de button met "Maak bestand aan" en voer de volgende regels bij
procedure TForm1.cmdMaakbestandClick(Sender: TObject); in:
procedure TForm1.cmdMaakbestandClick(Sender: TObject);
var bestandsnaam: String;
// declaratie van de file boven implementation, als globale variabele
begin
If (txtBestand.Text <> '') Then
begin
bestandsnaam := txtBestand.Text + '.txt';
// het bestand met de ingevoerde naam wordt aangemaakt
assignFile(f,bestandsnaam);
// de schrijfwijzer wordt aan het begin van het bestand gezet
REWRITE(f);
// als je iets wilt toevoegen aan een bestand (dus niet vanaf het begin wilt schrijven)
// gebruik dan APPEND(f); in plaats van REWRITE(f);
lblBestand.Visible := False;
txtBestand.Visible := False;
cmdMaakbestand.Visible := False;
txtRegel.Visible := True;
cmdVoegtoe.Visible := True;
cmdSluitaf.Visible := True;
end;
end;
De tekstfile moet je als globale variabele declareren, omdat hij in verschillende procedures wordt gebruikt.
Dus boven de regel met implementation komt:
(het eerste staat er al) var
Form1: TForm1;
// declaratie van de file
f:textFile;
4.2. Iets in een tekstbestand zetten.
Het is de bedoeling dat als je in het tweede tekstvenster een regel intikt, en je klikt op
"Voeg deze regel aan bestand toe" dat die regel in het bestand wordt gezet.
Als je de opdracht WRITELN(f,'Piet is gek'); geeft, dan
wordt de zin "Piet is gek" aan het bestand toegevoegd.
Bij ons programma moet de regel die in de tekstbox txtRegel is ingetypt aan het bestand
worden toegevoegd. Dat gaat als volgt :
Dubbelklik op het label "Voeg deze regel aan bestand toe" en zorg dat er het volgende staat:
procedure TForm1.cmdVoegtoeClick(Sender: TObject);
begin
WRITELN(f,txtRegel.Text);
txtRegel.Text := '';
end;
De laatste regel heeft tot gevolg dat de tekstbox weer leeg wordt gemaakt voor de volgende regel.
Elke keer als er op de button "Voeg deze regel aan bestand toe" wordt geklikt wordt er
iets aan het bestand toegevoegd. Je kunt het dus zo lang maken als je wilt.
Voer verder nog bij de button "Sluit af" het volgende in :
procedure TForm1.cmdSluitafClick(Sender: TObject);
begin
Closefile(f);
end;
Door de opdracht CloseFile(f) wordt het bestand "afgesloten", er kan daarna niets meer
(rechtstreeks) worden toegevoegd.
Als je het programma helemaal klaar hebt laat je het lopen (RUN !)
Voer als bestandsnaam in: PROEF en klik dan op MAAK BESTAND AAN.
Voer daarna minstens 10 regels in, en voeg die steeds aan het bestand toe.
Sluit dan af, dan stopt het programma.
Start dan KLADBLOK en kijk of het bestand PROEF.TXT bestaat (het zit waarschijnlijk
in de map van het Delphi-project) en wat er in zit.
Als alles goed is gegaan dan zitten de regels er in die je hebt ingevoerd met het programma.
4.3. Een tekstbestand inlezen.
Begin met een nieuw project, het formulier moet er uit zien zoals hiernaast.
Zet dus bovenaan een label met het opschrift : "Naam bestand ", en daarnaast een editbox
waar de naam kan worden ingevoerd.
Geef het label de naam lblBestand en geef de editbox de naam txtBestand
Zet daaronder een button met het opschrift "Lees begin", geef de button als naam
cmdLees
Naast de button cmdLees zet je nog een button met het opschrift "Lees volgende regel" en geef de button als
naam cmdVolgenderegel
Daaronder links een memobox, waarin de tekst kan worden getoond.
Het verschil tussen een memobox en een editbox is, dat in een editbox maar één regel tekst kan, en in
een memobox kunnen meerdere regels.
Geef die memobox als naam memoAfdruk, en zorg er voor dat er een horizontale en een verticale scrollbar is
(klik op Scrollbars in het propertiesvenster, en kies dan voor ssBoth)
Daarnaast rechts een imagebox, waarin de tekst ook kan worden getoond.
Geef die imagebox als naam imgAfdruk
Onderaan nog een button met het opschrift "Sluit af".
De naam van deze button is cmdSluitaf
Het is de bedoeling dat als je de naam van een tekstbestand invoert, en dan op de button cmdLees
klikt dat de inhoud ervan in de memobox er onder wordt getoond en ook in de imagebox.
Dat gaan we nu programmeren.
Dubbelklik op de button met "Lees begin" en voer de volgende regels bij
procedure TForm1.cmdLeesClick(Sender: TObject); in:
procedure TForm1.cmdLeesClick(Sender: TObject);
var bestandsnaam, regel: String;
// declaratie van de file boven implementation, als globale variabele
begin
If (txtBestand.Text <> '') Then
begin
bestandsnaam := txtBestand.Text + '.txt';
// het bestand met de ingevoerde naam wordt geopend
assignFile(f,bestandsnaam);
// de leeswijzer wordt aan het begin van het bestand gezet
reset(f);
readln(f, regel);
memoAfdruk.text := regel;
imgAfdruk.Canvas.TextOut(0,0,regel);
lblBestand.Visible := False;
txtBestand.Visible := False;
cmdLees.Visible := False;
end;
end;
De opdracht bestandsnaam := txtBestand.text + ".txt" heeft tot gevolg dat de naam van het
tekstbestand, dat ingelezen moet worden in de variabele "bestandsnaam" (daar kan een string in, zie eerste
programmaregel) wordt vastgelegd. Daarvoor wordt in de editbox txtBestand gekeken, en wat daar staat daar wordt
.txt achter geplakt.
Als je dus in het tekstvenster PROEF intikt dan komt er in "naambestand" te staan: "PROEF.txt"
assignFile(f,bestandsnaam); heeft tot gevolg dat het volgende gebeurt:
Als er in de variabele bestandsnaam PROEF.txt staat, dan had er in de opdracht net zo goed kunnen staan:
assignFile(f,'PROEF.txt');
Het bestand PROEF.txt wordt dan opgezocht op de schijf (in dezelfde map waarin het
programma staat; als het daar niet staat moet het pad er bij).
En er wordt een buffergeheugen met de naam f in het werkgeheugen gereserveerd, waarin de ingelezen regels
eerst worden geplaatst.
De opdracht reset(f); heeft tot gevolg dat de leeswijzer aan het begin van het bestand
wordt gezet; het programma houdt d.m.v. de leeswijzer bij tot hoever het bestand is ingelezen.
readln(f, regel); heeft tot gevolg dat er een regel van het
bestand wordt ingelezen
(eigenlijk gaat dat in twee stappen: eerst wordt er een gedeelte van het bestand (bijvoorbeeld
1024 bytes, dat is hier waarschijnlijk het hele bestand) in de buffer met de naam f gezet.
En dan wordt uit die buffer de eerste regel gelezen
en in de variabele "regel" (die is van het type string, zie de eerste programmaregel) vastgelegd).
memoAfdruk.text := regel; heeft tot gevolg dat deze eerste regel in
de memobox memoAfdruk getoond wordt.
imgAfdruk.Canvas.TextOut(0,0,regel); heeft tot gevolg dat deze eerste regel ook
in de imagebox imgAfdruk getoond wordt, en wel vanaf de plaats (0,0) dus bovenaan.
Een imagebox kun je voor plaatjes gebruiken, maar dus ook voor tekst!
De laatste drie programmaregels hebben tot gevolg dat de eerste drie objecten van het
scherm verdwijnen, die zijn dan niet meer nodig.
Laat het programma nu lopen, voer als bestandsnaam PROEF in, en als je geen fouten
hebt gemaakt dan wordt de eerste regel van dat tekstbestand getoond in het linker tekstvenster
en ook in de rechter imagebox.
Je moet natuurlijk wel zo'n tekstbestand hebben ingevoerd, zoals in 4.2. is uitgelegd.
De tekstfile moet je als globale variabele declareren, omdat hij in verschillende procedures wordt gebruikt.
Dus boven de regel met implementation komt:
(het eerste staat er al) var
Form1: TForm1;
// declaratie van de file
f:textFile;
4.4. De volgende regels inlezen.
Het is de bedoeling dat als je op de button "Lees volgende regel" klikt de volgende regel
van het tekstbestand getoond wordt. Dat gebeurt nu nog niet. Daarvoor moeten we eerst nog
iets invoeren.
Dubbelklik op de button bVolgenderegel. En voer onder procedure TForm1.cmdVolgenderegelClick het volgende in:
procedure TForm1.cmdVolgenderegelClick(Sender: TObject);
var regel: String;
begin
readln(f, regel);
memoAfdruk.text := memoAfdruk.text + chr(13) + chr(10) + regel;
aantalregels := aantalregels + 1;
imgAfdruk.Canvas.TextOut(0,(aantalregels-1)*15,regel);
end;
end;
De opdracht readln(f, regel); heeft tot gevolg dat de
volgende regel van het tekstbestand wordt gelezen, en aan de variabele "regel" wordt
toegekend.
De computer houdt bij tot hoever hij is gevorderd met het inlezen, en elke keer als hij
de opdracht readln(f, regel); tegenkomt leest hij de regel, die dan aan de beurt is, in
en de inhoud van die regel wordt dan aan de variabele "regel" toegekend.
Laat het programma nu weer lopen, voer als bestandsnaam PROEF in, en als je geen fouten
hebt gemaakt dan wordt de eerste regel van dat tekstbestand getoond in het linker tekstvenster
en ook in de rechter imagebox.
Als je daarna op "Lees volgende regel" klikt dan wordt de volgende regel getoond in het
linker tekstvenster, en ook in de rechter imagebox.
Klik maar een aantal keren achterelkaar op die button.
De opdracht memoAfdruk.text := memoAfdruk.text + chr(13) + chr(10) + regel; heeft tot gevolg dat de volgende
regel steeds wordt afgedrukt, maar dat ook de vorige regels te zien zijn.
Als de opdracht memoAfdruk.text := regel; zou zijn, dan zou je steeds alleen de laatste regel zien.
En als de opdracht memoAfdruk.text := memoAfdruk.text + regel; zou zijn, dan zou de nieuwe regel
steeds aan het vorige worden vastgeplakt, en dan zou je wel alle regels zien maar niet onder elkaar!
Ze zouden dan achter elkaar komen, op één hele lange regel.
Dan wordt de inhoud van "regel" er aan vastgeplakt!
Maar nu wordt de code chr(13) aan memoAfdruk.text, dus de tekst die er al is, vastgeplakt.
Dat is de code om er voor te zorgen dat de cursor naar de volgende regel gaat.
Dan wordt de code chr(10) er ook nog aan vastgeplakt.
Dat is de code om er voor te zorgen dat de cursor naar het begin van de regel gaat.
En dan wordt de nieuwe regel er aan vast geplakt, zodat de nieuwe regel steeds onder de vorige komt.
De opdracht imgAfdruk.Canvas.TextOut(0,(aantalregels-1)*15,regel); heeft tot gevolg dat de volgende regel steeds
onder de vorige wordt afgedrukt.
Als opdracht imgAfdruk.Canvas.TextOut(0,0,regel); zou zijn dan zou de nieuwe regel steeds bovenaan worden afgedrukt, over
de vorige heen. En dan zou je de vorige niet meer zien.
Daarom moet het aantal ingelezen regels worden bijgehouden, en als je voor de hoogte van een regel 15 pixels rekent dan moet
de plaats van de laatste regel steeds (aantalregels - 1)*15 pixels onder de bovenkantlijn zijn.
En het aantal ingelezen regels moet wel worden bijgehouden, daarom staat er in de programmaregel erboven:
aantalregels := aantalregels + 1;
En verder moet in de procedure voor het inlezen van het begin (dus in procedure TForm1.cmdLeesClick(Sender: TObject);) worden toegevoegd:
aantalregels := 1;
En natuurlijk moet de variabele aantalregels ook worden gedeclareerd. Het moet een globale variabele worden, omdat hij
in verschillende procedures wordt gebruikt.
Dus boven de regel met implementation komt:
(het eerste regels staan er al)
var
Form1: TForm1;
// declaratie van de file
f:textFile;
aantalregels: integer;
Voer verder nog bij de button "Sluit af" het volgende in :
procedure TForm1.cmdSluitafClick(Sender: TObject);
begin
Closefile(f);
end;
Door de opdracht CloseFile(f) wordt het bestand "afgesloten", er kan daarna niets meer uit het bestand worden gelezen.
4.5 Herhalingen, een aantal regels tegelijk inlezen.
In de vorige paragraaf kon je alle regels laten inlezen, maar voor elke regel moest
je weer op de button "Lees volgende regel" klikken.
Dat kan simpeler, want je hebt in Delphi dezelfde opdrachten als in Pascal om iets te laten herhalen.
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.
Net als in Pascal heb je ook in Visual Basic opdrachten vergelijkbaar met While en met Repeat.
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.
Als je de volgende programmaregels invoert:
REPEAT
begin
...................................
...................................
UNTIL (xxxxxxxxxxxxxx);
dan worden de opdrachten op de stippeltjes net zo lang uitgevoerd tot de voorwaarde op
xxxxxxxxxxxxxx niet meer geldt.
We gaan het programma uit de vorige paragraaf wat aanpassen.
Verwijder eerst het label bVolgenderegel van het formulier, en de bijbehorende programmaregels.
Voer bij de button cmdLees de volgende code onder Click in (verwijder eerst de regels die er
al stonden) :
procedure TForm1.cmdLeesClick(Sender: TObject);
// declaratie van de variabele "naambestand" waarin de naam
// van het bestand wordt vastgelegd en van
// de variabele "regel" waarin de inhoud van
// een ingelezen regel wordt vastgelegd.
var bestandsnaam, regel: String;
// declaratie van de teller i
i: integer;
begin
If (txtBestand.Text <> '') Then
begin
// haal de naam van het bestand uit de memobox txtBestand
bestandsnaam := txtBestand.Text + '.txt';
// het bestand met de ingevoerde naam wordt geopend
assignFile(f,bestandsnaam);
// de leeswijzer wordt aan het begin van het bestand gezet
reset(f);
// de labels lblBestand en cmdLees en de memobox
// txtBestand moeten nu verdwijnen
lblBestand.Visible := False;
txtBestand.Visible := False;
cmdLees.Visible := False;
// de memobox wordt eerst leeggemaakt
memoAfdruk.text := '';
// de imagebox wordt leeggemaakt
imgAfdruk.Canvas.FillRect(Rect(0,0, imgAfdruk.Width, imgAfdruk.Height) );
// de eerste 10 regels worden ingelezen
// en afgedrukt in de memobox en in de imagebox
for i := 1 to 10 do
begin
readln(f, regel);
memoAfdruk.text := memoAfdruk.text + chr(13) + chr(10) + regel;
imgAfdruk.Canvas.TextOut(0,(i-1)*15,regel);
end;
end;
end;
Laat het programma nu lopen, voer als bestandsnaam PROEF in.
Als het goed gaat dan worden de eerste tien regels van dat tekstbestand getoond in beide
vensters. (natuurlijk moeten er wel tien regels in zitten, anders krijg je een foutmelding)
4.6 While not end of file
We willen natuurlijk graag dat alle regels van het tekstbestand worden ingelezen en getoond.
Maar hoe kun je dat nu voor elkaar krijgen als je niet weet hoeveel regels er zijn ?
Dan moet de opdracht om een regel in te lezen worden herhaald, net zo lang tot het einde van
het tekstbestand is bereikt.
Dat gebeurt door de regel : while not eof(f) do
(eof is de afkorting van end-of-file)
Dit betekent dat de computer doorgaat zolang nog niet het einde van het bestand bereikt is.
Elke keer wordt een nieuwe regel ingelezen, en vastgelegd in de variabele "regel".
Closefile(f); heeft tot gevolg dat het bestand wordt afgesloten, vanaf dat moment kan er
niet meer uit dat bestand worden gelezen.
We gaan het programma uit de vorige paragraaf voor de laatste keer aanpassen.
Verwijder het label cmdSluitaf van het formulier, en de bijbehorende programmaregels.
Voer bij de button cmdLees de volgende code onder Click in (verwijder eerst de regels die er
al stonden) :
procedure TForm1.cmdLeesClick(Sender: TObject);
// declaratie van de variabele "naambestand" waarin de naam
// van het bestand wordt vastgelegd en van
// de variabele "regel" waarin de inhoud van
// een ingelezen regel wordt vastgelegd.
var bestandsnaam, regel: String;
// declaratie van de teller i
i: integer;
begin
If (txtBestand.Text <> '') Then
begin
// haal de naam van het bestand uit de memobox txtBestand
bestandsnaam := txtBestand.Text + '.txt';
// het bestand met de ingevoerde naam wordt geopend
assignFile(f,bestandsnaam);
// de leeswijzer wordt aan het begin van het bestand gezet
reset(f);
// de labels lblBestand en cmdLees en de memobox
// txtBestand moeten nu verdwijnen
lblBestand.Visible := False;
txtBestand.Visible := False;
cmdLees.Visible := False;
// de memobox wordt eerst leeggemaakt
memoAfdruk.text := '';
// de imagebox wordt leeggemaakt
imgAfdruk.Canvas.FillRect(Rect(0,0, imgAfdruk.Width, imgAfdruk.Height) );
// alle regels worden ingelezen
// en afgedrukt in de memobox en de eerste 10 in de imagebox
while not eof(f) do
begin
readln(f, regel);
memoAfdruk.text := memoAfdruk.text + chr(13) + chr(10) + regel;
if (i<10) then imgAfdruk.Canvas.TextOut(0,(i-1)*15,regel);
end;
end;
end;
Laat het programma nu lopen, voer als bestandsnaam PROEF in.
Als het goed gaat dan worden alle regels van dat tekstbestand getoond in beide
vensters.
4.7. Fouten opvangen.
Normaal is het zo, dat als er een fout optreedt in een programma, het programma stopt, en er verschijnt een foutmelding.
Maar je kunt een foutenafhandeling programmeren, zodat het programma ondanks eventuele fouten toch kan blijft draaien.
Als een programma loopt, en er gaat iets fout, dan zal Delphi een zogenaamde uitzondering genereren.
Deze uitzondering kan in de code van het programma worden opgelost, maar je zult dat wel zelf moeten programmeren.
De volgende codewoorden kun je gebruiken bij het foutafhandelingssysteem :
| codewoord | betekenis |
| try | bevat de code die uitgevoerd moet worden, maar waarin eventueel een fout op kan treden |
| except | geeft aan wat er moet gebeuren als er een fout optreedt in de code bij try |
| finally | geeft aan wat er, fout of geen fout, absoluut uitgevoerd moet worden |
| raise | geeft de mogelijkheid om zelf een fout te genereren |
Het ziet er als volgt uit:
try
// de code die uitgevoerd moet worden
except
on exception do
// de code die uitgevoerd moet worden als er een fout optreedt
end;
Als de code in het try-gedeelte geen fout genereert zal de code in het except-gedeelte worden overgeslagen.
Treedt er wel een fout op in het try-gedeelte dan zal het programma verder gaan met het except-gedeelte, en die code kan
afhankelijk zijn van de opgetreden fout (elke fout heeft een foutcode, exception genaamd) .
Bij het inlezen van een bestand, bij het programma van Delphi 4.3 , kan er een fout optreden als er
een verkeerde bestandsnaam wordt
ingevoerd. Als je er voor wilt zorgen dat het programma niet crasht, als dat gebeurt, dan kun je de code als volgt aanpassen:
(de zwartgekleurde regels zijn toegevoegd)
procedure TForm1.cmdMaakbestandClick(Sender: TObject);
var bestandsnaam: String;
// declaratie van de file boven implementation, als globale variabele
begin
If (txtBestand.Text <> '') Then
begin
bestandsnaam := txtBestand.Text + '.txt';
// het bestand met de ingevoerde naam wordt aangemaakt
try
begin
assignFile(f,bestandsnaam);
// de schrijfwijzer wordt aan het begin van het bestand gezet
REWRITE(f);
lblBestand.Visible := False;
txtBestand.Visible := False;
cmdMaakbestand.Visible := False;
txtRegel.Visible := True;
cmdVoegtoe.Visible := True;
cmdSluitaf.Visible := True;
end
except
on EInOutError do
begin
ShowMessage ('Bestand niet gevonden');
exit;
end;
end;
end;
end;
In de ontwerpfase wordt er trouwens niet op deze code gereageerd, je moet het gecompileerde programma (een exe-file)
starten zonder Delphi en dan werkt het.
De foutcode (hier: EInOutError) kun je gemakkelijk ontdekken: als je het programma laat lopen en je voert een verkeerde
bestandsnaam in, dan verschijnt er een foutmelding met de betreffende code.
Bij het programma van Delphi H1, kan er een fout optreden als er geen getal maar een letter of
helemaal niets wordt ingevoerd. Als je er voor wilt zorgen dat het programma niet crasht, als dat gebeurt,
dan kun je de code als volgt aanpassen:
(de zwartgekleurde regels zijn toegevoegd)
procedure TForm1.Button1Click(Sender: TObject);
var g1,g2, s, v, p: integer;
q: real;
begin
try
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
except
on EInOutError do
begin
ShowMessage ('Bestand niet gevonden');
exit;
end;
Ook bij het programma van Delphi H2 kan er zo'n fout optreden. Je kunt dat op dezelfde manier aanpassen.
4.8. Een bestand uitkiezen m.b.v. een Open-dialoogbox.
In het programma van 4.3 t/m 4.7 is een bestand geopend, nadat de naam van het bestand in ingetypt in een editbox.
Het is ook mogelijk de naam van het bestand uit te kiezen in een lijst, in een verkenner-achtig venster.
Zo'n venster wordt een OpenDialoog-venster genoemd in Delphi.
We veranderen het vorige programma zo, dat het bestand in zo'n OpenDialoog-venster uitgekozen kan worden.
Het formulier veranderen we zoals hiernaast.
Zet er een OpenDialoog-venster op, door in de toolbox te klikken op TOpenDialog, en
dan in het formulier te slepen met de muis.
Waar je het plaatst op het formulier maakt niet uit, want je ziet het toch niet op het formulier.
Pas als het OpenDialoog-venster in de code wordt aangeroepen verschijnt er zo'n venster, maar dan als een apart venster.
Het OpenDialoog-venster ziet er dan als volgt uit:
Als je klikt op de Open-en_lees-button dan is het de bedoeling dat het OpenDialoog-venster verschijnt.
Dat programmeer je dan als volgt: (in de commentaarregels zie je betekenis van de code)
procedure TForm1.cmdLeesClick(Sender: TObject);
var bestandsnaam, regel: String;
i: integer;
// declareer de OpenDialog variabele
openDialog : TOpenDialog;
begin
// laat het OpenDialoog-venster verschijnen
openDialog := TOpenDialog.Create(self);
// zorg er voor dat de actieve map de startmap van
// het OpenDialoog-venster wordt
openDialog.InitialDir := GetCurrentDir;
// Zorg er voor dat alleen bestaande files kunnen worden geopend
openDialog.Options := [ofFileMustExist];
// Zorg er voor dat alleen txt-files worden getoond
openDialog.Filter := 'text files|*.txt';
// Als er op de naam van een bestand geklikt is, doe dan het volgende:
if (openDialog.Execute) then
// geef de geheugenruimte voor het OpenDialoog-venster weer vrij
openDialog.Free;
// leg het gekozen bestand vast in een variabele
bestandsnaam := openDialog.FileName;
// het bestand met de ingevoerde naam wordt opgezocht
begin
assignFile(f,bestandsnaam);
// de leeswijzer wordt aan het begin van het bestand gezet
reset(f);
memoAfdruk.text := '';
while not eof(f) do
begin
readln(f, regel);
memoAfdruk.text := memoAfdruk.text + chr(13) + chr(10) + regel;
aantalregels := aantalregels + 1;
end;
end;
end;
4.9 Opdrachten
Opgaven. Maak nu opgave 4 van de oefenopgaven van delphi
|