Java apleti - primeri
Primer Jan Lukasiewicz kalkulatora
Kôd
import java.awt.*;
import javax.swing.*;
public class KalkulatorLukasevic extends JApplet {
static final int DUBINA_SLOGA = 4;
// kalkulator sa N=4 meta za upis brojeva
public void init() {
LCDPrikazCifara lcdPrikaz = new LCDPrikazCifara(DUBINA_SLOGA);
/*komponenta ekrana klakulatora*/
PanelTastera tasteriKalkulatora = new PanelTastera(8,
5, lcdPrikaz); /*komponenta za panel sa tasterima klakulatora*/
Container c = getContentPane();
c.add(lcdPrikaz, BorderLayout.NORTH);
c.add(tasteriKalkulatora, BorderLayout.CENTER);
}
public String getAppletInfo() {
StringBuffer s = new StringBuffer();
s.append("KALKULATOR\n");
s.append((char)169);
// Copyright simbol
s.append("2004 Matematicka gimnazija, ...\n");
return s.toString();
}
public String[][] getParameterInfo() {
return new String[][] {};
}
}
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
/***********************************************************************
* Klasa PanelTastera enkapsulira kompletan panel
* dugmadi kalkulatora i sve matematicke
* (i druge) operacije koje dugmad izvode.
**********************************************************************/
class PanelTastera extends JPanel implements ActionListener {
int velicinaVrste;
LCDPrikazCifara prikaz;
// slog prikaz
SlogKalk slog;
// slog u prikazu
// Dugmad kalkulatora su uredjena kao matrica od 8 reda od po 5 dugmica
private String[] oznakeTastera = {
"1/x", "x^2",
"y^x", "Sqr", "AC",
// red 0
"sin", "cos",
"tan", "\u03c0", "e",
// red 1
"ln", "log",
" ", " ", "
", // red 2
"PROMENA", "NAGORE", "NADOLE", "BRISANJE",
"/", // red 3
" ", "7",
"8", "9", "x",
// red 4
" ", "4",
"5", "6", "-",
// red 5
" ", "1",
"2", "3", "+",
// red 6
" ", "0",
".", "+/-", "DODAJ"
// red 7
};
public PanelTastera(int vrste, int kolone, LCDPrikazCifara lcd)
{
velicinaVrste = kolone;
prikaz = lcd;
slog = prikaz.getSlog();
setLayout(new GridLayout(vrste, kolone));
JButton b[] = new JButton [vrste*kolone];
for (int i=0, n=oznakeTastera.length; i < n;
i++) {
b[i] = new JButton(oznakeTastera[i]);
b[i].addActionListener(this);
add(b[i]);
}
setPreferredSize(new Dimension(300, 200));
}
public void actionPerformed(ActionEvent e) {
// ukoliko je pritisnuta bilo koja cifra od 0..9
String oznaka = e.getActionCommand();
if (oznaka.equals(oznakaTastera(4,1)) ||
oznaka.equals(oznakaTastera(4,2))
||
oznaka.equals(oznakaTastera(4,3))
||
oznaka.equals(oznakaTastera(5,1))
||
oznaka.equals(oznakaTastera(5,2))
||
oznaka.equals(oznakaTastera(5,3))
||
oznaka.equals(oznakaTastera(6,1))
||
oznaka.equals(oznakaTastera(6,2))
||
oznaka.equals(oznakaTastera(6,3))
||
oznaka.equals(oznakaTastera(7,1)))
{
unetaCifra(Integer.valueOf((String)oznaka).intValue());
} else if (oznaka.equals(oznakaTastera(0,0))) {
inverzno();
} else if (oznaka.equals(oznakaTastera(0,1))) {
kvadrat();
} else if (oznaka.equals(oznakaTastera(0,2))) {
stepenovanje();
} else if (oznaka.equals(oznakaTastera(0,3))) {
kvadratniKoren();
} else if (oznaka.equals(oznakaTastera(0,4))) {
brisiSve();
} else if (oznaka.equals(oznakaTastera(1,0))) {
sinus();
} else if (oznaka.equals(oznakaTastera(1,1))) {
kosinus();
} else if (oznaka.equals(oznakaTastera(1,2))) {
tangens();
} else if (oznaka.equals(oznakaTastera(1,3))) {
konstantaPI();
} else if (oznaka.equals(oznakaTastera(1,4))) {
konstantaE();
} else if (oznaka.equals(oznakaTastera(2,0))) {
ln();
} else if (oznaka.equals(oznakaTastera(2,1))) {
log();
} else if (oznaka.equals(oznakaTastera(2,2))) {
} else if (oznaka.equals(oznakaTastera(2,3))) {
} else if (oznaka.equals(oznakaTastera(2,4))) {
} else if (oznaka.equals(oznakaTastera(3,0))) {
promena();
} else if (oznaka.equals(oznakaTastera(3,1))) {
premotajGore();
} else if (oznaka.equals(oznakaTastera(3,2))) {
premotajDole();
} else if (oznaka.equals(oznakaTastera(3,3))) {
brisiCifru();
} else if (oznaka.equals(oznakaTastera(3,4))) {
podeljeno();
} else if (oznaka.equals(oznakaTastera(4,4))) {
puta();
} else if (oznaka.equals(oznakaTastera(5,4))) {
minus();
} else if (oznaka.equals(oznakaTastera(6,4))) {
plus();
} else if (oznaka.equals(oznakaTastera(7,2))) {
zarez();
} else if (oznaka.equals(oznakaTastera(7,3))) {
promenaZnaka();
} else if (oznaka.equals(oznakaTastera(7,4))) {
enter();
}
System.out.println("Pritisnut je " + oznaka + "
taster");
}
private void unetaCifra(int cifra) {
prikaz.dodajCifru(cifra);
}
private void brisiCifru() {
prikaz.ukloniCifru();
}
private void enter() {
slog.postaviVrednost(0);
prikaz.promenaSloga(false);
}
private void promenaZnaka() {
slog.setAkumulator(-slog.getAkumulator());
prikaz.promenaSloga(false);
}
private void kvadratniKoren() {
if (slog.getAkumulator() >= 0.0) {
slog.setAkumulator(Math.sqrt(slog.getAkumulator()));
prikaz.promenaSloga(true);
}
}
private void kvadrat() {
slog.setAkumulator(Math.pow(slog.getAkumulator(),
2));
prikaz.promenaSloga(true);
}
// Sinus, kosinuse i tangens prihvataju ugao u radijanima
private void sinus() {
slog.setAkumulator(Math.sin(slog.getAkumulator()));
prikaz.promenaSloga(true);
}
private void kosinus() {
slog.setAkumulator(Math.cos(slog.getAkumulator()));
prikaz.promenaSloga(true);
}
private void tangens() {
slog.setAkumulator(Math.tan(slog.getAkumulator()));
prikaz.promenaSloga(true);
}
private void log() {
if (slog.getAkumulator() > 1.0) {
slog.setAkumulator(Math.log(slog.getAkumulator())
/ Math.log(10.0));
prikaz.promenaSloga(true);
}
}
private void ln() {
if (slog.getAkumulator() > 1.0) {
slog.setAkumulator(Math.log(slog.getAkumulator()));
prikaz.promenaSloga(true);
}
}
// Dizanje elementa sledeceg na slogu (next-on-stack; NOS)
// na stepen vrha sloga (top-of-stack TOS)
private void stepenovanje() {
double stepen = Math.pow(slog.getElementSloga(1),
slog.getAkumulator());
slog.odbaci();
slog.setAkumulator(stepen);
prikaz.promenaSloga(true);
}
private void konstantaE() {
slog.setAkumulator(Math.E);
prikaz.promenaSloga(true);
}
private void konstantaPI() {
slog.setAkumulator(Math.PI);
prikaz.promenaSloga(true);
}
private void inverzno() {
if (slog.getAkumulator() != 0.0) {
slog.setAkumulator(1.0/ slog.getAkumulator());
prikaz.promenaSloga(true);
}
}
private void zarez() {
prikaz.zarez();
}
private void premotajGore() {
slog.premotajGore(1);
prikaz.promenaSloga(true);
}
private void premotajDole() {
slog.premotajDole(1);
prikaz.promenaSloga(true);
}
// Promena TOS i NOS
private void promena() {
slog.promena();
prikaz.promenaSloga(true);
}
private void brisiSve() {
slog.brisiSlog();
prikaz.promenaSloga(true);
}
private void plus() {
double zbir = slog.getAkumulator() + slog.getElementSloga(1);
slog.odbaci();
slog.setAkumulator(zbir);
prikaz.promenaSloga(true);
}
private void puta() {
double proizvod = slog.getAkumulator() * slog.getElementSloga(1);
slog.odbaci();
slog.setAkumulator(proizvod);
prikaz.promenaSloga(true);
}
private void minus() {
double razlika = slog.getElementSloga(1) - slog.getAkumulator();
slog.odbaci();
slog.setAkumulator(razlika);
prikaz.promenaSloga(true);
}
private void podeljeno() {
double kolicnik = slog.getElementSloga(1) / slog.getAkumulator();
slog.odbaci();
slog.setAkumulator(kolicnik);
prikaz.promenaSloga(true);
}
public String oznakaTastera(int vrsta, int kolona) {
return oznakeTastera[vrsta*velicinaVrste + kolona];
}
}
import java.awt.*;
import java.util.*;
import javax.swing.*;
class LCDPrikazCifara extends JComponent {
SlogKalk slog; // slog brojeva
int dubinaSloga; // koliko
elemenata sadrzi slog
Dimension velicinaPrikaza, staraVelicina; // dimenzije oblasti
za crtanje
Dimension velicinaCifre;
SedmoSegmentneCifre lcd = null; // referenca za
7-segmentne cifre u LCD-silu
boolean svezBroj = true;
int decimalnaPozicija = 0;
LinkedList undoSlog;
// undo sistema za brisanje cifara
private static final int PRORED = 2;
public LCDPrikazCifara(int dubina) {
dubinaSloga = dubina;
slog = new SlogKalk(dubinaSloga);
noviBroj(); // resetovanje svih rezima unosa
setPreferredSize(new Dimension(100, 120));
}
/** Resetovanje svih stanja konstruisanja/editovanja broja */
private void noviBroj() {
svezBroj = true;
decimalnaPozicija = 0;
undoSlog = new LinkedList();
}
/** Uneta je dodatna cifra. U zavisnosti od toga u kom
* rezimu se nalazimo, ova cifra bi trebalo da bude dodata
* pre ili posle zareza. */
public void dodajCifru(int cifra) {
int promenjeno = 1; // koliko reda u digitronu treba
precrtati
zapamtiZaUndo(); // zapamti trenutnu
vrednost zbog moguceg brisanja cifre
if (svezBroj) {
// potpuno novi broj?
slog.premotajGore(1);
slog.setAkumulator(0.0);
// brisi A
svezBroj = false;
// akumuliraj cifre od sada
promenjeno = dubinaSloga;
// celokupan slog treba precrtati
}
// ukoliko jos uvek nismo uneli decimale, mozemo
jednostavno pomeriti
// broj za jednu cifru sa x10 i uneti cifru.
double akumulator = slog.getAkumulator();
if (decimalnaPozicija == 0) {
slog.setAkumulator(akumulator * 10.0
+ cifra);
} else {
// ukoliko treba da dodamo decimalu,
moramo dodati razlomak
// koji odgovara decimalnom mestu koje
smo do sada dosegli
slog.setAkumulator(akumulator + ((float)cifra)/decimalnaPozicija);
decimalnaPozicija *= 10;
}
promenaSloga(false);
}
public void ukloniCifru() {
undo();
// ponovo uspostavlja prethodni broj i stanje
promenaSloga(false);
}
/**********************************************************
* Koristimo slog koji sadrzi prethodne vrednosti i stanje
* editovanja tako da mozemo lako da se vratimo na prethodni
* broj ukoliko korisnik obrise cifru.
**********************************************************/
public void zapamtiZaUndo() {
undoSlog.addFirst(new Double(slog.getAkumulator()));
undoSlog.addFirst(new Boolean(svezBroj));
undoSlog.addFirst(new Integer(decimalnaPozicija));
}
public void undo() {
if (!undoSlog.isEmpty()) {
decimalnaPozicija = ((Integer) undoSlog.removeFirst()).intValue();
svezBroj = ((Boolean)
undoSlog.removeFirst()).booleanValue();
slog.setAkumulator(((Double) undoSlog.removeFirst()).doubleValue());
} else {
noviBroj();
slog.setAkumulator(0.0);
}
}
/** Korisnik pritisnuo '.'. Od sada treba da dodajemo decimale
*/
public void zarez() {
if (decimalnaPozicija == 0) {
decimalnaPozicija = 10;
// desetine, stotine, itd.
}
}
public SlogKalk getSlog() {
return slog;
}
public void promenaSloga(boolean noviBroj) {
if (noviBroj) {
noviBroj();
}
repaint();
}
public void paintComponent(Graphics g) {
velicinaPrikaza = getSize();
// Ukoliko nismo inicijalizovali klasu LCD cifara,
ili
// se promenila velicina nase oblasti za crtanje,
// inicijalizujmo LCD cifre
if ((lcd == null) || (velicinaPrikaza.width != staraVelicina.width)
||
(velicinaPrikaza.height
!= staraVelicina.height)) {
staraVelicina = velicinaPrikaza;
// pamcenje nove velicine
velicinaCifre = new Dimension(velicinaPrikaza.width/12,
(velicinaPrikaza.height/dubinaSloga) - PRORED);
// kreiranje seta LCD cifara
lcd = new SedmoSegmentneCifre(velicinaCifre);
}
for(int i=0, y; i<dubinaSloga; i++) {
y = (dubinaSloga-i-1) * (velicinaCifre.height
+ PRORED);
g.fillRect(0,y,velicinaPrikaza.width,
velicinaCifre.height);
lcd.crtajBroj(slog.getElementSloga(i),
g, 0, y);
}
}
}
/***********************************************************************
* Klasa SlogKalk kapsulira slog brojeva i sve njegove
* nematematicke manipulacije (tj. samo manipulacije sloga)
*
* Niti java.util.Stack, niti LinkedList nisu koriscene jer slog
* koji nam je potreban ne moze imati beskonacan kapacitet i zato
sto
* mi na slogu zelimo samo double vrednosti, a ne kompletne objekte.
**********************************************************************/
public class SlogKalk {
double slog[]; // slog u srcu masine
int dubinaSloga;
// Konstruktor: izgradjuje slog datog kapaciteta
public SlogKalk(int dubina) {
dubinaSloga = dubina;
slog = new double[dubinaSloga];
brisiSlog();
}
public void postaviVrednost(double x) {
premotajGore(1);
setAkumulator(x);
}
public void premotajGore(int puta) {
double poslednjaVrednost;
for (int r=0; r < puta; r++) {
poslednjaVrednost = slog[dubinaSloga-1];
for (int i = dubinaSloga-2; i >= 0;
i--) {
slog[i+1] = slog[i];
}
slog[0] = poslednjaVrednost;
}
}
public void premotajDole(int puta) {
premotajGore(dubinaSloga-puta);
}
public void promena() {
double pomocna;
pomocna = slog[0];
slog[0] = slog[1];
slog[1] = pomocna;
}
public void brisiSlog() {
for (int i=0; i < dubinaSloga; i++) {
slog[i] = 0.0;
}
}
public void odbaci() {
premotajDole(1);
slog[dubinaSloga-1] = slog[dubinaSloga-2];
}
public void setAkumulator(double x) {
slog[0] = x;
}
public double getAkumulator() {
return slog[0];
}
public double getElementSloga(int n) {
return slog[n];
}
}
/**********************************************************************
* Klasa kreira prilagodljive 7-segmentne cifre sastavljene
* kao "kolekcija" segmenta A,B,C,D,Ef,G
*********************************************************************/
import java.awt.*;
import java.awt.image.*;
import java.util.StringTokenizer;
public class SedmoSegmentneCifre {
protected Image cifre[]; // sadrzava
sracunate slike za cifre 0..9
protected Dimension skala; // skala u kojoj
korisnik zeli cifre
static final int BROJ_CIFARA = 10 + 1; // jedna dodatna
za znak minus
static final int ox = 207;
static final int oy = 53;
static final int segW = 230;
static final int segH = 227;
int originalnaSirina;
static final double kurzivProcenat = 0.15; // koju sirinu koristiti
za kurziv
int kurzivOpseg;
int decimalW, decimalH, decimalXoff, decimalYoff;
// tacke koje cine celiju 7-segmentnog prikaza
static final int tacke[] = {207,53, 385,53, 207,280, 385,280,
240,75, 360,75,
240,258, 360,258, 207,159, 385,159, 240,144, 360,144,
240,176, 360,176};
// svaki segment je poligon sastavljen od tacaka
static final int defSegmenata[][] = {{0,1,5,4}, {0,4,10,8}, {1,5,11,9},
{8,10,11,9,13,12}, {8,12,6,2}, {9,13,7,3}, {6,7,3,2}};
// svaka cifra je kolekcija "upaljenih" segmenata
static final String[] defCifara= {"ABCEFG", "CF", "ACDEG", "ACDFG",
"BCDF", "ABDFG",
"BDEFG", "ACF", "ABCDEFG", "ABCDF", "D"};
// znak minus je "cifra 10"
/**********************************************************************
* Konstruktor: obratite paznju na velicinu na koju skaliramo
cifre
* i dinamicki ih prikazujemo (a la PostScript)
*********************************************************************/
public SedmoSegmentneCifre(Dimension velicina) {
skala = velicina;
originalnaSirina = skala.width;
skala.width = (int)(skala.width * (1.0 - kurzivProcenat));
kurzivOpseg = originalnaSirina - skala.width;
cifre = new Image[BROJ_CIFARA];
for(int cifra=0; cifra < BROJ_CIFARA; cifra++)
{
cifre[cifra] = prikaziCifru(cifra);
}
// slika decimalne tacke se sracunava samo iz velicine cifre
decimalW = skala.width/6;
decimalH = skala.height/10;
decimalXoff = skala.width - decimalW;
decimalYoff = skala.height - decimalH;
}
/**********************************************************************
* Prikazivanje 7-segmentne cifre iz njene definicije liste segmenata.
* Vraca se slika koja ce biti skladistena.
*********************************************************************/
protected Image prikaziCifru(int broj) {
Image slikaCifre;
Graphics g;
String segmenti;
slikaCifre = new BufferedImage(originalnaSirina,
skala.height, BufferedImage.TYPE_INT_RGB);
g = slikaCifre.getGraphics();
segmenti = defCifara[broj];
for(int seg=0; seg < segmenti.length(); seg++)
{
int segIndex = segmenti.charAt(seg)-'A';
prikazSegmenta(g, segIndex);
}
return slikaCifre;
}
/**********************************************************************
* Prikazivanje poligona segmenta u datom Graphics kontekstu.
* Ovo je mesto gde se desavaju sve "pametne" stvari:
* normalizujemo koordinate segmenta na opseg 0.0 .. 1.0
* skaliramo ih na zeljene velicine
* prikazujemo taj segment kao poligon
*********************************************************************/
protected void prikazSegmenta(Graphics g, int segment) {
int defSegmenta[] = defSegmenata[segment];
Polygon p = new Polygon();
for(int tacka=0; tacka < defSegmenta.length; tacka++) {
int v = defSegmenta[tacka];
int x = tacke[v * 2 + 0] - ox;
// translacija na koodinatni pocetak
int y = tacke[v * 2 + 1] - oy;
double normX = ((double)x) / segW;
// normalizacija na 0.0..1.0
double normY = ((double)y) / segH;
int polyX = (int)(normX * skala.width);
// skaliranje na trazenu velicinu
int polyY = (int)(normY * skala.height);
polyX += (1.0 - normY) * kurzivOpseg; // kurziv cifara
p.addPoint(polyX, polyY);
}
g.fillPolygon(p);
}
/**********************************************************************
* slikaCifre() daje klijentima pristup prikazanim ciframa
*********************************************************************/
public Image slikaCifre(int cifra) {
return cifre[cifra];
}
/**********************************************************************
* crtajBroj() prikazuje double vrednost u datom
* gfx kontekstu na (x,y)
*********************************************************************/
public void crtajBroj(double broj, Graphics g, int x, int y)
{
String doubleStr = brisi(Double.toString(broj), 5);
boolean isNegativan = (doubleStr.charAt(0) == '-');
int pozicijaEksponenta = doubleStr.indexOf('E');
int pozicijaZareza = doubleStr.indexOf('.');
int znacajneCifre = 6; // we need toString()
to gen 6 signif. digits
int indeksCifre = 0;
int mestoCifre;
int cifra;
int digitX = 0 ;
Color snimljenaBoja = g.getColor();
g.setColor(Color.green);
znacajneCifre = doubleStr.length();
// ukoliko je broj negativan, prikazi minus na krajnjem
levom mestu
if (isNegativan) {
g.drawImage(slikaCifre(10), x, y, null);
// crta minus
znacajneCifre--;
indeksCifre = 1;
}
if (pozicijaEksponenta != -1) {
znacajneCifre -= (doubleStr.length()
- pozicijaEksponenta); // pozicije eksponenta, npr., "E99"
}
if (pozicijaZareza != -1) {
znacajneCifre--; // ni decimalnti
zarez nije cifra
}
// sracunavanje pocetnog mesta za cifre da bi se
uredno poravnali brojevi
mestoCifre = 7 - znacajneCifre; // mesto 1
za najznacajnije cifre
/* Evo nekog koda za debagovanje. Mozete ga omoguciti ukoliko prosirujete ovaj kod
System.out.println("znacajneCifre " + znacajneCifre);
System.out.println("indeksCifre " + indeksCifre);
System.out.println("mestoCifre " + mestoCifre);
System.out.println("isNeg " + isNegativan);
System.out.println("Exp " + pozicijaEksponenta);
*/
// sada ide petlja za prikazivanje mantise: prikazivanje
svih znacajnih cifara
while (znacajneCifre != 0) {
if ((cifra = doubleStr.charAt(indeksCifre++))
!= '.') {
cifra -= '0';
digitX = x + mestoCifre*originalnaSirina;
g.drawImage(slikaCifre(cifra),
digitX, y, null);
znacajneCifre--;
mestoCifre++;
} else { // prikazivanje decimalnog
zareza na istom mestu sa poslednjom cifrom
g.fillRect(digitX + decimalXoff,
y + decimalYoff, decimalW, decimalH);
}
}
// ukoliko broj sadrzi i eksponent, pirkazi i njega
if (pozicijaEksponenta != -1) {
if (doubleStr.charAt(pozicijaEksponenta
+ 1) == '-') { // crtanje minusa
g.drawImage(slikaCifre(10),
x + 8*originalnaSirina, y, null);
pozicijaEksponenta++; //
izostavi minus
}
indeksCifre = pozicijaEksponenta + 1;
// izostavi 'E' ili 'E'
mestoCifre = 9;
while (indeksCifre < doubleStr.length())
{ // prikazi 'ENN'
cifra = doubleStr.charAt(indeksCifre++)
- '0';
digitX = x + mestoCifre*originalnaSirina;
g.drawImage(slikaCifre(cifra),
digitX, y, null);
mestoCifre++;
}
}
g.setColor(snimljenaBoja);
}
/**********************************************************************
* Odbacivanje irelevantnih decimalnih znakova
* iz numerickog stringa.
*********************************************************************/
private String brisi(String izvor, int nDecimala) {
String brisi = "";
StringTokenizer st = new StringTokenizer(izvor,
"E.", true);
boolean naDecMestu = false;
while(st.hasMoreTokens()) {
String simbol = st.nextToken();
if (naDecMestu) {
if (simbol.length() > 5
&& Character.isDigit(simbol.charAt(0))) {
simbol = simbol.substring(0,
5);
}
naDecMestu = false;
} else if (simbol.equals(".")) {
naDecMestu = true;
}
brisi += simbol;
// debug red System.out.println(brisi);
}
return brisi;
}
}
Primer Unicode konvertora
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
public class UnicodeAplet extends Applet implements ActionListener, ItemListener {
ZnaciKanvas znak;
TextField polazniTekst;
static final int OSNOVA= 0x2200;
static final int LIMIT_OSN= 0x2700;
static final int ALFABETA_OSN= 0x0370;
public void init() {
setLayout(new BorderLayout());
Panel panel = new Panel();
/* izborna list dostupnih
fontova za prikaz karaktera*/
panel.add(new Label("Font:"));
Choice fontList = new Choice();
String[] fontNames = getToolkit().getFontList();
for (int i = 0; i < fontNames.length;
i++) {
fontList.addItem(fontNames[i]);
}
fontList.addItemListener(this);
panel.add(fontList);
Font defaultFont = new Font(fontNames[0],
Font.PLAIN, 16);
/* polje za unos broja
koda od kog pocinje prikaz, misli se
na Unicode
set znakova i hex oblik */
panel.add(new Label("Unicode
osnova:"));
polazniTekst = new TextField(Integer.toHexString(LIMIT_OSN),
4);
polazniTekst.setFont(new
Font("Monospaced", Font.PLAIN, 12));
polazniTekst.addActionListener(this);
panel.add(polazniTekst);
add("North", panel);
ScrollPane sp = new ScrollPane();
znak = new ZnaciKanvas(defaultFont,
LIMIT_OSN);
sp.add(znak);
add("Center", sp);
add("South", new Label("Karakteri=0x2200,
LimOsn=0x2700, AlfaBeta=0x0370"));
}
public void itemStateChanged(ItemEvent e) {
if (e.getStateChange() ==
ItemEvent.SELECTED) {
String fontName = (String)e.getItem();
znak.setFont(new Font(fontName, Font.PLAIN, 16));
}
}
public void actionPerformed(ActionEvent e) {
try {
int newBase = Integer.valueOf(e.getActionCommand(), 16).intValue();
znak.setBase(newBase);
} catch (NumberFormatException
nfe) {
Toolkit.getDefaultToolkit().beep();
polazniTekst.select(0, Integer.MAX_VALUE);
}
}
/*
Koriste se adapter klase da bi se izbeglo
kreiranje praznih
metoda za interfejs osluskovaca dogadjaja
*/
static class AdapterZnak extends WindowAdapter
{
public void windowClosing(WindowEvent
e) {
System.exit(0);
}
}
public static void main(String args[]) {
Frame f = new Frame("UnicodeAplet");
UnicodeAplet znaciPR = new UnicodeAplet();
znaciPR.init();
znaciPR.start();
f.add("Center", znaciPR);
f.pack();
f.setSize(400, 500);
f.show();
f.addWindowListener(new AdapterZnak());
}
}
class ZnaciKanvas extends Canvas {
Font font;
int visinaZnaka;
int sirinaZnaka;
int osnovaZnaka;
public ZnaciKanvas(Font font, int osnova) {
FontMetrics fm = Toolkit.getDefaultToolkit().getFontMetrics(font);
visinaZnaka = fm.getHeight()
+ 3;
sirinaZnaka = fm.getMaxAdvance()
+ 4;
osnovaZnaka = osnova;
setSize(sirinaZnaka * 16
+ 60, visinaZnaka * 16 + 10);
}
public void setBase(int osnova) {
osnovaZnaka = osnova;
repaint();
}
public void setFont(Font font) {
this.font = font;
repaint();
}
public void paint(Graphics g) {
g.setFont(font);
g.setColor(Color.black);
char[] nizZnaci = new char[1];
int c = osnovaZnaka;
int y = 20;
for (int v = 0; v < 16;
v++) {
g.drawString(Integer.toHexString(c), 10, y);
int x = 60;
for (int h = 0; h < 16; h++) {
nizZnaci[0] = (char)c++;
g.drawChars(nizZnaci, 0, 1, x, y);
x += sirinaZnaka;
}
y += visinaZnaka;
}
}
}