home *** CD-ROM | disk | FTP | other *** search
/ Java 1.2 How-To / JavaHowTo.iso / code / ch06.txt < prev    next >
Text File  |  1998-12-14  |  41KB  |  1,993 lines
  1. Calc.java:
  2.  
  3. import java.util.*;
  4. import java.awt.*;
  5. import java.awt.event.*;
  6. import java.applet.*;
  7.  
  8. /**
  9.  * A simple calculator
  10.  */
  11. public class Calc extends Applet
  12. {
  13.  
  14.     Display  display = new Display();
  15.  
  16. /**
  17.  *  Initialize the Calc applet
  18.  */
  19.     public void init () {
  20.  
  21.         setLayout(new BorderLayout());
  22.         Keypad   keypad = new Keypad();
  23.  
  24.         add ("North", display);
  25.         add ("Center", keypad);
  26.     }
  27.  
  28. /**
  29.  * This allows the class to be used either as an applet
  30.  * or as a standalone application.
  31.  */
  32. public static void main (String args[]) {
  33.  
  34.        Frame f = new Frame ("Calculator");
  35.        Calc calc = new Calc ();
  36.  
  37.        calc.init ();
  38.  
  39.        f.setSize (210, 200);
  40.        f.add ("Center", calc);
  41.        f.show ();
  42. }
  43.  
  44. class Keypad extends Panel
  45. implements ActionListener
  46. {
  47.          Button b7;
  48.          Button b8;
  49.          Button b9;
  50.          Button bDiv;
  51.          Button b4;
  52.          Button b5; 
  53.          Button b6;
  54.          Button bMult;
  55.          Button b1;
  56.          Button b2;
  57.          Button b3;
  58.          Button bMin;
  59.          Button bDec;
  60.          Button b0;
  61.          Button bSign;
  62.          Button bPlus;
  63.          Button bC;
  64.          Button bEqu;
  65.  
  66. /**
  67.  * Initialize the keypad, add buttons, set colors, etc.
  68.  */
  69.     Keypad (){
  70.  
  71.          Font    font = new Font ("Times", Font.BOLD, 14);
  72.          Color   functionColor = new Color (255, 255, 0);
  73.          Color   numberColor = new Color (0, 255, 255);
  74.          Color   equalsColor = new Color (0, 255, 0);
  75.          setFont (font);
  76.  
  77.          b7 = new Button ("7");
  78.          add (b7);
  79.          b7.setBackground (numberColor);
  80.          b7.addActionListener(this);
  81.  
  82.          b8 = new Button ("8");
  83.          add (b8);
  84.          b8.setBackground (numberColor);
  85.          b8.addActionListener(this);
  86.  
  87.          b9 = new Button ("9");
  88.          add (b9);
  89.          b9.setBackground (numberColor);
  90.          b9.addActionListener(this);
  91.  
  92.          bDiv = new Button ("/");
  93.          add (bDiv);
  94.          bDiv.setBackground (numberColor);
  95.          bDiv.addActionListener(this);
  96.  
  97.          b4 = new Button ("4");
  98.          add (b4);
  99.          b4.setBackground (numberColor);
  100.          b4.addActionListener(this);
  101.  
  102.          b5 = new Button ("5");
  103.          add (b5);
  104.          b5.setBackground (numberColor); 
  105.          b5.addActionListener(this);
  106.  
  107.          b6 = new Button ("6");
  108.          add (b6);
  109.          b6.setBackground (numberColor);
  110.          b6.addActionListener(this);
  111.  
  112.          bMult = new Button ("x");
  113.          add (bMult);
  114.          bMult.setBackground (numberColor);
  115.          bMult.addActionListener(this);
  116.  
  117.          b1 = new Button ("1");
  118.          add (b1);
  119.          b1.setBackground (numberColor);
  120.          b1.addActionListener(this);
  121.  
  122.          b2 = new Button ("2");
  123.          add (b2);
  124.          b2.setBackground (numberColor);
  125.          b2.addActionListener(this);
  126.  
  127.          b3 = new Button ("3");
  128.          add (b3);
  129.          b3.setBackground (numberColor);
  130.          b3.addActionListener(this);
  131.  
  132.          bMin = new Button ("-");
  133.          add (bMin);
  134.          bMin.setBackground (numberColor);
  135.          bMin.addActionListener(this);
  136.  
  137.          bDec = new Button (".");
  138.          add (bDec);
  139.          bDec.setBackground (numberColor);
  140.          bDec.addActionListener(this);
  141.  
  142.          b0 = new Button ("0");
  143.          add (b0);
  144.          b0.setBackground (numberColor);
  145.          b0.addActionListener(this);
  146.  
  147.          bSign = new Button ("+/-");
  148.          add (bSign);
  149.          bSign.setBackground (numberColor);
  150.          bSign.addActionListener(this);
  151.  
  152.          bPlus = new Button ("+");
  153.          add (bPlus);
  154.          bPlus.setBackground (numberColor);
  155.          bPlus.addActionListener(this); 
  156.  
  157.          bC = new Button ("C");
  158.          add (bC);
  159.          bC.setBackground (functionColor);
  160.          bC.addActionListener(this);
  161.  
  162.          add (new Label (""));
  163.          add (new Label (""));
  164.  
  165.          bEqu = new Button ("=");
  166.          add (bEqu);
  167.          bEqu.setBackground (equalsColor);
  168.          bEqu.addActionListener(this);
  169.  
  170.          setLayout (new GridLayout (5, 4, 4, 4));
  171.     }
  172.  
  173.     public void actionPerformed(ActionEvent event)
  174.     {
  175.         Object object = event.getSource();
  176.  
  177.         if(object == bC)
  178.         {
  179.            display.Clear ();
  180.         }
  181.  
  182.         if(object == bDec)
  183.         {
  184.            display.Dot ();
  185.         }
  186.  
  187.         if(object == bPlus)
  188.         {
  189.            display.Plus ();
  190.         }
  191.  
  192.         if(object == bMin)
  193.         {
  194.            display.Minus ();
  195.         }
  196.  
  197.         if(object == bMult)
  198.         {
  199.            display.Mul ();
  200.         }
  201.  
  202.         if(object == bDiv)
  203.         {
  204.            display.Div ();
  205.         }
  206.  
  207.         if(object == bSign)
  208.         {
  209.            display.Chs ();
  210.         }
  211.  
  212.         if(object == bEqu)
  213.         {
  214.            display.Equals ();
  215.         }
  216.  
  217.         if(object == b0)
  218.         {
  219.            display.Digit ("0");
  220.         }
  221.  
  222.         if(object == b1)
  223.         {
  224.            display.Digit ("1");
  225.         }
  226.  
  227.         if(object == b2)
  228.         {
  229.            display.Digit ("2");
  230.         }
  231.  
  232.         if(object == b3)
  233.         {
  234.            display.Digit ("3");
  235.         }
  236.  
  237.         if(object == b4)
  238.         {
  239.            display.Digit ("4");
  240.         }
  241.  
  242.         if(object == b5)
  243.         {
  244.            display.Digit ("5");
  245.         }
  246.  
  247.         if(object == b6)
  248.         {
  249.            display.Digit ("6");
  250.         }
  251.  
  252.         if(object == b7)
  253.         {
  254.            display.Digit ("7");
  255.         }
  256.  
  257.         if(object == b8)
  258.         {
  259.            display.Digit ("8");
  260.         }
  261.  
  262.         if(object == b9)
  263.         {
  264.            display.Digit ("9");
  265.         }
  266.  
  267.     }
  268. }
  269. }
  270.  
  271. /* -------------------------------------------------- */
  272.  
  273. /**
  274.  * The Keypad handles the input for the calculator
  275.  * and writes to the display.
  276.  */
  277.  
  278. /* -------------------------------------------------- */
  279.  
  280. /**
  281.  * The Display class manages displaying the calculated result
  282.  * as well as implementing the calculator function keys.
  283.  */
  284. class Display extends Panel{
  285.  
  286.     double     last = 0;
  287.     int        op = 0;
  288.     boolean    equals = false;
  289.     int        maxlen = 10;
  290.     String     s;
  291.     Label      readout = new Label("");
  292.  
  293. /**
  294.  * Initialize the display
  295.  */
  296.     Display () {
  297.  
  298.        setLayout(new BorderLayout());
  299.        setBackground (Color.red);
  300.         setFont (new Font ("Courier", Font.BOLD + Font.ITALIC, 30));
  301.         readout.setAlignment(1);
  302.         add ("Center",readout);
  303.        repaint();
  304.         Clear ();
  305.     }
  306.  
  307. /**
  308.  * Handle clicking a digit.
  309.  */
  310.     void Digit (String digit) {
  311.          checkEquals ();
  312.  
  313.               /*
  314.                *       Strip leading zeros
  315.                */
  316.          if (s.length () == 1 && s.charAt (0) == '0' && digit.charAt (0) != '.')
  317.                      s = s.substring (1);
  318.  
  319.          if (s.length () < maxlen)
  320.                      s = s + digit;
  321.          showacc ();
  322.     }
  323.  
  324. /**
  325.  * Handle a decimal point.
  326.  */
  327.     void Dot () {
  328.          checkEquals ();
  329.  
  330.               /*
  331.                *       Already have '.'
  332.                */
  333.          if (s.indexOf ('.') != -1)
  334.                      return;
  335.  
  336.          if (s.length () < maxlen)
  337.                      s = s + ".";
  338.          showacc ();
  339.     }
  340.  
  341. /**
  342. If the user clicks equals without
  343.  clicking an operator
  344.  * key first (+,-,x,/), zero the display.
  345.  */
  346.     private void checkEquals () {
  347.          if (equals == true) {
  348.                         equals = false;
  349.                      s = "0";
  350.          }
  351.     }
  352.  
  353. /**
  354.  * Stack the addition operator for later use.
  355.  */
  356.     void Plus () {
  357.          op = 1;
  358.          operation ();
  359.     }
  360.  
  361. /**
  362.  * Stack the subtraction operator for later use.
  363.  */
  364.     void Minus () {
  365.          op = 2;
  366.          operation ();
  367.     }
  368.  
  369. /**
  370.  * Stack the multiplication operator for later use.
  371.  */
  372.     void Mul () {
  373.          op = 3;
  374.          operation ();
  375.     }
  376.  
  377. /**
  378.  * Stack the division operator for later use.
  379.  */
  380.     void Div () {
  381.          op = 4;
  382.          operation ();
  383.     }
  384.  
  385. /**
  386.  * Interpret the display value as a double, and store it
  387.  * for later use (by Equals).
  388.  */
  389.     private void operation () {
  390.          if (s.length () == 0) return;
  391.  
  392.          Double xyz = Double.valueOf (s);
  393.          last = xyz.doubleValue ();
  394.  
  395.          equals = false;
  396.          s = "0";
  397.     }
  398. /**
  399.  * Negate the current value and redisplay.
  400.  */
  401.     void Chs () {
  402.          if (s.length () == 0) return;
  403.  
  404.          if (s.charAt (0) == '-') s = s.substring (1);
  405.          else s = "-" + s;
  406.  
  407.          showacc ();
  408.     }
  409.  
  410. /**
  411.  * Finish the last calculation and display the result.
  412.  */
  413.     void Equals () {
  414.          double acc;
  415.  
  416.          if (s.length () == 0)  return;
  417.          Double xyz = Double.valueOf (s);
  418.          switch (op)  {
  419.               case 1:
  420.                      acc = last + xyz.doubleValue ();
  421.                      break;
  422.  
  423.               case 2:
  424.                      acc = last - xyz.doubleValue ();
  425.                      break;
  426.  
  427.               case 3:
  428.                      acc = last * xyz.doubleValue ();
  429.                      break;
  430.  
  431.               case 4:
  432.                      acc = last / xyz.doubleValue ();
  433.                      break;
  434.  
  435.               default:
  436.                      acc = 0;
  437.                      break;
  438.          }
  439.  
  440.          s = new Double (acc).toString ();
  441.          showacc ();
  442.          equals = true;
  443.          last = 0;
  444.          op = 0;
  445.     }
  446.  
  447. /**
  448.  * Clear the display and the internal last value.
  449.  */
  450.     void Clear () {
  451.          last = 0; 
  452.          op = 0;
  453.          s = "0";
  454.          equals = false;
  455.          showacc ();
  456.     }
  457.  
  458. /**
  459.  * Demand that the display be repainted.
  460.  */
  461.     private void showacc () {
  462.         readout.setText(s);
  463.         repaint ();
  464.     }
  465.  
  466. }
  467.  
  468.  
  469.  
  470.  
  471.  
  472.  
  473.  
  474.  
  475.  
  476. Checkbox1.java:
  477.  
  478. import java.awt.*;
  479.  
  480.   import java.applet.*;
  481.  
  482.   public class Checkbox1 extends Applet
  483.  {
  484.  
  485.      void displayButton_Clicked(java.awt.event.[ccc]
  486. ActionEvent event)
  487.  {
  488.  
  489.         // clear the results area
  490.  
  491.         results.setText("");
  492.  
  493.        // display the gender
  494.  
  495.        Checkbox current = genderGroup.getSelectedCheckbox();
  496.  
  497.        results.append(current.getLabel() + "\r\n");
  498.  
  499.  
  500.        // check each of the sports
  501.  
  502.        if (artCheckbox.getState() == true)
  503.  
  504.          results.append("Art\r\n");
  505.  
  506.        if (psychologyCheckbox.getState() == true)
  507.  
  508.           results.append("Psychology\r\n");
  509.  
  510.        if (historyCheckbox.getState() == true)
  511.  
  512.           results.append("History\r\n");
  513.  
  514.        if (musicCheckbox.getState() == true)
  515.  
  516.           results.append("Music\r\n");
  517.  
  518.        if (scienceCheckbox.getState() == true)
  519.  
  520.           results.append("Science\r\n");
  521.  
  522.     }
  523.  
  524.  
  525.     public void init() {
  526.  
  527.        // Call parents init method.
  528.  
  529.        super.init();
  530.  
  531.  
  532.        // This code is automatically generated by Visual Cafe
  533.  
  534.        // when you add components to the visual environment.
  535.  
  536.        // It instantiates and initializes the components. To
  537.  
  538.        // modify the code, use only code syntax that matches
  539.  
  540.        // what Visual Cafe can generate, or Visual Cafe may
  541.  
  542.        // be unable to back parse your Java file into its 
  543.  
  544.        // visual environment.
  545.  
  546.        //{{INIT_CONTROLS
  547.  
  548.        setLayout(null); 
  549.  
  550.        resize(442,354);
  551.  
  552.        label1 = new java.awt.Label("Gender:",Label.RIGHT);
  553.  
  554.        label1.setBounds(72,24,84,28);
  555.  
  556.        add(label1);
  557.  
  558.        genderGroup = new CheckboxGroup();
  559.  
  560.        maleButton = new java.awt.Checkbox("Male",genderGroup,
  561.  
  562.              true);
  563.  
  564.        maleButton.setBounds(168,24,58,21);
  565.  
  566.        add(maleButton);
  567.  
  568.        femaleButton = new java.awt.Checkbox("Female",
  569.  
  570.              genderGroup, false); 
  571.  
  572.        femaleButton.setBounds(240,24,71,21);
  573.  
  574.        add(femaleButton);
  575.  
  576.        historyCheckbox = new java.awt.Checkbox("History");
  577.  
  578.        historyCheckbox.setBounds(36,96,60,21);
  579.  
  580.        add(historyCheckbox);
  581.  
  582.        psychologyCheckbox = new java.awt.Checkbox("Psychology");
  583.  
  584.        psychologyCheckbox.setBounds(101,96,85,21);
  585.  
  586.        add(psychologyCheckbox);
  587.  
  588.        artCheckbox = new java.awt.Checkbox("Art");
  589.  
  590.        artCheckbox.setBounds(190,96,40,21);
  591.  
  592.        add(artCheckbox);
  593.  
  594.        musicCheckbox = new java.awt.Checkbox("Music");
  595.  
  596.        musicCheckbox.setBounds(238,96,56,21);
  597.  
  598.        add(musicCheckbox);
  599.  
  600.        scienceCheckbox = new java.awt.Checkbox("Science");
  601.  
  602.        scienceCheckbox.setBounds(298,96,93,21);
  603.  
  604.        add(scienceCheckbox);
  605.  
  606.        displayButton = new java.awt.Button("Display");
  607.  
  608.        displayButton.setBounds(48,204,100,33);
  609.  
  610.        add(displayButton);
  611.  
  612.        results = new java.awt.TextArea();
  613.  
  614.        results.setBounds(180,144,246,198);
  615.  
  616.        add(results);
  617.  
  618.        Action lAction = new Action();
  619.  
  620.        displayButton.addActionListener(lAction); 
  621.  
  622.     }
  623.  
  624.  
  625.     java.awt.Label label1;
  626.  
  627.     java.awt.Checkbox maleButton;
  628.  
  629.     CheckboxGroup genderGroup;
  630.  
  631.     java.awt.Checkbox femaleButton;
  632.  
  633.     java.awt.Label label2;
  634.  
  635.     java.awt.Checkbox historyCheckbox;
  636.  
  637.     java.awt.Checkbox psychologyCheckbox;
  638.  
  639.     java.awt.Checkbox artCheckbox;
  640.  
  641.    java.awt.Checkbox musicCheckbox;
  642.  
  643.    java.awt.Checkbox scienceCheckbox; 
  644.  
  645.    java.awt.Button displayButton;
  646.  
  647.    java.awt.TextArea results;
  648.  
  649.  
  650.  
  651.    class Action implements java.awt.event.ActionListener {
  652.  
  653.       public void actionPerformed(java.awt.event.ActionEvent
  654.  
  655.             event) {
  656.  
  657.          Object object = event.getSource();
  658.  
  659.          if (object == displayButton)
  660.  
  661.             displayButton_Clicked(event);
  662.  
  663.       }
  664.  
  665.    }
  666.  
  667. }
  668.  
  669.  
  670.  
  671.  
  672.  
  673.  
  674.  
  675. Doodle.java:
  676.  
  677. import java.applet.Applet;
  678. import java.awt.*;
  679. import java.awt.event.*;
  680.  
  681. /**
  682.  * The ColorBar class displays a color bar for color selection.
  683.  */
  684. class ColorBar {
  685.  
  686. /*
  687.  * the top, left coordinate of the color bar
  688.  */
  689. int xpos, ypos;
  690.  
  691. /*
  692.  * the width and height of the color bar
  693.  */
  694. int width, height;
  695.  
  696. /*
  697.  * the current color selection index into the colors array
  698.  */
  699. int selectedColor = 3;
  700.  
  701. /*
  702.  * the array of colors available for selection
  703.  */
  704. static Color colors[] = {
  705.        Color.white, Color.gray, Color.red, Color.pink,
  706.        Color.orange, Color.yellow, Color.green, Color.magenta,
  707.        Color.cyan, Color.blue
  708. };
  709.  
  710. /**
  711.  * Create the color bar
  712.  */
  713. public ColorBar (int x, int y, int w, int h) {
  714.  
  715.        xpos = x;
  716.        ypos = y;
  717.        width = w;
  718.        height = h; 
  719. }
  720.  
  721. /**
  722.  * Paint the color bar
  723.  * @param g - destination graphics object
  724.  */
  725. void paint (Graphics g) {
  726.  
  727.        int x, y, i;
  728.        int w, h;
  729.  
  730.        for (i=0; i<colors.length; i+=1) {
  731.               w = width;
  732.               h = height/colors.length;
  733.               x = xpos;
  734.               y = ypos + (i * h);
  735.               g.setColor (Color.black);
  736.               g.fillRect (x, y, w, h);
  737.               if (i == selectedColor) {
  738.                      x += 5;
  739.                      y += 5;
  740.                      w -= 10;
  741.                      h -= 10;
  742.               } else {
  743.                      x += 1;
  744.                      y += 1;
  745.                      w -= 2;
  746.                      h -= 2;
  747.               }
  748.               g.setColor (colors[i]);
  749.               g.fillRect (x, y, w, h);
  750.        }
  751. }
  752.  
  753. /**
  754.  * Check to see whether the mouse is inside a palette box.
  755.  * If it is, set selectedColor and return true;
  756.  *        otherwise, return false.
  757.  * @param x, y - x and y position of mouse
  758.  */
  759. boolean inside (int x, int y) {
  760.  
  761.        int i, h;
  762.  
  763.        if (x < xpos || x > xpos+width) return false;
  764.        if (y < ypos || y > ypos+height) return false; 
  765.  
  766.        h = height/colors.length;
  767.        for (i=0; i<colors.length; i+=1) {
  768.               if (y < ((i+1)*h+ypos)) {
  769.                      selectedColor = i;
  770.                      return true;
  771.               }
  772.        }
  773.        return false;
  774. }
  775. }
  776.  
  777. /**
  778.  * The Doodle applet implements a drawable surface
  779.  * with a limited choice of colors to draw with.
  780.  */
  781. public class Doodle extends Frame {
  782.  
  783. /*
  784.  * the maximum number of points that can be
  785.  * saved in the xpoints, ypoints, and color arrays
  786.  */
  787. static final int MaxPoints = 1000;
  788.  
  789. /*
  790.  * arrays to hold the points where the user draws
  791.  */
  792. int xpoints[] = new int[MaxPoints];
  793. int ypoints[] = new int[MaxPoints]; 
  794.  
  795. /*
  796.  * the color of each point
  797.  */
  798. int color[] = new int[MaxPoints];
  799.  
  800. /*
  801.  * used to keep track of the previous mouse
  802.  * click to avoid filling arrays with the
  803.  * same point
  804.  */
  805. int lastx;
  806. int lasty;
  807.  
  808. /*
  809.  * the number of points in the arrays
  810.  */
  811. int npoints = 0;
  812. ColorBar colorBar;
  813. boolean inColorBar;
  814.  
  815. /**
  816.  * Set the window title and create the menus
  817.  * Create an instance of ColorBar
  818.  */
  819.  
  820.     public void New_Action(ActionEvent event)
  821.     {
  822.         Doodle doodle = new Doodle();
  823.     }
  824.  
  825.     public void Quit_Action(ActionEvent event)
  826.     {
  827.         System.exit(0);
  828.     }
  829.  
  830.     class ActionListener1 implements ActionListener
  831.     {
  832.         public void actionPerformed(ActionEvent event)
  833.         {
  834.             String str = event.getActionCommand();
  835.             if (str.equals("New"))
  836.                 New_Action(event);
  837.             else if (str.equals("Quit"))
  838.                 Quit_Action(event);
  839.         }
  840.     }
  841.  
  842. public Doodle () {
  843.  
  844.        setTitle ("Doodle");
  845.  
  846.        setBackground(Color.white);
  847.  
  848.        MenuBar menuBar = new MenuBar();
  849.        Menu fileMenu = new Menu("File");
  850.        fileMenu.add(new MenuItem("Open"));
  851.        fileMenu.add(new MenuItem("New"));
  852.        fileMenu.add(new MenuItem("Close"));
  853.        fileMenu.add(new MenuItem("-"));
  854.        fileMenu.add(new MenuItem("Quit"));
  855.        menuBar.add (fileMenu);
  856.  
  857.        Menu editMenu = new Menu("Edit");
  858.        editMenu.add(new MenuItem("Undo"));
  859.        editMenu.add(new MenuItem("Cut"));
  860.        editMenu.add(new MenuItem("Copy"));
  861.        editMenu.add(new MenuItem("Paste"));
  862.        editMenu.add(new MenuItem("-"));
  863.        editMenu.add(new MenuItem("Clear"));
  864.        menuBar.add (editMenu);
  865.        setMenuBar (menuBar);
  866.  
  867.        colorBar = new ColorBar (10, 75, 30, 200); 
  868.  
  869.     WindowListener1 lWindow = new WindowListener1();
  870.     addWindowListener(lWindow);
  871.  
  872.     MouseListener1 lMouse = new MouseListener1();
  873.     addMouseListener(lMouse);
  874.  
  875.     MouseMotionListener1 lMouseMotion = new MouseMotionListener1();
  876.     addMouseMotionListener(lMouseMotion);
  877.  
  878.     ActionListener1 lAction = new ActionListener1();
  879.     fileMenu.addActionListener(lAction);
  880.  
  881.        setSize (410, 430);
  882.        show ();
  883. }
  884.  
  885. class WindowListener1 extends WindowAdapter
  886. {
  887.     public void windowClosing(WindowEvent event)
  888.     {
  889.         Window win = event.getWindow();
  890.         win.setVisible(false);
  891.         win.dispose();
  892.         System.exit(0);
  893.     }
  894. }
  895.  
  896. class MouseMotionListener1 extends MouseMotionAdapter
  897. {
  898.     public void mouseDragged(MouseEvent e)
  899.     {
  900.         int x = e.getX();
  901.         int y = e.getY();
  902.               if (inColorBar) return;
  903.               if ((x != lastx || y != lasty) && npoints < MaxPoints) {
  904.                      lastx = x;
  905.                      lasty = y;
  906.                      xpoints[npoints] = x;
  907.                      ypoints[npoints] = y;
  908.                      color[npoints] = colorBar.selectedColor;
  909.                      npoints += 1; 
  910.                      repaint ();
  911.               }
  912.     }
  913. }
  914.  
  915. class MouseListener1 extends MouseAdapter
  916. {
  917.     public void mousePressed(MouseEvent e)
  918.     {
  919.         int x = e.getX();
  920.         int y = e.getY();
  921.               if (colorBar.inside (x, y)) {
  922.                      inColorBar = true;
  923.                      repaint ();
  924.                      return;
  925.               }
  926.               inColorBar = false;
  927.               if (npoints < MaxPoints) {
  928.                      lastx = x;
  929.                      lasty = y;
  930.                      xpoints[npoints] = x;
  931.                      ypoints[npoints] = y;
  932.                      color[npoints] = colorBar.selectedColor;
  933.                      npoints += 1;
  934.               }
  935.               npoints = 0;
  936.     }
  937. }
  938.  
  939. /**
  940.  * Redisplay the drawing space
  941.  * @param g - destination graphics object
  942.  */
  943. public void update (Graphics g) {
  944.  
  945.        int i;
  946.  
  947.        for (i=0; i<npoints; i+=1) {
  948.               g.setColor (colorBar.colors[color[i]]);
  949.               g.fillOval (xpoints[i]-5, ypoints[i]-5, 10, 10);
  950.        }
  951.        colorBar.paint (g);
  952. }
  953.  
  954. /**
  955.  * Repaint the drawing space when required
  956.  * @param g - destination graphics object
  957.  */
  958. public void paint (Graphics g) {
  959.  
  960.        update (g);
  961. }
  962.  
  963. /**
  964.  * The main method allows this class to be run as an application
  965.  * @param args - command-line arguments
  966.  */
  967. public static void main (String args[]) {
  968.  
  969.        Doodle doodle = new Doodle ();
  970. }
  971.  
  972. }
  973.  
  974.  
  975.  
  976.  
  977.  
  978.  
  979.  
  980.  
  981.  
  982. Converter.java:
  983.  
  984. import java.awt.*;
  985. import java.awt.event.*;
  986. import java.applet.Applet;
  987.  
  988. /*
  989.  * the applet class
  990.  */
  991. public class Converter extends Applet {
  992.  
  993. /*
  994.  * the "from" unit index
  995.  */
  996. int fromindex = 0;
  997.  
  998. /*
  999.  * the "to" unit index
  1000.  */
  1001. int toindex = 0;
  1002.  
  1003. /*
  1004.  * a place to print the conversion factor
  1005.  */
  1006. TextField textfield = new TextField(12);
  1007.  
  1008. /*
  1009.  * where the choice lists are displayed
  1010.  */
  1011. Panel listpanel = new Panel();
  1012.  
  1013. /*
  1014.  * where the text field is displayed
  1015.  */
  1016. Panel textpanel = new Panel();
  1017. Choice unit1 = new Choice();
  1018. Choice unit2 = new Choice();
  1019.  
  1020. /*
  1021.  * an array of conversion factors
  1022.  */
  1023. String values[][] = {
  1024.        {"1.000", "1.000 E-2", "1.000 E-5", "3.397 E-1", "3.937 E-2", "6.214 E-6"},
  1025.        {"1.000 E+2", "1.000", "1.000 E-3", "39.37","3.28", "6.214 E-4"},
  1026.        {"1.000 E+5", "1.000 E+3", "1.000", "3.937 E+4","3.281 E+3", "6.214 E-1"},
  1027.        {"2.54", "0.0254", "2.54 E-5", "1.000", "12.0","1.578 E-5"},
  1028.        {"30.48", "0.3048", "3.048 E-4", "12.0", "1.000","1.894 E-4"},
  1029.        {"1.609 E+5", "1.609 E+3", "1609", "6.336 E+4","5280", "1.000"}
  1030. };
  1031.  
  1032. /*
  1033.  * called when the applet is loaded
  1034.  * create the user interface
  1035.  */
  1036. public void init() {
  1037.  
  1038.        textfield.setText(values[fromindex][toindex]);
  1039.        textfield.setEditable (false);
  1040.  
  1041.        this.setLayout(new BorderLayout());
  1042.        listpanel.setLayout(new FlowLayout());
  1043.        add("North", listpanel);
  1044.        add("South", textpanel);
  1045.  
  1046.        Label fromlabel = new Label ("To Convert From  ",1);
  1047.        listpanel.add(fromlabel);
  1048.        unit1.addItem("Centimeters");
  1049.         unit1.addItem("Meters");
  1050.         unit1.addItem("Kilometers");
  1051.         unit1.addItem("Inches");
  1052.         unit1.addItem("Feet");
  1053.         unit1.addItem("Miles");
  1054.         listpanel.add(unit1);
  1055.  
  1056.         Label tolabel = new Label ("  to    ",1);
  1057.        listpanel.add(tolabel);
  1058.        unit2.addItem("Centimeters");
  1059.        unit2.addItem("Meters");
  1060.        unit2.addItem("Kilometers");
  1061.        unit2.addItem("Inches");
  1062.        unit2.addItem("Feet");
  1063.        unit2.addItem("Miles");
  1064.        listpanel.add(unit2);
  1065.  
  1066.        Label multlabel = new Label ("Multiply by  ",1);
  1067.        textpanel.add(multlabel);
  1068.        textpanel.add(textfield);
  1069.  
  1070.     ItemListener1 lItem = new ItemListener1();
  1071.     unit1.addItemListener(lItem);
  1072.     unit2.addItemListener(lItem);
  1073.  
  1074. }
  1075.  
  1076. /**
  1077.  * called when an action event occurs
  1078.  * @param evt - the event object
  1079.  * @param arg - the target object
  1080.  */
  1081.  
  1082. class ItemListener1 implements ItemListener
  1083. {
  1084.     public void itemStateChanged( ItemEvent e)
  1085.     {
  1086.               fromindex = unit1.getSelectedIndex();
  1087.               toindex = unit2.getSelectedIndex();
  1088.               textfield.setText(values[fromindex][toindex]);
  1089.               repaint();
  1090.     }
  1091. }
  1092.  
  1093. /**
  1094.  * application entry point
  1095.  * @param args - commandline arguments
  1096.  */
  1097.  
  1098. public static void main(String args[]) {
  1099.  
  1100.         Frame f = new Frame("Converter ");
  1101.         Converter converter = new Converter();
  1102.         converter.init();
  1103.         converter.start();
  1104.               f.addWindowListener(new WindowCloser());
  1105.  
  1106.         f.add("Center", converter);
  1107.         f.setSize(500, 100);
  1108.            f.show();
  1109. }
  1110. }
  1111.  
  1112. class WindowCloser extends WindowAdapter
  1113. {
  1114.     public void windowClosing(WindowEvent e)
  1115.     {
  1116.         Window win = e.getWindow();
  1117.         win.setVisible(false);
  1118.         win.dispose();
  1119.         System.exit(0);
  1120.     }
  1121. }
  1122.  
  1123.  
  1124.  
  1125.  
  1126.  
  1127.  
  1128.  
  1129.  
  1130. SpreadSheet.java:
  1131.  
  1132. import java.io.*;
  1133. import java.awt.*;
  1134. import java.awt.event.*;
  1135. import java.applet.*;
  1136. import javax.swing.*;
  1137. import javax.swing.text.*;
  1138.  
  1139. /*
  1140.  * the applet class
  1141.  */
  1142. public class SpreadSheet extends Applet implements KeyListener{
  1143.  
  1144. /*
  1145.  * the text entry field
  1146.  */
  1147. TextField textField;
  1148.  
  1149. /*
  1150.  * instance of the sheet panel
  1151.  */
  1152. Sheet sheet;
  1153.  
  1154. /*
  1155.  * initialize the applet
  1156.  */
  1157. public void init () {
  1158.  
  1159.         setBackground(Color.lightGray);
  1160.         setLayout(new BorderLayout());
  1161.  
  1162.        textField = new TextField ("", 80);
  1163.        sheet = new Sheet (10, 5, 400, 200, textField);
  1164.        add ("North", textField);
  1165.        add ("Center", sheet);
  1166.        textField.addKeyListener(this);
  1167. }
  1168.  
  1169. /*
  1170.  * check for return keypresses
  1171.  */
  1172. public void keyTyped(KeyEvent e){}
  1173. public void keyReleased(KeyEvent e){}
  1174. public void keyPressed(KeyEvent e)
  1175. {
  1176.     char character;
  1177.     int x;
  1178.     
  1179.  
  1180.     character = e.getKeyChar();
  1181.     x=e.getKeyCode();
  1182.  
  1183.     //Check whether the user pressed Return
  1184.     if (x == 10)
  1185.     {   
  1186.            sheet.enter (textField.getText ());
  1187.     }
  1188. }
  1189. /*
  1190.  * application entry point
  1191.  * not used when run as an applet
  1192.  * @param args - command-line arguments
  1193.  */
  1194. public static void main (String args[]) {
  1195.  
  1196.        Frame f = new Frame ("SpreadSheet");
  1197.        SpreadSheet spreadSheet = new SpreadSheet ();
  1198.  
  1199.        spreadSheet.init ();
  1200.  
  1201.        f.addWindowListener(new WindowCloser());
  1202.        f.setSize (440, 330);
  1203.        f.add ("Center", spreadSheet);
  1204.        f.show ();
  1205. }
  1206. }
  1207.  
  1208. class WindowCloser extends WindowAdapter
  1209. {
  1210.     public void windowClosing(WindowEvent e)
  1211.     {
  1212.         Window win = e.getWindow();
  1213.         win.setVisible(false);
  1214.         win.dispose();
  1215.         System.exit(0);
  1216.     }
  1217. }
  1218.  
  1219.  
  1220.  
  1221.  
  1222.  
  1223.  
  1224.  
  1225.  
  1226. Sheet.java:
  1227.  
  1228. import java.awt.*;
  1229. import java.awt.event.*;
  1230.  
  1231. /*
  1232.  * the panel that holds the cells
  1233.  */
  1234. public class Sheet extends Panel implements MouseListener
  1235. {
  1236.  
  1237. /*
  1238.  * the number of rows and columns in the spreadsheet
  1239.  */
  1240. int rows;
  1241. int cols;
  1242.  
  1243. /*
  1244.  * width and height of the panel
  1245.  */
  1246. int width;
  1247. int height;
  1248.  
  1249. /*
  1250.  * the array of cells
  1251.  */
  1252. Cell cells[][];
  1253.  
  1254. /*
  1255.  * offsets into the panel where the cells are displayed
  1256.  */
  1257. int xoffset;
  1258. int yoffset;
  1259.  
  1260. /*
  1261.  * the row and column selected by a mouse click
  1262.  */
  1263. int selectedRow = 0;
  1264. int selectedCol = 0;
  1265.  
  1266. /*
  1267.  * the text entry field
  1268.  */
  1269. TextField textField;
  1270.  
  1271. /*
  1272.  * constructor
  1273.  * create all the cells and init them
  1274.  * @param r - number of rows
  1275.  * @param c - number of columns
  1276.  * @param w - width of the panel
  1277.  * @param h - height of the panel
  1278.  * @param t - instance of text entry field
  1279.  */
  1280. public Sheet (int r, int c, int w, int h, TextField t) {
  1281.  
  1282.        int i, j;
  1283.  
  1284.        rows = r;
  1285.        cols = c;
  1286.        width = w;
  1287.        height = h;
  1288.        xoffset = 30;
  1289.        yoffset = 30;
  1290.        textField = t;
  1291.  
  1292.        cells = new Cell[rows][cols]; 
  1293.        for (i=0; i<rows; i+=1) {
  1294.               for (j=0; j<cols; j+=1) {
  1295.                      cells[i][j] = new Cell (cells, rows, cols);
  1296.               }
  1297.        }
  1298.     addMouseListener(this); 
  1299.  
  1300. }
  1301.  
  1302. /*
  1303.  * a mapping array for converting column indexes to characters
  1304.  */
  1305. static String charMap[] = {
  1306.        "a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
  1307.        "k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
  1308.        "u", "v", "w", "x", "y", "z"
  1309. };
  1310.  
  1311. /*
  1312.  * paint each cell
  1313.  * @param g - destination graphics object
  1314.  */
  1315. public void paint (Graphics g) {
  1316.  
  1317.        int i, j;
  1318.        int x, y;
  1319.        int w, h;
  1320.        double val;
  1321.        String s;
  1322.  
  1323.        w = width / cols;
  1324.        h = height / rows;
  1325.  
  1326.        x = 0;
  1327.        g.setColor (Color.black);
  1328.        for (i=0; i<rows; i+=1) {
  1329.               y = (i * height / rows) + yoffset;
  1330.               g.drawString (String.valueOf (i+1), x, y+h);
  1331.        }
  1332.        y = yoffset-2;
  1333.        for (j=0; j<cols; j+=1) {
  1334.               x = (j * width / cols) + xoffset+(w/2);
  1335.               g.drawString (charMap[j], x, y);
  1336.        }
  1337.        for (i=0; i<rows; i+=1) {
  1338.               for (j=0; j<cols; j+=1) {
  1339.                      s = cells[i][j].evalToString ();
  1340.                      x = (j * width / cols) + xoffset + 2;
  1341.                      y = (i * height / rows) + yoffset - 2;
  1342.                      if (i == selectedRow && j == selectedCol) {
  1343.                             g.setColor (Color.yellow);
  1344.                             g.fillRect (x, y, w-1, h-1);
  1345.                      } else {
  1346.                             g.setColor (Color.white);
  1347.                             g.fillRect (x, y, w-1, h-1);
  1348.                      }
  1349.                      g.setColor (Color.black);
  1350.                      g.drawString (s, x, y+h); 
  1351.               }
  1352.        }
  1353. }
  1354.  
  1355. /*
  1356.  * called to recalculate the entire spreadsheet
  1357.  */
  1358. void recalculate () {
  1359.  
  1360.        int i, j;
  1361.  
  1362.        for (i=0; i<rows; i+=1) {
  1363.               for (j=0; j<cols; j+=1) {
  1364.                      cells[i][j].evaluate ();
  1365.               }
  1366.        }
  1367. }
  1368.  
  1369. /*
  1370.  * handle mouse down events
  1371.  * @param evt - event object
  1372.  * @param x - mouse x position
  1373.  * @param y - mouse y position
  1374.  */
  1375.  
  1376.     public void mouseClicked(MouseEvent e){}
  1377.     public void mouseEntered(MouseEvent e){}
  1378.     public void mouseExited(MouseEvent e){}
  1379.     public void mouseReleased(MouseEvent e){}
  1380.     public void mousePressed(MouseEvent e)
  1381.     {
  1382.         int x = e.getX();
  1383.         int y = e.getY();
  1384.  
  1385.            int w = width / cols;
  1386.            int h = height / rows;
  1387.  
  1388.            int sr = (y-yoffset)/h;
  1389.            int sc = (x-xoffset)/w;
  1390.  
  1391.            if (sr < 0 || sr >= rows || sc < 0 || sc > cols)
  1392.            return;
  1393.  
  1394.  
  1395.            selectedRow = sr;
  1396.            selectedCol = sc; 
  1397.            repaint ();
  1398.            textField.setText (cells[selectedRow][selectedCol].text);
  1399.     }
  1400.  
  1401.  
  1402. /*
  1403.  * called to enter a text into a selected cell
  1404.  * @param s - the string to enter
  1405.  */
  1406. void enter (String s) {
  1407.  
  1408.        cells[selectedRow][selectedCol].enter (s);
  1409.        recalculate ();
  1410.        repaint ();
  1411. }
  1412. }
  1413.  
  1414.  
  1415.  
  1416.  
  1417.  
  1418.  
  1419. Cell.java:
  1420.  
  1421. import java.awt.*;
  1422.  
  1423. /*
  1424.  * Defines an individual cell
  1425.  */
  1426. public class Cell {
  1427.  
  1428. /*
  1429.  * Token types returned by Lex()
  1430.  */
  1431. static final int NUMBER = 1;
  1432. static final int EQUALS = 2;
  1433. static final int PLUS = 3;
  1434. static final int MINUS = 4;
  1435. static final int STAR = 5;
  1436. static final int SLASH = 6;
  1437. static final int TEXT = 7;
  1438. static final int EOT = 8;
  1439. static final int LEFT = 9;
  1440. static final int RIGHT = 10;
  1441. static final int UNKN = 11;
  1442. static final int FORMULA = 12;
  1443. static final int REFERENCE = 13; 
  1444.  
  1445. /*
  1446.  * What is in this cell
  1447.  */
  1448. int type;
  1449.  
  1450. /*
  1451.  * The numeric value, if this cell is numeric
  1452.  */
  1453. double value;
  1454.  
  1455. /*
  1456.  * Numeric value for this token
  1457.  */
  1458. double lexValue;
  1459.  
  1460. /*
  1461.  * Index into input string (used for parsing)
  1462.  */
  1463. int lexIndex;
  1464.  
  1465. /*
  1466.  * Token value returned from Lex()
  1467.  */
  1468. int token;
  1469.  
  1470. /*
  1471.  * The text contents of this cell
  1472.  */
  1473. String text;
  1474. int textLength;
  1475. int textIndex; 
  1476.  
  1477. /*
  1478.  * Reference to all cells in spreadsheet
  1479.  */
  1480. Cell cells[][];
  1481.  
  1482. /*
  1483.  * Error flag, set if parse error detected
  1484.  */
  1485. boolean error;
  1486.  
  1487. /*
  1488.  * Used to force rereading of tokens
  1489.  */
  1490. boolean lexFlag;
  1491.  
  1492. /*
  1493.  * Number of rows and columns in the spreadsheet
  1494.  * Used for bounds checking
  1495.  */
  1496. int cols;
  1497. int rows;
  1498.  
  1499. public Cell (Cell cs[][], int r, int c) {
  1500.  
  1501.     cells = cs;
  1502.     rows = r;
  1503.     cols = c;
  1504.     text = "";
  1505.     lexFlag = true;
  1506.     type = UNKN;
  1507. }
  1508.  
  1509. /*
  1510.  * Called to get the numeric value of this cell
  1511.  */
  1512. double evaluate () {
  1513.  
  1514.     resetLex ();
  1515.     error = false;
  1516.     switch (type) {
  1517.         case FORMULA:
  1518.         Lex ();
  1519.         value = Level1 ();
  1520.         if (error) return 0;
  1521.         return value;
  1522.  
  1523.         case NUMBER:
  1524.         value = lexValue;
  1525.         return value;
  1526.  
  1527.         case UNKN:
  1528.         return 0;
  1529.     }
  1530.     error = true;
  1531.     return 0;
  1532. }
  1533.  
  1534. /*
  1535.  * Returns the string representation of the value
  1536.  */
  1537. String evalToString () {
  1538.  
  1539.     String s;
  1540.  
  1541.     if (type == TEXT || type == UNKN) return text;
  1542.     s = String.valueOf (value);
  1543.     if (error) return "Error";
  1544.     else return s;
  1545. }
  1546.  
  1547. /*
  1548.  * Called to enter a string into this cell
  1549.  */
  1550. void enter (String s) {
  1551.  
  1552.     text = s;
  1553.     textLength = text.length ();
  1554.     resetLex ();
  1555.     error = false;
  1556.     switch (Lex ()) {
  1557.         case EQUALS:
  1558.         type = FORMULA;
  1559.         break;
  1560.  
  1561.         case NUMBER:
  1562.         type = NUMBER;
  1563.         value = lexValue;
  1564.         break;
  1565.  
  1566.         default:
  1567.         type = TEXT;
  1568.         break; 
  1569.     }
  1570. }
  1571.  
  1572. /*
  1573.  * Top level of the recursive descent parser
  1574.  * Handle plus and minus.
  1575.  */
  1576. double Level1 () {
  1577.  
  1578.     boolean ok;
  1579.     double x1, x2;
  1580.  
  1581.     x1 = Level2 ();
  1582.     if (error) return 0; 
  1583.  
  1584.     ok = true;
  1585.     while (ok) switch (Lex ()) {
  1586.         case PLUS:
  1587.         x2 = Level2 ();
  1588.         if (error) return 0;
  1589.         x1 += x2;
  1590.         break;
  1591.  
  1592.         case MINUS:
  1593.         x2 = Level2 ();
  1594.         if (error) return 0;
  1595.         x1 -= x2;
  1596.         break;
  1597.  
  1598.         default:
  1599.         Unlex ();
  1600.         ok = false;
  1601.         break;
  1602.     }
  1603.     return x1;
  1604. }
  1605.  
  1606. /*
  1607.  * Handle multiply and divide. 
  1608.  */
  1609. double Level2 () {
  1610.  
  1611.     boolean ok;
  1612.     double x1, x2;
  1613.  
  1614.     x1 = Level3 ();
  1615.     if (error) return 0;
  1616.  
  1617.     ok = true;
  1618.     while (ok) switch (Lex ()) {
  1619.         case STAR:
  1620.         x2 = Level3 ();
  1621.         if (error) return 0;
  1622.         x1 *= x2;
  1623.         break;
  1624.  
  1625.         case SLASH:
  1626.         x2 = Level3 ();
  1627.         if (error) return 0;
  1628.         x1 /= x2;
  1629.         break;
  1630.  
  1631.         default:
  1632.         Unlex ();
  1633.         ok = false;
  1634.         break;
  1635.     }
  1636.     return x1; 
  1637. }
  1638.  
  1639. /*
  1640. Handle unary minus, parentheses, constants, and cell references
  1641.  */
  1642. double Level3 () {
  1643.  
  1644.     double x1, x2;
  1645.  
  1646.     switch (Lex ()) {
  1647.         case MINUS:
  1648.         x2 = Level1 ();
  1649.         if (error) return 0; 
  1650.         return -x2;
  1651.  
  1652.         case LEFT:
  1653.         x2 = Level1 ();
  1654.         if (error) return 0;
  1655.         if (Lex () != RIGHT) {
  1656.             error = true;
  1657.             return 0;
  1658.         }
  1659.         return x2;
  1660.  
  1661.         case NUMBER:
  1662.         case REFERENCE:
  1663.         return lexValue;
  1664.     }
  1665.     error = true;
  1666.     return 0;
  1667. }
  1668.  
  1669. /*
  1670.  * Reset the lexical analyzer.
  1671.  */
  1672. void resetLex () {
  1673.  
  1674.     lexIndex = 0;
  1675.     lexFlag = true;
  1676. }
  1677.  
  1678. /*
  1679.  * Push a token back for rereading. 
  1680.  */
  1681. void Unlex () {
  1682.  
  1683.     lexFlag = false;
  1684. }
  1685.  
  1686. /*
  1687.  * Returns the next token
  1688.  */
  1689. int Lex () {
  1690.  
  1691.     if (lexFlag) {
  1692.         token = lowlevelLex ();
  1693.     }
  1694.     lexFlag = true;
  1695.     return token;
  1696. }
  1697.  
  1698. /*
  1699.  * Returns the next token in the text string
  1700.  */
  1701. int lowlevelLex () {
  1702.  
  1703.     char c;
  1704.     String s; 
  1705.  
  1706.     do {
  1707.         if (lexIndex >= textLength) return EOT;
  1708.         c = text.charAt (lexIndex++);
  1709.     } while (c == ' ');
  1710.     switch (c) {
  1711.         case '=':
  1712.         return EQUALS;
  1713.  
  1714.         case '+':
  1715.         return PLUS;
  1716.  
  1717.         case '-':
  1718.         return MINUS; 
  1719.  
  1720.         case '*':
  1721.         return STAR;
  1722.  
  1723.         case '/':
  1724.         return SLASH;
  1725.  
  1726.         case '(':
  1727.         return LEFT;
  1728.  
  1729.         case ')':
  1730.         return RIGHT;
  1731.     }
  1732.  
  1733.     if (c >= '0' && c <= '9') {
  1734.         s = "";
  1735.         while ((c >= '0' && c <= '9') || c == '.' ||
  1736.             c == '-' || c == 'e' || c == 'E') {
  1737.             s += c;
  1738.             if (lexIndex >= textLength) break;
  1739.             c = text.charAt (lexIndex++);
  1740.         }
  1741.         lexIndex -= 1;
  1742.         try {
  1743.             lexValue = Double.valueOf (s).doubleValue();
  1744.         } catch (NumberFormatException e) {
  1745.             System.out.println (e);
  1746.             error = true;
  1747.             return UNKN;
  1748.         }
  1749.         return NUMBER; 
  1750.     }
  1751.     if (c >= 'a' && c <= 'z') {
  1752.         int col = c - 'a';
  1753.         int row;
  1754.         s = "";
  1755.         if (lexIndex >= textLength) {
  1756.             error = true;
  1757.             return UNKN;
  1758.         }
  1759.         c = text.charAt (lexIndex++);
  1760.         while (c >= '0' && c <= '9') {
  1761.             s += c;
  1762.             if (lexIndex >= textLength) break;
  1763.             c = text.charAt (lexIndex++);
  1764.         }
  1765.         lexIndex -= 1;
  1766.         try {
  1767.             row = Integer.valueOf (s).intValue() - 1;
  1768.         } catch (NumberFormatException e) {
  1769.             error = true;
  1770.             return UNKN;
  1771.         }
  1772.         if (row >= rows || col >= cols) {
  1773.             error = true;
  1774.             return REFERENCE; 
  1775.         }
  1776.         lexValue = cells[row][col].evaluate();
  1777.         if (cells[row][col].error) error = true;
  1778.         return REFERENCE;
  1779.     }
  1780.     return TEXT;
  1781. }
  1782. }
  1783.  
  1784.  
  1785.  
  1786.  
  1787.  
  1788.  
  1789.  
  1790.  
  1791. ColorPicker.java:
  1792.  
  1793. import java.applet.Applet;
  1794. import java.awt.*;
  1795. import java.awt.event.*;
  1796.  
  1797.  
  1798. /*
  1799.  * the Applet class
  1800.  */
  1801. public class ColorPicker extends Applet implements AdjustmentListener
  1802.  
  1803. {
  1804.  
  1805. /*
  1806.  * the panel that holds the sliders that
  1807.  * control the RGB values
  1808.  */
  1809. Panel controls = new Panel();
  1810.  
  1811. /*
  1812.  * the panel that holds the sample color
  1813.  */
  1814. Panel sample = new Panel();
  1815.  
  1816. public void adjustmentValueChanged(AdjustmentEvent evt)
  1817. {
  1818.       Object object1 = evt.getSource();
  1819.  
  1820.       if (object1 ==  (sbRed))
  1821.       {
  1822.               tfRed.setText(String.valueOf(sbRed.getValue()));
  1823.               changecolor();
  1824.          }
  1825.  
  1826.       if (object1 ==  (sbGreen))
  1827.       {
  1828.               tfGreen.setText(String.valueOf(sbGreen.getValue()));
  1829.               changecolor();
  1830.          }
  1831.  
  1832.       if (object1 ==  (sbBlue))
  1833.       {
  1834.               tfBlue.setText(String.valueOf(sbBlue.getValue()));
  1835.               changecolor();
  1836.       }
  1837. }
  1838.  
  1839. /*
  1840.  *the red scrollbar
  1841.  */
  1842. Scrollbar sbRed;
  1843.  
  1844. /*
  1845.  * the green scrollbar
  1846.  */
  1847. Scrollbar sbGreen;
  1848.  
  1849.  
  1850. /*
  1851.  * the blue scrollbar
  1852.  */
  1853. Scrollbar sbBlue;
  1854.  
  1855. /*
  1856.  * the red component TextField
  1857.  */
  1858. TextField tfRed;
  1859.  
  1860. /*
  1861.  * the green component TextField
  1862.  */
  1863. TextField tfGreen; 
  1864.  
  1865. /*
  1866.  * the blue component TextField
  1867.  */
  1868. TextField tfBlue;
  1869. int min = 0;
  1870. int max = 255;
  1871.  
  1872. /*
  1873.  * initilaizes the applet
  1874.  */
  1875. public void init () {
  1876.  
  1877.        this.setLayout(new BorderLayout());
  1878.        controls.setLayout (new GridLayout(3,3,5,5));
  1879.        this.add ("South",controls);
  1880.        this.add ("Center",sample);
  1881.  
  1882.        tfRed = new TextField (5);
  1883.        tfGreen = new TextField (5);
  1884.        tfBlue = new TextField (5);
  1885.        controls.add (new Label ("Red",1));
  1886.        controls.add (new Label ("Green",1));
  1887.        controls.add (new Label ("Blue",1));
  1888.        controls.add (tfRed);
  1889.        controls.add (tfGreen);
  1890.        controls.add (tfBlue);
  1891.  
  1892.        sbRed = new Scrollbar (Scrollbar.HORIZONTAL,0, 1, min, max);
  1893.        //set the values for the scrollbar
  1894.        // value, page size, min, max
  1895.        controls.add (sbRed);
  1896.     sbRed.addAdjustmentListener(this);
  1897.  
  1898.        sbGreen = new Scrollbar (Scrollbar.HORIZONTAL,0, 1, min, max);
  1899.        //set the values for the scrollbar
  1900.        // value, page size, min, max
  1901.        controls.add (sbGreen);
  1902.     sbGreen.addAdjustmentListener(this);
  1903.  
  1904.        sbBlue = new Scrollbar (Scrollbar.HORIZONTAL,0, 1, min, max);
  1905.        //set the values for the scrollbar
  1906.        // value, page size, min, max
  1907.        controls.add (sbBlue);
  1908.     sbBlue.addAdjustmentListener(this); 
  1909.  
  1910.        // sets the text fields to the slider value
  1911.        tfRed.setText(String.valueOf(sbRed.getValue()));
  1912.        tfGreen.setText(String.valueOf(sbGreen.getValue()));
  1913.        tfBlue.setText(String.valueOf(sbBlue.getValue()));
  1914.  
  1915.        changecolor();
  1916. }
  1917.  
  1918. /** Gets the current value in the text field.
  1919.  * That's guaranteed to be the same as the value
  1920.  * in the scroller (subject to rounding, of course).
  1921.  * @param textField - the textField
  1922.  */
  1923. double getValue(TextField textField) {
  1924.  
  1925.        double f;
  1926.        try {
  1927.               f = Double.valueOf(textField.getText())
  1928. σdoubleValue();
  1929.        } catch (java.lang.NumberFormatException e) {
  1930.               f = 0.0;
  1931.        }
  1932.        return f;
  1933. }
  1934.  
  1935.  
  1936. /*
  1937.  * changes the color of the sample to the
  1938.  * color defined by the RGB values set by
  1939.  * the user
  1940.  */
  1941. public void changecolor () {
  1942.  
  1943.        int i;
  1944.  
  1945.        sample.setBackground(new Color((int)getValue(tfRed),
  1946.               (int)getValue(tfGreen), (int)getValue(tfBlue)));
  1947.        repaint();
  1948. }
  1949.  
  1950. public void update (Graphics g) {
  1951.  
  1952.        paintAll(g);
  1953. }
  1954.  
  1955. /*
  1956.  * application entry point
  1957.  * not used when run as an applet
  1958.  * @param args - command line arguments
  1959.  */
  1960. public static void main (String args[]) {
  1961.  
  1962.        Frame f = new Frame ("ColorPicker");
  1963.        ColorPicker colorPicker = new ColorPicker ();
  1964.  
  1965.        colorPicker.init ();
  1966.        f.addWindowListener(new WindowCloser());
  1967.  
  1968.     f.setSize (300, 200);
  1969.     f.add ("Center", colorPicker);
  1970.        f.show ();
  1971. }
  1972. }
  1973.  
  1974. class WindowCloser extends WindowAdapter
  1975. {
  1976.     public void windowClosing(WindowEvent e)
  1977.     {
  1978.         Window win = e.getWindow();
  1979.         win.setVisible(false);
  1980.         win.dispose();
  1981.         System.exit(0);
  1982.     }
  1983. }
  1984.  
  1985.  
  1986.  
  1987.  
  1988.  
  1989.  
  1990.  
  1991.  
  1992.  
  1993.