var NS ;
NS = (typeof(document.all) == 'undefined') ;

var chConvArray = null ;
/*if (navigator.appVersion.indexOf("MSIE") != -1) {*/

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
function ConvFromHTMLToXML(HTMLStr)
{
  if (chConvArray == null)
    InitConvArray() ;

  return (Conv(HTMLStr, 1)) ;
}
function ConvFromXMLToHTML(XMLStr)
{
  if (chConvArray == null)
    InitConvArray() ;

  return (Conv(XMLStr, 2)) ;
}

// direction: 1 = from HTML to XML
function Conv(convStr, direction)
{
  var retStr ;
  var convFrom ;
  var convTo ;
  var g ;
  var thisPos ;

  retStr = new String(convStr) ;
  for (g = 0 ; g < chConvArray.length ; g++)
  {
    if (direction == 1)
    {
      convFrom  = chConvArray[g].GetHTML() ;
      convTo    = chConvArray[g].GetToXML() ;
    }
    else
    {
      convFrom  = chConvArray[g].GetXML() ;
      convTo    = chConvArray[g].GetHTML() ;
    }

    if ((thisPos = retStr.indexOf(convFrom)) > 0)
      for ( ; thisPos > -1 ; )
      {
        retStr = retStr.substr(0, thisPos) + convTo +
                 retStr.substr(thisPos + convFrom.length) ;
        thisPos = retStr.indexOf(convFrom, thisPos + 1) ;
      }
  }

  return (retStr) ;
}
function InitConvArray()
{
  chConvArray = new Array() ;
/*
  chConvArray[0] = new ConvTag('&', '!26') ;
  chConvArray[1] = new ConvTag('\"', '!quot;') ;
  chConvArray[2] = new ConvTag('\\\"', '&quot;') ;
  chConvArray[3] = new ConvTag('<', '!3C') ;
  chConvArray[4] = new ConvTag('>', '!3E') ;
*/
  chConvArray[0] = new ConvTag('&', '&amp;', '!26') ;
  chConvArray[1] = new ConvTag('\\\"', '&quot;', '!quot;') ;
  chConvArray[2] = new ConvTag('\"', '&quot;', '!quot;') ;
  chConvArray[3] = new ConvTag('<', '&lt;', '!3C') ;
  chConvArray[4] = new ConvTag('>', '&gt;', '!3E') ;
}
// ----------------------------------------------------------------------------
function ConvTag(convFrom, convTo, convToXML)
{
  if (typeof(ConvTagDefined) == 'undefined')
    protoConvTag() ;

  this.Init(convFrom, convTo, convToXML) ;
}

function protoConvTag()
{
  ConvTagDefined = true ;
  ConvTag.prototype.Init      = _CTInit ;
  ConvTag.prototype.GetHTML   = _CTGetFrom ;
  ConvTag.prototype.GetXML    = _CTGetTo ;
  ConvTag.prototype.GetToXML  = _CTGetToXML ;
}
function _CTInit(convFrom, convTo, convToXML)
{
  this.convFrom   = convFrom ;
  this.convTo     = convTo ;
  this.convToXML  = convToXML ;
}
function  _CTGetFrom()
{
  return (this.convFrom) ;
}
function _CTGetTo()
{
  return (this.convTo) ;
}
function _CTGetToXML()
{
  return (this.convToXML) ;
}

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
function CheckFrames(ServletName)
{
  CheckCommFrame('servercomm', '', ServletName)
}
function CheckSecureFrames(HTMLSSLServerName, ServletName)
{
  CheckCommFrame('sslservercomm', HTMLSSLServerName, ServletName)
}
/*
function CheckFrames(ServletName)
{
  var ServerCommFrame ;
  ServerCommFrame = FindFrame(null, 'servercomm') ;
  if (ServerCommFrame == null)
    alert('Error: A frame named servercomm is missing!') ;
//    self.location.href = ServletName +
//      'Call?htmltemplate=./misc/setupframe.htm&templparmLoadPage=./login/login.htm' ;
  else if (typeof(ServerCommFrame.CallServer) == 'undefined')
    ServerCommFrame.location.href = ServletName + 'Call?htmltemplate=./misc/servercomm.htm' ;
}
*/
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
function CheckCommFrame(FrameName, HTMLServerName, ServletName)
{
  var ServerCommFrame ;
  ServerCommFrame = FindFrame(parent, FrameName) ;
  if (ServerCommFrame == null)
    alert('Error: A frame named ' + FrameName + ' is missing!') ;
  else if (typeof(ServerCommFrame.CallServer) == 'undefined')
    LoadCommPage(ServerCommFrame, HTMLServerName, ServletName) ;

//    ServerCommFrame.location.href = HTMLServerName + ServletName + 'Call?htmltemplate=./misc/servercomm.htm' ;
}
function LoadCommPage(Frame, HTMLServerName, ServletName)
{
  Frame.location.href = HTMLServerName + ServletName + 'Call?htmltemplate=./misc/servercomm.htm' ;
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
function FindFrame(startFrame, frameName)
{
  var stFrame ;
  var g ;
  var retFrame ;

  if (startFrame == null)
    stFrame = top ;
  else
    stFrame = startFrame ;

    //alert(stFrame);
  if (typeof(stFrame.name) == 'unknown')
    return (null) ; // Cannot look at this frame (e.g. because its another protocol (https/http) than the caller).

  if (stFrame.name == frameName)
    return (stFrame) ;

  for (g = 0 ; g < stFrame.frames.length ; g++)
  {
    retFrame = FindFrame(stFrame.frames[g], frameName) ;
    if (retFrame != null)
      return (retFrame) ;
  }

  return (null) ;
}

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
function GetFullFrameName(startFrame, findFrame, level)
{
  var stFrame ;
  var thisFrameName ;
  var g ;
  var retFrameName = '' ;

  if (startFrame == null)
  {
    stFrame = top.frames ;
    thisFrameName = '' ;
  }
  else
  {
    stFrame = startFrame ;
    if (typeof(level) != 'undefined')
      thisFrameName = startFrame.name ;
    else
      thisFrameName = '' ;
  }

  if (stFrame == findFrame)
    return (thisFrameName) ;

  for (g = 0 ; g < stFrame.length ; g++)
  {
    retFrameName = GetFullFrameName(stFrame.frames[g], findFrame, 1) ;
    if (retFrameName != '')
      return (thisFrameName + '.' + retFrameName) ;
  }

  return ('') ;
}

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
function getParam(name, docURL, defValue)
{
  var myParm = name.toUpperCase();
  var search ;

  if (typeof(docURL) == 'undefined' || docURL == '')
    search = document.location.search;
  else
    search = docURL ;

  search = search.substr(1); // remove '?'
  var params = search.split('&');
  for (var i=0; i<params.length; i++)
  {
    var pair = params[i].split('=');
    if (pair[0].toUpperCase() == myParm)
    {
      var retValue ;
      retValue = '' ;
      for (var g=1; g < pair.length; g++)
        retValue += unescape(pair[g]) + '=' ;
      // remove last '='
      retValue = retValue.substring(0, retValue.length-1) ;
      return (retValue) ;
    }
  }

  if (typeof(defValue) == 'undefined')
    return ('') ;
  else
    return (defValue) ;
}

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
var resumingFocus = null ;

function ValidateForm(formName)
{
  var g ;
  var h ;
  var fieldName ;
  var fieldOnBlur ;
  var fieldOnBlurStr ;
  var formValidated = null ;
  var thisField ;

  for (h = 0 ; h < document.forms.length ; h++)
    if (document.forms[h].name == formName || document.forms.length == 1)
    {
      formValidated = document.forms[h] ;

      for (g = 0 ; g < document.forms[h].length ; g++)
      {
        thisField = document.forms[h].elements[g] ;
        fieldName = new String(thisField.name) ;

        fieldOnBlur = thisField.onblur ;
        if (fieldOnBlur == null)
          fieldOnBlur = thisField.onchange ;

        if (fieldOnBlur != null)
        {
          var indx ;
          var fullFieldName = 'document.' + document.forms[h].name + '.' + fieldName ;
          var findFieldName = 'document.getElementsByName(\''+ fieldName + '\')[0]' ;


          fieldOnBlurStr = new String(fieldOnBlur) ;
          indx = fieldOnBlurStr.indexOf('this') ;
          for (; indx > -1 ; )
          {
            fieldOnBlurStr = fieldOnBlurStr.substring(0, indx) + findFieldName + fieldOnBlurStr.substring(indx + 4) ;
            indx = fieldOnBlurStr.indexOf('this') ;
          }

          // Change name of function if NS (from onchange()/onblur() to anonymous())
          if (NS)
          {
            indx = fieldOnBlurStr.indexOf('{') ;
            fieldOnBlurStr = 'function anonymous() ' + fieldOnBlurStr.substr(indx) ;

          }

          var valRes ;
          fieldOnBlurStr += '\nanonymous() ;' ;
          valRes = eval(fieldOnBlurStr) ;
          if (valRes != true && typeof(valRes) != 'undefined')
            return (false) ;
        }
      }
    }


  if (formValidated != null)
    ;
  else
    return (false) ; // alert('No form validated') ;

  return (true) ;
}


// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
function CheckNotEmpty(fld, minSize, maxSize, mayBeEmpty)
{
  var localMinSize ;
  var localMaxSize ;
  var localMayBeEmpty ;
  var fldLen ;

  // If this validation function is called while another has signalled that it's resuming focus
  // to itself, then ignore the validation!
  if (resumingFocus != null)
    if (resumingFocus != fld)
      return (true) ;
    else
      resumingFocus = null ;

  if (typeof(minSize) == 'undefined')
    localMinSize = -1 ;
  else
    localMinSize = minSize ;
  if (typeof(maxSize) == 'undefined')
    localMaxSize = -1 ;
  else
    localMaxSize = maxSize ;
  if (typeof(mayBeEmpty) == 'undefined')
    localMayBeEmpty = false ;
  else
    localMayBeEmpty = mayBeEmpty ;


  fldLen = trim(fld.value).length ;
  if (fldLen == 0 && localMayBeEmpty == true)
    return (true) ;
  else if (localMinSize > -1 && fldLen < localMinSize)
  {
    alert('Field must contain at least ' + localMinSize + ' characters') ;
    resumingFocus = fld ;
    fld.focus() ;
    return (false) ;
  }
  else if (localMaxSize > -1 && fldLen > localMaxSize)
  {
    alert('Field must contain no more than ' + localMaxSize + ' characters') ;
    resumingFocus = fld ;
    fld.focus() ;
    return (false) ;
  }
  else if (fldLen == 0)
  {
    alert('Field must be entered') ;
    resumingFocus = fld ;
    fld.focus() ;

    return (false) ;
  }
  else
    return (true) ; // Something has been entered
}
function trim(value)
{
  var retValue = '' ;
  var g ;
  var h ;

  // Skip preceding spaces
  for (g = 0 ; g < value.length ; g++)
    if (value.charAt(g) != ' ')
      break ;

  if (g < value.length)
  {
    // Find the last non-space.
    for (h = value.length - 1 ; h > g ; h--)
      if (value.charAt(h) !=  ' ')
        break ;

    if (g <= h)
      // Copy up till the last non-space
      retValue = value.substring(g, h + 1) ;
  }

  return (retValue) ;
}

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
function AllEmpty(errText)
{
  var g ;
  var h ;
  var thisField ;
  var emptyCnt = 0 ;
  var fieldsFound = 0 ;
  var firstFld = null ;

  if (arguments.length > 1)
    for (g = 1 ; g < arguments.length ; g++)
    {
      thisField = document.all(arguments[g])
      if (thisField != null)
      {
        ++fieldsFound ;
        if (fieldsFound == 1)
          firstFld = thisField ;

        if (trim(thisField.value) == '')
          ++emptyCnt ;
      }
    }
  else
    // No arguments (but the errortext) so run thru all (non-hidden) fields
    for (h = 0 ; h < document.forms.length ; h++)
      for (g = 0 ; g < document.forms[h].length ; g++)
      {
        thisField = document.forms[h].item(g) ;
        if (thisField != null)
          if (thisField.type == 'text')
          {
            ++fieldsFound ;
            if (fieldsFound == 1)
              firstFld = thisField ;

            if (trim(thisField.value) == '')
              ++emptyCnt ;
          }
      }


  if (fieldsFound > 0 && emptyCnt == fieldsFound)
  {
    alert(errText) ;
    firstFld.focus() ;
    return (false) ;
  }
  else
    return (true) ;
}

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
function ValNumeric(format, fld, thousandSep, digitStr, defaultZero,
                    fieldDispLen, digitDispLen, defNumMask)
{
  var localDigitStr ;
  var localDefaultZero ;
  var localThousandSep ;
  var localFieldDispLen ;
  var localDigitDispLen ;

  // If this validation function is called while another has signalled that it's resuming focus
  // to itself, then ignore the validation!
  if (resumingFocus != null)
    if (resumingFocus != fld)
      return (true) ;
    else
      resumingFocus = null ;

  if (typeof(digitStr) == 'undefined')
    localDigitStr = '.' ;
  else
    localDigitStr = digitStr ;

  if (typeof(defaultZero) == 'undefined')
    localDefaultZero = '' ;
  else
    localDefaultZero = defaultZero ;

  if (typeof(thousandSep) == 'undefined')
    localThousandSep = '' ;
  else
    localThousandSep = thousandSep ;

  if (typeof(fieldDispLen) == 'undefined')
    localFieldDispLen = 0 ;
  else
    localFieldDispLen = fieldDispLen ;

  if (typeof(digitDispLen) == 'undefined')
    localDigitDispLen = 0 ;
  else
    localDigitDispLen = digitDispLen ;

  if (fld.value != '')
  {
    fld.value = ValNumStr(format, fld.value, localThousandSep, localDigitStr,
                          localDefaultZero, localFieldDispLen, localDigitDispLen, defNumMask) ;
    if (fld.value == '')
    {
      resumingFocus = fld ;
      fld.focus() ;
      return (false) ;
    }
    else
      return (true) ;
  }
  else
  {
    fld.value = localDefaultZero ;
    return (true) ;
  }
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
function ValNumStr(format, fldValue, thousandSep, digitStr, defaultZero,
                   fieldDispLen, digitDispLen, defNumMask)
{
  var numType ;
  var numStartRange = 'x' ;
  var numEndRange = 'x' ;
  var g, h ;
  var retStr ;
  var padCh = ' ' ;


  if (thousandSep != '')
    fldValue = RemoveThousand(fldValue, thousandSep) ;
  g = format.indexOf('(') ;
  if (g > -1)
  {
    var arguments ;
    var argArray ;
    numType = format.substring(0, g) ;

    h = format.indexOf(')', g + 1) ;
    arguments = format.substring(g + 1, h) ;
    argArray = ArgSplit(arguments, ',') ;
    if (argArray != null && argArray.length > 0)
    {
      var regExp = /!/g ;

      numStartRange = parseFloat(argArray[0]) ;
      if (argArray.length > 1 && argArray[1] != '')
        numEndRange = parseFloat(argArray[1]) ;
      if (argArray.length > 2 && argArray[2] != '')
        thousandSep = argArray[2].replace(regExp, '') ;
      if (argArray.length > 3 && argArray[3] != '')
        digitStr = argArray[3].replace(regExp, '') ;
      if (argArray.length > 4 && argArray[4] != '')
        defaultZero = argArray[4].replace(regExp, '') ;
      if (argArray.length > 5 && argArray[5] != '')
        fieldDispLen = argArray[5].replace(regExp, '') ;
      if (argArray.length > 6 && argArray[6] != '')
        digitDispLen = argArray[6].replace(regExp, '') ;
      if (argArray.length > 7 && argArray[7] != '')
        padCh = argArray[7].replace(regExp, '') ;
      if (argArray.length > 8 && argArray[8] != '')
        defNumMask = argArray[8].replace(regExp, '') ;

/*
 alert(':'+numStartRange+':') ;
 alert(':'+numEndRange+':') ;
 alert(':'+thousandSep+':') ;
 alert(':'+digitStr+':') ;
 alert(':'+defaultZero+':') ;
 alert(':'+fieldDispLen+':') ;
 alert(':'+digitDispLen+':') ;
 alert(':'+padCh+':') ;
*/
    }

/*
    numType = format.substring(0, g) ;
    h = format.indexOf(',', g + 1) ;
    if (h > -1)
    {
      numStartRange = parseFloat(format.substring(g + 1, h)) ;
      g = format.indexOf(')', h + 1) ;
      if (g > -1)
        numEndRange   = parseFloat(format.substring(h + 1, g)) ;
      else
        numEndRange   = parseFloat(format.substring(h + 1)) ;
    }
    else
      numStartRange = parseFloat(format.substring(g + 1)) ;
*/
  }
  else
    numType = format ;

  if (numType == 'INT')
  {
    retStr = parseInt(fldValue, 10) ;
    if (isNaN(retStr))
      retStr = defaultZero ;
    else
    {
      if (!isNaN(numStartRange))
      {
        if (typeof(defNumMask) != 'undefined')
          retStr = ExpandNumStr(defNumMask, retStr) ;

        if (retStr < numStartRange)
          retStr = numStartRange ;
      }

      if (!isNaN(numEndRange))
        if (retStr > numEndRange)
          retStr = numEndRange ;

      if (thousandSep != '')
        retStr = InsertThousandSep(retStr, thousandSep, digitStr) + '' ;
      if (fieldDispLen > 0)
        retStr = PadStr(retStr, fieldDispLen, fieldDispLen, padCh, 0, '0') ;
    }
  }
  else if (numType == 'FLOAT')
  {
    retStr = ConvertDigit(fldValue, digitStr, '.') ;
    retStr = parseFloat(retStr) ;
    if (isNaN(retStr))
      retStr = defaultZero ;
    else
    {
      if (!isNaN(numStartRange))
        if (retStr < numStartRange)
          retStr = numStartRange ;

      if (!isNaN(numEndRange))
        if (retStr > numEndRange)
          retStr = numEndRange ;
    }
    if (digitStr != '.')
      retStr = ConvertDigit(retStr, '.', digitStr) ;
    if (thousandSep != '')
      retStr = InsertThousandSep(retStr, thousandSep, digitStr) + '' ;

    if (digitDispLen > 0)
    {
      g = retStr.indexOf(digitStr) ;
      if (g > 0)
      {
        digitPart = retStr.substring(g + 1) ;
        wholePart = retStr.substring(0, g) ;
      }
      else
      {
        digitPart = '0' ;
        wholePart = retStr ;
      }

      if (fieldDispLen > 0)
      {
        var wholePartLen ;
        wholePartLen = fieldDispLen - digitDispLen - 1 ;
        wholePart = PadStr(wholePart, wholePartLen, wholePartLen, padCh, 0, '0') ;
      }

      digitPart = PadStr(digitPart, digitDispLen, digitDispLen, '0', 1, '0') ;
      retStr = wholePart + digitStr + digitPart ;
    }
    else if (fieldDispLen > 0)
    {
      g = retStr.indexOf(digitStr) ;
      if (g > 0)
        wholePart = retStr.substring(0, g) ;
      else
        wholePart = retStr ;
      wholePart = PadStr(wholePart, fieldDispLen, fieldDispLen, ' ', 0) ;
      digitPart = '' ;
      retStr = wholePart + digitPart ;
    }
  }
  else if (numType == 'ALLNUMERIC')
  {
    var indx ;
    retStr = fldValue ;
    for (indx = 0 ; indx < fldValue.length ; indx++)
    {
      var thisCh ;
      thisCh = fldValue.charAt(indx) ;
      if ((thisCh < '0' || thisCh > '9') && thisCh != digitStr && thisCh != thousandSep)
      {
        retStr = defaultZero ;
        break ;
      }
    }
    if (thousandSep != '')
      retStr = InsertThousandSep(retStr, thousandSep, digitStr) + '' ;
    if (fieldDispLen > 0)
      retStr = PadStr(retStr, fieldDispLen, fieldDispLen, padCh, 0, '0') ;
  }
  else if (numType == 'CCNUMBER')
  {
    var indx ;
    retStr = fldValue ;
    for (indx = 0 ; indx < fldValue.length ; indx++)
    {
      var thisCh ;
      thisCh = fldValue.charAt(indx) ;
      if ((thisCh < '0' || thisCh > '9') && thisCh != ' ')
      {
        retStr = retStr.substring(0, indx) + ' ' + retStr.substring(indx + 1) ;
      }
    }
    retStr = trim(retStr) ;
    if (fieldDispLen > 0)
      retStr = PadStr(retStr, fieldDispLen, fieldDispLen, padCh, 0, '0') ;
  }
  else if (numType == 'TRANSNUMBER')
  {
    var indx ;
    retStr = fldValue ;
    for (indx = 0 ; indx < retStr.length ; indx++)
    {
      var thisCh ;
      thisCh = retStr.charAt(indx) ;
      if ((thisCh < '0' || thisCh > '9'))
      {
        retStr = retStr.substring(0, indx) + retStr.substring(indx + 1) ;
        --indx ;
      }
    }
    retStr = trim(retStr) ;
    if (fieldDispLen > 0)
      retStr = PadStr(retStr, fieldDispLen, fieldDispLen, padCh, 0, '0') ;
  }
  else
    retStr = defaultZero ;

  return (retStr) ;
}
function ExpandNumStr(template, num)
{
  var g ;
  num += '' ;
  template += '' ;
  for (g = template.length-num.length ; g > 0 ; g--)
    num = template.charAt(g-1) + num ;

  return (num) ;
}
function ConvertDigit(fldValue, fromDigitStr, toDigitStr)
{
  var retStr ;
  var g ;

  retStr = fldValue + '' ;
  g = retStr.indexOf(fromDigitStr) ;
  if (g > -1)
    retStr = retStr.substring(0, g) + toDigitStr + retStr.substring(g + 1) ;
  return (retStr) ;
}
function RemoveThousand(fldValue, thousandSep)
{
  var retStr ;
  var g ;

  retStr = fldValue + '' ;

  g = retStr.indexOf(thousandSep) ;
  for (; g > -1 ;)
  {
    retStr = retStr.substring(0, g) + retStr.substring(g + 1) ;
    g = retStr.indexOf(thousandSep) ;
  }
  return (retStr) ;
}
function InsertThousandSep(fldValue, thousandSep, digitStr)
{
  var retStr ;
  var digitPart ;
  var g ;

  retStr = fldValue + '' ;
  g = retStr.indexOf(digitStr) ;
  if (g > -1)
  {
    digitPart = retStr.substring(g) ;
    retStr = retStr.substring(0, g) ;
  }
  else
    digitPart = '' ;

  for (g = retStr.length - 3 ; g > 0 ; g -= 3)
    retStr = retStr.substring(0, g) + thousandSep + retStr.substring(g) ;

  return (retStr + digitPart) ;
}
function PadStr(strValue, minLen, maxLen, padCh, padSide, overflowVal)
{
  var retValue ;
  var paddedStr ;
  var g ;

  strValue += '' ; // Convert to string!
  if (strValue.length > maxLen)
    strValue = overflowVal ;

  for (paddedStr = '', g = 0 ; g < maxLen ; g++)
    paddedStr += padCh ;

  if (padSide == 0)
    paddedStr = paddedStr.substring(0, maxLen - strValue.length) + strValue ;
  else
    paddedStr = strValue + paddedStr.substring(maxLen - (maxLen - strValue.length)) ;
  retValue = paddedStr ;

  return (retValue) ;
}

function CheckCCCard(fld)
{
  return (ValNumeric('CCNUMBER', fld)) ;
}
function CheckTransNo(fld)
{
  return (ValNumeric('TRANSNUMBER', fld)) ;
}

var dateFormat = 'DD/MM/YYYY' ; // Sequence of DD,MM,YYYY may be changed if desired.
var defaultSep = '-' ; // May be changed if desired.

var dayIndx ;
var monIndx ;
var yearIndx ;

// ----------------------------------------------------------------------------
// Validates a date field, displaying an errormessage and returning focus to
// the field if invalid.
// ----------------------------------------------------------------------------
function ValDate(fld)
{

  // If this validation function is called while another has signalled that it's resuming focus
  // to itself, then ignore the validation!
  if (resumingFocus != null)
    if (resumingFocus != fld)
      return (true) ;
    else
      resumingFocus = null ;

  if (fld.value != '')
  {
    var valDateStr ;
    valDateStr = ValDateStr(fld.value) ;
    if (valDateStr == '')
    {
      alert('Invalid date') ;
      if (NS)
        fld.value = '' ; // only when running NS
      fld.focus() ;
      resumingFocus = fld ;
      return (true) ;
    }
    else
    {
      fld.value = valDateStr ;
      return (true) ;
    }
  }
  else
    return (true) ;
}
// ----------------------------------------------------------------------------
// Validates an string containing a date. The format of the date must comply
// to the dateFormat string (defined previously). The exact format may be
// changed as long as it contain DD, MM and YYYY.
// The separator is determined by the first non-numeric character in the string.
// If no separator is found, then all parts are assumed to be filled.
// The passed in string may be missing 1 or 2 parts, in that case the missing
// parts are defaulted to today's values.
// The function returns the validated date, re-arranged to contain all parts
// using the seperator specified by defaultSep (defined previously).
// A non-valid date is returned as ''.
// ----------------------------------------------------------------------------
function ValDateStr(fldValue)
{
  var parts ;
  var g ;
  var ch ;
  var sepCh = '' ;

  if (fldValue == '')
    return ('') ;

  // Find the part indexes the first time the function is called.
  if (typeof(dateFormatArray) == 'undefined')
  {
    var dateFormatArray ;
    dateFormatArray = dateFormat.split('/', 3) ;
    for (g = 0 ; g < dateFormatArray.length ; g++)
      if (dateFormatArray[g] == 'DD')
        dayIndx = g ;
      else if (dateFormatArray[g] == 'MM')
        monIndx = g ;
      else if (dateFormatArray[g] == 'YYYY')
        yearIndx = g ;
  }

  // Find separator.
  for (g = 0 ; sepCh == '' && g < fldValue.length ; g++)
  {
    ch = fldValue.charAt(g) ;
    if (!(ch >= '0' && ch <= '9'))
      sepCh = ch ;
  }
  if (sepCh != '')
    parts = fldValue.split(sepCh, 3) ;
  else
  {
    // no seperator entered, try finding the parts without. Assume each part
    // being filled and get them in the order defined originally by dateFormat.
    var thisPos ;

    parts = new Array() ;
    for (thisPos = g = 0 ; g < 3 ; g++)
      if (dayIndx == g || monIndx == g)
      {
        parts[g] = fldValue.substring(thisPos, thisPos + 2) + '' ;
        thisPos += 2 ;
      }
      else if (yearIndx == g)
      {
        parts[g] = fldValue.substring(thisPos, thisPos + 4) + '' ;
        thisPos += 4 ;
      }
  }
  // fill in missing value with today's values.
  var today = new Date() ;
  if (parts[dayIndx] == '')
    parts[dayIndx] = today.getDate() ;
  if (parts[monIndx] == '')
    parts[monIndx] = today.getMonth() + 1 ;
  if (parts[yearIndx] == '')
    parts[yearIndx] = today.getFullYear() ;


  if (parts.length == 3)
  {
    if (parseInt(parts[yearIndx], 10) < 1000)
      parts[yearIndx] = parseInt(parts[yearIndx], 10) + 2000 ;

    var checkDate = new Date(parts[yearIndx], parts[monIndx] - 1, parts[dayIndx]) ;
    if (checkDate.getFullYear() != parts[yearIndx] ||
        checkDate.getMonth()    != parts[monIndx] - 1 ||
        checkDate.getDate()     != parts[dayIndx])
      return ('') ;
    else
    {
      parts[dayIndx]  = InsChars(2, '0', parts[dayIndx]) ;
      parts[monIndx]  = InsChars(2, '0', parts[monIndx]) ;
      parts[yearIndx] = InsChars(4, '0', parts[yearIndx]) ;

      return (parts[0] + defaultSep + parts[1] + defaultSep + parts[2]) ;
    }
  }
  else
    return ('') ;
}

// ----------------------------------------------------------------------------
// Inserts the insChar at the beginning of the passed str returning a string
// with the len length.
// ----------------------------------------------------------------------------
function InsChars(len, insChar, str)
{
  var retStr = '' ;
  var g ;
  var strstr = str + '' ;

  for (g = 0 ; g < len - strstr.length ; g++)
    retStr += insChar + '' ;

  retStr += strstr ;
  return (retStr) ;
}

// ----------------------------------------------------------------------------
function ValTime(fld)
{
  if (fld.value != '')
  {
    var valTime
    valTime = ValTimeStr(fld.value)
    if (valTime == '')
    {
      if (NS)
        fld.value = '' ;
      fld.focus() ;
      return (false) ;
    }
    else
    {
      fld.value = valTime ;
      return (true) ;
    }
  }
  else
    return (true) ;

}

function ValTimeStr(timeVal)
{
}

// ----------------------------------------------------------------------------
function ArgSplit(thisTag, Separator, addEmpty)
{
  var thisStart, thisEnd, inQuote, g ;
  var s ;

  attr = new Array() ;
  for (inQuote = false, thisStart = -1, thisEnd = -1, g = 0 ; g < thisTag.length ; g++)
  {
    if (thisTag.charAt(g) == '!')
      if (inQuote)
        inQuote = false ;
      else
        inQuote = true ;

    if (thisTag.charAt(g) != Separator || inQuote)
      if (thisStart == -1)
        thisStart = thisEnd = g ;
      else
        thisEnd = g ;
    else
    {
      // Separator found, split!
      if (thisStart != -1 && thisEnd != -1)
      {
        s = thisTag.substring(thisStart, thisEnd + 1) ;
        attr[attr.length] = new String(s) ;
      }
      else if (typeof(addEmpty) == 'undefined' || addEmpty == 1) // Add empty entry? specified by user!
      {
        s = '' ;
        attr[attr.length] = new String(s) ;
      }

      thisStart = thisEnd = -1 ;
    }
  }

  if (thisStart != -1 && thisEnd != -1)
  {
    s = thisTag.substring(thisStart, thisEnd + 1) ;
    attr[attr.length] = new String(s) ;
  }
  else if (thisStart != -1)
  {
    s = '' ;
    attr[attr.length] = new String(s) ;
  }


  return (attr) ;
}

// ------------------------------------------------------------------------------------------------
function SetFieldFocus(fieldName)
{
  var fld = document.getElementsByName(fieldName)[0] ;
  if (fld != null)
    fld.focus() ;
}

// ------------------------------------------------------------------------------------------------
// Function to insert text at the beginning of a <textarea> - only works in IE.
// Pass the textarea and the text to insert. Always inserts a newline after the new text.
// ------------------------------------------------------------------------------------------------
function insertFirst (textEl, text)
{
  textEl.value = text + '\n' + textEl.value ;
  var caretPos = textEl.createTextRange() ;
  caretPos.moveStart('character', text.length) ;
  caretPos.collapse() ;
  caretPos.select() ;
}

// ------------------------------------------------------------------------------------------------
function CheckMonYear(monFld, yearFld)
{
  var now ;
  var enteredMon ;
  var enteredYear ;

  now = new Date() ;
  enteredMon  = parseInt(monFld.value, 10) ;
  enteredYear = parseInt(yearFld.value, 10) ;

  if (enteredYear < 100)
      enteredYear += 2000 ;

  if (enteredYear < now.getYear() ||
      (enteredYear == now.getYear() && enteredMon < now.getMonth() + 1))
    return (false) ;
  else
    return (true) ;
}

// ------------------------------------------------------------------------------------------------
function GetCenterCoords(xWidth, yHeight, rlt)
{
  var xCoord ;
  var yCoord ;
  var coordStr ;
  var wnd ;

  if (typeof(rlt) != undefined)
    if (rlt == 'window')
      wnd = window ;
    else
      wnd = top ;
  else
    wnd = top ;

  xCoord = ((wnd.document.body.offsetWidth - xWidth) / 2) + wnd.window.screenLeft ;
  yCoord = ((wnd.document.body.offsetHeight - yHeight) / 2)  + wnd.window.screenTop ;

  coordStr = 'LEFT=' + xCoord + ',TOP=' + yCoord + ',WIDTH=' + xWidth + ',HEIGHT=' + yHeight ;
  return (coordStr) ;
}

// ------------------------------------------------------------------------------------------------
function ResizeWindow(win, elem, xnewHeight, sizeDirective)
{
  if (typeof(sizeDirective) == 'undefined' || sizeDirective == '' || sizeDirective == 'AUTO')
  {
    var origHeight ;
    var newHeight ;
    var newXPos ;
    var newYPos ;
    var curHeight ;

    origHeight = win.document.body.clientHeight ;
    newHeight  = xnewHeight + parseInt(window.document.body.topMargin, 10) + parseInt(window.document.body.bottomMargin, 10) ;

    // Windows have a minimal size(?) - otherwise ie 5.5 will show a scrollbar (strange).
    if (newHeight < 90)
      newHeight = 90 ;

    // Dirty check for "screen overflow"
    if (newHeight > win.screen.availHeight)
      newHeight = win.screen.availHeight ;

    if (win.document.body.clientHeight != newHeight)
      win.resizeBy(0, newHeight-origHeight) ;

    curHeight = win.document.body.clientHeight ;
    deltaY = (origHeight - curHeight) / 2 ;
    win.moveBy(0, deltaY) ;
  }
  else if (sizeDirective == 'FIXED')
    ; // Do nothing, window is already desired size.
  else
  {
    // Expected format of sizeDirective: x,y
    // also accepts only x in which case the height is automatically calculated.
    var xIndx ;
    var xSize ;
    var ySize ;

    sizeDirective = trim(sizeDirective) ;
    xIndx = sizeDirective.indexOf(',') ;
    if (xIndx == -1 || xIndx == sizeDirective.length - 1)
    {
      var deltaX ;
      var origXSize ;

      origXSize = win.document.body.clientWidth ;
      if (origXSize != sizeDirective)
      {
        // Set the width.
        win.resizeBy(sizeDirective - origXSize, 0) ;
        deltaX = (origXSize - sizeDirective) / 2 ;
        win.moveBy(deltaX, 0) ;
      }
      // Calculate and set the new height.
      ResizeWindow(win, elem, xnewHeight, 'AUTO') ;
    }
    else
    {
      var deltaX ;
      var deltaY ;
      var xAdjust ;
      var yAdjust ;
      var origXSize ;
      var origYSize ;

      origXSize = win.document.body.clientWidth ;
      origYSize = win.document.body.clientHeight ;
      deltaX    = (origXSize - xSize) / 2 ;
      deltaY    = (origYSize - ySize) / 2 ;
      xSize     = sizeDirective.substring(0, xIndx) ;
      ySize     = sizeDirective.substring(xIndx+1) ;
      if (xSize != origXSize || ySize != origYSize)
      {
        // Resize the window according to specification
        win.resizeTo(xSize, ySize) ;
        xAdjust = xSize - win.document.body.clientWidth ;
        yAdjust = ySize - win.document.body.clientHeight ;
        win.resizeBy(xAdjust, yAdjust) ;


        // Center the window
        win.moveBy(deltaX, deltaY) ;
      }
    }
  }
}
// ------------------------------------------------------------------------------------------------
function ValEMail(EMailFld, errText)
{

  //http://www.breakingpar.com/bkp/home.nsf/Doc!OpenNavigator&87256B280015193F87256C40004CC8C6
  // NOTE to allow for international characters the domain name is no longer checked for an explicit character range.
  // The sequence "(((.)+\.)+" was originally "(([a-zA-Z\-0]+\.)+" and could be altered to "(([a-zA-Z\-0-9æøåäöüéÆØÅ]+\.)+" if only an subset of national characters should be accepted.
  // Note also, that the top level domain part is still checked for a-z/A-Z.
  var re = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(((.)+\.)+[a-zA-Z]{2,}))$/
  if (resumingFocus != null)
    if (resumingFocus != EMailFld)
      return (true) ;
    else
      resumingFocus = null ;

  if (re.test(EMailFld.value))
    return (true) ;
  else
  {
    resumingFocus = EMailFld ;
    EMailFld.focus() ;
    if (errText != '')
      alert(errText) ;
    return (false) ;
  }


/*

  var value = EMailFld.value ;
  var atCh ;
  var namePart ;
  var serverPart ;

  if (resumingFocus != null)
    if (resumingFocus != EMailFld)
      return (true) ;
    else
      resumingFocus = null ;

  if (trim(EMailFld.value).length == 0)
    return (true) ; // empty is ok...
  else
  {
    var lastAtCh = value.lastIndexOf('@') ; // multiple '@' characters?
    atCh = value.indexOf('@') ;
    if (atCh == -1 || atCh != lastAtCh)
    {
      resumingFocus = EMailFld ;
      EMailFld.focus() ;
      if (errText != '')
        alert(errText) ;
      return (false) ;
    }
    else
    {
      var dot ;

      namePart = value.substr(0, atCh) ;
      serverPart = value.substr(atCh + 1) ;
      dot = serverPart.indexOf('.') ;
      if (namePart.length < 1)
      {
        resumingFocus = EMailFld ;
        EMailFld.focus() ;
        if (errText != '')
          alert(errText) ;
        return (false) ;
      }
      else if (serverPart.indexOf('.') == -1)
      {
        resumingFocus = EMailFld ;
        EMailFld.focus() ;
        if (errText != '')
          alert(errText) ;
        return (false) ;
      }
      else
      {
        var domain ;
        var servername ;
        servername  = serverPart.substring(0, dot) ;
        domain      = serverPart.substring(dot+1) ;
        if (servername.length < 1 || domain.length < 1)
        {
          resumingFocus = EMailFld ;
          EMailFld.focus() ;
          if (errText != '')
            alert(errText) ;
          return (false) ;
        }
        else
          return (true) ;
      }
    }
  }
*/
}

// ------------------------------------------------------------------------------------------------
// Simple function for clearing a field upon first user entry (login/email flds.).
// Can be called from a onactivate event.
function ClearOnFirstEntry(fld)
{
  if (typeof(fld.clearonfirstentry) == 'undefined')
  {
    fld.value = '' ;
    fld.clearonfirstentry = 1 ;
  }
}

// ------------------------------------------------------------------------------------------------
// Silently check E-Mail as it is typed - i.e. don't display error message, but set the
// enabled/disabled state of the passed button according to validity of the entered address.
// NOTE, the function operates on a timer event, as using key events will not be safe, they are
// not fired when the user uses auto-complete/selects a value from a browser generated list of
// previously entered values. So the timer is used, primitive but effective :(
// Functionality divided into 2 parts to allow direct call if ref to flds.
function PreCheckEMail(fldName, btnName, emptyIsLegal, startTimer)
{
  var btn = document.getElementsByName(btnName)[0] ;
  var fld = document.getElementsByName(fldName)[0] ;
  PreCheckEMailFlds(fld, btn, emptyIsLegal, true) ;
  if (startTimer)
    window.setTimeout('PreCheckEMail(\'' + fldName + '\',\'' + btnName + '\',' + emptyIsLegal +
                      ', true)', 100) ;
}
function PreCheckEMailFlds(fld, btn, emptyIsLegal, doChange)
{
  // doChange: if caller is going have more checks to do before deciding to set the eneabled state
  // of the button, then the flag may be set to false to avoid changing state befor final decision.

  var btnState ;
  if ((emptyIsLegal == false && trim(fld.value) == '') || ValEMail(fld, '') == false)
  {
    btnState = false ;
    if (doChange && btn.disabled == false)
      btn.disabled = true ;
  }
  else
  {
    btnState = true ;
    if (doChange && btn.disabled == true)
      btn.disabled = false ;
  }
  return (btnState) ;
}

// ------------------------------------------------------------------------------------------------
// Aux. function for filling the valid OPTIONS (passed in comboQueArray) in a SELECT (selectField).
// Note, the ChosenEntryID parameter is optional - if missing, entry 0 is selected.
function FillCombo(comboQueArray, selectField, chosenEntryID)
{
  var g ;
  var selectEntry = 0 ;
  selectField.options.length = 0 ; // Empty array, just set to the length to 0.

  for (g = 0 ; g < comboQueArray.length ; g++)
  {
    var thisOption ;
    thisOption = new Option(comboQueArray[g].GetDesc(), comboQueArray[g].GetID()) ;

    selectField.options[selectField.options.length] = thisOption ;
    if (typeof(chosenEntryID) != 'undefined')
      if (chosenEntryID == thisOption.value)
        selectEntry = g ;
  }
//  selectField.options.item(selectEntry).selected = true ;
  selectField.options[selectEntry].selected = true ;
}

// ------------------------------------------------------------------------------------------------
function AllNumeric(testValue)
{
  var g ;
  if (testValue.length > 0)
  {
    for (g = 0 ; g < testValue.length ; g++)
      if (!(testValue.charAt(g) >= 0 && testValue.charAt(g) <= 9))
        return (false) ;

    return (true) ;
  }
  else
    return (false) ; // Empty string, not considered to be 'All Numeric'.
}

// ------------------------------------------------------------------------------------------------
function IsSpace(testCh)
{
  if (testCh == ' ' || testCh == '\n' || testCh == '\r' || testCh == '\t')
    return (true) ;
  else
    return (false) ;
}
// ------------------------------------------------------------------------------------------------
function xFindFrame(frameParent, frameName)
{
  if (NS != false)
  {
    var g ;
    for (g = 0 ; g < frameParent.frames.length ; g++)
      if (frameParent.frames[g].name == frameName)
        return (frameParent.frames[g]) ;
    return (null) ;
  }
  else
    return (frameParent.frames(frameName)) ;
}

// -----------------------------------------------------------------------------------------------
function LoadURI(uri, id)
{
// uri: url to server file
// id: if set overwrite existing script, if not then append script

  if (document.createElement && document.getElementsByTagName)  // Checks for DOM1 support
  {
    var head = document.getElementsByTagName('head').item(0); // Get the first HEAD-tag in case of non-valid HTML
    var old ;
    if (id)
      old = document.getElementById(id); // Find old scripts
    if (id && old != null)
      head.removeChild(old); // Delete old scripts

    var script = document.createElement('script'); // Create a new script
    script.setAttribute('type','text/javascript'); // Set type to Javascript
//    script.setAttribute('defer','defer');
    // Defer: No need to wait for the entire script to be parsed and evaluated
    // http://www.w3.org/TR/REC-html40/interact/scripts.html#adef-defer
    script.setAttribute('src',uri); //  Source to js-file
    if (id) script.setAttribute('id',id); // Give script an ID
    void(head.appendChild(script)); // Append script to current site
  }
}