//////////////////////////////////////////////////////////////////////////////////////////////////
// John Warner (warnerj5000@gmail.com)
// PHD, Inc 2007
// Purpose: This javascript file handles the RotLeftCol.html file.
//          RotLeftCol.html contains the settings for the rotary sizing.
//          Application, Orientation, Series, and the various buttons.
//          All DHTML for the left column of rotary.html will be handled 
//          within this javascript file.
//////////////////////////////////////////////////////////////////////////////////////////////////


var compMode;
var 
    selectOrientation,  
    tabIns,
    App2tabIns,
    tabCriticalValues,
    App2tabCriticalValues,
    CompModetabCriticalValues,
    tabListFilter,
    CompModetabListFilter,
    App2tabListFilter,
    tabOuts,
    App2tabOuts,
    CompModetabOuts;

/*
function FilterFeedClick()
{
    InputChanged(this.id);
    return;
}
*/



function FilterSeriesClick(col)
{
    //InputChanged();
    InputChanged(new DummyEvent("rbMetricInputs")) ; 
    return;
}

function AllSeries(col)
{
    element("cbRCC").checked = true;
    element("cbRL").checked = true;
    element("cbRA").checked = true;
    element("cbRI").checked = true;
    element("cbR1K8K").checked = true;
    element("cbRAO2K8K").checked = true;
    element("cbRMP2K8K").checked = true;
    element("cbRF").checked = true;
    //InputChanged();
    InputChanged(new DummyEvent("rbMetricInputs")) ; 
    return;
}

function NoSeries(col)
{
    element("cbRCC").checked = false;
    element("cbRL").checked = false;
    element("cbRA").checked = false;
    element("cbRI").checked = false;
    element("cbR1K8K").checked = false;
    element("cbRAO2K8K").checked = false;
    element("cbRMP2K8K").checked = false;
    element("cbRF").checked = false;
    //InputChanged();
    InputChanged(new DummyEvent("rbMetricInputs")) ; 
    return;
}

function resetToDefault()
{
    return;
}

function copy()
{
    if (window.clipboardData)
    {
        // Input values
        
        var
            s = document.title + "\r\n\r\n\r\ninputs: \r\n\r\n",
            orDesc = "" ;
            
            switch (sOrientation)
            {
                case "divDiskOnCenter": orDesc = "Disk On Center"; break ;
                case "divDiskEndOnCenter": orDesc = "Disk End On Center"; break ;
	            case "divSphere": orDesc = "Sphere"; break ;
	            case "divPlateOnCenter": orDesc = "Plate On Center"; break ;
	            case "divRodOnCenter": orDesc = "Rod On Center"; break ;
	            case "divPointLoad": orDesc = "Point Load" ; break ;
                case "divPlateOffCenter": orDesc = "Plate Off Center" ; break ;
	            case "divRodOffCenter": orDesc = "Rod Off Center" ; break ;	           
            }
            
            s += "Orientation" + ":\t\t"+ orDesc + "\r\n";
            
            var tmpAxis;
            if (element("rbAxisVertical").checked  == true)
                tmpAxis = "Vertical";
            else
                tmpAxis = "Horizontal";
                
            s += "Axis" + ":\t\t\t" + tmpAxis + "\r\n";  
            s += "Angle of Rotation" + ":\t" + element("txtAOR").value + " " + element("spnUCAOR").innerHTML.substr(0,3) + "\r\n";
            if (element("spnUCRotTime").innerHTML.substr(0,2) == "ms")
                s += "Rotation Time" + ":\t" + element("txtRotTime").value + " " + element("spnUCRotTime").innerHTML.substr(0,2) + "\r\n";
            else
                 s += "Rotation Time" + ":\t\t" + element("txtRotTime").value + " " + element("spnUCRotTime").innerHTML.substr(0,3) + "\r\n";
            s += "Pressure" + ":\t\t" + element("txtPressure").value + " ";
            if (element("spnUCPressure").innerHTML.substr(0,5)== "mm-Hg")
                s += "mm-Hg" + "\r\n";
            else if (element("spnUCPressure").innerHTML.substr(0,5) == "in-Hg")
                s += "in-Hg" + "\r\n";
            else
                s += element("spnUCPressure").innerHTML.substr(0,3) + "\r\n";
                
            s += "Torque Safety Factor" + ":\t" + element("txtTSF").value + "\r\n";
            s += "Rotary Face To Load" + ":\t" + element("txtFTL").value + " ";
            if (element("spnUCFTL").innerHTML.substr(0,2) == "in")
                s += "in" + "\r\n";
            else if (element("spnUCFTL").innerHTML.substr(0,2) == "ft")
                s += "ft" + "\r\n";
            else if (element("spnUCFTL").innerHTML.substr(0,2) == "mm")
                s += "mm" + "\r\n";
            else if (element("spnUCFTL").innerHTML.substr(0,2) == "cm")
                s += "cm" + "\r\n";
            else
                s += "m" + "\r\n";
                
            s += "Radius" + ":\t\t\t" + element("txtRadius").value + " ";
            if (element("spnUCRadius").innerHTML.substr(0,1) == "m")
            {
                if (element("spnUCRadius").innerHTML.substr(0,2) == "mm")
                    s += "mm" + "\r\n";
                else
                    s += "m" + "\r\n";
            }
            else
                s += element("spnUCRadius").innerHTML.substr(0,2) + "\r\n";
                
            s += "Load" + ":\t\t\t" + element("txtLoad").value + " ";
            if (
                (element("spnUCLoad").innerHTML.substr(0,1) == "N") ||
                (element("spnUCLoad").innerHTML.substr(0,1) == "g")                   
               )
                s += element("spnUCLoad").innerHTML.substr(0,1) + "\r\n";
            else
                s += element("spnUCLoad").innerHTML.substr(0,2) + "\r\n";
                
            s += "Inertia Adder" + ":\t\t" + element("txtInertiaAdd").value + " ";
            if (element("spnUCInertiaAdd").innerHTML.substr(0,10) == "g-cm-sec^2")
                s += "g-cm-sec^2" + "\r\n";
            else if (element("spnUCInertiaAdd").innerHTML.substr(0,10) == "kg-m-sec^2")
                s += "kg-m-sec^2" + "\r\n"
            else
                s += element("spnUCInertiaAdd").innerHTML.substr(0,11) + "\r\n";
                
            s += "Torque Adder" + ":\t\t" + element("txtTorqueAdd").value + " ";
            if (element("spnUCTorqueAdd").innerHTML.substr(0,3) == "N-m")
            {
                if (element("spnUCTorqueAdd").innerHTML.substr(0,4) == "N-mm")
                    s += "N-mm" + "\r\n";
                else
                    s += "N-m" + "\r\n";
            }
            else
                s += element("spnUCTorqueAdd").innerHTML.substr(0,5) + "\r\n";
                
          //  s += "Eliminate Bounce"  + ":\t";
          //  if (element("cbBounce").checked)
           //     s += "Checked" + "\r\n";
           // else
            //    s += "Not checked" + "\r\n";
            
          
          // Critical Values
          
         s += "\r\n" + "Critical Values:" + "\r\n\r\n";
         
         s += "Inertia" + ":\t\t" + element("txtInertia").value + " ";
         if (element("spnUCInertia").innerHTML.substr(0,10) == "g-cm-sec^2")
            s += "g-cm-sec^2" + "\r\n";
         else if (element("spnUCInertia").innerHTML.substr(0,10) == "kg-m-sec^2")
            s += "kg-m-sec^2" + "\r\n";
         else
            s += element("spnUCInertia").innerHTML.substr(0,11) + "\r\n";
            
         s += "Required Torque" + ":\t" + element("txtReqTorque").value + " ";
         if (element("spnUCReqTorque").innerHTML.substr(0,3) == "N-m")
         {
            if (element("spnUCReqTorque").innerHTML.substr(0,4) == "N-mm")
                s += "N-mm" + "\r\n";
            else
                s += "N-m" + "\r\n";
         }
         else
            s += element("spnUCReqTorque").innerHTML.substr(0,5) + "\r\n";
         s += "Est. Peak Velocity" + ":\t" + element("txtPeakVelocity").value + " ";
         s += element("spnUCPeakVelocity").innerHTML.substr(0,7) + "\r\n";
         s += "Acceleration" + ":\t\t" + element("txtAcceleration").value + " ";
         s += element("spnUCAcceleration").innerHTML.substr(0,9) + "\r\n";
         s += "Kinetic Energy" + ":\t\t" + element("txtKineticEnergy").value + " ";
         if (element("spnUCKineticEnergy").innerHTML.substr(0,3) == "N-m")
         {
            if (element("spnUCKineticEnergy").innerHTML.substr(0,4) == "N-mm")
                s += "N-mm" + "\r\n";
            else
                s += "N-m" + "\r\n";
         }
         else
            s += element("spnUCKineticEnergy").innerHTML.substr(0,5) + "\r\n";
         s += "Backlash" + ":\t\t" + element("txtBacklash").value + " ";
         s += element("spnUCBacklash").innerHTML.substr(0,3) + "\r\n";   
         
         s += "\r\n\r\n";
         s += "Show Marginal:\t\t\t";
         if(element("cbMarginal").checked)
            s += "Yes";
         else
            s += "No";
         s += "\r\n";
         s += "Show Failed:\t\t\t";
         if(element("cbFailed").checked)
            s += "Yes";
         else
            s += "No";
         s += "\r\n";            
         s += "External shocks and stops:\t";
         if(element("cbExternalShocks").checked)
            s += "Yes";
         else
            s += "No";
            s += "\r\n";
        // Results
        
        s += "\r\n" + "Results:" + "\r\n\r\n"
        
        s += "Base Part Number" + ":\t" + element("td").innerHTML + "\r\n";
        s += "Axial Bearing Capacity" + ":\t" + element("txtAxialBearingCapacity").value + " ";
       if (element("spnUCAxialBearingCapacity").innerHTML.substr(0,1) == "g")
            s += "g" + "\r\n";
       else if (element("spnUCAxialBearingCapacity").innerHTML.substr(0,1) == "N")
            s += "N" + "\r\n";
       else
            s += element("spnUCAxialBearingCapacity").innerHTML.substr(0,2) + "\r\n";
       s += "Radial Bearing Capacity" + ":" + element("txtRadialBearingCapacity").value + " ";
       if (element("spnUCRadialBearingCapacity").innerHTML.substr(0,1) == "g")
            s += "g" + "\r\n";
       else if (element("spnUCRadialBearingCapacity").innerHTML.substr(0,1) == "N")
            s += "N" + "\r\n";
       else
            s += element("spnUCRadialBearingCapacity").innerHTML.substr(0,2) + "\r\n";
       s += "Expected Backlash" + ":\t" + element("txtExpectedBacklash").value + " ";
       s += element("spnUCExpectedBacklash").innerHTML.substr(0,3) + "\r\n";    
       s += "Rotational Tolerance" + "\r\n";
       s += "(Positive)" + ":\t\t" + element("txtRotationalTolerancePlus").value + " ";
       s += element("spnUCRotationalTolerancePlus").innerHTML.substr(0,3) + "\r\n";
       s += "Rotational Tolerance" + "\r\n";
       s += "(Negative)" + ":\t\t" + element("txtRotationalToleranceMinus").value + " ";
       s += element("spnUCRotationalToleranceMinus").innerHTML.substr(0,3) + "\r\n";
       //s += "Breakaway Pressure" + ":\t" + element("txtBreakawayPressure").value + " "; 7/23/08 Breakaway Pressure removed
        //if (element("spnUCBreakawayPressure").innerHTML.substr(0,5)== "mm-Hg")
         //       s += "mm-Hg" + "\r\n";
         //   else if (element("spnUCBreakawayPressure").innerHTML.substr(0,5) == "in-Hg")
         //       s += "in-Hg" + "\r\n";
          //  else
           //     s += element("spnUCBreakawayPressure").innerHTML.substr(0,3) + "\r\n";
       s += "Approx. Torque Output" + ":\t" + element("txtApproxTorqueOutput").value + " ";
       if (element("spnUCApproxTorqueOutput").innerHTML.substr(0,3) == "N-m")
         {
            if (element("spnUCApproxTorqueOutput").innerHTML.substr(0,4) == "N-mm")
                s += "N-mm" + "\r\n";
            else
                s += "N-m" + "\r\n";
         }
         else
            s += element("spnUCApproxTorqueOutput").innerHTML.substr(0,5) + "\r\n";
       s += "Device Weight" + ":\t\t" + element("txtDeviceWeight").value + " ";
       if (
                (element("spnUCDeviceWeight").innerHTML.substr(0,1) == "N") ||
                (element("spnUCDeviceWeight").innerHTML.substr(0,1) == "g")                   
               )
                s += element("spnUCDeviceWeight").innerHTML.substr(0,1) + "\r\n";
            else
                s += element("spnUCDeviceWeight").innerHTML.substr(0,2) + "\r\n";
       s += "Cv" + ":\t\t\t" + element("txtCv").value + " "  + "\r\n";
       s += "SCFM" + ":\t\t\t" + element("txtSCFM").value + " ";
       if (element("spnUCSCFM").innerHTML.substr(0,3) == "LPM")
            s += "LPM" + "\r\n";
       else
            s += "SCFM" + "\r\n";
       
       // Kinetic Energy Stopping Capacity
       
       s += "\r\n" + "Kinetic Energy Stopping Capacity:" + "\r\n\r\n"
       
       s += "Plain Unit Kinetic Energy" + ":\t\t"; 
       if (element("tdPlainWarning").style.display == "none")
       {      
            s += element("txtPlainUnitKe").value + " "; 
            if (element("spnUCPlainUnitKe").innerHTML.substr(0,3) == "N-m")
            {
                if (element("spnUCPlainUnitKe").innerHTML.substr(0,4) == "N-mm")
                    s += "N-mm" + "\r\n";
                else
                    s += "N-m" + "\r\n";
            }
             else
                 s += element("spnUCPlainUnitKe").innerHTML.substr(0,5) + "\r\n";
       }
       else
       {   
           var tmp = element("tdPlainWarning").innerHTML;
           if (tmp.indexOf("<") > 0)
                tmp = tmp.substr(0,tmp.indexOf("<")) + " " + tmp.substr(tmp.indexOf(">")+1);
          s += tmp + "\r\n";
       }
       s += "Plain Unit Fastest Rotation Time" + ":\t";
       if (element("tdPlainWarning").style.display == "none")
       {
            s += element("txtPlainUnitFastestRotation").value + " ";
            s += element("spnUCPlainUnitFastestRotation").innerHTML.substr(0,3) + "\r\n";
       }
       else
            s += "\r\n";
       s+= "Shock Pads Kinetic Energy" + ":\t\t";
       if (element("tdShockPadWarning").style.display == "none")
       {
             s += element("txtShockPadKe").value + " "; 
             if (element("spnUCShockPadKe").innerHTML.substr(0,3) == "N-m")
            {
                if (element("spnUCShockPadKe").innerHTML.substr(0,4) == "N-mm")
                    s += "N-mm" + "\r\n";
                else
                    s += "N-m" + "\r\n";
            }
             else
                 s += element("spnUCShockPadKe").innerHTML.substr(0,5) + "\r\n";            
       }
       else
       {
         var tmp = element("tdShockPadWarning").innerHTML;
         if (tmp.indexOf("<") > 0)
              tmp = tmp.substr(0,tmp.indexOf("<")) + " " + tmp.substr(tmp.indexOf(">")+1);
         s += tmp + "\r\n";
       }
       s += "Shock Pad Fastest Rotation Time" + ":\t";
       if (element("tdShockPadWarning").style.display == "none")
       {
            s += element("txtShockPadFastestRotation").value + " ";
            s += element("spnUCShockPadFastestRotation").innerHTML.substr(0,3) + "\r\n";
       }
       else
            s += "\r\n";
       s += "Cushions Kinetic Energy" + ":\t\t";
        if (element("tdCushionWarning").style.display == "none")
        {
             s += element("txtCushionKe").value + " ";    
             if (element("spnUCCushionKe").innerHTML.substr(0,3) == "N-m")
            {
                if (element("spnUCCushionKe").innerHTML.substr(0,4) == "N-mm")
                    s += "N-mm" + "\r\n";
                else
                    s += "N-m" + "\r\n";
            }
             else
                 s += element("spnUCCushionKe").innerHTML.substr(0,5) + "\r\n";  
        }
        else
        {
            var tmp = element("tdCushionWarning").innerHTML;
            if (tmp.indexOf("<") > 0)
              tmp = tmp.substr(0,tmp.indexOf("<")) + " " + tmp.substr(tmp.indexOf(">")+1);
            s += tmp + "\r\n";
        }
         s += "Cushion Fastest Rotation Time" + ":\t\t";
       if (element("tdCushionWarning").style.display == "none")
       {
            s += element("txtCushionFastestRotation").value + " ";
            s += element("spnUCCushionFastestRotation").innerHTML.substr(0,3) + "\r\n";
       }
       else
            s += "\r\n";
      s += "Shock Absorbers Kinetic Energy" + ":\t\t";
      if (element("tdShockAbsorberWarning").style.display == "none")
      {
            s += element("txtShockAbsorberKe").value + " "; 
            if (element("spnUCShockAbsorberKe").innerHTML.substr(0,3) == "N-m")
            {
                if (element("spnUCShockAbsorberKe").innerHTML.substr(0,4) == "N-mm")
                    s += "N-mm" + "\r\n";
                else
                    s += "N-m" + "\r\n";
            }
             else
                 s += element("spnUCShockAbsorberKe").innerHTML.substr(0,5) + "\r\n";   
      }
      else
      {
            var tmp = element("tdShockAbsorberWarning").innerHTML;
            if (tmp.indexOf("<") > 0)
              tmp = tmp.substr(0,tmp.indexOf("<")) + " " + tmp.substr(tmp.indexOf(">")+1);
            s += tmp + "\r\n";
      }
       s += "Shock Absorber Fastest Rotation Time" + ":\t";
       if (element("tdShockAbsorberWarning").style.display == "none")
       {
            s += element("txtShockAbsorberFastestRotation").value + " ";
            s += element("spnUCShockAbsorberFastestRotation").innerHTML.substr(0,3) + "\r\n";
       }
       else
            s += "\r\n";
       s += "Matching Shock Absorber Kit" + ":\t\t";
       s += element("tdShockAbsorberKit").innerHTML + "\r\n";
       
       //****************************************************************************
       //*                                  APP 2                                   *
       //****************************************************************************
       if (compMode)
       {    
                s += "\r\n\r\n\r\n";
                s += "********  Application 2  *********";
                s += "\r\n\r\n";
                s += "Inputs:\r\n\r\n";
               switch (sOrientation)
            {
                case "App2divDiskOnCenter": orDesc = "Disk On Center"; break ;
                case "App2divDiskEndOnCenter": orDesc = "Disk End On Center"; break ;
	            case "App2divSphere": orDesc = "Sphere"; break ;
	            case "App2divPlateOnCenter": orDesc = "Plate On Center"; break ;
	            case "App2divRodOnCenter": orDesc = "Rod On Center"; break ;
	            case "App2divPointLoad": orDesc = "Point Load" ; break ;
                case "App2divPlateOffCenter": orDesc = "Plate Off Center" ; break ;
	            case "App2divRodOffCenter": orDesc = "Rod Off Center" ; break ;	           
            }
            
            s += "Orientation" + ":\t\t"+ orDesc + "\r\n";
            
            var tmpAxis;
            if (element("App2rbAxisVertical").checked  == true)
                tmpAxis = "Vertical";
            else
                tmpAxis = "Horizontal";
                
            s += "Axis" + ":\t\t\t" + tmpAxis + "\r\n";  
            s += "Angle of Rotation" + ":\t" + element("App2txtAOR").value + " " + element("App2spnUCAOR").innerHTML.substr(0,3) + "\r\n";
            if (element("App2spnUCRotTime").innerHTML.substr(0,2) == "ms")
                s += "Rotation Time" + ":\t" + element("App2txtRotTime").value + " " + element("App2spnUCRotTime").innerHTML.substr(0,2) + "\r\n";
            else
                 s += "Rotation Time" + ":\t\t" + element("App2txtRotTime").value + " " + element("App2spnUCRotTime").innerHTML.substr(0,3) + "\r\n";
            s += "Pressure" + ":\t\t" + element("App2txtPressure").value + " ";
            if (element("App2spnUCPressure").innerHTML.substr(0,5)== "mm-Hg")
                s += "mm-Hg" + "\r\n";
            else if (element("App2spnUCPressure").innerHTML.substr(0,5) == "in-Hg")
                s += "in-Hg" + "\r\n";
            else
                s += element("App2spnUCPressure").innerHTML.substr(0,3) + "\r\n";
                
            s += "Torque Safety Factor" + ":\t" + element("App2txtTSF").value + "\r\n";
            s += "Rotary Face To Load" + ":\t" + element("App2txtFTL").value + " ";
            if (element("App2spnUCFTL").innerHTML.substr(0,2) == "in")
                s += "in" + "\r\n";
            else if (element("App2spnUCFTL").innerHTML.substr(0,2) == "ft")
                s += "ft" + "\r\n";
            else if (element("App2spnUCFTL").innerHTML.substr(0,2) == "mm")
                s += "mm" + "\r\n";
            else if (element("App2spnUCFTL").innerHTML.substr(0,2) == "cm")
                s += "cm" + "\r\n";
            else
                s += "m" + "\r\n";
                
            s += "Radius" + ":\t\t\t" + element("App2txtRadius").value + " ";
            if (element("App2spnUCRadius").innerHTML.substr(0,1) == "m")
            {
                if (element("App2spnUCRadius").innerHTML.substr(0,2) == "mm")
                    s += "mm" + "\r\n";
                else
                    s += "m" + "\r\n";
            }
            else
                s += element("App2spnUCRadius").innerHTML.substr(0,2) + "\r\n";
                
            s += "Load" + ":\t\t\t" + element("App2txtLoad").value + " ";
            if (
                (element("App2spnUCLoad").innerHTML.substr(0,1) == "N") ||
                (element("App2spnUCLoad").innerHTML.substr(0,1) == "g")                   
               )
                s += element("App2spnUCLoad").innerHTML.substr(0,1) + "\r\n";
            else
                s += element("App2spnUCLoad").innerHTML.substr(0,2) + "\r\n";
                
            s += "Inertia Adder" + ":\t\t" + element("App2txtInertiaAdd").value + " ";
            if (element("App2spnUCInertiaAdd").innerHTML.substr(0,10) == "g-cm-sec^2")
                s += "g-cm-sec^2" + "\r\n";
            else if (element("App2spnUCInertiaAdd").innerHTML.substr(0,10) == "kg-m-sec^2")
                s += "kg-m-sec^2" + "\r\n"
            else
                s += element("App2spnUCInertiaAdd").innerHTML.substr(0,11) + "\r\n";
                
            s += "Torque Adder" + ":\t\t" + element("App2txtTorqueAdd").value + " ";
            if (element("App2spnUCTorqueAdd").innerHTML.substr(0,3) == "N-m")
            {
                if (element("App2spnUCTorqueAdd").innerHTML.substr(0,4) == "N-mm")
                    s += "N-mm" + "\r\n";
                else
                    s += "N-m" + "\r\n";
            }
            else
                s += element("App2spnUCTorqueAdd").innerHTML.substr(0,5) + "\r\n";
                
          //  s += "Eliminate Bounce"  + ":\t";
          //  if (element("App2cbBounce").checked)
           //     s += "Checked" + "\r\n";
           // else
            //    s += "Not checked" + "\r\n";
            
          
          // Critical Values
          
         s += "\r\n" + "Critical Values:" + "\r\n\r\n";
         
         s += "Inertia" + ":\t\t" + element("App2txtInertia").value + " ";
         if (element("App2spnUCInertia").innerHTML.substr(0,10) == "g-cm-sec^2")
            s += "g-cm-sec^2" + "\r\n";
         else if (element("App2spnUCInertia").innerHTML.substr(0,10) == "kg-m-sec^2")
            s += "kg-m-sec^2" + "\r\n";
         else
            s += element("App2spnUCInertia").innerHTML.substr(0,11) + "\r\n";
            
         s += "Required Torque" + ":\t" + element("App2txtReqTorque").value + " ";
         if (element("App2spnUCReqTorque").innerHTML.substr(0,3) == "N-m")
         {
            if (element("App2spnUCReqTorque").innerHTML.substr(0,4) == "N-mm")
                s += "N-mm" + "\r\n";
            else
                s += "N-m" + "\r\n";
         }
         else
            s += element("App2spnUCReqTorque").innerHTML.substr(0,5) + "\r\n";
         s += "Est. Peak Velocity" + ":\t" + element("App2txtPeakVelocity").value + " ";
         s += element("App2spnUCPeakVelocity").innerHTML.substr(0,7) + "\r\n";
         s += "Acceleration" + ":\t\t" + element("App2txtAcceleration").value + " ";
         s += element("App2spnUCAcceleration").innerHTML.substr(0,9) + "\r\n";
         s += "Kinetic Energy" + ":\t\t" + element("App2txtKineticEnergy").value + " ";
         if (element("App2spnUCKineticEnergy").innerHTML.substr(0,3) == "N-m")
         {
            if (element("App2spnUCKineticEnergy").innerHTML.substr(0,4) == "N-mm")
                s += "N-mm" + "\r\n";
            else
                s += "N-m" + "\r\n";
         }
         else
            s += element("App2spnUCKineticEnergy").innerHTML.substr(0,5) + "\r\n";
         s += "Backlash" + ":\t\t" + element("App2txtBacklash").value + " ";
         s += element("App2spnUCBacklash").innerHTML.substr(0,3) + "\r\n";   
         
         s += "\r\n\r\n";
         s += "Show Marginal:\t\t\t";
         if(element("App2cbMarginal").checked)
            s += "Yes";
         else
            s += "No";
         s += "\r\n";
         s += "Show Failed:\t\t\t";
         if(element("App2cbFailed").checked)
            s += "Yes";
         else
            s += "No";
         s += "\r\n";            
         s += "External shocks and stops:\t";
         if(element("App2cbExternalShocks").checked)
            s += "Yes";
         else
            s += "No";
            s += "\r\n";
        // Results
        
        s += "\r\n" + "Results:" + "\r\n\r\n"
        
        s += "Base Part Number" + ":\t" + element("App2td").innerHTML + "\r\n";
        s += "Axial Bearing Capacity" + ":\t" + element("App2txtAxialBearingCapacity").value + " ";
       if (element("App2spnUCAxialBearingCapacity").innerHTML.substr(0,1) == "g")
            s += "g" + "\r\n";
       else if (element("App2spnUCAxialBearingCapacity").innerHTML.substr(0,1) == "N")
            s += "N" + "\r\n";
       else
            s += element("App2spnUCAxialBearingCapacity").innerHTML.substr(0,2) + "\r\n";
       s += "Radial Bearing Capacity" + ":" + element("App2txtRadialBearingCapacity").value + " ";
       if (element("App2spnUCRadialBearingCapacity").innerHTML.substr(0,1) == "g")
            s += "g" + "\r\n";
       else if (element("App2spnUCRadialBearingCapacity").innerHTML.substr(0,1) == "N")
            s += "N" + "\r\n";
       else
            s += element("App2spnUCRadialBearingCapacity").innerHTML.substr(0,2) + "\r\n";
       s += "Expected Backlash" + ":\t" + element("App2txtExpectedBacklash").value + " ";
       s += element("App2spnUCExpectedBacklash").innerHTML.substr(0,3) + "\r\n";    
       s += "Rotational Tolerance" + "\r\n";
       s += "(Positive)" + ":\t\t" + element("App2txtRotationalTolerancePlus").value + " ";
       s += element("App2spnUCRotationalTolerancePlus").innerHTML.substr(0,3) + "\r\n";
       s += "Rotational Tolerance" + "\r\n";
       s += "(Negative)" + ":\t\t" + element("App2txtRotationalToleranceMinus").value + " ";
       s += element("App2spnUCRotationalToleranceMinus").innerHTML.substr(0,3) + "\r\n";
       //s += "Breakaway Pressure" + ":\t" + element("App2txtBreakawayPressure").value + " "; 7/23/08 Breakaway Pressure removed
        //if (element("App2spnUCBreakawayPressure").innerHTML.substr(0,5)== "mm-Hg")
         //       s += "mm-Hg" + "\r\n";
         //   else if (element("App2spnUCBreakawayPressure").innerHTML.substr(0,5) == "in-Hg")
         //       s += "in-Hg" + "\r\n";
          //  else
           //     s += element("App2spnUCBreakawayPressure").innerHTML.substr(0,3) + "\r\n";
       s += "Approx. Torque Output" + ":\t" + element("App2txtApproxTorqueOutput").value + " ";
       if (element("App2spnUCApproxTorqueOutput").innerHTML.substr(0,3) == "N-m")
         {
            if (element("App2spnUCApproxTorqueOutput").innerHTML.substr(0,4) == "N-mm")
                s += "N-mm" + "\r\n";
            else
                s += "N-m" + "\r\n";
         }
         else
            s += element("App2spnUCApproxTorqueOutput").innerHTML.substr(0,5) + "\r\n";
       s += "Device Weight" + ":\t\t" + element("App2txtDeviceWeight").value + " ";
       if (
                (element("App2spnUCDeviceWeight").innerHTML.substr(0,1) == "N") ||
                (element("App2spnUCDeviceWeight").innerHTML.substr(0,1) == "g")                   
               )
                s += element("App2spnUCDeviceWeight").innerHTML.substr(0,1) + "\r\n";
            else
                s += element("App2spnUCDeviceWeight").innerHTML.substr(0,2) + "\r\n";
       s += "Cv" + ":\t\t\t" + element("App2txtCv").value + " "  + "\r\n";
       s += "SCFM" + ":\t\t\t" + element("App2txtSCFM").value + " ";
       if (element("App2spnUCSCFM").innerHTML.substr(0,3) == "LPM")
            s += "LPM" + "\r\n";
       else
            s += "SCFM" + "\r\n";
       
       // Kinetic Energy Stopping Capacity
       
       s += "\r\n" + "Kinetic Energy Stopping Capacity:" + "\r\n\r\n"
       
       s += "Plain Unit Kinetic Energy" + ":\t\t"; 
       if (element("App2tdPlainWarning").style.display == "none")
       {      
            s += element("App2txtPlainUnitKe").value + " "; 
            if (element("App2spnUCPlainUnitKe").innerHTML.substr(0,3) == "N-m")
            {
                if (element("App2spnUCPlainUnitKe").innerHTML.substr(0,4) == "N-mm")
                    s += "N-mm" + "\r\n";
                else
                    s += "N-m" + "\r\n";
            }
             else
                 s += element("App2spnUCPlainUnitKe").innerHTML.substr(0,5) + "\r\n";
       }
       else
       {   
           var tmp = element("App2tdPlainWarning").innerHTML;
           if (tmp.indexOf("<") > 0)
                tmp = tmp.substr(0,tmp.indexOf("<")) + " " + tmp.substr(tmp.indexOf(">")+1);
          s += tmp + "\r\n";
       }
       s += "Plain Unit Fastest Rotation Time" + ":\t";
       if (element("App2tdPlainWarning").style.display == "none")
       {
            s += element("App2txtPlainUnitFastestRotation").value + " ";
            s += element("App2spnUCPlainUnitFastestRotation").innerHTML.substr(0,3) + "\r\n";
       }
       else
            s += "\r\n";
       s+= "Shock Pads Kinetic Energy" + ":\t\t";
       if (element("App2tdShockPadWarning").style.display == "none")
       {
             s += element("App2txtShockPadKe").value + " "; 
             if (element("App2spnUCShockPadKe").innerHTML.substr(0,3) == "N-m")
            {
                if (element("App2spnUCShockPadKe").innerHTML.substr(0,4) == "N-mm")
                    s += "N-mm" + "\r\n";
                else
                    s += "N-m" + "\r\n";
            }
             else
                 s += element("App2spnUCShockPadKe").innerHTML.substr(0,5) + "\r\n";            
       }
       else
       {
         var tmp = element("App2tdShockPadWarning").innerHTML;
         if (tmp.indexOf("<") > 0)
              tmp = tmp.substr(0,tmp.indexOf("<")) + " " + tmp.substr(tmp.indexOf(">")+1);
         s += tmp + "\r\n";
       }
       s += "Shock Pad Fastest Rotation Time" + ":\t";
       if (element("App2tdShockPadWarning").style.display == "none")
       {
            s += element("App2txtShockPadFastestRotation").value + " ";
            s += element("App2spnUCShockPadFastestRotation").innerHTML.substr(0,3) + "\r\n";
       }
       else
            s += "\r\n";
       s += "Cushions Kinetic Energy" + ":\t\t";
        if (element("App2tdCushionWarning").style.display == "none")
        {
             s += element("App2txtCushionKe").value + " ";    
             if (element("App2spnUCCushionKe").innerHTML.substr(0,3) == "N-m")
            {
                if (element("App2spnUCCushionKe").innerHTML.substr(0,4) == "N-mm")
                    s += "N-mm" + "\r\n";
                else
                    s += "N-m" + "\r\n";
            }
             else
                 s += element("App2spnUCCushionKe").innerHTML.substr(0,5) + "\r\n";  
        }
        else
        {
            var tmp = element("App2tdCushionWarning").innerHTML;
            if (tmp.indexOf("<") > 0)
              tmp = tmp.substr(0,tmp.indexOf("<")) + " " + tmp.substr(tmp.indexOf(">")+1);
            s += tmp + "\r\n";
        }
         s += "Cushion Fastest Rotation Time" + ":\t\t";
       if (element("App2tdCushionWarning").style.display == "none")
       {
            s += element("App2txtCushionFastestRotation").value + " ";
            s += element("App2spnUCCushionFastestRotation").innerHTML.substr(0,3) + "\r\n";
       }
       else
            s += "\r\n";
      s += "Shock Absorbers Kinetic Energy" + ":\t\t";
      if (element("App2tdShockAbsorberWarning").style.display == "none")
      {
            s += element("App2txtShockAbsorberKe").value + " "; 
            if (element("App2spnUCShockAbsorberKe").innerHTML.substr(0,3) == "N-m")
            {
                if (element("App2spnUCShockAbsorberKe").innerHTML.substr(0,4) == "N-mm")
                    s += "N-mm" + "\r\n";
                else
                    s += "N-m" + "\r\n";
            }
             else
                 s += element("App2spnUCShockAbsorberKe").innerHTML.substr(0,5) + "\r\n";   
      }
      else
      {
            var tmp = element("App2tdShockAbsorberWarning").innerHTML;
            if (tmp.indexOf("<") > 0)
              tmp = tmp.substr(0,tmp.indexOf("<")) + " " + tmp.substr(tmp.indexOf(">")+1);
            s += tmp + "\r\n";
      }
       s += "Shock Absorber Fastest Rotation Time" + ":\t";
       if (element("App2tdShockAbsorberWarning").style.display == "none")
       {
            s += element("App2txtShockAbsorberFastestRotation").value + " ";
            s += element("App2spnUCShockAbsorberFastestRotation").innerHTML.substr(0,3) + "\r\n";
       }
       else
            s += "\r\n";
       s += "Matching Shock Absorber Kit" + ":\t\t";
       s += element("App2tdShockAbsorberKit").innerHTML + "\r\n";
       }
      
       
       
            
        //**********************8   
        window.clipboardData.setData("Text", s);
        alert("Data was copied to the clipboard.");
    } // End App2
    else
        alert( "Sorry, but copying to the clipboard only works in Microsoft's Internet Explorer browser.");
        
     return;
           
} // end copy function

function standardMode() {

    //set output modes...
    if (element("rbMetric").checked) {
        // set the metric input on for standard mode
        element("rbMetricInputs").checked = true;
    }

    if (element("rbImperial").checked) {
        // set the imperial input on for standard mode
        element("rbImperialInputs").checked = true;
    }
    
    //element("divCenterCol").style.width = "316px";
    compMode = false;
    
    rotList('');
   
    element("divDetails").innerHTML = element("CompModedivDetails").innerHTML;
    element("CompModedivDetails").innerHTML = "";
    //element("divCenterCol").style.width = "340px";
    
    element("tabRightCol").style.display = "block";
    element("compModeResults1Alt").style.display = "none";
    element("App2div").style.display = "none";

  
    
    
    
   
    return;
}

function compareMode() {
    
    // set display and width
    compMode = true;
    
    waitCursor();
    element("rbCompareMode").disabled = true;
    element("rbStandardMode").disabled = true;
    element("divCenterCol").style.width = "370px";


    //set output modes...
    if (element("rbMetric").checked) {
        // set the metric input on for standard mode
        element("App2rbMetricInputs").checked = true;
    }

    if (element("rbImperial").checked) {
        // set the imperial input on for standard mode
        element("App2rbImperialInputs").checked = true;
    }
 
    
    element("divCenterCol").style.display = "none";
    //element("divCenterCol").style.width = "450px";
    element("divCenterCol").style.display = "block";
   
    window.setTimeout("setupComp()",1000);
   

    element("CompModedivDetails").innerHTML = element("divDetails").innerHTML;
    element("divDetails").innerHTML = "";
    //element("App2divDetails").innerHTML = element("divDetails").innerHTML;
    element("App2hidSelected").value = element("hidSelected").value;
    element("CompModehidSelected").value = element("hidSelected").value;
    
    //element("App2flashcontent").innerHTML = element("flashcontent").innerHTML;
    //element("CompModeflashcontent").innerHTML = element("flashcontent").innerHTML;
    
    element("App2flashcontent").innerHTML ="";
    element("CompModeflashcontent").innerHTML = "";
    
  //*******************************
    var tmpOrientation;
    if (selectOrientation.id.substr(0,4) == "App2")
        tmpOrientation = selectOrientation.id;
    else
        tmpOrientation = "App2" + selectOrientation.id;
    divClick(tmpOrientation); // init to look like the first image was clicked    
    element("App2rbAxisVertical").checked = element("rbAxisVertical").checked;
    element("App2rbAxisHorizontal").checked = element("rbAxisHorizontal").checked;
    
    element("CompModecbFailed").checked = element("cbFailed").checked;
    element("App2cbFailed").checked = element("cbFailed").checked;
    element("CompModecbMarginal").checked = element("cbMarginal").checked;
    element("App2cbMarginal").checked = element("cbMarginal").checked;
    element("CompModecbExternalShocks").checked = element("cbExternalShocks").checked;
    element("App2cbExternalShocks").checked = element("cbExternalShocks").checked;
     
    setRotSWF('App2');
    
   
    // SETUP APP 2 Inputs
    var pressureLimit = element("rbPneumatic").checked ? 150 : 1500;
    SetupUC("App2imgAORMinus", "App2txtAOR", "App2imgAORPlus", "App2spnUCAOR", "angle", element("spnUCAOR").Units, element("spnUCAOR").ActualValue, element("spnUCAOR").ConvFact, 5.0, 4, 0, Infinity, false) ;    
    SetupUC("App2imgRotTimeMinus", "App2txtRotTime", "App2imgRotTimePlus", "App2spnUCRotTime", "time", element("spnUCRotTime").Units, element("spnUCRotTime").ActualValue, element("spnUCRotTime").ConvFact, 0.1, 4, 0, Infinity, false) ;
    SetupUC("App2imgPressureMinus", "App2txtPressure", "App2imgPressurePlus", "App2spnUCPressure", "pressure", element("spnUCPressure").Units, element("spnUCPressure").ActualValue, element("spnUCPressure").ConvFact, 1, 4, 0, pressureLimit, false) ;
    SetupUC("App2imgTSFMinus", "App2txtTSF", "App2imgTSFPlus", "App2spnUCTSF", "", "", element("spnUCTSF").ActualValue, 1, 1, 4, 1, Infinity, false) ;
    SetupUC("App2imgFTLMinus", "App2txtFTL", "App2imgFTLPlus", "App2spnUCFTL", "length", element("spnUCFTL").Units, element("spnUCFTL").ActualValue, element("spnUCFTL").ConvFact, 0.5, 4, 0, Infinity, false) ;
    SetupUC("App2imgRadiusMinus", "App2txtRadius", "App2imgRadiusPlus", "App2spnUCRadius", "length", element("spnUCRadius").Units, element("spnUCRadius").ActualValue, element("spnUCRadius").ConvFact, 1, 4, 0, Infinity, false) ;
    SetupUC("App2imgShortLengthMinus", "App2txtShortLength", "App2imgShortLengthPlus", "App2spnUCShortLength", "length", element("spnUCShortLength").Units, element("spnUCShortLength").ActualValue, element("spnUCShortLength").ConvFact, 1, 4, 0, Infinity, false) ;
    SetupUC("App2imgLengthMinus", "App2txtLength", "App2imgLengthPlus", "App2spnUCLength", "length", element("spnUCLength").Units, element("spnUCLength").ActualValue, element("spnUCLength").ConvFact, 1, 4, 0, Infinity, false) ;
    SetupUC("App2imgHeightMinus", "App2txtHeight", "App2imgHeightPlus", "App2spnUCHeight", "length", element("spnUCHeight").Units, element("spnUCHeight").ActualValue, element("spnUCHeight").ConvFact, 1, 4, 0, Infinity, false) ;
    SetupUC("App2imgShortLoadMinus", "App2txtShortLoad", "App2imgShortLoadPlus", "App2spnUCShortLoad", "weight", element("spnUCShortLoad").Units, element("spnUCShortLoad").ActualValue, element("spnUCShortLoad").ConvFact, 1, 4, 0, Infinity, false) ;
    SetupUC("App2imgLoadMinus", "App2txtLoad", "App2imgLoadPlus", "App2spnUCLoad", "weight", element("spnUCLoad").Units, element("spnUCLoad").ActualValue, element("spnUCLoad").ConvFact, 1, 4, 0, Infinity, false) ;
    SetupUC("App2imgInertiaAddMinus", "App2txtInertiaAdd", "App2imgInertiaAddPlus", "App2spnUCInertiaAdd", "inertia", element("spnUCInertiaAdd").Units, element("spnUCInertiaAdd").ActualValue, element("spnUCInertiaAdd").ConvFact, 1, 4, 0, Infinity, false) ;
    SetupUC("App2imgTorqueAddMinus", "App2txtTorqueAdd", "App2imgTorqueAddPlus", "App2spnUCTorqueAdd", "torque", element("spnUCTorqueAdd").Units, element("spnUCTorqueAdd").ActualValue, element("spnUCTorqueAdd").ConvFact, 1, 4, 0, Infinity, false) ;        
    SetupUC("App2imgCycleRateMinus", "App2txtCycleRate", "App2imgCycleRatePlus", "App2spnUCCycleRate", "cyclerate", element("spnUCCycleRate").Units, element("spnUCCycleRate").ActualValue, element("spnUCCycleRate").ConvFact, 1, 4, 0, Infinity, false) ;        
    SetupUC("App2imgTemperatureMinus", "App2txtTemperature", "App2imgTemperaturePlus", "App2spnUCTemperature", "temperature", element("spnUCTemperature").Units, element("spnUCTemperature").ActualValue, "F", 1, 1, -20, 180, false) ;        
  
  
   // SETUP App 1 compare mode critical values
   var colName = "CompMode";
    SetupUC(colName + "imgInertiaMinus", colName + "txtInertia", colName + "imgInertiaPlus",  colName + "spnUCInertia", "inertia", element("spnUCInertia").Units, element("spnUCInertia").ActualValue, element("spnUCInertia").ConvFact, 1, 4, 0, Infinity, true) ;        
    SetupUC( colName + "imgReqTorqueMinus",  colName + "txtReqTorque",  colName + "imgReqTorquePlus",  colName + "spnUCReqTorque", "torque", element("spnUCReqTorque").Units, element("spnUCReqTorque").ActualValue, element("spnUCReqTorque").ConvFact, 1, 4, 0, Infinity, true) ;        
    SetupUC(colName + "imgTotalInertiaMinus", colName + "txtTotalInertia", colName + "imgTotalInertiaPlus",  colName + "spnUCTotalInertia", "inertia", element("spnUCTotalInertia").Units, element("spnUCTotalInertia").ActualValue, element("spnUCTotalInertia").ConvFact, 1, 4, 0, Infinity, true) ;        
    SetupUC( colName + "imgTotalReqTorqueMinus",  colName + "txtTotalReqTorque",  colName + "imgTotalReqTorquePlus",  colName + "spnUCTotalReqTorque", "torque", element("spnUCTotalReqTorque").Units, element("spnUCTotalReqTorque").ActualValue, element("spnUCTotalReqTorque").ConvFact, 1, 4, 0, Infinity, true) ;        
    
    SetupUC( colName + "imgPeakVelocityMinus",  colName + "txtPeakVelocity",  colName + "imgPeakVelocityPlus",  colName + "spnUCPeakVelocity", "angularvelocity", element("spnUCPeakVelocity").Units, element("spnUCPeakVelocity").ActualValue, element("spnUCPeakVelocity").ConvFact, 1, 4, 0, Infinity, true) ;        
    SetupUC( colName + "imgAccelerationMinus",  colName + "txtAcceleration",  colName + "imgAccelerationPlus",  colName + "spnUCAcceleration", "angularacceleration", element("spnUCAcceleration").Units, element("spnUCAcceleration").ActualValue, element("spnUCAcceleration").ConvFact, 1, 4, 0, Infinity, true) ;        
    SetupUC( colName + "imgKineticEnergyMinus",  colName + "txtKineticEnergy", colName +  "imgKineticEnergyPlus", colName +  "spnUCKineticEnergy", "energy", element("spnUCKineticEnergy").Units, element("spnUCKineticEnergy").ActualValue, element("spnUCKineticEnergy").ConvFact, 1, 4, 0, Infinity, true) ;        
//    SetupUC( colName + "imgBacklashMinus", colName +  "txtBacklash", colName +  "imgBacklashPlus", colName +  "spnUCBacklash", "angle", element("hidDegree").value, "0", 1, 1, 4, 0, Infinity, true) ;     
    
    // SETUP App 2 critical values
    
    colName = "App2";
    SetupUC(colName + "imgInertiaMinus", colName + "txtInertia", colName + "imgInertiaPlus",  colName + "spnUCInertia", "inertia", element("spnUCInertia").Units, element("spnUCInertia").ActualValue, element("spnUCInertia").ConvFact, 1, 4, 0, Infinity, true) ;        
    SetupUC( colName + "imgReqTorqueMinus",  colName + "txtReqTorque",  colName + "imgReqTorquePlus",  colName + "spnUCReqTorque", "torque", element("spnUCReqTorque").Units, element("spnUCReqTorque").ActualValue, element("spnUCReqTorque").ConvFact, 1, 4, 0, Infinity, true) ;        
     SetupUC(colName + "imgTotalInertiaMinus", colName + "txtTotalInertia", colName + "imgTotalInertiaPlus",  colName + "spnUCTotalInertia", "inertia", element("spnUCTotalInertia").Units, element("spnUCTotalInertia").ActualValue, element("spnUCTotalInertia").ConvFact, 1, 4, 0, Infinity, true) ;        
    SetupUC( colName + "imgTotalReqTorqueMinus",  colName + "txtTotalReqTorque",  colName + "imgTotalReqTorquePlus",  colName + "spnUCTotalReqTorque", "torque", element("spnUCTotalReqTorque").Units, element("spnUCTotalReqTorque").ActualValue, element("spnUCTotalReqTorque").ConvFact, 1, 4, 0, Infinity, true) ;        
    SetupUC( colName + "imgPeakVelocityMinus",  colName + "txtPeakVelocity",  colName + "imgPeakVelocityPlus",  colName + "spnUCPeakVelocity", "angularvelocity", element("spnUCPeakVelocity").Units, element("spnUCPeakVelocity").ActualValue, element("spnUCPeakVelocity").ConvFact, 1, 4, 0, Infinity, true) ;        
    SetupUC( colName + "imgAccelerationMinus",  colName + "txtAcceleration",  colName + "imgAccelerationPlus",  colName + "spnUCAcceleration", "angularacceleration", element("spnUCAcceleration").Units, element("spnUCAcceleration").ActualValue, element("spnUCAcceleration").ConvFact, 1, 4, 0, Infinity, true) ;        
    SetupUC( colName + "imgKineticEnergyMinus",  colName + "txtKineticEnergy", colName +  "imgKineticEnergyPlus", colName +  "spnUCKineticEnergy", "energy", element("spnUCKineticEnergy").Units, element("spnUCKineticEnergy").ActualValue, element("spnUCKineticEnergy").ConvFact, 1, 4, 0, Infinity, true) ;        
//    SetupUC( colName + "imgBacklashMinus", colName +  "txtBacklash", colName +  "imgBacklashPlus", colName +  "spnUCBacklash", "angle", element("hidDegree").value, "0", 1, 1, 4, 0, Infinity, true) ;


  
  // SETUP App 2 Details
  detailsUCSetup("App2", ""); 
  detailsUCSetup("App2","C2");
  detailsUCSetup("App2", "C3");

  //set output modes...
  if (element("rbMetric").checked) {
      // set the metric input on for standard mode
      element("App2rbMetricInputs").checked = true;
      setOutputUnits('MasterModeMetric');
  }

  if (element("rbImperial").checked) {
      // set the imperial input on for standard mode
      element("App2rbImperialInputs").checked = true;
      setOutputUnits('MasterModeImperial');
  }
 

  initComp('CompMode');
  initComp('App2');
  
  
  element("tabRightCol").style.display = "none";
  
  element("App2div").style.display = "block";
    
  element("compModeResults1Alt").style.display = "block";   
    
    defCursor();
    
    window.setTimeout("enableButtons()",2000);
    return;
}

function enableButtons()
{
    
    element("rbCompareMode").disabled = false;
    element("rbStandardMode").disabled = false;
}
function pausecomp(millis)
{
    var date = new Date();
    var curDate = null;

    do { curDate = new Date(); }
    while(curDate-date < millis);
} 

function setupComp()
{
     // hide app1 results in right column and display it in center column
    element("tabRightCol").style.display = "none";
     
   // element("compModeResults1Alt").style.width = "450px";
    element("compModeResults1Alt").style.display = "block";   
        
    // display app2 inputs in right column
    element("App2div").style.display = "block";
    return;
}


function Print()
{
   
  tabIns = element("tableCenterCol");
  tabCriticalValues = element("divCriticalValues");
  App2tabCriticalValues = element("App2divCriticalValues");
  CompModetabCritcalValues = element("divCriticalValues");
  
  tabListFilter = element("tabListFilter");
  CompModetabListFilter = element("CompModetabListFilter");
  App2tabListFilter = element("App2tabListFilter");
  
  tabOuts = element("tabOuts"); 
  
  App2tabIns = element("tableApp2");
  App2tabOuts = element("App2tabOuts");
  CompModetabOuts = element("tabOuts");
 
  var printWin = window.open("print.html");
  return;
		
}

function changeAutoCalc()
{
    var checked = element("cbAutoCalc").checked;
    if (checked)
    {
        //element("spnCalculate").style.visiblity = "hidden";
        element("spnCalculate").style.display = "none";
    }
    else
    {
        //element("spnCalculate").style.visiblity = "visible";
        element("spnCalculate").style.display = "";
    }
    return;
}


// test function
function Initialize() // activated from testInitialize button
{
    objSettings = new Object();
    objSettings.myVar1 = 1;
    objSettings.myVar2 = 2;
    
    return;
}

function resetClick()
{
    if (compMode)
    {
        standardMode();       
    }
    onLoad();
}

function leftLoad()
{
    
    compMode = false;
    return;
}

function divClick(clicked)
{
   
 
    selectOrientation = element(clicked);
    
    // alert("In divClick, column = " + column);
   // alert("In divClick, clicked = " + clicked);
    var column = getColName(clicked);    
    
    // instead of endless if-else statements,
    // reset all to default state, and then select the clicked on.

    element(column + 'divDiskOnCenter').className='divNotSelected';
     
    element(column + 'divDiskEndOnCenter').className='divNotSelected';
    element(column + 'divPlateOffCenter').className='divNotSelected';
    element(column + 'divPlateOnCenter').className='divNotSelected';
    element(column + 'divPointLoad').className='divNotSelected';
    element(column + 'divRodOffCenter').className='divNotSelected';
    element(column + 'divRodOnCenter').className='divNotSelected';
    element(column + 'divSphere').className='divNotSelected';
    
    
    element(clicked).className='divSelected';
    
    element(column + 'hidSelected').value = clicked;
    
    if ((column == "") && (compMode == true))
    {
        column = "CompMode";
    }
       
    setRotSWF(column);
    setOrientation(clicked, column);
       
    return;
}