KalkulatorLukasevic.html
 
 

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;
        }
    }
}
 

                   UnicodeAplet