Tartalomjegyzék. Alapfogalmak

Color profile: Disabled Composite Default screen

Tartalomjegyzék 0. fejezet: A szerzõ elõszava ___________________________________________ 7 A makróírás eszközei________________________________________________ 7 Visual Basic for Application________________________________________ 8 Mit programozunk?______________________________________________ 8 Ne adjuk fel!___________________________________________________ 8 A könyv felépítése _________________________________________________ 8 1. rész: Alapfogalmak _____________________________________________ 9 2. rész: Visual Basic for Application __________________________________ 9 3. rész: Az Excel objektumai _______________________________________ 10 4. rész: Kapcsolat a felhasználóval ___________________________________ 11

Alapfogalmak 1. fejezet: A programozásról ___________________________________________ 15 Mi a programozás? ________________________________________________ 15 Programozás a számítógépen_______________________________________ 16 Programozási technikák ____________________________________________ 20 Struktúrált programozás__________________________________________ 21 Moduláris programozás__________________________________________ 22 Az objektumok jellemzõi __________________________________________ 24 Objektumok keletkezése __________________________________________ 25 Összefoglalás ____________________________________________________ 26 2. fejezet: Objektum-hivatkozások ______________________________________ 27 Az objektumok viszonya_____________________________________________ 27 Gyûjtemények _________________________________________________ 28 Hivatkozási útvonal _____________________________________________ 30 Objektumdiagram _________________________________________________ 33 Összefoglalás ____________________________________________________ 34

1

1 E:\0025 Excel 2003 programozÆsa\Ventura\Excel 2003_programozasa_1.vp 2008. februÆr 20. 17:54:39


Tartalomjegyzék

Visual Basic for Application 3. fejezet: Visual Basic Editor__________________________________________ 39 Visual Basic Editor (VBE) __________________________________________ 39 Projekt ablak _________________________________________________ 40 Tulajdonság ablak_______________________________________________ 43 Segédablakok _________________________________________________ 43 Eljárások szerkesztése______________________________________________ 44 Összegezve _____________________________________________________ 46 4. fejezet: Változók meghatározása _____________________________________ 47 A Visual Basic adattípusai ___________________________________________ 47 Numerikus adattípusok___________________________________________ 47 String adattípus _______________________________________________ 48 Egyéb adattípusok______________________________________________ 49 Adattípus meghatározása elnevezéssel __________________________________ 50 Változók meghatározása _____________________________________________ 51 A változók neve ________________________________________________ 51 A deklarálás _____________________________________________________ 52 Implicit deklaráció ______________________________________________ 52 Explicit deklarálás ______________________________________________ 53 Tömbök deklarálása _____________________________________________ 54 Dinamikus tömbök ______________________________________________ 56 Összefoglalva ____________________________________________________ 57 5. fejezet: Speciális változók___________________________________________ 59 Objektumok elnevezése _____________________________________________ 59 Tömbök helyett gyûjtemények ______________________________________ 61 Objektum-elõfordulás létrehozása ___________________________________ 61 A gyûjtemény bõvítése ___________________________________________ 62 Elem eltávolítása _______________________________________________ 63 Érték megváltoztatása ___________________________________________ 64 Felhasználói adattípus használata______________________________________ 64 Összefoglalás ____________________________________________________ 66 6. fejezet: Állandók, felsorolások _______________________________________ 67 Állandók deklarálása _______________________________________________ 67 Felsorolások ____________________________________________________ 68 A felsorolások használata ___________________________________________ 70 Összefoglalás ____________________________________________________ 71 7. fejezet: Hatókör, élettartam _________________________________________ 73 Eljárás szintû változók______________________________________________ 73 Paraméteres eljárás, szubrutin _____________________________________ 74 2



Tartalomjegyzék Opcionális paraméterek __________________________________________ 76 Tömbparaméter deklarálása ________________________________________ 77 Modul szintû változók és állandók_____________________________________ 80 Projekt szintû változók és állandók _____________________________________ 81 A modulok különbsége ___________________________________________ 81 Statikus változók__________________________________________________ 83 Tegyünk rendet! __________________________________________________ 84 8. fejezet: Az adatok használata ________________________________________ 85 Értékadás _______________________________________________________ 85 Operátorok _____________________________________________________ 87 Aritmetikai operátorok ___________________________________________ 87 A mûveletvégzés sorrendje ________________________________________ 88 Szövegkezelõ operátorok _________________________________________ 89 Összehasonlító operátorok _______________________________________ 92 Logikai operátorok _____________________________________________ 93 Összefoglalás ____________________________________________________ 94 9. fejezet: Programvezérlõ utasítások ___________________________________ 95 Elágazások (szelekciók) _____________________________________________ 95 If... Then... Else elágazás _________________________________________ 95 Select Case szelekció ____________________________________________ 99 Ciklusok (iterációk) ______________________________________________ 103 For.... Next iteráció ___________________________________________ 103 For Each... Next gyûjtemény iteráció__________________________________ 108 Do... Loop iteráció ____________________________________________ 110 Összefoglalás ____________________________________________________ 113 10. fejezet: Visual Basic eljárások ______________________________________ 115 Az eljárások _____________________________________________________ 115 Szubrutinok __________________________________________________ 116 Függvények___________________________________________________ 116 11. fejezet: A programok finomítása _____________________________________ 119 A program végrehajtása lépésenként ___________________________________ 119 Töréspont elhelyezése _____________________________________________ 122 Változók figyelése ________________________________________________ 123 Kifejezések figyelése, feltételes megszakítás ____________________________124 Helyi változók megfigyelése__________________________________________ 125 A próba ablak használata ___________________________________________ 127 Összegezve _____________________________________________________ 128

3



Tartalomjegyzék

Az Excel objektumai 13. fejezet: Ismerkedés a tulajdonságokkal ________________________________131 Excel objektumok_________________________________________________ 132 Az Excel mint objektum __________________________________________ 132 Munkafüzet gyûjtemény és objektumok _______________________________136 Munkalapok gyûjtemény és objektumok _______________________________139 Ablakok gyûjtemény, ablak objektum_________________________________142 Cellák és tartományok___________________________________________ 143 Rajz objektumok _______________________________________________ 151 Diagram objektumok ____________________________________________ 153 Összefoglalás ____________________________________________________ 155 14. fejezet: Makró készítése felvétellel ___________________________________ 157 Makró rögzítése__________________________________________________ 157 A felvételi jellemzõk meghatározása__________________________________ 158 Finomítsuk a felvételt ____________________________________________ 161 Adattartomány keretezése ___________________________________________ 163 Jelentés kiegészítése _______________________________________________ 169 Összegezve______________________________________________________ 171 15. fejezet: Vezérlés eseményekkel _______________________________________ 173 Az objektumok eseményei ___________________________________________ 173 Események alkalmazása _____________________________________________ 176 Egyéb események _________________________________________________ 178 Futásidejû hibakezelés ______________________________________________ 181

Kapcsolat a felhasználóval 16. fejezet: Üzenetek, párbeszéd _______________________________________ 187 Egyszerû üzenetek ________________________________________________ 187 Office segéd ____________________________________________________ 190 Párbeszédpanelek használata ________________________________________ 199 Párbeszédpanel létrehozása_______________________________________ 199 További vezérlések _______________________________________________ 205 Beviteli mezõ ________________________________________________ 206 Kombinált lista _______________________________________________ 207 Listapanel vezérlés _____________________________________________ 212 Összefoglalás ___________________________________________________ 216 17. fejezet: Menüsor, eszköztár ________________________________________ 217 Egyedi menü és eszköztár ___________________________________________ 217 Menük, eszköztárak programozása ____________________________________ 222 Menüpontok____________________________________________________ 225 4



Tartalomjegyzék Bõvítmények létrehozása ___________________________________________ 230 A bõvítmény elõkészítése ________________________________________ 230 Elõkészítés futási idõben ___________________________________________ 233 A függvény jellemzõk meghatározása ________________________________234 Billentyû-kombinációk programozása ________________________________235 Összegezve _____________________________________________________ 236 18. fejezet: Kapcsolat más programokkal_________________________________239 Az Office alkalmazások használata_____________________________________ 239 Kapcsolat létrehozása __________________________________________ 240 Objektum létrehozása __________________________________________ 242 Létezõ dokumentum kezelése ______________________________________ 243 Összegezve _____________________________________________________ 252

5





A szerzõ elõszava

z Excel elé ülve sok eszközt kapunk, ami megkönnyíti a mindennapi munkánkat. Mégis elõfordulhat, hogy találkozunk egy-egy olyan feladattal, amire a program nincs felkészítve. Máskor meg nem pontosan úgy történnek a dolgok, ahogy azt mi szeretnénk. Ez nem a program hibája! Nem is hiba. Egyszerûen arról van szó, hogy olyan feladattal találkoztunk, amit elõre nem lehetett látni. Ilyenkor lehetõségünk van belenyúlni a programba és új szolgáltatásokkal kiegészíteni az amúgy is szerteágazó lehetõségeket. Mit kell megismernünk ahhoz, hogy a saját feladatainkat automatizálhassuk? w Melyek a makrókészítés eszközei? w Mikor írjunk makrót? w Mi a makró?

A makróírás eszközei Ahhoz, hogy kibõvíthessük az Excel szolgáltatásait, meg kell ismerkednünk a makrókészítéssel. A makrókészítés két alapvetõ eszköze a Visual Basic for Application programnyelv, a másik, – ennél jóval nagyobb terület – az Excel objektumok ismerete, használata. Szerencsére, sem az objektumok, sem a Visual Basic nyelv nem változott jelentõsen az Office 97-es kiadás óta. Ha valaki megismerte a korábbi változatok lehetõségeit, pontosan ugyanúgy dolgozhat a 2003-asban, mint korábban. Várhatólag még sokáig a Visual Basic 6.0-ással egyezõ környezetben dolgozhatunk. Ezért is nem az a könyv címe, hogy az Excel 2003-as programozása. Elhanyagolhatóan kevés változás csak az objektumoknál történt. A programozás nyelve teljesen megegyezik a korábbi kiadásokban találhatóval.

7



A szerzõ elõszava

Visual Basic for Application Az Office alkalmazások programozását makrózásnak nevezzük. A programozás és a makrózás rokonértelmû szavak. Más szóval ugyanaz a jelentésük itt az Office környezetben. Ennek megfelelõen, aki makrót ír, az programozik. Az Office környezetben a programozás nyelve a Visual Basic for Application. Minden Office alkalmazás mögött ezt a nyelvet találjuk, ahogy ez a nyelve a Visual Basic 6.0 fejlesztõ környezetnek is.

Mit programozunk? Miért kell akkor külön az Excel, a Word vagy a PowerPoint programozásáról beszélnünk. Ennek egyszerû oka van! A Visual Basic „csak” keretet ad a programnak. A Visual Basic ismerete elengedhetetlen, de nem elégséges feltétele a sikeres makró írásnak. Az eszközök, amiket programozunk, az objektumok. Az alkalmazások objektumai alkalmazásonként eltérõek, és nagyon sokfélék. Egész más objektumok találhatók a Word-ben, mint az Excel-ben. Ezt a sokféleséget nem egyszerû megismerni. Például az Excel objektumairól szóló programozási referencia könyv több mint 1000 oldal. Az objektumokat mi magunk is felfedezhetjük. Tehát arra a kérdésre, hogy mit programozunk, a helyes válasz az, hogy az adott alkalmazás – jelen esetben az Excel – objektumait.

Ne adjuk fel! Lesznek olyan olvasók, akik ezt az elõzõ két gondolatot elolvasva leteszik a könyvet. Kár lenne ilyen hamar feladni! A könyv írásakor ugyanis azt feltételeztem, hogy sokan lesznek, akik korábban még nem programoztak, és így indulnak neki ennek az ismeretlen útnak. Elsõsorban nekik szánom ezt a könyvet. Tehát érdemes egy kicsit tovább lapozgatni benne. Akik még soha nem programoztak, azoknak javaslom, hogy fejezetrõl fejezetre haladva próbáljanak ki minden leírt példát, olvassák el az alapfogalmakról szóló részt. Bízom benne, hogy messzebb jutnak, mint gondolnák!

A könyv felépítése A könyvben részekbe foglaltam az elsajátítandó ismereteket. Egy-egy rész több fejezetbõl áll. A részek és a bennük olvasható fejezetek a következõ ismereteket fogják össze:

8



A könyv felépítése

1. rész: Alapfogalmak Ebben a részben a programozás alapetõ szemléleteirõl lesz szó. Megismerkedünk néhány programozási technikával, eljutunk addig, hogy megértsük az objektumok keletkezésének az okát. Megtanuljuk, mit kell tennünk ahhoz, hogy az objektumokat programozhassuk. 1. fejezet: A programozásról w Ennek a fejezetnek a célja, hogy kicsit betekintést nyerjünk a programozási technikákba. Megértsük, hogy miért nem mindegy, hogy milyen módod írunk meg egy programot, rálátásunk legyen az objektumok mûködésére. 2. fejezet: Objektum-hivatkozások w Az Office objektumok programozása során lényeges kérdés, hogy helyesen hivatkozzunk arra az objektumra, amit felhasználunk a programunkban. Tehát amikor programozunk, akkor nem kell kijelölnünk a kiszemelt objektumot, elegendõ, ha hivatkozni tudunk rá, de ezt pontosan kell megtennünk.

2. rész: Visual Basic for Application Ezt a részt teljes egészében arra szántuk, hogy megismerjük a Visual Basic for Application keretrendszert. Érdemes elsajátítani ezeket az ismereteket, mert ezt felhasználhatjuk a többi Office alklamazás programozásakor, ugyanúgy, mint a Visual Basic 6.0 fejlesztõ környezetben. 3. fejezet: Visual Basic Editor w Ez az a felület, ahol programot írhatunk. Ezt az eszközt használjuk makró írás közben. Itt találjuk meg a munkafüzethez tartozó programozási eszközöket, modulokat, ûrlapokat. Ezt a felületet fogjuk megtalálni az összes Office alkalmazás mögött. 4. fejezet: Változók meghatározása w A programozás legfõbb célja az adatfeldolgozás. A feldolgozandó adatokat meg kell õriznünk, a program futása közben. Erre vallók a változók. A változó nem más, mint az operatív memória egy meghatározott területe, amit egy névvel láttunk el. Azt a területet amit megneveztünk változónak nevezzük. 5. fejezet: Speciális változók w Lesznek olyan változók, amelyekket kicsit másként kezelünk, mint az elõzõ fejezetben megismerteket. Ezek kényelmesebbé, rugalmasabbá tehetik a programozást. 6. fejezet Állandók, felsorolások w Vannak olyan adatok, amelyek nem változnak meg a program futása közben. Ezeket állandókban tároljuk. Az ellandók egy speciális típusai a felsorolások. 9



A szerzõ elõszava 7. fejezet: Hatókör, élettartam w A változók ütközhetnek egymással. Ugyanabban a környezetben nem használhatjuk ugyanazt a változónevet. A progamozási egységek határt szabnak a változók érvényességének. Ezt nevezzük hatókörnek. Az élettartam segítségével azt határozhatjuk meg, hogy csak a program futási ideje alatt tárolja a változó a bele írt értéket, vagy még akkor is õrizze meg, amikr a program már lefutott. Erre azért lehet szükségünk, mert az újabb futtatáskor a korábban tárolt értéket szeretnénk tovább felhasználni. 8. fejezet: Az adatok használata w A változók tartalmával különféle mûveleteket végezhetünk. Az egyik legfontosabb mûvelet, amikor elhelyezzük bennük a feldolgozandó értékeket. Ezt értékadásnak nevezzük. A változókba írt értékekkel mûveleteket hajthatunk végre. Ezt operátorok segítségével tesszük. Operátor például az összeadás, kivonás mûveleti jel. 9. fejezet: Programvezérlõ utasítások w Amikor a változók tartalmától függõen eltérõ programrészeket szeretnénk végrehajtani, akkor a programvezérlõ utasításokhoz kell fordulnunk. A programvezérlõ utasításokkal elágazhatunk a környezeti feltételeknek megfelelõen, vagy megismételhetjük a program egy részletét, amíg a feltételek ehhez megfelelõek. 10. fejezet: Visual Basic eljárások w A programjainkat eljárásokba fogjuk megírni. Többféle eljárást használhatunk Visual Basic környezetben. Ezek közül, mi kétfélét tárgyalunk, a Sub és a Function típusokat. 11. fejezet: A program finomítása w Mire ehhez a fejezethez érünk, már ismerjük a változók használatát, a programvezérlõ utasításokat. Lehet, hogy a progamunk nem pont úgy fog mûködni, ahogy elképzeltük. Ilyenkor nagy segítség, ha meg tudjuk állítani az eljárást egy adott helyen, és megvizsgálhatjuk a változók tartalmát, kielemezhetjük a program lépéseit. Ehhez megvannak a megfelelõ eszközök a Visual Basic környezetben.

3. rész: Az Excel objektumai Ez a másik komponenes, amit meg kell ismernünk ahhoz, hogy makró írásba fogjunk. Sajnos a könyv terjedelme nem teszi lehetõvé, hogy az objektumok teljes skáláját megismerjük. Éppen ezért ebben a részben nem is az objektumokra fogunk koncentrálni, hanem sokkal inkább olyan módszereket mutatunk be, amelyek segítségével önállóan közelebb kerülhetünk az objektumok használatához. 13. fejezet: Ismerkedés a tulajdonságokkalw Az objektumok belsõ változóit tulajdonságnak nevezzük. Programozáskor a tulajdonságoknak értéket 10



A könyv felépítése adunk, ettõl az objektum megjelenése, mûködése megváltozik. Ezt jól kihasználhatjuk programkészítéskor. 14. fejezet: Makró készítése felvétellel w Az Office alkalmazások nagy részében úgy is készíthetünk makrót, hogy felvesszük – mint egy magnóval – azokat a lépéseket, amelyeket gyakran kell elvégeznünk. Ezekbõl az Office alkalmazások kis programokat, eljárásokat készítenek. Ez egyrészrõl azért hasznos, mert más írja meg helyettünk a programot, másrészrõl pedig ha megnézzük az eredményt és kielemezzük, akkor sokat tanulhatunk belõle az objektumokról. Röviden szólva a makró rögzítés egy tanító. 15. fejezet: Vezérlés eseményekkel w Az objektumokban vannak olyan eljárások, amelyek automatikusan lefutnak, ha történik valami az objektummal. Ezeket eseményeknek nevezzük. Ilyen esemény lehet Excel környezetben például egy munkafüzet megnyitása, bezárása, vagy egy cella tartalmának a megváltoztatása. Ezekbe az eseményvezérelt eljárásokba beírhatjuk a magunk utasításait, a szükséges program lépéseket. Ezzel az adott esemény bekövetkezésekor az fog történni, amit mi elgondoltunk.

4. rész: Kapcsolat a felhasználóval Itt már a bentfentesek biztonságával használjuk a programozás eszközeit, elindítjuk az általunk írt programokat. Tudunk már olyan eljárásokat, függvényeket készíteni, amit többen is szeretnének használni. Ha csak lehet, úgy kell átadnunk másoknak a programjainkat hogy ugyanúgy használhassák azokat, mintha az Excel részei lennének. Ebben a részben azokat az eszközöket ismerhetjük meg, amelyek lehetõvé teszik az általunk írt programok terjesztését. 16. fejezet: Ûzenetek, párbeszéd w A programokat rendszerint nem magunknak készítjük. Várhatóan, akik használni fogják, nem tudnak programozni. A számukra nekünk kell biztosítanunk a lehetõséget arra, hogy a program futása alatt Õk is befolyásolhassák a program mûködését. Másként fogalmazva a proram futásakor elõfordulhat, hogy tartanunk kell a kapcsolatot a felhasználóval. Ebben a fejezetben azokat az eszközöket, objektumokat ismerhetjük meg, amelyek ezt lehetõvé teszik. 17. fejezet: Menüsor, eszköztár w A felhasználó szereti azokat az eszközöket használni, amelyek már ismerõsek a számára. Mivel minden program használ menüparancsokat, eszköztárakat, a legegyszerûbb ha ezeknek az eszközöknek a segítségével férhet hozzá a felahasználó az általunk írt programokhoz. Egy másik szempont, hogy az eljárásainkból csak a mûködést adjuk át. 11



A szerzõ elõszava Nem lényeges a számára a megvalósítás módja. Ennek megfelelõen annyira rejtsük el a mekróinkat, emnyyire csak lehet. Ehhez jó lehetõség a bõvítmény készítése. Ezt is megismerhetjük ebbõl a fejezetbõl. 18. fejezet: Kapcsolat más programokkal w Az Excelben létrehozott eredményeinket nem egyszer Word táblázatban vagy PowerPoint prezentációban szeretnénk közzé tenni. Megtehetjük, ha megismerkedünk azzal a módszerrel, ahogy át lehet adni az adatot az egyik alkalmazásból a másikba. Természetesen ezt is automatizálhatjuk programírással. Ha megismerjük az Excel programozását, jobban megértjük azt is, hogy mi történik, amikor egy mûveletet végrehajtunk, kijelölünk egy tartományt, vagy éppen egy függvényt használunk. Tehát egy kicsit jobban belelátunk az Excel-be. A programozásban jártas olvasónak kicsit más szemmel kell olvasni ezt a könyvet. Különösen, ha már dolgozott Visual Basic környezetben. Nekik az Excel objektumainak használatát könnyítheti meg ez a könyv. Sok példával, feladattal juthatnak közelebb az Excel-hez.

Sok sikert kívánok a tanuláshoz!

Kovalcsik Géza

12



Alapfogalmak

1.rész



Az 1. rész tartalmából Ebben a részben a programozás alapetõ szemléleteirõl lesz szó. Megismerkedünk néhány programozási technikával, eljutunk adig, hogy megértsük az objektumok keletkezésének az okát. Megtanuljuk, mit kell tennünk ahhoz, hogy az objektumokat prograozhassuk.



1. fejezet

A programozásról

ivel azt tûztük ki célul, hogy programozni fogunk, ismerkedjünk meg néhány programozási alapfogalommal. Röviden gondoljuk át, hogy mit is jelent a programozás, milyen eszközök állnak rendelkezésünkre egy-egy program elkészítésekor. Ismerkedjünk meg az Office szerzõi által alkalmazott programozási technikával. Fedezzük fel, hogyan lehet Windows környezetben programozni. Ebben a fejezetben a következõ kérdésekre keressük a választ. w w w w w w w

Mi a programozás? Mik azok a változók? Mi az algoritmus? Hogyan programoznak ma? Mi az objektum? Melyek az objektumok jellemzõi? Hol találunk objektumokat?

Mi a programozás? Ki az, aki még soha nem programozott? Ha mást nem tettünk, csak elterveztük a szabadidõnk eltöltését, az már programozás. Ha elterveztük, hogy mit, hogyan teszünk, átgondoltuk az események sorrendjét, helyét és figyelembe vettük a körülményeket, akkor programoztunk. Ezek szerint mindenki programozott? Valószínûleg igen! Ezek szerint mindenki programozó? A maga módján igen! Tehát, amikor eltervezünk valamilyen eseménysort, akkor programozunk. Amikor a tervezett tennivalókat végrehajtjuk, akkor futtatjuk a programot. Persze ezt így a hétköznapjainkban sosem fogalmazzuk meg. Most is csak azért tettük, hogy közelebb kerüljünk a számítógépes programozáshoz.

15


A program A program egy adott idõben, adott helyen végrehajtott eseménysor meghatározása, amely figyelembe veszi a körülményeket.


Alapfogalmak

1. rész

Programozás a számítógépen A cél A számítógépes programozás célja az adatfeldolgozás automatizálása.

Változó A változó egy névvel ellátott operatív tár terület, ahol a program futtatásához szükséges adatokat tároljuk.

A számítógépes programozás célja az adatfeldolgozás. Adatokon végzünk mûveleteket és adatokat kapunk eredményül. Az adatokat elérhetõvé kell tenni a program számára. A program lépéseit az adatokhoz kell igazítanunk. A feldolgozás lépéseit algoritmusok írásával tervezzük meg. Változók w Ahhoz, hogy feldolgozhassuk az adatokat, biztosítani kell a program számára, hogy hozzáférjen. Erre a számítógép operatív memóriáját használjuk. A programnak tudnia kell arról, hogy hol találja az adatokat. Ezért elnevezzük azokat a memóriahelyeket, amit adattárolásra használunk. A névvel ellátott memóriarészt változónak nevezzük. A változó tehát nem más, mint az operatív tár egy adott területe, amit névvel látunk el. A változókban különbözõ értékeket tárolhatunk, kiolvashatjuk, megváltoztathatjuk a tartalmukat. A következõ kis példában három változó szerepel. Az elsõ sorban az A-nak nevezett memóriaterületre 15-öt írunk be, a B-nek nevezett területre 18-at. A változókban tárolt értékeket a harmadik lépésban összeadjuk. Az eredményt egy harmadik változóban tároljuk. Összeadáskor nem a tényleges értékeket használjuk fel, hanem a változók nevét, így a változóba rögzített értékekkel végzünk mûveletet.

Értékadás A programban a változó neve mögé egyenlõségjel után írjuk be azt az értéket, amit tárolni szeretnénk.

A = 15 B = 18 C=A+B

Vegyük szemügyre az utolsó parancssort! Ezt semmiképpen nem úgy kell értelmeznünk, mint a matematika órákon tanult egyenleteket. A program végrehajtásakor ugyanis az történik, hogy elõbb az egyenlõségjel jobb oldalára írt mûveletet hajtja végre a program, majd az eredményt beírja az egyenlõségjel bal oldalán álló változóba. Így olyan mûveleteket is leírhatunk, amit matematika órán hibásnak értelmeztünk volna. Ha egy változó értékét eggyel szeretnénk növelni, akkor ezt a következõ módon írjuk le: I=I+1

Algoritmus Az algoritmus azon lépések sorozata, melyek leírják egy feladat megoldását.

Ezt a sort úgy értelmezi a Visual Basic, hogy végrehajtja az egyenlõségjel jobb oldali mûveletét, vagyis az I változóhoz hozzáad egyet, majd az eredményt visszaírja az I változóba. Tehát itt nem azt írtuk le, hogy I egyenlõ egy önmagánál eggyel nagyobb számmal. Algoritmus w Amikor programot írunk, érdemes a feladatot megtervezni. Hasznos egyszerû szavakkal megfogalmazni azt, hogy milyen lépéseket fogunk elvégezni. Ehhez nem kell más, csak papír meg ceruza. Még azt a

16



1. fejezet

A programozásról

programnyelvet sem kell ismernünk, amiben majd megvalósítjuk a programot. Egyelõre csak azt kell tudnunk, hogy milyen adatokkal milyen mûveleteket szeretnénk elvégezni. A tervet persze késõbb le kell írnunk a kiválasztott programnyelven, de akkor már csak a kódolásra, a programnyelvre kell figyelnünk. Az algoritmuskészítés nem valami titokzatos dolog! Bármilyen tevékenységrõl készíthetünk algoritmust. Akár arról, hogy miként készül el az ebéd, vagy arról, hogy mit kell tennünk ahhoz, hogy reggelente bejussunk a munkahelyünkre. Ezek egyébként jó gyakorlatok a programozás megismeréséhez. Ha egy kész programot szeretnénk megérteni, akkor annak az algoritmusát kell felfedeznünk, megfejtenünk. Minden programnak van algoritmusa. Vannak nehezebben és könnyebben érthetõk, de mindegyiknek van valamilyen algoritmusa. A fõ cél az áttekinthetõség, egy egységes szerkezet kialakítása. Ez azért fontos, hogy az esetleg szükséges program bõvítéseket, módosításokat könnyen elvégezhessük. De nézzük meg az algoritmus általános szerkezetét! Ne feledjük, hogy adatfeldolgozásról van szó! Ez fontos! Egy program akkor jó, ha többször is felhasználhatjuk különbözõ adatok feldolgozására. Ilyenkor nem tudjuk elõre, hogy mik lesznek a feldolgozandó értékek. Akkor jutunk hozzá, amikor a felhasználó elindítja a programot. Tehát az elsõ részben be kell kérni a feldolgozandó adatokat a felhasználótól. Ha ezt nem tesszük, nincs mit feldolgozni. Az algoritmus következõ részében ténylegesen elvégezzük a szükséges adatfeldolgozást. Itt állítjuk elõ az eredményt. Végül az eredményrõl tájékoztatjuk a felhasználót. Vagyis kiírjuk az eredményt.

1. ábra: Általános algoritmus szerkezet lépései Ezt a szerkezetet követve, olyan programokat írhatunk, amit több év távlatából is könnyen megérthetünk. Esetleg más programozók is áttekinthetõnek ítélik. Ez elõfeltétele annak, hogy bármikor utólag is megváltoztathassuk a programot. Elõfordul, hogy egyszerûbb adatfeldolgozás során összevonjuk a beviteli részt a feldolgozási résszel, vagy épp a feldolgozást és az eredmény kiírását szerkesztjük egybe. Így egyszerûsíthetjük a programunkat.

17


CD melléklet 01 Fejezet Jacksom modszer.pdf


Alapfogalmak

1. rész

Parancstípusok Mielõtt nekifognánk bármilyen algoritmus elkészítésének, beszéljük meg, hogy milyen utasítástípusokat használunk egy programban. Ezeket tudatosan használva jól áttekinthetõ programokat készíthetünk. Másrészt újabb szakkifejezéseket érthetünk meg. Bármilyen programot megírhatunk háromféle utasítással. A három utasítástípus: a szekvencia, a szelekció és az iteráció. Ha csak ezt a három utasítástípust használjuk, akkor egy nagy lépést tettünk a strukturált programozás felé. Ez persze még nem elegendõ, de mindenképpen szükséges lépés. Az utasítástípusokat a végrehajtás sorrendjének módja alapján csoportosítjuk. Szekvencia Azokat a parancsokat, melyek hatására sem elágazás, sem ismétlés nem következik be, szekvenciának nevezzük.

Szelekció A változók tartalmától függõen a program különbözõ utasításait hajtjuk végre. A feltételek függvényében elágazást végrehajtó parancsok a szelekciók.

Iteráció A program meghatározott sorait ismétlõ utasításokat iterációnak nevezzük.

Szekvencia w Ha olyan utasításokat írunk a programba, amiket sorban egymás után kell végrehajtani, akkor szekvenciális utasításokat használunk. Ezekben a parancsokban végrehajtunk egy-egy programlépést, nem vesszük figyelembe a környezeti változók értékét, csak elvégezzük a szükséges mûveleteket. Olyan ez, mint a közlekedésben a kötelezõ haladási irány. Nem térünk el a kijelölt útvonaltól. Amikor például az elõzõ kis programban adatot írtunk az A és B változóba, akkor szekvenciát alkalmaztunk. Ugyanígy szekvencia volt az is, amikor kiszámítottuk a két szám összegét. Szelekció w A szó jelentése: választás. Szelektálni annyit tesz, mint válogatni, választani. De vajon mit kell választanunk egy programban? Utasításokat! A választás minden esetben függ valamitõl. Ha jó idõ van, valószínûleg a szabadba megyünk, míg rossz idõ esetén olyasmit teszünk, ami zárt helyen végezhetõ. A tevékenység kiválasztása ebben az esetben az idõjárástól függ. Persze a programban nem az idõjárás lesz a meghatározó. Itt a változók pillanatnyi értékétõl függõen más-más parancsokat fogunk végrehajtani. A szelekciót más néven elágazásnak is nevezzük. Elágazunk a program sorai között egy vagy több változó pillanatnyi értékétõl függõen. Iteráció w Más szóval ismétlés. Ez a mi esetünkben azt jelenti, hogy a program utasításainak egy részét többször ugyanúgy kell végrehajtani, csak esetenként más adattal. Az adat tehát minden ismétléskor más, de a mûveletek ugyanazok. Az iteráció megértéséhez ismerkedjünk meg a tömbváltozókkal. Mint azt már megbeszéltük, a programokat azért írjuk, hogy különbözõ adatokkal elvégezhessük ugyanazokat a mûveleteket. Ezt megtehetjük úgy is, hogy minden alkalommal megadjuk a feldolgozni kívánt adatokat. Más esetben, a programban egyszerre szeretnénk feldolgozni több adatot. Gondoljunk csak arra, hogy egy fizetéslistában a fizetések értékével végzünk mûveleteket. Ilyenkor indexelt változókat használunk. Ezt tömbnek nevezzük.

18



1. fejezet

A programozásról

A tömbváltozók a változó nevével és a név mögé írt indexszel azonosíthatóak. Az indexet zárójelek közé írjuk. Nézzünk egy egyszerû példát. A változó neve legyen Fizetes, és tároljunk nyolc különbözõ fizetés értéket. Ez a következõ módon írható le programban: Fizetes(1) = 48930 Fizetes(2) = 87390 Fizetes(3) = 75145 Fizetes(4) = 93457 Fizetes(5) = 69340 Fizetes(6) = 48930 Fizetes(7) = 87390 Fizetes(8) = 75145

A változó neve mind a nyolc esetben ugyanaz. A különbség az indexekben van. Ha ezeket a fizetéseket szeretnénk feldolgozni, mondjuk mindenki kap tíz százalék jutalmat, akkor a jutalom kiszámítását végzõ programrészletet nyolcszor kellene leírnunk. Ez feleslegesen növelné a program méretét, nehezebbé tenné a program olvasását. Ilyen esetben használjuk az iterációs parancsokat. Nézzük a programot egyelõre iteráció nélkül! Ez a következõ: Jutalom(1) = Fizetes(1) * 0.1 Jutalom(2) = Fizetes(2) * 0.1 Jutalom(3) = Fizetes(3) * 0.1 Jutalom(4) = Fizetes(4) * 0.1 Jutalom(5) = Fizetes(5) * 0.1 Jutalom(6) = Fizetes(6) * 0.1 Jutalom(7) = Fizetes(7) * 0.1 Jutalom(8) = Fizetes(8) * 0.1

Ez bizony elég hosszú lett! Ugyanezt ciklusszervezéssel, sokkal kevesebb lépésben is megírhatjuk. Szervezzünk egy ciklust, ami nyolcszor ismétli meg az adott parancsokat. Ez most csak egy egyszerû szorzás, de programozáskor lesznek összetettebb feladatok is. Még ne foglalkozzunk a Visual Basic parancsokkal, egyelõre csak szövegesen írjuk le a ciklust. Ez a következõképpen néz ki: I=0 Ismételd nyolcszor a parancsokat I=I+1 Jutalom(I) = Fizetes(I) * 0,1 Ismétlés vége

Elemezzük a programot!

19


Tömbváltozó Az azonos nevû, de indexszel ellátott változók, a tömbváltozók.


Alapfogalmak

1. rész

I=0

A program elsõ sorában egy úgynevezett ciklusszámlálót használunk. Ebben a sorban azt mondtuk meg, hogy induláskor nulla legyen az értéke. Ismételd nyolcszor a parancsokat

Amint belépünk a ciklusba – ez a második programsor –, a Visual Basic megjegyzi, hogy a ciklus kezdése és vége közötti utasításokat nyolcszor kell megismételnie. I=I+1

Ebben a sorban megnöveljük a ciklusszámláló értékét eggyel. Mivel induláskor nulla volt a tartalma, most egy lesz! Ez a parancssor minden végrehajtáskor eggyel növeli az I változó értékét. Ezt a változót felhasználhatjuk a tömbelemek azonosítására, hiszen minden ismétléskor eggyel megnõ az értéke. Így végiglépkedhetünk a tömb minden elemén. Vagyis az összes adatot feldolgozhatjuk. A ciklus végére tehát, minden Jutalom változóban megtaláljuk az egyes fizetésekhez tartozó értéket. Lám valóban nem kellett hozzá nyolc sor, hogy mind a nyolc fizetést feldolgozzuk. A ciklus kezdete és vége közötti részt ciklustestnek vagy ciklustörzsnek nevezzük. A ciklus annyiszor ismétli meg a ciklustestbe írt parancsokat, ahányszor azt meghatározzuk. A ciklustestben tetszõleges számú parancs lehet. Érdemes felfigyelni a program írásmódjára is! A ciklustestbe írt parancsokat kicsit beljebb kezdtük, mint a többit. Ez nagy segítség a programozónak a program olvasásakor. Messzirõl láthatja, hogy itt valami más szerkezet van.

Programozási technikák Röviden tekintsük át a programozási technikák fejlõdését. A programozáshoz a kezdeti idõkben kevesen értettek! Programokra mégis szükség volt, így aztán többen bele is fogtak a munkába. A kulcsszó ebben az idõszakban az volt, hogy „Csak egyszer mûködjön!”. Úgy is volt! Egyre másra készültek azok a programok, amelyek végre-valahára elindultak. A probléma akkor kezdõdött, amikor valamit változtatni kellett a programon. Ehhez meg kellett érteni a program algoritmusát. Ha nem volt a kezünkben az algoritmus, a programot meg kellett fejteni. Ez néha még a program írójának is nehézséget okozott!

20



1. fejezet

A programozásról

Akkoriban több olyan programnyelv volt, amelyben az utasítássorokat meg kellett számozni (Basic, Focal ...). A parancssorok számozása korlátozta a programok bõvíthetõségét. Amikor ugyanis szerettünk volna újabb sorokat beírni valahova a program belsejébe, ott ehhez nem volt elég szabad sor. Sebaj, kiugrottunk a program végére és megírtuk a hiányzó részletet. Aztán visszaugrottunk, hogy folytassuk a programot. Az ilyen ki-beugrálástól teljesen áttekinthetetlenné vált a program. Természetesen ez a számítógépnek nem okozott semmi nehézséget, de a programozóknak igen. Szinte lehetetlenné tette a programok utólagos módosítását, fejlesztését. Ez tette szükségessé a programozási technológia megújítását.

Struktúrált programozás Rendet kellett tehát tenni a programírás körül. A legfontosabb cél az volt, hogy áttekinthetõ, jól olvasható, bõvíthetõ programok készüljenek. Megfogalmazták azokat a feltételeket, programozási technológiát, amitõl a programok strukturáltak lettek. Egy jól strukturált programot minden hozzáértõ el tudott olvasni, és akár másik programozó által írt programokat is továbbfejleszthettünk, módosíthattunk. Olyan program, amit ne lehetne, ne kellene továbbfejleszteni, nincs! Mindezek szellemében bevezették a strukturált programozást. Elsõként az ugrás parancsot számûzték a programírás eszközei közül. A további programokban csak szekvenciák, szelekciók és iterációk szerepelhettek. Ezzel próbálták megszüntetni a kuszaságot. Ez természetesen csak egy lehetõség volt a strukturált programok írásához. Ha nem tartottuk be a szabályokat továbbra is írhattunk össze-vissza programokat. Eljárások w A másik fontos lépés a programok szétbontása volt. A túl hosszú programok áttekinthetetlenek, még akkor is, ha rendezettek. Olyanok, mint egy körmondat, ami elindul valahova, de olyan hosszú, hogy mire a végére jutunk, nem tudjuk mirõl szólt az eleje. Az áttekinthetõség érdekében kisebb egységekre bontották a programokat. Egy-egy kisebb, jól meghatározható részfeladatot, programrészletet külön eljárásban írtak meg. Az eljárásoknak nevet adtak, és ettõl kezdve az eljárásokat úgy használhatták, mint a program belsõ parancsait. Többnyire mi is ezt a technikát fogjuk használni. Egyelõre még a nyelv ismerete nélkül nézzünk egy példát. Visual Basic nyelvben az eljárásokat a Sub kulcsszóval kezdjük és End Sub parancssorral fejezzük be. A Sub kulcsszó mögé az eljárás nevét írjuk. Ezzel a névvel hivatkozhatunk az eljárásra. Így új parancsot hozhatunk létre. Egy-egy eljárásban egy-egy jól meghatározható, elkülöníthetõ programrészletet írunk meg. A megírt eljárásokat felhasználva összeállítjuk a teljes

21


Eljárás Az eljárás egy jól meghatározott önálló programrész. Az eljárások nevét, mint új utasításokat használhatjuk a program többi részében.


Alapfogalmak

1. rész

programot. Kisebb programokat természetesen nem bontunk részekre. Ezeket egyetlen eljárásban fogunk megírni, és a megírt eljárást futtatjuk. Sub Adatgyujtes() utasítás utasítás … End Sub Sub Feldolgozas() utasítás utasítás … End Sub Sub Eredmeny() utasítas utasítás … End Sub Sub Foprogram() Adatgyujtes Feldolgozas Eredmeny End Sub

Természetesen a fejlõdés itt sem állt meg. A strukturált programozásnak is voltak hiányosságai. Idõvel egyre nagyobb programok készültek. Ezeket már nem tudta egy programozó elkészíteni. Ha több programozó dolgozik ugyanazon a feladaton, szinte elkerülhetetlen, hogy – a hasonló feladat miatt – ne használják ugyanazokat a változóneveket. Így nem lehetett tudni, hogy melyik programrészlet nyúlt hozzá egy változóhoz. Nem lehetett tudni, hogy abban még a mi általunk írt érték van, vagy egy másik eljárás átírta azt. Ezt úgy próbálták elkerülni, hogy a lehetõségekhez képest csak az eljárásokon belül használjanak változókat. Így is elõfordult, hogy az adatok átadása miatt szükség volt úgynevezett publikus – a program minden részébõl elérhetõ – változókra.

Moduláris programozás A programozók újabb utat keresve, eljutottak a modul rendszerû programozáshoz. A modul egy zárt egység, amely egy feladat megoldásához tar-

22



1. fejezet

A programozásról

tozó összes eljárást és változót magában foglal. A modulba írt program teljesen önálló. A modul egy zárt programegység. A modul felelõs a benne történtekért. Ebbõl az elgondolásból alakult ki a moduláris programozás. Egy jól megírt modult többször fel lehet használni. Még azzal sem kell törõdnünk, hogy mi történik benne. A lényeg, hogy rábízhatunk bizonyos feladatokat, amiket a modul önállóan megold. Interfész w Fontos feltétele volt a moduláris programozásnak, hogy a modulok zártak legyenek, a modulba írt eljárásokhoz és változókhoz illetéktelen programok ne férjenek hozzá. Ezt úgy valósítják meg, hogy a modulba írt eljárást és változót a modul magába zárja. Van néhány eljárás, amit a modul magába zár. Ez persze így nem jó. A modulba megírt eljárásokhoz hozzá kell férni kívülrõl is. Ehhez meg kell mondanunk, hogy melyik modul, melyik eljárását szeretnénk használni. Ugyanígy a modulban meghatározott változóknak is adhatunk értéket, ha megmondjuk, melyik modul, melyik változójáról van szó. Amikor azt írjuk le, hogy egy adott modul adott eljárását kívánjuk futtatni, akkor a modul interfészérõl beszélünk. Ugyanígy interfészen keresztül férhetünk hozzá a modulba zárt változókhoz is. Ha például van egy Dolgozo modulunk, amiben meghatároztuk a Fizetes és Jutalom belsõ változókat, akkor ennek a következõ módon adunk értéket: Dolgozo.Fizetes = 97830 Dolgozo.Jutalom = Dolgozo.Fizetes * 0,1

Ha csak annyit írnánk le, hogy: Fizetes = 97830 Jutalom = Fizetes * 0,1

akkor a program nem a Dolgozo modulon belül található Fizetes és Jutalom változóba írná be a megfelelõ értékeket, hanem egy – a Dolgozo modultól független – másik változóba. Persze, ha van egyáltalán ilyen. A modulok eljárásait is hasonló módon használhatjuk. Ha a dolgozó modulban van Belepes és Kilepes eljárás, akkor ezt a következõképpen futtathatjuk le: Dolgozo.Belepes Dolgozo.Kilepes

Természetesen ebben az esetben a Dolgozo modulnak jól kell mûködnie és minden be- vagy kilépéssel kapcsolatos feladatot pontosan el kell végeznie.

23


Interfész Az modulban meghatározott változókra és eljárásokra csak az modul nevével együtt hivatkozhatunk. Ezt a hivatkozást nevezzük modul interfésznek.


Alapfogalmak

1. rész

Ez a technika lehetõvé tette, hogy mások által megírt modulokat építsünk be a programjainkba. Ez hatékonyabbá, áttekinthetõbbé és nem utolsósorban gyorsabbá tette a programozást. Ma sincs ez másként. A programozók modulokból építkeznek. Ezek a modulok az objektumok. Az egyes modulokat többször fel lehetett használni. Ha olyan feladatot kellett elvégezni, amit egy modul meg tudott oldani, nem kellett újra megírni. Minden modulra olyan munkát bíztak, amihez értett az adott modul. Amikor egy Windows operációs rendszer elé leülünk dolgozni, objektumokkal dolgozunk. Objektumok az ablakok, az alkalmazások, a dokumentumok, és minden, de minden, amivel a számítógépen találkozunk. Makró írása során az Excel objektumait fogjuk használni. Ezért fontos, hogy megismerkedjünk az objektum fogalmával.

Az objektumok jellemzõi Az objektumok jellemzõit meg kell ismernünk. Nem fogunk új objektumokat létrehozni, de használni fogjuk az Excel-ben megírt objektumokat. Értéket fogunk adni az objektumokban meghatározott változóknak, használni fogjuk a belsõ változókat.

Képzeljük el az objektumot! Ha szeretnénk elképzelni egy objektumot, leginkább egy olyan tárgynak kell elgondolnunk, amelyik képes elvégezni bizonyos mûveleteket és bizonyos tulajdonságait bármikor megváltoztathatjuk. Milyen érdekes lenne például egy olyan autó, aminek a színét bármikor egyetlen paranccsal megváltoztathatnánk. Más fantasztikus dolgot is elgondolhatunk! Például azt, hogy csak bemondunk egy címet, és az autónk odavisz minket. Persze így teljesen elveszíthetnénk az irányítást a dolgok felett. Biztosítani kell egy-egy olyan pillanatot is, amikor mi mondhatjuk meg azt, hogy mi történjen. Mégis, az objektumok valahogy ilyen varázslatos tárgyakként mûködnek. Ehhez a programozónak létre kell hoznia a megváltoztatható tulajdonságokat, a metódusokat és az objektum eseményeit. Tulajdonságok Az objektumok belsõ változóit tulajdonságoknak nevezzük.

Tulajdonságok w Az objektumok belsõ változóit tulajdonságoknak nevezzük. Mivel ezek belsõ változók, az interfészeken keresztül értéket adhatunk nekik, megváltoztathatjuk az értéküket vagy bármikor kiolvashatjuk õket. Minden objektum felelõs azért, hogy a rábízott értékeket – tulajdonságokat – megõrizze. Így, ha egy Excel munkafüzet egyik munkalapjának megváltoztatjuk a nevét, azt a munkalapnak meg kell õriznie mindaddig, amíg másik értéket, – másik munkalapnevet – nem adunk neki.

24



1. fejezet

A programozásról

Metódusok w Az objektumban megírt eljárások neve a metódus. A metódus tehát egy egyszerû programrészlet – eljárás –, amit az objektum magában hordoz. Hogy egy objektum milyen tulajdonságokkal és milyen metódusokkal bír, azt az objektumot elkészítõ programozó írta meg. A metódus az a cselekedet, amit egy objektum végre tud hajtani. Ilyen például a dokumentum mentése. Események w A kész objektumok elõre meghatározott módon végzik a dolgukat. Pedig milyen hasznos például mentés elõtt ellenõrizni, hogy a felhasználó minden adatot beírt-e a munkafüzet megfelelõ celláiba. Az objektum írói nem tudhatják elõre, hogy mi mit szeretnénk megvizsgálni egy munkafüzet mentése elõtt. Akkor hogyan írhatták volna meg az ellenõrzésre szolgáló programrészletet? Sehogy! Ezt majd nekünk kell megtennünk. Mindehhez meg kell teremteni a lehetõségeket. Az objektumok életében történnek bizonyos dolgok. Egy alkalmazás dokumentumát például kinyomtathatjuk, elmenthetjük, bezárhatjuk, megnyithatjuk. Ezek a dolgok események egy objektum életében. Ha meggondoljuk, pont akkor lenne jó valami módon beleszólni a történtekbe, amikor éppen bekövetkezik egy-egy esemény. Az objektumorientált programozás során találkozunk majd olyan eljárásokkal, amelyek pont akkor futnak le, amikor egy-egy ilyen esemény bekövetkezik. Ezekbe az eseményekbe mi írhatjuk meg a szükséges programrészeket.

Metódusok Az objektumok belsõ eljárásai a metódusok.

Események Az objektumoknak vannak olyan eljárásai, amik akkor futnak le, amikor valami történik az objektummal. Ezek az esemény vezérelt eljárások.

Objektumok keletkezése Objektumosztály w Az objektumosztályban írják le azokat az eljárásokat, amelyeket az objektumnak el kell majd végeznie. Az objektumosztályban határozzák meg a változókat is, amelyek a feldolgozandó adatokat tárolják. Az objektumosztály tartalmazza az összes meghatározást, ami az objektum mûködéséhez szükséges. Az objektumosztály azonban még nem futtatható egység! Ez csak egy minta, a tényleges objektumok létrehozásához.

Objektumosztály

Objektum-elõfordulás w Az objektumosztály tehát önmagában nem használható. A minta alapján létre kell hoznunk azt az objektumot amivel dolgozni fogunk. A minta alapján létrehozott objektumot objektum-elõfordulásnak nevezzük. Ilyet is csináltunk már, csak épp nem tudtuk, hogy mi történik miközben dolgozunk. Amikor például betöltjük valamelyik Office alkalmazást, egy minta alapján létrehozunk egy objektum-elõfordulást, ami például a Word, az Excel vagy akár az Access alkalmazás. Tehát maga az alkamazás sem más, mint egy objektum-elõfordulás. Ugyanígy objektum-elõfordulás

Objektumelõfordulás

25


A programban használható objektum mintákat nevezzük objektumosztálynak.

Az objektumosztály alapján létrehozott, ténylegesen mûködõ objektum az objektum-elõfordulás.


Alapfogalmak

1. rész

egy új munkafüzet, új munkalap vagy egy új Word dokumentum. Egy osztálymodul alapján egyszerre több objektum-elõfordulást is létrehozhatunk. Minden újonnan létrehozott objektumnak saját egyedi neve van. Kezdetben ez az egyetlen különbség az azonos objektumosztályból létrehozott elõfordulások között. Késõbb az objektum használata során azonban sok változáson megy keresztül egy-egy objektum.

Összefoglalás Amikor valamely Office alkalmazásban makrót – így nevezzük az Excelben írt programokat – írunk érdemes struktúráltan megvalósítani. Nagyobb feladatok esetén írjunk több kisebb eljárást és ezeket használjuk a teljes program felépítéséhez. De miért kellett megismerkednünk az objektumorientált programozással? Mi ezt a technológiát nem fogjuk használni, csak felhasználni. A programjainkban viszont objektumok tulajdonságait fogjuk beállítani, objektumok metódusait fogjuk futtatni és bizonyos esetekben beleszólunk az objektum mûködésébe. Ezért lényeges, hogy megértsük az objektumok viselkedését. Amikor egy Office alkalmazás elé leülünk, a legtöbb idõt arra érdemes fordítani, hogy megismerkedjünk az objektumokkal.

26



2. fejezet

Objektum-hivatkozások

mikor felhasználóként egy Office alkalmazással dolgozunk, annak az objektumaival végzünk mûveleteket. Minden esetben azzal az objektummal dolgozunk, amelyik aktív. Az aktív Excel munkalapot nevezzük át, az aktív munkafüzetet mentjük el, nyomtatjuk ki, vagy Word-ben az aktív bekezdés jellemzõit változtatjuk meg. Felhasználóként tehát fontos, hogy aktívvá tegyük azt az objektumot, amelyikkel mûveletet végzünk. Az elõzõ fejezetben olvastunk az objektumokba zárt változókról, eljárásokról. Ezekhez csak az objektum- interfészen keresztül férhetünk hozzá. Az interfész elsõ részében az objektumra kell hivatkozunk. Fontos megjegyezni, hogy programozáskor nem csak az aktív objektummal végezhetünk mûveletet, hanem bármelyikkel, amelyikre hivatkozni tudunk.

Megjegyzés Ez a fejezet még csak elméleti fejtegetéseket tartalmaz, de késõbb a gyakorlatban is kipróbáljuk az itt leírtakat.

w Mit jelent az objektumok hierarchiája? w Mi a gyûjtemény? w Mire használható az objektumdiagram?

Az objektumok viszonya Az Office alkalmazások objektumai kapcsolatban állnak egymással, alá- és fölérendeltségi viszony van közöttük. Az Excel alkalmazás elindítása után megjelenik egy munkafüzet. Ebben munkalapok vannak, amik cellákból állnak. A Word-öt szemlélve hasonló rendszert fedezhetünk fel. A Word alkalmazásban dokumentumok vannak, a dokumentumokban bekezdések. Itt is felfedezhetjük az alá- fölérendeltségi viszonyt. Az objektum rendszer legfelsõ szintjén minden Office programban maga az alkalmazás áll. Ennek minden alkalmazásban azonos a neve: Application. Ha tehát bármely Office alkalmazás programozásakor leírjuk az Application szót, magához az adott alkalmazáshoz szólhatunk. Excel esetén az Excel-hez, Word esetén a Word-höz, a PowerPoint esetén pedig a PowerPoint-hoz. Az alkalmazásokban a következõ eggyel alacsonyabb 27


CD melléklet 02 Fejezet Excel.pdf Formok.pdf Office.pdf


Alapfogalmak

1. rész

szinten találjuk az adott alkalmazás dokumentumát. Szemléltesse az Excel objektumok viszonyát 2. ábra.

2. ábra: Az Excel néhány objektuma Az objektumok rendszere Az objektumok egymásba vannak ágyazva. Ebbõl épül fel az objektumok rendszere.

A 2. ábrán felfedezhetjük, hogy az alkalmazás magában foglalja az összes munkafüzetet, a munkafüzetek pedig a munkalapokat. Ahogy az Excel részei a program menüsorai és eszköztárai is. Ha jól ismerjük az objektumok viszonyát, könnyebben hivatkozhatunk arra az objektumra, melynek a tulajdonságait szeretnénk megváltoztatni, vagy metódusát szeretnénk futtatni.

Gyûjtemények Gyûjtemény A gyûjtemény olyan objektumok összessége, melyekre egyenként és együtt is hivatkozhatunk.

Az 2. ábrán még valamit vegyünk észre! Jelesül azt, hogy vannak olyan objektumok is, amelyekbõl egyszerre többre is hivatkozhatunk. Ilyenek a munkafüzetek, vagy a munkafüzetben található munkalapok. Idõnként egyszerre kell hivatkoznunk az összes megnyitott munkafüzetre, máskor pedig egy kiszemelt munkafüzettel végzünk mûveleteket. Azok az objektumok, melyeknél néha egy elemre, máskor meg egyszerre az összesre lehet hivatkozni, a gyûjtemények. Ez mindjárt felvet egy kérdést. Hogy hivatkozhatunk a gyûjtemények összes elemére egyszerre, vagy az összes közül egyre.

28



2. fejezet


Elsõként egy formai jegyet érdemes megfigyelnünk. A gyûjtemények nevei minden esetben többes számban vannak. Így a munkafüzetek neve Workbooks, a munkalapoké Worksheets a celláké Cells. Minden elnevezés az angol nyelv többes szám ragjával, az s-sel végzõdik. Ha például szeretnénk megtudni, hogy hány munkafüzet van nyitva az Excel-ben, vagy egy adott munkafüzet hány munkalapból áll, akkor a gyûjteményre kell hivatkoznunk. FuzetSzam = Workbooks.Count LapSzam = Worksheets.Count

A fenti két példában megszámoltuk két gyûjtemény elemét. Ezeket egy-egy változóban tároltuk. Az elsõ programsor az Excel-ben megnyitott munkafüzeteket számlálta meg, a második az aktív munkafüzet munkalapjainak számát írta a változóba. Most nézzük meg azt is, hogy a gyûjtemény egyik elemét kiszemelve hogyan kell leírnunk a hivatkozást. Erre a gyûjtemény Item tulajdonságát használjuk. Nézzük meg, hogy az aktív munkafüzet egyik munkalapjára hogyan lehet rámutatni. Erre két módszert is biztosít az Excel. Az egyik esetben a gyûjtemény sorszámát, a másik esetben a nevét használjuk.

A gyûjtemény minden eleme A gyûjtemény minden elemére a gyûjtemény nevével hivatkozhatunk.

Szövegállandó A szövegállandót idézõjelek közé kell írnunk.

Neve = Worksheets.Item(1).Name Neve = Worksheets.Item("Munka1").Name

Mindkét parancs a Neve változóba írja annak a munkalapnak a nevét, amire hivatkoztunk. Mégis mi a különbség a két hivatkozás között? Az elsõ esetben a gyûjteményben elfoglalt helyének megfelelõ sorszámot írtuk be az Item tulajdonság zárójelei közé, míg a másik esetben szövegállandóként – idézõjelek közé – a munkalap nevét. Az elsõ parancs tehát a munkafüzet sorrend szerinti elsõ munkalapjának nevét írja a Neve változóba. Itt a munkalap helye a meghatározó. A második parancssor a Munka1 nevû munkalap nevét tárolja. A második hivatkozás esetén mindegy, hogy a munkafüzetben fizikailag hol található a Munka1 nevû munkalap. Legyen bárhol, a munkafüzetben, elvégezhetjük vele a megfelelõ mûveletet. A gyûjtemény egy elemére tehát hivatkozhatunk a helye vagy a neve szerint. Mivel a gyûjtemények elemeire gyakran kell hivatkoznunk programjainkban, ezért a Visual Basic megenged egy rövidebb írásmódot is. Ilyenkor nem kell beírnunk az Item tulajdonság nevét. Az elõzõ két parancs tehát a következõ írásmóddal is teljesen helytálló: Neve = Worksheets(1).Name Neve = Worksheets("Munka1").Name

29


A gyûjtemény egy eleme A gyûjtemény egy elemére a neve mõgötti zárójelek közé írt számmal, vagy szövegállandóval hivatkozhatunk.


Alapfogalmak

1. rész

Ennél az írásmódnál nem írjuk be az Item tulajdonság nevét, de még a tulajdonságok elválasztására használt pont operátort sem. Egyszerûen a gyûjtemény neve mögötti zárójelek közé beírjuk a gyûjtemény elemének azonosítására szolgáló értéket. Programozáskor rendszerint ezt az írásmódot használják a rövidsége miatt. Programozási szakkönyveket olvasva gyakran találkozhatunk azzal, hogy egy gyûjtemény egy elemére – például egy adott munkalapra – a könyv egyes számban szól. Valahogy így: Állítsuk be a munkalap (Worksheet) Name tulajdonságát egy adott értékre. Ez kissé zavaró lehet, mert azt gondolhatnánk, hogy úgyis hivatkozhatunk, hogy Worksheet. Nem! Ez csak annyit jelent, hogy a gyûjtemény egy elemére mutatunk rá, az elõbb ismertetett módszerek egyikével. Helyesen tehát például így: Worksheets(1).Name = "Számlák"

Hivatkozási útvonal Valóban igaz az, hogy nem kell aktívvá tennünk azt az objektumot, amivel mûveletet szeretnénk végezni. Mégsem közömbös, hogy melyik objektum aktív a hivatkozás pillanatában. Ez valami olyasmi, mint amikor az utcai információs térképen az „Itt áll Ön” felirat egy kiindulási pontot jelöl. A mi esetünkben azt jelenti, hogy nem kell leírnunk azt az útvonalat, amivel eljutunk az éppen aktív objektumhoz.

3. ábra: Az aktív objektumhoz viszonyítva hivatkozhatunk!

30



2. fejezet


Kezdjük azzal a feltételezéssel, hogy egy adott pillanatban a 3. ábrának megfelelõen a Munkafüzet1 munkafüzet Munka3 munkalapja aktív. Vizsgáljuk meg, hogy innen hogyan hivatkozhatunk egy kiszemelt objektumra. Ha az éppen aktív munkalap A1-es cellájába szeretnénk beírni az Excel szót, ezt a következõ utasítássorral tehetjük meg: Range("A1") = "Excel"

A Range objektummal az aktív munkalap tetszõleges cellatartományára hivatkozhatunk. Ennek a zárójelei közé írjuk be a módosítani kívánt tartomány – Excelben használatos – hivatkozását szövegállandóként. A kiadott parancs hatására az éppen aktív munkalap A1-es cellájába kerül az Excel szó. Ha ugyanebbe a munkafüzetbe, egy éppen nem aktív munkalap valamelyik cellájába – például az A1-esbe – szeretnénk írni az Excel szót, akkor meg kell azt is mondanunk, hogy melyik az a munkalap, amire gondolunk. Nem kell aktívvá tennünk, csak rá kell mutatnunk, így: Worksheets("Munka2").Range("A1") = "Excel"

Ez a parancssor annyiban tér el az elõzõtõl, hogy itt meghatároztuk azt a munkalapot is, amelyik A1-es cellájába szeretnénk írni. Nem tettük aktívvá, csak rámutattunk! A munkafüzetet ebben az esetben azért nem kellett meghatároznunk, mert az éppen aktív volt. Ha nem a neve, hanem a sorszáma szerint szeretnénk hivatkozni egy munkalapra, akkor ezt a következõ módon tehetjük meg: Worksheets(2).Range("A1") = "Excel"

Most írjuk be az Excel szót a Munkafüzet2 – éppen nem aktív – munkafüzet második, Munka2 munkalapjának B2-es cellájába. Ehhez már azt is meg kell mondanunk, hogy melyik füzet melyik lapjának melyik tartományába szándékozunk írni. Íme: Workbooks("Munkafüzet2").Worksheets("Munka2").Range("A1") = "Excel"

Ezt is megadhatjuk úgy, hogy a gyûjteményben elfoglalt helye szerint, sorszámmal hivatkozunk. A munkafüzetek a létrehozás vagy megnyitás szerint számozódnak. Tehát: Workbooks(2).Worksheets(2).Range("A1") = "Excel"

Beírhatunk a Munkafüzet2 munkafüzet más munkalapjára is. Ekkor a megfelelõ lapra kell mutatnunk. Ha például a Munka1 munkalap A1-es cellájába írunk, akkor ezt így kell a programba írni:

31



Alapfogalmak

1. rész

Workbooks("Munkafüzet2").Worksheets("Munka1").Range("A1") = "Excel"

Az Application objektumszintre ritkán lépünk vissza, mert ha Excelben programozunk, akkor az Excel objektum mindig aktív.

Application 1 AutoCorrect

RecentFiles

Windows

WorkBooks

Addins

Panes

Names

CommandBars

VBProject

CustomViews

PivotCaches

Mailer

Windows

RoutingSlip

2 DocumentProperties

WorkSheets

Panes 3

Shapes

ChartObjects

LinkFormat

Adjustment

Chart

OLEFormat

CallOutFormat

Scenarios

ShadowFormat

FreeFormBuilder

OLEObjects

Hyperlink

GroupShapes

Outline

FillFormat

LineForrmat

PageSetup

ControlFormat

PictureFormat

QueryTables

ConnectorFormat

ThreeDFormat

Parameters

Comments

TextEffectFormat

HPageBreaks

ShapeNodes

PivotCache

VPageBreaks

TextFrame

PivotFormulas

Hyperlinks

Characters

Names

4. ábra: Az Excel objektumdiagramja, 1. rész

32


PivotTables

PivotFields PivotItems


2. fejezet


Objektumdiagram Mivel az Excel-nek elég sok objektuma van, mindenképpen érdemes megismerkedni azzal a térképpel, ami felfedi az objektumok teljes rendszerét.

1 WorksheetFunction

FileSearch

VBE

ODBCErrors

CommandBars

FileFind

Assistant

Names

2

Styles Charts Axis

3

Borders

AxisTitle

Corners

Gridlines

PageSetup

TickLabels

Shapes

Range

Floor

ChartGroups

UpBars

ChartTitle

Borders

Interior

DownBars

Walls

Areas

Font

SeriesLines

Series Font

DropLines ChartArea

Interior

HiLoLines ChartFillFormat

Name

TickLabels PlotArea

SoundNote

Series DataTabe

Style

ErrorBars Border

Hiperlinks Font Shape Range FormatConditions

Legend LegendEntries LegendKey

Border DataLabels Points DataLabel

Validation

Interior

Comment

LeaderLines

Characters

5. ábra: Az Excel objektumdiagramja, 2. rész

33



Alapfogalmak

1. rész

Ezt szemlélteti a 32-33. oldalakon található 4. és 5. ábra. A rajz téglalapjai olyan objektumokat jelölnek, amelyeket gyûjteményként érhetünk el, az ellipszisek pedig olyanokat, amelyeket egyszerû objektumként. Itt felfedezhetjük azt is, hogy a gyûjtemények neveit többes számban, míg az objektumok neveit egyes számban olvashatjuk. A „közönséges” – nem gyûjteményként kezelt – objektumokra egyszerûen a nevükkel hivatkozhatunk. A nevük után, ponttal elválasztva beírhatjuk a használni kívánt tulajdonság vagy metódus nevét. Ha például az Excel alkalmazás nevét szeretnénk egy változóban tárolni, akkor ezt a következõ módon írhatjuk a programunkba: ProgNeve = Application.Name

Itt nincs Item tulajdonság és nincs zárójel az objektum neve mögött. Az objektumdiagram jól szemlélteti, hogy az objektumok miként viszonyulnak egymáshoz. Láthatjuk azt, amirõl eddig olvastunk, hogy az alkalmazásban (Application) találjuk a munkafüzeteket (Workbooks) és ezen belül a munkalapokat (Worksheets). A gyûjtemények jelölését érdemes egy kicsit jobban is szemügyre venni. A gyûjtemények esetén nem tudhatjuk elõre hogy hány eleme lesz. Ezért jelölik csak a gyûjteményeket. Ezt úgy kell értelmeznünk, hogy egy-egy gyûjteményt jelölõ téglalap tartalmazza a gyûjteményt és annak elemeit is. Amikor azt látjuk, hogy a Workbooks gyûjtemény magában foglalja a Worksheets gyûjtemény elemeit, azt úgy kell értenünk, hogy a Workbooks gyûjteményen belül van a munkalapok gyûjteménye és az összes eleme. Más szóval egy munkafüzetben sok munkalap lehet, és benne van az összes lap összes eleme, ami az adott munkafüzethez tartozik. Ezt a diagram áttekinthetõsége miatt ábrázolják így. Az itt közölt objektumdiagramot jól felhasználhatjuk a programozási feladatok megoldása közben.

Összefoglalás Ha tehát programból szeretnénk mûveletet végezni egy munkafüzettel, munkalappal vagy cellával, akkor hivatkoznunk kell rá. A hivatkozást minden esetben ahhoz a ponthoz viszonyítjuk, amelyik aktív. Az éppen aktív objektum hivatkozását nem kell leírnunk, ezt alapértelmezettnek tekinti a program. Az objektumok rengetegében az objektumdiagram segítségével tájékozódhatunk. Ha szeretnénk megismerni az Excel programozását, az egyik legfontosabb teendõnk, hogy megismerjük az Excel objektumait. Ez fáradtságos és hosszadalmas munka. A legnagyobb segítség a megismerés folyamatá-

34



2. fejezet


ban, a makrófelvétel. A felvételt elemezhetjük és sokat tanulhatunk belõle. Ennek a könyvnek nem célja az, hogy bemutassa az összes objektumot. Az viszont igen, hogy bemutassa, milyen módszerrel érdemes belefogni az ismerkedésbe. Az Excel objektumok leírása több mint ezer oldal lenne. Mi inkább a programozás módszerét és eszközeit ismerhetjük meg ebbõl a könyvbõl.

35





Visual Basic for Application

2. rész



A 2. rész tartalmából A második részben a Visual Basic for Application (VBA) programnyelvvel ismerkedünk meg. Ezt a nyelvet használjuk minden Office alkalmazás programozása, makrózása közben. A nyelv ismerete elengedhetetlen, de nem elégséges feltétele annak, hogy programozhassuk az Excelt.



3. fejezet

Visual Basic Editor

a átkapcsolunk a Visual Basic Editor felületre, akkor a munkafüzeteinket más nézõpontból láthatjuk. Ebben a nézetben a munkafüzet neve Projekt. A VBA programok projektekre épülnek, a projekt tehát egy programozási egység. A projektek modulokat tartalmaznak, ahova megírhatjuk azokat a programokat, amire szükségünk van. A modulokba eljárásokat fogunk írni. Egy-egy eljárásban jól körülhatárolható programrészeket írunk. Az eljárásokat késõbb építõkockaként felhasználva állítjuk össze a teljes programot. Vagyis, egy teljes program több modulból és több eljárásból állhat. Ebben a fejezetben a következõ kérdésekre keressük a választ: w w w w

Hogyan jeleníthetjük meg a Visual Basic Editor-t? Milyen részekbõl áll a Visual Basic Editor? Melyek a programszerkesztés eszközei? Hogyan használhatjuk a modulokat?

Visual Basic Editor (VBE) A VBE egy önálló program, amit minden Office alkalmazásból elindíthatunk. Töltsük be az Excel-t és indítsuk el. Betöltés után hajtsuk végre az Eszközök [Tools] Ø Makró [Macro] Ø Visual Basic Editor utasítást. A kiadott parancs hatására megjelenik egy újabb program. Ez a Visual Basic Editor! Az eredményt a 40. oldalon található 6. ábra mutatja be. A VBE-ben több segédablak is rendelkezésünkre áll. Ezek mindegyike a programozás különbözõ fázisait támogatja. Alapértelmezésben – ha más ablakot nem kapcsolunk be – a Project (projekt) ablak és a Properties (tulajdonság) ablak látható. Kezdjük tehát az ismerkedést ezekkel!

39


VBE A Visual Basic Editor egy önálló program, amit csak az Office alkalmazásokból indíthatunk el. Ez a programozás színtere.



2. rész

6. ábra: A Visual Basic Editor program

Projekt ablak Projekt A projekt egy munkafüzet, a benne található objektumokkal, modulokkal.

Objektum modul Az Excel minden objektumához tartozik egy osztálymodul. Ebben találjuk az eseményvezérelt eljárásokat.

A Projekt ablakban a megnyitott munkafüzeteket látjuk. Felfedezhetjük, hogy egy-egy munkafüzet a programozás oldaláról nézve megfelel egy-egy projektnek. Lehet, hogy több projektet találunk, mint amire számítottunk. Ez annak köszönhetõ, hogy az Excelben a beépülõ makrók munkafüzetben vannak, és ezek is megjelennek a programozási felületen. A programmal szállított beépülõ makrók tartalmát nem jeleníthetjük meg, mivel azokat a Microsoft jelszóval levédte. Az Excel objektumok moduljai w Vajon miért van szükség arra, hogy itt is megtaláljuk a megnyitott mukafüzeteket a bennük található összes munkalapot? A Projekt ablak megmutatja nekünk a projektben található összes modult. Az Excelben minden munkalaphoz és munkafüzethez tartozik egy-egy modul. Ezek osztálymodulok, amelyek az egyes objektumok eseményvezérelt eljárásait tartalmazzák. Errõl késõbb részletesen beszélünk az objektumok eseményeit ismertetõ fejezetben. Ha szeretnénk látni egy modul tartalmát, könnyen megjeleníthetjük, ha kettõs kattintással rákattintunk a projekt ablakban a megfelelõ objektumra. Tegyük is meg! (lásd 41. oldal 7. ábra)

40



3. fejezet

Visual Basic Editor

7. ábra: Egy munkalap objektumhoz tartozó osztálymodul megjelenítése 1. Kattintsunk kettõt a Munkafüzet1-es munkafüzet Munka1-es objektumára! 2. Megjelenik az objektumhoz tartozó osztálymodul. A megnyitott modulba egyenlõre még semmit nem írunk, de ez lesz az egyik hely, ahova majd a programjainkat, más szóval a makróinkat írjuk. A modul egy olyan felület, melyben egyszerû szövegszerkesztési módszerekkel írhatjuk meg eljárásainkat, programjainkat. Egy megnyitott modult a modul ablak jobb felsõ sarkában található x-el tehetünk láthatatlanná. Így nem lezárjuk, csak elrejtjük. Felhasználói modul w A programozás során szükségünk lehet további modulokra, vagy felhasználói ûrlapokra. Ezek is az adott projekt részei lesznek. Ez egyben azt is jelenti, hogy amikor elmentünk egy Excel munkafüzetet, vele együtt mentjük a projektbe beépített modulokat és az azokba megírt eljárásokat. Az általános – vagy más szóval felhasználói – modult nekünk kell majd a projektbe illeszteni. A mûveleteket a következõk szerint hajtsuk végre. A lépések megértését segíti a 42. oldal 8. Ábrája. 1. A Projekt ablakban jelöljük ki annak a projektnek bármely objektumát, amelybe az új modult szeretnénk létrehozni. 2. Hajtsuk végre az Insert Ø Module parancsot! 3. Az új modul megjelenik a projekt ablakban is és az editorban is.

41


Figyelem! Az objektumokhoz tartozó modulok osztálymodulok. Ennek az ismeretnek késõbb még jelentõsége lesz!

Felhasználói modul Ez nem tartozik objektumhoz. Az általános változók és eljárások helye.



2. rész

8. ábra: Új felhasználói modul létrehozása Ugyanezzel a módszerrel hozhatunk létre saját osztálymodult, vagy új felhasználói ûrlapot. Ezek mind a projekt részei lesznek, és az adott munkafüzettel együtt kerülnek mentésre.

Egyedi modulok kezelése Egyedi modulok Azokat a modulokat nevezzük egyedieknek, melyek nem az Excel objektumaihoz kapcsolódnak. Ilyenek a felhasználói modulok, az ûrlapok és az osztálymodulok.

Ha egyedi, felhasználói modulokat szúrtunk be a projektbe, akkor ezeket külön is elmenthetjük, vagy törölhetjük ha feleslegessé váltak. Más esetben külön megírt kész eljárásokat, programrészeket tartalmazó modulokat kapcsolhatunk hozzá a projekthez. Modul elmentése w Természetesen igaz, hogy a munkafüzettel a projekt moduljait is mentjük. Érdemes azonban egy másik mentési módszert is megismerni. Ez a modulok exportálása. Ha a Project ablakban az egér jobb gombjával rákattintunk egy egyedileg beillesztett modulra, akkor a helyi menüben kiválaszthatjuk az Export File utasítást. Ezzel külön, a munkafüzet elmentése nélkül is tárolhatjuk a kiválasztott modult a háttértárolónkon. Erre vonatkozó utasítást találunk a File menüpont alatt is. Az elmentett fájl típusa *.bas lesz. Ezt a modult késõbb más Office alkalmazásokban vagy a Visual Basic 6.0-ban felhasználhatjuk. Tehát az egyik pro-

42



3. fejezet

Visual Basic Editor

jektbõl a másikba juttathatjuk moduljainkat és a bennük lévõ programjainkat. Külsõ modul betöltése w Az importálással külsõ modult tölthetünk be. A projekt ablakban az egér jobb gombjával kattintsunk arra a projektre, amelyikbe szeretnénk betölteni egy modult. A helyi menübõl válasszuk ki az Import File utasítást. Keressük meg a korábban elmentett modult és töltsük be. A modul betöltésével együtt a benne megírt eljárásokat is betöltöttük, így az újabb projektben (dokumentumban) már nem kell megírnunk ezeket az eljárásokat. Modul törlése w Ha valamilyen okból feleslegessé válik egy általunk létrehozott modul, akkor azt törölhetjük a projektbõl. Ismét az egér jobb gombjának vesszük hasznát. A helyi menüben megtaláljuk a Remove XXX utasítást. Egy modul eltávolításakor megjelenik egy kérdés az esetleges mentésre vonatkozóan. Itt eldönthetjük, hogy más projektek részére félretesszük-e a törölni kívánt modult vagy sem. Tehát a Project ablak felelõs a projektben elhelyezett modulok kezeléséért. A projekt ablakban vehetünk fel újabb modulokat, vagy itt jeleníthetjük meg az Excel objektumokhoz rendelt osztálymodulokat. Tulajdonság ablak

Tulajdonság ablak A projekt segédablak alatt találunk egy másik ablakot. Ez a Properties window, magyarul tulajdonság ablak. Amint a projekt ablakban megváltoztatunk egy Excel objektum kijelölését, megváltozik a tulajdonság ablak tartalma is. Itt mindig annak az objektumnak látjuk a tulajdonságait, amelyiket a projekt segédablakban kijelöltük. Ezek azok a tulajdonságok, amelyeket a programozás során is fel fogunk használni. Ennek a segédablaknak az a szerepe, hogy beállíthassuk azokat a tulajdonság értékeket, amiket az egyes általunk írt program futása elõtt szükséges meghatároznunk. Ennek az ablaknak leginkább az egyedi, felhasználói ûrlapok készítésekor fogjuk hasznát venni.

Az Excel és az ûrlapok objektumainak a tulajdonságait megjelenítõ ablak. Itt mindig annak az objektumnak a tulajdonságai jelennek meg, amelyiket kijelöltük.

Segédablakok A VBE sok segédeszközzel támogatja a programozást. Ilyen eszközök a megjeleníthetõ segédablakok. Ezekrõl ejtünk néhány szót a következõ részben.

Próba ablak

Immediate Window (próba ablak) w Ez a segédablak alapértelmezésben nincs bekapcsolva. Ahhoz, hogy megjelenítsük, válasszuk ki a View Ø Immediate

A parancsok azonnali végrehajtását teszi lehetõvé.

43




2. rész

Window utasítást. Az utasítás végrehajtása után a VBE ablak jobb alsó részén megjelenik egy új segédablak. Ebben a segédablakban közvetlenül kiadhatunk Visual Basic utasításokat, amelyeket az ENTER billentyû leütése után azonnal végre is hajt a program. Ezt a lehetõséget a késõbbi ismerkedés során mi is kihasználjuk. Helyi ablak A futó program változóinak és objektumtulajdonságainak pillanatnyi értékét mutatja meg.

Figyelés ablak A kiválasztott változók tartalmát jeleníthetjük meg ebben az ablakban.

Locals Window (helyi ablak) w Egy-egy új eljárás elkészítése során nem biztos, hogy a program pontosan azt a feladatot végzi el, amit terveztünk. Ilyen esetben meg kell keresnünk az elkövetett hibát. Az egyes eljárások futtatása során szükségünk lehet arra, hogy az eljárások változóinak és az objektumok tulajdonságainak értékét megjelenítsük. Ezt szolgálja a Locals window. Alapértelmezés szerint ez sem látható, bekapcsolni a View Ø Locals window utasítással lehet. Watch Window (figyelés ablak) w Ennek az ablaknak a szerepe egy kicsit hasonlít a Locals Window-hoz, azzal a különbséggel, hogy itt meghatározhatjuk, hogy mely változókat és kifejezéseket szeretnénk figyelni. Bekapcsolni a View Ø Watch window utasítással lehet. Bármely segédablakot a jobb felsõ sarokban található x-szel zárhatjuk be. Egyelõre elégedjünk meg ennyivel, de a késõbbiekben részletesen elolvashatjuk a felsorolt segédablakok használatát.

Eljárások szerkesztése Eljárás létrehozása Az egyedi eljárásokat mi hozzuk létre. Az eljárást a Sub és End Sub utasításpár közé írjuk.

Mivel már tudjuk, hogyan hozhatunk létre új modult tovább léphetünk eggyel. Hozzunk létre új eljárást! Figyeljük meg a VBE viselkedését, miközben programot írunk egy modulba. Egy üres munkafüzetbe készítsük el elsõ eljárásunkat – ennek kapcsán megismerkedhetünk néhány szerkesztési lehetõséggel. Ha van már új munkafüzetünk – ez a programozás szempontjából egy új projekt –, akkor térjünk vissza a VBE programba. A programozási könyvek többségében az elsõ feladat a „Helló világ” program. Ettõl most se térjünk el. Az éppen aktív munkalap A1-es cellájába írjuk be ezt a szöveget program segítségével. Az új projektbe – az elõbb megismert módon – hozzunk létre egy modult. Tegyük aktívvá a projektet és hajtsuk végre az Insert Ø Module utasítást. A megjelenõ modulba gépeljük be az elsõ programunkat, de közben figyeljünk mindarra, ami a beírás közben történik. 1. A program beírását kezdjük el azzal, hogy írjuk le a sub ElsoMakro szöveget, mintha csak egy szövegszerkesztõben lennénk.

44



3. fejezet

Visual Basic Editor

2. Üssük le az ENTER billentyût. Ennek hatására a program szövege ilyen lesz: Sub ElsoMakro() End Sub

A Sub utasítás csak a párjával az End Sub paranccsal együtt érvényes. A Sub és End Sub közé kell írnunk a programot. A VBE befejezi az utasításpár beírását. A szövegkurzor beáll a Sub és End Sub utasítások közötti sorra, hiszen ide kell írni az eljárás utasításait.

9. ábra: Az elsõ saját eljárás megírásának lépései 3. A programtest parancsait illik beljebb kezdeni, ezért üssük le a Tab billentyût és gépeljük be a parancs elejét: Range( Figyeljük meg, hogy a VBE felkínálja az objektumba írható argumentumokat egy kis sárga panelben. Ez késõbb nagy segítséget jelent majd.

45




2. rész

4. Majd fejezzük be a parancsot a következõképpen: "a1") = "Helló világ"

10. ábra: Az elsõ eljárás futtatásának eredménye Indítsuk el a megírt programot. Álljunk az eljárás elsõ sorára és adjuk ki a Run Ø Run Macro utasítást. Nézzük meg az eredményt. Kapcsoljunk vissza az Excelbe és nézzük meg az éppen aktív munkalap A1-es celláját (10. ábra). Az eljárás elindításának másik módja, hogy a szövegkurzorral beállunk a Sub utasítássorba és leütjük az F5-ös funkcióbillentyût. Ennek nagy hasznát fogjuk venni a programozás során, mivel az eljárásokat többször is el kell indítanunk, hogy ellenõrizhessük mûködésüket. Minél gyorsabban el tudjuk indítani az ellenõrzendõ eljárást, annál kevesebb idõt fogunk tölteni a programban elkövetett hibák keresésével. A Visual Basic Editor további szolgáltatásait, lehetõségeit majd a gyakorlatok során fogjuk részletesebben megismerni.

Összegezve A munkafüzet programozási oldalról nézve Project . Ez a programozás legnagyobb egysége. A Project-ben találjuk azokat a modulokat, ahova programokat írhatunk. A Projekt-be illesztett modulokat az Excel a munkafüzettel együtt elmenti. Vagyis a modulok a munkafüzet részei. A modulokban eljárások vannak. Ezek egy részét az objektumok tartalmazzák (eseményvezérelt eljárások). A többi eljárást mi hozzuk létre. A Visual Basic Editor segédablakokkal támogatja munkánkat. A Project ablak a modulok kezelését teszi lehetõvé, a tulajdonság ablak az épp kijelölt objektum tulajdonságait jeleníti meg. Az Immedate, a Locals és Watch ablakok a program belövését szolgálják. Ezek használatáról részletesen olvashatunk a program finomítása fejezetben.

46



4. fejezet

Változók meghatározása

ár megbeszéltük, hogy a programozás célja az adatfeldolgozás automatizálása. Ennek tükrében ismerkedjünk meg a változók és az állandók használatával. A feldolgozandó adatokat „kézbe kell vennie” a programnak. Ehhez az adatokat változókban tároljuk. Tudnunk kell, hogy milyen adatokat tárolhatunk a változókban, és hogy milyen lehetõségeink vannak a változók használatára. A fejezet kérdései a következõk: w Milyen adattípusokat kezel a Visual Basic for Application? w Mit jelent a változók deklarálása? w Hogyan határozzuk meg a változókat?

A Visual Basic adattípusai A program futása alatt a változókat és az állandókat az operatív memóriában tároljuk. A különféle adattípusokhoz más-más méretû területet kell lefoglalni. A memóriaterület méretét mi határozzuk meg azzal, hogy megadjuk az adat típusát. A következõkben tekintsük át, hogy melyik adattípus mekkora helyet foglal az operatív tárból és milyen, mekkora értékeket írhatunk bele. A változók típusát három kategóriába sorolhatjuk; a numerikus – számokat tartalmazó –, a string – szöveget tartalmazó – és az egyéb adattípus, amely egyik elõzõbe sem illik bele.

Numerikus adattípusok A numerikus változótípusban számokat tárolunk. Amikor helyet foglalunk egy változónak, szeretnénk minél kisebb memória területet felhasználni erre a célra. Azért arra ügyeljünk, hogy a lefoglalt területen minden lehetséges értéket el tudjunk helyezni. Minél kisebb területet foglalunk le 47


Adattípusok A változók adattípusai segítségével gazdálkodhatunk az operatív memóriában lefoglalt helyek méretével.


Visual Basic for Application Numerikus adatok A numerikus adatokat kettes számrendszerbeli számmá konvertálja a program és így helyezi el a memóriában.

2. rész

a változó számára, annál kisebb értékek férnek ez az adott helyen. Ennek megfelelõen mindig a legkisebb – még elégséges nagyságú – helyet foglaljuk le. Nézzünk meg egy deklaráló – helyfoglaló – utasítást. A deklarációs utasításokat késõbb részletesen megismerhetjük, most csak az adattípus meghatározására figyeljünk. Dim intSzamlalo As Integer

Az utasítás Dim kulcsszava a deklaráló utasítás. Ezt a változó neve követi, amit tetszõlegesen határozhatunk meg, természetesen betartva a Visual Basic elõírásait. Az utasítást valójában a kiemelt As Integer miatt néztük meg. Ez a változótípusok meghatározásának az egyik módja. A felsorolt számtípusok közül a Byte, Integer és a Long egész, a Single, Double lebegõpontos és a Currency típus fixpontos számok tárolására alkalmas. Az egyes változótípusok hosszát és a bennük tárolható értékeket a 1. táblázatban soroljuk fel. 1. táblázat: Numerikus adattípusok Adattípus

Negatív érték

Pozitív érték

Byte

0

255

1 bájt

Integer

- 32 768

+ 32 767

2 bájt

Long

- 2 147 483 648

+ 2 147 483 647

4 bájt

Single

- 3,4*10±38

+ 3,4*10±38

6 jegy

4 bájt

Double

- 1,79*10±308

+ 1,79*10±308

14 jegy

8 bájt

9,22*10±11

9,22*10±11

4 tizedesjegy

8 bájt

Currency

-

+

Pontosság

Helyfoglalás

String adattípus String adattípus A String adattípus a szöveg betûinek a kettes számrendszerbeli kódjait tárolja az operatív memóriában.

A String adattípusú változókban szöveges adatokat – karakterláncokat – tárolhatunk. A karakterlánc jelentése nem más, mint tetszõleges karakterekbõl álló betûsorozat. Az angol string szó láncot jelent, innen a típus elnevezése. A változó hossza a benne tárolt karakterek számától függ. A tárolható karakterek kódjának 0 és 255 közé kell esnie. A String típusú változóban a leghosszabb tárolható szöveg 231 betûbõl állhat. Ha szükséges, elõre meghatározhatjuk a tárolható karakterek számát. Ebben az esetben a változóban tárolt karakterlánc hossza nem lehet több, mint amekkorát elõre meghatároztunk. A rögzített hosszúságú karakter-

48



4. fejezet


lánc hossza maximum 216 karakter lehet. A szöveges változó deklarálása a következõ: Dim strNeve As String

Ez a deklaráció egy elõre nem meghatározott hosszúságú karakterlánc tárolását teszi lehetõvé. Ha szeretnénk meghatározni a tárolható karakterek számát is, akkor ezt a következõképpen tehetjük meg: Dim strNeve As String * 10

Hossz megadása

A változótípus után leírt * 10-zel határoztuk meg, hogy milyen hosszúságú szöveg – karakterlánc – számára foglaltunk helyet az operatív tárban. Ha meghatároztuk a változót, akkor annak késõbb értéket is szeretnénk adni. Nézzük meg azt az utasítást, amelyben a strNeve változónak értéket adunk:

A String adattípus hosszát a változónév mõgé írt szorzással határozzuk meg.

strNeve = "Kovalcsik"

Egyéb adattípusok A programban használt logikai kifejezések eredményét logikai változókban tárolhatjuk. A dátumok feldolgozásához rendelkezésünkre áll egy dátum változótípus. Bizonyos esetben pedig nem tudjuk elõre, hogy milyen típusú lesz az adat, amit a változóban tárolni fogunk. Láttuk, hogy amikor egy objektumra hivatkozunk, a hivatkozás hosszú is lehet. Ezeket a hivatkozásokat rövidíthetjük le, ha változóban tároljuk a hivatkozást. Ahhoz, hogy a felsorolt adatokat tárolhassuk, szükségünk van olyan adattípusokra, melyek ezt lehetõvé teszik. Boolean adattípus w A logikai változók csak kétféle értéket vehetnek fel. Logikai igaz értéket – TRUE –, vagy hamis értéket – FALSE. A Visual Basic két bájt hosszúságú területet foglal le a Boolean adattípusú változók számára. A logikai változótípus meghatározására a következõ utasítást írjuk a programba:

Boolean típus

Dim bolValasz As Boolean

Date típus

Date adattípus w A dátum adattípus valójában egy valós tört szám, ami egy idõpont tárolására használható. A szám egész része a dátumot, – például: 2000. július 28. – határozza meg, a törtrésze pedig az idõpontot – 12 óra 28 perc. Az dátum napja 100. január 1. és 9999. december 31. között lehet. Deklarálása a következõ:

49


Logikai értékek tárolására létrehozott változótípus. Értéke True vagy False lehet.

A dátumot számként tárolja a program. Az egész rész a napot, a tört rész pedig az órát és a percet rögzíti.



2. rész

Dim datFizetesiDatum As Date Variant adattípus Ez az alapértelmezett adattípus. Ebben a véltozótípusban bármilyen értéket tárolhatunk.

Variant adattípus w Elõfordulhat, hogy elõre nem tudjuk, hogy mi lesz az adattípusa a változónak, amit tárolni fogunk. Ilyen esetekben használhatjuk a Variant adattípust. Ez az alapértelmezett adattípus, vagyis ha nem határozzuk meg a változó típusát, az Variant lesz. Tehát ezt az adattípust kétféleképpen is meghatározhatjuk. A következõ két típus-meghatározás eredménye azonos: Dim varVegyes_1 Dim varVegyes_2 As Variant

Adattípus meghatározása elnevezéssel A változók adattípusát meghatározhatjuk úgy is, hogy a változónevet egy típus-meghatározó karakterrel zárjuk be. A típus-meghatározó karakterek ugyanúgy meghatározzák a változó típusát, mint az As kulcsszó mögé írt típusnév. Ennek megfelelõen az As kulcsszót és típusnevet nem használhatjuk egy olyan változó esetén, amelyet típus-meghatározó karakterrel fejeztünk be. Egy szöveg típusú változót például így is meghatározhatunk: Dim Szoveg$

A változónév mögötti $-jel a típus-meghatározó karakter. Ez egyenértékû az As String típus-meghatározással. A Visual Basic nyelvben a következõ típus-meghatározó karaktereket használhatjuk: A 2. táblázat harmadik oszlopában felsorolt deklarálások soronként azonos adattípust határoznak meg. A többi változótípusnak nincs típus meghatározó karaktere. 2. táblázat: A típus-meghatározó karakterek Típus

Karakter

Deklaráció

String

$

Dim Szoveg$ vagy Dim Szoveg As String

Integer

%

Dim EgeszSzam% vagy Dim EgeszSzam As Integer

Long

&

Dim Hosszu& vagy Dim Hosszu As Long

Single

!

Dim Egyszeres! vagy Dim Egyszeres As Single

Double

#

Dim Dupla# vagy Dim Dupla As Double

Currency

@

Dim Penz@ vagy Dim Penz As Currency

50



4. fejezet


Mivel egyelõre az adattípusokkal foglalkozunk, elégedjünk meg ennyivel. Késõbb, amikor már megismerkedtünk a deklarálással is, ki fogjuk próbálni a felhasználói típus programozását.

Változók meghatározása Amikor változót deklarálunk, akkor nem teszünk mást, mint helyet foglalunk az operatív tárban. Mivel a Visual Basic egy magas szintû programnyelv, nem kell tudnunk, hogy fizikailag hol is lesz az a hely, amit lefoglaltunk. A lefoglalt helyre a változó nevével hivatkozunk.

A változók neve A változók nevét úgy határozzuk meg, hogy jelezze azt, mire használjuk. Szerencsés, ha az is kiderül a névbõl, hogy milyen adattípusú. A változók nevének meghatározásakor be kell tartanunk néhány elõírást. Ezek a következõk: w A változó neve nem lehet hosszabb mint 255 karakter. w Az elsõ karakternek betûnek kell lennie. w A változó neve nem tartalmazhat pontot, szóközt; és a !, @, #, &, % és $ karakterek csak a változónév végén szereplehetnek (ha így határozzuk meg a típust). w A változók neve nem lehet a Visual Basic nyelvben használt egyik kulcsszó sem. Ha a változó nevében szeretnénk megjelölni, hogy milyen a változó adattípusa, akkor érdemes a változónév elsõ három betûjét erre felhasználni. Ezt az elsõ három karaktert prefixnek nevezzük. Ezt az elnevezési módot az angol nyelvû programozási szakkönyvek magyar módszerként említik. Természetesen nem ezért érdemes használni. A prefixszel ellátott változó használata sok esetben egyszerûbbé teszi a kész program olvasását. Egy szöveg típusú változót például érdemes a következõképpen meghatározni: Dim strSzoveg As String

Ha a program olvasása során bármikor találkozunk ezzel a változóval, tudni fogjuk róla, hogy szöveg tárolására alkalmas. Ha a változó neve több szóból állna, akkor – mivel a névben nem lehet szóköz –, vagy kezdjünk minden szót nagybetûvel, vagy helyettesítsük a szóközt aláhúzás karakterrel. Például:

51


Az elnevezés szabályai A változók elnevezésekor figyelembe kell venni a felsorolásban meghatározott korlátozásokat.

Prefix Érdemes, de nem kötelezõ az elõtag karaktereket használni, hogy a program szövegébõl kiderüljön a változó típusa.



2. rész

Dim strDolgozoVezetekNeve As String

vagy aláhúzással Dim strDolgozo_vezetek_neve As String

Ezek persze csak ajánlások, de valóban támogatják a program olvashatóságát.

A deklarálás A változók deklarálásának – helyfoglalásának – két módja is van. Az egyik esetben a program valamelyik részében értéket adunk egy változónak. Vagyis nem határozzuk meg elõre a helyét és típusát, hanem egyszerûen csak használatba vesszük. Ezt implicit deklarációnak nevezzük. A másik esetben a program vagy eljárás elején elõre lefoglaljuk a változók helyét és típusát. Ezt explicit deklarációnak hívjuk.

Implicit deklaráció

Implicit deklaráció A deklarálás akkor történik, amikor használatba vesszük a változót. Gyors módszer, de sok a hiba lehetõsége.

Nézzük meg elõbb ezt a módszert, vonjuk le belõle a szükséges tanulságot, majd ismerkedjünk meg az explicit deklarálással. Egyszerûnek tûnik, hogy egyszer csak elkezdünk használni egy változót, amikor arra szükség van. Ilyenkor a program futás közben foglal helyet a változónak. Egyszerû, de nem biztonságos! Nézzük meg, íme: Sub ErtekBekerese() Szám = 18 ... ... Szam = Szam + 1 ‘???????????? End Sub

Ebben a kis programban az implicit módszerrel deklaráltuk a változókat. A deklarálás az értékadáskor automatikusan megtörtént. Késõbb a program egy másik pontján – ez rendszerint messze van attól a helytõl, ahol a változót deklaráltuk – szeretnénk megnövelni a Szám nevû változónak az értékét. Igenám, csakhogy elírtuk a változó nevét. Nem nagyon, csak éppen az ékezet hiányzik az „a” betûrõl. Mi fog történni, amikor a program végrehajtja az utasítást? Implicit módon deklarál egy másik változót, aminek a neve Szam lesz, és rögtön meg is növeli annak értékét

52



4. fejezet


eggyel. Ezeket a hibákat sokáig lehet keresgélni. Mennyivel egyszerûbb lenne a dolgunk, ha a program szólna minden esetben, amikor egy elõre nem deklarált változót szeretnénk használni. Ehhez rá kell szoknunk az explicit deklarálásra, mert így utasíthatjuk a programot a nem deklarált változók kiszûrésére. Programhibák típusai w A programozás során elkövethetõ hibákat két csoportba sorolhatjuk. Az egyik esetben a hiba abból származik, hogy egy parancsot, vagy kulcsszót elírtunk. Ezt gyorsan kijavíthatjuk, mert a Visual Basic ezt felfedezi, és amint kilépünk a sorból, pirosra színezi a hibás sort. Az ilyen hibákat szintaktikai hibának nevezzük. A másik hiba, amit a programozás logikájában ejtünk, a szemantikai hiba. Ezt már nehezebb felismerni, és ennek megkeresésében a Visual Basic sem tud segíteni. Ezeknek a hibáknak a kiküszöbölése hosszas keresgélést igényel. A logikai hibák elkövetésének egyik leggyakoribb oka az implicit deklarációból adódik.

Szemantikai hiba A program algoritmusában elkövetett hiba, amit elég nehéz megtalálni. A hiba oka sok esetben egy elírt változónév.

Explicit deklarálás Önmagában az explicit deklarálás még nem megoldás. Ki kell adnunk egy modul szintû parancsot, hogy a VB figyelje a nem deklarált változókat. Ehhez az eljárásokon kívül valahol a modul elejére be kell írnunk az Option Explicit parancsot. Amelyik modulban szerepel ez a sor, ott a program figyelmeztet, ha nem deklarált változót használunk. Ha tehát minden modulban kérjük a változók figyelését, akkor minden modul elején szerepelnie kell az Option Explicit parancsnak. Ha ez a parancs szerepel a modulban, akkor a Visual Basic, a program lefordítása közben, ellenõrzi a változók nevét. Ha olyan változót talál, amelyet korábban nem deklaráltunk, akkor leáll, hibát jelez és megjelöli a hibás sort. Beállíthatjuk úgyis a Visual Basic-et, hogy minden újonnan létrehozott modulba automatikusan beírja az Option Explicit utasítást. Ehhez kapcsoljunk át a VBE-be, és hajtsuk végre a következõ utasítást: Tools Ø Option. Megjelenik a beállító párbeszédpanel. Itt lapozzunk az Editor lapra, és kapcsoljuk be a Require Variable Declaration kapcsolót. Ettõl kezdve a bekapcsolás után létrehozott minden új modulban szerepelni fog az Option Explicit utasítás. Az elõbbi példánk explicit deklarálással a következõ lesz: Option Explicit Sub ErtekBekerese() Dim intSzam As Integer intSzam = 18

53


Explicit deklarálas A programban elõre rögzítjük, hogy milyen változókat fogunk használni. Ha olyan változót használunk, amit elõre nem deklaráltunk, a Visual Basic figyelmeztet a hibára.



2. rész

... ... intSzam = intSzam + 1 End Sub

Töltsük be az Excelt, és hozzunk létre a VBE-ben egy új felhasználói modult. Ebbe írjuk be a fenti kis programot. Próbáljunk meg egy nem deklarált változót használni és figyeljük meg a hibajelzést (11. ábra). Kattintsunk az üzenet OK gombjára. A programunk nem megy tovább.

11. ábra: A hibás deklarálás eredménye a program indítása után Megállt, megjelölve a hibás eljárást. Állítsuk le az eljárásunkat. Ezt a Run Ø Reset parancs végrehajtásával tehetjük meg. Javítsuk ki a hibát, és indítsuk újra a programot. Nem körülményes ez egy kicsit? De igen! Ha az explicit deklarálást használjuk, az elírt változónevek miatt nem kell hosszasan keresgélnünk a program hibáit.

Tömbök deklarálása Tömb deklarálás Tömb deklaráláskor olyan változót határozunk meg, amelyben több értéket is tárolhatunk.

Egy tömbben több értéket tárolhatunk ugyanazzal az elnevezéssel. Ezzel már találkozhattunk az alapismeretek olvasásakor. Az iskolában is használtunk már tömb változókat, amikor egy változó mellé indexet írtunk (például X1, X2, X3 ...). A tömb ugyanezt a célt szolgája a programban. Persze az index lehet összetett is – vagy másként: több dimenziós – (például:

54



4. fejezet


X1,1, X1,2, X2,1, X2,2 ....). A tömb deklarálására a következõ utasítást használjuk: Dim intSzam(4) As Integer Dim strNevek(10) As String Dim intSzam_2(4,4) As Integer

A változó neve mögé zárójelek közé beírjuk, hogy mekkora legyen a tömb. Ha vesszõvel elválasztva több számot is egymás mellé írunk, akkor több dimenziós tömböt deklaráltunk. Ilyen a példa harmadik sora! Hány eleme lesz a tömbnek? Ez attól függ, hogy honnan kezdõdik a tömbelemek számozása. Ha nullától kezdõdik, – ez az alapértelmezett–, akkor mindig eggyel több, mint amekkora számot a zárójelek közé írtunk, mert az elemek között a nullás is szerepelni fog. Ha szükséges, akkor változtathatunk ezen. Hasonlóan az Option Explicit utasításhoz, a modulba, az eljárásokon kívülre írjuk be az Option Base 1 utasítást. Ettõl kezdve a tömb legkisebb eleme nem a nulladik elem lesz, hanem az egyes. Ha nem írjuk be az Option Base 1 utasítást, vagy Option Base 0-t írunk be, akkor a modulban a tömbök elsõ eleme a nulladik lesz. A tömb elemeinek úgy adhatunk értéket, hogy leírjuk a változó nevét és a mögötte álló zárójelek közé beírjuk a tömbelem számát. Íme egy példa:

A kezdõ elem száma A tömbváltozó kezdõ eleme lehet nulla vagy egy. A modulba írt Option Base sorral beállíthatjuk.

Option Explicit Option Base 1 CD melléklet 04 Fejezet

Sub Nevek() Dim strNevek(3) As String strNevek(1) = "Kiss" strNevek(2) = "Nagy" strNevek(3) = "Vass" End Sub

Tomb deklaralasa.xls

Tömbök deklarálása esetén magunk is meghatározhatjuk, hogy melyik legyen a tömb legkisebb számú eleme. Ezt a következõ szintaktikával írhatjuk a programba: Dim Tomb_1(3 To 10) Dim Tomb_2(8 To 12) Dim Tomb_3(-5 To 30)

A tömbben tárolt adatok feldolgozásáról még szót ejtünk az Iterációs parancsok leírása során.

55


Az elsõ és az utolsó elem száma A változó zárójelei között meghatározhatj u, hogy az adott tömbnek melyik legyen az elsõ és az utolsó elemszáma.



2. rész

Dinamikus tömbök Dinamikus tömb Dinamikus tömbrõl akkor beszélünk, amikor a tömb jellemzõit csak a futás közben határozzuk meg.

Elõfordulhat olyan feladat is, amikor a program írásakor még nem tudjuk, hány elemû tömbre lesz szükségünk a program futtatásakor. Ha például szeretnénk egy tömbben tárolni egy munkafüzet lapjainak a nevét, nem tudhatjuk elõre, hogy hány munkalapja lesz az épp feldolgozás alatt álló munkafüzetnek. Ebben az esetben a program futása közben kell megadnunk az elemek számát, hogy se többet, se kevesebbet ne foglaljunk a szükségesnél. Ilyenkor dinamikus tömböt hozunk létre. Ha tömb deklarálásakor üresen hagyjuk a változó neve mögötti zárójelpárt, akkor dinamikus tömböt deklaráltunk. Dim strLapokNeve() As String

A dinamikus tömb elemei A dinamikus tömb elemeinek a számát a program futása közben a ReDim paranccsal adjuk meg.

Mikor határozzuk meg az elemek számát? Mindenképpen azelõtt, mielõtt használatba vennénk, de már a program futása közben! Erre való a ReDim utasítás! Tegyük fel, hogy eljutottunk a programnak ahhoz a részéhez, ahol felhasználnánk az elõbb deklarált változót. A következõ kis programrészlet szemlélteti a dinamikus tömb elemszámának megadását: Dim strLapokNeve() As String Dim intLapSzam As Integer strLapSzam = Worksheets.Count ReDim strLapokNeve(intLapSzam)

Mi történt a kis programunkban? Deklaráltuk a változóinkat. A következõ lépésben, – Sheets.Count paranccsal – megszámoltuk az aktív munkafüzet lapjait. Az eredményt futás közben felhasználtuk a tömb elemszámának meghatározására. A program további részében értéket adhatunk a tömb elemeinek. Ugyanígy járhatnánk el a megnyitott munkafüzetek neveinek meghatározásával is. Ahányszor kiadjuk a ReDim utasítást, újból helyet foglalunk a tömb elemeinek. Ez egyben azt is jelenti, hogy megszüntetjük az elõzõ deklarálást, és újból helyet foglalunk a tömbnek. Ebben az esetben az adatokat elveszítjük. Ha a ReDim utasítással csak növelni szeretnénk a tömb elemeinek számát – a korábbi tartalom megtartásával –, akkor a Preserve kulcsszót is be kell írnunk a következõképpen: ReDim Preserve strLapokNeve(intLapSzam)

Így a tömb korábbi elemei megmaradnak, feltéve, ha nem kisebbre vettük a tömböt. A korábban tárolt értékeke megmaradnak, csak azok vesznek el, amelyeket a rövidítés miatt elhagytunk.

56



4. fejezet


Összefoglalva A változóknak deklarálással foglalhatunk helyet az operatív memóriában. A kétféle deklarálási módszer közül hasznosabb az explicit deklaráció használata. E látszólag nehézkesebb módszer sok szemantikai, logikai hiba elkövetésében akadályozhat meg minket. A változók deklarálása során mi határozhatjuk meg a változók nevét és típusát. A névválasztásnál ügyeljünk a fejezetben leírt szabályokra. Sokat segíthetünk a program késõbbi olvashatóságán, ha elõtagokat használunk.

57





5. fejezet

Speciális változók

bben a fejezetben néhány érdekes adattárolási módszerrõl olvashatunk. Olyanokról, amelyek kicsit eltérnek az elõzõ fejezetben olvasottaktól. Ezek közé tartoznak az objektum típusú változók, a felhasználói gyûjtemények és adattípusok. Kicsit más a kezelésük, kicsit más célt szolgálnak. Az objektum típusú változó például nem arra szolgál, hogy egy objektumot tároljunk benne, hanem arra, hogy elnevezzünk vele egy objektumot. A felhasználói gyûjteményt használhatjuk tömbváltozók helyett. Ez a lehetõség kicsit összetettebb, de jó lehetõségeket kínál a programozás során. A felhasználói adattípus segítségével új – rekord szervezésû – változótípust hozhatunk létre. Tegyük fel tehát a következõ kérdéseket: w w w w

Miért más az objektum változók használata? Hogyan hozhatunk létre egyedi gyûjteményeket? Mire használhatjuk az egyedi gyûjteményeket? Mi a feladata a felhasználói változótípusnak?

Objektumok elnevezése Megtanultuk, hogy a változók olyan memóriaterületek, melyekben különféle értékeket tárolunk. Az objektum típusú változók esetén nem errõl van szó. A Visual Basic nem másolja az egész objektumot a lefoglalt helyre, csak az objektumra mutató hivatkozást. Így az objektum típusú változókat arra használjuk, hogy rámutassunk egy objektumra. A változó deklarálásában még nincs különbség, de az értékadás eltér a megszokottól. Induljunk ki eddigi ismereteinkbõl! Tegyük fel, hogy egy nem aktív munkafüzet – a neve legyen Munkafüzet1– elsõ munkalapján található A1-es cellába szeretnénk beírni valamilyen adatot. Legyen ez a jól bevált Excel szó. Ehhez le kell írnunk az objektumdiagram szerinti helyes elérési útvonalat. A parancs a következõ lesz:

59


Objektum típusú változó Az objektum típusú változókat az objektumok elnevezésére használjuk. Az elnevezéshez a Set kulcsszót kell használnunk.



2. rész

Workbooks("Munkafüzet1").Worksheets("Munka1").Range("A1")

=

("Excel")

Ha ezzel a tartománnyal, cellával több mûveletet is el kellene végeznünk, akkor az egyenlõségjel elõtti szöveget többször is le kéne írnunk. Ez hosszú, és eltéveszthetõ. Ilyenkor érdemes létrehozni egy objektum típusú változót és rövidebb névvel ellátni a kiszemelt cellát. Ezt a következõ módon tehetjük: Dim objA1 As Object Set objA1 =

Workbooks("Munkafüzet1").Worksheets("Munka1").Range("A1")

Vegyük észre a Set kulcsszót! Ez egy lényeges eltérés a korábbi értékadó utasításokhoz képest. Igaz, hogy ez így két programsort eredményezett, de cserébe ezek után az így létrehozott névvel hivatkozhatunk a Munkafüzet1 munkafüzet elsõ munkalapján található A1-es cellára. A lerövidített hivatkozást így használhatjuk: objA1 = "Excel"

Az Object típus helyett használhattunk volna Variant adattípust is. Ez ugyanis alkalmas objektum elnevezésére is. Ha a változótípus Object, akkor ezzel a névvel bármilyen objektumtípust elnevezhetünk. Ha elõre tudjuk, hogy milyen objektumot szeretnénk elnevezni, akkor ezt már a deklaráció során is meghatározhatjuk. Például használhattunk volna olyan deklarációt, hogy: Dim rngA1 As Range

Mi a különbség a két deklaráció között? Ha Object vagy Variant adattípust használunk, akkor a Visual Basic nem tudja, milyen objektumot fogunk elnevezni. Ennek megfelelõen azt sem tudja elõre, hogy az elnevezett objektumnak milyen tulajdonságai, metódusai lesznek. Ez azért fontos, mert az elnevezés számára le kell foglalni az elnevezett objektum tulajdonságainak helyét a memóriában. Ez értékadáskor, vagyis a Set parancs végrehajtásakor történik meg. Ahányszor elnevezünk vele egy tartományt, minden esetben helyet foglal a tulajdonságok tárolására. Ettõl a programunk egy kicsit lassúbb lesz. Ha deklaráláskor meghatározzuk az objektum típusát – ahogy ezt a második deklaráláskor tettük –, akkor a Visual Basic már itt lefoglalja a szükséges memóriaterületet. Ezt elegendõ egyszer megtenni, vagyis nem futás közben alakítja ki a tulajdonságok helyét. Ettõl a program gyorsabban fog futni. Más szóval, ha csak tehetjük, deklaráláskor határozzuk meg a változó objektumtípusát.

60



5. fejezet


Tömbök helyett gyûjtemények A Visual Basic-ben van egy Collection, – gyûjtemény – osztály. Ennek segítségével létrehozhatjuk saját gyûjteményeinket. A létrehozott gyûjtemény elemeiben bármit tárolhatunk. Még az sem elõírás, hogy azonos adattípusú értékeket helyezzünk el bennük. A gyûjteményeknek öt alapvetõ mûvelete van. Ezeket szinte mindegyik gyûjteménynél megtaláljuk. Ezek a következõk:

Gyûjtemények A tömb típusú változók helyett használhatunk gyûjteményeket. Ezek rugalmasabb kezelést tesznek lehetõvé.

w A Count tulajdonságból megtudhatjuk, hogy hány eleme van a gyûjteménynek. w Az Add metódussal új elemet vehetünk fel a gyûjteménybe. w A Remove metódust használva eltávolíthatjuk a gyûjtemény egy feleslegessé vált elemét. w Az Item metódus segítségével a gyûjtemény egy elemére hivatkozhatunk. w A For Each... Next ciklusszervezéssel végiglépkedhetünk a gyûjtemény összes elemén. Errõl a ciklusszervezésrõl szóló részben részletesen olvashatunk.

Objektum-elõfordulás létrehozása

Új objektum létrehozása

A Collection egy objektumosztály. Ebbõl létre kell hoznunk egy objektum-elõfordulást. Erre a következõ parancsokat használjuk: Dim colEgyedi As Collection Set colEgyedi = New Collection

Az elsõ parancssor még csak egy objektum típusú változó, amit majd arra használunk, hogy elnevezzük vele az új Collection objektum-elõfordulást. Ekkor hozzuk létre az elõfordulást. Erre a Set kulcsszót fogjuk használni. A második sorban már létrehoztuk a colEgyedi objektum-elõfordulást. Használatba is vehetjük. Mielõtt azonban ezt megtennénk, ismerkedjünk meg egy rövidebb írásmóddal is. Az objektum-elõfordulást létrehozhatjuk közvetlenül a deklaráló parancsban is. Ez egyszerûsíti a program írását. Dim colEgyedi As New Collection

Az itt leírt deklaráló utasítás eredménye ugyazaz lesz, mint az elõzõ két parancs eredménye.

61


Új objektumot a New kulcsszóval hozhatunk létre.


Visual Basic for Application Új elem felvétele a gyûjteménybe A gyûjtemény elemeinek számát az Add metódussal bõvíthetjük.

CD melléklet 05 fejezet Gyujtemeny.xls

2. rész

A gyûjtemény bõvítése A létrehozott új objektum-elõfordulásban tárolhatunk szöveget, számot, hivatkozhatunk objektumokra. Akár még úgy is, hogy az egyik elemben objektum-hivatkozás van, a másikban pedig egy szöveg vagy egy szám. Erre viszonylag ritkán van szükség, általában azonos adattípusokat tárolunk ebben is. Nézzük meg, hogyan lehet felvenni új elemet a gyûjteménybe. Használjuk az Add metódust! Sub Dolgozok() Dim colEgyedi As New Collection colEgyedi.Add "Kiss", "Fonok" colEgyedi.Add "Nagy", "Helyettes" colEgyedi.Add "Vass", "Titkar" colEgyedi.Add "Kósa", "Eloado_1" colEgyedi.Add "Sás", "Eloado_2" MsgBox colEgyedi(2) End Sub

A példát megtaláljuk a CD mellékleten. Töltsük be! Indítsuk el a VBE-t és nyissuk ki a Gyujtemeny nevû általános modult. Vegyük szemügyre az eljárás parancsait. Az elsõ sorban létrehoztuk a colEgyedi objektum-elõfordulást.

12. ábra: A Visual Basic felkínálja a metódus paramétereit A következõ öt sorban ugyanazt a mûveletet hajtjuk végre. Új elemeket veszünk fel a gyûjteménybe. Hogy mi kerüljön a gyûjteménybe és hova, az Add metódus paramétereivel határozzuk meg. Ebben segít a Visual

62



5. fejezet


Basic. Amint leütjük a szóközt az Add metódus után, megjelenik a paraméterek felsorolása (12. ábra). Nézzük meg, hogy melyik paraméternek mi a feladata. w Az Item helyére kell beírnunk azt az értéket, amit tárolni szeretnénk a gyûjtemény adott elemében. w A Key paraméter egy szöveg típusú adatot vár. Ezzel az értékkel hivatkozhatunk majd a gyûjtemény most felvett elemére. A kulcsba írt érték nem ismétlõdhet. w A Before paraméterrel határozhatjuk meg azt, hogy a gyûjtemény új eleme melyik – már korában felvett – elem elé kerüljön a sorban. Ha nem töltjük ki, akkor a lista végére kerül az új elem. w Az After paraméterrel azt határozhatjuk meg, hogy az új elem melyik – már korában felvett elem – mögé kerüljön a sorban. Nem kötelezõ kitölteni, ilyenkor a program az utolsó elem után teszi az új elemet. MsgBox colEgyedi(2)

Az utolsó sor kiírja az általunk meghatározott elem tartalmát. Ez a mi esetünkben a másodiknak felvett elem lesz. A gyûjtemény elemeire hivatkozhatunk a nevükkel is. Ezért határoztuk meg a Key paramétert is. Ha például szeretnénk tudni a fõnök nevét, nem kell tudnunk hogy hányadik a sorban, hanem hivatkozhatunk rá névvel az alábbi módon: MsgBox colEgyedi("Fonok")

Elem eltávolítása Ha a gyûjtemény egyik elemére már nincs szükségünk, akkor azt a Remove metódussal eltávolíthatjuk. Ezt a következõ kis eljárásban mutatjuk be, ahol felhasználjuk a Count tulajdonságot is: Sub DolgKilep() Dim colEgyedi As New Collection colEgyedi.Add "Kiss", "Fonok" colEgyedi.Add "Nagy", "Helyettes" colEgyedi.Add "Vass", "Titkar" colEgyedi.Add "Kósa", "Eloado_1" colEgyedi.Add "Sás", "Eloado_2" MsgBox colEgyedi.Count colEgyedi.Remove "Titkar" MsgBox colEgyedi.Count End Sub

A gyûjtemény Remove metódusával eltávolíthatjuk a gyûjtemény feleslegessé vált elemeit.


63


Elem eltávolítása a gyûjteménybõl



2. rész

Az eljárás eleje egyezik az elõzõvel, mindaddig, amíg felvesszük a gyûjtemény elemeit. A következõ sorban megszámoljuk az elemeket. Ezután a Remove metódussal eltávolítunk egy elemet, majd ismét megszámoljuk, hogy mennyi maradt. A példában a titkár adatát távolítottuk el. Természetesen most is hivatkozhattunk volna sorszámmal is. Ezt így kellett volna beírnunk a programba: colEgyedi.Remove 3

Ezzel a gyûjtemény harmadikként felvett elemét távolítottuk volna el.

Érték megváltoztatása Érték módosítása Az objektumelemben tárolt értékeket csak úgy módosíthatjuk, hogy elõbb kivesszük a gyûjteménybõl a módosítandó értéket, majd a helyére új értéket teszünk.


Ha a gyûjtemény egy elemének az értékét szeretnénk megváltoztatni, akkor ezt csak úgy tehetjük meg, hogy elõbb eltávolítjuk a felesleges elemet, és ismét felvesszük. Az új elem kulcsa, – Key – ugyanaz legyen, mint az eltávolítotté. Tehát, ha új titkár lép be a céghez, – a neve legye mondjuk Kovács –, akkor ezt így cserélhetjük le: Sub DolgCsere() Dim colEgyedi As New Collection colEgyedi.Add "Kiss", "Fonok" colEgyedi.Add "Nagy", "Helyettes" colEgyedi.Add "Vass", "Titkar" colEgyedi.Add "Kósa", "Eloado_1" colEgyedi.Add "Sás", "Eloado_2" MsgBox colEgyedi("Titkar") colEgyedi.Remove "Titkar" colEgyedi.Add "Kovács", "Titkar" MsgBox colEgyedi("Titkar") End Sub

A tömbváltozókkal ellentétben itt nem csak az indexekkel hivatkozhatunk egy elemre, hanem az új elem felvételénél megadott kulccsal is. A kulcsok nem ismétlõdhetnek, egyedinek kell lenniük.

Felhasználói adattípus használata A felhasználói adattípussal kialakíthatjuk egyéni adatstruktúráinkat. A felhasználói adattípust nevezik rekord típusú változónak is, ami arra utal, hogy egy meghatározott változótípus több változót is magában fog-

64



5. fejezet


lalhat. Ennek nagy hasznát vehetjük a listába szerkesztett adatok feldolgozásánál, vagy az Access programozásakor. A felhasználói adattípus meghatározását a Type és End Type sorok közé kell írnunk. A két utasítás között csak deklaráló utasítások lehetnek. Nézzünk egy példát: Type Dolgozok VezNev As String * 30 KerNev As String * 20 SzulDat as Date Belep as Date End Type

Felhasználói típus A felhasználói változótípust elõbb a Type … End Type utasításpárral meg kell határoznunk.

CD melléklet 05 Fejezet Rekord tipus.xls

A fenti utasításokat a modul eljárásain kívülre kell írni. Az eredmény az lesz, hogy létrejön egy új változótípus, amibe többféle adatot tárolhatunk. Nézzük meg a felhasználói típus használatát:

Deklarálás A meghatározott felhasználói típussal új változókat deklarálhatunk.

13. ábra: A felhasználói típus belsõ változói megjelennek Sub DolgAdat() Dim Alkalm As Dolgozok Alkalm.VezNev = "Kiss" Alkalm.KerNev = "Béla"

CD melléklet 05 Fejezet Rekord tipus.xls

65




2. rész

Alkalm.Belep = #1/1/2003# Alkalm.SzulDat = #4/14/1952# End Sub

Az elsõ sorban deklarálunk egy változót az újonnan létrehozott változótípussal. A következõ sorokban értéket adunk a típusban meghatározott belsõ változóknak. Ezt ugyanúgy tehetjük meg, mintha egy objektum tulajdonságai lennének. A program írásakor a Visual Basic felkínálja a belsõ változók neveit, amint leütjük a pont operátort. Ezt szemlélteti a 13. ábra.

Összefoglalás Ha a program objektum-hivatkozásait szeretnénk lerövidíteni, akkor hozzunk létre objektum típusú változót. Hacsak tehetjük, a deklaráló parancsban pontosan határozzuk meg az elnevezni kívánt objektum típusát. Így gyorsíthatunk a program futásán. Az értékadáskor ne felejtkezzünk meg a Set kulcsszóról. Fontos megjegyezni, hogy az objektum nem kerül vele a változóba, csak elnevezzük az objektumot! Objektum típusú változót használunk akkor is, amikor egy új objektumot szeretnénk létrehozni. Ezt láttuk gyakorlatban a gyûjtemény használatáról szóló bekezdésekben. A gyûjtemény objektum-osztály alapján létrehozott objektum-elõfordulás használatával kiválthatjuk a tömbváltozókat. A gyûjtemények több lehetõséget biztosítanak a program írása során. Rugalmasabban kezelhetõ, mint a tömbváltozó. A felhasználói adattípus egyedi, rekord szerkezetû adatfeldolgozásra használható. Az összetartozó változókat egybe zárhatjuk, mintha csak egy objektum tulajdonságai lennének.

66



6. fejezet

Állandók, felsorolások

ok esetben olyan értékekkel dolgozunk, amelyeket a program futása közben egyszer sem változtatunk meg. Ezeket állandóként tároljuk. Ha például, egy hibaüzenetet küldünk a felhasználónak, akkor minden esetben ugyanannak a szövegnek kell megjelennie, ha az adott hiba bekövetkezik. Nem csak hibaüzenetekkel járhatunk el így. Gondoljunk csak például a kereskedelemben használt áfa értékére vagy más értékekre, amik nem változnak. A programban használt állandókat úgyis megadhatjuk, hogy deklarálunk egy változót és rögtön utána értéket adunk a deklarált változónak. Ezt egy lépésben állandó deklarálásával valósíthatjuk meg. A kérdések a következõk: w w w w

Hogyan kell deklarálni az állandókat? Mi a szerepük a programban? Mi a felsorolás? Mire használható a felsorolás?

Állandók deklarálása Az állandók deklarálásának kulcsszava a Const. A következõ példában egy szöveges állandót deklarálunk, amit hibaüzenetként fogunk megjeleníteni a programban. Const STR_UZENET = "Nincs ilyen munkalap!"

Az állandó deklarálása magába foglalja az adattípus meghatározását és az értékadást. Mivel a fenti példában az adattípust nem írtuk le, az állandó Variant adattípusú lesz. Ez több helyet foglal, mintha meghatároznánk a valódi típusát. A következõ utasítássorban meghatározzuk az állandó adattípusát is.

67


Állandó deklarálása Az állandók deklarálásának a kulcsszava a Const. Deklarálásakor meghatározzuk annak adattípusát és az értékét.



2. rész

Const INT_LEPESEK As Integer = 17

A változók nevét érdemes végig nagybetûkkel írni, hogy a programban könnyen rátaláljunk az esetleges bõvítések, javítások alkalmával. A cél tehát ismét az áttekinthetõség, a könnyebb olvashatóság.

Felsorolások A felsorolás megértéséhez vizsgáljuk meg az MsgBox utasítást. Ez az utasítás üzenetek megjelenítésére szolgál. A példában rögtön alkalmazzuk a tanultakat, és az üzenet szövegét állandóként határozzuk meg. Az utasítás beírásakor figyeljünk magára a beírásra. Töltsük be az Excel-t, és térjünk át a Visual Basic Editor-ba. Hozzunk létre egy új modult, és írjuk be a következõ eljárást: CD melléklet 06 Fejezet Felsorolasok.xls

Sub UzenetPanel() Const STR_UZENET As String = "Üzenet panel megjelenítése" Const STR_CIMKE As String = "Üzenet" MsgBox STR_UZENET, vbCritical, STR_CIMKE End Sub

Az eljárás elsõ két sorában azokat az állandókat deklaráltuk, amelyeket az üzenet panelben fogunk használni. Az STR_UZENET állandóban a panelen megjelenõ üzenet szövegét deklaráltuk, az STR_CIMKE állandóban pedig a megjelenõ panel címsorának feliratát. Amint beírtuk az eljárást, indítsuk is el! Ehhez álljunk az eljárás valamelyik sorára és hajtsuk végre a Run Ø Run Sub/UserForm utasítást. Megjelenik az üzenetünk. A futtatás eredményét a 14. ábra mutatja

14. ábra: Üzenet panel megjelenítése

68



6. fejezet

Állandók, felsorolások

15. ábra: A Visual Basic belsõ állandókat használ paraméterezésre Ha elég figyelmesek voltunk az eljárás beírásakor, észrevehettük, hogy a MsgBox parancs beírásakor a második argumentumnál megjelent egy lista (15. ábra). Innen választhattuk ki, hogy a megjelenõ üzenet mit tartalmazzon. Így helyezhetünk el figyelmeztetõ ikont vagy hiba ikont a megjelenõ panelen. A listában szövegeket találunk. A megjelenõ szövegek mindegyike mögött egy szám, egy állandó van. Úgy is megírhattuk volna ezt az eljárást, hogy a szövegek mögötti számot írjuk be a második paraméter helyére. Ez is jó megoldás, de a számokat sokkal nehezebb megjegyezni. Ezért jelenik meg szövegként a második paraméter. Ha a vbCritical szöveg helyére azt írnánk, hogy vbInformation, akkor nem a piros kör jelent volna meg az ûrlap bal szélén, hanem egy kék „i” betû. Nos ezt a példát azért oldottuk meg, hogy feltehessük a kérdést. Mi is létrehozhatnánk ilyen felsorolásokat? Mi is meghatározhatnánk, hogy egy szöveg mögött milyen számot értelmezzen a program? Igen! Mi is létrehozhatunk ilyen felsorolást. Nézzük meg hogyan! A felsorolást deklarálnunk kell. A felsorolás elemeinek értéke csak egész szám lehet. A felsorolást az Enum és az End Enum utasításpár között kell meghatároznunk úgy, ahogy ez a következõ példában olvasható:

A Visual Basic-ben és az Office objektumokban a számokat felsorolásokban megadott értékek helyettesítik. Így könnyebb megjegyezni azokat.

A felsorolás deklarálása

Enum HetNap hetfo kedd szerda csutortok pentek szombat vasarnap End Enum

A felsorolás deklrálása az Enum.. End Enum utasításpárt használjuk. Ezzel új változó típust hozhatunk létre. A felsorolás nevét az Enum sorba írjuk!

69


A Visual Basic felsorolásai



A felsorolás elemei A felasorolás elemeinek, megadhatjuk az értékét, de ezek csak egész számok lehetnek.

CD melléklet 06 Fejezet Felsorolasok.xls

2. rész

A felsorolás meghatározását eljáráson kívülre, a modul elejére kell írnunk. A felsorolásba beírt szövegek úgy viselkednek, mint egy konstans. A felsorolt elemek értéke nullától kezdõdik, és minden elem értéke eggyel növekszik. Vagyis a vasarnap értéke hat. Mi is meghatározhatjuk az Enum elemeinek értékét. Ehhez a felsorolt szövegek mögé egyenlõségjelet írunk, majd egy egész számot. Ezt szemlélteti a következõ meghatározás: Enum HetNap_2 hetfo = 1 kedd = 2 szerda = 3 csutortok = 4 pentek = 5 szombat = 6 vasarnap = -1287 End Enum

A felsorolások használata Hogyan használjuk? Ha a felsorolást szeretnénk használatba venni, deklaráljunk változót a nevével.

A konstansok kipróbálására szolgáló modult bõvítsük ki egy példával, melyben kipróbáljuk a felsorolás használatát. Deklaráljunk egy felsorolást, majd egy eljárásban vegyük használatba. Ennek a lépéseit mutatja be a 16. ábra, amelyek a következõk: 1. Határozzuk meg a felsorolást! Most, mi adjunk értéket a felsorolás elemeinek a 16. ábra szerint. 2. Hozzunk létre egy eljárást – ez az ábrán az EnumTeszt. Deklaráljuk benne a Napok változót. 3. A változó típusa legyen ugyanaz, mint a felsorolás neve. Vegyük észre, hogy a típus megjelenik a listában. Akár innen is kiválaszthatjuk. 4. Adjunk értéket a Neve változónak. Amint leírjuk az egyenlõségjelet, rögtön megjelennek azok a szövegek, amelyeket a felsorolás meghatározásakor írtunk az Enum és az End Enum sorok közé. Itt nem abban a sorrendben jelennek meg, ahogy mi írtuk be, hanem ábécé szerint rendezve. Az ábrán a pénteki napot választottuk ki. 5. Az utolsó parancs segítségével jelenítsük meg a változó tartalmát. A kis panel a program futtatásakor látható lesz! Figyeljük meg, hogy a 16. ábra negyedik lépésében a VBE ugyanúgy felkínálja a felsorolás elemeit, mint a 15. ábrán amikor a MsgBox utasítást használtuk. Még a lista elején megjelenõ ábrák is azonosak az ott látottakkal, a felsorolás elemei ott is egy egész számot képviselnek.

70



6. fejezet

Állandók, felsorolások CD melléklet 06 Fejezet Felsorolasok.xls

16. ábra: A felsorolás használata Az elkészült programot úgy indíthatjuk el, hogy beállunk az elkészült eljárásba és végrehajtjuk a VBE Run Ø Run Sub/UserForm utasítását. Ennek hatására jelenik meg az ötödik lépésben beírt MsgBox utasítás eredménye. A megjelenõ panelen a pénteknek megfelelõ 5-ös számot látjuk.

Összefoglalás Azokat az értékeket, amelyeket nem fogunk megváltoztatni a program futási idejében állandókként deklaráljuk. Az állandó deklarálás kulcsszava a Const szó. Az állandó deklaráláskor meghatározhatjuk annak adattípusát is. Ez nem kötelezõ, de a kisebb helyfoglalás mégis indokolja. Programjainkban meghatározhatunk olyan felsorolásokat, melyek megkönnyítik a munkát. A felsorolásokban az általunk meghatározott szövegek mögé egész számokat rendelhetünk. Így nem kell megjegyeznünk azt, hogy milyen számértéket vár a program.

71





7. fejezet

Hatókör, élettartam

változókat és állandókat valamilyen eszközzel el kell választanunk egymástól. Nem lenne jó, ha egy adott eljáráshoz tartozó változónak egy másik eljárás beállíthatná az értékét. A hatókörök határai azt is lehetõvé teszik, hogy több eljárásban használhassuk ugyanannak a változónak vagy állandónak a nevét. A Visual Basic eljárásokban deklarált változónak csak abban az eljárásban adhatunk értéket, amelyben meghatároztuk. Természetesen kellenek tágabb határok is. Egy modulban dolgozva szükségünk lehet olyan változókra is, ami csak abban a modulban érvényes, amelyben deklaráltuk. Így egyben tarthatjuk az összetartozó eljárásokat, változókat és állandókat. Létezik egy még nagyobb egység is: a projekt. A projekt minden moduljában használható változókat globális változóknak nevezzük. Ezeknek a változóknak a projekt összes moduljában értéket adhatunk, és bármelyikben kiolvashatjuk tartalmukat. Mivel egy Visual Basic projekt többféle modult tartalmaz, fontos különbséget tennünk a modulok típusai között. A változók hatókör szempontjából másként viselkednek egy osztálymodulban, mint egy általános modulban. A fejezetben a következõ kérdésekre keressük a választ: w Mitõl függ egy változó hatóköre? w Hogyan deklarálhatunk eljárás szintû változókat? w Milyen hatással van a modul a változó hatókörére?

Eljárás szintû változók Az eljárás szintû változóknak csak abban az eljárásban változtathatjuk meg az értékét, amelyikben deklaráltuk. Több eljárásban használhatjuk ugyanazt a változó vagy állandó nevet. Az azonos nevek nem fognak ütközni egymással. A hatókör kérdését a gyakorlatban vizsgáljuk meg! Töltsük be az Excel-t, és a VBE-ben hozzunk létre egy új modult. Írjuk be a következõ két eljárást, és indítsuk el az elsõt. 73



Visual Basic for Application CD melléklet 07 Fejezet Hatokor.xls

Eljárás szintû hatókör Ha egy eljáráson belül – a Sub és End Sub között – deklarálunk egy változót, akkor azt csak abban az eljárásban használhatjuk, ahol meghatároztuk.

2. rész

Sub Kor_1() Dim strNeve As String strNeve = „Kiss” End Sub Sub Kor_2() strNeve = „Nagy” End Sub

A Kor_1 eljárás hibajelzés nélkül lefut, hiszen a második sorban egy eljárás szintû változónak adunk értéket. Próbáljuk elindítani a második – Kor_2 – eljárást! Amint elindítjuk, a program leáll, és megjelenik egy hibaüzenet. Az üzenet arról tájékoztat, hogy olyan változót használunk, amit korábban nem deklaráltunk. Tehát, ha nem ebben az eljárásban deklaráljuk a változót, akkor azt nem használhatjuk. Kézzelfoghatóvá vált, hogy az strNeve változó hatóköre a Kor_1-es eljárás. Állítsuk le az eljárás futását a Run > Reset paranccsal. Természetesen szükségünk lehet a Kor_2 eljárásban is strNeve változóra. Akkor azt ott is deklarálnunk kell!

Paraméteres eljárás, szubrutin Paraméter Ha egy eljárás neve mögötti zárójelpár között deklarálunk változót, akkor az egy olyan eljárás szintû változó lesz, amelynek az eljárás hívásakor értéket adhatunk.

CD melléklet 07 Fejezet Parameter.xls

Paraméteres eljárás indítása A paraméteres eljárást csak hívással lehet elindítani.

De mit kell tennünk akkor, ha egy eljárás szintû változónak egy másik eljárásból szeretnénk értéket adni? Az eljárás neve mögötti zárójelpár között is deklarálhatunk változókat. Az eljárás zárójelei között deklarált változóknak kívülrõl is adhatunk értéket, de használhatjuk az eljáráson belül is. Így hozhatunk létre olyan eljárásokat, melyek külsõ adatokat dolgoznak fel. Írjunk egy olyan eljárást, ami két számot összead, majd az eredményt kiírja egy üzenetpanel segítségével. Ügyeljünk az eljárás felépítésére, szerkezetére. Kezdjük az eljárásban használt állandók és változók meghatározásával. Zárjuk le az elõzõ példa kedvéért létrehozott munkafüzetet, és nyissunk egy újat az új példa miatt. Hozzunk létre egy általános modult, és írjuk bele a következõ eljárást! Sub Osszeado(sngSzam_1 As Single, sngSzam_2 As Single) Const STR_EREDMENY As String = "Az öszeadás eredménye: " Const STR_CIMKE As String = "Összeadás" Dim dblEredmeny As Double dblEredmeny = sngSzam_1 + sngSzam_2 MsgBox STR_EREDMENY & dblEredmeny, vbInformation, STR_CIMKE End Sub

Ezt az eljárást nem lehet közvetlen elindítani, csak úgy, hogy egy másik eljárásból meghívjuk. Ennek az oka az, hogy a zárójelek között deklarált változóknak értéket kell adni, és ezt csak akkor tehetjük meg, amikor

74



7. fejezet


meghívjuk az eljárást. Írjunk tehát egy másik eljárást is. Ebben egyetlen parancs lesz, az amivel meghívjuk az összeadó programot. Figyeljük meg, hogy amikor eljutunk a paraméterek megadásához, a Visual Basic megmutatja a paramétereket és azok adattípusát. Sub Szamolas() Osszeado 12, 45 End Sub


17. ábra: Egy eljárás paraméterezése Elemezzük a programot! A Szamolas eljárás meghívja az Osszeado eljárást. Amikor meghívja, értéket ad a két változónak, amit a zárójelek között deklaráltunk. Tehát, amikor az Osszeado eljárás elindul, már a két változóban lesz a meghíváskor beírt két szám. Amikor a Visual Basic végrehajtja a meghívott eljárást, visszatér abba az eljárásba, amelyik meghívta õt. Az Osszeado eljárás elsõ két sorában azokat az állandókat deklaráljuk, amelyeket az MsgBox-ban fogunk felhasználni az eredmény megjelenítésére. Az eredmény változó adattípusa nem egyezik meg a két összeadandó szám típusával. Ennek az oka az, hogy minden eredményt tárolnunk kell, márpedig két szimpla hosszúságú – Single – szám összege nagyobb is lehet, mint a szimpla hosszúság. Az adatbekéréssel nem foglalkozunk, mert az megtörtént, amikor meghívtuk az eljárást. Az algoritmus számítási része egyetlen sor, ami a két szám összegét beírja a dblEredmeny változóba. Az eljárás adatkiírási része egy újabb sor. Ez az MsgBox kezdetû. Itt egy ismeretlen mûveleti jelet találunk. Az & karakter egy olyan mûveleti jel, amelyik két külön változóban található értéket egymás mögé ír. Így oldottuk meg, hogy az eredmény megjelenésekor ne csak egy szám jelenjen meg, hanem egy rövidke szöveg is.

75


Szubrutin Amikor egy eljárást egy másik eljárásból meghívva indítjuk el, a meghívott eljárást szubrutinnak nevez-


Visual Basic for Application Paraméter értékadás A paraméteres eljárásoknak teszõleges sorrenben adhatunk át értéket, ha beírjuk a paraméter nevét és a kettõspont egyenlõségjel után írjuk az átadni kívánt értéket.

2. rész

Ejtsünk néhány szót a paraméterek megadásáról! A 75. oldal 17. ábráján láttuk, hogy megjelennek a meghívott eljárás argumentumai, amikor oda jutunk, hogy meg kell adni. A megjelenõ sárga sávon mindig az a paraméter jelenik meg félkövér betûvel, amelyiknek értéket adunk. Néha kényelmesebb lehet egy eljárás paramétereinek más sorrendben értéket adni. A Visual Basic erre is lehetõséget ad. Amikor épp felkínálja az elsõ paramétert a program, akkor mi beírhatjuk bármely más paraméter nevét, és kettõspont-egyenlõségjellel megadhatjuk a paraméter értékét. Ezt mutatja be a 18. ábra:

18. ábra: Paraméterek megadása tetszõleges sorrendben

Opcionális paraméterek Opcionális paraméter Ezek olyan paraméterek, amelyeknek nem kötelezõ megadni az értékét, amikor az eljárást meghívjuk.

Ha nem az összes paramétert akarjuk átadni a hívás pillanatában, akkor úgynevezett opcionális – nem kötelezõ – paramétert használunk. Ez egy olyan paraméter, amelynek az értékét nem kötelezõ megadni akkor, amikor meghívjuk az eljárást. A zárójelek között elõbb a kötelezõ paramétereket kell felsorolni, majd ezt követõen az opcionális paramétereket. Ha egyszer a felsorolásban opcionális paramétert adtunk meg, attól kezdve csak ilyet tartalmazhat a felsorolás többi része. Az opcionális paraméter meghatározásakor megadhatunk egy értéket, amit alapértelmezettnek tekint a program. En-

76



7. fejezet


nek megadása nem kötelezõ. Ezt az értéket akkor veszi fel a paraméter, ha az eljárás hívásakor nem adtunk értéket az adott paraméternek. Ha nem adjuk meg az opcionális paraméter kezdõ értékét, akkor az eljáráson belül lekérdezhetjük, hogy kapott-e értéket a változó az eljárás emeghívasakor. Erre az Ismissing(Valtozonev) függvényt haszálhatjuk. Oldjunk meg egy egyszerû példát. Írjunk egy olyan eljárást, ami a szorzás mûveletet végzi el. Úgy határozzuk meg a paramétereket, hogy amikor az eljárás hívásakor nem adunk értéket a szorzónak, akkor azt automatikusan tekintse egynek a program. Sub Szorzas(sngSzorzando As Single, Optional Szorzo = 1) Const STR_EREDMENY As String = "Az szorzás eredménye: " Const STR_CIMKE As String = "Szorzás" Dim dblEredmeny As Double dblEredmeny = sngSzorzando * Szorzo MsgBox STR_EREDMENY & dblEredmeny, vbInformation, STR_CIMKE End Sub


Alapérelmezett érték

Az eljárást hívjuk meg a korábban megírt Szamolas eljárásból. Módosítsuk a Szamolas eljárást a következõk szerint: Sub Szamolas_2() Osszeado sngSzam_2:=14, sngSzam_1:=25 Szorzas 45 End Sub

Az opcionális paraméterek esetén megadhatunk egy értket. Az opcionális változó, akor veszi fel ezt, ha híváskor nem adtunk értéket neki.


Felfedezhetjük, hogy a Szorzas eljárás hívása során a második paramétert nem adtuk meg. Ettõl még a meghívott eljárás mûködik, és eggyel megszorozza a Szorzando paraméternek átadott értéket.

Tömbparaméter deklarálása Ha paraméterként tömböt szeretnénk átadni az eljárásnak, akkor ezt is az eljárás neve mögötti zárójelek között kell deklarálnunk. A paraméter listában szerepelhet több változó is, de tömbváltozó csak egy! Ezt a lista legutolsó helyére kell írnunk. A tömbparaméter úgy mûködik, mint sok opcionális változó. A tömbparaméter – mûködését tekintve – hasonlít a dinamikus tömbökhöz. Mindig annyi eleme lesz, ahány elemnek az eljárás hívásakor értéket adtunk. A tömbparamétert tartalmazó eljárás hívásakor nem kötelezõ egyetlen elemnek sem értéket adni! A változó legkisebb eleme mindig a nullás lesz, függetlenül attól, hogy a modul elején kiadtuk-e az Option Base 1 parancsot vagy sem! A tömb méretét nem változtathatjuk meg a

77


Tömbparaméter A tömbparaméter az eljárásban tömbként viselkedik, ée annyi eleme lesz, amennyinek az eljárás hívásakor értéket adtunk. A tömb legkisebb eleme minden esetben a nullás elem lesz!



2. rész

tömbparamétert tartalmazó eljárásban sem, de a híváskor megadott bármelyik elem értékét átírhatjuk. Oldjunk meg egy példát! Írjunk egy olyan eljárást, amelyben dolgozók szervezeti egységét és nevét dolgozzuk fel. Tegyük fel, hogy mindig egy gazdasági egységet dolgozunk fel, de ott több ember is munkálkodik. A gazdasági egység nevének átadására használjunk egy szöveges típusú paramétert. Tegyük fel, hogy azt nem tudjuk elõre, hogy egy adott egységen belül hányan és kik dolgoznak. Ezért a második paraméter legyen tömb típusú! Az eljárásban írassuk ki a szervezeti egység nevét, és a neveket tartalmazó tömb legkisebb és legnagyobb elemének számát és tartalmát. Az eredmény kiírására használjuk az Immediate ablakot. Ide a Debug.Print paranccsal írhatunk ki bármit. Az elkészült eljárást hívjuk meg, és figyeljük az eredményt. A Dolgozok eljárás a következõ lesz: CD melléklet 07 Fejezet Parameter.xls TombParameter modul

Sub Dolgozok(strSzervezet As String, ParamArray Neve()) 'Az eljárásban használt változók deklarálása Dim lngAlso As Long Dim lngFelso As Long Dim strAlsoErteke As String Dim strFelsoErteke As String 'A feldolgozás adatainak az összegyûjtése Const STR_SZERVEZET As String = "A szervezeti egység: " Const STR_LEGKISEBB_SZAMA As String = "A legkisebb elem száma: " Const STR_LEGNAGYOBB_SZAMA As String = " A legnagyobb elem száma: " Const STR_LEGKISEBB_ERTEKE As String = " A legkisebb elem tartalma: " Const STR_LEGNAGYOBB_ERTEKE As String = " A legnagyobb elem tartalma: " 'Az adatok feldolgozása lngAlso = LBound(Neve)'A tömb legkisebb eleme a száma lngFelso = UBound(Neve)' A tömb legnagyobb elem strAlsoErteke = Neve(lngAlso)' A legkisebb elemén értéke strFelsoErteke = Neve(lngFelso)' A tömb legnagyobb elem értéke 'Eredmény kiírása Debug.Print STR_SZERVEZET & strSzervezet Debug.Print STR_LEGKISEBB_SZAMA & lngAlso Debug.Print STR_LEGNAGYOBB_SZAMA & lngFelso Debug.Print STR_LEGKISEBB_ERTEKE & strAlsoErteke Debug.Print STR_LEGNAGYOBB_ERTEKE & strFelsoErteke End Sub

Elemezzük ki az eljárás lépéseit! Az elsõ sorban egy megjegyzést találunk. Ezt nem hajtja végre a program. A megjegyzést felsõ vesszõvel kell kezdeni, és utána bármit beírhatunk. Megjegyzést írhatunk egy parancssor után is. A megjegyzések magyarázatul szolgálnak a program megértéséhez.

78



7. fejezet


Az eljárás következõ négy sorában deklaráljuk azokat a változókat, melyeket ebben az eljárásban használunk. Ezek hatóköre ez az eljárás! A konstansok deklarálása már az adatgyûjtéshez tartozik. Ezért a következõ lépések ezek meghatározását tartalmazzák. Az adatfeldolgozási rész elsõ két sorában egy-egy Visual Basic függvényt használunk. Az LBound függvény eredménye a tömb legkisebb elemének a száma. Ezt a függvényt bármelyik tömb esetén használhatjuk. Figyeljük meg, hogy a függvényhívás eredményt ad! Ezt az eredményt az lngAlso változóban tároljuk, a kiírásig. Hasonlóan járunk el a tömb legnagyobb elemének a számával is, az eredményt az lngFelso változóba írjuk. Itt az UBound függvényt használjuk. A legkisebb és legnagyobb elem tartalmának meghatározásához már felhasználhatjuk a kiszámított eredményt. A feldolgozás harmadik és negyedik sorában, egy-egy változóban rögzítjük a két tömbelembe írt értéket. Az eredmény kiírása részben az eredményeket kiírjuk az Immedate ablakba. Erre szolgálnak a Debug.Print kezdetû sorok. Ha ez az eljárás kész, futtassuk le! Írjunk egy Dolgozo_hivasa eljárást, amiben meghívjuk a Dolgozok eljárást. Még mielõtt megkezdenénk a futtatást, kapcsoljuk be az Immediate ablakot a View Ø Immediate Window paranccsal. Íme az eljárás:

19. ábra: Eredmény kiírása az Immediate ablakba Sub Dolgozok_hivasa() Dolgozok "Kereskedõk", "Vass", "Sass", "Kovács", "Soós" End Sub

79




2. rész

Álljunk a Dolgozok_hivasa eljárás egyik sorába és indítsuk el! Futás után nézzük meg az Immediate ablak tartalmát. Ezt szemlélteti a 79. oldal 19. ábrája. A Dolgozok_hivasa eljárásban változtassuk meg a paraméterlistát – adjunk más értékeket – , és futtassuk le többször az eljárást, ismerkedjünk a lehetõségekkel.

Modul szintû változók és állandók Modul szintû deklarálás Modul szintû deklarálákor az eljárásokon kívül kell maghatározni a változót vagy állandót.

Modul szintû változót úgy deklarálhatunk, hogy a modul eljárásokon kívüli területre írjuk a parancsot. Így a változónak bármelyik eljárásban értéket adhatunk és kiolvashatjuk az értékét. Talán egy technikai dolgot érdemes megtennünk! A változó típusát jelölõ elõtag-karaktereket kibõvíteni egy kis “m” betûvel. Valahogy így: Dim mlngNagySzam As Long

Próbáljuk ki a modul szintû változó használatát! Ha a fejezet eddigi feladatait megoldottuk, zárjuk le azt, és kezdjünk egy új munkafüzetet. Az új munkafüzetben hozzunk létre több általános modult. Az egyik modulban deklaráljunk egy modul szintû változót, majd ezt próbáljuk meg használni egy másik modulból. Beírás közben úgy néz ki, mintha minden rendben lenne. Elfogadja az értékadó parancssort, de amint elindítjuk az eljárást, a fordító leállítja, és nem definiált változó hibajelzéssel leáll. CD melléklet 07 Fejezet Modul szint.xls

20. ábra: A modul szintû változók használata

80



7. fejezet


Írjunk egy másik eljárást ugyanabba a modulba, amelyikben a változót deklaráltuk és abban ugyanígy adjunk értéket neki. Indítsuk el! Ez hibátlanul lefut. Vagyis ezt a változót abban a modulban használhatjuk, amelyikben meghatároztuk. A hatókör határa a modul. Ha precízek szeretnénk lenni, akkor a modul szintû változókat és állandókat a Private kulcsszóval kellene kezdeni. Ezt elhagyhatjuk, mert a modul szintû változók alapértelmezés szerint csak abban a modulban érvényesek, amelyben meghatároztuk azokat. A Private kulcsszót csak eljáráson kívül adhatjuk ki. Private kulcsszó

Private mlngNagySzam As Long Private Const MINT_SZAM As Integer = 5

Ez a pontos formája a modul szintû változók, vagy állandók deklarálásának.

Ezzel egyenértékû a következõ két sor: Dim mlngNagySzam As Long Const MINT_SZAM As Integer = 5

Projekt szintû változók és állandók Ezek az úgynevezett globális változók és állandók. A deklarálásukhoz a Public kulcsszót kell használni. Az elõzõ két változót alakítsuk át globális változóvá. A projekt szintû változók és állandók elõtag karakterei elé írjunk “g” betût. Íme: Public glngNagySzam As Long Public Const GINT_SZAM As Integer = 5

Projekt szintû deklarálás A projekt szintû deklarálás kulcsszava a Public. Ezeket a változókat a projekt minden eljárásában használhatjuk.

Ezt a változót és állandót a projekt bármely moduljának bármely eljárásában használhatjuk. Hozzunk létre egy globális változót, és próbáljunk meg értéket adni nekik több modul eljárásaiban.

A modulok különbsége A Visual Basic projektben többféle modult használhatunk. Amikor az alapfogalmak részben megismerkedtünk a Projekt felépítésével, láthattuk, hogy az Excel munkalapjai és a munkafüzet mögött van egy-egy modul. Amikor errõl volt szó, említettük, hogy ezek osztálymodulok. Ez fontos a globális változók deklarálása szempontjából. Máshogy fog viselkedni a globális változó egy általános modulban és másként egy osztálymodulban. Az osztálymodul feladata ugyanis az, hogy bezárja a benne deklarált változókat.

81


Fontos! A projekt szintû deklarálást mindíg egy általáos modulba írjuk! Az osztálymodulok bezárják a változókat!



2. rész

Ezt is úgy ismerjük meg, ha kipróbáljuk! Zárjuk le a korábbi Excel munkafüzeteket és hozzunk létre egy újat. Térjünk át a VBE programba. Most is hozzunk létre egy általános modult. Ebbe fogjuk megírni azt az eljárást, melyben értéket adunk a globális változónak. A megoldást a 21. ábra szemlélteti.

21. ábra: Globális változó az osztálymodulban 1. A project ablakban kattintsunk kettõt a Munka1 munkalap ikonjára. 2. Megnyílik a munkalaphoz tartozó osztálymodul. 3. A megnyitott modulban deklaráljunk egy globális változót. A változó neve legyen gcurBevetel, típusa pedig Currency. 4. Hozzunk létre egy általános modult. Nyissuk meg!

82



7. fejezet


5. Írjuk bele az ábrán látható eljárást! 6. Álljunk az eljárásba és a Run ØRun Sub/User Form parancs végrehajtásával indítsuk el az eljárást. 7. Az eljárás nem deklarált változó hibajelzéssel leáll. Mi lehet az oka a bekövetkezett fordítási hibának? Az, hogy a globális változót egy osztálymodulban deklaráltuk. Az osztálymodul ugyanis magába zárja a benne deklarált változókat. Ezeknek kívülrõl – másik modulból – csak az objektum-interfészen keresztül adhatunk értéket. Ezt is próbáljuk ki! Változtassuk meg az általános modul eljárását a következõ módon: Sub Szamla() Worksheets(1).gcurBevetel = 180000 End Sub

Ismét indítsuk el az eljárást! Most már hiba nélkül lefut. Az osztálymodulban deklarált globális változó úgy fog viselkedni, mintha a munkalapnak egy újabb tulajdonsága lenne az általunk deklarált változó. Fontos tehát megjegyeznünk, hogy az Excel objektumaihoz tartozó modulok osztálymodulok. Ha ezek moduljaiban globális változót deklarálunk, akkor azok új tulajdonságai lesznek az adott objektumnak. Ehhez a tulajdonsághoz csak az objektum-interfészen keresztül férhetünk hozzá.

Statikus változók Ha eljárásban deklaráltunk egy változót, az mindaddig megtartja az értékét, amíg abban az eljárásban fut a program amelyben létrehoztuk. Ha kilépünk az eljárásból, majd ismét visszalépünk, akkor a belépéskor újradeklarálódik a változó. Ezzel el is veszti azt az értéket, ami akkor volt benne, amikor utoljára nála jártunk. Ha mégis szükségünk volna a változó korábbi értékére – például szeretnénk megszámolni, hogy hányszor léptünk be az adott eljárásba –, akkor deklaráljunk statikus változót. A statikus azt jelenti, hogy akkor is megõrzi az értékét, ha elhagyjuk az eljárást, és az újbóli belépéskor nem deklaráljuk ismét, így nem veszítjük el a korábbi értékét. Az utasítás a következõ lesz:

Statikus változó

Sub Megszamol() Static intSzamlal As Integer intSzamlal = intSzamlal + 1 MsgBox intSzamlal End Sub

CD melléklet 07 Fejezet Statikus.xls

83


A statikus változó akkor is megtartja az értékét, ha kilépünk abból az eljárásból, amelyben deklaráltuk azt.



2. rész

A fenti kis program akkor is megtartja az intSzamlal értékét, ha kilépünk az eljárásból. Az ismételt végrehajtások eredménye az lesz, hogy az üzenetpanelben minden esetben eggyel nagyobb szám jelenik meg, mint a korábbi futtatás alkalmával.

Tegyünk rendet! Felmerülhet a kérdés, hogy melyik változót hol és hogyan deklaráljuk. Azokat az állandókat és változókat, melyeket a projekt több moduljában, több eljárásában szeretnénk használni, érdemes egy direkt erre a célra létrehozott általános modulban meghatározni. Vigyázzunk arra, hogy az Excel objektumok moduljai osztálymodulok. Az itt meghatározott globális változókat a Visual Basic bezárja. Ezek új tulajdonságai lesznek az objektumnak, és csak az objektum-interfészen keresztül érhetjük el õket. Ha kisebb programot írunk, vagy jól elhatárolható részekre bontható a program, akkor érdemes egy-egy összetartozó részt külön modulba megírni. Ilyen esetben lesznek modul szintû állandóink és változóink. Ezeket hasznos az eljárások elé a modul elejére írni. Így mindig egy helyen kell keresnünk a dolgainkat. Az eljárások állandóit és változóit tegyük az eljárás elsõ soraiba. A cél megint az áttekinthetõség. Fontos, hogy deklarálhatunk olyan változókat is, melyek az adott eljárásban évényesek, de külsõ értékek feldolgozására alkalmasak. Ezek az eljárások paraméterei. Az eljárások paramétereit az eljáráson belül ugyanúgy használhatjuk, mintha ott deklaráltuk volna.

84



8. fejezet

Az adatok használata

ár tudjuk, hogy hogyan lehet változókat, állandókat meghatározni, deklarálni. Az adatokat azért tároljuk, mert fel szeretnénk dolgozni õket. A változók tartalmával különféle mûveleteket végezhetünk. A feldolgozás során matematikai, logikai és szöveges mûveleteket fogunk végrehajtani. A számításokban használt mûveleti jeleket operátornak nevezzük. A következõ fejezetben ismerkedjünk meg az adatokon végezhetõ mûveletekkel, mûveleti jelekkel. Ismét tegyünk fel kérdéseket! w Mit jelent az értékadás? w Milyen mûveleteket hajthatunk végre a tárolt adatokon? w Milyen mûveleti jeleket használhatunk?

Értékadás Egy-egy változónak adhatunk úgy is értéket, hogy egyszerûen egy egyenlõségjel mögé beírjuk azt az értéket, amit tárolni szeretnénk. Máskor egy számítás eredményét rögzítjük egy változóban. Mind két esetben értékadásról beszélünk. Kezdjük a legegyszerûbbel. Az intSzamlalo változóban tároljuk a 25-ös értéket. Ezt így kell a programba írni: intSzamlalo = 25

Ilyennel már találkozhattunk a korábbi fejezetekben is. De nézzük a további lehetõségeket. Az értékadás jobb oldalán nemcsak konstansok, konkrét értékek szerepelhetnek, hanem kifejezések is. Oda képleteket is írhatunk. A képletekben felhasználhatjuk a program változóit. Talán még emlékszünk a számláló értékadásra, ahol a jobb oldalon ugyanazt a változót használtuk, mint a baloldalon. intSzamlalo = intSzamlalo + 1

85


Értékadás Írjuk le a változó nevét és utána egy egyenlõségjelet. Az egyenlõségjel mögé írjuk ba azt az értéket vagy kifejezést, amit a változóban tárolni szeretnénk.


Visual Basic for Application A feldolgozás menete Az értékadás feldolgozása során a program minden esetben az egyenlõségjel jobb oldalára írt kifejezést dolgozza fel, majd az eredményt a bal oldalra írt véltozóba írja.

Objektumok tulajdonságai Az objeltumok tulajdonságai, nem mások, mint az objektumba zárt változók. Ezeknek értéket adhatunk, vagy kiolvashatjuk a tartal-

2. rész

Emlékezzünk arra is, hogy a Visual Basic milyen sorrendben dolgozza fel az elõzõ utasítássort. Elõbb elvégzi a jobb oldalon található számítást, majd az eredményt beírja a baloldali változóba. Az utasítás végrehajtása elõtt az intSzamlalo változónak van valamilyen értéke, de a parancs végrehajtása után ezt az értéket eggyel növeltük. Mielõtt rátérnénk az operátorokra, még egy kis idõt töltsünk el az értékadó utasításokkal. Az objektumokról szóló fejezetben olvashattunk, hogy az objektumok egyik jellemzõje az, hogy milyen tulajdonságai vannak. A tulajdonságok valójában az objektumban tárolt változók, melyek értékét beállíthatjuk a programban. A változókat csak az objektumok interfészén keresztül érhetjük el. Vagyis, ha egy objektum egyik tulajdonságát szeretnénk beállítani, akkor egy értékadó utasítást kell írnunk a programba. Ha például, azt szeretnénk, hogy az aktív munkalap A1-es cellájába bekerüljön egy adat, akkor a Range("A1") objektum Value tulajdonságába kell írnunk az adatot. Például így: Range("A1").Value = "Helló világ"

Az objektum tulajdonságai nem mások, mint az objektumba zárt belsõ változók. Ha ez így van, akkor ki is olvashatjuk az objektumok tulajdonságainak pillanatnyi tartalmát. A következõ kis eljárás ezt teszi! Kiolvassa az épp aktív munkalap A1-es cellájába írt értéket és kiírja az Immedate ablakba. Sub KiOlvas() Debug.Print Range("A1").Value End Sub

Még azt is megtehetjük, hogy egy objektum tulajdonságának tartalmát átadjuk egy másik objektum tulajdonságának. Egy érdekes példa! Ebben megismerkedünk a Not operátorral. Ez az operátor ellenkezõjére váltja egy logikai változó tartalmát. Ha True volt, akkor ettõl a mûvelettõl False-ra vált és viszont. Ez épp jó is! Ugyanis a munkalap cellarácsaikak a megjelenítését egy olyan tulajdonság határozza meg, melynek a tartalma egy logikai érték. A cellarácsok ki- bekapcsolását végzõ program tehát a következõ lesz: CD melléklet 08 fejezet Ertekadas.xls

Sub KiBe() ActiveWindow.DisplayGridlines = Not ActiveWindow.DisplayGridlines End Sub

86



8. fejezet


Operátorok

Operátorok

Ideje most már az operátorokkal foglalkozni. A Visual Basic operátorok lehetnek egy vagy több karakteresek. A matematikai operátorok – mûveleti jelek – többsége egy karakteres, míg a logikai operátorok több karakteresek.

A programban használt mûveleti jeleket operátoroknak nevezzük.

Aritmetikai operátorok Az aritmetikai operátorokkal matematikai mûveleteket végzünk. A Visual Basicben hét aritmetikai operátort használhatunk. Ebben benne van a négy alapmûvelet, a hatványozás, az egészszámú osztás és a maradékosztás. A matematikai alapmûveletet a 3. táblázatban találjuk. 3. táblázat: Aritmetikai operátorok Mûvelet

Operátor

Példa

Eredmény

Hatványozás

^

3^2

9

Szorzás

*

2*4

8

Osztás

/

7/3

2,3333

Egészosztás

\

7\3

2

Maradékosztás

Mod

7 Mod 3

1

Összeadás

+

7+4

11

Kivonás

-

7-4

3

A négy alapmûveletet valószínûleg mindenki ismeri, ahogy a hatványozást is. Mégis a hatványozás, egészosztás és maradékosztás operátorokról beszéljünk egy kicsit. A hatványozásról csak a mûveleti jel miatt ejtünk szót. Kicsit másként mûködik, mint a többi karakter, amit beírunk a programba. Írjunk eljárást, amiben hatványozunk, de közben figyeljünk arra is, hogy mikor jelenik meg a hatványozás operátora. A program számítsa ki kettõnek a harmadik hatványát. Az eredményt írja be az éppen aktív munkalap B2-es cellájába. 1. Írjuk be addig a programot, amíg azt a 88. oldalon látható 22. ábra 1. lépése mutatja! 2. Üssük le az Alt Gr+3 (betû billentyûzet) kombinációt. 3. Ne lepõdjünk meg! A hatványozás mûveleti jel nem jelenik meg. Ez a billentyû így mûködik! 4. Írjuk be a hatványkitevõt! Ez a mi példánkban 3.

87


Aritmetikai operátorok A számtan órán hsznált – matematikai – mûveleti jeleket aritmetikai operátornak nevezzük.



2. rész

5. A kitevõ beírása után megjelenik a mûveleti jel is! 6. Futtassuk le az eljárást, és nézzük meg az eredményt!

22. ábra: A hatványozás operátor beírása A következõ mûveleti jel az egészosztás mûveleti jele. Ezzel ritkábban találkozunk, ez a \ jel. Az egészosztás eredménye egy egész szám, vagyis az osztás eredményének a törtrészét, elhagyja a program. Ennek megfelelõen e 7\2 és a 6\2 eredménye mindét mûvelet esetén 3 lesz. De vajon mi lesz azzal a résszel, ami az osztásból megmaradt? Ezt egy újabb operátorral a maradékosztással számíthatjuk ki. Ennek az osztásnak az eredménye az egészosztás után maradt maradék. A maradékosztás mûveleti jele a modusz szó rövidítése a Mod. Például a 7 Mod 2 erdménye 1 lesz, hiszen az egészszámú osztás maradéka ennyi. A 10 Mod 6 eredménye 4.

A mûveletvégzés sorrendje Prioritás Azt, hogy melyik mûvelettel kezdi a számolást a program a mûveletek prioritásának nevezzük.

Matematika órákon tanultuk a mûveletek végrehajtási sorrendjét. Ezt a mûveletek prioritásának neveztük. Elõbb a szorzás és az osztás majd az összeadás és a kivonás. De itt több operátor van. A mûveletek végrehajtási sorrendjét a 4. táblázatból nézhetjük meg. Elõfordulhat, hogy nem megfelelõ számunkra ez a mûveletvégzési sorrend. Ezen a zárójelek alkalmazásával változtathatunk. Ebben az esetben – mint azt a matematikában is tanultuk – a legbelsõ zárójeltõl kezdve és onnan kifelé haladva fogja végrehajtani a program a mûveleteket.

88



8. fejezet


4. táblázat: Az aritmetikai mûveletek végrehajtási sorrendje Mûvelet

A végrehajtás sorrendje

Hatványozás (^)

1.

Szorzás (*)

2.

Osztás (/)

2.

Egészosztás (\)

3.

Maradékosztás (Mod)

4.

Összeadás (+)

5.

Kivonás (-)

5.

Szövegkezelõ operátorok A szövegekkel kétféle mûveletet végezhetünk. Az egyik a szöveg összevonás mûvelete a másik a helyettesítõ karakteres összehasonlítás. Szövegösszevonás w Ennek operátora a &. Ezt az operátort arra használhatjuk, hogy két vagy több szöveges kifejezést – ez lehet szövegállandó, szöveg tartalmú változó vagy szöveges eredményû számítás – egymás mögé helyezzük. Erre egy kicsit romantikus példa, amikor Rómeó nevét tároljuk az egyik változóban, a másikba Júlia nevét írjuk, és a két változó tartalmát egy eredmény változóban együtt összevonva, együtt tároljuk. Íme a program, amely összeadja Rómeót és Júliát: Sub Osszevon() Dim strFiu As String Dim strLany As String Dim strEgyutt As String strFiu = "Rómeó" strLany = "Júlia" strEgyutt = strFiu & " és " & strLany Debug.Print strEgyutt End Sub

A szövegösszevonás mûveletet konkatenációnak nevezzük. Ezt a mûveleti jelet arra használhatjuk, hogy összefûzzük a szövegeket egy szöveggé.

CD melléklet 08 Fejezet Szoveges.xls

Like operátor

A program eredménye, hogy az strEgyutt változó tartalma „Rómeó és Júlia”. Helyettesítõ karakterek w A másik szöveges operátor a Like. Ezt a mûveleti jelet arra használhatjuk, hogy egy tetszõleges szövegrészrõl megmondjuk, tartalmazza-e az általunk keresett karaktersort. Ezzel már találkozhattunk,

89


Konkatenáció

A Like operátor segítségével szövegtöredékeket hasonlíthatunk össze. Az összehasonlításra helyettesítõ karaktereket használunk,



2. rész

amikor az operációs rendszerben egy fájl nevébõl csak egy kisebb részletet ismertünk. Ilyenkor helyettesítõ karaktereket használtunk. Most is ezt fogjuk tenni. A mûveleti jel bal oldalára a vizsgált szöveget írjuk, a jobb oldalra pedig azt a helyettesítõ karaktereket tartalmazó szöveg típusú értéket. Ha például, azt szeretnénk megvizsgálni, hogy a szöveg kezdõ betûje A betû, akkor ezt a következõ paranccsal tehetjük meg: CD melléklet 08 Fejezet Szoveges.xls

Sub VanABenne() Debug.Print "Alkalmazott" Like "A*" End Sub

Ha a fenti eljárást lefuttatjuk, akkor az Immediate ablakban a True érték jelenik meg. A * helyettesítõ karakter ugyanis egy vagy több karakternyi szöveget helyettesíthet. Ezzel az összehasonlítással tehát azt vizsgáltuk, hogy a bal oldali szöveg A betûvel kezdõdik, és nem vizsgáltuk az elsõ betût követõ további karaktereket. Most vizsgáljuk meg azt, hogy a jobb oldalra írt szövegben miket adhatunk meg? Szemléltesse a lehetõségeket egy-egy kis példa egy-egy rövid magyarázat kíséretében. A kérdõjel helyettesítõ karaktert ismerjük az operációs rendszerbõl. Ezzel egy betût helyettesíthetünk. Most írjunk egy rövidke programot, ami azt ellenõrzi, hogy a baloldalra írt szöveg második karaktere l betû. Itt a kérdõjel helyettesítõ karakterre lesz szükségünk. CD melléklet 08 Fejezet Szoveges.xls

Sub Masodikl() Debug.Print "Alma" Like "?l*" End Sub

A kérdõjel helyettesítõ karakter helyén bármilyen betû állhat, Az eredmény azért lett igaz, mert az alma szó második betûje l. A záró csillag helyettesítõ karakter szerepe az, hogy ne vegye figyelembe az l betût követõ karaktereket. Ha a mûvelet bal oldalára olyan szót írunk, amelynek a második betûje nem l, akkor az eredmény False lesz. Hasonló módon kereshetünk rá bármilyen számra. Tegyük fel, hogy olyan értéket keresünk, melynek az elsõ karaktere szám. Ebben az esetben a kérdõjelet nem használhatjuk, mert az nem csak a számokat helyettesíti, hanem bármelyik karaktert. Számot is, betût is. A számjegyek helyettesítésére a # karakter szolgál. Vessük össze a ? és a # helyettesítõ karakter eredményét. CD melléklet 08 Fejezet Szoveges.xls

Sub SzamJegy() Debug.Print "4-es" Like "#-es" 'az eredmény True Debug.Print "e-es" Like "#-es" 'az eredmény False Debug.Print "4-es" Like "?-es" 'az eredmény True

90



8. fejezet


Debug.Print "e-es" Like "?-es" 'az eredmény True End Sub

Az elsõ két sorban a # helyettesítõ karaktert használtuk. A második sor eredménye azért lett False (hamis) mert ott az elsõ karakter helyére szöveget írtunk. A harmadik és negyedik sor mindkét esetben True eredménnyel járt, mert a kérdõjel nem tesz különbséget a számjegyek és a betû karakterek között. A # minden esetben csak egyetlen számjegyet helyettesít. Vagyis, ha arra lennénk kíváncsiak, hogy az elsõ két karakter helyén szám van-e, akkor két # helyettesítõ karaktert kéne oda írnunk. Úgy is használhatjuk a Like operátort, hogy egy adott karakterpozícióban nem egy betûre keresünk rá, hanem többre. A példa talán kissé egyszerû, de jól szemlélteti a szögletes zárójelek közé írt betûk feladatát. A szögletes zárójelek között felsorolt betûk egy karakterhelyre helyettesítenek. Vizsgáljuk meg, hogy a baloldalon Kata, vagy Kati szerepel-e, de ha Kató van a baloldalon, akkor hamis legyen az eredmény. Sub KatiKato() Debug.Print "Kata" Like "Kat[ai]" ' az eredmény True Debug.Print "Kati" Like "Kat[ai]" ' az eredmény True Debug.Print "Kató" Like "Kat[ai]" ' az eredmény False End Sub


A harmadik eset azért ad False (hamis) eredményt, mert a szögletes zárójelek közötti felsorolásban nem szerepel az ó betû. A Like operátort és a szögletes zárójel helyettesítõ karaktert arra is használhatjuk, hogy a egy betûtartományra keressünk rá. Tegyük fel, hogy azokat az értékeket szeretnénk megtalálni, amelyek az ábc elsõ részébe esnek. Vagyis azokra az értékekre szeretnénk igaz értéket kapni eredményül. Ahol a bal oldali szöveg elsõ betûje az a és a az l betûk közé esik. Ezt a következõ utasítássorral adhatjuk meg: Sub AbcEleje() Debug.Print "Alagi" Like "[A-L]*" ’ az eredmény True Debug.Print "Marosi" Like "[A-L]*" ’ az eredmény False End Sub


Ha ennek fordítottjára lenne szükségünk, akkor ugyanezt a parancsot használhatjuk, csak a szögletes zárójelek között felkiáltójellel kell kezdenünk a helyettesítést. Az elõzõ példával ellentétes eredményt ad a következõ eljárás: CD melléklet 08 Fejezet

Sub AbcVege() Debug.Print "Alagi" Like "[!A-L]*" ’ az eredmény False

Szoveges.xls

91




2. rész

Debug.Print "Marosi" Like "[!A-L]*" ’ az eredmény True End Sub Optiont Compare Text Ezzel a paranccsal beállíthatjuk az adott modul összehasonlítását úgy, hogy ne különböztesse meg a kis- és nagybetûket.

A Like operátor alapértelmezett összehasonlítási módja bináris. Ez azt jelenti, hogy különbséget tesz a kis és nagybetûk között. Ha az eljárásokon kívülre beírjuk az Option Compare Text sort a Visual Basic azonosnak tekinti az adott betû kis és nagy változatát. A Like operátor helyettesítõ karaktereit a 5. táblázatban foglaltuk össze: 5. táblázat: Helyettesítõ karakterek Karakter

Mit helyettesít?

*

Egy vagy több karaktert helyettesít.

?

Egyetlen szöveg vagy szám karaktert helyettesít.

[...]

Egy karakter helyre helyettesíti a zárójelek közé írt betûket, vagy számokat, vagy a kötõjelekkel írt karakterek tartományát.

[!...]

Egy karakter helyre kihagyja a zárójelek közé írt betûket, vagy számokat, vagy a kötõjelekkel írt karakterek tartományát.

#

Egy pozícióra bármilyen szám helyettesítésére szolgál.

Összehasonlító operátorok Összehasonlító operátor Az összehasonlító operátorokkal két vagy több változó értékét vethetjük össze. A mûvelet eredménye csak True (igaz) vagy False (hamis) lehet.

CD melléklet 08 Fejezet Logikai.xls

A program futása közben különbözõ változók tartalmától tehetjük függõvé, hogy milyen mûveletekkel folytatjuk a programot. A változók tartalmának összehasonlítására használjuk a összehasonlító operátorokat. Az összehasonlító operátorok felhasználásával olyan kifejezéseket hozhatunk létre, melynek az eredménye True (igaz) vagy False (hamis) logikai érték. Azokat a kifejezéseket, amelyek csak True vagy False eredményt adhatnak, logikai kifejezéseknek is nevezzük. Ha a logikai kifejezések eredményét szeretnénk megõrizni, akkor Boolean típusú változót kell használnunk. Nézzünk egy egyszerû programrészletet, amelyben egy logikai kifejezés szerepel. Dim bolIgazE As Boolean Dim sngSzam_1 As Single Dim sngSzam_2 As Single sngSzam_1 = 18.23 sngSzam_2 = 17.45 bolIgazE = sngSzam_1 < sngSzam_2

92



8. fejezet


A két változó közé írt < jel egy összehasonlító operátor. A kifejezés eredménye False lesz, mert nem igaz a feltételezés, miszerint a 18,23 kisebb mint 17,45. Ennél persze több összehasonlító operátort is használhatunk. Ezeket soroljuk fel a 6. táblázatban. 6. táblázat: Az összehasonlító operátorok Operátor

Példa

Hogy olvassuk a kifejezést?

Eredmény

=

7=3

Igaz az állítás, hogy hogy 7 egyenlõ 3-al?

False (hamis)

>

7>3

Igaz az állítás, hogy 7 nagyobb mint 3?

True (igaz)

<

7<3

Igaz, hogy 7 kisebb mint 3?

False (hamis)

>=

7 >= 3

Igaz, hogy 7 nagyobb vagy egyenlõ mint 3?

True (igaz)

<=

7 <= 3

Igaz, hogy 7 kisebb vagy egyenlõ mint 3?

False (hamis)

<>

7 <> 3

Igaz, hogy 7 nem egyenlõ 3-al?

True (igaz)

A válasz a feltett kérdésekre csak igaz True vagy hamis False lehet. De mit kell tennünk, ha egyszerre több kérdésünk is van? További logikai operátorokat használunk.

Logikai operátorok A logikai operátorok arra szolgálnak, hogy egyszerre több logikai összehasonlítás eredményét összevonjuk. A logikai operátorokkal olyan értékeket dolgozhatunk fel, melyek logikai eredménnyel – True vagy False – rendelkeznek. A logikai operátorok használata is logikai kifejezést eredményez, vagyis ezek eredménye is csak True vagy False lehet. Ilyen kifejezéseket a mindennapi életben is használunk. Például ahhoz, hogy együnk több feltételnek is teljesülnie kell. Ha éhes vagyok és van mit enni, akkor eszem! Itt két feltételtõl is függ, hogy eszem-e vagy sem. Hiába vagyok éhes, ha nincs mit enni, de hiába van ennivaló, ha nem vagyok éhes. A két feltételt összehasonlító operátorokkal vizsgálhatjuk meg, miszerint vagy igaz, hogy éhes vagyok vagy hamis, ugyanúgy, minthogy az is igaz vagy hamis lehet hogy van-e ennivaló a közelben. Tegyük fel, hogy két logikai változót vizsgálunk bolX és bolY értékét. Minkét változóban csak True vagy False értékeke lehetnek. A logikai operátorok felsorolását a 94. oldalon található 7. tálázatban gyûjtöttük egybe. Már csak az a kérdés, hogy mire használhatjuk a logikai kifejezéseket. Erre kapunk választ a következõ fejezetben, ahol a programvezérlõ utasításokat ismerhetjük meg.

93


Logikai operátorok A logikai operátorokkal olyan kifejezéseket dolgozhatunk fel melyek értéke True vagy False.



2. rész

7. táblázat: Logikai operátorok Operátor

Mikor True (igaz) az eredmény?

And (és)

Az eredmény akkor és csak akkor True, ha egyszerre egy idõben az összes vizsgált érték True. Vagyis, ha mind bolX és bolY tartalma True.

Or (vagy)

A vagy logikai mávelet minden esetben True (igaz) éertket ad vissza, ha bármelyik vizsgált érték True (igaz) értéket tartamaz. Máshogy fogalmazva vagy ennek vagy annak, de legalább egynek igaznak kell lennie.

Xor (kizáró vagy)

Ha a Xor mûveletet végzünk, akkor annak az eredméyne akkor ad True értéket eredményül, ha a vizsgált változók nem azonos értékeket tárolnak. Vagyis, ha az összes vizsgált érték True vagy mind False, akkor az eredmény False, egyébként True.

Eqv (ekvivalencia)

Az xor mûvelet párja az eqv. Ez a mûvelet az egyezõséget vizsgálja. Ha az összes változó vagy True vagy False érték, az eredmény True, egyébként False.

Not (negálás)

Ez egy logikai változó tartalmát váltla át ellenkezõ értékûre. Ha egy logokai érték elé írjuk, akkor ha az Treu volt False eredményt ad, ha False volt az eredmény True lesz.

Összefoglalás A változóknak értéket adhatunk. Azt a változót, aminek értéket adunk, mindig az egyenlõségjel bal oldalára írjuk. Az egyenlõségjel jobb oldalán vagy egy konstans érték vagy egy kifejezés állhat. A Visual Basic, minden esetben az egyenlõségjel jobb oldalára írt kifejezés kiértékeléséval kezdi, majd az eredményt a bal oldali változóba írja. Ennek megfelelõen, a változó, aminek értéket adunk állhat az egyenlõségjel jobb oldalán is. Ebben az esetben a jobb oldalon felhasznált változó a kiinduló értéket tartalmazza, ami a mûvelet végrehajtása után megváltozik a jobb oldalon meghatározott számításnak megfelelõen. Az értékadó mûveletekben az egyenlõségjel jobb oldalára írt kifejezésekben mûveleti jeleket használunk. Ezeket a számítástechnikában operátoroknak nevezzük. Az operátorok állhatnak több betûbõl is. Gondoljunk a Mod, az And vagy az Or operátorokra.

94



9. fejezet

Programvezérlõ utasítások érjünk át a programvezérlõ utasítások megismerésére. Mint azt más az alapfogalmak részben olvastuk, bármilyen programot megírhatunk három utasítástípussal. Ezek a szekvencia, a szelekció és az iteráció. A szekvencia utasítástípussal külön nem foglalkozunk. Ez az utasítástípus például az értékadás, vagy egy eljárás meghívása. Máskor ezek segítségével változtatjuk meg egy-egy objektum tulajdonságait. Ebben a fejezetben a szelekció és iteráció utasítástípusokkal ismerkedünk. A fejezetben különös figyelmet fordítunk az adatfeldolgozás és a vezérlések kapcsolatára. Keressük a választ a következõ kérdésekre: w Hogy ágazhatunk el a programban? w Hogy függ össze az adat és a feldolgozás? w Hogyan ismételhetünk meg programrészeket?

Elágazások (szelekciók) Az elágazás vezérlõ utasítások segítségével a változók vagy objektum-tulajdonságok kiértékelése után más-más utasításcsoportokat hajthatunk végre. A kiértékelést az elõzõ fejezetben olvasott összehasonlító és logikai operátorokkal végezzük el. A Visual Basic szelekciós – elágazási – parancsai az If és a Select.

If... Then... Else elágazás Ezzel az elágazással logikai kifejezések segítségével kiértékelhetjük a feldolgozás alatt álló változókat. Mind azt az elõzõ fejezeten láttuk a logikai kifejezések eredménye True (igaz) vagy False (hamis) lehet. Attól függõen, hogy mi lett a logikai kifejezés értéke más-más utasításcsoportot hajthatunk végre. 95


Elágazások Az elágazás utasítástípus a programban tárolt változók tartalmától függõen a program más-más sorait hajtják végre.



2. rész

Egysoros If szelekció w Az If elágazásnak két szintaktikája – írási módja – is van. Az egysoros és a többsoros. Az egy soros a következõ: If logikai_kifejezés Then Utasítás_1 Else Utasítás_2

Ez a rövid írásmód. Ezt akkor használjuk, amikor a logikai kifejezés eredményétõl függõen csak egy utasításban tér el a program. Természetesen itt meghívhatunk általunk írt eljárásokat is, hiszen azok is egy utasításnak számítanak. Ha a logikai_kifejezés értéke True, akkor az Utasítás_1 kerül végrehajtásra, ellenkezõ esetben – vagyis, ha False az eredmény –, akkor az Utasítás_2 parancsot fogja végrehajtani a program. Ennél rövidebb már csak akkor lehet az If utasítás, ha nincs szükségünk az utasítás Else ágára. Többsoros If szelekció w Amikor a logikai kifejezés eredményétõl függõen nem csak egy utasítás az eltérés, akkor a többsoros írásmódot használunk. Ez a következõ: If logikai_kifejezés Then Utasítás_1 Utasítás_2 ...... Else Utasítás_3 Utasítás_4 ...... End If

Ez az írásmód úgy mûködik, hogy amikor a logikai kifejezés értéke True, akkor az If és Else közötti utasításokat hajtjuk végre, az Else és End If közötti részt átugorja a program. Ha pedig a kifejezés eredménye False, akkor az If és Else közé írt utasításokat hagyjuk figyelmen kívül, és az Else és End If közötti utasításokat végzi el a program. Több feltétel vizsgálata w Az If szerkezet teljes írásmódjában több feltételt is vizsgálhatunk. Ennek az írásmódja: If logikai_kifejezés_1 Then Utasítás_1 Utasítás_2 ...... ElseIf logikai_kifejezés_2 Then Utasítás_3 Utasítás_4

96



9. fejezet

Programvezérlõ utasítások

...... ElseIf logikai_kifejezés_n Then Utasítás_5 Utasítás_6 ...... Else Utasítás_7 Utasítás_8 ...... End If

Az If elágazásban annyi ElseIf sort írunk be, amennyit akarunk. Ebben a tekintetben nincs korlátozás. Természetesen minden ElseIf mögött más-más logikai kifejezést értékelnünk ki. Fontos szem elõtt tartani, hogy egy If utasításban csak egy utasításcsoport kerül végrehajtásra. Ez azt jelenti, hogy ha igaz a logikai_kifejezés_1 és a logikai_kifejezés_2 kifejezés értéke, akkor is csak egy ágba lép be a program. Tehát a példában az elsõ ág utasításait végrehajtja a program, de a második ágba akkor sem lép be a program, ha ennek a kifejezésnek is True az értéke.

Az If... End If szelekció alkalmazása Az utasítások mûködésérõl akkor szerezhetünk igazi tapasztalatokat, ha ki is próbáljuk õket. Hozzunk létre egy új munkafüzetet, és illesszünk be egy általános modult! A modul neve legyen Vezerles. Ebben a modulban fogjuk kipróbálni azokat a vezérlõ utasításokat, amelyekrõl ebben a fejezetben olvasunk. A feladat az lesz, hogy a megnyitott munkafüzet A1-es cellájába beírunk egy számot, és a beírt szám értékétõl függõen a B1-es cellába írassunk ki egy értékelõ szöveget. Ha az A1-es cella tartalma negatív szám, akkor a „Kisebb mint nulla.”, ha pozitív, akkor a „Nagyobb mint nulla.” ha pedig pont nulla, akkor a „Nulla” szöveg jelenjen meg. A programot igyekezzünk úgy megírni, hogy felhasználjuk a tanultakat! Deklaráljunk megfelelõ állandókat és változókat! Valahogy így! Sub If_Teszt_1() ‘ ——- Állandók deklarálása ——Const STR_NAGYOBB As String = "Nagyobb, mint nulla." Const STR_KISEBB As String = "Kisebb, mint nulla." Const STR_NULLA As String = "Nulla." ‘ ——- Változók deklarálása ——Dim sngCellaErtek As Single Dim strEredmeny As String

CD melléklet 09 Fejezet Vezerlesek.xls

97




2. rész

‘——- Adat bekérés ——sngCellaErtek = Range("A1") ‘——- Az adat feldolgozása ——If sngCellaErtek > 0 Then strEredmeny = STR_NAGYOBB ElseIf sngCellaErtek < 0 Then strEredmeny = STR_KISEBB Else strEredmeny = STR_NULLA End If ‘ ——- Eredmény kiírása ——Range("B1") = strEredmeny End Sub

Az eljárás elemzését kezdjük az adatbekérést végzõ sorral. sngCellaErtek = Range("A1")

Ebben a sorban beolvassuk a program sngCellaErtek változóba az éppen aktuális munkafüzet, aktuális munkalapján található A1-es cella tartalmát. A program további részében már nem fordulunk közvetlenül a elemzésre váró cellához, hanem a változóban tárolt értékkel dolgozunk tovább. Az így változóba írt értéket ki fogjuk elemezni. Erre szolgál a következõ utasítássor: If sngCellaErtek > 0 Then

Az sngCellaErtek > 0 összehasonlító kifejezés eredménye csak kétféle lehet, True vagy False. Ha a kifejezés értéke True, akkor a következõ utasításban az eredményt változóba beírjuk a megfelelõ konstans értékét, vagyis azt, ami a „Nagyobb, mint nulla” értéket tartalmazza. Ha teljesült a feltétel, akkor az If-bõl kilép a program, az End If sort követõ paranccsal folytatja tovább a program végrehajtását. Ha a feltétel nem teljesül – False eredményt ad a kifejezés kiértékelése –, akkor átlépünk a következõ kiértékelõ sorra. ElseIf sngCellaErtek < 0 Then

Ebben a sorban az összehasonlító kifejezéssel azt vizsgáljuk, hogy a feldolgozandó érték kisebb-e, mint nulla,a ha igen, akkor az eredmény változó értékébe beírjuk az STR_KISSEBB állandó tartalmát. Ha nem teljesül a feltétel, akkor az If parancs Else ágát hajtjuk végre. Vagyis, ha nem nagyobb és nem kisebb, mint nulla, akkor nem lehet más csak nulla.

98



9. fejezet


Az Else ágban tehát az eredmény strEredmeny változóba beírjuk a „Nulla” értéket. Az eljárás utolsó sorában már nincs más dolgunk, mint az eredményt kiírni a megfelelõ cellába. Ezt hajtja végre a következõ utasítás: Range(“B1") = strEredmeny

Fontos megjegyezni, hogy az If elágazás minden esetben csak egy elágazási ágba lép be. Ha az egyik feltétel igaznak bizonyul, akkor a program minden esetben az End If sort követõ parancsra lép.

Select Case szelekció Visual Basic for Application másik elágazást végrehajtó utasítása a Select. Ebben az utasításban egyetlen kifejezést vizsgálunk, és annak értékétõl függõen ágazunk el a programban. Az elágazás elsõ sorába írjuk le azt a kifejezést, amelyet vizsgálunk. A Case utasítások mögé pedig azt, hogy a kifejezés milyen értéke esetén kell belépni az elágazásba. A Select Case szerkezetet a következõ módon kell leírnunk: Select Case vizsgalt_kifejezes Case Ertek_1 ... Utasítás_1 Utasítás_2 .... Case Ertek_2 ... Utasítás_3 Utasítás_4 .... Case Ertek_n ... Utasítás_5 Utasítás_6 .... Case Else ... Utasítás_7 Utasítás_8 .... End Select

99


Select Case Ezzel az elágazással egy kifejezést értékelünk ki, és annak a tartalmától függõen lépünk be a program egy ágába.



Több érték Egy Case utasíás mögött több értéketsorolhat unk fel.

Értékhatár A kezdõ és végértéke közé írjuk be a To kulcsszót.

2. rész

A Visual Basic végiglépked a Case sorokon, és összehasonlítja a kifejezés pillanatnyi értékét a Case mögé írt értékkel. Ha a kifejezés értéke egyezik a Case mögé írt értékkel, akkor belép az elágazásba, ha nem tovább lép a következõ vizsgálatra. Ha a vizsgálat során egyetlen feltétel sem teljesült, akkor a Case Else ágba írt utasításokat végzi el a program. A Case Else ág elhagyható. Hasonlóan az If szelekcióhoz most is csak egy ágba lépünk be. Vagyis azt az ágat hajtjuk végre, ahol elõbb találunk egyezést. Az egyes Case utasítások mögött figyelhetünk akár több értéket is. Ezeket egymástól vesszõvel elválasztva soroljuk fel. Például: Case 1,4,5,8,9

Ez a vizsgálat több érték esetén is True – igaz. Ha a vizsgalt_kifejezes értéke egy, négy, öt, nyolc vagy kilenc, akkor ebbe az ágba fog belépni a program. Úgy is figyelhetünk több értéket, hogy a Case mögött megadjuk azt a legkisebb és a legnagyobb olyan értéket, amely esetén szeretnénk végrehajtani az elágazást. Ezt a következõ módon adhatjuk meg: Case 3 To 7

Ebbe az ágba akkor lépünk be, ha a vizsgált kifejezés értéke három és hét közé esik. Ha akkor szeretnénk belépni az egyik Case ágba, amikor a vizsgált kifejezés nagyobb, mint egy meghatározott érték, akkor az Is kulcsszót használjuk a következõ írásmóddal: Kisebb vagy nagyobb Ha kisebb vagy nagyobb érték hatására szeretnénk belépni egy ágba, használjuk az Is kulcsszót

Case Is > 100

Ebbe az ágba akkor jut be a program, ha a vizsgált kifejezés értéke nagyobb, mint 100. A különbözõ vizsgálati típusokat egymással kombinálva is használhatjuk. Tehát lehet egy Case mögött értékfelsorolás, értéksáv és minimum érték. Például: Case 1, 4, 12 To 17 , Is > 100

A Select Case szerkezetben a vizsgált kifejezés lehet egy változó tartalma vagy egy számított érték. Ezzel a két elágazó szerkezettel tudjuk meghatározni, hogy a program egyes részei mikor kerüljenek végrehajtásra.

100



9. fejezet


A Select Case Alkalmazása Készítsünk egy olyan eljárást, amelyik egytõl hétig terjedõ egész számokat dolgozunk fel. Az aktív munkalap A2-es cellájába írjunk egy számot egy és hét között. Tételezzük fel, hogy ez a hét napjának a sorszáma. Az eljárás futtatása után a B2-es cellába írjuk be szövegesen a hét napjának a nevét. Az eljárást nevezzük el Select_teszt_1 névvel. A program a következõ lehet: Sub Select_Teszt_1() ‘ Álandók deklarálása Const STR_INPUT_CELLA As String = "A2" Const STR_OUTPUT_CELLA As String = "B2" Const STR_NAP_1 As String = "hétfõ" Const STR_NAP_2 As String = "kedd" Const STR_NAP_3 As String = "szerda" Const STR_NAP_4 As String = "csütörtök" Const STR_NAP_5 As String = "péntek" Const STR_NAP_6 As String = "szombat" Const STR_NAP_7 As String = "vasárnap" Const STR_NAP_HIBA As String = "Nem megfelelõ érték!" ‘Változók deklarálása Dim sngCellaErtek As Single Dim strEredmeny As String ‘ A feldolgozandó adat beolvasása sngCellaErtek = Range(STR_INPUT_CELLA) ‘ Adatfeldolgozás sngCellaErtek = Int(sngCellaErtek) Select Case sngCellaErtek Case 1 strEredmeny = STR_NAP_1 Case 2 strEredmeny = STR_NAP_2 Case 3 strEredmeny = STR_NAP_3 Case 4 strEredmeny = STR_NAP_4 Case 5 strEredmeny = STR_NAP_5 Case 6 strEredmeny = STR_NAP_6 Case 7 strEredmeny = STR_NAP_7 Case Is < 1, Is > 7


101




2. rész

strEredmeny = STR_NAP_HIBA End Select ‘ A feldolgozás eredménye Range(STR_OUTPUT_CELLA) = strEredmeny End Sub

Futassuk le az eljárást, ismerkedjünk egy kicsit a mûködésével. Vegyük észre, hogy ebben az eljárásban, az állandók között rögzítettük a bemeneti és kimeneti cella nevét. Ez azért lehet hasznos, mert, ha változtatni akarunk a programon, nem kell végignéznünk a teljes eljárást. Elegendõ az eljárás elején az állandók tartalmát beállítani a megfelelõ értékre. Most nézzük meg a feldolgozás elsõ sorát: sngCellaErtek = Int(sngCellaErtek)

Itt a bekért adatról levágjuk a tizedes értéket. Erre azért van szükség, mert a felhasználó beírhat a cellába tört számot is. A 3,8, még szerda. Az Int függvény, csak a szám egész részét adja eredményül. Az eljárás többi részét, önállóan elemezzük ki! A szükséges ismereteket, már tudjuk. A Select további lehetõségeinek megismeréséhez készítsünk olyan eljárást, amelyik megválaszolja, hogy egy sorszámmal beírt hónap melyik évszakba esik. Az aktív munkalap A3-as cellájába írjunk be egy számot egy és tizenkettõ között. A B3-as cellában jelenítsük meg azt, hogy a hónap melyik évszakba esik. Ebben az eljárásban kipróbálhatjuk azt, hogy hogyan mûködik a Case mögé írt felsorolás. Az eljárás neve legyen Select_Teszt_2. Íme egy lehetséges megoldás: Sub Select_Teszt_2() ‘ Állandók deklarálása Const STR_INPUT_CELLA As String = "A3" Const STR_OUTPUT_CELLA As String = "B3" Const STR_TAVASZ As String = "Tavaszi hónap!" Const STR_NYAR As String = "Nyári hónap!" Const STR_OSZ As String = "Õszi hónap!" Const STR_TEL As String = "Téli hónap!" Const STR_HO_HIBA As String = "Nem megfelelõ érték!" ‘Változók deklarálása Dim sngCellaErtek As Single Dim strEredmeny As String ‘ Adatfeldolgozás sngCellaErtek = Range(STR_INPUT_CELLA) sngCellaErtek = Int(sngCellaErtek) Select Case sngCellaErtek Case 3 To 5

102



9. fejezet


strEredmeny = STR_TAVASZ Case 6 To 8 strEredmeny = STR_NYAR Case 9 To 11 strEredmeny = STR_OSZ Case 12, 1, 2 strEredmeny = STR_TEL Case Is < 1, Is > 12 strEredmeny = STR_HO_HIBA End Select ‘Eredmény kiírása Range(STR_OUTPUT_CELLA) = strEredmeny End Sub

Ciklusok (iterációk) Most elevenítsük fel egy kicsit azt a részt, ahol a változókról olvastunk. Akkor beszéltünk a tömbökrõl. Most a tömbökben, gyûjteményekben tárolt adatok feldolgozásáról lesz szó. Tömbökben tárolt adatok feldolgozása esetén ugyanazokat a lépéseket hajtjuk végre minden tömbelem feldolgozásakor. Annyiszor kell megismételni a lépéseket, ahány eleme a tömbnek van. Sorra kell vennünk a tömbben tárolt adatokat. A tömbben tárolt adatok feldolgozásához ciklust kell szerveznünk. A Visual Basic for Application nyelvben a következõ ciklusokat valósíthatjuk meg:

For.... Next iteráció Kezdjük az egy dimenziós tömbök feldolgozásával! Erre a For-Next ciklust használhatjuk. Ebben a ciklusban megadhatjuk a tömbváltozó elsõ és utolsó elemének a számát. A ciklusban „végig lépkedhetünk” a tömb elemein. A ciklus megvalósításához szükségünk lesz egy változóra, amelyben az aktuális lépés sorszámát tároljuk. Ezt a változó a ciklusszámláló. Ennek a változónak az értékét minden ismétléskor eggyel megnöveli a Next sor. Ennek a ciklusnak a legegyszerûbb formája a következõ: Dim intSzaml As Integer For intSzaml = Kezdoertek To Vegertek Step Lepes .... A ciklustest utasításai .... Next intSzaml

103


Iteráció A környezeti változóktól függõen többször hajthatunk végre egy programrészletet.


Visual Basic for Application A For Next mûködése

2. rész

1. Amikor legelõször rálépünk a ciklus elsõ – For – utasítására, a számláló – intSzaml – felveszi a kezdõ értéket – Kezdoertek. 2. Már itt rögtön a kezdõ lépéskor a számlálót tartalmazó változó értékét megvizsgáljuk, hogy elérte-e a végértéket. Ezt minden esetben megteszi a program, amikor a For sort hajtja végre. 3. Ha a számláló nagyobb vagy egyenlõ, mint a meghatározott végérték –Vegertek –, akkor a Next kulcsszót követõ utasítással folytatjuk az utasítások végrehajtását. 4. Ha a számláló értéke kisebb, mint a meghatározott végérték – Vegertek tartalma –, akkor a For kulcsszót követõ utasítással folytatjuk a program végrehajtását. 5. Ha a negyedik lépés következett be, akkor – a ciklustestbe írt utasítások végrehajtása után – eljutunk a Next utasításig. Itt megnöveljük a számláló értékét, annyival, amennyivel a For sorban a Step kulcsszó mögött – a Lepes változóban – meghatároztuk. A Step kulcsszó nem kötelezõ. Ha nem adjuk meg, akkor automatikusan eggyel fog növekedni a ciklusszámláló értéke. 6. Innen ismét visszalépünk a For sorra. A mûvelet ennek a listának a 2. lépéstõl folytatódik. Vagyis megvizsgáljuk, hogy a ciklusszámláló értéke egyenlõ vagy nagyobb, mint a végérték. A kezdõérték, végérték és a lépés bármilyen kifejezés, állandó vagy beírt érték lehet. A lépésköz értéke lehet negatív szám is. Ilyenkor a kezdõértéknek nagyobbnak kell lennie, mint a végértéknek.

A For Next alkalmazása Természetesen most is készítünk egy egyszerû példát, amelyben megvizsgáljuk a ciklus mûködését. Illesszünk be egy új általános modult, és ebbe írjuk meg a For ciklus kipróbálására szolgáló eljárást. Vektor feldolgozása Vektor, vagy egydimenziós tömb feldolgozásakor egy ciklusban oldjuk meg a feladatot.


Egy dimenziós tömb feldolgozása w A feladat a következõ! Kérjünk be a felhasználótól öt különbözõ értéket egy ötelemû tömbbe. Kössük ki, hogy csak egy és tíz közötti értéket szabad beírni. Az adatok bekérése után vizsgáljuk meg, hogy hányszor kaptunk hatnál kisebb számot. Az adat bekérésére használjuk az Inputbox függvényt. Sub For_Next_teszt_1() ‘—- Állandók deklarálása —Const STR_IN_CIM As String = "Számok bekérése" Const STR_IN As String = ". szám?" Const STR_OUT_CIM As String = "A kisebbek száma!" Const STR_OUT As String = "db kisebb szám volt, mint " Const INT_HATAR As Integer = 6

104



9. fejezet


‘—- Változók deklarálása —Dim intI As Integer Dim sngSzamok(1 To 5) As Single Dim bytKisebbek As Byte ‘—- Kezdeti értékadás, adatbekérés —bytKisebbek = 0 For intI = 1 To 5 sngSzamok(intI) = InputBox(intI & STR_IN, STR_IN_CIM) Next intI ‘—- Feldolgozás —For intI = 1 To 5 If sngSzamok(intI) < INT_HATAR Then bytKisebbek = bytKisebbek + 1 End If Next intI ‘—- Eredmény kiírása —MsgBox bytKisebbek & STR_OUT & INT_HATAR End Sub

Ebben az eljárásban szándékosan bontottuk két részre az adatbekérést és a feldolgozást, hogy szemléltethessük egy tömb változó feldolgozását. De nézzük a fontosabb részleteket! For intI = 1 To 5 sngSzamok(intI) = InputBox(intI & STR_IN, STR_IN_CIM) Next intI

Ebben a részben az Inputbox függvény felhasználásával bekértük az összes feldolgozandó adatot. Az adatokat egy tömbben tároltuk. Mire a ciklus ötször megismétli a testébe írt utasításokat, a tömb elemeiben a begépelt értékek vannak. Érdemes megfigyelni, hogy a ciklusszámláló pillanatnyi értékét használtuk fel arra, hogy a ciklustest, minden ismétlésekor újabb tömbelembe írjunk adatot. For intI = 1 To 5 If sngSzamok(intI) < INT_HATAR Then bytKisebbek = bytKisebbek + 1 End If Next intI

A feldolgozást hasonlóan írtuk meg. A ciklusszámláló értékét az elsõ lépésben visszaállítottuk a megfelelõ kezdõ értékre. A ciklustestben lévõ If-End If utasítást arra használtuk, hogy megvizsgáljuk, mekkora értéket írt a felhasználó az aktuális tömbelembe. Ha ez az érték kisebb volt mint hat,

105




2. rész

akkor megnöveltük a kisebb értékeket számláló változó tartalmát eggyel. Mire a ciklus végrehajtotta mind az öt ismétlést a bytKisebbek változóban már benne volt az eredmény. Ezt írattuk ki az eljárás utolsó sorában. Több dimenziós tömb Több dimenziós tömb feldolgozása esetén annyi ciklust ágyzunk egymásba, ahány dimenziója a tömbnek van.

Több dimenziós tömb feldolgozása w Több dimenziós tömbök esetén annyi For-Next ciklust ágyazunk egymásba, ahány dimenziós a tömb. Az ismétlések számának egyezni kell az egyes dimenziókba írt elemszámmal. Oldjuk meg az elõzõ példát úgy, hogy egy kétdimenziós tömb adatait dolgozzuk fel! Mivel az Excelben dolgozunk, egy kicsit tekintsünk elõre! Az aktív munkalap C3:E9-es tartományába írjunk be egy és tíz közé esõ számokat. Számoljuk meg azt, hogy hány olyan cella van, amelyben 6-nál kisebb értéket írt be a falhasználó. Ismét kérjük be egy tömbbe a feldolgozandó értékeket, és ebben a tömbben vizsgáljuk meg, az értékeket! Készítsük fel az aktív munkalapot a következõ adatokkal!

23. ábra: Készítsük elö a feldolgozandó adatokat Mivel az aktív munkalap adatait szeretnénk feldolgozni, kézenfekvõnek tûnik, hogy olyan tömböt deklaráljunk az adatbekéréshez, amelyik megegyezik a feldogozandó terület adataival. Ennek megfelelõen a tömb a következõ lesz: Dim sngSzamok(3 To 9, 3 To 5) As Single

Az adatok bekérését a Cells objektum segítségével végezzük el. A Cells-nek két argumentuma van. Az elsõ a sorra mutat, a második pedig az oszlopra. Mivel az aktív munkalap harmadik sorában kezdõdnek az adatok és a kilencedik sorig tartanak, ehhez érdemes igazítani a tömb elsõ dimenzióját. A másikat pedig a feldolgozandó oszlopoknak megfelelõen határozzuk meg. Amikor már a tömbben vannak az adatok, a ciklust úgy állítjuk össze, hogy az végiglépkedjen a megfelelõ sorokon és oszlopokon. A mintapélda a következõ:

106



9. fejezet


Sub For_Next_Teszt_2() ‘—- Állandók deklarálása —Const STR_OUT_CIM As String = "A kisebbek száma!" Const STR_OUT As String = " db kisebb szám volt, mint " Const INT_HATAR As Integer = 6 ‘—- Változók deklarálása —Dim intI As Integer Dim intK As Integer Dim bytKisebbek As Byte ‘ Tömb változó a feldolgozandó adatok számára Dim sngSzamok(3 To 9, 3 To 5) As Single ‘—- Kezdeti értékadás —bytKisebbek = 0 ‘—- Az adatok bekérése —For intI = 3 To 9 ‘ *** A tömb sorai For intK = 3 To 5 ‘ *** A tömb oszlopai sngSzamok(intI, intK) = Cells(intI, intK) Next intK Next intI ‘—- Feldolgozás —For intI = 3 To 9 ‘ *** A tömb sorai For intK = 3 To 5 ‘ *** A tömb oszlopai If sngSzamok(intI, intK) < INT_HATAR Then bytKisebbek = bytKisebbek + 1 End If Next intK Next intI ‘—- Eredmény kiírása —MsgBox bytKisebbek & STR_OUT & INT_HATAR End Sub

CD melléklet 09 Fejezet Vezerlesek_2.xls

A fenti eljárás – az adatbekérési részben – végiglépked az adatokat tartalmazó cellákon, és ennek megfelelõen beírja az ott talált értékeket az általunk deklarált tömbbe. Azért kellett a ciklusokat egymásba ágyazni, mert így tudjuk elérni a kétdimenziós tömb minden elemét. A külsõ ciklus a sorokon lépked végig, a belsõ pedig annak a sornak az oszlopain, amire a külsõ ciklus mutat. Így a tömb minden elemét eléri a program. A feldolgozási rész logikája ugyan ez. Ott is végiglépkedünk a kétdimenziós tömb minden elemén. Minden egyes elemet megvizsgálunk, hogy elérte a hatot vagy nem, Ha nem érte el, akkor megnöveljük a számláló értékét eggyel, ha igen akkor vesszük a következõ adatot. Ha olyan feladattal találkozunk, ahol nem kell a tömb minden elemét feldolgoznunk, akkor használhatjuk a Step részét a ciklusszervezésnek. Ez természetesen csak akkor célravezetõ, ha a feldolgozandó elemek azo-

107




2. rész

nos távolságra vannak. Például minden harmadik, vagy tizedik elemet szeretnénk kiértékelni a programunkkal. Természetesen nem tehetjük meg azt, hogy elõbb zárjuk be a külsõ ciklust és utána a belsõt. De azt igen, hogy egy utasítássorban zárjuk mindkét ciklust, ha azok egymást követõ sorokban lennének.

For Each... Next gyûjtemény iteráció For Each Ezzel a ciklusszervezéssel egy objektumgyûjtemény elemeit dolgozhatjuk fel.

A gyûjteményekben szintén egynél több adatot tárolhatunk, vagy egynél több objektumra hivatkozhatunk. Az Office alkalmazásokban gyakran használjuk a programok belsõ gyûjteményeit. Ilyenek az Excel-ben a munkalapok, munkafüzetek, a Word-ben a dokumentumok, bekezdések, az Access-ben a megnyitott ûrlapok, vagy a rajtuk található vezérlések. Amikor a feldolgozás során gyûjtemények elemeit szeretnénk feldolgozni, akkor használjuk a For Each…Next utasítást. Ennek segítségével végiglépkedhetünk az egyes elemeken, és feldolgozhatkójuk azok tulajdonságait. Ez az iteráció egy kicsit hasonlít az elõzõre. Itt is deklarálni kell egy változót, ami majd a ciklusszámláló lesz. Ennek a változónak olyannak kell lennie, amilyen a gyûjtemény eleme. Ha például, az Excel munkalapjait szeretnénk feldolgozni, akkor a ciklusszámláló változónak munkalap típusúnak kell lennie. Ha cellák tartalmával dolgozunk, akkor tartomány – Range – típust kell választanunk. Ha nem tudjuk eldönteni, hogy milyen típusú a gyûjtemény eleme, akkor az object adattípust válasszuk. A ciklus általános formája a következõ: Dim objValtozo As Object For Each objValtozo In Gyujtemeny mûveletket végzünk az objValtozo-val Next objValtozo

Elemezzük a fenti ciklust! A programrészlet elsõ utasítása, a Dim sor, amelyben deklaráltunk egy objektum típusú változót. Olyat, amilyen a gyûjtemény típusa. A For Each sorban az Each kulcsszót követõ változó az, ami végiglépked a gyûjtemény elemein. A Visual Basic mindaddig ismétli a ciklust, amíg az elemek végére nem ér. A Next utasítássorra érve vált a gyûjtemény következõ tagjára. Nézzünk egy olyan eljárást, ami végiglépked a megnyitott munkafüzet minden munkalapján. Nyissunk egy munkafüzetet, kapcsoljunk át a Visual Basic felületre. Szúrjunk be egy új általános modult, és írjuk meg a következõ eljárást.

108



9. fejezet


Sub For_Each_teszt_1() Dim wksLap As Worksheet For Each wksLap In Worksheets Debug.Print wksLap.Name Next wksLap End Sub


Nézzük meg az eljárás lépéseit! Az elsõ sorban deklaráltunk egy változót, aminek a típusa a Worksheet, vagyis egy munkalap. Ez lesz a ciklusszámlálónk. For Each wksLap In Worksheets

Ebben a sorban határoztuk meg azt, hogy melyik gyûjtemény elemeit vizsgáljuk végig. Ha egyszerû szavakkal fogalmazzuk meg ezt a sort, akkor ez azt jelenti, hogy; „Minden munkalapot – wksLap – vegyünk kézbe az aktív munkafüzet lapjai – Worksheets – közül. Ezt meg is teszi a program. A ciklustest egyetlen utasítása az, amelyik kiírja az éppen kézbe vett munkalap nevét az Immediate ablakba. A ciklust a Next wksLap sor zárja. Ennek az utasításnak a segítségével lépünk a gyûjtemény következõ elemére. Természetesen nem csak az aktív munkafüzet lapjain lépkedhetünk végig. Az in szó mögött megadhatjuk azt is, hogy melyik munkafüzet lapjaira vagyunk kíváncsiak. Ezt a következõ lehet: Sub For_Each_teszt_2() Dim wksLap As Worksheet For Each wksLap In Workbooks(1).Worksheets Debug.Print wksLap.Name Next wksLap End Sub

Egy korábbi (106. olal) feladatot is megoldhatunk ezzel a ciklussal. A For Next iteráció ismertetésekor azt vizsgáltuk, hogy egy számokkal kitöltött tartományban hány olyan cella található, amelyben hatnál nagyobb értéket írt a felhasználó. Ezt tegyük meg most is, de most használjuk a For Each ciklust! Sub For_Each_Teszt_4() ‘—- Állandók deklarálása —Const STR_OUT_CIM As String = "A kisebbek száma!" Const STR_OUT As String = " db kisebb szám volt, mint " Const INT_HATAR As Integer = 6 ‘—- Változók deklarálása —-


109




2. rész

Dim rngCella As Range Dim rngTartomany As Range Dim bytKisebbek As Byte Set rngTartomany = Range("C3:E9") ‘—- Kezdeti értékadás, adatbekérés és feldolgozás —bytKisebbek = 0 For Each rngCella In rngTartomany.Cells If rngCella.Value > INT_HATAR Then bytKisebbek = bytKisebbek + 1 End If Next rngCella ‘—- Eredmény kiírása —MsgBox bytKisebbek & STR_OUT & INT_HATAR End Sub

Az elsõ megoldáshoz képest másként lépkedünk végig a tartomány celláin. Az rngCella objektumváltozó lesz a ciklusszámláló. Az rngTartomany annak a tartománynak a hivatkozása, amely celláin végig fogunk lépkedni. Bármelyik tartományban találunk majd egy Cells gyûjteményt. A gyûjtemény elemei a tartományon belüli cellák. Ezt a ciklus elsõ sorában átadjuk a ciklusszámlálónak. Ha a program belép a ciklusba egyenként végiglép a gyûjtemény minden elemén, vagyis ismétlésenként más-más cellára fog hivatkozni. A ciklustesten ugyanazt a módszert használjuk a tartalom ellenõrzésére, mint az elsõ megoldásban. Miután végigjártuk az összes cellát kiírjuk az eredményt.

Do... Loop iteráció Do Loop A ciklus futása közben vizsgáljuk meg azt, hogy szükség van-e még az utasítások ismétlésére.

Nem mindig látszik elõre, hogy hány eleme lesz annak a tömbnek, mit fel kell dolgoznunk. Ilyenkor a tömbbe írt értékeket kell figyelnünk. A ciklust mindaddig kell ismételgetni, amíg a várt értéket meg nem kapjuk. Erre a használhatjuk a Do-Loop utasítás-párral megvalósítható ciklust. Ebben az esetben nem tudjuk elõre, hogy hány ismétlésre van szükség. Ebben az iterációban – ciklus típusban – addig hajtjuk végre a ciklus belsejében felsorolt utasításokat, amíg egy meghatározott feltétel nem teljesül. Vagyis amíg olyan adat nem érkezik, ami arról tájékoztat, hogy elég az ismétlésbõl. Ennek megfelelõen nem tudjuk elõre, hogy hányszor hajtjuk végre a ciklust, mivel elõre nem látható, hogy hányadik ismétlés hatására teljesül a meghatározott feltétel. Ennek a ciklusnak a bemutatása során mindenképpen beszélnünk kell a ciklusutasítások csoportosításáról is. Mégpedig a szerint, hogy a ciklus elején, vagy végén kerül-e ellenõrzésre a feltétel. Ha a ciklus elején tesztelünk,

110



9. fejezet


akkor elõl-tesztelõ ciklusról beszélünk, ha a végén, akkor hátul-tesztelõ ciklusról van szó. Ez azért érdekes, mert lesznek olyan ciklusok, melyek utasításait legalább egyszer végre kell hajtanunk. Ilyenkor hátul tesztelõ ciklust írunk a programba. Ha van olyan feltétel, aminek hatására a ciklusba írt parancsokat egyszer sem kell végrehajtani, akkor a ciklus belépési sorában kell megvizsgálnunk a feltétel teljesülését. A végrehajtás ezután a teszt eredményétõl függ, és lehet, hogy egyszer sem kerül sor a ciklus utasításainak a végrehajtására.. A Do Loop ciklusszervezés legegyszerûbb formája, amikor sem elõl, sem hátul nem tesztelünk. Ennek gyakorlati haszna nincs, mivel ez egy végtelen ciklust eredményez. Illetve ha megszegjük a strukturált programozás szabályait, akkor kiléphetünk a ciklusból az Exit Do utasítással, de ezt most rögtön felejtsük is el. Nézzük meg az elõl tesztelõ írásmódot. Ebben az esetben a Do parancs mögött határozzuk meg a feltétel vizsgálatát. Ez a következõ lehet: Do While logikai_kifejezes .... utasítások .... Loop

Elõltestzetlõ cilus Ha a ciklus elsõ utasítása tartalmazza a vizsgálatot, akoe az elõltesztelõ

A feltétel egy logikai kifejezés, ami – mint azt már olvastuk az operátorokról szóló részben – vagy True vagy False eredményt adhat. A While kulcsszó használatával mindaddig megismételjük a ciklusba írt utasításokat, amíg a kifejezés értéke True. Ellenkezõ esetben átlépünk a Loop utasítást követõ sorra. A másik elõl-tesztelõ ciklusszervezés esetén épp ellenkezõleg, addig ismételjük a ciklus utasításait, amíg a logikai kifejezés értéke False. Ehhez a While kulcsszót Until-ra kell felcserélnünk, így: Do Until logikai_kifejezes .... utasítások .... Loop

Ugyanezt az utasításpárt használhatjuk hátul-tesztelõ ciklus megvalósítására is. Ebben az esetben a ciklustestet lezáró Loop sorban kell meghatároznunk az ismétlés feltételét. Ebben a sorban is használhatjuk a While vagy az Until kulcsszavakat, melyek mûködése megegyezik az elõzõekben leírtakkal.

111



Visual Basic for Application Hátultesztelõ ciklus Ebben az esetban a ciklust lezáró utasítá mellett vizsgáljuk az ismétlés feltételét.

2. rész

Do .... utasítások .... Loop While logikai_kifejezes

vagy Do .... utasítások .... Loop Until logikai_kifejezes

Mivel ebben az esetben a ciklustest végén hajtjuk végre az ellenõrzést, a ciklusba írt utasítások legalább egyszer – feltétel nélkül – végrehajtásra kerülnek. Ha az utasítássor végére érve nem teljesül az ismétlés feltétele, akkor a Loop utáni utasítással folytatjuk a program végrehajtását, ellenkezõ esetben visszalépünk a Do sort követõ utasításra.

A Do Loop alkalmazása Nézzünk egy egyszerû példát! Írjunk egy eljárást, amelyik kitalál egy számot, amit mi nem tudunk. A program felhasználójának az lesz a feladata, hogy akármennyi próbálkozással, de találja ki a program által gondolt számot. Szemmel látható, hogy ebben az esetben nem tudhatjuk elõre, hogy a felhasználó hány próbálkozásból találja el a kívánt értéket. Így azt sem tudjuk elõre, hogy hányszor kell megismételni az adatbekérést. Ha szerencsés kezû a felhasználó, aki a program elõtt ül, elsõre is eltalálhatja, ha nagyon ügyetlen, akár több évet is próbálkozhat, mire megtalálja a kigondolt számot. Eredményül írassuk ki, hogy hányszor tippelt a felhasználó. CD melléklet 09 Fejezet Vezerlesek_5.xls

Sub Loop_teszt_1() ‘ —- Állandók deklarálása Const STR_IN_KERDES As String = _ "Tippeljen! Melyik számra gondoltam?" Const STR_CIM As String = "Játék" Const STR_OUT_START As String = "Ön " Const STR_OUT_END As String = " alkalommal tippelt!" ‘ —- Váltzók deklarálása Dim bytGondoltSzam As Byte Dim bytTipp As Byte

112



9. fejezet


Dim lngTippSzam As Long ‘ —- Kezdeti értékedás lngTippSzam = 0 bytGondoltSzam = Int(Rnd(1) * 10) + 1 Do ‘ —- Adatbekérés bytTipp = InputBox(STR_IN_KERDES, STR_CIM, bytGondoltSzam) ‘ —- Feldolgozás lngTippSzam = lngTippSzam + 1 Loop Until bytGondoltSzam = bytTipp ‘ Eredmény kiírása MsgBox STR_OUT_START & lngTippSzam & STR_OUT_END, , STR_CIM End Sub

A bytGondoltSzam változóban tároljuk azt az értéket, amit a program véletlen számként kitalált. Az bytTipp változót arra felhasználjuk, hogy a játékos által megadott tippet – egy számot – megõrizzük. A ciklust mindaddig ismételjük, amíg a Loop utasítás mögé írt feltétel eredménye False, vagyis amíg a két szám nem egyezik egymással. Érdemes felfigyelni arra is, hogy ebben a feladatban mind az adatbekérés mind a feldolgozás a ciklusban történik. Ez így helyénvaló, hiszen a megadott értékeket nem kívánjuk megõrizni. A kapott adatot azonnal feldolgozzuk. Ez még megfelel a strukturált programozás elvárásainak is.

Összefoglalás Az elovasott fejezetbõl kiderül, hogy a programok írása során háromféle utasítást használunk. Az egyik utasításcsoport a környezeti változók értékétõl függetkenül kerül végrehajtásra. Ezeket szekvencia utasításoknak nevezzük. A másik két utasításcsoport a környezeti változók értékétõl függõen hajtanak végre utasítássorokat. Ezek közûl az egyik csoport elõre meghatározott feltételektõl függõen különbözõ utasítássorokat hajtanak végre. Ezeket szelekciónak nevezzük.Vagyis a feltételeknek megfelelõen szelektálnak – választanak – az utasítássorok végrehajtásában. A másik csoport segítségével azokat a megfogalmazott gondolatokat valósíthatjuk meg, mint például az utasításblokkot négyszer ismételd meg, vagy az utasításblokkot addig kell ismételni, míg el nem érjük a a kívánt eredményt. A programnyelvtõl függetlenül minden nyelven ebbe a három kategóriába sorolhatjuk az utasításokat.

113





10. fejezet

Visual Basic eljárások

isual Basicben a program utasításait eljárásokba írjuk. Az eljárás több utasításból áll és egy-egy jól körülhatárolható feladatot oldhatunk meg egy-egy eljárással. Az eljárásoknak – a feladatuktól függõen – több fajtája van. A programban lesznek olyan eljárások, amelyeket mi hozunk létre, és lesznek olyanok, amelyeket a program kínál fel nekünk. Ebben a fejezetben ismerkedjünk meg azokkal az eljárás fajtákkal, amelyeket mi hozhatunk létre. A fejezet fõbb kérdései: w w w w

Milyen eljárásokat lehetnek a programokban? Mi az a szubrutin? Milyen eljárás a függvény? Hogy és hol használhatjuk a függvényeket, eljárásokat?

Az eljárások A Visual Basic nyelvben az eljárásoknak sok fajtája van. A programban használhatunk egyszerû eljárásokat, függvényeket, eseményvezérelt eljárásokat és az osztálymodulokba írhatunk tulajdonság eljárásokat. Eddig is használtunk eljárásokat, amikor az elõzõ fejezetben kipróbáltuk a vezérléseket. Sõt a változókról szóló fejezetben még azt is láthattuk, hogy lehet adatokat átadni egy eljárásnak. A változókról szóló fejezetben már írtunk szubrutint. Most ezeket az ismereteket foglaljuk össze. Az eljárások szerkezetét is érdemes úgy kialakítani, hogy azok az esetleges késõbbi program-módosítások idején áttekinthetõek legyenek. Az eljárást kezdjük az eljárás szintû változók és álladók deklarálásával, majd folytassuk az utasítások leírásával. Az eljárás minden esetben a Sub kulcsszóval kezdõdik, amivel egy sorban meghatározzuk az eljárás nevét. Az eljárást az End Sub utasítással zárjuk le.

115




2. rész

Az eljárásokon kívül csak az Option, valamint az alkalmazás vagy modul szintû állandók és változók deklarálására szolgáló utasítások állhatnak. Minden más utasítást Sub és End Sub utasítás-pár közé kell írnunk.

Szubrutinok A programba írt eljárásokat úgy használhatjuk, mint a program utasításait. Amikor egy korábban elkészített eljárást használunk a programban, azt szubrutinhívásnak nevezzük. A létrehozott eljárásokat a hatókörükön belül meghívhatjuk, vagyis önálló utasításként végrehajthatjuk. Az eljárásra, a nevével hivatkozhatunk. Ez egyben azt is jelenti, hogy minden megírt eljárás – még az eseményvezérelt eljárások is – meghívhatók, szubrutinnak használhatók. A szubrutinokban külsõ – a szubrutinon kívüli – adatokat is feldolgozhatunk. Ilyen esetben át kell adnunk a feldolgozandó adatokat az eljárásnak – szubrutinnak. Ha adatot szeretnénk átadni, akkor az eljárás neve mögötti zárójelpár között deklarálhatjuk az átadásra szánt adatokat. De ezt már megismerhettük a változók deklarálásáról szóló fejezetben.

Függvények A függvények olyan eljárások, amelyek egy értéket adnak vissza. Vagyis amikor lefuttatatunk egy függvényt, akkor a futás eredménye egy visszaadott érték. A függvény meghatározás kulcsszava a Function. A függvénynek is lehetnek argumentumai. Ezeket ugyanúgy, a függvénynév mögötti zárójelpárban határozzuk meg. Itt is adhatunk át opcionális vagy tömb argumentumokat, mint a szubrutin esetén. CD melléklet 10 Fejezet Fuggveny.xls

Function Osszead(sngA As Single, sngB As Single) As Single Osszead = sngA + sngB End Function

Az eredmény visszaadására a függvény nevét használjuk. Tehát a függvény neve önmaga is egy változó. Ennek megfelelõen meghatározhatjuk az adattípusát is. A függvény adattípusát az argumentumok zárójelén kívül adhatjuk meg. A függvény eredményét úgy hozhatjuk a külvilág tudomására, hogy a függvény eljáráson belül értéket adunk a függvénynév változónak. Function Osszead(sngA As Single, sngB As Single) As Single Osszead = sngA + sngB End Function

116



10. fejezet

Visual Basic eljárások

24. ábra: A függvényeket a munkalapokon is használhatjuk A függvény használata w A függvényt úgy használhatjuk fel, hogy egy változónak értéket adunk. Az összeadó függvény felhasználására példa a következõ kis eljárás: Sub OsszegHaszn Dim sngC as Single sngC = Osszead(25.456, 781.452) Debug.Print sngC End Sub

117




2. rész

A függvény használta során az argumentumokat zárójelek között soroljuk fel. Az Excel-ben a megírt függvényeinket akár a munkalapokon is használhatjuk. A létrehozott függvények bekerülnek az Excel függvénylistájába. Az általunk írt függvények mindaddig szerepelni fognak a munkalap függvények között, amíg az õket tartalmazó munkafüzet nyitva van. Nyissunk egy új munkafüzetet, és kapcsoljuk be a VBE-t. A megnyitott füzetbe illesszünk bele egy általános modult. Ebbe a modulba írjuk bele az elõbbi függvényt. Miután ezt megtettük, kapcsoljunk vissza az Excelbe, és vegyük használatba ezt az egyszerû kis függvényt (117. oldal 24. ábra). Eljárások hatóköre w Hasonlóan a változókhoz az eljárásoknak és függvényeknek is van hatókörük. Az eljárások hatókörével azt szabályozhatjuk, hogy az adott eljárást honnan lehessen meghívni. Az általános modulba írt eljárások és függvények alapértelmezett hatóköre az aktuális alkalmazás. Vagyis Public parancs nélkül az egész projektben használhatjuk a függvényt vagy eljárást. Ha szûkíteni szeretnénk a hatókört, akkor a Sub vagy Function kulcsszó elé írjuk be a Private szót. Az elõzõ összegzõ függvény esetén ezt így kell írni: Private Function Osszead(sngA As Single, sngB As Single) As Single Osszead = sngA + sngB End Function

Statikus eljárások w A változókról szóló részben már beszéltünk a statikus változókról. A statikus eljárásban deklarált összes változó statikus lesz. Ennek megfelelõen a statikus eljárásban egyetlen változó elé sem kell beírnunk a Static kulcsszót, hiszen enélkül is megtartják az értéküket az eljárás többszöri meghívásakor.

118



11. fejezet

A programok finomítása

gy-egy program a legkörültekintõbb tervezés mellett is lehet hibás. A legnehezebb feladat megtalálni azokat a hibákat, amelyeket mi okoztunk. A Visual Basic környezet sok hibát automatikusan észlel, és figyelmeztet rá. Csak gondoljunk az Option Explicit parancs használatára, vagy arra a hibajelzésre, ha egy-egy parancsot nem megfelelõen írtunk le és a pirossá változott, amint kiléptünk az adott sorból. A hibák egy másik csoportja adódhat abból, hogy rosszul találtuk ki a program algoritmusát. Ilyenkor úgy tûnik, minden rendben van. Nem jelzi, hogy nem deklaráltunk változót, vagy elírtunk valamit, de az eredmény mégsem az, amit elvártunk az eljárástól. Mivel a Visual Basic nem jelzi a hibát, ezeket a legnehezebb megtalálni. A fejlesztõi környezetek épp ezért rendelkeznek olyan eszközökkel, amelyekkel nyomon tudjuk követni a programok futását. Tegyük fel a következõ kérdéseket: w Hogyan lehet egy eljárást lépésenként végrehajtani? w Hogy állíthatjuk meg az eljárást futás közben? w Hogy vizsgálhatjuk meg a változók tartalmát?

A program végrehajtása lépésenként Kisebb programok esetén jól használható módszer, ha lépésenként hajtjuk végre az elkészített eljárást. Az eljárás, amit lépésenként hajtunk végre, olyan legyen, ami az éppen aktuális adattartomány minden celláját végigolvassa és a végén kiírja a tartomány legkisebb értékét. Valahogy így: Sub MinimumKeres() Const STR_MSG_1 As String = " A legkisebb szám a(z) " Const STR_MSG_2 As String = " amelyik a(z) " Const STR_MSG_3 As String = " cellában van." Dim dblTemp As Double

CD melléklet 11 Fejezet Finomitas.xls

119




2. rész

Dim dblMin As Double Dim strCime As String Dim rngTart As Range dblMin = Selection.CurrentRegion.Cells(1) For Each rngTart In Selection.CurrentRegion dblTemp = rngTart.Value If dblTemp < dblMin Then dblMin = dblTemp strCime = rngTart.Address End If Next rngTart Range(strCime).Select MsgBox STR_MSG_1 & dblMin & STR_MSG_2 & strCime & STR_MSG_3 End Sub

Az eljárás, mint eddig mindig, az állandók és a változók deklarálásával kezdõdik. A dblMin változó feladata, hogy az eljárás végén ebben a változóban megjelenjen a tartomány legkisebb értéke. A dblTemp változó az adatok átmeneti tárolására szolgál. dblMin = Selection.CurrentRegion.Cells(1)

A legelsõ érték, amit minimumként tárolunk, az aktuális tartomány elsõ cellája. Ezt az értéket az aktív tartomány bármelyik cellájából vehetnénk, de kézenfekvõ a tartomány elsõ celláját felhasználni. Így akár olyan tartomány esetén is felhasználhatjuk az eljárásunkat, amelyik egyetlen cellából áll. Késõbb, ha a tartományban találunk ennél kisebb értéket, akkor azzal lecseréljük ezt az értéket. For Each rngTart In Selection.CurrentRegion dblTemp = rngTart.Value If dblTemp < dblMin Then dblMin = dblTemp strCime = rngTart.Address End If Next rngTart

A For Each ciklus használatával végiglépkedünk a tartomány celláin. A ciklus elsõ utasítása a dblTemp változóba írja az aktuális cella tartalmát. Ezután, megvizsgáljuk, hogy a jelenlegi cella tartalma kisebb-e, mint a minimumként tárolt érték. Ha igen, akkor ki kell cserélnünk a korábbi minimumot, hiszen ez kisebb, mint amit korábban tároltunk. A következõ lépésben még annak a cellának a címét is megjegyezzük, ahol ezt

120



11. fejezet


az értéket találtuk. Ezt a strCime változóban tároljuk. A cím egy szöveg, ezért ezt egy szöveg típusú változóban õrizhetjük meg.

25. ábra: Készítsünk elõ adatoakt az eljáráshoz MsgBox STR_MSG_1 & dblMin & STR_MSG_2 & strCime & STR_MSG_3

Az eljárás utolsó lépése az eredmény kiíratása. Ezt az eredményekbõl és a deklarációs részben tárolt állandókból állítjuk össze. A megnyitott munkafüzetben álljunk a tartomány egyik cellájára. Az eredmény ellenõrzésére egy kissé távolabbi cellába, munkalap függvény segítségével keressük meg a minimum értéket. Ezután kapcsoljunk vissza a VBE-be és indítsuk el az eljárásunkat. Most futtassuk le ugyanezt az eljárást lépésenként. Ismét az eljárás elsõ sorára állunk és kiválasztjuk a Debug Ø Step Into utasítást vagy leütjük az F8-as funkcióbillentyût. Ennek az lesz az eredménye, hogy a Sub sort tartalmazó utasítássort az Excel sárga színnel kiemeli. A következõ lépés végrehajtásához ismét válasszuk ki a Step Into utasítást. Egyszerûbb a továbblépés az F8-as billentyûvel, mert ha minden lépésnél le kell nyitni a menüt, akkor kicsit nehézkes lesz a végére jutni egy hosszabb eljárásnak. A VBA azt az utasítást, amelyiket éppen megjelölte a sárga színû kiemeléssel még nem hajtotta végre. Ismét üssük le az F8-as billentyût. Most álljunk meg egy rövid idõre, és kicsit vizsgáljuk meg azt az utasítást, amelyiken már túljutottunk. Egyszerûen húzzuk az egérmutatót a dblMin változó fölé (122. oldal 26. ábra). Kis idõ múlva a változó alatt megjelenik annak pillanatnyi értéke. Ezt kipróbálhatjuk olyan változók esetén is, melyeknek még nem adtunk értéket.

121




2. rész

26. ábra: Ha az egérmutatót a változó fölé húzzuk, megjelenk a tartalma Ha tovább lépkedünk az eljárásban, nyomon követhetjük a ciklus és az elágazás végrehajtását is. Itt ismét megvizsgálhatjuk a változók pillanatnyi értékét, és az elemzés eredményét felhasználhatjuk a program kijavítására.

Töréspont elhelyezése Nagyobb eljárások esetén hosszadalmas lenne végiglépkedni az utasításokon. Lehet ugyanis, hogy gyanakszunk a program valamelyik részére és ez a rész nem az eljárás elején található. Ilyenkor a jónak ítélt utasítások fölött nem kell megállnunk. Ha egy korábban elkészített munkalap függvényben keressük a hibás részt, akkor nem is tudjuk elindítani a függvényt lépésenként. Ilyenkor is hasznos, ha a programot egy megfelelõ ponton leállítjuk és esetleg innen haladunk tovább lépésenként.

27. ábra: Töréspont elhelyezése az eljárásban

122



11. fejezet


Helyezzünk el töréspontot az If utasítást tartalmazó sornál (27. ábra). Ennek több módja is van. Az egyik, amikor ráállunk arra az utasításra, amelyiknél szeretnénk megállítani a programot és kiválasztjuk a Debug Ø Toggle Breakpoint utasítást vagy leütjük az ezzel egyenértékû F9-es funkció billentyût. Van egy másik módszer, ami még ennél is egyszerûbb. Ezt az egérrel valósíthatjuk meg, mégpedig úgy, hogy a modul bal szélén található szürke sávra kattintunk az elõtt a programsor elõtt, ahol töréspontra van szükségünk. A töréspont elhelyezése után indítsuk el az eljárást (F5-ös funkció billentyû). Ahányszor a törésponttal jelölt sort kell végrehajtania a programnak, megáll. Lehetõségünk van a változók tartalmának ellenõrzésére. Ennek az ellenõrzésnek a segítségével még azt is megtudhatjuk, hogy a program egyáltalán rálép-e a kiválasztott utasítássorra. Ha nem, megvizsgálhatjuk a program, algoritmusát, vagy a változókat. A törésponttól akár lépésenként folytathatjuk az eljárás végrehajtását.

Változók figyelése A változókat külön ablakban is megjeleníthetjük. Hajtsuk végre a 28. ábra rajzán látható lépéseket. Ha ezek után lépésenként hajtjuk végre az eljárás utasításait, akkor a kiválasztott változó mindegyik változását megfigyelhetjük.

28. ábra: Változó elhelyezése a figyelõ ablakban

123




2. rész

1. Kattintsunk az egérrel abba a változóba, amelyiket szeretnénk megfigyelni. 2. Hajtsuk végre a Debug Ø Quick Watch parancsot. 3. A mûvelet eredményeként megnyílik a Watches ablak. 4. A Watches ablakban megjelennek a kiszemelt változó jellemzõi. A Watches ablakban négy oszlopot találunk. Az elsõ oszlop a Expression. Ebben az oszlopban a változó nevét olvashatjuk. A második oszlop – Value – a változó értékét mutatja meg. Ez az oszlop megmutatja azt is, hogy a változó hatásköre jelenleg érvényes-e vagy nem. Addig, amíg a változó hatókörén kívüli utasításokat hajtunk végre, az Value oszlopban az Out of context szöveg jelenik meg. A harmadik oszlop a változó típusát jelzi. Mivel a eljárását nem kezdtük el végrehajtani, így még nincs deklarálva a kiválasztott változó. Ezért itt az Empty – üres – szöveg olvasható. A negyedik oszlop a változó hatókörét mutatja meg. Ez jelenleg a Module1-es modul MinimumKeres eljárása. Ez a mi esetünkben a Modul1-es modul, azon belül pedig a MinimumKeres eljárás. Ha a programot megállítjuk valahol, akkor itt a Watches ablakban mindig azt az értéket fogjuk látni, amit éppen a változó felvett. Utána számolhatunk az adott értéknek, vagy ha szükségét látjuk át is írhatjuk. Csak rá kell kattintani a Value értékre az egérrel, és átírhatjuk.

Kifejezések figyelése, feltételes megszakítás Sok esetben nem egyszerûen a változó értéke a hiba oka, hanem a több változóból számított helytelen érték. Ennek a megfigyelésére is lehetõségünk van. A kifejezéseket a fordító kiértékeli. Ennek segítségével feltételes megszakításokat is meghatározhatunk. Másként fogalmazva meghatározhatjuk, hogy a program akkor álljon le megszakítással, amikor valamelyik változó felvesz egy értéket. Állítsunk be olyan feltételes töréspontot, ami akkor állítja le eljárásunkat, amikor a dblTemp változó értéke megváltozik. Ehhez az Expression dobozban a dblTemp változónak kell szerepelnie és a Break When Value Changes választót kell bekapcsolnunk. Ha ezek után elindítjuk az eljárást, akkor a program csak abban az esetben áll le, ha a dblTemp változó értéke megváltozott. Figyeljük meg azt is, hogy a Watches listában ez elõtt a figyelés elõtt más a rajz. Most állítsunk be egy olyan figyelõpontot, amelyik akkor szakítja meg a program futását, amikor a dblMin pillanatnyi értéke kisebb, mint a dblTemp. Ehhez a kifejezés dobozba írjuk be a dblMin < dblTemp kifejezést és kapcsoljuk be a Töréspont, ha az érték IGAZ kapcsolót.

124



11. fejezet


29. ábra: A figyelõpont szerkesztése w Ha egy figyelõpont beállításán változtatni szeretnénk, akkor jelöljük ki a figyelõablak listájából és a helyi menübõl a Edit Wach utasítást. A megjelenõ panelben megváltoztathatjuk a beállításokat. A figyelõpont törlése w Ha az egyik vagy másik figyelõpontra tovább nincs szükségünk, akkor jelöljük ki a figyelések segédablakban a feleslegessé vált elemet és üssük le a billentyûzet DELETE gombját. Ha megfigyeléseinket befejeztük, akkor bezárhatjuk a figyelõablakot az ablak jobb felsõ sarkában található x gombbal. A figyelõablak lezárása után is megáll a program, ha vannak beállított feltételek. Tehát szüntessük meg a figyelõpontokat és kapcsoljuk ki a figyelések ablakot. A következõ részben már nem lesz rá szükségünk.

Helyi változók megfigyelése Az egyes eljárásokban állandókat, változókat és objektumokat használunk. Ezeket egyszerre is megfigyelhetjük a helyi ablak segítségével. Ez egy kicsit eltér az elõzõ figyelésektõl, mert nem mi választjuk ki a megfigyelni kívánt elemeket. Cserébe azonban nemcsak a változók értékét láthatjuk, hanem az eljárásban használt objektumok állapotáról is adatokat kaphatunk. Ezt az ablakot a View Ø Locals Window utasítással kapcsolhatjuk be. A helyi ablak bekapcsolása után helyezzünk el egy töréspontot az eljárásunknak abban a sorában, ahol az End If utasítás van. Ezután indítsuk el az eljárást. Amikor a töréspontra lépünk, akkor nézzük meg a helyi ablakot.

125




2. rész

30. ábra: A Local Window tartalma Ebben az ablakban megváltoztathatjuk az objektumok tulajdonságát vagy a változók értékét. Erre akkor lehet szükségünk, ha a megfigyelés során úgy látjuk, hogy a programlépések eredményeként nem következik be olyan állapot, amit vártunk. Ugyanezzel a módszerrel a figyelõablakban is élhettünk, ott azonban csak a megfigyelés alatt álló változók értékét változtathatjuk meg. Érdemes megjegyezni, hogy az objektumoknak vannak olyan tulajdonságai, amelyeket csak olvasni lehet. Természetesen ezeket itt sem módosíthatjuk. Miután megismertük ezt a megfigyelési lehetõséget zárjuk le a Local Window segédablakot. CD melléklet 11 Fejezet Finomitas.xls

31. ábra: Az Immediate ablakban közvetlen parancsokat adhatunk ki

126



11. fejezet


A próba ablak használata A próba ablakból elindíthatunk egy korábban már megírt eljárást. Ezt próbáljuk is ki. Kapcsoljuk be a próbaablakot a View Ø Immediate Window utasítással. Indítsuk el az elkészített eljárást (31. ábra). Ennek akkor vehetjük nagy hasznát, ha sok eljárást tartalmaz a programunk. A próba ablakban kipróbálhatjuk az utasításokat. Egyszerre egy sornyi utasítást írhatunk be és próbálhatunk ki. Kiírathatjuk az egyes objektumok tulajdonságát, végrehajthatjuk az objektumok metódusait. Ezt a lehetõséget használjuk fel az objektumok bemutatásáról szóló fejezetben. A program futása közben kiírathatjuk a változók értékét. Ehhez a Debug objektumot kell használnunk a programban. Ez egy vagy több új utasítássort jelent, melyeket be kell írnunk az eljárás sorai közé. Ennek az objektumnak egyetlen metódusát használhatjuk. Ez a Print metódus. Válasszuk ki a programunkban azt az utasítássort, amelyik után a változók értékét szeretnénk megjeleníteni és írjuk be a következõket:

32. ábra: A program futása közbe kiirathatjuk a változók tartalmát A változók vagy objektumok tulajdonságát az eljárás bármelyik pontjáról kilistázhatjuk. Az üzenetben szövegállandókat is használhatunk, amelyek segítségével a lista olvasását tehetjük egyszerûbbé. A Debug objektumban van még egy lehetõség a program változóinak az ellenõrzésére. Tegyük fel, hogy ugyanezen a helyen azt szeretnénk megtudni, hogy mikor azonos a két változó tartalma. Erre a az Assert eljárást használjuk. Ha az Assert után beírt logikai kifejezés értéke hamis lesz,

127




2. rész

akkor leáll a program. Ez hasonló, mint az Add Watch-ba írt kifejezés. Az elõzõ Debug.Print sor után írjuk be a következõ parancsot: Debug.Assert dblTemp <> dblMin

Azért nem egyenlõségjelet tettünk a két változó közé, mert így pont akkor lesz False az érték, ha azok tartalma megegyezik. További kiírási lehetõségek w Természetesen a tulajdonságok vagy változók értékét az MsgBox utasítás segítségével is megjeleníthetjük. Ennek egyetlen hátránya, hogy amíg az üzenet látszik, nem férünk hozzá máshoz, mint az üzenet panelhez. Másik lehetõség az, amikor a kiválasztott értékeket a munkalap valamelyik cellájába íratjuk ki. Erre a Cells vagy Range objektumot használhatjuk fel.

Összegezve Ha a program mûködése nem pontosan egyezik meg az elgondolásunkkal elemezzük ki a futását lépésenként, vagy álljunk meg a megfelelõ helyen, és vizsgáljuk meg a változók tartalmát. Ha szükséges, futás közben módosítsuk is.

128



Az Excel objektumai

3. Rész



A 3. rész tartalmából Ebben a részben az Excel objektumainak a megismerését tûzzük ki célul. Olyan eszközöket ismerünk meg, amelyek segítségével megszerezhetjük az Excel programozásához szükséges tudást. Makrót készítünk felvétellel, majd utána kielemezzük a felvett eljárásokat. Késõbb az Immediate ablakban kiadott parancsokkal folytatjuk az objektumok és metódusok megismerését. Ezekkel a módszerekkel megtanulhatjuk az Excel objektumok tulajdonságainak és metódusainak a kezelését.



13. fejezet

Ismerkedés a tulajdonságokkal z Excel objektumok megismerésére jó módszer, hogy az Immediate ablakban kiadott parancsok hatását megfigyeljük. Azt már olvastuk a Visual Basic Editor-ról szóló fejezetben, hogy az Immediate ablakban kiadott utasítások azonnal végrehajtásra kerülnek. Ebben a fejezetben ezt az eszközt fogjuk felhasználni arra, hogy az Excel egyik, másik objektumát felfedezzük. Figyeljük meg, hogy azoknak a tulajdonságoknak és metódusoknak a neve, amelyek több objektumban is elõfordulnak, azonos a nevük. A fejezet fõbb kérdései: w Hogyan változtathatjuk meg egy-egy objektum tulajdonságait? w Hogyan ismerkedhetünk meg az egyes objektumok használatával?

33. ábra: Rendezzük el az Excel és a VBE ablakait így 131



Az Excel objektumai

3. rész

Töltsük be az Excelt és kapcsoljuk be a Visual Basic Editor-t. A megjelenítését állítsuk be úgy, hogy a háttérben látható legyen az Excel program (131.oldal 33.ábra). Ehhez zárjuk le mind a projekt ablakot, mind pedig a tulajdonság – Properties – ablakot. Ezt úgy tehetjük meg, hogy a segédablakok jobb felsõ sarkában található x-re kattintunk. Kapcsoljuk be az Immediate ablakot. Ezt a View Ø Immediate Window utasítás végrehajtásával tehetjük meg. Ha ebbe az ablakba beírunk egy utasítást, akkor amint leütjük az ENTER billentyût, az Excel azonnal végrehajtja azt az utasítást, amit beírtunk. A már beírt utasításokat többször is végrehajthatjuk, ha az utasítás sorába állva ismét leütjük az ENTER-t. A Visual Basic szerkesztõ ablakát vegyük kisebbre, úgy, hogy a háttérben jól megfigyelhessük mi történik az Excelben.

Excel objektumok Ebben a fejezetben megismerkedhetünk néhány objektum egyik-másik tulajdonságának a beállításával és néhány metódussal. Megtanuljuk, hogy miként lehet programból új munkafüzetet kezdeni, hogy lehet egy munkafüzetbe új munkalapot beszúrni továbbá, hogyan milyen módszerekkel jelölhetünk meg egy kiszemelt cellatartományt.

Az Excel mint objektum Application Ez az objektum maga az Excel alkalmazás.

Name Ebbõl a tulajdonságból tudhatjuk meg egy objektum nevét.

Maga az Excel alkalmazás is objektum, így program írásakor ennek tulajdonságaihoz, metódusaihoz is hozzáférünk. Az objektum neve Application. Ennek a jellemzõi olyan tulajdonságok és metódusok, amelyek magára az Excel-re vonatkoznak. Most sem vesszük át az objektumleíró könyvek feladatát. Ötletszerûen kiemelünk néhány objektumot, és annak egyik-másik tulajdonságát, metódusát kipróbáljuk. A cél most nem az, hogy bemutassuk az Excel objektumait, inkább az ismerkedés módszerét szeretném átadni a Kedves Olvasónak. Ha valamelyik tulajdonság értékét szeretnénk megtudni, a sort kezdjük kérdõjellel. Figyeljük meg, hogy amint leírjuk a pontot az Application szó mögé, megjelennek az objektum tulajdonságai és metódusai (34. ábra). A megjelenõ listából kiválaszthatjuk azt, amelyiket ki szeretnénk próbálni. Kezdjük azzal, hogy kiíratjuk az alkalmazás nevét. Írjuk be a következõ sort az Immediate ablakba: ?Application.name

A válasz az, hogy „Microsoft Excel”. Az objektumok Name tulajdonsága minden objektumnál a kiválasztott objektum nevét tartalmazza. A név

132



13. fejezet

Ismerkedés a tulajdonságokkal

tulajdonság egyedi. Vagyis egy projekten belül nem használhatjuk kétszer ugyanazt a nevet. A Név tulajdonság értékét futási idõben nem lehet megváltoztatni. Az objektum felirata és a neve két külön tulajdonság. A felirat megvál-

34. ábra: A tulajdonság lista toztatható futási idõben is. A felirat tulajdonság a Caption. Ilyen tulajdonsága az Excel-nek is van. Ez az ablak bal felsõ sarkában látható. Jelenleg ez is a Microsoft Excel szöveget tartalmazza, vagyis a program nevét. Ez azonban átírható. Elõbb olvassuk ki, majd változtassuk meg! ?application.caption

Erre a következõ választ kapjuk: Microsoft Excel - Munkafüzet1. Azért jelent meg a munkafüzet neve is a válaszban, mert a megnyitott munkafüzet neve is megjelenik a program fejlécén, bár az nem része a program nevének. Ha a munkafüzet nem töltötte volna ki az Excel ablak teljes felületét, akkor csak a Microsoft Excel szöveg jelent volna meg. Változtassuk meg a program feliratát. Írjuk be a következõ sort az Immediate ablakba: application.caption = "Ez egy nagyszerû táblázatkezelõ program!"

A fenti utasítás eredményét a 134. oldalon látható 36. ábra szemlélteti. Ha szeretnénk visszaállítani az eredeti feliratot, adjuk ki a következõ parancsot: application.caption = ""

133


Caption Ûrlapok, alkalmazások, ablakok, parancsgombok feliratának tárolására szolgáló tulajdonság.


Az Excel objektumai

3. rész

36. ábra: Az Excel alkalmazás címcor tulajdonsága Visible Egy objektum láthatóságát állíthatjuk be ennek a tulajdonságnak a segítségével.

Szükség esetén elrejthetjük az Excel alkalmazást a program lezárása nélkül. Állítsuk be az Application objektum Visible tulajdonságát False értékre. application.visible = false

Ne lepõdjünk meg, az Excel eltûnt, de nem zártuk le. Ez abból is látszik, hogy a VBE még használható. Jelöljük ki a False szó és írjuk át True értékûre. Az ENTER gomb leütése után ismét megjelenik a program.

35. ábra: Az Excel beállításai w Ebben az objektumban találhatjuk meg az Excel beállításaiért felelõs tulajdonságokat is. Ha az Excel-ben kiadjuk az Eszközök Ø Beállítások menüparancsot, megjelenik a beállítás párbeszédpanel. Ezeket a

134



13. fejezet


beállításokat is programozhatjuk. Például a megjelenítés fülön található beállítások azok, amelyek a Display szóval kezdõdnek. Egyiket-másikat próbájuk ki! Az Immediate ablakban állítsuk be az értéküket False, majd True értékûre. Miután átkapcsoltuk, program paranccsal a beállításokat, érdemes megnézni a Beállítások párbeszédpanelt. Az egyes beállítások eredményét kérdezzük le az Immedate ablakban kiadott paranccsal. Például, kapcsoljuk ki az Ecxel állapotsorát! application.DisplayStatusBar=False

Ha a DisplayStatusBar tulajdonság értékét False-ra állítjuk, eltûntethetjük az állapotsort. Ugyanezzel a paranccsal ismét megjeleníthetjük, csak most True értékre kell állítanunk. Szükség esetén le is kérdezhetjük azt, hogy az állapotsor látható-e. ?application.DisplayStatusBar

Ugyanezzel a módszerrel rejthetjük el a szerkesztõlécet, ha a DisplayFormulaBar tulajdonság értékét megváltoztatjuk. Tetszés szerint próbáljunk ki néhány Display kezdetû tulajdonságot, figyeljük meg a hatásukat. Lekérdezhetjük az Excelhez tartozó fájl elérési útvonalakat is. Egyetegyet próbáljuk átállítani. Nem mindegyiket lehet! Más szóval ismerkedjünk a következõ tulajdonságokkal. ?application.AltStartupPath ?application.DefaultFilePath ?application.LibraryPath ?application.Path ?application.StartupPath ?application.TemplatesPath ?application.UserLibraryPath ?application.DefaultSaveFormat ?application.RecentFiles.Count

Ha az Excel, vagy az operációs rendszer verzióját szeretnénk megtudni, arra a következõ tulajdonságokat használjuk. ?application.Version ?application.OperatingSystem

A program felhasználó és a szervezet neveit kérdezzük le a következõ parancssorokkal:

135


Count Count metódusa minden gyûjteménynek van. A segítégével megszámlálhatjuk a gyûjteménybe foglalt objektumokat.


Az Excel objektumai

3. rész

?application.OrganizationName ?application.UserName

Az Application objektumnak vannak olyan tulajdonságai, amelyek objektumra vagy gyûjteményre mutatnak. Ezek segítségével hivatkozhatunk a mindenkori aktív objektumokra. próbáljuk ki a következõ néhány tulajdonság használatát: application.ActiveCell = "Excel 2003" ?application.ActivePrinter ?application.ActiveWindow.Caption ?application.ActiveSheet.name ?application.ActiveWorkbook.Name

Mivel az Excel alkalmazásban adjuk ki a parancsokat, nem kötelezõ leírni az Application objektum nevét. Vagyis az elõzõ utasításokat így is értelmezi a Visual Basic: ActiveCell = "Excel 2003" ?ActivePrinter ?ActiveWindow.Caption ?ActiveSheet.name ?ActiveWorkbook.Name

Még az Excel alkalmazást is bezárhatjuk programozottan. Adjuk ki a következõ parancsot: Kilépés a programból

application.quit

Az Application Quit metódusa lezárja az Excel alkalmazást.

Tegyük meg, majd ismét indítsuk el az Excelt.

Munkafüzet gyûjtemény és objektumok

Count Minden gyûjteménynek van Count metódusa. Ezzel a metódussal lekérdezhetjük, hogy hány eleme van a gyûjteménynek.

Érdemes visszalapozni az objektum-diagramra. Ott megfigyelhettük, hogy az Application objektum alatt találjuk a Worksheets gyûjteményt. Minden gyûjteménynek van Count metódusa! Ezzel megszámlálhatjuk a gyûjtemény elemeit. Ezt a metódust fogjuk felhasználni arra, hogy megszámoljuk az alkalmazásban megnyitott munkafüzeteket. ?application.workbooks.count

136



13. fejezet


Mivel a munkafüzetek abban az alkalmazásban vannak, amelyikben a parancsot kiadtuk, nem kötelezõ a hivatkozásban az Application objektumnak szerepelnie. Rövidebben leírva az elõzõ utasítást: Add

?workbooks.Count

Vegyünk fel újabb munkafüzetet a gyûjteménybe! A gyûjteményekbe az Add metódussal vehetünk fel újabb elemet. A munkafüzetek gyûjteményt is bõvíthetjük új elemmel. Az Add metódus eredménye, ugyanaz, mint amikor Excel felhasználóként új munkafüzetet kezdünk.

Az Add metódussal a gyûjteménybe újabb elemet vehetünk fel.

workbooks.add

Figyeljük meg a Visual Basic Editor mögött, az Excel alkalmazásban megjelent egy új üres munkafüzet. Vagyis a Workbooks gyûjtemény eggyel több munkafüzetbõl fog állni. Ahányszor ebbe a parancssorba állunk és leütjük az ENTER-t, mindannyiszor egy új munkafüzetet nyitunk. Álljunk vissza abba a sorba, amelyikben megszámoltuk a munkafüzeteket, és ismét számoljuk meg. Látni fogjuk a változást. Ha szeretnénk lezárni a munkafüzeteket, használjuk a close metódust. Ha ezt a parancsot kiadjuk, az Excel lezárja az összes megnyitott munkafüzetet, mivel a Close most a Workbooks gyûjteményre vontatozik.

Close Bezárhatjuk a munkafüzetet. Ilyen metódusa minden bezárható objektumnak van.

workbooks.close

Ha ezt az utasítást végrehajtottuk, akkor lépjünk vissza az add metódust tartalmazó sorra, és a segítségével hozzunk létre négy vagy öt munkafüzetet. Figyelem a munkafüzetek neve már nem egytõl kezdõdik. Munkafüzet objektum w Most fordítsuk a figyelmünket a munkafüzet objektum felé. Ez a Workbooks gyûjtemény egy eleme. Kezdjük az éppen aktív munkafüzettel. Erre az Activeworkbook hivatkozást használjuk. Ha elfelejtenénk, megtaláljuk az Application objektum tulajdonságai között. Activeworkbook.Close

A Workbooks – munkafüzetek – gyûjtemény egyik tagját zárjuk le ezzel az utasítással. Ez az elem az éppen kiválasztott, aktív munkafüzet. Az ActiveWorkbook tulajdonság a mindenkori aktív munkafüzetet határozza meg. Vagyis a Workbooks objektumgyûjtemény egyik elemével végzünk mûveletet. ?workbooks(1).name ?Activeworkbook.name

137


Workbook Ha a Workbooks gyûjteménynév mögé írt zárójelek között meghatározzuk a gyûjtemény egy elemét, akkor egy Workbook objektumra hivatkozhatunk.


Az Excel objektumai

3. rész

A Workbooks gyûjtemény munkafüzetekbõl áll. Workbook objektumra úgy hivatkozhatunk, hogy meghatározzuk azt is, hogy a gyûjtemény melyik elemével hajtjuk végre a mûveletet. Erre a gyûjtemény mögé, zárójelek közé írt index meghatározásával van lehetõségünk. Ezzel a Workbooks gyûjtemény egyik elemét határozzuk meg, vagyis egy Workbook objektumot. A zárójelbe írt egyes azt a munkafüzetet jelöli meg, amelyiket idõben a legkorábban nyitottuk meg. A Name tulajdonság a munkafüzet nevét tárolja tehát ez az utasítássor, a megadott munkafüzet nevét írja ki. Az aktív munkafüzet nevét az ?Activeworkbook.name utasítással írathatjuk ki. Az aktív munkafüzet és az elsõként megnyitottt munkafüzet nem feltétlenül ugyanaz. workbooks("Munkafüzet10").close

Activate Az objektum, amelynek ezt a metódusát használtuk aktuális objektum lesz.

Saved Ha a munkafüzet betöltése óta bármit megváltoztattunk, akkor az értéke False-ra vált.

A Workbooks gyûjtemény egyik elemére az elem – munkafütet – nevével is hivatkozhatunk. Ebben az esetben a munkafüzet nevét idézõjelek közé kell írnunk. Ha nem mûködik az utasítás, akkor lehet, hogy nincs ilyen névvel megnyitott munkafüzet, hiszen az elõbb mindet lezártuk, így a Munkafüzet10-est is. Ha most is ezt próbáljuk lezárni, akkor hibaüzenet jelenik meg. Ha egy már elmentett munkafüzetre szeretnénk a nevével hivatkozni, akkor az idézõjelek közé annak a fájlnak a nevét kell írnunk, amelyikbe elmentettük. Ilyenkor az XLS kiterjesztést is hozzá kell venni a névhez! workbooks("Munkafüzet12").activate

A Workbooks gyûjtemény egyik elemét aktiválhatjuk. Ha szeretnénk programból egy másik munkafüzetet aktiválni, akkor erre használjuk az Activate metódust. Itt is igaz az elõbb leírt gondolat, miszerint a már elmentett munkafüzetre a fájlnévvel hivatkozhatunk. ?activeworkbook.saved

Amikor egy munkafüzetben tartalmi vagy formai módosítást hajtunk végre, akkor az alkalmazás beállítja, hogy a munkafüzetben változtattunk, de nem mentettük el a változásokat. Mivel mi még semmit nem változtattunk a munkafüzeten, ezért a fenti kérdésre Igaz (True) választ kapunk. activeworkbook.saved=false

Ha szükségét látjuk, mi is beállíthatjuk ezt a Saved tulajdonságot. Ha ezután megpróbáljuk lezárni a munkafüzetet például az activework-

138



13. fejezet


book.close utasítással, akkor a program figyelmeztetni fog arra, hogy szükség esetén mentsük el a munkafüzetet. Worksheets Egy tetszõleges munkafüzet munkalapjait gyûjti össze.

Munkalapok gyûjtemény és objektumok A munkafüzetben pillanatnyilag használatban lévõ munkalapok (Worksheets) is gyûjteményt alkotnak. Ismerkedjünk meg a munkalapokon végezhetõ néhány mûvelettel. Mivel az elõzõ gyakorlatok során megnyitottunk és lezártunk munkafüzeteket, most az tûnik a legjobb megoldásnak, ha lezárjuk az összes munkafüzetet és megnyitunk egy újat. Esetleg lépjünk ki az Excel-bõl és indítsuk újra. Ez azért jó, mert akkor a munkafüzetetek számozása ismét a Munkafüzet1-el kezdõdik. Ha végeztünk, számoljuk meg hány lapja van az aktív munkafüzetnek. Most is a gyûjteménynek Count metódusát használjuk. ?worksheets.count

Vehetünk fel új lapokat a munkafüzetbe? Igen! Melyik metódus használatával? Az Add metódussal. Minden gyûjteménynek van Add metódusa? Tehát most is a jól bevált módszerrel bõvíthetjük a gyûjteményünket új elemmel. Worksheets.add

Az Add metódust már használtuk a munkafüzetek gyûjtemény esetén. Most ugyanezt használhatjuk a munkalapok gyûjteményhez is. Az aktív munkafüzethez ugyanezzel a módszerrel adhatunk hozzá egy új munkalapot. Ezzel az utasítással az aktuális munkafüzet Worksheets gyûjteményét bõvítettük újabb munkalap – WorkSheet – objektummal. A következõ példa megértéséhez kezdjünk még két új munkafüzetet. Ezt a Workbooks.add utasítás többszöri végrehajtásával tehetjük meg. Most a Munkafüzet1 munkafüzet éppen a legalsó. Legfelül látható munkafüzet az aktív. Workbooks(1).Worksheets.add

A munkalapok – Worksheets – gyûjteményt bõvíthetjük egy-egy elemmel, Worksheet objektummal. Azt is meghatározhatjuk, hogy melyik munkafüzetbe helyezünk új munkalapot. Ehhez a megfelelõ munkafüzet objektumra is rá kell mutatnunk. Az elõzõ utasítás tehát nem az aktív munkafüzetet bõvíti egy lappal, hanem azt, amelyiket legkorábban hoztuk létre, vagy nyitottuk meg, hiszen erre hivatkoztunk.

139



Az Excel objektumai

3. rész

?worksheets(1).name

A Worksheets gyûjtemény sorrendben elsõ objektumának a nevét írathatjuk ki a fenti utasítással. Ugyanazt a tulajdonságot használjuk fel, mint amivel a munkafüzet nevét kiírattuk. A tulajdonság ugyanaz, de az objektum már más. A munkafüzet lapjaira is hivatkozhatunk a zárójelbe írt számmal, de most nem az érkezési sorrend a számozás alapja, hanem a munkafüzetben elfoglalt hely. Tehát a Worksheet objektum a Worksheets gyûjtemény egyik eleme, amire indexeléssel is hivatkozhatunk. worksheets(1).name="Számítások"

A munkalap neve, ellentétben a munkafüzet nevével megváltoztatható. Ezt a kiszemelt munkalap objektum Name – név – tulajdonságának az átírásával tehetjük meg. Erre példa a fenti utasítássor. Ez az utasítás az aktív munkafüzet elsõ lapjának a nevét változtatja meg. ?worksheets.add.name

Ez egy érdekes több funkciós utasítás. Egyfelõl, végrehajtja az Add metódust, másfelõl kiírja az új munkalap nevét. Tehát egyszerre hajtunk végre egy metódust és íratunk ki egy tulajdonságot. worksheets.add.name = "Adatok"

Copy A Copy metódussal másolatot készíthetünk egy munkalapról.

Az elõzõ utasítást kissé átalakítva azt is megtehetjük, hogy programból beszúrunk egy új munkafüzet lapot és a beszúrás pillanatában már el is nevezzük. Ebben az utasításban ismét együtt használjuk a metódust és a tulajdonságot. Worksheets("Számítások").copy Before:=Worksheets(2)

A Copy metódussal munkalapokat másolhatunk. A Before paraméterben meghatározhatjuk, hogy melyik munkalap elé kerüljön a másolt munkalap. Figyeljük meg a munkalap nevét. Mivel két egyforma nevû munkalap nem lehet egy munkafüzetben, ezért a másolat neve Számítások(2) lesz. Ezzel az utasítással létrehoztunk egy új munkalapot, amit a munkalap gyûjtemény megfelelõ helyére be is fûztünk. Az új munkalap és a befûzés mûveleteket a Copy metódus oldotta meg. Worksheets("Számítások").copy Ê before:=Workbooks("Munkafüzet2").worksheets(2)

140



13. fejezet


Ezzel az utasítással a számítások munkalapot egy másik munkafüzetbe másoltuk át. Az utasítást csak akkor hajthatjuk végre hibaüzenet nélkül, ha valóban van Munkafüzet2 nevû munkafüzetünk. Ha nincs, válasszunk olyan munkafüzet nevet, amelyik létezik. Worksheets("Számítások").move Before:=Worksheets(4)

Move Ezzel a metódussal áthelyezhetjük a munkalapot egy másik helyre. A hely lehet akár egy másik munkafüzet is.

A Move metódus áthelyezi a munkalapot egy másik helyre. Most nem másolat készül, hanem csak áthelyezés. Természetesen ebben az esetben is választhatunk célként másik munkafüzetet. Worksheets("Számítások").copy Select

Ha nem határozzuk meg a Before paramétert, akkor új munkafüzetet nyit a másolandó munkalapnak, és ebbe az új füzetbe másolja a meghatározott munkalapot.

Azt az objektumot jelölhetjük ki, amelyiknek a Select metódusát használtuk.

worksheets(2).select

Kiválasztja a munkafüzet második lapját. Ebben a hivatkozásban is használhatjuk a munkalap nevét. Például: worksheets("Számítások").select worksheets(Array(1,4,6)).select

Egyszerre több munkalapot is kiválaszthatunk. A fenti utasítás eredményeként a Munka1, Munka4 és a Munka6-os munkalap lesz kiválasztva, vagyis csoportba foglalva. activesheet.select

Ha több munkalap van egyszerre kijelölve, akkor az a munkalap az aktív amelyiknek a neve vastag betûvel látszik. Ezzel az utasítással megszûnik a csoportba foglalás és csak az aktív munkalap lesz kiválasztva. A következõ példához ismét hajtsuk végre a csoportba foglalást elvégzõ utasítást. worksheets(Array(1,4,6)).select

Sheets

worksheets(4).activate

A csoportba foglalt munkalapok közül a megjelölt – negyedik – munkalapot teszi aktívvá. Ha egy olyan munkalapra mutatunk, amelyik nem

141


A Sheets gyûjtemény magába foglalja a munkafüzet összes lapját, azok típusától függetlenül.


Az Excel objektumai

3. rész

volt a csoportba foglalt lapok között, akkor ugyanúgy viselkedik, mint a Select utasítás, vagyis megszünteti a csoportba foglalást és kiválasztja a megcímzett munkalapot. ?sheets.count Charts A Charts gyûjtemény a munkafüzetben elhelyezett diagramlapok csoportja.

Windows A munkafüzetek ablakokban jelennek meg. Az ablakok gyûjtemény neve a Windows.

Megszámolja az aktív munkafüzetben található összes lapot. A Sheets is gyûjtemény, és az adott munkafüzet összes lapját magába foglalja. ?Worksheets.count

Csak a munkalapokat számolja meg, vagyis a Worksheets gyûjtemény elemeinek a számáról ad tájékoztatást, tehát azokról, amelyeken számolni szoktunk. A diagram lapok megszámlálásához a ?Charts.Count utasítást kell kiadnunk.

Ablakok gyûjtemény, ablak objektum Az Excelben megnyitott ablak nem azonos a munkafüzettel. Csak annyi a kapcsolatuk, hogy a munkafüzet is egy ablakban jelenik meg. A következõ gyakorlatokhoz elegendõ lesz egy megnyitott munkafüzet. Tehát zárjuk le a felesleges munkafüzeteket, majd a VBE próbaablakba írjuk be a következõ utasítást: ActiveWindow.NewWindow

Arrange Az Excelben megnyitott ablakok elrendezését állíthatjuk be az Arrange tulajdonsággal.

Azonos azzal a mûvelettel, amikor az Ablak (Window) Ø Új ablak (New window) utasítást hajtjuk végre. Az utasítás végrehajtása létrehoz egy új ablakot az aktív munkafüzethez. Tehát két ablakban is ugyanazt a munkafüzetet látjuk. Windows.arrange arrangestyle:=1

Ebben az utasításban az Arrange metódus segítségével egymás mellé rendeztük a Munkafüzet1 ablakait. A metódusnak az Arrangestyle argumentuma mögötti egyes szám a mozaik elrendezés meghatározását szolgálja. Windows.arrange arrangestyle:=xlcascade

Az utasítás ugyanaz, mint az elõzõ volt, de most nem egy számmal határoztuk meg, hogy milyen legyen az ablakok elrendezése, hanem egy Excel belsõ állandóval. Ez az állandó egy számot helyettesít. Ha a próbaab-

142



13. fejezet


lakba beírjuk a ?xlcascade utasítást, akkor megtudhatjuk azt, hogy ez az állandó a hetes számot rejti. Windows(2).activate

A kaszkád elrendezésû ablakok közül a legfelsõ az egyes számú. Tehát most a felülrõl számított második ablak kerül felülre. Ezzel viszont a felülre került ablak sorszáma egyes lett. Másképpen fogalmazva, ha a Windows(1).activate utasítást adjuk ki, akkor semmi nem történik, hiszen ez az aktív ablak és ez már az utasítás kiadása elõtt is aktív volt. activewindow.activatenext

Ezzel az utasítással átléphetünk a sorrendben következõ ablakba. Ha ugyanis aktiválunk egy ablakot, akkor a legutóbb használt ablak a sor végére kerül. Így az utasítás többszöri végrehajtásával egyenként végiglépkedhetünk az alkalmazásban jelenleg létezõ ablakokon. ?activewindow.caption

Ez az utasítás kiírja az éppen aktív ablak feliratát. Figyelem ez nem azonos a munkafüzet nevével. Ez csak a jelenleg aktív ablak felirata. Ha most lekérdezzük a munkafüzet nevét, akkor látni fogjuk a különbséget. activewindow.caption="Az én ablakom"

Az aktív ablak feliratát megváltoztathatjuk. Ez nem a munkafüzet neve, csak az ablaké. Az utasításait érdemes ismét kipróbálni. Tehát az ablak feliratát megváltoztathatjuk programból, de a munkafüzet nevét nem. Ilyet már korábban is csináltunk, amikor átírtuk az Excel alkalmazás címét. Akkor is a Caption tulajdonságot használtuk.

A Cells gyûjtemény a munkalap celláira mutat. Egy eleme mindig egy cellát takar.

Cellák és tartományok Lépjünk át az Excelbe és zárjuk le a megnyitott ablakokat. Csak egy munkafüzet egy ablaka legyen nyitva. Ismerkedjünk egy kicsit a munkalapon található cellákkal, tartományokkal. Adjuk ki a következõ utasítást! cells.select

A fenti utasítással az éppen aktív munkalap összes celláját kijelöljük, mivel a Cells objektumgyûjteménnyel végeztünk mûveletet. Ennek a parancsnak a végrehajtása ugyanazt eredményezi, mintha a munkalap bal

143


Cells


Az Excel objektumai

3. rész

felsõ sarkára kattintanánk. A cells gyûjteménynek nincs Add metódusa. A cellák száma ugyanis kötött és nem lehet megváltoztatni a számukat. cells(1).select

A cells gyûjtemény elsõ eleme a kiválasztott munkalap A1-es cellája. Vagyis a cella meghatározása során is meg kell mondanunk, hogy a cellák gyûjtemény melyik tagját szeretnénk kijelölni. A cella meghatározása a Cells objektum mögötti zárójelbe írt számmal lehetséges. A cellák számozása a munkalap bal felsõ cellájától kezdõdik és jobbra haladva növekszik. cells(5).select

Az elsõ cellasor ötödik cellájának a kiválasztása. cells(257).select

Ez az utasítás a második cellasor elsõ celláját jelöli ki. Ez azért van, mert egy sorban 256 cella van, és ha ezt túllépjük, akkor már a következõ cellasor valamelyik cellájára mutat. cells(16777216).select

A jelenlegi munkalap legutolsó celláját választja ki. cells(2,3).select

A Cells gyûjtemény egyik elemét meghatározhatjuk a sorszám és az oszlopszám megadásával is. A fenti utasítás zárójelében két számot látunk egymástól vesszõvel elválasztva. Az elsõ számmal a sorszámot határozhatjuk meg, a másodikkal pedig az oszlop számot. cells(65536,256).select

Ennek az utasításnak a végrehajtásakor ugyanaz lesz az eredmény, mintha a cells(16777216).select utasítást adtuk volna ki. Cells(1) = 400

A cell objektum tulajdonságainak értéket is adhatunk. A legutóbb kiadott select-tel a munkalap legutolsó celláját kiválasztottuk ki, azaz a legutolsó cella aktív. Ha kiadjuk a fenti utasítást, akkor ezzel úgy írhatunk adatot a munkalap egyes cellájába, hogy nem választjuk ki azt.

144



13. fejezet


Az utasítás végrehajtása után lépjünk vissza az A1-es cellára. Ott fogjuk találni a 400-as számot. Ebben az utasításban a Cells(1) cella Value tulajdonságát állítottuk be. Tehát pontosan, így kellett volna leírni az utasítást: Cells(1).value = 400 jelezve ezzel azt, hogy az objektum melyik tulajdonságát kívánjuk módosítani. Erre most azért nem volt szükség, mert minden objektumnak van egy alapértelmezett tulajdonsága, a cella objektumé az érték – Value – tulajdonság. range("c3").select

A tartomány objektum neve: Range. Ezzel hivatkozhatunk egy cellára vagy több cellából álló tartományra. Jelen esetben egy cellára hivatkozunk, nevezetesen a C3-asra. A hivatkozás egyik módja, ha a Range gyûjtemény zárójelébe idézõjelek közé beírjuk a cella A1 típusú címét. Ezt a Cells gyûjteményben nem tehetjük meg, ezért a programozáskor gyakran cellahivatkozásra is ezt az utasítást használjuk.

37. ábra: Tartomány kijelölése range("b2:d5").select

A Range gyûjteménybõl kijelöljük a B2:D5-ös tartományt. Itt a kijelölendõ tartomány bal felsõ és jobb alsó celláját használjuk fel a tartomány meghatározására (37. ábra). range("b2,c4,d1,a5").select

Egyszerre több tartományt is kijelölhetünk. Ennek az írásmódja azonban eltér a munkafüzetben használttól. A tartományokat itt vesszõvel kell elválasztani egymástól, függetlenül a Windows nemzetközi beállításától. range(cells(2,2),cells(5,4)).select

145


Range Jelentése tartomány. Segítségével tartományra hivatkozhatunk. A tartomány állhat egyetlen cellából is.


Az Excel objektumai

3. rész

Columns Egy tartomány oszlopaira hivatkozhatuk ezzel a gyûjteménnyel.

Rows Egy tartomány soraira hivatkozhatuk ezzel a gyûjteménnyel.

Ennek a tartománykijelölésnek az érdekessége az, hogy a Range paramétereiben a Cells gyûjtemény két tagja van. A zárójelek közötti két cellahivatkozás a tartományt határoló cellákat jelöli (37. ábra). ?cells.count ?columns.count ?rows.count

Az elsõ utasítás a munkalap Cells gyûjteményének az elemszámát határozza meg, a második a Columns gyûjtemény elemeit számolja meg, míg a harmadik a Rows gyûjtemény elemeinek a számát adja vissza eredményként. A Count módszert használjuk fel arra, hogy a gyûjtemény elemeinek a számát lekérdezzük. Most azért a teljes munkalap celláinak, sorainak és oszlopainak a számát határoztuk meg, mert ha nem mondjuk meg, hogy melyik tartományra gondolunk, akkor az éppen aktív munkalappal dolgozik a program. ?Range("A1:D6").cells.Count ?Range("A1:D6").columns.Count ?Range("A1:D6").rows.Count

Ha szükséges, akkor megszámolhatjuk egy tartomány celláinak, oszlopainak, vagy sorainak a számát is. A következõ példa beírása elõtt jelöljünk ki egy cellatartományt. Ehhez adjuk ki például a Range("b2:c7").select utasítást. ?selection.cells.count ?selection.columns.count ?selection.rows.count

Az éppen kijelölt tartományra a Selection objektumnévvel hivatkozhatunk. Ennek a jellemzõit is megtudhatjuk a fenti utasításokkal. A Selection objektumnak a tulajdonságai és metódusai egyeznek a Range objektuméval.

Currentregion A kijelölt, aktív tartományt körülvevõ adattartományra hiatkozhatunk a segítségével.

Adattartomány w Programozás során gyakran használunk adatokkal kitöltött tartományokat. Ezek jellemzõire is szükségünk lehet a program írása közben. A következõ példákban olyan gyakorlatokat végzünk el, amivel az adattartományok kezelését ismerhetjük meg. Lépjünk át az Excelbe és töltsük be az Adattart.xls munkafüzetet. Ez után ismét állítsuk vissza a környezetet úgy, hogy a Visual Basic szerkesztõ az Excel elõtt legyen és ismerkedjünk meg néhány lehetõséggel. Álljunk az A1-es cellára. Ehhez adjuk ki a Cells(1).select utasítást.

146



13. fejezet


38. ábra: Hivatkozás az aktuális adatterületre Selection.currentregion.select

Az éppen kijelölt cellát vagy tartományt körülvevõ adattartományra hivatkozhatunk a fenti paranccsal. Range("b5").currentregion.select

Hivatkozhatunk olyan adattartományra is, amelyik nem a jelenleg kijelölt cella körül van. Ilyenkor meg kell mondanunk azt is, hogy melyik cella körüli adattartománnyal szeretnénk mûveletet végezni. Ebben az esetben egy Range objektumra hivatkozva kell kezdeni az utasítást és mögé kell írni a currentregion objektumot, majd elvégezni a kívánt mûveletet. Ez a példában a kijelölés. Az egyszerûség kedvéért a további kijelöléseket vagy adattartomány hivatkozásokat kezdjük a Range – tartomány – meghatározásával. ?Selection.SpecialCells(xlCellTypeBlanks).count

A kiválasztott cella környezetében található üres cellák száma az eredmény. Ennek az utasításnak a végrehajtása során nem kellett kijelölni a tartományt. Range("a1").SpecialCells(xlCellTypeBlanks).select

Az A1-es cella környezetében található üres cellákat jelölhetjük ki. A kijelölés az utolsó celláig tart. Itt az utolsó cella nem a munkalap utolsó celláját jelenti, hanem az utolsó még kitöltött cellát. Válasszuk ki ismét az

147


SpecialCells Az ugrás párbeszédpanelbõl elérhetõ speciális kijelölést programozhatjuk ezzel a hivatkozással.


Az Excel objektumai

3. rész

A1-es cellát, és számoljuk meg, hogy mennyi üres cella van az éppen kijelölt cella környezetében.

39. ábra: SpecialCells objektum és a paraméterei

148



13. fejezet


A SpecialCells beírásakor, amint a zárójelhez érünk, a lenyíló listapanel felkínál néhány Excel állandót. Ezeknek a nevébõl kiderül, hogy melyiket kell kiválasztanunk egy adott speciális jelöléshez. Ezeket a cellákat kijelölhetjük, megszámolhatjuk és különféle Range objektum tulajdonságokat és metódusokat használhatunk. Végezzünk el néhány kijelölést vagy írassuk ki a meghatározott cellák számát a felsorolt cellatípusokra vonatkozóan, majd zárjuk le a munkafüzetet. Relatív tartományok kezelése w Kezdjünk egy üres munkafüzetet, és ennek az egyik munkalapján hozzunk létre egy adattartományt. A Visual Basic szerkesztõ próbaablakába írjuk be a következõ utasítást: Range(B2:F10)= "Adat"

Ezzel az utasítással a B2:F10-es tartomány mindegyik cellájába beírtuk az Adat szöveget. Ezután álljunk az adattartomány területén belül egy cellára, például a Range(B3).select utasítással. Adjuk is ki! Range(B3).select

Azért, hogy jobban követhessük az elvégzett gyakorlatokat, ezen az adattartományon fogunk dolgozni. Ha a tartomány egyik celláján állunk, akkor erre a tartományra a Selection.CurrentRegion hivatkozással mutathatunk rá. Ha az adattartományon kívül lévõ cellán állunk, akkor a helyes hivatkozás például a Range("a2").currentregion is lehet. Ezekben

Rows A Rows gyûjtemény elemével hivatkozhatunk egy adott tartomány tetszõleges sorára.

40. ábra: Az aktuális adattartomány nulladik sorát jelöltük ki a példákban azzal ismerkedhetünk meg, hogy ha egy tartománnyal mûveletet szeretnénk végrehajtani, akkor elegendõ hivatkozni a megfelelõ cellára. Álljunk tehát az adattartomány egyik cellájára. Selection.currentregion.rows(0).select

Most a Selection.CurrentRegion egy tartományhivatkozás. Ezt a mûveletet bármelyik tartománnyal elvégezhetjük. Ebben az utasításban a tartomány objektum nulladik sorát jelöltük ki. Ez éppen az aktuális adattartomány feletti sor. Ha nem határozzuk meg az aktuális tartományt,

149



Az Excel objektumai

3. rész

vagyis csak azt írjuk be, hogy rows(1).select, akkor az aktuális munkalap elsõ cellasorát fogjuk kiválasztani az utasítással. Most azonban mivel meghatároztuk, hogy melyik tartomány sorát szeretnénk megjelölni, csak olyan szélességben jelöltük ki a cellasort, amilyen széles az aktuális tartomány. Álljunk ismét az adattartomány területére (Range(B3).select), majd utána adjuk ki a következõ utasítást: Selection.currentregion.rows(1).font.bold = true

Columns Egy adott tartomány megfelelõ oszlopára hivatkozhatunk a segítségével.

Offset Az Offset ideiglenesen áthelyezi az A1-es cellát

Figyeljük meg, hogy ennek az utasításnak az eredményeként az adattartomány elsõ cellasorának betûi félkövérek lettek. Ezt a Font.bold tulajdonság beállításával értük el. Most azonban a hivatkozást érdemes megfigyelni. Ez a Selection.currentregion.rows(1). Ezzel a hivatkozással az adott tartomány elsõ sorára hivatkoztunk. Hasonló módon az elsõ oszlop cellaformázását is megváltoztathatjuk, ha a következõ utasítást is végrehajtjuk: Selection.currentregion.columns(1).font.bold = true

Az A1-es cella áthelyezése w Szükségünk lehet arra, hogy egy adott cellához viszonyítva, attól egy megfelelõ távolságra elhelyezkedõ tartományra hivatkozzunk. Ebben az esetben az A1-es hivatkozást áthelyezhetjük a munkalap bármely pontjára. A következõ utasítások segítségével nem csak a kijelölt vagy aktuális tartomány sorait vagy oszlopait fogjuk címezni, hanem egy adott cellához viszonyított tartományt. Ehhez választanunk kell egy viszonyítási pontot. Ez lehet egy cella vagy egy tartomány, ilyenkor a tartomány bal felsõ cellája a viszonyítási pont. Írjuk be a következõ parancsot az Immediate ablakba és hajtsuk is végre: range("c4").Select

A mi esetünkben ez a viszonyítási pont selection.currentregion hivatkozásnak megfelelõen a az adattartomány bal felsõ cellája. Ez jelen esetben a munkalapon a B2-es cellája. Hajtsuk tehát végre a következõ utasítást: selection.currentregion.offset(2,3).range("a1:a3").select

A mûvelet végrehajtása után az adattartomány bal felsõ cellájától három oszloppal jobbra és két sorral lejjebb hivatkozik az offset. Az utasítás eddigi része az így meghatározott pontra helyezte át az A1-es cella hivatkozását. Az offset mögé írt range objektum az offset által megjelölt cellát

150



13. fejezet


tekinti A1-es cellának. Így tehát a range("a1:a3") hivatkozás nem a munkalap A1:A3-as tartományát jelöli meg, hanem az offset által meghatározott cellához viszonyított A1:A3-as tartományt. Az offset és a range kom-

41. ábra: Az Offset eltolja az A1-es cella helyét binációival egy cellához vagy egy tartomány bal felsõ cellájához viszonyított bármilyen tartományt kijelölhetünk. Az offset argumentumai negatív számok is lehetnek, ezzel a viszonyítási pont elõtti cellák egyikére mutathatunk.

Rajz objektumok Zárjuk le mentés nélkül azt a munkafüzetet, amelyikbe eddig dolgoztunk, és kezdjünk egy új, üres munkafüzetet. Ebben most a rajz objektumokkal végezhetõ mûveletek közül vizsgálunk meg egy párat. Az elsõ legyen az, hogy hogyan használhatjuk az Add metódust a rajzok esetén. ActiveSheet.Rectangles.Add(45, 9, 72, 30).Select

42. ábra: Téglalap

151


Rectangles Téglalapok gyûjtménye


Az Excel objektumai

3. rész

Az aktív munkalapra rajzolunk egy téglalapot a fenti utasítással. Az Add metódus zárójelei között található számok sorrendben a következõ értékek: bal oldal távolsága a munkalap bal szélétõl, a téglalap felsõ oldalának a távolsága a munkalap tetejétõl, a téglalap szélessége és végül a téglalap magassága. Selection.Interior.ColorIndex = xlNone Shapes Office rajz alakzatok gyûjtemény. Használhatjuk mindegyik Office alkalmazásban.

A téglalap hátterének (Interior) a ColorIndex tulajdonságát megváltoztathatjuk. A jelenlegi az átlátszó, de, ha ide például az xlNone helyére egy hármast írunk, akkor a téglalap színezése piros lesz, mert a színpaletta harmadik színe a piros. A munkalaphoz nem csak téglalapot adhatunk hozzá programból, hanem az Excelben új rajzalakzatokat is. Ezt egy kicsit másképpen kell

43. ábra: Office rajz objektum megtennünk, mint a téglalap hozzáadását. Tehát ismerkedjünk meg az új elemek kezelésével is. Például: ActiveSheet.shapes.addshape(msoshape16pointstar,Ã 50,20,100,100).select

A fenti utasítás egy 16 ágú csillagot helyez el az éppen aktív munkalapra. Ha másik munkalapra hivatkozunk, akkor arra kerül rá a rajzalakzat. Az utasításban szereplõ msoshape16pointstar egy Office állandó. A zárójelen belül ez az elsõ argumentum. Ez határozza meg azt, hogy milyen alakzatot adunk hozzá a kijelölt munkalaphoz. A többi négy szám szerepe ugyanaz, mint az elõbb elkészített téglalap esetén, vagyis a hely és a méret meghatározása. Ezeket a változókat megtaláljuk a súgóban. activesheet.shapes(1).select

A rajzalakzatok kiválasztására használjuk ezt az utasítást. A zárójelbe írt szám az elhelyezés sorrendjének felel meg, tehát most a téglalap lesz

152



13. fejezet


kiválasztva. Ha a zárójelbe kettest írunk, akkor pedig a csillag. Tegyük ezt meg és változtassuk meg a színét a csillagnak. selection.shaperange.fill.Ã onecolorgradient, msogradientvertical ,1,0.25

Színátmenetes kitöltést adtunk az alakzatnak. Az elsõ paraméter a msogradientvertical ez a függõleges irányú színátmenet beállítását végzi. Az állandó nevébõl kiolvasható a választás hatása. A második paraméter az átmenet változó. Ennek az értéke 1 és 4 között lehet. Ez azt határozza meg, hogy hol legyen az átmenet: a bal oldalon, a jobboldalon, a szélek legyenek világosabbak, vagy a középsõ rész legyen világos. A harmadik pedig egy nulla és egy közötti érték: az átmenet erõssége állítható be vele. selection.characters.text = "Szöveg megjelenítése"

A kiválasztott alakzatba szöveget írhatunk. Erre példa a fenti utasítás.

44. ábra: Készítsünk egy ehhez hasonló diagramot!

Diagram objektumok Mielõtt ezekbe a gyakorlatokba belefognánk, ismét kezdjünk egy új munkafüzetet és ebbe készítsünk el egy diagramot. Ezen fogjuk kipróbálni a diagram objektumok néhány lehetõségét. A diagram létrehozása után alakítsuk ki a megfelelõ környezetet a gyakorlatokhoz. activesheet.chartobjects.item(1).select

153



Az Excel objektumai

3. rész

Miután átléptünk a Visual Basic szerkesztõbe, válasszuk ki a diagramot. A diagram kiválasztása a fenti utasítással történik. A zárójelbe írt szám a létrehozás sorrendjének felel meg. A diagramok esetén a kiválasztott diagramokkal végezhetünk mûveleteket. activechart.chartwizard gallery:=xl3dline

Az elkészített és aktív diagram diagramtípusát tetszés szerint megváltoztathatjuk. Erre a diagramvarázsló eljárást használjuk fel. A Galery paraméter mögé különféle Excel állandókat írhatunk be. Ezek mindegyike a nevében hordja a formázás hatását. activechart.chartwizard format:=2

A varázsló másik argumentuma a Format, ezzel a diagram osztásait állíthatjuk be. Ide a diagram típusától függõen a kétdimenziós diagramok esetén 1 és 10 közötti számot írhatunk, míg más diagramoknál ennél kevesebb lehetõség közül választhatunk. activechart.chartwizard categorylabels:=2

A diagram kategóriatengelyének a feliratát az adattábla elsõ oszlopaiból készíti el a varázsló. Itt változtathatunk ezen. Az utasítás értéke azt határozza meg, hogy hány oszlop kerüljön a kategóriatengely alá feliratként. Ha kipróbáltuk állítsuk vissza az egyes értéket. activechart.SeriesCollection(1).select activechart.Legend.Select

Ezzel az utasítással megjelölhetjük a diagram egyik adatsorát. A zárójelbe írt szám az adatsor sorszáma. Más diagramelemeket is megjelölhetünk. A Legend például a jelmagyarázat. activechart.HasTitle= True

A fenti utasítás a diagramhoz ad egy szövegdobozt. Ez a diagram címe lesz. Mivel még nem határozhattuk meg a tartalmát, ezért egy alapértelmezett szöveg jelenik meg benne. Ez a magyar Excelben „Diagramcím”, az angolban „Chart title”. Hasonló módon a kategória tengelyhez és az értéktengelyhez is rendelhetünk feliratot. activechart.Axes(xlcategory,xlPrimary) .hastitle = true

154



13. fejezet


A kategóriatengely feliratának a megjelenítésére használható tulajdonság-beállítást látjuk. Ha az xlcategory Excel-állandó helyére az xlvalue állandót írjuk, akkor ugyanezzel az utasítással az értéktengely mellé készíthetünk feliratot. activechart.ChartTitle.Characters.Text = "Bemutató" activechart.Axes(xlcategory,xlPrimary).axistitle.characters Ã .text ="Kategória" activechart.Axes(xlvalue,xlPrimary) .axistitle.characters.text ="Érték"

A fenti három utasítássor a már létrehozott feliratok tartalmának a megváltoztatására szolgál. Ezeket az utasításokat, csak akkor használhatjuk, he elõtte már létrehoztuk a tengelyek feliratait. activechart.Legend.Select selection.position= xlLeft

A fenti utasítás segítségével meghatározhatjuk a diagram jelmagyarázatának a helyét. A jelmagyarázat helyére az Excel állandók szövegei utalnak: xlLeft, xlRight, xltop és az xlbottom. ActiveChart.Rotation = 15

A diagram Rotation tulajdonságának beállítását arra használhatjuk, hogy programból a kívánt irányba fordítsuk a diagramot. A Rotation értéke 0 és 360 fok között lehet. Ez a beállítás csak a háromdimenziós diagramoknál használható!

Összefoglalás A VBE Immedite ablakában közvetlenül kiadott parancsok hatását megfigyelve megismerhetjük az objektumok tulajdonságait metódusait. Az objektumok jellemzõit a program felkínálja, amint az objektum neve mögé pontot írunk. A felkínált nevekbõl kitalálhatjuk, hogy melyik tulajdonságnak, vagy metódusnak mi a feladata. A háttérben elhelyezett Excelben azonnal megnézhetjük a mûveletek eredményét.

155





14. fejezet

Makró készítése felvétellel iután megismerkedtünk az Excel néhány objektumával és olvastunk a Visual Basic for Application utasításairól, ismerkedjünk meg az egyik legegyszerûbb, leggyorsabb programozási módszerrel a makró rögzítéssel. A legegyszerûbben ezzel a módszerrel automatizálhatjuk a napi feladatainkat. Közben az Excel megír egy-egy eljárást, amibõl sokat tanulhatunk az objektumok tulajdonságairól, metódusairól. Ezért minden elkészített makró-felvételt érdemes kielemezni. Ennek elsõdleges célja, hogy közelebb kerüljünk az Excel objektumaihoz. Lássuk, milyen kérdésekre kaphatunk választ ebbõl a fejezetbõl. w w w w w

Hogyan készíthetünk felvétellel eljárást? Hova kerülnek a felvett programok? Mit tanulhatunk a felvett eljárásból? Hogyan módosítatjuk a rögzített makrót? Hogyan érdemes elkezdeni egy program megírását?

Makró rögzítése Amint egy makró rögzítésébe fogunk, az elsõ, hogy meghatározzuk, melyek azok a mûveletek, amelyeket szeretnénk automatizálni. Ha a feladat sok lépésbõl áll, akkor többször gyakoroljuk el, mielõtt a felvételt elkezdenénk, ugyanis makró rögzítéskor az Excel minden kis mozdulatunkat hûen megõriz. Például, ha nem azon a cellán állunk a felvétel megkezdésekor, amelyiken kell, és felvétel közben módosítunk a cella kijelölésén, akkor a makró végrehajtásakor a program is megváltoztatja a cella kijelölését, és innen fog indulni a lejátszás. A most következõ felvétel egy egyszerû példa lesz. Ezt arra használjuk, hogy megismerjük a makró-rögzítés körülményeit, eszközeit. Készítsünk el egy olyan felvételt, amelyik az aktuális munkalap elsõ celláiba automatikusan beírja a munkafüzet készítõjének az adatait. Az adatok beírását 157


Makró rögzítés Egy makró rögzítése során az Excel egy eljárásban megjegyzi a végrehajtott mûvelteket.


Az Excel objektumai

3. rész

kezdje a program az A1-es cellától, és innen továbbhaladva töltse ki a megfelelõ cellákat a megfelelõ adatokkal. Készítsük elõ a feladatot. Töltsünk be egy üres munkafüzetet és álljunk az A1-es cella kivételével bármelyik cellára. Írjuk le egy papírra, hogy milyen lépéseket szeretnénk rögzíteni a felvétel során. A felvenni kívánt mûveletek a következõ lépésekbõl fognak állni: Elõkészítés írjuk le a rögzíteni kívánt makró lépéseit.

Az egérrel kattintsunk az A1-es cellára. (mert ugye nem azon álltunk) Gépeljük be, a Készítette szöveget. Kattintsunk a B1-es cellára. Gépeljük be a nevünket. Kattintsunk az A2-es cellára. Írjuk be a Vállalat szót. Kattintsunk a B2-es cellára. Gépeljük be a vállalatunk nevét. Üssük le az ENTER billentyût.

1. 2. 3. 4. 5. 6. 7. 8. 9.

Miután papírra rögzítettük az elgondolásunkat, belekezdhetünk a makró rögzítésébe. A programrögzítés megkezdésekor meghatározhatjuk a felvett eljárás helyét, nevét és, hogy mi legyen az a billentyûkombináció, amelynek hatására elindíthatjuk majd az elkészített programot.

A felvételi jellemzõk meghatározása A felvétel elindítása során egy kicsit még másra kell figyelnünk. Ugyanis az Excel most kérdezi meg, hogy hova szeretnénk rögzíteni a programot. Azt is itt adhatjuk meg, hogy milyen billentyû-kombinációval induljon majd el a rögzített eljárás. CD melléklet 14 Fejezet Rogzites_1.xls

45. ábra: A makró felvétel lépései

158



14. fejezet

Makró készítése felvétellel

Kezdjük el a felvételt (45. ábra)! Tehát az A1-es cella kivételével bármelyik cellán állhatunk a felvétel megkezdésekor. 1. Válasszuk ki az Eszközök (Tools) Ø Makró (Macro) Új makró rögzítése (Record New Macro) utasítást. 2. A Makrónév (Macro name) szerkesztõdobozba írjuk be a rögzítésre kerülõ program nevét: Keszitette. 3. A Parancsbillentyû (Shortcut key) dobozba írjuk be azt a billentyûkombinációt, amivel majd el fogjuk indítani az elkészült programot. Ez legyen a k betû.

Rögzítés indítása A felvételt az Eszközök Ø Makró Ø Új makró paranccsal indíthatjuk el.

Hova készüljön a felvétel A makró helye (Store macro in) listapanelben meghatározhatjuk, hogy hova kerüljön a felvett program. A lista lenyitása után három lehetõség közül választhatunk. Egyéni makró munkafüzetbe w (Personal Macro Workbook) Ez egy olyan munkafüzet, amit az Excel akkor hoz létre, amikor elkészítjük az elsõ makró felvételt. Az új munkafüzet neve Personal.xls lesz és automatikusan az XlStart mappába fogja menteni az Excel. Tehát a Personal.xls mentésérõl nem nekünk kell gondoskodnunk. Ez a munkafüzet rejtve marad. Az XlStart mappa feladata, hogy az Excel elindításakor betöltse azokat a munkafüzeteket is, amelyeket ide mentettünk. Vagyis ezt a mappát arra is felhasználhatjuk, hogy azokat a munkafüzeteket, amellyel a napi munkáinkat kezdjük ide mentjük, így az Excel elindítása után nem kell külön gondoskodnunk arról, hogy ezeket betöltsük. Ezt a tulajdonságát használjuk fel arra, hogy a Personal.xls minden elindítás után be legyen töltve. Ezt a munkafüzetet azért nem látjuk, mert amikor a program létrehozta és elmentette, akkor rejtett volt, így az újabb betöltés után is rejtett marad. Ez a mappa az újabb operációs rendszerekben a felhasználói profilhoz van hozzárendelve. A felvétel készítésekor az Excel a következõ mappába mentette a Personal.xls fájt. C:\Documents and Settings\Kovalcsik Géza\Application Data\Microsoft\Excel\XLSTART Ha az Office program közös XLSTART mappájába helyezzük át ezt a munkafüzetet, akkor az Excel minden esetben betölti függetlenül attól, hogy ki jelentkezett be a gépre. A közös XLSTART mappa a következõ helyen található: C:\Program Files\Microsoft Office\OFFICE11\XLSTART

159


A felvett makró helye A makró rögzítés kezdetén meghatározhatjuk, a felvétel helyét

Xlstart Ez egy speciális mappa. Azok a munkafüzetek amelyeket ide mentettünk, automatikusan betöltõdnek az Excel indításakor.


Az Excel objektumai Futtatható eljárások Csak azokat az eljárásokat tudjuk elindítani, amelyeket betöltöttünk. Ezért az eljárásokat tartalmazó munkafüzeteket be kell tölteni.

3. rész

Minderre azért van szükség, mert csak azokat az eljárásokat futtathatjuk, amelyek egy megnyitott munkafüzetben vannak. Az Excel úgy menti el a füzetet, hogy rejtett állapotban töltõdjön be. Így nem zavarja a felhasználót egy üresen megnyitott dokumentum. Új munkafüzetbe w (New Workbook) Ha ezt a lehetõséget választjuk, akkor az Excel a felvétel elindítása után létrehoz egy üres munkafüzetet, és abba fogja rögzíteni a felvételt. Ennek a mentésérõl nekünk kell majd gondoskodnunk, ahogy arra is nekünk kell majd figyelnünk, hogy a felvett makrót csak akkor tudjuk használni, ha azt elõbb betöltjük. Persze ha mi is elmentjük az XlStart mappába, akkor ez a munkafüzet is betöltõdik az Excel indításakor. A kérdés az, hogy milyen módszerrel tudjuk mi is rejtetten elmenteni a munkafüzetünket. Ha ugyanis elrejtjük, nem tudjuk menteni. A módszer az, hogy rejtsük el a füzetet, majd lépjünk ki az Excelbõl. Az Excel észreveszi, hogy a betöltés óta változtattunk rajta. A változtatás jelen esetben az, hogy elrejtettük. Amikor rákérdez a rejtett füzet mentésére, válaszoljuk azt, hogy szeretnénk elmenteni. Így a következõ betöltéskor rejtve marad. Ebben a munkafüzetben w (This Workbook) A felvétel a jelenleg használt munkafüzetbe készül. A felvett makrót minden alkalommal használhatjuk, ha elõtte betöltjük ezt a munkafüzetet. Ezt a lehetõséget rendszerint akkor érdemes választani, amikor olyan programot készítünk, amelyet csak egy munkafüzetben szeretnénk használni. A három lehetõségbõl válasszuk az Ebben a munkafüzetben (This Workbook) lehetõséget. Lépjünk tovább a felvétel elkészítésében:

Rögzítés vége A bal oldali gombbal állíthatjuk le a felvételt

4. Kattintsunk az OK gombra. Figyeljük meg, hogy bekapcsolódott egy eszköztár. Ezen találjuk meg azt a gombot, amelyikkel majd leállítjuk a felvételt (a bal oldali gomb). 5. Végezzük el a begyakorolt mûveletsort, majd a mûveletek végrehajtása után állítsuk le a felvételt. Ezt a felvétel indításakor megjelenõ eszköztár Rögzítés vége gombjával tehetjük meg. Ha az eszköztár nem jelenne meg, akkor válasszuk ki az Eszközök (Tools) Ø Makró (Macro) Rögzítés vége (Stop Recording) utasítást. A felvétel kész, ha szükséges ki is próbálhatjuk egy üres munkalapon. Ehhez elegendõ, ha átlapozunk egy üres munkalapra és leütjük a CTRL+ k billentyûkombinációt.

160



14. fejezet


A makró panel

Makró panel

A munkánk eredményének egyik jelét a makró párbeszédpanelben láthatjuk. Kapcsoljuk be a panelt az Eszközök (Tools) Ø Makró (Macro) Makrók (Macros) utasítás segítségével. Ebben a panelben a következõket fogjuk találni:

Ebben a párbeszédpanelben megtaláljuk az általános modulokba felvett eljárások nevét. Innen elindíthatjuk a makrót.

Makrónév w (Macro Name) A megjelenõ párbeszédpanel Makró név listájában felsorolja azokat a makrókat, amelyek jelenleg elérhetõek az Excelben, vagyis már betöltöttük õket. Ha több makrót rögzítettünk, akkor a Makrónév (Macro Name) listában több elem lesz. Indítás w (Run) Ha a listában felsorolt programok közül valamelyiket el szeretnénk indítani, akkor válasszuk ki a futtatandó program nevét és kattintsunk az Indítás (Run) gombra. Lépésenként w (Step Into) Lépésenként haladhatunk végig az utasításokon. Ha erre kattintunk, akkor betöltõdik a Visual Basic szerkesztõ és megjelenik az éppen kiválasztott makró. Szerkesztés w (Edit) Betölti a Visual Basic szerkesztõt és elénk tárja azt a makrót, amelyiket elõzõleg kijelöltünk a listában. Létrehozás w (Create) Ha a panel Makrónév szerkesztõdobozba beírunk egy új nevet, akkor aktívvá válik ez a gomb. Ha ezután rákattintunk átkerülünk a Visual Basic Editor programba és ott egy új eljárást találunk, amelynek a neve az lesz amit beírtunk a név mezõbe. Az eljárásba beírhatjuk a saját utasításainkat, így új makrót hozhatunk létre. Törlés w (Delete) gomb lenyomásával töröljük a listában kijelölt eljárást. Egyebek w (Options) gombra kattintva megjelenik egy párbeszédpanel. Ebben lehetõségünk van a billentyûkombináció utasítás megváltoztatására. Ha valamilyen okból a rögzítés beállításakor nem választottunk volna billentyûkombinációt, akkor ezt utólag meghatározhatjuk a listából kijelölt makróhoz.

Finomítsuk a felvételt

Felvétel szerkesztése

Amint elkészültünk egy makró rögzítésével érdemes megnézni az eredményt. Ehhez kapcsoljunk át a Visual Basic Editor-ba és nyissuk meg azt a modult, amibe az Excel az eljárást beírta. Itt a következõ programot találjuk:

161


A felvett makró egy önálló eljárás lesz. Nyissuk meg és egyszerûsítsük a lépéseket.


Az Excel objektumai

3. rész

Sub Készítette() ‘ ‘ Készítette Makró ‘ Rögzítette: Kovalcsik Géza, dátum: 2005 ‘ ‘ Billentyûparancs: Ctrl+k ‘ Range("A1").Select ActiveCell.FormulaR1C1 = "Készítette" Range("B1").Select ActiveCell.FormulaR1C1 = "Kovalcsik Géza" Range("A2").Select ActiveCell.FormulaR1C1 = "Vállalat" Range("B2").Select ActiveCell.FormulaR1C1 = "Help Key Bt" Range("B3").Select End Sub Hivatkozzunk, ne jelöljünk! Programból úgy dolgozunk az objektumokkal, hogy hivatkozunk rájuk.

A rögzített makró rendszerint több lépésben oldja meg a feladatot, mint mi tennénk. Most is így történt. A rögzítés esetén ugyanis ki kell jelölnünk azt a cellát, amivel dolgozni szeretnénk. Amikor az objektumokkal ismerkedtünk, megtanultuk, hogy nem kell kijelölnünk azokat az objektumokat, amelyekkel mûveleteket végzünk, elegendõ hivatkozni rájuk. Ez jelen esetben azokat a cellákat jelenti, amelyekbe beírtunk. Írjuk át a programot úgy, hogy csak hivatkozásokat használjunk: Sub Készítette() ‘ ‘ Készítette Makró ‘ Rögzítette: Kovalcsik Géza, dátum: 2005 ‘ ‘ Billentyûparancs: Ctrl+k ‘ Range("A1").Value = "Készítette" Range("B1").Value = "Kovalcsik Géza" Range("A2").Value = "Vállalat" Range("B2").Value = "Help Key Bt" End Sub

Ezzel valóban rövidebbé, áttekinthetõbbé tettük az eljárást, de még van mit csinosítani rajta. Például a felhasználó és a vállalata nevét lekérdezhetjük az Application objektumból. Ez azért jobb, mert így a makró bárhol a ténylegesen regisztrált felhasználó nevét fogja a megfelelõ cellába írni. A kész eljárás tehát így fog mutatni:

162



14. fejezet


Sub Készítette_megoldasa() ' ' Készítette Makró ' Rögzítette: Kovalcsik Géza, dátum: 2005 ' ' Billentyûparancs: Ctrl k ' Range("A1").Value = "Készítette" Range("B1").Value = Application.UserName Range("A2").Value = "Vállalat" Range("B2").Value = Application.OrganizationName End Sub

CD melléklet 14 Fejezet Rogzites_1.xls

Adattartomány keretezése Készítsünk felvétellel olyan makrót, amelyik bekeretez és megvonalaz egy tetszõleges méretû adattartományt. A felvételt úgy készítsük el, hogy amikor futtatjuk, akkor képes legyen bármekkora adattartományon mûködni. A felvételt a Personal.xls fájlba hozzuk létre. A felvétel elõkészítéséhez hozzunk létre egy adattartományt. Ebben állva fogjuk elindítani a felvételt.

Körülmények A makró felvétel körülményeit nekünk kell megteremtenünk. Most például egy adatokkal kitöltött tartományt.

CD melléklet 14 Fejezet Rogzites_2.xls

46. ábra: Adattartomány keretezése elõkészítõ lépései

163



Az Excel objektumai

3. rész

1. Jelöljünk ki egy több cellából álló tetszõleges méretû tartományt. 2. Írjuk az éppen aktív cellába a Tart szöveget. 3. Üssük le a CTRL+ENTER billentyûkombinációt. A felvétel elkezdése elõtt álljunk az adattartomány egyik cellájára. A sikeres felvétel érdekében lépésrõl lépésre pontosan hajtsuk végre a formázást. Kezdjük el a rögzítést! Figyeljünk arra, hogy a felvétel megkezdése elõtt az adattartomány egyik celláján álljunk, ahogy ezt a 46. ábra is szemlélteti. 1. Válasszuk ki az Eszközök (Tools) Ø Makró (Macro) Ø Új makró rögzítése (Record New Macro) utasítást. 2. A megjelenõ párbeszédpanelben adjunk nevet a felvételre váró makrónak. Ez a név a Keretezes legyen. A Makró helye (Store macro in) listapanelbõl válasszuk ki az Egyéni makrómunkafüzetben (Personal Macro Workbook) lehetõséget. A beállítások után kattintsunk az OK gombra. Amit mostantól csinálunk, azt az Excel rögzíti egy Keretezes nevû eljárásban. 3. Üssük le a CTRL+* billentyûkombinációt. Ezzel kijelöljük az aktuális adattartományt. 4. Válasszuk ki a Formátum (Format) Ø Cellák (Cells) utasítást. 5. Lapozzunk a Szegély (Border) lapra. 6. A tartomány külsõ keretét állítsuk be kettõs vonalra. 7. Rajzoljunk egybefüggõ vonalat a cellák közé. 8. Állítsuk meg a felvételt, azaz kattintsunk a rögzítés vége gombra. Nézzük meg a felvétel eredményét, és amennyire lehet egyszerûsítsük le a rögzített lépéseket. Sub Keretezés() ‘ ‘ Keretezés Makró ‘ Rögzítette: Kovalcsik Géza, dátum: 2005 ‘ ‘ Selection.CurrentRegion.Select Selection.Borders(xlDiagonalDown).LineStyle = xlNone Selection.Borders(xlDiagonalUp).LineStyle = xlNone With Selection.Borders(xlEdgeLeft) .LineStyle = xlDouble .Weight = xlThick .ColorIndex = xlAutomatic End With With Selection.Borders(xlEdgeTop)

164



14. fejezet


.LineStyle = xlDouble .Weight = xlThick .ColorIndex = xlAutomatic End With With Selection.Borders(xlEdgeBottom) .LineStyle = xlDouble .Weight = xlThick .ColorIndex = xlAutomatic End With With Selection.Borders(xlEdgeRight) .LineStyle = xlDouble .Weight = xlThick .ColorIndex = xlAutomatic End With With Selection.Borders(xlInsideVertical) .LineStyle = xlContinuous .Weight = xlThin .ColorIndex = xlAutomatic End With With Selection.Borders(xlInsideHorizontal) .LineStyle = xlContinuous .Weight = xlThin .ColorIndex = xlAutomatic End With End Sub

Ez az eljárás bizony elég hosszúra sikerült ahhoz képest, hogy alig állítottunk be valamit. Ezen van mit egyszerûsíteni. Emlékezzünk arra, hogy miket állítottunk be. Az Excel minden állítási lehetõséget rögzített, még azokat is, amikhez hozzá se nyúltunk. De vegyük sorra a lépéseket, és próbáljuk elhagyni a felesleges sorokat. Selection.CurrentRegion.Select

Az elsõ sor az, amelyik kijelöli az aktuális adattartományt. Ez a sor az eredménye annak, hogy leütöttük a CTRL+* billentyûkombinációt. A Selection kulcsszó arra a tartományra hivatkozik, amelyik éppen ki van jelölve. A CurrentRegion a kijelölt – Selection – környezetében található adattartományra hivatkozik, amit aztán a Select metódussal ki is jelölünk. Erre szükkségünk van, ezt ne töröljük. Lépjünk tovább! Nézzük meg a következõ két sort. Selection.Borders(xlDiagonalDown).LineStyle = xlNone Selection.Borders(xlDiagonalUp).LineStyle = xlNone

165



Az Excel objektumai

With End With Ezzel az utasításpárral egy objektum több tulajdonságát is beállíthatjuk.

3. rész

Ez a cellákon keresztbe húzott vonalak jellemzõit adja meg. De hiszen mi nem is húztunk a cellákba átlós vonalat. Az érték is xlNone, vagyis, hogy nincs ez a vonal. Ha nincs, akkor miért kell beállítani? Röviden szólva ez a két sor teljesen felesleges ebben az eljárásban. Töröljük is ki mindjárt. Nézzük meg a következõ beállítást. Itt egy érdekes kulcsszót találunk Ez a With és a párja az End With. Ezt az utasításpárt arra használjuk, hogy ne kelljen többször egymás után megismételnünk annak az objektumnak a hivatkozását, amelynek több tulajdonságát is beállítjuk. A következõ sorok az adattartomány bal szélére húzott vonal több jellemzõjét is beállítják. Emlékezzünk csak vissza, hogy mi mit is állítottunk. Csak és kizárólag a vonal típusát! Azt állítottuk be, hogy a tartomány bal szélére kerülõ vonal kettõs vonal legyen. A többi lépés felesleges: With Selection.Borders(xlEdgeLeft) .LineStyle = xlDouble .Weight = xlThick .ColorIndex = xlAutomatic End With

Tehát, a félkövérrel jelölt sorokat akár ki is törölhetjük az eljárásból. Igen ám, de a With és End With sorok között már csak egy tulajdonság van. Akkor nincs szükség erre az utasítás-párra. A fenti öt sorból tehát egyetlen sor marad, ez pedig a következõ: Selection.Borders(xlEdgeLeft).LineStyle = xlDouble

Hasonlóan végiggondolva a tartomány további széleinek a szegélyezését az eljárásunk végül így fog mutatni. Sub Keretezés() ‘ ‘ Keretezés Makró ‘ Rögzítette: Kovalcsik Géza, dátum: 2005 ‘ ‘ Selection.CurrentRegion.Select Selection.Borders(xlEdgeLeft).LineStyle = xlDouble Selection.Borders(xlEdgeTop).LineStyle = xlDouble Selection.Borders(xlEdgeBottom).LineStyle = xlDouble Selection.Borders(xlEdgeRight).LineStyle = xlDouble With Selection.Borders(xlInsideVertical) .LineStyle = xlContinuous .Weight = xlThin

166



14. fejezet


.ColorIndex = xlAutomatic End With With Selection.Borders(xlInsideHorizontal) .LineStyle = xlContinuous .Weight = xlThin .ColorIndex = xlAutomatic End With End Sub

Most eljutottunk addig, hogy az adattartomány széleinek a szegélyezését erõsen lerövidítettük. Hátramaradt a tartomány celláit elválasztó vonalak formázása. Ezekkel pont úgy bánhatunk el, mint a tartomány szélére húzott vonalakkal. Tehát a félkövérrel jelölt sorokból ennyi marad! Sub Keretezés() ‘ ‘ Keretezés Makró ‘ Rögzítette: Kovalcsik Géza, dátum: 2005 ‘ ‘ Selection.CurrentRegion.Select Selection.Borders(xlEdgeLeft).LineStyle = xlDouble Selection.Borders(xlEdgeTop).LineStyle = xlDouble Selection.Borders(xlEdgeBottom).LineStyle = xlDouble Selection.Borders(xlEdgeRight).LineStyle = xlDouble Selection.Borders(xlInsideVertical).LineStyle = _ xlContinuous Selection.Borders(xlInsideHorizontal).LineStyle = _ xlContinuous End Sub

Vajon ezen még lehet egyszerûsíteni? Mindenképpen! Nézzük meg az elsõ sort! Ott az áll, hogy jelöljük ki az aktuális cellák körül található adattartományt. Aztán a kijelölt tartománnyal végezzük el a beállításokat. Tényleg ki kell jelölni a tartományt ahhoz, hogy bekeretezzük? Nem! Elegendõ csak hivatkozni. A második sortól kezdve a Selection hivatkozásokat cseréljük le Selection.CurrentRegion hivatkozásra. Az eljárásunk ilyenné válik: Sub Keretezés() ‘ ‘ Keretezés Makró ‘ Rögzítette: Kovalcsik Géza, dátum: 2005

167



Az Excel objektumai

3. rész

‘ ‘ Selection.CurrentRegion.Borders(xlEdgeLeft).LineStyle = _ xlDouble Selection.CurrentRegion.Borders(xlEdgeTop).LineStyle = _ xlDouble Selection.CurrentRegion.Borders(xlEdgeBottom).LineStyle = _ xlDouble Selection.CurrentRegion.Borders(xlEdgeRight).LineStyle = _ xlDouble Selection.CurrentRegion.Borders(xlInsideVertical).LineStyle = xlContinuous Selection.CurrentRegion.Borders(xlInsideHorizontal).LineStyle _ = xlContinuous End Sub

_

Most használjuk a With… End With utasításpárt, és ezzel elértünk a kész eljáráshoz. A végeredmény tehát ez: CD melléklet 14 Fejezet Rogzites_2.xls

Sub Keretezés_megoldas() ‘ ‘ Keretezés Makró ‘ Rögzítette: Kovalcsik Géza, dátum: 2005 ‘ ‘ With Selection.CurrentRegion .Borders(xlEdgeLeft).LineStyle = xlDouble .Borders(xlEdgeTop).LineStyle = xlDouble .Borders(xlEdgeBottom).LineStyle = xlDouble .Borders(xlEdgeRight).LineStyle = xlDouble .Borders(xlInsideVertical).LineStyle = xlContinuous .Borders(xlInsideHorizontal).LineStyle = xlContinuous End With End Sub

Tehát a felvétel finomítása során szabaduljunk meg a felesleges soroktól, majd a kijelöléseket írjuk át úgy, hogy azokból hivatkozás legyen. Ha lehetõség van rá, használjuk a With.. End With utasításpárt.

168



14. fejezet


Jelentés kiegészítése Tegyük fel, hogy többször is kapunk olyan listákat, amelyekben nincsenek teljesen kitöltve a sorok. A lista egyes oszlopaiba, csak akkor írnak be adatot, ha attól kezdve megváltozik az oszlop értéke. Ráadásul minden esetben más a mérete a listának. Nem ugyanannyi a sorok vagy oszlopok száma. CD melléklet 14 Fejezet Rogzites_3.xls

47. ábra: A félkész jelentést így szeretnénk kiegészíteni Tehát a 47. ábra bal oldalán látható lista elrendezésbõl szeretnénk a jobb oldalon lévõ állapotot létrehozni. Erre több módszer is van egyik gyorsabb, a másik lassabb, de valahogy mégiscsak eredményre juthatunk. Elsõ lépésként jelöljük ki a tartomány üres celláit. 1. Álljunk a tartomány egyik cellájára, olyan helyre, hogy a cellában legyen adat. 2. Üssük le a CTRL+* billentyûket. Ezzel kijelöltük az aktuális adattartományt. 3. Hajtsuk végre a Szerkesztés (Edit) Ø Ugrás (Go To) parancsot. 4. A megjelenõ Ugrás panel alján találunk egy gombot, melynek a felirata Irányított (Special). Ha erre rákattintunk, akkor megjelenik egy újabb panel, amelyben hasznos kijelöléseket választhatunk. 5. Ebben a panelben jelöljük ki az Üres cellák (Blank Cells) választógombot, és kattintsunk a panel OK gombjára. Tehát most ott tartunk, hogy kijelöltük az összes üres cellát (170. oldal 48. ábra). Írjunk az összes cellába egy olyan képletet, amelyik a felette található cella értékét jeleníti meg. Ehhez hajtsuk végre a következõ lépéseket:

169



Az Excel objektumai

3. rész

48. ábra: az adattartomány üres cellának a kijelölése 1. Írjunk be az aktív cellába egy egyenlõség jelet. 2. A billentyûzeten üssük le a felfelé mutató nyíl billentyût. 3. Üssük le a CTRL+ENTER billentyû-kombinációt. És már ki is töltöttük a listát. Még szüntessük meg a cellákba írt képelteket. Ehhez: 1. jelöljük ki az egész adattartományt a CTRL+* billentyû-kombinációval. 2. Üssük le a CTRL+C billentyûket, ezzel a táblázatunkat a vágólapra helyeztük. 3. Most irányított beillesztéssel tegyük vissza az adatainkat ugyanarra a helyre. Szerkesztés (Edit) Ø Irányított beillesztés (Paste Special). 4. A megjelenõ párbeszédpanelbõl válasszuk ki az Értéket (Value) lehetõséget. 5. Szüntessük meg a másolás villogó jeleit az ESC billentyû segítségével. Nos, ha mindezzel végeztünk, akkor most már ideje makróként rögzíteni ezt a több lépésbõl álló mûveletsort. Tegyük is meg és nézzük meg a felvétel eredményét. A program mindössze ennyi: Sub JelentesKitolt() ‘ ‘ JelentesKitolt Makró ‘ Rögzítette: Kovalcsik Géza, dátum: 2005 ‘

170



14. fejezet

Makró készítése felvétellel CD melléklet 14 Fejezet

‘ Selection.CurrentRegion.Select Selection.SpecialCells(xlCellTypeBlanks).Select Selection.FormulaR1C1 = “=R[-1]C” Selection.CurrentRegion.Select Selection.Copy Selection.PasteSpecial Paste:=xlPasteValues, _ Operation:=xlNone, SkipBlanks _ :=False, Transpose:=False Application.CutCopyMode = False End Sub

Rogzites_3.xls

Ha megnézzük a felvétel eredményét itt nem is sokat kell egyszerûsíteni az eljáráson. Ezt önállóan oldjuk meg.

Összegezve Makró rögzítéssel egyszerû feladatokat oldhatunk meg. Ezt az eszközt felhasználhatjuk arra is, hogy megismerkedjünk az egyes objektumok metódusaival, tulajdonságaival. A feladat egyszerû elkészítünk egy makró felvételt, majd az eredmény kielemezve beépítjük a programunk megfelelõ helyére. A Makró rögzítés az egyik legnagyobb tanítómester, ha az objektumok tulajdonságait és metódusait használatát szeretnénk a magunkévá tenni. Egy-egy összetett makró elkészítésének lehet az elsõ lépése az, hogy felvétellel rögzítjük azokat a mûveleteket, amelyeket szeretnénk végrehajtani, majd ezt kiegészítjük vezérlõ utasításokkal.

171





15. fejezet

Vezérlés eseményekkel

int azt láttuk a programvezérlõ utasításokkal foglalkozó fejezetben, az utasítások a végrehajtását különbözõ feltételekhez köthettük. Ezt úgy tehettük meg, hogy a program változóit vizsgáltuk és ezek pillanatnyi értékétõl függõen hajtottunk végre más-más utasításcsoportokat. A mûveletek végrehajtását az objektumok eseményeinek bekövetkezésével is vezérelhetjük. Így például, meghatározhatjuk azt, hogy milyen utasításokat hajtson végre a program, amikor megnyitunk egy munkafüzetet, vagy mi történjen, ha az egyik munkalapról egy másikra lapozunk. Az eseményeket, az objektumok készítõi határozták meg, vagyis mi az elõre meghatározott eseményeket használjuk. Ebben a fejezetben ismerkedjünk meg az események kezelésével. A kérdések a következõk: w w w w

Hol találjuk az eseményeket? Milyen eseményei vannak az Excel objektumainak? Honnan tudjuk az esemény utáni állapotot? Mire használjuk fel az objektumok eseményeit?

Az objektumok eseményei Kezdjük az ismerkedést egy egyszerû példával. Nyissunk meg egy munkafüzetet és lépjünk át a programozási környezetbe. Ennek legegyszerûbb módja, ha leütjük az ALT+F11 billentyû-kombinációt. Azt már láttuk, hogy kell elkezdeni egy új modult, most ismerkedjünk meg azzal, hogy hogyan használhatjuk az objektumok elõre elkészített moduljait. Amint átkapcsoltunk a programozási környezetbe, vegyük szemügyre a projekt ablakot. Itt megtaláljuk az egyes munkalapokhoz és a munkafüzethez tartozó modulok ikonjait. Ezek az adott munkafüzet lapjainak a nevét viselik. A munkafüzet modulját ThisWorkbook-nak nevezte el a program. Kattintsunk kettõt az egyik munkalap ikonjára (174. oldal 49. ábra). Azt tapasztaljuk, hogy megnyílik egy modul. Ez már akkor is a 173


Események Az eseményeket eseményvezérelt eljárásokban valósították meg. Ezeket az objektumok moduljaiban találjuk.


Az Excel objektumai

3. rész

munkafüzet része volt, amikor megnyitottuk a munkafüzetet. A modul baloldali listáját nyissuk le. Ez az objektum lista. Itt válasszuk ki a Worksheet lehetõséget.

49. ábra: Jelenítsük meg az eseményvezérelt eljárásokat Ezután az ablak jobboldali listájából kiválaszthatjuk azokat az eseményeket, amelyekhez programot szeretnénk írni. Amint a listából kiválasztjuk a kiszemelt eseményt, a modullapon megjelenik egy eseményvezérelt eljárás. Ebbe az eljárásba kell leírnunk azokat az utasításokat, amelyeket akkor szeretnénk végrehajtani, amikor az adott esemény bekövetkezik. Az eseményeket minden munkalapon megtaláljuk, így ez munkalaponként lehet más és más.

Események paraméterei Az eseményvezérelt eljárások paraméterei adatot adnak át az eseményvezérelt eljárásnak.

Munkalap események w Amint a baloldali objektum listapanelbõl kiválasztottuk a Worksheet objektumot, rögtön megjelenik a munkalapok alapértelmezett eseményvezérelt eljárása, a SelectionChange. Ez az esemény akkor következik be, amikor megváltoztatjuk a munkafüzet celláinak a kijelölését. Vagyis amint az egyik tartomány helyett egy másikat jelölünk meg. Vegyük egy kicsit szemügyre ennek az eseménynek a szerkezetét. Figyeljük meg, hogy az eljárás neve mögötti zárójelben változó, vagy változók vannak. Mit kezdhetünk a változókkal? Ezek a változók a környezetrõl adnak át adatot ennek az eljárásnak. Az átadott értékeket megvizsgálhatjuk, és a változók tartalmától függõen vezérelhetjük a programot. A SelectionChange eseményben ez az érték a Target, ebbõl a változóból azt tudhatjuk meg, hogy a jelölés megváltoztatása után melyik az újonnan kijelölt tartomány. Ebben az eseményben különbözõ mûveleteket hajthatunk végre az újonnan kijelölt Target objektummal. Próbaként írjunk egy egyszerû parancsot az eseménybe. A kijelölt tartomány vagy cella hátterét színezzük be sárgára, amint kijelöljük az

174



15. fejezet


adott tartományt. Ezt egyetlen utasítással megvalósíthatjuk. Íme az eljárás:

CD melléklet 15 Fejezet

Private Sub Worksheet_SelectionChange(ByVal Target As _ Excel.Range) Target.Interior.ColorIndex = 6 End Sub

Esemeny_1.xls

Miután az utasítást beírtuk az elsõ munkalap SelectChange eljárásába, kapcsoljunk át az Excelbe. Jelöljünk ki néhány tartományt. Figyeljük meg, hogy a kijelölt tartományok háttérszíne a jelölés megváltoztatásának hatására sárga lesz. Ez a SelectionChange eseménybe írt utasítás eredménye. Megpróbálhatjuk, mi történik egy másik munkalapon a jelölés megváltoztatása után. Az eredmény semmi. Ez azért van, mert csak az egyik munkalap eseményét programoztuk. Munkafüzet eseményei w Ha azt szeretnénk, hogy egy adott munkafüzet minden lapja ugyanúgy viselkedjen a jelölés megváltoztatása, akkor ehhez nem kell minden munkalap SelectChange eseményét külön-külön utasításokkal ellátni, hanem a munkafüzet megfelelõ eseményét kell programoznunk. Ennek a megértésére is készítsük el ugyanezt a választ a jelölés megváltoztatására. A munkalap SelectChange eljárásából töröljük a beírt utasítást.

50. ábra: A munkafüzet eseményei Zárjuk le a munkalap modulját, majd nyissuk meg a munkafüzet objektum modulját. A projekt ablakban kattintsunk kettõt a munkafüzet moduljára (ThisWorkbook). Most is nyissuk le a baloldali listát. Váltsunk át a Workbook objektumra. A jobboldali listában most az Open esemény az

175



Az Excel objektumai CD mellékllet 15 Fejezet Esemeny_2.xls

3. rész

alapértelmezett. Nyissuk le a modul jobb oldali eseménylistáját és válasszuk ki a SheetSelectionChange eseményt. Ide írjuk be az elõbbi utasítást. Az esemény tehát ilyen képet fog mutatni: Private Sub Workbook_SheetSelectionChange _ (ByVal Sh As Object, ByVal Target As Excel.Range) Target.Interior.ColorIndex = 8 End Sub

Most visszalapozhatunk az Excel-be és kipróbálhatjuk a munkafüzet bármelyik munkalapján a jelölés megváltoztatását. Azt fogjuk tapasztalni, hogy a jelölés megváltoztatása esemény minden munkalapon átszínezi a kijelölt cellákat. Vagyis ha egy-egy esemény bekövetkezésére nem csak egy munkalapon szeretnénk a saját programunkkal reagálni, akkor a munkafüzet megfelelõ eseményét kell utasításokkal ellátnunk. Természetesen itt már több környezeti adatot kapunk. Az Sh arra a munkalapra mutat, amelyiknek megváltoztattuk a tartomány kijelölését. Mi most is csak a Target környezeti változót fogjuk használni. Most már a munkafüzet bármelyik lapján ugyanaz történik, amikor megváltoztatjuk a tartomány kijelölését. Tehát attól függ, hogy melyik eseményt fogjuk programozni, hogy egy munkalapra vagy a munkafüzet minden lapjára szeretnénk érvényesíteni az eseményben leírt utasításokat.

Események alkalmazása

CD melléklet 15 Fejezet

Oldjunk meg néhány egyszerû, szemléltetõ példát az események programozásáról. Ezekbõl kiderül, hogy miként használhatjuk fel az eseményvezérelt eljárásokban kívülrõl kapott értékeket. Az elsõ példában programozzuk úgy az egyik munkalapot, hogy annak az elsõ két oszlopában található cellákat semmilyen módon ne lehessen kijelölni. Ha a felhasználó mégis az elsõ két oszlop valamelyik cellájára kattintana, akkor automatikusan lépjünk át a harmadik oszlopba. Ott az a cella legyen aktív, amelyik sorba a felhasználó bele kattintott. A példa célja az, hogy megismerjük a külsõ – Target – változó használatát. Olyan módon kell megírnunk a programot, hogy amikor nem az elsõ vagy második oszlopba kattint a felhasználó, akkor ne történjen semmi. Nyissunk meg egy új munkafüzetet. Lépjünk át a VBE-be. Nyissuk ki a Munka1 munkalaphoz tartozó modult. A SelectionChange eseményvezérelt eljárásba írjuk be a következõ programot:

Esemeny_3.xls

Private Sub Worksheet_SelectionChange(ByVal Target As Range) If Target.Column < 3 Then Cells(Target.Row, 3).Select End If

176



15. fejezet


End Sub

Ahogy látható a Target egy Range típusú hivatkozás. Vagyis pont ugyanazok a tulajdonságai, mint bármelyik Range hivatkozásnak. Azt, hogy egy kijelölt tartomány jobb felsõ cellája melyik oszlopba esik, a Range objektum a Column tulajdonsága árulja el. Ezt a lehetõséget kihasználva megvizsgáljuk, hogy az újonnan kijelölt tartomány bal felsõ cellája benne van-e a munkalap elsõ két oszlopában. Ha igen, akkor átlépünk a harmadik oszlopban vele azonos sorban lévõ cellára. Írjuk meg a kis programot, és próbáljuk ki a mûködését. Ha bármely tartomány kijelöléséhez szeretnénk programot írni, akkor éljünk azzal a lehetõséggel, hogy a Target tartomány jellemzõihez hozzáférünk. Megállapíthatjuk, hogy hányadik sorban és oszlopban kezdõdik. Ahogy azt is megtudhatjuk, hány soros és oszlopos a Target. Nézzünk egy másik példát! Ebben azt próbáljuk ki, hogy az eseményvezérelt eljárásokból hogyan lehet értéket visszaadni az objektumnak. Érdekes módon erre az eseményvezérelt eljárás zárójelei közé írt változókat használhatjuk fel. Ha a munkafüzet tetszõleges cellájára kettõt kattintunk, akkor a cella átmegy szerkesztési állapotba. A kettõs kattintás eseményhez a BeforeDoubleClick eljárást programozták. Írjunk most egy olyan kiegészítõ programot, amelynek a segítségével egy inputbox függvényben megadott értéket írunk abba a cellába, amelyre kettõt kattintott a felhasználó. Természetesen, miután az inputbox függvénnyel kitöltöttük a cellát, nincs szükség arra, hogy átkerüljünk szerkesztési állapotba. A felhasználói felületen a kettõs kattintás eredménye az, hogy az adott cellát átváltjuk szerkesztési állapotba. Mivel az inputbox adatát írjuk a cellába nincs szükség arra, hogy az adat beírása után átváltsunk szerkesztési állapotba. Arra, hogy a cella feltöltése után ne kerüljön a cella szerkesztési állapotba, a BeforeDoubleClick esemény Cancel változóját fogjuk felhasználni. A programban határozzuk meg azt is, hogy a mûveletet csak a munkalap második oszlopában a második sortól végezze így az Excel. Nézzük az eljárást! Nyissuk meg a munkafüzet második munkalapjához tartozó modult. Válasszuk ki a BeforeDoubleClick eseményvezérelt eljárását. Ebbe írjuk be a következõ sorokat:

Az eseményekbõl értéket is adhatunk vissza. Erre az esemény egyik másik paraméterét használhatjuk fel.

CD melléklet 15 Fejezet Esemeny_4.xls

Private Sub Worksheet_BeforeDoubleClick(ByVal Target As Range, _ Cancel As Boolean) Dim varAdat As Variant Const STR_UZENET As String = “Milyen adatot írjak a cellába?” Const STR_CIM As String = “Szerkesztés” If Target.Column = 2 And Target.Row > 1 Then varAdat = InputBox(STR_UZENET, STR_CIM, Target.Value) Target.Value = varAdat Cancel = True

177


Visszaadott érték


Az Excel objektumai

3. rész

End If End Sub

Ha ez az esemény bekövetkezik, megjelenik egy inputbox párbeszédpanel. Ebbe beírhatunk egy tetszõleges értéket. Amint a panel OK gombjára kattintunk, az adat bekerül abba a cellába, amelyikre kettõt kattintottunk. Ha az eljárás utolsó sorában nem adtunk volna True értéket a Cancel változónak, akkor az adat beírása után, a kiválasztott cella, szerkesztési állapotba kerülne. Mivel a Cancel változónak az if-en belül adtunk értéket, a többi cellában nem változik meg a kettõs kattintás hatása.

Egyéb események Programozás során használhatunk olyan eseményeket is, amelyek nem kapcsolódnak objektumhoz. Ezeket egy-egy utasítással lehet aktívvá tenni. Az aktiváló utasítás kiadása közvetlenül nem hajt végre mûveletet, de ha bekövetkezik az esemény amelyiknek a figyelését elindítottuk, akkor egy általunk meghatározott eljárást indíthatunk el. OnTime w Az OnTime eseményt idõzítésre használhatjuk. Megtehetjük például, hogy egy eljárást egy adott idõpontban futtassunk le, vagy egy adott idõ elteltével. Ehhez készítsünk egy egyszerû példaprogramot. A program a segítségével egy kisiskolás gyakorolni tudja az összeadást. A program adjon fel egy összeadási feladatot, majd egy meghatározott idõ eltelte után írja ki az összeadás eredményét. Ennek a feladatnak az a célja, hogy megismerjük az idõzítés esemény használatát. Elõször még csak gondolatban, egyszerû mondatokkal fogalmazzuk meg a program lépéseit. 1. Tegyünk rendet: az esetleges korábbi feladatok eredményeit tüntessük el a cellákból. 2. Egy-egy változóban rögzítsük a két számot, (bytA,bytB) amit össze kell adni. A számok egy és tíz közötti egész értéket vehegynek fel. 3. Végezzük el az összeadást. Ennek az értékét egy harmadik változóban tároljuk (bytC). 4. Írjuk ki a feladatot. 5. Állítsuk be a várakozási idõt. Ha letelt, akkor hajtsuk végre azt az eljárást, amelyik kiírja az összeadás eredményét. Fogjunk hozzá a program megírásához. A feladat megoldása két eljárás lesz. Az egyik feladja a feladatot, a másik egy meghatározott idõ elteltével kiírja a megoldást. Kezdjünk egy új munkafüzetet. Nyissuk meg a VBE programot. Az új munkafüzetben hozzunk létre egy új program modult. Ebbe az új modulba

178



15. fejezet


kezdjük el írni az új eljárást. A neve Gyakorlás legyen, tehát írjuk le, hogy Public Sub Gyakorlás.


Dim bytA as Byte Dim bytB as Byte Dim bytC as Byte Public Sub Idozites() 'Az eredményt tartalmazó cellák törlése Range("A1:C2") = "" 'A számok elõállítása veletlenszám függvénnyel bytA = Int(Rnd(1) * 10) + 1 bytB = Int(Rnd(1) * 10) + 1 'Az eredmény kiszámítása bytC = bytA + bytB 'A feladat kiíratása Range("A1") = bytA Range("B1") = bytB 'A válasz cella kiválasztása Range("C1").Select 'Öt másodperc múlva írja ki az eredményt Application.OnTime Now + TimeValue("00:00:05"), "EredmKiir" End Sub

Ebbõl az egész feladatból az eljárás utolsó sora az, amit ennél a feladatnál meg kell beszélnünk. Az OnTime egy esemény figyelését állítja be. Ha az OnTime kulcsszó mögé a TimeValue függvényben egy pontos idõt írunk, akkor a következõ paraméterként megadott eljárást a megjelölt idõben fogja végrehajtani az Excel. Ez azt jelenti, hogy a program figyeli az idõpont bekövetkezése eseményt, és amikor elérkezik a megfelelõ pillanat, akkor végrehajtja az EredmKiir eljárást. A mi esetünkben azonban nem tudjuk elõre, hogy mikor kezd gyakorlásba a programunk felhasználója. Itt azzal a módszerrel állítjuk be a jelenlegi pillanattól számított öt másodpercet, hogy a Now értékhez – ez az aktuális jelenlegi idõpont – hozzáadunk öt másodpercet. Most nézzük meg azt az eljárást, amelyik kiírja az eredményt:


Sub EredmKiir() Range("E2") = bytC End Sub

OnKey w Ezzel az utasítással egy-egy kiválasztott billentyû leütését figyeltethetjük a programban. Hasonlóan az OnTime idõpont figyelését beállító utasításhoz, itt is meghatározhatjuk, hogy melyik billentyû leütése, me-

179



Az Excel objektumai

3. rész

lyik eljárás futtatását váltsa ki. Ezzel a figyeléssel a billentyûzet tetszõleges gombjához eljárást rendelhetünk. Ezt az eseményfigyelést is egy kis példával ismerjük meg. Az elõzõ feladatot folytassuk azzal, hogy amikor a program kiírja az eredményt, akkor kérdezze meg a program használóját, hogy kér-e újabb gyakorló feladatot. Ha kér, akkor ismét hajtsuk végre azt az eljárást, amelyik a feladatot feladja, ha nem akkor búcsúzzunk el. A válaszadást rendeljük hozzá egy-egy billentyûhöz, például az i betû leütése igen választ jelentsen, az n betû pedig nem választ. Az eredmény kiírás eljárást bõvítsük ki a következõ utasításokkal. Sub EredmKiir() Range("E2") = bytC Range("A3") = "Kérsz újabb feladatot _ i = igen / n = nem" Application.OnKey "i", "Ujabb" Application.OnKey "n", "Vege" End Sub

Az utolsó két utasítás az, amelyikkel beállítjuk az i illetve az n betû leütésének a figyelését. A végrehajtandó eljárás nevét az utasítássor végén idézõjelek közé kell írnunk. Most nézzük meg azt az eljárást amit a megfelelõ betû leütése után hajtunk végre. Sub Ujabb() Application.OnKey "i" Application.OnKey "n" Gyakorlás End Sub Sub Vege() Application.OnKey "i" Application.OnKey "n" Range(“A3") = "Szia majd legközelebb ismét talákozunk!" End Sub

Az elsõ két utasítással megszüntetjük a két betû figyeltetését. Ha ezt nem tennénk, akkor ezentúl nem használhatnánk a két betût másra, csak arra, hogy a Vege és Ujabb eljárásokat elindítsuk. Az Ujabb eljárásban közvetlenül indítjuk az újabb feladat feladását végzõ eljárást, a Vege eljárásban pedig búcsút veszünk a felhasználótól.

180



15. fejezet


Futásidejû hibakezelés Az eljárásokban objektumokat használunk. Sok esetben nem tudhatjuk elõre azt, hogy a használni kívánt objektum a futtatáskor a felhasználó rendelkezésére fog-e állni. Ha nincs meg minden eszköz azok közül, amit a program használna, akkor a program hibát fog jelezni. A programunknak megoldásokat kell adnia a felhasználónak és nem feladatokat. Vagyis ne kérjük meg a felhasználót arra, hogy õ hozza létre a program futtatásához szükséges környezetet. Errõl nekünk kell gondoskodnunk. Fel kell mérnünk azt a lehetséges környezeti hiányosságot, ami a program jó mûködését megakadályozná. Ezeket nekünk kell korrigálni futás közben. A hiba ugyanúgy esemény, mint a többi esemény, legalábbis abban az értelemben mindenképpen, hogy elõre nem tudjuk meghatározni, hogy mikor következnek be. Az elõre felmérhetõ hibákat futás közben kell kezelnünk. Ennek érdekében fel kell készíteni az eljárásokat arra, hogy a hibák kezelését mi programozhassuk. Az utasítás amivel átvehetjük az Excel-tõl a hibák kezelését, az On Error Go To címke utasítás. Ha ezt elsõ utasításként írjuk, akkor a program futása közben bekövetkezõ összes hibát mi kezelhetjük le. A hiba figyelése minden esetben attól a sortól történik, ahova beírtuk az On Error utasítást. A hibát vagy az eljárás végéig figyelhetjük, vagy az On Error GoTo 0 utasítássorig. A hibakezelõ részben létrehozhatjuk azt az objektumot, ami a program futtatásához szükséges, vagy visszatérhetünk a program megfelelõ sorára. A további magyarázat helyett oldjunk meg egy egyszerû példát. Tegyük fel, hogy az egyik eljárásunkban egy munkalapra hivatkozunk. Nem tudhatjuk elõre azt, hogy abban a munkafüzetben, amelyikben ezt a mûveletet végre szeretnénk hajtani, valóban van ilyen nevû munkalap. Még az is lehet, hogy valamikor volt, csak közben a felhasználó törölte. Ha az eljárásunk nem létezõ lapra hivatkozik, akkor a program hibajelzéssel megáll, és nem hajtja végre az utána következõ utasításokat. Mi lehet a megoldás? Megkérdezhetjük például a felhasználót, hogy beszúrjunk-e egy új munkalapot, vagy esetleg kérdezés nélkül beszúrhatunk egy új munkalapot, aminek a neve megegyezik a keresett lap nevével és ismét megkísérelhetjük végrehajtani azt az utasítást, ahol a hiba megtörtént. Egy új munkafüzetben hozzunk létre egy modult és írjuk meg a következõ kis eljárást. Sub LapNincs() Worksheets(“Nincs”).Range(“A1") = ”Bármi adat" End Sub

181


Ugrás a hibakezelõre Az On Error Goto paranccsal elugorhatunk az eljáráson belül arra a címkére, amelyben a hibát szeretnénk feldolgozni.


Az Excel objektumai

3. rész

Ebben az eljárásban egy Nincs nevû munkalapra szeretnénk írni. Lehet, hogy korábban volt ilyen lap, de most nincs. Így az eljárás nem hajtóA hiba száma A bekövetkezett hiba számát a hibaüzenetbõl tudhatjuk meg.

51. ábra: Az elem nincs a tartományban

Címke használata Amennyire lehet kerüljük a címkék használatát! A címkét kettõsponttal kell lezárni.

Visszatérés a hiba helyére Ha a hibát lekezeltük visszatérhatünk oda, ahol a hiba bekövetkezett.

dik végre, hanem hibaüzenettel leáll. A hibaüzenetet vegyük tudomásul. Jegyezzük meg a hiba kódját, erre késõbb még szükségünk lesz. Ezután kattintsunk a Vége [End] feliratú gombra (182. oldal 51.ábra). Hozzuk létre azt a szerkezetet, ami kezelni tudja ezt a hibát. Az eljárás elsõ sorába írjuk be az On Error utasítást. Az eljárás vége elé pedig írjuk be a címkét amire a hiba bekövetkezése után a programnak lépnie kell. A címke mögötti részre megírhatjuk a hiba kezelését végzõ utasítássort. Most csak annyit teszünk, hogy figyelmeztetjük a felhasználót arra, hogy nincs olyan munkalap, amire dolgozni szeretne. A programot bõvítsük ki a következõ sorral: Sub LapNincs() On Error GoTo HibaLapNincs Worksheets("Nincs").Range("A1") = "Bármi adat" HibaLapNincs: MsgBox "A munkafüzetben nincs ilyen munkalap" End Sub

A Visual Basic a címkét nem tekinti utasításnak, egyszerûen átlép rajta és végrehajtja a következõ utasítást. Vegyük észre, hogy ha ez így van, akkor a hibakezelõ részt a programunk akkor is végre fogja hajtani, ha nem következett be hiba. Ezért a címke elé minden esetben be kell írnunk az Exit Sub parancsot, ami kilép az eljárásból. Nézzük meg, hogy mi a teendõ, ha nemcsak jelezni szeretnénk a hiányosságot, hanem orvosolni is. A hiba bekövetkezésekor hozzunk létre egy új munkalapot, aminek a neve az lesz amit használni szerettünk volna. Ehhez a hibakezelõ részbe az üzenet helyére a következõ sort írjuk be:

182



15. fejezet


Worksheets.Add.Name = “Nincs”

Ez az utasítás beszúrja az új munkalapot, de nem írja rá azt a szöveget, mivel befejezük az eljárást. Térjünk vissza arra a sorra, ahol a hiba bekövetkezett. Ezt a Resume 0 utasítással tehetjük meg. Tehát most már van megfelelõ munkalapunk, ráírtuk a szöveget. Mivel a hibát kezelõ utasítások a fenti utasítások után következnek, a program szolgaian ezeket is végre fogja hajtani. Ezt úgy kerülhetjük el, hogy a hibakezelõ címke elõtt kilépünk az eljárásból. Ha a hibakezelést így hagyjuk, akkor minden bekövetkezett hiba esetén beszúrunk egy új munkalapot az aktuális munkafüzetbe és visszatérünk arra az utasításra, amelyik a hibát okozta. Ez azért nem jó, mert a hiba ismét bekövetkezik. Eredményként megint a hibakezelõ utasításokra lépünk. Belátható, hogy ez így az idõk végezetéig körbejár, anélkül, hogy bármi is történne a gépünkön. Most oldjuk meg azt is, hogy ne minden hiba bekövetkezése esetén hajtódjanak végre a hibakezelõ utasítások, csak akkor, ha a mi hibánk következik be. Ezt a hibakezelõ részbe írt egyetlen If utasítással oldhatjuk meg.

Azért, hogy ne hajtsuk végre a hibakezelõ részt minden esetben, ki kell lépni az eljárásból. Ha csak lehet ezt a módszert is kerüljük el!

Sub LapNincs() On Error GoTo HibaLapNincs Worksheets(“Nincs”).Range(“A1") = ”Bármi adat" Exit Sub HibaLapNincs: If Err.Number = 9 Then Worksheets.Add.Name = “Nincs” Resume 0 Else Error Err End If End Sub

Elemezzük ki a félkövér betûs utasításokat. Az If Err.Number = 9 Then vizsgálat azt a hibát engedi kezelni, amelyikre mi figyeltünk. Ezt a hibakódot az elsõ futtatáskor jegyezhettük fel. Ha több hibára is számítunk,

akkor azoknak a kódját is vizsgálnunk kell. Az If szerkezet Else ágában szereplõ Error Err utasítássor továbbra is ugyanolyan hibaüzenetet fog adni, mint amikor nem mi kezeltük le a futás közben elõforduló hibákat. Természetesen ez a program leállásával is fog járni.

183


Kilépés az eljárásból




Kapcsolat a felhasználóval

4. rész



A 4. rész tartalmából Itt már a bentfentesek biztonságával használjuk a programozás eszközeit, elindítjuk az általunk írt programokat. Tudunk már olyan eljárásokat, függvényeket készíteni, amit többen is szeretnének használni. Ha csak lehet, úgy kell átadnunk másoknak a programjainkat hogy ugyanúgy használhassák azokat, mintha az Excel részei lennének. Ebben a részben azokat az eszközöket ismerhetjük meg, amelyek lehetõvé teszik az általunk írt programok terjesztését.



16. fejezet

Üzenetek, párbeszéd

gyik-másik eljárásban szükség lehet arra, hogy az eljárás végrehajtása közben további adatokat kérdezzünk a gép elõtt ülõ felhasználótól. Erre a két legegyszerûbb eszköz, az InputBox és az MsgBox utasítások. A párbeszéd másik eszköze az Office segéd – Assistant – lehet. Ez a Microsoft Office eszköze, így minden Office alkalmazásban elérhetjük. Használhatunk ûrlapokat is arra, hogy a felhasználó elvégezze az eljárás közben szükséges beállításokat. Ebben a fejezetben néhány egyszerû példa segítségével megismerkedünk a kapcsolatot megvalósító eszközökkel. A fejezet a következõ kérdésekre ad választ: w w w w

Hogy használjuk az MsgBox függvényt? Milyen változatai vannak az InputBox függvénynek? Hogyan használhatjuk az Office segédet? Hogy hozhatunk létre egyéni ûrlapokat?

Egyszerû üzenetek Visual Basic környezetben két egyszerû eszköz áll a rendelkezésünkre ahhoz, hogy üzenetet küldjünk a felhasználónak. Ezekkel nem csak üzenhetünk, hanem adatot is kérhetünk a felhasználótól. Ezzel a felhasználó közvetlenül vezérelheti a program futását. Ezek az MsgBox és az InputBox. A „Vezérlés eseményekkel” címû fejezet végén a „Futásidejû hibakezelés” szakaszban megpróbáltunk egy olyan munkalapra adatot írni, amelyik nem is volt a munkafüzetben. Akkor a feladatot úgy oldottuk meg, hogy senkitõl nem kérdeztünk semmit, hanem beszúrtunk egy új munkalapot. Lehet, hogy a felhasználó nem így tett volna, ha megkérdezzük a véleményét. Ezt megtehettük volna egy MsgBox utasítás segítségével. Mielõtt megoldanánk a feladatot, vizsgáljuk meg az MsgBox utasítást. Töltsük be az Excel-t és kapcsoljunk át a Visual Basic Editor felületre.

187




4. rész

Kapcsoljuk be az Immedaite ablakot, és adjunk ki egy MsgBox parancsot. Kezdjük el begépelni a következõ sort:

52. ábra: Az MsgBox panel megjelenítésének a beállíása Amikor elérünk az MsgBox második argumentumához, lenyílik egy lista. Itt a program belsõ állandókat kínál fel. Ebbõl választva meghatározhatjuk, hogyan jelenjen meg az üzenet. Ha például a vbCritical értéket választjuk, akkor a panelen piros köröcske jelenik meg, a vbInformation hatására pedig az információ jelölést fogjuk látni. Ha ezek között a belsõ állandók közül többet is kipróbálunk, találunk olyat is, amelynek a hatására Igen-Nem gombok jelennek meg az MsgBox-ban. Ez a vbYesNo lehetõség. Ha ezek a gombok csak a megjelenítést szolgálják, akkor nem sokra megyünk velük. Jó lenne a programban annak megfelelõen elágazni, hogy a felhasználó melyik gombra kattintott. Ha például az Igen-t választotta, szúrjuk be az új munkalapot, ha a Nem gombot választotta állítsuk le az eljárást. Az MsgBox-ot kétféleképpen használhatjuk. Eddig csak a felhasználó tájékoztatására használtuk, de nem volt fontos a számunkra a felhasználó választása. Ahhoz, hogy ki tudjuk értékelni a felhasználó válaszát, az MsgBox függvény változatát kell használnunk. Ez pontosan ugyanazt tudja, mint az eljárás változat, csakhogy most visszakapjuk a felhasználó válaszának megfelelõ értéket. Lényeges különbség az, hogy most az argumentumokat zárójelek között kell felsorolnunk. Az Immedaite ablakban próbáljuk ki a következõ utasítássort: MsgBox függvény Az MsgBox függvény változatával nem csak üzenhetünk, de választ is kaphatunk a kérdésinkre.

?msgbox(“Üzenet szövege”,vbyesno)

Miután ENTER-t ütöttünk megjelenik a MsgBox. Kattintsunk egyszer az Igen gombra. Indítsuk el ismét és próbáljuk ki mi a válasz, ha a nem gombot ütjük le. Igen gomb esetén 6, Nem esetén 7 a válasz. Ezt az értéket tárolhatjuk egy változóban és egy If vezérléssel kiértékelve elágazhatunk.

188



16. fejezet


Térjünk vissza eredeti célunkhoz. A „Vezérlés eseményekkel” címû fejezet végén a „Futásidejû hibakezelés” szakaszban megpróbáltunk egy olyan munkalapra adatot írni, amelyik nem is volt a munkafüzetben. Nem kérdeztük a felhasználót, hogy õ akarja vagy sem, beszúrtuk az új munkalapot. Az eljárás az említett fejezetben így nézett ki: Sub LapNincs() On Error GoTo HibaLapNincs Worksheets("Borító").Range("A1") = "Bármi adat" Exit Sub HibaLapNincs: If Err.Number = 9 Then Worksheets.Add.Name = "Borító" Resume 0 Else Error Err End If End Sub

Használjuk fel a most szerzett ismeretünket és kérdezzük meg a felhasználót az új munkalap beszúrásáról. Ha kéri, hajtsuk végre a beszúrást és a program többi részét, ha nem lépjünk ki az eljárásból. Bõvítsük ki ezt a következõ módon: Sub LapNincs() Dim bytValasz As Byte On Error GoTo HibaLapNincs Worksheets("Borító").Range("A1") = "Bármi adat" Exit Sub HibaLapNincs: If Err.Number = 9 Then bytValasz = MsgBox _ ("Beillesszem a Borító nevû munkalapot?", vbYesNo) If bytValasz = vbYes Then Worksheets.Add.Name = "Borító" Resume 0 Else Exit Sub End If Else Error Err End If End Sub

Az MsgBox válasza Ha a függvény válaszát egy változóban tároljuk, akkor azt késõbb felhasználhatjuk.

189




4. rész

A Dim paranccsal meghatároztunk egy változót. Ebben fogjuk tárolni a felhasználó válaszát. A kérdést az elsõ félkövér sorban tesszük fel. Az MsgBox megjelenik, és rajta lesz az Igen és a Nem gomb. Ezt követõen az elágazunk a válasznak megfelelõen. Belsõ állandók Az MsgBox válaszához tartzó belsõ állandókat

If bytValasz = vbYes Then

Itt érdemes felfigyelni arra, hogy a vbYes belsõ állandót használtuk az összehasonlításkor. Használhattunk volna akár vbNo állandót is, csak akkor másként kellett volna megírni a programot. A bytValasz értéke akkor veszi fel a vbYes értéket, ha a felhasználó az Igen gombra kattint. Ellenkezõ esetben a válasz értéke megegyezett volna a vbNo állandó tartalmával. Ha tehát a felhasználó az Igen gombra kattint, akkor beszúrjuk az új munkalapot és visszatérünk a hibát okozó sorra. Vagyis sikeresen elvégeztük a beírást. Ellenkezõ esetben – ha a felhasználó nem kéri az új lapot – kilépünk az eljárásból, hiszen nincs hova beírnunk az adatot. Egy kis figyelmesség a felhasználónak az, ha még egy kérdõjelet is megjelenítünk az MsgBox panelen. Megtehetjük, mert ezeket a belsõ állandókat úgy találták ki, hogy összeadva egyik másik értékét egyszerre két megjelenítést is beállíthatunk. Írjuk át az MsgBox sort a következõre: bytValasz = MsgBox _ (“Beillesszem a Borító nevû munkalapot?”, vbYesNo+vbQuestion)

Assistant Ez a kis mókás figura az Office objektuma. Ennek a segítségével is kommunikáálk hatunk a felhasználóval.

Új ballon Az üzenet elõkésíztéséhez létre kell hoznunk azt a ballont, amiben majd az üzenet lesz.

Office segéd Nyissunk meg egy üres munkafüzetet és kapcsoljunk át a programszerkesztõbe. A jelenlegi munkafüzetbe szúrjunk be egy új modult. Az új modulba írjunk egy eljárást, amelyik figyelmezetõ üzenetet küld. Az üzenet megjelenítésére használjuk a segéd objektumot. Írjunk egy egyszerû példát, amelyikben a segéd megkérdezi, hogy láthatóak legyenek-e a munkalap cellarácsai. Ha a felhasználó az igen gombra kattint, akkor jelenítsük meg, ha a nem gombra, akkor rejtsük el a cellarácsokat. Sub Racsok() Dim blnCellaRacs As Balloon Dim intValasz As Integer Const STR_CIME As String = "Cellarácsok" Const STR_KERDES As String = _ "Láthatóak legyenek a cellarácsok?" Set blnCellaRacs = Assistant.NewBalloon ‘Az üzenetballon elokészítése

190



16. fejezet


With blnCellaRacs .Mode = msoModeModal .Heading = STR_CIME .Text = STR_KERDES .Button = msoButtonSetYesNo .Animation = msoAnimationGestureUp ‘A válasz eredmény megorzése intValasz = .Show End With ‘A válasz kiértékelése If intValasz = -3 Then ActiveWindow.DisplayGridlines = True ElseIf intValasz = -4 Then ActiveWindow.DisplayGridlines = False End If ‘A piheno animáció beállíása Assistant.Animation = msoAnimationIdle End Sub

53. ábra: Cellarácsok ki és bekapcslása az Office segéddel Az eljárás elindítása után a segéd a következõképpen fog megjelenni: Elemezzük ki az elkészített eljárást. Az eljárás elsõ soraiban deklaráljuk azokat a változókat és állandókat, amelyeket használni fogunk. A blnCellaRacs változó segítségével leegyszerûsítjük az üzenet hivatkozását. A intValasz változót a kérdésre adott válasz átmeneti megõrzésére használjuk fel. A STR_CIME állandó a ballon címe, míg a STR_KERDES a feltett kérdés szövege lesz. Set blnCellaRacs = Assistant.NewBalloon

Az Assistant.NewBallon által létrehozott objektumot – ez egy ballon lesz – elnevezzük a deklarált blnCellaRacs névvel. Ettõl kezdve ezzel a

191




4. rész

névvel hivatkozhatunk erre az objektumra. A következõ sorokban elõkészítjük az üzenetet és a ballon megjelenítését. .Mode = msoModeModal

Ezzel az utasítássorral azt állítjuk be, hogy amíg az üzenetre nem kaptunk választ, addig ne lehessen más mûveletet végrehajtani, vagyis, hogy a felhasználó ne tudjon a segéd – Assistant – kérdése közben az Excel-hez hozzáférni. Az msoModeModal Microsoft Office állandót a program felkínálja, miközben a programot írjuk. .Heading = STR_CIME

Ennek a tulajdonságnak a beállítása az üzenet ballon címét adja. Erre az eljárás elején deklarált állandót használjuk fel ugyanúgy, mint az üzenet-ballon szövegét megjelenítõ Text tulajdonság beállítása során. .Button = msoButtonSetYesNo

A fenti utasítássornak a feladata az, hogy az üzenet megjelenítése során az igen és a nem gombok megjelenjenek az üzenet alján. Ebben a sorban ismét egy Office állandót használtunk. Ezeket ismét a VBE kínálatából választhatjuk ki. .Animation = msoAnimationGestureUp

A segéd különféle animációkra képes. Ezeket mi határozhatjuk meg azzal, hogy az Animation tulajdonságnak megfelelõ értéket adunk. Ezek is a VBE által felkínált állandók alapján választhatók ki. Az állandók nevébõl kiderül, hogy mit fog mûvelni a kis segéd. intValasz = .Show

Ennek az utasítássornak kettõs szerepe van. Az egyik az, hogy megjelenítse a segédet és az elõkészített üzenetet. A másik feladata pedig az, hogy a intValasz változóban megõrizzük a választ. Ha válaszként az Igen gombra kattintunk, akkor a intValasz értéke -3 lesz, ha pedig a Nem gombra, akkor -4. A változóban tárolt értékektõl függõen vagy megjelenítjük a cellarácsokat, vagy elrejtjük. If intValasz = -3 Then ActiveWindow.DisplayGridlines = True ElseIf intValasz = -4 Then ActiveWindow.DisplayGridlines = False

192



16. fejezet


End If

Ha a felhasználó az Igen gombra kattint, vagyis a válasz értéke -3, akkor bekapcsoljuk a cellarácsokat, ha pedig a nem gombra, vagyis a válasz -4, akkor kikapcsoljuk. Assistant.Animation = msoAnimationIdle

Bizonyos animációk az utasítás kiadása után is folyamatosan ismétlõdnek, ezért tanácsos visszaállítani (Idle) vagyis üresjárat állapotba tenni az animációkat. Jelölõnégyzetek használata w A következõ példában tegyük lehetõvé, hogy a segéd felhasználásával az Excel beállításai közül egyszerre több jellemzõt is megváltoztasson a felhasználó. Ehhez jelölõnégyzeteket fogunk megjeleníteni a segéd ballonjában. Ehhez a CheckBoxes tulajdonságokat kell beállítanunk. Ennek indexeltnek kell lennie, de ötnél több jelölõnégyzetet nem használhatunk egy üzenet során. Az eljárás elején vizsgáljuk meg az átállítani kívánt tulajdonságok értékét, és ezeknek megfelelõen állítsuk be az üzenet jelölõnégyzeteit. Sub Beállítások() Dim blnBeallitas As Balloon Dim intValasz As Integer Dim strSzovegek(4) As String Dim intI As Integer Const STR_CIME As String = "Egyedi beállítások" Const STR_KERDES As String = _ "Jelöljük be a szükséges beállításokat!" Set blnBeallitas = Assistant.NewBalloon strSzovegek(1) = "Cellarácsok" strSzovegek(2) = "Állapotsor" strSzovegek(3) = "Szerkesztoléc" strSzovegek(4) = "Munkalap fülek" With blnBeallitas .Heading = STR_CIME .Text = STR_KERDES .Button = msoButtonSetOkCancel For intI = 1 To 4 .CheckBoxes(intI).Text = strSzovegek(intI) Next intI .CheckBoxes(1).Checked = ActiveWindow.DisplayGridlines .CheckBoxes(2).Checked = Application.DisplayStatusBar .CheckBoxes(3).Checked = Application.DisplayFormulaBar

193


Jelölõnégyzet Ha a ballon CheckBox objktum Text tulajdonságánek értéket adunk, akkor a választógomb megjelenik az üzenetben.



4. rész

.CheckBoxes(4).Checked = ActiveWindow.DisplayWorkbookTabs intValasz = .Show If intValasz = -1 Then ActiveWindow.DisplayGridlines = .CheckBoxes(1).Checked Application.DisplayStatusBar = .CheckBoxes(2).Checked Application.DisplayFormulaBar = .CheckBoxes(3).Checked ActiveWindow.DisplayWorkbookTabs = .CheckBoxes(4).Checked End If End With End Sub

Az eljárás beírása után álljunk az eljárás Sub utasítására és üssük le az F5-ös funkcióbillentyût. Ez ugyanis elindítja azt az eljárást, amit készítettünk. A segéd megjeleníti a jelölõnégyzeteket, és azokat a gombokat, amelyeket meghatároztunk. A jelölõnégyzetek közül bármelyiknek az értékét megváltoztathatjuk. Ha az OK gombra kattintunk, akkor az eljárás végrehajtja a megfelelõ beállításokat. Az eredmény a következõ lesz:

54. ábra: Az Office segéd ballonban megjelenített CheckBox-ok Elemezzük ki ennek az eljárásnak az utasításait is. Természetesen az eljárás a változók és állandók deklarálásával kezdõdik. Ezután a változók kezdeti értékét állítjuk be, melyeket most ne elemezzünk. Kezdjük a With blnBeallitas utasítássortól. Elsõként tisztázzuk, hogy mi az a blnBeallitas. Egy korábbi sorban deklaráltuk a blnBeallitas objektumváltozót. Ennek a változónak abban a sorban adtunk értéket, amelyik a Set kulcsszóval kezdõdik. Itt blnBeallitas névvel láttuk el a segéd ballonját. Ettõl kezdve a létrehozott új ballonra ezzel a névvel hivatkozhatunk. A With kulcsszót már korábban megismertük. Ennek az a feladata, hogy a mögé írt objektum tulajdonságait beállíthassuk. Ezért fogunk ponttal kezdõdõ utasítássorokat találni. A pont mögött tulajdonságok vannak. Ezek elé különben minden esetben oda kellett volna írni a blnBeallitas objektumnevet. Tehát ha most ponttal

194



16. fejezet


kezdõdik egy sor akkor gondoljuk elé a blnBeallitas-al azonosított Balloon objektumot. Ez mindaddig így tart, amíg el nem érünk az End With utasítást tartalmazó sorig. .Heading = STR_CIME .Text = STR_KERDES .Button = msoButtonSetOkCancel

Ezek a sorok az üzenet címét, szöveges magyarázatát és a panel alján megjelenõ gombokat határozzák meg. Az elsõ két utasításban felhasznált állandókat az eljárás korábbi részében deklaráltuk, kivéve a Button tulajdonság beállításához használt mso kezdetût. Ez az Office állandója, amit a VBE felkínál a program írása során. Ettõl jelennek meg az üzenet alján az OK és Mégse gombok.

For intI = 1 To 4 .CheckBoxes(intI).Text = strSzövegek(intI) Next intI

Ebben a ciklusban a jelölõnégyzetek szövegét adjuk meg. Ez a ChecBoxes objektum Text tulajdonság beállításával történik. Ennek eredményeként jelennek meg a jelölõnégyzetek. Tehát a jelölõnégyzetek attól látszanak, hogy a Text tulajdonságának értéket adunk. A CheckBoxes objektum indexe azt határozza meg, hogy hányadik legyen a sorrendben a megjelenítendõ jelölõnégyzet. Tehát a fenti ciklus négy jelölõnégyzetet fog megjeleníteni, azokkal a feliratokkal, amelyeket korábban letároltunk a strSzövegek tömbben. .CheckBoxes(1).Checked = ActiveWindow.DisplayGridlines .CheckBoxes(2).Checked = Application.DisplayStatusBar .CheckBoxes(3).Checked = Application.DisplayFormulaBar .CheckBoxes(4).Checked = ActiveWindow.DisplayWorkbookTabs

Ebben a négy sorban a jelölõnégyzetek kijelzését beállítjuk a módosítani kívánt tulajdonságok jelenlegi értékeknek megfelelõen. Erre azért van szükség, hogy a felhasználó felmérhesse a pillanatnyi állapotot. Ezt nem oldhattuk meg ciklussal, így egyenként kellett elvégezni a beállításokat. Ha a jelölõnégyzetek Checked tulajdonságát True értékre állítjuk be, akkor megjelenésükkor bekapcsoltak lesznek. Ezeket az értékeket most a megfelelõ tulajdonságok felhasználásával állítjuk be, így a jelölõnégyzetek tükrözik a környezeti beállításokat. intValasz = .Show

195




4. rész

Ennek az utasítássornak ismét kettõs szerepe van. Az egyik az üzenet megjelenítése, a másik, hogy megõrizzük azt az értéket, hogy melyik gombra kattintottunk. Ha az OK gomb volt az, akkor a intValasz változó értéke -1 lesz, ha a Mégse gomb volt az, akkor az eredménye -2 lesz. A további mûveleteket ennek a változónak az értékétõl függõen hajtjuk végre. Ha ugyanis az OK gombot választotta a felhasználó, akkor végrehajtjuk a jelölõnégyzetben beállított változtatásokat, ha a Mégse gombra, akkor megtartjuk az eredetieket. If intValasz = -1 Then ActiveWindow.DisplayGridlines = .CheckBoxes(1).Checked Application.DisplayStatusBar = .CheckBoxes(2).Checked Application.DisplayFormulaBar = .CheckBoxes(3).Checked ActiveWindow.DisplayWorkbookTabs = .CheckBoxes(4).Checked End If

Ha tehát a intValasz értéke -1, akkor változtatunk. Ezért vizsgáljuk az If utasításban azt, hogy a intValasz értéke -1. Ha igen, akkor végrehajtjuk a jelölõnégyzetekben meghatározott beállításokat. Ha az üzenetben a Mégse gombra kattint a felhasználó, akkor a beállításokat végzõ utasítássorokat nem hajtja végre a program. Az ezt követõ End With sor lezárja a blnBeallitas objektum tulajdonságainak beállítását és vizsgálatát.

55. ábra:

Választócsoport Az Office segédre elhelyezhetünk olyan gombokat is, amelyekbõl csak egyet lehet egyszerre kijelölni.

Választócsoport használata w A választócsoportból egyet használhatunk az Office segéd üzenetében. Tegyük fel, hogy egy cellába az engedmény mértékét szeretnénk beírni. A segéd ballonjában választócsoport használatával maximum öt választógombot használhatunk. Ezek a mi példánkban legyenek a 2%, 5%, 8% , 10% és 12% értékek. Ha a ballonban megjelenõ Mégse (Cancel) gombra kattintunk, akkor nem adunk engedményt. Vagyis 0% jelenjen meg az A1-es cellában. Most nem dolgozzuk ki a számlázó környezetet, elégedjünk meg annyival, hogy a választás eredményét jele-

196



16. fejezet


nítsük meg az A1-es cellában. Ennek a beállítására az Office segédet fogjuk használni. Tehát ezt szeretnénk megvalósítani: Sub Engedmeny() Dim blnEngedmeny As Balloon Dim intEredm As Integer Dim strSzazalek(5) As String Dim intI As Integer Const STR_CIME As String = “Engedmény” Const STR_KERDES As String = “Hány százalék?” strSzazalek(0) = “0%” strSzazalek(1) = “2%” strSzazalek(2) = “5%” strSzazalek(3) = “8%” strSzazalek(4) = “10%” strSzazalek(5) = “12%” Set blnEngedmeny = Assistant.NewBalloon With blnEngedmeny .Heading = STR_CIME .Text = STR_KERDES .Button = msoButtonSetCancel For intI = 1 To 5 .Labels(intI).Text = strSzazalek(intI) Next intI intEredm = .Show If intEredm = -2 Then intEredm = 0 End If End With Range(“A1") = strSzazalek(intEredm) End Sub

Az eljárás elején deklaráljuk a változókat és az eljárásban használandó állandókat. Ezek használatáról majd a programsorok értelmezése során ejtünk szót. Set blnEngedmeny = Assistant.NewBalloon

Ebben az utasítássorban elnevezzük az Assistant.NewBalloon által létrehozott objektumot blnEngedmeny névvel. Ennek a feladata a hivatkozás leegyszerûsítése, amivel már a korábbi feladatok megoldásánál is találkoztunk. Az üzenet elõkészítés elsõ sora a With blnEngedmeny sor. Mint már korábban is láttuk, a With utasítást akkor használjuk, ha ugyanannak az ob-

197




4. rész

jektumnak több tulajdonságát is szeretnénk megváltoztatni. Jelen esetben a segéd ballonjának a tulajdonságait állítjuk be, amíg a program rá nem lép az End With utasítássorra. .Heading = STR_CIME .Text = STR_KERDES .Button = msoButtonSetCancel

Ebben a három sorban meghatározzuk az üzenet ballon címét, üzenetének a szövegét és azt, hogy milyen gomb jelenjen meg az üzenet alján. A Heading tulajdonság az üzenet címkéje. Ennek az értékét az eljárás elején deklaráltuk. A Text a ballonban megjelenõ kérdés szövege, amit szintén már korábban meghatároztunk és végül a gomb beállítására az Office állandók egyikét használtuk fel. For I = int1 To 5 .Labels(intI).Text = strSzazalek(intI) Next intI

Ebben a három sorban meghatározzuk a választócsoport elemeinek a szövegét. Ennél többet nem is kell tennünk annak érdekében, hogy a választógombok megjelenjenek a segéd – Assistant – üzenetében. A strSzazalek tömb értékeit az eljárás deklarációs szakaszában már meghatároztuk. Ez egy hat elemû vektor. A nulladik elemét, majd arra fogjuk felhasználni, hogy a mégse gomb lenyomása esetén 0%-ot írjunk az A1-es cellába. Az intI ciklusszámláló egytõl ötig végiglépked a Labels objektumokon és a strSzazalek tömb elemeinek értékével feltölti azokat. intEredm = .Show

Ez az utasítássor megjeleníti a segéd üzenetét és a választásunknak megfelelõen egy számot ír a intEredm változóba. Ez vagy a kiválasztott választógomb sorszáma lesz, vagy a Mégse gomb esetén -2. If intEredm = -2 Then intEredm = 0 End If

Ha a Mégse gombra kattintott a felhasználó, akkor ennek megfelelõen kell eljárnunk, vagyis az eredmény értékét át kell írnunk nullára. Ez azt jelenti, hogy a vevõ nem kap árengedményt. Egyébként a intEredm változóban annak a gombnak a sorszáma lesz, amelyikre rákattintottunk. Range(“A1") = strSzazalek (intEredm)

198



16. fejezet


A választás után beírjuk az eredményt az A1-es cellába. Erre a korábban deklarált strSzazalek vektort használjuk fel.

Párbeszédpanelek használata Összetettebb feladatokat egyedi párbeeszédpanelek, ûrlapok létrehozásával oldhatunk meg. Itt mi határozzuk meg a panelek részegységeit. Ezzel teljesen egy adott feladathoz igazíthatjuk a ûrlapokat. A paneleken vezérléseket alkalmazhatunk. Ezek szintén korábban elkészített objektumok.

Párbeszédpanel létrehozása Lapozzunk át a VBE programba. A projekt ablakban az egér jobb gombjával kattintsunk rá annak a projektnek az egyik elemére, amelyikben az ûrlapot szeretnénk elkészíteni. A helyi menübõl válasszuk ki a Insert UserForm utasítást. Az utasítás végrehajtásának az lesz az eredménye, hogy megjelenik egy ûrlap.

56. ábra: Felhasználói ûrlap létrehozása az Excelben

Vagy magyarul párbeszébpanel, ûrlap.

Vezérlések

Az ûrlapokon használható vezérléseket egyszerûen úgy helyezhetjük el az ûrlapon, mint egy rajzoló programban. Ezzel kialakíthatjuk azt az ûrlap képet, amire egy-egy feladat megoldásához szükségünk lesz. Az ûrlapok és a vezérlések abban hasonlítanak a munkafüzetre, illetve a munkalapokra, hogy ezekhez is tartoznak elõre elkészített modulok.

199


User form

A vezérlések az ûrlapon elhelyezett látható objektumok.


Kapcsolat a felhasználóval CommandButton Parancsgomb vezérlés. Leggyakrabban a kattintásra eseményét használjuk.

4. rész

Ezekben a modulokban is elõre elkészített eljárások vannak, amelyek különbözõ események hatására hajtódnak végre. Az ûrlap modulját úgy jeleníthetjük meg, hogy kettõt kattintunk az ûrlap területére. Késõbb ugyanezzel a módszerrel jeleníthetjük meg a vezérlésekhez tartozó osztály modulokat is. Az ûrlap programozása eseményekkel történik. Ez a modul is osztálymodul, mint a munkafüzeté vagy a munkalapé. Ez azt is jelenti, hogy itt sem érdemes globális változót deklarálni, mert a modul bezárja azt. Rajzoljunk egy CommandButton vezérlést az ûrlapra.

57. ábra: Rajzoljunk vezérlõ objektumot az ûrlapra! 1. Kattintsunk rá arra a vezérlésre, amit az ûrlapra szeretnénk tenni 2. Rajzoljuk az ûrlap megfelelõ helyére. 3. Állítsuk be a vezérlés tulajdonságait Tulajdonságok beálíítasa A vezérlések tulajdonságainak eg része nem változik a program futása alatt. Ezeket állíthatjuk be a Properties, tulajdonság ablakban.

A harmadik lépést egy kicsit részletezzük! Amint az ûrlapra rajzoltuk a megfelelõ vezérlést állítsuk be azokat a tulajdonságait, amelyek a program futása alatt nem fognak megváltozni. Ehhez azt kell tennünk, hogy jelöljük ki, és a tulajdonság ablakban a megfelelõ tulajdonságokhoz írjuk be a megfelelõ értékeket. A legfontosabb, hogy amint felrajzoltuk nevezzük el. Persze a többi tulajdonság beállítását is célszerû ilyenkor elvégezni. Ha figyelmesen szemléljük az 58. ábrát, észre vehetjük, hogy a gomb nevét cmd elõtaggal kezdtük. Hasonlóan a változókhoz itt is érdemes olyan nevet adni, ami utal az objektum típusára. Ezzel a késõbbi munkánkat tesszük könnyebbé. Hasonlóan nevezzük el az ûrlapot is. Ennek az elõtagja lehet frm az angol Form szóra utalva. A mostani form neve például legyen frmProba. Miután mindezzel végeztünk, nézzük meg az ûrlaphoz tartozó modult, és ismerkedjünk meg az ûrlap eseményeivel. Ugyanebben a modulban fogjuk találni az ûrlapra helyezett vezérlések eseményeit is. Álljunk az ûrlapra és üssük le az F5-ös funkció billentyût. Az ûrlap mûködésbe lép, de a rajta elhelyezett gomb, még nem tudja mit kell csinálnia. Ah-

200



16. fejezet


58. ábra: A Bezárás gomb beállíásai hoz, hogy attól bezáródjon az ûrlap, hogy a bezárás gombra kattintottunk be kell írnunk egy egysoros parancsot a kattintásra eseményébe.

Események A vezérlések eseményeit az õket befogadó ûrlap moduljában találjuk

59. ábra: A vezérlõ objektumok eseményei Private Sub cmdClose_Click() Unload Me End Sub

Bár rövid kis utasításról van szó, mégis elemezzük ki. Az Unload kitessékeli azt az objektumot az operaív memóriából, amelynek a nevét mögé írtuk. Ez jelen esetben egy Me. De mi lehet ez? Ha egy ûrlap moduljába a Me objektumra hivatkozunk, akkor az arra az ûrlapra mutat, amelyikben éppen a programot írjuk. Tehát a parancs azt az ûrlapot zárja be, amelyikben ezt a parancsot kiadtuk. Ha az ûrlapon elhelyezett vezérlések egyikére szeretnénk hivatkozni, akkor kezdhetjük a hivatkozást a Me szócskával. Ha ezután egy pontot teszünk a felkínált listában megtaláljuk az ûrlapon elhelyezett összes vezérlõ objektumot.

201


Me hivatkozás Ezzel a névvel hivatkozhatunk arra az ûrlapra, amelyiknek a moduljában programozunk.



4. rész

A következõ megoldandó feladat az, hogy ne csak a Visual Basic Editorból lehessen elindítani az ûrlapot. Ha visszakapcsolunk az Excelbe megpróbálhatjuk a Makró párbeszédpanelbõl elindítani, de ott egy kis csalódás fog érni minket. Nincs az ûrlap az indítható elemek listájában. Az indításhoz nekünk kell megírnunk egy eljárást, amivel akár egy billentyû-kombinációval is mozgásba hozhatjuk az ûrlapot. Szúrjunk be tehát egy általános modult a projektünkbe, és írjuk meg az ûrlap indító eljárást. Nem lesz bonyolult, de ezt meg kell írnunk. Íme:

A párbeszédpanel indítása Ahhoz, hogy az elkészült panelt elindíthassuk egy külön eljárásra van szükség.

Sub frmProbaStart() frmProba.Show End Sub

Most már minden rendben! Elindíthatjuk az ûrlapot, és ha szükséges akár billentyût is rendelhetünk hozzá. Most már belefoghatunk az ûrlapok készítésébe. Térjünk át egy gyakorlati feladat megoldásához. Gyors beállítások w A fejezet elején, az Office segéddel, megoldottunk egy feladatot. Néhány gyors beállítást hajtottunk végre a felhasználó igényeinek megfelelõen. Oldjuk meg most ugyanezt ûrlap alkalmazásával. Hozzunk létre egy egyszerû párbeszédpanelt. Amiben ugyanazokat a beállításokat lehet elvégezni. Az ûrlapra helyezzünk el négy CheckBox vezérlést. Ezekkel fogjuk elvégezni a beállításokat. Rajzoljunk a panelre egy parancsgombot is. Ennek egyetlen feladata lesz, éspedig az, hogy miután elvégeztük a beállításokat, bezárjuk vele az ûrlapot. Rajzoljuk meg tehát a következõ párbeszédpanelt:

60. ábra: A gyors beállítás panel kivitelezés közben Rajzoljuk fel a négy jelölõnégyzetet az ûrlapra. Ha a jelölõnégyzet gombra kettõt kattintunk, akkor egyszerre több ilyen vezérlést is rajzolhatunk. Miután megrajzoltuk a négy jelölõnégyzetet, rajzoljunk egy pa-

202



16. fejezet


rancsgombot is. Ezt a parancsgombot arra fogjuk használni, hogy a beállítások után lezárjuk a párbeszédpanelt. Állítsuk be azokat a tulajdonságokat, amelyeket a program használata során nem fogunk megváltoztatni. A beállítások, az 60. ábrán látható számozásnak megfelelõen, a következõk legyenek: 1. Ûrlap Caption: Name:

Gyors beállítások frmGyorsBeallitas

2. CheckBox1 Caption: Name:

Cellarácsok chkCellaRacsok


Munkalap fülek chkLapFulek


Állapotsor chkAllapotsor


Szerkesztõléc chkSzerkLec

6. CommandButton1 Accelerator: B Cancel: True Caption: Bezárás Default: True Name: cmdBezaras Fontos, hogy még az elõtt nevezzük el a vezérléseinket, mielõtt az eseményeiket programozni kezdenénk. Az eseményvezérelt eljárások nevei ugyanis tartalmazzák a vezérlõ objektum nevét. Egy késõbbi átnevezéssel az eseménybe írt utasítások a korábbi névvel ellátott eseményben maradnak. Ezzel csak plusz munkát adunk magunknak. A beállítások után az ûrlapunk ilyen képet fog mutatni: Még mielõtt elkezdenénk megírni a programot, álljunk meg egy szóra! A parancsgomb néhány tulajdonsága talán újdonság lesz. Az Acceleretor tulajdonságba egy B betût írtunk. Ennek az a feladata, hogy a feliratban aláhúzza a Bezárás elsõ betûjét. Ha a felhasználó a leüti az ALT+B billentyûkombinációt, pont az történik, mintha az egérrel kattintott volna a

203


Elnevezés A vezérléseket a használatuk elõtt nevezzük el. Az vezérlés nevét itt is érdemes elõtaggal kezdeni.



4. rész

gombra. Hasonló célt szolgál a Default és a Cancel tulajdonságok True beállítása is. Ha egy ûrlapon valamelyik parancsgomb Default tulajdonságát True értékre állítjuk, akkor az lesz a panel alapértelmezett gombja. Egy ûrlap alapértelmezett gombját az ENTER billentyû hozza mûködésbe. Ha a Cancel tulajdonság értéke True, akkor azt az ESC billentyû leütése mûködteti. Ennek megfelelõen a mi bezárás gombunk az ALT+B, az ENTER és az ESC billentyûk leütésétõl is mûködésbe lép. Ezután kezdjük el a panel programozását. Kezdjük a cmdBezaras gombbal. Ebbe azt a parancssort kell beírnunk, amivel bezárhatjuk az ûrlapunkat. A leggyorsabban úgy juthatunk el a parancsgomb Click – kattintásra – eseményébe, a kettõt kattintunk a gombra.

61. ábra: A gyors beállítás panel a tulajdonságok beállítása után Private Sub cmdBezaras_Click() Unload Me End Sub

Események kiválasztása A párbeszédpanel bal oldali listájából kiválszthatjuk azt a vezérlésr, ameliyknek az eseményét programozni szeretnénk.

Ha egyszer már itt vagyunk az ûrlap modulban, írjuk meg a többi eljárást is! Nyissuk le a modul bal oldali listapanelét. A lenyitott listából válasszuk ki a chkCellaRacsok elemet. Itt találjuk meg ennek a vezérlésnek az eseményeit. Az alapértelmezett esemény a Click. Mi nem ezt fogjuk programozni, hanem a Change eseményt. Nyissuk le a modul jobb oldali listapanelét és keressük meg a kiszemelt eseményt. Ha megtaláltuk, írjuk bele a következõ sort. ActiveWindow.DisplayGridlines = chkCellaRacsok

Ebben az utasításban a chkCellaRacsok vezérlés pillanatnyi értékét használtuk fel arra, hogy láthatóvá tegyük, vagy elrejtsük az aktív ablak cellarácsait. A CheckBox vezérlések két állapotúak. Ha bekapcsoljuk az értéke True, kikapcsolva pedig False. A DisplayGridlines tulajdonság beállításához szintén logikai értéket kell írnunk. Tehát az egyik objektum

204



16. fejezet


tulajdonságának értékét átadjuk egy objektum tulajdonságának. A többi beállítást hasonlóan fogjuk megvalósítani. A chkLapFülek Change eseményéhez írjuk a következõ sort: ActiveWindow.DisplayWorkbookTabs = chkLapFulek

Az Állapotsor jelölõnégyzet Change eseményéhez a megfelelõ utasítássor a következõ: Application.DisplayStatusBar = chkAllapotsor

A Szerkesztõléc feliratú gomb utasítássora pedig ez legyen: Application.DisplayFormulaBar = chkSzerkLec

Próbáljuk ki a munkánk eredményét. Álljunk az ûrlapra és üssük le az F5-ös funkció-billentyût. Amint árváltjuk az ûrlapon a CheckBox vezérlések értékét azonnal végre is hajtódik a beállítás. Így a háttérben rögtön látjuk is az eredményt. Jelenlegi ûrlapunknak azonban van még egy hibája. Ez pedig az, hogy amikor megnyitjuk az ûrlapot, akkor a jelölõnégyzetek nem azt az állapotot mutatják, amit a környezet szerint mutatniuk kellene. Ezeket a beállításokat az ûrlap megnyitása során kell beállítanunk. Az ûrlap megnyitásakor bekövetkezõ esemény az Initialize aktiválódik. Vagyis azok az utasítások, amelyeket ebbe az eseményvezérelt eljárásba írunk, akkor fognak lefutni, amikor az ûrlapot megnyitjuk, használatba vesszük. Kattintsunk hát kettõt az ûrlapra. Keressük meg a Initialize eseményt, és írjuk be az eljárásba a következõ sorokat: chkCellaRacsok = ActiveWindow.DisplayGridlines chkLapFulek = ActiveWindow.DisplayWorkbookTabs chkAllapotsor = Application.DisplayStatusBar chkSzerkLec = Application.DisplayFormulaBar

Hátra van még az indító eljárás elkészítése. A próba ûrlap indításához már beillesztettünk egy általános modult a projektünkbe. Ez éppen jó lesz az újonnan létrehozott ûrlap indítóeljárásához.

További vezérlések Az ûrlapokon sokféle vezérlést használhatunk. Ezeknek a megismerésében nem segít a makró rögzítés. Itt nekünk kell kísérleteznünk, utána olvasnunk. Ezeket programozni is lehet. Ha kevésnek ítélnénk a rendelke-

205




4. rész

zésünkre álló vezérléseket, a kereskedelemben újabbakat vehetünk. Ebben a részben ismerkedjünk meg néhány vezérlés használatával.

Beviteli mezõ

TextBox Magyar nevén bevitali mezõ. Ezt a vezérlést arra használjuk, hogy a felhasználó által beírt értéket átadjuk a programnak.

Ebben a példában közvetlenül adunk át adatot egy ûrlapon elhelyezett TextBox vezérlésbõl a munkafüzet egyik cellájába. Nyissunk meg egy új munkafüzetet. Kapcsoljunk át a VBE ablakba. Az új munkafüzetbe szúrjunk be egy felhasználói párbeszédpanelt. A panelre helyezzünk el egy TextBox vezérlést. Jelöljük ki, és a tulajdonságablakban keressük meg a ControlSource tulajdonságát. Ennek a tulajdonságnak legyen az értéke A1. Ezzel meghatároztuk, hogy a mindenkori aktív munkalap A1-es cellájába kerüljön az a szöveg, amit az ûrlap beviteli mezõjébe írtunk. Ezután üssük le az F5-ös funkció-billentyût. A panel indításának az eredményeként a VBE-bõl átkerülünk az Excelbe. Vagyis a létrehozott párbeszédpanel az Excel területe fölött fog megjelenni. Írjunk be egy tetszõleges szöveget a beviteli dobozba, majd zárjuk le az ûrlapot. Erre használjuk az ûrlap jobb felsõ sarkában található X-et. Miután lezártuk a panelt a VBE-bõl lapozzunk vissza az Excelbe. Azt fogjuk tapasztalni, hogy az aktív munkalap A1-es cellájába került az a szöveg, amit a beviteli dobozba írtunk. Tehát, ha a ControlSource tulajdonságban egy cellára hivatkozunk, akkor az ûrlap lezárása után átadhatjuk az adatbeviteli doboz tartalmát. Ezt természetesen bármelyik másik adatbeviteli vezérlés esetén is megtehetjük. Ahhoz, hogy létrehozzunk egy olyan ûrlapot, amelynek a segítségével adott cellák tartalmát tölthetjük fel nem is kell programoznunk. Ha a munkafüzet egy meghatározott munkalapjának az A1-es cellájába szeretnénk irányítani az adatainkat, akkor meg kell határozni azt is, hogy melyik a kiválasztott munkalap. Ha ez például a Munka1-es lap, akkor a ContlolSource tulajdonságnak a Munka1!A1 értéket kell adni. Programozva w Ugyanezt a feladatot oldjuk meg programozással is. Ebben a megoldásban, azonban nem a ControlSource tulajdonságot fogjuk felhasználni, hanem a beviteli doboznak azt az eseményét, ami a beviteli doboz tartalmának a megváltozásakor következik be. Töröljük a ControlSource tulajdonság értékét. Kattintsunk kettõt a beviteli dobozra. Erre azért van szükség, hogy megjelenjen a beviteli dobozhoz tartozó modul. Ennek a vezérlésnek az alapértelmezett eseménye az adatváltozás. A TextBox1_Change eljárásban állunk. Ebbe írjuk be a következõ utasítássort: Worksheets(“Munka1").Range(”A1") = TextBox1

206



16. fejezet


Ismét indítsuk el az ûrlapot. Figyeljük meg, hogy ebben a megoldásban a Munka1-es munkalap A1-es cellájában azonnal megjelenik a beírt adat, amint leütünk egy betût. Ebben az esetben a beviteli doboz adatát az ûrlapban dolgoztuk fel. Ez most csak annyiból állt, hogy a beírt adatot átmásoltuk a kiválasztott cellába. Hasonlóan használhatjuk a jelölõnégyzetet, vagy a léptetõ gombot is. A vezérléseket tehát használhatjuk a kezdeti tulajdonságok beállításával, ilyenkor a munkalapon dolgozzuk fel a bevitt adatokat, vagy használhatjuk a vezérlés programozásával, ebben az esetben valamelyik eseményt használjuk fel arra, hogy megírjuk azokat az utasításokat, amelyekkel feldolgozzuk a beírt adatokat. Az adatátadás másik módja, amikor adatátadás közben kódoljuk az adatokat. Ehhez a választócsoport, a Kombinált lista, a lista és a választócsoport vezérléseket használjuk. A választócsoport, két vezérlés együttes használatából állítható össze. Ezek a Keret és a Választógomb.

Kombinált lista Ha bizonyos értékek közül kell választanunk egy adat kitöltésekor, akkor kombinált listát használunk. A lehetséges adatokat a kombinált lista lenyitásával jeleníthetjük meg. A listában felsorolt adatokat úgy használhatjuk fel, hogy lenyitjuk a listát és rákattintunk a megfelelõ sorra. A kiválasztott listaelemet a program segítségével feldolgozhatjuk, vagy a megfelelõ cellába juttathatjuk. Ahhoz, hogy kombinált listát tudjunk használni, meg kell adnunk azt, hogy milyen adatok jelenjenek meg a lista lenyitásakor. Ehhez a kombinált lista RowSource tulajdonságának kell értéket adnunk. A másik lényeges tulajdonság a ControlSource. Ebbõl olvashatjuk ki azt, hogy a lista melyik elemét választotta ki a felhasználó. Ezeket a tulajdonságokat kétféle módon határozhatjuk meg. Az egyik esetben egy munkalap megfelelõ tartományára hivatkozunk, a másik esetben programozással határozzuk meg a RowSource és a ControlSource tulajdonságok értékeit. A sorforrás tartományból w A következõ példát úgy oldjuk meg, hogy tartományokat használunk a tulajdonságok beállítására. Készítsünk egy ûrlapot, amelyikre rajzoljunk egy kombinált listát. A lista lenyitása után városok közül lehessen választani és a kiválasztott város nevét írjuk az elsõ munkalap A1-es cellájába. Nyissunk meg egy új munkafüzetet és készítsük elõ a listát a Munka2 (Sheet2) munkalapon. A lista elkészítése után kapcsoljunk át a VBE programba. A Insert Ø UserForm utasítással szúrjunk be egy ûrlapot az aktuális projektbe. Az új ûrlapra rajzoljunk egy kombináltlista vezérlést. Kattintsunk rá az egér jobb gombjával és válasszuk ki a Properties utasítást. A

207


ComboBox Lenyitható listapanel. A lenyitott lista tartalmát mi határozzuk meg. A felhasználó választását feldolgozhatjuk a programban.

RowSource A kombinált lista RowSource – sorforrás – tulajdonságában határozzuk meg azt, hoy mi jelenjen meg a lenyitott listában.



4. rész

keressük meg a RowSource tulajdonságot és írjuk be a sorforrás helyét, a Munka2!A2:A7 hivatkozást. Ezután keressük meg a ControlSource tulajdonságot. Ide írjuk be a Munka1:A1 cellahivatkozást. Ezután jelöljük ki az ûrlapot, és az F5-ös funkció-billentyû leütésével indítsuk el. A megjelenõ párbeszédpanelben nyissuk le a kombinált listát és válasszunk egy várost. Ezután zárjuk le az ûrlapot és nézzük meg a Munka1 munkalap A1-es celláját. Itt megtaláljuk a kiválasztott város nevét. Ez volt a legegyszerûbb módja annak, hogy kombinált listát használjunk.

62. ábra: Készítsük elõ a kombinált lista sorforrását Más esetben a sorforrás több oszlopot is tartalmazhat. Ilyet használunk például akkor, amikor azt szeretnénk megoldani, hogy amikor a listából kiválasztjuk egy termék nevét, a választás eredményeként a termék ára jelenjen meg egy cellában. Ennek a példának a megoldását azzal kezdjük, hogy ugyanebben a munkafüzetben a Munka2 munkalapon – a C1-es cellától kezdve – létrehozzuk a termékek listáját. Az elsõ oszlop legyen a termékek neve – Áru –, a második a termékek ára – Ár. Ezután rajzoljunk egy újabb kombinált listát az ûrlapra. A RowSource tulajdonságához írjuk be a Munka2!C2:D6-os hivatkozást. A ControlSource tulajdonsághoz írjuk be: Munka1!A3.

63. ábra: Több oszlopos sorforrás elõkészítése A vezérlésnek meg kell mondanunk, hogy most két oszlopból kell megjelenítenie az adatokat, ezért a ColumnCount (oszlop-szám) tulajdonsághoz írjunk be egy kettes számot. Ide mindig azt kell beírnunk, hogy hány

208



16. fejezet


oszlopa van a kombinált lista sorforrásának. A következõ lépésben határozzuk meg azt is, hogy a két oszlop közül melyiket szeretnénk felhasználni. Ezt a BoundColumn (kötött oszlop) tulajdonságban állíthatjuk be. Tehát írjuk be annak az oszlopnak a számát, amit a ControlSource tulajdonságban meghatározott cellába szeretnénk írni. Ez az árakat tartalmazó második oszlop. Ha szükséges, még azt is megadhatjuk, hogy a lista lenyitása után milyen szélesek legyenek a sorforrás egyes oszlopai. A ColumnWidths (oszlopszélességek) tulajdonságban soroljuk fel az oszlopok szélességét. Az egyes szélességeket egymástól pontosvesszõvel válasszuk el. Ide gépeljük be az 1 cm; 0 cm szélességeket. Amint kilépünk a tulajdonságból az Excel átírja a mértékegységeket pontra. A második oszlopnak azért adtunk nulla értéket, hogy a listában ne jelenjen meg az ár, csak a megnevezés. A tulajdonságok meghatározása után jelöljük ki az ûrlapot és indítsuk el. Ezt megtehetjük a szokásos módon az Indítás [Run] Eljárás/UserForm futtatása utasítással, de úgy is kipróbálhatjuk az ûrlapot, ha a kijelölése után leütjük az F5-ös funkció billentyût. A termék kiválasztása után zárjuk le az ûrlapot és nézzük meg az elsõ munkalapon az eredményt. Itt most a termék árát olvashatjuk.

64. ábra: Az elkészült kombinált lista használata Programból w A sorforrás megadásának másik módszere, amikor a lista elemeit tömbben deklaráljuk és programból a meghatározott tömböt használjuk a lista sorforrásaként. A sorforrás értékeinek beállítását akkor érdemes végrehajtani, amikor az ûrlapot betöltjük, használatba vesszük. Ezért a sorforrás tulajdonságot az ûrlap Initialize eseményvezérelt eljárásában fogjuk megírni. Az ide írt utasításokat akkor hajtja végre a program, amikor az ûrlapot megnyitjuk. Ismét oldjuk meg az elõzõ két feladatot, de most a sorforrást programból határozzuk meg. Szúrjunk be a projektbe egy újabb ûrlapot. Erre helyezzünk el egy kombinált lista vezérlést. Egy papírra írjuk fel a kombinált lista nevét, amit a tulajdonságablakban nézhetünk meg. Kattintsunk kettõt az ûrlap területére. A megjelenõ objektum modul megjelenése után válasszuk

209




4. rész

ki az Initialize esemény eljárást. Határozzunk meg egy tömböt, majd állítsuk be a lenyitott lista tartalmát. Az eljárás a következõ lesz: Private Sub UserForm_Initialize() Dim strVarosok(5) As String strVarosok(0) = "Érd" strVarosok(1) = "Szeged" strVarosok(2) = "Pécs" strVarosok(3) = "Szolnok" strVarosok(4) = "Budapest" strVarosok(5) = "Vác" ComboBox1.List = strVarosok End Sub

Figyeljük meg, hogy ebben az eseten nem a RowSource, hanem a List tulajdonságot állítottuk be. A másik érdekesség az, hogy a Városok tömböt használtuk fel a listasorok meghatározására, de nem írtunk mögé zárójelet, vagy indexet. Ez ebben az esetben így helyes. Tehát ha programból határozzuk meg a sorforrást, akkor a tömb nevét index és zárójel nélkül használjuk. Ha programból szeretnénk használni a lista eredményét, akkor ismét a lista tulajdonságot fogjuk igénybe venni. A kombinált lista List tulajdonságát ugyanúgy használhatjuk, mintha egy tömb lenne, vagyis a ComboBox1.List(0) hivatkozással a listapanel listájának az elsõ elemére mutatunk rá. Ez a mi példánk szerint az Érd értéket tartalmazza. Csakhogy a jelenlegi feladatban annak a listaelemnek a tartalmát szeretnénk megjeleníteni, amelyiket kiválasztottuk a listából. Ezt a ComboBox1.ListIndex tulajdonságából olvashatjuk ki. Ezt fogjuk felhasználni arra, hogy a kiválasztott lista értékét beírjuk az elsõ munkalap C1-es cellájába. Az utasítást a ComboBox1_Change eseményvezérelt eljárásába írjuk meg. Private Sub ComboBox1_Change() Worksheets("Munka1").Cells(1) = _ ComboBox1.List(ComboBox1.ListIndex) End Sub

Próbáljuk ki az ûrlap mûködését. Figyeljük meg azt is, hogy miután kiválasztottuk a listapanel egyik elemét, az eredmény azonnal megjelenik a Munka1 lap C1-es cellájában. Oldjuk meg a másik feladatot is programozással, vagyis a lenyitott listában jelenítsük meg a termékek nevét. A termék kiválasztása után a Munka1 munkalapon a C3-as cellában jelenítsük meg a kiválasztott áru értékét. Ehhez az ûrlap Initialize eljárását bõvítsük ki a következõ utasításokkal.

210



16. fejezet


Private Sub UserForm_Initialize() Dim strVarosok(5) As String Dim strAruk(4, 1) As String strVarosok(0) = "Érd" strVarosok(1) = "Szeged" strVarosok(2) = "Pécs" strVarosok(3) = "Szolnok" strVarosok(4) = "Budapest" strVarosok(5) = "Vác" strAruk(0, 0) = "Rádió" strAruk(0, 1) = "28000" strAruk(1, 0) = "Televízió" strAruk(1, 1) = "65000" strAruk(2, 0) = "Magnetofon" strAruk(2, 1) = "29300" strAruk(3, 0) = "CD lejátszó" strAruk(3, 1) = "34000" strAruk(4, 0) = "Videó" strAruk(4, 1) = "70000" ComboBox1.List = strVarosok ComboBox2.List = strAruk ComboBox2.ColumnCount = 2 ComboBox2.ColumnWidths = "1 cm ; 0 cm" End Sub

Az eljárás elején deklaráltunk egy két dimenziós tömböt. Ezt késõbb feltöltöttük adatokkal. A listapanel sorforrását ismét úgy határoztuk meg, hogy értéket adtunk a listapanel List tulajdonságának. A következõ sorban a ColumnCount tulajdonság értékét kettõre állítottuk be, ezzel jelezve, hogy a lista két oszlopos lesz. A ColumnWidths tulajdonságot úgy állítottuk be, hogy a lista második oszlopa ne jelenjen meg. A következõ feladat az, hogy az eredményt felhasználjuk. Ismét a Change eseményt fogjuk programozni. Kattintsunk tehát kettõt a kombinált listára, Majd a megjelenõ vezérlés modul Change eseményébe írjuk be a következõ két utasítássort. Worksheets(“Munka1").Range(”C1") = _ ComboBox2.List(ComboBox2.ListIndex, 0) Worksheets(“Munka1").Range(”D1") = _ ComboBox2.List(ComboBox2.ListIndex, 1)

211




4. rész

Az elsõ utasítássor segítségével a Munka1-es munkalap C3-as cellájába beírtuk az áru megnevezését. A második utasítássort pedig arra használtuk, hogy az áru árát megjelenítsük a D3-as cellában. Programozással tehát sokkal rugalmasabban használhatjuk a kombinált listát. A kétféle meghatározási módot kombinálhatjuk is. Ha például a sorforrást a munkalap tartományából határozzuk meg, akkor az eredményt az elõbb leírt módszerrel feldolgozhatjuk vagy a sorforrást megadhatjuk programból és az eredményt egy cellába írhatjuk a ControlSource tulajdonság meghatározásával.

Listapanel vezérlés Ez a vezérlés programozás szempontjából hasonló, mint a kombinált lista. Ennek is a RowSource és a ControlSource tulajdonságait használjuk fel a programozás során. A lista vezérlés némelyik tulajdonságának beállításával jelentõs mértékben megváltoztathatjuk ennek a vezérlésnek a szolgáltatásait. Ebben a részben azzal ismerkedünk meg, hogy mik ezek a beállítások és hogyan használhatjuk fel ennek a vezérlésnek az eredményeit.

ListBox Ez a lista mindíg nyitva van. Nincs adatbevitelre alkalmas része. Ebbõl csak kiválaszthatunk egy elemet.

Több listaelem kiválasztása w Kezdjünk egy új munkafüzetet, az elõzõt zárjuk le. Kapcsoljunk át VBE nézetbe. A jelenlegi projektbe szúrjunk be egy új ûrlapot. Erre az ûrlapra rajzoljunk egy lista vezérlést. Ennek a lista vezérlõelemnek a sorforrását programból fogjuk meghatározni. A sorforrás elemeinek feltöltésére az ûrlap Initialize eljárását használjuk. Kattintsunk kettõt az ûrlap hátterére. Meg fog jelenni az ûrlap objektumhoz tartozó modul. A modul Eljárás listájából válasszuk ki az Initialize eljárást. Az eljárásba írjuk be a következõ utasításokat: Private Sub UserForm_Initialize() Dim strForras(6) As String strForras(0) = "hétfo" strForras(1) = "kedd" strForras(2) = "szerda" strForras(3) = "csütörtök" strForras(4) = "péntek" strForras(5) = "szombat" strForras(6) = "vasárnap" ListBox1.List = strForras End Sub

Ezután a projekt ablakban (a VBE bal oldalán) kattintsunk kettõt az UserForm1 feliratú sorra. Ismét megjelenik a létrehozott ûrlap. Jelöljük

212



16. fejezet


ki az ûrlapra rajzolt listavezérlést és állítsuk be úgy a tulajdonságait, hogy minden listaelem elõtt megjelenjen egy jelölõnégyzet. Ennek érdekében LineStyle tulajdonság mellett található listát nyissuk le és válasszuk ki a fmListStyleOption lehetõséget. Ha bekapcsoljuk még azt is, hogy egyszerre több elemet lehessen kiválasztani, akkor a listapanel elemei elõtt választógombok jelennek meg. Ezt a listapanel MultiSelect tulajdonságának frmMultiSelectMulti ért5ékre állításával érhetjük el. Alapértelmezésben a választógombok egyszerre csak egy listaelem kiválasztását teszik lehetõvé. Állítsuk be azt is, hogy egyszerre több listaelemet is ki lehessen jelölni a listából. Ennek érdekében állítsuk be az objektum MultiSelect tulajdonságát a következõ értékre: fmMultiSelect-Multi. Ezután jelöljük ki az ûrlapot és hajtsuk végre az Indítás [Run] Eljárás/UserForm futtatás utasítást. A listában jelöljünk meg több listaelemet.

65. ábra: Több elem kiválasztása a listapanelbõl Ezután ismerjük meg azt is, hogy milyen módon lehet felhasználni az eredményt, vagyis, hogy hogyan adhatjuk át a program további részeinek, hogy mely elemeket választotta a felhasználó. A kiértékelésre felhasználhatjuk az ûrlap Terminate vagy a lista Change eseményét. Az ûrlap Terminate eseménye akkor következik be amikor bezárjuk az ûrlapot, a lista Change eseménye pedig akkor, amikor megváltoztatjuk a listaelemek kijelölését. Válasszuk az ûrlap lezárása eseményt – Terminate – és írjunk egy olyan programot, amelyik az aktív munkalapra kiírja a listából kiválasztható értékeket, és ezek mellé megjeleníti azt is, hogy melyik elemet választotta a felhasználó. Kattintsunk kettõt az ûrlap területére és írjuk meg a következõ eljárást. Private Sub UserForm_Terminate() Dim bytI As Byte For bytI = 1 To ListBox1.ListCount With Worksheets(“Munka1")

213




4. rész

.Cells(bytI, 6) = ListBox1.List(bytI - 1) .Cells(bytI, 7) = ListBox1.Selected(bytI - 1) End With Next bytI End Sub

Az eljárás elsõ sorában deklaráltunk egy változót. Ezt arra fogjuk felhasználni, hogy végiglépkedjünk a lista elemein. Tehát ennek a változónak az értéke fog rámutatni az éppen aktuális listaelemre. For bytI = 1 To ListBox1.ListCount

Ennek a sornak az a feladata, hogy addig ismételje a lista elemek kiértékelését, amíg a listaelemek száma tart. Ezt jelzi a sor végén található ListBox1.ListCount kifejezés. A ListCount tulajdonság ugyanis azt mutatja meg, hogy hány soros a lista. Cells(bytI, 1) = ListBox1.List(bytI - 1)

Ebben a sorban íratjuk ki a listák elemeit. Ezek az értékek az aktuális munkalap elsõ oszlopában fognak megjelenni. Cells(bytI, 2) = ListBox1.Selected(bytI - 1)

A ListBox1.Selected tulajdonságából megtudhatjuk, hogy éppen egy listaelemet bekapcsolt-e a felhasználó. Itt minden listaelemre rákérdezünk. A bekapcsolt elemek True értéket adnak vissza. Futtassuk az ûrlapot. Tetszõlegesen jelöljük ki a listaelemeket, majd zárjuk le az ûrlapot. A választásunk eredményét az aktív munkalapon fogjuk meg találni. Ha csak arra lennénk kíváncsiak, hogy a felhasználó melyik elemeket választotta ki a listából, akkor az ûrlap Initialize eljárásába írjunk be egy olyan utasítássort, amelyik törli a munkalapnak azt a területét, ahova az eredményeket írtuk. A Terminate eljárást írjuk át a következõképpen: Private Sub UserForm_Terminate() Dim bytI As Byte Dim bytK As Byte bytK = 1 For bytI = 1 To ListBox1.ListCount If ListBox1.Selected(bytI - 1) Then Cells(bytK, 9) = ListBox1.List(bytI - 1) bytK = bytK + 1 End If

214



16. fejezet


Next bytI End Sub

Ha a MultiSelect tulajdonságot fmMultiSelectExtended értékre állítjuk be, akkor a listapanel ugyanúgy fog mûködni, mint minden Windows alkalmazás. Vagyis, ha kijelölünk egy listaelemet és lenyomjuk a CTRL billentyût, akkor további listaelemeket választhatunk ki, ha pedig egy listaelem kijelölése után a SHIFT billentyû lenyomásával kattintunk egy másik sorra, akkor a kezdetben kijelölt listasortól addig jelöljük ki a listasorokat, ameddig az újonnan kijelölt elem tart. Lista, mint választócsoport w A listát beállíthatjuk úgy is, hogy egyszerre csak egy elemét lehessen kiválasztani és minden listasor elõtt egy választógomb legyen. A beállításhoz állítsuk be a lista LinsStyle tulajdonságát frmListStyleOption értékre és ne állítsunk be többszörös kiválasztást. Ugyanebbe a projektbe készítsünk még egy ûrlapot és ismét rajzoljunk egy lista vezérlést. Most is az ûrlap Initialize utasítását használjuk fel arra, hogy meghatározzuk a lista vezérlés elemeit. Ez legyen ugyanaz, mint az elõzõ feladat esetén. Indítsuk el ezt az ûrlapot. Próbáljuk meg kiválasztani a lista egyik vagy másik elemét. Azt fogjuk tapasztalni, hogy egyszerre csak egy eleme lehet kiválasztva. Zárjuk le az ûrlapot és nézzük meg a kiértékelés módját. A kiértékelésére több lehetõség is kínálkozik. A legegyszerûbb – ezt akkor használjuk, ha a munkalapon dolgozzuk fel a választás eredményét – az, amikor a lista ControlSource tulajdonságába beírjuk azt a cellahivatkozást, ahova az eredményt szeretnénk elhelyezni. A programban használható módszert írjuk meg az ûrlap lezárása (Terminate) eljárásba. Kattintsunk kettõt az ûrlap területén. A megjelenõ modul ablak Eljárás listájából válasszuk ki a Terminate eseményt. Ebbe írjuk bele a következõ utasításokat: Private Sub UserForm_Terminate() Range(“A5") = ListBox1.ListIndex Range(“A6") = ListBox1.List(ListBox1.ListIndex) End Sub

A lista ebben az állapotában a ListIndex tulajdonságban tárolja a kiválasztott listasor sorszámát. A sorszámozás nullától kezdõdik. Ezt az értéket jelenítjük meg az A5-ös cellában az elsõ utasítássorral. A második utasítás segítségével a listapanel kiválasztott sorának szövegét írjuk az aktív munkalap A6-os cellájába.

215




4. rész

Összefoglalás A felhasználóval sokféle grafikus eszközzel tarthatjuk a kapcsolatot. Egyszerûbb üzeneteket gyorsan kevés programozással küldhetünk az MsgBox segítségével, amelynek két változata is a rendelkezésünkre áll. Az egyik változat, amikor metódusként hivjuk meg, a másik esetben függvényként. Metódusként meghívva, nem értékelhetjük ki a felhasználó válaszát. Így nincs is értelme választási lehetõséget elheyezni rajta. A metódusként hívott MsgBox esetén az argumentumokat zárójeklek nélkül soroljuk fel. Ebben az esetben a zárojelek nem csak feleslegesek, de futási hibát is eredményeznek. A függvényként meghívott üzenet panel argumentumait zárójelek közé kell írnunk, és mindenképpen egy változóban kell tárolni a felhasználó válaszát. Hasonlóan egyszerû eszköz az Office segéd, amelyet minden Office alkalmazásból elérhetünk. Az egyszerûség hátránya, hogy csak korlátozott számú vezértlés helyezhetünk el rajta és csak programozottan kezelhetõ. Egyedi ûrlapokat hozhatunk létre az alkalmazás rugalmassá tétele érdekében. Ebben az esetben jó eredményeket érhetünk el a vezérlõ objektumok tulajdonságainka a beállításával. A programozása sem túl összetett ezeknek az eszközöknek, de a megismerés némi kisérlettezést igényel. Itt nem aklalmazhatjuk a makró rögzítést az objektumok megismerésére. Ezért kisebb programook írásával próbáljuk megismerni az eszközöket.

216



17. fejezet

Menüsor, eszköztár

iután elkészítettük az eljárásainkat, azt várhatólag többen is fogják használni. Mi el tudjuk indítani a felvett vagy általunk írt eljárásokat a Makrók (Macros) panelbõl vagy a Visual Basic Editorból. Ez a módszer azonban lehet, hogy egy átlagos felhasználónak nem lesz annyira egyszerû. Úgy kell kialakítanunk a program környezetet, hogy az, bárki számára könnyen kezelhetõ legyen. Például, helyezzünk el gombot egy eszköztáron, amivel elindítható az eljárás. Azt is megtehetjük, hogy teljesen új egyedi eszköztárat készítünk a programjaink mûködtetéséhez. További lehetõség, hogy menüparancshoz rendeljük a makrónkat. A végcél az, hogy amennyire lehet, olvasszuk bele az Excelbe azokat a programokat, amelyeket mi készítettünk. Ehhez jó eszköz, ha azt a munkafüzetet, amelyikben a programunk van beépülõ makróként mentjük el és hozzákapcsoljuk az Excelhez. A gondolatébresztõ kérdések a következõk: w Hogy rendelhetjük az eljárást eszköztárhoz vagy menühöz? w Mit kell tennünk egy beépülõ makró elkészítése során? w Hogy határozhatjuk meg, hogy egy függvény melyik kategóriába kerüljön?

Egyedi menü és eszköztár A menü és az eszköztár ugyanarra az objektum osztályra épül. Ezért mindkettõt ugyan ott, és ugyanúgy alakíthatjuk át. A kiindulás mindkét esetben az, hogy az egér jobb gombjával kattintsunk vagy az egyik eszköztárra, vagy a menüsorra. A helyi menüben az utolsó parancs a Testreszabás (Customize). Miután megjelent a párbeszédpanel, hozzáfoghatunk az eszköztárak, és a menü egyedi kialakításához. Mind a két objektumra ugyanazokat a parancsgombokat helyezhetjük el. A parancsgombokat ugyanúgy rendelhetjük hozzá az általunk írt eljárásokhoz.

217


Menü és eszköztár A Testreszabás panel bekapcsolása után mind két objektumot egyedileg átalakíthatjuk.



4. rész

66. ábra: A menü és az eszköztárak átalakíása Testreszabás panel Amíg ez a panel látszik, mind a menüt, mind az eszköztárat szerkeszthetjük.

Új ezsköztár A testreszabás panelben létrehozhatunk új eszköztárat.

Amíg az alkalmazásban látható a Testreszabás (Customize) párbeszédpanel, addig mind az eszköztárakat, mind a menüket szabadon átalakíthatjuk. Megfoghatjuk a panel Parancsok (Commans) lapon található bármelyik gombot és egy tetszõleges eszköztár gombjai, vagy a menü parancsok közé húzhatjuk. A megjelenõ párbeszédpanel három lapból áll. Az elsõ lap neve Eszköztárak (Toolbars). Itt találjuk meg az adott Office alkalmazásban – jelenleg ez az Excel – létrehozott eszköztárakat és menüsorokat. Ezen a lapon állva hozhatunk létre újabb eszköztárat vagy menüsort. A Parancsok (Commands) lapon az Excel-ben használható parancsgombokat, utasításokat fedezhetjük fel. Az itt található gombokat mind az eszköztárra, mind pedig a menüre elhelyezhetjük. Egyszerûen meg kell fogni az egérrel és a megfelelõ helyre húzni. A harmadik fül a Beállítások (Options) nevet viseli. Itt a menüsor mûködését állíthatjuk be. A Parancsok között található gombokhoz a program írói már hozzárendeltek bizonyos funkciókat Ha nincs szükségünk az adott funkcióra, ezeket a gombokat is felhasználhatjuk a magunk céljaira. Van azonban két olyan gomb, amit kifejezetten arra a célra tartottak fenn, hogy makrókat rendelhessünk hozzájuk. Ezeket, a Makrók (Macros) utasításcsoportban találjuk. Ha kiválasztjuk a csoportot, akkor megtaláljuk a Felhasználói menügomb (Custom Menu Item) Egyedi gomb (Custom Button). Ezekhez mi rendelhetjük hozzá az eljárásaikat. Elõször hozzunk létre egy újabb eszköztárat, amin majd az a gomb lesz, amivel az elõbb rögzített makrót fogjuk elindítani. Lapozzunk a párbeszédpanel Eszköztárak (Toolbars) lapjára és kattintsunk a Létrehozás (New) gombra. Erre megjelenik egy kisebb panel, amelyikben elnevezhetjük a most készülõ eszköztárat. Ennek a szerkesztõdobozába írjuk be a Segédlet elnevezést, majd kattintsunk az OK gombra.

218



17. fejezet


67. ábra: Új eszköztár létrehozása Az elkészült eszköztár még üres, hiszen nem helyeztünk még el rajta egyetlen gombot sem. Ha az eszköztár a késõbbiekben feleslegessé válik, törölhetjük az Eszköztárak listájából, ha kijelöljük és rákattintunk a Törlés (Delete) feliratú gombra. Most ezt ne tegyük, csak jegyezzük meg. Azt is figyeljük meg, hogy ha egy olyan eszköztárat jelölünk ki a listából, amelyik az Excel része volt – vagyis nem mi készítettük –, akkor a Törlés gombot nem választhatjuk ki. Ezeket az eszköztárakat ugyanis, nem lehet törölni, csak alaphelyzetbe állítani. Ez azt jelenti, hogy nyugodtan megváltoztathatjuk bármelyik eszköztár összetételét, ha meggondoljuk magunkat, bármikor visszaállíthatjuk az eredeti állapotot.

68. ábra: Új parancsgomb elhelyezésa az eszköztáron

219



Kapcsolat a felhasználóval Új gomb A Testreaszabás panel Parancsok lapjáról tetszõleges gombot húzhatunk az eszköztárra.

4. rész

Készítsünk gombot, amivel elindíthatunk egy eljárást. Nyissuk meg a CD melléklet Menusor eszkoztar mappájából a Menusor_eszkoztar.xls munkafüzetet, vagy bármelyik másikat, amelyben vannak makrók. A Kategóriák (Categories) listából keressük ki a Makrók (Macros) csoportot. Fogjuk meg az Egyedi gomb (Custom Button). Gombot és húzzuk az új – Segédlet – eszköztárra (219. oldal 68. ábra). Ehhez fogjuk hozzárendelni az egyik makrót tartalmazó megnyitott munkafüzet eljárását. A Testreszabás (Custoize) párbeszédpanel továbbra is legyen nyitva. Állítsuk be az Egyedi eszköztár gomb jellemzõit. Az egér jobb gombjával kattintsunk az Egyedi gombra. Ez az a helyi menü, ahol az eszköztárak gombjainak és a menüparancsoknak a jellemzõit beállíthatjuk. Itt találunk egy szerkesztõdobozt, mely a gomb nevét tartalmazza, ami jelenleg az Egyedi gomb (Custom Button). Ezt a szöveget írjuk át Jelentés-re. Erre azért van szükség, mert ez a szöveg fog megjelenni akkor, amikor az egérmutatót a gomb fölé húzzuk. A lenyitott helyi menüben a gombképen is változtathatunk. Ismét kattintsunk az egér jobb gombjával az eszköztár gombjára, és válasszuk ki a Gombkép váltása (Change Button Image) utasítást. Itt elõkészített rajzok várják, hogy felkerüljenek egy gomb felületére. Tetszés szerint válasszunk egyet. Ha még ezek között sincs olyan, amilyet mi szeretnénk, akkor kattintsunk a helyi-menü Gombkép szerkesztése (Edit Button Image) utasításra. Most már csak a saját fantáziánk és kézügyességünk lehet az akadálya egy tetszetõs gombfelület megrajzolásának. Rendeljük hozzá a makrót a gombhoz. A helyi-menü legalsó utasítása a Makróhozzárendelés (Assign Macro), ha erre kattintunk, akkor a megjelenõ párbeszédpanelbõl kiválaszthatjuk annak a makrónak a nevét, amit akkor szeretnénk lefuttatni, amikor erre a gombra kattintunk. Az OK gombra kattintva lépjünk ki a Hozzárendelés gombhoz panelbõl, majd a Testreszabás (Customize) panelt zárjuk le, a Bezárás (Close) feliratú gombbal. Álljunk egy üres lapra és kattintsunk rá az új gombra.

Új menüpont A Testreszabás panel Parancsok lapján találjuk az üres menüpontot.

69. ábra: A menüszerkezet Menüutasítás létrehozása w A mûveletek nagy része egyezik az eszköztárak kialakításával. Akkor mégis miért kell beszélnünk róla? Azért, mert itt

220



17. fejezet


nem csak parancsot vihetünk fel, hanem menüpontokat is. Menüpontot egyébként akár egy eszköztárra is fel lehet tenni. A menüpont mögött nincs végrehajtható mûvelet. Ennek csak az a célja, hogy befogadja azokat a gombokat, amelyeket majd felteszünk. A menü szerkezetét tetszés szerint megváltoztathatjuk. Új menüpontokat, almenüket hozhatunk létre. Ez az egyetlen, de lényeges különbség az eszköztárak és a menüparancsok kialakítása között. Ismét az egér jobb gombjával kattintsunk bármelyik eszköztárra, vagy a menüsorra. A helyi menübõl válasszuk ki a Testreszabás (Customize) utasítást. A megjelenõ párbeszédpanelben lapozzunk a Parancsok (Commands) lapra. Válasszuk ki az Új menü (New Menu) legutolsó kategóriát. Az ebben található menüponttal új menüpontot hozhatunk létre a menüsorban. Fogjuk meg az Új menü (New Menu) szöveget és húzzuk az Ablak [Window] és a Súgó [Help] menüpontok közé. Kattintsunk az új menüpontra az egér jobb gombjával, és a megjelenõ helyi menü Név (Name) szerkesztõdobozába írjuk be a Segédletek szöveget. Vigyünk almenüt az új menüpont alá. Ehhez fogjuk meg ugyanezt az Új menü (New Menu) gombot, az egér gombját tartsuk lenyomott állapotban és vontassuk a Segédletek menüpont fölé.

70. ábra: Új menüpont létrehozása Miközben a menüpontot vontatjuk, a már menüsoron lévõ menüpontok és az almenüpontok engedelmesen kinyílnak. Az egérmutató mellett megjelenik egy függõleges vonal. Ez ugyanúgy, mint az eszköztáraknál, azt a helyet mutatja, ahova az új menüpont kerül az egér elengedése után. Vigyük az új menüpontot a rajzán látható helyre. Amikor a menüpontot elengedjük, akkor az lenyitva marad. Most kattintsunk rá az egér jobb gombjával és adjuk meg az almenü nevét: Szöveges.

221


Új almenü A estreszabás panel Parancsol lapjáról az új menüpontot behúzhatjuk egy másik manü alá is,



4. rész

A következõ lépés, hogy a menühöz utasítást rendelünk. Az eljárás ugyanaz, mint az a gomb esetén volt, de most a Makrók (Macros) kategóriából a Felhasználói menügomb (Custom Menu Item) szövegû gombot visszük a Segédletek menüpont Szöveges almenüpontba. Az utasítást a helyi menü Név (Name) szerkesztõdobozában nevezzük el Jelentés kitöltése névvel. Az új utasításhoz rendeljük hozzá a Jelentes makrót. Ehhez kattintsunk az új utasításra az egér jobb gombjával, és a Makróhozzárendelés (Assign Macro) utasítás segítségével ugyanúgy rendeljük hozzá a programunkat, mint ahogy azt az eszköztár gombjával tettük. Próbáljuk meg a munkafüzet többi eljárását is menüparancshoz, vagy eszköztár gombjához rendelni. Ha a menüpont feleslegessé válik, akkor a Testreszabás párbeszédpanel megnyitása után egyszerûen fogjuk meg a menüpontot, és húzzuk le a helyérõl.

Menük, eszköztárak programozása

Commandbars gyûjtemény Az eszköztárak és menüsorok gyûjteménye.

Ezek jó megoldások, de hátrányuk, hogy minden gépen nekünk kell elvégezni a hozzárendelési mûveleteket. Ha eddig eljutottunk a könyvben, jogos a kérdés, hogy miért nem program segítségével tesszük fel a parancsokat? Ugyanis az eszköztárak és menük objektumok. Ha pedig objektumok, akkor programozni is lehet õket. Akkor most következzenek az eszköztárak és menük programozási lehetõségei. Mint azt a fejezet korábbi részében láttuk, az eszköztárak és a menük ugyanahhoz az objektumosztályhoz tartoznak. Mind két objektum a Commandbars gyûjtemény elemei. Ha programozottan szeretnénk meghatározni a jellemzõiket, akkor ennek a gyûjteménynek a részleteit fogjuk programozni. A Commandbars gyûjtemény magába foglalja az eszköztárakra és a menüsorokra elhelyezett gombokat, menüpontokat. Ezek a vezérlések a CommandBarControls gyûjtemény részei. Ennek a két objektumnak a megismerésével lehetõségünk nyílik programból megváltoztatni az Office alkalmazások menüsorainak és eszköztáraink az összeállítását. A Commandbars gyûjteményt ugyanis az összes Office alkalmazásban megtaláljuk. Ha szükséges új menüt és eszköztárat hozhatunk létre. Felmerülhet a kérdés, hogy mennyit segítünk a felhasználón, ha írunk egy olyan eljárást, ami parancsgombot helyez el egy új vagy már meglévõ eszköztárra. Nem sokat, ha most ugyanúgy el kell indítania egy eljárást a Makró (Macros) panelbõl, ami elhelyezi a gombot a megfelelõ helyre. Mi hát a megoldás? Az, hogy eszköztár létrehozását, módosítását annak a munkafüzetnek az Open eseményvezérelt eljárásába írjuk meg, amelyik a bõvítményeket tartalmazza. Így, amikor megnyitjuk a munkafüzetet,

222



17. fejezet


megjelennek a vezérlések is. Ha már nincs rájuk szükség, akkor a makrót tartalmazó munkafüzet Close eseményében levehetjük a felesleges vezérléseket, megszüntethetjük a munkafüzethez tartozó eszköztárakat. Eszközsor létrehozása w Ha nem szeretnénk az Office alkalmazáshoz tartozó eszköztárakat megváltoztatni, akkor hozzunk létre újat. Ezen helyezzük el majd azokat a gombokat, amelyekhez hozzárendeljük az egyedi eljárásainkat. Nyissuk meg az Utasítássorok.xls munkafüzetet, ebben az Eljárások modulban néhány egyszerû eljárást találunk. Ezek az aktív munkalap A1-es cellájába kiírják azt, hogy melyik eljárás futott le. Ezeket fogjuk elindítani az utasítássorokra elhelyezett vezérlésekkel. Elsõként ismerjük meg azt, hogy miként lehet létrehozni egy új utasítássort (Commandbar). Kapcsoljunk át VBE-be (ALT+F11). Kattintsunk kettõt az UtasításSorok modulra. Ez egy üres modul. Ebben fogjuk megírni az elsõ utasítássorok kezelését végzõ eljárásainkat. Az UtasításSorok modul UjEszkoztár eljárásába írjuk be a következõ utasításokat: Sub UjEszkoztár() ‘Ebben az eljárásban új eszköztárat hozunk létre ‘A létrehozott eszköztárra utasítássor vezérlése‘ket helyezünk el, ezek segítségével indítjuk el ‘az Eljárások modul eljárásait. On Error GoTo Hiba ‘Változók állandók deklarálása Dim cbrUjEszkt As CommandBar Const STR_NEVE As String = “Saját eszköztár” ‘Új eszköztár létrehozása: Set cbrUjEszkt = CommandBars.Add(Name:=STR_NEVE, _ Position:=msoBarFloating, MenuBar:=False, _ Temporary:=True) cbrUjEszkt.Visible = True Exit Sub Hiba: If Err.Number = 5 Then Exit Sub Else Error.Err End If End Sub

Elemezzük ki az eljárást! A hibakezelés célja az, hogy amikor már létrehoztuk az új eszköztárat, nem hozhatunk létre még egy ugyanolyan nevût. Ha az eljárást másodszor futtatjuk, az új eszköztárat létrehozó sor hi-

223




4. rész

bát fog okozni. Ekkor mi elugrunk a Hiba címkére, és ott be is fejezzük az eljárást az Exit Sub parancs hatására. Az ezt követõ utasításban deklaráljuk az új eszköztár azonosítására szolgáló változót: cbrUjEszkt. Majd az STR_NEVE állandóba elhelyezzük az új eszköztár nevét, melyet késõbb használunk fel. A Set utasítással kezdõdõ sorban hozzuk létre magát az eszköztárat. A metódusnak négy argumentuma van, az elsõben adhatjuk meg az elkészítendõ eszköztár nevét, a másodikban azt a helyet jelölhetjük meg, ahol meg kívánjuk jeleníteni az új eszköztárat. A MenuBar argumentum két értéket vehet fel, ha ezt False-ra állítjuk be, akkor az új utasítássor eszköztárként fog viselkedni. A Temporary argumentumban arról gondoskodhatunk, hogy mi történjen az utasítássorral akkor, amikor bezárjuk azt a munkafüzetet, amiben létrehoztuk. Ha ezt az argumentumot True értékre állítjuk, akkor az eszközsor eltûnik, amint lezárjuk azt a munkafüzetet, amiben létrehoztuk. cbrUjEszkt.Visible = True

Végül ezzel a parancssorral, megjelenítjük a létrehozott eszköztárat. Ez még üres, mincs rajta egyetlen vezérlés sem. Errõl mi fogunk gondoskodni. Menüsor létrehozása w A két eszköz között az eltérés csak egyetlen argumentum értékének a meghatározásában van. Ha ugyanis a MenuBar argumentumnak a True értéket adjuk, akkor a létrehozott utasítássor menüsorként fog mûködni. Mivel egy alkalmazásban egyszerre csak egy menüsort jelenít meg az összes Office alkalmazás, a megjelenítés után eltûnik az eredeti menüsor. Az eredeti menüsor, csak akkor tér jelenik meg ismét, ha töröljük az általunk létrehozott menüsort. A menüsor készítõ eljárás a következõ lesz: Sub UjMenusor() ‘Ebben az eljárásban új eszköztárat hozunk létre ‘A létrehozott eszköztárra utasítássor vezérlése‘ket helyezünk el, ezek segítségével indítjuk el ‘az Eljárások modul eljárásait. On Error GoTo Hiba ‘Változók állandók deklarálása Dim cbrUjEszkt As CommandBar Const STR_NEVE As String = “Saját menüsor” ‘Új eszköztár létrehozása: Set cbrUjEszkt = CommandBars.Add(Name:=STR_NEVE, _ Position:=msoBarFloating, MenuBar:=True, _ Temporary:=True)

224



17. fejezet


cbrUjEszkt.Visible = True Exit Sub Hiba: If Err.Number = 5 Then Exit Sub Else Error.Err End If End Sub

Az eljárás teljesen megegyezik az elõzõvel, a MenuBar argumentum értékének a meghatározásán és az elnevezésén kívül. Menüsort elrejteni vagy megjeleníteni csak programból lehet. Ha ezt az eszköztárak testreszabására szolgáló párbeszédpanelbõl szeretnénk megtenni, az Excel nem hajtja végre az utasítást, tehát marad az Excel eredeti menüsora. Menüsor és eszköztár törlése w Ha lezárjuk azt a munkafüzetet, amelyikben az eljárásaink vannak, nincs szükség az általunk létrehozott eszköztárra, vagy menüsorra. Meg kell tehát szabadulnunk tõle. Mivel a menüsorok és az eszköztárak ugyanannak a gyûjteménynek a részei, mindkét típust ugyanúgy törölhetjük. Ügyeljünk arra, hogy pontos névvel hivatkozzunk a törlendõ elemre. Az eljárás a következõ lesz: Sub EszkTöröl() Const STR_NEVE As String = “Saját eszköztár” ‘A létrehozott eszköztár törlése On Error GoTo Hiba CommandBars(STR_NEVE).Delete Exit Sub Hiba: If Err.Number = 5 Then Exit Sub Else Error.Err End If End Sub

Menüpontok Az eszköztár vagy menüsor létrehozása után a következõ legyen a menüpont. Menüpontot elhelyezhetünk eszköztáron is. A menüpontok újabb menüpontok befogadására képesek, vagyis egy-egy menüpont alá elhelyezhetünk almenüket is. Kezdjünk egy új eljárást, amelyikben menüket

225




4. rész

és almenüket helyezünk el az elõzõ részben létesített utasítássorra. Az új eljárásba a következõ utasításokat írjuk le: Sub MenuPontok() Dim cbrMenuSor As CommandBar Dim popMenu1 As CommandBarPopup Dim popSubMenu1 As CommandBarPopup Dim popSubMenu2 As CommandBarPopup Const STR_NEVE As String = “Saját menüsor” Const STR_MNU1_NEVE As String = “E&gyedi menü” Const STR_SMNU1_NEVE As String = “&Elsõ almenü” Const STR_SMNU2_NEVE As String = “&Második almenü” Set cbrMenuSor = CommandBars(STR_NEVE) Set popMenu1 = cbrMenuSor.Controls.Add _ (Type:=msoControlPopup) popMenu1.Caption = STR_MNU1_NEVE Set popSubMenu1 = popMenu1.Controls.Add _ (Type:=msoControlPopup) popSubMenu1.Caption = STR_SMNU1_NEVE Set popSubMenu2 = popMenu1.Controls.Add _ (Type:=msoControlPopup) popSubMenu2.Caption = STR_SMNU2_NEVE End Sub

Az eljárás ismét azoknak a változóknak és állandóknak a deklarálásával kezdõdik, amelyeket a felhasznált objektumok azonosítására fogunk felhasználni. A popMenu1 változó az utasítássorra elhelyezett menüpont azonosítója lesz, a popSubMenu1 és a popSubMenu2 változók pedig a popMenu1 vezérlésbe elhelyezett almenük elnevezését fogják szolgálni. Set cbrMenuSor = CommandBars(STR_NEVE)

A változók deklarálása után a létrehozott menüsort elnevezzük cbrMenuSor névvel. Set popMenu1 = cbrMenuSor.Controls.Add(Type:= msoControlPopup)

Ebben az utasításban a cbrMenuSor objektumhoz hozzáadunk egy új menüpontot. A Type argumentumban beállított msoControlPopup értékkel határozzuk meg azt, hogy az új vezérlés menüpont legyen. Ugyanebben az utasítássorban el is neveztük az új menüpontot popMenu1 névvel. Ez alá utasításokat, vagy újabb menüpontokat hozhatunk létre. Ebben az eljárásban az utóbbit tesszük.

226



17. fejezet


popMenu1.Caption = STR_MNU1_NEVE

Ez az utasítássor arra szolgál, hogy az elhelyezett menüpontnak a feliratát meghatározzuk. Ennek a feliratnak az értékét jegyezzük meg, mert ha késõbb hivatkozni szeretnénk a most elhelyezett menüpontra, akkor a hivatkozás során ezt a címkét kell használni. Set popMenu1 = cbrMenuSor.Controls.Add _ (Type:=msoControlPopup)

Mivel a vezérlésünket elneveztük a popMenu1 változóval, ezért a továbbiakban felhasználhatjuk hivatkozásként. Ha ezt nem tettük volna meg, akkor a következõ írásmóddal hivatkozhattunk volna a létrehozott vezérlésre: Set popSubMenu1 = cbrMenuSor.Controls(STR_MNU1_NEVE).Controls _ .Add(Type:=msoControlPopup)

A következõ utasítássorban az elhelyezett almenü feliratát határozzuk meg. Ezt a feliratot a késõbbiekben ismét használhatjuk arra, hogy hivatkozzunk az adott vezérlésre. Az eljárás két utolsó sorában leírt utasítások még egy almenüt helyeznek el a menüpont alá. Az egyes menüpontok szövegében található & karakter jelzi, hogy a mögötte álló karakter a menüpont billentyûkombinációja lesz. Set MenuSor = Application.CommandBars(“AZONOSÍTÓ”)

Ha az Excel saját utasítássorainak valamelyikére szeretnénk vezérlést elhelyezni, akkor a programunk csak annyiban fog változni, hogy az utasítássor elnevezése során a CommandBars gyûjtemény AZONOSÍTÓ szövege helyett, annak az utasítássornak a nevét kell beírnunk, amelyiket használni szeretnénk. Az utasítássorok nevét a mellékletben megtalálhatjuk. Ezek között találunk helyi menüket is! Menüpont törlése w Ha az egyes vezérlések feleslegessé válnak, akkor azokat törölhetjük az utasítássorról. Mivel az almenük a menüpont részei, elegendõ azt a menüt törölnünk, amelyiknek a részeire nincs tovább szükségünk. Íme egy példa az elõbbi menük törlésére: CommandBars(STR_NEVE).Controls(STR_MNU1_NEVE).Delete

Parancsok elhelyezése w A létrehozott eszköztárakra, menüsorokra és a menüpontok alá utasításokat helyezhetünk el. Ezekkel egyrészt elindíthat-

227




4. rész

juk azokat az eljárásokat, amelyeket mi készítettünk, másrészt mûködtethetjük az Excel beépített utasításait. Helyezzünk el utasításokat az utasítássor, a menüpont és az almenüpont alá. Ezt szemlélteti a következõ eljárás: Sub Utasítások() Dim cbrMenuSor As CommandBar Dim popMenu1 As CommandBarPopup Dim popSubMenu1 As CommandBarPopup Dim popSubMenu2 As CommandBarPopup Dim cbbEgyediGomb1 As CommandBarButton Dim cbbEgyediGomb2 As CommandBarButton Dim cbbEgyediGomb3 As CommandBarButton Const STR_NEVE As String = “Saját menüsor” Const STR_MNU1_NEVE As String = “E&gyedi menü” Const STR_SMNU1_NEVE As String = “&Elsõ almenü” Const STR_SMNU2_NEVE As String = “&Második almenü” Const STR_EGYEDI_1_CIM As String = “Egyedi egy” Const STR_EGYEDI_2_CIM As String = “Egyedi két” Const STR_EGYEDI_3_CIM As String = “Egyedi hár” Const STR_ELJ1 As String = “Eljárás1" Const STR_ELJ2 As String = “Eljárás2" Const STR_ELJ3 As String = “Eljárás3" Set cbrMenuSor = CommandBars(STR_NEVE) Set popMenu1 = cbrMenuSor.Controls.Add(Type:=msoControlPopup) popMenu1.Caption = STR_MNU1_NEVE Set popSubMenu1 = popMenu1.Controls.Add(Type:=msoControlPopup) popSubMenu1.Caption = STR_SMNU1_NEVE Set popSubMenu2 = popMenu1.Controls.Add(Type:=msoControlPopup) popSubMenu2.Caption = STR_SMNU2_NEVE cbrMenuSor.Controls.Add Type:=msoControlButton, ID:=2 Set cbbEgyediGomb1 =_ cbrMenuSor.Controls.Add(Type:=msoControlButton) With cbbEgyediGomb1 .FaceId = 51 .Caption = STR_EGYEDI_1_CIM .OnAction = STR_ELJ1 End With popMenu1.Controls.Add Type:=msoControlButton, ID:=3 popSubMenu1.Controls.Add Type:=msoControlButton, ID:=4 Set cbbEgyediGomb2 = _ popSubMenu1.Controls.Add(Type:=msoControlButton)

228



17. fejezet


With cbbEgyediGomb2 .FaceId = 68 .Caption = STR_EGYEDI_2_CIM .OnAction = STR_ELJ2 End With Set cbbEgyediGomb3 = – popMenu1.Controls.Add(Type:=msoControlButton) With cbbEgyediGomb3 .FaceId = 52 .Caption = “Egyedi eljárás” .OnAction = STR_ELJ3 End With End Sub

Mivel ez az eljárás egy kicsit hosszú, ezért ezt több lépésben elemezzük. Az elemzés elsõ részlete legyen az objektum elnevezést végzõ sorok megértése. Set cbrMenuSor = CommandBars(STR_NEVE) Set popMenu1 = cbrMenuSor.Controls.Add(Type:=msoControlPopup) popMenu1.Caption = STR_MNU1_NEVE Set popSubMenu1 = popMenu1.Controls.Add(Type:=msoControlPopup)

Ennek a résznek a feladata az, hogy a menüpontokat elnevezzük a deklarált változók nevével. Az eljárás elején deklaráljuk azokat a változókat, amelyeket az eljárásban használni fogunk. Ezután a Set kezdetû sorokban elnevezzük azokat az objektumokat – az utasítássort, a menüpontot és a két almenüpontot – amelyek már a rendelkezésünkre állnak. Ezekbe fogjuk elhelyezni az Excel beépített utasításait, és az eljárások modulban megírt eljárások indítását végzõ parancsvezérléseket. cbrMenuSor.Controls.Add Type:=msoControlButton, ID:=2

Ez az utasítás az utasítássorra közvetlenül helyezi el a kettes azonosítószámú Excel utasítást. Ez a Helyesírás utasítás. Ebben az esetben már korábban megneveztük az utasítássort egy változó segítségével. Itt már csak a vezérlést kell hozzáadnunk. Ennek a típusa gomb és az azonosítója a kettes szám. Set cbbEgyediGomb1 = – cbrMenuSor.Controls.Add(Type:=msoControlButton) With cbbEgyediGomb1 .FaceId = 51

229




4. rész

.Caption = STR_EGYEDI_1_CIM .OnAction = STR_ELJ1 End With

Ebben a programrészben egyedi eljárás indítására használjuk az utasítássorra elhelyezett vezérlést. A Set sorban elhelyezünk egy gombot az utasítássoron, majd a következõ lépésekben meghatározzuk a jellemzõit. Ezek sorrendben a következõk: FaceID, a gomb felületi rajza. A Caption kettõs célt szolgál. Egyrészt ez a szöveg jelenik meg a gomb mellett, ha menüként használjuk, másrészt ez a szöveg jelenik meg akkor, amikor az egeret a gomb fölé húzzuk. Az OnAction tulajdonság mögé, szövegállandóként vagy szöveget tartalmazó változóként írjuk annak az eljárásnak a nevét, amelyiket szeretnénk elindítani akkor, amikor a vezérlésre rákattintunk. Az eljárás további részei hasonlóak, mint az itt elemzett rész a különbség összesen annyi, hogy a menü és az almenü alá helyez el vezérlést. Ezeket nem részletezzük.

Bõvítmények létrehozása Ahogy a fejezet elején olvashattunk, lehetõségünk van arra is, hogy a makrókat tartalmazó munkafüzetet, bõvítménnyé alakítsuk. Töltsük be a CD melléklet Menusor eszkoztar mappájából a Bõvítmény.xls fájlt. Ebbõl fogunk bõvítményt létrehozni.

A bõvítmény elõkészítése Elõször röviden nézzük meg azt, hogy hogyan használhatjuk a bõvítményeket. A Microsoft Excellel együtt kapunk bõvítményeket, melyek telepítéskor egy külön erre a célra fenntartott mappába kerülnek. Azon a meghajtón, amire az Office alkalmazásokat telepítettük, keressük meg a Program files\Microsoft office\Office mappát. Ebben megtaláljuk a Makro (Library) mappát. Itt találjuk a bõvítményeket. Célszerû lesz nekünk is ide menteni a sajátjainkat, mert akkor a bõvítménykezelõ felismeri azokat, és használatra felkínálja. A bõvítmények kiterjesztése XLA. Ha ezek közül valamelyiket megnyitjuk, akkor használhatjuk a bennük megírt függvényeket, illetve eljárásokat. Érdemes megjegyezni, hogy ha közvetlenül a Megnyitás panellel töltjük be a beépülõ programokat, akkor csak addig állnak rendelkezésünkre az eszközei, amíg ki nem lépünk az Excelbõl, azaz a következõ betöltéskor már nem használhatjuk õket. Másik módszer a bõvítmények elérésére, hogy valamelyik indítókönyvtárba mentjük a beépülõt. Az igazán helyénvaló megoldás azonban

230



17. fejezet


az, hogy az Excel megnyitása után a beépülõt hozzákapcsoljuk magához a programhoz. Ennek érdekében válasszuk ki az Eszközök (Tools) Bõvítménykezelõ (Add-Ins) utasítást. Eredményképpen megjelenik egy párbeszédpanel, amelyik felkínálja a Makro (Library) mappában található bõvítményeket. Ha bármelyik beépülõ elõtt található választókapcsolót bekapcsoljuk, akkor kijelöltük az adott beépülõt arra, hogy betöltõdjön. A betöltésre akkor kerül sor, amikor a párbeszédpanel OK gombjára kattintunk. A továbbiakban, az Excel betöltésekor automatikusan betöltõdnek a kiválasztott beépülõk mindaddig, amíg a bõvítménykezelõben ki nem kapcsoljuk. Figyeljük meg azt is, hogy amint rákattintunk az egérrel egyik vagy másik bõvítményre, a panel alján megjelenik egy rövid leírás arról, hogy mire használható a kiválasztott bõvítmény. Arról, hogy ez a magyarázat megjelenjen, nekünk kell majd gondoskodnunk. Ezt úgy tehetjük, hogy mentés elõtt kitöltjük a munkafüzet adatlapját. Az adatlap párbeszédpanelt a Fájl (File) Adatlap (Properties) utasítás segítségével jeleníthetjük meg. Az adatlapról kerül a listába a bõvítmény neve is. Ha valóban szeretnénk megvédeni a programunkat az illetéktelen behatolástól, akkor a projektet védjük le jelszóval. Ezt a VBE nézetben tehetjük meg. Nézzük most már gyakorlatban is a bõvítmény-készítést. A lemezmellékletrõl töltsük be a Bõvítmény nevû munkafüzetet. Ebben egy egyszerû függvényt és egy korábban elkészített ûrlapot találunk. Ezt a munkafüzetet mentjük majd el bõvítményként. Készítsük elõ. A munkafüzet megnyitása után válasszuk ki a Fájl (File) Adatlap (Properties) utasítást. A megjelenõ adatlapban lapozzunk az Adatlap lapra és írjuk be a címet és a megjegyzést a szerint.

71. ábra: A kitöltött adalapból megjelenõ értékek

231




4. rész

Ezután kapcsoljunk át a VBE-be és állítsuk be a projekt tulajdonságait. Ehhez válasszuk ki a VBE Eszközök (Tools) VBAProject tulajdonságai (VBAProject Properties) utasítást. A megjelenõ panel két lapból áll. Az elsõ egy Általános (General) lap a másik pedig a projekt Védelem (Protection) beállítására szolgáló lap. Az általános lapon elnevezhetjük a projektet, egy rövid leírást mellékelhetünk hozzá, valamint meghatározhatjuk a súgó fájl jellemzõit. A védelem lapon pedig jelszót adhatunk meg annak érdekében, hogy a projektet csak az láthassa, aki ismeri a jelszót. Itt kapcsoljuk be a Projekt zárolása a megtekintés elõl (Lock project for viewing) lehetõséget és írjuk be a jelszót a Jelszó (Password) szerkesztõdobozba. A jelszót ismételjük meg a Jelszó megerõsítése (Confirm password) dobozban is. Ezután kattintsunk az OK gombra. Ezzel befejeztük az elõkészítést. Mentsük el a projektet. Térjünk vissza az Excelbe és válasszuk a Fájl (File) Mentés másként (Save As) utasítást. A megjelenõ panelben nyissuk le a Fájltípus (Save as Type) listapanelt. A listából válasszuk ki a Microsoft Excel bõvítmény (Microsoft Excel Add-in (*.xla)) lehetõséget és mentsük a munkafüzetet a bõvítmények számára fenntartott mappába (Program files\Microsoft office\Office\Makro (Library)). A projekt jelszavas védelme A programozási részt külön is véhatjük jelszóval.

72. ábra: A projekt jelszavas védelmének a beállítása Az eredmény az Excel betöltése után lesz látható ezért zárjuk le az Excelt, majd ismét töltsük be. Csatoljuk a bõvítményt az Excelhez. Hajtsuk végre az Eszközök (Tools) Bõvítmények (Add Ins) utasítást. A megjelenõ párbeszédpanelben keressük meg azt a beépülõt, amit most mentettünk el. Azt az elnevezést keressük, amit az adatlap Cím szerkesztõdobozába írtunk. Ha kijelöljük az általunk készített bõvítményt, akkor a panel lapján megjelenik az a magyarázat, amit az adatlap megjegyzés rovatába írtunk. Kapcsoljuk be a jelölõnégyzetét.

232



17. fejezet


Ha ezután megnézzük az Ablak (Window) Felfedés (Unhide) utasítása után megjelenõ panelt nem fogjuk benne találni a Bõvítmény munkafüzetet. Sõt, ha megnézzük a végrehajtható eljárásokat az Eszközök (Tools) Makró Makrók utasításban, ott sem fognak megjelenni a beépülõ munkafüzet eljárásai. Ha átkapcsolunk a VBE-be, akkor a projektek között megjelenik ugyan az új bõvítmény, de ezt már csak az nézheti meg, aki ismeri a projekt jelszavát.

Elõkészítés futási idõben Ebben a projektben két egyszerû program van az egyik egy függvény, a másik pedig az Excel beállítását szolgáló panel. A függvényt azonnal használatba vehetjük. Ha megnézzük a függvényvarázslót, akkor a Felhasználói függvénycsoportban megleljük a KerekErre függvényt. A függvényt elhelyezhetjük tetszõleges függvénycsoportban, de ehhez még kicsit programoznunk kell. A beállításra szolgáló eljárást nem találjuk sehol. Ha megnézzük az elérhetõ makrókat (Eszközök (Tools) Makró (Macro) Makrók (Macros) utasítás segítségével), azt fogjuk tapasztalni, hogy az eljárások nem jelennek meg. Tehát elrejtettük a felhasználó elõl azokat az eljárásokat, amelyeket mi hoztunk létre. Ezek indíthatóságáról mi fogunk gondoskodni. Az eddig megismert egyik módszerrel nyissuk meg a Bõvítmény projektet. Kapcsoljunk át a VBE-be és kattintsunk kettõt a Bõvítmény projekt jelére. Ha jelszóval védtük, akkor megjelenik egy párbeszédpanel. Innen csak akkor léphetünk tovább, ha ismerjük a jelszót. Miután beléptünk a projektbe, kattintsunk kettõt a ThisWorkbook szövegre. Ez a Bõvítmények projekt munkafüzete. A megjelenõ modul ablak baloldali listájából válasszuk ki a Workbook elemet. Ennek hatására megjelenik az alapértelmezésnek megfelelõ Open esemény. Ha a bõvítmény betöltése során szeretnénk végrehajtani utasításokat, akkor azokat ebbe az eljárásba kell megírnunk, hiszen amikor a bõvítményt tartalmazó munkafüzetet betölti az Excel, akkor megnyitja ezt a füzetet, és végrehajtja az Open eseményt. Ide leírhatjuk a függvények kategóriákba sorolásához szükséges programlépéseket és kiadhatjuk azokat az utasításokat, amelyek segítségével a munkafüzet betöltésekor menüpontot, vagy eszköztár gombot jelenítünk meg. Ezekhez hozzárendelhetjük a bõvítményben leírt eljárások indítását. Ha a bõvítményt eltávolítjuk az Excelbõl, akkor gondoskodnunk illik arról is, hogy a futási idõben megjelenített menüpontokat és utasítás gombokat megszüntessük. Ezt a munkafüzet BeforeClose eljárásában tehetjük meg. A függvények csoportjának a meghatározásáról nem kell gondoskodnunk, mivel a függvény automatikusan eltûnik a varázslóból, amikor a bõvítményt eltávolítjuk.

233




4. rész

A függvény jellemzõk meghatározása Határozzuk meg azt, hogy a KerekErre függvény a statisztikai csoportba kerüljön. Adjunk egy rövid leírást a függvény használatához. Ehhez tehát lépjünk be a bõvítmény ThisWorkbook eljárásába. Ide írjuk be a következõket: Private Sub Workbook_Open() ‘Függvénycsoport állandók Const BYT_PENZUGYI As Byte = 1 Const BYT_DATUM_IDO As Byte = 2 Const BYT_MAT_TRIG As Byte = 3 Const BYT_STATISZTIKA As Byte = 4 Const BYT_MATRIX As Byte = 5 Const BYT_ADATBAZIS As Byte = 6 Const BYT_SZOVEG As Byte = 7 Const BYT_LOGIKAI As Byte = 8 Const BYT_INFORMACIO As Byte = 9 Const STR_KEREK_ERRE As String = “KerekErre” Const STR_LEIRAS As String = _ “Kerekíti a számot az Egység” _ & “argumentumban megadott értékhez.” Application.MacroOptions _ Macro:=STR_KEREK_ERRE, _ Description:=STR_LEIRAS, _ Category:=BYT_STATISZTIKA End Sub

Az eljárás elején az állandókat csak a szemléltetés kedvéért határoztuk meg. Ebbõl azt tudhatjuk meg, hogy melyik függvénykategóriának mi a sorszáma. Jelen eljárásban elegendõ lett volna a statisztikai állandót meghatározni, ha a függvényt ebbe a csoportba szeretnénk beilleszteni. A következõ állandóban annak a függvénynek a nevét határoztuk meg, amelyiknek a tulajdonságait most fogjuk beállítani. Ez a KerekErre függvény. Ezután a függvény magyarázat szövegét deklaráljuk. Az állandók deklarálása után jöhet maga a beállítást elvégzõ utasítássor. Ha egy függvény tulajdonságait kívánjuk beállítani, akkor elegendõ a metódusnak csak a példában látható három argumentumát meghatározni. Az egyes argumentumok nevei magukért beszélnek. Ennek megfelelõen a Macro argumentumban azt kell meghatároznunk, hogy melyik függvény tulajdonságait állítjuk be, vagyis a függvény nevét. A Description argumentumban a magyarázó szöveget határozhatjuk meg, és végül a

234



17. fejezet


Category-ban azt állíthatjuk be, hogy a megnevezett függvény melyik csoportba kerüljön. Mivel ez az eljárás minden esetben lefut, amikor betöltjük ezt a munkafüzetet, minden esetben a megfelelõ csoportba kerül az általunk írt függvény. A bõvítmény elfedi a felhasználó elõl azt a munkafüzetet, amelyben a belé írt eljárások vannak. Nem kell rejtett füzetként menteni, és egy kis programozással a felhasználó úgy fogja találni, hogy a mi eljárásaink is részei az Excel-nek. Tetszés szerint be és kikapcsolhatjuk a bõvítményeinket. Ha szükséges jelszóval védhetjük bármelyik munkafüzet moduljait, így a bõvítményekét is. Ezzel elkerülhetjük az illetéktelen kezek munkáját. A bõvítmények betöltése olyan jól elfedi az eljárásainkat, hogy a Makrók (Macros) panelben sem jelennek meg azok. Ez jó is meg rossz is. Jó, mert nem fér hozzá a felhasználó. Rossz, mert nem fér hozzá a felhasználó. A jó az a dologban, hogy nem indíthatja el senki az eljárásunkat. Így viszont nekünk kell gondoskodnunk arról, hogy a megfelelõ eszköztár gombok megjelenjenek, és a megfelelõ menüparancsok is a helyükre kerüljenek. Most fogjuk csak igazán hasznát venni az eseményvezérelt eljárásoknak. A bõvítményként mentett munkafüzet Open – megnyitásra – eseményébe olyan programot fogunk írni, ami elhelyezi a szükséges gombokat mind az eszköztárakra, mind pedig a menüparancsok közé. A Close – bezárás – eseményt pedig arra fogjuk felhasználni, hogy levegyük azokat a gombokat, menüparancsokat, amelyeket mi tettünk fel.

Billentyû-kombinációk programozása Ennek a meghatározását a legegyszerûbben úgy tehetjük meg, hogy mielõtt a munkafüzetet bõvítményként mentenénk, az Eszközök [Tools] Makró [Macro] Makrók [Macros] utasítással megjelenített párbeszédpanelben rákattintunk az Egyebek [Options] gombra és a megjelenõ panelben megadjuk az eljárás a billentyûkombinációját (). Természetesen a MacroOptions metódus segítségével ezt megtehetjük akkor is, amikor a bõvítményt használatba vesszük, vagyis a bõvítményt tartalmazó munkafüzet Open eseményét felhasználva. A Bõvítmény munkafüzet Open eseményét bõvítsük a következõ sorokkal. Const STR_BEALL As String = “eljGyorsBeáll” Const STR_BEALL_LLEIRAS As String = _ “A munkafüzet gyors beállítása” Const STR_BILLENTYU As String = “U” Application.MacroOptions Macro:=STR_BEALL, _ Description:=STR_BEALL_LLEIRAS, _ hasShortCutKey:=True, _

235




4. rész

ShortcutKey:=STR_BILLENTYU

73. ábra: Billenntyû-kombinációk beállítása kézzel Az állandók meghatározása után állítsuk be az eljárás jellemzõit. Határozzuk meg a magyarázatát és azt a billentyûkombinációt, amelyikkel a bõvítmény betöltése után elindíthatjuk az eljárást. A MacroOption metódus Macro argumentumában azt határozzuk meg, hogy melyik eljáráshoz rendelünk billentyût. Ez a mi esetünkben az eljGyorsBeáll lesz. Az eljárás nevét eljárás elején az STR_BEALL állandóban tároljuk. A Description argumentumot arra használjuk, hogy az eljárás magyarázatnak értéket adjunk. Ezt akár el is hagyhatjuk. A hasShortCutKey argumentum az Excelnek szól. Itt mondjuk meg, hogy az eljáráshoz billentyûkombinációt fogunk hozzárendelni. A ShortcutKey argumentumban pedig egy betût választhatunk, amivel az eljárást majd mûködésbe hozhatja a felhasználó. Amikor a kézi beállítás lehetõségét választjuk, akkor is ezeket az argumentumokat határozzuk meg, csak akkor egy párbeszédpanelt használunk a beállításhoz (). Az utasítás eredményeként ezt az eljárást a SHIFT+CTRL+u billentyû-kombinációval indíthatjuk el.

Összegezve Mivel a bõvítményként elmentett munkafüzet eljárásai nem jelennek meg az elindítható eljárások listájában (Eszközök (Tools) Makró (Macro) Makrók (Macros) utasítás), biztosítanunk kell a felhasználónak az indítás lehetõségét. Erre három módszer kínálkozik. Az eljáráshoz billentyû-kombinációt vagy menüutasítást rendelhetünk, illetve az eszköztár egyik gombjához kapcsolhatjuk a bõvítményben megírt eljárást. Gyakran használt eljárások esetén akár egyszerre használhatjuk mind a három eszközt. Az egyes indítási módszereknek megvan az elõnyük és a hátrányuk. A billentyûkombináció például gyorsan végrehajtható, de nehéz megjegyez-

236



17. fejezet


ni. Az eszköztár gyors is és mindig látható is, de a felhasználónak meg kell jegyeznie a megfelelõ gombot. A menü szövege tájékoztatja a felhasználót arról, hogy mi történik, ha kiválasztja a megfelelõ menüutasítást, de több lépésre van szükség az utasítás kiválasztásához, vagyis lassú módszer.

237





18. fejezet

Kapcsolat más programokkal alálkozhatunk olyan idõszakonként ismétlõdõ feladattal, amikor az Excelben elkészített munkánk eredményét át kell tennünk a Word-be, vagy éppen idõszakonként prezentáció forrásaként szolgál az Excelben létrehozott dokumentum. Ennek a feladatnak az elvégzéséhez természetesen rendelkezésünkre áll a vágólap is, ha azonban ezt a feladatot gyakran kell végrehajtanunk, vagy olyan munkatársunk végzi, aki nem eléggé tájékozott a másolás mûveletében, akkor segítséget nyújthatunk neki a folyamatok automatizálásával. Ehhez ismernünk kell annak az alkalmazásnak az objektumait, amelyiket az Excelbõl szeretnénk vezérelni. Szerencsére a programozás eszköze a többi Office alkalmazásban is a VBA. Kisebb problémát, csak az fog okozni, hogy ebben a könyvben nem lesz lehetõségünk a többi alkalmazás objektumainak részletes bemutatására. De az Office alkalmazások többségében is jó segítséget nyújt a makró rögzítés. A kérdések a következõk legyenek: w Hogy érhetjük el Excelbõl a többi Office alkalmazást? w Hogy programozhatjuk Excelbõl az Office alklamazásokat?

Az Office alkalmazások használata Az elsõ lépés minden esetben az, hogy az általunk írt eljárásból el kell érnünk a használni kívánt alkalmazást. Mivel ezek is objektumok, itt is hivatkozni kell tudni. Erre több lehetõségünk is van. Az egyik az, amikor hasonlóan járunk el, mint az egyedileg létrehozott objektumaink használata esetén, azaz új objektumként deklaráljuk a kívánt alkalmazást. A másik módszer, amikor a CreateObject függvényt használjuk az alkalmazás megszólítására. Egy újabb lehetõség pedig, amikor egy futó alkalmazás szolgáltatásait vesszük igénybe.

239




4. rész

Kapcsolat létrehozása References Kapcsoljuk be azt az objektumot, amelyiket szeretnénk elérni a programunkból.

Az említett három módszert egyszerû példákon keresztül fogjuk megismerni. A legelsõ feladat kapcsolatot teremteni a kívánt alkalmazással. Töltsük be az Excelt és kapcsoljuk be a VBE programot. A VBE programban válasszuk ki az Tools Ø References utasítást. Az utasítás eredményeként meg fog jelenni egy párbeszédpanel, amiden meghatározhatjuk azokat az alkalmazásokat, amelyeket látni szeretnénk az Excelbõl is. A megfelelõ objektum-könyvtárat be kell kapcsolnunk a használatbavétel elõtt, különben az Excel nem ismeri fel (74. ábra). Megírhatjuk az elsõ eljárásunkat, amelyik használja a Word szövegszerkesztõt.

74. ábra: Kapcsoljuk be a használni kívánt objektumkönyvtárat

New kulcsszó A new kulcsszóval új objektumelõford ulást hozhatunk létre.

Sub WordExcelbol() Dim appWord As New Word.Application Const STR_SZOVEG As String = _ "Szöveg a Word szövegszerkesztõbe!" appWord.Visible = True appWord.Documents.Add appWord.Selection.TypeText STR_SZOVEG End Sub

Az eljárás elsõ utasítása a Dim. Ebben határozzuk meg azt, hogy az eljárásban használni fogjuk a Word szövegszerkesztõt. Amikor a deklaráláskor az As kulcsszó mõgé beírjuk a New szót, a Word alkalmazás objektum új elõfordulását hoztuk létre. A Word ennek a programsornak a hatására még nem töltõdik be, csak majd ha használatba vesszük. appWord.Visible = True

240



18. fejezet

Kapcsolat más programokkal

Erre az utasításra most a szemléltetés kedvéért van szükségünk. Ez a sor azt eredményezi, hogy megjelenik a Word, ugyanúgy mintha betöltöttük volna. Azaz csak majdnem ugyanúgy, mivel ezután az utasítás után, még nem lesz egyetlen megnyitott dokumentum sem. appWord.Documents.Add

Figyeljük meg, hogy a Word-ben ugyanúgy kezdhetünk új dokumentumot, mint ahogy az Excelben egy új munkafüzetet kezdtünk. Tehát itt is az Add metódust használjuk, de mivel a Word nem munkafüzettel dolgozik, itt a Documents gyûjteménybe veszünk fel egy új elemet. appWord.Selection.TypeText STR_SZOVEG

A következõ utasítással egy állandóban tárolt szöveget írunk a Word dokumentum éppen kiválasztott (Selection) pontjára, vagyis oda, ahol a szövegkurzor éppen áll. Futtassuk le eljárásunkat, és közben figyeljük meg, mi történik a képernyõn. Az eljárás végrehajtása után zárjuk le a szövegszerkesztõt.

75. ábra: Az eljárás futtatása után ezt látjuk a Wordben Ennek a módszernek az a hátránya, hogy csak a hivatkozásokban bekapcsolt objektumokat használhatjuk. Ez akkor nem is okoz problémát, ha magunknak írunk programot és gondoskodunk arról, hogy a hivatkozások be legyenek kapcsolva. Ha azonban másnak készítjük a programot,

241




4. rész

akkor ezt éppen azért tesszük, hogy a kellõ ismeretek hiányában is használhassák azt. Ebben az esetben másik módszerhez kell nyúlnunk.

Objektum létrehozása

CreateObject A CreateObject függvénnyel létrehizhatjuk úgy is a kapcsolatot, hogy nem kapcsoljuk be az adott objektumot a References panelben

A következõ módszert akkor is használhatjuk, ha elõre nem kapcsoltuk be annak az alkalmazásnak vagy objektumnak a hivatkozását, amit használni szeretnénk. Az elõzõ feladatot oldjuk meg még egyszer, de elõtte kapcsoljuk ki azt a hivatkozást, amitõl az Excel VBA ráismert a szövegszerkesztõre. Tehát a VBE-ben hajtsuk végre az Tools Reference utasítást és a megjelenõ párbeszédpanelben kapcsoljuk ki a Word objektumkönyvtárat (76. ábra). Próbáljuk meg ismét lefuttatni az eljárást. Az eredmény egy hibaüzenet lesz.

76. ábra: A referencia nélkül futtatott eljárás hibaüzenete Írjuk át az elõzõ eljárást. Ezúttal használjuk a CreateObject függvényt. Az eljárás tehát a következõ lesz: Sub WordExcelbol() Dim appWord As Object Const STR_OBJECT_TYPE As String = "Word.Application" Const STR_SZOVEG As String = _ "Szöveg a Word szövegszerkesztõbe!" Set appWord = CreateObject(STR_OBJECT_TYPE) appWord.Visible = True appWord.Documents.Add appWord.Selection.TypeText STR_SZOVEG End Sub

242



18. fejezet


Az eljárás végrehajtásának az eredménye ugyanaz lesz, csak most nem kell gondoskodnunk a hivatkozásról, tehát bármelyik gépen futtathatjuk, amelyikre korábban Word szövegszerkesztõt telepítettünk. Dim appWord As Object

Fedezzük fel, hogy most objektumnak deklaráltuk az appWord változót. Ez azonban csak az egyik különbség. A másik az, hogy a használatbavétel elõtt el kell neveznünk a szövegszerkesztõt a Set utasítás segítségével. Set appWord = CreateObject(STR_OBJECT_TYPE)

Ebben a sorban lényeges, hogy a függvény argumentumában szövegállandóként kell meghatároznunk azt, hogy melyik alkalmazással kívánunk dolgozni. Ha a gépünkre valamelyik alkalmazás korábbi változatát is telepítettük, akkor hasznos az Application kulcsszó mögé beírni a változat számát is. Ebben az esetben, az egyébként nagyon figyelmes és szolgálatkész VBE, nem kínálja fel a lehetséges alkalmazásokat, így a lehetõségeket nekünk kell tudnunk. Ezek a következõk: Office objektumok

8. táblázat: Alkalmazások szövegállandó hivatkozásai Alkalmazáneve

Hivatkozás szövege

Microsoft Excel

Excel.Application

Excel munkafüzet

Excel.Workbook

Excel munkalap

Excel.Worksheet

Excel diadram

Excel.Chart

Microsoft Access

Access.Application

Microsoft PowerPoint

PowerPoint.Application

Microsoft Word

Word.Application

Word dokumentum

Word.Document

Microsoft Binder

OfficeBinder.Application

Microsoft Outlook

Outlook.Application

Az Office alkalmazásokban található objektumokra a táblázatban látható szövegállandókkal hivatkozhatunk.

Létezõ dokumentum kezelése Ha egy korábban elkészített dokumentumhoz szeretnénk hozzáférni, annak adataival szeretnénk mûveletet végrehajtani, akkor a GetObject függvényt kell használnunk. Némelyik alkalmazás esetén a függvény

243




4. rész

használata elõtt gondoskodnunk kell arról, hogy megnyissuk azt az alkalmazást, amelyik dokumentumát használni kívánjuk. Programozott adatátadás Szükség esetén egy létezõ dokumentumba is átadhatunk adatokat.

Adatok átadása a programok között w Készítsünk egy példát, amelyikben egy Word dokumentum szövegét átvisszük az Excelbe. A programot Excelben írjuk meg. Elsõként hozzunk létre egy Word dokumentumot. Ebben legyen három bekezdés. A dokumentumot mentsük el. Jegyezzük meg a dokumentum nevét és a mentés helyét. Ezekre szükségünk lesz az eljárás megírása során.

77. ábra: A Word dokumentum elõkészítése Nyissuk meg a Word szövegszerkesztõt. A megjelenõ új dokumentumba írjunk be három tetszõleges tartalmú bekezdést. Utána mentsük el a dokumentumot. A könyv példájában a C merevlemez fõkönyvtárába került a dokumentum és a neve Get.doc. Ezután zárjuk le a szövegszerkesztõt. Töltsük be az Excelt. Kapcsoljunk át a VBE programba. Ne felejtsük el ellenõrizni és szükség esetén bekapcsolni a Word objektumkönyvtár hivatkozását a References panelben. Az új projektbe szúrjunk be egy új modult, és írjuk be a következõ eljárást:

Word.Document Ezzel az objektummal férhetünk hozzás egy létezõ Word dokumentumhoz.

Sub GetWordDok() Dim docWord As Word.Document Dim parBekezd As Word.Paragraph Dim intI As Integer Const STR_WORD_DOC As String = "C:\Get.doc" Const STR_OBJECT_TYPE As String = "Word.document" Const STR_CELL_1 As String = "A4" Const STR_CELL_2 As String = "A5"

244



18. fejezet


intI = 1 Set docWord = GetObject(STR_WORD_DOC, STR_OBJECT_TYPE) For Each parBekezd In docWord.Paragraphs Cells(intI, 1) = parBekezd intI = intI + 1 Next parBekezd Range(STR_CELL_1) = docWord.Parent.Name Range(STR_CELL_2) = docWord.Name End Sub

GetObject A GetObject függvénnyel létezõ dokumantumok hoz férhetünk hozzá.

Az eljárás elején deklaráljuk azokat a változókat, amelyeket használni fogunk. Ezután elnevezzük a létrehozott szöveg dokumentum objektumot, docWord névvel. Set docWord = GetObject(STR_WORD_DOC, STR_OBJECT_TYPE)

A GetObject függvénynek két argumentuma van, az egyik a használni kívánt dokumentum elérési útvonala és a fájl neve, a másik pedig az objektum osztály meghatározása. A mi esetünkben az objektum osztály a Word dokumentum. Az eljárás csak akkor fog helyesen mûködni, ha a megfelelõ elérési útvonalat írtuk be. Ügyeljünk tehát arra, hogy a könyv példája nem írható át betû szerint. For Each parBekezd In docWord.paragraphs Cells(intI, 1) = parBekezd intI = intI + 1 Next parBekezd

78. ábra: Az eljárás futása utáni eredmény az Excelben

245




4. rész

Ebben a ciklusban végiglépkedünk a Word dokumentum minden bekezdésén és átmásoljuk a kiolvasott szöveget az Excel aktuális munkalapjának celláiba. Az intI értékét a Cells paramétereként használjuk fel, így az egyes bekezdések egymás alatti, cellákban fognak megjelenni. Range(STR_CELL_1) = docWord.Parent.Name Range(STR_CELL_2) = docWord.Name

A következõ két utasítás csak azt kívánja szemléltetni, hogy a Word további tulajdonságaihoz is hozzáférhetünk. Az Parent tulajdonság a szülõ objektum. Mivel a dokumentum a Word-ben készült, ezért ebben az esetben a szülõ a Word szövegszerkesztõ. A második utasítássor a megnyitott dokumentum nevét írja az A5-ös cellába. Az eljárás végrehajtása után az aktuális munkalap celláiban az rajzának megfelelõ adatokat olvashatjuk. Ez az út oda-vissza járható. Ez azt jelenti, hogy írhatunk olyan eljárást is, amelyik az Excel-ben készült és az Excel-bõl visz át adatokat a szövegszerkesztõbe. Természetesen lehetõségünk van arra is, hogy a szövegszerkesztõben írunk egy eljárást, ami képes mindkét irányban adatot mozgatni. Word formázás Ha tudunk hivatkoni egy létezõ dokumentumra, akár meg is formázhatjuk a szövegét, még Excelbõl is.

Word szöveg formázása Excel makróval w Egy érdekes megoldás lehet az is, hogy a szövegszerkesztõ dokumentumában tárolt szövegeket az Excelben írt eljárás segítségével formázzuk meg. Az eljárás elindítása elõtt be kell tölteni a kiszolgáló programot. Ez jelen esetben a Word. A módosítandó dokumentumot nem kell és nem is szabad megnyitnunk. Ezt majd elvégzi az eljárás. Nézzünk erre is egy példát, használjuk fel az elõzõ feladatban létrehozott szöveg dokumentumot: Sub WordDokFormatum() Dim docWord As Word.Document Const BYT_WORD_HEADING_1 = -2 Const BYT_WORD_HEADING_2 = -3 Const BYT_WORD_HEADING_3 = -67 Const STR_WORD_DOC As String = "C:\Get.doc" Const STR_OBJECT_TYPE As String = "Word.document" Set docWord = GetObject(STR_WORD_DOC, STR_OBJECT_TYPE) docWord.Paragraphs(1).Style = (BYT_WORD_HEADING_1) docWord.Paragraphs(2).Style = (BYT_WORD_HEADING_2) docWord.Paragraphs(3).Style = (BYT_WORD_HEADING_3) End Sub

Az elõzõ eljáráshoz hasonlóan a módosítandó dokumentumhoz a GetObject függvénnyel férünk hozzá. A következõ három sorban az egymás után következõ bekezdéseket formázzuk meg a Word stílusaival. Itt érdemes megemlíteni az eljárás elején deklarált állandókat. Ezek a nevét és

246



18. fejezet


értékét a szemléltetés kedvéért a Word súgójából vettük. Vagyis a Word stílusait számokkal is meghatározhatjuk. A stílusokat a nevükkel is megadhattuk volna: docWord.Paragraphs(1).Style = (BYT_WORD_HEADING_1) docWord.Paragraphs(2).Style = (BYT_WORD_HEADING_2) docWord.Paragraphs(3).Style = (BYT_WORD_HEADING_3)

A Style zárójelei közé szövegállandóként beírhatjuk a stílus nevét is. Ennek az a szépséghibája, hogy a magyar Word esetén a magyar neveket kell írnunk, az angol esetén pedig az angol neveket. Emiatt az eljárás a programban szereplõ eltérõ stílusnevek miatt nem fut mindegyik nyelvi változatban. Vágólap használata makróból w A Windows egyik nagyon hasznos szolgáltatása a vágólap. Ez az eszköz nagy segítséget jelent akkor, ha valamelyik alkalmazásból adatot szeretnénk átadni egy másik alkalmazás dokumentuma számára. A következõ példa elõkészítését Excelbõl kezdjük. Egy egyszerû táblázatot készítsünk az egyik munkalapra. Ezt a táblázatot automatikus formázással formázzuk meg. Ezt a táblázatot juttassuk át egy Word dokumentumba, majd a dokumentumot mentsük el egy tetszõleges mappába. A Word dokumentum címe legyen azonos az elkészített munkalap nevével és ezt formázzuk meg Címsor 1 stílussal. A táblázat a következõképpen nézzen ki:

79. ábra: A feladatot Excelben oldjuk meg, egy eljárás megírásával. Íme az eljárás:

247


Vágólap Ez a Windows eszköze, de mivel használják az Office alklamazások ehhez is hozzáférhetünk.



Copy A kijelölt adatot a vágólapra másolja

Paste A vágólap adatát a kijelölt helyre leteszi.

4. rész

Sub WordbeMásol() Dim appWord As Word.Application Dim varFájlNeve As Variant Dim strLapNeve As String Const STR_OBJ_TIPUS As String = "Word.Application" Const STR_TITLE As String = "Másolás a Wordbe" Const STR_PROMPT As String = "Mi legyen a Word fájl neve?" Const STR_PATH_FILE As String = "C:\" Const STR_FAJL_TIPUS As String = ".doc" strLapNeve = ActiveSheet.Name varFájlNeve = Application.InputBox(STR_PROMPT, STR_TITLE, _ strLapNeve) If varFájlNeve <> False Then varFájlNeve = STR_PATH_FILE & varFájlNeve & STR_FAJL_TIPUS Set appWord = CreateObject(STR_OBJ_TIPUS) Selection.CurrentRegion.Copy With appWord .Documents.Add With .Selection .typetext ActiveSheet.Name .paragraphs(1).Style = -2 .typeparagraph .typeparagraph .Paste End With .ActiveDocument.SaveAs Filename:=varFájlNeve .Quit End With Application.CutCopyMode = False End If End Sub

Tehát a program elsõ sorai most is a deklarációkat tartalmazzák. Itt állandók és változók meghatározására került sor. Azt, hogy melyiket mire használjuk, majd a programsorok ismertetésekor említjük meg. strLapNeve = ActiveSheet.Name

A másolás elõtt tároljuk az aktuális munkalap nevét. Erre a fájl mentésekor lesz szükségünk. Ez lesz az a név, amit a program alapértelmezésként felkínál a Word dokumentum mentéséhez. Vagyis, ha nem változtatunk rajta, akkor ez lesz a Word fájl neve. Azért választottuk a Variant adattípust, mert az InputBox Mégse gombjára kattinva logikai értéket

248



18. fejezet


kapunk vissza, míg, ha beírunk egy fájl nevet, akkor szöveget. Ez a váltotótípus alklamaz mindét adattípus fogadására. varFájlNeve = Application.InputBox(STR_PROMPT, STR_TITLE, _ strLapNeve)

Az InputBox függvény az eljárás futása közben megkérdezi, mi legyen az elkészült dokumentum neve. Itt tetszõleges elnevezést adhatunk meg. Alapértelmezésként az aktív Excel munkalap nevét kínálja fel a program. Ennek az utasítássornak az eredményeként megjelenik egy párbeszédpanel, amiben megadhatjuk a Word fájl nevét. Létezik egy másik InputBox függvény is. Ez a VBE függvénye. Most az Excel függvényét használjuk, ezért írtuk elé az Application objektum nevét. Ha az OK gombra kattintunk, akkor a szerkesztõdobozba írt szöveget adja vissza a függvény, ha pedig a Mégse gombra, akkor logikai HAMIS érték a függvény eredménye. If varFájlNeve <> False Then Utasítások ... End If

Az InputBox függvény eredményétõl függõen lépünk tovább. Ha nem a Mégse gombra kattintott a felhasználó, akkor létrehozzuk a Word dokumentumot, adatokat írunk bele majd kilépünk az eljárásból. Ha a Mégse gombot választja a felhasználó, akkor kihagyjuk az If és End If közötti utasításokat és kilépünk az eljárásból. varFájlNeve = STR_PATH_FILE & varFájlNeve & STR_FAJL_TIPUS

A fájl nevét most már teljes hosszában létrehozzuk. Ebbe beletartozik az elérési útvonal is és a fájl kiterjesztése is. Figyeljünk arra, hogy az eljárás elején deklarált állandók tartalmazzák a megfelelõ adatokat. Az STR_ PATH_ FILE meghatározásához azt az útvonal nevet kell meghatároznunk, ami a gépünkön létezik, különben az eljárás nem fog mûködni. A fájl típusa minden esetben .doc legyen. Ne felejtsük ki a doc szó elõl a pontot! Set appWord = CreateObject(STR_OBJ_TIPUS)

Nevezzük el a Word alkalmazást appWord névvel, és hozzuk létre az objektumot a CrateObject függvény segítségével. Selection.CurrentRegion.Copy

249




4. rész

Az aktuális kijelölés környezetében található adattartományt másoljuk a vágólapra ennek a sornak a segítségével. Figyeljünk arra, hogy az eljárás indítása elõtt álljunk az adattartomány egyik cellájára, így az Excel felismeri az aktuális régiót. With appWord

Ettõl a sortól kezdve minden tulajdonság elé oda kell képzelnünk az appWord objektumot, ami ponttal kezdõdik. Vagyis ha szeretnénk a Wordben elkezdeni egy üres dokumentumot, akkor a következõ utasítást kell kiadnunk: .documents.Add

Ha nem írtuk volna a programba a With appWord sort akkor ezt a sort a következõ módon kellett volna leírnunk: appWord.documents.Add

Ezt minden alkalommal meg kellett volna ismételnünk amikor a Word-del végzünk mûveletet. A továbbiakban az érthetõség kedvéért a With részben meghatározott objektumokat dõlt betûvel szedjük az elemzés során, amint ez az elõzõ mintában látszik. With appWord.Selection

Ettõl a sortól kezdve a Selection elé odaképzelve az appWord objektum hivatkozást minden ponttal kezdõdõ sor elé oda kell gondolnunk a appWord.Selection objektumot. appWord.Selection.typetext ActiveSheet.Name

A létrehozott Word dokumentumba beírjuk az aktív munkalap nevét, mégpedig arra a helyre ahol a szövegkurzor áll. Mivel a dokumentum új, ezért erre csak egy lehetõségünk van, mégpedig az elsõ bekezdés. appWord.Selection.paragraphs(1).Style = -2

A beírt szöveget tartalmazó bekezdést megformázzuk Címsor 1 stílusúra. Ezt a formázást azon a bekezdésen állítjuk be, amelyikben a szövegkurzor áll. Még mindig csak ez az egy bekezdésünk van, így nem ronthatjuk el. appWord.Selection.typeparagraph

250



18. fejezet


appWord.Selection.typeparagraph

A következõ két sor ugyanazt eredményezi mint amikor a Word-ben egy-egy bekezdés befejeztével az ENTER billentyût leütjük, vagyis új bekezdéseket kezdünk a címsor után. appWord.Selection.Paste

Most érkezett el annak az ideje, hogy a vágólapra másolt táblázatot beszúrjuk a Word dokumentumba. Ez ugyanaz a mûvelet, mint amikor a hétköznapi munkánk során végrehajtjuk a Szerkesztés (Edit) Ø Beillesztés (Paste) utasítást. Vagyis a vágólap tartalma a szövegünkbe kerül, mégpedig arra a helyre, ahol a szövegkurzor áll (appWord.Selection). End With

A továbbiakban már érvényét veszíti a Selection objektum. Innentõl kezdve csak az appWord marad érvényben, vagyis ha egy tulajdonság elõtt pontot találunk, akkor ezentúl az már csak a Word alkalmazás objektumot jelenti. appWord.activedocument.SaveAs FileName:=FájlNeve

Mentsük el a szöveget! Erre használjuk a Word objektum SaveAs metódusát. A metódusnak egyetlen paraméterét adjuk meg, ami a fájl neve és elérési útvonala. Ezt korábban tároltuk a FájlNeve változóban még az InputBox függvény segítségével. appWord.Quit

Lezárjuk a szövegszerkesztõt. Az egész eljárás alatt nem jelent meg a szövegszerkesztõ, de ez nem azt jelenti, hogy nem töltõdött be, csak a Visible tulajdonság False értéke miatt nem látszott. Ha szeretnénk látni futás közben, akkor az If... End If utasítások között a CreateObject függvény mögötti helyre valahova írjuk be a következõ utasítássort: appWord.Visible = True

Az eljárást írjuk meg, majd futtassuk le. A megadott Word fájlt nyissuk meg és nézzük meg az eredményt. A további alkalmazásokkal hasonló módszerekkel cserélhetünk adatokat. A feladatunk csak annyi, hogy meg kell ismernünk a többi alkalmazás objektumait. Egyszerûsítheti az ismerkedést, ha átlépünk a kívánt alkalmazásba és az ott felvétellel rögzített eljárásokat kiele-

251




4. rész

mezzük. A felvétel eredményébõl átvehetjük azokat a részleteket amelyeket szükségesnek ítélünk. Amikor egy alkalmazás objektumaira hivatkozunk, a kiindulás minden esetben az Application objektum. Ezt helyettesíti az általunk használt objektum elnevezés. Mi a feladatban erre használtuk az appWord változót.

Összegezve Biztosítanunk kell, hogy a külsõ objektumot elérjük a programból. Ezt vagy úgy érhatjük el, hogy a Visual Basic Editor Tools Ø References párbeszéd-panelében bekapcsoljuk a használni kívánt objektum hivatkozást vagy a CreateObject függvénnyel. Ha a References beállítással hoztuk létre a kapcsolatot, akkor a New kulcsszóval létre kell hoznuk egy objektum elõfordulást. A CreateObject függvény esetén ezt megteszi maga a függvény. Kész dokumentumok eléréséhez használjuk a GetObject függvényt.

252



Tárgymutató

A Adattípusok _________________________47 Egyéb _____________________________ 49 Boolean __________________________49 Date ____________________________ 49 Variant___________________________ 50 Elnevezéssel _________________________50 Currency _________________________50 Double __________________________50 Integer___________________________ 50 Long ____________________________ 50 Single ___________________________ 50 String ___________________________ 50 Felhasználói _________________________64 Deklarálása ________________________65 Numerikus __________________________47 Byte_____________________________ 48 Currency _________________________48 Double___________________________ 48 Integer ___________________________ 48 Long ____________________________ 48 Single____________________________ 48 Objektum ___________________________ 59 String _____________________________ 48 Hossza ___________________________ 48 Megadása ______________________49 Alapfogalmak Algoritmus __________________________16 Eljárás _____________________________ 21 Események __________________________25 Gyûjtemény__________________________28 Interfész ____________________________ 23 Iteráció _____________________________ 18 Metódusok __________________________25 Program ____________________________ 15 Szekvencia ___________________________ 18 Szelekció ____________________________ 18

Tulajdonságok ________________________24 Tömbváltozó _________________________19 Változók ____________________________ 16 Értékadás ___________________________ 16 Algoritmus __________________________16 Elágazások __________________________95 Assistant __________________________190 Jelölõnégyzet ________________________193 Programozása _______________________190 Választócsoport______________________196 Új ballon __________________________190

B Billentyû-kombinációk ________________235 Bõvítmények ________________________230 Elõkészítése ________________________230 Programozottan ___________________233 Függvény jellemzõk ___________________234

C Commandbars _______________________222 Copy ______________________________ 248 CreateObject _______________________242 Címke _____________________________ 182

D Dinamikus tömb ______________________56 Tömb elemei _________________________56



Tárgymutató

E Eljárás _____________________________ 21 Hatóköre ___________________________ 118 Indítása ____________________________ 161 Lépésenként _______________________161 Létrehozása _________________________44 Paraméteres _________________________74 Indítása __________________________74 Statikus ____________________________ 118 Szerkesztése _________________________161 Törlése _____________________________ 161 Események ___________________________ 25 Helye______________________________ 173 Munkafüzet__________________________175 Munkalap___________________________ 174 On Error __________________________181 OnKey _____________________________ 179 OnTime ____________________________ 178 Paraméterei _________________________174 Visszaadott érték _____________________177 Eszköztár __________________________217 Commandbars_______________________222 Egyedi gomb ________________________218 Programozása _______________________222 Testreszabás _________________________218 Törlése ____________________________ 225 Új ezsköztár_________________________218 Programozással ____________________223 Új gomb___________________________ 220 Programozással ____________________227 Explicit deklarálás ____________________53

F Felhasználói adattípus _________________64 Deklarálása __________________________65 Felhasználói modul ____________________41 Betöltése ___________________________ 43 Elmentése ___________________________ 42 Létrehozása __________________________41 Törlése _____________________________ 43 Felsorolások _________________________68 Deklarálása__________________________69 Elemei _____________________________ 70 Használata __________________________70 Futásidejû hibakezelés________________181 Címke _____________________________ 182 Hiba száma _________________________182 Kilépés az eljárásból ___________________183 On Error Go To ______________________181 Visszatérés__________________________182

Függvények_________________________116 Használata __________________________117 Munkalapokon _____________________117

G GetObject _________________________245 Gyûjtemény __________________________28 Bõvítése ____________________________ 62 Egy eleme ___________________________ 29 Elemének eltávolítása ___________________63 Elemének megváltoztatása _______________64 Létrehozása __________________________61 Minden eleme ________________________29 Tulajdonságai, metódusai ________________61

H Hatókör ____________________________ 73 Eljárás _____________________________ 73 Modul _____________________________ 80 Projekt _____________________________ 81

I Implicit deklaráció ____________________52 Interfész ____________________________ 23 Iteráció ________________________18,103

K Kilépés az eljárásból _________________183 Konkatenáció ________________________89

L Like ________________________________ 89 Helyettesítõ karakterek _________________89

M Makró panel________________________161 Makró rögzítés _____________________157 Elõkészítése _________________________158 Indítása ____________________________ 161 Jellemzõk meghatározása ________________158 Rögzítés vége _______________________160 Szerkesztése _________________________161 Törlése _____________________________ 161 helye ______________________________ 159



Tárgymutató Ebben a munkafüzetben ______________160 Egyéni makró munkafüzet _____________159 Új munkafüzet _____________________160 indítása ____________________________ 159 Lépésenként _______________________161 Me________________________________ 201 Menü ______________________________ 217 Commandbars_______________________222 Egyedi gomb ________________________218 Programozással ____________________227 Programozása _______________________222 Testreszabás _________________________218 Új almenü __________________________221 Új menüpont _______________________220 Programozással ___________________224 Menüpontok ________________________225 Törlése ____________________________ 227 MsgBox függvény____________________188 Válasza ____________________________ 189 Munkafüzet Események __________________________175 Munkalap Események __________________________174 Mûveleti jelek ________________________87 Logikai _____________________________ 93 Matematikai__________________________87 Mûveletvégzés sorrendje ________________88 Szöveges ___________________________ 89

N New ______________________________ 240

O Objektum változók ____________________59 Objektum-elõfordulás _________________25 Létrehozása __________________________61 Objektummodul ______________________40 Objektumok _________________________24 Office objektumok ___________________243 Office segéd ________________________190 Jelölõnégyzet ________________________193 Programozása _______________________190 Választócsoport______________________196 Új ballon __________________________190 Operátorok _________________________87 Aritmetikai __________________________87 Logikai _____________________________ 93 Prioritása ___________________________ 88 Szövegkezelõ_________________________89 Like _____________________________ 89 Összehasonlító _______________________92

Option Explicit_______________________53 Beállítása ___________________________ 53

P Paraméter ___________________________ 74 Opcionális __________________________76 Tömbparaméter _______________________77 Értékadás ___________________________ 76 Paste______________________________ 248 Personal.xls ________________________159 Program ____________________________ 15 Moduláris __________________________22 Struktúrált __________________________21 Programhibák ________________________53 Szemantikai __________________________53 Programozott adatátadás_____________244 Projekt _____________________________ 40 Jelszavas védelme _____________________232 Párbeszédpanelek____________________199 Indítása ___________________________ 202 Létrehozása _________________________199 Vezérlések __________________________199 ComboBox _______________________207 Programból____________________209 CommandButton __________________200 Elnevezése _______________________203 Események________________________201 Kiválasztása ____________________204 Kombinált lista ____________________207 ListBox __________________________212 Listapanel ________________________212 Választócsoport _________________215 Parancsgomb _____________________200 TextBox _________________________206 Programozva___________________206 Tulajdonságok ____________________200



Tárgymutató

R References _________________________240

S Szekvencia___________________________ 18 Szelekció _________________________18,95 Szubrutinok _____________________74,116 Szövegállandó ________________________29 Szövegösszevonás _____________________89

T Testreszabás ________________________218 Eszköztár___________________________ 218 Menü _____________________________ 218 Tömbváltozó _________________________19 Deklarálása__________________________54 Dinamikus ___________________________ 56 Lásd: Dinamikus tömb Kezdõ eleme _________________________55 Tömbök deklarálása ___________________54 Törlése ____________________________ 225

U User form __________________________199 Indítása ___________________________ 202 Me _______________________________ 201 Vezérlések __________________________199 ComboBox _______________________207 Programból____________________209 CommandButton __________________200 Elnevezése _______________________203 Események________________________201 Kiválasztása ____________________204 Kombinált lista ____________________207 ListBox __________________________212 Listapanel ________________________212 Választócsoport _________________215 TextBox _________________________206 Programozva___________________206 Tulajdonságok ____________________200

V

Immediate window _____________________43 Locals window _______________________44 Tulajdonság ablak _____________________43 Watch window _______________________44 Vezérlõ utasítások Do... Loop _________________________110 Alkalmazása________________________112 Elõltestzetlõ _______________________111 Hátultesztelõ ______________________112 For Each __________________________108 For.... Next ________________________103 Alkalmazása _______________________104 Több dimenziós tömb _____________106 Vektor feldolgozása ______________104 Mûködése ________________________104 If Then _____________________________ 95 Alkalmazása ________________________97 Egysoros _________________________96 Több feltétel vizsgálata _______________96 Többsoros ________________________96 Select Case__________________________99 Alkalmazása _______________________101 Kisebb vagy nagyobb _______________100 Több érté ________________________100 Értékhatár _______________________100 Visual Basic Editor ___________________39 Figyelés ablak ________________________44 Helyi ablak__________________________44 Immediate window _____________________43 Locals window _______________________44 Próba ablak _________________________43 Tulajdonság ablak _____________________43 Watch window _______________________44 Visual Basic felsorolásai _______________69 Vágólap programozása________________247 Változók _________________________16,47 Adattípusa __________________________47 Lásd még: Adattípusok Deklarálása__________________________52 Explicit ___________________________ 53 Implicit ___________________________ 52 Eljárás szintû_________________________73 Elnevezése ___________________________ 51 Prefix ____________________________ 51 Szabályai __________________________51 Modul szintû ________________________80 Lásd: Paraméter ______________________74 Projekt szintû ________________________81 Speciális ____________________________ 59 Statikus ____________________________ 83

VBE ________________________________ 39 Figyelés ablak ________________________44 Helyi ablak__________________________44



Tárgymutató

W With... End With ____________________166 Word formázás ______________________246 Word.Application ___________________240 Word.Document _____________________244

X XlStart mappa ______________________159

O objektumok Elnevezése __________________________59 Események __________________________25 Metódusok __________________________25 Rendszere___________________________ 28 Tulajdonságok ________________________24 elõfordulás __________________________25 jellemzõi ____________________________ 24 keletkezése __________________________25

A Állandók ____________________________ 67 Deklarálása __________________________67

E Értékadás ________________________16,85 Paraméter ___________________________ 76


Tartalomjegyzék. Alapfogalmak

Recommend Documents