BEVEZETÉS A

POWERBUILDER

FEJLESZTŐ RENDSZER ALKALMAZÁSÁBA

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Szerkesztette: dr. Kovács László

Szerzők: dr. Kovács László, egyetemi docens (1., 3., 4. fejezet)

Varga Erika, egyetemi tanársegéd (2., 5., 7. fejezet)

Varga Andor, demonstrátor (4., 6. fejezet)

 

 

Miskolci Egyetem

Általános Informatikai Tanszék

 

Tartalomjegyzék

 

  1. A PowerBuilder 4GL fejlesztő rendszer alapjai 3
  2. A PowerScript programozási nyelv 16
  3. ADATBÁZIS KEZELÉSÉNEK alapjai A POwerbuilder

    4. rendszerben 36

  4. ADATKEZELÉS DATAWINDOW SEGÍTSÉGÉVEL 56
  5. Objektum-orientáltság A PowerBuilder-ben 67
  6. DATA WINDOW VEZÉRLŐ ELEM TULAJDONSÁGAI, METÓDUSAI 81
  7. MENÜ KÉSZÍTÉSE ÉS A FUTTATHATÓ ALKALMAZÁS GENERÁLÁSA 94

 

 

 

 

 

 

1. A PowerBuilder 4GL fejlesztő rendszer alapjai

 

Struktúra áttekintés

A PowerBuilder egy 4GL fejlesztő rendszer, amely erőteljesen támogatja a kliens – szerver és osztott struktúrában működő alkalmazások fejlesztését. Az alkalmazások objektum orientált környezetben dolgozhatók ki, s Windows-os környezetben futnak. A fejlesztő rendszer az egyes objektumok grafikus szerkesztőit is tartalmazza a minél gyorsabb és hatékonyabb alkalmazás fejlesztés érdekében. A elkészített alkalmazások az elsődleges relációs adatforrások mellett más típusú adatforrások adataival is dolgozhatnak.

A PowerBuilder rendszer is külön tartalmaz fejlesztő és futtató változatot. A fejlesztő változat többek között tartalmaz az egyes alkalmazás komponensek előállítására szolgáló vizuális szerkesztőket, s rendelkezik közvetlen adatforrás elérési, kezelési elemekkel is. A fejlesztőben az elkészített alkalmazás generálással futtatható kóddá alakítható. A kódolt program a PowerBuilder futtató változatában végrehajtható. A futtató változatban már nem lehet az elkészült programot módosítani.

A fejlesztés során elkészített kód, leírás egy adatszótárban kerül letárolásra. Az adatszótár tartalmazza mind a forrás leírást mind a generált kódot.

1. ábra

Az alkalmazások fejlesztése során modulonként rakjuk a kész rendszert. Az egyes modulok elkészítésére különböző vizuális szerkesztők (painter) állnak rendelkezésre. A legfontosabb alkalmazás elemek a következő osztályokat, objektum típusokat foglalják magukba:

A fenti elemek mellett nem szabad még egy fontos elemről megfeledkezni, a scriptek-ről. A script, mint kódszelet értelmezhető, amely nem egy önálló objektumot jelent, hanem egy 3GL-ben megadott kódrészletet jelöl. Az egyes objektumok egyedi viselkedése ilyen kódszeleteken keresztül adható meg. A PowerBuilder esetében e 3GL komponenst a PowerScript elnevezéssel illetik. Ez a nyelv az adatbázis kezelő utasítások mellett tartalmaz többek között

részt is.

A fejlesztés során létre kell hozni az igényelt objektumokat, amik az alkalmazás futtatásához szükségesek a megfelelő tervező szerkesztő (Painter) segítségével. Az elkészített részek a fejlesztés során is közvetlenül lefuttathatók, így gyorsan ellenőrizni tudjuk az eddigi beállítások, kódszeletek helyességét, anélkül, hogy ki kellene lépnünk a PowerBuilder fejlesztő környezetből.

A PowerBuilder fejlesztő környezet indításakor egy menürendszer, eszközsor jelenik meg a különböző objektum típusok kezelésére. Az elérhető menüpontokat mutatja be a következő ábra:

2. ábra

 

A fejlesztés további lépéseiben e menükből választhatjuk ki az éppen igényelt funkciót. A fenti ábra alapján érdemes megjegyezni az egyes objektum típusok grafikus reprezentálását, mivel a rendszer igen gyakran e szimbólumokkal utal az egyes elemek tipusára.

A PowerBuilder Library objektuma

A létrehozott objektumok egy adatszótárban, Library-ban tárolódnak. A Library az operációs rendszer szinten olyan állományként jelenik meg, melynek kiterjesztése:

PBL

A PowerBuilder fejlesztő rendszerben egyidejűleg több adatszótár állomány is létezhet, de minden objektum egy példánya csak egyben foglalhat helyet. Egy objektumot azonban átmásolhatunk más adat szótárakba is, azaz ekkor az egyes példányok más-más adat szótár állományban lesznek elhelyezve. A fejlesztés során célszerű a logikailag összetartozó elemeket egy adatszótár állományban elhelyezni. A futó alkalmazás nyilvántart egy keresési útvonalat, mely megadja hogy egy objektum hivatkozáskor mely adatszótár állományokat keresse fel és milyen sorrendben a hivatkozott objektum leírásának megkeresésére. Az egyes adat szótár állományok mint OS állományok átmásolhatók az egyik helyről a másikra, lehetővé téve az alkalmazás mentését, más gépre történő mozgatását.

A PowerBuilder rendszer az adat szótárakra vonatkozólag biztosít állomány szintű műveleteket (mint például új PBL létrehozása vagy PBL törlése), illetve objektum szintű kezelési műveleteket, mint

A Library szerkesztő a kinyitott adatszótár állománynál megmutatja a benne tárolt objektumokat. A komponensek kijelzésekor egy grafikus szimbólum utal a komponens tartalmára.

3. ábra

A PowerBuilder Application objektuma

Míg a Library objektum csak a tárolási hely kezelésére szolgált, addig az Application, azaz alkalmazás objektum már közvetlenül a futtatandó alkalmazáshoz, programhoz kötődik. Az alkalmazás objektum fogja össze az egyazon programhoz kötődő objektumokat. Maga az alkalmazás objektum egy úgynevezett nem-látható objektum, csak a háttérben, a memóriában van jelen. Az alkalmazás így összefogja, reprezentálja a futáshoz szükséges program elemek összességét. Ezen objektum tulajdonságai az egész alkalmazást érintő globális paraméterek leírására szolgálnak.

A globális tulajdonságok tárolása mellett egy másik fontos jellemzője az alkalmazás objektumnak, hogy ez lesz az alkalmazás belépési pontja is, vagy az alkalmazás futtatásakor ez az objektum fog aktivizálódni, s ennek kell az alkalmazás többi objektumát majd életre keltenie.

Egy új alkalmazás készítésének első lépése egy új Application objektum létrehozása. Ezt megtehetjük az alábbi lépéssorozattal:

Új alkalmazás létrehozatalakor választhatunk, hogy

A létrejött alkalmazás megjelenik az alkalmazás szerkesztőben. Ezt az elemet kijelölve a főmenü Entry- Properties menüpontján keresztül meghívható az alkalmazás tulajdonságainak beállítására szolgáló ablak (4. ábra). Ebben az ablakban többek között megadható

Ha megpróbálunk lefuttatni egy így létrehozott üres alkalmazást, amit a főmenü Run menüpontját keresztül tehetünk meg, akkor egy

’This application needs a script for its open event’

hibaüzenetet kapunk. A hibaüzenet arra utal, hogy valami hiányzik még a program futtatásához.

4. ábra

Az alkalmazás objektum egyik fontos feladata, hogy ő lesz az alkalmazás belépési pontja. Vagyis a futtatáskor az Application objektum egyik metódusa fog elsőként elindulni. Ez a metódus nem más, mint az

Open

metódus. Tehát az ezen metódushoz tartozó kódszeletben kell megadni az alkalmazás induló lépéseit. Az objektumhoz tartózó kódszeleteket az objektum kijelölése után az Entry – Script menüpontján keresztül érjük el. Ekkor behívódik a Script szerkesztő, mely egy kibővített szövegszerkesztőnek is tekinthető, ahová a PowerScript nyelv parancsainak ismeretében leírható a végrehajtandó lépések kódja. A Script szerkesztő felépítését a következő ábra mutatja.

5. ábra

A metódusok programozásánál a Select Event legördülő menüből választhatjuk ki, hogy melyik metódust is fogjuk elkészíteni, vagy módosítani. Válasszuk ki most az Open metódust, és irjuk be az ábrán is megadott utasításokat. Ezen utasítások pusztán arra szolgának hogy létrehozzunk egy a egész típusú változót, majd értéket adjunk a változónak. E kódrészlet csak azért lett magadva, hogy ne legyen üres az Open metódus. Ha lementjük a kódszeletet és újra próbálkozunk a futtatással, akkor most már nem kapunk hibajelzést, lefut az alkalmazás, igaz nem csinál semmit sem. Hogy valamit lássunk a futás eredményeképpen egy ablakot fogunk létrehozni, melyet majd a futó program megjelenít.

Mielőtt áttérnénk az ablakokra, megemlítjük, hogy az alkalmazásnak az Open metódus mellett még létezik Close metódusa, mely az alkalmazás befejezéskor hívódik meg.

 

A PowerBuilder Window objektuma

A Window, azaz ablak objektumok szolgálnak az információk megjelenítésére, adatatok beolvasására a felhasználó-program kommunikációja során. Az ablakokat a rendeltetési céljuk, viselkedésük és paraméterezhetőségük alapján négy csoportba sorolhatjuk:

Az ablakok egy másik fontos típusa a DataWindow, adatablak, melyben adatbázis táblák adati lesznek elérhetők, kezelhetők.

Az ablak létrehozásának főbb lépései:

A fenti parancsok hatására meghívódik a Window szerkesztő (6. ábra), melyben definiálhatjuk az ablakhoz tartozó vezérlő elemeket, megadhatjuk az ablak tulajdonságait, s a viselkedését meghatározó metódusokat. Az ablak szerkesztő vizuális szerkesztő, melyben rögtön látjuk a megjelenítési paraméterek hatását anélkül, hogy futtatni kellene a programot.

Az ablak objektumhoz több fontos tulajdonság is köthető, melyek az ablak kiválasztása után az Edit – Properties menüpont aktivizálásával érhetők el. A megjelenő paraméter beállító ablakot a 7. ábra mutatja. Az ablak objektumhoz a következő fontosabb tulajdonságok köthetők:

 

6. ábra

7. ábra

Az ablak rendszerint nemcsak egy üres keretet jelent, hanem több különböző vezérlő elemmel rendelkezik, melyek különböző szolgáltatásokat nyújtanak a felhasználó számára. A PowerBuilder-ben , mint objektum orientált nyelvben, az egyes vezérlő elemek is önálló objektumokként jelennek meg a programban. Az ablaknak vezérlő elemmel történő bővítéséhez ki kell nyitni az ablak szerkesztőben a vezérlő elemekhez tartozó menüpontot. A 6. ábra éppen egy ilyen nyitott vezérlő elem menüpontot mutat. Itt mindegyik grafikus elem egy-egy vezérlő elem típust szimbolizál. A legfontosabb vezérlő elem tipusok:

A kiválasztott vezérlő elem típus az egér segítségével átvihető az ablak munkaterületére. Ezáltal létrejön egy olyan új objektum, amely az ablakhoz tartozik és típusa a kijelölt típus lesz. A létrehozott objektum paraméterei az objektum kijelölésére szolgáló ablak megjelenítése után a főmenü Edit – Properties pontján keresztül érhetők el. A beállítható paraméterek típusa és jelentése vezérlőelem függő. A következő ábra az egysoros beviteli mező tulajdonságnak kezelésére szolgáló ablakot mutatja.

8. Ábra

Mint az ábrán is látható, a beviteli mező tulajdonságai között szerepel a

Több objektum együttes elhelyezése esetén igen fontos a megfelelő megjelenés, külalak. Ehhez szimmetrikusan, egymáshoz is igazítva kell elhelyezni az egyes vezérlő elemeket. Mivel kézzel igen körülményes egyenként beállítani a megfelelő pozíciókat, az ablak szerkesztő automatikus igazítási funkcióval is rendelkezik. Ehhez a főmenüből az Edit – Align Control menüpontot kell aktivizálni. Ennek segítségével az előzőleg kijelölt objektumokat

Az Edit – Space Control segítségével az egyes vezérlő elemek közötti térközt, míg a Size Control segítségével az egyes objektumok méreteit lehet szabályozni.

A megjelenítési paramétereken kívül az ablak objektum viselkedését is be kell állítanunk az alkalmazási környezet igényeinek megfelelően. Az egyedi viselkedési elemek már PowerScript kódszeletek készítését igénylik. A kódszeletek azonban nemcsak az egyes tevékenységek kiváltására szolgálhatnak, emellett alkalmasak az objektumok tulajdonságainak menetközbeni, dinamikus beállítására is. A PowerBuilder alkalmazások is már esemény orientált metodikával dolgoznak, vagyis az alkalmazás úgy működik, hogy a program felkészül egyes eseményekre, megadva az azokra adandó válaszokat, s a futás során a felhasználó eseményeket fog generálni, amire a program elvégzi a kijelölt választevékenységet. Így a PowerBuilder objektumok esetén az egyedi viselkedési felület kialakításához három dolgot is meg kell ismerni az objektumhoz kötődően:

Ezek ismeretében tudom a megfelelő kódszeleteket is elkészíteni. A következőkben három alapobjektum, a

legontosabb elemeit tekintjük át.

A Window objektum gyakrabban használt tulajdonságai:

A Window objektum gyakrabban használt eseményei:

A Window objektum gyakrabban használt metódusai:

Az ablakok kezelése során a fenti listát átnézve biztos hiányérzetünk támad, hiszen nem tudjuk meg belőle, hogyan is lehet egy ablakot létrehozni, majd megszüntetni. Ehhez nem az ablakhoz kapcsolódó programozási elemeket kell áttekintenünk, hanem egy újabb eszközhalmazt, az úgynevezett rendszer függvények körét. A rendszer függvények, általános, nem egy konkrét objektumhoz kötődő tevékenységek végrehajtására szolgálnak. Ezen függvények közül az

Open(ablak)

szolgál egy ablak létrehozására, megnyitására. Ha tehát egy alkalmazásban egy XXX nevű ablakot szeretnénk megjeleníteni és használni, akkor elsőként ki kell adni egy Open(XXX) hívást az alkalmazás megfelelő, rendszerint induló kódszeletében.

Ha egy ablakra már nincs szükség, le lehet zárni, akkor az ablak lezárását a

Close(ablak)

hívással tudjuk elérni. Néhány további fontos rendszer függvény leírását a PowerScript-et ismertető fejezetben találhatjuk meg.

Az ablak objektum után tekintsük át a nyomógomb objektumhoz kötődő programozási elemeket.

A CommandButton objektum gyakrabban használt tulajdonságai:

A CommandButton objektum gyakrabban használt eseményei:

A CommandButton objektum gyakrabban használt metódusai:

A harmadik, igen gyakran használt vezérlő elem az egysoros beviteli mező. Ehhez a következő programozási elemeket kínálja fel a rendszer.

A SingleLineEdit objektum gyakrabban használt tulajdonságai:

A SingleLineEdit objektum gyakrabban használt eseményei:

A SingleLineEdit objektum gyakrabban használt metódusai:

 

PÉLDAPROGRAM

 

Az előzőekben vázolt PowerBuilder elemek szemléltetésére egy kis mintapéldát veszünk. Az alkalmazás elindítása után egy ablakot jelenít meg, melyben egy egysoros beviteli mező és két nyomógomb van. Az egyik feliarata : KILÉPÉS és hatására leáll az alkalmazás. A másik nyomógomb felirata TOROL és kitörli a beviteli mező tartalmát.

Az alkalmazás fejlesztés lépései:

A fenti programozási lépések után elindítható a program. A futó program képernyőjét mutatja be a következő ábra.

9. ábra

 

 

 

 

 

 

 

 

 

 

2 A PowerScript programozási nyelv

 

Script definíció

A PowerBuilder-ben a script (szkript) egy esemény bekövetkezése esetén végrehajtandó utastások halmaza, egy kódszelet, ami PowerScript nyelven íródott.

A szkriptekben használt utasítások típusai:

ALAPOK

Kommentezés

A megjegyzés lehet

Sortördelés

A PowerBuilder-ben a sorokat nem kell külön karakterrrel lezárni, egy sor egy utasítást jelent. Amennyiben egy logikai utasítást több sorban írunk le, használnunk kell a ’&’ sortörés karaktert. Használatának feltétele:

Megjegyzés: Beágyazott SQL utasítások esetén az utasítás végét a ’;’ karakter jelzi, tehát több soros utasítás esetén sem kell használni a sortörés ’&’ karakterét.

Például:

SELECT emp_id, salary

INTO :li_emp, :ldc_pay

FROM employee

WHERE emp_id = :li_which_emp USING SQLCA;

Azonosítók használata

Az azonosító nevek megadásakor az alábbi szabályokra kell ügyelni:

Megjegyzés: Annak érdekében, hogy ne keverjük össze a kivonás ’-’ jelét az azonosítókban használható ’-’ jellel, ezért a mínusz jel előtt mindig kell hagyni egy üres karaktert, vagy zárójelet vagy egy üres karaktert a mínuszjel után.

Például:

a=b-c helytelen ("b-c" változóként értelmezi)

a=(b)-c helyes, de a=b-(c) helytelen, mert “b-“ nevű függvényt keres

a=b –c vagy a=b- c helyes

Adattípusok

Alaptípusok

  

Any

Olyan adattípus, mely felveszi a hozzárendelt adat típusát. Felvehető adattípusok: bármely alaptípus, struktúrák, tömbök és objektumok.

Blob

Nagyméretű bináris objektum típus, korlátlan mennyiségű adat tárolására (pl. Word dokumentum, kép stb.).

Boolean

TRUE vagy FALSE értékű.

Char

Egyetlen karakter. (Megadása történhet ’ ’ vagy " " között is.)

Date

Dátum yyyy-mm-dd formátumban.

DateTime

Dátum és idő típus kombinálva egyetlen változóba.

Double

Előjeles lebebőpontos számok 15 számjegy pontossággal.

Értelmezési tartomány: 2.2E-308 – 1.7E+308

Decimal (Dec)

Előjeles decimális számok 18 számjegy pontossággal. A tizedespont bárhol előfordulhat a 18 számjegy között és nem számít bele a 18 számjegybe.

Integer (Int)

16-biten ábrázolt előjeles egész számok.

Értelmezési tartomány: -32768 - +32767

Long

32-biten ábrázolt előjeles egész számok.

Értelmezési tartomány: -2147483648 - +2147483647

Real

Előjeles lebegőpontos számok 6 számjegy pontossággal.

Értelmezési tartomány: 1.17E-38 – 3.4E+38

String

16-bites operációs rendszereken max. 60 karakter hosszúságú sztring, vagy 32-bites rendszerekben korlátlan hosszúságú karakterlánc. Sztring konstansok megadása történhet ’ ’ vagy " " között is. Egy sztringben " megadása: ~".

Time

Idő típus 24 órás formátumban, hh:mm:ss alakban.

Unsigned Integer

(UnsignedInt, UInt)

Előjel nélküli egész számok 16-biten ábrázolva, 0-65535 tartományban.

Unsigned Long

(ULong)

Előjel nélküli egész számok 32-biten ábrázolva, 0-4294967295 tartományban.

Felsorolt típusok

A felsorolt adattípusú változók csak egy előre megadott értékhalmazból vehetnek fel értéket. Alkalmazásuk:

A felsorolt típus megadása:

A felsorolt adattípus előnye, hogy nem igényel külön értékellenőrzést.

Példa néhány felsorolt adattípusra:

Adattípus

Felvehető értékek

Alkalmazási példa

Alignment

Center!

Justify!

Left!

Right!

Alignment left_align

Left_align = Left!

Icon

Exclamation! (felkiáltójel)

Information!

Question!

StopSign!

None! (üres ikon)

MessageBox("Title", &

"Msg", Exclamation!)

TextCase

Anycase!

Upper!

Lower!

sle_name.Textcase = Upper!

HelpCommand

Index!

Keyword!

Topic!

ShowHelp("app.hlp", Index!)

WindowState

Maximized!

Minimized!

Normal!

Run("sample.exe", &

Maximized!)

A felsorolt adattípusok listáját lásd a PowerBar ® Browser ® Enumerated ablakban.

Változók

A változók egyik fontos jellemzője, hogy az alkalmazás melyik részeiben lehet elérni őket. Ezt a változó hatásköre határozza meg.

Hatáskör

 

A különböző hatáskörben megadott változók nevei lehetnek azonosak, de akkor a következő fontossági (láthatósági) sorrend érvényesül:

  1. Lokális

  2. Osztott (shared)

  3. Globális

  4. Objektum-előforduláshoz kötődő (instance)

Változók elnevezésének konvenciói

A változó hatáskörének és típusának ismerete fontos a programozó számára. Hogy ezen az információkat ne kelljen egy külön leírásból kikeresni, a változó azonosító nevében szokás kódolni mind a hatáskör, mind a típus leírást. Így a szabványos azonosító név az alábbi alakot veszi fel:

hatáskör|adattípus_elnevezés

Példák:

la_dwdata //any típusú lokális változó

si_count //integer típusú osztott változó

gs_name //sztring típusú globális változó

il_rownum //long típusú objektum-előforduláshoz kötődő változó

Változók megadása

A változókat deklarálni kell mielőtt felhasználjuk őket. A deklarációs utasítás formája:

adattípus változónév [=kezdőérték]

Több, azonos típusú változó megadása történhet egy sorban, a változók neveit vesszővel elválasztva.

Példák:

integer li_return_code //integer típusú lokális változó

long ll_x, ll_y, ll_z //long típusú lokális változók

decimal {2} ldc_balance /*decimális típusú lokális változó, ahol kötelező a tizedespont utáni számjegyek számának (pontosság) megadása*/

date gd_today //dátum típusú globális változó

Kezdőérték

A változó deklarálásakor adhatunk kezdőértéket a változónak, vagy elfogadhatjuk a PowerBuilder-ben alapértelmezett kezdőértéket.

A PowerBuilder által nyújtott alapértelmezett kezdőértékek:

Adattípus

Kezdőérték

Bármely numerikus adattípus

0

Boolean

FALSE

Date

1900-01-01

DateTime

1900-01-01 00:00:00

String

"" (üres sztring)

Time

00:00:00

 

Példák:

string ls_sortby = "zipcode" //sztring típusú lokális változó

dec {2} ldc_account_balance = 0.00 /*két tizedesjegy pontossággal megadott lokális változó*/

blob{100} ib_Emp_Picture /*objektum-előforduláshoz kötődő 100 byte méretű bináris objektum*/

Értékadás

Az értékadás művelete az egyik legfontosabb utasítás, alakja:

változónév = kiértékelhető_kifejezés

Megjegyzések:

Konstansok

CONSTANT adattípus változónév = kezdőérték

Példák:

CONSTANT INT RED = 255

CONSTANT date date_compiled = Today( )

Tömbök

Több, logikailag összetartozó azonos típusú értékek esetén tömb alkalmazható adattárolásra. A tömb létrehozásának formátuma:

adattípus változónév [ { d1, ..., dn } ] { = { értéklista } }

ahol di az egyes dimenziók méretét jelöli. A tömbök indexelése alapértelmezés szerint 1-től kezdődik!

Példák:

decimal {2} ld_prices[ ] // 2 tizedesjegyet tartalmazó decimális számok tömbje

blob lb_data[ ] // Lokális blob típusú változók tömbje

date ld_birthdays[ ] // Dátumtömb

string ls_city[ ] // Különböző hosszúságú sztringek tömbje

integer li_stats[ ] = {23, 12} // Integerek 2 elemű tömbje

integer li_TaxCode[3] // 3 integer értéket tartalmazó tömb

string ls_day[7] // 7, különböző hosszúságú sztring tömbje

blob ib_image[10] // Különböző méretű blob típusú változók 10 elemű tömbje

dec{2} lc_Cost[10] // 2 tizedesjegyű decimális számok 10 elemű tömbje

decimal lc_price[20] // Különböző pontosságú decimális számok 20 elemű tömbje

Fix hosszúságú tömbök esetén használhatjuk a TO kulcsszót egy elemszám tartomány kijelölésére (ahelyett, hogy a tömb méretét adnánk meg). A TO megadásával megváltoztathatjuk a tömb alsó határindexét (úgy, hogy a felső határindex mindig nagyobb legyen, mint az alsó).

real lr_Rate[2 to 5] /* Real típusú változók 4 elemű tömbje, a 2-iktól az 5. elemig tartalmaz értékeket */

integer li_Qty[0 to 2] // 3 integer értéket tartalmazó tömb (0., 1., 2. elem)

string ls_Test[-2 to 2] // 5 sztringet tartalmazó tömb

integer li_year[76 to 96] // Integer értékek 21 elemű tömbje

integer li_count[10 to 5] /* Helytelen tömb deklaráció, mert az alsó határindex nagyobb, mint a felső */

integer li_price[-10 to -20] /* Helytelen használata a TO tartomány kijelölőnek, mert az alsó határindex nagyobb, mint a felső */

integer li_score[2,3] //Kétdimenziós, 6 elemű integer tömb

integer li_RunRate[1 to 5, 10 to 25]

/* Olyan kétdimenziós integer tömb, ahol az első dimenzió indexe 1-től 5-ig, míg a második dimenzió tömbindexe 10-től 25-ig fut*/

long ll_days[3, 300, 50] //Háromdimenziós, 45 ezer elemű long tömb

integer li_staff[100, 0 to 20, -5 to 5]

Operátorok

Operátor

Szimbólum

Aritmetikai

+, -, *, /, ^, ++, +=, --, -=, *=, /=, ^=

Relációs

=, >, >=, <, <=, <>

Logikai

AND, OR, NOT

Sztring összefűzés

+

Objektum vmely tulajdonságának (tagjának) kijelölése

.

Megjegyzések:

NULL érték

A NULL érték azt jelenti, hogy az adott változó értéke nem ismert, nem meghatározott. Tehát nem azonos az üres sztringgel vagy a 0 értékkel!

Egy változó értéke a következő két esetben lehet NULL:

Megjegyzések:

Ciklusszervező utasítások, elágazások

Kapcsolódó utasítások:

RETURN, EXIT, CONTINUE, GOTO

  1. CHOOSE CASE

    2. CHOOSE CASE változó

    CASE kifejezéslista

    utasításblokk

    { CASE kifejezéslista

    utasításblokk. . . }

    { CASE ELSE

    utasításblokk }

    END CHOOSE

    Kifejezés típusa

    Példa

    Egyetlen érték

    CASE 3

    Értéktartomány

    CASE 10 TO 25

    CASE ’a’ TO ’k’

    Értéklista

    CASE 5, 10, 15, 20

    Relációs kifejezés

    CASE IS < 25

    Az előző típusok kombinációja

    CASE 3, 5 TO 7, 24

     

  2. IF … THEN

IF feltétel1 THEN

választevékenység1

{ ELSEIF feltétel2 THEN

választevékenység2 . . . }

{ ELSE

választevékenység3 }

END IF

Megjegyzések:

  1. FOR…NEXT

FOR ciklusváltozó = kezdőérték TO végérték {STEP növekmény}

utasításblokk

NEXT

 

Megjegyzések:

  1. DO…LOOP

Előltesztelő formák:

  1. DO UNTIL feltétel b) DO WHILE feltétel

utasításblokk utasításblokk

LOOP LOOP

 

Hátultesztelő formák:

c) DO d) DO

utasításblokk utasításblokk

LOOP UNTIL feltétel LOOP WHILE feltétel

Megjegyzések:

Struktúrák

A struktúra egy vagy több, tetszőleges típusú változó (struktúra elem) egyetlen logikai egységbe tömörítése. Tulajdonképpen egy PowerBuilder osztály, melyhez különböző tulajdonságokat rendelhetünk.

Struktúrát definiálhatunk a Structure Painter programban, ahol fel kell sorolnunk a struktúra elemeit (név, típus). A struktúra definiálása és PBL könyvtárba történő elmentése után deklarálhatunk változókat ilyen struktúra típussal és adhatunk értéket az egyes tulajdonság (struktúra) elemeknek.

Példa:

Employee struktúra:

s_emp emp_id integer

emp_name string

emp_deptid integer

emp_picture blob

Változó deklarálása:

s_emp lstr_employee //struktúra típusú lokális változó

Értékadás a struktúra változóinak:

lstr_employee.emp_id = 172

lstr_employee.emp_name = ’Joe Smith’

lstr_employee.emp_deptid = 2

lstr_employee.emp_picture = "photo.bmp"

Hivatkozási előtagok

A PowerScript hivatkozási előtagok lehetővé teszik, hogy általánosan hivatkozzunk objektumokra vagy vezérlési elemekre. Ezek használata azért célszerű, mert így a hivatkozás akkor is érvényben marad, ha az objektum vagy vezérlési elem neve megváltozik.

Hivatkozási előtag

Hol használható

Mire hivatkozik

This

Különböző objektumok (ablak, menü stb.) és vezérlési elemek szkriptjeiben

Magára az objektumra vagy vezérlési elemre

Parent

Egy ablakhoz rendelt vezérlési elem, vagy

menü szkriptjében

A vezérlési elemet tartalmazó ablakra, vagy

az eggyel magasabb szinten lévő menüelemre

Super

Leszármazott objektum vagy vezérlési elem esetén

Szülő vagy ősobjektum

ParentWindow objektum tulajdonság: Menükhöz írott szkriptekben ezt a menü-objektum tuljadonságot hivatkozási előtagként használhatjuk. A program futása során ez azt az ablakot azonosítja, amelyikhez a menüt társítottuk.

Fontosabb függvények

  1. Matematikai függvények

    2. Sqrt(n)

    Double értékkel tér vissza. Kiszámítja egy szám négyzetgyökét. Negatív számot megadva hibajelzéssel tér vissza.

    Mod(x,y)

    Az x/y matematikai művelet maradékát adja eredményül.

    Log(n)

    Double eredményt ad. Kiszámítja n természetes alapú logaritmusát, ahol n > 0.

    Exp(n)

    Double eredményt ad. Kiszámítja e n-edik hatványát.

    Sin(n)

    Double eredményt ad. Kiszámítja egy radiánban megadott szög szinuszát.

    Cos(n)

    Double eredményt ad. Kiszámítja egy radiánban megadott szög cosinuszát.

    Abs(n)

    Kiszámítja n abszolút értékét.

  2. Típus ellenőrző és konverziós függvények

    3. Char(n)

    Visszaadja egy sztring első karakterét, vagy egy integer értéket karakterré konvertál.

    Dec(n)

    Sztringet decimális számmá konvertál.

    Double(n)

    Sztringet double értékké konvertál.

    Integer(n)

    Sztringet integer értékké konvertál.

    Long(n)

    Sztringet long értékké konvertál.

    Real(n)

    Sztringet real értékké konvertál.

    Time(datetime)

    Egy datetime típusú változó idő részét adja vissza.

    Date(datetime)

    Egy datetime típusú változó dátum részét adja vissza.

    Date(string)

    Megfelelő formátumú sztringet dátummá alakít. Amennyiben nem megfelelő a sztring formátuma, úgy 1900-01-01 dátummal tér vissza.

    Date ( year, month, day )

    Numerikus értékeket dátummá alakít, ahol az év 4 számjegyű, a hónap 1 v. 2 számjegyű és a nap 1 v. 2 számjegyű.

    DateTime ( date {, time } )

    Egy dátum és egy idő értéket DateTime értékké kombinál. Ha az időt elhagyjuk, akkor 00:00:00-ra állítja a rendszer.

    IsDate(string)

    A megadott sztring érvényes dátum formátum-e.

    IsTime(string)

    A megadott sztring érvényes idő formátum-e.

    IsNull(n)

    Az argumentum NULL értékű-e (nem értelmezett).

    IsNumber(n)

    Az argumentum numerikus érték-e.

    String ( data, { format } )

    Sztringgé konvertál egy dátum, idő vagy DateTime típusú változót megadott formátumban; illetve egy numerikus értéket.

  3. Sztringkezelő függvények

    4.

    Fill( chars, n )

    Adott n hosszon feltölt egy sztringet a megadott karaktereket ismételve.

    Left( string, n )

    Egy sztring elejéről n számú karakterrel tér vissza.

    LeftTrim(string)

    Levágja egy sztring elejéről az üres karaktereket.

    Len(string/blob)

    Long értékkel tér vissza, és visszaadja egy sztring vagy blob hosszát.

    Lower ( string )

    A megadott sztringet kisbetűssé konvertálja.

    Match( string, textpattern )

    Boolean értékkel tér vissza. Megmondja, hogy az adott sztringben megtalálható-e a keresett szövegminta.

    Mid(string, start {,length})

    Az adott sztringből visszaadja a megadott pozícióban kezdődő, adott hosszúságú rész-sztringet.

     

    Pos(string1, string2 {,start})

    Az első sztringben keresi a második sztring előfordulását a megadott pozíciótól kezdve. A Default keresési pozíció 1, az első sztring eleje. Visszatérési értéke long, az első előfordulás helye. Kis- és nagybetű érzékeny!!!

    Replace(string1, start, n, string2)

    Az első sztringben az adott pozíciótól kezdődően n hosszúságú karakterláncot kicserél a második sztringre.

    Reverse ( string )

    Megfordítja a karakterek sorrendjét egy sztringben.

    Right ( string, n )

    Az adott sztring végéről n számú karakterrel tér vissza.

    RightTrim ( string )

    A sztring végéről levágja az üres karaktereket.

    Space ( n )

    Adott hosszúságú sztringet hoz létre üres karakterekkel feltöltve.

    Trim ( string )

    A sztring elejéről és végéről levágja az üres karaktereket.

    Upper ( string )

    A sztring minden egyes karakterét nagybetűvé alakítja.

     

  4. Dátumkezelő függvények

    5. Day ( date )

    Egy dátumból visszaadja a napot integerként (1-31).

    DayName ( date )

    Egy dátumból visszaadja a napot sztringként (hétfő, kedd stb.).

    DayNumber(date)

    Egy dátumból visszaadja a nap sorszámát a héten (vasarnap= 1, hétfő=2 stb.).

    DaysAfter(date1, date2)

    Megadja, hogy a második dátum hány nappal későbbi, mint az első. Ha date1 > date2 akkor negatív Long értékkel tér vissza.

    Hour ( time )

    Visszaadja az órát integerként (00-23) az adott idő változóból.

    Minute ( time )

    Visszaadja a percet integerként (00-59) az adott idő változóból.

    Month ( date )

    Egy dátumból visszaadja a hónapot integerként (1-12).

    Now ( )

    Megadja az aktuális időt a rendszeridő alapján.

    RelativeDate ( date, n )

    A megadott dátumnál n nappal (integer) korábbi vagy későbbi dátumot adja meg.

    RelativeTime ( time, n )

    A megadott időpontnál n másodperccel korábbi vagy későbbi időpontot adja meg 24 órán belül.

    Second ( time )

    Visszaadja a másodpercet integerként (00-59) az adott idő változóból.

    Today ( )

    Az aktuális rendszerdátumot adja meg.

    Year ( date )

    Egy dátumból visszaadja az évet integerként.

  5. Tömbökre használható függvények

    6. LowerBound(array {,n})UpperBound(array {,n})

    n dimenziós tömb felső határát adja meg Long értékként, illetve –1-et, ha a megadott n érték nagyobb, mint a tömb dimenziója. n értéke alapértelmezés szerint 1. Fix méretű tömbök esetén mindig a tömb méretét adja vissza. Nem fix méretű tömbök deklarációjakor (feltöltés előtt) ez az érték mindig 0.

  6. Egyéb hasznos függvények

Beep ( n )

n darab (max. 10) csipogás.

IsValid ( objectname )

Boolean értékkel tér vissza. Megadja, hogy az adott objektum létezik-e.

KeyDown ( keycode )

Boolean-el tér vissza. Megadja, hogy az adott billentyű lenyomásra került-e, ahol keycode a billentyű ASCII kódja.

MessageBox

(title, text {,icon {,button {,default}}})

Egy üzenet ablakot jelenít meg a képernyőn, aminek megadjuk a címét (string), a megjelenítendő szöveget (string), ikont és gombokat. Végül megadható, hogy a megjelenített gombok közül melyik legyen a default (alapértelmezés szerint az első, azaz az OK gomb).

RGB ( red, green, blue )

Egy long érték, ami megadja a piros, zöld és kék színek kombinációjából előálló színt. Ahol red az előállított szín piros komponensének integer értéke, green az előállított szín zöld komponensének integer értéke, és blue az előállított szín kék komponensének integer értéke.

SetNull ( variable )

Bármely változó NULL-ra állítása.

SetPointer ( type )

Az egérpointer beállítása megfelelő alakra, ahol type lehet:

Arrow! - nyíl

Cross! - kereszt

Beam!

HourGlass! - homokóra

SizeNS! – függőleges méretezés nyila

SizeNESW! – ablak jobb felső v. bal alsó sarkán megjelenő méretező nyíl

SizeWE! – vízszintes méretezés nyila

SizeNWSE! - ablak bal felső v. jobb alsó sarkán megjelenő méretező nyíl

UpArrow!

SignalError({number}, {text})

Rendszerhiba generálása az alkalmazás szintjén, ahol number az Error objektum number tagjának értéke és akkor kell megadni, ha ezt az értéket az üzenetablakban meg akarjuk jeleníteni, illetve text az Error objektum text tagjának értéke és akkor kell megadni, ha ezt a szöveget az üzenetablakban meg akarjuk jeleníteni.

PopulateError(number, text)

Az Error objektum feltöltése rendszerhiba előidézése nélkül.

Hibakezelés az Error objektumon keresztül

 

Ezt az objektumot végrehajtás során bekövetkező hibák (futásidejű hibák) regisztrálására használjuk. Az objektum szkriptekből érhető el. Az Error objektum tulajdonság értékein keresztül lehet a művelet végrehajtás sikerességéről információt szerezni. A tulajdonságok listája az objektum orientáltságról szóló részben található meg.

 

 

PÉLDAPROGRAMOK

  1. Prímszámok meghatározása és kiíratása 1-200-ig (w_proba ablak cb_1 gombjának Click eseményéhez rendelve)

integer i, j, k=1, szamlalo=0, a_prim[]

string primszamok

for i = 1 to 200 step 1

szamlalo=0

for j = 1 to i

if Mod(i,j) = 0 then szamlalo = szamlalo + 1 //Mod(x,y), maradékos osztás fv.

next

if szamlalo <= 2 then

a_prim[k] = i

k++

end if

end for

/*Primszamok kiiratasa 1-200-ig forditott sorrendben*/

for i = (k)-1 to 1 step –1

//String(arg), numerikus értéket sztringgé konvertál – kiiratáshoz hasznos

//Sztringösszefűzés operátora a + jel

primszamok = primszamok + String(a_prim[i]) + ", "

next

/*A MessageBox paraméterezése: ablakcim (string), megjelenitendő szöveg (string), megjelenitendő ikon (felsorolt tipusú), megjelenitendő gomb (felsorolt tipusú)

A megjeleníthető ikonok listáját lásd fentebb a felsorolt típusok között.

Megjeleníthető gombok: OK! — (Default),

OKCancel! — OK és Cancel gombok,

YesNo! — Yes és No gombok,

YesNoCancel! — Yes, No, és Cancel gombok együtt,

RetryCancel! — Retry és Cancel gombok,

AbortRetryIgnore! — Abort, Retry, és Ignore gombok */

MessageBox("Primszamok", primszamok, None!, OK!)

Megjegyzés: Az operátorok előtt és után tetszőlegesen használható a Space karakter, illetve az operátorok az operandusokkal egybe is írhatók. Kivétel a kivonás operátora, melynek írásmódjára szigorú megkötések vannak (lásd Operátorok címszó alatt)!!!

 

 

 

  1. Kétoperandusú műveletek eredményét kiszámító ablak.

Készítsük el a w_matek nevű ablakot a következő elrendezéssel:

Instance (objektum-előforduláshoz kötött) változók – tehát minden szkriptből láthatók:

integer operandus1

integer operandus2

char operator

Az első beviteli mező (EditMask) szkriptje:

operandus1 = 0

em_operandus1.SetFocus() //A SelectText hívása előtt a beviteli mezőre kell állítani a fokuszt

/*A SelectText kijelöli a beviteli mező tartalmát, argumentumok: a kijelölés kezdő és végpontja és visszatérési értéke a kijelölt szöveg hossza*/

em_operandus1.SelectText(1, 5)

operandus1 = Integer(em_operandus1.Text) //Szöveg átalakítása Integerré

A második beviteli mezőjé ezzel analóg (operandus1 helyett operandus2).

Az operátor kiválasztását lehetővé tevő ListBox szkriptje:

operator = ' '

//Az operátor felveszi a kiválasztott ListBox elem értékét

operator = lb_operator.SelectedItem()

Az eredmény kijelző mező (sle_result) DisplayOnly tulajdonságú, nincs hozzá szkript.

A cb_szamitas gomb szkriptje (feladata a művelet elvégzése és az eredmény megjelenítése az sle_result mezőben):

long szorzas_eredmeny = 0

decimal {3} osztas_eredmeny = 0.000

//Parameteratadas ellenorzese, numerikus értékeket sztringgé alakítva, hogy megjelenithetők legyenek

//Szöveg kiiratása: az objektum Text attributumát egyenlővé tesszük a megjelenitendő string értékkel

//sle_result.Text = String(operandus1) + ' ' + operator + ' ' + String(operandus2)

/*Trim(string): a sztring elejéről és végéről az üres karakterek eltávolítása, lásd még LeftTrim(string) és RightTrim(string)*/

CHOOSE CASE trim(operator)

CASE "+"

sle_result.Text = String(operandus1 + operandus2)

//értékadás az eredmény SingleLineEdit mező Text tagjának

CASE '-'

sle_result.Text = String(operandus1 -operandus2)

CASE '*'

szorzas_eredmeny = operandus1 * operandus2

sle_result.Text = String(szorzas_eredmeny)

CASE '/'

osztas_eredmeny = operandus1 / operandus2

sle_result.Text = String(osztas_eredmeny)

CASE '^'

/*Amennyiben a hatvanyozas eredmenye nem abrazolhato a long

tartomanyban, ugy az eredmeny 0 lesz*/

szorzas_eredmeny = operandus1 ^ operandus2

sle_result.Text = String(szorzas_eredmeny)

CASE ELSE

sle_result.Text = " " //Ha nincs kijelölve operátor

END CHOOSE

A törlés gomb szkriptje:

em_operandus1.Text = " " //Törli a képernyőről a korábban bevitt értéket

operandus1 = 0

em_operandus2.Text = " "

operandus2 = 0

lb_operator.SelectItem(0) //Törli a ListBox legutóbbi kijelölését

sle_result.Text = " "

A kilépés gomb szkriptje:

//Close(w_matek) – is jó, de a következő parancs ablaknév-független

Close(parent) //Bezárja a gombot tartalmazó ablakot

Megjegyzés: A beviteli mezők Modified, a ListBox SelectionChanged és a gombok Clicked eseményéhez rendeljük a szkripteket.

3) Sztringkezelő példaprogram: egy adott szövegben megkeresi a megadott sztring minden előfordulását, és egy kiválasztott helyen lecseréli azt egy másik megadott sztringre. (w_sztringkezeles)

A keresés gomb Click eseményéhez rendelt szkript:

long uj_poz

integer i = 1, talalat_szam = 0

boolean kilep = FALSE

if rb_betu_erzekeny.Checked = TRUE then //RadioButton kiválasztásának lekérdezése

do until kilep = TRUE

if i = 1 then //Első találati hely esetén

//Adott szöveg keresése a megadott szövegben. A Pos() fv. a találat helyét adja vissza a megadott szövegben.

a_poziciok[i] = Pos(mle_megadott_szoveg.Text, Trim(sle_keresendo_szoveg.Text))

if a_poziciok[i] <> 0 then

i++

talalat_szam += 1

else

kilep = TRUE //A keresett szöveg nincs a megadott szövegben

end if

else

//Sztring hosszának lekérdezése: Len(string) függvénnyel, ami Long értékkel tér vissza

//Trim(string): Sztring elejéről és végéről levágja a felesleges (üres) karaktereket

uj_poz = a_poziciok[i -1] + len(Trim(sle_keresendo_szoveg.Text))

if uj_poz <= len(mle_megadott_szoveg.Text) -len(Trim(sle_keresendo_szoveg.Text)) then

//Pos(megadott_sztring, keresendo_sztring, kereses_kezdeti_pozicioja – default 1, a szöveg eleje)

a_poziciok[i] = Pos(mle_megadott_szoveg.Text, Trim(sle_keresendo_szoveg.Text), uj_poz)

if a_poziciok[i] <> 0 then

i++

talalat_szam += 1

else

kilep = TRUE //A keresett szöveg nincs a megadott szövegben

end if

else

kilep = TRUE //A keresett szöveg nincs a megadott szövegben

end if

end if

loop

elseif rb_betu_nem_erzekeny.Checked = TRUE then //A másik RadioButton van kiválasztva

/* Ugyanaz, mint fent azzal a különbséggel, hogy mivel itt a kis- és nagybetűre nem érzékeny a keresés, ezért a megadott szöveget és a keresendő szöveget egyaránt kisbetűsre alakitjuk és igy végezzük el a keresést – Lower(string), de ugyanigy lehetne nagybetűsre is alakitani mindkét szöveget és úgy végrehajtani a keresést – Upper(string) */

do until kilep = TRUE

if i = 1 then

a_poziciok[i] = Pos(Lower(mle_megadott_szoveg.Text), Lower(Trim(sle_keresendo_szoveg.Text)))

if a_poziciok[i] <> 0 then

i++

talalat_szam += 1

else

kilep = TRUE

end if

else

uj_poz = a_poziciok[i -1] + len(Trim(sle_keresendo_szoveg.Text))

if uj_poz <= len(mle_megadott_szoveg.Text) -len(Trim(sle_keresendo_szoveg.Text)) then

//Hosszú sor több sorba tördelése az & sorvégi lezáró karakterrel történik

a_poziciok[i] = Pos(Lower(mle_megadott_szoveg.Text), &

Lower(Trim(sle_keresendo_szoveg.Text)), uj_poz)

if a_poziciok[i] <> 0 then

i++

talalat_szam += 1

else

kilep = TRUE

end if

else

kilep = TRUE

end if

end if

loop

end if

sle_talalatok_szama.Text = String(talalat_szam) //Kiirja a talalatok számát

A csere gomb Click eseményéhez rendelt szkript:

//A csere előtti szöveg másolatának megőrzése, a csere visszaállíthatóságának érdekében – Mégse gomb

masolat = mle_megadott_szoveg.Text //A teljes megadott szöveget kimásolja

if IsNull(sle_csere_poz.Text) = FALSE and & //Ha a mező nem NULL értékű

Integer(Trim(sle_csere_poz.Text)) <= Integer(sle_talalatok_szama.Text) &

and sle_csere_poz.Text <> " " then

/*Egy szövegben valamely sztring kicserélése egy másik sztringre: Replace(megadott_szöveg – string, csere kezdő poziciója a megadott szövegben – long, milyen hosszú a lecserélendő szöveg – long, új szöveg – string)*/

mle_megadott_szoveg.Text = &

Replace(mle_megadott_szoveg.Text, a_poziciok[Integer(sle_csere_poz.Text)], &

len(Trim(sle_keresendo_szoveg.Text)), Trim(sle_csere_szoveg.Text))

//Adott tömb határainak lekérdezése: LowerBound(tomb), UpperBound(tomb)

//Határozatlan méretű tömb definiciója esetén az alsó határ mindig 1

for i = Integer(sle_csere_poz.Text)+1 to UpperBound(a_poziciok)

a_poziciok[i] += Len(Trim(sle_csere_szoveg.Text)) -Len(Trim(sle_keresendo_szoveg.Text))

next

end if

cb_megse.Enabled = TRUE //Mégse gomb engedélyezése

this.Enabled = FALSE //Az aktuális objektum – itt Csere gomb - letiltása

  1. Zsebszámológéppel egy adott szám négyzetgyökének kiszámítása. Számoljuk ki 2 négyzetgyökét.

    2. A 2-es számgombhoz rendelt szkript (a többi számgombé ezzel analóg):

    if sle_input.Text = "0" then //ha ez az első számjegy

    sle_input.Text = String(2)

    else //ha nem ez az első számjegy

    sle_input.Text += String(2) //akkor az eddigi számjegyekhez hozzáfűzi a 2-est

    end if

    elemszam++ //a szamjegyeket tároló tömb elemszáma eggyel nő

    a_szamok[elemszam] = '2' //a 2-es számjegy bekerül ebbe a tömbbe

    Az sqrt (négyzetgyökvonás) gomb Clicked eseményéhez rendelt szkript:

    if IsNull(sle_input.Text) = FALSE then //ha a kijelző nem NULL értékű

    if Integer(sle_input.Text) > 0 then sle_input.Text = String(Sqrt(Integer(sle_input.Text)))

    /*ha a kijelzőn látható érték (integerként) pozitív szám, akkor kiszámolható a négyzetgyöke és megjeleníthető a kijelzőn*/

    end if

  2. Dátumkezelésre példa. A program kiírja az aktuális rendszerdátumot és időt (részletezve) és egy születési dátum megadásakor megadja, hogy az adott dátum milyen napra esett és kiszámítja a megadott dátum és az aktuális dátum között eltelt napok számát.

    3. Az ablak Open eseményéhez rendelt szkript:

    sle_today.Text = String(Today()) //aktuális rendszerdátum kiiratása

    sle_now.Text = String(Now()) //aktuális rendszeridő kiiratása

    sle_ev.Text = String(Year(Date(sle_today.Text))) //az aktuális dátumból az év kinyerése

    sle_honap.Text = String(Month(Date(sle_today.Text))) //az aktuális dátumból a hónap kinyerése

    sle_nap.Text = String(Day(Date(sle_today.Text))) //az aktuális dátumból a nap kinyerése

    sle_napnev.Text = DayName(Date(sle_today.Text)) //a dátumból a nap nevének a meghatározása

    sle_ora.Text = String(Hour(Time(sle_now.Text))) //a rendszeridőből az óra kinyerése

    sle_perc.Text = String(Minute(Time(sle_now.Text))) //a rendszeridőből a perc kinyerése

    sle_masodperc.Text = String(Second(Time(sle_now.Text))) //a rendszeridőből a másodperc kinyerése

    A születési dátum beviteli mező szkriptje:

    string nap

    nap = DayName(Date(sle_szuldatum.Text)) //a születési dátumból a születésnap nevének a meghatározása

    choose case nap //a születésnap magyarítása

    case 'Sunday'

    sle_szulnap.Text = 'vasárnapi'

    case 'Monday'

    sle_szulnap.Text = 'hétfõi'

    case 'Tuesday'

    sle_szulnap.Text = 'keddi'

    case 'Wednesday'

    sle_szulnap.Text = 'szerdai'

    case 'Thursday'

    sle_szulnap.Text = 'csütörtöki'

    case 'Friday'

    sle_szulnap.Text = 'pénteki'

    case 'Saturday'

    sle_szulnap.Text = 'szombati'

    end choose

    sle_eltnapok.Text = String(DaysAfter(Date(sle_szuldatum.Text), Date(sle_today.Text)))

  3. Példa menü készítésére.

Először hozzunk létre egy menüt a következő felépítéssel:

Window

Open

  
 

Close

  

Format

Alignment

Right!
   

Left!
   

Center!
 

Font

  

Egy karakter aláhúzását úgy lehet megadni, hogy az adott karakter elé beszúrunk egy & karaktert.

Az Open menüponthoz rendeljük hozzá egy kész ablakunk megnyitását (pl. w_sztringkezeles).

A Close menüpont szkriptje:

Close(w_sajat) //meg kell adni azt az ablakot, amit be akarunk zárni

A Format ® Alignment menüpontjaival a szövegmezőben adott szöveg elrendezését változtathatjuk meg.

Így a Right Alignment menüpont szkriptje (a többié ehhez hasonló):

w_sajat.mle_szoveg.Alignment = Right!

//mely ablak, mely szöveges mezőjének elhelyezkedésére vonatkozik

A menü elkészítése után hozzá kell azt rendelni egy ablakhoz (itt: w_sajat). A hozzárendelést az adott ablak Properties ablakában lehet megadni (Menu name = m_sajat). Az ablakot futtatva a menü megjelenik az ablak felső sorában.

 

 

3. ADATBÁZIS KEZELÉSÉNEK alapjai A POwerbuilder rendszerben

 

Adatforrások

A 4GL rendszerek egyik fő jellemzője, hogy az elkészített alkalmazások valamilyen adatbázisból vett adatokkal dolgoznak. A PowerBuilder esetében is a rendszer egyik fő eleme a különböző adatforrásokban tárolt adatok, elsősorban a relációs adatforrásokban tárolt adatok kezelésére, elérésére szolgáló modul. A rendszer lehetővé teszi, hogy az alkalmazásunk futás közben felvegye a kapcsolatot az adatforrással, parancsokat küldjön át, onnan adatokat fogadjon vagy adatokat küldjön. A PowerBuilder fejlesztő változata emellett még egy interaktív adatbázis kezelő felületet is biztosít, mellyel közvetlenül is módosíthatók, lekérdezhetők az adatbázisban tárolt adatok.

A PowerBuilder alkalmazásokból több különböző adatforrás is elérhető. Az adatforrás lehet

Az adatforrások interaktív kezelésére több komponens is rendelkezésre áll a PowerBuilder fejlesztő környezetében. A DataBase Painter, azaz adatbázis szerkesztővel a kiválasztott adatbázis objektumait, tábláit tudjuk kezelni. Ezen keresztül hozhatunk létre új táblákat, kapcsolatokat, s módosíthatjuk a táblák szerkezeté is. A séma kezelő lehetőségek mellett ez a modul adatkezelő részt is magába foglal, azaz itt lehet a táblák adatait megtekinteni, rekordokat módosítani, törölni vagy felvinni.

A másik komponens a Query Painter, vagyis lekérdezés szerkesztő. Ebben a modulban lekérdezéseket lehet összeállítani mélyebb SQL ismeretek nélkül is. A lekérdezés alapjául szolgáló táblákat kijelöléssel választhatjuk ki, s a végrehajtandó SELECT utasítás többi elemét, mint például a projekciós és szelekciós részt táblázatok kitöltésével állítjuk össze. Az elkészített lekérdezési parancs a VIEW objektumokhoz hasonlóan letárolható, viszont a parancssor nem az adatbázisban tárolódik, hanem alkalmazás objektumként.

Mivel az adatbázisokhoz történő kapcsolódás során meg kell adni az adatforrás pontos elérési paramétereit, a kapcsolat felvételnél a rendszernek több paraméterre is rá kell kérdeznie a kezelőnél. Hogy ne kelljen minden egyes kapcsolat felvételnél ugyanazokat a paramétereket ismételten megadni, a PowerBuilder rendszer bevezette az DB Profile fogalmát, mely egy olyan objektum ,amely magába foglalja egy konkrét adatforráshoz történő kapcsolódás paramétereit. A fejlesztő rendszerben ezek után elég csak a szükséges Profile objektumot kijelölni, mert ez alapján egyértelmű lesz az adatkapcsolat iránya is. Mivel az egyedi adatforrások az ODBC kapcsolaton keresztül érhetők el , a rendszer egyik modulja egy ODBC konfiguráció szerkesztő, melyből új ODBC kapcsolatokat hozhatunk létre, amit majd beépíthetünk egy Profile-ba, s ezen keresztül adatbázis kezelést vagy lekérdezést hajthatunk végre rajta.

A következő részben röviden sorra vesszük az interaktív adatkezelő komponenseket.

ODBC konfiguráció szerkesztő

Az ODBC konfiguráció szerkesztő a rendszer főmenüjéből közvetlenül meghívható. A megjelenő kezelő ablak felépítése hasonlít a Windows OS rendszereknél megismert ODBC konfigurációs panelre. E modul szolgál új ODBC források létrehozatalára. Pontosabban fogalmazva ez a modul csak az ODBC kapcsolatot hozza létre, az adatforrás rendszerint már egy fizikailag létező DBMS lesz. A kezelő ablakban elsőként az igényelt ODBC driver, meghajtó típusát kell kiválasztani. Ezt követően a CREATE parancs után meg kell adni az adatforrás egyedi paramétereit, mint például az Oracle DBMS adatforrás esetén

Ezen adatok mellett még egyéb, az adatforrás típusától függő paramétereket is be lehet állítani. A létrehozott ODBC kapcsolat felhasználható a PowerBuilder alkalmazásokban adatbázis kapcsolat kiépítéséhez.

 

DB Profile szerkesztő

Ez a modul is közvetlenül a főmenüből hívható meg. A megjelenő ablakban a már létrehozott DB Profile –ok listáját találhatjuk. Az ablakban az alábbi fő funkciók élnek:

1. ábra

Új Profile létrehozása esetén egy új ablak jelenik meg, melyben megadhatjuk az adatkapcsolat részletes jellemzését (lásd 2. ábra).

2. ábra

Ebben a panelben adhatjuk meg a részletes adatforrás elérési információt, a hálózati paramétereket, s az elvárt tranzakció kezelési szintet is. Az ábrán is ez a terület van kijelölve, melyen többek között beállíthatjuk a zárolási típust is, a normál zárolás, az optimista zárolás és a csak olvasható üzemmód közül választva.

A rendszer nyilvántartja hogy melyik Profile alapján dolgozunk, s megőrzi ezt a beállítást a rendszerből való kilépésünk után is, s így amikor legközelebb belépünk a PowerBuilder fejlesztő rendszerbe, s adatbázis kezelő tevékenységet kezdünk el, akkor ezen Profile alapján hajtódik végre a kapcsolódás a háttérben.

 

Database szerkesztő

Az adatbázis szerkesztővel a kapcsolt adatbázisban tudunk adminisztratív jellegű munkát végezni. Ennek során módosíthatjuk az objektumok szerkezetét, adatokat kérdezhetünk le vagy módosíthatunk. A munkát grafikus, ablakos környezet támogatja. A grafikus kezelő felület mellett a rendszer egy szöveges, parancs orientált komponenst is tartalmaz, amelyet adatbázis adminisztrátori modulnak nevez. Ebben tetszőleges SQL parancs küldhető el az adatbázis felé, s lehetőséget ad, amennyiben ezt a szolgáltatást az adatforrás is támogatja, az SQL parancsok végrehajtási tervének a lekérdezésére is.

Az adatbázis szerkesztő is külön főmenü pontként érhető el. Az aktuális DB Profile alapján dönti el a rendszer, melyik adatbázist is kell megnyitnia. A megnyitott adatbázishoz kapcsolódóan elvégezhető funkciók közül most csak a lényegesebbeket emeljük ki. Az egyes funkciók a megfelelő menüpont aktiválásával indíthatók el.

 

Táblákkal kapcsolatos műveletek

Ha létező táblákkal kívánunk dolgozni, akkor az elsőként üres munkaterülettel megjelenő adatbázis szerkesztőnél az Object – Select Tables menüpontot válasszuk ki, melyre megjelenik egy panel, melyben az elérhető táblák listája található. Ebből egy vagy több tábla is kijelölhető feldolgozásra. A kiválasztott táblák szerkezete és kapcsolata is megjelenik az adatbázis szerkesztő ablakában (3. ábra)

3. ábra

A megjelenő táblák közül egyet kiválasztva meghívható a tábla szerkezet szerkesztő ablak is. Ez a funkció az Object – Edit Object menüponton keresztül érhető el. Mint ahogy a 4. ábra is mutatja, a szerkesztő ablakban többek között a következő elemeket lehet beállítani:

A meglévő tábla struktúra új mezők felvitelével és létező mezők törlésével módosítható. A mező szintű paraméterek mellett ugyanitt, az Edit – Table Properties menüponttal az egész táblára vonatkozó kulcs, kapcsolókulcs integritási elemek állíthatók be.

4. ábra

Az adatbázis szerkesztőben lehetőség van a tábla önálló szerkesztése mellett a táblák közötti kapcsolatok szabályozására is. Ha kijelölünk egy kapcsolatot és meghívjuk a szerkesztőjét az Object – Edit Object menüponton keresztül, akkor az 5. ábrán látható kezelő ablak fog megjelenni. Itt tudjuk beállítani, hogy az egyes kapcsoló, idegen kulcsok mely táblákra vonatkoznak, s mi legyen a kapcsolódó rekordok törlésekor felmerülő problémák megoldási mechanizmusa. A kapcsolat kezelő ablakban a szülő rekord törléséhez rendelendő választevékenységeket jelölhetjük ki. Ha ugyanis törölni szeretnénk egy hivatkozott rekordot, akkor az alábbi lehetőségek közül választhat az adatbáziskezelő:

Az érték ellenőrzéshez a kiértékelendő kifejezés rendszerint tartalmazhat tárolt eljárás hívásokat is. Ezen integritás ellenőrzési, vagy validálási eljárásokat is ezen szerkesztőben tudjuk kezelni a Design – Validation Maintenance menüpontján keresztül. Ezután előbb egy eljárás lista jelenik meg, melyből kijelölhetjük a szerkesztendő eljárást, vagy új eljárást is létrehozhatunk. Az eljárás szerkesztésekor megjelenő panelban a rendszer ellenőrzi a kifejezések szintaktikai helyességét, és segítségként megjeleníti a felhasználható, már meglévő eljárások listáját.

5. ábra

Még az adatbázis szerkesztőhöz tartozóan megemlítjük az adatbázis adminisztrátori parancsfelületet. Ez tulajdonképpen nem más mint egy szöveges parancsorientált kezelő felület, melyben tetszőleges SQL utasítás adható ki az adatbázis felé. Ez a parancs felület az adatbázis szerkesztő főmenüjének Design – Database Adminsitration pontjából hívható meg.

Az adminisztrátori modulban a közvetlen SQL parancs végrehajtás mellett egyéb segéd funkciók is rendelkezésre állnak. Egyik ilyen funkció a generált végrehajtási terv ellenőrzése. Ehhez az SQL parancs begépelése után a Design- Explain SQL menüpontot kell kiválasztani. A végrehajtás után egy külön ablakban megjelenik a generált terv szöveges leírása, mely utal a kiválasztott fizikai elérési módszerre vagy join típusra.

A közvetlen SQL parancs kiadás mellett néhány igazi adminisztrátori funkció is elérhető ebből a modulból. Ilyen funkció a felhasználók nyilvántartása és a táblák védelme.

6. ábra

A felhasználók kezelésénél (6. ábra), mely a Design – Maintance Users menüponthoz kötődik, felvihetők új felhasználók, törölhetők és módosíthatók a régebbi bejegyzések. Egy felhasználóról az azonosító nevét és jelszavát tartja nyilván. A táblák védelmi adatainál, mely a Design – Table Security menüpontból érhető el, minden egyes felhasználóhoz megadhatjuk mely táblát és milyen műveletre érhet el. Természetesen mind a védelmi, mind a felhasználó kezelői műveletek a közvetlen SQL parancsok kiadásával is elérhetők (lásd a CREATE USER vagy a GRANT SQL utasításokat).

7. ábra

Query szerkesztő

Ebben a szerkesztőben definiálhatunk SQL lekérdezéseket, melyeket lementve mások újra felhasználhatnak az alkalmazásaikban. Az SQL lekérdezés mint objektum a PowerBuilder-ben tárolódik le, s nem az adatbázisban. A lekérdezés szerkesztőt a főmenüből indíthatjuk el. A megjelenő ablakban előbb kiválaszthatjuk a kezelendő táblákat, majd a képernyő alján elhelyezkedő táblázat segítségével megadhatjuk az SQL utasítás egyéb elemeit is.

A táblázat tartalmaz külön

részt. A projekciós rész felül látható, s a tábla mezőinek kijelölésével adható meg. A join rész a kijelölt táblák alapján határozódik meg, s a megjelenő Eszközkészlet (Toolbar) Join pontjával állítható be.

A generált SQL utasítás a szerkesztő táblázat Syntax kartonján tekinthető meg.

 

8. ábra

 

 

Adatbázis elérés programból

Az interaktív kezelő felület hasznos a gyakorlott, SQL és DBA ismeretekkel rendelkező alkalmazás fejlesztő számára, hiszen egy platformról tudja mind az alkalmazás, mind az adatbázis struktúráját felépíteni. Az elkészített alkalmazás futása során valószínűleg szintén adatbázisban tárolt adatokkal fog dolgozni. Ekkor azonban már nem használhatók a most megismert kezelő felületek, az adatkezelés a programban, a felhasználó szeme elől elrejtve hajtódik végre. A végrehajtandó műveleteket most tehát az alkalmazás programjában kell kódolni.

Az alkalmazásnak az adatbázishoz történő csatlakozásánál elsődleges paraméter a kapcsolat azonosítása, hogy hol helyezkedik el az adatforrás, milyen típusú az adatbázis, milyen azonosító név alatt fog megtörténni a bejelentkezés, és így tovább. E paraméterek tárolására egy külön objektum típus létezik a PowerBuilder rendszerben, s ez az objektum a Transaction objektum.

Az adatbázis kapcsolódáshoz léteznie kell egy Transaction objektumnak, ami majd a megfelelő paraméterértékek beállítása után a kapcsolat megnyitásakor kerül felhasználásra. Ezt a Transaction objektumot vagy mi hozzuk létre, vagy felhasználjuk a rendszer által automatikusan létrehozott Transaction objektumot, amit SQLCA–nak jelölnek. A Transaction objektum, s rajta keresztül az adatbázis kapcsolat az alábbi paraméterekkel írható le:

 

A következő példában az alapértelmezési kapcsolat leíró objektum, azaz az SQLCA tulajdonságait állítjuk be olyan értékekre, hogy az egy ODBC adatforrásra mutasson:

SQLCA.DBMS="ODBC"

SQLCA.DBParm="ConnectString='DSN=Sampl '"

A paraméterezés egyik fő nehézsége, hogy a különböző adatforrások más és más szintaktika szerint kérik a kapcsolódási paramétereket. A pontos kapcsolódási szintaktika meghatározásában segítségünkre lehet a DBProfile mechanizmus. Ha ugyanis korábban már létrehoztunk egy DBProfile objektumot, akkor annak a Preview tulajdonsága a helyes kapcsolódási paraméterlistát fogja tartalmazni. Az ott lévő beállításokat illeszthetjük be a program szövegébe. A következő ábra egy ODBC DBProfile Preview jellemzőjét mutatja meg:

9. ábra

Ha beállítottuk az adatkapcsolati paramétereket, akkor a tényleges adatbázis kapcsolat egy SQL utasításon keresztül valósítható meg:

CONNECT USING trobj;

ahol trobj a beállított Transaction objektum azonosítója. Ha az SQLCA-t használjuk fel a kapcsolat paraméterezésére, akkor elegendő csak a CONNECT parancs a USING tag nélkül a kapcsolat felvétel elindításához. Mivel a CONNECT parancs már SQL parancs, a parancsot pontosvesszővel kell lezárni, a normál PowerScript kifejezésektől eltérően, ahol nem kell pontosvessző a kifejezés után. Az adatkezelési tevékenységek elvégzése után a kapcsolat megszakítása a

DISCONNECT USING trobj;

utasítással lehetséges, melynél szintén használható az egyszerűsített alak (DISCONNECT) az SQLCA alkalmazása esetén. A kapcsolat felvétel vagy felbontás sikeressége a Transaction objektum hibakódokat tartalmazó tulajdonságainak lekérdezésével lehetséges. A következő példa egy ilyen hibakezelő részt mutat be:

CONNECT USING SQLCA;

IF SQLCA.SQLCode < 0 THEN &

MessageBox("Connect Error", SQLCA.SQLErrText, Exclamation!)

DISCONNECT USING SQLCA;

IF SQLCA.SQLCode < 0 THEN &

MessageBox("Disconnect Error", SQLCA.SQLErrText, Exclamation!)

A PowerBuilder rendszer lehetővé teszi, hogy egyidejűleg több adatkapcsolat is éljen. Ekkor szükségszerű, hogy az SQLCA mellett egy másik Transaction objektumot is létrehozzunk. Ez az objektum is ugyanúgy hozható létre, mint a többi objektum, azaz a CREATE paranccsal. A következő minta erre a lépésre ad egy példát, ahol Dbtrans az új Transaction objektum azonosítója.

transaction DBTrans

DBTrans = CREATE transaction

DBTrans.DBMS = "ODBC"

A kapcsolat létrehozása után SQL adatkezelő parancsokat küldhetünk el az adatforrás felé.

Az SQL parancsokat a beágyazott SQL mechanizmusának megfelelően a PowerScript utasítások közé illeszthetjük be. Az SQL utasításokat nem kell semmilyen előtaggal bevezetni, közvetlenül beírhatjuk az SQL parancsszavakat a programkódba. A normál PowerScript nyelvi elemektől eltérően itt nem kell folytató sor jelölést alkalmazni (&), az SQL utasítás több soron keresztül is írható, s az SQL utasítás végét kell egy pontosvessző karakterrel jelölni. A következő példa egy új rekord beszúrását mutatja egy minta PowerScript környezetben:

integer i

CONNECT;

for i = 1 to 200

INSERT INTO DOLGOZO VALUES(22,’PETER’,233);

next

A fenti példa furcsasága, hogy mind a kétszázszor ugyanaz az értékhármas kerül be az új rekordba, hiszen egyazon SQL utasítás kerül ismétlésre a ciklusban. Ilyen jellegű megoldásra ritkán van szükség, a gyakorlatban inkább arra van szükség, hogy a végrehajtandó SQL utasítás ne rögzítetten legyen kódolva a programban, hanem a program futása során kerüljön az pontosításra. Például beolvasunk egy nevet és az ilyen nevű dolgozók adatai kellenek. Ebben az esetben a név érték előbb egy PowerScript változóba kerül, s ezen változó tartalmát kell felhasználni az SQL utasítás összeállításánál. Tehát a SQL utasítás gazdanyelvi változókra történő hivatkozásokat is tartalmazni fog. A PowerScript környezetben az SQL parancsba beépített gazdanyelvi változókat egy kettőspont karakter előzi meg, mint ahogy az a szabvány beágyazott SQL rendszerekben is szokásos. A következő példában a beszúrt rekord első mezője az i változó aktuális értékét veszi fel:

integer i

CONNECT;

for i = 1 to 200

INSERT INTO DOLGOZO VALUES(:i,’PETER’,233);

next

A gazdanyelvi változó szerepelhet az SQL műveletek szelekciós részében is:

integer i

UPDATE DOLGOZO SET kor =:k WHERE kod = :i;

A gazdanyelvi változót nemcsak értékek adatbázisba küldésére, hanem adatok fogadására is használhatjuk. Itt is ügyelni kell azonban arra, hogy a PowerScript változók megadott mérettel rendelkeznek, így nem tudnak tetszőleges nagy rekordhalmazt befogadni. Így a lekérdezés eredményét csak akkor szoktuk közvetlenül változóba elhelyezni, ha a lekérdezés egyetlen egy rekordot ad vissza. Ilyenkor a lekérdezést SELECT .. INTO alakban kell kiadni. A következő példa az 55 évnél idősebb dolgozók létszámát adja vissza.

integer i

SELECT COUNT(*) INTO :i FROM DOLGOZO WHERE kor > 55;

Ha több rekord várható az eredményhalmazban, akkor itt is a jól ismert kurzor struktúrát kell alkalmazni. A kurzor kezelés szokásos lépései:

A kurzor deklarálása a

DECLARE kurzornév CURSOR FOR SQL-SELECT;

paranccsal történik. A fenti utasításban a kurzornév egy PowerScript változó, melynek láthatóságra ugyanazon szabályok vonatkoznak mint a többi normál változókra. Ha több különböző kódszeletben is szeretnénk elérni a kurzor struktúrát, akkor a kurzornév változónak globális láthatósággal kell rendelkeznie. Ezt úgy érjük el, hogy a fenti deklarációs parancsot a Declare – Global Variable menüpontban adjuk meg. A kurzorhoz tartozó lekérdezés az

OPEN kurzornév;

utasítással hajtható vége. A lekérdezés eredményhalmazának soron következő rekordját a

FETCH kurzornév INTO :v1,:v2,..;

módon kérdezhetjük le és tölthetjük át gazdanyelvi változókba. Alapesetben mindig a következő eredményrekordot kapjuk vissza a FETCH utasításnál. Ha az adatbázis támogatja, akkor nemcsak előre, hanem visszafele is lehet lépegetni az eredmény halmazban, a FETCH PRIOR utasítással. A kurzor struktúra felszabadítása a

CLOSE kurzornév;

paranccsal lehetséges.

A kurzorok kezelésénél fontos kérdés, hogy az eredmény rekordok beolvasásánál, melyet egy ciklusban végzünk el, hogyan dönthetjük el, hogy elértük-e már az eredményhalmaz végét vagy sem. Erre a feladatra a PowerBuilder-ben az általános hibakezelési módszer alkalmazható, azaz minden SQL azaz most FETCH utasítás után lekérdezzük a Transaction objektum SQLCode hibastátuszát.

A Transaction objektum SQLCode mezője az alábbi értékeket veheti fel:

Ha adatok lekérdezésénél a beolvasott adatbázis mező NULL értékű volt, a hozzá rendelt gazdanyelvi változó akkor is fog valamilyen normál értéket tartalmazni, mely természetesen egy rossz, téves érték. Az adatbázis mezők NULL értékre történő ellenőrzésére az indikátor változók alkalmazhatók. Az indikátor változók egész típusú változók, melyek a normál gazdanyelvi változókhoz kötődnek, s értékük jelzi, hogy a tényleges adatbázis érték került-e át a program változóba.

Az indikátor változót közvetlenül a normál változó után, tőle szóközzel elválasztva kell megadni, s őt is egy kettőspont vezeti be az SQL parancsban. Az indikátor változó értéke lehet

A következő példa az indikátor változó használatát mutatja be

integer ert, ind

SELECT kor, fiz INTO :ert :ind, :fiz FROM DOLGOZO WHERE kod = 55;

if ind < 0 then

Messagebox("Hiba","NULL ertek a mezoben", None!, OK!)

end if

A példában csak az ert változóhoz kötöttünk indikátor változót, így csak a kor mezőből átvett, s az ert változóba kerülő adat helyessége ellenőrizhető.

Az említett SQL utasításoknál, mint látható, lehetőség volt arra, hogy a különböző végrehajtásokkor más és más adatértékkel dolgozzanak, amit a gazdanyelvi változók SQL utasításokba történő beépítésével értünk el. Így rugalmasan tudtuk kezelni az átadott adatokat, szelekciós feltételeket, azonban az SQL utasítás jellegét , az SQL parancs további elemeit (például a projekciós részt, az SQL utasítás típusát) nem lehetett már változtatni, az továbbra is rögzített maradt. Ha az alkalmazásunkban teljesen rugalmasan kívánunk SQL parancsokat kiadni, vagyis a program futása során dől csak el, hogy pontosan milyen utasítást is kell végrehajtani, akkor a dinamikus SQL parancsokat kell alkalmazni.

A dinamikus SQL utasításoknak négy típusa létezik, amelyek különböző előkészítési lépéseket igényelnek:

Mi most itt csak az első és a harmadik módszert mutatjuk be röviden. Az első típusú dinamikus SQL parancsoknál a legegyszerűbb a végrehajtás menete:

A következő minta ezen dinamikus SQL típusra mutat példát:

string szoveg

szoveg = "CREATE TABLE Dolgozo (nev char(12), kor integer, "&

+"fiz integer not null)"

EXECUTE IMMEDIATE :szoveg;

A lekérdezés esetén már sokkal több előkészítő lépésre lesz szükség. Elsőként jelezni kell, hogy dinamikus SQL SELECT kerül majd végrehajtásra:

DECLARE kurzornév DYNAMIC CURSOR FOR SQLSA ;

Az SQLSA azonosító egy alapértelmezési DynamicStagingArea-t jelöl, amely az utasítások végrehajtásához szükséges leíró terület. Ezután előállítjuk a végrehajtandó SELECT utasítás szövegét egy sztringbe:

parancsszöv = "SELECT …"

A parancs tartalmazhat hivatkozásokat változókra is egy ? formájában. Ez a kérdőjel jelzi, hogy a parancsban arra a helyre egy változó értéke fog majd kerülni. A parancsszöveg összeállítása után elküldjük a parancsot feldolgozásra:

PREPARE SQLSA FROM parancsszöv;

Ez még nem jelenti a parancs végrehajtását, csak azt hogy a DBMS ellenőrzi azt és előkészíti végrehajtásra. A tényleges végrehajtás a

OPEN DYNAMIC kurzornév [USING paraméterlista] ;

paranccsal történik. A USING kulcsszó után azon gazdanyelvi változók listája található, melyek aktuális értékei behelyettesítődnek az egyes ? szimbólumokba az SQL parancsnál. A generált eredmény rekordokat a már ismert módon, azaz a

FETCH kurzornév INTO változólista ;

módon kérdezhetjük le és a kurzort a

CLOSE kurzornév;

utasítással zárhatjuk le.

A következő példa ezen SQL végrehajtási típust szemlélteti:

DECLARE skurz DYNAMIC CURSOR FOR SQLSA ;

integer dkod

string dorsz = "MA"

string sqlpar

sqlpar = "SELECT kod FROM dolgozo WHERE orsz = ?"

PREPARE SQLSA FROM :sqlpar ;

OPEN DYNAMIC skurz USING :dorsz ;

FETCH skurz INTO :dkod ;

CLOSE skurz ;

A PowerBuilder, mint már láttuk, párhuzamosan több adatkapcsolat fenntartását is támogatja. Ebben az esetben viszont már nem egyértelmű, hogy melyik helyre továbbítódnak a kiadott, beágyazott SQL parancsok. Az egyértelmű végrehajtási hely kijelöléshez az SQL parancsokat egy újabb taggal is ki kell bővíteni párhuzamos adatkapcsolatok megléte esetén. A kapcsolat azonosítására a hozzá tartozó Transaction objektumot használjuk, melyet az SQL parancs végén a USING kulcsszót követően adunk meg. Ha nem adunk meg USING tagot az SQL parancsban, akkor az a SQLCA –val kijelölt adatforráshoz fog továbbítódni.

A következő példában egy a DBTrans-al kijelölt adatbázishoz továbbítódik az SQL parancs:

 

transaction DBTrans

DBTrans = CREATE transaction

DBTrans.DBMS = "ODBC"

INSERT INTO DOLGOZO VALUES(3,4) USING DBTrans;

A USING tag minden önálló SQL utasításhoz hozzáköthető.

 

PÉLDAPROGRAM

 

Példaprogramként egy olyan kis minta alkalmazást készítünk, melyben egy megadott adatbázis táblát kezelhetünk, az alábbi funkciókkal:

A programnak egy főképernyője van, s azon két nyomógomb. Az egyik nyomógomb aktivizálja a rekord felvitel ablakot, míg a másik a rekord lekérdezés ablakot. Mindkét funkció a beágyazott SQL parancsmódra épül. Az adatbázis egy ODBC adatforrás, melyben a kezelt tábla a DOLGOZO tábla az alábbi szerkezettel:

DOLGOZ (kod Number, nev CHAR, kor NUMBER)

Az egyes modulok főbb működési lépései:

Keret modul:

Rekord felvitel (AA):

Rekordok lekérdezése (BB)

Az AA ablakban és a BB ablakban is három mező van melyek az egyes adatbázis mezőknek felelnek meg.

A program kódszeletei:

Főablak

Főablak Open metódusa (kapcsolat felvétel):

SQLCA.DBMS = "ODBC"

SQLCA.AutoCommit = False

SQLCA.DBParm = "ConnectString='DSN=ORAPROBA;UID=scott;PWD=tiger;'"

CONNECT USING SQLCA;

IF SQLCA.SQLCode < 0 THEN

Messagebox("Kapcs hiba",SQLCA.SQLErrText, Exclamation!)

DISCONNECT USING SQLCA;

ELSE

MessageBox("Kapcs OK","Kapcsolat rendben",Exclamation!)

END IF

Főablak Close metódusa (kapcsolat lezárás):

DISCONNECT USING SQLCA;

Főablak Cb_1 objektum Click metódusa (ablak nyitás):

Open(aa)

Itt Cb_1 jelöli azt a nyomógombot, melynek felirata: Adatfelvitel. Az aa az ezt végrehajtó ablak neve.

Főablak Cb_2 objektum Click metódusa (ablak nyitás):

Open(bb)

Itt Cb_2 jelöli azt a nyomógombot, melynek felirata: Lekerdezes. A bb az ezt végrehajtó ablak neve.

AA ablak

Az AA ablak Cb_2 objektum Click metódusa (rekord felvitel):

integer m1,m3

string m2

m1 = integer(sle_1.text)

m2 = sle_2.text

m3 = integer(sle_3.text)

INSERT INTO DOLGOZO VALUES (:m1,:m2,:m3);

if SQLCA.SQLCode < 0 THEN

Messagebox('DB','Hibas SQL parancs')

ELSE

MEssagebox('DB','Siekres SQL parancs')

END IF

Az AA ablak Cb_1 objektum Click metódusa (ablak zárás):

Close (AA)

BB ablak

A Global Variable részben megadott deklaráció (kurzor deklarálás):

DECLARE kurz1 CURSOR FOR SELECT kod, nev, kor FROM DOLGOZO;

A BB ablak Open metódusa (kurzor nyitás, első rekord kijelzése):

integer m1

string m2

integer m3

OPEN kurz1;

fetch next kurz1 into :m1, :m2,:m3;

if SQLCA.SQLCode <> 0 THEN

messagebox ('DB', 'Ures a tabla')

else

sle_1.text = string(m1)

sle_2.text = m2

sle_3.text = string(m3)

end if

A BB ablak Close metódusa (ablak zárás):

CLOSE kurz1;

A BB ablak cb_1 Click metódusa (következő rekord kijelzése):

integer m1

string m2

integer m3

fetch next kurz1 into :m1, :m2,:m3;

if SQLCA.SQLCode <> 0 THEN

messagebox ('DB', 'Nincs tobb adat')

else

sle_1.text = string(m1)

sle_2.text = m2

sle_3.text = string(m3)

end if

Itt Cb_1 jelöli azt a nyomógombot, melynek felirata: Elore.

 

A BB ablak cb_2 Click metódusa (előző rekord kijelzése):

integer m1

string m2

integer m3

fetch prior kurz1 into :m1, :m2,:m3;

if SQLCA.SQLCode <> 0 THEN

messagebox ('DB', 'Nincs tobb adat')

else

sle_1.text = string(m1)

sle_2.text = m2

sle_3.text = string(m3)

end if

Itt Cb_2 jelöli azt a nyomógombot, melynek felirata: Hatra.

A program ablakait mutatják be a következő ábrák.

Adatbázis kapcsolódás ablak (ODBC ablak)

Főablak

 

 

 

 

 

 

 

 

 

 

 

 

AA ablak

BB ablak

 

 

 

 

 

 

 

 

 

 

4 ADATKEZELÉS DATAWINDOW SEGÍTSÉGÉVEL

 

A DataWindow (adatablak) egy olyan objektum, melynek segítségével egyszerű módon elérhetőek és megjeleníthetőek az adatbázisban tárolt adatok.

A DataWindow kétféle adatforrás elérését támogatja:

A DataWindow mögött álló "motor" intelligens, hatékony kapcsolatot biztosít a kliens alkalmazás és az adatszerver között. Figyeli, hogy mikor változnak meg az adatok az adatforrásban, mikor van szükség az adatok frissítésére. Ezenkívül megoldja a különböző adattípusok közötti automatikus konverziót, s figyeli az értékhez rendelt szabályok teljesülését is.

A PowerBuilder rendszer széles skáláját biztosítja a hatékony adatkapcsolatoknak és megjelenítési módoknak. Az egyes megjelenítési formák tetszőlegesen kombinálhatók a különböző adatforrásokkal.

 

DataWindow objektum készítése

A DataWindow készítése négy alaplépésből áll:

  1. Az adatforrás kiválasztása.

  2. A végeredmény megjelenítési formájának megadása.

  3. Az adatok megjelenítési formájának pontosítása, illetve az érvényességi szabályok megtervezése.

  4. Az elkészült formátum megtekintése

A PowerBar-ban található DataWindow szerkesztő segítségével készíthetünk új adatablakot, illetve módosíthatunk már meglévő adatablakokat. A DataWindow szerkesztőt aktivizálva a Select DataWindow ablak jelenik meg. Innen kiválasztható egy már meglévő ablak módosításra. A New gomb segítségével egy új adatablak készíthető.

Egy új DataWindow a következő két lépésben készíthető el:

  1. Ki kell választani egy adatforrást.

  2. Választani kell egy megjelenítési formát. Ez fogja meghatározni, hogyan fog megjelenni az eredmény a képernyőn.

Az adatforrások esetében öt féle adatforrás típus közül lehet választani:

Relációs típusú adatforrások:

1. Quick Select

Ez a legkönnyebb módja az adatforrás definiálásának, de a csak korlátozott lehetőségeket biztosít. Leginkább akkor használatos, ha elsődleges kulcs és idegen kulcs segítségével kapcsolódó táblák szolgálnak adatforrásként. A Quick Select esetén a táblák listájából lehet táblákat választani, amelyben azonban csak azok a táblák szerepelnek, amelyek egy kulcs – kapcsoló kulcs segítségével kapcsolódnak. A SELECT utasítás nem tartalmazhat csak WHERE szelekciós részt. A Quick Select nem támogatja az olyan SQL utasításokat, amelyekben a GROUP BY vagy a HAVING szerepel.

2. SQL Select

Az SQL Select lehetőséget biztosít teljes SELECT utasítás használatára. Minden standard ANSI SQL SELECT-et támogat, tehát a WHERE, HAVING vagy a GROUP BY tagok is szerepelhetnek a SQL utasításban.

3. Query

Ugyanolyan SELECT utasítást tartalmazhat, mint az SQL Select, azonban az utasítás szövegét egy vizuális Query szerkesztő segítségével állítjuk elő. Az így elkészült utasítás, ami Query objektumként kerül letárolásra, bármelyik DataWindow-hoz felhasználható.

4. Tárolt eljárás

Tárolt eljárás választása esetén a DataWindow szerkesztő megjeleníti azon adatbázisban aktuálisan tárolt eljárásokat, amelyhez a PowerBuilder éppen kapcsolódik. A tárolt eljárás lefordított SQL utasítások sora.

A tárolt eljárások használata gyorsíthatja a program működését a

A DBMS pszeudo kódban, lefordítva tárolja az eljárásokat, így azok futásra készek, amikor a DataWindow meghívja őket.

 

Nem relációs típusú adatforrás

5. External

A DataWindow számára lehet adatforrás egy külső, nem adatbázisbeli szöveges állomány is. Ekkor minden mező nevét és típusát pontosan meg kell adni, hogy a rendszer értelmezni tudja a az állományban tárolt adatokat.

 

Az SQL Select adatforrás használata

Amikor az SQL Select adatforrás kiválasztásra kerül, kinyílik a Select Tables ablak. A szükséges táblák két módon választhatók ki:

Az SQL toolbox

A DataWindow szerkesztő egy SQL toolbox-ot is tartalmaz, ami a képernyő alján található. Az SQL toolbox segítségével létrehozható vagy módosítható egy SQL SELECT utasítás.

Automatikus Join

Ha olyan táblák kerülnek kiválasztásra, melyeknek egy vagy több mezője kulcs – kapcsoló kulcs kapcsolatban áll vagy ugyanaz a nevük és az adattípusuk, akkor a Select szerkesztő automatikusan definiálja az illesztési kapcsolatot és meg is jeleníti a join-t.

A join operátor beállítása

Outer join használata esetén, illetve ha a join nem egyenlőségen alapul, hanem valamilyen más reláción, akkor a join ikon kiválasztásával nyitható ki a Join dialog box.

Join törlése

A Join dialog box-ban a kijelölt join törölhető a Delete gomb megnyomásával.

Join létrehozása

  1. Aktivizálni kell a Join gombot a toolbarban.

  2. Ki kell jelölni azon mezőneveket, amelyek között a join kapcsolatot felépítjük .

  3. Meg kell nyomni a join gombot másodszor is, hogy kiléphessünk a join módból a normál módba.

SQL painter

 

Amint korábban már látható volt, a DataWindow szerkesztő magában foglal egy Select szerkesztőt is. Ennek segítségével készíthetünk SQL SELECT utasításokat, és később itt meg is változtathatók.

SQL SELECT utasítás szerkesztése

Az edit funkció a Design>Convert To Syntax menü segítségével érhető el. A változtatások elvégzése után a Design>Convert To Graphics menü segítségével térhetünk vissza grafikus módba.

 

 

A Quick Select adatforrás használata

A Quick Select adatforrás

Quick Select adatforrás választása esetén a PowerBuilder megjeleníti a Quick Select Dialog box-ot. Itt amikor kiválasztásra kerül egy tábla, a mezői is megjelennek. Szintén megjelennek a kulcs – kapcsoló kulcson keresztül kapcsolódó táblák is. Ezekből a táblákból akár több is választható. A PowerBuilder ezután minden táblát megjelenít, ami kapcsolatban áll a kiválasztott táblákkal.

Ha kijelöltük a mezőket, amelyeket használni szeretnénk a DataWindow-ban, akkor ezek a mezők megjelennek a Selected Colums box-ban is.

Minden mezőnév alatt a következő kritériumok adhatók meg:

Az azonos mezőhöz tartozó feltételek OR kapcsolatban állnak egymással, hacsak nem adunk meg közöttük AND kapcsolatot. A különböző mezőkhöz tartozó feltételek AND kapcsolatban állnak, míg nem adunk meg OR kapcsolatot.

Az OK gombra kattintva a DataWindow szerkesztő legenerálja az alapértelmezési formáját a DataWindow objektumnak.

Az SQL SELECT utasítás megtekintése

Ha meg szeretnénk nézni az összeállított lekérdezéshez tartozó SQL SELECT utasítást, akkor kattintsunk az SQL Select gombra a toolbar-ban. Ha el szeretnénk hagyni a Select painter-t és vissza szeretnénk térni a design munkaterülethez, akkor nyomjuk meg újra a gombot.

A Quick Select dialog box

Ha egyszer bezártuk a Quick Select dialog box-ot, akkor többször nem lehet visszatérni, hogy változásokat eszközöljünk. De meg tudjuk néni, és meg is tudjuk változtatni az SQL SELECT utasítást, ha a Select gombra kattintunk.

 

A DataWindow objektum megjelenítési képe

A DataWindow objektum megjelenítési formátumát fejlesztés közben, előzetesen is megtekinthetjük. Ez a következő képen tehető meg:

  1. Kattintsunk rá a Preview gombra a PainterBar-ban vagy válasszuk ki a Design>Preview menüpontot. Ekkor láthatóvá válik a megjelenítési kép. A PowerBuilder minden olyan rekordot visszaad az adatbázisból, ami megfelel a SELECT utasításban megadott WHERE feltételnek.

  2. Teszteljük a DataWindow objektumot például az adatok megváltoztatásával.

  3. Ha el akarjuk hagyni a Preview módot, akkor kattintsunk újra a Preview gombra a Painter Bar-ban. A PowerBuilder visszatér a munkaterülethez.

DataWindow objektum mentése

  1. Válasszuk ki a File>Save menüpontot.

  2. Ha már korábban el volt mentve a DataWindow akkor, akkor a PowerBuilder az új változatot ugyanabba a library-ba menti, és visszatér a munkaterülethez. Ha még nem volt eddig elmentve, akkor a PowerBuilder megjeleníti a Save DataWindow dialog box-ot.

  3. Adjunk nevet a DataWindow-nak. A PowerBuilder nem ajánl fel default nevet. Ajánlott, hogy a név a d_ előtaggal kezdődjön.

  4. Komment írható a DataWindow-hoz. Ezek a kommentek megjelennek a Library painterben is.

  5. Válasszuk ki a megfelelő library-t amelybe elmentjük az objektumot.

  6. Nyomjuk meg az OK gombot.

A PowerBuilder elmenti a DataWindow definícióját a megadott library-ba és visszatér a DataWindow painter-hez.

 

A DataWindow megjelenítési formái

A PowerBuilder széles körű lehetőséget biztosít az adatok megjelenítéséhez.

A Tabular megjelenítési forma

A rekordok egymás utáni sorokba rendezve találhatók. Minden mező fölött ott van a megnevezése. Ilyenkor a mezők sorrendje felcserélhető, és a megnevezések megváltoztathatók.

A Group megjelenítési forma

Hasonló a tabulár formához. Csoportok képezhetők, melyeknek megjeleníthetők a részösszegei illetve a végső összeg.

A Grid megjelanítési forma

Vonalakkal elválasztva jeleníti meg a sorokat és az oszlopokat. Futási és előnézeti módban is van lehetőség az oszlopok szélességének a megváltoztatására. Szintén változtatható a sorrend is.

Freeform megjelenítési mód

Ez a forma nagyfokú rugalmasságot biztosít. A mezők nevei függőlegesen helyezkednek el az eddigi vizszinteshez képest.

Label megjelenítési mód

Ebben az estben kis cimkék formájában jelennek meg az adatok. Kiválasztható a címke mérete és a típusa.

N-up megjelenítési mód

Egy sorban több (előre definiált számú) rekord is megjeleníthatő.

Graph megjelenítési mód

Grafikonos megjelenítést tesz lehetővé különböző formákban. 17 különböző típusú 2 és 3 dimenziós garfikon közül választhatunk.

Crosstab megjelenítési mód

Kettő vagy több független változóban lehet összegezni az adatokat.

Composite megjelenítési mód

Több DataWindow jeleníthatő meg egyetlen DataWindow-ban.

OLE 2.0 megjelenítési mód

OLE szervertől érkező adat megjelenítésére.

Rich Text megjelenítési mód

Lehetőséget biztosít:

 

Határok és színek beállítása minden DataWindowhoz együttesen

A DataWindow Options dialog box-ban (elérhető a Design>Options menüpontból) a Generation fülre kattintva beállítható a háttérszín és egyéb színparaméter. Ezek a beállítások minden DataWindow-nál érvénybe leszne, de a DataWindow szerkesztő lehetőséget ad ezek egyedi megváltoztatására is.

Report szintű bállítások

A DataWindow szerkesztő munkatere több részre osztható, melyeket bandoknak nevezünk. Minden egyes band mérete, háttérszíne, stb külön megadható. A DataWindow a következő bandokra osztható:

A szürke sor feletti rész a band. A szürke sorban van feltüntetve a band neve (header, stb). A bandok mérete megváltoztatható (egér>bal gomb>húzni). A bandok leírása:

  1. Header: Címet és a mezők neveit tartalmazza minden oldal tetején. A mezők neve megjelenik a grid és tabular esetén.

  2. Detail: Rekordok sorait tartalmazza, annyi darab jelenik meg belőle, amennyi befér a DataWindow magasságába. Mezőnevek csak néha jelennek meg, pl:freeform.

  3. Footer: A lap alján megjelenő információ, általában oldalszámozásra használják.

  4. Summary: Összegek és eredmények jelennek meg az egész DataWindow-ra nézve, az utolsó footer előtt. Ha nincs footer, akkor az utolsó rekord után jelenik meg. A végeredmény csak az utolsó oldalon jelenik meg.

Csoportképzés esetén még a következő bandok is megjelennek:

  1. Group header: Csoport fejlece, néha összegző információt tartalmaz.

  2. Group tailer: Csoportra nézve tartalmaz összeget.

DataWindow objektum szerkesztése

Tervező módban lehetőség van az objektumok paramétereinek beállítására. Jobb gombbal kell az objektumra kattintani és kiválasztani a popup menüből a Propertis (tulajdonság) elemet. Különböző tulajdonság ablakok nyílhatnak ki attól függően, hogy milyen objektumot választottunk ki.

Lehetőség van objektumokat is hozzáadni a DataWindow-hoz. Az objektum felhelyezése után jobb gombbal rákattintva az objektum paraméterek beállíthatók.

Számított érték

A DataWindow számított értéket is tartalmazhat bármalyik band-ban. Számított mezőt adva a DataWindow-hoz a számításokat a kliens oldal végzi. Számított mező elkészítésének lépései:

  1. Az Objects gomb megnyomása után a legördülő menüből kiválasztható a Compute gomb.

  2. Felhelyezése után kinyílik a dialog box.

  3. A More gombot megnyomva a Modify Expression dialog box nyílik ki.

  4. A kifejezés beírása után OK.

  5. OK #2. A számított mező megjelenik a DataWindow-n.

A PowerBuilder 5 előre definiált számítást is felkínál (Object>Average / Count / Page n of n / Sum / Today)

Edit menü

Ebben a menüpontban hasznos dolgok találhatók a tetszetős elrendezés eléréséhez. Használatuk magyarázatot nem igényel.

DataWindow Options

Az Option dialog box (Design>Options...) ad lehetőséget az alapértelmezési paraméterek átállítására.

Az objektumhatárok megjelenítése

A Show Edges kiválasztásával az objektumhatárok láthatóvá válnak. Ez előnyös lehet, mert:

Aligment grid options

A rács és a vonalzó segítségével könnyebb elhelyezni az objektumokat.

Zoom

A munkaterületen és preview módban lehetőség van zoomolásra.

A mezők közötti Tabulátor sorrend beállítása

Design>Tab Order vagy Tab Order gomb.

 

Legördülő DataWindow

Gyakran előfordul, hogy a felhasználónak a létező értékek közül kell választania egyet. Ilyenkor sokkal könnyebb egy legördülő menüből vagy radio gomb segítségével választani, mint fejben tartani az összes értéket. A PowerBuilder erre kínálja például a legördülő DataWindow-t.

Könnyen belátható, hogy a radio gombos megoldás csak néhány választási lehetőség esetén kezelhető észszerű képernyőméretek mellett. Ezenkívül a létező értékek listája folyamatosan változhat, így ezt mindig újra kell generálni. Ezen probléma egyik lehetséges megoldása a DataWindow.

Példaként vegyük azt az esetet, amikor egy vállalatnál az új dolgozók adatait visszük fel. És a dolgozó egyik mezője a vállalatrészleg azonosítója, ahol dolgozik. Ilyenkor ahelyett, hogy magát az azonosító kódot írnánk be, egy legördülő DataWindow-ból kiválasztjuk a megfelelő részleget és majd ebből kiolvasható lesz az ID is. Ebben az esetben a név lesz kiválasztva és megjelenítve az ablakban, de az ID lesz a letárolási érték.

Ilyen esetekben a mező Properties>Edit -jében a Style mezőt kell DropDownDW-ra állítani. Amikor a felhasználó a mezőre megy a legördülő DataWindow megjeleníti a legutolsó értékeket.

A DataWindow-ban minden olyan mezőnek meg kell jelenni, amit használni akarunk. Általában ez két mező, az egyik amit a felhasználó lát, míg a másik amit letárolunk.

 

A DataWindow Control

A DataWindow tulajdonképpen nem más mint egy eszköz az adatbázis adatainak az eléréséhez. Ez azonban csak az adatok lekérdezését valósítja meg. Ahhoz, hogy az így kapott adatok láthatóvá váljanak meg is kell őket jeleníteni. Az alkalmazások rendszerint több különböző elemi információt is megjeleníthetnek egy képernyőn. A PowerBuilder rendszer lehetőséget ad arra, hogy egy ablakban ne csak elemi vezérlő elemeket tegyünk fel, mint például egy egysoros szövegmező, hanem egy adatablakot is. Azaz az egyik ablak magába foglal egy másik adatablakot. A DataWindow Control elnevezés egy ilyen, másik ablakra feltett adatablakot jelöl.

A DataWindow Control mögé mindig egy a konkrét DataWindow objektum köthető. A DataWindow objektum adatai egy bufferben tárolódnak, melyet Primary Buffernek (Elsődleges buffernek) hívunk. Az ebben a bufferben lévő adatok láthatók majd a DataWindow Controlon keresztül.

DataWindow Control definiálása

A Window szerkesztő használatakor egy DataWindow vezérlő elemet lehet felhelyezni a képernyőre. Csakúgy, mint bármely más vezérlő elem a DataWindow definíciója is a PowerBuilder library-ban tárolódik, amikor elmentjük az ablakot. A DataWindow vezérlő elem tulajdonságait az objektum kijelölése után a Properties menüpontban érhetjük el.

A DataWindow objektum és a DataWindow Control összekapcsolása

A DataWindow vezérlő elem egyik tulajdonsága hordozza a hozzá kapcsolódó DataWindow objektum azonosítását. A DataWindow objektum két különböző módon köthető a DataWindow vezérlő elemhez: a fejlesztői környezetben, vagy a dinamikusan a futási idő alatt.

Ha a kapcsolatot a fejlesztői környezetet alatt definiáljuk, akkor csak egy DataWindow objektum köthető a kontroll elemhez, míg a futási idő alatt dinamikusan több különböző objektum is társítható egymás után a vezérlő elemhez.

Társítás a fejlesztői környezetben

A Window szerkesztőn keresztül történhet. A Properties menüpontot kell kiválasztani a Popup menüből, és ott a DataWindow Object Name mellett a Browse gombot. A Select DataWindow dialog boxban található listából kiválasztható a megfelelő objektum, majd az OK gombra kattintva elfogadtathatjuk a kijelölt értéket.

Társítás a futás alatt

Mivel a DataWindow objektum neve a DataWindow control elem egyik tulajdonsága, így az értéke megváltoztatható a scriptben, csakúgy, mint bármely más érték.

Ha társítani szeretnénk egy objektumot és egy vezérlő elemet, akkor a vezérlő elem DataObject tulajdonságát kell átállítani.

DWControl.DataObject = DWname

Például a

dw_reports.DataObject = "d_report1"

utasítás a dw_reports vezérlő elemhez a d_report1 nevű adatablak objektumot rendeli hozzá.

 

A DataWindow kapcsolódása az adatbázishoz

A PowerBuilder alkalmazásokban az adatbázisból az adatok kinyerése illetve ott az adatok módosítása elsődlegesen a DataWindow objektumon és vezérlő elemen keresztül történik.

A kapcsolódáshoz a DataWindow objektum a következő információkat várja:

Mint az előzőekben már láthattuk, a DataWindow vezérlő lelem az adatok megjelenítésére szolgál. Ezeknek is lehetnek különböző metódusai, melyek az adatok manipulálását szolgálják. Például, ha egy alkalmazásban a felhasználó az adatbázis adatait akarja megtekinteni, akkor a kódszeletnek tartalmaznia kell a következő utasítást:

dw_control.Retrieve()

Ez a függvény hajtja végre az objektumhoz tartozó SQL SELECT utasítást, és jeleníti meg az eredményt.

A tranzakció objektum társítása a DataWindow objektumhoz

A DataWindow objektum és a DataWindow vezérlő elem társítása után még egy lépés hátra van a kapcsolat felvételhez. A kapcsolat Transaction objektumának tulajdonságait is be kell állítani. Az adatbázis azonosítóját a DataWindow objektumhoz a SetTransObject() függvény segítségével állíthatjuk be. A függvény általános formája a következő:

dw_control.SetTransObject(Transaction_object)

Ez a függvény szolgáltatja a szükséges adatbázis belépési információt a DataWindow objektumnak és a DataWindow vezérlő elemnek.

E függvény meghívásának tipikus helye a DataWindow Constructor eseményhez kapcsolódó kódszelete, vagy az ablak Open eseményhez kapcsolódó kódszelete. De természetes, hogyha bármilyen más esemény hatására megváltozik a DataObject értéke, akkor ott újra kell hívni a függvényt.

Adatok kinyerése

A sikeres adatbázis kapcsolódás után az alkalmazás elérheti az adatbázist, s onnan adatokat nyerhet ki, illetve módosíthatja az ott tárolt adatokat. Adatok kinyerésére a

Retrieve()

függvény használható. A függvénynek két formában hívható:

A retrieve() hívása argumentum nélkül

Amikor olyan alkalmazás készül, melynek nincs szüksége az alkalmazásból vett értékekre az adatok kinyeréséhez, azaz partméter nélküli az adatablakhoz rendelt SELECT utasítás, akkor a következõ formát kell használni:

DW_CONTROL.RETRIEVE()

A retrieve hívása argumentumokkal

Olyan DataWindow objektumok esetén, melyek aktuális paraméter értékeket igényelnek az adatlekérdezéshez, a függvényt a következõ formában kell használni:

DW_CONTROL.RETRIEVE( ARG1 {, ARG2, ARG3, ... } )

A Retrieve() visszatérési értékei

A visszatérési érték három féle lehet:

Érték:

Jelentés:

-1

Sikertelen.

0

Nincs áthozott adat.

>0

Az áthozott rekordok száma.

 

 

5. Objektum-orientáltság A PowerBuilder-ben

 

A PowerBuilder objektum egy olyan egyed, melynek vannak tulajdonságai (jellemzői) és van viselkedése. Egy objektum osztály (röviden: osztály) egy objektum tulajdonságait és viselkedését írja le, vagyis meghatározza hogy egy objektum milyen és hogyan viselkedik.

Például legyen az objektum egy ablak (Window). Ennek olyan tulajdonságai lehetnek, mint például magasság, szélesség, keret, megjelenítési pozíció stb. Az objektum viselkedését az objektumon értelmezett függvények valamint az objektumon bekövetkező események határozzák meg. Példánkban az ablakokra értelmezett függvények pl: Move(), Resize() és Close() és az események lehetnek pl: Open, Activate stb.

A PowerBuilder-ben a különböző objektum definíciós komponenseket használjuk (Object Painter-ek, pl. User Object Painter, WindowPainter, MenuPainter stb.) arra, hogy saját osztályokat hozzunk létre.

Egy osztály egyede, az osztály egy megtestesülési formája (azaz előfordulása). Például az ablakokra kitett OK gomb a CommandButton osztály egy egyede (Instance). Amikor létrehozunk egy objektumot az osztály definícót felhasználva, akkor egy egyedelőfordulást hozunk létre (ami saját memóriaterülettel rendelkezik). Egy adott objektum osztályból létrehozott minden egyes objektumnak meg lehet a maga tulajdonság halmaza (azaz különböző tulajdonság értékekkel rendelkezhetnek), például minden létrehozott ablak különböző méretű lehet.

A PowerBuilder osztályok definíciója PBL fájlokban tárolódik, ami forráskód és lefordított kód keveréke. A PowerBuilder ezt az osztálydefiníciót használja egy osztály egyedének létrehozásához. Ez a fájl exportálható a LibraryPainter-ből és tetszőleges szövegszerkesztő programmal megtekinthető.

PowerBuilder objektumok

A PowerBuilder rendszerobjektumok olyan beépített objektumok, amelyeket az alkalmazások fejlesztéséhez használunk. Ilyen objektumok például az ablakok, menük, a grafikus vezérlő elemek és más előre definiált egyedek, amikre alkalmazásainkból hivatkozhatunk (pl. a Message és az Error objektumok).

A PowerBuilder vezérlő elemek a rendszerobjektumok egy alcsoportja, amiket ablakokban vagy user objektumokban helyezünk el. Rendszerint ezek grafikus objektumok, amik lehetővé teszik, hogy a felhasználók kommunikáljanak az alkalmazásunkkal.

A PowerBuilder rendszer struktúrák szintén a rendszerobjektumok egy részhalmazát képezik és ezek tartalmazzák más rendszerobjektumok változóit. Például ilyen rendszer struktúra az Environment (környezetleíró) objektum.

 

Rendszerobjektumok tulajdonságai, eseményei és függvényei

Minden rendszerobjektumnak van számos tulajdonsága. Ezeket a tulajdonságokat (azok értékét) szkriptekben vagy az objektum Property lapján lehet megváltoztatni.

A PowerBuilder alkalmazások eseményvezérlet alkalmazások. Azért írunk szkripteket, hogy meghatározzuk mi történjen, amikor egy esemény bekövetkezett.

A vezérlési elemekhez, kivéve a GroupBox-ot és a rajz objektumokat, mindig kötünk eseményeket. Néhány rendszerobjektum viszont, például a rendszer struktúrák, soha nincsenek eseményhez kötve.

Beépített függvények, melyeket objektumokra illetve vezérlő elemekre lehet meghívni.

Megjegyzés:

A PowerBuilder-ből lekérdezhetők a rendszerobjektumok, a hozzájuk tartozó (rajtuk értelmezett) tulajdonságok, események és függvények a Browser ® System fülből (PowerBar-ból érhető el).

  1. Ablak objektum

    2. Ablak nyitása: Open(w_employee)

    Ekkor egy w_employee típusú ablak egyed jön létre w_employee változónévvel, amit a rendszer globálisan kezel, vagyis más ablakokból lehet rá hivatkozni és újbóli megnyitásakor a már létező (megnyitott) ablak aktivizálódik, de nem kerül megnyitásra új ablak.

    Mivel egy ablak tulajdonképpen egy adattípus, ezért ezzel a típussal változó is deklarálható:

    w_employee mywin

    Ekkor egy ablak egyed jön létre, ami más ablakokból nem érhető el. Vagyis a rendszer a referencia változók felhasználásával megnyitott ablakokat nem globálisan kezeli!!!

    Ennek az ablak egyednek a megnyitása: Open(mywin)

    Ebben az esetben valahányszor kiadjuk az Open(mywin) utasítást, a w_employee ablak egy új egyede kerül megnyitásra.

    Egy ablak egyed bezárása: Close(mywin)

    Ekkor bezáródik az aktív ablak egyed (amelyikre meghívtuk a Close() függvényt). Ennél általánosabb megoldás, ha az ablakra felhelyezünk egy kilépés gombot és ennek a Clicked eseményéhez azt a szkriptet rendeljük, hogy:

    Close(parent)

    Az utasítás hatására az az ablak kerül bezárása, amelyiken a kilépés gombot megnyomtuk. Ugyanis nyomógombok esetén a parent (szülő) hivatkozási tag azt az ablak objektumot jelenti, amelyiken az adott nyomógomb található.

    Ablaktömb létrehozása: w_employee mywinarray[5] vagy w_employee mywinarray[]

    Ablak egyedek megnyitása: Open(mywinarray[1]), Open(mywinarray[2])

    Ez az utasítás kinyitja a w_employee ablak első és második egyedét.

    Megnyitáskor a két ablak ugyanazon a helyen lesz, ezért célszerű az egyik ablakot áthelyezni egy másik pozícióba:

    mywinarray[1].Move(100,200)

    A Move(x,y) függvény bármely objektumra és vezérlési elemre meghívható.

    Esetleg a második ablak el is rejthető:

    mywinarray[2].Hide()

    Hivatkozhatunk valamely ablakon lévő vezérlési elemre is:

    mywinarray[1].sle_count.text = "2"

    Vagyis az első ablakban lévő beviteli mezőbe beírunk egy 2-es számot. Ehhez természetesen az első ablakban kell lennie egy sle_count nevű SingleLineEdit beviteli mezőnek (vezérlési elemnek).

    Több ablakegyed kinyitása vagy bezárása:

    w_employee myarray[5]

    for i = 1 to 5

    Open(myarray[i])

    next

    Különböző típusú ablakokat tartalmazó tömböt is létre lehet hozni. Ehhez azt kell tudni, hogy minden felhasználó által definiált ablak a window adattípusból van leszármaztatva, ezért:

    window newarray[3]

    a newarray tömb bármilyen típusú ablakra hivatkozhat.

    window newarray[3]

    string win[3]

    int i

    win[1] = "w_employee"

    win[2] = "w_customer"

    win[3] = "w_sales"

    for i = 1 to 3

    Open(newarray[i], win[i])

    next

    Itt az Open függvény következő formáját használtuk:

    Open ( windowVariable, windowType )

    Ahol windowVariable egy window típusú változó (vagy a window-ból leszármaztatott ablakváltozó) és windowType egy sztring, ami meghatározza az ablak típusát. A fenti példa három ablakot fog megnyitni: a w_employee egy egyedét, a w_customer egy egyedét és a w_sales egy egyedét.

  2. Error objektum

    3. Az Error objektum feltöltésére két függvény áll rendelkezésre:

    - SignalError(): ez lehetővé teszi az Error objektum feltöltését egy megadott számmal és szöveggel mielőtt a függvény rendszerhiba (SystemError) eseményt vált ki az alkalmazás szintjén.

    - PopulateError(): ez lehetővé teszi az Error objektum feltöltését egy megadott számmal és szöveggel anélkül, hogy rendszerhiba (SystemError) esemény következne be az alkalmazás szintjén.

    SignalError()

    SystemError eseményt vált ki az alkalmazás szintjén.

    SignalError ( { number }, { text } )

    Ahol number (opcionális) egy integer, melynek értéke az Error objektum number tulajdonságában kerül eltárolásra és ezt a számot használjuk fel az üzenet objektumban, a hiba jelzésére.

    A text sztring szintén opcionális, mely az Error objektum text tulajdonságában kerül eltárolásra és ezt a szöveget használja az üzenet objektum a hiba jelzésére.

    Visszatérési értéke (integer) 1 ha sikeresen végrehajtódott illetve –1 ha hiba történt a függvény végrehajtása során. Ezt a visszatérési értéket általában nem használjuk sehol.

    Használata: hibakezelés, hibafeldolgozás tesztelése

    int error_number

    string error_text

    /*Az Error objektum feltöltése: a struktúra többi értéke akkor kerül feltöltésre, amikor a SystemError esemény bekövetkezett*/

    Error.Number = 1010

    Error.Text = "Salary must be a positive number."

    Error.Windowmenu = "w_emp"

    error_number = Error.Number

    error_text = Error.Text

    /*Az Error objektum teljes feltöltése majd SystemError esemény kiváltása*/

    SignalError(error_number, error_text)

    Az Error objektumba saját magunk által definiált hibát is megadhatunk (saját számmal és szöveggel), majd meg kell hívni a SignalError függvényt. A felhasználó által létrehozott hiba kezelésére azonban be kell szúrni a kódot a SystemError esemény szkriptjébe. Ha ezt nem tesszük meg, akkor a SignalError függvény meghívásakor nem történik semmi.

     

    PopulateError()

    Feltölti az Error objektumot anélkül, hogy SystemError eseményt váltana ki.

    PopulateError ( number, text )

    Ahol number egy integer, melynek értéke az Error objektum number tulajdonságában kerül eltárolásra és text egy sztring, mely az Error objektum text tulajdonságában kerül eltárolásra.

    Visszatérési értéke (integer) 1 ha sikeresen végrehajtódott illetve –1 ha hiba történt a függvény végrehajtása során. Ezt a visszatérési értéket általában nem használjuk sehol.

    Használata: a PopulataError függvénnyel lehet értéket adni az Error objektum number és text mezőinek. A többi mező az Error objektumban automatikusan kerül feltöltésre. Ezután meg kell hívni a SignalError() függvényt argumentum nélkül, ami kiváltja a SystemError eseményt. A felhasználó által definiált hibák kezelésére be kell szúrni a kódot a SystemError esemény szkriptjébe. Ha ezt nem tesszük meg, akkor a SignalError függvény hívásakor nem történik semmi.

    /* A példában meghívjuk a gf_DoSomething függvényt, melynek két paramétere van: egy táblanév és egy rekord szám; visszatérési értéke sikeres végrehajtás esetén 0 egyébként pedig egy negatív szám */

    li_result = gf_DoSomething("Company", record_id)

    IF (li_result < 0) THEN

    CHOOSE CASE li_result

    CASE -1

    PopulateError(1, "No company record exists record id: " + record_id)

    CASE -2

    PopulateError(2, "That company record is currently locked. Please try again later.")

    CASE -3

    PopulateError(3, "The company record could not be updated.")

    CASE else

    PopulateError(999, "Update failed.")

    END CHOOSE

    SignalError()

    END IF

     

  3. Message objektum

    4. A Message objektumot használjuk olyan események feldolgozására, melyek nem PowerBuilder által definiált események, valamint különböző ablakok között paraméterek átadására. A Message objektum a PowerBuilder-ben előre definiált, de saját (leszármaztatott) Message objektum létrehozására is van lehetőség.

     

  4. Environment objektum

Az Environment objektum egy rendszerstruktúra, mely arról a számítógép platformról tartalmaz információkat, ahol a PowerBuilder alkalmazásunk fut. Az objektumot a GetEnvironment(envinfo) függvény hívásával tudjuk feltölteni, ahol envinfo az az Environment objektum, ami a környezeti információkat tárolja.

Az Environment objektumhoz nem kapcsolódik esemény.

 

 

 

 

CREATE utasítás

Megadott objektum típusú objektum egyedet hoz létre. A CREATE utasítás után a létrejött objektum egyed tulajdonságaira hivatkozni a ‘.’ operátorral lehet.

Szintaxisa:

objectvariable = CREATE objecttype

Ahol objectvariable egy változó melynek típusa objecttype és objecttype az objektum adattípusa.

Az objektumtípus meghatározása dinamikusan:

objectvariable = CREATE USING objecttypestring

Ahol objectvariable egy változó, melynek adattípusa megegyezik a létrehozandó objektum típusával és objecttypestring egy sztring, melynek értéke a létrehozandó osztálytípus neve.

Nem kell CREATE utasítást használni ahhoz, hogy memóriát foglaljunk a következő objektumok esetén:

Viszont PopupMenu létrehozásához CREATE utasítást kell használni!!!

Az objektumtípus meghatározása dinamikusan:

A CREATE USING lehetővé teszi, hogy az alkalmazás dinamikusan válassza meg az objektum típusát.

uo_a uo_a_var

string ls_objectname

IF ... THEN

ls_objectname = "uo_a_desc1"

ELSE

ls_objectname = "uo_a_desc2"

END IF

uo_a_var = CREATE USING ls_objectname

 

DESTROY utasítás

CREATE utasítással létrehozott objektumok megszűntetése, a memóriaterület felszabadítása. A DESTROY utasítást csak akkor szabad kiadni, ha az adott objektumra biztosan nem hivatkozik más objektum. A PowerBuilder egyébként automatikusan megszűnteti azokat az objektumokat, melyekre nincs hivatkozás.

Példák

  1. Új tranzakciós objektum létrehozása

    2. transaction DBTrans

    DBTrans = CREATE transaction

    DBTrans.DBMS = 'ODBC'

  2. UserObject létrehozása, amikor az alkalmazásnak szüksége van az általa nyújtott szolgáltatásokra. A példa előbb ellenőrzi hogy létezik-e a UserObject mielőtt meghívja rá a függvényeket.

    3. Az n_service objektum hozza létre a Service objektumot. Az invo_service egy instance változó.

    n_service invo_service

    Az objektum Open eseménye létrehozza a Service objektumot.

    //valamely objektum Open eseménye

    IF (some condition) THEN

    invo_service = CREATE n_service

    END IF

    Amikor egy másik szkript olyan függvényt akar hívni, ami az n_service osztályba tartozik, előbb leellenőrzi, hogy az invo_service létrejött-e.

    IF IsValid(invo_service) THEN

    invo_service.of_perform_some_work( )

    END IF

    Ha a Service objektum létrejött, akkor meg is kell szűntetni ha már nincs rá szükség.

    IF isvalid(invo_service) THEN DESTROY invo_service

  3. Példa Environment objektum alkalmazására

n_file_service_class lnv_fileservice

string ls_objectname

environment luo_env

GetEnvironment ( luo_env )

IF luo_env.Win31 = TRUE THEN

ls_objectname = "n_file_service_class_win16"

ELSE

ls_objectname = "n_file_service_class_win32"

END IF

lnv_fileservice = CREATE USING ls_objectname

 

Objektumokra használható hivatkozási tagok

This

Ez a hivatkozási tag azt az ablakot, user object-et, menüt, alkalmazás objektumot vagy vezérlő elemet jelenti, amelyikhez az aktuális szkriptet (amelyikből hivatkozunk) írtuk.

Használatával általánosabb szkriptek írhatók (tulajdonos független). Például a következő utasítás az aktuális objektum X tulajdonságát változtatja meg:

This.X = This.X + 50

Használata akkor kötelező, amikor egy globális vagy egy lokális változónak ugyanaz a neve, mint egy instance változónak. Ugyanis a PowerBuilder először a globális vagy lokális változót találja meg, de a This hivatkozási taggal elérhetjük, hogy az instance változót vegye figyelembe a rendszer a globális helyett.

Példák:

  1. A következő utasítást egy menü szkriptjében elhelyezve, az utasítás hatására a kiválasztott menüelem mellé egy kiválasztó jel (pipa) kerül.

    2. This.Check( )

  2. A következő függvényhívásnál a This a szkriptet magába foglaló objektumra való hivatkozást ad át.

    3. ReCalc(This)

  3. Ha a következő utasításnál elhagyjuk a This hivatkozási tagot, akkor x egy lokális változót jelent (amennyiben definiált). Vagyis ekkor a szkript az x lokális változó értékéhez ad hozzá 50-et, nem pedig a vezérlő elem vagy objektum X tulajdonságához. Ha azonban nincs x lokális változó deklarálva, akkor a szkript az objektum X tulajdonságára hivatkozik.

    4. x = x + 50

  4. A következő szkriptet használjuk annak érdekében, hogy biztosan az objektum tulajdonságát változtassuk meg. Például ha a következő szkriptet egy CommandButton Clicked eseményéhez kötjük, akkor a gomb megnyomásakor megváltozik a gomb X tulajdonsága, vagyis a gomb vízszintes pozíciója.

This.x = This.x + 50

 

 

 

 

 

 

 

Parent

A Parent (szülő) hivatkozási tag azt az objektumot jelöli, amelyik az aktuális objektumot magába foglalja.

A következő objektumokhoz kötött szkriptekben használható:

Attól függ, hogy mit jelöl a Parent hivatkozási tag, hogy hol használjuk:

Példák:

  1. Ha a következő utasítást egy CommandButton Clicked eseményéhez kötött szkriptben helyezzük el, akkor a gomb megnyomásakor bezáródik az ablak, amin a gomb található.

    2. Close(Parent)

  2. Ha a következő utasítást egy CommandButton szrkiptjébe tesszük, akkor a gomb megnyomásakor megjelenik egy vízszintes gördítősáv az ablakban, vagyis az utasítás beállítja a gombot tartalmazó ablak HscrollBar tulajdonságát TRUE-ra.

    3. Parent.HScrollBar = TRUE

  3. Ha a következő utasítást egy user objektumon található CheckBox Clicked eseményéhez kötött szkriptben adjuk ki, akkor a CheckBox kijelölése elrejti a user objektumot.

    4. Parent.Hide( )

  4. Ha a következő utasítást ugyanennek a CheckBox-nak a szkriptjében helyezzük el, akkor a CheckBox kijelölésekor a user objektum elérhetetlenné / inaktívvá válik. Vagyis az utasítás beállítja a user objektum Enabled mezőjét (tulajdonságát) FALSE-ra.

    5. Parent.Enabled = FALSE

  5. Ha a következő utasítást a Select menüpontból elérhető SelectAll menüelem Clicked eseményéhez kötött szkriptben adjuk meg, akkor a SelectAll menüelem kiválasztása után a Select menüpont elérhetetlenné válik (inaktív lesz).

    6. Parent.Disable( )

  6. Ha a következő utasítást ugyanott helyezzük el, ahol az előzőt, akkor a SelectAll menüelem kiválasztásával megjelölésre kerül a Select menüpont.

Parent.Checked = TRUE

Super

Amikor leszármaztatott objektumhoz vagy vezérlő elemhez írunk szkriptet, akkor lehetőségünk van bármely őshöz kötött szkript / függvény meghívására. Az őst direkte is megnevezhetjük a híváskor, vagy használhatjuk a Super hivatkozási tagot a közvetlen ős kijelöléséhez.

Akkor kell használnunk a Super hivatkozási tagot egy ősosztálybeli függvény meghívásakor, ha a leszármaztatott osztályban is létezik ugyanilyen nevű és argumentumlistájú függvény. Egyébként a Super hivatkozási tag nélkül hívható az ősosztályban definiált függvény.

Nem használható viszont a Super hivatkozási tag arra, hogy elérjük az ős ablakobjektumon lévő vezérlő elemeket (gombokat, beviteli mezőket stb.). A Super hivatkozási tag csak esemény vagy függvény esetén használható.

Példák:

  1. Ebben a példában meghívjuk az ősosztálybeli wf_myfunc függvényt (feltesszük, hogy a leszármazott osztályban is van egy wf_myfunc nevű függvény definiálva).

    2. Super::wf_myfunc(myarg1, myarg2)

    A fenti utasítást egy leszármaztatott ablakhoz definiált szkriptben vagy függvényben kell kiadni, nem pedig az ablak egy vezérlő eleméhez kötött szkriptben.

  2. A következő utasítás, ha egy CommandButton szkriptjében adjuk ki, akkor meghívja a közvetlen ős ablakban található CommandButton Clicked eseményéhez kötött szkriptjét.

Super::EVENT Clicked()

 

Egy objektum ősében definiált függvények és események meghívása az objektumból

{ objectname. } ancestorclass ::{ type } { when } name ( { argumentlist } )

Ahol objectname annak az objektumnak a neve, amelynek az őse tartalmazza a végrehajtani kívánt függvényt;

ancestorclass annak az ősosztálynak a neve, amelyiknek a függvényét vagy eseményét végre akarjuk hajtani (ha a közvetlen ősosztályról van szó használjuk a Super hivatkozási tagot);

type határozza azt meg, hogy függvényt vagy eseményt hívunk (FUNCTION, EVENT);

when határozza azt meg, hogy a függvény vagy esemény azonnal végrehajtásra kerüljön-e vagy csak az aktuális szkript futása után – megadható értékek: TRIGGER — (Default) azonnali végrehajtás, POST — halasztott végrehajtás;

name az objektum meghívandó függvényének vagy eseményének a neve;

argumentlist a meghívandó függvénynek vagy eseménynek átadásra kerülő értékek listája.

Példák:

  1. Tegyük fel hogy egy ablak w_ancestor ősablakának van egy ue_process nevű eseménye és a leszármaztatott ablaknak is van definiált szkriptje ugyanerre az eseményre.

    2. EVENT ue_process( )

    w_ancestor::EVENT ue_process( ) //csak az adott ősablak eseményét hívja meg

  2. A következő utasítást egy leszármaztatott ablak szkriptjében vagy egy ebben az ablakban található vezérlő elem szkriptjében adjuk meg és ez meghívja az adott ablak közvetlen ősében a Clicked eseményre definiált szkriptet.

    3. Super::EVENT Clicked(0, x, y)

  3. A következő utasítások az ősablak wf_myfunc függvényét hívják meg (feltéve, hogy a leszármaztatott ablakban szintén van wf_myfunc nevű függvény definiálva).

    4. Super::wf_myfunc( )

    Super::POST wf_myfunc( )

  4. Tegyük fel, hogy az ősablak CloseQuery eseménye visszatér valamilyen értékkel annak ellenőrzésére, hogy az ablakot be kell-e zárni vagy sem. Ha a leszármaztatott objektumnak szintén van definiálva szkriptje erre az eseményre az ősobjektum visszatérési értéke nem kerül vissza a rendszerhez. Mégis a visszatérési érték felfogásához szúrjuk be a következő kódot a leszármaztatott objektum szkriptjébe:

result = Super::EVENT CloseQuery( )

RETURN result

 

CALL utasítás

Egy leszármaztatott objektum szkriptjéből meghív egy ősosztálybeli szkriptet. Ilyen szkripteket user objektum, menü vagy ablak objektum ősosztály eseményeire hívhatunk meg.

CALL ancestorobject {`controlname}::event { ( argumentlist ) }

Ahol ancestorobject a leszármaztatott objektum egy őse; a controlname egy ős ablakban vagy hagyományos user objektumban található vezérlőelem neve; event egy esemény az ősobjektumra; argumentlist az eseménynek átadni kívánt értékek listája.

Példák:

  1. A következő utasítás meghív egy tetszőleges ős ablak valamely eseményére (itt Open) definiált szkriptet.

    2. CALL w_emp::Open

  2. A következő utasítás meghívja a w_emp ős ablakban található cb_close CommandButton Clicked eseményéhez definiált szkriptet.

CALL w_emp`cb_close::Clicked

 

 

 

 

Objektumokon értelmezett függvények

Create()

DataWindow objektumot hoz létre.

dwcontrol.Create ( syntax {, errorbuffer } )

Ahol dwcontrol annak a DataWindow controlnak vagy DataStore-nak a neve, ahol a PowerBuilder a DataWindow objektumot létrehozza. Syntax egy sztring, melynek értéke a a DataWindow objektum létrehozásához felhasznált DataWindow forráskód. Az errorbuffer megadása opcionális és annak a sztringnek a neve, ami a felmerült hiba üzenetet tartalmazza. Ha nem adjuk meg ezt a sztringet, akkor a hibaüzenet egy MessageBox-ban jelenik meg.

A következő példában létrehozunk egy új DataWindow objektumot a dw_new változóban a SyntaxFromSQL függvény által visszaadott DataWindow forráskódnak megfelelően.

string error_syntaxfromSQL, error_create

string new_sql, new_syntax

new_sql = 'SELECT emp_data.emp_id, ' + 'emp_data.emp_name ' + 'from emp_data ' &

+ 'WHERE emp_data.emp_salary>45000'

new_syntax = SQLCA.SyntaxFromSQL(new_sql, 'Style(Type=Form)', error_syntaxfromSQL)

IF Len(error_syntaxfromSQL) > 0 THEN

// Hiba megjelenítése egy MultiLineEdit többsoros beviteli ablakban

mle_sfs.Text = error_syntaxfromSQL

ELSE

// Új DataWindow létrehozása

dw_new.Create(new_syntax, error_create)

IF Len(error_create) > 0 THEN

// Hiba megjelenítése egy MultiLineEdit többsoros beviteli ablakban

mle_create.Text = error_create

END IF

END IF

dw_new.SetTransObject(SQLCA)

dw_new.Retrieve()

SyntaxFromSQL()

DataWindow forráskódot generál egy SQL utasítás alapján.

transaction.SyntaxFromSQL ( sqlselect, presentation, err )

Ahol transaction a transaction objektum neve; sqlselect egy sztring, melynek értéke érvényes SQL SELECT utasítás kell legyen; presentation egy sztring, melynek értéke egy alapértelmezett megjelenítési stílus – formátuma: Style(Type=presentationstyle); és err szintén szting, ahol a hibaüzenet kerül eltárolásra.

 

A teljes megjelenítési sztring formátuma:

"Style ( Type=value property=value ... )

DataWindow ( property=value ... )

Column ( property=value ... )

Group groupby_colnum1 Fby_colnum2 ... property ... )

Text property=value ... )

Title ( 'titlestring' )"

Példák a függvény használatára:

string ERRORS, sql_syntax

sql_syntax = "SELECT emp_data.emp_id," + "emp_data.emp_name FROM emp_data " &

+ "WHERE emp_data.emp_salary >45000"

//A generált DataWindow forráskódot egy MultiLineEdit mezőben jeleníti meg

//A megjelenítési stílus: tabular

mle_sql.text = SQLCA.SyntaxFromSQL(sql_syntax, "", ERRORS)

A következő példában grid megjelenítési stílusú DataWindow objektumot hozunk létre.

string ERRORS, sql_syntax

string presentation_str, dwsyntax_str

sql_syntax = "SELECT emp_data.emp_id," + "emp_data.emp_name FROM emp_data "&

+ "WHERE emp_data.emp_salary > 45000"

presentation_str = "style(type=grid)"

dwsyntax_str = SQLCA.SyntaxFromSQL(sql_syntax, presentation_str, ERRORS)

IF Len(ERRORS) > 0 THEN

MessageBox("Caution", "SyntaxFromSQL caused these errors: " + ERRORS)

RETURN

END IF

dw_1.Create( dwsyntax_str, ERRORS)

IF Len(ERRORS) > 0 THEN

MessageBox("Caution", "Create cause these errors: " + ERRORS)

RETURN

END IF

dw_1.SetTransObject(SQLCA)

dw_1.Retrieve()

 

Modify()

Egy DataWindow objektumot módosít, tulajdonságértékeinek megváltoztatásával.

dwcontrol.Modify ( modstring )

A következő utasítás megváltoztatja a DataWindow háttérszínét pirosra.

dw_cust.Modify("DataWindow.Color = 255")

A következő utasítás megváltoztatja a Dept_t szöveges objektum szövegét.

dw_cust.Modify("Dept_t.Text='Dept'")

CreateInstance()

Távoli objektum egy egyedét hozza létre.

connection.CreateInstance (objectvariable {, classname } )

Ahol connection az adatbázis kapcsolat létesítésénél használt kapcsolódási objektum neve; objectvariable egy változó, melynek típusa megegyezik a létrehozandó objektum típusával, vagy annak egy leszármaztatott osztályával; és a classname sztring megadása opcionális, melynek értéke a létrehozandó osztály adattípusának a neve.

A következő példában létrehozunk egy objektumot (helyi vagy távoli objektumként). A példában távoli objektum létrehozásához a CreateInstance() függvényt használjuk és a CREATE utasítás szolgál helyi objektum létrehozásához.

boolean bWantRemote

connection myconnect

uo_customer iuo_customer //UserObject típusú

//Annak meghatározása, hogy helyi vagy távoli objektumot akarunk létrehozni

...

//Az objektum létrehozása

IF bWantRemote THEN

//Távoli objektum létrehozása

IF myconnect.CreateInstance(iuo_customer) <> 0 THEN

//hiba

...

END IF

ELSE

//Helyi objektum létrehozása

iuo_customer = CREATE uo_customer

END IF

/*Függetlenül attól, hogy az objektum a szerver vagy a kliens gépen lett létrehozva, ugyanúgy hívható meg rá függvény*/

IF isValid(iou_customer) THEN

iuo_customer.GetCustomerData()

END IF

 

 

 

6. DATA WINDOW VEZÉRLŐ ELEM TULAJDONSÁGAI, METÓDUSAI

 

DataWindow kontrolt használhatunk egy ablakban, vagy egy felhasználó által definiált objektumon belül, és ilyenkor nem kell mást tenni, mint létrehozni egy DataWindow objektumot, melynek segítségével láthatóvá válnak az adatok, illetve manipulálhatunk azokon.

A DataWindow objektum lehetővé teszi a felhasználó számára, hogy az adatbázis adatait vagy más információkat megjelenítsen, azokon manipuláljon, azokat módosítsa. DataWindow objektumot a DataWindow painter segítségével készíthetünk.

Tulajdonságok:

Tulajdonság:

Típus:

Leírás:

Border

Boolean

Meghatározza, hogy a kontrolnak van-e kerete. Lehetséges értékei:

  • True - van
  • False - nincs

BorderStyle

BorderStyle (enumerated)

Meghatározza a keret típusát. Értékei:

StyleBox!

StyleLowered!

StyleRaised!

StyleShadowBox!

BringToTop

Boolean

Meghatározza, hogy a PowerBuilder a sor elejére rakja-e a kontrolt.

ControlMenu

Boolean

Meghatározza, hogy a Control Menu box megjelenje-e a Control Title bar-ban. Értékei:

  • True - megjelenik
  • False - nem jelenik meg

DataObject

String

Tartalmazza annak a DataWindow objektumnak vagy a Reportnak nevét, amely a kontrolhoz kapcsolódik.

DragAuto

Boolean

Megadja, hogy a PowerBuilder automatikusan Drag módba teszi-e a kontrolt. Értékei:

  • True - Amikor rákattintasz a kontrolra, az automatikusan Drag módba kerül.
  • False - Amikor rákattintasz a kontrolra, az nem kerül automatikusan Drag módba, hanem manuálisan kell beállítani, a Drag függvény használatával.

DragIcon

String

Tartalmazza annak az ikonnak a nevét (vagy a file nevét, ami az ikont tartalmazza), amit szeretnél megjeleníteni, amikor a felhasználó vonszolja a kontrolt (az ICO file). A default ikon egy box a kontrol méretével azonos nagyságú.

Amikor a felhasználó vonszolja a kontrolt, az ikon mutatja, hogy a kontrol olyan terület fölött van ahová beejthető (ahhoz kapcsolható) - érvényes drop terület. Amikor a kontrol kívül esik az érvényes drop tartományon, akkor azt a No-Drop ikon jelzi.

Figyelem: Az ICO file-ok csak a Windows és a Macintosh platformokon támogatottak.

Enabled

Boolean

Meghatározza, hogy a kontrol elérhető-e (kiválasztható-e). Értékei:

  • True - elérhető
  • False - nem érhető el

Height

Integer

Megadja a DataWindow kontrol magasságát, a PowerBuilderben.

HScrollBar

Boolean

Megadja, hogy a vízszintes gördítősáv megjelenjen-e a kontrolban, amikor az összes adat nem jeleníthető meg egy időben. Értékei:

  • True - megjelenik
  • False - nem jelenik meg

HSplitScroll

Boolean

Megadja, hogy a split bar megjelenjen-e a kontrolban. Értékei:

  • True - megjelenik
  • False - nem jelenik meg

Icon

String

Megadja annak az ICO file-nak a nevét, amely tartalmazza azt DataWindow kontrol minimalizálásakor megjelenő ikont.

Figyelem: Csak Windows és Macintosh.

LiveScroll

Boolean

Gördíti a sorokat a DataWindow kontrolban, amikor a felhasználó mozgatja a gördítősávot.

MaxBox

Boolean

Megadja, hogy a Maximize Box megjelenjen-e a DataWindow kontrol title bar-jában. Értékei:

  • True - megjelenik
  • False - nem jelenik meg

MinBox

Boolean

Megadja, hogy a Minimize Box megjelenjen-e a DataWindow kontrol title bar-jában. Értékei:

  • True - megjelenik
  • False - nem jelenik meg

Object

DWObject

Az objektum direkt manipulálásához használatos egy DataWindow objektum script-jéből. Ezek az objektumok lehetnek például mezők, vagy szöveges objektumok.

Resizable

Boolean

Megadja, hogy a DataWindow kontrol átméretezhető-e. Értékei:

  • True - átméretezhető
  • False - nem méretezhető át

RightToLeft

Boolean

Megadja, hogy a karaktereket jobbról balra haladva kell megjeleníteni. Értékei:

  • True - jobbról balra haladva jeleníti meg
  • False - balról jobbra haladva jeleníti meg

TabOrder

Integer

Megadja, hogy a Tabulátor sorban hányadik az ablakban, vagy a felhasználói objektumban. (A 0 azt jelenti, hogy nem lehet Tabulátorral ráugrani.)

Tag

String

Megadja a Tag értékét amely kijelöli a DataWindow kontrolt.

Title

String

Az a szöveg, ami megjelenik a DataWindow kontrol title bar-jában.

TitleBar

Boolean

Megadja, hogy a title bar megjelenjen-e a DataWindow kontrolban. A felhasználó csak akkor tudja mozgatni a kontrolt, ha van title bar-ja. Értékei:

  • True - megjelenik
  • False - nem jelenik meg

Visible

Boolean

Megadja, hogy a DataWindow kontrol látható-e. Értékei:

  • True - látható
  • False - nem látható

VScrollBar

Boolean

Megadja, hogy a függőleges gördítősáv megjelenjen-e a kontrolban, amikor az összes adat nem jeleníthető meg egy időben. Értékei:

  • True - megjelenik
  • False - nem jelenik meg

Width

Integer

Meghatározza a DataWindow kontrol szélességét, a PowerBuilderben.

X

Integer

Meghatározza az X irányú pozíciót (a távolságot az ablak bal oldalától) , a PowerBuilderben.

Y

Integer

Meghatározza az Y irányú pozíciót (a távolságot az ablak felső oldalától) , a PowerBuilderben.

Függvények:

Függvény név:

Visszatérési érték típusa:

Leírás:

AcceptText

Integer

Felhasználja a DataWindow kontrol edit kontroljának a tartalmát a DataWindow bufferében levő aktuális rekordra.

CanUndo

Boolean

Megadja, hogy az utolsó módosítás visszavonható-e az UNDO függvénnyel. Értékei:

  • True - lehet UNDO
  • False - nem lehet UNDO

CategoryCount

Integer

Visszaadja a megadott grafikonban lévő kategóriák számát a DataWindow kontrolban.

CategoryName

String

Visszaadja annak a kategóriának a nevét, amely a megadott grafikonban van.

ClassName

String

Visszaadja azt a nevet, ami kijelöli a DataWindow kontrolt.

Clear

Integer

Kitörli a kiválasztott szöveget a DataWindow kontrolban lévő edit kontrolból.

RTF esetén kitörli a kiválasztott szöveget a DataWindowból.

ClearValues

Integer

Kitörli az összes értéket a listából kapcsolódva a megadott mezőhöz.

Clipboard

Integer

Átmásolja a megadott ábrát (grafikont) a vágólapra.

Copy

Integer

Átmásolja a kiválasztott szöveget az edit kontrolból és a DataWindow kontrol aktuális rekord és mezőértékéből a vágólapra.

CopyRTF

String

RTF (Rich Text Format) stringként visszaadja a kiválasztott szöveget, képet és input mezőt a DataWindow kontrolból. A bittérképek és az input mezők is a string részét képezik.

Create

Integer

Egy DataWindow objektumot hoz létre a megadott forráskód alapján, és kicseréli a megadott DataWindow kontrolban a DataWindow objektumot az új DataWindow objektuma.

CrosstabDialog

Integer

Megjeleníti a Crosstab Definition dialog boxot, így a felhasználó futás közben is meg tudja változtatni a DataWindow objektum crosstab definícióját.

Cut

Integer

Kivágja a kiválasztott szöveget az edit kontrolból és a DataWindow aktuális rekord és mezőértékéből, és eltárolja a vágólapra.

RTF esetén a kivágja a kiválasztott szöveget a DataWindow kontrolból.

DataCount

Long

Visszaadja a DataWindow kontrolban lévő megadott grafikonban található kiválasztott listában lévő adatok számát.

DBCancel

Integer

Törli a folyamatban lévő adatbázis retrieval hívást.

DBErrorCode

Long

Visszaadja az adatbázisban generált hiba kódját számként.

Ez a függvény hamarosan ki fog kerülni a PowerBuilder későbbi változataiból, ezért használata nem célszerű. A hibakódok az esemény argumentumaként is elérhetők.

DBErrorMessage

String

Egy stringet ad vissza, mely tartalmazza az adatbázisban generált hibaüzenetet.

Ez a függvény hamarosan ki fog kerülni a PowerBuilder későbbi változataiból, ezért használata nem célszerű. A hibaüzenetek az esemény argumentumaként is elérhetők.

DeletedCount

Long

Visszaadja azon rekordok számát, melyeket kitöröltünk a DataWindow kontrolból, de még nem lettek módosítva (UPDATE) a kapcsolódó adatbázis táblájában.

DeleteRow

Integer

Kitörli a megadott rekordot a DataWindow kontrolból.

Describe

String

Visszaadja a kért információt a DataWindow kontrol felépítéséről.

Drag

Integer

A DataWindow kontrol vonszolásának az eleje vagy a vége.

Filter

Integer

Megjeleníti a megadott rekordokat, ezen az aktuális szűrőn keresztül.

FilteredCount

Integer

Visszaadja azon sorok számát, melyek jelenleg nem láthatók az aktuális szűrő miatt.

Find

Long
  1. szintakszis: Megkeresi azt a következő rekordot a DataWindow kontrolban, amelynek az adatai megfelelnek a megadott feltételeknek.
  2. szintakszis: RTF esetén megkeresi a megadott szöveget a kontrolban és kijelöli (highlight), ha megtalálja. Megadható a keresés iránya, és hogy csak egész szavakat keressen, vagy szótöredéket is.

FindCategory

Integer

Visszaadja a megadott grafikonban található megadott kategóriák számát a DataWindow kontrolban.

FindGroupChange

Long

A keresés a megadott rekordtól indul a megadott csoportban lévő első szünetig a DataWindow kontrolban.

FindNext

Integer

Megtalálja a szöveg következő előfordulását a kontrolban és kijelöli (highlight), az előzetesen hívott FIND függvény kritériumait használja.

FindRequired

Integer

Azonosítja azt a szükséges mezőt, melyet a felhasználó nem töltött ki.

FindSeries

Integer

A megadott grafikonon a megadott sorozatok számát adja meg a DataWindow kontrolban.

GetBandAtPointer

String

Visszaadja azt a stringet a banddel együtt, amelyre a pointer mutat, és utána egy tab karaktert (~t) és azon sorok számát, melyek kapcsolódnak a bandhoz.

GetBorderStyle

Border (enu-merated)

Visszaadja a Border adattípusát jelezve a megadott mező keretének a típusát. Értékei:

Box!

Lowered!

NoBorder!

Raised!

ResizeBorder!

ShadowBox!

Underline!

GetChild

Integer

A megadott változóba letárolja a gyerek DataWindow nevét a megadott mezőben.

GetClickedColumn

Integer

Visszaadja a DataWindow kontrolban annak a mezőnek a sorszámát, amelyre a felhasználó kattintott, vagy duplán kattintott.

GetClickedRow

Long

Visszaadja a DataWindow kontrolban annak a rekordnak a sorszámát, melyre a felhasználó kattintott, vagy duplán kattintott.

GetColumn

Integer

Visszaadja az aktuális mező sorszámát a DataWindow kontrolban.

GetColumnName

String

Visszaadja az aktuális mező nevét a DataWindow kontrolban.

GetContextService

Integer

Készít egy hivatkozást a megadott szolgáltatás összefüggés specifikus alkalmazására.

GetData

Double

Visszaadja a megadott grafikonban található megadott sorozatban lévő megadott adat értékét. Lásd még GetDataValue.

GetDataPieExplode

Integer

Reports the percentage that a pie slice is exploded in a pie graph.

GetDataStyle

Integer

Meghatározza egy adat előfordulását a grafikonban. Minden adatnak külön megjelenítési beállításai lehetnek. Különböző szintaktikák vannak, attól függően, hogy mely beállítást akarod ellenőrizni.

GetDataValue

Integer

Visszaadja a megadott grafikonban található megadott sorozatban lévő megadott adat értékét.

GetFormat

String

Visszaadja a megadott mezőben a megjelenítés formáját.

GetItemDate

Date

Visszaadja a megadott rekordban és mezőben található dátumot.

GetItemDateTime

DateTime

Visszaadja a megadott rekordban és mezőben található dátum-időt.

GetItemDecimal

Decimal

Visszaadja a megadott rekordban és mezőben található decimális adatot.

GetItemNumber

Double

Visszaadja a megadott rekordban és mezőben található számot.

GetItemStatus

dwItemStatus (enumerated)

Visszaadja a megadott bufferben található megadott rekordban és mezőben lévő adat státuszát. Értékei:

DataModified!

New!

NewModified!

NotModified!

GetItemString

String

Visszaadja a DataWindow kontrol megadott rekordjában és mezőjében található stringet.

GetItemTime

Time

Visszaadja a DataWindow kontrol megadott rekordjában és mezőjében található időt.

GetMessageText

String

Megadja a crosstab DataWindow objektum által generált üzenet szövegét.

Ez a függvény hamarosan ki fog kerülni a PowerBuilder későbbi változataiból, ezért használata nem célszerű. Az üzenet szövege egy felhasználó által definiált DataWindow esemény argumentumaként is elérhetők, a pbm_ dwnmessagetext segítségével.

GetNextModified

Long

Visszaadja az első olyan rekord sorszámát, amely módosítva volt a megadott bufferben a megadott DataWindow kontrolban a megadott rekord után.

GetObjectAtPointer

String

Visszaad egy stringet a mező vagy egy kontrol nevével, ami a pointer alatt van a DataWindow kontrolban, aztán egy tab karakter (~t) következik, majd egy rekord sorszám.

GetParent

PowerObject

A szülő objektum nevére ad egy hivatkozást.

GetRow

Long

Visszaad egy integert, amelyben az aktuális rekord sorszáma van.

GetSelectedRow

Integer

Visszaadja az első kiválasztott rekord sorszámát a megadott rekord sorszáma után.

GetSeriesStyle

Integer

Megadja egy grafikonban egy csoport előfordulását. Több különböző szintaktikája van.

GetSQLPreview

String

Visszaadja azt az aktuális SQL utasítást, melyet a DataWindow kontrol a DB-nek átad.

Ez a függvény hamarosan ki fog kerülni a PowerBuilder későbbi változataiból, ezért használata nem célszerű. Az SQL utasítás egy esemény argumentumaként is elérhető.

GetSQLSelect

String

Visszaadja az aktuális SELECT utasítást.

GetText

String

Visszaadja az edit kontrol szövegét az aktuális rekordon és mezőn keresztül.

GetTrans

Integer

Visszaadja a DataWindow tranzakció objektumában található értéket.

GetUpdateStatus

Integer

Tartalmazza azon rekordok számát, melyek módosítva lettek egy változón keresztül és a dwBuffer enum adattípusa által azonosított buffer, amelyben a rekord található egy másik változót tartalmaz.

Ez a függvény hamarosan ki fog kerülni a PowerBuilder későbbi változataiból, ezért használata nem célszerű. Az UpdateStatus a DBError és az SQLPreview események argumentumaként is elérhetők a DataWindow kontrolban.

GetValidate

String

Visszaadja a megadott mezőben használt érvényességi szabályt (validation rule).

GetValue

String

Visszaadja a megadott elemet a megadott mezőben található érték listából.

GroupCalc

Integer

Újraszámolja a szüneteket a csoportban.

Hide

Integer

Láthatatlanná teszi a kontrolt.

ImportClipboard

Long

A vágólapról bemásolja az adatot a DataWindow kontrolba.

ImportFile

Long

Egy fileból bemásolja az adatot a DataWindow kontrolba.

ImportString

Long

Egy stringből bemásolja az adatot a DataWindow kontrolba.

InsertDocument

Integer

Beilleszt egy RTF vagy sima szöveg formátumú filet a DataWindow kontrolba. A függvény paramétereként megadható, hogy az új szöveg hogyan legyen beillesztve:

  • Az aktuális pontba beszúrható.
  • Az egész létező szöveg kicserélhető az új szövegre.

Ez a függvény csak azokhoz a DataWindow kontrolokhoz használható, melyek RTF formában jelenítik meg az adatot.

InsertRow

Long

Beszúr egy kezdeti értékekkel feltöltött új sort a megadott sor elé.

IsSelected

Boolean

A visszaadott érték igaz, ha a megadott rekord a DataWindow-ban kiválasztott; a visszaadott érték hamis, ha nem kiválasztott, vagy a rekordszám nagyobb, mint a rekordok száma a DataWindow kontrolban.

LineCount

Integer

Meghatározza a sorok számát egy olyan edit kontrolban, ahol engedélyezett a többsoros mód.

ModifiedCount

Long

Visszaadja azon módosított rekordok számát a DataWindow kontrolban, melyek még nem lettek módosítva a kapcsolódó DB táblájában.

Modify

String

Egy stringben található leírást követve megváltoztatja a DataWindow kontrolt.

Move

Integer

A meghatározott DataWindow kontrolt a meghatározott helyre áthelyezi.

ObjectAtPointer

grObjectType

Visszaadja azon csoportok számát, amin a pointer túlmutat, a grafikonban megjelelő adatok számát és meghatározza az objektum típusát.

OLEActivate

Integer

Aktiválja az OLE-t az OLE objektum számára a DataWindow kontrol megadott rekordjában és mezőjében.

Figyelem: Csak Windows platformokon érhető el az OLE.

Paste

Integer

Beilleszti a vágólap tartalmát az edit kontrolba, a DataWindow kontrol aktuális rekordján és mezőjén keresztül.

PasteRTF

Long

RTF adatot illeszt be egy stringből egy DataWindow kontrolba, amelynek RTF megjelenítési formája van.

PointerX

Integer

A DataWindow kontrol bal oldala és a pointer közötti távolságot adja vissza.

PointerY

Integer

A DataWindow kontrol eleje és a pointer közötti távolságot adja vissza.

Position

Integer
  1. szintakszis: Megadja a beszúrási pont pozícióját az edit kontrolban, a DataWindow kontrol aktuális rekordján és mezőjén keresztül.
  2. szintakszis: Megadja a sor és az oszlop szerinti helyét a beszúrási pontnak, vagy a kijelölt szöveg elejét és a végét az olyan DataWindow kontrolban, mely RTF formátumban van.

PostEvent

Boolean

Hozzáad egy eseményt az üzenetsor végéhez.

Print

Integer

A DataWindow kontrol tartalmát az aktuális printerre küldi. Ennek a függvénynek több különböző szintaktikája van.

PrintCancel

Integer

Törli a nyomtatás job-ot és a spool file-t (ha már létezik), amikor a DataWindow kontrol tartalmát a nyomtatóra küldjük.

Ennek a függvénynek két szintaktikája van. Az első szintakszist akkor kell használni, amikor előzőleg a Print függvény első szintakszisát használtuk.

ReplaceText

Integer

Kicseréli a kijelölt szöveget az edit kontrolban a megadott stringre.

ReselectRow

Integer

Lehetővé teszi, hogy újra végrehajtsuk a SELECT utasítást minden olyan mezőre, mely módosítva lett, és frissíti az összes időpecsétet a mezőkön.

Reset

Integer
  1. szintaktika: Törli az összes adatot a DataWindow kontrolból.
  2. szintaktika: Nem alkalmazható DataWindow objektumhoz.
  3. szintaktika: Töröl minden adatot, kategóriát vagy csoportot egy grafikonról egy DataWindow objektumon belül egy külső adatforrással együtt.

ResetDataColors

Integer

Reseteli az adatpont színét a csoportra megadott színre.

ResetTransObject

Integer

Megállítja a DataWindow kontrolt abban, hogy tovább használja a programozó által definiált tranzakció objektumot (ezek után a DataWindow a saját belső tranzakció objektumát fogja használni).

ResetUpdate

Integer

Reseteli a DataWindow kontrolhoz tartozó módosítási jelzőket.

Resize

Integer

A DataWindow kontrol szélességét és magasságát változtatja.

Retrieve

Long

Rekordokat nyer ki az adatbázisból a DataWindow kontrol számára.

RowCount

Long

A DataWindow kontrolban aktuálisan elérhető rekordok számát adja vissza (minden kinyert rekord (retrieved) mínusz minden törölt rekord (deleted) plusz minden beszúrt rekord (inserted) mínusz minden olyan rekord ami ki lett szűrve (filtered)).

RowsCopy

Integer

Átmásol egy csokor rekordot egyik DataWindow kontrolból egy másikba, vagy egyik bufferből egy másikba egy DataWindow kontrolon belül.

RowsDiscard

Integer

Eldob egy csokor rekordot. A rekordok nem állíthatók vissza újabb Retrieve hívás nélkül.

RowsMove

Integer

Töröl egy csokor rekordot a DataWindow kontrolból, és beszúrja egy másik DataWindow kontrolba, vagy egy másik bufferbe ugyanazon DataWindow kontrolon belül.

SaveAs

Integer
  1. szintaktika: Elmenti a DataWindow kontrol tartalmát a megadott file-ba a megadott formátumban, a mezőnevek feltüntetésével az elején, vagy a nélkül.
  2. Elmenti a DataWindow kontrol megadott grafikonján megjelenített adatokat a megadott file-ba a megadott formátumban.

Scroll

Integer

Összefog az edit kontrolon belül megadott számú sort a megadott irányban.

ScrollNextPage

Long
  1. szintakszis: Egy oldalt görget előre (annyit, ahány rekord egyszerre látszik a DataWindowban), amikor a DataWindow kontrol nincs RTF módban.
  2. szintakszis: A DataWindow kontrol következő oldalára görget, amikor RTF módban van.

ScrollNextRow

Long

A DataWindow kontrolt a következő sorra görgeti. A ScrollNextRow megváltoztatja az aktuális rekordot, de nem változtatja meg az aktuális mezőt.

ScrollPriorPage

Long
  1. szintakszis: Egy oldalt görget hátra (annyit, ahány rekord egyszerre látszik a DataWindowban), amikor a DataWindow kontrol nincs RTF módban.
  2. szintakszis: A DataWindow kontrol előző oldalára görget, amikor RTF módban van.

ScrollPriorRow

Long

A DataWindow kontrolt a előző sorra görgeti. A ScrollPriorRow megváltoztatja az aktuális rekordot, de nem változtatja meg az aktuális mezőt.

ScrollToRow

Integer

A megadott rekordra görgeti a kontrolt. A ScrollToRow megváltoztatja az aktuális rekordot, de nem változtatja meg az aktuális mezőt.

SelectedLength

Integer

Megadja a karakterek és a space-ek teljes számát az edit kontrolban kijelölt szövegben az aktuális rekordon és mezőn keresztül.

SelectedLine

Integer

Megadja az edit kontrolban lévő sor sorszámát az aktuális rekordon és mezőn keresztül.

SelectedStart

Integer

Megadja az edit kontrol kezdeti helyét az aktuális rekordon és mezőn keresztül.

SelectedText

String

Megadja a kiválasztott szöveget (ha van kiválasztva) az edit kontrolból az aktuális rekordon és mezőn keresztül.

SelectRow

Integer

Kijelöli a megadott rekordot vagy törli azon a kijelölést.

SelectText

Integer
  1. szintaktika: Kijelöl szöveget az edit kontrolban. Megadható, hogy hol kezdődjön a kijelölés és hány karaktert foglaljon magába.
  2. szintaktika: Kijelöli a megadott sor elejétől a megadott sor végéig a szöveget, amikor RTF módban van.

SelectTextAll

Integer

A DataWindow kontrol egész tartalmát kijelöli az RTF részt is.

SelectTextLine

Integer

Kijelöli a beszúrási pontot tartalmazó sort.

SelectTextWord

Integer

Kijelöli a beszúrási pontot tartalmazó szót.

SeriesCount

Integer

Visszaadja a megadott grafikonban található csoportok számát.

SeriesName

String

Visszaadja a megadott grafikonban a megadott csoport nevét.

SetActionCode

Integer

Definiálja, hogy mit csináljon a DataWindow kontrol egy adott esemény után.

Ez a függvény hamarosan ki fog kerülni a PowerBuilder későbbi változataiból, ezért használata nem célszerű. A kódot az esemény scriptjében lehet megadni.

SetBorderStyle

Integer

A megadott mező keretét állítja be.

SetColumn

Integer

A megadott mezőt állítja be aktuális mezőnek.

SetDataPieExplode

Integer

Explodes a pie slice in a pie graph.

SetDataStyle

Integer

A megadott grafikonon a megadott csoportban a megadott adatpontra:

  1. Beállítja az adatpont színét.
  2. A vonal stílusát és szélességét állítja be.
  3. A kitöltő mintát, vagy szimbólumot állítja be.

SetDetailHeight

Integer

Beállítja minden egyes rekord magasságát egy megadott sorban.

SetFilter

Integer

A DataWindow kontrol szűrőfeltételét definiálja. Az aktuális szűrés végrehajtható a FILTER függvénnyel.

SetFocus

Integer

A DataWindow kontrolt hozza fókuszba.

SetFormat

Integer

A megadott mező megjelenítési formáját állítja be.

SetItem

Integer

Beállítja a megadott rekord és mező értékét a megadott DataWindow kontrolban.

SetItemStatus

Integer

Beállítja a rekordok állapotát a megadott mezőben a DataWindow kontrolban a megadott bufferben.

SetPosition

Integer
  1. szintaktika: Megadja, hogy a DataWindow kontrol mindig felül legyen-e a front-to-back sorban az ablakon belül.
  2. szintaktika: Átmozgat egy DataWindowt tartalmazó objektumot egy másik csoportba, vagy megváltoztatja az objektumok front-to-back sorrendjét egy csoporton belül.

SetRedraw

Integer

Vezérli az automatikus újrarajzolását a DataWindow kontrolnak bármely tulajdonság, vagy tartalom megváltozása esetén.

SetRow

Integer

A megadott rekord lesz az aktuális rekord a DataWindow kontrolban.

SetRowFocusIndicator

Integer

Beállítja a megadott sorra az indikátort.

SetSeriesStyle

Integer

A DataWindow kontrolban a megadott grafikon megadott csoportjában:

  1. Beállítja a csoport színét.
  2. Beállítja a vonal stílust és vastagságot.
  3. Beállítja a kitöltő mintát vagy szimbólumot a csoportban lévő adatjelzőknek.
  4. Megadja, hogy a csoport egy overlay-e.

SetSort

Integer

Definiálja a rendezési kritériumot a DataWindow kontrol számára. Az aktuális rendezés a SORT függvénnyel hajtható végre.

SetSQLPreview

Integer

Beállítja az aktuális SQL utasítást a DataWindow kontrol számára.

SetSQLSelect

Integer

Beállítja az aktuális SQL SELECT utasítást a DataWindow kontrol számára.

SetTabOrder

Integer

Megváltoztatja a megadott mező tabulátor értékét a DataWindow kontrolban.

SetText

Integer

Kicseréli a szöveget az edit kontrolban az aktuális rekordban és mezőben a DataWindow kontrolban a megadott szövegre.

SetTrans

Integer

Beállítja az értékeket a DataWindow kontrol belső tranzakció objektumában.

SetTransObject

Integer

Beállítja a tranzakció objektumot a DataWindow kontrol számára, és jogot ad a tranzakció irányítására, beleértve a scriptből kiadható COMMIT utasítást is.

SetValidate

Integer

Megváltoztatja az érvényességi szabályt (validation rule) a DataWindow kontrol megadott mezőjére.

SetValue

Integer

A megadott adat értékét állítja be a listában, vagy a DataWindow kontrol megadott mezőjének a kódtábláját.

ShareData

Integer

Megosztja az adatokat az elsődleges és a másodlagos DataWindow kontrol között.

ShareDataOff

Integer

Megszünteti a megosztást a DataWindow kontrolra nézve. Ha ez a kontrol az elsődleges DataWindow kontrol, akkor minden másodlagos DataWindow kontrol lekapcsolódik és a DataWindow objektumaik nem tartalmazzák többé az adatokat.

Show

Integer

Láthatóvá teszi a DataWindow kontrolt.

ShowHeadFoot

Integer

RTF formátum esetén: megjeleníti a header és a footer módosításához szükséges panelt, vagy bezárja azokat, és visszatér a fő szöveg editálásához.

Sort

Integer

Rendezi a DataWindow kontrol rekordjait az aktuális rendezési kritérium szerint.

TextLine

String

Információt jelenít meg az edit kontrolról az aktuális rekordon és mezőn keresztül.

TriggerEvent

Integer

Triggerel egy megadott eseményt a DataWindow kontrolban, és lefuttatja az eseményhez tartozó scriptet.

TypeOf

Object

A kontrol típusát adja vissza.

Undo

Integer

Törli az utolsó módosítást az edit kontrolban az aktuális rekordon és mezőn keresztül.

Update

Integer

Elküldi az adatbázisnak a DataWindow kontrol összes INSERT, DELET és UPDATE utasítását.

 

 

7. MENÜ KÉSZÍTÉSE ÉS A FUTTATHATÓ ALKALMAZÁS GENERÁLÁSA

 

A menü objektumok (menüpontok) rendezett halmazából áll. A menüpontok olyan objektumok a menüben, melyek hozzáférést biztosítanak az alkalmazásban végrehajtható tevékenységekhez. Minden menüpontnak vannak jellemzői és eseményei, melyekre különböző viselkedési módok definiálhatók.

Menüt a Menu Painter-ben definiálhatunk, ami a PowerBar-ból érhető el, és ezt a menü definíciót a PowerBuilder egy PBL állományban tárolja.

Menü megjelenítési formája lehet:

Legördülő menü: egy menüsor valamely eleme alatt megjelenő menü (Pl. Fájl menüpont alatt megjelenő menü bármely alkalmazásban).

Cascading menü: egy legördülő menü valamely eleme mellett megjelenő menü (a menü elem kifejtése, részletezése) – például MS Word-ben Beszúrás ® Kép menüpont mellett megjelenő menü, ami kifejti, hogy honnan lehet képet beszúrni.

Repülő vagy popup menü: ezeket a menüket az alkalmazás a felhasználó kérésére jeleníti meg (a jobb egérgomb lenyomásának hatására). Mivel egy ilyen menü tartalma (a megjelenített menü elemek) attól függ, hogy az alkalmazás mely területén került lenyomásra a jobb egérgomb, ezért ezeket kontextus-függő menüknek is szokták nevezni.

A menü stíluselemei

Ezekkel a billentyűkkel egy menü elem Clicked eseményét lehet előidézni.

Shortcut billentyű: egyetlen billentyű lenyomás vagy billentyű kombináció, ami a menü elem mellett fel van tűntetve. Ennek használatához a menü elem nem lehet látható!

Gyorsító billentyű: a menü elem egy aláhúzott karaktere. A menüsor egy elemére a Clicked esemény az ALT + az aláhúzott karakter kombinációjával idézhető elő. A legördülő és cascaded menüben ez az esemény az aláhúzott karakter lenyomásával bekövetkezik. A gyorsító billentyű használatához a menü elemnek láthatónak kell lennie!

A menüt több összefüggő részre osztó vízszintes vonalak.

Annak jelölésére használjuk, hogy az adott menü elem kiválasztásakor egy dialógus ablak nyílik ki.

Egy adott menü elem mellett a kiválasztó jel (pipa) azt mutatja meg, hogy az adott jellemző bekapcsolt vagy kikapcsolt állapotban van-e.

Az MDI (Multiple Document Interface) alkalmazások eszköztárakat is használhatnak. Az eszköztár olyan ábrát megjelenítő gombokat tartalmaz, amik menü elemekhez vannak társítva (ugyanazt a funkciót szolgálják és ugyanaz a hatásuk).

Menü események

Esemény

Leírás

Clicked

A felhasználó kiválasztja a menüelemet vagy a hozzárendelt gombot az eszköztárról kattintással, gyorsító vagy shortcut billentyű lenyomásával vagy kiválasztja a menüelemet és lenyomja az ENTER billentyűt.

Selected

A felhasználó az egérmutatót a menüelemre mozgatja, vagy a nyíl billentyűkkel rááll a menüelemre.

Menü szkriptek

Szkripteket használunk annak leírására, hogy milyen adatfeldolgozás történjen, amikor egy esemény bekövetkezik. A menü elemekhez írt szkriptek tehát azt a tevékenységsort definiálják, ami a menüelem kiválasztásakor (kattintással vagy kijelöléssel) végrehajtásra kerül. A szkript definíciós ablak a PowerBar-ból érhető el.

Hivatkozás ablakra

A menüt létrehozása után hozzá kell rendelnünk egy ablakhoz (lásd később) ahhoz hogy használni tudjuk. Egyetlen menü több ablakhoz is hozzárendelhető.

A menüelemekhez írott szkriptekben gyakran szükséges hivatkoznunk arra az ablak, amihez a menüt hozzárendeltük. Ezt három féleképpen tehetjük meg:

Közvetlen hivatkozás az ablakra:

Nem elég általános megoldás.

window_reference(hivatkozott ablak neve).control_name.tulajdonság = érték

Hivatkozás a ParentWindow attribútummal:

Az ablak neve helyett mindenhol használható a ParentWindow tulajdonság ugyanúgy, mint egy adott ablakra helyezett vezérlési elemek esetén.

Például annak az ablaknak a bezárása, amihez a menüt hozzárendeltük a következő utasítással végezhető el: Close(ParentWindow)

A ParentWindow tulajdonságot felhasználhatjuk a hozzátársított ablak tulajdonságaira történő hivatkozáshoz, de nem az ablakon elhelyezkedő vezérlési elemekre történő hivatkozáshoz (menü szkriptből).

Például:

w_custdata.cb_insert.Enabled = FALSE //a w_custdata nevű ablak insert gombját letiltja

ParentWindow.cb_insert.Enabled = FALSE //helytelen hivatkozás

Megoldás:

w_custdata lw_myparent //referenciaváltozó deklarálása

lw_myparent = ParentWindow

lw_myparent.cb_insert.Enabled = FALSE

 

Menü létrehozása

  1. MenuPainter megnyitása a PowerBar-ból.

  2. A MenuPainter megnyitásakor a menü kiválasztást lehetővé tevő dialógus ablak nyílik meg először. Itt kiválaszthatunk egy már létező menüt, vagy nyithatunk egy újat is.

  1. Legördülő menü létrehozása

  1. A menü kiválasztó dialógus ablakban kattintsunk a New gombra a MenuPainter munkaterület megnyitásához. Ha már a MenuPainter-ben vagyunk, akkor ugyanezt a File ® New menüponton keresztül tehetjük meg.

  2. Adjuk meg az első elemet a menüsorban.

  3. A TAB billentyű lenyomása után a kurzor arra a beviteli mezőre áll, ahol megadhatjuk az adott menüsor elem alatt megjelenő legördülő menü első elemét.

  4. Gépeljük be a menüpont szövegét (ami megjelenik a menüben). Ekkor a MenuPainter automatikusan a következő nevet rendeli a menüponthoz: m_megadottszöveg.

  1. A Lock Name kétállapotú kapcsológombbal azt jelezhetjük, hogy zárolni kívánjuk a menüelem nevét annak érdekében, hogy a menü elem szövegének megváltoztatásával ne változzon a menüelem neve. Egy következő menüelemre mozgatva a kurzort a MenuPainter automatikusan lezárja a menüelem nevét.

  2. MicroHelp szöveg is megadható (opcionális) – ez a szöveg fog megjelenni az állapotsorban.

  3. Ha a menüelemhez gombot is szeretnénk hozzárendelni az eszköztárban, akkor válasszuk a Pictures fület (csak MDI alkalmazások esetén jelenik meg az eszköztár).

  4. Megadhatók a menü stílusjegyei (Style fül – például kiválasztó jel itt adható meg)

  5. Shortcut billentyű definiálása (opcionális) a Shortcut fülben. Ez a billentyű kombináció a menüben a menüelem szövege mellett, jobb oldalon lesz látható.

További menüelemek és menüsor elemek megadása:

A legördülő menüelemeket egymás után a TAB billentyűvel érhetjük el.

A következő menüsor elem definiálásához kattintsunk az előző menüsor elem jobb oldalára.

Új legördülő menüelem beszúrása (két meglévő közé):

    1. Kattintsunk annak a menüsor elemnek a jobb oldalára, amelyikbe az új menüelemet be szeretnénk szúrni.

    2. Válasszuk ki azt a menüelemet ami után egy újat be szeretnénk szúrni (kattintsunk a jobb oldalára vagy TAB-al álljunk rá).

    3. Kattintsunk az Insert gombra az eszköztárban.

Menü elemeken végrehajtható műveletek, amik elérhetők az eszköztárból a megfelelő gombra kattintással vagy menüből is:

A menü a fejlesztés során megtekinthető (Design ® Preview kiválasztásával vagy a Preview gomb lenyomásával a PainterBar-ban. A MenuPainter ekkor a menüt egy általános üres ablakban mutatja, melynek címsorában a menü neve jelenik meg.

A MenuPainter munkaterülethez való visszatéréshez zárjuk be a Preview ablakot vagy nyomjuk meg ismét a Preview gombot a PainterBar-ban.

 

 

 

 

 

 

 

  1. Cascading menü léterhozása

  1. A cascading menü pozíciójának meghatározása: a MenuPainter munkaterületen mozgassuk a kurzort arra a menüelemre, amelyikhez cascading menüt szeretnénk létrehozni.

  2. Kattintsunk a NextLevel (következő szint) gombra az eszköztárban, vagy válasszuk ki az Edit ® Next Level menüpontot a menüből. Ekkor egy újabb MenuFor mező jelenik meg és ezzel együtt egy üres menübeviteli ablak is, és a beviteli pointer az első üres mezőbe ugrik.

  3. Az új cascading menühöz tartozó elemeket ugyanúgy definiáljuk innentől mint a legördülő menü elemeit.

  4. Az előző szinthez való visszatéréshez kattintsunk a PriorLevel (előző szint) gombra az eszköztárban, vagy válasszuk ki az Edit ® Previous Level menüpontot a menüből.

 

A menü ezt követően elmenthető a File ® Save vagy File ® SaveAs menüpont kiválasztásával. Ekkor a Save Menu dialógus ablak jelenik meg, ahol nevet adhatunk a menünknek és rövid megjegyzést is fűzhetünk hozzá.

Elnevezési konvenció: minden menü m_ előtaggal kezdődik.

 

Menü hozzárendelése ablakhoz

A fentiek szerint létrehozott és elmentett menü önmagában még nem használható. Hozzá kell rendelnünk egy ablakhoz, ahol megjelenik majd és elérhetővé válnak a funkciói. Hozzárendelés után a menü mindig megjelenik az ablak felső részén, amikor az ablakot megnyitjuk.

Ennek lépései a WindowPainter-ben:

  1. Hívjuk meg a WindowPainter-t a PowerBar-ból.

  2. Nyissuk ki azt az ablakot, amelyikhez a menüt hozzá kívánjuk rendelni.

  3. Nyissuk meg a Window dialógus ablakot először kettőt kattintva magára az ablakra, majd kiválasztva az Edit ® Properties menüpontot vagy az ablakban jobb egérgombbal kattintva a megjelenő popup menüből a Properties elemet kiválasztva.

  4. Adjuk meg a megfelelő menü nevét (Menu Name) vagy kattintsunk a Browse gombra, hogy a megjelenő Select Menu dialógus ablakból választhassunk egy menü nevet.

  5. Kattintsunk az OK gombra.

 

 

 

 

Eredmény:

 

Popup menü megjelenítése

A popup menüt ugyanúgy hozzuk létre mint a legördülő menüt a MenuPainter-ben. A különbség csupán a megjelenítésben van. A popup menü nem jelenik meg az ablak felső részén az ablak megnyitásakor, tehát nem kell hozzárendelni a menüt az ablakhoz, mint azt fent tettük. Ehelyett az ablak rbuttondown eseményéhez kell szkriptet írnunk. Attól függően, hogy mit szeretnénk megjeleníteni és milyen pozícióban, különböző szkripteket lehet írni.

A popup menü megjelenítésére a PopMenu() függvény használható a következő formában:

menuname.PopMenu ( xlocation, ylocation )

Vagyis ez a függvény megjeleníti a megadott menüt (amennyiben az hozzá van rendelve az ablakhoz – vagyis az ablak felső részén is megjelenik és popup menüként is) az adott pozícióban. Ahol xlocation a megjelenítendő menü PowerBuilder egységben mért távolsága az ablak bal szélétől és ylocation a megjelenítendő menü PowerBuilder egységben mért távolsága az ablak felső szélétől.

Ha a menü nincs hozzárendelve az ablakhoz (vagyis nem akarjuk, hogy az ablak felső részén megjelenjen), akkor a CREATE utasítást kell használni ahhoz, hogy memóriát allokáljunk a menü számára.

Ahhoz, hogy egy létrehozott menüt popup menüként meg tudjunk jeleníteni, a menünek Visible tulajdonságúnak kell lennie.

 

 

 

Most lássunk néhány példát ilyen szkriptekre.

  1. A következő utasítás megjeleníti a saját menünk (m_sajat) format menüpontját az 50, 50 pozícióban. Itt m_sajat hozzá van rendelve az ablakhoz, tehát az ablak felső részén is megjelenik.

    2. m_sajat.m_format.PopMenu(50,50)

    m_sajat.PopMenu(50,50) //ekkor a teljes menü megjelenik

  2. A következő utasítás megjeleníti a saját menünk (m_sajat) format menüpontját a kurzorpozícióban. Itt m_sajat hozzá van rendelve az ablakhoz, tehát az ablak felső részén is megjelenik.

    3. m_sajat.m_format.PopMenu(PointerX(), PointerY())

    m_sajat.PopMenu(PointerX(), PointerY()) //ekkor a teljes menü megjelenik

  3. A következő utasítás megjeleníti a saját menüt (m_sajat) a kurzorpozícióban. Ebben az esetben az ablakhoz hozzárendelt menü nem az m_sajat, vagyis m_sajat csak popup menüként jelenik meg, ha a jobb egérgomb lenyomásra kerül.

m_sajat NewMenu //új menüt definiálunk

NewMenu = CREATE m_sajat //memóriafoglalás az új menü számára

NewMenu.PopMenu(PointerX(),PointerY()) //új menü meghívása a kurzorpozícióban

 

 

VÉGREHAJTHATÓ ÁLLOMÁNY LÉTREHOZÁSA

A PowerBuilder alkalmazások több különböző komponensből épülnek fel. Ezek legtöbbje PowerBuilder könyvtárakban (PBL-ekben) van tárolva, de néhányuk lehet más fájltípusú (pl. ikonok ICO fájlban, képek BMP fájlban vagy a help fájlok).

Végrehajtható fájlt (.exe) többféle képpen is létre lehet hozni.

  1. Az összes PowerBuilder objektumot, képet, ikont stb. egyetlen végrehajtható állományba összefűzzük.

  2. Az összes PowerBuilder objektumot egyetlen EXE állományba tesszük de a többi fájlt (képek, ikonok stb.) nem fűzzük hozzá a végrehajtható állományhoz.

  3. Néhány PowerBuilder objetumot és az összes egyéb fájlt összefűzzük egyetlen végrehajtható állományba, majd a maradék PowerBuilder objektumokat PowerBuilder dinamikus könyvtárakba (PBD) helyezzük.

  4. Néhány PowerBuilder objetumot egy EXE állományba helyezünk; a maradék PowerBuilder objektumokat PowerBuilder dinamikus könyvtárakba (PBD) helyezzük de a többi fájlt (képek, ikonok stb.) nem fűzzük hozzá sem az EXE, sem pedig a PBD állományokhoz.

A végrehajtható állomány létrehozásához először tekintsük át a lehetséges komponensek fogalmát és létrehozásuk főbb lépéseit.

PBL létrehozása

  1. Nyissuk ki a Library painter-t és kattintsunk a Create Library gombra az eszköztárban.

  2. A megjelenő ablakban adjuk meg az új könyvtár nevét és elérési útvonalát, majd mentsük el.

  3. Megadhatjuk a könyvtár rövid leírását a megjelenő tulajdonság ablakban, majd kattinsunk az OK gombra.

  4. Válasszuk ki azokat az objektumokat, amiket a Library painter-ből át kívánunk helyezni az új PBL-be.

  5. Az eszköztárban nyomjuk meg a Move gombot. Ekkor kinyílik a könyvtár kiválasztó ablak.

  6. Válasszuk ki a célkönyvtárat és nyissuk meg (Open). Ekkor a kiválasztott objektumok átkerülnek az új könyvtárba.

PBD

A PowerBuilder dinamikus könyvtár egy olyan fájl, ami lefordított PowerBuilder objektumokat és opcionálisan képeket, ikonokat stb. tartalmaz. A PBD-t az alkalmazás futásidőben használja. Alkalmazása azért előnyös, mert a rendszer az egyes objektumokat akkor tölti be a memóriába a PBD-ből, amikor futás során szükség van rájuk.

PBD létrehozása

  1. A Library painterből válasszuk ki azt a PBL-t, amelyikből PBD-t akarunk generálni. Ezután válasszuk ki a Library ® Build Runtime Library menüpontot.

  2. A megjelenő ablakból válasszuk ki a megfelelő opciókat és nyomjuk meg az OK gombot.

PBR

A PowerBuilder Resource fájl tulajdonképpen egy ASCII fájl, ami felsorolja az alkalmazás által használt fájlok (erőforrások) neveit. Ilyen erőforrás fájlok lehetnek pl. ICO, BMP, HLP stb. fájlok. EXE vagy PBD állomány létrehozásánál használható fel.

PBR létrehozása

Egy PBR létrehozásához bármely editor használható. Ha a PowerBuilder fájlszerkesztőjével akarunk text fájlt szerkeszteni, ahhoz nyomjuk meg a SHIFT+F6 billentyűkombinációt bárhol a programban.

PBR szerkesztésekor ügyeljünk, hogy

EXE állomány készítése

Végrehajtható állományt a Project Painter-ben hozhatunk létre és a legegyszerűbb esetben nem lesz szükségünk PBD-k illetve PBR létrehozására. Egész egyszerűen minden létrehozott objektumot (ablakot, menüt, ikont stb.) egyetlen PBL-be helyezünk, és ebből készítünk futtatható programot.

Ennek lépései a következők:

  1. A PowerBar-ból indítsuk el a ProjectPainter-t. A megjelenő ablakban nyomjuk meg New gombot egy új projekt létrehozásához.

  2. Ha új projekt létrehozását választottuk, akkor megjelenik egy választó ablak, ahol ki kell választani az új projekt típusát. Ez lehet Application, Proxy Library vagy C++. Alapból válasszuk az Application típust.

  3. Ezután megjelenik egy képernyő, ahol a projekt létrehozásához szükséges információkat lehet megadni.

  4. Először adjuk meg a futtatható állomány nevét és elérési útvonalát. Itt ügyeljünk arra, hogy ennek az állománynak a PowerBuilder gyökérkatalógusában található Shared katalógusban kell létrejönnie! A mi gépeinken ez általában: c:\Program Files\Powersoft\Shared\p.exe (de EXE állomány készítése előtt mindenképpen ellenőrizzük!).

  5. Ezután megadható egy PBR.

  6. A többi opció beállítása után végül a Library lista mutatja az alkalmazáshoz definiált PBL-eket. Ha azt szeretnénk, hogy egy PBL a PBD része legyen, akkor jelöljük be a könyvtár melletti kis négyzetet.

  7. A mezők kitöltése után mentsük el a projektet.

  8. Ezután építsük fel a futtatható állományt a Build gomb segítségével az eszköztárból.