/*********** SCRIPT PARA ABRIR POPUP ***********/
function MM_openBrWindow(theURL,winName,features) {
  window.open(theURL,winName,features);
}
/*********** SCRIPT PARA COMBO TER O COMPORTAMENTO DE LINK ***********/
function MM_jumpMenu(targ,selObj,restore){ //v3.0
  eval(targ+".location='"+selObj.options[selObj.selectedIndex].value+"'");
  if (restore) selObj.selectedIndex=0;
}
/**
 *  Retorna "true" se e somente se o parâmetro "method" do
 *  form passado existir e conter um valor com tamanho maior
 *  do que 0.
 */
function podeEnviar(form) {
    var elem = form.elements['method'];
    return (elem && elem.value.length > 0);
}

/**
 *  Verifica se existe ao menos um elemento selecionado num array de
 *  radio buttons ou check boxes, ou num select
 *
 *  @param      nome string nome do radio button ou check box
 *  @return     true se ao menos um elemento estiver selecionado
 */
function existeSelecionado(nome) {
    var f = document.forms[0];
    var elementos = f.elements[nome];
	
	if (elementos) {
        // se for um select
        if (elementos.options) {
            for (var i = 0; i < elementos.options.length; i++) {
                if (elementos.options[i].selected) {
                    return true;
                    break;
                }
            }
        // Se for um array de elementos
        } else if (elementos.length) {
            for (var i = 0; i < elementos.length; i++) {
                if (elementos[i].checked) {
                    return true;
                    break;
                }
            }
        // Se for um só elemento
        } else {
            return elementos.checked;
        }
    }
    return false;
}

/**
 *  Verifica se existe ao menos um elemento selecionado num array de
 *  radio buttons, check boxes ou em um select.
 *
 *  @param      nome string nome do radio button ou check box
 *  @return     true se ao menos um elemento estiver selecionado
 */
function existeCampoSelecionado(form, campo) {
    var selecionado = false;
	
	if (form.elements[campo]) {
        // se for um select
        if (form.elements[campo].options) {
            for (var i = 0; i < form.elements[campo].options.length; i++) {
                if (form.elements[campo].options[i].selected) {
                    return true;
                    break;
                }
            }
        // Se for um array de elementos
        } else if (form.elements[campo].length) {
            for (var i = 0; i < form.elements[campo].length; i++) {
                if (form.elements[campo][i].checked == true) {
                    return true;
                }
            }
        // Se for um só elemento
        } else {
            return form.elements[campo].checked;
        }
    }
    return false;
}

/**
 *  Verifica se os campos estão preenchidos
 *  @param paresCampoMsg 	 	array de pares no formato nomeCampo1, msgErro1, ...
 *  @return 	alert com msg passada na string
 */
function camposEstaoPreenchidos(paresCampoMsg) {
	var campo;
	var msg;
	var retorno = true;
	
	for (var i = 0; i < paresCampoMsg.length; i += 2) {
	    campo = paresCampoMsg[i];
	    msg = paresCampoMsg[i + 1];
		if (trim(document.forms[0].elements[campo].value) == '') { 
		    alert(msg);
			retorno = false;
			break;
		}
	}
	return retorno;
}


/**
 *  Imita o método "trim()" da classe "String" do Java
 */
function trim(s) {
    var comeco = '';
	var fim = '';
    var encontrouPrimeiroChar = false;
    var encontrouUltimoChar = false;
	var retorno = '';
	
    if (s) {
	    if (s.length != null && s.length > 0) {
		    // Garante que a string tenha quantidade par de caracteres
		    if (s.length % 2 == 1) {
			    s += ' ';
			}
	        for (var i = 0, j = s.length - 1; i < j; i++, j--) {
		        if (s.charAt(i) != ' ') {
    			    encontrouPrimeiroChar = true;
				    comeco += s.charAt(i);
				} else if (encontrouPrimeiroChar) {
				    comeco += s.charAt(i);
				}
		        if (s.charAt(j) != ' ') {
    			    encontrouUltimoChar = true;
				    fim = s.charAt(j) + fim;
				} else if (encontrouUltimoChar) {
				    fim = s.charAt(j) + fim;				    
				}
		    }
		} else {
		    comeco = '';
			fim = '';
		}
  	    retorno = comeco + fim;
	}
	return retorno;
}

/**
*	trim2... mais facil e pratico =]
*/
function trim2(inputString) {
   // Removes leading and trailing spaces from the passed string. Also removes
   // consecutive spaces and replaces it with one space. If something besides
   // a string is passed in (null, custom object, etc.) then return the input.
   if (typeof inputString != "string") { return inputString; }
   var retValue = inputString;
   var ch = retValue.substring(0, 1);
   while (ch == " ") { // Check for spaces at the beginning of the string
      retValue = retValue.substring(1, retValue.length);
      ch = retValue.substring(0, 1);
   }
   ch = retValue.substring(retValue.length-1, retValue.length);
   while (ch == " ") { // Check for spaces at the end of the string
      retValue = retValue.substring(0, retValue.length-1);
      ch = retValue.substring(retValue.length-1, retValue.length);
   }
   while (retValue.indexOf("  ") != -1) { // Note that there are two spaces in the string - look for multiple spaces within the string
      retValue = retValue.substring(0, retValue.indexOf("  ")) + retValue.substring(retValue.indexOf("  ")+1, retValue.length); // Again, there are two spaces in each of the strings
   }
   return retValue; // Return the trimmed string back to the user
}



/**
 *  Habilita tags
 *
 *  @param statusHabilita   true para habilitar, false para desabilitar
 *  @param nomesTags        array de nomes de tags
 */
function habilitaTags(statusHabilita, nomesTags) {
    var tags;
	var nomeTag;
	
	for (var i = 0; i < nomesTags.length; i++) {
		nomeTag = nomesTags[i];
		document.forms[0].elements[nomeTag].disabled = !statusHabilita;
	}
}


/**
 *  Limpa tags
 *
 *  @param statusHabilita   true para habilitar, false para desabilitar
 *  @param nomesTags        array de nomes de tags
 */
function limpaTags(nomesTags) {
	var nomeTag;
	
	for (var i = 0; i < nomesTags.length; i++) {
		nomeTag = nomesTags[i];
		document.forms[0].elements[nomeTag].value = '';
	}
}


/**
 *  Valida o novo pré-requisito clínico antes de tentar criar
 *
 *  @param nomeTipoStr  nome da tag com nome do tipo de pré-requisito clínico
 *  @param paramAlfaStr nome da tag que diz se é parâmetro alfanumérico
 *  @param paramNumStr  nome da tag que diz se é parâmetro numérico
 *  @param minAceitavelStr  nome da tag que contém o valor mínimo aceitável
 *  @param maxAceitavelStr  nome da tag que contém o valor máximo aceitável
 *  @param msgPreenchaNomeTipo
 *  @param msgSelecioneParamAlfaOuParamNum
 *  @param msgPreenchaMinAceitavel
 *  @param msgPreenchaMaxAceitavel
 *  @param msgNaoNumeroValidoMinAceitavel
 *  @param msgNaoNumeroValidoMaxAceitavel
 *  @param msgMinDeveSerMenorIgualMax
 *  @return true se os valores máximo e mínimo forem válidos
 */
function validaTipoPreRequisitoClinico(nomeTipoStr, paramAlfaStr, paramNumStr,
        minAceitavelStr, maxAceitavelStr,
        msgPreenchaNomeTipo, msgSelecioneParamAlfaOuParamNum, 
        msgPreenchaMinAceitavel, msgPreenchaMaxAceitavel, 
        msgNaoNumeroValidoMinAceitavel, msgNaoNumeroValidoMaxAceitavel, 
        msgMinDeveSerMenorIgualMax) {
    var f = document.forms[0];
    var nomeTipo = f.elements[nomeTipoStr];
    var paramAlfa = f.elements[paramAlfaStr];
    var paramNum = f.elements[paramNumStr];
	var minAceitavel = f.elements[minAceitavelStr];
	var maxAceitavel = f.elements[maxAceitavelStr];
	var valido = false;
    var selecionouParamAlfaOuParamNum = paramAlfa.checked || paramNum.checked;
    var selecionouParamNum = paramNum.checked;
	
    if (camposEstaoPreenchidos(new Array(nomeTipoStr, msgPreenchaNomeTipo))) { 
        if (selecionouParamAlfaOuParamNum) {
            // Selecionou parâmetro numérico
            if (selecionouParamNum) {
                if (camposEstaoPreenchidos(new Array(minAceitavelStr, msgPreenchaMinAceitavel))) { 
                    if (camposEstaoPreenchidos(new Array(maxAceitavelStr, msgPreenchaMaxAceitavel))) { 
                        if (isNaN(minAceitavel.value)) {
                            alert('\'' + minAceitavel.value + '\' ' + msgNaoNumeroValidoMinAceitavel);
                        } else if (isNaN(maxAceitavel.value)) {	
                            alert('\'' + maxAceitavel.value + '\' ' + msgNaoNumeroValidoMaxAceitavel);
                        } else if (parseFloat(minAceitavel.value) > parseFloat(maxAceitavel.value)) {
                            alert(msgMinDeveSerMenorIgualMax);
                        } else {
                            valido = true;
                        }
                    }
                }
            // Selecionou parâmetro alfanumérico, tá tudo bem
            } else {
                valido = true;
            }
        } else { 
            alert(msgSelecioneParamAlfaOuParamNum);
        }
    }
	return valido;
}


//  Impede a entrada de caracteres não numéricos em input:text Numeros,pontos e backspace permitidos
function bloquearNaoNumeros(evt){
	/* var charCode = getKeyCode(evt);
    if ((charCode < 48 || charCode > 57) && charCode != 8 && charCode != 46 && charCode != 9) return false;
    return true;*/
	var reNumeroChar = /\d/;	// Expressao regular pra validar um caractere com numero ou ponto(.) 
	var reNumeroString = /^[\-]?\d*[\.]?\d*$/;	// Expressao regular pra validar string com numeros decimais
	return checkKeyPress(evt,reNumeroString,reNumeroChar);
}

function bloquearNaoNumerosChange(evt){
	var reNumeroString = /^[\-]?\d*[\.]?\d*$/;
	checkChange(evt,reNumeroString);
}

//  Impede a entrada de caracteres não numéricos em input:text Apenas Numeros permitidos e teclas de escape e clipboard
function numInteiroKeyPress(evt){
	var reNumeroChar = /\d/;	// Expressao regular pra validar um caractere com numero
	var reNumeroString = /^[\-]?\d*$/;	// Expressao regular pra validar string com numeros inteiros
	return checkKeyPress(evt,reNumeroString,reNumeroChar);
}

function numInteiroChange(evt){
	var reNumeroString = /^[\-]?\d*$/;	// Expressao regular pra validar string com numeros inteiros
	checkChange(evt,reNumeroString);
}

// -------------- INICIO FUNCOES SisLU -----------------/
/**
*	@author: Allan Jones
*	obs: Qualquer duvida ou alteracao, avise-me, pois estas funções são usadas
*	em outro sistema (SisLU) também.
*/

//regular expressions

// Teclas de Escape, como Enter, Backspace, del, leftarrow, rightarrow, etc...
var teclasEscape = /[\x00\x03\x08\x09\x0D\x16\x18\x1A\x25\x26\x27\x28]/;
// Teclas de Clipboard usadas nos Ctrl da vida... Teclas são X, V, Z, C
var teclasClipboard = /[cvxz]/i;

// Retorna o código do evento de acordo com o browser
function getKeyCode(objEvent){
	return (objEvent.which) ? objEvent.which : objEvent.keyCode;
}

// Retorna o elemento que gerou o evento
function getSource(objEvent){
	return (objEvent.srcElement) ? objEvent.srcElement : objEvent.target;
}

// Checa se o evento eh um Ctrl + C, Ctrl + V, Ctrl + X ou Ctrl + Z (para browsers NS6)
function checkClipboardCode(objEvent, strKey) {
	return (objEvent.ctrlKey) ? objEvent.ctrlKey && teclasClipboard.test(strKey) : false;
}

/* Recebe o evento e se for ENTER, simula o click do botão passado.
*  Se for passado um objInput como um input de Texto por exemplo, ele só
*  executará o click do botão se o objInput.value nao for vazio. 
*/
function executaSeEnter(objEvent,botao,objInput){
	if(getKeyCode(objEvent) == 13){
		if(!objInput){
			botao.click();
			return true;
		}
		else if(objInput.value && objInput.value.length > 0){
			botao.click();
			return true;
		}
	}
}

/**
*	Método trim igual do java.lang.String sendo que é mais fácil de entender
*	Retira espaços do começo e final da String e mais de 1 espaço dentro da string
*/
function trim2(inputString) {
   // Removes leading and trailing spaces from the passed string. Also removes
   // consecutive spaces and replaces it with one space. If something besides
   // a string is passed in (null, custom object, etc.) then return the input.
   if (typeof inputString != "string") return inputString;
   var retValue = inputString;
   var ch = retValue.substring(0, 1);
   while (ch == " ") { // Check for spaces at the beginning of the string
      retValue = retValue.substring(1, retValue.length);
      ch = retValue.substring(0, 1);
   }
   ch = retValue.substring(retValue.length-1, retValue.length);
   while (ch == " ") { // Check for spaces at the end of the string
      retValue = retValue.substring(0, retValue.length-1);
      ch = retValue.substring(retValue.length-1, retValue.length);
   }
   while (retValue.indexOf("  ") != -1) { // Note that there are two spaces in the string - look for multiple spaces within the string
      retValue = retValue.substring(0, retValue.indexOf("  ")) + retValue.substring(retValue.indexOf("  ")+1, retValue.length); // Again, there are two spaces in each of the strings
   }
   return retValue; // Return the trimmed string back to the user
}

/**
*	@author: Allan Jones
*	obs: Qualquer duvida ou alteracao, avise-me, pois estas funções são usadas
*	em outro sistema (SisLU) também.
*
*	Funcao que recebe uma mascara de formato e retorna a expressao regular
*	para esse formato. Ex:
*	mascara: ##/##/@@@@ retorna um regular expression para 22/33/abcd por exemplo
*	se for passado um 'index', retorna uma regular expression para a mascara até
* 	aquele índice. Ex:
*   mascara: ##-@@/#### e index = 8 equivale a passar apenas a mascara: ##-@@/##
*	Obs: # - Indica qualquer número
*		 @ - Indica qualquer letra
*/
function makeRegEx(mascara, index){
	var regex = "^(";
	var tmp = mascara.length;
	if(index && index <= mascara.length) tmp = index;
	for(var i=0; i<tmp; i++){
		if(mascara.charAt(i) == "#") regex = regex + "\\d";
		else if(mascara.charAt(i) == "@") regex = regex + "[a-zA-Z]";
		else regex = regex + "[" + mascara.charAt(i) + "]";
	}
	regex = regex + ")$";
	return new RegExp(regex);
}

/**
*	@author: Allan Jones
*	obs: Qualquer duvida ou alteracao, avise-me, pois estas funções são usadas
*	em outro sistema (SisLU) também.
*
*	Funcao que aplica o formato da mascara passada.
*	Uso: onkeypress="return maskKeyPress(event,'##.@##@@##-@')"
*	Se for passado um botao, ele executará botao.click() se a
* 	tecla pressionada for Enter (keyCode = 13).
*/
function maskKeyPress(objEvent,mascara,botao) {
	if(!mascara) return true; // Se nao passar mascara, aceita tudo
	var iKeyCode, strKey, objInput, regex;  
	isKeyCode = getKeyCode(objEvent); // Obtém Código da Tecla pressionada
	objInput = getSource(objEvent); // Obtém o campo que disparou o evento
	strKey = String.fromCharCode(isKeyCode); // Transforma o código da tecla em um caractere
	
	if(botao){
		if(executaSeEnter(objEvent,botao)){;
			return true;
		}
	}
	// Se for tecla de escape, ou de clipboard, deixa passar...
	if(teclasEscape.test(strKey) || checkClipboardCode(objEvent, strKey)){
		return true;
	}

	// Cria uma expressão regular para a mascara passada, de acordo com o tamanho atual da entrada
	regex = makeRegEx(mascara,objInput.value.length);
	if (objInput.value.length == 0 || regex.test(objInput.value)) {
		// Se for valida a entrada atual, guardamos seu valor em objInput.validValue
		objInput.validValue = objInput.value;
		
		// Criamos uma nova expressão regular, para ver se o conjunto formado pela 
		// entrada atual + tecla pressionada é válido.
		regex = makeRegEx(mascara,objInput.value.length + 1);
		if (!regex.test(objInput.value + strKey)) {
			
			/* Se não for válido, verificamos se auxiliamos o usuário na formatação
			 inserindo automaticamente caracteres vindos da formatação como uma "/" para
			 formatos de data, ou um "-" em outros casos 	 */
			var carac = mascara.charAt(objInput.value.length);
			if(carac != "#" && carac != "@"){
				while(carac != "#" && carac != "@" && mascara.length > objInput.value.length){
					objInput.value = objInput.value + mascara.charAt(objInput.value.length);
					carac = mascara.charAt(objInput.value.length);
				}
				
				// Depois de auxiliar a insercao dos caracteres de formato, verificamos novamente o conjunto
				regex = makeRegEx(mascara,objInput.value.length + 1);
				if (regex.test(objInput.value + strKey)){
					// Se for valido, guardamos o valor valido, e deixamos passar a entrada.
					objInput.validValue = objInput.value;
					return true;
				}
			}
			return false;
		}
	}
	else {
		// Se o valor atual por algum motivo nao for valido, retorna para o ultimo valor valido armazenado
		objInput.value = (objInput.validValue) ? objInput.validValue : "";
		return false;
	}
	return true;
}

/**
*	@author: Allan Jones
*	obs: Qualquer duvida ou alteracao, avise-me, pois estas funções são usadas
*	em outro sistema (SisLU) também.
*
*	Funcao que protege o formato da mascara passado mesmo em casos
*	de Ctrl + V por exemplo.
*	Uso: onchange="maskChange(event)"
*/
function maskChange(objEvent,mascara) {
	if(!mascara) return true; // Se nao passar mascara, aceita tudo
  	var objInput = getSource(objEvent);
	var regex = makeRegEx(mascara,objInput.value.length);
  	if (objInput.value.length != 0 && !regex.test(objInput.value)) {
		objInput.value = (objInput.validValue) ? objInput.validValue : "";
		objInput.focus();
	   	objInput.select(); 
 	}
	else objInput.validValue = objInput.value;
}

/**
*	Recebe um evento, a expressao regular para o caractere digitado e a expressao regular
*	para o valor do campo como um todo. Com isso, bloqueia ou não o que foi digitado
*/
function checkKeyPress(objEvent,regExpString,regExpChar){
	var iKeyCode, strKey, objInput, regex;  
	isKeyCode = getKeyCode(objEvent); // Obtém Código da Tecla pressionada
	objInput = getSource(objEvent); // Obtém o campo que disparou o evento
	strKey = String.fromCharCode(isKeyCode); // Transforma o código da tecla em um caractere
	if (regExpString.test(objInput.value) || objInput.value == "") {
		objInput.validValue = objInput.value;
		if(teclasEscape.test(strKey) || checkClipboardCode(objEvent, strKey)) return true;
		if (!regExpChar || !regExpChar.test(strKey)){
			// Verifica se o conjunto é aceito
			if(regExpString.test(objInput.value + strKey)){
				return true;
			}
			return false;
		}
	}
	else {
		objInput.value = (objInput.validValue) ? objInput.validValue : "";
		return false;
	}
	
	// Nunca chega aki =P
	return true;
}

/**
*	Função que garante integridade do campo em caso de Ctrl + V por exemplo
*/
function checkChange(objEvent,regExpString){
	var objInput = getSource(objEvent);
	if (!regExpString.test(objInput.value)) {
		objInput.value = (objInput.validValue) ? objInput.validValue : "";
		objInput.focus();
		objInput.select(); 
	}
	else{
		objInput.validValue = objInput.value;
	}
}

/**
*	Funcionalidade existente apenas no Internet Explorer, mas também não
*	é usada no Motion pois no struts não tem o atributo "onpaste="algumacoisa""
*	na taglib de html:text
*	uso: onpaste="return checkPaste(event,new RegExp('^\d$'))"
*/
function checkPaste(objEvent,regExpString) {
	var strPasteData = window.clipboardData.getData("Text");
	var objInput = objEvent.srcElement;
	if (!regExpString.test(strPasteData)) {
		objInput.focus();
		return false;
	}
	return true;
}

/**
*	Função utilizada para selecionar um item de uma combo, através de um campo de texto
*	objEvent é o evento disparado pelo campo de texto, e combo é a combo que você deseja.
*
*/
function filtroKeyPress(objEvent,combo) {
	var objInput = getSource(objEvent); // Adquirimos o input
	strKey = String.fromCharCode(getKeyCode(objEvent)); // Adquirimos o caractere digitado
	// Se for tecla de escape ou de clipboard deixa passar
	if(teclasEscape.test(strKey) || checkClipboardCode(objEvent, strKey)) return true;
	var regex = new RegExp("^" + objInput.value + strKey,"i");
	
	// faz um iterate pela combo, procurando pelo valor do input + o que foi digitado
    for (var i=0; i < combo.options.length; i++) {
		if(regex.test(combo.options[i].text)){
			combo.options[i].selected = true;
			objInput.validValue = objInput.value + strKey;
			return true;
		}
	}
	
	// Se chegou aqui, nao achou pelo input + caractere digitado, entao procura apenas
	// pelo input e bloqueia o caractere digitado.
	regex.compile("^" + objInput.value,"i");
	for (var i=0; i < combo.options.length; i++) {
		if(regex.test(combo.options[i].text)){
			combo.options[i].selected = true;
			objInput.validValue = objInput.value;
			return false;
		}
	}
	if(!objInput.validValue) objInput.validValue = "";
	return false;
}

/**
*	Em casos de Ctrl + V por exemplo, tentamos garantir o campo.
*	Veja a função acima
*/
function filtroChange(objEvent,combo){
	objInput = getSource(objEvent);
	if(!objInput.validValue) objInput.validValue = "";
	
	// Se mudou pra string vazia, entao seleciona o primeiro item da combo
	if(trim2(objInput.value).length == 0){
		objInput.validValue = "";
		combo.options[0].selected = true;
	}
	var regex = new RegExp("^" + objInput.value, "i");
	
	// Procura o item na combo que deve ser selecionado com o input atual
	for (var i=0; i < combo.options.length; i++) {
		if(regex.test(combo.options[i].text)){
			combo.options[i].selected = true;
			objInput.validValue = objInput.value;
			return;
		}
	}
	
	// Se o input atual eh inconsistente com o valido, retorna para o valido
  	if (!regex.test(objInput.validValue)) {
		objInput.value = objInput.validValue;
		objInput.focus();
		objInput.select(); 
 	}
}
// -------------- FIM FUNCOES SisLU -----------------/

/** muda a acao do action, passando por parametro para o struts o methodo que deve ser envocado */
function executar(form, acao, lista) {
  form.action = form.action +"?method="+ acao;
  form.acao.value = acao;
  selecionarTodasListas( lista );
}

/** funcao para links de paginas que precisam ser chamadas por submit */
function executarComSubmit(form, acao, lista) {
	executar(form, acao, lista);
	form.submit();
}

/** Versão menos brain-dead do executar, que não mistura GET com POST. */
function executarPostComSubmit(form, acao, lista, ancora) {
  executarPost(form, acao, lista, ancora);
  form.submit();
}

/** Versão menos brain-dead do executar, que não mistura GET com POST. */
function executarPost(form, acao, lista, ancora, preventSubmit) {
    form.elements['method'].value = acao;
    if (lista) selecionarTodasListas(form, lista);
    if (ancora) form.action = form.action + "#" + ancora;
    if (!preventSubmit && !document.isSubmitted) {
        document.isSubmitted = true;
        form.submit();
    }
}

function goLink(form, params) {
  if(params){
	  form.action = form.action +"?" + params;
  }
  executarPost(form,form.action);
  
}

/**
 *  Cancelar a edição do formulário, chamado o método "cancelar" do action.
 *  Usa a location bar ao invés de dar submit() no formulário, para evitar
 *  que informações editadas sendo enviadas podendo causar erros.
 */
function cancelarEdicao(form) {
    //location.href = form.action + "?method=cancelar";
    executarPost(form, 'cancelar');
}

/**
 *  Copia o valor do campo "textoProcuraOld" do formulário para o campo
 *  "textoProcura".
 */
function restoreSearch(form) {
    form.textoProcura.value = form.textoProcuraOld.value;
    if (form.tipoBusca) {
        form.tipoBusca.value = form.tipoBuscaOld.value;
    }
}

/** 
 *  Versão menos brain-dead dos "ifs" hardcoded nos inputs.
 *  Pra usar essa aqui, a mensagem que aparece no alert deve estar numa
 *  variável chamada SELECT_FIELD_ERROR.
 *
 *  Depende do "verifica.js".
 */
function executaSeSelecionado(form, campo, acao, ancora, preventSubmit) {
    if (existeCampoSelecionado(form, campo)) {
        executarPost(form, acao, null, ancora, preventSubmit);
        return true;
    } else {
        alert(SELECT_FIELD_ERROR);
        return false;
    }
}

/** 
 *  Pede confirmação para o metodo excluir e faz a chamada do
 *  executar. A variável "MENSAGEM_EXCLUSAO" é definida no template. 
 */
function confirmarExclusao(form, field, ancora, naoVerifica, action) {
    var result = true;
    if (!action) action = 'excluir';
    if (!naoVerifica && !existeCampoSelecionado(form, field)) {
        alert(SELECT_FIELD_ERROR);
        return false;
    }
    result = confirm(MENSAGEM_EXCLUSAO);
    if (result) {
        executarPost(form, action, null, ancora);
    }
    return result;
}

/**
 *  Muda o valor do input chamado "pagina" para o valor passado.
 */
function setPagina(form, pag) {
    form.pagina.value = pag;
}

/**
 *  Um trim() que é uma gracinha! :-)
 *  Pra ser usado como um método de um objeto String mesmo, assim:
 *  var str2 = str1.trim();
 *
 *  Não é lindo? :-)
 */
String.prototype.trim = function() {
    var str = this.replace(/^\s*/, "");
    str = str.replace(/\s*$/, "");
    return str;
}

/** muda a acao do action, passando por parametro para o struts o methodo que deve ser envocado */
function callAtualizar(form, ancora) {
  form.action = form.action +"?method=atualizar&#"+ ancora;
  form.acao.value = "atualizar";
}

/** funcao usada nas listas onde a execucao é no onChangee e nos links do sistema onde precisa de submit*/
function selecionar(form, acao) {
  executar(form, acao);
  form.submit();
}

/** muda a acao do action, passando por parametro para o struts o methodo que deve ser envocado fazendo antes a selecao de todos os itens dos listbox abertos */
function selecionarTodasListas(form, lista) {
    lista = lista.split(",");
    for (var i = 0; i < lista.length; i++) {
        selectAll(form.elements[lista[i]]);
    }
}
  
/**
 *	Função para ser usada no evento "OnChange()" de objetos SELECT, com o intuito
 *	de serem usados para redirecionamento de páginas. O atributo "VALUE" deve ser
 *	a URI para onde quer-se mandar o usuário.
 */
function redir( obj ) {
    document.location.href = obj[obj.selectedIndex].value;
}

/** Wrapper pra função de voltar no history. */
function voltar() {
    history.go(-1);
}

/**
 *	Recebe um objeto do tipo "select" (uma lista em um form), limpa ele, e coloca
 *	o conteúdo do vetor "nomes" na sua lista, com os valores designados em "valores".
 */
function montaSelect( obj, nomes, valores ) {

    obj.options.length = nomes.length;

    for (var i = 0; i < nomes.length; i++) {
        obj.options[i].text = nomes[i];
        obj.options[i].value = valores[i];
    }

}

/**
 *	Adiciona a(s) opção(ões) selecionada(s) no select "src" ao select "dest".
 *	Se "delsrc" for "true", apaga a opção no select "src".
 */
function addOption( src, dest, delsrc ) {

 /*   for (var i = 0 ; i < src.length ; i++)
	{
		//if (src.options) alert('Achei um select - ' + i);
		//else alert('Achei um Hidden - ' + i);
		
	}*/
	
	if ( src.selectedIndex == -1 ) return;

    var opts = new Array();
    for (var i = 0; i < src.options.length; i++ )
	{
		if ( src.options[i].selected ) {
			opts[opts.length] = new Option('', '', false, true);
			opts[opts.length-1].text = src.options[i].text;
			opts[opts.length-1].value = src.options[i].value;
			if ( delsrc && src.options[i].value != '0' ) {
				src.options[i] = null;
				i--;
			}
		}
	}

    // procura nos options existentes em dest se já não existe a opção,
    // senão insere uma opção
    for (var i = 0; i < opts.length; i++) {

        var achou = false;
        for (var j = 0; j < dest.options.length; j++) {
            if ( dest.options[j].text == opts[i].text &&
                 dest.options[j].value == opts[i].value ) {
                achou = true;
                break;
            }
        }
        if (!achou) dest.options[ dest.options.length ] = opts[i];

    }

}

/** Remove a opção selecionada de um select. */
function removeOption( obj ) {
    if ( obj.selectedIndex == -1 ) return;

    for ( var i = 0; i < obj.options.length; i++ ) {
        if ( obj.options[i].selected ) {
            obj.options[i] = null;
            i--;
        }
    }
}

/** Seleciona todos os itens de um select ou de uma lista de checkboxes. */
function selectAll(obj) {
    if (obj.options) {
        for (var i = 0; i < obj.options.length; i++) {
            obj.options[i].selected = true;
        }
    } else if (obj.length) {
        for (var i = 0; i < obj.length; i++) {
            obj[i].checked = true;
        }
    } else {
        obj.checked = true;
    }
}

/**
 *  Adiciona uma nova opção ao objeto select passado, caso não
 *  exista já uma opção com o mesmo valor.
 */
function addNewOption( select, valor ) {
    valor=valor.trim();
	if (valor.length < 1) return;
	
	var opt = new Option( valor, valor + '(novo)', false, false );
    var achou = false;

    for ( var i = 0; i < select.options.length; i++ ) {
        if ( select.options[i].value == opt.value ||
             select.options[i].text == valor) {
            achou = true;
            break;
        }
    }

    if ( !achou ) select.options[ select.length ] = opt;

}



/**
 *  Manda página para impressão
 */
function imprimir()
{
  if (window.print != null) 
  {
    window.print(); 
  } 
  else 
  { 
    alert('Infelizmente seu browser n&atilde;o suporta essa facilidade. Selecione Imprimir do Menu Arquivo ou pressione - Ctrl+P - no teclado.'); 
  }
}

/**
 * Seta o elemento itemIndex da página e chama o executarPost.
 * Método serve para situações onde há um botão de comando para cada item de uma lista.
 */
function executarIndexPost(form, acao, lista, ancora, preventSubmit, index) {
    if (index) form.itemIndex.value = index;
    if (index == 0) form.itemIndex.value = 0;
	executarPost(form, acao, lista, ancora, preventSubmit);
}

/**
 * Coloca o focus no primeiro campo da página para o usuário.
 * utilize assim: <body onLoad="placeFocus();">
 */
function placeFocus() {
	if (document.forms.length > 0) {
		var field = document.forms[0];
		for (i = 0; i < field.length; i++) {
			if ((field.elements[i].type == "text") || (field.elements[i].type == "textarea") || (field.elements[i].type.toString().charAt(0) == "s")) {
				document.forms[0].elements[i].focus();
				break;
         	}
	   	}
	}
}

function submitForm ()
	{ 
	if(document.form.marca != null)
		document.form.marca.value="";
	document.form.submit();
	}

/******************* SCRIPT DA HOME *********************/
var mfBanners = [
				 

['wap.php', '/imagens/destaque_wap.jpg'], 
['unidade_botafogo.php', '/imagens/destaque_voluntarios.jpg'], 
//['agasalho.php', '/imagens/destaque_agasalho2008.jpg'],
//['cliente_de_olho_na_saude.php', '/imagens/banner_meningite_lamina.jpg'], 
//['vacinas.php', '/imagens/destaque_arpoador3.jpg'], 
//['vacinas.php', '/imagens/destaque_arpoador3.jpg'], 
['http://www.clubda.com.br', '/imagens/banner_clubda.jpg']
];
var mfIe = false;

if(document.all)
	{
		mfIe = true;
	}

var mfBannerIndex = 0;

function inicio()
	{
	var htmlString1 ='<a href="'+mfBanners[mfBannerIndex][0]+'" target="_blank"><img border="0" 	src="'+mfBanners[mfBannerIndex][1]+'"></a>'; 
	document.all.banner.innerHTML = htmlString1;
	}

function mfBannerChange() 
	{
		var htmlString = '<a href="'+mfBanners[mfBannerIndex][0]+'" target="_self"><img border="0" 	src="'+mfBanners[mfBannerIndex][1]+'"></a>';
		if(mfIe)
			{
				document.all.banner.innerHTML = htmlString;
			}
		else
			{
				document.layers["banner"].document.open();
				document.layers["banner"].document.write(htmlString);
				document.layers["banner"].document.close();
			}
		
		if(mfBannerIndex < mfBanners.length - 1)
			{
				mfBannerIndex++;
			}
		else
			{
				mfBannerIndex = 0;
			}
	}
setInterval("mfBannerChange()", 5000);