var DEBUG         = false;
var ADDMSG_OPTION = true;
var MAX_TYPES     = 0;

var CURRENT_TYPE;

var RS_METHODS       = new Array(MAX_TYPES);
var RS_METHODS_MENU  = new Array(MAX_TYPES);
var FLD_FILTERS      = new Array(MAX_TYPES);
var FLD_LISTS        = new Array(MAX_TYPES);
var ARY_VALUES_CACHE = new Array(MAX_TYPES);
var STR_VALUES_CACHE = new Array(MAX_TYPES);
var DEF_VALUES_CACHE = new Array(MAX_TYPES);
var FLAGS_LOADED     = new Array(MAX_TYPES);

var MSG_LOADING     = "Loading..."
var MSG_NOT_LOADED  = ""
var MSG_LOADED      = "Choose one..."
var ERR_LOADING     = "Error loading!"

var NO_VALUE = "";
var COL_SEP  = "~";
var ROW_SEP  = "|";

var RE_AT_ANY         = 0;
var RE_AT_VALUE_ANY   = 1;
var RE_AT_VALUE_BEGIN = 2;
var RE_AT_VALUE_END   = 3;
var RE_AT_LABEL_ANY   = 4;
var RE_AT_LABEL_BEGIN = 5;
var RE_AT_LABEL_END   = 6;

var SORT_BY_VALUE = 0;
var SORT_BY_LABEL = 1;

var OPT_FIRST    = 0;
var OPT_SELECTED = 1;
var OPT_ALL      = 2;

var SEL_BY_ID    = 0;
var SEL_BY_VALUE = 1; 
var SEL_BY_LABEL = 2;

var INITIAL_FILTER;

//------------------------------------------------------------ OVERRIDABLE METHODS
var getInitialFilter = function() {return null;}
var getFilter        = function(theValue) {return theValue;}
var onListsLoaded    = function() {return;}
var getErrMsg        = function(theType) {return ERR_LOADING;}
var getEmptyMsg      = function(theType) {return MSG_NOT_LOADED;}
var getLoadingMsg    = function(theType) {return MSG_LOADING;}
var getLoadedMsg     = function(theType) {return MSG_LOADED;}

//------------------------------------------------------------ CREATE
function createList(strTokens, rsId) {
  //if (DEBUG) alert("Callback[" + rsId + "]: " + strTokens);
  //-- CLEANUP
  destroyLists(CURRENT_TYPE);
  destroyCache(CURRENT_TYPE);
  destroyFilters(CURRENT_TYPE);
  //-- SELF LIST
  var filled = fillListFromRs(FLD_LISTS[CURRENT_TYPE], CURRENT_TYPE, strTokens, getLoadedMsg(CURRENT_TYPE));
  if (DEBUG) alert("Filled: " + filled);
  if (!filled) {   
    fillListFromErr(FLD_LISTS[CURRENT_TYPE], getErrMsg(CURRENT_TYPE));
    return onListsLoaded();
  }
  //-- FOCUS
  FLD_LISTS[CURRENT_TYPE].disabled = false;
  
  //-- NEXT LISTS
  /*
  if (2 == FLD_LISTS[CURRENT_TYPE].options.length) {
    if (DEBUG) alert("2 elements, one more jsrs!");
    FLD_LISTS[CURRENT_TYPE].options[1].selected = true;
    DEF_VALUES_CACHE[CURRENT_TYPE] = FLD_LISTS[CURRENT_TYPE].options[1].value;
    createFilter(CURRENT_TYPE, getFilter(FLD_LISTS[CURRENT_TYPE].options[1].text));  
    loadNextOne(++CURRENT_TYPE);
    return;
  }*/
  var opt = selectOptionFromType(FLD_LISTS[CURRENT_TYPE], CURRENT_TYPE, DEF_VALUES_CACHE[CURRENT_TYPE]);
  if (0 < opt) {
    if (DEBUG) alert("An element selected, one more jsrs!");
    DEF_VALUES_CACHE[CURRENT_TYPE] = FLD_LISTS[CURRENT_TYPE].options[opt].value;
    createFilter(CURRENT_TYPE, getFilter(FLD_LISTS[CURRENT_TYPE].options[opt].text)); 
    loadNextOne(++CURRENT_TYPE);
    return;
  } 
  if (DEBUG) alert("Cannot select nothing, ending!");
  INITIAL_FILTER = getInitialFilter();
  createFilter(CURRENT_TYPE, INITIAL_FILTER);
  FLD_LISTS[CURRENT_TYPE].options[0].selected = true;
  return onListsLoaded();
}

function createFilter(theType, theValue) {
  if (null != FLD_FILTERS[theType]) {
    FLD_FILTERS[theType].disabled = false;
    FLD_FILTERS[theType].focus();
    FLD_FILTERS[theType].select(); 
    if (2 == arguments.length && !isEmptyStr(theValue)) {
      FLD_FILTERS[theType].value = theValue;
    }
  }
}

//------------------------------------------------------------ RELOAD (CREATE FROM CACHE)
function reloadList(theType) {
  //-- CLEANUP
  destroyLists(theType);
  destroyCache(theType + 1);
  destroyFilters(theType + 1);
  //-- SELF LIST
  if (!fillListFromType(FLD_LISTS[theType], theType, getLoadedMsg(theType))) {
    fillListFromErr(FLD_LISTS[theType], getErrMsg(theType));
    return;
  }
  FLD_LISTS[theType].disabled = false;
  FLD_LISTS[theType].options[0].selected = true;
  createFilter(theType);  
}

//------------------------------------------------------------ FILL
function fillListFromRs(objList, type, tokens, msgOption) {
  //if (DEBUG) alert("[fillListFromRs] Begin.");
  //-- CACHE
  STR_VALUES_CACHE[type] = tokens;
  ARY_VALUES_CACHE[type] = getAryFromTokens(tokens);
  return fillListFromType(objList, type, msgOption);
}

function fillListFromType(objList, type, msgOption) {
  //if (DEBUG) alert("[fillTypedList] Begin.");
  var results = false;
  if (isAry(ARY_VALUES_CACHE[type])) {
    //if (DEBUG) alert("[fillTypedList] Array #" + type + " ok.");
    results = fillListFromAry(objList, ARY_VALUES_CACHE[type], msgOption);
  } else if (null != STR_VALUES_CACHE[type] && STR_VALUES_CACHE[type].length > 1) {
    //if (DEBUG) alert("[fillTypedList] String #" + type + " ok.");
    results = fillListFromStr(objList, STR_VALUES_CACHE[type], msgOption);
  }
  FLAGS_LOADED[type] = results;
  return results;
}

function fillListFromStr(objList, strOptionPairs, msgOption) {
  //if (DEBUG) alert("[fillListFromStr] Begin.");
  if (isEmptyStr(strOptionPairs)) {
    return false;
  }
  var aryOptionPairs = getAryFromTokens(strOptionPairs);
  return fillListFromAry(objList, aryOptionPairs, msgOption);
}

function fillListFromAry(objList, aryOptionPairs, msgOption, msgValue) {
  //if (DEBUG) alert("[fillListFromAry] Begin.");
  if (isEmptyAry(aryOptionPairs)) {
    return false;
  }
  if (arguments.length < 3 || null == msgOption) {
    //if (DEBUG) alert("[fillListFromAry] No msg specified.");
    msgOption = MSG_LOADED;
  }
  if (arguments.length < 4 || null == msgValue) {
    msgValue = NO_VALUE;
  }  
  if (ADDMSG_OPTION) {
    //if (DEBUG) alert("[fillListFromAry] Msgs enabled.");  
    objList.options[0] = new Option(msgOption, msgValue);
  }
  for(var i = 0; i < aryOptionPairs.length; i++) {
    if (aryOptionPairs[i].indexOf(COL_SEP) != -1) {
      var aryOptions = aryOptionPairs[i].split(COL_SEP);
      if (ADDMSG_OPTION) {
        //if (DEBUG) alert("[fillListFromAry] Populating element [" + (i + 1) + "::" + aryOptions[0] + "::" + aryOptions[1] + "].");  
        objList.options[i + 1] = new Option(aryOptions[1], aryOptions[0]);
      } else {
        //if (DEBUG) alert("[fillListFromAry] Populating element [" + (i) + "::" + aryOptions[0] + "::" + aryOptions[1] + "].");  
        objList.options[i] = new Option(aryOptions[1], aryOptions[0]);
      }
    }  
  }
  return true;
}

function fillListFromErr(objList, msgOption, msgValue) {
  //if (DEBUG) alert("[fillListFromErr] Begin.");
  if (arguments.length < 2 || null == msgOption) {
    //if (DEBUG) alert("[fillListFromErr] No msg specified.");
    msgOption = ERR_LOADING;
  }
  if (arguments.length < 3 || null == msgValue) {
    msgValue = NO_VALUE;
  }   
  if (null != objList.options) {
    objList.length = 0;
  }
  objList.options[0] = new Option(msgOption, msgValue);
}

function fillListFromMsg(objList, msgOption, msgValue) {
  //if (DEBUG) alert("[fillListFromMsg] Begin.");
  if (arguments.length < 2 || null == msgOption) {
    //if (DEBUG) alert("[fillListFromMsg] No msg specified.");
    msgOption = MSG_LOADING;
  }
  if (arguments.length < 3 || null == msgValue) {
    msgValue = NO_VALUE;
  }   
  if (null != objList.options) {
    objList.length = 0;
  }
  objList.options[0] = new Option(msgOption, msgValue);
}

//------------------------------------------------------------ EMPTY
function emptyList(objList, msgOption, msgValue) {
  if(objList!=undefined)
  {
  	objList.disabled = true;
  	objList.options.length = 0;
  	if (arguments.length < 2 || null == msgOption) {
    	//if (DEBUG) alert("[emptyTypedList] No msg specified.");
    	msgOption = MSG_NOT_LOADED;
  	}
  	if (arguments.length < 3 || null == msgValue) {
    	msgValue = NO_VALUE;
  	}   
  	if (ADDMSG_OPTION) {
    	//if (DEBUG) alert("[emptyTypedList] Msgs enabled.");  
    	objList.options[0] = new Option(msgOption, msgValue);
  	}
  }
}

function emptyListFromType(objList, type, msgOption, msgValue) {
  //if (DEBUG) alert("[emptyTypedList] Begin.");
  emptyList(objList);
  FLAGS_LOADED[type] = false;
}

//------------------------------------------------------------ DESTROY
function destroyFilters(theType) {
  for (var i = theType; i < MAX_TYPES; i++) {
    if (null != FLD_FILTERS[i]) {
      //if (DEBUG) alert("Destroying Filter [" + i + "]: " + FLD_FILTERS[i].name);
      FLD_FILTERS[i].value = getEmptyMsg(i);
      FLD_FILTERS[i].disabled = true;
    }
  }
}

function destroyLists(theType) {
  for(var i = theType; i < MAX_TYPES; i++) {
    //if (DEBUG) alert("Destroying List [" + i + "]: " + FLD_LISTS[i].name);
    emptyListFromType(FLD_LISTS[i], i, getEmptyMsg(i));   
    if(FLD_LISTS[i]!=undefined)
    	FLD_LISTS[i].disabled = true;
  }  
}

function destroyCache(type) {
  for(var i = type; i < MAX_TYPES; i++) {
    //if (DEBUG) alert("Destroying Cache " + i);
    ARY_VALUES_CACHE[i] = null;
    STR_VALUES_CACHE[i] = "";
  }  
}

function destroyDefaultValues(type) {
  for(var i = type; i < MAX_TYPES; i++) {
    //if (DEBUG) alert("Destroying Default Value " + i);
    DEF_VALUES_CACHE[i] = NO_VALUE;
  }  
}

function destroyFlags(type) {
  for(var i = type; i < MAX_TYPES; i++) {
    //if (DEBUG) alert("Destroying IsLoaded Flag " + i);
    FLAGS_LOADED[i] = false;
  }  
}

//------------------------------------------------------------ HELPERS
function selectOptionFromType(objList, type, optionVal) {
  //if (DEBUG) alert("[selectTypedOption] Begin.");
  if (arguments.length < 3 || isEmptyStr(optionVal)) {
    optionVal = NO_VALUE;
  }
  for (var i = 0; i < objList.options.length; i++ ) {
    if (objList.options[i].value == optionVal ){
      objList.selectedIndex = i;
      objList.options[i].selected = true;
      //-- DEF_VALUES_CACHE[type] = optionVal;
      return i;
    }  
  }
  return -1;
}

function getRegexp(reType, strToMatch) {
  //if (DEBUG) alert("[getRegexp] Begin.");
  if (arguments.length < 2 || isEmptyStr(strToMatch)) {
   //-- MATCH NON EMPTY PAIRS /^(VALUE)COL_SEP(LABEL)$/
    return new RegExp("^(.+?)" + COL_SEP + "(.+)$", "i");
  }
  switch (reType) {
    case RE_AT_ANY :
      return new RegExp("^(.*?)" + strToMatch + "(.*)$", "i");
    case RE_AT_VALUE_ANY :
      return new RegExp("^(.*?)" + strToMatch + "(.*?)" + COL_SEP + "(.*)$", "i");
    case RE_AT_VALUE_BEGIN :
      return new RegExp("^" + strToMatch + "(.*?)" + COL_SEP + "(.*)$", "i");
    case RE_AT_VALUE_END :
      return new RegExp("^(.*?)" + strToMatch + COL_SEP + "(.*)$", "i");
    case RE_AT_LABEL_ANY :
      return new RegExp("^(.*?)" + COL_SEP + "(.*?)" + strToMatch + "(.*)$", "i");
    case RE_AT_LABEL_BEGIN :
      return new RegExp("^(.*?)" + COL_SEP + strToMatch + "(.*)$", "i");
    case RE_AT_LABEL_END :
      return new RegExp("^(.*?)" + COL_SEP + "(.*?)" + strToMatch + "$", "i");
    default :
      return new RegExp("^(.+?)" + COL_SEP + "(.+)$", "i");
  }
}  

function getAryFromTokens(theString, fillAlways) {
	if (arguments.length < 2 || null == fillAlways) {
		fillAlways = false;
	}
  if (isEmptyStr(theString)) {
  	return new Array();
  } 
  if (theString.indexOf(COL_SEP) == -1) {
  	var tmp = new Array();
  	if (fillAlways) {
	  	tmp[0] = theString;
	  }
  	return tmp;
  }
  return theString.split(ROW_SEP);
}

//------------------------------------------------------------ LISTS
function getItemizedStr(ary) {
  var results = "";
  if (isAry(ary)) {
    var j = 1;
    for(var i = 0; i < ary.length; i++) {
      if (!isEmptyStr(ary[i])) {
        results += '&nbsp;&nbsp;&nbsp;' + (j++) + '.- ' + ary[i] + '<br>';
      }
    }
  } else if (!isEmptyStr(ary)) {
    results += '&nbsp;&nbsp;&nbsp;1.- ' + ary[i] + '<br>';
  }
  return results;
}

function getItemizedTxt(ary) {
  var results = "";
  if (isAry(ary)) {
    var j = 1;
    for(var i = 0; i < ary.length; i++) {
      if (!isEmptyStr(ary[i])) {
        results += '\t' + (j++) + '.- ' + ary[i] + '\n';
      }
    }
  } else if (!isEmptyStr(ary)) {
    results += '\t1.- ' + ary[i] + '\n';
  }
  return results;
}

function backupList(objLst) {
  bck = new Array();
  for (var i = 0; i < objLst.length; i++) {
    bck[bck.length] = new Option(objLst.options[i].text, objLst.options[i].value);
  }
  return bck;
}

function restoreList(objLst, bck) {
  objLst.options.length = 0;
  for (var i = 0; i < bck.length; i++) {
    objLst.options[objLst.length] = new Option(bck[i].text, bck[i].value);
  }
}

//------------------------------------------------------------ MULTIPLE LISTS
function copyOptions(lstFrom, lstTo, maxOpt, errMsg) {
  var aryFrom = getOptions(lstFrom, true);
  if (!isEmptyAry(aryFrom)) {
    var aryTo = createOptions(lstFrom, lstTo, aryFrom, maxOpt);
    if (errMsg && (isEmptyAry(aryTo) || aryTo.length < aryFrom.length)) {
     alert(errMsg);
    }
    if (isAry(aryTo) && aryTo.length > 0) {
      sortOptions(lstTo);
    }
  }
}

function moveOptions(lstFrom, lstTo, maxOpt, errMsg) {
  var aryFrom = getOptions(lstFrom, true);
  if (!isEmptyAry(aryFrom)) {
    var aryTo = createOptions(lstFrom, lstTo, aryFrom, maxOpt);
    if (errMsg && (isEmptyAry(aryTo) || aryTo.length < aryFrom.length)) {
     alert(errMsg);
    }
    if (isAry(aryTo) && aryTo.length > 0) {
      removeOptions(lstFrom, aryTo);
      sortOptions(lstTo);
    }
  }
}

function copyAllOptions(lstFrom, lstTo, maxOpt, errMsg) {
  var aryFrom = getOptions(lstFrom, false);
  if (!isEmptyAry(aryFrom)) {
    var aryTo = createOptions(lstFrom, lstTo, aryFrom, maxOpt);
    if (errMsg && (isEmptyAry(aryTo) || aryTo.length < aryFrom.length)) {
     alert(errMsg);
    }
    if (isAry(aryTo) && aryTo.length > 0) {
      sortOptions(lstTo);
    }
  }
}

function moveAllOptions(lstFrom, lstTo, maxOpt, errMsg) {
  var aryFrom = getOptions(lstFrom, false);
  if (!isEmptyAry(aryFrom)) {
    var aryTo = createOptions(lstFrom, lstTo, aryFrom, maxOpt);
    if (errMsg && (isEmptyAry(aryTo) || aryTo.length < aryFrom.length)) {
     alert(errMsg);
    }
    if (isAry(aryTo) && aryTo.length > 0) {
      removeOptions(lstFrom, aryTo);
      sortOptions(lstTo);
    }
  }
}

function createOptions(lstFrom, lstTo, aryValues, maxOpt, repeatOpt, errMsg) {
  //-- Create options from an array of option values, return the array of options created
  if (isEmptyAry(aryValues)) {
    return null;
  }
  if (arguments.length < 4 || null == maxOpt) {
    maxOpt = -1;
  }
  if (0 <= maxOpt && existOption(lstTo, NO_VALUE)) {
    ++maxOpt;
  }
  if (0 <= maxOpt && maxOpt <= lstTo.options.length) {
    return null;
  }
  if (arguments.length < 5 || null == repeatOpt) {
    repeatOpt = false;
  }
  var optCreated = new Array();
  var j = -1;
  var k = 0;
  for (var i = 0; i < aryValues.length; i++) {
    //-- Skip dummy option
    if (NO_VALUE != aryValues[i]) {
      //-- Skip, if necessary, repeated options
      if (repeatOpt || !existOption(lstTo, aryValues[i])) {
        //-- Obtain the index of the option
        j = selectOption(lstFrom, aryValues[i]);
        if (j >= 0) {
          lstTo.options[lstTo.options.length] = new Option(lstFrom.options[j].text, lstFrom.options[j].value);
          optCreated[k++] = aryValues[i];
          if (0 <= maxOpt && maxOpt <= lstTo.options.length) {
            return optCreated;
          }
        }
      }
    }
  }
  return optCreated;
}

function removeOptions(lst, aryValues) {
  //-- Remove options from an array of option values
  if (isEmptyAry(aryValues)) {
    return null;
  }
  var optRemoved = new Array();
  var j = -1;
  var k = 0;
  for (var i = 0; i < aryValues.length; i++) {
    //-- Skip dummy option
    if (NO_VALUE != aryValues[i]) {
      //-- Obtain the index of the option
      j = selectOption(lst, aryValues[i]);
      if (j >= 0) {
        lst.options[j] = null;
        optRemoved[k++] = aryValues[i];
      }
    }
  }
  return optRemoved;
}

function removeAllOptions(lst) {
  if (0 >= lst.options.length) {
    return null;
  }
  for (var i = lst.options.length - 1; i >= 0; i--) {
    lst.options[i] = null;
  }
  lst.options.length = 0;
}

function sortOptions(lst, byWhich) {
  //-- By label or by value(defaults)
  if (lst.options.length <= 1) {
    return;
  }
  if (arguments.length < 2 || null == byWhich) {
    byWhich = SORT_BY_VALUE;
  }
  var lstTemp = new Array();
  var temp = new Object();
  for (var i = 0; i < lst.options.length; i++) {
    lstTemp[i] = lst.options[i];
  }
  for(var x = 0; x < lstTemp.length - 1; x++) {
    for(var y = (x+1); y < lstTemp.length; y++) {
      if (SORT_BY_LABEL == byWhich) {
        if (lstTemp[x].text > lstTemp[y].text) {
          temp = lstTemp[x].text;
          lstTemp[x].text = lstTemp[y].text;
          lstTemp[y].text = temp;
          temp = lstTemp[x].value;
          lstTemp[x].value = lstTemp[y].value;
          lstTemp[y].value = temp;
        }
      } else {
        if (lstTemp[x].value > lstTemp[y].value) {
          temp = lstTemp[x].text;
          lstTemp[x].text = lstTemp[y].text;
          lstTemp[y].text = temp;
          temp = lstTemp[x].value;
          lstTemp[x].value = lstTemp[y].value;
          lstTemp[y].value = temp;
        }
      }
    }
  }
  for(var i = 0; i < lst.options.length; i++) {
    lst.options[i].value = lstTemp[i].value;
    lst.options[i].text  = lstTemp[i].text;
  }
}

function getCurrentOption(lstId) {
  var objLst = document.forms[0].elements[lstId];
  if (objLst) {
    return objLst.value;
  }
  return null;
}

function getOptions(lst, selected) {
  //-- Get an array of values for options selected
  if (0 >= lst.options.length) {
    return null;
  }
  var aryValues = new Array();
  var j = 0;
  for (var i = 0; i < lst.options.length; i++) {
    if (NO_VALUE != lst.options[i].value && (!selected || lst.options[i].selected)) {
      aryValues[j++] = lst.options[i].value;
    }
  }
  return aryValues;
}

function selectFirstOption(objLst, objFlt, value, addMsg) {
  //-- Select first option available, returns its index
  var minLength = addMsg ? 1 : 0;
  var objLstOpts   = objLst.options;
  var objLstLength = objLstOpts.length;

  objLstOpts[0].selected = true;
  if (objLstLength <= minLength) {
    if (objFlt) {
      objFlt.focus();
      objFlt.select();
    }
    return (minLength - 1);
  } 
  if (objLstLength == minLength + 1) {
    objLstOpts[minLength].selected = true;
    return minLength;
  }
  return selectOption(objLst, value);
}

function selectOption(objLst, value) {
  //-- Select an option value, returns its index
  var objLstOpts   = objLst.options;
  var objLstLength = objLstOpts.length;
    
  if (isEmptyStr(value)) {
    return -1;
  }
  for (var i = 0; i < objLstLength; i++) {
    if (objLstOpts[i].value == value) {
      objLstOpts[i].selected = true;
      return i;
    }
  }
  return -1;
}

function selectOptions(lst, aryValues) {
  //-- Select an array of option values, return an array of indexes
  if (isEmptyAry(aryValues)) {
    return null;
  }
  var aryIndexes = new Array();
  var j = -1;
  var k = 0;
  for (var i = 0; i < aryValues.length; i++) {
    j = selectOption(lst, aryValues[i]);
    if (j >= 0) {
      aryIndexes[k++] = j;
    }
  }
  return aryIndexes;
}

function selectAllOptions(lst) {
  for (var i = 0; i < lst.options.length; i++) {
    lst.options[i].selected = true;
  }
}

function unSelectAllOptions(lst) {
  for (var i = 0; i < lst.options.length; i++) {
    lst.options[i].selected = false;
  }
}

function existOption(lst, value) {
  //-- Looks for an option value
  if (isEmptyStr(value)) {
    return false;
  }
  for (var i = 0; i < lst.options.length; i++) {
    if (lst.options[i].value == value) {
      return true;
    }
  }
  return false;
}

function tokenizeList(lst) {
  //-- Tokenize all options
  var tokens = "";
  for (var i = 0; i < lst.options.length; i++) {
    if (NO_VALUE != lst.options[i].value) {
      tokens += (lst.options[i].value + COL_SEP + lst.options[i].text + ROW_SEP);
    }
  }
  if (tokens.length > ROW_SEP.length) {
    return tokens.substr(0, (tokens.length - ROW_SEP.length));
  }
  return COL_SEP; 
}

function tokenizeOptions(lst) {
  //-- Tokenize all options
  var tokens = "";
  for (var i = 0; i < lst.options.length; i++) {
    if (NO_VALUE != lst.options[i].value) {
      tokens += (lst.options[i].value + COL_SEP);
    }
  }
  if (tokens.length > COL_SEP.length) {
    return tokens.substr(0, (tokens.length - COL_SEP.length));
  }
  return COL_SEP; 
}

function unTokenizeOptions(tokens) {
  //-- Untokenize an retun an array of option values
  if (tokens.length <= 0) {
    return null;
  }
  return tokens.split(COL_SEP);
}

function dumpList(lst) {
  document.write("<br />");
  for (var i = 0; i < lst.length; i++) {
    document.write(lst.options[i].value + "&nbsp;-&nbsp;" + lst.options[i].text + "\",<br />");
  }
  alert(i);
}

function traceIt(str) {
  var obj = getObj('debug');
  str = obj ? obj.value + str : str;
  obj.value = str + '\n';
}

function untraceIt() {
  var obj = getObj('debug');
  obj && (obj.value = '');
}

//------------------------------------------------------------ KEY EVENTS (TODO)
var netscape = "";
var ver = navigator.appVersion; len = ver.length;
for(iln = 0; iln < len; iln++) {
  if (ver.charAt(iln) == "(") {
    break;
  }
}
netscape = (ver.charAt(iln + 1).toUpperCase() != "C");
function keyDown(DnEvents) {
  k = (netscape) ? DnEvents.which : window.event.keyCode;
  if (k == 13) {
//    return false;
  }
}
document.onkeydown = keyDown;
if (netscape) {
  document.captureEvents(Event.KEYDOWN | Event.KEYUP);
}