var  rightPanelVisible = true;

function openRightPanel(){
	document.getElementById("rightPanel_top").style.display = (rightPanelVisible)?'none':'block';
	document.getElementById("rightPanel_middle").style.display = (rightPanelVisible)?'none':'block';
	imgSrc = "rightPanel_" + (rightPanelVisible? "show" : "hide") + ".gif";
	MM_swapImage('rightPanelImg','','img/'+imgSrc,1);
	rightPanelVisible = !rightPanelVisible;
}


function openCustomPopup(param,width,height) {
  
b=window.open(param,'popup','width=' + width + ',height=' + height + ',menubar=no,resizable=yes,top=70,left=250,scrollbars=0,status=no,titlebar=no,toolbar=no,location=no,menubar=no,status=no');
b.focus();

}



function MM_preloadImages() { //v3.0
  var d=document; if(d.images){ if(!d.MM_p) d.MM_p=new Array();
    var i,j=d.MM_p.length,a=MM_preloadImages.arguments; for(i=0; i<a.length; i++)
    if (a[i].indexOf("#")!=0){ d.MM_p[j]=new Image; d.MM_p[j++].src=a[i];}}
}

function MM_swapImgRestore() { //v3.0
  var i,x,a=document.MM_sr; for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) x.src=x.oSrc;
}

function MM_swapImage() { //v3.0
  var i,j=0,x,a=MM_swapImage.arguments; document.MM_sr=new Array; for(i=0;i<(a.length-2);i+=3)
   if ((x=MM_findObj(a[i]))!=null){document.MM_sr[j++]=x; if(!x.oSrc) x.oSrc=x.src; x.src=a[i+2];}
}

function ActivateDiv(numId) {

		for(i=1;i<4;i++){
		
			//MM_findObj('area_'+i).style.display = (i==numId)?'block':'none';
			//alert(MM_findObj('ling_'+i).className);
			if (i==numId){
			
				MM_findObj('area_'+i).style.display='block';
				//swapStyle(MM_findObj('ling_'+i).className,1)
				MM_findObj('ling_'+i).className=swapStyle(MM_findObj('ling_'+i).className,1);
				//MM_findObj('ling_'+i).className=(MM_findObj('ling_'+i).className)+'Act';
			}else{
			//alert(i+"a");
				MM_findObj('area_'+i).style.display='none';
				//alert(i+"b");
				MM_findObj('ling_'+i).className=swapStyle(MM_findObj('ling_'+i).className,0);
				//MM_findObj('ling_'+i).className.lenght
				//alert(i+"c");
			}
		}
	}

function swapStyle(aTabStyle,state){
	if (state){
		//alert(aTabStyle+"toACT");
		aaa=aTabStyle.length;
		tabroot=aTabStyle.substring(0,aaa-1);
		return tabroot+"1";
	}else{
		bbb=aTabStyle.length;
		tabroot=aTabStyle.substring(0,bbb-1);
		return tabroot+"0";
	}
}

function change_iframe_content(par){
	var valId= (par.value);
	//var cal='calendar_'+valId+'.htm';

	MM_findObj('myiframe').src = 'calendar_'+valId+'.htm';
}

function MM_findObj(n, d) { //v4.01
  var p,i,x;  if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {
    d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
  if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
  for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document);
  if(!x && d.getElementById) x=d.getElementById(n); return x;
}

function MM_reloadPage(init) {  //reloads the window if Nav4 resized
  if (init==true) with (navigator) {if ((appName=="Netscape")&&(parseInt(appVersion)==4)) {
    document.MM_pgW=innerWidth; document.MM_pgH=innerHeight; onresize=MM_reloadPage; }}
  else if (innerWidth!=document.MM_pgW || innerHeight!=document.MM_pgH) location.reload();
}
MM_reloadPage(true);

function MM_openBrWindow(theURL,winName,features) { //v2.0
  window.open(theURL,winName,features);
}

/* Controlla le caratteristiche di una stringa */
//public class RGIString extends Applet
//{

function RGIString()
{
    // proprietà
    this._string = "";
    
    // metodi
    this.IsValidFromTo      = _IsValidFromTo;
    this.IsValid            = _IsValid;
    this.IsAlphabeticFromTo = _IsAlphabeticFromTo;
    this.IsAlphabetic       = _IsAlphabetic;
    this.IsNumericFromTo    = _IsNumericFromTo;
    this.IsNumeric          = _IsNumeric;
    this.AreDigitsFromTo    = _AreDigitsFromTo;
    this.AreDigits          = _AreDigits;
    this.SetString          = _SetString;
    this.GetString          = _GetString;
}

/* Verifica che la gestita stringa sia valida rispetto ad una maschera passata */
// int nFrom, int nTo, String strMask
function _IsValidFromTo(nFrom, nTo, strMask)
{
    // Cicla sui caratteri da analizzare 
    for(var i = nFrom; i < nTo; i++)
    {
        var ch = this._string.charAt(i);
        // Verifica se il carattere è contenuto nella stringa 
        if (strMask.indexOf( ch ) == -1)
			return false;
    }

    return true;
}



/* Come IsValid, su tutta la stringa */
//String strMask
function _IsValid(strMask)
{
    return this.IsValidFromTo(0, this._string.length, strMask);
}

/* Verifica che la stringa sia composta di sole lettere */
// int nFrom, int nTo
function _IsAlphabeticFromTo(nFrom, nTo)
{
    return this.IsValidFromTo(nFrom, nTo, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
}

/* Come IsAlphabetic, su tutta la stringa */
function _IsAlphabetic()
{
    return this.IsAlphabeticFromTo(0, this._string.length);
}

/* Verifica che la stringa sia composta solo di numeri, . e segni */
// int nFrom, int nTo
function _IsNumericFromTo(nFrom, nTo)
{
    return this.IsValidFromTo(nFrom, nTo, "1234567890+-.");
}

/* Come IsNumeric, su tutta la stringa */
function _IsNumeric()
{
    return this.IsNumericFromTo(0, this._string.length);
}

/* Imposta la stringa da utilizzare */
// String strIn
function _GetString()
{
	return this._string;
}

/* Imposta la stringa da utilizzare */
// String strIn
function _SetString(strIn)
{
    this._string = strIn;
}


/* Verifica che la stringa sia composta solo di numeri */
// int nFrom, int nTo
function _AreDigitsFromTo(nFrom, nTo)
{
    return this.IsValidFromTo(nFrom, nTo, "1234567890");
}

/* Come AreDigits, su tutta la stringa */
function _AreDigits()
{
    return this.AreDigitsFromTo(0, this._string.length);
}

//public class RGIDate extends Applet
//Richiede l'inclusione di RGIString.js

    // Costanti
    var ARROTONDAMENTO_PER_DIFETTO  = "0";
    var ARROTONDAMENTO_GIUSTO       = "1";
    var ARROTONDAMENTO_PER_ECCESSO  = "2";
    var INTERNAL_ARROTONDAMENTO_PER_DIFETTO = 0;
    var INTERNAL_ARROTONDAMENTO_GIUSTO      = 1;
    var INTERNAL_ARROTONDAMENTO_PER_ECCESSO = 2;

    //var MILLISECOND            = 14;
    var SECOND                 = 1000;
    var MINUTE                 = 60 * SECOND;
    var HOUR                   = 60 * MINUTE;
    var DAY                    = 24 * HOUR;
    var WEEK                   =  7 * DAY;
    var MONTH                  =  4 * WEEK;
    var YEAR                   = 12 * MONTH;
    
    
    // Costruttore di default
    function RGIDate()
    {
        this._date = new Date();
        
        // Metodi
        this.SubDaysFromDate = _SubDaysFromDate;
        this.SubDays         = _SubDays;
        this.AddDaysFromDate = _AddDaysFromDate;
        this.AddDays         = _AddDays;
        this.GetAsString     = _GetAsString;
        this.GetTimeAsString = _GetTimeAsString;
        this.GetYearsOfDifferenceFromThisDateGiornoMese = _GetYearsOfDifferenceFromThisDateGiornoMese;
        this.GetYearsOfDifferenceFromThisDate = _GetYearsOfDifferenceFromThisDate;
        this.SetDate         = _SetDate;
        this.SetFromString   = _SetFromString;
        this.AddYears        = _AddYears;
        this.GetYearsOfDifferenceFromTodayGiornoMese = _GetYearsOfDifferenceFromTodayGiornoMese;
        this.GetYearsOfDifferenceFromTodayConArrotondamento = _GetYearsOfDifferenceFromTodayConArrotondamento;
        this.GetYearsOfDifferenceFromToday = _GetYearsOfDifferenceFromToday;
    }


    // Recupera la data immagazzinata, in formato stringa
    function _GetAsString()
    {
        var data1 = new Date();
        data1.setTime(this._date.getTime());
        
        return DataToStringa( data1 );
    }
    
   
        // Recupera l'ora della data immagazzinata, in formato stringa
    function _GetTimeAsString()
    {
        var data1 = new Date();
        data1.setTime(this._date.getTime());
        
        var iOra     = data1.getHours();
        var iMinuti  = data1.getMinutes();
        var iSecondi = data1.getSeconds();
        var sTmp     = "";
        var sOra     = "";
        
        // Converte l'ora
        sTmp = "" + iOra;
        if(sTmp.length < 2)
            sTmp = "0" + sTmp;
        sOra = sTmp + ":";

        // Converte i minuti
        sTmp = "" + iMinuti;
        if(sTmp.length < 2)
            sTmp = "0" + sTmp;
        sOra = sOra + sTmp + ":";
        
        // Converte i secondi
        sTmp = "" + iSecondi;
        if(sTmp.length < 2)
            sTmp = "0" + sTmp;
        sOra = sOra + sTmp;
        
        return sOra;
    }
    

    // Toglie un certo numero di giorni (i) dalla data passata
    // Imposta la data corrente alla data passata
    // Date date, var i
    function _SubDaysFromDate(date, iGiorni)
    {
        var iOra = date.getHours();
        var iOffsetDate = date.getTimezoneOffset();
        this._date.setTime(date.getTime() - iGiorni * DAY );
        // Gestione dei passaggi a/da l'ora legale
        // 1. Verifica se è cambiata la distanza da UTC 
        // (il che avviene nei momenti di passaggio)
        var iDeltaUTC = this._date.getTimezoneOffset() - iOffsetDate;
        // Aggiunge il delta 
        this._date.setTime(this._date.getTime() + iDeltaUTC * MINUTE );
        
        // Reimposta l'ora per assicurarsi che venga gestita correttamente 
        // il 
        //this._date.setHours( iOra );
    }

    // Toglie un certo numero di giorni dalla data corrente
    // var i
    function _SubDays(iGiorni)
    {
        this.SubDaysFromDate(this._date, iGiorni);
    }

    // Aggiunge un certo numero di giorni alla data corrente
    function _AddDays(iGiorni)
    {
        this.SubDays(-iGiorni);
    }

    // Aggiunge un certo numero di giorni alla data corrente
    // e imposta la data corrente
    function _AddDaysFromDate(date, iGiorni)
    {
        return this.SubDaysFromDate(date, -iGiorni);
    }
    
    
    // Calcola gli anni di differenza tra la data corrente e quella passata
    // var sData, var sTipoArrotondamento, var sMeseConfrontoPerAttorotondamento, var sTipoArrotondamento
    function _GetYearsOfDifferenceFromThisDateGiornoMese(
                                              sData, 
                                              sTipoArrotondamento, 
                                              sMeseConfrontoPerAttorotondamento, 
                                              sGiornoConfrontoPerArrotondamento)
    {

        // Verifica che s contenga una data accettabile
        var flag = IsValid(sData);

        // Crea una data dalla stringa
        var data1;
        if(flag)
        {
            data1 = StringaToData(sData);
        }
        else
        {
            return 0;
        }

        // Azzera i campi ora, minuti, secondi della data
        data1.setHours(0);
        data1.setMinutes(0);
        data1.setSeconds(0);

        // Nuova data
        var iTipoArrotondamento = parseInt( sTipoArrotondamento, 10 );
        var iMeseConfronto = parseInt( sMeseConfrontoPerAttorotondamento, 10 );
        var iGiornoConfronto = parseInt( sGiornoConfrontoPerArrotondamento, 10 );
        
        var data2 = new Date()
            data2.setTime( this._date.getTime() );
            

        // Se la data corrente è successiva a quella passata
        // Inverte le date
        if(data2.getTime() > data1.getTime())
        {
            var dataTmp = new Date();
            dataTmp.setTime( data1.getTime()  );
            data1.setTime  ( data2.getTime()  );
            data2.setTime  ( dataTmp.getTime() );
        }

        // Calcola gli anni di differenza
        // Se < 100, aggiunge 1999
        var iAnniData2 = data2.getYear();
                      iAnniData2 += ( iAnniData2 < 100 ? 1900 : 0 );
        var iAnniDiff = data1.getYear() - iAnniData2;
        
        // imposta anche sulla data minore lo stesso anno
        data2.setYear( data1.getYear() );

        // Esegue gli arrotondamenti
        if( data2.getTime() > data1.getTime() )
        {
            // Se ora la data minore è maggiore di quella maggiore, aggiusta il conto
            switch (iTipoArrotondamento)
            {
                case INTERNAL_ARROTONDAMENTO_PER_DIFETTO: // '\0'
                    iAnniDiff--;
                    break;

                case INTERNAL_ARROTONDAMENTO_GIUSTO: // '\001'
                    var iMesiDiff = data2.getMonth() - data1.getMonth();
                    if(iMesiDiff < iMeseConfronto)
                        iAnniDiff--;
                    else if(iMesiDiff == iMeseConfronto)
                    {
                        // Il mese è al limite, controlla i giorni
                        // Copia il mese della data maggiore su quella minore per confrontare i giorni
                        data2.setMonth( data1.getMonth());
                        if(data2.getTime() > data1.getTime() )
                        {
                            var iGiorniDiff = data2.getDate() - data1.getDate();
                            if(iGiornoConfronto <= iGiornoConfronto)
                                iAnniDiff--;
                        }
                    }
                    break;
            }
        }
        else
        {
            switch (iTipoArrotondamento)
            {
                case INTERNAL_ARROTONDAMENTO_PER_DIFETTO: // '\0'
                default:
                    break;

                case INTERNAL_ARROTONDAMENTO_GIUSTO: // '\001'
                    // Controlla i mesi
                    var iMesiDiff = data1.getMonth() - data2.getMonth();
                    if(iMesiDiff > iMeseConfronto)
                    {
                        iAnniDiff++;
                        break;
                    }
                    
                    // Prosegue il controllo solo se MesiDiff = MesiConfronto
                    if(iMesiDiff != iMeseConfronto)
                        break;
                    
                    // Copia il mese della data maggiore su quella minore per confrontare i giorni
                    data2.setMonth(data1.getMonth());
                    if(!(data2.getTime() < data1.getTime()) )
                        break;
                
                    var iGiorniDiff = data1.getDate() - data2.getDate();
                    if(iGiorniDiff > iGiornoConfronto)
                        iAnniDiff++;
                    break;

                case INTERNAL_ARROTONDAMENTO_PER_ECCESSO: // '\002'
                    iAnniDiff++;
                    break;
            }
        }
        
        return iAnniDiff;
    }


    // var sData, var sTipoArrotondamento
    function _GetYearsOfDifferenceFromThisDate(sData, sTipoArrotondamento)
    {
        return this.GetYearsOfDifferenceFromThisDateGiornoMese(sData, sTipoArrotondamento, "6", "0");
    }



    // Carica la data in formato stringa nell'oggetto corrente
    function _SetFromString(sData)
    {
        var flag = IsValid(sData);
        if(flag)
        {
            var data1 = StringaToData( sData );
            this._date.setTime(data1.getTime());
        }
        return flag;
    }




    // Verifica se si tratta del venerdì prima di Pasqia
    /*function IsFridayBeforeEaster()
    {
        var flag  = false;
        var data1 = new Date();
        data1.setTime(this._date.getTime());
        //data1.getDate() == 2 && // ? Questo controllo cosa significa?
        if( (data1.getMonth() == 2 || data1.getMonth() == 3)
        )
        {
            // Crea la data del venerdì di pasqua
            var data2 = new Date();
            data2.setTime(this._date.getTime());
            var iAnno = data1.getYear() % 19;
            data2.setDate(  _thisEaster[iAnno][0]);
            data2.setMonth( _thisEaster[iAnno][1]);
            for(; data2.get(DAY_OF_WEEK) != 6; data2.add(DATE, 1));
            flag = data1.equals(data2);
        }
        return flag;
    }*/


    // Imposta la data contenuta nell'oggetto
    function _SetDate(data)
    {
        this._date.setTime(data.getTime());
    }

    
    // Aggiunge un certo numero di anni alla data corrente
    function _AddYears(iAnno)
    {
        var iAnnoCorrente = this._date.getYear();
            iAnnoCorrente += ( iAnnoCorrente < 1900 ? 1900 : 0 );
        this._date.setYear(iAnnoCorrente  + iAnno);
    }


    // Anni di differenza da oggi
    function _GetYearsOfDifferenceFromToday()
    {
        return this.GetYearsOfDifferenceFromTodayConArrotondamento(
            ARROTONDAMENTO_GIUSTO);
    }

    function _GetYearsOfDifferenceFromTodayConArrotondamento(sTipoArrotondamento)
    {
        return this.GetYearsOfDifferenceFromTodayGiornoMese(sTipoArrotondamento, "6", "0");
    }


    // Calcola la differenza
    function _GetYearsOfDifferenceFromTodayGiornoMese(
        sTipoArrotondamento, 
        sMeseConfrontoPerAttorotondamento, 
        sGiornoConfrontoPerArrotondamento)
    {
        // Oggi a mezzanotte
        var data1 = new Date();
        data1.setHours(0);
        data1.setMinutes(0);
        data1.setSeconds(0);
        
        return this.GetYearsOfDifferenceFromThisDateGiornoMese(
                                    DataToStringa( data1 ),
                                    sTipoArrotondamento, 
                                    sMeseConfrontoPerAttorotondamento, 
                                    sGiornoConfrontoPerArrotondamento)  
        
    }

    // Lunedì dopo pasqua?
    /*function IsMondayAfterEaster()
    {
        var flag = false;
        var data1 = new Date();
        data1.setTime(this._date);
        if(data1.getDate() == 2 && (data1.getMonth() == 2 || data1.getMonth() == 3))
        {
            var data2 = new Date();
            data2.setTime(this._date);
            var i = data1.getYear() % 19;
            data2.setDate( _thisEaster[i][0]);
            data2.setMonth( _thisEaster[i][1]);
            data2.add(DATE, 1);
            for(; data2.getMonth() != 1; data2.add(MONTH, 1));
            data2.add(DATE, 1);
            flag = data1.equals(data2);
        }
        return flag;
    }*/



    
    function GetDate()
    {
        return this._date;
    }


    /*
    function IsDateAfterToday(var s)
    {
        var flag = IsValid(s);
        var data1;
        if(flag)
        {
            var i = Integer.parseInt(s.substring(0, 2));
            var j = Integer.parseInt(s.substring(3, 5));
            var k = Integer.parseInt(s.substring(6, 10));
            data1 = new Date(k, j - 1, i);
        }
        else
        {
            return 0;
        }
        var data2 = new Date();
        var data12 = new Date(data2.getYear(), data2.getMonth(), data2.getDate());
        if(data1.after(data12))
            return 1;
        return !data1.before(data12) ? 3 : 2;
    }



    function MakeLavorativo()
    {
        var flag = false;
        var data1 = new Date();
        var data2 = new Date();
        while(!flag)
        {
            data1.setTime(this._date);
            data2.setTime(this._date);
            var i = data1.get(DAY_OF_WEEK);
            if(i != 1 && i != 7)
            {
                var j = 0;
                var flag1;
                for(flag1 = false; !flag1 && j < _thisFestivi.length; j++)
                {
                    var k = _thisFestivi[j][0];
                    var l = _thisFestivi[j][1];
                    data2.setDate( k);
                    data2.setMonth( l);
                    flag1 = data1.equals(data2);
                }

                if(!flag1 && !IsFridayBeforeEaster() && !IsMondayAfterEaster())
                    flag = true;
            }
            if(!flag)
                AddDays(1);
        }

    }

    private static final var _thisFestivi[][] = {
        {
            1, 0
        }, {
            6, 0
        }, {
            25, 3
        }, {
            1, 4
        }, {
            14, 7
        }, {
            15, 7
        }, {
            1, 10
        }, {
            8, 11
        }, {
            24, 11
        }, {
            25, 11
        }, {
            26, 11
        }
    };*/
    
    /*private static final var _thisEaster[][] = {
        {
            14, 3
        }, {
            3, 3
        }, {
            23, 2
        }, {
            11, 3
        }, {
            31, 2
        }, {
            18, 3
        }, {
            8, 3
        }, {
            28, 2
        }, {
            16, 3
        }, {
            5, 3
        }, {
            25, 2
        }, {
            13, 3
        }, {
            2, 3
        }, {
            22, 2
        }, {
            10, 3
        }, {
            30, 2
        }, {
            17, 3
        }, {
            7, 3
        }, {
            27, 2
        }
    };*/

    // Recupera la data immagazzinata, in formato stringa
    // Date data1
    function DataToStringa( data1 )
    {
        var iGiorno = data1.getDate();
        var iMese   = data1.getMonth();
        var iAnno   = data1.getYear();
        var sTmp    = "";
        var sData   = "";
        
        // Converte il giorno
        sTmp = "" + iGiorno;
        if(sTmp.length < 2)
            sTmp = "0" + sTmp;
        sData = sTmp + "/";

        // Converte il mese
        sTmp = "" + (iMese + 1);
        if(sTmp.length < 2)
            sTmp = "0" + sTmp;
        sData = sData + sTmp + "/";
        
        // Converte l'anno - gestisce il caso (Mozilla, Opera) in cui l'anno ha valore 106 se > di 2000
        sData = sData + (iAnno < 1900 ? 1900 + iAnno : iAnno);
        
        return sData;
    }

    // Verifica che la stringa passata sia una data
    function IsValid(s)
    {
        var flag = false;

        // accetta il formato gg/mm/aaaa
        if(s.length == 10)
        {
            var rgistring = new RGIString();
            rgistring.SetString(s);
            // I primi due caratteri (gg) devono essere numeri
            flag = rgistring.AreDigitsFromTo(0, 2);

            // Poi ci deve essere un / o un -
            if (flag)
                flag = rgistring.IsValidFromTo(2, 3, "/-");

            // Poi due caratteri (mm) che devono essere numeri
            if(flag)
                flag = rgistring.AreDigitsFromTo(3, 5);

            // Poi ci deve essere un / o un -
            if(flag)
                flag = rgistring.IsValidFromTo(5, 6, "/-");

            // Poi quattro caratteri (aaaa) che devono essere numeri
            if(flag)
                flag = rgistring.AreDigitsFromTo(6, 10);

            // Ora prova a costruire la data
            if(flag)
            {
                flag = false;

                // Inizia con il mese
                var mese = parseInt(rgistring.GetString().substring(3, 5), 10);

                // Se ha un valore corretto per il mese
                if(mese > 0 && mese < 13)
                {
                    // Estrae giorno e anno
                    var giorno = parseInt(rgistring.GetString().substring(0, 2), 10);
                    var anno   = parseInt(rgistring.GetString().substring(6, 10), 10);

                    // Anno deve essere accettabile
                    if (anno > 1899)
                    {
                        // Crea la data
                        // Il mese è sbagliato. Bisogna togliere 1
                        var data = new Date(anno, mese-1, 1);

                        // Individua l'ultimo giorno del mese
                        if (giorno > 0)
                        {
                            var ultimoGiorno;
                            switch (mese)
                            {
                                // Febbraio - Anno Bisestile?
                                case 2: // '\002'
                                        if(IsLeapYear(anno))
                                            ultimoGiorno = 29;
                                        else
                                            ultimoGiorno = 28;
                                        break;

                                case 4: // '\004'
                                case 6: // '\006'
                                case 9: // '\t'
                                case 11: // '\013'
                                        ultimoGiorno = 30;
                                        break;

                                default:
                                        ultimoGiorno = 31;
                                        break;

                            }
                            // Verifica il giorno rispetto all'ultimo giorno del mese
                            if (giorno <= ultimoGiorno)
                                flag = true;
                        }
                    }
                }
            }
        } else {
        
		// accetta il formato ggmmaaaa
		 if(s.length == 8)
		 {
		     var rgistring = new RGIString();
		     rgistring.SetString(s);
		     // I primi due caratteri (gg) devono essere numeri
		     flag = rgistring.AreDigitsFromTo(0, 2);

		     // Poi due caratteri (mm) che devono essere numeri
		     if(flag)
		         flag = rgistring.AreDigitsFromTo(2, 4);

		     // Poi quattro caratteri (aaaa) che devono essere numeri
		     if(flag)
		         flag = rgistring.AreDigitsFromTo(4, 8);

		     // Ora prova a costruire la data
		     if(flag)
		     {
		         flag = false;

		         // Inizia con il mese
		         var mese = parseInt(rgistring.GetString().substring(2, 4), 10);

		         // Se ha un valore corretto per il mese
		         if(mese > 0 && mese < 13)
		         {
		             // Estrae giorno e anno
		             var giorno = parseInt(rgistring.GetString().substring(0, 2), 10);
		             var anno   = parseInt(rgistring.GetString().substring(4, 8), 10);

		             // Anno deve essere accettabile
		             if (anno > 1899)
		             {
		                 // Crea la data
		                 // Il mese è sbagliato. Bisogna togliere 1
		                 var data = new Date(anno, mese-1, 1);

		                 // Individua l'ultimo giorno del mese
		                 if (giorno > 0)
		                 {
		                     var ultimoGiorno;
		                     switch (mese)
		                     {
		                         // Febbraio - Anno Bisestile?
		                         case 2: // '\002'
		                                 if(IsLeapYear(anno))
		                                     ultimoGiorno = 29;
		                                 else
		                                     ultimoGiorno = 28;
		                                 break;

		                         case 4: // '\004'
		                         case 6: // '\006'
		                         case 9: // '\t'
		                         case 11: // '\013'
		                                 ultimoGiorno = 30;
		                                 break;

		                         default:
		                                 ultimoGiorno = 31;
		                                 break;

		                     }
		                     // Verifica il giorno rispetto all'ultimo giorno del mese
		                     if (giorno <= ultimoGiorno)
		                         flag = true;
		                 }
		             }
		         }
		     }
		 }        
        
        }
        return flag;
    }
    
    function IsLeapYear( anno )
    {
        return (new Date(anno, 1, 29).getDate()==29);
    }

    function StringaToData( sData )
    {
        if (IsValid(sData))
        {
            return StringheToData( sData.substring(6, 10), sData.substring(3, 5), sData.substring(0, 2));
        }
        else
            return null;
    }


    function StringheToData( sAnno, sMese, sGiorno )
    {
        return new Date( parseInt(sAnno, 10), parseInt(sMese, 10) - 1, parseInt(sGiorno, 10) );
    }
    

    // Confronta due date in formato stringa
    // Restituisce 1 se la prima data è successiva alla seconda;
    //             2 se le seconda data è successiva alla prima
    //             3 se sono uguali
    function IsDateAfterThisDate(sData1, sData2)
    {
        // Converte la prima data
        var flag = IsValid(sData1);
        var data1;
        if(flag)
        {
            data1 = StringaToData( sData1 );
        }
        else
        {
            return 0;
        }
        
        // Converte la seconda data
        flag = IsValid(sData2);
        var data2;
        if(flag)
        {
            data2 = StringaToData( sData2 );
        }
        else
        {
            return 0;
        }
        
        if(data1.getTime() > data2.getTime())
            return 1;
            
        return (data1.getTime() < data2.getTime()) ? 2: 3;
    }

    
    // controlla se l'ora e il tempo passati sono prima o dopo di adesso
    function IsDateTimeAfterNow(sData1, sOra1, sData2, sOra2)
    {
        // Se la data1 non è valida, restituisce falso
        var flag = IsValid(sData1);
        if (!flag) return false
        
        // Se la Ora1 non è valida, restituisce falso
        flag = IsValidTime(sOra1);
        if (!flag) return false
        
        var data1    = StringaToData( sData1 );
        var iOre1    = parseInt(sOra1.substring(0, 2));
            data1.setHours( iOre1 );
        var iMinuti1 = parseInt(sOra1.substring(3, 5));
            data1.setMinutes( iMinuti1 );

        // Se la data2 non è valida, restituisce falso
        flag = IsValid(sData2);
        if (!flag) return false
        
        // Se la Ora1 non è valida, restituisce falso
        flag = IsValidTime(sOra2);
        if (!flag) return false
        
        var data2    = StringaToData( sData2 );
        var iOre2    = parseInt(sOra2.substring(0, 2));
            data2.setHours( iOre2 );
        var iMinuti2 = parseInt(sOra2.substring(3, 5));
            data2.setMinutes( iMinuti2 );


        // Confronta le due date
        if(data1.getTime() > data2.getTime())
            return 1;
            
        return (data1.getTime() < data2.getTime()) ? 2: 3;
    }

    // Controlla che sia un'ora valida (hh:mm)
    function IsValidTime(sTime)
    {
        var flag = false;
        // Formato riconosciuto: hh:mm
        if(sTime.length == 5)
        {
            var rgistring = new RGIString();
            rgistring.SetString( sTime );
            flag = rgistring.AreDigitsFromTo(0, 2);
            if(flag)
                flag = rgistring.IsValidFromTo(2, 3, ":");
            if(flag)
                flag = rgistring.AreDigitsFromTo(3, 5);
            if(flag)
            {
                flag = false;
                // Verifica che che l'ora sia un numero tra 0 e 24
                var iOra = parseInt(rgistring.GetString().substring(0, 2), 10);
                if(iOra >= 0 && iOra <= 24)
                {
                    // Verifica che i minuti siano tra 0 e 60
                    var iMinuti = parseInt(rgistring.GetString().substring(3, 5), 10);
                    if(iMinuti >= 0 && iMinuti < 60)
                        flag = true;
                }
            }
        }
        return flag;
    }