function Confirma(){
	var agree = confirm("Deseja excluir este registro?");
	if (agree) {
		return(true);
	} else {
		return(false)
	}
}

function popup(URL) {
   var width = 360;
   var height = 330;
   var left = 10
   var top = 10
   window.open(URL,'Popup', 'width='+width+', height='+height+', top='+top+', left='+left+', toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=no, resizable=no, fullscreen=no');
}

// Title: Tigra Form Validator
// URL: http://www.softcomplex.com/products/tigra_form_validator/
// Version: 1.3
// Date: 08/25/2005 (mm/dd/yyyy)
// Notes: This script is free. Visit official site for further details.
// Nova adaptação: Fabrício Nogueira Magri
// Contribuição: André Sam - www.zunz.com.br


// PARA APRENDER A USAR ( caso n saiba )
// http://www.phpbrasil.com/articles/article.php/id/1117



// regular expressions or function to validate the format
var re_dt = /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/,
re_tm = /^(\d{1,2})\:(\d{1,2})\:(\d{1,2})$/,
re_cpf = /^([0-9]{3}\.){2}[0-9]{3}-[0-9]{2}$/,
re_cnpj = /^[0-9]{2}\.[0-9]{3}\.[0-9]{3}\/[0-9]{4}\-[0-9]{2}$/,
a_formats = {
    'alpha'   : /^[a-zA-Z\.\-]*$/,
    'alphanum': /^\w+$/,
    'unsigned': /^\d+$/,
    'integer' : /^[\+\-]?\d*$/,
    'real'    : /^[\+\-]?\d*\.?\d*$/,
    'email'   : /^[\w-\.]+\@[\w\.-]+\.[a-z]{2,4}$/,
    'phone'   : /^[\d\.\s\-]+$/,
    'cpfcnpj' : function (s_cpfcnpj) {
        // pega somente os numeros
        var numero = s_cpfcnpj.replace(/\D/g, "");
        var igual = true;
        
        var tipo = 0;
        // check format
        if (re_cpf.test(s_cpfcnpj) || (numero.length == 11 && s_cpfcnpj.length == numero.length))
            tipo = 1;
        else if (re_cnpj.test(s_cpfcnpj) || (numero.length == 14 && s_cpfcnpj.length == numero.length))
            tipo = 2;
        else
            return false;
        
        // verifica se todos os numeros sao iguais
        for (var i = 1; i < numero.length; i++) {
            if (numero.charAt(i-1) != numero.charAt(i)) 
                igual = false;
        }
        if (igual)
            return false;

        function impCalcDig11(numero) {
            var pesos = [2,3,4,5,6,7,8,9,2,3,4,5,6,7,8,9];
            var calc = 0, x='';
            var numero = String(numero).split("");
            var limite = numero.length -1;
            var result = 0;
            var pso = 0;
            for (var i = limite; i >= 0; i--) {
                x += "\npso:" + pesos[pso] + " * " + numero[i] + " = " + (pesos[pso] * parseInt(numero[i]));
                calc += (pesos[pso++] * parseInt(numero[i]));
            }
            result = 11 - ((calc)%11);
            if (result == 11) {result = 0;}
            return result;
        }

        if (tipo == 1){
            var cpf = numero.substring(0,9);
            var digito = numero.substring(9,11);
            var soma, mt, dg = 0;
            var dgc = "";
            for (var j = 1; j <= 2; j++) {
                soma = 0;
                mt = 2;
                for (i = 8 + j; i >= 1; i--) {
                    soma += parseInt(cpf.charAt(i - 1), 10) * mt;
                    mt++;
                }
                dg = 11 - (soma % 11);
                if (dg > 9) 
                    dg = 0;
                cpf += dg;
                dgc += dg;
            }
        } else if (tipo == 2) {
            var cnpj = numero.substring(0,12);
            var digito = numero.substring(12,14);
            var digitoc = 0;
            var dgc = "";
            for (var j = 1; j <= 2; j++) {
                digitoc = impCalcDig11(cnpj);
                if (digitoc == 10) 
                    digitoc = 0;
                dgc  += digitoc;
                cnpj += digitoc;
            }
        }
        // digito inválido
        if (dgc != digito)
            return false;

        return true;
    },    
    // substitua a data por isto aqui 
    'date' : function (s_date) { 
        // check format 
        if (!re_dt.test(s_date)){ 
            return false; 
        } 
        // check allowed ranges 
        if (RegExp.$1 > 31 || RegExp.$2 > 12 || RegExp.$3 < 1900){ 
            return false; 
        } 
        var dt_test = new Date(); 
        if (RegExp.$3 > dt_test.getFullYear() + 10) 
            return false;        
        // check number of day in month 
        var dt_test = new Date(RegExp.$3, Number(RegExp.$2-1), RegExp.$1); 
        if (dt_test.getMonth() != Number(RegExp.$2-1)) 
            return false; 
        return true; 
    }, 
    'time'    : function (s_time) {
        // check format
        if (!re_tm.test(s_time))
            return false;
        // check allowed ranges    
        if (RegExp.$1 > 23 || RegExp.$2 > 59 || RegExp.$3 > 59)
            return false;
        return true;
    }
},


a_messages = [
    'Nenhum nome do formulário passou à rotina do Validator',
    'Nenhum array do campo "%form%" passou à rotina do Validator',
    'O formulário "%form%" não pode ser encontrado no documento',
    'Entrada imcompleta no campo de formulário "%n%". Atributo "l" não encontrado',
    'Não encontrado o campo "%n%" no formulário "%form%"',
    'Não encontrada a label tag (id="%t%")',
    'Não é possível validar. Campo "%m%" não encontrado',
    '"%l%" é um campo obrigatório',
    '"%l%" precisa no mínimo %mn% caracteres ou mais',
    '"%l%" não pode ter mais que %mx% caracteres',
    '"%v%" não é um valor válido para "%l%"',
    '"%l%" deve ser "%ml%"'
]


// validator counstruction routine
function validator(s_form, a_fields, o_cfg) {
    this.f_error = validator_error;
    this.f_alert = o_cfg && o_cfg.alert
        ? function(s_msg) { alert(s_msg); return false }
        : function() { return false };
        
    // check required parameters
    if (!s_form)    
        return this.f_alert(this.f_error(0));
    this.s_form = s_form;
    
    if (!a_fields || typeof(a_fields) != 'object')
        return this.f_alert(this.f_error(1));
    this.a_fields = a_fields;

    this.a_2disable = o_cfg && o_cfg['to_disable'] && typeof(o_cfg['to_disable']) == 'object'
        ? o_cfg['to_disable']
        : [];
        
    this.exec = validator_exec;
}

// validator execution method
function validator_exec() {
    var o_form = document.forms[this.s_form];
    if (!o_form)    
        return this.f_alert(this.f_error(2));
        
    b_dom = document.body && document.body.innerHTML;
    
    // check integrity of the form fields description structure
    for (var n_key in this.a_fields) {
        // check input description entry
        this.a_fields[n_key]['n'] = n_key;
        if (!this.a_fields[n_key]['l'])
            return this.f_alert(this.f_error(3, this.a_fields[n_key]));
        o_input = o_form.elements[n_key];
        if (!o_input)
            return this.f_alert(this.f_error(4, this.a_fields[n_key]));
        this.a_fields[n_key].o_input = o_input;
    }

    // reset labels highlight
    if (b_dom)
        for (var n_key in this.a_fields) 
            if (this.a_fields[n_key]['t']) {
                var s_labeltag = this.a_fields[n_key]['t'], e_labeltag = get_element(s_labeltag);
                if (!e_labeltag)
                    return this.f_alert(this.f_error(5, this.a_fields[n_key]));
                this.a_fields[n_key].o_tag = e_labeltag;
                
                // normal state parameters assigned here
                e_labeltag.className = 'tfvNormal';
            }

    // collect values depending on the type of the input
    for (var n_key in this.a_fields) {
        var s_value = '';
        o_input = this.a_fields[n_key].o_input;
        if (o_input.type == 'checkbox') // checkbox
            s_value = o_input.checked ? o_input.value : '';
        else if (o_input.value) // text, password, hidden
            s_value = o_input.value;
        else if (o_input.options) // select
            s_value = o_input.selectedIndex > -1
                ? o_input.options[o_input.selectedIndex].value
                : null;
        else if (o_input.length > 0) // radiobuton
            for (var n_index = 0; n_index < o_input.length; n_index++)
                if (o_input[n_index].checked) {
                    s_value = o_input[n_index].value;
                    break;
                }
        this.a_fields[n_key]['v'] = s_value.replace(/(^\s+)|(\s+$)/g, '');
    }
    
    // check for errors
    var n_errors_count = 0,
        n_another, o_format_check;
    for (var n_key in this.a_fields) {
        o_format_check = this.a_fields[n_key]['f'] && a_formats[this.a_fields[n_key]['f']]
            ? a_formats[this.a_fields[n_key]['f']]
            : null;

        // reset previous error if any
        this.a_fields[n_key].n_error = null;

        // check reqired fields
        if (this.a_fields[n_key]['r'] && !this.a_fields[n_key]['v']) {
            this.a_fields[n_key].n_error = 1;
            n_errors_count++;
        }
        // check length
        else if (this.a_fields[n_key]['mn'] && this.a_fields[n_key]['v'] != '' && String(this.a_fields[n_key]['v']).length < this.a_fields[n_key]['mn']) {
            this.a_fields[n_key].n_error = 2;
            n_errors_count++;
        }
        else if (this.a_fields[n_key]['mx'] && String(this.a_fields[n_key]['v']).length > this.a_fields[n_key]['mx']) {
            this.a_fields[n_key].n_error = 3;
            n_errors_count++;
        }
        // check format
        else if (this.a_fields[n_key]['v'] && this.a_fields[n_key]['f'] && (
            (typeof(o_format_check) == 'function'
            && !o_format_check(this.a_fields[n_key]['v']))
            || (typeof(o_format_check) != 'function'
            && !o_format_check.test(this.a_fields[n_key]['v'])))
            ) {
            this.a_fields[n_key].n_error = 4;
            n_errors_count++;
        }
        // check match    
        else if (this.a_fields[n_key]['m']) {
            for (var n_key2 in this.a_fields)
                if (n_key2 == this.a_fields[n_key]['m']) {
                    n_another = n_key2;
                    break;
                }
            if (n_another == null)
                return this.f_alert(this.f_error(6, this.a_fields[n_key]));
            if (this.a_fields[n_another]['v'] != this.a_fields[n_key]['v']) {
                this.a_fields[n_key]['ml'] = this.a_fields[n_another]['l'];
                this.a_fields[n_key].n_error = 5;
                n_errors_count++;
            }
        }
        
    }

    // collect error messages and highlight captions for errorneous fields
    var s_alert_message = '',
        e_first_error;

    if (n_errors_count) {
        for (var n_key in this.a_fields) {
            var n_error_type = this.a_fields[n_key].n_error,
                s_message = '';
                
            if (n_error_type)
                s_message = this.f_error(n_error_type + 6, this.a_fields[n_key]);

            if (s_message) {
                if (!e_first_error)
                    e_first_error = o_form.elements[n_key];
                s_alert_message += s_message + "\n";
                // highlighted state parameters assigned here
                if (b_dom && this.a_fields[n_key].o_tag)
                    this.a_fields[n_key].o_tag.className = 'tfvHighlight';
            }
        }
        alert(s_alert_message);
        // set focus to first errorneous field
        if (e_first_error.focus && e_first_error.type != 'hidden'  && !e_first_error.disabled)
            eval("e_first_error.focus()");
        // cancel form submission if errors detected
        return false;
    }
    
    for (n_key in this.a_2disable)
        if (o_form.elements[this.a_2disable[n_key]])
            o_form.elements[this.a_2disable[n_key]].disabled = true;

    return true;
}

function validator_error(n_index) {
    var s_ = a_messages[n_index], n_i = 1, s_key;
    for (; n_i < arguments.length; n_i ++)
        for (s_key in arguments[n_i])
            s_ = s_.replace('%' + s_key + '%', arguments[n_i][s_key]);
    s_ = s_.replace('%form%', this.s_form);
    return s_
}

function get_element (s_id) {
    return (document.all ? document.all[s_id] : (document.getElementById ? document.getElementById(s_id) : null));
} 

/*
 * Configurable variables. You may need to tweak these to be compatible with
 * the server-side, but the defaults work in most cases.
 */
var hexcase = 0;  /* hex output format. 0 - lowercase; 1 - uppercase        */
var b64pad  = ""; /* base-64 pad character. "=" for strict RFC compliance   */
var chrsz   = 8;  /* bits per input character. 8 - ASCII; 16 - Unicode      */

/*
 * These are the functions you'll usually want to call
 * They take string arguments and return either hex or base-64 encoded strings
 */
function hex_sha1(s){return binb2hex(core_sha1(str2binb(s),s.length * chrsz));}
function b64_sha1(s){return binb2b64(core_sha1(str2binb(s),s.length * chrsz));}
function str_sha1(s){return binb2str(core_sha1(str2binb(s),s.length * chrsz));}
function hex_hmac_sha1(key, data){ return binb2hex(core_hmac_sha1(key, data));}
function b64_hmac_sha1(key, data){ return binb2b64(core_hmac_sha1(key, data));}
function str_hmac_sha1(key, data){ return binb2str(core_hmac_sha1(key, data));}

/*
 * Perform a simple self-test to see if the VM is working
 */
function sha1_test()
{
  if(hex_sha1("abc") == "a9993e364706816aba3e25717850c26c9cd0d89d") document.getElementById("cipher").style.display="inline";
}

function sha1sumbit()
{
  platnost = new Date;
  platnost.setTime(platnost.getTime()+(86400000*365));

  if(document.login.xcipher.checked)
  {
    document.cookie="js_cipher=1;expires="+platnost.toGMTString();
    if(document.login.password.value && document.login.uid.value.length>22)
    {
     document.login.mdpass.value = hex_sha1(document.login.uid.value+""+document.login.password.value);
     document.login.password.value="";
    }
    else return false;
  }
  else document.cookie="js_cipher=0;expires="+platnost.toGMTString();
  return true;
}

/*
 * Calculate the SHA-1 of an array of big-endian words, and a bit length
 */
function core_sha1(x, len)
{
  /* append padding */
  x[len >> 5] |= 0x80 << (24 - len % 32);
  x[((len + 64 >> 9) << 4) + 15] = len;

  var w = Array(80);
  var a =  1732584193;
  var b = -271733879;
  var c = -1732584194;
  var d =  271733878;
  var e = -1009589776;

  for(var i = 0; i < x.length; i += 16)
  {
    var olda = a;
    var oldb = b;
    var oldc = c;
    var oldd = d;
    var olde = e;

    for(var j = 0; j < 80; j++)
    {
      if(j < 16) w[j] = x[i + j];
      else w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
      var t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)),
                       safe_add(safe_add(e, w[j]), sha1_kt(j)));
      e = d;
      d = c;
      c = rol(b, 30);
      b = a;
      a = t;
    }

    a = safe_add(a, olda);
    b = safe_add(b, oldb);
    c = safe_add(c, oldc);
    d = safe_add(d, oldd);
    e = safe_add(e, olde);
  }
  return Array(a, b, c, d, e);

}

/*
 * Perform the appropriate triplet combination function for the current
 * iteration
 */
function sha1_ft(t, b, c, d)
{
  if(t < 20) return (b & c) | ((~b) & d);
  if(t < 40) return b ^ c ^ d;
  if(t < 60) return (b & c) | (b & d) | (c & d);
  return b ^ c ^ d;
}

/*
 * Determine the appropriate additive constant for the current iteration
 */
function sha1_kt(t)
{
  return (t < 20) ?  1518500249 : (t < 40) ?  1859775393 :
         (t < 60) ? -1894007588 : -899497514;
}

/*
 * Calculate the HMAC-SHA1 of a key and some data
 */
function core_hmac_sha1(key, data)
{
  var bkey = str2binb(key);
  if(bkey.length > 16) bkey = core_sha1(bkey, key.length * chrsz);

  var ipad = Array(16), opad = Array(16);
  for(var i = 0; i < 16; i++)
  {
    ipad[i] = bkey[i] ^ 0x36363636;
    opad[i] = bkey[i] ^ 0x5C5C5C5C;
  }

  var hash = core_sha1(ipad.concat(str2binb(data)), 512 + data.length * chrsz);
  return core_sha1(opad.concat(hash), 512 + 160);
}

/*
 * Add integers, wrapping at 2^32. This uses 16-bit operations internally
 * to work around bugs in some JS interpreters.
 */
function safe_add(x, y)
{
  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
  return (msw << 16) | (lsw & 0xFFFF);
}

/*
 * Bitwise rotate a 32-bit number to the left.
 */
function rol(num, cnt)
{
  return (num << cnt) | (num >>> (32 - cnt));
}

/*
 * Convert an 8-bit or 16-bit string to an array of big-endian words
 * In 8-bit function, characters >255 have their hi-byte silently ignored.
 */
function str2binb(str)
{
  var bin = Array();
  var mask = (1 << chrsz) - 1;
  for(var i = 0; i < str.length * chrsz; i += chrsz)
    bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (24 - i%32);
  return bin;
}

/*
 * Convert an array of big-endian words to a string
 */
function binb2str(bin)
{
  var str = "";
  var mask = (1 << chrsz) - 1;
  for(var i = 0; i < bin.length * 32; i += chrsz)
    str += String.fromCharCode((bin[i>>5] >>> (24 - i%32)) & mask);
  return str;
}

/*
 * Convert an array of big-endian words to a hex string.
 */
function binb2hex(binarray)
{
  var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
  var str = "";
  for(var i = 0; i < binarray.length * 4; i++)
  {
    str += hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8+4)) & 0xF) +
           hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8  )) & 0xF);
  }
  return str;
}

/*
 * Convert an array of big-endian words to a base-64 string
 */
function binb2b64(binarray)
{
  var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  var str = "";
  for(var i = 0; i < binarray.length * 4; i += 3)
  {
    var triplet = (((binarray[i   >> 2] >> 8 * (3 -  i   %4)) & 0xFF) << 16)
                | (((binarray[i+1 >> 2] >> 8 * (3 - (i+1)%4)) & 0xFF) << 8 )
                |  ((binarray[i+2 >> 2] >> 8 * (3 - (i+2)%4)) & 0xFF);
    for(var j = 0; j < 4; j++)
    {
      if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
      else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
    }
  }
  return str;
}