var add_special_text = '';
var vd_required_field = 1; // fieldas yra privalomas
var vd_not_required_if_empty = 0; // fieldas nera privalomas, jei tuscias, bet jei uzpildytas tai tikrinam
var vd_special_error = 0; //jeigu yra ivedami kokie nors patobulinimai jie kreipiasi i si erora

//begin validator functions

/******************************************************************************
 * function:  VDFormValidate
 * author: tmv
 * date: 2004.05.12
 * parameters:
 * error_string - turimu klaidu stringas
 * form_name -  formos vardas, reikalingas jeigu norima submitinti forma jeigu erroru nera
 * submit_btn_id - mygtuko vardas kuri reikia disablinti kai forma yra submitinama
 * paskirtis: Patikrinti ar yra erroru, jei nera submitinti forma arba grazinti true, o jei yra erroru isvesti alerta
 * Formatas:
 *****************************************************************************/
function VDFormValidate(error_string, form_name, submit_btn_id) {
    if(error_string == '') {
        if(form_name != undefined && form_name != '') {
            if(submit_btn_id != undefined && document.getElementById(submit_btn_id) != null)
                document.getElementById(submit_btn_id).disabled = true;
            document.getElementById(form_name).submit();
        }
        else
            return true;
    }
    else {
        alert(error_string);
        return false;
    }
}

/******************************************************************************
 * function:  VDCheckDate
 * author: tmv
 * date: 2004.05.12
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * d_min - minimali datos reiksme, nenurodzius: 1000-01-01
 * d_max - maximali datos reiksme, nenurodzius: 2999-01-01
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * date_format - datos formato tipas
 * paskirtis: Tikrina ar teisingai yra ivesta data.
 * Formatas: 2000-01-01, 2000 01 01, 2000/01/01, 01/01/2000
 * PASTABOS 16, 17, 18 skaiciai imami is datos formato konfiguracijos, todel ir keisti tokie :)
 *****************************************************************************/
function VDCheckDate(field_id, show_error_text, is_required, d_min, d_max, error_text, date_format) {
	//var field_object = document.getElementById(field_id);
	var field_value = document.getElementById(field_id).value;
    switch (date_format) {
        case undefined:
        case 1:
            var regexp = /^(\d{4})\-(\d{2})\-(\d{2})$/;
            var separator = '-';
            break;
        case 2:
            var regexp = /^(\d{4})\.(\d{2})\.(\d{2})$/;
            var separator = '.';
            break;
        case 16:
            var regexp = /^(\d{4}) (\d{2}) (\d{2})$/;
            var separator = ' ';
            break;
        case 17:
            var regexp = /^(\d{4})\/(\d{2})\/(\d{2})$/;
            var separator = '/';
            break;
        case 18:
            var regexp = /^(\d{2})\/(\d{2})\/(\d{4})$/;
            var separator = '/';
            break;
        case 19:
            var regexp = /^(\d{2})\.(\d{2})\.(\d{4})$/;
            var separator = '.';
            break;
    }
    if(date_format == undefined || date_format < 20) {
        if (d_min == undefined || d_min == '') {
            d_min = '1000'+separator+'01'+separator+'01';
        }
        if (d_max == undefined || d_max == '') {
            d_max = '2999'+separator+'01'+separator+'01';
        }

        if (VDMakeDate(field_value, separator) < VDMakeDate(d_min, separator)) {
            vd_special_error = 1;
            add_special_text += '\n'+vd_error_date_min + d_min + '.\n';
        }
        //alert(check_field_value > check_max_value );
        if (VDMakeDate(field_value, separator) > VDMakeDate(d_max, separator)) {
            vd_special_error = 1;
            add_special_text += '\n'+vd_error_date_max + d_max + '.\n';
        }
    }
    switch (date_format) {
        case undefined:
        case 1:
        case 16:
        case 17:
            var month = field_value.substr(5, 2);
            var day = field_value.substr(8, 2);
            break;
        case 18:
            var month = field_value.substr(0, 2);
            var day = field_value.substr(3, 2);
            break;
    }
    if (month>12 || month<1 || day>31 || day<1) vd_special_error = 1;

    return VDReturnValue(regexp, field_id, show_error_text, 'date', is_required, error_text);
}

/******************************************************************************
 * function:  VDCheckTime
 * author: tmv
 * date: 2004.05.12
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * t_min - minimali laiko reiksme, nenurodzius: 00:00
 * t_max - maximali laiko reiksme, nenurodzius: 23:59
 * paskirtis: Tikrina ar teisingai yra ivestas laikas.
 * Formatas: 12:00
 *****************************************************************************/
function VDCheckTime(field_id, show_error_text, is_required, t_min, t_max, error_text) {
    var regexp = /^(\d{2})\:(\d{2})$/;
	var return_value = VDReturnValue(regexp, field_id, show_error_text, 'time', is_required, error_text);
    if (return_value == '') {
	    if (t_min == undefined || t_min == '') {
	        t_min = '00:00';
	    }
		if (t_max == undefined || t_max == '') {
		    t_max = '23:59';
		}
		//var field_object = document.getElementById(field_id);
		var field_value = document.getElementById(field_id).value;
		if (field_value < t_min) {
            vd_special_error = 1;
			add_special_text += '\n'+vd_error_time_min + t_min + '.\n';
		}
		if (field_value > t_max) {
            vd_special_error = 1;
			add_special_text += '\n'+vd_error_time_max + t_max + '.\n';
		}
        var min = field_value.substr(3,2);
        if (min > 59) vd_special_error = 1;
		return_value += VDReturnValue(regexp, field_id, show_error_text, 'time', is_required, error_text);
	}
    return return_value;
}

/******************************************************************************
 * function:  VDCheckEmail
 * author: tmv
 * date: 2004.05.12
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina ar teisingai yra ivestas el. pasto adresas.
 * Formatas: leidzia ir tokius: emtec25@diamond.vaikinai.org,  iki 4 subdomainu.
 *****************************************************************************/
function VDCheckEmail(field_id, show_error_text, is_required, error_text) {
    var regexp =  /^([a-zA-Z0-9])+([\.a-zA-Z0-9_-])*@([a-zA-Z0-9_-])+([.]{1}[a-zA-Z0-9_-]+){0,3}(\.[a-zA-Z0-9]{2,4})$/;
    return VDReturnValue(regexp, field_id, show_error_text, 'email', is_required, error_text);
}

/******************************************************************************
 * function:  VDCheckYear
 * author: nezinomas
 * date: nezinoma
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina ar teisingai yra ivesti metai
 * Formatas: nezinomas bet galima nuspeti is regexpo ;)
 *****************************************************************************/
function VDCheckYear(field_id, show_error_text, is_required, error_text) {
    var regexp =  /^[12]{1}[90]{1}(\d)?(\d)?$/;
    return VDReturnValue(regexp, field_id, show_error_text, 'year', is_required, error_text);
}

/******************************************************************************
 * function: VDCheckName
 * author: tmv
 * date: 2004.05.12
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina ar teisingai yra ivestas vardas.
 * Formatas: Pirma raide turi buti didzioji.
 *****************************************************************************/
function VDCheckName(field_id, show_error_text, is_required, error_text) {
    var regexp = new RegExp('^[A-Z'+vd_lang_letters_upper+']{1}[a-z'+vd_lang_letters_lower+']+$');
    return VDReturnValue(regexp, field_id, show_error_text, 'name', is_required, error_text);
}

/******************************************************************************
 * function:  VDCheckSurname
 * author: tmv
 * date: 2004.05.13
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina ar teisingai yra ivesta pavarde.
 * Formatas: Pirmos pavardes raides turi buti didziosios.
 *                  Testas arba Testas-Testavicius
 *****************************************************************************/
function VDCheckSurname(field_id, show_error_text, is_required, allowed_simbols, error_text) {
    if(allowed_simbols == undefined || allowed_simbols == '')
        allowed_simbols = ' ';
    var regexp = new RegExp('^([A-Z'+vd_lang_letters_upper+']{1}[a-z'+vd_lang_letters_lower+']+['+allowed_simbols+']{1,3})?[A-Z'+vd_lang_letters_upper+']{1}[a-zA-Z'+vd_lang_letters_lower+']{2,50}$');
    return VDReturnValue(regexp, field_id, show_error_text, 'full_name', is_required, error_text);
}

/******************************************************************************
 * function:  VDCheckFullName
 * author: tmv
 * date: 2004.05.13
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina ar teisingai yra ivesta vardas ir pavarde.
 * Formatas: Pirmos vardo ir pavardes raides turi buti didziosios.
 *                  Testas Testavicius arba gali butu Testas Testavicius-Testo
 *****************************************************************************/
function VDCheckFullName(field_id, show_error_text, is_required, allowed_simbols, error_text) {
    if(allowed_simbols == undefined || allowed_simbols == '')
        allowed_simbols = ' ';
    var regexp = new RegExp('^[A-Z'+vd_lang_letters_upper+']{1}[a-z'+vd_lang_letters_lower+']+[ ]{1,3}[A-Z'+vd_lang_letters_upper+']{1}[a-zA-Z'+vd_lang_letters_lower+']{2,50}(['+allowed_simbols+']{1,3}[A-Z'+vd_lang_letters_upper+']{1}[a-z'+vd_lang_letters_lower+']{2,50})?$');
    return VDReturnValue(regexp, field_id, show_error_text, 'full_name', is_required, error_text);
}

/******************************************************************************
 * function:  VDCheckFullNameUpper
 * author: tmv
 * date: 2004.05.13
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina ar teisingai yra ivesta vardas ir pavarde.
 * Formatas: Visos vardo ir pavardes raides turi buti didziosios
 *****************************************************************************/
function VDCheckFullNameUpper(field_id, show_error_text, is_required, error_text) {
    var regexp = new RegExp('^[A-Z'+vd_lang_letters_upper+']{2,50}[ ]{1,3}[A-Z'+vd_lang_letters_upper+']{2,50}$');
    return VDReturnValue(regexp, field_id, show_error_text, 'full_name_upper', is_required, error_text);
}

/******************************************************************************
 * function: VDCheckPhone
 * author: tmv
 * date: 2004.05.13
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina ar teisingai yra ivestas telefonas.
 * Formatas: Turi buti tik skaiciai.Leidziamas pirmas simbolis +
 *****************************************************************************/
function VDCheckPhone(field_id, show_error_text, is_required, error_text) {
    var regexp = /^(\+)?[0-9 ]{3,20}$/;
    return VDReturnValue(regexp, field_id, show_error_text, 'phone', is_required, error_text);
}

/******************************************************************************
 * function: VDCheckURL
 * author: tmv
 * date: 2004.05.13
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina ar teisingai yra url.
 * Formatas:
 *****************************************************************************/
function VDCheckURL(field_id, show_error_text, is_required, error_text) {
    //var regexp = /^(http(s?):\/\/|ftp:\/\/|www\.)+([\.a-zA-Z0-9_-])+(\.[a-zA-Z0-9_-]{2,3})([\/])?$/i;
	//var regexp = /^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/i;
    var regexp = /^(http(s?):\/\/|ftp:\/\/)([\.a-zA-Z0-9_-])+(\.[a-zA-Z]{2,4})((\/[\%\.a-zA-Z0-9_\/\?\&\=-]{0,})?)$/i;
    return VDReturnValue(regexp, field_id, show_error_text, 'url', is_required, error_text);
}

/******************************************************************************
 * function: VDCheckLetters
 * author: tmv
 * date: 2004.05.13
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * min_chars - kiek simboliu yra minimumas.Default 3 simboliai
 * max_chars - kiek simboliu yra maximumas.Default 255 simboliai
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina ar yra ivedami simboliai yra raides.
 * Formatas: Tik raides
 *****************************************************************************/
function VDCheckLetters(field_id, show_error_text, is_required, min_chars, max_chars, error_text) {
    if(min_chars == undefined || min_chars == '')
        min_chars = 3;
    if(max_chars == undefined || max_chars == '')
        max_chars = 255;
    add_special_text += '\n'+vd_error_min+min_chars + '. '+vd_error_max + max_chars+'.\n';
    var regexp = new RegExp('^[a-z'+vd_lang_letters_upper+vd_lang_letters_lower+']{'+min_chars+','+max_chars+'}$', 'i');
    return VDReturnValue(regexp, field_id, show_error_text, 'letters', is_required, error_text);
}

/******************************************************************************
 * function: VDCheckNumbers
 * author: tmv
 * date: 2004.05.13
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * min_chars - kiek simboliu yra minimumas.Default 3 simboliai
 * max_chars - kiek simboliu yra maximumas.Default 255 simboliai
 * not_special_text - ar neišvesti papildomo teksto
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina ar yra ivedami simboliai yra skaiciai.
 * Formatas: Leidziami tik skaiciai.
 *****************************************************************************/
function VDCheckNumbers(field_id, show_error_text, is_required, min_num, max_num, error_text, not_special_text) {
    if(min_num == undefined || min_num == '')
        min_num = 1;
    if(max_num == undefined || max_num == '')
        max_num = 255;
    if (not_special_text == undefined) add_special_text += '\n'+vd_error_min+min_num + '. '+vd_error_max + max_num+'.\n';
    var regexp = new RegExp('^\\d{'+min_num+','+max_num+'}$');
    return VDReturnValue(regexp, field_id, show_error_text, 'numbers', is_required, error_text);
}


function VDCheckCompanyCode(field_id, show_error_text, is_required, min_num, max_num, error_text, not_special_text) {
	var code = document.getElementById(field_id).value.replace(/-/g, '');

    var regexp = new RegExp('^\\d{'+min_num+','+max_num+'}$');
    return VDReturnValue(regexp, field_id, show_error_text, 'numbers', is_required, error_text, code);
}

/******************************************************************************
 * function: VDCheckNumbersLettersEtc
 * author: tmv
 * date: 2004.05.13
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * min_chars - kiek simboliu yra minimumas.Default 3 simboliai
 * max_chars - kiek simboliu yra maximumas.Default 255 simboliai
 * etc_sim - galima prideti savo simboliu kurie leidziami.
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina ar yra ivedami simboliai sutampa su leidziamais.
 * Formatas:
 * Pastabos:
 *     1.norint itraukti i etc simbolius simboli "-" reikia parasyti taip "\\\-" jei js rasoma php (tmv 2004.10.22)
        2.norint itraukti simboli '\' reikia parasyti \\\\\\\ - jei rasoma php (tmv 2005-08-17 14:26:48)
 *****************************************************************************/
function VDCheckNumbersLettersEtc(field_id, show_error_text, is_required, min_nl, max_nl, etc_sim, error_text) {
    if(min_nl == undefined || min_nl == '')
        min_nl = 3;
    if(max_nl == undefined || max_nl == '')
       max_nl = 255;
    if(etc_sim == undefined || etc_sim == '')
        etc_sim = '';
    else {
        var etc_sim_show = etc_sim.replace('\\\-', '-');
        etc_sim_show = etc_sim_show.replace('\\\\', '\\');
        add_special_text = '\n'+vd_error_etc + etc_sim_show + '\n';
    }
    add_special_text += '\n'+vd_error_min + min_nl + '. '+vd_error_max + max_nl+'.\n';

    var regexp = new RegExp('^[A-Za-z0-9'+vd_lang_letters_lower+vd_lang_letters_upper+etc_sim+']{'+min_nl+','+max_nl+'}$', 'i');
    return VDReturnValue(regexp, field_id, show_error_text, 'letters_numbers_etc', is_required, error_text);
}

/******************************************************************************
 * function: VDCheckFor
 * author: tmv
 * date: 2004.05.13
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * simbols - simbolius kurie turi buti (i)
 * icase - ar reikia atsizvelgti i tai ar raides didziosios ar mazosios
 * min_chars - kiek simboliu yra minimumas.Default 3 simboliai
 * max_chars - kiek simboliu yra maximumas.Default 255 simboliai
 * not_special_text - ar neišvesti papildomo teksto
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina ar laukelyje ivedami simboliai atitinka .
 * Formatas:
 *****************************************************************************/
function VDCheckFor(field_id, show_error_text, is_required, simbols, icase, min_nl, max_nl, error_text) {

    if(icase == undefined || icase == 0) {
        icase = '';
    }
     if(min_nl == undefined || min_nl == '')
        min_nl = 3;
    if(max_nl == undefined || max_nl == '')
       max_nl = 255;
    if(simbols == undefined || simbols == '')
        simbols = '';
    else
        add_special_text = '\n'+vd_error_etc + simbols + '\n';
    add_special_text += '\n'+vd_error_min + min_nl + '. '+vd_error_max + max_nl+'.\n';
    //A-Za-z0-9'+vd_lang_letters_lower+vd_lang_letters_upper+etc_sim+'

    var regexp = new RegExp('^['+simbols+']{'+min_nl+','+max_nl+'}$', icase);

    return VDReturnValue(regexp, field_id, show_error_text, 'manualy_simbols', is_required, error_text);
}


/******************************************************************************
 * function:  VDCheckDecimal
 * author: tmv
 * date: 2004.05.13
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * min_num - kokia maziausia reiksme , default 0
 * max_num - kokia didziausia reiksme, default 1000000000
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 *pl_min_check - jeigu lygus 1 tai leidiza pries sakiciu ivesti + arba - zenklus.Jei reikia minuso tai min reiksme reikia nurodyti
 *kokia  norima kad butu ne nulis
 * allow_comma - pakeicia kablelius i taskus
 * decimal_count - kiek skaiciu po kablelio gali but
 * paskirtis: Tikrina ar yra ivedami simboliai sutampa su leidziamais.
 * Formatas: 10.100 arba 10, -100, +100.00
 *****************************************************************************/
function VDCheckDecimal(field_id, show_error_text, is_required, min_num, max_num, error_text, pl_min_check, allow_comma, decimal_count) {
    var field_value = document.getElementById(field_id).value;
    if (allow_comma == 1) field_value = field_value.replace(',', '.');
    if(min_num == undefined || min_num == '')
        min_num = 0;
    if(max_num == undefined || max_num == '')
        max_num = 1000000000;
	var dot_place = field_value.indexOf('.');
	if (dot_place != field_value.lastIndexOf('.'))
		vd_special_error = 1;
	else if (decimal_count != undefined && dot_place > -1 && field_value.length - dot_place-1 > decimal_count)
		vd_special_error = 1;

    field_value = parseFloat(field_value);
    if(field_value < min_num) {
        vd_special_error = 1;
        add_special_text += vd_error_decimal_min + min_num;
    }
    if(max_num < field_value) {
        vd_special_error = 1;
        add_special_text += vd_error_decimal_max + max_num;
    }
    if(pl_min_check == 1)
        pl_min_check = '([+-])?';
    else
        pl_min_check = '';
    var separator = '\\.';
    //jeigu leidziamas ir kablelis kaip atskirimas
    if(allow_comma == 1) {
        separator = '[\\.,]';
    }
    //var regexp = /^\d{1,10}(\.?(\d)){0,3}$/;
    var regexp = new RegExp('^'+pl_min_check+'\\d{1,10}('+separator+'?(\\d)){0,4}$');
    return VDReturnValue(regexp, field_id, show_error_text, 'decimal', is_required, error_text);
}

/******************************************************************************
 * function:  VDCheckIsFieldChecked
 * author: tmv
 * date: 2004.05.13
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina ar checbox arba radio yra pazymeti.
 * Formatas:
 *****************************************************************************/
function VDCheckIsFieldChecked(field_id, show_error_text, is_required, error_text) {
    var return_text = '';
    var vd_obj = document.getElementById(field_id);
    if(vd_obj.checked == false) {
       VDMarkField(vd_obj, 2, 'checkbox');
       return_text = VDFieldTypeErrorText('checkbox');
    }
    else
        VDMarkField(vd_obj, 3, 'checkbox');
    return return_text;
    //return VDReturnValue(regexp, field_id, show_error_text, 'decimal', is_required, error_text);
}

/******************************************************************************
 * function:  VDCheckEmpty
 * author: tmv
 * date: 2004.05.13
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina ar fieldas nera tuscias.O gali rasyti bet ka isskyrus VIEN tarpus, tarpai galimi jei yra koks nors tekstas
 * Formatas: FĘĖĮĖŲŠĮŲĖĮŠėčęėčęėčėčė7654#$%#$%^#^$%^  :)
 *****************************************************************************/
function VDCheckEmpty(field_id, show_error_text, is_required, error_text) {
    var regexp = /.+/;
    return VDReturnValue(regexp, field_id, show_error_text, 'empty', is_required, error_text);
}

/******************************************************************************
 * function:  VDCheckInteger
 * author: tmv
 * date: 2004.05.13
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina ar irasytas sveikas skaicius
 * Formatas: 10, 10000.
 *****************************************************************************/
function VDCheckInteger(field_id, show_error_text, is_required, error_text) {
    var regexp = /^\d+$/;
    return VDReturnValue(regexp, field_id, show_error_text, 'integer', is_required, error_text);
}

/******************************************************************************
 * function:  VDCheckSearch
 * author: tmv
 * date: 2004.05.13
 * parameters:
 * fields_array - masyvas fieldu kuriuos reikia patikrinti
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * select_fields_array - masyvas select fieldu kuriuos reikia patikrinti
 * paskirtis: Tikrina ar yra uzpildytas nors vienas paieskos kriterijus
 * Formatas: jeigu nors vienas yra uzpildytas grazina true, tai yra viskas teisingai
 *****************************************************************************/
function VDCheckSearch(fields_array, error_text, select_fields_array) {
	//2005.06.13 donatas: VD_search_obj obj don't work in mozilla browser
    //var VD_search_obj = document.getElementById;
    var VD_search_counter = 0;
    var VD_search_fields_cnt = fields_array.length;

    for(i=0;i<VD_search_fields_cnt;i++) {
        if(document.getElementById(fields_array[i]) != null && document.getElementById(fields_array[i]).value.trim() == '')
            VD_search_counter++;
        if (document.getElementById(fields_array[i]) == null) VD_search_counter++;
    }
    if (select_fields_array != undefined) {
        VD_search_fields_cnt += select_fields_array.length;
        for(i=0;i<select_fields_array.length;i++) {
            if(document.getElementById(select_fields_array[i]) != null && document.getElementById(select_fields_array[i]).selectedIndex == 0)
                VD_search_counter++;
        }
    }
    //alert(VD_search_fields_cnt + ' == ' + VD_search_counter);
    if(VD_search_fields_cnt == VD_search_counter) {
        if(error_text != '' && error_text != undefined)
            vd_error_field_search = error_text;
        return false;
    } else return true;
}


function VDCheckPersonCodeN18(field_id, show_error_text, is_required, min_num, max_num, error_text, not_special_text) {
	vd_special_error = 0;
    var regexp = /[3456]\d{10,10}/;

	if( msg = VDReturnValue(regexp, field_id, show_error_text, 'n18', is_required, ((error_text)?error_text:vd_error_n18)) ){
		return msg;
	}else{
		var aD = document.getElementById(field_id).value.substr(0,1);
        if( aD == 3 ){
            var BD = '19';
        }else if( aD == 4 ){
            var BD = '19';
        }else if( aD == 5 ){
            var BD = '20';
        }else if( aD == 6 ){
            var BD = '20';
        }

		function Age( byr, bmo, bday ) {
			var now = new Date();
			var tmo = now.getMonth()+1;
			return now.getFullYear() -(( (tmo > parseInt(bmo)) || (tmo==parseInt(bmo) & now.getDate() >= parseInt(bday)) )?parseInt(byr):parseInt(byr)+1);
		}

		if( Age( (BD +document.getElementById(field_id).value.substr(1,2)), document.getElementById(field_id).value.substr(3,2), document.getElementById(field_id).value.substr(5,2) ) < 18 ){
			var regexp = new RegExp('^Bla Bla Bla - Ne Pilnametis$');
			return VDReturnValue(regexp, field_id, show_error_text, 'n18', is_required, ((error_text)?error_text:vd_error_n18))
		}else{
			return '';
		}
	}
}


/******************************************************************************
 * function:  VDCheckISBN
 * author: tmv
 * date: 2005.04.08
 * parameters:
 * field_id - formos fieldo id
 * show_error_text -  erroro tekstas
 * is_required - ar laukelis yra privalomas (1 - privalomas, 0- neprivalomas, bet jei uzpildytas bus tikrinamas)
 * error_text -  klaidos tekstas kuris bus rodomas vartotojui, nera butinas nes yra default
 * paskirtis: Tikrina isbn koda
 * Formatas:
 *****************************************************************************/
function VDCheckISBN(field_id, show_error_text, is_required, error_text){
    var regexp = /(?=.{13})\d{1,5}( |\-)\d{1,7}\1\d{1,6}\1(\d|X)/;
    return VDReturnValue(regexp, field_id, show_error_text, 'isbn', is_required, error_text);
}

//end validator functions

//others functions

function VDFieldTypeErrorText(field_info_type, show_error_text, field_text) {
	var error = '';
    //alert(field_info_type);
    switch(field_info_type) {
        case 'date':
            //alert(show_error_text);
            if(show_error_text.indexOf(vd_error_date) == -1 || field_text == 1)     //kad nepranesinetu 2 vienodu klaidu pranesimu
                error = vd_error_date + add_special_text;
    	break;
        case 'time':
            if(show_error_text.indexOf(vd_error_time) == -1 || field_text == 1)
                error = vd_error_time + add_special_text;
    	break;
        case 'email':
            if(show_error_text.indexOf(vd_error_email) == -1 || field_text == 1)
                error = vd_error_email;
    	break;
        case 'name':
            if(show_error_text.indexOf(vd_error_name) == -1 || field_text == 1)
                error = vd_error_name;
    	break;
        case 'full_name':
            if(show_error_text.indexOf(vd_error_full_name) == -1 || field_text == 1)
                error = vd_error_full_name;
    	break;
        case 'full_name_upper':
            if(show_error_text.indexOf(vd_error_full_name) == -1 || field_text == 1)
                error = vd_error_full_name_upper;
    	break;
        case 'phone':
            if(show_error_text.indexOf(vd_error_phone) == -1 || field_text == 1)
                error = vd_error_phone;
    	break;
        case 'url':
            if(show_error_text.indexOf(vd_error_url) == -1 || field_text == 1)
                error = vd_error_url;
    	break;
        case 'letters':
            if(show_error_text.indexOf(vd_error_letters) == -1 || field_text == 1)
                error = vd_error_letters + add_special_text;
    	break;
        case 'numbers':
            if(show_error_text.indexOf(vd_error_numbers) == -1 || field_text == 1)
                error = vd_error_numbers + add_special_text;
    	break;
        case 'letters_numbers_etc':
            if(show_error_text.indexOf(vd_error_letters_numbers_etc) == -1 || field_text == 1)
                error = vd_error_letters_numbers_etc + add_special_text;
    	break;
        case 'decimal':
            if(show_error_text.indexOf(vd_error_decimal) == -1 || field_text == 1) {
                  //          alert(' 1 : '+vd_error_decimal);
                error = vd_error_decimal + add_special_text;
            }
    	break;
        case 'checkbox':
            if(show_error_text.indexOf(vd_error_checbox) == -1 || field_text == 1)
                error = vd_error_checbox;
    	break;
        case 'empty':
            //alert(vd_error_field_empty);
            if(show_error_text.indexOf(vd_error_field_empty) == -1 || field_text == 1)
                error = vd_error_field_empty;
    	break;
        case 'integer':
            if(show_error_text.indexOf(vd_error_field_integer) == -1 || field_text == 1)
                error = vd_error_field_integer;
        break;
        case 'manualy_simbols':
            if(show_error_text.indexOf(vd_error_manualy_simbols) == -1 || field_text == 1)
                error = vd_error_manualy_simbols;
        break;
        case 'isbn':
            if(show_error_text.indexOf(vd_error_isbn) == -1 || field_text == 1)
                error = vd_error_isbn;
        break;
    }
    return error;
}

function VDMarkField(field_obj, status, info_type, show_error_text) {
    switch (status) {
        case 0:
            field_obj.removeAttribute('title');
            field_obj.style.borderColor = '';
            field_obj.style.borderWidth = '';
            if(field_obj.getAttribute('type') == 'select-multiple' || field_obj.getAttribute('type') == 'select')
                field_obj.style.backgroundColor = '';
        break;
        case 1:
//alert(  info_type);
            field_obj.setAttribute('title', VDFieldTypeErrorText(info_type, show_error_text, 1));
            field_obj.style.borderColor = 'red';
            field_obj.style.borderWidth = '1px';
            if(field_obj.getAttribute('type') == 'select-multiple' || field_obj.getAttribute('type') == 'select')
                field_obj.style.backgroundColor = 'red';
        break;
        case 2:
            field_obj.setAttribute('title', VDFieldTypeErrorText(info_type, show_error_text, 1));
            field_obj.style.backgroundColor = 'red';
        break;
        case 3:
            field_obj.removeAttribute('title');
            field_obj.style.backgroundColor = '';
        break;
        case 4: //2005.01.27 tmv.naudojamas atskirai nuo validatoriaus iskvieciant, kad nudazytu fieldus raudonai
            field_obj.setAttribute('title', show_error_text);
            field_obj.style.borderColor = 'red';
            field_obj.style.borderWidth = '1px';
            if(field_obj.getAttribute('type') == 'select-multiple' || field_obj.getAttribute('type') == 'select')
                field_obj.style.backgroundColor = 'red';
        break;
    }
    add_special_text = '';
    vd_special_error = 0;
}

function VDReturnValue( check_regexp, field_id, show_error_text, info_type, is_required, error_text, fv ) {
	var field_value = ((fv)?fv:document.getElementById(field_id).value);

    var return_text = '';
    //jeigu fieldas yra privalomas arba jeigu fieldas nera privalomas bet yra uzpildytas
    if(is_required == 1 || ((is_required == undefined || is_required == 0) && field_value.trim() != '')) {
        field_value = field_value.trim();
    	var field_values = field_value.split(/,/g);
		var err = 0;

        // Mantas 2006-08-07: jei nodojamas for ( var .. in .. ) sakinys
        // itraukiami ir metodai, todel reikia naudoti paprasta for sakini
		for (var Key=0; Key < field_values.length; Key++) {
            field_value = field_values[Key].trim();

	        if(!check_regexp.test(field_value) || vd_special_error == 1) {
	          //alert(  info_type);
	            if(error_text == undefined || error_text == '')
	                return_text = VDErrorText(field_value, info_type, show_error_text);
	            else
	                return_text = error_text;

				err++;

	        } else {
	           // ok?
			}
		}

		if(err){
			VDMarkField(document.getElementById(field_id), 1, info_type, show_error_text);
		}else{
			VDMarkField(document.getElementById(field_id), 0, info_type, show_error_text);
		}
    }
    else if(((is_required == undefined || is_required == 0) && field_value.trim() == '')) { //jeigu fieldas nera privalomas ir
    //tuscias tai panaikinam raudonus borderius arba raudona fona
        VDMarkField(document.getElementById(field_id), 0, info_type, show_error_text);
    }
    if(return_text.trim() != '')
        return_text = return_text + "\n";
    return return_text;
}

function VDErrorText(string, info_type, show_error_text) {
    var val_error_msg = '';
    //if(string.replace(/ /g, '') != '') {
    if(string.trim() != '') {
        //alert('1 : '+show_error_text);
        val_error_msg = VDFieldTypeErrorText(info_type, show_error_text);
        //alert(val_error_msg);
    }
    else {
        if(show_error_text.indexOf(vd_error_empty) == -1)
         	val_error_msg += vd_error_empty;
    }
    return val_error_msg;
}

/**
* @auth tmv
* @date 2005-08-17 15:59:19
* @return int
* @param idate, sep
* @desc funkcija VDMakeDate()
*/
function VDMakeDate(idate, sep) {
    var split_date = idate.split(sep);
    var dateToCheck = new Date();
    dateToCheck.setYear(split_date[0]);
    dateToCheck.setMonth(split_date[1] - 1);
    dateToCheck.setDate(split_date[2]);
    return dateToCheck.getTime();
}

//String.prototype.trim = function() { return this.replace(/^\s+|\s+$/, ''); };