/*
pattern_name					<-	paterno prasminga dalis pvz.: time, email
laisvas parametru skaicius		<-	stringai
return							<-	true if correct, false if incorrect or undefined
*/
function validate_string(pattern_name)
{	
	//var regexp_all = new Array('email','time','number','number_integer','number_integer','number_integer_positive','','','','','','','','')
	var i, args = validate_string.arguments

	//paprastesnis	->	/^[\w\.=-]+@[\w\.-]+\.[a-z]{2,3}$/i
	//kitas			->	/^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9])+$/
	var regexp_email = /^[a-z0-9]([a-z0-9_\-\.]*)@([a-z0-9_\-\.]*)(\.[a-z]{2,3}(\.[a-z]{2}){0,2})$/i

	//HH:MM or HH:MM:SS or HH:MM:SS.mmm
	//(where the .mmm is milliseconds as used in SQL Server datetime datatype.
	//Also, the .mmm portion will accept 1 to 3 digits after the period
	var regexp_time = /^([1-9]|1[0-2]):[0-5]\d(:[0-5]\d(\.\d{1,3})?)?$/
	
	var regexp_text = /^[a-zA-Z0-9,\.\-_@\S\s]+$/ //raides ir skaiciai

	var regexp_number = /(^-?\d\d*\,\d*$)|(^-?\d\d*$)|(^-?\,\d\d*$)/ //gali buti neigiami ir nelyginis, t.y. su kableliais

	var regexp_number_integer = /(^-?\d\d*$)/	//sveikas skaicius, gali buti neigiamas

	var regexp_number_integer_positive = /^\d\d*$/	//sveikas teigiamas skaicius (deja gali buti nulis)

	var regexp_gif_jpg = /\\[w_]*\.(gif|jpg)$/

	//alert(reg.test(args[i]))

	for (i=1; i<args.length; i++)
	{
		if (!args[i]) return false
		if (eval('!'+'regexp_'+pattern_name+'.test(args[i])'))
			return false
	}
	return true
}


// ====================================================   formating


//str			<- stringas valymui
//remove_simb	<- stringas kuris randamas
//new_simb		<- stringas pakeiciamas
//return		<- isvalyta stringa
function remove_simb(str,remove_simb,new_simb)
{
	var objRegExp = new RegExp(remove_simb,'g')
	return str.replace(objRegExp,new_simb)
}


//ismeta visus lisnus speisus, tame tarpe pradzioje ir pabaigoje
//return	<-	apdorotas stringas
function clean_spaces(strValue)
{
	//check for all spaces
	var objRegExp = /^(\s*)$/;
    if(objRegExp.test(strValue)) {
       strValue = strValue.replace(objRegExp, '');
       if( strValue.length == 0)
			return strValue;
    }

	//check for leading & trailing spaces
	objRegExp = /^(\s*)([\W\w]*)(\b\s*$)/;
	if(objRegExp.test(strValue)) 
	{
       strValue = strValue.replace(objRegExp, '$2');
	}
	
	//meta nereikalingus tarpus tarp zodziu
	objRegExp = new RegExp('  ','g')
	while (objRegExp.test(strValue))
	{
		strValue = strValue.replace(objRegExp,' ')
	}
	
	return strValue;
}

/**!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 * Removes trailing and leading whitespace in a string.
 */
function removeWhitespace(str) {
	var re = /^(\s+)(\S.+\s?\S+)(\s+)$/;
	return str.replace(re, "$2");s
}


//a: value for check
//return	->	jei tik tarpai arba nulis > true, antraip > false
function is_full(a)
{
	if (!a) return false
	if (a + '' == '') return false
	else return true
	
//	if (a.length == 0 || a == 0) return false
//	else return true

/* senas variantas
	a = clean_spaces(a)
	if (a == "" || a == 0) return false
	return true
*/
}







/*---------------------------------------------------------     oldai

var reg_pattern = "pattern", reg_flags = "flags"
var regExp_patterns = new Array()

//paprastesnis -> /^[\w\.=-]+@[\w\.-]+\.[a-z]{2,3}$/i
//"^[a-z0-9]([a-z0-9_\-\.]*)@([a-z0-9_\-\.]*)(\.[a-z]{2,3}(\.[a-z]{2}){0,2})$"

//'^[\w\.=-]+@[\w\.-]+\.[a-z]{2,3}$'

regExp_patterns["e-mail"] = new Array()
regExp_patterns["e-mail"][reg_pattern] = '^[\\w\\.=-]+@[\\w\\.-]+\\.[a-z]{2,3}$'
regExp_patterns["e-mail"][reg_flags] = 'i'

//HH:MM or HH:MM:SS or HH:MM:SS.mmm 
//(where the .mmm is milliseconds as used in SQL Server datetime datatype. 
//Also, the .mmm portion will accept 1 to 3 digits after the period
regExp_patterns["time"] = new Array()
regExp_patterns['time'][reg_pattern] = '^([1-9]|1[0-2]):[0-5]\d(:[0-5]\d(\.\d{1,3})?)?$'
regExp_patterns['time'][reg_flags] = ''

regExp_patterns['number'] = new Array()
regExp_patterns['number'][reg_pattern] = '(^-?\\d\\d*\\,\\d*$)|(^-?\\d\\d*$)|(^-?\\,\\d\\d*$)' //gali buti neigiami ir nelyginis, t.y. su kableliais
regExp_patterns['number'][reg_flags] = ''

regExp_patterns['number_integer'] = new Array()
regExp_patterns['number_integer'][reg_pattern] = '(^-?\\d\\d*$)' //sveikas skaicius, gali buti neigiamas
regExp_patterns['number_integer'][reg_flags] = ''

regExp_patterns['number_integer_positive'] = new Array()
regExp_patterns['number_integer_positive'][reg_pattern] = '^\\d\\d*$' //sveikas teigiamas skaicius (deja gali buti nulis)
regExp_patterns['number_integer_positive'][reg_flags] = ''

regExp_patterns['letters_only'] = new Array()
regExp_patterns['letters_only'][reg_pattern] = '^[a-zA-Z]*$'
regExp_patterns['letters_only'][reg_flags] = ''

regExp_patterns['gif_jpg'] = new Array()
regExp_patterns['gif_jpg'][reg_pattern] = '\\\\[w_]*\\.(gif|jpg)$'
regExp_patterns['gif_jpg'][reg_flags] = ''



//return							<-	true if correct, false if incorrect
//laisvas parametru skaicius		<-	turi buti formos inputu atributai name

function validate_regexp(pattern_name)
{	
	var i, args = validate_regexp.arguments

	alert(regExp_patterns[pattern_name][reg_pattern])
	//alert(reg.test(this.obj.value))
	
	if (regExp_patterns[pattern_name][reg_flags] == '')
		var reg = new RegExp(regExp_patterns[pattern_name][reg_pattern])
	else
		var reg = new RegExp(regExp_patterns[pattern_name][reg_pattern], regExp_patterns[pattern_name][reg_flags])

		//alert(reg.test(args[i]))

	for (i=1; i<args.length; i++)
	{
		if (!reg.test(args[i]))
			return false

		//alert()

	}

	return true;
}

*/