OOP 10 - Dialógus tervezés II

Elôzô számunkban odáig jutottunk el, hogy volt már egy adatmezôs ablakunk, ahol nevet - lakcímet -telefont kérhettünk be. Most tovább kellene lépni s, megtanulni használni ezeket a vezérlôket (controls = kontollok). Nem tudunk még értéket adni neki, írni / olvasni. Három lépésbôl áll e folyamat:

• Létre kell hozni egy olyan rekordot mely lefedi az adatmezôs ablaon lévô vezérlôk adatcsere típúsait
• Értéket kell adni a vezérlônek az elôbb létrehozott rekord segítségével, és
• Az új értékeket - amit a vezérlô input view-okba írtunk - pedig el kell tudni menteni e rekordba

Az adat rekord létrehozása

Hogy írjuk vagy olvassuk az ablak adatmezôit, létre kell hozni egy buffer-t - ez leggyakrabban egy adat rekord - ami tárolja annak adatait. (Az adatmezôk, s egyéb kontrollok állapotát.)

A rekord egyes mezôit az ablakon látható kontrollok SetData() GetData()-ája határozza meg. Ezek a metódusok ( SetData() és GetData() ) valamilyen adatot várnak. Pl.: az InputLine - szöveg bekérô sor - logikusan String-et vár, de hossz nem mindegy egyenlônek kell lennie az initializálásor megadott AMaxLen: Integer értékével.

A TRadioButton.SetData() leírja, hogy egy numerikus változót a Value mezôt állítja be, de a hosszára még rá kell jönnünk. Ha elôszörre nem írják le az azt jelenti, hogy az elôdjét kell megnézni, s ott a Value mezôt. Az elôdje a TCluster s itt található meg a Value mezô melynek most már kiderült, hogy Word a típusa. Ezeket az információkat a Help-bôl szerezhetjük meg. (A TVISION.TPH file-ban vannak. Help/Files menüpont)

• Tehát rá kell jönnünk milyen adatot vár a GetData() és milyet ad vissza a SetData() általános metódus.

 

New(Vezetek, Init(R, 16)); {Vezetek: TInputLine}
New(Kereszt, Init(R, 16)); {Kereszt: TInputLine}
New(Varos, Init(R, 16)); {Varos: TInputLine}
New(Iranytszam, Init(R, 4)); {Iranytszam: TInputLine}
New(Utca, Init(R, 16)); {Utca: TInputLine}
New(Hazszam, Init(R, 3)); {Hazszam: TInputLine}
New(Egyeb, Init(R, nil, nil, nil, 16)); {Egyeb: TMemo}
New(Tel, Init(R, 16)); {Tel: TInputLine}
New(Note, Init(R, nil, nil, nil, 80)); {Note: TMemo}

Nos itt a TAB sorrend (FIGYELEM meg kell nézni a futó programban a TAB sorrendet is !), a kontrollok típusa - ami nem annyira fontos, mint - az általuk kívánt adattípus - hossz is meg van. A TMemo-ról még annyit kell tudni, hogy a TEditor utóda és a beleírható szöveg max. hossza 64KB, de a tényleges hosszt az initializáláskor adtuk meg. Így ilyen hosszú karaktertömböt (Array[1..hossz] of Char) csinálunk. De lényeg most jön: minden karakter tömb elôtt amit TMemo használ egy Word-nek kell állnia amibe a TMemo-ban lévô ill. leendô szöveg hossza kerül !!! Jöjjön a rekord:

 

TAdatok = record
  VNev,
  KNev,
  Varos : String[16];
  Irszam : String[4];
  Utca : String[16];
  HazSzam : String[3];
  EgyebHossz: Word;

  Egyeb : Array[1..16] of Char;
  Tel : String[16];
  NoteHossz : Word;
  Note : Array[1..80] of Char;
end;

Íme kész a rekord ami leírja az ablak kontroljainak adatcsere mezôit.

Összefoglalom milyen kontroll milyen milyen típusú adatot használ fel az adatcserére:

kontroll típus	Az adatcseréhez felhasznált típus:
TInputLine	String[AMaxLen]
TMemo	Word az aktuális szöveghosszra, és a szöveg tárolására Array[1..AMaxLen] of Char
TRadioButton és
TCheckBoxes	Word mely az aktuális bekapcsolt állapotot hivatott tartalmazni
TLabel és
TButton	Nincs szükség adat mezôre !
TListBox	TCollection megfelelô sorrendjét

Az ablak kontrolljainak feltöltése adatokkal

Most, hogy tudjuk - ismerjük a Pelda01 program TProbaDialog ablakának kotroljait leíró adatcserés rekordot felettéb egyszerûen írhatunk be adatot. Ehhez az alábbi lépésekre van szükség:

• A definiált adatcsere rekord-ot létrehozni - az-az deklarálni
• A deklarált rekordot adatokkal megfelelôen (!) feltölteni, végül
• a dialógusnak ezt az adattal tei rekordot átadni adatbeállítás ( SetData() ) címén.

Most jön a kontrollok feltöltése adatokkal. Az okosok azt mondták (pl.: a tutor09.pas - a BP TV Tutoral-ja), hogy hozzunk létre egy globális változót a fent definiált rekord számára. Nos én nem ezt mondom, sôt valami szerintes sokkal szebbet mondok: hozzunk létre a TProbaDialog-ba egy public - mindenki számára elérhetô - Adatok mezôt melynek típusa a Tadatok. Miért jó ez ? Mert az Adatok változó nyílván ahhoz az ablakhoz tartozik mely ki írja - kezeli ôt. Gondoljunk bele 23 másik fajta ablakunk van s mindegyiket a programban globálisnak deklaráljuk, ha a programot debuggoljuk akkor csak kapkodnánk a fejünket, hogy melyik Adat változó melyik. Jöhet a kérdés most akkor hogy kezeljük az Adatok változót, pl. az applikációból ?

Egyszerû az Applikációnak egy private mezôje a TProbaDialog melynek viszont publikus mezôje az Adatok változó. Így hivatkozunk rá:

ProbaDialog^.Adatok.VNev:=‘Bérczi’;

lehet, hogy kacifántosnak tûnik, de: így is mindenki eléri akinek szüksége van | lehet rá (ha valamelyik metódus nem éri el, akkor az biztos nem az applikáció része, tehát nem szabványos logikus az OOP-s programunk.), s még késôbb is áttekinthetô a program.

Lássuk a konkrét adat feltöltést:

A TProbaDialog konstruktor init-jében a kontrollok (avagy még magyartalanabbul vezérlôk) behelyezése (insert-álása) után helyezzük el az ablak kezdeti érték megadását az alábbi forma szerint:

with Adatok do

begin
  VNev:='Bérczi';
  KNev:='László';
  Varos:='PÉCS';
  Irszam:='7632';
  Utca:='NemMondom meg tér';
  HazSzam:='99';
  EgyebHossz:=14;
  Egyeb:='R4s Technology'#0#0;
  Tel:='06-72-999-999';
  NoteHossz:=19;
  Note:='Nincs más mondandóm'#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0+
  #0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0;
end;

SetData(Adatok);

Mit miért csináltunk így ?

Mivel a TProbaDialog initjében vagyunk ez azt jelenti hogyha az objektumunk saját metódusait hívjuk meg akkor nem kell az objektum megnevezés, elég a metódus név.

A rekord elemeire, meg úgy hivatkozhatunk legegyszerûbben, - ennek köztudottnak kell lennie - ha with-do-t használunk. A VNEV a vezetéknév míg a KNEV logikusan a keresztnév. A Varos, Irszam, Utca, HazSzam neveket egyértelmûen rendeltetésüknek megfelelôen használjuk. Az EgyebHossz jelenti a helyileg utána kövekezô Egyeb Char (karakter) tömb-ben lévô szöveg hosszát Word-ben ! (Úgy, mint a String 0. eleme ! csak az Byte). A Tel változó is egy String, melyet ÍGY TÖLTÜNK fel: 06-xx-yyy-zzz. Még pedig azárt, mert késôbb így fogjuk használni. (Lásd validating !) A Note a megjegyzés hossza alias Egyeb, míg a Note char array-be megy a tényleges megjegyzés.

Miért raktuk oda azt a rengeteg 0-át ?

Mert egy tömb minden elemét fel kell sorolnunk értékadáskor. Ezt a úgy kerülhetjük ki, hogy írunk egy procedure-át, melynek egy String-et adunk meg amiben a szöveg van, FELTÉVE, hogy nem ekarunk 255 karakternél hosszabb TMemo-t használni: míg a Word változót és a KarakterTömböt cím szerint. A rutin mit fog csinálni ? Átmásolja a String-bôl a KarakterTömbbe a szöveget, és a Word-be pedig a String hosszát másolja, lássuk:

 
procedure CopyStringToTMemo(AText: String; var ArraysLength: Word; var CharArray);

  function Min(A, B: Word): Word;
  begin
   if A < B then Min:=A
            else Min:=B;
  end;
 
var MinLen: Word;

begin {IN: ArraysLength = SizeOf(CharArray), OUT = Length(AText) !!!}
  MinLen:=Min(Word(Ord(AText[0])), ArraysLength);
  ArraysLength:=MinLen;
  Move(Mem[Seg(AText):Ofs(AText)+1], CharArray, MinLen);
end;

A példa procedure forráskódja (ConvStr.PAS) !

Ez szerintem elvileg érthetô: de azért elmondom:

• Bemegy az AText: String-ben a szöveg
• Az ArrayLength()-ben BEMENETKOR, s csak akkor a karaktertömb fizikai hossza, melyet SizeOf(CharArray)-vel állapíthatunk meg a függvény meghívása elôtt.
• A CharArray pedig az a karaktertömb melybe a string tartalma másolódik
• A procedure elsô lépése, hogy kiválasztjuk a kisebben a string hossz és a karaktertömb mérete közül két okból:
  - Lehet, hogy a KarakterTömb rövidebb, mint a String-ben tárolt szöveg, pl.: 234 karakter hosszú szöveg a string-ben, míg a karaktertömb csak 80 karakterbôl áll. Így elkerülhetjük azt, hogy többet másoljun a memóriába, mint karaktertömb (CharArray) hossza. Mi történne ha többet másolnánk ? Akkor más változók adatait írnánk felûl, s hibás lenne a programunk !
  - A második dolog amire jó ez a minimum kiválasztás, hogyha a szöveg hosszabb, mint a karaktertömb akkor hossznak az ArraysLenghth-ben csak olyan hosszt adunk vissza ami érvényes, nem a túllógót, hanem a karaktertömb maximális hosszát !
  - A harmadik dolog ami ugye evidens, hogy csak annyit másolunk a karaktertömbbe amennyit szükséges az-az ha nagyobb a karaktertömb akkor csak a szöveget a string-bôl melynek hossza vagy Length(AText) vagy Ord(AText(S[0])). (Az Ord() függv. Char-ból Byte-ot csinál, és a String-ek 0. eleme a hossz.) A Word() prefixumot azért tesszük mindig elé, mert Byte-ból, Word-del kell számolni, s hogy minden biztosan tiszta legyen ! Kell !
• A másolás megtörtént, s az ArraysLength Word változóba - melynek ugyanúgy akár a karaktertömbnek (CharArray) címszerinti átadást definiáltunk - nem más mint vagy a String (az AText) hossza vagy a karaktertömb hossza kerül. Az elôzôek szerint megbeszéltük, hogy a kettô közül a kisebb !

Ha valakit zavar, hogy a TMemo két típus definiálást igényel használjon egymásba ágyazott ciklusokat e probléma megoldására:

TEgyebMemo = record
  EgyebHossz: Word;
  Egyeb : Array[1..16] of Char;
end;

TNoteMemo = record
  NoteHossz : Word;
  Note : Array[1..80] of Char;
end;

TAdatok = record
  VNev,
  KNev,
  Varos : String[16];
  Irszam : String[4];
  Utca : String[16];
  HazSzam : String[3];
  EgyebMemo : TEgyebMemo;
  Tel : String[16];
  NoteMemo : TNoteMemo;
end;

Így szerintem már mindenkinek kell, hogy tessék (tetszôdjék), hogyan is hivatkozunk a TProbaDialog-on belûl e adatokra, pl. a NoteMemo Note karaktertömbjére ?

(TProbaDialog.)Adatok.NoteMemo.Note:=‘akármiislehetideemekétaposztrofközéírvaakutyamegamacska!’;

Nos így hivatkozhatunk rá, lehet, hogy így elegánsabb ? Nekem mindegy így is jó meg úgy is !

Hasznosítsuk az initializáláskor a fenti procedure-át !

with Adatok do

begin
  VNev:='Bérczi';
  KNev:='László';
  Varos:='PÉCS';
  Irszam:='7632';
  Utca:='NemMondom meg tér';
  HazSzam:='99';
  EgyebHossz:=SizeOf(Egyeb);
  CopyStringToTMemo(‘R4s Technology’, EgyebHossz, Egyeb);
  Tel:='06-72-999-999';
  NoteHossz:=SizeOf(Note);
  CopyStringToTMemo(‘Nincs más mondandóm’, NoteHossz, Note);
end;

SetData(Adatok);

Látható, hogy a sok nulla char beírásától megszabadultunk, s azt is, hogy a CopyStringToTMemo() elôtt az elmondottak szerint meg kell azni karakterömb fizikai méretét.

Elegáncsosabbá lehet tenni a dolgot az elôbb elmondott rekord-ba zárással, s a rekord által definiált változót cím szerint átadni, s úgy kezelni a hosszt, s karaktertömböt. Ezt már rátok bízom legyen ennyi kreativitásotok !

Az adatok kiolvasása - lementése a kontrollokból

Ez hasonlóan egyszerû, mint a SetData() függvény használata, ugyanazt a rekordot használhatjuk az adatok elmentésére, mint a bevitelhez hiszen ugyanúgy Z-order szerint menti le ahogy beolvassa az adatokat.

Tegyük fel, hogy a kedves felhasználó, bepötyög valami a mezôkbe lenyomja az elment gombot, s nekünk az Adatok rekordba kell másolnunk, hogy tehessünk vele valamit a késôbbiekben, valahogy így:

A TProbaDialog objektumban implentáljuk az adat lekérô utasítást:

GetData(Adatok);

Az ablakon látható gombokhoz tartozó események lekezelése

Láttuk a TProbaDialog init-jében, hogy mint ahogy az lenni szokott a gombokhoz most is eseményt társítottunk, mégpedig rendre:

• '~Ú~j' => cmUjAdat
• '~E~lment' => cmSaveUj
• '~M~égsem' => cmClose
• '~K~övetkezô' => cmTElore
• 'E~l~ôzô' => cmTHatra

procedure TProbaDialog.HandleEvent(var Event: TEvent);

begin
  Inherited HandleEvent(Event);
  if (Event.What = evBroadcast) and (Event.Command = cmProbaDialogLetezel)
  then ClearEvent(Event);
  if (Event.What = evCommand) then
  begin
   case Event.Command of
     cmTHatra: ; {az elôzô adat beolvasása}
     cmTElore: ; {begin Adatok:= ???valami; SetData(Adatok); end;}
     cmSaveUj: GetData(Adatok); {Az kontroll-adatok bekérése késôbbre!}
     cmUjAdat: begin FillChar(Adatok, SizeOf(Adatok), 0); SetData(Adatok); end;
   end;
   ClearEvent(Event);
  end;

end;

Ez csak egy formális bemutatása az események többágú-szelekcióval való szétválasztására, de konkrét megoldás a továbbiakban, hisz még nincs ami e leolvasott adatokkal valamit kezdene !

Mit is lehetne e adatokkal (Név, cím, Tel.) kezdeni ???

Írjunk egy abszolút kezdetleges nyilvántartó programot !

Az Adatok nyilvántartása, s elmentése file-ba

Dolgunk nem nehéz, hisz meg van a felhasználói környezet - az adat bekérô kontrollok (inputline), a gombok a dialóguson melyek biztosíthatják a nevek - címek elôre | hátra lapozását. Most már csak annyit kell megoldani, hogy egy file-ba legyenek eltárolva a nevek és címek rekordonként. Nézzük a megvalósítást lépésenként:

• Adott a TAdatok típus mely a TProbaDialog-on tárolja az adatokat. Mivel erre a típusú rekordra épül az adatcsere a dialógus és az applikáció között, az egyszerûség kedvéért (hogy elkerüljük a nehézkes adat - típus konvertációt) ilyen típusos file-t hozunk létre. A file is a TProbaDialog-hoz fog tartozni, méghozzá privát módon. Deklarálása:
  AdatFile: File of TAdatok;
• Kell egy változó is mely az aktuális file-on belûli pozíciót tartalmazza mely nem más, hogy melyik számú (0-tól számolva) rekord látható a dialóguson. Legyen:
  MelyikRekord: Word; a deklarálás.
• Ezek után kellenek eljárások melyek kezelik ezt a file-t. Kell:
  FileOpen; {A file megnyitása}
  FileClose; {A file bezárása}
  ReadRekord(x); {Az x. rekord olvasása a file-ból.}
  SaveRecordToLastPos; {A file végéhez hozzáfûzve írja a file az új rekordot}
  Továbbá kell három elefánt, sorry az más ..., tehát le kell kezelni a dialóguson látható gombokat amirôl feljebb már szóllottunk. Így az eseményekhez társítjuk majd a file-mûveleteket.
• Nézzük a forráskódot magyarázó részletekkel:

 
>

constructor TProbaDialog.Init;

var R : TRect;

begin
  Inherited Init(R, ‘Adat nyilvántartó dialógus’);
 
  {a kontrollok - gombok definiálása}
 
  MelyikRekord:=0;
  FileOpen;
  ReadRecord(MelyikRekord);
  SetData(Adatok);
end;

Mi az a: MelyikRekord:=0; ? Nyilván a 0. rekordot az-az az elsô adatot írjuk ki a dialógusba megnyitáskor.

A FileOpen; megnyitja a file-t, a ReadRecord(MelyikRekord); sor pedig jelen esetben a 0. rekordot olvassa be az Adatok változóba - lásd alább - és a SetData(Adatok); a dialógusba másolja ezen rekord adatait - mezôit.

destructor TProbaDialog.Done;
begin
  Inherited Done;
  FileClose;
end;

Ez a metódus az objektum megszüntetésekor hívódik meg, s ha felszabadítottunk minden az objektummal kapcsolatos memória-területet akkor végül zárjuk le a file-t:

procedure TProbaDialog.FileClose;
begin
  System.Close(AdatFile);
end;

Mely így történik. A System szó azért van ott, mert a Close egy view-ban saját magának s nem a file-nak a bezárását jelenti, ezért meg kell adni, hogy a System Unit Close() rutinját akarjuk használni.

A file-megnyitását is nézzük meg:

procedure TProbaobaDialog.FileOpen;
begin
  MelyikRekord:=0;
  Assign(AdatFile, 'adatok.dat');
  Reset(AdatFile);
end;

A MelyikRekord változót lenullázzuk, az AdatFile file-típushoz hozzárendeljük az ‘adatok.dat’ file-t, s megnyitjuk. (A CD-n a forráskódban nem ugyanezt találod, mert nekem még arra is figyelnem kellet hogyha CD-rôl indítják el a programot, akkor ne lehessen írni, s read-only-val kell megnyitni !)

Lássuk az olvasási mûveletet:

procedure TProbaobaDialog.ReadRecord(var x: Word);
begin
  if Word(FileSize(AdatFile)-1) >= x then
  begin
   Seek(AdatFile, x);
   Read(AdatFile, Adatok);
  end else Dec(x);
end;

Egyáltalán akkor olvasunk, ha a beolvasandó rekord mutatója nem mutat az utolsó rekord mögé, tehát ha még létezik. A FileSize() típusos file-nál a rekordok számát adja vissza 1-tôl számolva így ki kell belôle egyet vonni, mert az x 0-tól van számolva a Seek() file-kezelô parancs miatt. Ha jó az x értéke akkor olvasunk, ha nem akkor csökkentjük az x-et, hogy ne engedjük a maximális rekordok száma után menni.

Ha már olvastunk nézzük meg az írást is:

procedure TProbaobaDialog.SaveRecordToLastPos;
begin
  Seek(AdatFile, FileSize(AdatFile));
  Write(AdatFile, Adatok);
end;

Láthatjuk, hogy ez se ördöngôs, a file legvégére pozícionálunk, s oda írjuk az Adatok rekordot. A fogas kérdés az, hogy hogyan kerül az Adatok rekordba a dialógus adata. Ezt a HandleEvent() intézi el a GetData()-paranccsal:

procedure TProbaobaDialog.HandleEvent(var Event: TEvent);

var B: Boolean;
begin
  B:=True;
  Inherited HandleEvent(Event);
  if (Event.What = evBroadcast) and (Event.Command = cmProbaDialogLetezel)
  then ClearEvent(Event);
  if (Event.What = evCommand) then
  begin
   case Event.Command of
   cmClose : Close;

   cmTHatra:
   begin
    if MelyikRekord <> 0 then Dec(MelyikRekord);
    ReadRecord(MelyikRekord);
    SetData(Adatok);
   end;

   cmTElore:
   begin
    Inc(MelyikRekord);
    ReadRecord(MelyikRekord);
    SetData(Adatok);
   end;

   cmSaveUj: begin GetData(Adatok); SaveRecordToLastPos; end;

   cmUjAdat:
   begin
    ClearEvent(Event);
    Event.What:=evKeyDown;
    Event.KeyCode:=kbAltZ;
    PutEvent(Event);
    FillChar(Adatok, SizeOf(Adatok), 0);
    SetData(Adatok);
    B:=False;
   end;
   end;
   if B then ClearEvent(Event);
  end;

end;

Lássuk az elejétôl:

• Az Inherited ... az elôd objektum saját HandleEvent()-jét szúrja ide be
• a cmProbaDialogLetezel parancs lényegét már megbeszéltük az elôzô számban
• Ha a beérkezô parancs evCommand akkor azt lekezljük, mert nekünk szólhat:
• cmClose: Ha a Mégse gombot nyomtuk meg akkor zárjuk be a dialógust
• cmTHatra: Egy rekorddal hátrébb megyünk ha nem a legelejét vagyunk, s ekkor beolvassuk az elôzô rekordot, maly kiírjuk a dialóguson úgy, hogy a SetData()-val új értéket adunk a kontrolloknak
• cmTElore: Egy rekorddal elôrébb megyünk, beolvassuk a rekordot, maly a dialógusnak adjuk az adatokat.
• cmSaveUj: A már fent tárgyalt SaveRecordToLastPos; nevü metódus menti el az Adatok rekord tartalmát, melyet e metódus meghívása elôtt a GetData() metódussal töltöttunk fel az éppen a dialóguson látható adatokkal.
• cmUjAdat: Egy kicsit kacifántosabb: Töröljük ezt az eseményt melynek segítségével idáig eljutottunk, s új eseményt generálunk mely a célt szolgálja, hogy a Vezeték név inputline-jához ugorjunk. Ezt valójában az Alt+Z billentyûvel lehet elérni, akkor csináljuk úgy mintha meg is nyomtuk volna: Írjuk az esemény listára, hogy ALT+Z-t nyotunk. Ez azért jó, mert ha új adatokat akarunk beírni akkor úgy is vezetéknévvel kezdjük.
  FillChar(Adatok, SizeOf(Adatok), 0); az eddigi adatok kitörlését szolgálja, így üres lesz az Adatok rekord, s ezt egyenlôvé teszük a kontollok értékével a SetData()-val.
• Az utolsó lépés az esemény törlése a ClearEvent()-tel kivéve akkor, ha a cmUjAdat-ban dolgoztunk mert ott már kitöröltük az eseményt újat adtunk neki és nincs szükség arra, hogy az új eseményt rögtön ki is töröljük. Ha nem a cmUjAdat-ban dolgoztunk meghívódik a ClearEvent() mert a B Boolean változó True, s így kitörlôdhetnek a már végrehajtott régi események.

Validating data entry - A begépelt adatok ellenôrzése

Cikkünk utolsó témájához érkeztünk, a begépelt adatok helyességét ellenôrizzük le. De mit is jelent ez ? Leellenôrizhetjük, hogy jó -e az irányító szám meg van -e XXXX az-az négy számjegyû, vagy van e a házszám helyén adat, le lehetne ellenôrizni azt is ha itt pl. dátumot kérnénk be, hogy helyes e a dátum, meg még sok mindent ...

Általánosságban a Turbo Vision egy negyon kényelmes eszközt ad kezünkbe az adatok leellenôrzését illetôen a Validate Unit formájában. Le ellenôrizni a TInputLine-t és örökített utódait lehet legegyszerûbben.

Két apró lépésbôl áll e ellenôrzés létrehozása:

1. Az InputLine-hoz kell rendelni a kívánt ellenôrzô objektumot
2. majd egyszerûen meg kell zézni, hogy helyes -e a dialóguson látható összes InputLine.

A Validator objektumok InputLine-hoz rendelése

Minden InputLine rendelkezik egy Validator mezôvel. Ha ilyen ellôrzô objektumot - validator-t - akarunk hasznáni akkor ezzek kell egyenlôvé tenni. Ezt a SetValidator() metódussal tehetjük meg mellyel úgyszintén minden TInputLine rendelkezik.

Milyen validator-ok léteznek:

• Létezik az ôs - absztrakt TValidator melybôl származik az összes többi
• TPXPictureValidator: bizonyos beviteli képet követel meg, pl.: ###-&&& 3 betû, 3 szám a rendszám táblákhoz
• TRangeValidator bizonyos értékek között engedi csak beírni a számot, pl.: 1000 és 9999 között, mint az irányítószámok.
• TStringLookupValidator: mely StringCollection-okat vizsgál, ezzel majd máskor foglalkozunk.

Hogyan hozzuk ezeket létre:

RangeValidator:=New(PRangeValidator, Init(1000, 9999));

Ugye nem felejtettük el a uses-ban a Validate Unit-ot beírni ?

Jelen esetben a RangeValidator, mint nevébôl is következik két határ közötti értékeket enged beírni, egyébként kiírja egy msgbox-ban, hogy: "Value is not in the range: 1000-9999".

A másik leggyakrabban használt Validator a TPXPictureValidator, melynek elôre egy maszkot adunk meg, hogy milyen karaktereket fogadjon el egymás után. A speciális ekkor használandó karakterek:

Speciális:

# Csak számot fogad el

? Csak betût fogad el, kis- és nagy-betûk megkülönböztetésével

& Csak NAGY betût fogad el

@ Bármilyen karaktert elfogad

! Bármilyen karaktert elfogad, ha betû akkor csak NAGY betût

Ha egyezik:

; A következô betû szerint

* Az ismétlés szorzója

[] Választási lehetôség - nem kötelezô beírni

{} Csoport operátor

, Alternatívák elválasztása

Minden más: betû szerint

Nézzünk egy példát a fentiekkel:

Kérjük be a telefonszámot a vidéki hívókoddal, a körzetszámmal, s a kapcsolási számmal, pl.: 06-72-123-456, erre a picturevalidator: Tel^.SetValidator(New(PPXPictureValidator, Init('##-##-###-###[#]', True))); Láthatjuk, hogy az utolsó [ ]-be van téve, mert nem kötelezô, ez azért van mert BP-n 7 jegyûek a számok míg a vidékiek 6 jegyûek.

Az elôzô példában már láthattuk a konkrét beállítását is a validator-nak de részletesebben:

Megbeszéptük, hogy a TInputLine-nak van egy Validate: PValidator mezôje melyet be kell állítanunk úgy, hogy létrehozzuk a validator-t és egyenlôvé tesszük ezzel a mezôvel. A legegyszerûbb létrehozás látható:

Tel^.SetValidator(New(PPXPictureValidator, Init('##-##-###-###[#]', True)));

Az inputline-nak a SetValidator() metódusa egy PValidator pointer-t vár. A New() függvénnyel újonan létrehozott objektum címét a New() simán a függvény értékeként adja vissza. Az Init-ben a maszkot adjuk meg a fentiek szerint, s az AutoFill Boolean változót, melyet most True-ra állítottunk. Nézzünk egy teljes példát a rangevalidator-ra:

R.Assign(50, 4, 59, 5);
New(Iranytszam, Init(R, 4));
if CommandEnabled(cmUjAdat)
then Iranytszam^.SetValidator(New(PRangeValidator, Init(1000, 9999)));
Insert(Iranytszam);
R.Assign(33, 4, 47, 5);
Insert(New(PLabel, Init(R, '~I~rányítószám:', Iranytszam)));

Látjuk, hogy a dialog-ra insert-áljuk az inputline-t s a hozzá tartozó labelt, míg a validator-t símán a SetValidator() metódus paramétereként hoztuk létre.

A Valid metódusok meghívása

Két fô kérdést lehet feltenni:

• Mi az egyáltalán, hogy Valid ? (Valid = érvényes, itt: hibátlan ...)
• És mikor ellenôrizhetem le az inputline-t ? (magyartalanul mikor "validatálhatok" ?)

Az elsô kérdésre a válasz egyszerû: valid vagyis érvényes az inputline-ban a szöveg ha megfelel a beállított validator elvárásainak, pl.: a fenti range (határ) validator elvárása, hogy 1000-9999 között legyen a beírt érték.

A második kérdésre a válasz több úton folytatódik: Az inpútline-t leellenôrizhetem:

• Bezáráskor, ill. ezt nem is én ellenôrzöm le, hanem ha meg akarunk semmisíteni egy group-ot, vagy egy ablakot bezárni akkor automatikusan meghívódik az inputline-ok leellenôrzése, s mindaddig nem lehet bezárni míg nem helyes az inputline értéke.
• Ellenôrzés az inputline-ok közötti TAB váltás során: Meg lehet tenni, hogy csak akkor engedjuk továbblépni a felhasználót, ha helyes formában írta be az adatot. Ugyanis - mint már megbeszéltük rég - minden view-nak van egy Options flag-ja mely különbözô beállításokat tartalmaz többek közt ezt az ellenôrzés engedélyezését is. Tehát ha be van kapcsolva az OfValidate bit akkor minden fókusz vesztéskor a Validator objektum megvizsgálja az inputline-t, hogy helyes -e az adat, ha nem akkor nem enged belôle kilépni. Folytassuk az elôzô példát az irányítószámmal. Addíg kell az irányítószámot beírni míg az jó nem lesz:

Iranytszam^.Options:=Iranytszam^.Options or OfValidate;

Ugyanígy kell beállítani más esetekben is az OfValidate Options flag ezen bit-jét.

• A programozó kérésére ellenôrzés:
  Szükség lehet rá, hogy csak akkor hajtunk végre egy mûveletet, ha hibátlan az adat. (Viszont nem akarjuk használni a TAB-os állandó ellenôrzéses formát.) Pl.: lementéskor. Erre is van egy megoldás a TGroup-nak a Valid() metódusa, melyben lekérdezhetjük, hogy egy parancs !!! (nem szöveg) végrehajtható -e az adott csoporton - ablakon - dialóguson. Pl.: tegyük fel, hogy megkérdezzük, hogy végrehajtható -e a bezárás ? Ez meg csak akkor hajtható végre, ha az összes inputline adata helyes. Így egyszerre leellenôriztünk mindent ! Lássuk:

if Valid(cmClose) then SaveRecordsToLastPos;

Szerintem e cikk bôségesen (sôt túl) sok információt tartalmazott egyszere a Kedves Olvasónak. DE szerintem egy hasznos programmal szolgáltam, amit a kezdôk, -e témában érdeklôdôk remélem nagy örömmel fogadnak. A validate-ról nem mondtam el mindent mert ebben a részben ennyire van szükség, ill. ami kevéske hátramaradt az pedig az objektumok belsô szerkezetének - mûködésének leírásakor tárgyaljuk. Akinek kérdése van az az alsó címre eMail-ezzen, s válaszolok.

A cikk Winword DOC formátumban
Az adatnyilvántartó program EXE-je !

Bérczi László
eMail:PC-XUser@IDG.HU, Subject: "OOP rovat"
BELA@MI.STUD.PMMFK.JPTE.HU

Vissza a PC-X User 10 fôoldalához