//------------------------------------------------------------------
//	GLOBAL VARIABLES for this script
//------------------------------------------------------------------
var strDigit = "1234567890";
var phoneNumberDelimiters = "()- "; // characters which are allowed in international phone numbers
var validWorldPhoneChars = phoneNumberDelimiters + "+"; // (a leading + is OK)
var minDigitsInIPhoneNumber = 10; // Minimum no of digits in an international phone no.\
var phoneRegularExpression = /^((\+\d{1,3}(-| )?\(?\d\)?(-| )?\d{1,3})|(\(?\d{2,3}\)?))(-| )?(\d{3,4})(-| )?(\d{4})(( x| ext)\d{1,5}){0,1}$/
var emailRegularExpression = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*\.(\w{2}|(com|net|org|edu|int|mil|gov|arpa|biz|aero|name|coop|info|pro|museum))$/

//------------------------------------------------------------------



//-------------------------------------------------------------------
// Trim functions
//   Returns string with whitespace trimmed
//-------------------------------------------------------------------
function LTrim(str) {
    if (str == null) { return null; }
    for (var i = 0; str.charAt(i) == " "; i++);
    return str.substring(i, str.length);
}
function RTrim(str) {
    if (str == null) { return null; }
    for (var i = str.length - 1; str.charAt(i) == " "; i--);
    return str.substring(0, i + 1);
}
function Trim(str) { return LTrim(RTrim(str)); }
function LTrimAll(str) {
    if (str == null) { return str; }
    for (var i = 0; str.charAt(i) == " " || str.charAt(i) == "\n" || str.charAt(i) == "\t"; i++);
    return str.substring(i, str.length);
}
function RTrimAll(str) {
    if (str == null) { return str; }
    for (var i = str.length - 1; str.charAt(i) == " " || str.charAt(i) == "\n" || str.charAt(i) == "\t"; i--);
    return str.substring(0, i + 1);
}
function TrimAll(str) {
    return LTrimAll(RTrimAll(str));
}
//-------------------------------------------------------------------
// isNull(value)
//   Returns true if value is null
//-------------------------------------------------------------------
function isNull(val) { return (val == null); }

//-------------------------------------------------------------------
// isBlank(value)
//   Returns true if value only contains spaces
//-------------------------------------------------------------------
function isBlank(val) {
    if (val == null) { return true; }
    for (var i = 0; i < val.length; i++) {
        if ((val.charAt(i) != ' ') && (val.charAt(i) != "\t") && (val.charAt(i) != "\n") && (val.charAt(i) != "\r")) { return false; }
    }
    return true;
}

//-------------------------------------------------------------------
// isString(strValue)
//   Returns true if value contains is String
//-------------------------------------------------------------------

function isString(strValue) {
    return (typeof strValue == 'string' && strValue != '' && isNaN(strValue));
}

//-------------------------------------------------------------------
// isNumber(strValue)
//   Returns true if value contains is Number
//-------------------------------------------------------------------
function isNumber(strValue) {
    return (!isNaN(strValue) && strValue != '');
}

//-------------------------------------------------------------------
// isInteger(value)
//   Returns true if value contains all digits
//-------------------------------------------------------------------
function isInteger(val) {
    if (isBlank(val)) { return false; }
    for (var i = 0; i < val.length; i++) {
        if (!isDigit(val.charAt(i))) { return false; }
    }
    return true;
}

//-------------------------------------------------------------------
// isEmail(strValue)
//   Check to see if email address entered is valid. 
//-------------------------------------------------------------------

function isEmail(strValue) {
    var objRE = /^[\w-\.\']{1,}\@([\da-zA-Z-]{1,}\.){1,}[\da-zA-Z-]{2,}$/;

    return (strValue != '' && objRE.test(strValue));
}

//-------------------------------------------------------------------
// isNumeric(value)
//   Returns true if value contains a positive float value
//-------------------------------------------------------------------
function isNumeric(val) { return (parseFloat(val, 10) == (val * 1)); }

//-------------------------------------------------------------------
// isArray(obj)
// Returns true if the object is an array, else false
//-------------------------------------------------------------------
function isArray(obj) { return (typeof (obj.length) == "undefined") ? false : true; }

//-------------------------------------------------------------------
// isDigit(value)
//   Returns true if value is a 1-character digit
//-------------------------------------------------------------------
function isDigit(num) {
    if (num.length > 1) { return false; }

    if (strDigit.indexOf(num) != -1) { return true; }
    return false;
}

//-------------------------------------------------------------------
// setNullIfBlank(input_object)
//   Sets a form field to "" if it isBlank()
//-------------------------------------------------------------------
function setNullIfBlank(obj) { if (isBlank(obj.value)) { obj.value = ""; } }

//-------------------------------------------------------------------
// setFieldsToUpperCase(input_object)
//   Sets value of form field toUpperCase() for all fields passed
//-------------------------------------------------------------------
function setFieldsToUpperCase() {
    for (var i = 0; i < arguments.length; i++) {
        arguments[i].value = arguments[i].value.toUpperCase();
    }
}

//-------------------------------------------------------------------
// disallowBlank(input_object[,message[,true]])
//   Checks a form field for a blank value. Optionally alerts if 
//   blank and focuses
//-------------------------------------------------------------------
function disallowBlank(obj) {
    var msg = (arguments.length > 1) ? arguments[1] : "";
    var dofocus = (arguments.length > 2) ? arguments[2] : false;
    if (isBlank(getInputValue(obj))) {
        if (!isBlank(msg)) { alert(msg); }
        if (dofocus) {
            if (isArray(obj) && (typeof (obj.type) == "undefined")) { obj = obj[0]; }
            if (obj.type == "text" || obj.type == "textarea" || obj.type == "password") { obj.select(); }
            obj.focus();
        }
        return true;
    }
    return false;
}

//-------------------------------------------------------------------
// disallowModify(input_object[,message[,true]])
//   Checks a form field for a value different than defaultValue. 
//   Optionally alerts and focuses
//-------------------------------------------------------------------
function disallowModify(obj) {
    var msg = (arguments.length > 1) ? arguments[1] : "";
    var dofocus = (arguments.length > 2) ? arguments[2] : false;
    if (getInputValue(obj) != getInputDefaultValue(obj)) {
        if (!isBlank(msg)) { alert(msg); }
        if (dofocus) {
            if (isArray(obj) && (typeof (obj.type) == "undefined")) { obj = obj[0]; }
            if (obj.type == "text" || obj.type == "textarea" || obj.type == "password") { obj.select(); }
            obj.focus();
        }
        setInputValue(obj, getInputDefaultValue(obj));
        return true;
    }
    return false;
}

//-------------------------------------------------------------------
// commifyArray(array[,delimiter])
//   Take an array of values and turn it into a comma-separated string
//   Pass an optional second argument to specify a delimiter other than
//   comma.
//-------------------------------------------------------------------
function commifyArray(obj, delimiter) {
    if (typeof (delimiter) == "undefined" || delimiter == null) {
        delimiter = ",";
    }
    var s = "";
    if (obj == null || obj.length <= 0) { return s; }
    for (var i = 0; i < obj.length; i++) {
        s = s + ((s == "") ? "" : delimiter) + obj[i].toString();
    }
    return s;
}

//-------------------------------------------------------------------
// getSingleInputValue(input_object,use_default,delimiter)
//   Utility function used by others
//-------------------------------------------------------------------
function getSingleInputValue(obj, use_default, delimiter) {
    switch (obj.type) {
        case 'radio': case 'checkbox': return (((use_default) ? obj.defaultChecked : obj.checked) ? obj.value : null);
        case 'text': case 'hidden': case 'textarea': return (use_default) ? obj.defaultValue : obj.value;
        case 'password': return ((use_default) ? null : obj.value);
        case 'select-one':
            if (obj.options == null) { return null; }
            if (use_default) {
                var o = obj.options;
                for (var i = 0; i < o.length; i++) { if (o[i].defaultSelected) { return o[i].value; } }
                return o[0].value;
            }
            if (obj.selectedIndex < 0) { return null; }
            return (obj.options.length > 0) ? obj.options[obj.selectedIndex].value : null;
        case 'select-multiple':
            if (obj.options == null) { return null; }
            var values = new Array();
            for (var i = 0; i < obj.options.length; i++) {
                if ((use_default && obj.options[i].defaultSelected) || (!use_default && obj.options[i].selected)) {
                    values[values.length] = obj.options[i].value;
                }
            }
            return (values.length == 0) ? null : commifyArray(values, delimiter);
    }
    alert("FATAL ERROR: Field type " + obj.type + " is not supported for this function");
    return null;
}

//-------------------------------------------------------------------
// getSingleInputText(input_object,use_default,delimiter)
//   Utility function used by others
//-------------------------------------------------------------------
function getSingleInputText(obj, use_default, delimiter) {
    switch (obj.type) {
        case 'radio': case 'checkbox': return "";
        case 'text': case 'hidden': case 'textarea': return (use_default) ? obj.defaultValue : obj.value;
        case 'password': return ((use_default) ? null : obj.value);
        case 'select-one':
            if (obj.options == null) { return null; }
            if (use_default) {
                var o = obj.options;
                for (var i = 0; i < o.length; i++) { if (o[i].defaultSelected) { return o[i].text; } }
                return o[0].text;
            }
            if (obj.selectedIndex < 0) { return null; }
            return (obj.options.length > 0) ? obj.options[obj.selectedIndex].text : null;
        case 'select-multiple':
            if (obj.options == null) { return null; }
            var values = new Array();
            for (var i = 0; i < obj.options.length; i++) {
                if ((use_default && obj.options[i].defaultSelected) || (!use_default && obj.options[i].selected)) {
                    values[values.length] = obj.options[i].text;
                }
            }
            return (values.length == 0) ? null : commifyArray(values, delimiter);
    }
    alert("FATAL ERROR: Field type " + obj.type + " is not supported for this function");
    return null;
}

//-------------------------------------------------------------------
// setSingleInputValue(input_object,value)
//   Utility function used by others
//-------------------------------------------------------------------
function setSingleInputValue(obj, value) {
    switch (obj.type) {
        case 'radio': case 'checkbox': if (obj.value == value) { obj.checked = true; return true; } else { obj.checked = false; return false; }
        case 'text': case 'hidden': case 'textarea': case 'password': obj.value = value; return true;
        case 'select-one': case 'select-multiple':
            var o = obj.options;
            for (var i = 0; i < o.length; i++) {
                if (o[i].value == value) { o[i].selected = true; }
                else { o[i].selected = false; }
            }
            return true;
    }
    alert("FATAL ERROR: Field type " + obj.type + " is not supported for this function");
    return false;
}

//-------------------------------------------------------------------
// getInputValue(input_object[,delimiter])
//   Get the value of any form input field
//   Multiple-select fields are returned as comma-separated values, or
//   delmited by the optional second argument
//   (Doesn't support input types: button,file,reset,submit)
//-------------------------------------------------------------------
function getInputValue(obj, delimiter) {
    var use_default = (arguments.length > 2) ? arguments[2] : false;
    if (isArray(obj) && (typeof (obj.type) == "undefined")) {
        var values = new Array();
        for (var i = 0; i < obj.length; i++) {
            var v = getSingleInputValue(obj[i], use_default, delimiter);
            if (v != null) { values[values.length] = v; }
        }
        return commifyArray(values, delimiter);
    }
    return getSingleInputValue(obj, use_default, delimiter);
}

//-------------------------------------------------------------------
// getInputText(input_object[,delimiter])
//   Get the displayed text of any form input field
//   Multiple-select fields are returned as comma-separated values, or
//   delmited by the optional second argument
//   (Doesn't support input types: button,file,reset,submit)
//-------------------------------------------------------------------
function getInputText(obj, delimiter) {
    var use_default = (arguments.length > 2) ? arguments[2] : false;
    if (isArray(obj) && (typeof (obj.type) == "undefined")) {
        var values = new Array();
        for (var i = 0; i < obj.length; i++) {
            var v = getSingleInputText(obj[i], use_default, delimiter);
            if (v != null) { values[values.length] = v; }
        }
        return commifyArray(values, delimiter);
    }
    return getSingleInputText(obj, use_default, delimiter);
}

//-------------------------------------------------------------------
// getInputDefaultValue(input_object[,delimiter])
//   Get the default value of any form input field when it was created
//   Multiple-select fields are returned as comma-separated values, or
//   delmited by the optional second argument
//   (Doesn't support input types: button,file,password,reset,submit)
//-------------------------------------------------------------------
function getInputDefaultValue(obj, delimiter) { return getInputValue(obj, delimiter, true); }

//-------------------------------------------------------------------
// isChanged(input_object)
//   Returns true if input object's value has changed since it was
//   created.
//-------------------------------------------------------------------
function isChanged(obj) { return (getInputValue(obj) != getInputDefaultValue(obj)); }

//-------------------------------------------------------------------
// setInputValue(obj,value)
//   Set the value of any form field. In cases where no matching value
//   is available (select, radio, etc) then no option will be selected
//   (Doesn't support input types: button,file,password,reset,submit)
//-------------------------------------------------------------------
function setInputValue(obj, value) {
    var use_default = (arguments.length > 1) ? arguments[1] : false;
    if (isArray(obj) && (typeof (obj.type) == "undefined")) {
        for (var i = 0; i < obj.length; i++) { setSingleInputValue(obj[i], value); }
    }
    else { setSingleInputValue(obj, value); }
}

//-------------------------------------------------------------------
// isFormModified(form_object,hidden_fields,ignore_fields)
//   Check to see if anything in a form has been changed. By default
//   it will check all visible form elements and ignore all hidden 
//   fields. 
//   You can pass a comma-separated list of field names to check in
//   addition to visible fields (for hiddens, etc).
//   You can also pass a comma-separated list of field names to be
//   ignored in the check.
//-------------------------------------------------------------------
function isFormModified(theform, hidden_fields, ignore_fields) {
    if (hidden_fields == null) { hidden_fields = ""; }
    if (ignore_fields == null) { ignore_fields = ""; }
    var hiddenFields = new Object();
    var ignoreFields = new Object();
    var i, field;
    var hidden_fields_array = hidden_fields.split(',');
    for (i = 0; i < hidden_fields_array.length; i++) {
        hiddenFields[Trim(hidden_fields_array[i])] = true;
    }
    var ignore_fields_array = ignore_fields.split(',');
    for (i = 0; i < ignore_fields_array.length; i++) {
        ignoreFields[Trim(ignore_fields_array[i])] = true;
    }
    for (i = 0; i < theform.elements.length; i++) {
        var changed = false;
        var name = theform.elements[i].name;
        if (!isBlank(name)) {
            var type = theform.elements[i].type;
            if (!ignoreFields[name]) {
                if (type == "hidden" && hiddenFields[name]) { changed = isChanged(theform[name]); }
                else if (type == "hidden") { changed = false; }
                else { changed = isChanged(theform[name]); }
            }
        }
        if (changed) { return true; }
    }
    return false;
}



//-------------------------------------------------------------------
// addEventaddEvent(obj,evType,fn,useCapture)
//   obj to which you want to attach event "Window"
//	 eveType :- Event type like "Load"
//	fn:- function to perform on this event
//-------------------------------------------------------------------

function addEvent(obj, evType, fn, useCapture) {
    var ret = false;
    if (obj != null) {
        if (obj.addEventListener) {
            obj.addEventListener(evType, fn, useCapture);
            ret = true;
        }
        else if (obj.attachEvent) {
            obj.attachEvent('on' + evType, fn);
            ret = true;
        }
    }
    return ret;
}

//-------------------------------------------------------------------
// isRadioButtonChecked function Check ratiobutton on for .net Server side Component
//-------------------------------------------------------------------

function isRadioButtonChecked(ObjectForm, strRadioButtonId, number) {
    var boolreturn = false;
    for (iIndex = 0; iIndex < number; iIndex++) {
        var radioButtonName = strRadioButtonId + "_" + iIndex;
        if (ObjectForm.elements[radioButtonName].checked == true) {
            boolreturn = true;
            return boolreturn;
        }
    }
    return boolreturn;
}

//-------------------------------------------------------------------
// Date validation
//-------------------------------------------------------------------


function isDate(dateStr) {
    // Checks for the following valid date formats:
    // MM/DD/YY   MM/DD/YYYY   MM-DD-YY   MM-DD-YYYY
    // Also separates date into month, day, and year variables

    var datePat = /^(\d{1,2})(\/|-)(\d{1,2})\2(\d{2}|\d{4})$/;

    // To require a 4 digit year entry, use this line instead:
    // var datePat = /^(\d{1,2})(\/|-)(\d{1,2})\2(\d{4})$/;

    var matchArray = dateStr.match(datePat); // is the format ok?
    if (matchArray == null) {
        //alert("Date is not in a valid format.")
        return false;
    }
    month = matchArray[3]; // parse date into variables
    day = matchArray[1];
    year = matchArray[4];
    if (month < 1 || month > 12) { // check month range
        alert("Month must be between 1 and 12.");
        return false;
    }
    if (day < 1 || day > 31) {
        alert("Day must be between 1 and 31.");
        return false;
    }
    if ((month == 4 || month == 6 || month == 9 || month == 11) && day == 31) {
        alert("Month " + month + " doesn't have 31 days!")
        return false
    }
    if (month == 2) { // check for february 29th
        var isleap = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
        if (day > 29 || (day == 29 && !isleap)) {
            alert("February " + year + " doesn't have " + day + " days!");
            return false;
        }
    }
    return true;  // date is valid
}

//------------------------------------------------------------------------------------------
// Search through string's characters one by one.
// If character is not in bag, append to returnSt
//------------------------------------------------------------------------------------------
function stripCharsInBag(s, bag) {
    var i;
    var returnString = "";
    // Search through string's characters one by one.
    // If character is not in bag, append to returnString.
    for (i = 0; i < s.length; i++) {
        // Check that current character isn't whitespace.
        var c = s.charAt(i);
        if (bag.indexOf(c) == -1) returnString += c;
    }
    return returnString;
}

//------------------------------------------------------------------------------------------
// Function check for International phone number     
//------------------------------------------------------------------------------------------
function checkInternationalPhone(strPhone) {
    s = stripCharsInBag(strPhone, validWorldPhoneChars);
    return (isInteger(s) && s.length >= minDigitsInIPhoneNumber);
}

//------------------------------------------------------------------------------------------
// Function check for phone number     
//------------------------------------------------------------------------------------------
function isPhoneNumber(strValue) {
    return (strValue != '' && phoneRegularExpression.test(strValue));
}

//------------------------------------------------------------------------------------------
// Function Message display
// id of element to display message in
// msgtype class to give element ("warn" or "error")
// message string to display
//------------------------------------------------------------------------------------------
function msg(fld, msgtype, message) {
    // setting an empty string can give problems if later set to a 
    // non-empty string, so ensure a space present. (For Mozilla and Opera one could 
    // simply use a space, but IE demands something more, like a non-breaking space.)
    var dispmessage;
    //if (!emptyString.test(message)){

    var elem = document.getElementById(fld);
    elem.innerHTML = message;

    elem.className = msgtype;   // set the CSS class to adjust appearance of message
}

// --------------------------------------------
//            commonCheck
// Common code for all validation routines to:
// (a) check for older / less-equipped browsers
// (b) check if empty fields are required
// Returns true (validation passed), 
//         false (validation failed) or
//         proceed (don't know yet)
// valfield : element to be validated
// infofield: id of element to receive info/error msg
// required:   true if required
// --------------------------------------------

var proceed = 2;
var nbsp = 160; 	// non-breaking space char
var node_text = 3; // DOM text node-type
var emptyString = /^\s*$/;
var global_valfield; // retain valfield for timer thread

function commonCheck(valfield, infofield, required) {


    
    if (!document.getElementById)
        return true;  // not available on this browser - leave validation to the server
    var elem = document.getElementById(infofield);
   
    
    //if (!elem.firstChild) return true;  // not available on this browser 
    //if (elem.firstChild.nodeType != node_text) return true;  // infofield is wrong type of node

    valfield = document.getElementById(valfield);

    
    if (emptyString.test(valfield.value)) {
        if (required) {
            msg(infofield, "req", "*");
            setfocus(valfield);
            return false;
        }
        else {
            msg(infofield, "warn", "");   // OK
            return true;
        }
    } else {
        msg(infofield, "req", " ");
    }
    
    return proceed;
}

// --------------------------------------------
//            validatePresent
// Validate if something has been entered
// Returns true if so
// valfield: element to be validated
// infofield: id of element to receive info/error msg
// --------------------------------------------

function validatePresent(valfield, infofield) {

    var stat = commonCheck(valfield, infofield, true);
    if (stat != proceed) return stat;

    //msg(infofield, "warn", "");
    return true;
}


// --------------------------------------------
//  validateDropDown
// Returns true if anything other then first index is selected (and also if could not be executed because of old browser)
// --------------------------------------------

function validateDropDown(valfield, infofield) {

    if (!document.getElementById)
        return true;  // not available on this browser - leave validation to the server

    
    
    var tfld = document.getElementById(valfield).selectedIndex;  // value of field with whitespace trimmed off
   
    if (tfld < 1) {
        msg(infofield, "req", "*");
        setfocus(valfield);
        return false;
    } else {
        msg(infofield, "req", " ");
    }

    return true;
}


// --------------------------------------------
//                  setfocus
// Delayed focus setting to get around IE bug
// --------------------------------------------

function setFocusDelayed() {
    global_valfield.focus();
}

function setfocus(valfield) {
    // save valfield in global variable so value retained when routine exits
    global_valfield = valfield;
    setTimeout('setFocusDelayed()', 100);
}