function msize (obj) {
    if(obj === undefined || obj === null)
    {
        return 0;
    }
    var len = obj.length ? obj.length-1 : (obj?0:-1);
        for (var k in obj)
        {
            if (obj.hasOwnProperty(k))
            {
                len++;
            }
        }
    return len;
}

/*
* erzeugt eine echte Kopie eines Objektes
*/
function cloneObject(obj, maxdepth) {
    if (maxdepth === undefined) {
        maxdepth = 4;
    }
    //c/onsole.log(maxdepth, 'clone=', obj, ',',typeof(obj),',', (obj == null)?'null':obj.constructor);
    if(obj === null || (typeof(obj) != 'object' && typeof(obj) != 'array') || maxdepth === 0) {
        return obj;
    }
    //var typeOfObject = typeof(obj);

    /*
    if(typeof(obj) === 'object') {
        var temp = {};
        for(var i in obj) {
            var elem = obj[i];
            if(typeof(obj[i]) == 'object' || typeof(obj[i]) == 'array')  temp[i] = cloneObject(obj[i]);
            else temp[i] = obj[i];
        }
        return temp;
    }
    */
    var temp;
    if (obj.length === undefined) {
        temp = {};
    }
    else {
        temp = [];
    }
    for (var key in obj) {
        if (obj.hasOwnProperty(key)) {
            temp[key] = cloneObject(obj[key], maxdepth-1);
        }
    }
    return temp;
}

/*
* Trimming eines Strings
* der zweite Parameter ist ein regulaerer Ausdruck, der bestimmt, was am Anfang und Ende weggeschnitten wird
* Moeglich waere zb
* [\\W\\s)
*/
function trim(elem, trimming) {
    if (trimming === undefined) {
        trimming = "\\s*";
    }
    var regex_trimming = trimming + "(.*?)" + trimming + "$";
    var reg = new RegExp(regex_trimming);
    var erg = reg.exec(elem);
    if (erg !== null && erg !== undefined) {
        elem = erg[1];
    }
    return elem;
}

// erzeugt aus einer href eine ID
// Eine ID hat den Aufbau [A-Za-z][A-Za-z0-9_\.:\-]
// Erlaubt ist zB aBc09-123.Spec_Baz:124.899
// '/' -> '.' Backlash
// '&' -> '_:_' Ampersand
// '?' -> '_:_' Questionmark
// '=' -> '_:_' equals
// '"' -> '_' quote
// '__' -> '_'
function href2id(href) {
    href = href.replace(/http:\/*/g,'');
    href = href.replace(/\//g,'_');
    href = href.replace(/&/g,'_a_');
    href = href.replace(/\+/g,'_p_');
    href = href.replace(/\?/g,'_q_');
    href = href.replace(/\=/g,'_');
    href = href.replace(/"/g,'_');
    href = href.replace(/\./g,'_');
    href = href.replace(/__/g,'_');
    return href;

}

/*
* Union eines Arrays
*/
function union(a1,a2) {
    if (a2 === undefined) {
        a2 = [];
    }
    var erg = [];
    var isNew;
    for (var a1Elem in a1) {
        if (a1.hasOwnProperty(a1Elem)) {
            isNew = true;
            for (var aa1Elem in erg) {
                if (erg.hasOwnProperty(aa1Elem)) {
                    isNew &= (a1[a1Elem] != erg[aa1Elem]);
                }
            }
            if (isNew) {
                erg.push(a1[a1Elem]);
            }
        }
    }
    for (var a2Elem in a2) {
        if (a2.hasOwnProperty(a2Elem)) {
            isNew = true;
            for (var aa2Elem in erg) {
                if (erg.hasOwnProperty(aa2Elem)) {
                    isNew &= (a2[a2Elem] != erg[aa2Elem]);
                }
            }
            if (isNew) {
                erg.push(a2[a2Elem]);
            }
        }
    }
    return erg;
}

/**
* Vereint zwei kommagetrennte Listen (und loescht dabei die Leerzeichen)
*
* col_union("a1,a2,a3, a4 , a5", "b1,b2, a4, b3 , a5") => "a1,a2,a3,a4,a5,b1,b2,b3"
*/
function col_union(a,b) {
    var a1 = a.split(',');
    if (b === undefined) {
        b = '';
    }
    var b1 = b.split(',');
    var m;
    for (var i1=0; i1 < a1.length; i1++) {
        m = trim(a1.shift());
        if (0 < m.length) {
            a1.push(trim(m));
        }
    }
    for (var i2=0; i2 < b1.length; i2++) {
        m = trim(b1.shift());
        if (0 < m.length) {
            b1.push(trim(m));
        }
    }
    erg = union(a1,b1);
    return erg.join(',');
}

/**
* Anzahl der Elemente in einer Liste "a1, a2, a3, a4,a5" = 5
*/
function col_length(a) {
    var a1 = a.split(',');
    var erg = a1.length;
    if (erg === 1 && a1[0].length === 0) {
        erg = 0;
    }
    return erg;
}

/**
* holt das n-te Element eine kommaseperierten Liste
*/
function col_get(col, index) {
    var erg = null;
    var colSplit = col.split(',');
    if (index < colSplit.length) {
        erg = trim(colSplit[index]);
    }
    return erg;
}

/**
* prueft eine kommaseperierte Liste auf das Vorhandensein eines Elementes
*/
function col_has(col, elem) {
    elem = trim(elem);
    var colSplit = col.split(',');
    var hasElem = false;
    for (var i = 0; i < colSplit.length; i += 1) {
        hasElem |= (elem == trim(colSplit[i]));
    }
    return hasElem;

}

/*
* Zeit einlesen im deutschen Format also Tag, Monat, Jahr
* gibt die Zeit seit dem 1.1.1970 in Sekunden zurueck;
*/
function parseDate(date) {
    var regex = "^\\s*(\\w*)\\s*[\\.,]\\s*([\\wäöüÄÖÜ]*)\\s*[\\.,]\\s*(\\w*)\\s*$";
    var reg = new RegExp(regex);
    var erg = reg.exec(date);
    if (erg === null) {
        erg = 0;
    }
    else {
        var monName = erg[2].slice(0,3).toLowerCase();
        //c/onsole.log('parseDate',erg, erg[2].toLowerCase(),erg[2].slice(0,3));
        switch (escape(monName)) {
            case "jan": monName =  1; break;
            case "feb": monName =  2; break;
            case "mar":
            case "m%uFFFDr":
            case "mae": monName =  3; break;
            case "apr": monName =  4; break;
            case "mai":
            case "may": monName =  5; break;
            case "jun": monName =  6; break;
            case "jul": monName =  7; break;
            case "aug": monName =  8; break;
            case "sep": monName =  9; break;
            case "okt":
            case "oct": monName = 10; break;
            case "nov": monName = 11; break;
            case "dez":
            case "dec": monName = 12; break;
        }
        var year = parseInt(erg[3],10);
        if (year < 30) {
            year += 2000;
        }
        if (year < 100) {
            year += 1900;
        }
        var d = new Date(year,parseInt(monName, 10) - 1, parseInt(erg[1], 10));
        erg = Date.parse(d) / 1000;
    }
    return erg;
}

/**
 * require_once - Aequivalent
 *
 * Aufruf ueber require_once('Adresse', function (fehlerCode) {...});
 * Im Unterschied zu PHP ist der Aufruf asynchron, d.h. die Funktionen, die abhaengig sind vom require_once
 * muessen in einer Callback-Funktion stehen -
 * das zweite Argument ist die Callback-Funktion, die aufgerufen wird am Ende des Codes
 *
 * Fehlercode = 1, falls der Script bereits existiert
 * Fehlercode = 2, falls der Aufruf erfolgreich war (aequivalent Returncode 2xx - 3xx)
 * Fehlercode = 4, falls es einen Fehler gab (aequivalent Returncode 4xx - 5xx)
 *
 * Beispiel:
 * require_once("/common/slider.js", function () {$("XYZ".slider())});
 *
 */
var vxcp_scripts = [];
function require_once(path, callback) {
    //c/onsole.log('require_once,', path, callback);
    var obj = {};
    obj.path = path;
    obj.callback = callback;
    obj.status = 0;
    obj.timer = false;
    obj.timerStart = 0;
    // loaded zeigt den Zustand der Verarbeitung an
    //  0 = script wurde noch nicht geladen
    //  1 = script wird geladen
    //  2 = script wurde geladen, aber die Callback-Funktion wurde noch nicht ausgefuehrt
    //  3 = die Callback-Funktion wurde ausgefuehrt
    obj.loaded = 0;
    vxcp_scripts.push(obj);
    scripts_handle();
}

/**
* intern, gehoert zu require_once
*/
function scripts_loadCallback(status, path, t) {
    //c/onsole.log('loaded,', path, status, t.readyState);
    var hasChanged = false;
    for (var i=0; i < vxcp_scripts.length; i += 1) {
        if (vxcp_scripts[i].path == path && (t == undefined || t.readyState != 'loading')) {
            vxcp_scripts[i].status = status;
            if (vxcp_scripts[i].loaded == 0 || vxcp_scripts[i].loaded == 1) {
                vxcp_scripts[i].loaded = 2;
                hasChanged = true;
            }
        }
    }
    if (hasChanged) {
        scripts_handle();
    }
    return;
}

/**
* intern, gehoert zu require_once
* Dieser Script wird durch das Time-Interval aufgerufen, und sollte solange laufen, bis
* der Script definitiv geladen ist. Momentan gibt es aber kein gesichertes Kriterium dafuer, dazs ein Script geladen ist,
* deswegen wird beim ersten Aufruf so getan, als sei der Script bereits geladen und das Timeout-Interval wird geloescht.
*/
function script_callbackInterval(path) {
    var found = scripts_isset(path);
    //c/onsole.log("script_callbackInterval", path, found);
    for (var i=0; i < vxcp_scripts.length; i += 1) {
        if (vxcp_scripts[i].path == path && vxcp_scripts[i].loaded < 2) {
            // den Script als geladen kennzeichnen
            // aber mit dem Fehlercode 4 (= not found)
            vxcp_scripts[i].loaded = 2;
            vxcp_scripts[i].status = 4;
        }
        if (vxcp_scripts[i].timer !== false) {
            window.clearInterval(vxcp_scripts[i].timer);
            vxcp_scripts[i].timer = false;
        }
    }
    scripts_handle();
}

/**
* intern, gehoert zu require_once
* testet, ob ein script existiert
*/
function scripts_isset(path) {
    var found = false;
    var scripts = document.getElementsByTagName("script");
    for (var i = 0; i < scripts.length; i+= 1) {
        var src = scripts[i].src;
        //if (src == path) {
        //    //c/onsole.log(scripts[i], ', innerHTML =' , scripts[i].innerHTML);
        //}
        var type = scripts[i].type;
        if (src !== undefined && 2 < src.length && type !== undefined && 2 < type.length && type == "text/javascript") {
            //c/onsole.log(i, src);
            var srcA = src.split('/');
            var file = srcA[srcA.length - 1];
            found |= (src == path);
        }
    }
    return found;
}

/**
* intern, gehoert zu require_once
* Warteschlange, laedt die Scripte in der Eingabe-Reihenfolge
*/
function scripts_handle() {
    // Sind Scripte noch offen, dann wird der Handle abgebrochen
    var is_loading = false;
    // Scripte, die noch ausgefuehrt werden muessen
    var next_path = false;
    var next_path_index = false;
    // Callbacks, die noch ausgefuehrt werden muessen
    var next_function = false;
    var next_function_index = false;
    for (var i=0; i < vxcp_scripts.length; i += 1) {
        if (vxcp_scripts[i].loaded == 0) {
            next_path = vxcp_scripts[i].path;
            next_path_index = i;
        }
        if (vxcp_scripts[i].loaded == 1) {
            is_loading == true;
        }
        if (vxcp_scripts[i].loaded == 2) {
            next_function = vxcp_scripts[i].callback;
            next_function_index = i;
        }
    }
    //c/onsole.log('script handle', is_loading, next_path, next_function, next_function_index);

    // Alle Scripte sollen nacheinander geladen werden (ist eventuell nicht notwendig)
    // falls es Probleme gibt, den Script einkommentieren
    //if (is_loading) {
    //    // es laeuft ein Load-Vorgang
    //    return;
    //}

    if (next_path !== false) {
        vxcp_scripts[next_path_index].loaded = 1;
        var scripts = document.getElementsByTagName("script");
        var head = document.getElementsByTagName("head")[0];
        var found = scripts_isset(next_path);

        if (found) {
            // Script existiert bereits, eventuell reingeladen durch ein anderes require_once
            // es musz dennoch die Callback-Funktion ausgefuehrt werden
            scripts_loadCallback(1, next_path);
            scripts_handle();
        }
        else {
            var s = document.createElement("script");
            var s_src = document.createAttribute("src");
            s_src.nodeValue = next_path;
            s.setAttributeNode(s_src);

            var s_type = document.createAttribute("type");
            s_type.nodeValue = "text/javascript";
            s.setAttributeNode(s_type);

            s.onload = function (e) {scripts_loadCallback(2, next_path, this);};
            s.onreadystatechange = function (e) {scripts_loadCallback(2, next_path, this);};
            s.onerror = function (e) {scripts_loadCallback(4, next_path, this);};

            // Fuer alle Faelle, falls sonst nichts klappt, wird ein Timeout gestartet
            // siehe: script_callbackInterval
            vxcp_scripts[next_path_index].timerStart = new Date();
            vxcp_scripts[next_path_index].timer = window.setInterval(
                function () {
                    script_callbackInterval(next_path);
                }
                ,2000);
            head.appendChild(s);
            scripts_handle();
        }
    }
    else if (next_function !== false) {
        vxcp_scripts[next_function_index].loaded = 3;
        try {
            next_function(vxcp_scripts[next_function_index].status);
        }
        catch (e) {
            //c/onsole.log(e);
        }
        //c/onsole.log('executed,', vxcp_scripts[next_function_index].path, vxcp_scripts[next_function_index].status);
        scripts_handle();
    }
    // es gibt nichts mehr zu tun, auf in's Nirvana
    return false;
}

/**
* Elemente aus einem HTML-Text extrahieren
*
* 1. reines extrahieren des BodyTags
* gibt einen DOM zurueck
*/
function html_parse_body(html) {
    //var regex = "<body[^>]*>([\\s\\S]*)<\\/body>";
    var regex = "<!\\-\\-\\s*vxcp_ajax_start\\s*\\-\\->([\\s\\S]*)<!\\-\\-\\s*vxcp_ajax_end\\s*\\-\\->";
    var reg = new RegExp(regex);
    var regerg = reg.exec(html);
    var erg = null;
    if (regerg !== null) {
        erg = regerg[1];
    }
    return erg;
}

/**
* entfernt Kommentare aus JSON
*/
function json_stripComments(data) {
    //c/onsole.log(data);
    var postRegex = /[^\{\[]*([\s\S]*?)[^\}\]]*$/g;
    postRegex.lastIndex = 0;
    var erg = postRegex.exec(data);
    //c/onsole.log(erg);
    if (erg != null && 0 < erg[1].length) {
        data = erg[1];
    }
    else {
        var postRegex = /^.*?\-\->([\s\S]*)<\!\-\-.*$/g;
        postRegex.lastIndex = 0;
        var erg = postRegex.exec(data);
        if (erg != null) {
            data = erg[1];
        }
    }
    return data;
}

/**
* Sucht das Form-Element, das alle Input-Felder gemeinsam haben
* uebergeben wird eine Objekt der Form:
* {'fields':[elem, elem, ...]}
*/
function vxcp_validateForm_findFormOfAllInputs(option) {
    var erg;
    var allFieldsS;
    if (option.fields !== undefined) {
        var allFields = [];
        for (var field in option.fields) {
            if (option.fields.hasOwnProperty(field)) {
                allFields.push(field);
            }
        }
        allFieldsS = allFields.join(',');
    }
    erg = vxcp_jQuery(allFieldsS).parents('form');
    return erg;
}

/**
* sucht die ID des umfassenden Parents
*/
function vxcp_getParentFormId(field) {
    erg = vxcp_jQuery(field).parents('form');
    var id = null;
    if (0 < erg.length) {
        id = erg.attr('id');
    }
    return id;
}


var tooltipp_hover_elem = false;
var tooltipp_hover_tip = false;
var tooltipp_globalCounter = 1;
var tooltipp_globalInitCounter = 1;
var tooltipp_last;
var tooltipp_hover_entry = {x:0, y:0};

(function($) {

    /**
    * Logged informationen in einem festen Feld mit.
    * Uebergabe-Parameter ist der Text, der ausgegeben werden soll
    */
    function log(text) {
        var target = $('#log_target');
        if (target.length == 0) {
             var target = document.createElement('div');
             target.id = 'log_target';
             target = $(target);
             $('body').append(target);
             target.css('position', 'fixed')
             .css('top', '10px')
             .css('left', '10px')
             .css('padding', '10px')
             .css('width', '300px')
             .css('height', '300px')
             .css('background', 'white');
        }
        var line = document.createElement('div');
        target.prepend(line);
        $(line).append(text);
        target.children().filter(':gt(12)').remove();
        return;
    }

     /*
         Toggle für den crosscontent
     */
    $.fn.vxcp_crosscontent_toggle = function() {
        var parentElement = this;
        if (parentElement === undefined || parentElement === null)
        {
            return false
        }

        if( $(parentElement).hasClass('vxcp_crosscontent-showmin') )
        {
            $(parentElement).removeClass('vxcp_crosscontent-showmin').addClass('vxcp_crosscontent-showmax');
        }
        else
        {
            $(parentElement).removeClass('vxcp_crosscontent-showmax').addClass('vxcp_crosscontent-showmin');
        }

        return this;
    };

    /*
    * Validiert ein Formular-Element
    * in 'Validators'
    * validator ist ein Array von Objekten mit folgenden wesentlichen Parametern
    * - validator = ein Bezeichner aus der Liste moeglicher Validatoren
    * - value = in Kombination mit einem Validator, zB Zeichenlaenge mind. 'value' Werte
    * - callback = eine Funktion mit genau einen Parameter, die diesen Parameter auf wahr oder falsch prueft
    * in 'Group'
    * stehen weitere Eingabe-Felder, die zur Validierung gehoeren, zB wenn bei einer Gruppe von Checkboxes die Bedingung lautet, dass mind. eine Checkbox markiert sein muss. In diesem Fall muessen alle Checkboxes mitgeliefert werden, so dass der Validator zaehlen kann.
    */
    $.fn._vxcp_validateInput = function(validators, group) {
        //c/onsole.log('common 508', validators, group);
        var nodeType = $(this).get(0).nodeName.toLowerCase();
        var val = $(this).val();
        var number = parseInt(val,10);
        var inValidMsg = [];
        var ee;
        var erg;
        var countSelected = function () {
            var elem = $(this).get(0);
            erg += (elem.checked === true || elem.checked === 1)?1:0;
            erg += (elem.selected === true || elem.selected === 1)?1:0;
        };
        for (var i_para in validators) {
            if (validators.hasOwnProperty(i_para)) {
                // in para steht der gerade zu testende Validator
                var para = validators[i_para];
                //c/onsole.log(para);
                var value = (para.value !== undefined && para.value !== null) ? parseInt(para.value, 10) : 0 ;
                // ein Validator ist erst gueltig (= sinnvoll), wenn er entweder einen Validator-Bezeichner
                // oder eine Callback-Function hat
                if (para.validator !== undefined || para.callback !== undefined) {
                    var regex;
                    //c/onsole.log('validateInput 2', para.validator, nodeType);
                    para.target = $(this);
                    para.group = group;
                    // Fehlerlevel
                    para.level = 3;
                    //c/onsole.log('validator:', para);
                    if (nodeType == 'select') {
                        var selectedElem = para.target.find(':selected');
                        //c/onsole.log('selectedElem', selectedElem);
                        if (para.callback !== undefined) {
                            ee = para.callback(para);
                            if (!ee) {
                                inValidMsg.push(para);
                            }
                        }
                    }
                    if (nodeType == 'input') {
                        //c/onsole.log(para.validator, val, value, para);
                        if (para.validator !== undefined) {
                            switch (para.validator) {
                                case 'required':
                                    regex = "\\S+";
                                break;
                                case 'number':
                                    regex = "^\\s*\\-?\\d*\\s*$";
                                break;
                                case 'absnumber':
                                    regex = "^\\s*\\d*\\s*$";
                                break;
                                case 'date':
                                    if (0 === parseDate(val)) {
                                        inValidMsg.push(para);
                                    }
                                break;
                                case 'plz_start':
                                    regex = "^\\d{5}(?:\\D|$)";
                                break;
                                case 'minLength':
                                    if (val.length < value) {
                                        inValidMsg.push(para);
                                    }
                                break;
                                case 'minLengthOrEmpty':
                                    if (val.length < value && 0 < val.length) {
                                        inValidMsg.push(para);
                                    }
                                    if (0 == val.length) {
                                        para.level = 1;
                                        inValidMsg.push(para);
                                    }
                                break;
                                case 'maxLength':
                                    if (value < val.length) {
                                        inValidMsg.push(para);
                                    }
                                break;
                                case 'minVal':
                                    if (number < value) {
                                        inValidMsg.push(para);
                                    }
                                break;
                                case 'maxVal':
                                    if (value < number) {
                                        inValidMsg.push(para);
                                    }
                                break;
                                case 'groupmin':
                                case 'groupmax':
                                    erg = 0;
                                    para.group.each(countSelected());
                                    if (erg < value && para.validator == 'groupmin') {
                                        inValidMsg.push(para);
                                    }
                                    if (value < erg && para.validator == 'groupmax') {
                                        inValidMsg.push(para);
                                    }
                                break;
                                case 'regex':
                                    regex = para.value;
                                break;
                                default:
                                break;
                            }
                        }
                        if (para.callback !== undefined) {
                            ee = para.callback(val);
                            if (!ee) {
                                inValidMsg.push(para);
                            }
                        }
                    }

                    if (regex !== undefined) {
                        var reg = new RegExp(regex);
                        erg = reg.exec(val);
                        //c/onsole.log(regex,erg);
                        if (erg === null || erg === undefined) {
                            inValidMsg.push(para);
                        }
                    }

                }
            }
            //c/onsole.log(i_para, para, value);
        }
        //c/onsole.log('635 inValidMsg', validators, inValidMsg);
        return inValidMsg;
    };

 /*
    * Validiert ein ganzes Formular
    * diese Funktion ist sowohl Teil der interaktiven Trigger, als auch der direkten ueberpruefen
    * die direkte Ueberpruefung wird dann ausgefuehrt, wenn weder ein Trigger, noch ein Submit ausgefuehrt wird
    *    zB wenn man die zweite Seite der Ergebnis-Seite aufruft
    *
    * Validators ist die komplette Liste aller Validatoren, zusammengefasst nach dem indentifizierenden Element (ist auch der Schluessel)
    * Optionen enthaelt eine Liste von allen fuer den zu testenden Validatoren,
    * bei diesen Objekten ist unter target das Element, das getestet werden soll.
    * kurz nochmals fuer Bloedis:
    * NUR UNTER OPTIONEN IN DEN OBJEKTEN.TARGET IST DAS ZIELOBJEKT
    *
    * Auf diese Weise koennen zB Validatoren fuer eine Klasse 'required', 'number' und eine spezielle ID angelegt werden,
    * und dann fuer verschiedene Elemente getestet werden.
    *
    * Parameter:
    *   $(this)     = ALLE Formulare, die zu valdierende Inputfelder haben, nicht nur das gerade betrachtete
    *   validators  = die Original-Validatoren
    *   optionen    =
    *       bei Einzelfeldern, die getriggert wurden, ein Array mit Objekten, im einzelnen enthalten diese Objekte:
    *           error_action        = Zahl
    *                                   0 = es wird die Eingabe als Fehler behandelt, aber es wird kein Fehler angezeigt
    *                                   1 = die Fehlermeldung wird im Ergebnis gespeichert
    *           event               = zB "blur", "submit"
    *           input_class_error
    *           input_class_success
    *           target              = jQuery vom Zielobjekt
    *           validator           = der dem Event zugeordnete Validator
    *       bei Submits
    *           submit              = true / false
    *                                   bei Formularen wird immer die Fehlermeldung gespeichert - wirkt im Zusammenhang mit
    *                                   error_action, soll solche Fehler behandeln, die erstmal nur eine Warnung schmeissen
    *                                   und erst beim Submit wie ein Fehler behandelt werden
    *                                   zB Fehler, die im Kontext mit anderen Eingaben stehen, diese Fehler koennen vorruebergehend falsch sein,
    *                                   aber dann durch ein anderes Feld wieder in einem korrekten Kontext kommen
    *           formBackRef         = das Formular zum Submit - wird nicht mehr verwendet
    *           submitBackRef       = der Submitbutton bei einem "submit"-Event,
    *                                   wird zusammen mit "spec_submit_prefix" verwendet,
    *                                   um die Anzahl der uebereinstimmenden Praefixe zu den einzelnen
    *           spec_submit_prefix  = die Anzahl der Praefixes, die uebereinstimmen musz vom Submit-Button und dem Feldelement
    */
    $.fn._vxcp_validateForm = function(validators, optionen) {
        //c/onsole.log('_vxcp_validateForm',validators, optionen);
        var errorElement = null;
        var errorMsg = null;
        var erg = 0;
        var form = null;
        var submit = false;
        if (optionen !== undefined && optionen.submit !== undefined) {
            delete optionen.submit;
            submit = true;
        }
        if (optionen !== undefined && optionen.submitBackRef !== undefined) {
            form = optionen.submitBackRef.parents('form');
        }
        //c/onsole.log('Form in', $(this), validators, optionen);
        for (var field in validators) {
            // Alle Validatoren durchgehen und die zugehoerigen Elemente ermitteln und gegen den
            //      die Alternative waere gewesen, alle Elemente durchzugehen und die dazugehoerigen Validatoren zu suchen
            if (typeof(field) == 'string' && errorElement === null) {
                // input sind alle Elemente, fuer die der Identifier des Validatorfeldes zutrifft
                var input = $(this).find(field);
                //c/onsole.log('teste' , input, optionen);
                //c/onsole.log('find.field', field, $(this), input);
                if (0 < input.length && errorElement === null) {
                    input.each( function () {

                        //c/onsole.log('input in', $(this), validators, optionen);
                        // Wird das Formular generell ueberprueft, oder wird nur ein Teil des Formulars ueberprueft ?
                        // bei einer speziellen Ueberpruefung reicht es wenn ein Feld aus der Liste vergliechen wird (das ist nun die Frage, weil es schraenkt enorm ein)
                        // TODO: bisher ist die Ueberpruefung auf ein Feld oder komplettes Formualar beschraenkt, es koennten durchaus mehrere Felder getestet werden
                        //      0 ist das erste Objekt von mehreren, aber was fuer das erste Objekt gilt
                        //      zB targetElement sollte! fuer alle anderen Objekte auch gelten.
                        var checkInput = false;
                        if (optionen !== undefined && optionen[0] !== undefined && optionen[0].target !== undefined && optionen[0].event !== undefined) {
                            checkInput |= optionen[0].target.get(0) == $(this).get(0);
                        }
                        else {
                            // generelle Ueberpruefung (bei submit)
                            checkInput = true;
                            if (optionen !== undefined
                                && optionen.submitBackRef !== undefined
                                && optionen.spec_submit_prefix !== undefined && 0 < optionen.spec_submit_prefix) {
                                // Test, ob ein Submit
                                var id_submit = optionen.submitBackRef.attr('id').split('_');
                                var id_element = $(this).attr('id').split('_');
                                if (id_submit.length < optionen.spec_submit_prefix || id_submit.length < optionen.spec_submit_prefix) {
                                    checkInput = false;
                                }
                                else {
                                    checkInput = true;
                                    for (var ii = 0; ii < optionen.spec_submit_prefix; ii += 1) {
                                        if (id_submit[ii] != id_element[ii]) {
                                            checkInput = false;
                                        }
                                    }
                                    //c/onsole.log("Teste ID:", id_submit,  id_element, checkInput);
                                }
                            }
                        }

                        if (errorElement === null && checkInput) {
                            // das naechste Feld nur ueberpruefen, solange kein Fehler aufgetreten ist
                            // in inputElem steht das Inputfeld
                            var inputElem = $(this);
                            var paraGroup = validators[field];
                            // hier gilt auch, das ist nur ein Spezialfall
                            if (optionen !== undefined && 0 < msize(optionen)) {
                                paraGroup = [];
                                for (var opt_i in optionen) {
                                    if (optionen[opt_i].validator !== undefined || optionen[opt_i].callback !== undefined) {
                                        optionen[opt_i].validator.error_action = optionen[opt_i].error_action;
                                        paraGroup.push(optionen[opt_i].validator);
                                    }
                                }
                                //&& optionen[0] !== undefined && optionen[0].target !== undefined && optionen[0].event !== undefined && optionen[0].validator != undefined) {
                                //paraGroup = [optionen[0].validator];
                                if (paraGroup.length == 0) {
                                    // falls ueber die Optionen weitere Infos gekommen sind,
                                    // aber keine Validatoren oder Callbacks dabei gewesen sind
                                    // dann werden die alten Validatoren wieder hergestellt
                                    paraGroup = validators[field];
                                }
                            }
                            //c/onsole.log('parameterGroup.validatorID', field);
                            //c/onsole.log('parameterGroup.testElem', inputElem);
                            //c/onsole.log('parameterGroup', paraGroup);
                            // para['id'] = field;
                            // $(this).get(0).nodeName = INPUT/SELECT ?
                            var elem = $(this).get(0);
                            var type = 0;
                            if (elem.type !== undefined) {
                                type = elem.type.toLowerCase();
                            }
                            if (type != 'submit') {
                                var hasData = false;
                                for (var v in paraGroup) {
                                    if (typeof(paraGroup[v]) == 'object') {
                                        hasData |= (paraGroup[v].validator !== undefined || paraGroup[v].callback !== undefined) ;
                                    }
                                }

                                if (hasData) {
                                    var inputGroup = input;
                                    if (optionen !== undefined && optionen[0] !== undefined) {
                                        if (optionen[0].validator.grouping !== undefined) {
                                            inputGroup = $(this).parents(optionen[0].validator.grouping).find(field);
                                        }
                                        if (optionen[0].input_class_success !== undefined) {
                                            inputElem.removeClass(optionen[0].input_class_success);
                                        }
                                        if (optionen[0].input_class_error !== undefined) {
                                            inputElem.removeClass(optionen[0].input_class_error);
                                        }
                                    }
                                    /** Aufruf des Einzeltestes **/
                                    //c/onsole.log(inputElem);
                                    var invalidMsg = inputElem._vxcp_validateInput(paraGroup, inputGroup);
                                    //c/onsole.log('795 invalidMsg', paraGroup, inputGroup, "===>", invalidMsg);
                                    var hasError = 0;
                                    for (var invalidMsgIndex in invalidMsg) {
                                        if (invalidMsg.hasOwnProperty(invalidMsgIndex)) {
                                            var invalidMsgElem = invalidMsg[invalidMsgIndex];
                                            if (invalidMsgElem.error_action == 1 || submit) {
                                                if (hasError < invalidMsgElem.level) {
                                                    errorMsg = invalidMsgElem.msg;
                                                }
                                                hasError = Math.max(hasError, invalidMsgElem.level);
                                            }
                                            if (invalidMsgElem.error_action === 0) {
                                                // Das Ergebniss stimmt zwar noch nicht,
                                                // aber es soll kein Fehler angezeigt werden
                                                hasError = Math.max(hasError, invalidMsgElem.level);
                                            }
                                            //c/onsole.log("invalidMsgElem",invalidMsgElem,hasError);
                                        }
                                    }
                                    //c/onsole.log('invalidMsg', paraGroup, inputGroup, "===>", invalidMsg,hasError);
                                    if (0 < hasError) {
                                        // Fehler
                                        //errorMsg = invalidMsg;
                                        errorElement = inputElem;
                                        //slice(0,1);
                                        if (errorMsg !== null) {
                                            erg = {'msg': [errorMsg], 'element': errorElement};
                                            //c/onsole.log('errorMsg', errorMsg);
                                            //c/onsole.log('optionen', optionen);
                                            var input_class_error;
                                            if (optionen !== undefined && optionen.input_class_error !== undefined) {
                                                input_class_error = optionen.input_class_error;
                                            }
                                            if (optionen !== undefined && optionen[0] !== undefined) {
                                                if (optionen[0].input_class_error !== undefined) {
                                                    input_class_error = optionen[0].input_class_error;
                                                }
                                            }
                                            if (input_class_error !== undefined && 1 < hasError) {
                                                inputElem.addClass(input_class_error);
                                            }
                                        }
                                    }
                                    else{
                                        // kein Fehler
                                        if (optionen !== undefined && optionen[0] !== undefined) {
                                            if (optionen[0].input_class_success !== undefined) {
                                                inputElem.addClass(optionen[0].input_class_success);
                                            }
                                        }
                                    }
                                }
                                //c/onsole.log('check=',    inputElem,    hasData, invalidMsg, invalidMsg == '');
                            }
                        }
                    });
                }
            }
        }

        //c/onsole.log('common 822');
        return erg;
    }

    /**
    * msg ist ein array von Strings
    */
    var errorReport = null;
    $.fn.vxcp_validateFormError = function(msg,option) {
        var field = $(this);
        var makeTip = true;
        //c/onsole.log('(863) vxcp_validateFormError', field, msg, option, errorReport);
        if (errorReport !== null) {
            //c/onsole.log('(865) vxcp_validateFormError', field, msg, option, errorReport);
            if (msg == errorReport.msg && field.get(0) == errorReport.field.get(0)) {

            }

        }
        //c/onsole.log(option);
        if (makeTip) {
            $('#internal_error_msg').remove();
            var erg2string = '';
            if (option.html_pre !== undefined) {
                erg2string = option.html_pre + erg2string;
            }
            for (i = 0; i < msg.length; i++) {
                if (0 < i) {
                    erg2string = erg2string + '<br/>';
                }
                erg2string = erg2string + msg[i];
            }
            if (option.html_post !== undefined) {
                erg2string =  erg2string + option.html_post;
            }

            //options.mode = 1;
            //options.align = 1;
            $ii = $(erg2string);
            $ii.attr('id','internal_error_msg');
            if (option !== undefined && option.tooltip_container !== undefined) {
                //c/onsole.log($(option.tooltip_container));
                $(option.tooltip_container).prepend($ii);
            }
            else {
                $('body').prepend($ii);
            }
            var tips = $(this).vxcp_tooltip({xpath: '#internal_error_msg',mode: 1, position: 'formular', align: 1});
            errorReport = {};
            errorReport.field = $(this);
            errorReport.tip = tips;
            errorReport.msg = msg;
            //c/onsole.log('(910) vxcp_validateFormError', errorReport);
        }
        //c/onsole.log($('#internal_error_msg'));
        //c/onsole.log('common 860');
    }

    /**
    *
    */
    $.fn.vxcp_validateForm = function(option) {
        //c/onsole.log('vxcp_validateForm',option);
        // Feststellen des Formulars -> damit kann festgestellt werden, wo der Submit liegt
        // TODO: alternativ kann der Submit per Option uebergeben werden, damit wuerde die Pflicht zur Form entfallen

        option = $.extend( {
            'spec_submit_prefix' : 0
        } , option);

        var forms = vxcp_validateForm_findFormOfAllInputs(option);

        //c/onsole.log(forms);
        if (0 < forms.size()) {
            forms.each( function() {
                var form = $(this);
                var submits = form.find('[type=submit]');
                //c/onsole.log("submits", submits, $(this));
                //c/onsole.log(forms,submits);
                submits.bind('click', function () {
                    var optionen = {};
                    optionen.submit = true;
                    optionen.formBackRef = form;
                    optionen.submitBackRef = $(this);
                    if (option.input_class_error !== undefined) {
                        optionen.input_class_error = option.input_class_error;
                    }
                    if (option.input_class_success !== undefined) {
                        optionen.input_class_success = option.input_class_success;
                    }
                    optionen.spec_submit_prefix = option.spec_submit_prefix;
                    //c/onsole.log('option(en)', option, optionen);
                    var erg = forms._vxcp_validateForm(option.fields, optionen);
                    if (erg !== 0 && erg.msg !== undefined && 0 < erg.msg.length && erg.element) {
                        //c/onsole.log('vxcp_validateFormError (1)');
                        //c/onsole.log("(950) vxcp_validateFormError");
                        erg.element.vxcp_validateFormError(erg.msg,option);
                    }
                    //c/onsole.log(option.fields,'ergebniss=' + erg, erg.element);
                    if (erg.element !== undefined) {
                        return false;
                    }else{
                        // Beim Klick auf einen der Compare-Buttons: Checkboxen zaehlen
                        var buttonCompare = $(this).attr("name");
                        if(buttonCompare=='vxcp_button-compare'){
                             thisFormId = form.attr('id');
                             thisTableName = '#'+thisFormId+'-result_table';
                              var tariffCount = $(thisTableName).find("input:checked");
                              if (0 == tariffCount.length) {
                                return false;
                              } else{
                                  return true;
                              }
                        }


                        //return true;
                    }

                });

                // Events fuer Formular-Elemente ermitteln, die zu einer sofortige Ueberpruefung fuehren
                for (var field in option.fields) {
                    var validatorListe = option.fields[field];
                    //c/onsole.log(field);

                    //Feststellen, welche Events fuer dieses Element insgesamt existieren
                    // und diese zusammenfassen
                    //  die einzelnen Validatoren durchgehen und die Trigger zusammenfassen
                    var specialEvents = [];
                    for (var para in validatorListe) {
                        // in Para stehen die einzelnen Parameter fuer ein Event
                        var paraValue = validatorListe[para];
                        //c/onsole.log('test specialEvents=', field, paraValue, typeof(paraValue));
                        if (typeof(paraValue) == 'object'
                            && paraValue.trigger !== undefined
                            && paraValue.trigger !== null) {
                            specialEvents.push(paraValue.trigger);
                        }
                        if (typeof(paraValue) == 'object'
                            && paraValue.trigger_neutral !== undefined
                            && paraValue.trigger_neutral !== null) {
                            specialEvents.push(paraValue.trigger_neutral);
                        }
                    }
                    // alle Events, die angelegt worden sind fuer dieses Element, zusammengefasst
                    specialEvents = col_union(specialEvents.join(','));

                    //c/onsole.log("specialEvents", specialEvents);

                    // Alle Validatoren fuer ein bestimmtes Event zusammenfassen
                    for (var i_events = 0; i_events < col_length(specialEvents); i_events++) {
                        var thisSpecialEvent = col_get(specialEvents, i_events);
                        var eventValidator = [];

                        // Alle Parameter fuer dieses Event einfangen
                        // dazu werden fuer jeden Event alle Angaben fuer diesen Event durchgegangen und getestet.
                        var allValidatorForEvent = [];
                        for (var para in validatorListe) {
                            var paraValue = validatorListe[para];
                            if (typeof(paraValue) == 'object'
                                && paraValue.trigger !== undefined
                                && paraValue.trigger != null
                                && (( paraValue.validator !== undefined && paraValue.validator !== null) || (paraValue.callback !== undefined && paraValue.callback))
                                && col_has(paraValue.trigger, thisSpecialEvent)) {

                                //var specialEventsfield = $(this);
                                //var trigger = paraValue.trigger;
                                var validator = paraValue;

                                eventValidator.push({
                                        'event' : thisSpecialEvent,
                                        'target' : null,
                                        'validator': validator,
                                        'error_action': 1
                                    });
                            }
                            if (typeof(paraValue) == 'object'
                                && paraValue.trigger_neutral !== undefined
                                && paraValue.trigger_neutral !== null
                                && (( paraValue.validator !== undefined && paraValue.validator !== null) || (paraValue.callback !== undefined && paraValue.callback))
                                && col_has(paraValue.trigger_neutral, thisSpecialEvent)) {

                                //var specialEventsfield = $(this);
                                //var trigger = paraValue.trigger;
                                var validator = paraValue;

                                eventValidator.push({
                                        'event' : thisSpecialEvent,
                                        'target' : null,
                                        'validator': validator,
                                        'error_action': 0
                                    });
                            }
                        }
                        //c/onsole.log('collected Events', field, thisSpecialEvent, eventValidator);

                        // alle Tests zum einem Event sind zusammengefasst in dem Array 'eventValidator'
                        // der Event selber steht unter 'thisSpecialEvent'
                        $(field).each( function() {
                            // den Eventvalidator fuer jedes einzelne Feld aktualisieren
                            //c/onsole.log ('eventValidator', eventValidator);
                            var cloneEventValidator = cloneObject(eventValidator);
                            for (var i in eventValidator) {
                                cloneEventValidator[i].target = $(this);
                                if (option.input_class_error !== undefined) {
                                    cloneEventValidator[i].input_class_error = option.input_class_error;
                                    cloneEventValidator[i].input_class_success = option.input_class_success;
                                }
                            }

                            window.setTimeout( function () {
                                    // Test aller Felder nach dem Document-Ready
                                    // wird gebraucht um bei einem Reload alle Felder zu markieren,
                                    // die fehlerhaft sind
                                    var erg = forms._vxcp_validateForm(option.fields, cloneEventValidator);
                                    //c/onsole.log ('eventValidator erg', erg);
                                }
                                , 100);

                            //c/onsole.log ('cloneEventValidator', cloneEventValidator);
                            //c/onsole.log('binding', option);
                            //c/onsole.log('binding', thisSpecialEvent, $(this));
                            $(this).bind(thisSpecialEvent, function() {
                                //c/onsole.log('common 995');
                                var erg = forms._vxcp_validateForm(option.fields, cloneEventValidator);
                                if (erg !== 0 && erg.msg !== undefined && 0 < erg.msg.length && erg.element) {
                                        //c/onsole.log('vxcp_validateFormError (2)');
                                        //c/onsole.log("(1065) vxcp_validateFormError (normaler Aufruf)", erg);
                                       erg.element.vxcp_validateFormError(erg.msg,option);
                                }
                                //c/onsole.log('common 1000');
                            });
                        });
                    }
                } /* of element */

                // Alle Elemente versehen mit einem Trigger, der Tooltips entfernt
                if (option !== undefined && option.tooltip_container !== undefined) {
                    form.find(':input').bind('focus change keyup', function() {
                        var aktivTips = $(option.tooltip_container).children(':visible').filter(':not(:animated)');
                        //c/onsole.log("(1077) Test remove tooltip, Trigger:", $(this), ", active Tooltip:",aktivTips);
                        if (0 < aktivTips.length) {
                            var close = true;
                            var popuptime = aktivTips.attr('popuptime');
                            //c/onsole.log("(1080) Zeitpunkt der Aktivierung ", popuptime);
                            if (popuptime != undefined) {
                                var d = new Date();
                                var dd = d.getTime();
                                //c/onsole.log("(1084) Zeit seit Aktivierung", dd-popuptime);
                                if (dd-popuptime < 1000) {
                                    close = false;
                                }
                            }
                            if (close) {
                                aktivTips.slideUp(200);
                                aktivTips.removeAttr('popuptime');
                            }
                        }
                    });
                }
            }); /* of each form */
        }
        else {
            // Javascript possible if there is a form
            //alert ("Javascript Validierung fehlgeschlagen, weil Form-Element fehlt");
        }

        //c/onsole.log('common 1012');
    }

    /**
    * wird wahrscheinlich nicht mehr gebraucht
    */
    $.fn.vxcp_checkInput = function(regx,error) {
        //c/onsole.log('common 1016');
        $(this).each(function () {
            var target = $(this);
            var targetID = target.attr('id');
            var count = new String($('#id').length + 1);
            var error_id = targetID.concat('_', count);
            var parent = $(this).parent();
            //  style=\"display: none;\"
            var errorTemplate = "<div id=\"" + error_id +"\" style=\"position: absolute; display: none;\">" + error + "</div>";
            parent.append(errorTemplate);

            $(this).bind('keyup', function () {
                //c/onsole.log('common 1030');
                var reg = new RegExp(regx);
                //var reg = /\d/;
                var val = $(this).val();
                var erg = reg.exec(val);
                if (reg.exec(val) === null) {
                    //c/onsole.log("(1105) creating tooltip");
                    parent.vxcp_tooltipshow(
                        "#" + error_id,
                        {'align': '#' + targetID}
                    );
                }
                else {
                    $("#" + error_id).hide();
                }
                //c/onsole.log('common 1044');
            });
        });
        //c/onsole.log('common 1044');
    }

        /**
        * eigentlich vorgesehen fuer Auto-Complete, kann aber auch fuer andere AJAX-Sachen genutzt werden.
        * Bsp.:
        * $('#plz').vxcp_ajaxForm('refTarget','#plz_target',{})
        *
        * wird wahrscheinlich nicht mehr gebraucht
        */
        $.fn.vxcp_ajaxForm = function(ref, target, options) {
            //c/onsole.log('common 1050');
            options = $.extend( {'autocomplete': true, 'closeautocomplete': false, 'closeblur': true, 'openfocus': true, 'absolute': true, 'slideTime': 100}, options);
            $(this).each(function () {
                var inputFeld = $(this);
                $(target).hide();
                if (options.absolute) {
                    $(target).css('position','absolute');
                }
                if (options.closeblur) {
                    $(target).addClass('closeblur');
                    $(this).bind('blur', function(event) {
                        //c/onsole.log('common 1065');
                        //c/onsole.log(event, $(event.target).parents());
                        window.setTimeout(
                            function () {
                                //c/onsole.log('common 1069');
                                if ($(target).hasClass('closeblur')) {
                                    $(target).clearQueue().stop().slideUp(options.slideTime,
                                        function() {
                                            $(target).css('z-index',0);
                                        });
                                }
                                else {
                                    $(target).addClass('closeblur');
                                }
                            }
                            , (50 + options.slideTime)
                        );
                    })
                }
                var ajaxAction = 'keyup';
                if (options.openfocus) {
                    ajaxAction = ajaxAction + ' focus';
                }
                $(this).bind(ajaxAction, function(event) {
                    //c/onsole.log('common 1089');
                    //c/onsole.log(event.type,event.keyCode,event);
                    var noCursorKey = true;
                    if (event.keyCode == 37 || event.keyCode == 38 || event.keyCode == 39 || event.keyCode == 40) {
                        noCursorKey = false;

                        var children = $(target).children();
                        var posHighlight = -1;
                        $(target).children().each( function (i) {
                            if ($(this).hasClass('active')) {
                                posHighlight = i;
                            }
                        });
                        if (event.keyCode == 40) {
                            $(target).children().removeClass('active');
                            posHighlight = (posHighlight + 1) % children.length;
                            $(target).children().eq(posHighlight).addClass('active');
                        }
                        if (event.keyCode == 38) {
                            $(target).children().removeClass('active');
                            if (-1 < posHighlight) posHighlight = (posHighlight - 1) % children.length;
                            $(target).children().eq(posHighlight).addClass('active');
                        }
                    }
                    if (noCursorKey) {
                        var form = $(this).parents('form');
                        var post = {};
                        var count = 0;
                        form.find(':input').each( function () {
                            post[$(this).attr('name')] = $(this).val();
                            count += 1;
                        });

                        if (0 < count) {
                            $(target).stop().slideUp(options.slideTime);
                            $.post(ref, post, function(data) {
                                //c/onsole.log('common 1125');
                                if (1 < data.length) {
                                    // aufklappen
                                    $(target).stop().empty().append(data).css('z-index',1001);
                                    $(target).slideDown(options.slideTime, function() {
                                        $(this).css('height','');

                                        $(target).mouseenter( function() {
                                            //c/onsole.log('common 1132');
                                            $(target).children().removeClass('active');
                                        });

                                        if (options.autocomplete) {
                                            $(target).children().click( function() {
                                                //c/onsole.log('common 1139');
                                                if (!options.closeautocomplete) {
                                                    $(target).removeClass('closeblur');
                                                }
                                                inputFeld.val($(this).text());
                                                inputFeld.focus();
                                            });

                                        }
                                    });
                                }
                            });
                        }
                    }
                });
            });
            //c/onsole.log('common 1145');
        }

        /**
        * Fuer 'on the fly'-generierte Tooltips.
        * Callback-Routine, ist Teil der Tooltip-Routine
        */
        function text2TipHTMLDefault(content, preferredID) {
            var toolTip = document.createElement('div');
            toolTip.id = preferredID;
            $(toolTip)
                .css('position', 'absolute')
                .css('background','#fff')
                .css('padding','5pt')
                .css('border','2pt solid black')
                .css('width','300px')
                .css('display','none')
                .append(content);
            var toolTipContainer = $('.vxcp_tooltip_container');
            if (0 == toolTipContainer.size()) {
                toolTipContainer = $('body');
            }
            toolTipContainer.append(toolTip);

            //c/onsole.log('inside tooltip', toolTip);
            return toolTip;
        }

        /**********************************************************************
        * flashes a tooltip at the object
        * the tooltip must be an immidiate child of the Object, this is for a more generic approach of
        * mode=0: ausgeloest wird der Event durch einen Mousemove und klebt dann am Mousezeiger,
        *                der Tooltip endet, wenn der Mauszeiger das Element verlaesst.
        * mode=1: ausgeloest wird der Tooltipp direkt, enden tut er, wenn der Tipp weggeklickt wird, oder beim naechsten Test
        * ### Example
        * <div class='helper'>aaa...<span>bbb...</span></div>
        * $('.helper').vxcp_tooltip('span')
        * ### Options
        *
        *  scrolling = true,  Tooltip geht mit der Maus mit
        *  scrolling = false,  Tooltip steht an einer festen Stelle
        *  position = 'auto'|'top'|'formular' (default ist 'auto')
        *           'formular' bindet kein Event an das zugehoerige Element, sondern 'flasht' direkt auf
        *  posx = zahl,
        *  posy = zahl,
        *
        *  child = string, indentifiziert das Subelement mit dem Inhalt fuer den Tooltip
        *  assign_pre = gibt einen Praefix an, der zum id des Elements das entsprechende Element mit dem Tooltip sucht.
        *  xpath = direkte Angabe des Identifier (in form eines XPath)
        *
        * ================================================================================
        *  internal, position wird umgewandelt in diese Parameter
        *  mode = 0, fuer Erweiterungen
        *  valign = 0, wie 1, wird gebraucht um zu zeigen, dass der Default genommen werden soll
        *  valign = 1, unterhalb des Tooltips, ausser es ist zuwenig Platz, dann oberhalb
        *  valign = 2, unter oder oberhalb des Tooltips, abhaengig davon, wo mehr Platz ist
        *  valign = 3, oberhalb des Elementes
        *  valign = 4, oberhalb des Tooltips, ausser es ist zuwenig Platz, dann unterhalb
        *  align = 0, wie 1, wird gebraucht um zu zeigen, dass der Default genommen werden soll
        *  align = 1, immer rechts vom Element, bleibt stehen, selbst wenn es aus dem Bildschirm rausgeht
        *  align = 2, rechts vom Element, ausser es ist zuwenig Platz, dann links.
        *  cap = 0, wie 1, wird gebraucht um zu zeigen, dass der Default genommen werden soll
        *  cap = 1, geht ueber den Bildschirmrand hinaus
        *  cap = 2, (komplex capping) bleibt am Bildschirmrand stehen, beruecksicht aber nur links/rechts,
        *           und erst wenn links, rechts nicht benoetigt wird, oben/unten
        *  order = 0, wie 1, wird gebraucht um zu zeigen, dass der Default genommen werden soll
        *  order = 1, es wird Platz gemessen unter Beruecksichtigung der Maus,
        *           der Tooltipp kann also springen in Abhaengigkeit von der Maus
        *  order = 2, es wird Platz gemessen an den Dimensionen des ausloesenden Elementes
        *  check_mouse = 0
        *  check_mouse = 1 Tooltip bewegt sich mit der Maus mit
        *  ajaxFromRef = true das ausloesende Element enthaelt eine href, von der der Content durch AJAX geholt wird
        *  text2TipHTML = callBack-Funktion, wandelt einen Text in einen Tooltip um haengt ihn in den Body ein.
        *           die Funktion bekommt zwei Parameter:
        *           (1) den Inhalt, reiner HTML, der durch innerHTML eingehaengt wird,
        *               ! Es sind wegen innerHTML keine sofortigen Javascript-Operationen auf dem Inhalt moeglich
        *           (2) eine bevorzugte ID zur Identifizierung des Tooltips,
        *               diese ID wird vor Tooltip-Routine vergeben.
        *           es wird kein Wert zurueckgegeben
        *
        * *************************************
        * Beispiel fuer Ajax-geladenen Tooltip mit einem Element im Tooltip, dass auf die Klasse close den Tooltip schliesst
        *
        * $('.vxcp_urltooltip').vxcp_tooltip({
        *   'ajaxFromRef': true,
        *   'cap' : 2,
        *   'closeElement' : '.close',
        *   'triggerAction' : 'click'
        * });
        * *************************************
        * Bedeutung von Variablen
        *   tooltipp_hover_elem     =   die Maus befindet sich gerade ueber dem ausloesenden Element
        *   tooltipp_hover_tip      =   die Maus befindet sich gerade ueber dem Tooltip
        *   tooltipp_hover_entry    =   Objekt mit x und y Attribut, bezeichnet die Stelle, an der der Maus-Event
        *                               auf dem Tooltip das erstemal gemessen wurde
        * bei tooltipp_hover_elem und tooltipp_hover_tip koennen immer nur wechselseitig auf true oder false sein
        * sind beide auf false, dann wird der Tooltip ausgeschaltet.
        * Beide auf True waere ein Fehler.
        *
        *   tips                    =   der ermittelte Tooltip
        *                               bleibt leer bei AJAX - Tooltips
        *   tipnot                  =   lokale Variable beim Ermitteln des korrekten Tooltips
        *   tooltipp_last           =   der letzte offene Tooltip
        *                               wird auf undefined gesetzt, wenn der Tooltip geschlossen wird.
        *
        ***********************************************************************/

        $.fn.vxcp_tooltip = function(options) {
            //c/onsole.log('common 1253');
            options = $.extend( {
                'valign': 0,
                'align': 0,
                'order': 0,
                'cap': 0,
                'check_mouse': 0,
                'scrolling': true,
                'posx': 0,
                'posy': 0,
                'cursorx': 18,
                'cursory': 18,
                'zindex': 1,
                'ajaxFromRef': false,
                'triggerAction': 'mousemove mouseenter',
                'closeMouseout': true,
                'text2TipHTML' : text2TipHTMLDefault,
                'position': 'auto',
                'tooltipp_globalInitCounter' : 0}, options);

            if (options.position == 'formular') {
                //if (options.align == 0) options.align = 2;
                options.align = 2;
                options.valign = 1;
                options.check_mouse = 2;
                options.cursorx = 0;
                options.cursory = 0;
            }
            if (options.position == 'top') {
                if (options.align == 0) options.align = 1;
                if (options.valign == 0) options.valign = 3;
                if (options.cap == 0) options.cap = 1;
                if (options.order == 0) options.order = 1;
                if (options.check_mouse == 0) options.check_mouse = 1;
                //options.align = 3;
            }
            if (options.position == 'auto') {
                if (options.align == 0) options.align = 2;
                if (options.valign == 0) options.valign = 1;
                if (options.cap == 0) options.cap = 2;
                if (options.order == 0) options.order = 1;
                if (options.check_mouse == 0) options.check_mouse = 1;
                //options.align = 3;
            }
            if (!options.scrolling) {
                options.check_mouse = 2;
            }

            var elements = $(this);
            var tips = $([]);
            elements.each(function () {
                // der GlobalCounter ist nur fuer Tests
                options.globalCounter = tooltipp_globalCounter;
                tooltipp_globalCounter += 1;
                // hoverElem = das ausloesende Element
                var hoverElem = $(this);
                // tips enthaelt den den Tooltip
                var tipnot = true;
                // testen, ob man den Tooltip ueber die Praefix-Methode bekommt
                if (options.assign_pre !== undefined) {
                    var thisId = options.assign_pre.concat($(this).attr('id'));
                    tips = $('#' + thisId);
                    if (0 < tips.length) {
                        tips.css('position', 'absolute').css('z-index', options.zindex);
                        tips.hide();
                        tipnot = false;
                    }
                }
                // testen, ob man den Tooltip ueber die Child-Methode bekommt
                if (options.child !== undefined && tipnot) {
                    tips = $(this).children(options.child);
                    if (0 < tips.length) {
                        tips.css('position', 'absolute').css('z-index', options.zindex);
                        tips.hide();
                        tipnot = false;
                    }
                }
                if (options.xpath !== undefined && tipnot) {
                    tips = $(options.xpath);
                    tips.css('position', 'absolute').css('z-index', options.zindex);
                    tips.hide();
                        tipnot = false;
                }

                if (options['ajaxFromRef'] && tipnot) {
                    //options['closeMouseout'] = false;
                    tipnot = false;
                }

                // hier ist die Bestimmung des anzuzeigenden Elementes fertig
                // bis auf die Anzeige mit Ajax steht der Tooltip in tips
                // --------------------
                // zuerst unterscheiden, ob es sich um einen durch einen Event ausgeloesten Tooltip handelt oder
                // um einen intern (zB bei Formular) angeforderten Tooltip handelt,

                if (options.position != 'formular') {
                    // optionCopy wird neu erzeugt bei jedem Durchlauf und ist ein echter Clone
                    var optionsCopy = $.extend({
                        'tooltipp_hover_entry': {},
                        'tooltipp_hover_tip': false,
                        // *
                        // tooltipp_hover_elem = true, wenn der Mauszeiger auf dem ausloesenden Element ist,
                        // wird auf false sobald der Mauszeiger das Element verlassen hat.
                        // ist fuer asynchrone Aufrufe wichtig, damit das Element nach dem Aufruf noch weiss, ob es gebraucht wird
                        'tooltipp_hover_elem': false}, options);
                    optionsCopy['tips'] = tips;
                    optionsCopy['trigger'] = hoverElem;
                    // fuer die Tips ein Flag setzen, dass sie noch keine Event-Steuerung haben
                    optionsCopy['tipsAreRaw'] = true;

                    // ---------------------------------------
                    // Versieht den Tooltip mit seinen Events
                    var initTooltip = function () {
                        //c/onsole.log('initTooltip', optionsCopy.tips, optionsCopy.globalCounter, optionsCopy.tooltipp_globalInitCounter);
                        optionsCopy.tooltipp_globalInitCounter = tooltipp_globalInitCounter;
                        tooltipp_globalInitCounter = tooltipp_globalInitCounter + 1;
                        if (optionsCopy.closeElement !== undefined) {
                            var closeElem = optionsCopy.tips.find(optionsCopy.closeElement);
                            //c/onsole.log(optionsCopy.closeElement, closeElem);
                            if (0 == closeElem.size()) {
                                // es wurde kein Close-Element gefunden
                            }
                            else {
                                closeElem.bind('click', function () {
                                    optionsCopy.tips.hide(0);
                                });
                            }
                        }
                        optionsCopy.tips.bind('mousemove mouseenter', function (event) {
                            // Verhalten wenn die Mouse auf den Tooltip kommt
                            //c/onsole.log('mouseEnter', optionsCopy.globalCounter);
                            if (!optionsCopy.tooltipp_hover_tip) {
                                // Der Tooltipp soll verschwinden, wenn ein anderes Ereigniss
                                // mit einer gewissen Distanz zum Punkt eintritt, an dem der Tooltip ausgeloesst wurde
                                // damit wird das Flackern von Tooltips verhindert
                                optionsCopy.tooltipp_hover_entry.x = event.pageX;
                                optionsCopy.tooltipp_hover_entry.y = event.pageY;
                            }
                            optionsCopy.tooltipp_hover_tip = true;
                            optionsCopy.tooltipp_hover_elem = false;
                            var dx = optionsCopy.tooltipp_hover_entry.x - event.pageX;
                            var dy = optionsCopy.tooltipp_hover_entry.y - event.pageY;
                            var r = dx * dx + dy * dy;
                            //c/onsole.log('r=', r, optionsCopy.tips);
                            if (optionsCopy.closeElement === undefined) {
                                if (r < 2000) {
                                    optionsCopy['event'] = event;
                                    optionsCopy.tips.stop().show();
                                }
                                else {
                                    if (optionsCopy.closeMouseout) {
                                        optionsCopy.tips.hide();
                                    }
                                }
                            }
                            return false;
                        });

                        if (optionsCopy.closeMouseout && optionsCopy.closeElement === undefined) {
                            optionsCopy.tips.mouseout( function () {
                                //co/nsole.log('closeMouseout', optionsCopy.tips, $(this), optionsCopy.globalCounter, optionsCopy.tooltipp_globalInitCounter, optionsCopy.tooltipp_hover_elem, optionsCopy.tooltipp_hover_tip);
                                optionsCopy.tooltipp_hover_tip = false;
                                if (!optionsCopy.tooltipp_hover_elem && !optionsCopy.tooltipp_hover_tip) {
                                    optionsCopy.tips.hide(0);
                                    $('.dev_helper').hide();
                                }
                            });
                        }
                    }
                    // Versieht den Tooltip mit seinen Events
                    // ---------------------------------------

                    hoverElem.bind( optionsCopy['triggerAction'],function (event) {
                        // der Tooltip wird angefordert
                        optionsCopy['event'] = event;
                        if (options['ajaxFromRef']) {
                            // wir wollen Ajax
                             var href = optionsCopy.trigger.attr('href');
                             if (href !== undefined && 5 < href.length) {
                                var preferredID = 'ajaxTooltip_' + href2id(href);
                                var count_tooltopsWithThisRef = $('#' + preferredID).size();
                                //c/onsole.log(hoverElem,hoverElem.attr('href'),preferredID);
                                if (optionsCopy.tips.size() == 0) {
                                    $.get(href, function(data) {
                                       var toolTipElem = options['text2TipHTML'](data,preferredID);
                                       //c/onsole.log("toolTipElem = ", toolTipElem);
                                       var toolTipContainer = $('.vxcp_tooltip_container');
                                       if (0 == toolTipContainer.size()) {
                                            toolTipContainer = $('body');
                                       }
                                       toolTipContainer.append(toolTipElem);
                                       optionsCopy.tips = $(toolTipElem);
                                       optionsCopy['tipsAreRaw'] = false;
                                       initTooltip();
                                    });
                                }
                                else {
                                    // es existiert bereits Tooltip, in dem genau diese Adresse abgefragt wurde

                                }
                             }
                        }
                        if (optionsCopy['tipsAreRaw']) {
                            // Die Anforderung ist das erstemal, die Parameter und Trigger muessen initialisiert werden
                            if (0 < optionsCopy.tips.size()) {
                                optionsCopy['tipsAreRaw'] = false;
                                initTooltip();
                            }
                            //c/onsole.log('hoverElem.triggerInit', optionsCopy['tips'].size(), optionsCopy.globalCounter);
                        }

                        //c/onsole.log("(1544) creating tooltip");
                        optionsCopy.trigger.vxcp_tooltipshow(optionsCopy.tips, optionsCopy);
                        optionsCopy.tooltipp_hover_elem = true;
                        optionsCopy.tooltipp_hover_tip = false;
                        return false;
                    });
                    //c/onsole.log('hoverElem.init', optionsCopy.tips, optionsCopy, optionsCopy.globalCounter);
                    // Die Bedingungen, zu denen das Tooltip geschlossen werden soll
                    // (1) Wenn die Mouse den Trigger verlaesst,
                    //     Dabei wird auch beruecksichtigt, dass der Tooltip eventuell ueber dem Trigger stand,
                    //     in dem Fall zaehlt der MouseOut des Tooltips
                    if (optionsCopy.closeMouseout) {
                        if (optionsCopy.closeElement === undefined) {
                            optionsCopy.trigger.mouseout( function () {
                                //c/onsole.log('triggerMouseout', optionsCopy.tips, optionsCopy.trigger, $(this), optionsCopy.globalCounter, optionsCopy.tooltipp_globalInitCounter, optionsCopy.tooltipp_hover_elem, optionsCopy.tooltipp_hover_tip);
                                optionsCopy.tooltipp_hover_elem = false;
                                if (!optionsCopy.tooltipp_hover_elem && !optionsCopy.tooltipp_hover_tip) {
                                    optionsCopy.tips.hide(0);
                                    $('.dev_helper').hide();
                                }
                            });
                        }
                        else {

                        }
                    }
                }

                if (options.position == 'formular') {
                    // die Tooltips, die fuer gewoehnlich einen Warnhinweis enthalten bezogen auf eine Eingabe

                    //c/onsole.log("(1575) creating tooltip for formular");
                    hoverElem.vxcp_tooltipshow(tips, options);

                    hoverElem.mouseenter( function () {
                        tips.hide(0, function() {tips.remove();});
                    });
                    hoverElem.keyup( function () {
                        tips.hide(0, function() {tips.remove();});
                    });
                    tips.click( function () {
                        tips.hide(0, function() {tips.remove();});
                    });
                    var d = new Date();
                    tips.attr('popUpTime', d.getTime());
                }
            });
            return tips;
            //c/onsole.log('common 1505');
        };

    $.fn.vxcp_tooltipshow = function(tips, options) {
        //c/onsole.log('(1590) displaying Tooltip');
        //c/onsole.log(tips, options);
        options = $.extend( {
            'mode': 0,
            'align': 0,
            'valign': 0,
            'posx': 0,
            'posy': 0,
            // zusaetzlicher Abstand nach oben
            'offsetTopQuads': 10,
            'cursorx': 10,
            'cursory': 10 }, options);
        // der Ausloeser wird ueber den Event ermittelt
        // fuer den Fall, dass der Event keinen Trigger mitliefert
        // wird die Referenzierung durch $(this) verwendet,
        // das ist korrekt, solange die Struktur nicht durch 'clone' verschoben wird.
        var event = options.event?options.event:0;
        var hoverElem2;
        if (event) {
            hoverElem2 = event.currentTarget;
        }
        var hoverElem = (hoverElem2)?$(hoverElem2):$(this);
        if (1 == tips.length) {
            if (options.mode == 0 || options.mode == 1 || options.mode == 2) {
                var test = 0;

                /**** Felder zum Testen der Tooltip-Berechnung (Start) ****/
                if (1 == test) {
                    var b = 10;
                    var test_tooltip_1;
                    do {
                        b = b - 1;
                        test_tooltip_1 = $('#test_tooltip_1');
                        if (0 < test_tooltip_1.length) b = 0;
                        else $('body').append('<div id="test_tooltip_1" class="dev_helper" style="background-color: #0a0; position: absolute; filter:alpha(opacity=20); opacity: 0.2; -moz-opacity:0.2;"></div>');
                    } while (0 < b);

                    var b = 10;
                    var test_tooltip_2;
                    do {
                        b = b - 1;
                        test_tooltip_2 = $('#test_tooltip_2');
                        if (0 < test_tooltip_2.length) b = 0;
                        else $('body').append('<div id="test_tooltip_2" class="dev_helper" style="background-color: #00a; position: absolute; filter:alpha(opacity=20); opacity: 0.2; -moz-opacity:0.2;"></div>');
                    } while (0 < b);

                    var b = 10;
                    var test_tooltip_3;
                    do {
                        b = b - 1;
                        test_tooltip_3 = $('#test_tooltip_3');
                        if (0 < test_tooltip_3.length) b = 0;
                        else $('body').append('<div id="test_tooltip_3" class="dev_helper" style="background-color: #aa0; position: absolute; filter:alpha(opacity=20); opacity: 0.2; -moz-opacity:0.2;"></div>');
                    } while (0 < b);

                    var b = 10;
                    var test_tooltip_4;
                    do {
                        b = b - 1;
                        test_tooltip_4 = $('#test_tooltip_4');
                        if (0 < test_tooltip_4.length) b = 0;
                        else $('body').append('<div id="test_tooltip_4" class="dev_helper" style="background-color: #a00; position: absolute; filter:alpha(opacity=20); opacity: 0.2; -moz-opacity:0.2;"></div>');
                    } while (0 < b);

                    var b = 10;
                    var test_tooltip_5;
                    do {
                        b = b - 1;
                        test_tooltip_5 = $('#test_tooltip_5');
                        if (0 < test_tooltip_5.length) b = 0;
                        else $('body').append('<div id="test_tooltip_5" class="dev_helper" style="background-color: #aaa; position: absolute;"></div>');
                    } while (0 < b);
                }
                /**** Felder zum Testen der Tooltip-Berechnung (Ende) ****/

                if (0 < tips.not(':visible,animated').length) {
                    tips.not(':visible,animated').css('z-index', 5);
                    //hoverElem.css('z-index', 1000);
                    tips.show();
                    tips.css('z-index', 10000);
                    //tips.css('opacity', 1);
                    tips.parent().css('z-index', 10000);
                    //tips.parent().css('opacity', 1);
                    //tips.css('border', '10px solid blue');
                }

                // Screendaten, sichtbarer Bereich, Start und Ausdehnung
                // log ('window.innerHeight ' +  window.innerHeight);
                // log ('document.body.clientHeight ' + document.body.clientHeight);
                // log ('document.documentElement.clientHeight ' + document.documentElement.clientHeight);
                // log ('window.innerWidth ' +  window.innerWidth);
                // log ('document.body.clientWidth ' + document.body.clientWidth);
                var innerHeight = window.innerHeight?window.innerHeight:(document.body.clientHeight?document.body.clientHeight:document.documentElement.clientHeight);
                var innerWidth = window.innerWidth?window.innerWidth:document.body.clientWidth;
                var scrollTop = window.pageYOffset?window.pageYOffset:(document.body.scrollTop?document.body.scrollTop:document.documentElement.scrollTop);
                var scrollLeft = window.pageXOffset?window.pageXOffset:(document.body.scrollLeft?document.body.scrollLeft:document.documentElement.scrollLeft);

                var bottomWindow = innerHeight + scrollTop;
                var rightWindow = innerWidth + scrollLeft;

                // ausloesendes Element
                var hoverElemOffset = hoverElem.offset();
                var hoverElemWidth = hoverElem.outerWidth();
                var hoverElemHeight = hoverElem.outerHeight();
                //c/onsole.log(tips.get(0));
                // tooltip - Container
                var tipsParentOffset = $(tips.get(0).offsetParent).offset();
                //psStraight = tips.get(0);
                //c/onsole.log(tipsStraight, tipsStraight.offsetLeft);
                //c/onsole.log(tipsStraight.offsetParent, tipsStraight.offsetParent.offsetLeft);
                //c/onsole.log(tipsStraight.offsetParent.offsetParent, tipsStraight.offsetParent.offsetParent.offsetLeft);
                //c/onsole.log(tipsStraight.offsetParent.offsetParent.offsetParent, tipsStraight.offsetParent.offsetParent.offsetParent.offsetLeft);

                // tooltop Daten
                var tipsWidth = tips.outerWidth();
                var tipsHeight = tips.outerHeight();

                // Basisoffset fuer die Tips
                var tipsBaseOffsetTop = hoverElemOffset.top;
                var tipsBaseOffsetLeft = hoverElemOffset.left;
                var tipsBaseOffsetTopOriginal = tipsBaseOffsetTop;
                var tipsBaseOffsetLeftOriginal = tipsBaseOffsetLeft;

                // EventOffset
                var eventOffsetTop = tipsBaseOffsetTopOriginal;
                var eventOffsetLeft = tipsBaseOffsetLeftOriginal;
                var eventOffsetBottom = tipsBaseOffsetTopOriginal + hoverElemHeight;
                var eventOffsetRight = tipsBaseOffsetLeftOriginal + hoverElemWidth;

                var margin_top = tipsBaseOffsetTopOriginal - scrollTop - 10;
                var margin_bottom = innerHeight + scrollTop - (tipsBaseOffsetTopOriginal + hoverElemHeight) - 20;
                var margin_left = tipsBaseOffsetLeftOriginal - scrollLeft - 10;
                var margin_right = innerWidth + scrollLeft - (tipsBaseOffsetLeftOriginal + hoverElemWidth) - 20;

                var preferBottom = margin_top < margin_bottom;
                var preferRight = margin_left < margin_right;

                //log('innerHeight: ' + innerHeight);
                //log('innerWidth: ' + innerWidth);
                //log('scrollTop: ' + scrollTop);
                //log('scrollLeft: ' + scrollLeft);
                //log('bottomWindow: ' + bottomWindow);
                //log('rightWindow: ' + rightWindow);
                //log('eventOffsetTop: ' + tipsBaseOffsetTopOriginal);
                //log('eventOffsetLeft: ' + tipsBaseOffsetLeftOriginal);

                if (event != 0 && options.check_mouse == 1) {
                    //var eventOffsetTop = event.clientY - hoverElemOffset.top + scrollTop;
                    //var eventOffsetLeft = event.clientX - hoverElemOffset.left + scrollLeft;
                    var eventTop = event.pageY - tipsBaseOffsetTopOriginal;
                    var eventLeft = event.pageX - tipsBaseOffsetLeftOriginal;

                    var r = 2;

                    eventOffsetTop = tipsBaseOffsetTopOriginal + eventTop - r;
                    eventOffsetLeft = tipsBaseOffsetLeftOriginal + eventLeft - r;
                    eventOffsetBottom = tipsBaseOffsetTopOriginal + eventTop + r + options.cursory;
                    eventOffsetRight = tipsBaseOffsetLeftOriginal + eventLeft + r + options.cursorx;

                    margin_top = tipsBaseOffsetTopOriginal + eventTop - scrollTop - 10 - r - options.offsetTopQuads;
                    margin_bottom = innerHeight + scrollTop - eventTop - tipsBaseOffsetTopOriginal - 20 - r - options.cursory;
                    margin_left = tipsBaseOffsetLeftOriginal + eventLeft - scrollLeft - 10 - r;
                    margin_right = innerWidth + scrollLeft - eventLeft - tipsBaseOffsetLeftOriginal - 20 - r - options.cursorx;
                }

                if (options.order == 0 || options.order == 1) {
                    preferBottom = margin_top < margin_bottom;
                    preferRight = margin_left < margin_right;
                }

                // Test
                //c/onsole.log(tips);
                // tipsBaseOffsetTopOriginal + hoverElemHeight
                if (1 == test) {
                    test_tooltip_1
                        .css('top', eventOffsetBottom)
                        .css('left', eventOffsetRight)
                        .css('height', margin_bottom)
                        .css('width', margin_right)
                        .show();

                    test_tooltip_2
                        .css('top', scrollTop + 10)
                        .css('left', eventOffsetRight)
                        .css('height', margin_top)
                        .css('width', margin_right)
                        .show();

                    test_tooltip_3
                        .css('top', eventOffsetBottom)
                        .css('left', scrollLeft + 10)
                        .css('height', margin_bottom)
                        .css('width', margin_left)
                        .show();

                    test_tooltip_4
                        .css('top', scrollTop + 10)
                        .css('left', scrollLeft + 10)
                        .css('height', margin_top)
                        .css('width', margin_left)
                        .show();
                }

                // Aussuchen des passenden Quadrates
                var pos = 0;
                if (2 == options.align && margin_right < tipsWidth && margin_right < margin_left) {
                    // bevorzugt rechts, ausser es passt nicht und links ist mehr Platz
                    pos += 2;
                }
                if ((0 == options.valign || 1 == options.valign) && margin_bottom < tipsHeight && margin_bottom < margin_top) {
                    // bevorzugt unten, ausser es passt nicht und oben ist mehr Platz
                    pos |= 1;
                }
                if (2 == options.valign && margin_bottom < margin_top) {
                    // dahin, wo mehr Platz ist
                    pos |= 1;
                }
                if (3 == options.valign) {
                    // grundsaetzlich oben
                    pos |= 1;
                }
                if (4 == options.valign && (tipsHeight <= margin_top || margin_bottom < margin_top)) {
                    // bevorzugt oben
                    pos |= 1;
                }


                // Standart bottom-right
                var tipsTop = eventOffsetBottom + options.posy;
                var tipsLeft = eventOffsetRight + options.posx;
                var isRight = true;
                var isBottom = true;

                if (1 == pos) {
                    // top-right
                    tipsTop = eventOffsetTop - tipsHeight - options.offsetTopQuads + options.posy;
                    tipsLeft = eventOffsetRight + options.posx;
                    isRight = true;
                    isBottom = false;
                }

                if (2 == pos) {
                    // bottom-left
                    tipsTop = eventOffsetBottom + options.posy;
                    tipsLeft = eventOffsetLeft - tipsWidth + options.posx;
                    isRight = false;
                    isBottom = true;
                }

                if (3 == pos) {
                    // top-left
                    tipsTop = eventOffsetTop - tipsHeight - options.offsetTopQuads + options.posy;
                    tipsLeft = eventOffsetLeft - tipsWidth  + options.posx;
                    isRight = false;
                    isBottom = false;
                }

                if (options.cap == 2) {
                    var noCap = true;
                    if (isRight) {
                        // capping right
                        if (margin_right < tipsWidth) {
                            tipsLeft = eventOffsetRight + margin_right - tipsWidth;
                            noCap = false;
                        }
                    }
                    else {
                        // capping left
                        if (margin_left < tipsWidth) {
                            tipsLeft = scrollLeft + 10;
                            noCap = false;
                        }
                    }

                    if (noCap) {
                        if (isBottom) {
                            // capping bottom
                            if (margin_bottom < tipsHeight) {
                                tipsTop = eventOffsetBottom + margin_bottom - tipsHeight;
                                noCap = false;
                            }
                        }
                        else {
                            // capping left
                            if (margin_top < tipsHeight) {
                                tipsTop = scrollTop + 10;
                                noCap = false;
                            }
                        }
                    }
                }

                if (1 == test) {
                    test_tooltip_5
                        .css('top', tipsTop)
                        .css('left', tipsLeft)
                        .css('height', tipsHeight)
                        .css('width', tipsWidth)
                        .show();
                }

                //c/onsole.log(tips);
                tips.css('top',  (tipsTop) + 'px');
                tips.css('left',  (tipsLeft) + 'px');
            }
        }
        return false;
    }








    $(document).ready(function(){

        // ********************************************************************************
        // Tooltips initialisieren

        // die Child-Tooltip-Initialisierung
        //$('.vxcp_tooltip').css('border', '10px solid cyan').hover(
        //    function () {$(this).css('border', '10px solid green');},
        //    function () {$(this).css('border', '10px solid red');}
        //);
        //c/onsole.log("(1925) creating Tooltip");
        $('.vxcp_tooltip').vxcp_tooltip( {child: '.vxcp_tooltip-content', assign_pre : 'vxcp_tooltip_'});

        // Sobald die Child-Tooltip-Initialisierung abgeschlossen ist, koennen die Tooltips an das Ende des Bodies.
        // dadurch wird das Berechnen der Position leichter weil all dir relativen Offsets wegfallen
        //  die Tooltips stehen nur wegeb Google&Co an den Stellen, an denen sie jetzt stehen.
        $('body').append('<div class="vxcp_tooltip_container vxcp" style="position: absolute; top:0px; left:0px;"></div>');
        $('.vxcp_tooltip-content').appendTo('.vxcp_tooltip_container');

            //$('#plz').vxcp_ajaxForm('refTarget','#plz_target',{})

        // *********************************************************************************
        // Anpassung an Browser, die sich im Quirks-Mode befinden
        // speziell an den Internet-Explorer, der sich im Quirks-Mode anders verhaelt als zB der Firefox.
        // getestet wird die spezielle Eigenschaft 'document.documentElement.currentStyle.hasLayout'
        // die nur im IE existiert und anscheinend nur dann true ist, wenn eine CSS verwendet wurde.
        //$('body').prepend(document.compatMode);
        // document.compatMode == 'BackCompat'
        var c1n = '?';
        if (document.documentElement.currentStyle !== undefined && document.documentElement.currentStyle.hasLayout !== undefined) {
            c1n = document.documentElement.currentStyle.hasLayout;
        }
        if (c1n == false) {
            var base = $('.vxcp');
            base.find('input[type=text]').addClass('vxcp_input-text');
            base.find('input[type=radio]').addClass('vxcp_input-radio');
            base.find('input[type=checkbox]').addClass('vxcp_input-checkbox');
            base.find('input[type=submit]').addClass('vxcp_input-submit');
            vxcp_jQuery('body').addClass('vxcp_quirksmode');
        }

    });

})(vxcp_jQuery);
(function($) {




    ///////////////// TOGGLE
    ///////////////// TOGGLE
    ///////////////// TOGGLE

    $.fn.vxcp_toggle_connect = function() {

            var TOGGOPENER = this;
            var TOGGNAME = TOGGOPENER.attr('data-toggle-name');

            if(!vxcp_empty(TOGGNAME)){

                var TOGGCONTENTS = $('div[data-toggle-name='+ TOGGNAME +'], tr[data-toggle-name='+ TOGGNAME +'], li[data-toggle-name='+ TOGGNAME +']').not('.vxcp_toggle');

                if(TOGGCONTENTS.length >= 1){

                        // erstmal für alle den toogle status setzen
                        TOGGCONTENTS.each(function(){

                                var thisToggleContent = $(this);
                                thisToggleContent.addClass('vxcp_toggle-content');

                                //alert(TOGGNAME + ' -- ' + thisToggleContent.css('display'));

                                if(thisToggleContent.css('display') == 'none'){
                                    //aufgeklappt
                                    thisToggleContent.attr('data-toggle-status', 'off');
                                } else {
                                    thisToggleContent.attr('data-toggle-status', 'on');
                                }

                                if(thisToggleContent.attr('data-toggle-handle') !== undefined){
                                    var handle = parseInt(thisToggleContent.attr('data-toggle-handle'));
                                }else{
                                    var handle = 1;
                                }

                                if ( handle == 1 )
                                {
                                    $(window).resize(function() {
                                        thisToggleContent.attr('data-toggle-status', '');
                                        if(thisToggleContent.css('display') == 'none'){
                                            //aufgeklappt
                                            thisToggleContent.attr('data-toggle-status', 'off');
                                        } else {
                                            thisToggleContent.attr('data-toggle-status', 'on');
                                        }
                                    });
                                }
                        });

                        if(TOGGOPENER.is(':checkbox') || TOGGOPENER.is(':radio')){
                                /////////////////////////////////////////////////////// CHECKBOX

                                if( TOGGOPENER.is(':checked') ){
                                    //haken drin, also aufklappen
                                    TOGGCONTENTS.show().attr('data-toggle-status', 'on');
                                } else {
                                    //haken draußen, also einklappen
                                    TOGGCONTENTS.hide().attr('data-toggle-status', 'off');
                                }

                                    if(TOGGOPENER.is(':checkbox')){
                                                // BIND CHECKBOX ////////////////////////
                                                TOGGOPENER.change(function() {

                                                    if(!vxcp_empty(TOGGNAME)){

                                                        var THISCONTENTS = $('div[data-toggle-name='+ TOGGNAME +'], tr[data-toggle-name='+ TOGGNAME +'], li[data-toggle-name='+ TOGGNAME +']').not('.vxcp_toggle');

                                                        if($(this).is(':checked')){
                                                            //aufgeklappt
                                                            THISCONTENTS.attr('data-toggle-status', 'on').slideDown(200);
                                                            TOGGOPENER.attr('data-toggle-status', 'on');
                                                        } else {
                                                            THISCONTENTS.attr('data-toggle-status', 'off').slideUp(200);
                                                            TOGGOPENER.attr('data-toggle-status', 'off');
                                                        }
                                                    }
                                                });

                                    } else if(TOGGOPENER.is(':radio')){



                                                var form      = TOGGOPENER.closest('form');
                                                var groupName = TOGGOPENER.attr('name');

                                                if(form.length == 1){
                                                    var radioGroup = form.find(':radio[name="'+groupName+'"]');

                                                    var THISCONTENTS = $('div[data-toggle-name='+ TOGGNAME +'], tr[data-toggle-name='+ TOGGNAME +'], li[data-toggle-name='+ TOGGNAME +']').not('.vxcp_toggle');

                                                    radioGroup.change(function() {

                                                        if($(this).is('.vxcp_toggle[data-toggle-name='+ TOGGNAME +']')){
                                                            // in der gruppe gabs nochn anderes toggle. ein anderes aus der gruppe angeklickt.. schließen
                                                            THISCONTENTS.attr('data-toggle-status', 'on').slideDown(200);
                                                            TOGGOPENER.attr('data-toggle-status', 'on');

                                                        } else {
                                                            THISCONTENTS.attr('data-toggle-status', 'off').slideUp(200);
                                                            TOGGOPENER.attr('data-toggle-status', 'off');
                                                        }

                                                    });
                                                }

                                    }

                        }else{
                            // für alle div-toggles (keine checkbox-toggles)

                                //erster gefundener container.. wenn dieser auf ist werden alle anderen auch geöffnet
                                var firstContainer = TOGGCONTENTS.eq(0);



                                if(firstContainer.css('display') == 'none'){
                                    //aufgeklappt
                                    TOGGCONTENTS.hide().attr('data-toggle-status', 'off');
                                    TOGGOPENER.attr('data-toggle-status', 'off');
                                } else {
                                    TOGGCONTENTS.show().attr('data-toggle-status', 'on');
                                    TOGGOPENER.attr('data-toggle-status', 'on');
                                }

                                if(
                                    !vxcp_empty(TOGGOPENER.attr('data-toggle-opened')) &&
                                    !vxcp_empty(TOGGOPENER.attr('data-toggle-closed'))
                                ){

                                    if(TOGGOPENER.attr('data-toggle-status') == 'off'){
                                        //aufgeklappt
                                        TOGGOPENER.text(TOGGOPENER.attr('data-toggle-closed'));
                                    } else {
                                        TOGGOPENER.text(TOGGOPENER.attr('data-toggle-opened'));

                                    }
                                }

                                // BIND ////////////////////////
                                TOGGOPENER.click(function() {


                                    if(!vxcp_empty(TOGGNAME)){
                                        var THISCONTENTS = $('div[data-toggle-name='+ TOGGNAME +']').not('.vxcp_toggle');

                                        if(THISCONTENTS.length >= 1){

                                            var firstContainer = THISCONTENTS.eq(0);

                                            if(firstContainer.is(':hidden')){
                                                //aufgeklappt
                                                THISCONTENTS.slideDown(200).attr('data-toggle-status', 'on');
                                                TOGGOPENER.attr('data-toggle-status', 'on');
                                            } else {
                                                THISCONTENTS.slideUp(200).attr('data-toggle-status', 'off');
                                                TOGGOPENER.attr('data-toggle-status', 'off');
                                            }

                                            if(
                                                !vxcp_empty(TOGGOPENER.attr('data-toggle-opened')) &&
                                                !vxcp_empty(TOGGOPENER.attr('data-toggle-closed'))
                                            ){

                                                if(TOGGOPENER.attr('data-toggle-status') == 'off'){
                                                    //aufgeklappt
                                                    TOGGOPENER.text(TOGGOPENER.attr('data-toggle-closed'));
                                                } else {
                                                    TOGGOPENER.text(TOGGOPENER.attr('data-toggle-opened'));

                                                }
                                            }

                                        }
                                    }

                                });



                        }

                }
            }

    }


/*#######################################################################*/





    $.fn.vxcp_eInfo = function(text, status) {

        var targetElem = this;



        if(typeof targetElem.attr('data-einfo-id') === 'undefined'){
            var uniq = Math.random().toString(16).slice(2);
            targetElem.attr('data-einfo-id', uniq);
        }else{
            var uniq = targetElem.attr('data-einfo-id');
        }


        if($('body').children('#vxcp_einfo_container').length != 1){
           $('#vxcp_einfo_container').remove();
           $('body').append('<div id="vxcp_einfo_container" class="vxcp"></div>');
        }

        var eInfoContainer = $('body').children('#vxcp_einfo_container');

        if($('div.vxcp_einfo[data-einfo-id="'+uniq+'"]').length != 0){
           $('div.vxcp_einfo[data-einfo-id="'+uniq+'"]').remove();
        }

        eInfoContainer.append('<div class="vxcp_einfo boru" data-einfo-id="'+uniq+'">'+text+'</div>');

        var statusClass = 'default';
        if( typeof status !== 'undefinded'){
            if(status == 'success' || status == 'error'){
                statusClass = status;
            }
        }

        var eInfoElem = eInfoContainer.children('.boru');
        eInfoElem.addClass('vxcp_einfo_'+statusClass).removeClass('boru');
        targetElem.vxcp_eInfo_positioning(eInfoElem);

        setTimeout(function(){
            // mach nach 2200ms die schließanimationsklasse hinzu
            eInfoElem.addClass('vxcp_einfo_goingclose');
            setTimeout(function(){
                 // mach nach 800ms das element komplett weg
                eInfoElem.remove();
            }, 800);
        }, 2200);

        $(window).resize(function() {
            setTimeout(function(){
                targetElem.vxcp_eInfo_positioning(eInfoElem);
            }, 50);
        });
        return this;
    }


    $.fn.vxcp_eInfo_positioning = function(eInfoElem) {

        var targetElem     = this;
        var position       = targetElem.offset();
        var left           = 0;
        var top            = 0;
        var additinalSpace = 16;

        eInfoElem.css('display', 'none');

        if(targetElem.is(':visible')){

            var windowWidth = parseInt($(window).width());
            var targetElemWidth = parseInt(targetElem.outerWidth()) ;
            var targetElemHeight = parseInt(targetElem.outerHeight()) ;


            if(targetElemWidth + 400 > windowWidth){
                //zu wenig platz im layout... mach ein tooltip der sich DRUNTER legt (nicht seitlich)
                side = 'bottom';
                left = parseInt(position.left) ;
                top = parseInt(position.top) + targetElemHeight + additinalSpace;

            } else {
                // links rechts platzierung weil mehr als window 400px mehr platz als input

                var side = 'right';
                left = parseInt(position.left) + targetElemWidth + additinalSpace;

                if(targetElemHeight < 22){
                    top = parseInt(position.top) - 4 ;
                }else{
                    top = parseInt(position.top) ;
                }

            }

            eInfoElem.removeClass('vxcp_einfo_right-sided vxcp_einfo_bottom-sided vxcp_einfo_top-sided vxcp_einfo_left-sided');
            eInfoElem.addClass('vxcp_einfo_'+side+'-sided');
            eInfoElem.css({
                "display": "block",
                "left": parseInt(left)+"px",
                "top": parseInt(top)+"px"
                });

        } else {
         //   alert('nicht sichtbar'+eInfoElem.html());

        }

        return this;
    }





    $.fn.vxcp_tab_connect = function() {

    /*
        <div class="vxcp_tab">
            <ul class="vxcp_tab-bar">
                <li class="vxcp_active"><a href="#reiter1">Reiter 1</a></li>
                <li><a href="#reiter2">Reiter 2</a></li>
                <li><a href="#reiter3">Reiter 3</a></li>
            </ul>
            <div data-tab-content-name="reiter1">
                Inhalt Reiter 1
            </div>
            <div data-tab-content-name="reiter2">
                Inhalt Reiter 2
            </div>
            <div data-tab-content-name="reiter3">
                Inhalt Reiter 3
            </div>
        </div>

    */



        var tabContainer = this;

        if(tabContainer.find('ul.vxcp_tab-bar').length == 1 && tabContainer.find('[data-tab-content-name]').length >= 1){


            var thisUlBar = tabContainer.find('ul.vxcp_tab-bar');


            /*TAB AKTIVEIEREN WENN LI AKTIVE WAR ODER EIN ANKER VORHANDEN*/

            onLoadAname = false;

            if(thisUlBar.find('li.vxcp_active a').length == 1){
               //wenn aktiver reiter durch klasse
               onLoadAname = thisUlBar.find('li.vxcp_active a:eq(0)').attr('href').split('#')[1];
               thisUlBar.attr('data-default-tab', onLoadAname);
            }

            if(!vxcp_empty(window.location.hash.substring(1))){
                var AnchorName = window.location.hash.substring(1);
              //anchor without the # character
                if(thisUlBar.find('a[href="#'+AnchorName+'"]').length == 1){
                    onLoadAname = AnchorName;
                }
            }



            if(!vxcp_empty(onLoadAname)){
                /*TAB AKTIVEIEREN WENN LI AKTIVE WAR ODER EIN ANKER VORHANDEN*/
                tabContainer.find('[data-tab-content-name]').each(function() {

                        var thisContent = $(this);

                        if(thisContent.is('[data-tab-content-name="'+onLoadAname+'"]')){
                            thisContent.addClass('vxcp_active');

                        }else {
                            thisContent.removeClass('vxcp_active');
                        }

                });


            }


            thisUlBar.children('li').each(function() {

                    var iAname = $(this).find('a:eq(0)').attr('href').split('#')[1];
                    $(this).vxcp_tabLi_connect();

                    if(!vxcp_empty(onLoadAname) && iAname == onLoadAname){
                            /*TAB AKTIVEIEREN WENN LI AKTIVE WAR ODER EIN ANKER VORHANDEN*/
                            $(this).addClass('vxcp_active');
                    } else if (!vxcp_empty(onLoadAname)) {
                            /*TAB AKTIVEIEREN WENN LI AKTIVE WAR ODER EIN ANKER VORHANDEN*/
                            $(this).removeClass('vxcp_active');
                    }
            });

            onLoadAname = false;

        }


        return this;
    }





    $.fn.vxcp_tabLi_connect = function() {


            this.children('a').click(function() {

                var thisAName    = $(this).attr('href').split('#')[1];
                var thisLi       = $(this).closest('li');
                var tabContainer = thisLi.closest('.vxcp_tab');
                var thisUlBar    = tabContainer.find('ul.vxcp_tab-bar');


                thisUlBar.children('li').each(function() {
                        var IIlI = $(this);

                        if(IIlI.is(thisLi)){
                            IIlI.addClass('vxcp_active');
                        }else {
                            IIlI.removeClass('vxcp_active');
                        }
                });


                tabContainer.find('[data-tab-content-name]').each(function() {

                        var thisContent = $(this);

                        if(thisContent.is('[data-tab-content-name="'+thisAName+'"]')){
                            thisContent.addClass('vxcp_active');

                        }else {
                            thisContent.removeClass('vxcp_active');
                        }

                });


            });

    }


    $.fn.vxcp_tabOpener_connect = function() {

        var thisLink = this;
        thisLink.click(function() {
            var thisAName = $(this).attr('href').split('#')[1];
            $('ul.vxcp_tab-bar > li a[href="#'+thisAName+'"]').trigger('click').vxcp_scrollto(80);
        });
        return this;
    }



})(vxcp_jQuery);

function vxcp_empty(str) {
	if(str == '' ||  str == 'NaN' || str == 'undefined' || str == null){
		return true;
	}else {
		return false;
	}
}

function vxcp_tabAndContentShow(thisAName){
    (function($){
        if(!vxcp_empty(thisAName)){

            if($('ul.vxcp_tab-bar').find('a[href="#'+thisAName+'"]').length == 1){

                    var thisA        = $('ul.vxcp_tab-bar').find('a[href="#'+thisAName+'"]');
                    var tabContainer = thisA.closest('.vxcp_tab');
                    var thisLi       = thisA.closest('li');
                    var thisUlBar    = tabContainer.find('ul.vxcp_tab-bar');

                    thisUlBar.children('li').each(function() {
                            var IIlI = $(this);
                            if(IIlI.is(thisLi)){
                                IIlI.addClass('vxcp_active');
                            }else {
                                IIlI.removeClass('vxcp_active');
                            }
                    });


                    tabContainer.find('[data-tab-content-name]').each(function() {
                            var thisContent = $(this);
                            if(thisContent.is('[data-tab-content-name="'+thisAName+'"]')){
                                thisContent.addClass('vxcp_active');
                            }else {
                                thisContent.removeClass('vxcp_active');
                            }
                    });

            }
        }
    })(vxcp_jQuery);
}



(function($){



    ///////////////// ALL CONNECT
    ///////////////// ALL CONNECT
    ///////////////// ALL CONNECT

    $.fn.vxcp_master_connect = function() {

            var thisOb = this;


            thisOb.find('div.vxcp_tab').each(function() {
                $(this).vxcp_tab_connect();
            });

			thisOb.find('.vxcp_toggle').each(function() {
                $(this).vxcp_toggle_connect();
            });

    };



    $(document).ready(function() {

        vxcp_siteHtml  = $('html').eq(0);
        vxcp_siteBody  = vxcp_siteHtml.find('body').eq(0);
        vxcp_siteBody.vxcp_master_connect();


    });






})(vxcp_jQuery);