In de DOS-wereld van de jaren tachtig en negentig had je een probleem: je computer was een black box, maar je besturingssysteem was extreem kaal. Er was nog geen plug & play. Geen Windows dat je drivers voor je regelt. Je moest alles zelf regelen, maar je wist nauwelijks wat je had en je kon nergens bij. Welke CPU zit erin? Hoeveel geheugen heb je? Welke IRQ gebruikt je geluidskaart? DOS vertelde je dat niet zomaar. Je moest het zelf uitzoeken. En als je iets wilde aanpassen, in BIOS, CMOS-geheugen, op je disks: DOS hielp je niet. Dus dat deed je met utilities, kleine programma's die geen andere functie hadden dan het beheren van je systeem.

De onbetwiste koning van die utilities was Peter Norton. Zijn Norton Utilities (NU) was een verzameling gereedschap die elke serieuze pc-gebruiker op zijn harde schijf had staan. Denk aan UnErase om per ongeluk gewiste bestanden terug te halen, Disk Doctor om beschadigde file systems te repareren en Speed Disk voor defragmentatie. Daar zat ook System Information (SI) bij: een tool die je precies vertelde wat er in je machine zat. CPU-type, geheugen, video-adapter, seriële poorten, alles.

Ik ga mijn eigen versie bouwen: SystemInformation.PAS. Niet zo uitgebreid als Norton SI, maar wel met dezelfde filosofie: laat zien wat er in de machine zit, op een manier die bruikbaar en overzichtelijk is. En ik bouw het in Pascal 6.0 met Turbo Vision, omdat dat een nette interface geeft op een manier die conceptueel de tijd van DOS ruimschoots heeft overleefd. Wat ik vandaag doe is het frame neerzetten. Alleen de structuur, geen invulling. Denk aan een bouwwerk waar je eerst de draagmuren plaatst, voordat je de kamers gaat inrichten. Hier is de volledige code:

Program SysInfo;

{$G+}

Uses
  Objects, Drivers, Views, Menus, Dialogs, App;

Type
  TSysInfoApp = Object(TApplication)
    Procedure InitMenuBar; Virtual;
    Procedure HandleEvent(Var Event: TEvent); Virtual;
    Procedure ShowSysInfo;
  End;

Const
  cmSysInfo = 100; 

Procedure TSysInfoApp.InitMenuBar;
Begin
  { komt in aflevering 27 }
End; 

Procedure TSysInfoApp.HandleEvent(Var Event: TEvent);
Begin
  { komt in aflevering 27 }
End;

Procedure TSysInfoApp.ShowSysInfo;
Begin
  { komt in aflevering 28 }
End;

Var
  SysInfoApp: TSysInfoApp;

Begin
  SysInfoApp.Init;
  SysInfoApp.Run;
  SysInfoApp.Done;
End.

Dat is het. Dit compileert en draait, maar doet nog niets zinnigs. Laten we de onderdelen langs lopen.

Object-overerving

TSysInfoApp = Object(TApplication) betekent: we maken een nieuw object-type, dat alle eigenschappen en methoden van TApplication overneemt en daar onze eigen dingen aan toevoegt. TApplication zit in de App unit van Turbo Vision en bevat alle basismechaniek: de event loop, schermafhandeling, menu's, dialogen. Wij hoeven dat niet opnieuw te bouwen, we breiden het alleen uit.

Die drie methods die we declareren - InitMenuBar, HandleEvent, ShowSysInfo - zijn onze uitbreidingen. De eerste twee zijn Virtual, wat betekent dat we een bestaande method van TApplication overschrijven met onze eigen versie. ShowSysInfo is helemaal nieuw.

Event-driven

Het hele systeem draait om events: dingen die gebeuren. Een toetsaanslag, een muisklik, een menu-keuze. In plaats van dat wij een lus schrijven die constant checkt "is er een toets ingedrukt?", doet Turbo Vision dat voor ons. Wij schrijven alleen code voor "als dit event gebeurt, doe dan dat".

HandleEvent is de centrale verkeersregelaar. Elk event dat binnenkomt, gaat daar langs. Wij kijken of het een event is waar we iets mee moeten (bijvoorbeeld het commando cmSysInfo). En als dat zo is, voeren we de bijbehorende actie uit (in dit geval ShowSysInfo aanroepen).

Die cmSysInfo constante is gewoon een getal (100) dat we als label gebruiken. Als de gebruiker een bepaald menu-item kiest, stuurt het menu een event met dat commando-nummer. HandleEvent vangt dat op en weet dan: ah, de gebruiker wil systeeminformatie zien.

Het hoofdprogramma

De laatste regels zijn het patroon dat je in vrijwel elk Turbo Vision programma ziet:

SysInfoApp.Init;

SysInfoApp.Run;

SysInfoApp.Done;

Init bereidt alles voor: detecteert de video hardware, zet de event queue op, tekent het scherm. Run start de event loop: vanaf dat moment luistert het programma naar input en reageert op events. Die loop blijft draaien totdat de gebruiker het programma afsluit. Done ruimt netjes op: herstelt de oude video mode, geeft geheugen vrij.

Dit patroon - initialiseren, draaien, opruimen - is niet specifiek voor Pascal of Turbo Vision. Je ziet het ook in moderne GUI frameworks in C++, Rust, Python. De techniek is veranderd, het principe niet.

Waarom zo opbouwen?

Je zou kunnen denken: waarom al die moeite? Kunnen we niet gewoon een simpel programmaatje schrijven dat wat tekst op het scherm zet? Dat kan. Maar dan bouwen we een wegwerpscriptje. Wat we hier neerzetten is een uitbreidbare applicatie. Als we straks meer functies willen toevoegen, zoals informatie over geheugen, schijven, poorten, dan hoeven we alleen maar een nieuw menu-item en een nieuwe ShowXxx-procedure toe te voegen. De hele infrastructuur (menu's, event handling, dialogen) staat al. We hoeven het wiel niet opnieuw uit te vinden.

En die infrastructuur werkt consistent. Een menu gedraagt zich altijd hetzelfde. Een dialoog heeft altijd dezelfde bediening. Niet alleen hier, maar in ieder programma dat ooit geschreven is met Turbo Vision. Je krijgt dus op een efficiente manier een interface die meteen begrepen wordt door gebruikers. Zoiets als MacOS en Windows dus, maar dan wat eerder.