var xBrowser= new Object();
xBrowser.v = navigator.userAgent.toLowerCase();
xBrowser.isIe = (xBrowser.v.indexOf("msie 6") > -1 )?true:false;
xBrowser.cssCompat = (document.compatMode == "CSS1Compat")?true:false;
xBrowser.isMoz = (xBrowser.v.indexOf("rv:1.") > -1 )?true:false;

/**************************************************************
ReverseString: Returns a string in which the character order
of a specified string is reversed

Parameters:
Expression = The expression argument is the string whose
characters are to be reversed. If expression
is a zero-length string (""), a zero-length
string is returned. If expression is null,
false is returned.

Returns: String
***************************************************************/
function ReverseString(Expression)
{
	if (Expression == null)
	return (false);

	var dest = '';
	for (var i = (Expression.length - 1); i >= 0; i--)
	dest = dest + Expression.charAt(i);
	return dest;
}

/**************************************************************
StrConv: Returns a String converted as specified in the
Parameters Section.

Parameters:
String     = String expression to be converted.
Conversion = Number specifying the type of conversion
to perform.
1 = TO UPPER CASE
2 = to lower case
3 = To Proper Case
If Conversion is null or not specified 1
is set as default.

Returns: String
***************************************************************/
function StrConv(String, Conversion)
{
	var index;
	var tmpStr;
	var tmpChar;
	var preString;
	var postString;
	var strlen;

	if (Conversion == null || Conversion.length == 0)
	Conversion = '1';

	if (Conversion != '1' && Conversion != '2' && Conversion != '3')
	Conversion = '1';

	if (Conversion == '1')
	return String.toUpperCase();

	if (Conversion == '2')
	return String.toLowerCase();

	//Proper Case
	tmpStr = String.toLowerCase();
	strLen = tmpStr.length;
	if (strLen > 0)
	{
		for (index = 0; index < strLen; index++)
		{
			if (index == 0)
			{
				tmpChar = tmpStr.substring(0, 1).toUpperCase();
				postString = tmpStr.substring(1, strLen);
				tmpStr = tmpChar + postString;
			}
			else
			{
				tmpChar = tmpStr.substring(index, index + 1);
				if (tmpChar == " " && index < (strLen - 1))
				{
					tmpChar = tmpStr.substring(index + 1, index + 2).toUpperCase();
					preString = tmpStr.substring(0, index + 1);
					postString = tmpStr.substring(index + 2,strLen);
					tmpStr = preString + tmpChar + postString;
				}
			}
		}
	}
	return tmpStr;
}

/**************************************************************
Chr: Returns a String containing the character associated
with the specified character code.

Parameters:
CharCode = Long that identifies a character.

Returns: String
***************************************************************/
function Chr(CharCode)
{
	return String.fromCharCode(CharCode);
}

/**************************************************************
Asc: Returns an Integer representing the character code
corresponding to the first letter in a string

Parameters:
String = The required string argument is any valid
string expression. If the string if not in
the range 32-126, the function return ZERO

Returns: Integer
***************************************************************/
function Asc(string)
{
	var symbols = " !\"#$%&'()*+'-./0123456789:;<=>?@";
	var loAZ = "abcdefghijklmnopqrstuvwxyz";
	symbols += loAZ.toUpperCase();
	symbols += "[\\]^_`";
	symbols += loAZ;
	symbols += "{|}~";
	var loc;
	loc = symbols.indexOf(string);
	if (loc > -1)
	{
		Ascii_Decimal = 32 + loc;
		return (32 + loc);
	}
	return (0);
}

/**************************************************************
LBound: Returns a Long containing the smallest available
subscript for the indicated dimension of an array

Parameters:
array = Array to verify

Returns: Integer       (-1 if Array does not contain
any subscript)
***************************************************************/
function LBound(array)
{
	var i = 0;
	var temp = '';

	if (array.length == 0)
	return (-1);

	for (i = 0; i < array.length; i++)
	{
		temp = array[i]
		if (temp != null)
		{
			var temp = i;
			return temp;
		}
	}
	return (-1);
}

/**************************************************************
UBound: Returns a Long containing the largest available
subscript for the indicated dimension of an array

Parameters:
array = Array to verify

Returns: Integer       (-1 if Array does not contain
any subscript)
***************************************************************/
function UBound(array)
{
	return (array.length - 1);
}

/**************************************************************
Join: Returns a string created by joining a number of
substrings contained in an array.

Parameters:
array     = One-dimensional array containing substrings
to be joined
Delimiter = String character used to separate the
substrings in the returned string.
If delimiter is a zero-length string (""),
all items in the list are concatenated
with no delimiters.

Returns: String
***************************************************************/
function Join(array, Delimiter)
{
	var temp = '';

	if (array.length == 0)
	return '';

	if (Delimiter.length == 0)
	Delimiter = ' ';

	for (var i = 0; i < array.length; i++)
	{
		temp = temp + array[i]
		if (i < array.length - 1)
		temp = temp + Delimiter;
	}
	return temp;
}


/**************************************************************
Left: Returns a String containing a specified number of
characters from the left side of a string.

Parameters:
String = String expression from which the leftmost
characters are returned. If string contains null,
false is returned.
Length = Numeric expression indicating how many characters
to return. If 0, a zero-length string ("") is
returned. If greater than or equal to the number
of characters in string, the entire string is
returned.

Returns: String
***************************************************************/
function Left(String, Length)
{
	if (String == null)
	return (false);

	return String.substr(0, Length);
}

/**************************************************************
Right: Returns a String containing a specified number of
characters from the right side of a string.

Parameters:
String = String expression from which the leftmost
characters are returned. If string contains null,
false is returned.
Length = Numeric expression indicating how many characters
to return. If 0, a zero-length string ("") is
returned. If greater than or equal to the number
of characters in string, the entire string is
returned.

Returns: String
***************************************************************/
function Right(String, Length)
{
	if (String == null)
	return (false);

	var dest = '';
	for (var i = (String.length - 1); i >= 0; i--)
	dest = dest + String.charAt(i);

	String = dest;
	String = String.substr(0, Length);
	dest = '';

	for (var i = (String.length - 1); i >= 0; i--)
	dest = dest + String.charAt(i);

	return dest;
}

/**************************************************************
Mid: Returns a String containing a specified number of
characters from a string

Parameters:
String = String expression from which characters are
returned. If string contains null, false is
returned.
Start  = Number. Character position in string at which
the part to be taken begins. If Start is
greater than the number of characters in
string, Mid returns a zero-length string ("").
Length = Number of characters to return. If omitted
false is returned.

Returns: String
***************************************************************/
function Mid(String, Start, Length)
{
	if (String == null)
	return (false);

	if (Start > String.length)
	return '';

	if (Length == null || Length.length == 0)
	return String.substr((Start - 1));

	return String.substr((Start - 1), Length);
}

/**************************************************************
InStr: Returns a Long specifying the position of the first
occurrence of one string within another. Is String1
or String2 are null, false is returned.

Parameters:
String1 = String expression being searched.
String2 = String expression sought

Returns: Integer
***************************************************************/
function InStr(String1, String2)
{
	var a = 0;

	if (String1 == null || String2 == null)
	return (false);

	String1 = String1.toLowerCase();
	String2 = String2.toLowerCase();

	a = String1.indexOf(String2);
	if (a == -1)
	return 0;
	else
	return a + 1;
}


function str_pad(input,pad_length,pad_string,padtype){	
	var len=input.length;
	temp=input;
	for (var i = len; i < pad_length; i++)
	{
		if (padtype==0)
		temp = temp + pad_string;
		else
		temp = pad_string + temp;
	}
	return temp;
}
/**************************************************************
Split: Returns a zero-based, one-dimensional array containing
a specified number of substrings

Parameters:
Expression = String expression containing substrings and
delimiters. If expression is a zero-length
string(""), Split returns an empty array,
that is, an array with no elements and no
data.
Delimiter  = String character used to identify substring
limits. If delimiter is a zero-length
string (""), a single-element array
containing the entire expression string
is returned.

Returns: String
***************************************************************/
function Split(Expression, Delimiter)
{
	var temp = Expression;
	var a, b = 0;
	var array = new Array();

	if (Delimiter.length == 0)
	{
		array[0] = Expression;
		return (array);
	}

	if (Expression.length == '')
	{
		array[0] = Expression;
		return (array);
	}

	Delimiter = Delimiter.charAt(0);

	for (var i = 0; i < Expression.length; i++)
	{
		a = temp.indexOf(Delimiter);
		if (a == -1)
		{
			array[i] = temp;
			break;
		}
		else
		{
			b = (b + a) + 1;
			var temp2 = temp.substring(0, a);
			array[i] = temp2;
			temp = Expression.substr(b, Expression.length - temp2.length);
		}
	}

	return (array);
}


function wordsCount(expression){
	var array=Split(expression,' ');
	return array.length;
}

function wordNum(expression,search){
	var array=Split(expression,' ');
	for (var i=0;i<array.length;i++){
		if (search==array[i])
		return i+1;
	}
	return 0;
}

function getWordNum(expression,num){
	var array=Split(expression,' ');
	for (var i=0;i<array.length;i++){
		if (num==i+1)
		return array[i];
	}
	return null;
}

/**************************************************************
LTrim: Returns a String containing a copy of a specified
string without leading spaces

Parameters:
String = The required string argument is any valid
string expression. If string contains null,
false is returned

Returns: String
***************************************************************/
function LTrim(String)
{
	var i = 0;
	var j = String.length - 1;

	if (String == null)
	return (false);

	for (i = 0; i < String.length; i++)
	{
		if (String.substr(i, 1) != ' ' &&
		String.substr(i, 1) != '\t')
		break;
	}

	if (i <= j)
	return (String.substr(i, (j+1)-i));
	else
	return ('');
}

/**************************************************************
RTrim: Returns a String containing a copy of a specified
string without trailing spaces

Parameters:
String = The required string argument is any valid
string expression. If string contains null,
false is returned

Returns: String
***************************************************************/
function RTrim(String)
{
	var i = 0;
	var j = String.length - 1;

	if (String == null)
	return (false);

	for(j = String.length - 1; j >= 0; j--)
	{
		if (String.substr(j, 1) != ' ' &&
		String.substr(j, 1) != '\t')
		break;
	}

	if (i <= j)
	return (String.substr(i, (j+1)-i));
	else
	return ('');
}

/**************************************************************
RTrim: Returns a String containing a copy of a specified
string without both leading and trailing spaces

Parameters:
String = The required string argument is any valid
string expression. If string contains null,
false is returned

Returns: String
***************************************************************/
function Trim(String)
{
	if (String == null)
	return (false);

	return RTrim(LTrim(String));
}

/**************************************************************
Replace: Returns a string in which a specified substring has
been replaced with another substring a specified
number of times.

Parameters:
Expression = String expression containing substring to
replace
Find       = Substring being searched for.
Replace    = Replacement substring.

Returns: String
***************************************************************/
function Replace(Expression, Find, Replace)
{
	var temp = Expression;
	var a = 0;

	for (var i = 0; i < Expression.length; i++)
	{
		a = temp.indexOf(Find);
		if (a == -1)
		break
		else
		temp = temp.substring(0, a) + Replace + temp.substring((a + Find.length));
	}

	return temp;
}
/**************************************************************
Mask: Returns a Boolean if the specified Expression match
the specified Mask.

Parameters:
Expression = String to validate
Mask       = String that can contain the following
options:
9 = only numbers (0..9)
X = only letters (a..z or A..Z)
* = Anything...
Example: alert(Mask("(954) 572-4419", "(999) 999-9999")); => TRUE
alert(Mask("33351-820", "99999-9999"));          => FALSE
alert(Mask("This is a test", "XXXXXX"));         => FALSE
alert(Mask("This 34 a test", "**************")); => TRUE

Returns: Boolean
***************************************************************/
Mask=function (Expression, Mask)
{
	Mask = Mask.toUpperCase();
	LenStr = Expression.length;
	LenMsk = Mask.length;
	if ((LenStr == 0) || (LenMsk == 0))
	return (false);
	if (LenStr != LenMsk)
	return (false);
	TempString = '';
	for (Count = 0; Count <= Expression.length; Count++)
	{
		StrChar = Expression.substring(Count, Count + 1);
		MskChar = Mask.substring(Count, Count + 1);
		if (MskChar == '9')
		{
			if(!IsNumber(StrChar))
			return (false);
		}
		else if (MskChar == 'X')
		{
			if(!IsChar(StrChar))
			return (false);
		}
		else if (MskChar == '*')
		{
			if(!IsAlphanumeric(StrChar))
			return (false);
		}
		else
		{
			if (MskChar != StrChar)
			return (false);
		}
	}
	return (true);
}

/**************************************************************
IsEmail: Returns a Boolean if the specified Expression is a
valid e-mail address. If Expression is null, false
is returned.

Parameters:
Expression = e-mail to validate.

Returns: Boolean
***************************************************************/
IsEmail=function (Expression)
{
	if (Expression == null)
	return (false);

	var supported = 0;
	if (window.RegExp)
	{
		var tempStr = "a";
		var tempReg = new RegExp(tempStr);
		if (tempReg.test(tempStr)) supported = 1;
	}
	if (!supported)
	return (Expression.indexOf(".") > 2) && (Expression.indexOf("@") > 0);
	var r1 = new RegExp("(@.*@)|(\\.\\.)|(@\\.)|(^\\.)");
	var r2 = new RegExp("^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$");
	return (!r1.test(Expression) && r2.test(Expression));
}

/**************************************************************
IsChar: Returns a Boolean value indicating whether an
expression can be evaluated as a character (this
not only includes alpha chars but all symbols such as
@#$%^&|\_+-/*="!?,.:;'(){}<>[]

Parameters:
- Expression = Variant containing a numeric expression or
string expression.

Returns: Boolean
***************************************************************/
IsChar=function (Expression)
{
	Expression = Expression.toLowerCase();
	RefString = "0123456789";

	if (Expression.length < 1)
	return (false);

	for (var i = 0; i < Expression.length; i++)
	{
		var ch = Expression.substr(i, 1)
		var a = RefString.indexOf(ch, 0)
		if (a != -1)
		return (false);
	}
	return(true);
}

/**************************************************************
IsNumber: Returns a Boolean value indicating whether an
expression can be evaluated as a number (this
includes values like $15,656.00)

Parameters:
Expression = Variant containing a numeric expression or
string expression.

Returns: Boolean
***************************************************************/
IsNumber=function (Expression)
{
	Expression = Expression.toLowerCase();
	RefString = "0123456789.-";

	if (Expression.length < 1)
	return (false);

	for (var i = 0; i < Expression.length; i++)
	{
		var ch = Expression.substr(i, 1)
		var a = RefString.indexOf(ch, 0)
		if (a == -1)
		return (false);
	}
	return(true);
}

/**************************************************************
IsAlphanumeric: Returns a Boolean value indicating whether an
expression can be evaluated as a number or
char.

Parameters:
Expression = Variant containing a numeric expression or
string expression.

Returns: Boolean
***************************************************************/
IsAlphanumeric=function (Expression)
{
	Expression = Expression.toLowerCase();
	RefString = "abcdefghijklmnopqrstuvwxyz0123456789 ";

	if (Expression.length < 1)
	return (false);

	for (var i = 0; i < Expression.length; i++)
	{
		var ch = Expression.substr(i, 1)
		var a = RefString.indexOf(ch, 0)
		if (a == -1)
		return (false);
	}
	return(true);
}	

function xForm(form){
	
	var me=this;
	
	this.validError=new Object();
	
	this.validError.required=[];
	
	this.validate=function (){
		var valid=true		
		this.validError.required=[];
		
		for (var j=0; j<form.elements.length; j++){
			var element=form.elements[j];
			if (xDef(element.currentStyle)){
				if (element.currentStyle.display=='none' | element.currentStyle.visibility=='hidden')
				continue;
			}
			else{
				var d=document.defaultView.getComputedStyle(element, null).getPropertyValue("display");
				var v=document.defaultView.getComputedStyle(element, null).getPropertyValue("visibility");
				
				if (d=='none' | v=='hidden')
				continue;
			}
			for (var i=0; i<element.attributes.length;i++){				
				intAtt=element.attributes[i];		
				switch (intAtt.name.toLowerCase()){
					case 'allowonly':
						if (element.value!=''){
							switch (intAtt.value){
								case '0..9':							
									if (!IsNumber(element.value)){
										
									}
								break;
							}
						}
					break;
					case 'required':
						var seteado=true;
						if (intAtt.value=="true"){
							switch (element.tagName.toUpperCase()){
								case 'TEXTAREA':
								case 'BUTTON':
									if (!element.innerHTML){
										seteado=false;
									}
								break;
								case 'INPUT':				
									if (!element.value){
										seteado=false;
									}									
								break;								
								case 'SELECT':
									if (element.selectedIndex==-1)
										seteado=false;
								break;
							}
						}
						
						if (!seteado){
							if (!xDef(element.validateInfo))
								element.validateInfo=new Object();
							
							element.validateInfo.beforeBorder=element.style.border							
							
							if (element.validateInfo.beforeBorder=="")
							element.validateInfo.beforeBorder="medium none";
							
							element.style.border="red 1px solid";
							valid=false;
							
							this.validError.required[this.validError.required.length]=element;
						}
						else{
							if (xDef(element.validateInfo))
							element.style.border=element.validateInfo.beforeBorder;
						}
					break;							
				}
			}
		}
		return valid;		
	}

	
	this.loadXML=function(oNode){		
		var e=0;
		var item=null;
		var name='';
		var value='';
				
		for (var i=0; i<oNode.childNodes.length;i++){
			var node=oNode.childNodes[i];
			if (node.nodeType=='1'){
				name=node.nodeName;				
				node.normalize();				
				value='';			
				if (node.firstChild!=null)
				value=node.firstChild.nodeValue;
				
				item=form.elements.namedItem(name);				
				
				if (item==null) // item no encontrado en el form
				continue;
				/*
				alert(name)
				alert(value)
				*/	
				
				if (typeof(item.tagName)!='undefined'){
					// el form tiene un solo elemento con este nombre
					this.setFieldValue(item,value);
				}
				else{
					// el form tiene varios elementos con este nombre
					var e=0;
					for (e=0;e<item.length;e++){
						this.setFieldValue(item[e],value);
					}
				}
			}
		}		
	}
	
	this.setFieldValue=function(item,value){		
		switch (item.tagName.toUpperCase()){
			case 'INPUT':				
				switch(item.type.toLowerCase()){
					case 'radio':                        
					case 'checkbox':
						if (item.value==value)
							item.checked=true;
						else
							item.checked=false;
						break;
					case 'button':
					case 'text':
					case 'password':						
						item.value=value;
					break;                        
				}
			break;
			case 'TEXTAREA':
			case 'BUTTON':
				item.value=value;
			break;
			case 'SELECT':
				var seteado=false;
				// recorre los items para ver si se encuentra el valor
				for (var i=0;i<item.options.length;i++){
					if (item.type=='select-multiple'){
						if (item.options[i].value==value){
							item.options[i].selected=true;
							seteado=true;
						}
						else
							item.options[i].selected=false;
					}
					else{
						if (item.options[i].value==value){
							item.options[i].selected=true;
							//item.selectedIndex=i;
							seteado=true;
							break;
						}
						else{
							item.options[i].selected=false;
							//item.selectedIndex=-1;
						}
					}
				}
				if (!seteado){
					//agregar el item que no esta
					var oOption = document.createElement("OPTION");
					item.options.add(oOption);
					oOption.innerHTML = value;
					oOption.value = value;
				}
			break;
		}		
	}
	 

	this.applyMask=function(element,Mask){

		if (typeof(element._mask_listener)!='undefined'){
			xRemoveEventListener(element,'keypress',element._mask_listener);
		}
		var keyListener1=function (){
            Mask=element.applymask;
        /*
        Mask="";

			for (var i=0; i<element.attributes.length;i++){
				intAtt=element.attributes[i];
				switch (intAtt.name.toLowerCase()){
					case 'applymask':
						Mask=intAtt.value;
					break;
				}
			}
			*/
			var e=new xEvent(arguments[0]);
			if (e.keyCode==8)
			return;
                   //alert(Mask)
			if (e.target.value.length==Mask.length){
				e.stopPropagation();
				e.preventDefault();
				return;
			}

			var StrChar = String.fromCharCode(e.keyCode);
			var MskChar = Mask.substring(e.target.value.length, e.target.value.length+1);
	
			if (MskChar!='9' & MskChar!='X' & MskChar!='*' & MskChar!='W'){
				e.target.value=e.target.value+MskChar
				MskChar = Mask.substring(e.target.value.length, e.target.value.length+1);
			}
	
			if (MskChar == '9')
			{
				if(!IsNumber(StrChar)){
					e.stopPropagation();
					e.preventDefault();
				}
			}
			else if (MskChar == 'X')
			{
				if(!IsChar(StrChar)){
					e.stopPropagation();
					e.preventDefault();
				}
			}
			else if (MskChar == '*')
			{
				if(!IsAlphanumeric(StrChar)){
					e.stopPropagation();
					e.preventDefault();
				}
			}
            else if (MskChar == 'W')
			{
				if((!IsAlphanumeric(StrChar))&(StrChar!='.')){
					e.stopPropagation();
					e.preventDefault();
				}
			}

		}
        element.applymask=Mask;
		xAddEventListener(element,'keypress',keyListener1);
		element._mask_listener=keyListener1;
	}
	
	/**************************************************************
	AllowOnly: This function allow entering just the specified
	Expression to a textbox or textarea control.
	
	Parameters:
	Expression = Allowed characters.
	a..z => ONLY LETTERS
	0..9 => ONLY NUMBERS
	other symbols...
	
	Example: use the onKeyPress event to make this function work:
	//Allows only from A to Z
	onKeyPress="AllowOnly('a..z');"
	
	//Allows only from 0 to 9
	onKeyPress="AllowOnly('0..9');"
	
	//Allows only A,B,C,1,2 and 3
	onKeyPress="AllowOnly('abc123');"
	
	//Allows only A TO Z,@,#,$ and %
	onKeyPress="AllowOnly('a..z|@#$%');"
	
	//Allows only A,B,C,0 TO 9,.,,,+ and -
	onKeyPress="AllowOnly('ABC|0..9|.,+-');"
	
	Remarks: Use the pipe "|" symbol to separate a..z from 0..9 and symbols
	
	Returns: None
	***************************************************************/
	
	this.applyAllowOnly=function(element,Expression){
		var keyListener2=function (){
			Expression="";
						
			for (var i=0; i<element.attributes.length;i++){				
				intAtt=element.attributes[i];		
				//alert(intAtt.name.toLowerCase());
				switch (intAtt.name.toLowerCase()){
					case 'allowonly':
						Expression=intAtt.value;
					break;							
				}
			}
			
			var e=new xEvent(arguments[0]);
			if (e.keyCode==8)
			return;
			
			Expression = Expression.toLowerCase();
			Expression = Replace(Expression, 'a..z', 'abcdefghijklmnopqrstuvwxyz');
			Expression = Replace(Expression, '0..9', '0123456789');
			Expression = Replace(Expression, '|', '');
			Expression = Replace(Expression, '.', '.,');		
		
			var ch = String.fromCharCode(e.keyCode);
			ch = ch.toLowerCase();
			Expression = Expression.toLowerCase();
			var a = Expression.indexOf(ch);
			if (a == -1){
				e.stopPropagation();
				e.preventDefault();
			}
			else{
				if (Chr(e.keyCode)==','){
					e.stopPropagation();
					e.preventDefault();
					e.target.value+='.';
				}
			}
		}
		xAddEventListener(element,'keypress',keyListener2);
	}
	
	
	
	this.extendsForm=function(form){		
		this._elm=form;
		
		var node=null;
		for (var j=0;j<this._elm.elements.length;j++){
			node=this._elm.elements.item(j);
			for (var i=0; i<node.attributes.length;i++){				
				intAtt=node.attributes[i];		
				switch (intAtt.name.toLowerCase()){
					case 'applymask':					
						this.applyMask(node,intAtt.value);
					break;  
					case 'allowonly':
						this.applyAllowOnly(node,intAtt.value);
					break;						
				}
			}
		}
	}
	// :D:D q sio
	if (xDef(form))
		this.extendsForm(form);

}