Tartalom

1. Mi a Delphi? ..................................................................................... 1 2. Az integrált fejleszt i környezet .................................................... 3 3. Els programunk Delphi-ben ......................................................... 6 3.1. 3.2. 3.3. 3.4. Komponensek kiválasztása.......................................................... 6 Komponensek tulajdonságainak beállítása.................................. 7 A reakciók beállítása az eseményekre....................................... 10 Program mentése, fordítása, futtatása....................................... 12

Mgr. Végh László

4. A projekt fájlfelépítése.................................................................. 15 5. A forráskódok áttekintése ............................................................ 16 5.1. Az ablak forráskódja (.pas) ........................................................ 16 5.2. Alkalmazás projekt fájlja (.dpr) ................................................... 19

Programozás Delphi-ben

6. Alap komponensek áttekintése ................................................... 20 7. Komponensek tulajdonságaik ..................................................... 24 7.1. 7.2. 7.3. 7.4. 7.5. 7.6. 7.7. 7.8. Komponens neve és felirata....................................................... 25 A komponens mérete és elhelyezkedése .................................. 26 A komponens engedélyezése és láthatósága ........................... 27 A komponensek „Tag” tulajdonsága .......................................... 29 Komponensek színe és bet típusa ............................................ 29 Komponens lebeg súgója......................................................... 30 Az egérmutató beállítása ........................................................... 31 Tabulátor .................................................................................... 31

8. Események .................................................................................... 32 9. Hibakeresés ................................................................................... 36 10. Nagyobb projektek készítése....................................................... 41 11. Standard üzenetablakok............................................................... 43 11.1. ShowMessage.......................................................................... 43 11.2. MessageDlg ............................................................................. 44 11.3. MessageDlgPos ....................................................................... 46 12. Információk bevitele ..................................................................... 46 © Mgr. Végh László, 2005-2006 http://www.prog.ide.sk 12.1. Jelöl négyzet használata – CheckBox .................................... 47 12.2. Választógomb – RádioButton................................................... 48 12.3. Választógomb csoport – RadioGroup ...................................... 49

Komárom, 2006. október 26.

12.4. Beolvasás „üzenetablak” segítségével..................................... 50 12.5. Egysoros szöveg beviteli doboz – Edit..................................... 51 12.6. Többsoros szöveg beviteli doboz – Memo............................... 54 12.7. Görget sáv - ScrollBar ............................................................. 56 12.8. Szám bevitele – SpinEdit segítségével .................................... 58 12.9. Listadoboz – ListBox ................................................................ 59 12.10. Kombinált lista – ComboBox .................................................. 65 12.11. StringGrid komponens ........................................................... 66 12.12. Id zít – Timer ....................................................................... 72 12.13. Gauge, ProgressBar komponensek....................................... 74 13. További komponensek ................................................................. 76 13.1. Kép használata – Image .......................................................... 76 13.2. Választóvonal – Bevel .............................................................. 82 13.3. Alakzat – Shape ....................................................................... 83 13.4. Grafikus nyomógomb – BitBtn ................................................. 84 13.5. Eszköztár gomb – SpeedButton............................................... 86 13.6. Kép lista – ImageList ................................................................ 87 13.7. Eszköztár – ToolBar ................................................................. 88 13.8. Állapotsáv – StatusBar ............................................................. 90 13.9. Könyvjelz k – TabControl, PageControl .................................. 92 13.10. Formázható szövegdoboz – RichEdit .................................... 94 13.11. XPManifest komponens ......................................................... 95 14. Menük létrehozása ........................................................................ 96 14.1. F menü – MainMenu ............................................................... 97 14.2. Lokális (popup) menü – PopupMenu ..................................... 103 15. Objektum orientált programozás............................................... 104 15.1. 15.2. 15.3. 15.4. 15.5. Konstruktor ............................................................................. 109 Destruktor, free metódus........................................................ 111 Hozzáférés az adatokhoz....................................................... 111 Öröklés ................................................................................... 114 Polimorfizmus, virtuális és absztrakt metódusok ................... 115

18.1. 18.2. 18.3. 18.4. 18.5. 18.6. 18.7.

Ecset stílusa ........................................................................... 130 Bitmap beolvasása állományból............................................. 132 Szöveg grafikus kiírása .......................................................... 132 Egyszer grafikus editor......................................................... 134 Színátmenet létrehozása ....................................................... 137 Kép kirajzolása megadott koordinátákra ................................ 139 Animáció megjelenítése ......................................................... 141

19. Hibák a program futásakor, kivételek kezelése ....................... 143 19.1. Hibák kezelése hagyományos módon ................................... 144 19.2. Hibák kezelése kivételek segítségével .................................. 145 19.3. Except blokk szintaxisa .......................................................... 149 20. M veletek fájlokkal ..................................................................... 150 20.1. 20.2. 20.3. 20.4. Fájltámogatás az Object Pascal-ban ..................................... 150 Fájltámogatás a Delphi-ben ................................................... 152 Hibák a fájlokkal való munka során........................................ 153 További fájlokkal kapcsolatos parancsok............................... 156

21. Standard dialógusablakok ......................................................... 156 21.1. 21.2. 21.3. 21.4. 21.5. 21.6. OpenDialog, SaveDialog ........................................................ 160 OpenPictureDialog, SavePictureDialog ................................. 162 FontDialog .............................................................................. 163 ColorDialog............................................................................. 165 PrinterSetupDialog, PrintDialog ............................................. 166 FindDialog, ReplaceDialog..................................................... 168

22. Több ablak (form) használata .................................................... 170 22.1. Alkalmazás két ablakkal (modális ablak) ............................... 170 22.2. Ablakok, melyekb l át lehet kapcsolni másik ablakokba (nem modális ablak) ................................................................................. 174 22.3. Könyvnyilvántartó program .................................................... 177 23. SDI, MDI alkalmazások ............................................................... 184 23.1. Alkalmazás, mely több dokumentummal tud egyszerre dolgozni (MDI)................................................................................................ 184 24. A Windows vágólapja ................................................................. 188 24.1. A vágólap használata a programozásban.............................. 189 25. A Windows üzenetei ................................................................... 199 25.1. Üzenet kezelése Delphi-ben .................................................. 201 25.2. Beérkez üzenetek számlálása ............................................. 204 25.3. Felhasználó által definiált üzenetek küldése.......................... 207

16. Az osztályok hierarchiája, VCL .................................................. 117 17. Billenty zet, egér ........................................................................ 118 17.1. 17.2. 17.3. 17.4. Az egér ................................................................................... 118 Billenty zet ............................................................................. 121 Példaprogramok az egér és a billenty zet használatára ....... 122 Drag & Drop – fájlok tartalmának megtekintése .................... 126

18. Grafika, rajzolás, szöveg kiírása................................................ 129

25.4. A képerny felbontásának érzékelése ................................... 211 25.5. A Windows néhány kiválasztott üzenete................................ 212 26. További hasznos programrészek .............................................. 213 26.1. Hang lejátszása az alkalmazásban........................................ 213 26.2. Er forrás (resource) állományok használata ......................... 215 26.3. Kép mozgatása a kurzor billenty k segítségével ................... 219 26.4. Objektumokból álló tömb........................................................ 220 26.5. Aktuális dátum, id lekérdezése ............................................ 223 26.6. INI állományok, rendszerleíró adatbázis (regiszterek) használata ....................................................................................... 227 Gyakorlatok ........................................................................................ 235 Melléklet: Leggyakrabban használt változók.................................. 252 Melléklet: Magyar - Angol - Szlovák szótár ..................................... 254 Irodalomjegyzék: ............................................................................... 255

1. Mi a Delphi?
Bevezetésként nézzük meg, milyen f jellemvonásai vannak a Delphi programozási nyelvnek. A Delphi alapja az Object Pascal programozási nyelv, amely az ismert Turbo Pascal objektumos felépítménye. Éppen ezért sok mindent, amit megtanultunk Turbo Pascal-ban, most fel fogunk tudni használni a Delphi-ben. Fontos, hogy valamilyen szinten már tudjunk programozni – ismerjük a vezérlési szerkezetek: ciklusok (for..do, while..do, repeat..until), elágozások (if..then..else, case..end) fogalmát. Tudnunk kéne, hogyan kell a program elején változókat deklarálnunk (var..) és ismernünk a Turbo Pascal-ban használt változók alaptípusait (a Delphi-ben használt egyszer változók típusait a jegyzet végén lev mellékletben megtalálhatjuk). Miért jobb a Delphi fejleszt i környezetében programoznunk más hozzá hasonló programozási nyelv helyett? Els sorban a produktivitás végett. A Delphi az egyik legeffektívebb eszköz, mellyel a Windows operációs rendszer alatt alkalmazásokat hozhatunk létre. A rengeteg vizuális eszköznek és integrált környezetnek köszönhet en maximálisan leegyszer sített fejleszt i fázisa van az alkalmazás létrehozásának. Amit eddig 8-10 órán át írtunk Turbo Pascal-ban, azt Delphi-ben létre tudjuk hozni pár óra alatt. Ezen kívül a programozás Windows alatt általában (tehát Delphi-ben is) különbözik a szekvenciális programozástól, melyet a DOS alatti programozásból ismerhetünk. A Windows alatti programozás eseményekkel irányított programozás. A program irányítását az operációs rendszer végzi, a programozónak csak a rendszer különféle eseményeire kell reagálnia. Az irányítás tehát továbbra is az operációs

1

Architect.Delphi for Win32 menüpontot. vagy figyelmen kívül hagyhatja – a programozónak csak ezt a reakciót kell megfogalmaznia (hogy mit tegyen az alkalmazás).rendszernél marad. illetve . Az alkalmazás erre az üzenetre reagálhat (pl. Ebben a jegyzetben lev ábrák a Delphi 2005-ös (Delphi 9) A Delhi elindítása után új alkalmazás létrehozásához válasszuk ki a File – New – VCL Form application . ill. Ha szeretnénk telepíteni a Delphi 2005 Personal változatát.Net alkalmazásokat is hozhatunk létre.borland. hogy nem tartalmaz hálózat és adatbázis támogatást – ezek csak a magasabb (Professional. úgy. A Personal változat ingyenes nem kommerciális célokra – tanulásra nekünk egyel re ez tökéletesen megfelel. magasabb verziószámú Delphi-ben is. 2 3 . Enterprise) változatoknál érhet k el. Mi itt csak Delphi Win32 alkalmazásokat fogunk létrehozni. Ennek a változatnak az egyik legnagyobb megkötése. de C#. Architect és Enterprise.com – Downloads – Delphi weboldalon ingyenesen kérhetünk egy rövid kérd ív kitöltésével. Ezekr l természetesen még szó lesz b vebben is a következ fejezetekben. Y koordinátákon”. Láthattuk. a te f ablakodban bal egérkattintás történt az X. Természetesen az alkalmazások létrehozhatók a leírtak alapján alacsonyabb. Az integrált fejleszt i környezet komponenskönyvtár) verziójából valók. A 2005-ös változatnak négy kiadása létezik – Personal. a felhasználó klikkel az egér valamelyik gombjával). Ha „történik valami” (pl. hogy a Delphi 2005-ben nem csak Delphi Win32 alkalmazást. (VCL = Visual Component Library = Vizuális 2. melyet a www. Professional. a rendszer küld az alkalmazásunknak egy üzenetet. a telepítés után szükségünk lesz egy kódra (CD key). hogy kiír valamit). melyet a következ höz hasonló képen képzelhetünk el: „kedves alkalmazás.

megvalósítását végezhetjük el itt. akkor egy feliratban kapunk tájékoztatást a funkciójáról. amely a form-on lev komponensek elrendezését. Ha egérrel „rámegyünk” az ikonra. Azt. Ezek a fájlok Menü: A különféle beállítások. kezdeti beállításait tartalmazza (. kép-. ha rákattintunk az egér jobb gombjával és kiválasztjuk az „Arrange – by Name” menüpontot. komponenseket (nyomógombokat. Ezt az ablakot kezdetben nem látjuk. az alábbi ábrához hasonlót láthatunk.) . Hasonlóan az „Arrange – by Category” segítségével állíthatjuk vissza. melyeket utána elhelyezhetünk az ablakunkon (form-on). Minden egyes alkalmazásunk egy projektb l áll. a hozzájuk tartozó ablakok (form-ok) és az ablakon lev komponensek elrendezését tartalmazó fájlok.dfm kiterjesztés ). Project manager: A Delphi-ben mindig egy komplex Objektumfelügyel Forráskód szerkeszt rendszerben (Projektben) dolgozunk. 4 5 lehetnek programfájlok (unit-ok). Ezt átállíthatjuk. Ablak tervez : A leend programunk formáját tervezhetjük meg itt aránylag egyszer helyezhetünk el rajta. stb. Objektum felügyel : Ez a Delphi egyik legfontosabb része. Forráskód szerkeszt : A Delphi-nek az a része. Nézzük most meg mib l is áll a Delphi fejleszt i környezete: Elempaletta: Itt választhatjuk ki a komponenseket. Segítségével beállíthatjuk az egyes komponensek tulajdonságait (Properties) és a komponensek reakcióit az eseményekre (Events). ahova magát Ablak tervez Elempaletta a forráskódot (programot) írjuk. segítség. Megváltoztathatjuk az ablak (form) méretét. Kezdetben a projektünkhöz két fájlt köt dik – egy programkódot tartalmazó fájl (. stb. feliratokat. láthatjuk a project manager-ben. programfuttatások. keresés. ugyanott klikkeljünk a „design” fülre. hogy a projektünkhöz milyen fájlok kapcsolódnak és melyik fájl melyik fájlhoz tartozik. képeket. stb. az alul lev „code” fül segítségével jeleníthetjük meg. Menü Struktúra Eszköztár Projekt ma n a g e r TIPP: Az Objektum felügyel ben a tulajdonságok és események kategóriák szerint vannak besorolva.pas kiterjesztés ) és egy olyan fájl. hang-. fájlok.Miután létrehoztunk egy új alkalmazást. A projekt tetsz leges fájlt használhat. Eszköztár: A menüb l is hívható funkciók gyors elérését teszik lehet vé. módon. adat-. Ha vissza szeretnénk menni a form-unk tervezéséhez. Struktúra: Ebben az ablakban láthatjuk a form-unkon lev komponensek hierarchikus elrendezését.

1.2.Delphi for Win32 menüpontra. Klikkeljünk az ablakunkban arra a helyre. elhelyezéseit fogjuk változtatni. Az új alkalmazás létrehozásához. tehát komponenseket is szokás így jelölni a nevük el tt ezzel is segítve a programkód könnyebb megértését. Hasonlóan helyezzünk el az ablakunkon egy TButton (nyomógomb) komponenst. (Megjegyzés: A „T” bet a „type” rövidítése – általában Delphiben minden osztályt. Jelenleg az ablakunkon két komponens – Label1 és Button1 található. A további alkalmazások létrehozását a jöv ben már ennél tömörebben fogjuk átvenni. Komponensek kiválasztása Az kiválasztása. a megfelel komponensek komponenst. Mi most csak a komponensek feliratait.automatikusan az objektumhoz a Label1 nevet rendeli 3. Ezzel a kiválasztott komponens aktív lesz az Objektum felügyel 6 7 . melyet minden alkalmazás fejlesztésének kezdetében meg kell tennünk. ahogy az alábbi ábrán is láthatjuk: fogjuk tárgyalni. 2. ha még nem tettük meg. 3. 001 Az els alkalmazásunk elkészítését egy kicsit részletesebben hozzá. A form-unkon lesz még egy nyomógomb. 4. Els programunk Delphi-ben Az els programunk annyit fog tenni. Az elempalettában válasszuk ki a TLabel (címke) közepén megjelenik a els lépések egyike. A címke elhelyezésekor a Delphi 3. 1.) 3. beállítjuk azok néhány tulajdonságát. klikkeljünk a File – New – VCL Form Application . A Delphi az elhelyezett objektumhoz a Button1 nevet rendeli hozzá. hasonlóan. ill. méreteit. Általában minden komponensnek ennél jóval több tulajdonsága van – ezekkel majd folyamatosan megismerkedünk. hogy kiír egy szöveget az ablakunkba. 1. A képerny f ablakunk (from-unk). amely megnyomásával az alkalmazást bezárhatjuk. ahová a címkét szeretnénk tenni. Klikkeljünk a Label1-re a f ablakunkban (Form1-en). Komponensek tulajdonságainak beállítása Miután kiválasztottuk a szükséges komponenseket. Az osztályokról majd még lesz szó b vebben a kés bbi fejezetekben.

Ha nincs kiválasztva. amely a komponensre jobb egérgombbal klikkelve jelenik meg. se a nyomógombra). Keressük itt meg a Caption (felirat) tulajdonságot és klikkeljünk rá. Ekkor az Objektum felügyel ben a Button1 jelennek Klikkeljünk tulajdonságra és írjuk be: „Kilépés”. 5. Változtassuk meg ezt is. A komponensek elhelyezkedését beállíthatjuk szintén a Position kiválasztásával a lokális pop-up menüb l. Ekkor az Objektum felügyel ben a f ablakunk tulajdonságait állíthatjuk be. Válasszuk itt ki ismét a Caption tulajdonságot és írjuk be feliratnak: „Els alkalmazásom”. Vegyük észre. hogy a Caption beállításával a komponens neve nem változik meg. A bal oldali oszlopban vannak a komponens tulajdonságainak a nevei. válasszuk most ki a Properties fület. a jobb oldali oszlopban a hozzájuk tartozó értékek.ablakában. amit máshova szeretnénk tenni és vigyük át Észre vehettük. ahogy azt tennénk bármilyen Windows alkalmazásnál – fogjuk meg az alkalmazásunk jobb alsó sarkát (vagy jobb és utána alsó szélét) és húzzuk beljebb. Egyszer en fogjuk meg azt a komponenst. Jegyezzük meg. Az ablakunk kisebb lett. Például a mi nyomógombunk felirata Kilépés. csak a felirat. hogy az alkalmazásunk form-ján is mindjárt megváltozott a felirat. Az Objektum felügyel ben két oszlopot láthatunk. Ezzel kijelöltük. Változtassuk meg a f ablak méretét kisebbre úgy. 2. de a programkódban továbbra is Button1 néven fog szerepelni! 3. amely jelenleg így néz ki: nyomógombra. Természetesen ezt is beállíthatjuk az Objektum felügyel ben is a Top (távolság a form tetejét l) és a Left (távolság a form bal szélét l) tulajdonságok segítségével. 4. amely megjelenik rajta. Ez a f ablak alapértelmezett felirata. 8 9 . a Button1 a feliratú Caption egérrel. Ezzel befejeztük az alkalmazásunk külalakjának tervezését. Klikkeljünk tulajdonságai most a form-unkon meg. hogy ne klikkeljünk se a címkére. hogy az ablakunk fels sávjában a Form1 felirat szerepel. Itt az ablak tetején két választási lehet ségünk van – Properties és Events. hogy a komponens tulajdonságait fogjuk beállítani. Klikkeljünk bárhova a form-unkra (de úgy. A „Label1” érték helyett írjuk be: „Szia!”. Az ablakunk méretét beállíthatjuk az Objektum felügyel ben is a Width (szélesség) és Height (magasság) tulajdonságok segítségével. Végül rendezzük el az ablakunkban a címke és a nyomógomb komponenseket.

milyen eseményekre szeretnénk reagálni. Megnyitjuk ezért az Objektum felügyel ben a Button1 komponenst. A következ lépésben már csak be kell állítanunk. hogy megjelentek a kurzor mellett egy kis ablakban különféle parancsszavak. A Kilépés gombra kattintásnál szeretnénk. Ez megtehetjük úgy. hogy mit tegyen a program a Kilépés gombra kattintáskor. Nekünk már csak az a dolgunk. 2. Az Objektum felügyel ben most kiválasztjuk az Events (események) fület. üres mez re Az Objektum felügyel nek ebben az üres mez jében most Alkalmazásunk ablaka pontosan így fog kinézni futtatáskor is (természetesen rácspontok nélkül lesz). hogy a Kilépés gombra kattintással a program befejezze a futását. stb. A 10 közé tette. Ezekb l most csak egyetlen egy lesz.Terminate. Írjuk be a begin. hogy elt nt az ablak tervez helyette a forráskód szerkeszt és ablaka jelent meg. A reakciók beállítása az eseményekre A következ fontos lépés a reakciók beállítása az eseményekre. ha az alkalmazásunk befejez dne. Eseményeknek nevezünk mindent. A Delphi automatikusan létrehozta a Button1Click eljárást és a kurzort az eljárás begin. mint például: kattintás egérrel. Ez az automatikus kiegészítés a programozó munkáját szeretné 11 . ahol a kurzor villog a következ sort: Application. El ször is meghatározzuk. billenty megnyomása. amely meghatározza. A programrész írásakor észrevehettük.end kulcsszavai 3. Ebbe az ablakba fogjuk megírni a programkódot. ebben kiválasztjuk az OnClick sort. ha a felhasználó a Kilépés gombra klikkel. Továbbá észre vehettük. 1. vagy kiválasztjuk az Objektum felügyel legördül listájából.end közé.3. amely mindig meg lesz hívva. hogy egyszer en rákattintunk a komponensre a form-unkon. ami az operációs rendszerben történik és valahogyan összefügg a komponenseinkkel. A mi esetünkben a programkód beírása egyetlen lépésb l fog állni.jobb oszlopban az OnClick mellett lev klikkeljünk rá duplán. megjelenik a Button1Click felirat. Mivel mi a komponensre kattintásra szeretnénk reagálni... Ez egy eljárás neve. hogy ide beírjuk azt a programrészt.

Az alkalmazás lefordításához és futtatásához klikkeljünk az eszköztárban a Run – Run funkcióbillenty t). után nem létrehoz egy futtatható alkalmazást (. tehát annak a forráskódnak a nevét. Ezzel a projektünket elmentettük.Terminate. Adjuk meg a unit nevét.pas nevet.EXE kiterjesztés állományt).DCU kiterjesztés állomány). majd kiválasztani a megjelen listából a megfelel parancsot. Az els alkalmazásunk elindult. Itt hagyhatjuk a unit1. Ajánlom. A linker ezekb l a kompilált állományokból 3. de ajánlatos mindig. Mindenek el tt azonban mentsük el az egész projektünket. Megjelenik egy ablak. ahol a projekt nevét kell megadnunk. azt el hívhatjuk manuálisan is a Ctrl + Space billenty kombináció megnyomásával. Ide írjuk be az elso. A fordítás két lépésben zajlik: egy kompilátor és egy linker segítségével. amelyben meg kell adnunk az elmenteni kívánt unit nevét. A következ lépés az alkalmazás lefordítása. Az egy sornyi programkód helyet (ami most Application. 1.dpr nevet. 2. A kompilátor az alkalmazás vagy annak egy részének megírása után a projektet kompillálja egy „közbüls ” formába (ekkor minden modulhoz létrejön egy . elveszhetne az alkalmazásunk el nem mentett része. Program mentése. Ezzel befejez dött! a alkalmazásunk létrehozásának fázisa valójában 2. Próbáljunk rákattintani a ikonra (vagy válasszuk ki a menüb l a parancsot. Hasonló módon fogunk a jöv ben programozni bonyolultabb események kezelését is. Majd megjelenik egy újabb dialógusablak.megkönnyíteni és meggyorsítani. nyomjuk meg az F9 Kilépés gombra. Ez az állomány már bármelyik gépen futtatható Windows operációs rendszeren a Delphi jelenléte nélkül is. M ködik? 12 13 . 3. Bár nem kötelez . hogy minden egyes projektnek hozzunk létre egy új alkönyvtárt. minden fordítás és futtatás el tt az alkalmazás összes részét elmenteni. fordítása. A fordítás alatt a programozó számára érthet állományból a számítógép számára érthet állomány létrehozását értjük. futtatása Az els alkalmazásunk kész! Hátra maradt még az alkalmazás lefordítása és futtatása. Elég elkezdenünk írni az utasítást. és ha mindig ugyanabba a mappába mentenénk. Ha a lista véletlenül nem jelenik meg automatikusan.) fogjuk beírni a néha hosszú és bonyolultnak t n programkódot. ill. amelyben a Button1Click eljárásunk is van. és abba mentsük el a projekt összes állományát – a Delphi minden projekthez több állományt hoz létre. Az egész alkalmazás elmentéséhez klikkeljünk a File – Save All menüpontra.4. egy id igazodnánk ki a mappában található fájlokon. ha ugyanis a fordításnál vagy futtatásnál komolyabb hiba lépne fel. 1.

forrásállománya. egyéb tulajdonságait 14 15 . feliratait. melyik állományokat kell átmásolnunk. Azokhoz a modulhoz. Ha belenézünk a mappába. tartalmaz rendszermenüt (melyet a bal fels sarokban lev ikonra klikkelléssel hívhatunk el ). minimalizálni. A projekt különféle beállításait tartalmazza.close) és az Application. *. hogy az alkalmazásunk egy csomó olyan funkcióval is rendelkezik. Els sorban nézzük meg. stb. Megjegyzés az els alkalmazásunkhoz: a program befejezésére az Application. *. Ez tartalmazza az egyes modulok programkódját. tehát mindent amit az Ablak tervez ben. Az Application. Ezek az állományok az ablak és a rajta lev komponensek listáját és tulajdonságait tartalmazzák. Vegyük észre. amelyet nekünk nem kellett beprogramoznunk – az ablakot lehet mozgatni. láthatunk többek között egy elso. ahová az alkalmazást elmentettük. *.BDSPROJ Borland Development Studio Project fájl. hogy néz ki a projektünk fájlfelépítése. Ezt az állományt bárhol és bármikor a Windows alatt elindíthatjuk és gyönyörködhetünk az els m köd alkalmazásunkban. ill. melyekhez tartozik ablak. Gyakorlatilag az alkalmazás minden egyes ablakához tartozik egy ilyen állomány.DFM Delphi Form. lehetséges.Terminate nem az egyetlen használható megoldás.Terminate függvényt használtuk. melyekhez ablak nem tartozik. Ha valaki már programozott Delphi-ben. Formleírás.PAS Unit forráskód.DPR Delphi Project. hogy erre más metódust használt (pl. méreteit.exe nev állományt. több állományt találhatunk benne. Objektum felügyel ben beállítottunk (a komponensek elrendezését. Minden projekthez egyetlen ilyen állomány tartozik. Egy projektnek egy vagy több ilyen állománya lehet. léteznek ilyen kiterjesztés állományok is. A projekt fájlfelépítése Vizsgáljuk meg. ha a forráskódot szeretnénk más gépre átvinni: *. Minden projektnek létezik egyetlen ilyen f Az els alkalmazás létrehozása sikeresen magunk mögött van. maximalizálni. ahova a projektet mentettük.Terminate túl er s eszköznek t nik neki. de els dlegesen ez a függvény szolgál az alkalmazás befejezésére és használata teljesen korrekt és biztonságos. Ezen funkciókat a Delphi „programozta” be a Windows operációs rendszerrel együttm ködve.4. átméretezni. de ezeken kívül a projekt még tartalmazhat további ilyen állományokat (modulokat) is. Ez els sorban létrehozza az alkalmazás ablakait és sikeres létrehozáskor elindítja az alkalmazást. form1. Ha megnézzük a mappánkat.

SysUtils. szeretnénk benne valami javítani. Ezek közül számunkra a legfontosabb a *. Az els része az interface kulcsszóval kezd dik (csatlakozási vagy publikus felület). és amelyeket szeretnénk 16 17 .Terminate. var Form1: TForm1. ill.pas) Amikor megtervezzük hogy miként nézzen ki az alkalmazásunk ablaka. milyen programkódokat hozott létre a Delphi az el z program megírásakor.EXE kiterjesztés állomány.RES Resource.pas állománynak a szerkezetét: A unit unit1. Nézzük meg most ennek a unit1. unit Unit1. Variants. Label1: TLabel. Az alkalmazásunk ikonját tartalmazza. Forms. Graphics. A további állományokat nem szükséges átmásolnunk.dfm} 5. a Delphi automatikusan generál hozzá forráskódot. nem elég ez az egyetlen állomány. Dialogs. StdCtrls.Button1Click(Sender: TObject). szükséges hozzá az összes fent említett állomány is. Természetesen. ezen állományok többségét a Delphi a fenti állományokból hozta létre automatikusan a projekt fordításakor. Az interface részben fel vannak sorolva azok a típusok. változók. ha a programunk kódját meg szeretnénk nézni. Messages. private { Private declarations } public { Public declarations } end. begin Application. Classes. Az ablak forráskódja (. type TForm1 = class(TForm) Button1: TButton. majd újra fordítani. melyeket a unitban használunk. interface *. elég ezt az állományt átmásolnunk és futtatnunk (ebben a másik gépben nem szükséges hogy legyen Delphi). a modulunk nevét adja meg. end.1.és a komponens egyes eseményeihez tartozó eljárások neveit is). Windows er forrásfájl. end. uses Windows. 5. a második az implementation (kivitelezési vagy implementációs rész). A forráskódok áttekintése Ebben a fejezetben megnézzük. procedure Button1Click(Sender: TObject). Ha alkalmazásunkat más gépre szeretnénk átvinni és futtatni (a forráskód nélkül). implementation {$R *. hogy a unit két részre van bontva. procedure TForm1. Ezt követ en észrevehetjük. Controls.

pas végz dés állományokhoz: Egy alkalmazáson belül több ilyen állományunk is lehet. programból is elérhet k legyenek.dfm állomány beolvasására kerül sor.dfm} sort.Button1Click eljárás megvalósítását láthatjuk. hogy a TForm1 tartalmaz egy nyomógombot (Button1) és egy címkét (Label1). mint egy hagyományos Pascal fájl más kiterjesztéssel: eseményhez hoztunk létre – ez az eljárás kerül futtatásra. mit is tegyen az adott eljárás vagy függvény.) Továbbá észrevehetjük. A uses parancs után fel vannak sorolva azok a modulok. Alkalmazásunk minden egyes ablak egy ilyen külön modulban található.hogy más unitból. Az implementation részben találunk egy {$R *. tehát a .2. A $R egy küls resource fájl beolvasását jelzi. {$R *. Form1). sort). A var kulcsszó után egyetlen változónk van deklarálva.res} begin Application. ha a felhasználó rákattint a nyomógombra). (Osztály = olyan adattípus.dfm most nem azt jelzi. eljárásokat. ez a Form1 objektum. melyeket csak a mi unit-unkon belül szeretnénk használni. Végül egy megjegyzés a modulokhoz. majd egy Button1Click nev eljárást (ez a mi eljárásunk..dpr) Nézzük meg. hanem itt a * csak a mi unitunk nevét helyettesíti. Unit1 in 'Unit1.Run. uses Forms. A Delphi-ben szokás az osztályok neveit mindig T bet vel kezdeni. függvényeket is.CreateForm(TForm1. 18 program elso. eljárásokat és függvényeket.Initialize. Végül a TForm1. end. Az osztály tartalmazhat adatokat. Valójában ez az állomány nem mást. eljárások definíciója következhet. Ezek után a TForm1 osztály private (magán – csak az osztályon belül használható) és public (nyilvános – az osztályon kívülr l is elérhet ) változók. amit az OnClick hogy az összes . Az implementation részben egyrészt a feljebb felsorolt eljárások. Láthatjuk. mi van a programunk interface részében. mit tartalmaz az alkalmazás projekt állománya. Application.pas' {Form1}. melyek szükségesek a mi modulunk futtatásához. Nézzük meg részletesebben. melynek begin. melyekhez ablak (form) nem tartozik. melyet valamiféle sablonnak képzelhetünk el bizonyos objektumok – mi esetünkben f ablak – létrehozásához. 19 . A type parancs után a TForm1 típusú osztály definícióját látjuk. ha ott használjuk a mi unit-unkkat (ha a másik programban megadjuk a uses unit1. Másrészt ide írhatjuk azokat a további változókat. 5. Nekünk itt most nincs egyik sem. hogy a TForm típusú osztályból lett létrehozva. Ez valójában a mi f ablakunknak a típusa. Application. ami valójában a mi alkalmazásunk f ablaka.dfm végz dés állományt olvassa be. Ez a fájl tartalmazza a f ablakunk és a rajta található komponensek beállításait. függvények megvalósítását írjuk le – tehát azt. Ezen kívül az alkalmazásunk tartalmazhat még további ilyen modulokat is. Alkalmazás projekt fájlja (. A *. tehát csak a unit1.end közötti részét mi írtuk be.

res} sor most az elso. amely segítségével részletesen beállíthatjuk a menü egyes RadioButton A CheckBox-hoz hasonló komponens.nem) információk bevitelére szolgáló komponens. Ezekb l a Delphi-ben rengeteg van (az Enterprise változatban több mint 200). használni a szöveg színének kijelölésére (mivel egyszerre csak egy színt választhatunk). ill. ha nem akarjuk a bonyolultabb RichEdit komponenst használni. melyeket elhelyezhetünk az alkalmazásunk ablakában (form-on). Ez a komponens csupán szöveg megjelenítésére képes. Ez az állomány tartalmazza az alkalmazásunk ikonját. PopupMenu A f menu és lokális pop-up menu létrehozására szolgáló komponens. aláhúzott típusának kijelölésére (mivel ezeket bárhogy kombinálhatjuk. egyszerre többet is kijelölhetünk). A {$R *. CheckBox-ot pedig a szöveg félkövér. d lt. de itt a felhasználó csak egyet jelölhet ki több ilyen komponens közül. Ennek ellenére a címkénél több különböz eseményre is reagálhatunk. létrehozza a f ablakunkat és elindítja az alkalmazást. „Menu Designer”-rel. Beviteli mez . Hosszabb. Használható szövegszerkeszt létrehozásánál. RadioButton-t lehetne pl. itt lennének felsorolva az összes hozzájuk tartotó modulok (unitok). Majd a f program inicializálja az alkalmazást. Amennyiben ez nekünk nem elég. Egysoros szöveg bevitelére vagy megjelenítésére szolgáló komponens. sok kész komponenst találhatunk az Interneten is. létrehozhatunk saját komponenseket is. de nem szükségszer egyetlen komponenst sem. Memo Edit Címke. CheckBox Logikai érték vagy (igen. szolgáló egyszer többsoros szöveg megjelenítésére például egy alkalmazás komponens. 6. Button Nyomógomb.res állomány csatolását jelzi. Ez az egyike a leggyakrabban használt komponenseknek. hogy ez a program használja ez el bb elemzett unit1.pas modult – tehát azt a modult. Standard paletta komponensei: MainMenu. Ha az alkalmazásunkban több ablakunk lenne. 20 21 . kijelölni megjelenítésére Egyszerre bármennyi ilyen komponens ki lehet jelölve (pipálva). Egy kijelölése mindenképpen szükséges. Alap komponensek áttekintése Komponensek alatt azokat az elemeket értjük. A Delphi rendelkezik egy úgynevezett menüpontjait.Label Láthatjuk. amely az alkalmazásunk f ablakát tartalmazza.

Ha az alkalmazásunk periodikus id közönként fog valamilyen m veletet végezni. Image Kép. StatusBar Állapotsáv. Ha szeretnénk a fájl megnyitni vagy menteni egy állományt. GroupBox. ScrollBar Görget sáv. sorkizárás) OpenDialog. System. mely a Button-tól eltér en bitképet is meg tud jeleníteni magán. Valamilyen érték beállítására Az Memo komponens b vített változata. Ezen komponenseknek nem csak vizuális jelent sége van. Timer Id zít . … Standard külön ezeket. egy rajzprogramban). Dialogs. amely a listában nem szerepel. Az alkalmazásban ennek a komponensek a segítségével többfajta formátumú képet meg tudunk jeleníteni. 22 23 . A komponens rajz létrehozására is szolgálhat (pl. így könnyen létrehozhatunk bármilyen külalakú nyomógombot. Több hasonló típusú érték kiírására szolgál. Hasonló a ListBox-hoz. szolgálhat. Samples palettákról: BitBtn Nyomógomb. de logikai is. de van lehet sége új érték beírására is. A gomb lehet lenyomott állapotban is. nyomtatásra. Panel Komponensek. Segítségével bonyolultabb szövegszerkeszt is létrehozható. mely jóval több tulajdonsággal rendelkezik. használhatjuk standard dialógusablakok szín és bet típus kiválasztására. dialógusablakok. melyekb l lehet egyet vagy többet kijelölni (a komponens beállításától függ en). szó keresésére egy szövegben. de ezzel RichEdit helyet lehet megtakarítani az alkalmazásunkban. éppen mi történik az alkalmazásban. SaveDialog. ComboBox Legördül lista. Az alkalmazásunk ablaka alján írhatunk ki segítségével a felhasználónak beállítási hogy információkat. RadioGroup. Néhány az Additional. jobbra. illetve információkat arról. SpeedButton Eszköztáron használható gombok. Win32. szükségünk lesz erre a komponensre. MediaPlayer A komponens segítségével hang és videó fájlokkal dolgozhatunk. nem kell dialógusablakokat hanem Hasonlóan készítenünk helyette léteznek megkeresésére.ListBox Lista. melyek más komponensek logikai csoportokba való sorolására szolgálnak. középre. A felhasználó választhat a listából. beállítható kölcsönös kizárás is lenyomott állapotban (gondoljunk például a Word szöveg igazítási gombjaira – balra.

Label1. a többi „egyedi” tulajdonságot az egyes komponenseknél fogjuk külön tárgyalni. majd nyomjuk meg az F1 7. Sok tulajdonság közös több komponensnél is. vagy egy saját ablakot hoznak létre.1. hogy a felhasználó az értéket a jobb szélén található fel és le nyilak segítségével állítsa be. PopupMenu. Néhány komponensnek van saját tervez je (Designer-je) is. Timer. Néhány komponens a tervezésnél az ablakunkban már a végleges állapotában jelenik meg (pl. de a programban ott van és használhatjuk az összes funkcióját (pontosabban metódusát). Ha szeretnénk tudni valamelyik tulajdonságról többet. amely alkalmas például egész számok bevitelére.SpinEdit Praktikus komponens. Ennek a fejezetnek a további részében csak azokkal a tulajdonságokkal fogunk foglalkozni. az alkalmazás futása alatt pedig a programkód segítségével egyszer olvasással (pl. ). Továbbá megkülönböztetünk még read-only (csak olvasni lehet) és write-only (csak írni lehet) tulajdonságokat. Komponensek tulajdonságaik Minden valójában az komponensnek adott osztály – vannak tulajdonságaik – (melyek A komponens attribútumai). írással ill. de a viselkedését is. A klasszikus beírás mellett megengedi. Most csak a közös tulajdonságokat soroljuk fel. Az utóbbiak olyan komponensek. amely segítségével könnyebben beállítható a komponens külalakja és tulajdonságai. amely az alkalmazás futásakor nem látható. megtalálhatók az Objektum felügyel ben. Az Objektum felügyel ben a komponenseknek csak azokat a tulajdonságokat találjuk meg. Komponens neve és felirata 24 25 . Ennek hatására megjeleni a Delphi súgója a kijelölt tulajdonságra.Caption := ‘Címke új felirata’. tulajdonságok nem csak a komponens külalakját határozzák meg. funkcióbillenty t. melyek hozzáférhet k a tervezés alatt. Ezen kívül léteznek még úgynevezett run-time tulajdonságok is. Button. egyáltalán nem láthatók. melyek a tervezés alatt is elérhet k. melyek az alkalmazás futtatásakor mindig másképp nézhetnek ki. melyek csak egy-egy komponensnél találhatók meg. melyek csak az alkalmazás futása alatt érhet k el. némelyik azonban egy kis négyzettel van ábrázolva (pl. Ezek a tulajdonságok általában csak a program futásakor érhet k el. amely minden komponensnél léteznek. de 7. Edit. vagy a StatusBar. MainMenu. OpenDialog. Ide tartozik például a Timer komponens is. klikkeljünk rá az adott tulajdonságra. tehát. Label. Ilyen komponens például a MainMenu. …). …). Az alkalmazás létrehozása alatt a tulajdonságok értékeit az Objektum felügyel segítségével tudjuk megváltoztatni. vannak olyan egyedi tulajdonságok is.

az ablak átméretezésekor is? Erre szolgál az Anchors tulajdonság. A komponens nevének egyedinek kell lennie a tulajdonosán belül. Ha a feliratban az & jelet szeretnénk megjeleníteni. meg kell azt dupláznunk (&&). Ennek megadásával a komponenst nem fogjuk tudni onnan leválasztani.3. hanem a alkalmazás futtatásakor nem lehet majd a megadott méretnél kisebbre. görget sáv-nak átméretezésénél is ott marad az ablak teljes szélességében (ill. magasságában). A komponens neve egy azonosító. ha a komponenst valamilyen kis távolságra szeretnénk elhelyezni a form szélét l úgy. Ha a komponens nevét nem állítjuk be.2. Felirattal nem lehet ellátni olyan komponenseket. és ugyanolyan is. mint egy másik komponensé. amellyel az alkalmazásban a komponensre hivatkozni tudunk. de nem lehet ugyanolyan nev komponens egy ablakon belül. Ezt az Align tulajdonság segítségével tehetjük meg. hogy mindig ugyanakkora távolságra legyen t le. A komponens mérete és elhelyezkedése A komponens elhelyezkedését a Left (bal szélét l) és Top (tetejét l) tulajdonságok adják meg. 7. Az utolsó mérettel és elhelyezkedéssel kapcsolatos érdekes tulajdonság a Constrains. melyek segítségével megadhatjuk a komponens lehetséges minimális és maximális egy méretét. a komponens felirata (Caption lehet (magasság) tulajdonsága határozza meg. vagy egyenesen rajta a komponensen nincs felirata). A komponens méretét a Width (szélesség) és Height tulajdonság). Ha a komponens feliratában valamelyik bet elé & jelet teszünk. Ha például akkor beállítjuk az ezt a az tulajdonságot alkalmazás ablakánál. hogy a komponens mindig az ablak (form) valamelyik részéhez illeszkedjen (ragaszkodjon). Hasonlóan a Left és Top tulajdonságokhoz az értékük képpontokban (pixelekben) van megadva. pl. amelyeken ugyanolyan nev komponens van. Button) és egy sorszámból áll. Segítségével megadhatjuk. De mit tehetünk. akkor a tulajdonosa az ablak (form) és ennek bal fels sarkához képest van megadva a nyomógomb elhelyezkedése (Left és Top tulajdonsága). a Delphi automatikusan beállít neki egy nevet. Button5. A felirat segítségével lehet beállítani a komponens gyors elérését is a felhasználó számára. A névvel ellentétben lehet. hogy a komponens a form melyik széléhez (vagy széleihez) illeszkedjen. Néhány komponensnél beállíthatjuk. A felirat például az ablak tetején jelenik meg (Form komponensnél). A komponens engedélyezése és láthatósága 27 26 . A tulajdonságok a koordinátákat nem az egész képerny höz viszonyítva tartalmazzák. az ablak tulajdonság) bármilyen tartalmazhat szóközöket.Minden komponensnek a Delphi-ben van neve (Name tulajdonoshoz (szül höz) viszonyítva. illetve nagyobbra méretezni. Egyszer bben megfogalmazva az alkalmazásunkban lehet két ablak (form). amely a komponens típusából (pl. és a felhasználó ezt a komponenst kiválaszthatja az Alt + aláhúzott bet billenty zetkombináció segítségével. ablakot 7. Ennek a tulajdonságnak négy altulajdonsága van. akkor ez a bet a feliratban alá lesz húzva. Ha például egy nyomógombot helyezünk el közvetlenül az ablakunkon (form-on). (Button). melyeknél ennek nincs értelme (pl.

stb.). CC – a zöld összetev mennyiségét határozza meg. Szükség esetén áttipizálással bármilyen más 4 bájt hosszúságú értéket is írhatunk bele (pl. Megjegyzés: Ha a Visible tulajdonság értéke igaz egy komponensnél. A másik hasonló tulajdonság a Visible. clBtnFace.) a Visible tulajdonsága hamis. a komponensen megjelen felirat bet típusát (ha a komponensen megjeleníthet felirat). de az alkalmazás futásakor a komponens „szürke” lesz. Ha ugyanis a komponens tulajdonosának (tehát amin a komponens van. ahol: • • • • AA – a színpalettát határozza meg. TPanel. stb. Sokkal áttekinthet bb a felhasználó számára. jel) a komponensek egy különös tulajdonsága. 28 29 . összetev ik (piros. clBlue. Alapállapotban ebben a tulajdonságban egy LongInt típusú értéket tárolhatunk. ez általában 00. ha az alkalmazásunk éppen nem állítható (a felhasználó számára nem elérhet ) komponensei szürkék. TForm. Segítségével beállíthatjuk. zöld. stb. hogy a komponens nem látható. clGreen.4. mivel a felhasználóknak zavaró lehet. Ez csak egy kiegészít memóriaterület.). Komponensek színe és bet típusa A komponensek Color (szín) és Font (bet típus) tulajdonságaik segítségével beállíthatjuk a komponens háttérszínét. stb. akkor sem a tulajdonos. Alapértelmezésben ez mindig igaz (true). amely egy run-time (csak futási id ben elérhet ) és read-only (csak olvasható) típusú tulajdonság. clRed. Ebben az esetben a szín megadására egy 4 bájtos hexadecimális számot használunk. inkább használjuk csak az Enabled tulajdonságot. mutatót.5. A komponensek „Tag” tulajdonsága A Tag tulajdonság (lefordítva: hozzáf zött cédula. Ezért létezik a komponenseknek egy Showing tulajdonsága. hogy a komponens látható legyen-e az alkalmazás futásakor. Ha átállítjuk hamisra (false). ill. A színt ezeken a konstansokon kívül megadhatjuk az komponensünk látható a képerny n. segítségével tudjuk beállítani.A komponens engedélyezését az Enabled tulajdonság 7. sem a rajta lev komponensek nem láthatók. hogy a komponensünk valóban látható-e a képerny n.). clWindow. ha átállítjuk hamisra (false) csak az alkalmazás futtatásakor vehetjük majd észre. A Color tulajdonság értékét megadhatjuk el re definiált konstansok segítségével: clXXX formában. ha például nyomógombok t nnek el és jelennek meg. melynek formája: $AABBCCDD. karaktereket. Ennek a tulajdonságnak a beállítása semmilyen hatással nem jár. nem reagál majd a rákattintásra. vagy a Windows által a rendszerelemekre használt színek neveit (pl. tervezési módban nem történik látszólag semmi. pl. hogy a 7. ahol különféle felhasználói adatok tárolhatók. Az XXX helyére vagy a szín nevét írhatjuk angolul (pl. BB – a kék összetev mennyiségét határozza meg. tervezési id ben itt sem fogunk látni különbséget. Programunkban ahol lehet. az még nem jelenti feltétlenül azt. DD – a piros összetev mennyiségét határozza meg. Ennek a tulajdonságnak az értéke megadja. de a helyükön vannak és láthatók. kék) segítségével is. tehát nem használhatók. Az alapértelmezett értéke ennek a tulajdonságnak is igaz (true).

Azt. paranccsal tehetjük ilyen formában: 7.Például: $00FF0000 – telített kék szín (clBlue). A bet stílusát hasonlóan állíthatjuk be. Ha a program futása alatt szeretnénk beállítani a Font tulajdonság valamelyik elemét (altulajdonságát). A számozás 0-tól kezd dik.6. Ide egy számot kell beírnunk.Size := 18.Font. crUpArrow (felfelé mutató nyíl).8. Az egérmutató beállítása Sok tulajdonsággal. $00609025 – sötétzöld szín.7. A Font tulajdonság értéke egy TFont típus lehet. hányadik lesz a komponens a sorrendben. (egérmutató) hogy az meg: Button1. 7. Komponens lebeg súgója A komponens Hint (javaslat) tulajdonságának köszönhet en az objektum felett egérrel elhaladva egy sárga téglalapban információt 30 . például egy közölhetünk a felhasználóval (ha megnyomja pl. Így egyetlen tulajdonság átállításával (a form ShowHint tulajdonságával) beállíthatjuk. stb. tehát Button1. $003050A0 – barna szín. $00FFFFFF – fehér szín (clWhite). A TFont osztály egyes elemeit beállíthatjuk az Objektum felügyel ben. Így be tudjuk egyszerre állítani az ablakunkon lev összes komponens színét és bet típusát a form-unk Font és Color tulajdonságainak beállításával. stb. Ezekkel beállíthatjuk. ha az adott komponens felett áll. nyomógombon a bet csak ezt halmazként méretét. fsItalic ]. hogy ez a segítség megjelenjen-e a felhasználónak. akkor mi fog történni). A komponens ShowHint (javaslatot megjelenít) tulajdonságával megadható.Style := [ fsBold. hogy a TAB billenty megnyomásakor milyen sorrendben legyenek aktívak a komponensek a TabOrder (TAB sorrend) tulajdonság segítségével állíthatjuk be. ha a Font mellett rákattintunk a „+“ jelre. $000000FF – telített piros szín (clRed). ha a komponens tulajdonosának (ami általában a form) a ShowHint tulajdonsága igaz. a gombot. A kiírandó segítséget a komponens Hint tulajdonságához kell hozzárendelnünk (megadnunk az Objektum felügyel ben). hogy a komponenshez a javaslat akkor jelenjen meg. Tabulátor Ha az alkalmazásunknak több komponense van.Font. egérmutatónak milyen alakja legyen. crHelp (nyíl kérd jellel). crCross (kereszt). $00000000 – fekete szín (clBlack). A legtöbb komponens tartalmaz egy ParentColor (szül színe) és egy ParentFont (szül bet típusa) tulajdonságot is. A ParentShowHint tulajdonsággal meghatározhatjuk.form) a színét és bet típusát használja. amely azt jelenti. azt a következ kell megadnunk. komponens Ennek rendelkezik segítségével Cursor beállíthatjuk. jó ha intelligensen m ködik a TAB billenty . Lehetséges értékek: crHourGlass (homokóra). $0000FF00 – telített zöld szín (clGreen). 31 7. hogy az ablak összes komponensére megjelenjen-e a javaslat vagy nem. hogy a komponens a tulajdonosának (ami leggyakrabban az alkalmazás ablaka .

majd ha rövid id n belül (ahogy a Windows-ban be van állítva) érkezik második klikkelés is. Itt nem az ablak (form) aktiválásáról van szó. stb. Az el z esemény ellentettje. read-only). ahogy mi azt szeretnénk. OnClick 8. ha befejeztük a bevitelt az Edit komponensbe és máshova kattintunk. melyek majdnem minden komponensnél el fordulnak. hanem Enter. Ahhoz. Ez az egyik leggyakrabban használt esemény. Duplakattintáskor az els klikkelésnél OnClick esemény következik be. Hasonlóan. 32 33 . Összefügg a Modified tulajdonsággal (run-time. megnyomunk egy billenty t. Sokszor szükségünk van rá. ha pl. vannak olyan események is. stb. hogy a komponens tartalma megváltozott-e. Gyakran használatos az Edit és Memo komponenseknél. hanem a komponens aktiválásáról. például ha Edit komponensbe kattintunk. ill. ha a komponens aktív (például egy aktív nyomógomb). tulajdonságaik. Erre szolgálnak az események. Ezek közül a legfontosabbak a következ k: OnEnter Amikor a komponens aktiválva lett. ahogy a komponenseknek vannak olyan OnDblClick A komponensre kattintáskor az egér bal gombjával. hogy egy eseményere a komponens úgy reagáljon. Space billenty k megnyomásakor is bekövetkezik. meg kell írnunk az eseményhez tartozó programkódot (eljárást). amelyek szinte minden komponensnél megtalálhatók. ha hamis. ha csak a tulajdonságait állítjuk be. stb. hanem a sorban következ re megy át). a szöveg az Edit komponensben). rákattintunk egérrel. akkor bekövetkezik az OnDblClick esemény. A komponensre duplakattintáskor az egér bal gombjával. hogy az adott komponensre lehet-e egyáltalán a tabulátor segítségével eljutni (ha a TabStop értéke igaz. OnChange Ha a komponens vagy annak tartalma megváltozik (pl. Események A legtöbb komponensnél nem elég.A TabStop (TAB áljon meg) tulajdonság segítségével beállíthatjuk. akkor lehet. hogy az adott komponens valamilyen tevékenységet végezzen. Például akkor következik be. Komponensek eseményeik: Esemény Mikor következik be Megjegyzés OnExit Amikor a komponens deaktiválva lett. mozgatjuk felette az egeret. akkor nem lehet – a tabulátor nem áll meg a komponensen. Ez az esemény nem csak egérkattintáskor. amely megadja. amikor az egyik ablakból átmegyünk a másikba.

OnKeyPress Amikor a komponens aktív és a felhasználó lenyom egy billenty t. ssCtrl). vagy Ctrl billenty (ssAlt. amely éppen az egérmutató alatt van. és ne az éppen aktív komponens. annak a komponensnek az eseménye következik be. amely a lenyomott billenty t ASCII jelét (bet t. írásjelet) tartalmazza. Amikor a felhasználó lenyomja valamelyik egérgombot. hogy a lenyomott billenty t a form kapja meg (méghozzá a komponens el tt). akkor mindegyik felengedésénél létrejön ez az eljárás. A különbség ez el z eljárástól.OnKeyDown Amikor a komponens aktív és a felhasználó lenyom egy billenty t. Felhasználhatjuk az eljárás Key paraméterét. OnDeactivate Amikor az ablak inaktívvá válik. OnMouseDown Általában annak a komponensnek az eseménye következik be. OnMouseMove Amikor a felhasználó megmozdítja az egeret a komponensen. amelynek van ASCII jele (tehát nem Shift. hogy le volt-e nyomva az Alt. A gomb felengedésénél jön létre. ssShift. Amikor a felhasználó felengedi valamelyik egérgombot. mint az OnKeyDown eseménynél. számot. amely megadja a lenyomott billenty virtuális kódját (virtual key codes). tehát elhagyja a mi ablakunkat. Key és Shift paramétere hasonló. Ez az esemény csak olyan billenty lenyomásakor következik be. Ha a felhasználó egy másik ablakra (vagy alkalmazásra) klikkel. amely az egérmutató alatt van. F1 és hasonlók). ha a felhasználó egy másik ablakból (vagy alkalmazásból) erre az ablakra klikkel. Továbbá a Shift paraméter (amely egy halmaz típusú) segítségével meghatározhatjuk. Ha több egérgomb van lenyomva. Hasonlóan az el z höz. OnKeyUp Amikor a komponens aktív és a felhasználó felenged egy billenty t. akkor a form KeyPreview tulajdonságát át kell állítanunk igazra (true). Megjegyzés: Ha azt szeretnénk. OnMouseUp Ablak (form) eseményei: Esemény OnActivate Mikor következik be Amikor az ablak aktívvá válik. Shift. 34 35 . Megjegyzés Akkor van generálva ez az eljárás. hogy itt a Key paraméter char típusú.

utána az OnClose.) a Számítások gomb megnyomásakor pedig a következ számítás menjen végbe. ill. elrejtésekor. OnHide Az ablak megmutatásakor. j:=0. Ezek az eljárások szorosan összefüggenek az ablak Visible tulajdonságával. A Kilépés megnyomásakor fejez djön be az alkalmazás (Form1. Mindenekel tt készítsünk egy egyszer bemutatjuk a hibakeresést.j: integer. amelyen A programon két nyomógomb (Számítások és Kilépés felirattal) és egy címke legyen. OnClose Ha az ablakot bezárjuk (Alt-F4. 9. Az ablak bezárásakor el ször az OnCloseQuery esemény következik be. begin Látható ablakok (melynek a visible tulajdonságuk igaz) létrehozásakor az események bekövetkezéseinek a sorrendje a következ : OnCreate.OnCloseQuery.Button1Click(Sender: TObject). megszüntetésekor. melyeket ne feledkezzünk el megszüntetni az OnDestroy eljárás kezelésében. OnPaint.Caption:=IntToStr(j). OnActivate. Az OnCreate esemény kezelésében lehet ségünk van dinamikusan létrehozni objektumok. 020 programot. „Biztos hogy kilépsz?”) vagy az adatok elmentésének figyelmeztetésére.). Itt a paraméterben megadhatjuk. Az els esemény szolgálhat meger sítésre (pl.Close. Hibakeresés 36 37 . var i. OnDestroy Az ablak létrehozásakor ill. OnShow. OnShow. procedure TForm1. X a jobb fels sarokban. for i:=1 to 10 do j:=j+i. Label1. stb. melynek végeredményét kiíratjuk a címkébe: OnCreate. Az alkalmazás bezárásának elkerülésére még az OnClose eseménynél is van lehet ségünk. end. rendszermenü segítségével. hogy az ablakunk bezárás helyett csak elrejtve vagy minimalizálva legyen.

Itt leáll. Ilyen ideális eset azonban ritkán fordul el . beleugrik az alprogramba és ott is soronként lépeget tovább. Azokkal a hibákkal. amíg ahhoz a sorhoz nem ér. a program hagyományos módon elindul és fut mindaddig. Ezért a Delphi tartalmaz egy integrált debugger-t rengetek eszközzel hibák megkeresésére. helyesen fog m ködni. és innen lépegethetünk tovább például a fent említett eszközökkel. Ha rákattintunk a hibaüzenetre és megnyomjuk az F1 funkcióbillenty t. nem a helyes eredményt kapjuk. hogy ha lépésben) elvégzi. hogy a programunk hiba nélkül fut. Step Over lépegetés Hasonló az el z egy blokként (egy eszközhöz annyi különbséggel. Ha alprogram hívásához érünk. melyeket a fordító nem jelez. és a sor el tt 38 39 . Az ilyen hiba esetében a program nem fut le. Mi ezek közül az fogjuk bemutatni a leggyakrabban használtakat. nem ugrik bele az alprogramba. és a szemantikai hibák – parancsok logikailag rossz sorrendbe használata). Az ilyen hibáknál a program elindul és mi abban a meggy z désben élünk. ahol a kurzorral álltunk. melyeket a fordító kijelez. Ilyenkor használhatjuk a hibakeresésre használható eszközöket. Egyszer bben F8 alprogram hívásához érünk. Ezzel az eszközzel lépegetni tudunk soronként az alkalmazásunkban. • és olyan hibákra melyeket a fordító nem jelzi (logikai hibák). Egyszer bben az F7 funkcióbillenty vel indíthatjuk el. elolvashatjuk a hiba részletes leírását. hogy a Delphinek megadhatjuk. majd „Ok” (vagy rákattintunk a sor elején a kék körre – ). majd lefordítjuk és futtatjuk. Némely esetekben azonban el fordulhat. hogy például a számítások eredményeként.Ha ezt az alkalmazás elmentjük. a kurzor mindig a hibás sorban áll és megjelenik egy hibaüzenet. A programunkban el forduló hibákat durván két csoportra oszthatjuk: • olyan hibákra. melyeket a fordító kijelez (ide tartoznak a szintaktikai hibák – elírt parancsok. Ekkor a kijelölt sor háttere átszínez dik. melyeket a menüben a Run alatt találunk. Nehezebb megtalálni azonban az olyan hibákat. Run to Cursor Ha ráállunk a kurzorral valamelyik sorra a forráskódban és ezzel (vagy egyszer bben az F4 funkcióbillenty vel) indítjuk el. kiválasztjuk a menüb l a Run – Add Breakpoint – Source Breakpoint… menüpontot. Gyakorlatban: Trace Into lépegetés ráállunk valamelyik sorra a forráskódban. hogy a programunk melyik pontján álljon meg. Ezek közül a leggyakrabban használtak: Breakpoints (Add Breakpoint – Source Breakpoint…) A breakpoint (megszakítás pontja) úgy m ködik. illetve léphetünk tovább a következ sorra. most nem fogunk foglalkozni. hanem azt funkcióbillenty vel érhetjük el.

vagy odaállunk a kurzorral és elindítjuk a programot a „Run to Cursor” segítségével. leáll. Komponensek megnevezése Ha komolyabb alkalmazást készítünk. a „Step Over” segítségével. nem jó ötlet a komponenseknek meghagyni azokat a nevüket. Ha a program a futása során breakpoint-hoz ér. ahonnan lépegethetünk tovább egyesével az els két eszköz segítségével (F7. Egy programban több breakpoint-ot is elhelyezhetünk. majd futtathatjuk tovább a Run – Run (vagy F9 segítségével). hogy kijelöljük a programban Breakpoint-ot. Közben figyelhetjük a kiválasztott változók értékeit. Kisebb alkalmazás készítésénél ez 40 41 . de ha mégsem jelenne meg a View – Debug Windows – Watches menüvel hívhatjuk el ). Ebben az esetben hívhatjuk meg a Run – Program Reset menüpontot (vagy CTRL+F2). Új változót vagy kifejezést a Run – Add Watch… (CTRL+F5) menüpont segítségével adhatunk a figyelt változók közé (a Watch Listbe). figyelhetjük. Ez egy nagyon hasznos eszköz. hogy a program ebben a sorban le fog állni. változók de vagy megváltoztathatjuk tulajdonságok értékeit. Ez jelenti azt. Az itt felsorolt módszerek csak javaslatok. ha például az „i” változóban nem 7. Nagyobb projektek készítése Ebben a fejezetben nagyobb projektek készítésének alapelveir l lesz néhány szó. nem szükséges ezek szerint írni az alkalmazásunkat. F8). Gyakorlatban ezt úgy használjuk. A változók értékeit a a Watch List ablakban követhetjük nyomon (ez az ablak automatikusan megjelenik a program indításakor.egy piros kör jelenik meg ( ). olvashatóbb és érthet bb lesz a projektünk. Ezt az eszközt egyszer bben a CTRL+F7 funkcióbillenty vel hívhatjuk el . Watch (Add Watch…) A program lépegetése közben ennek az eszköznek a Program Reset El fordulhat. hogyan viselkedne a program. 10. hogy a programunk futását le szeretnénk állítani és elölr l futatni. A breakpoint-ot a piros körre ( ) kattintva szüntethetjük meg. ahonnan a változókat figyelni szeretnénk. hanem 1500 lenne. ha arra vagyunk kíváncsiak. Majd az „Add Watch…” (vagy CTRL+F5) segítségével beállítjuk a figyelni kívánt változókat és elkezdünk lépegetni a „Trace Into” ill. hogy a programunk lefagy. vagy csak egyszer en olyan helyzetbe kerülünk. Evalute / Modify Ennek mindenekel tt az eszköznek a segítségével a kifejezések. de ezek betartásával sokkal áttekinthet bb. segítségével figyelhetjük az egyes változók érékét. melyeket a Delphi automatikusan rendel hozzájuk. A programot utána elindítjuk a Run – Run (vagy F9) segítségével.

könnyen olvasható legyen mások számára is és f leg saját magunknak is. procedure ShowMessage(const Msg:string). ha a nagy és kisbet k használatában mint a rendet tartunk és követünk vagy a valamilyen logikát. szóközök – ne spóroljunk az üres sorokkal és a bekezdésekkel (beljebb írásokkal). A legjobb a sablon alapján. viszont ilyent csak ritkán készítünk.’). a beviteli mez t megnevezhetjük edtXXX-nek. • Megjegyzések – hasznos megjegyzések gyakori használata nagyon egyszer . szóközökkel a programunkban. használatával az alkalmazásunkban sok id t és problémát spórolhatunk meg magunknak a jöv ben.1.lényegtelen. Az ilyen a esetekre standard a Delphi egy elegáns Ezek rendelkezik: üzenetablakokkal. Ez a legegyszer bb standard üzenetablak. hogy biztos ki akar-e lépni. btnSzamitasok. megkérdezni t le. 42 43 . • Bekezdések. Például a „btnKilepesClick” sokkal áttekinthet bb. például: btnKilepes. hogy a program könnyen áttekinthet . Például: ShowMessage(’Ez egy rövid kis információ. ShowMessage Ha csak a egy egyszer szöveget akkor szeretnénk kiíratni a üzenetablakban Szintaxisa: felhasználónak. üres sorok. Nyomógombot például btnXXX-nek nevezhetünk el. akarja-e menteni a dokumentumot. stb. mégis a beállítások és megjelenítések széles választékával rendelkezik. képet imgXXX-nek. A lényeg. megoldással stb. hogy a felhasználót értesíteni szeretnénk például a számítások állapotáról. Standard üzenetablakok Az alkalmazásunkban nagyon sokszor el fordulhat. Megjegyzést a forráskódba tehetünk {kapcsos zárójelek} közé vagy két törtvonal // segítségével a sor elején. figyelmeztetni a hibákra vagy a rosszul megadott bemeneti értékekre. elteltével újra át szeretnénk 11. használhatjuk ShowMessage eljárást. 11. Ezek megfelel komponenseket megnevezni valamilyen áttekinthet használatával programunk sokkal áttekinthet bb lesz. „btnkilepesclick” „BTNKILEPESCLICK”). ha wndXXX-nek nevezzük el). Az ablakunkat (form-ot) legjobb frmXXX-nek elnevezni (vagy talán még jobb. ha majd valamennyi id nézni. Ennek ellenére jó. ahol XXX a nyomógomb funkcióját írja le. Forráskód külalakja Az alábbi javaslatok betartásával olvasható és áttekinthet forráskódot tudunk majd írni: • Nagy és kisbet k – a Delphi (Pascal) nem case-sensitive programozási nyelv.

mbAll. Például: if MessageDlg(‘Elmenteni a fájlt?’. mbYesToAll. nyomógombokat szögletes zárójelek között kell felsorolnunk. mtConfirmation. mbRetry. mrIgnore. mrNo. mbCancel]. 0) = mrYes then mentsd_el(fajlnev). mbNo. [mbYes. hogy melyik gombok jelenjenek meg az üzenetablakon. mint az [mbOk. mrAll. Lehetséges értékek: o o o o o mtWarning – figyelmeztetést jelz sárga-fekete ikon mtError – hibát jelz piros „stoptábla” mtInformation – információt jelz kék „i” bet mtConfirmation – kérdést jelz kék kérd jel mtCustom – az üzenetablakon nem lesz kép • HelpCtx: a súgó azon témájának „Context ID”. Lehetséges értékek: o mbYes. Szintaxisa: function MessageDlg(const Msg:string.2. ha valamelyik el re definiált konstanst használjuk (például az mbOKCancel ugyanazt jelenti. például: [mbAbort. mbCancel]). mbRetry. mrRetry. DlgType: TMsgDlgType. Lehetséges értékek: mrNone. amely megjelenjen. mrCancel. ha megnyomjuk az F1 billenty t. adjunk meg 0-t. mbCancel. Ezzel a függvénnyel az üzenetablakunk külalakját jelent s mértékben formálhatjuk. mbIgnore. mbIgnore]. amit meg szeretnénk jeleníteni DlgType: az üzenetablak célját jelzi. ezért a kiválasztott Az üzenetablak felirata (nálunk „Project1”) ugyanaz. mbAbort. mrOk. amellyel a felhasználó bezárta az üzenetablakot. A paraméterek leírása: • • Msg: a szöveg. mbOK. mbNo. 44 45 . Ez alól egyedüli kivétel. HelpCtx: Longint): Word. MessageDlg Az el z eljárásnál többet tud a MessageDlg függvény. mbNoToAll. Ha ezt nem akarjuk használni. 11. mbHelp Figyelem: Itt egy halmazt kell megadnunk.• Buttons: indikálja. mrYes. mrAbort. Buttons: TMsgDlgButtons. mint az alkalmazás futtatható (exe) állományának a neve. A MessageDlg visszaadja annak a nyomógombnak az értékét.

12. o o Caption – felirat. Grayed. és a felhasználónak nem ugrálnak állandóan ablakok (mint ahogy az lenne az üzenetablakok 12. X. azonban ez nagyon sokszor nem megfelel . Információk bevitele Az információkat a programunkba komponensek segítségével vihetjük be. cbGrayed.1. Ez néha nem megfelel . Y: Integer): Word. pontosabban valamely osztály objektumaira vonatkoznak). hogy az üzenetablak mindig a képerny közepén jelenik meg. Logikai értékek bevitelére használhatjuk a programunkba a már említett üzenetablakokat is. melyek csak valamely komponensekre. HelpCtx: Longint. Szerencsére a Delhi-ben létezik az el z függvénynek egy kib vített változata. eseményeivel és metódusaival (metódus = olyan függvények és eljárások. akkor a jelöl négyzetnek három lehetséges értéke lehet: Checked. de ennek értéke háromféle lehet: cbChecked.3. Szintaxisa: function MessageDlg(const Msg:string. hogy állandóan látható ki van-e jelölve. Jelöl négyzet használata – CheckBox El nye. 46 47 . Checked – megadja hogy ki van-e pipálva a jelöl négyzet (true) vagy nincs kipipálva (false). Az itt tárgyalt komponensek szinte mindegyike ugyanúgy kimenetre is szolgálhat. Ezért ne olvassuk ezt a fejezetet úgy. o State – hasonló az el z höz. cbUnchecked. A CheckBox fontosabb tulajdonságai: o AllowGrayed – ha ennek a tulajdonságnak az értéke igaz (true). MessageDlgPos Az el z függvény egyik hátránya. amely a jelöl négyzet mellett szerepeljen. Ennél sokkal megfelel bb a CheckBox (jelöl négyzet) használata. melyekkel logikai értéket (igen-nem vagy 0-1) vihetünk be az alkalmazásunkba. a MessageDlgPos. Egyébként csak két értéke lehet. DlgType: TMsgDlgType. egyetlen kattintással kijelölhet . de sok komponens ugyanúgy használható bevitelre. mint adatok megjelenítésére (kimenetre). Ebben a fejezetben veszünk néhány példát ezek használatára és megismerkedünk az egyes komponensek további (egyéni) tulajdonságaival. mint bemenetre. hogy ennek a fejezetnek a címe „információk bevitele”. Igaz. Buttons: TMsgDlgButtons. hogy itt csak azok a komponensek szerepelnek. áttekinthet el használatánál ez helyett).Kezdjük a legegyszer bb beviteli komponensekt l. 11. mellyel adatokat vihetünk be a programunkba. plusz még további két paramétere mellyel megadhatjuk az üzenetablak helyét a képerny n. Unchecked. melynek ugyanolyan paraméterei vannak mint a MessageDlg függvénynek.

Ha már ki van választva egy. de nem szüntethetjük meg a kiválasztást. hogy a csoporton belül egy gomb se legyen kiválasztva. tehát egyet mindenképpen ki kell választanunk. Columns – segítségével megadhatjuk. Ezt a következ képpen határozhatjuk meg: if CheckBox1. A RadioButton komponensek szinte mindig valamilyen logikai csoportot összekapcsoló komponensen vannak rajta (GroupBox. Ha értéke -1 akkor egyik sincs kiválasztva. kiválaszthatunk egy másikat.Checked = true then … Vagy használhatjuk „rövidített” változatban is: if CheckBox1. hogy melyik választógomb (lehet ség) van kiválasztva. hogy a gomb ki van-e választva. o ItemIndex – ennek a tulajdonságnak az értéke tartalmazza. Az egyik legfontosabb tulajdonsága: 48 49 . de ez csak ritkán szokott el fordulni. választógomb van kijelölve (tehát a számozás 0-tól kezd dik). az ItemIndex tulajdonság tesztelésével vizsgálhatjuk: 12. Nagyon egyszer en tudjuk a jelöl négyzetek értékeit kiolvasni. de lehet közvetlenül a form-on (ablakunkon) is. ha 1 akkor a második. hogy a felhasználó kijelölte-e az els jelöl négyzetet (és ha igen. Azt.o Checked – értéke (true/false) megadja. hogy melyik nyomógomb van kiválasztva. Az egyes lehet ségek neveit külön-külön sorban adjuk meg. mivel itt a csoporton belül mindig csak egyet lehet kiválasztani. milyen választógombok szerepeljenek a komponensünkön (tehát mib l lehessen választani). Választógomb csoport – RadioGroup A RadioGroup komponens legfontosabb tulajdonságai: o Items – értéke egy TStrings típus lehet. A „karikákat” a RadioGroup komponens kirakja automatikusan minden sor elé. ha 0 akkor az els . Panel komponenseken). hogy a választási lehet ségek (választógombok) hány oszlopban legyenek megjelenítve.3. o 12. akkor el szeretnénk végezni valamilyen m veletet).2. Az alkalmazás indításakor megoldható. stb. Több RadioButton komponens használata helyett azonban jobb használni inkább egy RadioGroup komponens. Ennek segítségével adhatjuk meg. Választógomb – RádioButton Ez a komponens általában csoportokban fordul el .Checked then … Az adatok felhasználótól való beolvasásán kívül természetesen nagyon jól használható a CheckBox logikai értékek megjelenítésére is. Például meg szeretnénk tudni.

Ezen könnyíthetünk. hogy a bevitt szöveg helyett csillagocskák vagy más jelek jelenjenek meg – igy használhatjuk jelszó bevitelére). Az egyes paraméterek leírása: • • • ACaption: a dialógusablak felirata. 50 51 Például: . Egysoros szöveg beviteli doboz – Edit 12. o Az Edit komponensnek sok specifikus tulajdonsága van. HELLO = 1.ItemIndex = SZIA then … Természetesen ennél az eszköznél sokkal jobban felhasználható egysoros szöveg bevitelére az Edit komponens. APrompt. vagy formátozhatjuk (például megadhatjuk egyetlen tulajdonság beállításával. Beolvasás „üzenetablak” segítségével Egysoros szöveg beolvasásához használhatunk egy újabb „üzenetablakot”.5. vagy beállíthatjuk az Edit komponensben lev szöveget. ha például a számok helyett konstansokat definiálunk (const SZIA = 0. melyik lehet séghez melyik szám tartozik. melyek segítségével az egysoros bevitelt korlátozhatjuk. …) és ezek segítségével teszteljük a feltételt: if RadioGroup1. 12. ''). Segítségével kiolvashatjuk.4.ItemIndex = 0 then … Ez a tesztelés azonban nagyon sok programozónak nem a nev := InputBox('Név megadása'. Az Edit komponens legfontosabb tulajdonságai: o Text – ez a tulajdonság tartalmazza a beviteli mez ben megjelen szöveget. MaxLength – az Edit-be megadható szöveg maximális hossza. 'Kérlek add meg a neved:'. ADefault: string): string. ADefault: a beviteli mez ben megjelen kezdeti szöveg.if RadioGroup1. legmegfelel bb. Segítségével beállíthatjuk milyen maximum milyen hosszú szöveget adhat meg a felhasználó. az InputBox-ot: function InputBox(const ACaption. mivel meg kell jegyezni. APrompt: a dialógusablakban megjelen szöveg.

o

Modified – annak megállapítására szolgáló tulajdonság, hogy a beviteli mez ben történt-e változás.

beadhat bet ket is, nem csak számokat. Ezek átalakításánál számmá természetesen a programban hiba következik be, melyet vizsgálnunk kell (pl. az átalakításhoz a Val függvényt használjuk, mely harmadik paraméterében visszaadja, történt-e hiba az átalakításnál). Például: val(Edit1.Text, k, hiba); if hiba<>0 then begin

o

AutoSelect – segítségével beállíthatjuk, hogy a beviteli mez be lépéskor ki legyen-e jelölve az egész szöveg. Ezt az szerint adjuk meg, hogy a felhasználó a mez ott lev értéket fogja módosítani. értékét el reláthatóan új értékkel fogja helyettesíteni, vagy csak az

o

ReadOnly

meghatározza,

hogy

a

felhasználó

Edit1.SetFocus; MessageDlg(‘Csak számot adhatsz meg!’, mtError, [mbOk], 0) end; A SetFocus metódus a példában csupán arra szolgál, hogy az Edit1-et teszi aktívvá, tehát ahhoz hogy új adatot adhasson meg a felhasználó, nem kell el ször rákattintania, mindjárt oda írhatja a számokat. Másik megoldás, hogy a bemenetnél kisz rjük azokat a karaktereket, melyek nem számok. Ennél azonban nagyon figyelmesen kell eljárnunk, ugyanis nem elég ha az OnKeyPress

megváltoztathatja-e az Edit-bel lev értéket. o PasswordChar – ennek a tulajdonságnak az értéke egy karakter lehet, amely meg fog jelenni a bevitelnél a bevitt karakterek helyett. Jelszó bevitelénél használhatjuk. Az Edit komponens több metódussal is rendelkezik, melyek közül az egyik: o CopyToClipboard – vágólapra másolja az Edit-bel lev szöveget. Az Edit komponens használata nagyon egyszer elég

eseményben

kisz rjük

a

nem

megfelel

karaktereket,

mivel

a

elhelyezni a komponens valahova a form-on. Ajánlott a komponens fölé elhelyezni mindjárt egy Label-t is, amely segítségével megadjuk mit kérünk a felhasználótól. Utána már csak pl. egy nyomógomb OnClick eseményében az Edit1.Text tulajdonság értékét ellen rizzük (ha szükséges) és felhasználjuk (pl. valahova máshova berakjuk, stb.). Sokkal érdekesebb a helyzet, ha a felhasználótól csak valamilyen számot szeretnénk beolvasni. Erre több megoldásunk is lehet: Megengedjük, hogy a felhasználó beadhasson szöveget is, majd az számmá alakítjuk. Ennek a hátránya, hogy a felhasználó
52

felhasználó a vágólapról való bemásolással továbbra is tud szöveget beilleszteni (tehát figyelnünk kell pl. az OnChange eseményt is). Példa a billenty zetr l való kisz résre az OnKeyPress eseményben: if not (Key in [’0’.. ’9 ’, #8]) then begin Key := #0; MessageBeep($FFFFFFFF); end; A MessageBeep egy Windows API függvény, ezért a súgó Delphi-hez tartozó részében nem található meg, csak a „Microsoft Platform SDK”
53

részben, ha az be van installálva. A függvény a Windows-ban beállított, eseményekhez definiált hangok lejátszására szolgál. Paraméterének lehetséges MB_OK. értékei: $FFFFFFFF, MB_ICONHAND, MB_ICONASTERISK, MB_ICONQUESTION, MB_ICONEXCLAMATION,

tehát hogy tudjon tabulátorokat (bekezdéseket) és új sorokat létrehozni a szövegben, ezeknek a tulajdonságoknak az értékeit igazra (true) kell állítanunk. Ha ezt nem tesszük meg, a felhasználó akkor is tud létrehozni bekezdéseket és új sorokat a Ctrl+Tab és Ctrl+Enter billenty zetkombinációk segítségével. o Text – hasonló tulajdonság, mint az Edit komponensnél. Memo komponensben lev szöveget tartalmazza. o Lines – segítségével a Memo-ba beírt szöveg egyes soraival tudunk dolgozni. Ez a tulajdonság TString típusú, melynek sok hasznos tulajdonsága és metódusa van. Például a Lines (TString) LoadFromFile és SaveToFile metódusaival be tudunk olvasni a merevlemezr l ill. el tudunk menteni a merevlemezre szöveget. A Lines tulajdonság használatát mutatja be a következ példa is:

12.6. Többsoros szöveg beviteli doboz – Memo
A Memo komponens segítségével az Edit-hez hasonló, de többsoros szöveget olvashatunk be. A Memo legfontosabb tulajdonságai: o Alignment – a sorok igazításának beállítására használható tulajdonság. Segítségével a sorokat igazíthatjuk balra, jobbra vagy középre. o ScrollBars görget sáv – tulajdonsággal meg, megadhatjuk, vagy ne hogy a

komponensen a vízszintes, a függ leges vagy mindkett jelenjen-e legyen egyik görget sáv se a komponensen. o WordWrap – igaz (true) értéke az automatikus sortördelést jelenti (ha ez a tulajdonság igaz, nem lehet „bekapcsolva” a vízszintes görget sáv, mivel ez a kett kölcsönösen kizárja egymást). o WantTabs, WantEnter – a Tab és Enter billenty knek minden komponenseknél más funkciójuk van. A tabulátor megnyomására általában a következ komponens lesz aktív a form-on. Ha szeretnénk, hogy a felhasználó a Memo komponensben használni tudja a Tab és Enter billenty ket, tulajdonság

procedure TForm1.Button1Click(Sender: TObject); begin Memo1.Lines.LoadFromFile(’c:\autoexec.bat’); ShowMessage(’A 6. sor: ’ + Memo1.Lines[5]); end;

54

55

o

LargeChange – az eltolás mértéke, ha a görget sáv sávjában kattintunk valahova, vagy a PageUp, PageDown billenty ket nyomjuk meg.

Ha meg szeretnénk határozni azt az értéket, amelyet a felhasználó beállított a görget sávon, azt legjobban az OnChange eseményben vizsgálhatjuk. Ha igazán szép görget sávot akarunk létrehozni, akkor a görget sáv mellé (vagy elé) tegyünk egy címkét (Label) is, amely folyamatosan a csúszka aktuális pozíciójának értékét mutatja.

12.7. Görget sáv - ScrollBar
Gyakori probléma a számok bevitele a programba. Számok bevitelére használhatjuk a már említett Edit vagy Memo komponenseket is. Most azt mutatjuk be, hogyan vihetünk be számokat a ScrollBar komponens segítségével. A ScrollBar legfontosabb tulajdonságai: o Kind – meghatározza, hogy a komponens vízszintesen (sbHorizontal) vagy függ legesen (sbVertical) helyezkedjen el. Az új ScrollBar kezdeti beállítása mindig vízszintes. Ebben a példában az RGB Windows API funkcióját használtuk a három o o Min, Max – meghatározza a határértékeket. Position – meghatározza a csúszka aktuális pozícióját (aktuális értéket). o SmallChange – az eltolás mértéke, ha a görget sáv szélein lev nyilakra kattintunk, vagy a billenty zeten lev nyilak segítségével állítjuk be.
56

színb l a végs szín meghatározására. Enne a függvénynek a szintaxisa: function RGB(red, green, blue: byte): cardinal; ahol red, green, blue az alapszínek (piros, zöld, kék) mennyiségét jelölik, mindegyik értéke 0-tól 255-ig lehet. Ezeket az értékeket (0, 255) megadtuk mindegyik görget sáv Min (0) és Max (255) tulajdonságában.
57

Position. ScrollBar2. o MaxValue – segítségével megadhatjuk a maximum értéket. Legfontosabb tulajdonságai: o Columns – oszlopok száma. rengeteg hasznos metódusa van.Color := RGB(ScrollBar1. o Items – a legfontosabb tulajdonság. Szintaxisuk: function IntToStr(Value: integer): string. és mint olyannak. A számot megadhatjuk billenty zet segítségével és egér segítségével is a komponens szélén lev fel-le nyilakra kattintva. Ebben a programkódban használtuk az IntToStr ill. Ezek egész számot alakítanak át szöveggé ill. end. Label4. ezért itt most csak a használatát ismerjük meg: try ertek := StrToInt(szöveg). except on EConvertError do … end.ScrollBar1Change(Sender: TObject). a lista egyes elemeit tartalmazza. Legfontosabb tulajdonságai: o o Value – meghatározza a beadott (kiválasztott) értéket. 12. 12. Listadoboz – ListBox A klasszikus listadoboz (ListBox) az egyik leggyakrabban hasznát kimeneti komponens. amit a felhasználó megadhat a SpinEditbe.8. fordítva. hogy a jobb szélén lev nyilakra függvényeket. StrToInt A SpinEdit komponens szintén számok bevitelére szolgál. function StrToInt(const S: string): integer. o Increment – megadja. MinValue – meghatározza a minimum értéket.Position). kattintva mennyivel növekedjen ill.Position. A kivételekr l még lesz szó a kés bbiekben. csökkenjen a SpinEdit aktuális értéke. amit a felhasználó megadhat a SpinEditbe. begin Label1. melyekben az adatok meg lesznek jelenítve.Position). Ha az utóbbi függvényben az S paraméter nem számot tartalmaz (hanem bet ket is).Az egyes görget sávok OnChange eseményeinek programkódjai durván a következ k: procedure TForm1.9.Caption := 'Piros: ' + IntToStr(ScrollBar1. Szám bevitele – SpinEdit segítségével 58 59 . Ez is TString típusú. ScrollBar3. akkor az átalakítás során az EConvertError kivétel következik be. hasonlóan a Memo komponens Lines tulajdonságához.

o

ItemIndex – az éppen kiválasztott elem sorszáma. A számozás 0-tól kezd dik. Ha nincs kiválasztva egyik eleme sem a listának, akkor az ItemIndex értéke -1. • •

(elemek számában), más elemeket tartalmaznak, vagy ha más sorrendben tartalmazzák az elemeket. Insert – új elemet szúr be a listába a megadott helyre. LoadFromFile – beolvassa a lista elemeit egy szöveges állományból. A sikertelen beolvasást a kivételek segítségével kezelhetjük, melyekr l kés bb lesz szó. • Move – egy helyével megadott elemet a listába egy másik (új) helyre helyez át. • SaveToFile – elmenti a lista elemeit egy szöveges állományba. A lista minden eleme egy új sorban lesz a fájlban. A sikertelen mentést a kivételek segítségével kezelhetjük, melyr l b vebben kés bbi fejezetekben lesz szó. Nézzünk meg egy példát ezeknek a metódusoknak a

o

MultiSelect – egyszerre több érték (elem) kiválasztását engedélyezi (true) ill. tiltja (false). Több elem kiválasztásánál azt, hogy melyik elemek vannak kiválasztva a ListBox Selected tulajdonságával indext l kezd d vizsgálhatjuk, amely egy 0 tömb (pl. a Selected[0] igaz, ha az els

elem van kiválasztva, a Selected[1] igaz, ha a második elem van kiválasztva, stb.). o SelCount – kiválasztott elemek darabszámát tartalmazza (ha a MultiSelect értéke igaz). o Sorted – megadja, hogy a lista elemei legyenek-e rendezve ábécé sorrendben. Ha értéke igaz (true), új elem

hozzáadásánál a listához automatikusan rendezve kerül a listadobozba. Nézzük meg egy kicsit részletesebben a ListBox legfontosabb tulajdonságát, az Items tulajdonságot. Ez egy TString típusú tulajdonság, melynek sok hasznos metódusa van. Ezek közül a leggyakrabban használt metódusok: • • • • Add – a lista végére új elemet rak be. Clear – a ListBox összes elemét törli. Delete – kitöröl egy kiválasztott elemet a listában. Equals – teszteli, hogy két lista tartalma egyenl -e. False értéket ad vissza, ha a két lista különbözik a hosszában

használatára, hogy jobban megérthessük ket: 022

60

61

ListBox1.Items.Add(s); end; Rendezd nyomógomb: procedure TForm1.Button1Click(Sender: TObject); begin ListBox1.Sorted := true; end; Töröld nyomógomb – törli a lista kijelölt elemét: procedure TForm1.Button3Click(Sender: TObject); begin ListBox1.Items.Delete(ListBox1.ItemIndex); end; A form-ra helyezzünk el egy ListBox-ot, melynek Items tulajdonságába adjunk meg néhány nevet. Rakjunk a form-ra még pár nyomógombot is (Rendezd, Adj hozzá, Töröld, Töröd mind, Olvasd be, Mentsd el, Kilépés). Most az egyes nyomógombok OnClick eseményeit fogjuk kezelni: Adj hozzá nyomógomb – egy InputBox segítségével Töröld mind nyomógomb – törli a lista összes elemét: procedure TForm1.Button4Click(Sender: TObject); begin ListBox1.Clear; end; Megjegyzés: A lista törlését itt a ListBox1.Clear metódussal végeztük el. Ez ugyanúgy kitörli a lista elemét, mint a ListBox1.Items.Clear metódus, de az elemek törlésen kívül további „tisztító” m veleteket is elvégez. Gyakorlatilag a két metódus közti különbség a ComboBox komponensnél látható: a ComboBox.Clear kitörli a teljes listát, a ComboBox.Items.Clear kitörli szintén a listát, de az utolsó kiválasztott érték a beviteli mez ben marad! Mentsd el nyomógomb: procedure TForm1.Button6Click(Sender: TObject);

beolvasunk egy nevet, melyet a lista végéhez adunk: procedure TForm1.Button2Click(Sender: TObject); var s:string; begin s := InputBox('Adj hozzá', 'Kérlek add meg a nevet:', ''); if s<>'' then

62

63

begin ListBox1.Items.SaveToFile('nevsor.txt'); end; Olvasd be nyomógomb: procedure TForm1.Button5Click(Sender: TObject); begin ListBox1.Items.LoadFromFile('nevsor.txt'); end; Láthatjuk, hogy az utóbbi két metódus saját maga megnyitja a fájlt, beolvassa / menti az adatokat, majd bezárja a fájlt. Kilépés nyomógomb: procedure TForm1.Button7Click(Sender: TObject); begin Form1.Close; end; Végül még megemlítünk néhány példát a többi metódus használatára is: Medve Elemér beszúrása a 3. helyre a listában: ListBox1.Items.Insert(2, ’Medve Elemér’); A lista els elemének áthelyezése a 3. helyre: ListBox1.Items.Move(0, 2);

felhasználó csak a listában szerepl

értékek közül

választhat.

Természetesen van amikor ez nekünk így jó, de el fordulhat, hogy a felhasználónak több szabadságot szeretnénk adni a választásnál (például saját érték beírását). Ezekre adhat megoldást a ComboBox komponens.

12.10. Kombinált lista – ComboBox
Ennek a komponensnek a formája a képerny n nagyon hasonlít az Edit komponenséhez, a felhasználó gyakran írhat bele saját szöveget. Hasonlít azonban a ListBox komponenshez is, mivel a jobb szélén lev nyílra kattintva (vagy Alt + lefelé nyíl, vagy Alt + felfelé nyíl) megjelenik (legördül) egy lista, amelyb l a felhasználó választhat. Mivel a ComboBox tulajdonságai, metódusai és használata sok mindenben megegyezik (vagy nagyon hasonlít) a ListBox-al, ezért nem vesszük át mindet még egyszer, helyette inkább kiegészítjük továbbiakkal: o Style – ez a tulajdonság nem csak a ComboBox külalakját adja meg, de komponens viselkedését és a felhasználói bemenetek lehet ségét is. Értéke lehet: • csDropDown: tipikus ComboBox, amely megjeleníti a listát, de közvetlen szöveg bevitelt is lehet vé tesz. • csDropDownList: szövegbevitelt nem tesz lehet vé. Valamelyik bet kezd dik. (billenty ) megnyomásakor az els ket

Ezekb l a példákból is jól látható, hogy a ListBox komponens felhasználására nagyon sok lehet ség van. Azonban a ListBox komponens használatának is lehet hátránya: az egyik hátránya lehet, hogy az alkalmazás ablakán állandóan ott van és sok helyet foglal el. Másik hátránya: ha a ListBox-ot bemeneti komponensként használjuk, a
64

olyan elemre ugrik a listában, amely ezzel a bet vel

65

var i.j. A lista összes elemének a magassága azonos. • csOwnerDrawVariable: hasonló az el z höz. A programból mindjárt több tulajdonságát is láthatjuk a StringGrid komponensnek: 66 67 . a lista közvetlenül a beviteli mez alatt van megjelenítve (állandóan). begin k := k + 1. az els alábbi programrészt: procedure TForm1.j] := IntToStr(k). A megjelenített lista méretét a komponens Height tulajdonsága határozza meg. de az egyes elemeknek a listában különböz (méretük) lehet. Segítségével szöveges adatokat jeleníthetünk meg táblázatban. begin k := 0.Button1Click(Sender: TObject).11.• csSimple: a közvetlen szövegbevitelt lehet vé teszi. end. end. mint a lista. with StringGrid1 do for i:=1 to ColCount-1 do for j:=1 to RowCount-1 do nyomógomb OnClick eseményébe írjuk be az magasságuk 12. • csOwnerDrawFixed: kép megjelenítését teszi lehet vé a listában.k:integer. Ha elhelyezünk a form-on egy StringGrid komponens és két nyomógombot. Cells[i. melyet az ItemHeight tulajdonság határoz meg. StringGrid komponens Ez nem olyan gyakran használt komponens.

FixedColor – a rögzített oszlopok és sorok háttérszíne. még néhány érdekes metódusa a StringGrid Végül komponensnek: • MouseToCell: az X. o RowCount – hasonlóan az el z höz. 068 Label1. FixedRows – a rögzített (fix) sorok száma. állítsuk be a következ komponensek alábbi tulajdonságait az Objectum Inspector-ban (vagy írjuk be a a Form OnCreate eseményébe): használatát: Készítsünk egy alkalmazást. • CellRect: a megadott cella képerny -koordinátáit adja meg pixelekben. melyek a példában nem szerepelne: o o o o FixedCols – a rögzített (fix) oszlopok száma. A programunk továbbá tartalmazzon két nyomógombot. A következ feladat szemlélteti a StringGrid komponens Miután a szükséges komponenseket elhelyeztük a form-on. a második nyomógomb pedig rendezze ezeket a számokat növekv sorrendbe. StringGrid1. Az els nyomógomb generáljon véletlenszer számokat a StringGrid-be. 68 69 . A StringGrid komponens további tulajdonságai. Y koordinátákhoz meghatározza a táblázat sorát és oszlopát.DefaultColWidth := 30. o Cells – az egész táblázat szövegeinek mátrixa. GridLineWidth – az egyes cellák közti vonal vastagsága.o ColCount – oszlopok számát határozza meg (fix oszlopokkal együtt). melyben egy SpinEdit komponens segítségével beállíthatjuk a StringGrid komponens méretét 3x3-tól 10x10-ig. csak ez a sorok számát határozza meg.Caption := ‘A négyzet mérete’.

StringGrid1.ScrollBars := ssNone. // beallitjuk az elozo cellat az // aktualis cellara 71 Majd írjuk meg az egyes komponensek eseményeihez tartozó programrészeket: procedure TForm1. SpinEdit1.EditorEnabled := False.Enabled := true. StringGrid1.MaxValue := 10.MinValue := 3.SpinEdit1Change(Sender: TObject).ei. Button2.Cells[i. begin // a cellakba 10-99 kozotti veletlen szamokat // generalunk az oszlopok(sorok) 0-tol // vannak szamozva !! for i:=0 to StringGrid1. SpinEdit1.ColCount-1 do for j:=0 to StringGrid1. begin // a StringGrid1-el dolgozunk. StringGrid1.Button1Click(Sender: TObject). var i.ej]) then begin s := Cells[i. // a rendezes gombot nem elerhetove tesszuk Button2.Width := 31 * SpinEdit1.j:integer.j] a with parancson belul. // beallitjuk a StringGrid szelesseget es magassagat // minden cella 31 szeles(magas) a vonalal egyutt // az egyik szelen + 3 a StringGrig keretenek // szelessege(magassaga) StringGrid1. Cells[i. // a rendezes gombot elerhetove tesszuk Button2.j.ej:integer. // azt jelzi. SpinEdit1. StringGrid1.RowCount-1 do StringGrid1. s:string.StringGrid1.j:integer.DefaultRowHeight := 30.Button2Click(Sender: TObject). csere := true.FixedRows := 0.ej] := s.j] := IntToStr(random(90)+10).j] := Cells[ei.RowCount := SpinEdit1. var i.Enabled := false.FixedCols := 0. procedure TForm1.Value + 3.j]. var i. // beallitjuk a sorok es oszlopok szamat StringGrid1. Button2.Caption := ‘Rendezés’. procedure TForm1. Az alabbi sor // kiadasaval nem kell mindig megadnunk hogy // pl.ColCount := SpinEdit1. 70 . end. // elozo cella oszlopindexe csere := false. begin // toroljuk a cellak tartalmat for i:=0 to 9 do for j:=0 to 9 do StringGrid1. StringGrid1. with StringGrid1 do repeat ei := 0. helyette eleg // a Cells[i.j].Cells[i.Height := 31 * SpinEdit1.Value.Enabled := False.Value.Value := 5.Caption := ’Generálás’. csere:boolean. StringGrid1.Value + 3. Cells[ei.j]:=''.j])<StrToInt(Cells[ei.Cells[i. volt-e csere // (false=nem volt) for j:=0 to RowCount-1 do for i:=0 to ColCount-1 do begin // osszehasonlitjuk az aktualis cellat // az elozovel if StrToInt(Cells[i. end.ej]. Button1. end. SpinEdit1. // elozo cella sorindexe ej := 0.

Caption)-1) + LeftStr(Label1. StrUtils.Caption. majd visszatérni a program normális futásához. begin // a program inditasakor beallitjuk a // veletlenszam generatort randomize. Például a már említett körbe futó A StringGrid komponens nem csak adatok megjelenítésére. Id zít vel tudjuk megoldani például mozgó szöveg (folyamatosan körbe futó szöveg) kiírását is. amelyek az StrUtils unitban találhatók. end.Timer1Timer(Sender: TObject). o Interval – meghatározza azt az id intervallumot (milliszekundumokban). a LeftStr a szöveg bal részéb l ad vissza a második paraméterben 12. hogy a program futása közben ebbe a komponensbe a felhasználó tudjon beírni közvetlenül is adatokat.FormCreate(Sender: TObject).Enabled := false. de adatok bevitelére is használható. // mivel mar rendezve vannak a szamok Button2. amig igaz nem // lesz. ej := j. Ahhoz.Caption. ki kell egészítenünk programunk uses részét ezzel a unittal: uses …. end. szöveg így oldható meg a segítségével: procedure TForm1.Caption := RightStr(Label1. Length(Label1. until not csere. end. // addig megyunk vegig az egesz // StringGrid-en. // a rendezes gombot nem elerhetove tesszuk. begin Label1. elvégezni valamilyen rövid m veletet. procedure TForm1. át kell állítanunk a StringGrid. A RightStr függvény az els paraméterként megadott szöveg jobb. Mivel a programunk használ két függvényt: RightStr és LeftStr.ei := i. 1). Id zít – Timer Gyakran szükségünk lehet bizonyos id nként megadott mennyiség karaktert. amelyet periodikusan végre akarunk hajtani. hogy csere=false. (intervallumonként) megszakítani a program normális futását. Az OnTimer eseménybe írhatjuk azt a kódot. ami eltelte után újra és újra bekövetkezik a OnTimer eseménye. A Timer komponens nem sok tulajdonsággal rendelkezik. pontosabban egy specifikus tulajdonsága van: 72 73 . end.12.Options tulajdonságának goEditing altulajdonságát true-ra.

begin Gauge1. A példánkban 10 másodperc alatt ér a folyamat a végére. a Windows NT-ben 10 milliszekundum. Ebb l következik. Lehetséges értékek: gkHorizontalBar (vízszintes sáv). hogy pontosan 1 másodpercenként fog bekövetkezni az OnTimer esemény. MaxValue – maximális értéke a sávnak (default: 100). gkNeedle („analóg sebességmér óra”). akkor sem következik be az esemény. Ha például a komponensünk Interval tulajdonságát 1000 ms-ra állítjuk be. akkor a Progress = 20 érték 10%-nak felel meg. komponenseknek (és a Timer komponens) segítségével. gkVerticalBar (függ leges sáv). hanem csak egy. A Windows órája és kerekítés végett ebben az esetben 989 ms-onként következne be az esemény. hogy ennék kisebb intervallumot hiába adunk meg a Timer komponensben. gkText (csak a százalékot jeleníti meg. amely segítségével a Gauge használatát szemléltetjük. és miután felszabadul. intervalluma a Windows 98-ban 55 milliszekundum.13. Továbbá ha az alkalmazásunk hosszabb ideig (példánkban 1 mp-nél tovább) foglalt. nem fog bekövetkezni több esemény egymás után hirtelen (nem halmozódik fel).Progress + 1. Kind – a komponens külalakját határozza meg. amely a komponensen is megjelenik. a m velet nem fog ennél rövidebb id közönként végrehajtódni. ProgressBar komponensek Egy hosszabb folyamat állapotát jelezhetjük ezeknek a szemlélteti semmilyen grafikus elemmel). Gauge. Például: ha a MinValue = 0 és MaxValue = 200. nem 12. amely Nézzük el ször a Gauge komponens fontos tulajdonságait: o o o MinValue – minimális értéke a sávnak (default: 0). A Timer komponens Interval tulajdonságát állítsuk be 100 milliszekundumra (tehát másodpercenként 10-szer fog bekövetkezni az OnTimer eseménye).Timer1Timer(Sender: TObject). melyben a szelet nagyobbodik).Megjegyzés: A Timer a Windows id zít jét használja. Továbbá a Windows bels órája nem pontos. Most nézzünk egy példát. 023 A form-ra helyezzünk el egy Gauge komponenst és egy Timer komponens.Progress := Gauge1. További tulajdonságai a Gauge komponensnek: o o ForeColor – a kitöltés színe. 74 75 . Az OnTimer eseménybe a következ programrész szerepel: procedure TForm1. gpPie („kalács” – kör formájú alak. Progress – aktuális értéke a sávnak. az nem jelenti azt. majd a következ esemény csak a megadott intervallum eltelte után lesz.

o Proportional – ha értéke igaz (true).1. mindaddig menjen. o Transparent transparent – bitmap tulajdonság (BMP) értéke kép igaz esetében. az eseményekhez (Events) tartozó eljárások programkódjának megírása. Stretch – ha értéke igaz (true). milliszekundumban egy képponttal jobbra teszi). akkor betartja a szélesség és magasság arányát. ha kisebb. akkor véletlenszer magasságban beúszik a képerny bal szélér l. mivel tartalmaz egy vászont (Canvas objektum). 3. Az image komponens leggyakrabban használt tulajdonságai: o o Picture – megjelenítend kép. A kép lesz maga a léggömb. rajzoljuk meg Paint-ban (vagy más rajzoló programban) a léggömböt. ha a a elkészítésének. Állítsuk felügyel ben: be a komponensek tulajdonságait az Objektum akkor 76 77 . amíg nem nyomunk le egy billenty t vagy nem mozgatjuk meg az egeret. Kezdjük tehét az els nél. melynek mérete legyen 200 x 200 pixel. tehát nem torzul a kép. komponensek kiválasztása és elhelyezése a form-on. Ez 13. A ProgressBar komponens hasonló a Gauge-hoz. Háttérszínnek a Delphi a bitmap bal alsó sarkában lev pont színét veszi. az id zít pedig ezt a képet fogja mozgatni (minden 10. a komponensek kiválasztásánál. Ezen kívül jól használható például rajzprogram készítésére is. Ezt a rajzot BMP fájlformátumban mentsük el. melyre bármit kirajzolhatunk. akkor lekicsinyíti a komponens méretére. mint azt már eddig is megfigyelhettük három f lépésb l fog állni: 1. akkor az egész képet megjeleníti a komponensben. Max és Position tulajdonságai vannak. ha a stretch tulajdonság hamis . Tehát ha nagyobb a kép. csak más a külalakja és mások a tulajdonságainak a nevei: a MinValue. érdekesebbé tehetik alkalmazásunkat. háttérszínt átlátszóvá teszi (csak akkor m ködik.false). (true). Ha kész a rajzunk. További komponensek Ebben a fejezetben f leg olyan további komponenseket sorolunk fel. melyben egy léggömb fog úszni balról jobbra.end. nekiláthatunk az alkalmazásunk 13. melyek grafikailag szebbé. komponensek tulajdonságainak (Properties) beállítása az Objektum felügyel ben. Az alkalmazásunk elkészítése. Készítsünk egy egyszer képerny véd t. A Form-unkra tegyünk egy képet (Image) és egy id zít t (Timer). MaxValue és Progress helyett Min. Próbáljuk ki az Image és a Timer komponensek használatát a gyakorlatban is. akkor felnagyítja. 2. Kép használata – Image Kép megjelenítését teszi lehet vé. 024 Miel tt belekezdenénk a programunk készítésébe. Ha kimegy a képerny jobb szélén.

tehát az induláskor az egész képerny t betakarja majd (mivel maximalizált és nincs keretje). Megadjuk.Picture Ennél a tulajdonságnál adjuk meg az elmentett képünket (BMP). • Form1. Form1. ahogy azt a fenti példában is tettük.• Form1. Megjegyzés: ugyanezzel a tulajdonsággal tudjuk beállítani azt is.Interval := 10. Image1. hogy az ablakunk ne legyen futási id ben átméretezhet (bsSingle).FormCreate(Sender: TObject).Left := Random(Screen. Alkalmazásunk tervezési fázisban most valahogy hasonlóan nézhet ki: 78 79 (minimalizálás.Width := 200.Height-200).Cursor := crNone. mert ennek az eljárásnak a meghívásakor az alkalmazásunk még nincs maximalizálva. A Screen (képerny ) objektum segítségével meghatározható a képerny Ezzel megadtuk a fontosabb tulajdonságokat. Megadjuk. a BorderIcons-al megadhatjuk. begin randomize. Image1. az ablakunk hátterének színét és az egér kurzorát (ez utóbbit nincs-re állítjuk): procedure TForm1. méretét.Transparent := true.Height := 200.BorderStyle := bsNone. de a jöv ben még jól jöhet ezek ismerete más programok készítésénél. • Image1. end.Color := clBlack. .WindowState := wsMaximized. tehát a programkód megírásának. így nem kapnánk meg az egész képerny felbontása úgy. hogy az id zít nél 10 milliszekundumonként következzen be az OnTimer esemény. Ezzel az ablakunk kezdetben maximalizált állapotban lesz. Az ablakunknak nem lesz látható kerete. Image1. Igaz. amely a léggömböt ábrázolja. maximalizálás. Továbbá egy hasonló tulajdonsággal. A Form1 – OnCreate eseményében beállítjuk véletlenszer en a léggömb helyzetét. hogy képünk háttere átlátszó legyen. bezárás). Form1. • Image1. Meghatározzuk a képünk méretét. Itt azért a Screen objektumot használtuk és nem a Form1-et. • Timer1.Top := Random(Screen.Width-200). • Image1. hogy az ablakunk keretén melyik gombok legyenek elérhet k Most nekiláthatunk az események kezelésének. ebben a programban ezekre most nincs szükségünk.

Most már csak az hiányzik. Shift: TShiftState). Igaz. Most beállítjuk. hogy a form-unk nem közvetlenül a képerny n lesz átrajzolva. Ahhoz. hogy bármelyik billenty tesszük meg: procedure TForm1.Height-200). hanem egy bitmap segítségével a memóriában.Width then begin Image1. amikor az egérkurzor homokórából nyílra változik (ha az egeret nem mozgatjuk. end.DoubleBuffered := true.Width. Image1. Ennek a tulajdonságnak igazra való állítása azt eredményezi. begin Form1. Ezt a Form1 – OnKeyDown eseményében implementation parancsszava alá beírva az alábbi sort): var indul: integer.Timer1Timer(Sender: TObject).Left + 1. Ehhez a Form1 – OnMouseMove eseményét kell kezelnünk. Kilépni egyel re csak valamelyik gomb megnyomásával tudunk.FormCreate eljárásba: indul := 0. begin Image1.Width). Így ha az OnMouseMove eseményhez beírnánk az alkalmazás befejezését (form bezárását). egérmozgatással nem. Ezt kiküszöbölhetjük. Próbáljuk meg lefuttatni az alkalmazásunkat.FormCreate eljárását a következ sorral: megnyomására a az egér mozgatására (változására) szükségünk lesz egy változóra (indul nevet adunk neki). hogy a léggömb mozogjon. hogy a képerny véd nk indulás után ne lépjen ki rögtön bal oldalára negatív pozícióba (-Image1. rögtön az indulás után a programunk befejez dne. Egészítsük tehát ki a programunkat egy indul nev globális változóval (a modul program befejez djön. véletlenszer magasságban Form1. A változó értékét növeljük 10-zel mindaddig.FormKeyDown(Sender: TObject. viszont a villogás így megsz nik. hogy kilépni csak akkor fogunk tudni az egér mozgatásával. Ha a kép kiment a képerny átrakjuk a képerny jobb oldalán. A form OnMouseMove eseménye ugyanis meghívódik rögtön az indítás után is.Left := -Image1. end. end. Egészítsük ki tehát a TForm1. akkor is bekövetkezik ez az esemény az indulás után). Ezt úgy fogjuk kiküszöbölni.Close. ezzel a memóriából több helyet lefoglal a programunk.Top := Random(Form1. ha az egérmozgatás az alkalmazás indulása után 1 vagy több másodperccel történt meg (ennek figyeléséhez kell az indul változó). Továbbá láthatjuk. melyben az indulás óta eltelt id t fogjuk számolni. procedure TForm1. hogy a programunkból ki lehessen lépni az egér megmozdításával is. var Key: Word. Itt azonban egy kis problémába ütközhetünk. if Image1. hogy a képerny n a léggömb mozgatása villogással jár.Most beállítjuk.Left > Form1. ahonnan be fog jönni a képre. amíg nem érünk el több mint 1000-et (több mint 1000 milliszekundumot) a Timer1 – sor beszúrásával a 80 81 . amíg nem érjük el az 1000 milliszekundumot (1 másodpercet).Left := Image1. ha a Form1 – OnCreate eseményének kezelésében beállítjuk a Form DoubleBuffered tulajdonságát igazra (true). tehát növeljük a Timer1 – OnTimer eseményében a kép Left tulajdonságát 1-gyel. Ennek a változónak az értékét a Form1 – OnCreate eseményében állítsuk be 0-ra a következ TForm1.

hanem közben emelkedjen. hogy az alakzat beljebb lesz (bsLower) vagy kijjebb lesz (bsRaised) az ablakon. Lehetséges értékei: • bsBottomLine – a komponens alján egy vízszintes vonal jelenik meg. Fontos megemlíteni.2. vagy süllyedjen is. csak vizuálisan jelenik meg a programban (tehát nem csoportosíthatunk vele pl. 13.FormMouseMove(Sender: TObject. miután eltelt az indulástól több mint 1 másodperc. Shift: TShiftState. Tehát a TForm1. M ködik? Képerny véd nk megpróbálhatjuk magunk továbbfejleszteni például úgy. Ennek a komponensnek nincs egyetlen eseménye sem. a léggömb mérete változzon. X. • bsRightLine – függ leges vonal a komponens jobb oldalán. A keret belseje egy szintben van az ablakkal (form-mal). elválaszthatjuk ket egymástól. hogy a Bevel komponens nem lesz a ráhelyezett komponensek tulajdonosa (mint pl. begin if indul>1000 then Form1. Két fontos tulajdonsága van: o Shape – meghatározza.OnTimer eseményének kezelésében. Végül írjuk meg a Form1 – OnMouseMove eseményéhez a programkódot: procedure TForm1.3.Timer1Timer eljárást egészítsük ki a következ sorral: if indul<=1000 then indul := indul + 10. Y: Integer). Futtassuk le az alkalmazásunkat. szebbé tételére. mégis elegáns a komponens az o • • bsSpacer – üres (nem lesz látható semmi). hogy két léggömbünk legyen. vizuálisan szétoszthatjuk csoportokra. bsTopLine – vízszintes vonal a komponens tetején. Segítségével komponenseket Style – meghatározza. amely belseje attól függ en. • bsBox – doboz (keret). A Bevel komponenssel tehetünk az alkalmazásunkba egy egyszer vonalat vagy keretet (amely lehet benyomódva vagy kiemelve is).Close. hogy a komponens Style tulajdonsága mire van állítva vagy beljebb lesz vagy kijjebb lesz az ablakon (form-on). hogyan nézzen ki a Bevel komponens. • bsFrame – keret körbe. Választóvonal – Bevel Egyik alkalmazásunk legegyszer bb. 13. a Panel komponensnél). melyeknél van értelme. Alakzat – Shape 82 83 . esetleg ne csak vízszintesen haladjon. • bsLeftLine – függ leges vonal a komponens bal oldalán. RadioButton-okat sem logikai csoportokba)! Természetesen ez csak azoknál az alakzatoknál (Shape tulajdonság) használható. end. Próbáljunk meg kilépni az egér mozgatásával.

egymás után kell elhelyezkedniük. hogy hogyan hozhatunk létre bitmap-ot több képb l. fent. csak vizuális nem célt lesz a tulajdonosa.4. így bármilyen egyéni külalakú gombot létrehozhatunk. és a többi állapotnál akkor. de BitBtn nyomógombon képet is el lehet helyezni. bkAll. stEllipse. bkAbort. ha a gombot nem lehet kiválasztani. o Layout – meghatározza. saját képet adhatunk meg (a Glyph tulajdonságban). A bitmap-nek teljesítenie kell két feltételt: minden képnek ugyanolyan méret nek kell lennie és a képeknek sorban. bkOK. bkNo. NumGlyphs – Megadja. bkHelp. Hasonlóan komponens o Margin – meghatározza a kép és a gomb bal széle közti távolságot pixelekben. stRectangle. hogy a bitmap hány képet tartalmaz. o o Spacing – meghatározza a kép és a felirat közti távolságot pixelekben. Ha azt képet komponens ezek után egy ikont jelenít meg ezek közül a képek közül a BitBtn állapotától függ en: • Up – a nem lenyomott gombnál jelenik meg. bkClose. Ha a bkCustom-ot választjuk. be. bkYes. bkRetry. Fontosabb tulajdonságai: o Shape – az alakzat formája (stCircle. akkor a képet a szöveggel együtt középre igazítja. Azzal. • Disabled – akkor jelenik meg. ha nincs más kép. melyet a következ részben írunk le). szolgál. ráhelyezett geometriai alakzatok. stRoundRect. stSquare). további fontos tulajdonságait fogjuk felsorolni a BitBtn komponensnek: o Glyph – a gombon megjelenítend kép (bitmap). Ha értéke -1. lent). hogy a kép hol jelenjen meg a nyomógombon (bal oldalon. szeretnénk. Ez nagyon hasonló a Button komponenshez. akkor 18 x 18 képpontnyi méret használjunk. 84 85 . bkIgnore. • Clicked – ha a gomb éppen meg lett nyomva (rá lett klikkelve egérrel). megismerkedünk az ImageList komponenst tárgyaló fejezetben. Grafikus nyomógomb – BitBtn Ha a hagyományos nyomógombtól (Button) egy kicsit eltér t szeretnénk kialakítani. hogy a saját képünk hasonló legyen az el re definiáltakhoz. melyekkel a programunkat az el z komponenshez.Egyszer szépíthetjük. • Down – ha a gomb tartósan lenyomott állapotban van (ez az állapot a BitBtn komponensnél nem következik o Kind – néhány el re definiált kép közül választhatunk. használhatjuk a BitBtn komponenst. A BitBtn 13. jobb oldalon. bkCancel. vastagsága és stílusa. ennek az állapotnak csak a SpeedButton gombnál van jelent sége. Itt most csak a Button-nál nem található. stRoundSquare. Pen – körvonal színe. lehetséges értékei: bkCustom. o o Brush – kitöltés színe és stílusa.

13. A SpeedButton komponens nagyon hasonló a BitBtn A SpeedButton-okat szinte mindig egy Panel komponensen helyezzük el. vagy az egyik gombnak mindenképen muszáj benyomva maradnia (false). Külön megadható az is. Négy különböz képet helyezhetünk el a gomb állapotainak megfelel en. mindig csak egy lehet lenyomva. eszköztárat alakítva ki bel lük. A kölcsönös kizárás lényege ilyen esetben. Hasonlóan a komponenshez. Itt jelent sége lesz a negyedik – down (tartósan lenyomva) állapotnak is. A komponenst tervezési fázisban egy kis négyzet jelképezi. vagy egy csoportban mindegyik lehet-e felengedett állapotban. Gondoljuk végig például Word-ben a szöveg igazítását: o o Down – ez a tulajdonság adja meg. amely az alkalmazás futása alatt nem látható (hasonlóan pl. Kép lista – ImageList Ahhoz. A szöveg igazításánál a gombok közül egy állandóan lenyomott állapotban van. AllowAllUp – ez a tulajdonság határozza meg. Ezt a többi gomb nem tudja megvalósítani. a BitBnt gombok nem használhatóak eszköztár gombnak. Az egy csoportba tartozó gomboknak azonos GroupIndex-el kell rendelkezniük. hogy legalább egynek benyomva kell-e lennie. több ugyanolyan méret kép tárolása. Eszköztár gomb – SpeedButton Az eddig tárgyalt gombok. el bb szükséges néhány szót szólnunk az ImageList komponensr l. Csak 0-tól különböz GroupIndex esetén használható. hogy a gomb lenyomott állapotban van-e (true esetén lenyomott állapotban van). akkor létrejön a csoportosítás. Amennyiben a GroupIndex = 0 akkor a gomb BitBnt gombként fog viselkedni. a Timer BitBtn komponenshez ez is tartalmazhat több képet.6. 13. hogy megismerkedjünk az eszköztár egy másik fejezetben tárgyaltunk. Ezek a tárolt képek (bitmapek. a sima Button. hogy az egy csoportba tartozó gombok közül lehet-e mind egyszerre felengedve (true). Ennek a komponensnek a célja. ikonok…) indexek segítségével érhet k el. Legfontosabb tulajdonságai: o Glyph – a gombon elhelyezked kép.5.o GroupIndex – ennek a tulajdonságnak a segítségével csoportosíthatóak a gombok. tehát nem fog „benyomva” maradni. Ha GroupIndex-nek 0-nál nagyobb számot adunk. melyez az el z módszerének kialakításával (ToolBar komponens segítségével). hogy az egy csoportba tartozó gombok közül. komponenshez). 86 87 . s a másik lenyomásakor az el z felenged. mindegyik állapotához egy-egy képet.

Az ImageList fontosabb tulajdonságai: o o Width – a komponensben tárolandó képek szélessége. hozzá lettek rendelve az ImageList-bel lev ikonok. Az összes kép az ImageList-ben úgy van reprezentálva. majd az Object Inspector-ban beállítjuk az Images tulajdonságot az ImageList komponensünkre. Eszköztár – ToolBar A ToolBar komponens segítségével szintén el állíthatunk eszköztárt. Szorosan együttm ködik az ImageList komponenssel. Image1. 6. de hasonlóan felhasználható további komponenseknél is (pl. mint egy darab széles bitmap.Picture. Mindegyik ListBox-ban tárolt kép index segítségével érhet ImageList1. nem probléma megváltoztatni ToolButton ket a ToolBar nyomógombjainak (tehát a objektumoknak) az ImageIndex 13. Height – a komponensben tárolandó képek magassága. majd kiválasztjuk a „New Button” menüpontot. A képek hozzáadása után az OK gomb megnyomásával bezárjuk az Editor-t. metódus el. ToolBar). az 2. melyet az el z részben ismerhettünk meg. Az egér bal gombjával rákattintunk a ToolBar komponensre. Az eszköztás kialakítását ToolBar o tulajdonságainak átállításával.GetBitmap(0. Az el z lépés ismétlésénél a gombokhoz automatikusan melynek értéke 0-tól N-1-ig lehet (N darab kép esetében). Jobb egérgombbal rákattintunk az ImageList-re és kiválasztjuk az Image List Editor-t. Láthatjuk. Az alkalmazás tervezési fázisában a képek megadásához az Image List Editor eszközt használhatjuk. komponens segítségével egy példán ismertetjük: 1.7. 5. Az Editor-ban az Add gomb megnyomásával hozzáadjuk az ImageList-hez a szükséges képeket (bitmapot – BMP és ikont – ICO választhatunk). Ne felejtsünk el néha berakni „New Separator”-t is. továbbá más a tervezési fázisa is. Ezt felhasználhatjuk a BitBtn. 4. ahány gombot akarunk elhelyezni. ha a nyomógomb nem elérhet . hogy a gombok áttekinthet en legyenek elrendezve.Az ImageList komponenst tehát hatékonyan ki tudjuk használni több kép vagy ikon tárolására. Például: az ImageList1-ben tárolt 0 index képet állítja be az Image1 Bitmap-jának. 3. Az el bbi fejezetekben leírt eszköztár kialakításával (panel és SpeedButton komponensekb l) szemben a ToolBar komponens valamivel több lehet séggel rendelkezik. Ezt a lépést megismételjük annyiszor. Ha ez a kezdeti beállítás nekünk nem felel meg. Jobb egérgombbal rákattintunk a ToolBar komponensre. Megemlítjük még a ToolBar komponens fontosabb tulajdonságait: DisabledImages – segítségével meghatározhatjuk. SpeedButton komponenseknél. hogy a nyomógombokon milyen képek jelenjenek meg. 88 89 . A form-on elhelyezünk egy ToolBar és egy ImageList komponenst. hogy ennek a komponensnek a segítségével nagyon egyszer en és rugalmasan kialakíthatunk eszköztárakat.Bitmap). melyet a komponensre kattintva jobb egérgombbal (vagy dupla kattintással) hívhatunk el .

Az alkalmazás futási idejében ha meg szeretnénk jelentetni valamit a StatusBar els StatusPanel-ján (ez a 0. az aktuális bet típust. A StatusPanel fontosabb tulajdonságai: • Width – meghatározza a szélességét. melyekben mindig csak egy gomb lehet lenyomva (pl. Az alkalmazásunk ablakának alján az állapotsáv (StatusBar) segítségével tudunk kiíratni a felhasználónak különféle információkat. Ha StatusBar komponenst rakunk az alkalmazásunkba. hogy a gombok olyan logikai csoportokba vannak-e osztva. Word bet színének kiválasztása az eszköztárban). a kijelölt rész koordinátáit és méretét. o MenuItem – segítségével a gombokhoz a f menü egyes menüpontjait lehet hozzárendelni. Grouped – meghatározza. Lehetséges értékek: • • • tbsButton: nyomógomb. • tbsCheck: nyomógomb két lehetséges (lenyomott ill.8. tbsDivider: látható függ leges választóvonal. például a bet típust. 13. azonban az utolsó StatusPanel szélessége mindig az alkalmazásunk ablakának szélességét l függ. tbsSeparatos stílusú ToolButton-okkal). hogy a nyomógombokon milyen képek jelenjenek meg. • Text – a StatusPanelon megjelenítend tartalmazza. pontosabban hány részb l álljon az állapotsávunk. A gombok logikai csoportokba való osztását az határozza meg.Panels[0]. • o tbsSeparator: üres hely (választósáv). hogyan vannak elválasztva (tbsDivider. mivel az Align tulajdonsága A ToolBars-on elhelyezked nyomógombok. mivel az utolsó a maradék részt tölti ki. azt a következ módon tehetjük meg: StatusBar1. Az egyes részeket indexek segítségével érhetjük el. Állapotsáv – StatusBar 90 91 . stb. TStatusPanel típusú objektum.menü (pl. • Alignment – a szöveg igazítását határozza meg a StatusPanelen belül. választóvonalak (ToolButton objektumok) fontosabb tulajdonságai: o Style – meghatározza a nyomógombok stílusát és alapértelmezésben erre van állítva. a vonalvastagságot. Legfontosabb tulajdonsága: o Panels – tervezési fázisban egy editor segítségével megadhatjuk hány részre legyen szétosztva. az automatikusan az ablak aljához „tapad”. Word sorigazitásai). felengedett) állapottal. Például egy grafikus programban kiírathatjuk ide az egér koordinátáit. tbsDropDown: legördül választék .o HotImages – segítségével meghatározhatjuk.Text := ’Times New Roman’. index ). Minden egyes rész egy új. ha a nyomógomb aktív (ki van választva). szöveget viselkedését is. Ennek a tulajdonságnak csak a tbsCheck stílusú nyomógomboknál (ToolButton-oknál) van értelme.

az a többi lapon nem lesz látható. A TabControl egyik fontosabb eseménye az OnChanging. a lapok közötti nekünk átváltást kell a nekünk rajta kell lev beprogramoznunk átváltáskor PageControl Vegyük észre. Könyvjelz k – TabControl. Ebb l adódik. amely a már ismert TString típusú. Els két komponens között különbséget. ha például nem megfelel A TabControl csak a könyvjelz k definiálására szolgál.9. látásra nem látunk a mindkét komponens lapra elhelyezünk egy komponenst. mindegyik „lapon” látható lesz. A fels részében megjeleníti a könyvjelz ket.13. Ebben az eljárásban megakadályozhatjuk az átváltást is. Mindegyik lapja tartalmazhat saját komponenseket. hogy a PageControl-nál az egyes lapok fizikailag új komponensek (TabSheet). amely akkor következik be. viszont itt mindegyik lapra külön-külön komponenseket rakhatunk. Így a tervezési id ben használhatjuk a String List Editor-t. tehát fizikailag is csak az adott lapon lesz rajta. értékeket adott meg – erre az komponenseket láthatóvá ill. Ha valamelyik 92 93 . mégis m ködése eltér . PageControl A Delphi-ben könyvjelz kkel kétféle képen dolgozhatunk. hogy (pl. Igaz. Ezekb l a különbségekb l adódik a két komponenssel való eltér munka és a két komponens eltér kialakítása is a tervezési fázisban. hogy ez egy kicsit bonyolítja a tervezését. A TabIndex tulajdonság meghatározza az aktuális könyvjelz t. amelyben be tudnánk állítani az egyes könyvjelz ket (füleket). Vagy TabControl vagy PageControl segítségével. Továbbá kihasználhatjuk az össze metódust. A PageControl-nál nincs editorunk. de saját maga nem tartalmaz semmilyen lapokat: ha elhelyezünk egy komponenst valamelyik „lapon” (bár fizikailag nincs egyetlen lapja sem). amelyet a TString típusnál megismertünk. TabControl A TabControl-nál a könyvjelz ket (füleket) a Tabs tulajdosnág segítségével adhatjuk meg. láthatatlanná tenni). ha a felhasználó át szeretne váltani másik fülre (könyvjelz re). A PageControl az el z vel ellentétben már tartalmaz lapokat is. A tervezési fázisban úgy tehetünk bele AllowChange paraméter szolgál.

A TStrings típusnak van olyan metódusa. További el nye. o PlainText – igaz (true) érték esetén a szöveget sima TXT állományba menti el. ezért itt csak néhány további fontosabb tulajdonságát említjük meg: o Lines – a Memo-hoz hasonlóan épül fel. A különbség a program futása alatt mindjárt látható lesz az egyes komponensek külalakján: 94 95 . s azt beolvastathatjuk Delphi-ben. hamis (false) értéknél a mentés RFT fájlba történik. Tulajdonságai hasonlóak a Memo komponens tulajdonságaihoz. hogy az alkalmazásunknak.11. mint egy külön komponensel. A kiválasztott lapot az ActivePage tulajdonság határozza meg. nem az indexét vagy más „mutatót”. vagy elmenti RTF állományba a formázott szöveget. 13. Itt a RichEdit esetében van egy automatikus konverzió.rtf'). használhatjuk az XPManifest komponenst. Minden létrehozott lappal úgy tudunk dolgozni.10. mely fájlból olvassa be a szöveget.LoadFromFile('c:\delphi. TStrings a típusa. melyet létrehozunk. hanem a megformázott szöveget. Pl. Ennek a komponensnek a használata nagyon egyszer . hogy itt a szöveg formázható. tehát egyenesen az adott lapot használja. elég elhelyezni bárhova az alkalmazásunkban (futási id ben nem látható). elegáns kinézete legyen. hogy a PageControl komponensre jobb egérkattintással rákattintunk és kiválasztjuk a New Page menüpontot. 13. XPManifest komponens Ha azt szeretnénk. Ez egy TTabSheet típusú tulajdonság. Így nekünk itt is csak a beolvasással vagy a fájlba írással kell tör dnünk. Formázható szövegdoboz – RichEdit A többi szövegdoboztól a legf bb eltérés.Lines. ill. A következ vagy el z lapra való átmenésre a programban elég meghívni a PageControl SelectNextPage metódusát. Példa egy RTF állomány beolvasására: RichEdit1. mint más modern Windows XP alatti alkalmazásoknak. oda ki tudja menteni. hogy ne az RTF fájl sima szöveges változatát lássuk.új lapot. A Memo-hoz hasonló tulajdonságokkal és metódusokkal rendelkezik. hogy beolvassa. Wordpad-del el állíthatunk egy RTF állományt.

nem elég kiszedni az alkalmazás ablakából. melyek valamilyen parancsot hajtanak végre.1. tehetünk a f menü sávjába is (amely mindig látható az ablak tetején). oldalán. Miel tt belekezdenénk a menük létrehozásába a Delphi-ben. Ezt a három pontot a név után mi írjuk be. • dialógusok – menüpontok. mivel a felhasználó általában ezekre klikkelve egy menü 96 97 ket betartani. de ajánlott ezt az elvet betartanunk. de Ezeknél a menüpontoknál bekapcsolt állapotban egy „pipa” (vagy pont) van a menüpont bal 14. amelyek segítségével a program valamilyen beállításának ki vagy bekapcsolása lehetséges. • nevük (feliratuk) után három pont van. mely egy mélyebb szinten lev almenüt nyit meg. Ez azonban nem ajánlatos. cselekményt indítanak el. Az ilyen menüpont a jobb szélén egy kis háromszöggel van megjelölve. nézzük meg milyen követelményeknek kell megfelelnie a f menünek.14. melyek hatására egy új ablak (dialógusablak) jelenik meg. A három pont kirakása a menüpontban nem kötelez . Az ilyen menüpontoknál a Ha el szeretnénk távolítani az XPManifest komponenst az alkalmazásunkból. Menük létrehozása . mely valamilyen parancsot végrehajt. A f menü menüpontjai lehetnek: • parancsok – azok a menüpontok. Természetesen ezek csak javaslatok. Az alkalmazásunkban kétfajta menüt hozhatunk létre: f menüt és lokális (popup) menüt. • beállítások – olyan menüpontok. F menü – MainMenu A f menü az alkalmazásunk ablakának legtetején helyezkedik el. Nézzük ezeket sorban. ez nélkül is m ködik. almenüt megnyitó menüpontok – olyan menüpont. a teljes eltávolításhoz ki kell törölnünk a programunk uses részéb l is az XPMan unitot. nem kötelez ajánlott. Menüpontot.

hogy ezt se vigyük túlzásba. Crtl+M-re (mint másolás). ha lehet. hogy betartsuk a menü standard struktúráját. Így ez nagyon zavaró lehet. Néha ez jól jöhet. Szerkesztés. Klikkeljünk az új menüpont helyére. Ctrl+V a beillesztés legyen. Súgó menüpontok. melyek minden alkalmazásban hasonlóak. amely segítségével könnyen kialakíthatjuk a f menünket. Nyomtató beállítása. „Táblázat megjelenítése” után ha megjelenne „Lista megjelenítése” ugyanabban a menüpontban). melyekre szintén próbáljunk meg odafigyelni: az Alt+bet típusúak. a Crtl+C megnyomásakor befejez dne a program. a Ctrl+C maradjon Ctrl+C. majd adjuk meg a menüpont feliratát (Caption tulajdonság). A menüsávot Fájl. az adott bet re kezd d menüpont nyíljon meg. Nézet… menüpontokkal kezdjük. ha a menüben megváltoznak a menüpontok nevei. Tartsuk be a megszokott billenty kombinációkat is. hogyan készíthetünk a az ablakunkon bárhova egy almenü. nem lehet rákattintani. További zavaró eset lehet. a Ctrl+C a másolás. Legjobb. pl. A menüpontokat próbáljuk valamilyen logikailag összefügg csoportokban elrendezni. Másolás. abból egy újabb almenü. stb. Ha magyar programot készítünk. melyeknél. A billenty kombinációkat azonban nem ajánlatos lefordítani! Pl. mely a felhasználót zavarhatja. Ablak. ha a menü legfels szintjére klikkelve megnyílik egy olyan választék. használjunk benne a menük neveinek (feliratainak) is magyar szavakat. Így a menüpont a helyén marad. Nem nagyon örülnének a felhasználók. Másik dolog. Eszközök. Kivágás. A menüpontok eltüntetése (visible) helyett használjuk inkább a menüpontok engedélyezésének tiltását (enabled). csak kivételes esetekben. mint hasznot. Mentés. Hasonlóan a Szerkesztés alatt legyen a Visszavonás. Fontos. melyb l már nem nyílik meg további. Mentés másként. a File menüpont alatt legyen az Új. csak „szürke” lesz. Nyomtatás. alacsonyabb szint választóvonalakat. Egy összefügg csoportban jó. után nézzük. nagyon zavaró eset lehet. A komponens az alkalmazásunkban egy kis négyzettel lesz jelezve. ha pl. …. A felhasználó számára másik. megnyílik a Menu Designer. nem a pontos nevüket. készítsünk külön egy angol változatot. de nagyon sok esetben megzavarhatjuk vele a felhasználót (f leg ha a megváltozott név nincs logikai összefüggésben az el z vel. akkor az megváltozhat „Táblázat eltüntetése” menüpontra. Ha erre a kis négyzetre duplán rákattintunk. A felhasználók többsége csak a menüpont helyzetét jegyzi meg. és melyekhez a felhasználók már 98 hozzászoktak. Az almenüknél is próbáljuk meg betartani a standard elrendezést. stb. Észrevehetjük. Ez után a rövid bevezet Delphi-ben menüt.megnyílását várja el alatta (melyb l aztán választhat). pl. A megváltoztatásukkal több kárt érnénk el. stb. ne változtassuk meg pl. Használjunk a csoportok között vízszintes választóvonalakat. mely természetesen futási id ben nem látható. A másik fajta billenty zetkombinációk. Ha külföldön is szeretnénk a programunkat terjeszteni. nem azonnal egy parancs lefutását. Almenük helyett inkább használjunk a menüben vízszintes Helyezzünk el MainMenu komponenst. Ezzel összefügg a menü nyelve is. ha a menüben elt nnek és megjelennek menüpontok. Kilépés menüpontok. pl. pl. ha nincs több 5-6 menüpontnál. de azért vigyázzunk. hogy minden 99 . ha rákattintunk a „Táblázat megjelenítése” menüpontra. ha a menüb l egy almenü nyílik meg. Megnyitás. a végén legyenek a Beállítások.

0-nál nagyobb szám). A menünk a Menu Designer-ben hasonlóan néz ki. Minden menüpontnak egyetlen fontos eseménye van. A menüpontra kattintva nekünk kell beállítani a programban a Checked tulajdonságot true-ra. Csak rajtunk múlik. az OnClick esemény. Ha néhány menüpontnak ugyanazt a GroupIndex-et állítjuk be (0-nál nagyobb) és a RadioItem értékét igazra (true) állítjuk. hogy a menüpontokat nem jó gyakran változatni. A menüben ez a menüpont egy vízszintes választóvonalként fog megjelenni. eltüntetni és megjeleníteni. a Caption tulajdonságban a bet elé tegyünk egy „and” (&) jelet. hogy az egy csoportba tartozó menüpontok közül egyszerre csak egy lehet-e kiválasztva (kipipálva). Tervezési id ben a billenty zetkombinációt az Object Inspector-ban egyszer en kiválaszthatjuk. billenty zetkombinációval is el lehessen érni. nem jelöl dik be menüpontra. akkor a menüpontok közül egyszerre mindig csak egy lehet kiválasztva. &Szerkesztés. o RadioItem – segítségével meghatározható. Mégis el fordulhat. hogyan állíthatjuk be például a Ctrl+C kombinációt: mnuItmMasolas. futási id ben a következ példa mutatja.egyes menüpontnak vannak külön tulajdonságaik. hogy a menüpont ki legyen-e jelölve. hogy itt láthatjuk azokat a menüpontokat is. hogy itt beállítjuk-e a Name tulajdonságot is (pl. mnuFajl. ha a felhasználó rákattint a o GroupIndex – a menüpontok logikai csoportokba való osztását lehet vele megoldani (az ugyanabba a csoportba tartozó menüpontoknak a GroupIndex-e egyforma. Ebben adhatjuk meg azokat a parancsokat. ShortCut – a menüpont billenty zetkombinációját határozza meg. [ssCtrl]). hozzunk létre oda egy új menüpontot és adjunk meg a Caption tulajdonságnak egy köt jelet (-). hogy a menüpontokat vagy az egész menüt meg szeretnénk változtatni (például váltás a nyelvi verziók között. Ebben az esetben . melyeknek a Visible tulajdonságuk hamis (false). kattintsunk rá a tervezési id ben jobb egérgombbal és válasszuk ki a „Create Submenu”-t. Ha a menüpontokat el szeretnénk választani egymástól egy vízszintes vonallal. Már szó volt arról. Ha szeretnénk. hogy látható-e a menüpont. stb. amit a Delphi automatikusan hozzárendelt. A rövidítés (billenty zetkombináció) a menüpont mellé (jobb oldalára) automatikusan kiíródik. vagy szürke és nem lehet rákattintani. o Enabled – meghatározza. A menüpontok fontosabb tulajdonságaik: o o Checked – meghatározza. mint ahogy ki fog nézni az alkalmazásunkban. Ha valamelyik menüpontból egy új almenüt szeretnénk megnyitni. melyeket végre akarunk hajtani. vagy hagyjuk azt. pontosabban hogy mellette (a bal oldalán) legyen-e pipa (jelöl pont). hogy a menüpont engedélyezve van-e. hogy a menüpontot az Alt+bet o automatikusan a menüpontra klikkelve. Például: &File. azzal a különbséggel. vagy ha van egy kezd és egy haladó felhasználónak készített 101 menünk).ShortCut := ShortCut(Word(’C’). 100 Visible – meghatározza. mnuSzerkesztes).

hogy mindig a megfelel beállítani. Az popup menük varázsa abban rejlik. hogy hogyan lehet bebiztosítani. Amivel megjelenítend külön-külön nk is lehet).létrehozunk két menüt (két MainMenu komponenst teszünk a form-ra) és a Form Menu tulajdonságában beállítjuk azt. az az. Ez az esemény pontosan az el tt következik be. Ha a tulajdonság értéke hamis (false). Itt tehát még letesztelhetünk valamilyen beállításokat. var mnItmUj: TMenuItem. majd azok szerint beállíthatjuk a menüpontokat. A komponensekhez tudjuk PopupMenu komponensek popup menüt a form-on lev tulajdonságával (egy alkalmazásban természetesen több PopupMenu- 102 103 .Button1Click(Sender: TObject). Ezek a menük általában a jobb egérgombbal kattintáskor jelennek meg. melybe mindent belerakunk és a menüpontok Visible tulajdonságainak segítségével állítgatjuk. ezért itt ezt nem részletezzük. hogy melyek legyenek láthatók. hogy pontosan azokat a menüpontokat tartalmazza. A problémánk itt az új menüpont OnClick eseményéhez tartozó eljárás megadásánál lehet. melynek segítségével futási id ben is adhatunk új menüpontot a menü végére. foglalkozni fogunk. mnItmUj. A PopupMenu a MainMenu-hoz képest egy új tulajdonsággal. 14. amely segítségével beszúrhatunk menüt máshova is. ahogy azt megszoktuk más programokban. Az ilyen menü létrehozása nagyon hasonlít a MainMenu létrehozásához. Lokális (popup) menü – PopupMenu Manapság már szinte nem létezik olyan alkalmazás. A PopupMenu komponens új eseménye az OnPopup. amelyiket éppen használni szeretnénk. Egyik közülük pl. miel tt megjelenne a popup menü. • Létrehozunk egy „nagy” menüt. akkor a menü automatikusan megjelenik a komponensre kattintáskor a jobb egérgombbal.Add(mnItmUj). A Delphi-ben popup menüt a PopupMenu komponens segítségével hozhatunk létre. end. Ezzel kapcsolatban felsoroljuk. Például: procedure TForm1. amely ne tartalmazna lokális (popup) menüt. Az új tulajdonsága az AutoPopup.2. mégpedig a popup menü jelenjen meg. hogy milyen lehet ségeink vannak. hanem azt a programkódban a Popup metódus segítségével jeleníthetjük meg. • Létrehozunk több menüt (több MainMenu komponenst) és a futási id ben ezeket cserélgetjük (a Form Menu tulajdonságának segítségével). begin mnItmUj := TMenuItem. akkor a menü nem jelenik meg automatikusan. Ha ennek értéke igaz (true). ha futási id ben szeretnénk új menüpontokat berakni a menübe: • Berakhatjuk az új menüpontokat a fent említett módon (hasonlóan az Add-hoz létezik Insert metódus is.Create(Self). A menüpontok sok metódussal is rendelkeznek. egy új metódussal és egy új eseménnyel rendelkezik. amelyre az adott pillanatban szükségünk lehet (az aktuális komponenshez vonatkozik). nem csak a végére). az Add metódus.Caption := 'Új menüpont'. mnItmFile.

A kett nek elválaszthatatlan egészén értjük az objektumot. Ezek az objektumok az alkalmazás épít elemei. A virtuális metódusok segítségével lehet megoldani az öröklés folyamaton keresztül a sokoldalúságot. a statikus megoldás következménye képen. hogy nem csak a régi metódust cseréli ki az újra. függvények). melyet úgy képzelhetünk el. különféle autótípusoknak). de rendelkezhet további adatmez kkel és metódusokkal is. Az osztálynak jellemeznie kéne a viselkedését és a tulajdonságait több hasonló objektumnak (pl. mint bizonyos objektumok sablonját (pl. és amely meghatározza a konkrét objektumok viselkedését. hanem az egész objektumot „átnézve” a régi metódusra mutató összes hivatkozást átírja az új metódusra mutatóvá. nincs hatással az objektum más részeire – így nem változik meg teljesen annak tulajdonsága. hanem a régit fogják meghívni. Tehát ugyanolyan nev function-t vagy procedure-t deklarálhatunk. • Öröklés: Lehet ségünk van új objektumok létrehozására létez objektumokból. a másik a kód. ezért a hibák eltávolítása és az objektumok tulajdonságainak objektumra. 15. Továbbá mivel az adatokat és a programkódot is együtt tartalmazza az objektum. Az objektum a program 104 105 . Gondoljunk itt pl. Objektum orientált programozás Ez a programozási stílus különálló objektumokat használ. Ez azt jelenti. a másik a virtuális. melyek tartalmazzák (magukban zárják) az adataikat és a programkódjaikat is. • Polimorfizmus: Az utód örökölt metódusait a régi helyett új utasítás sorozattal láthatjuk el. az autó egy konkrét. autók). Az objektumok használata lehet vé teszi az egyszer bb beavatkozást a programkódba. Az új objektum a létez objektum összes mez jét (adat) és metódusát (kód) örökli. Az egyik Az változtatása minimális hatással van a többi A statikus metódusok az örökléskor csupán kicserélik az el d metódusát újra. Az objektum az osztály egy konkrét el fordulása (pl. az objektum más részében elhelyezked . Az osztály egy adattípus. példánya). fizikailag létez futásakor memóriát foglal le. és az öröklés folyamatra nézve sokoldalúvá válik. • Zártság: A polimorfizmus megengedi ugyanazt a metódust „kicserélni” egy új metódusra. Ezután a zártság (tehát hogy mennyire zárt az osztály) két szálon futhat tovább.szál – az öröklésre vonatkoztatva – a statikus. akik nem az újat. amilyen az sben szerepel (azért. objektum orientált programozás két legfontosabb szakkifejezése az osztály és az objektum. esetleg t meghívó más metódusokra. Ezáltal megváltozik az egész objektum tulajdonsága. Az osztály tartalmazhat valamilyen adatokat (adatmez k) és metódusokat (eljárások. hogy felülírjuk az régit). Egy objektumnak négy jellemz tulajdonsága van: • Adat és kód kombinációja: Az objektum egyik alkotóelem az adat (vagy adatszerkezet).

// (B) EnAutom. function TAuto. Továbbá ahhoz.Kapacitas := 5. melynek következ mez i lesznek: • • • • típusa – az autó típusa – szöveg típusú. Az alábbi kódot az implementation részben bármilyen eljárásba vagy függvénybe beletehetjük. Mi például a nyomógomb OnClick eseményének kezelését megvalósító eljárásba tesszük bele: procedure TForm1. %d: %d (%d). Ahhoz.Tankolj(Mennyit: Integer): Boolean. Benzin := Min(Kapacitas. ami még belefér és hamis (false) értéket ad vissza. mint a változó és az adattípus közti összefüggést. meg kell adnunk a metódusok (procedure. Ezt az implementation részben adjuk meg. Kapacitas])). EnAutom. procedure InfoKiir. end. A Min függvény (argumentumokban megadott számok közül a kisebbet adja vissza) a Math unitban található. function) programkódját. function Tankolj(Mennyit: Integer): Boolean. gyártási éve – egész szám típusú. end.Az objektum és osztály közötti összefüggést úgy képzelhetjük el. var EnAutom: TAuto. benzin – a tartályban lev szám típusú. Most deklarálunk egy TAuto osztály típusú változót és megmutatjuk. hogyan dolgozhatunk a változóval. hogyan hívhatjuk meg a metódusait. melynek ablakán kezdetben egyetlen gomb legyen. begin ShowMessage(Format('%s. A Result változót használhatjuk a Delhi-ben a függvény értékének visszaadására (a Delphi-ben nem szokták használni a klasszikus „pascalos” felírást: funkcio_neve := visszaadási_érték). [Tipus. GyartasiEv. Benzin.Button1Click(Sender: TObject). (Benzin + Mennyit)). hogy a kompilátor 106 . tankolj – a megadott mennyiség benzinnel feltölti a tartályt.Tipus := 'Skoda'. GyartasiEv.Benzin := 0.GyartasiEv := 1950. benzin mennyisége – egész tudja melyik osztályhoz tartoznak ezek a metódusok. Ha a megadott mennyiség nem fér a tartályba. 028 Írjuk be a következ kódot a modulunk interface részébe: type TAuto = class Tipus: String. ezért használatához ki kell egészítenünk a modulunk uses részét ezzel a unittal. end.'. feltölti a maximumra.InfoKiir. Kapacitas: Integer. begin Result := (Benzin + Mennyit) <= Kapacitas. 107 kapacitás – a tartály rtartalma – egész szám típusú. EnAutom. létrehozunk egy autó osztályt. Az osztálynak a következ metódusai lesznek: • • információk kiírása – kiírja az összes adatmez t. Benzin. Hozzunk létre a Delhi-ben egy új alkalmazást. begin // (A) EnAutom. a metódus elé ponttal elválasztva megadjuk az osztály nevét: procedure TAuto. Ahhoz. hogy mindent jobban megértsünk. hogy ezzel az osztállyal tudjunk dolgozni.

Kell valamit mondanunk az objektumok létrehozásáról. Miután az objektumot létrehoztuk és használtuk. mivel a Delphi maga foglalja le annak az objektumnak a memóriát. A konstruktort a constructor kulcsszó segítségével deklarálhatjuk.Tipus := 'Skoda'. ahová az objektumot eltehetjük). Csupán egy hivatkozást (mutatót) tartalmaz a memóriának arra a helyére. if not EnAutom. Ekkor hiba (kivétel) következik be. Tegyünk tehát konstruktort a TAuto osztályba: type TAuto = class 109 . Nem ajánlatos azonban a konstruktort másként elnevezni.InfoKiir. amelyt l az összes többi osztály (tehát ez is) örökli. end. melyen a konstruktort meghívjuk. A megoldás tehát az. A konstruktor egy specifikus eljárás. mint Create. hanem csak egy hivatkozást az objektumra (a memóriában csak azt a helyet hozzuk létre. els pillanatban minden m ködik mindaddig. EnAutom. hogy az osztály típusú változó (most nem az objektumról beszélünk. 15. … Honnan lett az osztályunknak // (A) // (B) Create konstruktora? Ez valójában a TObject konstruktora.1. melyet konstruktor-nak neveznek (ez az eljárás szolgál a memória lefoglalására és az objektum inicializálására). Ezt a Free metódus segítségével tehetjük meg: … EnAutom. EnAutom. vagy definiálhatunk egy teljesen új konstruktort is.InfoKiir.InfoKiir. end. Az alábbi néhány sor kulcsfontosságú az objektum orientált programozás megértéséhez! Az objektum orientált modell alapgondolata abban rejlik. amíg nem nyomjuk meg a nyomógombot. Gyakran azonban az objektumot inicializálni is kell. Nem tartalmazza sem az auto objektumot sem az auto mez it. Ha a változót úgy hozzuk létre. EnAutom. meg is kell szüntetnünk a végén. Általában ezzel a céllal teszünk az osztályunkba konstruktort. A konstruktor tehát megoldja helyettünk a memória lefoglalással kapcsolatos problémákat.Free. Hogy miért? A hiba elmagyarázása egy kicsit bonyolult és összefügg az objektum orientált modell alapgondolatával. amely a fenti példában az EnAutom. Konstruktor A Create metódust a memória lefoglalása végett hívtuk meg. Ha most elmentjük és lefuttatjuk az alkalmazásunkat.Tankolj(2) then ShowMessage('Ne vidd túlzásba a tankolást!'). Használhatjuk a Create metódus megváltoztatott verzióját. ahová a hivatkozást tehetjük el)! Magát az objektumot nekünk kell létrehoznunk a Create metódusának segítségével. ahol az objektum fizikailag megtalálható. csak a változóról). nem tartalmazza az objektum „értékét”. hogy az (A) és (B) bet vel jelölt sorok közé az el z eljárásban beszúrjuk a konstruktor meghívását: … 108 begin EnAutom := TAuto. ahogy az a fenti példában tettük (a var szócska segítségével).EnAutom. akkor nem hozzuk létre az objektum fizikai reprezentációját (nem hozzuk létre azt a helyet a memóriában.Create.

InfoKiir. begin EnAutom := TAuto. Meg kell adnunk a konstruktorhoz tartozó programkódot is. GGyartasiEv.Free). KKapacitas: Integer). Ezt bárhova beírhatjuk a modulunk implementation részébe akár két eljárás közé is. procedure InfoKiir.Tipus: String. Kapacitas := KKapacitas. Ez a Free metódus leelen rzi. Kapacitas: Integer. hogy „mindenki a saját adataiért a felel s”. ha ott van. de ennek ellenére jó és formálisan is helyes. Egyik alapelve az objektum orientált programozásnak. akkor a konstruktorban mindig el ször meg kell hívnunk az sének a konstruktorát (inherited Create. 1950. A destruktor feladata az objektum megszüntetése. begin inherited Create. Hozzáférés az adatokhoz Az osztály elméletileg bármennyi adatot és metódust tartalmazhat.Create('Skoda'. A TObject-t l közvetlenül származó osztályban az s konstruktorának hívása nem szükséges. amely a destruktort hívja meg (EnAutom.Create(TTipus: String. end.) és utána feltüntetnünk a saját utasításainkat. BBenzin. Ha helyesen akarunk eljárni. Tipus := TTipus. A destruktor neve általában mindig Destroy. A helyesen megalkotott osztály adatainak rejtve kéne maradnia az osztályon belül. 110 EnAutom.Tankolj(2) then ShowMessage('Ne vidd túlzásba a tankolást!'). 15. function Tankolj(Mennyit: Integer): Boolean. Ez el z eljárásban már találkoztunk egy metódussal. Az optimális hozzáférés tehát a következ : „kívülr l” nem lehet az adatokhoz közvetlenül hozzáférni. hogy az adott objektum létezik-e (nem NIL-re mutat-e a mutató). ha ezekhez az adatokhoz csak az osztály metódusainak segítségével lehet hozzáférni. Az a jó. Benzin.InfoKiir. GyartasiEv. GGyartasiEv. if not EnAutom. a lefoglalt memória felszabadítása. BBenzin.Free. de rendelkezésre állnak azok a metódusok.3. Destruktor. melyek ezt a hozzáférést (olvasást. end. EnAutom. end. 0. KKapacitas: Integer). de ajánlott els eljárásként feltüntetni rögtön az implementation után. constructor Create(TTipus: String.2. Így be van biztosítva az autorizált hozzáférés az adatokhoz. Benzin := BBenzin. constructor TAuto. free metódus A destruktor egyszer en fogalmazva a konstruktor ellentettje. 5).Button1Click(Sender: TObject). EnAutom. var EnAutom: TAuto. A Button1Click eljárásunk. Nem ajánlatos hogy bárki tudjon manipulálni az osztály adataival. írást) bebiztosítják. 15. majd meghívja az objektum destruktorát. Az Objekt Pascal-ban ezt a következ hozzáférési kulcsszavak használatával érhetjük el: 111 . most így fog kinézni: procedure TForm1. GyartasiEv := GGyartasiEv. melyben az EnAutom objektummal dolgozunk.

. Ez utóbbira azért van szükség. …. AutoUnit. Megmutatjuk. Az els AutoUnit modullal: uses Windows. alkalmazásunkban AutoUnit nevet és mentsük el ezen a néven. Benzin. de az alkalmazás létrehozásakor is elérhet k. a SysUtils-ban a Format függvény és a Math unitban a Min függvény. BBenzin. • protected – kizárólag az objektumon „belülr l”.Delphi for Win32 menüpont segítségével hozhatunk létre. (eredeti) unit uses részét egészítsük ki az • private – az adatmez k és metódusok elérése csak az objektum-osztály „belsejére” korlátozott. ahol az osztályt definiáljuk bármelyik adatmez t és metódus elérhet az objektumon kívülr l is (még a private is). GyartasiEv. SysUtils. hogy az objektumokat megfelel en tudjuk használni és programunk is áttekinthet bb legyen. azok metódusaiban is elérhet k. Ne felejstük el a programunk uses részébe beírni ennek az új unitnak a nevét. mert a Dialogs unitban található a ShowMessage eljárás. KKapacitas: Integer). A másik modulban marad a TForm1 osztály definíciója és a form-on található eljárás). ahol maga az objektum típus is „látható”. annak leszármazottaiban is. Hozzunk létre tehát egy új unitot. Ebbe 112 113 . function Tankolj(Mennyit: Integer): Boolean. Így biztosítva van az adatokhoz való megfelel hozzáférés is. sorral. amely engedélyezve vannak a fenti négy kulcsszó segítségével úgy. mint a public részben szerepl adatmez k és metódusok. Math. bárhonnan elérhet k. azaz csak magában az objektum típusban ill. Az itt felsorolt adatmez k és metódusok kívülr l nem érhet k el. procedure InfoKiir. public constructor Create(TTipus: String. amelyeket használunk az osztályunk metódusaiban. rakjuk át a TAuto osztály definícióját és az osztály metódusainak implementációját. end. adjunk neki a mi hozzáférést a mi TAuto osztályunkon: type TAuto = class protected Tipus: String. Az alkalmazás szemszögéb l hasonlóan bárhonnan látható. de a többi unitban már csak azok.• public – ebben a részben elhelyezett adatmez k és metódusok az objektumon kívülr l is. Ahhoz. ugyanis abban a unitban. GGyartasiEv. hogyan lehet bebiztosítani az autorizált komponensek eseményeihez tartozó eljárások (a mi esetünkben egyenl re csak a Button1 Onclick eseményét kezel • published – az itt szerepl adatmez k és metódusok nem csak a program futásakor. az osztályok definícióját és metódusainak implementációját ajánlott mindig külön unit-ban tárolni. Ezentúl a saját osztályaink definícióit és a hozzájuk tartozó metódusok implementációit mindig az AutoUnit modulba írjuk majd. ahogy azt leírtuk. Messages. Új unitot a File – New – Unit . Kapacitas: Integer. Az AutoUnit-ot pedig egészítsük ki a uses Dialogs.

BBenzin. hiba!!! 15. if not EnTeherautom. Ekkor ezt a metódust használhatjuk egy 115 114 . Ez azt jelenti. GGyartasiEv. Type TTeherauto = class(TAuto) private Teherbiras: Integer. Az ilyen hozzáférés el nye a polimorfizmus néven ismert. Polimorfizmus. Példaként hozzunk létre egy teherautó osztályt az auto osztály segítségével (az TAuto osztályból való örökléssel). Benzin. EnTeherautom. begin EnTeherautom := TTeherauto. és természetesen lesz saját konstruktora. begin ShowMessage( Format('%s.Free. end. TTeherbiras: Integer). Megjegyzés: az utód osztály helyett bármikor használhatjuk az sének az osztályát. BBenzin. 20. Teherbiras := TTeherbiras. 200.15. procedure InfoKiir. A teherautó osztálynak lesz egy plusz mez je: a teherbírása. dinamikus köt dést is lehet vé tesz. end. hogy a mi két osztályunk (TAuto. Kapacitas. [Tipus. // lehet // NEM lehet. Az objektum orientált programozási nyelv azonban más. GGyartasiEv. 1980. end. GGyartasiEv. Így dolgozhatunk az új osztállyal: procedure TForm1. %d: %d (%d). procedure TTeherauto.InfoKiir. KKapacitas). TTeherauto) a köt dést dinamikusan definiálja. Tegyük fel.Create(TTipus: String.5. end. Teherbiras])).Button2Click(Sender: TObject). Az InfoKiir metódus a teherautó teherbírását is ki fogja írni. Az összes metódus a fenti példákban statikus köt désen alapul.Tankolj(2) then ShowMessage('Ne vidd túlzásba a tankolást!').4. BBenzin. Fordított eset nem lehetséges. EnTeherautom. de az új osztályt további adatmez kkel és metódusokkal is el szeretnénk látni. begin inherited Create(TTipus. EnTeherautom. Például: EnAutom := EnTeherautom. ha egy új osztályt szeretnénk létrehozni egy létez (kész) osztály mintája alapján. var EnTeherautom: TTeherauto. public constructor Create(TTipus: String. Teherbiras = %d'. GyartasiEv. A megváltozattott eljárások programkódjai: constructor TTeherauto. KKapacitas.InfoKiir.InfoKiir. EnTeherautom := EnAutom. melyet kihasználhatunk. virtuális és absztrakt metódusok A Pascal függvények és eljárások általában statikus köt désen alapulnak. TTeherbiras: Integer). KKapacitas. Öröklés Az öröklés az objektum orientált programozás tulajdonsága. hogy a metódus hívása már a fordítónál (és linkernél) „meg van oldva”.Create('Avia'. 10).

VCL) van összegy jtve. … end. Type TTeherauto = class(TAuto) … procedure InfoKiir.. Megjegyzés: Például az eseményekre reagáló metódusok általában tartalmaznak egy TObject típusú Sender paramétert. override. mivel az EnAutom TAuto típusú. begin Valami := TValami. Hogy jobban megértsük az osztály és objektum közti lesznek deklarálhatunk. amilyen például az objektum létrehozása. munka az objektummal . A delphi szíve az osztályok hierarchiája. Az Object Inspector és az elempaletta lehet séget adnak a VCL komponenseinek elhelyezésére a formunkon. hogy a két ugyanolyan nev metódus közül melyik osztály metódusa 16. … end. amely a program futása során a két osztály közül bármelyiknek az objektumára hivatkozhat. Minden osztály a rendszerben a TObject típusú osztály utódja. stb. Az. melynek metódusai az osztályok alap viselkedését határozzák meg.... az EnAutom).általános változónál (mint pl. tehát az egész hierarchiának egyetlen gyökere van. virtual. mindig a program futása alatt d l el a konkrét helyzett l függ en (pontosabban attól függ en. Gyakorlatilag ebb l következik. A dinamikus köt dést a virtual és override kulcsszavak használatával definiálhatunk: type TAuto = class … procedure InfoKiir. Statikus köt dés esetén mindig a TAuto metódusa lett volna meghívva. hogy az osztályban nem kell leírni (definiálni) az absztrakt metódus programkódját (testét). mivel minden osztály a TObject osztályból van levezetve. // itt dolgozhatunk a Valami-vel 117 116 . különbséget. A TObject osztály egy absztrakt osztály. … end. Az osztályok hierarchiája. majd a komponensek tulajdonságainak változtatására a nélkül. VCL Az összes komponens a vizuális komponenskönyvtárban (Visual Component Library. A komponensek használatakor valójában az osztályok lesz meghívva. hierarchiájának a „leveleib l” hozunk létre konkrét objektumokat. megszüntetése. hogy az EnAutom éppen melyik osztály objektumára hivatkozik). virtual.Create. vegyünk rá egy példát: var // TValami – osztály Valami: TValami. hogy programkódot kellene írnunk. Az abstract melyek kulcsszó csak segítségével az utódokban olyan metódusokat definiálva. // Valami – újonnan létrehozott objektum . Ezzel meg van engedve a TObject osztályt használni bármilyen más osztály helyett. A fent említett tények miatt ez a paraméter a VCL bármelyik osztályának eleme lehet. abstract. type TAuto = class … procedure EvValtoztatasa.

ahol nincs egyetlen komponens sem. ha a következnek be. vagy az aktív ablaknak van „default button”-ja (a nyomógomb Default tulajdonságával lehet beállítani) • a felhasználó megnyomja az Esc billenty t és az aktív ablaknak van „cancel button”-ja (a nyomógomb Cancel tulajdonságával állítható be) Az ablak (form) esetében az OnClick akkor következik be.Parent := self. btnUj. A három esemény eljárásainak paraméterei hasonlóak (csak az OnMouseMove érthet okokból nem tartalmazza a lenyomott egérgombot megadó paraméterét). Továbbá OnMouseUp és rendelkezésünkre az áll még az OnMouseDown. ha a felhasználó az ablak üres részére klikkel.Create(self). Az egér Az egér szempontjából az egyik leggyakrabban használt esemény az OnClick. // self = form1-ünk btnUj.Valami. felengedi az egérgombot.1. Ezek akkor OnMouseMove események. A VCL (és a Delphi) nagy el nye. ha ismerjük az egyes komponenseket (a hierarchiában a „fa leveit”). illetve mozgatja az egérkurzort. btnUj. amikor a felhasználó lenyomja az egérgombot. egér Ebben a fejezetben a két legfontosabb bemeneti eszközre – a billenty zetre és az egérre fogunk összpontosítani. amely szinte minden komponensnél megtalálható. Az OnClick esemény azonban máskor is bekövetkezik: • ha a felhasználó a listában a billenty zet (nyilak) módszerrel programunkhoz a program futása alatt.Left := 100. Például a form bármelyik metódusában egy új nyomógombot a következ módon hozhatunk létre: var btnUj: TButton. end. btnUj. 17. elég. duplakattintásnál következik be. Billenty zet. segítségével kiválasztja az elemet. amely 17. Nézzük milyen paraméterei vannak az eljárásoknak (szemléltetjük az OnMouseDown eljáráson): 118 119 . Ehhez hasonló az OnDblClick esemény.Visible := true. vagy nem elérhet komponensre (melynek Enabled tulajdonsága false). hogy a komponensek használatához nem kell ismernünk az osztályok részletes hierarchiáját. Ezzel a // objektum megszüntetése komponenseket is adhatunk a felhasználó felengedi az egérgombot az adott komponens fölött. begin btnUj := TButton.Free.Top := 200. end. • ha a felhasználó a szóközt nyomja meg és az aktív komponens a CheckBox vagy a Button. • ha a felhasználó megnyomja az Enter billenty t és az aktív komponens a Button. Ez az esemény pontosabban akkor következik be.

Az OnKeyPress a billenty megnyomásakor következik be.FormMouseDown(Sender: TObject. A koordináták képpontokban (pixelekben) vannak megadva a komponens bal fels sarkához viszonyítva. Továbbá az egér saját gombjainak az állapotát is jelzi. Lehetséges értékei: mbLeft (bal egérgomb). Az X. elég használnunk a Mouse globális változót. a harmadik ha felfelé görgetjük. melynek értéke igaz (true). melyek segítségével az egér görget gombjával dolgozhatunk. melyik egérgomb volt lenyomva (melyik egérgomb lenyomásával következett be az esemény). …) nem generálnak OnKeyPress eseményt. 17. F1. Shift: TShiftState. ssRight (jobb egérgomb). amely Char típusú és a lenyomott billenty ASCII kódját tartalmazza. Azok a billenty k. OnKeyUp és OnKeyPress eseményeket használjuk. A Sender paraméter azt a komponenst jelöli. mbRight (jobb egérgomb). Ctrl. Ha azokat a billenty ket szeretnénk figyelni. akkor használhatjuk a TMouse osztályt is. akkor az OnKeyDown ill. amennyivel a szöveg elmozduljon a görgetésnél).2.Procedure TForm1. Shift. eseményeknél. WheelPresent-et (van-e görget je az egérnek) és a WheelScrollLines-t (sorok száma. a MousePos paraméter pedig megadja az egér kurzorának a koordinátáit. X. mely tartalmaz további információkat is az egérr l. Billenty zet A billenty zettel való munka során leggyakrabban az OnKeyDown. amelyen bekövetkezett az esemény. a második ha lefelé. egérgomb). Button: TMouseButton. Az esemény kezelésében rendelkezésünkre áll a Key paraméter. A Shift paraméter megadja némely gombok állapotát az esemény bekövetkezésekor. ssLeft (bal egérgomb). ssMiddle (középs ssDouble (duplakattintás következett be). melyeknek nincs ASCII kódjuk. Rendelkezésünkre állnak még az OnMouseWheel. Lehetséges értékei: ssShift (Shift billenty le volt nyomva). ha a görget t bármelyik irányba görgetjük. mbMiddle (középs egérgomb). Y: Integer). Ezek közül a legfontosabb a MousePresent. Y paraméterek az egérkurzor koordinátáit adják meg azon a komponensen belül. ssCtrl (Ctrl billenty ). OnKeyUp eseményeket kell 120 121 OnMouseWheelDown és az OnMouseWheelUp események. Az események eljárásaiban a WheelDelta paraméterb l megtudhatjuk. Az els esemény akkor következik be. melyekb l minden fontosat megtudhatunk az egérr l. amelyen az esemény bekövetkezett. Ha ezek az események és paramétereik nem elég nekünk valamilyen m velet elvégzéséhez. ssAlt (Alt billenty ). melyeknek nincs ASCII kódjuk (pl. A többi tulajdonságból megemlítjük még a CursorPos-t (egér koordinátái a képerny höz viszonyítva). a Shift+A megnyomásakor egyetlen OnKeyPress esemény következik be. mivel egyszerre több értéket is tartalmazhat. Ez a paraméter egy halmaz. ha van egér a rendszerben (be van telepítve). mennyivel görgettük a görg t. A Shift paraméter hasonló mint az el z . Ha ki szeretnénk használnia TMouse osztályt. Ennek a változónak van néhány tulajdonsága. A Button paraméter megadja. Tehát pl.

stb. hogy a Shift. begin ShowMessage(’Koordináták: X=’ + IntToStr(X) + ’.FormMouseDown(Sender: TObject. Minden egérkattintásnál a form-ra (ablakra) kiírja. Ez itt egy virtuális billenty kód. pl. Shift: TShiftState. mbMiddle: ShowMessage(’Középs egérgomb. Procedure TForm1. ahová az egérrel kattintottunk. X. Meg volt nyomva a Shift a dupla egérkattintásnál? 030 122 123 . tartalmazza. Ctrl. hogy meg volt-e nyomva a Shift billenty . end. használatát.’). Továbbá használhatjuk az eljárás Shift paraméterét is. begin if (ssShift in Shift) and (ssDouble in Shift) then ShowMessage(’Shift + dupla kattintás’). end. akkor erre a ClientToScreen metódust használhatjuk. Y: Integer). VK_Control (Ctrl).FormMouseDown(Sender: TObject. VK_Back (Backspace). X.használnunk. Y: Integer). Ha az egész képerny höz viszonyítva szeretnénk megtudni a koordinátákat.’). Procedure TForm1. X. ha a felhasználó lenyom egy billenty t. Y=’ + IntToStr(Y)). amely megadja. mbRight: ShowMessage(’Jobb egérgomb.’). Shift: TShiftState. begin case Button of mbLeft: ShowMessage(’Bal egérgomb. 032 Az el z példában a koordinátákat az ablakhoz viszonyítva írtuk ki. 17. Koordináták kiírása a képerny höz viszonyítva. a második amikor felengedi. end. Procedure TForm1. Alt gombok közül melyik választógomb volt lenyomva az esemény bekövetkezésekor. Y: Integer). 031 Az egér melyik nyomógombjával volt kattintva? 029 Az alábbi példa bemutatja az OnMouseDown esemény Az OnMouseDown esemény segítségével kiírjuk az ablak azon pontjának koordinátáit.3. Button: TMouseButton. end. amely a lenyomott billenty kódját Az alábbi példában az OnMouseDown esemény segítségével megállapítjuk. Button: TMouseButton. Mindkét esemény kezelésének eljárásában van Key paraméter. Az els akkor következik be. melyik egérgombbal történt a kattintás. ha kattintunk. amikor az egérrel duplán kattintottunk a form-on. Button: TMouseButton. Shift: TShiftState.FormMouseDown(Sender: TObject. Példaprogramok az egér és a billenty zet használatára Az egérkurzor koordinátáinak kiírása.

end else if Mouse. Button: TMouseButton.Text. procedure TForm1. begin if not Mouse.Procedure TForm1. Y: Integer). [mbOk]. Edit1. [mbOk].’. var Pont: TPoint. A szöveg azonban nem jelenik meg úgy 124 125 . Az alkalmazás egy beviteli szövegdobozt tartalmaz. i: Integer. Ha van egér. ShowMessage(’Koordináták: X=’ + IntToStr(Pont. end.Text := ret. 0). 034 Az alábbi példa szemlélteti a billenty zettel való munkát. X. Application. Az alkalmazás leáll. ahová a felhasználó megadhat valamilyen szöveget. procedure TForm1. Shift: TShiftState.MousePresent then begin MessageDlg(’Hiba: Nincs egér. Procedure TForm1.X) + ’. A dekódolás ennek ellentettje lesz. 0). Van-e egér a rendszerben? Van-e görget gombja? 033 Ahhoz. begin Key := Chr(Ord(Key)+1). var ret: String. var Key: Char).FormCreate(Sender: TObject).Button1Click(Sender: TObject). for i := 1 to Length(ret) do ret[i] := Chr(Ord(ret[i])-1).WheelPresent then MessageDlg(’Info: az egérnek van görget je. hogy megtudjuk van-e egér telepítve az operációs rendszerben. Billenty zetr l bemenet kódolása. akkor hasonlóan megállapítjuk van-e görget gombja. hogy eggyel nagyobb ASCII kódú jelet írunk ki. hanem „elkódolt” formában íródik a szövegdobozba.’. a globális Mouse változót fogjuk használni.Y)). end. begin Pont := ClientToScreen(Point(X.Edit1KeyPress(Sender: TObject. mtInformation.Terminate.FormMouseDown(Sender: TObject. mtError. Y=’ + IntToStr(Pont. end. A kódolás a mi példánkban úgy fog történni. end.Y)). ahogy azt a felhasználó megadja. A nyomógomb megnyomásával a szöveg dekódolódik olvaható formába. begin ret := Edit1.

… 126 127 . X. X. X.DragMode := dmAutomatic. A felhasználó a kiválasztott állományt meg tudja majd fogni a FileListBox komponensben és áthúzni a Memo komponensbe. Source: TObject. Y: Integer). mi a Form1 OnCreate eseményében állítjuk be). ahol a fájl tartalma megjelenik. var Accept: Boolean). Mouse. begin Accept := Source is TFileListBox.4. hanem bekövetkezhet például csak az egér elmozdításánál bizonyos számú képponttal. Azt. Az alkalmazás létrehozásához fogjuk használni a DirectoryListBox. Source: TObject. Memo1: OnDragOver.FileList tulajdonásgát. State: TDragState. Ahhoz. end. hogy a dragand-drop m velet egyáltalán nem is volt elindítva (csak inicializálva volt a bal egérgomb megnyomásakor). be kell állítanunk a DirectoryListBox1.FormCreate(Sender: TObject). Ennek a tulajdonságnak hivatkozást kell tartalmaznia Az egyes eseményekhez tartozó eljárásokat tartalmazó programrész: … procedure TForm1. hogy a m velet el volt-e indítva (pontosabban hogy fut-e). Target: TObject. A valódi indítása a m veletnek azonban nem kell hogy azonnal bekövetkezzen.FileListBox komponensünkre (ezt beállíthatjuk az Object Inspector-ban is. end.LoadFromFile(FileListBox1. begin DirectoryListBox1.Memo1DragDrop(Sender.IsDragging then if (Target <> nil) then ShowMessage('Az állomány sikeresen át lett húzva a komponensbe.Memo1DragOver(Sender. Y: Integer). 035 Az alkalmazásunk szöveges fájlok kiírását (megjelenítését) fogja lehet vé tenni a drag-and-drop m velet segítségével. hogy a DirectoryListBox komponensben a mappa változtatásakor a FileListBox komponenst tartalma automatikusan megváltozzon. Az OnEndDrag esemény bekövetkezésekor tehát lehetséges. OnDragDrop és a FileListBox: OnEndDrag eseményeit. Ebben a pillanatban van ugyanis inicializálva a drag-and-drop m velet.DragImmediate := false. end.FileListBox1EndDrag(Sender. FileListBox1. Drag & Drop – fájlok tartalmának megtekintése A következ példa bemutatja.Lines. Figyelmeztetés: az OnStartDrag esemény minden egyes bal egérgomb lenyomáskor bekövetkezik. procedure TForm1.') else ShowMessage('Az állományt nem sikerült áthúzni!'). melynek ebben az esetben true értéke lesz. procedure TForm1. begin if Source is TFileListBox then Memo1. hogyan használhatjuk alkalmazásunkban a drag and drop m veletet.FileName).IsDragging globális objektum változójából. procedure TForm1. megtudhatjuk a Mouse. Memo és Label komponenseket.FileList := FileListBox1. begin if Mouse. Kezelni fogjuk a Form1: OnCreate. Y: Integer. end. FileListBox. 17.

Ez a távolság alapértelmezett beállításban 5 pixel.DragImmediate globális objektum tulajdonságát False-ra. Az esemény kezelésében megint meggy z dünk róla.Az utolsó Az ablak OnCreate eseményében beállítottuk a eseményt csak bemutatás végett kezeljük a programunkba. sikertelen m velet esetén pedig az értéke nil. hanem csak komponensek tulajdonsága. az Image-ben és a TBitmap osztályban. a megadott állományt beolvassuk a Lines tulajdonságba. A Brush tulajdonság beállításával változik az alakzatok kitöltésének színe és mintája. szöveg kiírása A Delphi-ben van egy alapobjektum a rajzolásra – a vászon (TCanvas osztály). de ugyanúgy megtalálható további komponensekben is. hogy a drag-and-drop m velet nem indul el rögtön az egérgomb lenyomása után. A canvas objektum sok grafikus komponens tulajdonsága a Delphi-ben.DragThreshold tulajdonság segítségével változtathatjuk meg. ha az egérkurzor egy megadott távolságot tesz meg. Továbbá kezelve van a Memo komponens OnDragOver eseménye. mint pl. amikor a komponens fölé húzunk valamilyen objektumot. A Font tulajdonságnak is vannak A másik kezelt esemény a Memo komponens OnDragDrop eseménye. Vászon van a form-on. mint ahogy a fest m veszek is rajzolnak a vászonra. Ezzel bebiztosítjuk. Ezzel elértük. Erre a vászonra (Canvas) rajzolhatunk. Mouse. Color (szín) és Style (stílus). Name (bet típus neve). Ez látszódik az egérkurzor alakján is. stb. Ez az esemény a FileListBox OnEndDrag eseménye. amikor a drag-and-drop m velet befejez dik (akár sikeresen – az objektum fogadva volt. hanem csak akkor. Ez az esemény akkor következik be. Az esemény kezelésében az Accept paraméter értékét állítjuk be True-ra. hogy a vászon nem egy különálló komponens. amelyen vászon van. Size (méret). Style (stílus). Grafika. rajzolás. • Font – bet . amikor a felhasználó lenyomja a bal egérgombot a FileListBox komponensben. 128 129 . 18. A drag-and-drop operáció kezdete (inicializálása) abban a pillanatban következik be. Ez az esemény akkor következik be. hogy nekünk ezt ne kelljen kezelni az OnMouseDown eseményben (a BeginDrag függvény segítségével). Képzeljük el az ablakunkat (form) úgy. melynek értéke sikeres m velet esetén a célkomponenst tartalmazza. ha a húzás forrása egy TFileListBox típusú objektum. akár sikertelenül – az objektum nem volt fogadva). mint egy üres területet. amikor az objektumot elengedjük a komponens fölött. Az ecsetnek vannak további tulajdonságai is: Bitmap (az ecset mintáját definiáló bitkép). Ahhoz. Ne feledjük. Ez akkor következik be. Charset (karakterkészlet). altulajdonságai: Color. értékét a Mouse. hogy a belehúzott objektum forrása egy TFileListBox típusú objektum-e. hasonlóan. Ha igen. A következ felsorolásból megismerhetjük a vászon legfontosabb tulajdonságait: • Brush – ecset. hogy a Memo komponenst a belehúzott objektumot tudja fogadni (és hajlandó legyen fogadni). beállítjuk a FileListBox DragMode tulajdonságát dmAutomatic-ra már az ablak OnCreate eseményében. Itt fontos a Target paraméter.

FormPaint(Sender: TObject). Az ecset stílusának beállításánál az ItemIndex (áttipizáljuk) Az egyes események kezelésének programkódja: TbrushStyle típusra. ha szükséges átrajzolni az ablakot (pl. A négyzet kirajzolását a RoundRect (lekerekített sarkú aktuális értékét átalakítjuk rögtön hozzárendelhetjuk téglalap) metódus segítségével biztosítjuk be. 131 .RoundRect(10.• Pen – toll.Color := clRed. Pie (körszelet).Style tulajdonsághoz. stb.100. ha az ablak el volt takarva másik ablakkal. begin Canvas. segítségével. stb.Brush. Polyline.ItemIndex). vagy alkalmazás indításakor.100.Brush.Style tulajdonságok segítségével az ecsetet. A vászon Color tollának (szín).Color és a felhasználó rákattint valamelyik választógombra a vászonra kirajzolni egyszer (RadioGroup). Chord. Ezt a tulajdonságot írni és olvasni is lehet. begin Repaint. procedure TForm1. • PenPos – toll aktuális pozíciója. Canvas. így rajzolhatunk a vászonra pontonként.Columns := 2. kikényszerítjük az ablak átrajzolását a Repaint metódus a Canvas. Width end. Megpróbálhatunk más procedure TForm1. pl.10). end. Polygon. Miután segítségével. 18. • Pixels – a pixelek színe. A tulajdonság értékét olvasni és írni is lehet. típusát adja meg.ItemIndex := 0. hogyan lehet geometriai alakzatot megadott kitöltési Maga a kirajzolás az OnPaint eseményben történik.RadioGroup1Click(Sender: TObject).10. RadioGroup1. (vonalvastagság). Altulajdonságai: Style (stílus).Brush.Brush.1. Canvas. 036 program ebben a fejezetben bemutatja. Ez az esemény mindig akkor következik be. 130 alakzatokat is kirajzolni. end. így a Brush.). Az alkalmazásban beállítjuk a Canvas.FormCreate(Sender: TObject). Mode (toll rajzolási módja).Style := TBrushStyle(RadioGroup1. begin RadioGroup1. procedure TForm1.10. Ecset stílusa Az els stílussal. a Rectangle (téglalap).

Az alkalmazás beolvas egy bitképet a tapeta. Canvas. bmp. A FontDialog komponensen kívül szükségünk lesz még egy Button komponensre.FormPaint(Sender: TObject). Az események eljárásaihoz tartozó programkódok: A programban használt FillRect metódus a megadott téglalapot kifesti az aktuális ecsettel. de rajzolhatunk is.Brush.Bitmap := bmp.Assign(FontDialog1. a kiválasztott bet típussal kiírunk egy szöveget a form-ra. 038 bitképet és jeleníthetjük meg az ecset segítségével.3. Minden programkódot a form OnPaint eseményének kezelésébe írunk.Bitmap := nil.FillRect(Rect(0. begin Canvas. procedure TForm1.Create.Button1Click(Sender: TObject).Width. 037 procedure TForm1. másrészt megmutatja. Az alkalmazásban kezelni fogjuk a Button komponens OnClick eseményét és a Form OnPaint eseményét. begin bmp := TBitmap.0. hogyan olvashatunk be küls állományból egy a felhasználó ennek a dialógusablaknak a segítségével választ bet típust. Canvas. end. A következ alkalmazás egyrészt szemlélteti a szöveg kiírását grafikus módban.Brush.18. Utánna ezzel az ecsettel (tehát a bitmap-pal) kitöltjük az egész ablakot. procedure TForm1. majd hozzárendeli az ablak (form) ecsetéhez. Miután 132 133 .Free. Most nem lesz szükségünk semmilyen komponensre.Font). end. Repaint.Execute then Canvas.2. begin if FontDialog1. Canvas. Szöveg grafikus kiírása A vászonra nem csak írhatunk.LoadFromFile('tapeta.bmp állományból. bmp.FormPaint(Sender: TObject). Bitmap beolvasása állományból Megmutatjuk.Height)). end.'Teszt szöveg'). hogyan dolgozhatunk a FontDialog komponenssel (err l b vebben a kés bbi fejezetekben lesz szó).bmp').Font. var bmp: TBitmap. 18.50.TextOut(20.

Image1.LineTo(X. A következ eseményeit OnClick fogjuk kezelni az egyes Button2.DefaultExt := 'bmp'. Shift: TShiftState.Y). megváltoztathatjuk a vonal vastagságát és színét. Y: Integer). procedure TForm1. .Canvas. procedure TForm1. end. Shift: TShiftState. X. (Image1).Color := clWhite. majd a munkák eredményét elmenthetjük fájlba. UpDown1. Az OnPaint eseményben kiírjuk a szöveget a TextOut metódus segítségével. OnResize (Form1). Image1. procedure TForm1. OnMouseDown Button1. begin Image1.Y).FormCreate(Sender: TObject). begin if ssLeft in Shift then Image1.Image1MouseMove(Sender: TObject.Cursor := crCross.Position := 1. Lavel és UpDown.Min := 1.Assign metódusát használjuk. melynek els jelentik. (UpDown1. SavePictureDialog1. Egyszer grafikus editor Az egyes eseményekhez tartozó programkód: Ennek az alkalmazásnak a segítségével egyszer en rajzolhatunk bitképeket.Max := 20. (Image1).Canvas. A bet típus változtatásakor meghívjuk az ablak átrajzolására szolgáló Repaint metódust. end. X.Brush. 134 135 ColorDialog.4. komponenseknek: OnMouseMove OnCreate (Form1).Image1MouseDown(Sender: TObject.MoveTo(X. Button: TMouseButton. SavePictureDialog. Image. UpDown1. begin Form1. UpDown1.Canvas. Button3). két paramétere a szöveg koordinátáit 18. 039 Szükségünk lesz a következ komponensekre: 3 x Button.A bet típus kiválasztása után a vászon Font. Y: Integer).DoubleBuffered := true. amely az egyik bet típus összes atribútumát átmásolja a másikba.

Execute then try Image1. A szín kiválasztása után elég ennek a komponensnek a Color tulajdonságát hozzárendelnünk a toll színéhez.Button1Click(Sender: TObject). end.Picture.Image1. A vonal színének kiválasztásához a ColorDialog komponenst használjuk. end.Brush. Image1. ha például valamilyen grafikus editort készítünk.SaveToFile metódusát használjuk. Button: TUDBtnType). ahol a kattintás történt. 18. procedure TForm1. end. Az egér mozgatásakor.Color.Bitmap. Image1.FormResize(Sender: TObject).5.Button2Click(Sender: TObject). end.Color := ColorDialog1.Button3Click(Sender: TObject).Execute then Image1. Tehát a OnMouseDown és OnMouseMove események együttm ködését használjuk. procedure TForm1. begin Image1. begin Image1. procedure TForm1.Width := UpDown1.0.Width := Image1. Színátmenet létrehozása Ebben a részben egy színetmenetet fogunk kirajzolni az ablakunk vásznára.Picture.Canvas. ha a bal egérgomb lenyomva van.Caption := 'Vonalvastagság: ' + IntToStr(UpDown1.Height)).Height := Image1. begin Image1. Image1.Picture. end. except ShowMessage('Hiba a kép mentésénél!'). Itt fontos metódusok a MoveTo (toll pozícióját állítja be) és a LineTo (toll mozgatása és egyben vonal rajzolása).Pen.Canvas.FillRect(Rect(0.Width. húzunk vonalat az egér koordinátáig a toll el z pozíciójától (ezzel a toll pozícióját is megváltoztatjuk az egér koordinátáira). begin if ColorDialog1.Height.SaveToFile( SavePictureDialog1.Canvas. A kép mentéséhez a SavePictureDialog komponenst (fájlnév és mentés helyének meghatározásához) és az Image.Color := clWhite.Pen. procedure TForm1. Label1.end. 136 137 . begin if SavePictureDialog1.FileName). procedure TForm1.Canvas. end. 040 A toll vonalvastagságának beállításához az UpDown komponenst használjuk (a Win32 kategóriából). Ez a trükk jól jöhet a jöv ben.UpDown1Click(Sender: TObject.Position).Bitmap. A rajzolás a következ képpen megy végbe: az egérgomb megnyomásakor a toll pozícióját azokra a koordinátákra állítjuk.Position.Picture.Width.

i: Integer.FormResize(Sender: TObject). Ezzel a módszerrel egy kis módosítás után könnyel létrehozhatunk egy olyan rajzprogramot gyerekeknek. begin // kezdeti beállítások szinTol := clRed. deltaB := (GetBValue(szinIg)-GetBValue(szinTol)) / Width.Height)).Color := RGB ( Round(deltaR*i+GetRValue(szinTol)). 18.zöld. Végül az ablak átméretezésekor bekövetkez eseményhez (OnResize) beírtuk az ablak átrajzolására szolgáló metódust (Repaint). begin Repaint.i+1. Az eredményt a Round függvénnyel kikerekítettük egész számra.6. end. Round(deltaB*i+GetBValue(szinTol))). deltaB: Double. deltaG. szinTol. szinIg := clYellow. end. var deltaR. // egyes színösszetev k növekménye deltaR := (GetRValue(szinIg)-GetRValue(szinTol)) / Width.piros. Round(deltaG*i+GetGValue(szinTol)). // rajzolas for i:=0 to Width do begin Canvas. end. begin DoubleBuffered := true.Az alkalmazásban az ablak OnCreate.0. Kép kirajzolása megadott koordinátákra Ebben a programban megismerkedünk azzal. procedure TForm1.kék) a különbség a szomszédos pontok között (deltaR. hogy a kezdeti szín (szinTol) összetev jéhöz hozzáadtuk a növekmény (deltaX) és a sor elejét l számított képpontok (i) szorzatát. szinIg: TColor. hogyan rajzolhatunk ki egy képet egy Image komponens megadott részére. deltaG. deltaB). OnPaint és OnResize eseményeihez írjuk meg a programkódot. G . A rajzolás el tt meghatároztuk mennyi az egyes színösszetev kben (R . B . 138 139 . Az aktuális szín összetev it úgy határoztuk meg. A szín változtatását és a kirajzolást egy ciklus segítségével oldottuk meg. melyben pecsételgethetik a kiválasztott képet a megadott helyre.FormCreate(Sender: TObject).Brush.FormPaint(Sender: TObject). end. procedure TForm1. procedure TForm1. hogy az átméretezésnél az átrajzolás ne villogjon.FillRect(Rect(i. Canvas. 078 A programunkban használni fogunk két Image komponenst és egy Button komponenst. deltaG := (GetGValue(szinIg)-GetGValue(szinTol)) / Width. Az ablak létrehozásánál beállítottuk a DoubleBuffered értékét true-ra azért.

Image1. A nagyobb Image1 komponensre fogunk rajzolni. Erre szolgál az Animate komponens (a Win32 kategóriából). var x. az Image2 komponensbe töltsük be a Picture tulajdonság segítségével az a képet.Height)).Draw(x.FillRect( Rect(0. begin Randomize.FormCreate(Sender: TObject).Image2.Image1. melyet akarunk majd az Image1-re kirajzolni.Draw metódusát használjuk. y := Random(Image1. Erre a Canvas.Width) . Animáció megjelenítése A Delphi-ben nem csak statikus grafikát.Width div 2. procedure TForm1. // Hattert kifestjuk sotetkekre Image1. begin // Kiszamitjuk.Width.Height) .Brush. hogy a képunk háttere átlátszó legyen. hogy a program futásakor ne legyen látható.Graphic. áthelyezésekor megjelen animációk).Image1 komponens háttérszínét is sötétkékre az RGB függvény segítségével.Graphic. Itt beállítjuk az 18.y.Image2. a másik. Image2 komponens csupán a kép tárolására fog szolgálni. end. Mivel véletlenszer helyre rajzoljuk ki.50).Picture. Ebbe.Color := RGB(0.Image2.Canvas. Y koordinatakra Image1. Ne felejtsük még beállítani a Form OnCreate eseményében a véletlenszám generátor inicializálását (randomize). 140 141 . de animációt is megjeleníthetünk. de segítségével lehet ségünk nem van csak néhány AVI állományokat rendszeranimáció lejátszására is (pl.0. Az alkalmazásunkhoz tartozó programkód tehát így néz ki: procedure TForm1.Image1.Picture. A Button1 nyomógomb megnyomásakor egy véletlenszer helyre kirakjuk az Image1 komponensre az Image2-ben tárolt képet. end.Height div 2.0. // Kirajzoljuk a csillagot az X.Picture. Ennek játszhatunk le. majd a Transparent tulajdonságát true-ra.7.Graphic).Canvas. hova fogjuk kirajzolni a csillagot x := Random(Image1.Canvas. ezért a gomb újboli megnyomásakor mindig más helyre fog kirajzolódni a képünk. fájl törlésekor.y: Integer. Továbbá állítsuk be az Image2 komponenst Visible tulajdonságát false-ra.Button1Click(Sender: TObject).

el re definiált animációk közül. var a. Hozzunk létre egy ablakot (form). hogy a program egy adott részében el fordulhat hiba a futása közben. amely segítségével szemléltetni Az egyes eseményekhez tartozó programkód: fogjuk az egyes hibakezelési lehet ségeket. 041 kívül felvehet például aviFindFile. aviFindComputer. majd beírja a nyomógomb feliratába két A CommonAVI tulajdonság segítségével választhatunk a standard. begin Animate1. procedure TForm1.FormCreate(Sender: TObject). OnClick eseményének kezelésébe írjuk be az alábbi programrészt: procedure Form1. begin a := 0. helyezzünk el rá egy Animate komponenst és két nyomógombot. . end. end. A nyomógomvok segítségével elindíthatjuk ill. majd a nyomógomb procedure TForm1. aviCopyFile. Button1. begin Animate1.Hozzunk létre egy új alkamazást.Caption := IntToStr(c). Az aviRecycleFile értéken 142 143 szám egész rész hányadosát (div). kivételek kezelése Amint sejtjük.CommonAVI := aviRecycleFile. b := 0. end. Az Animate komponens segítségével AVI állományok is lejátszhatók. megállíthatjuk majd az animációt. tegyünk rá egy nyomógombot (button).Button1Click(Sender: TObject). Létrehozunk egy eljárást. ha a hiba csak nagyon ritkán. ezt a hibát megfele en kezelnünk kell még akkor is. stb.Button2Click(Sender: TObject). c: Integer. Hibák a program futásakor. end. b.Button1Click(Sender: TObject). kis valószín séggel fordul el .Active := true. begin Animate1. értékeket. Ebben az esetben az álloányt az útvonallal együtt a FileName tulajdonságban kell megadni.Stop. procedure TForm1. A program kiszámolja. 19. c := a div b.

procedure TForm1. melyekben valamilyen változók. Button1. Button1. Hibák kezelése hagyományos módon A hiba kezelése hagyományos módon általában feltételek segítségével történik. 0-t. ebben a példában csak azt mutatjuk be.Ebben a programban nincs kezelve semmilyen hiba. c: Integer. nyilvánvaló.2. Ha a programot lefuttatjuk és megnyomjuk a nyomógombot.Caption := ’Hiba’. end. hogyan fog az eljárásunk kinézni. Ez a hiba egy kivételt eredményez.Caption := IntToStr(c).Button1Click(Sender: TObject). Hogy miért van ez így. Hibák kezelése kivételek segítségével Most ugyanebben az eljárásban a hibát kivételek segítségével kezelni.1. var a. ha még nem ismerjük a kivételek használatának pontos szintaxisát. • az eljárásokban a hiba valamelyik paraméterben van megadva. 043 procedure TForm1. b változókba 0-t tettünk a program elején. stb. end. függvények és eljárások visszaadási értékeit figyeljük. except on EdivByZero do begin ShowMessage(’Nullával nem lehet osztani!’). end. hogy a kivétel kezelve van. Button1. begin a := 0. begin a := 0. b. var a. b. Mivel az a. Még ha mi nem is kezeltük a hibát. begin c := a div b. end else begin ShowMessage(’Nullával nem lehet osztani!’). if b<>0 then 144 145 . Ennek a módszernek a hátrányai egyszer en megfogalmazva a következ k: • • a hibakódokat meg kell jegyeznünk.Caption := IntToStr(c). hibakódok. minden függvény az eredménytelenséget másképp reprezentálja – false értéked ad vissza. 042 fogjuk 19. hogy a hiba bekövetkezik (osztás nullával). err l a kés bbiekben lesz szó. Nézzük meg hogyan kezelnénk hagyományos módszerekkel a hibát az el z programunkban.Caption := ’Hiba’. b := 0. melyet a div m velet generál. esetleg valamilyen globális paraméterben. Button1. Nem baj.Button1Click(Sender: TObject). 19. -1-et. láthatjuk. b := 0. try c := a div b. láthatjuk az üzenetet a kivételr l. end. c: Integer.

elmondunk néhány dolgot a kivételekr l és a program állapotáról. végül minden kivétel kezelve lesz.Caption := ’Szia’.end. Fontos. Ez az egyszer példa bemutatja a munkát a kivételekkel. c: Integer. b. hogy a kivételt értelmetlen dolog kézzileg el hívni. Button1. amely minden esetben végrehajtódik. akár nem. except on EdivByZero do begin ShowMessage(’Nullával nem lehet osztani!’). Ha a program elején a b változó értékét megváltoztatjuk nem nulla számra. begin a := 0. Az Nézzük meg most részletesebben a finally részt. amelyet el akarunk végezni minden esetben. majd a nyomógomb feliratában megjelenítti a „Hiba” szót. Ezt a részt általában a lefoglalt memória felszabadítására. Ha az adott programrészben nincs ilyen eljárás. a kivételek kezelésére szolgáló parancsokat tartalmazza a következ formában: on kivétel_típpusa do parancsok else parancsok • finally – annak a programrésznek az elejét jelzi. akár nem. Form1. • except – a védett kód végét jelenti. try c := a div b. nem a kivételt okozó programkód után. megnyitott fájlok bezárására használjuk. end. Button1. amely a kivételt kezeli. • raise – kivétel el hívására szolgál. amíg valaki nem foglalkozik vele. Ezt a részt olyan tevékenységek elvégzésére használjuk. Ilyen pl. Még ha úgy is t nik. end. akkor a program az osztás eredményét megjeleníti a nyomógomb feliratában. Nézzünk most példát a kivételek kezelésére a finally blokk nélkül (a memória felszabadítása helyett most az ablak feliratját fogjuk megváltoztatni „Szia”-ra). var a. akár a kivétel bekövetkezik. b := 0. akkor a kivétel „feljebb viv dik” mindaddig. hogy procedure Form1. Miel tt konkrét példákon megmutatnánk a kivételek használatát. end. a memória felszabadítása. Ha bekövetkezik valamilyen kivétel. kivételek egész mechanizmusa négy kulcsszón alapszik: • try – a védett kód elejét jelzi.Caption := IntToStr(c).Button1Click(Sender: TObject). mégis néha hasznos lehet. ezért van az. akkor kerestetik egy „kezel eljárás”. amelyben el reláthatóan bekövetkezhet a hiba. Ez program kiírja a hibát. akár bekövetkezett a kivétel. Extrém esetekben ezt maga a Delphi kezeli.Caption := ’Hiba’. hogy a kivétel kezelése után a program a „kivételt kezel eljárás” után fog folytatódni. 146 147 . tehát azt a programrészt.

A megoldás a finally blokk használata lehet: try c := a div b.Ha bekövetkezik a 0-val való osztás. finally Form1. finally Form1.Caption := IntToStr(c).Caption := ’Hiba’. 044 try {parancsok} except on {kivétel_típusa} do {ennek a kivételnek a kezelése} on {kivétel_típusa} do {ennek a kivételnek a kezelése} … else {bármilyen más kivétel kezelése} end. end. b. end. hogy az else részben bármilyen más kivételt kezelhetünk. end. Sajnos azonban most nincs lekezelve a kivételünk.Button1Click(Sender: TObject). ami végett az egészet tettük. begin a := 0. soha nem lesz végrehajtva az ablak feliratának beállítása „Szia”-ra. b := 0. c: Integer. var a.Caption := IntToStr(c). Button1. var a.Caption := ’Szia’. try c := a div b. b := 0. begin a := 0. melyet el re nem vártunk. Az ismeretlen kivételek 149 . end. 19. b. procedure Form1. except on EdivByZero do begin ShowMessage(’Nullával nem lehet osztani!’). try 148 Láthatjuk. A megoldás: kombináljuk (egymásba ágyazzuk) a finally és az except blokkot. procedure TForm1. Button1. Button1. end.3.Button1Click(Sender: TObject). end. Except blokk szintaxisa Az except rész több felhasználási lehet séget is ad: Most már biztosak lehetünk benne. hogy az alblak feliratának megváltoztatása (memóriatisztogatás) minden esetben megtörténik. c: Integer.Caption := ’Szia’.

Assign(F) parancsot 20. Ennek az alap kulcsszava a File. end. sor: String. melyen helyezzünk el egy Button és egy Memo komponenst. CloseFile(fajl). Általában legjobb az ismeretlen kivételeket nem kezelni.1.sor).Lines.Create(’Nem lehet konvertálni!’). Ha felhasználjuk az el z fejezetben szerzett ismereteinket. M veletek fájlokkal A fájlok támogatását a Delphiben három pontba lehet szétosztani: • az Object Pascal-ból ered fájltámogatásra. Az sem jó ötlet. ha a kivételt kezeljük pl. hogy a Delphi-ben az eredeti parancsok máshol vannak használva (pl. Ez csak a Delphi Professional változatától érhet foglalkozni ebben a fejezetben. Tehát a kivételt vagy kezeljük. Edit.txt’).Button1Click(Sender: TObject). Ennek az oka az. Close (fájl bezárása) parancsokat. Ha a kivételt kezeljük. mivel ebben az esetben a felhasználó kétszer lesz figyelmeztetve: egyszer a saját MessageBox-unkkal. vagy figyelmen kívül hagyjuk.kezelésénél azonban legyünk maximálisan óvatosak. egy MessageBox-al. Pl. a Text több komponens tulajdonsága. de a System modullal lehet csak használhatjuk. end.TXT fájl tartalmát beolvassa a program a Memo komponensbe. olvasásánál kelezkez hibákat kezelni. Fájltámogatás az Object Pascal-ban 150 . • a vizuális komponenskönyvtár fájltámogatása. így a Delphi-re hagyni. 045 20. begin AssignFile(fajl. A gomb megnyomásakor az aktuális könyvtárban található DATA. Memo1. while not Eof(fajl) do begin ReadLn(fajl. Assign (fájl hozzárendelése). Hozzunk létre egy ablakot (form). pl. var fajl: TextFile. Memo). hogy a Pascal-ból megszoktuk a Text (szöveg fájl típusa). A fájlokkal való munkát az Object Pascalban egy példa segítségével említjük meg. Reset(fajl). hogyan tudjuk a fájl megnyitásánál. magunk is rájöhetünk. lehet ségünk van például egy új kivétel meghívására megadott hibaszöveggel: raise EConvertError. írásánál.’data. el. az Assign(F) helyett a System. elmenteni (pl. így a standard kezelése következik be. egyszer pedig a Delhi MessageBox-ával. Az eredeti parancsszavak is a Delphiben továbbra is megmaradtak. 151 ket használni.Add(sor). LoadFromFile. ezzel nem fogunk procedure TForm1. majd újból el hívjuk. AssignFile és CloseFile parancsokkal vannak helyettesítve. Lehet. amelyben metódusok segítségével lehet adatokat beolvasni ill. Ezek a Delphi-ben TextFile. SaveToFile metódusok) • fájltámogatás adatbázis formátumokhoz.

Ezek a metódusok elérhet k pl. WriteLn(fájl. end. file of Integer. ReadLn(fájl. A legismertebb metódusok a LoadFromFile és a SaveToFile. Fájlokkal kapcsolatos leggyakrabban használt parancsok: file of parancssor beírásával. 2-harmadi adat elé. Write(fájl. Hibák a fájlokkal való munka során A Delphi bármilyen I/O hiba esetében EInOutError kivételt generál. hozzárendelni a küls fájl a változónkhoz. akkor használhatjuk a <tipus> formát a deklaráláshoz. a fájl végér l akarunk olvasni (eof) 153 20. szöveg) – sor írása szöveges (txt) fájlba. hanem helyette egy rövid. Seek(fájl. pozíció) – a mutató beállítása a megadott helyre a típusos fájlban. Láthatjuk. szöveg) – sor olvasása szöveges (txt) fájlból. 046 • • • • • • • • AssignFile(fájl. bezárni az állományt.LoadFromFile(’data. melyek adatokat beolvasnak (megjelenítenek) ill. nem szöveges fájlal szeretnénk dolgozni. Procedure TForm1. ahogy további osztályokban is. TBitmap osztályokban. 20. változó) – egy adat olvasása fájlból. Reset(fájl) – fájl megnyitása olvasásra. hanem valamilyen típusos állománnyal.Button1Click(Sender: TObject). TPicture. Fájltámogatás a Delphi-ben Sokszor nem akarunk foglalkozni a „hosszadalmas” Object Pascalból ered fájltámogatással. melynek értéke a következ k lehetnek: • CloseFile(fájl) – állomány bezárása. hogy ez így mennyivel egyszer bb.Ha más.2. a TString. begin Memo1. A hiba pontosabb definíciója az ErrorCode lokális változóban szerepel. Rewrite(fájl) – fájl megnyitása írásra.). Read(fájl. fizikainév) – a fájl változóhoz egy fizikai fájl hozzákapcsolása a merevlemezen. Változtassuk meg az el z példánkat a LoadFromFile metódus használatával. Nem kell deklarálnunk változókat. változó) – egy adat írása fájlba. pl.txt’).Lines. stb.3. egyszer megoldást szeretnénk használni. elmentenek a fájlba egyetlen 2 3 4 5 100 152 . 1-második adat elé. Erre is van lehet ségünk a Delphiben. megnyitni. ErrorCode Jelentése File not found Invalid file name Too many open files Access denied Disk read error – ha pl. A pozíció értéke 0-tól számolódik (0-els adat elé állítja be a mutatót.

A következ példa bemutatja a kivételek kezelését a fájl fájlból való olvasáskor is. 048 Procedure TForm1.Lines. amely írásra volt megnyitva 105 File not open for output – ha olyan fájlba akarunk írni.101 102 103 Disk write error – ha pl.Message). melyben bármilyen nem kezelt kivétel esetében a program leáll. try Reset(fajl).AppException(Sender: TObject. 154 beolvasásakor a Memo komponensbe. Append segítségével Memo1. hogy egy programban több helyen is dolgozunk az állományokkal. teli lemezre akarunk írni File not assigned – ha pl.sor). except on E:EInOutError do case E. melybe beírjuk a kivételeket kezel programrészt „egyszer s Procedure TForm1. end. Ezt egy egyszer példán szemléltetjük. end.Add(sor).OnException := AppException. Képzeljük el. amely nem volt megnyitva Reset.txt’). finally CloseFile(fajl). Procedure TForm1. nem számot karunk beolvasni szöveges fájlból szám típusú változóba Ebben a példában kezeltük a hibákat a fájl megnyitásánál és a A kivételek standard kezelése természetesen képes a kivételt kezelni. end.ErrorCode of 2: ShowMessage(’Nincs meg a fájl!’). ha azt nem tesszük meg a programunkban. Rewrite. 103: ShowMessage(’A fájl nem volt megnyitva!’). else ShowMessage(’Hiba: ’ + E. mivel használhatjuk a TApplication objektum OnException eseményét. var fajl: TextFile. E: Exception).Button1Click(Sender: TObject). 047 mindenkorra”. 104 File not open for input – ha olyan fájlból akarunk olvasni. begin 155 . nem volt meghívva az Assign File not open – ha pl. end. olyan fájlból akarunk dolgozni. sor: String. try while not Eof(fajl) do begin ReadLn(fajl. end. Szerencsére ez fölösleges is. amely olvasásra volt megnyitva 106 Invalid numeric format – ha pl. end. begin AssignFile(fajl. Leírni mindenhova ugyanazt a programrészt a kivételek kezelésére unalmas és hosszadalmas lehet. begin Application.FormCreate(Sender: TObject).’data.

Ezek a komponensek nem dolgoznak közvetlenül a fájlokkal. nyomtatnak. mappákkal való munkát segítik. melyet visszaad. jól használni. könyvtárokkal. mentenek el. találhatók a SysUtils modulban. Sok alkalmazásnak hasonló igénye van: fájlokat megnyitnak meg. megnyitásnál. stb. ha a megadott nev állomány létezik. • DirectoryListBox – szintén egy speciális ListBox. de lehet ket 20. // hibaüzenet // programleállás Miel tt belekezdenénk a standard dialógusablakok ismertetésébe. end. háttér) választanak. keresnek valamilyen kifejezést. stb.). • ChangeFileExt(név. igy könnyen tudja kezelni. stb. • ExtractFileName(teljes_név) – A teljes útvonallal együtti fájlnévb l kiszedi csak a fájl nevét. egy kicsit régebbiek. 21. kiterjesztés) – megváltoztatja a fájl kiterjesztését és visszaadja az fájl új nevét. Ezért léteznek úgynevezett „common dialog”-usok. További fájlokkal és mappákkal kapcsolatos függvények további metódusait. tehét el re definiált standard dialógusablakok. Ezek a Win 3. színt (bet . Az alábbi komponensek igaz. hanem csak a neveiket jelenítik meg. ha a törlés sikeres volt. melyek az állományokkal. További fájlokkal kapcsolatos parancsok Csak röviden megemlítjük a Delphi melyekkel a fájlok és a mappák összefüggnek: • FileExist(név) – értéke true. Application. választási lehet séget adnak. • RenameFile(réginév.Terminate. nézzünk meg még néhány komponenst. amely az adott meghajtón lev szolgál. mint sajátot készíteni. • ExtractFileExt(név) – Az adott fájl kiterjesztését adja vissza.4. • DeleteFile(név) – kitörli a megadott nev állományt és true értéket ad vissza. • FilterComboBox – a fájlok maszkjainak megjelenítésére szolgáló legördöl lista.ShowException(E). újnév) – átnevezi a fájlt és true értéket ad vissza. 156 157 . amely könyvtárszerkezet megjelenítésére számítógépr l el rhet meghajtók listáját tartalmazza. • DriveComboBox – egy speciális legördül lista. ha az átnevezés sikeres volt. El nyei: • ugyanaz az ablak jelenik meg a felhasználónak minden alkalmazásnál (pl. Standard dialógusablakok • a programozónak is egyszer bb ezeket használnia. mentésnél.1 kategória alatt találhatók: • FileListBox – ez egy speciális ListBox az aktuális könyvtárban található összes fájl kírására.Application.

amelyb l nem lehet átkapcsolni az alkalmazás másik ablakába. amely futási id ben nem látszódik. amely több true/false altulajdonságból áll. dialógusablak néhány funkcióját nem is használjuk vagy hiányzik valamilyen funkció. nem nem PrinterSetupDialog igen A nyomtató (nyomtatás) beállítására szolgáló dialógusablak. ahogy kinéznek. de a dialógusablakok angolul lesznek. úgy kell használnunk ket. Ez a metódus true értéket ad vissza. • ezek standard Windows dialógusablakok. SaveDialog igen Az állomány megadása mentéshez. PrintDialog igen A nyomtatandó dokumentum nyomtatóra való küldéséhez szolgáló dialógusablak. Megjegyzés: A modális ablak olyan ablak. 158 159 . Szövegben egy kifejezés keresésére és kicserélésére szolgáló dialógusablak. FontDialog igen A bet típus kiválasztására szolgáló dialógusablak. ha a felhasználó az OK gombbal zárta be. még ha a ColorDialog igen Szín kiválasztására szolgáló dialógusablak. Szövegben egy kifejezés keresésére szolgáló dialógusablak. csak a modális ablak bezárása után. A PrinterSetupDialog kivételével mindegyik dialógusnak van Options tulajdonsága. A dialógusablakok tervezési id ben egy kis négyzettel vannak szemléltetve. magyar nyelv programunkat angol Windows alatt futtatjuk. ezért ha pl. OpenPictureDialog igen Az állomány kiválasztása megnyitáshoz. tartalmazza a kiválasztott kép el nézetét is. keveredik a két nyelv – a programunk magyar marad. A dialógusablakot az Execute metódussal lehet megnyitni. tartalmazza a kép el nézetét is. FindDialog A Delphi-ben a következ dialógusablakokkal találkozhatunk: ReplaceDialog Dialógusablak neve OpenDialog Modális? igen Jelentése Az állomány kiválasztása megnyitáshoz.Hátrányai: • egy bizonyos határokon túl nem lehet ket változtatni. SavePictureDialog igen Az állomány megadása mentéshez. false értéket pedig ha a felhazsnáló a dialógusablakból a Cancel gombbal vagy a jobb fels sarokban lev X-szel lépett ki.

A kiválasztott fájlokat a TString típusú Files tulajdonságban kapjuk vissza. run-time tulajdonság. Események: A legfontosabb események az OnShow és az OnClose. 160 161 . OnSelectionChange. SaveDialog Ez a két dialógusablak annyira hasonlít egymásra. ha a felhasználó nem ad meg. Tulajdonságok: • DefaultExt – kiterjesztés. o ofHideReadOnly – nem jelenik meg a „megnyitás csak olvasásra” lehet ség a dialógusablakon. Title – a dialógusablak felirata (Caption helyett). *. Továbbá használhatjuk még az OnFolderChange. OpenDialog. Ha nincs súgónk hozzá. amely a kiválasztott állomány (állományok) teljes nevét (neveit) tartalmazza útvonallal együtt. melyek a dialógusablak megnyitásakor ill. o ofOldStyleDialog – „régi stílusú” dialógusablakot jelenít meg. amely automatikusan hozzá lesz téve a fájl nevéhez. Hasznos esemény lehet még az OnCanClose.doc. *. dialógusablak megnyitásakor.1. pl.). fájlok kijelölését ill. akkor ezt ajánlott letiltani. ha a felhasználó megvéltoztatja a mappát. melyekkel a dialógusablak kölalakját lehet módosítani: o ofOverwritePrompt – megjelenik a figyelmeztetés. melyek akkor következnek be.21. stb. • FileName – a kiválasztott állomány teljes nevét (útvonallal együtt) tartalmazza. o ofShowHelp – megjelenik a „Help” nyomógomb. Options – beállítási lehet ségek (logikai értékek). melyben a dialógusablak bezárását lehet megakadályozni. • Filter – az állományok sz rése oldható meg a segítségével (megadott maszk alapján. o ofAllowMultiSelect – lehet séget ad több állomány kiválasztására egyszerre. hogy egyszerre vesszük át ket. • FilterIndex – melyik legyen a „default” maszk a • o ofEnableSizing – lehet séget ad a felhasználónak változattni a dialógusablak méretét. Lehet megadni is mint bemeneti érték. • • InitialDir – kezdeti könyvtár (mappa). ha a felhasználó létez fájlt akar felülírni. A program tervezési fázisában ez a tulajdonság a Filter Editor segítségével adható meg. Metódusok: Legfontosabb metódus az Execute. mellyel a dialógusablakot megjelentetjük. bezárásakor következnek be. a fájlok maszkját (sz r ). OnTypeChange eseményeket is.txt. • Files – read-only.

wmf.Caption := OpenDialog1. fdPrinter.emf típusú. . ha a képet felismeri a TPicture osztály.3. … 21. de a dialógusablak része a kép el nézetét mutató felület is. fdBoth) • Font – bemeneti és kimeneti információk a bet típusról (bemeneti lehet pl.Options then ShowMessage(’Csak olvasásra megnyitott.Filename.Példa: a kiválasztott állomány nevét a Form1 feliratába szeretnénk kiírni. OpenPictureDialog. if ofReadOnly in OpenDialog1.’).ico.Execute then begin Form1. SavePictureDialog Hasonló az el z khöz. FontDialog Ez a dialógusablak biztosan mindenki számára ismer s a szövegszerkeszt programokból. . Ezt az el nézetet azonban csak akkor Szükséges 163 hozzá még engedélyezni a . majd megállapítani. 162 21. . láthatjuk. … if OpenDialog1. az aktuális bet típus). end. tehát ha a kép .bmp.2. MaxFontSize – meg lehet segítségükkel határozni milyen értékek között választhat a felhasználó bet méretet. Tulajdonságai: • Device – meghatározza melyik berendezés számára van a bet típus (fdScreen. hogy az állomány csak olvasásra lett-e megnyitva. • MinFontSize.

melyben megadható és Metódusok: Legfontosabb metódusa az Execute.4. Ha értéknek a 0-t hagyjuk. o fdForceFontExist – ajánlott értékét true-ra állítani. A definiáláshoz klasszikus String List Editor-t használhatunk.Execute then Memo1. 21.Font. bet típusokat. Események: Az el z dialógusokhoz képest van egy új eseménye. melyb l kiolvasható a konkrét szín.Font := FontDialog1. a Symbols. amely akkor következik be. o fdEffects – a bet stílusok beállításának – megjeleníti az „Alkalmaz” Nézzünk egy konkrét példát a FontDialog használatára. begin if FontDialog1. aláhúzott.Button1Click(Sender: TObject). procedure TForm1. end. stb.) o fdTrueTypeOnly – csak a True-Type bet típusokat jeleníti meg. A CustomColor tulajdonság segítségével definiálhatunk 16 felhasználói színt.fdLimitSize-ot az Options tulajdonságban. Wingdings. akkor a választás nem lesz korlátozva. különben a felhasználó megadhat olyan nev bet típust is. ha a felhasználó megnyomja az „Alkalmaz” nyomógombot. A példánkban a Memo komponens bet típusát szeretnénk beállítani. az OnApply. ColorDialog Legfontosabb tulajdonsága a Color. o fdApplyButton nyomógombot. • Options – különféle beállítási lehet ségek: o fdAnsiOnly – csak szöveges bet típusokat jelenít meg. lehet ségét jeleníti meg a dialógusablakban (pl. tehát kisz ri pl. stb. melyben a formátum a következ : 164 165 . amely nem létezik.

az csak annyi. Az Options tulajdonság altulajdonságai: • cdFullOpen – az egész dialógusablak megnyitását szükséges megtennünk. BB. PrintDialog A PrinterSetupDialog a nyomtató beállításait megjelenító dialógusablakot nyit meg. hogy megnyitjuk az Execute metódussal. MaxPage). PrinterSetupDialog. A PrintDialog komponensnek már van néhány paramétere. CC pedig a szín egyes összetev it jelölik hexadecimális számrendszerbe. 21. Amit ezzel a dialógusablakkal kapcsolatban 166 167 .ColorX=AABBCC. ahol X helyére A. Ennek nincs semmi különösebb eseménye vagy tulajdonsága.. melyek megadhatják például: a másolatok számát (Copies tulajdonság). A dialógusablak formája szorosan összefügg a beinstallált nyomtató típusával. az AA.P bet ket írhatunk. eredményezi (tehát a felhasználói színeket is). Be lehet állítani kezdeti értékeket vagy ki lehet olvasni beállíott értékeket. a leválogatás módját (Collage tulajdonság). Szintén be lehet határolni (korlátozni) a kinyomtatandó oldalak számát (MinPage.5. • cdPreventFullOpen – megakadájozza (tiltja) a felhasználói színek részének megnyitását a dialógusablakban.

• Ha frWholeWord – csak egész szavak legyenek keresve. DisableMatchCase). tehát a képerny n maradhatnak többszöri keresés / csere után is. amely akkor következik be. amelyet keresnünk kell a FindText tulajdonságban kapjuk meg. hogy az alapértelmezett = lefelé. ezek valamelyikét egyáltalán nem szeretnénk a felhasználónak megjeleníteni a dialógusablakban. 21. • frMatchCase – meg legyenek-e különböztetve a kis és nagybet k.6. Van lehet ség arra is. magát a keresést.). FindDialog. amely bezárja a dialógusablakot. stb. true értéke azt jelenti. 168 169 . cserét sajnos nekünk kell teljes mértékben beprogramoznunk. hogy ezek a lehet ségek a felhasználónak megjelenjenek. Ehhez a Disable szóval kezd d használhatjuk (pl. amely a „Replace” nyomógomb megnyomásakor következik be. használjuk a Hide-al kezd d lehet ségeket (pl. frHideMatchCase. Az Execute metóduson kívül rendelkezésre áll még az CloseDialog metódus is. de le legyenek tiltva. A tulajdonsága is. Az Options tulajdonság lehet ségei: • frDown – keresés iránya. A ReplaceDialog még rendelkezik egy OnReplace eseménnyel is. ReplaceDialog A FineDialog és ReplaceDialog ablakoknál szintén csak a dialógusablakokról van szó. A szöveget. ReplaceDialog-nak van még egy ReplaceText Metódusok: Ezek a dialógusablakok nem modálisak. amely kizárólag az adatok bevitelére szolgál. lehet ségeket Események: A FindDialog OnFind eseménnyel rendelkezik. ha a felhasználó a „Find Next” nyomógombra kattintott.

Ahhoz. 2 x Button (Form1-en) és Label. Unit2. A segédablak modálisan lesz megjelenítve. Alkalmazás két ablakkal (modális ablak) Ez az alkalmazás két ablakot fog tartalmazni: egy f ablakot és egy segédablakot. Ezek az 22. tehát nem lehet majd bel le átkapcsolni az alakalmazás másik (f ) ablakába. a második ablakot külön be kell raknunk az alkalmazásba.Delphi for Win32 menüpontot. Graphics. amelyek segítségével például valamilyen adatokat viszünk be a programba. Controls.1. stb. Classes. hogy az egyik modulból (unitból) tudjuk használni a másikat (tehát hogy az egyik modulból elérhet k legyenek a másikban lev komponensek). stb.). Dialogs. további ablakai (pl. egy kicsit változtatnunk kell a forráskódokon (Unit1. Szükségünk lehet további ablakokra.pas. Edit. Az alkalmazás létrehozása után (File – New – VCL Form Applications . 2 x Button 170 171 . Forms. A második modulban keressük meg az implementation részt és ez alá írjuk be: uses Unit1. amikor már nem elég egy ablak az alkalmazásnak. hogy mindkét modulban fogunk tudni dolgozni a másik modulban definiált komponensekkel. Ehhez kapcsoljuk ki a Form2 automatikus létrehozását a program indításakor a következ képpen: nyissuk meg a Project – Options menüpontot.Delphi for Win32) az alkalmazásunknak egy ablaka a következ komponenseket fogjuk Ezzel bebiztosítottuk. Mivel a mi alkalmazásunk két ablakot fog tartalmazni. Unit2. beállításokat állítunk be.pas) uses részét egészítsük ki a Unit2-vel: uses Windows. Majd a Form2-t az Auto-create forms listából helyezzük át az Available forms listába. beállítások megadására. Tehát az alkalmazásnak lesze egy f ablakok két féle módon jeleníthet k meg: • modális ablakként: az így megjelenített ablakból nem tudunk átkapcsolni az alkalmazás másik ablakába. amikor szükségünk lesz rá. SysUtils. amely segítségével adatot viszünk be a programba. hogyan lehet a program futása alatt létrehozni az ablakot (Form2). 050 Alkalmazásunkban (Form2-n). Az alkalmazásba bekerül a Form2 ablak és a hozzá tartozó program modul is – Unit2. A form létrehozását a programban így akkor hajthatjuk végre. Oktatási okokból megmutatjuk azt is.pas) a következ képpen: 1. Ehhez 22. Messages. ablakja és lehetnek válasszuk a File – New – Form . válasszuk ki itt a Forms részt. Az els modul (Unit1. Ha nincs kiválasztva. Több ablak (form) használata Az alkalmazások készítésénél egy id után eljön az a pillanat. bevitelre. Variants. • nem modális ablakként: az ilyen ablakból át lehet kapcsolni az alkalmazás másik ablakába. 2.(Form1) van.pas. Ez a nyomógomb megnyomásakor következik be: használni: Label.

Create(Self). begin Form2 := TForm2. procedure TForm1. unit Unit1.Create(Self). end. end. end. end. begin ModalResult := mrOk.Text.Button1Click(Sender: TObject).pas forráskódját: 172 173 . var Form2: TForm2. A Unit2.ShowModal = mrOk then Label1.Button1Click(Sender: TObject). end. az alkalmazásból át lehet kapcsolni másik alkalmazásba. end.pas forráskódja pedig így néz ki: unit Unit2. begin ModalResult := mrCancel. amíg a modális ablakot nem zárjuk be. Észrevehetjük.Text. finally Form2.Free. de ugyanennek az alkalmazásnak a f ablakába nem tudunk visszamenni.Free. … procedure TForm1.Caption := Form2.Button1Click(Sender: TObject).Edit1. begin Close. begin Form2 := TForm2. try if Form2. var Form2: TForm2. end.Edit1.ShowModal = mrOk then Label1.Caption := Form2. … procedure TForm2.Button2Click(Sender: TObject).procedure TForm1. end.Button2Click(Sender: TObject). hogy az alkalmazás futása alatt ha megnyitjuk a második form-ot. Nézzük meg el ször a Unit1. procedure TForm2. try if Form2. finally Form2.

Button1Click(Sender: TObject). hogy az már létezik-e.Create(Self). és ha igen. 174 . melyekb l át lehet kapcsolni másik ablakokba (nem modális ablak) Készítsünk el az el z anniy külömbséggel. fel kell szabadítanunk. Form2.Button1Click(Sender: TObject).Show. Form2: TForm2. amíg a modális ablakot nem zárjuk be. akkor csak aktiválnunk kell. Míg a modális ablakot csak az ablak bezárásával hagyhatjuk el. Ha azt akarjuk. hogy a ShowModal metódus meghívásánál a program „várakozik“ addig. Most megváltoztatjuk a második ablak megnyitására szolgáló procedure TForm1. eljárást: A megnyitott modális ablakot a ModalResult tulajdonság beállításával zárjuk be. Mindkét tevékenységet a második ablakban (Form2) fogjuk végrehajtani. A másik „problémánk“ az. hogy az ablak létezését bármikor tesztelhessük unit Unit1.2. Ahhoz. Nézzük most meg a két forráskódot. nem valamelyik eljárásban. 051 Az eltérés az el z példától a modális és nem modális ablakok közötti különbségekb l adódik. implementation {$R *. Ezért miel tt létrehoznánk a segédablakot tesztelnünk kell. mert a felhasználó bel le átléphet az alkalmazás ablakába és megpróbálhatja újra létrehozni a segédablakot annak ellenére. end. 22. el ször a Unit1-et: a felhasználó a segédablak bezárása nélkül. … var Form1: TForm1. hogy a Form2 a bezárás után a memóriában ne foglalja a helyet. Ne felejsük el. Ezt tehát a program elején kell deklarálnunk. A Form2 továbbra is a memóriában van és bármikor el hívhatjuk. 175 szükségünk lesz egy globális változóra (Form2). alkalmazáshoz hasonló alkalmazást a segédablak nem modálisan lesz átkapcsolhat a f ablakba Megoldásra maradt még két problémánk: hogyan zárjuk be a második ablakot és hogyan biztosítsuk be a második ablakban megadott érték átadását. A beállított értéket megkapjuk a Form2. hogy az már létezik. begin if Form2 = nil then Form2 := TForm2.end. tehét hogy megjelenítve. hogy a Close metódus a második ablaknál (Form2) csak az ablak elrejtését eredményezi. a Show metódus meghívásánál a program fut tovább. nem a felszabadítását a memóriából. míg a nem modális ablak létrehozásánál.dfm} procedure TForm1. Ablakok. a nem modális ablaknál ez nem igaz. Az ablakot ezért nem hozhatjuk létre ugyanúgy mint az el z f példában: els sorban azért nem.ShowModal függvény hívásánál visszatérési értékként.

Create(Self).Text. következ könyv adatainak megtekintésére. A felszabadításkor bekövetkezik az OnDestroy esemény. end. ami az ablak felszabadítását eredményezi a memóriából. end. 22. új könyv hozzáadására és könyv törlésére. A második form nyomógombjainak OnClick eseményeibe a Close metódust használtuk. Az új könyv hozzáadása egy másik (modálisan megjelenített) form segítségével történjen. Ennek az eseménynek a kezelésében beállítottuk az Action paramétert caFree-re. Majd nézzük meg a Unit2 modult is: melynek kezelésében beállítottuk a Form2 mutató értékét nil-re. Form2. begin Form1. begin Close. Az ablak bezárásánál bekövetkezik az OnClose esemény. procedure TForm2. end.3. A program kilépéskor egy küls fájlba mentse az adatokat. procedure TForm1. begin Action := caFree. end.Button1Click(Sender: TObject). A következ könyvek nyilvántartására fog szolgálni. end.Button2Click(Sender: TObject). end.Label1. 082 177 . … procedure TForm2.FormDestroy(Sender: TObject).begin if Form2 = nil then Form2 := TForm2. mellyel bezárjuk az ablakot. procedure TForm2.Caption := Edit1. Az alkalmazásunk tartalmazzon négy nyomógombot: el z könyv adatainak megtekintésére. Close. amikor megpróbáljuk unit Unit2. procedure TForm2.Show. end. A Form2 értékét az els unitban teszteljük. melyeket az alkalmazás indításakor automatikusan olvasson be. var Action: TCloseAction).Button2Click(Sender: TObject). begin Close. egyszer program meg Minden könyvr l szeretnnénk jegyezni a szerz t. könyv címét. Könyvnyilvántartó program Az alábbi példán keresztül szemléltetjük a két ablakkal való munkát és a fájlokkal való munkát. 176 létrehozni a második ablakot. end. begin Form2 := nil.FormClose(Sender: TObject. oldalainak számát és a könyv árát.

Unit2. Tehát most nem fogjuk kikapcsolni a második form létrehozását a projekt beállításaiban.ennek a programban a TKonyv nevet adtuk. 179 . file deklaralasa } a: array[1. A második formot most nem fogjuk mi létrehozni. { n . olvassuk be. ára). { akt . megjelenitett konyv } akt: integer. f: file of TKonyv. begin n:=0. 178 form segítségével fog … procedure TForm1.dfm} type { TKonyv tipus definialasa } TKonyv = record Szerzo. Az új könyv hozzáadása a következ történni: implementation {$R *. hanem hagyjuk. Ar: integer.konyvek szama a tombben } n: integer. var { tomb. Cim: string[255]. Nézzük el ször is az els ablakhoz tartozó programkódot: … uses Windows. hogy a Delphi automatikusan létrehozza a program indításakor. end. Oldalak. ezért definiálunk egy record típust.aktualis. Mivel minden egyes könyvr l meg kell jegyeznünk több adatot is (szerz .10000] of TKonyv. … . oldalak száma.FormCreate(Sender: TObject). cím. A könyveket egy ilyen típusú tömbben tároljuk és egy ilyen típusú állományba mentjük el ill. Messages..

begin { ugras az elozore } if akt>1 then begin dec(akt).0).Caption := a[akt]. end. a[i+1].Caption := a[akt]. a[i+1]. var i: integer. Read(f. 181 .'konyvek.a[n]). end else begin akt := 0.Cim := Form2. Label8.Text) do begin a[i+1] := a[i].Oldalak := StrToInt(Form2.Caption := IntToStr(a[akt].Ar). end.Oldalak).Szerzo. Button2. begin { uj konyv hozzaadasa Form2 megjelenitesevel } if Form2. Label6.Cim>Form2.Button2Click(Sender: TObject).' + chr(10) + chr(13) + 'A file nem letezik?'. end.ShowModal = mrOk then begin { a konyv helyenek megkeresese ugy. inc(n). Label5.Edit2.Cim.dat'). except MessageDlg('Hiba az adatok megnyitasakor. ha letezik } if n>0 then begin akt := 1.Szerzo. try Reset(f).Button1Click(Sender: TObject). procedure TForm1.Text). end.Text.[mbOK]. a[i+1].Caption := ''. end.Click.Cim.Button3Click(Sender: TObject). procedure TForm1. dec(i). Label5.Caption := IntToStr(a[akt].Caption := a[akt]. { a beirt konyv megjelenitese } akt := i.Szerzo. procedure TForm1.Oldalak). try while not eof(f) do begin inc(n). begin { ugras a kovetkezore } if akt<n then begin inc(akt). Label7. Label7.Caption := IntToStr(a[akt]. { elso konyv megjelenitese. Label7. end. a[i+1].{ adatok beolvasasa kulso fajlbol } AssignFile(f.Szerzo := Form2.Edit4.Caption := ''.Text.Edit1. 180 Label7.Ar := StrToInt(Form2.Ar). Label6. end. end.Caption := a[1]. Label8. Label8.Edit3.Ar).Caption := a[1].Text). Label6. end.Caption := ''. end. finally CloseFile(f).Caption := ''. end. while (i>0) and (a[i].Caption := IntToStr(a[1].Edit2. Label8.Oldalak). Label5. Label5.Caption := IntToStr(a[akt].Caption := a[akt].Caption := IntToStr(a[1]. end. hogy a konyvek cimei ABC szerint legyenek rendezve } i := n. mtWarning. Label6.Cim.

Label5. var i: integer.Click. end. end else if n>0 then begin akt := n-1.Top + 30.Text := ''. 182 var end.Button2Click(Sender: TObject). end else begin akt := 0.Text := ''. end.FormClose(Sender: TObject.procedure TForm1. end. Action: TCloseAction).dfm} uses Unit1. try for i:=1 to n do Write(f. Button2.FormShow(Sender: TObject).0). procedure TForm2. end.Text := ''. end.Caption := ''. begin { kezdeti beallitasok } Top := Form1. begin { a torolt konyv utani konyvek eggyel elobbre helyezese } for i := akt to n-1 do a[i] := a[i+1]. procedure TForm2. end. dec(n). Label6. procedure TForm2. procedure TForm1.Left + 30. { kovetkezo.Click.[mbOK].Button4Click(Sender: TObject). Ez azért van. Label7. A második ablaknál a Form OnShow eseményében állítjuk be a kezdeti beállításokat. Button2. end. Left := Form1.Text := ''. finally CloseFile(f). except MessageDlg('Hiba az adatok mentésénél!'.SetFocus. Edit4.a[i]).Caption := ''. end.Caption := ''. ha van ilyen } if akt<=n then begin dec(akt).Caption := ''. begin { adatok mentese fajlba } try Rewrite(f). Label8. Edit1. Edit3. begin ModalResult := mrOk. var i: integer.Button1Click(Sender: TObject). begin ModalResult := mrCancel. mtError. end. Edit1. mert az OnCreate esemény csak a 183 . Majd a második ablakhoz tartozó forráskódot: … implementation {$R *. Edit2. vagy elozo konyv megjelenitese.

23.. menteni menüvel. SDI rövidítésekkel. • MDI – Multiple Document Interface: olyan alkalmazás. Ne felejtsük el a Unit1 modul Uses részét kiegészíteni a Unit2 23. A form-ra helyezzünk el egy Button és egy OpenPictureDialog komponenst. egy Button komponenst (Form1-en). most kialakítunk kézileg egy MDI alkalmazást. Így a modális ablak megnyitásakor. . táblázat.Delphi for Win32). mely több dokumentummal tud egyszerre dolgozni (MDI) Biztos mindenki ismer olyan alkalmazást. Ha ezt nem tennénk meg. hogy megértsük és gyakoroljuk az ilyen alkalmazás létrehozását. amely egyszerre több dokumentum (objektum) megnyitását teszi lehet vé. Hozzunk létre egy hagyományos alkalmazást (File – New – VCL Forms Application . létrejön stb. akarjuk.pas: 184 185 . Most szüntessük meg a Form2 automatikus létrehozását az alkalmazás indulásakor (Project – Options – . az induláskor egy nem szép. hogyan hozhatunk létre egy ilyen alkalmazást. Ehhez rakjunk be az alkalmazásunkba egy új form-ot (File – New – Form Delphi for Win32). programot modullal. 052 Most létre kell hoznunk egy gyermek (child) form-ot. melyben egyszerre több kép lehet nyitva. csak nem látható a képerny n.) lehet megnyitva. ahogy azt az el z fejezetekben is már megtettük. MDI alkalmazást legegyszer bben létrehozhatunk a File – New – Others menüpontból ahová a projektünket váza a Delphi Projects – MDI Végül Application az MDI Ezzel segítségével. Továbbá be kell biztosítanunk a Form2 felszabadítását a memóriából a bezáráskor (lásd a program OnClose eseményének kezelését). Ilyen például a Windowsban található Jegyzettömb. melyben egyszerre csak egy dokumentumot (objektumot) lehet beolvasni. Ezért szükséges például az Edit komponensekbe beírt szöveg törlése az ablak megjelenítésekor (OnShow eseményben). Ahhoz.1. Erre tipikus példa az MS Word. majd bezárásakor a Form2 továbbra is létezik. a módszerrel pár perc alatt létrehozhatunk MDI alkalmazást. melyben egyszerre több dokumentum (kép.). Alkalmazás. Egy képnézeget fogunk létrehozni. Ezek jelentése: • SDI – Single Document Interface: olyan alkalmazás. fájl.program indításánál következik be. ugyanis itt hozza létre mindkét formot (mivel hagytuk az „Auto-create forms” beállításban a Form2-t is).. Az OK-ra kattintás után meg kell adnunk a egy mappát. Nézzük hogy néz ki a Unit1. Ilyen például az MS Word. Ebben a fejezetben megmutatjuk. Erre helyezzünk el egy Image komponenst. együtt.. SDI. alkalmazásunk dialógusokkal.. egy OpenPictureDialog komponenst (Form1en) és egy Image komponenst (Form2-n). MDI alkalmazások A programozás során találkozhatunk az MDI. üres ablak lenne látható. Az alkalmazásban két form-ot fogunk használni.

maximalizálás. end.unit Unit1. Ha megpróbáljuk az alkalmazásunkat futtatni. a szül ablak második sorában megjelennek ablakán kívülre ablak feliratát.FormCreate(Sender: TObject). fsStayOnTop (olyan gyermek 187 . procedure TForm2. Image1. és a A f ablaknál ablaknál beállítjuk: beállítjuk: FormStyle := fsMDIForm. A második ablakot nem lehet a szül több képet is megnyithatunk. bezárás). var Action: TCloseAction)..LoadFromFile( OpenPictureDialog1. end.Picture. Unit2.Button1Click(Sender: TObject).pas-t is: az utódhoz tartozó rendszergombok (minimalizálás.FileName). A FormStyle további lehetséges értékei: fsNormal (klasszikus SDI alkalmazás. … procedure TForm1. procedure TForm1. amelyet eddig is használtunk). begin if OpenPictureDialog1. hogy egy kicsit másképp m ködik. end. begin FormStyle := fsMDIChild. interface uses …. A MainMenu komponens elhelyezése után már ha kinagyítjuk az utód ablakát. Egyszerre Majd nézzük meg a Unit2. end.Create(Self) do begin Caption := OpenPictureDialog1. end.Execute then with TForm2.FormCreate(Sender: TObject). Figyeljük meg a szül valamelyik utód ablakot maximalizáljuk. Semmi mást nem kell beállítanunk. minimalizálásnál csak a szül ablak aljára teszi le. menüt sem kell létrehoznunk.FileName. begin FormStyle := fsMDIForm. end.Align := alClient. ha mozgatni. 186 Az alkalmazás létrehozásának egyik legfontosabb része a FormStyle tulajdonság beállítása. Image1. A második ablak (utód) maximalizálásával összefügg egy probléma: a maximalizálás után elfoglalja a szül ablak egész területét és utána már nincs rá módunk megváltoztatni az ablak méretét. begin Action := caFree. … procedure TForm2. Ezt egy kis trükkel fogjuk kijavítani: helyezzünk el a Form1 ablakon egy MainMenu komponenst. mint az eddig létrehozott alkalmazások. FormStyle := fsMDIChild.FormClose(Sender: TObject. unit Unit2. észrevehetjük. end.

CutToClipboard: a kijelölt szöveget a vágólapra helyezi át (kivágja az eredeti dokumentumból). illetve a Ctrl+X billenty zetkombinációkat.Create(Self) do felírással. hogy mindig a többi ablak el tt legyen).ablakokra.Create(Self) felírást használtuk. amely minden sor végén CR (Carriage Return – sor elejére) és LF (Line Feed – új sor) jeleket tartalmaz. A vágólap az egyik leggyakrabban használt eszköz az alkalmazások közti kommunikációra. hogy itt az ablak kialakítása után már nincs szükségünk az ablakra való hivatkozásra. CF_WAVE – hang WAV formátumban. bitképet. Ha a vágólapra elhelyezünk új adatot. Ha az általunk készített alkalmazásban szeretnénk használni a vágólapot. az el z bármilyen hosszú. melyeknél azt szeretnénk. A kép beolvasására és megjelenítésére használhattuk ennek a komponensnek a LoadFromFile metódusát. de különböz törl dik. míg itt megelégedtünk a with TForm2. 24. A Ctrl+X rövidítés hasonlóan m ködik mint a Ctrl+C annyi különbséggel. Ilyen formátum többféle lehet. 24. CF_PICTURE – TPicture típusú objektum. Az el z fejezetben a változó := TForm2. mint pl. elég megismerkednünk néhány alapfogalommal. A kép megjelenítésére az Image komponenst használtuk. a második a vágólap tartalmának beillesztésére a kijelölt helyre. stb. HTML kódot. ezek közül a leggyakrabban használtak: • CF_TEXT – egyszer szöveg. A vágólap használata a programozásban A legegyszer bb m veleteket a vágólappal elvégzhetjük az alábbi három metódus segítségével: • CopyToClipboard: a kijelölt szöveget a vágólapra másolja. Ctrl+V. Hasonló m veletek elérhet k az alkalmazás menüjén keresztül is a Szerkesztés – Másolás. Az adat természetesen lehet nem csak egyszer szöveget adattípusokat is. így a Create visszaadási értékét nem kell semmilyen változóban tárolnunk. A legtöbb felhasználó a vágólapot rutinosan használja. A helyezhetünk el. Ha a Windowsban az egyik alkalmazásból a másikba át szeretnénk rakni valamilyen szöveget vagy • 188 189 . A Windows vágólapja Biztos mindenki ismeri a Ctrl+C.1. leggyorsabban a vágólap segítségével tehetjük meg. Figyeljük meg. illetve Szerkesztés – Kivágás alatt. Az els a kijelölt szöveg (vagy más objektum) másolására szolgál a vágólapra. Szerkesztés – Beillesztés. Ennek oka. A vágólapon egyszerre egy adat lehet. CF_TIFF – TIFF formátumban lev kép. vágólapon táblázatot. hogyan alakítunk ki gyermek ablakokat. hogy a kijelölt részt kivágja a dokumentumból. képet (esetleg más objektumot). • • • • CF_BITMAP – kép bitmap formátumban. A szöveg végét NUL (Null Character) karakter jelzi. Az adatok típusát a vágólapon az adat formátumjának nevezzük.

melyek közül a legfontosabbak: • • AsText – a vágólap tartalmát repretentálja szövegként. azt a következ módon tehetjük meg: Clipboard. ezt Clipboard néven érhetjük el. A TClipboard osztálynak több tulajdonsága is van. amely az összes olyan formátumot tartalmazza. Vágólappal dolgozó szövegszerkeszt program 053 Létrehozunk egy egyszer szöveget egy gomb programot. A Delphi-ben használhatjuk a globális objektumát ennek az osztálynak. elég ha a programunk Uses részét kiegészítjük a Clipbrd unittal és máris elérhet lesz számunkra a Clipboard objektum. Az nyomógombok OnClick eseményeihez tartozó programkódok: 190 191 . de néha el fordulhat. Ezek a metódusok rendelkezésünkre állnak több komponensnél is. Ebben az esetben a vágólaphoz a TClipboard osztály segítségével kell hozzáférnünk. a hogyan használhatjuk ki a programunkban a vágólapot. A kijelölt megnyomásával vágólapon lev szöveget pedig egy másik nyomógomb megnyomásával beszúrhatjuk a Memo komponensünkbe.• PasteFromClipboard: a vágólapról belilleszti az adatokat a kurzor aktuális helyére. hogy a vágólapra pl. Ezt nem kell külön deklarálnunk és létrehoznunk. • Open. Image1) a vágólapra. amely szemlélteti. RichEdit komponenseknél. melyek a vágolapon lev aktuális adatokra vonatkoznak. Formats – tömb. ha például át szeretnénk másolni egy képet (pl. A TClipboard osztály legfontosabb metódusai: • Assign – objektum (leggyakrabban kép) vágólapra való másolására szolgál. képet vagy más objektumot akarunk elhelyezni.Assign(Image1.Picture). A fenti metódusoknak a használata nagyon egyszer . A munka ezzel az objektummal nagyon egyszer . mint például az Edit. Close – a vágólap megnyitására és bezárására szolgáló metódusok több adat vágólapra való helyezésekor. A harmadik nyomógomb a kijelölt szöveget áthelyezi (kivágás) a vágólapra. A Memo komponensen kívül tehát a programunkon használni fogunk még három nyomógombot (Button) is. vágólapra másolhatjuk. Memo. • HasFormat – megállapítja hogy a vágólapon lev adatok adott formátumúak-e.

akkor a nyomógomb maradna aktív és így a felhasználónak kellett volna a kurzort átvinnie a Memo komponensbe (úgy hogy odakattint az egérrel). hogy a vágólapon lev alkalmazásunk egyetlen komponensbe. Ellenkez jelenít meg a programunk. hogy a nyomógombra kattintás után ismét a Memo komponens legyen az aktív (tehát hogy a kurzor átkerüljön a Memo komponensbe). begin Memo1. A következ nyomógombot (Button) és egy Memo komponenst fog tartalmazni. Messages. Arra. Memo1. A nyomógombra kattintás után leteszteljük milyen adat van a vágólapon (szöveg vagy kép) és ett l függ en beillesztjük a Memo vagy az Image Szöveges adat van a vágólapon? 054 A következ program meghatározza.Text := Clipboard.PasteFromClipboard.Az alkalmazás létrehozásakor ne felejtsük el beírni a Clipbrd procedure TForm1.SetFocus.SetFocus. 192 193 esetben hibaüzenetet .SetFocus. modult a programunk Uses részébe. Ha a vágólapon szöveges adat van.. A SetFocus metódussal bebiztosítjuk.Button3Click(Sender: TObject)..AsText else ShowMessage(’A vágólapon nincs szöveg!’). Dialogs.Button2Click(Sender: TObject). Clipbrd. begin Memo1. adat a megadott formátumú-e. begin Memo1.Button1Click(Sender: TObject). procedure TForm1. továbbá egy Memo és egy Image komponenst. StdCtrls. begin if Clipboard.. Ha ezt a metódust nem használtuk volna.CopyToClipboard. Hova rakjuk a vágólapról az adatot? 055 Az alábbi programban is a HasFormat metódust fogjuk használni. az a nyomógombra kattintás után a Memo komponensbe lesz beillesztve.HasFormat(CF_TEXT) then Memo1. Memo1. procedure TForm1. end. a HasFormat függvényt használtuk CF_TEXT paraméterrel.Button1Click(Sender: TObject). hogy a vágólapon szöveges adat van-e. end. end. uses Windows. Memo1. Az alkalmazás egy „Beillesztés” feliratú nyomógombot fog tartalmazni. procedure TForm1. .CutToClipboard. end.

Kezelni fogjuk a form OnCreate. melyeknek van valamilyen összefüggésük a vágólappal. Minden ilyen ablakhoz eljut a WM_DRAWCLIPBOARD üzenet mindig. Az alkalmazásunk alapm ködése már kész is lenne. StdCtrls. begin if Clipboard. hogyan érzékeljük. akkor a rendszer az els ablaknak a láncban küld egy WM_CHANGECBCHAIN üzenetet.PasteFromClipboard else if Clipboard. Ezekután ha a vágólap tartalma megváltozik. Ennek az alkalmazásnak a segítségével minden olyan szöveget evidálni tudunk majd. amely a vágólapon „keresztülment”. A programban néhány Windows API függvényt is fogunk használni.Picture. amikor a vágólap uses Windows.HasFormat(CF_PICTURE) then Image1. ha nem kéne még egy fontos dolgot megoldanunk. Az alkalmazásunk egy Memo komponenst fog tartalmazni. mindig kapunk egy WM_DRAWCLIPBOARD üzenetet. tartalma megváltozik. A form-unk létrehozásakor tehát besoroljuk ebbe a láncba a mi alkalmazásunkat is (annak f ablakát) a SetClipboardViewer függvény segítségével.’).HasFormat(CF_TEXT) then Memo1. 194 195 . ha megváltozott a vágólap tartalma. hogy mi történik valamelyik vágólapfigyel eltávolításakor a láncból. mégpedig azt.OnDestroy eljárásait. hanem csak az els nek. eljárást. Ezért a WM_DRAWCLIPBOARD üzenetet nekünk is tovább kell küldenünk a következ ablaklnak. procedure TForm1. Messages.Button1Click(Sender: TObject). Ezért tehát ehhez az üzenethez is lére kell hoznunk egy kezel logikusan OnChangeCBChain nevet a adunk. WM_DRAWCLIPBOARD üzenethez. A Windows-ban létezik egy vágólapfigyel k lánca. továbbá kialakítjuk a WM_DRAWCLIPBOARD és WM_CHANGECBCHAIN üzenetek kezelésére szolgáló eljárásokat. Hozzunk létre egy új alkalmazást. Vágólapfigyel program 056 Végül egy kicsit bonyolultabb példát mutatunk be. A metódus megírásakor figyelembe kell vennünk. end. majd helyezzünk el rajta egy Memo komponenst. annak az utána következ nek és így tovább.Assign(Clipboard) else ShowMessage(’A vágólapon ismeretlen adat van. Ha a lánc valamelyik elemét el kell távolítani. Ennek kezeléséhez létre kell hoznunk egy OnDrawClipboard metódust. Most gondolkodjunk el azon. melynek Hasonlóan a WM_CHANGECBCHAIN üzenetet is tovább kell küldenünk a láncban soron következ ablaknak. Neki tovább kell küldenie a következ nek. Ez a lánc tartalmazza azokat az ablakokat. Clipbrd. …. melybe folyamatosan kiírunk minden olyan szöveget. hogy a Windows nem küldi el ezt az üzenetet az össze vágólapfigyel nek a láncban. amely bármelyik programban a vágólapra lett helyezve.

Ehhez a ChangeClipboardChain Windows API függvényt fogjuk felhasználni.Az utolsó dolog. end. begin {kijelentkezunk a lancbol} ChangeClipboardChain(Handle. begin {ha szoveg van a vagolapon. WM_DRAWCLIPBOARD. 197 .OnChangeCBChain( var msg: TWMChangeCBChain). procedure OnChangeCBChain( var msg: TWMChangeCBChain). kovHandle). begin {besoroljuk a lancba az ablakunkat} kovHandle := SetClipboardViewer(Handle). programunk Uses részét kib víteni a Clipbrd modullal! procedure TForm1.FormCreate(Sender: TObject). Hasonlóan az el z alkalmazásokhoz itt sem felejtsük el a … … message WM_CHANGECBCHAIN. procedure TForm1. uses Windows.AsText).Next).Next else {egyebkent tovabbkuldjuk az uzenetet} SendMessage(kovHandle.Remove = kovHandle then kovHandle := msg.Add(Clipboard. end.Lines..FormDestroy(Sender: TObject).HasFormat(CF_TEXT) then Memo1. amit még meg kell tennünk összefügg az alkalmazásunk bezárásával. end.. Clipbrd. message WM_DRAWCLIPBOARD. {tovabbkuldjuk az uzenetet} SendMessage(kovHandle. 0..OnDrawClipboard( var msg: TWMDrawClipboard). WM_CHANGECBCHAIN. end. end. berakjuk a memo-ba} if Clipboard. 0).Remove. 196 procedure TForm1. type … private kovHandle: HWND. begin {ha a mi utanunk kovetkezo jelentkezik ki a lancbol. akkor megvaltoztatjuk a kovHandle-t} if msg. procedure TForm1. StdCtrls. . msg. hogy az alkalmazásunkat már nem akarjuk tovább vágólapfigyel ként használni és ezért el kell távolítani ebb l a láncból. procedure OnDrawClipboard( var msg: TWMDrawClipboard). Messages. msg. Ekkor a rendszernek tudtára kell hoznunk.

) van egy azonosítója. Ennek paramétere az ablakunk azonosítója (handle). Ehhez a SendMessage függvényt használjuk: ennek els paramétere a célablak azonosítója (kovHandle). melynek végére bekerül az új üzenet. Az üzenet egy információ arról. Utána az üzenetet tovább kell küldenünk az utánunk következ vágólapfigyel nek. a következ két paramétere pedig az üzenet paramétereinek elküldésére szolgál. ha WM_CHANGECBCHAIN valamelyik vágólapfigyel üzenet érkezik. Az alkalmazás besorolása a vágólapfigyel k láncába a következ . Ez a leíró adattípusát tekintve egy LongWord. 25. hogy a megsz n ablak a mi utánunk következ -e (ebben az esetben más ablak lesz az utánunk 198 199 . beír valamilyen szöveget. A Windows ezt az üzenetet elküldi azoknak az ki szeretne jelentkezni a láncból. melynek els paramétere a kijelentkez ablak. vagyis egy el jel nélküli 32 bites egész szám. hogy a vágólapon szöveg vane. Sok esetben azonban a Delphi programozónak is a Windows üzeneteiteinek a használatához kell nyúlnia.Remove paraméteréb l megtudhatjuk. neki kell küldenünk tovább minden vágólappal kapcsolatos üzenetet. ezek kizárólag az operációs rendszerhez köt dnek. Az üzenetek nem a Delphi specialitásai.n. Ehhez a message kulcsszót használhatjuk a metódus deklarálása után megadva. Sokat programozhatunk a Delphi-ben az nélkül. jelöl négyzetnek. Saját magunk kijelentkezését a láncból a SetClipboardViewer függvény segítségével történik. üzenethurok (message loop). melyet a msg. hogy az üzenetekkel foglalkoznunk kellene. stb. A Windows üzenetei Ez a fejezet a Windows operációs rendszer üzeneteivel fog foglalkozni. amely minden fontos információt tartalmaz arról hol és mi történt. az ablak-leíró (windows handle). Ezzel a leíróval tudunk azonosítani a rendszerben egy adott objektumot. melyeket ez érint. második paramétere az üzenet. Ha a megsz n ablak nem az utánunk következ . Ha a felhasználó kattint az egérrel. ami azt jelenti. ha WM_DRAWCLIPBOARD üzenetet kapunk (tehát ha változik a vágólap tartalma). akkor az üzenetet továbbküldjük az utánunk következ nek a láncban. a Windows létrehoz egy üzenetet. Ezt az azonosítót kovHandle változóba tesszük. a második paramétere pedig a láncban utánunk következ ablak azonosítója. hogy a rendszerben valahol valami történt. Az OnChangeCBChain metódus mindig meg lesz hívva.A TForm1 deklarációjában létre kell hoznunk két eljárást két üzenet kezelésére. Az üzenet az egyik legfontosabb fogalom a Windows operációs rendszerben. beviteli mez nek. A metódusban leellen rizzük. Minden alkalmazásnak van üzenetsora (message queue). vagy bármilyen más esemény történik. Megjegyzés: A Windowsban minden egyes ablaknak és vezérl nek (gombnak. megnyom egy billenty t. berakjuk a Memo komponensbe. Az üzenet alkalmazásoknak. hogy ChangeClipboardChain Windows API függvény segítségével hajtjuk végre. és ha igen.Next paraméterb l tudhatunk meg). Az OnDrawClipboard metódus mindig meg van hívva. msg. A függvény a láncban utánunk következ vágólapfigyel handle-jét adja vissza. tehát a mi ablakunk azonosítója (handle). Az alkalmazás „belsejében” fut egy ú.

az ú. Figyelni fogjuk a WM_DELETEITEM üzenetet.log nev állományba a törlés dátumával és idejével együtt. 2. Az üzenet az alkalmazás üzenetsorának végére kerül. Az üzenetek a rendszerben a következ keresztül: 1. Az els helyeken mennek eljárásait A Windows generál egy üzenetet. 4. 3.n. hanem az üzenet érkezésekor elmentjük egy elemek. ablakeljárás (window procedure) hajtja végre. tehát megfelel módon reagál rá. Az ablakeljárás „kezeli” az üzenetet. 25. Ablakeljárás – végrehajt valamilyen reakciót az üzenetre. átrajzolja az ablakot. mivel az események között. Az alkalmazás üzenethurokja – a sor elejér l az els üzenetet lekéri és továbbadja az ablakeljárásnak. Valamilyen hely – itt valamilyen esemény bekövetkezik. Észrevehetjük a hasonlóságot ez között és a Delphi Bármi Bekövetkezik az esemény. pontban generált üzenet az „érintett” alkalmazásban az üzenetsor végére kerül. Üzenet kezelése Delphi-ben példa bemutatja. Ezen kívül a Delphi tartalmaz speciális adattípust minden üzenettípusnak. például kiír valamilyen információt. eseménykezelt programozása között. stb. Az üzenet feldolgozást speciális eljárás. tehát ez az üzenet generálásának a helye.1. A Delphi-ben az üzenetek els sorban a TMessage osztály segítségével vannak reprezentálva. és az itt leírt üzenetek között van kapcsolat: a Delphi számunkra egyszer en megérthet eseményekbe foglalja az üzeneteket. Ez a törölt elemünk azonban nem fog elveszni. Üzenhurok A hurok beolvassa a következ üzenetet a sorból… Üzenetsor Ablakeljárás …és átadja az ablakeljárásnak. melyeket a Windowstól kap. ha a lista elemeib l egy vagy több elem törl dni fog. hogy lekérjen egy üzenetet az üzenetsorból és továbbítsa azt feldolgozásra. Ez nem véletlen. amelyeket a Delphi-ben kezelünk. A nyomógomb megnyomásakor töröljük a listából az aktuális (kijelölt) elemet. hogyan lehet Delphi-ben „elkapni” a rendszerüzeneteket. 057 200 201 . amelyet a ListBox-ot vagy ComboBox-ot tartalmazó ablaknak küld a rendszer akkor. Az alkalmazás üzenetsora – az 1. Az alkalmazás egy ListBox komponenst és egy nyomógombot fog tartalmazni.melynek feladata csupán az. Ezeknek az eseményeknek a kezel programozzuk.

%s’.DeleteItemStruct. Writeln(F. ’Törölt elemek listája’). WriteLn(F. vagy az üzenethez tartozó konkrét típusnak. … … type TForm1 = class(TForm) ListBox1:TListBox. end. var F: TextFile. CloseFile(F). deklarációból és az eljárás implementációjából procedure TForm1. public { Public declarations } end.log’).A nyomógomb OnClick eseményéhez tartozó eljáráson kívül létrehozunk egy kezel eljárást a WM_DELETEITEM üzenet kezelésére. begin AssignFile(F.ItemIndex). [ ListBox1. end.Button1Click(Sender: TObject).Delete(ListBox1. private { Private declarations } procedure OnListBoxDelete(var msg: TWMDeleteItem). inherited. ’**********************************’).Items.OnListBoxDelete(var msg: TWMDeleteItem).log’) then begin Rewrite(F). Format(LOGFORMAT. var Form1: TForm1. procedure Button1Click(Sender: TObject). amely után annak az üzenetnek a nevét kell megadnunk. A deklaráció végén a message kulcsszót kell használnunk.Items[msg. Button1:TButton. ’elemek. TimeToStr(Time) ])). procedure TForm1. akkor a TWMDeleteItem típust használhatjuk.dfm} Az üzenetet kezel eljárás létrehozásánál a deklarációban szerepelnie kell az üzenetet pontosító paraméternek. implementation {$R *. const LOGFORMAT = ’%s – törölve: %s. 202 203 . amelyet kezelni fogunk. begin ListBox1. if not FileExists(’elemek. Ez az eljárás két részb l fog állni: a TForm1 osztály private részében szerepl (eljárás törzséb l). message WM_DELETEITEM. Ennek a paraméternek vagy egy általános TMessage típusúnak kell lennie. DateToStr(Date).ItemID]. Az eljárás implementációjában a fejléc után már nem kell megadnunk a message kulcsszót. Ha tehát a WM_DELETEITEM üzenetet kezeljük. WriteLn(F. end else Append(F).

mivel a Delphi-ben az események segítségével megoldhatjuk a reakciókat az üzenetekre. A készül alkalmazásunk egy Edit komponenst.OnMessage eseménye bármilyen bejöv üzenetr l „értesül”. Miért? Ha például „kijavítjuk” a WM_PAINT üzenetek kezelését és elfelejtjük meghívni az s kezelését az inherited kulcsszó segítségével. Ebb l adódik. hogy a legtöbb áttranszformálva. mint ahogy az el z példában az alkalmazásunk kapta a WM_DELETEITEM üzeneteket.OnMessage esemény kezelése az egyik legleterheltebb eljárása az egész alkalmazásnak. de leggyakrabban ennek ellentettje az igaz. Bizonyos esetekben készakarva nem hívjuk meg az eljárás sben lev kezelését. de az üzenetek fogadásához nem kell kézileg eljárásokat definiálnunk.2. 25. egy listát és egy nyomógombot fog tartalmazni.Az üzenetet kezel eljárás végén használtuk az inherited eljárás Az eseményével. Ennek a kulcsszónak a segítségével a mi eljárásunk lefutása után meghívjuk a WM_DELETEITEM standard kezelését úgy. Az inherited kulcsszó után nem kell feltüntetnünk semmilyen további információkat. amely a message kulcsszó után van megadva a deklarációban. 058 A bejöv üzenetek megszámlálásához kihasználjuk azt. 204 205 . a Delphi tudja. Ezért soha ne írjunk bele több programkódot. ha is az kulcsszót. Az ablak (form) feliratában (Caption) folyamatosan megjelenítjük az alkalmazás által kapott üzenetek számát. alábbi Ez példában az esemény egy érdekes eseménnyel mindig. Ez azonban nem jelenti azt. Ezt a kulcsszót ajánlatos minden üzenetet kezel megismerkedhetünk. Ezt az üzenet specifikációjából tudja meg. private változóra.OnMessage eseményét is. mint amennyi szükséges. mégpedig az Application objektum OnMessage bekövetkezik végén használnunk (ha csak nem készítünk valamilyen speciális eljárást az üzenet kezelésére). A form OnCreate eseményén és a nyomógomb OnClick eseményén kívül tehát kezelni fogjuk az Application. Szükségünk lesz még egy „UzenetekSzama” nev melyben az üzenetek számát fogjuk számolni. Beérkez üzenetek számlálása A következ Delphi-ben a példa szemlélteti. hogy az Application. hogy az alkalmazás a rendszert l ne kapna üzeneteket. Mondtuk. melyik metódusról (melyik sr l) van szó. Létrehozzuk tehát ennek az eseménynek a kezelésére szolgáló eljárást. alkalmazásunk valamelyik komponense valamilyen üzenetet kap a rendszert l. Ehhez meg kell írnunk az AppOnMessage eljárást és „össze kell kapcsolnunk” az Application objektum OnMessage eseményével. akkor nem lesz kirajzolva semmi sem (ha csak a mi kezelésünkben nem végezzük el kézileg a kirajzolást). hogy az Application. ahogy az az sében van definiálva. hogy megközelít leg mennyi standard üzenet eseményekbe van üzenet érkezik egy alkalmazáshoz a futása során. Hasonlóan kap üzeneteket.

end. mint maga a címzett. beírhatjuk helyette csak a Handled := true. begin if Edit1. end. … tovább mint kezeletlen.Items. parancsot. Megjegyzés: Az OnMessage esemény kezelését (összekapcsolását az AppOnMessage eljárással) nem csak programilag realizálhatjuk.Text <> ’’ then ListBox1.OnMessage := AppOnMessage. hogy az üzenetet mi is kezeljük és az eredeti címzetthez is eljusson. begin Inc(UzenetekSzama). procedure TForm1. Természetesen van arra is lehet ség.Add(Edit1. end. procedure TForm1. UzenetekSzama := 0. var Handled: Boolean).Text). mennek tovább az üzenet címzettjéhez. begin Application. melyek nincsenek az OnMessage esemény kezelésében „leállítva“.AppOnMessage(var Msg: TMsg. el tte azonban mentsük el az össze munkánkat! Az Application. … … procedure TForm1. Ezt a Handled 206 207 25. de tervezési id ben az Object Inspectoron keresztül is. melyet az alkalmazásunk kapott egyáltalán nem kevés. Figyelembe kell vennünk azt is.message = $0100 then Handled := true. procedure AppOnMessage(var Msg: TMsg. OnKeyDown). Caption := ’Üzenetek száma: ’ + IntToStr(UzenetekSzama). hogy ez tényleg csak egy nagyon egyszer alkalmazás.FormCreate(Sender: TObject). Felhasználó által definiált üzenetek küldése . Ha nincs kezelve. Egy kis munka után az alkalmazásunkban láthatjuk.3. Azok az üzenetek. Ez alatt vagy az esemény kezelését értjük (pl. hogy az üzenet menjen-e … type TForm1 = class(TForm) … private { Private declarations } UzenetekSzama: Integer. Észrevettük a különbséget? Ha az efektus nem elegend számunkra. Érdekességképpen próbáljuk meg az AppOnMessage eljárást kiegészíteni a következ sorral: if Msg. akkor az üzenet fel lesz dolgozva „standard úton“. amely a komponens programozója által van definiálva.OnMessage esemény összekapcsolását az AppOnMessage eljárással a már megszokott módon tesszük meg az ablak OnCreate eseményének kezelésében.paraméterrel állíthatjuk be. bonyolultabb alkalmazásoknál az üzenetek száma több tízezer lehet. Ehhez azonban el bb az alkalmazásunkba be kell raknunk egy ApplicationEvents komponenst az Additional kategóriából. hogy az üzenetek száma. vagy nem.Button1Click(Sender: TObject). amely azt jelzi. Az OnMessage esemény kezelése az üzenetr l hamarabb értesül. vagy a „default“ reakciót. var Handled: Boolean).

Erre a WM_USER-t l a $7FFF sorszámú üzeneteket használhatjuk. amely kiírja az információt a számítás befejezésér l. de az üzenetek használata néhány el nnyel jár a kalsszikus metódusokkal szemben: • az üzenetet el lehet küldeni az nélkül. A számítás befejezésekor a számítást végz eljárás küld egy üzenetet az ablaknak (form) a számítás befejezésér l. hogy pontosan ismernénk a címzettjének a típusát. amely segítségünkre van saját 208 209 . A változó értéke mindig ki lesz írva az alkalmazás ablakának feliratában. … const WM_KESZ = WM_USER + 100. Ezt a az alapelvet általánostíthatjuk: miért ne cserélhetne az üzenetek segítségével két alkalmazás is információt egymás között? Továbbmenve: létezik valamilyen ok. A form erre az üzenetre egy információs üzenetablak megjelenítésével reagál. ha egyenesen meghívhat valamilyen eljárást vagy függvényt? Ez igaz. Deklatáljuk az üzenet kezelését végz eljárást (WMKesz) is. Saját üzenet definiálása nagyon egyszer . Ennek a definiálása meg kell hogy el zze a TForm1 osztály deklarálását. Amint a rendszerben valami történik. Az üzenet létrehozásához nem kell semmi mást tennünk. private { Private declarations } lehet séget ad felhasználói üzenetek küldésére. 059 A programozás során definiálnunk kell a WM_KESZ konstanst. • az üzenetet el lehet küldeni egyszerre több címzettnek is (ú. A Szamitas metódus impementációjában valamilyen számítás szimulálását végezzük el. mivel benne már használjuk ezt a konstanst. A számítás elvégzése után ez a metódus küld egy üzenetet az alkalmazásnak. A WM_USER egy a rendszerben definiált konstans. • nem történik semmi sem. A Windows egy számítást (egy változó növekedését 1-t l 10000-ig). type TForm1 = class(TForm) Button1: TButton.n. ha a címzett nem reagál az üzenetre.Tekintettel arra. Az utolsó lépés a WMKesz eljárás imlementálása. amiért ne használhatná ki ezt a rendszert egy alkalmazás információk küldésére például egy egyik és másik ablaka között a program futása alatt? Felmerülhet a kérdés: miért küldjön egy alkalmazás saját magának üzenetet (pl. A következ alkalmazás a nyomógombra kattintás után elindít üzeneteket. a számítás befejezésér l). melyhez hozzáadunk valamennyit). felhasználhatjuk az üzenetek küldésének mechanizmusát alkalmazások közti komunikációra vagy egy alkalmazáson belüli komunikációra is. a Windows küld az alkalmazásnak egy üzenetet. hogy definiálhatunk saját (felhasználói) konstansok létrehozására (úgy használhatjuk mint alapot. mint definiálnunk saját konstans. Az alábbi példában definiálink egy WM_KESZ üzenetet: const WM_KESZ = WM_USER + 100. procedure Button1Click(Sender: TObject). az üzenetek küldése remek lehet ség az információ átadására az operációs rendszert l az egyes alkalmazásoknak. Ahogy eddig is láthattuk. broadcasting).

WParam ill.Button1Click(Sender: TObject). A függvény meghívásakor csak az ablak-leírót (handle) kell ismernünk. begin ShowMessage('A számítás befejez dött. ha változott a képerny beállítása. … üzenetsornak) és addig nem tér vissza. WM_KESZ. j. amíg az üzenet kezelése be nem fejez dik. használhatjuk erre a WM_DISPLAYCHANGE nev beérkez üzenet kezelését. amely hasonló a SendMessage eljáráshoz. 0).4. procedure Szamitas. j:=i. end. end. A képerny felbontásának érzékelése Ha szükségünk van az alkalmazásban a képerny felbontásának. message WM_KESZ.procedure WMKesz(var Msg: TMessage). end. Az üzenet küldésére használhatjuk a Perform metódust is. procedure TForm1. begin // szamitas szimulalasa for i:=1 to 10000 do begin Caption := IntToStr(i). eljárásban segítségével procedure TForm1. begin Szamitas. Az alábbi alkalmazás mindig megjelenít egy információs ablakot. A függvény átadja az üzenetet egyenesen a címzett üzenetkezel eljárásának (nem az … type TForm1 = class(TForm) private { Private declarations } 211 210 . end. public { Public declarations } end. // felhasznaloi uzenet kuldese SendMessage(Self. Segítségével üzenetet küldhetünk egyenesen az adott komponensnek. Eredmény = ' + IntToStr(Msg. színmélységének változását figyelni. procedure TForm1.Handle.WParam)). hanem a program azonnal folytatódik a PostMessage eljárás urán. Msg. Továbbá üzenet küldésére használható még a PostMessage eljárás is.LParam hivatkozhatunk rájuk).j: integer. csak ez nem vár az üzenet kezelését végz eljárásból való visszatérésre. 060 Az üzenet elküldésére a SendMessage rendszerfüggvényt használjuk. az üzenet azonosítója.Handle.Szamitas. … 25.WMKesz(var Msg: TMessage). az üzenet két további paramétere (a kezel a Msg. var i. A SendMessage-nak négy paramétere van: • • • a címzett azonosítója (handle). amelyet minden komponens tartalmaz. ami a mi esetünkben a Self.

stb.procedure WMDisplayChange(var Msg: TMessage). … procedure TForm1. Ha egy billenty le lett nyomva a billenty zeten.1. Továbbá a nyomógomb OnClick eseményéhez tartozó eljárást fogjuk megírni: … uses 212 213 . metódusok találhatók. zenét játszhatunk le. A következ program csak egy nyomógombot fog tartalmazni. Ha egy billenty fel lett engedve a billenty zeten. A Windows néhány kiválasztott üzenete A Windowsban rendgeteg fajta üzenet van. Hang lejátszása az alkalmazásban Sokszor szeretnénk programunkat színesebbé tenni különféle rövid hangok lejátszásával.WMDisplayChange(var Msg: TMessage). Ha a felhasználó mozgatja az egeret. melynek megnyomásakor egy hangot játszunk majd le. begin ShowMessage('A képerny beállítása megváltozott. található. illetve olyan eljárások. Ha a felhasználó lenyomja a bal egérgombot. public { Public declarations } end. de eddig még nem esett róluk szó. melyek a programozás során hasznunkra lehetnek. inherited. Ha az ablaknak át kell rajzolni magát. További hasznos programrészek Ebben a részben rövid programrészek. például egy gomb megnyomásakor vagy egy játékprogramban a kincs megtalálásakor. 25. Ezek többségét megtalálhatjuk a súgóban ill. … WM_TIMER WM_QUIT $0113 $0012 Ha bekövetkezik az id zít eseménye. 26. message WM_DISPLAYCHANGE.5. Ha kérés érkezett az alkalmazás bezárására. amely az MMSystem unitban Üzenet azonosítója: WM_ACTIVATE WM_KEYDOWN WM_KEYUP WM_LBUTTONDOWN WM_MOUSEMOVE WM_PAINT Értéke: $0016 $0100 $0101 $0201 $0200 $000F Mikor kapunk ilyen üzenetet? Ha az ablak aktiválva vagy deaktiválva van. 061 Az alkalmazás forráskódjában ne felejtsül el beírni a programunk uses részébe az MMSystem modul használatát. utána nézhetünk az Interneten. Ennek az eljárásnak a segítségével WAV formátumban lev hangot.'). Itt most ezekb l felsorolunk néhányat: 26. Ezt egyszer en megtehetjük a PlaySound eljárással. end.

akkor a hangot körbe-körbe fogja lejétszani mindaddig. end. beállítani. a LoadFromFile metódussal beolvastuk az állományba – ennek hátránya. … . bit a futtatható állománnyal együtt a WAV állományt is át kell másolnunk a programunk terjesztésekor. hogy a BMP fájlokat is mindig az EXE mellé kell másolnunk. StdCtrls.SND_ASYNC). melynek mindegyik bitje valamilyen beállítási lehet ség. Er forrás (resource) állományok használata Eddig ha valamilyen bitképet akartunk felhasználni az alkalmazásunkban. bit (SND_ASYNC) – ha értéke 1.2. hogy az ilyen fajta lejátszásnál mindig .wav'. Ha egyszerre több beállítani. 4... • 3. a Az PlaySound(NIL. harmadik paramétere pedig egy ú. 4. amig az eljárás nem lesz újból meghívva. bit 1. • esetben az eljárás els paramétere nem a fájl nevét.wav’. begin PlaySound('boink. SND_LOOP-al A hangot a már említett PlaySound eljárással játszuk le. SND_LOOP or SND_ASYNC ). akkor a hangot a memóriából (nem küls fájlból) fogja lejátszani. Meg kell hogy jegyezzük. bit 3. A hang együtt lejátszását az ebben az is esetben lehet. akkor a lejátszás aszinkron. 26. paranccsal SND_ASYNC-t szükséges melynek els paramétere a fájl neve (elérési útvonallal együtt. … procedure TForm1. az or m velet segítségével kapcsolhatjuk össze. ha nem ugyanabban a mappában található. ezeknek 0. három lehet ségünk volt: 1. pl. • 1.0.Windows. Mindegyik bitet szeretnénk bitre használható ezeket egy konstans.Button1Click(Sender: TObject). akkor nem fogja lejátszani az alapértelmezett hangot. • 2. A BMP fájlokat külön tároltuk és pl.n. bit (SND_LOOP) – ha értéke 1. 0 . második paramétere mindig 0. SND_ASYNC).: a zárójelben megadott SND-vel kezd d neve van. Ebben az 214 215 . és ha véletlenül nem tettük oda. flag. Aszinkron lejátszásnál elindul a hang lejátszása és az alkalmazás fut tovább. mivel innen játsza le a hangokat. a program nem tudta beolvasni – hibát írt ki vagy nem jelent meg a programban a kép. bit 2. Pl: PlaySound( ‘boink. különben szinkron (SND_SYNC). Szinkron lejátszásnál az alkalmazás leáll és vár a hang lejátszásának befejez désére. hanem a memória azon részére mutató pointer. bit (SND_NODEFAULT) – ha értéke 1 és a lejátszás során hiba következik be (nincs meg a lejátszandó hang). hogy egy olyan szám. ahol a hang van. Messages. MMSystem. Ez utóbbi azt jelenti. ahol az alkalmazásunk). bit (SND_MEMORY) – ha értéke 1.

így azokat terjesztésnél nem kell majd külön hozzámásolgatnunk. az ú. Ezek segítségével nem csak BMP.RES} A programból e képet a következ képpen érhetjül el (tölthetjük be az Image komponensbe): 216 217 . er forrás (resource) fájlok használatával.DFM} {$R PELDA. így a fordítás után az belekerült az EXE fájlba. akkor a teljes útvonala segítsével érhetjük el ("c:\Program Files\Borland\Bds\3. hogy az elkészült er forrás-fájlt építse bele a programba: PATH-jában.n. jegyzettömb) segítségével hozzunk lérte valami.bmp" kep2 RCDATA "rozsa.exe valami. A képeket a lefordított futtatható (EXE) állományhoz fogjuk csatolni és innen fogjuk használni (betölteni az Image komponensbe).0\Bin\brcc32. akkor azokat berakhattuk egy-egy Image komponensbe. Ehhez valamilyen egyszer sorokat tartalmazza: szövegszerkeszt (pl. egy EXE-ben benne lesz minden.rc Ha a brcc32. de bármilyen más típusú állományok is (akár az el z fejezetben használt WAV fájlok is) Majd használjuk Borland er forrás-szerkeszt jét (brcc32. csatolhatók a lefordított EXE állományunkhoz. Most megismerkerünk a negyedik lehet séggel is. Több. hasonló BMP állomány esetén használhattunk egy ImageList komponenst és ebben tárolhattuk a képeinket.exe").bmp" Ehhez el ször is létre kell hoznunk egy resource fájlt.bmp" kep3 RCDATA "sivatag. elég volt ezt átmásolnunk a programunk terjesztésénél.res nev állomány. amely a következ {$R *.exe) a létrehozott RC fájl lefordításáhoza: brcc32.2. Ha kevés BMP állományunk volt.rc állományt (resource script). 062 ket A következ fordítási direktívával utasítjuk a fordítót. Ekkor létrejött egy valami. 3. Az egyes nyomógombok megnyomásakor mindig más képet akarunk majd megjeleníteni az Image komponensben. kep1 RCDATA "jeghegy.exe program mappája nincs benne a számítógép Els példánkban hozzunk létre egy form-ot. melyen helyezzünk el egy Image komponenst és három nyomógombot (Button).

3. Tartalma: boink RCDATA "boink. finally Stream.Button1Click(Sender: TObject). hogy ott a kep2 ill. Így kapunk egy hangok.LoadFromStream(Stream).Create(HInstance. Ezt a képet mozgassuk a nyilak segítségével.res állományt. begin 218 219 TObject. hogy a 061-es feladatban lev hang (WAV állomány) az exe állományhoz legyen csatolva.rc parancs 26.rc állományban megadtuk). end. … {$R *. finally ResStream. end.Bitmap.RT_RCDATA).FormKeyDown(Sender: Key: Word. end. Próbjuk meg hasonlóan megoldani. 'kep1'. end.res} procedure TForm1.wav" Ezt fordítsuk le a brcc32. 063 Ehhez el ször is hozzuk létre az RC állományt. Ezt felhasználjuk a programunkban a hang memóriából való lejátszására a következ képpen: … procedure TForm1. StdCtrls. … .Button1Click(Sender: TObject). RT_RCDATA). begin Stream := TResourceStream. 064 Ehhez elég megírnunk az OnKeyDown eseményhez tartozó eljárást: segítségével. try Image1. try PlaySound(ResStream.Free.exe hangok. var … uses .Memory. Kép mozgatása a kurzor billenty k segítségével A következ programban csupán egy képet (Image) helyezzünk el a form-on.rc-nek. A másik három nyomógombhoz tehát ugyanilyen az eljárás fog kerülni annyi különbséggel. 'boink'. nevezzük el például hangok.Free. SND_MEMORY or SND_ASYNC). 0. var Stream : TResourceStream.procedure TForm1.Picture. kep3 lesz megadva második paraméternek. begin ResStream := TResourceStream. var ResStream: TResourceStream. Messages.dfm} {$R hangok.Create(HInstance. Shift: TShiftState). … Az resource stream létrehozásakor a második paraméter adja meg a kép azonosítóját (ahogy a valami. Windows. MMSystem.

private { Private declarations } a: array[1.Top > 0 then Image1. cs: TBitmap. közben jobbra-balra is mozgatva egy sin(5x) függvény segítségével.Left > 0 then Image1. … A programunk tervezési id ben csak a Timer komponenst fogja tartalmazni. VK_LEFT: if Image1.Top-3. procedure FormCreate(Sender: TObject). Forms.FormCreate(Sender: TObject). var Form1: TForm1. A létrehozott komponenseket egy Timer segítségével lefele mozgatjuk. public { Public declarations } end. Ha egérrel az ablakba kattintunk. type TForm1 = class(TForm) Timer1: TTimer. akkor sokszor célszer egy olyan tömb létrehozása. Shift: TShiftState.Top:=Image1. Variants. Button: TMouseButton.Left:=Image1. procedure TForm1. begin DoubleBuffered := true. interface uses Windows. A komponensekben megjelenítend szerint egy er forrás (resource) fájl programhoz csatoljuk és innen olvassuk be. procedure FormMouseDown(Sender: TObject.Top:=Image1. Graphics. A példában maximum 50 ilyen komponenst tartalmazó tömböt használunk. a TImage komponenseket (melyeket a tömbben tárolunk) a program futása során hozzuk majd létre. Ha több komponenst szeretnénk használni az alkalmazásunkban.Top+Image1. ExtCtrls.Left+3.4. VK_RIGHT: if Image1. X. a kattintás helyén létrehozunk egy TImage komponenst (mely egy csillagot ábrázol). end.Height < ClientHeight then Image1. n: integer. 065 220 221 .dfm} 26. Objektumokból álló tömb Objektumokat (komponenseket) a program futása során is létrehozhatunk. Dialogs. Messages. SysUtils. képet az el z a fejezet lefordított segítségével unit Unit1. A következ példában egy TImage komponensb l álló tömböt használunk. Controls.case Key of VK_DOWN: if Image1..Left+Image1.Top+3. end. Classes. amely komponensekb l (objektumokból) áll. end. Y: Integer).Width < ClientWidth then Image1.Left-3.50] of TImage. VK_UP: if Image1. implementation {$R *. Ezeket a komponenseket egy tömbben tároljuk. procedure FormDestroy(Sender: TObject).Left:=Image1. procedure Timer1Timer(Sender: TObject).

Top := -a[i]. Ez van a típus a Double Képzeljük részében lebeg pontos el.Create(HInstance.Top := a[i].FormMouseDown(Sender: TObject. Y: Integer).Top+1. függvényt és eljárást találhatunk.Left := a[i].FormDestroy(Sender: TObject).a[n+1]. elég ha kivonjuk egymásból a két dátumot.round(sin((a[i]. inc(n). a[n+1]. 'csillag'.Top>Height then a[i]. cs.12. procedure TForm1.Left := X .Timer1Timer(Sender: TObject).Top := Y . melyek segítségével a dátummal és az id vel dolgozhatunk. var i: integer.30. end. var i: integer. Aktuális dátum.Top*PI/180*5)*90).Width then a[i]. Shift: TShiftState. a[n+1]. res := TResourceStream. a[n+1]. hogy szükségünk van az aktuális dátum és id lekérdezésére. a[i]. Ebben az esetben szükséges. end.5. var res: TResourceStream.Width div 2. a[n+1]. id lekérdezése A programozás során gyakran el fordulhat.Create. begin if n<50 then begin a[n+1] := TImage. Néha a dátummal és az id vel való munkánk során szükségünk lehet valamelyik Windows API függvény használatára (pl.res} procedure TForm1. van hogy szám típussegítségével valójában a definiálva. begin DoubleBuffered := true.Free.a[n+1].Bitmap := cs.Enabled := false.Autosize := true. procedure TForm1.Picture. begin for i:=1 to n do 222 begin a[i]. a tizedes részben pedig az tárolódik.Parent := Self. RT_RCDATA). end. a[n+1]. end. cs.Left<-a[i]. res.Width. X. 26. a SetSystemTime-ra.Free.FormCreate(Sender: TObject). Erre több adatszerkezetet.Height div 2.Height.Create(Self). Ezért ha például két id pont között eltelt id re van szükségünk. Ekkor tizedesszám elhelyezve 1899. end.Left := -a[i].Top-1)*PI/180*5)*90) + round(sin(a[i].Left>Width then a[i]. hogy a dátumot és az id t olyan formátumban 223 .{$R kepek.LoadFromStream(res). if a[i]. melyel beállíthatjuk a rendszerid t).Transparent := true. a[n+1]. hogy a nap hányad része telt el éjfél óta (a 24 óra hányad része telt el éjfél óta). egész valamilyen az TDateTime típusú változóban tároljuk az aktuális dátumot és id t.Left := Width. cs := TBitmap. if a[i]. a[n+1]. Button: TMouseButton. procedure TForm1. n := 0. end. end.Free. A Delphi-ben a dátum és id megjegyzésére szolgáló alaptípus a TDateTime. begin for i:=1 to n do a[i]. if a[i]. óta eltelt napok száma.Left .

mely megadja hogy a függvény paraméterében lev év (Word típusú – egész szám) szök év e. end. id t.tároljuk.Button1Click(Sender: TObject). var SystemTime: TSystemTime). TimeToStr A TDateTime adattípusból az id t alakítja szöveggé.Caption := 'Mai dátum: ' + DateToStr(Date).Button2Click(Sender: TObject). mindkett t és kiírja egy Label komponensbe. DayOfWeek A megadott TDateTime adattípusból IsLeapYear Értéke egy logikai változó. Az egyes nyomógombokhoz tartozó programkód: visszaadja a nap sorszámát a hétben. Aktuális dátumot adja vissza. begin Label1. DateToStr A TDateTime adattípusból a a dátumot alakítja szöveggé. procedure DateTimeToSystemTime (DateTime: TDateTime.Caption := 'Id : ' + TimeToStr(Time). Aktuális id t adja vissza. Ez a formátum (adattípus) a Delphi-ben a TSystemTime. end.Button3Click(Sender: TObject). A eredmény 1 (vasárnap) és 7 (szombat) közötti szám. procedure TForm1. procedure TForm1. Aktuális dátum és id lekérdezése 066 A következ program három nyomógomb segítségével lekérdezi az aktuális dátumot. begin 224 225 . amely „tetszik” a Windows-nak. Néhány további metódus a dátummal és id vel való munkához: Now Date Time DateTimeToStr Aktuális id t és dátumot adja vissza. begin Label1. procedure TForm1. A TDateTime értéket szöveggé alakítja a formátum megadásának lehet ségével (Format paraméter). A két adattípus közötti átváltásra egy függvény és egy eljárás szolgál: function SystemTimeToDateTime (SystemTime: TSystemTime): TDateTime.

ProcessMessages. Például. Ezt az eredményt elég elosztanunk 1000-rel és megkapjuk a számítás idejét másodpercekben.Caption := 'Dátum és id : ' + DateTimeToStr(Now). például elmentjük egy szöveges vagy bináris állományba. az ablak háttérszínét. stb. nekünk mint programozónak két lehet ségünk van: procedure TForm1. viszont a programozónak plusz munkát jelent. a kezdeti könyvtárat a dokumentumok megnyitásához és mentéséhez.Label1. INI állományok. var i. Ha ezt az id t elrakjuk egy változóba a számítás el tt. end. A beállítások tárolása INI állományokban 074 Az alábbi program szemlélteti. Ahhoz. megkapjuk a számítás idejét milliszekundumokban. majd a számítás után kiszámoljuk a különbséget. begin startido := GetTickCount. A GetTickCount Windows API függvény megadja a Windows utolsó indítása óta eltelt id t milliszekundumokban.') end. Tárolni fogjuk az ablak pozícióját a képerny n. hogyan tárolhatunk beállításokat inicializációs (*. • A beállításokat valamilyen általánosan változást. ido: Cardinal. rendszerleíró adatbázis (regiszterek) használata A felhasználó az alkalmazásunk használatakor sokszor beállít különféle beállításokat. Ez a felhasználó számára nem választjuk. van: a a m köd viszont a mechanizmus segítségével mentjük el. ido := GetTickCount . beállítja az ablak elhelyezkedését a képerny n. for i:=1 to 5000 do begin Label1.ini) fájlokban. end. melyeket szeretné. Ehhez a GetTickCount függvényt fogjuk használni: maradnának. Application. Ha ezt a módszert beállításokat Windows inicializációs (*. • A beállításokat megjegyezzük valamilyen saját formátumban.ini) állományokba mentjük el vagy a tárolására felhasználjuk rendszerleíró adatbázisát (regiszterek). startido.startido.6. hogy a programunk ezeket a beállításokat megjegyezze. beállítások két jelent semmilyen lehet ségünk programozó munkáját megkönnyíti. Ez a felhasználó számára problámamentes. ha legközelebb is beállítva A számítás idejének mérése 067 Ha az alkalmazásunk egy hosszabb számítást tartalmaz. méretét és az beviteli dobozban található szöveget. A 226 227 .Caption := IntToStr(i). 26.Button1Click(Sender: TObject). lemérhetjük a számítás idejét és kiírhatjuk a felhasználónak. ShowMessage('A számítás ' + FloatToStr(ido/1000) + ' másodpercig tartott.

IniFajl. var IniFajl: TIniFile.Free. begin Close.WriteBool('Form'. Width := IniFajl. var IniFajl: TIniFile.Text). 229 .'Maximized'.'Width'.'. IniFajl. Height := IniFajl. // vegul felszabaditjuk az objektumot a memoriabol finally IniFajl. // megprobaljuk kiirni az adatokat a fajlbol try IniFajl. Left := IniFajl.WriteInteger('Form'.programból való kilépéskor az adatokat elmentjül INI fájlokba.100). var Action: TCloseAction). WindowState := wsNormal.Width).153).FormClose(Sender: TObject.Create( ChangeFileExt(Application.ReadInteger('Form'. … … uses Windows. end. SysUtils.ReadInteger('Form'. WindowState=wsMaximized). end.100).'Width'.'.'Left'.FormCreate(Sender: TObject).Left). Top := IniFajl. … . IniFajl. programunk uses részét egészítsük ki az IniFiles unittal.'Height'.ExeName.'Height'. end.Free.ReadBool('Form'. IniFajl.'Left'. // megprobaljuk beolvasni az adatokat a fajlbol try Edit1. hogy dolgozhassunk az INI fájlokkal. IniFiles.ExeName.ReadString('Edit'.WriteString('Edit'.Height).'Text'.'').WriteInteger('Form'.WriteInteger('Form'.ReadInteger('Form'.Text := IniFajl. begin // letrehozunk egy TIniFile tipusu objektumot IniFajl := TIniFile. procedure TForm1.Create( ChangeFileExt(Application.WriteInteger('Form'. end. … procedure TForm1.'Top'.ini')).'Text'.'Maximized'. IniFajl. a program indításakor pedig beolvassuk onnan. if IniFajl. end.132).Edit1.ReadInteger('Form'. Messages.Button1Click(Sender: TObject). begin // letrehozunk egy TIniFile tipusu objektumot IniFajl := TIniFile. procedure TForm1.'Top'.Top).false) then WindowState := wsMaximized else 228 Ahhoz. // vegul felszabaditjuk az objektumot a memoriabol finally IniFajl.ini')).

Ha most megnézzük.OpenKey('\Software\Mi alkalmazasunk\Edit'.ReadInteger('Width'). ezt láthatjuk: [Edit] Text=Szia [Form] Top=416 Left=396 Width=153 Height=132 Maximized=0 felszabadítjuk azt a memóriából a Free metódus fogjuk tárolni. Height := Reg. begin Close. beolvassuk a szoveget Edit1. False) then begin // ha sikerult. beolvassuk az ablak mereteit Top := Reg. Végül. melynek paramétereként megadjuk az inicializációs állomány nevét. end. … .ReadInteger('Height').ExeName és ChangeFileExt függvényeket is.A programban ezután létrehozhatun egy TIniFile típusú objektumot a Create metódus segítségével. A programban használtuk még az Application. // megprobaljuk megnyitni a mi alkalmazasunk // Edit kulcsat if Reg. A beállítások elmentéséhez a WriteString. // megprobaljuk megnyitni a mi alkalmazasunk // Form kulcsat if Reg. Programunk ekkor így néz ki: … uses Windows. hogy az ini fájlunknak ugyanaz a neve legyen. hogy az adatokat nem inicializációs állományokban 230 . az állományból való beolvasáshoz pedig a ReadString. SysUtils. Width := Reg. 231 Rendszerleíró adatbázis (regiszterek) használata 075 Most megoldjuk az el z feladatot mégegyszer azzal a különbséggel. False) then begin // ha sikerult. Ezeket csupán azért alkalmaztuk. Messages. procedure TForm1. hanem a Windows rendszerleíró adatbázisában.Create(KEY_READ).RootKey := HKEY_CURRENT_USER.Button1Click(Sender: TObject). ReadInteger és ReadBool függvényeket.ReadString('Text').FormCreate(Sender: TObject).ReadInteger('Left'). … procedure TForm1. begin // letrehozzunk egy TRegistry tipusu objektumot Reg := TRegistry. ha már nincs szükségünk a létrehozott TIniFile típusú objektumra.ReadInteger('Top').Text := Reg. end. mit tartalmaz a programunk által létrehozott ini állomány. exe helyett ini kiterjesztéssel. Left := Reg. Registry. try // beallitjuk a fo kulcsot Reg. mint a futtatható állománynak.OpenKey('\Software\Mi alkalmazasunk\Form'. segítségével. WriteInteger és WriteBool függvényeket használjuk. var Reg: TRegistry.

ezért ekkor itt false paramétert adunk meg.FormClose(Sender: TObject. var Reg: TRegistry.if Reg. Paraméterként megadjuk.Free. hogy dolgozhassunk a rendszerleíró adatbázissal. … Ahhoz. hogy olvasni vagy írni akarunk-e a rendszerleíró adatbázisba.Edit1.RootKey := HKEY_CURRENT_USER.WriteInteger('Height'. „\ Software A \ mi Mi alkalmazásunkban kulcsot használunk: alkalmazasunk \ Edit” melyben a szövegdoboz tartalmát tároljuk. end.Create metódus segítségével létrehozunk egy objektumot a TRegistry osztályból. melyhez viszonyulnak majd a továbbiakban megadott utak. Olvasáshoz KEY_READ. Reg. True) then begin // ha sikerult.Create(KEY_WRITE). Reg. try // beallitjuk a fo kulcsot Reg. és „\ Software \ Mi alkalmazasunk \ Form” melyben az alkalmazásunk ablakának méretét és pozícióját tároljuk. Reg.WriteBool('Maximized'. begin // letrehozzunk egy TRegistry tipusu objektumot Reg := TRegistry. beirjuk az ablak mereteit Reg. var Action: TCloseAction).Top). procedure TForm1.Width).Left). finally // felszabaditjuk az objektumot a memoriabol Reg.OpenKey('\Software\Mi alkalmazasunk\Form'. A RootKey tulajdonság segítségével megadjuk a f kulcsot.WriteInteger('Width'. Olvasáskor nem szeretnénk ha létrehozná.OpenKey('\Software\Mi alkalmazasunk\Edit'. Itt általában a HKEY_CURRENT_USER vagy HKEY_LOCAL_MACHINE kulcsokat szokás megadni. Majd a TRegistry. end. end.WriteInteger('Left'. WindowState=wsMaximized). 233 . // megprobaljuk megnyitni a mi alkalmazasunk // Edit kulcsat if Reg. íráskor viszont true paramétert.Free. Reg. ha még nem létezik. // megprobaljuk megnyitni a mi alkalmazasunk // Form kulcsat if Reg. end.ReadBool('Maximized') then WindowState := wsMaximized else WindowState := wsNormal.Height). end. mindenekel tt a programunk uses részét ki kell egészítenünk a Registry unittal.WriteInteger('Top'. True) then begin // ha sikerult. end. íráshoz KEY_WRITE konstanst adjuk meg paraméterként. melyb l szeretnénk két az egyes adatokat beolvasni. hogy a megadott kulcsot az objektum létre hozhatja-e. Az OpenKey metódus segítségével megnyitjuk azt a kulcsot. 232 end. ha az még nem létezik. beirjuk a szoveget Reg.Text). Az OpenKey második paramétere megadja. finally // felszabaditjuk az objektumot a memoriabol Reg. mivel a kulcsot létre akarjuk hozni.WriteString('Text'.

amelyen két gomb lesz (Kiírás. Készítsünk programot. hogyan jelennek meg.Adatok írásához és olvasásához az inicializációs fájloknál használt metódusokhoz hasonlóan WriteString. Páratlan. fejezetben leírt „Els programunkat”. 004 5. Fibonacci) és egy címke szerepel.). Ne felejtsük el el tte beállítani a véletlenszám generátort (randomize.Caption := ‘Uj felirat’. majd a számot az IntToStr() függvénnyel tudjuk szöveggé alakítani). amelyen három gomb (Páros. formában adhatjuk meg). majd futtassuk le a programot és figyeljük. amely egy címkét A és egy gomb WriteBool illetve ReadString. felszabadítjuk azt a Free metódus segítségével. ill. Próbáljunk meg készíteni egy alkalmazást. megnyomásakor a számítógép a címke feliratába írjon ki 5 véletlenszer lottószámot 1-t l 90-ig (ilyen véletlenszámokat a random(90)+1 függvénnyel tudunk generálni. Az els gomb megnyomásakor a címke feliratát átírja az 234 235 . Gyakorlatok 1. Hozzunk létre egy alkalmazást. a másik gomb megnyomására kilép a programból. Próbáljunk meg különféle komponenseket elhelyezni az ablakunkban.Size tulajdonságával tehetjük meg). 001 2. hogy minden indítás után ne kapjuk ugyanazokat a számokat. Kilépés) és egy címke. Végül ha már nincs szükségünk az objektumra. Az egyik megnyomásakor átírja a címke feliratát (ezt a programkódban: Label1. milyen értékeket tudunk megadni nekik. Készítsük el a 3. A program tervezésekor állítsuk be az Objektum felügyel ben. WriteInteger. ReadInteger és ReadBool függvényeket használuk. hogy a címke bet mérete nagyobb legyen (ezt a címke Font. 002 3. 003 4. Az alábbi ábrán láthatjuk hogyan hozta létre az alkalmazásunk a kulcsokat a rendszerleíró adatbázisban és hogyan helyezte el benne az egyes adatokat: nyomógombot tartalmaz (Sorsolás).

els

10 páratlan számra (1, 3, 5, …), a második 10 páros számra (2, 4, 6, …), a 10 Fibonacci

üzenet Biztos benne? kérdéssel, stb. Legalább ötször egymás után. 007 (ismétlés Turbo Pascalból: egy i változó deklarálása a unit implementation részében, case elágazás használata) 8. B vítsük ki az el z feladatot úgy, hogy az ablak helye

megnyomásakor az els

harmadik megnyomásakor kiírja az els

számot (1, 1, 2, 3, 5, 8, … - mindegyik szám az el z kett összege). A számokat ciklus segítségével próbáljuk meg generálni. 005

minden gombnyomás után máshol legyen a képerny n véletlenszer en kiválasztva. 008 (új tulajdonságok: Left, Top, Width, Height, Screen.Width, Screen.Height,

A Objektum

következ

néhány

megoldott az

feladatban (form1)

(6.-21.)

a

tulajdonságokat a könnyebb megértés végett, ha lehet, nem az felügyel ben, hanem ablak OnCreate eseményében állítunk be. Így a forráskódból érthet bb lesz, hogy melyik tulajdonságokat állítottuk át. Természetesen a saját program elkészítésekor ezeket ugyanúgy beállíthatjuk az Objektum felügyel ben is, ahogy eddig tettük az OnCreate esemény helyett. A 22. feladattól, amikor már remélhet leg természetes lesz számunkra, hogy a

események: OnCreate, ismétlés Turbo Pascalból: random, randomize) 9. Próbáljuk meg a programot úgy átírni, hogy ha a felhasználó máshogy (X-szel a jobb fels sarokban, ALT+F4-gyel, stb.) akarja bezárni az alkalmazást, akkor se tudja és jelenjen meg neki ebben az esetben az Így nem fog menni, csak a gombbal! felirat. 009 (új esemény: Form1.OnCloseQuery, ennek CanClose paramétere) 10. A képerny n jelenjen meg egy adatlap (ábra). Ha az Edit1 beviteli mez be beírjuk a nevünket, akkor a Label3 címkébe kerüljön be a bevitt adat! 010 (új tulajdonságok: Edit1.Text, Font.Style halmaz)

komponensek melyik tulajdonságát kell beállítanunk az Objektum felügyel ben, a példaprogramoknál is visszatérünk a komponensek alapvet kezdeti tulajdonságainak az Objektum felügyel ben való beállításához.

6. Jelenjen meg a képerny n két nyomógomb Belevágok! és Kilépés felirattal. A belevágok gombra való kattintás után jelenjen meg az Üdvözöllek a programozás világában! üzenet. 006 (tulajdonság: Caption, esemény: OnClick, metódus: Form1.Close) 7. Jelenjen meg a képerny n egy gomb Kilép felirattal. Ha a felhasználó rákattint, jelenjen meg egy üzenet Meggondolta? kérdéssel. Majd ha „leokézza”, egy másik
236 237

CheckBox OnClick eseményére ugyannak az eljárásnak a 11. B vítsük az el z feladatot egy újabb kérdéssel (Életkora:), ami csak akkor jelenjen meg, amikor a felhasználó válaszolt az el z kérdésre. 011 (új tulajdonság: Visible) 12. Jelenjen meg a képerny n két beviteli mez és egy Csere feliratú gomb. A gombra kattintáskor a két beviteli mez tartalma cserél djön meg. 012 13. Zöldséges standunkon háromféle terméket árulunk: megadása, mint az CheckBox1-nek) 17. Készítsünk szoftvert kávé automatához! Rádiógombokkal lehessen megadni az italt (kávé, tea, kakaó), jelöl négyzetekkel a hozzávalókat (citrom, cukor, tej,

tejszín). A szoftver számolja ki és jelenítse meg a fizetend összeget! Teához ne lehessen tejszínt, kávéhoz citromot, kakaóhoz se citromot, se tejszínt kérni! (ábra) 017 (új tulajdonságok: Enabled, RadioButton1.Checked)

burgonyát, répát és káposztát. Egységárukat egy-egy címke jeleníti meg, a vásárolt mennyiséget egy-egy beviteli mez be írjuk. Egy gomb megnyomása után számítsuk ki és jelenítsük meg a fizetend összeget! 013 (új tulajdonság: Font.Size, függvények: StrToFloat, FloatToStr, Round) 14. A programablak bal fels sarkában jelenjen meg egy

nyomógomb. Ha a felhasználó rákattint, menjen a gomb a jobb fels sarokba, majd a jobb alsó, bal alsó, végül újra a bal fels sarokba, stb. 014 (új tulajdonságok: Form1.ClientWidth, Form1.ClientHeight) 15. Találjuk ki a gép által gondolt egész számot tippeléssel, ha a gép minden tipp után megmondja, hogy az kicsi vagy nagy! 015 (új tulajdonságok: Button1.Default, Button1.Cancel, új metódus: Edit1.SelectAll) 16. Készítsünk programot elektronikus pizza rendeléshez! A kért összetev ket jelöl négyzetekkel lehessen megadni. A program ezek alapján automatikusan a jelölés közben jelenítse meg a pizza árát! 016 (új tulajdonságok: CheckBox1.Checked, saját eljárás létrehozása, az összes 18. Színkeverés RGB színmodell alapján. A képerny n jelenjen meg három görget sáv, amely az RGB színmodell három alapszínét állítja be 0 és 255 között. A kikevert szín egy címke hátterében jelenjen meg! (ábra) 018 (új tulajdonságok: ScrollBar1.Min, ScrollBar1.Max,

238

239

ScrollBar1.Position, Form1.DoubleBuffered, új esemény: OnChange, új Windows API függvény: RGB)

adata a Push gomb hatására kerüljön a lista tetejére, míg a Pop gomb hatására a lista fels elem eleme kerüljön a beviteli mez be, és törl djön a listáról (ábra). A lista legfeljebb 10 lehet. Ha a lista tele van (Full) vagy üres (Empty), gomb hatására kapjunk hibajelzést ListBox1.Count, akkor a megfelel metódusok:

(üzenet ablak)! 025 (új tulajdonság: ListBox1.Items[0], új ListBox1.Items.Insert, ListBox1.Items.Delete)

19. Készítsünk csúszkás számológépet! A kért számot egy-egy vízszintes görget sáv tologatásával lehessen bevinni, majd a megfelel nyomógombra (feliratuk: Összeadás, Kivonás, Szorzás, Osztás) való kattintáskor jelenjen meg egy címkében az eredmény! 019 22. Sor bemutatása: a képerny n jelenjen meg egy lista és egy 20. Készítsünk programot, amely egy ListBox-ot tartalmaz. Ha rákattintunk a form-ra egérrel, duplán rákattintunk, vagy megnyomunk egy billenty t, írassuk ki a ListBox-ba az OnMouseDown, OnClick, OnMouseUp, OnDblClick, OnKeyDown, OnKeyPress, OnKeyUp események neveit olyan sorrendben, ahogy bekövetkeznek. 021 (tulajdonság: Form1.KeyPreview, metódus: ListBox1.Items.Add) 21. Verem demonstrálása: készítsünk egy alkalmazást, amely tartalmaz egy listát és egy beviteli mez t. A beviteli mez 23. Olvassunk be az InputBox függvény segítségével egy 3*4es mátrixot, melyet egy StringGrid komponensbe jelenítsünk meg. Számoljuk ki az elemek átlagát és szorzatát. 070 beviteli mez . A Push gomb hatására a beviteli mez tartalma kerüljön a lista tetejére, a Pop gomb hatására a lista alsó eleme kerüljön a beviteli mez be. A lista legfeljebb 10 elem lehet. Ha a lista tele van vagy üres, akkor a megfelel gomb generáljon hibajelzést! 026

240

241

069 25. oszlopainak és átlóinak összege azonos-e (az eredményt egy MessageBox segítségével jelenítsük meg). majd ellen rizzük. Olvassunk be egy 3*3-as mátrixot.24. mint a fels . Ne engedjük. Az alábbi példában szerepl mátrix b vös négyzet. 071 242 243 . hogy a mátrix b vös négyzet-e. hogy az intervallum alsó értéke nagyobb legyen. Írjuk ki a Sin függvény értékeit táblázatosan egy StringGrid komponensbe el re megadott intervallumban fokonként. azaz sorainak.

a program töltse ki a megadott mintával a nagyobb Image komponenst. és írja ki a megtalálás idejét. Készítsünk egy alkalmazást. 072 26. jelenítünk meg. Készítsünk programot. 077 244 245 .28. kirajzol amely egy egy nyomógomb egy image megnyomásakor komponensre. Ha valamelyik háttérmintára rákattintunk egérrel. 073 sakktáblát 29. Folyamatosan értékelje sebességünket (átlagos sebesség egy billenty lenyomására). amely tartalmaz egy nagyobb méret üres Image komponenst és négy kisebb Image melyekben különböz háttérmintákat komponenst. amely egy nyomógomb megnyomásakor kirajzolja egy image komponensbe a sin(x) függvény grafikonját. Programunk írja ki mely billenty t kell lenyomni. 027 27. Készítsünk egy alkalmazást.

hogy mennyiszer volt az adott szám kigenerálva. majd: néhány változatát. valamelyik képre rákattintunk egérrel. akkor minden egyes kattintás helyére a program "pecsételje oda" a kiválasztott rajzot. kicsinyített A program Ha alkalmazást. Ha újra megnyomjuk a nyomógombot. Amelyik szám(ok) az adott pillanatban a legtöbbször fordulnak el . A számítógép 0 és 19 közötti véletlen számokat generáljon ki és számolja az egyes számok el fordulását. azokat zöld oszlop helyett mindig pirossal szemléltessük. 076 246 247 . A számok generálását egy nyomógomb segítségével lehessen elindítani.31. melyet oszlopokkal szemléltessen. mellyel letörölhetjük a rajzlapot. Készítsünk tartalmazzon egy "pecsétel kép programot". A rajzot úgy rakjuk ki a rajzlapra. a számok generálása elölr l kezd djön. Mindegyik oszlop fölé írja oda. Az alkalmazásunk tartalmazzon még egy nyomógombot is. amely szemlélteti a véletlen számok eloszlását. Készítsünk 30. A program tehát a nyomógomb megnyomása után minden szám oszlopának magasságát beállítja nullára. majd a rajzlapra kattintunk (nagyobb méret Image komponens). hogy a kattintás helye (koordinátái) a kirajzolandó kép közepén legyen.

amíg valamelyik nem éri el a 99-et. a harmadik a nyomógomb Memo segítségével lehessen Az megváltozatni komponens bet típusát. hogy a nevek ABC sorrendben maradjanak). 080 32. tartalmát. Az összes nevet és telefonszámot a programból való kilépéskor mentsük el egy küls állományba. melyben nevek találhatók ABC sorrendben. A „Törlés” gombra kattintáskor a kijelölt nevet töröljük a névsorból. Készítsünk telefonkönyvet. ezeket piros oszloppal szemlélteti. a jobb oldalon jelenjen meg a név és a hozzá tartozó telefonszám. amely tartalmazni fog egy Memo komponenst és három nyomógombot. melyik számok el fordulása a legnagyobb. Az „Új szám” nyomógombra kattintáskor egy új (modális) ablakban kérjünk be egy nevet és egy telefonszámot. Az adott szám oszlopának magasságát megnöveli egy pixellel és fölé kiír eggyel nagyobb számot.• • Kigenerál egy 0-19 közötti véletlen számot. 049 33. 0. • Figyeli. alkalmazást b vítsük ki menüvel (MainMenu). majd olvassa be a program a Memo komponensünkbe a fájl 248 249 . Készítsünk programot. a többit zölddel. A program indításakor olvassuk be ebb l a fájlból a neveket. Az alkalmazás tartalmazzon egy ListBox-ot.01 secként) a kigenerált szám oszlopának magasságát mindaddig. akkor a jobb oldalon ne jelenjen meg semmilyen név és telefonszám). 081 • Kigenerálja a következ véletlen számot… A program a nyomógomb megnyomása után automatikusan m ködjön és növelje bizonyos id közönként (pl. Ilyenkor a jobb oldalon a törölt elem után következ (ha nincs akkor az el tte lev ) név jelenjen meg (ha nincs el tte lev sem. Ekkor a számok generálása álljon le. ahonnan szintén elérhet legyen ez a három funkció. melyet helyezzünk el a névsorban a megfelel helyre (úgy. A második nyomógomb mentse el a fájlt (dialógusablakkal lehessen megadni a fájl nevét és helyét). Ha valamelyik névre rákattintunk (kijelöljük). Az els nyomógomb egy dialógusablak segítségével válasszon ki egy TXT fájlt.

és újból lehessen tippelni valamelyik nyomógomb megnyomásával! 083 34. amelyre tippeltünk. különben csökkenjen 1-gyel. majd a csigák álljanak újra a rajtvonalra.35. Ha az a csiga nyert. Készítsünk „csigák versenye” játékot. akkor a pontszámunk növekedjen 3-mal. amíg valamelyik nem éri el az ablak jobb szélét. amely megjeleníti és folyamatosan mutatja (frissíti) az aktuális id t. Készítsünk alkalmazást. A nyertes csiga színét egy MessageBox segítségével írjuk ki. 079 250 251 . Mindegyik csiga véletlenszer hellyel menjen jobbra mindaddig. A csigák valamelyik gomb megnyomásával induljanak el.

4 x 10 .7 x 10 .5.6 x 10 4951 .20 19 . True Helyigény 1 bájt 1 bájt 2 bájt 4 bájt Pontosság 38 Helyigény Boolean 4 bájt 6 bájt 8 bájt 8 bájt ByteBool WordBool LongBool .16 39 38 324 308 324 308 252 253 . 2 63 Valós számok típusai: Típus Típus Single Real48 Real Double Értéktartomány . 1.. 1.5808 .1 x 10 4932 Egykarakteres szöveges változók: Típus Char PChar Értéktartomány 1 karakter változó Helyigény 1 bájt változó Többkarakteres szöveges változó: Típus String Értéktartomány felhasználó deklarálhatja ( pl... 65 535 . 1... 2 147 483 647 0 .7 x 10 .0 x 10 .5 x 10 ..20 19 . 127 0 . 255 ..2 147 483 648 . True False.5. String[50].2. 3.7 x 10 7-8 11 .16 15 ..0 x 10 45 Értéktartomány False.922337203685477.128 ..12 15 ...... 4 294 967 295 -2 63 Comp Currency Extended Helyigény 1 bájt 1 bájt 2 bájt 2 bájt 4 bájt 4 bájt 4 bájt 4 bájt 8 bájt Logikai változók: -2 63 + 1 . True False.1. 2 147 483 647 . 32 767 0 . 1.5807 . True False.9 x 10 .20 8 bájt 8 bájt 10 bájt .32 768 .. 2 63 19 . 4 294 967 295 0 .Melléklet: Leggyakrabban használt változók Egész számok típusai: Típus Shortint Byte Smallint Word Integer Longint Cardinal Longword Int64 Értéktartomány ..3. String[255] ) Helyigény aktuális hossz + 1 bájt + 1 .2 147 483 648 . 922337203685477.

ISBN: 963-618-307-4. Budapest. I. Kiskapu Kft. Brno. ISBN: 963-930166-3. Computer Press. 2002 [3] Kuzmina Jekatyerina.Melléklet: Magyar .Angol . Dr. Tamás Péter. 2003 254 255 .Szlovák szótár Magyar integrált fejleszt i környezet menü eszköztár ablak tervez elempaletta objektum felügyel forráskód szerkeszt tulajdonságok események metódusok eseménykezelés vizuális komponenskönyvtár alkalmazás program interfész (alkalmazásprogramozási felület) Angol integrated development environment (IDE) menu toolbar form designer tool palette object inspector code editor properties events methods handle event visual component library (VCL) application program interface (API) Szlovák integrované vývojové prostredie hlavná ponuka panel nástrojov návrhár formuláru paleta komponent object inspector editor programového kódu vlastnosti udalosti metódy obsluha udalosti knižnica vizuálnych komponentov rozhranie pre vývoj aplikácií Irodalomjegyzék: [1] Václav Kadlec: Delphi Hotová řešení. ISBN: 80-251-0017-0. ComputerBooks. Computer Press. ISBN: 807226-627-6.. Budapest. 2003 [2] Steve Teixeira. 2005 [4] Marco Cantú: Delphi 7 Mesteri szinten. Praha. Xavier Pacheco: Mistrovství v Delphi 6. kötet. Tóth Bertalan: Programozzunk Delphi 7 rendszerben!.