/* -----------------------------------------------------------------------------------------------------
   Gestione Navigator
   ----------------------------------------------------------------------------------------------------- */
function isIE() {
  return navigator.appName == 'Microsoft Internet Explorer';
}

function isIE6() {
  return  navigator.appVersion.match(/MSIE 6.\d+;/);
}

/* -----------------------------------------------------------------------------------------------------
  Funzione            : getMessageDefault
  Descrizione         : Questa funzione restituisce una stringa nella lingua specificata dal cookie
                        'userLanguage' in base alla chiave fornita, se non trova la traduzione
                        ritorna il valore di default.
  Argomenti di Input  : msgCode - chiave, msgDefault - valore di default, arg0, ..., argn eventuali
                        stringhe da sostituire a {0}, ..., {n}
  Argomenti di Output : La stringa calcolata
  Autore              : Sergio Lipari
  Data creazione      : 30/05/2007
   ----------------------------------------------------------------------------------------------------- */
var stringRes = new Array();
function getMessageDefault(msgCode, msgDefault, arg0, arg1, arg2, arg3) {
 var language = readCookie('userLanguage');
 var msg;
 if (language == null || language == 'it') {
  msg = msgDefault;
 } else {
  var dictionary = stringRes[language];
  if(dictionary == null) {
   msg = msgDefault;
  } else {
   msg = dictionary[msgCode];
   if (typeof msg == 'undefined' || msg == null) {
    msg = msgDefault;
   }
  }
 } 
 var ind;
 for (var i=0; (ind = msg.indexOf("{" + i + "}")) > 0; i++) {
  msg = msg.substring(0, ind) + eval("arg" + i) + msg.substring(ind + 3, msg.length);
 }
 return msg;
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : getMessage
   Descrizione         : Questa funzione restituisce una stringa nella lingua specificata dal cookie
                         'userLanguage' in base alla chiave fornita.
   Argomenti di Input  : msgCode - chiave, arg0, ..., argn eventuali stringhe da sostituire
                          a {0}, ..., {n}
   Argomenti di Output : La stringa calcolata
   Autore              : Antonio Flaccomio
   Data creazione      : 16/04/2007
   ----------------------------------------------------------------------------------------------------- */
function getMessage(msgCode, arg0, arg1, arg2, arg3) {
 var language = readCookie('userLanguage');
 if (language == null) {
  language = "it";
 }
 var dictionary = stringRes[language];
 if(dictionary == null) {
  dictionary = stringRes['it'];
 }
 var msg = dictionary[msgCode];
 if (typeof msg == 'undefined') {
  return "Message: \"" + msgCode + "\" not defined for current language (" + language.value + ").";
 } else {
  var ind;
  for (var i=0; (ind = msg.indexOf("{" + i + "}")) > 0; i++) {
   msg = msg.substring(0, ind) + eval("arg" + i) + msg.substring(ind + 3, msg.length);
  }
  return msg;
 }
}

/* -----------------------------------------------------------------------------------------------------
   Funzioni di passaggio per il form
   ----------------------------------------------------------------------------------------------------- */
function caricaParametriForm(azione, formId) {
 var idx;
 var paramString;
 var form = document.getElementById(formId);

 if ((idx = azione.lastIndexOf('?')) == -1){
  return azione;
 }
 paramString = azione.substring(idx+1, azione.length);
 var parametri = paramString.split('&');
 var nome_valore;
 for (var i=0; i<parametri.length; i++) {
  nome_valore = parametri[i].split('=');
  var el   = document.createElement("INPUT");
  el.type  = 'hidden';
  el.name  = nome_valore[0];
  el.value = nome_valore[1];
  el.id    = nome_valore[0]; /* aggiungiamo anche un id per potere poi recuperare l'element */

  var elts = document.getElementById(el.name);
  if (elts != null) {
   elts.value = nome_valore[1];
  } else {
   form.appendChild(el);
  }
 }
 return azione.substring(0, idx);
}

function formPost(azione, formId) {
 var path = caricaParametriForm(azione, formId);
 document.getElementById(formId).action = path;
 document.getElementById(formId).submit();
}

/* -----------------------------------------------------------------------------------------------------
   Gestione Menù
   ----------------------------------------------------------------------------------------------------- */
function showHideFrameMenu() {
 var div = document.getElementById("colonna1");
 var menuchiuso = document.getElementById("menuchiuso");
 var pagina = document.getElementById("page");
 var validatori = document.getElementById("validatori");
 if (div.style.display == "none") {
  createCookie('vistamenu', 'inline', 30);
  div.style.display = "inline";
  menuchiuso.style.display = "none";
  pagina.style.width= "904px";
  validatori.style.width= "904px";
 } else {
  createCookie('vistamenu', 'none', 30);
  div.style.display = "none";
  menuchiuso.style.display = "inline";
  pagina.style.width= "715px";
  validatori.style.width= "715px";
 }
}

/* -----------------------------------------------------------------------------------------------------
   Gestione Style
   ----------------------------------------------------------------------------------------------------- */
function ChStyle(obj, newStyle) {
 obj.className = newStyle;
 return;
}

/* -----------------------------------------------------------------------------------------------------
   Gestione Cookie
   ----------------------------------------------------------------------------------------------------- */
function createCookie(name, value, days) {
 if (days) {
  var date = new Date();
  date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
  var expires = "; expires=" + date.toGMTString();
 } else {
  expires = "";
 }
 document.cookie = name + "=" + value + expires + "; path=/";
}

function readCookie(name, defVal) {
 var nameEQ = name + "=";
 var ca = document.cookie.split(';');
 for (var i=0; i < ca.length; i++) {
  var c = ca[i];
  while (c.charAt(0)==' ') c = c.substring(1, c.length);
  if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length, c.length);
 }
 return defVal;
}

/* -----------------------------------------------------------------------------------------------------
   Gestione Window
   ----------------------------------------------------------------------------------------------------- */
function openWin() {
 var w    = 400;
 var h    = 165;
 var winl = (screen.width - w) / 2;
 var wint = (screen.height - h) / 2;
 var winProps = "height=" + h + ", Width=" + w + ", top= " + wint + ", left= " + winl;
 window.open("Credits.jsp", "Credits", "toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=no, resizable=no, " + winProps);
 return;
}

function visualizzaFile(nomeCampo) {
 var chkElement = document.getElementById('chkExist_' + nomeCampo);
 if (chkElement == null || chkElement.value == 'N') {
  alert(getMessageDefault('operazionenonconsentita', 'Operazione non consentita!'));
 } else {
  eval(chkElement.value);
 }
}

function openDocument(fileToOpen, nomeCampo) {
 openDirectDocument(fileToOpen, nomeCampo);
}

function openDirectDocument(fileToOpen, nomeCampo) {
 var chkElement = document.getElementById((nomeCampo != null) ? ('chkExist_' + nomeCampo) : 'chkExist');
 if (chkElement != null && chkElement.value == 'N') {
 	alert(getMessageDefault('operazionenonconsentita', 'Operazione non consentita!'));
 	return;
 }
 // --- L'impostazione di questa configurazione è funzionale alle
 //     transazioni di front-office. Non modificare i parametri
 //     della window.
 //     Stranamente una variabile non può essere usata come titolo.
 popWindow = window.open(fileToOpen, '', 'width=640, height=480, toolbar=no, location=no, status=yes, menubar=yes, scrollbars=yes, resizable=yes');
}

function openDirectModel(fileToOpen, nomeCampo) {
 var chkElement = document.getElementById((nomeCampo != null) ? ('chkExist_' + nomeCampo) : 'chkExist');
 if (chkElement != null && chkElement.value == 'N') {
  alert(getMessageDefault('operazionenonconsentita', 'Operazione non consentita!'));
  return;
 }
 // --- L'impostazione di questa configurazione è funzionale alle
 //     transazioni di front-office. Non modificare i parametri
 //     della window.
 popWindow = window.open(fileToOpen, '', 'toolbar=yes, location=yes, directories=yes, status=yes, menubar=yes, scrollbars=yes, resizable=yes, width=640, height=480');
}

function openGuide(url) {
 var w    = 800;
 var h    = 600;
 var winl = (screen.width - w) / 2;
 var wint = (screen.height - h) / 2;
 var winProps = "height=" + h + ", Width=" + w + ", top= " + wint + ", left= " + winl;
 popWindow = window.open(url, 'popWindow', 'toolbar=no, location=no, directories=no, status=yes, menubar=no, scrollbars=yes, resizable=no, ' + winProps);
}

/* -----------------------------------------------------------------------------------------------------
   Gestione Form & Field
   ----------------------------------------------------------------------------------------------------- */
function controllaCampiForm(f) {
 var checkBoxUniti = false;
 for (var i=0; i<propColonne.length; i++) {
  if (propColonne[i].tipoDati=='CHB' && !checkBoxUniti) {
   unisciValoriCheckBox(f);
   checkBoxUniti = true;
  }
  // --- Controllo obbligatorietà colonne calcolate (solo INSERIMENTO E MODIFICA).
  if (propColonne[i].obbligatorio && !propColonne[i].chiave && propColonne[i].tipoDati == 'CLC' &&
    (f.elements['siglaStato'].value == 'I' || f.elements['siglaStato'].value == 'M')) {
   var valore;
   valore = f.elements['CONTR_'+ propColonne[i].nomeCampo].value;
   if (valore=='') {
    alert(getMessageDefault('campoObbligatorio', 'Il campo {0} è obbligatorio!', propColonne[i].etichetta));
    return false;
   }
  }

  // --- Non esegue i controlli se il campo è definito come non modificabile.
  if (propColonne[i].modificabile) {
   // --- Controllo campi data.
   if ((propColonne[i].tipoDati=='DAT'|| propColonne[i].tipoDati=='DATC' )&& f.elements[propColonne[i].nomeCampo].value != '') {
    rc = normalizzaData(f.elements[propColonne[i].nomeCampo]);
    if (rc == false) {
     if (f.elements[propColonne[i].nomeCampo].type!='hidden') {
      alert(getMessageDefault('dataNonValida', 'Il campo {0} contiene una data non valida.', propColonne[i].etichetta));
      f.elements[propColonne[i].nomeCampo].focus();
     }
     return false;
    } else if (propColonne[i].tipoDati=='DATC'&& f.elements[propColonne[i].nomeCampo].value != ''){
      var controllaData1DataOdierna= !controllaData1DataOdiernaLabel(f.elements[propColonne[i].nomeCampo].value, propColonne[i].etichetta);
      if (controllaData1DataOdierna == false) {
       return false;
      }
    }
   }
   // --- Controllo campo Codice fiscale / Partita IVA.
   if (propColonne[i].tipoDati=='CFI' && f.elements[propColonne[i].nomeCampo].value != '') {
    f.elements[propColonne[i].nomeCampo].value = f.elements[propColonne[i].nomeCampo].value.toUpperCase();
    rc = controllaCFPIVA(f.elements[propColonne[i].nomeCampo].value);
    if (rc == false) {
     if (f.elements[propColonne[i].nomeCampo].type!='hidden')
      alert(getMessageDefault('codiceNonValido', 'Il campo {0} contiene un codice non valido.', propColonne[i].etichetta));
      f.elements[propColonne[i].nomeCampo].focus();
     return false;
    }
   }
   // --- Controllo campo e-Mail.
   if (propColonne[i].tipoDati=='EMA' && f.elements[propColonne[i].nomeCampo].value != '') {
    rc = controllaeMail(f.elements[propColonne[i].nomeCampo].value);
    if (rc == false) {
     if (f.elements[propColonne[i].nomeCampo].type!='hidden')
      alert(getMessageDefault('emailNonValida', 'Il campo {0} contiene un indirizzo di posta elettronica non valido.', propColonne[i].etichetta));
      f.elements[propColonne[i].nomeCampo].focus();
     return false;
    }
   }
   // --- Controllo campi obbligatori (solo in INSERIEMNTO e MODIFICA).
   if (propColonne[i].obbligatorio && !propColonne[i].chiave &&
     (f.elements['siglaStato'].value == 'I' || f.elements['siglaStato'].value == 'M')) {
    var valore;
    // --- eb 11/10/2005 esteso a hidden il controllo del campo RBU.
    if (propColonne[i].tipoDati == 'RBU' && f.elements[propColonne[i].nomeCampo].type != 'hidden')
     valore = valoreRadio(f.elements[propColonne[i].nomeCampo]);
    else
     valore = f.elements[propColonne[i].nomeCampo].value;
    if (valore=='') {
     alert(getMessageDefault('campoObbligatorio', 'Il campo {0} è obbligatorio!', propColonne[i].etichetta));
     if (f.elements[propColonne[i].nomeCampo].type != 'hidden')
      if (propColonne[i].tipoDati != 'RBU')
        f.elements[propColonne[i].nomeCampo].focus();
     return false;
    }
   }
   // --- Controllo campi numerici.
   if ((propColonne[i].tipoDati=='NUM') || (propColonne[i].tipoDati=='VAL')) {
    if (propColonne[i].modificabile) {
     sFieldValue = f.elements[propColonne[i].nomeCampo].value
     if (sFieldValue!='') {
      if (isNumeric(sFieldValue)) {
       iValue = eval(sFieldValue);
       if (iValue < 0) {
        alert(getMessageDefault('numeroPositivo', 'Il campo {0} deve essere un numero maggiore di zero.', propColonne[i].etichetta));
        f.elements[propColonne[i].nomeCampo].focus();
        return false;
       }
      } else {
       alert(getMessageDefault('numeroErrato', 'Il campo {0} deve essere un numero.', propColonne[i].etichetta));
       f.elements[propColonne[i].nomeCampo].focus();
       return false;
      }
     }
    }
   }
   // --- Controllo campi numerici decimali.
   if (propColonne[i].tipoDati.substr(0, 3)=='DEC') {
    if (propColonne[i].modificabile) {
     sFieldValue = f.elements[propColonne[i].nomeCampo].value
     if (sFieldValue!='') {
      if (isNumericDec(sFieldValue)) {
       maxLenDec = propColonne[i].tipoDati.substr(3);
       maxLenInt = propColonne[i].maxLenInt - maxLenDec - 1;
       posDecSeg = sFieldValue.indexOf('-');
       posDecSep = sFieldValue.indexOf(',');
       if (posDecSeg != -1) {
        posDecSeg = 1;
       } else {
        posDecSeg = 0;
       }
       if (posDecSep == -1) {
        posDecSep = sFieldValue.indexOf('.');
       }
       if (posDecSep != -1) {
        lenInt = sFieldValue.substr(posDecSeg, posDecSep).length - posDecSeg;
        lenDec = sFieldValue.substr(posDecSep + 1).length;
       } else {
        lenInt = sFieldValue.length;
        lenDec = 0;
       }
       if ((lenInt > maxLenInt) || (lenDec > maxLenDec)) {
        pict = '(formato ' + '999999999999'.substring(0, maxLenInt) + ',' + '999999999999'.substring(0, maxLenDec) + ')';
        alert(getMessageDefault('formatoNumeroDecimaleErrato', 'Il campo {0} ha un formato non valido.\n Inserire un valore nel formato {1}.', propColonne[i].etichetta, pict));
        f.elements[propColonne[i].nomeCampo].focus();
        return false;
       }
      } else {
       alert(getMessageDefault('numeroErrato', 'Il campo {0} deve essere un numero.', propColonne[i].etichetta));
       f.elements[propColonne[i].nomeCampo].focus();
       return false;
      }
     }
    }
   }
   // --- Controllo valore minimo campo (solo in INSERIMENTO e MODIFICA).
   if (f.elements['siglaStato'].value == 'I' || f.elements['siglaStato'].value == 'M') {
    if (propColonne[i].minLenInt > 0) {
     valore = f.elements[propColonne[i].nomeCampo].value;
     if (valore.length > 0 && valore.length < propColonne[i].minLenInt) {
      alert(getMessageDefault('pochiCaratteri', 'Il campo {0} non può essere inferiore a {1} caratteri!', propColonne[i].etichetta, propColonne[i].minLenInt));
      f.elements[propColonne[i].nomeCampo].focus();
      return false;
     }
    }
   }
  }
 }
 return true;
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : normalizzaData
   Descrizione         : Questa funzione controlla se l'argomento di input é una data valida (formato
                         gg/mm/aaaa).
   Argomenti di Input  : sData  - Indica il valore della stringa che si vuole esaminare (la stringa
                                  rappresenta una data in formato gg/mm/aaaa).
   Argomenti di Output : bRc    - Indica l'esito del controllo (True - Controllo eseguito con
                                  successo, False - Controllo fallito).
   Autore              : Stefano Sandolo
   Data creazione      : 16/10/1997
   Autore              : Ernesto Bazan
   Data revisione      : 30/04/2001
   Annotazioni         : Accetta i delimitatori '-' e '.' (che elimina e converte nel delimitatore
                         standard '/'; accetta l'anno senza secolo e giorno e mese su una posizione.
   ----------------------------------------------------------------------------------------------------- */
function normalizzaData(f) {
 var resultData;
 var resOrario;
 var valore = f.value;
 if (f.className != 'readonly') {
  if (valore.length < 11) {
   resultData = checkData(valore);
   if (resultData == null)
     return false;
   resOrario = new Array(null,'00','00','00');
  } else {
   var temp = valore.match(/^(\S{6,10})\s(\S*)/);
   if (temp == null)
    return false;
   resultData = checkData(temp[1]);
   if (resultData == null)
    return false;
   resOrario = checkOrario(temp[2]);
   if (resOrario == null)
    return false;
  }
  var data = new Date(resultData[3],resultData[2] - 1,resultData[1],resOrario[1],resOrario[2],resOrario[3]);
  if(data.getMonth() != resultData[2] - 1 || resOrario[1] > 23 || resOrario[2] > 59 || resOrario[3] > 59)
   return false;

  if (f.maxLength < 19) {
   f.value = resultData[1] + '/' + resultData[2] + '/' + resultData[3];
  } else {
   f.value = resultData[1] + '/' + resultData[2] + '/' + resultData[3] + ' ' + resOrario[1] + ':' + resOrario[2] + ':' +resOrario[3];
  }
 }
 return true;
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : regolaData
   Descrizione         : Questa funzione genera le date in formato AAAAMMGG
   Argomenti di Input  : d - data in formato gg/mm/aaaa
   Argomenti di Output : data in formato aaaammgg
   Autore              : Roberto Franco
   Data creazione      : 16/02/2001
   ----------------------------------------------------------------------------------------------------- */
function regolaData(d) {
 iPosizione1 = d.indexOf('/');
 iPosizione2 = d.lastIndexOf('/');
 iPosizione3 = d.indexOf(' ');
 giorno      = d.substring(0, iPosizione1);
 mese        = d.substring(iPosizione1 + 1, iPosizione2);
 if (iPosizione3!=-1) {
  anno   = d.substring(iPosizione2 + 1, iPosizione3);
  orario = d.substring(iPosizione3 + 1, d.length);
 } else {
  anno   = d.substring(iPosizione2 + 1, d.length);
  orario = '';
 }
 return anno + mese + giorno + orario;
}

function checkData(stringa) {
 var res = stringa.match(/^(\d{2})(\d{2})(\d{2})$/);
 if (res == null) {
  res = stringa.match(/^(\d{2})(\d{2})(\d{4})$/);
 }
 if (res == null) {
  res = stringa.match(/^(\d{1,2})\D{1}(\d{1,2})\D{1}(\d{2}|\d{4})$/);
 }
 if (res == null) return null;
 if (res[1].length != 2) res[1] = '0' + res[1];
 if (res[2].length != 2) res[2] = '0' + res[2];
 if (res[3].length != 4) res[3] = '20' + res[3];
 return res;
}

function checkOrario(stringa) {
 var res = stringa.match(/^(\d{2})(\d{2})(\d{2})?$/);
 if (res == null) {
  res = stringa.match(/^(\d{1,2})\D(\d{1,2})\D?(\d{1,2})?$/);
  if (res == null) return null;
 }
 if (res[1].length != 2) res[1] = '0' + res[1];
 if (res[2].length != 2) res[2] = '0' + res[2];
 if (res[3].length == 1) res[3] = '0' + res[3];
 if (res[3].length != 2) res[3] = '00';
 return res;
}

// --- 13/11/2004 eb Inserito controllo obbligatorietà necessario dopo la
//     modifica effettuata da Daniele per il controllo di obbligatorietà
//     sulle colonne calcolate.
function controllaCampiFormEditor(f) {
 f.elements.EditorValue.value = '' + idContent.document.body.innerHTML + '';
 var tmp = '' + idContent.document.body.innerHTML + '';
 // --- <bm> E' necessario inserire una funzione in grado di eliminare i tag
 //     HTML per controllare il puro testo digitato dall'utente.
 if (tmp != '') {
  return controllaCampiForm(f);
 } else {
  alert(getMessageDefault('inserireTestoNewsletter', 'Occorre inserire il testo della newsletter!'));
 }
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : eliminaCarattere
   Descrizione         : Questa funzione elimina tutte le occorrenze di un particolare carattere dalla
                         stringa passata come argomento di input.
   Argomenti di Input  : v      - Indica il valore della stringa che si vuole esaminare.
                         c      - Indica il valore del carattere che si vuole eliminare.
   Argomenti di Output : tmpStr - Indica la il valore della stringa elaborato dalla funzione.
   Autore              :
   Data creazione      : 26/08/1998
   Autore              :
   Data revisione      : 20/08/1999
   Annotazioni         :
   ----------------------------------------------------------------------------------------------------- */
function eliminaCarattere(v, c) {
 var tmpStr = '';
 var tmpChr = '';
 for (var iIdx = 0; iIdx < v.length; iIdx++) {
  tmpChr = v.substring(iIdx, (iIdx + 1));
  if (tmpChr != c) {
   tmpStr = tmpStr + tmpChr;
  }
 }
 return tmpStr;
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : isNumeric
   Descrizione         : Questa funzione controlla se l'argomento di input contiene un dato di tipo
                         numerico.
   Argomenti di Input  : sValue - Indica il valore che si vuole esaminare.
   Argomenti di Output : bRc    - Indica l'esito del controllo (True - Controllo eseguito con successo,
                                  False - Controllo fallito).
   Autore              : 
   Data creazione      : 
   Autore              : G. Tito
   Data revisione      : 01/02/2004
   Annotazioni         : Modifica della struttura di controllo con l'uso di regular expression
   ----------------------------------------------------------------------------------------------------- */
function isNumeric(sValue) {
 // --- Iniziale opzionale, qualsiasi occorrenza di numeri 0-9.
 var regesp = /^-?[\d]{1,}$/;
 // --- Ritorna true se la regular expression coincide.
 return sValue.match(regesp) != null;
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : isNumericDec
   Descrizione         : Questa funzione controlla se l'argomento di input contiene un dato di tipo
                         numerico (viene validato positivamente anche il punto decimale).
   Argomenti di Input  : sValue - Indica il valore che si vuole esaminare.
   Argomenti di Output : bRc    - Indica l'esito del controllo (True - Controllo eseguito con successo,
                                  False - Controllo fallito).
   Autore              : 
   Data creazione      : 
   Autore              : G. Tito
   Data revisione      : 01/02/2004
   Annotazioni         : Modifica della struttura di controllo con l'uso di regular expression
   ----------------------------------------------------------------------------------------------------- */
function isNumericDec(sValue) {
 // --- Numeri naturali positivi eo negativi.
 var regespnat = /^-?[\d]{1,}$/;
 // --- Iniziale opzionale, qualsiasi occorrenza din numeri, 1 punto o virgola, n numeri.
 var regespdec = /^-?[\d]{1,}[,.]{1}[\d]{1,}$/;
 // --- Ritorna true se è un numero naturale oppure la regular expression coincide.
 return (sValue.match(regespnat) != null || sValue.match(regespdec) != null);
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : formatNumber
   Descrizione         : 
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function formatNumber(Expression, iNumDecimals) {
 var dbInVal = Expression;
 var bNegative = false;
 var iInVal = 0;
 var strInVal = '';
 var strWhole = '';
 var strDec = '';
 var strTmp = '';
 var strOut = '';
 var iLen = 0;
 if (isNaN(dbInVal)) {
  dbInVal = 0;
 }
 if (dbInVal < 0) {
  bNegative = true;
  dbInVal *= -1;
 }
 dbInVal = dbInVal * Math.pow(10, iNumDecimals)
 iInVal = parseInt(dbInVal);
 if ((dbInVal - iInVal) >= .5) {
  iInVal++;
 }
 strInVal = iInVal + '';
 strWhole = strInVal.substring(0, (strInVal.length - iNumDecimals));
 strDec = strInVal.substring((strInVal.length - iNumDecimals), strInVal.length);
 while (strDec.length < iNumDecimals) {
  strDec = '0' + strDec;
 }
 iLen = strWhole.length;
 if (iLen >= 3) {
  while (iLen > 0) {
   strTmp = strWhole.substring(iLen - 3, iLen);
   if (strTmp.length == 3) {
    strOut = '.' + strTmp + strOut;
    iLen -= 3;
   } else {
    strOut = strTmp + strOut;
    iLen = 0;
   }
  }
  if (strOut.substring(0, 1) == '.') {
   strWhole = strOut.substring(1, strOut.length);
  } else {
   strWhole = strOut;
  }
 }
 if (strWhole.length==0)
  strWhole = '0';
 if (bNegative) {
  retVal = '-' + strWhole
  if (iNumDecimals > 0) {
   retVal += ',' + strDec;
  }
 } else {
  retVal = strWhole
  if (iNumDecimals > 0) {
   retVal += ',' + strDec;
  }
 }
 return retVal
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : controllaCampoPercentuale
   Descrizione         : Utilizzata quando si vuole esprimere parametro in percentuale (solo interi)
                         se il valore scritto in parametroPER è corretto posa in parametro il valore
                         diviso 100.
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function controllaCampoPercentuale(parametroPER, parametro, etichetta) {
 if ((parametroPER.value < 0)   ||
     (parametroPER.value > 100) ||
     (parametroPER.value.indexOf(',') > 0) ||
     (parametroPER.value.indexOf('.') > 0) ||
     (parametroPER.value == '') ||
     (!isNumeric(parametroPER.value))) {
   alert(getMessageDefault('percentoNonValido', 'Inserire un valore percentuale intero (0 e 100 %) nel campo {0}', etichetta));
   parametroPER.value = '0';
   parametro.value = '0';
   parametroPER.focus();
  } else {
   parametro.value = parametroPER.value/100;
  }
  return false;
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : controllaSeDatiModificati
   Descrizione         : <;-)> è la stringa di sostituzione utilizzata per eliminare gli 'a capo'
                         dai campi TextArea da TabellaHandler.JSCode - eb 18/08/2003.
   Argomenti di Input  : 
   Argomenti di Output : true se si puo' proseguire.
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function controllaSeDatiModificati(f) {
 var stato = f.siglaStato.value;
 if (stato == null  || (stato != 'I' && stato !=  'M')) {
  return true;
 }
 var nomiCampiMod = datiFormModificati(f);
 if (nomiCampiMod.length > 0) {
  return confirm(getMessageDefault('campiModificati', 'I seguenti campi risultano modificati:\n{0}\n\nvuoi andare avanti senza salvare?', nomiCampiMod));
 }
 return true;
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : datiFormModificati
   Descrizione         : <;-)> è la stringa di sostituzione utilizzata per eliminare gli 'a capo'
                         dai campi TextArea da TabellaHandler.JSCode - eb 18/08/2003.
   Argomenti di Input  : 
   Argomenti di Output : stringa - lista dei campi modificati.
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function datiFormModificati(f) {
 var nomiCampiMod = '';
 var checkBoxUniti = false;
 for (var i=0; i<propColonne.length; i++) {
  if (propColonne[i].tipoDati=='CHB' && !checkBoxUniti) {
   unisciValoriCheckBox(f);
   checkBoxUniti=true;
  }
  if ((propColonne[i].modificabile) && (propColonne[i].tipoDati != 'FIL')) {
   var tmpElement = f.elements[propColonne[i].nomeCampo];
   var tmpStr = propColonne[i].valoreIniziale;
   if (tmpElement.type=='hidden')  {
    // --- I campi nascosti si comportano tutti allo stesso modo;
    //     anche se nei metadati sono definiti come CMB RBU CHB ...
    //     in HTML sono sempre type='Hidden'.
    valore = f.elements[propColonne[i].nomeCampo].value;
    if (propColonne[i].tipoDati == 'CHB') {
     if (valore != tmpStr) {
      nomiCampiMod = nomiCampiMod += '\r - ' + propColonne[i].etichetta +' : (modifiche non specificate)';
     }
    }
   } else {
    checkStr = '<;-)>';
    var valore;
    if (propColonne[i].tipoDati != 'RBU') {
     valore = f.elements[propColonne[i].nomeCampo].value;
    } else {
     valore = valoreRadio(f.elements[propColonne[i].nomeCampo]);
    }
    tmpStr = replaceSpecialChar(tmpStr);
    if (valore != tmpStr) {
     // --- Debug
     //alert(propColonne[i].nomeCampo +'---'+ valore +'---'+ tmpStr)
     nomiCampiMod = (nomiCampiMod.length > 0 ? nomiCampiMod += '\r - ' + propColonne[i].etichetta : ' - ' + propColonne[i].etichetta);
    }
   }
  }
 }
 return nomiCampiMod;
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : confermaElimina
   Descrizione         : 
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function confermaElimina() {
 return confirm(getMessageDefault('confermaElimina', 'Si conferma la cancellazione?'));
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : confermaModifica
   Descrizione         : 
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : Aurelio Di Pasquale
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function confermaModifica() {
 return confirm(getMessageDefault('confermaModifica', 'Si conferma la modifica?'));
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : controlloUsoInvio
   Descrizione         : 
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function controlloUsoInvio() {
 if (document.getElementById("passaggio").action=='') {
  alert(getMessageDefault('noInvio', 'Si è utilizzato il pulsante invio: occorre utilizzare invece gli appositi bottoni. Grazie.'));
  return false;
 } else {
  return true;
 }
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : calcCharLeft
   Descrizione         : Questa funzione controlla la lunghezza dei valori inseriti in un campo di
                         tipo TEXTAREA
   Argomenti di Input  : target  - indica il campo di input da controllare;
   Argomenti di Output : maxLen  - indica la dimensione massima prevista per il campo di input;
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function calcCharLeft(target, maxLen) {
 sLen = target.value.length;
 if (sLen > maxLen) {
  target.value = target.value.substring(0, maxLen);
  charLeft = 0;
  alert(getMessageDefault('troppiCaratteri', 'Non è possibile immettere più di {0} caratteri.', maxLen));
 } else {
  charLeft = maxLen - sLen;
 }
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : controllaData1Data2
   Descrizione         : Questa funzione consente di controllare se la data passata come argomento
                         dData1 é inferiore alla data passata come argomento dData2.
   Argomenti di Input  : oData1   - Html InputField
                         oData2   - Html InputField
   Argomenti di Output : Nessuno
   Autore              : Giovanni Chiello
   Data creazione      : 14/12/1999
   Autore              :
   Data revisione      :
   Annotazioni         :
   ----------------------------------------------------------------------------------------------------- */
function controllaData1Data2(oData1, oData2) {
 var bErrore = false;
 if ((oData1 != null) && (oData2 != null)) {
  if ((oData1.value != '') && (oData2.value != '')) {
   if (normalizzaData(oData1) && normalizzaData(oData2) && regolaData(oData2.value) < regolaData(oData1.value))
    bErrore = true;
   if (bErrore == true) {
    alert(getMessageDefault('dateIncoerenti', 'Le date digitate non sono coerenti.'));
    oData2.value = '';
   }
  }
 }
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : controllaData1Data2Label
   Descrizione         : Questa funzione consente di controllare se la data passata come argomento
                         dData1 é inferiore alla data passata come argomento dData2.
                         Valorizzando le etichette è possibile customizzare il messaggio di
                         indicando i campi covolti
   Argomenti di Input  : oData1   - Html InputField
                         oData2   - Html InputField
                         etichetta data 1
                         etichetta data 2
   Argomenti di Output : Nessuno
   Autore              : LDC
   Data creazione      : 13/02/2006
   Autore              :
   Data revisione      :
   Annotazioni         :
   ----------------------------------------------------------------------------------------------------- */
function controllaData1Data2Label(oData1, oData2, lData1,lData2) {
 var bErrore = false;

 if ((oData1 != null) && (oData2 != null)) {
  if ((oData1.value != '') && (oData2.value != '')) {
   if (normalizzaData(oData1) && normalizzaData(oData2) && regolaData(oData2.value) < regolaData(oData1.value)) {
    alert(getMessageDefault('data2InferioreData1', 'La data {0} non può essere inferiore alla {1}!', lData2.toLowerCase(), lData1.toLowerCase()));
    oData2.value = '';
    bErrore = true;
   }
  }
 }
 return bErrore;
}
/* -----------------------------------------------------------------------------------------------------
   Funzione            : controllaData1DataOdiernaLabel
   Descrizione         : Questa funzione consente di controllare se la data passata come argomento
                         dData1 é superiore alla data odierna.
                         Valorizzando le etichette è possibile customizzare il messaggio di
                         indicando il campo covolto
   Argomenti di Input  : oData1   - String
                         etichetta data 1
   Argomenti di Output : Nessuno
   Autore              : adp
   Data creazione      : 07/09/2007
   Autore              :
   Data revisione      :
   Annotazioni         :
   ----------------------------------------------------------------------------------------------------- */
function controllaData1DataOdiernaLabel(oData1, lData1) {
 var bErrore = false;
 var today = new Date();
 var day = today.getDate();
 if (day < 10 ) {
    day = '0' + day;
 }
 var month = today.getMonth() +1;
 if (month < 10 ) {
    month = '0' + month;
 }
 var year = today.getFullYear();
 if ((oData1 != null)) {
    if (regolaData(day + '/' + month + '/' + year) < regolaData(oData1)) {
     alert(getMessageDefault('data2InferioreData1', 'La data {0} non può essere superiore alla data odierna!', oData1.toLowerCase()));
     oData1.value = '';
     bErrore = true;
    }
 }
 return bErrore;
}
/* -----------------------------------------------------------------------------------------------------
   Funzione            : controllaeMail
   Descrizione         : Questa funzione controlla se l'argomento di input contiene un indirizzo di
                         posta elettronica valido.
   Argomenti di Input  : sValue  - Indica il valore della stringa che si vuole esaminare.
   Argomenti di Output : bRc     - Indica l'esito del controllo (True - Controllo eseguito con
                                   successo, False - Controllo fallito).
   Autore              : Ernesto Bazan
   Data creazione      : 04/08/2001
   Autore              :
   Data revisione      :
   Annotazioni         :
   ----------------------------------------------------------------------------------------------------- */
function controllaeMail(sValue) {
 if (sValue == null) {
  return (false);
 }
 
 var supported = 0;
 if (window.RegExp) {
  var tmpStr = 'a';
  var tmpReg = new RegExp(tmpStr);
  if (tmpReg.test(tmpStr)) supported = 1;
 }
 if (!supported || sValue.indexOf(' ') >= 0) {
  return (sValue.indexOf('.') > 2) && (sValue.indexOf('@') > 0) && (sValue.indexOf(' ') < 0);
 }

 var espressione = /^[_a-zA-Z0-9+-]+(\.[_a-zA-Z0-9+-]+)*@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)+$/;
 if (!espressione.test(sValue)) {
  return false;
 }
 return true; 
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : convertiEuroLire
   Descrizione         : 
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function convertiEuroLire(madre, figlia) {
 var nImpNew = 0;
 var nImpOri = 0;
 nImpNew = passaggio.elements[madre].value;
 nImpNew = replace(nImpNew, ',', '.');
 if (nImpNew > 0) {
  nImpOri = formatNumber(nImpNew, 2);
  nImpOri = replace(nImpOri, '.', '');
  passaggio.elements[madre].value = nImpOri;
  nImpNew = (nImpNew * 1936.27);
  if (figlia!='') {
   passaggio.elements[figlia].value = formatNumber(nImpNew, 0);
  }
 } else {
  passaggio.elements[figlia].value ='';
 }
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : controllaCFPIVA
   Descrizione         : 
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function controllaCFPIVA(sValue) {
 var bRc = true;
 var iOdd = 0;
 var iEven = 0;
 var iDouble = 0;
 var iCin = 0;
 var tabellaCF = new Array(36);
 var tabellaCFB = new Array(36);
 var tabellaCFA = new Array(36);
 if (sValue.length==11) {
  iOdd = sValue.charAt(0)*1 + sValue.charAt(2)*1 + sValue.charAt(4)*1 +
  sValue.charAt(6)*1 + sValue.charAt(8)*1;
  for (var i=1; i<11; i=i+2) {
   iDouble = sValue.charAt(i)*2;
   if (iDouble >9)
    iEven += iDouble%10 + 1;
   else
    iEven += iDouble;
  }
  iCin = (10 - (iEven + iOdd)%10)%10;
  if (iCin==(sValue.charAt(10)*1))
   return true;
  else
   return false;
 } else {
  if (sValue.length==16) {
   tabellaCF[0]='0'; tabellaCF[1]='1'; tabellaCF[2]='2';
   tabellaCF[3]='3'; tabellaCF[4]='4'; tabellaCF[5]='5';
   tabellaCF[6]='6'; tabellaCF[7]='7'; tabellaCF[8]='8';
   tabellaCF[9]='9';
   tabellaCF[10]='A'; tabellaCF[11]='B'; tabellaCF[12]='C';
   tabellaCF[13]='D'; tabellaCF[14]='E'; tabellaCF[15]='F';
   tabellaCF[16]='G'; tabellaCF[17]='H'; tabellaCF[18]='I';
   tabellaCF[19]='J'; tabellaCF[20]='K'; tabellaCF[21]='L';
   tabellaCF[22]='M'; tabellaCF[23]='N'; tabellaCF[24]='O';
   tabellaCF[25]='P'; tabellaCF[26]='Q'; tabellaCF[27]='R';
   tabellaCF[28]='S'; tabellaCF[29]='T'; tabellaCF[30]='U';
   tabellaCF[31]='V'; tabellaCF[32]='W'; tabellaCF[33]='X';
   tabellaCF[34]='Y'; tabellaCF[35]='Z';
   for (var iTab=0; iTab<10; iTab++) {
    tabellaCFA[iTab] = iTab;
   }
   for (var iTab=10; iTab<36; iTab++)
    tabellaCFA[iTab]=iTab-10;
    tabellaCFB[0]=1;   tabellaCFB[1]=0;   tabellaCFB[2]=5;
    tabellaCFB[3]=7;   tabellaCFB[4]=9;   tabellaCFB[5]=13;
    tabellaCFB[6]=15;  tabellaCFB[7]=17;  tabellaCFB[8]=19;
    tabellaCFB[9]=21;
    tabellaCFB[10]=1;  tabellaCFB[11]=0;  tabellaCFB[12]=5;
    tabellaCFB[13]=7;  tabellaCFB[14]=9;  tabellaCFB[15]=13;
    tabellaCFB[16]=15; tabellaCFB[17]=17; tabellaCFB[18]=19;
    tabellaCFB[19]=21; tabellaCFB[20]=2;  tabellaCFB[21]=4;
    tabellaCFB[22]=18; tabellaCFB[23]=20; tabellaCFB[24]=11;
    tabellaCFB[25]=3;  tabellaCFB[26]=6;  tabellaCFB[27]=8;
    tabellaCFB[28]=12; tabellaCFB[29]=14; tabellaCFB[30]=16;
    tabellaCFB[31]=10; tabellaCFB[32]=22; tabellaCFB[33]=25;
    tabellaCFB[34]=24; tabellaCFB[35]=23;
    var tot = 0;
    var tmp = '';
    for (var iChar=0; iChar<15; iChar++) {
     tmp = sValue.charAt(iChar);
     var j=0;
     for (j=0; j<36; j++) {
      if (tmp==tabellaCF[j])
       break;
     }
     if (j==36)
      return false;
     if ((iChar%2)==0) {
      tot += tabellaCFB[j];
     } else {
      tot += tabellaCFA[j];
     }
    }
    tot %= 26;
    iCin = tabellaCF[tot + 10];
    if (iCin==sValue.charAt(15))
     return true;
    else
     return false;
 } else
  return false;
 }
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : valoreRadio
   Descrizione         : Funzione JS che dato un elemento di tipo Radio Button torna il valore del
                         bottone selezionato. Ritorna '' se nessun bottone é selezionato.
   Argomenti di Input  : 
   Argomenti di Output : String - il codice JS.
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function valoreRadio(radio) {
 if (radio!=null) {
  for (var i=0; i < radio.length; i++) {
   if (radio[i].checked)
    return radio[i].value
  }
 }
 return '';
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : aggiornaCombo
   Descrizione         : 
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function aggiornaCombo(cmbOrig, cmbDest, aDati) {
 if (cmbOrig==null || cmbDest==null) return;
 codOrig = 0;
 if (cmbOrig.selectedIndex>=0) {
  codOrig=cmbOrig.options[cmbOrig.selectedIndex].value;
 }
 precIndex = 0;
 precCod = 0;
 if (cmbDest.selectedIndex>=0)
  precCod=cmbDest.options[cmbDest.selectedIndex].value;
 cmbDest.options[0].text = "";
 cmbDest.options[0].value = "";
 counter = 1;
 for (ctr=0; ctr<aDati.length; ctr++) {
  if (aDati[ctr].codMadre==codOrig) {
   var oOption = document.createElement("OPTION");
   isIE() ? cmbDest.add(oOption) : cmbDest.add(oOption, null);
   cmbDest.options[counter].text  = aDati[ctr].des;
   cmbDest.options[counter].value = aDati[ctr].cod;
   if (aDati[ctr].cod==precCod)
    precIndex=counter;
    counter++;
  }
 }
 cmbDest.length = counter;
 cmbDest.selectedIndex=precIndex;
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : aggiornaComboInversa
   Descrizione         : 
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function aggiornaComboInversa(cmbOrig, cmbDest, aDati) {
 codOrig = 0;
 if (cmbOrig.selectedIndex>=0)
  codOrig=cmbOrig.options[cmbOrig.selectedIndex].value;
 else
  return;
 precCod=0;
 if (cmbDest.selectedIndex>=0)
  precCod=cmbDest.options[cmbDest.selectedIndex].value;
 codMadre=0;
 for (ctr=0; ctr<aDati.length; ctr++) {
  if (aDati[ctr].cod==codOrig) {
   codMadre=aDati[ctr].codMadre;
   ctr=10000;
  }
 }
 if (codMadre==precCod || codMadre==0)
   return;
 for (iMadri=0; iMadri<cmbDest.length; iMadri++) {
  if (cmbDest.options[iMadri].value==codMadre) {
   cmbDest.selectedIndex = iMadri;
   return;
  }
 }
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : unisciValoriCheckBox
   Descrizione         : 
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function unisciValoriCheckBox(f) {
 var elemento;
 var i;
 var nome;
 var campoUnione;
 for (i=0; i<f.elements.length; i++) {
  elemento = f.elements[i];
  nome = elemento.name;
  if (typeof nome != 'undefined' && nome.length>2) {
   if (nome.charAt(0)=='m' && nome.charAt(1)=='_') {
    campoUnione = eval('f.' + nome.substring(2));
    if (campoUnione) {
     if (elemento.checked) {
      // --- Se non era già acceso.
      if (campoUnione.value.indexOf(elemento.value + '+') == -1)
       // --- Lo accende.
       campoUnione.value = campoUnione.value + elemento.value + '+';
     } else {
      // --- Se era già acceso.
      if (campoUnione.value.indexOf(elemento.value + '+') != -1)
        // --- Lo spegne.
        campoUnione.value = campoUnione.value.replace(elemento.value + '+', '');
     }
    }
   }
  }
 }
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : controllaCampiFormMessaggi
   Descrizione         : Seleziona gli elementi option presenti nella SelGruppiOut e nella contatti
                         utilizzati come colonne calcolate nella PustTabellaMessaggi ed effettua il
                         controlloCampiForm.
   Descrizione         : 
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function controllaCampiFormMessaggi(f) {
 var i;
 if ((f.selGruppiOut.options.length==0) && (f.contatti.options.length==0)) {
  alert(getMessageDefault('nessuncontatto', 'Occorre inserire almeno un contatto o una lista di distribuzione.'));
  return false;
 }
 for (i=0; i<f.selGruppiOut.options.length; i++) {
  f.selGruppiOut.options[i].selected = true;
 }
 for (i=0; i<f.contatti.options.length; i++) {
  f.contatti.options[i].selected = true;
 }
 return controllaCampiForm(f);
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : openCloseSubForm
   Descrizione         : Questa funzione è utilizzata da ColonnaSeparatore per aprire/chiudere una sezione 
                         del form.
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : Antonio Flaccomio
   Data creazione      : 14/01/2008
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function openCloseSubForm(el) {
	var bullet = el.getElementsByTagName('IMG')[0];
	var show = (bullet.src.indexOf('plus.gif') > 0);
	bullet.src = show ? '../images/menu/minus.gif' : '../images/menu/plus.gif';
	var el = el.parentNode.parentNode;
	while((el = el.nextSibling) != null) {
		if(el.className == 'table-row') {
			if(el.getElementsByTagName('DIV')[0] != null && el.getElementsByTagName('DIV')[0].className == 'separatore') {
				break;
			}
			el.style.display = show ? 'block' : 'none';
		}
	}
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : focusSulPrimoCampo
   Descrizione         : Questa funzione è utilizzata in qualsiasi  maschera di immissione o modifica
                         per portare il cursore sul primo campo utile.
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : ep
   Data creazione      : 18/06/2008
   Autore              : 
   Data revisione      : 
   Annotazioni         : Recuperato da codice esistente pre L4 
                         La gestione dei campi DECODIFICATO è stata aggiunta perchè la proprietà 
                         "readonly" non sembrava funzionare.
                         In realtà ho verificato che readOnly è una proprieta CASE SENSITIVE !!
                         del DOM mentre le altre non lo sono (name, value, type).
                         Non fidandomi del js, permane il controllo anche su DECODIFICATO
   ----------------------------------------------------------------------------------------------------- */
function focusSulPrimoCampo(){
 var f = document.getElementById('passaggio');
 if (f != null) {
  for (i=0; i<f.elements.length; i++) {
   var nome='?';
   if (f.elements[i].type == 'text'){
    nome = f.elements[i].name;
   }
   if (!f.elements[i].readOnly && 
       !f.elements[i].disabled && 
       f.elements[i].type != 'hidden' && 
       nome.indexOf('_DECODIFICATO') == -1 ) {
    f.elements[i].focus();
    break;
   }
  }
 }
}

/* -----------------------------------------------------------------------------------------------------
   Altre funzioni
   ----------------------------------------------------------------------------------------------------- */

/* -----------------------------------------------------------------------------------------------------
   Funzione            : checkKey
   Descrizione         : Controlla che sia stato premuto il tasto invio e chiama l'handler 'onclick'
                         sull'elemento passato.
   Descrizione         : 
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function checkKey(el) {
 if (el == null) {
  return;
 }
 if (event.keyCode==13) {
  el.onclick();
 }
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : replaceSpecialChar
   Descrizione         : 
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function replaceSpecialChar(inString) {
 var rules = [['\r\n', '(;-))'],
              ['\\', '&#92;'],
              ['<', '&#60;'],
              ['>', '&#62;'],
              ['"', '&#34;'],
              ['\'', '&#39;']];

 for (var i=0; i<rules.length; i++) {
  var checkStr = rules[i][1];
  while (inString.indexOf(checkStr) != -1) {
   var tmpStrLeft  = inString.substring(0, inString.indexOf(checkStr));
   var tmpStrRight = inString.substring(inString.indexOf(checkStr) + checkStr.length, inString.length);
   inString = tmpStrLeft + rules[i][0] + tmpStrRight;
  }
 }
 return inString;
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : replace
   Descrizione         : 
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function replace(Expression, Find, Replace) {
 var strTmp = Expression;
 var a = 0;
 for (var i = 0; i < Expression.length; i++) {
  a = strTmp.indexOf(Find);
  if (a == -1) {
   break;
  } else {
   strTmp = strTmp.substring(0, a) + Replace + strTmp.substring(a + Find.length);
  }
 }
 return strTmp;
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : lanciaMotoreRicercaRapida
   Descrizione         : 
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function lanciaMotoreRicercaRapida(nomeTransazione, objCampoRicerca) {
 var w    = 740;
 var h    = 450;
 var winl = (screen.width - w) / 2;
 var wint = (screen.height - h) / 2;
 var winProps = 'height=' + h + ', width=' + w + ', top=' + wint + ', left= ' + winl;
 if (objCampoRicerca==null) {
  RicercaRapida = window.open('../dbmanager/mrr-init.do?nomeTabella=' + nomeTransazione, 'PopUpWindow', 'toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=yes, resizable=no, ' + winProps);
 } else {
  RicercaRapida = window.open('../dbmanager/mrr-init.do?nomeTabella=' + nomeTransazione + '&valoreMnemonico=' + objCampoRicerca.value, 'PopUpWindow', 'toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=yes, resizable=no, ' + winProps);
 }
 return;
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : lanciaMotoreRicercaRapidaArr
   Descrizione         : 
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function lanciaMotoreRicercaRapidaArr(nomeTransazione, arrayCampi) {
 var w    = 740;
 var h    = 450;
 var winl = (screen.width - w) / 2;
 var wint = (screen.height - h) / 2;
 var winProps = 'height=' + h + ', width=' + w + ', top=' + wint + ', left= ' + winl;
 var campi = '';
 var valore = '';
 var elemento;
 var campo = '';
 var sinonimo = '';
 var desObbligatorio='';

 for (var i = 0; i < arrayCampi.length; i++) {
  desObbligatorio='';
  if (arrayCampi[i].indexOf('!') > 0) {
   desObbligatorio = arrayCampi[i].substr(arrayCampi[i].indexOf('!')+1);
   arrayCampi[i] = arrayCampi[i].substr(0,arrayCampi[i].indexOf('!'));
  }
  // --- Verifico se siamo in presenza di un campo
  //     sinonimo (ved. documentazione MRR).  
  if (arrayCampi[i].indexOf('=') > 0) {
   campo = arrayCampi[i].substr(0,arrayCampi[i].indexOf('='));
   sinonimo = arrayCampi[i].substr(campo.length+1);
   elemento = eval('document.forms[0].' + campo);
  } else {
   elemento = eval('document.forms[0].' + arrayCampi[i]);
  }
  var valore=(elemento ? elemento.value : '');
  if(valore=='' && desObbligatorio!=''){
     alert('Prima di richiamare la finestra di ricerca è necessario digitare il campo "'+desObbligatorio+'"');
     return;
  }
  if (elemento != null && arrayCampi[i].indexOf('=') > 0) {
   campi += '&' + sinonimo + '=' + valore;
  } else {
   campi += '&' + arrayCampi[i] + '=' + valore;
  }
 }
 // --- Debug
 // alert('campi ' + campi);
 RicercaRapida = window.open('../dbmanager/mrr-init.do?nomeTabella=' + nomeTransazione + campi, 'PopUpWindow', 'toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=yes, resizable=no, ' + winProps);
 return;
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : funzioneNonDisponibile
   Descrizione         : Controllo funzione non disponibile (per i bottoni custom non disponibili).
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function funzioneNonDisponibile(f) {
 alert(getMessageDefault('funzioneNonDisponibile', 'Funzione non disponibile!'));
 return false;
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : writeData
   Descrizione         : Questa funzione scrive la data del giorno sulla home.
   Argomenti di Input  :
   Argomenti di Output : La stringa calcolata
   Autore              : Ernesto Bazan
   Data creazione      : 06/05/2007
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function writeData() {
 var day   = new Array(getMessageDefault("domenica", "domenica"), getMessageDefault("lunedi", "lunedi"), getMessageDefault("martedi", "martedi"),
                       getMessageDefault("mercoledi", "mercoledi"), getMessageDefault("giovedi", "giovedi"), getMessageDefault("venerdi", "venerdi"),
                       getMessageDefault("sabato", "sabato"));

 var month = new Array(getMessageDefault("gennaio", "gennaio"), getMessageDefault("febbraio", "febbraio"), getMessageDefault("marzo", "marzo"),
                       getMessageDefault("aprile", "aprile"), getMessageDefault("maggio", "maggio"), getMessageDefault("giugno", "giugno"),
                       getMessageDefault("luglio", "luglio"), getMessageDefault("agosto", "agosto"), getMessageDefault("settembre", "settembre"),
                       getMessageDefault("ottobre", "ottobre"), getMessageDefault("novembre", "novembre"), getMessageDefault("dicembre", "dicembre"));
 
 var s = "";
 var d = new Date();
 s += day[d.getDay()];
 s += " " + d.getDate();
 s += " " + month[d.getMonth()];
 if (d.getHours() < 10) {
  s += " 0" + d.getHours();
 } else {
  s += "  " + d.getHours();
 };

 if (d.getMinutes() < 10) {
  s += ":0" + d.getMinutes();
 } else {
  s += ":" + d.getMinutes();
 }
 document.getElementById('data').innerHTML = s;
 setTimeout("writeData()", 60000);
 return;
}

/* -----------------------------------------------------------------------------------------------------
   Le successive righe devono essere decommentate prima del deploy.
   ----------------------------------------------------------------------------------------------------- */
/*
function right() {
 if (navigator.appName == 'Netscape' && (e.which == 3 || e.which == 2)) {
  return false;
 } else if (navigator.appName == 'Microsoft Internet Explorer' && (event.button == 2 || event.button == 3)) {
  alert("SISPI S.p.A.");
  return false;
 }
 return true;
}

if (document.layers) {
 window.captureEvents(Event.MOUSEDOWN);
}
if (document.layers) {
 window.captureEvents(Event.MOUSEUP);
}
document.onmousedown = right;
document.onmouseup   = right;
window.onmousedown   = right;
window.onmouseup     = right;
*/

/* -----------------------------------------------------------------------------------------------------
   Funzione            : 
   Descrizione         : Gestione News
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
var startPos = 120;     // Posizione iniziale
var speed    = 30;      // Velocità dello scroller (20 più veloce, 40 più lento)
var newsID   = 'news';  // ID div box delle news
var classAdd = 'hasJS'; // Classe che lo script aggiunge quando Javascript è disponibile

// --- Inizializzazione scroller.
var scrollPos = startPos;

function initNews() {
 var n = document.getElementById(newsID);
 if(!n) {
  return;
 }
 n.className = classAdd;
 interval = setInterval('scrollNews()', speed);
 n.onmouseover = function() {
  clearInterval(interval);
 }
 n.onmouseout = function() {
  interval = setInterval('scrollNews()', speed);
 }
}

function scrollNews() {
 var n = document.getElementById(newsID);
 n.style.top = scrollPos + 'px';
 if (scrollPos < -n.scrollHeight) {
  scrollPos = startPos;
 }
 scrollPos--;
}

/* -----------------------------------------------------------------------------------------------------
   Funzione            : externalLinks
   Descrizione         : Gestione Link esterni
   Argomenti di Input  : 
   Argomenti di Output : 
   Autore              : 
   Data creazione      : 
   Autore              : 
   Data revisione      : 
   Annotazioni         : 
   ----------------------------------------------------------------------------------------------------- */
function externalLinks() {
 if (!document.getElementsByTagName) {
  return;
 }
 var anchors = document.getElementsByTagName("a");
 for (var i=0; i<anchors.length; i++) {
  var anchor = anchors[i];
  if (anchor.getAttribute("rel") == "esterno") {
   anchor.target = "_blank";
   if (anchor.title) {
    anchor.title += getMessageDefault('linkinnewwindow', '\n (Attenzione: questo link si apre in una nuova finestra) ');
   } else {
    anchor.title += getMessageDefault('linkinnewwindow', ' (Attenzione: questo link si apre in una nuova finestra) ');
   }
  }
 }
}

/* -----------------------------------------------------------------------------------------------------
   Fissa il target del form metareport utilizzato nel tasto Pulisci dei report
   ----------------------------------------------------------------------------------------------------- */
function setTargetMetareport() {
 document.getElementById("metareport").target="_self";
 return true;
}

/* -----------------------------------------------------------------------------------------------------
   Funzioni semplificate per la gestione dei cookie
   ----------------------------------------------------------------------------------------------------- */
function setCookie(name, value, expires, path, domain, secure) {
  var today = new Date();
  today.setTime(today.getTime()); //Sono millisecondi
  if (expires) {
    expires = expires * 1000 * 60 * 60 * 24;
  }
  var expires_date = new Date(today.getTime() + (expires));
  document.cookie = name + "=" +escape(value) + ((expires) ? ";expires=" + expires_date.toGMTString() : "") + ((path) ? ";path=" + path : "") + ((domain) ? ";domain=" + domain : "") + ((secure) ? ";secure" : "");
}

function getCookie(name) {
  var start = document.cookie.indexOf(name + "=");
  var len = start + name.length + 1;
  if ((!start) && (name != document.cookie.substring(0, name.length))) {
   return null;
  }
  if (start == -1) return null;
  var end = document.cookie.indexOf(";", len);
  if (end == -1) end = document.cookie.length;
  return unescape(document.cookie.substring(len, end));
}

function deleteCookie(name, path, domain) {
 if (getCookie(name)) {
  document.cookie = name + "=" + ((path) ? ";path=" + path : "") + ((domain) ? ";domain=" + domain : "") +  ";expires=Thu, 01-Jan-1970 00:00:01 GMT";
 }
}

/* -----------------------------------------------------------------------------------------------------
   Evento window.onload
   ----------------------------------------------------------------------------------------------------- */
function windowOnLoad() {
 // --- Imposta style, font e skin.
 var cssCarattere = document.getElementById('csscarattere');
 if(cssCarattere) {
  cssCarattere.href = '../css/' + readCookie('fontSize', 'fontmedium.css');
 }
 var cssSkin = document.getElementById('cssskin');
 if(cssSkin) {
  cssSkin.href = '../css/' + readCookie('cssskin', 'skindefault.css');
 }
 var colonna1 = document.getElementById('colonna1');
 if(colonna1) {
   colonna1.style.display = readCookie('vistamenu', 'inline');
   // --- Imposta menù.
  if (colonna1.style.display == "inline") {
   createCookie('vistamenu', 'inline', 30);
   colonna1.style.display = "inline";
   document.getElementById("menuchiuso").style.display = "none";
  } else {
   createCookie('vistamenu', 'none', 30);
   colonna1.style.display = "none";
   document.getElementById("menuchiuso").style.display = "inline";
  }
 }

 // --- Attiva link esterni.
 externalLinks();

 // --- Attiva news.
 if (!document.getElementById) {
  return;
 }
 initNews();
 
 // --- Mostra / Nascondi campi non obbligatori.
 if (document.getElementById) {
  var lnk = document.getElementById('form-handler');
  if (lnk != null && propColonne && propColonne.length > 1) {
   var swi = lnk.appendChild(document.createElement('a'));
   swi.href = '#';
   swi.appendChild(document.createTextNode(getMessageDefault('nascondi', 'Nascondi')));
   swi.onclick = function() {
    var lnkText = this.firstChild.nodeValue;
    this.firstChild.nodeValue = (lnkText == getMessageDefault('nascondi', 'Nascondi')) ? getMessageDefault('mostra', 'Mostra') : getMessageDefault('nascondi', 'Nascondi');
    this.title = (lnkText == getMessageDefault('nascondi', 'Nascondi')) ? getMessageDefault('mostraCampiNonObbligatori', 'Mostra campi non obbligatori') : getMessageDefault('nascondiCampiNonObbligatori', 'Nascondi campi non obbligatori');
    var tmp = document.getElementsByTagName('div');
    for (var i=0; i<tmp.length; i++) {
     if (tmp[i].className == 'container-field-not-required') {
      tmp[i].style.display = (tmp[i].style.display == 'none') ? 'block' : 'none';
     }
    }
    return false;
   }
  }
 }
}