//-------------------------
// KeyboardLib.js
//-------------------------

// key modifier "constants"
var kmNone = 0;
var kmShift = 1; 
var kmCtrl = 2; 
var kmAlt = 4;		
//------------------------

var keyF7 = 118;
var keyF8 = 119;
var keyF9 = 120;
var keyF1 = 112; 
var keyF12 = 123;


function GoFormHome(AForm)
{
  var i;
  
  for (i=0;i<AForm.length;i++)
    try
    {
      window.scrollTo(0, 0);
      AForm[i].focus();
      return;
    }
    catch(err)
    {
      continue;
    }
}


function GoFormEnd(AForm)
{
  var i;
  
  for (i=AForm.length - 1;i>-1;i--)
    try
    {
      window.scrollBy(0, 999999999);
      AForm[i].focus();
      return;
    }
    catch(err)
    {
      continue;
    }
}


function GlobalKeyPress(AForm, AKeyEvent)
{

	if (! AKeyEvent)
		AKeyEvent = window.event;

  if (AKeyEvent.ctrlKey)
  {
    if (AForm && AKeyEvent.keyCode == 35)
      GoFormEnd(AForm)
    else
    if (AForm && AKeyEvent.keyCode == 36)
      GoFormHome(AForm);
  }
		
	if (IsProduction())
		return;
		
	if (AKeyEvent.keyCode == keyF8 && AKeyEvent.shiftKey && AKeyEvent.ctrlKey)
	  WhizTextInputByName()
	else
	if (event.keyCode == keyF8 && AKeyEvent.ctrlKey)
    WhizInputForm(AForm)
  else
	if (AKeyEvent.keyCode == keyF8 && AKeyEvent.shiftKey)
    WhizTextInput()
  else
	if (AKeyEvent.keyCode == keyF8)
		WhizInput();
			
}			//GlobalKeyPress()
	

function GetModifierKeys(AKeyEvent)
{
	var i;
	
	i = 0;
	
	if (AKeyEvent.shiftKey)
		i = kmShift;
		
	if (AKeyEvent.ctrlKey)
		i = i + kmCtrl;
		
	if (AKeyEvent.altKey)
		i = i + kmAlt;
		
	return i;
	

}				//GetModifierKeys()


function IsDigitKey(AKeyCode, AIsShiftKeyDown)
{
	return (! AIsShiftKeyDown) && ((AKeyCode >= 48 && AKeyCode <= 57) || 
				(AKeyCode >= 96 && AKeyCode <= 105))
				
}				//IsDigitKey()


function IsHyphenKey(AKeyCode, AIsShiftKeyDown)
{
	var HyphenKey = 189; HyphenKey2 = 109;
	
	return (! AIsShiftKeyDown) && (AKeyCode == HyphenKey || AKeyCode == HyphenKey2);
	
}			//IsHyphenKey()



function IsDeletionKey(AKeyCode, AModifierKeys)
{
	var BackSpaceKey = 8; DeleteKey = 46;
	
	return ((AKeyCode == BackSpaceKey && (AModifierKeys != kmAlt)) || (AKeyCode == DeleteKey))
		
}				//IsDeletionKey()


function IsEditorKey(AKeyCode, AModifierKeys)
//Determines whether a keystroke should be valid for any editor control
{
	var EnterKey = 13;
	var vKey = 86; zKey = 90;
	
	if (IsCopyKey(AKeyCode, AModifierKeys) || (AKeyCode == vKey || AKeyCode == zKey) && AModifierKeys == kmCtrl)
		return true
	else
		return IsDeletionKey(AKeyCode, AModifierKeys) || IsNavigationKey(AKeyCode) || 
		          IsInsertKey(AKeyCode, AModifierKeys) || (AKeyCode == EnterKey);
		
}				//IsEditorKey()


function IsUndoKey(AKeyCode, AModifierKeys)
{
	var zKey = 90;
	var BackSpaceKey = 8;
	
	if (AModifierKeys == kmCtrl && AKeyCode == zKey)
	  return true
	else
	if (AModifierKeys == kmAlt && AKeyCode == BackSpaceKey)
	  return true
	else
	  return false;

}     //IsUndoKey()


function IsNavigationKey(AKeyCode)
{
	var TabKey = 9;
	var HomeKey = 36; EndKey = 35;
	var LeftKey = 37; RightKey = 39;
	var UpKey = 38; DownKey = 40;
	
	return AKeyCode == TabKey || AKeyCode == HomeKey || AKeyCode == EndKey || 
	        AKeyCode == LeftKey || AKeyCode == RightKey ||
	          AKeyCode == UpKey || AKeyCode == DownKey;

}       //IsNavigationKey()


function IsCopyKey(AKeyCode, AModifiersKeys)
{
  var cKey = 67;
  
  return (AKeyCode == cKey) && (AModifiersKeys == kmCtrl)

}       //IsCopyKey()


function IsInsertKey(AKeyCode, AModifiersKeys)
{
	var InsertKey = 45;
  
  return (AKeyCode == InsertKey) && (AModifiersKeys == kmNone)

}       //IsInsertKey()


function IsShiftKey(AKeyCode)
{

  return AKeyCode == 16;
  
}       //IsShiftKey()


function IsCapsLockKey(AKeyCode)
{
  
  return AKeyCode == 20;

}     //IsCapsLockKey()


function IsEscapeKey(AKeyCode)
{

  return AKeyCode == 27;

}       //IsEscapeKey()


function IsEditKey(AKeyCode, AModifierKeys)
//Determines whether a key would likely cause a change to data being edited.
{

  if (IsKeyFunctionKey(AKeyCode))
    return false
  else
  if (IsInsertKey(AKeyCode, AModifierKeys))
    return false
  else
  if (IsCopyKey(AKeyCode, AModifierKeys))
    return false
  else
  if (IsNavigationKey(AKeyCode))
    return false
  else
  if (IsKeyModifierKey(AKeyCode))
    return false
  else
  if (IsCapsLockKey(AKeyCode))
    return false
  else
  if (IsEscapeKey(AKeyCode))
    return false
  else
  if (IsUndoKey(AKeyCode, AModifierKeys))
    return false
  else
    return true;
		
}				//IsEditKey()



function IsStrictEditorKey(AKeyCode, AModifierKeys)
//Same as IsEditorKey, except Ctrl-V and Insert are not allowed. This prevents using
// the keyboard to paste into the control.
{
	var BackSpaceKey = 8; DeleteKey = 46;
	var TabKey = 9; EnterKey = 13;
	var HomeKey = 36; EndKey = 35;
	var LeftKey = 37; RightKey = 39;
	var cKey = 67; zKey = 90;
	
	//KeyEventsToStatusBar(event);
	
	if ((AKeyCode == cKey || AKeyCode == zKey) && AModifierKeys == kmCtrl)
		return true
	else
		return ((AKeyCode == BackSpaceKey) || (AKeyCode == DeleteKey) ||
			(AKeyCode == TabKey) || (AKeyCode == EnterKey) ||
			(AKeyCode == HomeKey) || (AKeyCode == EndKey) || 
			(AKeyCode == LeftKey) || (AKeyCode == RightKey));
		
}				//IsStrictEditorKey()


function IsDateDelimiterKey(AKeyCode, AIsShiftKeyDown)
{
	var SpaceKey = 32; PeriodKey = 190; PeriodKey2 = 110; 
	var ForwardSlashKey = 191; ForwardSlashKey2 = 111;

	return ((AKeyCode == SpaceKey || 
				(AKeyCode == PeriodKey || AKeyCode == PeriodKey2 ||
					AKeyCode == ForwardSlashKey || AKeyCode == ForwardSlashKey2 ||
						IsHyphenKey(AKeyCode, AIsShiftKeyDown)) &&
							! AIsShiftKeyDown));

}					//IsDateDelimiterKey()


function IsTimeDelimiterKey(AKeyCode, AIsShiftKeyDown)
{
	var SpaceKey = 32; PeriodKey = 190; PeriodKey2 = 110; 
	var ColonKey = 186;
	
	return (AKeyCode == SpaceKey || 
				AKeyCode == PeriodKey || AKeyCode == PeriodKey2 ||
					(AKeyCode == ColonKey && AIsShiftKeyDown));

}					//IsTimeDelimiterKey()


function DateKeysEvent(AInputObject, AAutoFill)
{
	var SpaceKey = 32;
	var sDelimiters = '. /-';
	var iModifierKeys = GetModifierKeys(event);
	var bEventKeyIsDateDelimiter;
	
	function GetCurrentMonth()
	{
		var Result;
		
		Result = (new Date().getMonth() + 1).toString();
		if (Result.length == 1)
			return '0' + Result
		else
			return Result;
	
	}			//GetCurrentMonth()
	
	function GetCurrentDay()
	{
		var Result;
		
		Result = new Date().getDate().toString();
		if (Result.length == 1)
			return '0' + Result
		else
			return Result;
			
	}			//GetCurrentDay()


	function GetCurrentYear()
	{
		return new Date().getFullYear().toString();
	}	
		
	function GetDelimiterCount(AInputString)
	{
		var iInput, iDelimiters, iResult;
		
		iResult = 0;
		
		iInput=0;
		while (AInputString.charAt(iInput) == ' ')	//skip over beginning spaces
			iInput++;
		
		for (iInput=iInput; iInput < AInputString.length; iInput++)
			for (iDelimiters=0; iDelimiters < sDelimiters.length; iDelimiters++)
				if (AInputString.charAt(iInput) == sDelimiters.charAt(iDelimiters))
					iResult++;
					
		return iResult;
	
	}			//GetDelimiterCount()
	
	
	function IsDelimiterChar(AChar)
	{
		var i;
		
		for (i=0; i < sDelimiters.length; i++)
			if (AChar == sDelimiters.charAt(i))
				return true;
				
		return false;
	
	}			//IsDelimiterChar()
	
	function GetLastChar()
	{
	  return AInputObject.value.charAt(AInputObject.value.length - 1);
	}
	
	function GetChar(AIndex)
	{
	  return AInputObject.value.charAt(AIndex);
	}
		
	function DoIncrementalAutofill()
	{
		var iDelimiterCount = GetDelimiterCount(AInputObject.value);

	  if (LeftTrim(AInputObject.value) == '')
	  {
	    AInputObject.value = GetCurrentMonth() + '/';
	    return;
	  }
		else
		if (GetLastChar() == '0')
		{
		  if (AInputObject.value.length == 1)
		    return ''
		  else
		  if (IsDelimiterChar(AInputObject.value.charAt(AInputObject.value.length - 2)))
		    return ''
		  else
		  if (AInputObject.value.charAt(AInputObject.value.length - 2) == '0')
		    return '';
		}

		with (AInputObject.value)
		  if (IsDelimiterChar(charAt(length - 1)))
			{
				if (iDelimiterCount == 1)
					AInputObject.value = AInputObject.value + GetCurrentDay() + '/';
				else
				if (iDelimiterCount == 2)
					AInputObject.value = AInputObject.value + GetCurrentYear();
				else
					return;
			}	          //if...
			else
			if (iDelimiterCount == 0 && AInputObject.value.length == 4)
			  AInputObject.value += GetCurrentYear();
			else
			if (iDelimiterCount == 0 && AInputObject.value.length < 3)
			  AInputObject.value = AInputObject.value + '/'
			else
			if (iDelimiterCount == 1 && GetLastPiece(AInputObject.value, '/').length < 3)
			  AInputObject.value = AInputObject.value + '/';
					
	}       //DoIncrementalAutofill()
	
	bEventKeyIsDateDelimiter = IsDateDelimiterKey(event.keyCode, event.shiftKey);
	if (IsDigitKey(event.keyCode, event.shiftKey) || 
	      IsEditorKey(event.keyCode, iModifierKeys) || bEventKeyIsDateDelimiter)
	{
	  if (event.keyCode == SpaceKey)
	    event.returnValue = false;

	  if (bEventKeyIsDateDelimiter && event.keyCode != 32)
	    if (AInputObject.value == '' || (IsCaretAtEnd(AInputObject) && 
	          IsDelimiterChar(AInputObject.value.charAt(AInputObject.value.length - 1))))
	    {
	      event.returnValue = false;
	      return;
	    }

		if (event.keyCode == SpaceKey && AAutoFill) 
		{
		  if (kmCtrl == iModifierKeys || ((kmCtrl + kmShift) == iModifierKeys))
		  {
		    if (TrimSpaces(AInputObject.value) == '')
		      AInputObject.value = GetDateString(Today())
		    else
		    if (IsValidDateString(AInputObject.value))
		    {
		      if (kmCtrl == iModifierKeys)
		        AInputObject.value = IncDateString(ExpandDateString(AInputObject.value), 1)
		      else
		        AInputObject.value = DecDateString(ExpandDateString(AInputObject.value), 1);
		    }
		    else
		      DoIncrementalAutofill();
		  }
		  else
		    DoIncrementalAutofill();
		}
		else
			return;
	}
	else
		event.returnValue = false;
		
}				//DateKeysEvent()


function TimeKeysEvent(AInputObject, AControlColor)
{
  var SpaceKey = 32;
  var keyA = 65;    //Am/Pm keys
  var keyP = 80;
  var keyM = 77;
  var iDigitCount;
  var iValLength;
  
  if (event.keyCode == SpaceKey)
  {
    with (event.srcElement)
    {
      iValLength = value.length;
      
      if ((iValLength == 1 || iValLength == 2) && (Pos(':', value) == -1 && Pos('.', value) == -1))
      {
        value = value + ':';
        event.returnValue = false;
        return;
      }
      else
      if (iValLength > 1 && iValLength < 5 && 
            (Pos(value.charAt(value.length - 1), ':.') > -1) || Pos(value.charAt(value.length - 2), ':.') > -1)
      {
        value = value + '0';
        event.returnValue = false;
        return;
      }
      else
      {
        iDigitCount = GetDigitCount(value);
        
        if ((iValLength == 5 || iValLength == 4) && (iDigitCount == 3 || iDigitCount == 4) && 
            (GetCharCount(value, ':') == 1 || GetCharCount(value,'.') == 1))
          value = value + GetInferredTimeSuffix(value);
      }
      
    }     //with...
    
    event.returnValue = false;
    return;
    
  }       //if...
    
	//if (IsDigitKey(event.keyCode, event.shiftKey) || 
			//IsEditorKey(event.keyCode, GetModifierKeys(event)) || 
				//IsTimeDelimiterKey(event.keyCode, event.shiftKey) ||
				  //event.keyCode == keyA || event.keyCode == keyP ||
				    //event.keyCode == keyM || event.shiftKey)
		//ProcessBadKeyEvent(false, AControlColor)
	//else
	//{
		//event.returnValue = false;
		//ProcessBadKeyEvent(true, AControlColor);
  //}
  
  if (! (IsDigitKey(event.keyCode, event.shiftKey) || 
		IsEditorKey(event.keyCode, GetModifierKeys(event)) || 
			IsTimeDelimiterKey(event.keyCode, event.shiftKey) ||
				 event.keyCode == keyA || event.keyCode == keyP ||
				   event.keyCode == keyM || event.shiftKey))
	{
     event.returnValue = false;
     return;
  }
		
}				//TimeKeysEvent()


function ProcessBadKeyEvent(AIsBadKey, ANormalControlColor)
{
  var sControlColor = ANormalControlColor;
  
	if ((sControlColor == '') || (sControlColor == undefined))
	  sControlColor = 'white';
	  
	with (event)
	{
	  if (srcElement.style.backgroundColor == '')
	    srcElement.style.backgroundColor = 'white';
	    
	  if (AIsBadKey && (srcElement.style.backgroundColor == sControlColor))
	    ReverseField(srcElement)
	  else
	  if (! AIsBadKey && ! (srcElement.style.backgroundColor == sControlColor))
	    ReverseField(srcElement);
  }

}       //ProcessBadKey


function PagerKeysEvent(AInputObject, AAutoPrefix)
{
	PhoneKeysEvent(AInputObject, AAutoPrefix);
	
}		//PagerKeysEvent()


function ZipKeysEvent(AInputObject)
{
	var SpaceKey = 32;
	var Hyphen = 189;

  if (SpaceKey == event.keyCode)
  {
		event.returnValue = false;
	  if (AInputObject.value == '')
	    AInputObject.value = '741'
	  else
	  if (AInputObject.value == '741')
	    AInputObject.value = '740'
	  else
	  if (AInputObject.value == '740')
	    AInputObject.value = ''
	  else
    if (AInputObject.value.length == 5)
      AInputObject.value += '-';
	}
	else
	if (Hyphen == event.keyCode)
	{
	  if (GetCharCount(AInputObject.value, '-') > 0)
	    event.returnValue = false
	  else
	    return;
	}
	else
	if (IsDigitKey(event.keyCode, IsShiftKey(event.shiftKey)))
	  return
	else
	if (IsEditorKey(event.keyCode, GetModifierKeys(event)))
	  return
	else
	  event.returnValue = false;
	  
}		//ZipKeysEvent()


function SsnKeyUpEvent(AInputObject)
{
  var bIsSpaceKey = (event.keyCode == 32 && GetModifierKeys(event) == kmNone);


  function ValueToDigits()
  {

    with (AInputObject)
      value = GetDigitString(value);
  
  }         //ValueToDigits()


  function IsBadFormat()
  {
    var i;
    
    if (IsDigitString(AInputObject.value))
      return false;
          
    with (AInputObject)
      for (i = 0; i < value.length; i++)
        if (i == 3 || i == 6)
        {
          if (value.charAt(i) != '-')
            return true
        }
        else
        if (! IsDigit(value.charAt(i)))
          return true;
          
    return false;
  
  }       //IsBadFormat()
  
  
  function ReformatDigitsOnly()
  {
  
    with (AInputObject)
      if (value.length > 4 && value.length < 10)
        value = value.substr(0, 3) + '-' + value.substr(3, 2) + '-' + value.substr(5)
      else
      if (value.length == 4)
        value = value.substr(0, 3) + '-' + value.substr(3)
      else
      if (value.length == 3)
        value += '-';
  
  }           //ReformatDigitsOnly()
  

	function TrySymbolInsertion()
	{
	  var bIsCaretAtEnd = IsCaretAtEnd(AInputObject);
	
	  if (! bIsCaretAtEnd && (! bIsSpaceKey))
	      return;
	      
	  if (IsBadFormat())
	  {
	    ValueToDigits();
	    ReformatDigitsOnly();
	  }
	  else
    with (AInputObject)
      if (value > '' && IsDigit(value.charAt(value.length - 1)))
        if (value.length == 3)
          value += '-'
        else
        if (value.length == 6)
          value += '-'
        else
        if (IsDigitString(value))
          ReformatDigitsOnly();
	
	}         //TrySymbolInsertion()

	if (IsDigitKey(event.keyCode, event.shiftKey) || bIsSpaceKey)
	  TrySymbolInsertion()
	else
	if (IsEditorKey(event.keyCode, GetModifierKeys(event)))
	  return;

}           //SsnKeyUpEvent()


function SsnKeyDownEvent(AInputObject)
{
	var SpaceKey = 32;
	
	
	function TrySymbolInsertion()
	{

    event.returnValue = false;
    
    with (AInputObject)
      if (value > '' && IsDigit(value.charAt(value.length - 1)))
        if (value.length == 3)
          value += '-'
        else
        if (value.length == 6)
          value += '-'
        else
        if (IsDigitString(value))
          if (value.length > 4 && value.length < 10)
            value = value.substr(0, 3) + '-' + value.substr(3, 2) + '-' + value.substr(5)
          else
          if (value.length == 4)
            value = value.substr(0, 3) + '-' + value.substr(3);
	
	}         //TrySymbolInsertion()
	
		
	if (IsDigitKey(event.keyCode, event.shiftKey))
	  return;
	else
	if (IsEditorKey(event.keyCode, GetModifierKeys(event)))
	  return
	else
	if (event.keyCode == SpaceKey && GetModifierKeys(event) == kmNone)
	  TrySymbolInsertion()
	else
	if (IsHyphenKey(event.keyCode, event.shiftKey))
	  TrySymbolInsertion()
	else
	  event.returnValue = false;
	
}         //SsnKeyDownEvent()


function SsnKeysEvent(AInputObject)
//call this on KeyDown - deprecated in favor of combination of SsnKeyDownEvent and SsnKeyUpEvent
{

  SsnKeyDownEvent(AInputObject);
  	
}			//SsnKeysEvent()
	

function PhoneKeysEvent(AInputObject, AAutoAreaCode, AAutoPrefix)
{
	var SpaceKey = 32; PeriodKey = 190; PeriodKey2 = 110;
	
	function IsPhoneDelimiterKey(AKeyCode, AIsShiftKeyDown)
	{
		return ((AKeyCode == SpaceKey || 
					AKeyCode == PeriodKey || AKeyCode == PeriodKey2 || 
						(IsHyphenKey(AKeyCode, AIsShiftKeyDown)) &&
							(! AIsShiftKeyDown)));
	
	}				//IsPhoneDelimiterKey()


  if (event.keyCode == SpaceKey)
  {
    if (LeftTrim(AInputObject.value) == '')
    {	
  
		  event.returnValue = false;
		
		  if (AAutoAreaCode && AAutoPrefix)
			  AInputObject.value = '918-494-';
		  else
		  if (AAutoPrefix)
			  AInputObject.value = '494-';
		  else
		  if (AAutoAreaCode)
			  AInputObject.value = '918-';
  			
	  }
  }

  if (IsDigitKey(event.keyCode, event.shiftKey) || 
	  IsEditorKey(event.keyCode, GetModifierKeys(event)) || 
		  IsPhoneDelimiterKey(event.keyCode, event.shiftKey))
    return
  else
	  event.returnValue = false;

}			//PhoneKeysEvent()


function PhoneKeysEventNew(AInputObject, AAutoAreaCode, AAutoPrefix)
{
	var SpaceKey = 32; PeriodKey = 190; PeriodKey2 = 110;
	
	function IsPhoneDelimiterKey(AKeyCode, AIsShiftKeyDown)
	{
		return ((AKeyCode == SpaceKey || 
					AKeyCode == PeriodKey || AKeyCode == PeriodKey2 || 
						(IsHyphenKey(AKeyCode, AIsShiftKeyDown)) &&
							(! AIsShiftKeyDown)));
	
	}				//IsPhoneDelimiterKey()


  if (event.keyCode == SpaceKey)
  {
    if (IsCaretAtEnd(AInputObject))
    {
      event.returnValue = false;
      if (TrimSpaces(AInputObject.value) == '')
      {	
		    if (AAutoAreaCode)
		      AInputObject.value = '918-'
		    else
		    if (AAutoPrefix)
		      AInputObject.value = '494-';
		    return;
		  }
		  else
		  if (AAutoPrefix && AInputObject.value.match(new RegExp('^918-$')))
		  {
		    AInputObject.value += '494-';
		    return;
		  }
		  else
		  if (AInputObject.value.match(new RegExp('[0-9]$')))
		  {
		    if (AInputObject.value.match(new RegExp('^[0-9]$')))
		      AInputObject.value += '-'
		    else
		    if (AInputObject.value.match(new RegExp('^[0-9][0-9][0-9]$')))
		      AInputObject.value += '-'
		    else
		    if (AInputObject.value.match(new RegExp('^[0-9][0-9][0-9]-[0-9][0-9][0-9]$')))
		      AInputObject.value += '-';
		    return;
		  }
    }
  }

  if (IsDigitKey(event.keyCode, event.shiftKey) || 
	  IsEditorKey(event.keyCode, GetModifierKeys(event)) || 
		  IsPhoneDelimiterKey(event.keyCode, event.shiftKey))
    return
  else
	  event.returnValue = false;

}			//PhoneKeysEventNew()


function ExtensionKeysEvent(AInputObject, AAutoPrefix)
{
	var SpaceKey = 32;
	
	if (event.keyCode == SpaceKey && AAutoPrefix && LeftTrim(AInputObject.value) == '')
	{
		AInputObject.value = '1-';
		event.returnValue = false;
	}
	else
		PhoneKeysEvent(AInputObject, false);

}			//ExtensionKeysEvent()


function DigitKeysEvent()
{
	if (IsDigitKey(event.keyCode, event.shiftKey) || 
			IsEditorKey(event.keyCode, GetModifierKeys(event)))
		return
	else
		event.returnValue = false;
		
}				//DigitKeysEvent()


function IsKeyModifierKey(AKeyCode)
{
  var ShiftKey = 16;
  var CtrlKey = 17;
  var AltKey = 18;
  
  return AKeyCode >= 16 && AKeyCode <= 18;
  
}       //IsKeyModifierKey()


function IsKeyFunctionKey(AKeyCode)
{
  
  return AKeyCode >= keyF1 && AKeyCode <= keyF12;

}       //IsKeyFunctionKey()


function NumericKeysEvent(AControlColor)
{
  var PeriodKey = 190; PeriodKey2 = 110; SpaceKey = 32;
  var bBadKey;

  if (! IsEditKey(event.keyCode, GetModifierKeys(event)))
    return;

	if (IsDigitKey(event.keyCode, event.shiftKey) || 
			IsEditorKey(event.keyCode, GetModifierKeys(event)) ||
			  ((event.keyCode == PeriodKey || event.keyCode== PeriodKey2) &&
			      (! event.shiftKey)))
		bBadKey = false;
	else
	if (event.keyCode == SpaceKey)
	{
	  event.returnValue = false;
	  with (event.srcElement)
	    if (Pos('.', value) > -1)
	      bBadKey = true
	    else
	    {
	      value = value + '.';
	      bBadKey = false;
	    }
	}
	else
	{
	  bBadKey = true;
		event.returnValue = false;
	}
	
	if ((AControlColor == '') || (AControlColor == undefined))
	  AControlColor = 'white';
	  
	with (event)
	{
	
	  if (srcElement.style.backgroundColor == '')
	    srcElement.style.backgroundColor = 'white';
	    
	  if (bBadKey && (srcElement.style.backgroundColor == AControlColor))
	    ReverseField(srcElement)
	  else
	  if (! bBadKey && ! (srcElement.style.backgroundColor == AControlColor))
	    ReverseField(srcElement);
  }
		
}       //NumericKeysEvent()


function IntegerKeysEvent(AControlColor)
{
  var bBadKey;

  if (! IsEditKey(event.keyCode, GetModifierKeys(event)))
    return;

	if (IsDigitKey(event.keyCode, event.shiftKey) || 
			IsEditorKey(event.keyCode, GetModifierKeys(event)))
		bBadKey = false;
	else
	{
	  bBadKey = true;
		event.returnValue = false;
	}
	
	if ((AControlColor == '') || (AControlColor == undefined))
	  AControlColor = 'white';
	  
	with (event)
	{
	
	  if (srcElement.style.backgroundColor == '')
	    srcElement.style.backgroundColor = 'white';
	    
	  if (bBadKey && (srcElement.style.backgroundColor == AControlColor))
	    ReverseField(srcElement)
	  else
	  if (! bBadKey && ! (srcElement.style.backgroundColor == AControlColor))
	    ReverseField(srcElement);
  }
		
}       //IntegerKeysEvent()


function CostCenterKeysEvent()
{
	var FKey = 70; TKey = 84; NKey = 78;		//upper & lower case letters
		
	with (event)
		if (IsEditorKey(event.keyCode, GetModifierKeys(event)) || IsDigitKey(keyCode, shiftKey) || 
				IsHyphenKey(keyCode, shiftKey) || keyCode == FKey || keyCode == TKey ||
					keyCode == NKey)
			return
		else
			event.returnValue = false;

}			//CostCenterKeysEvent()


function CityKeysEvent(AInputObject)
{
	var SpaceKey = 32;
	
	if (LeftTrim(AInputObject.value) == '')
		if (SpaceKey == event.keyCode)
		{
			AInputObject.value = 'Tulsa';
			event.returnValue = false;
		}

}			//CityKeysEvent()


function StateKeysEvent(AInputObject)
{
	var SpaceKey = 32;

	if (LeftTrim(AInputObject.value) == '')
		if (SpaceKey == event.keyCode)
		{
			AInputObject.value = 'OK';
			event.returnValue = false;
		}
		
}			//StateKeysEvent()


function LimitInputEvent(ATextInput, ACharacterLimit)
{
  //Works best when attached to both OnKeyUp and OnChange

	with (ATextInput)
    if (value.length > ACharacterLimit)
		  value = value.substr(0, ACharacterLimit);
		
}		//LimitInputEvent()


function LimitInputEventx(ATextInput, ACharacterLimit, ACounterObject, AOptionalWarningColor, AOptionalNormalColor, AOptionalPercentRemaining)
{
  //Optional colors are for the ACounterObject object's text color
  var APercentUsedWarning = .90;
  
  if (AOptionalPercentRemaining)
    APercentUsedWarning = (100 - AOptionalPercentRemaining) / 100;
      
  if (! AOptionalWarningColor)
    AOptionalWarningColor = 'red';
  
  LimitInputEvent(ATextInput, ACharacterLimit);
      
  ACounterObject.innerText = ACharacterLimit - ATextInput.value.length;
  
  with (ATextInput)
    if (value.length >= (ACharacterLimit * APercentUsedWarning))
      ACounterObject.style.color = AOptionalWarningColor
    else
      if (AOptionalNormalColor)
        ACounterObject.style.color = AOptionalNormalColor
      else
        ACounterObject.style.color = 'black';

}         //LimitInputEventx()