//is used for beginorder
function loadForm()
{
	populateVendor()
	populateRequestor()

}
//is used for updatemain
function loadForm2()
{
	populateVendor()
	populateDeliverTo()
	populateApproved()
	populateRequestor()
	populateCPO()
	populateCE()
}

//is used for ordercontinue
function loadForm3()
{
	populateAccount()
	populateOC()
}

//is used for ordercontinue
function loadForm6()
{
	populateOC()
}


//is used for convenience check report
function loadForm4()
{
	populateProjectTitle()
	populateAccount()
}

//is used for bank card report
function loadForm5()
{
	populateCardHolder()
}

//is used for add payment
function loadForm8()
{
populateVendor()
}

function loadForm7()
{
	populateVendor()
	populateDeliverTo()
	populateApproved()
	populateCardHolder()
	populateRequestor()
	populateReceivedBy()
	populateCPO()
	populateCE()

}


var keyTime, keyStr = '', allOptsVendor = new Array(), lastKey;
var agt=navigator.userAgent.toLowerCase();
var is_ie = ((agt.indexOf("msie") != -1) && (agt.indexOf("opera") == -1));






function populateVendor()
{
  for(var i = 0; i < document.form1.jtitle.options.length; i++)
  {
    allOptsVendor[i] = document.form1.jtitle.options[i].value.toLowerCase();
  }
}

function setSelectionVendor()
{ 
  // only deals with IE as firefox behaves well anyway, other browser can be added
  if(is_ie)
  {
    var currentKey = unescape('%' + window.event.keyCode.toString(16)).toLowerCase();
    var idx, currentSIdx = document.form1.jtitle.selectedIndex;
    var newTime = new Date().getTime();
    if(keyTime != null && newTime - keyTime < 400) // if two keys were pressed between 0.3 seconds (can be customized), do type-ahead
    {
      keyStr += currentKey;
      idx = findIdxVendor();
	
    }
    else // unfortunately we seem to have to handle default browser behavior too
    {
      keyStr = currentKey;
      var selectFirst = true;
      if(keyStr == lastKey)
      {
        idx = currentSIdx + 1;
        if(idx < allOptsVendor.length && allOptsVendor[idx].charAt(0) == lastKey)
          selectFirst = false;
      }
      if(selectFirst) idx = findIdxVendor();
      lastKey = currentKey;
    }
    if(idx >= 0)
    {
      document.form1.jtitle.options[currentSIdx].selected = false;
      document.form1.jtitle.options[idx].selected = true;
    }
  }
}
function findIdxVendor()
{
  // full scan to find the smallest idx that match string keyStr (case-insensitive)
  // if you get rid of all the toLowerCase() calls in this script, it'd become case
  // sensitive match
  var idx = -1, len = keyStr.length;
  for(var i = 0; i < allOptsVendor.length; i++)
  {
    var str = allOptsVendor[i].substring(0, len);
    if(keyStr == str) { idx = i; break }
  }
  return idx;
}
function setTimeVendor()
{
  keyTime = new Date().getTime();
  return false;
}

/////////////////////////
var allOptsRequestor = new Array(), lastKey;

function populateRequestor()
{
  for(var i = 0; i < document.form1.title.options.length; i++)
  {
    allOptsRequestor[i] = document.form1.title.options[i].value.toLowerCase();
	
  }
}

function setSelectionRequestor()
{
  // only deals with IE as firefox behaves well anyway, other browser can be added
  if(is_ie)
  {
    var currentKey = unescape('%' + window.event.keyCode.toString(16)).toLowerCase();
    var currentSIdx = document.form1.title.selectedIndex;
    var newTime = new Date().getTime();
    if(keyTime != null && newTime - keyTime < 400) // if two keys were pressed between 0.3 seconds (can be customized), do type-ahead
    {
      keyStr += currentKey;
      idx = findIdxRequestor();
    }
    else // unfortunately we seem to have to handle default browser behavior too
    {
      keyStr = currentKey;
      var selectFirst = true;
      if(keyStr == lastKey)
      {
        idx = currentSIdx + 1;
        if(idx < allOptsRequestor.length && allOptsRequestor[idx].charAt(0) == lastKey)
          selectFirst = false;
      }
      if(selectFirst) idx = findIdxRequestor();
      lastKey = currentKey;
    }
    if(idx >= 0)
    {
      document.form1.title.options[currentSIdx].selected = false;
      document.form1.title.options[idx].selected = true;
    }
  }
}
function findIdxRequestor()
{
  // full scan to find the smallest idx that match string keyStr (case-insensitive)
  // if you get rid of all the toLowerCase() calls in this script, it'd become case
  // sensitive match
  var idx = -1, len = keyStr.length;
  for(var i = 0; i < allOptsRequestor.length; i++)
  {
    var str = allOptsRequestor[i].substring(0, len);
    if(keyStr == str) { idx = i; break }
  }
  return idx;
}
function setTimeRequestor()
{
  keyTime = new Date().getTime();
  return false;
}

///////////// Received by
var allOptsReceivedBy = new Array(), lastKey;

function populateReceivedBy()
{
  for(var i = 0; i < document.form1.ReceivedBy.options.length; i++)
  {
    allOptsReceivedBy[i] = document.form1.ReceivedBy.options[i].value.toLowerCase();
  }
}

function setSelectionReceivedBy()
{
  // only deals with IE as firefox behaves well anyway, other browser can be added
  if(is_ie)
  {
    var currentKey = unescape('%' + window.event.keyCode.toString(16)).toLowerCase();
    var currentSIdx = document.form1.ReceivedBy.selectedIndex;
    var newTime = new Date().getTime();
    if(keyTime != null && newTime - keyTime < 400) // if two keys were pressed between 0.3 seconds (can be customized), do type-ahead
    {
      keyStr += currentKey;
      idx = findIdxReceivedBy();
    }
    else // unfortunately we seem to have to handle default browser behavior too
    {
      keyStr = currentKey;
      var selectFirst = true;
      if(keyStr == lastKey)
      {
        idx = currentSIdx + 1;
        if(idx < allOptsReceivedBy.length && allOptsReceivedBy[idx].charAt(0) == lastKey)
          selectFirst = false;
      }
      if(selectFirst) idx = findIdxReceivedBy();
      lastKey = currentKey;
    }
    if(idx >= 0)
    {
      document.form1.ReceivedBy.options[currentSIdx].selected = false;
      document.form1.ReceivedBy.options[idx].selected = true;
    }
  }
}
function findIdxReceivedBy()
{
  // full scan to find the smallest idx that match string keyStr (case-insensitive)
  // if you get rid of all the toLowerCase() calls in this script, it'd become case
  // sensitive match
  var idx = -1, len = keyStr.length;
  for(var i = 0; i < allOptsReceivedBy.length; i++)
  {
    var str = allOptsReceivedBy[i].substring(0, len);
    if(keyStr == str) { idx = i; break }
  }
  return idx;
}
function setTimeReceivedBy()
{
  keyTime = new Date().getTime();
  return false;
}
///

/////////////////////////
var allOptsPreparedBy = new Array(), lastKey;

function populatePreparedBy()
{
  for(var i = 0; i < document.form1.preparedby.options.length; i++)
  {
    allOptsPreparedBy[i] = document.form1.preparedby.options[i].value.toLowerCase();
  }
}

function setSelectionPreparedBy()
{
  // only deals with IE as firefox behaves well anyway, other browser can be added
  if(is_ie)
  {
    var currentKey = unescape('%' + window.event.keyCode.toString(16)).toLowerCase();
    var currentSIdx = document.form1.preparedby.selectedIndex;
    var newTime = new Date().getTime();
    if(keyTime != null && newTime - keyTime < 400) // if two keys were pressed between 0.3 seconds (can be customized), do type-ahead
    {
      keyStr += currentKey;
      idx = findIdxPreparedBy();
    }
    else // unfortunately we seem to have to handle default browser behavior too
    {
      keyStr = currentKey;
      var selectFirst = true;
      if(keyStr == lastKey)
      {
        idx = currentSIdx + 1;
        if(idx < allOptsPreparedBy.length && allOptsPreparedBy[idx].charAt(0) == lastKey)
          selectFirst = false;
      }
      if(selectFirst) idx = findIdxPreparedBy();
      lastKey = currentKey;
    }
    if(idx >= 0)
    {
      document.form1.preparedby.options[currentSIdx].selected = false;
      document.form1.preparedby.options[idx].selected = true;
    }
  }
}
function findIdxPreparedBy()
{
  // full scan to find the smallest idx that match string keyStr (case-insensitive)
  // if you get rid of all the toLowerCase() calls in this script, it'd become case
  // sensitive match
  var idx = -1, len = keyStr.length;
  for(var i = 0; i < allOptsPreparedBy.length; i++)
  {
    var str = allOptsPreparedBy[i].substring(0, len);
    if(keyStr == str) { idx = i; break }
  }
  return idx;
}
function setTimePreparedBy()
{
  keyTime = new Date().getTime();
  return false;
}

/////////////////////////
var allOptsDeliverTo = new Array(), lastKey;

function populateDeliverTo()
{
  for(var i = 0; i < document.form1.jtitle.options.length; i++)
  {
    allOptsDeliverTo[i] = document.form1.jtitle.options[i].value.toLowerCase();
  }
}

function setSelectionDeliverTo()
{
  // only deals with IE as firefox behaves well anyway, other browser can be added
  if(is_ie)
  {
    var currentKey = unescape('%' + window.event.keyCode.toString(16)).toLowerCase();
    var currentSIdx = document.form1.jtitle.selectedIndex;
    var newTime = new Date().getTime();
    if(keyTime != null && newTime - keyTime < 400) // if two keys were pressed between 0.3 seconds (can be customized), do type-ahead
    {
      keyStr += currentKey;
      idx = findIdxDeliverTo();
    }
    else // unfortunately we seem to have to handle default browser behavior too
    {
      keyStr = currentKey;
      var selectFirst = true;
      if(keyStr == lastKey)
      {
        idx = currentSIdx + 1;
        if(idx < allOptsDeliverTo.length && allOptsDeliverTo[idx].charAt(0) == lastKey)
          selectFirst = false;
      }
      if(selectFirst) idx = findIdxDeliverTo();
      lastKey = currentKey;
    }
    if(idx >= 0)
    {
      document.form1.jtitle.options[currentSIdx].selected = false;
      document.form1.jtitle.options[idx].selected = true;
    }
  }
}
function findIdxDeliverTo()
{
  // full scan to find the smallest idx that match string keyStr (case-insensitive)
  // if you get rid of all the toLowerCase() calls in this script, it'd become case
  // sensitive match
  var idx = -1, len = keyStr.length;
  for(var i = 0; i < allOptsDeliverTo.length; i++)
  {
    var str = allOptsDeliverTo[i].substring(0, len);
    if(keyStr == str) { idx = i; break }
  }
  return idx;
}
function setTimeDeliverTo()
{
  keyTime = new Date().getTime();
  return false;
}


/////////////////////////
var allOptsApproved = new Array(), lastKey;

function populateApproved()
{
  for(var i = 0; i < document.form1.approved.options.length; i++)
  {
    allOptsApproved[i] = document.form1.approved.options[i].value.toLowerCase();
  }
}

function setSelectionApproved()
{
  // only deals with IE as firefox behaves well anyway, other browser can be added
  if(is_ie)
  {
    var currentKey = unescape('%' + window.event.keyCode.toString(16)).toLowerCase();
    var currentSIdx = document.form1.approved.selectedIndex;
    var newTime = new Date().getTime();
    if(keyTime != null && newTime - keyTime < 400) // if two keys were pressed between 0.3 seconds (can be customized), do type-ahead
    {
      keyStr += currentKey;
      idx = findIdxApproved();
    }
    else // unfortunately we seem to have to handle default browser behavior too
    {
      keyStr = currentKey;
      var selectFirst = true;
      if(keyStr == lastKey)
      {
        idx = currentSIdx + 1;
        if(idx < allOptsApproved.length && allOptsApproved[idx].charAt(0) == lastKey)
          selectFirst = false;
      }
      if(selectFirst) idx = findIdxApproved();
      lastKey = currentKey;
    }
    if(idx >= 0)
    {
      document.form1.approved.options[currentSIdx].selected = false;
      document.form1.approved.options[idx].selected = true;
    }
  }
}
function findIdxApproved()
{
  // full scan to find the smallest idx that match string keyStr (case-insensitive)
  // if you get rid of all the toLowerCase() calls in this script, it'd become case
  // sensitive match
  var idx = -1, len = keyStr.length;
  for(var i = 0; i < allOptsApproved.length; i++)
  {
    var str = allOptsApproved[i].substring(0, len);
    if(keyStr == str) { idx = i; break }
  }
  return idx;
}
function setTimeApproved()
{
  keyTime = new Date().getTime();
  return false;
}


/////////////////////////
var allOptsCardHolder = new Array(), lastKey;

function populateCardHolder()
{
  for(var i = 0; i < document.form1.cardholder.options.length; i++)
  {
    allOptsCardHolder[i] = document.form1.cardholder.options[i].value.toLowerCase();
  }
}

function setSelectionCardHolder()
{
  // only deals with IE as firefox behaves well anyway, other browser can be added
  if(is_ie)
  {
    var currentKey = unescape('%' + window.event.keyCode.toString(16)).toLowerCase();
    var currentSIdx = document.form1.cardholder.selectedIndex;
    var newTime = new Date().getTime();
    if(keyTime != null && newTime - keyTime < 400) // if two keys were pressed between 0.3 seconds (can be customized), do type-ahead
    {
      keyStr += currentKey;
      idx = findIdxCardHolder();
    }
    else // unfortunately we seem to have to handle default browser behavior too
    {
      keyStr = currentKey;
      var selectFirst = true;
      if(keyStr == lastKey)
      {
        idx = currentSIdx + 1;
        if(idx < allOptsCardHolder.length && allOptsCardHolder[idx].charAt(0) == lastKey)
          selectFirst = false;
      }
      if(selectFirst) idx = findIdxCardHolder();
      lastKey = currentKey;
    }
    if(idx >= 0)
    {
      document.form1.cardholder.options[currentSIdx].selected = false;
      document.form1.cardholder.options[idx].selected = true;
    }
  }
}
function findIdxCardHolder()
{
  // full scan to find the smallest idx that match string keyStr (case-insensitive)
  // if you get rid of all the toLowerCase() calls in this script, it'd become case
  // sensitive match
  var idx = -1, len = keyStr.length;
  for(var i = 0; i < allOptsCardHolder.length; i++)
  {
    var str = allOptsCardHolder[i].substring(0, len);
    if(keyStr == str) { idx = i; break }
  }
  return idx;
}
function setTimeCardHolder()
{
  keyTime = new Date().getTime();
  return false;
}



/////////////////////////
var allOptsAccount = new Array(), lastKey;

function populateAccount()
{
  for(var i = 0; i < document.form1.orderacct.options.length; i++)
  {
    allOptsAccount[i] = document.form1.orderacct.options[i].value.toLowerCase();
  }
}

function setSelectionAccount()
{
  // only deals with IE as firefox behaves well anyway, other browser can be added
  if(is_ie)
  {
    var currentKey = unescape('%' + window.event.keyCode.toString(16)).toLowerCase();
    var currentSIdx = document.form1.orderacct.selectedIndex;
    var newTime = new Date().getTime();
    if(keyTime != null && newTime - keyTime < 400) // if two keys were pressed between 0.3 seconds (can be customized), do type-ahead
    {
      keyStr += currentKey;
      idx = findIdxAccount();
    }
    else // unfortunately we seem to have to handle default browser behavior too
    {
      keyStr = currentKey;
      var selectFirst = true;
      if(keyStr == lastKey)
      {
        idx = currentSIdx + 1;
        if(idx < allOptsAccount.length && allOptsAccount[idx].charAt(0) == lastKey)
          selectFirst = false;
      }
      if(selectFirst) idx = findIdxAccount();
      lastKey = currentKey;
    }
    if(idx >= 0)
    {
      document.form1.orderacct.options[currentSIdx].selected = false;
      document.form1.orderacct.options[idx].selected = true;
    }
  }
}
function findIdxAccount()
{
  // full scan to find the smallest idx that match string keyStr (case-insensitive)
  // if you get rid of all the toLowerCase() calls in this script, it'd become case
  // sensitive match
  var idx = -1, len = keyStr.length;
  for(var i = 0; i < allOptsAccount.length; i++)
  {
    var str = allOptsAccount[i].substring(0, len);
    if(keyStr == str) { idx = i; break }
  }
  return idx;
}
function setTimeAccount()
{
  keyTime = new Date().getTime();
  return false;
}



/////////////////////////
var allOptsOC = new Array(), lastKey;

function populateOC()
{
  for(var i = 0; i < document.form1.oc.options.length; i++)
  {
    allOptsOC[i] = document.form1.oc.options[i].value.toLowerCase();
  }
}

function setSelectionOC()
{
  // only deals with IE as firefox behaves well anyway, other browser can be added
  if(is_ie)
  {
    var currentKey = unescape('%' + window.event.keyCode.toString(16)).toLowerCase();
    var currentSIdx = document.form1.oc.selectedIndex;
    var newTime = new Date().getTime();
    if(keyTime != null && newTime - keyTime < 400) // if two keys were pressed between 0.3 seconds (can be customized), do type-ahead
    {
      keyStr += currentKey;
      idx = findIdxOC();
    }
    else // unfortunately we seem to have to handle default browser behavior too
    {
      keyStr = currentKey;
      var selectFirst = true;
      if(keyStr == lastKey)
      {
        idx = currentSIdx + 1;
        if(idx < allOptsOC.length && allOptsOC[idx].charAt(0) == lastKey)
          selectFirst = false;
      }
      if(selectFirst) idx = findIdxOC();
      lastKey = currentKey;
    }
    if(idx >= 0)
    {
      document.form1.oc.options[currentSIdx].selected = false;
      document.form1.oc.options[idx].selected = true;
    }
  }
}
function findIdxOC()
{
  // full scan to find the smallest idx that match string keyStr (case-insensitive)
  // if you get rid of all the toLowerCase() calls in this script, it'd become case
  // sensitive match
  var idx = -1, len = keyStr.length;
  for(var i = 0; i < allOptsOC.length; i++)
  {
    var str = allOptsOC[i].substring(0, len);
    if(keyStr == str) { idx = i; break }
  }
  return idx;
}
function setTimeOC()
{
  keyTime = new Date().getTime();
  return false;
}


/////////////////////////////
var allOptsProject = new Array(), lastKey;

function populateProjectTitle()
{
  for(var i = 0; i < document.form1.project_title.options.length; i++)
  {
    allOptsProject[i] = document.form1.project_title.options[i].value.toLowerCase();
  }
}

function setSelectionProject()
{
  // only deals with IE as firefox behaves well anyway, other browser can be added
  if(is_ie)
  {
    var currentKey = unescape('%' + window.event.keyCode.toString(16)).toLowerCase();
    var idx, currentSIdx = document.form1.project_title.selectedIndex;
    var newTime = new Date().getTime();
    if(keyTime != null && newTime - keyTime < 400) // if two keys were pressed between 0.3 seconds (can be customized), do type-ahead
    {
      keyStr += currentKey;
      idx = findIdxProject();
	
    }
    else // unfortunately we seem to have to handle default browser behavior too
    {
      keyStr = currentKey;
      var selectFirst = true;
      if(keyStr == lastKey)
      {
        idx = currentSIdx + 1;
        if(idx < allOptsProject.length && allOptsProject[idx].charAt(0) == lastKey)
          selectFirst = false;
      }
      if(selectFirst) idx = findIdxProject();
      lastKey = currentKey;
    }
    if(idx >= 0)
    {
      document.form1.project_title.options[currentSIdx].selected = false;
      document.form1.project_title.options[idx].selected = true;
    }
  }
}
function findIdxProject()
{
  // full scan to find the smallest idx that match string keyStr (case-insensitive)
  // if you get rid of all the toLowerCase() calls in this script, it'd become case
  // sensitive match
  var idx = -1, len = keyStr.length;
  for(var i = 0; i < allOptsProject.length; i++)
  {
    var str = allOptsProject[i].substring(0, len);
    if(keyStr == str) { idx = i; break }
  }
  return idx;
}
function setTimeProject()
{
  keyTime = new Date().getTime();
  return false;
}

/////////////////////////
var allOptsCPO = new Array(), lastKey;

function populateCPO()
{
  for(var i = 0; i < document.form1.cpo.options.length; i++)
  {
    allOptsCPO[i] = document.form1.cpo.options[i].value.toLowerCase();
//	alert (allOptsRequestor[i]);
	
  }
}

function setSelectionCPO()
{
  // only deals with IE as firefox behaves well anyway, other browser can be added
  if(is_ie)
  {
    var currentKey = unescape('%' + window.event.keyCode.toString(16)).toLowerCase();
    var currentSIdx = document.form1.cpo.selectedIndex;
//alert (currentSIdx + "1");
    var newTime = new Date().getTime();
    if(keyTime != null && newTime - keyTime < 400) // if two keys were pressed between 0.3 seconds (can be customized), do type-ahead
    {

      keyStr += currentKey;
      idx = findIdxCPO();
    }
    else // unfortunately we seem to have to handle default browser behavior too
    {

      keyStr = currentKey;
      var selectFirst = true;
      if(keyStr == lastKey)
      {

        idx = currentSIdx + 1;
        if(idx < allOptsCPO.length && allOptsCPO[idx].charAt(0) == lastKey)

          selectFirst = false;
      }
      if(selectFirst) idx = findIdxCPO();
      lastKey = currentKey;
    }
    if(idx >= 0)
    {

//			alert (currentSIdx);
      document.form1.cpo.options[currentSIdx].selected = false;
      document.form1.cpo.options[idx].selected = true;
    }
  }
}
function findIdxCPO()
{
  // full scan to find the smallest idx that match string keyStr (case-insensitive)
  // if you get rid of all the toLowerCase() calls in this script, it'd become case
  // sensitive match
  var idx = -1, len = keyStr.length;
  for(var i = 0; i < allOptsCPO.length; i++)
  {
    var str = allOptsCPO[i].substring(0, len);
    if(keyStr == str) { idx = i; break }
  }
  return idx;
}
function setTimeCPO()
{
  keyTime = new Date().getTime();
  return false;
}

/////////////////////////


/////////////////////////
var allOptsCE = new Array(), lastKey;

function populateCE()
{
  for(var i = 0; i < document.form1.ce.options.length; i++)
  {
    allOptsCE[i] = document.form1.ce.options[i].value.toLowerCase();
  }
}

function setSelectionCE()
{
  // only deals with IE as firefox behaves well anyway, other browser can be added
  if(is_ie)
  {
    var currentKey = unescape('%' + window.event.keyCode.toString(16)).toLowerCase();
    var currentSIdx = document.form1.ce.selectedIndex;
    var newTime = new Date().getTime();
    if(keyTime != null && newTime - keyTime < 400) // if two keys were pressed between 0.3 seconds (can be customized), do type-ahead
    {
      keyStr += currentKey;
      idx = findIdxCE();
    }
    else // unfortunately we seem to have to handle default browser behavior too
    {
      keyStr = currentKey;
      var selectFirst = true;
      if(keyStr == lastKey)
      {
        idx = currentSIdx + 1;
        if(idx < allOptsCE.length && allOptsCE[idx].charAt(0) == lastKey)
          selectFirst = false;
      }
      if(selectFirst) idx = findIdxCE();
      lastKey = currentKey;
    }
    if(idx >= 0)
    {
      document.form1.ce.options[currentSIdx].selected = false;
      document.form1.ce.options[idx].selected = true;
    }
  }
}
function findIdxCE()
{
  // full scan to find the smallest idx that match string keyStr (case-insensitive)
  // if you get rid of all the toLowerCase() calls in this script, it'd become case
  // sensitive match
  var idx = -1, len = keyStr.length;
  for(var i = 0; i < allOptsCE.length; i++)
  {
    var str = allOptsCE[i].substring(0, len);
    if(keyStr == str) { idx = i; break }
  }
  return idx;
}
function setTimeCE()
{
  keyTime = new Date().getTime();
  return false;
}