function highlite_row(el){
   var form =  document.convert_form;
   var category = el.value;
   // clear highliting
   for (var i=0; i < form.measurement_category.length; i++){
       var temp =  form.measurement_category[i].value;
       var temp_row = document.getElementById(temp + "_row");
       color = "#99FFFF";
       if(temp == category){color = "#FFFFFF";}
       temp_row.style.color = color;
   }
   // enable selected category units only
   var categories = new Array('area','distance','weight','volume','pressure','temperature');
   for(var i=0; i < categories.length; i++){
      from = 'document.convert_form.' + categories[i] + "_from.disabled";
      to = 'document.convert_form.' + categories[i] + "_to.disabled"; 
      if(categories[i] == category){
         eval(from + '=false');
         eval(to + '=false');
      }else{
         eval(from + '=true');
         eval(to + '=true');

      }
   }
}

function clear_adjusted(){
  document.convert_form.adjusted.value= '';
}

// dispatch
function convert(el){
   
   var form =  document.convert_form;
   var original = form.original.value;
   
   // null validation
   if(!original){
      alert('No value entered!');
      form.original.focus();
      return false;
   }

   /*
      - have to append 0. when just a .123
      - remove all non-intgers except decimal
        no exponents, etc
   */
   original = original.replace(/^\./,'0.'); // don't really need this?
   original = original.replace(/[^0-9.]/g,'');
   form.original.value = original;

   // null validation part two
   if(original.length == 0){
      alert('Invalid or no value entered!');
      form.original.focus();
      return false;
   }

   // NaN test
   if(isNaN(original)){
      alert(original + " is not a valid number!" );
      return false;
   }

   // zero entry validation
   if(original == 0){
      // this does test 0.00
      alert('0 is not a valid entry!');
      form.original.value = '';
      form.original.focus();
      return false;
   }

   // get and validate conversion categories and units of measure
   var type =  get_category(form);
   if(!type){
      alert('No category selected!');
      return false;
   }
   var unit_one_id =  type + "_from";
   var unit_two_id =  type + "_to";
   var unit_one = get_selected_unit(form,unit_one_id);
   if(!unit_one){
      alert('No from unit selected!');
      return false;
   }  
   var unit_two = get_selected_unit(form,unit_two_id);
   if(!unit_two){
      alert('No to unit selected!');
      return false;
   }
   
   // no conversion required trap
   if(unit_one == unit_two){
      form.adjusted.value = original;
      form.original.focus();
      return false;
   }

   var adjusted = 0; // default 
   switch(type){
   case 'area':
      adjusted = area(original,unit_one,unit_two);
      break;
   case 'distance':
      adjusted = length(original,unit_one,unit_two);
      break;
   case 'pressure':
      adjusted = pressure(original,unit_one,unit_two);
      break
   case 'temperature':
      adjusted = temperature(original,unit_one,unit_two);
      break
   case 'volume':
      adjusted = volume(original,unit_one,unit_two);
      break
   case 'weight':
      adjusted = weight(original,unit_one,unit_two);
      break

   default:
      alert('Invalid category selected: ' + type);
   }
   
   if(isNaN(adjusted)){
      alert(adjusted + " is not a number!" );
      adjusted = '';
      form.adjusted.value = '';
      return false;
   }
   adjusted = precision_of_two(adjusted);
   form.adjusted.value = adjusted;
   form.adjusted.focus();
   return true; 
}

function get_category(form){
   for (var i=0; i < form.measurement_category.length; i++){
      if(form.measurement_category[i].checked){
         return form.measurement_category[i].value;
      }
   }
   return false;
}

function get_selected_unit(form,id){
   var i = document.getElementById(id).selectedIndex;
   return document.getElementById(id)[i].value;
}

function precision_of_two(val){
   // also note that these are subject to floating point, machine specific snafus
   var rounded = val.toFixed(2)
   var test =  rounded + '';
   if(test.match('.00')){
      test = test.replace('.00','');
      return test;
   }
   if(test.match('.99')){
      rounded = parseFloat(rounded) + 0.01;
   }

   return rounded;
}



/************************************************
      CONVERSION MAPPINGS
*************************************************/

function length(val,unit_one,unit_two){
   /* 
      inches, feet, yards, miles
      millimeters, centimeters, meters, kilometers
   */

   var centimeter = {
      foot: 0.0328,
      inch: 0.3937,
      kilometer: 1 * Math.pow(10,-5),
      mile: 6.2137 * Math.pow(10,-6),
      millimeter: 10,
      yard: 0.0109
   }
   
   var foot = {
      centimeter:30.48,
      inch:12,
      kilometer: 3.048 * Math.pow(10,-4),
      mile: 1.8939 * Math.pow(10,-4),
      millimeter: 304.8,
      yard:0.3333
   }
   
   var inch = {
      centimeter:2.54,
      foot: 0.0833,
      kilometer: 2.5399 * Math.pow(10,-5),
      mile: 1.5782 * Math.pow(10,-5),
      millimeter: 25.4,
      yard:0.0277
   }
   
   var kilometer = {
      centimeter:100000,
      foot: 3280.8398,
      inch: 39370.0787, 
      mile: 0.6213,
      millimeter: 1000000,
      yard: 1093.6132
   }
   
   var mile = {
      centimeter: 160934.3999,
      foot:5280,
      inch: 63360,
      kilometer: 1.6093,
      millimeter: 1609344,
      yard: 1760
   }
   
   var millimeter = { 
      centimeter: 0.1,
      foot: 0.0032,
      inch: 0.0393,
      kilometer: 1 * Math.pow(10,-6),
      mile:6.2137 * Math.pow(10,-7),
      yard: 0.0010
   }
   
   var yard = {
      centimeter: 91.44,
      foot: 3,
      inch: 36,
      kilometer: 9.1440 * Math.pow(10,-4),
      mile:5.6818 * Math.pow(10,-4),
      millimeter: 914.4
   }

   // [REFACTOR] move this into it's own object since it's called by everyone
   var prop = unit_one + '.' + unit_two;
   var conversion = eval(prop);
   if(isNaN(conversion)){
      alert('Invalid to conversion units: ' + prop);
      return 0;
   }
   return val * conversion;

}

function area(val,unit_one,unit_two){
   /*
      square:
      inches, feet, yards, miles
      millimeters, centimeters, meters, kilometers      
   */

   var square_meter = {
      square_millimeter:1 * Math.pow(10,6),
      square_inch: 1550.003,
      square_foot:10.7639,
      square_yard:1.19599,
      square_mile:3.861 * Math.pow(10,-7),
      square_kilometer:1 * Math.pow(10,-6)
   }
   
   var square_millimeter = {
      square_meter:1 * Math.pow(10,-6),   
      square_inch:0.00155,
      square_foot:1.076 * Math.pow(10,-5),
      square_yard:1.196 * Math.pow(10,-6),
      square_mile:3.8610216 * Math.pow(10,-13),
      square_kilometer:1 * Math.pow(10,-12)
   }
   
   var square_inch = {
      square_millimeter:645.16,
      square_meter:0.000645,
      square_foot:0.00694,
      square_yard:0.0007716,
      square_mile:2.4909767 * Math.pow(10,-10),
      square_kilometer:6.4516 * Math.pow(10,-10)
   }
   
   var square_foot = {
      square_inch: 144,
      square_millimeter:9.290304 * Math.pow(10,4),
      square_meter:0.09290304,
      square_yard:0.11111,
      square_mile:3.58701 * Math.pow(10,-8),
      square_kilometer:9.290304 * Math.pow(10,-8)
   }
   
   var square_yard = {
      square_foot:9,
      square_inch:1296,
      square_millimeter:836127.3600033,
      square_meter:0.8361,
      square_mile:3.228 * Math.pow(10,-7),
      square_kilometer:8.3612736 * Math.pow(10,-7)
   }
   
   var square_mile = {
      square_yard:3097600,
      square_foot:2.78784 * Math.pow(10,7),
      square_inch:4014489600,
      square_millimeter:2589988110346.36,
      square_meter:2589988.11,
      square_kilometer:2.58999
   }
   
   var square_kilometer = {
      square_mile:0.3861,
      square_yard:1195990.05,
      square_foot:1.07639104 * Math.pow(10,7),
      square_inch:1.5500031 * Math.pow(10,9),
      square_millimeter:1000000000000,
      square_meter:1 * Math.pow(10,6)
   }

   // [REFACTOR] move this into it's own object since it's called by everyone
   var prop = unit_one + '.' + unit_two;
   var conversion = eval(prop);
   if(isNaN(conversion)){
      alert('Invalid to conversion units: ' + prop);
      return 0;
   }
   return val * conversion;
}

function volume(val,unit_one,unit_two){
   /*
       liters, cubic meter
       fluid ounces
       quarts, gallons
       cubic feet, cubic yards
             
   */
   var liter = {
      fluid_ounce:33.81402, 
      quart:1.0567, 
      gallon:0.26417,
      cubic_foot:0.03531, 
      cubic_yard:0.00131, 
      cubic_meter:0.001
   } 
   var fluid_ounce = {
      liter:0.0295,
      quart:0.0312,
      gallon:0.0078,
      cubic_foot:0.001,
      cubic_yard:3.868 * Math.pow(10,-5),
      cubic_meter:2.9573 * Math.pow(10,-5)
   }
   var quart = {
   	liter:0.9463,
      fluid_ounce:32,
      gallon:0.25,
      cubic_foot:0.0334,
      cubic_yard:0.0012,
      cubic_meter:0.0009
   }

   var gallon = {
	   liter:3.7854,
	   fluid_ounce:127.9999,
	   quart:4,
      cubic_foot:0.1336,
      cubic_yard:0.00495,
      cubic_meter:0.00378
   }

   var cubic_foot = {
	   liter:28.3168,
	   fluid_ounce:957.5064,
	   quart:29.9220,
      gallon:7.48052,
      cubic_yard:0.03704,
      cubic_meter:0.02832
   }

   var cubic_yard = {
	   liter:764.5548,
	   fluid_ounce:25852.6749,
	   quart:807.8961,
      gallon:201.9740,
      cubic_foot:27,
      cubic_meter:0.7646
   }

   var cubic_meter = {
	   liter:1000,
	   fluid_ounce:33814.0222,
	   quart:1056.6882,
      gallon:264.1720,
      cubic_foot:35.3146,
      cubic_yard:1.3079
   }
   
   // [REFACTOR] move this into it's own object since it's called by everyone
   var prop = unit_one + '.' + unit_two;
   var conversion = eval(prop);
   if(isNaN(conversion)){
      alert('Invalid to conversion units: ' + prop);
      return 0;
   }
   return val * conversion;

}

function weight(val,unit_one,unit_two){
   /*
      kilograms, metric tons
      ounces, pounds english tons, US tons
   */

   var kilogram = {
      ounce: 35.2739,
      pound: 2.2046,
      english_ton: 9.84 * Math.pow(10,-4),
      metric_ton: 9.999 * Math.pow(10,-4),
      us_ton: 0.001102
   }

   var ounce = {
      kilogram: 0.0283,
      pound: 0.0625,
      english_ton: 2.7901 * Math.pow(10,-5),
      metric_ton: 2.8349 * Math.pow(10,-5),
      us_ton: 3.1249 * Math.pow(10,-5)
   }
   
   var pound = {
      kilogram: 0.4535,
      ounce: 16,
      english_ton: 4.4642 * Math.pow(10,-4),
      metric_ton: 4.5359 * Math.pow(10,-4),
      us_ton: 4.9999 * Math.pow(10,-4)
   }
   
   var english_ton = {
      kilogram: 1016.0469,
      ounce: 35840,
      pound: 2240,
      metric_ton: 1.0160,
      us_ton: 1.12
   }
   
   var metric_ton = {
      kilogram: 1000,
      ounce: 35273.9619,
      pound: 2204.6226,
      english_ton: 0.9842,
      us_ton: 1.1023
   }
   
   var us_ton = {
      kilogram: 907.1847,
      ounce:32000,
      pound:2000,
      english_ton: 0.8928,
      metric_ton: 0.9071
   }

   // [REFACTOR] move this into it's own object since it's called by everyone
   var prop = unit_one + '.' + unit_two;
   var conversion = eval(prop);
   if(isNaN(conversion)){
      alert('Invalid to conversion units: ' + prop);
      return 0;
   }
   return val * conversion;


}

function temperature(val,unit_one,unit_two){
   /*     
      celsius farenhiet      
   */
   if(unit_one == 'celsius'){
      return (val * 9/5) + 32;
   }else{
      //its farenheit to celsius
      return (val - 32) * 5/9;
   }

}

function pressure(val,unit_one,unit_two){
   /*     
      atmosphere
   	centimeter of mercury
      inches of mercury
      kilogram/cm squared
      magapascal
      pounds/in squared
      kip
      ton_force_sq_feet
   */
   var atmosphere = {
      // Standard atmosphere 
      centimeter_of_mercury:75.9999,
      inch_of_mercury: 29.9212,
      kilogram_cm_squared:1.0332,
      magapascal: 0.1013,
      pound_in_squared:14.6959,
      kip: 0.014695949,
      ton_force_sq_feet:1.058108312   
   }
   
   var centimeter_of_mercury  = {
      // 0 degrees celcius 
      atmosphere:0.0132,
      inch_of_mercury:0.3937,
      kilogram_cm_squared:0.0136,
      magapascal:0.0013,
      pound_in_squared:0.1933,
      kip: 0.000193367,
      ton_force_sq_feet:0.013922439
   }
   
   var inch_of_mercury = {
      // 32 degrees  
      atmosphere:0.0334,
      centimeter_of_mercury:2.5399,
      kilogram_cm_squared:0.0345,
      magapascal: 0.0033,
      pound_in_squared:0.4911527,
      kip: 0.000491153,
      ton_force_sq_feet:0.035363008
   }
   
   var kilogram_cm_squared = {
      atmosphere:0.9678,
      centimeter_of_mercury:73.5559,
      inch_of_mercury:28.9590,
      magapascal: 0.0980,
      pound_in_squared: 14.2233,
      kip: 0.014223343,
      ton_force_sq_feet:1.024080718
   }
   
   var magapascal = {
      atmosphere:9.8692,
      centimeter_of_mercury:750.0615,
      inch_of_mercury:295.2998,
      kilogram_cm_squared: 10.1971,
      pound_in_squared:145.0377,
      kip: 0.145037738,
      ton_force_sq_feet:10.442717117
   }
   
   var pound_in_squared = {
      atmosphere: 0.0680,
      centimeter_of_mercury: 5.1714,
      inch_of_mercury: 2.0360,
      kilogram_cm_squared: 0.0703,
      magapascal: 0.0068,
      kip: 0.001,
      ton_force_sq_feet:0.072
   }

   var kip = {
      atmosphere:68.04596391,  
      centimeter_of_mercury:5171.507548025,
      inch_of_mercury:2036.025872223,  
      kilogram_cm_squared:70.306957964,
      magapascal:6.894757293,
      pound_in_squared:1000,
      ton_force_sq_feet: 72
   }

   var ton_force_sq_feet = {
      atmosphere:0.945082832,
      centimeter_of_mercury:71.826493722,
      inch_of_mercury:28.278137114,  
      kilogram_cm_squared:0.976485527,
      magapascal:0.095760518,
      pound_in_squared:13.888888889, 
      kip: 0.013888889
   }                     

   // [REFACTOR] move this into it's own object since it's called by everyone
   var prop = unit_one + '.' + unit_two;
   var conversion = eval(prop);
   if(isNaN(conversion)){
      alert('Invalid to conversion units: ' + prop);
      return 0;
   }
   return val * conversion;

}