var gFormInputIsIncorrect=false; // to avoid submitting of incorrect form input this variable will be evaluated in checkRequired(..) (submit without leaving form field with wrong input)
    
    var gErrorMessageNotAWholePositiveNumber = "ist keine ganze positive Zahl!"

    function unsignedIntTypeCheck(field) {
        gFormInputIsIncorrect=false;    
        var value = eval(field).value;
        for( i = 0; i < value.length; ++i)
        if ( value.charAt(i) < "0" || value.charAt(i) > "9" ) { 
            gFormInputIsIncorrect=true;
            alert(value + " " + gErrorMessageNotAWholePositiveNumber);
            eval(field).value = "";
            eval(field).focus();
            return false;
        }
        return true;
    }

    var gErrorMessageNotANumber = "ist keine Zahl!"

    function floatTypeCheck(field) {
        gFormInputIsIncorrect=false;    
        var value = eval(field).value;
        value = value.replace(/,/g,".");
        // ** replace dots that german users may type to separate thousanders **
        //Removed because of mantis 4373 
        //value = value.replace(/(\.)(?=\d\d\d)/g,"");
        eval(field).value = value;
        if (isNaN(value)) {
            gFormInputIsIncorrect=true;
            alert(value + " " + gErrorMessageNotANumber);
            eval(field).focus();
            return false;
        }
        return true;
    }

    /**
    * checks the given date field with default pattern "dd.MM.yyyy"
    */
    function dateTypeCheck(mfield) {
        return dateTypeCheckWithPattern(mfield, "dd.MM.yyyy");
    }

    /**
    * checks a given field against the date format pattern that is given as 
    * parameter. The pattern looks like "dd.MM.yyyy" or "yy-MM-dd HH:mm:ss" for
    * example. 
    * This function works only with JavaScript 1.2! It uses replace() and Number().
    * The following pattern symbols are allowed:
    * 
 Symbol   Meaning                 Presentation        Example
 ------   -------                 ------------        -------
 yyyy     year                    (Number)            1996
 yy       year                    (Number)            02
 MM       month in year           (Number)            07
 dd       day in month            (Number)            10
 HH       hour in day (0~23)      (Number)            00
 mm       minute in hour          (Number)            30
 ss       second in minute        (Number)            55
 SSS      millisecond             (Number)            978
 
    * see java.text.SimpleDateFormat!
    */  
    function dateTypeCheckWithPattern(field, datePattern) {         
        gFormInputIsIncorrect=false;    

        var dateString = eval(field).value;

        if (dateString == "")
            return true;

        // ** analyze the pattern **
        var dayPos = datePattern.indexOf("dd");
        var dayLength = 2;
        var monthPos = datePattern.indexOf("MMM");
        var monthLength = 3;
        if (monthPos == -1) {
            monthPos = datePattern.indexOf("MM");
            monthLength = 2;
        }
        var yearPos = datePattern.indexOf("yyyy");
        var yearLength = 4;
        if (yearPos == -1) {
            yearPos = datePattern.indexOf("yy");
            yearLength = 2;
        }
        var hourPos = datePattern.indexOf("HH");
        var hourLength = 2;
        var minutePos = datePattern.indexOf("mm");
        var minuteLength = 2;
        var secondPos = datePattern.indexOf("ss");
        var secondLength = 2;
        var millisecondPos = datePattern.indexOf("SSS");
        var millisecondLength = 3;

        // ** get values by pattern **
        var day = -1;
        var month = -1;
        var year = -1;
        var hour = -1;
        var minute = -1;
        var second = -1;
        var millisecond = -1;

        // ** fix a simple german pattern with leading 0s and 4-digit years **
        dateString = simpleGermanPatternFix(dateString, datePattern);
        field.value = dateString;

        if (dayPos > -1) {
            var dayStr = dateString.substring(dayPos, (dayPos + dayLength));
            day = new Number(dayStr);
            if (isNaN(day))
                return dateFormatError(field, dateString, datePattern);
        }
        if (monthPos > -1) {
            var monthStr = dateString.substring(monthPos, (monthPos + monthLength));
            month = new Number(monthStr);
            if (isNaN(month)) {
                month = getMonthNumber(monthStr);
            }
                //return dateFormatError(field, dateString, datePattern);
        }
        if (yearPos > -1) {
            var yearStr = dateString.substring(yearPos, (yearPos + yearLength));
            year = new Number(yearStr);
            if (isNaN(year))
                return dateFormatError(field, dateString, datePattern);
        }
        if (hourPos > -1) {
            var hourStr = dateString.substring(hourPos, (hourPos + hourLength));
            hour = new Number(hourStr);
            if (isNaN(hour) || hourStr == "") {
                hour = 0;
                hourStr = "00";
                //return dateFormatError(field, dateString, datePattern);
            } else if (hourStr.length == 1) {
                hourStr = "0" + hourStr;
            }
        }
        if (minutePos > -1) {
            var minuteStr = dateString.substring(minutePos, (minutePos + minuteLength));
            minute = new Number(minuteStr);
            if (isNaN(minute) || minuteStr == "") {
                minute = 0;
                minuteStr = "00";
                //return dateFormatError(field, dateString, datePattern);
            } else if (minuteStr.length == 1) {
                minuteStr = "0" + minuteStr;
            }
        }
        if (secondPos > -1) {
            var secondStr = dateString.substring(secondPos, (secondPos + secondLength));
            second = new Number(secondStr);
            if (isNaN(second) || secondStr == "") {
                second = 0;
                secondStr = "00";
                //return dateFormatError(field, dateString, datePattern);
            } else if (secondStr.length == 1) {
                secondStr = "0" + secondStr;
            }
        }
        if (millisecondPos > -1) {
            var millisecondStr = dateString.substring(millisecondPos, (millisecondPos + millisecondLength));
            millisecond = new Number(millisecondStr);
            if (isNaN(millisecond) || millisecondStr == "") {
                millisecond = 0;
                millisecondStr = "000";
                //return dateFormatError(field, dateString, datePattern);
            } else if (millisecondStr.length == 1) {
                millisecondStr = "00" + millisecondStr
            } else if (millisecondStr.length == 2) {
                millisecondStr = "0" + millisecondStr
            }
        }
        // ** check correctness of single values **
        var upper = 31;
        if ( month == 4 || month == 6 || month == 9 || month == 11 )
            upper = 30;
        else if ( month == 2 )
            upper = 29;
        if ((dayPos > -1) && (day < 1 || day > upper)) {
            return dateFormatError(field, dateString, datePattern);
        }
        if ((monthPos > -1) && (month < 1 || month > 12)) {
            return dateFormatError(field, dateString, datePattern);
        }
        if ((yearPos > -1) && (year < 0)) {
            return dateFormatError(field, dateString, datePattern);
        }
        if ((hourPos > -1) && (hour < 0 || hour > 23)) {
            return dateFormatError(field, dateString, datePattern);
        }
        if ((minutePos > -1) && (minute < 0 || minute > 59)) {
            return dateFormatError(field, dateString, datePattern);
        }
        if ((secondPos > -1) && (second < 0 || second > 59)) {
            return dateFormatError(field, dateString, datePattern);
        }
        if ((millisecondPos > -1) && (millisecond < 0 || millisecond > 999)) {
            return dateFormatError(field, dateString, datePattern);
        }
        // ** check correctness of entire String **
        var testStr = datePattern;
        if (dayPos > -1)
            testStr = testStr.replace(/dd/, dayStr);
        if (monthPos > -1 && monthLength == 2)
            testStr = testStr.replace(/MM/, monthStr);
        if (monthPos > -1 && monthLength == 3 && month > 0)
            testStr = testStr.replace(/MMM/, getMonthString(month));
        if (yearPos > -1) {
            if (yearLength == 2)
                testStr = testStr.replace(/yy/, yearStr);
            else if (yearLength == 4)
                testStr = testStr.replace(/yyyy/, yearStr);
        }
        if (hourPos > -1) 
            testStr = testStr.replace(/HH/, hourStr);
        if (minutePos > -1) 
            testStr = testStr.replace(/mm/, minuteStr);
        if (secondPos > -1)
            testStr = testStr.replace(/ss/, secondStr);
        if (millisecondPos > -1)
            testStr = testStr.replace(/SSS/, millisecondStr);
        // ** now testStr should exactly look like the given dateString **
        if (testStr != dateString) {
            // ** check again with the new string **
            field.value = testStr;
            return dateFormatError(field, dateString, datePattern);
        }

        return true;
    }

    // ** this variable defines the time that is set by default if time is found in pattern, but user only provides the date.
    // ** It may be overridden to define another default time. 
    var gTimecheckDefaultTime = "00:00";

    function setTimecheckDefaultTime(mValue) {
        if (mValue != null)
            gTimecheckDefaultTime = mValue;
    }

    function getTimecheckDefaultTime() {
        return gTimecheckDefaultTime;
    }

    /**
    * helper method to replace 2-digit years by 4-digit years and 1-digit 
    * day or month by 2-digit day or month (only if datePattern is the simple 
    * german date pattern: "dd.MM.yyyy").
    */
    function simpleGermanPatternFix(dateString, datePattern) {
        var tmpDate = "";
        var tmpTime = "";
        var dateSep = ".";
        var patternDateSep = ".";

        var patternParts = datePattern.split(" ");
        var patternPartsDate = "";
        var patternPartsTime = "";

        // ** indizes in pattern **
        var monthIndex = -1;
        var yearIndex = -1;
        var dayIndex = -1;

        for (var i = 0; i < patternParts.length; i++) {
            if (patternParts[i].indexOf(".") > -1 || patternParts[i].indexOf("-") > -1 || patternParts[i].indexOf("/") > -1) {
                patternPartsDate = patternParts[i];
                if (patternParts[i].indexOf("-") > -1)
                    patternDateSep = "-";
                if (patternParts[i].indexOf("/") > -1)
                    patternDateSep = "/";
            }
            if (patternParts[i].indexOf(":") > -1) {
                patternPartsTime = patternParts[i];
            }
        }

        var tmpParts = dateString.split(" ");
        for (var i = 0; i < tmpParts.length; i++) {
            if (tmpParts[i].indexOf(".") > -1 || tmpParts[i].indexOf("-") > -1 || tmpParts[i].indexOf("/") > -1) {
                tmpDate = tmpParts[i];
                if (tmpParts[i].indexOf("-") > -1)
                    dateSep = "-";
                if (tmpParts[i].indexOf("/") > -1)
                    dateSep = "/";
            }
            if (tmpParts[i].indexOf(":") > -1) {
                tmpTime = tmpParts[i];
            }
        }

        if (patternPartsDate.length > 0) {
            var datePatternParts = patternPartsDate.split(patternDateSep); // ** splits into dd MM yyyy **
            var dateParts = tmpDate.split(dateSep); // ** splitted values **

            var dayStr = "";
            var monthStr = "";
            var yearStr = "";

            for (var i = 0; i < datePatternParts.length; i++) {
                if (datePatternParts[i] == "dd")
                    dayIndex = i;
                if (datePatternParts[i] == "MM" || datePatternParts[i] == "MMM")
                    monthIndex = i;
                if (datePatternParts[i] == "yyyy" || datePatternParts[i] == "yy")
                    yearIndex = i;
            }
        
            if (dayIndex > -1 && dayIndex < dateParts.length)
                dayStr = dateParts[dayIndex];
            if (monthIndex > -1 && monthIndex < dateParts.length)
                monthStr = dateParts[monthIndex];
            if (yearIndex > -1 && yearIndex < dateParts.length)
                yearStr = dateParts[yearIndex];

            if (dayStr.length == 1)
                dayStr = "0" + dayStr;
            var month = new Number(monthStr);
            if (isNaN(month)) {
                month = getMonthNumber(monthStr); // ** if no correct month, returns current month **
            } 
            if (datePatternParts[monthIndex].length == 2 && month < 10)
                monthStr = "0" + month;
            if (datePatternParts[monthIndex].length == 3) {
                monthStr = getMonthString(month);
            }
            if (yearStr.length < 3) {
                if (yearStr == "") {
                    yearStr = "" + (new Date().getFullYear());
                } else {
                    var year = new Number(yearStr);
                    if (!isNaN(year) && datePatternParts[yearIndex] == "yyyy") {
                        // ** hardcoded step at 2040 means: 39 becomes 2039, 40 becomes 1940 **
                        if (year < 40) {
                            year = 2000 + year;
                        } else {
                            year = 1900 + year;
                        }
                        yearStr = "" + year;
                    }
                }
            }
            if (dayStr.length > 0 && monthStr.length > 0 && yearStr.length > 0) {
                tmpDate = patternPartsDate;
                tmpDate = tmpDate.replace(/dd/, dayStr);
                    if (datePatternParts[monthIndex].length == 3)
                        tmpDate = tmpDate.replace(/MMM/, monthStr);
                    if (datePatternParts[monthIndex].length == 2)
                        tmpDate = tmpDate.replace(/MM/, monthStr);
                    if (datePatternParts[yearIndex].length == 4)
                        tmpDate = tmpDate.replace(/yyyy/, yearStr);
                    if (datePatternParts[yearIndex].length == 2)
                        tmpDate = tmpDate.replace(/yy/, yearStr);
            }
        }
    
        if (patternPartsTime.length > 0) {
            if (tmpTime == "")
                tmpTime = getTimecheckDefaultTime();
            tmpTime = simpleTimeFix(tmpTime, patternPartsTime);
        }

        if (tmpDate == "" && patternPartsDate != "")
            tmpDate = dateToString(new Date(), patternPartsDate);

 
        if (tmpDate == "" && tmpTime == "")
            return dateString;
        else {
            var combined = datePattern;
            var dateReg = new RegExp(patternPartsDate);
            var timeReg = new RegExp(patternPartsTime);
            combined = combined.replace(dateReg, tmpDate);
            combined = combined.replace(timeReg, tmpTime);
            return combined;
        }
    }

    /**
     * fixes hours, minutes, seconds, but at the moment no milliseconds
     */
    function simpleTimeFix(dateString, datePattern) {
        var tmp = dateString;
        
        var timePatternParts = datePattern.split(":");
        var timeParts = dateString.split(":");
        
        var hourStr = "0";
        var minuteStr = "0";
        var secStr = "0";
        var msecStr = "0";
        
        for (var i = 0; i < timeParts.length; i++) {
            if (i < timePatternParts.length) {
                if (timePatternParts[i] == "HH")
                    hourStr = timeParts[i];
                if (timePatternParts[i] == "mm")
                    minuteStr = timeParts[i];
                if (timePatternParts[i] == "ss")
                    secStr = timeParts[i];
                if (timePatternParts[i] == "SSS")
                    msecStr = timeParts[i];
            }
        }
        
        if (hourStr.length == 1)
            hourStr = "0" + hourStr;
        if (minuteStr.length == 1)
            minuteStr = "0" + minuteStr;
        if (secStr.length == 1)
            secStr = "0" + secStr;
        if (msecStr.length == 1)
            msecStr = "0" + msecStr;
        if (msecStr.length == 2)
            msecStr = "0" + msecStr;
        tmp = datePattern;
        tmp = tmp.replace(/HH/, hourStr);
        tmp = tmp.replace(/mm/, minuteStr);
        tmp = tmp.replace(/ss/, secStr);
        tmp = tmp.replace(/SSS/, msecStr);

        return tmp;
    }

    var gErrorMessageDateFormatIncorrect = "ist kein Datum im Format"

    function dateFormatError(field, value, datePattern) {
        gFormInputIsIncorrect=true;
        alert("'" + value + "' " + gErrorMessageDateFormatIncorrect + " '" + datePattern + "'! ");
        eval(field).focus();
        return false;
    }

/**
 * ********************** dateToString *************************
 * converts a date to a string by given date pattern that can consist of the 
 * following elements: 
 * Symbol   Meaning                 Presentation        Example
 ------   -------                 ------------        -------
 yyyy     year                    (Number)            1996
 yy       year                    (Number)            02
 MM       month in year           (Number)            07
 dd       day in month            (Number)            10
 HH       hour in day (0~23)      (Number)            00
 mm       minute in hour          (Number)            30
 ss       second in minute        (Number)            55
 SSS      millisecond             (Number)            978
 */
    function dateToString(mDate, datePattern) {
        var d = mDate.getDate();
        var M = mDate.getMonth();
        var y = mDate.getFullYear();
        var h = mDate.getHours();
        var m = mDate.getMinutes();
        var s = mDate.getSeconds();
        var sss = mDate.getMilliseconds();

        // ** analyze the pattern **
        var dayPos = datePattern.indexOf("dd");
        var dayLength = 2;
        var monthPos = datePattern.indexOf("MM");
        var monthLength = 2;
        if (datePattern.indexOf("MMM") > -1)
            monthLength = 3;
        var yearPos = datePattern.indexOf("yyyy");
        var yearLength = 4;
        if (yearPos == -1) {
            yearPos = datePattern.indexOf("yy");
            yearLength = 2;
        }
        var hourPos = datePattern.indexOf("HH");
        var hourLength = 2;
        var minutePos = datePattern.indexOf("mm");
        var minuteLength = 2;
        var secondPos = datePattern.indexOf("ss");
        var secondLength = 2;
        var millisecondPos = datePattern.indexOf("SSS");
        var millisecondLength = 3;

        var dayStr = "" + d;
        var monthStr = "" + (M+1);
        if (monthLength == 3)
            monthStr = "" + getMonthString((M+1));
        var yearStr = "" + y;
        var hourStr = "" + h;
        var minuteStr = "" + m;
        var secondStr = "" + s;
        var millisecondStr = "" + sss;
        if (d < 10)
                dayStr = "0" + dayStr;
        if ((M+1) < 10 && monthLength == 2)
                monthStr = "0" + monthStr;
        if (h < 10)
                hourStr = "0" + h;
        if (m < 10)
                minuteStr = "0" + m;
        if (s < 10)
                secondStr = "0" + s;
        if (sss < 100)
                millisecondStr = "0" + sss;
        if (sss < 10)
                millisecondStr = "0" + millisecondStr;
        
        var retStr = datePattern;
        if (dayPos > -1)
            retStr = retStr.replace(/dd/, dayStr);
        if (monthPos > -1) {
            if (monthLength == 2)
                retStr = retStr.replace(/MM/, monthStr);
            if (monthLength == 3)
                retStr = retStr.replace(/MMM/, monthStr);
        }
        if (yearPos > -1) {
            if (yearLength == 4)
                retStr = retStr.replace(/yyyy/, yearStr);
            else if (yearLength == 2)
                retStr = retStr.replace(/yy/, yearStr.substring(2,4));
        }
        if (hourPos > -1) 
            retStr = retStr.replace(/HH/, hourStr);
        if (minutePos > -1) 
            retStr = retStr.replace(/mm/, minuteStr);
        if (secondPos > -1)
            retStr = retStr.replace(/ss/, secondStr);
        if (millisecondPos > -1)
            retStr = retStr.replace(/SSS/, millisecondStr);
        
        return retStr;
    }

    function emailTypeCheck(field) {
        gFormInputIsIncorrect=false;    

        var value = eval(field).value;
        gFormInputIsIncorrect = !testEmail(value)        
        if (gFormInputIsIncorrect)
        {
            return emailFormatError(field, value);
        }
        return true;
    }


    var gErrorMessageEmailFormatIncorrect = "ist keine g\u00fcltige Email-Adresse!";

    function emailFormatError(field, value) {
        gFormInputIsIncorrect=true;
        
        alert(value + " " + gErrorMessageEmailFormatIncorrect);
        eval(field).focus();
        return false;
    }
 
 
    var gErrorMessagePhoneTypeIncorrect = "ist keine g\u00fcltige Tel/Fax Nummer!";
 
    function phoneTypeCheck(field) {
        gFormInputIsIncorrect=false;    

        var value = eval(field).value;
        gFormInputIsIncorrect = !testEuropeanPhoneNumber(value);
        if (gFormInputIsIncorrect)
        {
            gFormInputIsIncorrect=true;
            alert(value + " " + gErrorMessagePhoneTypeIncorrect);
            eval(field).focus();
            return false;
        }
        return true;
    }


    var gErrorMessagePleaseShortenTextBegin = "Bitte k\u00fcrzen Sie Ihren Text auf maximal";
    var gErrorMessagePleaseShortenTextEnd = "Zeichen!";

    function unsignedLengthTypeCheck(obj,len) {
        gFormInputIsIncorrect=false;
        
        if(obj.value.length > len)
        {
            gFormInputIsIncorrect=true;
            alert(gErrorMessagePleaseShortenTextBegin + " "+len+" " + gErrorMessagePleaseShortenTextEnd);
            eval(obj).value = eval(obj).value.substring(0, len);
            eval(obj).focus();
            return false;
        }   
        return true;
    }

    var gErrorMessageRequired = "ist ein Pflichtfeld. Bitte machen Sie eine Angabe!";

    /**
     * checks all elements of given (or first) form in document for an HTML
     * attribute "isRequired". If that attribute is found and its value is "true"
     * and the element is a text input field, then this method checks if
     * the user has made a text-input of at least MINIMUM_LENGTH characters.
     * @return true if all required fields are filled, false otherwise
     */
    function checkRequired(mForm) {
        var MINIMUM_LENGTH = 1;
        if (!eval(mForm))
            mForm = document.forms[0];
        var mElem = null;
        var isReq = false;
        var gFormInputIsIncorrect = false;
        
        if (eval(mForm)) {
            for (var i = 0; i < mForm.elements.length; i++) {
                isReq = false;
                mElem = mForm.elements[i];
                if (eval(mElem.getAttribute("isRequired"))) {
                    if (mElem.getAttribute("isRequired") == "true")
                        isReq = true;
                } 
                // ** check that required text input fields are filled with at least MINIMUM_LENGTH characters **
                if (isReq == true) { 
                    var isEmpty = false;
                    var text = mElem.name;
                    if (mElem.getAttribute("description") != null)
                        text = mElem.getAttribute("description"); 
                    if (mElem.type == "text" || mElem.type == "password" || mElem.type == "hidden" || mElem.type == "textarea") {
                        if (trim(mElem.value).length < MINIMUM_LENGTH)
                            isEmpty = true;
                    }
                    if (mElem.type == "radio") {
                         var isRadioChecked = false;
                        // ** find the other radio buttons with the same name **
                        for (var j = 0; j < mForm.elements.length; j++) {
                            if (mForm.elements[j].name == mElem.name && mForm.elements[j].type == "radio") {
                                if (mForm.elements[j].checked == true && mForm.elements[j].value != "")
                                    isRadioChecked = true;
                            }
                        }
                        if (!isRadioChecked)
                            isEmpty = true;
                    }
                    if (mElem.type == "checkbox") {
                        if (mElem.checked == false) 
                            isEmpty = true;
                    }
                    if (mElem.type == "select" || mElem.type == "select-one") {
                        if(mElem.options.length>0)
                            if (trim(mElem.options[mElem.selectedIndex].value).length < MINIMUM_LENGTH)
                                isEmpty = true;
                    }
                    if (isEmpty) {
                        alert("'" + text + "' " + gErrorMessageRequired);
                        mElem.focus();
                        return false;
                    }
                }
            }
        }
        if(gFormInputIsIncorrect) {
            return false;
        }
        return true;
    }

    var gErrorMessageMinLength=" is shorter than required minimal length: ";
    var gOnBlurFocusingItself = false;
    /**
    * Checks given text form element's value for length. 
    * If it is shorter than minLength, shows error message. If the field is not required (does not have attribute "isRequired" = true)
    * and is empty, it passes the check, too. 
    * @return true if form element's value length is larger or equal than minLength, false otherwise
    */
    function checkMinLength(mElem, minLength){
        if (gOnBlurFocusingItself) { //preving endless loop in IE
            gOnBlurFocusingItself = false;
            return;
        }

        var isReq = false;
        var tooShort = false;
        var text = mElem.name;
        if (mElem.getAttribute("description") != null)
            text = mElem.getAttribute("description");
            if (mElem.getAttribute("isRequired") == "true"){
                isReq = true;
            }
         
        if (mElem.type == "text" || mElem.type == "password" || mElem.type == "hidden" || mElem.type == "textarea") {
            if ((isReq && trim(mElem.value).length < 1) || (trim(mElem.value).length >= 1 && trim(mElem.value).length < minLength)){
                tooShort = true;
            }
        }
        if (tooShort) {
            alert("'" + text + "' " + gErrorMessageMinLength + minLength);
            if (window.event && window.event.type == 'blur') { //IE fix - prevent endless loop
                gOnBlurFocusingItself = true;
            }
            mElem.focus();
            return false;
        }
        return true;
    }
    
    /**
     * remove white spaces, tabs and carriage returns from a String
     * @return trimmed String
     */
    function trim(s) {
        if(s==null)
            return null;

        if(s.length==0)
            return '';

        // remove leading spaces and carriage returns
        while ((s.substring(0,1) == ' ') || (s.substring(0,1) == '\n') || (s.substring(0,1) == '\r')) {
            s = s.substring(1,s.length);
        }

        // remove trailing spaces and carriage returns
        while ((s.substring(s.length-1,s.length) == ' ') || (s.substring(s.length-1,s.length) == '\n') || (s.substring(s.length-1,s.length) == '\r')) {
            s = s.substring(0,s.length-1);
        }
        return s;
    }

    // ***********************************************************************
    // ** Methods for Month Strings. This may be outsourced later to a 
    // ** localized file (JSP)
    // ***********************************************************************
    var monthStringArr=new Array("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");

    function getMonthString(monthNumber) {
        if (monthNumber > 0 && monthNumber <= 12)
            return monthStringArr[monthNumber - 1];
        else
            return monthStringArr[(new Date()).getMonth()];
    }

    function getMonthNumber(monthString) {
        for (var i = 0; i < monthStringArr.length; i++) {
            if (monthStringArr[i].toLowerCase() == monthString.substr(0,3).toLowerCase())
                return (i+1);
        }
        return ((new Date()).getMonth()+1);
    }

/*
*******************************************************************************
** methods for validating phone numbers and e-mail adresses
*******************************************************************************
*/

/*
    top level domain is allowed to be 2 characters long or one of the named 3-5 characters long domains
*/
function testEmail(src) {
    src = trim(src);
    if (src == "") {
        return true;
    }
    
    var regex = new RegExp("^([a-zA-Z0-9_\.\-]|\\+)+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$");
    if (!regex.test(src)) {
        return false;
    }
    
    var parts = src.split("@");
    if (parts.length != 2) {
        return false;
    }
    var name = parts[0];
    var domain = parts[1];
    
    var domains = domain.split(".");
    if (domains.length < 2) {
        return false;
    }
    
    //first level domain has to be two characters long or one of the named domains
    var firstLevelDomain = domains[domains.length - 1];
    regex = new RegExp("^(\\w{2}|(com|net|org|edu|int|mil|gov|arpa|biz|aero|name|coop|info|pro|museum))$", "i");
    if (!regex.test(firstLevelDomain)) {
        return false;
    }

    return true;    
}

/*
    tests general phone number (aplha characters allowed)
*/
function testGeneralPhoneNumber(src) {
    src = trim(src);
    if (src == "") {
        return true;
    }
    var phoneReg = "^[+|0-9][0-9-/()\\. ]*[0-9)]$";
    var regex = new RegExp(phoneReg, "i");
    return regex.test(src);
}

/*
    tests european form phone number (aplha characters not allowed)
*/
function testEuropeanPhoneNumber(src) {
    src = trim(src);
    if (src == "") {
        return true;
    }
    var phoneReg = "^[+|0-9][0-9-/()\\. ]*[0-9)]$";
    var regex = new RegExp(phoneReg, "i");
    return regex.test(src);
}


/*
*******************************************************************************
** methods for validating distribution lists
*******************************************************************************
*/

function emailDistributionListTypeCheck(field) {
    var value = eval(field).value;
    var list = value.split(/[;,]/);
    for(var i in list) {
        if (!testEmail(list[i])) {
            return emailFormatError(field, list[i]);
        }
    }
    return true;
}

function phoneDistributionListTypeCheck(field) {
    var value = eval(field).value;
    var list = value.split(/[;,]/);
    for(var i in list) {
        if (!testEuropeanPhoneNumber(list[i])) {
            alert(value + " " + gErrorMessagePhoneTypeIncorrect);
            eval(field).focus();
            return false;
        }
    }
    return true;
}