////////////////////////////////////////////////////////////////////////
///// variabili globali utilizzate da formattaImporto
/////////////////////////////////////////////////////////////////////////
	var segno, decimali, lmax;
	var presenzaSegno;
	var giaPremutoVirgola;
	var VIRGOLA, PUNTO;
	var regexpPoint = /\./g;
	var regexpComma = /,/g;
	NETSCAPE = "Netscape";
	EXPLORER = "Microsoft Internet Explorer";
	NUMERI = "0123456789";
	var SetCaratteriAmmessi = " !()+,-./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]_abcdefghijklmnopqrstuvwxyz";
	// variabili lato client per le chiamate ajax
	var myFieldsSeparator = "|";
	var myObjectsSeparator = "#%#";  
	var myRowsSeparator = "#$#"; 
////////////////////////////////////////////////////////////////////////
///// routines utilizzate da formattaImporto
/////////////////////////////////////////////////////////////////////////
	function presentaAVideoConSegno(stringa, dec, lungh, s, sistema) {
    setParametri(dec, lungh, s, sistema);
	
    stringaSeparata = new Array(3);
    stringaSeparata = separaStringa(stringa);
    parteIntera = stringaSeparata[0];
    parteDecimale = stringaSeparata[1];
    parteSegno = stringaSeparata[2];
	
	//se nella parte decimale è presente il PUNTO, vuol dire
	//che era stata digitata la virgola col carattere del PUNTO,
	//quindi sostituisco il PUNTO con la VIRGOLA
    if (parteDecimale.charAt(0) == PUNTO) {
        parteDecimale = VIRGOLA + parteDecimale.substr(1, parteDecimale.length);
    }

    if (parteDecimale.length >= 1) {
        n = parteDecimale.length;
        for (k = 0; k <= decimali - n; k++)
            parteDecimale = parteDecimale + '0';
    }

    if (parteIntera.length == 0)
        parteIntera = "0";
	
	if (parteSegno == "+"){
		 return  parteIntera + parteDecimale ;
	}else{
		 return  parteSegno + parteIntera + parteDecimale ;
	}
	
  }
  
	function presentaAVideo(stringa, dec, lungh, s, sistema) {
	setParametri(dec, lungh, s, sistema);

    stringaSeparata = new Array(3);
    stringaSeparata = separaStringa(stringa);
    parteIntera = stringaSeparata[0];
    parteDecimale = stringaSeparata[1];
    parteSegno = stringaSeparata[2];

		//se nella parte decimale è presente il PUNTO, vuol dire
		//che era stata digitata la virgola col carattere del PUNTO,
		//quindi sostituisco il PUNTO con la VIRGOLA
    if (parteDecimale.charAt(0) == PUNTO) {
        parteDecimale = VIRGOLA + parteDecimale.substr(1, parteDecimale.length);
    }

    if (parteDecimale.length >= 1) {
        n = parteDecimale.length;
        for (k = 0; k <= decimali - n; k++)
            parteDecimale = parteDecimale + '0';
    }

    if (parteIntera.length == 0)
        parteIntera = "0";
    return puntina(parteIntera) + parteDecimale + parteSegno;
  }

  function controllaOnBlur(stringa, dec, lungh, s, sistema) {
      var MSG7 ="Troppi interi";

      setParametri(dec, lungh, s, sistema);

      stringaSeparata = new Array(3);
      stringaSeparata = separaStringa(stringa);
      parteIntera = stringaSeparata[0];
      parteDecimale = stringaSeparata[1];
      parteSegno = stringaSeparata[2];

      if (parteIntera.length > lmax - decimali) {
          alert(MSG7 + ": " + stringa);
          return false;
      } else
          return true;
  }

  function spuntina(stringa, dec, lungh, s, sistema) {
      setParametri(dec, lungh, s, sistema);
      if (PUNTO == ".") {
          expr = /\./;
      } else {
          expr = /\,/;
      }
      while ( stringa.match(expr,'') ) {
          stringa = stringa.replace(expr,'');
      }
    	return stringa;
  }

  function puntina(stringa) {

    a = new Array();
    i = 0;
    while (i < stringa.length)
    {
      a[i] = stringa.charAt(i++);
    }
    k = stringa.length;

    jj = k - 3;
    while (jj > 0)
    {
      for (l = k; l > jj; l--)
      {
        a[l] = a[l-1];
      }
      a[jj] = PUNTO;
      k = k + 1;
      jj = jj - 3;
    }
    esito = '';
    for (jj = 0; jj < k; jj++)
    {
      esito = esito + a[jj];
    }

    return esito;
  }

  function svirgola(stringa) {
    stringa = stringa.replace(VIRGOLA,'.');
    return stringa;
  }

  function uguaglianzaStringhe(stringa1, stringa2) {
      esito = true;
      if (stringa1.length == stringa2.length)
          for (i = 0; i < stringa1.length; i++)
          {
              if (stringa1.charAt(i) != stringa2.charAt(i))
                  esito = false;
          }
      else
          esito = false;

      return esito;
  }

  function setParametri(dec, lungh, s, sistema) {
      if (dec == null || dec == '') {
         decimali =  2;
      } else {
         decimali =  dec;
      }

      if (lungh == null || lungh == '') {
         lmax =  10;
      } else {
         lmax =  lungh;
      }

      if (s == null || s == '') {
          segno =  "N";
      } else {
          segno =  s.toUpperCase();
      }

      if (sistema == "ENG") {
          VIRGOLA =  '.';
          PUNTO =  ',';
      } else {
          VIRGOLA =  ',';
          PUNTO =  '.';
      }
  		//alert(decimali + "d" + lmax + "l" + segno + "s" + VIRGOLA + "v" + PUNTO + "p");
  }

  //separa l'importo in: parteIntera, parteDecimale, parteSegno
  function separaStringa(stringa) {
      var parteIntera, parteDecimale;
      var parteSegno;
      lung = stringa.length;
  		//indexOf restituisce -1 se non trova la stringa cercata
  		//    posizioneVirgola = stringa.indexOf(VIRGOLA);
      posizioneVirgola = stringa.indexOf(VIRGOLA) +
                         stringa.indexOf(PUNTO) + 1 ;
      posizioneSegno = stringa.indexOf("+") + stringa.indexOf("-") + 1;
  //parte decimale presente
      if (posizioneVirgola != -1)
      {
          giaPremutoVirgola = true;
		  if (posizioneSegno != -1){
				parteIntera = stringa.substring(1, posizioneVirgola); //2007
		  }else{
				parteIntera = stringa.substring(0, posizioneVirgola); //2007
		  }
  //segno presente
          if (posizioneSegno != -1)
          {
			 
              parteDecimale = stringa.substring(posizioneVirgola, lung);//2007
              
  //segno non richiesto
              if (segno == "N")
              {
                  presenzaSegno = false;
                  parteSegno = "";
              }
              else
              {
                  presenzaSegno = true;
                  parteSegno = "" + stringa.charAt(posizioneSegno);
              }
          }
  //segno assente
          else
          {
              parteDecimale = stringa.substring(posizioneVirgola, lung);
  //segno richiesto
              if(segno == "S")
              {
                  presenzaSegno = true;
                  parteSegno = "+";
              }
              else
              {
                  presenzaSegno = false;
                  parteSegno = "";
              }
          }
      }
      else
  //parte decimale assente
      {

          if (decimali > 0)
          {
              parteDecimale = VIRGOLA;
              for (k = 1; k <= decimali; k++)
                  parteDecimale = parteDecimale + '0';
          }
          else
              parteDecimale = "";
          giaPremutoVirgola = false;
  //segno presente
          if (posizioneSegno != -1)
          {
              parteIntera = stringa.substring(1, lung);

  //segno non richiesto
              if(segno == "N")
              {
                  presenzaSegno = false;
                  parteSegno = "";
              }
              else
              {
                  presenzaSegno = true;
                  parteSegno = "" + stringa.charAt(posizioneSegno);
              }
          }
  //segno assente
          else
          {
  //segno richiesto
              parteIntera = stringa;
              if(segno == "S")
              {
                  presenzaSegno = true;
                  parteSegno = "+";
              }
              else
              {
                  presenzaSegno = false;
                  parteSegno = "";
              }
          }
      }
      esito = new Array( parteIntera , parteDecimale , parteSegno);
      return esito;
  }

  //funzione per la digitazione di un campo di tipo importo (separatore migliaia)
  function formattaImporto(evento) {
          BACKSPACE = 8;
   ///// Netscape Navigator non intercetta TAB ENTER CANC CURSORI END HOME///////
      if (NAVIGATOR == NETSCAPE) {
          VIRGOLA1 = 44;
          VIRGOLA2 = 46;
          VIRGOLA3 = 46;
          PIU = 43;
          MENO = 45;
          numero = String.fromCharCode(evento.which);
          codice = evento.which;
          valore = evento.target.value;
      } else {
          VIRGOLA1 = 188;
          VIRGOLA2 = 110;
          VIRGOLA3 = 190;
          PIU = 107;
          MENO = 109;

          SU = 38;
          GIU = 40;
          DX = 39;
          SX = 37;
          CANC = 46;
          END = 35;
          HOME = 36;
          TAB = 9;

          numero = String.fromCharCode(evento.keyCode);
          codice = evento.keyCode;
          valore = evento.srcElement.value;
      }
      ritornaFalso = 0;

      stringaSeparata = new Array(3);
      var importoIniziale = valore;
      var importoAggiornato = importoIniziale;
      var parteIntera, parteDecimale, parteSegno;
      var valore;

      importoDaAggiornare = false;

      stringaSeparata = separaStringa(valore);
      parteIntera = stringaSeparata[0];
      parteDecimale = stringaSeparata[1];
      parteSegno = stringaSeparata[2];
  //alert (parteIntera + "#" + parteDecimale + "#" + parteSegno);

      if (NAVIGATOR == EXPLORER)
          if (codice == SU   ||
              codice == GIU  ||
              codice == DX   ||
              codice == SX   ||
              codice == CANC ||
              codice == END  ||
              codice == HOME ||
              codice == TAB    )
              return true;

      if (codice == PIU || codice == MENO) {
          if (presenzaSegno)
          {
              if (codice == PIU)
                  parteSegno = '+';
              else
                  parteSegno = '-';
              if (NAVIGATOR == NETSCAPE)
                  evento.target.value = parteIntera + parteDecimale + parteSegno;
              else
                  evento.srcElement.value = parteIntera + parteDecimale + parteSegno;
              return false;
          }
          else
              return false;
      }

      if (codice == VIRGOLA1 || codice == VIRGOLA2 || codice == VIRGOLA3) {
          if ( (importoIniziale.length >= lmax)   ||
               ((parteDecimale.length - 1) > decimali)   )
          {
              return false;
          }
          else
          {
              if (giaPremutoVirgola)
                  return false;
              else
                  return true;
          }
      }

      if (codice == BACKSPACE) {
          return true;
      }

      if (carattereNumerico(codice))
      {
          if(giaPremutoVirgola)
          {
              if (parteIntera.length + parteDecimale.length - 1 >= lmax)
              {
                  return false;
              }
              else
              {
                  if ((parteDecimale.length - 1) < decimali)
                      return true;
                  else
                      return false;
              }
          }
          else
          {
              if ( parteIntera.length < (lmax - decimali) )
                  return true;
              else
                  return false;
          }
      }
      return false;
  }

  //  End  /////////////////////////////////////////////////////////////////

  function controllaOnUp(evento, dec, lungh, s, sistema) {
      setParametri(dec, lungh, s, sistema);
      stringaSeparata = new Array(3);
      if (NAVIGATOR == NETSCAPE)
          stringaSeparata = separaStringa(evento.target.value);
      else
          stringaSeparata = separaStringa(evento.srcElement.value);
      parteIntera = stringaSeparata[0];
      parteDecimale = stringaSeparata[1];
      parteSegno = stringaSeparata[2];

      if (parteDecimale.length > decimali + 1)
      {
          alert("Errore: troppi decimali")
          parteDecimale = parteDecimale.substr(1, parteDecimale.length);
          if (NAVIGATOR == NETSCAPE)
              evento.target.value = parteIntera + parteDecimale + parteSegno;
          else
              evento.srcElement.value = parteIntera + parteDecimale + parteSegno;
      }

      if (parteIntera.length > lmax - decimali)
      {
  //        alert("Errore: troppi interi")
      }
  }

  ////////////////////////////////////////////////////////////////////////
  ///// controllo la digitazione carattere per carattere se numerica
  /////////////////////////////////////////////////////////////////////////
  function carattereNumerico(codice) {
      if (navigator.appName == "Netscape") {
          if ( (codice > 47 && codice < 58) )
              return true;
          else
              return false;
      } else {
          if ( (codice > 47 && codice < 58) ||
               (codice > 95 && codice < 106)  )
              return true;
          else            return false;
      }
  }

  function isNumerico(evento) {
      if (navigator.appName == "Netscape"){
          codice = evento.which
          valore = String.fromCharCode(evento.which);
      } else {
          codice = evento.keyCode;
          valore = String.fromCharCode(evento.keyCode);
      }

      //var numero = /[\d,\s,\b]/;
      //var matchArray = valore.match(numero);

      //if (navigator.appName == "Netscape")
      //{
      //    if (matchArray == null)
      //        return false;
      //    else
      //        return true;
      //}

      if (carattereNumerico(codice))
          return true;
      else
          return false;
  }

  //  End  /////////////////////////////////////////////////////////////////


  ////////////////////////////////////////////////////////////////////////
  ///// controllo la digitazione carattere per carattere se alfabetica
  /////////////////////////////////////////////////////////////////////////
  function isAlfabetico(evento) {
   if (navigator.appName == "Netscape")
      valore = String.fromCharCode(evento.which);
    else
      valore = String.fromCharCode(evento.keyCode);

    var numero = /[a-z,\s,\b]/gi;
    var matchArray = valore.match(numero);
    if (matchArray == null)
      return false;
    else
      return true;
  }
  // End  /////////////////////////////////////////////////////////////////


  ////////////////////////////////////////////////////////////////////////
  ///// controllo la digitazione carattere per carattere se alfanumerico
  /////////////////////////////////////////////////////////////////////////

  function isAlfanumerico(evento) {
   if (navigator.appName == "Netscape")
      valore = String.fromCharCode(evento.which);
    else
      valore = String.fromCharCode(evento.keyCode);

    var numero = /[\w,\s,\b]/;
    var matchArray = valore.match(numero);
    if (matchArray == null)
      return false;
    else
      return true;
  }

  // End  /////////////////////////////////////////////////////////////////


  ////////////////////////////////////////////////////////////////////////
  ///// Controllo validità campi data
  /////  I messaggi di errore a video hanno formati diversi:
  /////     con Internet Explorer compaiono in una nuova finestra
  /////     con Netscape compaiono nella barra di stato (l'uso di una finestra
  /////     provoca loop infinito)

  /////////////////////////////////////////////////////////////////////////
  function isDataValida(dateStr)
  {
  	// la data può avere il seguente formato:
  	// GG/MM/AA   GG/MM/AAAA   GG-MM-AA   GG-MM-AAAA

  	var datePat = /^(\d{1,2})(\/|-)(\d{1,2})\2(\d{2}|\d{4})$/;

  	var matchArray = dateStr.match(datePat); // is the format ok?
        var errors = '';
        var esito = true;

        window.status = 'Document: Done';

     if(dateStr.length == 0)
     {
       return true;
     }

  if (matchArray == null)
  {
  //		alert("La data ha formato invalido.")
  //		return false;
  		errors = "La data ha formato invalido.";
  		esito = false;
  }
  else
  {
    month = matchArray[3]; // parse date into variables
    day = matchArray[1];
    year = matchArray[4];
    if (month < 1 || month > 12)
    { // check month range
  		errors = "Mese deve essere da 1 a 12.";
  		esito = false;
    }
    if ( day < 1 ||
     ((month==1 || month==3 || month==5 || month==7 ||
       month==8 || month==10 || month==12) && day>31) )
    {
    	errors = "Giorno deve essere da 1 a 31.";
        esito = false;
    }

    if ( day < 1 ||
      	 ((month==4 || month==6 || month==9 || month==11) && day>30) )
    {
      errors = "Giorno deve essere da 1 a 30.";
      esito = false;
    }

    if (month == 2)
    { // check for february 29th
      var g = parseInt(year / 4);
      if (day > 29 || (day == 29 && (year / 4) != g))
      {
  	errors = "Febbraio nel "+year+" non può avere "+day+" giorni!";
  	esito = false;
      }
    }
  }
  if (esito == false)
  {
  // con Netscape emetto il messaggio di errore nella riga di stato per problemi di loop
      if (navigator.appName == "Netscape")
      {
          window.status = errors;
      }
      else
      {
        alert (errors);

      }

  }
  return esito;  // date is valid
  }

  //  End  /////////////////////////////////////////////////////////////////

  ////////////////////////////////////////////////////////////////////////
  ///// Controllo validità e formattazione campo data
  ///// Questa funzione viene mantenuta per consentire l'utilizzo del vecchio nome
  ///// per un periodo di tempo limitato
  //////////////////////////////////////////////////////////////////////////
  function ControllaData(page)
  {
    var esito=FormattaData(page);
    return esito;
  }

  ////////////////////////////////////////////////////////////////////////
  ///// Controllo validità e formattazione campo data
  /////  l'anno di due cifre è completato con "20" se <50, altrimenti con "19"
  /////  I messaggi di errore a video hanno formati diversi:
  /////     con Internet Explorer compaiono in una nuova finestra
  /////     con Netscape compaiono nella barra di stato (l'uso di una finestra
  /////     provoca loop infinito)
  /////  Se la data digitata contiene errori il focus rimane sul campo
  /////////////////////////////////////////////////////////////////////////

  // *********  variabili globali  **********//

  //***   se anno < AnnoDiscriminante si assume secolo 21° altrimenti 20° secolo  ***//

    var AnnoDiscriminante = '50';
    var AnnoMinimo  = '1900';
    var AnnoMassimo = '2100';
    var EsitoControlli = true;
    var Msg1 = "Il formato della data non é corretto";
    var Msg2 = "Il giorno deve essere compreso fra 1 e 31 " ;
    var Msg3 = "Il mese digitato non può avere ";
    var Msg4 = "Il mese deve essere compreso fra 1 e 12 ";
    var Msg5 = "L' anno digitato non é bisestile";
    var Msg6 = "L' anno digitato non é valido ";
    var Msg7 = "Sono ammessi solo anni compresi tra 1900 e 2100";
    var errors='';

  function FormattaData(page)
  {
    var dataFormattata='          ';
    var dataOut='          ';
    data = page.value;
    window.status = 'Document: Done';

    if (!data)
    {
      EsitoControlli = true;
      dataOut='';
    }
    else
    {
      EsitoControlli = true;
      if (!parseFloat(data.charAt(0)) && data.charAt(0) != "0")
      {
        dataFormattata = "**********";
      }
      else
      {
  //      separatore nel secondo carattere: GsMs oppure GsMMs

        if (!parseFloat(data.charAt(1)) && data.charAt(1) != "0")
        {
          if (!parseFloat(data.charAt(3)) && data.charAt(3) != "0")
            dataFormattata = DataGsMs(data);
          else
            dataFormattata = DataGsMMs(data);
        }
        else
        {

  //      separatore nel terzo carattere: GGsMs oppure GGsMMs
          if (!parseFloat(data.charAt(2))&& data.charAt(2) != "0")
          {
            if (!parseFloat(data.charAt(5)) && data.charAt(5) != "0")
              dataFormattata = DataGGsMMs(data);
            else
              dataFormattata = DataGGsMs(data);
          }
          else
          {
            dataFormattata = DataGGMM(data);
          }
        }
      }

    if (dataFormattata == "**********")
    {
      errors = Msg1;
    }
    else
    {
     errors = ControlliLogici(dataFormattata);
    }
    if (errors != '')
    {
      dataFormattata = data;
      EsitoControlli=false;

  // con Netscape i messaggi di errore vengono emessi nella StatusBar (l'uso di
  //   alert o di finestra aggiuntiva provoca loop infinito)

      if (navigator.appName == "Netscape")
      {
          window.status = errors;
      }
      else
      {
        alert (errors);

      }
     page.focus();

    }
    else
    {
      dataOut=dataFormattata;
      EsitoControlli=true;
      page.value = dataOut;

    }
  }

  return EsitoControlli;
  }
  // ******    controllo data nel formato GsMsAAAA GsMsAA    ******

  function DataGsMs(data) {
    var dataFormattata='';
    var anno = '';

   // formattazione anno

    if(data.length == 8)
    {
      anno = data.substring(4,8);
    }
    else
    {
      anno = data.substring(4,6);
    }

    if(((data.length != 8) && (data.length != 6)) ||

  // controllo se 1° carattere non è numerico
       (!parseFloat(data.charAt(0)) && data.charAt(0) != "0")||

  // oppure se 1° separatore non è carattere speciale

         !ValoreSeparatore(data.charAt(1)) ||

  // controllo se 2° carattere non è numerico
         (!parseFloat(data.charAt(2)) && data.charAt(2) != "0") ||

  // oppure se 2° separatore non è carattere speciale
         !ValoreSeparatore(data.charAt(3)) ||

  // controllo se anno non è numerico
         !ValoreNumerico (anno))
         {
           dataFormattata = "**********";
         }
         else
         {
           if (anno.length == 2)  anno = CompletaAnno(anno);
           dataFormattata = "0";
           dataFormattata += data.substring(0,1);
           dataFormattata += "/";
           dataFormattata += "0";
           dataFormattata += data.substring(2,3);
           dataFormattata += "/";
           dataFormattata += anno;
         }
    return dataFormattata;
  }
  // ******    controllo data nel formato GsMMsAAAA GsMMsAA    ******

  function DataGsMMs(data) {
    var dataFormattata='';
    var anno = '';

   // formattazione anno

    if(data.length == 9)
    {
      anno = data.substring(5,9);
    }
    else
    {
      anno = data.substring(5,7);
    }

    if(((data.length != 9) && (data.length != 7)) ||

  // controllo se 1° carattere non è numerico
       (!parseFloat(data.charAt(0)) && data.charAt(0) != "0")||

  // oppure se 1° separatore non è carattere speciale

         !ValoreSeparatore(data.charAt(1)) ||

  // controllo se 2° e 3° carattere non sono numerici
         (!parseFloat(data.charAt(2)) && data.charAt(2) != "0") ||

         (!parseFloat(data.charAt(3)) && data.charAt(3) != "0") ||

  // oppure se 2° separatore non è carattere speciale
         !ValoreSeparatore(data.charAt(4)) ||

  // controllo se anno non è numerico
         !ValoreNumerico (anno))
         {
           dataFormattata = "**********";
         }
         else
         {
           if (anno.length == 2)  anno = CompletaAnno(anno);

           dataFormattata = "0";
           dataFormattata += data.substring(0,1);
           dataFormattata += "/";
           dataFormattata += data.substring(2,4);
           dataFormattata += "/";
           dataFormattata += anno;
         }
    return dataFormattata;
  }
  // ******    controllo data nel formato GGsMsAAAA GGsMsAA    ******

  function DataGGsMs(data) {
    var dataFormattata='';
    var anno = '';

   // formattazione anno

    if(data.length == 9)
    {
      anno = data.substring(5,9);
    }
    else
    {
  //    anno = secolo + data.substring(5,7);

      anno = data.substring(5,7);
    }

    if(((data.length != 9) && (data.length != 7)) ||

  // controllo se 1° carattere non è numerico
       (!parseFloat(data.charAt(0)) && data.charAt(0) != "0")||

  // controllo se 2° carattere non è numerico
         (!parseFloat(data.charAt(1)) && data.charAt(1) != "0") ||

  // oppure se 1° separatore non è carattere speciale

         !ValoreSeparatore(data.charAt(2)) ||

  // controllo se 3° carattere non è numerico

         (!parseFloat(data.charAt(3)) && data.charAt(3) != "0") ||

  // oppure se 2° separatore non è carattere speciale
         !ValoreSeparatore(data.charAt(4)) ||

  // controllo se anno non è numerico
         !ValoreNumerico (anno))
         {
           dataFormattata = "**********";
         }
         else
         {
           if (anno.length == 2)  anno = CompletaAnno(anno);
           dataFormattata += data.substring(0,2);
           dataFormattata += "/";
           dataFormattata += "0";
           dataFormattata += data.substring(3,4);
           dataFormattata += "/";
           dataFormattata += anno;
         }
    return dataFormattata;
  }


  // ******    controllo data nel formato GGsMMsAAAA GGsMMsAA    ******

  function DataGGsMMs(data) {
    var errors='',dataFormattata='';
    var mese=data.substring(3,5);
    var giorno=data.substring(0,2);

    var anno = '';

   // formattazione anno

    if(data.length == 10)
    {
      anno = data.substring(6,10);
    }
    else
    {
      anno = data.substring(6,8);
    }

    if(((data.length != 10) && (data.length != 8)) ||

  // controllo se giorno non è numerico
       !ValoreNumerico (giorno) ||

  // oppure se 1° separatore non è carattere speciale

         !ValoreSeparatore(data.charAt(2)) ||

  // controllo se 2° carattere non è numerico
         !ValoreNumerico (mese) ||

  // oppure se 2° separatore non è carattere speciale
         !ValoreSeparatore(data.charAt(5)) ||

  // controllo se anno non è numerico
         !ValoreNumerico (anno))
         {
           dataFormattata = "**********";
         }
         else
         {
           if (anno.length == 2)  anno = CompletaAnno(anno);

           dataFormattata = giorno;
           dataFormattata += "/";
           dataFormattata += mese;
           dataFormattata += "/";
           dataFormattata += anno;
         }
    return dataFormattata;
  }
  // ******    controllo data nel formato GGMMAAAA GGMMAA    ******

  function DataGGMM(data) {
    var errors='',dataFormattata='';
    var giorno=data.substring(0,2);
    var mese=data.substring(2,4);

    var anno = '';

   // formattazione anno

    if(data.length == 8)
    {
      anno = data.substring(4,8);
    }
    else
    {
      anno = data.substring(4,6);
    }
    if(((data.length != 8) && (data.length != 6)) ||
  // controllo se giorno carattere non è numerico
      !ValoreNumerico (giorno) ||

  // controllo se 2° carattere non è numerico
         !ValoreNumerico (mese) ||

  // controllo se anno non è numerico
         !ValoreNumerico (anno))
         {
           dataFormattata = "**********";
         }
         else
         {
           if (anno.length == 2)  anno = CompletaAnno(anno);

           dataFormattata = giorno;
           dataFormattata += "/";
           dataFormattata += mese;
           dataFormattata += "/";
           dataFormattata += anno;
         }
    return dataFormattata;
  }

  // ******    controllo separatore carattere speciale    ******

  function ValoreSeparatore (DatoImmesso) { //
    esito=true;
  //verifica che separatore sia un carattere speciale

       if ((parseFloat(DatoImmesso) || DatoImmesso == "0")
          || (DatoImmesso >= "a" && DatoImmesso <= "z")
          || (DatoImmesso >= "A" && DatoImmesso <= "Z"))
       {
         esito = false;
       }
  return esito;
  }

  //******   aggiunge il secolo  ******
  function CompletaAnno (DatoImmesso) {

    if (eval(DatoImmesso) < eval(AnnoDiscriminante))
      anno = 20 + DatoImmesso;
    else
      anno = 19 + DatoImmesso;
    return anno;
  }

  function ValoreNumerico (DatoImmesso) {
    esito=true;

    for(var i=0;i<DatoImmesso.length;i++)
    {
      if((DatoImmesso.charAt(i) != "0") &&
          isNaN(DatoImmesso.charAt(i)))
      {
        esito=false;
        break;
      }
    }
  return esito;
  }
  function ControlliLogici(data) {
    var errors='';
    var giorno=data.substring(0,2);
    var mese=data.substring(3,5);
    var anno=data.substring(6,10);

  //  controlli validità giorno compreso tra 1 e 31
          if (eval(giorno)<1 || eval(giorno)>31)
          {
            errors = Msg2;    // + " : " + giorno;
          }
          else
          {
            if ((eval(giorno)>29 && eval(mese) == 2) ||

               (eval(giorno)== 31 && (eval(mese)== 4 || eval(mese)==6 ||
                                      eval(mese)== 9 || eval(mese)==11)))
            {
              errors = Msg3 + giorno + " giorni";
            }
          }
  //  controlli validità  mese
          if (eval(mese)<1 || eval(mese)>12)
          {
            errors = Msg4;    // + " : " + mese;
          }
  //  controlli anno
          var temp = parseInt(anno/4);
          if (mese == 2 && giorno == 29 && (anno/4) != temp)
          {
            errors = Msg5 + " : " + anno;
          }
  //  controlli validità anno
          if (anno.length < 4)
          {
            errors = Msg6 + " : " + anno;
          }
          if (eval(anno)<AnnoMinimo || eval(anno)>AnnoMassimo)
          {
            errors = Msg7;
          }
  return errors;
  }

  //  End  /////////////////////////////////////////////////////////////////

  ////////////////////////////////////////////////////////////////////////
  ///// Controllo validità campo importo dopo la digitazione
  /////////////////////////////////////////////////////////////////////////
  function controllaImporto(stringa, dec, lungh, s, sistema) {
      var verify = true;
      var importo = stringa;
      var quanteVirgola = 0;
      var quantiSegno = 0;
      var parteIntera = "";
      var PIU = '+';
      var MENO = '-';
      var MSG;
      var MSG1 ="Troppi decimali";
      var MSG2 ="Troppi caratteri di separazione parte intera - parte decimale";
      var MSG3 ="Caratteri non ammessi";
      var MSG4 ="Separatore delle migliaia in posizione errata";
      var MSG5 ="Decimali non consentiti";
      var MSG6 ="Troppi caratteri segno";
      var MSG7 ="Troppi interi";

      setParametri(dec, lungh, s, sistema);

      if ( !(stringaAmmessa(importo, NUMERI + PUNTO + VIRGOLA + PIU + MENO)) )
      {
          verify = false;
          MSG = MSG3;
      }

      for (var i=0; i < importo.length; i++)
          if (importo.charAt(i) == VIRGOLA)
              quanteVirgola = quanteVirgola + 1;

  //    if (segno == "N")
  //        PIU = MENO = '';

      for (var i=0; i < importo.length; i++)
          if (importo.charAt(i) == PIU || importo.charAt(i) == MENO)
              quantiSegno = quantiSegno + 1;

  //troppi segno
      if (verify && (quantiSegno > 1) )
      {
          verify = false;
          MSG = MSG6;
      }
  //il segno è presente
      if (verify && ( quantiSegno == 1 ) )
      {
  //il segno è presente ed è richiesto
          if (segno == "S")
          {
  //il segno non è in posizione corretta (a dx)
              if ( importo.charAt(importo.length - 1) != PIU &&
                   importo.charAt(importo.length - 1) != MENO   )
              {
                  verify = false;
                  MSG = MSG3;
              }
  //il segno è in posizione corretta (a dx)
              else
                  importo = importo.substring(0, importo.length - 1)
          }
  //il segno è presente e non è richiesto
          else
          {
              verify = false;
              MSG = MSG3;
          }
      }


      //se non c'e' nessuna virgola non esiste la parte decimale
      if (verify && (quanteVirgola == 0) )
      {
          parteIntera = importo;
          //La parte intera deve contenere solo numeri e il punto (separatore migliaia)
          if ( !(stringaAmmessa(parteIntera, NUMERI + PUNTO + PIU + MENO)) )
          {
              verify = false;
              MSG = MSG3;
          }
      }
      //se c'e' una virgola viene divisa la parte intera da quella decimale e
      //vengono fatti i controlli su quest'ultima
      else
      {
          if (verify && (quanteVirgola == 1) )
          {
      // controllo se sono consentiti i decimali
              if (decimali == 0)
              {
                  verify = false;
                  MSG = MSG5;
              }
              else
              {
                  parteIntera = importo.substring(0,importo.indexOf(VIRGOLA));
                  var dec = importo.substring(importo.indexOf(VIRGOLA) + 1);

                  // la parte decimale deve contenere solo numeri e forse il segno
                  if ( (!(stringaAmmessa(dec, NUMERI + PIU + MENO))) )
                  {
                      verify = false;
                      MSG = MSG3;
                  }

                  // la parte decimale deve essere al max lunga 'decimali'
                  if ( (dec.length > decimali) || (dec.length == 0))
                  {
                      MSG = MSG1;
                      verify = false;
                  }
              }
          }
          //se c'e' piu' di una virgola l'importo non e' corretto
          else
              if (verify)
              {
                  MSG = MSG2;
                  verify = false;
              }
      }

      if (verify && (parteIntera.length > lmax - decimali))
      {
          MSG = MSG7;
          verify = false;
      }

      if (PUNTO == '.')
          var carPunto = /\./;
      else
          var carPunto = /\,/;
      //se nella parte intera c'e' almeno un punto, viene controllato che questi caratteri
      //siano in posizione corretta
      if ((verify) && (parteIntera.search(carPunto) != -1))
      {
          var j = 4; var i = parteIntera.length;
          //Il carattere punto deve essere nelle posizioni multiple di 4,
          //partendo dalla cifra piu' a destra, quindi viene eseguito un controllo
          //per posizioni multiple di 4
          do
          {
              i = i - j;
              //il carattere nella posizione i deve essere un punto mentre i caratteri
              //piu' a destra, cioe' nelle posizioni i+1, i+2, i+3, devono essere diverse dal punto
              if (parteIntera.charAt(i) != PUNTO)
              {
                  verify = false;
                  MSG = MSG4;
              }
              for (var c=1; c < j; c++)
              {
                  if (parteIntera.charAt(i + c) == PUNTO)
                  verify = false;
                  MSG = MSG4;
              }
          }
          while (i >= j);
      }

      if (!verify)
      {
  //        alert("L'importo \'" + importo + "\' non è corretto ");
          alert(MSG + ": " + importo);
          return false;
      }
      return true;
  }
  //  End  /////////////////////////////////////////////////////////////////
  function eliminaVirgola(stringa)
{
  stringa = stringa.replace(VIRGOLA,'');
  //stringa = stringa.replace(PUNTO,'');
  return stringa;
}
  ////////////////////////////////////////////////////////////////////////
  // Restituisce 'true' se la stringa 'input' contiene solo caratteri
  // compresi nella stringa <caratteriAmmessi>. Usata per i campi che accettano
  // solo un certo insieme di caratteri.
  /////////////////////////////////////////////////////////////////////////
  function stringaAmmessa(input, caratteriAmmessi) {
      var ok = true;
      var chr = null;
      var i = 0;

      for (i=0; (i<input.length) && (ok); i++)
      {
          chr = input.charAt(i);
          ok = (caratteriAmmessi.indexOf(chr,0) != -1);
      }
      return ok;
  }
  ////////////////////////////////////////////////////////////////////////
  // Restituisce la stringa senza gli eventuali spazi in coda
  ////////////////////////////////////////////////////////////////////////
  	function rTrim(strToTrim) {
		return (new String(strToTrim).replace(/\s*$/g,""));
	}
  ////////////////////////////////////////////////////////////////////////
  // Restituisce la stringa senza gli eventuali spazi all'inizio
  /////////////////////////////////////////////////////////////////////////
	function lTrim(strToTrim) {
		return (new String(strToTrim).replace(/^\s*/g,""));
	}
  ////////////////////////////////////////////////////////////////////////
  // Restituisce la stringa senza gli eventuali spazi all'inizio e in coda
  /////////////////////////////////////////////////////////////////////////
	function Trim(strToTrim) {
		return (new String(new String(strToTrim).replace(/\s*$/g,"")).replace(/^\s*/g,""));
	}

	/*formatta una stringa numerica sostituendo la virgola decimale con il punto
	  per consentirne le operazioni matematiche in Javascript,
	  Restituisce un Array contenente come 1° elemento il dato formattato con il punto decimale
	  ed come 2°  il dato con la formattazione del client (per ora è fissata la virgola decimale)
	*/
	function formattaNum(numero, decimali) {
		var arrNumFormatted = new Array();
		var strAppoEng = "";
		var strAppoIta = "";
		var parteIntera = "";
		var parteDecimale = "";
		var zeriDaAggiungere = 0;
		var numeroApp = new String(numero.valueOf());
		var numeroStrEng = new String(numero.valueOf());
		var numeroStrIta = new String(numero.valueOf());
		var numFormatted = new Number();
		//cerco l'indice con cui compaiono la virgola e il punto nella stringa
		punti = numeroApp.search(regexpPoint);
		virgole = numeroApp.search(regexpComma);
		numeroApp = numeroApp.replace(regexpPoint,"");
		numeroApp = numeroApp.replace(regexpComma,"");

		if (isNaN(numeroApp)) {
			window.alert("Il valore inserito non è valido");

			numeroStrEng = "0.";
			numeroStrIta = "0,";
			zeriDaAggiungere = decimali.valueOf();
			for (i=0; i<zeriDaAggiungere; i++) {
				strAppoEng += "0";
				strAppoIta += "0";
			}
			numeroStrEng += strAppoEng;
			numeroStrIta += strAppoIta;
			numFormatted = numeroStrEng;
			arrNumFormatted[0] = numFormatted;
			arrNumFormatted[1] = numeroStrIta;
			return arrNumFormatted;
		}
		else if (punti > -1 && virgole > -1) {
			/*ci sono sia punti che virgole per decidere qual'è il separatore decimale
			verifico quale è più a destra*/
			if (virgole > punti) {
				numeroStrEng = numeroStrEng.replace(regexpPoint,"");
				numeroStrEng = numeroStrEng.replace(regexpComma,".");
				//da implementare!!!! considero solo un punto separatore di migliaia
				parteIntera = numeroStrEng.substr(0, virgole-1);
				parteDecimale = numeroStrEng.substr(virgole, numeroStrEng.length);
			} else {
				numeroStrEng = numeroStrEng.replace(regexpComma,"");
				//da implementare!!!! considero solo una virgola separatore di migliaia
				parteIntera = numeroStrEng.substr(0, punti-1);
				parteDecimale = numeroStrEng.substr(punti, numeroStrEng.length);
			}
		} else if ((virgole > -1) || (punti > -1)) {
			// i due tipi di separatori non sono presenti contemporaneamente
			//o c'è la virgola o il punto
				if (virgole > -1) {
					if (virgole == 0) {
						parteIntera = 0;
					} else {
						parteIntera = numeroStrEng.substr(0, virgole);
					}
					parteDecimale = numeroStrEng.substr(virgole+1, numeroStrEng.length);
				} else {
					if (punti == 0) {
						parteIntera = 0;
					} else {
						parteIntera = numeroStrEng.substr(0, punti);
					}
					parteDecimale = numeroStrEng.substr(punti+1, numeroStrEng.length);
				}
		} else if ((virgole == -1) || (punti == -1)) {
			//non ci sono separatori
			parteIntera = numeroStrEng;
			parteDecimale = "";
		}

		if (parteDecimale.length < decimali.valueOf()) {
			//la parte decimale è più corta di quella richiesta -> aggiungo zeri in fondo
			zeriDaAggiungere = decimali.valueOf() - parteDecimale.length;
			numeroStrEng = parteIntera + "."  + parteDecimale;
			numeroStrIta = parteIntera + ","  + parteDecimale;
			for (i=0; i<zeriDaAggiungere; i++) {
				strAppoEng += "0";
				strAppoIta += "0";
			}
			numeroStrEng += strAppoEng;
			numeroStrIta += strAppoIta;
		} else if (parteDecimale.length > decimali.valueOf()) {
			//la parte decimale è più lunga di quella richiesta -> tolgo zeri in fondo
			parteDecimale = parteDecimale.substr(0, decimali.valueOf());
			numeroStrEng = parteIntera + "."  + parteDecimale;
			numeroStrIta = parteIntera + ","  + parteDecimale;
		} else {
			// OK
			numeroStrEng = parteIntera + "."  + parteDecimale;
			numeroStrIta = parteIntera + ","  + parteDecimale;
		}
		numFormatted = numeroStrEng;
		arrNumFormatted[0] = numFormatted;
		arrNumFormatted[1] = numeroStrIta;
		return arrNumFormatted;
	}

function fnum(num,dig) {
var numFormattato;
 var strFormattato;
 var posVirgola;
 var lenStrFormattato
 var digSignificativi
 var digDaAggiungere;
 var regexpPoint = /\./g;
 numFormattato = ((Math.round(num * Math.pow(10,dig))) / Math.pow(10,dig));
 strFormattato = new String(numFormattato);
 strFormattato = strFormattato.replace(regexpPoint,",");
 lenStrFormattato = strFormattato.length
 posVirgola = strFormattato.search(",");
 if (posVirgola == -1) {
	 posVirgola = lenStrFormattato - 1
 }
 digSignificativi = lenStrFormattato - (posVirgola +1)
 digDaAggiungere = dig - digSignificativi
 if (posVirgola == lenStrFormattato - 1) {
	strFormattato += ",";
 }
	for (i=0; i<digDaAggiungere; i++) {
		strFormattato += "0";
	}
 return strFormattato
}

function checkAlfa(Campo) {
	if (stringaAmmessa(Campo.value, SetCaratteriAmmessi)) {
		Campo.value = Trim(new String(Campo.value)).toUpperCase();
	} else {
		alert("Sono stati immessi uno o più caratteri non ammessi.");
		Campo.value = '';
	}
}

function riempiZeriSX(Campo, lunghezza) {
	if (stringaAmmessa(Campo.value, SetCaratteriAmmessi)) {
		while (Campo.value.length < lunghezza && Campo.value.length > 0) {
			Campo.value = '0'+ Campo.value.toString();
		}
	} else {
		alert("Sono stati immessi uno o più caratteri non ammessi.");
		Campo.value = '';
	}
}

function presentaAVideoSenzaDec(stringa, dec, lungh, s, sistema) {//04032005
    setParametri(dec, lungh, s, sistema);

    stringaSeparata = new Array(3);
    stringaSeparata = separaStringa(stringa);
    parteIntera = stringaSeparata[0];
    parteDecimale = stringaSeparata[1];
    parteSegno = stringaSeparata[2];

    if (parteIntera.length == 0)
        parteIntera = "0";	
		//2007
	if (parteSegno == "+"){
		 return puntina(parteIntera) ;
	}else{
		 return parteSegno +   puntina(parteIntera)  ;
	}
	// fine 2007
   
  }
  //  End  /////////////////////////////////////////////////////////////////
  
  function CheckInputNum() {
	// controlla la digitazione di soli campi numerici
		var CodicetastoPremuto = window.event.keyCode;
		if ((CodicetastoPremuto >= 48 && CodicetastoPremuto <= 57) || (CodicetastoPremuto == 46) || (CodicetastoPremuto >= 96 && CodicetastoPremuto <= 106) || (CodicetastoPremuto == 8) || (CodicetastoPremuto == 9))  /* 0-9 */
			{
				event.returnValue = true;
			} else {
				event.returnValue = false;
		}
	}
	function spuntinaESvirgola(stringa, dec, lungh, s, sistema)
{
	var szOutput = spuntina(stringa, dec, lungh, s, sistema);
	return svirgola(szOutput);
}
function trattaNegativi(valore){
		var stringaOutput = "";
		var escludiSegno = new String(valore).substring(1,new String(valore).length);
		if (escludiSegno.length > Number(3))	{
			stringaOutput = "-" + puntina(new String(escludiSegno));
		}else{
			stringaOutput = valore;
		}
		return stringaOutput;
}
function paddingLeft(str,len,char)
// padding a sinistra 
	{
		var howMany=len-new String(str).length;
		var retStr="";
		for (var p=0;p<howMany;p++) retStr+=char;
		return retStr+str;
	}
function restituisciTroncamento(valore,sistemaInUso){
		var stringaOutput;
		if (sistemaInUso != "ENG"){
			var posDec = new String(valore).indexOf(",");
		}else{
			var posDec = new String(valore).indexOf(".");
		}
		
		if (posDec != "-1"){
			var stringaDecimali = new String(valore).substring(posDec+1, new String(valore).length);	
			
			if (stringaDecimali.length > 1){
				var sottoStringa = valore.substring(posDec+1,posDec+3);
				
				stringaOutput = valore.substring(0,posDec+1) + 	sottoStringa;

			}else{
				stringaOutput = valore;
			}
		}else{
			stringaOutput = valore;
		}
		
		return stringaOutput;
	}
	function trattaNegativiConDecimali(valore,sistemaInUso){
		var stringaOutput;
		if (sistemaInUso != "ENG"){
			var posDec = new String(valore).indexOf(",");
		}else{
			var posDec = new String(valore).indexOf(".");
		}
		if (posDec != "-1"){
			var stringaNegativi = new String(valore).substring(1, posDec);	
				alert(stringaNegativi);
				var sottoStringa = valore.substring(posDec+1,posDec+3);
				alert(sottoStringa);
				stringaOutput = "-" + valore.substring(0,posDec+1) + sottoStringa ;
				alert(stringaOutput)
		}else{
			stringaOutput = valore;
		}
		
		return stringaOutput;
	}
	
	
/// <summary>Apre la popup che visualizza la scheda prodotto</summary>
function fApriPopupProdotto(codiceMarketing)
{
  var popupURL  =   "App_Pages/Loading.asp?FUNCTION_TO_LOAD=SchedaProdottoViewer";
  popupURL      +=  "&CM="+codiceMarketing;
  popupURL      +=  "&LoadingPage_Title=Caricamento scheda prodotto";
  popupURL      +=  "&LoadingPage_SubTitle=Recupero nome documento in corso";

  var popupProdotto = window.open(popupURL,
  "SchedaProdotto", 
  "toolbar=no,button=no,scrollbars=yes,resizable=no,width=750,height=450"
  );
  
  popupProdotto.focus();
}

//AJAX
var MAXIMUM_WAITING_TIME = 2000;
function createRequestObject() {
   try { return new ActiveXObject("Msxml2.XMLHTTP"); } catch (e) {}
   try { return new ActiveXObject("Microsoft.XMLHTTP"); } catch (e) {}
   try { return new XMLHttpRequest(); } catch(e) {}
   alert("XMLHttpRequest non supportato");
   return null;
 }

 /*
function createRequestObject() 
{
  var xmlhttp;
  try 
  { 
    xmlhttp=new ActiveXObject("Msxml2.XMLHTTP"); 
  }
  catch(e) 
  {
    try { xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");}
    catch(f) { xmlhttp=null; }
  }
  if(!xmlhttp&&typeof XMLHttpRequest!="undefined") 
  {
    xmlhttp=new XMLHttpRequest();
  }
  return  xmlhttp;
}
*/
/// <summary>
/// Pulisce un oggetto INPUT di tipo TEXT da caratteri considerati non validi,
/// quelli validi sono indicati nella variabile interna pCaratteriValidi.
/// Da utilizzare negli eventi onchange e onkeyup dell'oggetto INPUT:
/// onchange="javascript:pulisciCaratteriInputText(this);" onkeyup="javascript:pulisciCaratteriInputText(this);" 
/// <summary>
function pulisciCaratteriInputText(obj)
{
  var retVal = '';
  var currentChar = '';
  var pCaratteriValidi = "ABCDEFGHILMNOPQRSTUVZWYJKXabcdefghilmnopqrstuvzwyjkx0123456789-";
  
  for(var i = 0; i<=obj.value.length-1; i++)
  {
    currentChar = obj.value.charAt(i);
    if(pCaratteriValidi.indexOf(currentChar.toString())>-1)
    {
      retVal += obj.value.charAt(i);
    }
  }
  obj.value=retVal;
}
/// <summary>
/// Tornano le dimensioni delle finestre di popup per posizionamento ottimale dei pannelli 
/// <summary>
function getWinWidth() {
 var winW = screen.width;
 if (parseInt(navigator.appVersion)>3) {
  if (navigator.appName=="Netscape") {
   winW = window.innerWidth;
  }
  if (navigator.appName.indexOf("Microsoft")!=-1) {
   winW = document.body.offsetWidth;
  }
 }
 return winW;
}
function getWinHeight() {
 var winH = screen.height;
 if (parseInt(navigator.appVersion)>3) {
  if (navigator.appName=="Netscape") {
   winH = window.innerHeight;
  }
  if (navigator.appName.indexOf("Microsoft")!=-1) {
   winH = document.body.offsetHeight;
  }
 }
 return winH;
}

function creaRitornoACapo(stringaInput, numeroBlank){
		// funzione che determina il ritorno a capo di una stringa
		// in base al punto di rottura deciso
		// in questo caso--> il blank 
		// ad es.2 --> se incontro il secondo blank determino la rottura
		var posizioneOutput = "";
		var controlloCarattere = "no";
		var stringaInputAppo = new String(stringaInput).toString();		
		var lunghezzaStringa = stringaInputAppo.length;		
		var blankAppo = 0;
		for (indice = 0;indice < lunghezzaStringa;indice++){
			var carattere = stringaInputAppo.charAt(indice);				
			if (controlloCarattere == "no"){			
				if (carattere == " "){
					blankAppo++;					
					if (blankAppo == numeroBlank){																
						controlloCarattere = "si";
						posizioneOutput=indice;						
					}
						
				}		
			}
		}
		return posizioneOutput ;
		
	}