III. Watcom VX-REXX

Bevezetô:

Most pedig ismerkedjünk meg egy valódi vizuális fejlesztôkörnyezettel, a VX-REXX-szel! A vizuális REXX környezetek közül nagyon sokan ezt a terméket sorolják a képzeletbeli elsô helyre. Nem is alaptalanul. A kanadai illetôségû Watcom cég által készített VX-REXX rendelkezik mindazon jellemzôkkel, amelyeket egy vizuális fejlesztôkörnyezettôl elvárunk. Sajnos a termék továbbfejlesztését az 1995-ös évben abbahagyták, így a legutolsó verzió a mai napig az akkoriban kiadott 2.1-es maradt. Ehhez megjelent még néhány javítást, amelyeket pl. a hobbes-ról lehet letölteni. Ha ezeket egymás után szépen telepítjük, akkor eljuthatunk a 2.1d változathoz, amely az abszolút végállomást jelenti. A VX-REXX és a vele készített termékek 2000 állóságáról sem lehet sajnos semmit tudni. A tapasztalatom az, hogy a VX-REXX jól mûködik 2000 után is, ám ez sovány vigasz lehet azok számára, akiknek az alkalmazások használata során biztosra kell menniük. A VX-REXX kereskedelmi termék, s ha boltban már nem is, használtan talán még be lehet szerezni. Próbaverziókat lehet találni az interneten és a DevCon CD-ken, ezek azonban annyira korlátozottak, hogy nem érdemes velük komolyan foglalkozni.

Egy egyszerû példaprogram

Vágjunk gyorsan a dolgok közepébe! Készítsünk egy egyszerû alkalmazást, amely egy beviteli mezôbôl, nyomógombból és egy listából áll. A program a futás során a beviteli mezôbe gépelt szavakat fogja gombnyomásra hozzáadni a listában található többi elemhez.

A programozást azzal kezdjük, hogy készítünk egy új projectet. Ezt nagyon egyszerûen megtehetjük a Projects gyûjtôben található project minta a gyûjtôben történô ledobásával, amely hatására egy új gyûjtô keletkezik, amelyet egyszerûen átnevezünk igényünknek megfelelôen. Az ily módon létrehozott projectben három másik ikont találunk, amelyek közül a VRP kiterjesztésûre kell klikkantani és már elénk is tárul a fejlesztôkörnyezet.

Bármilyen alkalmazást is készítünk, mindig a következô három fô tevékenységet fogjuk elvégezni: objektumokból építkezve létre kell hozni a felhasználói felületet, be kell állítani az objektumok tulajdonságait, az objektumokhoz kódrészleteket kell csatolni. A rendelkezésre álló objektumokat a környezet job oldalán (Tools) láthatjuk. Válasszuk ki a példaprogramhoz szükséges beviteli mezôt és jelöljük ki helyét a jobb oldalon található munkatáblán. Ismételjük meg a mûveletet a nyomógombbal és a listával is. Valami olyasmit kell kapnunk, amit az alábbi ábrán is láthatunk:

A példaprogram kezdeménye

A következô lépés a program felületéhez felhasznált objektumok tulajdonságainak beállítása. Természetesen azokat a tulajdonságokat nem kell átállítanunk, amelyeknek elégedettek vagyunk az alapértelmezett értékével. Elôször a beviteli mezô magasságát fogjuk átállítani, hogy az automatikusan igazodjon az éppen használt font magasságához. Klikkantsunk a jobb egérgombbal (balkezesek a ballal :-) a beviteli mezôre és az elôbukkanó menübôl válasszuk az Open, majd pedig a Properties szót. A megjelenô jegyzettömb Size oldalán találjuk az Autosize tulajdonságot engedélyezô jelölônégyzetet, amelyet be kell jelölnünk. Zárjuk be a jegyzettömböt és nyissuk meg az elôzôekben leírtakhoz hasonlóan a nyomógomb tulajdonságait tartalmazó jegyzettömböt. Lapozzunk a Text oldalra és a Caption mezôbe írjuk be a nyomógombra írandó szöveget, amely legyen mondjuk "szöveg hozzáadása". Végezetül állítsuk át a lista azon tulajdonságát, amely meghatározza, hogy a listához adott elemek milyen sorrendben jelenjenek meg. Ezt a lista tulajdonságait tartalmazó jegyzettömb List oldalán tehetjük meg, a Sort lenyíló menüben. Mivel azt szeretnénk, hogy a szövegek a bevitel sorrendjében jelenjenek meg, válasszuk a none opciót. Érdemes még a Size oldalon engedélyezni az AdjustHeight tulajdonságot, hogy a lista magassága automatikusan változzon, ha azt a bevitt elemek száma megkívánja. Szorgalmasak a rajztábla Caption tulajdonságát is megadhatják. Ez fogja ugyanis meghatározni, hogy milyen szöveg jelenjen meg programunk fejlécében. Próbáljuk ki, hogy hogyan néz ki a felület a valóságban! Bökjünk az egérrel a Run menüre, s válasszuk a lenyíló menübôl a Run project funkciót. Ennek hatására el fog tûnni a fejlesztôkörnyezet és meg fog jelenni a programunk. Valami olyasmi, amit az alábbi ábrán is láthatunk.

Az elsô sikeres futtatás

Próbáljunk meg írni a beviteli mezôbe, bökjünk a nyomógombra és figyeljük meg, hogy a Tab gomb megnyomásával hogyan váltogathatunk az objektumok között. S bár valószínûleg örömmel fogjuk konstatálni, hogy a program már csinál valamit, az igazi funkcionalitás eléréséhez meg kell írni az objektumokhoz rendelt rutinokat. Zárjuk be a programot! A fejlesztôkörnyezet újra meg fog jelenni. A példaprogrammal azt szeretnénk elérni, hogy a gomb megnyomására a beviteli mezôbe gépelt szöveg feltûnjön a listában. A szükséges kód megírásához a drag and drop technikát fogjuk használni. Az elsô lépés az, hogy a gomb megnyomásakor ki kell olvasnunk a beviteli mezô szövegét. Ez azt jelenti, hogy a Click eseményre kell reagálnunk. Kattintsunk a 2. egérgombbal a nyomógombra és válasszuk az Event (esemény) menüpontot. Az elôbukkanó eseménylistából válasszuk a Click eseményt, majd pedig bökjünk az Open gombra. Ennek hatására meg fog jelenni egy szövegszerkesztô, amely a szükséges kód kezdeményeit fogja tartalmazni. Rendezzük úgy az ablakokat, hogy a szövegszerkesztô és a rajztábla egyidejûleg látszódjon! A beviteli mezô felett nyomjuk le és tartsuk is így a 2. egérgombot, s mozogjunk az egérrel a szövegszerkesztô azon felülete felé, ahová a kódot szeretnénk beírni, majd engedjük el az egeret!

Drag and drop programozás

A megjelenô dialógusablakból válasszuk a Get property rész alól a Value kulcsszót, majd nyomjuk meg az OK gombot. Ennek hatására a

value = VRGet( "EF_1", "Value" )

A következô lépés az, hogy a kiolvasott szöveget hozzáadjuk a listához. A lista felett tartsuk lenyomva a 2. egérgombot és vontassuk a szövegszerkesztôre! Ismét meg fog jelenni egy dialógusablak, amelyben ezúttal a válasszuk a Methods rész alatt található Add a string funkciót és nyomjuk meg az OK gombot. Ha minden jól megy, akkor egy újabb dialógusablak fog megjelenni:

Karakterlánc hozzáadása

A String beviteli mezôbe írjuk be a value változót, mivel ennek az értékét akarjuk hozzáadni a listához. A Quoted string jelölônégyzetet kapcsoljuk ki, mivel a value értékét akarjuk megjeleníteni, nem pedig a value karakterláncot. Az OK gomb megnyomására eltûnik a dialógus és a következô sor jelenik meg a szövegszerkesztôben:

position = VRMethod( "LB_1", "AddString", value,  )

Miután hozzáadtuk a beviteli mezô szövegét a listához, ki kell törölni a tartalmát, hogy helyet csináljunk a következô szövegnek. Vontassuk tehát újra a beviteli mezôt a szövegszerkesztôre és a felbukkanó dialógusablakból válasszuk a Value értéket a Set property rész alatt. A második dialógusban klikkantsunk az OK-ra érték megadása nélkül, ugyanis törölni akarjuk a mezô tartalmát. A következô sorral kell, hogy gazdagodjon a rutin:

ok = VRSet( "EF_1", "Value", "" )

Amikor rábökünk a nyomógombra, akkor a fókusz átkerül a beviteli mezôrôl. Az lenne viszont a kívánatos, hogy a fókusz a klikkantás után automatikusan visszakerüljön a beviteli mezôre. Vontassuk tehát a beviteli mezôt a szövegszerkesztôre, majd pedig válasszuk a Set focus to object funkciót a Methods rész alatt. A következô kódrészlettel fog gazdagodni programunk:

ok = VRMethod( "EF_1", "SetFocus" )

Ezzel elvileg kész is példaprogram. Futtassuk a kódot a Run project opció segítségével, s ellenôrizzük, hogy a beviteli mezôbe begépelt szövegek a gomb megnyomására rendben hozzáadódnak-e a listához! Ha mindent rendben találunk, akkor mentsük el a programot (Project -> Save) és készítsünk belôle EXE fájlt (Project -> Make EXE file). Az EXE fájl futtatásához szükség van a fejlesztôkörnyezettel adott és szabadon terjeszthetô VROBJ.DLL-re is. Ha tehát továbbadjuk programunkat, akkor ne felejtsük el csatolni a VROBJ.DLL-t is!

A VX-REXX programok szerkezete

A példaprogram készítése során már megfigyelhettük, hogy egy project nem más, mint néhány kód (*.VRX) és néhány bináris fájl (*.VRY) összessége, amelyek vázai automatikusan létrejönnek a project minta leejtésekor keletkezett gyûjtôben. Kódfájlból legalább egy mindig van, ugyanis ez tartalmazza a REXX programot. További kódfájlokat lehet létrehozni a Project -> New code file menüpont segítségével. A kódfájlok mindegyike tartalmaz egy eredetileg üres Main rutint, amely legelsôként hajtódik végre. Ebbôl a fô rutinból kerülnek aztán meghívásra a további rutinok, amelyeket szekcióknak (section) nevezünk. Az ugyanazon kódfájlon belül található szekciók nevei és változói globálisak, hacsak nem adtuk meg nevük után a PROCEDURE kulcsszót. A bináris fájlok a grafikus felületet alkotó objektumokat tartalmazzák. Amikor például valamelyik objektumot átnevezzük, akkor tulajdonképpen a megfelelô binárist fájlt változtatja a fejlesztôkörnyezet. A programot felépítô építôelemek (objektumok, szekciók, stb.) létrehozásakor a környezet automatikusan névvel látja el azokat. A neveket természetesen kedvünk szerint megváltoztathatjuk. A szekciók közötti eligazodást segíti a szekcióablak (Section window). Segítségével ugyanis könnyedén váltogathatunk a szekciók között és akár új, általános célú szekciókat is létrehozhatunk. Az objektumok törlésekor vagy másolásakor a hozzájuk tartozó rutinok is törlésre vagy sokszorosításra kerülnek. Ezeket a feladatokat is automatikusan elvégzi a fejlesztôkörnyezet. Minden egyes kódfájlban jelen vannak bizonyos elôre definiált szekciók. A Main szekcióról, mint a legelsô végrehajtott rutinról már tettünk említést. Emellett léteznek még további készen kapott rutinok is: Halt (megszakítás lekezelése), Init (inicializálás), Window_close (ablak bezárása), Quit (close esemény lekezelése), Fini (az ablak megsemmisítése elôtt meghívott utolsó rutin). Amennyiben az adott ablak megjelenítése elôtt, vagy bezárása után kell bizonyos feladatokat elvégeznünk, akkor ezeket a szekciókat kell módosítanunk. A Main rutint nem ajánlott módosítani.

Az elôre definiált rutinok végrehajtási sorrendje kötött. Mint már említettük, a Main rutin kerül elôször meghívásra, amely összegyûjti az esetlegesen az ablaknak küldött paramétereket. Az elôre definiált InitArgs.0 tartalmazza a paraméterek darabszámát. Maguk a paraméterek az InitArgs.1, InitArgs.2 stb. változókban kerülnek elraktározásra. A Main után az Init rutin kerül sorra. Ekkor az ablak még nem látható, ez csak a rutin végrehajtása után következik be. Amennyiben az ablak megjelenítése elôtt pl. változókat kell inicializálni, akkor erre a legjobb hely az Init rutin. Az Init rutinból visszatérés után ismét a Mainben találjuk magunkat. Egy várakozási ciklusba lépünk be, amely események bekövetkezésekor meghívja az eseményhez tartozó rutint. Az elôredefiniált Window_Close esemény akkor következik be, ha a felhasználó bezárja az ablakot. A Window_Close rutin a Quit rutint hívja meg, amely megkezdi az ablak bezárását. Az események feldolgozását végzô hurok leáll, amikor a Quit rutin az ablak ShutDown jellemzôjét 1-re állítja. Ha tehát programunkból bárhonnan meghívjuk a Quit rutint, akkor az az ablak bezárását fogja eredményezni. Végezetül a Fini rutin kerül végrehajtásra, amelybôl már nincs visszatérés. Ha ez a rutin kerül meghívásra, akkor az ablak menthetetlenül be fog záródni. A Fini rutin visszatérési értéke az, amit az ablakot meghívó program visszatérési értékként fog megkapni. A default érték 0, érték visszaadása kötelezô.

Ikonok és képek

A példaprogramunk futtatása közben megfigyelhettük, hogy az ablak bal felsô sarkában a default OS/2-es programikon volt látható. A resource editor segítségével bitmap objektumokat, tehát többek között ikonokat is hozzáadhatunk a programunkhoz. Íly módon elérhetjük például, hogy az objektumok hátterében képek legyenek láthatóak, vagy hogy egyedi ikonja legyen alkalmazásunknak. Ahhoz, hogy az objektumhoz képeket csatolhassunk, az objektumnak be kell állítani a PicturePath tulajdonságát. Ezt megtehetjük például a VRSet utasítással. Az alábbi példákban beállítottunk egy háttérképet egy ablaknak, és egy ikont egy nyomógombnak:

call VRSet VRWindow(), "PicturePath", "D:\OS2\BITMAP\OS2LOGO.BMP"
call VRSet "IPB_1", "PicturePath", "D:\OS2\MDOS\WINOS2\WINOS2.ICO"

Az OS/2 operációs rendszer ikonokat definiál bizonyos alkalmazáscsoportoknak, amelyekre kulcsszavak segítségével hivatkozhatunk. Ha például az Application kulcsszót írjuk be a PicturePath értékeként, akkor az alkalmazásokhoz definiált ikont fogjuk megkapni. A kulcsszavakat megtaláljuk a VX-REXX programozási segédletben. Az OS/2-es fájlokban (EXE, DLL) tárolt vagy fájlokhoz rendelt ikonokat is felhasználhatjuk. Ha pl. a C:\OS2\E.EXE sort adjuk meg értékként, akkor az E.EXE programhoz rendelt ikont fogjuk megkapni. Végrehajtható állományokhoz csatolt ikonokra vagy bitmapekre a sorszámuk segítségével lehet hivatkozni:

#sorszám[:DLL neve]  (bitmap hivatkozás)
$sorszám[:DLL neve]  (ikonra hivatkozás)

Ha pl. az 1899-es bitmapra akarunk hivatkozni a JHUTT DLL-ben, akkor azt a #1899:JHUTT szóval tehetjük meg. Az ikonokat és képeket csatolhatjuk saját alkalmazásunkhoz is a resource editor (Project -> Resource editor) és az OS/2-es resource compiler eszközök segítségével. Az alábbi képen látható resource editor segítségével egy resource (.RC) fájlt hozunk ilyen esetekben létre a project alkönyvtárában, amelybôl aztán a resource compiler (RC.EXE, az OS/2 tools része) segítségével egy bináris resource fájlt készíttetünk. Ezt a fájlt használja aztán a VX-REXX fel a végtermék (.EXE) készítéséhez.

Ikonok és bitmapek megadása

A resource editor tulajdonképpen nem más, mint egy primitív szövegszerkesztô, amely segítségével az .RC fájlt szerkeszthetjük. Az .RC fájl tartalmazza a csatolni kívánt képek és ikonok definícióját, amely a következôképpen néz ki:

bitmap/icon azonosítószám fájlnév  (pl. bitmap 101 c:\os2\bitmaps\warp.bmp)

Az azonosítószám 1-tôl 64000-ig terjedhet. A legalacsonyabb számú ikon lesz a készített program ikonja. Ha kész vagyunk a szerkesztéssel, akkor fordítsuk le a definíciókat (File -> Save and compile). Az eredményül kapott bináris fájl automatikusan felhasználásra kerül a project .EXE fájljának készítésekor.

Menü készítése

A legtöbb grafikus felülettel rendelkezô program menürendszerrel is rendelkezik. A VX-REXX-ben a menük készítésére a Menüszerkesztô szolgál, amelyet a rajztábla elôbukkanó menüjébôl (Open -> Menü Editor) indíthatunk. A Menüszerkesztô segítségével szinte mindenfajta menü készíthetô. Mindegyik típus esetében közös vonás, hogy a menüelemeket egyesével kell létrehozni, a nevük és szintjük megadásával. Az elsô szinten elhelyezkedô menüelemek fognak megjelenni a lenyíló menük címsorában.

Készül a program menüje

A menü struktúrájának elkészítése után meg kell adnunk a menükhöz csatolt rutinokat is. Ezt a menüelem kiválasztásával és az Edit event gomb megnyomásával kezdhetjük el. Az objektumokhoz csatolt rutinok készítésekor már megismert szövegszerkesztô fog megjelenni, a szokás szerint elôre elkészített kódvázzal, amelyet igény szerint alakíthatunk.

Beépített dialógusok használata

Sok munkát spórolhatunk meg magunknak, ha programunkhoz felhasználjuk az operációs rendszerbe beépített standard dialógusokat. A VX-REXX környezet lehetôvé teszi az OS/2 fájl- (VRFileDialog), font- (VRFontDialog), üzenet- (VRMessage) és karakterlánc-beviteli dialógusát (VRPrompt). A leggyakrabban a fájldialógust szokás használni:

path = VRFileDialog( VRWindow(), "Példadialógus", "Megnyit", "*.BMP" )

A függvény elsô paramétere a dialógust meghívó ablak azonosítója, a második pedig a dialógusablak címe. Ezt a két paramétert kötelezô megadni. A meghívó ablak azonosítója helyett a VRWindow() függvényt adtuk meg, amely az éppen végrehajtott REXX programhoz tartozó ablak azonosítóját adja meg. Ez az ablak egészen addig elérhetetlen lesz, amíg a meghívott dialógusablakot be nem zárjuk. A harmadik paraméter a dialógusablak fájlmezeje fölött álló default szöveget cseréli le az általunk megadottra. Az utolsó paraméter, a fájlmaszk a megjelenítendô fájlok listáját határozza meg. Amennyiben teljes elérési útvonalat is megadunk, akkor azzal az alapértelmezés szerinti alkönyvtárt is beállíthatjuk. A függvény visszatérése után a path változóban találjuk meg a választott fájlt a teljes elérési útvonallal.

Egy másik nagyon gyakran használt beépített dialógus az üzenetdialógus:

call VRMessage VRWindow(), "Helló VX-REXX programozó!", "VX-REXX", "I", "button.", 1, 2

Az elsô két paramétert kötelezô megadni. Az elsô a már ismert ablakazonosító, a második pedig a megjelenítendô üzenet. A harmadik opcionális mezô az ablak címét, a negyedik pedig a megjelenítendô ikon típusát adja meg. Az I (information) mellett még rendelkezésre állnak az E (error), N (none), Q (query) és W (warning) ikonok. A button. összetett változó a nyomógombok számát (0. elem) és szövegeit adja meg. Az utolsó két paraméter azt szabja meg, hogy hányas sorszámú gombok aktivizálódjanak az ENTER és ESC gombok megnyomására. Amennyiben többsoros üzenetet kell megjelenítenünk, akkor a VRMessageStem függvényt használhatjuk.

Természetesen nemcsak beépített dialógusokat használhatunk programunkban, hanem saját magunk is készíthetünk új ablakokat. Ha például Window2 néven készítettünk egy dialógust (Project -> New window file) , akkor azt a

value = Window2( VRWindow() )

Többszálas programfuttatás

Klasszikus REXX programok esetében már megszokhattuk, hogy egy adott pillanatban egy szekción belül csak egy programfájl futhatott. VX-REXX programok esetében egy idôben több programfájl is futhat, ami azt jelenti, hogy a VX-REXX programok többszálúak (multithreaded) is lehetnek. A szálak akkor lehetnek nagyon hasznosak, ha viszonylag sok idôt igénylô feladato(ka)t kell végrehajtani és nem akarjuk, hogy a felhasználónak ez idô alatt várni kelljen. Többszálas programok esetében ugyanis a felhasználó tovább dolgozhat az alkalmazással (fô szál) miközben a mellékszál a háttérben végzi a hosszadalmas munkát. Amikor a segédszál kész, akkor a felhasználó errôl értesítést kap és felhasználhatja a rendelkezésre álló eredményeket. VX-REXX-ben kétféleképpen indíthatunk el szálakat. Az egyik módszer az, hogy az Application objektum StartThread metódusát használjuk egy programfájl elindítására. A programfájl neve a harmadik paraméter (File1), míg az átadandó paramétereket ezután soroljuk fel:

tid = VRMethod( "Application", "StartThread", "File1", "Param1" )
if tid = -1 then
     	say "Nem sikerült a szálat elindítani."
else
	say "A szál indítása sikeres! (tid="tid")"

A függvényhívás eredményeként visszakapunk egy szálazonosítót (tid), amely -1-tôl különbözô, ha sikerült a szál elindítása. Ablakfájlt is elindíthatunk a StartThread metódussal, ám ekkor meg kell adnunk az ablakfájl neve elôtt a subroutine kulcsszót és az elsô paraméternek a VRWindow() függvénynek kell lennie:

tid = VRMethod( "Application", "StartThread", "subroutine Window2", VRWindow() )

Mint láttuk, a szál indításakor paramétereken keresztül adhatunk át adatokat neki. A szálnak természetesen adatokat is kell tudni visszajuttatni a hívó programnak. Erre a PostQueue metódus alkalmas:

Call VRMethod "Application", "PostQueue", 0, 1, "call WorkerDone", "WordCount", count

A fenti függvényhívás során a metódus a 0 azonosítóval rendelkezô szálnak (ami mindig a fôprogram) küld egy adatot. A 0-t követô paraméter a várakozási sor azonosítója, 1 azt jelenti, hogy az elsôdleges várakozási sort használjuk. A "call WorkerDone" paraméter azt adja meg, hogy a fôszál az üzenet feldolgozásakor a WorkerDone rutint hívja meg. A WordCount paraméter a visszaadott változó nevét, a count értéke pedig a változó értékét szabja meg. A fôszál programfájljában a WorkerDone rutin a VRInfo utasítást használja a visszaküldött érték kihámozására. Ez a rutin pl. a következôképpen nézhet ki:

WorkerDone:
       count = VRInfo( "WordCount" )
       say "A szál által visszaadott eredmény: "count
return

A PostQueue metóduson kívül a szálak az Application objektum PutVar és GetVar metódusait is használhatják adatcserére. A PutVar beállítja, a GetVar pedig kiolvassa egy adott globális változó (UserName) értékét:

Call VRMethod "Application", "PutVar", "UserName"
Call VRMethod "Application", "GetVar", "UserName"

Az éppen futó szálakról a ListThreads metódussal szerezhetünk információt:

Call VRMethod "Application", "ListThreads", "myThreads."
DO i = 2 TO myThreads.0
     Say 'ID.'i'='myThreads.i
END

Saját azonosító is lekérdezhetô a GetThreadID metódussal:

thread = VRMethod( "Application", "GetThreadID", [ "real" ] ) 

A real paraméter megadása esetén a rendszer által tárolt azonosítót kapjuk vissza. Ha nem adjuk meg a real paramétert, akkor a VX-REXX, a rendszerétôl eltérô azonosítóját kapjuk meg. Bármelyik szálat (a fôszál kivételével) megállíthatjuk az azonosító ismeretében a HaltThread metódussal:

Call VRMethod "Application", "HaltThread", tid

Segítség beépítése

Segítség beépítésére több lehetôség is van a VX-REXX-ben. Amennyiben lehetôségünk van INF vagy HLP fájlok készítésére, akkor ezeket felhasználhatjuk a VX-REXX programokban. Az INF/HLP fájlok csak az IPF help compiler segítségével készíthetôk, ez azonban nem része a VX-REXX-nek. Ha megvan a help fájl, akkor azt hozzáadhatjuk bármelyik tetszôleges ablakhoz, ha beállítjuk annak HelpFile tulajdonságát:

Call VRSet "MyWindow", "HelpFile", "myhelp.hlp"

Egy alternatív megoldás közönséges szövegfájlok felhasználása. Ebben az esetben a segítség szövege egy közönséges szövegfájlban foglal helyet, amelyet a HelpText tulajdonság beállításával hozhatunk az adott ablak tudomására:

Call VRSet "MyWindow", "HelpText", "(myhelp.txt)"

Ha valamilyen speciális szolgáltatásra van szükségünk, akkor a segítségrendszert teljesen magunk is felépíthetjük. Minden ablakhoz létezik ugyanis egy elôredefiniált Help esemény, amely köré tetszôleges helprendszert építhetünk. Bármelyik változatot használjuk, a beépített segítség mindig elérhetô lesz az F1 billentyû megnyomásával.

Hibakeresés

Sajnos a legjobban megírt programban is elôfordulhatnak hibák, amelyek felderítése nem mindig egyszerû feladat. A VX-REXX fejlesztôkörnyezet a hibakeresésben is a segítségünkre siet. Ennek a szolgáltatásnak az elsô szintje az úgynevezett run time exception lekezelése. Ez azt jelenti, hogy ha programunkban valamilyen hiba történik, akkor a VX-REXX megszakítja a program futását és egy ablakban megjelenti, hogy a program mely részén történt a hiba. A hibás sorra kattintva elindul a szövegszerkesztô, betölti a hibás részt és már hozzá is foghatunk a javításhoz.

A második szint az interaktív hibakeresô-környezet. Ez azt jelenti, hogy programunkat lépésrôl lépésre hajthatjuk végre és megvizsgálhatjuk az egyes változók tartalmát. Amennyiben a hibakeresôben kívánjuk futtatni programunkat, csak annyit kell tennünk, hogy a Run -> Run project menüpont helyett a Run -> Debug projectet választjuk a futtatáshoz. A környezet tulajdonképpen négyfajta ablakból áll. A programfájlok és a hozzájuk tartozó szekciók a Section ablakban láthatók. Ugyanebbôl az ablakból lehet a másik három ablakfajtát is megnyitni. A második fajta ablak a forráskód (szekció) megjelenítésére szolgál. Ebbôl az ablakból lehet töréspontokat beállítani vagy változókat kiválasztani, amelyeknek az értéke a harmadik fajta ablakban, a változó ablakban követhetô nyomon. A negyedig fajta ablak az eredményablak, amelyben a REXX programértelmezô által rendelkezésre bocsátott információ látható.

A hibakeresés kellékei

REXX GYÍK:

K1. Lehetséges-e drag and drop mûveletek programozása VX-REXX-ben?
V1. Természetesen. A legtöbb beépített VX-REXX objektum lehetôvé teszi a drag and drop használatát. Leckénkben terjedelmi okok miatt nem tértünk ki néhány dologra, így a drag and drop programozására sem. Ezeket azonban igen jól dokumentálták a VX-REXX-hez adott programozási segédletben (VX-REXX Programmer's Guide).

Gyakorlat:

1. A leckében bemutatott példaprogram üres sorokat is hozzáad a listához. Alakítsuk át a programot, hogy ez ne történhessen meg! Úgy oldjuk meg a feladatot, hogy a nyomógombot a beviteli mezô értékének megváltozásakor (Change event) kikapcsoljuk (Set property -> Enabled értéke 0), ha a beviteli mezô éppen üres lenne! A program indításakor se legyen engedélyezve a nyomógomb! Ezt elérhetjük a nyomógomb tulajdonságait tartalmazó jegyzettömb Style oldalán található Enabled jelölônégyzet kikapcsolásával. Érdemes engedélyezni az ugyanezen az oldalon található Default tulajdonságot. Ez azt jelenti, hogy a Click esemény lesz az alapértelmezett esemény, s a hozzá tartozó rutin az ENTER gomb megnyomására is végre fog hajtódni. Ezzel elérhetjük azt, hogy a beviteli mezôbe beírt szövegek az ENTER megnyomására is hozzáadódjanak a listához.

2. Bôvítse ki a példaprogramot segítô üzenetekkel (hints)! Ehhez csupán ki kell töltenie az objektumok beállításait tartalmazó jegyzettömb Hint oldalán található beviteli mezôket a megfelelô üzenetekkel. Ne felejtse el a fôablak jegyzettömbjének Hint oldalán a ShowHints jelölônégyzet megjelölésével a segítô üzenetek megjelenítését engedélyezni!

Kádár Zsolt 1999. 10. 24.

[ Elôzô lecke | Következô lecke | Tartalom ]