// JavaScript utility functions

var LOG_TRACE = 0;
var LOG_DEBUG = 1;
var LOG_INFO = 2;
var LOG_WARN = 3;
var LOG_ERROR = 4;
var LOG_FATAL = 5;

var LOG_LEVEL = LOG_ERROR;
var ie = false;
var firefox = false;
var httpRequest = null;
var cookieMap;

// This re must be the same as AODConstants.FLEXIBLE_DATE_PATTERN.
var DATE_PATTERN = "^(\\d{1,2})[\\/\\-\\.](\\d{1,2})[\\/\\-\\.](\\d{4}|\\d{2}|\\d{1})$|^(\\d{2})(\\d{2})(\\d{4}|\\d{2})$";
var DATE_REGEXP = new RegExp(DATE_PATTERN);
var SEGMENTED_DATE_PATTERN = DATE_PATTERN + "|^(\\d{1,2})[\\/\\-\\.](\\d{4}|\\d{2})$|^(\\d{4}|\\d{2})$";
var SEGMENTED_DATE_REGEXP = new RegExp(SEGMENTED_DATE_PATTERN);
// This re must be the same as AODConstants.FLEXIBLE_TIME_PATTERN.
var TIME_REGEXP = /^(\d{1,2})[:\.](\d{1,2})(|[:\.](\d{1,2})(|\.(\d{1,3}))) *(am|pm)?$/i;
var TIME_REGEXP_12HR = /^(\d{1,2})[:\.](\d{1,2})(|[:\.](\d{1,2})(|\.(\d{1,3}))) *(am|pm)$/i;

var NUMERIC_REGEXP = /^\d+$/;
var FLOATING_POINT_REGEXP = /^(\d+\.?\d*|\.\d+)$/;
var SIGNED_NUMERIC_REGEXP = /^\-?\d+$/;
var SIGNED_FLOATING_POINT_REGEXP = /^\-?\d+\.?\d*$/;
var NON_BLANK_REGEXP = /[^ ]+/;
var ALL_BLANK_REGEXP = /^ *$/;
var PARSEABLE_NUMERIC_REGEXP = new RegExp("^0*([1-9]+[0-9]*)$");

// from https://bytes.com/groups/javascript/148646-onchange-onblur-events
var GLOBAL_TAKE_FOCUS = null;

function setFocus(ref) {
    GLOBAL_TAKE_FOCUS=ref;
    setTimeout("GLOBAL_TAKE_FOCUS.focus();",100);
}

// had trouble with this, perhaps because w3c and ms event models
// are not cross-browser compatible.
// but the compatibility issue seems to be addressed. 
function addEventListenerSafely(element, evtType, evtHandler, capture) {
    if (element.addEventListener) {
        // mozilla
        element.addEventListener(evtType, evtHandler, capture);
    }
    else if (element.attachEvent) {
        // IE
        alert('attaching event: ' + evtType + ' of element: ' + element + ' to handler: ' + evtHandler);
        element.attachEvent('on' + evtType, evtHandler);
    }
    else {
        alert('could not addEventListener ' + evtHandler + ' for event ' + evtType + ' on element ' + element);
    }
}

function initUtils() {
    ie = isIE();
    firefox = isFirefox();
}

// clear a selection list
function clearSelection(selectionList, lastIndex) {
    for (var i = selectionList.length-1; i >= lastIndex; i--) 
    { 
        selectionList.remove(i); 
    } 
}

function dumpElements(form) {
    for (var i = 0; i < form.elements.length; i++) {
        document.write(form.elements[i].type + " " + form.elements[i].name + "<BR>");
    }
}
    
function createXMLHttpRequest() 
{ 
    var req = null; 
    if (typeof XMLHttpRequest != "undefined") { 
        req = new XMLHttpRequest(); 
    } else if (window.ActiveXObject) { 
        try { 
            // Try to create XMLHttpRequest in later versions 
            // of Internet Explorer 
            req = new ActiveXObject("Msxml2.XMLHTTP"); 
        } catch (e1) { 
            // Failed to create required ActiveXObject 
            try { 
                // Try version supported by older versions 
                // of Internet Explorer 
                req = new ActiveXObject("Microsoft.XMLHTTP"); 
            } catch (e2) { 
                // Unable to create an XMLHttpRequest with ActiveX 
                setErrorMessage("Unable to create XMLHttpRequest."); 
            } 
        } 
    } 
    return req; 
} 
// Multiple Concurrent AJAX requests.

// With JavaScript you can have more than one AJAX request processing
// at a single time. In order to insure the proper post processing of
// code it is recommended that you use JavaScript Closures.  The
// closure binds the request to the callback.  The example below shows
// an XMLHttpRequest object abstracted by a JavaScript object called
// AJAXInteraction. As arguments you pass in the URL to call and the
// function to call when the processing is done.
    
// Use this for multiple concurrent
// AJAX calls (max 2 w/IE).
// from https://www.ajaxprojects.com/ajax/tutorialdetails.php?itemid=225#start
// among other places.
// example:

// function makeRequest() {
//   var ai = new AJAXInteraction("processme", function() { alert("Doing Post Process");});
//   ai.doGet();
// }

function AJAXInteraction(url, callback, errorCallback) {
    this.TEXT_RESPONSE = 0;
    this.XML_RESPONSE = 1;

    var responseType = this.TEXT_RESPONSE;
    var req = init();
    req.onreadystatechange = processRequest;

    function init() {
        if (window.XMLHttpRequest) {
            return new XMLHttpRequest();
        } else if (window.ActiveXObject) {
            return new ActiveXObject("Microsoft.XMLHTTP");
        }
    }

    function processRequest () {
        var response = null;
        if (req.readyState == 4) {
            if (req.status == 200) {
                if (callback != null && typeof(callback) == 'function') {
                    if (responseType == this.XML_RESPONSE) {
                        response = req.responseXML;
                    }
                    else {
                        response = req.responseText;
                    }
                    callback(response);
                }
            } else {
                if (errorCallback != null && typeof(callback) == 'function') {
                    if (responseType == this.XML_RESPONSE) {
                        response = req.responseXML;
                    }
                    else {
                        response = req.responseText;
                    }
                    errorCallback(req.status, response);
                }
            }
        }
    }
    
    this.doGet = function() {
        req.open("GET", url, true);
        req.send(null);
    }

    this.doPost = function(body) {
        req.open("POST", url, true);
        req.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
        req.send(body);
    }

    this.setResponseType = function(type) {
        responseType = type;
    }
}
    
function getMultiSelectAsParameterString(elementId, parameterName, firstChar) {
    var selectElement = document.getElementById(elementId);
    var stringRep = '';
    if (selectElement != null) {
        var options = selectElement.options;
        if (options != null) {
            for (var i = 0; i < selectElement.length; i++) {
                if (options[i].selected) {
                    stringRep += (stringRep.length == 0 ? '' : '&') + parameterName + "=" + options[i].value;
                }
            }
        }
    }
    return stringRep == '' ? stringRep : firstChar + stringRep;
}

function getSelectAsParameterString(elementIdBase, firstChar){

    var selectElement = document.getElementById(elementIdBase);
    var stringRep = '';
   
    if (selectElement != null) {
        var elementIndex = selectElement.selectedIndex;
        var element = selectElement.options[elementIndex].value;
        if (element != null) {
            
               stringRep += (stringRep.length == 0 ? '' : '&') + elementIdBase + "=" + element;
        }
    }
    return stringRep == '' ? stringRep : firstChar + stringRep;
}

function getParameterString(form) {
    warn("getParameterString(form) is deprecated - use getFormElementsAsParameterString(form)");
    var parameterString = ''; 
    var size = form.length; 
    var elements = form.elements; 
    var name = ''; 
    for (var i = 0 ; i < size ; i++) 
    { 
        name = elements[i].name; 
        
        if (name == '') 
        { 
            name = form.name + i; 
        } 
        value = elements[i].value; 

        if (i > 0) 
        { 
            parameterString = parameterString + '&'; 
        } 
        parameterString = parameterString 
            + name + '=' 
            + encodeURIComponent(value); 
    } 
    return parameterString; 
} 

function getRadioGroupAsParameterString(elementIdBase, elementCount, firstChar) {
    var element = null;
    var stringRep = '';
    for (var i = 0; i < elementCount; i++) {
        element = document.getElementById(elementIdBase + i);
        trace('element:' + elementIdBase + i + ' checked? ' + element.checked);
        if (element.checked) {
            stringRep += (stringRep.length == 0 ? '' : '&') + elementIdBase + "=" + element.value;
            break;
        }
    }
    trace('rg stringRep=' + stringRep);
    return stringRep == '' ? stringRep : firstChar + stringRep;
}

function hideElement(name) {
    if (name && name.length > 0) {
        trace("in hideElement name=" + name);
                hideRetrievedElement(document.getElementById(name));
    }
}

function hideRetrievedElement(element) {
    trace("in hideRetrievedElement element=" + element);
    if (element && element.style) {
        //element.style.visibility = 'collapse';
        element.style.visibility = 'hidden'; 
        element.style.display = 'none';
    }
}

function hideAndShrinkElement(name) {
    if (name && name.length > 0) {
        trace("in hideAndShrinkElement name=" + name);
                hideAndShrinkRetrievedElement(document.getElementById(name));
    }
}

function hideAndShrinkRetrievedElement(element) {
    trace("in hideAndShrinkRetrievedElement element=" + element);
    if (element && element.style) {
        //element.style.visibility = 'collapse';
        element.style.visibility = 'hidden'; 
        element.style.display = 'none';
        element.style.height = '0px';
    }
}

function showElement(name) {
    if (name && name.length > 0) {
        trace("in showElement, name=" + name);
        showRetrievedElement(document.getElementById(name));
    }
}

function showRetrievedElement(element) {
    trace("in hideRetrievedElement element=" + element);
    if (element && element.style) {
        element.style.visibility = 'visible'; 
        //element.style.display = 'inline'; 
        element.style.display = 'block';
    }
}

function showElementInLine(name) {
    if (name && name.length > 0) {
        trace("in showElement, name=" + name);
        showRetrievedElementInLine(document.getElementById(name));
    }
}

function showElementCSS(id) {
    var el = document.getElementById(id);
    if (exists(el)) {
        el.className = 'visible';
    }
}

function hideElementCSS(id) {
    var el = document.getElementById(id);
    if (exists(el)) {
        el.className = 'invisible';
    }
}

function showRetrievedElementInLine(element) {
    trace("in hideRetrievedElement element=" + element);
    if (element && element.style) {
        element.style.visibility = 'visible'; 
        element.style.display = 'inline'; 
    }
}

function removeChildren(element) {
    if (element && element.childNodes) {
        trace(">> removing children of " + element);
        for (var i = element.childNodes.length-1;
             i >= 0; i--) {
            removeChildren(element.childNodes[i]);
            trace("<< removing child node " + element.childNodes[i]);
            element.removeChild(element.childNodes[i]);
        }
    }
}

function removeChildrenById(id) {
    if (exists(id)) {
        removeChildren(document.getElementById(id));
    }
}

//+ Carlos R. L. Rodrigues
//@ https://jsfromhell.com/array/search [rev. #2]

// Searches a value inside an ordered array using binary search or
// supplies the index where the searched value should be inserted to
// keep the array ordered.

function search(o, v, i){
    var h = o.length, l = -1, m;
    while(h - l > 1)
        if(o[m = h + l >> 1] < v) l = m;
    else h = m;
    return o[h] != v ? i ? h : -1 : h;
}

function setFlaggedLabelsOnElement(elementName, flags, labels) {
    var html = '';
    var flagCount = 0;
    for (var i = 0; i < flags.length; i++) {
        if (flags[i]) {
            if(flagCount > 1 && flagCount < flags.length){
                html += ', ';
            }
            if(flagCount == 0){
                html = '<I>' + labels[i] + '</I>';
            }else{
                html += "<SPAN STYLE='white-space:nowrap'>" + labels[i] + "</SPAN>";
            }
            if(flagCount == 0 && flags.length > 1){
                html += ':&nbsp;';
            }
            flagCount++;
        }
    }
    if(html != ''){
        html += '<BR>';
    }
    setRecordsTypesHTML(elementName, html);
}

function setNestedFlaggedLabelsOnElement(elementName, flags, labels) {
    var isCheked = false;
    var html = '';
    var flagCount = 0;
    for(var i = 0; i < 4; i++){
        if(flags[i]){
            isCheked = true;
        }
    }
    if(isCheked){
        html = '<I>' + labels[0] + '</I>:&nbsp;';
        for (var i = 1; i < flags.length; i++) {
            if (flags[i]) {
                if(flagCount > 0 && flagCount < flags.length){
                    html += ', ';
                }
                html += "<SPAN STYLE='white-space:nowrap'>" + labels[i] + "</SPAN>";
                flagCount++;
            }
        }
        if(html != ''){
            html += '<BR>';
        }
    }
    setRecordsTypesHTML(elementName, html);
}

function setRecordsTypesHTML(elementName, html) {
    var element = document.getElementById(elementName);
    if (element) {
        element.innerHTML += html;
    }
}

function setHTML(elementName, html) {
    var element = document.getElementById(elementName);
    if (element) {
        element.innerHTML = html;
    }
}

function setText(elementName, text) {
    var element = document.getElementById(elementName);
    if (element) {
        removeChildren(element);
        element.appendChild(document.createTextNode(text));
    }
}

function setElementTextFromArray(element, a) {
    if (element) {
        removeChildren(element);
        var text = '';
        for (var idx in a) {
            text += a[idx] + '\n';
        }
        element.appendChild(document.createTextNode(text));
    }
}

function appendElementTextFromArray(element, a) {
    if (element) {
        var text = '';
        for (var idx in a) {
            text += a[idx] + '\n';
        }
        element.appendChild(document.createTextNode(text));
    }
}

function setElementHtmlFromArray(element, a) {
    if (element) {
        var html = '';
        for (var idx in a) {
            html += '<br>' + a[idx] + '\n';
        }
        element.innerHTML = html;
    }
}

function appendElementHtmlFromArray(element, a) {
    if (element) {
        var html = '';
        for (var idx in a) {
            html += '<br>' + a[idx] + '\n';
        }
        element.innerHTML += html;
    }
}

// return count of keys in a json object.
function keyCount(obj) { return Object.keys(obj).length; }

// these trim functions 
// are from https://www.somacon.com/p355.php

String.prototype.trim = function() {
    return this.replace(/^\s+|\s+$/g,"");
}
String.prototype.ltrim = function() {
    return this.replace(/^\s+/,"");
}
String.prototype.rtrim = function() {
    return this.replace(/\s+$/,"");
}

String.prototype.capitalize = function() {
    return this[0].toUpperCase() + this.substring(1, this.length).toLowerCase();
}

String.prototype.startsWith = function(target) {
    var result = false;
    if (target != null
        && (target.length == 0
            || this.indexOf(target) == 0)) {
        result = true;
    }
    return result;
}

String.prototype.endsWith = function(target) {
    var result = false;
    if (target != null) {
        if (target.length == 0) {
            result = true;
        }
        else {
            var len = this.length;
            if (len > 0) {
                var pos = this.lastIndexOf(target);
                if (pos > 0
                    && len - pos == target.length) {
                    result = true;
                }
            }
        }
    }
    return result;
}

String.prototype.reverse = function() {
    var result = '';
    for(var i = this.length - 1;
        i >= 0;
        i--) {
        result += this.substring(i, i+1);
    }
    return result;
}

function getParentNode(element, parentNodeName) {
    var parentNode = null;
    if (parentNodeName && parentNodeName.length > 0) {
        for (parentNode = element.parentNode;
             parentNode && parentNode.nodeName != parentNodeName;
             parentNode = parentNode.parentNode)
        {}
    }
    return parentNode;
}

function getDateFromString(dateString) {
    var dateArr = dateString.split(/[.,\/-]/);
    var curYear = new Date().getFullYear();
    var month, day, yearString, year;

    if (dateArr.length < 3) {
        month = dateString.substring(0, 2);
        day = dateString.substring(2, 4);
        yearString = dateString.substring(4, dateString.length);
    } else {
        month = dateArr[0];
        day = dateArr[1];
        yearString = dateArr[2];
    }
    var year = parseInt(yearString);

    if (year < 100) {
        if (year <= 1 + (curYear % 100)) {
            year = year + 2000;
        } else {
            year = year + 1900
        }
    }
    return new Date(year, month - 1, day);
}

function validateDateOrder(start, end) {
    var valid = true;
    var startDateStr = document.getElementById(start).value;
    var endDateStr = document.getElementById(end).value;
    var startDate = getDateFromString(startDateStr);
    var endDate = getDateFromString(endDateStr);

    if (startDate > endDate) {
        message = 'Start date [' + formatDate(startDate)
            + '] must be on or before the end date [' + formatDate(endDate) + '].';
        alert(message);
        valid = false;
    }
    return valid;
}

function validateRe(elementName, re, elementLabel, stateIfMatched) {
    return validateElementByRe(document.getElementById(elementName),
                               re,
                               false, 
                               elementLabel,
                               stateIfMatched);
}

function validateElementByRe(element, re, blanksOk, elementLabel, stateIfMatched) {
    var value = null;
    var valid = true;
    var match = null;
    var message = null;
    if (element) {
        value = element.value;
        if (value != null) {
            value = value.trim();
            if (value.length == 0) {
                if (!blanksOk) {
                    valid = false;
                    message = elementLabel + ' is required.';
                }
            }
            else {
                match = re.exec(value);
                if (!match || match.length == 0) {
                    valid = false;
                    message = 'The value of ' + elementLabel
                          + ' is not ' + stateIfMatched
                          + '.';
                }
            }
        }
        else {
            valid = false;
            message = 'Value of element ' + elementLabel + ' is null.';
        }
        if (!valid) {
            if (message != null) {
                alert(message);
            }
            //element.focus();
            setFocus(element);
        }
    }
    else {
        alert('Element ' + elementName 
              + ' is not present in the document.');
    }
    return valid;
}

function validateDateElement(element, elementLabel) {
    return validateElementByRe(element, DATE_REGEXP, false, elementLabel, 'a date');
}

function validateDateOrBlankElement(element, elementLabel) {
    return validateElementByRe(element, DATE_REGEXP, true, elementLabel, 'a date');
}

function validate12HourTimeElement(element, elementLabel) {
    if (element && element.value) {
        element.value = element.value.toUpperCase();
    }
    return validateElementByRe(element, TIME_REGEXP_12HR, false, elementLabel, 'a time followed by AM or PM');
}

function validate12HourTimeOrBlankElement(element, elementLabel) {
    if (element && element.value) {
        element.value = element.value.toUpperCase();
    }
    return validateElementByRe(element, TIME_REGEXP_12HR, true, elementLabel, 'a time followed by AM or PM');
}

function validateTimeElement(element, elementLabel) {
    return validateElementByRe(element, TIME_REGEXP, false, elementLabel, 'a time');
}

function validateTimeOrBlankElement(element, elementLabel) {
    return validateElementByRe(element, TIME_REGEXP, true, elementLabel, 'a time');
}

function validateFloatingPointElement(element, elementLabel) {
    return validateElementByRe(element, FLOATING_POINT_REGEXP, false, elementLabel, 'a number');
}

function validateFloatingPointOrBlankElement(element, elementLabel) {
    return validateElementByRe(element, FLOATING_POINT_REGEXP, true, elementLabel, 'a number or blank');
}

function validateNumericElement(element, elementLabel) {
    return validateElementByRe(element, NUMERIC_REGEXP, false, elementLabel, 'a whole number');
}

function validateNumericOrBlankElement(element, elementLabel) {
    return validateElementByRe(element, NUMERIC_REGEXP, true, elementLabel, 'a whole number, or blank');
}

function validateNumericElementByRange(element, elementLabel, minValue, maxValue) {
    var valid = false;
    if (validateElementByRe(element, NUMERIC_REGEXP, false, elementLabel, 'a whole number')) {
        if (element.value >= minValue
            && element.value <= maxValue) {
            valid = true;
        }
        else {
            alert('The value of ' + elementLabel
                  + ' is not in the range '
                  + minValue + '-' + maxValue
                  + '.');
            element.focus();
        }
    }
    return valid;
}

function validateNumericOrBlankElementByRange(element, elementLabel, minValue, maxValue) {
    var valid = false;
    if (validateElementByRe(element, NUMERIC_REGEXP, true, elementLabel, 'a whole number')) {
        if (!element.value || element.value.trim().length == 0) {
            valid = true;
        }
        else {
            if (element.value >= minValue
                && element.value <= maxValue) {
                valid = true;
            }
            else {
                alert('The value of ' + elementLabel
                      + ' is not in the range '
                      + minValue + '-' + maxValue
                      + '.');
                setFocus(element);
            }
        }
    }
    return valid;
}

function validateFloatingPointElementByRange(element, elementLabel, minValue, maxValue) {
    var valid = false;
    if (validateElementByRe(element, FLOATING_POINT_REGEXP, false, elementLabel, 'a number')) {
        if (element.value >= minValue
            && element.value <= maxValue) {
            valid = true;
        }
        else {
            alert('The value of ' + elementLabel
                  + ' is not in the range '
                  + minValue + '-' + maxValue
                  + '.');
            setFocus(element);
        }
    }
    return valid;
}

function validateFloatingPointOrBlankElementByRange(element, elementLabel, minValue, maxValue) {
    var valid = false;
    if (validateElementByRe(element, FLOATING_POINT_REGEXP, true, elementLabel, 'a number')) {
        if (!element.value || element.value.trim().length == 0) {
            valid = true;
        }
        else {
            if (element.value >= minValue
                && element.value <= maxValue) {
                valid = true;
            }
            else {
                alert('The value of ' + elementLabel
                      + ' is not in the range '
                      + minValue + '-' + maxValue
                      + '.');
                setFocus(element);
            }
        }
    }
    return valid;
}

function isNonBlank(value) {
    return value && ! ALL_BLANK_REGEXP.test(value.trim());
}

function isNonBlankElement(element) {
    var result = false;
    if (element) {
        trace('isNonBlankElement: id=' + element.id + ' type=' + element.type);
        if (element.type == 'text' || element.type == 'textarea' || element.type == 'hidden') {
            result = isNonBlank(element.value);
        }
        else {
            alert('Element ' + element.id + ' cannot be tested for blankness; not type text, textarea or hidden.');
        }
    }
    else {
        alert('isNonBlankElement: Element not found!');
    }
    return result;
}

function validateNonBlank(elementId, label) {
    return validateNonBlankElement(document.getElementById(elementId), label);
}

function validateNonBlankElement(element, label) {
    var valid = false;
    if (element) {
        if (isNonBlankElement(element)) {
            valid = true;
        }
        else {
            var divNode = getParentNode(element, "DIV");
            if (divNode) {
                showRetrievedElement(divNode);
            }
            
            setFocus(element);
            element.scrollIntoView();
            alert(label + ' is required.');
        }
    }
    else {
        alert('Element for ' + label + ' not found!');
    }
    return valid;
}

function fatal(message) {
    log(message, LOG_FATAL);
}

function error(message) {
    log(message, LOG_ERROR);
}

function warn(message) {
    log(message, LOG_WARN);
}

function info(message) {
    log(message, LOG_INFO);
}

function debug(message) {
    log(message, LOG_DEBUG);
}

function trace(message) {
    log(message, LOG_TRACE);
}

function log (message, level) {
    var dateString = null;
    var date = null;
    if (message != null
        && level != null) {
        date = new Date();
        if (typeof(date.format) == 'function') {
            dateString = date.format('%Y-%m-%d %H:%M:%S');
        }
        else {
            dateString = '' + date.getTime();
        }

        message = dateString + ': ' + message;
        if (typeof(window["console"]) != "undefined"
            && console && console.log) {
            if (level >= LOG_LEVEL) { 
                console.log(message);
            }
        }
        else {
            if (level > LOG_INFO) {
                alert(message);
            }
        }
    }
}

function isFirefox() {
    var re = /^.+Firefox.+$/;
    return re.test(navigator.userAgent);
}

function isIE() {
    var re = /^.+(MSIE|Trident).+$/;
    return re.test(navigator.userAgent);
}

function createOption(text, value, additionalText) {
    var option = document.createElement('option');
    if (ie) {

        // IE7 displays contents of label
        // attribute in SELECT.
        // IE6 uses text attribute.

        option.text = text;
        option.label = text;
    }
    else {
        option.text = text;
        option.label = additionalText;
    }
    option.value = value;
    return option;
}

function getEvent(e) {
    return e || window.event;
}

function getEventTarget(e) {
    var target = e.target || e.srcElement;
    if (target.nodeType == 3) {
        // deal with Safari bug
        target = target.parentNode;
    }
    return target;
}

function fireEvent(target, evtName, evtClass) {
    // courtesy codesnippets.joyent.com/posts/show/1654
    try {
        if (target.fireEvent) {
            // IE
            target.fireEvent('on' + evtName);
        }
        else if (document.createEvent) {
            // Mozilla
            var evt = document.createEvent(evtClass);
            if (evt.initEvent) {
                evt.initEvent(evtName, true, true);
            }
            if (target.dispatchEvent) {
                target.dispatchEvent(evt);
            }
        }
    }
    catch (e) {
        error("Error firing event: " + e);
    }
}

Array.max = function( array ){
    return Math.max.apply( Math, array );
};

Array.min = function( array ){
    return Math.min.apply( Math, array );
};

function getOptionTextByValue(element, value) {
    var optionText = null;
    
    if (element
        && element.nodeName.toUpperCase() == 'SELECT') {
        var options = element.options;
        for (var i = 0;
             i < options.length && !optionText;
             i++) {
            if (options[i].value == value) {
                optionText = options[i].text
                    || options[i].label;
            }
        }
    }
    return optionText;
}

function isOptionSelectedByValue(element, value) {
    var optionSelected = false;
    
    if (element
        && element.nodeName.toUpperCase() == 'SELECT') {
        var options = element.options;
        if (options) {
            for (var i = 0;
                 i < options.length && !optionSelected;
                 i++) {
                if (options[i].selected
                    && options[i].value == value) {
                    optionSelected = true;
                }
            }
        }
    }
    return optionSelected;
}

function setOptionSelectedByValue(element, value) {
    if (element
        && element.type.toUpperCase() == 'SELECT-ONE') {
        var options = element.options;
        if (options) {
            for (var i = 0;
                 i < options.length;
                 i++) {
                if (!options[i].selected
                    && options[i].value == value) {
                    element.selectedIndex = i;
                    break;
                }
            }
        }
    }
}

function setOptionSelectedByValueRegexp(element, re) {
    var selectedMatch = false;
    if (element
        && element.type.toUpperCase() == 'SELECT-ONE') {
        var options = element.options;
        if (options) {
            for (var i = 0;
                 i < options.length;
                 i++) {
                if (!options[i].selected
                    && options[i].value) { 
                    var match = re.exec(options[i].value);
                    if (match && match.length > 0) {
                        element.selectedIndex = i;
                        selectedMatch = true;
                        break;
                    }
                }
            }
        }
    }
    return selectedMatch;
}

function isOptionSelectedByText(element, text) {
    var optionSelected = false;
    
    if (element
        && element.nodeName.toUpperCase() == 'SELECT') {
        var options = element.options;
        var optionText = null;
        if (options) {
            for (var i = 0;
                 i < options.length && !optionSelected;
                 i++) {
                if (options[i].selected) {
                    optionText = options[i].text
                        || options[i].label;
                    if (optionText == text) {
                        optionSelected = true;
                    }
                }
            }
        }
    }
    return optionSelected;
}

function isOptionSelectedByRegexp(element, re) {
    var optionSelected = false;
    var match = null;
    
    if (element
        && element.nodeName.toUpperCase() == 'SELECT') {
        var options = element.options;
        var optionText = null;
        if (options) {
            for (var i = 0;
                 i < options.length && !optionSelected;
                 i++) {
                if (options[i].selected) {
                    optionText = options[i].text
                        || options[i].label;
                    match = re.exec(optionText);
                    if (match != null && match.length > 0) {
                        optionSelected = true;
                    }
                }
            }
        }
    }
    return optionSelected;
}

function getSelectedOptionByElement(el, startIndex) {
    var option = null;
    var index = getSelectedIndexByElement(el);
    if (index >= startIndex) {
        try {
            option = el.options[index];
        }
        catch (e) {
            option = null;
        }
    }
    return option;
}

function getSelectionTextByElement(el, startIndex) {
    var optionText = null;
    var option = getSelectedOptionByElement(el, startIndex);
    if (option != null) {
        optionText = option.text || option.label;
    }
    return optionText;
}

function getSelectedOptions(id) {
    return getSelectedOptionsByElement(document.getElementById(id));
}

function getSelectedOptionsByElement(element) {
    var selectedOptions = [];
    if (element && element.options) {
        for (var i = 0; i < element.options.length; i++) {
            if (element.options[i].selected) {
                selectedOptions[selectedOptions.length] = element.options[i];
            }
        }
    }
    return selectedOptions;
}

function setSelectedIndex(id, index) {
    setSelectedIndexByElement(document.getElementById(id),
                              index);
}


function getSelectedIndex(id) {
    return getSelectedIndexByElement(document.getElementById(id));
}

function setSelectedIndexByElement(el, index) {
    if (index != null && index >= 0) {
        if (el != null
            && el.type.toUpperCase() == 'SELECT-ONE'
            && el.options
            && index < el.options.length) {
            el.selectedIndex = index;
        }
    }
}

function getSelectedIndexByElement(el) {
    var index = -1;
    if (el != null
        && el.type.toUpperCase() == 'SELECT-ONE'
        && el.options) {
        index = el.selectedIndex;
    }
    return index;
}

function valueIsChecked(idArray, label) {
    var isChecked = false;
    var element = null;
    for (var i = 0; i < idArray.length; i++) {
        element = document.getElementById(idArray[i]);
        if (element) {
            if (element.type == 'checkbox') {
                if (element.checked) {
                    isChecked = true;
                }
            }
            else {
                alert('Element ' + idArray[i] + ' is not a checkbox.');
            }
        }
        else {
            alert('Element ' + idArray[i] + ' not found in document.');
        }
    }
    if (!isChecked) {
        alert('Please make a selection for ' + label + '.');
    }
    return isChecked;
}

function valueInRowIsChecked(idArray, label, recordType) {
    var isChecked = false;
    var element = null;
    if(document.getElementById(recordType).checked){
    for (var i = 0; i < idArray.length; i++) {
        element = document.getElementById(idArray[i]);
        if (element) {
            if (element.type == 'checkbox') {
                if (element.checked) {
                    isChecked = true;
                }
            }
            else {
                alert('Element ' + idArray[i] + ' is not a checkbox.');
            }
        }
        else {
            alert('Element ' + idArray[i] + ' not found in document.');
        }
    }

    if (!isChecked) {
        alert('Please make a selection for ' + label + '.');
    }

    }else{
        isChecked = true;
    }
    return isChecked;
}

function radioGroupHasSelection(baseName, elementCount, label) {
    var hasSelection = radioGroupHasSelectionQuiet(baseName, elementCount, label);
    if (!hasSelection) {
        alert('Please make a selection for ' + label + '.');
    }
    return hasSelection;
}

function radioGroupHasSelectionQuiet(baseName, elementCount, label) {
    var hasSelection = false;
    var elementId = null;
    var element = null;
    for (var i = 0; i < elementCount; i++) {
        elementId = baseName + i;
        element = document.getElementById(elementId);
        if (element) {
            if (element.type == 'radio') {
                if (element.checked) {
                    hasSelection = true;
                }
            }
            else {
                alert('Element ' + elementId + ' is not a radio button.');
            }
        }
        else {
            alert('Element ' + elementId + ' not found in document.');
        }
    }
    return hasSelection;
}

function unCheckElements(elementIds) {
    for (var i = 0; i < elementIds.length; i++) {
        unCheckElement(elementIds[i]);
    }
}

function checkElements(elementIds) {
    for (var i = 0; i < elementIds.length; i++) {
        checkElement(elementIds[i]);
    }
}

function unCheckElement(elementId) {
    setBooleanElement(elementId, false);
}

function checkElement(elementId) {
    setBooleanElement(elementId, true);
}

function setBooleanElement(elementId, value) {
    var element = document.getElementById(elementId);
    if (element
        && (element.type == 'checkbox'
            || element.type == 'radio')) {
        element.checked = value;
    }
}

//
// fit a TEXTAREA to show all rows with a configurable
// number of rows hidden.
//
function fitTextArea(elementId, rowsHidden, minRows) {
    var element = document.getElementById(elementId);
    if (element && element.type == "textarea") {
        if (element.value) {
            //var lineCount = element.value.split("\n").length;
            var lineCount = element.value.length / element.cols + 1;
            trace("elementId=" + elementId + " lineCount=" + lineCount);
            var newRows = lineCount - rowsHidden;
            if (newRows > minRows) {
                element.rows = newRows;
            }
        }
    }
}

function handleTextAreaKeyUp(element, minRows) {
    trace("handleTextAreaKeyUp: element.id=" + element.id);
    if (element && minRows)
    {        
        var lines = element.value.split('\n');
        var lineCount = 0;
        for (var i = 0; i < lines.length; i++) {
            if (lines[i].length == 0) {
                lineCount++;
            }
            else {
                lineCount += divide(lines[i].length, element.cols);
                if (lines[i].length % element.cols > 0) {
                    lineCount++;
                }
            }
            trace("lines[" + i + "].length=" + lines[i].length + " element.cols=" + element.cols
                  + " lineCount=" + lineCount);
        }
        lineCount++;
        trace("lineCount=" + lineCount + " minRows=" + minRows + " current rows=" + element.rows);
        if (lineCount != element.rows
            && lineCount >= minRows) {
            element.rows = lineCount;
            trace("set rows to " + element.rows);
        }
    }
}

//
// clear a text element
//
function clearTextElement(elementId) {
    var element = document.getElementById(elementId);
    if (element && (element.type == 'text'
                    || element.type == 'textarea')) {
        element.value = '';
    }
}

//
// find index of first checked element in list
// of elements given list of ids
//

function findFirstChecked(elementIdList) {
    var gotChecked = false;
    for (var i = 0; i < elementIdList.length && !gotChecked; i++) {
        gotChecked = document.getElementById(elementIdList[i]).checked;
    }
    return gotChecked ? i : -1;
}

function getChildByNodeName(divElement, nodeName) {
    var nodes = getChildrenByNodeNames(divElement, [nodeName]);
    return nodes && nodes.length > 0 ? nodes[0] : null;
}

function getChildrenByNodeName(divElement, nodeName) {
    var nodes = getChildrenByNodeNames(divElement, [nodeName]);
    return nodes && nodes.length > 0 ? nodes : null;
}

function getChildByNodeNames(divElement, nodeNames) {
    var nodes = getChildrenByNodeNames(divElement, nodeNames);
    return nodes && nodes.length > 0 ? nodes[0] : null;
}

function getChildrenByNodeNames(divElement, nodeNames) {
    trace('getChildByNodeNames divElement='
          + divElement + ' target nodeNames=' + nodeNames);
    var childNodes = [];
    if (nodeNames && nodeNames.length > 0
        && divElement && divElement.childNodes
        && divElement.childNodes.length > 0) {
        for (var i = 0;
             i < divElement.childNodes.length;
             i++) {
            trace('i=' + i
                  + ' divElement.childNodes[' + i + ']='
                  + divElement.childNodes[i]
                  + ' divElement.childNodes[' + i + '].nodeName='
                  + divElement.childNodes[i].nodeName);

            for (var j = 0;
                 j < nodeNames.length;
                 j++) {
                trace('nodeNames[' + j + ']=' + nodeNames[j]);
                if (divElement.childNodes[i].nodeName.toUpperCase() == nodeNames[j].toUpperCase()) {
                    childNodes[childNodes.length] = divElement.childNodes[i];
                }
            }
        }
    }
    for (var i = 0; i < childNodes.length; i++) {
        trace('childNodes[' + i + '].nodeName=' + childNodes[i].nodeName);
    }
    return childNodes;
}

function divide(numerator, denominator) {
    // In JavaScript, dividing integer values yields a floating point
    // result (unlike in Java, C++, C).  To find the integer quotient,
    // reduce the numerator by the remainder first, then divide.
    // Idea is from code at 
    // https://www.augustana.ca/~mohrj/courses/2000.fall/csc110/JavaScript/examples/integer_division.html
    // which, incidentally, did not check the denominator for 0.
    
    var quotient = null;
    if (numerator && denominator
        && NUMERIC_REGEXP.test(numerator)
        && NUMERIC_REGEXP.test(denominator)
        && denominator != 0) {
        var remainder = numerator % denominator;
        quotient = ( numerator - remainder ) / denominator;
    }
    return quotient;
}

function formatDate(date) {
    var month = 1 + date.getMonth();
    var day = date.getDate();
    var year = date.getFullYear();
    var formattedDate = (month < 10 ? '0' : '') + month
        + '/' + (day < 10 ? '0' : '') + day
        + '/' + year;
    return formattedDate;
}

function formatTime(date) {
    var hours = date.getHours();
    var minutes = date.getMinutes();
    var seconds = date.getSeconds();
    var formattedTime = (hours < 10 ? '0' : '') + hours
        + ':' + (minutes < 10 ? '0' : '') + minutes;
    //        + ':' + (seconds < 10 ? '0' : '') + seconds;
    return formattedTime;
}

function isHidden(divElementId) {
    var element = document.getElementById(divElementId);
    return element
        && element.nodeName
        && element.nodeName.toUpperCase() == 'DIV'
        && element.style
        && element.style.visibility == 'hidden';
}

function isVisible(divElementId) {
    var isVisible = false;
    var element = document.getElementById(divElementId);
    return element
        && element.nodeName
        && element.nodeName.toUpperCase() == 'DIV'
        && element.style
        && element.style.visibility == 'visible';
}

function isElementHidden(element) {
    return element
        && element.style
        && element.style.visibility == 'hidden';
}

function isElementVisible(element) {
    return element
        && element.style
        && element.style.visibility == 'visible';
}

function dataExists(elementIds) {
    var result = false;
    var element = null;
    for (var i = 0; i < elementIds.length && !result; i++) {
        element = document.getElementById(elementIds[i]);
        if (element) {
            if (/^txt.+/.test(elementIds[i])) {
                result = isNonBlankElement(element);
            }
            else if (/^rad.+/.test(elementIds[i])
                     || /^cb.+/.test(elementIds[i])) {
                result = element.checked;
            }
        }
    }
    return result;
}

// from https://www.netlobo.com/javascript_select_onchange.html
// executes an onchange function after 750ms (or specified delay)
// prevents multiple executions of onchange code when user happens to
// have focus set to a select box and scrolls with mouse scroll-wheel.

// After an option is selected the safeOnChange function will wait
// for 750ms and if another option has not been chosen it will execute
// the code passed into it.

function safeOnChange( code, delay ) {
    delay = delay || 750;
    window.clearTimeout( soc_id );
    soc_id = window.setTimeout( code, delay );
}
// global timer ID for the safeOnChange function.
var soc_id = null;

function inspectRadioElement(element) {
    alert(element.id + '=' + element.checked);
}

function toggleElementDisabled(id, state) {
    var element = document.getElementById(id);
    if (element) {
        element.disabled = state;
    }
}

function getElementsByIdMatch(form, re) {
    var elements = form.elements;
    var matchingElements = [];
    for (var i = 0; i < elements.length; i++) {
        if (exists(elements[i])) {
            if (elements[i].id != null) {
                var match = re.test(elements[i].id);
                if (match == true) {
                    matchingElements[matchingElements.length]
                        = elements[i];
                }
            }
        }
    }
    return matchingElements;
}

function setRadioGroupDefault(group, defaultValue) {
    if (group) {
        var hasChoice = false;
        var defaultElement = null;
        for (var i = 0; i < group.length; i++) {
            if (group[i].checked) {
                hasChoice = true;
            }
            if (group[i].value == defaultValue) {
                defaultElement = group[i];
            }
        }
        if (!hasChoice && defaultElement) {
            defaultElement.checked = true;
        }
    }
}

// assumes group member ids are base + digit, numbered sequentially
// starting at startingIndex, with memberCount members, where digit
// corresponds to value which should trigger that group member being
// checked.

function setRadioGroupByIdBase(groupIdBase, value, startingIndex, memberCount) {
    var element = null;
    var elementId = null;
    var count = 0;
    var index = startingIndex;
    for (; count < memberCount;
         count++, index++) {
        elementId = groupIdBase + index;
        element = document.getElementById(elementId);
        if (element != null) {
            element.checked = (index == value);
        }
    }
}

function setSelectByIdBase(groupIdBase, value, startingIndex, memberCount){
    var element = null;
    var elementId = null;
    var count = 0;
    var index = startingIndex;
    for (; count < memberCount;
         count++, index++) {
        elementId = groupIdBase;
        element = document.getElementById(elementId).options[index];
        if (element != null) {
            element.selected = (index == value);
        }
    }
}

function setTextElementSafely(elementId, value) {
    var element = document.getElementById(elementId);
    if (element != null) {
        if (value && value != null) {
            element.value = value;
        }
        else {
            element.value = '';
        }
    }
}

// returns the trailing number of a string.
// useful with numbered element Ids.
function getTrailingNumber(elementId) {
    var index = -1;
    var match = /^[a-zA-Z]+([0-9]+)/.exec(elementId);
    if (match && match.length > 1) {
        index = match[1];
    }
    return index;
}

function cursorPosition(element) {
    var cursorPosition = null;
    element.focus();
    var debugging = false;
    
    // get selection in firefox, opera, …

    if (typeof(element.selectionStart) == 'number') {
        cursorPosition = element.selectionStart;
    }
    else if (document.selection) {
        
        cursorPosition = cursorPosition2(element);

        // calls to setEndPoint() were producing
        // invalid argument errors for text boxes
        // so we're ditching this code.
        
//         var selection_range = document.selection.createRange().duplicate();
//         if (debugging) { alert('got selection range'); }
        
//         // Check that the selection is actually in our element
//         if (selection_range.parentElement() == element)
//         {
//             // Create three ranges, one containing all the text before the selection,
//             // one containing all the text in the selection (this already exists), and one containing all
//             // the text after the selection.
//             var before_range = document.body.createTextRange();
//             if (debugging) { alert('got before range'); }
//             // Selects all the text
//             before_range.moveToElementText(element); 
//             // Moves the end where we need it
//             if (before_range.setEndPoint)
//             {
//                 before_range.setEndPoint("EndToStart", selection_range);
//             }
            
//             var after_range = document.body.createTextRange();
//             // Selects all the text
//             after_range.moveToElementText(element); 
//             // Moves the start where we need it
//             if (after_range.setEndPoint)
//             {
//                 after_range.setEndPoint("StartToEnd", selection_range);
//             }

//             var before_finished = false;
//             var selection_finished = false;
//             var after_finished = false;
//             var before_text = null;
//             var untrimmed_before_text = null;
//             var selection_text = null;
//             var untrimmed_selection_text = null;
//             var after_text = null;
//             var untrimmed_after_text = null;

//             // Load the text values we need to compare
//             before_text = untrimmed_before_text = before_range.text;
//             selection_text = untrimmed_selection_text = selection_range.text;
//             after_text = untrimmed_after_text = after_range.text;

//             // Check each range for trimmed newlines by shrinking the range by 1 character and seeing
//             // if the text property has changed. If it has not changed then we know that IE has trimmed
//             // a \r\n from the end.
//             do {
//                 if (!before_finished)
//                 {
//                     if (before_range.compareEndPoints("StartToEnd", before_range) == 0)
//                     {
//                         before_finished = true;
//                     } else {
//                         before_range.moveEnd("character", -1)
//                         if (before_range.text == before_text)
//                         {
//                             untrimmed_before_text += "\r\n";
//                         }
//                         else
//                         {
//                             before_finished = true;
//                         }
//                     }
//                 }
//                 if (!selection_finished)
//                 {
//                     if (selection_range.compareEndPoints("StartToEnd", selection_range) == 0)
//                     {
//                         selection_finished = true;
//                     }
//                     else
//                     {
//                         selection_range.moveEnd("character", -1)
//                         if (selection_range.text == selection_text) {
//                             untrimmed_selection_text += "\r\n";
//                         } else {
//                             selection_finished = true;
//                         }
//                     }
//                 }
//                 if (!after_finished)
//                 {
//                     if (after_range.compareEndPoints("StartToEnd", after_range) == 0)
//                     {
//                         after_finished = true;
//                     }
//                     else
//                     {
//                         after_range.moveEnd("character", -1)
//                         if (after_range.text == after_text)
//                         {
//                             untrimmed_after_text += "\r\n";
//                         }
//                         else
//                         {
//                             after_finished = true;
//                         }
//                     }
//                 }
//             } while ((!before_finished || !selection_finished || !after_finished));

//             // Untrimmed success test to make sure our results match what is actually in the element
//             // This can be removed once you’re confident it’s working correctly
//             var untrimmed_text = untrimmed_before_text + untrimmed_selection_text + untrimmed_after_text;
//             var untrimmed_successful = false;
//             if (element.value == untrimmed_text)
//             {
//                 untrimmed_successful = true;
//             }
//             // ** END Untrimmed success test

//             cursorPosition = untrimmed_before_text.length;
//        }
    }
    return cursorPosition;
}

// code from https://topic.csdn.net/t/20020130/09/507998.html
// and https://forums.asp.net/t/1304151.aspx 
function cursorPosition2(txt1) {
    //var txt1=document.getElementById("TextBox1");
    
    var currentRange=document.selection.createRange();  
    var workRange=currentRange.duplicate();
    txt1.select();
    var allRange=document.selection.createRange();
    var len=0;  
    
    while(workRange.compareEndPoints("StartToStart",allRange)>0)  
    {  
        workRange.moveStart("character",-1);  
        len++;  
    }  
    
    currentRange.select();  
    
    //        window.alert(len);
    return len;
}
 
function getFormElementsAsParameterString(form) {
    var parameterString = '';
    if (form && form.elements) {
        var elementCount = form.elements.length;
        var element = null;
        var elementType = null;
        var elementParameterString = null;
        var elementValue = null;
        for (var i = 0; i < elementCount; i++) {
            element = form.elements[i];
            elementType = element.type.toUpperCase();
            elementParameterString = null;
            elementValue = null;
            if (/(TEXT(AREA|)|HIDDEN|BUTTON)/.test(elementType)) {
                elementValue = element.value;
            }
            else if (elementType == 'SELECT-ONE') {
                elementValue = element.options[element.selectedIndex].value;
            }
            else if (elementType == 'SELECT-MULTIPLE') {
                var options = element.options;
                var optionCount = options.length;
                for (var i = 0; i < optionCount; i++) {
                    if (options[i].selected) {
                        if (elementParameterString) {
                            elementParameterString += '&';
                        }
                        else {
                            elementParameterString = '';
                        }
                        elementParameterString += element.name
                            + '=' + encodeURIComponent(options[i].value);
                    }
                }
            }
            else if (elementType == 'RADIO') {
                if (element.checked) {
                    elementValue = element.value;
                }
            }
            else if (elementType == 'CHECKBOX') {
                if (element.checked) {
                    elementValue = element.value || 'on';
                }
            }
            else {
                error('Unexpected element type: ' + elementType);
            }
            if (elementValue != null && elementValue != 'null') {
                // shouldn't get here in case of multi-select
                elementParameterString = element.name
                    + '=' + encodeURIComponent(elementValue);
            }
            if (elementParameterString && elementParameterString != 'null') {
                if (parameterString && parameterString.length > 0) {
                    parameterString += '&';
                }
                parameterString += elementParameterString;
            }
        }
    }
    return parameterString;
}

// from https://webforumz.com/blogs/spinal007/random-string-in-javascript-210/
function rnd(){ return String((new Date()).getTime()).replace(/\D/gi,'') }

// from https://stackoverflow.com/questions/960293/window-open-returns-undefined-or-null-on-2nd-call
function openWindow(url, name, props) {
    if (document.all){ //do this only in IE
        var windowRef = window.open("", name, props);
        if (windowRef != null) {
            windowRef.close();
        }
    }
    var windowRef = window.open(url, name, props);
    if (windowRef == null) {
        alert('Could not open window to url ' + url);
    } else {
        if (!windowRef.opener) {
            windowRef.opener = self;
        }
        windowRef.focus();
    }
    return windowRef;
}

function openWindow(target, windowName, width, height) {
  window.open(target, windowName,'scrollbars=yes,width=' + width
              + ',height=' + height + ',resizable=yes,menubar=no,toolbar=no');
    return false;
}

function toHex(value) {
    var hexValue = '';
    var remainder = 0;
    var digit = '';
    var hexDigits = 'ABCDEF';
    if (value != null) {
        while (value > 0) {
            remainder = value & 15;
            if (remainder < 10) {
                digit = '' + remainder;
            }
            else if (remainder < 16) {
                digit = hexDigits[remainder - 10];
            }
            hexValue = digit + hexValue;
            value = value >> 4;
        }
    }
    return hexValue;
}

function generateRandomHexString(length) {
    var rndString = '';
    var rndValue = 0;
    var hexValue = '';
    if (length != null) {
        while (rndString.length < length) {
            rndValue = Math.floor(10000000000 * Math.random());
            hexValue = toHex(rndValue);
            rndString += hexValue;
        }
    }
    return rndString;
}

function round(number, digitsAfterDecimal) {
    var rounded = NaN;
    if (number != null
        && digitsAfterDecimal != null) {
        try {
            if (number == 0) {
                rounded = 0;
            }
            else if (digitsAfterDecimal == 0) {
                rounded = Math.round(number);
            }
            else {
                var scale = Math.pow(10, digitsAfterDecimal);
                rounded = Math.round(number * scale)/scale;
            }
        }
        catch (e) {
        }
    }
    return rounded;
}

Number.prototype.round = function(digitsAfterDecimal) {
    var n = this;
    if (this != null && !isNaN(this)) {
        n = round(this, digitsAfterDecimal);
    }
    return n;
}

// createRandom... functions are
// based on https://www.mauvecloud.net/textgen.html

function createRandomAlphaNumericString(minsize, maxsize) {
    var alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
    var alnum = alpha + '0123456789';
    return createRandomText(alpha, alnum, minsize, maxsize);
}

function createRandomText(startvalid, validchars, minsize, maxsize) {
    var textout = '';
    var count = 0;
    var actualsize = 0;
    if (minsize <= 0)
    {
        window.alert("Minimum Text Size must be at least 1!");
        return;
    }
    if (maxsize < minsize)
    {
        window.alert("Maximum Text Size cannot be smaller than Minimum!");
        return;
    }

    actualsize = Math.floor(Math.random() * (maxsize - minsize + 1)) + minsize;
    textout = startvalid.charAt(Math.floor(Math.random() * startvalid.length));
    for (count = 1; count < actualsize; count++) {
        textout += validchars.charAt(Math.floor(Math.random()
                                                * validchars.length));
    }
    return textout;
}

function sleep(millis) {
    var start=new Date();
    for (var end=start; end-start<millis; end=new Date()) {}
}

function exists(thing) {
    var exists = false;
    if (typeof(thing) != 'undefined'
        && thing != null) {
        exists = true;
    }
    return exists;
}

function setProperty(element, property, value) { 
    if (exists(element)) {
        element.prop(property, value);
    }
}

function resetCookieMap() {
    cookieMap = [];
    var cookieString = document.cookie;
    if (cookieString != null && cookieString.length > 0) {
        var cookieList =  cookieString.split(';');
        for (index = 0; index < cookieList.length; index++) {
            var cookiePair = cookieList[index].split('=');
            if (cookiePair != null && cookiePair.length == 2) {
                setCookie(cookiePair[0], cookiePair[1]);
            }
        }
    }
}

function getCookie(name) {
    var value = null;
    if (cookieMap == null) {
        resetCookieMap();
    }
    if (name != null) {
        value = cookieMap[name.trim()];
    }
    return value;
}

function setCookie(name, value) {
    if (cookieMap == null) {
        resetCookieMap();
    }
    if (cookieMap != null
        && name != null 
        && name.length > 0) {
        cookieMap[name.trim()] = value;
    }
}

// add rows to tables when the rows contain form widgets
function addInputRow(divElementId, offset)
{
    addInputRow(divElementId, offset, false);
}

function addInputRow(divElementId, offset, discharge)
{
    return addMatchingInputRow(divElementId, offset, null, discharge);
}

// adds input row to table inside
// div w/passed-in element id
// divElementId: id of div containing table.
// offset: number of rows before last row
//         at which to insert the new row.
// elementPattern: if non-null, is pattern which one id 
//                 must match in order for row to be duplicated.
function addMatchingInputRow(divElementId, offset, elementPattern, discharge)
{
    trace('addMatchingInputRow offset=' + offset);
    var focusTarget = null;
    var divElement = document.getElementById(divElementId);
    if (divElement && divElement.childNodes && divElement.childNodes.length > 0)
    {
        var formDataTable = getChildByNodeName(divElement, 'TABLE');
        if (formDataTable)
        {
            var lastFieldRowIndex = -1;
            var lastFieldRow = null;
            var lastFieldRowCells = null;
            trace('formDataTable=' + formDataTable);
            var inputElements = [];
            var tbody = getChildByNodeName(formDataTable, "TBODY");
            trace('tbody=' + tbody);
            var rowCount = -1;
            var inputElementsForCell = [];
            var inputElementIdSuffix = 0;
            var lastRow = 0;
            if (tbody && tbody.childNodes && tbody.childNodes.length > 0)
            {
                var trows = getChildrenByNodeName(tbody, "TR");
                trace('trows=' + trows);
                rowCount = trows.length;
                if (rowCount > 0)
                {
                    var currentRow = null;
                    var cells = null;
                    var lastFieldRowIndex = -1;
                    var fieldRowCount = 0;
                    lastFieldRowIndex = -1;
                    for (var rowIndex = 0;
                         rowIndex < rowCount;
                         rowIndex++)
                    {
                        currentRow = trows[rowIndex];
                        cells = getChildrenByNodeName(currentRow, "TD");
                        if (cells)
                        {
                            trace("rowIndex=" + rowIndex + " cells.length=" + cells.length);
                        }
                        else
                        {
                            trace("rowIndex=" + rowIndex + " cells is null!");
                        }
                        inputElementsForCell = [];
                        for (var i = 0;
                             i < cells.length;
                             i++)
                        {
                            inputElementsForCell
                                = getChildrenByNodeNames(cells[i], ['INPUT', 'SELECT', '#text']);
                            for (var j = inputElementsForCell.length - 1;
                                 j >= 0; j--)
                            {
                                if (inputElementsForCell[j].nodeName == '#text'
                                    && inputElementsForCell[j].data == '\n')
                                {
                                    inputElementsForCell.splice(j, 1);
                                }
                            }
                                    
                            
                            if (inputElementsForCell.length > 0)
                            {
                                fieldRowCount++;
                                var match = /([0-9]+)$/.exec(inputElementsForCell[0].id);
                                if (match && match.length > 0)
                                {
                                    var rowIsOk = false;
                                    if (elementPattern == null)
                                    {
                                        rowIsOk = true;
                                    }
                                    else
                                    {
                                        for (var j = 0;
                                             j < inputElementsForCell.length && !rowIsOk;
                                             j++)
                                        {
                                            rowIsOk = elementPattern.test(inputElementsForCell[j].id);
                                        }
                                    }
                                    if (rowIsOk)
                                    {
                                        lastFieldRowIndex = rowIndex;
                                        inputElementIdSuffix = parseInt(match[1]);
                                    }
                                }
                            }
                        }
                    }
                    trace("lastFieldRowIndex=" + lastFieldRowIndex
                          + " inputElementIdSuffix=" + inputElementIdSuffix);

                    if (lastFieldRowIndex == 99) {
                        var btnAddInterruption = document.getElementById("btnAddInterruption");
                        btnAddInterruption.className = "AssessBtn";
                        btnAddInterruption.disabled = true;
                        return true;
                    }
                    
                    if (lastFieldRowIndex >= 0)
                    {
                        lastFieldRow = trows[lastFieldRowIndex];
                        lastFieldRowCells = getChildrenByNodeName(lastFieldRow, "TD");
                        if (lastFieldRowCells)
                        {
                            trace("lastFieldRowCells.length=" + lastFieldRowCells.length);
                            inputElementsForCell = [];
                            for (var i = 0; i < lastFieldRowCells.length; i++)
                            {
                                inputElementsForCell
                                    = getChildrenByNodeNames(lastFieldRowCells[i], ['INPUT', 'SELECT', '#text']);
                                for (var j = inputElementsForCell.length - 1;
                                     j >= 0; j--)
                                {
                                    if (inputElementsForCell[j].nodeName == '#text'
                                        && inputElementsForCell[j].data == '\n')
                                    {
                                        inputElementsForCell.splice(j, 1);
                                    }
                                }
                                trace("inputElementsForCell " + i + ":"
                                      + inputElementsForCell);
                                inputElements[inputElements.length]
                                    = inputElementsForCell;
                            }
                        }
                        else
                        {
                            trace("lastFieldRowCells is null!");
                        }
                    }
                }
                lastRow = lastFieldRowIndex;
                trace('inputElements=' + inputElements);
                trace('rowCount=' + rowCount);
            }
            var newRowIndex = rowCount - offset;

            var newInputElementIdSuffix;

            if (discharge) {
                newInputElementIdSuffix = lastRow;
            } else {
                newInputElementIdSuffix = inputElementIdSuffix + 1;
            }

            if (inputElements.length > 0)
            {
                var row = formDataTable.insertRow(newRowIndex);
                inputElementsForCell = [];
                for (var i = 0; i < inputElements.length; i++)
                {
                    inputElementsForCell = inputElements[i];
                    trace('cell ' + i + ':' + inputElementsForCell.length + ' elements.');
                    var cell = row.insertCell(i);
                    var modelCell = lastFieldRowCells[i];
                    cell.vAlign = modelCell.vAlign;
                    //cell.class = modelCell.class;
                    cell.bgColor = modelCell.bgColor;
                    var radioElements = 0;
                    var wantStateCopy = false;
                    for (var j = 0; j < inputElementsForCell.length; j++)
                    {
                        wantStateCopy = false;
                        if (inputElementsForCell[j].nodeName == '#text')
                        {
                            var nodeValue = inputElementsForCell[j].nodeValue;
                            if (/^[\n\r]+$/.test(nodeValue))
                            {
                                continue;
                            }
                            cell.appendChild(document.createTextNode(inputElementsForCell[j].nodeValue));
                        }
                        else
                        {
                            var inputElement = document.createElement(inputElementsForCell[j].nodeName);
                            inputElement.id = inputElementsForCell[j].id.replace(/[0-9]+$/, newInputElementIdSuffix); 
                            inputElement.name = inputElementsForCell[j].name.replace(/[0-9]+$/, newInputElementIdSuffix);
                            if (inputElementsForCell[j].className === "hasDatepicker"){
                                $(inputElement).datepicker({ changeYear: true , changeMonth: true, yearRange: '-100:+5', showOn:'focus'});
                                $(inputElement).attr('placeholder', 'mm/dd/yyyy');
                            } else {
                                inputElement.className = inputElementsForCell[j].className;
                            }
                            inputElement.readonly = inputElementsForCell[j].readonly;
                            //inputElement.style = inputElementsForCell[j].style;
                            // check if we should copy the value
                            var wantStateCopyId = inputElementsForCell[j].id + 'WantStateCopy';
                            var wantStateCopyElement = document.getElementById(wantStateCopyId);
                            wantStateCopy = wantStateCopyElement;
                            if (inputElementsForCell[j].tabIndex > 0) {
                                inputElement.tabIndex = inputElementsForCell[j].tabIndex + inputElements.length;
                            }
                            if (inputElementsForCell[j].onchange)
                            {
                                inputElement.onchange = inputElementsForCell[j].onchange;
                            }
                            if (inputElementsForCell[j].onclick)
                            {
                                inputElement.onclick = inputElementsForCell[j].onclick;
                            }
                            if (inputElementsForCell[j].onkeyup)
                            {
                                inputElement.onkeyup = inputElementsForCell[j].onkeyup;
                            }
                            trace('inputElement.id=' + inputElement.id 
                                  + ' inputElement.name=' + inputElement.name
                                  + ' inputElement.type=' + inputElement.type
                                  + ' inputElement.className=' + inputElement.className);
                            if (inputElement.nodeName == 'INPUT')
                            {
                                inputElement.type = inputElementsForCell[j].type;
                                if (inputElement.type == 'text')
                                {
                                    if (inputElementsForCell[j].size
                                        && inputElementsForCell[j].size > 0)
                                    {
                                        inputElement.size = inputElementsForCell[j].size;
                                    }
                                    if (inputElementsForCell[j].maxLength
                                        && inputElementsForCell[j].maxLength > 0)
                                    {
                                        inputElement.maxLength = inputElementsForCell[j].maxLength;
                                    }
                                    trace(' inputElement.size=' + inputElement.size);
                                    trace(' inputElement.maxLength=' + inputElement.maxLength);
                                    if (wantStateCopy)
                                    {
                                        inputElement.value = inputElementsForCell[j].value;
                                    }
                                }
                                else if (inputElement.type == 'radio')
                                {
                                    inputElement.value = inputElementsForCell[j].value;
                                    inputElement.checked = false;
                                    if (wantStateCopy)
                                    {
                                        inputElement.checked = inputElementsForCell[j].checked;
                                    }
                                    radioElements++;
                                }
                                else if (inputElement.type == 'checkbox')
                                {
                                    if (wantStateCopy)
                                    {
                                        inputElement.checked = inputElementsForCell[j].checked;
                                    }
                                }
                            }
                            else if (inputElement.nodeName == 'SELECT')
                            {
                                var oldOptions = inputElementsForCell[j].options;
                                var newOptions = inputElement.options;
                                for (var k = 0; k < oldOptions.length; k++)
                                {
                                    var option = createOption(
                                        //ie ? oldOptions[k].label : oldOptions[k].text,
                                        oldOptions[k].text,
                                        oldOptions[k].value,
                                        oldOptions[k].label);
                                    if (wantStateCopy)
                                    {
                                        option.selected = oldOptions[k].selected;
                                    }
                                    newOptions[newOptions.length] = option;
                                    trace('option text=' + option.text
                                          + ' value=' + option.value
                                          + ' label=' + option.label);
                                }
                            }
                            cell.appendChild(inputElement);
                            if (focusTarget == null &&
                                !(inputElement.nodeName == 'INPUT'
                                  && inputElement.type.toUpperCase() == 'HIDDEN'))
                            {
                                focusTarget = inputElement;
                            }
                        }
                    } // loop over inputElementsForCell
                } // loop over inputElements 
            } // if (inputElements.length > 0)
        } // if (formDataTable)
    } // if (divElement ...)
    if (focusTarget != null)
    {
        setFocus(focusTarget);
    }
}

function updateTextStatusFromControllerById(controllerId, textElementId)
{
    updateTextInputStatusFromController(document.getElementById(controllerId),
                                        document.getElementById(textElementId));
}

function updateTextStatusFromController(controller, textElement)
{
    if (exists(textElement)
        && textElement.type == 'text'
        && exists(controller)) {

        if (controller.type == 'radio'
            || controller.type == 'checkbox') {
            textElement.disabled
                = controller.checked == false;
        }
        else if (controller.type.toUpperCase() == 'SELECT-ONE') {
            textElement.disabled
                = !isOptionSelectedByText(controller, 'Other');
        }
    }
}

function updateTextStatusAndHiddenFromController(controller, textElement, hidElement)
{
    if (exists(hidElement)
        && hidElement.type == 'hidden') {
        updateTextStatusFromController(controller, textElement);
        if (textElement.disabled) {
            hidElement.value = textElement.value;
        }
    }
}

function updateTextStatusFromControllerByPattern(controller, textElement, pattern)
{
    if (exists(textElement)
        && textElement.type == 'text'
        && exists(controller)) {

        if (controller.type.toUpperCase() == 'SELECT-ONE') {
            textElement.disabled
                = !isOptionSelectedByRegexp(controller, pattern);
        }
    }
}

function updateTextsFromControllerByPattern(controller, textElement, hidElement, pattern)
{
    if (exists(hidElement)
        && hidElement.type == 'hidden') {
        updateTextStatusFromControllerByPattern(controller, textElement, pattern);
        if (textElement.disabled) {
            hidElement.value = textElement.value;
        }
    }
}

function updateTextFromSelect(selectElement, textElement) {
    if (exists(textElement)
        && textElement.type == 'text'
        && exists(selectElement)
        && selectElement.type.toUpperCase() == 'SELECT-ONE') {
        var options = getSelectedOptionsByElement(selectElement);
        if (options != null
            && options.length > 0) {
            var textValue = options[0].text || options[0].label;
            if (textValue.toLowerCase().indexOf("select one") < 0) {
                textElement.value = textValue;
            }
        }
    }
}

function updateTextFromText(srcTextElement, dstTextElement) {
    if (exists(dstTextElement)
        && dstTextElement.type == 'text'
        && exists(srcTextElement)
        && srcTextElement.type == 'text') {
        dstTextElement.value = srcTextElement.value;
    }
}
        
function updateChoiceFromTextById(textElementId, choiceElementId) {
    updateChoiceFromText(document.getElementById(textElementId),
                         document.getElementById(choiceElementId));
}

function updateChoiceFromText(textElement, choiceElement) {
    if (exists(textElement)
        && textElement.type == 'text'
        && exists(choiceElement)
        && (choiceElement.type == 'radio'
            ||  choiceElement.type == 'checkbox')) {
        choiceElement.checked
            = textElement.value.length > 0;
    }
}

function updateAssociatedTexts(controller,
                               textElements,
                               controllerLabel,
                               previousControllerState) {
    try {
        if (exists(controller)
            && exists(textElements)) {
            if (!exists(controllerLabel)) {
                controllerLabel = "Controller";
            }
            
            if (controller.type.toUpperCase() == "SELECT-ONE") {
                if (exists(previousControllerState)) {
                    var options = controller.options;
                    var selectedIndex = controller.selectedIndex;
                    if (options != null
                        && selectedIndex != null
                        && selectedIndex >= 0
                        && selectedIndex < options.length) {

                        // find the index with a corresponding text-element which is not
                        // empty.  there should be at most one, so take the first.

                        // if there is no text-element index: just 
                        //   make the corresponding text element
                        //   writeable.

                        // if there is a text-element index:
                        //   if the index is the same as the selected index, do nothing.  (this shouldn't happen
                        //   if this function is called as an onChange handler. 

                        //   if the text-el. index is different thn the
                        //     selected index, show the confirmation
                        //     dialog.

                        //   if confirmation is received, clear current text-el and set
                        //     it to readonly. 
                        //     make the text-el corresponding to selected index writeable. 
                        //     save controller state in hidden variable for next time. 

                        //   if confirmation is not received restore controller state.  

                        var wantRestore = false;
                        var currentTextElement = null;
                        var nonBlankTextIndex = -1;
                        var nonBlankTextElement = null;

                        for (var index = 0; 
                             index < textElements.length
                             && nonBlankTextIndex < 0;
                             index++) {

                            currentTextElement = textElements[index];
                            if (currentTextElement != null) {
                                if (currentTextElement.value
                                    && currentTextElement.value.trim().length > 0) {
                                    nonBlankTextIndex = index;
                                    nonBlankTextElement = currentTextElement;
                                }
                            }
                        }

                        var selectedTextElement = textElements[selectedIndex];
                        if (nonBlankTextIndex < 0) {
                            for (var index = 0; 
                                 index < textElements.length;
                                 index++) {

                                currentTextElement = textElements[index];
                                if (currentTextElement != null) {
                                    currentTextElement.readonly = index != selectedIndex;
                                    currentTextElement.disabled = index != selectedIndex;
                                }
                            }
                        }
                        else {
                            if (nonBlankTextIndex == selectedIndex) {
                                // We end up here when the form is first loaded. 
                                for (var index = 0; 
                                     index < textElements.length;
                                     index++) {

                                    currentTextElement = textElements[index];
                                    if (currentTextElement != null) {
                                        currentTextElement.readonly = index != selectedIndex;
                                        currentTextElement.disabled = index != selectedIndex;
                                    }
                                }
                            }
                            else {
                                if (confirm("Changing your selection for '"
                                            + controllerLabel
                                            + "' will clear the text '"
                                            + nonBlankTextElement.value
                                            + "'.  Continue?")) {
                                    nonBlankTextElement.value = '';
                                    fireEvent(nonBlankTextElement, 'change', 'HTMLEvents');
                                    nonBlankTextElement.readonly = true;
                                    nonBlankTextElement.disabled = true;

                                    if (exists(selectedTextElement)) {
                                        selectedTextElement.readonly = false;
                                        selectedTextElement.disabled = false;
                                    }
                                }
                                else {
                                    wantRestore = true;

                                    if (exists(selectedTextElement)) {
                                        selectedTextElement.readonly = true;
                                        selectedTextElement.disabled = true;
                                    }
                                }
                            }
                        }

                        if (wantRestore) {
                            // restore old value of select.
                            controller.selectedIndex
                                = previousControllerState.value;
                        }
                        else {
                            previousControllerState.value
                                = controller.selectedIndex;
                        }                        
                    } // select options exist & selected index is valid
                } // previous controller state exists
            } // controller is a single-select drop-down
            else if (controller.type.toUpperCase() == 'CHECKBOX') {
                var textElement = textElements[0];
                if (textElement != null
                    && textElement.value
                    &&  textElement.value.trim().length > 0) {
                    if (controller.checked) {
                        textElement.readonly = false;
                        textElement.disabled = false;
                    }
                    else {
                        if (confirm("Changing your selection for '"
                                    + controllerLabel
                                    + "' will clear the text '"
                                    + textElement.value
                                    + "'.  Continue?")) {
                            textElement.value = '';
                            fireEvent(textElement, 'change', 'HTMLEvents');
                            textElement.readonly = true;
                            textElement.disabled = true;
                            controller.checked = false;
                        }
                        else {
                            // restore old value of checkbox.
                            controller.checked = true;
                        }
                    }
                }
                else {
                    if (controller.checked) {
                        textElement.readonly = false;
                        textElement.disabled = false;
                    }
                    else {
                        textElement.readonly = true;
                        textElement.disabled = true;
                    }
                }
            }
        } // controller form element and text element array exist
    }  
    catch (e) {
        alert("Exception in updateAssociatedTexts:" + e);
    }
    //return ie;
}

function clearTableCell(divElementId, rowIndex, columnIndex) {
    clearTableCellChild(divElementId, rowIndex, columnIndex, null);
}

function clearTableCellChild(divElementId, rowIndex, columnIndex, childIndex) {
    var divElement = document.getElementById(divElementId);
    if (divElement && divElement.childNodes
        && divElement.childNodes.length > 0) {
        var formDataTable = getChildByNodeName(divElement, 'TABLE');
        if (formDataTable) {
            var tbody = getChildByNodeName(formDataTable, "TBODY");
            var rowCount = -1;
            if (tbody && tbody.childNodes
                && tbody.childNodes.length > 0) {
                var trows = getChildrenByNodeName(tbody, "TR");
                rowCount = trows.length;
                if (rowCount > 0) {
                    var targetRowIndex = rowIndex < 0
                        ? rowCount + rowIndex : rowIndex;
                    if (targetRowIndex >= 0 && targetRowIndex < rowCount) {
                        var targetRow = trows[targetRowIndex];
                        var cells = getChildrenByNodeName(targetRow, "TD");
                        var cellCount = cells.length;
                        if (cellCount > 0) {
                            var targetColumnIndex = columnIndex < 0
                                ? cellCount + columnIndex : columnIndex;
                            if (targetColumnIndex >= 0 && targetColumnIndex < cellCount) {
                                var cell = cells[targetColumnIndex];
                                if (cell) {
                                    if (childIndex == null) {
                                        removeChildren(cell);
                                    }
                                    else {
                                        var nodes = cell.childNodes;
                                        if (nodes) {
                                            var nodeCount = nodes.length;
                                            if (nodeCount > 0) {
                                                var targetChildIndex = childIndex < 0
                                                    ? nodeCount + childIndex : childIndex;
                                                if (targetChildIndex >= 0 && targetChildIndex < nodeCount) {
                                                    cell.removeChild(nodes[targetChildIndex]);
                                                } // target node exists
                                            } // > 0 nodes
                                        } // nodes array exists
                                    } // child index was passed to func.
                                } // target cell exists
                            } // target column exists
                        } // row has > 0 cells
                    } // row's cell array exists
                } // > 0 rows in table
            } // table body exists & its array of rows exists 
        } // table exists
    } // div containing table exists
} // clearTableCellChild

function findLeastHighCutPointIndex(value, cutPoints, inclusive) {

    // if inclusive is false, finds the index of the least cut point
    // in the array cutPoints which exceeds the value.
    // if inclusive is true then find the index of the least cut point
    // which equals or exceeds the value.
    // 

    var cutPointIndex = null;
    try {
        if (value != null
            && cutPoints != null
            && cutPoints.length > 0) {
            cutPointIndex = -1;
            for (var i = 0;
                 i < cutPoints.length
                 && cutPointIndex == -1;
                 i++) {
                if ((inclusive && value <= cutPoints[i])
                    || (!inclusive && value < cutPoints[i])) {
                    cutPointIndex = i;
                }
            }
            if (cutPointIndex == -1) {
                // value exceeds the highest cut point
                cutPointIndex = cutPoints.length;
            }
        }
    }
    catch (e) {
        error('findLeastHighCutPointIndex:' + e);
    }
    return cutPointIndex;
}

function findHighCutPointIndex(value, cutPoints, inclusive_flags) {

    // if inclusive_flags[i] is false, finds the index of the least cut point
    // in the array cutPoints which exceeds the value.
    // if inclusive_flags[i] is true then find the index of the least cut point
    // which equals or exceeds the value.

    // cutPoints should be passed in sorted order

    var cutPointIndex = null;
    try {
        if (value != null
            && cutPoints != null
            && cutPoints.length > 0
            && inclusive_flags != null
            && inclusive_flags.length == cutPoints.length) {
            cutPointIndex = -1;
            for (var i = 0;
                 i < cutPoints.length
                 && cutPointIndex == -1;
                 i++) {
                if ((inclusive_flags[i] && value <= cutPoints[i])
                    || (!inclusive_flags[i] && value < cutPoints[i])) {
                    cutPointIndex = i;
                }
            }
            if (cutPointIndex == -1) {
                // value exceeds the highest cut point
                cutPointIndex = cutPoints.length;
            }
        }
    }
    catch (e) {
        error('findLeastHighCutPointIndex:' + e);
    }
    return cutPointIndex;
}

// Thanks to 
// https://lea.verou.me/2009/02/check-if-a-css-property-is-supported/
function isCSSPropertySupported(property) {
    return property in document.body.style;
}

// selectorSupported lovingly lifted from the mad italian genius, diego perini
// https://javascript.nwbox.com/CSSSupport/
function isCSSSelectorSupported(selector){
  
  var support, link, sheet, doc = document,
      root = doc.documentElement,
      head = root.getElementsByTagName('head')[0],
 
      impl = doc.implementation || {
              hasFeature: function() {
                  return false;
              }
      },
 
  link = doc.createElement("style");
  link.type = 'text/css';
 
  (head || root).insertBefore(link, (head || root).firstChild);
 
  sheet = link.sheet || link.styleSheet;
 
  if (!(sheet && selector)) return false;
 
  support = impl.hasFeature('CSS2', '') ?
  
              function(selector) {
                  try {
                      sheet.insertRule(selector + '{ }', 0);
                      sheet.deleteRule(sheet.cssRules.length - 1);
                  } catch (e) {
                      return false;
                  }
                  return true;
                  
              } : function(selector) {
                
                  sheet.cssText = selector + ' { }';
                  return sheet.cssText.length !== 0 && !(/unknown/i).test(sheet.cssText) && sheet.cssText.indexOf(selector) === 0;
              };
   
  return support(selector);
 
};

function setMapValue(map, keys, value) {
    try {
        if (map != null
            && exists(map.length)
            && keys != null
            && exists(keys.length)) {
            for (var i = 0; i < keys.length; i++) {
             map[keys[i]] = value;
            }
        }
    }
    catch (e) {
        error("setMapValue: " + e);
    }
}
            
function setMapValues(map, keys, values) {
    try {
        if (map != null
            && exists(map.length)
            && keys != null
            && exists(keys.length)
            && values != null
            && exists(values.length)
            && keys.length == values.length) {

            for (var i = 0; i < keys.length; i++) {
             map[keys[i]] = values[i];
            }

        }
    }
    catch (e) {
        error("setMapValues: " + e);
    }
}

function localParseInt(s) {
    var intValue = null;
    try {
        if (s != null && s.trim() != '') {
            var match = PARSEABLE_NUMERIC_REGEXP.exec(s);
            if (match && match.length == 2) {
                intValue = parseInt(match[1]);
            }
        }
    } catch (e) {
      alert("Problem: Could not parse string " + s + " as an integer.");
    }
    return intValue;
}
    
function parseDate(s) {
    var aDate = null;
    try {
        if (s != null && s.trim() != '') {
            s = s.trim();
            var match = DATE_REGEXP.exec(s);
            if (match && match.length >= 4) {
                if (match[3] != null && match[3].trim().length > 0) {
                    month = localParseInt(match[1]);
                    day = localParseInt(match[2]);
                    year = localParseInt(match[3]);
                }
                else if (match.length >= 7 && match[6].trim().length > 0) {
                    month = localParseInt(match[4]);
                    day = localParseInt(match[5]);
                    year = localParseInt(match[6]);
                }

                if (year < 100) {
                    const currentYear = new Date().getFullYear();
                    const currentCentury = divide(currentYear, 100);

                    if (year <= (currentYear % 100 + 1)) {
                        year += currentCentury * 100;
                    } else {
                        year += (currentCentury - 1) * 100;
                    }
                }

                aDate = new Date(year, month - 1, day);
            }
        }
    } catch (e) {
        alert("Problem: Could not parse string " + s + " as a date.");
    }

    return aDate;
}

function updateIcuCcuStay() {
    var hiddensaveWhenUpdateButton = disEnForm.getElementByName("saveWhenUpdateButton");
    if (hiddensaveWhenUpdateButton) {
        hiddensaveWhenUpdateButton.value = 1;
    }

    var radioButton = disEnForm.getElementByName("radICUCCUStayExistence");
    if (radioButton) {
        radioButton[0].removeAttribute('disabled');
        radioButton[1].removeAttribute('disabled');
        radioButton[2].removeAttribute('disabled');
        radioButton[3].removeAttribute('disabled');

        if (radioButton.value == 1 || radioButton[1].checked) {
            var button = disEnForm.getElementByName("btnAddIcuCcuStay");
            if (button) {
                button.removeAttribute('disabled');
                button.removeAttribute('readonly');
                button.className = "AssessBtn";
                //button.className = "TopNavBtn";
            }
            
            var totalDays = disEnForm.getElementByName("txtICUCCUStayTotalDays");
            if(totalDays) {

                totalDays.removeAttribute('disabled');
                totalDays.removeAttribute('readonly');
            }

            return updateIcuCcuStayDates(0);
        }
    } else {
        return false;
    }
}

function updateIcuCcuStayDates(index) {
    var newIndex = index;
    var admitDate = disEnForm.getElementByName("txtIcuCcuAdmitDate" + newIndex);
    var transferDate = disEnForm.getElementByName("txtIcuCcuTransferDate" + newIndex);

    if (admitDate && transferDate) {
        admitDate.removeAttribute('disabled');
        transferDate.removeAttribute('disabled');
        
        admitDate.removeAttribute('readonly');
        transferDate.removeAttribute('readonly');

        newIndex = index + 1;
        return updateIcuCcuStayDates(newIndex);
    } else {
        return false;
    }
}

function clearIcuCcuStay(type) {
    var array = ["txtIcuCcuAdmitDate", "Admit Date", "txtIcuCcuTransferDate", "Transfer Date"];
    var message = "Changing your selection for 'ICU/CCU Stay' will clear any information entered in this section. Continue?";
    return disableAddMoreSectionLTRAX.disableRadio('radICUCCUStayExistence', message, array, type, 'btnAddIcuCcuStay', 'txtICUCCUStayTotalDays');
}

function disButtonByNameLTRAX(buttonName, disable){
    if (buttonName === "btnAddIcuCcuStay")
    {
        var myButton = disEnForm.getElementByName(buttonName);
        if (myButton){
            myButton.disabled = (disable !== undefined ? disable : !myButton.disabled);
            myButton.className = (myButton.disabled ? "TopNavBtnDis" :"AssessBtn");
        }
    }
    else if (buttonName)
    {
        var myButton = disEnForm.getElementByName(buttonName);
        if (myButton){
            myButton.disabled = (disable !== undefined ? disable : !myButton.disabled);
            myButton.className = (myButton.disabled ? "TopNavBtnDis" :"TopNavBtn");
        }
    }
}


var disableAddMoreSectionLTRAX = new function(){
    var type = undefined;
    
    return {
        disableRadio : function (nameElement, message, arrayName, type, buttonName, totalDaysFieldName) {
            return checkDependentElementWithMessageLTRAX(nameElement, message, true, true, this.collect(arrayName, type, totalDaysFieldName), function(disable)
            {
                disButtonByNameLTRAX(buttonName, disable);
            });
                 
        },
        disableArray : function(nameElement, arrayName, type) {
            return checkDependentElementWithMessageLTRAX(nameElement, null, false, true, this.collect(arrayName, type, totalDaysFieldName));
        },
        
        disableTotalDays : function(nameElement, type) {
            if (nameElement)
            {
                var dayField = disEnForm.getElementByName(nameElement);
                if (dayField){
                    dayField.disabled = true;
                }
            }
        },
        
        collect : function (array, typeNew, totalDaysFieldName) {
            var arrayDisable = [];
            if (array && array.constructor == Array && typeNew) {
                type = typeNew;
                var beginIndex = 0;
                while (disEnForm.getElementByName(this.generateElementName(array[0], type, beginIndex)))
                {
                    for (var i = 0 ; i < array.length; i++)
                        arrayDisable.push(this.generateElementName(array[i], type, beginIndex));
                    beginIndex++;
                }
                arrayDisable.push(totalDaysFieldName);
                arrayDisable.push("Total Days");
                return arrayDisable;
            }else return [];
        },
        generateElementName : function (elementName, type, index) {
            return (elementName + index);
        }
    };
}();

function checkDependentElementWithMessageLTRAX(elementName, message, clearOnCheck, disable, dependants, callback) {
    message = message == null ? "Deselecting this will clear the following: %fields%. Continue?" : message;
    var element = eval("document.frmIRFPAI." + elementName);
    if (!element || !dependants || !dependants.length || dependants.length < 2 || dependants.length % 2 != 0) return false;
    var sFields = "";
    var firstValue = "";
    var elementRadioValue = getElementValue(element);
    if ((element.checked  || ( elementRadioValue != "1")) == clearOnCheck) {
        for (var i=0; i<dependants.length; i+=2) {
            dep = eval("document.frmIRFPAI." + dependants[i]);
            if (!dep) continue;
            isCheckbox = (dep.type == "checkbox");//dependants[i].type == "checkbox"; // TODO replace with more correct check
            if (i == 0 && !isCheckbox) firstValue = dep.value;
            if ((isCheckbox && dep.checked) || (!isCheckbox && dep.value && dep.value.replace(/^\s+|\s+$/, '').length > 0)){
                if (sFields.length > 0)
                    sFields += ", ";
                sFields += dependants[i+1];
            }
        }
        if ( (sFields.length > 0 && confirm(message.replace(/%fields%/, sFields).replace(/%firstValue%/, firstValue))) || (sFields.length == 0) ) {
            for (var i=0; i<dependants.length; i+=2) {
                dep = eval("document.frmIRFPAI." + dependants[i]);
                if (dep) {
                    if (dep.type == "checkbox")
                        dep.checked = false;
                    else if (dep.type == "text")
                        dep.value = "";
                    if (dep.options)
                        dep.selectedIndex = 0;
                    if (disable) {
                        dep.disabled = true;
                        dep.readOnly = true;
                    }
                }
            }
            if (callback)
                callback(true);
            return true;
        }
        else if (sFields.length > 0){
            if (element.length > 0 && /INPUT/.test(element[0].nodeName) && element[0].type == "radio") {
                setElementValue(element[0], "1");
                if (callback)
                    callback(false);
            }
            return false;
        }
        if (disable) {
            for (var i=0; i<dependants.length; i+=2) {
                dep = eval("document.frmIRFPAI." + dependants[i]);
                if (dep) {
                    dep.disabled = true;
                    dep.readOnly = true;
                }
            }
        }
        return true;
    }
    else {
        for (var i=0; i<dependants.length; i+=2) {
            dep = eval("document.frmIRFPAI." + dependants[i]);
            if (dep) {
                dep.disabled = false;
                dep.readOnly = false;
                if (i==0) dep.focus();
            }
        }
        if (callback)
            callback(false);
        return true;
    }
}

function disableSelectElement(el, newSelectedIndex) {
    if (el && el.nodeName.toUpperCase() == 'SELECT') {
        el.disabled = true;
        el.readonly = true;
        if (exists(newSelectedIndex)) {
            el.selectedIndex = newSelectedIndex;
        }
    }
}

function enableSelectElement(el, newSelectedIndex, optionBuilder) {
    if (el && el.nodeName.toUpperCase() == 'SELECT') {
        el.disabled = false;
        el.readonly = false;

        if (exists(optionBuilder) && typeof(optionBuilder) == 'function') {
            optionBuilder(el);
        }

        if (exists(newSelectedIndex)) {
            el.selectedIndex = newSelectedIndex;
        }
    }
}

//formatting extension
String.prototype.format = function() {
    var string = this;
    var currentArg = null;
    for (var i = 0, n = arguments.length; i < n ; i++) {
        currentArg = arguments[i];
        if (currentArg == null || currentArg == undefined) { 
            currentArg = '';
        }
        var reg = new RegExp('\\{' + i + '\\}', 'gm');
        string = string.replace(reg, currentArg);
    }

    return string;
}

// From https://gist.github.com/westc/55314af02bc5a5551f3cb64fb5c07c93

Date.prototype.getFiscalYear = function(opt_monthStart) { 
  if (opt_monthStart == undefined) { 
      opt_monthStart = 9; // October
  }
  var date = this;
  var month = date.getMonth(),
      year = date.getFullYear(),
      yearOffset = Math.floor((month - ((opt_monthStart % 12) || 12)) / 12) + 1;
  return yearOffset + year;
}
Date.prototype.fiscalQuarter = function(opt_monthStart) {
  if (opt_monthStart == undefined) { 
      opt_monthStart = 9; // October
  }
  var date = this;
  var month = date.getMonth(),
      monthIndex = ((month - opt_monthStart) + 12) % 12;
  return ~~(monthIndex / 3) + 1;
}

function parseBoolean(str) { 
  return /^true$/i.test(str);
}

// based on https://stackoverflow.com/a/16541547
Window.prototype.testForPopupBlockAndOpen = function(windowPath, windowName, windowFeature, blockedMessage, timeoutMsec) {
    var popupBlocked = false;
    if (!timeoutMsec) {
        timeoutMsec = 25;
    }
    var popup = this.open(windowPath, windowName, windowFeature);
    setTimeout( function() {
        if (popup == null) {
            // Works For IE & Firefox
            popupBlocked = true;
        }
        else if (popup.outerHeight === 0) {
            // Works For Chrome
            popupBlocked = true;
        }
        if (popupBlocked) { 
            alert(blockedMessage);
        }
        else {
            popup.focus();
        }
    
    }, timeoutMsec);
}