//保存验证对像的所有属性
var jQuery_Validator_initConfig = [];
(function($) {
    $.validator =
    {
        initConfig: function(controlOptions) {
            var settings =
		    {
		        debug: false,
		        validatorGroup: "YK_VALIDATOR",
		        alertMessage: false,            //是否显示提示对话框
		        showMessage: true,               //是否显示错误信息
		        showValid: true,                //显示的时候是否就进行验证
		        validObjects: [],               //验证对像组
		        errorList: [],                   //验证不通过列表
		        validList: [],                   //验证成功的列表
		        onSuccess: function() { return true; },     //验证成功时执行    在这里控制成功后是true 还是 false
		        onError: function() { },                    //验证失败时执行
		        form: "",                                 //验证对像父级对像
		        errorFocus: true                           //出错是否自动跳到第一个出错对像
		    };
            $.extend(true, settings, controlOptions);
            jQuery_Validator_initConfig.push(settings);


            //绑定执行优先
            //找出当前form中的提交按钮，
            //var submits = $(settings.form).find("[type=submit]").not("[validatorgroup]");
            var submits = $(settings.form).find("[type=submit]");
            for (var i = 0; i <= submits.length - 1; i++) {
                var item = submits[i];
                //取得这个按钮的点击事件保存存来
                var fun = item.onclick;
                item.onclick = function() {
                    //进行验证
                    //判断当前验证的组
                    var group = "YK_VALIDATOR";
                    if (typeof ($(this).attr("validatorgroup")) != "undefined" && $(this).attr("validatorgroup") != "") {
                        group = $(this).attr("validatorgroup");
                    }
                    if ($.validator.valid(group) == false) {
                        return false;
                    }
                    if (typeof (fun) != "undefined") {
                        //现在这里只满足了一个提交按钮的方式
                        fun.call(this); //这里要问当为别的参数要如何进行传参呢？？？？？？？？？？？？？？？？？
                    }
                };
            };

            //后面这些其他按钮以后再解决
            //这里可能会出现浏览器兼容的问题
            //查看form中的取他按钮
            //var buttons = $().find("[validatorgroup=''],[validatorgroup][validatorgroup!='']");
            var buttons = $(settings.form).find("[validatorgroup=''],[validatorgroup][validatorgroup!='']").not("[type=submit]");
            for (var i = 0; i <= buttons.length - 1; i++) {
                var item = buttons[i];
                //取得这个按钮的点击事件保存存来
                var fun = item.onclick;
                item.onclick = function() {
                    //进行验证
                    //判断当前验证的组
                    var group = "YK_VALIDATOR";
                    //如果只声明的validatorgroup没有给值的话，那么为默认验证组
                    if (typeof ($(this).attr("validatorgroup")) != "undefined" && $(this).attr("validatorgroup") != "") {
                        group = $(this).attr("validatorgroup");
                    }
                    if ($.validator.valid(group) == false) {
                        return false;
                    }
                    if (typeof (fun) != "undefined") {
                        fun.call(this);
                    }
                };
            };
        },

        //如果validator对象对应的element对象的validator属性追加要进行的校验。
        //取得当前验证组的基本设置
        getInitConfig: function(validatorgroup) {
            if (jQuery_Validator_initConfig != null) {
                for (i = 0; i < jQuery_Validator_initConfig.length; i++) {
                    //判断目标验证是否包括了当前组
                    if (this.hasGroup(jQuery_Validator_initConfig[i], validatorgroup)) {
                        return jQuery_Validator_initConfig[i];
                    }
                }
            }
            return null;
        },

        //设置配置信息
        setInitConfig: function(settings, validatorgroup) {
            if (jQuery_Validator_initConfig != null) {
                for (i = 0; i < jQuery_Validator_initConfig.length; i++) {
                    //判断目标验证是否包括了当前组
                    if (this.hasGroup(jQuery_Validator_initConfig[i], validatorgroup)) {
                        jQuery_Validator_initConfig[i] = settings;
                        break;
                    }
                }
            }
        },

        //给验证对像添加组
        addGroup: function(elem, validatorgroups) {
            jQuery.each((validatorgroups || "").split(/\s+/), function(i, validatorgroup) {
                if (!this.hasGroup(elem, validatorgroup)) {
                    elem.validatorGroup += (elem.validatorGroup ? " " : "") + validatorgroup;
                }
            });
        },

        //移除验证对像的相应组
        removeGroup: function(elem, validatorgroups) {
            var reg = validatorgroups.split(" ").join("|");
            elem.validatorGroup = elem.validatorGroup.replace(new RegExp(reg, "gi", ""));
        },

        //判断验证对像是否包含了相应组
        hasGroup: function(elem, validatorgroup) {
            return elem && jQuery.inArray(validatorgroup, (elem.validatorGroup).toString().split(/\s+/)) > -1;
        },

        //为指定的组添加已有的验证控件，selector为指定的在定义时的 搜索标示
        addValid: function(selector, tagretValidatorGroup, validatorgroup) {
            if (typeof (validatorgroup) == "undefined") {
                //如果没有定义指定到哪一个组的话为默认组
                validatorgroup = "YK_VALIDATOR";
            };

            //添加
            if (typeof (tagretValidatorGroup) != "undefined") {
                //取出要进行添加验证的组
                var initConfig = $.validator.getInitConfig(validatorgroup);
                //判断是否包含了当前这个验证，如果有移除原有的验证
                initConfig = this.removeValid(selector, validatorgroup);
                var initConfigTarget = $.validator.getInitConfig(tagretValidatorGroup);
//                for (item in initConfigTarget.validObjects) {
                for (var i = 0; i <= initConfigTarget.validObjects.length - 1; i++) {
                    var item = initConfigTarget.validObjects[i];
                    if (item.selector == selector) {
                        item.validator.enable = true;
                        initConfig.validObjects.push(item);
                        break;
                    }
                }
            }
            var oo = "";
            //保存请的设置
            this.setInitConfig(initConfig, validatorgroup);
            return initConfig;
        },

        removeValid: function(selector, validatorgroup) {
            if (typeof (validatorgroup) == "undefined") {
                //如果没有定义指定到哪一个组的话为默认组
                validatorgroup = "YK_VALIDATOR";
            };
            //取出要进行删除验证的组
            var initConfig = $.validator.getInitConfig(validatorgroup);

            for (i in initConfig.validObjects) {
                var item = initConfig.validObjects[i];
                if (item.selector == selector) {
                    initConfig.validObjects.splice(i, 1);
                }
            }
            //保存请的设置
            this.setInitConfig(initConfig, validatorgroup);
            return initConfig;
        },        

        itemValid: function(selector, validatorgroup) {
            if (typeof (validatorgroup) == "undefined") {
                //如果没有定义指定到哪一个组的话为默认组
                validatorgroup = "YK_VALIDATOR";
            };
            //取出要进行删除验证的组
            var initConfig = $.validator.getInitConfig(validatorgroup);
            var item = null;
            for (i in initConfig.validObjects) {
                item = initConfig.validObjects[i];
                if (item.selector == selector) {
                    break;
                }
            }
            if(item!=null)
            {
            this.blurValid(item);
            }
        },

        addMethod: function(selector, rule, validatorgroup) {
            if (typeof (validatorgroup) == "undefined") {
                //如果没有定义指定到哪一个组的话为默认组
                validatorgroup = "YK_VALIDATOR";
            };
            //选删除原有的再添加
            this.removeMethod(selector, rule, validatorgroup);
            //添加这个验证方法
            var initConfig = $.validator.getInitConfig(validatorgroup);
            for (i in initConfig.validObjects) {
                var item = initConfig.validObjects[i];
                if (item.selector == selector) {
                    //合关这个方法
                    $.extend(true, initConfig.validObjects[i].validator, rule);
                }
            }
            //保存请的设置
            this.setInitConfig(initConfig, validatorgroup);
            return initConfig;
        },

        //删除验证方法
        removeMethod: function(selector, rule, validatorgroup) {
            if (typeof (validatorgroup) == "undefined") {
                //如果没有定义指定到哪一个组的话为默认组
                validatorgroup = "YK_VALIDATOR";
            };

            //取出要进行删除验证的组
            var initConfig = $.validator.getInitConfig(validatorgroup);
            for (i in initConfig.validObjects) {
                var item = initConfig.validObjects[i];
                if (item.selector == selector) {
                    //删除这个
                    if (typeof (initConfig.validObjects[i].validator.rules[rule]) != "undefined") {
                        delete initConfig.validObjects[i].validator.rules[rule];
                    }
                    if (typeof (initConfig.validObjects[i].validator.message[rule]) != "undefined") {
                        delete initConfig.validObjects[i].validator.message[rule];
                    }
                    if (typeof (initConfig.validObjects[i].validator.messageAlert[rule]) != "undefined") {
                        delete initConfig.validObjects[i].validator.messageAlert[rule];
                    }
                }
            }
            //保存请的设置
            this.setInitConfig(initConfig, validatorgroup);
            return initConfig;
        },

        //验证相应组
        valid: function(validatorgroup, onlyvalid) {
            //声明返回数据
            var isValid = false;
            if (typeof (validatorgroup) == "undefined") {
                validatorgroup = "YK_VALIDATOR";
            }
            //取出验证配置文件
            var initConfig = $.validator.getInitConfig(validatorgroup);
            if (initConfig == null) {
                //当找不到当前配置的时候默认为验证通过
                return true;
            }
            initConfig.errorList = [];                   //验证不通过列表
            initConfig.validList = [];                   //验证成功的列表
            //取出当前配置里面的所有验证对像
            var oo = initConfig.validObjects.length;
            $.map(initConfig.validObjects, function(elem) {
                if (elem.validator.enable == true) {
                    //当要进行验证的时候
                    var returnObj = $.validator.blurValid(elem);
                    //根据验证结果处理
                    if (returnObj.isValid == true) {
                        initConfig.validList.push(returnObj);
                    }
                    else {
                        initConfig.errorList.push(returnObj);
                    }
                }
            });
            //不执行结果只验证
            if (typeof (onlyvalid) != "undefined" && onlyvalid == true) {
                return isValid;
            }

            //返回结果
            if (initConfig.errorList.length > 0) {
                //出错了，执行用户自定义方法
                initConfig.onError();
                //判断是否显示出错提示框
                if (initConfig.alertMessage == true) {
                    var alertMessage = "";
                    for (errorItem in initConfig.errorList) {
                        if (typeof (initConfig.errorList[errorItem].messageAlert) != "undefined") {
                            if (alertMessage == "") {
                                alertMessage += "_" + initConfig.errorList[errorItem].messageAlert;
                            }
                            else {
                                alertMessage += "\r\n_" + initConfig.errorList[errorItem].messageAlert;
                            }
                        }
                    }
                    alert(alertMessage);
                }
                //判断是否要返回第一个焦点
                if (initConfig.errorFocus) {
                    if(initConfig.errorList[0].target.validator != null 
                        && initConfig.errorList[0].target.validator.targetFocus !=null)
                    {
                        $(initConfig.errorList[0].target.validator.targetFocus).focus();
                    }
                    else
                    {
                        initConfig.errorList[0].target.focus();
                    }
                }
            }
            else {
                //验证成功，执行用户自定义方法
                isValid = initConfig.onSuccess();
            }
            return isValid;
        },

        focusValid: function(elem) {
            //返回验证结果
            var returnObj = $.validator.oneIsValid(elem);
            if (returnObj.isValid == false) {
                //验证出错显示提示信息
                $.validator.setClass(elem, "focus", returnObj);
            }
            else {
                //验证成功显示成功信息
                $.validator.setClass(elem, "valid", returnObj);
            }
            return returnObj;
        },

        blurValid: function(elem) {
            //返回验证结果
            var returnObj = this.oneIsValid(elem);
            if (returnObj.isValid == false) {
                //验证出错显示错误信息
                $.validator.setClass(elem, "error", returnObj);
            }
            else {
                //验证成功显示成功信息
                $.validator.setClass(elem, "valid", returnObj);
            }
            return returnObj;
        },

        showValid: function(elem) {
            //返回验证结果
            var returnObj = this.oneIsValid(elem);
            if (returnObj.isValid == false) {
                //验证出错显示错误信息
                //$.validator.setClass(elem, "error", returnObj);
            }
            else {
                //验证成功显示成功信息
                $.validator.setClass(elem, "valid", returnObj);
            }
            return returnObj;
        },

        //添加错误信息提示和验证目标样式
        setClass: function(elem, type, returnObj) {
            var initConfig = $.validator.getInitConfig(elem.validator.validatorgroup);
            //添加样式
            switch (type) {
                case "focus":
                    if (!elem.validator.tag.hasClass(elem.validator.classFocus)) {
                        //移除外部没用的Display
                        $(elem.validator.tag).css("display", "");
                        //取出设置的样式
                        var remove = elem.validator.classShow + " " + elem.validator.classFocus + " " + elem.validator.classError + " " + elem.validator.classValid + " " + elem.validator.classAjax;
                        //删除样式
                        $(elem).removeClass(remove);
                        $(elem).addClass(elem.validator.classFocus);
                        //是否显示出错信息
                        //                        if (initConfig.showMessage == true) {
                        elem.validator.tag.removeClass(remove);
                        //判断如果没有显示文字的话不显示
                        if (elem.validator.messageFocus == "") {
                            elem.validator.tag.html("");
                        }
                        else {
                            elem.validator.tag.addClass(elem.validator.classFocus); //.hide().fadeIn().css("display", "inline");
                            elem.validator.tag.html(elem.validator.messageFocus);
                        }
                        //                        }
                    }
                    break;
                case "error":
                    //取出设置的样式
                    //移除外部没用的Display                    
                    $(elem.validator.tag).css("display", "");
                    var remove = elem.validator.classShow + " " + elem.validator.classFocus + " " + elem.validator.classError + " " + elem.validator.classValid + " " + elem.validator.classAjax;
                    //删除样式
                    $(elem).removeClass(remove);
                    elem.validator.tag.removeClass(remove);
                    $(elem).addClass(elem.validator.classError);
                    elem.validator.tag.addClass(elem.validator.classError); //.hide().fadeIn().css("display", "inline");
                    //elem.validator.tag.html(returnObj.message);
                    //这里在这个项目中不显示出错信息，把出错信息显示在onFocus上面
                    elem.validator.tag.html("");
                    elem.validator.messageFocus = returnObj.message;
                    break;
                case "valid":
                    if (!elem.validator.tag.hasClass(elem.validator.classValid)) {
                        //移除外部没用的Display
                        $(elem.validator.tag).css("display", "");
                        //取出设置的样式
                        var remove = elem.validator.classShow + " " + elem.validator.classFocus + " " + elem.validator.classError + " " + elem.validator.classValid + " " + elem.validator.classAjax;
                        //删除样式
                        $(elem).removeClass(remove);
                        elem.validator.tag.removeClass(remove);
                        $(elem).addClass(elem.validator.classValid);
                        elem.validator.tag.addClass(elem.validator.classValid); //.hide().fadeIn().css("display", "inline");
                        elem.validator.tag.html(elem.validator.messageValid);
                    }
                    break;
                case "ajax":
                    //移除外部没用的Display
                    $(elem.validator.tag).css("display", "");
                    //取出设置的样式 如果没有的话就直接这一个 returnObj 的性性变为 classAjax ,messageAjax
                    var remove = elem.validator.classShow + " " + elem.validator.classFocus + " " + elem.validator.classError + " " + elem.validator.classValid + " " + elem.validator.classAjax;
                    //删除样式
                    $(elem).removeClass(remove);
                    elem.validator.tag.removeClass(remove);
                    $(elem).addClass(returnObj.classAjax);
                    elem.validator.tag.addClass(returnObj.classAjax); //.hide().fadeIn().css("display", "inline");
                    elem.validator.tag.html(returnObj.messageAjax);
                    break;
            }

        },

        //获取指定字符串的长度
        getLength: function(elem) {
            var sType = elem.get(0).type;
            var len = 0;
            switch (sType) {
                case "text":
                case "hidden":
                case "password":
                case "textarea":
                case "file":
                    var val = elem.val();
                    if (elem.validator.wideWord == true) {
                        for (var i = 0; i < val.length; i++) {
                            if (val.charCodeAt(i) >= 0x4e00 && val.charCodeAt(i) <= 0x9fa5) {
                                len += 2;
                            } else {
                                len++;
                            }
                        }
                    }
                    else {
                        len = val.length;
                    }
                    break;
                case "checkbox":
                case "radio":
                    $.map(elem, function(item) {
                        if (item.checked == true) {
                            len++;
                        }
                    });
                    break;
                case "select-one":
                    //返回-1不进行处理
                    len = elem.find("option[selected]").length;
                    break;
                case "select-multiple":
                    len = elem.find("option[selected]").length;
                    break;
            }
            return len;
        },


        //取对像的指定错误信息
        getMessage: function(returnObj, elem) {
            //设置验证出错
            returnObj.isValid = false;
            //取出错误显示信息
            if (typeof (elem.validator.message) == "string") {
                //当直接定义了错误信息的话取这个显示信息
                returnObj.message = elem.validator.message;
            }
            else if (typeof (elem.validator.message[returnObj.rule]) == "string") {
                //当有特定的验证显示的话取这个显示信息
                returnObj.message = elem.validator.message[returnObj.rule];
            }
            else {
                //当有特定的验证显示，但没有给当前验证学科加显示的时候，取第一个显示
                for (var item in elem.validator.message) {
                    returnObj.message = elem.validator.message[item];
                    break;
                }
            }
            //取出错误提示信息
            if (typeof (elem.validator.messageAlert) == "string") {
                //当直接定义了错误信息的话取这个提示信息
                returnObj.messageAlert = elem.validator.messageAlert;
            }
            else if (typeof (elem.validator.messageAlert[returnObj.rule]) != "undefined") {
                //当有特定的验证提示的话取这个提示信息
                returnObj.messageAlert = elem.validator.messageAlert[returnObj.rule];
            }
            else {
                //当有特定的验证提示，但没有给当前验证学科加提示的时候，取第一个提示
                for (item in elem.validator.messageAlert) {
                    returnObj.messageAlert = elem.validator.messageAlert[item];
                    break;
                }
                //当提取不到提示的时候，赋值为显示的信息
                if (returnObj.messageAlert == "") {
                    returnObj.messageAlert = returnObj.message;
                }
            }
            return returnObj;
        },

        //对单个对像进行验证
        oneIsValid: function(elem) {
            //返回的对像
            var returnObj = new Object();
            returnObj.isValid = true;  //默认通过
            returnObj.target = elem;
            returnObj.rule = "";            //出错学科
            returnObj.message = "";         //出错显示
            returnObj.messageAlert = "";    //出错提示

            //这里进行验证 //验证对像是否通过
            for (rule in elem.validator.rules) {
                switch (rule) {
                    case "required":
                        //验证不能为空
                        var val = elem.val();
                        //判断是否有初始值
                        if (elem.validator.rules[rule] != null) {
                            //说明有特定的空值
                            if (val == elem.validator.rules[rule]) {
                                returnObj.isValid = false;
                                returnObj.rule = rule;
                            }
                        }
                        else {
                            //当没有特定的空值时判断是否为空
                            if (val.length == 0) {
                                returnObj.isValid = false;
                                returnObj.rule = rule;
                            }
                        }
                        break;
                    case "min":
                        var len = this.getLength(elem);
                        //最小长度
                        if (elem.validator.rules[rule] > len) {
                            returnObj.isValid = false;
                            returnObj.rule = rule;
                        }
                        break;
                    case "max":
                        var len = this.getLength(elem);
                        //最大长度
                        if (elem.validator.rules[rule] < len) {
                            returnObj.isValid = false;
                            returnObj.rule = rule;
                        }
                        break;
                    case "equalTo":
                        //当为对比的时候
                        //取出当前控件的值
                        var val = elem.val();
                        //声明对比对像,操作符 数据学科（默认为字符型）
                        var equaTo, operate, dataType;
                        //找出对比符号
                        if (typeof (elem.validator.rules[rule]) == "string") {
                            //当为字符的时候，对比对像就为内容，操作符为 ==
                            equaTo = elem.validator.rules[rule];
                            operate = "==";
                            dataType = "string";
                        }
                        else {
                            //如果不是的话，那就取他的下级 target 为对比对像  operate 为操作符 dataType为数据学科
                            equaTo = elem.validator.rules[rule]["target"];
                            operate = "==";
                            dataType = "string";
                            if (typeof (elem.validator.rules[rule]["operate"]) != "undefined") {
                                operate = elem.validator.rules[rule]["operate"];
                            }
                            if (typeof (elem.validator.rules[rule]["dataType"]) != "undefined") {
                                dataType = elem.validator.rules[rule]["dataType"];
                            }
                        }
                        //那么先查出对比的对像的值
                        var equaVal = $(equaTo).val();
                        //判断比较学科是string 还是 number
                        //生成表达式值
                        switch (dataType) {
                            case "string":
                                break;
                            case "number":
                                val = parseFloat(val);
                                equaVal = parseFloat(equaVal);
                                break;
                            case "date":
                                val = new Date(val);
                                equaVal = new Date(equaVal);
                                break;
                        }
                        //根据表达式取得是否为 true
                        switch (operate) {
                            case "==":
                                if (!(val == equaVal)) { returnObj.isValid = false; returnObj.rule = rule; }
                                break;
                            case "!=":
                                if (!(val != equaVal)) { returnObj.isValid = false; returnObj.rule = rule; }
                                break;
                            case ">":
                                if (!(val > equaVal)) { returnObj.isValid = false; returnObj.rule = rule; }
                                break;
                            case ">=":
                                if (!(val >= equaVal)) { returnObj.isValid = false; returnObj.rule = rule; }
                                break;
                            case "<":
                                if (!(val < equaVal)) { returnObj.isValid = false; returnObj.rule = rule; }
                                break;
                            case "<=":
                                if (!(val <= equaVal)) { returnObj.isValid = false; returnObj.rule = rule; }
                                break;
                        }
                        break;
                    case "regex":
                        //正则表达式验证
                        //如果是正则表达式验证的话，当目标的内容为“”空的时候不进行验证，因为验证是否为空是由required来进行
                        if (elem.val() != "") {
                            //首先取得是否为在定义中了的正则表达式
                            var regexpress;
                            try {
                                var regexpress = eval("jQuery_Validator_RegexEnum." + elem.validator.rules[rule]);
                            } catch (ex) { };
                            if (typeof (regexpress) == "undefined") {
                                //如果没有的话那么就取传入自定义的
                                regexpress = elem.validator.rules[rule];
                            }
                            var reg = new RegExp(regexpress)
                            if (!reg.test(elem.val())) {
                                returnObj.isValid = false;
                                returnObj.rule = rule;
                            }
                        }
                        break;
                    case "ajax":
                        //ajax验证，
                        //道先取得当前显示对像的CSS
                        var tipClass = elem.validator.tag.attr("className");
                        var tipHtml = elem.validator.tag.html();
                        //给tag添加classAjax样式                        
                        this.setClass(elem, "ajax", { classAjax: elem.validator.classAjax, messageAjax: elem.validator.messageAjax });
                        //声明ajax内容
                        //jQuery_Validator_Ajax_URL = elem.validator.rules[rule]["url"];
                        var beforeFun = elem.validator.rules[rule];
                        var ajaxURL = beforeFun();

                        //先默认是验证失败
                        returnObj.isValid = false;
                        returnObj.rule = rule;
                        $.ajax(
                        {
                            cache: false,
                            async: false,
                            dataType: 'html',
                            url: ajaxURL,
                            error: function(XMLHttpRequest, textStatus, errorThrown) {
                                var message = XMLHttpRequest.responseText;
                                alert("远程数据出错");
                            },
                            success: function(result) {
                                if (result == "1") {
                                    returnObj.isValid = true;
                                    returnObj.rule = "";
                                }
                            }
                        });
                        //ajax完成返还样式和内容
                        this.setClass(elem, "ajax", { classAjax: tipClass, messageAjax: tipHtml });

                }
                //当验证有出错的时候就不再进行出错验证直接返回
                if (returnObj.isValid == false) {
                    return this.getMessage(returnObj, elem, rule);
                    break;
                }
            }
            return returnObj;
        }
    };

    //每个校验控件必须初始化的
    $.fn.formValidator = function(controlOptions) {
        var setting =
	    {
	        validatorGroup: "YK_VALIDATOR",         //默认的验证组，多个验证组的话用空格分开
	        enable: true,                            //是否要进行验证
	        wideWord: false,                       //中文是否占两个长度
	        targetOutside: false,            //验证出错显示对像是否在form外面
	        targetTag: "",                   //验证出错显示对像
            targetFocus: null,
	        rules: {},               //验证集内容
	        message: {},            //出错显示的对像集json
	        messageAlert: {},        //出错提示的对像集json
	        messageShow: "",               //验证控件默认显示的内容
	        messageFocus: "",              //当焦点的时候提示的文字
	        messageValid: "",              //当验证成功时提示的文字
	        messageAjax: "正在验证数据,请稍候...",              //当AJAX时提示的文字
	        classShow: "onShow",                //默认显示的CSS
	        classFocus: "onFocus",      //验证焦点的时候样式
	        classError: "onError",       //出错提示样式
	        classValid: "onValid",            //验证通过目标样式
	        classAjax: "onLoad"            //AJAX取信息目标样式
	    };

        //获取该校验组的全局配置信息
        controlOptions = controlOptions || {};
        //验证的组必须要有
        if (typeof (controlOptions.validatorGroup) == "undefined") {
            controlOptions.validatorGroup = "YK_VALIDATOR";
        };
        var initConfig = $.validator.getInitConfig(controlOptions.validatorGroup);
        //先合并整个配置(深度拷贝)
        $.extend(true, setting, controlOptions);

        //现在开始添加操作
        //取得当前组form对像 取第一个
        var form = $(initConfig.form);
        //取得显示对像
        var tag = null;
        if (setting.targetOutside == true) {
            //如果显示的出错信息在外部的话取他的对像
            tag = $(setting.targetTag);
        }
        else {
            //不然的话显示出错对像为当前的name+tip 取第一个，因为显示对像只会有一个
            if (this.length == 0) {
                alert(this.selector + " undefined");
            }
            var expression = "[for='" + this.get(0).name + "'][lang='tip']";
            tag = form.find(expression);
        }
        //将验证内容保存到验证对像中
        this.validator = setting;
        //将显示验证对像赋值给验证对像
        this.validator.tag = tag;
        //将验证对像存放到validObjects中
        initConfig.validObjects.push(this);
        //开始进行赋值
        if (setting.messageShow != "") {
            tag.html(setting.messageShow);
        }
        //添加CSS样式
        tag.addClass(setting.classShow);

        //判断是否显示验证
        if (initConfig.showValid == true) {
            $.validator.showValid(this);
        }

        var elem = this;
        var srcTag = this.get(0).tagName.toLowerCase();
        var stype = this.get(0).type;

        if (srcTag == "input" || srcTag == "textarea" || srcTag == "select") {
            //添加focus事件
            this.bind("focus", function() {
                //执行验证
                $.validator.focusValid(elem);
            });
            if (setting.targetFocus != null && setting.targetFocus.length > 0)
            {
                $(setting.targetFocus).bind("focus", function () {
                    //执行验证
                    $.validator.focusValid(elem);
                });
            }
            //失去焦点
            this.bind("blur", function() {
                //执行验证
                $.validator.blurValid(elem);
            });
            if (setting.targetFocus != null && setting.targetFocus.length > 0) {
                $(setting.targetFocus).bind("blur", function () {
                    //执行验证
                    $.validator.blurValid(elem);
                });
            }
            //当为checkbox的时候添加onchange事件
            if (stype == "checkbox" || srcTag == "select") {
                this.bind("change", function() {
                    elem.trigger("focus");
                });
            }
        };
    };
})(jQuery);