bártfai barnabás--makróhasználat excelben

Bártfai Barnabás

Makróhasználat Excelben

Bártfai Barnabás

MMaakkrróóhhaasszznnáállaatt EExxcceellbbeenn

BBS-INFO Kiadó, 2010.

© Bártfai Barnabás, 2010.

Minden jog fenntartva! A könyv vagy annak oldalainak másolása, sokszorosí-tása csak a szerző írásbeli hozzájárulásával történhet.

A betűtípus elnevezések, a Microsoft, a Windows, az Excel bejegyzett védjegyek. A Microsoft Szoftver Információ telefonszáma: (06-1) 267-46-36

A könyv nagyobb mennyiségben megrendelhető a kiadónál: BBS-INFO Kiadó, 1630 Bp. Pf. 21. Tel.: 407-17-07

A könyv megírásakor a szerző és a kiadó a lehető legnagyobb gondossággal járt el. Ennek ellenére, mint minden könyvben, ebben is előfordulhatnak hibák. Az ezen hibákból eredő esetleges károkért sem a szerző, sem a kiadó semmiféle felelősséggel nem tartozik, de a kiadó szívesen fogadja, ha ezen hibákra felhívják figyelmét.

ISBN 978-963-9425-40-8

Kiadja a BBS-INFO Kft. 1630 Budapest, Pf. 21. Felelős kiadó: a BBS-INFO Kft. ügyvezetője Nyomdai Munkák: Biró Family Nyomda, Budapest Felelős vezető: Biró Krisztián

Tartalomjegyzék 5

TARTALOMJEGYZÉK

Bevezető .................................................................................................................................. 7 1. A makrókról ....................................................................................................................... 92. Ami a makróhasználathoz szükséges .......................................................................... 11

2.1. Vezérlők ................................................................................................................. 12 2.1.1. Léptetőnyilak .............................................................................................. 14 2.1.2. Lista .............................................................................................................. 14 2.1.3. Legördülő lista ........................................................................................... 15 2.1.4. Jelölőnégyzetek .......................................................................................... 16 2.1.5. Választógombok ......................................................................................... 16 2.1.6. Gördítősáv, csúszka ................................................................................... 17 2.1.7. Nyomógombok .......................................................................................... 18 2.1.8. Feliratok és csoportpanelek ...................................................................... 19

2.2. Űrlap-vezérlőelemek és Active-X vezérlők ....................................................... 19 2.3. Hivatkozások ......................................................................................................... 20 2.4. Lapvédelem és cellazárolás ................................................................................. 21 2.5. Védelem a makrók ellen ...................................................................................... 22 2.6. Hogyan rendezzük el a táblázatunkat? ............................................................. 23

3. Tulajdonságpanelek és eseménykezelők.................................................................... 243.1. Tulajdonságpanelek.............................................................................................. 24 3.2. Eseménykezelők .................................................................................................... 25

4. Makrók rögzítése és szerkesztése ................................................................................. 274.1. Makrók rögzítése 2003-as verzióig ..................................................................... 27 4.2. Makrók rögzítése 2007-es verzitól ...................................................................... 28 4.3. Makrók indítása .................................................................................................... 29 4.4. Makrók szerkesztése ............................................................................................ 29 4.5. A makrók felépítése .............................................................................................. 31 4.6. Megjegyzések elhelyezése ................................................................................... 32 4.7. Többsoros utasítások ............................................................................................ 33 4.8. Hibakezelés ............................................................................................................ 33

5. Makróprogramozás ......................................................................................................... 355.1. Cellaazonosítások ................................................................................................. 35 5.2. Értékadás ............................................................................................................... 37 5.3. Változók ................................................................................................................. 38 5.4. Egyszerűbb számítások ........................................................................................ 39 5.5. Függvények ........................................................................................................... 41 5.6. Üzenőablakok ........................................................................................................ 43 5.7. Feltételvizsgálatok ................................................................................................ 45

6 Makróhasználat Excelben

5.8. Ciklusok ................................................................................................................. 48 5.9. Tömbök .................................................................................................................. 50 5.10. Alprogramok ......................................................................................................... 52 5.11. Makróból elérhető Excel funkciók ...................................................................... 53

5.11.1. Munkalap váltása .................................................................................. 54 5.11.2. Formázások ............................................................................................ 54 5.11.3. Sor és oszlopátméretezések .................................................................. 58 5.11.4. Lapvédelem ............................................................................................ 58 5.11.5. Fájl műveletek ........................................................................................ 60 5.11.6. Nyomtatás .............................................................................................. 61 5.11.7. Beszúrás, törlés ...................................................................................... 61

5.12. Párbeszédpanelek használata.............................................................................. 63 5.13. Objektumorientáltság ........................................................................................... 72

6. Programozási tanácsok ................................................................................................... 746.1. A felhasználó mindenre képes ............................................................................ 74 6.2. Kommentezés ........................................................................................................ 75 6.3. Rövidítések ............................................................................................................ 75 6.4. Statikus adatok ...................................................................................................... 75 6.5. Strukturáltság, tagolás ......................................................................................... 75 6.6. Ismeretlen adatok ................................................................................................. 76 6.7. Az adatok biztonsága ........................................................................................... 76 6.8. Problémák a ciklusok használata során ............................................................. 76 6.9. A makró nem táblázat .......................................................................................... 77 6.10. Mentések ................................................................................................................ 77

7. Példák és lehetőségek ..................................................................................................... 787.1. Árkalkuláció .......................................................................................................... 78

7.1.1. Táblázat kiegészítése ................................................................................. 80 7.2. Életjáték .................................................................................................................. 83 7.3. Számológép Excel táblázatban párbeszédpanellel ........................................... 87 7.4. Nyilvántartó .......................................................................................................... 93 7.5. Új táblázat generálása ügyféladatokból ........................................................... 110 7.6. Tréfás munkafüzet .............................................................................................. 115

8. Tárgymutató ................................................................................................................... 117

Bevezető 7

Bevezető

Jelen könyv az Excel azon rejtett képességeit ismerteti, amelyek segítségével az Excelből olyan programot varázsolhatunk, amely a saját igényeinkhez a leginkább alkalmazkodik. Az Excel sokkal többet tud annál, mint amit első látásra mutat magából. Ha bekapcsolunk bizonyos rejtett eszköztárakat, szalagokat, használjuk az azon lévő funkciókat, netán belevágunk a táblázatunk Visual Basic kóddal történő kiegészítésébe, szinte csodákat tehetünk.

A makrókról sokan hallottak már, de azt valami misztikus dolognak kezelve csak kevesen mertek belevágni a használatukba is. Pedig egyáltalán nem ördögtől való, s még programozni sem szükséges tudni hozzá, bár a komolyabb lehetőségek megvalósítása már lényegében programozásnak minősül.

A makrókat többféle célra is használhatjuk. Az egyik, ismertebb módszer a feladatok automatizálása, amikor rögzítünk egy tevékenységsorozatot, majd azt a későbbiekben – akár más adatokkal – ismételten vagy többszörösen végrehajtjuk. Ez a módszer amunkánkat könnyíti meg, hiszen ha a tevékenységsorozat összetett és többször is elvégzendő, úgy elég azt csak egyszer megtanítani a gépnek, ami aztán már később bármikor ismét végre tudja azt hajtani.

A másik lehetőség a makrók nyomógombokhoz, eseményekhez való rendelése. Ezzel a módszerrel az Excelből tetszőleges alkal-mazást varázsolhatunk, hiszen a vezérlőelemekkel és különféle tevé-kenységeket végrehajtó gombokkal olyan paneleket hozhatunk létre, amelyeket a többi Windows alatti alkalmazásnál is megszoktunk. A tevékenységek előre megadhatók, végrehajtódni pedig akkor fognak, ha a későbbi használó rákattint az adott gombra.

A mindezen funkciók mögött álló makrók pedig könnyedén rögzíthetők, vagy ha kissé komplikálni akarjuk a dolgot, úgy leprogramozhatók.

A könyv feltételezi, hogy a tisztelt olvasó már rendelkezik az Excel program középszintű ismeretével, azaz tudja azt használni, kellően


ismeri a formázási lehetőségeket, ismeri a függvényeinek nagy részét, különös tekintettel a kereső, összegző, adatbázis, és feltételes függvényekre, továbbá nem okoz gondot az alakzatok kezelése sem.

Ha netán ezen ismeretek még hiányosak, úgy ajánljuk, hogy ismételje át ezeket, például a szerző Táblázatkezelés c. könyvének segítségével.

A könyvben leírtak alapját az Excel 2007 és 2010 verziói adják, kezelést tekintve főként a 2007-es verziókban szükséges lépéseket írjuk le. Ez azonban nem jelenti azt, hogy a leírtak nem használhatók más korábbi verziókban, hiszen néhány helyen ejtünk is szót ezekről az eltérésekről is.

A könyvben lévő példák letölthetők a kiadó www.bbs.hu címen található weblapjáról a Letöltések meüpont alatt, így aki nem akar vesződni a begépeléssel, az ezt így megspórolhatja.

A makrókról 9

1. A makrókról

Az Office programcsomagban lehetőség van arra, hogy a dokumentumba (Word szöveg, Excel táblázat, stb.) ún. makrókat építsünk, amellyel bizonyos feladatokat automatikussá tehetünk. Ezt megtehetjük egy gyakran végzett művelet automatizálása miatt, vagy egy gombhoz, legördülő listához, vagy egyéb űrlapelemhez rendelt funkció végrehajtása miatt is. A makró lényegében nem más, mint egy Visual Basic modulban tárolt program, vagy parancs- és függvénysorozat, előre rögzített tevékenységek sora. A makrók a dokumentumhoz kapcsolódva tárolódnak, azok részét képezik (ezért vírusok esetén veszélyt is jelenthetnek).

A makrók készítésének több módja is van, de a program kezelésének ismerete alapfeltétel. Egy makrót írhatunk Visual Basic nyelven is, de ehhez ismerni kell a nyelv szintaxisát. Az egyszerűbb megoldás a makró rögzítése, amikor lényegében felveszünk egy tevékenységsorozatot. Ekkor az Office lépésenként eltárolja az egyes parancsok végrehajtásának adatait. (A lagpraktikusabb a kettő kombinálása.)

A makrók alkalmazásának igen hasznos és látványos módja, amikor például a Word dokumentumban vagy az Excel táblázatban létrehozunk űrlapelemeket, gombokat, stb., majd ezekhez makrókat rendelünk. Például készítünk egy Készítés feliratú gombot, amely beírja az adatot a megfelelő helyre, kinyomtat egy munkalapot, majd elmenti a táblázatot.

Az Excelből a makrók segítségével igen könnyedén látványos alkalmazásokat készíthetünk, amelyeket komolyabb célokra is fel-használhatunk, így akár készíthetünk egy komolyabb automatizált nyilvántartást, amely még a kimutatások külön fájlban való elkészítését is megoldja helyettünk.

Ha valamit lehet automatizálni, akkor azt a makrókkal tudjuk megtenni. Jól jönnek a makrók lehetőségei tehát minden olyan esetben, amikor valamilyen műveletet várhatóan a későbbiekben is jópárszor el kell majd végezni, de egy kevésbé bennfentesnek szánt


nyilvántartó elkészítésére, vagy szimulációra is tökéletes. Olyan esetekben tehát, ahol ismételni kell bizonyos lépéseket, esetleg azokat valamitől függően kell végrehajtani, s mindezt lehet automatizálni, használhatjuk a makrókat. Összetettebb Excel alkalmazások esetén is nagy valószínűséggel jól jönnek a makrók lehetőségei, de a táblázatok, szöveges dokumentumok felhasználóbarátabbá tételében is hasznos segítség lehet.

Nem érdemes azonban a makrókra, mint a mindenre jó, tökéletes megoldásra tekintenünk. Nem használhatjuk a makrókat, ha nem tudjuk magunk sem egyértelműen definiálni, hogy milyen esetben mit kell elvégezni. Nem érdemes makrót készíteni a ritkán használt feladatokhoz sem, és azt sem árt szem előtt tartani, hogy bizonyos esetekben sokszor nem elég az Excel teljesítménye, egy más adat-bázis-kezelő alkalmazás ugyanazt a problémát sokkal gyorsabban megoldhatja, bár kétségtelen, hogy azok kezelése, programozása nem olyan egyszerű, mint az Excel makróinak kezelése.

Ne felejtsük el továbbá azt sem, hogy bár a programunkat a Visual Basic használatával készítjük, azok nem lesznek Visual Basic prog-ramok, csupán az Excel makróprogramjai, mivel nem működnének az Excel nélkül, utasításaik az Excelre épülnek, és nem is lehet őket befordítani sem.

Pontosan a fentiek miatt jelen könyvben sem a Visual Basic szigorú szabályai szerint fogjuk ismertetni a nyelv lehetőségeit, hanem az egyszerűséget és az érthetőséget szem előtt tartva mutatjuk be az utasításokat. Sok utasítást ezért minden bizonnyal a bemutatottnál komplexebben és szabatosabban is lehetne használni, melyekre az Excel makróprogramozásánál viszont többnyire nincs szükség. A Visual Basic egy objektumorientált programozási nyelv, amely objektumkezelési metódusa sokkal nagyobb lehetőségeket rejt, mint amit az Excelből érdemes volna kihasználni. Az Excel makróprogramozása azonban jó alapot nyújthat a Visual Basic önálló használatához is, de ehhez jelentősen túl kell lépni a jelen könyvben ismertetett lehetőségeken.

Ami a makróhasználathoz szükséges 11

2. Ami a makróhasználathoz szükséges

Ebben a fejezetben megismerjük az Excel azon funkcióit, melyek bár közvetlenül nem tartoznak a makrókhoz, viszont az általános lehetőségeknél kissé bonyolultabbak, vagy ritkábban használtak, de a makrók használatához sokszor nélkülözhetetlenek.

Azon túl, hogy ismernünk kell az Excel függvényeit, illetve azok lehetőségeit, van még pár hasznos dolog az Excelben, ami nem kerülheti el a figyelmünket, ha hatékonyan akarunk dolgozni a makrókkal.

Bár a makrók használatához elegendő csupán azok menüből, szalagról történő meghívása is, ez nem nevezhető esztétikus megoldásnak egy komolyabb Excel táblázat esetében. A legismertebb megoldás, ha egy nyomógombra kattintva indul el makró, úgy ahogy azt a rendes alkalmazásokban is már megszokhattuk. De hogyan tudunk nyomógombot készíteni Excelben? Sokkal egyszerűbben, mint gondolnánk. Az Excel ugyanis lehetőséget biztosít az olyan ismert vezérlőelemek használatára a táblázaton belül, mint például a nyomógomb, léptetőnyíl, legördülő lista, választógomb, kijelölőnégyzet, stb. Persze ezeknek a vezérlőknek a beillesztéséhez szükséges eszköztár vagy szalag alapesetben nem látszik, mivel ezek magasabb szintű funkciók, így nem akarták a fejlesztők, hogy az átlagfelhasználót megzavarja. Sajnos a 2007-es verzióban a vezérlők és makrók használata még annyira sem elérhető, mint a korábbi változatokban volt, mert a funkciókat igencsak elrejtették, így alapesetben semelyik szalagon sem találhatók meg.

Nekünk viszont a makróhasználathoz létszükséglet, ezért kapcsoljuk is be azt minél hamarabb.

2003-as, illetve korábbi verziókban a vezérlők eszköztárat a Nézet menü Eszköztárak almenü Vezérlők eszközkészlete pontjával tudjuk bekapcsolni.


Office 2007-ben a Fejlesztőeszközök eszköztárat kell bekapcsolnunk a Fájl menü Excel beállításai gombján kattintva a Népszerű elemek funkció Fejlesztőeszközök lap megjelenítése a szalagon felirat előtti négyzet kipipálásával.

Ha ezzel megvolnánk, akkor már lehetőségünk van ezeket az elemeket a táblázatunkban alkalmazni.

A vezérlők mellett nagyban segítheti munkánkat a hivatkozások használata is, hiszen ezekkel olyan gombokat, füleket, elemeket hozhatunk létre, amelyre kattintva könnyedén ugrálhatunk a táblázat különböző pontjai közt.

Mivel a makróhasználat biztonsági kockázatokat is rejt, ezért a használat előtt meg kell ismerkednünk azok engedélyezésének lehetőségeivel is, különben nem fognak működni makróink mások számítógépén.

2.1. Vezérlők

Egy űrlapvezérlő táblázatra való beszúrásához 2007-es verzióban gördítsük le a Fejlesztőeszközök szalag Vezérlők mezőjében lévő Beszúrás ikont, kattintsunk annak az űrlap-vezérlőelemnek az ikonjára, amit használni szeretnénk, majd rajzoljuk azt meg a táblázat kívánt helyén. 2003-as verzióban a vezérlők eszköztár megfelelő elemét kell választani, majd szintén a kívánt helyen megrajzolni a vezérlőt.

A vezérlő formázása és felparaméterezése a jobb egérgomb használatával történik.

A vezérlő konfigurálásához (azaz olyan adatok megadásához, hogy melyik cellára vonatkozzon a vezérlő, milyen értékeket vehet fel stb.) kattintsunk a vezérlőre a jobb egérgombbal, majd a helyi menüből válasszuk a Vezérlő formázása pontot. Ez nagyon fontos lépés, ezen adatok megadása nélkül a vezérlőnk nem lesz több, mint egy dísz.

A vezérlők egy-egy cellához kapcso-lódnak, így ha a vezérlőt használjuk, az a kapcsolt cella tartalmát fogja módosítani. Például egy léptetőnyíl esetében megadhatjuk az induló, a minimális és maximális értéket, a


lépésközt, illetve a cellacsatolást. Ez utóbbi nagyon fontos, hiszen a Cellacsatolás sornál adhatjuk meg azt a cellát, ami módosulni fog a vezérlő használata által. Más vezérlőknél más adatok megadása szükséges, például egy legördülő lista esetén a bemeneti tartomány, a cellacsatolás és a lenyíló sorok számának megadása kell.

Nyomógomb esetén kissé más a helyzet, az ugyanis egy makró indítását eredményezheti, az elvégzendő műveleteket tehát a makrónak kell tartalmaznia. (Makró indítását természetesen más vezérlő is kiválthat, de ez nem jellemző.)

Vezérlő utólagos áthelyezéséhez, vagy átméretezéséhez kattintsunk rá a jobb egérgombbal. Ezt követően a vezérlő húzással áthelyezhető, illetve a szélein vagy sarkain lévő jelek húzásával átméretezhető.

Egyes vezérlők szerkesztése során bekapcsolásra kerül a tervező mód. Ezért ha végeztünk a vezérlők megrajzolásával és felparaméterezésével, lépjünk ki a tervező módból a Fejlesztőeszközök szalag Vezérlők mezőjében lévő Tervező mód ikon kikapcsolásával.

Egyes vezérlők csak akkor működnek normálisan, ha az oldalon lapvédelmet is használunk.

Fontos, hogy a csatolt cellának nem szabad zároltnak lennie, mert különben a vezérlő nem tudja módosítani annak tartalmát.

A kinézet szerkesztésekor a vezérlők használata esetén célszerű, ha a vezérlőket a csatolt cella mellé, vagy fölé helyezzük. A legpraktikusabb megoldás az, ha a legördülő lista vezérlő eltakarja a kapcsolt cellát, így érve el azt, hogy annak tartalma ne is látszódjon. A léptetőelemeket a kapcsolt cella mellé célszerű helyezni úgy, hogy a sormagasságot nagyobbra állítjuk. Egyes vezérlőknél (pl. választógombok) praktikus megoldás, ha a csatolt cella szövegszínét a háttérrel azonosra állítjuk, így nem lesz zavaró annak numerikus tartalma.

Mindemellett célszerű kikapcsolni a rácsvonalakat és a fejléceket, a panelek megjelenését pedig a hátterek színezésével kialakítani.


2.1.1. Léptetőnyilak

Praktikus megoldás, ha a numerikus adatot nem csak begépeléssel tudunk rögzíteni.

Ha a beviteli mező mellé kis le és felfelé mutató nyilat helyezünk, használhatjuk ezeket is olymódon, hogy a lefelé mutató nyíllal csökkenthetjük, míg a felfelé mutató nyíllal növelhetjük a beviteli mezőben található értéket. A vezérlő formázásánál megadható a lépésköz és a mező által felvehető legkisebb és legnagyobb érték is, így ezen határokon túl már hiába nyomkodjuk a gombokat, nem fog az érték változni. A cellacsatolás sorban annak a cellának az azonosítója áll, amely értékét a vezérlő módosítja.

2.1.2. Lista

A listakeret olyan terület, amelybe tetszőleges adatot nem írhatunk, csupán a gép által felajánlott listából választhatunk. Amennyiben a listára nem férne rá az összes kiválasztható adat, úgy jobboldalt egy gördítősáv is megjelenik. A listáról elemet választani a megfelelő elemen történő kattintással tudunk.

Ha a lista egyszeres, úgy csak egy érték választható ki, melynek sorszáma kerül a csatolt cellába.

Többszörös lista esetén bármely elem kattintással kijelölhető és ismételt kattintással a kijelölése megszüntethető.

A kiterjeszthető lista alapesetben csak egy elem kijelölését teszi lehetővé, ám ha a listán való kattintás mellett nyomva tartjuk a Shift vagy a Ctrl gombokat is, úgy több elem kijelölése is lehetséges.


Mivel a csatolt cella csupán az egyszeres kijelölés esetén fogja követni a listát, ezért ez utóbbi két lehetőséget ne használjuk.

A bemeneti tartomány azon cellákat határozza meg, amely cellákból a lista elemei kikerülnek. Ennek egy összefüggő, függőleges tartománynak kell lennie.

Fontos tudni, hogy az eredményt adó csatolt cellába nem a lista kiválasztott eleme kerül, hanem annak listabeli sorszáma. Így tehát ha mégis az adott elemre van szükségünk, úgy célszerűen a forrásadatot tartalmazó lista elé egy sorszámokat tartalmazó oszlopot is helyezni, majd az FKERES függvény segítségével a sorszámból a hozzá tartozó listaelemet visszaállítani, esetleg a listák ActiveX változatait használni.

2.1.3. Legördülő lista

A legördülő lista nagymértékben hasonlít a listakerethez, de itt a gép alapállapotban csak egy elemet jelenít meg, amelynek eset-leges megváltoztatásához a jobb oldalán elhelyezkedő legördítő nyíllal a listát külön kell legördíteni. Ha a listára nem férne rá az összes kiválasztható adat, úgy jobboldalt egy gördítősáv is megjelenik. Erről a listáról elemet választani úgy tudunk, hogy az egérrel a megfelelő elemen kattintunk.

Az ilyen elemet tehát célszerűen csak egysorosra tervezzük. A bemeneti tartomány itt is

azon cellákat határozza meg, amely cellákból a lista elemei kikerülnek. Ennek is össze-függő, függőleges tartomány-nak kell lennie.

Fontos, hogy az eredményt adó csatolt cellába itt sem a lista kiválasztott eleme kerül, hanem annak listabeli sor-száma. Az elem vissza-nyerésére a listáknál ismer-tetett módszer használható.

A legördülő listánál megadható további paraméter még a kattintásra lenyíló sorok száma is. Ha a lista ennél több elemet tartalmaz, úgy gördítősáv jelenik meg.


Ha a bemeneti tartomány üres adatokat is tartalmaz, úgy a listában ezen üres sorok is megjelennek, így a gördítősáv jelentősen hosszú lehet.

2.1.4. Jelölőnégyzetek

A kiválasztónégyzetek egymástól független különböző szolgáltatások be-, illetve kikapcsolására szolgálnak. Ha egy négyzet üres a négyzetben történő kattintás a négyzet bejelölését (ki-pipálását), bejelölt négy-zet esetén pedig annak törlését jelenti. A kat-tintás történhet a négyzet melletti feliratra is.

A jelölőnégyzet ered-ménye a csatolt cellában egy logikai adat lesz, ha a cella bejelölt, úgy IGAZ, ha üres, úgy HAMIS ered-ményt kapunk.

A vezérlő formázása során az alapértelmezett értéket és a csatolt cella azonosítóját adhatjuk meg.

A jelölőnégyzet szövegének módosításához kattintsunk rá a jobb egérgombbal, majd a szövegre a bal gombbal. Ezt követően lehetőség van a szöveg módosítására.

Egy lapon tetszés szerinti számú négyzetet elhelyezhetünk, azok egymásra semmiféle hatást nem gyakorolnak.

2.1.5. Választógombok

A választókapcsolók, vagy más néven rádiógombok olyan kis kör alakú gombocskák, melyek közül, mindig csak egyet aktivizálhatunk, azok egymástól függetlenül történő kapcsolása értelmetlen lenne. A kiválasztás egyszerűen az adott választókapcsolón történő kattintással valósítható meg.


Egy lapon tetszés szerinti számú választógombot elhelyez-hetünk, viszont azok közül csak egy lehet bekapcsolt állapotban. Ha valamely másik válasz-tógombra kattintunk, a korábban bekapcsolt kikapcsolásra kerül. Ennek megfelelően elegendő egy választógomb esetében formázni a vezérlőt, az a munkafüzetlapon lévő összes többi választógombra is vonatkozni fog.

A vezérlő formázása során az alapértelmezett értéket és a csatolt cella azonosítóját adhatjuk meg.

A jelölőnégyzet eredménye a csatolt cellában egy szám lesz, amely megadja, hogy hányadik választógomb van bekapcsolt állapotban. A sorrend nem a lapon elfoglalt helytől, hanem a szerkesztéskor a készítés sorrendjétől függ. Tehát az elsőnek készített választógomb adja az 1 értéket, a harmadiknak készült pedig a 3-t. Ha viszont kitörlünk egy gombot, úgy a további gombok már eggyel kisebb értéket adnak eredményül, tehát a csatolt cellában lévő szám sosem lehet nagyobb a gombok számánál.

A csatolt cellában lévő számértékből a listánál ismertetett módszerrel, vagy a HA függvény használatával tudjuk előállítani a számunkra szükséges adatokat.

A választógombok szövegének módosításához kattintsunk rá a jobb egérgombbal, majd a szövegre a bal gombbal. Ezt követően lehetőség van a szöveg módosítására.

2.1.6. Gördítősáv, csúszka

A gördítősáv vagy csúszka segítségével a léptetőnyilakhoz ha-sonlóan numerikus adatot vihetünk be. A csúszkát vízszintesen és függőlegesen is elhelyezhetjük, így amelyik oldal a hosszabb, abban az irányban fogjuk tudni mozgatni a sávon a csúszkát.

A vezérlő formázása során a csatolt cella azonosítóján túl számos további paramétert adhatunk meg.


Az aktuális érték és a lépésköz mellett itt is megadható a mező által felvehető legkisebb és legnagyobb érték is, amely a csúszka két szélső értékéhez tartozik. Ezen határokon túl már hiába nyomkodjuk a gombokat, nem fog az érték változni. Az ugrási távolság az az érték, amivel akkor változik csatolt cella, ha a sáv hátterére kattintunk.

2.1.7. Nyomógombok

A nyomógombhoz hasonló területeken történő kattintással az adott gomb funkcióját aktivizálhatjuk, azaz segítségével egy makrót indíthatunk. A gombok esetén a formázás kissé eltér a többi vezérlőelemtől, mivel itt a szokásos panel helyett a makrók kiválasztására van lehetőségünk, illetve a gombok esetében lehetőség van a felirat szövegének tetszés szerinti formázására is.

A gomb megrajzolását követően az Excel azonnal megnyitja a makróhozzárendelés panelt, ahol választhatunk, hogy a gombhoz új makrót írunk, vagy rögzítünk egy tevékenység-sorozatot. Természetesen nem kötelező azonnal hozzárendelni makrót a gombhoz, azt később is meg tudjuk tenni. Ha elkezdjük a rögzítést, úgy azt a Nézet szalag Makrók gombjának legördítésével elérhető Rögzítés vége funkcióval tudjuk befejezni.

Ha egy meglévő gombra rákattintunk, úgy alapesetben a hozzá rendelt makró fog elindulni. A gomb szerkesztéséhez a jobb egérgombbal kell rákattintani, majd a helyi menüből a Makró-hozzárendelés pontot választani. Ha a gomb már szerkesztés alatt áll, úgy ez a pont nem érhető el, ilyenkor kattintsunk másutt, majd


kezdjük előröl a jobb egérgombbal való kattintást. A gombhoz rendelhetünk előre megírt, vagy korábban rögzített makrókat is, ha választunk a panel bal oldalán lévő listából.

Az átméretezés szintén a jobb egérgombbal való kattintást követően, a széleken és sarkokon lévő jelek húzásával kivitelezhető. Ekkor módosíthatjuk a gomb feliratát is, illetve ha kijelöljük a szöveget úgy a betűtípus, betűméret és néhány egyéb betűjellemző is módosítható.

2.1.8. Feliratok és csoportpanelek

A vezérlők rendszerezéséhez, azok áttekinthetővé tételéhez feliratokat és csoportpanel-kereteket is létrehozhatunk. Ezen elemek azonban vezérlési funkciót nem látnak el.

2.2. Űrlap-vezérlőelemek és ActiveX vezérlők

Az Excel táblázatokban vezérlő készítésénél ugyanazon vezérlőket megtaláljuk az Űrlap-vezérlőelemek és ActiveX vezérlők között is. Jogosan merülhet fel a kérdés, hogy mi a különbség a kettő közt és mikor érdemes az egyiket és mikor a másikat használni.

Nos a felhasználó alapesetben csak annyit lát, hogy a hagyományos űrlap vezérlőelemeken szebben jelennek meg a betűk, míg az ActiveX vezérlőkön töredezettebben. A különbség azonban nem ez. A hagyományos űrlap vezérlőelemek használata egyszerűbb, konfigurálása kézenfekvőbb, viszont a használhatóságuk köre korlátozottabb. Az Excel táblázataiban többnyire bőven elegendő ezeket használni, viszont ha már párbeszédpaneleket is készítünk, úgy az ActiveX vezérlőkre lesz szükségünk. Az ActiveX vezérlőkkel olyan külső funkciók is használhatók, amelyek nem az Excel lehetőségei, hanem külső programok által használt vezérléseket valósítanak meg, így ezen speciális vezérlések ezáltal Excelből is elérhetővé válnak. Az ActiveX vezérlők lényegében olyan kis bővítmények, melyek az Excel program lehetőségein kívül másutt, akár az interneten is használatosak, segítséget nyújthatnak különböző feladatok elvégzéséhez. Egyes webhelyek megkövetelik az ActiveX vezérlők telepítését ahhoz, hogy meg lehessen tekinteni a webhelyet, vagy műveleteket tudjunk végezni rajtuk. Ennek megfelelően tehát ha csupán egy egyszerűbb Excel makróprogramot kívánunk készíteni, ahol a vezérlőket az Excel táblázataiba integráljuk, úgy jobban járunk a hagyományos vezérlőkkel, mivel azokat


egyszerűbben konfigurálhatjuk. Ha azonban ennél többre vágyunk, úgy jöhetnek az ActiveX vezérlők.

A legszembetűnőbb eltéréseket, a két vezérlőtípus tulajdonság-lapján táthatjuk. A hagyományos vezérlőknél a helyi menü Vezérlő formázása pontjának Vezérlő fülénél állíthatjuk be a legfontosabb jellemzőket, az ActiveX vezérlők esetében viszont a helyi menü Tulajdonságok pontját használhatjuk. Ez utóbbi lényegesen összetettebb és magyar nyelvű Excel esetén is angolul jelenik meg. Ebből adódóan sokkal több paraméter állítható, így jobban konfigurálható, mint a hagyományos vezérlő.

Néhány vezérlő esetében azonban egyéb jelentős, működésbeli eltérések is vannak. Az egyik ilyen például a legördülő listán kiválasztott sor által szolgáltatott eredmény. A hagyományos űrlapvezérlő azt adja meg, hogy a lista hányadik elemét választottuk ki, így a cellacsatolásként megadott eredménycellába egy szám kerül. Az ugyanilyen ActiveX vezérlő viszont magát a kiválasztott listaelemet írja a csatolt cellába. Ennek megfelelően az eredmény feldolgozása is merőben más műveleteket fog igényelni.

2.3. Hivatkozások

Ha olyan gombokat szeretnénk készíteni, amelyek a munkafüzetünk másik oldalára vagy pontjára visz, akkor ezért nem kell makrót rögzítenünk, sokkal egyszerűbb egy alakzathoz rendelt hiperhivatkozás. Az alakzat bármi lehet, egy bezárógomb, egy lapfül, vagy egy tetszőleges gomb, a lényeg az, hogy ezt rajzoljuk meg először. Ha elkészült, kattintsunk rá, majd válasszuk a Beszúrás szalagról a Hiperhivatkozást. A baloldali résznél kattintsunk a Dokumentum adott pontja gombra, majd a baloldali részben válasszuk ki a kívánt munkalapot és írjuk be


azt a cellaazonosítót, amire ugrani szeretnénk. Ezzel el is készült egy olyan gomb, amelyre kattintva más helyre ugorhatunk.

2.4. Lapvédelem és cellazárolás A vezérlők megfelelő működése és az űrlap átírásának, téves

módosításának elkerülése érdekében mindenképpen szükséges a cellazárolások és lapvédelmek használata.

Javasolt, hogy az összes cellát állítsuk zároltra, az adatbevitelre szánt celláknál pedig kapcsoljuk ki a zárolást. Alapesetben minden cella zároltra van állítva, de mivel nem aktív a lapvédelem, ezért ezt nem érzékeljük. Ha tehát egy lapot oly módon szeretnénk megóvni, hogy csak néhány adatbeviteli cella tartalma legyen módosítható, a többi pedig ne, úgy jelöljük ki a védelmet nem igénylő cellákat, majd gördítsük le a Kezdőlap szalag Cellák mezőjében a Formátum elemet és kapcsoljuk ki a Cellák zárolása pontot. (Ugyanezt érjük el, ha a Kezdőlap szalag Betűtípus mezőjének jobb alsó sarkában lévő jelre kattintva előhívjuk a cellaformázás panelt, ahol a Védelem fület választjuk.) A panelen kapcsoljuk ki a zárolást a pipa kivételével a Zárolt felirat előtti négyzetből. (Ha nem változtattuk meg, úgy alapesetben minden cella zároltra van állítva.)

Miután ezt minden olyan cellánál megtettük, ahol engedélyezett a módosítás, kapcsoljuk be a védelmet is. Ehhez gördítsük le a Kezdőlap szalag Cellák mezőjében a Formátum elemet és válasszuk a Lapvédelem pontot. A megjelenő panelen kattintsunk az OK gombra, esetleg állítsuk be a védelem hatókörét, vagy adjunk jelszavat. Jelszavas védelem esetén a jelszó a védelem feloldásához szükséges, így elfelejtése súlyos következményekkel járhat.


Az optimális működés érdekében célszerű úgy bekapcsolni a lapvédelmet, hogy a zárolt cellák kijelölését se engedélyezzük. Ezzel megakadályozhatjuk, hogy a kitölthető cellákon túl más cellára is rávihessük a cellakurzort. Ehhez vegyük ki a pipát a Zárolt cellák kijelölése előtti négyzetből.

Ha a védelem bekapcsolását követően netán mégis módosítani szeretnénk a táblázatot úgy bármikor kikapcsolhatjuk a védelmet, ha legördítjük a Kezdőlap szalag Cellák mezőjében a Formátum elemet és kiválasztjuk a Lapvédelem feloldása pontot. Természetesen ha a védelem bekapcsolásakor jelszót is megadtunk, úgy a védelem csak ennek begépelését követően oldható fel.

Itt kell megjegyezni, hogy ha olyan táblázattal találkozunk, ahol egyes funkciók ikonjai szürkék, nem használhatók, akkor azok védettek, hiszen védett táblázatban a különböző módosításokat kiváltó menüpontok sem hívhatók le.

Lehetőségünk van arra is, hogy előre meghatározzuk az egyes cellákba írható adatok formátumát és elfogadható értékeit. Ezt nagyon egyszerűen beállíthatjuk, hiszen nem kell mást tenni, mint az Adatok szalag Érvényesítés ikonján kattintani, majd a megjelenő panelt értelemszerűen kitölteni.

2.5. Védelem a makrók ellen Mivel a makrók veszélyes kódokat, vírusokat is tartalmazhatnak,

ezért alapesetben az Excel letiltja a használatukat. Ha tehát engedélyezzük a makróhasználatot a saját gépünkön, majd az ott elkészített és tökéletesen működő Excel alkalmazást átvisszük egy másik gépre, az nagy valószínűséggel egyáltalán nem fog működni, mivel az alapértelmezés szerinti beállítás nem engedi a makrók futtatását.

Ha nem akarjuk minden egyes indításkor külön engedélyezni az adott munkafüzet makróit, úgy rákényszerülünk arra, hogy megváltoztassuk a makróbeállításokat. Ehhez a következőket kell tennünk: • kattintsunk az Office menü alsó-középső részén található Az Excel

Beállításai gombra,


• kattintsunk a baloldali listán az Adatvédelmi központ funkcióra,• kattintsunk Az adatvédelmi központ beállításai gombra,• kattintsunk a baloldali listán a Makróbeállítások funkcióra,• jelöljük be Az összes makró engedélyezését,• zárjuk a panelt az OK gombbal.

2.6. Hogyan rendezzük el a táblázatunkat? Ha egy Excel táblázatot vezérlőkkel és makrókkal való használatra

szeretnénk felkészíteni, úgy célszerű annak szerkezetét jó előre végiggondolni.

Nagyon fontos, hogy külön munkalapon tároljuk a módosítandó adatokat és külön munkalapokat hozzunk létre azon vezérlő és beviteli paneleknek, amelyeken a kezelést végezzük. Ezen paneleken használjunk zárolást és lapvédelmet. Lapvédelmet az adatok tárolására szolgáló munkalapokon is használhatunk, de ekkor makróból meg kell oldani a lapvédelem ki- illetve bekapcsolását.

A vezérlőket tartalmazó munkalapok sormagasságait és oszlop-szélességeit igazítsuk a beviteli mezőkhöz. Ha szükséges használjuk több keskenyebb cellát, cellaegyesítéseket, keretezéseket és háttereket. Itt kikapcsolhatjuk a rácsokat és fejléceket is.

A kiértékelést végző függvényeket, valamint a segédszámításokat elvégeztethetjük ezeken a lapokon is, de ezen cellák színét állítsuk háttérszínűre, hogy a segédadatok ne legyenek láthatók.

Ha több beviteli panelt készítünk, úgy azokat külön munkalapra helyezzük, melyekre hiperhivatkozásokkal ellátott alakzatok segítségével ugorhatunk.


3. Tulajdonságpanelek éseseménykezelők

3.1. Tulajdonságpanelek Minden objektumnak, így a munkafüzetnek, a munkalapnak, a

párbeszédpanelnek, a különböző vezérlőknek van egy ún. tulajdonságpanelja, amely az objektum jellemzőit foglalja össze. Ezen panelek az esetek nagy részében nem láthatók, és többnyire nincs is rájuk szükség egészen addig, amíg nem kezdünk el egy kicsit mélyebben foglalkozni az Excel lehetőségeivel.

A tulajdonságpanelekkel leginkább az ActiveX vezérlők és a párbe-szédpanelek esetén találkozhatunk. A sima űrlapvezérlők a tulajdon-ságpaneleket nem jelenítik meg, csupán azoknak az éppen szükséges adatait. Ha viszont létrehozunk például egy ActiveX beviteli listát, majd annak a jobb egérgombbal előhívható helyi menüjéből a Tulajdonságok pontot választjuk, úgy megkapjuk a kívánt tulajdonságlapot. Ezek a tulajdonságlapok számos jellemző tekintetében azonosak, de tartalmuk függ az objektum típusától. Például az előbbi beviteli lista esetén egyedi a ListFillRange mező, ami azt határozza meg, hogy a beviteli listában szereplő adatok honnan származzanak, vagy a ListRow, ami azt adja meg, hogy legördítéskor hány sor látszódjon. Ez logikusan nincs például egy léptetőnyílnál, de a

Tulajdonságpanelek és eseménykezelők 25

LinkedCell ott is megtalálható, hiszen hogy melyik cellához történjen a csatolás, azaz hogy hova kerüljön az eredmény, azt minden vezérlőnél meg kell adni. Fontos paraméter még A (Name) mezőben lévő név, hiszen ez alapján tudunk hivatkozni az objektumra, de számos szín, keret, megjelenítés, betűtípus, elrejtés, méret, stb. adat is meghatározható itt.

A tulajdonságlapon lévő jellemzők megjeleníthetők ábécébe rendezve is, de ha kattintunk a Categorized fülre, akkor funkció szerint kategorizálva valószínűleg könnyebben találjuk meg a kívánt tulajdonság beállítására szolgáló sort. (ld. 66. oldal.)

3.2. Eseménykezelők

Mielőtt kitérnénk az eseménykezelésre nézzük meg, mi is az esemény, mi válthatja azt ki. Eseménynek azokat a tevékenységeket vagy történéseket nevezünk, amelyek változást eredményeznek a folyamatokban. Tipikus esemény tehát egy kattintás, dupla kattintás, de esemény az egér rámozdítása egy objektum fölé, lehúzása arról, az azon való elmozdítás, illetve esemény lehet egy munkalap megnyílása vagy bezárása is. Az eseménykezelés során tehát azt kell vizsgálnunk, hogy milyen objektummal mi történt és azt kell meghatároznunk, hogy az adott esemény bekövetkeztekor mit kell csinálni. Látható tehát, hogy rengeteg esemény létezhet, hiszen rengeteg objektumunk van, amivel rengeteg dolgot végezhetünk, de ezen események nagy része esetén nem kell csinálnunk semmit sem, ezért ezeket vizsgálni sem kell. (Nem kell tehát lekezelnünk azt, hogy mi történik, ha rávisszük az OK gomb fölé az egeret, vagy levisszük onnan, elegendő csak azt meghatározni, hogy mi történjen akkor, ha rákattintunk.)

Az objektumorientáltság révén minden objektumhoz tudunk eseménykezelést definiálni az Excelben, így az eseménykezelőkkel számos érdekes dolog kivitelezhető, hiszen eseménykezelő kódok nem csak a párbeszédpanel-elemekhez rendelhetők, hanem akár a munkalapokhoz vagy a munkafüzetekhez is. Így például akár azt is megtehetjük, hogy egy munkafüzet megnyitásakor az azonnal be is záródjék, lehetetlenné téve annak használatát.

Az eseménykezelés megvalósításához első lépésben a Fejlesztőeszközök szalagon kattintsunk a Visual Basic gombra. A panel baloldali részében megjelenik a projektlista, ahol (először dupla kattintással) ki tudjuk választani a kívánt objektumot. Ezt követően a jobboldali ablakrész tetején már megjelenik két legördítő elem, ahonnan választhatunk objektumot,


illetve hozzá tartozó eseményt. A kiválasztás hatására a szükséges kódrészlet nyitó és záró tagja létrejön, e kettő közé pedig beírhatjuk az esemény bekövetkeztekor végrehajtandó utasításokat.

Az alábbi ábrán látható példában egy olyan táblázatot hoztunk létre, ami megnyitáskor is megkérdezi, hogy tényleg meg akarjuk-e nyitni.

Ugyanilyen módon azonban elérhetjük azt is, hogy például a táblázat megnyitásával együtt rögtön elinduljon az általunk megírt program is, ami elrejti a teljes táblázatot és csak párbeszédpanelekkel kommunikál a felhasználóval.

A tréfás kedvű felhasználók itt sok érdekes dolgot meg tudnak valósítani, hiszen bezáráshoz, nyomtatáshoz, lapváltáshoz és még számos eseményhez lehet vicces kódokat írni, az őrületbe kergetve ezzel a munkafüzet használóját.

Makrók rögzítése és szerkesztése 27

4. Makrók rögzítése és szerkesztése

Az Excel makrói lényegében nem mások, mint olyan rögzített tevékenységsorozatok, amelyek Visual Basic nyelven kerülnek leí-rásra. Ebből következően a makrókat vagy úgy rögzítjük, hogy a magnóhoz hasonlóan felvesszük a tevékenységünket, vagy pedig egy felületen a programozási nyelvekhez hasonlóan beírjuk azok VBA kódját.

A makrók rögzítése során természetesen nem kerül rögzítésre minden. Nem rögzülnek a különböző menükön, szalagokon történő lépkedések, csak a kiválasztott funkció. Ha tehát ötször oda-vissza váltunk a Kezdőlap és Beszúrás szalag közt, majd kattintunk a vastag betűs gombon, úgy a makróban csak a vastag betű kiválasztása fog szerepelni. Ugyanígy ha össze-vissza lépkedünk a munkalapon a különféle cellák közt, majd végül az E3-ba beírunk valamit, úgy a makróba csak az E3 cella kiválasztása és a beírás kerül.

A makró a rögzítés indításától egészen addig tartalmazni fogja a tevékenységeket, ameddig a rögzítést le nem állítjuk. Excel 2007-ben a rögzítés vége gomb a bal alsó sarokban, a Nézet szalagon a Makrók gombbal legördíthető funkciónál, illetve a Fejlesztőeszközök szalag Kód mezőjében van.

A rögzítés indítása történhet szalagról, menüből, vagy egy nyomógomb vezérlő rajzolásával is.

Minden makró önálló nevet kap, melynél vagy elfogadjuk a gép által felajánlottat (pl. Gomb2_Kattintás), vagy mi adunk neki egyet.

A rögzített vagy megírt makrókat a gép a táblázattal együtt elmenti, azokat külön menteni nem szükséges.

4.1. Makrók rögzítése 2003-as verzióig

Excel 2003-ig a rögzítést az Eszközök menü Makró menüpont Új makró rögzítése almenüjével indíthatjuk. A tevékenységek rögzítése mindaddig megtörténik, amíg azt a gombbal, vagy az Eszközök menü Makró menüpont Rögzítés vége almenüjével le nem állítjuk. A rögzítés befejeztével természetesen a makrót utólag is módosíthatjuk,


s abban Visual Basic nyelven módosításokat is végezhetünk. A rögzített makró szerkesztéséhez válasszuk az Eszközök menü Makró menüpont Makrók almenüjét vagy üssük le az Alt-F8 billentyűket. A megjelenő listából válasszuk ki a szerkesztendő makrót, majd kattintsunk a Szerkesztés gombra. Ha nem szerkeszteni kívánjuk a makrót, hanem gyorsbillentyűt kívánunk hozzá rendelni, úgy az Egyebek gombra kell kattintanunk.

Korábban rögzített makró futtatásának legegyszerűbb módja, ha a hozzárendelt gyorsbillentyű kombinációt leütjük. Ha ilyet nem definiáltunk, úgy válasszuk az Eszközök menü Makró menüpont Makrók almenüjét, vagy üssük le az Alt-F8 billentyűket. A megjelenő listából válasszuk ki az indítandó makrót, majd kattintsunk az Indítás gombra.

4.2. Makrók rögzítése 2007-es verziótól

2007-es verzióban a rögzítést a Nézet szalag Makrók ikon Makró rögzítése funkciójával indíthatjuk. Miután megadtuk a makró nevét, a tevékenységek rögzítése mindaddig megtörténik, amíg azt a bal alsó sarokban lévő gombbal, vagy a Nézet szalag Makrók ikon Rögzítés vége funkciójával le nem állítjuk.


Makrórögzítésre lehetőség van egy űrlapvezérlő (pl. nyomógomb) megrajzolásakor, vagy annak helyi menüjéből a Makróhozzárendelés pont kiválasztásakor is, ha a Rögzítés gombra kattintunk.

A rögzítés befejeztével természetesen a makrót utólag itt is módosíthatjuk, s abban Visual Basic nyelven módosításokat is végezhetünk. A rögzített makró szerkesztéséhez kattintsunk a vezérlő helyi menüjének Makróhozzárendelés pontján, vagy a Nézet szalag Makrók ikon Makrók megjelenítése során.

A megjelenő listából válasszuk ki a szerkesztendő makrót, majd kattintsunk a Szerkeszt gombra. Ha nem szerkeszteni kívánjuk a makrót, hanem gyorsbillentyűt kívánunk hozzá rendelni, úgy az Egyebek gombra kell kattintanunk. (Ez csak szalagról való választással működik, helyi menünél nem.)

4.3. Makrók indítása

Korábban rögzített makró futtatásának legegyszerűbb módja, ha a hozzárendelt gyorsbillentyű kombinációt leütjük, vagy a csatolt űrlapvezérlőn kattintunk. Ha ilyet nem definiáltunk, úgy az előbbi panel Indítás gombját is használhatjuk.

Jelen könyv témája miatt nekünk a későbbiekben a nyomógomb űrlapvezérlő használatával történő indítás lesz a leginkább hasznos.

4.4. Makrók szerkesztése

Ha a korábban ismertetett verziótól függő módszerrel előhívjuk a makrók panelt, esetleg a nyomógomb vezérlőre a jobb egérgombbal kattintva a Makró-hozzárendelés pontot választjuk, úgy megjelennek már létrehozott makrók. A makró nevére, majd a Szerkesztés gombra való kattintás hatására megjelenik a Visual Basic


fejlesztőfelülete, ahol lehetőségünk van a makrók módosítására, szerkesztésére.

A szerkesztés igen egyszerű, lényegében egy jegyzettömbhöz hasonló felületet kapunk, ahol a szövegszerkesztésben megszokott lehetőségeink vannak. A mentéssel és hasonló dolgokkal nem kell foglalkoznunk, még ha be is zárjuk a Visual Basic ablakát a makró a táblázattal együtt akkor is elmentésre kerül.

A Visual Basic felület sajnos még a magyar változatban is angol nyelvű, bár valójában ezekre a funkciókra egyáltalán nem lesz szükségünk. A Visual Basic és a hozzá kapcsolódó felület használata nem e könyv témája, bár a szerkesztés a Visual Basic nyelv használatával történik, de néhány makró rögzítése, majd a létrehozott kódok tanulmányozásával az alapfunkciókra hamar rá lehet jönni a nyelv elsajátítása nélkül is. Azt a kis programozási alapismeretet, amire szükség van, a későbbiekben tárgyaljuk.

A makrók modulokban tárolódnak. Egy munkafüzethez több modul is tartozhat, de erre valójában nincs szükség, mert az utasítások alapján az egy modulban lévő makrók kellően elválasztásra kerülnek egymástól. (Ha később nem találunk egy korábban készített makrót, nézzük meg a többi modulban is.)


A szerkesztőfelület az alapvető formázási hibákat automatikusan javítja, illetve az utasításokat kékkel kiemeli.

Persze a Visual Basic nyelv rengeteg lehetőséget tartogat, ezeket mi most nem fogjuk mind megismerni, csupán azokat, amelyekre az Excel makróhasználatához szükség van.

Persze kezdhetnénk úgy is, hogy megtanuljuk a Visual Basicet, majd nekiállunk abban makrókat programozni, de ez a módszer nem vezet gyors eredményre. A legjobb megoldás, ha rögzítünk tevékenységeket makrókban, majd azokat kielemezve végignézzük, hogy az adott tevékenység milyen kódot generált. Ha kielemezzük a rögzített makrókat, rengeteget tanulhatunk. Mivel e könyvben sem térhetünk ki minden lehetőségre, illetve nem is lenne értelme minden olyan dolgot leírni, amit pár pillanat alatt magunk is előállíthatunk, ezért ezt a módszert javasoljuk minden olyan esetre, amikor valami új dolgot szeretnénk megvalósítani.

Persze vannak olyan dolgok, melyek nem rögzíthetők, azokat csak programozással tudjuk megoldani. Ilyenek például a feltétel-vizsgálatok, tehát azok a tevékenységsorozatok, amelyek végrehajtása valamilyen feltételtől függ, vagy a ciklusok, tömbök használata, de ide sorolhatók az üzenetablakok megjelentetése is. Ezen lehetőségeket csak úgy tudjuk kivitelezni, ha a korábban rögzített vagy megírt kódot magunk egészítjük ki a szükséges utasításokkal.

4.5. A makrók felépítése

Minden makró egy SUB utasítással kezdődik, amelyet a makrónév követ. Mivel a rögzített makrók paramétert nem tartalmaznak, a makrónév után lévő nyitó zárójelet rögtön a záró zárójel követi. A makró utolsó utasítása az End Sub, ezzel történik a makró zárása. E két utasítás közt helyezkednek el a makrót alkotó utasítások, soronként egy-egy darab. Az utasítások után, azzal egy sorban az utasítás paraméterei állnak.

Ha egy sor végére aláhúzásjelet teszünk, úgy az egy sorban lévő utasítások több sorban is leírhatók. Arra viszont figyelni kell, hogy ne törjük meg utasítás közben a sort. (A könyvben sajnos papírszélességi okokból ez sok esetben nem kivitelezhető, ezért értelemszerűen az e miatt több sorba írt utasításokat a kódszerkesztőben egy sorba kell felvinni, különben hibajelzést kapunk.)

A szerkesztés során a gép a makrók közé vonalakat húz, ezzel jelezve az egy modulban lévő különböző makrók határait.


Mindezeket gyönyörűen láthatjuk is, ha rögzítünk pár makrót, majd kiválasztjuk valamelyiket szerkesztésre.

Ahhoz, hogy a makróink áttekinthetőek legyenek, nem árt figyelni a tagolásra. A programozás során bevált gyakorlat, hogy az egy csoportba tartozó vagy egy szinten végrehajtandó utasításokat beljebb kezdjük. Tipikus példája ennek a feltételvizsgálat, amikor az adott feltétel teljesülése esetén végrehajtódó utasítások pár karakterrel beljebb állnak, mint a program többi, minden esetben végrehajtódó része.

4.6. Megjegyzések elhelyezése

Az áttekinthetőség további feltétele, hogy tudjuk, melyik programrész mire szolgál. Ezt úgy tudjuk megvalósítani, hogy a programba megjegyzéseket helyezünk. Ezen megjegyzések nem fognak végrehajtódni, viszont később, amikor már nem emlékszünk arra, hogy azt miért, vagy miért úgy írtuk, nagyon hasznosak lesznek. A programok írása során komoly probléma, ha később javítani, vagy kiegészíteni szeretnénk a programot, de addigra már nem tudjuk, hogy mit miért írtunk oda, melyik programrészlet mire való, stb. Ezt elkerülendő mindenképpen ajánlatos kommentezni a programot, azaz a kényesebb, vagy fontosabb programrészletekhez olyan megjegyzést írni, amit mi megértünk, de a gép nem hajtja végre. Az ilyen megjegyzéseket úgy tudjuk elkészíteni, hogy a megjegyzést tartalmazó sort aposztróf jellel kezdjük.

(A Visual Basic pedig zöld színnel jelzi, hogy az a sor megjegyzés.)

Sub makro1() Ez a sor végrehajtásra kerül 'Ez csak egy megjegyzés, nem hajtódik végre Ez már végrehajtódik End Sub


4.7. Többsoros utasítások

Előfordulhat, hogy bizonyos utasításokat hosszuk miatt nem akarunk egyetlen sorba írni, hanem több sorban kívánjuk azt szerepeltetni. Ekkor megtehetjük, hogy azt a tagok közt elválasztjuk. Az elválasztásra azonban nem szóközt vagy kötőjelet, hanem aláhúzásjelet kell használnunk úgy, hogy a sort aláhúzásjellel zárjuk, majd az utasítás többi részét a következő sorba írjuk. Ez a módszer természetesen nem használható a paraméterként megadott szövegek esetében, illetve utasításszón belül.

4.8. Hibakezelés

Mivel emberek vagyunk munkánk során hibát is véthetünk. Nincs ez másként az Excel makrók készítésekor sem. Előfordulhat, hogy már beíráskor elrontunk valamit, nem megfelelően gépeljük be a parancsokat, véletlenül összevonunk sorokat, stb. Az ilyen jellegű hibák többségét könnyen észrevehetjük, mert a gép a szöveget pirossal kiemeli. Olvassuk át a sort és ellenőrizzük, hogy szintaktikailag minden rendben van-e.

Ha a hiba nem elírásból származik, hanem valamilyen logikai, vagy az adatokkal kapcsolatos probléma, úgy a gép azt nem tudja kijelezni, viszont a makró lefutásakor az hibajelzést ad. Ilyenkor a makró hibáig terjedő része végrehajtódik, ott viszont a makró hibával leáll, majd rákérdez, hogy mit tegyen a gép. Célszerű a makró szerkesztését (Debug) válasz-tani, hiszen a hibát ki kell javítani, az nem maradhat a programban. Ez esetben a Visual Basic a hibás sort megjelöli és sárgával kijelzi, hogy láthassuk hol ált le a program futása. Ha kijavítottuk a hibát, az F5 billentyű lenyomásával folytathatjuk a makró futtatását, vagy bezárhatjuk a szerkesztőt, de ez esetben a gép megerősítést kér, hogy valóban leállítjuk a hibakeresőt.

Segítség a hibakeresésben, hogy ha a programban valamely változó neve fölé visszük az egérkurzort, úgy a Visual Basic


megjeleníti annak aktuális értékét, melyekből sok hasznos következtetést vonhatunk le.

A hibáknak a nagyobbik része azonban nem okoz hibajelzést, csupán egyszerűen nem azt, vagy nem úgy csinálja a makró, ahogyan mi azt szeretnénk. Az ilyen hibákat sokszor még észrevenni is nehéz, a hiba okát megtalálni és kijavítani pedig méginkább az.

Teszteléskor használhatjuk a Visual Basic ablakának gombjait is. így például innen is tudjuk közvetlenül indítani a makrót, vagy leállítani a futtatást. A gombokkal indíthatjuk, felfüggeszthetjük, vagy leállíthatjuk a makró futtatását. Ez utóbbi gombra különösen hiba esetén lehet szükség.

Az F8 billentyűvel lehetőségünk van a makrót lépésenként is futtatni, így minden egyes F8 gomb megnyomás egyetlen sor végrehajtását eredményezi.

További lehetőség a töréspont beszúrása, amivel az adott ponton felfüggeszthetjük a program futtatását, így ellenőrizni tudjuk, hogy az adott pillanatban a változók milyen értékeket tartalmaznak, vagy miért történt probléma. Töréspontot az F9 billentyűvel szúrhatunk be a kurzor sorára és szintén az F9 billentyűvel távolíthatjuk azt el.

Makróprogramozás 35

5. Makróprogramozás

Ahhoz, hogy a makrókat ne csak rögzíteni tudjuk, hanem azokat saját igényeink szerint szerkeszteni vagy átprogramozni is, meg kell ismerkedni számos további tudnivalóval, melyek lényegében a programozás alapjait is jelentik. Ilyenek a változók kezelésének ismerete, a feltételvizsgálatok, a ciklusok, stb. Ha ezekkel a dolgokkal sikeresen megismerkedtünk, úgy már könnyedén elkészíthetjük az Exceles makróprogramunkat.

A következőkben a makrók programozásához szükséges tudnivalókat foglaljuk tehát össze, mindezeket példákkal szemléltetve. A példamakrókat magunk is kipróbálhatjuk, ha kiválasztjuk a Nézet szalag Makrók ikonjáról a Makrók megjelenítése pontot. Itt egy makrónév megadásával majd a Létrehozás gombra kattintva lehetőségünk van begépelni azokat, míg az Indítás gombra kattintva ki is próbálhatjuk a már felvitteket.

5.1. Cellaazonosítások

Az Excel makróiban nagyon fontos, hogy a táblázat celláira hivatkozni tudjunk. Lényeges tehát, hogy ismerjük a makrókban történő cellaazonosításokat, amely a Range(cellaazonosító) formulával történik. A cellaazonosító helyén állhat változó, vagy idézőjelek közé írt sor és oszlopazonosítás. Az A1 cellát például a Range("A1") formulával azonosíthatjuk.

Másik lehetőség a cellaazonosításra a Cells(sorszám,oszlopszám) formula is, ahol például a Cells(5, 3) a C5 cellát azonosítja.

Emellett ismernünk kell azt is, hogy miként tudunk hivatkozni a makrókban az aktuális cellára. E célra az ActiveCell formula szolgál.

Bár más programozási környezetben ez nem jellemző, de az Excel makróiban fontos dolog, hogy mozogni tudjuk a táblázatban, azaz meg tudjuk változtatni az aktív cellát. E célra a Range(cella-


azonosító).Select utasítás szolgál. Ha a cellaazonosítót közvetlenül adjuk meg, úgy azt idézőjelek közé kell tenni. Például a Range("A1").Select

utasítás az A1-es cellára helyezi a cellakurzort. Ha egy területet szeretnénk kijelölni úgy értelemszerűen a terület

azonosítója áll a cellaazonosító helyén. Például a Range("A1:D5").Select

utasítás kijelöli az A1-től D5-ig terjedő területet. A Range és Cells utasítások látszólag ugyanazt a célt szolgálják,

ám nem csupán az azonosítások írásában van a különbség. A két azonosító akár össze is vonható, sőt kiegészíthető munkalapra való hivatkozással is.

A Worksheets(2).Range("B2:D5").Cells(2,2) formula például a második munkalap C3-as cellájára hivatkozik, mivel a Worksheets(2) tag a második munkalapot, a Range("B2:D5").Cells(2,2) tag pedig a B2:D5 tartomány második sorának második oszlopát jelenti. A lehetőségeink tehát igen tágak, csak ki kell használnunk őket.

Ha nem abszolút, hanem relatív hivatkozásra van szükségünk, úgy Selection.Offset(sor, oszlop) formulát kell használnunk. Ez esetben az aktuális cellától mérten történik meg a cella meghatározása. Ha például a makróban a Selection.Offset(3, 2).Select parancsot használjuk, úgy az kiválasztja az aktuális cellától 3 sorral lejjebb és 2 oszloppal jobbra lévő cellát. Ugyanígy a Selection.Offset(2, 1) = 1 utasítás az aktuális cellától 2 sorral lejjebb és 1 oszloppal jobbra lévő cellába ír egy egyest.

Az azonosítani kívánt cella természetesen lehet más munkalapon is, ebben az esetben a Range("munkalapnév!cellaazonosító")

formátumot kell használnunk a hivatkozásban. Pl.: Range("Munka2!A1")

Ha a makróhasználat során csak egyszerűen munkalapot szeretnénk váltani, úgy a Sheets("Munkalapnév").Selectutasítást kell kiadni. Például a Sheets("Munka2").Select

sor a Munka2 munkalapra vált át.


Előfordulhat, hogy a rögzített makrókban az itt bemutatott formulákat a gép egy kicsit összetettebben kezeli, hiszen például az aktuális cella esetében az ActiveCell.FormulaR1C1 kifejezést használja, ami ugyanúgy jó. Ezek azért vannak így, mert a Visual Basic sokkal több lehetőséget kínál, mint amit mi az Excel makróprogramozása során kihasználunk, így a rögzítéskor gyakran a komplexebb alak kerül tárolásra.

5.2. Értékadás

Az értékadás során egy cellának vagy egy változónak megváltoztatjuk az értékét. Az új érték lehet egy konkrét szám, vagy egy számolt kifejezés is. Például az ActiveCell = 1

utasítás az aktuális cellába 1-et ír be. Most nézzünk egy egyszerű példát. Az alábbi kis makró az A2

cella tartalmát az A1 celláénál eggyel nagyobbra állítja be. Ehhez írjunk egy számot az A1 cellába, majd rögzítsük az alábbi makrót, és indítsuk is el: Sub test() Range("A2") = Range("A1") + 1 End Sub

Persze vigyáznunk kell, hogy az A1-ben szám legyen, különben a program hibajelzéssel leáll, mivel a szöveghez nem tud egyet hozzáadni.

Az értékadásnak egy speciális, de a programozás során gyakran alkalmazott módszere amikor az értékadó utasítás mindkét felén ugyanaz a kifejezés áll, de a jobb oldalon az egy művelettel kerül kiegészítésre. Ilyenkor a gép úgy változtatja meg a kifejezés értékét, hogy a kifejezéssel végrehajtja az adott műveletet. Például ha az előbbi kis programunkat az alábbiak szerint módosítanánk, akkor az indításkor bármi is legyen az A1 cellában, annak értéke eggyel nőni fog: Sub test() Range("A1") = Range("A1") + 1 End Sub

Természetesen a +1 helyett bármi más is állhat, ha *2 lenne, akkor megduplázná, stb.


Az értékadás során a cellába függvényt is írhatunk, de ez esetben a makrókban az angol változat függvényeit kell használnunk. A táblázatba ettől függetlenül a magyar változatnak megfelelő függvény kerül. Például a Selection.Offset(1, 0) = "=RAND()"

utasítás az aktuális cella alatti cellába egy véletlenszámot ír. Ha viszont megnézzük a cellát ott nem az =RAND(), hanem az =VÉL() függvény lesz található.

Fontos eltérés, hogy a makrókban a nem egész számok esetén a tizedeseket ponttal kell elválasztani, a vessző ugyanis a paraméterek elválasztására szolgál a pontosvessző helyett. Ha tehát az aktuális cellába másfelet szeretnénk írni, úgy az ActiveCell = 1.5

utasítást kell használni.

5.3. Változók

Azokat az adatokat, amelyekre a program futása során szükség van ún. változókban tároljuk. Minden változónak van egy neve és egy értéke. (Más programnyelvekben típusa is, amely meghatározza, hogy milyen jellegű adat tárolható a változóban. Itt a típust többnyire nem szükséges definiálni, azt az első értékadás határozza meg.) Azt, hogy milyen változókat szeretnénk használni a program elején lehet megadni egy DIM utasítást követően az alábbi módon: DIM valtozonev

A változókkal a későbbiekben számos műveletet végezhetünk, felvetethetjük velük egy cella értékét, számolhatunk velük, beírhatjuk az értékét egy cellába, stb. Ha a későbbiekben ezt a hivatkozást írjuk a programba, úgy a helyett a változó aktuális értékét kell beleképzelnünk. Ha azonban a változó nevét, vagy bármilyen más szöveget idézőjelek közé teszünk, úgy maga szöveg lesz az érték. A változónév azonban nem lehet tetszőleges kifejezés, kerülendők például a Visual Basic utasításai és az írásjelek is.

A változók értékét nagyon egyszerű megadni, egyszerűen csak a változónév után kell írni egy egyenlőségjelet majd a felveendő értéket. Pl.: X = 6


Ha a változónak szöveges értéket szeretnénk adni, úgy a szöveget idézőjelek közé kell tenni. Pl.: Y = ”Ez a szöveg lesz a változó értéke”

A változó csak a makró futásának idejéig tárolja az adatot, ha a makrót újraindítjuk a változók értékei törlődnek. (Jelen könyvben nem térünk ki a lokális és globális változókra, arra az Excel makróprogramozása során nem lesz szükség. Elég annyit tudni, hogy a változók érvényességi körét is lehet szabályozni.)

A változóknak léteznek speciális formái is, ilyenek például a tömbök, melyektől később ejtünk szót.

5.4. Egyszerűbb számítások

A változókkal végezhetünk egyszerűbb számításokat is, így a numerikus változókkal a hagyományos matematikai alapműveletek (összeadás: +, kivonás:-, szorzás:*, osztás:/, hatványozás:^) végez-hetők el, szöveges változókkal pedig összefűzést végezhetünk.

Ha bonyolultabb függvényeket szeretnénk használni, úgy arra a makrók csak elég körülményesen alkalmasak, ez esetben a legegyszerűbb a táblázatban olyan cellákat elhelyezni, amelyek elvégzik a kívánt műveletet. Ezeket a cellákat persze elrejthetjük a kíváncsi tekintetek elől, hogy azok ne zavarjanak.

Nagyon fontos, hogy csak a változó típusának megfelelő művelet végezhető el, tehát ha numerikus a változónk, akkor matematikai műveleteket végezhetünk rajta, ha pedig szöveges, úgy szöveg-műveletet. Ha netán szöveges változón kívánunk matematikai műveletet végrehajtani, úgy a makró hibajelzéssel leáll.

Ha egy változóval műveletet szeretnénk végezni, úgy a sort azzal a változóval kell kezdeni, ami szeretnénk, ha felvenné a kívánt értéket, majd az egyenlőségjel után megadjuk, hogy mi legyen az adott változó. Pl.: Y = X*2+6

A zárójelezések természetesen ugyanúgy használhatók, mint másutt. Pl.: Y = (X+1)^2

Gyakori igény, hogy a számítás eredménye ne egy új változóba kerüljön, hanem a változó saját maga módosuljon. Ilyenkor az egyenlőség előtt és után is ugyanaz a változó áll. Például ha azt szeretnénk, hogy az A változó értéke eggyel nagyobb legyen, úgy használhatjuk az alábbi formulát:


A = A+1

Szöveges változók esetén a szövegek összefűzésére van lehetőség, melyre a + vagy a & műveleti jelek használhatók. A kettő közt az a különbség, hogy ha a cellában nem szöveg, hanem szám szerepel úgy a + jel összeadja a számokat, az & jel viszont egymás után írja. Például a Z = X & Y

formula a Z változóba az X és az Y változóban lévő szövegek egymás után írt sorát adja. A két szöveg közé ezáltal nem kerül szóköz, tehát ha a két szót nem akarjuk egybeírni, úgy a Z = X & ” ” & Y

formulát kell használnunk. Nézzünk meg egy példát. Készítsünk el egy egyszerű makrót, ami

három változót használ, az A felveszi az A1 cella értékét, a B az A2-t, a C pedig e kettő összefűzése lesz, ami a makró lefutásakor bekerül az A3 cellába. Sub Makro1() Dim a Dim b Dim c a = Range("a1") b = Range("a2") c = a & b Range("a3") = c End Sub

A makrónak készítsünk egy nyomógombot is, hogy könnyebben tudjuk futtatni. (ld. 2.1.7.)

Nézzük meg, hogy mi történik, ha az A1 cellába 1-et, az A2-be pedig 2-t írunk, majd rákattintunk a nyomógombunkra. Ha jól csináltuk, úgy az A3 cellába bekerül a 12-es szám.

Most írjuk át az A1-es cellát a Az eredmény: szövegre (a kettőspont után tegyünk még egy szóközt is) és kattintsunk ismét a gombon. Logikusan az A3-ba a Az eredmény: 2 szöveg került.

Csináljunk egy egyszerű játékot az előzőekből. Írjuk az A2 cellába az =KEREKÍTÉS(VÉL()*6+0,5;0) függvényt, az A1-es cellába pedig az A kockadobás eredménye: szöveget.

Ezután már nincs más dolgunk, mint sűrűn kattintgatni a makróhoz rendelt nyomógombunkra. Ugye mindenki kitalálja, hogy mi történik?


5.5. Függvények Bár magukban a táblázatokban jóval több, azért a makró-

programokban is használhatók függvények. Ezek a függvények az Excel angol függvényeinek nevéből adódnak. Ha számokat tartal-maznak, úgy a tizedesjegyek elválasztása ponttal történik, ha pedig több paramétert igényelnek, úgy a paraméterek elválasztására a vessző szolgál.

A függvények paraméterei változók, vagy további függvények lehetnek, illetve használhatjuk a cellaazonosításokat is.

Nézzünk egy példát egy egyszerű négyzetgyökszámításra, az sqr függvény felhasználásával. Készítsünk egy gombot, amelyhez az alábbi makrót rendeljük: Sub Makro1() Range("A2") = ("Négyzetgyöke: " & Sqr(Range("A1"))) End Sub

Ha beírunk egy számot az A1 cellába, majd kattintunk a gombra, úgy az A2 cellába megjelenik a négyzetgyöke. Ha viszont az A1 cellába szöveget írunk, úgy a makró hibajelzéssel leáll, mivel a függvény mindenképpen számot fogad csak el bemeneti paraméterként.

Ugyanígy természetesen más függvényeket is használhatunk, például a log(kifejezés) függvényt logaritmusszámításra, a sin(kifejezés) függvényt színuszszámításra, now() függvényt a mostani időpont meghatározására, stb.

Természetesen lehetnek olyan függvények is, amelyeknek több paraméter is lehet. Ilyen például a kerekítésre szolgáló round függvény, vagy a szövegfüggvények, stb. Nézzünk példákat. A Range("A2") = Round(Range("A1"), 0)

utasítás az A2 cellába beírja az A1 cella egészre kerekített értékét, a Range("B2") = Left(Range("B1"), 10)

utasítás pedig a B1 cellában lévő szöveg első tíz karakterét írja az A2 cellába.


Bár a Visual Basic számos Excel függvényt nem támogat közvetlen módon, azért van megoldás arra, hogy az Excel függvényeit a makró-programokban is használjuk. E célra a Worksheetfunction.függ-vénynév metódus szolgál.

Például a SZUM függvény angol változata önállóan nem használható, viszont ezzel a kis kiegészítéssel már igen. Például a Range("A11") = WorksheetFunction.Sum(Range("A1:A10"))

utasítás az A11-es cellába írja be az A1 és A10 cellák által határolt területen lévő számok összegét.

Most pedig nézzük, meg az egyik leggyakrabban használt kereső-függvény használatát a makróprogramozásban. Köztudott, hogy az FKERES függvény igen hasznos tud lenni adatbázis jellegű táblázatokban, nyilvántartásokban, mivel képes arra, hogy egy megadott adatot kikeresve egy táblázatból, az adott adathoz tartozó, de másik oszlopban lévő értékkel térjen vissza. Ha tehát az A2 cellába azt az értéket szeretnénk írni, ami a B1:B10 terület azon cellája mellett van a C oszlopban, ami megegyezik az A1 cellával, úgy Excelben az =FKERES(A1;B1:C10;2) függvényt kell használnunk. Mindezt a makróprogramunkban is megtehetjük, csak itt nem az fkeres függvényt, hanem a WorksheetFunction.VLookup utasítást kell hasz-nálnunk. A paraméterezés azonos, a program tehát logikusan a következő: Sub kereses() Range("a2") = WorksheetFunction.VLookup(Range("A1"), Range("B1:C10"), 2) End Sub

Persze önmagában így a programnak nincs értelme, hiszen az Excel függvény ez esetben egyszerűbb, viszont olyan esetekben, amikor mindez egy összetett folyamat része, nagyon hasznos tud lenni, hiszen nem kell az Excel táblázatba a szükséges függvényeket beleírni.


5.6. Üzenőablakok

Praktikus lehetőség az Excel makróprogramozásában, ha a program során megjelenítendő üzeneteinket külön kis ablakban jelenítjük meg. Különösen hasznos ez figyelmeztetésekkor, például ha jelezni kívánjuk, hogy nincs kitöltve minden szükséges adat, azok esetleg rosszak, vagy hogy a folyamat után még ne felejtsen el a felhasználó valami mást is megcsinálni.

Üzenetablak megjelenítéséhez az MsgBox (üzenet)

utasítás használható. Az üzenet lehet változó, szám, vagy szöveg is, így ha szöveget szeretnénk megjeleníteni, úgy azt idézőjelek közé kell tenni. Ha ezt elfelejtenénk, úgy több szó esetén hibajelzést kapunk, egy szó esetén pedig változónak értelmezi a makró a szót, így üres lesz az ablakunk. Például: MsgBox ("Ne felejtsd el a többit sem!")

Ha összefűzött szöveget kívánunk megjelentetni, az sem ördöngösség: MsgBox ("Az eredmény: " & x)

A hagyományos üzenőablakon túl azonban számos egyéb ablakfajtát használhatunk. Ekkor azonban mivel több gomb közül is választhatunk nagy valószínűség szerint tud-nunk kell, hogy melyik gombot nyomta meg a felhasználó, ezért az eredményt egy változónak kell felvenni. Ilyen esetben a változó = MsgBox("üzenet", paneltípus)

sor használható. (A visszadott érték nem logikus, pl. 6 vagy 7, tehát azt nem árt előre tesztelni.) Például: eredmeny = MsgBox("Most mi legyen?", vbAbortRetryIgnore)

A panel típusa igen sok féle lehet, melyet az alábbi táblázatban foglalunk össze:

vbOKOnly Csak OK gombvbOKCancel OK és Mégsem gombokvbAbortRetryIgnore Leállítás, Ismét és Kihagyás gombok vbYesNoCancel Igen, Nem és Mégsem gombok vbYesNo Igen és Nem gombok


vbRetryCancel Ismét és Mégsem gombokvbCritical OK gomb hibajelzéssel és hanggal * vbQuestion OK gomb kérdőjel jelzésselvbExclamation OK gomb felkiáltójellel és hanggal * vbInformation OK gomb i jellel és hanggal *vbSystemModal OK gomb rendszerikonnal*vbMsgBoxHelpButton OK és Súgó gombok*vbMsgBoxRight OK gomb jobbra igazított címszöveggel* vbMsgBoxRtlReading OK gomb fordított fejsorral*stb.

* képek az alábbiak szerint:

vbCritical vbExclamation vbInformation

vbSystemModal vbMsgBoxHelpButton vbMsgBoxRtlReading

További igen egyszerű lehetőség a beviteli ablak, amit egy egyszerű változó = InputBox("Szöveg", "Cimke") formájú értékadással tudunk megvalósítani. Például: eredmeny = InputBox("Hogy hívnak?", "Névbekérés")

A begépelt szöveg értelemszerűen a váltózóba kerül. (Jelen példában az eredmeny változó veszi fel a Gipsz Jakab értéket.)


5.7. Feltételvizsgálatok

A makróprogramozás egyik legfontosabb lehetősége, hogy az adataink értékétől függően eltérő utasítások hajthatók végre. A feltételvizsgálatok során kielemzünk pl. egy változót (amit vehetünk a táblázat egyik cellájából), majd attól függően, hogy annak mi az értéke, más és más utasításokat futtatunk le. A feltételvizsgálatot emiatt szokás elágazásoknak is nevezni a programban.

A feltételvizsgálat tehát minimum két részből kell hogy álljon, hiszen egyrészt van a kielemezendő rész (pl. a változónk egy fel-tétellel), másrészt pedig vannak a vizsgálat eredményétől függően végrehajtandó utasítások.

A leggyakoribb eset az, amikor a feltételvizsgálat eredményétől függően vagy végrehajtunk valamilyen utasítássorozatot, vagy nem. Másik lehetőség, hogy a feltétel igaz vagy hamis voltától függően hajtunk végre különféle utasítássorozatokat. A harmadik és egyben legritkább eset, amikor többféle eredménye is lehet a feltétel-vizsgálatnak és így mindegyik eredményre vonatkozólag más-más utasítássorozatot határozunk meg. Nézzük most meg ezeket a lehető-ségeket a gyakorlatban.

Az egyszerű feltételvizsgálat formailag a következő módon néz ki: IF feltétel THEN utasítás

Azaz ha a feltétel teljesül, akkor végrehajtódik az utasítás. Például az IF X = 0 THEN Y = Y + 1

utasítás használata során ha X éréke nulla, akkor Y értéke egyel nő. Praktikus módszer ez a nullával való osztás megakadályozására,

hiszen ha az IF Y <> 0 THEN Z = X / Y

utasítást használjuk, úgy az osztás csakis akkor hajtódik végre, ha az osztó nem nulla, különben nem történik semmi.

A fenti szerkezet hátránya azonban, hogy a Then után csupán egyetlen utasítás állhat. Ha több utasítást szeretnénk a feltételtől függően végrehajtani úgy arra is van lehetőség csak ez esetben ki kell egészítenünk a formulát a következő módon: IF feltétel THEN utasítás1 utasítás2 utasításn END IF


Tehát a végrehajtandó utasításokat a then utáni sorokba írjuk egészen az END IF utasításig. Az END IF után álló utasítások viszont már mindenképpen végrehajtódnak, függetlenül a feltételtől. Nézzünk erre is egy példát: IF Y <> 0 THEN Z = X / Y MsgBox ("Az osztás végrehajtható volt”) END IF

Tehát ha Y nulla, akkor nem történik semmi, viszont ha attól eltérő szám, úgy kiszámításra kerül a Z változó értéke és megjelenik egy üzenetablak is.

Ezzel lényegében meg is ismertük a feltételvizsgálat legegy-szerűbb módját. Ha viszont a feltétel nem teljesülése esetén valami másnak kell történnie, úgy a fenti módszer már kissé bonyolult lenne. Persze megoldható két egymás utáni feltételvizsgálattal ellentétes feltételt meghatározva, például IF Y <> 0 THEN Z = X / Y IF Y = 0 THEN Z = 0

Ez a módszer bonyolult feltétel, esetén nem igazán szerencsés, ráadásul nagyobb az esélye a hibázásnak is. Ilyen esetben kell bevezetni a „különben” ágat a következő módon: IF feltétel THEN a feltétel teljesülése esetén végrehajtódó utasítás(ok) ELSE a feltétel nem teljesülése esetén végrehajtódó utasítás(ok) END IF

A fenti példa tehát kicsit kibővítve és megfordítva tehát valahogy így nézne ki: IF Y = 0 THEN Z = 0 MsgBox ("Az osztás nem volt végrehajtható”) ELSE Z = X / Y MsgBox ("Az osztás végrehajtható volt”) END IF

Ha tehát az Y változó értéke nulla, úgy a Z változó is felveszi a nulla értéket, majd megjeleníti az üzenetablakban „Az osztás nem volt végrehajtható” szöveget, különben pedig a Z változó értéke felveszi az X és Y változó hányadosát és „Az osztás végrehajtható volt” szöveget jeleníti meg a makró.


A harmadik, bár viszonylag ritkán használt lehetőség, amikor egy változó adott értékeitől függően kell különféle utasításokat végrehajtani. Mivel itt nem feltételvizsgálat történik, ezért nem az IF hanem a SELECT utasítást kell használnunk.

A száraz ismertetés helyett a legjobb, ha rögtön megnézünk egy példát, ami az X változó értéknek megfelelő szöveget írja ki üzenetablakban: Select Case X Case 1 MsgBox ("Egy") Case 2

MsgBox ("Kettő")Case 3 MsgBox ("Három") Case 4 MsgBox ("Négy") Case Else MsgBox ("Más") End Select

Természetesen itt is lehet egy-egy ágban több utasítást is elhelyezni. A Case Else ág tartalmazza azokat az utasításokat, amelyek akkor hajtódnak végre, ha egyik Case ágnak sem volt lehetősége lefutni.

A feltételvizsgálatok egymásba is ágyazhatók, ha tehát egy IF utasításban újabb IF utasítást helyezünk el, úgy annak utasításai csak akkor hajtódnak végre, ha mindkét feltétel teljesül: IF feltétel1 THEN

a feltétel1 teljesülése esetén, de a feltétel2- től függetlenül végrehajtódó utasítás(ok) IF feltétel2 THEN

mindkét feltétel teljesülése esetén végrehajtódó utasítás(ok)

ELSE a feltétel1 teljesülése, de a feltétel2 nem teljesülése esetén végrehajtódó utasítás(ok)

END IF ELSE a feltétel1 nem teljesülése esetén, de a feltétel2-től függetlenül végrehajtódó utasítás(ok) END IF


5.8. Ciklusok

Gyakran előfordul, hogy adott utasítássorozatot egymás után többször is végre kall hajtani. A ciklusok segítségével megvaló-síthatók olyan szerkezetek, amelyekben az utasítások mindaddig végrehajtódnak, ameddig egy feltétel teljesül. Természetesen a feltétel nem teljesülése esetén a program kilép a ciklusból és a ciklust követő utasításon folytatja végrehajtást.

A különféle programozási rendszerek többféle ciklusszervezést is támogatnak, így megkülönböztethetünk előltesztelő, hátultesztelő és növekményes ciklust.

Elöltesztelős ciklus esetében a gép a feltételt még a ciklus végrehajtása előtt kiértékeli, így annak nem teljesülése esetén a ciklus egyszer sem hajtódik végre. A hátultesztelős ciklusok egyszer mindenképp lefuttatják a ciklusmagot alkotó utasításokat, majd ez után történik a kiértékelés, illetve annak eldöntése, hogy a ciklus ismételten lefuttatható-e. (Ezt a módszer pontosan e miatt többnyire nem is alkalmazzák.)

A növekményes ciklusok egy változó értékét növelik egy adott értékről egy másik adott értékig meghatározott lépésközzel. A ciklus tehát addig hajtódik végre, amíg a ciklusváltozó el nem éri a célértéket.

Leggyakrabban a növekményes ciklust használjuk, így ennek a megvalósítása is a legegyszerűbb: For ciklusvaltozo = ettől To eddig ismételendő utasítások Next

A ciklusban tehát a ciklusváltozó értéke a legelső alkalommal felveszi a kezdőértéket majd lefutnak a ciklusmag utasításai. Ezt követően a kezdőértéknél eggyel nagyobb értéket vesz fel, és ismét lefutnak a ciklusmag utasításai. Mindez addig ismétlődik, amíg a ciklusváltozó el nem éri a másodikként megadott értéket.

Ha a kezdő- és záróérték megegyezik, úgy a ciklus csak egyszer fut le. Ha a záróérték kisebb a kezdőértéknél, úgy a ciklus nem fut le egyszer sem.

A ciklus kezdő és záróértéke megadható változóban is, illetve a ciklusmagban is használhatunk olyan utasításokat, amik a táblázat adott cellájától, valamely változótól, vagy akár magától a


ciklusváltozótól függenek. Ezt kihasználva a ciklusmag minden egyes lefutásakor mást és mást eredményezhet.

Nézzünk egy példát. Töltsük fel a táblázatunk A oszlopának első húsz sorát annak sorszámával: Sub Makró1() For ciklusvaltozo = 1 To 20 Range("a" & ciklusvaltozo) = ciklusvaltozo Next End Sub

A program elszámol egytől húszig, majd minden egyes lefutásakor az A oszlop ciklusváltozó értékének megfelelő sorába beírja magát a ciklusváltozót. Ugye nem is olyan bonyolult?

Ennél kicsit összetettebb az elöltesztelős ciklus. Ez a módszer viszont sokkal több lehetőséget kínál, mivel a ciklusváltozó értékét tetszőleges módon szabályozhatjuk, sőt a ciklusból való kilépést akár külső feltételhez is köthetjük. Fontos azonban, hogy úgy írjuk meg a programot, hogy az még véletlenül se kerüljön végtelen ciklusba, tehát legyen esély arra, hogy a ciklusfeltétel valamikor ne teljesüljön. A megvalósítás módja a következő: Do While ciklusfeltétel ismételendő utasítások Loop

Fontos tehát, hogy a ciklusmagban ismétlő utasításokban legyen olyan utasítás, ami befolyásolja a ciklusfeltételt, mégpedig oly módon, hogy az előbb utóbb felvehessen olyan értéket is, ami esetén a ciklusfeltétel már nem teljesül.

Nézzük tehát meg az előző példát – ami feltölti a táblázatunk A oszlopának első húsz sorát annak sorszámával – ezen ciklus alkalmazásával: Sub Makró1() Do While szamlalo < 20 szamlalo = szamlalo + 1 Range("a" & szamlalo) = szamlalo Loop End Sub

A példán jól látható, hogy feltételnek azt határoztuk meg, hogy a számláló kisebb legyen húsznál. Ez egy darabig teljesül is, de mivel a ciklusmagban van egy utasítás, ami minden egyes alkalommal eggyel megnöveli a számláló értékét, a huszadik lefutás után már nem fog teljesülni, így a program kilép a ciklusból.


Ezen módszer másik variációja, amikor nem azt mondjuk meg, hogy mikor hajtódhat végre a ciklus, hanem azt, hogy meddig. A formula majdnem ugyanaz, csupán a While helyett Untilt kell írnunk, illetve a feltételt kell ellentétesre állítanunk: Sub Makró1() Do Until szamlalo >= 20 szamlalo = szamlalo + 1 Range("a" & szamlalo) = szamlalo Loop End Sub

Az utasítássorozat tehát a mindaddig végrehajtja a ciklusmagot alkotó utasításokat, amíg a feltétel nem teljesül. Fontos tehát, hogy a ciklus belsejébe mindenképp helyezzünk olyan utasítást, amely kihatással van a feltételre, ellenkező esetben ugyanis végtelen ciklust kaphatunk.

5.9. Tömbök

Az Excel lényege, hogy az adatokat táblázatokban tároljuk, ezáltal lehetőségünk van több, összetartozó adat tárolására is. A makrókban használt változók azonban csupán egyetlen értéket képesek tárolni, így olyan esetekben, amikor sok adatot kell ideiglenesen feldolgozni, sok változóra volna szükségünk. Ennek azonban azon túl, hogy körülményes lenne a használatuk, számos hátránya is lenne, például az, hogy a velük való munkát nem lehetne automatizálni, ami a lényege a programozásnak. Olyan esetekben pedig, ahol előre nem meghatározható számú, vagy túl sok adatot kell eltárolni, ott a hagyományos változókkal való adatfeldolgozás pedig nem is kivitelezhető.

Ha nagymennyiségű adatot szeretnék változókban tárolni, úgy az úgynevezett tömböket kell használni.

Tömbökből többféle is létezik, attól függően, hogy egy adatsort, vagy adattáblát kell-e bennük tárolni. Ha adatsort kívánunk feldolgozni, úgy egydimenziós tömbről beszélünk, melynek csak egy indexe van, amely megadja, hogy hányadik adat kell a sorozatból. Ha táblázatszerű adathalmazt dolgozunk fel, úgy kétdimenziós tömböt használunk, amely két indexszel rendelkezik. Ezek ugyanúgy, mint az Excel táblázataiban, meghatározzák, hogy az adott tömb hányadik „oszlopának” hányadik „sorában” lévő adatra van szükségünk. Persze itt nincsenek sorok és oszlopok, mindegyik dimenzió esetén egy sorszámmal történik a hivatkozás a tömb adott elemére.


A tömbök használata során a tömb adott számú elemére a változónév után zárójelbe beírt indexszel tudunk hivatkozni. Például: ActiveCell = tomb(index)

Ha a tömb többdimenziós, úgy több index is szerepel a zárójelben, melyeket vesszővel választunk el egymástól. Például: ActiveCell = tomb(index1, index2)

Tömböt létrehozni többféle módon is tudunk. Az egyik megoldás, amikor az értékadásnál a változónév után zárójelben megadjuk, hogy a tömbök indexei mettől meddig tartsanak. Például: Dim tomb(1 To 10)

vagy Dim ertek(0 To 25, 1 To 20)

A másik lehetőség az értékadás során kínálkozik. Ha a változónak úgy adunk értéket, hogy jelezzük, hogy az tömb és annak minden egyes elemét is felsoroljuk, akkor a tömb tartalma a felsorolt elemekkel töltődik fel. Ez esetben az index 0-tól kezdődik és n–1-ig tart. Például: tomb = Array("hétfő", "kedd", "szerda","csütörtök", "péntek", "szombat", "vasárnap")

Ez esetben az ActiveCell = tomb(0)

utasítás a hétfő értéket, az ActiveCell = tomb(6)

utasítás pedig a vasárnap értéket írja az aktuális cellába.

A tömbök használata az esetek túlnyomó részében a ciklusokkal együtt történik, mivel így lehetőségünk van végigmenni a tömb minden elemén.

Az alábbi példa a táblázat A1:E5 területén lévő adatoknak a dupláját írja be az A11:E15 területre:

Sub masol() Dim ertek(0 To 4, 1 To 5) oszlop = Array("a", "b", "c", "d", "e") For ciklusa = 0 To 4

For ciklusb = 1 To 5 cella = oszlop(ciklusa) & ciklusb ertek(ciklusa, ciklusb) = Range(cella)

Next ciklusb Next ciklusa


For ciklusa = 0 To 4 For ciklusb = 1 To 5

sor = ciklusb + 10 cella = oszlop(ciklusa) & sor Range(cella) = ertek(ciklusa, ciklusb) * 2

Next ciklusb Next ciklusa End Sub

A feladat persze más módon, így tömbök nélkül is megoldható lenne, de most a tömbök használatát kívánjuk szemléltetni azáltal, hogy a program első felében a területet beolvassuk egy tömbbe, majd a második részben az új helyre kiírjuk az adatok dupláját. A példa jól szemlélteti a tömbök használatának többféle alkalmazását, hiszen az oszlopazonosításokhoz egy egydimenziós tömböt használtunk, a területen lévő adatok tárolására pedig egy kétdimenziós tömb szolgált. Mindkét esetben két egymásba ágyazott ciklust használtunk, ami végigment a területen és beolvasta a tömbbe a táblázat adatait, illetve kiírta a tömbből a táblázatba az adatok dupláját. A cellaazonosítás legenerálásához szintén tömböt használtunk, ahol a tömb elemei tartalmazták az oszlopazonosítók betűit.

A példa kis módosítással minden olyan esetben hasznos lehet, ahol számolt értéket tartalmazó cellákból kell konkrét adatot tartalmazó cellatartományt előállítani.

Gyakori probléma, hogy át szeretnénk másolni egy területen lévő számolt adatokat úgy, hogy a célhelyen már ne képletek, hanem számok legyenek. Ha csak simán a vágólapos másolást használnánk, úgy az új helyen is képletek lennének, ráadásul hibás adatokkal az eltolás miatt. Egy ilyen kis makróval azonban mindez kivitelezhető, hiszen a táblázatból való beolvasáskor a változóba nem a képlet, hanem az érték kerül, így amikor azt visszaírjuk a táblázatba, az új helyen már csak a szám fog szerepelni.

5.10. Alprogramok

Ha programunknak vannak olyan részletei, amelyek azonos módon több helyen is ismétlődnek, akkor azokat ne írjuk meg feleslegesen többször, hiszen elegendő ha csak egyszer készítjük el, és ahol szükséges alprogramként meghívjuk.

Az alprogramokat ugyanúgy készítjük el, mint bármely más makrót, csupán ezekre nem történik hivatkozás gombokról. A programkódba bárhová illeszthetjük, kezdeni a


Sub alprogramnév()

zárni az End sub

utasítással lehet. Az alprogramot meghívni nagyon egyszerű, csupán a nevét kell beírni a szükséges helyre. Az alprogram neve bármilyen olyan általunk kitalált szó lehet, ami nem meglévő utasítás, függvény vagy változónév.

Nézzük meg, hogyan épülhet fel tehát az alprogramokat használó makró a gyakorlatban:

Sub kattintas() If ActiveCell > 0 then

elso masodik elso

End if End Sub Sub elso() Az elso alprogramot alkotó utasítások End Sub Sub masodik() A második alprogramot alkotó utasítások End Sub

A fenti példában a gomb a kattintas makrót hívja meg, amely makró ha az aktuális cellában nullánál nagyobb értéket talál, akkor először az elso alprogramot alkotó utasításokat, majd a második alprogramot alkotó utasításokat, végül ismét az elso alprogramot alkotó utasításokat hajtja végre. Ha az aktuális cellában nulla, vagy annál kisebb érték szerepel, úgy nem történik semmi. (Nem árt azonban tudni, hogy a lokális változók csak az adott alprogramban használhatók, másutt nem lesz értéke.)

5.11. Makróból elérhető Excel funkciók

Lényegében bármely Excel funkciót elérhetjük a makrókból is, így azokat is, melyeket jelen könyvben nem részleteztünk ki. Ha rögzítjük a tevékenységet, könnyedén megtekinthetjük a funkciónak megfelelő utasítást. Bár ez a módszer nem mindig a legegyszerűbb formát rögzíti, kiindulási alapnak tökéletes. Az azonban kétségtelen, hogy ha magunk gépeljük be az utasításokat, valószínűleg a logikusabb, egyszerűbb formátumokat fogjuk használni, ellentétben a gép általi makrórögzítéssel.


Számos funkció párbeszédpaneleket nyit meg, amelyeken megadott paraméterek nem kerülnek be rögzítéskor a makróba. Ha ezeket az adatokat is használni kívánjuk (például lapvédelemnél a jelszavak, stb.), úgy mindenképpen a kézi programozást kell választanunk. A párbeszédpaneleket meghívó funkciók ugyanis az utasítások paraméterezésével oldható meg.

Fontos továbbá megjegyezni azt is, hogy bár lehetőségünk van az Excel táblázatba makróból is függvényeket írni, a makróban mindig az angol függvénynevet kell szerepeltetni. A makró lefutását követően ezek a táblázatban már a magyar nevükkel fognak szerepelni.

5.11.1. Munkalap váltása

A lapváltás makróban nagyon egyszerű, csupán a Sheets("Munkalapnév").Select

utasítást kell használnunk.

5.11.2. Formázások

Ha makróból szeretnénk megformázni egy cellát, úgy kivételesen a legjobb módszer, ha makrórögzítéssel rögzítjük a formázást, majd ezt a kódot illesztjük a programunkba. Ennek oka ugyanis a számos paraméterben és színkódban keresendő, amit nem biztos, hogy fejből tudunk, vagy könyvből kinézünk, így sokkal gyorsabb, ha rögzítjük a formázást. Természetesen ettől függetlenül e könyvben is bemutatjuk a lehetőségeket.

Az egyik lehetőség, hogy a formázási utasítás kiadása előtt a Range("cellaazonosító").Select

utasítással ki kell jelölnünk a formázandó cellát, vagy cellaterületet, majd a Selection.Font

és a Selection.Interior

utasítások különféle változataival formázhatjuk a kijelölést.


A Selection.Font utasítás az alábbi kiegészítésekkel használható:

.Name = "Betűtípusnév"

.Size = betűméret

.Bold = True/False

.Italic = True/False

.Strikethrough = True/False

.Superscript = True/False

.Subscript = True/False

.OutlineFont = True/False

.Shadow = True/False

.Underline = aláhúzástípus stb.

Ha például egy kijelölés betűméretét 12 pontosra kívánjuk módosítani, úgy a Selection.Font.Size = 12

utasítást kell használnunk. Ugyanígy a vastag betűs megjelenítéshez a Selection.Font.Bold = True

utasítás használható. Ha több formázást szeretnénk egyszerre alkalmazni, úgy a With

Selection.Font és End With utasításpárok közé kell írni a formázó tagokat. Például: With Selection.Font .Bold = True .Name = "Tahoma" .Size = 11 .Strikethrough = False End With

Természetesen a formázást nem csupán egy korábban kijelölt cellára vagy területre, hanem az utasításban megadott konkrét cellára is vonatkoztathatjuk, ekkor a Selection tag helyett a Range("cellaazonosító") tagot kell írnunk. Ha például a B2-es cellát szeretnénk vastag betűsre állítani, úgy a Range("B2").Font.Bold = True

utasítást kell használnunk, míg az A2:A10 terület dőlt betűssé teteléhez a Range("A2:A10").Font.Italic = True

utasítást adhatjuk ki.


A színek használata során meg kell különböztetni a betűszínt és a háttérszínt. A betűszín állítására a Range("cellaazonosító").Font.Color = színkód

utasítás, a háttérszín módosításához pedig a Range("cellaazonosító").Interior.Color = színkód

utasítás szolgál. Ennek megfelelően például a Range("B4").Font.Color = 12611584 Range("B5").Interior.Color = 11000000

utasítások a B4 cellában lévő szöveg színét kékre, a B5 cella hátterét világoszöldre állítják.

A cellában lévő szöveg igazításánál külön lehet megadni a függőleges és vízszintes igazításokat.

A vízszintes igazítás beállítása a Range("cellaazonosító").HorizontalAlignment = igazítástípus

utasítással, a függőleges igazítás pedig a Range("cellaazonosító").VerticalAlignment = igazítástípus

utasítással határozható meg az alábbiaknak megfelelően:

.HorizontalAlignment = xlLeft vízszintes igazítás balra

.HorizontalAlignment = xlCenter vízszintes igazítás középre

.HorizontalAlignment = xlRight vízszintes igazítás jobbra

.HorizontalAlignment = xlGeneral vízszintes igazítás általánosan

.VerticalAlignment = xlTop függőleges igazítás felülre

.VerticalAlignment = xlCenter függőleges igazítás középre

.VerticalAlignment = xlBottom függőleges igazítás alulra

A két igazítás természetesen össze is vonható a szokásos With taggal. Például a Range("B5").Select With Selection .HorizontalAlignment = xlLeft .VerticalAlignment = xlBottom End With

utasítások vízszintesen balra, függőlegesen pedig alulra igazítja a B5 cella tartalmát.

A számformátum beállítása a Range("cellaazonosító").NumberFormat = "formátumkód"


utasítással történik. Ha például az E6-os cellát két tizedesjegyet tartalmazó számként kívánjuk használni, úgy a Range("E6").NumberFormat = "0.00"

utasítást kell kiadnunk. A kijelölés, majd a kijelölt terület formátumának megadása ez esetben is jó megoldás. Ennek megfelelően tehát a B2:C4 tartomány szövegként való beállítása a Range("B2:C4").Select Selection.NumberFormat = "@"

utasításokkal is megvalósítható. Ugyanígy az A1-es cella tizedesek nélküli pénznemként való használata a Range("A1").NumberFormat = "_-* # ##0 $_-;-* # ##0 $_-;_-* ""-""?? $_-;_-@_-"

utasítással állítható be. Ez esetben azonban fontos, hogy a formátumkódban ne a Ft, hanem a $ szimbólumot használjuk, különben hibajelzést kapunk. A táblázatban természetesen a Ft fog megjelenni, hacsak nem állítottuk át a rendszer nyelvét.

Az idézőjelek közé a formátumnak azt a kódot kell írni, amit az Excelben is írnánk az egyéni formátum meghatározásakor a formátumkód mezőbe. A formátumkód maximum négy szakaszból állhat, a szakaszokat pontosvesszővel választhatjuk el egymástól. Az első szakasz a pozitív számok, a második a negatív számok, a harmadik a nulla értékek, a negyedik pedig a szövegek formátumát adja meg. Természetesen megadhatunk kevesebb szakaszt is. Például ha csak egy szakaszt adunk meg, valamennyi szám ezt a formátumot veszi fel. Ha ki akarunk hagyni egy szakaszt, úgy helyére csak a pontosvesszőt kell írnunk. A formátumkódba különböző kódkaraktereket kell írnunk. A # csak az értékes jegyeket jeleníti meg, a fölösleges nullákat nem. A 0 (nulla) nullákkal egészíti ki a számot, ha az kevesebb számjegyet tartalmaz, mint ahány 0 szerepel a formátumban. A $ az aktuális pénznemet jeleníti meg. A ? a tizedesvessző mindkét oldalán az értéktelen nullák helyén szóközt jelenít meg. Ha a cellában számok mellett szöveget is meg szeretnénk jeleníteni, úgy a szöveget foglaljuk idézőjelek közé, vagy helyezzünk a karakter elé fordított ferde vonalat (\). Ezres elválasztáshoz használjunk szóközt a #-ek közt (Pl. # ###)

Természetesen a fentieken túl számos további formázást is végezhetünk, melyek utasításait makrórögzítéssel könnyedén megtalálhatjuk, így ezekre már nem térünk ki.


5.11.3. Sor és oszlopátméretezések

Ha meg kívánjuk változtatni a sormagasságokat vagy oszlop-szélességeket, úgy azokat nagyon egyszerűen megtehetjük a Columns("oszlopazonosítás").ColumnWidth = méret

illetve a Rows("sorazonosítás").RowHeight = méret

utasítások segítségével. Ha tehát például az A, B és C oszlopok szélességét 14 egységre, a 3. sor magasságát pedig 15 egységre kívánjuk módosítani, úgy az alábbi utasításokat kell begépelnünk a programkódba: Columns("A:C").ColumnWidth = 14 Rows("3:3").RowHeight = 15

5.11.4. Lapvédelem

Makróprogramozásnál fontos feladat, hogy a felhasználók illetéktelen hozzáférése elől védett lapokat feloldhassuk a munkánk idejére, majd azt annak befejeztével ismét védetté tegyük. A lapvédelem feloldására az ActiveSheet.Unprotect

utasítást, a védelem bekapcsolására az ActiveSheet.Protect

utasítást kell használnunk. A védelmek ki illetve bekapcsolásához azonban először a védett lapra kell állnunk, majd azt követően visszatérni az eredeti lapra, mely lapváltásokhoz a Sheets("Munkalapnév").Select

utasítást használhatjuk. A védelmek azonban csak akkor hatásosak, ha ahhoz jelszó is

kapcsolódik. Ha azonban rögzítjük a makrót, akkor a jelszó nem kerül bele a Visual Basic programba, így annak lefuttatásakor már jelszó nélkül kerül csak levédésre a lap. Ha tehát jelszóval is védeni szeretnénk az oldalt úgy azt nekünk kell begépelni a makróba a ActiveSheet.Protect Password:="jelszo"

és ActiveSheet.Unprotect Password:="jelszo"

utasítások használatával.


Bár ez esetben a jelszó valóban nagyobb védelmet nyújt, az azonban a Visual Basic kódban szerepel, így ilyen esetben nem árt magát a makróprogram megtekintését is jelszóval levédeni a Visual Basic Tools menüjének VBAProject Properties menüpontjával előhívható panel Protection fülénél. Itt pipáljuk ki a Lock project for viewing felirat előtti négyzetet és adjuk meg a jelszót.

A védelemre szolgáló utasítás természetesen nem csak az aktuális munkalapra vonatkozhat, hiszen a Sheets("Munkalapnév").Protect Password:="jelszo"

és Sheets("Munkalapnév").Unprotect Password:="jelszo"

formulával tetszőleges munkalap is levédhető és feloldható. A lapvédelem bekapcsolásakor számos opciót is megadhatunk,

amikre szükségünk is van, hiszen célszerű, ha a védett oldalon semmi mást sem engedélyezünk, mint a nem védett cellák kijelölését és használatát, így megakadályozhatjuk azt, hogy a felhasználó rálépjen egy védett cellára, megnézve annak tartalmát. Ez sok esetben még kényelmesebbé is teszi az adatbevitelt, hiszen ha eleve nem engedélyezzük csak az adatbeviteli cellákra való ráállást, úgy azon túl, hogy elrejthetjük függvényeinket, valóban beviteli panel látszatát tudjuk kelteni.

Egy munkalap fentiek szerinti védelme tehát a következő utasításokkal oldható meg: Sheets("védettlapnév").Select ActiveSheet.Protect Password:="jelszo", DrawingObjects:=True, Contents:=True, Scenarios:=True ActiveSheet.EnableSelection = xlUnlockedCells Sheets("eredetilapnév").Select

A programon belüli hozzáférés biztosításához és a védelem kikap-csolásához értelemszerűen a


Sheets("Védettlapnév").Unprotect Password:="jelszo"

utasítás használható.

5.11.5. Fájl műveletek

Egy makrókkal ellátott táblázat esetén nagyon fontos, hogy az adataink folyamatosan biztonságban legyenek és a felhasználók ne tudjanak visszaélni egy esetlegesen el nem mentett közbülső verzióval. Alkalmazzuk tehát a mentést minden fontosabb művelet után (persze csak egyszer, a makrók legvégén), hiszen ha a felhasználó kilép a táblázatból és nemmel válaszol a mentésre vonatkozó kérdésre, akkor semmit sem ér az időközben végrehajtott program. A mentéshez az ActiveWorkbook.Save

utasítás kiadása szükséges. Ha esetleg a táblázatunknak más nevet kívánunk adni, vagy más fájlformátumban szeretnénk menteni, akkor az ActiveWorkbook.SaveAs

formulát kell használni és azt a Filename:= ”fájlnév” és FileFormat:= formátum attribútumokkal kell kiegészíteni. Az ActiveWorkbook.SaveAs Filename:= _ "C:\Excelmakro\minta\test.xls", FileFormat _ :=xlExcel8

utasítás tehát a táblázatot test.xls néven a C:\Excelmakro\minta mappába a 2003-as verzió formátumában (tehát sima xls és nem xlsx) menti el. Vigyázzunk, mert az xlsx formátum nem támogatja a makrókat, az újabb verziók esetében az xlsm formátumra van szükségünk.

Bár nem jellemző, de előfordulhat, hogy szükségünk lehet táblázat megnyitására makróból. Ilyenkor a Workbooks.Open Filename:= "fájlnév"

utasítást használhatjuk. Például: Workbooks.Open Filename:= "C:\Tablazatok\makrominta.xls"

Új munkafüzet (táblázat fájl) létrehozása makróból igen egyszerűen megvalósítható, csupán a Workbooks.Add


utasítást kell kiadni. Természetesen ez esetben gondoskodni kell az új táblázat elmentéséről, illetve annak bezárásáról is. Ehhez kapcsolódóan szükséges tudni, hogy munkafüzet váltásához a Windows("Munkafüzetnév").Activate

utasítást, az aktuális munkafüzet (táblázat fájl) bezárásához az ActiveWorkbook.Close

utasítást használhatjuk. (Ez utóbbi előtt egy mentést is célszerű végezni.)

Ezen módszerekkel akár azt is megtehetjük, hogy meglévő táblá-zatainkból, nyilvántartásunkból ügyfeleink részére automatikusan létrehozatunk egy külön táblázatot, amelybe csupán az általunk meghatározott, rá vonatkozó adatok (és a hozzá kapcsolódó függvények, képletek, stb.) kerülnek. (Ld. 7.5. példaprogram.) A létrehozás egyetlen gombnyomásra megvalósítható úgy, hogy az új munkafüzettel kapcsolatos minden munkát az általunk írt makró-program elvégez, a felhasználónak azzal semmiféle tennivalója nincs.

5.11.6. Nyomtatás

Igen gyakori igény, hogy a munkalap nyomtatása makróból is kivitelezhető legyen. Szerencsére ezt viszonylag egyszerű kivitelezni, hiszen elég az ActiveWindow.SelectedSheets.PrintOut

utasítást beírni a programkódba az aktuális munkalap kinyom-tatásához. Ha több példányban szeretnénk nyomtatni, úgy az utasítás mögé a Copies:=példányszám tagot is oda kell írnunk. Ha tehát például az aktuális munkalapot két példányban kívánjuk kinyomtatni, úgy az ActiveWindow.SelectedSheets.PrintOut Copies:=2

utasítást kell a kódba írni.

5.11.7. Beszúrás, törlés

Mivel nem csak a normál munkalap használatakor, hanem a makróprogramozás során is szükségünk lehet sorok vagy oszlopok beszúrására és törlésére, ezért ezen utasításokat is ismernünk kell. Szerencsére ezen funkciók viszonylag egyszerűen kivitelezhetők,


csupán arra kell figyelni, hogy a beszúrások mindig az aktuális cella elé történnek. Egy sor beszúrásához tehát a Range("cellaazonosító").EntireRow.Insert

utasítást, egy oszlop beszúrásához pedig a Range("cellaazonosító").EntireColumn.Insert

utasítást kell kiadni. Adott sor törlésére a Range("cellaazonosító").EntireRow.Delete

utasítás, oszlop törlésére pedig a Range("cellaazonosító").EntireColumn.Delete

utasítás szolgál. A cellaazonosítások lehetnek a hagyományos betű-szám kombinációk (Pl.: A1), illetve csak sor (Pl.: 4:4) vagy csak oszlopazonosítások (Pl.: C:C) is. Értelemszerűen a csak sorazonosításból álló azonosítókat a sortörléshez és beszúráshoz, a csak oszlopazonosításból álló azonosítókat az oszloptörléshez és beszúráshoz használhatjuk.

Ha a cellaazonosításban több sort vagy oszlopot adunk meg, úgy ezáltal több sort vagy oszlopot tudunk beszúrni. Ennek megfelelően például a Range("1:5").EntireRow.Insert

utasítással a táblázat legelejére (tehát az 1. sor elé) öt sort tudunk beszúrni, míg a Range("E:E").EntireColumn.Insert

utasítás az E oszlop elé egyetlen oszlopot illeszt úgy, hogy azt és a mögöttes tartalmat egy sorral jobbra tolja.

A Range("cellaazonosító") tag természetesen helyette-síthető a Range("cellaazonosító").Select és Selection tagokkal is. Így például a Range("C4").Select Selection.EntireRow.Insert Range("E8").Select Selection.EntireColumn.Insert Range("C11").Select Selection.EntireRow.Delete Range("D14").Select Selection.EntireColumn.Delete

utasítások a 4. sor elé egy sort, az E oszlop elé egy oszlopot szúrnak be, illetve kitörlik a 11. sort és a D oszlopot.


5.12. Párbeszédpanelek használata

A párbeszédpanelek használatával olyan lehetőségeink nyílnak meg az Excel makróprogramozásában, amik eddig csak a komolyabb alkalmazásoknak volt a sajátjuk. Segítségükkel elszakadhatunk az Excel táblázataitól, és olyan adatbeviteli vagy adatmegjelenítő felületet alakíthatunk ki, mint amilyenek a többi Windows-os programban használatosak.

A párbeszédpaneleket azonban egyszerű makrórögzítéssel nem hozhatjuk létre (csak viszonylag öszetett programozással), sőt még az eddig megismert programkódtól is el kell szakadnunk egy kissé, hiszen a Visual Basic e célra külön szerkesztőt kínál.

A párbeszédpaneleken használható vezérlők lehetőségeire itt most nem térnénk ki ismételten, azok szerepét az 2.1. pontban már ismertettük.

A lehetőségeink igen tágak, hiszen nem csak a szokásos vezérlőhasználathoz tudunk kódokat rendelni, hanem például akár a gomb feletti egérmozgatáshoz, egy párbeszédpanel bezárásához, vagy egy legördülő lista megváltozásához is.

Ha párbeszédablakot kívánunk használni, úgy először egy makrót kell készítenünk, vagy egy eseményt kell definiálnunk, amely megnyitja a párbeszédpanelt. Ezt legegyszerűbben úgy tehetjük meg, ha létrehozunk egy nyomógombot a Fejlesztőeszközök szalag Beszúrás gombjának Űrlap-vezérlőelemek részénél, majd a makró hozzárendelés panelen az Újat gombot választjuk. Ekkor a makrónk csupán a Sub, End Sub utasításpárt fogja tartalmazni, amibe magunk tudjuk begépelni a párbeszédpanel megjelenítésére szolgáló párbeszédpanelnév.Show

utasítást. A párbeszédpanel természetesen bármikor, bármely makró bármely részén meghívható ugyanezen utasítással. Hosszabb program esetén a makró futása a párbeszédpanel feldolgozásáig nem lép tovább, tehát előbb meg kell adnunk a párbeszédpanelen a kívánt adatokat, be kell azt zárni, majd csak ezt követően hajtódik végre a program következő utasítása.

Adott esetben szükség lehet a panel bezárására is, amire a párbeszédpanelnév.Hide

utasítás szolgál, bár természetesen a panel bezárógombja is becsukja a panelt.


Készítsünk most példaként egy egyszerű alkalmazást, amely termékeket tart nyilván, és amely tartalmaz egy Kimutatás gombot egy párbeszédpanel megjelenítésére, ahol legördülő listáról választhatjuk ki a kívánt elemeket a hozzá tartozó adatok megtekintése céljából. Ehhez első lépésben hozzuk létre az adatokat tartalmazó táblázatot:

Fontos, hogy a táblázatban a termékek nevei ábécébe legyenek rendezve. A Kimutatás gombot a Fejlesztőeszközök szalag Beszúrás gombjának Űrlap-vezérlőelemek részénél a gomb beszúrásával rajzolhatjuk meg, majd a makró hozzárendelés panelen az Újat gombot választva írjuk be a leendő kimutatas nevű panelünk megjelenítésére szolgáló utasítást a makrókódba: Sub Gomb1_Kattintás() kimutatas.Show End Sub

Ezzel a makró ugyan képes meghívni a párbeszédpanelt, de mivel az még nincs kész, hibajelzést adna. (A lehetőségek áttekintése után folytatjuk a példát.)

Párbeszédpanelek szerkesztését a makrók szerkesztésére szolgáló Microsoft Visual Basic alkalmazás paneljén az Insert menü UserForm pontjával kezdeményezhetjük. További lehetőség, ha az eszköztáron kattintunk az Insert UserForm gombra.


A megjelenő szerkesztőbe tetszés szerint rajzolhatjuk meg a különféle eszköztár-vezérlőket. A használni kívánt vezérlőt a Toolbox panelről választhatjuk ki, amiket aztán a segédrácsokkal ellátott új panelünkre rajzolhatjuk ki. A kész eszköztár-elemek utólag tetszés szerint áthelyezhetők, vagy átméretezhetők a korábban már megismert módszereknek megfelelően. (A szélein és sarkain lévő négyzetek húzásával, illetve a vezérlő közepének húzásával.) Ugyanilyen módon maga párbeszédpanel is tetszőleges méretűre állítható be.

Nagyon fontos, hogy a panel minden egyes eleméhez, illetve magához a panelhez is számos tulajdonságot állíthatunk be, illetve számos tevékenységet rendelhetünk hozzá. A tulajdonságok beállítása a tulajdonságlapon történik, ami alapesetben az ablak bal szélén látható és mindig a kiválasztott elem tulajdonságait mutatja. Ha nem látjuk, úgy az adott elem jobb egérgombbal előhívható helyi menüjének Properties pontjával is


elérhetjük. A tulajdonságlap elemei megtekinthetők ábécé rendben és kategorizálva is. Ez utóbbi praktikusabb, mivel egy csoportba gyűjti a hasonló célra szolgáló jellemzőket. A kettő közt váltani a tulajdon-ságlap felső sorában lévő fülek segítségével lehet.

A tulajdonságlapon rengeteg paramétert állíthatunk, melyek közül az alábbi listában kigyűjtöttük a legfontosabbakat. A tulajdonságok listája természetesen vezérlőtípustól függően eltérőek, hiszen míg a legördülő listánál a bemeneti adattartomány megadása szükséges, addig egy rádiógombnál a csoportnév.

Name A vezérlő neve (erre a névre hivatkozhatunk) Caption A párbeszédpanel fejlécének szövegeControlSource Ide kerül a vezérlő által kiválasztott adat RowSource A vezérlő bemeneti adattartományaListRows Lenyíló sorok számaFont A vezérlő betűtípusa és méreteTextAlign IgazításHeight MagasságLeft Vízszintes pozícióTop Függőleges pozícióWidth SzélességText TartalomLocked Zárolt/MódosíthatóPicture Kapcsolt képPasswordChar Jelszó elrejtése (az ide beírt karakterrel)BackColor HáttérszínBackStyle HáttérstílusBorderColor KeretszínBorderStyle KeretstílusSpecialEffect KeretkiemelésForeColor SzövegszínGroupname Csoportnév (rádiógomboknál)

A vezérlőkhöz meghatározható tulajdonságokon túl minden vezérlőhöz kódokat is rendelhetünk, amely kódok bizonyos események bekövetkezésekor futnak le. Ilyen esemény lehet, ha rákattintunk egy gombra, megváltoztatjuk egy legördülő listán a kiválasztott elemet, elmozdítjuk az egeret egy kép felett, duplán kattintunk egy listára, stb. Ezen események mindegyike más-más tevékenységsorozatot válthat ki, amely tevékenységsorozatot a szokásos módon tudjuk leprogramozni, bár ezen kódrészletek a


makróprogramunk kódjától különállóan szerkeszthetők, hiszen minden panelnek önálló kódlapja van. Ha tehát írunk egy makrót, ami két párbeszédpanellal dolgozik, úgy összesen három különálló lapon tudjuk a kódot megtekinteni. A vezérlőkhöz rendelhető események típustól függően természetesen szintén eltérőek lehetnek.

Vezérlőhöz kódot rendelni a legegyszerűbben úgy tudunk, hogy a vezérlőre a panelszerkesztőben duplán kattintunk. Ez a módszer már csak azért is praktikus, mert így rögtön létrejön a vezérlő tipikus tevékenységének megfelelő alprogram keret a Sub, End Sub utasításpárokkal, amik közé már csak a tevékenységet kell beírnunk. (A kód megjelenítése a helyi menü View code pontjával is kezdeményezhető.)

A kódszerkesztő ablak felső sorában lévő két legördíthető elem nagyon fontos, hiszen ezek segítségével viszonylag könnyen szerkeszthetünk tevékenységekhez tartozó kódokat. Szerencsére nem kell ismernünk az események utasításait és pontos formátumát, hiszen elegendő csak kiválasztani a bal felső legördülő elem segítségével a kívánt vezérlőt, a jobb felsővel pedig a kívánt eseményt és máris létrejön a szükséges kódkeret Sub, End Sub utasításpárja.

Ha feleslegesen hoztunk volna létre eseményhez tartozó kódot, úgy egyszerűen töröljük ki a hozzátartozó Sub, End Sub utasítás-párokat.

A Sub utasítás után a vezérlőnevet és az eseménykódot kell írni aláhúzásjellel elválasztva.

A leggyakoribb ilyen esemény a kattintás, melyhez a Sub vezérlőnév_Click()

utasítás használható, és a változás, melyhez a Sub vezérlőnév_Change()

utasítás használható, de számos további esemény (dupla kattintás, egérmozgatás, billentyű lenyomás, felengedés, hiba, stb.) is kiválasztható, amelyeket hozzárendelhetünk a vezérlőhöz.


Ha a vezérlő által beviendő adatra akarunk hivatkozni, úgy azt a saját panel kódjában a Vezérlőnév.Value

másutt a Panelnév.Vezérlőnév.Value

formulával tehetjük meg, amit ugyanúgy kezelhetünk, mint egy változót.

A párbeszédpanel bezárására Panelnév.Hide

utasítást tudjuk használni. Ezt célszerű egy kilépésre szolgáló gomb kattintási vezérlésébe tenni a Private Sub Bezárógombnév_Click() Panelnév.Hide End Sub

utasítások segítségével. Mivel gyakori, hogy párhuzamosan szerkesztjük a

párbeszédpaneleket, azok tulajdonságait, illetve a hozzájuk tartozó kódokat, ezért előfordul, hogy az egyik eltűnik amiatt, hogy a másikat szerkesztjük. Ilyenkor használhatjuk az F7 és Shift F7 gombokat a váltáshoz, vagy a Project Explorert, ami az ablak bal felső sarkában van és fa struktúra szerűen tartalmazza a különféle objektumokat. Ezekre duplán kattintva előtérbe hívhatjuk a makrókódunkat, vagy a párbeszéd-paneljeinket.

Most folytassuk a példánkat és készítsük el a legördülő listát, illetve az adatmegjelenítő mezőket. Kattintsunk a párbeszédpanel szerkesztőnél a Toolbox panelen a ComboBox elemre és rajzoljuk meg a legördülő listát az üres panelen. Válasszuk a Label elemet, rajzoljuk meg a szöveg helyét és írjuk át a feliratot Készlet:-re. Ugyanígy a Label elemmel készítsük el az Érték és a Ft. feliratot is. Válasszuk a Textbox elemet, majd rajzoljuk meg az a készlet és érték adatának megjelenítésére szolgáló szövegdobozokat a Készlet és Érték feliratok után. Ezek most még keretes, fehér hátterű szövegdobozok lesznek, de ez ne zavarjon minket, mert majd ezeket úgyis eltüntetjük. Már csak az Ablak bezárása gomb van hátra. Ehhez


válasszuk a CommandButton elemet, rajzoljuk meg a gomb helyét, majd kattintsunk rá és írjuk át a szövegét Ablak bezárása-ra.

A következő lépés a vezérlők tulajdonságainak megadása. Először magának a párbeszédpanelnak a nevét kell megadnunk,

hogy a korábban megírt makró meg tudja jeleníteni. Ez nem egy bonyolult feladat, kattintsunk a panel egy üres részére és a bal alsó sarokban található tulajdonságpanelen írjuk át a (Name) értékét Kimutatas-ra (itt ne használjunk ékezetet, mert a programkódban is így volt a neve).

A legördülő lista tulajdonságainál viszont már jóval több mindent kell megadnunk. Először is kattintsunk rá, majd a (Name) értékét Legordulo-re módosítsuk, hogy a későbbiekben könnyedén tudjuk azonosítani. Most adjuk meg, hogy honnan vegye az adatokat a lista. Ehhez a RowSource mezőbe írjuk be az A4:A12 tartományazonosítót. Ha a kiválasztott elemet az Excel táblázatában is viszont szeretnénk látni, úgy annak célcelláját a ControlSource mezőbe kell bevinni. Bár ez esetben ez most nem létkérdés, az esetek többségében azonban szükséges lehet, így vigyük ide most mi is be az E3 cellaazonosítót. S hogy ne legyen túl nagy a listánk állítsuk át a legördülő sorok számát is 5-re a ListRows mezőben. (Ehhez az elemhez majd kódot is kell rendelnünk, de előbb nézzük meg a többi elem tulajdonságait.)

A Készlet, Érték és Ft. szövegek esetében a betűméretet kell egy kicsit nagyobbra venni, mivel alapértelmezésben 8 pontos, mi pedig 10 pontos betűkkel szeretnénk ezeket kiíratni. Kattintsunk tehát a tulajdonságpanelen a Font mezőre, majd a jobb sarkában így megjelenő három pontot tartalmazó gombra. Most megjelenik egy új panel a szokásos betűformázási lehetőségekkel. Nekünk a betűtípus és stílus megfelel, csupán a betűméretet kell 8-ról 10 pontra módosítani. Ha készen van, kattintsunk az OK gombra, majd


ismételjük ezt meg a többi szövegnél is. Ezeknek nevet nem szükséges adni, mert nem használjuk őket sehol.

Most következik a panel egyik legérdekesebb része, az adat-megjelenítések. Erre a célra két textboxot csináltunk, de ezek kerettel és fehér háttérrel jelennek meg, ráadásul üresek is. Az adatokat beléjük a táblázatból fogjuk venni, melyeket majd kódból generálunk le. (Használhatnánk Excel függvényeket is, ami valószínűleg egyszerűbb is lenne, de most szeretnénk bemutatni a kódból való adatgenerálást is, így ezt a módszer választottuk.) Az adatokat majd az F3 és G3 cellákba fogjuk legenerálni, tehát válasszuk most a Készlet felirat melletti textboxot és írjuk be a tulajdonságpaneljének ControlSource mezőjébe az F3 cellaazonosítót. S hogy ne legyen keretünk és hátterünk, a tulajdonságpanelen a SpecialEffect és BackStyle értékeke vegyük le 0-ra. Ezzel szinte teljesen el is tűnt a szövegdobozunk. Persze van még mit beállítani, hiszen itt is módosítani kell a betűméretet 10 pontra. Ezt az előzőekben leírt módon, a Font sornál megtehetjük. A textbox azonban elsődlegesen szövegbeviteli mezőként funkcionál, ezért aztán lehetőséget biztosít arra, hogy a benne lévő szöveget módosítsuk, abba új szöveget vigyünk be. Mi viszont most adatmegjelenítésre használjuk, így meg kell akadályozni az adatbevitel lehetőségét. Ezt a Locked sor False-ról True-ra való átállításával tudjuk kivitelezni. A fentiekhez hasonlóan ugyanezeket a beállításokat végig kell vezetnünk az Érték és Ft. között lévő textboxon is, csupán ott a tulajdonságpanel ControlSource mezőjébe a G3 cellaazonosítót kell írnunk.

Ezzel lényegében megadtuk a szükséges tulajdonság-beállításokat. Kisebb szépítéseket még megtehetünk, de a lényeg kész.

A következő lépés a vezérlők eseményeihez rendelt kódok elkészítése, amely egyrészt a kilépés gomb funkciójának megha-tározását jelenti, másrészt pedig meg kell oldanunk, hogy a legördülő lista minden egyes változásakor az F3 és G3 cellákba bekerüljenek a kívánt adatok. Ezen adatokat azonban a táblázatban való kereséssel, illetve számolással tudjuk előállítani. Ráadásul eltérés, hogy a legördülő lista az Excel saját listájával szemben nem a sorszámot, hanem megát az elemet adja vissza eredményül, amire figyelni kell. A kód elkészíthető lehetne úgy is, hogy nem figyeljük a legördülő változását, hanem egy gombot készítünk, ami aktiválja a legördülő listán kiválasztott elemet, de ez a módszer így elegánsabb. Ráadásul zavaró is lehetne, hogy gomb megnyomása előtt a kiválasztott érték eltér az eredményt adókétól.


A bezárógomb elkészítése egyszerűbb, kezdjük tehát azzal. Kattintsunk duplán a tervezőpanelen az Ablak bezárása gombunkra, melynek hatására megjelenik a kódszerkesztő ablaka a Private Sub Kilepes_Click() End Sub

tartalommal. Egészítsük ezt most ki az panel bezárására szolgáló utasítással: Private Sub Kilepes_Click() Kimutatas.Hide End Sub

Ezzel sikeresen megadtuk, hogy ha rákattintunk a kilepes elneve-zésű gombra, akkor eltűnik a kimutatas elnevezésű párbeszédpanel.

Nézzük a másik feladatunkat, amivel elérhetjük, hogy az E3, F3 és G3 cellákba bekerüljenek a kívánt adatok. Az adatok számítása a legördülő lista megváltozásakor kell hogy megtörténjen, mégpedig úgy, hogy az E3 cellába a legördülő lista értéke, az F3 cellába az ahhoz tartozó készlet, a G3-ba pedig a készlet és darabár szorzata kerüljön. Ezt a már korábban ismertetett függvényekkel valósíthatjuk meg. Kattintsunk tehát duplán a tervezőpanelen a legördülő listánkra, melynek hatására a kódszerkesztő ablakban most a Private Sub legordulo_Change() End Sub

utasítások is megjelennek. Látható, hogy itt nem a legördülő listára való kattintás, hanem a változás a legfontosabb lehetőség, így a kód is rögtön e szerint képződik. Egészítsük tehát ki ezt is az alábbiak szerint: Private Sub legordulo_Change() Range("E3") = legordulo.Value Range("F3") = WorksheetFunction.VLookup(Range("e3"), Range("A4:b100"), 2) Range("G3") = WorksheetFunction.VLookup(Range("e3"), Range("A4:c100"), 3) * Range("f3") End Sub

(A Range (”F3”) és Range (”G3”) kezdetű sorokat természetesen egy sorba kell írni, csak jelen könyvben nem fért ki a teljes utasítás.)


Ezzel lényegében el is készült a panel, nincs más dolgunk, mint kipróbálni, amit az Excel táblázatban a Kimutatás gombra kattintva meg is kezdhetünk.

A fenti lépéseket nem kötelező ebben a sorrendben végigcsinálni, jó megoldás az is, ha egy-egy vezérlőelem elkészítése után rögtön meghatározzuk annak tulajdonságait és a hozzá tartozó kódokat.

Az eseménykezelőkkel sok érdekes dolog is kivitelezhető, hiszen eseménykezelő kódok nem csak a párbeszédpanel-elemekhez rendelhetők, hanem egyéb objektumokhoz is. Erről részletesebben a 3.2. pontban szóltunk.

5.13. Objektumorientáltság

Mint azt korábban jeleztük az előzőekben elsősorban az egyszerűségre és érthetőségre törekedtünk, ezért nem minden esetben úgy kezeltünk bizonyos lehetőségeket, ahogyan azt szabvány szerint illene. Ezért aztán bár számos objektumként is kezelhető műveletet is egyszerű utasításként használtunk, ez nem jelenti azt, hogy azokat ne lehetne komplexebb módon is kezelni. A Visual Basicben minden objektum rendelkezik a rá jellemző tulajdon-ságokkal (pl. változókban meghatározható értékek), illetve cselekvési képességekkel (pl. meg lehet nyitni, el lehet tüntetni, rá lehet duplán kattintani, stb.) Ezek együtt alkotják az objektum jellemzőit. Fontos továbbá az öröklődés lehetősége is, ami az osztályok egymásból való származtatását teszi lehetővé, így egy objektum megörökli a szülő


objektumának tulajdonságait, de kibővítheti vagy felülbírálhatja is a saját maga esetében azokat. Így aztán az objektumok osztályokba szerveződnek, az osztályok pedig függvényeket, metódusokat, tagfüggvényeket és változókat tartalmazhatnak. (Ezeket a hivatkozások során ponttal választjuk el egymástól, de mivel az esetek többségében nem írjuk ki az aktuális szülőobjektum neveket, ezért azokkal nem is találkozunk.)

Mit jelent azonban mindez számunkra? Láthattuk, hogy például az MsgBox szó képviselhet önálló utasítást is, (meghívva megjelenik egy szövegdoboz), de ha egy változóval vetetjük fel az értékét, és az egyenlőségjel után írjuk, úgy nem csak hogy megjelenik, hanem vissza is adja a változónak a megnyomott gomb kódját. Ugyanilyen módon az utasításaink nagy része szintén kezelhető objektumként, de jó példa erre a párbeszédpanel, illetve az azokon használt elemek, amelyekre hivatkozni ponttal elválasztva a szülőobjektum nevétől tudunk, illetve amelyek megjeleníthetők, eltüntethetők, de mindemellett különféle értékeket is felvehetnek.

Ha valaki tehát kicsit mélyebben szeretne foglakozni a makrók lehetőségeivel, úgy ezen az úton elindulva a súgó segítségével rengeteg mindent megvalósíthat.


6. Programozási tanácsok

Bár az előző fejezetben már igen sok hasznos tanácsot adtunk, a makróprogramok elkészítését illetően, nem árt néhány olyan általános tanácsot is megfogadni, amely komplexen, az egész programozási folyamatra igaz.

6.1. A felhasználó mindenre képes

Ne tételezzük fel azt, hogy a felhasználó csak olyan adatot fog megadni, amit mi elvárunk tőle. Akár tévedésből, akár heccből, de a felhasználók az adatbevitel során rögzíthetnek olyan adatokat is, amelyek feldolgozása problémába ütközne. Tipikus ilyen az, amikor számot várunk, de a felhasználó nem számot visz be. Esetleg a szám negatív, vagy túl nagy. Sokszor a nulla is jelenthet problémát, ha azzal a későbbiekben osztani fogunk. A programot tehát úgy kell elkészíteni, hogy a bevihető adatok körét le kell szűkíteni, illetve a bevitt adatokat ellenőrizni kell, és a további feldolgozási folyamatot ettől függővé téve kell folytatni. Ennek értelmében a kész progra-munkat minden elképzelhető hülyeségre tesztelni szükséges.

Másik tipikus hiba, hogy olyankor is engedünk végrehajtani tevé-kenységet, amikor nem lehetne. Például eladhat terméket olyankor, amikor a raktárkészlet nulla. Ha ilyen esetben az eladás során levonjuk az eladást, negatív készletet kaphatunk, ami gondot okozhat.

Figyelni kell arra is, hogy a tevékenység végeztével előálló adatok nem okoznak-e problémát. Például ha eladjuk az összes árut és nulla lesz a raktárkészlet, majd ezzel a raktárkészlettel osztjuk el a költségeket, akkor a nullával való osztás hibajelzést eredményez.

További fontos szabály, hogy védjük le a táblázatunkat attól, hogy abba a felhasználó beleírhasson olyan helyre is valamit, ahová neki nem volna szabad. Ezt a lapvédelemmel és a cellazárolásokkal nagyon jól meg tudjuk oldani.

Gondoljuk végig továbbá, hogy mit tehet meg a felhasználó a táblázatunkkal és az okozhat-e a későbbiekben problémát. Ha nem

Programozási tanácsok 75

akarjuk, hogy az alkalmazott hozzáférjen bizalmas adatokhoz, vagy átírjon készletadatokat, akkor ezek megfelelő védelméről is gondos-kodnunk kell.

6.2. Kommentezés

Gondoljunk előre arra, hogy a programunkat a későbbiek során esetleg módosítanunk kell, vagy egy hibát csak jóval a megírás után fedezünk fel. Pár hónap elteltével már nem fogunk emlékezni arra, hogy mit miért írtunk a programba, melyik rész mi célt szolgált, vagy miért úgy oldottuk meg. Az előrelátó programozó folyamatosan kommentezi a programot, ami azt jelenti, hogy olyan nem végrehajtandó megjegyzéseket szúr bele, ami kellő magyarázattal szolgál az adott programrész szerepéről.

6.3. Rövidítések

Számos lehetőségünk van arra, hogy az utasításokat lerövidítsük, egyszerűsítsük. Ez nagyon sok esetben praktikus, de a túlzásba vitt rövidítés könnyen áttekinthetetlenné teheti a kódot. Figyeljünk tehát arra, hogy a tömörítés csak megfelelő mértékű legyen, és az ne menjen az olvashatóság rovására.

6.4. Statikus adatok

Nagyobb alkalmazásokban számos olyan adat van, amely az adott szituációban állandó, tehát minden további nélkül dolgozhatunk ezen számokkal közvetlenül is a programban. Mi van azonban akkor, ha egy ilyen adat a későbbiek során mégis megváltozik? A programot erre felkészíteni ugyan nem szükséges, de ha magunknak kell kikeresni a programkódban az ilyen adatokat és egyesével megváltoztatni azt, úgy azon túl, hogy nehezen találjuk meg, könnyen ki is hagyhatunk egyet. Az ilyen konstansok esetén ne a számot írjuk be közvetlenül a programkódba, hanem a kód elején vegyünk fel egy konstansot értékadással, majd ezzel a konstanssal végezzük el a műveleteket a szükséges helyeken.

6.5. Strukturáltság, tagolás

Nagyon fontos, hogy programunk jól áttekinthető legyen. Ez több dologból tevődik össze.

Egyrészt tabulátorok használatával kezdjük beljebb a logikailag egy egységet képező részeket, ciklusokat feltételrendszereket, stb.


Másrészt válasszuk szét az egybetartozó programrészeket, te-gyünk közéjük üres sorokat, vagy helyezzük őket külön modulokba.

A legjobb, ha minden egyes külön feladathoz önálló eljárásokat, függvényeket készítünk, így egy eljárás vagy függvény mindig csak egy dolgot csinál, azt, amire a neve is utal.

6.6. Ismeretlen adatok

Egy makró, eljárás vagy függvény megírásakor nagyon fontos, hogy sose bocsátkozzunk feltételezésekbe a bemenő adatokat vagy paramétereket illetően. Erről már tettünk említést a felhasználói adatbevitel során, de adatokat nem csak a felhasználó vihet be, hanem maga a program is előállíthat, illetve azok egyéb helyről is származhatnak.

Minden esetben készüljünk fel az esetleges hibalehetőségekre, amiket a programkódba épített alternatív megoldásokkal vagy hibaüzenettel is lekezelhetünk.

6.7. Az adatok biztonsága

A felhasználói adatkezelésnél már tettünk említést arról, hogy ha nem készítjük fel megfelelően a programot, úgy a felhasználók könnyen hozzáférhetnek bizalmas adatokhoz, vagy átírhatnak kényes adatokat. Mindezen túl fel kell készülnünk a rafináltabb felhasználókra is, így célszerű minden változót vagy függvényt a lehető legkisebb kiterjedésben deklarálnunk, megvédve attól, hogy arra jogosulatlan elemek is használhassák. Ne deklaráljunk feleslegesen globálisnak olyan változókat, amelyeket elég lokálisan használni. A táblázatok védelme és a jelszó kezelése sajnos az Excel makróprogramozásában sokszor elfelejtődik, de vannak módszerek a védelemre, amit fontos esetekben ki kell használnunk.

6.8. Problémák a ciklusok használata során

Írjuk úgy meg a programot, hogy a ciklusokból csak szabályos módon történjen meg a kilépés. Kerüljük ciklusból közvetlenül kilépő utasításokat. Lehetőleg ne használjunk túl mélyen egymásba ágyazott ciklusokat sem, mert hiba esetén nagyon nehézkessé válik a hibakeresés. Többnyire minden problémához maximálisan elegendő a három-négy szint mélységű egymásba ágyazás, ennél mélyebb szerkezeteket ne csináljunk. Ha mégis szükséges, úgy helyezzük a belső ciklusokat külön eljárásba, amit majd a ciklusból meghív-hatunk.

Programozási tanácsok 77

6.9. A makró nem táblázat

Fontos tudni, hogy a makróprogram sokmindenben nem úgy viselkedik mint a táblázat, tehát nem képes magától követni a táblázatban tett módosításokat. Amíg egy táblázatban ha kitörlünk vagy beszúrunk egy sort, úgy az ezáltal feljebb vagy lejjebb csúszó sorokra történő hivatkozások automatikusan módosulnak. Ugyanígy az oszloptörlés esetén is elmozduló cellákra történő más cellákban lévő hivatkozások követik az elmozduló cellák azonosító adatait. A makrókban lévő hivatkozások azonban nem teszik ezt meg. Ha tehát beszúrunk pár sort néhány új adatnak, attól a makróprogramban a hivatkozások még mindig arra cellára fognak mutatni, amire eredetileg is hivatkoztak, tehát ilyen esetben a programban is meg kell tennünk a szükséges módosításokat.

6.10. Mentések

Mivel az Excel makróprogramozása során az adtok a táblázatban tárolódnak, az Excel kilépéskor rákérdez azok mentésére. E mentés elmaradása azonban a teljes addigi munka elvesztését is eredményezheti, így egy olyan programnál, ahol fontosak az adatok folyamatos megléte, nem engedhetjük meg, hogy maga a felhasználó döntsön a mentés végrehajtásáról. Célszerű tehát ha a programot úgy készítjük el, hogy egy-egy feladat elvégzését követően mentés is történjen. Ez nem csak a felhasználó általi elfelejtett mentés problémájára ad megoldást, hanem az esetleges áramszünet, szabálytalan kilépés, vagy véletlen gépkikapcsolás ellen is véd. Ne felejtsük el azonban azt sem, hogy a mentés hosszabb ideig is eltarthat, így ha túl sokszor végezzük, nagyobb táblázatok esetén zavaróan lelassíthatja a munkát.


7. Példák és lehetőségek

7.1. Árkalkuláció

Első példánkban készítsünk egy árkalkuláció számító táblázatot, amelyben vezérlőelemekkel dolgozhatunk. Ebben még nem lesznek makrók, csupán a vezérlők használatában tudunk a segítségével elmélyülni. A későbbiekben viszont kiegészítjük a táblázatot egy olyan funkcióval, ami már makrókkal dolgozik.

A táblázatban listából legyen lehetőségünk felvinni a fizetési módot és az alapanyagot. A mennyiséget és a haszonkulcsot, ami 0 és 20% közt lehet léptetőnyílakkal számíthatjuk ki. Az alapanyagokhoz tartozó árak külön lapon tárolódjanak az alábbiak szerint: Fa 1500 Ft, Acél 3100 Ft, Műanyag 1100 Ft, Réz 3800 Ft. Készpénzfizetés, illetve 10 db-nál több rendelés esetén a rendszer adjon 5% kedvezményt.

Gépeljük be az ábrának megfelelően a Megrendelés, Mennyiség:, Fizetési mód:, Haszonkulcs:, Alapanyag: és Fizetendő összeg szövegeket. Most váltsunk át a Munka2 lapra, és ott vigyük fel az A3:A5 cellákba a lehetséges fizetési módokat. Az alapanyagokat a C3:C6 cellákba ábécébe gépeljük be,

Példák és lehetőségek 79

majd írjuk melléjük a D oszlopba az árakat. Most váltsunk vissza a Munka1 fülre és készítsük el a formázást. Ehhez jelöljük ki az A1:H10 területet, majd adjunk világosszürke hátteret. Az A2:H2 területnek sötétszürke hátteret adjunk, fehér betűszínnel. Ugyanezeket állítsuk be az A9:H9 területre is. Az A2:H2 területre kérjünk cellák közt középre zárást és vastag betűs írást. Állítsuk be középre zártra, 12 pontosra és vastag betűsre a C4, F4 és D9 cellákat. A G5 cellába gépeljünk be egy %-jelet, állítsuk jobbra zártra, tegyük 12 pontos vastag betűssé. Álljunk a C4 cellára, állítsuk fehér hátterűvé és kérjünk rá „vastag körbe” szegélyt. Tegyük kissé magasabbá a 4-es sort, a 4-es és 5-ös sor közti vonal húzásával. Végezzük ezt el a 6-os sorra is. Az A és a H oszlopokat állítsuk keskenyebbre, a B és a D oszlopokat pedig szélesebbre.

Most készítsük el a vezérlőelemeket. (Ha nem volt engedélyezve a Fejlesztőeszközök szalag, akkor ezt tegyük meg a Fájl menüben az Excel beállításainál. Régebbi verziókban kapcsoljuk be a vezérlők eszköztárat a Nézet menü Eszköztárak almenü Vezérlők eszköztára pontjával.)

Először rajzoljuk meg a léptetőnyílakat. Ehhez kattintsunk a Fejlesztőeszközök szalag beszúrás gombjára, majd a gombra, végül a C4 cella mellett jobb oldalra rajzoljuk meg a léptetőnyílakat. (Kattintsunk a D4 cella bal felső sarkánál, majd az egérgomb nyomvatartása mellett húzzuk az egérrel a négyzetet akkorára, amekkora elemet akarunk készíteni.) Ugyanilyen módon rajzoljuk meg az F4 cella mellé is a léptetőnyílakat. Most készítsük el a legördülő beviteli listákat is. Kattintsunk a Fejlesztőeszközök szalag Beszúrás gombjára, majd az űrlap vezérlők közül a gombra, végül a C6 cellára rajzoljuk meg az elemet.

A különbség érzékeltetése végett az alapanyag kiválasztására most ActiveX vezérlőt használjunk, már csak azért is, mert ez közvetlenül megadja a lista kiválasztott elemének tartalmát a csatolt cellában, ellentétben az űrlap vezérlőelemmel, ami a sorszámát adja. Erre persze majd a kiértékelő függvényeknél is figyelni kell. Válasszuk tehát a Fejlesztőeszközök szalag Beszúrás gombját, majd az ActiveX vezérlők közül a beviteli listát. Rajzoljuk meg a lista helyét az F6 cella felett.

A következő lépés a vezérlőelemek paraméterezése. Kattintsuk a mennyiség léptetőnyílára a jobb egérgombbal, majd a

helyi menüből válasszuk a Vezérlő formázása pontot. Kattintsunk a Cellacsatolás melletti mezőre, és gépeljük be a C4 szöveget, jelezvén, hogy a C4-es cellán lévő értéket tudjuk majd ezzel változtatni, végül


zárjuk be az ablakot az OK gombbal. A haszonkulcs léptetőnyílának paraméterezése hasonlóan történik, de itt a Cellacsatolás mellé F4-et kell írni, és a Maximális érték sort is ki kell tölteni 20-szal, hogy a léptetés csak 0-tól 20-ig történhessen.

Paraméterezzük be a fizetési mód elemet is. Kattintsunk a fizetési mód legördítő listájára a jobb egérgombbal, válasszuk a Vezérlő formázása pontot, majd a Cellacsatolás mellé írjuk be a C6-ot, majd a Bemeneti tartomány mellé a Munka2!A3:A6 szöveget. Zárjuk be ismét az ablakot. Ezzel megadtuk azt, hogy a lista elemeit az Excel honnan vegye, és hová illessze be a kiválasztottat. Már csak az alapanyag paraméterezése van hátra. Mivel ez ActiveX vezérlő, a paraméterek megadása eltér az űrlap vezérlőtől. Először a Fejlesztőeszközök szalagon váltsunk át tervező módra, majd kattintsunk a jobb egérgombbal az alapanyag kiválasztására szolgáló legördíthető listára és válasszuk a helyi menüből a Tulajdonságok pontot. A tulajdonságpanelen a LinkedCell mellé a F6-ot, a ListFillRange mellé a Munka2!C3:C20 szöveget írjuk be. Ahhoz, hogy használhassuk is a vezérlőelemeket, ki kell lépni a tervező módból. Ehhez kattintsunk ismét a Tervező mód gombon.

Próbáljuk is ki rögtön az elemeket, növeljük a léptetőnyílakkal az értékeket, gördítsük le a kiválasztólistákat és válasszuk a lehetőségek közül.

Most már nincs más hátra, mint a fizetendő összeget meghatá-rozni. A feladat kissé összetett lesz, hiszen a számítást egy függ-vénybe lenne célszerű megadni. Gépeljük be tehát a D9-es cellába az =FKERES(F6;Munka2!C3:D6;2)*C4*(1+F4/100)*HA(C4>10;0,95;1)* HA(C6="készpénz";0,95;1) függvényt. (A függvény első része megkeresi a kiválasztott alapanyaghoz tartozó árat, majd ezt beszorozza a darabszámmal. A következő szorzatban az 1 a 100%, az F4/100 pedig a haszonkulcsnál kiválasztott szám századrésze. A két utolsó szorzat egy-egy feltételvizsgálat, amely 1, ha nem teljesül a feltétel, és 0,95, tehát 5%-kal csökkentett érték, ha a rendelt darabszám nagyobb, mint 10, illetve a fizetési mód készpénzes.)

Próbáljuk ki, hogy működik a táblázatunk. Változtassuk a panelen a mennyiséget, a haszonkulcsot, az alapanyagot és a fizetési módot.

7.1.1. Táblázat kiegészítése

Ebben a példában kiegészítjük a fenti táblázatot azzal a lehetőséggel, hogy gombnyomásra új anyagot tudjunk felvinni.

Még mielőtt azonban létrehoznánk a makrót gondoljuk végig, hogy mire lesz szükségünk. Kell egy panel, ahol megtörténik az


adatbevitel. Ezen a panelen két adatot kell rögzítenünk, majd ezeket az adatokat be kell vinnünk a lista aljára és mivel az FKERES függvény csak ábécébe rendezett listában működik, be kell rendeznünk a listát is. Mindehhez viszont tudnunk kell, hogy melyik az első üres sor, ahova majd történhet a beírás. E sor számát rögzítsük az adatokat tartalmazó tábla F1 mezőjében az =SZÖVEG(DARAB2(C3:C22)+3;"#####") függvény segítségével.

Most hozzuk létre felvitelre szolgáló gombot. Kattintsunk a Fejlesztőeszközök szalag Beszúrás gombjának Gomb űrlapvezérlő-elemén, rajzoljuk meg a gombot majd hozzunk létre egy ujanyag nevű új makrót az Újat gombbal.

A makró az alábbi utasításokat fogja tartalmazni: Sub ujanyag() kieg.Show Sheets("Munka2").Select anyagsor = "c" + Range("f1") arsor = "d" + Range("f1") Range(anyagsor) = Range("g1") Range(arsor) = Range("h1") Range("C3:D22").Sort Key1:=Range("c3") Sheets("Munka1").Select End Sub

Mivel a makrónk legelső utasítása megjelenít egy párbeszédpanelt, ezért ezt el kell készítenünk. Ehhez a Visual Basic ablakában válasszuk az Insert menü UserForm pontját. Nevezzük át a panelünket kieg-re úgy, hogy kattintsunk rá a jobb egérgombbal, válasszuk a Properties pontot a helyi menüből, majd az így megjelenő jobboldali tulajdonságmezőbe a (Name) sorba beírjuk a kieg szót. Adjuk meg a panel címét is: írjuk a Caption sorba az Új anyag felvitele szöveget. Ezt követően el kell készítenünk a beviteli mezőket és a magyarázó szövegeket, valamint az OK gombot. Ha visszakattintunk a panelra ismét megjelennek az eszközök a szerkesztéshez. A pöttyözés csak a pontos igazításban segít, a végleges panelen nem fog látszódni. Most válasszuk a TextBox elemet és húzással rajzoljuk meg a két beviteli panelt. A magyarázó szövegekhez a Label elemet válasszuk, majd miután kijelöltük a helyét, kattintsunk rá és írjuk át anyagnév-re, illetve a másikat ár-ra. Az OK gombhoz a CommandButton elemet kell választanunk, majd a megrajzolást követően rákattintani és átírni a feliratát OK-ra.


Ha bármelyiket elrontottuk volna húzással, illetve a sarkain lévő négyzetek húzásával korrigálhatunk mindent.

Folytassuk a munkát a beviteli mezők beállításával. Kattintsunk az anyagnév mellettire, majd (a helyi menü Properties pontjával előhívható tulajdonságpanelen) csatoljuk hozzá a Munka2 lapon lévő G1 mezőt úgy, hogy a tulajdonságpanelen a ControlSource sorba bírjuk a Munka2!G1-et. Ez azért fontos lépés, hiszen így tudjuk elérni, hogy a mezőben és a táblázatban lévő adatok azonosak legyenek. Ugyanígy járjunk el az ár beviteli mezőjével is, kattintsunk rá, majd csatoljuk hozzá a Munka2 lapon lévő H1 mezőt úgy, hogy a tulajdonságpanelen a ControlSource sorba bírjuk a Munka2!H1-et.

Most jön az OK gomb. Először is nevezzük el úgy, hogy a tulajdonságmezőbe a (Name) sorba beírjuk az ok szót. Most pedig egy igen érdekes dolog jön, hiszen funkciót kell hozzá rendelni, mégpedig azt, hogy ha rákattintunk, akkor zárja be a panelt.

Kattintsunk rá kétszer, és nézzük meg mi történik. A Visual Basic átmegy kódszerkesztő módba és létrehozza az adott gomb adott tevékenységéhez tartozó kód kezdő és zárótagját. (Ugyanezt érjük el a helyi menü View Code pontjával.) A kódszerkesztőben minden gomb minden tevékenységéhez (kattintás, dupla kattintás, egér fölé vitel, stb.) önálló kódot készíthetünk, így például megtehetnénk azt is, hogy más történjen a gombra való kattintáskor és dupla kattintáskor.


Ebben segítségünkre van a két felső legördülő mező, ami az elkészített panelelemeket, illetve az azoknál használható tevékenységeket tartalmazzák. Azt persze, hogy az adott esemény bekövetkeztekor mi történjen, mindenképpen nekünk kell beprogramozni. Jelen esetben nincs bonyolult dolgunk, csak annyit kell tenni, hogy bezárjuk a kieg nevű panelt, amit a kieg.hide utasítással érünk el. A kód tehát így fog kinézni: Private Sub ok_Click() kieg.Hide End Sub

Ezzel az OK gomb szerepe is elkészült. De mi is történik miután bevittük az adatokat? Visszatérve a makrónkhoz (kattintsunk a baloldali lista Module1 sorára) láthatjuk, hogy a bevitt alapanyag és ár mezőket át kellett másolnunk a listánk utolsó sorába, majd ábécébe rendezni a listát, végül visszatérni az első lapra.

Ez a módszer persze számos dologgal kiegészíthető, hiszen nem ellenőrzi a bevitt adatokat, nincs mégsem gombunk, nem írja ki, hogy esetleg van már ilyen alapanyag, stb. Ráadásul a legördülő elem is csak húsz sor megjelenítésére van beállítva, így aztán annál többet már hiába viszünk fel.

7.2. Életjáték

Az életjátékot egy matematikus találta ki, s valójában nem is játék, hanem csupán egy szimuláció. A dolog lényege, hogy egy kezdeti négyzetháló egyes pontjait élő sejteknek nevezünk ki, majd a túlélés és elpusztulás szabályait megtartva iterációkon keresztül figyeljük a változásokat. A szabályok szerint a sejt túléli az iterációt, ha két vagy három szomszédja van, elpusztul, ha kettőnél kevesebb (elszi-getelődés), vagy háromnál több (túlnépesedés) szomszédja van. Új sejt születik viszont minden olyan cellában, melynek környezetében pontosan három sejt található. A szomszédos cellák alatt az átlós irányba vett szomszédokat is beleszámítjuk.

Kiinduló állapot 1. iteráció 2. iteráció


Az iterációkat elvileg a végtelenségig folyathatjuk, de az esetek jelentős részében nem érdemes, mert vagy elpusztul az összes sejt, vagy beáll egy állandósult állapotra, vagy pedig egy dinamikus, önmagát adott lépésenként megismétlő állapot keletkezik. Persze ez az állapot gyakran csak több ezer iteráció után jön létre.

Miután nagyvonalakban átnéztük az elveket, nézzük meg, hogy miként lehet egy ilyen szimulációt az Excelben létrehozni. Az Excel persze egyáltalán nem erre való, és minden bizonnyal egy ilyen feladatot sokkal egyszerűbben megoldhatnánk más programnyelven, de pont ez a kihívás. Ez a példa jól tudja szemléltetni az adott helyzetből való új állapot létrehozását, valamint a tömbök és ciklusok kezelését.

Első ránézésre azt gondolnánk, hogy a feladat megoldása úgy kivitelezhető, hogy végigmenve a rácson annak minden pontján meghatározzuk a következő iterációban felvenni kívánt állapotot. A dolog egyetlen szépséghibája, hogy ha így tennénk, akkor folyamat során az egyik cellában már az új, n+1-edik, a mellette lévőben pedig még csak az n-edik iteráció állapota lenne, ami azt eredményezné, hogy ezen cella új állapotának meghatározásakor már nem tudnánk, hogy valójában hány szomszédja volt, hiszen a szomszédjainak egy része, már megváltozott. Ezt kiküszöbölendő egyszerre kellene kiszámolni az összes cellát, majd egyszerre visszaírni az új állapotokat. Belátható, hogy erre a párhuzamos számolásra az Excel önmagában nem képes, viszont ha az új állapotokat változókban tároljuk addig, amíg nem történik meg minden cella kiszámítása, majd ezen változókat írjuk vissza a táblázatba, akkor nyert ügyünk van. Persze ennyi változót nem célszerű egyenként használni, ráadásul egy kétdimenziós területről lévén szó definiálni sem igazán lehetne. Van viszont lehetőség tömbök használatára, aminek a kétdimenziós változata pontosan az ilyen jellegű adattárolásokhoz való.

A feladat persze sokféleképpen megoldható, megtehetjük azt is, hogy az adatok tömbbe való beolvasásakor programból számoljuk meg a szomszédok számát és azt egy feltételvizsgálat segítségével értékeljük ki, majd írjuk be a megfelelő adatot a tömbbe. Ez a módszer azonban kilencszer annyi cellabeolvasást igényelne, mint ha csak egy cellát olvasnánk be, hiszen minden cella esetén a szomszédokat is meg kellene nézni. Ez a művelet viszont Excelben sajnos nagyon lassú, ezért jobban járunk, ha létrehozunk egy a játéktérrel azonos méretű táblarészt, ahol megszámoltatjuk a szomszédos sejtek számát és egy másikat, ahol ezek alapján a


táblázatbeli függvényekkel számoltatjuk ki a következő állapotot. Ezt a táblázatrészt aztán beolvassuk a tömbbe, majd ezután a tömbünk tartalmával már nyugodtam felülírhatjuk az eredeti játékteret. Persze ez sem lesz villámgyors, de a célnak tökéletesen megfelel.

A példánkban a játéktérnek az Excel táblázatának 1-től 20-ig terjedő sorait és A-tól Z-ig terjedő oszlopait jelöltük ki. Ez egy 20x26-os terület, ami már jól be tudja mutatni a játék lényegét. Tételezzük fel, hogy az élő sejteket a cellákba írt 1 érték jelenti (a 0 pedig, hogy nincs élő sejt). Egy kis formázás azért nem árt, mielőtt nekilátnánk a dolognak, ezért állítsuk be az A-Z oszlopszélességeket úgy, hogy nagyjából négyzetesek legyenek a cellák. (Ez kb. a 2-es értéket jelenti.) Hasznos, ha csinálunk esetleg rácsozást vagy hátteret is ezen a területen. A látványosság kedvéért a táblázatra tegyük a betűszínt a háttérszínnel azonossá és erre a területre állítsunk be feltételes formázást is, hogy jobban látszódjanak az élő sejtek. Ez esetben a cellakijelölési szabályok közül a „nagyobb, mint” funkciót kell választanunk, és beállítanunk úgy, hogy a 0,5-nél nagyobb értékű cellák háttere piros, betűszíne fekete legyen (persze más színeket is használhatunk).

A következő dolog a játéktér mellett a szomszédos cellák számát megadó táblázatrész létrehozása. Itt a szélső sorokat és oszlopokat kihagyjuk, mivel a játéktéren kívül lévő területekkel nem lenne érdemes foglalkozni, ezért ezek úgysem adnának értelmes ered-ményt.

Írjuk be tehát az AB2 cellába az =A1+A2+A3+B1+B3+C1+C2+C3 képletet, majd másoljuk ezt le az AB2:AY19 terület minden cellájába (Ezt egyszerű sarokhúzással vagy vágólappal megtehetjük) Ha jól csináltuk, akkor az AY19 cellában az =X18+X19+X20+Y18+Y20+Z18+Z19+Z20 képletnek kell lennie. Ezzel most már elkészült a területünk, ami megmutatja a szomszédos cellák számát.

Ezen terület adatait felhasználva most hozzuk létre a következő állapot kiszámítására használható függvényeket. E célra használjuk az A21:Z40 cellatartományt. A túlélési logika szerint tehát, ha a cellában 1 van és a szomszédos cellák összege 2 vagy 3, akkor marad az 1, viszont ha 0 van a cellában, de a szomszédos cellák összege 3, akkor ott is 1 lesz. Minden más esetben 0 kerül a cellába. Ez azonban egyszerűsíthető, hiszen látható, hogy függetlenül az eredeti állapottól mindenképpen 1 lesz egy cellában, ha a szomszédjai számának összege 3. Így aztán a túlélésnek csak azt a részét kell megnéznünk még, hogy ha a cellában 1 van és a szomszédjai száma 2. Ezen logika


mentén az A21 cellába az =HA(VAGY(ÉS(AA1=2;A1=1);AA1=3);1;0) függvényt írva, majd a cellát lemásolva az egész A21:Z40 területre, már ez a terület a helyes túlélési és születési adatokat adja a következő iterációra vetítve. (Mivel az ÉS függvénnyel azt vizsgáltuk, hogy a cellában 1 van és a szomszédjainak száma 2, majd ezt kiegészítettük azzal, hogy függetlenül mindentől, ha a szomszédok száma 3, akkor a cellában 1 lesz, egyébként meg 0.)

Most már nem maradt más hátra, mint elkészíteni a makróprogramunkat, ami beolvassa az A21:Z40 cellatartományt egy tömbbe, majd ezt a tömböt visszaírja az A1:Z20 területre. Ehhez készítsünk egy gomb űrlapelemet a Fejlesztőeszközök szalag, Beszúrás gomb, Gomb űrlapelem segítségével és a Makró-hozzárendelés panelen az Újat gombra kattintva kezdjünk hozzá a makró megírásának az alábbiak szerint: Sub kovetkezo() A makró neve más is lehet, de akkor azt kell hozzárendelni. Dim beiras Dim ertek(0 To 25, 1 To 20) Dim ciklusa Dim ciklusb Dim masodik Dim tomb tomb = Array("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z")


masodik = ciklusb + 20 beiras = tomb(ciklusa) & masodik ertek(ciklusa, ciklusb) = Range(beiras)



beiras = tomb(ciklusa) & ciklusb Range(beiras) = ertek(ciklusa, ciklusb)


End Sub


Ezzel lényegében el is készültünk. Írjuk tetszés szerint egyeseket az A1:Z20 területre, majd a gombra kattintgatva nézzük meg az újabb és újabb iterációkat.

7.3. Számológép Excel táblázatban párbeszédpanellel

Készítsünk egy olyan számológépet, amely egy önálló ablakban nyílik meg egy gombra való kattintás hatására és amelyben a szokásos alapműveletek elvégzésére van lehetőség.

Bár egy ilyen számológépnek nem sok értelme lenne egy Excel táblázat esetében, a példán keresztül viszont nagyon jól megismerhetjük a panelek szerkesztését és a hozzájuk kap-csolódó eseménykódokat.

A táblázattal most nem fogunk foglalkozni, bár a néhány segédcellára szükségünk lesz, amire most az


A1:A4 cellákat fogjuk használni. Az indításhoz azonban egy nyomógombra szükségünk lesz. Készítsünk tehát egy gomb űrlapelemet a Fejlesztőeszközök szalag, Beszúrás gomb, Gomb űrlapelem segítségével és a Makró-hozzárendelés panelen az Újat gombra kattintva kezdjünk hozzá a makró megírásának az alábbiak szerint:

Sub szamologep() A makró neve más is lehet, de akkor azt kell hozzárendelni. calc.Show End Sub

A makróprogramunknak más dolga nem is lesz, csupán elindítani a párbeszédpanelt, aminek majd a calc nevet fogjuk adni. Ezt azonban meg kell szerkeszteni és meg kell írni a gombokhoz tartozó programkódokat is.

Hozzuk létre tehát a párbe-szédpanelt. Ehhez a Visual Basic ablakában válasszuk az Insert menü UserForm pontját.

Nevezzük át a panelünket Calc-ra úgy, hogy kattintsunk rá a jobb egérgombbal, válasszuk a Properties pontot a helyi menüből, majd az így megjelenő jobboldali tulajdonságmezőbe a (Name) sorba beírjuk a calc szót. Adjuk meg a panel címét is: írjuk a Caption sorba a számológép szöveget.

Ezt követően el kell készítenünk a kijelzőt és a gombokat. Ha visszakattintunk a panelra, ismét megjelennek az eszközök a szerkesztéshez. A pöttyözés csak a pontos igazításban segít, a végleges panelen nem fog látszódni. Most válasszuk a TextBox elemet és húzással rajzoljuk meg a kijelzőnket, illetve a CommandButton elemet választva a gombokat. Ha bármelyiket elrontottuk volna húzással, illetve a sarkain lévő négyzetek húzásával korrigálhatunk mindent.

Folytassuk a munkát a kijelző beállításával. Kattintsunk rá, majd a tulajdonságpanel (Name) mezőjébe írjuk be a kijelző szöveget és


csatoljuk hozzá az A1 mezőt úgy, hogy a tulajdonságpanelen a ControlSource sorba bírjuk az A1-et. Ez nagyon fontos lépés, hiszen így tudjuk elérni, hogy a mezőben és a cellában lévő adatok azonosak legyenek. Ezek után a kijelző formázása van még hátra, kattintsunk a font sorra, majd a megjelenő három pontra és állítsuk át 16 pontos félkövérre a szöveget.

A gombok formázása egy kicsit hosszadalmas feladat lesz, hiszen minden gombon meg kell tennünk a szükséges beállításokat. Kezdjük a bal felsővel, ami a 7-es gomb. Kattintsunk rá, majd kattintsunk a tulajdonságpanel font sorára, illetve a megjelenő három pontra és állítsuk át 20 pontos félkövérre a szöveget. A (Name) sorba írjuk a Gomb7 szövet, a Caption sorba a 7-et. Csináljuk meg ezt az összes gombbal is az alábbi lista alapján:

(Name) Caption (Name) Caption (Name) Caption gomb1 1 gomb2 2 gomb3 3 gomb4 4 gomb5 5 gomb6 6 gomb7 7 gomb8 8 gomb9 9 gomb0 0 gombce CE gombC C gombper / gombszorzas X gombegyenlo = gombplus + gombminus –

Úgy is csinálhatjuk, hogy egy gombot elkészítünk, majd vágólapra téve beillesztgetjük többször. Ez esetben a formázást és a méretre igazításokat megspórolhatjuk, a tulajdonságpanelen végzett név és felirat-beállításokat azonban mindenképpen el kell végezni. A feliratot persze a gombra kattintva is tudjuk módosítani.


Ezzel elneveztük a gombokat és elkészítettük a feliratokat is rajtuk. Nincs más hátra, mint a legérdekesebb feladat, leprogramozni, hogy melyik gomb megnyomásakor mi történjen. Ez a kód azonban nem a makróprogramunkban fog elhelyezkedni, hanem a párbeszédpanelhez fog tartozni, ezért a felvitele is egy kicsit másként történik.

Kattintsunk valamelyik gomb-ra kétszer, és nézzük meg mi történik. A Visual Basic átmegy kódszerkesztő módba és létre-hozza az adott gomb adott tevékenységéhez tartozó kód kezdő és zárótagját. (Ugyanezt érjük el a helyi menü View Code pontjával.) A kódszerkesztőben minden gomb minden tevékenységéhez (kattintás, dupla kattintás, egér fölé vitel, stb.) önálló kódot készíthetünk, így például megtehetnénk azt is, hogy más történjen a 7-es gombra való kattintáskor és dupla kattintáskor.

A kód felvitele történhet úgy is, hogy egyenként duplán kattintunk a gombokra és meghatározhatjuk mindegyik tennivalóját, de ha tudjuk a gombok neveit, úgy az is jó módszer, ha csak az egyikkel lépünk be a kódszerkesztőbe és itt már az összes gombhoz tartozó kódot beírjuk. Ebben segítségünkre van a két felső legördülő mező, ami az elkészített panelelemeket, illetve az azoknál hasz-nálható tevékenységeket tartalmazzák. Azt persze, hogy az adott esemény bekövetkeztekor mi történjen, mindenképpen nekünk kell beprogramozni.

Mivel azonban egy műveletnél nem csupán a kijelzőn lévő számra van szükség, hanem az előtte leütött műveleti jelre, illetve az előtt bevitt számra is, ezért azokat is el kell tárolnunk a táblázatban, sőt azt is tudnunk kell, hogy mikor kezdünk új számot gépelni (A1-A4 cellák).

Jelen esetben egy számjegy megnyomásakor az A1-es cellában tárolt kijelző értéket kell megtoldani az adott jeggyel, ami lényegében az ott lévő szám megtízszerezését, majd a lenyomott szám hozzáadását jelenti az 0-tól 9-ig terjedő számbillentyűknél. (Most a tizedesekkel nem foglalkozunk, de ha valakinek van kedve, kiegészítheti úgy is a programot.) Ezt a funkciót kell tehát beírni ezekhez a rutinokhoz, ami a Range("a1") = Range("a1") * 10 + n utasítást jelenti. Ez alól kivételt képez az az eset, amikor művelet után végezzük a számbevitelt, ezért erre egy kis vizsgálatot is el kell


végezni. Mivel azonban ez minden szám esetén ugyanaz, nem írjuk be mindegyik kódba, hanem létrehoztunk neki egy külön szamelso nevű rutint, amit meghívunk.

A CE gomb az utolsó jegy törlését valósítja meg, ami lényegében a tízzel való osztás és lefelé kerekítés. (Jelen esetben kivontunk 4-et és úgy kerekítettünk, mivel a round függvény öt tizedtől felfele kerekítene és nekünk az utolsó jegy törlése kell.)

A C gomb feladata viszonylag egyszerű, ki kell törölni mindent. A bevitt számot, a műveletet, és az előtt bevitt számot is.

A műveleti jelek (és az egyenlőségjel) esetében a tennivaló majdnem ugyanaz, hiszen végrehajtani nem a megnyomott műveleti jelnek megfelelő műveletet kell, hanem az az előttit. Ha például az 1 + 2 - 3 gombokat nyomjuk le, úgy a kivonás gomb megnyomásakor az előző összeadást kell elvégezni. Emiatt tehát el kell tárolnunk az utolsó műveletet, amit majd a következő műveleti jel vagy az egyenlőség megnyomásakor kell elvégeznünk. Így aztán a legjobb módszer, ha erre is készítünk egy külön rutint, amit meghívunk a műveleti jelek gombjainak megnyomásakor, majd ezután rögzítjük az új műveleti jelet. Ez a szamol nevű rutin egy elágazáskezeléssel elvégzi a kívánt műveletet, majd visszatér a kívánt művelet kódjához. Arra azonban fel kell készíteni, hogy egy osztás során nulla is lehet az utolsó szám, ami a program hibával való leállását eredményezné, így egy feltételvizsgálatot is beiktatva az osztást nulla esetén nem engedjük elvégezni.

Nézzük tehát a teljes kódsort:

Private Sub kijelzo_Click() Range("a1").Show End Sub

Private Sub gomb1_Click() szamelso Range("a1") = Range("a1") * 10 + 1 End Sub



Private Sub gomb4_Click() szamelso


Range("a1") = Range("a1") * 10 + 4 End Sub






Private Sub gomb0_Click() szamelso Range("a1") = Range("a1") * 10 End Sub

Private Sub gombce_Click() Range("a1") = Round((Range("A1") - 4) / 10, 0) End Sub

Private Sub gombc_Click() Range("a1") = 0 Range("a2") = 0 Range("a3") = 0 End Sub

Private Sub gombplus_Click() If Range("a3") > 0 Then szamol Range("a3") = 1 Range("a4") = 1 End Sub

Private Sub gombminus_Click() If Range("a3") > 0 Then szamol Range("a3") = 2 Range("a4") = 1 End Sub

Private Sub gombszorzas_Click() If Range("a3") > 0 Then szamol Range("a3") = 3


Range("a4") = 1 End Sub

Private Sub gombper_Click() If Range("a3") > 0 Then szamol Range("a3") = 4 Range("a4") = 1 End Sub

Private Sub gombegyenlo_Click() If Range("a3") > 0 Then szamol Range("a3") = 0 Range("a4") = 1 End Sub

Sub szamelso() If Range("a4") = 1 Then Range("a2") = Range("a1") Range("a1") = 0 Range("a4") = 0 End If End Sub

Sub szamol() Select Case Range("a3") Case 1 Range("a1") = Range("a2") + Range("a1") Case 2 Range("a1") = Range("a2") - Range("a1") Case 3 Range("a1") = Range("a2") * Range("a1") Case 4 If Range("a1") <> 0 Then

Range("a1") = Range("a2") / Range("a1") End If Case Else Range("a1") = 0 End Select End Sub

A fenti számológépnek persze még rengeteg hiányossága van, nem kezeli például a tizedes számokat, stb., de nem is az volt a célunk, hogy egy profi számológépet készítsünk, hanem hogy bemutassuk az ilyen jellegű lehetőségeket.

7.4. Nyilvántartó

Készítsünk egy egyszerű nyilvántartó programot termékek eladása, beszerzése és raktárkészlet nyilvántartása céljából. A termékeket vonalkód alapján tartsuk nyilván. Ha van vonalkódolvasónk, úgy könnyű dolgunk lesz, mert azzal pillanatok


alatt beazonosíthatjuk a termékeket. Ennek hiányában használhatunk egyszerű kódokat is. Fontos, hogy csak azokat a termékeket engedje eladni a rendszer, amiből készletünk is van. Mindemellett szükséges, hogy legyen lehetőség új termék rögzítésére és új beszállító felvitelére is, illetve szükség esetén meg tudjuk változtatni a termékek adatait is. A táblát úgy kell elkészíteni, hogy a beviteli oldalakon csak azok az adatok legyenek módosíthatók, amikre valóban szükség van, a többi cellára rá se tudjunk lépni. Figyelnünk kell az olyan lehetőségekre is, hogy a felhasználó nem létező vonalkódot ad meg, vagy nulla darabot akar eladni, stb.

Mivel jelen példa beviteli célokra az Excel munkalapjait használja, ezért sajnos a nyomógombokat csak akkor tudjuk aktiválni, ha entert is ütöttünk az adatbevitel után (tehát a kurzorunk nem a szerkesztőlécen áll). Ez persze kiküszöbölhető, ha párbeszéd-panelokat használunk, de annak elkészítése jóval nagyobb munkával jár. (Akinek van kedve hozzá, átalakíthatja.)

A példát próbáltuk úgy elkészíteni, hogy ahol többféle lehetőség is létezett, ott bemutattuk a különféle megoldásokat. A példa persze további funkciókkal is kiegészíthető, megoldhatunk vele az áfakezeléstől kezdve a vevőnyilvántartáson át egészen a kedvezmények kezeléséig igen sok mindent. A mintával viszont már így is számos dolgot gyakorolhatunk, például az adatbeviteli módokat, vezérlőelemeket, az adatbázis-kezelő függvények haszná-latát, a lapváltásokat, az automatikus adatkitöltéseket, a programból való másolásokat, rendezéseket, feltételvizsgálatokat, stb.

Az elkészítés során első lépésben készítsük el a táblákat, azaz az eladási és beszerzési panelt, az új termék, új beszállító felvitelére szolgáló panelt, az eladások és beszerzések nyilvántartásait és a kimutatások készítésére szolgáló táblát.

A formázásokat nem fogjuk egyenként kirészletezni, mivel feltételezhetően aki már itt tart az Excel kezelése során, azoknak ez már könnyedén megy, ráadásul az ábrákról lepuskázhatók. Ami talán említést érdemel az az, hogy a vonalkódokra szolgáló mezőknél számformátumot használjunk tizedesek nélkül, mivel automatikusan exponenciális formát venne fel az Excel a sok számjegy miatt.

A betűméretek, betűtípusok, cellaszélességek és magasságok a mintaábrákon látszódnak, a háttérszínek tetszőlegesek lehetnek, mi a szürke különféle árnyalatait használtuk. A mintában látható módon meghagytuk azokat a számokat, amik csupán az ellenőrzéseket, feltételvizsgálatokat szolgálják, (Pl. Eladas!G6, kimutatasok!K2:L3,


stb.) a végleges állapotban ezeket célszerű a háttérszínnel azonos betűszínűre állítani, hogy ne zavarja a felhasználókat.

Bár jelen esetben a lapok közti váltásra gombokat készítettünk, használhatunk egyszerű hiperhivatkozást is a Beszúrás fülről.

Fülek elnevezéseinél nem használtunk ékezetes karaktereket, ettől persze el lehet térni, de akkor konzekvensen járjunk el a programban való hivatkozások használata során is.

Az beszallitok lap:

Itt semmi különleges nincs, a lap csupán adattárolásra szolgál. Egyedüli fontos dolog az A1-es cellában lévő függvény, ami azért szükséges, hogy a makró tudja, hogy melyik sorba kell majd beírni a következő beszállítót rögzítés esetén. Az A1 cella tartalma tehát: =SZÖVEG(DARAB2(B3:B1000)+3;"#####")

A lapot nem szükséges induló adatokkal feltölteni, elég azt csupán a harmadik sorig elkészíteni. A 4. sortól lefelé már a beszállítói rögzítésre szolgáló lapon tudjuk az adatokat felvinni.

Az eladasok panel:

A lap szintén adattárolásra szolgál. Az A1 cella viszont itt is fontos. Tartalma: =SZÖVEG(DARAB2(A3:A10000)+3;"#####")

A lapot szintén nem szükséges induló adatokkal feltölteni, ezt is elég a harmadik sorig elkészíteni. Már csak azért sem, mert elvileg itt nincsenek is induló adatok. A 4. sortól lefelé az adatok már az eladások során fognak az oldalon létrejönni.


A beszerzesek panel:

A lap szintén adattárolásra szolgál és szinte teljesen megegyezik az eladasok lappal, ezért úgy járunk a legjobban, ha arról készítünk egy másolatot. Az A1 cella viszont itt is fontos. Tartalma azonos az eladasok lapon lévőével: =SZÖVEG(DARAB2(A3:A10000)+3;"#####")

A lapot szintén nem szükséges induló adatokkal feltölteni, ezt is elég a harmadik sorig elkészíteni. Már csak azért sem, mert elvileg itt sincsenek induló adatok. A 4. sortól lefelé az adatok már a beszerzések rögzítése során fognak az oldalon létrejönni.

Az termekek panel:

Ez a lap is elsődlegesen adattárolásra szolgál, bár itt már vannak számítások is. Szintén fontos dolog az A1-es cellában lévő függvény, ami azért szükséges, hogy a makró tudja, hogy melyik sorba kell majd beírni a következő terméket rögzítés esetén.

A panelen az alábbi cellák tartalmaznak képletet:

A1 =SZÖVEG(DARAB2(A3:A9998)+3;"#####") F1 =SZUMHA(beszerzesek!B$4:B$10000;A1;beszerzesek!C$4:C$10000) G1 =SZUMHA(eladasok!B$4:B$10000;A1;eladasok!C$4:C$10000) H1 =F1-G1 I1 =SZUMHA(beszerzesek!B$4:B$10000;A1;beszerzesek!E$4:E$10000) J1 =SZUMHA(eladasok!B$4:B$10000;A1;eladasok!E$4:E$10000)


K1 =J1-I1 K2 =SZUM(K4:K998)

A lapot nem szükséges induló adatokkal feltölteni, elég azt csupán a harmadik sorig elkészíteni. A 4. sortól lefelé már a termékek rögzítésre szolgáló lapon tudjuk az adatokat felvinni. Ez esetben azonban az F..K oszlopokat – mivel azok számolt értéket tartalmaznak – úgy tudjuk a legegyszerűbben feltölteni, ha az F1:K1 cellák tartalmát lemásoljuk. (A makró is ezt teszi.) Manuális feltöltés esetén azonban nagyon fontos, hogy az adatok vonalkód szerint növekvő sorrendben kövessék egymást.

Az Eladas lap:


D4 =MA() D10 =FKERES(D8;termekek!A$4:J$998;2) D12 =D6*G8 G6 =DARABTELI(termekek!A4:A1000;D8) G8 =G10 G10 =FKERES(D8;termekek!A$4:J$998;5) G12 =FKERES(D8;termekek!A$4:J$998;8)


A D6 cella mellett lévő léptetőnyilat a Fejlesztőeszközök szalag Beszúrás gombjának Léptetőnyíl űrlapvezérlő elemének beszúrásával tudjuk megrajzolni, majd a jobb egérgombbal előhívható helyi menüjének Vezérlő formázása pontjánál a cellacsatoláshoz a $D$6 cellahivatkozást kell bevinni.

A Beszerzés, Termékadat módosítás, Kimutatások és Eladás gombokat a Fejlesztőeszközök szalag Beszúrás gombjának Gomb űrlapvezérlő elemének beszúrásával tudjuk megrajzolni, majd miután elkészültek a makrók, úgy a jobb egérgombbal előhívható helyi menüjének Makró hozzárendelés pontjánál az alábbi makrókat hozzárendelni: Beszerzés: lapvaltas_beszerzes Termékadat módosítás: lapvaltas_termekadatok Kimutatások: lapvaltas_kimutatasok Eladás: eladas

A D6, D8, G8 cellák esetében kapcsoljuk ki a cellák zárolását, majd kapcsoljuk be a lapvédelmet. Ehhez jelöljük ki a fenti cellákat majd kattintsunk a Kezdőlap szalag Szám mezőjének jobb alsó sarkában lévő jelre. A megjelenő panelen válasszuk a Védelem fület, majd távolítsuk el a pipát a Zárolt szöveg előtti négyzetből és OKézzuk le a panelt.

A Beszerzes lap:

A panel elkészítésének legegyszerűbb módja, ha az Eladas panelről készítünk egy másolatot, majd átírjuk az eltérő szövegeket, képleteket. A panelen az alábbi cellák tartalmaznak képletet: D4 =MA() D10 =FKERES(D8;termekek!A$4:J$998;2) D12 =D6*G8 G6 =DARABTELI(termekek!A4:A1000;D8)


G8 =G10 G10 =FKERES(D8;termekek!A$4:J$998;4) G12 =FKERES(D8;termekek!A$4:J$998;8) D14 =FKERES(FKERES(D8;termekek!A$2:J$998;3);beszallitok!A$4:J$1000;2)

A D6 cella mellett lévő léptetőnyilat a Fejlesztőeszközök szalag Beszúrás gombjának Léptetőnyíl űrlapvezérlő elemének beszúrásával tudjuk megrajzolni, majd a jobb egérgombbal előhívható helyi menüjének Vezérlő formázása pontjánál a cellacsatoláshoz a $D$6 cellahivatkozást kell bevinni.

Az Eladás, Termékadat módosítás, Új termék rögzítése és Beszerzés gombokat a Fejlesztőeszközök szalag Beszúrás gombjának Gomb űrlapvezérlő elemének beszúrásával tudjuk megrajzolni, majd miután elkészültek a makrók, úgy a jobb egérgombbal előhívható helyi menüjének Makró hozzárendelés pontjánál az alábbi makrókat hozzárendelni: Eladás: lapvaltas_eladas Termékadat módosítás: lapvaltas_termekadatok Új termék rögzítése: lapvaltas_ujtermek Beszerzés: beszerzes

A D6, D8, G8 cellák esetében kapcsoljuk ki a cellák zárolását, majd kapcsoljuk be a lapvédelmet.


A Termekadatok lap:


D6 =D8 D8 =FKERES(D4;termekek!A$2:J$998;2) D10 =FKERES(FKERES(D4;termekek!A$2:J$998;3);beszallitok!A$4:J$1000;2) D12 =G12 D14 =G14 G8 =SZÖVEG(termekek!A1-SORSZÁM(D4;termekek!A4:A998);"#####") G10 =FKERES(D4;termekek!A$2:J$998;8) G12 =FKERES(D4;termekek!A$2:J$998;5) G14 =FKERES(D4;termekek!A$2:J$998;4)

Az Eladás, Beszerzés, Kimutatások és Adatok módosítása gombokat a Fejlesztőeszközök szalag Beszúrás gombjának Gomb űrlapvezérlő elemének beszúrásával tudjuk megrajzolni, majd miután elkészültek a makrók, úgy a jobb egérgombbal előhívható helyi menüjének Makró hozzárendelés pontjánál az alábbi makrókat hozzárendelni: Beszerzés: lapvaltas_beszerzes Eladás: lapvaltas_eladas Kimutatások: lapvaltas_kimutatasok Adatok módosítása: termekadatmodositas

A D4, D6, D12, D14 cellák esetében kapcsoljuk ki a cellák zárolását, majd kapcsoljuk be a lapvédelmet.


Az ujtermek lap:


D4 =MA() D14 =FKERES(D12;beszallitok!A4:D50;3) G13 =DARABTELI(termekek!A4:A999;ujtermek!D8)

A G13-as cella betűszínét célszerű a háttérszínnel azonosra állítani. A beszállító melletti legördülő lista elkészítéséhez válasszuk a

Fejlesztőeszközök szalag Beszúrás gombjának Beviteli lista űrlapvezérlő elemét, majd rajzoljuk meg a legördülő elemet a D12 cella fölé. Ezt követően kattintsunk rá a jobb egérgombbal, majd a helyi menü Vezérlő formázása pontjával előhívható panel Vezérlő fülénél a cellacsatoláshoz írjuk be a $D$12 hivatkozást, a Bemeneti tartomány sorba pedig a beszallitok!$B$4:$B$50 hivatkozást.

Az Eladás, Beszerzés, Új beszállító és Termék rögzítése gombokat a Fejlesztőeszközök szalag Beszúrás gombjának Gomb űrlapvezérlő elemének beszúrásával tudjuk megrajzolni, majd miután elkészültek a makrók, úgy a jobb egérgombbal előhívható helyi menüjének Makró hozzárendelés pontjánál az alábbi makrókat hozzárendelni: Eladás: lapvaltas_eladas Beszerzés: lapvaltas_beszerzes Új beszállító: lapvaltas_ujbeszallito Termék rögzítése: ujtermek


A D8, D10, D12, G8, G10 cellák esetében kapcsoljuk ki a cellák zárolását, majd kapcsoljuk be a lapvédelmet.

Az ujbeszallito lap:


D4 =MA() F10 =DARABTELI(beszallitok!B4:B50;D6)

Az F10-es cella betűszínét célszerű a háttérszínnel azonosra állítani.

Az Eladás, Beszerzés, Új termék rögzítése és Új beszállító rögzítése gombokat a Fejlesztőeszközök szalag Beszúrás gombjának Gomb űrlapvezérlő elemének beszúrásával tudjuk megrajzolni, majd miután elkészültek a makrók, úgy a jobb egérgombbal előhívható helyi menüjének Makró hozzárendelés pontjánál az alábbi makrókat hozzárendelni: Eladás: lapvaltas_eladas Beszerzés: lapvaltas_beszerzes Új termék rögzítése: lapvaltas_ujtermek Új beszállító rögzítése: ujbeszallito

A D6, D8, D10 cellák esetében kapcsoljuk ki a cellák zárolását, majd kapcsoljuk be a lapvédelmet.


A Kimutatasok lap:

Ez a lap kissé eltér a többitől, mivel összesített információk megadására szolgál. Segítségével számolhatjuk ki egy adott időszakban történt értékesítések és beszerzések bevételi és kiadási adatait, illetve itt van lehetőségünk egy adott termékre vonatkozó minden részletes információt megtudni. A hagyományos összegző vagy matematikai műveletek helyett azonban jelen esetben adatbázis műveleteket kell használnunk, mivel előfordulhat, hogy egy termék beszerzési vagy eladási ára időközben megváltozik, így a táblákban ugyanaz a termék más-más árakon fog szerepelni, aminek összege nem lesz azonos a darabszám és ár szorzatával.

A panelen csupán egy gombot helyeztünk el, amivel vissza tudunk térni az eladási lapra. Ezt a Fejlesztőeszközök szalag Beszúrás gombjának Gomb űrlapvezérlő elemének beszúrásával tudjuk megrajzolni, majd miután elkészültek a makrók, úgy a jobb egérgombbal előhívható helyi menüjének Makró hozzárendelés pontjánál a lapvaltas_eladas makrót hozzárendelni.

A D4, D5 cellák típusát állítsuk dátum formátumúra, a D13-at számra nulla tizedessel.

Képleteket az alábbi cellákba írjunk:

D7 =AB.SZUM(eladasok!A3:E10000;eladasok!E3;K2:L3) D8 =AB.SZUM(beszerzesek!A3:E10000;beszerzesek!E3;K2:L3) D9 =D7-D8 D15 =FKERES($D$13;termekek!$A$4:$K$1000;2) D16 =AB.SZUM(beszerzesek!A3:E10000;beszerzesek!E3;K13:K14) D17 =AB.SZUM(eladasok!A3:E10000;eladasok!E3;K13:K14)


D18 =D17-D16 D19 =FKERES(FKERES($D$13;termekek!$A$4:$K$1000;3);beszallitok!$A$4:$D$50;2) D20 =FKERES(FKERES($D$13;termekek!$A$4:$K$1000;3);beszallitok!$A$4:$D$50;3) D21 =FKERES(FKERES($D$13;termekek!$A$4:$K$1000;3);beszallitok!$A$4:$D$50;4) G15 =FKERES($D$13;termekek!$A$4:$K$1000;6) G16 =FKERES($D$13;termekek!$A$4:$K$1000;7) G17 =FKERES($D$13;termekek!$A$4:$K$1000;8) D19 =FKERES($D$13;termekek!$A$4:$K$1000;4) D20 =FKERES($D$13;termekek!$A$4:$K$1000;5) K3 =">="&D4 L3 ="<="&D5 K14 ="="&D13

Nagyon fontos, hogy a K2, L2 cellákban a dátum, illetve a K13 cellákban a vonalkód szöveg pontosan úgy legyen írva, mint ahogyan az az eladasok és beszerzesek lapok fejléceiben is szerepel. A K és L oszlopok betűszínét célszerű a háttérszínnel azonosra állítani. Ezek a területek határozzák meg ugyanis a feltételt, ami az adatbázisból való összegzés alapját képezi. A3, L3 és K14 cellák fura képletei a feltétel automatikus összeállításában játszanak szerepet.

A D4, D5, D13 cellák esetében kapcsoljuk ki a cellák zárolását, majd kapcsoljuk be a lapvédelmet.

Miután elkészültünk az oldalakkal, kapcsoljuk be a Korrektúra szalagon a lapvédelmeket úgy, hogy a Lapvédelem gombra kattintva a megjelenő panelen csak a Nem zárolt cellák kijelölése sor előtt hagyjuk meg a pipát.

A paneleken a makrók hozzárendelést csak az után tudjuk megtenni, miután a makrók elkészültek. A kód megírása azonban hosszadalmas is lehet, ezért sokszor elegendő csupán a makróírást megkezdeni a kezdő és zárótaggal, a program lényegi részét ráérünk a végén is közéírni.

A jelen nyilvántartóhoz tartozó makrószerkesztőben megírandó programkód a következő:

Sub eladas() Sheets("Eladas").Select letezike = Range("g6") keszlet = Range("g12") datum = Range("D4") vonalkod = Range("D8") mennyiseg = Range("D6")


egysegar = Range("g8") osszertek = Range("D12") If letezike = 0 Then

MsgBox ("Nem létező vonalkód!") Range("d8").Select Else If keszlet >= mennyiseg Then

If mennyiseg = 0 Then MsgBox ("Figyelem! Az eladott mennyiségnél

nulla lett beállítva!") Else

Sheets("eladasok").Select ujsorszam = Range("a1") datumcella = "a" + ujsorszam vonalkodcella = "b" + ujsorszam mennyisegcella = "c" + ujsorszam egysegarcella = "d" + ujsorszam osszesencella = "e" + ujsorszam Range(datumcella) = datum Range(vonalkodcella) = vonalkod Range(mennyisegcella) = mennyiseg Range(egysegarcella) = egysegar Range(osszesencella) = osszertek Sheets("Eladas").Select Range("g8") = "=g10" Range("D6") = 1 Sheets("Eladas").Select Range("d8").Select ActiveWorkbook.Save

End If Else

MsgBox ("Az adott termékből nincs elégkészlet! Rögzítsen készletet, vagy adja el egyedi termékként!")

Range("d8").Select End If End If End Sub

Sub beszerzes() Sheets("Beszerzes").Select letezike = Range("g6") datum = Range("D4") vonalkod = Range("D8") mennyiseg = Range("D6") egysegar = Range("g8") osszertek = Range("D12") If letezike = 0 Then

MsgBox ("Nem létező vonalkód!") Range("d8").Select Else


If mennyiseg = 0 Then MsgBox ("Figyelem! A beszerzett mennyiségnél

nulla lett beállítva!") Range("d6").Select

Else Sheets("beszerzesek").Select ujsorszam = Range("a1") datumcella = "a" + ujsorszam vonalkodcella = "b" + ujsorszam mennyisegcella = "c" + ujsorszam egysegarcella = "d" + ujsorszam osszesencella = "e" + ujsorszam Range(datumcella) = datum Range(vonalkodcella) = vonalkod Range(mennyisegcella) = mennyiseg Range(egysegarcella) = egysegar Range(osszesencella) = osszertek Sheets("Beszerzes").Select Range("g8") = "=g10" Range("D6") = 1 Range("d8").Select ActiveWorkbook.Save

End If End If End Sub

Sub termekadatmodositas() ujsorszam = Range("g8") nev = Range("d6") eladasiar = Range("d12") beszerzesiar = Range("d14") Sheets("termekek").Select nevcella = "b" + ujsorszam beszerzesiarcella = "d" + ujsorszam eladasiarcella = "e" + ujsorszam Range(nevcella) = nev Range(eladasiarcella) = eladasiar Range(beszerzesiarcella) = beszerzesiar Sheets("Termekadatok").Select Range("d6") = "=d8" Range("d12") = "=g12" Range("d14") = "=g14" Range("d4").Select ActiveWorkbook.Save End Sub

Sub ujtermek() If Range("g13") <> 0 Then

MsgBox ("Létező vonalkód!")Else vonalkod = Range("d8")


nev = Range("d10") eladasiar = Range("g10") beszerzesiar = Range("g8") beszallito = Range("d12") Sheets("termekek").Select ujsorszam = Range("a1") vonalkodcella = "a" + ujsorszam nevcella = "b" + ujsorszam beszallitocella = "c" + ujsorszam beszerzesiarcella = "d" + ujsorszam eladasiarcella = "e" + ujsorszam Range(vonalkodcella) = vonalkod Range(nevcella) = nev Range(beszallitocella) = beszallito Range(eladasiarcella) = eladasiar Range(beszerzesiarcella) = beszerzesiar Range("f1:k1").Select Selection.Copy beiras = "f" + ujsorszam Range(beiras).Select ActiveSheet.Paste Range("a4:k1000").Sort Key1:=Range("a4") Range("k2").Select Sheets("Beszerzes").Select ActiveWorkbook.Save End If End Sub

Sub ujbeszallito() If Range("f10") = 1 Then

MsgBox ("Létező Beszállítónév!") Range("d6").Select Else beszallito = Range("d6") cim = Range("d8") tel = Range("d10") Sheets("beszallitok").Select ujsorszam = Range("a1") kod = ujsorszam - 3 kodcella = "a" + ujsorszam beszallitocella = "b" + ujsorszam cimcella = "c" + ujsorszam telcella = "d" + ujsorszam Range(kodcella) = kod Range(beszallitocella) = beszallito Range(cimcella) = cim Range(telcella) = tel Sheets("Beszerzes").Select ActiveWorkbook.Save End If End Sub


Sub lapvaltas_eladas() Sheets("Eladas").Select End Sub Sub lapvaltas_beszerzes() Sheets("Beszerzes").Select End Sub Sub lapvaltas_ujtermek() Sheets("ujtermek").Select End Sub Sub lapvaltas_ujbeszallito() Sheets("ujbeszallito").Select End Sub Sub lapvaltas_termekadatok() Sheets("termekadatok").Select End Sub Sub lapvaltas_kimutatasok() Sheets("kimutatasok").Select End Sub

Röviden kielemezve a programot láthatjuk, hogy mind az eladás, mind az értékesítés esetében a makró beolvassa az adatokat a beviteli panelról, és ellenőrzi, hogy létezik-e az adott vonalkód, ha nem, hibajelzést ad, különben pedig egy újabb ellenőrzés következik arra vonatkozólag, hogy nem nulla-e az eladandó vagy beszerzendő készlet. Eladás esetén még azt is megvizsgálja, hogy van-e elég készlet. Ha minden rendben, úgy átvált az eladás vagy beszerzés lapra, az A1 cellából kiolvassa az első üres sor sorszámát maghatározó képlet eredményét, majd változókba felveszi a cellakoordinátákat. Ezekre a koordinátákra beírja az adatokat, majd visszatér a beviteli panelra, ahol visszaállítja az esetlegesen átírt árat (mivel alapesetben felajánljuk a normál árat, de lehetőség van a terméket más áron is eladni vagy beszerezni). Ezután a mennyiséget egyre állítja, átviszi a kurzort a vonalkód sorba és elmenti a fájlt. Egy nagyon praktikus, de igen egyszerűen kivitelezhető funkciója a makrónak, hogy a termék eladási és beszerzési ára megváltoztatható, az ott lévő képlet számra átírható, de értékesítés vagy beszerzés után mindig visszaírjuk az eredeti ajánlott árat tartalmazó képletet.

Termékadat módosítás esetén beolvassa az adatokat a beviteli panelról, átvált a termékek lapra, majd változókba felveszi a cellakoordinátákat. Ezekre a koordinátákra beírja az adatokat, majd visszatér a beviteli panelra, ahol visszaállítja az átírt adatokat az eredeti hivatkozásokra. (Erre azért van szükség, hogy módosításkor ne kelljen minden adatot újra bevinni, amin nem változtatunk, ott a képlet behozza az eredetit.) A rutin a fájl elmentésével zárul.


Új termék rögzítése esetén egy vizsgálattal kezdünk, nehogy véletlenül egy létező vonalkódot megadva ugyanazon kód alatt több termék is szerepelhessen. Ha a vonalkód nem létezik, úgy az adatok beolvasása, a termékek lapra váltás, az első üres sor számának beolvasása, a cellaadatok meghatározása, majd az adatok lista végére való beírása következik. Mivel azonban ez a tábla számolt adatokat is tartalmaz, amik az első sorban már megvannak, a program kijelöli az F1:K1 területet, majd bemásolja ezt abba a sorba, ahova az adatok is kerültek. Természetesen lehetőség lenne a képleteket programból is felvinni, de ez így egyszerűbb, és nem árt, ha erre is látunk példát. Ezzel azonban még nincs minden rendben, mert az új termékünk a lista végén van, és a termékekre vonatkozó FKERES függvény csak akkor szolgáltat helyes eredményt, ha a lista rendezett. A program emiatt berendezi a termékeket tartalmazó területet vonalkód szerint növekvő sorrendbe. Végül kurzoráthelyezéssel, lapváltással és mentéssel zárul a funkció.

Az új beszállító rögzítésére szolgáló rész ellenőrzi, hogy létezik-e a megadott nevű beszállító, s ha igen, úgy hibajelzést ad, ha pedig nem, úgy rögzíti az új beszállító adatait. Ehhez beolvassa az adatokat a beviteli panelról, átvált a beszállítók listáját tartalmazó lapra, az A1 cellából kiolvassa az első üres sor sorszámát maghatározó képlet eredményét, melyből meghatározza az új beszállító kódját és változókba felveszi a cellakoordinátákat. Ezekre a koordinátákra beírja az adatokat, majd visszatér a beszerzés panelra, végül elmenti a fájlt.

A program végén a lapvaltas-sal kezdődő makrók vannak, ezek csupán a különböző panelek közti váltásra szolgálnak.

Ha még jobban el kívánjuk dugni az Excelt a nyilvántartónkból, úgy tüntessük el a sor és oszlopazonosítókat, a fejléceket, valamint a rácsvonalakat a Nézet szalag Megjelenítés mezőjében lévő összes pipa eltávolításával.

A táblázat és a program a fentiek szerint úgy lett elkészítve, hogy korlátozott mennyiségű adat tárolását teszi csak lehetővé, így kb. 50 beszállító, 1.000 termék és 10.000 értékesítés és beszerzés rögzíthető vele. Ez persze még egy normál üzletnél is elegendő lehet egy évre, de ezek az értékek könnyedén módosíthatók is, minimális sebességcsökkenés árán. Nagy adatbázis esetén azonban inkább az állandó mentések fogják lelassítani a használatot, erre viszont szükség van, mert egy átlagos felhasználótól nem várhatjuk el, hogy ilyenre külön gondoljon, s ha csak egyszer is nemet nyom véletlenül a


kilépéskor feltett, mentésre vonatkozó kérdésre, úgy az egész aznap rögzített munka és adatmennyiség elvész.

7.5. Új táblázat generálása ügyféladatokból

Tételezzük fel, hogy van egy nyilvántartásunk, amiből szeretnénk adott ügyfélhez tartozó kimutatást készíteni egy külön táblázatba. Ezt az új Excel fájlt teljesen automatikusan kell létrehoznunk egy másik táblázatban lévő adatok alapján, majd meg kell csinálni a szükséges formázásokat, végül egy generált névvel el kell mente-nünk.

A példához használjuk fel az előző pontban elkészített nyilván-tartó programunkat, hiszen ott már vannak adatok, amiket fel tudunk adott esetben használni. A feladat azonban jóval összetettebb annál, mint elsőre látszik, hiszen sem az értékesítéseknél, sem pedig a beszerzéseknél nincs nyilvántartva, hogy az adott terméknek ki volt a beszállítója. Emiatt először össze kell állítani a terméklistát, majd utána már meg lehet csinálni a szükséges számításokat. Mindezt most úgy oldottuk meg, hogy egy külön lapra ezeket a programmal elkészíttettük, majd ezt a lapot egy tömbbe másoltuk, végül a tömböt kiírtuk egy új munkafüzetbe, amit végül megformáztunk.

A kigyűjtés céljára létrehoztunk egy ugyfelkimutatas nevű lapot, ami tartalmazza a fejlécet, illetve ahova a makrónk majd összegyűjti a szükséges adatokat. Ennek megfelelően készítsük el ezt a lapot az ötödik sorig az alábbi ábrának megfelelően. (A hatodik sortól az adatokat már a program fogja feltölteni, azt nem kell bevinni.)


Képletek az alábbi sorokban szerepelnek:

B2 =FKERES(kimutatasok!$D$25;beszallitok!A$4:D$50;2) B3 =FKERES(kimutatasok!$D$25;beszallitok!A$4:D$50;3) E2 =MA() G2 =DARAB2(B6:B10000)

Képletek természetesen az adatokat tartalmazó sorokban is lesznek, eltérően viszont az előbbi példától, a gép által feltöltött sorokban szereplő képletet most nem másoljuk, hanem a programból íratjuk be.

Az oldalt persze beformázhatjuk, így a B6:B1000 cellák típusát átállíthatjuk nulla tizedesjegyet tartalmazó számmá, de ennek most akkora jelentősége nincs, mivel a végleges új fájlban a formázásokat a programnak kell elvégeznie.

Ha megvagyunk a segédlappal, akkor már csak a kimutatasok lapot kell kiegészítenünk úgy, hogy lehetőség legyen onnan ügyfelet választva elindítani a munkát. Ehhez először kapcsoljuk ki a lapvédelmet a Korrektúra szalagon. Egészítsük ki a panelt az ábra szerint, készítsük el a beszállító kiválasztására szolgáló legördülő listát, melyhez válasszuk a Fejlesztőeszközök szalag Beszúrás gombjának Beviteli lista űrlapvezérlő elemét, majd rajzoljuk meg a legördülő elemet a D25 cella fölé. Ezt követően kattintsunk rá a jobb egérgombbal, majd a helyi menü Vezérlő formázása pontjával előhívható panel Vezérlő fülénél a cellacsatoláshoz írjuk be a $D$25 hivatkozást, a Bemeneti tartomány sorba pedig a beszallitok!$B$4:$B$50 hivatkozást.

Most hozzuk létre az Ügyfél kimutatás készítése gombot a Fejlesztőeszközök szalag Beszúrás gombjának Gomb űrlapvezérlő elemének kiválasztásával. Rajzoljuk meg a gombot, majd a megjelenő Makró-hozzárendelés panelen adjuk meg az ugyfelkimutatas makrónevet és kattintsunk az Újat gombra. Vigyük be az alábbi programot, végül állítsuk vissza a lapvédelmet a Korrektúra szalagon.


Sub ugyfelkimutatas() ugyfel = Range("d25") Sheets("termekek").Select Dim termek(1 To 1000) ugyfeltermeke = 0 For i = 1 To 1000 sor = i + 3 cella = "a" & sor ugyfelcella = "c" & sor ugyfeltermek = Range(ugyfelcella) If ugyfel = ugyfeltermek Then

ugyfeltermeke = ugyfeltermeke + 1 termek(ugyfeltermeke) = Range(cella)

End If Next Sheets("ugyfelkimutatas").Select torlendo = "B6:G" & Range("g2") + 6 Range(torlendo).ClearContents For i = 1 To ugyfeltermeke sor = i + 5 vonalkodcella = "b" & sor termeknevcella = "c" & sor eladottdbcella = "d" & sor eladasiertekcella = "e" & sor beszerzettdbcella = "f" & sor beszerzesiertekcella = "g" & sor Range(vonalkodcella) = termek(i) Range(termeknevcella) = "=Vlookup(B" & sor & ",termekek!$A$4:$K$12,2)" Range(eladottdbcella) = "=Vlookup(B" & sor & ",termekek!$A$4:$K$12,7)" Range(eladasiertekcella) = "=Vlookup(B" & sor & ",termekek!$A$4:$K$12,10)" Range(beszerzettdbcella) = "=Vlookup(B" & sor & ",termekek!$A$4:$K$12,6)" Range(beszerzesiertekcella) = "=Vlookup(B" & sor & ",termekek!$A$4:$K$12,9)" Next

tablazat = ugyfeltermeke + 4 oszlop = Array("a", "b", "c", "d", "e", "f", "g") Dim adat(1 To 6, 1 To 1000) For i = 1 To 6 For j = 1 To tablazat cella = oszlop(i) & j adat(i, j) = Range(cella) Next Next munkafuzetnev = Range("b2") & Range("e2") & ".xls" Workbooks.Add


ActiveWorkbook.SaveAs Filename:=munkafuzetnev, FileFormat:=xlExcel8 Windows(munkafuzetnev).Activate For i = 1 To 6 For j = 1 To tablazat

cella = oszlop(i) & j Range(cella) = adat(i, j)

Next Next Columns("A:A").ColumnWidth = 3 Columns("B:B").ColumnWidth = 15 Columns("C:C").ColumnWidth = 30 Columns("D:D").ColumnWidth = 15 Columns("E:E").ColumnWidth = 15 Columns("F:F").ColumnWidth = 15 Columns("G:G").ColumnWidth = 15 Range("B2").Font.Bold = True Range("B6:B1000").NumberFormat = "0" Range("D2").HorizontalAlignment = xlRight Range("E2").HorizontalAlignment = xlLeft Range("F2").HorizontalAlignment = xlRight Range("G2").HorizontalAlignment = xlLeft Range("B5").HorizontalAlignment = xlRight Range("D5:G5").HorizontalAlignment = xlRight ActiveSheet.PageSetup.PrintArea = "" With ActiveSheet.PageSetup .Orientation = xlLandscape .PaperSize = xlPaperA4 End With ActiveWorkbook.Save ActiveWorkbook.Close End Sub

Ha mindent jól csináltunk és kiválasztunk egy beszállítót, majd rákattintunk az Ügyfél kimutatás készítése gombra, úgy a Dokumentumok mappában létre fog jönni egy ügyfélnévből és dátumból álló xls fájl, ami csak azokat a termékadatokat tartalmazza, ahol az adott ügyfél volt a beszállító.

De nézzük meg egy kicsit részletesebben, hogy mit is csinál a program.

Az ügyfélkód beolvasása és egy tömbdeklarálás után egy ciklus segítségével végigmegy a termékek lapon lévő vonalkódokon és megvizsgálja, hogy az adott vonalkódhoz tartozó beszállítókód megegyezik-e a kiválasztott beszállító kódjával. Ha igen, úgy eggyel megnöveli az ügyfél termékeinek számának nyilvántartására szolgáló ugyfeltermeke változót, és a termek tömb következő elemébe felveszi a vonalkódot. A ciklus lefutásának hatására az ugyfeltermeke változóban egy az ügyfél termékeinek számával azonos érték lesz, a termek tömb


eleje pedig fel lesz töltve azokkal a vonalkódokkal, amik a kiválasztott ügyfélhez tartoznak. Ezt követően átvált az ugyfelkimutatas lapra, ahol letöröl a listából annyi sort, amennyit az korábban tartalmazott (ezt a G2-ből veszi), így ha netán a mostani kigyűjtés kevesebb elemet tartalmazna, mint ami a listában a korábbi futás eredményeként volt, akkor azok már nem fognak zavarólag ottmaradni. Most ismét lefut egy ciklus, de most már csak annyiszor, ahány terméket kigyűjtöttünk az előbb. A ciklusmagban először meghatározzuk a beírási koordinátákat, majd beírjuk a vonalkódot a B oszlop soron következő sorába. Az ezt követő utasítások a képleteket írják be az adott sor C, D, E, F és G oszlopaiba. A beíró képletek az FKERES függvényt hozzák létre az adott cellákban, de mivel ezt már korábban jeleztük, a makróban mindig az angol függvénynevet és formátumot kell használni, tehát az FKERES helyett a VLOOKUP-ot, a pontosvessző helyett pedig a vesszőt. (Ha lenne tizedesjel, úgy ott a vessző helyett pont kellene.) Miután elkészült az ideiglenes táblázat, jön az ebben lévő cellák átmásolása az új munkafüzetbe. Mielőtt azonban azt létrehoznánk, megállapítjuk, hogy az hány sorból fog majd állni, és létrehozzuk az oszlopok betűjeleinek azonosítására szolgáló tömböt, illetve az adatok tárolására szolgáló kétdimenziós tömböt. Ebbe a tömbbe aztán két egymásba ágyazott ciklus segítségével beolvassuk az ugyfelkimutatas munkalap szükséges celláit. (Bár a tömb nagyobb, valójában csak a táblázat méretének megfelelő számú sor, kerül bele, hiszen a ciklus is csak ennyiszer fut le. Ugyanígy a tömb nulladik eleme sem kerül feltöltésre, mivel az A oszlop üres.) A beolvasást követően összeállítjuk a leendő munkafüzet nevét az ügyfélnévből és a dátumból. (Ha nem a dokumentumok mappába szeretnénk menteni, akkor itt lehetne eléírni az elérési utat is.) A következő utasítás létrehozza az új munkafüzetet, majd rögtön el is menti azt a megadott néven, sima xls (8-as verziójú Excel) formátumban, hogy az is tudja olvasni, akinek a régi változat van meg. Ez valójában nem feltétlen szükséges lépés még itt, de ha netán kiegészítjük a programot és váltogatni szeretnénk a fájlok között, akkor így most már van neve a fájlnak, amire tudunk hivatkozni. Az új fájl adatfeltöltése szintén két egymásba ágyazott ciklussal valósul meg, csupán jelen esetben a tömb értéke kerül a cellába. Most már csak az új táblázat formázása és ismételt mentése van hátra. A formázás során beállítjuk az oszlopszélességeket, vastag betűssé tesszük a B2 cellát, majd a szükséges helyeken megváltoztatjuk az igazításokat is. Mivel azonban a jelen cellaszélességekkel nem férne el nyomtatásban


egy lapon a táblázat, átállítjuk a lap tájolását is fekvő A4-re. Miután ez is kész elmentjük, majd bezárjuk az új munkafüzetet.

Ellenőrzésként nyissuk meg a Dokumentumok mappában lévő új Excel táblázatot és nézzük meg, hogy valóban úgy néz-e ki, ahogy mi szeretnénk és azokat az adatokat tartalmazza-e amiknek abban lenni kell.

Fontos, hogy ismételt mentés esetén ne hagyjuk nyitva az előzőt, mert ilyen ellenőrző rész nincs a programkódban. Ugyanúgy számos egyéb ellenőrzést is be lehetne még építeni, s ha valódi célra szolgáló más által használt táblázatot készítünk, akkor ezeket tegyük is meg mindenképpen. (Például a fenti példák nem ellenőrzik azt sem, hogy a vonalkód valóban számokból áll-e, így ez esetben is leáll a program hibajelzéssel.) Persze előre nem biztos, hogy gondolunk mindenre, s sokminden csak a használat során derül ki, úgyhogy készüljünk fel arra, hogy adott esetben ki kell egészítenünk a programot. Viszont mivel itt a program és a táblázat az abban lévő adatokkal együtt szoros egységet alkot, nehezebb a dolgunk, mintha egy önálló programmal oldottuk volna meg a feladatot.

7.6. Tréfás munkafüzet

Készítsünk egy olyan munkafüzetet, ami a megnyitása után egy perccel megkérdezi, hogy „Nem unod még a munkát?”. Ha erre a kérdésre igennel válaszolunk, úgy lépjen ki a táblából. A legjobb, ha a kollégánk egy meglévő fontos Excel tábláját alakítjuk át, de ekkor figyelnünk kell arra is, hogy engedélyezve legyenek a makrók futtatása az adott gépen.

A megvalósításhoz kattintsunk az átalakítandó munkafüzetben a Fejlesztőeszközök szalag Visual Basic ikonján, majd a projektlistán dupla kattintással válasszuk ki a ThisWorkbook elemet. A felső legördülőknél válasszuk a Workbook és Open elemeket, hogy a megnyitáskor történő eseményt tudjuk definiálni. Ide vigyük fel az alábbi kódot. Private Sub Workbook_Open() Application.OnTime Now + TimeValue("00:01:00"), "kilep" End Sub

Most válasszuk az Insert menü Module elemét és készítsük el az alábbi makrót: Sub kilep() mitortenjen = MsgBox("Nem unod még a munkát?", vbYesNo) If mitortenjen = 6 Then ActiveWorkbook.Close End Sub


Ezzel el is készültünk. Zárjuk be a kódszerkesztőt és mentsük el a dokumentumot.

Ellenőrzésként nyissuk meg a fájlt és várjuk meg, hogy mi történik.

Tárgymutató 117

8. Tárgymutató

activecell, 37 activex vezérlő, 19 add, 112 aláhúzás, 55 alignment, 56 alprogram, 52 array, 51, 86 beillesztés, 107 beszúrás, 61 betűméret, 54 betűtípus, 54 beviteli ablak, 44 beviteli lista, 79 bezárás, 61, 113 bold, 54 case, 47, 93 cellaazonosítás, 35 cellacsatolás, 25, 70 cellazárolás, 21 ciklus, 48, 51, 76, 86,

112, 114 close, 61, 113 columns, 57 columnwidth, 113 commandbutton, 88 controlsource, 66, 70 copy, 107 csoportpanel, 19 dim, 38, 112 do, 49 dőlt betű, 54 else, 46 értékadás, 37 esemény, 115 eseménykezelés, 25 fájlműveletek, 60 fejlesztőeszközök, 12 felirat, 19 feltételvizsgálat, 45 fkeres, 42, 80, 114 font, 54

for, 48, 51, 86, 112 formázás, 54 függvények, 40 gomb, 43, 63, 88, 98 gördítősáv, 17 hibakezelés, 33 hide, 71, 83 hivatkozások, 20 időzítő, 115 if, 45, 93, 105, 112 igazítás, 56, 113 index, 51, 54 inputbox, 44 insert, 62 italic, 54 jelszó, 58 kattintás, 67, 91 kijelző, 88 kilépés, 115 kiválasztónégyzet, 16 lapméret, 113 lapvédelem, 21, 58 legördülő lista, 15, 63,

80 léptetőnyil, 14 léptetőnyíl, 79, 97 lista, 14 loop, 49 makrók indítása, 29 makrók szerkesztése,

29 makrórögzítés, 27 másolás, 107 megjegyzések, 32 megnyitás, 115 mentés, 60, 107 msgbox, 43, 105 munkalap, 36, 54 next, 48 nyomógomb, 11, 18 nyomtatás, 61

objektum, 72 oszlopszélesség, 57,

113 párbeszédpanel, 63 paste, 107 protect, 58 range, 36, 93, 105 rendezés, 107 rows, 58 save, 60, 106, 113 select, 47 sheets, 54, 106, 108 show, 63, 64, 81, 88 sormagasság, 58 sort, 107 sub, 32 számformátum, 56 számítások, 39 tájolás, 113 tesztelés, 34 textbox, 88 then, 45 tömb, 50, 86, 112 töréspont, 34 törlés, 61 tulajdonságpanel, 24,

65 underline, 55 until, 50 userform, 64 űrlap-vezérlő, 19 üzenőablak, 43 választókapcsoló, 16 változó, 38 vastag betű, 54, 113 védelem, 98 vezérlő, 66 vezérlők, 12 vlookup, 42, 112, 114 while, 49 worksheetfunction, 42

A BBS-INFO KIADÓ AJÁNLATAAccess 2007 zsebkönyv (176 oldal, B6, 970 ft.) Adobe Photoshop zsebkönyv (192 oldal, B6, 870 ft.) A manipuláció tudománya (160 oldal, B6, 760 Ft.) Amit tudni kell a raktárkezelő és számlázó programokról (128 o., B5, 1870 Ft.) Az internet és lehetőségei (240 oldal, B6, 1970 ft.) Csodálatos úticélok (160 színes oldal, keménytáblás, B6, 1970 ft.) Elektronikai készülékek hulladékainak kezelése (80 o. 790 Ft.) Excel 2007 zsebkönyv (240 oldal, 970 Ft.) GTK+ Programozás Free Pascalban (240 oldal 2490 Ft.) Hálózatépítés otthonra és kisirodába (176 olda, B/5, 1970 ft.) Hétköznapi marketing sorozat (970 Ft./db.) Hogyan használjam? Minden amit a számítógép használatához tudni kell (560 o. 2490 Ft.) Hogyan használjam? CD - oktatóprogram (4930 Ft.) Hogyan kezdjem? (240 o. 1760 Ft.) Informatikai füzetek (ECDL vizsgákhoz)

1. Az információ technológia alapfogalmai (152 o. 970 Ft.) 2. Számítógép-használat és fájlkezelés (220 o. 1430 Ft.) 3. Szövegszerkesztés (242 o. 1430 Ft.) 4. Táblázatkezelés (192 o. 1430 Ft.) 5. Adatbázis-kezelés (140 o. 1190 Ft.) 6. Prezentáció-készítés (104 o. 1190 Ft.) 7. Információ és kommunikáció (160 o. 1190 Ft.) 10. ECDL Képszerkesztés (144 o. 970 Ft.) 11. ECDL Webkezdő (144 o. 970 Ft.)

Intrastat kézikönyv (192 o. 1870 Ft.) JavaScript kliens oldalon (188 o. 2900 Ft.) Kezdő bűnözők kézikönyve (216 o. 970 Ft.) Macromedia Flash MX (204 o. 1970 Ft.) MySQL.NET (540 oldal, B6, 3920 ft.) Nevelés és értékkutatás - A pedagógiai gyakorlat pszichológiája (200 o. 1970 ft.) Office XP (352 o. 2190 Ft.) Office 2007 (464 oldal, B5, 3920 ft.) OpenOffice.org (400 oldal, B5, 2990 ft.) Ötletek és tanácsok Windows felhasználóknak (176 o. CD mell. 1970 Ft.) PC hardver kézikönyv (360 o. 2870 Ft.) PowerPoint 2007 zsebköny (142 olda, B/6, 870 ft.) Problémamegoldó folyamat a minőségért és hatékonyságért (72 o. 650 Ft.) Programozás Turbo Pascal nyelven (232 o. 1290 Ft.) Puskázási kézikönyv (128 o. B6, keménytáblás, 970 Ft.) Számítástechnika másként (64 oldal, B6, színes, keménytáblás, 1190 Ft.) Szerver oldali Webprogramozás (192 o. 2900 Ft.) Szövegszerkesztési feladatgyűjtemény + CD mellékl. (144 o. A4, 1970 Ft.) Titkos hadműveletek pénztárcánk ellen (240 o. 540 Ft.) Weblapkészítés házilag (200 o. 1760 Ft.) Webes adatbázis-kezelés MySQL és PHP használatával (160 oldal, B6, 2490 ft.) Windows XP zsebkönyv (256 o. 870 Ft.) Windows Vista zsebkönyv (416 o. 1490 Ft.) Windows XP részletesen (386 o. 1970 Ft.) Word 2007 zsebköny (250 olda, B/6, 970 ft.) Videoszerkesztés házilag (240 o. 1970 Ft.) XHTML - A HTML megújulása XML alapokon (200 o. 2900 Ft.) stb.

További könyvek, részletes információk, újdonságok és tartalomjegyzékek az interneteten:

WWW.BBS.HU

A könyvek megrendelhetők a kiadó címén: BBS-INFO Kft. 1630 Bp., Pf. 21.

Ingyen is játszható internetes városépítő stratégiai játék

WWW.SECONDORB.HU WWW.SECONDORB.COM

bártfai barnabás--makróhasználat excelben

Documents