// ===================================================================
// Author: Matt Kruse <matt@mattkruse.com>
// WWW: http://www.mattkruse.com/
//
// NOTICE: You may use this code for any purpose, commercial or
// private, without any further permission from the author. You may
// remove this notice from your final code if you wish, however it is
// appreciated by the author if at least my web site address is kept.
//
// You may *NOT* re-distribute this code in any way except through its
// use. That means, you can include it in your product, or your web
// site, or any other form where the code is actually being used. You
// may not put the plain javascript up on your site for download or
// include it in your javascript libraries for download. 
// If you wish to share this code with others, please just point them
// to the URL instead.
// Please DO NOT link directly to my .js files from your site. Copy
// the files to your server and use them there. Thank you.
// ===================================================================

// HISTORY
// ------------------------------------------------------------------
// May 17, 2003: Fixed bug in parseDate() for dates <1970
// March 11, 2003: Added parseDate() function
// March 11, 2003: Added "NNN" formatting option. Doesn't match up
//                 perfectly with SimpleDateFormat formats, but 
//                 backwards-compatability was required.

// ------------------------------------------------------------------
// These functions use the same 'format' strings as the 
// java.text.SimpleDateFormat class, with minor exceptions.
// The format string consists of the following abbreviations:
// 
// Field        | Full Form          | Short Form
// -------------+--------------------+-----------------------
// Year         | yyyy (4 digits)    | yy (2 digits), y (2 or 4 digits)
// Month        | MMM (name or abbr.)| MM (2 digits), M (1 or 2 digits)
//              | NNN (abbr.)        |
// Day of Month | dd (2 digits)      | d (1 or 2 digits)
// Day of Week  | EE (name)          | E (abbr)
// Hour (1-12)  | hh (2 digits)      | h (1 or 2 digits)
// Hour (0-23)  | HH (2 digits)      | H (1 or 2 digits)
// Hour (0-11)  | KK (2 digits)      | K (1 or 2 digits)
// Hour (1-24)  | kk (2 digits)      | k (1 or 2 digits)
// Minute       | mm (2 digits)      | m (1 or 2 digits)
// Second       | ss (2 digits)      | s (1 or 2 digits)
// AM/PM        | a                  |
//
// NOTE THE DIFFERENCE BETWEEN MM and mm! Month=MM, not mm!
// Examples:
//  "MMM d, y" matches: January 01, 2000
//                      Dec 1, 1900
//                      Nov 20, 00
//  "M/d/yy"   matches: 01/20/00
//                      9/2/00
//  "MMM dd, yyyy hh:mm:ssa" matches: "January 01, 2000 12:30:45AM"
// ------------------------------------------------------------------

var MONTH_NAMES=new Array('January','February','March','April','May','June','July','August','September','October','November','December','Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec');
var DAY_NAMES=new Array('Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sun','Mon','Tue','Wed','Thu','Fri','Sat');
function LZ(x) {return(x<0||x>9?"":"0")+x}

// ------------------------------------------------------------------
// isDate ( date_string, format_string )
// Returns true if date string matches format of format string and
// is a valid date. Else returns false.
// It is recommended that you trim whitespace around the value before
// passing it to this function, as whitespace is NOT ignored!
// ------------------------------------------------------------------
function isDate(val,format) {
    if (format == null)
        format = 'd/M/yyyy';
	var date=getDateFromFormat(val,format);
	if (date==0) { return false; }
	return true;
	}

// -------------------------------------------------------------------
// compareDates(date1,date1format,date2,date2format)
//   Compare two date strings to see which is greater.
//   Returns:
//   1 if date1 is greater than date2
//   0 if date2 is greater than date1 of if they are the same
//  -1 if either of the dates is in an invalid format
// -------------------------------------------------------------------
function compareDates(date1,dateformat1,date2,dateformat2) {
	var d1=getDateFromFormat(date1,dateformat1);
	var d2=getDateFromFormat(date2,dateformat2);
	if (d1==0 || d2==0) {
		return -1;
		}
	else if (d1 > d2) {
		return 1;
		}
	return 0;
	}

// ------------------------------------------------------------------
// formatDate (date_object, format)
// Returns a date in the output format specified.
// The format string uses the same abbreviations as in getDateFromFormat()
// ------------------------------------------------------------------
function formatDate(date,format) {
	format=format+"";
	var result="";
	var i_format=0;
	var c="";
	var token="";
	var y=date.getYear()+"";
	var M=date.getMonth()+1;
	var d=date.getDate();
	var E=date.getDay();
	var H=date.getHours();
	var m=date.getMinutes();
	var s=date.getSeconds();
	var yyyy,yy,MMM,MM,dd,hh,h,mm,ss,ampm,HH,H,KK,K,kk,k;
	// Convert real date parts into formatted versions
	var value=new Object();
	if (y.length < 4) {y=""+(y-0+1900);}
	value["y"]=""+y;
	value["yyyy"]=y;
	value["yy"]=y.substring(2,4);
	value["M"]=M;
	value["MM"]=LZ(M);
	value["MMM"]=MONTH_NAMES[M-1];
	value["NNN"]=MONTH_NAMES[M+11];
	value["d"]=d;
	value["dd"]=LZ(d);
	value["E"]=DAY_NAMES[E+7];
	value["EE"]=DAY_NAMES[E];
	value["H"]=H;
	value["HH"]=LZ(H);
	if (H==0){value["h"]=12;}
	else if (H>12){value["h"]=H-12;}
	else {value["h"]=H;}
	value["hh"]=LZ(value["h"]);
	if (H>11){value["K"]=H-12;} else {value["K"]=H;}
	value["k"]=H+1;
	value["KK"]=LZ(value["K"]);
	value["kk"]=LZ(value["k"]);
	if (H > 11) { value["a"]="PM"; }
	else { value["a"]="AM"; }
	value["m"]=m;
	value["mm"]=LZ(m);
	value["s"]=s;
	value["ss"]=LZ(s);
	while (i_format < format.length) {
		c=format.charAt(i_format);
		token="";
		while ((format.charAt(i_format)==c) && (i_format < format.length)) {
			token += format.charAt(i_format++);
			}
		if (value[token] != null) { result=result + value[token]; }
		else { result=result + token; }
		}
	return result;
	}
	
// ------------------------------------------------------------------
// Utility functions for parsing in getDateFromFormat()
// ------------------------------------------------------------------
function _isInteger(val) {
	var digits="1234567890";
	for (var i=0; i < val.length; i++) {
		if (digits.indexOf(val.charAt(i))==-1) { return false; }
		}
	return true;
	}
function _getInt(str,i,minlength,maxlength) {
	for (var x=maxlength; x>=minlength; x--) {
		var token=str.substring(i,i+x);
		if (token.length < minlength) { return null; }
		if (_isInteger(token)) { return token; }
		}
	return null;
	}
	
// ------------------------------------------------------------------
// getDateFromFormat( date_string , format_string )
//
// This function takes a date string and a format string. It matches
// If the date string matches the format string, it returns the 
// getTime() of the date. If it does not match, it returns 0.
// ------------------------------------------------------------------
function getDateFromFormat(val,format) {
	val=val+"";
	format=format+"";
	var i_val=0;
	var i_format=0;
	var c="";
	var token="";
	var token2="";
	var x,y;
	var now=new Date();
	var year=now.getYear();
	var month=now.getMonth()+1;
	var date=1;
	var hh=now.getHours();
	var mm=now.getMinutes();
	var ss=now.getSeconds();
	var ampm="";
	
	while (i_format < format.length) {
		// Get next token from format string
		c=format.charAt(i_format);
		token="";
		while ((format.charAt(i_format)==c) && (i_format < format.length)) {
			token += format.charAt(i_format++);
			}
		// Extract contents of value based on format token
		if (token=="yyyy" || token=="yy" || token=="y") {
			if (token=="yyyy") { x=4;y=4; }
			if (token=="yy")   { x=2;y=2; }
			if (token=="y")    { x=2;y=4; }
			year=_getInt(val,i_val,x,y);
			if (year==null) { return 0; }
			i_val += year.length;
			if (year.length==2) {
				if (year > 70) { year=1900+(year-0); }
				else { year=2000+(year-0); }
				}
			}
		else if (token=="MMM"||token=="NNN"){
			month=0;
			for (var i=0; i<MONTH_NAMES.length; i++) {
				var month_name=MONTH_NAMES[i];
				if (val.substring(i_val,i_val+month_name.length).toLowerCase()==month_name.toLowerCase()) {
					if (token=="MMM"||(token=="NNN"&&i>11)) {
						month=i+1;
						if (month>12) { month -= 12; }
						i_val += month_name.length;
						break;
						}
					}
				}
			if ((month < 1)||(month>12)){return 0;}
			}
		else if (token=="EE"||token=="E"){
			for (var i=0; i<DAY_NAMES.length; i++) {
				var day_name=DAY_NAMES[i];
				if (val.substring(i_val,i_val+day_name.length).toLowerCase()==day_name.toLowerCase()) {
					i_val += day_name.length;
					break;
					}
				}
			}
		else if (token=="MM"||token=="M") {
			month=_getInt(val,i_val,token.length,2);
			if(month==null||(month<1)||(month>12)){return 0;}
			i_val+=month.length;}
		else if (token=="dd"||token=="d") {
			date=_getInt(val,i_val,token.length,2);
			if(date==null||(date<1)||(date>31)){return 0;}
			i_val+=date.length;}
		else if (token=="hh"||token=="h") {
			hh=_getInt(val,i_val,token.length,2);
			if(hh==null||(hh<1)||(hh>12)){return 0;}
			i_val+=hh.length;}
		else if (token=="HH"||token=="H") {
			hh=_getInt(val,i_val,token.length,2);
			if(hh==null||(hh<0)||(hh>23)){return 0;}
			i_val+=hh.length;}
		else if (token=="KK"||token=="K") {
			hh=_getInt(val,i_val,token.length,2);
			if(hh==null||(hh<0)||(hh>11)){return 0;}
			i_val+=hh.length;}
		else if (token=="kk"||token=="k") {
			hh=_getInt(val,i_val,token.length,2);
			if(hh==null||(hh<1)||(hh>24)){return 0;}
			i_val+=hh.length;hh--;}
		else if (token=="mm"||token=="m") {
			mm=_getInt(val,i_val,token.length,2);
			if(mm==null||(mm<0)||(mm>59)){return 0;}
			i_val+=mm.length;}
		else if (token=="ss"||token=="s") {
			ss=_getInt(val,i_val,token.length,2);
			if(ss==null||(ss<0)||(ss>59)){return 0;}
			i_val+=ss.length;}
		else if (token=="a") {
			if (val.substring(i_val,i_val+2).toLowerCase()=="am") {ampm="AM";}
			else if (val.substring(i_val,i_val+2).toLowerCase()=="pm") {ampm="PM";}
			else {return 0;}
			i_val+=2;}
		else {
			if (val.substring(i_val,i_val+token.length)!=token) {return 0;}
			else {i_val+=token.length;}
			}
		}
	// If there are any trailing characters left in the value, it doesn't match
	if (i_val != val.length) { return 0; }
	// Is date valid for month?
	if (month==2) {
		// Check for leap year
		if ( ( (year%4==0)&&(year%100 != 0) ) || (year%400==0) ) { // leap year
			if (date > 29){ return 0; }
			}
		else { if (date > 28) { return 0; } }
		}
	if ((month==4)||(month==6)||(month==9)||(month==11)) {
		if (date > 30) { return 0; }
		}
	// Correct hours value
	if (hh<12 && ampm=="PM") { hh=hh-0+12; }
	else if (hh>11 && ampm=="AM") { hh-=12; }
	var newdate=new Date(year,month-1,date,hh,mm,ss);
	return newdate.getTime();
	}

// ------------------------------------------------------------------
// parseDate( date_string [, prefer_euro_format] )
//
// This function takes a date string and tries to match it to a
// number of possible date formats to get the value. It will try to
// match against the following international formats, in this order:
// y-M-d   MMM d, y   MMM d,y   y-MMM-d   d-MMM-y  MMM d
// M/d/y   M-d-y      M.d.y     MMM-d     M/d      M-d
// d/M/y   d-M-y      d.M.y     d-MMM     d/M      d-M
// A second argument may be passed to instruct the method to search
// for formats like d/M/y (european format) before M/d/y (American).
// Returns a Date object or null if no patterns match.
// ------------------------------------------------------------------
function parseDate(val) {
	var preferEuro=(arguments.length==2)?arguments[1]:false;
	generalFormats=new Array('y-M-d','MMM d, y','MMM d,y','y-MMM-d','d-MMM-y','MMM d');
	monthFirst=new Array('M/d/y','M-d-y','M.d.y','MMM-d','M/d','M-d');
	dateFirst =new Array('d/M/y','d-M-y','d.M.y','d-MMM','d/M','d-M');
	var checkList=new Array('generalFormats',preferEuro?'dateFirst':'monthFirst',preferEuro?'monthFirst':'dateFirst');
	var d=null;
	for (var i=0; i<checkList.length; i++) {
		var l=window[checkList[i]];
		for (var j=0; j<l.length; j++) {
			d=getDateFromFormat(val,l[j]);
			if (d!=0) { return new Date(d); }
			}
		}
	return null;
	}
//import js.validation.isDate;
//import js.validation.isEmail;
//import js.validation.isEmpty;
//import js.validation.isNomeObjeto;
//import js.validation.isValidarTamanho;

function validarCampo(objeto, mensagem, condicao) {
  
  if (condicao) {
    erros.push(mensagem);
    if (!objFocus) {
      objFocus = objeto;
      objAba = aba;
    }
  }
  else {
    if (objeto.className == 'campo_erro') {
        objeto.className = objeto.getAttribute('classNameAntiga');
    }
  }
}

function validarCampoEmail(objeto, mensagem) {
    condicao = (!isEmail(objeto.value));
    validarCampo(objeto, mensagem, condicao);
}
function validarCampoNomeObjeto(objeto, mensagem) {
    condicao = (!isNomeObjeto(objeto.value));
    validarCampo(objeto, mensagem, condicao);
}

function validarCampoString(objeto, mensagem) {
    condicao = (isEmpty(objeto.value));
    validarCampo(objeto, mensagem, condicao);
}

function validarCampoHoraData(objeto, mensagem) {
    condicao = (!isDate(objeto.value, 'HH:mm dd/MM/yyyy'));
    validarCampo(objeto, mensagem, condicao);
}

function validarCampoDataHora(objeto, mensagem) {
    condicao = (!isDate(objeto.value, 'dd/MM/yyyy HH:mm'));
    validarCampo(objeto, mensagem, condicao);
}

function validarCampoHora(objeto, mensagem) {
    condicao = (!isDate(objeto.value, 'HH:mm'));
    validarCampo(objeto, mensagem, condicao);
}

function validarCampoData(objeto, mensagem) {
    condicao = (!isDate(objeto.value, 'dd/MM/yyyy'));
    validarCampo(objeto, mensagem, condicao);
}

function validarTamanhoCampo(objeto, tamanho, mensagem) {
    condicao = (!isValidarTamanho(objeto.value, tamanho));
    validarCampo(objeto, mensagem, condicao);
}
//import js.validation.isEmpty;
//import js.validation.isDate;

function trim(aString) {
  result = String(aString).replace(/^[\s]+/g, "");
  return result.replace(/[\s]+$/g,"");
}

function floatBr( numero ) {
  var tempn;
  var temp;

  numero = trim( numero );
  numero = numero.replace( ',' , '.' );
  tempn  = numero.split( '.' );
  if( ! tempn[ 1 ] || tempn[ 1 ] == 'undefined' ) {
    tempn[ 1 ]  = '00';
  }
  if( ! tempn[ 0 ] || tempn[ 0 ] == 'undefined' ) {
    tempn[ 0 ] = '0';
  }
  res  = String( parseFloat( tempn[ 0 ] + '.' + tempn[ 1 ] ) ).replace( '.' , ',' ); 
  temp = String( res ).split( ',' );
  if( ! temp[ 1 ] || temp[ 1 ] == 'undefined' ) {
    temp[ 1 ] = '0';
  }
  res = temp[ 0 ] + ',' + temp[ 1 ]; 
  return  res
}

/**
 * validar um input de um form
 * @type void
 * @param oElement campo do form que será validado
 * @type oElement obj
 *
 * @note atributos disponíveis:
 *   - upper
 *   - lower
 *   - filter
 *   - format
 *   - tab
 *   - fmtdata
 *   - floatbr
 */
function validateElement( oElement ) {
  if( ! oElement.bProcessed ){

    // flag para testar se o elemento já foi validado
    oElement.bProcessed = false;

    //*** BEGIN OnBlur ********************************************************
    if ( browser.isGecko ) window.captureEvents( Event.BLUR );
    oElement.oldOnBlur = oElement.onblur;
    oElement.onblur    = function ( event ) {
      // propriedade 'upper'
      // colocar todos os caracteres do imput em maiusculo
      //------------------------------------------------------------------------------------------------------------------------------------
      var sFmtUpperCase = this.getAttribute( "upper" ) == "upper";
      if( sFmtUpperCase ){
        this.value = this.value.toUpperCase();
      }

      // propriedade 'lower'
      // colocar todos os caracteres do imput em minusculo
      //------------------------------------------------------------------------------------------------------------------------------------
      var sFmtLowerCase = this.getAttribute( "lower" ) == "lower";
      if ( sFmtLowerCase ){
        this.value = this.value.toLowerCase();
      }

      // propriedade 'filter'
      // filtra o valor do campo
      //------------------------------------------------------------------------------------------------------------------------------------
      var sFmtfilter = this.getAttribute( "filter" );
      if ( sFmtfilter ){
        var re = new RegExp( '[^' + sFmtfilter + ']' );

        // propriedade 'format'
        // formato que o campo aceita (mascara)
        //-----------------------------------------------------------------------------------------------------------------------------------
        var sFrmFormat = oElement.getAttribute( "format" );
        if ( sFrmFormat ) {
          rex = sFrmFormat;
          while ( rex.indexOf( '#' ) != -1 ) rex = rex.replace( '#' , '[' + sFmtfilter + ']' );
          rex = '^' + rex + '$';
          rex = new RegExp( rex );
          if ( ! rex.test( this.value ) ) {
            oElement.value = '';
          }
        } else {
          if ( re.test( this.value ) ){
            oElement.value = '';
          }
          if ( browser.isGecko ) {
            event.preventDefault();
          } else {
            window.event.returnValue = false;
          }
        }
      }

      // propriedade 'float'
      // formato que o campo aceita (mascara)
      //-----------------------------------------------------------------------------------------------------------------------------------
      var sFmtFloatBrasil = this.getAttribute( "float" ) == "float";
      if ( sFmtFloatBrasil ) {
        this.value = floatBr( this.value );
      }

      // propriedade 'format'
      // formato que o campo aceita (mascara)
      //-----------------------------------------------------------------------------------------------------------------------------------
      var sFmtDate = this.getAttribute( "fmtdata" );
      if ( sFmtDate ) {
        this.value = fmtDateBr( this.value );
      }
      try {
        this.oldOnBlur();
      } catch ( err ) {}
    }
    //*** END OnBlur ********************************************************

    //*** BEGIN OnFocus *******************************************************
    if ( browser.isGecko ) window.captureEvents( Event.FOCUS );
    oElement.oldOnFocus = oElement.onfocus;
    oElement.onfocus    = function ( event ) {
      var sFmtFloatBrasil = this.getAttribute( "float" ) == "float";
      if( sFmtFloatBrasil ) {
        this.value = floatBr( this.value );
        this.select();
      }
      try {
        this.oldOnFocus();
      } catch ( err ) {}
    }
    //*** END OnFocus *********************************************************

    //*** BEGIN OnKeyPress ****************************************************
    if ( browser.isGecko ) window.captureEvents( Event.KEYPRESS );
    oElement.oldOnKeypress = oElement.onkeypress;
    oElement.onkeypress    = function ( event ) {
      var keyCode  = ( ! window.event ) ? event.which : window.event.keyCode;
      // comparação que permite que as teclas de controle nao sejam tratadas
      //------------------------------------------------------------------------------------------------------------------------------------
      pressedKey  = String.fromCharCode( keyCode );
      if ( pressedKey == '\r' || parseInt( pressedKey.charCodeAt( 0 ) ) == 0 || parseInt( pressedKey.charCodeAt( 0 ) ) == 8 || pressedKey == '' ) {
        return true;
      }

      // propriedade 'upper'
      // colocar todos os caracteres do imput em maiusculo
      //------------------------------------------------------------------------------------------------------------------------------------
      var sFmtUpperCase = this.getAttribute( "upper" ) == "upper";
      if ( sFmtUpperCase ) {
        this.value = this.value.toUpperCase();
        this.style.textTransform = 'uppercase';
      }

      // propriedade 'lower'
      // colocar todos os caracteres do imput em minusculo
      //------------------------------------------------------------------------------------------------------------------------------------
      var sFmtLowerCase = this.getAttribute( "lower" ) == "lower";
      if ( sFmtLowerCase ) {
        this.style.textTransform = 'lowercase';
      }

      // propriedade 'filter'
      // filtra o valor do campo
      //------------------------------------------------------------------------------------------------------------------------------------
      var sFmtfilter = this.getAttribute( "filter" );
      if ( sFmtfilter ) {
        var sKey = String.fromCharCode( keyCode );
        var re   = new RegExp( '[^' + sFmtfilter + ']' );
        if ( re.test( sKey ) ) {
          try {
            event.preventDefault();
          } catch ( err ) {
            window.event.returnValue = false;
          }
          return false
        }
      }

      // propriedade 'format'
      // formato que o campo aceita (mascara)
      //-----------------------------------------------------------------------------------------------------------------------------------
      var sFrmFormat = this.getAttribute( "format" );
      if( sFrmFormat ) {
        var stext        = this.value;
        var sKey         = String.fromCharCode( keyCode );
        var strSelection = ( document.selection ) ? document.selection.createRange().text : this.value.substr( this.selectionStart , this.selectionEnd );
        if ( strSelection != '' ) {
          this.value = '';
          try {
            event.preventDefault();
          } catch ( err ) {
            window.event.returnValue = false;
          }
          //document.selection.clear();
        } else {
          if ( sFrmFormat.substr( stext.length , 1 ) == '#' ) {
            if ( ( sFrmFormat.substr( stext.length + 1 , 1 ) != '#' ) && ( sFrmFormat.substr( stext.length + 1 , 1 ) != '' ) ) {
              this.value = this.value + sKey + sFrmFormat.substr( stext.length + 1 , 1 );
              try {
                event.preventDefault();
              } catch ( err ) {
                window.event.returnValue = false;
              }
            } else {
              return true;
            }
          } else {
            if ( stext.length + 1 <= sFrmFormat.length ){
              this.value = this.value + sFrmFormat.substr( stext.length , 1 ) + sKey;
              //keyCode = 0;
            }
            try {
              event.preventDefault();
            } catch ( err ) {
              window.event.returnValue = false;
            }
          }
        }
      }

      // propriedade 'tab'
      // tab automatico para o campo passado de parametro
      //-----------------------------------------------------------------------------------------------------------------------------------
      var sAutotab = this.getAttribute( "tab" );
      if( sAutotab ) {
        e = this.form.elements;
        if ( this.value.length + 1 == this.getAttribute( "maxlength" ) ) {
          var tForm      = this.form;
          var elementobj = null;
          for ( i = 0 ; i < tForm.elements.length ; i++ ){
            if ( sAutotab == tForm.elements[ i ].name ) {
              var elementobj = tForm.elements[ i ];
              break;
            }
          }
          var elementobj = ( elementobj != null ) ? elementobj : eval( sAutotab );
          var sKey       = String.fromCharCode( keyCode );
          this.value     = this.value + sKey;

          if ( browser.isGecko ) {
            event.preventDefault();
          } else {
            window.event.returnValue = false;
          }
          elementobj.focus();
          elementobj.select();
        }
      }

      // propriedade 'floatbr'
      // formata o numero como float
      //-----------------------------------------------------------------------------------------------------------------------------------
      var sFmtFloatBrasil = this.getAttribute( "float" ) == "float";
      if( sFmtFloatBrasil ) {
        var sKey    = String.fromCharCode( keyCode );
        var re      = new RegExp( '[^0-9,]|(,[0-9]*,)' );
        var atestar = this.value + sKey
        if ( re.test( atestar ) ) {
          if ( browser.isGecko ) {
            event.preventDefault();
          } else {
            window.event.returnValue = false;
          }
        }
      }

      // propriedade 'fmtdata'
      // formata o campo completando com o caracter '/' ( somente data no formato br )
      //-----------------------------------------------------------------------------------------------------------------------------------
      var sFmtDate = this.getAttribute( "fmtdata" ) == 'fmtdata';
      if( sFmtDate ) {
        this.maxlength = '10';
        var sKey    = String.fromCharCode( keyCode );
        var re      = new RegExp( '[^0-9/]|(/[0-9]*/[0-9]*/)' );
        var atestar = this.value + sKey

        if( re.test( atestar ) ) {
          if ( event.preventDefault ) {
            event.preventDefault();
          } else {
            window.event.returnValue = false;
          }
        } else {
          atestar = this.value;
          if ( sKey != '/' ) {
            if ( ( atestar.length == 1 ) || ( atestar.length == 4 ) ) {
              this.value += sKey + '/';
              if ( browser.isGecko ) {
                event.preventDefault();
              } else {
                window.event.returnValue = false;
              }
            } else if ( ( atestar.length == 2 ) || ( atestar.length == 5 ) ) {
              this.value += '/';
            }
          } else {
            if ( ( atestar.length == 0 ) || ( atestar.length == 3 ) ) {
              if ( browser.isGecko ) {
                event.preventDefault();
              } else {
                window.event.returnValue = false;
              }
            } else if ( atestar.length == 1 ) {
              this.value = '0' + this.value;
            } else if ( atestar.length == 4 ) {
              this.value = this.value.substr( 0 , 3 ) + '0' + this.value.substr( 3 , 1 );
            }
          }
        }
      }
      try {
        this.oldOnKeypress();
      } catch ( err ) {}
    }
    //*** END OnKeyPress ******************************************************

  }
}
/**
 * @class comparação de browsers.
 */
function Browser() {
  /**
   * se o navegador for baseado na tecnologia gecko
   * @type bool
   */
  this.isGecko     = window.navigator.userAgent.toLowerCase().indexOf( 'gecko' ) != -1;
  /**
   * se for a coisa do ie
   * @type bool
   */
  this.isIe        = window.navigator.userAgent.toLowerCase().indexOf( 'msie' )  != -1;
  /**
   * se for o opera
   * @type bool
   */
  this.isOpera     = window.navigator.userAgent.toLowerCase().indexOf( 'opera' ) != -1;
  /**
   * se for o konqueror ou safari
   * @type bool
   */
  this.isKonqueror = window.navigator.userAgent.toLowerCase().indexOf( 'khtml' ) != -1;
}
browser = new Browser();
/**
 * validar números de cnpj
 * @type void
 * @param cnpj recebe o número do cnpj, com ou sem mascara ( ##.###.###/####-## )
 * @type  cnpj str
 *
 * @return bool
 */
function isCnpj( cnpj ) {
  // flag para o return
  var erro  = 0;

  quatorze  = /^(\d{14})+$/;
  soNum     = /^(\d{2})+\.+(\d{3})+\.+(\d{3})+(\/|\\)+(\d{4})+\-+(\d{2})+$/;
  if ( ! quatorze.test( cnpj ) ) {
    if ( soNum.test( cnpj ) ) {
      num  = soNum.exec( cnpj );
      cnpj = num[ 1 ] + num[ 2 ] + num[ 3 ] + num[ 5 ] + num[ 6 ];
    } else {
      erro++;
    }
  }
  var a = [];
  var b = new Number;
  var c = [6,5,4,3,2,9,8,7,6,5,4,3,2];
  for ( i = 0 ; i < 12 ; i++ ){
    a[ i ] = cnpj.charAt( i );
    b += a[ i ] * c[ i + 1 ];
  }
  a[ 12 ] = ( ( x = b % 11 ) < 2 ) ? 0 : 11 - x;
  b = 0;
  for ( y = 0 ; y < 13 ; y++ ) {
    b += ( a[ y ] * c[ y ] );
  }
  a[ 13 ] = ( ( x = b % 11 ) < 2 ) ? 0 : 11-x;
  if ( ( cnpj.charAt( 12 ) != a[ 12 ] ) || ( cnpj.charAt( 13 ) != a[ 13 ] ) ) {
    erro++;
  }
  if ( erro > 0 ){
    return false;
  }
  return true;
}/**
  * função que valida se uma string é um email válido
  * @type Bolean
  * @param email {String} recebe a string do email
  * @return resposta booleana, dependendo se o email e ou nao valida
  */
function isEmail(email)
{
    validEmail = /^([\w\.\-])+@+([\w\.\-])+([\.])+([\w\.\-])+$/i;
    return validEmail.test(email);
}
//import js.validation.validateElement;
//import js.validation.isEmail;
//import js.validation.isCnpj;
//import js.validation.isCpf;
//import js.string.trim;
//import js.string.zfill;
//import js.format.floatBr2Us;
//import js.format.floatBr;
//import js.format.fmtDateBr;
//import js.utils.Browser;
//import js.format.fmtDate;
//import js.validation.isDate;

/**
 * Inicializa o validateForm de todos os forms da pagina.
 */
function init()
{
	for (var i = 0; i < document.forms.length; validateForm(document.forms[i], i++));
	if (window.tonload)
        tonload();
} 

if(window.addEventListener)
	window.addEventListener('load', init, false);

else if(window.attachEvent)
	window.attachEvent('onload', init);

else
{
	if(window.onload)
        window.tonload = window.onload;

	window.onload = init;
}  

// JavaScript Document
/**
 * valida todos os campos do formulário usando a função validateElement
 * e o atributo require dos campos
 * @type void
 * @param oForm formulário a ser validado
 * @type  oForm obj
 * @throws caso o usuário passe um id de div inválido no atributo 'div'
 * @throws caso o usuário passe um id de div repetido no atributo 'div'
 * @last update: Ruhan Bidart<ruhan@2xt.com.br> - 08/09/2006  
 */
function validateForm(oForm) {
    var _elem = oForm.elements;
    for (var i = 0; i < _elem.length; i++)
    {
        validateElement(_elem[i]);
    }

    oForm.oldOnSubmit = oForm.onsubmit;
    oForm.onsubmit = function ()
    {
        disabledForm(oForm, true);                                             
        var _elem = this.elements;
        var _msgs = [];
        // numero do div para onde a msg sera direcionada
        var numMsg;
        for (var i = 0; i < _elem.length; i++)
        {               
            // atributo 'require'
            sRequire = _elem[i].getAttribute('require');
            if (sRequire)
            {
                sValor = (_elem[i].tagName.toLowerCase() == 'select') ? _elem[i][_elem[i].selectedIndex].value : _elem[i].value;
                try
                {
                    var sFunc = eval(_elem[i].getAttribute('function'));
                }
                catch (err)
                {
                }
                var sFunc = (typeof(sFunc) == 'function') ? sFunc : function () { return true; };

                if (sRequire && (isEmpty(sValor) || !sFunc(sValor)))
                {
                    // apanha o numero do div da mensagem
                    numMsg = sRequire.substr(0,1);
                    if(isNaN(numMsg))
                        throw 'Deve-se passar, no início da mensagem: ' + sRequire + ' o número referente ao div de erros.';
                    else
                    {                    
                        numMsg = parseInt(numMsg);                    
                        // tira o numero da mensagem
                        sRequire = sRequire.substr(1, sRequire.length);
                        // para que não apareça o undefined
                        if(_msgs[numMsg] == undefined)
                            _msgs[numMsg] = '';
                            
                        // povoa a lista de mensagens  
                        var a = document.createElement('a');
                        var span = document.createElement('span');

                        // cria um link para o campo com erro
                        a.setAttribute('href', '#erros');
                        a.setAttribute('onClick', 'document.getElementById(\'' + _elem[i].id + '\').focus()');  
                        a.innerHTML = sRequire;                        
                        span.appendChild(a);
                        _msgs[numMsg] += span.innerHTML + '\n'; 
                    }
                }
            }
        }
        disabledForm(oForm, false);         
        if (_msgs.length > 0)
        {
            s = this.getAttribute('requires');
            if (s != null && s != 'undefined')
                _msg = s + '\n' + _msg;

            div = this.getAttribute('div');
            if (div)
            {
                // no parametro 'div' são passados todos os divs utilizados para se mostrar
                // a resposta.
                var divs = div.split(',');
                var objDivs = [];
                for(var i = 0; i < divs.length; i++)
                {
                    objDivs[i] = document.getElementById(divs[i]);
                    if (objDivs[i] == null)
                    {
                        throw 'Não há div com o id ' + divs[i];                    
                    }    
                }
                for(i = 1; i < _msgs.length; i++)
                {
                    if(!(_msgs[i] == undefined))
                    {
                        // formata as mensagens
                        while (_msgs[i].indexOf('\n') != -1)
                            _msgs[i] = _msgs[i].replace('\n', '<br />');
                        // insere as mensagens nos divs correspondentes
                        objDivs[i - 1].innerHTML = _msgs[i];
                        objDivs[i - 1].style.display = 'block';                      
                    }               
                }      
                // direciona para o primeiro div onde ocorreram os erros               
                window.scrollTo(0,400);
            }
            else
                window.alert(_msgs);

            _msgs = '';
            return false;
        }
        try
        {
            // mostra a mensagem de sucesso
            disabledForm(_elem, false);                                                         
            window.scrollTo(0,250);            
            return this.oldOnSubmit();            
        }
        catch (err)
        {
        }
    }
}
/**
 * validar números de cpf
 * @type void
 * @param cpf recebe o número do cpf, aceito com ou sem mascara ( ###.###.###-## )
 * @type  cpf str
 * 
 * @returnx bool
 */
function isCpf( cpf ) {
  // flag para o return
  var erro  = 0;
  
  // só caracteres numéricos
  onze = /^(\d{11})+$/;
  if ( ! onze.test( cpf ) ) {
    // tento tirar a mascara que o campo pode ter
    soNum = /^(\d{3})+\.+(\d{3})+\.+(\d{3})+\-+(\d{2})+$/;
    if ( soNum.test( cpf ) ) {
      num = soNum.exec( cpf );
      cpf = num[ 1 ] + num[ 2 ] + num[ 3 ] + num[ 4 ];
    } else {
      erro++;
    }
  }

  if ( cpf == "00000000000" || cpf == "11111111111" || cpf == "22222222222" || cpf == "33333333333" || cpf == "44444444444" || cpf == "55555555555" || cpf == "66666666666" || cpf == "77777777777" || cpf == "88888888888" || cpf == "99999999999" ){
      erro++;
  }
  var a = [];
  var b = new Number;
  var c = 11;
  for ( var i = 0 ; i < 11 ; i++ ){
    a[ i ] = cpf.charAt(i);
    if ( i < 9 ) {
      b += ( a[ i ] * --c );
    }
  }
  a[ 9 ] = ( ( x = b % 11 ) < 2 ) ? 0 : 11 - x;
  b = 0;
  c = 11;
  for ( y = 0 ; y < 10 ; y++ ) {
    b += ( a[ y ] * c-- );
  }
  a[ 10 ] = ((x = b % 11) < 2) ? 0 : 11 - x;
  if ( ( cpf.charAt( 9 ) != a[ 9 ] ) || ( cpf.charAt( 10 ) != a[ 10 ] ) ) {
    erro++;
  }
  if ( erro > 0 ){
    return false;
  }
  return true;
}
/**
 * testar se a string s passada de parametro esta vazia ou nao
 * @type void
 * @param s recebe a string a ser testada
 * @type  s str
 *
 * @return bool
 */
function isEmpty( s ) {
  var re = /\s/g;
  var s  = s.replace( re , "" );

  RegExp.multiline = true;

  // validação tambem para os campos que contem o atributo 'float'
  return ( s.length == 0 || s == '0,0' ) ? true : false;
}

function isSenha(s) {
    sSenha = document.getElementById('senha').value 
    sConfirmacao = document.getElementById('repita').value
    if(sSenha.length >= 5) return true
    return false
}

function isConfirm(s) {
    sSenha = document.getElementById('senha').value 
    sConfirmacao = document.getElementById('repita').value
    if(sSenha == sConfirmacao) return true
    return false
}