Programozás | Java, JSP » Data parancsnok - J2ME alapok

Mikrós kávé – avagy hogyan lehet kávéivás közben telefonálni 1. A mikrós kávé készítésének titka – Mi az a J2ME? Mint azt már az előző jegyzetemben is kifejtettem (ha nem olvasták volna – ami nagy hiba :-) –, innen megszerezhetik), ez a legkisebb Jáva 2-es platform. A Java Micro Editiont kifejezetten mobiltelefonokra illetve egyéb kisképernyős, zsebben is elférő eszközökre fejlesztettek ki (pl. Palmtop, PDA) Nyelvi szabályait tekintve megegyezik a J2SE és J2EE specifikációkban leírtakkal, csak nem támogatja azok összes osztályát. Tehát a mikrós kávé lehet, hogy nem adja vissza a hagyományos kávék ízét, de van olyan bolti kávé, ami ehhez hasonlóan alig hozza extázisba az ízlelőbimbókat. 1.1 Alapfogalmak, rövidítések • • • • • • • • • • • • • • • CDC (Connected Device Configuration): olyan konfiguráció, ami több megabájtnyi memóriával rendelkező, nagyteljesítményű eszközökhöz

(pl. InternetTV, kommunikátor vagy egyéb osztott, hálózatra kapcsolt eszköz) készült. Általában TCP/IP protokollt használnak és JVM-en alapulaz ilyen eszközök CLDC (Connected Limited Device Configuration): kisebb, korlátoltabb hordozható eszközökhöz (pl. mobiltelefon) készült konfiguráció. Általában nem TCP/IP-re épül az ilyen eszközök kommunikációja és általában igaz az ilyen eszközökre, hogy elemmel mûködnek, korlátozott memória kapacitással és korlátozott feldolgozási teljesítménnyel rendelkeznek, valamint alacsony sávszélességű a kapcsolatuk. J2ME API: optimalizált, kis méretű; nincs osztály-függőség J2ME Runtime Environment: dinamikusan konfigurálható futtatási környezet, ami egy adott alkalmazás futtatásához szükséges környezetté alakítható, ha az eszköz támogatja a profilt, amire a programot írtuk. JAD (Java Application Descriptor): egy .jad kiterjesztésű fájl, ami kötött formában információkat

tartalmaz a midletről, így még a JAR fájl letötlése előtt megállapítható, hogy alkalmas-e az alkalmazás az eszközre. Enélkül nem lehet letölteni a JAR-t [Kávéellenőr, KÖJÁL :)] JAM (Java Application Manager): Jáva alkalmazás menedzser [A mikrós kávét kiszolgáló pincér(nő)] JAR (Java Archive Resource): archivált, tömörített Jáva program; a JAM feltételezi, hogy ilyen formátumban tároltak az alkalmazások a letöltéshez. Ebben vannak a class fájlok és az egyéb erőforrások (pl. képek), valamint az ún manifest file-t is JAR fájlokat az SDK-ban lévő jarexe futtatásával hozhatunk létre. JCC (JavaCodeCompact): segédlet (utility), ami lehetővé teszi, hogy a KVM-be beépítsük a bájtkódot (így csökken az indulási ideje). JCP (Java Communication Process): a J2ME virtuális gépeit, a konfigurációkat és a profilokat specifikálja KVM (K Virtual Machine): a CLDC alapú készülékek C nyelven írt virtuális gépe; neve kis méretére

(pár 10 KB) utal; olyan 16/32-bites RISC/CISC mikroprocesszorokkal/vezérlõkkel rendelkezõ eszközökhöz alkalmazható, melyek legalább 160 Kbyte memóriával rendelkeznek. Ebbõl 128 kilobájt tárolja az aktuális virtuális gépet és a könyvtárakat. [Japán, mikrohip-alapú minikávéfőző] Manifest file: egy .mf kiterjesztésű szöveges fájl a JAR-ban, ami a szvitről tartalmaz információt kötött tartalommal. MIDlet: MIDP alkalmazás; csak a MIDP és a CLDC specifikációkban definiált API-t használja. [Mikrós kávé] MIDP (Mobile Information Device Profile): az első, CLDC alapú készülékekhez készült profil; olyan funkciókat határoz meg, mint például a felhasználói felület használata, utánvilágítás-tárolás, hálózati mûködés, és alkalmazás modell; pl. ilyet használnak a Nokia készülékei [Kávékészítésre alkalmas mikró] MIDPEG (Mobile Information Device Profile Expert Group): a MIDP-t készítő cégcsoport (tagjai pl. Motorola,

Nokia, Sun stb.) Suite [swi:t]: MIDletek együttese; ez van a JAR-ban; magyarul: szvit 2. Mitől más, mint a hagyományos kávé? – a J2ME és a J2SE különbségei CLDC-re nézve 2.1 Mit hagytak ki? • • • • • • • • a lebegõpontos adattípusok (double, float). JNI (Java Native Interface) (minden olyan natív kódot, melyet a virtuális gép hív meg fordítási idõben, be kell linkelni közvetlenül a KVM-be) finalize() metódus. szálcsoportokat és démon szálak felhasználó-definiált Java-szintû osztálybetöltõ korlátozott a hibakezelés (a java.langError legtöbb leszármazottja nem támogatott) nem lehet *-os importhivatkozást használni a csomagok osztályainál, mert nem minden JDK osztályt tartalmaz a J2ME AWT, Swing (a képernyőket a program maga alakítja ki vagy előregyártott képernyőkből választ) 2.2 Mit változtattak? • • • • • • a CLDC implementáció (KVM + API) méretének kisebbnek kell lennie, mint 128

kilobájt egy alkalmazás maximális futtatási területe egy 32 kilobájtos Jáva kupac (heap). más szemétgyűjtő algoritmus más hibafelismerési algoritmus (a J2SE-s változat túlságosan memóriaigényes volt) a KVM kódjai megírásához ANSI C kompatibilis fájlokat használtak, tehát C nyelven írták őket (a virtuális gép könnyen átvihető oda, ahol C fordító van) a .class fájlok nem futtathatóak (először elő-ellenőrizni kell őket egy preverifyexe nevű programmal, ami bepakolja a megfelelt osztályokat egy ./output jegyzékbe) 2.3 Mi maradt a régiben? • • • • ugyanazt a Jáva nyelvet használja (kávéból van ez is) hordozhatóság wrapperek és natív függvények használata a host rendszerfüggvények meghívásához (a JNI helyett) az alábbi csomagok és osztályok (a dőlt betűsek interfészeket jelölnek): • java.lang : Object, Boolean, Byte, Character, Class, Integer, Long, Runtime, Sort, System, Thread, Runnable, String, StringBuffer,

Throwable, Math, Exception, ClassNotFoundException, IllegalAccessException, InstantiationException, InterruptedException, RuntimeException, ArithmeticException, ArrayStoreException, ClassCastException, IllegalArgumentException, IllegalThreadStateException, NumberFormatException, IllegalMonitorStateException, IndexOutOfBoundsException, ArrayIndexOutOfBoundsException, StringIndexOutOfBoundsException, NegativeArraySizeExceptoin, NullPointerException, SecurityException. Error, VirtualMachineError, OutOfMemoryError • java.util : Vector, Stack, Hashtable, Enumeration, Calendar, Date, TimeZone, Random, EmptyStackException, NoSuchElementException • java.io : InputStream, OutputStream, ByteArrayInputStream, ByteArrayOutputStream, DataInput, DataOutput, DataInputStream, DataOutputStream, Reader, Writer, InputStreamReader, OutputStreamReader, PrintStream, EOFException, IOException, InterruptedException, UnsupportedEncodingException, UTFDataFormatException 3. Hogyan működik a mikró? –

A MID eszközök felépítése 3.1 Tulajdonságai • • • • Képernyõ: • méret: 96×54 • színmélység: 1 bit • torzítási arány: 1:1 Input: • egykezes billentyûzet (ITU-T); pl. szokványos mobiltelefon készülék • kétkezes billentyûzet (QWERTY); pl. PalmTop • értintõ képernyõ Memória: • 128 Kbyte non-volatile memória (tartalmát megőrzi a készülék) a MIDP komponenseknek • 8 Kbyte non-volatile memória az alkalmazás által létrehozott perzisztens adatoknak • 32 Kbyte volatile memória a Java futtatásnak Hálózat: Kétirányú, rádiós, esetleg idõszakos, korlátolt sávszélességgel 3.2 Mikrós kávék – MIDletek Minden MIDlet tartalmaz egy osztályt, amely a javax.microeditionmidletMIDlet osztály leszármazottja, és olyan további osztályokat, amelyek szükségesek a MIDlet számára. Ez azért kell, mert egy MIDlet nem rendelkezhet public static void main() metódussal. A MIDlet az az egyed, amelyet az alkalmazás vezérlõ

szoftver elindít, azaz létrehozza egy példányát. A MIDP definiál egy JRE-t a MIDletek számára, ezáltal elérhetõek lesznek a következők: • a CLDC-t és a virtuális gépet implementáló osztályok és natív kód • a MIDP-t implementáló osztályok és natív kód. • a végrehajtandó egyszerû JAR fájl minden osztálya. • a jad kiterjesztésű, szöveges leíró fájl tartalma. 3.21 Használati utasítás – A JAD leíró fájl tartalma (A MIDletek attributumai) • • • • • • • • • • • MIDlet-Name: a MIDlet készlet neve. Kötelezõ (Pl: RanErodOstroma) MIDlet-Version: a MIDlet készlet verziója (major.minormicro) A micro rész elhagyható Minden értéknek 0 és 99 között kell lennie. Kötelezõ (Pl: 104) MIDlet-Vendor: a MIDlet készletet szolgáltató szervezet. Kötelezõ (Pl: MacokCORPS) MIDlet-Icon: a MIDlet készletet reprezentáló ikont tartalmazó PNG fájl neve. (Pl: fortranpng) MIDlet-Description: a MIDlet készlet

leírása. (Pl: ) MIDlet-Info-URL: egy URL, amely információkat tartalmaz a MIDlet készletrõl. (Pl: http://www.progmathu/midletek/PMInfojar) MIDlet-X : az X. MIDlet neve, ikonja és osztálya a JAR fájlon belül A legkisebb értéknek 1-nek kell lennie. A MIDlet osztályának rendelkeznie kell egy publikus, argumentum nélküli konstruktorral Kötelezõ (Pl.: MIDlet-1: ProgmatBivaly, /kepek/bivalypng, PMBotokBivaly; MIDlet-2: ProgmatMacok, /kepek/macok.png, PMBotokMacok) MIDlet-Jar-URL: az az URL, ahonnan a JAR fájlt letöltöttük. (Pl.: http://wwwprogmathu/midletek/PMjar) MIDlet-Jar-Size: a JAR fájl mérete bájtokban. (Pl: 12674) MIDlet-Data-Size: a MIDlet által igényelt minimális perzisztens adat bájtokban. Alapértelmezésben nulla MicroEdition-Profile: egy érvényes J2ME profil megnevezése. Kötelezõ (Pl: MIDP-10) MicroEdition-Configuration: egy érvényes J2ME konfiguráció megnevezése. Kötelezõ (Pl: CLDC-10) 3.22 Egy egyszerű mikrós kávé receptje

import javax.microeditionmidlet* public class MikrosKave extends MIDlet { public MikrosKave() { // a kávé melegítése és kiöntése csészébe } public void startApp() { // a csésze szájhoz emelése } public void pauseApp() { // a csésze lerakása } public void destroyApp(boolean kellefeltetel) { // a csésze elmosása } } Ez egy egyszerű MIDlet elkészítési receptje (de ebben nincs se cukor, se tejpor). A három alapvető függvényen kívül persze még bőven tartalmazhat saját metódusokat. A fenti program-modell kifejtve: public void startApp(); - a MIDlet Aktív állapotba lép lefoglalja a memóriaterületeket; ha nem sikerül elindítani a MIDletet, akkor a MIDletStateChangeException kivételt generálja. Csak akkor lehet meghívni, ha a MIDlet Szüneteltetett állapotban van. public void pauseApp(); - a MIDlet Szüneteltetett állapotba lép lefoglalja a memóriaterületeket; ha bármilyen hiba keletkezik, az MIDlet megszűnik. Csak akkor lehet meghívni, ha a

MIDlet Aktív állapotban van. public void destroyApp(boolean kellefeltetel) – ha az argumentuma true, akkor felszabadít minden lefoglalt memóriaterületet, ha false, generálja a MIDletStateChangeException kivételt. 3.23 Hogyan rakjuk be a kávét a mikróba? 1. 2. 3. 4. 5. A programozó .java kiterjesztésű fájl(ok)ba megírja a forráskódo(ka)t A kódo(ka)t lefordítja byte-kód(ok)ra. Ennek eredménye egy (vagy több) class kiterjeszésű fájl A mobiltelefonunk, vagy egyéb hodozható információs eszközünk azonban nem tudja közvetlenül ezeket a fájlokat futtatni. Neki egy JAR fájlra van szüksége Az SDK tömörítőprogramjával készítünk egy .jar kiterjesztésű fájlt, amibe becsomagoljuk az összes MIDletünket, valamint az .mf kiterjesztásű fájlt Ez alkotja a szvitet Egy szvit azonban nem biztos, hogy felhasználható mindegyik készülékfajtára, úgyhogy szükség van egy fájlra, ami ellenőrzi, hogy megfelel-e a készülék követelményeinek.

Ez az alkalmazás leíró, egy jad kiterjesztésű fájl. A tartalma alapján eldönthető, hogy alkalmas-e a programunk Ha igen, az alkalmazás letölthető a megfelelő WAP kapcsolaton keresztül a JAD-ban megadott URL címről. 4. A mikrós kávék nagyító alatt – a J2ME csomagjai, osztályai 4.1 A java.util csomag mikrós szemmel 4.11 A mikró időzítőjének beállítása – a Timer osztály Az időzítő feladatait hajtja végre egy háttérben futó szálként, ütemezi őket egy későbbi futtatáshoz, ami lehet egyszeri vagy szabályos időközönkénti újraindítás. Alapvetően nem daemon-process, úgyhogy késleltetheti egy alkalmazás befejeződését (ha szeretnénk, hogy terminálódjon, hívjuk meg az időzítő cancel metódusát). Az osztály szálbiztos (thread-safe): több szál megoszthat egy Timer objektumot anélkül, hogy külső szinkronizációra lenne szükség. Nem garantált a valós idejű (real-time) végrehajtás, az időzítő a wait

módszert használja az ütemezéshez, így eszközfüggő a késleltetés valódi mértéke. Periodikus ismétlés esetén kétféle jellegű módszert használhatunk: Kötött késleltetésű végrehajtás (fixed-delay execution): ha a periódusban a feladat végrehajtását valami (szemétgyűjtő algoritmus, hiba) késlelteti, az ismételt végrahajtások is elcsúsznak időben. Ilyenre van szükség az animációknál, nyomvatartott billentyűk esetén vagy meghatározott időközönkénti kurzorvillogtatásnál, egyszóval olyan esetekben, ahol fontosabb a folyamatosság, mint a pontosság. A vonatkozó tagfüggvény: schedule. Kötött ismétlődésű végrehajtás (fixed-rate execution): megpróbálja kiküszöbölni a csúszást; Pontos szinkronizációknál használatos. A vonatkozó tagfüggvény: scheduleAtFixedRate Esetlegesen generált kivételei: IllegalArgumentException – ha negatív értéket állítottunk be a késleltetésnek IllegalArgumentException – ha az

adott feladatot már végrehajtották vagy kivették a listáról vagy az időzítőt lekapcsolták. Tagfüggvényei: • public void schedule(TimerTask feladat, long kesleltetes); - egy (ezredmásodpercben megadott) bizonyos időtartam múlva hajtja végre az adott feladatot. Meghívható egy adott időpontra is, ha a második paraméterében egy Date típusú dátumot adunk meg. • public void schedule(TimerTask feladat, long kesleltetes, long periodus); - a második paraméterben megadott időtartam múlva periodus időközönként végrehajtja az adott feladatot. Megadható dátum is neki, amitől kezdve ismétli a feladatot A csúszás kiküszöbölésére ugyanezzel a paraméterszignatúrával meghívhatjuk a scheduleAtFixedRate nevű metódust is. • public void cancel(); - leállítja az időzítőt, megakadályozva a további ismétlődést vagy egy esetleges későbbi futtatást. 4.12 Időzített feladatok – a TimerTask osztály Tagfüggvényei: • public abstract

void run(); - lefuttatja a szükséges alkalmazást (a Runnable interfészfől való ez a módszer) • public boolean cancel(); - leveszi a végrehajtási listáról az adott feladatot. Visszatérési értéke true, ha a feladat egyszeri végrahajtásra ütemezték és jelenleg nem fut, vagy periodikus ismétlésre van beállítva. Akkor false, ha egyszeri végrehajtású, és éppen fut, vagy ha már nincs a listán vagy nem is volt rajta. Magyarán szólva: igaz értékkel tér vissza, ha sikeresen megakadályozta az ütemezett feladat(ok) végrehajtását, minden egyéb esetben hamis. • public long scheduledExecutionTime(); - megadja a legközelebbi, még nem futó feladat végrehajtásának idejét a Date.getTime() metódushoz hasonló formában 4.2 A javax.microeditionio csomag 4.21 Hova dugjuk a mikrót? – A Connector osztály Ezen osztály segítségével létesíthetünk távoli kapcsolatot a tagfüggvények első paraméterében URL címen keresztül. Az

opcionális második paraméterrel a hozzáférés módját szabhatjuk meg (írás, olvasás, mindkettő), a harmadik, szintén opcionális argumentum pedig arra vonatkozik, hogy akarunk-e kivételt generálni időtúllépés esetén. Mivel I/O-ról van szó, minden függvénye generálja a java.ioIOException kivételt I/O hiba esetén, valamint további kivételeket: IllegalArgumentException – ha nem megfelelő a paraméter; ConnectionNotFoundException – ha nem létesíthető kapcsolat a megadott címhez, vagy nem létezik a megadott protokolltípus; SecurityException – ha nem engedélyezett a belépés. Adattagjai: • public static final int READ – olvasás (az 1-es egész értéknek megfelelő) • public static final int READ WRITE – írás és olvasás (2-es egész érték) • public static final int WRITE - a 3-as egész értékhez az írási módot rendelték Tagfüggvényei: • public static Connection open(String URLcim, int kapcsmod, boolean kellekivetel); -

kapcsolat létesítése; csak az első paraméter kötelező, a másik kettő opcionális. • public static java.ioInputStream openInputStream(String URLcim); - a megadott címre kapcsolatot létesít és megnyit egy bemeneti folyamot. A fenti lenyomatban az InputStream szövegrész helyébe írhatunk OutpuStream-et, DataInputStream-et vagy DataOutputStreamet is, melynek hatására a kapcsolat létesítésekor megnyílik az adott irányú (adat)folyam. 4.3 A javax.microeditionlcdui csomag Osztályhierarchia a csomagban • class java.langObject • class javax.microeditionlcduiAlertType • class javax.microeditionlcduiCommand • class javax.microeditionlcduiDisplay • class javax.microeditionlcduiDisplayable • class javax.microeditionlcduiCanvas • class javax.microeditionlcduiScreen • class javax.microeditionlcduiAlert • class javax.microeditionlcduiForm • class javax.microeditionlcduiList • class javax.microeditionlcduiTextBox • class javax.microeditionlcduiFont

• class javax.microeditionlcduiGraphics • class javax.microeditionlcduiImage • class javax.microeditionlcduiItem • class javax.microeditionlcduiChoiceGroup • class javax.microeditionlcduiCustomItem • class javax.microeditionlcduiDateField • class javax.microeditionlcduiGauge • class javax.microeditionlcduiImageItem • class javax.microeditionlcduiSpacer • class javax.microeditionlcduiStringItem • class javax.microeditionlcduiTextField • class javax.microeditionlcduiTicker 4.31 *BÍÍÍP KÉSZ A KÁVÉ! – az AlertType osztály A hierarchia ábécé sorrendben az első elemével az Alert osztály objektumainak típusát határozhatjuk meg, valamint hanggal is egyértelműbbé, észrevehetőbbé tehetjük a figyelmesztetéseket. Adatagjai (public static final AlertType típusú mindegyik): • INFO – olyan üzenetek átadására szolgáló típus, amelyek nem izgatják fel a felhasználót • WARNING – veszélyre figyelmeztető üzenetek átadására

szolgáló típus • ERROR – hibaüzenetek átadására szolgáló típus • ALARM – értesítő üzenetek (találkák, ébresztés) átadására szolgáló típus • CONFIRMATION – megerősítő üzenetek (pl. „Célpont bemérve!”) átadására szolgáló típus Tagfüggvénye: • public boolean playSound(Display megejelenito); - a készülék ilyen esetekben használt hangjával is értesíti a felhasználót; a visszatérési érték a figyelmeztetés sikerére vonatkozik. Ha a paraméter null, NullPionterException kivétel keletkezik. 4.32 „Főzz kávét!” és egyéb parancsok – A Command osztály Szemantikus információkat tartalmaz egy parancs kiváltotta hatásról (tehát nem magát a parancsalgoritmust tartalmazza). A hatást (action) az CommandListener interfész definiálja és a public void commandAction(Command parancs, Displayable megjelenit); módszerével rendeli hozzá a megjeleníthető objektumhoz egy parancson keresztül. Egy parancsobjektum

jelképezhet finombillentyűt, menüelemet, hangutasítást vagy más olyan dolgot, amit a felhasználó közvetlenül elérhet. Ha a parancs nem képezhető le közvetlenül a készülékeken lévő gombokra vagy egyszerű utasításokra, akkor a menün keresztül lehet megvalósítani azt. Egy parancs négyféle információt tartalmaz: egy rövid cimkét (short label) egy opcionális hosszú cimkét (long label), egy típust (type) és egy prioritást (priority). Címkék: egy szöveges változók, amik tudatják a felhasználóval, hogy az adott parancs mit vált ki (lásd pl. a jobb és bal alsó sarokban lévő kis rubrikákat a mobiltelefonokon). A rövid címke egy minimális hosszúságú szöveget jelent (pl. „Start”), a hosszú címke pedig egy kifejtett szöveget jelent (pl „Új játék indítása”) Implementációfüggő, hogy melyikre van hely, de a rövid címke mindenképp elfér. Ha elfér a hosszú címke és be van állítva, akkor az érvényes Típus: azt

határoza meg, melyik finombillentyűhöz ven rendelve. Pl egy CANCEL típusú parancsot a kis Cvel jelölt gombbal aktivizálhatunk Az adattagok ezeket a típusokat képviselik Prioritás: az ugyanazon képernyőn megjelenő parancsok közti fontossági sorrendet szabályozó egész érték. Minél kisebb, annál fontosabb (a legfontosabb az 1-es értékű parancs). Ha ugyanannyi a prioritása két parancsnak, ami ugyanazon a képernyőre fejti ki hatását, akkor előállásuk sorrendje a mérvadó. Az adott parancs nem csinál semmit önmagában, a fenti commandAction függvény definiálja az általa kiváltott hatást. Konstruktorai: • public Command(String rovidCimke, String hosszuCimke, int tipus, int prioritas); - a második paraméter el is maradhat, vagy null esetén érvénytelen. MEGJEGYZÉS: ahol nincs feltüntetve a konstruktor, az paraméter nélkül inicializálódik. Adattagjai (mindegyik public static final int; implementációfüggőek): • SCREEN – a teljes

képernyőt kezelő parancs (pl. Mentés/Betöltés); értéke 1 • BACK – visszalép az előző képernyőhöz; értéke 2. • CANCEL – negatív válasz, helyenként a BACK funkcióival bír; értéke 3. • OKAY – pozitív válasz (a CANCEL párja); előrelépés a következő képernyőre; értéke 4. • HELP – on-line súgó; értéke 5. • STOP – megállít valamilyen éppen futó folyamatot; értéke 6. • EXIT – kilépés egy alkalmazásból; értéke 7. • ITEM – a képernyő egy megadott elemét vagy egy Choice komponenst kezelő parancs; értéke 8. Tagfüggvényei: • public • public • public • public 4.33 String getLabel(); - megadja a rövid cimkét String getLongLabel(); - megadja a hosszú cimkét (null-t, ha nincs) int getCommandType(); - megadja a parancs típusát int getPriority(); - megadja a parancs prioritás értékét A mikró képernyővezérlője – A Display osztály Ezzel az osztállyal állíthatjuk be a képernyőt,

kezelhetjük bemeneti eszközt és kapcsolhatjuk be a készülék egyéb funkcióit (pl. rezgetés) Szoros kapcsolatban áll a Displayable osztállyal, mert minden megjelenített objektumot ennek az osztálynak az objektumai tartalmaznak, tehát a Display objektumok a megjelenítést valósítják meg (tulajdonképpen a képernyőkezelést), a Displayable objektumok meg azok, amiket megjelenítenek. Azt mondjuk egy alkalmazásról, hogy előtérben van, ha ténylegesen megjeleníthető és a bemeneti eszköz eseményei eljutnak hozzá. Ha nem nyúl az input és a megjelenítő eszközhöz, akkor azt mondjuk, háttérben van Az osztály adattagjai különböző típusú képernyőelemek. Adattagok (mindegyik public static final int): • LIST ELEMENT – egy List objektumnak megfelelő kép; értéke 1. • CHOICE GROUP ELEMENT – egy ChoiceGroup objektumnak megfelelő kép; értéke 2. • ALERT – egy Alert objektumnak megfelelő kép; értéke 3. • COLOR BACKGROUND – a háttér

színe; értéke 0. • COLOR FOREGROUND – az előtér színe; értéke 1. • COLOR HIGHLIGHTED BACKGROUND – a kiemelt háttér színe; értéke: 2. • COLOR HIGHLIGHTED FOREGROUND – a kiemelt előtér színe; értéke: 3. Az előtér színe és a háttér színe mindig kontrasztban áll egymással. A háttér színe alatt a képernyő alapszínét értjük, a kiemelt háttér színe pedig a kitöltött téglalapok színét határozza meg. Az előtér a szövegelemekre, ábraelemekre vonatkozik. • • COLOR BORDER – a keret színe; téglalapok, formák szegélyének színe; értéke 4. COLOR HIGHLIGHTED BORDER – a kiemelt keret színe; értéke 5. Tagfüggvények: • public int getColor(int szinTerulet); - visszaadja az adattagok közül választott terület (ez a paraméter) színét 0x00RRGGBB formában. • public int getBestImageWidth(int kepTipus); - visszaadja az adattagok közül választott képernyőtípus (lista, choice group vagy alert) legalkalmasabb

beállításakor mért szélességét (ha nincs ilyen, akkor 0-val tér vissza). • public int getBestImageHeight(int kepTipus); - ugyanaz, mint az előbb, csak a magasságra vonatkozik. • public int getBorderStyle(boolean kiemelt); - megadja a (kiemelt) keret stílusát (pontozott – Graphics.DOTTED; vagy folyamatos – GraphicsSOLID) • public boolean isColor(); - megállapíthatjuk vele, hogy az eszközünk támogatja-e a színes megjelenítést • public int numColor(); megállapíthatjuk vele, hogy az eszközünk színskálája/szürkeárnyalata meddig terjed • public int numAlphaLevels(); - megállapíthatjuk vele, hogy az eszközünkön mennyire lehet áttetszővé tenni a megjelenített objektumokat (lásd bővebben az Image osztálynál) • public Displayable getCurrent(); - megadja az aktuálisan megjelenített objektumot. • public void setCurrent(Displayable ujKepernyo); - megjelenít egy új objektumot; ez általában nem azonnal következik be a

függvényhívás után. Ha az aktuális objektum Alert típusú, akkor e helyébe lép az új objektum (mintha nem is lenne ott az a figyelmeztetés). Ha meg akarjuk tartani az Alert-et, akkor használjuk azt első paraméterként, második paraméterként pedig a figyelemfelkeltő • • 4.34 jelzés után megjeleníteni kívánt objektumot (ami nem lehet sem null, sem Alert, különben NullPointerException vagy IllegalArgumentException kivételt generál). A függvény azonnal visszatér, függetlenül az Alert idejétől. Az egyparaméteres formát meg lehet még hívni Itemmel is. public boolean flashBacklight(int idotartam); - egy meghatározott időtartam erejéig felkapcsolja a készülék háttérvilágítását (vagy fényesre erősíti, ha tompítottra van állítva). Az idortartam-ot ezredmásodpercben kell megadni (ha negatív értéket adunk meg, IllegalArgumentException kivételt generál). A visszatérési érték a sikerességet jelzi public boolean vibrate(int

idotartam); - meghatározott ideig rezgeti a telefont; a paraméterre és a visszatérési értékre vonatkozóan lásd az előző függvényt! Mit látunk a mikró ablakán át? – A Displayable osztály Ezen osztály objektumai megjelenhetnek a kijelzőn. Beállíthatunk hozzájuk parancsot, címet, folyamatosan futó szöveget (távírószalagot – ticker-tape) stb. Alapesetben azonban nem tartozik hozzá semmi, és nem jelenik meg a kijelzőn sem. Tagfüggvényei: • public int getWidth(); - megadja a megjeleníthető felület szélességét (pixelben) • public int getHeight(); - megadja a megjeleníthető felület magasságát (pixelben) • public Ticker getTicker(); - megkaphatjuk vele a megjeleníthető felület futó szövegét. • public String getTitle(); - megadja a megjeleníthető felület címét • public void setTitle(String cim); - megadja a megjeleníthető felület címét; ám ügyelni kell arra, hogy megfelelően tegyük ezt, mert a cím átállítása

futási idő alatt befolyásolja a tartalmazó terület méretét. Ha null-t adunk meg, akkor nem lesz címe az objektumnak • public void setTicker(Ticker szalag); - megkaphatjuk vele a megjeleníthető felület futó szövegét; ugyanúgy ügyelni kell rá, mint a cím esetében. • public void addCommand(Command parancs); - parancsot rendel a megjeleníthető objektumhoz. Ha a megadott parancs már a képernyőn fut, akkor nincs hatása a függvény hívásának NullPointerException kivételt generál, ha a parancs értéke null. • public void removeCommand(Command parancs); - eltávolítja az objektumhoz rendelt parancsot. Ha nincs hozzárendelve az adott parancs, a hatás nem következik be :) Ha a parancs null, a függvény nem csinál semmit. • public boolean isShown(); - megmondja, hogy az adott objektum látható-e éppen a képernyőn. • protected void sizeChanged(int szel, int mag); - az implementáció meghívja ezt a függvényt, ha az objektum méretét

megváltoztatták; a paraméterek az új magasság illetve szélesség értékeket tartalmazzák. A méret általában az objektum tartalmában való módosítás során változhat meg 4.35 A mikró gombjainak kezelése, vásznak – A Canvas osztály A Displayable osztály egyik alosztálya, ami az alacsony szintű események kezelésére és bizonyos grafikai elemek képernyőn való megjelenítésére használatos (mintha egy vászonra rajzolnánk). Elérhetjük általa egy szabványos ITU-T típusú egykezes billentyűzet számbillentyűit és az egyéb gombokat (*, #). Az ezeknek megfelelő billentyúkódok az Unicode karakterkészlet adott karaktereit jelölik Azok, amiknek nincs megfelelője a karakterkészletben, negatív értékűek, az érvénytelen karakter pedig a 0. Felhasználási területe azonban főként a játékok, játékalkalmazások, ugyanis adattagjaival elérhetjük a különböző vezérlőbillentyűket is (irányok, tűzgomb, játékgombok). Ahol nincsenek

külön iránybillentyűk, ott a 2, 3, 6, illetve 8 számbillentyűk kódját adja az irányváltozókra meghívott getKeyCode() metódus. Az ugyanazon paraméterekkel meghívott getGameAction() módszer azonban minden esetben irányok kódját adja majd. A billentyűkkel, mutatókal, mozgatással vagy rajzolással összefüggő metódusokat csak azután lehet meghívni, hogy meghívtuk a showNotify() módszert, azaz miután az objektumot ténylegesen láthatóvá tettük a képernyőn. A hideNotify() tagfüggvény meghívása után az ilyen módszerek csak azután fejthetik ki hatásukat, miután meghívtuk a showNotify()-t. Egy Canvas objektum lehet normál vagy teljes képernyős módban. Az előbbi esetén van hely a parancscimke, egy folymatosan futó szöveg vagy egyéb feliratok megjelenítésére, míg az utóbbinál a képernyő lehető legtöbb pixelét magáénak mondja az alkalmazás. A mutatók, billentyűk lenyomására, lenyomva tartására ill. felengedésére

három tagfüggvény szolgál, melyeket általában feltételként szoktunk használni. Pl if (VaszonkeyRepeated(FIRE)) { } - ha lenyomva tartjuk a tűzgombot, akkor ezt és ezt csinálja. Esetlegesen keletkezendő kivételek: • IllegalArgumentException – ha a paraméter nem megfelelő Adattagjai (mindegyik public static final int): • UP - a FEL játékgomb; értéke 1. • DOWN - a LE játékgomb; értéke 6. • LEFT - a BALRA játékgomb; értéke 2. • RIGHT - a JOBBRA játékgomb; értéke 5. • FIRE - a TŰZ játékgomb; értéke 8. • GAME A - az A játékgomb; értéke 9. • GAME B - a B játékgomb; értéke 10. • GAME C - a C játékgomb; értéke 11. • GAME D - a D játékgomb; értéke 12. • KEY NUM0 – a 0-s számbillentyű; értéke 48. • KEY NUM1 - a 1-es számbillentyű; értéke 49. • KEY NUM2 - a 2-es számbillentyű; értéke 50. • KEY NUM3 - a 3-as számbillentyű; értéke 51. • KEY NUM4 - a 4-es számbillentyű; értéke 52. • KEY NUM5

- a 5-ös számbillentyű; értéke 53. • KEY NUM6 - a 6-os számbillentyű; értéke 54. • KEY NUM7 - a 7-es számbillentyű; értéke 55. • KEY NUM8 - a 8-as számbillentyű; értéke 56. • KEY NUM9 - a 9-es számbillentyű; értéke 57. • KEY STAR - a csillagnak (*) megfelelő billentyű; értéke 42. • KEY POUND - a kettőskeresztnek (#) megfelelő billentyű; értéke 35. Tagfüggvényei: • A Displayable osztályból ismert getWidth(), getHeight() metódusok a Canvas objektum méreteinek leérdezésére (pixelben). • public boolean isDoubleBuffered(); - megállapítja, az objektum kétszeresen pufferelt-e. • public boolean hasPointerEvents(); - megállapítja, hogy a platform támogatja-e a mutató (azaz amolyan egér jellegű) gombok lenyomását/felengedését • public boolean hasPointerMotionEvents(); - megállapítja, hogy a platform támogatja-e a mutató mozgatását (amolyan egérkurzor mozgatását, vonszolást). • public boolean hasRepeatEvents(); -

megállapítja, hogy a platform támogatja-e az ismétlő jellegű eseményeket (pl. gomb lenyomva tartása) • public int getKeyCode(int jatekGomb); - visszatér az adott készüléken lévő, a paraméterben megadott billentyű kódjának értékével. Ha támogatja a játékbillentyűket, akkor annak a kódjával, ha nem akkor a megfelelő számbillentyű kódjával (lásd még fent). • public String getKeyName(int billKod); - visszatér az adott készüléken lévő, a paraméterben megadott billentyűkódhoz tartozó billentyű nevével. Ha játékgombok nevét szeretnénk megkapni, akkor a getKeyName(getKeyCode(jatekGomb)); összetett függvényt kell meghívnunk. • public int getGameAction(int billKod); - visszatér az adott készüléken lévő, a paraméterben megadott billentyűkódnak megfelelő játékgomb kódjával, vagy 0-val, ha nincs hozzátartozó kód. • public void setFullScreenMode(boolean teljesKep); - teljesképernyőssé állítja az objektumot, ha a

paraméter true és normál módba rakja, ha false. • • • • • • • • • • • • • 4.36 protected void keyPressed(int billKod); - az adott billentyű lenyomásakor hívjuk meg protected void keyRepeated(int billKod); - az adott billentyű lenyomva tartásakor hívjuk meg protected void keyReleased(int billKod); - az adott billentyű felengedésekor hívjuk meg protected void pointerPressed(int x, int y); - mutatóbillentyű az objektumon belüli adott ponton való lenyomásakor hívjuk meg. protected void pointerReleased(int x, int y); - mutatóbillentyű az objektumon belüli adott ponton való felengedésekor hívjuk meg. protected void pointerDragged(int x, int y); - mutatóbillentyű az objektumon belüli adott ponton való megragadásakor hívjuk meg (vonszoláshoz pl.; elengedni a pointerReleased metódussal lehet). protected abstract void paint(Graphics grObj); - kirajzol a képernyőre egy a következő tulajdonságokkal grafikai objektumot: •

fekete színű • alapértelmezett betűtípusú • SOLID átrajzolású • a Canvas objektum bal-felső sarkától indul ki a koordináta-rendszere • a Canvas objektumot láthatóvá teszi A grafikai objektum által meghatározott minden egyes pixelt ki kell tölteni, különben a korábbi képernyő darabkái is ott maradnak, hiszen nincs képernyőtörlés a hívás előtt. Ezen kívül a tartalom sohasem marad meg, ha eltüntetjük az Canvas objektumot a képernyőről. A kép megfelelő módosítására a repaint utasítások szolgálnak, úgyhogy ne próbáljunk meg másként hivatkozni a paint paraméterére. A függvény visszatérése után a paraméterben megadott grafikai objektumon végzett mindennemű operáció hatástalan, tehát ezeket a metóduson belül kell megoldani. Csak az implementáció hívhatja meg ezt a függvényt! public final void repaint(int x, int y, int szeles, int magas) – az objektum téglalapban megadott részét újrarajzolja; lásd még majd

a Graphic osztályban. public final void repaint() – az egész objektumot újrarajzolja; lásd még majd a Graphic osztályban. public final void serviceRepaints(); - kiszolgálja az objektumhoz tartozó összes függésben lévő repaint kérelmet (ha van), azaz azonnal végrehajtja őket, s blokkol minden más tevékenységet (KIVÉVE a paint() fonalait, mert az holtpont (deadlock) kialakulásához vezethet). Ha nincs egy sem függésben, vagy még nem látható az objektum, akkor nem csinál semmit. protected void showNotify(); - az objektum megjelenítése a képernyőn protected void hideNotify(); - az objektum eltüntetése a képernyőről protected void sizeChanged(int szel, int mag); - ha teljesképernyőssé bővül, vagy normál méretűre csökken az objektum mérete, az alkalmazás meghívja ezt a függvényt. Ha akkor váltotat méretet, amikor a képernyőn látható, magával vonz egy automatikus repaint hívást is (az már implementációfüggő, hogy csak bizonyos

részeket fest újra, vagy az egész képernyőt). Ha nem látható, akkor késleltethető ez a hívás a legközelebbi megjelenítésig. A kijelző képernyője – A Screen osztály A Displayable osztály másik alosztálya, ami a képernyő tartalmát, s voltaképpen az összes magas szintű felhasználói interfész-osztályt jelképezi. Alosztályai segítségével kezelhetjük 4.361 A értesítő képernyő – Az Alert osztály Ez egy olyan képernyőfajta, ami valamilyen üzenetről értesíti a felhasználót, majd vár egy bizonyos ideig, mielőtt átváltana a következő képernyőre. Tartalmazhat szöveget és/vagy képet Mozgókép esetén csak egy adott pillanatkép jelenik meg, változni csak egy újabb képbeállítási metódus (setImage) hívásával fog. Háromféle időtartam lehetséges: megszabott ideig, örökre vagy észrevételi parancsig. Ez utóbbi kettő például valamilyen gomb lenyomásáig vagy egy parancs kiváltotta hatás bekövetkezéséig tart.

A háttérben mindig marad egy „észrevételi parancs”, ami visszaállítódik, ha az összes parancsot ki is töröltük. Ezt a parancsot explicit nem lehet beállítani, sem előhívni, csak a megfelelő tagfüggvényeken keresztül. Aktivitási jelző: egy Gauge típusú objektum, ami jelzi az aktivitást. Vonatkozik rá azonban néhány megszorítás: • non-interaktívnak kell lennie, azaz a felhasználó nem szólhat bele a működésébe; • nem lehet megosztva egy másik (Alert vagy Form) tartalmazással; • nem lehetnek parancsai; • nem lehet ItemCommandListener-je; • nem lehet cimkéje (azaz null értékűnek kell lennie a cimkéjének); • kivitelezésének alapértékűnek kell lennie (LAYOUT DEFAULT). Konstruktorai: • public Alert(String cim, String uzenet, Image kep, AlertType tipus); ha bármelyik null, akkor az objektum nem rendelkezik azzal az attributummal. Az utolsó három paraméter el ismaradhat, ha közülük mindegyik null. Az utolsó

argumentum (tipus) az értesítés viselkedését és kezelését szabályozza. Adattagok: • public static final int FOREVER – észrevételig (pl. egy gomb lenyomása) a képernyőn marad az értesítő üzenet/kép. Értéke: -2 • public static final Command DISMISS COMMAND – egy megszabott parancs jelképezi majd az észrevételt, amíg az üzenet a képernyőn maradhat. A parancs cimkéje egy üres sztring (nem null!!!), típusa OKAY, prioritása 0. Lásd még fent Tagfüggvények: • public int getDefaultTimeout(); - ezredmásodpercben megadja az alap időtartamot, amíg az Alert objektum látható. • public int getTimeout(); - ezredmásodpercben megadja a beállított időtartamot, amíg az Alert objektum látható. Ha a szöveg vagy kép túl nagy ahhoz, hogy egyetlen képernyőn elférjen, görgethető lesz, és ebben az esetben az időtartam FOREVER értékűvé válik, függetlenül attól, mit állítottunk be a setTimeout módszerrel. • public void

setTimeout(int idotartam); - beállíthatjuk, meddig legyen látható a a képernyőn az értesítő üzenet/kép. Ha nem megfelelő a paraméter (nem pozitív és nem is -2), akkor IllegalArgumentException kivétel keletkezik. • public AlertType getType(); - megkaphatjuk vele az objektum típusát • public String getString(); - megkaphatjuk vele az értesítő üzenetet • public Image getImage(); - megkaphatjuk vele az értesítő képet • public Gauge getIndicator(); - megkaphatjuk vele az objektumhoz rendelt aktivitási jelzőt, ami Gauge típusú (bár igencsak le van korlátozva; lásd fent). Az utóbbi három metódusból a getTimeout / setTimeout mintájára könnyen kitalálható, mik a beállítási függvények nevei, illetve azok paraméter-típusa és visszatérési érték-típusa. • • 4.362 public void addCommand(Command parancs); - első meghíváskor megadhatunk neki egy észrevételi parancsot, későbbi meghíváskor egyéb parancsokat rendelhetünk

hozzá. Hívása a DISMISS COMMAND argumentummal hatástalan. Ugyanilyen szignatúrával, csak removeCommand néven eltávolíthatjuk a parancsokat (a DISMISS COMMAND kivételével persze). public void setCommandListener(CommandListener parancsfigyelo); beállítható az objektumhoz egy parancsfigyelő. Ha a paraméter értéke null, a default figyelő lesz hozzárendelve az objektumhoz. Az űrlap – A Form osztály Az űrlap programozási szempontból képek, szövegek, szöveg- és adatmezők, grafikonok, választható elemek egyvelege, tehát normális esetben az Item bármelyik alosztálya használható elemként egy űrlapban. Ha az alkalmazás olyan elemet akar beilleszteni egy űrlapba, ami már benne van valamelyik Form objektumban, akkor IllegalStateException keletkezik, azaz egy elem egyszerre csak egy objektumban lehet benne. Egy űrlap méretlét a benne lévő elemek száma határozza meg Az űrlap tartalma sorokra osztott. Egy adott Form objektumban minden sor

ugyanolyan széles, a sor magassága a sorban szereplő elemektől függ. Az elemek implementációtól függő módon megjeleníthetőek jobbról-balra, vagy balról-jobbra. Az űrlap tetején mindig kell lennie egy üres sornak, ebbe kerülnek az elemek a megfelelő sorrendben, az űrlap megfelelő szélétől kezdve. Be lehet állítani különböző tördelési szabályokat (Jobbra szedett, balra szedett, középre szedett), amiket az ImageItem osztály adattagjai szolgáltatnak. Mielőtt beraknánk egy elemet a sorba, akkor mindig megnézzük, ven-e számára elég hely. A sortörés megvalósulhat a felhasználó szabályai szerint is (pl. minden cimkével rendelkező Item elem után tördeljen), vagy az alábbi „gyári” módokon is: Sortörés az adott elem ELŐTT valósul meg: • sortörést jeleztek az előző elem után • érvényes a LAYOUT NEWLINE BEFORE irányelv • " "-nel kezdődő StringItem-nél • ChoiceGroup, DateField, Gauge vagy TextField

esetén, ha a LAYOUT 2 irányelv nincs beállítva • az adott elem tördelési beállítása (LAYOUT LEFT, LAYOUT CENTER vagy LAYOUT RIGHT) különbözik az űrlap tördelési beállításától Sortörés az adott elem UTÁN valósul meg: • " "-nel végződő StringItem-nél • érvényes a LAYOUT NEWLINE AFTER irányelv • ChoiceGroup, DateField, Gauge vagy TextField esetén, ahol LAYOUT 2 irányelv be van állítva A sortörést tartalmazó cimkék megkurtíthatóak úgy, hogy a sortörés utáni részük ne látszódjon. Esetlegesen keletkezendő kivételek: • NullPointerException – ha az elemeket tartalmazó tömb, vagy egy elem értéke null. • IllegalStateException – ha a beillesztendő elemet már tartalmazza egy űrlap. • IndexOutOfBoundsException – ha az index nem a 0.méret-1 határ közé esik Konstruktorai: • public Form(String cim, Item[] elemek); - létrehoz egy űrlapot a megadott tartalommal, de lehet üres is (a második paraméter

opcionális, de nem lehet null). Tagfüggvényei: • a Displayable osztályból ismert getWidth, getHeight méretlekérdező függvények. • public int append(Item ujelem); - űrlap tartalmának bővítése egy elemmel; az elem az adott sor végére kerül. Paraméterként megadható még neki az Item objektum helyett String vagy Image objektum is (alapesetűre szűkítve az adott elemfajtát). • public void insert(int index, Item elem); - új elem beszúrása a megadott • public void delete(int index); - megadott elem törlése • public void deleteAll(); - az elem törlése • public void set(int index, Item elem); - elem áthelyezése máshová; ha eredetileg volt ott valami, akkor azt felülírja. • public Item get(int index); - megkapjuk vele az adott indexű elem referenciáját • public int size(); - megadja az űrlap méretét (elemszámát) • public void setItemStateListener(ItemStateListener elemFigyelo); rendelhető az űrlaphoz egy elemfigyelő objektum (vagy

a meglévő módosítható egy új figyelővel), ami a változásokat figyeli. Eltávolíthatjuk az aktuális figyelőt, ha a paramétert null értékkel adjuk meg. 4.363 A lista – A List osztály Egy listát tartalmaz, amelynek elemei közül választhatunk, lépegethetünk közöttük stb. Viselkedésében és API-jában sok hasonlóságot a ChoiceGroup osztállyal mutat (pl. mindkettő implementálja a Choice interfészt és ugyanazok a módszereik). A lépegetés és a választás a készülék megefelelő billentyűjével valósítható meg („Select”, „Go” vagy egyéb finombillentyűk). Az elemkiválasztást tekintve többféle listát is létrehozhatunk, amelyeket az implementált Choice interfész adattagjai alapján különböztetünk meg: kizárólagos (exclusive), többszörös (multiple), implicit (implicit) és előreugró (popup). Kizárólagos lista: a válsztás nem parancson keresztül van megoldva, hanem mindig kizárólag az aktuális elemet tekintjük

a választott elemnek (így nincs sok értelme a cimkéknek). Ha tehát mondjuk a 3 elemen vagyunk, akkor ezt választottuk ki, s továbblépés után már a 4. elem lesz kiválasztva Többszörös lista: egyszerre több elemet is kiválaszthatunk az elemek megjelölésével. Implicit lista: egy megadott parancsot hívhatunk a listaelem kiválasztásával (ilyen pl. a menü is) Előreugró lista: a választott elem mindaddig látható, amíg a felhasználó nem hajt végre bizonyos lépéseket. Esetlegesen keletkezendő kivételek: • IndexOutOfBoundsException – ha a megadott index értéke nem megfelelő. • IllegalArgumentException – ha a többszörös listáknál a kiválasztást vizsgáló logikai tömb mérete kisebb, mint a lista mérete (ha nagyobb, a maradék elem false lesz) vagy az elhelyezési stratégia értéke nem megfelelő (0,1 vagy 2 lehet). • NullPointerException – ha a String típusú listaelem vagy többszörös listáknál a kiválasztást vizsgáló

logikai tömb értéke null. Konstruktorai: • public List(String cimke, int fajta, String[] elemek, Image[] kepelemek); - inicializál egy megadott fajtájú lista objektumot a megfelelő elemekkel. A második két paramléter elmaradhat, de ha az egyiket kitesszük, akkor mindkettőt ki kell tenni, s a két tömb méretének meg kell egyeznie. A kép nélküli elemeknél az Image[] megfelelő elemét null értékűnek kell beállítani. Adattagja: • public static final Command SELECT COMMAND – egy SCREEN típusú kiválasztó parancs, üres sztring cimkével és 0-s prioritással. Tagfüggvényei: • public int size(); - megkaphatjuk vele a lista méretét (elemszámát) • public int append(String elem, Image kepelem); - a lista bővítése egy új elemmel, ami a lista végére kerül • public void insert(int index, String elem, Image kepelem); - elem beszúrása az index változóban megadott helyre. • public void delete(int index); - a megadott listaelem törlése •

public void deleteAll(); - a lista összes elemének törlése • public void set(int index, String elem, Image kepelem); - a második és harmadik paraméterben megadott elem áthelyezése a listában az első paraméternek megfelelő helyre; ha volt ott valami, azt felülírja. • public boolean isSelected(int index); - megállapítja, hogy az adott indexű elem ki van-e választva. • public int getSelectedIndex(); - megadja a kiválasztott elem indexét (ha nincs ilyen, akkor –1 a visszatérési érték). • public int getSelectedFlags(boolean[] kivalasztasiTomb eredmenye); megadja, hány elem van kiválasztva a paraméterében megadott listában. Argumentuma eredmény paraméter, azaz a függvény hívása után megváltozik. A tömb méretének legalább akkorának kell lennie, mint a listának. • public void setSelectedIndex(int index); - megjelöli vagyis kiválasztja az adott elemet. • public int setSelectedFlags(boolean[] kivalasztasiTomb); - többszörös lista

esetén egy logikai tömbbel megadhatjuk, mely elemeket választjuk ki. Kizárólagos, implicit és előreugró listák esetén az első kiválasztás érvényes, minden további elemre a választás hatástalan, valamint ha egyet sem választunk, az elsőt jelöli meg. • • • 4.364 public void setFitPolicy(int elhelyezes); - beállíthatjuk vele a Choice osztályból ismert elhelyezési stratégiákat (lásd később), azaz azt, hogyan helyezkednek el a képernyőn a listaelemek. Az int visszatérési értékű, paraméter nélküli getFitPolicy-vel megkaphatjuk ezt az értéket public void setFont(int index, Font betutipus); - beállíthatjuk vele az adott szövegelem betűtípusát public Font setFont(int index); - megkaphatjuk általa az adott szövegelem betűtípusát A szövegdoboz – A TextBox osztály A szövegszerkesztőkből is ismert szövegdobozszerű képernyő-objektumokat lehet vele elkészíteni. A szövegdoboz maximális mérete a beleírható karakterek

számát jelenti, az aktuális mérete pedig az éppen benne lévő karakterek számával egyenlő. A szövegdobozban lehet görgetni a szöveget (transzparens módon persze), így annak bármely részét szerkeszthetjük. Esetlegesen keletkezendő kivételek: • IllegalArgumentException – ha a szöveg hossza nagyobb, mint a méret; ha a méret nem pozitív értékű; ha a szöveg nem felel meg a megszabott TextField korlátozásoknak; ha a megszorításra vonatkozó paraméter érvénytelen. • StringIndexOutOfBoundsException – ha a szövegrész nem esik bele a szövegdobozba • ArrayIndexOutOfBoundsException – ha szövegrész nem esik bele a megadott tömbbe, vagy nem fér el benne. • NullPointerException – ha vizsgált szövegrész null. Konstruktora: • public TextBox(String cim, String kezdoszoveg, int meret, int megszoritas); - létrehoz egy szövegdobozt a megadott szöveggel, mérettel és bizonyos megszorításokkal, amiket a TextField osztályban lévő

adattagok közül választhatunk ki. Tagfüggvényei: • public String getString(); - megkaphatjuk vele a szövegdoboz tartalmát. • public void setString(String szoveg); - átírhatjuk vele a szövegdoboz tartalmát. • public int getChars(char[] mit masol); - egy karaktertömbbe másolhatjuk vele a szövegdoboz teljes tartalmát; a karakterek darabszámával tér vissza. • public void setChars(char[] mit masol, int honnan, int hossz); - egy karaktertömb megadott részét a szövegdobozba másolhatjuk. • public void insert(String mit, int hova); - egy szöveget beilleszt a szövegdoboz adott indexű karaktere elé (az első karakter előtti hely a 0. pozíció) • public void insert(char[] mit, int honnan, int hossz, int hova); - egy karaktertömb meghatározott részét beilleszti a szövegdoboz adott indexű karaktere elé (az első karakter előtti hely a 0. pozíció) • public void delete(int honnan, int hossz); - törli a szövegdoboz tartalmának adott részét •

public int getMaxSize(); - megadja a szövegdoboz méretét • public int setMaxSize(int meret); - átméretezi a szövegdobozt • public int size(); - megadja, hogy a dobozban éppen hány karakter van • public int getCaretPosition(); - megadja a kurzor pozícióját; alapesetben 0. • public int getConstraints(); - megadja a szövegdobozra vonatkozó megszorítások kódját • public void setConstraints(int megszoritas); - bemeneti megszorításokat állíthatunk be a szövegdobozhoz (lásd a TextField osztályban). 4.37 A mikró feliratainak tulajdonságai – A Font osztály Ezzel kezelhetjük a betűtípusokat. Egy betűtípusnak van stílusa (style), mérete (size) és megjelenése (face) A stílusok kombinálhatóak egy | (logikai VAGY) jellel (értékeik ekkor összeadódnak), a másik kettő nem. A méret rendszerfüggő, a betűk egymáshoz való méretkülönbségét jelzi. Az alapesetek: STYLE PLAIN – normál stílus; FACE SYSTEM – a rendszer

alapbetűformája; SIZE MEDIUM – közepes betűméret. Ha tehát nem állítjuk be külön, akkor ezek érvényesek Adattagjai (public static final int mindegyik): • STYLE PLAIN – normál betűstílus; értéke 0. • STYLE BOLD – félkövér betűstílus; értéke 1. • STYLE ITALIC – dőlt betűstílus; értéke 2. • STYLE UNDERLINE - aláhúzott betűstílus; értéke 4. • • • SIZE SMALL – kis betűméret; értéke 8. SIZE MEDIUM – közepes betűméret; értéke 0. SIZE LARGE – nagy betűméret; értéke 16. • • FACE SYSTEM – a rendszer alapbeállítása; értéke 0. FACE MONOSPACE – „azonos nyomtávú”, azaz minden betű egyforma méretű helyet igényel (ilyen pl. a Courier betűtípus is); értéke 32 • FACE PROPORTIONAL – „proporcionális”, azaz minden betű különböző méretű helyet igényel (pl. Times New Roman); értéke 64. • FACE STATIC TEXT – elem rajzolásához és képernyőtartalom beállításához használt

alapértelmezett betűtípus módosító; értéke 0. • FACE INPUT TEXT – a felhasználó által beírt szöveg rajzolási beállítására használt betűtípus módosító; értéke 1. Tagfüggvényei: • public static Font getDefaultFont(); - a rendszer alap betűtípusával tér vissza • public static Font getFont(int fajta, int stilus, int meret); - visszatér a megadott tulajdonságokkal rendelkező betűtípussal; ha nincs ilyen, akkor a leginkább hasonlót veszi elő; mindig visszatér, még ha komoly eltérések vannak a megadott és a kapott típus között. IllegalArgumentException-t generál, ha nem megfelelően adtuk meg a paramétereket. • public static Font getStyle(); - megadja az adott betűtípus stílusát • public static Font getSize(); - megadja az adott betűtípus méretét • public static Font getFace(); - megadja az adott betűtípus megjelenési fajtáját • public static int getHeight(); - megadja az adott típusú betű szabvány magasságát

• public static int getBaseLinePosition(); - pixelben megadja a szöveg tetejétől az aljáig mért távolságot • public boolean isBold(); – félkövér-e a betűtípus; hasonlóképpen meghívhatjuk a többi stílusra is: isItalic(); – dőlt-e a betűtípus; isPlain(); - normál-e a betűtípus; isUnderlined(); - aláhúzott-e a betűtípus; • public int charWidth(char kar); - megadja az adott betűtípussal írt karakter szélességét • public int charsWidth(char[] kar, int kezd index, int hossz); ugyanazt eredményezi, mint az előző, csak ez egy adott karaktertömb meghatározott részére vonatkozik. ArrayIndexOutOfBoundsException-t generál, ha a megadott részterület nem megfelelő értékű (negatív vagy nagyobb, mint a tömb), valamint a NullPointerException-t, ha a kar értéke null. • public int stringWidth(String szoveg); - megadja az adott betűtípussal írt szöveg szélességét • public int substringWidth(String szoveg, int kezd index, int hossz);

- ugyanaz, mint az előbbi, csak egy szövegrészre vonatkozik; a kivételeit lásd a charsWidth függvénynél. 4.38 A mikró díszítései – A Graphics osztály Kétdimenziós grafikai műveleteket valósíthatunk meg a Graphics típusú objektumokkal, rajzolhatunk különböző geometriai síkidomokat, vonalakat, s ki is színezhetjük őket, 24 bites színmélységben (8-8 bit a vörös, zöld és kék összetevőkre). Persze nem minden készülék támogatja a színeket, vagy ha mégis, nem biztos, hogy kihasználhatjuk mind a 24 bitet. Az ilyen esetekben az implementációnak megfelelő színekhez rendeli a készülék a különböző színeket (pl. szürkeárnyalatok is így jönnek létre) A képek Porter és Duff „forrást a cél fölé” szabálya alapján jelennek meg a képernyőn. A forrás pixeleit a cél pixelei fölé helyezik, így a teljesen átlátszó forráspixelek érintetlenül hagyják az adott célpixeleket, a teljesen átlátszatlan forráspixelek

pedig teljes mértékben kitöltik az adott célpixeleket. A félig átlátszó forráspixelek az alfa értéküktől függően töltik ki a célpixeleket (az alfáról bővebben majd az Image osztálynál olvashatsz). Az alapértelmezett koordináta-rendszer a képernyő balfelső sarkától kezdődik (ez a (0,0) pont). A pontok (x,y) formában jelöltek. Az x-tengely balról jobbra halad, az y-tengely pedig felülről lefelé, azaz minél messzebb kerülünk az origótól, annál nagyobb az értéke a koordinátáknak (negatív koordináta nincs). A koordinátákat egész értékekkel mérjük. Klippnek nevezzük a Graphics objektum területén belül egy adott pixelcsoportot, amit különböző metódusokkal megváltoztatunk. A rajzolt szöveg vagy kép ún. horgonypontokon (anchor points) keresztül illeszkedik be a megfelelő helyre Ezek segítségével a lehető legkisebb számításokkal megjeleníthetőek. A horgonypontokhoz viszonyítva beállítható elhelyezkedésük

(középre, balra, felülre stb.) Úgy képzelhetjük el, hogy a szöveg vagy kép egy hajó és horgonyt vet egy pontba. Pl ha felülre helyezzük a szöveget/képet, akkor a horgonypont a szöveg/kép fölött van. A vízszintes horgonyvetéseket lehet kombinálni a függőlegesekkel egy | jellel, ekkor értékeik összeadódnak Esetlegesen keletkezendő kivételek: • IllegalArgumentException – ha a paraméter (horgony, vonalstílus, színek, transzformáció) nem megfelelő értékű. • StringIndexOutOfBoundsException – ha a szövegrész nem esik bele a szövegbe • ArrayIndexOutOfBoundsException – ha szövegrész nem esik bele a megadott tömbbe. • NullPointerException – ha kirajzolandó elem (szöveg, kép) értéke null. Adattagjai (public static final int mindegyik): • HCENTER – a horgonypont körül vízszintesen középre helyezi a képet vagy a szöveget; értéke 1. • LEFT – a horgonypontot a képek vagy szövegek bal oldalára helyezi; értéke 4. •

RIGHT – a horgonypontot a képek vagy szövegek jobb oldalára helyezi; értéke 8. • • • • • • VCENTER – a horgonypont körül függőlegesen középre helyezi a képet vagy szöveget; értéke 2. TOP – a horgonypontot a képek vagy szövegek fölé helyezi; értéke 16. BOTTOM – a horgonypontot a képek vagy szövegek alá helyezi; értéke 32. 20 17 24 BASELINE – a horgonypontot a szöveg alapvonalához helyezi; értéke 64. 6 3 10 SOLID – folyamatos vonalstílus; értéke 0 (alapértelmezett). 36 33 40 DOTTED – pontozott vonalstílus; értéke 1. Ha a horgonypont értéknek 0-át adunk meg, akkor az a LEFT | TOP beállításnak megfelelőt eredményezi. Tagfüggvényei: • public void drawLine(int x1, int y1, int x2, int y2); - egyenes vonalat húz az (x1,y1) pontból az (x2,y2) pontba az aktuális színnel és vonalstílussal. • public void drawRect(int x, int y, int szeles, int magas); - rajzol egy (x,y) pontból kiinduló szeles×magas téglalapot

az aktuális színnel és vonalstílussal. A megrajzolt téglalap kerete miatt +1 pixelt rá kell számolni a szélességre és a magasságra. Ha bármelyik érték negatív, nem jelenik meg semmi. • public void drawRoundRect(int x, int y, int szeles, int magas, int ivSz, int ivM); - ugyanaz, mint az előbbi, csak a téglalap sarkait begörbíti. Az utolsó két paraméter az ív magasságát ill. szélességét adja meg a sarkokhoz viszonyítva (azaz a színezett részeket) • public void drawArc(int x, int y, int szeles, int magas, int ivKezdete, int ivSzoge); - rajzol egy ívet az aktuális színnel és vonalstílussal egy megadott téglalap alakú területen (x,y,szeles, magas) belül; a második két paraméter az ív kezdetét jelzi, valamint az ívszög értékét (+ : órajárással ellentétes, - : az óra járásával megegyező irányban). Az ív a téglalap széléig lesz megrajzolva. • • • • • • • • • • • • • • • • • • • •

• • • • • • • • 4.39 public void drawString(String szoveg, int x, int y, int horgony); kirajzol egy szöveget az aktuális színnel és betűtípussal; az (x,y) pont a horgonypont helyzetét jelöli, amihez képest a horgony értéke alapján a szöveget megrajzoljuk. public void drawChar(char kar, int x, int y, int horgony); - egy karakter kirajzolása az aktuális színnel és betűtípussal (a paramétereket lásd előbb). public void drawImage(Image kep, int x, int y, int horgony); - egy kép kirajzolása; ha a célterület maga a grafikai objektum, a hatás definiálatlan. public void drawSubstring(String szoveg, int honnan, int hossz, int x, int y, int horgony); - a szoveg adott részét rajzolja ki az aktuális színnel és betűtípussal. public void drawChars(char[] karTomb, int honnan, int hossz, int x, int y, int horgony); - a karTomb adott részét rajzolja ki az aktuális színnel és betűtípussal. public void drawRegion(Image kep, int x1, int y1, int

szeles, int magas, int tr, int x2, int y2, int horgony); - a megadott kép egy régióját (x1,y1, magas, szeles) áttranszformálja az (x2,y2) pontba a tr-nek megfelelő transzformációval, amit a javax.microeditionlcduigameSprite osztály adattagjaiból vesz. public void copyArea(int x1, int y1, int szeles, int magas, int x2, int y2, int horgony); - az (x1,y1) pontból kiinduló a grafikai objektum adott téglalapnyi tartalmát átmásolja az (x2,y2) pontból kiinduló területre (aminek szintén az objektumon belülre kell esnie, a kilógó részek nem jelennek meg). Keletkezhető kivételek: IllegalArgumentException – ha a másolandó terület nagyobb, mint az objektum; IllegalStateException – ha az (x2,y2) pont a grafikus objektumon kívülre esik. public void translate(int x, int y); - eltolja a grafikai objektumot az adott koordináta rendszer (x,y) pontjába. A hívásai összeadódnak, azaz, például, egy translate(7,3); majd egy translate(2,1) egy (9,4) pontba való

eltolást eredményez. public int getTranslateX(); - megadja az eltolt pont eredeti x koordinátáját public int getTranslateY(); - megadja az eltolt pont eredeti y koordinátáját public int getColor(); - megadja az aktuális színt (0x00RRGGBB) public int getDisplayColor(int szin); - megadja annak a színnek a kódját, amit a készülék megjelenít az aktuális szín hatására; ezáltal szabályozhatjuk a színeket. public int getRedComponent(); - megadja az aktuális szín vörös színtartalmát (0-255) public int getGreenComponent(); - megadja az aktuális szín zöld színtartalmát (0-255) public int getBlueComponent(); - megadja az aktuális szín kék színtartalmát (0-255) public int getGreyScale(); - megadja az aktuális színt szürkeárnyalatban (0-255) public int getStrokeStyle(); - megadja az aktuális vonalstílust public int getClipX(); - megadja a klip x koordinátáját (a nyíllal jelölt pontban) public int getClipY(); - megadja a klip y koordinátáját (a

nyíllal jelölt pontban) klip public int getClipHeight(); - megadja klip magasságát public int getClipWidth(); - megadja a klip szélességét public Font getFont(); - megadja az aktuális betűtípust public void setFont(Font btipus); - beállíthatjuk vele az aktuális betűtípust public int setClip(int x, int y, int szeles, int magas); - áthelyezi és/vagy átméretezi az aktuális klipet public void setColor(int RGB); - beállítható az aktuális szín (0x00RRGGBB) public void setColor(int voros, int zold, int kek); - beállítható az aktuális szín (komponensenként 0-255) public void setGreyScale(int arnyalat); - beállítható egy szürkeárnyalat a színezésekhez (0-255) public setStrokeStyle(int korvonal); - beállítható vele az aktuális vonalstílus (0-1) Képek a mikrón – Az Image osztály Ezzel az osztállyal képeket készjthetünk az alkalmazáshoz. Megkülönböztetünk mozgó- vagy változtatható képeket (mutable images) ill. állóképeket (immutable

images) Az utóbbi fajtába tartozó képeken létrehozásuk után nem változtathatunk, míg a másik félék csak fehér pixeleket tartalmazó üres képként jönnek létre, s a megfelelő függvénnyel újra és újra megváltoztathatóak. A mozgókép csak teljesen átlátszatlan pixeleket tartalmaz, míg egy állóképben bármilyen alfa értékkel rendelkező pixel megtalálható. Egy mozgóképből készíthető állókép egy egyszerű createImage metódushívással, s ez fordítva is működik, csak bonyolultabb eljárás szükséges hozzá (ez benne van a hivatalos dokumentációban). Az alfa értéket a bitmélységből nyerjük, ami a mintánként bitek számát jelenti. Az alfa = 0 esetben teljesen átlátszatlan pixelről van szó; ha az alfa értéke 2bitmélység – 1 értékű, a pixel teljesen átlátszó; a kettő között félig átlátszó pixelről beszélünk. A képobjektum lehet egy PNG (Portable Network Graphics – Hordozható Hálózati Grafika)

formátumú (info itt), de vehetjük egy ARGB (Alpha-Red-Green-Blue) tömbből is. Ahhoz, hogy egy PNG képet megjeleníthessünk, a készüléknek teljesítenie kell az alábbi pontokban megfogalmazott követelményeket (amik voltaképpen az egyes chunkok támogatását jelentik): IHDR követelmény: • A PNG kép és a képobjektum hosszának illetve szélességének meg kell egyeznie. A túl nagy értékek memóriakapacitás hiányában nem biztos, hogy megjeleníthetőek. • Minden színt (akár alfa tartalommal együtt is) fel lehessen használni, bár a megjelenítés a készüléktől függ. • Az alfa tartalommal rendelkező színtípusokat (4 és 6) az alfa értéknek megfelelően tudnia kell dekódolni. • Bármely bitmélységet támogatnia kell. • A képtömörítést csak a nullás módszerrel lehet végrehajtani, ami a „zlib” tömörítési sémát követi (ezt használjuk a JAR fájlok esetén is), ezáltal a képkitömörítés kódja ugyanaz lesz, mint a JAR

kitömörítési kód. • A készüléknek támogatnia kell a nullás szűrőmódszer mind az 5 alaptípusát (None, Sub, Up, Average, Paeth). A szűréssel optimalizálható a tömörítés, mert kihasználja a képben a térbeli hasonlóságokat. • A készüléknek támogatnia kell mind a nullás (None), mind az egyes összeszövő módszert (Adam7). A képek betöltése szinkron jellegű és nem lehet átlapozni rendereléssel (azaz nincs előnye az interlace method 1-nek a nullással szemben). PLTE követelmény: a készüléknek támogatia kell a paletta alapú képeket is. IDAT követelmény: a képeket a nullás szűrőmódszer 5 alaptípusa alapján lehet kódolni. IEND követelmény: a kép érvényessége miatt tartalmaznia kell az IEND chunkot. Ezeken kívül van jó pár olyan chunk, amiket jó, ha támogat a készülék, de nem „életbevágóak”. Tagfüggvényei: • public int getWidth(); - megadja a kép szélességét (pixelben) • public int getHeight(); -

megadja a kép magasságát (pixelben) • public boolean isMutable(); - ha a visszatérési érték true, az adott kép változtatható, ha false, állóképről van szó. • public static Image createImage(int szeles, int magas); - létrehoz egy új változtatható képobjektumot. A kép még nem látható természetesen, ezt a Display osztály függvényeivel kell megvalósítani. Ha a paraméterek nem pozitívak, IllegalArgumentException kivétel keletkezik. • public static Image createImage(Image kep); - állóképet készít a nem null értékű kep objektumból. Ha a paraméterben megadott kép is állókép, akkor pusztán visszatér a függvény, anélkül, hogy bármit is megalkotna. Ha a paraméter null, NullPointerException kivétel keletkezik. • public static Image createImage(String nev); - állóképet készít a nem null értékű néven ismert forrásból. A nevek JAR fájlokban lévő erőforrások eléréséhez kellenek Vannak abszolút útvonalnevek (/ jellel

kezdődőek) és relatív útvonalnevek (nem / jellel kezdődőek). Az abszolút nevek a JAR-ban lévő létező fájlnevekre mutatnak, a relatívak pedig a MIDlet Suite JAR fájl tartalmára hivatkoznak. A relatív útvonalnevek abszolúttá konvertálódnak a dokumentációban leírt módon A java.ioIOExeption kivételt generálja, ha a kép nem tölthető be • public static Image createImage(byte[] adat, int honnan, int hossz); állóképet hoz létre egy bájttömbből kiolvasott adatból. Az adat-nak önazonosító formátumúnak kell lennie (pl. PNG), amit a készülék támogat Ha a megadott résztömb kilóg az adattömbből, ArrayIndexOutOfBoundsException kivétel keletkezik; ha az adattömb null értékű, • • • • NullPointerException kivétel keletkezik; ha a második két paraméter nem megfelelő, IllegalArgumentException keletkezik. public static Image createImage(Image kep, int x, int y, int szeles, int magas, int tr); - állóképet hoz létre egy

megadott pozícióban lévő forrás egy régiójából, amit esetleg transzformálhatunk a tr-ben megadott módon. Ha a tr értéke TRANS NONE, a megadott terület lefedi a teljes forrást, ami maga is állókép, akkor létrehozás nélkül pusztán visszatér a függvény. Ha a paraméterek nem megfelelőek (méret nem pozitív, a tr nem érvényes), akkor IllegalArgumentException kivétel; ha a kep értéke null, akkor NullPointerException kivétel keletkezik. public static Image createImage(java.ioInputStream beFolyam); - egy bemeneti folyamból kódol be egy képet. Ha nem tölthető be a kép, akkor javaioIOExeption kivétel keletkezik. public Graphics getGraphics(); - egy mozgóképhez létrehoz egy grafikai objektumot. Állóképhez érvénytelen a függvény hívása. Az grafikai objektum aktuális színe fekete lesz, a célterület és a klipterület pedig maga a képobjektum. Az aktuális betűtípus az alapértelmezett, a vonalstílus folyamatos, a koordináta-rendszer

origója a képobjektum bal-felső sarka. Az élettartama végtelen az ilyen módon létrehozott objektumoknak. public static Image createRGBImage(int[] rgb, int szeles, int magas, boolean vanAlfa); - egy színekből álló tömbből építi fel a képet a következő módszer segítségével: P(x,y) = rgb[x + y*szeles], ahol a<magas és b<szeles pozitív egészek. Ha a tömb null, NullPointerException keletkezik, ha a méret nem pozitív, IllegalArgumentExeption, ha pedig a tömb mérete kisebb, mint a behatárolt terület, akkor ArrayIndexOutOfBoundsException kivétel keletkezik. 4.310 A mikró alkatrészei – Az Item osztály Általában a Form objektumokhoz használjuk az elemeket. Egy elem elhelyezése az éppen érvényes tördelési direktívától függ, amit az adattagok közül választunk. A vízszintes és függőleges elhelyezési stratégiákat a Graphics-nál megismert módon lehet egymással kombinálni. Némelyik direktívának nincs hatása bizonyos

környezetben. Az elem mérete lehet minimális (minimum size) és alkalmas (preferred size). Az előbbi a legkisebb méretet jelenti, amit még képes megjeleníteni a készülék úgy, hogy használni lehessen az elemet. Az utóbbi a tördelések minimalizását lehetővé tevő előnyös méret. Az alkalmas méretet (akár külön-külön is) zárolni lehet egy adott értékre. Az adattagok között találhatunk olyan állandókat is, amik a megjelenítés módjáért felelnek. Háromféleképp jeleníthető meg egy elem: gombként, hiperhivatkozásként vagy normál módon. Az első interaktív használathoz jó, a második úgy használható, mint egy link a bögészőben, az utolsó pedig nem interaktív használatra alkalmas. Az alapbeállítás egy Item objektumnál a következő: • Nem tartalmazza az objektumot semmi. • Nem tartalmaz parancsot (az alapértelmezett parancs is null) • Nem tartalmaz parancsfigyelőt (ez is null) • A tördelési direktíva a LAYOUT DEFAULT

• Az alkalmas mérete nem zárolt. Adattagjai (public static final int mindegyik): • LAYOUT DEFAULT – alapértelmezett elhelyezési stratégia; értéke 0. • LAYOUT LEFT – balra tördelt elhelyezési stratégia; értéke 1. • LAYOUT RIGHT – jobbra tördelt elhelyezési stratégia; értéke 2. • LAYOUT CENTER – középre való elhelyezési; értéke 3. • LAYOUT TOP – felülre való elhelyezési stratégia; értéke 0x10. • LAYOUT BOTTOM - alulra való elhelyezési stratégia; értéke 0x20. • LAYOUT VCENTER – függőlegesen középre való elhelyezési stratégia; értéke 0x30. • LAYOUT NEWLINE BEFORE – az adott elemet egy sortörés után helyezi el; értéke 0x100. • LAYOUT NEWLINE AFTER – a következő elemet egy sortörés után helyezi el; értéke 0x200. • LAYOUT SHRINK – az elem szélessége a legkeskenyebb értékre csökken; értéke 0x300. • LAYOUT EXPAND - az elem vízszintes irányban kitölti a rendelkezésére álló teret;

értéke 0x800. • • • LAYOUT VSHRINK - az elem magassága a legalacsonyabb értékre csökken; értéke 0x1000. LAYOUT VEXPAND - az elem függőleges irányban kitölti a rendelkezésére álló teret; értéke 0x2000. LAYOUT 2 – ha aktív, a MIDP 2.0 elhelyezési szabályok érvényesek, ha nem a MIDP 10-s szabályok; értéke 0x4000. • PLAIN – normál megjelenési mód; értéke 0. • HYPERLINK – hiperhivatkozás megjelenési mód; értéke 1. • BUTTON – gomb megjelenési mód; értéke 2. Tagfüggvényei: • public void setLabel(String cimke); - beállít egy cimkét az elemhez; ha null, az objektumhoz nem tartozik címke. Nem érvényes a hívása Alert objektummal való kombinálás esetén, és IllegalStateException kivétel keletkezik. • public String getLabel(); - megadja az objektum cimkéjét. • public void setLayout(int direktiva); - beállíthatunk vele egy tördelési direktívát. Alert objektumokkal való kombináció esetén úgy viselkedik,

mint a setLabel módszer. Ha a paraméter nem megfelelő, akkor IllegalArgumentExeption keletkezik. • public int getLayout(); - megadja az érvényes tördelési direktívát. • public void addCommand(Command parancs); - beállíthatunk vele egy nem null parancsot az objektumhoz. Alert objektumokkal való kombináció esetén úgy viselkedik, mint a setLabel módszer. Ha a parancsobjektum értéke null, NullPointerException keletkezik • public void removeCommand(Command parancs); - eltávolíthatunk vele egy parancsot. Ha a parancs nem tartozik az objektumhoz, nem történik semmi. Ha az alapértelmezett parancsot távolítjuk el, az null-ra állítódik. • public void setItemCommandListener(ItemCommandListener figyelo); beállíthatunk vele egy parancsfigyelőt az elemhez. Alert objektumokkal való kombináció esetén úgy viselkedik, mint a setLabel módszer. Egy érvényben lévő parancsfigyelő eltávolítható, ha a paraméterben null-t adunk meg. • public int

getPreferredWidth(); - megadja az alkalmas szélességet. • public int getPreferredHeight(); - megadja az alkalmas magasságot. • public void setPreferredSize(int szeles, int magas); - zárolható vele az alkalmas méret. A zár feloldásához állítsuk a megfelelő paraméter(eket) –1 értékre A paramétereknek nem szabad negatívnak lenniük (kivéve –1-nek), mert IllegalArgumentException keletkezik. Ha valamelyik paraméter 0 és a minimális méret között van, akkor azt az értéket zárolja a fordító. Alert objektumokkal való kombináció esetén úgy viselkedik, mint a setLabel módszer. • public int getMinimumWidth(); - megadja a minimális szélességet. • public int getMinimumHeight(); - megadja a minimális magasságot. • public void setDefaultCommand(Command parancs); - beállíthatjuk az objektumhoz az alapértelmezett parancsot. Alert objektumokkal való kombináció esetén úgy viselkedik, mint a setLabel módszer. • public void

notifyStateChanged(); - jelzést küld az elemet tartalmazó Form objektumnak, hogy vegye észre az elemhez rendelt ItemStateListener típusú állapotfigyelőt. Ez figyeli az elemen végrehajtott változásokat. Ha nem tartozik egy Form objektumhoz az adott elem, akkor IllegalStateException kivétel keletkezik. 4.3101 Opciók – A ChoiceGroup osztály Egy űrlapobjektumban elhelyezett választható elemeket tartalmaz ez az osztály. Megvalósíthatóak jelölőnégyzetekkel (check box), rádiógombokkal (radiobutton), vagy választógombokkal. Az utóbbi kettőt keverni szokták itt-ott, azért linkeltem be egy-egy definíciót. A háromféle típust (MULTIPLE, EXCLUSIVE, POPUP) a Choice interfészből választhatjuk ki hozzá. Konstruktorai és tagfüggvényei ugyanazok, mint a List osztálynál megismert módszerek, csak az IMPLICITE fajtát nem lehet használni a ChoiceGroup objektumok esetén. 4.3102 Állítgatható alkatrészek – A CustomItem osztály Interaktív elemeket

készíthetünk ezzel az osztállyal. Rendelkeznek az Item osztályban leírt tulajdonságokkal (méret, direktívák, megjelenítési mód), de ezeken kívül helyben szerkeszthetőek is. Billentyűlenyomási vagy mutató kiváltotta eseményeket rendelhetünk hozzájuk, átszabhatjuk a megjelenésüket, és meghatározhatjuk a bejárásuk irányát is (vízszintes vagy függőleges). Konstruktora: • protected CustomItem(String cimke); - ősosztály konstruktor, a cimke különbözhet az alosztályokban. Adattagjai (protected static final int mindegyik): • TRAVERSE HORIZONTAL – engedélyezi az interakciós bitnél a vízszintes bejárást; értéke 1. • TRAVERSE VERTICAL – engedélyezi az interakciós bitnél a függőleges bejárást; értéke 2. • KEY PRESS - engedélyezi az interakciós bitnél a billentyűlenyomáshoz rendelt események támogatását; értéke 4. • KEY RELEASE - engedélyezi az interakciós bitnél a billentyű felengedéséhez rendelt

események támogatását; értéke 4. • KEY REPEAT - engedélyezi az interakciós bitnél a billentyű lenyomvatartáshoz rendelt események támogatását; értéke 0x10. • POINTER PRESS - engedélyezi az interakciós bitnél a mutató lenyomásához rendelt események támogatását; értéke 0x20. • POINTER RELEASE - engedélyezi az interakciós bitnél a mutató felengedéséhez rendelt események támogatását; értéke 0x40. • POINTER DRAG - engedélyezi az interakciós bitnél a vonszolási események támogatását; értéke 0x80. • NONE – jelzi, hogy a bejárás elkezdődött vagy helyet változtatott; értéke 0. Tagfüggvényei (az alosztályok valósítják meg a hívásukat): • protected final int getInteractionModes(); - megadja az érvényben lévő interakciós módokat. Ha 0-val tér vissza egyedül parancsokon keresztül lehet kommunikálni az elemekkel. • protected abstract int getMinContentWidth(); - megadja a minimális szélességet (pixelben);

az implementáció hívja meg az elhelyezési algoritmus részeként. • protected abstract int getMinContentHeight(); - megadja a minimális magasságot (pixelben); az implementáció hívja meg az elhelyezési algoritmus részeként. • protected abstract int getPrefContentWidth(int magas); - megadja az alkalmas szélességet (pixelben); az implementáció hívja meg az elhelyezési algoritmus részeként. A paraméter értéke segít kiszámítani ezt; ha –1, akkor nem használja a paramétert a számításhoz. • protected abstract int getPrefContentHeight(int szeles); - megadja az alkalmas magasságot (pixelben); az implementáció hívja meg az elhelyezési algoritmus részeként. A paraméter értéke segít kiszámítani ezt; ha –1, akkor nem használja a paramétert a számításhoz. • protected void sizeChanged(int szeles, int magas); - az elem méretének megváltozásakor meghívja az implementáció; ha az eklem látható a képernyőn, a metódus hívása

magával von egy repaint hívást is (ha kisebb lett, akkor elég csak a körülötte lévő részeket újrafesteni). Ebben az esetben mindenképpen a paint előtt kerül meghívásra. • protected final void invalidate(); - jelzést küld arról, hogy a méret és a bejárási pont megváltozott, a korábbi értékek már érvénytelenek, frissítés szükséges. • protected abstract void paint(Graphics g, int szeles, int magas); egy fekete, alapértelmezett betűtípussal és vonalstílussal rendelkező grafikai objektumot készít, fest az elemhez. Az objektumot az elem pozíciójára helyezi az elem méretének megfelelően (ez van a paraméterben), koordináta rendszerének origója tehát az elemobjektum bal felső sarka. Csak a megjelenítés (showNotify) után kerül meghívásra. • protected final void repaint(int x, int y, int szeles, int magas); - az elemobjektum egy adott téglalapnyi területét újrafesti; ha nem adunk meg paramétert, az egész objektumot

újrafesti. Olyankor hívja meg az implementáció, amikor frissíteni kell a megjelenített objektum képét (pl. átméretezéskor) • • • • • • • • • • • protected boolean traverse(int irany, int vpSzel, int vpMag, int[] t); - a rendszer hívja meg abban az esetben, ha a bejárás elkezdődik az elemben vagy folytatódik benne. A visszatérési érték a bejárás lépésének sikerét jelzi, azaz false, ha elért az elem határaihoz vagy nem támogatott a bejárás. Az első a bejárás irányát jelenti, amihez a Canvas játékbillenytű kódjait használja fel; a második és a harmadik paraméter pedig a legnagyobb látható (viewport) téglalap méreteit jelöli. Az utolsó paraméter egy négyelemű tömb, aminek eredményei elérhetőek a hívás után is. Egy [x, y, szeles, magas] téglalapról van szó, az elemobjektumhoz viszonyítva. Az éppen látható részét tartalmazza az objektumnak. Ha a visszatérési érték false, a téglalap

eredményei nem lényegesek, hiszen nincs mit bejárni. A bejárás kezdőpontját a bejárási irány és a bejárás tengelye alapján kaphatjuk meg UP irány és TRAVERSE VERTICAL esetén, például, ez a pont a leginkább jobbra eső pontját jelenti. protected void traverseOut(); - a rendszer hívja meg a bejárás végén. protected void keyPressed(int bill); - a rendszer hívja meg a billentyű lenyomása esetén, ha ez az interakciós mód támogatott. protected void keyReleased(int bill); - a rendszer hívja meg a billentyű felengedése esetén, ha ez az interakciós mód támogatott. protected void keyRepeated(int bill); - a rendszer hívja meg a billentyű nyomva tartása esetén, ha ez az interakciós mód támogatott. public int getGameAction(int bill); - megadja a billentyűkódhoz tartozó játékgomb kódját. protected void pointerPressed(int x, int y); - a rendszer hívja meg a mutató adott pontban való lenyomása esetén, ha ez az interakciós mód támogatott.

protected void pointerReleased(int x, int y); - a rendszer hívja meg a mutató adott pontban való felengedése esetén, ha ez az interakciós mód támogatott. protected void pointerDragged(int x, int y); - a rendszer hívja meg a mutató adott pontból való vonszolása esetén, ha ez az interakciós mód támogatott. protected void showNotify(); - a rendszer hívja meg ha az elem legalább részben látható a képernyőn, és korábben egyáltalán nem volt látható. protected void hideNotify(); - a rendszer hívja meg a képernyőn legalább részben látható elem elrejtésekor. 4.3103 Digitális óra – A DateField osztály A DateField osztály tagfüggvényeivel kezelhetjük a dátumokat és az időpontokat. Három módban hozhatunk létre dátmmezőket: időt mutató (óra, perc), dátumot mutató (év, hó, nap), vagy mindkettőt mutató formában. Beállíthatunk hozzájuk időzónát is (a javautilTimeZone osztályból), de ha nem tesszük, a helyi időzóna az

alapértelmezett. Az időt számíthatja ezredmásodpercben, greenwich-i időzóna szerinti 1970. január 1-től, de egy java.utilDate típusú objektummal is Az utóbbnál az évet ÉV-1900 formában kiszámított egész értékkel, a hónapot 0 (január) - 11 (december), a napot 1-31, az órát 0-23, a percet 0-59, a másodpercet 0-61 egész értékű formában. Ha kilépnénk az ismert határok közül, nincs baj, mert a fordító megfelelően értelmezi azt (pl március 40. => április 9) A 61 másodpercet szökőmásodpercnek nevezzük, és ez mindig december 31-én vagy június 30-án a nap utolsó másodperce egy vagy két évente. A dátum kiszámításáról lásd még a J2SE dokumentációt! Esetlegesen keletkezendő kivételek: • IllegalArgumentException kivétel keletkezik, ha az időmérési mód nem megfelelő értékű. Konstruktorai: • public DateField(String címke, int mod, TimeZone idozona); - létrehoz egy dátummező objektumot a megadott módban és

időzónában. Ha az utolsó paramétert elhagyjuk, vagy null értéket adunk meg neki, akkor az alapértelmezett (helyi) időzónát használja. Adattagjai (public static final int mindegyik): • DATE – mutatja az évet, hónapot, napot; az óra, perc komponensek a Date objektumban 00:00:00-ra állítódnak; értéke 1. • TIME – mutatja az órát és a percet; az év, hó, nap komponensek a Date objektumban az 1970. január 1-re állítódnak; értéke 2. • DATE TIME – mutatja az évet, hónapot, napot, órát, percet; értéke 3. Tagfüggvényei: • public Date getDate(); - megadja az aktuális dátumot; ha TIME módban egy is nappal meghaladja a kezdőidőt az aktuális dátum, akkor null lesz a visszatérési érték. • public void setDate(Date datum); - beállítja az aktuális dátumot. DATE TIME mód csak perc pontosságig mér, tehát nincs másodperc komponens semmilyen esetben. Ha TIME módban egy nappal is meghaladja a kezdőidőt az aktuális dátum, akkor

null lesz a visszatérési érték, erre ügyelni kell. A DATE mód esetén az óra és perc komponenseket nem veszi figyelembe a fordító • public int getInputMode(); - megadja a használt időmérési módot. • public void setInputMode(int mod); - az időmérés módjának átállítása. 4.3104 Grafikonok – A Gauge osztály Grafikonokat készíthetünk vele. Egy grafikonnak van egy aktuális értéke és egy maximum értéke (a minimum érték 0). Mindkettőt beállíthatja az alkalmazás A megjeleníthető terület valószínűleg kisebb, mint a mérhető, így több pontnak esetleg azonos lesz a helyzete a képernyőn. Egy grafikon lehet interaktív is, azaz a felhasználó állíthatja be az értékeit. Nem interaktív grafikonok lehetnek határozatlanok. Ez négy grafikon típusnál fordulhat elő: folyamatosan tétlen, növekvő-tétlen, folyamatosan futó, növekvő-frissülő. A növekvő-frissülő esetén nincs ismert végpont, de a grafikon értékeiről

tájékoztatást kap a felhasználó. A folyamatosan futó típus esetén nincs végpont, és nem kap tájékoztatást a grafikon értékeiről a felhasználó, csak a futásról értesül. A folytonos-tétlen és növekvő-tétlen esetekben nincs folyamatban lévő munka, nincs aktivitás. Ha határozatlan grafikon esetén a kezdő- és aktuális érték nem az adattagokból ismert állapotok közül való, vagy a maximális érték nem pozitív egész (esetleg –1-gyel jelölt határozatlan), akkor IllegalArgumentException kivétel keletkezik. Konstruktora: • public Gauge(String cimke, boolean interaktiv, int maxErtek, int kezdoErtek); - létrehoz egy interaktív vagy nem interaktív grafikont a megadott kezdő- és maximális értékkel. Adattagjai (public static final int mindegyik): • INDEFINITE – határozatlan; a maximum értékre használjuk; értéke: -1. • CONTINUOUS IDLE – folyamatosan tétlen állapot; értéke: 0. • INCREMENTAL IDLE – növekvő-tétlen

állapot; értéke 1. • CONTINUOUS RUNNING – folyamatosan futó állapot; értéke 2. Például egy animáció futása is ilyen (nem tudjuk mik a képkockák, de látjuk a mozgóképet). • INCREMENTAL UPDATING – növekvő-frissülő állapot; értéke 3. Például egy animáció képkockája (frame) a grafikon egy ilyen állapota; ha meghívják a setValue(3)-at, akkor frissül, és továbblép a következő képkockára. Tagfüggvényei: • public void setValue(int ertek); - beállítja a grafikon aktuális értékét. Ha nem határozatlan a függvény és az ertek nem pozitív, a fordító 0-át vesz helyette, ha nagyobb, mint a maximális érték, akkor a maximális értéket veszi helyette. • public int getValue(); - megadja a grafikon aktuális értékét. • public void setMaxValue(int maxErtek); - beállítja a grafikon maximális értékét • public int getMaxValue(); - megadja a grafikon maximális értékét. • public boolean isInteractive(); - megállapítja,

hogy a grafikon interaktív-e. 4.3105 Képelemek – Az ImageItem osztály Képben a kép. Egy ilyen objektum hivatkozást tartalmaz egy Image objektumra Az Item osztályból örökölt elhelyezési direktívák némelyikét átdefiniálja. Konstruktorai: • public ImageItem(String cimke, Image kep, int direktiva, String szoveg, int megjelenes); - létrehoz egy képet a kep képben a megfelelő direktívával és megjelenéssel. A szoveg-gel jelzett ún „alternatív szöveg” akkor kerül a képernyőre, ha a kép már nem férne ki. Ha az utolsó paramétert elhagyjuk, akkor az alapértelmezett megjelenési mód (PLAIN) érvényes. IllegalArgumentException keletkezik, ha a direktíva vagy a megjelenési mód értéke nem megfelelő. Adattagjai (nem különböznek az Item-ben megismertektől): • LAYOUT DEFAULT, LAYOUT LEFT, LAYOUT RIGHT, LAYOUT NEWLINE BEFORE, LAYOUT NEWLINE AFTER LAYOUT CENTER, Tagfüggvényei: • public void setImage(Image kep); - beállítja a

képelemet tartalmazó képobjektumot. • public void setAltText(String szoveg); - beállítja az alternatív szöveget, adjunk meg neki null értéket. • public void setLayout(int direktiva); - beállítja az elhelyezési direktívát. • public Image getImage(); - megadja a képelemet tartalmazó képobjektumot; ha nincs hozzá tartozó kép, a visszatérési érték null. • public String getAltText(); - megadja az alternatív szöveget; ha nincs szöveg, a visszatérési érték null. • public int getLayout(); - megadja a képelem elhelyezési direktíváját. • public int getAppearanceMode(); - megadja a képelem megjelenítési módját. 4.3106 Üres helyek – A Spacer osztály Ez reprezentálja a térközöket, üres helyeket az elemek sorában. Voltaképpen egy nem interaktív, üres elem, ami látható. :) Az alkalmas méret ennél az osztálynál megegyezik a minimális mérettel Egy Spacer objektum cimkéje mindig null, tehát a setLabel metódus hívása mindig

kivételt eredményez. Nem rendelhetőek hozzájuk parancsok (még alapértelmezett parancs sem), tehát az addCommand és a setDefaultCommand hívása mindig kivételt generál. Konstruktora: • public Spacer(int minSzel, int minMag); - létrehoz egy üres elemet a megadott minimális mérettel. Ha bármelyik paraméter negatív, IllegalArgumentException keletkezik Tagfüggvénye: • public void setMinimumSize(int minSzel, int minMag); - beállítja a minimális méretet; ha a minimális méret nagyobb, mint a maximális méret, akkro az számít helyette. Ha bármelyik paraméter negatív, IllegalArgumentException keletkezik. 4.3107 Feliratok – A StringItem osztály A feliratok szöveges elemek, melyeknek tartalmát csak az alkalmazás módosíthatja, a felhasználó nem (azaz nem interaktív elem). A címke megjelenítése eltérhet a szöveges tartalmától Konstruktorai: • public StringItem(String címke, String tartalom, int megjelenes); létrehoz egy szövegelemet a

megadott cimkével és tartalommal. A harmadik paraméter a megjelenés módját határozza meg, de el is maradhat (ilyenkor PLAIN módban jelenik meg az elem). Ha a megjelenési mód nem megfelelő, IllegalArgumentException kivétel keletkezik. Tagfüggvényei: • public void setText(String szoveg); - beállítja a szövegelem tartalmát; ha null, az elem üres lesz. • public void setFont(Font btip); - beállítja a szövegelem szövegének betűtípusát; ha null, az alapértelmezett betűtípus érvényes. • public String getText(); - visszatér a szövegelem tartalmával; ha null, az elem üres. • • public Font getFont(); - megadja a szövegelem szövegének betűtípusát public int getAppearanceMode(); - megadja a szövegelem megjelenítési módját. 4.3108 Szövegmezők – A TextField osztály Az ilyen típusú objektumok az űrlapba illeszthető szerkeszthető szövegelemek. A maximális méretét (abeleírható karakterek számát) megszabhatjuk az objektum

készítésénél, de maga a készülék is korlátozhatja ezt. Ún. bemeneti megszorításokat (input constraints) rendelhetünk a szöveghez, amivel megszabhatjuk, milyen formában lehessen bevinni a szöveget (pl. csak számok, telefonszám, jelszó, e-mail cím stb) A bevitel történhet akárhogyan, de a képernyőn a megszorításnak megfelelő forma fog megjelenni. Ha valamilyen szűréssel egybekötött megszorítás van érvényben, akkor az API ellenőrzi a bevitel szintaxisát. A megszorítást jelképező változó „low order” formában (a legkisebb helyiértékű bit van az első helyen) vett 16 bitjét a szövegtípus (constraint setting) határozza meg. A „high order”-ben (a low order fordítottja) – azaz a CONSTRAINT MASK állandó tartalmából – vett 16 bitjét pedig a módosítási kapcsoló (modifier flag); mindkettő használható az & (ÉS) bitoperátorral együtt (hogy pl. a jelszó kódolt értékét megfelelően kapjuk meg) Az esetek

kombinálhatóak egy | jellel. Szövegtípusok: ANY, EMAILADDR, NUMERIC, PHONENUMBER, URL, DECIMAL Módosítási kapcsolók: PASSWORD, UNEDITABLE, SENSITIVE, NON PREDICTIVE, INITIAL CAPS WORD, INITIAL CAPS SENTENCE Bemeneti módokat (pl. csupa nagybetűs, csupa kisbetűs, kínai, arab stb írásjelek) is beállíthatunk, de ez eszközfüggő, így nem részletezem. Megtalálható a hivatalos dokumentációban Keletkezhető kivételek: lásd a TextBox osztály kivételeit Konstruktora: • public TextField(String cimke, String tartalom, int maxMeret, int megszoritas); - létrehoz egy szövegmező objektumot a megfelelő tartalommal, mérettel és megszorítással. Adattagjai (public static final int mindegyik): • ANY – bármilyen szövegtípus megengedett, nincs megszorítás; értéke: 0. • EMAILADDR – e-mail címek bevitelére vonatkozó megszorítás; értéke: 1. • NUMERIC – csak számokat tartalmazó szöveg bevitelére vonatkozó megszorítás; a mínuszjel is egy

karakternek számít; értéke: 2. • PHONENUMBER – telefonszámok bevitelére vonatkozó megszorítás; készüléktől függően tartalmazhat nem számjellegű karaktereket is (pl. + jelet); értéke: 3 • URL – URL cím bevitelére vonatkozó megszorítás; értéke: 4. • DECIMAL – számokat és egyéb jeleket (mínuszjel, tizedespont/tizedesvessző) tartalmazó szöveg bevitelére vonatkozó megszorítás; a jelek külön karakternek számítanak; értéke: 5. • • • • PASSWORD – a bevitelt jelszó formájúra állító módosítási kapcsoló, azaz a készüléktől függően valami helyettesítő jel kerül a beütött billentyű visszajelzésekor a képernyőre (általában *); a titkosítás érdekében, ha ezt állítjuk be, be kell állítani a SENSITIVE és a NON PREDICTABLE kapcsolókat is; értéke: 0x10000 UNEDITABLE – a szerkesztést megtiltó kapcsoló; értéke: 0x20000 SENSITIVE – a kapcsoló olyan szövegek bevitelénél használatos, aminek

tartalmát nem tárolhatja szótárban, táblázatban vagy egyéb könnyen azonosítható helyen; a kapcsoló tehát ezeket szűri; értéke: 0x40000 NON PREDICTIVE – a kapcsoló szűri azokat a szavakat, amik szerepelnek a szótárban, vagy valamilyen eltárolt helyen, tahát a szónak nem megfejthető jellegűnek kell lennie; értéke: 0x80000 • • • INITIAL CAPS WORD – ez a kapcsoló minden új szó kezdőbetűjét kapitalizálja (nagybetűvel írja); hogy mi számít egy szónak, az implementációfüggő; értéke: 0x100000 INITIAL CAPS SENTENCE – ez a kapcsoló minden új mondat első szavának kezdőbetűjét kapitalizálja; a mondat végének meghatározása implementációfüggő; értéke: 0x200000 CONSTRAINT MASK – a megszorítás-maszk változója; arra szolgál, hogy bizonyos módosítás kapcsolókat eltávolítson; így pl. jelszó esetén a megfelelő megszorítási módot úgy kaphatjuk meg, hogy a maszkot a getConstraint() módszer visszatérési

értékével ÉS-eljük; értéke: 0xFFFF Tagfüggvényei: ugyanazok, mint a TextBox osztály metódusai. 4.311 Reklámszalagok – A Ticker osztály Ezzel egy „távírószalagot” hozhatunk létre, ami a képernyőn folyamatosan futó szöveget takar. Az irány és a sebesség implementációfüggő. Nem lehet leállítani, vagy elindítani, megállás nélkül fut, bár ideiglenesen szüneteltethető, ha a felhasználó nem foglalkozik a készülékkel (energiatakarékossági okokból). Tartalmazhat sortördelő karaktereket (/n vagy u000a) szeparációs célból, de a teljes szövegnek benne KELL lennie az objektumban. Ha a setTicker módszerrel megosztunk egy ilyen objektumot, olyan érzése lehet az embernek, mintha az különválna a képernyőktől, mert mindegyik képernyőn ugyanott és ugyanúgy fut. Természetesen egyéb alkalmazási módszerek is megvalósíthatóak. Konstruktora: public Ticker(String szoveg); Tagfüggvényei: • public String getString(); - megadja a

futó szöveg tartalmát • public void setString(String ujszoveg); - a futó szöveg tartalmának módosítása; ha az ujszoveg értéke null, kivétel keletkezik (NullPointerException). 4.4 A javax.microeditionlcduigame csomag Osztályhierarchia a csomagban • class java.langObject • class javax.microeditionlcduiDisplayable • class javax.microeditionlcduiCanvas • class javax.microeditionlcduigameGameCanvas • class javax.microeditionlcduigameLayer • class javax.microeditionlcduigameSprite • class javax.microeditionlcduigameTiledLayer • class javax.microeditionlcduigameLayerManager 4.41 Kávézás játék közben – A GameCanvas osztály A Canvas osztályból öröklődik, szerepe a játékok felhasználói felületének megvalósítása. A parancsok hozzárendelését és a bemeneti eseményeket átveszi a Canvas-ból. Minden egyes használathoz egy (az objektum maximális méretével megegyező méretű) dedikált puffer rendelődik, ami minimalizálja a heap

használatát. Konstruktora: • public GameCanvas(boolean atvaltas); - új objektumot hoz létre, s a paraméterében engedélyezhetjük, hogy csak a játékbillentyűkkel lehessen irányítani; ha false-ot adunk meg, akkor maradhatnak iránynak a 2,4,6,8 billenyűk is. Adattagjai (public static final int mindegyik): • UP PRESSED - a FEL játékgomb; értéke 0x0002. • • • • • • • • DOWN PRESSED - a LE játékgomb; értéke 0x0040. LEFT PRESSED - a BALRA játékgomb; értéke 0x0004. RIGHT PRESSED - a JOBBRA játékgomb; értéke 0x0020. FIRE PRESSED - a TŰZ játékgomb; értéke 0x0100. GAME A PRESSED - az A játékgomb; értéke 0x0200. GAME B PRESSED - a B játékgomb; értéke 0x0400. GAME C PRESSED - a C játékgomb; értéke 0x0800. nem támogatja ezeket minden készülék GAME D PRESSED - a D játékgomb; értéke 0x1000. Tagfüggvényei: • protected Graphics getGraphics(); - megadja a bufferben lévő grafikai objektumot; az objektum mindaddig nem

lesz látható, így a flushGraphics-ot meg nem hívták. • public int getKeyStates(); - a billentyűk állapotának vizsgálatához szoktuk használni feltételekben. A 0 állapot a felengedett állapotot, az 1-es a lenyomott állapotot jelöli Pl. int keyState = getKeyStates(); if ((keyState & LEFT KEY) != 0) {//ha a bal gombot lenyomjuk, tedd ezt } • • 4.42 public void paint(Graphics g); - kifesti az objektumot. public void flushGraphics(int x, int y, int szeles, int magas); - a bufferben lévő tartalom megfelelő részét láthatóvá teszi; paraméter nélkül meghívva az egész buffert üríti. Képrétegek – A Layer osztály Ez jelképezi a játék többrétegű képernyőjét. A rétegobjektum koordinátarendszerét a ráfestett grafikai objektum adja. Tagfüggvényei: • public void setPosition(int x, int y); - a rétegobjektum kezdőkoordinátáit állítja be; az alapeset (0,0). • public void move(int dx, int dy); - a rétegobjektumot elmozdítja a

megfelelő vektorral (az x tengelyen a negatív érték balra mozgást, az y tengelyen a negatív érték felfelé való mozgást eredményez). • public int getX(); - a rétegobjektum bal felső sarkának x koordinátáját adja meg. • public int getY(); - a rétegobjektum bal felső sarkának x koordinátáját adja meg. • public int getWidth(); - a rétegobjektum szélességét adja meg (pixelben). • public int getHeight(); - a rétegobjektum magasságát adja meg (pixelben). • public void setVisible(boolean lathato); - láthatóvá/nemláthatóvá teszi a rétegobjektumot. • public boolean isVisible(); - megállapítja, hogy a rétegobjektum látható-e. • public abstract void paint(Graphics g); - kifesti az objektumot, ha látható. 4.431 Rajzfilm a mikróban? – A Sprite osztály Talán ez a legizgalmasabb osztály mindközül, ugyanis akár rajzfilmeket is készíthetünk objektumai segítségével. A rajzfilmek képkockákra (frames) bonthatóak, amelyek

különböző tartalommal rendelkeznek – az azonos mozzanatokat ismétléssel oldják meg. A képernyő folyamatos frissítésével változik a kép A képkockák a Sprite objektum képelemének (ami lehet álló- vagy mozgókép is!) feldarabolásából adódnak a megadott szélesség illetve magasság szerint a bal felső sarokból kiindulva és jobbról balra haladva. 1 A feldarabolás változatai: 2 1 2 3 4 3 4 1 2 3 4 A képen végrehajtott transzformációkhoz általában egy hivatkozási pixelt (reference pixel) használunk, amihez képest a transzformációt végrehajtjuk. Például, ha egy iránytű pörgését akarjuk szemléltetni, akkor a hivatkozási pixelt megadhatjuk az tengely középpontjának és az objektumot elforgatva e körül úgy tetszik, mintha az iránytű forogna (persze ha egy valódi iránytűt szeretnénk modelezni, akkor külön megrajzoljuk az állapotokat, nem 90 fokonként forgatjuk, mert úgy egy kicsit durva a hasonlóság :))

Esetlegesen keletkezendő kivételek: • IllegalArgumentException – ha a képkocka mérete vagy a képkockák száma kisebb, mint 1; ha a képkockákból álló kép mérete nem a képkocka méretének többszöröse; ha a képkocka indexe a tartományon kívül esik. • IndexOutOfBoundsException – ha a képkocka indexe a tartományon kívül esik. • NullPointerException – ha a paraméter értéke nem lehet null, és mégis az. Konstruktorai: • public Sprite(Image kep); - egy nem animációkhoz használt objektumot hoz létre. • public Sprite(Image kep, int kockaSzel, int kockaMag); - új, animált objektumot hoz létre a megfelelő darabolási technikával előállított képkockákkal. • public Sprite(Sprite animacio); - egy másik objektumból hozza létre az újat. Adattagjai (public static final int mindegyik): • TRANS NONE – nincs transzponáció; értéke 0. • TRANS ROT90 – elforgatás 90 fokkal az óramutató járásával megegyezően; értéke 5. •

TRANS ROT180 - elforgatás 180 fokkal az óramutató járásával megegyezően; értéke 3. • TRANS ROT270 - elforgatás 270 fokkal az óramutató járásával megegyezően; értéke 6. • TRANS MIRROR – tengelyes tükrözés a középponti függőleges tengelyre; értéke 2. • TRANS MIRROR ROT90 – tükrözés és forgatás 90 fokkal az óramutató járásával megegyezően; értéke 7. • TRANS MIRROR ROT180 - tükrözés és forgatás 180 fokkal az óramutató járásával megegyezően; értéke 1. • TRANS MIRROR ROT270 - tükrözés és forgatás 270 fokkal az óramutató járásával megegyezően; értéke 4. Tagfüggvényei: • public void defineReferencePixel(int x, int y); - meghatározhatjuk vele a hivatkozási pixelt. Alapesetben ez a Sprite objektum (0,0) koordinátájú pixele • public void setRefPixelPosition(int x, int y); - áthelyezhetjük az objektumot úgy, hogy a hivatkozási pixele a paraméterben megadott koordinátákra essen. • public void

getRefPixelX(); - megadja a hivatkozási pixel x koordinátáját. • public void getRefPixelY(); - megadja a hivatkozási pixel y koordinátáját. • public void setFrame(int index); - elhelyezhetjük az adott képkocká(ka)t a megfelelő helyre. • public void setFrameSequence(int[] kepkockak); - meghatározhatjuk vele a képkockák sorrendjét; az alapeset (null) egymás utáni sorrend, ismétlés nélkül. • public void setImage(Image kep, int kockaSzel, int kockaMag); - új képkockákat rak a régiek helyére. • public int getFrame(); - megadja az adott képkocka indexét. • public int getRawFrameCount(); - megadja az egymástól különböző képkockák darabszámát. • public void nextFrame(); - a következő képkockára ugrik. Ha az utolsó képkockára hívják meg, akkor az első képkockára ugrik. • public void prevFrame(); - az előző képkockára ugrik. Ha az első képkockára hívják meg, akkor az utolsó képkockára ugrik. • • • •

4.432 public void defineCollisionRectangle(int x, int y, int szeles, int magas); - beállít az objektumhoz egy téglalapot, ami az objektummal való ütközések elkerüléséért felel; alapesetben a (0,0) pontból kiinduló, a teljes képobjektumot magában foglaló téglalapról van szó. public void setTransform(int tr); - végrehajt egy transzformációt az objektumon (lásd adattagok). Alapesetben 0, azaz nincs transzformáció public final boolean collidesWith(Sprite s, boolean atlatszatlan); ellenőrzi, hogy az ütközési téglalap és első paraméterben megadott objektum közt fennáll-e az ütközés; ha igen, true értékkel tér vissza. Ha a második paraméter true, akkor csak teljesen átlátszatlan pixelek ütközését vizsgálja. A Sprite helyett használhatunk TiledLayer-t is, vagy Image objektumot is (bár ebben az esetben második és harmadik paraméternek a kép koordinátáit kell megadni; az utolsó paraméter a logikai változó lesz). public final void

paint(Graphics g); - kifesti az objektumot a grafikai objektum szerint; csak akkor hatásos, ha látható az objektum. Csempék – A TiledLayer osztály Kisebb darabokból – csempékből (tiles) – összerakott képeket készíthetünk velük, amelyekben sok az ismétlődés. Leginkább gördülő háttérnél szokás alkalmazni 2D-s játékokban (pl a karakter haladásának imitálására). A statikus csempék a képkockákhoz hasonló módon nyerhetőek ki az objektum képeleméből Lehetnek animált csempék is, ezek indexe negatív számokkal jelölt, és a setAnimatedTile módszerrel lehet őket hozzárendelni egy adott statikus csempéhez. A megjelenítendő képet cellákra osztjuk fel, és ebbe rakjuk a csempéket egymás után; az üres helyekre 0-s indexű csempét rakunk (alapesetben minden cella értéke 0). A kitöltését mind a paint tagfüggévnnyel, mind a LayerManager osztállyal megvalósíthatjuk. Esetlegesen keletkezendő kivételek: •

IllegalArgumentException – ha a csempék mérete vagy a sorok száma kisebb, mint 1; ha a csempékből álló kép mérete nem a képkocka méretének többszöröse; • IndexOutOfBoundsException – ha a csempe indexe a tartományon kívül esik. • NullPointerException – ha a paraméter értéke null. Konstruktora: • public TiledLayer(int oszlopDB, int sorDB, Image kep, int csSzel, int csMag); - az első két paraméter a cellákból felépített kép cellákban megadott méretére vonatkozik, a harmadik az a kép, amiből felépíti, az utolsó kettő pedig a csempék méretére (így a forráskép felosztására) utal. Tagfüggvényei: • public int createAnimatedTile(int sIndex); - a megadott indexű statikus vagy üres csempét animálttá alakítja. A visszatérési érték az animált csempéktől függő negatív szám (az első animált csempe indexe –1, a második –2 és így tovább). • public void setAnimatedTile(int aIndex, int sIndex); - az első

paraméterben megadott indexű animált csempét hozzárendeli egy statikus csempéhez (második paraméter). Az animációt úgy valósíthatjuk meg, hogy különböző statikus csempéket rendelünk az animálthoz. [nem értem, miért van szükség két függvényre, ahol kivétel is keletkezhet pont az egymástól való függőségük miatt, de a tapasztalt mikróhasználók bizonyára tudják, mi a jó :)] • public int getAnimatedTile(int aIndex); - megadja, éppen melyik statikus csempéhez van rendelve a paraméterben megadott animált csempe. • public void setCell(int oszlopDB, int sorDB, int index); - értéket ad az első két paraméterrel meghatározott cellának (az érték a harmadik paraméter lesz). • public void fillCell(int oszIndex, int sorIndex, int oszlopDB, int sorDB, int index); - értéket ad az első két paraméterrel meghatározott cellától kezdődően a harmadik-negyedik paraméterrel jelzett területen (az érték az utolsó paraméter lesz). •

public int getCell(int oszlopDB, int sorDB); - megadja az adott cellához rendelt értéket. Negatív érték esetén animált, pozitív érték esetén statikus, 0 esetén üres csempéről van szó • public final int getCellWidth(); - megadja egy cella hosszát (pixelben). • public final int getCellHeight(); - megadja egy cella magasságát (pixelben). • public final int getColumns(); - megadja a kialakítandó kép hosszát (cellában). • • • 4.43 public final int getRows(); - megadja a kialakítandó kép magasságát (cellában). public void setStaticTileSet(Image kep, int csSzel, int csMag); - új csempéket rak a régiek helyére. Csak a statikusokat cseréli, az animáltak maradnak ott, ahol voltak ha az új képelem ugyanannyi vagy több cellát tartalmaz, mint a régi; ha kevesebbet, akkor 0-ra állítja mindet, majd törli. public final void paint(Graphics g); - kifesti az objektumot a grafikai objektum szerint; csak akkor hatásos, ha látható az

objektum. Rétes melegítése a mikróban – A LayerManager osztály Ezzel kezelhetjük a különböző rétegeket. Megszab a látható területnek egy nézőablakot (view window), ami mindig az adott réteg éppen látható állapotát jeleníti meg az alap koordináta rendszerhez képest. Így egyéb dolgokat is feltüntethetünk a képernyőn (pl. pontszámok, eredmény a játékablakon kívül) A rétegek egymás fölöt helyezkednek el, az 1. réteg a legalsó, a legnagyobb indexű a legfelső réteg Tagfüggvényei: • public void append(Layer reteg); - réteg hozzáadása. • public void insert(Layer reteg, int index); - réteg beszúrása a megadott szintre; ha az adott szinten már volt valami, akkor azt eltávolítja előbb. • public void remove(Layer reteg); - réteg eltávolítása. • public Layer getLayerAt(int index); - visszatér a megadott szinten lévő réteg referenciájával. • public int getSize(); - megadja a rétegek számát. • public void

paint(Graphics g, int x, int y); - kifesti a nézőablakot az adott ponton a grafikai objektum szerint. Az összes réteget kifesti, de a nézőablakon kívülieket egyáltalán nem. • public void setViewWindow(int x, int y, int szeles, int magas); beállítja a nézőablakot. Alapesetben az eredeti koordinátarendszer (0,0) pontjában helyezkedik el 4.5 A javax.microeditionMIDlet csomag A főprogram; egy ilyet mindig kell tartalmazzon a midletünk, a main helyett van. Konstruktora: • protected MIDlet(); - az alosztályai inicializálják. Tagfüggvényei: • protected abstract void startApp(); - a MIDlet Aktív állapotba lép lefoglalja a memóriaterületeket; ha nem sikerül elindítani a MIDletet, akkor a MIDletStateChangeException kivételt generálja. Csak akkor lehet meghívni, ha a MIDlet Szüneteltetett állapotban van. • protected abstract void pauseApp(); - a MIDlet Szüneteltetett állapotba lép lefoglalja a memóriaterületeket; ha bármilyen hiba keletkezik, az

MIDlet megszűnik. Csak akkor lehet meghívni, ha a MIDlet Aktív állapotban van. • protected abstract void destroyApp(boolean kellefeltetel) – ha az argumentuma true, akkor felszabadít minden lefoglalt memóriaterületet, ha false, generálja a MIDletStateChangeException kivételt. Az állapot Megszüntetett állapotba lép, meghívható mind Aktív, mind Szüneteltetett állapotból. • public final void notifyDestroyed(); - jelzést küld arról, hogyha az alkalmazás Szüneteltetett állapotba lépett. • public final void notifyPaused(); - jelzést küld arról, hogyha az Megszűnt állapotba lépett. • • • 5. public final int checkPermission(String engedely); - ellenőrzi, hogy az adott engedély állapotát (0 – tiltott; 1 – engedélyezett; -1 – nem ismert). Ha nincs API, tiltottnak minősül minden engedély. public final boolean platformRequest(String URL); - ha az adott URL-t le tudja kezelni az eszköz, akkor true, egyébként kivételt generál.

Csak a legutolsó kérelmet szolgálja ki, így nem blokkolható. public final void resumeRequest(); - ezzel állapítja meg az alkalmazáskezelő szoftver, hogy melyik folyamat érdekelt az Aktív állapotba lépésben, így általában Szünetelt állapotban hívódik meg (bár ebben az állapotban is kiszolgálhat bizonyos aszinkron eseményeket – pl. időzítők) Történetek a mikrós kávékról – linkek, források • • • • • • • • • MIDlet tutorial magyarul, példákkal – Móricz Attila Java 2 ME útmutatója Első MIDletünk – a Debreceni Egyetem ismertetője a MIDP 2.0 specifikációjának letöltése – a SUN hivatalos oldaláról (a hiányok pótlására) Mobilprogramozás kezdőknek; J2ME a mobilon – az index.hu fórumai Forráskódok a különböző osztályok alkalmazásához – angolul van, de remek gyakorlati segítség Információk a MIDlet letöltéséről – nélkülözhetetlen :) Jávácska kiegészítő – pdf formátumban Data

parancsnok Jáva jegyzete – az első rész, ha valaki nem olvasta volna ;) Szegedi Zoltán diplomamunkája – a WAP alapú programozásról; pdf formátum