//funções diversas

/**
 * Função para validar o browser.
 * Retorna uma variável boolean.
 *
 * @return IE - boolean com true = IE / false = Mozilla
 */
function validaBrowser(){
   var IE = true;
   if(window.ActiveXObject) {
      IE = true;
   }
   else {
      IE = false;
   }
   return IE;
}

//formata um valor para o formato americano
function formataNumSql(valor) {
  var vlTemp = "" + valor;
  vlTemp = vlTemp.replace(".","");
  vlTemp = vlTemp.replace(",",".");
  return vlTemp;
}

//http://www.eggheadcafe.com/articles/20031204.asp
function FormatEmptyNumber(decimalDelimiter,decimalPlaces)
{
    var preDecimal = '0';
    var postDecimal = '';
 
    for(i=0;i<decimalPlaces;i++)
    {
      if (i==0) { postDecimal += decimalDelimiter; }
      postDecimal += '0';
    }
   return preDecimal + postDecimal;
}

//http://www.eggheadcafe.com/articles/20031204.asp
function FormatClean(num)
{
     var sVal='';
     var nVal = num.length;
     var sChar='';
     
   try
   {
      for(c=0;c<nVal;c++)
      {
         sChar = num.charAt(c);
         nChar = sChar.charCodeAt(0);
         if ((nChar >=48) && (nChar <=57))  { sVal += num.charAt(c);   }
      }
   }
    catch (exception) { AlertError("Format Clean",exception); }
    return sVal;
}

//http://www.eggheadcafe.com/articles/20031204.asp
function formatNumber(num,decimalPlaces)
{       

  var minus='';
  var comma='';
  var dec='';
  var preDecimal='';
  var postDecimal='';
  
  try 
  {
   
    //formatar o valor para que fique obrigatoriamente no formato 0.00
    num = num.toFixed(2);
    num = "" + num;
    
    decimalPlaces = parseInt(decimalPlaces);
    comma = ".";
    dec = ",";
    
    if (decimalPlaces < 1) { dec = ''; }
    if (num.lastIndexOf("-") == 0) { minus='-'; }
   
    preDecimal = FormatClean(num);
    
    // preDecimal doesn't contain a number at all.
    // Return formatted zero representation.
    
    if (preDecimal.length < 1)
    {
       return minus + FormatEmptyNumber(dec,decimalPlaces);
    }
    
    // preDecimal is 0 or a series of 0's.
    // Return formatted zero representation.
    
    if (parseInt(preDecimal) < 1)
    {
       return minus + FormatEmptyNumber(dec,decimalPlaces);
    }
    
    // predecimal has no numbers to the left.
    // Return formatted zero representation.
    
    if (preDecimal.length == decimalPlaces)
    {
      return minus + '0' + dec + preDecimal;
    }
    
    // predecimal has fewer characters than the
    // specified number of decimal places.
    // Return formatted leading zero representation.
    
    if (preDecimal.length < decimalPlaces)
    {
       if (decimalPlaces == 2)
       {
        return minus + FormatEmptyNumber(dec,decimalPlaces - 1) + preDecimal;
       }
       return minus + FormatEmptyNumber(dec,decimalPlaces - 2) + preDecimal;
    }
    
    // predecimal contains enough characters to
    // qualify to need decimal points rendered.
    // Parse out the pre and post decimal values
    // for future formatting.
    
    if (preDecimal.length > decimalPlaces)
    {
      postDecimal = dec + preDecimal.substring(preDecimal.length - decimalPlaces,
                                               preDecimal.length);
      preDecimal = preDecimal.substring(0,preDecimal.length - decimalPlaces);
    }

    // Place comma oriented delimiter every 3 characters
    // against the numeric represenation of the "left" side
    // of the decimal representation.  When finished, return
    // both the left side comma formatted value together with
    // the right side decimal formatted value.
    
    var regex  = new RegExp('(-?[0-9]+)([0-9]{3})');
 
    while(regex.test(preDecimal))
    {
       preDecimal = preDecimal.replace(regex, '$1' + comma + '$2');
    }
       
  }
  catch (exception) { 
    //AlertError("Format Number",exception); 
    alert(exception);
  }
  return minus + preDecimal + postDecimal;
}

//retorna o valor de determinada propriedade (prop) de um objeto simples
function pegaValorProp(data, prop) {
  if (prop == null) return data;
  else if (typeof prop == 'function') return method(prop);
  else return data[prop];
}

function criaElemento(idRoot,tipoEle,idEle,nomeEle,valorEle,textoEle,selEle,cssEle,htmlPre) {
  /*idRoot = id do container onde os elementos serão criados (DIV)
   tipoEle = tipo do elemento a ser criado checkbox ou radio
   idEle = id base do elemento a ser criado (prefixo do elemento)
   nomeEle = nome base do elemento a ser criado (prefixo do elemento)
   valorEle = valor correspondente a propriedade value 
   textoEle = texto a ser exibido como referência ao elemento criado
   selEle = boolean, true ou false, caso o elemento deva ser marcado inicialmente
   cssEle = nome da classe CSS para o elemento
   htmlPre = texto HTML a ser inserido antes do novo elemento
   ps: elemento = elemento HTML (checkbox, option, etc)
   ps: prefixo é o nome do elemento: codPerfil, pois será concatenado com o value, ex: codPerfil1, codPerfil2
   */
  var objRoot = document.getElementById(idRoot);
  var html;
  var htmlRoot;
  var htmlTemp = '';
  
  if (objRoot) {
    if (htmlPre) htmlTemp = htmlPre;
    html = htmlTemp + "<input type='" + tipoEle + "' ";
    html += "id='" + idEle + "' ";
    html += "name='" + nomeEle + "' ";
    html += "value='" + valorEle + "' ";
    if (cssEle) html += "class='" + cssEle + "'";
    if (selEle) html += "checked ";
    //html += "><label for='" + idEle + "'>" + textoEle + "</label></br>";
		html += ">&nbsp;<span>" + textoEle + "</span><br>";
    htmlRoot = DWRUtil.getValue(idRoot, {escapeHtml:false});
    DWRUtil.setValue(idRoot,htmlRoot + html, {escapeHtml:false});
	//escapeHtml: não transformar os códigos Html, ex: <html> ficaria &lt;html&gt;
  }
}

/*Função para remover determinado elemento de um container(root).
  Não utilizado no momento, pois quando o elemento é um array está dando erro...,
 substituído temporariamente por limpaElemento.
*/
 
function removeElemento(idRoot, nomeEle) {
  var objRoot = document.getElementById(idRoot);
  var obj;
  var array = false;
  var totObj = 0;
  var cont = 0;
  if (objRoot) {
    obj = document.getElementsByName(nomeEle);
    array = isArray(obj);
    if (array == false) {
      objRoot.removeChild(obj);
    }
    else {
      totObj = obj.length;
      for(cont = 0;cont < totObj; cont++) {
        alert('passou: ' + cont);
        objRoot.removeChild(obj[cont]);
      }
    }
  }
}

//Remove todos os elementos do container informado
function limpaElemento(idRoot) {
  var objRoot = document.getElementById(idRoot);
  while (objRoot.hasChildNodes()) {
    objRoot.removeChild(objRoot.lastChild);
  }
}

/*Função para saber se determinado objeto é um array.
  Modificar, pois .length não é um bom caminho, pois se for uma String, retornará
  o tamanho de caracteres da mesma...
*/
function isArray(obj) {
  /*if (obj instanceof Array) {
    return true;
  }
  else {
    return false;
  }*/
  return obj.length > 1 ? true : false;
}

//Função padrão para adicionar eventos as tabelas criadas
//nomeFuncao - nome da função a ser chamada ao clicar em um item da tabela
function defineAcaoTabela(options, objPai, codigo,nomeFuncao) {
  //options = objeto com conteúdo 'options' referente ao evento rowCreator
  //row = elemento row sendo criado
  var row = document.createElement("tr");
//  var codigo = options.rowData.codigo;
  var classeCss;
  var classeCssOver = "over";
  //montar cor-sim, cor-nao
  if (options.rowIndex % 2 == 0) {
  	classeCss = "par"
  }
  else {
  	classeCss = "impar";
  }
  row.className = classeCss;    
  
  if (validaBrowser()) {
    row.attachEvent("onclick", function(e)
      {
        if (nomeFuncao) {
            eval('objPai.' + nomeFuncao + '(' + codigo + ')');
        }
        else {
            objPai.carregar(codigo);    
        }
      }
    );
    //evento ao passar o mouse sobre as linhas da tabela
    row.attachEvent("onmouseover",
        function(e) {
            tabelaMouseOver(row, classeCssOver); //função 01
        }
    );                
    //evento ao sair da linhas
    row.attachEvent("onmouseout",
        function(e) {
            tabelaMouseOver(row, classeCss); //função 01
        }
    );                
  }
  else {
   row.addEventListener("click", function(e)
      {
        if (nomeFuncao) {
            eval('objPai.' + nomeFuncao + '(' + codigo + ')');
        }
        else {
            objPai.carregar(codigo);    
        }
      },
      false);
        //evento ao passar o mouse sobre as linhas da tabela
        row.addEventListener("mouseover",
            function(e) {
                tabelaMouseOver(row, classeCssOver); //função 01
            }
        , false);                
        //evento ao sair da linhas
        row.addEventListener("mouseout",
            function(e) {
                tabelaMouseOver(row, classeCss); //função 01
            }
        , false);                  
  }
  
  return row;
}

//acao para tabela no evento mouseOver
function tabelaMouseOver(row, css) {
  row.className = css;
}

//acao para tabela no evento mouseOut
function tabelaMouseOut(row, css) {
  row.className = css;
}

	//retorna um array com os valores (value dos elementos HTML)
	defineItens = function(nomeBase){
		//nomeBase = nome dos elementos HTML que serão utilizados
		//retorna todos os elementos com o nome perfil
		var arr = document.getElementsByName(nomeBase);
		var lista = [];//array que terá os perfis selecionados
		var tot;
		for(tot = 0; tot < arr.length; tot++){
			//verificar se o objeto foi selecionado (checked)
			if(arr[tot].checked){
				//acrescentar baseando-se no total da lista
				lista[lista.length] = arr[tot].value;
			}
		}
		return lista;
	}
	
	//marcar os itens de acordo com a lista, baseando-se no campo value
	preencheItens = function(nomeBase, lista){
		if(lista) {
			var arr = document.getElementsByName(nomeBase);
			var tot;
			var totLista;
			desmarcaItens(nomeBase);
			for(totLista = 0; totLista < lista.length; totLista++){
				for(tot = 0; tot < arr.length; tot++){
					if(arr[tot].value == lista[totLista]){
						arr[tot].checked = true;
						break;
					}
				}		
			}
		}
	}
	
	//desmarcar os objetos (checked = false)
	desmarcaItens = function(nomeBase){
		var arr = document.getElementsByName(nomeBase);
		var tot;
		for(tot = 0; tot < arr.length; tot++){
			arr[tot].checked = false;
		}				
	}

	//limpar mensagens de erro no formulário
	limparErro = function() {
		var obj = document.getElementsByTagName('span');
		for (tot = 0; tot < obj.length; tot++) {
			if (obj[tot].id.indexOf('Err') > 0) {
				DWRUtil.setValue(obj[tot].id, '');
			}
		}
	}
	
	/**
	* Envia foco primeiro campo disponível.
	* Pode receber como parâmetro um objeto com uma das propriedades:
	* form = id do formulário que será utilizado para enviar foco para o primeiro campo do mesmo
	* campo = id do elemento HTML que receberá o foco.
	* Se não houver parâmetro, então o primeiro campo disponível na página receberá o foco.
	* Ex de chamadas:
	* enviaFoco(); 
	* enviaFoco({form:'idDoFormulario'});
	* enviaFoco({idCampo:'idDoElementoHTML'});
	*/
	function enviaFoco(elemento){
		var objArray;
		var obj;
		if (!elemento) { //se não recebeu parâmetros
			objArray = document.getElementsByTagName("input");
			if (objArray) {
				obj = campoFoco(objArray);
			}
		}
		else {
			if (elemento.idCampo) { //se recebeu parâmetro com id do campo
				obj = document.getElementById(elemento.idCampo);
			}
			else if (elemento.form) { //se recebeu parâmetro com id do formulário
				objArray = document.getElementById(elemento.form);
				if (objArray) {
					obj = campoFoco(objArray);
				}
			}
		}
		//se encontrou o objeto, envia o foco
		if (obj) {
			obj.focus();
		}
	}
	/**
	* Retorna o primeiro campo de uma coleção HTML que não seja do tipo Hidden (possa receber Foco).
	*/
	function campoFoco(objArray) {
		var ret;
		for (i = 0; i < objArray.length; i++) {
			if (objArray[i].type) {
				if (objArray[i].type == 'text' || objArray[i].type == 'password' || 
							objArray[i].type.indexOf('select') > -1) {
					ret = objArray[i];
					break;
				}
			}
		}	
		return ret;
	}
	
	//exibe as mensagens de erro de cada campo
	/**
	 * Preencher os campos informando os problemas na validação. Os elementos HTML devem estar com a nomenclatura:
	 * propriedadeErr, ex: pesCodigoErr, pefNomeErr
	 * @param {Object} obj - objeto InvalidValue
	 */
	function exibeValidacao(obj) {
		var temp; //conteúdo temporário do elemento
		limparErro();
		for (atu = 0; atu < obj.length; atu++) {
			//verificar se há necessidade de concatenar as mensagens para o campo, quando houve mais de uma mensagem de erro
			if (obj[atu]) {
				temp = DWRUtil.getValue(obj[atu].propertyName + 'Err');
				if (temp != '') {
					temp += ', ';
				}
				//localizar o elemento que representa a mensagem de erro do campo
				DWRUtil.setValue(obj[atu].propertyName + 'Err', temp + obj[atu].message);				
			}
		}
	}	
	
	//
	//função que simula o Trim do Java
	//retira os espaços das extremidades do texto
	function trim(str){
		str=str.replace(/\s+/g," ");
		str=str.replace(/^ /,"");
		str=str.replace(/ $/,"");
		return str;
	}	

/**
 * Retorna boolean se um determinado texto é numérico ou não
 * @param {Object} sText
 */
function IsNumeric(sText)
{
   var ValidChars = "0123456789";
   var IsNumber = true;
   var Char;
 
   for (i = 0; i < sText.length && IsNumber == true; i++) 
      { 
      Char = sText.charAt(i); 
      if (ValidChars.indexOf(Char) == -1) 
         {
         	IsNumber = false;
         }
      }
   return IsNumber;
}

/**
 * Retorna se um determinado texto é numérico ou não, pelo evento keypress
 */
function CheckKeyCode()
{
	alert('teste');
  if( (event.keyCode == 189 || event.keyCode == 109) ||
      (event.keyCode >= 48 && event.keyCode <= 57) || 
      (event.keyCode >= 96 && event.keyCode <= 105) ) {
    return true; 
	}
  else {
    return false;
  }
}	

/**
 * Função para adicionar eventos em elementos HTML: window, input, etc.
 * @param {Object} obj - objeto principal a ter a função adicionada
 * @param {Object} evType - tipo do evento: load, blur
 * @param {Object} fn - função javascript a ser adicionada no evento
 * Não compatível com IE rodando em sitemas Macintosh
 */
/*function addEvent(obj, evType, fn)
{
    if (obj.addEventListener)
    {
       obj.addEventListener(evType, fn, false);
       return true;
    }
    else if (obj.attachEvent)
    {
       var r = obj.attachEvent("on"+evType, fn);
       return r;
    } 
    else
    {
       return false;
    }
}*/

/**
 * Função para remover um evento de um elemento HTML
 * @param {Object} obj - objeto principal a ter a função removida
 * @param {Object} evType - tipo do evento: load, blur
 * @param {Object} fn - função javascript a ser adicionada no evento
 * @param {Object} useCapture
 */
/*function removeEvent(obj, evType, fn, useCapture){
	if (!useCapture) useCapture = false;
  if (obj.removeEventListener){
    obj.removeEventListener(evType, fn, useCapture);
    return true;
  } else if (obj.detachEvent){
    var r = obj.detachEvent("on"+evType, fn);
    return r;
  } else {
    alert("Handler could not be removed");
  }
}*/