// To implent validation on a page, follow the format of the following
// examples and load the method after the document body is loaded.
//
// See the ValidateField() method for the pre-built validation types and names.
//
// 		 function AddValidators() {
//			<%
//				string thresholdID = "";
//				
//				// If in edit mode
//				if (CustomSLAReportsDG.EditItemIndex > -1)
//				{
//					// Give DataGrid Update button a browser-accessible id.
//					LinkButton but = (LinkButton)CustomSLAReportsDG.SelectedItem.Cells[5].Controls[0];
//					but.Attributes["id"] = "UpdateButton";
//					
//					// Get ID of fields to validate
//					thresholdID = CustomSLAReportsDG.SelectedItem.FindControl("GridThresholdTB").ClientID;
//				}
//			%>
//			
//			// Add Rules
//			AddRule("validate", "<%=thresholdID%>", true, "numeric", "", "Threshold must be a positive number.");
//			
//			// Apply validation event to appropriate button
//			ApplyToObject("validate", "UpdateButton");
//		}
//
// OR
//
// 		 function AddValidators() {
//			// Add Rules
//			AddRule("validate", "<%=Page.FindControl("UserNameTB").ClientID%>", true, "usrename", "", "Username is a required field and must be at least 4 characters long.");
//			AddRule("validate", "<%=Page.FindControl("FirstNameTB").ClientID%>", true, "", "", "First Name is a required field and must be at least 4 characters long.");
//			
//			// Apply validation event to appropriate button(s)
//			ApplyToObject("validate", "<%=Page.FindControl("SaveNewB").ClientID%>");
//			ApplyToObject("validate", "<%=Page.FindControl("AssignSitesB").ClientID%>");
//		}

// Add regular expressions here.

var reUsername = /^[a-zA-Z0-9\s\-_]*$/;
var reUsernameOrEmail = /^[a-zA-Z0-9\s\-_]*$|^(([^<>()[\]\\.,;:\'\s@\"]+(\.[^<>()[\]\\.,;:\'\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
var rePosInteger = /^\d+$/;
var rePosIntegerNoZero = /^(0+[1-9]|[1-9])[0-9]*$/;
var reInteger = /^\-?\d+$/;
var rePosNumeric = /^\d*\d(\.\d\d*)?$/;
var reNumeric = /^\-?\d*\d(\.\d\d*)?$/;
var reEmpty = /^\s*$/;
var reUSPhoneNumberNoExtension = /^(\(\d{3}\)|\d{3})\s?\d{3}[- ]?\d{4}$/;
var reUSPhoneNumber = /^(\(\d{3}\)|\d{3})\s?\d{3}[- ]?\d{4}(\s?((ext)|(x))\s?\d{4})?$/;
var rePhoneNumber = /^((\+\d{1,3}(-| )?\(?\d\)?(-| )?\d{1,3})|(\(?\d{2,3}\)?))(-| )?(\d{3,4})(-| )?(\d{4})(\s?((ext)|(x))\s?\d{4})?$/;
var rePostalCode = /^[a-zA-Z]\d[a-zA-Z]\s?\d[a-zA-Z]\d$/;
var reZipCode = /^\d\d\d\d\d$/;
var reZipPostal = /^\d{5}-\d{4}|\d{5}|[a-zA-Z]\d[a-zA-Z]\s?\d[a-zA-Z]\d$/;
var reIpAddress = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
var reWebAddress = /^https?\:\/\/[a-zA-Z0-9\-\.]+(\.[a-zA-Z]{2,3})?(\/\S*)?(\:[0-9]+)?([\/a-zA-Z0-9\-\.]+)?$/;
var reWebOrServerAddress = /^(((ht|f)tp(s?))\:\/\/)?(www.|[a-zA-Z].)?[a-zA-Z0-9\-\.]+(\.(com|edu|gov|mil|net|org|biz|info|name|museum|us|ca|uk))?(\:[0-9]+)*(\/($|[a-zA-Z0-9\.\,\;\?\'\\\+&%\$#\=~_\-]+))*$/;
var reURL = /^(http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&amp;:/~\+#]*[\w\-\@?^=%&amp;/~\+#])?/;
var reEmail = /^(([^<>()[\]\\.,;:\'\s@\"]+(\.[^<>()[\]\\.,;:\'\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
var reMultipleEmail = /^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*([,;]\s*\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*)*/;
//var reMultipleEmail = /^(([^<>()[\]\\.,;:\'\s@\"]+(\.[^<>()[\]\\.,;:\'\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))(\;\s*(([^<>()[\]\\.,;:\'\s@\"]+(\.[^<>()[\]\\.,;:\'\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,})))*$/;
var reValidFileName = /^(?!^(PRN|AUX|CLOCK\$|NUL|CON|COM\d|LPT\d|\..*)(\..+)?$)[^\x00-\x1f\\?*:\";|/<>]+$/;
var reNoHtmlTags = /^([^<]|<[^a-zA-Z]|<$)*$/;
var reOid = /^1.3.6(\.\d+)+$/;
var rePort = /^(6553[0-5]|655[0-2]\d|65[0-4]\d\d|6[0-4]\d{3}|[1-5]\d{4}|[1-9]\d{0,3}|0)$/; 
// Internal variables
var __ValidationObjects = "";
var __ValidationCondRules = new Array();
var __ErrorPrompt = "The following errors occurred:";

////////////////////////////////////////////////////////////////////////////////////////

// Generates the regular expression for a positive integer less than or equal to 'upperBound' with the option to include/exclude zero.
function GetNumberRangeRegex(upperBound, nonZero)
{
    var regexExpression = '^(';
    upperBound = upperBound.toString();
    
    //remove zeros at the beginning
    if (upperBound.length > 0)
    {
        upperBound = upperBound.replace(/^0*/, '');
        
        if (upperBound.length == 0)
            upperBound = '0';

        if (upperBound.length == 1)
        {
            if (nonZero)
                regexExpression += (upperBound == 0 ? '' : (upperBound == 1 ? '1' : '[1-' + upperBound + ']'));
            else
                regexExpression += (upperBound == 0 ? '0' : '[0-' + upperBound + ']');
        }
        else
        {
            for (var i = upperBound.length - 1; i > -1; i--)
            {
                var isLastDigit = i == upperBound.length - 1;
                var isFirstDigit = i == 0;
            
                var endLimit = upperBound.length - i;
                var currentDigit = upperBound.charAt(i);
                
                if (isLastDigit)
                {
                    var range = currentDigit > 0 ? '[0-' + currentDigit + ']' : '0';
                    regexExpression = regexExpression + upperBound.substr(0, upperBound.length - endLimit) + range;
                }
                else
                {
                    if (currentDigit > 0)
                    {   
                        currentDigit--;

                        if (isFirstDigit && currentDigit == 0)
                        {
                            //do nothing
                        }
                        else
                        {
                            var range = '';
                            var lowerRangeLimit = ((isFirstDigit && nonZero) ? '1' : '0');	             
                            
                            if (lowerRangeLimit < currentDigit)
                            {
                                range = '[' + lowerRangeLimit + '-' + currentDigit + ']';
                            }
                            else
                            {
                                range = currentDigit.toString();
                            }
            	                
                            var numberOfWildCardDigits = endLimit - 1;
                            var wildCardDigitsExpression = '\\d' + (numberOfWildCardDigits > 1 ? '{' + numberOfWildCardDigits + '}' : '');
            	                
        	                var expression = upperBound.substr(0, upperBound.length - endLimit) + range + wildCardDigitsExpression;
        	                if (expression.indexOf('[0-') == 0)
        	                {
        	                    expression = '[1-' + expression.substr(3, expression.length - 1);
        	                }

                            regexExpression += '|' + expression;
                        }
                    }
                }
            }
            
            var numberOfWildCardDigits = upperBound.length - 1;
            if (numberOfWildCardDigits > 1)
            {
                numberOfWildCardDigits--;
                regexExpression += '|' + (nonZero ? '[1-9]' : '\\d') + '\\d' + '{0,' + numberOfWildCardDigits + '}';
            }
            else
            {
                regexExpression += '|' + (nonZero ? '[1-9]' : '\\d');
            }
        }
    }
    
    regexExpression += ')$';
    
    return regexExpression;
}

// Provides opertunity to override the default english error prompt.
function SetLocalizedErrorPrompt(errPrompt)
{
    __ErrorPrompt = errPrompt;    
}

// Add Validation Rule to page
//   groupName: Name of validation group
//   elementId: ID of the field to add the rule to
//   required: boolean indicating if the field is a required field
//   validationType: The type of validation to be performed
//   regExp: Regular Expression for "custom" validation type.  Either /^ etc. $/ or ""
//   errorMsg: The error message to display
function AddRule(groupName, elementId, required, validationType, regExp, errorMsg) {
	var element = document.getElementById(elementId);
	if (element != null) {
		element.setAttribute("validationgrp", groupName);
		
		if (required)
			element.setAttribute("data-required", "true");
		else
			element.setAttribute("data-required", "false");
			
		element.setAttribute("validation", validationType);
		element.setAttribute("regexp", regExp);
		element.setAttribute("errormsg", errorMsg);
		
		if (__ValidationObjects == "")
			__ValidationObjects = elementId;
		else
			__ValidationObjects += "," + elementId;
	}
}

//this override allows you to validate the value of one element and highlight another element if validation fails
function AddRule(groupName, elementId, required, validationType, regExp, errorMsg, elementToHighlight) {
	var element = document.getElementById(elementId);
	if (element != null) {
		element.setAttribute("validationgrp", groupName);
		
		if (required)
			element.setAttribute("data-required", "true");
		else
			element.setAttribute("data-required", "false");
			
		element.setAttribute("validation", validationType);
		element.setAttribute("regexp", regExp);
		element.setAttribute("errormsg", errorMsg);
		
		if(elementToHighlight)
		{
		    element.setAttribute("elementToHighlight", elementToHighlight);
		}
		if (__ValidationObjects == "")
			__ValidationObjects = elementId;
		else
			__ValidationObjects += "," + elementId;
	}
}

function RemoveValidationRule(elementId) {
	var valObjects = __ValidationObjects.split(",");
	var newValObjects = new Array();

	for (i=0; i<valObjects.length; i++) {
		if (valObjects[i] != elementId)
			newValObjects.push(valObjects[i]);
	}
	__ValidationObjects = newValObjects.join(",");		
}

// Add Rule such that one of the provided groupings of elements must have input.
// eg. AddConditionalRule("group", "somename", true, "Error Message", "lastName,firstName", "lastName,username,password");
//     Fulfillment of at one and only one of the following conditions will result in this rule returning true:
//     - lastName and firstName are non-empty/checked
//     - lastName, username, and password are non-empty/checked
//
// groupName: Name of the validation group
// ruleName: A unique name for this conditional rule
// exclusive: Boolean indicating if test should be exclusive (one and only one) or inclusive (at least one)
// errorMsg: The error message to display
// ids_1, ids_2,...,ids_n: Comma-delimited lists of element id's to check
function AddConditionalRule(groupName, ruleName, exclusive, errorMsg, ids) {
	if (arguments.length < 5)
		return;
		
	var newRuleId = "__ValidationCondRule_" + groupName + "_" + ruleName;
	var elements = new Array();
	for (var i=4; i<arguments.length; i++) {
		elements.push(arguments[i]);
	}
	__ValidationCondRules.push(elements);
	var newRuleIndex = __ValidationCondRules.length-1;
	
	var newRule = document.createElement("input");
	newRule.setAttribute("id", newRuleId);
	newRule.setAttribute("type", "hidden");
	newRule.setAttribute("value", newRuleIndex);
	
	if (exclusive)
		newRule.setAttribute("exclusive", "true");
	else
		newRule.setAttribute("exclusive", "false");
		
	newRule.setAttribute("validationgrp", groupName);
	newRule.setAttribute("validation", "conditional");
	newRule.setAttribute("errormsg", errorMsg);
	
	document.appendChild(newRule);
	
	if (__ValidationObjects == "")
		__ValidationObjects = newRuleId;
	else
		__ValidationObjects += "," + newRuleId;
}
	
	

// Apply Validation Event to an object
//   groupName: The validation group to validate
//   elementId: The ID of the object that should initiate validation.
function ApplyToObject(groupName, elementId) {
	var element = document.getElementById(elementId);
	if (element != null) {
		element.setAttribute("onclick", "var o = Validate('" + groupName + "'); if (o == false){event.returnValue = false;} return o;");
		
		// Do not remove this line.  Line is necessary for IE to register the event.
		element.outerHTML = element.outerHTML; 
	}
}

// Apply Validation Event to a datagrid
// To be used when the "Update" button ID cannot be found
//   groupName: The validation group to validate
//   buttonText: The inner HTML text of the button to search for (eg. "Update" or "Save")
//   gridId: The ID of the datagrid to search
function ApplyToGrid(groupName, buttonText, gridId) {
	var element = document.getElementById(gridId);
	if (element != null) {
		element.setAttribute("onclick", "return ValidateFromGrid(event, '" + buttonText + "', '" + groupName + "');");
		
		// Do not remove this line.  Line is necessary for IE to register the event.
		element.outerHTML = element.outerHTML; 
	}
}


////////////////////////////////////////////////////////////////////////////////////////


// Validate when link or button with text is clicked.  For situations where
// the actual object's ID cannot be retrieved and a search for the text in a
// parent object must be done to find the object.
//
// evt: event object
// updateText: Display text of the link or button
// group: Name of the validation group
function ValidateFromGrid(evt, updateText, group) {

	if (evt.srcElement.nodeName.toString().toUpperCase() == "INPUT") {
		if (evt.srcElement.type.toUpperCase() == "SUBMIT" || evt.srcElement.type.toUpperCase() == "BUTTON") {
			if (evt.srcElement.value == updateText) {
				return Validate(group);
			}
		}
	} else if (evt.srcElement.nodeName.toString().toUpperCase() == "A" && evt.srcElement.innerHTML == updateText) {
		return Validate(group);
	}
}

// Validate on demand
// group: Name of the validation group
function Validate(group) {
	var errorText = "";
	var errorIds = "";
	var errorFound = false;
	
	if (__ValidationObjects == "")
		return;

	elements = __ValidationObjects.split(",");
	for (var i=0; i<elements.length; i++)
	{
		var currElement = document.getElementById(elements[i]);
		
        if(currElement != null){
	        if (currElement.getAttribute("elementToHighlight") != null)
	        {
	            var elementToHighlight = document.getElementById(currElement.getAttribute("elementToHighlight"));
	            if (elementToHighlight != null)
	            {
                    elementToHighlight.style.backgroundColor = "";		
                }
	        }
		    else if (currElement.style.backgroundColor != null)
		    {
			    currElement.style.backgroundColor = "";
		    }

		    if (currElement.getAttribute("validationgrp") == group)
		    {
			    if (!ValidateField(currElement))
			    {
				    errorText += "<li>" + currElement.getAttribute("errormsg") + "</li>";
				
				    var elementToHighlight = currElement.id;
				    if (currElement.getAttribute("elementToHighlight") != null)
				        elementToHighlight = currElement.getAttribute("elementToHighlight");
				
				    if (errorIds == "")
					    errorIds = elementToHighlight;
				    else
					    errorIds += "," + elementToHighlight;

				    errorFound = true;
			    }
		    }
        }
	}
	
	if (errorFound) {
		DisplayErrorMsg(errorIds, "#FFEEEE", __ErrorPrompt, errorText);
		return false;
	} else {
		return true;
	}
}

// Displays error message popup.  Modify to change look of error message.
function DisplayErrorMsg(ids, fieldBgColor, headerText, bodyText) {
	var popup = window.createPopup();
	var popupBody = popup.document.body;
	
	popupBody.style.border = "solid 1px black";
	popupBody.style.padding = "0px";
	popupBody.style.background = "#FFFFCC";
	popupBody.style.fontFamily = "Arial";
	popupBody.style.fontSize = "x-small";
		
	popupBody.innerHTML = "<div id=\"__ValidationErrorBox\" style=\"width: 300px; overflow: auto; padding: 6px\">" +
	                      headerText + "<ul style=\"color: #FF0000; margin: 5px 0px 0px 20px; list-style-type: square\">" + bodyText + "</ul></div>";

	popup.show(0, 0, 300, 100, document.body);

	var popupHeight = popup.document.getElementById("__ValidationErrorBox").offsetHeight+10;
	if (event.clientX < (window.screen.width/2))
		popup.show(event.clientX, event.clientY-100, 300, popupHeight, document.body);
	else
		popup.show(event.clientX-300, event.clientY-100, 300, popupHeight, document.body);
	
	var fields = ids.split(",");
	for (var i=0; i<fields.length; i++) {
		document.getElementById(fields[i]).style.backgroundColor = fieldBgColor;
	}
}


// Validate a specific HTML object
function ValidateField(element)
{
    var fieldValue;
    if (element.tagName.toLowerCase() == "table")
        fieldValue = (element.rows.length > 1 ? "rows" : "");
    else if (element.tagName.toLowerCase() == "div")
        fieldValue = element.innerHTML;
    else
    	fieldValue = element.value;
	
	var fieldType = element.getAttribute("validation");
	var fieldRequired = element.getAttribute("data-required");
	var fieldRegExp = new RegExp(element.getAttribute("regexp"));
	
	if (fieldValue == null)
		fieldValue = "";
	if (fieldType == null)
		fieldType = "";
	
	if (fieldRequired != null) 
		fieldRequired = ((element.getAttribute("data-required")).toLowerCase() == "true");
	else
		fieldRequired = false;

	// Non-Standard Tests
	if (fieldType.toLowerCase() == "checked") {
		return element.checked;
	} else if (fieldType.toLowerCase() == "conditional") {
		var exclusive = (element.getAttribute("exclusive") == "true");
		return ValidateConditional(fieldValue, exclusive);
	}

	
	// Regular Expression Tests
	if (fieldRequired && reEmpty.test(fieldValue)) {
		return false;
	}

	var testRegExp;
	switch (fieldType.toLowerCase()) {
		case "integer":
			testRegExp = reInteger;
			break;

		case "posinteger":
		    testRegExp = rePosInteger;
		    break;

        case "posintegernozero":
            testRegExp = rePosIntegerNoZero;
            break;

		case "posintegerbis":
		    testRegExp = rePosInteger;
            return (reEmpty.test(fieldValue) || testRegExp.test(fieldValue) && (parseInt(fieldValue) > 0 && parseInt(fieldValue) <= 65535));
		    break;

		case "posinteger16":
			testRegExp = rePosInteger;
            return (reEmpty.test(fieldValue) || testRegExp.test(fieldValue) && (parseInt(fieldValue) >= 0 && parseInt(fieldValue) <= 32767));
			break;

		case "numeric":
			testRegExp = reNumeric;
			break;
		
		case "posnumeric":
			testRegExp = rePosNumeric;
			break;
		
		case "postal":
			testRegExp = rePostalCode;
			break;
		
		case "zip":
			testRegExp = reZipCode;
			break;
		
		case "zippostal":
			testRegExp = reZipPostal;
			break;

	    case "usphonenumbernoextension":
	        testRegExp = reUSPhoneNumberNoExtension;
	        break;
			
	    case "phonenumber":
	        testRegExp = rePhoneNumber;
	        break;
	        
	    case "usphonenumber":
	        testRegExp = reUSPhoneNumber;
	        break;
		
		case "ipaddress":
			testRegExp = reIpAddress;
			break;
			
		case "port":
			testRegExp = rePort;
			break;
			
		case "web":
			testRegExp = reWebAddress;
			break;
			
	    case "weborserver":
	        testRegExp = reWebOrServerAddress;
	        break;
		
		case "email":
			testRegExp = reEmail;
			break;
			
		case "multipleemail":
			testRegExp = reMultipleEmail;
			break;
			
		case "username":
			testRegExp = reUsername;
			break;
			
		case "UsernameOrEmail":
			testRegExp = reUsernameOrEmail;
			break;
			
		case "validfilename":
			testRegExp = reValidFileName;
			break;

		case "custom":
			testRegExp = fieldRegExp;
			break;
			
		case "nohtml":
			testRegExp = reNoHtmlTags;
			break;
			
		case "URL":
			testRegExp = reURL;
			break;
		
		case "oid":
		    testRegExp = reOid;
		    break;
		
		case "regex":
            try
	        {
	            var regularExpression = new RegExp(fieldValue);
	            return true;
	        }
	        catch(error)
	        {
	            return false;
	        }
		    break;
			
		default:
			testRegExp = /.*/;
			break;
	}
	
	return (reEmpty.test(fieldValue) || testRegExp.test(fieldValue));
}

// Validate a conditional rule specified by the element in the specified
// __ValidationCondRules array index
function ValidateConditional(index, exclusive) {
	var args = __ValidationCondRules[index];
	if (args == null)
		return false;

	var ruleValidated = false;
	for (var i=0; i<args.length; i++) {
		var validated = true;
		
		var elements = args[i].split(",");
		for (var j=0; j<elements.length; j++) {
			var currElementId;
			var negate = false;
			if (elements[j].charAt(0) == "!") {
				currElementId = elements[j].substr(1);
				negate = true;
			} else {
				currElementId = elements[j];
				negate = false;
			}	
				
			var currElement = document.getElementById(currElementId);
			if ((currElement.nodeName.toString().toUpperCase() == "INPUT") &&
			    (currElement.getAttribute("type").toUpperCase() == "CHECKBOX" || currElement.getAttribute("type").toUpperCase() == "RADIO")) {
			    if (negate)
					validated = validated && !currElement.checked;
				else
					validated = validated && currElement.checked;
					
			} else {
				if (negate)
					validated = validated && reEmpty.test(currElement.value);
				else
					validated = validated && !reEmpty.test(currElement.value);
			}
		}
		if (exclusive)
			ruleValidated = ruleValidated ^ validated;
		else
			ruleValidated = ruleValidated || validated;
	}
	return ruleValidated;	
}

//function AddHMTLValidation(validationGroup)
//{
//    var textboxes = document.getElementsByTagName('input');
//        for (var i = 0; i < textboxes.length; i++)
//            if (textboxes[i].type == 'text' && textboxes[i].getAttribute("validation") == null)
//                AddRule(validationGroup, textboxes[i].id, false, "nohtml", "", "HTML script tags are not permitted.");
//}

function ValidateForHTMLTags()
{			    
    var reNoHtmlTags = /^([^<]|<[^a-zA-Z]|<$)*$/;
    var htmlTagsDetected = false;
    var textboxes = document.getElementsByTagName('input');
    for (var i = 0; i < textboxes.length; i++)
        if (textboxes[i].type == 'text' && !reNoHtmlTags.test(textboxes[i].value))
        {
            textboxes[i].style.backgroundColor = "#FFEEEE";
            htmlTagsDetected = true;
        }

    if (htmlTagsDetected)
    {
        alert('HTML tags are not permitted.');
        return false;
    }
    else
        return true;
}

function testFormValidation()
{
    alert("FormValidation");
}

//////////////////////////////////////////////////////////////////////////////
//	JavaScript to allow the a Multiline textbox to have a Max Length./////////
//////////////////////////////////////////////////////////////////////////////
function AddKeyEvents(control, max)
{		
	if (control != null)
	{
		control.onkeypress = function() { ValidateDescriptionFieldLength2(control, max); }
		control.onkeyup = function() { ValidateDescriptionFieldLength1(control, max); }
		control.onkeydown = function() { ValidateDescriptionFieldLength1(control, max); }
	}
}

function ValidateDescriptionFieldLength1(control, max)
{
	//var maxlimit = control.MaxLength;
	
	if (control.value.length > max)
		control.value = control.value.substring(0, max-1);
	return true;
}

function ValidateDescriptionFieldLength2(control, max)
{
	//var maxlimit = control.MaxLength;

	if (control.value.length >= max-1)
		return false;
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////