/******************************************************
*
*   Intellimaker Javascript FD_API
*   Ver 1.0     02/03/2006
*
*   Federico Bonarrigo
*
*   Descrizione:
*   API Javascript per Formattazione dati numerici
*
*   Copyright (c) 2006 Intellimaker srl 
*******************************************************/
    
STRINGA_ERRORE = "#Errore#"    //costante
SEPARATORE_PREFISSO = " "
SEPARATORE_POSTFISSO = " "
//String.prototype.trim = function() { return this.replace(/^\s+|\s+$/g, ''); };

 
/*****
*
*    Costruttore Formato
*
*****/
function Formato(i_tipocampo, i_numdecimali, i_flagragruppa, a_sepdecimali, a_sepmigliaia, a_simboloprefisso, a_simbolopostfisso, a_formatodata) {
    if ( arguments.length > 0 )
        this.init(i_tipocampo, i_numdecimali, i_flagragruppa, a_sepdecimali, a_sepmigliaia, a_simboloprefisso, a_simbolopostfisso, a_formatodata);
};

/*****
*
*    Formato init
*
*****/
Formato.prototype.init = function(i_tipocampo, i_numdecimali, i_flagragruppa, a_sepdecimali, a_sepmigliaia, a_simboloprefisso, a_simbolopostfisso, a_formatodata) {
    this.i_tipocampo = i_tipocampo;
    this.i_numdecimali = i_numdecimali - 0;
    this.i_flagragruppa = i_flagragruppa - 0;
    this.a_sepdecimali = a_sepdecimali;
    this.a_sepmigliaia = a_sepmigliaia;
    this.a_simboloprefisso = a_simboloprefisso;
    this.a_simbolopostfisso = a_simbolopostfisso;
    this.a_formatodata = a_formatodata;
};

/*****
*
*    Formato toString
*
*****/
Formato.prototype.toString = function() {
    return 'i_tipocampo:|' + this.i_tipocampo + '|\t' + 'i_numdecimali:|' + this.i_numdecimali+ '|\t' 
            + 'i_flagragruppa:|' + this.i_flagragruppa+ '|\t' + 'a_sepdecimali:|' + this.a_sepdecimali+ '|\t' 
            + 'a_sepmigliaia:|' + this.a_sepmigliaia + '|\t' + 'a_simboloprefisso:|' + this.a_simboloprefisso + '|\t' 
            + 'a_simbolopostfisso:|' + this.a_simbolopostfisso + '|\t' + 'a_formatodata:|' + this.a_formatodata + '|';
};

/*****
*
*    FD_Format: funzione che formatta il dato
*
*****/
function FD_Format(valore, objFormato){
    if (valore.toString().trim() == "") return ""
    var stringaRis;
    switch(objFormato.i_tipocampo){
        case 2 :    //intero
        case 18 :   //Contatore
            if (!accettaIntero(valore)) return STRINGA_ERRORE
            valore = valore.toString();
            stringaRis = raggruppaMigliaia(valore, objFormato);
            break;
        case 3 :    //decimale
        case 7 :    //valuta
            if (!accettaFloat(valore)) return STRINGA_ERRORE
            valore = valore.toString();        
            var numeroArrotondato = round_decimals(valore, objFormato.i_numdecimali);
            stringaRis = raggruppaMigliaia(classicReplace(numeroArrotondato.toString(), ".", objFormato.a_sepdecimali), objFormato)
            break;
        default :
            stringaRis = valore
    }
    return AggiungiPrefissoPostfisso(stringaRis, objFormato.a_simboloprefisso, objFormato.a_simbolopostfisso)
}

/*****
*
*    FD_Unformat: funzione che restituisce il dato pulito a partire da quello formattato
*
*****/
function FD_Unformat(valore, objFormato){
    var Ris;
    valore = TogliPostFisso(TogliPreFisso(valore, objFormato.a_simboloprefisso), objFormato.a_simbolopostfisso);
    switch(objFormato.i_tipocampo){
        case 2 :    //intero
        case 18 :   //Contatore
			if (valore.toString().trim() == "") return 0;
            Ris = parseInt(riunisciMigliaia(valore, objFormato));
            break;
        case 3 :    //decimale
        case 7 :    //valuta
			if (valore.toString().trim() == "") return 0;
            Ris = parseFloat(classicReplace(riunisciMigliaia(valore, objFormato), objFormato.a_sepdecimali, "."));
            break;
        default :
            Ris = valore
    }
    return Ris
}

/*****
*
*    FD_Check: funzione che verifica un valore formattato e restituisce true o false 
*
*****/
function FD_Check(valore, objFormato){
    if (valore.toString().trim() == "") return true
    var b_Ris;
    valore = TogliPostFisso(TogliPreFisso(valore, objFormato.a_simboloprefisso), objFormato.a_simbolopostfisso);
    switch(objFormato.i_tipocampo){
        case 2 :    //intero
        case 18 :   //Contatore
            b_Ris = checkMigliaia(valore, objFormato) && accettaIntero(riunisciMigliaia(valore, objFormato));
            break;
        case 3 :    //decimale
        case 7 :    //valuta
            b_Ris = checkMigliaia(valore, objFormato) && accettaFloat(classicReplace(riunisciMigliaia(valore, objFormato), objFormato.a_sepdecimali, "."));
            break;
        default :
            b_Ris = true
    }
    return b_Ris
}


function FD_CheckFormatoCampo(oggetto, TipoCampo, NumDecimali, raggruppa, SepDec, SepMigl, Prefisso, Postfisso, FrmtData){
//funzione che controlla che il valore inserito nel campo sia giusto col tipo campo selezioanto
    curFormato = new Formato(TipoCampo, NumDecimali, raggruppa, SepDec ,SepMigl, Prefisso, Postfisso, FrmtData);    
    aF = oggetto.value;
    //implemento un ciclo che togli gli 0 dall'inizio del numero
       // alert("af:"+aF);
    if (!FD_Check(aF, curFormato)){             
          alert(errForm);
          oggetto.focus();
          return false; 
          
    }
    else{
        if ((aF.length>1)&&((TipoCampo ==2)||(TipoCampo ==18)||(TipoCampo ==3)||(TipoCampo ==7))){
            for (i = 0; i< aF.length;i++){        
                if ((i+1)<aF.length){
                    if ((aF.charAt(i)=='0')&&(aF.charAt(i+1)!=SepDec)){
                    //tolgo lo zero e esco dal ciclo
                        aF = aF.substring(1);
                        i = i-1;
                    }
                    else{i = aF.length+1;}
                }
            }
        }    
		if ((TipoCampo != "8") && (TipoCampo != "9"))
        { 
			var a = FD_Unformat(aF, curFormato);
			oggetto.value = ((!aF.trim()==''))?FD_Format(FD_Unformat(aF, curFormato), curFormato):'';
        }
        return true;
    }      
}

function FD_OnFocus(oggetto, TipoCampo, NumDecimali, raggruppa, SepDec, SepMigl, Prefisso, Postfisso, FrmtData){
//funzione da chiamare sull'onfocus dei campi che attualmente si occupa solo di eliminare le migliaia dai campi numerici
    switch(TipoCampo){
        case 2 :    //intero
        case 18 :   //Contatore
        case 3 :    //decimale
        case 7 :    //valuta
            curFormato = new Formato(TipoCampo, NumDecimali, raggruppa, SepDec ,SepMigl, Prefisso, Postfisso, FrmtData);
            oggetto.value = TogliPostFisso(TogliPreFisso(riunisciMigliaia(oggetto.value, curFormato), Prefisso), Postfisso);
            break;
        default :
            break;
    } 
}                            

/*****
*
*    Sezione con funzioni di utilità
*
*****/


/* This script is Copyright (c) Paul McFedries and 
Logophilia Limited (http://www.mcfedries.com/).
Permission is granted to use this script as long as 
this Copyright notice remains in place.*/
function round_decimals(original_number, decimals) {
    var result1 = original_number * Math.pow(10, decimals)
    var result2 = Math.round(result1)
    var result3 = result2 / Math.pow(10, decimals)
    return pad_with_zeros(result3, decimals)
}

function pad_with_zeros(rounded_value, decimal_places) {
    var value_string = rounded_value.toString()
    var decimal_location = value_string.indexOf(".")
    if (decimal_location == -1) {
        decimal_part_length = 0
        value_string += decimal_places > 0 ? "." : ""
    }
    else {
        decimal_part_length = value_string.length - decimal_location - 1
    }
    var pad_total = decimal_places - decimal_part_length
    if (pad_total > 0) {
        for (var counter = 1; counter <= pad_total; counter++) 
            value_string += "0"
        }
    return value_string
}

/*funzione che toglie il prefisso dal valore*/
function TogliPreFisso(valore, prefisso){
    //la funzione presuppone il valore nel formato prefisso + spazio + valore es. € 123.00
    var valtmp= valore.toString().trim();
    if (prefisso=='') return valtmp;
    var globpref = prefisso + SEPARATORE_PREFISSO;
    var posizione;
    posizione = valore.indexOf(globpref);
    if (posizione ==0){
        valtmp = valore.substring(posizione + globpref.length, valtmp.length);
    }
    return valtmp;
}

/*funzione che togli il postfisso dal valore*/
function TogliPostFisso(valore, postfisso){
    //la funzione presuppone il valore nel formato valore+ spazio+ postfisso es. 55 %
    var valtmp= valore.toString().trim();
    if (postfisso=='') return valtmp;
    var posizione;
    var globpost = SEPARATORE_POSTFISSO + postfisso;
    posizione = valore.lastIndexOf(globpost);
    if (posizione==-1) return valtmp;
    if (posizione==(valtmp.length - globpost.length)) {
        valtmp = valore.substring(0, posizione);
    }
    return valtmp;
}

/*funzione che aggiunge prefisso e postfisso. */
function AggiungiPrefissoPostfisso(valore, prefisso, postfisso){
    return ((prefisso=="")?"":prefisso + SEPARATORE_PREFISSO) + valore.toString().trim() + ((postfisso=="")?"":SEPARATORE_POSTFISSO + postfisso);
}

/* Funzione che aggiunge il simbolo separatore su ogni migliaio*/
function raggruppaMigliaia(stringa, objFormato){
    if (objFormato.i_flagragruppa!=1) return stringa;
    var parti = stringa.split(objFormato.a_sepdecimali)
    var sep = objFormato.a_sepmigliaia;
    var prefix
    if (parti[0].substring(0,1) == "-"){
        prefix = "-";
        parti[0] = parti[0].substring(1,parti[0].length);
    }
    else{
        prefix = "";
    }
    var resto = parti[0].length % 3;
    var Gruppi = Math.floor(parti[0].length/3) - (resto==0?1:0);
    if (Gruppi==0) return prefix + parti.join(objFormato.a_sepdecimali);
    var risul = parti[0].substr(0, (resto==0?3:resto));
    for(var i=0; i<Gruppi; i++){
        risul += objFormato.a_sepmigliaia + parti[0].substr((resto==0?3:resto) + (i*3), 3); 
    }
    return prefix + risul + ((parti.length==1)?"":objFormato.a_sepdecimali+parti[1])
}

/* Funzione che elimina i separatori migliaia*/
function riunisciMigliaia(stringa, objFormato){
    return classicReplace(stringa, objFormato.a_sepmigliaia, "") 
}

/* Funzione che verifica la correttezza della disposizione dei separatori di migliaia
*   sicuramente migliorabile tramite regexp
*/
function checkMigliaia(stringa, objFormato){
    if (stringa.indexOf(objFormato.a_sepmigliaia)==-1) return true 
    //if (objFormato.i_flagragruppa!=1) return false     //Da attivarsi solo se si volesse impedire di scrivere le cifre raggruppate quando il flag di raggruppamento è falso
    var b_ris = true
    if (stringa.substring(0,1) == "-") stringa = stringa.substring(1,stringa.length);
    var parti = stringa.split(objFormato.a_sepdecimali)
    if(parti.length>2) return false;
    var gruppiMigl = parti[0].split(objFormato.a_sepmigliaia)
    if ((gruppiMigl[0].length>3)||(gruppiMigl[0].length==0)) return false;
    if (gruppiMigl.length>0)
        for(var i=1; i<gruppiMigl.length; i++){
            if(gruppiMigl[i].length!=3){
                b_ris = false;
                break;
            }
        }
    if(parti.length>1)
        if (parti[1].indexOf(objFormato.a_sepmigliaia)!=-1) return false
    return b_ris
}

/* Extract from Simon Willison's Weblog
(http://simon.incutio.com/archive/2006/01/20/escape).
Aggiunti caratteri '^' e '$'
*/
RegExp.escape = function(text) {
  if (!arguments.callee.sRE) {
    var specials = [
      '/', '.', '*', '+', '?', '|', '^', '$',
      '(', ')', '[', ']', '{', '}', '\\'
    ];
    arguments.callee.sRE = new RegExp(
      '(\\' + specials.join('|\\') + ')', 'g'
    );
  }
  return text.replace(arguments.callee.sRE, '\\$1');
}

/*Aggiunge alla classe String il metodo trim*/
String.prototype.trim = function(){
    return this.replace(/^\s*|\s*$/g,"");
}

/*Implementazione del Replace classico (ad esempio quelli di VBScript o di T-SQL)*/
function classicReplace(stringa, strFind, strSostituisci){
    var expr = new RegExp(RegExp.escape(strFind), "gi")
    return stringa.replace(expr, strSostituisci)
}

/*Verifico che il valore normalizzato sia un intero*/
function accettaIntero(valore){ 
    if (valore=="") return true; 
    var sPattern=/(^-?\d+$)/; 
    return (sPattern.test(valore));
}

/*Verifico che il valore normalizzato (numero in formato javascript) sia un float */
function accettaFloat(valore){ 
    if (valore=="") return true; 
    var sPattern=/(^-?\d+$)|(^-?\d+\.\d+$)/; 
    return (sPattern.test(valore));
}

/******************************************************
*
*   FINE Intellimaker Javascript FD_API
*
******************************************************/