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 mentjük el, nyomtatjuk ki, vagy Word-ben az aktív bekezdés jellemzıit változtatjuk meg. Felhasználóként tehát fontos, hogy aktívvá tegyük azt az objektumot, amelyikkel mőveletet végzünk. Az elızı fejezetben olvastunk az objektumokba zárt változókról, eljárásokról. Ezekhez csak az objektum- interfészen keresztül férhetünk hozzá. Az interfész elsı részében az objektumra kell hivatkozunk. Fontos megjegyezni, hogy programozáskor nem csak az aktív objektummal végezhetünk mőveletet, hanem bármelyikkel, amelyikre hivatkozni tudunk. ♦ 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 állnak. A Word-öt szemlélve hasonló rendszert fedezhetünk fel. A Word alkalmazásban dokumentumok vannak, a dokumentumokban bekezdések. Itt is felfedezhetjük az alá- fölérendeltségi viszonyt. Az objektum rendszer legfelsı szintjén minden Office programban maga az alkalmazás áll. Ennek minden alkalmazásban azonos a neve: Application. Ha tehát bármely Office alkalmazás programozásakor leírjuk az Application szót, magához az adott alkalmazáshoz szólhatunk. Excel esetén az Excel-hez, Word esetén a Word-höz, a PowerPoint esetén pedig a PowerPoint-hoz. Az alkalmazásokban a következı eggyel alacsonyabb
Elsıként egy formai jegyet érdemes megfigyelnünk. A győjtemények nevei minden esetben többes számban vannak. így a munkafüzetek neve Workbooks, a munkalapoké Worksheets a celláké Cells. Minden elnevezés az angol nyelv többes szám ragjával, az s-sel végzıdik. Ha például szeretnénk megtudni, hogy hány munkafüzet van nyitva az Excel-ben, vagy egy adott munkafüzet hány munkalapból áll, akkor a győjteményre kell hivatkoznunk. FuzetSzam = Workbooks.Count LapSzam = Worksheets.Count
A fenti két példában megszámoltuk két győjtemény elemét. Ezeket egy-egy változóban tároltuk. Az elsı programsor az Excel-ben megnyitott munkafüzeteket számlálta meg, a második az aktív munkafüzet munkalapjainak számát írta a változóba. Most nézzük meg azt is, hogy a győjtemény egyik elemét kiszemelve hogyan kell leírnunk a hivatkozást. Erre a győjtemény Item tulajdonságát használjuk. Nézzük meg, hogy az aktív munkafüzet egyik munkalapjára hogyan lehet rámutatni. Erre két módszert is biztosít az Excel. Az egyik esetben a győjtemény sorszámát, a másik esetben a nevét használjuk. Neve = Worksheets.Item(l).Name Neve = Worksheets.Item("Munkai").Name
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 munkafüzetek, vagy a munkafüzetben található munkalapok. Idınként egyszerre kell hivatkoznunk az összes megnyitott munkafüzetre, máskor pedig egy kiszemelt munkafüzettel végzünk mőveleteket. Azok az objektumok, melyeknél néha egy elemre, máskor meg egyszerre az összesre lehet hivatkozni, a győjtemények. Ez mindjárt felvet egy kérdést. Azt, hogy hogyan hivatkozhatunk a győjtemények összes elemére egyszerre, vagy az összes közül egyre.
Mindkét parancs a Neve változóba írja annak a munkalapnak a nevét, amire hivatkoztunk. Mégis mi a különbség a két hivatkozás között? Az elsı esetben a győjteményben elfoglalt helyének megfelelı sorszámot írtuk be az Item tulajdonság zárójelei közé, míg a másik esetben szövegállandóként - idézıjelek közé - a munkalap nevét. Az elsı parancs tehát a munkafüzet sorrend szerinti elsı munkalapjának nevét írja a Neve változóba. Itt a munkalap helye a meghatározó. A második parancssor a Munkai nevő munkalap nevét tárolja. A második hivatkozás esetén mindegy, hogy a munkafüzetben fizikailag hol található a Munkai nevő munkalap. Legyen bárhol, a munkafüzetben, elvégezhetjük vele a megfelelı mőveletet. A győjtemény egy elemére tehát hivatkozhatunk a helye vagy a neve szerint. Mivel a győjtemények elemeire gyakran kell hivatkoznunk programjainkban, ezért a Visual Basic megenged egy rövidebb írásmódot is. Ilyenkor nem kell beírnunk az Item tulajdonság nevét. Az elızı két parancs tehát a következı írásmóddal is teljesen helytálló: Neve = Worksheets(1).Name Neve = Worksheets("Munka1").Name
Ennél az írásmódnál nem írjuk be az Item tulajdonság nevét, de még a tulajdonságok elválasztására használt pont operátort sem. Egyszerően a győjtemény neve mögötti zárójelek közé beírjuk a győjtemény elemének azonosítására szolgáló értéket. Programozáskor rendszerint ezt az írásmódot használják a rövidsége miatt. Programozási szakkönyveket olvasva gyakran találkozhatunk azzal, hogy egy győjtemény egy elemére - például egy adott munkalapra - a könyv egyes számban szól. Valahogy így: Állítsuk be a munkalap (Worksheet) Name tulajdonságát egy adott értékre. Ez kissé zavaró lehet, mert azt gondolhatnánk, hogy úgyis hivatkozhatunk, hogy Worksheet. Nem! Ez csak annyit jelent, hogy a győjtemény egy elemére mutatunk rá, az elı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 tartomá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: W o r ks h e e t s ( " M u n ka 2 " ). R a ng e ( " A l " )
=
"E xc e l "
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 meghatároznunk, mert az éppen aktív volt. Ha nem a neve, hanem a sorszáma szerint szeretnénk hivatkozni egy munkalapra, akkor ezt a következı módon tehetjük meg: Wo r ks he e ts (2 ).R an ge( " A l " )
=
"Excel"
Most írjuk be az Excel szót a Munkafüzet 2 - éppen nem aktívmunkafü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 s h e et s ( 2 ) . R a n ge(" Al" )
=
"Excel"
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 Excelben 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églalapjai olyan objektumokat jelölnek, amelyeket győjteményként érhetünk el, az ellipszisek pedig olyanokat, amelyeket egyszerő objektumként. Itt felfedezhetjük azt is, hogy a győjtemények neveit többes számban, míg az objektumok neveit egyes számban olvashatjuk. A „közönséges" - nem győjteményként kezelt - objektumokra egyszerően a nevükkel hivatkozhatunk. A nevük után, ponttal elválasztva beírhatjuk a használni kívánt tulajdonság vagy metódus nevét. Ha például az Excel alkalmazás nevét szeretnénk egy változóban tárolni, akkor ezt a következı módon írhatjuk a programunkba: ProgNeve = Application.Name
Itt nincs Item tulajdonság és nincs zárójel az objektum neve mögött. Az objektumdiagram jól szemlélteti, hogy az objektumok miként viszonyulnak egymáshoz. Láthatjuk azt, amirıl eddig olvastunk, hogy az alkalmazásban (Application) találjuk a munkafüzeteket (Workbooks) és ezen belül a munkalapokat (Worksheets). A győjtemények jelölését érdemes egy kicsit jobban is szemügyre venni. A győjtemények esetén nem tudhatjuk elıre, hogy hány eleme lesz. Ezért jelölik csak a győjteményeket. Ezt úgy kell értelmeznünk, hogy egy-egy győjteményt jelölı téglalap tartalmazza a győjteményt és annak elemeit is. Amikor azt látjuk, hogy a Workbooks győjtemény magában foglalja a Worksheets győjtemény elemeit, azt úgy kell értenünk, hogy a Workbooks győjteményen belül van a munkalapok győjteménye és az összes eleme. Más szóval egy munkafüzetben sok munkalap lehet, és benne van az összes lap összes eleme, ami az adott munkafüzethez tartozik. Ezt a diagram áttekinthetısége miatt ábrázolják így. Az itt közölt objektumdiagramot jól felhasználhatjuk a programozási feladatok megoldása közben.
Ha tehát programból szeretnénk mőveletet végezni egy munkafüzettel, munkalappal vagy cellával, akkor hivatkoznunk kell rá. A hivatkozást minden esetben ahhoz a ponthoz viszonyítjuk, amelyik aktív. Az éppen aktív objektum hivatkozását nem kell leírnunk, ezt alapértelmezettnek tekinti a program. Az objektumok rengetegében az objektumdiagram segítségével tájékozódhatunk. Ha szeretnénk megismerni az Excel programozását, az egyik legfontosabb teendınk, hogy megismerjük az Excel objektumait. Ez fáradtságos és hosszadalmas munka. A legnagyobb segítség a megismerés 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 munkafüzeteinket más nézıpontból láthatjuk. Ebben a nézetben a munkafüzet neve Projekt. A VBA programok projektekre épülnek, a projekt tehát egy programozási egység. A projektek modulokat tartalmaznak, ahova megírhatjuk azokat a programokat, 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íthatunk. Töltsük be az Excel-t és indítsuk el. Betöltés után hajtsuk végre az Eszközök [Tools] > Makró [Macro] > Visual Basic Editor utasítást. A kiadott parancs hatására megjelenik egy újabb program. Ez a Visual Basic Editor. Az eredményt a 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 (tulajdonsá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 objektumára! 2. Megjelenik az objektumhoz tartozó osztálymodul. A megnyitott modulba egyenlıre még semmit nem írunk, de ez lesz az egyik hely, ahova majd a programjainkat, más szóval a makróinkat írjuk. A modul egy olyan felület, melyben egyszerő szövegszerkesztési módszerekkel írhatjuk meg eljárásainkat, programjainkat. Egy megnyitott modult a modul ablak jobb felsı sarkában található x-szel tehetünk láthatatlanná, így nem lezárjuk, csak elrejtjük. A programozás során szükségünk lehet további modulokra, vagy felhasználói őrlapokra. Ezek is az adott projekt részei lesznek. Ez egyben azt is jelenti, hogy amikor elmentünk egy Excel munkafüzetet, vele együtt mentjük a projektbe beépített modulokat és az azokba megírt eljárásokat. Az általános - vagy más szóval felhasználói - modult nekünk kell majd a projektbe illeszteni. A mőveleteket a következık szerint hajtsuk végre. A lépések megértését segíti a 46. oldal 8. ábrája. 1. A Projekt ablakban jelöljük ki annak a projektnek bármely objektumát, amelybe az új modult szeretnénk létrehozni. 2. Hajtsuk végre az Insert > 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 munkafü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 munkafüzet elmentése nélkül is tárolhatjuk a kiválasztott modult a háttértárolónkon. Erre vonatkozó utasítást találunk a File menüpont alatt is. Az elmentett fájl típusa *.bas lesz. Ezt a modult késıbb más Office alkalmazásokban vagy a Visual Basic 6.0-ban felhasználhatjuk. Tehát az egyik pro-
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. Aprojekt ablakban az egér jobb gombjával kattintsunk arra a projektre, amelyikbe szeretnénk betölteni egy modult. A helyi menübıl válasszuk ki az Import File utasítást. Keressük meg a korábban elmentett modult és töltsük be. A modul betöltésével együtt a benne megírt eljárásokat is betöltöttük, így az újabb projektben (dokumentumban) már nem kell megírnunk ezeket az eljárásokat. Ha valamilyen okból feleslegessé válik egy általunk létrehozott modul, akkor azt törölhetjük a projektbıl. Ismét az egér jobb gombjának vesszük hasznát. A helyi menüben megtaláljuk a Remove XXX utasítást. Egy modul eltávolításakor megjelenik egy kérdés az esetleges mentésre vonatkozóan. Itt eldönthetjük, hogy más projektek részére félretesszük-e a törölni kívánt modult vagy sem. Tehát a Project ablak felelıs a projektben elhelyezett modulok kezeléséért. A projekt ablakban vehetünk fel újabb modulokat, vagy itt jeleníthetjük meg az Excel objektumokhoz rendelt osztálymodulokat.
A projekt segédablak alatt találunk egy másik ablakot. Ez a Properties window, magyarul tulajdonság ablak. Amint a projekt ablakban megváltoztatunk egy Excel objektum kijelölését, megváltozik a tulajdonság ablak tartalma is. Itt mindig annak az objektumnak látjuk a tulajdonságait, amelyiket a projekt segédablakban kijelöltük. Ezek azok a tulajdonságok, amelyeket a programozás során is fel fogunk használni. Ennek a segédablaknak az a szerepe, hogy beállíthassuk azokat a tulajdonság értékeket, amiket az egyes általunk írt program futása elıtt szükséges meghatároznunk. Ennek az ablaknak leginkább az egyedi, felhasználói őrlapok készítésekor fogjuk hasznát venni.
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 kiadhatunk Visual Basic utasításokat, amelyeket az ENTER billentyő leütése után azonnal végre is hajt a program. Ezt a lehetıséget a késıbbi ismerkedés során mi is kihasználjuk. 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 hasonlít a Locals Window-hoz, azzal a különbséggel, hogy itt meghatározhatjuk, hogy mely változókat és kifejezéseket szeretnénk figyelni. Bekapcsolni a View > Watch window utasítással lehet. Bármely segédablakot a jobb felsı sarokban található x-szel zárhatunk be. Egyelıre elégedjünk meg ennyivel, de a késıbbiekben részletesen 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, miközben programot írunk egy modulba. Egy üres munkafüzetbe készítsük el elsı eljárásunkat - ennek kapcsán megismerkedhetünk néhány szerkesztési lehetıséggel. Ha van már új munkafüzetünk - ez a programozás szempontjából egy új projekt -, akkor térjünk vissza a VBE programba. A programozási könyvek többségében az elsı feladat a „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é utasítást. A megjelenı modulba gépeljük be az elsı programunkat, de közben figyeljünk mindarra ami a beírás közben történik. 1. A program beírását kezdjük el azzal, hogy írjuk le a sub ElsoMakro szöveget, mintha csak egy szövegszerkesztıben lennénk.
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.
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állunk a Sub utasítássorba és leütjük az F5-ös funkcióbillentyőt. Ennek nagy hasznát fogjuk venni a programozás során, mivel az eljárásokat többször is el kell indítanunk, hogy ellenırizhessük mőködésüket. Minél gyorsabban el tudjuk indítani az ellenırzendı eljárást, annál kevesebb idıt fogunk tölteni a programban elkövetett hibák keresésével. A Visual Basic Editor további szolgáltatásait, lehetıségeit majd a gyakorlatok során fogjuk részletesebben megismerni.
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.
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 Project ablak a modulok kezelését teszi lehetıvé, a tulajdonság ablak az épp kijelölt objektum tulajdonságait jeleníti meg. Az Immedate, a Locals és Watch ablakok a program belövését szolgálják. Ezek használatáról részletesen olvashatunk a program finomítása fejezetben.
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. Már megbeszéltük, hogy a programozás célja az adatfeldolgozás automatizálása. Ennek tükrében ismerkedjünk meg a változók és az állandók használatával. A feldolgozandó adatokat „kézbe kell vennie" a programnak. Ehhez az adatokat változókban tároljuk. Tudnunk kell, hogy milyen adatokat tárolhatunk a változókban, és hogy milyen lehetıségeink vannak a változók használatára. A fejezet kérdései a következık: ♦ 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?
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 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ékeket írhatunk bele. A változók típusát három kategóriába sorolhatjuk; a numerikus — számokat tartalmazó —, a string — szöveget tartalmazó — és az egyéb adattípus, amely egyik elızıbe sem illik bele.
A numerikus változótípusban számokat tárolunk. Amikor helyet foglalunk egy változónak, szeretnénk minél kisebb memória területet felhasználni erre a célra. Azért arra ügyeljünk, hogy a lefoglalt területen minden lehetséges értéket el tudjunk helyezni. Minél kisebb területet foglalunk le
A String adattípusú változókban szöveges adatokat - karakterláncokat - tárolhatunk. A karakterlánc jelentése nem más, mint tetszıleges karakterekbıl álló betősorozat. Az angol string szó láncot jelent, innen a típus elnevezése. A változó hossza a benne tárolt karakterek számától függ. A tárolható karakterek kódjának 0 és 255 közé kell esnie. A String típusú változóban a leghosszabb tárolható szöveg 231 betőbıl állhat. Ha szükséges, elıre meghatározhatjuk a tárolható karakterek számát. Ebben az esetben a változóban tárolt karakterlánc hossza nem lehet több, mint amekkorát elıre meghatároztunk. A rögzített hosszúságú karakter-
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 szeretnénk adni. Nézzük meg azt az utasítást, amelyben a strNeve változónak értéket adunk:
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ározzuk meg a változó típusát, az Variant lesz. Tehát ezt az adattípust kétféleképpen is meghatározhatjuk. A következı két típus meghatározás eredménye azonos: Dim varVegyes_l Dim varVegyes_2 As Variant
strNeve = "Kovalcsik"
A programban használt logikai kifejezések eredményét logikai változókban tárolhatjuk. A dátumok feldolgozásához rendelkezésünkre áll egy dátum változótípus. Bizonyos esetben pedig nem tudjuk elıre, hogy milyen típusú lesz az adat, amit a változóban tárolni fogunk. Láttuk, hogy amikor egy objektumra hivatkozunk, a hivatkozás hosszú is lehet. Ezeket a hivatkozásokat rövidíthetjük le, ha változóban tároljuk a hivatkozást. Ahhoz, hogy a felsorolt adatokat tárolhassuk, szükségünk van olyan adattípusokra, melyek ezt lehetóVé teszik. A logikai változók csak kétféle értéket vehetnek fel. Logikai igaz értéket - TRUE-, vagy hamis értéket - FALSE. A Visual Basic két bájt hosszúságú területet foglal le a Boolean adattípusú változók számára. A logikai változótípus meghatározására a következı utasítást írjuk a programba: 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ı:
A változók adattípusát meghatározhatjuk úgy is, hogy a változónevet egy típus meghatározó karakterrel zárjuk be. A típus meghatározó karakterek ugyanúgy meghatározzák a változó típusát, mint az As kulcsszó mögé írt típusnév. Ennek megfelelıen az As kulcsszót és típusnevet nem használhatjuk egy olyan változó esetén, amelyet típus meghatározó karakterrel fejeztünk be. Egy szöveg típusú változót például így is meghatározhatunk: Dim Szoveg$
A változónév mögötti $-jel a típus meghatározó karakter. Ez egyenértékő az As String típus meghatározással. A Visual Basic nyelvben a következı típus meghatározó karaktereket használhatjuk: A 2. táblázat harmadik oszlopában felsorolt deklarálások soronként azonos adattípust határoznak meg. A többi változótípusnak nincs típus meghatározó karaktere.
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.
Dim strDolgozoVezetekNeve As String
vagy aláhúzással Dim strDolgozo_vezetek_neve As String
Amikor változót deklarálunk, akkor nem teszünk mást, mint helyet foglalunk az operatív tárban. Mivel a Visual Basic egy magas szintő programnyelv, nem kell tudnunk, hogy fizikailag hol is lesz az a hely, amit lefoglaltunk. A lefoglalt helyre a változó nevével hivatkozunk.
A változók 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 kulcsszó sem. Ha a változó nevében szeretnénk megjelölni, hogy milyen a változó adattípusa, akkor érdemes a változónév elsı három betőjét erre felhasználni. Ezt az elsı három karaktert prefixnek nevezzük. Ezt az elnevezési módot az angol nyelvő programozási szakkönyvek magyar módszerként említik. Természetesen nem ezért érdemes használni. A prefixszel ellátott változó használata sok esetben egyszerőbbé teszi a kész program olvasását. Egy szöveg típusú változót például érdemes a következıképpen meghatározni: Dim strSzoveg As String Ha a program olvasása során bármikor találkozunk ezzel a változóval, tudni fogjuk róla, hogy szöveg tárolására alkalmas. Ha a változó neve több szóból állna, akkor — mivel a névben nem lehet szóköz —, vagy kezdjünk minden szót nagybetővel, vagy helyettesítsük a szóközt aláhúzás karakterrel. Például:
Ezek persze csak ajánlások, de valóban támogatják a program olvasható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áltozót, amikor arra szükség van. Ilyenkor a program futás közben foglal helyet a változónak. Egyszerő, de nem biztonságos! Nézzük meg, íme: Sub ErtekBekerese() 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áltozónak az értékét. Igen ám, csakhogy elírtuk a változó nevét. Nem nagyon, csak éppen az ékezet hiányzik az „a" betőrıl. Mi fog történni, amikor a program végrehajtja az utasítást? Implicit módon deklarál egy másik változót, aminek a neve Szam lesz, és rögtön meg is növeli annak értékét
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 csoportba sorolhatjuk. Az egyik esetben a hiba abból származik, hogy egy parancsot, vagy kulcsszót elírtunk. Ezt gyorsan kijavíthatjuk, mert a Visual Basic ezt felfedezi, és amint kilépünk a sorból, pirosra színezi a hibás sort. Az ilyen hibákat szintaktikai hibának nevezzük. A másik hiba, amit a programozás logikájában ejtünk, a szemantikai hiba. Ezt már nehezebb felismerni, és ennek megkeresésében a Visual Basic sem tud segíteni. Ezeknek a hibáknak a kiküszöbölése hosszas keresgélést igényel. A logikai hibák elkövetésének egyik leggyakoribb oka az implicit deklarációból adódik.
Önmagában az explicit deklarálás még nem megoldás. Ki kell adnunk egy modul szintő parancsot, hogy a VB figyelje a nem deklarált változókat. Ehhez az eljárásokon kívül valahol a modul elejére be kell írnunk az Option Explicit parancsot. Amelyik modulban szerepel ez a sor, ott a program figyelmeztet, ha nem deklarált változót használunk. Ha tehát minden modulban kérjük a változók figyelését, akkor minden modul elején szerepelnie kell az Option Explicit parancsnak. Ha ez a parancs szerepel a modulban, akkor a Visual Basic, a program lefordítása közben, ellenırzi a változók nevét. Ha olyan változót talál, amelyet korábban nem deklaráltunk, akkor leáll, hibát jelez és megjelöli a hibás sort. Beállíthatjuk úgyis a Visual Basic-et, hogy minden újonnan létrehozott modulba automatikusan beírja az Option Explicit utasítást. Ehhez kapcsoljunk át a VBE-be, és hajtsuk végre a következı utasítást: Tools > Option. Megjelenik a beállító párbeszédpanel. Itt lapozzunk az Editor lapra, és kapcsoljuk be a Require Variable Declaration kapcsolót. Ettıl kezdve a bekapcsolás után létrehozott minden új modulban szerepelni fog az Option Explicit utasítás. Az elıbbi példánk explicit deklarálással a következı lesz: Option Explicit Sub ErtekBekerese() Dim intSzam As Integer intSzam = 18
intSzam = intSzam + 1 End Sub
Töltsük be az Excelt, és hozzunk létre a VBE-ben egy új felhasználói modult. Ebbe írjuk be a fenti kis programot. Próbáljunk meg egy nem deklarált változót használni és figyeljük meg a hibajelzést (11. ábra).
Kattintsunk az üzenet OK gombjára. A programunk nem megy tovább. 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 haszná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. Persze 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 haszná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 Explicit utasításhoz, a modulba, az eljárásokon kívülre írjuk be az Option Base 1 utasítást. Ettıl kezdve a tömb legkisebb eleme nem a nulladik elem lesz, hanem az egyes. Ha nem írjuk be az Option Base 1 utasítást, vagy Option Base 0-t írunk be, akkor a modulban a tömbök elsı eleme a nulladik lesz. A tömb elemeinek úgy adhatunk értéket, hogy leírjuk a változó nevét és a mögötte álló zárójelek közé beírjuk a tömbelem számát. íme egy példa: 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 megadnunk az elemek számát, hogy se többet, se kevesebbet ne foglaljunk a szükségesnél. Ilyenkor dinamikus tömböt hozunk létre. Ha tömb deklarálásakor üresen hagyjuk a változó neve mögötti zárójelpárt, akkor dinamikus tömböt deklaráltunk. Dim strLapokNeve() As String
Mikor határozzuk meg az elemek számát? Mindenképpen azelıtt, mielıtt használatba vennénk, de már a program futása közben! Erre való a ReDim utasítás! Tegyük fel, hogy eljutottunk a programnak ahhoz a részéhez, ahol felhasználnánk az elıbb deklarált változót. A következı kis programrészlet szemlélteti a dinamikus tömb elemszámának megadását: Dim strLapokNeve() As String Dim intLapSzam As Integer strLapSzam = Worksheets.Count ReDim strLapokNeve(intLapSzam)
Mi történt a kis programunkban? Deklaráltuk a változóinkat. A következı lépésben, - Sheets.Count paranccsal - megszámoltuk az aktív munkafüzet lapjait. Az eredményt futás közben felhasználtuk a tömb elemszámának meghatározására. A program további részében értéket adhatunk a tömb elemeinek. Ugyanígy járhatnánk el a megnyitott munkafüzetek neveinek meghatározásával is. Ahányszor kiadjuk a ReDim utasítást, újból helyet foglalunk a tömb elemeinek. Ez egyben azt is jelenti, hogy megszüntetjük az elızı deklarálást, és újból helyet foglalunk a tömbnek. Ebben az esetben az adatokat elveszítjük. Ha a ReDim utasítással csak növelni szeretnénk a tömb elemeinek számát - a korábbi tartalom megtartásával -, akkor a Preserve kulcsszót is be kell írnunk a következıképpen: ReDim Preserve strLapokNeve(intLapSzam)
így a tömb korábbi elemei megmaradnak, feltéve, ha nem kisebbre vettük a tömböt. A korábban tárolt értékek megmaradnak, csak azok vesznek 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áltozók, a felhasználói győjtemények és adattípusok. Kicsit más a kezelésük, kicsit más célt szolgálnak. Az objektum típusú változó például nem arra szolgál, hogy egy objektumot tároljunk benne, hanem arra, hogy elnevezzünk vele egy objektumot. A felhasználói győjteményt használhatjuk tömbváltozók helyett. Ez a lehetıség kicsit összetettebb, de jó lehetıségeket kínál a programozás során. A felhasználói adattípus segítségével új - rekord szervezéső - változótípust hozhatunk létre. Tegyük fel tehát a következı kérdéseket: ♦ 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önféle értékeket tárolunk. Az objektum típusú változók esetén nem errıl van szó. A Visual Basic nem másolja az egész objektumot a lefoglalt helyre, csak az objektumra mutató hivatkozást. így az objektum típusú változókat arra használjuk, hogy rámutassunk egy objektumra. A változó deklarálásában még nincs különbség, de az értékadás eltér a megszokottól. Induljunk ki eddigi ismereteinkbıl! Tegyük fel, hogy egy nem aktív munkafüzet - a neve legyen Munkafü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égeznünk, akkor az egyenlıségjel elıtti szöveget többször is le kéne írnunk. Ez hosszú és eltéveszthetı. Ilyenkor érdemes létrehozni egy objektum típusú változót és rövidebb névvel ellátni a kiszemelt cellát. Ezt a következı módon tehetjük: Dim 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ékadó utasításokhoz képest. Igaz, hogy ez így két programsort eredményezett, de cserébe ezek után az így létrehozott névvel hivatkozhatunk a Munkafüzetl munkafüzet elsı munkalapján található Al-es cellára. A lerövidített hivatkozást így használhatjuk: objAl = "Excel"
A Visual Basic-ben van egy Collection, - győjtemény - osztály. Ennek segítségével létrehozhatjuk saját győjteményeinket. A létrehozott győjtemény elemeiben bármit tárolhatunk. Még az sem elıírás, hogy azonos adattípusú értékeket helyezzünk el bennük. A győjteményeknek öt alapvetı mővelete van. Ezeket szinte mindegyik győjteménynél megtaláljuk. Ezek a következık: ♦ A Count tulajdonságból megtudhatjuk, hogy hány eleme van a győjtemé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 feleslegessé vált elemét. ♦ Az Item metódus segítségével a győjtemény egy elemére hivatkozhatunk. ♦ 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.
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:
A Collection egy objektumosztály. Ebbıl létre kell hoznunk egy objektum-elıfordulást. Erre a következı parancsokat használjuk:
Dim rngAl As Range
Dim colEgyedi As Collection Set colEgyedi
Mi a különbség a két deklaráció között? Ha Object vagy Variant adattípust használunk, akkor a Visual Basic nem tudja, milyen objektumot fogunk elnevezni. Ennek megfelelıen azt sem tudja elıre, hogy az elnevezett objektumnak milyen tulajdonságai, metódusai lesznek. Ez azért fontos, mert az elnevezés számára le kell foglalni az elnevezett objektum tulajdonságainak helyét a memóriában. Ez értékadáskor, vagyis a Set parancs végrehajtásakor történik meg. Ahányszor elnevezünk vele egy tartományt, minden esetben helyet foglal a tulajdonságok tárolására. Ettıl a programunk egy kicsit lassúbb lesz. Ha deklaráláskor meghatározzuk az objektum típusát - ahogy ezt a második deklaráláskor tettük -, akkor a Visual Basic már itt lefoglalja a szükséges memóriaterületet. Ezt elegendı egyszer megtenni, vagyis nem futás közben alakítja ki a tulajdonságok helyét. Ettıl a program gyorsabban fog futni. Más szóval, ha csak tehetjük, deklaráláskor határozzuk meg a változó objektumtípusát.
= New Collection
Az elsı parancssor még csak egy objektum típusú változó, amit majd arra használunk, hogy elnevezzük vele az új Collection objektum-elıfordulást. Ekkor hozzuk létre az elıfordulást. Erre a -Set kulcsszót fogjuk használni. A második sorban már létrehoztuk a colEgyedi objektum-elıfordulást. Használatba is vehetjük. Mielıtt azonban ezt megtennénk, ismerkedjünk meg egy rövidebb írásmóddal is. Az objektum-elıfordulást létrehozhatjuk közvetlenül a deklaráló parancsban is. Ez egyszerősíti a program írását. Dim colEgyedi As New Collection
Az itt leírt deklaráló utasítás eredménye 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árolunk ebben is. Nézzük meg, hogyan lehet felvenni új elemet a győjteménybe. Használjuk az Add metódust! Sub Dolgozok() Dim colEgyedi As New Collection colEgyedi.Add "Kiss", "Fonok" colEgyedi.Add "Nagy", "Helyettes" colEgyedi.Add "Vass", "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.
Basic. Amint leütjük a szóközt az Add metódus után, megjelenik a paraméterek felsorolása (12. ábra). Nézzük meg, hogy melyik paraméternek mi a feladata. ♦ 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 hivatkozhatunk 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 eleme melyik — már korában felvett — elem elé kerüljön a sorban. Ha nem töltjük ki, akkor a lista végére kerül az új elem. ♦ Az After paraméterrel azt határozhatjuk meg, hogy az új elem melyik — már korában felvett elem — mögé kerüljön a sorban. Nem kötelezı kitölteni, ilyenkor a program az utolsó elem után teszi az új elemet. MsgBox colEgyedi(2)
Az utolsó sor kiírja az általunk meghatározott elem tartalmát. Ez a mi esetünkben a másodiknak felvett elem lesz. A győjtemény elemeire hivatkozhatunk a nevükkel is. Ezért határoztuk meg a Key paramétert is. Ha például szeretnénk tudni a fınök nevét, nem kell tudnunk hogy hányadik a sorban, hanem hivatkozhatunk rá névvel az alábbi módon: MsgBox colEgyedi("Fonok")
Ha a győjtemény egyik elemére már nincs szükségünk, akkor azt a Remove metódussal eltávolíthatjuk. Ezt a következı kis eljárásban mutatjuk be, ahol felhasználjuk a Count tulajdonságot is: Sub DolgKilep () Dim colEgyedi As New Collection colEgyedi.Add "Kiss",
A következı öt sorban ugyanazt a mőveletet hajtjuk végre. Új elemeket veszünk fel a győjteménybe. Hogy mi kerüljön a győjteménybe és hova, az Add metódus paramétereivel határozzuk meg. Ebben segít a Visual
"Fonok"
colEgyedi.Add
"Nagy",
"Helyettes"
colEgyedi.Add
"Vass",
"Titkár"
colEgyedi.Add
"Kosa",
colEgyedi.Add
"Sás",
"Eloado_l" "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őjtemény elemeit. A következı sorban megszámoljuk az elemeket. Ezután a Remove metódussal eltávolítunk egy elemet, majd ismét megszámoljuk, hogy mennyi maradt. A példában a titkár adatát távolítottuk el. Természetesen most is hivatkozhattunk volna sorszámmal is. Ezt így kellett volna beírnunk a programba: colEgyedi.Remove 3
Ezzel a győjtemény harmadikként felvett elemét távolítottuk volna el.
Ha a győjtemény egy elemének az értékét szeretnénk megváltoztatni, akkor ezt csak úgy tehetjük meg, hogy elıbb eltávolítjuk a felesleges elemet, és ismét felvesszük. Az új elem kulcsa, — Key — ugyanaz legyen, mint az eltávolítotté. Tehát, ha új titkár lép be a céghez, — a neve legye mondjuk Kovács —, akkor ezt így cserélhetjük le:
lalhat. Ennek nagy hasznát vehetjük a listába szerkesztett adatok feldolgozásánál, vagy az Access programozásakor. A felhasználói adattípus meghatározását a Type és End Type sorok közé kell írnunk. A két utasítás között csak deklaráló utasítások lehetnek. Nézzünk egy példát: Type Dolgozok VezNev As String * 30 KerNev As String * 20 SzulDat as Date Belep as Date End Type
A fenti utasításokat a modul eljárásain kívülre kell írni. Az eredmény az lesz, hogy létrejön egy új változótípus, amibe többféle adatot tárolhatunk. Nézzük meg a felhasználói típus használatát:
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 kulcsok 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-
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 használatáról szóló bekezdésekben. A győjtemény objektum-osztály alapján létrehozott objektum-elıfordulás használatával kiválthatjuk a tömbváltozókat. A győjtemények több lehetıséget biztosítanak a program írása során. Rugalmasabban kezelhetı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 felhasználónak, akkor minden esetben ugyanannak a szövegnek kell megjelennie, ha az adott hiba bekövetkezik. Nemcsak hibaüzenetekkel járhatunk el így. Gondoljunk csak például a kereskedelemben használt áfa értékére vagy más értékekre, amik nem változnak. A programban használt állandókat úgyis megadhatjuk, hogy deklarálunk egy változót és rögtön utána értéket adunk a deklarált változónak. Ezt egy lépésben állandó deklarálásával valósíthatjuk meg. A kérdések a következı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 megjelení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 állandó Variant adattípusú lesz. Ez több helyet foglal, mintha meghatároznánk a valódi típusát. A következı utasítássorban meghatározzuk az állandó adattípusát is.
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 utasítás üzenetek megjelenítésére szolgál. A példában rögtön alkalmazzuk a tanultakat, és az üzenet szövegét állandóként határozzuk meg. Az utasítás beírásakor figyeljünk magára a beírásra. Töltsük be az Excel-t, és térjünk át a Visual Basic Editor-ba. Hozzunk létre egy új modult, és írjuk be a következı eljárást: 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 tartalmazzon, így helyezhetünk el figyelmeztetı ikont vagy hiba ikont a megjelenı panelen. A listában szövegeket találunk. A megjelenı szövegek mindegyike mögött egy szám, egy állandó van. Úgy is megírhattuk volna ezt az eljárást, hogy a szövegek mögötti számot írjuk be a második paraméter helyére. Ez is jó megoldás, de a számokat sokkal nehezebb megjegyezni. Ezért jelenik meg szövegként a második paraméter. Ha a vbCritical szöveg helyére azt írnánk, hogy 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 felsorolást deklarálnunk kell. A felsorolás elemeinek értéke csak egész szám lehet. A felsorolást az Enum és az End Enum utasításpár között kell meghatároznunk úgy, ahogy ez a következı példában olvasható: 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 írnunk. A felsorolásba beírt szövegek úgy viselkednek, mint egy konstans. A felsorolt elemek értéke nullától kezdıdik, és minden elem értéke eggyel növekszik. Vagyis a 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élteti 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 felsorolást, majd egy eljárásban vegyük használatba. Ennek a lépéseit mutatja be a 16. ábra, amelyek a következı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 eljárásba és végrehajtjuk a VBE Run > Run Sub/UserForm utasítását. Ennek hatására jelenik meg az ötödik lépésben beírt MsgBox utasítás eredménye. A megjelenı panelen a pénteknek megfelelı 5-ös számot látjuk.
Azokat az értékeket, amelyeket nem fogunk megváltoztatni a program futási idejében, állandókként deklaráljuk. Az állandó deklarálás kulcsszava a Const szó. Az állandó deklaráláskor meghatározhatjuk annak adattípusát is. Ez nem kötelezı, de a kisebb helyfoglalás mégis indokolja. Programjainkban meghatározhatunk olyan felsorolásokat, melyek megkönnyítik a munkát. A felsorolásokban az általunk meghatározott szövegek mögé egész számokat rendelhetünk. így nem kell megjegyeznünk azt, hogy milyen számértéket vár a program.
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áshoz tartozó változónak egy másik eljárás beállíthatná az értékét. A hatókörök határai azt is lehetıvé teszik, hogy több eljárásban használhassuk ugyanannak a változónak vagy állandónak a nevét. A Visual Basic eljárásokban deklarált változónak csak abban az eljárásban adhatunk értéket, amelyben meghatároztuk. Természetesen kellenek tágabb határok is. Egy modulban dolgozva szükségünk lehet olyan változókra is, ami csak abban a modulban érvényes, amelyben deklaráltuk. így egyben tarthatjuk az összetartozó eljárásokat, változókat és állandókat. Létezik egy még nagyobb egység is: a projekt. Aprojekt minden moduljában használható változókat globális változóknak nevezzük. Ezeknek a változóknak a projekt összes moduljában értéket adhatunk, és bármelyikben kiolvashatjuk tartalmukat. Mivel egy Visual Basic projekt többféle modult tartalmaz, fontos különbséget tennünk a modulok típusai között. A változók - hatókör szempontjából - másként viselkednek egy osztálymodulban, mint egy általános modulban. A fejezetben a következı kérdésekre keressük a választ: ♦ 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 ütközni egymással. A hatókör kérdését a gyakorlatban vizsgáljuk meg! Töltsük be az Excel-t, és a VBE-ben hozzunk létre egy új modult. írjuk be a következı két eljárást, és indítsuk el az elsıt.
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 eljárás szintő változónak adunk értéket. Próbáljuk elindítani a második Kor__2 - eljárást! Amint elindítjuk, a program leáll, és megjelenik egy hibaüzenet. Az üzenet arról tájékoztat, hogy olyan változót használunk, amit korábban nem deklaráltunk. Tehát, ha nem ebben az eljárásban deklaráljuk a változót, akkor azt nem használhatjuk. Kézzelfoghatóvá vált, hogy az strNeve változó hatóköre a Kor_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 eljárásból szeretnénk értéket adni? Az eljárás neve mögötti zárójelpár között is deklarálhatunk változókat. Az eljárás zárójelei között deklarált változóknak kívülrıl is adhatunk értéket, de használhatjuk az eljáráson belül is. így hozhatunk létre olyan eljárásokat, melyek külsı adatokat dolgoznak fel. írjunk egy olyan eljárást, ami két számot összead, majd az eredményt kiírja egy üzenetpanel segítségével. Ügyeljünk az eljárás felépítésére, szerkezetére. Kezdjük az eljárásban használt állandók és változók meghatározásával. Zárjuk le az elızı példa kedvéért létrehozott munkafüzetet, és nyissunk egy újat az új példa miatt. Hozzunk létre egy általános modult, és írjuk bele a következı eljárást! Sub Ö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 deklará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ó eljá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égrehajtja a meghívott eljárást, visszatér abba az eljárásba, amelyik meghí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. ábráján láttuk, hogy megjelennek a meghívott eljárás argumentumai, amikor oda jutunk, hogy meg kell adni. A megjelenı sárga sávon mindig az a paraméter jelenik meg félkövér betővel, amelyiknek értéket adunk. Néha kényelmesebb lehet egy eljárás paramétereinek más sorrendben értéket adni. A Visual Basic erre is lehetıséget ad. Amikor épp felkínálja az elsı paramétert a program, akkor mi beírhatjuk bármely más paraméter nevét, és kettıspont-egyenlıségjellel megadhatjuk a paraméter értékét. Ezt mutatja be a 18. ábra:
Ha nem az összes paramétert akarjuk átadni a hívás pillanatában, akkor úgynevezett opcionális — nem kötelezı — paramétert használunk. Ez egy olyan paraméter, amelynek az értékét nem kötelezı megadni akkor, amikor meghívjuk az eljárást. A zárójelek között elıbb a kötelezı paramétereket kell felsorolni, majd ezt követıen az opcionális paramétereket. Ha egyszer a felsorolásban opcionális paramétert adtunk meg, attól kezdve csak ilyet tartalmazhat a felsorolás többi része. Az opcionális paraméter meghatározásakor megadhatunk egy értéket, amit alapértelmezettnek tekint a program. En-
nek megadása nem kötelezı. Ezt az értéket akkor veszi fel a paraméter, ha az eljárás hívásakor nem adtunk értéket az adott paraméternek. Ha nem adjuk meg az opcionális paraméter kezdı értékét, akkor az eljáráson belül lekérdezhetjük, hogy kapott-e értéket a változó az eljárás 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 szorzás mőveletet végzi el. Úgy határozzuk meg a paramétereket, hogy amikor az eljárás hívásakor nem adunk értéket a szorzónak, akkor azt automatikusan tekintse egynek a program. Sub Szorzás(sngSzorzando As Single, Optional Szorzó = 1) Const STR_EREDMENY As String = "Az szorzás eredménye: " Const STR_CIMKE As String = "Szorzás" Dim dblEredmeny As Double dblEredmeny = sngSzorzando * Szorzó MsgBox STR_EREDMENY & dblEredmeny, vblnformation, STR_CIMKE End Sub
tömbparamétert tartalmazó eljárásban sem, de a híváskor megadott bármelyik elem értékét átírhatjuk. Oldjunk meg egy példát! írjunk egy olyan eljárást, amelyben dolgozók szervezeti egységét és nevét dolgozzuk fel. Tegyük fel, hogy mindig egy gazdasági egységet dolgozunk fel, de ott több ember is munkálkodik. A gazdasági egység nevének átadására használjunk egy szöveges típusú paramétert. Tegyük fel, hogy azt nem tudjuk elıre, hogy egy adott egységen belül hányan és kik dolgoznak. Ezért a második paraméter legyen tömb típusú! Az eljárásban írassuk ki a szervezeti egység nevét, és a neveket tartalmazó tömb legkisebb és legnagyobb elemének számát és tartalmát. Az eredmény kiírására használjuk az Immediate ablakot. Ide a Debug.Print paranccsal írhatunk ki bármit. Az elkészült eljárást hívjuk meg, és figyeljük az eredményt. ADolgozok eljárás a következı lesz: Sub
Dolgozok(strSzervezet As
'Az
String,
ParamArray Neve())
eljárásban használt változók deklarálása
Dim lngAlso As Long Dim lngFelso As Long
Az eljárást hívjuk meg a korábban megírt Számolás eljárásból. Módosítsuk a Számolás eljárást a következıit szerint:
Dim strAlsoErteke As 'A feldolgozás
Sub Szamolas_2 () Összeadó sngSzam_2:= 14, sngSzam_l:=25 Szorzás 45 End Sub
String
Dim strFelsoErteke As
String
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: "
Felfedezhetjük, hogy a Szorzás eljárás hívása során a második paramétert nem adtuk meg. Ettól még a meghívott eljárás mőködik, és eggyel megszorozza a Szorzando paraméternek átadott értéket.
'Az adatok feldolgozása lngAlso = LBound(Neve)'A tömb legkisebb eleme a lngFelso = UBound(Neve)' A tömb strAlsoErteke = Neve(lngAlso)'
száma
legnagyobb elem
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
Ha paraméterként tömböt szeretnénk átadni az eljárásnak, akkor ezt is az eljárás neve mögötti zárójelek között kell deklarálnunk. A paraméter listában szerepelhet több változó is, de tömbváltozó csak egy! Ezt a lista legutolsó helyére kell írnunk. A tömbparaméter úgy mőködik, mint sok opcionális változó. A tömbparaméter — mőködését tekintve — hasonlít a dinamikus tömbökhöz. Mindig annyi eleme lesz, ahány elemnek az eljárás hívásakor értéket adtunk. A tömbparamétert tartalmazó eljárás hívásakor nem kötelezı egyetlen elemnek sem értéket adni! A változó legkisebb eleme mindig a nullás lesz, függetlenül attól, hogy a modul elején kiadtuk-e az Option Base 1 parancsot vagy sem! A tömb méretét nem változtathatjuk meg a
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övetkezı lépések ezek meghatározását tartalmazzák. Az adatfeldolgozási rész elsı két sorában egy-egy Visual Basic függvényt használunk. Az LBound függvény eredménye a tömb legkisebb elemének a száma. Ezt a függvényt bármelyik tömb esetén használhatjuk. Figyeljük meg, hogy a függvényhívás eredményt ad! Ezt az eredményt az lngAlso változóban tároljuk, a kiírásig. Hasonlóan járunk el a tömb legnagyobb elemének a számával is, az eredményt az lngFelso változóba írjuk. Itt az UBound függvényt használjuk. A legkisebb és legnagyobb elem tartalmának meghatározásához már felhasználhatjuk a kiszámított eredményt. A feldolgozás harmadik és negyedik sorában, egy-egy változóban rögzítjük a két tömbelembe írt értéket. Az eredmény kiírása részben az eredményeket kiírjuk az Immedate ablakba. Erre szolgálnak a Debug.Print kezdető sorok. Ha ez az eljárás kész, futtassuk le! írjunk egy Dolgozo_hivasa eljárást, amiben meghívjuk a Dolgozok eljárást. Még mielıtt megkezdenénk a futtatást, kapcsoljuk be az Immediate ablakot a View > Immediate Window paranccsal. íme az eljárás:
Sub Dolgozok_hivasa () Dolgozok "Kereskedık", End Sub
"Vass",
"Sass",
"Kovács",
"Soós'
Á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, ismerkedjü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 értéket adhatunk és kiolvashatjuk az értékét. Talán egy technikai dolgot érdemes megtennünk! Aváltozó típusát jelölı elıtag-karaktereket kibıvíteni egy kis "m" betővel. Valahogy így: Dim mlngNagySzam As Long
Próbáljuk ki a modul szintő változó használatát! Ha a fejezet eddigi feladatait megoldottuk, zárjuk le azt, és kezdjünk egy új munkafüzetet. Az új munkafüzetben hozzunk létre több általános modult. Az egyik modulban deklaráljunk egy modul szintő változót, majd ezt próbáljuk meg használni egy másik modulból. Beírás közben úgy néz ki, mintha minden rendben lenne. Elfogadja az értékadó parancssort, de amint elindítjuk az eljárást, a fordító leállítja, és nem definiált változó hibajelzéssel leáll.
Irjunk egy másik eljárást ugyanabba a modulba, amelyikben a változót deklaráltuk és abban ugyanígy adjunk értéket neki. Indítsuk el! Ez hibátlanul lefut. Vagyis ezt a változót abban a modulban használhatjuk, amelyikben meghatároztuk. A hatókör határa a modul. Ha precízek szeretnénk lenni, akkor a modul szintő változókat és állandókat a Private kulcsszóval kellene kezdeni. Ezt elhagyhatjuk, mert a modul szintő változók alapértelmezés szerint csak abban a modulban érvényesek, amelyben meghatároztuk azokat. A Private kulcsszót csak eljáráson kívül adhatjuk ki.
Ezt is úgy ismerjük meg, ha kipróbáljuk! Zárjuk le a korábbi Excel munkafüzeteket és hozzunk létre egy újat. Térjünk át a VBE programba. Most is hozzunk létre egy általános modult. Ebbe fogjuk megírni azt az eljárást, melyben értéket adunk a globális változónak. A megoldást a 21. ábra szemlélteti.
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é írjunk "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áljunk 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áthattuk, hogy az Excel munkalapjai és a munkafüzet mögött van egy-egy modul. Amikor errıl volt szó, említettük, hogy ezek osztálymodulok. Ez fontos a globális változók deklarálása szempontjából. Máshogy fog viselkedni a globális változó egy általános modulban, és másként egy osztálymodulban. Az osztálymodul feladata ugyanis az, hogy bezárja a benne deklarált változókat.
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égrehajtásával indítsuk el az eljárást. 7. Az eljárás nem deklarált változó hibajelzéssel leáll. Mi lehet az oka a bekövetkezett fordítási hibának? Az, hogy a globális változót egy osztálymodulban deklaráltuk. Az osztálymodul ugyanis magába zárja a benne deklarált változókat. Ezeknek kívülrıl — másik modulból — csak az objektum-interfészen keresztül adhatunk értéket. Ezt is próbáljuk ki! Változtassuk meg az általános modul eljárását a következı módon: Sub 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álymodulban deklarált globális változó úgy fog viselkedni, mintha a munkalapnak egy újabb tulajdonsága lenne az általunk deklarált változó. Fontos tehát megjegyeznünk, hogy az Excel objektumaihoz tartozó modulok osztálymodulok. Ha ezek moduljaiban globális változót deklarálunk, akkor azok új tulajdonságai lesznek az adott objektumnak. Ehhez a tulajdonsághoz csak az objektum-interfészen keresztül férhetünk hozzá.
Ha eljárásban deklaráltunk egy változót, az mindaddig megtartja az értékét, amíg abban az eljárásban fut a program amelyben létrehoztuk. Ha kilépünk az eljárásból, majd ismét visszalépünk, akkor a belépéskor újradeklarálódik a változó. Ezzel el is veszti azt az értéket, ami akkor volt benne, amikor utoljára nála jártunk. Ha mégis szükségünk volna a változó korábbi értékére - például szeretnénk megszámolni, hogy hányszor léptünk be az adott eljárásba -, akkor deklaráljunk statikus változót. A statikus azt jelenti, hogy akkor is megırzi az értékét, ha elhagyjuk az eljárást, és az újbóli belépéskor nem deklaráljuk ismét, így nem veszítjük el a korábbi értékét. Az utasítás a következı lesz: 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írni. Ilyen esetben lesznek modul szintő állandóink és változóink. Ezeket hasznos az eljárások elé a modul elejére írni. így mindig egy helyen kell keresnünk a dolgainkat. Az eljárások állandóit és változóit tegyük az eljárás elsı soraiba. 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 meghatározni, deklarálni. Az adatokat azért tároljuk, mert fel szeretnénk dolgozni ıket. A változók tartalmával különféle mőveleteket végezhetünk. A feldolgozás során matematikai, logikai és szöveges mőveleteket fogunk végrehajtani. A számításokban használt mőveleti jeleket operátornak nevezzük. A következı fejezetben ismerkedjünk meg az adatokon végezhetı mőveletekkel, mőveleti jelekkel. Ismét tegyünk fel kérdéseket! ♦ Mit jelent az értékadás? ♦ Milyen mőveleteket hajthatunk végre a tárolt adatokon? ♦ Milyen mőveleti jeleket használhatunk?
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égrehajtása után ezt az értéket eggyel növeltük. Mielıtt rátérnénk az operátorokra, még egy kis idıt töltsünk el az értékadó utasításokkal. Az objektumokról szóló fejezetben 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 interfészén keresztül érhetjük el. Vagyis ha egy objektum egyik tulajdonságát szeretnénk beállítani, akkor egy értékadó utasítást kell írnunk a programba. Ha például azt szeretnénk, hogy az aktív munkalap A l-es cellájába bekerüljön egy adat, akkor a Range("Al") objektum Value tulajdonsá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 tulajdonságainak pillanatnyi tartalmát. A következı kis eljárás ezt teszi! Kiolvassa 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
Egy-egy változónak adhatunk úgy is értéket, hogy egyszerően egy egyenlıségjel mögé beírjuk azt az értéket, amit tárolni szeretnénk. Máskor egy számítás eredményét rögzítjük egy változóban. Mindkét esetben értékadásról beszélünk. Kezdjük a legegyszerőbbel! Az intSzamlalo változóban tároljuk a 25-ös értéket. Ezt így kell a programba írni: intSzamlalo = 25
Ilyennel már találkozhattunk a korábbi fejezetekben is. De nézzük a további lehetıségeket. Az értékadás jobb oldalán nemcsak konstansok, konkrét értékek szerepelhetnek, hanem kifejezések is. Oda képleteket is írhatunk. A képletekben felhasználhatjuk a program változóit. Talán még emlékszünk a számláló értékadásra, ahol a jobb oldalon ugyanazt a változót használtuk, mint a bal oldalon. intSzamlalo = intSzamlalo + 1
End Sub
Még azt is megtehetjük, hogy egy objektum tulajdonságának tartalmát átadjuk egy másik objektum tulajdonságának. Egy érdekes példa! Ebben megismerkedünk a Not operátorral. Ez az operátor ellenkezıjére váltja egy logikai változó tartalmát. Ha True volt, akkor ettıl a mővelettıl False-ra vált és viszont. Ez épp jó is! Ugyanis a munkalap cellará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.DisplayGridlines End Sub
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! 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átorokról beszéljünk egy kicsit. A hatványozásról csak a mőveleti jel miatt ejtünk szót. Kicsit másként mőködik, mint a többi karakter, amit beírunk a programba. írjunk eljárást, amiben hatványozunk, de közben figyeljünk arra is, hogy mikor jelenik meg a hatványozás operátora. A program számítsa ki kettınek a harmadik hatványát. Az eredményt írja be az éppen aktív munkalap B2-es cellájába. 1. írjuk be addig a programot, amíg azt a 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.
A következı mőveleti jel az egészosztás mőveleti jele. Ezzel ritkábban találkozunk, ez a \ jel. Az egészosztás eredménye egy egész szám, vagyis az osztás eredményének a törtrészét, elhagyja a program. Ennek megfelelıen e 7\2 és a 6\2 eredménye mindét mővelet esetén 3 lesz. De vajon mi lesz azzal a résszel, ami az osztásból megmaradt? Ezt egy újabb operátorral, a maradékosztással számíthatjuk ki. Ennek az osztásnak az eredménye az egészosztás után maradt maradék. A maradékosztás mőveleti jele a modusz szó rövidítése, a Mod. Például a 7 Mod 2 erdménye 1 lesz, hiszen az egészszámú osztás maradéka ennyi. 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.
amikor az operációs rendszerben egy fájl nevébıl csak egy kisebb részletet ismertünk. Ilyenkor helyettesítı karaktereket használtunk. Most is ezt fogjuk tenni. A mőveleti jel bal oldalára a vizsgált szöveget írjuk, a jobb oldalra pedig a helyettesítı karaktereket tartalmazó szöveg típusú értéket. Ha például azt szeretnénk megvizsgálni, hogy a szöveg kezdı betője A bető, akkor ezt a következı paranccsal tehetjük meg: Sub VanABenne() Debug.Print "Alkalmazott" Like "A*" End Sub
A szövegekkel kétféle mőveletet végezhetünk. Az egyik a szöveg összevonás mővelete a másik a helyettesítı karakteres összehasonlítás. Ennek operátora a &. Ezt az operátort arra használhatjuk, hogy két vagy több szöveges kifejezést — ez lehet szövegállandó, szöveg tartalmú változó vagy szöveges eredményő számítás - egymás mögé helyezünk. Erre egy kicsit romantikus példa, amikor Rómeó nevét tároljuk az egyik változóban, a másikba Júlia nevét írjuk, és a két változó tartalmát egy eredmény változóban együtt összevonva, együtt tároljuk. íme a program, amely összeadja Rómeót és Júliát: Sub Ö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 jelet arra használhatjuk, hogy egy tetszıleges szövegrészrıl megmondjuk, tartalmazza-e az általunk keresett karaktersort. Ezzel már találkozhattunk,
Ha a fenti eljárást lefuttatjuk, akkor az Immediate ablakban a True érték jelenik meg. A * helyettesítı karakter ugyanis egy vagy több karakternyi szöveget helyettesíthet. Ezzel az összehasonlítással tehát azt vizsgáltuk, hogy a bal oldali szöveg A betővel kezdıdik, és nem vizsgáltuk az elsı betőt követı további karaktereket. Most vizsgáljuk meg azt, hogy a jobb oldalra írt szövegben miket adhatunk meg? Szemléltesse a lehetıségeket egy-egy kis példa egy-egy rövid magyarázat kíséretében. A kérdıjel helyettesítı karaktert ismerjük az operációs rendszerbıl. Ezzel egy betőt helyettesíthetünk. Most írjunk egy rövidke programot, ami azt ellenırzi, hogy a 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 eredmény azért lett igaz, mert az alma szó második betője l. A záró csillag helyettesítı karakter szerepe az, hogy ne vegye figyelembe az l betőt követı karaktereket. Ha a mővelet bal oldalára olyan szót írunk, amelynek a második betője nem l, akkor az eredmény False lesz. Hasonló módon kereshetünk rá bármilyen számra. Tegyük fel, hogy olyan értéket keresünk, melynek az elsı karaktere szám. Ebben az esetben a kérdıjelet nem használhatjuk, mert az nem csak a számokat helyettesíti, hanem bármelyik karaktert. Számot is, betőt is. A számjegyek helyettesítésére a # karakter szolgál. Vessük össze a ? és a # helyettesítı 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
Debu g.Prin t End Sub
"e-es"
Like "? -es"
' a z ered mén y Tru e
Debug.Print "Marosi" Like "[!A-L]*" ' az eredmény True End Sub
Az elsı két sorban a # helyettesítı karaktert használtuk. A második sor eredménye azért lett False (hamis), mert ott az elsı karakter helyére szöveget írtunk. A harmadik és negyedik sor mindkét esetben True eredménnyel járt, mert a kérdıjel nem tesz különbséget a számjegyek és a bető karakterek között. A # minden esetben csak egyetlen számjegyet helyettesít. Vagyis ha arra lennénk kíváncsiak, hogy az elsı két karakter helyén szám van-e, akkor két # helyettesítı karaktert kéne oda írnunk. Ú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.
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ásokon kívülre beírjuk az Option Compare Text sort a Visual Basic azonosnak tekinti az adott bető kis és nagy változatát. A Like operátor helyettesítı karaktereit a 5. táblázatban foglaltuk össze:
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 kezdenünk a helyettesítést. Az elızı példával ellentétes eredményt ad a következı eljárás: Sub AbcVege () Debug.Print
A program futása közben különbözı változók tartalmától tehetjük függıvé, hogy milyen mőveletekkel folytatjuk a programot. A változók tartalmának összehasonlítására használjuk a összehasonlító operátorokat. Az összehasonlító operátorok felhasználásával olyan kifejezéseket hozhatunk létre, melynek az eredménye True (igaz) vagy False (hamis) logikai érték. Azokat a kifejezéseket, amelyek csak True vagy False eredményt adhatnak, logikai kifejezéseknek is nevezzük. Ha a logikai kifejezések eredményét szeretnénk megırizni, akkor Boolean típusú változót kell használnunk. Nézzünk egy egyszerő programrészletet, amelyben egy logikai kifejezés szerepel. Dim 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 "Alagi"
Like
"[ !A-L] *"
'
az
eredmény False
A két változó közé írt < jel egy összehasonlító operátor. A kifejezés eredménye False lesz, mert nem igaz a feltételezés, miszerint a 18,23 kisebb mint 17,45. Ennél persze több összehasonlító operátort is használhatunk. Ezeket soroljuk fel a 6. táblázatban.
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 összehasonlítás eredményét összevonjuk. A logikai operátorokkal olyan értékeket dolgozhatunk fel, melyek logikai eredménnyel - True vagy False - rendelkeznek. A logikai operátorok használata is logikai kifejezést eredményez, vagyis ezek eredménye is csak True vagy False lehet. Ilyen kifejezéseket a mindennapi életben is használunk. Például ahhoz, hogy együnk, több feltételnek is teljesülnie kell. Ha éhes vagyok és van mit enni, akkor eszem! Itt két feltételtıl is függ, hogy eszem-e vagy sem. Hiába vagyok éhes, ha nincs mit enni, de hiába van ennivaló, ha nem vagyok éhes. A két feltételt összehasonlító operátorokkal vizsgálhatjuk meg, miszerint vagy igaz, hogy éhes vagyok vagy hamis, ugyanúgy, minthogy az is igaz vagy hamis lehet, hogy van-e ennivaló a közelben. Tegyük fel, hogy két logikai változót vizsgálunk: bolX és bolY értékét. 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áltozó aminek értéket adunk, állhat az egyenlıségjel jobb oldalán is. Ebben az esetben a jobb oldalon felhasznált változó a kiinduló értéket tartalmazza, ami a mővelet végrehajtása után megváltozik a jobb oldalon meghatározott számításnak megfelelıen. Az értékadó mőveletekben az egyenlıségjel jobb oldalára írt kifejezésekben mőveleti jeleket használunk. Ezeket a számítástechnikában operátoroknak nevezzük. Az operátorok állhatnak több betőbıl is. Gondoljunk a Mod, az And vagy az Or operátorokra.
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
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 értékadás, vagy egy eljárás meghívása. Máskor ezek segítségével változtatjuk meg egy-egy objektum tulajdonságait. Ebben a fejezetben a szelekció és iteráció utasítástípusokkal ismerkedünk. A fejezetben különös figyelmet fordítunk az adatfeldolgozás és a vezérlések kapcsolatára. Keressük a választ a következı kérdésekre:
Ez a rövid írásmód. Ezt akkor használjuk, amikor a logikai kifejezés eredményétıl függıen csak egy utasításban tér el a program. Természetesen itt meghívhatunk általunk írt eljárásokat is, hiszen azok is egy utasításnak számítanak. Ha a logikai_kifejezés értéke True, akkor az Utasítás_l kerül végrehajtásra, ellenkezı esetben - vagyis, ha False az eredmény -, akkor az Utasítás_2 parancsot fogja végrehajtani a program. Ennél rövidebb már csak akkor lehet az If utasítás, ha nincs szükségünk az utasítás Else ágára. 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
♦ Hogy ágazhatunk el a programban? ♦ Hogy függ össze az adat és a feldolgozás? ♦ Hogyan ismételhetünk meg programrészeket?
Else
Utasítás_3 Utasítás_4 End If
Az elágazás vezérlı utasítások segítségével a változók vagy objektum-tulajdonságok kiértékelése után más-más utasításcsoportokat hajthatunk végre. A kiértékelést az elızı fejezetben olvasott összehasonlító és logikai operátorokkal végezzük el. A Visual Basic szelekciós - elágazási - parancsai az If és a Select.
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:
Ezzel az elágazással logikai kifejezések segítségével kiértékelhetjük a feldolgozá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.
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
'---- Adat bekérés ------sngCellaErtek = Range("Al") ' ---- Az adat feldolgozása-------If sngCellaErtek > 0 Then strEredmeny = STR_NAGYOBB
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. Ebben 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 írassunk 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 igyekezzü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
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 éppen aktuális munkafüzet aktuális munkalapján található Al-es cella tartalmá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ı utasításban az eredményt változóba beírjuk a megfelelı konstans értékét, vagyis azt, ami a „Nagyobb, mint nulla" értéket tartalmazza. Ha teljesült a feltétel, akkor az If-bıl kilép a program, az End If sort követı paranccsal folytatja tovább a program végrehajtását. Ha a feltétel nem teljesül False eredményt ad a kifejezés kiértékelése -, akkor átlépünk a következı kiértékelı sorra. 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áltozó értékébe beírjuk az STR_KISSEBB állandó tartalmát. Ha nem teljesül a feltétel, akkor az If parancs Else ágát hajtjuk végre. Vagyis, ha nem nagyobb és nem kisebb, mint nulla, akkor nem lehet más csak nulla.
Az Else ágban tehát az eredmény strEredmeny változóba beírjuk a „Nulla" értéket. Az eljárás utolsó sorában már nincs más dolgunk, mint az eredményt kiírni a megfelelı cellába. Ezt hajtja végre a következı utasítás: Range("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.
A Visual Basic végiglépked a Case sorokon, és összehasonlítja a kifejezés pillanatnyi értékét a Case mögé írt értékkel. Ha a kifejezés értéke egyezik a Case mögé írt értékkel, akkor belép az elágazásba, ha nem, tovább lép a következı vizsgálatra. Ha a vizsgálat során egyetlen feltétel sem teljesült, akkor a Case Else ágba írt utasításokat végzi el a program. A Case Else ág elhagyható. Hasonlóan az If szelekcióhoz, most is csak egy ágba lépünk be. Vagyis azt az ágat hajtjuk végre, ahol elıbb találunk egyezést. Az egyes Case utasítások mögött figyelhetünk akár több értéket is. Ezeket egymástól vesszıvel elválasztva soroljuk fel. Például: Case 1 , 4 , 5 , 8 , 9
Visual Basic for Application másik elágazást végrehajtó utasítása a Select. Ebben az utasításban egyetlen kifejezést vizsgálunk, és annak értékétıl függıen ágazunk el a programban. Az elágazás elsı sorába írjuk le azt a kifejezést, amelyet vizsgálunk. A Case utasítások mögé pedig azt, hogy a kifejezés milyen értéke esetén kell belépni az elágazásba. A Select Case szerkezetet a következı módon kell leírnunk: Select Case vizsgalt_kifejezes Case Ertek_l Utasítás_l Utasitás_2
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 kifejezés nagyobb, mint egy meghatározott érték, akkor az Is kulcsszót használjuk a következı írásmóddal: Case Is > 100
Case Ertek_2 Utasítás_3 Utasítás_4
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 Ertek_n Case 1, 4, 12 To 17 , Is > 100 Utasítás_5 Utasítás_6 Case Else
Utasitás_7 ütasítás_8 End Select
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ámokat 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övetkezı lehet: Sub Select_Teszt_l() 1
Állandók deklarálása
Const STR_INPUT_CELLA As String = "A2"
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. Vegyük észre, hogy ebben az eljárásban, az állandók között rögzítettük a bemeneti és kimeneti cella nevét. Ez azért lehet hasznos, mert, ha változtatni akarunk a programon, nem kell végignéznünk a teljes eljárást. Elegendı az eljárás elején az állandók tartalmát beállítani a megfelelı értékre. Most nézzük meg a feldolgozás elsı sorát:
Const STR_OUTPUT_CELLA As String = "B2" Const STR_NAP_1 As String = "hétfı"
sngCellaErtek = Int(sngCellaErtek)
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 Dim strEredmeny As v
Single String
A feldolgozandó adat beolvasása
sngCellaErtek = Range(STR_INPUT_CELLA) 1
Itt a bekért adatról levágjuk a tizedesértéket. Erre azért van szükség, mert a felhasználó beírhat a cellába tört számot is. A 3,8, még szerda. Az Int függvény, csak a szám egész részét adja eredményül. Az eljárás többi részét, önállóan elemezzük ki! A szükséges ismereteket már tudjuk. A Select további lehetıségeinek megismeréséhez készítsünk olyan eljárást, amelyik megválaszolja, hogy egy sorszámmal beírt hónap melyik évszakba esik. Az aktív munkalap A3-as cellájába írjunk be egy számot egy és tizenkettı között. A B3-as cellában jelenítsük meg azt, hogy a hónap melyik évszakba esik. Ebben az eljárásban kipróbálhatjuk azt, hogy hogyan mőködik a Case mögé írt felsorolás. Az eljárás neve legyen Select_Teszt_2. íme egy lehetséges megoldás:
Adatfeldolgozás
sngCellaErtek =
Int(sngCellaErtek)
Select Case sngCellaErtek Case 1 strEredmeny = STR_NAP_1 Case 2 strEredmeny = STR_NAP_2 Case 3 strEredmeny = STR_NAP_3 Case 4 StrEredmeny = STR_NAP_4 Case 5 strEredmeny = STR_NAP_5 Case 6 strEredmeny = STR_NAP_6 Case 7 StrEredmeny = STR_NAP_7 Case Is < 1,
Is > 7
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. Akkor beszéltünk a tömbökrıl. Most a tömbökben, győjteményekben tárolt adatok feldolgozásáról lesz szó. Tömbökben tárolt adatok feldolgozása esetén ugyanazokat a lépéseket hajtjuk végre minden tömbelem feldolgozásakor. Annyiszor kell megismételni a lépéseket, ahány eleme a tömbnek van. Sorra kell vennünk a tömbben tárolt adatokat. A tömbben tárolt adatok feldolgozásához ciklust kell szerveznünk. A Visual Basic for Application nyelvben a következı ciklusokat valósíthatjuk meg:
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érté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ó értéke egyenlı vagy nagyobb, mint a végérték. A kezdıérték, végérték és a lépés bármilyen kifejezés, állandó vagy beírt érték lehet. A lépésköz értéke lehet negatív szám is. Ilyenkor a kezdıértéknek nagyobbnak kell lennie, mint a végértéknek.
Természetesen most is készítünk egy egyszerő példát, amelyben megvizsgáljuk a ciklus mőködését. Illesszünk be egy új általános modult, és ebbe írjuk meg a For ciklus kipróbálására szolgáló eljárást. A feladat a következı! Kérjünk be a felhasználótól öt különbözı értéket egy ötelemő tömbbe. Kössük ki, hogy csak egy és tíz közötti értéket szabad beírni. Az adatok bekérése után vizsgáljuk meg, hogy hányszor kaptunk hatnál kisebb számot. Az adat bekérésére használjuk az Inputbox függvényt. Sub
For_Next_teszt_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_CIM) 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
akkor megnöveltük a kisebb értékeket számláló változó tartalmát eggyel. Mire a ciklus végrehajtotta mind az öt ismétlést a bytKisebbek változóban már benne volt az eredmény. Ezt írattuk ki az eljárás utolsó sorában. Több dimenziós tömbök esetén annyi For-Next ciklust ágyazunk egymásba, ahány dimenziós a tömb. Az ismétlések számának egyezni kell az egyes dimenziókba írt elemszámmal. Oldjuk meg az elızı példát úgy, hogy egy kétdimenziós tömb adatait dolgozzuk fel! Mivel az Excelben dolgozunk, egy kicsit tekintsünk elıre! Az aktív munkalap C3;E9-es tartományába írjunk be egy és tíz közé esı számokat. Számoljuk meg azt, hogy hány olyan cella van, amelyben 6-nál kisebb értéket írt be a falhasználó. Ismét kérjük be egy tömbbe a feldolgozandó értékeket, és ebben a tömbben vizsgáljuk meg, az értékeket! Készítsük el az aktív munkalapot a következı adatokkal!
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 begépelt értékek vannak. Érdemes megfigyelni, hogy a ciklusszámláló pillanatnyi értékét használtuk fel arra, hogy a ciklustest, minden ismétlésekor újabb tömbelembe írjunk adatot.
Dim sngSzamok(3 To 9, 3 To 5) As Single
For inti = 1 To 5 If sngSzamok(inti)
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:
< 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,
Az adatok bekérését a Cells objektum segítségével végezzük el. A Cells-nek két argumentuma van. Az elsı a sorra mutat, a második pedig az oszlopra. Mivel az aktív munkalap harmadik sorában kezdıdnek az adatok és a kilencedik sorig tartanak, ehhez érdemes igazítani a tömb elsı dimenzióját. A másikat pedig a feldolgozandó oszlopoknak megfelelıen határozzuk meg. Amikor már a tömbben vannak az adatok, a ciklust úgy állítjuk össze, hogy az végiglépkedjen a megfelelı sorokon és oszlopokon. A mintapélda a következı:
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 F o r i ntK = 3 T o 5 ' * * * A t ö mb o s z l o pai If sngSzamok(inti, intK) < INT_HATAR Then bytKisebbek = bytKisebbek + 1 End If Next intK Next inti '— Eredmény kiírása — MsgBox bytKisebbek & STRJDUT & INT_HATAR End Sub
nos távolságra vannak. Például minden harmadik, vagy tizedik elemet szeretnénk kiértékelni a programunkkal. Természetesen nem tehetjük meg azt, hogy elıbb zárjuk be a külsı ciklust és utána a belsıt. De azt igen, hogy egy utasítássorban zárjuk mindkét ciklust, ha azok egymást követı sorokban lennének.
A győjteményekben szintén egynél több adatot tárolhatunk, vagy egynél több objektumra hivatkozhatunk. Az Office alkalmazásokban gyakran használjuk a programok belsı győjteményeit. Ilyenek az Excel-ben a munkalapok, munkafüzetek, a Word-ben a dokumentumok, bekezdések, az Access-ben a megnyitott őrlapok, vagy a rajtuk található vezérlések. Amikor a feldolgozás során győjtemények elemeit szeretnénk feldolgozni, akkor használjuk a For Each...Next utasítást. Ennek segítségével végiglépkedhetünk az egyes elemeken és 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 munkalapjait szeretnénk feldolgozni, akkor a ciklusszámláló változónak munkalap típusúnak kell lennie. Ha cellák tartalmával dolgozunk, akkor tartomány - Range - típust kell választanunk. Ha nem tudjuk eldönteni, hogy milyen típusú a győjtemény eleme, akkor az object adattípust válasszuk. A ciklus általános formája a következı: Dim objValtozo As Object
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étdimenziós tömb minden elemén. Minden egyes elemet megvizsgálunk, hogy elérte a hatot vagy nem. Ha nem érte el, akkor megnöveljük a számláló értékét eggyel, ha igen akkor vesszük a következı adatot. Ha olyan feladattal találkozunk, ahol nem kell a tömb minden elemét feldolgoznunk, akkor használhatjuk a Step részét a ciklusszervezésnek. Ez természetesen csak akkor célravezetı, ha a feldolgozandó elemek azo-
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épked a győjtemény elemein. A Visual Basic mindaddig ismétli a ciklust, amíg az elemek végére nem ér. A Next utasítássorra érve vált a győjtemény következı tagjára. Nézzünk egy olyan eljárást, ami végiglépked a megnyitott munkafüzet minden munkalapján. Nyissunk egy munkafüzetet, kapcsoljunk át a Visual Basic felületre. Szúrjunk be egy új általános modult, és írjuk meg a következı eljárást.
Sub For_Each_teszt_l () Dim wksLap As Worksheet For Each wksLap In Worksheets Debug.Print wksLap.Name Next wksLap End Sub
Dim rngCella As Range Dim rngTartomany As Range Dim bytKisebbek As
'— Kezdeti értékadás,
feldolgozás —
In
rngTartomany.Cells
If rngCella.Value > INT_HATAR Then bytKisebbek = bytKisebbek + 1 End If Next
For Each wksLap In Worksheets
adatbekérés és
bytKisebbek = 0 For Each rngCella
Nézzük meg az eljárás lépéseit! Az elsı sorban deklaráltunk egy változót, aminek a típusa a Worksheet, vagyis egy munkalap. Ez lesz a ciklusszámlálónk.
Byte
Set rngTartomany = Range("C3: E9 " )
'—
rngCella Eredmény kiírása —
MsgBox bytKisebbek & STR_OUT & INT_HATAR
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öltött tartományban hány olyan cella található, amelyben hatnál nagyobb értéket írt a felhasználó. Ezt tegyük meg most is, de 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 —
End Sub
Az elsı megoldáshoz képest másként lépkedünk végig a tartomány celláin. Az rngCella objektumváltozó lesz a ciklusszámláló. Az rngTartomany annak a tartománynak a hivatkozása, amely celláin végig fogunk lépkedni. Bármelyik tartományban találunk majd egy Cells győjteményt. A győjtemény elemei a tartományon belüli cellák. Ezt a ciklus elsı sorában átadjuk a ciklusszámlálónak. Ha a program belép a ciklusba egyenként végiglép a győjtemény minden elemén, vagyis ismétlésenként más-más cellára fog hivatkozni. A ciklustesten ugyanazt a módszert használjuk a tartalom ellenırzésére, mint az elsı megoldásban. Miután végigjártuk az összes cellát, kiírjuk az eredményt.
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 elejé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ı ciklusról van szó. Ez azért érdekes, mert lesznek olyan ciklusok, melyek utasításait legalább egyszer végre kell hajtanunk. Ilyenkor há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 eredményétıl függ, és lehet, hogy egyszer sem kerül sor a ciklus utasításainak a végrehajtására.. A Do Loop ciklusszervezés legegyszerőbb formája, amikor sem elöl, sem hátul nem tesztelünk. Ennek gyakorlati haszna nincs, mivel ez egy végtelen ciklust eredményez. Illetve ha megszegjük a strukturált programozás szabályait, akkor kiléphetünk a ciklusból az Exit Do utasítással, de ezt most rögtön felejtsük is el. Nézzük meg az elö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
Do utasítások Loop While logikai_kifejezes vagy Do utasítások Loop Until logikai_kifejezes
Mivel ebben az esetben a ciklustest végén hajtjuk végre az ellenırzést, a ciklusba írt utasítások legalább egyszer - feltétel nélkül - végrehajtásra kerülnek. Ha az utasítássor végére érve nem teljesül az ismétlés feltétele, akkor a Loop utáni utasítással folytatjuk a program végrehajtását, ellenkezı esetben visszalépünk a Do sort követı utasításra.
Loop A feltétel egy logikai kifejezés, ami - mint azt már olvastuk az operátorokról szóló részben — vagy True vagy False eredményt adhat. A While kulcsszó használatával mindaddig megismételjük a ciklusba írt utasításokat, amíg a kifejezés értéke True. Ellenkezı esetben átlépünk a Loop utasítást követı sorra. A másik elö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 meghatároznunk az ismétlés feltételét. Ebben a sorban is használhatjuk a While vagy az Until kulcsszavakat, melyek mőködése megegyezik az elızıekben leírtakkal.
Nézzünk egy egyszerő példát! írjunk egy eljárást, amelyik kitalál egy számot, amit mi nem tudunk. A program felhasználójának az lesz a feladata, hogy akármennyi próbálkozással, de találja ki a program által gondolt számot. Szemmel látható, hogy ebben az esetben nem tudhatjuk elıre, hogy a felhasználó hány próbálkozásból találja el a kívánt értéket. így azt sem tudjuk elıre, hogy hányszor kell megismételni az adatbekérést. Ha szerencsés kező a felhasználó, aki a program elıtt ül, elsıre is eltalálhatja, ha nagyon ügyetlen, akár több évet is próbálkozhat, mire megtalálja a kigondolt számot. Eredményül írassuk ki, hogy hányszor tippelt a felhasználó. 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 adatbekérés, mind a feldolgozás a ciklusban történik. Ez így helyénvaló, hiszen a megadott értékeket nem kívánjuk megırizni. A kapott adatot azonnal feldolgozzuk. Ez 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 érté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égre. Ezeket szelekciónak nevezzük.Vagyis a feltételeknek megfelelıen szelektálnak — választanak — az utasítássorok végrehajtásában. A másik csoport segítségével azokat a megfogalmazott gondolatokat valósíthatjuk meg, mint például az utasításblokkot négyszer ismételd meg, vagy az utasításblokkot addig kell ismételni, míg el nem érjük a a kívánt eredményt. A programnyelvtıl függetlenül minden nyelven ebbe a három kategóriába sorolhatjuk az utasításokat.
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 feladatuktól függıen - több fajtája van. A programban lesznek olyan eljárások, amelyeket mi hozunk létre, és lesznek olyanok, amelyeket a program kínál fel nekünk. Ebben a fejezetben ismerkedjünk meg azokkal az eljárás fajtákkal, amelyeket mi hozhatunk létre. A fejezet fıbb kérdései: ♦ 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 eljárásokat és az osztálymodulokba írhatunk tulajdonság eljárásokat. Eddig is használtunk eljárásokat, amikor az elızı fejezetben kipróbáltuk a vezérléseket. Sıt a változókról szóló fejezetben még azt is láthattuk, hogy lehet adatokat átadni egy eljárásnak. A változókról szóló fejezetben már írtunk szubrutint. Most ezeket az ismereteket foglaljuk össze. Az eljárások szerkezetét is érdemes úgy kialakítani, hogy azok az esetleges késıbbi 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 kulcsszóval kezdıdik, amivel egy sorban meghatározzuk az eljárás nevét. Az eljárást az End Sub utasítással zárjuk le.
Az eljárásokon kívül csak az Option, valamint az alkalmazás vagy modul szintő állandók és változók deklarálására szolgáló utasítások állhatnak. Minden más utasítást Sub és End Sub utasítás-pár közé kell írnunk.
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 feldolgozhatunk. Ilyen esetben át kell adnunk a feldolgozandó adatokat az eljárásnak - szubrutinnak. Ha adatot szeretnénk átadni, akkor az eljárás neve mögötti zárójelpár között deklarálhatjuk az átadásra szánt adatokat. De ezt már megismerhettük a változók deklarálásáról szóló fejezetben.
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 visszaadott érték. Afüggvény meghatározás kulcsszava a Function. A függvénynek is lehetnek argumentumai. Ezeket ugyanúgy, a függvénynév mögötti zárójelpárban határozzuk meg. Itt is adhatunk át opcionális vagy tömb argumentumokat, mint a szubrutin esetén. 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ározhatjuk 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 tudomására, hogy a függvény eljáráson belül értéket adunk a függvénynév változónak. Function Ö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, Debug.Print End Sub
sngC
781.452)
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 használhatjuk. A létrehozott függvények bekerülnek az Excel függvénylistájába. Az általunk írt függvények mindaddig szerepelni fognak a munkalap függvények között, amíg az ıket tartalmazó munkafüzet nyitva van. Nyissunk egy új munkafüzetet, és kapcsoljuk be a VBE-t. A megnyitott füzetbe illesszünk bele egy általános modult. Ebbe a modulba írjuk bele az elıbbi függvényt. Miután ezt megtettük, kapcsoljunk vissza az Excelbe, és vegyük használatba ezt az egyszerő kis függvényt (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 alkalmazás. Vagyis Public parancs nélkül az egész projektben használhatjuk a függvényt vagy eljárást. Ha szőkíteni szeretnénk a hatókört, akkor a Sub vagy Function kulcsszó elé írjuk be a Private szót. Az elızı összegzı függvény esetén ezt így kell írni: Private Function Összead(sngA As Single, sngB As Single) As Single Összead = sngA + sngB End Function
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ésre, 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 abból, hogy rosszul találtuk ki a program algoritmusát. Ilyenkor úgy tőnik, minden rendben van. Nem jelzi, hogy nem deklaráltunk változót, vagy elírtunk valamit, de az eredmény mégsem az, amit elvártunk az eljárástól. Mivel a Visual Basic nem jelzi a hibát, ezeket a legnehezebb megtalálni. A fejlesztıi környezetek épp ezért rendelkeznek olyan eszközökkel, amelyekkel nyomon tudjuk követni a programok futását. Tegyük fel a következı kérdéseket: ♦ 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?
A változókról szóló részben már beszéltünk a statikus változókról. A statikus eljárásban deklarált összes változó statikus lesz. Ennek megfelelıen a statikus eljárásban egyetlen változó elé sem kell beírnunk a Static kulcsszót, hiszen enélkül is megtartják az értéküket az eljárás többszöri meghívásakor.
Kisebb programok esetén jól használható módszer, ha lépésenként hajtjuk végre az elkészített eljárást. Az eljárás, amit lépésenként hajtunk végre, olyan legyen, ami az éppen aktuális adattartomány minden celláját végigolvassa és a végén kiírja a tartomány legkisebb értékét. Valahogy így:
Dim dblMin As Double Dim strCime As String Dim rngTart As Range dblMin = Selection.CurrentRegion.Cells(1) For Each rngTart In Selection.CurrentRegion dblTemp = rngTart.Value If dblTemp < dblMin Then dblMin = dblTemp strCime = rngTart.Address End If Next rngTart Range(strCime).Select MsgBox STR_MSG_1 & dblMin & STR_MSG_2 & StrCime & STR_MSG_3 End Sub
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.
Az eljárás, mint eddig mindig, az állandók és a változók deklarálásával kezdıdik. A dblMin változó feladata, hogy az eljárás végén ebben a változóban megjelenjen a tartomány legkisebb értéke. A dblTemp változó az adatok átmeneti tárolására szolgál. dblMin = Selection.CurrentRegion.Cells( 1 ) MsgBox STR_MSG_1 & dblMin & STR_MSG_2 & strCime & STR_MSG_3
A legelsı érték, amit minimumként tárolunk, az aktuális tartomány elsı cellája. Ezt az értéket az aktív tartomány bármelyik cellájából vehetnénk, de kézenfekvı a tartomány elsı celláját felhasználni. így akár olyan tartomány esetén is felhasználhatjuk az eljárásunkat, amelyik egyetlen cellából áll. Késıbb, ha a tartományban találunk ennél kisebb értéket, akkor azzal lecseréljük ezt az értéket. For Each rngTart In Selection.CurrentRegion dblTemp = rngTart.Value If dblTemp < dblMin Then dblMin = dblTemp strCime = rngTart.Address End If Next rngTart
A For Each ciklus használatával végiglépkedünk a tartomány celláin. A ciklus elsı utasítása a dblTemp változóba írja az aktuális cella tartalmát. Ezután megvizsgáljuk, hogy a jelenlegi cella tartalma kisebb-e, mint a minimumként tárolt érték. Ha igen, akkor ki kell cserélnünk a korábbi minimumot, hiszen ez kisebb, mint amit korábban tároltunk. A következı lépésben még annak a cellának a címét is megjegyezzük, ahol ezt az érté-
Az eljárás utolsó lépése az eredmény kiíratása. Ezt az eredményekbıl és a deklarációs részben tárolt állandókból állítjuk össze. A megnyitott munkafüzetben álljunk a tartomány egyik cellájára. Az eredmény ellenırzésére egy kissé távolabbi cellába, munkalap függvény segítségével keressük meg a minimum értéket. Ezután kapcsoljunk vissza a VBE-be és indítsuk el az eljárásunkat. Most futtassuk le ugyanezt az eljárást lépésenként. Ismét az eljárás elsı sorára állunk és kiválasztjuk a Debug > Step Into utasítást vagy leütjük az F8-as funkcióbillentyőt. Ennek az lesz az eredménye, hogy a Sub sort tartalmazó utasítássort a VBE sárga színnel kiemeli. A következı lépés végrehajtásához ismét válasszuk ki a Step Into utasítást. Egyszerőbb a továbblépés az F8-as billentyővel, mert ha minden lépésnél le kell nyitni a menüt, akkor kicsit nehézkes lesz a végére jutni egy hosszabb eljárásnak. A VBA azt az utasítást, amelyiket éppen megjelölte a sárga színő kiemeléssel, még nem hajtotta végre. Ismét üssük le az F8-as billentyőt. Most álljunk meg egy rövid idıre, és kicsit vizsgáljuk meg azt az utasítást, amelyiken már túljutottunk. Egyszerően húzzuk az egérmutatót a dblMin változó fölé (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 haladunk 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ó billentyő). Ahányszor a törésponttal jelölt sort kell végrehajtania a programnak, megáll. Lehetıségünk van a változók tartalmának ellenırzésére. Ennek az ellenırzésnek a segítségével még azt is megtudhatjuk, hogy a program egyáltalán rálép-e a kiválasztott utasítássorra. Ha nem, megvizsgálhatjuk a program algoritmusát, vagy a változókat. A törésponttól akár lépésenként folytathatjuk az eljárás végrehajtását.
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ó ható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 MinimumKeres eljárás.
Ha a programot megállítjuk valahol, akkor itt a Watches ablakban mindig azt az értéket fogjuk látni, amit éppen a változó felvett. Utá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ételes megszakításokat is meghatározhatunk. Másként fogalmazva meghatározhatjuk, hogy a program akkor álljon le megszakítással, amikor valamelyik változó felvesz egy értéket. Állítsunk be olyan feltételes töréspontot, ami akkor állítja le eljárásunkat, amikor a dblTemp változó értéke megváltozik. Ehhez az Expression dobozban a dblTemp változónak kell szerepelnie és a Break When Value Changes választót kell bekapcsolnunk. Ha ezek után elindítjuk az eljárást, akkor a program csak abban az esetben áll le, ha a dblTemp változó értéke megváltozott. Figyeljük meg azt is, hogy a Watches listá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 kifejezést és kapcsoljuk be a Break When Value is True kapcsolót.
Ha egy figyelıpont beállításán változtatni szeretnénk, akkor jelöljük ki a figyelıablak listájából és a helyi menübıl a Edit 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éseinket befejeztük, akkor bezárhatjuk a figyelıablakot az ablak jobb felsı sarkában található x gombbal. A figyelıablak lezárása után is megáll a program, ha vannak beállított feltételek. Tehát szüntessük meg a figyelıpontokat és kapcsoljuk ki a figyelések ablakot. A következı részben már nem lesz rá szükségünk.
Az egyes eljárásokban állandókat, változókat és objektumokat használunk. Ezeket egyszerre is megfigyelhetjük a helyi ablak segítségével. Ez egy kicsit eltér az elızı figyelésektıl, mert nem mi választjuk ki a megfigyelni kívánt elemeket. Cserébe azonban nemcsak a változók értékét láthatjuk, hanem az eljárásban használt objektumok állapotáról is adatokat kaphatunk. Ezt az ablakot a View > Locals Window utasítással kapcsolhatjuk be.
A helyi ablak bekapcsolása után helyezzünk el egy töréspontot az eljárásunknak abban a sorában, ahol az End If utasítás van. Ezután indítsuk el az eljárást. Amikor a töréspontra lépünk, akkor nézzük meg a helyi ablakot. Ebben az ablakban megváltoztathatjuk az objektumok tulajdonságát vagy a változók értékét. Erre akkor lehet szükségünk, ha a megfigyelés során úgy látjuk, hogy a programlépések eredményeként nem következik be olyan állapot, amit vártunk. Ugyanezzel a módszerrel a figyelıablakban is é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 lehetı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 utasítással. Indítsuk el az elkészített eljárást (31. ábra). Ennek akkor vehetjük nagy hasznát, ha sok eljárást tartalmaz a programunk. A próba ablakban kipróbálhatjuk az utasításokat. Egyszerre egy sornyi utasítást írhatunk be és próbálhatunk ki. Kiírathatjuk az egyes objektumok tulajdonságát, végrehajthatjuk az objektumok metódusait. Ezt a lehetıséget használjuk fel az objektumok bemutatásáról szóló fejezetben. A program futása közben kiírathatjuk a változók értékét. Ehhez a Debug objektumot kell használnunk a programban. Ez egy vagy több új
utasítássort jelent, melyeket be kell írnunk az eljárás sorai közé. Ennek az objektumnak egyetlen metódusát használhatjuk. Ez a Print metódus. Válasszuk ki a programunkban azt az utasítássort, amelyik után a változók értékét szeretnénk megjeleníteni és írjuk be a következıket: A változók vagy objektumok tulajdonságát az eljárás bármelyik pontjáról kilistázhatjuk. Az üzenetben szövegállandókat is használhatunk, amelyek segítségével a lista olvasását tehetjük egyszerőbbé. 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 értékét az MsgBox utasítás segítségével is megjeleníthetjük. Ennek egyetlen hátránya, hogy amíg az üzenet látszik, nem férünk hozzá máshoz, mint az üzenet panelhez. Másik lehetıség az, amikor a kiválasztott értékeket a munkalap valamelyik cellájába íratjuk ki. Erre a Cells vagy Range objektumot használhatjuk fel. 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ódosítsuk is.
Az Excel objektumok megismerésére jó módszer, hogy az Immediate ablakban kiadott parancsok hatását megfigyeljük. Azt már olvastuk a Visual Basic Editor-ról szóló fejezetben, hogy az Immediate ablakban kiadott utasítások azonnal végrehajtásra kerülnek. Ebben a fejezetben ezt az eszközt fogjuk felhasználni arra, hogy az Excel egyik-másik objektumát felfedezzük. Figyeljük meg, hogy azoknak a tulajdonságoknak és metódusoknak a neve, amelyek több objektumban is elıfordulnak, 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 megjelení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égrehajtásával tehetjük meg. Ha ebbe az ablakba beírunk egy utasítást, akkor amint leütjük az ENTER billentyőt, az Excel azonnal végrehajtja azt az utasítást, amit beírtunk. A már beírt utasításokat többször is végrehajthatjuk, ha az utasítás sorába állva ismét leütjük az ENTER-t. A Visual Basic szerkesztı ablakát vegyük kisebbre, úgy, hogy a háttérben jól megfigyelhessük mi történik az Excelben.
tulajdonság egyedi. Vagyis egy projekten belül nem használhatjuk kétszer ugyanazt a nevet. A Név tulajdonság értékét futási idıben nem lehet megváltoztatni.
Ebben a fejezetben megismerkedhetünk néhány objektum egyik-másik tulajdonságának a beállításával és néhány metódussal. Megtanuljuk, hogy miként lehet programból új munkafüzetet kezdeni, hogy lehet egy munkafüzetbe új munkalapot beszúrni, továbbá hogyan, milyen módszerekkel jelölhetünk meg egy kiszemelt cellatartományt.
Maga az Excel alkalmazás is objektum, így program írásakor ennek tulajdonságaihoz, metódusaihoz is hozzáférünk. Az objektum neve Application. Ennek a jellemzıi olyan tulajdonságok és metódusok, amelyek magára az Excel-re vonatkoznak. Most sem vesszük át az objektumleíró könyvek feladatát. Ötletszerően kiemelünk néhány objektumot, és annak egyik-másik tulajdonságát, metódusát kipróbáljuk. A cél most nem az, hogy bemutassuk az Excel objektumait, inkább az ismerkedés módszerét szeretném átadni a Kedves Olvasónak. Ha valamelyik tulajdonság értékét szeretnénk megtudni, a sort kezdjük kérdıjellel. Figyeljük meg, hogy amint leírjuk a pontot az Application szó mögé, megjelennek az objektum tulajdonságai és metódusai (34. ábra). A megjelenı listából kiválaszthatjuk azt, amelyiket ki szeretnénk próbálni. Kezdjük azzal, hogy kiíratjuk az alkalmazás nevét, írjuk be a következı sort az Immediate ablakba: ?application.name
A válasz az, hogy „Microsoft Excel". Az objektumok Name tulajdonsága minden objektumnál a kiválasztott objektum nevét tartalmazza. A név
Az objektum felirata és a neve két külön tulajdonság. A felirat megváltoztatható futási idıben is. Afelirat tulajdonság a Caption. Ilyen tulajdonsága az Excel-nek is van. Ez az ablak bal felsı sarkában látható. Jelenleg ez is a Microsoft Excel szöveget tartalmazza, vagyis a program nevét. Ez azonban átírható. Eló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 munkafüzet neve is megjelenik a program fejlécén, bár az nem része a program nevének. Ha a munkafüzet nem töltötte volna ki az Excel ablak teljes felületét, akkor csak a Microsoft Excel szöveg jelent volna meg. Változtassuk meg a program feliratát. írjuk be a következı sort az Immediate ablakba: application.caption = "Ez egy nagyszerő táblázatkezelı program!" A fenti utasítás eredményét a 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 = ""
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édpanelt. Az egyes beállítások eredményét kérdezzük le az Immedate ablakban kiadott paranccsal. Például, kapcsoljuk ki az Excel állapotsorát! application.DisplayStatusBar=False
Szükség esetén elrejthetjük az Excel alkalmazást a program lezárása nélkül. Állítsuk be az Application objektum Visible tulajdonságát false értékre. application.visible = false
Ne lepıdjünk meg, az Excel eltőnt, de nem zártuk le. Ez abból is látszik, hogy a VBE még használható. Jelöljük ki a False szó és írjuk át True értékőre. Az ENTER gomb leütése után ismét megjelenik a program.
Ha a DisplayStatusBar tulajdonság értékét False-ra állítjuk, eltőntethetjük az állapotsort. Ugyanezzel a paranccsal ismét megjeleníthetjük, csak most True értékre kell állítanunk. Szükség esetén le is kérdezhetjük azt, hogy az állapotsor látható-e. ?application.DisplayStatusBar
Ugyanezzel a módszerrel rejthetjük el a szerkesztólécet, ha a DisplayFormulaBar tulajdonság értékét megváltoztatjuk. Tetszés szerint próbáljunk ki néhány Display kezdető tulajdonságot, figyeljük meg a hatásukat. Lekérdezhetjük az Excelhez tartozó fájl elérési útvonalakat is. Egyetegyet próbáljuk átállítani. Nem mindegyiket lehet! Más szóval, ismerkedjünk a következı tulajdonságokkal. ?application. AltStartupPath ?application.DefaultFilePath ?application. LibraryPath ?application. Path ?application. StartupPath ?application. TemplatesPath ?application.UserLibraryPath ?application.DefaultSaveFormat ?application.RecentFiles.Count
Ha az Excel, vagy az operációs rendszer verzióját szeretnénk megtudni, arra a következı tulajdonságokat használjuk. ?application .Version ?application.OperatingSystem
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
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:
Vegyünk fel újabb munkafüzetet a győjteménybe! A győjteményekbe az Add metódussal vehetünk fel újabb elemet. A munkafüzetek győjteményt is bıvíthetjük új elemmel. Az Add metódus eredménye ugyanaz, mint amikor Excel felhasználóként új munkafüzetet kezdünk. workbooks. add
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:
Figyeljük meg a Visual Basic Editor mögött, az Excel alkalmazásban megjelent egy új üres munkafüzet. Vagyis a Workbooks győjtemény eggyel több munkafüzetbıl fog állni. Ahányszor ebbe a parancssorba állunk és leütjük az ENTER-t, mindannyiszor egy új munkafüzetet nyitunk. Álljunk vissza abba a sorba, amelyikben megszámoltuk a munkafüzeteket, és ismét számoljuk meg. Látni fogjuk a változást. Ha szeretnénk lezárni a munkafüzeteket, használjuk a close metódust. Ha ezt a parancsot kiadjuk, az Excel lezárja az összes megnyitott munkafüzetet, mivel a Close most a Workbooks győjteményre vontatozik.
ActiveCell = "Excel 2003"
workbooks. close
application.ActiveCell = "Excel 2003" ?application.ActivePrinter ?application.ActiveWindow.Caption ?application.ActiveSheet.name ?application.ActiveWorkbook.Name
?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
Ha ezt az utasítást végrehajtottuk, akkor lépjünk vissza az add metódust tartalmazó sorra, és a segítségével hozzunk létre négy vagy öt munkafüzetet. Figyelem a munkafüzetek neve már nem egytıl kezdıdik. Most fordítsuk a figyelmünket a munkafüzet objektum felé. Ez a Workbooks győjtemény egy eleme. Kezdjük az éppen aktív munkafüzettel. Erre az ActiveWorkbook hivatkozást használjuk. Ha elfelejtenénk, megtaláljuk az Application objektum tulajdonságai között. activeworkbook. Close
Érdemes visszalapozni az objektum-diagramra. Ott megfigyelhettük, hogy az Application objektum alatt találjuk a Worksheets győjteményt. Minden győjteménynek van Count metódusa! Ezzel megszámlálhatjuk a győjtemény elemeit. Ezt a metódust fogjuk felhasználni arra, hogy megszámoljuk az alkalmazásban megnyitott munkafüzeteket. ?application.workbooks.count
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
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ójelek közé írt index meghatározásával van lehetıségünk. Ezzel a Workbooks győjtemény egyik elemét határozzuk meg, vagyis egy Workbook 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 nevét tárolja, tehát ez az utasítássor a megadott munkafüzet nevét írja ki. Az aktív munkafüzet nevét az ?Activeworkbook.name utasítással írathatjuk ki. Az aktív munkafüzet és az elsıként 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üzenet jelenik meg. Ha egy már elmentett munkafüzetre szeretnénk a nevével hivatkozni, akkor az idézıjelek közé annak a fájlnak a nevét kell írnunk, amelyikbe elmentettük. Ilyenkor az XLS kiterjesztést is hozzá kell venni a névhez!
A munkafüzetben pillanatnyilag használatban lévı munkalapok (Worksheets) is győjteményt alkotnak. Ismerkedjünk meg a munkalapokon végezhetı néhány mővelettel. Mivel az elızı gyakorlatok során megnyitottunk és lezártunk munkafüzeteket, most az tőnik a legjobb megoldásnak, ha lezárjuk az összes munkafüzetet és megnyitunk egy újat. Esetleg lépjünk ki az Excel-bıi és indítsuk újra. Ez azért jó, mert akkor a munkafüzetetek 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őjtemény Count metódusát használjuk. ?worksheets.count
Vehetünk fel új lapokat a munkafüzetbe? Igen! Melyik metódus használatával? Az Add metódussal. Minden győjteménynek van Add metódusa? Tehát most is a jól bevált módszerrel bıvíthetjük a győjteményünket új elemmel.
workbooks("Munkafüzetl2").activate
Worksheets.add
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.
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ó munkafüzet az aktív.
?activeworkbook.saved
Amikor egy munkafüzetben tartalmi vagy formai módosítást hajtunk végre, akkor az alkalmazás beállítja, hogy a munkafüzetben változtattunk, de nem mentettük el a változásokat. Mivel mi még semmit nem változtattunk a munkafüzeten, ezért a fenti kérdésre Igaz (True) választ kapunk. activeworkbook.saved=false
Ha szükségét látjuk, mi is beállíthatjuk ezt a Saved tulajdonságot. Ha ezután megpróbáljuk lezárni a munkafüzetet például az activeworkbook.close utasítással, akkor a program figyelmeztetni fog arra, hogy szükség esetén mentsük el a munkafüzetet.
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 írathatjuk ki a fenti utasítással. Ugyanazt a tulajdonságot használjuk fel,
Horksheets("Számítások").move
Before:=Worksheets( 4 )
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.
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(1).name="Számítások"
Worksheets("Számítások").copy
A munkalap neve, ellentétben a munkafüzet nevével megváltoztatható. Ezt a kiszemelt munkalap objektum Name — név — tulajdonságának az átírásával tehetjük meg. Erre példa a fenti utasítássor. Ez az utasítás az aktív munkafüzet elsı lapjának a nevét változtatja meg. ?worksheets.add.name
Ez egy érdekes több funkciós utasítás. Egyfelıl, végrehajtja az Add metódust, másfelıl kiírja az új munkalap nevét. Tehát egyszerre hajtunk végre egy metódust és íratunk ki egy tulajdonságot.
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: wor ksheets("Számításo k").select
worksheets.add.name = "Adatok"
worksheets (Array ( 1 , 4 , 6 ) ) . select worksheets(Array("Munkai","Munka4","Munka6")).select
Az elızı utasítást kissé átalakítva azt is megtehetjük, hogy programból beszúrunk egy új munkafüzet lapot és a beszúrás pillanatában már el is nevezzük. Ebben az utasításban ismét együtt használjuk a metódust és a tulajdonságot.
Egyszerre több munkalapot is kiválaszthatunk. A fenti utasítás eredményeként a Munkai, Munka4 és a Munka6-os munkalap lesz kiválasztva, vagyis csoportba foglalva.
Worksheets("Számitások").cop y Before:=Worksheets( 2 )
activesheet.select
A Copy metódussal munkalapokat másolhatunk. A Before paraméterben meghatározhatjuk, hogy melyik munkalap elé kerüljön a másolt munkalap. Figyeljük meg a munkalap nevét. Mivel két egyforma nevő munkalap nem lehet egy munkafüzetben, ezért a másolat neve Számítások (2) lesz. Ezzel az utasítással létrehoztunk egy új munkalapot, amit a munkalap győjtemény megfelelı helyére be is főztünk. Az új munkalap és a befőzés mőveleteket a Copy metódus oldotta meg.
Ha több munkalap van egyszerre kijelölve, akkor az a munkalap az aktív, amelyiknek a neve vastag betővel látszik. Ezzel az utasítással megszőnik a csoportba foglalás és csak az aktív munkalap lesz kiválasztva. A következıpéldához ismét hajtsuk végre a csoportba foglalást elvégzıutasítást.
Worksheets ("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üzetbe másoltuk át. Az utasítást csak akkor hajthatjuk végre hibaüzenet nélkül, ha valóban van Munkafüzet2 nevő munkafüzetünk. Ha nincs, válasszunk olyan munkafüzet nevet, amelyik létezik.
wor ksheets( 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ámolni szoktunk. A diagram lapok megszámlálásához a ?Charts. Count utasítást kell kiadnunk.
A kaszkád elrendezéső ablakok közül a legfelsı az egyes számú. Tehát most a felülrıl számított második ablak kerül felülre. Ezzel viszont a felülre került ablak sorszáma egyes lett. Másképpen fogalmazva, ha a Windows(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épkedhetünk az alkalmazásban jelenleg létezı ablakokon. ?activewindow.caption
Az Excel-ben megnyitott ablak nem azonos a munkafüzettel. Csak annyi a kapcsolatuk, hogy a munkafüzet is egy ablakban jelenik meg. Akövetkezı gyakorlatokhoz elegendı lesz egy megnyitott munkafüzet. Tehát zárjuk le a felesleges munkafüzeteket, majd a VBE próbaablakba írjuk be a következı utasítást: ActiveWindow.NewWindow
Azonos azzal a mővelettel, amikor az Ablak (Window) > Új ablak (New window) utasítást hajtjuk végre. Az utasítás végrehajtása létrehoz egy új ablakot az aktív munkafüzethez. Tehát két ablakban is ugyanazt a munkafüzetet látjuk.
Ez az utasítás kiírja az éppen aktív ablak feliratát. Figyelem, ez nem azonos a munkafüzet nevével! Ez csak a jelenleg aktív ablak felirata. Ha most lekérdezzük a munkafüzet nevét, akkor látni fogjuk a különbséget. activewindow.caption="Az én ablakom"
Az aktív ablak feliratát megváltoztathatjuk. Ez nem a munkafüzet neve, csak az ablaké. Az utasításait érdemes ismét kipróbálni. Tehát az ablak feliratát megváltoztathatjuk programból, de a munkafüzet nevét nem. Ilyet már korábban is csináltunk, amikor átírtuk az Excel alkalmazás címét. Akkor is a Caption tulajdonságot használtuk.
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 szolgálja.
Lépjünk át az Excelbe és zárjuk le a megnyitott ablakokat. Csak egy munkafüzet egy ablaka legyen nyitva. Ismerkedjünk egy kicsit a munkalapon található cellákkal, tartományokkal. Adjuk ki a következı utasítást!
Windows.arrange arrangestyle:=xlcascade
cells. select
Az utasítás ugyanaz, mint az elızı volt, de most nem egy számmal határoztuk meg, hogy milyen legyen az ablakok elrendezése, hanem egy Excel belsı állandóval. Ez az állandó egy számot helyettesít. Ha a próbaablakba beírjuk a ?xlcascade utasítást, akkor megtudhatjuk azt, hogy ez az állandó a hetes számot rejti.
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.
Windows(2).activate
cells ( 1 ) .select
A cells győjtemény elsı eleme a kiválasztott munkalap Al-es cellája. Vagyis a cella meghatározása során is meg kell mondanunk, hogy a cellák győjtemény melyik tagját szeretnénk kijelölni. A cella meghatározása a Cells objektum mögötti zárójelbe írt számmal lehetséges. 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
minden objektumnak van egy alapértelmezett tulajdonsága, a cella objektumé az érték - Value - tulajdonság. range("c3") .select
A tartomány objektum neve: Range. Ezzel hivatkozhatunk egy cellára vagy több cellából álló tartományra. Jelen esetben egy cellára hivatkozunk, nevezetesen a C3-asra. A hivatkozás egyik módja, ha a Range győjtemény zárójelébe idézıjelek közé beírjuk a cella 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).
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
range ("b2, c4, dl, a5 ") . select
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 legutolsó cella aktív. Ha kiadjuk a fenti utasítást, akkor ezzel úgy írhatunk adatot a munkalap egyes cellájába, hogy nem választjuk ki azt. 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 utasítást: Cells(1). value — 400 jelezve ezzel azt, hogy az objektum melyik tulajdonságát kívánjuk módosítani. Erre most azért nem volt szükség, mert
Egyszerre több tartományt is kijelölhetünk. Ennek az írásmódja azonban eltér a munkafüzetben használttól. A tartományokat itt vesszıvel kell elválasztani egymástól, függetlenül a Windows nemzetközi beállításától. range(cells( 2 , 2 ) , cells( 5 , 4 ) ) . select
Ennek a tartománykijelölésnek az érdekessége az, hogy a Range paramétereiben a Cells győjtemény két tagja van. A zárójelek közötti két cellahivatkozás a tartományt határoló cellákat jelöli (37. ábra).
?cells.count ?columns.count ?rows.count
Az elsı utasítás a munkalap Cells győjteményének az elemszámát határozza meg, a második a Columns győjtemény elemeit számolja meg, míg a harmadik a Rows győjtemény elemeinek a számát adja vissza eredményként. A Count módszert használjuk fel arra, hogy a győjtemény elemeinek a számát lekérdezzük. Most azért a teljes munkalap celláinak, sorainak és oszlopainak a számát határoztuk meg, mert ha nem mondjuk meg, hogy melyik tartományra gondolunk, akkor az éppen aktív munkalappal dolgozik a program. ?Range("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. Ehhez adjuk ki például a Range("b2:c7").select utasítást. ?selection.cells.count ?selection.columns.count ?selection.rows.count
Az éppen kijelölt tartományra a Selection objektumnévvel hivatkozhatunk. Ennek a jellemzıit is megtudhatjuk a fenti utasításokkal. A Selection objektumnak a tulajdonságai és metódusai egyeznek a Range objektuméval. Programozás során gyakran használunk adatokkal kitöltött tartományokat. Ezek jellemzıire is szükségünk lehet a program írása közben. 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. Ezután ismét állítsuk vissza a környezetet úgy, hogy a Visual Basic szerkesztı az Excel elıtt legyen, és ismerkedjünk meg néhány lehetıséggel. Álljunk az 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 kijelölt cella körül van. Ilyenkor meg kell mondanunk azt is, hogy melyik cella körüli adattartománnyal szeretnénk mőveletet végezni. Ebben az esetben egy Range objektumra hivatkozva kell kezdeni az utasítást és mögé kell írni a CurrentRegion objektumot, majd elvégezni a kívánt mőveletet. Ez a példában a kijelölés. Az egyszerőség kedvéért a további kijelöléseket vagy adattartomány hivatkozásokat kezdjük a Range — tartomány — meghatározásával. ?Selection.SpecialCells(xlCellTypeBlanks).count
Akiválasztott cella környezetében található üres cellák száma az eredmény. Ennek az utasításnak a végrehajtása során nem kellett kijelölni a tartományt. Range ( " a l " ) .SpecialCells(xlCellTypeBlanks).select
Az Al-es cella környezetében található üres cellákat jelölhetjük ki. Akijelölés az utolsó celláig tart. Itt az utolsó cella nem a munkalap utolsó celláját jelenti, hanem az utolsó még kitöltött cellát. Válasszuk ki ismét az Al-es cellát, és számoljuk meg, hogy mennyi üres cella van az éppen kijelö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írtuk az Adat szöveget. Ezután álljunk az adattartomány területén belül egy cellára, például a Range(B3).select utasítással. Adjuk is ki! Range (B3) . select
Hogy jobban követhessük az elvégzett gyakorlatokat, ezen az adattartományon fogunk dolgozni. Ha a tartomány egyik celláján állunk, akkor erre a tartományra a Selection.CurrentRegion hivatkozással mutathatunk rá. Ha az adattartományon kívül lévó cellán állunk, akkor a helyes hivatkozás például a Range("a2").currentregion is lehet. Ezekben a példákban azzal ismerkedhetünk meg, hogy ha egy tartománnyal mőveletet szeretnénk végrehajtani, akkor elegendı hivatkozni a megfelelı cellára. Álljunk tehát az adattartomány egyik cellájára. 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 adattartomá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:
számok is lehetnek, ezzel a viszonyítási pont elıtti cellák egyikére mutathatunk.
Selection.currentregion.rows(1).font.bold = true
Figyeljük meg, hogy ennek az utasításnak az eredményeként az adattartomány elsı cellasorának betői félkövérek lettek. Ezt a Font. bold tulajdonság beállításával értük el. Most azonban a hivatkozást érdemes megfigyelni. Ez a Selection.currentregion.rows(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égrehajtjuk: 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ímezni, hanem egy adott cellához viszonyított tartományt. Ehhez választanunk kell egy viszonyítási pontot. Ez lehet egy cella vagy egy tartomány, ilyenkor a tartomány bal felsı cellája a viszonyítási pont. írjuk be a következı parancsot az Immediate ablakba és hajtsuk is végre: range("c4").Select
A mi esetünkben ez a viszonyítási pont a selection.currentregion hivatkozá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: selection.currentregion.offset( 2 , 3 ) .range( " a l : a 3 " ) .select
A mővelet végrehajtása után az adattartomány bal felsı cellájától három oszloppal jobbra és két sorral lejjebb hivatkozik az offset. Az utasítás eddigi része az így meghatározott pontra helyezte át az A l-es cella hivatkozá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ározott cellához viszonyított Al:A3-as tartományt. Az offset és a range kombiná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
Zárjuk le mentés nélkül azt a munkafüzetet, amelyikben eddig dolgoztunk, és kezdjünk egy új, üres munkafüzetet. Ebben most a rajz objektumokkal végezhetı mőveletek közül vizsgálunk meg 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ıoldalának távolsága a munkalap tetejétıl, a téglalap szélessége és végül a téglalap magassága.
Selection.Interior.Colorlndex = xlNone
A téglalap hátterének (Interior) a Colorlndex tulajdonságát megváltoztathatjuk. A jelenlegi az átlátszó, de, ha ide például az xlNone helyére egy hármast írunk, akkor a téglalap színezése piros lesz, mert a színpaletta harmadik színe a piros. A munkalaphoz nem csak téglalapot adhatunk hozzá programból, hanem az 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, 5 0 , 2 0 , 1 0 0 , 1 0 0 ) .select
Színátmenetes kitöltést adtunk az alakzatnak. Az elsı paraméter a msogradientvertical, ez a függıleges irányú színátmenet beállítását végzi. Az állandó nevébıl kiolvasható a választás hatása. A második paraméter az átmenet változó. Ennek az értéke 1 és 4 között lehet. Ez azt határozza meg, hogy hol legyen az átmenet: a bal oldalon, a 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 átmenet erıssége állítható be vele. selection.characters.text = "Szöveg megjelenítése"
A kiválasztott alakzatba szöveget írhatunk. Erre példa a fenti utasítás.
Mielıtt ezekbe a gyakorlatokba belefognánk, ismét kezdjünk egy új munkafüzetet és ebbe készítsünk el egy diagramot. Ezen fogjuk kipróbálni a diagram objektumok néhány lehetıségét. A diagram létrehozása után alakítsuk ki a megfelelı környezetet a gyakorlatokhoz.
A fenti utasítás egy 16 ágú csillagot helyez el az éppen aktív munkalapra. Ha másik munkalapra hivatkozunk, akkor arra kerül rá a rajzalakzat. Az utasításban szereplı 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
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álasztott diagramokkal végezhetünk mőveleteket.
activechart.chartwizard gallery:=xl3dline
activechart.Axes(xlcategory,xlPrimary).axistitle.characters . text ="Kategória"
Az elkészített és aktív diagram diagramtípusát tetszés szerint megváltoztathatjuk. Erre a diagramvarázsló eljárást használjuk fel. A Galery paraméter mögé különféle Excel állandókat írhatunk be. Ezek mindegyike a nevében hordja a formázás hatását. activechart.chartwizard format:=2
A varázsló másik argumentuma a Format, ezzel a diagram osztásait állíthatjuk be. Ide a diagram típusától függıen a kétdimenziós diagramok esetén 1 és 10 közötti számot írhatunk, míg más diagramoknál ennél kevesebb lehetıség közül választhatunk. activechart.chartwizard categorylabels:=2
A diagram kategóriatengelyének a feliratát az adattábla elsı oszlopaiból készíti el a varázsló. Itt változtathatunk ezen. Az utasítás értéke azt határozza meg, hogy hány oszlop kerüljön a kategóriatengely alá feliratként. Ha kipróbáltuk, állítsuk vissza az egyes értéket. activechart.SeriesCollection(1).select activechart.Legend.Select
Ezzel az utasítással megjelölhetjük a diagram egyik adatsorát. A zárójelbe írt szám az adatsor sorszáma. Más diagramelemeket is megjelölhetünk. A Legend például a jelmagyarázat. activechart.HasTitle= True
A fenti utasítás a diagramhoz ad egy szövegdobozt. Ez a diagram címe lesz. Mivel még nem határozhattuk meg a tartalmát, ezért egy alapértelmezett szöveg jelenik meg benne. Ez a magyar Excelben „Diagramcím", az angolban „Chart title". Hasonló módon a kategóriatengelyhez és az értéktengelyhez is rendelhetünk feliratot. activechart.Axes(xlcategory,xlPrimary).hastitle = true
A kategóriatengely feliratának a megjelenítésére használható tulajdonság-beállítást látjuk. Ha az xlcategory Excel-állandó helyére az xlvalue állandót írjuk, akkor ugyanezzel az utasítással az értéktengely mellé készíthetünk feliratot. activechart.ChartTitle.Characters.Text = "Bemutató"
activechart.Axes(xlvalue,xlPrimary) .axistitle.characters.text ="Érték"
A fenti három utasítássor a már létrehozott feliratok tartalmának a megváltoztatására szolgál. Ezeket az utasításokat csak akkor használhatjuk, 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 diagramoknál használható!
A VBE Immedite ablakában közvetlenül kiadott parancsok hatását megfigyelve megismerhetjük az objektumok tulajdonságait, metódusait. Az objektumok jellemzıit a program felkínálja, amint az objektum neve mögé pontot írunk. A felkínált nevekbıl kitalálhatjuk, hogy melyik tulajdonságnak vagy metódusnak mi a feladata. A háttérben elhelyezett Excel-ben azonnal megnézhetjük a mőveletek eredményé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 álljunk 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:
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 legegyszerőbben ezzel a módszerrel automatizálhatjuk a napi feladatainkat. Közben az Excel megír egy-egy eljárást, amibıl sokat tanulhatunk az objektumok tulajdonságairól, metódusairól. Ezért minden elkészített makró-felvételt érdemes kielemezni. Ennek elsıdleges célja, hogy közelebb kerüljünk az Excel objektumaihoz. Lássuk, milyen kérdésekre kaphatunk választ ebbıl a fejezetbıl.
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.
♦ 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 elkezdenénk, ugyanis makró rögzítéskor az Excel minden kis mozdulatunkat hően megıriz. Például ha nem azon a cellán állunk a felvétel megkezdésekor amelyiken kell, és felvétel közben módosítunk a cella kijelölésén, akkor a makró végrehajtásakor a program is megváltoztatja a cella kijelölését, és innen fog indulni a lejátszás. A most következı felvétel egy egyszerő példa lesz. Ezt arra használjuk, hogy megismerjük a makró-rögzítés körülményeit, eszközeit. Készítsünk el egy olyan felvételt, amelyik az aktuális munkalap elsı celláiba automatikusan beírja a munkafüzet készítıjének az adatait. Az adatok beírását
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.
Minderre azért van szükség, mert csak azokat az eljárásokat futtathatjuk, amelyek egy megnyitott munkafüzetben vannak. Az Excel úgy menti el a füzetet, hogy rejtett állapotban töltıdjön be. így nem zavarja a felhasználót egy üresen megnyitott dokumentum.
Kezdjük el a felvételt (45. ábra)! Tehát az A1-es cella kivételével bármelyik cellán állhatunk a felvétel megkezdésekor. 1. Válasszuk ki az Eszközök (Tools) > Makró (Macro) > Új makró rögzítése (Record New Macro) utasítást. 2. A Makrónév (Macro name) szerkesztıdobozba írjuk be a rögzítésre kerülı program nevét: 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ő.
(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 észreveszi, hogy a betöltés óta változtattunk rajta. A változtatás jelen esetben az, hogy elrejtettük. Amikor rákérdez a rejtett füzet mentésére, válaszoljuk azt, hogy szeretnénk elmenteni. így a következı betöltéskor rejtve marad.
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 munkafüzet, amit az Excel akkor hoz létre, amikor elkészítjük az elsı makró felvételt. Az új munkafüzet neve Personal.xls lesz és automatikusan az XlStart mappába fogja menteni az Excel. Tehát a Personal.xls mentésérıl nem nekünk kell gondoskodnunk. Ez a munkafüzet rejtve marad. Az XlStart mappa feladata, hogy az Excel elindításakor betöltse azokat a munkafüzeteket is, amelyeket ide mentettünk. Vagyis ezt a mappát arra is felhasználhatjuk, hogy azokat a munkafüzeteket, amellyel a napi munkáinkat kezdjük ide mentjük, így az Excel elindítása után nem kell külön gondoskodnunk arról, hogy ezeket betöltsük. Ezt a tulajdonságát használjuk fel arra, hogy a Personal.xls minden elindítás után be legyen töltve. Ezt a munkafüzetet azért nem látjuk, mert amikor a program létrehozta és elmentette, akkor rejtett volt, így az újabb betöltés után is rejtett marad. Ez a mappa az újabb operációs rendszerekben a felhasználói profilhoz van hozzárendelve. A felvétel készítésekor az Excel a következı mappába mentette a Personal.xls fájt. C:\Documents and Settings\Kovalcsik Géza\Application DataXMicrosoft\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 betöltıdnek az Excel indításakor.
(This Workbook) A felvétel a jelenleg használt munkafüzetbe készül. A felvett makrót minden alkalommal használhatjuk, ha elıtte betöltjük ezt a munkafüzetet. Ezt a lehetıséget rendszerint akkor érdemes választani, amikor olyan programot készítünk, amelyet csak egy munkafüzetben szeretnénk használni. A három lehetıségbıl válasszuk az Ebben a munkafüzetben (This Workbook) lehetıséget. Lépjünk tovább a felvétel elkészítésében: 4. Kattintsunk az OK gombra. Figyeljük meg, hogy bekapcsolódott egy eszköztár. Ezen találjuk meg azt a gombot, amelyikkel majd leállítjuk a felvételt (a bal oldali gomb). 5. Végezzük el a begyakorolt mőveletsort, majd a mőveletek végrehajtása után állítsuk le a felvételt. Ezt a felvétel indításakor megjelenı eszköztár Rögzítés vége gombjával tehetjük meg. Ha az eszköztár nem jelenne meg, akkor válasszuk ki az Eszközök (Tools) > Makró (Macro) > Rögzítés vége (Stop Recording) utasítást. A felvétel kész, ha szükséges, ki is próbálhatjuk egy üres munkalapon. Ehhez elegendı, ha átlapozunk egy üres munkalapra és leütjük a CTRL+ k billentyőkombinációt.
Sub Készítette()
Amunkánk eredményének egyik jelét a makró párbeszédpanelben láthatjuk. Kapcsoljuk be a panelt az Eszközök (Tools) > Makró (Macro) > Makrók (Macros) utasítás segítségével. Ebben a panelben a következıket fogjuk találni: (Macro Name) A megjelenı párbeszédpanel Makró név listájában felsorolja azokat a makrókat, amelyek jelenleg elérhetıek az Excelben, vagyis már betöltöttük ıket. Ha több makrót rögzítettünk, akkor a Makrónév (Macro Name) listában több elem lesz.
'
Készítette Makró
'
Rögzítette:
'
Billentyőparancs:
Kovalcsik Géza,
2005
Ctrl+k
Range("Al").Select ActiveCell.FormulaRICl
=
"Készítette"
Range( " B l " ) .Select ActiveCell.FormulaRICl
(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.
dátum:
=
"Kovalcsik Géza"
Range("A2").Select ActiveCell.FormulaRICl
=
"Vállalat"
Range ( " B 2 ") .Select ActiveCell.FormulaRICl = "Help Key Bt" Range ("B3") .Select
(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. Ebben lehetıségünk van a billentyőkombináció utasítás megváltoztatására. Ha valamilyen okból a rögzítés beállításakor nem választottunk volna billentyő-kombinációt, akkor ezt utólag meghatározhatjuk a listából kijelölt makróhoz.
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 ismerkedtünk, megtanultuk hogy nem kell kijelölnünk azokat az objektumokat, amelyekkel mőveleteket végzünk, elegendı hivatkozni rájuk. Ez jelen esetben azokat a cellákat jelenti, amelyekbe beírtunk. írjuk át a programot úgy, hogy csak hivatkozásokat használjunk: Sub Készítette() '
Készítette Makró
' '
Rögzítette:
'
Billentyőparancs:
Kovalcsik Géza,
Range("Al").Value = Range ( "Bl") .Value
2005
Ctrl+k "Készítette"
= "Kovalcsik Géza"
Range("A2").Value = Range ("B2") .Value
dátum:
"Vállalat" = "Help Key Bt"
End Sub
Amint elkészültünk egy makró rögzítésével, érdemes megnézni az eredményt. Ehhez kapcsoljunk át a Visual Basic Editor-ba és nyissuk meg azt a modult, amibe az Excel az eljárást beírta. Itt a következı programot találjuk:
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érdezhetjük az Application objektumból. Ez azért jobb, mert így a makró bárhol a ténylegesen regisztrált felhasználó nevét fogja a megfelelı cellába írni. A kész eljárás tehát így fog mutatni:
Sub Készitette_megoldasa ()
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.
' Készítette Makró ' Rögzítette: Kovalcsik Géza, dátum: 2005 ' Billentyőparancs: Ctrl k
A felvétel elkezdése elıtt álljunk az adattartomány egyik cellájára. A sikeres felvétel érdekében lépésrıl lépésre pontosan hajtsuk végre a formázást. Kezdjük el a rögzítést! Figyeljünk arra, hogy a felvétel megkezdése elıtt az adattartomány egyik celláján álljunk, ahogy ezt a 46. ábra is szemlélteti.
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é-
1. Válasszuk ki az Eszközök (Tools) > Makró (Macro) > Új makró rögzítése (Record New Macro) utasítást. 2. A megjelenı párbeszédpanelben adjunk nevet a felvételre váró makrónak. Ez a név a Keretezes legyen. A Makró helye (Store macro in) listapanelbıl válasszuk ki az Egyéni makrómunkafüzetben (Personal Macro Workbook) lehetıséget. A beállítások után kattintsunk az OK gombra. Amit mostantól csinálunk, azt az Excel rögzíti egy Keretezes nevő eljárásban. 3. Üssük le a CTRL+* billentyőkombinációt. Ezzel kijelöljük az aktuális adattartományt. 4. Válasszuk ki a Formátum (Format) > Cellák (Cells) utasítást. 5. Lapozzunk a Szegély (Border) lapra. 6. A tartomány külsı keretét állítsuk be kettıs vonalra. 7. Rajzoljunk egybefüggı vonalat a cellák közé. 8. Állítsuk meg a felvételt, azaz kattintsunk a Rögzítés vége gombra. Nézzük meg a felvétel eredményét, és amennyire lehet egyszerősítsük le a rögzített lépéseket. Sub Keretezes() ’ Keretezés Makró ’ Rögzítette: Kovalcsik Géza, dátum: 2005
séhez hozzunk létre egy adattartományt. Ebben állva fogjuk elindítani a felvételt.
Selection.CurrentRegion.Select Selection.Borders(xlDiagonalDown).LineStyle = xlNone Selection.Borders(xlDiagonalUp).LineStyle = xlNone With Selection.Borders(xlEdgeLeft) .LineStyle = xlDouble .Weight = xlThick .ColorIndex = xlAutomatic End With With Selection.Borders(xlEdgeTop)
.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
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:
.Colorlndex = xlAutomatic End With With Selection.Borders(xlInsideVertical) .LineStyle = xlContinuous .Weight = xlThin .Colorlndex = xlAutomatic
With
Selection.Borders(xlEdgeLeft)
.LineStyle = xlDouble .Weight = xlThick .Colorlndex = xlAutomatic End With
End With With Selection.Borders(xlInsideHorizontal) .LineStyle = xlContinuous .Weight = xlThin .Colorlndex = xlAutomatic
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ı:
End With End Sub
Ez az eljárás bizony elég hosszúra sikerült ahhoz képest, hogy alig állítottunk be valamit. Ezen van mit egyszerősíteni. Emlékezzünk arra, hogy miket állítottunk be. Az Excel minden állítási lehetıséget rögzített, még azokat is amikhez hozzá se nyúltunk. De vegyük sorra a lépéseket, és próbáljuk elhagyni a felesleges sorokat. Selection.CurrentRegion.Select
Az elsı sor az, amelyik kijelöli az aktuális adattartományt. Ez a sor az eredménye annak, hogy leütöttük a CTRL+* billentyő-kombinációt. A Selection kulcsszó arra a tartományra hivatkozik, amelyik éppen ki van jelölve. A CurrentRegion a kijelölt — Selection — környezetében található adattartományra hivatkozik, amit aztán a Select metódussal ki is jelölünk. Erre szü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
Selection.Borders(xlEdgeLeft).LineStyle = xlDouble
Hasonlóan végiggondolva a tartomány további széleinek a szegélyezését, az eljárásunk végül így fog mutatni. Sub Keretezés() ’ Keretezés Makró ’ Rögzítette: Kovalcsik Géza, dátum: 2005
Selection.CurrentRegion.Select Selection.Borders(xlEdgeLeft).LineStyle = xlDouble Selection.Borders(xlEdgeTop).LineStyle = xlDouble Selection.Borders(xlEdgeBottom).LineStyle = xlDouble Selection.Borders(xlEdgeRight).LineStyle = xlDouble With Selection.Borders(xlInsideVertical) .LineStyle = xlContinuous .Weight = xlThin
.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ó ' 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()
Selection.CurrentRegion.Select Selection.Borders(xlEdgeLeft).LineStyle = xlDouble Selection.Borders(xlEdgeTop).LineStyle = xlDouble Selection.Borders(xlEdgeBottom).LineStyle = xlDouble Selection.Borders(xlEdgeRight).LineStyle = xlDouble Selection.Borders(xlInsideVertical).LineStyle = _ xlContinuous Selection.Borders(xlInsideHorizontal).LineStyle = _ xlContinuous End Sub
Vajon ezen még lehet egyszerősíteni? Mindenképpen! Nézzük meg az elsı sort! Ott az áll, hogy jelöljük ki az aktuális cellák körül található adattartományt. Aztán a kijelölt tartománnyal végezzük el a beállításokat. Tényleg ki kell jelölni a tartományt ahhoz, hogy bekeretezzük? Nem! Elegendı csak hivatkozni. A második sortól kezdve a Selection hivatkozásokat cseréljük le Selection.CurrentRegion hivatkozásra. Az eljárásunk ilyenné válik: Sub Keretezés () ' Keretezés Makró ' Rögzítette: Kovalcsik Géza, dátum: 2005
v 1
Keretezés Makró Rögzítette: Kovalcsik Géza, dátum: 2005
With Selection.CurrentRegion .Borders(xlEdgeLeft).LineStyle = xlDouble .Borders(xlEdgeTop).LineStyle = xlDouble .Borders(xlEdgeBottom).LineStyle = xlDouble .Borders(xlEdgeRight).LineStyle = xlDouble .Borders(xlInsideVertical).LineStyle = xlContinuous .Borders(xlInsideHorizontal).LineStyle = xlContinuous End With End Sub
Tehát a felvétel finomítása során szabaduljunk meg a felesleges soroktól, majd a kijelöléseket írjuk át úgy, hogy azokból hivatkozás legyen. Ha lehetıség van rá, használjuk a With.. End With utasításpárt.
Tegyük fel, hogy többször is kapunk olyan listákat, amelyekben nincsenek teljesen kitöltve a sorok. A lista egyes oszlopaiba, csak akkor írnak be adatot, ha attól kezdve megváltozik az oszlop értéke. Ráadásul minden esetben más a mérete a listának. Nem ugyanannyi a sorok vagy oszlopok száma.
Tehát a 47. ábra bal oldalán látható lista elrendezésbıl szeretnénk a jobb oldalon lévı állapotot létrehozni. Erre több módszer is van, egyik gyorsabb a másik lassabb, de valahogy mégiscsak eredményre juthatunk. Elsı lépésként jelöljük ki a tartomány üres celláit. 1. Álljunk a tartomány egyik cellájára, olyan helyre, hogy a cellában legyen adat. 2. Üssük le a CTRL+* billentyőket. Ezzel kijelöltük az aktuális adattartományt. 3. Hajtsuk végre a Szerkesztés (Edit) > Ugrás (Go To) parancsot. 4. A megjelenı Ugrás panel alján találunk egy gombot, melynek a felirata Irányított (Special). Ha erre rákattintunk, akkor megjelenik egy újabb panel, amelyben hasznos kijelöléseket választhatunk. 5. Ebben a panelben jelöljük ki az Üres cellák (Blank Cells) választógombot, és kattintsunk a panel OK gombjára. Tehát most ott tartunk, hogy kijelöltük az összes üres cellát (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épleteket. 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 Operation:=xlNone,
Paste:=xlPasteValues,
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 makró felvételt, majd az eredményt kielemezve beépítjük a programunk megfelelı 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égrehajtani, 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ételekhez köthettük. Ezt úgy tehettük meg, hogy a program változóit vizsgáltuk, és ezek pillanatnyi értékétıl függıen hajtottunk végre más-más utasításcsoportokat. A mőveletek végrehajtását az objektumok eseményeinek bekövetkezésével is vezérelhetjük, így például meghatározhatjuk azt, hogy milyen utasításokat hajtson végre a program amikor megnyitunk egy munkafüzetet, vagy mi történjen, ha az egyik munkalapról egy másikra lapozunk. Az eseményeket az objektumok készítıi határozták meg, vagyis mi az elıre meghatározott eseményeket használjuk. Ebben a fejezetben ismerkedjünk meg az események kezelésével. A kérdések a következık: ♦ 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 munkafüzetet és lépjünk át a programozási környezetbe. Ennek legegyszerőbb módja, ha leütjük az ALT+F11 billentyő-kombinációt. Azt már láttuk, hogy kell elkezdeni egy új modult; most ismerkedjünk meg azzal, hogy hogyan használhatjuk az objektumok elıre elkészített moduljait. Amint átkapcsoltunk a programozási környezetbe, vegyük szemügyre a projekt ablakot. Itt megtaláljuk az egyes munkalapokhoz és a munkafüzethez tartozó modulok ikonjait. Ezek az adott munkafüzet lapjainak a nevét viselik. A munkafüzet modulját ThisWorkbook-nak nevezte el a program. Kattintsunk kettıt az egyik munkalap ikonjára (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.
Próbaként írjunk egy egyszerő parancsot az eseménybe. A kijelölt tartomány vagy cella hátterét színezzük be sárgára, amint kijelöljük az 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.
Ezután az ablak jobboldali listájából kiválaszthatjuk azokat az eseményeket, amelyekhez programot szeretnénk írni. Amint a listából kiválasztjuk a kiszemelt eseményt, a modullapon megjelenik egy eseményvezérelt eljárás. Ebbe az eljárásba kell leírnunk azokat az utasításokat, amelyeket akkor szeretnénk végrehajtani, amikor az adott esemény bekövetkezik. Az eseményeket minden munkalapon megtaláljuk, így ez munkalaponként más és más lehet. Amint a baloldali objektum listapanelbıl kiválasztottuk a Worksheet objektumot, rögtön megjelenik a munkalapok alapértelmezett eseményvezérelt eljárása, a SelectionChange. Ez az esemény akkor következik be, amikor megváltoztatjuk a munkafüzet celláinak a kijelölését. Vagyis amint az egyik tartomány helyett egy másikat jelölünk meg. Vegyük egy kicsit szemügyre ennek az eseménynek a szerkezetét. Figyeljük meg, hogy az eljárás neve mögötti zárójelben változó, vagy változók vannak. Mit kezdhetünk a változókkal? Ezek a változók a környezetrıl adnak át adatot ennek az eljárásnak. Az átadott értékeket megvizsgálhatjuk, és a változók tartalmától függıen vezérelhetjük a programot. A SelectionChange eseményben ez az érték a Target, ebbıl a változóból azt tudhatjuk meg, hogy a jelölés megváltoztatása után melyik az újonnan kijelölt tartomány. Ebben az eseményben különbözı mőveleteket hajthatunk végre az újonnan kijelölt Target objektummal.
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 programozásáról. Ezekbıl kiderül, hogy miként használhatjuk fel az eseményvezérelt eljárásokban kívülrıl kapott értékeket. Az elsı példában programozzuk úgy az egyik munkalapot, hogy annak az elsı két oszlopában található cellákat semmilyen módon ne lehessen kijelölni. Ha a felhasználó mégis az elsı két oszlop valamelyik cellájára kattintana, akkor automatikusan lépjünk át a harmadik oszlopba. Ott az a cella legyen aktív, amelyik sorba a felhasználó 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ásodik oszlopba kattint a felhasználó, akkor ne történjen semmi. Nyissunk meg egy új munkafüzetet. Lépjünk át a VBE-be. Nyissuk ki a Munkai munkalaphoz tartozó modult. A SelectionChange eseményvezérelt eljárásba írjuk be a következı programot:
Private Sub Worksheet_SelectionChange(ByVal Target As Range) If Target.Column < 3 Cells(Target.Row,
Then 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 kihasználva megvizsgáljuk, hogy az újonnan kijelölt tartomány bal felsı cellája benne van-e a munkalap elsı két oszlopában. Ha igen, akkor átlépünk a harmadik oszlopban vele azonos sorban lévı cellára. írjuk meg a kis programot, és próbáljuk ki a mőködését. Ha bármely tartomány kijelöléséhez szeretnénk programot írni, akkor éljünk azzal a lehetıséggel, hogy a Target tartomány jellemzıihez hozzáférünk. Megállapíthatjuk, hogy hányadik sorban és oszlopban kezdıdik. Ahogy azt is megtudhatjuk, hány soros és oszlopos a Target. Nézzünk egy másik példát! Ebben azt próbáljuk ki, hogy az eseményvezérelt eljárásokból hogyan lehet értéket visszaadni az objektumnak. Érdekes módon erre az eseményvezérelt eljárás zárójelei közé írt változókat használhatjuk fel. Ha a munkafüzet tetszıleges cellájára kettıt kattintunk, akkor a cella átmegy szerkesztési állapotba. A kettıs kattintás eseményhez a BeforeDoubleClick eljárást programozták. írjunk most egy olyan kiegészítı programot, amelynek a segítségével egy inputbox függvényben megadott értéket írunk abba a cellába, amelyre kettıt kattintott a felhasználó. Természetesen, miután az inputbox függvénnyel kitöltöttük a cellát, nincs szükség arra, hogy átkerüljünk szerkesztési állapotba. A felhasználói felületen a kettıs kattintás eredménye az, hogy az adott cellát átváltjuk szerkesztési állapotba. Mivel az inputbox adatát írjuk a cellába nincs szükség arra, hogy az adat beírása után átváltsunk szerkesztési állapotba. Arra, hogy a cella feltöltése után ne kerüljön a cella szerkesztési állapotba, a BeforeDoubleClick esemény Cancel változóját fogjuk felhasználni. A programban határozzuk meg azt is, hogy a mőveletet csak a munkalap második oszlopában a második sortól végezze így az Excel. Nézzük az eljárást! Nyissuk meg a munkafüzet második munkalapjához tartozó modult. Válasszuk ki a BeforeDoubleClick eseményvezérelt eljárását. Ebbe írjuk be a következı sorokat: Private Sub Worksheet_BeforeDoubleClick(ByVal Target As Range, Cancel As Boolean) Dim varAdat As Variant Const STR_UZENET As String = "Milyen adatot írjak a cellába?" Const STR_CIM As String = "Szerkesztés"
If Target.Column = 2 And Target.Row > varAdat = InputBox(STRJJZENET,
1
Then
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édpanel. Ebbe beírhatunk egy tetszıleges értéket. Amint a panel OK gombjára kattintunk, az adat bekerül abba a cellába, amelyikre kettıt kattintottunk. Ha az eljárás utolsó sorában nem adtunk volna True értéket a Cancel változónak, akkor az adat beírása után a kiválasztott cella szerkesztési állapotba kerülne. Mivel a Cancel változónak az if-en belül adtunk értéket, a többi cellában nem változik meg a kettıs kattintás hatása.
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 segítségével egy kisiskolás gyakorolni tudja az összeadást. A program adjon fel egy összeadási feladatot, majd egy meghatározott idı eltelte után írja ki az összeadás eredményét. Ennek a feladatnak az a célja, hogy megismerjük az idızítés esemény használatát. Elıször még csak gondolatban, egyszerő mondatokkal fogalmazzuk meg a program lépéseit. 1. Tegyünk rendet: az esetleges korábbi feladatok eredményeit tüntessük el a cellákból. 2. Egy-egy változóban rögzítsük a két számot, (bytA,bytB) amit össze kell adni. A számok egy és tíz közötti egész értéket 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ı elteltével kiírja a megoldást. Kezdjünk egy új munkafüzetet. Nyissuk meg a VBE programot. Az új munkafüzetben hozzunk létre egy új program modult. Ebbe az új modulba 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:C 2") = "" '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( " 0 0 :00:05"), "EredmKiir" End Sub
Ebbıl az egész feladatból az eljárás utolsó sora az, amit ennél a feladatnál meg kell beszélnünk. Az OnTime egy esemény figyelését állítja be. Ha az OnTime kulcsszó mögé a TimeValue függvényben egy pontos idıt írunk, akkor a következı paraméterként megadott eljárást a megjelölt idıben fogja végrehajtani az Excel. Ez azt jelenti, hogy a program figyeli az idıpont bekövetkezése eseményt, és amikor elérkezik a megfelelı pillanat, akkor végrehajtja az EredmKiir eljárást. A mi esetünkben azonban nem tudjuk elıre, hogy mikor kezd gyakorlásba a programunk felhasználója. Itt azzal a módszerrel állítjuk be a jelenlegi pillanattól számított öt másodpercet, hogy a Now értékhez — ez az aktuális jelenlegi idıpont — hozzáadunk öt másodpercet. Most nézzük meg azt az eljárást, amelyik kiírja az eredményt: Sub EredmKiir () Range( " E 2 " ) End Sub
= bytC
Ezzel az utasítással egy-egy kiválasztott billentyő leütését figyeltethetjük a programban. Hasonlóan az OnTime idıpont figyelését beállító utasításhoz, itt is meghatározhatjuk, hogy melyik billentyő leütése, melyik eljárás futtatását váltsa ki. Ezzel a figyeléssel a billentyőzet tetszıleges gombjához eljárást rendelhetünk. Ezt az eseményfigyelést is egy kis példával ismerjük meg. Az elızı feladatot folytassuk azzal, hogy amikor a program kiírja az eredményt, akkor kérdezze meg a program használóját, hogy kér-e újabb gyakorló feladatot. Ha kér, akkor ismét hajtsuk végre azt az eljárást, amelyik a feladatot feladja, ha nem akkor búcsúzzunk el. A válaszadást rendeljük hozzá egy-egy billentyőhöz, például az i bető leütése igen választ jelentsen, az n bető pedig nem választ. Az eredmény kiírás eljárást bıvítsük ki a következı utasításokkal. Sub EredmKiir() Range ("E2") = 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 megfelelı bető leütése után hajtunk végre. Sub Ujabb()
Application.OnKey "i" Application.OnKey "n" Gyakorlás End Sub Sub Vege() Application.OnKey "i" Application.OnKey "n" Range("A3") = "Szia majd legközelebb ismét talákozunk!" End Sub
Az eljárásokban objektumokat használunk. Sok esetben nem tudhatjuk elıre azt, hogy a használni kívánt objektum a futtatáskor a felhasználó rendelkezésére fog-e állni. Ha nincs meg minden eszköz azok közül, amit a program használna, akkor a program hibát fog jelezni. A programunknak megoldásokat kell adnia a felhasználónak és nem feladatokat. Vagyis ne kérjük meg a felhasználót arra, hogy ı hozza létre a program futtatásához szükséges környezetet. Errıl nekünk kell gondoskodnunk. Fel kell mérnünk azt a lehetséges környezeti hiányosságot, ami a program jó mőködését megakadályozná. Ezeket nekünk kell korrigálni futás közben. A hiba ugyanúgy esemény, mint a többi esemény, legalábbis abban az értelemben mindenképpen, hogy elıre nem tudjuk meghatározni, hogy mikor következik be. Az elıre felmérhetı hibákat futás közben kell kezelnünk. Ennek érdekében fel kell készíteni az eljárásokat arra, hogy a hibák kezelését mi programozhassuk. Az utasítás — amivel átvehetjük az Excel-tıi a hibák kezelését -, az On Error GoTo címke utasítás. Ha ezt elsı utasításként írjuk, akkor a program futása közben bekövetkezı összes hibát mi kezelhetjük le. A hiba figyelése minden esetben attól a sortól történik, ahova beírtuk az On Error utasítást. A hibát vagy az eljárás végéig figyelhetjük, vagy az On Error GoTo 0 utasítássorig. A hibakezelı részben létrehozhatjuk azt az objektumot, ami a program futtatásához szükséges, vagy visszatérhetünk a program megfelelı sorára. A további magyarázat helyett oldjunk meg egy egyszerő példát. Tegyük fel, hogy az egyik eljárásunkban egy munkalapra hivatkozunk. Nem tudhatjuk elıre azt, hogy abban a munkafüzetben, amelyikben ezt a mőveletet végre szeretnénk hajtani, valóban van ilyen nevő munkalap. Még az is lehet, hogy valamikor volt, csak közben a felhasználó törölte. Ha az eljárásunk nem létezı lapra hivatkozik, akkor a program hibajelzéssel megáll, és nem hajtja végre az utána következı utasításokat. Mi lehet a megoldás? Megkérdezhetjük például a felhasználót, hogy beszúrjunk-e egy új munkalapot, vagy esetleg kérdezés nélkül beszúrhatunk egy új munkalapot, aminek a neve megegyezik a keresett lap nevével és ismét megkísérelhetjük végrehajtani azt az utasítást, ahol a hiba megtörtént. Egy új munkafüzetben hozzunk létre egy modult és írjuk meg a következı kis eljárást. Sub LapNincs ()
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.
Worksheets("Nincs").Range("Al") End Sub
=
"Bármi adat"
Ebben az eljárásban egy Nincs nevő munkalapra szeretnénk írni. Lehet, hogy korábban volt ilyen lap, de most nincs. így az eljárás nem hajtó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ássort. Most csak annyit teszünk, hogy figyelmeztetjük a felhasználót arra, hogy nincs olyan munkalap, amire dolgozni szeretne. A programot bıvítsük ki a következı sorral: Sub LapNincs_megoldas() On Error GoTo HibaLapNincs Worksh eets("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 bekövetkezett. Ezt a Resume 0 utasítással tehetjük meg. Tehát most már van megfelelı munkalapunk, ráírtuk a szöveget. Mivel a hibát kezelı utasítások a fenti utasítások után következnek, a program szolgaian ezeket is végre fogja hajtani. Ezt úgy kerülhetjük el, hogy a hibakezelı címke elıtt kilépünk az eljárásból. Ha a hibakezelést így hagyjuk, akkor minden bekövetkezett hiba esetén beszúrunk egy új munkalapot az aktuális munkafüzetbe és visszatérünk arra az utasításra, amelyik a hibát okozta. Ez azért nem jó, mert a hiba ismét bekövetkezik. Eredményként megint a hibakezelı utasításokra lépünk. Belátható, hogy ez így az idık végezetéig körbejár, anélkül, hogy bármi is történne a gépünkön. Most oldjuk meg azt is, hogy ne minden hiba bekövetkezése esetén hajtódjanak végre a hibakezelı utasítások, csak akkor, ha a mi hibánk következik be. Ezt a hibakezelı részbe írt egyetlen // utasítással oldhatjuk meg. Sub LapNincs_megoldas_2() On Error GoTo HibaLapNincs Worksheets("Nincs").Range( " A l " ) Exit Sub HibaLapNincs: If Err.Number = 9 Then Worksheets.Add.Name = "Nincs" Resume 0 Else Error Err End If End Sub
=
"Bármi
adat"
Elemezzük ki a félkövér betős utasításokat. Az If Err.Number = 9 Then vizsgálat azt a hibát engedi kezelni, amelyikre mi figyeltünk. Ezt a hibakódot az elsı futtatáskor jegyezhettük fel. Ha több hibára is számítunk, akkor azoknak a kódját is vizsgálnunk kell. Az If szerkezet Else ágában szereplı Error Err utasítássor továbbra is ugyanolyan hibaüzenetet fog adni, mint amikor nem mi kezeltük le a futás közben elıforduló hibákat. Természetesen ez a program leállásával is fog járni.
Kapcsoljuk be az Immedaite ablakot és adjunk ki egy MsgBox parancsot. Kezdjük el begépelni a következı sort:
Egyik-másik eljárásban szükség lehet arra, hogy az eljárás végrehajtása közben további adatokat kérdezzünk a gép elıtt ülı felhasználótól. Erre a két legegyszerőbb eszköz, az InputBox és az MsgBox utasítások. A párbeszéd másik eszköze az Office segéd — Assistant — lehet. Ez a Microsoft Office eszköze, így minden Office alkalmazásban elérhetjük. Használhatunk őrlapokat is arra, hogy a felhasználó elvégezze az eljárás közben szükséges beállításokat. Ebben a fejezetben néhány egyszerő példa segítségével megismerkedünk a kapcsolatot megvalósító eszközökkel. A fejezet a következı kérdésekre ad választ: ♦ 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 üzenhetünk, hanem adatot is kérhetünk a felhasználótól. Ezzel a felhasználó közvetlenül vezérelheti a program futását. Ezek az MsgBox és az InputBox. A „Vezérlés eseményekkel" címő fejezet végén a „Futásidejő hibakezelés" szakaszban megpróbáltunk egy olyan munkalapra adatot írni, amelyik nem is volt a munkafüzetben. Akkor a feladatot úgy oldottuk meg, hogy senkitıl nem kérdeztünk semmit, hanem beszúrtunk egy új munkalapot. Lehet, hogy a felhasználó nem így tett volna, ha megkérdezzük a véleményét. Ezt megtehettük volna egy MsgBox utasítás segítségével. Mielıtt megoldanánk a feladatot, vizsgáljuk meg az MsgBox utasítást. Töltsük be az Excel-t és kapcsoljunk át a Visual Basic Editor felületre.
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 lehetıség. Ha ezek a gombok csak a megjelenítést szolgálják, akkor nem sokra megyünk velük. Jó lenne a programban annak megfelelıen elágazni, hogy a felhasználó melyik gombra kattintott. Ha például az Igen-t választotta, szúrjuk be az új munkalapot, ha a Nem gombot választotta, állítsuk le az eljárást. Az MsgBox-ot kétféleképpen használhatjuk. Eddig csak a felhasználó tájékoztatására használtuk, de nem volt fontos a számunkra a felhasználó választása. Ahhoz, hogy ki tudjuk értékelni a felhasználó válaszát, az MsgBox függvény változatát kell használnunk. Ez pontosan ugyanazt tudja, mint az eljárás változat, csakhogy most visszakapjuk a felhasználó válaszának megfelelı értéket. Lényeges különbség az, hogy most az argumentumokat zárójelek között kell felsorolnunk. Az Immedaite ablakban próbáljuk ki a következı utasítássort: ?msgbox("Ü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árolhatjuk 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:
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
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érdezzük meg a felhasználót az új munkalap beszúrásáról. Ha kéri, hajtsuk végre a beszúrást és a program többi részét, ha nem, lépjünk ki az eljárásból. Bıvítsük ki ezt a következı módon: Sub LapNincs () Dim bytValasz As Byte On Error GoTo HibaLapNincs Worksheets("Borító").Range("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
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. Ellenkezı esetben — ha a felhasználó nem kéri az új lapot — kilépünk az eljárásból, hiszen nincs hova beírnunk az adatot. Egy kis figyelmesség a felhasználónak az, ha még egy kérdıjelet is megjelenítünk az MsgBox panelen. Megtehetjük, mert ezeket a belsı állandókat úgy találták ki, hogy összeadva az egyik és másik értéket egyszerre két megjelenítést is beállíthatunk. írjuk át az MsgBox sort a következıre: bytValasz = MsgBox ("Beillesszem a Borító nevő munkalapot?",
vbYesNo+vbQuestion)
Nyissunk meg egy üres munkafüzetet és kapcsoljunk át a programszerkesztıbe. A jelenlegi munkafüzetbe szúrjunk be egy új modult. Az új modulba írjunk egy eljárást, amelyik figyelmezetı üzenetet küld. Az üzenet megjelenítésére használjuk a segéd objektumot. írjunk egy egyszerő példát, amelyikben a segéd megkérdezi, hogy láthatóak legyenek-e a munkalap cellarácsai. Ha a felhasználó az igen gombra kattint, akkor jelenítsük meg, ha a nem gombra, akkor rejtsük el a cellarácsokat. Sub Racsok()
Dim blnCellaRacs As Balloon Dim intValasz As Integer Const STR_CIME As String = "Cellarácsok" Const STR_KERDES As String = "Láthatóak legyenek a cellarácsok?" Set blnCellaRacs = Assistant.NewBalloon 'Az üzenetballon 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 Elself intValasz
=
-4
=
True
=
False
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.
Then
ActiveWindow.DisplayGridlines
.Heading = STR_CIME
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:
Ennek a tulajdonságnak a beállítása az üzenet ballon címét adja. Erre az eljárás elején deklarált állandót használjuk fel ugyanúgy, mint az üzenet-ballon szövegét megjelenítı Text tulajdonság beállítása során. .Button = msoButtonSetYesNo
A fenti utasítássornak a feladata az, hogy az üzenet megjelenítése során az igen és a nem gombok megjelenjenek az üzenet alján. Ebben a sorban ismét egy Office állandót használtunk. Ezeket ismét a VBE kínálatából választhatjuk ki. .Animation = msoAnimationGestureUp
A segéd különféle animációkra képes. Ezeket mi határozhatjuk meg azzal, hogy az Animation tulajdonságnak megfelelı értéket adunk. Ezek is a VBE által felkínált állandók alapján választhatók ki. Az állandók nevébıl kiderül, hogy mit fog mővelni a kis segéd.
Elemezzük ki az elkészített eljárást. Az eljárás elsı soraiban deklaráljuk azokat a változókat és állandókat, amelyeket használni fogunk. A blnCellaRacs változó segítségével leegyszerősítjük az üzenet hivatkozását. A intValasz változót a kérdésre adott válasz átmeneti megırzésére használjuk fel. A STR_CIME állandó a ballon címe, míg a STR_KERDES a feltett kérdés szövege lesz. Set blnCellaRacs = Assistant.NewBalloon
intValasz = .Show
Ennek az utasítássornak kettıs szerepe van. Az egyik az, hogy megjelenítse a segédet és az elıkészített üzenetet. A másik feladata pedig az, hogy a intValasz változóban megırizzük a választ. Ha válaszként az Igen gombra kattintunk, akkor a intValasz értéke -3 lesz, ha pedig a Nem gombra, akkor -4. A változóban tárolt értékektıl függıen vagy megjelenítjük a cellarácsokat, vagy elrejtjük. If intValasz = -3 Then ActiveWindow.DisplayGrldlines
= True
Elself intValasz = -4 Then ActiveWindow.DisplayGridlines = False End If
.CheckBoxes(2).Checked = Application.DisplayStatusBar .CheckBoxes(3).Checked = Application.DisplayFormulaBar .CheckBoxes( 4 ) .Checked = ActiveWindow.DisplayWorkbookTabs intValasz =
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.
.Show
If intValasz = -1 Then ActiveWindow.DisplayGridlines = Application.DisplayStatusBar = Application.DisplayFormulaBar =
Assistant.Animation = msoAnimationldle
.CheckBoxes(1).Checked
.CheckBoxes(2).Checked .CheckBoxes(3).Checked
ActiveWindow.DisplayWorkbookTabs = .CheckBoxes(4).Checked End If
Bizonyos animációk az utasítás kiadása után is folyamatosan ismétlıdnek, ezért tanácsos visszaállítani (Idle) vagyis üresjárat állapotba tenni az animációkat.
A következı példában tegyük lehetıvé, hogy a segéd felhasználásával az Excel beállításai közül egyszerre több jellemzıt is megváltoztasson a felhasználó. Ehhez jelölınégyzeteket fogunk megjeleníteni a segéd ballonjában. Ehhez a CheckBoxes tulajdonságokat kell beállítanunk. Ennek indexeltnek kell lennie, de ötnél több jelölınégyzetet nem használhatunk egy üzenet során. Az eljárás elején vizsgáljuk meg az átállítani kívánt tulajdonságok értékét, és ezeknek megfelelıen állítsuk be az üzenet jelölınégyzeteit.
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 értékét megváltoztathatjuk. Ha az OK gombra kattintunk, akkor az eljárás végrehajtja a megfelelı beállításokat. Az eredmény a következı lesz:
Sub Beállítások () Dim blnBeallitas As Dim intValasz As Dim strSzovegek(4) Dim inti As
Balloon
Integer As String
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"
Wi t h b l n Be a l l it a s .Heading = STR_CIME .Text = STR_KERDES .Button = msoButtonSetOkCancel For inti = 1 To 4
.CheckBoxes(inti).Text = strSzovegek(inti) Next inti .CheckBoxes(1).Checked = ActiveWindow.DisplayGridlines
Elemezzük ki ennek az eljárásnak az utasításait is. Természetesen az eljárás a változók és állandók deklarálásával kezdıdik. Ezután a változók kezdeti értékét állítjuk be, melyeket most ne elemezzünk. Kezdjük a With blnBeallitas utasítássortól. Elsıként tisztázzuk, hogy mi az a blnBeallitas. Egy korábbi sorban deklaráltuk a blnBeallitas objektumváltozót. Ennek a változónak abban a sorban adtunk értéket, amelyik a Set kulcsszóval kezdıdik. Itt blnBeallitas névvel láttuk el a segéd ballonját. Ettıl kezdve a létrehozott új ballonra ezzel a névvel hivatkozhatunk. A With kulcsszót már korábban megismertük. Ennek az a feladata, hogy a mögé írt objektum tulajdonságait beállíthassuk.
Ezért fogunk ponttal kezdıdı utasítássorokat találni. A pont mögött tulajdonságok vannak. Ezek elé 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 tartalmazó sorig. .Heading = STR_CIME .Text = STR_KERDES .Button
= msoButtonSetOkCancel
Ezek a sorok az üzenet címét, szöveges magyarázatát és a panel alján megjelenı gombokat határozzák meg. Az elsı két utasításban felhasznált állandókat az eljárás korábbi részében deklaráltuk, kivéve a Button tulajdonság beállításához használt mso kezdetőt. Ez az Office állandója, amit a VBE felkínál a program írása során. Ettıl jelennek meg az üzenet alján az OK és Mégse gombok.
For inti = 1 To 4
.CheckBoxes(intI).Text = strSzövegek(intI) Next inti
Ebben a ciklusban a jelölınégyzetek szövegét adjuk meg. Ez a CheckBoxes objektum Text tulajdonság beállításával történik. Ennek eredményeként jelennek meg a jelölınégyzetek. Tehát a jelölınégyzetek attól látszanak, hogy a Text tulajdonságának értéket adunk. A CheckBoxes objektum indexe azt határozza meg, hogy hányadik legyen a sorrendben a megjelenítendı jelölınégyzet. Tehát a fenti ciklus négy jelölınégyzetet fog megjeleníteni, azokkal a feliratokkal, amelyeket korábban letároltunk a strSzövegek tömbben.
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 további mőveleteket ennek a változónak az értékétıl függıen hajtjuk végre. Ha ugyanis az OK gombot választotta a felhasználó, akkor végrehajtjuk a jelölınégyzetben beállított változtatásokat, ha a Mégse gombra, akkor megtartjuk az eredetieket. If intValasz = -1 Then ActiveWindow.DisplayGridlines = .CheckBoxes (1) .Checked Application.DisplayStatusBar = .CheckBoxes(2).Checked Application.DisplayFormulaBar = .CheckBoxes(3).Checked ActiveWindow.DisplayWorkbookTabs = .CheckBoxes(4).Checked End If
Ha tehát az intValasz értéke -1, akkor változtatunk. Ezért vizsgáljuk az If utasításban azt, hogy a intValasz értéke -1. Ha igen, akkor végrehajtjuk a jelölınégyzetekben meghatározott beállításokat. Ha az üzenetben a Mégse gombra kattint a felhasználó, akkor a beállításokat végzı utasítássorokat nem hajtja végre a program. Az ezt követı End With sor lezárja a blnBeallitas objektum tulajdonságainak beállítását és vizsgálatát.
.CheckBoxes( 1 ) .Checked = ActiveWindow.DisplayGridlines .CheckBoxes( 2 ) .Checked = Application.DisplayStatusBar . CheckBoxes( 3 ) .Checked = Application.DisplayFormulaBar . CheckBoxes ( 4 ) .Checked = ActiveWindow.DisplayWorkbookTabs
Ebben a négy sorban a jelölınégyzetek kijelzését beállítjuk a módosítani kívánt tulajdonságok jelenlegi érté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égyzetek tükrözik a környezeti beállításokat.
A választócsoportból egyet használhatunk az Office segéd üzenetében. Tegyük fel, hogy egy cellába az engedmény mértékét szeretnénk beírni. A segéd ballonjában választócsoport használatával maximum öt választógombot használhatunk. Ezek a mi példánkban legyenek a 2%, 5%, 8% , 10% és 12% értékek. Ha a ballonban megjelenı Mégse (Cancel) gombra kattintunk, akkor nem adunk engedményt. 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 jelení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:
Az üzenet elıkészítés elsı sora a With blnEngedmeny sor. Mint már korábban is láttuk, a With utasítást akkor használjuk, ha ugyanannak az 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.
Sub Engedmény () Dim blnEngedmeny As Balloon
.Heading = STR_CIME
Dim intEredm As
.Text = STR_KERDES
Integer
Dim strSzazalek(5) Dim inti As
As
String
.Button
= msoButtonSetCancel
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
Ebben a három sorban meghatározzuk az üzenet ballon címét, üzenetének a szövegét és azt, hogy milyen gomb jelenjen meg az üzenet alján. A Heading tulajdonság az üzenet címkéje. Ennek az értékét az eljárás elején deklaráltuk. A Text a ballonban megjelenı kérdés szövege, amit szintén már korábban meghatároztunk és végül a gomb beállítására az Office állandók egyikét használtuk fel. For I = inti To 5 .Labels(inti).Text = Next
strSzazalek(inti)
inti
.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álandó állandókat. Ezek használatáról majd a programsorok értelmezése során ejtünk szót.
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 ciklusszá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
Set blnEngedmeny = Assistant.NewBalloon
Ebben az utasítássorban elnevezzük az Assistant.NewBalloon által létrehozott objektumot blnEngedmeny névvel. Ennek a feladata a hivatkozás leegyszerősítése, amivel már a korábbi feladatok megoldásánál is találkoztunk.
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áltozó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ábban 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.
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 jeleníthetjük meg, hogy kettıt kattintunk az őrlap területére. Késıbb ugyanezzel a módszerrel jeleníthetjük meg a vezérlésekhez tartozó osztály modulokat is. Az őrlap programozása eseményekkel történik. Ez a modul is . osztálymodul, mint a munkafüzeté vagy a munkalapé. Ez azt is jelenti, hogy itt sem érdemes globális változót deklarálni, mert a modul bezárja azt. Rajzoljunk egy CommandButton vezérlést az őrlapra.
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.
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
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.
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 megfelelı értékeket. A legfontosabb, hogy amint felrajzoltuk, nevezzük el. Persze a többi tulajdonság beállítását is célszerő ilyenkor elvégezni. Ha figyelmesen szemléljük az 58. ábrát, é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ánkat tesszük könnyebbé. Hasonlóan nevezzük el az őrlapot is. Ennek az elıtagja lehet frm az angol Form szóra utalva. A mostani form neve például legyen frmProba. Miután mindezzel végeztünk, nézzük meg az őrlaphoz tartozó modult, és ismerkedjünk meg az őrlap eseményeivel. Ugyanebben a modulban fogjuk találni az őrlapra helyezett vezérlések eseményeit is.
re szeretnénk hivatkozni, akkor kezdhetjük a hivatkozást a Me szócskával. Ha ezután egy pontot teszünk, a felkínált listában megtaláljuk az őrlapon elhelyezett összes vezérlı objektumot. A következı megoldandó feladat az, hogy ne csak a Visual Basic Editorból lehessen elindítani az őrlapot. Ha visszakapcsolunk az Excelbe, megpróbálhatjuk a Makró párbeszédpanelbıl elindítani, de ott egy kis csalódás fog érni minket. Nincs az őrlap az indítható elemek listájában. Az indításhoz nekünk kell megírnunk egy eljárást, amivel akár egy billentyő-kombinációval is mozgásba hozhatjuk az őrlapot. Szúrjunk be tehát egy általános modult a projektünkbe, és írjuk meg az őrlap indító eljárást. Nem lesz bonyolult, de ezt meg kell írnunk. íme: Sub
frmProbaStart()
frmProba.Show End Sub
Á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. Ahhoz, 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.
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ényeinek megfelelıen. Oldjuk meg most ugyanezt őrlap alkalmazásával. Hozzunk létre egy egyszerő párbeszédpanelt, amiben ugyanazokat a beállításokat lehet elvégezni. Az őrlapra helyezzünk el négy CheckBox vezérlést. Ezekkel fogjuk elvégezni a beállításokat. Rajzoljunk a panelre egy parancsgombot is. Ennek egyetlen feladata lesz, éspedig az, hogy miután elvégeztük a beállításokat, bezárjuk vele az őrlapot. Rajzoljuk meg tehát a következı párbeszédpanelt:
Private
Sub cmdClose_Click()
Unload Me End Sub
Bár rövid kis utasításról van szó, mégis elemezzük ki. Az Unload kitessékeli azt az objektumot 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 éppen a programot írjuk. Tehát a parancs azt az őrlapot zárja be, amelyikben ezt a parancsot kiadtuk. Ha az őrlapon elhelyezett vezérlések egyiké-
Rajzoljuk fel a négy jelölınégyzetet az őrlapra. Ha a jelölınégyzet gombra kettıt kattintunk, akkor egyszerre több ilyen vezérlést is rajzolhatunk. Miután megrajzoltuk a négy jelölınégyzetet, rajzoljunk egy 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: Name:
Gyors beállítások frmGyorsBeallitas
2. CheckBoxl Caption: Name:
Cellarácsok chkCellaRacsok
5. CheckBox2 Caption: Name:
Munkalap fülek chkLapFulek
4. CheckBox3 Caption: Name:
Állapotsor chkAllapotsor
5. CheckBox4 Caption: Name:
Szerkesztóléc chkSzerkLec
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 billentyő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ésbe. Ha a Cancel tulajdonság értéke True, akkor azt az ESC billentyő leütése mőködteti. Ennek megfelelıen a mi bezárás gombunk az ALT+B, az ENTER és az ESC billentyők leütésétıl is mőködésbe lép.
Ezután kezdjük el a panel programozását. Kezdjük a cmdBezaras gombbal. Ebbe azt a parancssort kell beírnunk, amivel bezárhatjuk az őrlapunkat. A leggyorsabban úgy juthatunk el a parancsgomb Click - kattintásra — eseményébe, ha kettıt kattintunk a gombra. Private Sub cmdBezaras_Click()
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 eseményeiket programozni kezdenénk. Az eseményvezérelt eljárások nevei ugyanis tartalmazzák a vezérlı objektum nevét. Egy késıbbi átnevezéssel az eseménybe írt utasítások a korábbi névvel ellátott eseményben maradnak. Ezzel csak 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
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, írjuk bele a következı sort. ActiveWindow.DisplayGridlines = chkCellaRacsok
Ebben az utasításban a chkCellaRacsok vezérlés pillanatnyi értékét használtuk fel arra, hogy láthatóvá tegyük, vagy elrejtsük az aktív ablak cellarácsait. A CheckBox vezérlések két állapotúak. Ha bekapcsoljuk, az értéke True, kikapcsolva pedig False. A DisplayGridlines tulajdonság beállításához szintén logikai értéket kell írnunk. Tehát az egyik objektum tulajdonságának értékét átadjuk egy objektum tulajdonságának. A többi beállítást hasonlóan fogjuk megvalósítani. A chkLapFülek Change eseményéhez írjuk a következı sort:
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ánaolvasnunk. Ezeket programozni is lehet. Ha kevésnek ítélnénk a rendelkezésünkre álló vezérléseket, a kereskedelemben újabbakat vehetünk. Ebben a részben ismerkedjünk meg néhány vezérlés használatával.
ActiveWindow.DisplayWorkbookTabs = chkLapFülek
Az Állapotsor jelölınégyzet Change eseményéhez a megfelelı utasítássor a következı: Application.DisplayStatusBar = chkAllapotsor
A Szerkesztıléc feliratú gomb utasítássora pedig ez legyen: Application.DisplayFormulaBar = chkSzerkLec
Próbáljuk ki a munkánk eredményét. Álljunk az őrlapra és üssük le az F5-ös funkcióbillentyőt. Amint á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 állapotot mutatják, amit a környezet szerint mutatniuk kellene. Ezeket a beállításokat az őrlap megnyitása során kell beállítanunk. Az őrlap megnyitásakor bekövetkezı esemény, az Initialize aktiválódik. Vagyis azok az utasítások, amelyeket ebbe az eseményvezérelt eljárásba írunk, akkor fognak lefutni, amikor az őrlapot megnyitjuk, használatba vesszük. Kattintsunk hát kettıt az őrlapra. Keressük meg a Initialize eseményt, és írjuk be az eljárásba a következı sorokat: chkCellaRacsok = ActiveWindow.DisplayGridlines chkLapFülek = ActiveWindow.DisplayWorkbookTabs chkAllapotsor = Application.DisplayStatusBar
Ebben a példában közvetlenül adunk át adatot egy őrlapon elhelyezett TextBox vezérlésbıl a munkafüzet egyik cellájába. Nyissunk meg egy új munkafüzetet. Kapcsoljunk át a VBE ablakba. Az új munkafüzetbe szúrjunk be egy felhasználói párbeszédpanelt. A panelre helyezzünk el egy TextBox vezérlést. Jelöljük ki és a tulajdonságablakban keressük meg a ControlSource tulajdonságát. Ennek a tulajdonságnak legyen az értéke A1. Ezzel meghatároztuk, hogy a mindenkori aktív munkalap A1-es cellájába kerüljön az a szöveg, amit az őrlap beviteli mezıjébe írtunk. Ezután üssük le az F5-ös funkció-billentyőt. A panel indításának az eredményeként a VBE-ból átkerülünk az Excelbe. Vagyis a létrehozott párbeszédpanel az Excel területe fölött fog megjelenni. írjunk be egy tetszıleges szöveget a beviteli dobozba, majd zárjuk le az őrlapot. Erre használjuk az őrlap jobb felsı sarkában található x-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 esetén is megtehetjük. Ahhoz, hogy létrehozzunk egy olyan őrlapot, amelynek a segítségével adott cellák tartalmát tölthetjük fel, nem is kell programoznunk. Ha a munkafüzet egy meghatározott munkalapjának az 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.
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.
Ugyanezt a feladatot oldjuk meg programozással is. Ebben a megoldásban azonban nem a ControlSource tulajdonságot fogjuk felhasználni, hanem a beviteli doboznak azt az eseményét, ami a beviteli doboz tartalmának a megváltozásakor következik be. Töröljük a ControlSource tulajdonság értékét. Kattintsunk kettıt a beviteli dobozra. Erre azért van szükség, hogy megjelenjen a beviteli dobozhoz tartozó modul. Ennek a vezérlésnek az
alapértelmezett eseménye az adatváltozás. A TextBoxl_Change eljárásban állunk. Ebbe írjuk be a következı utasítássort: Worksheets("Munkai").Range("Al")
szítsuk elı a listát a Munka2 (Sheet2) munkalapon. A lista elkészítése után kapcsoljunk át a VBE programba.
= 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 őrlapban dolgoztuk fel. Ez most csak annyiból állt, hogy a beírt adatot átmásoltuk a kiválasztott cellába. Hasonlóan használhatjuk a jelölı négyzetet, vagy a léptetı gombot is. A vezérléseket tehát használhatjuk a kezdeti tulajdonságok beállításával, ilyenkor a munkalapon dolgozzuk fel a bevitt adatokat, vagy használhatjuk a vezérlés programozásával, ebben az esetben valamelyik eseményt használjuk fel arra, hogy megírjuk azokat az utasításokat, amelyekkel feldolgozzuk a beírt adatokat. Az adatátadás másik módja, amikor adatátadás közben kódoljuk az adatokat. Ehhez a Választócsoport, a Kombinált Lista é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 lenyitásával jeleníthetjük meg. A listában felsorolt adatokat úgy használhatjuk fel, hogy lenyitjuk a listát és rákattintunk a megfelelı sorra. A kiválasztott listaelemet a program segítségével feldolgozhatjuk vagy a megfelelı cellába juttathatjuk. Ahhoz, hogy kombinált listát tudjunk használni, meg kell adnunk azt, hogy milyen adatok jelenjenek meg a lista lenyitásakor. Ehhez a kombinált lista RowSource tulajdonságának kell értéket adnunk. A másik lényeges tulajdonság a ControlSource. Ebbıl olvashatjuk ki azt, hogy a lista melyik elemét választotta ki a felhasználó. Ezeket a tulajdonságokat kétféle módon határozhatjuk meg. Az egyik esetben egy munkalap megfelelı tartományára hivatkozunk, a másik esetben programozással határozzuk meg a RowSource és a ControlSource tulajdonságok értékeit. A következı példát úgy oldjuk meg, hogy tartományokat használunk a tulajdonságok beállítására. Készítsünk egy őrlapot, amelyikre 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 elsı munkalap Al-es cellájába. Nyissunk meg egy új munkafüzetet és ké-
A Insert > UserForm utasítással szúrjunk be egy őrlapot az aktuális projektbe. Az új őrlapra rajzoljunk egy kombináltlista vezérlést. Kattintsunk rá az egér jobb gombjával és válasszuk ki a Properties utasítást. Keressük meg a RowSource tulajdonságot és írjuk be a sorforrás helyét, a Munka2!A2:A7 hivatkozást. Ezután keressük meg a ControlSource tulajdonságot. Ide írjuk be a 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 megjelenı párbeszédpanelben nyissuk le a kombinált listát és válasszunk egy várost. Ezután zárjuk le az őrlapot és nézzük meg a Munkai munkalap Al-es celláját. Itt megtaláljuk a kiválasztott város nevét. Ez volt a legegyszerőbb módja annak, hogy kombinált listát használjunk.
Más esetben a sorforrás több oszlopot is tartalmazhat. Ilyet használunk például akkor, amikor azt szeretnénk megoldani, hogy amikor a listából kiválasztjuk egy termék nevét, a választás eredményeként a termék ára jelenjen meg egy cellában. Ennek a példának a megoldását azzal kezdjük, hogy ugyanebben a munkafüzetben a Munka2 munkalapon - a 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 tulajdonsághoz írjuk be: Munkal!A1. A vezérlésnek meg kell mondanunk, hogy most két oszlopból kell megjelenítenie az adatokat, ezért a ColumnCount (oszlop-szám) tulajdonsághoz írjunk be egy kettes számot. Ide mindig azt kell beírnunk, hogy hány oszlopa van a kombinált lista sorforrásának. A következı lépésben határozzuk meg azt is, hogy a két oszlop közül melyiket szeretnénk felhasználni. Ezt a BoundColumn (kötött oszlop) tulajdonságban állíthatjuk be. Tehát írjuk be annak az oszlopnak a számát, amit a ControlSource tulajdonságban meghatározott cellába szeretnénk írni. Ez az árakat tartalmazó második oszlop. Ha szükséges, még azt is megadhatjuk, hogy a lista lenyitása után milyen szélesek legyenek a sorforrás egyes oszlopai. A ColumnWidths (oszlopszélességek) tulajdonságban soroljuk fel az oszlopok szélességét. Az egyes szélességeket egymástól pontosvesszıvel válasszuk el. Ide gépeljük be az 1 cm; 0 cm szélességeket. Amint kilépünk a tulajdonságból az Excel átírja a mértékegységeket pontra. A második oszlopnak azért adtunk nulla értéket, hogy a listában ne jelenjen meg az ár, csak a megnevezés. A tulajdonságok meghatározása után jelöljük ki az őrlapot és indítsuk el. Ezt megtehetjük a szokásos módon 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.
megírni. Az ideírt utasításokat akkor hajtja végre a program, amikor az őrlapot megnyitjuk. Ismét oldjuk meg az elızı két feladatot, de most a sorforrást programból határozzuk meg. Szúrjunk be a projektbe egy újabb őrlapot. Erre helyezzünk el egy kombinált lista vezérlést. Egy papírra írjuk fel a kombinált lista nevét, amit a tulajdonságablakban nézhetünk meg. Kattintsunk kettıt az őrlap területére. A megjelenı objektum modul megjelenése után válasszuk ki az Initialize esemény eljárást. Határozzunk meg egy tömböt, majd állítsuk be a lenyitott lista tartalmát. Az eljárás a következı lesz: P ri v a te
strVarosok( 0 )
=
As
String
"Érd"
strVarosok( 1 )
=
"Szeged"
strVarosok(2)
=
"Pécs"
strVarosok( 3 )
=
"Szolnok"
strVarosok( 4 )
=
strVarosok( 5 )
=
"Budapest" "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ömböt használtuk fel a listasorok meghatározására, de nem írtunk mögé zárójelet vagy indexet. Ez ebben az esetben így helyes. Tehát, ha programból határozzuk meg a sorforrást, akkor a tömb nevét index és zárójel nélkül használjuk. Ha programból szeretnénk használni a lista eredményét, akkor ismét a lista tulajdonságot fogjuk igénybe venni. A kombinált lista List tulajdonságát ugyanúgy használhatjuk, mintha egy tömb lenne, vagyis a ComboBoxl.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 megjeleníteni, amelyiket kiválasztottuk a listából. Ezt a ComboBoxl .ListLndex 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
A sorforrás megadásának másik módszere, amikor a lista elemeit tömbben deklaráljuk és programból a meghatározott tömböt használjuk a lista sorforrásaként. A sorforrás értékeinek beállítását akkor érdemes végrehajtani, amikor az őrlapot betöltjük, használatba vesszük. Ezért a sorforrás tulajdonságot az őrlap Initialize eseményvezérelt eljárásában fogjuk
S u b Us e rF o rm _In i t i al iz e ()
Dim strVarosok( 5 )
Sub ComboBoxl_Change()
Worksheets("Munkai").Cells( 1 ) End Sub
= ComboBoxl.Value
Próbáljuk ki az őrlap mőködését. Figyeljük meg azt is, hogy miután kiválasztottuk a listapanel egyik elemét, az eredmény azonnal megjelenik a Munkai lap Al-es cellájában. Oldjuk meg a másik feladatot is programozással, vagyis a lenyitott listában jelenítsük meg a termékek nevét. A termék kiválasztása után a 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,
As
String
1)
strVarosok( 0 )
=
"Érd"
strVarosok( 1 )
=
"Szeged"
strVarosok( 2 )
=
"Pécs"
strVarosok( 3 )
=
"Szolnok"
strVarosok( 4 )
=
strVarosok( 5 ) strAruk(0,
=
"Budapest" "Vác"
0) = "Rádió"
strAruk(0,
1) = "28000"
s t r A r uk ( l ,
0) =
strArukd,
1) = "65000"
strAruk(2,
0) = "Magnetofon" 1) = "29300"
strAruk(3,
0) =
strAruk(3,
1) = "34000"
"CD lejátszó"
strAruk(4,
0) = "Videó"
strAruk(4,
1) = "70000"
ComboBox2.List
=
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 haszná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 sorforrást a munkalap tartományából határozzuk meg, akkor az eredményt az elıbb leírt módszerrel feldolgozhatjuk, vagy a sorforrást megadhatjuk programból és az eredményt egy cellába írhatjuk a ControlSource tulajdonság meghatározásával.
"Televízió"
strAruk(2,
ComboBoxl.List
A következı feladat az, hogy az eredményt felhasználjuk. Ismét a Change eseményt fogjuk programozni. Kattintsunk tehát kettıt a kombinált listára, majd a megjelenı vezérlés modul Change eseményébe írjuk be a következı két utasítássort.
=
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.
strVarosok
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.
Kezdjünk egy új munkafüzetet, az elızıt zárjuk le. Kapcsoljunk át VBE nézetbe. A jelenlegi projektbe szúrjunk be egy új őrlapot. Erre az őrlapra rajzoljunk egy lista vezérlést. Ennek a lista vezérlıelemnek a sorforrását programból fogjuk meghatározni. A sorforrás elemeinek feltöltésére az őrlap Initialize eljárását használjuk. Kattintsunk kettıt az őrlap hátterére. Meg fog jelenni az őrlap objektumhoz tartozó modul. A modul Eljárás listájából válasszuk ki az Initialize eljárást. Az eljárásba írjuk be a következı utasításokat: Private
Sub UserForm_Initialize()
Dim strForras(6) strForras(O) strForras(l)
= =
As String
"hétfı" "kedd"
strForras(2) = "szerda" strForras( 3 ) = "csütörtök" strForras(4) = "péntek" strForras( 5 ) = "szombat" strForras( 6 )
= "vasárnap"
Válasszuk az őrlap lezárása eseményt - Terminate - és írjunk egy olyan programot, amelyik az aktív munkalapra kiírja a listából kiválasztható értékeket, és ezek mellé megjeleníti azt is, hogy melyik elemet választotta a felhasználó. Kattintsunk kettıt az őrlap területére és írjuk meg a következı eljárást.
ListBoxl.List = strForras End Sub
Private Sub UserForm_Terminate() Dim bytl As Byte
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.
For bytl
= 1 To ListBoxl.ListCount
With Worksheets("Munkai") .Cells(bytl,
1)
= ListBoxl.List(bytl
.Cells(bytl,
2)
= ListBoxl.Selected(bytl
-
1) -
1)
End With Next bytl End Sub
Az eljárás elsı sorában deklaráltunk egy változót. Ezt arra fogjuk felhasználni, hogy végiglépkedjünk a lista elemein. Tehát ennek a változónak az értéke fog rámutatni az éppen aktuális listaelemre. For bytl
=
1
To ListBoxl.ListCount
Ennek a sornak az a feladata, hogy addig ismételje a lista elemek kiértékelését, amíg a listaelemek száma tart. Ezt jelzi a sor végén található ListBoxl .ListCount kifejezés. AListCount tulajdonság ugyanis azt mutatja meg, hogy hány soros a lista. Cells(bytl,
Alapértelmezésben a választógombok egyszerre csak egy listaelem kiválasztását teszik lehetıvé. Állítsuk be azt is, hogy egyszerre több listaelemet is ki lehessen jelölni a listából. Ennek érdekében állítsuk be az objektum MultiSelect tulajdonságát a következı értékre: fmMultiSelect-Multi. Ezután jelöljük ki az őrlapot és hajtsuk végre az 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álhatjuk az őrlap Terminate vagy a lista Change eseményét. Az őrlap Terminate eseménye akkor következik be, amikor bezárjuk az őrlapot, a lista Change eseménye pedig akkor, amikor megváltoztatjuk a listaelemek kijelölését.
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. Abekapcsolt elemek True értéket adnak vissza. Futtassuk az őrlapot. Tetszılegesen jelöljük ki a listaelemeket, majd zárjuk le az őrlapot. A választásunk eredményét az aktív munkalapon fogjuk 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 UserForm_Terminate() Range("Al") = ListBoxl.Listlndex Range("A2") = ListBoxl.List(ListBoxl.Listlndex) End Sub
Private Sub üserForm_Terminate() Dim bytl As Byte Dim bytK As Byte bytK = 1 For bytl
=
1
To
ListBoxl.ListCount
If ListBoxl.Selected(bytl Cells(bytK,
1)
-
1)
= ListBoxl.List(bytl
Then -
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 utasí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.
1)
bytK = bytK + 1 End If Next bytl End Sub
Ha a MultiSelect tulajdonságot fmMultiSelectExtended értékre állítjuk be, akkor a listapanel ugyanúgy fog mőködni, mint minden Windows alkalmazás. Vagyis, ha kijelölünk egy listaelemet és lenyomjuk a CTRL billentyőt, akkor további listaelemeket választhatunk ki, ha pedig egy listaelem kijelölése után a SHIFT billentyő lenyomásával kattintunk egy másik sorra, akkor a kezdetben kijelölt listasortól addig jelöljük ki a listasorokat, ameddig az újonnan kijelölt elem tart. 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 vezérlést. Most is az őrlap Initialize utasítását használjuk fel arra, hogy meghatározzuk a lista vezérlés elemeit. Ez legyen ugyanaz, mint az elızı feladat esetén. Indítsuk el ezt az őrlapot. Próbáljuk meg kiválasztani a lista egyik vagy másik elemét. Azt fogjuk tapasztalni, hogy egyszerre csak egy eleme lehet kiválasztva. Zárjuk le az őrlapot és nézzük meg a kiértékelés módját. 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 cellahivatkozást, ahova az eredményt szeretnénk elhelyezni. A programban használható módszert írjuk meg az őrlap lezárása (Terminate) eljárásba. Kattintsunk kettıt az őrlap területén. A megjelenı modul ablak Eljárás listájából válasszuk ki a Terminate eseményt. Ebbe írjuk bele a következı utasításokat:
A felhasználóval sokféle grafikus eszközzel tarthatjuk a kapcsolatot. Egyszerőbb üzeneteket gyorsan, kevés programozással küldhetünk az MsgBox segítségével, amelynek két változata is a rendelkezésünkre áll. Az egyik változat, amikor metódusként hívjuk meg, a másik esetben függvé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 argumentumait zárójelek közé kell írnunk, és mindenképpen egy változóban kell tárolni a felhasználó válaszát. Hasonlóan egyszerő eszköz az Office segéd, amelyet minden Office alkalmazásból elérhetünk. Az egyszerőség hátránya, hogy csak korlátozott számú vezérlés helyezhetünk el rajta és csak programozottan kezelhetı. Egyedi őrlapokat hozhatunk létre az alkalmazás rugalmassá tétele érdekében. Ebben az esetben jó eredményeket érhetünk el a vezérlı objektumok tulajdonságainak a beállításával. A programozása sem túl összetett 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 általunk írt eljárásokat a Makrók (Macros) panelból vagy a Visual Basic Editorból. Ez a módszer azonban lehet, hogy egy átlagos felhasználónak nem lesz annyira egyszerő. Úgy kell kialakítanunk a program kö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ákapcsoljuk 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 kerü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 eszköztárak és a menü egyedi kialakításához. Mind a két objektumra ugyanazokat a parancsgombokat helyezhetjük el. A parancsgombokat ugyanúgy rendelhetjük hozzá az általunk írt eljárásokhoz.
Amíg az alkalmazásban látható a Testreszabás (Customize) párbeszédpanel, addig mind az eszköztárakat, mind a menüket szabadon átalakíthatjuk. Megfoghatjuk a panel Parancsok (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öztárak (Toolbars). Itt találjuk meg az adott Office alkalmazásban -jelenleg ez az Excel — létrehozott eszköztárakat és menüsorokat. Ezen a lapon állva hozhatunk létre újabb eszköztárat vagy menüsort. A Parancsok (Commands) lapon az Excel-ben használható parancsgombokat, utasításokat fedezhetjük fel. Az itt található gombokat mind az eszköztárra, mind pedig a menüre elhelyezhetjük. Egyszerően meg kell fogni az egérrel és a megfelelı helyre húzni. A harmadik fül a Beállítások (Options) nevet viseli. Itt a menüsor mőködését állíthatjuk be. A Parancsok között található gombokhoz a program írói már hozzárendeltek bizonyos funkciókat. Ha nincs szükségünk az adott funkcióra, ezeket a gombokat is felhasználhatjuk a magunk céljaira. Van azonban két olyan gomb, amit kifejezetten arra a célra tartottak fenn, hogy makrókat rendelhessünk hozzájuk. Ezeket a Makrók (Macros) utasításcsoportban találjuk. Ha kiválasztjuk a csoportot, akkor megtaláljuk a Felhasználói menügomb (Custom 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árbeszé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örlés (Delete) feliratú gombra. Most ezt ne tegyük, csak jegyezzük meg. Azt is figyeljük meg, hogy ha egy olyan eszköztárat jelölünk ki a listából, amelyik az Excel része volt - vagyis nem mi készítettük -, akkor a Törlés gombot nem választhatjuk ki. Ezeket az eszköztárakat ugyanis nem lehet törölni, csak alaphelyzetbe állítani. Ez azt jelenti, hogy nyugodtan megváltoztathatjuk bármelyik eszköztár összetételét, ha meggondoljuk magunkat, bármikor visszaállíthatjuk az eredeti állapotot.
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 tartalmazó 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érmutató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 megjelenı párbeszédpanelbıl kiválaszthatjuk annak a makrónak a nevét, amit akkor szeretnénk lefuttatni, amikor erre a gombra kattintunk. Az OK gombra kattintva lépjünk ki a Hozzárendelés gombhoz panelból, majd a Testreszabás (Customize) panelt zárjuk le, a Bezárás (Close) feliratú gombbal. Álljunk egy üres lapra és kattintsunk rá az új gombra.
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étre. Ez az egyetlen, de lényeges különbség az eszköztárak és a menüparancsok kialakítása között. Ismét az egér jobb gombjával kattintsunk bármelyik eszköztárra vagy a menüsorra. A helyi menübıl válasszuk ki a Testreszabás (Customize) utasítást. A megjelenı párbeszédpanelben lapozzunk a Parancsok (Commands) lapra. Válasszuk ki az Új menü (New 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 állapotban és vontassuk a Segédletek menüpont fölé.
Miközben a menüpontot vontatjuk, a már menüsoron lévı menüpontok és az almenüpontok engedelmesen kinyílnak. Az egérmutató mellett megjelenik egy függıleges vonal. Ez ugyanúgy, mint az eszköztáraknál, azt a helyet mutatja, ahova az új menüpont kerül az egér elengedése után. Vigyük az új menüpontot a 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 Segédletek menüpont Szöveges almenüpontba. Az utasítást a helyi menü Név (Name) szerkesztıdobozában nevezzük el Jelentés kitöltése névvel. Az új utasításhoz rendeljük hozzá a 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édpanel 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, jogos a kérdés, hogy miért nem program segítségével tesszük fel a parancsokat? Ugyanis az eszköztárak és menük objektumok. Ha pedig objektumok, akkor programozni is lehet okét. Akkor most következzenek az eszköztárak és menük programozási lehetıségei. Mint azt a fejezet korábbi részében láttuk, az eszköztárak és a menük ugyanahhoz az objektumosztályhoz tartoznak. Mindkét objektum a Commandbars 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 vezérlések a CommandBarControls győjtemény részei. Ennek a két objektumnak a megismerésével lehetıségünk nyílik programból megváltoztatni az Office alkalmazások menüsorainak és eszköztárainak 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érléseket, megszüntethetjük a munkafüzethez tartozó eszköztárakat. Ha nem szeretnénk az Office alkalmazáshoz tartozó eszköztárakat megváltoztatni, akkor hozzunk létre újat. Ezen helyezzük el majd azokat a gombokat, amelyekhez hozzárendeljük az egyedi eljárásainkat. Nyissuk meg az 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írni az elsı utasítássorok kezelését végzı eljárásainkat. Az UtasításSorok modul UjEszkoztár eljárásába írjuk be a következı utasításokat: Sub UjEszkoztár() 'Ebben az eljárásban új eszköztárat hozunk létre 'A létrehozott eszköztárra utasítássor vezérlése'ket helyezünk el, ezek segítségével indítjuk el 'az Eljárások modul eljárásait. On Error GoTo Hiba 'Változók, állandók deklarálása Dim cbrUjEszkt As CommandBar Const STR_NEVE As String = "Saját eszköztár" 'Új eszköztár létrehozása: Set cbrUjEszkt = CommandBars.Add(Name:=STR_NEVE, Position:=msoBarFloating, MenuBar:=False, Temporary:=True) cbrUjEszkt.Visible = True Exit Sub Hiba: If Err.Number = 5 Then Exit Sub Else E r r o r . Er r
Az ezt követı utasításban deklaráljuk az új eszköztár azonosítására szolgáló változót: cbrUjEszkt. Majd az STR_NEVE állandóba elhelyezzük az új eszköztár nevét, melyet késıbb használunk fel. A Set utasítással kezdıdı sorban hozzuk létre magát az eszköztárat. A metódusnak négy argumentuma van, az elsıben adhatjuk meg az elkészítendı eszköztár nevét, a másodikban azt a helyet jelölhetjük meg, ahol meg kívánjuk jeleníteni az új eszköztárat. A MenuBar argumentum két értéket vehet fel, ha ezt False-ra állítjuk be, akkor az új utasítássor eszköztárként fog viselkedni. A Temporary argumentumban arról gondoskodhatunk, hogy mi történjen az utasítássorral akkor, amikor bezárjuk azt a munkafüzetet, amiben létrehoztuk. Ha ezt az argumentumot True értékre állítjuk, akkor az eszközsor eltőnik, amint lezárjuk azt a munkafüzetet, amiben létrehoztuk. cbrUjEszkt.Visible = True
Végül ezzel a parancssorral megjelenítjük a létrehozott eszköztárat. Ez még üres, 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 argumentumnak a True értéket adjuk, akkor a létrehozott utasítássor menüsorként fog mőködni. Mivel egy alkalmazásban egyszerre csak egy menüsort jelenít meg az összes Office alkalmazás, a megjelenítés után eltőnik az eredeti menüsor. Az eredeti menüsor csak akkor 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
'A létrehozott
eszköztárat hozunk létre
eszköztárra utasítássor vezérlése-
'ket
helyezünk el,
'az
Eljárások modul eljárásait.
ezek segítségével
indítjuk el
On Error GoTo Hiba 'Változók állandók deklarálása
End If
Dim cbrUjEszkt As CommandBar
End Sub
Const STR_NEVE As String = "Saját menüsor"
Elemezzük ki az eljárást! A hibakezelés célja az, hogy amikor már létrehoztuk az új eszköztárat, nem hozhatunk létre még egy ugyanolyan nevőt. Ha az eljárást másodszor futtatjuk, az új eszköztárat létrehozó sor hibá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.
Set cbrUjEszkt = CommandBars.Add(Name:=STR_NEVE,
'Új
eszköztár létrehozása:
Position:=msoBarFloating, MenuBar:=True, Temporary:=True)
cbrUjEszkt.Visible = True Exit Sub
Hiba: If Err.Number = 5 Then Exit Sub Else E r r or .E rr 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" V A létrehozott eszköztár törlése On Error GoTo Hiba CommandBars(STR_NEVE).Delete Exit Sub Hiba : If Err.Number = 5 Then Exit Sub Else Error.Err End If End Sub
Az eszköztár vagy menüsor létrehozása után a következı legyen a menüpont. Menüpontot elhelyezhetünk eszköztáron is. A menüpontok újabb menüpontok befogadására képesek, vagyis egy-egy menüpont alá elhelyezhetünk almenüket is. Kezdjünk egy új eljárást, amelyikben menüket é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 cbrMenuSor 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ékkel határozzuk meg azt, hogy az új vezérlés menüpont legyen. Ugyanebben az utasítássorban el is neveztük az új menüpontot popMenu1 névvel. Ez alá utasításokat vagy újabb menüpontokat hozhatunk létre. Ebben az eljárásban az utóbbit tesszük. popMenul.Caption = STR_MNU1_NEVE
Ez az utasítássor arra szolgál, hogy az elhelyezett menüpontnak a feliratát meghatározzuk. Ennek a feliratnak az értékét jegyezzük meg, mert ha késıbb hivatkozni szeretnénk a most elhelyezett menüpontra, akkor a hivatkozás során ezt a címkét kell használni. Set popMenul = cbrMenuSor.Controls.Add (Type:=msoControlPopup)
Mivel a vezérlésünket elneveztük a popMenul változóval, ezért a továbbiakban felhasználhatjuk hivatkozásként. Ha ezt nem tettük volna meg, akkor a következı írásmóddal hivatkozhattunk volna a létrehozott vezérlésre: Set 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érlést elhelyezni, akkor a programunk csak annyiban fog változni, hogy az utasítássor elnevezése során a CommandBars győjtemény AZONOSÍTÓ szövege helyett, annak az utasítássornak a nevét kell beírnunk, amelyiket használni szeretnénk. Ha az egyes vezérlések feleslegessé válnak, akkor azokat törölhetjük az utasítássorról. Mivel az almenük a menüpont részei, elegendı azt a menüt törölnünk, amelyiknek a részeire nincs tovább szükségünk, íme egy példa az elıbbi menük törlésére: CommandBars(STR_NEVE) .Controls (STR_MNU1_NEVE) .Delete
A létrehozott eszköztárakra, menüsorokra és a menüpontok alá utasításokat helyezhetünk el. Ezekkel egyrészt elindíthatjuk azokat az eljárásokat, amelyeket mi készítettünk, másrészt mőködtethetjük az Excel beépített utasításait. Helyezzünk el utasításokat az
utasítássor, a menüpont és az almenüpont alá. Ezt szemlélteti a következı eljárás: Sub Utasítások() Dim cbrMenuSor As CommandBar Dim 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:=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 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
.Caption = STR_EGYEDI_2_CIM .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 elemezzük. Az elemzés elsı részlete legyen az objektum elnevezést végzı sorok megértése.
End With
Ebben a programrészben egyedi eljárás indítására használjuk az utasítássorra elhelyezett vezérlést. A Set sorban elhelyezünk egy gombot az utasítássoron, majd a következı lépésekben meghatározzuk a jellemzıit. Ezek sorrendben a következık: 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ákattintunk. Az eljárás további részei hasonlóak, mint az itt elemzett rész, a különbség összesen annyi, hogy a menü és az almenü alá helyez el vezérlést. Ezeket nem részletezzük.
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üpontot és a két almenüpontot — amelyek már a rendelkezésünkre állnak. Ezekbe fogjuk elhelyezni az Excel beépített utasításait, és az eljárások modulban megírt eljárások indítását végzı parancsvezérléseket.
Ahogy a fejezet elején olvashattuk, lehetıségünk van arra is, hogy a makró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ó munkafüzetet!
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 .Caption = STR_EGYEDI_1_CIM .OnAction = STR ELJ1
Elıször röviden nézzük meg azt, hogy hogyan használhatjuk a bıvítményeket. 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 Files\Microsoft Office\Office mappát. Ebben megtaláljuk a Makro (Library) mappát. Itt találjuk a bıvítményeket. Célszerő lesz nekünk is ide menteni a sajátjainkat, mert akkor a bıvítménykezelı felismeri azokat, és használatra felkínálja. A bıvítmények kiterjesztése XLA. Ha ezek közül valamelyiket megnyitjuk, akkor használhatjuk a bennük megírt függvényeket, illetve eljárásokat. Érdemes megjegyezni, hogy ha közvetlenül a Megnyitás panellel töltjük be a beépülı programokat, akkor csak addig állnak rendelkezésünkre az eszközei, amíg ki nem lépünk az 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ítménykezelı (Add-Ins) utasítást. Eredményképpen megjelenik egy párbeszédpanel, amelyik felkínálja a Makro (Library) mappában található bıvítményeket. Ha bármelyik beépülı elıtt található választókapcsolót bekapcsoljuk, akkor kijelöltük az adott beépülıt arra, hogy betöltıdjön. A betöltésre akkor kerül sor, amikor a párbeszédpanel OK gombjára kattintunk. A továbbiakban az Excel betöltésekor automatikusan betöltıdnek a kiválasztott beépülık mindaddig, amíg a bıvítménykezelıben ki nem kapcsoljuk. Figyeljük meg azt is, hogy amint rákattintunk az egérrel egyik vagy másik bıvítményre, a panel alján megjelenik egy rövid leírás arról, hogy mire használható a kiválasztott bıvítmény. Arról, hogy ez a magyarázat megjelenjen, nekünk kell majd gondoskodnunk. Ezt úgy tehetjük, hogy mentés elıtt kitöltjük a munkafüzet adatlapját. Az adatlap párbeszédpanelt a Fájl (File) > Adatlap (Properties) utasítás segítségével jeleníthetjük meg. Az adatlapról kerül a listába a bıvítmény neve is. Nézzük most már gyakorlatban is a bıvítmény-készítést. A lemezmellékletrıl töltsük be a Bovitmeny.xls nevő munkafüzetet. Ebben egy egyszerő függvényt és egy korábban elkészített őrlapot találunk. Ezt a munkafüzetet mentjük majd el bıvítményként. Készítsük elı! A munkafüzet megnyitása után válasszuk ki a Fájl (File) > Adatlap (Properties) utasítást. A megjelenı adatlapban lapozzunk az Adatlap lapra és írjuk be a címet és a megjegyzést a szerint.
Ha valóban szeretnénk megvédeni a programunkat az illetéktelen behatolástól, akkor a projektet védjük le jelszóval. Ezt a VBE nézetben tehetjük meg. 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 megjelenı 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 érdeké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 Office\Office\Makro (Library)).
Az eredmény az Excel betöltése után lesz látható, ezért zárjuk le az Excel-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 lapján megjelenik az a magyarázat, amit az adatlap megjegyzés rovatába írtunk. 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 munkafüzetet. Sıt, ha megnézzük a végrehajtható eljárásokat az Eszközök (Tools) > Makró > Makrók utasításban, ott sem fognak megjelenni a beépülı munkafüzet eljárásai. Ha átkapcsolunk a VBE-be, akkor a projektek között megjelenik ugyan az új bıvítmény, de ezt már csak az nézheti meg, aki ismeri a projekt jelszavát.
Határozzuk meg azt, hogy a KerekErre függvény a statisztikai csoportba kerüljön. Adjunk egy rövid leírást a függvény használatához. Ehhez tehát lépjünk be a bıvítmény ThisWorkbook eljárásába. Ide írjuk be a következıket: Private Sub Workbook__Open ()
Ebben a projektben két egyszerő program van, az egyik egy függvény, a másik pedig az Excel beállítását szolgáló panel. A függvényt azonnal használatba vehetjük. Ha megnézzük a függvényvarázslót, akkor a Felhasználói függvénycsoportban megleljük a KerekErre függvényt. A függvényt elhelyezhetjük tetszıleges függvénycsoportban, de ehhez még kicsit programoznunk kell. A beállításra szolgáló eljárást nem találjuk sehol. Ha megnézzük az elérhetı makrókat (Eszközök (Tools) > Makró (Macro) > Makrók (Macros) utasítás segítségével), azt fogjuk tapasztalni, hogy az eljárások nem jelennek meg. Tehát elrejtettük a felhasználó elıl azokat az eljárásokat, amelyeket mi hoztunk létre. Ezek indíthatóságáról mi fogunk gondoskodni. Az eddig megismert egyik módszerrel nyissuk meg a 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égrehajtja az Open eseményt. Ide leírhatjuk a függvények kategóriákba sorolásához szükséges programlépéseket és kiadhatjuk azokat az utasításokat, amelyek segítségével a munkafüzet betöltésekor menüpontot, vagy eszköztár gombot jelenítünk meg. Ezekhez hozzárendelhetjük a bıvítményben leírt eljárások indítását. Ha a bıvítményt eltávolítjuk az Excelbıl, akkor gondoskodnunk illik arról is, hogy a futási idıben megjelenített menüpontokat és utasítás gombokat megszüntessük. Ezt a munkafüzet BeforeClose eljárásában tehetjük meg. A függvények csoportjának a meghatározásáról nem kell gondoskodnunk, mivel a függvény automatikusan eltőnik a varázslóból, amikor a bıvítményt eltávolítjuk.
'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ároztuk meg. Ebbıl azt tudhatjuk meg, hogy melyik függvénykategóriának mi a sorszáma. Jelen eljárásban elegendı lett volna a statisztikai állandót meghatározni, ha a függvényt ebbe a csoportba szeretnénk beilleszteni. A következı állandóban annak a függvénynek a nevét határoztuk meg, amelyiknek a tulajdonságait most fogjuk beállítani. Ez a KerekErre függvény. Ezután a függvény magyarázat szövegét deklaráljuk. Az állandók deklarálása után jöhet maga a beállítást elvégzı utasítássor. Ha egy függvény tulajdonságait kívánjuk beállítani, akkor elegendı a metódusnak csak a példában látható három argumentumát meghatározni. Az egyes argumentumok nevei magukért beszélnek. Ennek megfelelıen a Macro argumentumban azt kell meghatároznunk, hogy melyik függvény tulajdonságait állítjuk be, vagyis a függvény nevét. 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 általunk írt függvény. A bıvítmény elfedi a felhasználó elól azt a munkafüzetet, amelyben az eljárások vannak. Nem kell rejtett füzetként menteni, és egy kis programozással a felhasználó úgy fogja találni, hogy a mi eljárásaink is részei az Excel-nek. Tetszés szerint be- és kikapcsolhatjuk a bıvítményeinket. Ha szükséges jelszóval védhetjük bármelyik munkafüzet moduljait, így a bıvítményekét is. Ezzel elkerülhetjük az illetéktelen kezek munkáját. A bıvítmények betöltése olyan jól elfedi az eljárásainkat, hogy a Makrók (Macros) panelben sem jelennek meg azok. Ez jó is meg rossz is. Jó, mert nem fér hozzá a felhasználó. Rossz, mert nem fér hozzá a felhasználó. 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ényként mentett munkafüzet Open — megnyitásra — eseményébe olyan programot fogunk írni, ami elhelyezi a szükséges gombokat mind az eszköztárakra, mind pedig a menüparancsok közé. A Close - bezárás - eseményt pedig arra fogjuk felhasználni, hogy levegyük azokat a gombokat, menüparancsokat, amelyeket mi tettünk fel.
Ennek a meghatározását a legegyszerőbben úgy tehetjük meg, hogy mielıtt a munkafüzetet bıvítményként mentenénk, az Eszközök [Tools] > Makró [Macro] > Makrók [Macros] utasítással megjelenített párbeszédpanelben rákattintunk az Egyebek [Options] gombra és a megjelenı panelben megadjuk az eljárás a billentyőkombinációját. Természetesen a MacroOptions metódus segítségével ezt megtehetjük akkor is, amikor a bıvítményt használatba vesszük, vagyis a bıvítményt tartalmazó munkafüzet Open eseményét felhasználva. A Bovitmeny.xls munkafüzet Open eseményét bıvítsük a következı sorokkal. Const STR_BEALL As String = "eljGyorsBeáll" Const STR_BEALL_LLEIRAS As String = "A munkafüzet gyors beállítása" Const STR_BILLENTYU As String = "U" Application.MacroOptions Macro:=STR BEÁLL, Description:=STR_BEALL_LLEIRAS, hasShortCutKey:=True, ShortcutKey:=STR BILLENTYŐ
Az állandók meghatározása után állítsuk be az eljárás jellemzıit. Hatá-
rozzuk meg a magyarázatát és azt a billentyőkombinációt, amelyikkel a bıvítmény betöltése után elindíthatjuk az eljárást. A MacroOption metódus Macro argumentumában azt határozzuk meg, hogy melyik eljáráshoz rendelünk billentyőt. Ez a mi esetünkben az eljGyorsBeáll lesz. Az eljárás nevét - eljárás elején - az STR_BEALL állandóban tároljuk. A Description argumentumot arra használjuk, hogy az eljárás magyarázatnak értéket adjunk. Ezt akár el is hagyhatjuk. A hasShortCutKey argumentum az Excelnek szól. Itt mondjuk meg, hogy az eljáráshoz billentyőkombinációt fogunk hozzárendelni. A ShortcutKey argumentumban pedig egy betőt választhatunk, amivel az eljárást 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 eredményeként ezt az eljárást a SHIFT+CTRL+u billentyő-kombinációval indíthatjuk 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ő-kombinációt vagy menüutasítást rendelhetünk, illetve az eszköztár egyik gombjához kapcsolhatjuk a bıvítményben megírt eljárást. Gyakran használt eljárások esetén akár egyszerre használhatjuk mind a három eszközt. Az egyes indítási módszereknek megvan az elınyük és a hátrányuk. A billentyőkombináció például gyorsan végrehajtható, de nehéz megjegyezni. Az eszköztár gyors - is és mindig látható is -, de a felhasználónak meg
kell jegyeznie a megfelelı gombot. A menü szövege tájékoztatja a felhasználót arról, hogy mi történik, ha kiválasztja a megfelelı menüutasítást, de több lépésre van szükség az utasítás kiválasztásához, vagyis lassú módszer.
Találkozhatunk olyan idıszakonként ismétlıdı feladattal, amikor az Excel-ben elkészített munkánk eredményét át kell tennünk a Word-be, vagy éppen prezentáció forrásaként szolgál az Excel-ben létrehozott dokumentum. Ennek a feladatnak az elvégzéséhez természetesen rendelkezésünkre áll a vágólap is, ha azonban ezt a feladatot gyakran kell végrehajtanunk, vagy olyan munkatársunk végzi, aki nem eléggé tájékozott a másolás mőveletében, akkor segítséget nyújthatunk neki a folyamatok automatizálásával. Ehhez ismernünk kell annak az alkalmazásnak az objektumait, amelyiket az Excel-bıi szeretnénk vezérelni. Szerencsére a programozás eszköze a többi Office alkalmazásban is a VBA. Kisebb problémát csak az fog okozni, hogy ebben a könyvben nem lesz lehetıségünk a többi alkalmazás objektumainak részletes bemutatására. De az Office alkalmazások többségében is jó segítséget nyújt a makrórögzítés. A kérdések a következık legyenek: ♦ 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 érnünk a használni kívánt alkalmazást. Mivel ezek is objektumok, itt is hivatkozni kell tudni. Erre több lehetıségünk is van. Az egyik az, amikor hasonlóan járunk el, mint az egyedileg létrehozott objektumaink használata esetén, azaz új objektumként deklaráljuk a kívánt alkalmazást. A másik módszer, amikor a CreateObject függvényt használjuk az alkalmazás megszólítására. Egy újabb lehetıség pedig, amikor egy futó alkalmazás szolgáltatásait vesszük igénybe.
appWord.Visible = True
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ényeké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 megfelelı objektum-könyvtárat be kell kapcsolnunk a használatbavétel elıtt, különben az Excel nem ismeri fel (74. ábra). Megírhatjuk az elsı eljárásunkat, amelyik használja a Word szövegszerkesztıt.
Erre az utasításra most a szemléltetés kedvéért van szükségünk. Ez a sor azt eredményezi, hogy megjelenik a Word, ugyanúgy mintha betöltöttük volna. Azaz csak majdnem ugyanúgy, mivel ezután az utasítás után, még nem lesz egyetlen megnyitott dokumentum sem. appWord.Documents.Add
Figyeljük meg, hogy a Word-ben ugyanúgy kezdhetünk új dokumentumot, mint ahogy az 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.
Sub WordExcelbol() Dim appWord As New Word.Application Const STR_SZOVEG As String = "Szöveg a Word szövegszerkesztıbe!" appWord.Visible = True appWord.Documents.Add appWord.Selection.TypeText STR_SZOVEG End Sub
Az eljárás elsı utasítása a Dim. Ebben határozzuk meg azt, hogy az eljárásban használni fogjuk a Word szövegszerkesztıt. Amikor a deklaráláskor az As kulcsszó mögé beírjuk a New szót, a Word alkalmazás objektum új elıfordulását hoztuk létre. A Word ennek a programsornak a hatására még nem töltıdik be, csak ha majd használatba vesszük.
Ennek a módszernek az a hátránya, hogy csak a hivatkozásokban bekapcsolt objektumokat használhatjuk. Ez akkor nem is okoz problémát, ha magunknak írunk programot és gondoskodunk arról, hogy a 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 használhassák azt. Ebben az esetben másik módszerhez kell nyúlnunk.
Az eljárás végrehajtásának az eredménye ugyanaz lesz, csak most nem kell gondoskodnunk a hivatkozásról, tehát bármelyik gépen futtathatjuk, amelyikre korábban Word szövegszerkesztıt telepítettünk. Dim appWord As Object
A következı módszert akkor is használhatjuk, ha elıre nem kapcsoltuk be annak az alkalmazásnak vagy objektumnak a hivatkozását, amit használni szeretnénk. Az elızı feladatot oldjuk meg még egyszer, de elıtte kapcsoljuk ki azt a hivatkozást, amitıl az Excel VBA ráismert a szövegszerkesztıre. Tehát a VBE-ben hajtsuk végre a Tools > Reference utasítást és a megjelenı párbeszédpanelben kapcsoljuk ki a Word objektumkönyvtárat (76. ábra). Próbáljuk meg ismét lefuttatni az eljárást. Az eredmény egy hibaüzenet lesz.
Fedezzük fel, hogy most objektumnak deklaráltuk az appWord változót. Ez azonban csak az egyik különbség. A másik az, hogy a használatbavétel elıtt el kell neveznünk a szövegszerkesztıt a Set utasítás segítségével. Set appWord = CreateObject(STR_OBJECT_TYPE)
Ebben a sorban lényeges, hogy a függvény argumentumában szövegállandóként kell meghatároznunk azt, hogy melyik alkalmazással kívánunk dolgozni. Ha a gépünkre valamelyik alkalmazás korábbi változatát is telepítettük, akkor hasznos az Application kulcsszó mögé beírni a változat számát is. Ebben az esetben - az egyébként nagyon figyelmes és szolgálatkész VBE -, nem kínálja fel a lehetséges alkalmazásokat, így a lehetıségeket nekünk kell tudnunk. Ezek a következık:
í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
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 alkalmazá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 írjuk meg. Elsıként hozzunk létre egy Word dokumentumot. Ebben legyen három bekezdés. A dokumentumot mentsük el. Jegyezzük meg a dokumentum nevét és a mentés helyét. Ezekre szükségünk lesz az eljárás megírása során.
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_TYPE)
A GetObject függvénynek két argumentuma van, az egyik a használni kívánt dokumentum elérési útvonala és a fájl neve, a másik pedig az objektum-osztály meghatározása. A mi esetünkben az objektum-osztály a Word dokumentum. Az eljárás csak akkor fog helyesen mőködni, ha a megfelelı elérési útvonalat írtuk be. Ügyeljünk tehát arra, hogy a könyv példája nem írható át bető szerint.
Nyissuk meg a Word szövegszerkesztıt. A megjelenı új dokumentumba írjunk be három tetszıleges tartalmú bekezdést. Utána mentsük el a dokumentumot. A könyv példájában a C merevlemez fıkönyvtárába került a dokumentum és a neve Get.doc. Ezután zárjuk le a szövegszerkesztıt. Töltsük be az Excelt. Kapcsoljunk át a VBE programba. Ne felejtsük el ellenırizni és szükség esetén bekapcsolni a Word objektumkönyvtár hivatkozását a References panelben. Az új projektbe szúrjunk be egy új modult, és írjuk be a következı eljárást: 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"
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 bekezdésén és átmásoljuk a kiolvasott szöveget az Excel aktuális munkalapjának celláiba. Az intI értékét a Cells paramétereként használjuk fel, így az egyes bekezdések egymás alatti cellákban fognak megjelenni. Range(STR_CELL_1) = docWord.Parent.Name Fange(STR_CELL_2) = docWord.Name
A következı két utasítás csak azt kívánja szemléltetni, hogy a Word további tulajdonságaihoz is hozzáférhetünk. 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övegszerkesztıbe. Természetesen lehetıségünk van arra is, hogy a szövegszerkesztıben írunk egy eljárást, ami képes mindkét irányban adatot mozgatni. Egy érdekes megoldás lehet az is, hogy a szövegszerkesztı dokumentumában tárolt szövegeket az Excelben írt eljárás segítségével formázzuk meg. Az eljárás elindítása elıtt be kell tölteni a kiszolgáló programot. Ez jelen esetben a Word. A módosítandó dokumentumot nem kell és nem is szabad megnyitnunk. Ezt majd elvégzi az eljárás. Nézzünk erre is egy példát, használjuk fel az elızı feladatban létrehozott szöveg dokumentumot: Sub 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_TYPE) 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 GetObject függvénnyel férünk hozzá. A következı három sorban az egymás után következı bekezdéseket formázzuk meg a Word stílusaival. Itt érde-
mes megemlíteni az eljárás elején deklarált állandókat. Ezek nevét és értékét a szemléltetés kedvéért a Word súgójából vettük. Vagyis a Word stílusait számokkal is meghatározhatjuk. A stílusokat a nevükkel is megadhattuk volna: docWord.Paragraphs(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áltatása a vágólap. Ez az eszköz nagy segítséget jelent akkor, ha valamelyik alkalmazásból adatot szeretnénk átadni egy másik alkalmazás dokumentuma számára. A következı példa elıkészítését Excel-bıi kezdjük. Egy egyszerő táblázatot készítsünk az egyik munkalapra. Ezt a táblázatot automatikus formázással formázzuk meg. Ezt a táblázatot juttassuk át egy Word dokumentumba, majd a dokumentumot mentsük el egy tetszıleges mappába. A Word dokumentum címe legyen azonos az elkészített munkalap nevével és ezt formázzuk meg Címsor 1 stílussal. A táblázat a következıképpen nézzen ki:
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_FAJL_TIPUS Set appWord = CreateObject(STR_OBJ_TIPUS) Selection.CurrentRegion.Copy With appWord .Documents.Add With .Selection .typetext ActiveSheet.Name .paragraphs(1).Style = -2 .typeparagraph .typeparagraph .Paste End With .ActiveDocument.SaveAs Filename:=varFá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.
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árbeszédpanel, amiben megadhatjuk a Word fájl nevét. Létezik egy másik InputBox függvény is. Ez a VBE függvénye. Most az Excel függvényét használjuk, ezért írtuk elé az Application objektum nevét. Ha az OK gombra kattintunk, akkor a szerkesztıdobozba írt szöveget adja vissza a függvény, ha pedig a Mégse gombra, akkor logikai HAMIS érték a függvény eredménye. If varFájlNeve <> False Then 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_FAJL_TIPUS
A fájl nevét most már teljes hosszában létrehozzuk. Ebbe beletartozik az elérési útvonal is és a fájl kiterjesztése is. Figyeljünk arra, hogy az eljárás elején deklarált állandók tartalmazzák a megfelelı adatokat. Az STR_ PATH_ FILE meghatározásához azt az útvonal nevet kell meghatároznunk, ami a gépünkön létezik, különben az eljárás nem fog mőködni. A fájl típusa minden esetben .doc legyen. Ne felejtsük ki a doc szó elıl a pontot! Set appWord = CreateObject(STR_OBJ_TIPUS)
strLapNeve = ActiveSheet.Name
A másolás elıtt tároljuk az aktuális munkalap nevét. Erre a fájl mentésekor lesz szükségünk. Ez lesz az a név, amit a program alapértelmezésként felkínál a Word dokumentum mentéséhez. Vagyis, ha nem változtatunk rajta, akkor ez lesz a Word fájl neve. Azért választottuk a Variant
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ásoljuk a vágólapra ennek a sornak a segítségével. Figyeljünk arra, hogy az eljárás indítása elıtt álljunk az adattartomány egyik cellájára, így az Excel felismeri az aktuális régiót. With appWord
Ettıl a sortól kezdve minden tulajdonság elé oda kell képzelnünk az appWord objektumot, ami ponttal kezdıdik. Vagyis ha szeretnénk a Wordben elkezdeni egy üres dokumentumot, akkor a következı utasítást kell kiadnunk: .Documents.Add
Ha nem írtuk volna a programba a With appWord sort, akkor ezt a sort a következı módon kellett volna leírnunk: appWord.Documents.Add
Ezt minden alkalommal meg kellett volna ismételnünk amikor a Word-del végzünk mőveletet. A továbbiakban az érthetıség kedvéért a With részben meghatározott objektumokat dılt betővel szedjük az elemzés során, amint ez az elızı mintában látszik. With appWord.Selection
Ettıl a sortól kezdve a Selection elé odaképzelve az appWord objektum hivatkozást minden ponttal kezdıdı sor elé oda kell gondolnunk a app Word.Selection objektumot.
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 bekezdéseket kezdünk a címsor után. appWord.Selection.Paste
Most érkezett el annak az ideje, hogy a vágólapra másolt táblázatot beszúrjuk a Word dokumentumba. Ez ugyanaz a mővelet, mint amikor a hétköznapi munkánk során végrehajtjuk a Szerkesztés (Edit) > Beillesztés (Paste) utasítást. Vagyis a vágólap tartalma a szövegünkbe kerül, mégpedig arra a helyre, ahol a szövegkurzor áll (appWord.Selection). End With
A továbbiakban már érvényét veszíti a Selection objektum. Innentıl kezdve csak az appWord marad érvényben, vagyis ha egy tulajdonság elıtt pontot találunk, akkor ezentúl az már csak a Word alkalmazás objektumot jelenti. appWord.ActiveDocument.SaveAs FileName:=FájINeve
Mentsük el a szöveget! Erre használjuk a Word objektum SaveAs metódusát. A metódusnak egyetlen paraméterét adjuk meg, ami a fájl neve és elérési útvonala. Ezt korábban tároltuk a FájlNeve változóban még az InputBox függvény segítségével. appWord.Quit
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.
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üggvény mögötti helyre valahova írjuk be a következı utasítássort:
appWord.Selection.Paragraphs(1).Style = -2 appWord.Visible = True
A beírt szöveget tartalmazó bekezdést megformázzuk Címsor 1 stílusúra. Ezt a formázást azon a bekezdésen állítjuk be, amelyikben a szövegkurzor áll. Még mindig csak ez az egy bekezdésünk van, így nem ronthatjuk el.
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 alkalmazás objektumait. Egyszerősítheti az ismerkedést, ha átlépünk a
kívánt alkalmazásba és az ott felvétellel rögzített eljárásokat kielemezzü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-panelében bekapcsoljuk a használni kívánt objektum hivatkozást vagy a CreateObject függvénnyel. Ha a References beállítással hoztuk létre a kapcsolatot, akkor a New kulcsszóval létre kell hoznuk egy objektum-elıfordulást. A CreateObject függvény esetén ezt megteszi maga a függvény. Kész dokumentumok eléréséhez használjuk a GetObject függvényt.
A könyv további részében felhasználjuk az eddig megismert eljárásokat és metódusokat. Munka közben megismerkedü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 alkalmazá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 meghatározott cellatartomány szöveges adatait fogjuk átalakítani. Elıfordulhat, hogy sok cellába írtunk be szöveges adatokat, melyekben elkövettü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öveget 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.
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 meghatározott tartomány celláin, és a cellák adatain hajtsuk végre a panelben meghatározott mőveletet.
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 szolgá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 elkezdtü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ítjuk 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 tervezését részletesen együtt fogjuk megoldani. Most tehát, a „kisbető-nagybető" 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ölté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 kijelö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
A megváltoztatott adatokat írjuk be a megfelelı 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 feldolgozá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 eredmé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 összevoná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 állni: lépkedjünk végig a meghatározott cellatartomány celláin, az egyes cellá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 feldolgoztuk.
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 helyezünk el, automatikusan csak akkor látszanak, amikor a megfelelı oldalt 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.
á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.
A sokcélú oldal elsı lapjára rajzoljunk egy keretet. Ez a keret arra szolgál, hogy a választógombokat csoportba foglalhassunk. Ebbe a keretbe helyezzü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 tulajdonsá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 vezérlések tulajdonságainak egy részét akkor állítjuk be, amikor létrehozzuk a vezérlést - ez a tervezési idıszak -, míg más tulajdonságokat akkor
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 esetünkben csak a Visual Basic for Application lehet. Most a saját mondatainkkal, 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 adatbeké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ézzü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, adatbeké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 egyfajta programozási szemlélet, miszerint az eljárások felépítése során érdemes 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öbbi 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 lehetı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égrehajtanunk. 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 megvaló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 lapjá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 állí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 megterveztü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 írjuk 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.
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 tovább. Most nem elemezzük végig a programtervezés lépéseit, csak a végeredmé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. 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.
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 alkalmaznunk, í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ı utasításokkal. Ha szükséges az őrlapnak, vagy valamelyik vezérlésnek 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 tulajdonságok beállítási listája és a saját szavainkkal leírt program lesz, vagyis a kész terv.
Egyszerő szavakkal fogalmazzuk meg azokat a feladatokat, 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 eszközzel. Az eszköz lehet őrlap, vagy munkalap. Tehát a feladat megfogalmazá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ő szabadkézi rajzzal is. A rajzon adjunk nevet az összes alkalmazott vezé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 szakaszá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
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 helyeznünk a megfelelı vezérléseket és az elıre megtervezett eljá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álnunk 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?
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. Komolyabb 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 megjeleníti az elkészített őrlapot. A nevét már tudjuk, hiszen ezt már a tervezé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 leginká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
Azt a munkafolyamatot, amikor a saját szavainkkal leírt programlépéseket á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 nekifoghatunk a tényleges megvalósításnak. Elsıként a felhasználói felületet hozzuk létre. Létrehozzuk az őrlapot, vagy őrlapokat. Beállítjuk az őrlap 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.
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 utasí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 visszagondolunk 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ípusúnak kell lennie. Ez legyen a következı:
Case 1 'mltTextEszk harmadik lapján áll a felhasználó Case 2 End Select
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 tartományban kell végiglépkedni a cellákon. Erre vonatkozólag a terv alapján a refTartomany vezérlésbe fog adatot írni a felhasználó. A teljes ciklus tehát a következı lesz:
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álnunk, hogy melyik választókapcsolót kapcsolta be a felhasználó. Ezt három If utasítással valósíthatjuk meg.
For Each Cella In Range(refTartomany)
If optKisBetu Then
Next
Elself optNagybetu Then
Cella
Eddig tehát a program kódolva így néz ki:
Elself optTulNev Then End If
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 ismét a nyelvi leíráshoz kell fordulnunk. Ez egy MultiPage objektum, így tehá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 kiderü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ó
Ezzel a módszerrel alakítsuk át az egész tervet Visual 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 nem é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 nem ismerünk és a referencia könyvben vagyunk kénytelenek utána nézni a megfelelı szintaktiká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ássorban. 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 megfelelı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 érdemes 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 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 spiSzovegHely_Change() txtSzovegHely = spiSzovegHely 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 spiSzovHely_Change() txtSzovHely = spiSzovHely End Sub
Private Sub txtSzovHely_Enter() valTxtSzovHely = txtSzovHely End Sub
Private Sub spiMinuszKar_Change() txtMinuszKar = spiMinuszKar End Sub
Tegyük magunk elé az elkészült tervet. Lapozzunk az objektumok tulajdonsá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 projektablakban 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 vezérlések tulajdonságait állítsuk be a tulajdonságlista alapján. Az őrlapnak 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 megismertü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övetı 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írjuk a megfelelı utasításokat. Legelsıként az őrlap Initialize eseményvezé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 keressü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ítanunk, 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övetkezik, amikor lehetıleg mindent ki kell próbálnunk. Kicsit tekintsük az elké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 vizsgálni. A VBE programot ne zárjuk le. Kapcsoljunk át az Excel-be és a Eszkö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áljuk 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ırzése már megtörtént, amikor ezt a vezérlést megírták. Tehát az őrlap betö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 ellenı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ényleg 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 felhaszná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ésrıl tudjuk, hogy mit használ. A tesztek eredményét minden esetben jegyezzük fel. A felhasználó az egyes vezérlések között a tabulátor billentyővel is mozoghat. 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áltá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 terveztü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 megjelení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árjuk. Most válasszuk a második lehetıséget. A két parancsgomb kattintásra eseményében cseréljük ki a frmTextEszk.Hide utasítássort a következıre:
Ezeket a gondolatokat önállóan tervezzük meg. A megvalósított megoldá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ábbá feljegyeztük a javítás módját, akkor a dokumentáció elkészítése van már csak hátra.
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 egyenlı hosszúságú szövegeket, álljon mondjuk mindegyik cella szövege tíz karakterbıl. Ezután a következı helyrıl - txtMinuszKar - értékét szándékosan állítsuk be tíznél nagyobb értékre. Erre a program futási idejő hibajelzé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 ismé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. Tehá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 gondolkodjunk, 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ódhat, 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örlés helyétıl a szöveg végéig törölnünk kell a felesleges karaktereket.
Mindenképpen érdemes a tesztelés eredményeit más szempontból is átgondolnunk. Most arra gondolok, hogy az okos a más kárán, mások hibáibó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 érté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 tervezési szakaszban is abból kellett volna kiindulnunk, hogy a felhasználó mit írhat 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áskor 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 eszkö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 teszteltü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étrehozni, a munkafüzet megnyitása - Open - eseményvezérelt eljárás felhasználásával. Esetleg elmenthetjük beépülı makróként, levédhetjük jelszó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éppen 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 okbó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 érdemes hozzáfőzni a program kinyomtatott eljárásait, és egyéb automatikus dokumentumokat. Ez fényképként szolgál a tényleges megvalósításró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 semelyik 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 eszkö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 elké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 felhasználókra bízzuk a továbbiakat, és örömmel töltsön el minket, hogy olyat alkottunk, ami sokak hasznára válik.
A példákat úgy oldjuk meg, hogy azok beépülı programként használható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 helyezzü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. 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 ellenırizhetjük azt, hogy mennyire sajátítottuk el az olvasottakat. A CD mellékleten kapunk egy kis útmutatást a megoldáshoz. Hacsak 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 tervezé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 mellé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 haszná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. Ezutá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áljuk 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ítkoztunk, 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.
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 legutolsó 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 tulajdonsá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 projektké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ásban 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 Megjelení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átni, amikor a panel OK gombjára kattintunk. Készítsünk egy új párbeszédpanelt, 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áltoztatjuk 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 vonatkozzanak a beállítások. Ne felejtsük el azt sem, hogy az őrlap megjelenésekor az őrlap kapcsoló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ározott 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 cellá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álaszthasson 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édpanelt, 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 menü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ó meghatározhassa azokat az oszlopokat, amelyek szerint csoportosítani szeretné 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értelmezé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 listá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 felhaszná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
. 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 0101010101010101010101010101010101010101010101010101010101010101010101010101010 ©m(2009)10101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101