kovalcsik géza_az excel programozása

Amikor 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 ment- jük el, nyomtatjuk ki, vagy Word-ben az aktív bekezdés jel- lemzı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.

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

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 áll- nak. A Word-öt szemlélve hasonló rendszert fedezhetünk fel. A Word alkal- mazá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: Appli- cation. 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 ese- té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

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.

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 mun- kafü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, melyek- né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. Azt, hogy hogyan hivatkozhatunk a győjtemények összes elemére egyszerre, vagy az összes közül egyre.

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 munka- lapjainak 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.

Neve = Worksheets.Item(l) .Name Neve = Worksheets.Item("Munkai") .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 el- sı 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ı munkalap- jának nevét írja a Neve változóba. Itt a munkalap helye a meghatározó. A második parancssor a Munkai nevő munkalap nevét tárolja. A második hivatkozás esetén mindegy, hogy a munkafüzetben fizikailag hol találha- tó a Munkai nevő munkalap. Legyen bárhol, a munkafüzetben, elvégez- hetjü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. Ilyen- kor nem kell beírnunk az Item tulajdonság nevét. Az elızı két parancs te- hát a következı írásmóddal is teljesen helytálló:

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

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ás- mó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 (Work- sheet) 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ıtbb ismertetett módszerek egyikével. Helyesen tehát például így:

Worksheets(1).Name = "Számlák"

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.

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

Range( " A l " ) = "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 tarto- mány - Excelben használatos - hivatkozását szövegállandóként. A kiadott parancs hatására az éppen aktív munkalap Al-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 A2-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( " A l " ) = "Excel "

Ez a parancssor annyiban tér el az elızıtói, hogy itt meghatároztuk azt a munkalapot is, amelyik Al-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 meg- hatá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:

Wo rkshee ts (2 ).R an ge( " A l " ) = "Exce l "

Most írjuk be az Excel szót a Munkafüzet 2 - éppen nem aktív-munka- fü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("Al") = "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:

Wo r kbo o ks (2 ) . Wo rk sh eet s ( 2 ) .R an ge( " A l " ) = "Exce l "

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

Workbooks("Munkafüzet2").Worksheets("Munkai") .Range("Al") = "Excel"

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

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.

Ezt szemlélteti a 36-37. oldalakon található 4. és 5. ábra. A rajz téglalap- jai olyan objektumokat jelölnek, amelyeket győjteményként érhetünk el, az ellipszisek pedig olyanokat, amelyeket egyszerő objektumként. Itt fel- fedezhetjü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 egysze- rően a nevükkel hivatkozhatunk. A nevük után, ponttal elválasztva beír- hatjuk 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 viszo- nyulnak egymáshoz. Láthatjuk azt, amirıl eddig olvastunk, hogy az al- kalmazá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 objek- tumdiagramot jól felhasználhatjuk a programozási feladatok megoldása közben.

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 se- gí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 folyamata-

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.

Ha átkapcsolunk a Visual Basic Editor felületre, akkor a mun- kafü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, amikre 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:

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

AVBE egy önálló program, amit minden Office alkalmazásból elindítha- tunk. 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 44. 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 (tulajdon- ság) ablak látható. Kezdjük tehát az ismerkedést ezekkel!

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.

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 45. oldal 7. ábra)

1. Kattintsunk kettıt a Munkafüzet l-es munkafüzet Munkal-es objek- tumá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ódsze- rekkel írhatjuk meg eljárásainkat, programjainkat. Egy megnyitott modult a modul ablak jobb felsı sarkában található x-szel tehetünk láthatat- lanná, így nem lezárjuk, csak elrejtjük.

A programozás során szükségünk lehet további modu- lokra, 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 46. oldal 8. ábrája.

1. A Projekt ablakban jelöljük ki annak a projektnek bármely objektu- mát, amelybe az új modult szeretnénk létrehozni.

2. Hajtsuk végre az Insert > Modulé parancsot! 3. Az új modul megjelenik a projekt ablakban is és az editorban is.

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 mun- kafüzettel együtt kerülnek mentésre.

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.

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 munka- füzet elmentése nélkül is tárolhatjuk a kiválasztott modult a háttértáro- ló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-

jektból a másikba juttathatjuk moduljainkat és a bennük lévı programjainkat.

Az importálással külsı modult tölthetünk be. Apro- jekt 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ölt- sük be. A modul betöltésével együtt a benne megírt eljárásokat is betöltöt- tük, így az újabb projektben (dokumentumban) már nem kell megírnunk ezeket az eljárásokat.

Ha valamilyen okból feleslegessé válik egy általunk létre- hozott modul, akkor azt törölhetjük a projektbıl. Ismét az egér jobb gomb- jának vesszük hasznát. A helyi menüben megtaláljuk a Remove XXX uta- sítást. Egy modul eltávolításakor megjelenik egy kérdés az esetleges men- tésre vonatkozóan. Itt eldönthetjük, hogy más projektek részére félre- tesszü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ít- hetjük meg az Excel objektumokhoz rendelt osztálymodulokat.

A projekt segédablak alatt találunk egy másik ablakot. Ez a Properties window, magyarul tulajdonság ablak. Amint a projekt ablakban megváltoz- tatunk 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.

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.

Ez a segédablak alapértelmezésben nincs bekapcsolva. Ahhoz, hogy megjelenítsük, válasszuk ki a View > Immediate

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 ki- adhatunk 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.

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.

Ennek az ablaknak a szerepe egy kisit ha- sonlít a Locals Window-hoz, azzal a különbséggel, hogy itt meghatároz- hatjuk, hogy mely változókat és kifejezéseket szeretnénk figyelni. Bekap- csolni a View > Watch window utasítással lehet.

Bármely segédablakot a jobb felsı sarokban található x-szel zárha- tunk be. Egyelıre elégedjünk meg ennyivel, de a késıbbiekben részlete- sen elolvashatjuk a felsorolt segédablakok használatát.

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, mi- közben programot írunk egy modulba.

Egy üres munkafüzetbe készítsük el elsı eljárásunkat - ennek kap- csá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 „Hello világ" program. Ettıl most se térjünk el. Az éppen aktív munkalap Al-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 > Modulé uta- sí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.

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.

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.

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 Al-es celláját (10. ábra).

Az eljárás elindításának másik módja, hogy a szövegkurzorral beál- lunk 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 so- rán fogjuk részletesebben megismerni.

A munkafüzet programozási oldalról nézve Project. Ez a programozás legnagyobb egysége. A projektben találjuk azokat a modulokat, ahova programokat írhatunk. A projektbe 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 Pro- ject 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észle- tesen olvashatunk a program finomítása fejezetben.

Már megbeszéltük, hogy a programozás célja az adatfeldolgo- zá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:

♦ Milyen adattípusokat kezel a Visual Basic for Application? ♦ Mit jelent a változók deklarálása? ♦ Hogyan határozzuk meg a változókat?

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ıikben tekintsük át, hogy melyik adattí- pus mekkora helyet foglal az operatív tárból és milyen, mekkora értéke- ket í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.

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 felhasz- ná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

a változó számára, annál kisebb értékek férnek el 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 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.

A String adattípusú változókban szöveges adatokat - karakterlánco- kat - 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. Eb- ben 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-

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

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 szeret- nénk adni. Nézzük meg azt az utasítást, amelyben a strNeve változónak értéket adunk:

strNeve = "Kovalcsik"

A programban használt logikai kifejezések eredményét logikai változók- ban 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 adat- típusokra, melyek ezt lehetóVé teszik.

A logikai változók csak kétféle értéket vehetnek fel. Lo- gikai 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:

Dim bolValasz As Boolean

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ı:

Dim datFizetesiDatum As Date

Elıfordulhat, hogy elıre nem tudjuk, hogy mi lesz az adat tí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ároz- zuk meg a változó típusát, az Variant lesz. Tehát ezt az adattípust kétféle- képpen is meghatározhatjuk. A következı két típus meghatározás eredmé- nye azonos:

Dim varVegyes_l Dim varVegyes_2 As Variant

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álhat- juk egy olyan változó esetén, amelyet típus meghatározó karakterrel fejez- tü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övet- kezı 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.

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.

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 lefoglal- tunk. A lefoglalt helyre a változó nevével hivatkozunk.

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:

♦ A változó neve nem lehet hosszabb mint 255 karakter. ♦ Az elsı karakternek betőnek kell lennie. ♦ A változó neve nem tartalmazhat pontot, szóközt; és a !, @, #, &, % és $

karakterek csak a változónév végén szerepelhetnek (ha így határozzuk meg a típust). ♦ A változók neve nem lehet a Visual Basic nyelvben használt egyik kulcs-

szó 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 felhasz- ná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 meg- hatá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:

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 olvas- hatóságát.

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.

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álto- zó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()

Szam = 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álto- zó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ál- tozót, aminek a neve Szam lesz, és rögtön meg is növeli annak értékét

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.

A programozás során elkövethetı hibákat két cso-

portba 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.

Ö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áb- ban 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étreho- zott 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övet- kezı lesz:

Option Explicit

Sub ErtekBekerese() Dim intSzam As Integer intSzam = 18

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 dek- lará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.

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.

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 hasz- náltunk már tömb változókat, amikor egy változó mellé indexet írtunk (például Xi, X2, X3...). A tömb ugyanezt a célt szolgálja a programban. Per- sze az index lehet összetett is - vagy másként: több dimenziós - (például:

Xi,i, Xi,2, X24, X2,2 ....)• A tömb deklarálására a következı utasítást hasz- náljuk:

Dim intSzam(4) As Integer Dim strNevek(lO) 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 Expli- cit 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:

Option Explicit Option Base 1

Sub Nevek() Dim strNevek(3) As String

strNevek(l) = "Kiss"

strNevek(2) = "Nagy"

strNevek(3) = "Vass" End Sub

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_l(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.

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 megad- nunk 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

Mikor határozzuk meg az elemek számát? Mindenképpen azelıtt, mie- lı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övet- kezı lépésben, - Sheets.Count paranccsal - megszámoltuk az aktív mun- kafüzet lapjait. Az eredményt futás közben felhasználtuk a tömb elem- szá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üze- tek 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 el- veszí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 kulcs- szó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 vet- tük a tömböt. A korábban tárolt értékek megmaradnak, csak azok vesz- nek el, amelyeket a rövidítés miatt elhagytunk.

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.

Ebben 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ál- tozó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álto- zó 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:

♦ 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?

Megtanultuk, hogy a változók olyan memóriaterületek, melyekben külön- fé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álto- zó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üzetl- elsı munkalapján található Al-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:

Workbooks("Munkafüzetl").Worksheets("Munka1").Range ("Al") = ("Excel")

Ha ezzel a tartománnyal, cellával több mőveletet is el kellene végez- nü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övetke- zı módon tehetjük:

Dim objAl As Object Set objAl = Workbooks("Munkafüzetl").Worksheets("Munkai").Range("Al")

Vegyük észre a Set kulcsszót! Ez egy lényeges eltérés a korábbi érték- adó utasításokhoz képest. Igaz, hogy ez így két programsort eredménye- zett, de cserébe ezek után az így létrehozott névvel hivatkozhatunk a Munkafüzetl munkafüzet elsı munkalapján található Al-es cellára. A le- rövidített hivatkozást így használhatjuk:

objAl = "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 rngAl 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 tu- lajdonsá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 tar- tomá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.

A Visual Basic-ben van egy Collection, - győjtemény - osztály. Ennek se- gítségével létrehozhatjuk saját győjteményeinket. A létrehozott győjte- mé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 alap- vetı mővelete van. Ezeket szinte mindegyik győjteménynél megtaláljuk. Ezek a következık:

♦ A Count tulajdonságból megtudhatjuk, hogy hány eleme van a győjte- ménynek.

♦ Az Add metódussal új elemet vehetünk fel a győjteménybe. ♦ ARemove metódust használva eltávolíthatjuk a győjtemény egy felesle-

gessé vált elemét. ♦ Az Item metódus segítségével a győjtemény egy elemére hivatkozha-

tunk. ♦ 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.

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ıfor- dulá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 ugyan az lesz, mint az elızı két parancs eredménye.

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áro- lunk ebben is. Nézzük meg, hogyan lehet felvenni új elemet a győjtemény- be. Használjuk az Add metódust!

Sub Dolgozok() Dim colEgyedi As New Collection

colEgyedi.Add "Kiss", "Fonok"

colEgyedi.Add "Nagy", "Helyettes"

colEgyedi.Add "Vass", "Titkár"

colEgyedi.Add "Kosa", "Eloado_l"

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 Győjtemény nevő általános modult. Vegyük szem- ügyre az eljárás parancsait. Az elsı sorban létrehoztuk a colEgyedi objektum-elıfordulást.

A következı öt sorban ugyanazt a mőveletet hajtjuk végre. Új eleme-

ket 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

Basic. Amint leütjük a szóközt az Add metódus után, megjelenik a para- méterek felsorolása (12. ábra).

Nézzük meg, hogy melyik paraméternek mi a feladata.

♦ Az Item helyére kell beírnunk azt az értéket, amit tárolni szeretnénk a győjtemény adott elemében. ♦ A Key paraméter egy szöveg típusú adatot vár. Ezzel az értékkel hivat-

kozhatunk majd a győjtemény most felvett elemére. A kulcsba írt érték nem ismétlıdhet. ♦ ABefore paraméterrel határozhatjuk meg azt, hogy a győjtemény új ele-

me 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. ♦ 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ölte- ni, 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")

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 mu- tatjuk 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", "Titkár" colEgyedi.Add "Kosa", "Eloado_l" colEgyedi.Add "Sás", "Eloado_2" MsgBox colEgyedi.Count colEgyedi.Remove "Titkár" MsgBox colEgyedi.Count

End Sub

Az eljárás eleje egyezik az elızıvel, mindaddig, amíg felvesszük a győj- temé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.

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 el- távolítotté. Tehát, ha új titkár lép be a céghez, — a neve legye mondjuk Ko- vá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", "Titkár" colEgyedi.Add "Kosa", "Eloado_l" colEgyedi.Add "Sás", "Eloado 2" MsgBox colEgyedi("Titkár") colEgyedi .Remove "Titkár" colEgyedi .Add "Kovács", "Titkár" MsgBox colEgyedi("Titkár")

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 kul- csok nem ismétlıdhetnek, egyedinek kell lenniük.

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-

lalhat. Ennek nagy hasznát vehetjük a listába szerkesztett adatok feldol- gozá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

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árolha- tunk. Nézzük meg a felhasználói típus használatát:

Sub DolgAdatO

Dim Alkalm As Dolgozok

Alkalm. VezNev = "Kiss"

Alkalm. KerNev = "Béla"

Alkalm.Belep = #l/l/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.

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 hasz- ná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ál- tozókat. A győjtemények több lehetıséget biztosítanak a program írása során. Rugalmasabban kezelhetık, mint a tömbváltozók.

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.

Sok 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 fel- használónak, akkor minden esetben ugyanannak a szöveg- nek 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áltoz- nak. A programban használt állandókat úgyis megadhatjuk, hogy dekla- rá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ıit:

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

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 megjele- níteni a programban.

Const STR_UZENET = "Nincs ilyen munkalap!"

Az állandó deklarálása magában 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 ál- landó Variant adattípusú lesz. Ez több helyet foglal, mintha meghatároz- nánk a valódi típusát. A következı utasítássorban meghatározzuk az ál- landó adattípusát is.

Const INT LÉPESEK 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.

A felsorolás megértéséhez vizsgáljuk meg az MsgBox utasítást. Ez az uta- sí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ér- jünk át a Visual Basic Editor-ba. Hozzunk létre egy új modult, és írjuk be a következı eljárást:

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.

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 tartalmaz- zon, í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 vblnformation, 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 fel- sorolá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 meg- határoznunk úgy, ahogy ez a következı példában olvasható:

Enum HetNap hetfo kedd szerda csütörtök péntek szombat vasárnap

End Enum

A felsorolás meghatározását eljáráson kívülre, a modul elejére kell ír- nunk. 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 vasárnap é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él- teti a következı meghatározás:

Enum HetNap_2 hetfo = 1 kedd = 2 szerda = 3 csütörtök = 4 péntek = 5 szombat = 6 vasárnap = -1287

End Enum

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 felsoro- lást, majd egy eljárásban vegyük használatba. Ennek a lépéseit mutatja be a 16. ábra, amelyek a következıit:

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.

Az elkészült programot úgy indíthatjuk el, hogy beállunk az elkészült el-

járásba és végrehajtjuk a VBE Run > Run Sub/UserForm utasítását. En- nek 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.

Azokat az értékeket, amelyeket nem fogunk megváltoztatni a program fu- tá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 megjegyez- nünk azt, hogy milyen számértéket vár a program.

A változókat és állandókat valamilyen eszközzel el kell vá- lasztanunk egymástól. Nem lenne jó, ha egy adott eljárás- hoz 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ároz- tuk. 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. Aprojekt minden moduljában használható változókat globális válto- zóknak nevezzük. Ezeknek a változóknak a projekt összes moduljában ér- téket adhatunk, és bármelyikben kiolvashatjuk tartalmukat. Mivel egy Visual Basic projekt többféle modult tartalmaz, fontos különbséget ten- nünk a modulok típusai között. A változók - hatókör szempontjából - más- ként viselkednek egy osztálymodulban, mint egy általános modulban. A fejezetben a következı kérdésekre keressük a választ:

♦ Mitıl függ egy változó hatóköre? ♦ Hogyan deklarálhatunk eljárás szintő változókat? ♦ Milyen hatással van a modul a változó hatókörére?

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 üt- közni egymással. A hatókör kérdését a gyakorlatban vizsgáljuk meg! Tölt- sü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.

Dim strNeve As String strNeve = „Kiss"

End Sub

Sub Kor_2() strNeve = „Nagy"

End Sub

AKor_l eljárás hibajelzés nélkül lefut, hiszen a második sorban egy el- já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 hi- baü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 dek- lará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_l-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!

De mit kell tennünk akkor, ha egy eljárás szintő változónak egy másik el- já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álto- zók meghatározásával. Zárjuk le az elızı példa kedvéért létrehozott mun- kafüzetet, és nyissunk egy újat az új példa miatt. Hozzunk létre egy álta- lános modult, és írjuk bele a következı eljárást!

Sub Összeadó(sngSzam_l 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_l + sngSzam_2 MsgBox STR_EREDMENY & dblEredmeny, vblnformation, 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 dekla- rált változóknak értéket kell adni, és ezt csak akkor tehetjük meg, amikor

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 Számolás ()

Összeadó 12, 45 End Sub

Elemezzük a programot! A Számolás eljárás meghívja az Összeadó el- járást. Amikor meghívja, értéket ad a két változónak, amiket a zárójelek között deklaráltunk. Tehát, amikor az Összeadó 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ég- rehajtja a meghívott eljárást, visszatér abba az eljárásba, amelyik meg- hívta ıt.

Az Összeadó 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.

Ejtsünk néhány szót a paraméterek megadásáról! A 79. oldal 17. áb- rá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 ne- vét, és kettıspont-egyenlıségjellel megadhatjuk a paraméter értékét. Ezt mutatja be a 18. ábra:

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 fel- sorolá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-

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 el- járáson belül lekérdezhetjük, hogy kapott-e értéket a változó az eljárás meghívásakor. Erre az Ismissing(Valtozonev) függvényt használhatjuk.

Oldjunk meg egy egyszerő példát. írjunk egy olyan eljárást, ami a szor- zá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 Szorzás(sngSzorzando As Single, Optional Szorzó = 1) Const STR_EREDMENY As String = "Az szorzás eredmény e: "

Const STR_CIMKE As String = "Szorzás"

Dim dblEredmeny As Double

dblEredmeny = sngSzorzando * Szorzó MsgBox STR_EREDMENY & dblEredmeny, vblnformation, S TR_CIMKE

End Sub

Az eljárást hívjuk meg a korábban megírt Számolás eljárásból. Módo- sítsuk a Számolás eljárást a következıit szerint:

Sub Szamolas_2 () Összeadó sngSzam_2:= 14, sngSzam_l:=25

Szorzás 45 End Sub

Felfedezhetjük, hogy a Szorzás eljárás hívása során a második para- mé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.

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öm- bökhöz. Mindig annyi eleme lesz, ahány elemnek az eljárás hívásakor ér- téket adtunk. A tömbparamétert tartalmazó eljárás hívásakor nem köte- lezı 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

tömbparamétert tartalmazó eljárásban sem, de a híváskor megadott bár- melyik 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 gaz- dasági egység nevének átadására használjunk egy szöveges típusú para- métert. Tegyük fel, hogy azt nem tudjuk elıre, hogy egy adott egységen be- lü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 tar- talmazó 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ív- juk meg, és figyeljük az eredményt. ADolgozok eljárás a következı lesz:

Sub Dolgozok(strSzervezet As String, ParamArray Neve()) ' A z 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 kiirá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.

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övetke- zı 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ügg- vényt használunk. Az LBound függvény eredménye a tömb legkisebb ele- mé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 tar- talmának meghatározásához már felhasználhatjuk a kiszámított ered- mé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 fut- tatást, kapcsoljuk be az Immediate ablakot a View > Immediate Window paranccsal. íme az eljárás:

Sub Dolgozok_hivasa ()

Dolgozok "Kereskedık", "Vass", "Sass", "Kovács", "Soós'

End Sub

Á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 83. 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, is- merkedjünk a lehetıségekkel.

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 ér- téket adhatunk és kiolvashatjuk az értékét. Talán egy technikai dolgot ér- demes megtennünk! Aváltozó típusát jelölı elıtag-karaktereket kibıvíte- ni 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.

Irjunk egy másik eljárást ugyanabba a modulba, amelyikben a válto- zót deklaráltuk és abban ugyanígy adjunk értéket neki. Indítsuk el! Ez hi- bá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 ál- landókat a Private kulcsszóval kellene kezdeni. Ezt elhagyhatjuk, mert a modul szintő változók alapértelmezés szerint csak abban a modulban ér- vényesek, amelyben meghatároztuk azokat. A Private kulcsszót csak eljá- ráson kívül adhatjuk ki.

Private mlngNagySzam As Long

Private Const MINT_SZAM As Integer = 5

Ezzel egyenértékő a következı két sor:

Dim mlngNagySzam As Long Const MINT_SZAM As Integer = 5

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é ír- junk "g" betőt. íme:

Public glngNagySzam As Long Public Const GINT_SZAM As Integer = 5

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ál- junk meg értéket adni nekik több modul eljárásában.

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áthat- tuk, 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álymodul- ban. Az osztálymodul feladata ugyanis az, hogy bezárja a benne deklarált változókat.

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 el- járást, melyben értéket adunk a globális változónak. A megoldást a 21. ábra szemlélteti.

1. A project ablakban kattintsunk kettıt a Munkai 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!

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égre-

hajtá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ál- tozó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ál- toztassuk meg az általános modul eljárását a következı módon:

Sub Szarnia () 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ály- modulban 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 tulaj- donsághoz csak az objektum-interfészen keresztül férhetünk hozzá.

Ha eljárásban deklaráltunk egy változót, az mindaddig megtartja az ér- té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 újra- deklará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álto- zó 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:

Sub Megszámol () Static intSzamlal As Integer intSzamlal = intSzamlal + 1 MsgBox intSzamlal

End Sub

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.

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ír- ni. 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. Acé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.

Már tudjuk, hogy hogyan lehet változókat, állandókat meg- hatá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égrehajta- ni. 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ővele- tekkel, mőveleti jelekkel. Ismét tegyünk fel kérdéseket!

♦ Mit jelent az értékadás? ♦ Milyen mőveleteket hajthatunk végre a tárolt adatokon? ♦ Milyen mőveleti jeleket használhatunk?

Egy-egy változónak adhatunk úgy is értéket, hogy egyszerően egy egyen- lı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. Mindkét esetben érték- adá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álto- zót használtuk, mint a bal oldalon.

intSzamlalo = intSzamlalo + 1

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 bal oldali 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ég- rehajtá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 ér- tékadó utasításokkal. Az objektumokról szóló fejezetben olvashattuk, 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 in- terfé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 A l-es cel- lájába bekerüljön egy adat, akkor a Range("Al") objektum Value tulajdon- ságába kell írnunk az adatot. Például így:

Range("Al").Value = "Hello 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 tulajdon- ságainak pillanatnyi tartalmát. A következı kis eljárás ezt teszi! Kiolvas- sa az épp aktív munkalap Al-es cellájába írt értéket és kiírja az Immedate ablakba.

Sub KiOlvas() Debug.Print Range("Al").Value

End Sub

Még azt is megtehetjük, hogy egy objektum tulajdonságának tartal- má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ácsainak megjelenítését egy olyan tulajdonság határozza meg, melynek tartalma egy logikai érték. A cellarácsok ki- és bekapcsolását végzı program tehát a következı lesz:

Sub KiBe() ActiveWindow.DisplayGridlines = Not ActiveWindow.Di splayGridlines

End Sub

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.

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őveleteket a 3. táblázatban találjuk.

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áto- rokról beszéljünk egy kicsit. A hatványozásról csak a mőveleti jel miatt ej- tü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 92. 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.

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!

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 megfele- lı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ás- nak az eredménye az egészosztás után maradt maradék. A maradékosz- tá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. A10 Mod 6 eredménye 4.

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.

A szövegekkel kétféle mőveletet végezhetünk. Az egyik a szöveg összevo- nás mővelete a másik a helyettesítı karakteres összehasonlítás.

Ennek operátora a &. Ezt az operátort arra használhat- juk, 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é helyezünk. Erre egy kicsit romantikus példa, amikor Rómeó nevét tárol- juk az egyik változóban, a másikba Júlia nevét írjuk, és a két változó tar- talmá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 Összevon () 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 program eredménye, hogy az strEgyutt változó tartalma „Rómeó és Júlia".

A másik szöveges operátor a Like. Ezt a mőveleti je-

let arra használhatjuk, hogy egy tetszıleges szövegrészrıl megmondjuk, tartalmazza-e az általunk keresett karaktersort. Ezzel már találkozhattunk,

amikor az operációs rendszerben egy fájl nevébıl csak egy kisebb részletet is- mertü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 a helyettesítı karaktereket tartalmazó szöveg típusú értéket. Ha pél- dául azt szeretnénk megvizsgálni, hogy a szöveg kezdı betője A bető, akkor ezt a következı paranccsal tehetjük meg:

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

End Sub

Ha a fenti eljárást lefuttatjuk, akkor az Immediate ablakban a True ér- ték jelenik meg. A * helyettesítı karakter ugyanis egy vagy több karakter- nyi szöveget helyettesíthet. Ezzel az összehasonlítással tehát azt vizsgál- tuk, 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 bal oldalra írt szöveg második karaktere l bető. Itt a kérdıjel helyettesítı karakterre lesz szükségünk.

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

End Sub

A kérdıjel helyettesítı karakter helyén bármilyen bető állhat, Az ered- mény azért lett igaz, mert az alma szó második betője l. A záró csillag he- lyettesí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 helyet- tesíti, hanem bármelyik karaktert. Számot is, betőt is. A számjegyek he- lyettesítésére a # karakter szolgál. Vessük össze a ? és a # helyettesítı karakterek eredményét.

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

Debug.Print "e-es" Like "?-es" ' a z 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 ered- ménnyel járt, mert a kérdıjel nem tesz különbséget a számjegyek és a be- tő karakterek között. A # minden esetben csak egyetlen számjegyet he- lyettesít. Vagyis ha arra lennénk kíváncsiak, hogy az elsı két karakter he- lyén szám van-e, akkor két # helyettesítı karaktert kéne oda írnunk.

Úgyis 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 bal oldalon Kata, vagy Kati szerepel-e, de ha Kató van a bal oldalon, akkor hamis legyen az eredmény.

Sub KatiKato() Debug.Print "Kata" Like "Katfai]" ' az eredmény True

Debug.Print "Kati" Like "Kat[ai]" ' az eredmény True

Debug.Print "Kató" Like "Katfai]" ' 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 egy betőtartományra keressünk rá. Tegyük fel, hogy azokat az értékeket szeretnénk megtalálni, amelyek az abc 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 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 kezde- nünk a helyettesítést. Az elızı példával ellentétes eredményt ad a követ- kezı eljárás:

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

Debug.Print "Marosi" Like "[!A-L]*" ' az eredmény T rue

End Sub

ALike 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áso- kon 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:

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 tartal- má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 kifeje- zés szerepel.

Dim bollgazE As Boolean Dim sngSzam_l As Single Dim sngSzam_2 As Single sngSzam_l = 1 8 . 2 3 sngSzam_2 = 17.45 bollgazE = sngSzam_l < sngSzam_2

A két változó közé írt < jel egy összehasonlító operátor. A kifejezés ered- mé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.

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.

A logikai operátorok arra szolgálnak, hogy egyszerre több logikai összeha- sonlí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, mint- hogy 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. Mindkét változóban csak True vagy False érték lehet. A logikai operátorok felsorolását a 98. oldalon található 7. táblá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 program vezérlı utasí- tásokat ismerhetjük meg.

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ével kezdi, majd az eredményt a bal oldali változóba írja. Ennek megfelelıen, a válto- zó 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áro- zott 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 ope- rátoroknak nevezzük. Az operátorok állhatnak több betőbıl is. Gondol- junk a Mod, az And vagy az Or operátorokra.

Térjünk át a programvezérlı utasítások megismerésére. Mint azt már 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 ér- tékadás, vagy egy eljárás meghívása. Máskor ezek segítségével változtat- juk 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 figyel- met fordítunk az adatfeldolgozás és a vezérlések kapcsolatára. Keressük a választ a következı kérdésekre:

♦ Hogy ágazhatunk el a programban? ♦ Hogy függ össze az adat és a feldolgozás? ♦ Hogyan ismételhetünk meg programrészeket?

Az elágazás vezérlı utasítások segítségével a változók vagy objektum-tu- lajdonsá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 - paran- csai az If és a Select.

Ezzel az elágazással logikai kifejezések segítségével kiértékelhetjük a fel- dolgozás alatt álló változókat. Mint 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.

Az If elágazásnak két szintaktikája - írásmódja - is

van. Az egysoros és a többsoros. Az egysoros a következı:

If logikai_kifejezés Then Utasítás_l 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észete- sen 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_l kerül végrehajtásra, ellenkezı esetben - vagyis, ha False az ered- mény -, akkor az Utasítás_2 parancsot fogja végrehajtani a program. En- né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.

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

Utasitás_l

Utasitá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 J/é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.

Az If szerkezet teljes írásmódjában több feltételt is vizsgálhatunk. Ennek az írásmódja:

If logikai_kifejezés_l Then

Utasítás_l

Utasítás_2

Elself logikai_kifejezés_2 Then Utasitás_3

Utasítás_4

Elself logikai_kifejezés_n Then Utasitás_5

Utasítás_6

Else Utasítás_7

Utasítás_8

End If End If

Az If elágazásban annyi ElseIf sort írunk be, amennyit akarunk. Eb- ben a tekintetben nincs korlátozás. Természetesen minden Elself mögött más-más logikai kifejezést értékelü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, ha ennek a kifejezésnek is True az értéke.

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 Vezérlés. 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 Al-es cellájába be- írunk egy számot, és a beírt szám értékétıl függıen a Bl-es cellába íras- sunk ki egy értékelı szöveget. Ha az Al-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 igye- kezzünk úgy megírni, hogy felhasználjuk a tanultakat! Deklaráljunk megfelelı állandókat és változókat! Valahogy így:

Sub If_Teszt_l () v ---- Állandók deklarálása ------ Const STR_NAGYOBB As String = "Nagyobb, mint nulla."

Const STRJKISEBB As String = "Kisebb, mint nulla."

Const STR_NULLA As String = "Nulla." 1 ---- Változók deklarálása ------ Dim sngCellaErtek As Single

Dim strEredmeny As String

'---- Adat bekérés------- sngCellaErtek = Range("Al") ' ---- Az adat feldolgozása-------- If sngCellaErtek > 0 Then

strEredmeny = STR_NAGYOBB

Elself sngCellaErtek < 0 Then strEredmeny = STRJKISEBB

Else strEredmeny = STR_NULLA

End If ' ------Eredmény kiírása-------- Range("Bl") = strEredmeny

End Sub

Az eljárás elemzését kezdjük az adatbekérést végzı sorral.

sngCellaErtek = Range("Al")

Ebben a sorban beolvassuk a program sngCellaErtek változóba az ép- pen aktuális munkafüzet aktuális munkalapján található Al-es cella tar- talmát. A program további részében már nem fordulunk közvetlenül az 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ı uta- sí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.

Elself sngCellaErtek < 0 Then

Ebben a sorban az összehasonlító kifejezéssel azt vizsgáljuk, hogy a feldolgozandó érték kisebb-e, mint nulla, ha igen, akkor az eredmény vál- tozó értékébe beírjuk az STR_KISSEBB állandó tartalmát. Ha nem telje- sü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.

Az Else ágban tehát az eredmény strEredmeny változóba beírjuk a „Nul- la" é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("Bl") = 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.

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üg- gıen ágazunk el a programban. Az elágazás elsı sorába írjuk le azt a kifeje- zé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_l

Utasítás_l Utasitá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

Utasitás_7 ütasítás_8

End Select

A Visual Basic végiglépked a Case sorokon, és összehasonlítja a kifeje- zé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, to- vá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 vizsgált_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 ki- fejezés nagyobb, mint egy meghatározott érték, akkor az Is kulcsszót használjuk a következı írásmóddal:

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.

Készítsünk egy olyan eljárást, amelyik egytıl hétig terjedı egész számo- kat dolgoz 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 napjainak a sorszáma. Az eljá- rás futtatása után a B2-es cellába írjuk be szövegesen a hét napjainak a nevét. Az eljárást nevezzük el Select_teszt_l névvel. A program a követke- zı lehet:

Sub Select_Teszt_l() 1 Állandó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 v A feldolgozandó adat beolvasása

sngCellaErtek = Range(STR_INPUT_CELLA) 1 Adatfeldolgozás sngCellaErtek = Int(sngCellaErtek)

Select Case sngCellaErtek

Case 1 strEredmeny = STR_NAP_1



Case 4 StrEredmeny = STR_NAP_4



Case 7 StrEredmeny = STR_NAP_7

Case Is < 1, Is > 7

strEredmeny = STR_NAP_HIBA

End Select v 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. Ve- gyük észre, hogy ebben az eljárásban, az állandók között rögzítettük a be- meneti és kimeneti cella nevét. Ez azért lehet hasznos, mert, ha változtat- ni akarunk a programon, nem kell végignéznünk a teljes eljárást. Elegen- dı 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 el- já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 Se- lect_Teszt_2. íme egy lehetséges megoldás:

Sub Select_Teszt_2() 1 Állandók deklarálása Const STR_INPUT_CELLA As String = "A3" Const STR_OUTPUT_CELLA As String = "B3" Const STRJTAVASZ 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 v Adatfeldolgozás sngCellaErtek = Range(STR_INPUT_CELLA)

sngCellaErtek = Int(sngCellaErtek)

Select Case sngCellaErtek

Case 3 To 5

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

Most elevenítsük fel egy kicsit azt a részt, ahol a változókról olvastunk. Ak- kor 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 ese- tén ugyanazokat a lépéseket hajtjuk végre minden tömbelem feldolgozása- kor. 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 fel- dolgozásához ciklust kell szerveznünk. A Visual Basic for Application nyelvben a következı ciklusokat valósíthatjuk meg:

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. Ez 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 = Kezdıérték To Végérték Step Lépes

A ciklustest utasításai

Next intSzaml

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 — Kezdıérték.

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ér- ték -Végérték -, 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 - Végérték 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 Lépes 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ésétıl folytatódik. Vagyis megvizsgáljuk, hogy a ciklusszámláló ér- té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.

Természetesen most is készítünk egy egyszerő példát, amelyben megvizs- gá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.

A feladat a következı! Kérjünk be a fel- haszná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 be- kérésére használjuk az Inputbox függvényt.

Sub For_Next_teszt_l() "— Á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 STRJ3UT As String = "db kisebb szám volt, mint "

Const INT_HATAR As Integer = 6

v— Változók deklarálása — Dim inti As Integer Dim sngSzamok(1 To 5) As Single Dim bytKisebbek As Byte 1— Kezdeti értékadás, adatbekérés — bytKisebbek = 0 For inti = 1 To 5

sngSzamok(inti) = InputBox(inti & STR_IN, STR__IN_C IM)

Next inti v— Feldolgozás —

For inti = 1 To 5 If sngSzamok(inti) < INT_HATAR Then

bytKisebbek = bytKisebbek + 1 End If

Next inti v— Eredmény kiirá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ömbvá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 be- gé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ése- kor ú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,

akkor megnöveltük a kisebb értékeket számláló változó tartalmát eggyel. Mi- re 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ök esetén annyi For-Next ciklust ágyazunk egymásba, ahány dimenziós a tömb. Az is- mé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 feldolgo- zandó értékeket, és ebben a tömbben vizsgáljuk meg, az értékeket! Ké- szítsük el az aktív munkalapot a következı adatokkal!

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 el- sı 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ı:

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ömbvá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(intl, intK)

Next intK

Next inti '— Feldolgozás —

For inti = 3 lo 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 int i '— Eredmény kiírása — MsgBox bytKisebbek & STRJDUT & INT_HATAR

End Sub

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 ugyanez. Ott is végiglépkedünk a kétdi- menzió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ó ér- té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-

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 mind- két ciklust, ha azok egymást követı sorokban lennének.

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ál- juk 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 ele- meken és feldolgozhatjuk 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 munkalap- jait szeretnénk feldolgozni, akkor a ciklusszámláló változónak munkalap típusúnak kell lennie. Ha cellák tartalmával dolgozunk, akkor tarto- má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 Győjtemény

mőveleteket 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ép- ked 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őjte- mé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üze- tet, kapcsoljunk át a Visual Basic felületre. Szúrjunk be egy új általános modult, és írjuk meg a következı eljárást.

Sub For_Each_teszt_l () 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álto- zót, aminek a típusa a Worksheet, vagyis egy munkalap. Ez lesz a ciklus- szá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 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. Ez 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 (110. olal) feladatot is megoldhatunk ezzel a ciklussal. A For Next iteráció ismertetésekor azt vizsgáltuk, hogy egy számokkal kitöl- tö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 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 —

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őjte- mé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ır- zésére, mint az elsı megoldásban. Miután végigjártuk az összes cellát, kiír- juk az eredményt.

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 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 aszerint, hogy a ciklus ele- jén, vagy végén kerül-e ellenırzésre a feltétel. Ha a ciklus elején tesztelünk,

akkor elöltesztelı ciklusról beszélünk, ha a végén, akkor hátultesztelı cik- lusról van szó.

Ez azért érdekes, mert lesznek olyan ciklusok, melyek utasításait leg- alább egyszer végre kell hajtanunk. Ilyenkor hátultesztelı 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 ered- mé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 progra- mozá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öltesztelı í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

A feltétel egy logikai kifejezés, ami - mint azt már olvastuk az operáto- rokról szóló részben — vagy True vagy False eredményt adhat. A While kulcs- szó 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öltesztelı 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átultesztelı ciklus megvaló- sítására is. Ebben az esetben a ciklustestet lezáró Loop sorban kell meg- hatá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.

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, ellen- kezı esetben visszalépünk a Do sort követı utasításra.

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álhat- ja, 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 fel- használó.

Sub Loop_teszt_l() x — Á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!" 1 — Váltzók deklarálása Dim bytGondoltSzam As Byte Dim bytTipp As Byte

Dim lngTippSzam As Long ' — Kezdeti értékedás lngTippSzam = 0 bytGondoltSzam = Int(Rnd(l) * 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 adatbe- ké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 megfelel a strukturált programozás elvárásainak is.

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 ér- tékétıl függetlenü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 hajt 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 hajt vég- re. Ezeket szelekciónak nevezzük.Vagyis a feltételeknek megfelelıen sze- lektá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 uta- sí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.

Visual 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 fel- adatuktól függıen - több fajtája van. A programban lesznek olyan eljárások, amelyeket mi hozunk létre, és lesznek olya- nok, amelyeket a program kínál fel nekünk. Ebben a fejezetben ismerked- jünk meg azokkal az eljárás fajtákkal, amelyeket mi hozhatunk létre. A fejezet fıbb kérdései:

♦ Milyen eljárások 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?

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 el- já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ál- tuk 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 el- járások szerkezetét is érdemes úgy kialakítani, hogy azok az esetleges ké- sıbbi programmó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 kulcs- szó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.

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 állhat- nak. Minden más utasítást Sub és End Sub utasítás-pár közé kell írnunk.

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óak, szubrutinnak használhatók.

A szubrutinokban külsı - a szubrutinon kívüli - adatokat is feldolgoz- hatunk. Ilyen esetben át kell adnunk a feldolgozandó adatokat az eljárás- nak - 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.

A függvények olyan eljárások, amelyek egy értéket adnak vissza. Vagyis amikor lefuttatunk egy függvényt, akkor a futás eredménye egy vissza- adott érték. Afüggvény meghatározás kulcsszava a Function. A függvény- nek 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.

Function Összead(sngA As Single, sngB As Single) As Single Összead = 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ározhat- juk az adattípusát is. Afü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 tu- domására, hogy a függvény eljáráson belül értéket adunk a függvénynév változónak.

Function Összead (sngA As Single, sngB As Single) As Single Összead = sngA + sngB

End Function

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 = Összead(25.456, 781.452) Debug.Print sngC

End Sub

A függvény használata 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 hasz- ná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ügg- vé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 Excel- be, és vegyük használatba ezt az egyszerő kis függvényt (121. oldal 24. ábra).

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 alkal- mazá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ügg- vény esetén ezt így kell írni:

Private Function Összead(sngA As Single, sngB As Single) As Single

Összead = sngA + sngB End Function

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 el- járás többszöri meghívásakor.

Egy-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és- re, ha egy-egy parancsot nem megfelelıen írtunk le és pirossá változott, amint elléptünk az adott sorból. A hibák egy másik csoportja adódhat ab- bó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övet- kezı kérdéseket:

♦ Hogyan lehet egy eljárást lépésenként végrehajtani? ♦ Hogy állíthatjuk meg az eljárást futás közben? ♦ Hogy vizsgálhatjuk meg a változók tartalmát?

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égigol- vassa és a végén kiírja a tartomány legkisebb értékét. Valahogy így:

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 & S TR_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álto- zóban megjelenjen a tartomány legkisebb értéke. A dblTemp változó az adatok átmeneti tárolására szolgál.

d b lMin = Se lec t i on .Cu r ren tReg io n .Ce l l s ( 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 vehet- né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 tartal- má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 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.

MsgBox STR_MSG_1 & dblMin & STR_MSG_2 & strCime & S TR_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 se- gí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 tartal- mazó utasítássort a VBE sárga színnel kiemeli. A következı lépés végrehaj- tá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é (126. 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.

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.

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 elıtt nem kell megállnunk. Ha egy korábban elkészített munkalap függvényben, vagy eseményvezérelt eljárásban 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 hala- dunk tovább lépésenként.

Ha már megállítottuk valahol a futó eljárást, akkor bármelyik másik

soron megállíthatjuk a programot. Ehhez álljunk a kurzorral a megfelelı sorra és a helyi menübıl hajtsuk végre a Run to Cursor parancsot. A program tovább lép a megszakítási pontról, de abban a sorban ismét megáll, amelyikben a kurzor állt.

Helyezzünk el töréspontot az //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 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ó bil- lentyő). 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, meg- vizsgá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.

A változókat külön ablakban is megjeleníthetjük. Hajtsuk végre a 128. oldal 28. rajzon 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.

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 Watch.es 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 az eljárást 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ó ha- tókörét mutatja meg. Ez jelenleg a Module1-es modul MinimumKeres eljárá-

sa. Ez a mi esetünkben a Modull-es modul, azon belül pedig a MinimumKe- res 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ánaszá- 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.

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éte- les megszakításokat is meghatározhatunk. Másként fogalmazva megha- tá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ásun- kat, 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ábana 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 kifeje- zést és kapcsoljuk be a Break When Value is True kapcsolót.

Ha egy figyelıpont beállításán változtatni sze-

retnénk, akkor jelöljük ki a figyelıablak listájából és a helyi menübıl a Edit Watch utasítást. A megjelenı panelben megváltoztathatjuk a beállí- tásokat.

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ése- inket 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.

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át- hatjuk, 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.

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ıablak- ban is élhetü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 le- hetıséget, zárjuk le a Local Window segédablakot.

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 uta- sí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 sor- nyi 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álto- zók értékét szeretnénk megjeleníteni és írjuk be a következıket:

A változók vagy objektumok tulajdonságát az eljárás bármelyik pont- já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é.

ADebug 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 az Assert eljárást használjuk. Ha az Assert után beírt logikai kifejezés értéke hamis lesz, 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.

Természetesen a tulajdonságok vagy változók ér- té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. Errıl a könyv késıbbi fejezeteiben olvashatunk.

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ódo- sítsuk is.

Az Excel objektumok megismerésére jó módszer, hogy az Immediate ablakban kiadott parancsok hatását megfigyel- jü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ódu- soknak a neve, amelyek több objektumban is elıfordulnak, azonosak. A fejezet fıbb kérdései:

♦ Hogyan változtathatjuk meg egy-egy objektum tulajdonságait? ♦ Hogyan ismerkedhetünk meg az egyes objektumok használatával?

Töltsük be az Excelt és kapcsoljuk be a Visual Basic Editor-t. A megje- lenítését állítsuk be úgy, hogy a háttérben látható legyen az Excel program (135. 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égre- hajtá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égrehajt- hatjuk, 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 megfi- gyelhessük mi történik az Excelben.

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ódsze- rekkel jelölhetünk meg egy kiszemelt cellatartományt.

Maga az Excel alkalmazás is objektum, így program írásakor ennek tulaj- donságaihoz, metódusaihoz is hozzáférünk. Az objektum neve Applicati- on. 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öny- vek 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 ne- vé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

tulajdonság egyedi. Vagyis egy projekten belül nem használhatjuk két- szer 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- toztatható futási idıben is. Afelirat tulajdonság a Caption. Ilyen tulajdon- sá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ólbb olvassuk ki, majd változtassuk meg!

?application.caption

Erre a következı választ kapjuk: Microsoft Excel - Munkafüzetl. Azért jelent meg a munkafüzet neve is a válaszban, mert a megnyitott munka- fü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 138. oldalon látható 36. ábra szemlélteti. Ha szeretnénk visszaállítani az eredeti feliratot, adjuk ki a következı parancsot:

application.caption = ""

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át- szik, 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.

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

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áljuk 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édpa- nelt. Az egyes beállítások eredményét kérdezzük le az Immedate ablakban kiadott paranccsal. Például, kapcsoljuk ki az Excel állapotsorát!

application.DisplayStatusBar=False

Ha a DisplayStatusBar tulajdonság értékét False-ra állítjuk, eltőntet- hetjü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 Display- FormulaBar tulajdonság értékét megváltoztatjuk. Tetszés szerint próbál- junk 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. Egyet- egyet próbáljuk átállítani. Nem mindegyiket lehet! Más szóval, ismerked- jü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:

?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. Tegyük meg, majd ismét indítsuk el az Excelt. Adjuk ki a következı parancsot:

application.quit

É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őjte- mény elemeit. Ezt a metódust fogjuk felhasználni arra, hogy megszámoljuk az alkalmazásban megnyitott munkafüzeteket.

?application.workbooks.count

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:

'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őjte- mé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.

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üt- jü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.

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 mun- kafüzetet. Figyelem a munkafüzetek neve már nem egytıl kezdıdik.

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 munka- fü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

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óje- lek 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 objektu-

mot. 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 ne- vé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 írathat- juk ki. Az aktív munkafüzet és az elsıként megnyitott munkafüzet nem feltétlenül ugyanaz.

workbooks("MunkafüzetlO") .close

A Workbooks győjtemény egyik elemére az elem — munkafüzet — 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üzetlO-est is. Ha most is ezt próbáljuk lezárni, akkor hibaüze- net 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 ír- nunk, amelyikbe elmentettük. Ilyenkor az XLS kiterjesztést is hozzá kell venni a névhez!

workbooks("Munkafüzetl2").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áltoztat- tunk, de nem mentettük el a változásokat. Mivel mi még semmit nem vál- toztattunk 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 activeworkbook.close utasítással, akkor a program figyelmeztetni fog arra, hogy szükség esetén mentsük el a munkafüzetet.

A munkafüzetben pillanatnyilag használatban lévı munkalapok (Work- sheets) is győjteményt alkotnak. Ismerkedjünk meg a munkalapokon vé- gezhetı néhány mővelettel. Mivel az elızı gyakorlatok során megnyitot- tunk é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ép- jünk ki az Excel-bıi és indítsuk újra. Ez azért jó, mert akkor a munkafüze- tetek számozása ismét a Munkafüzet 1-el kezdıdik. Ha végeztünk, szá- moljuk meg hány lapja van az aktív munkafüzetnek. Most is a győjte- mény Count metódusát használjuk.

?worksheets.count

Vehetünk fel új lapokat a munkafüzetbe? Igen! Melyik metódus hasz- nálatával? Az Add metódussal. Minden győjteménynek van Add metódu- sa? 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ó. A legfelül látható mun- kafüzet az aktív.

Workbooks(l) .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 a legkorábban hoztuk létre, vagy nyitottuk meg, hiszen erre hivatkoztunk.

?worksheets (1) . name

A Worksheets győjtemény sorrendben elsı objektumának a nevét írat- hatjuk 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áltoztatha- tó. 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"

Az elızı utasítást kissé átalakítva azt is megtehetjük, hogy program- bó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ámi tások" ) .cop y Be fo re :=Workshee ts( 2)

A Copy metódussal munkalapokat másolhatunk. A Before paraméter- ben 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)

Ezzel az utasítással a számítások munkalapot egy másik munkafüzet- be másoltuk át. Az utasítást csak akkor hajthatjuk végre hibaüzenet nél- kül, ha valóban van Munkafüzet2 nevő munkafüzetünk. Ha nincs, vá- lasszunk olyan munkafüzet nevet, amelyik létezik.

H o r k s h e e t s ( " S z á m í t á s o k " ). m o v e B e f o r e : = W o r k s h e e t s ( 4 )

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

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.

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 worksheets(Array("Munkai","Munka4","Munka6") ).select

Egyszerre több munkalapot is kiválaszthatunk. A fenti utasítás ered- ményeként a Munkai, Munka4 és a Munka6-os munkalap lesz kiválaszt- va, vagyis csoportba foglalva.

activesheet.select

Ha több munkalap van egyszerre kijelölve, akkor az a munkalap az ak- tív, amelyiknek a neve vastag betővel látszik. Ezzel az utasítással meg- sző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ıuta- sítást.

worksheets(Array(1,4,6)).select 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 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

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ámol- ni szoktunk. A diagram lapok megszámlálásához a ?Charts. Count utasí- tást kell kiadnunk.

Az Excel-ben megnyitott ablak nem azonos a munkafüzettel. Csak annyi a kapcsolatuk, hogy a munkafüzet is egy ablakban jelenik meg. Akövetke- zı gyakorlatokhoz elegendı lesz egy megnyitott munkafüzet. Tehát zár- juk le a felesleges munkafüzeteket, majd a VBE próbaablakba írjuk be a következı utasítást:

ActiveWindow.NewWindow

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 mun- kafü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üzetl ablakait. A metódusnak az Arrangestyle argumentuma mögötti egyes szám a mozaik elrendezés meghatározását szol- gálja.

Windows.arrange arrangestyle: =xlcascade

Az utasítás ugyanaz, mint az elızı volt, de most nem egy számmal ha- tároztuk meg, hogy milyen legyen az ablakok elrendezése, hanem egy Ex- cel belsı állandóval. Ez az állandó egy számot helyettesít. Ha a próbaab- 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 fe- lülre került ablak sorszáma egyes lett. Másképpen fogalmazva, ha a Win- dows(l).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ép- kedhetü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 alkalma- zás címét. Akkor is a Caption tulajdonságot használtuk.

Lépjünk át az Excelbe és zárjuk le a megnyitott ablakokat. Csak egy mun- kafü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 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 Al-es cellája. Va-

gyis a cella meghatározása során is meg kell mondanunk, hogy a cellák győj- temé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. Acellá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(l) = 400

A cell objektum tulajdonságainak értéket is adhatunk. A legutóbb kiadott select-tel a munkalap legutolsó celláját választottuk ki, azaz a leg- utolsó 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.

Az utasítás végrehajtása után lépjünk vissza az Al-es cellára. Ott fogjuk találni a 400-as számot. Ebben az utasításban a Cells(l) cella Value tulajdonságát állítottuk be. Tehát pontosan így kellett volna leírni az uta- sítást: Cells(1). value — 400 jelezve ezzel azt, hogy az objektum melyik tu- lajdonsá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 objek- tumé 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őj- temény zárójelébe idézıjelek közé beírjuk a cella Al 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.

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, dl, 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.

r a n g e ( c e l l s ( 2 , 2 ) , c e l l s ( 5 , 4 ) ) . s e l e c t

Ennek a tartománykijelölésnek az érdekessége az, hogy a Range para- métereiben a Cells győjtemény két tagja van. A zárójelek közötti két cella- hivatkozá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 ha- tá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 ered- mé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("Al:D6") .cells.Count

?Range("A1:D6") .columns.Count

?Range("Al: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. Eh- hez 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 Selec- tion objektumnak a tulajdonságai és metódusai egyeznek a Range objek- tuméval.

Programozás során gyakran használunk adatokkal kitöl- tött tartományokat. Ezek jellemzıire is szükségünk lehet a program írása közben. Akö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 Excel-be é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 szer- kesztı az Excel elıtt legyen, és ismerkedjünk meg néhány lehetıséggel.

Álljunk az Al-es cellára. Ehhez adjuk ki a Cells(l).select utasítást.

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 ki- jelö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

Akiválasztott cella környezetében található üres cellák száma az ered- mény. Ennek az utasításnak a végrehajtása során nem kellett kijelölni a tartományt.

Range ( " a l " ) .SpecialCells(xlCellTypeBlanks).select

Az Al-es cella környezetében található üres cellákat jelölhetjük ki. Aki- jelölés az utolsó celláig tart. Itt az utolsó cella nem a munkalap utolsó cel- láját jelenti, hanem az utolsó még kitöltött cellát. Válasszuk ki ismét az Al-es cellát, és számoljuk meg, hogy mennyi üres cella van az éppen kije- lölt cella környezetében.

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 me-

lyiket 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.

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( B 2 : F 1 0 ) = "Adat"

Ezzel az utasítással a B2:F10-es tartomány mindegyik cellájába beír- tuk 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

Hogy jobban követhessük az elvégzett gyakorlatokat, ezen az adattar- tományon fogunk dolgozni. Ha a tartomány egyik celláján állunk, akkor erre a tartományra a Selection.CurrentRegion hivatkozással mutatha- tunk 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 a pél- dá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.

Seiection.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 adat- tartomány feletti sor. Ha nem határozzuk meg az aktuális tartományt, vagyis csak azt írjuk be, hogy rows(l).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 tarto-

má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

Figyeljük meg, hogy ennek az utasításnak az eredményeként az adat- tartomány elsı cellasorának betői félkövérek lettek. Ezt a Font. bold tulaj- donság beállításával értük el. Most azonban a hivatkozást érdemes megfigyelni. Ez a Selection.currentregion.rows(l). 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égre- hajtjuk:

Selection.currentregion.columns(1).font.bold = true

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 A2-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ímez- ni, 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 a selection.currentregion hivat- kozásnak megfelelıen az adattartomány bal felsı cellája. Ez jelen esetben a munkalapon a B2-es cella. Hajtsuk tehát végre a következı utasítást:

s e l e c t i o n . c u r r e n t r e g i o n .o f f s e t ( 2 , 3 ) . r a n g e ( " a l : a 3 " ) . s e l e c t

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 A l-es cella hivat- kozását. Az offset mögé írt range objektum az offset által megjelölt cellát tekinti Al-es cellának. így tehát a range("al:a3") hivatkozás nem a munkalap Al:A3-as tartományát jelöli meg, hanem az offset által meghatáro- zott cellához viszonyított Al:A3-as tartományt. Az offset és a range kombi- ná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 mutat- hatunk.

Zárjuk le mentés nélkül azt a munkafüzetet, amelyikben eddig dolgoz- tunk, és kezdjünk egy új, üres munkafüzetet. Ebben most a rajz objektumokkal végezhetı mőveletek közül vizsgálunk meg néhányat.

Az elsı legyen az, hogy hogyan használhatjuk az Add metódust a rajzok esetén.

ActiveSheet.Rectangles.Add(45, 9, 72, 30).Select

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ıolda- lának távolsága a munkalap tetejétıl, a téglalap szélessége és végül a tég- lalap magassága.

Selection.Interior.Colorlndex = xlNone

A téglalap hátterének (Interior) a Colorlndex tulajdonságát megvál- toztathatjuk. 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ínpalet- ta harmadik színe a piros.

A munkalaphoz nem csak téglalapot adhatunk hozzá programból, hanem az Excel-ben új rajzalakzatokat is. Ezt egy kicsit másképpen kell 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(msoshapel6pointstar,

50,20,100,100) .select

A fenti utasítás egy 16 ágú csillagot helyez el az éppen aktív munka-

lapra. Ha másik munkalapra hivatkozunk, akkor arra kerül rá a rajzalak- zat. Az utasításban szereplı msoshapel6pointstar 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 kiválasztva. Ha a zárójelbe kettest írunk, akkor pedig a csillag. Tegyük ezt meg és változtassuk meg a csillag színét.

selection.shaperange.fill. onecolorgradient msogradientvertical, 1 , 0 . 2 5

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ég- zi. 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 jobb oldalon, 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 átme- net 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.

Mielıtt ezekbe a gyakorlatokba belefognánk, ismét kezdjünk egy új mun- kafü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(l).select

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álasz- tott 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ál- toztathatjuk. Erre a diagramvarázsló eljárást használjuk fel. A Galery pa- ramé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ı oszlopai- bó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á felirat- ké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ölhe- tü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értel- mezett szöveg jelenik meg benne. Ez a magyar Excelben „Diagramcím", az angolban „Chart title". Hasonló módon a kategóriatengelyhez és az ér- téktengelyhez is rendelhetünk feliratot.

activechart .Axes(xlcategory, xlPrimary) .hastitle = true

A kategóriatengely feliratának a megjelenítésére használható tulajdon- ság-beállítást látjuk. Ha az xlcategory Excel-állandó helyére az xlvalue állan- dót írjuk, akkor ugyanezzel az utasítással az értéktengely mellé készíthe- tü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ál- hatjuk, ha 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 diagra- moknál használható!

A VBE Immedite ablakában közvetlenül kiadott parancsok hatását megfi- gyelve 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 Excel-ben azonnal meg- nézhetjük a mőveletek eredményét.

Miutá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 legegy- szerő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.

♦ 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?

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 próbáljuk el, mielıtt a felvételt elkezde- né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

kezdje a program az Ai-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 áll- junk az A2-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:

1. Az egérrel kattintsunk az A1-es cellára. (Mert ugye nem azon álltunk!) 2. Gépeljük be, a Készítette szöveget. 3. Kattintsunk a B1-es cellára.

4. Gépeljük be a nevünket. 5. Kattintsunk az A2-es cellára. 6. Írjuk be a Vállalat szót. 7. Kattintsunk a B2-es cellára. 8. Gépeljük be a vállalatunk nevét. 9. Üssük le az ENTER billentyőt.

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é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.

Kezdjük el a felvételt (45. ábra)! Tehát az A1-es cella kivételével bár- melyik 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 ke- rülı program nevét: Készítette.

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ő.

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.

(Personal Macro Workbook) Ez egy olyan mun- kafü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ét- rehozta é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 DataXMic- rosoft\Excel\XLSTAKT

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 FilesXMicrosoft Office\OFFICEll\XLSTART

XlsTART Ez egy speciális mappa. Azok a munkafüzetek amelyeket ide mentettünk, automatikusan be- töltıdnek az Ex- cel indításakor.

Minderre azért van szükség, mert csak azokat az eljárásokat futtat- hatjuk, 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.

(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 Excel-bıi. Az Excel észre- veszi, 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álaszol- juk azt, hogy szeretnénk elmenteni. így a következı betöltéskor rejtve marad.

(This Workbook) A felvétel a jelenleg használt

munkafüzetbe készül. A felvett makrót minden alkalommal használhat- juk, 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:

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ı esz- köztár Rögzítés vége gombjával tehetjük meg. Ha az eszköztár nem je- lenne 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.

Amunkánk eredményének egyik jelét a makró párbeszédpanelben láthat- juk. Kapcsoljuk be a panelt az Eszközök (Tools) > Makró (Macro) > Mak- rók (Macros) utasítás segítségével. Ebben a panelben a következıket fogjuk találni:

(Macro Name) A megjelenı párbeszédpanel Makró név listájá-

ban felsorolja azokat a makrókat, amelyek jelenleg elérhetıek az Excel- ben, 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.

(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.

(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ó.

(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.

(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.

(Delete) gomb lenyomásával töröljük a listában kijelölt eljárást.

(Options) gombra kattintva megjelenik egy párbeszédpanel. Eb- ben 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 bil- lentyő-kombinációt, akkor ezt utólag meghatározhatjuk a listából kijelölt makróhoz.

Amint elkészültünk egy makró rögzítésével, érdemes megnézni az ered- mé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 ta- láljuk:

Sub Készítette()

' Készítette Makró

' Rögzítette: Kovalcsik Géza, dátum: 2005

' Billentyőparancs: Ctrl+k

Range("Al").Select

ActiveCell.FormulaRICl = "Készítette"

Range("Bl " ) .Select ActiveCell.FormulaRICl = "Kovalcsik Géza"

Range("A2").Select ActiveCell.FormulaRICl = "Vállalat"

Range ("B2") .Select ActiveCell.FormulaRICl = "Help Key Bt"

Range ("B3") .Select

End Sub

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 ismer- kedtü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("Al").Value = "Készítette"

Range ( "Bl") .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állalat nevét lekér- dezhetjü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:

Sub Készitette_megoldasa ()

' Készítette Makró


' Billenty őparancs: Ctrl k

Range("Al").Value = "Készítette"

Range("Bl").Value = Application.UserName Range("A2").Value = "Vállalat" Range("B2").Value = Application.OrganizationName

End Sub

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.

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 for- má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) lista- panelbı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 Keretezes()

’ Keretezés Makró ’ Rögzítette: Kovalcsik Géza, dátum: 2005

Selection.CurrentRegion.Select Selection.Borders(xlDiagonalDown).LineStyle = xlNon e

Selection.Borders(xlDiagonalUp).LineStyle = xlNone

With Selection.Borders(xlEdgeLeft) .LineStyle = xlDouble .Weight = xlThick .ColorIndex = xlAutomatic

End With

With Selection.Borders(xlEdgeTop)

.LineStyle = xlDouble .Weight = xlThick .Colorlndex = xlAutomatic

End With

With Selection.Borders(xlEdgeBottom) .LineStyle = xlDouble .Weight = xlThick .Colorlndex = xlAutomatic

End With

With Selection.Borders(xlEdgeRight) .LineStyle = xlDouble .Weight = xlThick .Colorlndex = xlAutomatic

End With

With Selection.Borders(xlInsideVertical) .LineStyle = xlContinuous .Weight = xlThin .Colorlndex = xlAutomatic

End With

With Selection.Borders(xlInsideHorizontal) .LineStyle = xlContinuous .Weight = xlThin

.Colorlndex = 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 Se- lection kulcsszó arra a tartományra hivatkozik, amelyik éppen ki van je- lö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üksé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

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 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

.Colorlndex = 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áspá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 = xlDoubl e

Selection.Borders(xlEdgeRight).LineStyle = xlDouble

With Selection.Borders(xlInsideVertical) .LineStyle = xlContinuous .Weight = xlThin

.Colorlndex = xlAutomatic

End With With Selection.Borders(xlInsideHorizontal)

.LineStyle = xlContinuous

.Weight = xlThin .Colorlndex = 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ó


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áso- kat. 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 Selec- tion.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

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:

Sub Keretezés_megoldas()

v Keretezés Makró 1 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 sorok- tó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.

Tegyük fel, hogy többször is kapunk olyan listákat, amelyekben nincse- nek 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.

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 adattar- tomá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 felira-

ta 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ógom- bot, és kattintsunk a panel OK gombjára.

Tehát most ott tartunk, hogy kijelöltük az összes üres cellát (174. 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:

1. írjunk be az aktív cellába egy egyenlıségjelet. 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éple- teket. 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. 5. 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 '

Selection.CurrentRegion.Select Selection.SpecialCells(xlCellTypeBlanks).Select

Selection.FormulaRICl = "=R[-1]C"

Selection.CurrentRegion.Select

Selection.Copy Selection.PasteSpecial Paste:=xlPasteValues,

Operation:=xlNone, SkipBlanks:=False, Transpose:=False

Application.CutCopyMode = false

End Sub

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.

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 mak- ró felvételt, majd az eredményt kielemezve beépítjük a programunk meg- felelı helyére. A Makró rögzítés az egyik legjobb tanítómester, ha az objektumok tulajdonságainak és metódusainak a használatát szeretnénk megtanulni.

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égre- hajtani, majd ezt kiegészítjük vezérlı utasításokkal.

Mint azt láttuk a programvezérlı utasításokkal foglalkozó fejezetben, az utasítások végrehajtását különbözı feltéte- lekhez 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ővele- tek 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énye- ket az objektumok készítıi határozták meg, vagyis mi az elıre meghatáro- zott eseményeket használjuk. Ebben a fejezetben ismerkedjünk meg az események kezelésével. A kérdések a következık:

♦ 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?

Kezdjük az ismerkedést egy egyszerő példával. Nyissunk meg egy mun- kafüzetet és lépjünk át a programozási környezetbe. Ennek legegysze- rőbb módja, ha leütjük az ALT+F11 billentyő-kombinációt. Azt már lát- tuk, 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 (178. oldal 49. ábra). Azt tapasztaljuk, hogy megnyílik egy modul. Ez már akkor is a

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.

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ényve- zé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 mun- kalaponként más és más lehet.

Amint a baloldali objektum listapanelbıl kiválasz- tottuk a Worksheet objektumot, rögtön megjelenik a munkalapok alap- értelmezett eseményvezérelt eljárása, a SelectionChange. Ez az ese- mény akkor következik be, amikor megváltoztatjuk a munkafüzet cellái- nak 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. Fi- gyeljük meg, hogy az eljárás neve mögötti zárójelben változó, vagy válto- zók vannak. Mit kezdhetünk a változókkal? Ezek a változók a környezet- rıl adnak át adatot ennek az eljárásnak. Az átadott értékeket megvizs- gá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 ki- jelö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 tar- tomány vagy cella hátterét színezzük be sárgára, amint kijelöljük az adott tartományt. Ezt egyetlen utasítással megvalósíthatjuk. íme az eljárás:

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

End Sub

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.

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.

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 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.Colorlndex = 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.

Oldjunk meg néhány egyszerő, szemléltetı példát az események progra- mozásáról. Ezekbıl kiderül, hogy miként használhatjuk fel az esemény- vezé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ó belekattintott. 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áso- dik 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 Munkai munkalaphoz tartozó modult. A SelectionChange eseményve- zérelt eljárásba írjuk be a következı programot:

Private Sub Worksheet_SelectionChange(ByVal Target As Range) If Target.Column < 3 Then

Cells(Target.Row, 3).Select End If

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 Column tulajdonsága árulja el. Ezt a lehetıséget kihasz- ná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ál- hatjuk 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 Before- DoubleClick 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üle- ten a kettıs kattintás eredménye az, hogy az adott cellát átváltjuk szerkesz- té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 BeforeDoub- leClick 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:

Private Sub Worksheet_BeforeDoubleClick(ByVal Targe t 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(STRJJZENET, STR_CIM, Target.Value)

Target.Value = varAdat

Cancel = True

End If

End Sub Ha ez az esemény bekövetkezik, megjelenik egy inputbox párbeszédpa-

nel. 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 szer- keszté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.

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.

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 se- gí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ő mon- datokkal fogalmazzuk meg a program lépéseit.

1. Tegyünk rendet: az esetleges korábbi feladatok eredményeit tüntes- sü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 vegyenek fel.

3. Végezzük el az összeadást. Ennek az értékét egy harmadik változóban tároljuk (bytC).

4. A megfelelı cellákba í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ı eltel- té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 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 byte as Byte

Public Sub Gyakorlási) 'Az eredményt tartalmazó cellák törlése Range("Al:C2") = "" 'A számok elıállítása veletlenszám függvénnyel bytA = Int(Rnd(l) * 10) + 1 bytB = Int(Rnd(l) * 10) + 1 'Az eredmény kiszámítása byte = bytA + bytB 'A feladat kiíratása Range("Al") = bytA Range ("Bl") = bytB 'A válasz cella kiválasztása Range( " C l " ) .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 fel- adatná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( " E 2 " ) = bytC

End Sub

Ezzel az utasítással egy-egy kiválasztott billentyő leütését figyel-

tethetjü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, melyik eljárás futtatását váltsa ki. Ezzel a figyeléssel a billentyőzet tetszıle- ges 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 hoz- zá 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") = byte 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 meg- felelı 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ákozu nk!"

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.

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 programunk- nak 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 érte- lemben mindenképpen, hogy elıre nem tudjuk meghatározni, hogy mikor következik be.

Az elıre felmérhetı hibákat futás közben kell kezelnünk. Ennek érde- ké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ıi a hibák kezelését -, az On Error GoTo címke utasítás. Ha ezt elsı utasításként ír- juk, akkor a program futása közben bekövetkezı összes hibát mi kezelhet- jük le. A hiba figyelése minden esetben attól a sortól történik, ahova beír- tuk 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étrehozhat- juk 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. Te- gyü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övet- kezı kis eljárást.

Sub LapNincs () Worksheets("Nincs").Range("Al") = "Bármi adat"

End Sub

Ebben az eljárásban egy Nincs nevő munkalapra szeretnénk írni. Le- het, hogy korábban volt ilyen lap, de most nincs. így az eljárás nem hajtó- 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 End feliratú gombra (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ás- sort. Most csak annyit teszünk, hogy figyelmeztetjük a felhasználót arra, hogy nincs olyan munkalap, amire dolgozni szeretne. A programot bıvít- sük ki a következı sorral:

Sub LapNincs_megoldas() On Error GoTo HibaLapNincs Worksheets("Nincs").Range( " A l " ) = "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. Ahiba 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:

Worksheets.Add.Name = "Nincs"

Ez az utasítás beszúrja az új munkalapot, de nem írja rá azt a szöveget, amivel befejeztük az eljárást. Térjünk vissza arra a sorra, ahol a hiba be- kö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ı uta- sí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 ese- té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ások- ra 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 haj- tódjanak végre a hibakezelı utasítások, csak akkor, ha a mi hibánk követke- zik be. Ezt a hibakezelı részbe írt egyetlen // utasítással oldhatjuk meg.

Sub LapNincs_megoldas_2() On Error GoTo HibaLapNincs Worksheets("Nincs").Range( " A l " ) = "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 hiba- kó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.

Egyik-másik eljárásban szükség lehet arra, hogy az eljárás vég- rehajtá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áso- kat. Ebben a fejezetben néhány egyszerő példa segítségével megismerke- dünk a kapcsolatot megvalósító eszközökkel. A fejezet a következı kérdé- sekre ad választ:

♦ 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?

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 üzenhe- tünk, hanem adatot is kérhetünk a felhasználótól. Ezzel a felhasználó köz- vetlenü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 megte- hettü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.

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

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 vblnformation hatására pedig az információ jelölést fogjuk látni. Ha ezek közül 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 lehe- tı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("Ü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 választjuk. Igen gomb esetén 6, Nem esetén 7 a válasz. Ezt az értéket tárol- hatjuk egy változóban és egy If vezérléssel kiértékelve elágazhatunk.

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("Al") = "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érd ezzük meg a fel- használót az új munkalap beszúrásáról. Ha kéri, haj tsuk 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("Al") = "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

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. Aztán az MsgBox megjelenik és rajta lesz az Igen és a Nem gomb. Ezt követıen az elágazunk a válasznak megfelelıen.

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égezzük a beírást. El- lenkezı esetben — ha a felhasználó nem kéri az új lapot — kilépünk az eljárás- bó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 megje- lenítünk az MsgBox panelen. Megtehetjük, mert ezeket a belsı állandókat úgy találták ki, hogy összeadva az egyik és másik értéket egyszerre két meg- jelení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)

Nyissunk meg egy üres munkafüzetet és kapcsoljunk át a programszer- kesztı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át- ható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 el ıkészítése

With blnCellaRacs .Mode = msoModeModal .Heading = STR_CIME .Text = STR_KERDES .Button = msoButtonSetYesNo .Animation = msoAnimationGestureUp 'A válasz eredmény meg ırzése intValasz = .Show

End With 'A válasz kiértékelése If intValasz = -3 Then

ActiveWindow.DisplayGridlines = True Elself intValasz = -4 Then

ActiveWindow.DisplayGridlines = False End If 'A pihenı animáció beálliása Assistant.Animation = msoAnimationldle

End Sub

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 dekla-

rá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 hivat- kozását. A intValasz változót a kérdésre adott válasz átmeneti megır- zé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. New Ballon által létrehozott objektumot - ez egy ballon

lesz - elnevezzük a deklarált blnCellaRacs névvel. Ettıl kezdve ezzel a 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 üze- net-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 so- rá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 ne- vé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 megje- lení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ít- jük a cellarácsokat, vagy elrejtjük.

If intValasz = -3 Then ActiveWindow.DisplayGrldlines = True

Elself intValasz = -4 Then ActiveWindow.DisplayGridlines = False

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 = msoAnimationldle

Bizonyos animációk az utasítás kiadása után is folyamatosan ismét- lıdnek, ezért tanácsos visszaállítani (Idle) vagyis üresjárat állapotba tenni az animációkat.

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 megje- lení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(l) = "Cellarácsok" strSzovegek(2 ) = "Állapotsor" strSzovegek(3 ) = "Szerkesztılé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.DisplayGridli nes

.CheckBoxes(2).Checked = Application.DisplayStatusBar

.CheckBoxes(3).Checked = Application.DisplayFormulaBar

.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. Ajelölınégyzetek közül bármelyiknek az ér- té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:

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 ob- jektumvá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é minden esetben oda kellett volna írni a blnBeallitas objektumnevet. Tehát, ha most ponttal kezdıdik egy sor, akkor gondoljuk elé a blnBeallitas-al azonosított Balloon objektumot. Ez mindaddig tart, amíg el nem érünk az End With utasítást tartalma- zó 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 tulaj- donsá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 Check- Boxes objektum Text tulajdonság beállításával történik. Ennek eredménye- ké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ı je- lö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íta- ni kívánt tulajdonságok jelenlegi értékének 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égyze- tek tükrözik a környezeti beállításokat.

intValasz = .Show

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 az intValasz változó értéke -1 lesz, ha a Mégse gomb volt az, akkor az eredménye -2 lesz. A to- vá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) .Ch ecked

Application.DisplayStatusBar = .CheckBoxes(2).Check ed

Application.DisplayFormulaBar = .CheckBoxes(3).Chec ked

ActiveWindow.DisplayWorkbookTabs = .CheckBoxes(4).C hecked End If

Ha tehát az intValasz értéke -1, akkor változtatunk. Ezért vizsgál- juk 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.

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ér- té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. Va-

gyis 0% jelenjen meg az Al-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- nítsük meg az Al-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 Engedmény () 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(O) = "0%" strSzazalek(l) = "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("Al") = strSzazalek(intEredm)

End Sub

Az eljárás elején deklaráljuk a változókat és az eljárásban használan- dó állandókat. Ezek használatáról majd a programsorok értelmezése so- rá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 hivat- kozá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 ko-

rábban is láttuk, a With utasítást akkor használjuk, ha ugyanannak az objektumnak 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, üzene- té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 ele- jén deklaráltuk. A Text a ballonban megjelenı kérdés szövege, amit szin- té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 = inti 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. Az 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 Al-es cellába. Az inti ciklus- számláló egytıl ötig végiglépked a Labels objektumokon és az 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 az intEredm vál- tozóban annak a gombnak a sorszáma lesz, amelyikre rákattintottunk.

Range( " A l " ) = strSzazalek(intEredm)

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

Összetettebb feladatokat egyedi párbeszé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 az őrlapokat. A paneleken vezérléseket alkalmazhatunk. Ezek szintén korábban elkészített objektumok.

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.

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. 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 jele- ní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.

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

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 Properties ablakban a megfelelı tulajdonságokhoz írjuk be a megfele- lı é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, észrevehetjü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án- kat 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- 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.

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 kites- sékeli azt az objektumot a memóriából, amelynek a nevét utánna í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 ép- pen 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 őr- lapon elhelyezett összes vezérlı objektumot.

A következı megoldandó feladat az, hogy ne csak a Visual Basic Edi- torbó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 billen- tyő-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:

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ára.

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ényei- nek megfelelıen. Oldjuk meg most ugyanezt őrlap alkalmazásával. Hoz- zunk 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 el- végeztük a beállításokat, bezárjuk vele az őrlapot. Rajzoljuk meg tehát a következı párbeszédpanelt:

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 rajzol- hatunk. Miután megrajzoltuk a négy jelölınégyzetet, rajzoljunk egy parancsgombot 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, a 60. ábrán látható szá- mozásnak megfelelıen a következıit legyenek:

1. Őrlap Caption: Gyors beállítások Name: frmGyorsBeallitas

2. CheckBoxl Caption: Cellarácsok Name: chkCellaRacsok

5. CheckBox2 Caption: Munkalap fülek Name: chkLapFulek

4. CheckBox3 Caption: Állapotsor Name: chkAllapotsor

5. CheckBox4 Caption: Szerkesztóléc Name: chkSzerkLec

6. CommandButtonl Accelerator: B Cancel: True Caption: Bezárás Default: True Name: cmdBezaras

Fontos, hogy még azelıtt nevezzük el a vezérléseinket, mielıtt az ese- mé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 marad- nak. Ezzel csak pluszmunkát adunk magunknak. A beállítások után az őrlapunk a 208. oldal 61. ábráján látható módon fog kinézni.

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ó leüti az ALT+B billen- tyőkombinációt, pont az történik, mintha az egérrel kattintott volna a 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és- be. 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 őr- lapunkat. A leggyorsabban úgy juthatunk el a parancsgomb Click - kat- tintásra — eseményébe, ha kettıt kattintunk a gombra.

Private Sub cmdBezaras_Click() Unload Me

End Sub

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, ír- juk 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 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 ese- ményéhez írjuk a következı sort:

ActiveWindow.DisplayWorkbookTabs = chkLapFülek

Az Állapotsor jelölınégyzet Change eseményéhez a megfelelı utasítás- sor 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 átvá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 állapo- tot 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 uta- sítások, amelyeket ebbe az eseményvezérelt eljárásba írunk, akkor fognak lefutni, amikor az őrlapot megnyitjuk, használatba vesszük. Kattint- sunk 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

chkLapFülek = ActiveWindow.DisplayWorkbookTabs

chkAllapotsor = Application.DisplayStatusBar

chkSzerkLec = Application.DisplayFormulaBar

Hátra van még az indító eljárás elkészítése. Apró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.

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ánaol- vasnunk. Ezeket programozni is lehet. Ha kevésnek ítélnénk a rendelke- zésünkre álló vezérléseket, a kereskedelemben újabbakat vehetünk. Eb- ben a részben ismerkedjünk meg néhány vezérlés használatával.

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úr- junk 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 tet- szıleges szöveget a beviteli dobozba, majd zárjuk le az őrlapot. Erre hasz- náljuk az őrlap jobb felsı sarkában található x-szet. Miután lezártuk a panelt a VBE-ból lapozzunk vissza az Excelbe. Azt fogjuk tapasztalni, hogy az aktív munkalap Al-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 ese- té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 Al-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 Munkal-es lap, akkor a ControlSource tulajdonságnak a MunkaHAl értéket kell adni.

Ugyanezt a feladatot oldjuk meg programozással is. Ebben a

megoldásban azonban nem a ControlSource tulajdonságot fogjuk felhasznál- ni, hanem a beviteli doboznak azt az eseményét, ami a beviteli doboz tartal- mának a megváltozásakor következik be. Töröljük a ControlSource tulajdon- sá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 TextBoxl_Change eljárásban állunk. Ebbe írjuk be a következı utasítássort:

Worksheets("Munkai").Range("Al") = TextBoxl

Ismét indítsuk el az őrlapot. Figyeljük meg, hogy ebben a megoldásban a Munkal-es munkalap Al-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 őr- lapban 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 hasz- nálhatjuk a vezérlés programozásával, ebben az esetben valamelyik ese- mé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 és a Lista 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.

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 le- nyitásával jeleníthetjük meg. A listában felsorolt adatokat úgy használ- hatjuk fel, hogy lenyitjuk a listát és rákattintunk a megfelelı sorra. A ki- választott listaelemet a program segítségével feldolgozhatjuk vagy a meg- felelı 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 kombi- ná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ét- fé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 következı példát úgy oldjuk meg, hogy tarto- mányokat használunk a tulajdonságok beállítására. Készítsünk egy őrla- pot, amelyikre egy kombinált listát helyezünk el. A lista lenyitása után városok közül lehessen választani és a kiválasztott város nevét írjuk az el- sı munkalap Al-es cellájába. Nyissunk meg egy új munkafüzetet és ké-

szítsuk 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. Kattint- sunk rá az egér jobb gombjával és válasszuk ki a Properties utasítást. 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 tulaj- donságot. Ide írjuk be a MunkaliAl cellahivatkozást. Ezután jelöljük ki az őrlapot, és az F5-ös funkció-billentyő leütésével indítsuk el. A megjele- nı 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 Munkai munkalap Al-es celláját. Itt megtaláljuk a kiválasztott város nevét. Ez volt a legegy- szerőbb módja annak, hogy kombinált listát használjunk.

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 lis- tá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 Cl-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. ARowSource tulajdonsága-

hoz írjuk be a Munka2!C2:D6-os hivatkozást. A ControlSource tulajdon- sághoz írjuk be: Munkal!A1.

A vezérlésnek meg kell mondanunk, hogy most két oszlopból kell meg- jelenítenie az adatokat, ezért a ColumnCount (oszlop-szám) tulajdonság- hoz írjunk be egy kettes számot. Ide mindig azt kell beírnunk, hogy hány 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ál- ni. Ezt a BoundColumn (kötött oszlop) tulajdonságban állíthatjuk be. Te- hát írjuk be annak az oszlopnak a számát, amit a ControlSource tulajdon- sá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 (osz- lopszé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 aRun > Run Sub/UserForm 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.

A sorforrás megadásának másik módszere, amikor a lista ele-

meit tömbben deklaráljuk és programból a meghatározott tömböt használ- juk 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 sor- forrá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 őr- lapot 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 helyez- zü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 ki az Initialize esemény eljárást. Határozzunk meg egy tömböt, majd állít- suk be a lenyitott lista tartalmát. Az eljárás a következı lesz:

Private Sub UserForm_Init ial ize() 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" ComboBoxl.List = strVarosok

End Sub

Figyeljük meg, hogy ebben az esetben nem a RowSource, hanem a List tulajdonságot állítottuk be. A másik érdekesség az, hogy a Városok töm- bö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 tulaj- donságát ugyanúgy használhatjuk, mintha egy tömb lenne, vagyis a Com- boBoxl.List(O) 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 meg- jeleníteni, amelyiket kiválasztottuk a listából. Ezt a ComboBoxl .List- Lndex tulajdonságából olvashatjuk ki. Ezt fogjuk felhasználni arra, hogy a kiválasztott lista értékét beírjuk az elsı munkalap Al-es cellájába. Az utasítást a ComboBoxl__Change eseményvezérelt eljárásába írjuk be.

Private Sub ComboBoxl_Change() Worksheets("Munkai").Cells(1 ) = ComboBoxl.Value

End Sub

Próbáljuk ki az őrlap mőködését. Figyeljük meg azt is, hogy miután ki- választottuk a listapanel egyik elemét, az eredmény azonnal megjelenik a Munkai lap Al-es cellájában.

Oldjuk meg a másik feladatot is programozással, vagyis a lenyitott lis- tában jelenítsük meg a termékek nevét. A termék kiválasztása után a Munkai munkalapon a A2-es 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.

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(l, 0) = "Televízió" strArukd, 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"

ComboBoxl.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étdimenzió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 kombi- nált listára, majd a megjelenı vezérlés modul Change eseményébe írjuk be a következı két utasítássort.

Private Sub ComboBox2_Change() Worksheets("Munkai").Range("A2") = ComboBox2.Value

Worksheets("Munkai").Range("B2") =

ComboBox2.List(ComboBox2.Listlndex, 1) End Sub

Az elsı utasítássor segítségével a Munkal-es munkalap A2-es cellájá- ba beírtuk az áru megnevezését. A második utasítássort pedig arra hasz- náltuk, hogy az áru árát megjelenítsük a B2-es 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 sorfor- rá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 tulaj- donság meghatározásával.

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.

Kezdjünk egy új munkafüzetet, az elızıt zár- juk 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 ve- zé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(O) = "hétfı"

strForras(l) = "kedd"

strForras(2) = "szerda" strForras(3 ) = "csütörtök" strForras(4) = "péntek" strForras(5 ) = "szombat"

strForras( 6 ) = "vasárnap"

ListBoxl.List = strForras

End Sub

Ezután a projekt ablakban (a VBE bal oldalán) kattintsunk kettıt a UserForml feliratú sorra. Ismét megjelenik a létrehozott őrlap. Jelöljük 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 érté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: fmMul- tiSelect-Multi. Ezután jelöljük ki az őrlapot és hajtsuk végre az Run > Run Sub/UserForm futtatás utasítást. A listában jelöljünk meg több listaelemet.

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ál- hatjuk 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álaszt- ható é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 bytl As Byte For bytl = 1 To ListBoxl.ListCount

With Worksheets("Munkai") .Cells(bytl, 1) = ListBoxl.List(bytl - 1)

.Cells(bytl, 2) = ListBoxl.Selected(bytl - 1)

End With

Next bytl

End Sub

Az eljárás elsı sorában deklaráltunk egy változót. Ezt arra fogjuk fel- haszná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 bytl = 1 To ListBoxl.ListCount

Ennek a sornak az a feladata, hogy addig ismételje a lista elemek kiér- tékelését, amíg a listaelemek száma tart. Ezt jelzi a sor végén található ListBoxl .ListCount kifejezés. AListCount tulajdonság ugyanis azt mutatja meg, hogy hány soros a lista.

Cells(bytl, 1) = ListBoxl.List(bytl - 1)

Ebben a sorban íratjuk ki a listák elemeit. Ezek az értékek az aktuális munkalap elsı oszlopában fognak megjelenni. A Listbox.List zárójelei kö- zött azért kell egyet levonnunk a számláló érékébıl, mert a lista számozá- sa nullától kezdıdik. Ennek megfelelıen a legnagyobb elem száma is eggyel kisebb, mint a számláló legnagyobb értéke.

Cells(bytl, 2) = ListBoxl.Selected(bytl - 1)

A ListBoxl .Selected tulajdonságából megtudhatjuk, hogy éppen egy listaelemet bekapcsolt-e a felhasználó. Itt minden listaelemre rákérdezünk. Abe- kapcsolt elemek True értéket adnak vissza. Futtassuk az őrlapot. Tetszıle- gesen jelöljük ki a listaelemeket, majd zárjuk le az őrlapot. A választásunk eredményét az aktív munkalapon fogjuk megtalá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 üserForm_Terminate()

Dim bytl As Byte

Dim bytK As Byte

bytK = 1 For bytl = 1 To ListBoxl.ListCount

If ListBoxl.Selected(bytl - 1) Then Cells(bytK, 1) = ListBoxl.List(bytl - 1)

bytK = bytK + 1

End If

Next bytl

End Sub

Ha a MultiSelect tulajdonságot fmMultiSelectExtended értékre állít- juk 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 lista- sorokat, ameddig az újonnan kijelölt elem tart.

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.

Egy másik projektbe készítsünk egy őrlapot és rajzoljunk egy lista ve- zé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.

Akié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 cellahivat- kozást, ahova az eredményt szeretnénk elhelyezni. A programban hasz- ná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övet- kezı utasításokat:

Private Sub UserForm_Terminate()

Range("Al") = ListBoxl.Listlndex

Range("A2") = ListBoxl.List(ListBoxl.Listlndex) End Sub

A lista ebben az állapotában a Listlndex tulajdonságban tárolja a kivá- lasztott listasor sorszámát. A sorszámozás nullától kezdıdik. Ezt az érté- ketjelenítjük meg az Al-es cellában az elsı utasítássorral. A második uta- sítás segítségével a listapanel kiválasztott sorának szövegét írjuk az aktív munkalap A2-es cellájába.

A felhasználóval sokféle grafikus eszközzel tarthatjuk a kapcsolatot. Egy- szerőbb üzeneteket gyorsan, kevés programozással küldhetünk az Msg- Box segítségével, amelynek két változata is a rendelkezésünkre áll. Az egyik változat, amikor metódusként hívjuk meg, a másik esetben függ- vényként. Ha metódusként hívjuk meg, nem értékelhetjük ki a felhaszná- ló válaszát. így nincs is értelme választási lehetıséget elhelyezni rajta. A metódusként hívott MsgBox esetén az argumentumokat zárójelek nélkül soroljuk fel. Ebben az esetben a zárójelek nem csak feleslegesek, de futási hibát is eredményeznek. A függvényként meghívott üzenet panel argu- mentumait 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 al- kalmazásból elérhetünk. Az egyszerőség hátránya, hogy csak korlátozott számú vezérlés helyezhetünk el rajta és csak programozottan kezelhetı.

Egyedi őrlapokat hozhatunk létre az alkalmazás rugalmassá tétele ér- dekében. Ebben az esetben jó eredményeket érhetünk el a vezérlı objektumok tulajdonságainak a beállításával. A programozása sem túl össze- tett ezeknek az eszközöknek, de a megismerés némi kísérletezést igényel. Itt nem alkalmazhatjuk a makrórögzítést az objektumok megismerésére. Ezért kisebb programok írásával próbáljuk megismerni az eszközöket.

Miután elkészítettük az eljárásainkat, azt várhatóan többen is fogják használni. Mi el tudjuk indítani a felvett vagy ál- talunk í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örnyezetét, 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 Excel-be 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ákap- csoljuk az Excel-hez. A gondolatébresztı kérdések a következık:

♦ Hogy rendelhetjük az eljárást eszköztárhoz vagy menühöz? ♦ Mit kell tennünk egy beépülı makró elkészítése során? ♦ Hogy határozhatjuk meg, hogy egy függvény melyik kategóriába ke-

rüljön?

A menü és az eszköztár ugyanarra az objektum osztályra épül. Ezért mindkettıt ugyanott és ugyanúgy alakíthatjuk át. A kiindulás mindkét esetben az, hogy az egér jobb gombjával kattintsunk 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 esz- kö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.

Amíg az alkalmazásban látható a Testreszabás (Customize) párbeszéd- panel, addig mind az eszköztárakat, mind a menüket szabadon átalakít- hatjuk. Megfoghatjuk a panel Parancsok (Commands) 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öz- tá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 áll- va hozhatunk létre újabb eszköztárat vagy menüsort. A Parancsok (Com- mands) 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 vise- li. 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áren- deltek 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 Menü Item), Egyedi gomb (Custom Button). Ezekhez mi rendelhetjük hozzá az eljárásainkat.

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ár- beszédpanel Eszköztárak (Toolbars) lapjára és kattintsunk a Létrehozás (New) gombra (67. ábra). 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.

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ör- lé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ál- toztathatjuk bármelyik eszköztár összetételét, ha meggondoljuk magunkat, bármikor visszaállíthatjuk az eredeti állapotot.

Készítsünk gombot, amivel elindíthatunk egy eljárást. Nyissuk meg a CD melléklet 17 Fejezet mappájából a Menu_l.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 (223. oldal 68. ábra). Ehhez fogjuk hozzárendelni az egyik makrót tartal- mazó megnyitott munkafüzet eljárását.

A Testreszabás (Customize) 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-ve. Erre azért van szükség, mert ez a szöveg fog megjelenni akkor, amikor az egér- mutatót a gomb fölé húzzuk.

A lenyitott helyi menüben a gomb képén 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 megjele- nı 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.

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

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ét- re. Ez az egyetlen, de lényeges különbség az eszköztárak és a menüparan- csok 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 (Com- mands) lapra. Válasszuk ki az Új menü (New Menü) 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 Menü) 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 Menü) gombot, az egér gombját tartsuk lenyomott állapot- ban és vontassuk a Segédletek menüpont fölé.

Miközben a menüpontot vontatjuk, a már menüsoron lévı menüpon-

tok é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 rajzon 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.

A következı lépés, hogy a menühöz utasítást rendelünk. Az eljárás ugyanaz, mint a gomb esetén volt, de most a Makrók (Macros) kategóriából a Felhasználói menügomb (Custom Menü Item) szövegő gombot visszük a Se- gé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 Jelentés 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édpa- nel megnyitása után egyszerően fogjuk meg a menüpontot és húzzuk le a helyérıl.

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, jo- gos 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 okét. Akkor most következzenek az esz- kö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. Mindkét objektum a Com- mandbars győjtemény eleme. 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ában foglalja az eszköztá- rakra és a menüsorokra elhelyezett gombokat, menüpontokat. Ezek a ve- zérlések a CommandBarControls győjtemény részei.

Ennek a két objektumnak a megismerésével lehetıségünk nyílik prog- ramból megváltoztatni az Office alkalmazások menüsorainak és eszköztára- inak 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, 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ér- léseket, megszüntethetjük a munkafüzethez tartozó eszköztárakat.

Ha nem szeretnénk az Office alkalmazáshoz tarto- zó eszköztárakat megváltoztatni, akkor hozzunk létre újat. Ezen helyez- zük el majd azokat a gombokat, amelyekhez hozzárendeljük az egyedi el- járásainkat. Nyissuk meg az Utasitassorok.xls munkafüzetet, az Eljárá- sok modulban néhány egyszerő eljárást találunk. Ezek az aktív munkalap Al-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+Fll). Kattintsunk kettıt az UtasításSorok modulra. Ez egy üres modul. Ebben fogjuk megír- ni 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ét- rehoztuk az új eszköztárat, nem hozhatunk létre még egy ugyanolyan ne- vőt. Ha az eljárást másodszor futtatjuk, az új eszköztárat létrehozó sor hi- 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 esz- köztárként fog viselkedni. A Temporary argumentumban arról gondos- kodhatunk, 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 munka- fü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, nincs rajta egyetlen vezérlés sem. Errıl mi fogunk gondoskodni.

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 ar- gumentumnak a True értéket adjuk, akkor a létrehozott utasítássor me- nüsorként fog mőködni. Mivel egy alkalmazásban egyszerre csak egy me- nü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 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

' a z 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) 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.

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" VA 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

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á elhe- lyezhetünk almenüket is. Kezdjünk egy új eljárást, amelyikben menüket é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 MenuPontokO Dim cbrMenuSor As CommandBar Dini popMenul As CommandBarPopup Dim popSubMenul 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 = "SEls ı almenü" Const STR_SMNU2__NEVE As String = "SMásodik almenü" Set cbrMenuSor = CommandBars(STR_NEVE) Set popMenul = cbrMenuSor.Controls.Add _

(Type:=msoControlPopup)

popMenul.Caption = STR_MNU1_NEVE

Set popSubMenul = popMenul.Controls.Add (Type:=msoControlPopup)

popSubMenul.Caption = STR_SMNU1_NEVE

Set popSubMenu2 = popMenul.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. ApopMenul változó az utasítássorra elhelyezett menüpont azonosítója lesz, a popSubMenul és a popSubMenu2 változók pedig a popMenul 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 cbrMe- nuSor névvel.

Set popMenul = 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ék- kel határozzuk meg azt, hogy az új vezérlés menüpont legyen. Ugyaneb- ben 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.

popMenul.Caption = STR_MNU1_NEVE

Ez az utasítássor arra szolgál, hogy az elhelyezett menüpontnak a fel- iratá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 popMenul = cbrMenuSor.Controls .Add

(Type:=msoControlPopup)

Mivel a vezérlésünket elneveztük a popMenul változóval, ezért a to- vá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 popSubMenul = 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ér- lé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.

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ük- ségünk, íme egy példa az elıbbi menük törlésére:

CommandBars(STR_NEVE) .Controls (STR_MNU1_NEVE) .De lete

A létrehozott eszköztárakra, menüsorokra és a me- nüpontok alá utasításokat helyezhetünk el. Ezekkel egyrészt elindíthat- juk azokat az eljárásokat, amelyeket mi készítettünk, másrészt mőköd- tethetjü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övetke- zı eljárás:

Sub Utasítások() Dim cbrMenuSor As CommandBar Dim popMenul As CommandBarPopup Dim popSubMenul As CommandBarPopup Dim popSubMenu2 As CommandBarPopup Dim cbbEgyediGombl 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 = "SMá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ási" Const STR_ELJ2 As String = "Eljárás2" Const STR_ELJ3 As String = "Eljárás3" Set cbrMenuSor = CommandBars(STR_NEVE) Set popMenul = cbrMenuSor.Controls.Add(Type:=msoCon trolPopup) popMenul.Caption = STR_MNU1_NEVE Set popSubMenul = popMenul.Controls.Add(Type:=msoCo ntrolPopup) popSubMenul.Caption = STR_SMNU1_NEVE Set popSubMenu2 = popMenul.Controls.Add(Type:=msoCo ntrolPopup) popSubMenu2.Caption = STR_SMNU2_NEVE cbrMenuSor.Controls.Add Type:=msoControlButton, ID: =2

Set cbbEgyediGombl =_ cbrMenuSor.Controls.Add(Type:=msoControlButton) With cbbEgyediGombl

.Faceld = 51

.Caption = STR_EGYEDI_1_CIM

.OnAction = STR_ELJ1

End With

popMenul.Controls.Add Type:=msoControlButton, ID:=3

popSubMenul.Controls.Add Type:=msoControlButton, ID :=4

Set cbbEgyediGomb2 = popSubMenul.Controls.Add(Type:=msoControlButton)

With cbbEgyediGomb2

.Faceld = 68


.OnAction = STR_ELJ2

End With

Set cbbEgyediGomb3 = - popMenul.Controls.Add(Type:=msoControlButton) With cbbEgyediGomb3

.Faceld = 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 elemez- zük. Az elemzés elsı részlete legyen az objektum elnevezést végzı sorok megértése.

Set cbrMenuSor = CommandBars(STR_NEVE) Set popMenul = cbrMenuSor.Controls.Add(Type:=msoControlPopup) popMenul.Caption = STR_MNU1_NEVE Set popSubMenul = popMenul.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üpon- tot é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 cbbEgyediGombl = - cbrMenuSor.Controls.Add(Type:=msoControlButton) With cbbEgyediGombl

.Faceld = 51


.OnAction = STR ELJ1

End With

Ebben a programrészben egyedi eljárás indítására használjuk az uta- sí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: FacelD, 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ákat- tintunk.

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.

Ahogy a fejezet elején olvashattuk, lehetıségünk van arra is, hogy a mak- rókat tartalmazó munkafüzetet bıvítménnyé alakítsuk. Ha bıvítménnyé alakítjuk azt a munkafüzetet, amelybe az eljárásainkat írtuk, akkor mind a munkafüzetet, mind pedig az eljárásokat elrejti az Excel a felhasználó elıl. Ezzel azt érjük el, hogy az eljárásaink úgy fognak viselkedni, mintha az Excel részei lennének. Töltsük be a CD mellékleten található munka- füzetet!

Elıször röviden nézzük meg azt, hogy hogyan használhatjuk a bıvítménye- ket. A Microsoft Excel-lei 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 Fi- les\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 ben- nü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 Excel-bıi, 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 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ít- ménykezelı (Add-Ins) utasítást. Eredményképpen megjelenik egy párbe- szé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áb- biakban 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édpa- nelt a Fájl (File) > Adatlap (Properties) utasítás segítségével jeleníthet- jük meg. Az adatlapról kerül a listába a bıvítmény neve is.

Nézzük most már gyakorlatban is a bıvítmény-készítést. A lemezmel- lékletrıl töltsük be a Bovitmeny.xls nevő munkafüzetet. Ebben egy egy- szerő függvényt és egy korábban elkészített őrlapot találunk. Ezt a mun- kafü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.

Ha valóban szeretnénk megvédeni a programunkat az illetéktelen be-

hatolástól, akkor a projektet védjük le jelszóval. Ezt a VBE nézetben te- hetjük meg.

Ezután kapcsoljunk át a VBE-be és állítsuk be a projekt tulajdonságait. Ehhez válasszuk ki a VBE Tools > VBAProject Properties utasítását. A meg- jelenı panel két lapból áll. Az elsı egy General lap a másik pedig a projekt 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 ér- dekében, hogy a projektet csak az láthassa, aki ismeri a jelszót.

Itt kapcsoljuk be a Lock project for viewing lehetıséget és írjuk be a jelszót a Password szerkesztıdobozba. Ajelszót ismételjük meg a Confirmpassword 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 Of- fice\Office\Makro (Library)).

Az eredmény az Excel betöltése után lesz látható, ezért zárjuk le az Ex-

cel-t, majd ismét töltsük be. Csatoljuk a bıvítményt az Excel-hez. 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 lap- ján megjelenik az a magyarázat, amit az adatlap megjegyzés rovatába ír- tunk. Kapcsoljuk be a jelölınégyzetét.

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 Bovitmeny.xls mun- kafü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.

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 Fel- használói függvénycsoportban megleljük a KerekErre függvényt. A függ- vé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 Bovitmeny.xls projektet. Kapcsoljunk át a VBE-be és kattintsunk kettıt a projektjelé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égre- hajtja az Open eseményt. Ide leírhatjuk a függvények kategóriákba soro- lásához szükséges programlépéseket és kiadhatjuk azokat az utasításo- kat, 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ít- mé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 te- hetjü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.

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övetke- zı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 = "Kerekiti 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ároz- tuk 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ügg- vé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ás- sor. 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ároz- ni. Az egyes argumentumok nevei magukért beszélnek. Ennek megfelelı- en a Macro argumentumban azt kell meghatároznunk, hogy melyik függ- vény tulajdonságait állítjuk be, vagyis a függvény nevét. ADescription argumentumban a magyarázó szöveget határozhatjuk meg, és végül a

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ölt - jük ezt a munkafüzetet, minden esetben a megfelelı csoportba kerül az ál- talunk írt függvény.

A bıvítmény elfedi a felhasználó elól azt a munkafüzetet, amelyben az el- járások vannak. Nem kell rejtett füzetként menteni, és egy kis programozás- sal 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ít- mé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ó. Ajó 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ény- ké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.

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 fel- használva. A Bovitmeny.xls munkafüzet Open eseményét bıvítsük a követ- kezı 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 BEÁLL, Description:=STR_BEALL_LLEIRAS, hasShortCutKey:=True, ShortcutKey:=STR BILLENTY Ő

rozzuk meg a magyarázatát és azt a billentyőkombinációt, amelyikkel a bıvít- mé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 bil- lentyő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 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 (73. ábra). Az utasítás ered- ményeként ezt az eljárást a SHIFT+CTRL+u billentyő-kombinációval indít- hatjuk el.

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ő-kombi- ná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 megjegyezni. Az eszköztár gyors - is és mindig látható is -, de a felhasználónak meg

Az állandók meghatározása után állítsuk be az eljárás jellemzıit. Hatá-

kell jegyeznie a megfelelı gombot. A menü szövege tájékoztatja a felhasz- ná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.

Találkozhatunk olyan idıszakonként ismétlıdı feladattal, amikor az Excel-ben elkészített munkánk eredményét át kell ten- nünk a Word-be, vagy éppen prezentáció forrásaként szolgál az Excel-ben létrehozott dokumentum. Ennek a feladatnak az el- vé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 munka- társunk végzi, aki nem eléggé tájékozott a másolás mőveletében, akkor se- gítséget nyújthatunk neki a folyamatok automatizálásával.

Ehhez ismernünk kell annak az alkalmazásnak az objektumait, amelyiket az Excel-bıi szeretnénk vezérelni. Szerencsére a programozás esz- kö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öbb- ségében is jó segítséget nyújt a makrórögzítés. A kérdések a következık legyenek:

♦ Hogyan érhetjük el Excel-bıi a többi Office alkalmazást? ♦ Hogyan programozhatjuk Excel-bıi az Office alkalmazásokat?

Az elsı lépés minden esetben az, hogy az általunk írt eljárásból el kell ér- nü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 alkalma- zás megszólítására. Egy újabb lehetıség pedig, amikor egy futó alkalma- zás szolgáltatásait vesszük igénybe.

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 Excel-t és kapcsoljuk be a VBE programot. A VBE programban válasszuk ki a Tools > References utasítást. Az utasítás eredménye- ként meg fog jelenni egy párbeszédpanel, amiben meghatározhatjuk azokat az alkalmazásokat, amelyeket látni szeretnénk az Excel-bıi is. A meg- felelı 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.

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 el- já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 ha majd használatba vesszük.

appWord.Visible = True

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öt- tü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 Excel-ben 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.

Ennek a módszernek az a hátránya, hogy csak a hivatkozásokban be-

kapcsolt objektumokat használhatjuk. Ez akkor nem is okoz problémát, ha magunknak írunk programot és gondoskodunk arról, hogy a hivatko-

zások be legyenek kapcsolva. Ha azonban másnak készítjük a programot, akkor ezt éppen azért tesszük, hogy a kellı ismeretek hiányában is hasz- nálhassák azt. Ebben az esetben másik módszerhez kell nyúlnunk.

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 hasz- ná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öveg- szerkesztıre. Tehát a VBE-ben hajtsuk végre a Tools > Reference utasí- tást és a megjelenı párbeszédpanelben kapcsoljuk ki a Word objektum- könyvtárat (76. ábra). Próbáljuk meg ismét lefuttatni az eljárást. Az ered- mény egy hibaüzenet lesz.

í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

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 futtat- hatjuk, 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ál- landó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álto- zat számát is. Ebben az esetben - az egyébként nagyon figyelmes és szol- gálatkész VBE -, nem kínálja fel a lehetséges alkalmazásokat, így a lehe- tıségeket nekünk kell tudnunk. Ezek a következık:

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

használata elıtt gondoskodnunk kell arról, hogy megnyissuk azt az alkal- mazást, amelyik dokumentumát használni kívánjuk.

Készítsünk egy példát, amelyikben egy Word dokumentum szövegét átvisszük az Excelbe. A programot Excelben ír- juk 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.

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 hi- vatkozását a References panelben. Az új projektbe szúrjunk be egy új modult, és írjuk be a következı eljárást:

Sub GetWordDokO 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" inti = 1 Set docWord = GetObject(STR_WORD_DOC, STR_OBJECT_TYPE) For Each parBekezd In docWord.Paragraphs

Cells(intl, 1) = parBekezd inti = inti + 1

Next parBekezd Range(STR_CELL_1) = docWord.Parent.Name

Range(STR_CELL_2) = docWord.Name

End Sub

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_TY PE)

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(intl, 1) = parBekezd inti = inti + 1

Next parBekezd

Ebben a ciklusban végiglépkedünk a Word dokumentum minden be- kezdésén és átmásoljuk a kiolvasott szöveget az Excel aktuális munka- lapjá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

Fange(STR_CELL_2) = docWord.Name

A következı két utasítás csak azt kívánja szemléltetni, hogy a Word to- vábbi tulajdonságaihoz is hozzáférhetünk. A 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 249. oldal 78. 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ıi visz át adatokat a szövegszer- kesztı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.

Egy érdekes megoldás lehet az is, hogy a szövegszerkesztı dokumentumában tárolt szövegeket az Excel- ben í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ítan- dó dokumentumot nem kell és nem is szabad megnyitnunk. Ezt majd el- vé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 WordDokFormatumO 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_TY PE) docWord. Paragraphs(l).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 Get- Object 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 érde-

mes megemlíteni az eljárás elején deklarált állandókat. Ezek nevét és ér- té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 megad- hattuk volna:

docWord.Paragraphs(l).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.

A Windows egyik nagyon hasznos szolgálta- tá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 dokumen- tuma számára. A következı példa elıkészítését Excel-bıi kezdjük. Egy egyszerő táblázatot készítsünk az egyik munkalapra. Ezt a táblázatot au- tomatikus 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övetke- zıképpen nézzen ki:

A feladatot Excel-ben oldjuk meg, egy eljárás megír ásával. íme az eljárás:

Sub WordbeMásoK) 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_FAJ L_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ájINeve

.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 men- tésekor lesz szükségünk. Ez lesz az a név, amit a program alapértelmezés- ként felkínál a Word dokumentum mentéséhez. Vagyis, ha nem változta- tunk 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 kapunk vissza, míg, ha beírunk egy fájl nevet, akkor szöveget. Ez a változótí- pus alkalmaz mindké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árbe- szé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ügg- vény eredménye.

If varFájlNeve <> False Then Utasitá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_FAJ L_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 CreateObject függvény segítségével.

Selection.CurrentRegion.Copy

Az aktuális kijelölés környezetében található adattartományt másol-

juk 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 Ex- cel 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 Word- ben 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 app Word.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ílu- súra. Ezt a formázást azon a bekezdésen állítjuk be, amelyikben a szöveg- kurzor áll. Még mindig csak ez az egy bekezdésünk van, így nem ronthat- juk el.

appWord.Selection.typeparagraph

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 be- kezdé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 be- szú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) > Beillesz- té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ájINeve

Mentsük el a szöveget! Erre használjuk a Word objektum SaveAs me- tó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 jelenti azt, 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ügg- vé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. Amegadott 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. Afeladatunk csak annyi, hogy meg kell ismernünk a többi al- kalmazá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- 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.

Biztosítanunk kell, hogy a külsı objektumot elérjük a programból. Ezt vagy úgy érhetjük el, hogy a Visual Basic Editor Tools > References párbeszéd-pa- nelében bekapcsoljuk a használni kívánt objektum hivatkozást vagy a Cre- ateObject 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.

A könyv további részében felhasználjuk az eddig megismert eljárásokat és metódusokat. Munka közben megismerke- dünk néhány új programozási eszközzel. Ezek segítségével olyan segédleteket készítünk, amelyeket a napi munkánk során is jól felhasználhatunk. Az egyes feladatok megvaló- sításakor megismerkedünk azokkal a lépésekkel, amelyeken egy alkal- mazás megvalósítása során végig kell haladnunk. A fejezet kérdései:

♦ Hogyan fogjunk hozzá? ♦ Mit kell meghatároznunk a tervezés során? ♦ Hogy készül egy segédlet?

Az elsı feladat három részbıl áll. Mind a három részfeladatban egy meg- határozott cellatartomány szöveges adatait fogjuk átalakítani. Elıfordul- hat, hogy sok cellába írtunk be szöveges adatokat, melyekben elkövet- tünk kisebb-nagyobb hibákat. Készítsünk egy olyan segédletet, amelyik a következı változtatásokat végzi el egy meghatározott cellatartományon.

A felhasználó egy párbeszédpanelbıl jelölhesse ki a megfelelı cellatartományt, amin a módosításokat

végre kell hajtania. Választógombok segítségével meghatározhassa, hogy milyen módosí- tásokat szeretne végrehajtani a kijelölt cellatartomány celláiba írt szö- vegeken.

♦ A szövegek megváltoztatása csupa kisbetősre, ♦ A szövegek megváltoztatása csupa nagybetősre, ♦ A cellák szövegének minden szavát nagy kezdıbetősre alakítsa.

A felhasználó által meghatározott tartomány szöveges

adatokat tartalmazó celláiba, egy párbeszédpanel segítségével új szöve- get lehessen beszúrni. Az új szöveget vagy a cellákba írt adatok elé, vagy mögé, vagy a felhasználó által meghatározott karakterpozícióra szúrja be az általunk elkészített makró.

A felhasználó által meghatározott cellatartomány celláiból szövegrészt távolítson el a makró. A felhasználónak legyen lehetı- sége arra, hogy a cellák elsı vagy utolsó valahány karakterét eltávolíthassa a cellákból, illetve a szöveg egy meghatározott részét a szöveg belsejébıl.

Az elızıekben felsorolt mőveleteket egyetlen párbeszédpanelbıl lehessen kiválasztani. A háromféle mővelet között lapozhassunk az elkészítendı panelen. A tartomány meghatározása közös mind a három mőveletnél. A panelen három gomb legyen. Az egyik a beállítások alkalmazására szol- gáljon, a másik a panel lezárására és a mőveletek végrehajtására, míg a harmadik segítségével úgy zárhassuk le a párbeszédpanelt, hogy semmi ne változzon. A panel azt a tartományt tekintse alapértelmezett módosí- tandó tartománynak, ami akkor volt kijelölve, amikor a mőveletet elkezd- tük végrehajtani.

Az elsı lépés minden esetben a tervezés. Tervezéskor mindig abból induljunk ki, hogy a programok négy részbıl állnak. Az elsı részben beállít- juk a kezdeti jellemzıket, a második részben bekérjük a szükséges adatokat, majd feldolgozzuk a rendelkezésünkre álló adatokat, végül kiírjuk vagy végrehajtjuk az eredményt. A mi feladatunk három részfeladatból áll. A három feladatot egyenként tervezzük meg. Az elsı részfeladat ter- vezését részletesen együtt fogjuk megoldani. Most tehát, a „kisbető-nagy- bető" részt tervezzük meg.

Soroljuk fel a feladat részeit, tőzzük ki magunk elé a célt, amit szeretnénk megvalósítani. Ehhez amennyire lehet, következetesen ragaszkodjunk.

Az eljárás indítása után be kell állítanunk a kezdeti értékeket. A feladat meghatározása során kikötöttük, hogy a panel betöl- tése után a tartomány kijelölés alapértelmezett értéke a panel megnyitá- sa elıtt kijelölt tartomány legyen, és az alapértelmezett választógomb ki- jelölés a Mind kisbetővel legyen bekapcsolva. A kezdeti értékek beállítá- sát a program inicializálásának nevezzük. Ezeket a beállításokat akkor

fogjuk végrehajtani, amikor a párbeszédpanelt megjelenítjük. A kezdeti értékek beállítását a létrehozott őrlap Initialize eseményvezérelt eljárá- sában fogjuk leírni.

Ebben a részben meg kell határoznunk azt a tartományt, amelyikkel a mőveleteket szeretnénk végrehajtani. Ezt egy tartományhivatkozásra alkalmazható vezérléssel oldjuk meg. A má- sik adat amit be kell kérnünk, az elvégzendı mőveletre vonatkozik. A há- rom mővelet közül egyszerre csak egyet lehet kiválasztani, így ezt egy vá- lasztócsoport gombsorral oldjuk meg.

A feldolgozás során lépkedjünk végig a meg- határozott tartomány celláin, és a cellák adatain hajtsuk végre a panelben meghatározott mőveletet.

A megváltoztatott adatokat írjuk be a megfe-

lelı cellákba.

Itt még nem fejeztük be a tervezést. Gondoljuk át, hogy a három részbıl mit vonhatunk össze? Vagyis az adatbekérés, a fel- dolgozás és az eredmény kiírása mőveletekbıl mit lehet összevonással egyszerősíteni? Az adatbekérés és a feldolgozás lépéseit végiggondolva nem fedezünk fel közös részeket. Vizsgáljuk meg a feldolgozás és ered- mény mőveleteit. Itt közös mőveletet fedezhetünk fel a két rész között. Mindkét részben végig kell lépkedni a cellákon és a cellák tartalmával kell elvégeznünk a mővelet, majd az eredményt be kell írnunk az adott cellába. Ezt összevonhatjuk, ugyanis a feldolgozás eredményét rögtön be- írhatjuk abba a cellába, aminek a tartalmát feldogozzuk. Ezzel az össze- vonással a futási idı rövidebb lesz, mivel nem kell kétszer végiglépkedni a tartomány celláin, másrészt kevesebb programlépéssel oldhatjuk meg a feladatot. Az összevonás további elınnyel is jár: nem kell - adott esetben jelentıs memóriaigényő - tömböt deklarálni az értékek átmeneti tárolá- sához.

Az összevont feldolgozási és kiírási rész a következı lépésekbıl fog áll- ni: lépkedjünk végig a meghatározott cellatartomány celláin, az egyes cel- lákban tárolt értékeket változtassuk meg a meghatározott módon és az eredményt azonnal írjuk vissza abba a cellába, aminek az adatát feldol- goztuk.

Tervezzük meg azt a párbeszédpanelt, melynek segítségével bekérjük az eljárás adatait. Ezen a panelen helyezzünk el egy sokcélú oldal MultiPage

vezérlést. Azok a vezérlések, amelyeket a sokcélú oldal egyik lapjára he- lyezünk el, automatikusan csak akkor látszanak, amikor a megfelelı ol- dalt választjuk ki. Erre azért van szükségünk, mert több eljárás adatát is ennek a panelnek a segítségével fogjuk bekérni.

A sokcélú oldal elsı lapjára rajzoljunk egy keretet. Ez a keret arra szol-

gál, hogy a választógombokat csoportba foglalhassunk. Ebbe a keretbe he- lyezzünk el három választógombot. A keretbe helyezett választógombok közül egyszerre csak egyet enged kijelölni a keret.

A tartomány kijelölésére a többi szöveges eszköz esetén is szükségünk lesz, ezért azokat nem a sokcélú oldalra helyezzük el, hanem közvetlen az őrlapra. A vezérlı gombra szintén az őrlapon lesz szükségünk.

Az elgondolást rajzoljuk le egy papírra. A program megvalósításakor ezt a rajzot fogjuk felhasználni arra, hogy létrehozzuk az őrlapot.

Az őrlapnak és az őrlapra elhelyezett vezérléseknek lesznek olyan tu- lajdonságai, amelyek nem változnak meg az egész futási idı alatt. Ezeket fixen beállíthatjuk még a panel megjelenítése elıtt. Más tulajdonságait akkor kell majd beállítanunk, amikor használjuk az őrlapot. Tehát a ve- zérlések tulajdonságainak egy részét akkor állítjuk be, amikor létrehoz- zuk a vezérlést - ez a tervezési idıszak -, míg más tulajdonságokat akkor

állítunk be, amikor a felhasználó meghatározza a tulajdonság értékét — ez a futási idıszak.

Atervezési idıben beállítandó tulajdonságok jellemzıit írjuk le. Ezzel elı- készítjük a program kódolását. A felhasznált vezérléseket nevezzük el. Az elnevezések mindig utaljanak arra, hogy mi az adott vezérlés feladata, más szóval használjunk beszédes neveket. Az elnevezések után írjuk le azt is, hogy az egyes vezérléseknek melyik tulajdonságait, milyen értékre szeretnénk beállítani a tervezési idıben. Az elnevezéseket a megtervezett rajzra írjuk fel. A programban ezekkel az általunk adott nevekkel hivatkozhatunk az egyes vezérlésekre.

Miután a vezérléseket elneveztük, készítsünk egy listát, amelyikben

leírjuk, hogy mely tulajdonságnak milyen értéket adunk a tervezési idı- ben. Ebben a részben határozzuk meg azt is, hogy az egyes vezérléseknek mely eseményeit mire fogjuk felhasználni. Az elnevezéseket azért írjuk a rajzra, hogy ezzel pontosan meghatározhassuk az egyes vezérléseket. Ezeket a tulajdonságok beállítási listájában, a beállítandó tulajdonságok között is fel fogjuk sorolni.

5. RÉSZ

A felhasználói felület kialakítása még nem jelenti azt, hogy elkészültünk a program tervezésével. Határozzuk meg azokat a lépéseket, amelyeket akkor hajt végre a program, amikor például betöltjük az őrlapot, vagy rá- kattintunk valamelyik parancsgombra. Egyelıre ne törıdjünk azzal, hogy milyen programnyelven készítjük majd el a makrónkat, bár ez a mi ese- tünkben csak a Visual Basic for Application lehet. Most a saját mondata- inkkal, szavainkkal fogalmazzuk meg az egyes eljárások lépéseit, amit úgy írjunk le egy papírra, mintha az általunk elvégzendı mőveletek program utasítások lennének.

Az eljárások tervezése során úgy alakítsuk ki a programlépéseket, hogy az elsı rész a kezdeti értékek beállítása legyen, ezt kövesse az adat- bekérés, utána a feldolgozás, és végül az eredmény megjelenítése zárja az eljárást. Ha mód van rá, a tervezés második lépésében vonjuk össze azokat a programrészeket, amelyekben erre lehetıség adódik. Erre most néz- zünk egy nagyon egyszerő példát.

Ahhoz, hogy az őrlapot megjeleníthessük, írjunk egy eljárást. Erre azért van szükség, mert az őrlapot a felhasználó csak eljárás segítségével tudja megjeleníteni.

Ebben az eljárásban nincs szükség kezdeti értékek beállítására, adat- bekérés részre. A feldolgozás rész az őrlap megjelenítése. Eredmény itt a szó szoros értelmében nem jön létre, így azzal nincs is dolgunk.

Mivel ennek az eljárásnak egyetlen őrlap megjelenítése a feladata, az adatot nem kívülrıl kérjük be, hanem a program írásakor mi határozzuk meg, hiszen ez az eljárás csak egy adattal fog dolgozni. Ezt egy értékként fogjuk meghatározni. Az elemzés eredményeként kiderül, hogy az eljárá- sunknak egyetlen utasítássora lesz, ami megjeleníti az adott őrlapot.

Igen, a példa talán túl egyszerő volt, de nem volt haszontalan. Ez egy- fajta programozási szemlélet, miszerint az eljárások felépítése során ér- demes abból kiindulni, hogy az eljárások négy részbıl álljanak (kezdeti értékek beállítása, adatbekérés, feldolgozás, eredmény megjelenítése). A részek meghatározása után vonjuk össze az összevonható részeket. A töb- bi eljárás kialakítása során is ezt a módszert fogjuk követni. Végül a saját szavainkkal írjuk le egy papírra az eljárást.

Milyen lépéseket kell végrehajtanunk az őrlapban? Legjobb, ha magát az őrlap megjelenését is egy eljárásnak fogjuk fel. Az elsı feladat a kezdeti értékek beállítása. Ezeket a lépéseket minden esetben végre kell hajtanunk, amikor az őrlap megjelenik. Mőveleteket kell végrehajtani, ha a felhasználó rákattint valamelyik parancsgombra. Ezt most írjuk le úgy, mintha utasítássorok lennének:

Figyeljük meg, hogy az egyes vezérlések eseményeit úgy írjuk le, mintha egy feltételt vizsgálnánk. Errıl nincs szó, hiszen az események bekö- vetkezését a program figyeli, mi csak kihasználjuk a program kínálta le- hetıséget, de ha bekövetkezik valamelyik esemény, akkor mi határozzuk meg azt, hogy mi történjen.

Nézzük meg a leírt programunkat, és fedezzük fel azt, hogy vannak benne közös részek. Most persze nem próbálkozhatunk egyszerő összevonással, mert a közös részeket más-más feltételek teljesülésekor kell végrehajta- nunk. Ha ilyen esetben a közös részeket egynél több utasítássorban tudjuk megvalósítani, akkor kiemeljük ıket és szubrutinként írjuk meg.

Két szubrutin jelöltet fedezhetünk fel. Az egyik az átalakítások meg- valósítását végzi el, a másik pedig az őrlap lezárását. Az őrlap lezárását egyetlen utasítássorral megoldhatjuk, így ebbıl nem lesz szubrutin. Az átalakítások végrehajtását viszont már több utasítással végezhetjük el. Ebbıl tehát szubrutint fogunk írni. Ez egy eljárás lesz, ami a külvilágtól kapja meg az adatokat. Az eljárás adatbekérı része a következı lesz:

A feldolgozás rész a következı utasításokból áll:

Itt látszólag felesleges az a vizsgálat, hogy a sokcélú oldal melyik lap-

ján áll a felhasználó. Ezt azért írtuk bele a feldolgozásba, mert elıkészí- tettük a sokcélú oldal többi lapjának a feldolgozását is.

Ne felejtsük el megírni a kezdeti értékek beállítására szolgáló eljárást sem, mely a panel megjelenésekor fog lefutni. Most nem lépkedünk végig a tervezés lépésein, hiszen itt csak bizonyos vezérlések tulajdonságait ál- lítjuk be. Ez a következı lesz:

Ezután azokat a feltételeket, amelyek eseményt takarnak, írjuk át esemény eljárássá, és az egészet írjuk le egy lapra. A következıknek kell lenni:

Mivel a többi részfeladatot a fejezet elején már leírtuk, itt a megfelelı idı arra, hogy megpróbáljuk a többit önállóan megtervezni. Az olvasottakat gondoljuk át, egy kicsit pihenjünk. A pihenés után vegyünk elı papírt és ceruzát, és fogjunk neki a tervezésnek. Ha a kísérletben elakadnánk, akkor vegyük elı ismét a könyvet, és nézzük meg a könyv megoldását.

Tervezzük meg a sokcélú oldal második lapját: (270. oldal 82. ábra) Azokat a vezérléseket, amelyeket a feladat korábbi részében már megter- veztünk, most csak jelezzük. Ezeket halványan jelöltük a tervben. A többi jellemzıinek beállítását felsoroljuk, mint azt az elızı részfeladat esetén is tettük.

A továbbiakban a programozási részt tervezzük meg. Tekintsük úgy

őrlapunkat, mintha csak most kezdtünk volna bele a tervezésbe. Ismét ír- juk le azokat a programlépéseket, amelyeket akkor kell végrehajtanunk, amikor az egyes vezérléseket használja a felhasználó.

Elsı lépés a kezdeti értékek beállítása legyen. Ezeket a beállításokat ismét az őrlap betöltésekor állítsuk be, vagyis ezekkel az utasításokkal bıvítsük ki a frmTextEszk őrlap Initialize eseményvezérelt eljárását. A korábban megírt részleteket halvány betővel írtuk le.

Ezután folytassuk azoknak a vezérléseknek a programozásával, amelyeknek a leírásában eseményeket használunk. Az eseményeket egy-egy programként írjuk meg.

A tervezés következı lépése az lesz, hogy az átalakítást végzı eljárást ki kell bıvítenünk azokkal az utasításokkal, amelyek a szöveg beszúrását elvégzik. Vagyis nem készítünk új eljárást, hanem a meglévıt írjuk to- vább. Most nem elemezzük végig a programtervezés lépéseit, csak a vég- eredményt írjuk le (de ne felejtsük el, hogy a program négy részbıl áll), majd elvégezzük a lehetséges összevonásokat.

Egyszerő szavakkal fogalmazzuk meg azokat a fel-

adatokat, amelyeket szeretnénk megvalósítani. A megfogalmazás olyan legyen, mintha mi képviselnénk a programunkat a felhasználó érdekében. Próbáljuk kitalálni azt, hogy a felhasználó mit csinál az általunk elé tárt esz- közzel. Az eszköz lehet őrlap, vagy munkalap. Tehát a feladat megfogalma- zása legyen egy elképzelt párbeszéd köztünk és a felhasználó között.

Egyszerően rajzoljuk le egy papírra azt a felhasználói felületet, amit a felhasználó elé fogunk tárni. Nem fontos, hogy a rajz milliméter beosztású papírra kerüljön. A könyvben így volt egyszerőbb elkészíteni a rajzokat. Tervezhetünk teljesen egyszerő sza- badkézi rajzzal is.

A rajzon adjunk nevet az összes alkalmazott ve- zérlésnek. A vezérlések neve tartalmazza azt, hogy milyen vezérlés típust használunk. Erre a név elsı három betőjét használjuk fel. Az elnevezések további része utaljon arra, hogy mire fogjuk használni az adott vezérlést.

A tervezésnek ebben a sza- kaszában írjuk le a vezérléseknek azokat a tulajdonságait, amelyeket még tervezési idıszakban ruházunk fel értékkel. Errıl készítsünk listát, amit majd a megvalósításkor felhasználhatunk. Ha már úgyis szemügyre

vesszük az összes alkalmazott vezérlést, gondoljuk át azt is, hogy az egyes vezérléseknek mely eseményeit fogjuk felhasználni a programban.

Ha találunk olyan programlépéseket, amelyek azonos szerkezetben, de más feltétel teljesülésekor kell alkal- maznunk, írjuk meg szubrutinként, vagy függvényként.

Azokat az eseményeket, amelyeket a tervezési idıszakban arra szántunk, hogy felhasználjuk, töltsük ki a megfelelı uta- sításokkal.

Ha szükséges az őrlapnak, vagy valamelyik vezérlés- nek kezdeti beállításokat meghatározni, akkor ezt írjuk le. Ha új eljárást kell létrehozni egy vezérlés mőködtetéséhez, akkor ezt is tervezzük meg.

Az eredmény a felhasználói felület rajza, a tulajdon- ságok beállítási listája és a saját szavainkkal leírt program lesz, vagyis a kész terv.

A terv elkészülte után még vár ránk a megvalósítás. Ez már csak technikai lépésekbıl áll. Létre kell hoznunk a projektet, a megfelelı őrlapokat, és a modulokat. Az őrlapra el kell he- lyeznünk a megfelelı vezérléseket és az elıre megtervezett el- járásokat le kell írnunk most már a kiválasztott programnyelven. Ez a mi esetünkben a Visual Basic for Application. Ehhez meg kell talál- nunk az adott nyelv megfelelı utasításait, függvényeit vagy objektumait, amelyek képesek elvégezni az általunk leírt mőveleteket. Ebben a fejezetben a következı kérdésekre kapunk választ:

♦ Hogyan alakítsuk át a programtervet programmá? ♦ Mit jelent a programkódolás? ♦ Milyen sorrendben valósítsuk meg a tervben leírtakat?

Azt a munkafolyamatot, amikor a saját szavainkkal leírt programlépése- ket átalakítjuk a kiválasztott programnyelv számára értelmezhetı utasí- tásokká, a program kódolásának nevezzük. A program kódolása után ne- kifoghatunk a tényleges megvalósításnak. Elsıként a felhasználói felüle- tet hozzuk létre. Létrehozzuk az őrlapot, vagy őrlapokat. Beállítjuk az őr- lap azon tulajdonságait, amelyeket tervezési idıben kell beállítanunk. Az őrlapra felrajzoljuk a megtervezett vezérléseket, és ezek tulajdonságait is beállítjuk.

Ezután - a program kódolása alapján-, a megfelelı helyre beírjuk azokat az eljárásokat, amelyeket az egyes vezérlések, vagy az őrlap esemé- nyeihez rendeltünk. Ha valamelyik eljárásban szubrutint hívunk, akkor a szubrutint még azelıtt meg kell írnunk, mielıtt a szubrutint hívó eljá- rást begépelnénk. A befejezı lépés a program belövése, a kipróbálás, és a hibák megkeresése.

A legegyszerőbbnek az kínálkozik, hogy a saját szavainkkal leírt eljárások szövegének egy részét magyarázatként használjuk a program kódolásakor. A projekt megfelelı moduljaiba - megjegyzésként - írjuk be a program lépé- seit, majd ezek közé a sorok közé beszúrjuk a tényleges parancsokat. Komo- lyabb kódoláshoz mindenképpen javaslom megfelelı Language Reference könyvek megvásárlását.

Kezdjük a legegyszerőbbel. Arra az eljárásra gondolok, amelyik megje- leníti az elkészített őrlapot. A nevét már tudjuk, hiszen ezt már a terve- zéskor meghatároztuk. Ennek az eljárásnak az egyetlen utasítássora az, hogy jelenítsük meg az őrlapot. Areferencia könyvben, a CD mellékletben vagy a súgóban keressük meg a UserForm objektum leírását. Ennek az objektumnak a leírásában megtaláljuk a tulajdonságok, a metódusok és az események felsorolását. Türelmesen olvassuk el a listát, és próbáljunk találni egy olyat, aminek a feladata az objektum megjelenítése. Erre leg- inkább a Show felel meg. Ezután keressük meg a Show metódus leírását. Olvassuk el, hogy milyen argumentumai vannak, mit kell beállítanunk. Ezután már le is írhatjuk az eljárást. Ez a következı lesz:

Sub PanelMegjelenit() "Jelenjen meg az frmTextEszk panel

frmTextEszk.Show End Sub

Most fogjunk egy nagyobb kódolási munkába. írjuk meg az átalakítást végzı szubrutin kódját. Elsı lépésként írjuk le az eljárás elsı utasítását.

Sub Átalakít()

Ezután keressük meg azt az utasítást, amivel végiglépkedhetünk egy tartomány celláin. Vagyis a következı mondatot kell átalakítanunk a program számára értelmezhetı utasítássá:

Mindaddig amíg a tartomány összes celláján végig nem értünk

Fedezzük fel azt, hogy ez egy olyan utasítás, ami addig ismétli a leírt uta- sításokat, amíg a meghatározott tartomány mindegyik celláján végig nem ér. Ennek lesz egy párja is, ami a ciklus végét jelzi. Ha egy kicsit visszagondo- lunk a tanultakra, akkor a programvezérlésrıl szóló fejezetben olvashattunk egy olyan ciklusról, amelyik végiglépked egy győjtemény elemein. Ez a For Each ciklus. Ennek a ciklusnak az alkalmazásához szükségünk lesz egy objektum típusú változó deklarálásához. Ez a változó fog a győjtemény elemé-

re mutatni. Ennek a változónak vagy objektum típusúnak vagy Range típu- súnak kell lennie. Ez legyen a következı:

Dim Cella as Range

Most nézzük a For Each ciklust. A ciklusszámlálónk már megvan, de ebben a ciklus-szervezésben azt is meg kell határoznunk, hogy melyik tar- tományban kell végiglépkedni a cellákon. Erre vonatkozólag a terv alap- ján a refTartomany vezérlésbe fog adatot írni a felhasználó. A teljes ciklus tehát a következı lesz:

For Each Cella In Range(refTartomany)

Next Cella

Eddig tehát a program kódolva így néz ki:

Sub Atalak.it ()

Dim Cella As Range 'Mindaddig amig a tartomány összes celláján végig nem 'értünk For Each Cella In Range(refTartomany)

'Következı cella

Next Cella

End Sub

Lépjünk eggyel beljebb az eljárásban. Itt egy elágazást találunk. Az el- ágazás feltétele az, hogy a sokcélú oldal melyik lapja az aktív. Mivel itt sokfelé — több mint kettı — ágazunk el, kézenfekvınek tőnik a Select Case elágazás használata. Ebben az elágazásban az mltTextEszk objektumról szeretnénk megtudni azt, hogy pillanatnyilag melyik lapja aktív. Tehát is- mét a nyelvi leíráshoz kell fordulnunk. Ez egy MultiPage objektum, így te- hát ennek a tulajdonságai között kell keresgélnünk. Hosszas keresgélés után - hiszen több tulajdonság leírását is végigolvastuk - kiderült, hogy nekünk a Value tulajdonságot kell felhasználnunk. A leírásból az is kide- rül, hogy a lapok számozása nullától kezdıdik. Ennek az elágazásnak a leírása tehát a következı lesz:

Select Case mltTextEszk.Value

'mltTextEszk elsı lapján áll a felhasználó

Case 0

'mltTextEszk második lapján áll a felhasználó

Case 1

'm l tTextEszk harmadik lap ján á l l a felhasználó

Case 2

End Select

Most folytassuk azzal a kódolást, hogy az elágazás egyes részeit dolgozzuk ki. A programtervben a sokcélú oldal els ı lapján meg kell vizsgál- nunk, hogy melyik választókapcsolót kapcsolta be a felhasználó. Ezt há- rom If utasítással valósíthatjuk meg.

If optKisBetu Then

Elself optNagybetu Then

Elself optTulNev Then

End If

Ezzel a módszerrel alakítsuk át az egész tervet Vis ual Basic utasítá- sokká. A további lépéseket most nem részletezzük vé gig. A teljes eljárás a következ ı lesz:

Sub Atalakit() Dim Cella As Range 'Mindaddig amig a tartomány összes celláján végig n em értünk

For Each Cella In Range(refTartomany)

Select Case mltTextEszk.Value

'mltTextEszk els ı lapján áll a felhasználó

Case 0 'Ha az optKicsi választó kapcsoló a kiválasztott

If optKicsi Then 'Az aktuális cella kisbet ővel

Cella.Value = LCase(Cella.Value)

'Ha az optNagy választó kapcsoló a kiválasztott

Elself optNagy Then 'Az aktuális cella nagy bet ővel

Cella.Value = UCase(Cella.Value) 'Ha az optTulNev választó kapcsoló a kiválasztott

Elself optTulNev Then 'Munkalap föggvény alkalmazása

'Az aktuális cella szavai nagy kezd ıbet ővel

Cella.Value = Application.WorksheetFunction.

Proper(Cella.Value)

End If

'mltTextEszk második lapján áll a felhasználó

Case 1 'Ha az optElore választó kapcsoló a kiválasztott

If optElore Then 'A txtPluszSzoveg text box tartalma a cellaszöveg

Cella.Value = txtPluszSzoveg & Cella.Value

'Ha az optVegere választó kapcsoló a kiválasztott

Elself optVegere Then 'A txtPluszSzoveg text box tartalma a cellaszöveg

Cella.Value = Cella.Value & txtPluszSzoveg

'Ha az optKoze választó kapcsoló a kiválasztott

Elself optKoze Then 'A txtPluszSzoveg text box tartalma adott helyre

Cella.Characters(txtSzovegHely, 0).Insert

txtPluszSzoveg

End If 'mltTextEszk harmadik lapján áll a felhasználó

Case 2 'Ha az optElolrol választó kapcsoló a kiválasztott

If optElolrol Then 'A cellaszöveg bal oldalának levágása

Cella.Value = Right(Cella, Len(Cella)

txtMinuszKar) 'Ha az optVegerol választó kapcsoló a kiválasztott

Elself optVegerol Then 'A cellaszöveg jobb oldalának levágása

Cella.Value = Left(Cella, Len(Cella)-

txtMinuszKar) 'Ha az optKozul választó kapcsoló a kiválasztott

Elself optKozul Then 'A cellaszöveg közepének kivágása

Cella.Value = Left(Cella, txtSzovHely) &

Right(Cella,Len(Cella.Value)-(Val(txtMinuszKar)

+ Val(txtSzovHely)))

End If

End Select

'Következ ı Cella

Next Cella

End Sub

Azoknak az utasításoknak a kódolásánál, amelyeket n em ismerünk és a referencia könyvben vagyunk kénytelenek utána néz ni a megfelel ı szin- taktikának, mindig annak az objektumnak a leírásátó l érdemes elindul-

ni, amelyiknek a tulajdonságát, vagy metódusát használjuk az utasítás- sorban. Miután megtaláltuk az objektumot, olvassuk végig az objektum tulajdonság listáját vagy metóduslistáját, és próbáljunk számunkra meg- felelıt találni. Ne felejtkezzünk meg arról sem, hogy ha az Excel referencia könyvben nem találunk számunkra megfelelı függvényt, akkor érde- mes szétnézni a munkalap függvények között is, ahogy ezt ennek a programnak a személynévvé alakítást megvalósító utasításában is tettük. A kódolást folytassuk az eseményvezérelt eljárások utasításainak meg- írásával. Ezeknek az eljárásoknak a nevét nem mi fogjuk meghatározni, hiszen ezek már léteznek az egyes objektumokhoz tartozó modulokban. Ezek a következıit lesznek:

Private Sub UserForm_Initialize() optKicsi = True refTartomány = Selection.Address mltTextEszk.Value = 0 optElore = True txtPluszSzoveg = "" txtSzovegHely = 1 txtSzovegHely.Enabled = false spiSzovegHely = 1 spiSzovegHely.Enabled = false optElolrol = True txtMinuszKar = 1 spiMinuszKar = 1 txtSzovHely = 1 spiSzovHely = 1 txtSzovHely.Enabled = false spiSzovHely.Enabled = false

End Sub

Private Sub cmdAlkalmaz_Click() Atalakit

End Sub

Private Sub cmdBezaras_Click() frmTextEszk.Hide

End Sub

Private Sub cmdRendben_Click()

Atalakit

frmTextEszk.Hide

End Sub

Private Sub optElore_Enter()

txtSzovegHely.Enabled = False

spiSzovegHely.Enabled = False End Sub

Private Sub optElorol_Enter()

spiSzovHely.Enabled = False

txtSzovHely.Enabled = False End Sub

Private Sub optKoze_Enter() txtSzovegHely.Enabled = True

spiSzovegHely.Enabled = True End Sub

Private Sub optKozul_Enter()

spiSzovHely.Enabled = True

txtSzovHely.Enabled = True End Sub

Private Sub optVegere_Enter()

txtSzovegHely.Enabled = False

spiSzovegHely.Enabled = False End Sub

Private Sub optVegerol_Enter()

spiSzovHely.Enabled = False

txtSzovHely.Enabled = False End Sub

Private Sub spiMinuszKar_Change() txtMinuszKar = spiMinuszKar

End Sub

Private Sub spiSzovegHely_Change() txtSzovegHely = spiSzovegHely

End Sub

Private Sub spiSzovHely_Change() txtSzovHely = spiSzovHely

End Sub

Private Sub txtMinuszKar_Change()

On Error GoTo MinuszTipHiba spiMinuszKar = txtMinuszKar

Exit Sub

MinuszTipHiba: If Err = 13 Then

txtMinuszKar = valTxtMinuszKar End If

End Sub

Private Sub txtMinuszKar_Enter() valTxtMinuszKar = txtMinuszKar

End Sub

Private Sub txtSzovegHely_Change() On Error GoTo TipusHiba spiSzovegHely = txtSzovegHely

Exit Sub

TipusHiba: If Err = 13 Then

txtSzovegHely = valTxtSzovegHely End If

End Sub

Private Sub txtSzovegHely_Enter() valTxtSzovegHely = txtSzovegHely.Value

End Sub

Private Sub txtSzovHely_Change() On Error GoTo TipHiba spiSzovHely = txtSzovHely

Exit Sub

TipHiba: If Err = 13 Then

txtSzovHely = valTxtSzovHely End If

End Sub

Private Sub txtSzovHely_Enter()

valTxtSzovHely = txtSzovHely

End Sub

Tegyük magunk elé az elkészült tervet. Lapozzunk az objektumok tulajdon- ságait leíró részhez. Töltsük be az Excel-t, kezdjünk egy új munkafüzetet. Mivel ezzel a munkafüzettel komoly szándékaink vannak, mentsük el.

Ezután kapcsoljunk át VBE-be, és a jelenlegi projektbe szúrjunk be egy új felhasználói őrlapot. Az egér jobb gombjával kattintsunk a projekt- ablakban a jelenlegi projekt egyik objektumára. A megjelenı helyi-menü- bıl válasszuk ki a Insert > UserForm utasítást.

Miután az őrlapot létrehoztuk, állítsuk be azokat a tulajdonságait, amiket korábban megterveztünk. Tehát ismét vegyük elı a tervünket, és lépésrıl lépésre hozzuk létre az egyes vezérléseinket, és a létrehozott ve- zérlések tulajdonságait állítsuk be a tulajdonságlista alapján. Az őrlap- nak például a Name és a Caption tulajdonságát kell meghatároznunk. Ne felejtsük el a pontos megnevezéseket, hiszen a programot úgy terveztük meg, hogy az utasítások ezekre fognak hivatkozni. Ezt a munkát mindenki önállóan végezze el. Miután ezzel végeztünk, jöhet a program vagy a kód beírása.

Az elsı eljárás amit megírunk az legyen, ami megjeleníti az őrlapot. Ezt egy új modulba írjuk meg. Tehát, hozzuk létre az új modult és írjuk bele a következı eljárást:

Sub PanelMegjelenít() 'Jelenjen meg a frmTextEszk panel frmTextEszk.Show

End Sub

Mentsük el a munkafüzetet, és írjuk be a további eljárásokat is. Most csak egy eljárást kell beírnunk, ez a fejezet korábbi részében kódolt Átalakít nevő rutin lesz. Mivel ezt az eljárást az őrlap parancsgombjai hívják meg, ezt az őrlap mögött elrejtett modulba fogjuk megírni. Ezt a modult úgy jeleníthetjük meg, hogy az őrlap területére kettıt kattintunk az egérrel. Ez az őrlaphoz rendelt modul sablon, amiben megtaláljuk az őrlap eseményvezérelt eljárásait. Most ezzel egyelıre nem törıdünk, hanem létrehozzuk az Átalakít eljárást. Ennek a módját már korábban meg- ismertük. Egyszerően begépeljük a következı utasítássort:

Sub Atalakit

A szöveg begépelése után leütjük az ENTER billentyőt, és a Sub utasí- tássor mögé elkezdjük beírni a kódolt programot. Ez tehát a gyakorlatban egy szövegmásolási feladat. Lehet, hogy a szövegek beírása közben ezt-azt elütöttünk. A program számára értelmezhetı utasítások írásmódját azonnal ellenırzi a program, de ha például valamelyik objektum vagy vezérlés nevét írtuk rosszul, akkor ez a beíráskor nem derül ki. A begépelést köve- tı lépés tehát a hibakeresés lesz. Ehhez hajtsuk végre a Debug > Compile VBAProject utasítást. Ha egyik-másik vezérlésre nem jó névvel hivatkoztunk, akkor ez az ellenırzés ezt felfedi. Ha tervezési hibára bukkantunk, akkor a hibajavítás eredményét vezessük át a tervbe is, hiszen ez a program dokumentációjának része lesz.

A tervezéskor használni szándékoztuk némelyik vezérlés eseményeit. Ezek az események már csak arra várnak, hogy beír- juk a megfelelı utasításokat. Legelsıként az őrlap Initialize eseményve- zérelt eljárásába írjuk be a szükséges sorokat. Ehhez kattintsuk kettıt az őrlap bármelyik pontjára. A megjelenı modulban a jobboldali listából ke- ressük ki az Initialize eseményt és a Sub és End Sub sorok közé írjuk be a tervezett kezdeti beállításokat. Természetesen a begépelt utasításokat lássuk el magyarázó szövegekkel, hogy a programot egy év múlva is meg- érthessük. Miután kitöltöttük a kiválasztott eljárást, ismét ellenırizzük le fordítással. Az ellenırzést nem okos dolog az összes utasítás beírása után elvégezni, mert így jóval nagyobb részt kell majd esetleg kijavíta- nunk, nehezebb dolgunk lesz.

Ez a pillanat az, amikor még reményünk van arra, hogy a programunk jól fog mőködni. Erre sok esélyünk van, de most egy olyan idıszak követke- zik, amikor lehetıleg mindent ki kell próbálnunk. Kicsit tekintsük az el- készült munkát ellenségnek. Minél inkább próbáljuk „átejteni", kifogni rajta. Minden részletét ellenırizzük mőködés közben. A helytelen mőkö- désrıl készítsünk listát, ami alapján majd a hibákat kijavíthatjuk.

Elıször még ne az legyen a cél, hogy különbözı tartományok szövegét átalakítsuk, hanem gyızıdjünk meg a felhasználói felület helyes mőkö- désérıl. Vagyis az a pillanat, amikor a Rendben vagy az Alkalmaz gombra kattintunk még várat egy kicsit magára.

Fentrıl lefelé, egyre mélyebb szintek felé haladva végezzük el az ellen- ırzést. Ennek megfelelıen az őrlapot megjelenítı eljárást kezdjük vizs- gálni. A VBE programot ne zárjuk le. Kapcsoljunk át az Excel-be és a Esz- közök (Tools) > Makró (Macro) > Makrók (Macros) utasítással indítsuk el az őrlap megjelenítését végzı eljárást. Ha az őrlap megfelelıen megjelent, akkor e mellé az eljárás mellé, a tervben jelöljük meg a jó eredményt.

Ugyanígy vizsgáljuk meg az őrlap lezárás mőködését is. Vagyis kattintsunk a Bezárás gombra.

Ismét töltsük be az őrlapot. Most a kezdeti beállítás mőködését fogjuk ellenırizni. A betöltés után válasszuk ki a sokcélú oldal lapjai közül a má- sodikat vagy a harmadikat. Hajtsunk végre olyan beállításokat, amelyek eltérnek a kezdeti beállításban meghatározott értékektıl. Ehhez használ- juk a kezdeti beállítás eljárás tervét. Mindent változtassunk meg. Ezután zárjuk le az őrlapot és ismét töltsük be. Az ismételt betöltés után vegyük elı a tervet, vagy a kódolt programot és ellenırizzük a teljes őrlapot. Ha minden megfelel a kezdeti beállításnak, akkor ez az eljárás jó. Ha így van, akkor ezt is dokumentáljuk.

Most gondoljuk magunkat a felhasználó helyébe és próbáljuk használatba venni az egyes vezérléseket. Kezdjük az egérrel. Ismét töltsük be az őrlapot és kezdjük az ellenırzést a sokcélú oldal vá- lasztógombjaival. Most felmerülhet a kérdés, hogy miért nem a sokcélú oldal lapjain kattintgatunk végig? Erre az a válasz, hogy ennek az ellenır- zése már megtörtént, amikor ezt a vezérlést megírták. Tehát az őrlap be- töltése után — mivel a kezdeti beállítás megfelelıen mőködik —, a sokcélú oldal elsı lapján állunk. Az egyes objektumok tulajdonságait ellenırizzük a tervben leírtak alapján. Húzzuk az egeret az egyes vezérlések fölé és el- lenırizzük, hogy a helyes tipp szöveg jelenik-e meg.

A tervbıl keressük meg azokat a vezérléseket, amelyeknek az esemé- nyeit programoztuk. Minden ilyen vezérlést ellenırizzünk le, hogy tény- leg az történik-e, amit mi szerettünk volna. A mi esetünkben például a léptetı vezérlések engedélyezése attól is meg kell hogy változzon, ha az egérrel kijelöljük. Ne felejtsük el kipróbálni a léptetı gomb és a hozzájuk tartozó szövegdobozok mőködését sem. Ezt minden esetben próbáljuk ki úgy is, hogy a szövegdobozba beírunk egy számot, és a léptetıvel tovább lépünk. Ha a szövegdobozba írt számtól folytatja a számolást, akkor jónak minısíthetjük.

Ellenırizzük le az őrlap mőködését arra az esetre is, amikor a felhasz- náló a billentyőzetrıl szeretné kiválasztani a megfelelı vezérléseket. A sokcélú oldal lapjai között CTRL+TAB leütésével válthatunk, Alapokon a vezérléseket az ALT és az aláhúzott bető kombinációja választja ki.

Ellenırizzük mindegyik szövegdoboz esetén, hogy mi történik, ha olyan adatokat írunk be, amire a programunk nem készült fel. Minden teszt lépés- rıl tudjuk, hogy mit használ. A tesztek eredményét minden esetben jegyez- zük fel.

A felhasználó az egyes vezérlések között a tabulátor billentyővel is mo- zoghat. Az egyes vezérlések közötti mozgás akkor jó, ha úgy lép át egyik vezérlésrıl a másikra a felhasználó, mint ahogy a könyv sorait olvassa. Ha ettıl eltér a bejárási úrvonal, akkor válasszuk ki a View > Tab Order utasítást és állítsuk be a megfelelı sorrendet.

Az ellenırzésnek ki kell terjednie minden adattípusra. Ezért nyissunk egy új munkafüzetet, és hozzunk létre egy olyan tartományt, ami tartalmaz képleteket, szövegeket, számokat, logikai értékeket. Ezen a tartomá- nyon vizsgáljuk meg az Átalakít eljárás mőködését.

Jelöljünk ki két-három sort, és egyelıre az Alkalmaz gomb használatával vizsgáljuk meg mi történik az adatainkkal. Kezdjük a kis- és nagybető vál- tással. Azt tapasztalhatjuk, hogy ez az eljárás a logikai értékeket átalakítja szöveggé, vagyis olyan eredménye is van az eljárásunknak, amit nem tervez- tünk bele. Mi lehet ennek az oka? Az, hogy az eljárásunk nem csak azokat a cellákat alakítja át, amiben szöveget talál. Ez nem szerencsés. Mit tehetünk ennek az elkerülésére? Azt, hogy a programba beépítünk egy vizsgálatot, ami csak azokon a cellákon hajtja végre a változtatásokat, amelyikben szö- veges adat van. Erre a munkalap függvények között találunk egy nagyszerő függvényt. A magyar változatban a függvény neve, SZÖVEG.E(). Mivel azt már láttuk, hogy a munkalap függvényeket felhasználhatjuk a programban is, már csak az a kérdés, hogy mi lehet a neve angolul, hiszen a VBA csak ezt a nyelvet ismeri. Erre egy nagyon jó szótárat találunk, ha megnyitjuk az Office programkönyvtárból a Funcs.xls fájlt. Ebbıl kinézhetjük, hogy az angol neve ISTEXT(). Ezt a függvényt használjuk fel a For Each ciklus elsı sora után. Ezt egy //utasításba beépítve kikerülhetjük azokat a cellákat, amelyekbe nem szöveges típusú adatot írt a felhasználó. Az If utasítás End If párját a For Each ciklust lezáró Next Cella utasítássor elé írjuk be.

A tesztelés közben arra lehetünk figyelmesek, hogy az őrlap többszöri használata során az őrlap nem úgy jelenik meg, mint azt a kezdeti beállí- tásban leírtuk. Ennek az oka az, hogy amíg nem töltjük be az őrlapot, addig az Initialize eseménye nem következik be. Azt gondolhatnánk pedig, hogy a betöltés megtörténik minden alkalommal amikor programból meg- jelenítjük az őrlapot. Akulcsszó a megjelenítés. Vagyis arról van szó, hogy

a megjelenítés és a betöltés nem ugyanaz. A Bezárás és a Rendben gombok kattintásra eseményeiben mi csak elrejtjük az őrlapot a Hide metódussal, de nem zárjuk le. Mit tehetünk? Két lehetıségünk van: az egyik az, hogy átírjuk a kezdeti beállításokat az Activate eseménybe, vagy amikor már nincs szükségünk az őrlapra, akkor nem csak elrejtjük, hanem le is zár- juk. Most válasszuk a második lehetıséget. A két parancsgomb kattintás- ra eseményében cseréljük ki a frmTextEszk.Hide utasítássort a követke- zıre:

UnLoad frmTextEszk

Ne felejtsük el letesztelni a munkánkat az adatok szempontjából sem. Ebben a részben próbáljuk meg azt, hogy egy tartományba beírunk egyen- lı hosszúságú szövegeket, álljon mondjuk mindegyik cella szövege tíz ka- rakterbıl. Ezután a következı helyrıl - txtMinuszKar - értékét szándéko- san állítsuk be tíznél nagyobb értékre. Erre a program futási idejő hiba- jelzéssel fog reagálni.

Felfedezhetünk még egy hibát, amikor ugyanis a törlés helyeként a - txtSzovHely — nagyobb értéket adunk meg mint a szöveg hossza, akkor is- mét az elızı hibajelzéssel találkozunk.

Hiba akkor is bekövetkezhet, ha a törlés helye és a törlendı karakterek számának az összege nagyobb mint az adott cellába írt szöveg hossza.

Ha ilyen — nagyobb módosítást igénylı — hibával találkozunk, akkor nem egyszerően kiegészítjük a programot a megfelelı utasításokkal, mint ahogyan azt az elızı hibák javításakor tettük, hanem magát a hibajaví- tást is megtervezzük. Ehhez érdemes elıvenni a tervnek azt a változatát, amit a saját szavainkkal írtunk le, és a kritikus részt újratervezni.

Ismét a saját szavainkkal fogalmazzuk meg a szükséges lépéseket. Te- hát ne a programot kezdjük foltozgatni, hanem a terv megfelelı részét gondoljuk át még egyszer. Az elsı lépésben még ne utasításokban gondol- kodjunk, hanem abban, hogy mit várunk el a megfelelı beállításoktól.

Ha például a szöveg elejérıl szeretne a felhasználó hosszabb szöveget törölni, mint a teljes szöveg hossza a cellában, akkor ki kell törölni a cella teljes tartalmát. Ugyanez a helyzet, ha a szöveg végérıl kell a programnak hosszabb szöveget eltávolítania, mint maga a szöveg. Tehát ebben az esetben is törölni kell a cella teljes tartalmát.

Gondoljuk át azt, amikor a törlés helyeként nagyobb számot állít be a felhasználó, mint a cellába írt szöveg hossza. Ebben az esetben módosítás nélkül kell hagyni a cella szövegét. Persze itt még egy probléma is adód- hat, amikor a helymeghatározás kisebb, mint a cellába írt szöveg hossza, de az adott helytıl kezdve olyan hosszúságú karakterláncot kell eltávolí- tania a programnak, ami túlmutat a szöveg végén. Ebben az esetben a tör- lés helyétıl a szöveg végéig törölnünk kell a felesleges karaktereket.

Ezeket a gondolatokat önállóan tervezzük meg. A megvalósított megol- dást a CD mellékleten található programban leellenırizhetjük. Tehát elı- ször megfogalmazzuk, majd módosítjuk a tervet, és kódoljuk, mintha egy új programot készítenénk.

Ha mindent ellenıriztünk és a felfedezett hibákat kijavítottuk, továb- bá feljegyeztük a javítás módját, akkor a dokumentáció elkészítése van már csak hátra.

Mindenképpen érdemes a tesztelés eredményeit más szempontból is át- gondolnunk. Most arra gondolok, hogy az okos a más kárán, mások hibái- ból tanul. Fogalmazzuk meg tévedéseinket, találjuk meg a tervezésnek azokat a pontjait, amire a következı tervek elkészítése során nagyobb gondot kell majd fordítanunk.

Az egyik tervezési hiba az volt, hogy nem gondoltunk arra, hogy csak olyan cellák tartalmára kell elvégeznünk a módosító mőveleteket, amelyekben szöveges típusú adatok vannak. Ez csak a tesztelés során derült ki, amikor a logikai értékeket tartalmazó cellákat is módosította a programunk. Az eredmény az lett, hogy a cellába írt logikai értékeket a program szöveges ér- tékekké alakította, a felhasználó nem kis bosszúságára. Ebben az esetben azt a hibát követtük el, hogy a tervezés folyamán csak a számunkra fontos szöveges adatokkal végzett mőveletekre koncentráltunk. Tehát már a terve- zési szakaszban is abból kellett volna kiindulnunk, hogy a felhasználó mit ír- hat a cellába, mert amit beírhat, azt be is írja...

A következı hiba az volt, amikor az őrlap ismételt megnyitása esetén a kezdeti beállításokat nem hajtotta végre a program. Ezt a hibát a kódolás- kor sikerült létrehoznunk, amikor az őrlapot úgy helyeztük használaton kívülre, hogy nem zártuk le, hanem csak elrejtettük. Ebben az esetben a terv jó volt, a kódolás nem. Ezt úgy kerülhettük volna el, ha pontosabban utánanézünk a felhasznált utasítás mőködésének.

A harmadik hibát — ami a legnagyobb beavatkozást igényelte — a karakterek törlését végzı programrészben találtuk. Ez azért keletkezett, mert nem tartottuk be azt az egyszerő programozási szabályt, hogy olyan mélységig kell elkészíteni egy program tervét, hogy azt ne lehessen kisebb utasításokra bontani, vagyis az elemi lépések szintjéig. Erre a program kódolása során kellett volna rájönnünk, hiszen itt olyan lépéseket kellett kódolnunk, amelyeket a tervben nem részleteztünk.

A CD mellékleten találunk egy jegyzetet, ami a programtervezés pontos lépéseit részletezi. A könyvben leírt módszer ennek nagyon leegyszerősített változata. Tehát aki szeretne több információt kapni a programtervezés esz- közeirıl, az olvassa el a CD mellékleten található Jackson modszer.pdf fájt.

A jelenlegi program tervezése során szándékosan maradtak benne a hibák, hogy a tesztelés során találjunk javítandó hibás részleteket. Nem lett volna célszerő rögtön egy jó megoldást közölni, hiszen akkor mit tesz- teltünk volna?

Ha elkészültünk az alkalmazással, akkor létrehozhatjuk azokat az eszközöket, amivel egy egyszerő felhasználó is birtokába veheti munkánk eredményét. Itt a billentyő-kombinációra, menüpontra és az eszköztár gombjára gondolok. A felhasználói eszközöket futási idıben érdemes lét- rehozni, a munkafüzet megnyitása - Open - eseményvezérelt eljárás fel- használásával. Esetleg elmenthetjük beépülı makróként, levédhetjük jel- szóval.

A könyvben nem fogjuk elkészíteni ennek a programnak a leírását, hiszen egész eddig errıl szólt ez a fejezet. Most csak a dokumentáció elkészítésé- hez szeretnék felsorolni néhány szempontot.

Az elsı kérdés az, hogy milyen dokumentáció készüljön? Mindenkép- pen kell készítenünk egy „mőszaki" leírást a munkánkról. Erre nekünk vagy más programozónak lehet szükségünk akkor, amikor valamilyen ok- ból változtatni kell a programon. Rendszerint ez csak magunknak szól, hiszen a program a mi szellemi termékünk, és rendszerint nem adjuk meg másoknak a módosítás jogát. Ennek a leírásnak olyannak kell lennie, aminek a segítségével bármelyik szakember képes megérteni a program mőködését.

Ennek az egyik része az amit mi tervnek neveztünk, a másik része pedig az, ami az utasítások sorai közé írt megjegyzésekbıl áll. A megjegyzé- seket, tehát nem felesleges rossznak kell tekinteni, hanem a dokumentá- ció részének. A tervezés során készített leírásainkat már csak rendbe kell tenni, átvezetni a tervezés óta bekövetkezett változtatásokat. Ehhez ér- demes hozzáfőzni a program kinyomtatott eljárásait, és egyéb automati- kus dokumentumokat. Ez fényképként szolgál a tényleges megvalósítás- ról, de önmaga nem helyettesíti a terv dokumentumot.

Nem szabad elfelejtenünk, hogy a legegyszerőbb program használata is komoly gondokat okoz a kezdı felhasználóknak. Soha ne kezeljük le se- melyik felhasználónkat azzal, hogy nem készítünk használati utasítást. Itt a lehetı legrészletesebben ki kell térni arra, hogy például milyen esz- közökkel lehet kiválasztani egyik vagy másik vezérlést, mikor mi törté- nik, ha ı végrehajt egy-egy mőveletet. A dokumentáció nyelvezetének köznapi nyelven kell szólni. Ez azt jelenti, hogy a használati útmutatóban nem azt kell bebizonyítanunk, hogy milyen okosak vagyunk, és hány angol szakkifejezést vagy annak rövidítését ismerjük. A tudásunkról az el- készült program mőködése, könnyen kezelhetısége fog majd tanúskodni.

A dokumentáció megjelenési formája többféle lehet. Nem csak papíron,

hanem a gépen is - Help formájában - adhatunk használati utasítást, de a legjobb, ha mindkét lehetıséggel élünk. A Help elkészítésérıl most nem beszélünk, mert ennek a könyvnek más a témája.

A dokumentációk elkészülte után már csak az marad hátra, hogy a fel- használókra bízzuk a továbbiakat, és örömmel töltsön el minket, hogy olyat alkottunk, ami sokak hasznára válik.

Oldjunk meg minél több önálló feladatot. Ehhez ad segítséget a könyv utolsó fejezete. Ebben a fejezetben csak kiírjuk a feladatokat, a megoldást nem adjuk meg. Ezt most önállóan a Kedves Olvasónak kell elvégeznie. A megoldások során el- lenırizhetjük azt, hogy mennyire sajátítottuk el az olvasottakat. A CD mellékleten kapunk egy kis útmutatást a megoldáshoz. Ha- csak lehet, ezt akkor használjuk, amikor elakadtunk a megoldásban vagy a tervezésben.

Természetesen a megoldásokat most is megkapjuk, de már nem a könyvben, hanem a CD mellékleten. A feladatok megoldásaiban a terve- zéskor a Jackson módszer jelölésrendszerét használjuk fel. Azoknak, akik nem ismerik a Jackson módszer jelöléseit javaslom olvassák el a CD mel- lékleten található 01 fejezet\Jackson modszer.pdf fájlban leírtakat. A feladatok megvalósítása során a Jackson módszer jelölési rendszerét hasz- náljuk. A megoldások megértéséhez szükségünk lesz erre az ismeretre.

A feladatok az elsıtól az utolsó felé haladva egyre összetettebbek lesznek. Az egyes megoldások egyre inkább megkövetelik azt, hogy a programokat megtervezzük.

Az egyes programok megtervezése elıtt mindig érdemes megismerkedni az objektumokkal, azok tulajdonságaival és metódusaival, amit felhaszná- lunk a programban. Ehhez készítsünk olyan makrófelvételeket, amelyek használják azt az objektumot, amire a programot építeni szeretnénk. Ez- után kicsit barátkozzunk, ismerkedjünk a kiszemelt eszközökkel.

Amikor az objektumokkal ismerkedünk, legjobb ha a kezünk ügyében van a program referencia könyv. Ha ez nem áll rendelkezésünkre, használ- juk a CD melléklet 02 Fejezet mappájában található fájlokat, vagy a súgót. Ebben nincs leírva az összes objektum, csak azoknak a leírására szorítkoz- tunk, amelyek a könyvben legalább egyszer szerepeltek. A melléklet tehát, a könyv példáinak megoldásaihoz elegendı ismeretet ad, de nem elég minden feladat megvalósításához. Ha komolyan szeretnénk foglalkozni az Excel programozásával, akkor mindenképpen szükségünk lesz egy teljes leírásra. Ehhez a kereskedelembıl szerezhetünk be angol nyelvő könyveket.

A példákat úgy oldjuk meg, hogy azok beépülı programként használ- hatóak legyenek. Vagyis minden program megírása során gondoskodjunk arról, hogy a felhasználó elérhesse a megírt programokat anélkül, hogy át kelljen kapcsolnia VBE nézetbe. Ehhez a helyezzük el a megfelelı menü- pontokat, vagy határozzuk meg a megfelelı billentyő-kombinációkat. Szükség esetén használjunk menü-utasításokat, eszköztárakra helyez- zünk el gombokat, és ha szükséges rendeljünk billentyő-kombinációt a megírt programhoz.

Gondoskodjunk arról is, hogy a projekt lezárása után visszaállítsuk az Excel eredeti állapotát.

Az elsı feladatban módosítsuk a CTRL+END billentyő-kombináció mő- ködését. Ez ugyanis már az Excel korábbi változataiban is érdekesen mő- ködött. Ennek a billentyő-utasításnak az a feladata, hogy kijelölje a leg- utolsó felhasznált cellát. Ezt úgy kell értenünk, hogy ha például az A3-as és a Dl-es cellába adatokat írtunk, akkor a legutolsó felhasznált cellának a D3-ast tekinti a program. Vagyis megkeresi a legutolsó sort és oszlopot, amiben adatot módosítottunk és ezek metszéspontjában található cellát választja ki.

Ez nem mindig jó! Próbáljuk ki mi történik akkor, ha mind az A3-as mind pedig a Dl-es cella tartalmát töröljük, és szeretnénk kijelölni a pillanatnyilag használt utolsó cellát. A törlés után is a D3-as cellát fogja az utolsó használt cellaként kijelölni.

Készítsünk egy olyan programot, ami CTRL+END leütése után a való- di utolsó cellát választja ki. A feladat megoldáskor ügyeljünk arra is, hogy a CTRL+END csak addig mőködjön a módosítottak szerint, amíg a programot tartalmazó munkafüzet be van töltve.

A feladat megoldásának kulcsa a munkalap objektum UsedRange tu- lajdonsága. A tervezés elıtt kicsit nézzünk utána a mőködésének.

Ezt és a következı feladatot egyetlen munkafüzetben, egyetlen projekt- ként oldjuk meg. Ez azt jelenti, hogy bizonyos eljárásokat a második feladat megoldása során már csak bıvítenünk kell. Erre a megoldás során minden esetben találunk utalást. A két feladat megoldását is egy leírás- ban találjuk majd meg.

A program terv: \21 Fejezet\Szerviz\Service.pdf

A megvalósított program: \21 Fejezet\Szerviz\ Service.xls \21 Fejezet\Szerviz\ Service.xla

Egészítsük ki a munkalap füleken megjelenı helyi menüt és a Formátum (Format) > Lap (Sheet) almenüt egy új utasítással. A neve legyen Üres lapok törlése. A feladata az lesz, hogy az aktuális munkafüzetbıl eltávolítsa azokat a munkalapokat, amelyek egyik cellájába sem írtunk adatot. Ennek a feladatnak a megvalósítására ismét a UsedRange tulajdonságot használjuk fel.

A program terv leírása: \21 Fejezet\Szerviz\Service.pdf

A megvalósított program: \21 Fejezet\Szerviz\ Service.xls \21 Fejezet\Szerviz\ Service.xla

A munkalapok jellemzıit úgy állíthatjuk be, hogy kiválasztjuk az Eszkö- zök (Tools) > Beállítások (Options) utasítást és a párbeszédpanel Megjele- nítés (View) lapján megtaláljuk a megfelelıbeállításokat. Ha ebben a panelben módosítjuk a beállítást, akkor az eredményt csak akkor fogjuk lát- ni, amikor a panel OK gombjára kattintunk. Készítsünk egy új párbeszéd- panelt, amelyik azonnal végrehajtja a megváltoztatott beállításokat. Ké- szítsük el a következı ábrán látható őrlapot:

Ennek az őrlapnak az lesz a feladata, hogy a megfelelı jelölınégyzet átkapcsolásának hatására beállítsuk a jelölınégyzet mellé írt állapotot. Például ki és bekapcsolhassuk a cellarácsokat, a munkalapfüleket, és a többi állapotot. Mindezt úgy hajtsa végre a program, hogy amint megvál- toztatjuk az egyik vagy másik jelölınégyzet állapotát, a megfelelı beállí- tás azonnal ennek megfelelı legyen. A Megjegyzések kombinált listában választhassuk ki a Nincs, Csak jelezve és a Megjegyzés és jelzése lehetısé- geket.

Ha a Bezárás gombra kattintunk, akkor az őrlap bezárása történjen meg. Ha a Minden lapra gombra kattintunk, akkor a jelölınégyzetek be- állított állapotának megfelelıen az aktív munkafüzet minden lapjára vo- natkozzanak a beállítások.

Ne felejtsük el azt sem, hogy az őrlap megjelenésekor az őrlap kapcso- lóinak a pillanatnyi állapotot kell tükrözniük.

A projekt betöltésekor helyezzünk el egy új menüutasítást az Eszközök (Tools) menüpont alá Munkalap beállítás... névvel, amit távolítsunk el a projekt lezárásakor.

A program terv leírása: \21 FejezetXGyors atkapcsolas\GyorsKapcs.pdf

A megvalósított program: \21 FejezetXGyors atkapcsolasX GyorsKapcs.xls \21 FejezetXGyors atkapcsolasX GyorsKapcs.xla

Egy adattartományban különbözı számértékek lehetnek. Szükségünk lehet arra, hogy kijelöljük azokat a cellákat, amelyek tartalma megfelel bizonyos feltételeknek. A kijelölés után a meghatározott cellákkal kü- lönbözı mőveleteket végezhetünk. Törölhetjük a cellák tartalmát, vagy bármilyen formai beállítással megformázhatjuk a kijelölt tartományokat.

Készítsünk egy segédprogramot, amelyik megjelöli azokat a számokat tartalmazó cellákat, amelyek megfelelnek a felhasználó által meghatáro- zott feltételeknek. A tartomány, amin a mőveletet elvégezzük attól függ, hogy a mővelet megkezdése elıtt mi volt kijelölve.

Ha csak egy cella volt kijelölve a mővelet megkezdése elıtt, akkor az aktív munkalap minden olyan celláján haladjon végig a program, amelyek szám állandókat tartalmaznak. Ha pedig a mővelet megkezdése elıtt a felhasználó kijelölt egy tartományt, akkor csak a kijelölt tartomány cel- láin lépkedjen végig a program.

Ha a kiválasztott területen nincs egyetlen olyan cella sem, amelyikben szám lenne, akkor a program üzenettel jelezze, hogy az adott tartomány nem tartalmaz számot.

A kijelölési feltételek meghatározása során a felhasználó választhas- son a következı összehasonlítási lehetıségek közül:

♦ egyenlı ♦ kisebb ♦ kisebb egyenlı ♦ nagyobb ♦ nagyobb egyenlı ♦ nem egyenlı ♦ értékek között ♦ értékeken kívül

Az elsı hat lehetıség esetén egy beviteli mezıben a felhasználó hatá- rozhassa meg azt az értéket, amivel a cellákba írt számokat szeretné összehasonlítani. Az „értékek között" és az „értékeken kívül" választás esetén pedig jelenjen meg két beviteli mezı, hiszen most két számértéket is meg kell majd határoznia a felhasználónak.

A két beviteli mezı közül a végérték meghatározására szolgáló mindaddig legyen szürke hátterő, amíg nincs rá szükség, és tiltsuk meg a kivá- lasztását is.

A párbeszédpanelen két parancsgomb is legyen, az egyik végrehajtja a kiválasztott beállításoknak megfelelı beállítást, és bezárja a párbeszéd- panelt, a másik pedig a mőveletek elvégzése nélkül zárja be a panelt. A párbeszédpanel a következıképpen nézzen ki:

A program eléréséhez helyezzünk el menüutasítást a cellák helyi me- nüjében és a Szerkesztés (Edit) menüpont alá Érték jelölése... szöveggel.

A program terv leírása: \21 Fejezet\Ertek jeloles\ErtekJelol.pdf

A megvalósított program: \21 FejezetXErtek jelolesX ErtekJelol.xls \21 FejezetXErtek jeloles\ ErtekJelol.xla

Részösszegek számítására az Excel alapállapotában is van lehetıségünk. Ha a beépített lehetıséget használjuk, akkor egyszerre csak egy oszlop szerint csoportosíthatunk, és egyszerre csak egy függvény használatára van lehetıségünk.

A párbeszédpanel csak akkor lesz kitöltve, ha egy adatterületre állunk és ott indítjuk el a programot. Egy ilyen elképzelt adatterületen állva az ábrának megfelelı módon fog megjelenni:

A feladatban úgy készítsünk párbeszédpanelt, hogy a felhasználó meg-

határozhassa azokat az oszlopokat, amelyek szerint csoportosítani szeret- né az adatait. A csoportosítási oszlopok száma ne egy legyen, hanem maximum három. Ezeknek az oszlopoknak a rendezését is végezzük el a részösszegek kiszámítása elıtt. Vagyis ne bízzuk a felhasználóra azt, hogy azokat az oszlopokat, amelyek szerint a csoportosítást meg szeretné valósítani, neki kelljen elıkészíteni egy rendezéssel.

Minden csoporthoz lehessen egyszerre több részösszeg függvényt is használni. Vagyis egy-egy újabb függvény alkalmazásához ne kelljen újra indítani a részösszeg készítés mőveletét. A függvényeket csoportosítási

oszloponként lehessen beállítani. Vagyis minden csoportosítási szinthez egyedileg meghatározott számításokat lehessen beállítani.

Az összegzendı oszlopokra a program tegyen ajánlatot. Alapértelme- zés szerint azokat az oszlopokat kínálja fel számításra, amelyeknek a má- sodik sorában számot talál. Ez azért lehet hasznos, mert a részösszeg ké- szítést rendszerint listába szedett adatokon szokás végrehajtani. Ha lis- tánk következetes, akkor az egyes oszlopokban azonos típusú adatok lesznek. Az elsı sor a fejléc sor, tehát itt valószínőleg csak szöveges adatok lesznek. A második sorban azonban már adatok vannak, amibıl kiderül, hogy melyik oszlopban tároltunk számokat és melyikben szöveges adatokat. Természetesen ezt csak alapértelmezettként kínálja fel. Ezen a fel- használó tetszés szerint változtathasson.

A program kezelését úgy biztosítsuk, hogy lecseréljük az Adatok (Data) > Részösszegek (Subtotals) menüpont mőködését.

A program terv leírása: \21 Fejezet\Reszosszegek\Reszosszegek.pdf

A megvalósított program: \21 FejezetX Részösszegek \ Reszosszegek.xls \21 FejezetX Részösszegek \ Reszosszegek.xla

. 01010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010 1010101010101010101

0101010101010101010101010101010101010101010101010 10101010101010101010101010101010101010101010101010101010101010101010101 01010101010101010101010101010101010101010 1010101010101010101010101010101010101010101010101010101010101010101010101010101 01010101010101010101010101010101010 10101010101010101010101010101010101010101010101010101010101010 10101010101010101010101 010101010101010101010101010101010 101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 0101010101010101010101010101010 10101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 01010101010101010101010 10101010 10101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010 101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010 1010101010101010101010101010101010101010101010 101010 10101010101010 101010101010101010101010101010101 01010101010101010 101010101010101010101010101010101 010101010101010101010101010101010101010 1010101010101010101010101010101 01010101010101010 101010101010101010101010101 0101010101010101 010101010101010101010 10101010 10101010 10101010101010101010101 010101010101010 1010101010101010101010101010101 0101010101010101010101010101010101010101010101010 1010101010101010101010101 0101010101010 101010101010101010101010101010101 010101010101010101010101010101010101010101010101010 10101010101010101010101 01010101010 10101010101010101010101010101010101 01010101010101 010101010101010101010101010101010101010 101010101010101010101 010101010 1010101010101010101010101010101010101 01010101010101010101010101010101010101010101010101010 101010101010101010101 0101010 10101010101010101010101010101010101 0101010101010101010101010101010101010101010101010101010 10101010101010101010101 0101010 10101010101010101010101010101010101 0101010101010101010101010101010101010101010101010101010 10101010101010101010101 010101010 101010101010101010101010101 010101 010101 01010101010101010101010101010101 01010101010101010 10101010101010101010101 0101010 1010101010101010101010101010101010101010101010101010101010 101010101010101 01010101010101010 10101010101010101010101 0101010 101010101010101010101010101010101 0101010101010101010101010101010101010101 01010101010101010 10101010101010101010101 010101010101010101010101010101010101010101 0101010101010101010101010101010101010101010101010101010 10101010101010101010101 010101010101010101010101010 1010101010101010101 0101010101 01010101010101 010101010101010101010101010 10101010101010101010101 0101010101010101010101010101010 1010101010101010101 010101010101010101 010101 0101010101010101010101010101010101010101010101 010101010101010101010101010101010 1010101010101010101010101010101010101 01010101010101010101010101010101010101010101010101 0101010101010101010 1010101010 1010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 0101010101010101010101010101010101010 101010101010101010101010101010101010101010101010101010101010 10101010101010101010101 0101010101010101010101010101010 101010101010101010101010 10101010101010101010 10101010101010 1010101010101010101010101010101 0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010 10101010101010101010101010101 01010 1010101010101010101010101010101010101010101010101010 101010101010101010101010101010101010101010101010101010101010101 01010 101010101010101010101010101010101010 10101010101010 1010101010101010 1010101010101010101010101010101010101010101010101 01010 1010101010101010101010101010101010101010 101010101010 101010101010 101010101010101010101010101010101010101010101010101 0101010 101010101010101010 1010101010101010101010101010101010101010 1010101010101010101010101010101010101010101010101010101 0101010 1010101010101010101010101010101010101010 10101010101010101010101010101010 10101010101010101010101010101010101010101 010101010 101010101010101010101010101010101010101010101010 10101010101010101010 1010101010101010101010101010101010101010101 01010101010 1010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 0101010101010 10101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010 10101010101010101010101010101010 1010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010 101010101010101010101010101010101010101010 101010101010101010101010101010101010101010101010101010101010101 01010101010101010 101010101010101010101010101010101010 1010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010 101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 01010101010101010101010 1010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010 1010101010101010101010101010 ©m(2009) 10101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010 101010101010101010101010101010101010101010101010101 010101010101010101 010101010101010101010101010101010101010101010101010 101010101010101010101010101010101010101010101010101 010101010101010101