// JavaScript Document
/*
* Função:	
*	Mask_IsValidChar 
*	 Verifica se o caracater da máscara é um caracater curinga .
* Parâmetros: 
*	maskChar = caracter da posição atual da máscara.
* Retorno:
*	true no caso de ser um caracter curinga OU false se não for um caracter curinga.
* Observações:
*	Um caracter curinga se trata de uma posição da mascara onde o usuário  pode inserir um caracter 
*	No caso de mudança nesta função as mesmas regras deverão ser aplicadas na função Mask_ExecuteRegexPerChar	 	
*/
function Mask_IsValidChar(maskChr) //Verifica se o caracter digitado corresponde a um caracter válido da mascara
{
	var ret; 
	ret=false;
	if (maskChr == '9') ret=true; 	// aceita número /^[0-9]$/
	if (maskChr == '$') ret=true; 	// aceita número, virgula e ponto	 /^[0-9,.]$/; 
	if (maskChr == 'C') ret=true; 	// aceita número, virgula 		 /^[0-9,]$/; 	
	if (maskChr == 'a') ret=true;	// Aceita somente letras; Converte a letra para minúscula   /^[a-zA-Z]$/;
	if (maskChr == 'A') ret=true;	// Aceita somente letras; Converte a letra para maiúscula   /^[a-zA-Z]$/;
	if (maskChr == '?') ret=true;	// Aceita letras minúscula, maiúscula, numero;  espaço, caracteres válidos   /^[a-zA-Z0-9 !@$%&*()?><::,.]$/; 
	if (maskChr == '!') ret=true;	// Aceita letras minúscula, maiúscula, numero;  espaço	/^[a-zA-Z0-9 ]$/;	
	
 	return ret;
}
/*
* Função:	
*	Mask_ExecuteRegexPerChar 
*	 Executa a expressão regular referente ao tipo passado em maskChar.
* Parâmetros: 
*	chr = caracter a ser inserido (não o código ascii).
*	maskChar = caracter curinga da posição atual da máscara.
* Retorno:
*	o caracter se a entrada for válida ou 'false' se inválida.
* Observações:
*	o retorno do valor 'false' está entre string devido o espaco ser tratado com o valor boolean false;	
*	No caso de mudança nesta função as mesmas regras deverão ser aplicadas na função Mask_IsValidChar	 	
*/
function Mask_ExecuteRegexPerChar (chr, maskChar){

	var regxTipo; // Onde ... é a expressão regular apropriada
	regxTipo='';

		switch (maskChar) 
		{
			case '9':
				regxTipo=/^[0-9]$/;  
				break;
			case 'a':
			case 'A':
				regxTipo=/^[a-zA-Z]$/;
				if (maskChar == 'A') 
					chr=chr.toUpperCase(); 
				else
					chr=chr.toLowerCase(); 	
				break;
			case '?':
				regxTipo=/^[a-zA-Z0-9 !@$%&*()?><::,.]$/; 
				break;
			case '$':
				regxTipo=/^[0-9,.]$/; 
				break;		
			case 'C':
				regxTipo=/^[0-9,]$/; 
				break;					
			case '!':
				regxTipo=/^[a-zA-Z0-9 ]$/;
				break;
		}

	if ((chr!='') && (regxTipo!=''))
	{
		if( regxTipo.test(chr)) //executa a expressao regular
		{
			return chr;//retorna o caracter aprovado pela máscara 
		}else{
			return 'false'; //O espaco retorna o mesmo valor boolean false	
		}
	}else{
		return 'false';	  //O espaco retorna o mesmo valor boolean false			
	}
}

/*
* Função:	
*	Mask_GetOnKeyPress 
*	 Captura a tecla digitada pelo usuário.
* Retorno:
*	retorna o código  ASCII da tecla digitada.
*/
function Mask_GetOnKeyPress(){
	var ascii;
	if (document.all)
	{
		ascii = event.keyCode;
    }else{
		ascii = evt.which;
    }	
	return ascii;
}
/*
* Função:	
*	Mask_IsValidkey 
*	 verifica se a tecla digita pelo usuário poderá ser tratado pela mascara.
* Retorno:
*	retorna o código ASCII da tecla digitada OU o 'false' para teclas inválidas.
* Observação:
*	16 = SHIFT; 20 CAPS LOCK ; 9=TAB ; 35-40 =direcionais((home,end,cima,baixo...)
*/
function Mask_IsValidkey()
{
	var ascii;
	ascii= Mask_GetOnKeyPress(); 
//	alert(ascii);
	if ( (ascii==9) ||(ascii==16) || (ascii==20) || ((ascii>=35) && (ascii<=40)) )
		{
			return 'false'; //O espaco retorna o mesmo valor boolean false	
		}else{
			return ascii;
		}

}
/*
* Função:	
*	Mask_ReplaceChar 
*	 Subististui um caracter por um outro caracter ou texto .
* Parâmetros: 
*	str = string a ser tratada.
*	pos = posição do caracter na string a qual será substituido.
* 	text = caracter ou texto a ser inserido
* Retorno:
*	retorna um  nova String.
*/
function Mask_ReplaceChar(str,pos,text)
{
	return str.substring(0, pos)+text+str.substring(pos+1,str.length);
}
/*
* Função:	
*	Mask_InsertChar 
*	 Insere  um caracter por um outro caracter ou texto .
* Parâmetros: 
*	str = string a ser tratada.
*	pos = posição do caracter na string a qual será inserido.
* 	text = caracter ou texto a ser inserido
* Retorno:
*	retorna um  nova String.
*/
function Mask_InsertChar(str,pos,text)
{
	return str.substring(0, pos)+text+str.substring(pos,str.length);//substitui o caracter pela tecla pressionada
}

/*
* Função:	
*	mask_onChange 
*	 Função responsavel por formatar um valor de input através de uma mascara.
* Parâmetros: 
*	mask = mascara a ser tratada. 
*	obj = Objeto de input.
*Observação:  
*	O campo length tem a função de definir a mascara baseado-se no tamanho, onde pegará o primeiro caracter e duplicará ate chegar ao tamanho definido da máscara .
*	Caso o campo length for definido  será ignorado os outros curingas da mascara e será levado em conta apenas o primeiro caracter.
*/
function mask_onchange(obj,mask) //onchange
{

	if (obj.value) //verifica  se campo está vazio
	{	
		var array_value,array_mask,pos_letra,pos_fmt,newString;
		newString='';
		

		array_mask=mask.split("");//mascara da string
		array_value=obj.value.split("");//string a ser tratada
		pos_letra=0; //contador da posição da atual da string

		for (pos_fmt=0;pos_fmt<mask.length;) //percorre a mascara
		{
			if (array_value[pos_letra]) //verifica se é o fim da string
			{
				if (Mask_IsValidChar(array_mask[pos_fmt])) //verifica se é um curinga
				{
					charEX= Mask_ExecuteRegexPerChar (array_value[pos_letra],array_mask[pos_fmt]);
					if (charEX != 'false')// false é uma string. Motivo que o valor boolean false é igual a espaço
					{
						newString=newString+charEX;
						pos_fmt++; //incrementa o contador da posicao do formato
					}
					pos_letra++; //incrementa o contador da posicao da string //incrementa ate achar um caracter que atenda ao curinga
				}else{//Não é um curinga 
					if (array_mask[pos_fmt]==array_value[pos_letra])
					{//caso se for uma caracter de marcação incrementa para ir para o proximo caracter
						pos_letra++;
					}
					pos_fmt++;
				}
						
				if (array_mask[pos_fmt]) //verifica o formato da proxima letra
				{
					if (! Mask_IsValidChar(array_mask[pos_fmt])) //se for uma marcador insere
					{
						newString=newString+array_mask[pos_fmt];
					}
				}
			}else{
				pos_fmt=mask.length+1; //Fim do For que percorre a mascara;
			}
		obj.value=newString;
		}
	}
}

function mask_onkeydown(obj,mask,blankChar)
{
	Key_Press=Mask_IsValidkey();//captura a tecla pressionada
	ret=true;
	
	if (event.shiftKey) {
		if (Key_Press=="false")
			{
				return true
			}	 
	}
//	if (Key_Press==17) {	//bloqueia a tecla control
		//alert("Não é permitido o uso da Tecla Ctrl");
		//return false;
	//}
	var isSelected=false;	
	if (isSelectedText()) {//verifica se esta mais de um caracter selecioando
		var s=GetSelectedText();
		isSelected=true;	
		GetPosCursorStart = Number(GetPosCursor(obj)-s.length+1); //captura a possicao inicial atual do cursor da String selecionada
		GetPosCursorEnd=GetPosCursor(obj); //captura a possicao fianl atual do cursor na String
		
		if ((Key_Press!=46) &&(Key_Press!=8)&&(Key_Press!="false"))
			{
				Key_Press="Del";
			}
	}else{
		GetPosCursorEnd=GetPosCursor(obj); //captura a possicao fianl atual do cursor na String
		GetPosCursorStart=GetPosCursorEnd;	//captura a possicao inicial atual do cursor na String	
	}
	var newString,pos_fmt,GetPosCursorStr,ret;
	newString='';
	
	if (!blankChar) blankChar='0';//caso não for inserido irá subistituir os caracter apagado por 0
	

			
	if (obj.value.length >= mask.length ) //mostra a mascara
	{//altera valor que estiver na mascara
		switch (Key_Press) 
		{
			case "false": 
				ret=true; //tecla habilida teclas direcionais
				break;
			case 8: //tecla back-space	
					ret=false;
					for (i_CursorStr= GetPosCursorStart; i_CursorStr<=GetPosCursorEnd;i_CursorStr++) 
					{

						if(Mask_IsValidChar(mask.charAt(i_CursorStr-1)))//VERIFICA A POSICAO ANTERIOR
						{
							obj.value=Mask_ReplaceChar(obj.value,i_CursorStr-1,blankChar);
							SetCursorPos(obj,GetPosCursorStart-1);
						}else{
								if (GetPosCursorStart == GetPosCursorEnd) { //passa se não tiver selecionado duas mais de 1 letra								
									if(Mask_IsValidChar(mask.charAt(i_CursorStr-2)))//VERIFICA A POSICAO ANTERIOR
									{
										obj.value=Mask_ReplaceChar(obj.value,i_CursorStr-2,blankChar);
										SetCursorPos(obj,GetPosCursorStart-2);
									}						 
								}
							}
					}
				break; 
			case 46:
			case "Del": //tecla back-space					
						if(	Key_Press == 46) {
								ret=false; //anula o pressionar da tecla
						}				

						if (!isSelected) {//passa se não tiver selecionado duas mais de 1 letra	
							for (i=GetPosCursorEnd;i<mask.length;i++)
							{
								if(Mask_IsValidChar(mask.charAt(i)))//VERIFICA A POSIÇÃO  ATUAL
								{
									if(obj.value.charAt(i)!=blankChar) 
									{
										obj.value=Mask_ReplaceChar(obj.value,i,blankChar);
										SetCursorPos(obj,i);
										i=mask.length+1;
										
									}
								}
							}
						SetCursorPos(obj,GetPosCursorStart);							
						}else{
							for (i_CursorStr= GetPosCursorStart-1; i_CursorStr<GetPosCursorEnd;i_CursorStr++) 
							{	
								if(Mask_IsValidChar(mask.charAt(i_CursorStr)))//VERIFICA A POSIÇÃO  ATUAL
								{
									if(obj.value.charAt(i_CursorStr)!=blankChar) 
									{
										obj.value=Mask_ReplaceChar(obj.value,i_CursorStr,blankChar);
										
									}
								}							
							}
						SetCursorPos(obj,GetPosCursorStart-1);							
						}

				break; 				
		}

	}

 return ret;	//desabilitando ou habilitando a o pressionar da tecla
}

function mask_onkeypress(obj,mask,blankChar)
{

	var newString,pos_fmt,GetPosCursorStr,ret;
	newString='';
	
	if (!blankChar) blankChar='0';
	
	GetPosCursorStr=GetPosCursor(obj);
	Key_Press=Mask_IsValidkey();
	ret=false;
	
			
	if (  (obj.value.length < mask.length ) )//monta o campo com a mascara
	{
		charEX= Mask_ExecuteRegexPerChar (String.fromCharCode(Key_Press),mask.charAt(GetPosCursorStr));//verifica se a tecla digitada esta no formato;
		
		if (charEX != 'false') //verifica se a primeira tecla digitada é válida
		{
			newString=charEX;// valor da tecla pressionada  
			cont=1;
		}else{
			newString='';// valor da tecla pressionada  
			cont=0;
		}
		
		for (pos_fmt=cont;pos_fmt<mask.length;pos_fmt++)
		{ //tamanho máximo  do formato	
				if(Mask_IsValidChar(mask.charAt(pos_fmt))) //verifica se o caracter é para aceitar um valor
				{ 
					newString=newString+blankChar;
				}else{
					newString=newString+mask.charAt(pos_fmt);
				}
		}	
		
		obj.value=newString;
		SetCursorPos(obj,cont);
		
	}else{
		if (Key_Press!= 'false') 
			{
				charEX= Mask_ExecuteRegexPerChar (String.fromCharCode(Key_Press),mask.charAt(GetPosCursorStr));//verifica se a tecla digitada esta no formato;
				cont=0;
				
				if (charEX == 'false')
				{ //pula para o proximo caracter
					cont=1;
					charEX= Mask_ExecuteRegexPerChar (String.fromCharCode(Key_Press),mask.charAt(GetPosCursorStr+1));//verifica se a tecla digitada esta no formato;
				};
				
				if (charEX != 'false')// false é uma string. Motivo que o valor boolean false é igual a espaço
				{
					if(Mask_IsValidChar(mask.charAt(GetPosCursorStr+cont))) //verifica se o caracter é para aceitar um valor
					{
						obj.value=Mask_ReplaceChar(obj.value,GetPosCursorStr+cont,charEX);
					}
					//seta nova posição do cursor	
					if(Mask_IsValidChar(mask.charAt(GetPosCursorStr+cont+1))) //verifica se o proximo caracter é para aceitar um valor;
					{
						SetCursorPos(obj,GetPosCursorStr+cont+1);
					}else{
						SetCursorPos(obj,GetPosCursorStr+cont+2);
					}
				}else{
					ret=false;
				}
			}
	}
 return ret;	
}




/*
* Função:	
*	SetCursorPos 
*	 Função responsavel por setar a posição do cursor em um campo determinado
* Parâmetros: 
*	objField = Objeto de input.
*	pos = qual será a posição do curso. 
*/
function SetCursorPos(objField,pos)
{
	var obj = objField;
	var d = obj.createTextRange();
	d.moveStart("character",pos);
	d.moveEnd("character",-(obj.value.length-pos));
	d.select();
}

/*
* Função:	
*	SetCursorPos 
*	 Função responsavel por retornar a posição do cursor de um campo determinado
* Parâmetros: 
*	objField = Objeto de input.
* Retorno:
*	Posição do Cursor. 
*/
function GetPosCursor(objField)
{
//	******captura a posição Inicial do cursor
	objField.focus();
	var workRange=document.selection.createRange();
	objField.select();
	var allRange=document.selection.createRange();
	workRange.setEndPoint("StartToStart",allRange);
	var posStart=workRange.text.length;
	workRange.collapse(false);
	workRange.select();
	
//	SetCursorPos(objField, posStart);

	
	return posStart;
}

function FocusAndSelect(objField)
{
	var Sel = objField.createTextRange();
	Sel.moveEnd("character",objField.value.length-1);
	Sel.select();
	objField.focus();
}

function appendnote(stext){
	document.getElementById("msg").innerHTML += "<br>"+stext;
}

function GetSelectedText()
{
	var oRange = document.selection.createRange();
	return oRange.text
}

function isSelectedText()
{
	var stext ;
	stext = GetSelectedText();
	if (stext)
	{	
		//appendnote('-----------isSelectedText:true');
		return true;
	}else{
		//appendnote('-----------isSelectedText:false');
		return false;
	}
}


/*
* Função:	
*	Mask_Money 
*	 verifica se a tecla digita pelo usuário poderá ser tratado pela mascara.
* Retorno:
*	retorna o código ASCII da tecla digitada OU o 'false' para teclas inválidas.
* Observação:
*	16 = SHIFT; 20 CAPS LOCK ; 9=TAB ; 48-57 =0-9; 44=Virgula 46 = ponto
*/