/*
Impede a entrada de dados com datas superior a data informada
Ricardo Araripe em 17/11/2005
   sNomeCampo -> nome do campo a ser validado
   dDataDig   -> data digitada  (dd/mm/aaaa)
   dDataLim   -> data limite    (dd/mm/aaaa)
*/
function LimitaData(sNomeCampo,dDataDig,dDataLim)  {
   var mDataDig = dDataDig.substr(6,4) + dDataDig.substr(3,2) + dDataDig.substr(0,2)
   var mDataLim = dDataLim.substr(6,4) + dDataLim.substr(3,2) + dDataLim.substr(0,2)

   if (mDataDig.length < 2)  {
      alert("Atenção!!! Data invalida ou nula.");
      sNomeCampo.focus();
      sNomeCampo.select();
      return false;
   }

   if (mDataDig > mDataLim)   {
      alert("Atenção!!! Data informada " + dDataDig + " \n não pode ser superior a data " + dDataLim);
      sNomeCampo.focus();
      sNomeCampo.select();
      return false;
   }
   return true;
}	

/* 
	Funcoes que alinham o conteudo de um input text à direita
	Sao necessarias somente p/ Netscape, pois IE utiliza o atributo:
	style="text-align:right"
	Parametros:	indice do form na página (0 se for o primeiro....),
					nome do input text e o tamanho do texto final
*/					
function alinhaTexto(indForm, nameText, sizeText)	{

	navegador = navigator.appName;	
	if (  navegador.indexOf("Netscape") > -1
	   && String(document.forms) != "undefined"
	   && String(document.forms[indForm]) != "undefined"
	   && String(document.forms[indForm].elements) != "undefined"
	   && String(document.forms[indForm].elements[nameText]) != "undefined"
	   )	{
		aux = document.forms[indForm].elements[nameText].value;
		document.forms[indForm].elements[nameText].value = pad(aux,sizeText);
	}
}

function pad(valor,size) {
    var str = '' + valor;
    while (str.length > size)
    	str = str.substr(1);
    	
    while (str.length < size)
        str = ' ' + str;
    return str;
}

function padZero(objCampo, piTam)  {
   
   if (objCampo.value != '') {
      objCampo.value=strZero(objCampo.value, piTam);
   }
}   

// Verifica se o parâmetro foi informado ao elemento text de um form
function verifyText(vform, vtext, nomeParam) {
  if (vform.elements[vtext].value != '')  {
    return true;
  }
  alert("Deve-se informar o campo '" + nomeParam + "' para a pesquisa.");
  return false;
}

// verifica se algum dos 2 parâmetros foi informado aos elementos text do form.
// Só avisa se nenhum deles for informado
function verifyText2(vform, vtext1, vtext2, nomeParam)  {
  if (vform.elements[vtext1].value != '')
    return true;

  if (vform.elements[vtext2].value != '')
    return true;

  alert("Deve-se informar o campo '" + nomeParam + "' para a pesquisa.");
  return false;
}

// verifica se alguma linha de um elemento do tipo select
// foi selecionada
function verifySelect(vform, vselect, nomeParam, bIncluiZero)  {

   // valida parâmetros informados
   if (String(bIncluiZero) == "undefined")  {
      bIncluiZero = true;
   }   

   ind = 0;
   if (bIncluiZero) {
      ind = -1;
   }
   if (vform.elements[vselect].selectedIndex > ind)
      return true;
    
   alert("Deve-se selecionar o campo '" + nomeParam + "' para a pesquisa.");
   return false;
}

// verifica se o conteudo (do tipo Valor) de um elemento do form foi 
// informado corretamente
function verifyValor(vform, vtext, nomeParam)  {
   var dif = Math.abs(parseInt(vform.elements[vtext].value));
   
   if (isNaN(dif) || (vform.elements[vtext].value.length < 3)) {
      alert("O campo '" + nomeParam + "' não foi informado corretamente");
      return false;
   }
   return true;
}


// verifica se alguma das opções de um RadioButton foi selecionado
// a função retorna o indice da opção selecionada
function verifyRadio(vform, vradio, sMsg)  {
   
   for (var i=0;i<vform.elements[vradio].length;i++) {
     if (vform.elements[vradio][i].checked) {
	    return i;
	  }   		
   }
   
   if (sMsg != "") alert(sMsg);
   return -1;
   
}


// verifica se todos os elementos (exceto os do tipo hidden) do form
// passado como parâmetro estão com valores. 
// Retorna -1 se existir elemento sem value, 0 se estiver ok
function verifyElementsValue(vform) {
   
   for (var i = 0; i < vform.elements.length; i++) {
      
      if (vform.elements[i].type != "hidden")   {     
         if (vform.elements[i].value == "")   {
            return -1;
         }
      }
   }
   return 0;
}


// marca/desmarca array de checkbox, ao selecionar 
// um checkbox "pai"
function marcaCheckboxs(pCheckPai, pChecks)   {   
   if (  String(pChecks) != "undefined")  {      
      if (String(pChecks.length) != "undefined")   {         
         for(i=0; i < pChecks.length; i++) {
            pChecks[i].checked = pCheckPai.checked;
         }
      }
      else  {
         pChecks.checked = pCheckPai.checked;
      }
   }
}


/**
 *    Retorna um texto informado em um campo de um formulário.
 *    No caso de select, radio e checkbox, retorna se o elemento
 *    estiver selecionado.
 *    Utiliza separador de campos (default ','), no caso de encontrar
 *    mais de um campo para o nome informado e separador de valor 
 *    (default ',') se o campo for multivalorado.
 */
function obtemValorCampoFormulario(
      psChaveCampo
   ,  vForm, psNomeCampo
   ,  psSepCampo, psSepValor
   ,  pbMaisDeUm
   )  {

   // variáveis
   var sRet_VlrCmpForm  = "";
   var iCmpForm         = -1;   
   var aCmpForm         = "";
   var iCmp             = 0;
   var iItem            = 0;

   // valida parâmetros informados
   if (String(psSepCampo) == "undefined")  {
      psSepCampo = ",";
   }   
   if (String(psSepCampo) == "")  {
      psSepCampo = "\0\0\0";
   }   
   if (String(psSepValor) == "undefined")  {
      psSepValor = ",";
   }
   if (String(pbMaisDeUm) == "undefined")  {
      pbMaisDeUm = false;
   }   
   
   if (     String(vForm)        != "undefined"
         && String(vForm.name)   != "undefined"
      )  {

      // cria um array de índices de campos retornados
      iPosEle  = obtemIndiceElemento(vForm, psNomeCampo, psSepCampo, pbMaisDeUm);
      aCmpForm = iPosEle.split(psSepCampo);
      if (iPosEle != -1)   {

         // identifica retorno
         sRet_VlrCmpForm = psChaveCampo + "=";
         for (var iCmp=0; iCmp < aCmpForm.length; iCmp++)   {
         
            // para cada campo retornado, obtenho seu valor
            // (select, radio e checkbox somente se selecionados)
            iCmpForm = parseInt(aCmpForm[iCmp]);
            if (vForm.elements[iCmpForm].type.indexOf("select") > -1)  {

               // carrega todos os valores do campo select que foram selecionados
               bJaCarregou = false;
               for (var iItem=0; iItem < vForm.elements[iCmpForm].length; iItem++) {
                  if (vForm.elements[iCmpForm].options[iItem].selected)  {
                     if (bJaCarregou)  {
                        sRet_VlrCmpForm += psSepValor;
                     }
                     bJaCarregou =  true;
                     if (  String(vForm.elements[iCmpForm].options[iItem].value) != ""
                        && vForm.elements[iCmpForm].options[iItem].value != "undefined"
                        )  {
                        sRet_VlrCmpForm += vForm.elements[iCmpForm].options[iItem].value;
                     }
                     else  {
                        sRet_VlrCmpForm += vForm.elements[iCmpForm].options[iItem].text;
                     }
                  }
               }
               
            }
            else if (   vForm.elements[iCmpForm].type == "radio"
                     || vForm.elements[iCmpForm].type == "checkbox"){
                     
               // somente os elementos selecionados são retornados
               if (vForm.elements[iCmpForm].checked) {
                  if (  String(vForm.elements[iCmpForm].value) != ""
                     && vForm.elements[iCmpForm].value != "undefined"
                     )  {
                     sRet_VlrCmpForm += vForm.elements[iCmpForm].value;
                  }
                  else  {
                     sRet_VlrCmpForm += vForm.elements[iCmpForm].text;
                  }
               }
               
            }
            else  {
               sRet_VlrCmpForm += vForm.elements[iCmpForm].value;
            }
         }
      }
   }

   // retorna
   return sRet_VlrCmpForm;
}

/**
 *    Transfere o valor informado para um campo de um formulário
 *    Esse valor pode ter um separador, indicando que o campo aceita
 *    múltiplos valores (ex: select).
 *    O flag pbMaisDeUm indica que há mais de um campo com o nome informado.
 */
function defineValorCampoFormulario(
      vForm
   ,  psNomeCampo
   ,  pValor
   ,  psSepCampo
   ,  psSepValor
   ,  pbMaisDeUm
   )  {
               
   // variáveis
   var aCmpForm    = "";
   var iCmpForm    = -1;
   var iItem       = 0;
   var iCmp        = 0;
   var iVlr        = 0;
   var aValores    = "";

   // valida parâmetros informados
   if (String(psSepCampo) == "undefined")  {
      psSepCampo = ",";
   }   
   if (String(psSepValor) == "undefined")  {
      psSepValor = ",";
   }
   if (String(pbMaisDeUm) == "undefined")  {
      pbMaisDeUm = false;
   }

   if (  String(vForm) != "undefined"
      && String(pValor) != "undefined"
      )  {

      // identifica o índice do campo no formulário
      aCmpForm = obtemIndiceElemento(vForm, psNomeCampo, psSepCampo, pbMaisDeUm).split(psSepCampo);
      if (aCmpForm[0] != "-1")   {
        
         // verifica para qual campo deve atribuir valor
         for (iCmp=0; iCmp < aCmpForm.length; iCmp++)   {
            iCmpForm = parseInt(aCmpForm[iCmp]);   
      
            // se for um select, deve selecionar o item correspondente
            if (vForm.elements[iCmpForm].type == "select-one")  {  
               for (iItem=0; iItem < vForm.elements[iCmpForm].length; iItem++) {
                  if (  vForm.elements[iCmpForm].options[iItem].value != ""
                     && vForm.elements[iCmpForm].options[iItem].value != "undefined"
                     )  {
                     if (vForm.elements[iCmpForm].options[iItem].value == pValor)   {
                        vForm.elements[iCmpForm].selectedIndex = iItem;
                        vForm.elements[iCmpForm].options[iItem].selected = true;
                        break;
                     }
                  }
                  else {
                     if (vForm.elements[iCmpForm].options[iItem].text == pValor) {
                        vForm.elements[iCmpForm].selectedIndex = iItem;
                        vForm.elements[iCmpForm].options[iItem].selected = true;
                        break;
                     }
                  }
               }
            }

            // se for um select multiple, pode existir mais de um item selecionado
            // (pValor usando o pSeparador)
            else if (vForm.elements[iCmpForm].type == "select-multiple")  {

               // no caso se select-multiple, pode existir mais de um 
               // valor selecionado
               aValores = pValor.split(psSepValor);
               
               // para cada valor informado, procuro o item correspondente
               // no select
               for (iVlr=0; iVlr < aValores.length; iVlr++)   {
                  for (iItem=0; iItem < vForm.elements[iCmpForm].length; iItem++) {
                     if (  vForm.elements[iCmpForm].options[iItem].value != ""
                        && vForm.elements[iCmpForm].options[iItem].value != "undefined"
                        )  {
                        if (vForm.elements[iCmpForm].options[iItem].value == aValores[iVlr])   {
                           vForm.elements[iCmpForm].options[iItem].selected = true;
                           break;
                        }
                     }
                     else {
                        if (vForm.elements[iCmpForm].options[iItem].text == aValores[iVlr]) {
                           vForm.elements[iCmpForm].options[iItem].selected = true;
                           break;
                        }
                     }
                  }
               }
            }
            
            // se for radio ou checkbox, seleciono o item correspondente
            else if (   vForm.elements[iCmpForm].type == "checkbox"
                     || vForm.elements[iCmpForm].type == "radio") {
               if (vForm.elements[iCmpForm].value == pValor) {
                  vForm.elements[iCmpForm].checked = true;
               }
            }
            else  {
               vForm.elements[iCmpForm].value = pValor;
            }
         }
      }
   }               
}

/**
 *    Retorna um texto com qtd espaços em branco, para 
 *    iniciar um select vazio
 */
function escreveBrancos(qtd)	{
   var i, max;
   var sRet = "";
   var sCarac = "";
   
   if (navigator.appName.indexOf("Netscape") > -1) {
      sCarac = "-";
      max = qtd;
   }
   else {
      sCarac = "&nbsp;";
      max = qtd + qtd/2;
   }
   
   for (i=0; i< max; i++) {
      sRet = sRet + sCarac;
   }
   sRet = "<option>" + sRet + "</option>"
   document.write(sRet);   
}

/**
 *    Remove o conteúdo de todos os elementos
 *    do form passado como parâmetro.
 *    (os elementos select perdem os itens selecionados)
 */
function limpaForm(vForm, bRemoveSelect)   {

   // verifica o parâmetro informado
   if (String(bRemoveSelect) == "undefined") {
      bRemoveSelect = false;
   }

   for (var i=0; i < vForm.length; i++)   {

      if (  vForm.elements[i].type == "button"
         || vForm.elements[i].type == "submit") {
         continue;
      }   
      else if (vForm.elements[i].type == "select-one") {
         // nao usa bRemoveSelect
         vForm.elements[i].selectedIndex = 0;
      }            
      else if (vForm.elements[i].type == "select-multiple") {
         if (bRemoveSelect) {
            for (var j=vForm.elements[i].options.length-1; j > -1; j--) {
               vForm.elements[i].options[j] = null;
            }
         }
         else  {
            for (var j=0; j < vForm.elements[i].length; j++) {
               if (vForm.elements[i].options[j].selected)  {
                  vForm.elements[i].options[j].selected = false;
               }         
            }
         }
      }      
      else if (   vForm.elements[i].type == "checkbox"
               || vForm.elements[i].type == "radio") {
         vForm.elements[i].checked = false;
      }
      else  {
         vForm.elements[i].value = "";
      }
   }   
}

/**
 *    Retorna uma String única dos parâmetros informados em um formulário de entrada de
 * dados
 *
 * Parâmetros:
 *    - pForm
 *          Formulário utilizado na entrada dos dados
 *
 *    - pSepCampos (Default "&")
 *          Separador a ser utilizado entre os campos
 *
 *    - pSepNomeValor (Default "=")
 *          Separador a ser utilizado entre o nome do campo e o seu conteúdo
 *
 *    - pSepMultiplosValores (Default ";")
 *          Separador a ser utilizados entre os diversos valores que compõem o campo
 *
 */
function Form_obtemStringUnicaEntradaDados(
                  pForm
               ,  pSepCampos, pSepNomeValor, pSepMultiplosValores
               ,  pbRetCamposVazios
               )  {

   // verifica se o formulário é válido
   if (     String(pForm) == "undefined"
         || String(pForm.elements) == "undefined"
      )  {
      return "";
   }
   
   // valida separadores informados
   if (String(pSepCampos) == "undefined") {
      pSepCampos = "&";
   }
   if (String(pSepNomeValor) == "undefined") {
      pSepNomeValor = "=";
   }
   if (String(pSepMultiplosValores) == "undefined") {
      pSepMultiplosValores = ";";
   }
   pbRetCamposVazios = (String(pbRetCamposVazios) == "true");

   // processa cada elemento do formulário
   sDadosInfo = "";
   for(  
         iPos = 0
      ;  iPos < pForm.elements.length
      ;  iPos++
      )  {
         
      // identifica o elemento que está sendo analisado
      elemento = pForm.elements[iPos];
      if (     String(elemento.name) != "undefined"
            && (pbRetCamposVazios || String(elemento.name).replace(/\ /g, "") != "")
         )  {
         
         // adiciona conteúdo de checkbox e radio
         if (     elemento.type == "checkbox"
               || elemento.type == "radio"
            ) {
            if (elemento.checked)   {
               if (sDadosInfo != "") sDadosInfo += pSepCampos;
               sDadosInfo += elemento.name + pSepNomeValor + elemento.value;
            }
         }
         
         // adiciona conteúdo de campo select
         else if (elemento.type.indexOf("select") > -1)   {
                        
            // verifica cada elemento selecionado
            sDadosSelect = "";
            for (var j=0; j < elemento.options.length; j++) {
               if (     elemento.options[j].selected
                     && elemento.options[j].value != "undefined"
                     && (pbRetCamposVazios || elemento.options[j].value.replace(/\ /g, "") != "")
                  )  {
                  if (sDadosSelect != "") sDadosSelect += pSepMultiplosValores;
                  sDadosSelect += elemento.options[j].value;
               }         
            }
            
            // adiciona o campo
            if (pbRetCamposVazios || sDadosSelect != "") {
               if (sDadosInfo != "") sDadosInfo += pSepCampos;
               sDadosInfo += elemento.name + pSepNomeValor + sDadosSelect;
            }
            
         }
         
         // identifica conteúdo default
         else if (   elemento.type != "button"
                  && elemento.value != "undefined"
                  && (pbRetCamposVazios || elemento.value.replace(/\ /g, "") != "")
                 )  {
               if (sDadosInfo != "") sDadosInfo += pSepCampos;
               sDadosInfo += elemento.name + pSepNomeValor + elemento.value;
         }
         
      }

   }      

   // retorna
   return sDadosInfo;
   
}


/**
 *    Limita o texto do TextArea em iMax caracteres
 *    Retorna true se o limite foi ultrapassado
 */
function limitaTextArea(iMax, objTextArea)  {   
   var sAux = objTextArea.value;
   
   if (sAux.length > iMax)   {
      objTextArea.value = sAux.substring(0,iMax);
      if (navigator.appName.indexOf("Netscape") >-1) {
         objTextArea.blur();
      }
      return true;
   }
   return false;
}

/**
 *    Alterna a seleção de um radio button tal qual um checkbox
 *    (necessita de uma variável auxiliar)
 */
function toggleRadio(radioObj, varname)   {
   var status = eval(varname);
   if (status)  {
      radioObj.checked = !status;
   }      
   eval(varname + "=" + radioObj.checked);
}



/**
 *    Retorna uma String pela repetição de uma string informada
 */
function Form_repeat(piQtd, psString)  {
   
   // prepara o retorno
   ret_Form_repeat = "";
   
   // realiza o processamento
   if (  String(piQtd) != "undefined"
      && String(psString) != "undefined"
      )  {
      for(
            piQtd = Global_obtemValorNumerico(piQtd)
         ;  piQtd > 0
         ;  piQtd--
         )  {
         ret_Form_repeat += psString;
      }
   }
   
   // retorna
   return ret_Form_repeat;
}

/**
 *    A partir de campos de um formulário gera e retorna uma String com os dados
 * armazenados no campo
 *
 * Parâmetros
 *    pForm
 *       Formulário de entrada de dados
 *
 *    pasCampos
 *       Array de Strings contendo as seguintes informações
 *          [Nome Campo]psSep[Txt Inicio]psSep[Txt Fim]psSep[Vlr Inválido]psSepInv[Vlr Inválido]
 * 
 *    psSep
 *       Separador dos dados contidos nas Strings de pasCampos
 *
 *    psSepInv
 *       Separador dos dados inválidos contidos nas Strings de pasCampos
 *
 * Exemplo:
 *    Considere um formulário com os campos Cmp1 e Cmp2;
 *       psSep = ";"
 *       pasCampos = {
 *             "Cmp1;Campo1 = ;vbCrLf "
 *          ,  "Cmp2;Campo2 = ;vbCrLf "
 *       }
 *
 *    => retorna: Campo1 = [Conteúdo do Campo Cmp1]vbCrLf Campo2 = [Conteúdo do Campo Cmp2]vbCrLf
 *
 */
function obtemStringDadosForm(pForm, pasCampos, psSep, psSepInv)  {
   
   // verifica os parâmetros informados
   if (  String(pForm) == "" || String(pForm) == "undefined" 
      || String(pForm.elements) == "undefined"
      || String(pasCampos) == "" || String(pasCampos) == "undefined" 
      || String(pasCampos.length) == "undefined"
      )  {
      return "";
   }
   
   // variáveis
   ret_obtStrDadFrm = "";
   
   // verifica se pasCampos é uma String para garantir um array de Strings
   if (String(pasCampos.substring) != "undefined") {
      pasCampos = pasCampos.split("__TransformaEmArrayDeString__");
   }
   
   // processa os campos informados
   for(i_obtStrDadFrm=0; i_obtStrDadFrm < pasCampos.length; i_obtStrDadFrm++) {
      
      // identifica os dados informados p/ o campo
      asDadosCmp_obtStrDadFrm  = String(pasCampos[i_obtStrDadFrm]).split(psSep);

      // identifica o valor do campo do formulário
      sVlr = obtemValorCampoFormulario("", pForm, asDadosCmp_obtStrDadFrm[0], "", "", true).substring(1);
      
      // valida o valor do campo
      bVlr = true;
      if (String(psSepInv) != "undefined" && asDadosCmp_obtStrDadFrm.length > 3) {
         asVlrInv_obtStrDadFrm = asDadosCmp_obtStrDadFrm[3].split(psSepInv);
         for(i_vlrInv=0; bVlr && i_vlrInv < asVlrInv_obtStrDadFrm.length; i_vlrInv++) {
            bVlr = (sVlr != asVlrInv_obtStrDadFrm[i_vlrInv]);
         }
      }
      
      // adiciona o resultado encontrado
      if (bVlr)   {
      
         // adiciona ao retorno o txt de início
         if (asDadosCmp_obtStrDadFrm.length > 1) {
            ret_obtStrDadFrm += asDadosCmp_obtStrDadFrm[1];
         }
         
         // adiciona ao retorno o valor
         ret_obtStrDadFrm += sVlr;

         // adiciona ao retorno o txt de fim
         if (asDadosCmp_obtStrDadFrm.length > 2) {
            ret_obtStrDadFrm += asDadosCmp_obtStrDadFrm[2];
         }

      }
      
   }
   
   // retorna
   return ret_obtStrDadFrm;
   
}

// funcao para forçar o focus num campo text, de modo que o cursor
// fique no final do campo
function focusTextInput(objInput)   {

   var selectionStart = 100;
   var selectionEnd = 100;

   if (String(objInput) != "undefined")   {
      if (objInput.setSelectionRange) {
         objInput.focus();
         objInput.setSelectionRange(selectionStart, selectionEnd);
      }
      else if (objInput.createTextRange) {
         var range = objInput.createTextRange();
         range.collapse(true);
         range.moveStart('character', selectionStart);
         range.moveEnd('character', selectionEnd);
         range.select();
      }
   }
}


/**
 * Responsável:   Andre Vallier
 * Data:          10/12/2004
 *
 *    Valida os dados informados em um formulário e o envia o se tudo estiver preenchido
 *
 * Parâmetros
 *    pForm
 *       Formulário de entrada de dados
 *
 *    psCampos
 *       Nome dos campos de entrada de dado a ser verificado. Cada campo deve estar separado
 * por psSepCampos. Cada campo deve conter o nome do campo e o texto a ser apresentado em caso
 * de erros. O nome do campo e o texto devem estar separados por psSepDados. Exemplo: Camp
 * 
 *    psSepDados
 *       Separador dos dados contidos nas Strings de sCampos
 *
 *    psSepCampos
 *       Separador dos dados contidos nas Strings de sCampos
 *
 *
 *    pbEnviaDadosForm
 *       Define se o formulário deve ser enviado se tudo estiver certo
 *
 * Retorna:
 *    Retorna false se algum campo não estiver preenchido, senão retorna true e poderá
 * executar o formulário
 *
 * Exemplo:
 *    Considere um formulário com os campos Cmp1 e Cmp2;
 *       psSep = ";"
 *       sCampos = "Cmp1;Cmp2"
 *
 */
function Form_validaProcessaForm(
   pForm, psCampos, psSepDados, psSepCampos
,  pbEnviaDadosForm
)   {

   // valida os parâmetros informados
   if (  String(pForm.elements) == "undefined"
      || String(psCampos)       == "undefined"
      || String(psSepDados)     == "undefined"
      || String(psSepCampos)    == "undefined"
      )  {
      return false;
   }
   
   // garante e adapta os parâmetros informados
   pbEnviaDadosForm = (String(pbEnviaDadosForm) == "true");
   
   // valida os campos
   asCampos = psCampos.split(psSepCampos);
   for(i=0; i < asCampos.length; i++)   {
      asCampo = asCampos[i].split(psSepDados);

      //    se a propriedade value do campo não estiver preenchido
      // ou se o campo for select e não estiver selecionado
      objCmp = eval("pForm." + asCampo[0]);
      if (String(objCmp) != "undefined")  {
         if (  (
                     String(eval("pForm." + asCampo[0] + ".type")) != "undefined"
                  && eval("pForm." + asCampo[0] + ".type")
                  && eval("pForm." + asCampo[0] + ".type").indexOf("text") > -1
                  && eval("pForm." + asCampo[0] + ".value") == ""
               )
            || (  
                  eval("pForm." + asCampo[0] + ".type").indexOf("select") > -1
               && eval("pForm." + asCampo[0] + ".selectedIndex") == -1
            ))   {
            alert("O campo '" + (asCampo.length<2?asCampo[0]:asCampo[1]) + "' deve ser informado");
            eval("pForm." + asCampo[0] + ".focus()");
            return false;
         }
      }
   }

   // processa o formulário de solicitação
   if (pbEnviaDadosForm)   {
      pForm.submit();
   }
   
   // retorna
   return true;
   
}

/* 
	Funcao para controlar a janela target de um form, definindo
	argumentos do window open
	http://javascript.internet.com/forms/form-target-formatting.html
*/					

// test variables
var myHeight = 200;
var isResizable = true;

function createTarget(form) {
   _target = form.target;
   _colon = _target.indexOf(":");
   
   if(_colon != -1) {
      form.target = _target.substring(0,_colon);
      form.args = _target.substring(_colon+1);
   } else if(typeof(form.args)=="undefined") {
      form.args = "";
   }
   
   if(form.args.indexOf("{")!=-1) {
      _args = form.args.split("{");
      form.args = _args[0];
      for(var i = 1; i < _args.length;i++) {
         _args[i] = _args[i].split("}");
         form.args += eval(_args[i][0]) + _args[i][1];
      }
   }
   form.args = form.args.replace(/ /g,"");
   _win = window.open('',form.target,form.args);
   if(typeof(focus)=="function")
      _win.focus();
      
   return true;
}


function marcaSelecaoOptions(pSelect, pVlr)   {
   for(i=0; i < pSelect.options.length; i++) {
         pSelect.options[i].selected = pVlr;
   }
}

// funcao que escreve o valor do elemento, no outro
// elemento passado como parametro
function escreveOutroElemento(thisElement, otherElement) {      
   if (thisElement.value != "") {
      otherElement.value = thisElement.value;
   }
}