| /* |
| * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * - Neither the name of Oracle nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS |
| * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
| * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
| * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| /* |
| */ |
| |
| import java.applet.Applet; |
| import java.awt.*; |
| import java.awt.event.*; |
| import java.io.*; |
| import java.lang.*; |
| import java.net.*; |
| |
| public class SpreadSheet |
| extends Applet |
| implements MouseListener, KeyListener { |
| String title; |
| Font titleFont; |
| Color cellColor; |
| Color inputColor; |
| int cellWidth = 100; |
| int cellHeight = 15; |
| int titleHeight = 15; |
| int rowLabelWidth = 15; |
| Font inputFont; |
| boolean isStopped = false; |
| boolean fullUpdate = true; |
| int rows; |
| int columns; |
| int currentKey = -1; |
| int selectedRow = -1; |
| int selectedColumn = -1; |
| SpreadSheetInput inputArea; |
| Cell cells[][]; |
| Cell current = null; |
| |
| public synchronized void init() { |
| String rs; |
| |
| cellColor = Color.white; |
| inputColor = new Color(100, 100, 225); |
| inputFont = new Font("Monospaced", Font.PLAIN, 10); |
| titleFont = new Font("Monospaced", Font.BOLD, 12); |
| title = getParameter("title"); |
| if (title == null) { |
| title = "Spreadsheet"; |
| } |
| rs = getParameter("rows"); |
| if (rs == null) { |
| rows = 9; |
| } else { |
| rows = Integer.parseInt(rs); |
| } |
| rs = getParameter("columns"); |
| if (rs == null) { |
| columns = 5; |
| } else { |
| columns = Integer.parseInt(rs); |
| } |
| cells = new Cell[rows][columns]; |
| char l[] = new char[1]; |
| for (int i=0; i < rows; i++) { |
| for (int j=0; j < columns; j++) { |
| |
| cells[i][j] = new Cell(this, |
| Color.lightGray, |
| Color.black, |
| cellColor, |
| cellWidth - 2, |
| cellHeight - 2); |
| l[0] = (char)((int)'a' + j); |
| rs = getParameter("" + new String(l) + (i+1)); |
| if (rs != null) { |
| cells[i][j].setUnparsedValue(rs); |
| } |
| } |
| } |
| |
| Dimension d = getSize(); |
| inputArea = new SpreadSheetInput(null, this, d.width - 2, cellHeight - 1, |
| inputColor, Color.white); |
| resize(columns * cellWidth + rowLabelWidth, |
| (rows + 3) * cellHeight + titleHeight); |
| addMouseListener(this); |
| addKeyListener(this); |
| } |
| |
| public void setCurrentValue(float val) { |
| if (selectedRow == -1 || selectedColumn == -1) { |
| return; |
| } |
| cells[selectedRow][selectedColumn].setValue(val); |
| repaint(); |
| } |
| |
| public void stop() { |
| isStopped = true; |
| } |
| |
| public void start() { |
| isStopped = false; |
| } |
| |
| public void destroy() { |
| for (int i=0; i < rows; i++) { |
| for (int j=0; j < columns; j++) { |
| if (cells[i][j].type == Cell.URL) { |
| cells[i][j].updaterThread.stop(); |
| } |
| } |
| } |
| } |
| |
| public void setCurrentValue(int type, String val) { |
| if (selectedRow == -1 || selectedColumn == -1) { |
| return; |
| } |
| cells[selectedRow][selectedColumn].setValue(type, val); |
| repaint(); |
| } |
| |
| public void update(Graphics g) { |
| if (! fullUpdate) { |
| int cx, cy; |
| |
| g.setFont(titleFont); |
| for (int i=0; i < rows; i++) { |
| for (int j=0; j < columns; j++) { |
| if (cells[i][j].needRedisplay) { |
| cx = (j * cellWidth) + 2 + rowLabelWidth; |
| cy = ((i+1) * cellHeight) + 2 + titleHeight; |
| cells[i][j].paint(g, cx, cy); |
| } |
| } |
| } |
| } else { |
| paint(g); |
| fullUpdate = false; |
| } |
| } |
| |
| public void recalculate() { |
| int i,j; |
| |
| //System.out.println("SpreadSheet.recalculate"); |
| for (i=0; i < rows; i++) { |
| for (j=0; j < columns; j++) { |
| if (cells[i][j] != null && cells[i][j].type == Cell.FORMULA) { |
| cells[i][j].setRawValue(evaluateFormula(cells[i][j].parseRoot)); |
| cells[i][j].needRedisplay = true; |
| } |
| } |
| } |
| repaint(); |
| } |
| |
| public float evaluateFormula(Node n) { |
| float val = 0.0f; |
| |
| //System.out.println("evaluateFormula:"); |
| //n.print(3); |
| if (n == null) { |
| //System.out.println("Null node"); |
| return val; |
| } |
| switch (n.type) { |
| case Node.OP: |
| val = evaluateFormula(n.left); |
| switch (n.op) { |
| case '+': |
| val += evaluateFormula(n.right); |
| break; |
| case '*': |
| val *= evaluateFormula(n.right); |
| break; |
| case '-': |
| val -= evaluateFormula(n.right); |
| break; |
| case '/': |
| val /= evaluateFormula(n.right); |
| break; |
| } |
| break; |
| case Node.VALUE: |
| //System.out.println("=>" + n.value); |
| return n.value; |
| case Node.CELL: |
| if (n == null) { |
| //System.out.println("NULL at 192"); |
| } else { |
| if (cells[n.row][n.column] == null) { |
| //System.out.println("NULL at 193"); |
| } else { |
| //System.out.println("=>" + cells[n.row][n.column].value); |
| return cells[n.row][n.column].value; |
| } |
| } |
| } |
| |
| //System.out.println("=>" + val); |
| return val; |
| } |
| |
| public synchronized void paint(Graphics g) { |
| int i, j; |
| int cx, cy; |
| char l[] = new char[1]; |
| |
| |
| Dimension d = getSize(); |
| |
| g.setFont(titleFont); |
| i = g.getFontMetrics().stringWidth(title); |
| g.drawString((title == null) ? "Spreadsheet" : title, |
| (d.width - i) / 2, 12); |
| g.setColor(inputColor); |
| g.fillRect(0, cellHeight, d.width, cellHeight); |
| g.setFont(titleFont); |
| for (i=0; i < rows+1; i++) { |
| cy = (i+2) * cellHeight; |
| g.setColor(getBackground()); |
| g.draw3DRect(0, cy, d.width, 2, true); |
| if (i < rows) { |
| g.setColor(Color.red); |
| g.drawString("" + (i+1), 2, cy + 12); |
| } |
| } |
| |
| g.setColor(Color.red); |
| cy = (rows+3) * cellHeight + (cellHeight / 2); |
| for (i=0; i < columns; i++) { |
| cx = i * cellWidth; |
| g.setColor(getBackground()); |
| g.draw3DRect(cx + rowLabelWidth, |
| 2 * cellHeight, 1, d.height, true); |
| if (i < columns) { |
| g.setColor(Color.red); |
| l[0] = (char)((int)'A' + i); |
| g.drawString(new String(l), |
| cx + rowLabelWidth + (cellWidth / 2), |
| cy); |
| } |
| } |
| |
| for (i=0; i < rows; i++) { |
| for (j=0; j < columns; j++) { |
| cx = (j * cellWidth) + 2 + rowLabelWidth; |
| cy = ((i+1) * cellHeight) + 2 + titleHeight; |
| if (cells[i][j] != null) { |
| cells[i][j].paint(g, cx, cy); |
| } |
| } |
| } |
| |
| g.setColor(getBackground()); |
| g.draw3DRect(0, titleHeight, |
| d.width, |
| d.height - titleHeight, |
| false); |
| inputArea.paint(g, 1, titleHeight + 1); |
| } |
| |
| //1.1 event handling |
| |
| public void mouseClicked(MouseEvent e) |
| {} |
| |
| public void mousePressed(MouseEvent e) |
| { |
| int x = e.getX(); |
| int y = e.getY(); |
| Cell cell; |
| if (y < (titleHeight + cellHeight)) { |
| selectedRow = -1; |
| if (y <= titleHeight && current != null) { |
| current.deselect(); |
| current = null; |
| } |
| e.consume(); |
| } |
| if (x < rowLabelWidth) { |
| selectedRow = -1; |
| if (current != null) { |
| current.deselect(); |
| current = null; |
| } |
| e.consume(); |
| |
| } |
| selectedRow = ((y - cellHeight - titleHeight) / cellHeight); |
| selectedColumn = (x - rowLabelWidth) / cellWidth; |
| if (selectedRow > rows || |
| selectedColumn >= columns) { |
| selectedRow = -1; |
| if (current != null) { |
| current.deselect(); |
| current = null; |
| } |
| } else { |
| if (selectedRow >= rows) { |
| selectedRow = -1; |
| if (current != null) { |
| current.deselect(); |
| current = null; |
| } |
| e.consume(); |
| } |
| if (selectedRow != -1) { |
| cell = cells[selectedRow][selectedColumn]; |
| inputArea.setText(new String(cell.getPrintString())); |
| if (current != null) { |
| current.deselect(); |
| } |
| current = cell; |
| current.select(); |
| requestFocus(); |
| fullUpdate = true; |
| repaint(); |
| } |
| e.consume(); |
| } |
| } |
| |
| public void mouseReleased(MouseEvent e) |
| {} |
| |
| public void mouseEntered(MouseEvent e) |
| {} |
| |
| public void mouseExited(MouseEvent e) |
| {} |
| |
| public void keyPressed(KeyEvent e) |
| { |
| } |
| |
| public void keyTyped(KeyEvent e) { |
| fullUpdate=true; |
| inputArea.processKey(e); |
| e.consume(); |
| } |
| |
| public void keyReleased(KeyEvent e) |
| {} |
| |
| public String getAppletInfo() { |
| return "Title: SpreadSheet \nAuthor: Sami Shaio \nA simple spread sheet."; |
| } |
| |
| public String[][] getParameterInfo() { |
| String[][] info = { |
| {"title", "string", "The title of the spread sheet. Default is 'Spreadsheet'"}, |
| {"rows", "int", "The number of rows. Default is 9."}, |
| {"columns", "int", "The number of columns. Default is 5."} |
| }; |
| return info; |
| } |
| |
| |
| } |
| |
| class CellUpdater extends Thread { |
| Cell target; |
| InputStream dataStream = null; |
| StreamTokenizer tokenStream; |
| |
| public CellUpdater(Cell c) { |
| super("cell updater"); |
| target = c; |
| } |
| |
| public void run() { |
| try { |
| dataStream = new URL(target.app.getDocumentBase(), |
| target.getValueString()).openStream(); |
| tokenStream = new StreamTokenizer(new BufferedReader(new InputStreamReader(dataStream))); |
| tokenStream.eolIsSignificant(false); |
| |
| while (true) { |
| switch (tokenStream.nextToken()) { |
| case StreamTokenizer.TT_EOF: |
| dataStream.close(); |
| return; |
| default: |
| break; |
| case StreamTokenizer.TT_NUMBER: |
| target.setTransientValue((float)tokenStream.nval); |
| if (! target.app.isStopped && ! target.paused) { |
| target.app.repaint(); |
| } |
| break; |
| } |
| try { |
| Thread.sleep(2000); |
| } catch (InterruptedException e) { |
| break; |
| } |
| } |
| } catch (IOException e) { |
| return; |
| } |
| } |
| } |
| |
| class Cell { |
| public static final int VALUE = 0; |
| public static final int LABEL = 1; |
| public static final int URL = 2; |
| public static final int FORMULA = 3; |
| |
| Node parseRoot; |
| boolean needRedisplay; |
| boolean selected = false; |
| boolean transientValue = false; |
| public int type = Cell.VALUE; |
| String valueString = ""; |
| String printString = "v"; |
| float value; |
| Color bgColor; |
| Color fgColor; |
| Color highlightColor; |
| int width; |
| int height; |
| SpreadSheet app; |
| CellUpdater updaterThread; |
| boolean paused = false; |
| |
| public Cell(SpreadSheet app, |
| Color bgColor, |
| Color fgColor, |
| Color highlightColor, |
| int width, |
| int height) { |
| this.app = app; |
| this.bgColor = bgColor; |
| this.fgColor = fgColor; |
| this.highlightColor = highlightColor; |
| this.width = width; |
| this.height = height; |
| needRedisplay = true; |
| } |
| |
| public void setRawValue(float f) { |
| valueString = Float.toString(f); |
| value = f; |
| } |
| public void setValue(float f) { |
| setRawValue(f); |
| printString = "v" + valueString; |
| type = Cell.VALUE; |
| paused = false; |
| app.recalculate(); |
| needRedisplay = true; |
| } |
| |
| public void setTransientValue(float f) { |
| transientValue = true; |
| value = f; |
| needRedisplay = true; |
| app.recalculate(); |
| } |
| |
| public void setUnparsedValue(String s) { |
| switch (s.charAt(0)) { |
| case 'v': |
| setValue(Cell.VALUE, s.substring(1)); |
| break; |
| case 'f': |
| setValue(Cell.FORMULA, s.substring(1)); |
| break; |
| case 'l': |
| setValue(Cell.LABEL, s.substring(1)); |
| break; |
| case 'u': |
| setValue(Cell.URL, s.substring(1)); |
| break; |
| } |
| } |
| |
| /** |
| * Parse a spreadsheet formula. The syntax is defined as: |
| * |
| * formula -> value |
| * formula -> value op value |
| * value -> '(' formula ')' |
| * value -> cell |
| * value -> <number> |
| * op -> '+' | '*' | '/' | '-' |
| * cell -> <letter><number> |
| */ |
| public String parseFormula(String formula, Node node) { |
| String subformula; |
| String restFormula; |
| float value; |
| int length = formula.length(); |
| Node left; |
| Node right; |
| char op; |
| |
| if (formula == null) { |
| return null; |
| } |
| subformula = parseValue(formula, node); |
| //System.out.println("subformula = " + subformula); |
| if (subformula == null || subformula.length() == 0) { |
| //System.out.println("Parse succeeded"); |
| return null; |
| } |
| if (subformula == formula) { |
| //System.out.println("Parse failed"); |
| return formula; |
| } |
| |
| // parse an operator and then another value |
| switch (op = subformula.charAt(0)) { |
| case 0: |
| //System.out.println("Parse succeeded"); |
| return null; |
| case ')': |
| //System.out.println("Returning subformula=" + subformula); |
| return subformula; |
| case '+': |
| case '*': |
| case '-': |
| case '/': |
| restFormula = subformula.substring(1); |
| subformula = parseValue(restFormula, right=new Node()); |
| //System.out.println("subformula(2) = " + subformula); |
| if (subformula != restFormula) { |
| //System.out.println("Parse succeeded"); |
| left = new Node(node); |
| node.left = left; |
| node.right = right; |
| node.op = op; |
| node.type = Node.OP; |
| //node.print(3); |
| return subformula; |
| } else { |
| //System.out.println("Parse failed"); |
| return formula; |
| } |
| default: |
| //System.out.println("Parse failed (bad operator): " + subformula); |
| return formula; |
| } |
| } |
| |
| public String parseValue(String formula, Node node) { |
| char c = formula.charAt(0); |
| String subformula; |
| String restFormula; |
| float value; |
| int row; |
| int column; |
| |
| //System.out.println("parseValue: " + formula); |
| restFormula = formula; |
| if (c == '(') { |
| //System.out.println("parseValue(" + formula + ")"); |
| restFormula = formula.substring(1); |
| subformula = parseFormula(restFormula, node); |
| //System.out.println("rest=(" + subformula + ")"); |
| if (subformula == null || |
| subformula.length() == restFormula.length()) { |
| //System.out.println("Failed"); |
| return formula; |
| } else if (! (subformula.charAt(0) == ')')) { |
| //System.out.println("Failed (missing parentheses)"); |
| return formula; |
| } |
| restFormula = subformula; |
| } else if (c >= '0' && c <= '9') { |
| int i; |
| |
| //System.out.println("formula=" + formula); |
| for (i=0; i < formula.length(); i++) { |
| c = formula.charAt(i); |
| if ((c < '0' || c > '9') && c != '.') { |
| break; |
| } |
| } |
| try { |
| value = Float.valueOf(formula.substring(0, i)).floatValue(); |
| } catch (NumberFormatException e) { |
| //System.out.println("Failed (number format error)"); |
| return formula; |
| } |
| node.type = Node.VALUE; |
| node.value = value; |
| //node.print(3); |
| restFormula = formula.substring(i); |
| //System.out.println("value= " + value + " i=" + i + |
| // " rest = " + restFormula); |
| return restFormula; |
| } else if (c >= 'A' && c <= 'Z') { |
| int i; |
| |
| column = c - 'A'; |
| restFormula = formula.substring(1); |
| for (i=0; i < restFormula.length(); i++) { |
| c = restFormula.charAt(i); |
| if (c < '0' || c > '9') { |
| break; |
| } |
| } |
| row = Float.valueOf(restFormula.substring(0, i)).intValue(); |
| //System.out.println("row = " + row + " column = " + column); |
| node.row = row - 1; |
| node.column = column; |
| node.type = Node.CELL; |
| //node.print(3); |
| if (i == restFormula.length()) { |
| restFormula = null; |
| } else { |
| restFormula = restFormula.substring(i); |
| if (restFormula.charAt(0) == 0) { |
| return null; |
| } |
| } |
| } |
| |
| return restFormula; |
| } |
| |
| |
| public void setValue(int type, String s) { |
| paused = false; |
| if (this.type == Cell.URL) { |
| updaterThread.stop(); |
| updaterThread = null; |
| } |
| |
| valueString = new String(s); |
| this.type = type; |
| needRedisplay = true; |
| switch (type) { |
| case Cell.VALUE: |
| setValue(Float.valueOf(s).floatValue()); |
| break; |
| case Cell.LABEL: |
| printString = "l" + valueString; |
| break; |
| case Cell.URL: |
| printString = "u" + valueString; |
| updaterThread = new CellUpdater(this); |
| updaterThread.start(); |
| break; |
| case Cell.FORMULA: |
| parseFormula(valueString, parseRoot = new Node()); |
| printString = "f" + valueString; |
| break; |
| } |
| app.recalculate(); |
| } |
| |
| public String getValueString() { |
| return valueString; |
| } |
| |
| public String getPrintString() { |
| return printString; |
| } |
| |
| public void select() { |
| selected = true; |
| paused = true; |
| } |
| public void deselect() { |
| selected = false; |
| paused = false; |
| needRedisplay = true; |
| app.repaint(); |
| } |
| public void paint(Graphics g, int x, int y) { |
| if (selected) { |
| g.setColor(highlightColor); |
| } else { |
| g.setColor(bgColor); |
| } |
| g.fillRect(x, y, width - 1, height); |
| if (valueString != null) { |
| switch (type) { |
| case Cell.VALUE: |
| case Cell.LABEL: |
| g.setColor(fgColor); |
| break; |
| case Cell.FORMULA: |
| g.setColor(Color.red); |
| break; |
| case Cell.URL: |
| g.setColor(Color.blue); |
| break; |
| } |
| if (transientValue){ |
| g.drawString("" + value, x, y + (height / 2) + 5); |
| } else { |
| if (valueString.length() > 14) { |
| g.drawString(valueString.substring(0, 14), |
| x, y + (height / 2) + 5); |
| } else { |
| g.drawString(valueString, x, y + (height / 2) + 5); |
| } |
| } |
| } |
| needRedisplay = false; |
| } |
| } |
| |
| class Node { |
| public static final int OP = 0; |
| public static final int VALUE = 1; |
| public static final int CELL = 2; |
| |
| int type; |
| Node left; |
| Node right; |
| int row; |
| int column; |
| float value; |
| char op; |
| |
| public Node() { |
| left = null; |
| right = null; |
| value = 0; |
| row = -1; |
| column = -1; |
| op = 0; |
| type = Node.VALUE; |
| } |
| public Node(Node n) { |
| left = n.left; |
| right = n.right; |
| value = n.value; |
| row = n.row; |
| column = n.column; |
| op = n.op; |
| type = n.type; |
| } |
| public void indent(int ind) { |
| for (int i = 0; i < ind; i++) { |
| System.out.print(" "); |
| } |
| } |
| public void print(int indentLevel) { |
| char l[] = new char[1]; |
| indent(indentLevel); |
| System.out.println("NODE type=" + type); |
| indent(indentLevel); |
| switch (type) { |
| case Node.VALUE: |
| System.out.println(" value=" + value); |
| break; |
| case Node.CELL: |
| l[0] = (char)((int)'A' + column); |
| System.out.println(" cell=" + new String(l) + (row+1)); |
| break; |
| case Node.OP: |
| System.out.println(" op=" + op); |
| left.print(indentLevel + 3); |
| right.print(indentLevel + 3); |
| break; |
| } |
| } |
| } |
| |
| class InputField { |
| int maxchars = 50; |
| int cursorPos = 0; |
| Applet app; |
| String sval; |
| char buffer[]; |
| int nChars; |
| int width; |
| int height; |
| Color bgColor; |
| Color fgColor; |
| |
| public InputField(String initValue, Applet app, int width, int height, |
| Color bgColor, Color fgColor) { |
| this.width = width; |
| this.height = height; |
| this.bgColor = bgColor; |
| this.fgColor = fgColor; |
| this.app = app; |
| buffer = new char[maxchars]; |
| nChars = 0; |
| if (initValue != null) { |
| initValue.getChars(0, initValue.length(), this.buffer, 0); |
| nChars = initValue.length(); |
| } |
| sval = initValue; |
| } |
| |
| public void setText(String val) { |
| int i; |
| |
| for (i=0; i < maxchars; i++) { |
| buffer[i] = 0; |
| } |
| if (val == null) { |
| sval = ""; |
| } else { |
| sval = val; |
| } |
| nChars = sval.length(); |
| sval.getChars(0, sval.length(), buffer, 0); |
| } |
| |
| public String getValue() { |
| return sval; |
| } |
| |
| public void paint(Graphics g, int x, int y) { |
| g.setColor(bgColor); |
| g.fillRect(x, y, width, height); |
| if (sval != null) { |
| g.setColor(fgColor); |
| g.drawString(sval, x, y + (height / 2) + 3); |
| } |
| } |
| |
| public void processKey(KeyEvent e) { |
| char ch = e.getKeyChar(); |
| switch (ch) { |
| case '\b': // delete |
| if (nChars > 0) { |
| nChars--; |
| sval = new String(buffer, 0, nChars); |
| } |
| break; |
| case '\n': // return |
| selected(); |
| break; |
| default: |
| if (nChars < maxchars && ch >= '0') { |
| buffer[nChars++] = ch; |
| sval = new String(buffer, 0, nChars); |
| } |
| } |
| app.repaint(); |
| } |
| |
| public void keyReleased(KeyEvent e) { |
| } |
| |
| public void selected() { |
| } |
| } |
| |
| class SpreadSheetInput |
| extends InputField { |
| |
| public SpreadSheetInput(String initValue, |
| SpreadSheet app, |
| int width, |
| int height, |
| Color bgColor, |
| Color fgColor) { |
| super(initValue, app, width, height, bgColor, fgColor); |
| } |
| |
| public void selected() { |
| float f; |
| sval = ("".equals(sval)) ? "v":sval; |
| switch (sval.charAt(0)) { |
| case 'v': |
| String s= sval.substring(1); |
| try { |
| int i; |
| for (i = 0; i < s.length(); i++) { |
| char c = s.charAt(i); |
| if (c < '0' || c > '9') |
| break; |
| } |
| s = s.substring(0, i); |
| f = Float.valueOf(s).floatValue(); |
| ((SpreadSheet)app).setCurrentValue(f); |
| } catch (NumberFormatException e) { |
| System.out.println("Not a float: '" + s + "'"); |
| } |
| break; |
| case 'l': |
| ((SpreadSheet)app).setCurrentValue(Cell.LABEL, sval.substring(1)); |
| break; |
| case 'u': |
| ((SpreadSheet)app).setCurrentValue(Cell.URL, sval.substring(1)); |
| break; |
| case 'f': |
| ((SpreadSheet)app).setCurrentValue(Cell.FORMULA, sval.substring(1)); |
| break; |
| } |
| } |
| } |
