// --
// Str2Att()
// --
function Str2Att(valueOfField, typeOfField) {
  var retValue;
  switch(typeOfField) {
    case "S":
      if ((valueOfField=="undefined")||(valueOfField=="")) {
        retValue = null;
      } else {
        retValue = String(valueOfField);
      }
      break; 
    case "I":
      valueOfField = String(valueOfField).replace(/\./gi,"");
      valueOfField = String(valueOfField).replace(/,/gi,".");
      retValue = parseInt(valueOfField, 10);
      break;
    case "F":
      valueOfField = String(valueOfField).replace(/\./gi,"");
      valueOfField = String(valueOfField).replace(/,/gi,".");
      retValue = parseFloat(valueOfField);
      break;
    case "GLAT":
    case "GLON":
      retValue = valueOfField;
      break;
    case "DT":
      if (valueOfField=="") {
        retValue = "";
      } else {
        var GetTime = getDateFromFormat(valueOfField, "dd/MM/yyyy HH:mm:ss");
        if (GetTime==0) {
          retValue = Number.NaN;
        } else {
          retValue = new Date(GetTime);
        }
      }
      break;
    case "D":
      if (valueOfField=="") {
        retValue = "";
      } else {
        var GetTime = getDateFromFormat( valueOfField, "dd/MM/yyyy");
        if (GetTime==0) {
          retValue = Number.NaN;
        } else {
          retValue = new Date(GetTime);
        }
      }
      break;
    case "T":
      if (valueOfField=="") {
        retValue = "";
      } else {
        retValue = new Date(getDateFromFormat( valueOfField, "HH:mm:ss" ));
      }
      break;
    default:
      retValue = null;
      break;
  }
  return retValue;
} // Str2Att()

// --
// Att2Str()
// --
function Att2Str(valueOfField, typeOfField) {
  var retValue;
  switch(typeOfField) {
    case "S":
      if ((valueOfField==null)) {
        retValue = "";
      } else {
        retValue = ""+valueOfField;
      }
      break; 
    case "I":
      if (isNaN(valueOfField)) {
        retValue = "";
      } else {
        retValue = parseInt(valueOfField, 10);  
        if (isNaN(retValue)) {
          retValue = "";
        } else {
          retValue = String(retValue).replace(/\./gi,",");
        }
      }
      break;
    case "F":
      if (isNaN(valueOfField)) {
        retValue = "";
      } else {
        retValue = parseFloat(valueOfField);
        if (isNaN(retValue)) {
          retvalue = "";
        } else {
          retValue = String(retValue).replace(/\./gi,",");
        }
      }
      break;
    case "GLAT":
      if (isNaN(valueOfField)) {
        retValue = "";
      } else {
        retValue = parseFloat(valueOfField);
        if (isNaN(retValue)) {
          retvalue = "";
        } else {
          retValue = valueOfField;
        }
      }
      break;
    case "GLON":
      if (isNaN(valueOfField)) {
        retValue = "";
      } else {
        retValue = parseFloat(valueOfField);
        if (isNaN(retValue)) {
          retvalue = "";
        } else {
          retValue = valueOfField;
        }
      }
      break;
    case "DT":
      var dt = new Date(valueOfField);
      if (isNaN(dt)) {
        retValue = "";
      } else {
        retValue = formatDate(dt,"dd/MM/yyyy HH:mm:ss");
      }
      break;
    case "D":
      var dt = new Date(valueOfField);
      if (isNaN(dt)) {
        retValue = "";
      } else {
        retValue = formatDate(dt,"dd/MM/yyyy");
      }
      break;
    case "T":
      var dt = new Date(valueOfField);
      if (isNaN(dt)) {
        retValue = "";
      } else {
        retValue = formatDate(dt,"HH:mm:ss");
      }
      break;
    default:
      retValue = "";
      break;
  }
  return retValue;
} // Att2Str()

// --
// AttFormat()
// --
function AttFormat(valueOfField, typeOfField) {
  var retValue;
  switch(typeOfField) {
    case "S":
      if ((valueOfField==null)||(valueOfField=="undefined")) {
        retValue = "";
      } else {
        retValue = String(valueOfField).replace(/'/gi,"&#39");
      }
      break; 
    case "I":
      if (isNaN(valueOfField)) {
        retValue = "";
      } else {
        retValue = parseInt(valueOfField, 10);  
        if (isNaN(retValue)) {
          retValue = "";
        } else {
          retValue = formatNumber(valueOfField, "#,##0");
        }
      }
      break;
    case "F":
      if (isNaN(valueOfField)) {
        retValue = "";
      } else {
        retValue = parseFloat(valueOfField);
        if (isNaN(retValue)) {
          retvalue = "";
        } else {
          retValue = formatNumber(valueOfField, "#,##0.00");
        }
      }
      break;
    case "GLAT":
      if (isNaN(valueOfField)) {
        retValue = "";
      } else {
        retValue = parseFloat(valueOfField);
        if (isNaN(retValue)) {
          retvalue = "";
        } else {
          retValue = valueOfField;
        }
      }
      break;
    case "GLON":
      if (isNaN(valueOfField)) {
        retValue = "";
      } else {
        retValue = parseFloat(valueOfField);
        if (isNaN(retValue)) {
          retvalue = "";
        } else {
          retValue = valueOfField;
        }
      }
      break;
    case "DT":
      var dt = new Date(valueOfField);
      if (isNaN(dt)) {
        retValue = "";
      } else {
        retValue = formatDate(dt,"dd/MM/yyyy HH:mm:ss");
      }
      break;
    case "D":
      var dt = new Date(valueOfField);
      if (isNaN(dt)) {
        retValue = "";
      } else {
        retValue = formatDate(dt,"dd/MM/yyyy");
      }
      break;
    case "T":
      var dt = new Date(valueOfField);
      if (isNaN(dt)) {
        retValue = "";
      } else {
        retValue = formatDate(dt,"HH:mm:ss");
      }
      break;
    default:
      retValue = "";
      break;
  }
  return retValue;
} // AttFormat()

// --
// Arr2Str()
// --
function Arr2Str(pStr, pIni, pFim) {
  var retValue = "";
  var aStr = pStr.split(",");
  for (var x=0; x<aStr.length; x++) {
    retValue += pIni + eval(aStr[x]) + pFim;
  }
  return retValue;
} // Arr2Str()

function leftfill(chr, tam) {
  var retValue = this;
  if (this.length<tam) {
    var rep = "";
    for (var x=0; x<tam-this.length; x++) {
      rep += chr;
    }
    retValue = rep + retValue;
  }
  return retValue;
} // leftfill()

function rightfill(chr, tam) {
  var retValue = this;
  if (this.length<tam) {
    var rep = "";
    for (var x=0; x<tam-this.length; x++) {
      rep += chr;
    }
    retValue += rep;
  }
  return retValue;
} // rightfill()

// --
// left()
// Retorna String, limitado aos n caracteres à esquerda
// --
function left(n) {
  return n<=this.length?this.substr(0,n):this;
} // left()

// --
// right()
// Retorna String, limitado aos n caracteres à direita
// --
function right(n) {
  return n<=this.length?this.substr(this.length-n,n):this;
} // right()

// --
// count()
// Retorna o Número de Ocorrências de um Caracter em um String
// --
function count(chr) {
  count=this.split(chr);
  return count.length-1; 
} // count()

// --
// trim()
// Remove Caracteres Em Branco à Direita e à Esquerda de String
// --
function trim() {
  var a = this.ltrim().rtrim();
  return a;
} // trim

// --
// ltrim()
// Remove Caracteres Em Branco à Esquerda de String
// --
function ltrim() {
  var regex1 = /^\s+/;
  var a = this.replace(regex1,'');
  return a;
} // ltrim()

// --
// rtrim()
// Remove Caracteres Em Branco à Direita de String
// --
function rtrim() {
  var regex1 = /\s+$/;
  var a = this.replace(regex1,'');
  return a;
} // rtrim()

// --
// strip()
// Remove Caracteres Especiais de String
// --
function strip() {
  var regex1 = /[\.,\?;:'"\(\){}\[\]\!]+/g;
  var a = this.replace(regex1,'');
  return a;
} // strip()

// --
// stripall()
// Remove Caracteres Especiais de String
// --
function stripall() {
  var regex1 = /[-\.,\?;:'"\(\){}\[\]\!]+/g;
  var a = this.replace(regex1,'');
  return a;
} // stripall()

// --
// stripAlpha()
// --
function stripAlpha() {
  var regex1 = /[^0-9]+/gi;
  var a = this.replace(regex1,'');
  return a;
} // stripAlpha()

// --
// isDate()
// Retorna true, se o Valor for um Data
// --
function isDate() {
  var s = this.stripAlpha();
  var b = true;
  if (s.length!=8) {
    b = false;
    return b;
  } else {
    var day;
    var month;
    var year;
    var leap = 0;
    year = s.right(4);
    if (year == 0) { 
      b = false;
      return b;
    }
    month = s.substr(2,2);
    if ((month < 1) || (month > 12)) {
      b = false;
      return b;
    }
    day = s.left(2);
    if (day < 1) {
      b = false;
      return b;
    }
    if ((year % 4 == 0) || (year % 100 == 0) || (year % 400 == 0)) {
      leap = 1;
    }
    if ((month == 2) && (leap == 1) && (day > 29)) {
      b = false;
      return b;
    }
    if ((month == 2) && (leap != 1) && (day > 28)) {
      b = false;
      return b;
    }
    if ((day > 31) && ((month == "01") || (month == "03") || (month == "05") || (month == "07") || (month == "08") || (month == "10") || (month == "12"))) {
      b = false;
      return b;
    }
    if ((day > 30) && ((month == "04") || (month == "06") || (month == "09") || (month == "11"))) {
      b = false;
      return b;
    }
  }
  return b;
} // isDate()

// ---
// isNull()
// Retorna true, se o valor é nulo
// ---
function isNull(val) { 
  return( val==null );
} // isNull()

// ---
// isBlank()
// Retorna true, se o valor contiver somente espaços
// ---
function isBlank(val) {
  if(val==null) {
    return true;
  }
  for(var i=0;i<val.length;i++) {
    if ((val.charAt(i)!=' ')&&(val.charAt(i)!="\t")&&(val.charAt(i)!="\n")&&(val.charAt(i)!="\r")){
      return false;
    }
  }
  return true;
} // isBlank()

// ---
// isInteger()
// Retorna true, se o valor contiver somente dígitos
// ---
function isInteger(val) {
  val = val.trim();
  val = val.replace(/\./gi,'');
  val = val.replace(/^0*\s/gi,'');
  if (isBlank(val)) { return false; }
  for(var i=0;i<val.length;i++) {
    if(!isDigit(val.charAt(i))) { 
      return false;
    }
  }
  return true;
} // isInteger()

// ---
// isArray(obj)
// Returns true if the object is an array, else false
// ---
function isArray(obj){
  return (typeof(obj.length)=="undefined")?false:true;
}

// ---
// isDigit(value)
// Returns true if value is a 1-character digit
// ---
function isDigit(num) {
  if (num.length>1) {
    return false;
  }
  var string="1234567890";
  if (string.indexOf(num)!=-1){
    return true;
  }
  return false;
}

// ---
// isNumeric(value)
// Retorna true, se o valor representar um valor em ponto flutuante
// ---
function isNumeric(val) {
  var psin  = "";
  var pint  = "";
  var pfrac = "";
  var s = val;
  s = s.trim();
  s = s.replace(/^0*\s\./gi,'');
  if (isBlank(s)) {
    return false;
  }
  var a = s.split(',');
  if (a.length>2) {
    return false;
  }
  if (a[0].length==0) {
    psin = "";
    pint = "0";
  } else {
    if (a[0].charAt(0)=="-") {
      psin = "-";
      a[0] = a[0].replace(/\-/gi,'');
    }
    if (a[0].length==0) {
      pint = 0;
    } else {
 	    if (!(isInteger(a[0]))) {
        return false;
      } else {
        pint = parseInt(a[0], 10);
      }
    }
  }
  if (a.length==1) {
    pfrac = "0";
  } else {
    if (a[1].length==0) {
      pfrac = "0";
    } else {
      if (!(isInteger(a[1]))) {
        return false;
      } else {
        pfrac = parseInt(a[1], 10);
      }
	  }
  }
  return true;
} // isNumeric()

function mod(a, b) { return a-Math.floor(a/b)*b }
function div(a, b) { return Math.floor(a/b) }
function max(a, b) { if (a>b) { return a } else { return b } }

// --
// formatNumber()
// --
function formatNumber(number,pattern) {
  if (!(isNumeric(""+number))) { number = 0; }
  var str = number.toString();
  var strInt;
  var strFloat;
  var formatInt;
  var formatFloat;
  if(/\./g.test(pattern)) {
    formatInt = pattern.split('.')[0];
    formatFloat	= pattern.split('.')[1];
  } else {
    formatInt = pattern;
	formatFloat	= null;
  }
  if(/\./g.test(str)) {
    if(formatFloat!=null) {
      var tempFloat	= Math.round(parseFloat('0.'+str.split('.')[1])*Math.pow(10,formatFloat.length))/Math.pow(10,formatFloat.length);
      strInt = (Math.floor(number)+Math.floor(tempFloat)).toString();				
      strFloat	= /\./g.test(tempFloat.toString())?tempFloat.toString().split('.')[1]:'0';
    } else {
      strInt = Math.round(number).toString();
      strFloat	= '0';
    }
  } else {
    strInt = str;
    strFloat = '0';
  }
  if(formatInt!=null) {
    var outputInt	= '';
	var zero = formatInt.match(/0*$/)[0].length;
    var comma = null;
	if(/,/g.test(formatInt)) {
      comma	= formatInt.match(/,[^,]*/)[0].length-1;
    }
	var newReg	= new RegExp('(\\d{'+comma+'})','g');
    if(strInt.length<zero) {
      outputInt	= new Array(zero+1).join('0')+strInt;
	  outputInt	= outputInt.substr(outputInt.length-zero,zero)
	} else {
      outputInt	= strInt;
    }
	var 
	outputInt = outputInt.substr(0,outputInt.length%comma)+outputInt.substring(outputInt.length%comma).replace(newReg,(comma!=null?',':'')+'$1');
    outputInt = outputInt.replace(/^,/,'');
	strInt	= outputInt;
  }
  if(formatFloat!=null) {
    var outputFloat	= '';
	var zero = formatFloat.match(/^0*/)[0].length;
    if(strFloat.length<zero) {
      outputFloat		= strFloat+new Array(zero+1).join('0');
	  //outputFloat		= outputFloat.substring(0,formatFloat.length);
	  var outputFloat1	= outputFloat.substring(0,zero);
	  var outputFloat2	= outputFloat.substring(zero,formatFloat.length);
	  outputFloat		= outputFloat1+outputFloat2.replace(/0*$/,'');
	} else {
      outputFloat = strFloat.substring(0,formatFloat.length);
    }
	strFloat = outputFloat;
  } else {
    if(pattern!='' || (pattern=='' && strFloat=='0')) {
      strFloat	= '';
    }
  }
  strInt = strInt.replace(/,/gi,'.');
  return strInt+(strFloat==''?'':','+strFloat);
} // formatNumber()

// --
// numbersonly()
// --
function numbersonly(f, e, dec) {
  var key, keychar;
  if (window.event) {
    key = window.event.keyCode;
  } else if (e) {
    key = e.which;
  } else {
    return true;
  }
  keychar = String.fromCharCode(key);
  if ((key==null) || (key==0) || (key==8) || (key==9) || (key==13) || (key==27) ) {
    return true;
  } else if ((("0123456789").indexOf(keychar) > -1)) {
    return true;
  } else if (dec && (keychar == ",")) {
    f.form.elements[dec].focus();
    return false;
  } else {
    return false;
  }
} // numbersonly()

// --
// wordWrap()
// --
function wordWrap(s,m,msk) {
  if (""+msk=="undefined") { msk = "_"; }
  s = s.replace(/\r/gi,''); s = s.replace(/\n/gi,''); s = s.replace(/\s/gi,msk);
  var str = "";
  try {
    if (s.length<=m) { return s; }
    for (var x=0; x<Math.ceil(s.length/m); x++) {
      if (x>0) { str += "<br>"; }
      str += s.substring(x*m, (x+1)*m);
    }
  } catch(e) {
    str = e.description;
  }
	return str;
} // wordWrap()

// --
// formatMask()
// --
function formatMask(str, msk) {
  str = str.stripall();
  switch (msk) {
    case "DT":
      str = str.replace(/(\d{2})(\d{2})(\d{4})(\d{2})(\d{2})(\d{2})/, '$1/$2/$3 $4:$5:$6');
      break;
  }
  return str;
} // formatMask()

String.prototype.leftfill     = leftfill;
String.prototype.rightfill    = rightfill;
String.prototype.left         = left;
String.prototype.right        = right;
String.prototype.trim         = trim;
String.prototype.ltrim        = ltrim;
String.prototype.rtrim        = rtrim;
String.prototype.strip        = strip;
String.prototype.stripall     = stripall;
String.prototype.stripAlpha   = stripAlpha;
String.prototype.isDate       = isDate;