// QuickConvert.java
// by Gregory C. Wilcox
// August 22, 1997

/*
  bugs:
  fix layout
  implement molecular weight input
  make tweakFont into a class
  add online help
 */

import java.awt.*;
// import java.applet.*;
import java.awt.event.*;
import java.applet.Applet;
import java.applet.AppletContext;
// QuickConvert classes
// import UnitData;
import ChoicePanel;
// // import HelpFrame;
// import HelpDialog;
// QuickConvert interfaces
// import DialogClient;

// can't extend Choice,
// since pItems and selectedIndex are not visible by method 'clear'
// so, use ChoicePanel instead
// and wait for 'remove' method in JDK 1.1
/*
class ClearChoice extends Choice
{
  public synchronized void clear() {
    // pItems = new Vector();
    // selectedIndex = -1;
  }
}
*/

/**
 * DialogClients are notified when the Dialog with which they 
 * are associated is dismissed.  A reference to the dismissed 
 * Dialog is passed as a parameter of dialogDismissed() in case 
 * a DialogClient is a client of more than one Dialog.<p>
 *
 * @version 1.0, Apr 1 1996
 * @author  David Geary
 * @see     MessageDialog
 * @see     QuestionDialog
 * @see     YesNoDialog
 * @see     gjt.test.DialogTest
 */
interface DialogClient {
    abstract public void dialogDismissed(Dialog d); 
}

// header panel containing information about QuickConvert
class Header extends Panel {
  Label title = new Label("QuickConvert", Label.CENTER);
  Label version = new Label("Version 2.0", Label.CENTER);
  Label copyright = new Label("Copyright 2000 by Arthur D. Little, Inc.", Label.CENTER);
  int titleX = 0, titleY = 0;
  // 'wide' could be 192, but jdk1.0.3 can't shrink fonts - so copyright is big
  int wide = 256;
  public Header(Graphics g) {
    Font currentFont = g.getFont();
    Font titleFont = tweakFont(currentFont, Font.BOLD, 8);
    title.setFont(titleFont);
    Font copyrightFont = tweakFont(currentFont, Font.ITALIC, -2);
    copyright.setFont(copyrightFont);
    setSize( wide, 64 );
    // lay the header out by hand for a custom look
    setLayout(null);
    add(title);
    add(version);
    add(copyright);
    title.setBounds(titleX, titleY, wide, 24);
    version.setBounds(titleX, titleY + 20, wide, 16);
    copyright.setBounds(titleX, titleY + 40, wide, 16);
  }

  // increment the font size, and optionally set the style
  Font tweakFont(Font font, int style, int sizeInc) {
    String fontName = font.getName();
    int fontStyle = style >= 0 ? style : font.getStyle();
    int fontSize = font.getSize();
    return new Font(fontName, fontStyle, fontSize + sizeInc);
  }

}

class OKDialog extends Dialog implements ActionListener
{
    Panel p1 = new Panel();
    Panel p2 = new Panel();
    Button OKButton = new Button("OK");

    public OKDialog(Frame parent, String title) {
	super(parent, title, true);
	p2.add(OKButton);
	OKButton.addActionListener(this);
	add("South", p2);
    }

    public void actionPerformed(ActionEvent event) {
	if (event.getSource() == OKButton)
	    dispose();
    }

    public void windowClosing(WindowEvent event) {
	dispose();
    }
}

class AboutDialog extends OKDialog {
  public AboutDialog(Frame parent) {
    super(parent, "About QuickConvert");
    p1.add(new Label("QuickConvert"));
    p1.add(new Label("Copyright 2000 by Arthur D. Little, Inc."));
    p1.add(new Label("Acorn Park, Cambridge, MA 02140"));

    add("Center", p1);

    setSize(288, 192);
  }
}

class MessageDialog extends OKDialog {
  public MessageDialog(Frame parent, String title, String message) {
    super(parent, title);
    p1.add(new Label(message));
    add("Center", p1);
    setSize(288, 128);
  }
  public static void error(Frame parent, String string) {
    MessageDialog md = new MessageDialog(parent, "Error: ", string);
    md.setVisible(true);
  }
  public static void caution(Frame parent, String string) {
    // message("Caution: ", string);
    MessageDialog md = new MessageDialog(parent, "Caution: ", string);
    md.setVisible(true);
  }
}

// get an integer from user
class GetIntegerDialog extends OKDialog implements ActionListener
{
    int inputValue = 1;
    TextField inputField = new TextField("", 8);
    protected DialogClient client;
    // constructor with input value
    public GetIntegerDialog(Frame parent, DialogClient client, String label, int inputValue) {
	this(parent, client, label);
	inputField.setText(Integer.toString(inputValue));
    }
    // standard constructor
    public GetIntegerDialog(Frame parent, DialogClient client, String label) {
	super(parent, "Enter value");
	this.client = client;
	p1.add(new Label(label));
	p1.add(inputField);
	add("Center", p1);
	setSize(256, 128);
	OKButton.addActionListener(this);
    }
    public void setVisible(boolean visible) {
	inputField.requestFocus();
	super.setVisible(visible);
    }
    public void actionPerformed(ActionEvent event) {
	if (event.getSource() == OKButton) {
	    String inputString = inputField.getText();
	    try { inputValue = Integer.parseInt(inputString); }
	    catch (NumberFormatException e) {
		MessageDialog.error((Frame)this.getParent().getParent(), inputString + " is not a number.");
		System.err.println('\7' + inputString + " is not an integer.");
		// this only works in the context of an applet
		// showStatus(inputString + " is not a number.");
	    }
	    dispose();
	    client.dialogDismissed(this);
	}
    }
}

public class QuickConvert extends Applet implements DialogClient, ActionListener, ItemListener
{
    int i, digits = 16, molWeight = 0;
    int kindValue = 0;
    Double inputValue, outputValue;
    String inputString = "1";
    String outputString = inputString;
    String javaVersion = System.getProperty("java.version");
    GetIntegerDialog molWeightDialog;
    Frame QCFrame;

    Header header;
    Label kindLabel = new Label("Kind:");
    TextField input = new TextField(inputString, digits);
    TextField output = new TextField(outputString, digits);
    Label baseLabel = new Label("SI base units: ");
    Label baseValue = new Label("Java version: " + javaVersion);
    Label fromLabel = new Label("From:");
    Label toLabel = new Label("To:");
    Label blankLabel = new Label();
    Choice kind = new Choice();
    // ClearChoice fromUnit = new ClearChoice();
    // ClearChoice toUnit = new ClearChoice();
    // ChoicePanel fromUnit = new ChoicePanel(256 + 128, 32);
    // ChoicePanel   toUnit = new ChoicePanel(256 + 128, 32);
    Choice fromUnit = new Choice();
    Choice   toUnit = new Choice();
    Panel checkPanel = new Panel();
    Checkbox abbrev = new Checkbox("Abbreviate");
    Checkbox round = new Checkbox("Round");
    Panel buttonPanel = new Panel();
    Button convertButton = new Button("Convert");
    Button flipButton = new Button("Flip");
    Button aboutButton = new Button("About");
    Button helpButton = new Button("Help");
    Button molWeightButton = new Button("Mol. Weight");

    // use beep (ASCII code 7) to signal message
    void message(String label, String string) { System.err.println('\7' + label + string); }

    // not used
    public static Frame getFrame(Component component) {
	Component c = component;
	if (c instanceof Frame) return (Frame)c;
	while((c = c.getParent()) != null)
	    if (c instanceof Frame) return (Frame)c;
	return null;
    }

    void getMolWeight() {
	molWeightDialog = new GetIntegerDialog(QCFrame, this, "Molecular weight:", molWeight);
	molWeightDialog.setVisible(true);
    }

    public void dialogDismissed(Dialog d) {
	if (d == molWeightDialog)  {
	    molWeight = molWeightDialog.inputValue;
	    // do conversion and show result
	    showOutput();
	}
    }

    // count the number of significant digits in this number
    int signifDigits (String string) {
	int digits = 0;
	char c;
	for (int i=0; i<string.length(); i++) {
	    c = string.charAt(i);
	    if (Character.isDigit(c)) digits++;
	    else
		switch (c) {
		case '.': break;
		case '+': break;
		case '-': break;
		case 'e':
		case 'E': return digits;
		default:  MessageDialog.error(QCFrame, "Bad digit in SignifDigits");
		}
	}
	return digits;
    }

    double logBase10(double number) { return Math.log(number) / Math.log(10.0); }

    // set the number of significant digits in a number
    double setSignifDigits(double number, int digits) {
	// this doesn't work
	// System.out.println("Mantissa = " + Long.toString(mantissa(number)) +
	//                  ", exponent = " + Integer.toString(exponent(number)));
	double exponent = Math.floor(logBase10(number));
	double tenToExp = Math.pow(10, exponent);
	double mantissa = number / tenToExp;
	double theScale = Math.pow(10, digits - 1);
	double roundMan = Math.round(mantissa * theScale) / theScale;
	return roundMan * tenToExp;
    }

    public void init() {

	// get the Frame for QuickConvert
	// getFrame(this) = the lazy way of doing it: climb the inheritance path
	// QuickConvert.getParent() -> AppletViewerPanel
	// AppletViewerPanel.getParent() -> AppletViewer, which is a Frame
	// getParent returns a Component, so cast it to a Frame
	QCFrame = (Frame)this.getParent().getParent();;

	// System.out.println("Java version: " + javaVersion);
	setSize(512 + 96, 256);

	Graphics graphics = getGraphics();
	header = new Header(graphics);
	graphics.dispose();
	UnitData.HiliteSI();

	output.setEditable(false);

	GridBagLayout      gbl = new GridBagLayout();
	GridBagConstraints gbc = new GridBagConstraints();

	setLayout(gbl);
	gbc.gridwidth = GridBagConstraints.REMAINDER;
	gbc.anchor    = GridBagConstraints.NORTH;
	// gbc.ipadx = 4;
	gbl.setConstraints(header, gbc);

	gbc.anchor  = GridBagConstraints.WEST;
	gbl.setConstraints(kind, gbc);
	gbl.setConstraints(fromUnit, gbc);
	gbl.setConstraints(toUnit, gbc);

	gbc.gridwidth = GridBagConstraints.RELATIVE;
	gbl.setConstraints(baseLabel, gbc);
	gbl.setConstraints(checkPanel, gbc);

	gbc.gridwidth = GridBagConstraints.REMAINDER;
	gbl.setConstraints(baseValue, gbc);
	gbl.setConstraints(buttonPanel, gbc);

	add(header);
	add(kindLabel); add(kind);
	add(fromLabel); add(input); add(fromUnit);
	add(toLabel); add(output); add(toUnit);
	add(baseLabel); add(baseValue);
	checkPanel.add(abbrev);
	checkPanel.add(round);
	add(checkPanel);
	buttonPanel.add(convertButton);
	buttonPanel.add(flipButton);
	buttonPanel.add(aboutButton);
	buttonPanel.add(helpButton);
	buttonPanel.add(molWeightButton);
	add(buttonPanel);

	kind.addItemListener(this);
	fromUnit.addItemListener(this);
	toUnit.addItemListener(this);
	abbrev.addItemListener(this);
	round.addItemListener(this);

	input.addActionListener(this);
	flipButton.addActionListener(this);
	convertButton.addActionListener(this);
	aboutButton.addActionListener(this);
	helpButton.addActionListener(this);
	molWeightButton.addActionListener(this);

	for (i=0; i<UnitData.All.length; i++) kind.addItem( UnitData.All[i].category );
	// setKind(0, false);
	// setKind(8, false);  // density & concentration
	setKind(21, false);		// length
	// setKind(32, false);  // temperature
	// showOutput();
    }

    public void setVisible(boolean visible) {
	input.requestFocus();
	super.setVisible(visible);
    }

    // set the kind of unit to be converted
    void setKind(int unitKind, boolean newAbbrev) {
	boolean abbrevP, abbrevChecked = abbrev.getState();
	CUnit[] unit = UnitData.All[unitKind].unit;
	String unitName;
	// display the correct kind of units
	kind.select(unitKind);
	// only enable the molecular weight button for densities
	boolean densityP = (unit == UnitData.Density);
	molWeightButton.setEnabled(densityP);
	// width gets truncated to width of smallest label
	baseValue.setSize(256, baseValue.getBounds().height);
	// display the correct base units
	baseValue.setText(UnitData.All[unitKind].base);
	int fromItem = fromUnit.getSelectedIndex();
	int toItem = toUnit.getSelectedIndex();
	// clear the "from" and "to" menus
	fromUnit.removeAll();
	toUnit.removeAll();
	// add new choices to "from" and "to" menus
	for (i=0; i<unit.length; i++) {
	    // we want to abbreviate, and an abbreviation exists
	    abbrevP = (abbrevChecked && !(unit[i].abbrev.equals(UnitData.NO_SYMBOL)));
	    unitName = abbrevP ? unit[i].abbrev : unit[i].name;
	    fromUnit.addItem( unitName );
	    toUnit.addItem( unitName );
	    // convert to SI units by default
	    if (unit[i].system == UnitData.SI) toUnit.select(i);
	}
	// convert from first unit by default
	fromUnit.select(0);
	// if abbreviation check box is changed, keep previous unit selections
	if (newAbbrev) {
	    fromUnit.select(fromItem);
	    toUnit.select(toItem);
	}
    }

    double convertTemp (double in, int from, int to) {
	double kelvin = 0.0, out = 0.0;
	double ctok = 273.15, ktor = 1.8, ftor = 459.670;

	switch (from) {
	case UnitData.DEGK: kelvin = in;               break;
	case UnitData.DEGR: kelvin = in /ktor;         break;
	case UnitData.DEGF: kelvin = (in +ftor) /ktor; break;
	case UnitData.DEGC: kelvin = in +ctok;         break;
	}
	switch (to) {
	case UnitData.DEGK: out = kelvin;               break;
	case UnitData.DEGR: out = ktor * kelvin;        break;
	case UnitData.DEGF: out = ktor * kelvin - ftor; break;
	case UnitData.DEGC: out = kelvin - ctok;        break;
	}
	if (kelvin < 0) MessageDialog.caution(QCFrame, "This temperature is below absolute 0.");
	return out;
    }

    double RatioToConc(String abbrev) {
	if      (abbrev.equals("ppm")) return 1.0e6;
	else if (abbrev.equals("vol %")) return 1.0e2;
	else {
	    MessageDialog.error(QCFrame, "Unknown concentration unit - %s" + abbrev);
	    return 0.0;
	}
    }

    // is a molecular weight required?
    boolean molWeightP (int from, int to) {
	CUnit[] unit = UnitData.All[kindValue].unit;
	return (unit == UnitData.Density) && 
	    // exclusive OR - only one unit must be a concentration
	    ((unit[from].system == UnitData.CO) ^ 
	     (unit[to].system == UnitData.CO)
	     );
    }

    double convertConcentration(double in, int from, int to) {
	// 'ratio' is the ratio of substance to air,
	// from which ppm and volume % are derived
	double ratio, density;
	double R = 0.08205;		// litre-atmosphere/mol-K
	double p = 1.0;		// atmospheres
	double T = 294.15;		// 21 degrees Centigrade
	double m = molWeight;	// molecular weight

	// do this the first time only
	if ( molWeightP(from, to) && (molWeight == 0)) getMolWeight();

	CUnit[] unit = UnitData.Density;
	int si = UnitData.All[kindValue].SI;
	if (unit[from].system != UnitData.CO) {
	    if (unit[to].system != UnitData.CO) {
		MessageDialog.error(QCFrame, "One of the units should be a concentration.");
		return 0.0;
	    }
	    else {
		// converting from density to concentration
		// first convert density to SI
		density = in * unit[from].factor / unit[si].factor;
		ratio = (density * R * T) / (p * m);
		return ratio * RatioToConc(unit[to].abbrev);
	    }
	} else if (unit[to].system != UnitData.CO) {
	    // converting from concentration to density
	    // convert concentration unit to ratio
	    ratio = unit[from].factor / RatioToConc(unit[from].abbrev);
	    density = (ratio * p * m) / (R * T);
	    // add 'in' to this line to fix bug in verion 2.0 and create version 2.01?
	    return in * density * unit[si].factor;
	} else
	    // converting concentrations
	    return in * RatioToConc(unit[to].abbrev) /
		RatioToConc(unit[from].abbrev);
    }

    double convert(int unitKind, double in) {
	boolean roundP = round.getState();
	CUnit[] unit = UnitData.All[unitKind].unit;
	int from = fromUnit.getSelectedIndex();
	int to = toUnit.getSelectedIndex();
	int conc = UnitData.CO;
	double fromFactor = unit[from].factor;
	double toFactor = unit[to].factor;
	double out;

	if (unit == UnitData.Temperature)
	    out = convertTemp (in, from, to);
	else if (unit == UnitData.Density && (unit[from].system == conc || unit[to].system == conc))
	    out = convertConcentration (in, from, to);
	else out = in * fromFactor / toFactor;
	if (roundP) {
	    int digits = signifDigits(input.getText());
	    out = setSignifDigits(out, digits);
	}
	return out;
    }

    void showOutput() {
	inputString = input.getText();
	try {
	    inputValue = Double.valueOf(inputString.trim());
	}
	catch (NumberFormatException e) {
	    MessageDialog.error(QCFrame, inputString + " is not a number.");
	    return;
	}
	outputValue = new Double(convert(kindValue, inputValue.doubleValue()));
	outputString = outputValue.toString();
	// System.out.println("Converting " + inputString + " to " + outputString);
	output.setText(outputString);
    }

    public void itemStateChanged(ItemEvent event) {
	kindValue = kind.getSelectedIndex();
	Object item = event.getSource();
	// this covers 'kind', 'fromUnit', and 'toUnit'
	if (item instanceof Choice) {
	    if (item == kind) setKind(kindValue, false);
	    showOutput();
	}
	if (item == abbrev) setKind(kindValue, true);
	if (item == round) showOutput();
    }

    public void actionPerformed(ActionEvent event) {
	// System.out.println(event);
	Object item = event.getSource();
	if (item == input) {
	    showOutput();
	} else
	    if (item == flipButton) {
		int from = fromUnit.getSelectedIndex();
		int to = toUnit.getSelectedIndex();
		fromUnit.select(to);
		toUnit.select(from);
		showOutput();
	    } else
		if (item == convertButton) {
		    showOutput();
		} else
		    if (item == aboutButton) {
			AboutDialog ab = new AboutDialog(QCFrame);
			ab.setVisible(true);
		    } else
			if (item == helpButton) {
				// HelpFrame help = new HelpFrame();
			    HelpDialog help = new HelpDialog(QCFrame);
			    help.setVisible(true);
			} else
			    if (item == molWeightButton) {
				getMolWeight();
			    }
    }
}

// end of file