Hoi Gerard!

De liefde voor Pascal is bij mij van de Turbo Pascal tijd (heb wat met Pascal op een Amiga en een Mac gerommeld, maar de echte doorbrak kwam bij Turbo Pascal).

Als eerste zou ik aan de slag gaan met Lazarus, welke op Free Pascal gebaseerd is - misschien heb je dit al geïnstalleerd staan. Lazarus is gratis en staat het zelfs toe om jouw programma, zonder al te veel moeilijkheden, te her-compileren onder Linux of MacOS X.
Zelfs als je geen Windows GUI wilt gebruiken, dan is dit al een makkelijke werk omgeving - je kunt hier namelijk ook zogenaamde Console applicaties bouwen (zoals je nu al doet met Free Pascal).

Tweede punt is dat de interactie met de gebruiker wat anders gaat en sterker object georiënteerd is, maar niet gevreesd - het is makkelijk dan je denkt. De meeste code wordt door Lazarus zelf aangemaakt terwijl je de GUI bouwt.

Het opbouwen van de GUI is een kwestie van klikken, plaatsen en schuiven. Zodra je dat gedaan hebt kun je het e.e.a. aan de GUI gaan koppelen.
Het belangrijkste deel is natuurlijk een window, wat in Delphi/Lazarus een Form genoemd wordt. Bij het aanmaken van een applicatie wordt er meteen al een voor je aangemaakt.

Vervolgens plaatsje componenten op dit venster, b.v. een button (TButton), edit box (TEdit), etc.
De eerste keer is het zeker aan te raden om wat daarmee te spelen, zodat je een gevoel krijgt bij hoe het e.e.a. geplaatst kan worden.
Start zo'n programma ook af en toe even om te kijken wat het doet. (F9 geloof ik onder Windows, Command+R onder Mac)

Lazarus (en Delphi) kent behoorlijk wat leuke zaken zoals het automatisch uitlijnen en schalen, maar daar moet je in het begin nog even niet naar kijken - dat verwart het e.e.a. te snel.

Na het plaatsen van componenten (de zogenaamde visual components - de componenten die zichtbaar zullen zijn) moeten we kijken naar events. De events die je het meeste gebruikt zal waarschijnlijk het "OnClick" event zijn.

Als je b.v. een formulier bouwt, dan zul je invoer velden (editbox), tekst velden (memo), aanvink componenten (checkbox, radiobutton) en knoppen (button) veel gebruiken. Zet ze gerust op het venster (Form), en start het programma. Je zult zien dat veel zaken al voor je geregeld zijn zoals het intypen van tekst, kopiëren en plakken, indrukken van knoppen, etc. Dit werk allemaal al zonder dat je een regel code hoefde te typen.

Als ik aan een formulier denk, dan neem ik voor het gemak even aan dat er het e.e.a. ingevuld dient te worden en dat er een "submit" (verstuur) knop gaat komen. Het invul deel is dus makkelijk, en de knop ook, maar achter de knop moeten we natuurlijk iets van code hangen om het e.e.a. te controleren en te versturen. Dit gaat via het "OnClick" event van de knop (button). Dubbel klik op de knop op het formulier en een stukje code wordt al klaar gezet voor je. Je hoeft hier alleen maar het "slimme" deel toe te voegen.

In dit "slimme" deel lezen we dan de invoer velden uit (en later bouw je daar waarschijnlijk ook de verificatie in).

Het lezen van een editbox bijvoorbeeld gaat via het uitlezen van de "text" property. Properties zijn onderdeel van het betreffende object, de TEdit box heeft er een aantal, zoals locatie en omvang (top, left, width, height), kleur (color), ingevoerde tekst (text), etc.
Iets soortgelijks geldt ook voor de andere componenten.

Om nu niet een hele cursus te schrijven (wat overigens misschien wel een goed idee is voor een artikeltje!), laat ik je hier even mee spelen - er kan weinig fout gaan. Stel gerust vragen ...!

Wat andere bronnen hierover:

Engelstalig:

- Start Programming Using Object Pascal (ik denk dat je de eerste hoofdstukken over kunt slaan)
- Lazarus Form Tutorial (gaat iets te snel de diepte in, maar het geeft een idee - in het Nederlands)
- Developing a GUI application with Lazarus (slaat soms wat belangrijke details over en gaat op andere momenten wat diep)

Ik zie dat de Nederlandse vertegenwoordiging wat dit onderwerp betreft maar wat magertjes is ... PCM is een serie gestart, maar alleen Deel 1 blijkt online beschikbaar. Mocht je lid zijn van de HCC, dan vindt je daar ook een Pascal gebruikersgroep.

Zoals eerder gezegd: speel er een beetje mee, en stel gerust vragen!

Dank Hans,

Zal proberen met Lazarus te gaan werken. Echter mijn eerdere poging was dat ik vond dat ik door Lazerus de controle over het programmeren verloor. Het leek te veel taken over te nemen.

Ik laat wel weer weten hoe het verder gaat.

Ik ben destijds vanuit Turbo Pascal naar Delphi overgeschakeld ... initieel was het even wennen, maar intussen weet ik niet beter .

Zoals gezegd: vraag gerust (geen haast) ...

Het eerste form misluk al.

Moet echt gaan zoeken hoe dit werkt. Dacht een simpel form te bouwen met een koptekst. veldje met label en een intik veldje.

Echter kreeg fout melding op foutmelding.

Kap ee nu ff mee. Of zal toch echt de boeken in moeten. Als je kan zou je me kunnen helpen door dat simpele prog te sturen, dan zie ik de code en kan ik verder. als je wil "hengst@euronet.nl". Dank

Hi Hengst,

De eerste stap kan wat tegen vallen inderdaad - vooral ook omdat het hele denk patroon even omgezet moet worden.

Je kunt jouw code eventueel in dit forum meesturen als attachment, en ik kan straks even proberen een simpel voorbeeld in elkaar te zetten voor je, die ik dan ook als attachment eraan hang. Moet ik wel even zeker weten of je onder b.v. Windows werkt of niet. (ivm compiler settings, omdat ik zelf op een Mac werk - dus moet ik even iets in elkaar zetten onder een virtuele machine mocht je onder Windows werken).

Hoi Hans,

Werk onder windows.

Dank

OK, dit heb ik gedaan (zie attachment):

1. In Lazarus, ga naar FILE - NEW en kies APPLICATION.

Er zal zich een Form (window) openen, en een "lege" editor met wat voorgekauwde code.

N.b.: Iets waar ik zelf heel erg aan moest wennen is dat Lazarus nooit geopend worden zonder een open project te openen.
D.w.z. dat het altijd het laatst gebruikte project opent of  het begint een nieuw leeg project (waardoor je deze stap dus zou kunt overslaan).

unit Unit1;
{$mode objfpc}{$H+}
interface
uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs;
type
  TForm1 = class(TForm)
  private
    { private declarations }
  public
    { public declarations }
  end;
var
  Form1: TForm1;
implementation
{$R *.lfm}
end.

2. Vervolgens heb ik een Tedit, TButton en een TLabel op de Form geplaatst.

Optioneel:

* Voor TEdit heb ik in object inspector window, het veld Text leeg gemaakt,
* Voor TButton het veld Caption aangepast naar "klik hier",
* En voor TLabel de caption op "nog niks" gezet.

3. Ik heb vervolgens ge-dubbel-klikt op de TButton wat een beetje code genereerd:

procedure TForm1.Button1Click(Sender: TObject);
begin
end; 

4. In dit voorbeeld wil ik dat de gebruiker wat invult en dat de Label na het drukken op de knop de tekst overneemt, mits de TEdit niet leeg is.

procedure TForm1.Button1Click(Sender: TObject);
begin
  if Edit1.Text<>'' then Label1.Caption:=Edit1.Text;
end;

Super simpel, dus ik weet niet hoever je zou willen dat ik door ga.

In het ZIP bestand, dubbel klik het project1.lpi bestand om Lazarus te starten.
Je kunt ook eerst Lazarus openen en dan het bestand met FILE - OPEN openen natuurlijk.

Oke dank.

Vraagje: wordt dus elke button, veldje in het formulier een aparte procedure?

Dus als ik mijn pascal programma inclusief alle const en var en data en interface met de BD in dit programma erbij zet, moet ik button voor button aanmaken om het formulier te vullen.

Het werkt wel verlossend voor de correctie gedeelte. Das heel mooi.

Zie ook dat het te kleuren is e.d.

2e vraag ik werk op 2 plekken (2 comnputers) is het één file om mee te nemen of veel meer.

Dank voor je hulp.

Gerard

Buttons kunnen een procedure delen, maar over het algemeen heeft iedere button zijn eigen functie.

Als voorbeeld, stel dat je 2 buttons hebt, Button1 en Button2.
In de Object Inspector kun je zien dat als je 2x op Button1 hebt geklikt, dat er bij het veld "OnClick" de procedure naam "Button1OnClick". 

Bij Button2 zou je in dat veld dus ook "Button1OnClick" kunnen invullen, waardoor beide buttons dezelfde procedure aanroepen, wat niet veel gedaan wordt maar handig kan zijn als de functies veel code delen.

Dus: standaard, krijgt iedere button zijn eigen functie, tenzij je er mee gaat rommelen ...

Bij een gedeelde procedure wordt het dan wel zaak om dat correct af te vangen, indien beiden buttons net even anders werken, b.v.:

procedure TForm1.Button1Click(Sender: TObject);
begin
  if Sender=Button1 then 
    begin
      ... 
    end
  else if Sender=Button2 then
    begin
      ... 
    end 
  else exit; // niet echt nodig, procedure verlaten indien een ander object hierheen gaat
   
// code die beiden delen hier:
   ....
end;

Uiteraard is het netter om een procedure of functie te schrijven die het gezamenlijke werk afhandelt.

Zoals je hierboven ziet kun je met de variable "Sender" bepalen welk object deze functie heeft aangeroepen - als je geavanceerdere dingen gaat bouwen dan kan dat handig zijn.

Procedures en Functies

Even handig om te weten, is dat het window (de Form) een "object" is en je dus daaraan functies, procedures en variabelen kunt hangen.
Dat gebeurt in de declaratie boven in. Als je naar het begin scrolled, zie je waarschijnlijk al wat ik bedoel.
Maar ... je kunt ze ook gewoon definiëren zoals je "vroeger" in TP deed.

Bestanden ...

Wat ik over het algemeen doe is mijn project in een specifieke directory opslaan en na wat rommelen de hele directory zip en meeneem. Dus de .PAS, .LPI, .LPR, .LPS, .LFM, .RES etc meenemen. 

LPI, LPS en LPR (LPR is een Pascal bestand, de anderen zijn XML bestanden met instellingen) zijn project bestanden,
LFM bestanden zijn de Forms en componenten op de forms,
RES zijn resource bestanden (zoals afbeeldingen etc),
en de PAS bestanden zijn de oude bekenden.

Soms laat ik de EXE en de BAK directory weg als ik iets mee ga nemen naar een andere computer, of als ik een backup maak.

Hopelijk helpt je dit een beetje op weg ... het wordt op den duur wel handig om de individuele bestanden eens door te kijken met een tekst editor (Notepad of zo), zodat je een idee krijgt waar wat zit ...

Hoi Hans,

Dank voor de start.

Zie hier wat het wordt. Ziet er wel naar uit alles opnieuw te moeten opzetten.

Vraagje nog: waar laat ik me constanten en var die over het hele programma gebruik worden.

Veel van de uitkomsten van het invullen zijn weer onderdeel van een andere variabele.

Tot nu toe krijg ik alleen de variabele in de functies en procedures neergezet, maar die moeten eruit. Wil niet alles via externe files laten lopen.

Dank voor alles.

Gerard

Globale Variabelen

Je kunt globale variabelen op 2 manieren definiëren.

1. Als onderdeel van TForm (mijn voorkeur).

unit Unit1;
{$mode objfpc}{$H+}
interface
uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs;
type
  TForm1 = class(TForm)
  private
    { private declarations }
    MijnPriveVar : integer;
  public
    { public declarations }
    MijnPublicVar : integer;
  end;
var
  Form1: TForm1;
implementation
{$R *.lfm}
end.

Hierbij wordt de variabele een "property" (zeg maar) van een TForm object. Je maakt er maar 1 dus verwarring kan er niet zijn, en de variabelen zijn in iedere TForm1 procedure/functie te gebruiken als "MijnPriveVar" en "MijnPublicVar".

Het verschil tussen deze twee is dat "MijnPublicVar" alleen in TForm1 procedures te zien zijn, dus een andere procedure van een ander object kan deze variabele dus niet zien. Dit in tegenstelling to de "public" variant, welke we gezien kan worden.

Ik zou voorlopig met de private versie werken tot je wat verder gevorderd bent en b.v. met meerder Forms gaat werken die met elkaar moeten communiceren.

2) Je kunt globale variabelen ook toevoegen aan de Form1 declaratie - maar dat zou ik vermijden. Dit kan ongewenste neven effecten hebben.

var
  Form1: TForm1;
  MijnVar : integer;

Constanten

Je kunt globale constanten op verschillende plaatsen definiëren, zoals in TP, en ik doe dat meestal na de var Form1 declaratie.

var
  Form1: TForm1;
const
  MijnConst = 1;

Overigens handig om te weten dat ik zelden extra bestanden (units) nodig heb. Ik gebruik dat alleen als ik zelf een complexer object heb gebouwd - wat zelden gebeurt - om alles een beetje bij elkaar te houden. Zo'n object kun je dan weer in Form1 definiëren als een property, maar ik denk dat ik nu wat te ver ga voor een eerste poging haha ...

EXE kleiner maken onder Windows

Als je er klaar voor bent zal ik je ook laten zien hoe je een EXE kleiner kunt krijgen met een enkele stap.
De initiële EXE kan best groot worden, maar naarmate je meer code schrijft zal het programma aanzienlijk minder groot worden dan andere omgevingen. Zie ook Size Matters.

Als eerste moeten we in DOS even gaan kijken waar het STRIP commando staat (dit schijnt niet te werken als je 64 bits compileert).

Vaak is dat

c:lazarusfpc2.4.2bini386-win32strip

Je kunt het naar jouw project folder kopieren, of dit pad toevoegen aan de DOS PATH, of kopieren (b.v. C:WINDOWSsystem32), zodat het "altijd" beschikbaar is.

doe dan vervolgens

strip --strip-all jouwproject.exe

Wat de omvang van de EXE significant kan reduceren (iets soortgelijks zie je ook onder Linux en MacOS X).

Uiteraard kun je ook (of daarna) ook nog eens UPX gebruiken, maar ik ben er zelf niet zo'n fan van.
Als DOS gebruiker ken je het vast wel, het comprimeert de EXE en tijden het aanroepen wordt het vanzelf in geheugen uitgepakt.

Blijf gerust vragen! Ik vindt het al leuk dat een andere Turbo Pascaller Delphi of Lazarus probeert! 

Hoi Hans,

Blij dat je dit doet. De reden van de globale variabelen is juist dat ik al doende ben met meerdere forms waar de gegeven info mee moeten.

Dit programma heeft dus 3 invul forms en één uitslag form. Ik wil dus ook (wat nog niet lukt) onderaan elk form een button hebben om naar het andere form te springen. De verzamelde info blijft dan bestaan en kan gewijzigd worden. Op het laatste form zit weer een knop "declareren", waarbij alles in een file definitief wordt weggeschreven en de nodige files worden aangemaakt.

Daar moet ook een button komen, wissen en opnieuw beginnen.

Dus aardig wat te doen om mijn bestaande programma in Lazarus over te schrijven.

Weet je de code om van form naar form te springen en die om alle info te wissel en opnieuw te beginnen?

Dank.

Gerard

Hoi Hans,

Zit toch nog met de structuur.

Ik zou denken in heb de volgende bronnen:

1) Hoofdprogramma (daarin constanten en globale variabelen en de functies door alles gebruikt)
     Ook juist de verzameling van alles.

2) 2 of 3 units met elk een specifiek doel deel van het totale programma.
     Hierin wordt de info verzameld gecontroleerd (zoals BSN Check, Num Check, Postcode CHK, Datum CHK enz welke weer in de hoofdpgr zit)

3) Unit (laatste) ter afsluiting opschoning en wegschrijven van de informatie.

Het lijkt nu dat alles wat ik wijzig in het hoofdprogramma op problemen stuit. Dit komt omdat ik niet weet wat de regel "Application.Run" doet en waar ik hier codes kan toevoegen.

Lijkt wel of ik opnieuw alles moet leren hé. Terwijl ik met me huidige simpele console programma al declaraties wegstuur en goedgekeurd krijg.
Het begint me weer te dagen waarom ik jaren geleden LAZARUS of DelPHI niks vond omdat het code genareerd waarmee ik niks kan.

Geen probleem - graag gedaan ...

Als eerste zou ik in jouw opstelling niet met 3 forms werken, maar met slecht 1 form waarbij de inhoud veranderd als de gebruiker naar de volgende stap gaat of opnieuw wil beginnen.

Er zijn een aantal componenten die daarbij handig kunnen zijn, zoals de TPageControl, welke je onder "Common Controls" kunt vinden.

In feite is dit een soort tabbladen geval waarbij je de gebruiker van tab naar tab kunt laten springen.
Normaal staan de tab's, boven aan de tabbladen, aan maar dat kan ongewenst zijn natuurlijk als je wilt voorkomen dat een gebruiker een beetje heen-en-weer gaat springen. Maar daar kijken we zo even naar.

Als eerste dus een TPageControl op de form plaatsen. Tab bladen maak je aan door met rechts op het component (op de form) te klikken en "Add Page" te kiezen. Voeg er zoveel toe als je nodig hebt.

Mocht je (later) de tabbladen willen verbergen, zet dan de property (van de TPageControl) "ShowTabs" op False. Dit kun je in design mode doen maar ook later als het programma gestart is. Dat laatste gaat het beste in het "OnCreate" event van de TForm met b.v.

PageControl1.ShowTabs:=FALSE;

Tijdens het programmeren vindt ik het zelf wel makkelijk om te tabs te zien en aan te kunnen klikken zodat ik snel op en neer kan.

Op de "pages" of tabbladen kun je gewoon componenten zetten - tijdens het programmeren kun je dit al doen en zien hoe het werkt. 

Een TPageControl heeft een property die aangeeft welk tabblad actief is in "ActivePage". Stel je hebt 3 tabbladen (Tabsheet1 ... TabSheet3) dan kun je als volgt daarmee werken:

if PageControl1.ActivePage=TabSheet1 then
  begin
    ...
  end;

of om een gewenst tabblad te activeren (de andere tabbladen worden dan vanzelf onzichtbaar):

PageControl1.ActivePage := TabSheet2;

Op die manier kun je de gebruiker van tabblad naar tablad laten gaan, inclusief jouw eigen "verder" of "start opnieuw" knop en eventuele verificatie, zonder dat je overbodig veel vensters hoeft te openen (met alle gevolgen van dien).