// spezielle Funktionen für die Seite
var isNN = (navigator.appName.indexOf('Netscape') != -1);

function _keyPress(evt) {
    if (document.all) {
        //evt = (evt) ? evt : ((event) ? event : null);
        evt = window.event;
        myString = new String(window.event.srcElement.value);
        oElem = window.event.srcElement;
        keyChar = window.event.keyCode;
    }
    else {
        oElem = evt.target;
        keyChar = String.fromCharCode(evt.which);
        myString = new String(oElem.value);
    }
    var charCode = (evt.charCode || evt.charCode == 0) ? evt.charCode : ((evt.keyCode) ? evt.keyCode : evt.which);
    return charCode;
}

// verwirft den TastenKode
function _preventKeyCode(evt) {
    evt.keyCode = 0;
    evt.returnValue = false;
    if (evt.preventDefault) {
        evt.preventDefault();
    }
}

function KeyPressINT(evt) {
    var charCode = _keyPress(evt);
    if (charCode > 13 && (charCode < 48 || charCode > 57)) {
        _preventKeyCode(evt);
        return false;
    }
    return true;
}

function KeyPressDECIMAL(evt) {
    var charCode = _keyPress(evt);
    // nur Zahlen und Punkt sowie Komma
    if (charCode > 13) {
        if (!((charCode > 47 && charCode < 58) || charCode == 44 || charCode == 46)) {
            _preventKeyCode(evt);
            return false;
        }
    }
    return true;
}

function KeyPressDATE(evt) {
    var charCode = _keyPress(evt);
    // nur Zahlen und Punkt sowie Komma
    if (charCode > 13) {
        if (!((charCode > 47 && charCode < 58) || charCode == 44 || charCode == 46)) {
            _preventKeyCode(evt);
            return false;
        }
    }
    return true;
}

function KeyPressPASSWORD(evt) {
    var charCode = _keyPress(evt);
    if (charCode > 13 && (charCode == 39)) {
        _preventKeyCode(evt);
        return false;
    }
    return true;
}

function doKeypress(control) {
    maxLength = control.attributes["maxLength"].value;
    value = control.value;
    if (maxLength && value.length > maxLength - 1) {
        event.returnValue = false;
        maxLength = parseInt(maxLength);
    }
}
// Cancel default behavior
function doBeforePaste(control) {
    maxLength = control.attributes["maxLength"].value;
    if (maxLength) {
        event.returnValue = false;
    }
}
// Cancel default behavior and create a new paste routine
function doPaste(control) {
    maxLength = control.attributes["maxLength"].value;
    value = control.value;
    if (maxLength) {
        event.returnValue = false;
        maxLength = parseInt(maxLength);
        var oTR = control.document.selection.createRange();
        var iInsertLength = maxLength - value.length + oTR.text.length;
        var sData = window.clipboardData.getData("Text").substr(0, iInsertLength);
        oTR.text = sData;
    }
}


function KeyPress(evt) {
    if (document.all) {
        //evt = (evt) ? evt : ((event) ? event : null);
        evt = window.event;
        myString = new String(window.event.srcElement.value);
        oElem = window.event.srcElement;
        keyChar = window.event.keyCode;
    }
    else {
        oElem = evt.target;
        keyChar = String.fromCharCode(evt.which);
        myString = new String(oElem.value);
    }
    var charCode = (evt.charCode || evt.charCode == 0) ? evt.charCode : ((evt.keyCode) ? evt.keyCode : evt.which);
    bOk = true;
    if (oElem.INTEGER == true) {
        if (charCode > 13 && (charCode < 48 || charCode > 57)) {
            bOk = false;
        }
    }
    if (oElem.KENNUNG == true) {
        // Apostroph entfernen
        if (charCode > 13 && (charCode == 39)) {
            bOk = false;
        }
    }
    if (oElem.TELEFON == true) {
        // nur Zahlen und minus, Leerzeichen und Slash
        if (charCode > 13) {
            if (!((charCode > 47 && charCode < 58) || charCode == 45 || charCode == 32 || charCode == 47)) {
                bOk = false;
            }
        }
    }
    if (oElem.DATE) {
        // nur Zahlen und Punkt sowie Komma
        if (charCode > 13) {
            if (!((charCode > 47 && charCode < 58) || charCode == 44 || charCode == 46)) {
                bOk = false;
            }
        }
    }
    if (oElem.DECIMAL) {
        // nur Zahlen und Punkt sowie Komma
        if (charCode > 13) {
            if (!((charCode > 47 && charCode < 58) || charCode == 44 || charCode == 46)) {
                bOk = false;
            }
        }
    }
    if (bOk == false) {
        if (evt.returnValue) {
            evt.returnValue = false;
        }
        else {
            if (evt.preventDefault) {
                evt.preventDefault();
            }
        }
        return false;
    }
    return true;
}


function ValidateField(sender, args) {
    var bValid = true;
    args.IsValid = false;
    var f = document.forms[0];
    var ctl = f.elements[sender.controltovalidate];
    var sValue = args.Value;
    if (ctl.REQUIRED == true) {
        if (!ctl.DATE) {
        }
        else {
            if (args.Value == ctl.DATE)
                sValue = "";
        }
        if (sValue == "")
            bValid = false;
    }
    // ist etwas zu überprüfen
    if (sValue != "") {
        if (!ctl.DECIMAL) {
        }
        else {
            pattern = "^[0-9]([\,\.][0-9]+)?$";
            bValid = IsValidDecimal(sValue, pattern);
        }
        if (!ctl.INTEGER) {
        }
        if (!ctl.RANGE) {
        }
        else {
            bValid = IsValidRange(sValue, ctl.RANGE);
        }
        if (!ctl.EMAIL) {
        }
        else {
            alert("Email:" + sValue);
            bValid = emailCheck(sValue);

        }
        if (!ctl.PASSWORD) {
        }
        else {
            bValid = IsValidPassword(ctl.value, ctl.PASSWORD);
        }
        // DAtumsfeld abchecken
        if (!ctl.DATE) {
        }
        else {
            sValue = sValue.replace(/j/, "y");
            sValue = sValue.replace(/j/, "y");
            sValue = sValue.replace(/j/, "y");
            sValue = sValue.replace(/j/, "y");
            sValue = sValue.replace(/m/, "M");
            sValue = sValue.replace(/m/, "M");
            sValue = sValue.replace(/t/, "d");
            sValue = sValue.replace(/t/, "d");
            bValid = IsValidDatum(sValue, ctl.DATE);
        }
    }
    args.IsValid = bValid;
}

function CheckPrime(sender, args) {
    var iPrime = parseInt(args.Value);
    var iSqrt = parseInt(Math.sqrt(iPrime));

    for (var iLoop = 2; iLoop <= iSqrt; iLoop++)
        if (iPrime % iLoop == 0) {
        args.IsValid = false;
        return;
    }

    args.IsValid = true;
}


// Formularbezogenene Funktionen

var defButton = ""; 	// Standardbutton zum Abschicken bei CR
// versendet das Formular durch Drücken von Enter
function EnterSubmit(evt) {
    //	alert("EnterSubmit");
    evt = (evt) ? evt : ((event) ? event : null);
    if (getKeyCode(evt) == 13) {
        SendDefaultButtonClick();
    }
}

// versendet das Formular
function SendDefaultButtonClick() {
    var f = document.forms[0];
    //	alert("typeof(Page_ClientValidate)");
    if (typeof (Page_ClientValidate) == 'function') {
        window.ValidatorEnableAll(true);
        SetDefaultButtonEvent(f);
        if (Page_ClientValidate())
            f.submit();
    }
    else {
        SetDefaultButtonEvent(f);
        f.submit();
    }
}

function SetDefaultButtonEvent(f) {
    //	alert(defButton);
    for (i = 0; i < f.elements.length; i++) {
        if (f.elements[i].name == "__EVENTTARGET") {
            //			alert("set defButton");
            f.elements[i].value = defButton;
        }
    }
}

//private Funktionen
function getKeyCode(evt) {
    if (document.all)
        keyChar = evt.keyCode;
    else
        keyChar = String.fromCharCode(evt.which);
    return keyChar;
}


function IsValidRange(sValue, sRange) {
    var wert = sValue.replace(',', '.');
    if (sRange.charAt(0) == "<")
    // Wert größer als er sein darf
        if (wert > eval(sRange.substring(1, sRange.length))) {
        return false;
    }
    if ((sRange.charAt(0) == ">") && (wert > 0))
    // Wert kleiner als er sein darf
        if (wert < eval(sRange.substring(1, sRange.length))) {
        return false;
    }
    if (sRange.charAt(0) == "-") {
        z = sRange.indexOf('+');
        z1 = eval(sRange.substring(0, z));
        z2 = eval(sRange.substring(z, sRange.length));
        if ((wert < z1) || (wert > z2)) {
            return false;
        }
    }
    return true;
}

function IsValidPassword(sValue, nMinLength) {
    var regPat = "(?=([0-9])(?=([0-9a-zA-Z])).{2})";
    var userPat = new RegExp(regPat);
    var matchArray = sValue.match(userPat)
    if (matchArray == null) {
        return false;
    }
    if (sValue.length <= nMinLength) {
        return false;
    }
    return true;
}

// ------------------------------------------------------------------
// These functions use the same 'format' strings as the 
// java.text.SimpleDateFormat class, with minor exceptions.
// The format string consists of the following abbreviations:
// 
// Field        | Full Form          | Short Form
// -------------+--------------------+-----------------------
// Year         | yyyy (4 digits)    | yy (2 digits), y (2 or 4 digits)
// Month        | MMM (name or abbr.)| MM (2 digits), M (1 or 2 digits)
//              | NNN (abbr.)        |
// Day of Month | dd (2 digits)      | d (1 or 2 digits)
// Day of Week  | EE (name)          | E (abbr)
// Hour (1-12)  | hh (2 digits)      | h (1 or 2 digits)
// Hour (0-23)  | HH (2 digits)      | H (1 or 2 digits)
// Hour (0-11)  | KK (2 digits)      | K (1 or 2 digits)
// Hour (1-24)  | kk (2 digits)      | k (1 or 2 digits)
// Minute       | mm (2 digits)      | m (1 or 2 digits)
// Second       | ss (2 digits)      | s (1 or 2 digits)
// AM/PM        | a                  |
//
// NOTE THE DIFFERENCE BETWEEN MM and mm! Month=MM, not mm!
// Examples:
//  "MMM d, y" matches: January 01, 2000
//                      Dec 1, 1900
//                      Nov 20, 00
//  "M/d/yy"   matches: 01/20/00
//                      9/2/00
//  "MMM dd, yyyy hh:mm:ssa" matches: "January 01, 2000 12:30:45AM"
// ------------------------------------------------------------------

var MONTH_NAMES = new Array('January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec');
var DAY_NAMES = new Array('Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat');
function LZ(x) { return (x < 0 || x > 9 ? "" : "0") + x }

// ------------------------------------------------------------------
// isDate ( date_string, format_string )
// Returns true if date string matches format of format string and
// is a valid date. Else returns false.
// It is recommended that you trim whitespace around the value before
// passing it to this function, as whitespace is NOT ignored!
// ------------------------------------------------------------------
function IsValidDatum(val, format) {
    // nichts eingetragen
    if (val == format)
        return true;
    if (_isCharDates(val)) {
        var i = parseInt(val.charAt(0));
        var date = getDateFromFormat(val, format);
        if (date == 0) { return false; }
        return true;
    }
    return false;
}

function IsValidDecimal(val, pattern) {
    if (val == "")
        return true;
    var wert = val.replace(',', '.');
    if (wert.match(pattern) == null) {
        return false;
    }
    return true;
}


// -------------------------------------------------------------------
// compareDates(date1,date1format,date2,date2format)
//   Compare two date strings to see which is greater.
//   Returns:
//   1 if date1 is greater than date2
//   0 if date2 is greater than date1 of if they are the same
//  -1 if either of the dates is in an invalid format
// -------------------------------------------------------------------
function compareDates(date1, dateformat1, date2, dateformat2) {
    var d1 = getDateFromFormat(date1, dateformat1);
    var d2 = getDateFromFormat(date2, dateformat2);
    if (d1 == 0 || d2 == 0) {
        return -1;
    }
    else if (d1 > d2) {
        return 1;
    }
    return 0;
}

// ------------------------------------------------------------------
// formatDate (date_object, format)
// Returns a date in the output format specified.
// The format string uses the same abbreviations as in getDateFromFormat()
// ------------------------------------------------------------------
function formatDate(date, format) {
    format = format + "";
    var result = "";
    var i_format = 0;
    var c = "";
    var token = "";
    var y = date.getYear() + "";
    var M = date.getMonth() + 1;
    var d = date.getDate();
    var E = date.getDay();
    var H = date.getHours();
    var m = date.getMinutes();
    var s = date.getSeconds();
    var yyyy, yy, MMM, MM, dd, hh, h, mm, ss, ampm, HH, H, KK, K, kk, k;
    // Convert real date parts into formatted versions
    var value = new Object();
    if (y.length < 4) { y = "" + (y - 0 + 1900); }
    value["y"] = "" + y;
    value["yyyy"] = y;
    value["yy"] = y.substring(2, 4);
    value["M"] = M;
    value["MM"] = LZ(M);
    value["MMM"] = MONTH_NAMES[M - 1];
    value["NNN"] = MONTH_NAMES[M + 11];
    value["d"] = d;
    value["dd"] = LZ(d);
    value["E"] = DAY_NAMES[E + 7];
    value["EE"] = DAY_NAMES[E];
    value["H"] = H;
    value["HH"] = LZ(H);
    if (H == 0) { value["h"] = 12; }
    else if (H > 12) { value["h"] = H - 12; }
    else { value["h"] = H; }
    value["hh"] = LZ(value["h"]);
    if (H > 11) { value["K"] = H - 12; } else { value["K"] = H; }
    value["k"] = H + 1;
    value["KK"] = LZ(value["K"]);
    value["kk"] = LZ(value["k"]);
    if (H > 11) { value["a"] = "PM"; }
    else { value["a"] = "AM"; }
    value["m"] = m;
    value["mm"] = LZ(m);
    value["s"] = s;
    value["ss"] = LZ(s);
    while (i_format < format.length) {
        c = format.charAt(i_format);
        token = "";
        while ((format.charAt(i_format) == c) && (i_format < format.length)) {
            token += format.charAt(i_format++);
        }
        if (value[token] != null) { result = result + value[token]; }
        else { result = result + token; }
    }
    return result;
}

// ------------------------------------------------------------------
// Utility functions for parsing in getDateFromFormat()
// ------------------------------------------------------------------
function _isInteger(val) {
    var digits = "1234567890";
    for (var i = 0; i < val.length; i++) {
        if (digits.indexOf(val.charAt(i)) == -1) { return false; }
    }
    return true;
}
function _isCharDates(val) {
    var digits = "1234567890.-/";
    for (var i = 0; i < val.length; i++) {
        if (digits.indexOf(val.charAt(i)) == -1) {
            return false;
        }
    }
    return true;
}

function _getInt(str, i, minlength, maxlength) {
    for (var x = maxlength; x >= minlength; x--) {
        var token = str.substring(i, i + x);
        if (token.length < minlength) { return null; }
        if (_isInteger(token)) { return token; }
    }
    return null;
}


// ------------------------------------------------------------------
// getDateFromFormat( date_string , format_string )
//
// This function takes a date string and a format string. It matches
// If the date string matches the format string, it returns the 
// getTime() of the date. If it does not match, it returns 0.
// ------------------------------------------------------------------
function getDateFromFormat(val, format) {
    val = val + "";
    format = format + "";
    var i_val = 0;
    var i_format = 0;
    var c = "";
    var token = "";
    var token2 = "";
    var x, y;
    var now = new Date();
    var year = now.getYear();
    var month = now.getMonth() + 1;
    var date = 1;
    var hh = now.getHours();
    var mm = now.getMinutes();
    var ss = now.getSeconds();
    var ampm = "";
    var i;

    while (i_format < format.length) {
        // Get next token from format string
        c = format.charAt(i_format);
        token = "";
        while ((format.charAt(i_format) == c) && (i_format < format.length)) {
            token += format.charAt(i_format++);
        }
        // Extract contents of value based on format token
        if (token == "yyyy" || token == "yy" || token == "y") {
            if (token == "yyyy") { x = 4; y = 4; }
            if (token == "yy") { x = 2; y = 2; }
            if (token == "y") { x = 2; y = 4; }
            year = _getInt(val, i_val, x, y);
            if (year == null) { return 0; }
            i_val += year.length;
            if (year.length == 2) {
                if (year > 70) { year = 1900 + (year - 0); }
                else { year = 2000 + (year - 0); }
            }
        }
        else if (token == "MMM" || token == "NNN") {
            month = 0;
            for (i = 0; i < MONTH_NAMES.length; i++) {
                var month_name = MONTH_NAMES[i];
                if (val.substring(i_val, i_val + month_name.length).toLowerCase() == month_name.toLowerCase()) {
                    if (token == "MMM" || (token == "NNN" && i > 11)) {
                        month = i + 1;
                        if (month > 12) { month -= 12; }
                        i_val += month_name.length;
                        break;
                    }
                }
            }
            if ((month < 1) || (month > 12)) { return 0; }
        }
        else if (token == "EE" || token == "E") {
            for (i = 0; i < DAY_NAMES.length; i++) {
                var day_name = DAY_NAMES[i];
                if (val.substring(i_val, i_val + day_name.length).toLowerCase() == day_name.toLowerCase()) {
                    i_val += day_name.length;
                    break;
                }
            }
        }
        else if (token == "MM" || token == "M") {
            month = _getInt(val, i_val, 1, 2);
            if (month == null || (month < 1) || (month > 12)) { return 0; }
            i_val += month.length;
        }
        else if (token == "dd" || token == "d") {
            date = _getInt(val, i_val, 1, 2);
            if (date == null || (date < 1) || (date > 31)) { return 0; }
            i_val += date.length;
        }
        else if (token == "hh" || token == "h") {
            hh = _getInt(val, i_val, 1, 2);
            if (hh == null || (hh < 1) || (hh > 12)) { return 0; }
            i_val += hh.length;
        }
        else if (token == "HH" || token == "H") {
            hh = _getInt(val, i_val, 1, 2);
            if (hh == null || (hh < 0) || (hh > 23)) { return 0; }
            i_val += hh.length;
        }
        else if (token == "KK" || token == "K") {
            hh = _getInt(val, i_val, token.length, 2);
            if (hh == null || (hh < 0) || (hh > 11)) { return 0; }
            i_val += hh.length;
        }
        else if (token == "kk" || token == "k") {
            hh = _getInt(val, i_val, token.length, 2);
            if (hh == null || (hh < 1) || (hh > 24)) { return 0; }
            i_val += hh.length; hh--;
        }
        else if (token == "mm" || token == "m") {
            mm = _getInt(val, i_val, token.length, 2);
            if (mm == null || (mm < 0) || (mm > 59)) { return 0; }
            i_val += mm.length;
        }
        else if (token == "ss" || token == "s") {
            ss = _getInt(val, i_val, token.length, 2);
            if (ss == null || (ss < 0) || (ss > 59)) { return 0; }
            i_val += ss.length;
        }
        else if (token == "a") {
            if (val.substring(i_val, i_val + 2).toLowerCase() == "am") { ampm = "AM"; }
            else if (val.substring(i_val, i_val + 2).toLowerCase() == "pm") { ampm = "PM"; }
            else { return 0; }
            i_val += 2;
        }
        else {
            if (val.substring(i_val, i_val + token.length) != token) { return 0; }
            else { i_val += token.length; }
        }
    }
    // If there are any trailing characters left in the value, it doesn't match
    if (i_val != val.length) { return 0; }
    // Is date valid for month?
    if (month == 2) {
        // Check for leap year
        if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) { // leap year
            if (date > 29) { return 0; }
        }
        else { if (date > 28) { return 0; } }
    }
    if ((month == 4) || (month == 6) || (month == 9) || (month == 11)) {
        if (date > 30) { return 0; }
    }
    // Correct hours value
    if (hh < 12 && ampm == "PM") { hh = hh - 0 + 12; }
    else if (hh > 11 && ampm == "AM") { hh -= 12; }
    var newdate = new Date(year, month - 1, date, hh, mm, ss);
    return newdate.getTime();
}

// ------------------------------------------------------------------
// parseDate( date_string [, prefer_euro_format] )
//
// This function takes a date string and tries to match it to a
// number of possible date formats to get the value. It will try to
// match against the following international formats, in this order:
// y-M-d   MMM d, y   MMM d,y   y-MMM-d   d-MMM-y  MMM d
// M/d/y   M-d-y      M.d.y     MMM-d     M/d      M-d
// d/M/y   d-M-y      d.M.y     d-MMM     d/M      d-M
// A second argument may be passed to instruct the method to search
// for formats like d/M/y (european format) before M/d/y (American).
// Returns a Date object or null if no patterns match.
// ------------------------------------------------------------------
function parseDate(val) {
    var preferEuro = (arguments.length == 2) ? arguments[1] : false;
    generalFormats = new Array('y-M-d', 'MMM d, y', 'MMM d,y', 'y-MMM-d', 'd-MMM-y', 'MMM d');
    monthFirst = new Array('M/d/y', 'M-d-y', 'M.d.y', 'MMM-d', 'M/d', 'M-d');
    dateFirst = new Array('d/M/y', 'd-M-y', 'd.M.y', 'd-MMM', 'd/M', 'd-M');
    var checkList = new Array('generalFormats', preferEuro ? 'dateFirst' : 'monthFirst', preferEuro ? 'monthFirst' : 'dateFirst');
    var d = null;
    for (var i = 0; i < checkList.length; i++) {
        var l = window[checkList[i]];
        for (var j = 0; j < l.length; j++) {
            d = getDateFromFormat(val, l[j]);
            if (d != 0) { return new Date(d); }
        }
    }
    return null;
}

function emailCheck(emailStr) {
    /* The following pattern is used to check if the entered e-mail address
    fits the user@domain format.  It also is used to separate the username
    from the domain. */
    var emailPat = /^(.+)@(.+)$/
    /* The following string represents the pattern for matching all special
    characters.  We don't want to allow special characters in the address. 
    These characters include ( ) < > @ , ; : \ " . [ ]    */
    var specialChars = "\\(\\)<>@À-ÖØ-öø-ÿ,;:\\\\\\\"\\.\\[\\]"
    /* The following string represents the range of characters allowed in a 
    username or domainname.  It really states which chars aren't allowed. */
    var validChars = "\[^\\s" + specialChars + "\]"
    /* The following pattern applies if the "user" is a quoted string (in
    which case, there are no rules about which characters are allowed
    and which aren't; anything goes).  E.g. "jiminy cricket"@disney.com
    is a legal e-mail address. */
    var quotedUser = "(\"[^\"]*\")"
    /* The following pattern applies for domains that are IP addresses,
    rather than symbolic names.  E.g. joe@[123.124.233.4] is a legal
    e-mail address. NOTE: The square brackets are required. */
    var ipDomainPat = /^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/
    /* The following string represents an atom (basically a series of
    non-special characters.) */
    var atom = validChars + '+'
    /* The following string represents one word in the typical username.
    For example, in john.doe@somewhere.com, john and doe are words.
    Basically, a word is either an atom or quoted string. */
    var word = "(" + atom + "|" + quotedUser + ")"
    // The following pattern describes the structure of the user
    var userPat = new RegExp("^" + word + "(\\." + word + ")*$")
    /* The following pattern describes the structure of a normal symbolic
    domain, as opposed to ipDomainPat, shown above. */
    var domainPat = new RegExp("^" + atom + "(\\." + atom + ")*$")


    /* Finally, let's start trying to figure out if the supplied address is
    valid. */

    /* Begin with the coarse pattern to simply break up user@domain into
    different pieces that are easy to analyze. */
    var matchArray = emailStr.match(emailPat)
    if (matchArray == null) {
        /* Too many/few @'s or something; basically, this address doesn't
        even fit the general mould of a valid e-mail address. */
        //	alert("Email address seems incorrect (check @ and .'s)")
        return false
    }
    var user = matchArray[1]
    var domain = matchArray[2]

    // See if "user" is valid 
    if (user.match(userPat) == null) {
        // user is not valid
        //    alert("The username doesn't seem to be valid.")
        return false
    }

    /* if the e-mail address is at an IP address (as opposed to a symbolic
    host name) make sure the IP address is valid. */
    var IPArray = domain.match(ipDomainPat)
    if (IPArray != null) {
        // this is an IP address
        for (var i = 1; i <= 4; i++) {
            if (IPArray[i] > 255) {
                //	        alert("Destination IP address is invalid!")
                return false
            }
        }
        return true
    }

    // Domain is symbolic name
    var domainArray = domain.match(domainPat)
    if (domainArray == null) {
        //	alert("The domain name doesn't seem to be valid.")
        return false
    }

    /* domain name seems valid, but now make sure that it ends in a
    three-letter word (like com, edu, gov) or a two-letter word,
    representing country (uk, nl), and that there's a hostname preceding 
    the domain or country. */

    /* Now we need to break up the domain to get a count of how many atoms
    it consists of. */
    var atomPat = new RegExp(atom, "g")
    var domArr = domain.match(atomPat)
    var len = domArr.length
    //if (domArr[domArr.length-1].length<2 || domArr[domArr.length-1].length>3) {
    if (domArr[domArr.length - 1].length < 2) {
        // the address must end in a two letter or three letter word.
        //   alert("The address must end in a three-letter domain, or two letter country.")
        return false
    }

    // Make sure there's a host name preceding the domain.
    if (len < 2) {
        var errStr = "This address is missing a hostname!"
        //   alert(errStr)
        return false
    }

    // If we've gotten this far, everything's valid!
    return true;
}


// ##########################################################
// Ende private Funktionen
// ##########################################################

function ValidatePLZORT(sender, args) {
    args.IsValid = false;
    var f = document.forms[0];
    if (f.ort.value == "")
        return;
    if (f.plz.value == "")
        return;

    args.IsValid = true;
}

function ResetField(name, nWert) {
    var oElem;
    oElem = document.forms[0].elements[name];
    if (oElem != undefined)
        oElem.value = nWert;
}

function addHandler(target, eventName, handler) {
    if (target.attachEvent) {
        target.attachEvent('on' + eventName, handler);
    }
    else {
        target.addEventListener(eventName, handler, false);
    }
}

function setAllColumn(feld) {
    var form = document.forms[0];
    var check = feld.checked;
    var id = feld.id;
    var i;
    for (i = 0; i < form.elements.length; i++) {
        var oElem = form.elements[i];
        if (oElem.type == "checkbox") {
            //			j = oElem.id.indexOf(id);
            //			alert(oElem.id + ' ' + id + ' j:' + j);
            if ((j = oElem.id.indexOf(id)) == 0) {
                oElem.checked = check;
            }
        }
    }
}

function setAllColumnName(feld) {
    var form = document.forms[0];
    var check = feld.checked;
    var id = feld.name;
    var i;
    for (i = 0; i < form.elements.length; i++) {
        var oElem = form.elements[i];
        if (oElem.type == "checkbox") {
            //			j = oElem.name.indexOf(id);
            //			alert(oElem.name + ' [' + id + '] j:' + j);
            if ((j = oElem.name.indexOf(id)) >= 0) {
                oElem.checked = check;
            }
        }
    }
}

function setAllColumnID(feld) {
    var form = document.forms[0];
    var check = feld.checked;
    var feldid = feld.id;
    var letztes = 0;
    // So oft suchen, bis kein weiterer Punkt mehr vorkommt
    while ((letztes = feldid.indexOf('_')) > 0) {
        feldid = feldid.substring(letztes + 1);
    }
    var i;
    for (i = 0; i < form.elements.length; i++) {
        var oElem = form.elements[i];
        if ((oElem.type == "checkbox") || (oElem.type == "radio")) {
            if ((j = oElem.id.indexOf(feldid)) >= 0) {
                oElem.checked = check;
            }
        }
    }
}


addHandler(document, 'keypress', KeyPress);

function setIframeHeight(iframeName) {
    var iframeEl = document.getElementById ? document.getElementById(iframeName) : document.all ? document.all[iframeName] : null;
    if (iframeEl) {
        iframeEl.style.height = "auto"; // helps resize (for some) if new doc shorter than previous
        // need to add to height to be sure it will all show
        var h = alertSize();
        var hf = FooterHeight();
        var new_h = (h - hf - 40);
        if (new_h > 0) {
            iframeEl.style.height = new_h + "px";
            window.status = hf;
        }
    }
}

function alertSize() {
    var myHeight = 0;
    if (typeof (window.innerWidth) == 'number') {
        //Non-IE
        myHeight = window.innerHeight;
    } else if (document.documentElement && (document.documentElement.clientWidth || document.documentElement.clientHeight)) {
        //IE 6+ in 'standards compliant mode'
        myHeight = document.documentElement.clientHeight;
    } else if (document.body && (document.body.clientWidth || document.body.clientHeight)) {
        //IE 4 compatible
        myHeight = document.body.clientHeight;
    }
    //window.alert( 'Height = ' + myHeight );
    return myHeight;
}