Brian Long (www.blong.com)
Vertaling: A.G. van der Heijden
In dit tweede hoofdstuk van deze cursus Kylix Open Edition ontwikkelt Brian Long een tekstverwerkings programma.
Dis artikel verscheen voor het eerst in Linux Format nummer 20, november 2001.
Klik hier om de bestanden te downloaden die bij dit artikel horen.
In hoofdstuk 1 zagen we hoe Kylix geinstalleerd worden op Linux distributies, en wat de belangrijkste onderdelen zijn van de IDE. Deze keer bezien we hoe we een tekstverwerkingsprogramma maken (zie Figuur 1).
Figuur 1: Wat het pre-installatie test programma zegt over een passende distributie
Allereerst starten we Kylix Open edition of, als dit al draait, starten we een nieuw project (File | New Application). Hiermee maken we de infra voor een programma met een enkel formulier, wat in dit geval het enige is dat we nodig hebben. Voor we verder gaan dienen we ons project te bewaren, en vanaf nu zouden we dat ook regelmatig moeten doen (om verlies van werk te voorkomen bij het onvoorzien crashen van het programma).
De bestanden die deel uitmaken van een Kylix project staan beschreven in het stuk over Kylix Project bestanden. Om uw project te bewaren kiest u voor File | Save All (of u kiest de bijbehorende knop, getoond in Figuur 2). Hier wordt u eerst gevraagd om een naam voor het formulier (de standaard aangeboden naam luidt TextEditorU.pas) en daarna voor het projectbestand zelf (in de bijgevoegde bestanden heet het ding TextEditor.dpr).
Figuur 2: De knop voor het bewaren van alle ingevoerde veranderingen
Merk op, dat ondanks dat het projectbestand en het unitbestand verschillende extensies hebben, het toch van wezenlijk belang is dat hun namen verschillen! Onze standaard gewoonte voor enkele formulier projecten zoals deze is, dat we een naam kiezen voor het project (wat de naam wordt van het resulterende uitvoerbare programma) en dat we de unit dezelfde naam geven, maar met een letter U toegevoegd.
Het formulier object heet op dit moment Form1 (en is ook van het type TForm1), wat een niet erg duidelijke naam is. Verander die naam (middels de Name eigenschap op de Object Inspector) in frmTextEditor, en denk erom op Enter te drukken na het intypen van de nieuwe Name om zeker te zijn dat hij wordt toegekend aan de betreffende eigenschap. U moet proberen te onthouden op Enter te drukken na het intypen van een nieuwe eigenschap in Kylix 1 omdat er anders het gevaar is dat de bedoelde waarde wordt genegeerd.
Nu moeten we de nodige componenten op het formulier zetten. Vanaf de Standard pagina van het Component Palet, heeft u een TMemo component nodig (dat is een component met de klassenaam TMemo, maar de tekst die bij het Component Palet wordt gegeven als u de muis erboven houdt, luidt Memo - de klassenaam zonder de voorafgaande T). Verander de Name eigenschap van Memo1 in memText.
Het mem voorvoegsel wordt gebruikt om aan te geven dat memText is een memo component is, en het frm voorvoegsel gebruikt voor de naam van het formulier geeft aan dat frmTextEditor een formulier is. Dit zijn voorbeelden van een algemene componentennaam-conventie: een klein groepje letters wordt ontleend aan het objecttype en gebruikt als voorvoegsel.
Van dezelfde Component Palet pagina haalt u een TMainMenu (waarvan de verklarende tekst luidt MainMenu) en u verandert de naam in mnuMainMenu. Er is een opmerkelijk verschil tussen het memo en het menu (behalve dat ze heel verschillende dingen doen). Het memo is een visuele component. U ziet de visuele representatie op de Form Designer en u ziet hem ook bij het draaien van het programma. De hoofdmenu component is een niet-visueel onderdeel, en dus gebruikt de Form Designer dezelfde icoon om hem aan te duiden als het Component Palet (zie Figuur 3), waardoor u de component tijdens het ontwerpen kunt selecteren. Bij het draaien is de component niet zichtbaar, maar hopelijk wordt het actuele menu dat door de component wordt vertegenwoordigd wel getoond.
Wil deze menucomponent kunnen fungeren als hoofdmenu voor het formulier (dus vertoond worden aan de bovenkant van het formulier) moet hij verbonden worden met de Menu eigenschap van het formulier. Gelukkig wordt dat automatisch geregeld, dankzij het feit dat dit de enige menucomponent is van het formulier (dit kun je controleren door het formulier object te selecteren middels het aanklikken van de achtergrond van de Form Designer en het nazien van de Menu eigenschap in de Object Inspector). Met andere woorden: terwijl we de menu component opbouwen (zoals we later zullen doen), zullen we het menu automatisch zien verschijnen aan de bovenkant van het formulier.
Figuur 3: Een niet-visuele menu component
Nu hebben we nog wat meer componenten nodig, dit keer van de Dialogs pagina van het Component Palet. Zet een TOpenDialog en een TSaveDialog component (beide niet-visueel) op de Form Designer. Ze zullen respectievelijk gebruikt worden om bestanden te openen en namen te geven aan bestanden die bewaard moeten worden. Verander hun Name eigenschappen in dlgOpen en dlgSave.
Er zijn niet meer visuele knoppen vereist op het formulier zodat de memo alle ruimte op het formulier mag innemen door de Align eigenschap in te stellen op alClient. (Hiermee krijgt hij opdracht alle beschikbare ruimte in te nemen, na bezien te hebben welke andere vensters er op het scherm staan)
Ook de memo toont (zoals vele knoppen) standaard zijn naam als zijn tekstuele inhoud (zoals getoond in Figuur 3), zodat we dit kunnen verbeteren door gebruik te maken van zijn Lines eigenschap. Lines is een eigenschap die geimplementeerd is als een TStrings object - een object ontworpen om een serie tekststrings te beheren. Dit object beheert de memo inhoud, dus roep zijn eigenschap editor op door te drukken op de ellips knop (de knop met de drie stippen erop) of door het indrukken van Ctrl+Enter, en haal alle tekst weg. Nu blijft het memovenster leeg.
Het laatste wat we met de gebruikersinterface van dit programma moeten doen is het aanmaken van het menu. Als we dat gedaan hebben kunnen we gaan overdenken hoe het programma feitelijk moet gaan werken. U maakt menus in de Menu Designer (zie Figuur 4). Hij kan worden gestart hetzij door dubbelklikken op de component, hetzij door met de rechtermuisknop erop te klikken en te kiezen voor Menu Designer uit het context menu, of door de component te selecteren en dan de eigenschappen editor te starten voor de Items eigenschap (selecteer de eigenschap in de Object Inspector en druk op de ellips knop of op Ctrl+Enter).
Figuur 4: Een leeg menu in de Menu Designer
Allereerst is de Menu Designer leeg, wat te begrijpen is. Echter wordt een mogelijk menu onderdeel gemarkeerd, en de eigenschappen van dit incomplete TMenuItem component staan ter beschikking in de Object Inspector. Door een of meer eigenschappen in te voeren kunnen we de TMenuItem component werkelijkheid maken en completeren. Stel Caption op &File, voor een typisch bestandsmenu en stel zijn Name op mniFile. Incidenteel zorgt de & in het opschrift dat de volgende letter onderstreept wordt als hij in het menu verschijnt, wat wil zeggen dat de gebruiker het File menu kan activeren door het indrukken van Alt+F.
Klik nu weer op de aanduiding van dit File menu in de Menu Designer, en u zou twee andere mogelijke menu onderdelen moeten zien, die wachten op uw nadere uitwerking. Een ervan is een ander onderdeel op de menubalk naast File, terwijl het andere een menu onderdeel is binnen het File menu (zie Figuur 5). Klik op het onderdeel onder File en stel het opschrift Caption op &New, zijn Name op mniNew en zijn ShortCut op Ctrl+N, wat wil zeggen dat Ctrl+N direct dit menu onderdeel activeert zonder de menu's te hoeven benaderen.
Figuur 5: Een menu onderdeel geregeld, nog verschillende te gaan
Ga door met het toevoegen van menu onderdelen aan het File menu, waarbij u telkens de Name, Caption en ShortCut eigenschappen kiest zoals aangegeven in de onderstaande lijst. Merk op dat voor het laatste menu onderdeel in de lijst, de afkorting letter voor letter moet worden ingevoerd omdat hij niet in de lijst van de Object Inspector staat. Merk ook op dat de drie puntjes op het eind van het menu onderdeel Open... aangeven dat er een dialoog zal verschijnen als de gebruiker voor dat onderdeel kiest.
Name = mniOpen, Caption = '&Open...', ShortCut = Ctrl+O
Name = mniSave, Caption = '&Save', ShortCut = Ctrl+S
Name = mniSeparator, Caption = '-'
Name = mniExit, Caption = 'E&xit', ShortCut = Alt+X
Figuur 6: Het complete File menu
Nu het File menu compleet is, zou uw scherm eruit moeten zien als in Figuur 6. Op naar de volgende menu's: een Edit menu en een Help menu. Klik op het invoerveld naast File in de Menu Designer om het Edit menu aan te maken (en daarna op de invoer naast Edit, die op dat punt zal verschijnen, voor het Help menu). Zet de menu onderdelen als volgt in elkaar:
Name = mniEdit, Caption = '&Edit'
Name = mniCut, Caption = 'Cu&t', ShortCut = Ctrl+X
Name = mniCopy, Caption = '&Copy', ShortCut = Ctrl+C
Name = mniPaste, Caption = '&Paste', ShortCut = Ctrl+V
Name = mniHelp, Caption = '&Help'
Name = mniAbout, Caption = '&About...'
Nu de UI (User Interface) compleet is, kunnen we de benodigde functionaliteit toevoegen aan de menu onderdelen. Elk menu onderdeel heeft een OnClick event dat geactiveerd wordt als het onderdeel wordt geselecteerd. We gaan OnClick event handlers schrijven voor alle in aanmerking komende menu onderdelen die allemaal de vereiste code bevatten. U kunt een OnClick event handler maken voor een TMenuItem component door gebruik te maken van de Object Inspector's Events pagina, waarbij u dubbel klikt in de rechter kolom naast de aanduiding OnClick. U kunt ook dubbel klikken op het passende menu onderdeel in de Menu Designer.
We nemen de gemakkelijkste eerst: File | Exit en Help | About.... Eerst maken we OnClick event handlers voor allebei. De eerste moet de applicatie afsluiten. Alle CLX applicaties hebben een hoofdformulier (standaard is dat het eerste formulier in het project) en als dat formulier wordt gesloten, stopt de hele applicatie (in tegenstelling tot alleen een formulier dat wordt gesloten). We kunnen daar ons voordeel mee doen door de Close method van het hoofdformulier aan te roepen, waardoor dus het hele programma zal sluiten. Het enige formulier in dit project (en tegelijk derhalve het hoofdformulier) is frmTextEditor. Dus om de applicatie af te sluiten kan de event handler van het menu onderdeel het commando geven:
frmTextEditor.Close
Maar we kunnen nog iets beters doen. Al deze event handlers zijn ontworpen om het gedrag van diverse componenten te bedienen, maar ze zijn allemaal geimplementeerd als methods van de formulier klasse. Dus alle event handlers zijn automatisch in de scope van het formulier, en vandaar kunnen we ook simpeltjes schrijven:
Close
In het geval van het About menu onderdeel kunnen we een simpel meldingsvenster tonen, zodat de twee event handlers er als volgt uitzien:
procedure TfrmTextEditor.mniExitClick(Sender: TObject);
begin
Close
end;
procedure TfrmTextEditor.mniAboutClick(Sender: TObject);
begin
ShowMessage('Text Editor Application')
end;
Merk op dat terwijl u de parameters invoert in een parameter lijst, een behulpzame tiplijst u laat zien wat de formele declaratie van de argumenten is (zie Figuur 7). In dit geval vertelt hij ons, dat ShowMessage overloaded is en biedt hij ons een keus tussen het doorgeven van een of twee parameters. Dit heet de Code Parameters tooltip, en hij wordt automagisch aangeroepen als u een parameter lijst invoert door het intypen van een openings aanhalingsteken. U kunt hem ook op elk gewenst moment laten opduiken (aangenomen dat u in een parameter lijst bent) met Ctrl+Shift+Space.
Figuur 7: Code Parameters: een behulpzame herinnering aan de vereiste argumenten
In volgorde van eenvoud komen dan de menu onderdelen van het Edit menu. Clipboard faciliteiten worden beschikbaar door bepaalde methods van de memo beheersroutines, zodat de event handlers er als volgt uit zien:
procedure TfrmTextEditor.mniCutClick(Sender: TObject);
begin
memText.CutToClipboard
end;
procedure TfrmTextEditor.mniCopyClick(Sender: TObject);
begin
memText.CopyToClipboard
end;
procedure TfrmTextEditor.mniPasteClick(Sender: TObject);
begin
memText.PasteFromClipboard
end;
U zult uiteraard opmerken dat er terwijl u deze code invoert een ander venster opduikt, terwijl u de punt invult na de naam van de memo. Dit is het Code Completion venster, dat u aanbiedt de identifiers voor u in te typen. Figuur 8 toont u hoe de PasteFromClipboard method wordt geselecteerd in het Code Completion venster - door op Enter te drukken wordt dit voor u ingevuld. U kunt de Code Completion bijna overal oproepen, niet alleen voor het benaderen van methods en eigenschappen van componenten door het indrukken van Ctrl+Space.
Figuur 8: Code Completion: een geheugensteun en typehulp in enen
Alles wat over is zijn de New, Open en Save menu onderdelen op het File menu. Het is nuttig om bij te houden of de gebruiker veranderingen in het memo heeft aangebracht, zodat we kunnen vragen of hij dat wil bewaren als hij kiest voor File | New, bijvoorbeeld. Dit wordt gedaan door het gebruik van een Boolean vlag variabele, gedefinieerd als een data veld in de formulier klasse. De vlag wordt niet gebruikt buiten het formulier, maar hij is wel nodig binnen verschillende event handlers, zodat het logisch is hem te definieren als deel van het formulier.
Hetzelfde geldt voor de naam van het bestand dat bewerkt wordt. Het is nuttig dat bij te houden terwijl de gebruiker bestanden opent. Dit wordt ook gedefinieerd als onderdeel van de formulier klasse. Op dit moment is de formulier kalsse een type definitie die er als volgt uitziet, naar de top van de unit (in de interface sectie van de unit):
type
TfrmTextEditor = class(TForm)
mnuMainMenu: TMainMenu;
memText: TMemo;
dlgOpen: TOpenDialog;
dlgSave: TSaveDialog;
mniFile: TMenuItem;
mniNew: TMenuItem;
...
mniAbout: TMenuItem;
procedure mniExitClick(Sender: TObject);
...
procedure mniPasteClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
Kylix voegt declaraties toe voor alle componenten en event handlers aan de kop van de klasse. We kunnen extra data velden toevoegen, methods of eigenschappen in hetzij de private sectie (als we niet willen dat code van andere formulieren zich daar toegang toe kan verschaffen) of de publieke sectie (als het ons niet kan schelen als andere formulieren de code ook gebruiken). Omdat dit een enkele formulier toepassing is, maakt het weinig uit welke sectie we kiezen, dus laten we hem willekeurig toevoegen aan de prive sectie van de formulier klasse, op deze manier:
private
{ Private declarations }
FModified: Boolean;
FFileName: WideString;
Merk op dat het F voorvoegsel algemeen wordt gebruikt om een prive data veld aan te duiden. Merk ook op dat de bestandsnaam wordt opgeslagen in een WideString, wat een string is gemaakt van WideChar karakters (Unicode karakters), om ook bestandsnamen te kunnen bevatten met internationale tekens erin. Als u alleen simpele karakters in een string wenst, zou u het type String kunnen gebruiken (of AnsiString, wat een equivalent is), dat bestaat uit karakters van het type Char (of AnsiChar).
Als ons formulier (of welk object ook) tijdens het draaien wordt aangemaakt, zullen alle datavelden worden geinitialiseerd met nul-byte waardes, zodat FModified wordt geinitialiseerd als False, en FFileName wordt geinitialiseerd als een lege string (dit bespaart ons het zelf moeten initialiseren van de velden).
Wanneer de gebruiker een nieuw bestand wenst te openen, zou het leuk zijn om de bestandsnaam op de programmabalk te kunnen schrijven. Als de gebruiker een nieuw bestand maakt (wat ook het geval is als het programma start) zou de menubalk dit ook kunnen aangeven. Om dit te bewerkstelligen kunnen we de vereiste code plaatsen in een nieuwe methode gedefinieerd in de formulier klasse, die dan kan worden aangeroepen vanwaar hij maar nodig is. Voor een method die een nieuwe bestandsnaam opneemt en er iets mee doet, maar geen waarde retourneert, kunnen we een procedure declareren die een string parameter opneemt (als een waarde moet worden teruggegeven kunnen we een functie declareren). Breid de prive sectie van de formulier klasse als volgt uit:
private
{ Private declarations }
FModified: Boolean;
FFileName: WideString;
procedure SetFileName(const FileName: WideString);
Hiermee wordt een declaratie toegevoegd van een procedure methode genaamd SetFileName, die een WideString als argument opneemt, aangeduid als FileName. De const modifier doet twee dingen: hij zorgt dat de string efficient wordt doorgegeven en zorgt ook dat de methode de string niet kan veranderen. Om de methode te implementeren, voegt u deze code toe aan het onderste deel van de unit, waar de event handlers staan (de implementatie sectie van de unit). Het opzetten van een methode is derhalve een twee stappen proces: declareer de methode in de klasse en implementeer de methode dan in de implementatie sectie.
procedure TfrmTextEditor.SetFileName(const FileName: WideString);
begin
FFileName := FileName;
if Length(FFileName) = 0 then
Caption := ''
else
Caption := FFileName
end;
Hiermee wordt de doorgegeven bestandsnaam
opgeslagen in het prive data veld van het formulier, daarna wordt de bestandsnaam
geschreven als er een is, en anders wordt hij op de menubalk van het formulier
gezet. We moeten deze method aanroepen zo snel als het formulier is aangemaakt
(wat we kunnen doen via de
Je kunt een OnCreate event handler maken voor het formulier middels de Object Inspector, zoals gebruikelijk, of door het dubbelklikken van de achtergrond van de Form Designer (als hij niet verstopt is door de componenten, zoals nu het geval is). Het dubbelklikken van veel componenten mmaakt een event handler voor wat beschouwd wordt als de standaard (of de beste) event voor die component. Voor een knop of een menu onderdeel is dat OnClick, voor een memo of een edit controle is dat OnChange en voor een formulier is het OnCreate.
Om het formulier te selecteren zodat een event handler aangemaakt kan worden, gebruikt u of de instance lijst van de Object Inspector (de uittreklijst aan de bovenkant) of kies het memo op de Form Designer en druk op Escape. Escape selecteert de op dat moment geselecteerde parent control van de component, wat in het geval van het memo het formulier is.
procedure TfrmTextEditor.FormCreate(Sender: TObject);
begin
//Haal het formulier om te melden dat we met een nieuw bestand beginnen
SetFileName(FFileName)
end;
Een andere huishoudelijke taak die we nu kunnen afhandelen is het stellen van FModified op True telkens wanneer de inhoud van het memo is veranderd (daarvoor is een OnChange event handler nodig voor het memo, welke kan worden aangemaakt door er dubbel op te klikken):
procedure TfrmTextEditor.memTextChange(Sender: TObject);
begin
FModified := True
end;
Nu kunnen we verder gaan met de New/Open/Save menu onderdelen; laten we eerst Save afhandelen. Als de gebruiker het bestand wil opslaan, moeten we eerst zien of we een geldige bestandsnaam opgeslagen hebben in FFileName (een lengte van nul betekent dat dat niet het geval is!). Zo niet, dan roepen we de save dialoog aan (door zijn Execute method) om de gebruiker toe te staan een bestandsnaam te kiezen, en aannemend dat de gebruiker de save dialoog niet heeft onderbroken (wat Execute ertoe brengt om False te retourneren), kunnen we de bestandsnaam opslaan in het data veld. Aannemend dat we een geldige bestandsnaam hebben, kunnen we de inhoud van het memo opslaan onder de bestandsnaam door het aanroepen van de SaveToFile method van het TStrings object opgeslagen in de Lines eigenschap van het memo.
procedure TfrmTextEditor.mniSaveClick(Sender: TObject);
begin
if Length(FFileName) = 0 then
if dlgSave.Execute then
SetFileName(dlgSave.FileName);
if Length(FFileName) > 0 then
begin
memText.Lines.SaveToFile(FFileName);
FModified := False
end
end;
Merk op dat net als in C/C++, meerdere statements tot een geheel gemaakt kunnen worden in een compound statement (bijvoorbeeld door meer statements te laten uitvoeren als een voorwaarde geldig is), door ze te omgeven met passende markeringen: begin en end in het geval van Delphi's ObjectPascal.
Maar wat nu als de gebruiker een nieuw, leeg document wil maken? Als er veranderingen zijn geweest in het huidige exemplaar moeten we eerst aanbieden het document te bewaren. Daarna, aangenomen dat alles bewaard is, kunnen we de bestandsnaam wissen, de memo leeg maken en de veranderingsvlag uitschakelen. De vereiste event handler ziet er als volgt uit:
procedure TfrmTextEditor.mniNewClick(Sender: TObject);
begin
if FModified then
case MessageDlg('Veranderingen bewaren?', mtConfirmation, [mbYes, mbNo, mbCancel], 0) of
mrYes: mniSaveClick(mniSave);
mrNo: FModified := False;
mrCancel: Exit;
end;
if not FModified then
begin
SetFileName('');
memText.Clear;
FModified := False
end
end;
MessageDlg wordt gebruikt om een bevestigingsdialoog op te zetten met drie knoppen, zoals aangegeven in de derde parameter, die bestaat uit een set genummerde waardes. Het meldingsvenster heeft een Yes, No en Cancel knop aan boord.
Als de gebruiker drukt op Yes (wat MessageDlg ertoe brengt om mrYes te retourneren), voert de code handmatig het Save menu onderdeel OnClick event handler uit (die tenslotte is geimplementeerd als een andere formulier method). Als de gebruiker drukt op No, geven we aan dat er niets te bewaren valt door de veranderingsvlag te zetten op False. Als de gebruiker drukt op Cancel, stappen we uit de event handler, en laten het oude bestand dus zoals het was. Als de gebruiker drukt op Yes of No, gaat de code naar de volgende voorwaarde: als er geen veranderingen te bewaren zijn, wordt alles gewist.
Nu resteert het Open menu onderdeel. Als dit wordt gekozen moet de open dialoog worden aangeroepen om de gewenste bestandsnaam op te halen. Vervolgens, als er nog te verwerken veranderingen zijn in het oude bestand, moet de gebruiker de gelegenheid krijgen die te bewaren - dat gebeurt door activering van de OnClick event handler van het New menu onderdeel. Aangenomen dat de gebruiker niet bij het oude bestand wil blijven, wordt het nieuwe bestand geladen in de memo's Lines eigenschap, de bestandsnaam wordt ingesteld en de veranderingsvlag weer op nul gezet.
procedure TfrmTextEditor.mniOpenClick(Sender: TObject);
begin
if dlgOpen.Execute then
begin
mniNewClick(mniNew);
if not FModified then
begin
memText.Lines.LoadFromFile(dlgOpen.FileName);
SetFileName(dlgOpen.FileName);
FModified := False
end
end
end;
Een laatste aardigheidje kunnen we toevoegen door te controleren of er niet bewaarde wijzigingen zijn als het programma wordt afgesloten (OnCloseQuery van het hoofdformulier regelt deze situatie). De gebruiker moet veranderingen kunnen bewaren, weggooien of afbreken (als hij langer wil nadenken over wat hij wil doen). We gebruiken dan weer het gedrag van het New menu onderdeel om de gebruiker te vragen of hij wil bewaren of niet.
procedure TfrmTextEditor.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
begin
mniNewClick(mniNew);
if FModified then
CanClose := False
end;
Als de gebruiker het afsluiten wil onderbreken, laat de New menu onderdeel even handler FModified ingesteld op True, en zetten we de CanClose parameter op False. CanClose wordt gedeclareerd met een var modifier, wat wil zeggen dat een var parameter wordt doorgegeven (pass-by-reference parameter). Standaard is deze True, wat wil zeggen dat het formulier gesloten kan worden, maar als we hem op False zetten blijft het formulier open.
Een Kylix project bestaat uit een hele serie bestanden, waarvan een aantal erg belangrijk is (en dus ook niet gewist moet worden!) en waarvan andere tijdens het bewaren of het compileren worden herschreven. De bestanden krijgen namen gebaseerd op hetzij de actuele projectnaam, of de bron module (of liever unit om de correcte term te gebruiken) waar ze bijhoren.
Als u Kylix start, gebruikt hij de standaard projectnaam Project1 en de standaard unit naam Unit1. Het projectbestand staat voor de hele applicatie, terwijl de unit vooral de broncode bevat voor een individueel formulier. Echter kan een unit ook niet gerelateerd zijn aan een formulier, omdat hij (bijvoorbeeld) ook elders bruikbare bibliotheek code bevat.
Hier is een lijst van de meer algemene bestanden die u kunt tegenkomen, gebaseerd op de standaard Kylix nomenclatuur:
| Bestandsnaam | Beschrijving |
| Project1.dpr | Het project bronbestand, toegankelijk via Project | View Source. Het bestand bevat de code, die alle standaard forumulieren genereert en zorgt dat het programma gaat draaien. Ook bevat hij verwijzingen naar alle bestanden die bij het project horen, inclusief de padinformatie als dat nodig is. De historische extensie staat voor Delphi Project |
| Project1.res | Het project resourcebestand, die in Kylix niet gebruikt wordt (Delphi gebruikt hem voor het opslaan van de programma icoon en versie informatie) |
| Project1.kof | De Kylix Options File, wat een tekstmatig configuratie bestand is onderhouden en gebruikt door de IDE om de instellingen van de project opties dialoog op te slaan |
| Project1.conf | De equivalent van het .kof bestand voor de command-regel compiler (dcc). U kunt kant en klare Kylix programma's maken van script bestanden middels de commando-regel hulpprogramma's, bijvoorbeeld: dcc Project1.dpr |
| Unit1.pas | Een Delphi PAScal unit (bron module). Elk formulier heeft een bijbehorende unit (genaamd formulier unit) die bevat de formulier klasse definitie en alle event handlers van het formulier en de componenten die daar op zijn geplaatst |
| Unit1.xfm | Het formulier bestand waarvan de geassocieerde broncode gevonden kan worden in Unit1.pas. Standaard zijn dit tekstbestanden die direct kunnen worden bewerkt als dat nodig is. Dit kan aangegeven worden met een voorkeur in het environment options dialog (New forms as text) |
| Unit1.dcu | Een gecompileerde versie van Unit1.pas (Delphi compiled unit) |
| Project1.~dpr | Een backup van het project bestand. Het aanmaken van backups wordt bestuurd door een editor optie (kies Tools | Editor Options..., ga naar de Display pagina en de optie is Create backup file) |
| Unit1.~pas | Een backup van de formulier unit |
| Unit1.~xfm | Een backup van het formulier bestand |
| Project1 | De resulterende executable gecompileerd van uw project en bijbehorende bestanden |
De belangrijkste bestanden om te bewaren zijn de .dpr, .pas en de .xfm bestanden, omdat zij de mogelijkheden van het programma bepalen. Echter, als u instellingen verandert in de project opties dialoog, dient u ook de bestanden .kof en .conf als belangrijk te beschouwen.
Daarmee is dit simpele teksteditor project voltooid. Tenminste voor nu. Mogelijk kunnen we hem in het volgende hoofdstuk met een aantal opties verbeteren, en misschien wel met een knoppen- en een statusbalk. Tot we daar aan toe zijn: veel programmeerplezier!
Brian Long werkte eertijds voor Borland UK, waar hij een heel aantal verplichtingen had waaronder Technische Ondersteuning voor alle programmeer applicaties. Sinds hij in 1995 wegging, heeft Brian training en consultancy diensten verleend aan de Delphi en C++Builder gemeenschappen, en de zich nieuw vormende Kylix gemeenschap.
Als u training nodig hebt in deze producten, of oplossingen moet hebben voor problemen ermee, neem dan contact op, of bezoek Brian's Web site.
Behalve het schrijven van een Borland Pascal probleem-oplossend book gepubliceerd in 1994, is Brian een regelmatige columnist in The Delphi Magazine en heeft hij talloze artikelen gepubliceerd in Developer's Review, Computing, Delphi Developer's Journal en EXE Magazine. Hij werd genomineerd voor de Spirit of Delphi 2000 prijs.
In zijn vrije tijd (en tijdens het wachten op de compilatie van zijn C++ programma's) heeft Brian zichzelf de kunst van het jongleren aangeleerd en het maken van opblaasbare origami papieren kikkers.