function Int2Str(num, digit) {
    var str, count;

    str = num.toString();
    count = digit - str.length;
    if (count > 0) {
        while (--count >= 0) str = "0" + str;
    }
    return str;
}

function Str2Int(str) {
    var c, cpt, count;

    count = str.length;
    if (count <= 0) return 0;
    for (cpt = 0; cpt < count; cpt++) {
        c = str.charAt(cpt);
        if (c >= "0" && c <= "9") return parseInt(str.substring(cpt, count), 10);
    }
    return 0;
}

function VerifierTel(oChamps) {
    //Déclaration des variables locales + initialisation
    var c;
    var str = "";
    var numero = oChamps.value;
    var count = numero.length;
    if (count <= 0) return str;
    while (--count >= 0) {
        c = numero.charAt(count);
        if (c < "0" || c > "9") numero = numero.substring(0, count) + numero.substring(count + 1, numero.length);
    }

    for (count = 0; count < numero.length; count++) {
        if (count > 0 && count % 2 == 0) str += " ";
        str += numero.charAt(count);
    }
    oChamps.value = str;
    return true;
}

function VerifierEmail(oChamps) {
    //Déclaration des variables locales
    var pos;
    var point;
    var value = oChamps.value;
    if (value != "") {
        pos = value.indexOf("@") + 1;
        if (pos > 1) {

            point = value.indexOf(".", pos);
            if (point > pos && point < value.length - 1) {
                return true;
            }
        }
        alert("Erreur de saisie dans le champ Adresse email");
        oChamps.value = "";
        oChamps.focus();
        return false;
    } else {
        return true;
    }
}

function VerifierEntier(oChamps, sBornes) {
    var verifier = true;
    var lMin, lMax, oTest;
    var numero = oChamps.value;
    str = "";
    count = numero.length;
    if (count <= 0) verifier = false;

    while (--count >= 0) {
        c = numero.charAt(count);
        if (c < "0" || c > "9") numero = numero.substring(0, count) + numero.substring(count + 1, numero.length);
    }
    for (count = 0; count < numero.length; count++) {

        str += numero.charAt(count);
    }
    numero = str;
    oChamps.value = numero;
    if (sBornes != "") {
        oTest = new Array()
        oTest = sBornes.split(",")
        lMin = Str2Int(oTest[0])
        lMax = Str2Int(oTest[1])
        if (numero < lMin || numero > lMax) {
            alert("Valeur entière erronée. Elle doit être comprise entre " + lMin + " et " + lMax);
            oChamps.value = "";
            oChamps.focus();
            verifier = false
        }
    }
    return verifier;
}

//--------------------------------------------------------------------
// Nom fonction                              : VerifierDate(champ)
// -----------------
// Description                   : vérifie si une date est correcte et gère la complétion
//
// Date de création : 12/05/2003
// Auteur           : FG
//--------------------------------------------------------------------
function VerifierDate(champ) {

    var dateSaisie;
    var datePourValidation;
    var moisReference;
    var anneeReference;
    var temp;
    var unedate = new Date;
    var datereference;
    var datejour;
    if (champ.value == '')
    { return; }
    else {
        // par défaut
        datePourValidation = champ.value;
        // on splitte sur le séparateur de date
        datejour = new Date; // initialisé automatiquement avec la date du jour                            
        datereference = datejour.getDate() + '/' + (datejour.getMonth() + 1) + '/' + datejour.getFullYear();
        temp = datereference.split("/");
        // mois de référence = mois du début de la période
        // année de référence = année du début de la période
        moisReference = temp[1];
        anneeReference = temp[2];


        // analyse de la saisie
        dateSaisie = champ.value.split("/")
        // saisie de la forme xx/xx
        if (dateSaisie.length == 2)
        { datePourValidation = champ.value + "/" + anneeReference };
        // saisie de la forme xx/xx/
        if (dateSaisie.length == 3 && dateSaisie[2] == '')
        { datePourValidation = champ.value + anneeReference };
        // saisie de la forme xx/
        if (dateSaisie.length == 2 && dateSaisie[1] == '')
        { datePourValidation = champ.value + moisReference + "/" + anneeReference };
        // saisie de la forme xx
        if (dateSaisie.length == 1)
        { datePourValidation = champ.value + "/" + moisReference + "/" + anneeReference };
    }
    // ici on a le code standard (légèrement aménagé) de VerifierDate
    var str;
    var verifier = true;
    var oChamps;

    oChamps = champ;
    str = datePourValidation;
    sFormat = "Local";

    dArray = str.split("/");
    if (dArray.length != 3) verifier = false
    else {
        dArray[0] = Str2Int(dArray[0]);
        dArray[1] = Str2Int(dArray[1]) - 1;
        dArray[2] = Str2Int(dArray[2]);
        if (dArray[2] < 50) dArray[2] += 2000;
        if (dArray[2] < 100) dArray[2] += 1900;
        if (oChamps != null && sFormat == "Local") {
            oChamps.value = Int2Str(dArray[0], 2) + "/" + Int2Str(1 + dArray[1], 2) + "/" + dArray[2];
        }
        if (oChamps != null && sFormat == "Us") {
            oChamps.value = Int2Str(dArray[1], 2) + "/" + Int2Str(1 + dArray[0], 2) + "/" + dArray[2];
        }
        dt = new Date(dArray[2], dArray[1], dArray[0]);
        if (sFormat == "Local" && (dt.getMonth() != dArray[1] || dt.getDate() != dArray[0] || !verifier)) { verifier = false; }
        if (sFormat == "Us" && (dt.getMonth() != dArray[0] || dt.getDate() != dArray[1] || !verifier)) verifier = false;
        if (dt.getYear() == dArray[2] && verifier) verifier = true;
        if (1900 + dt.getYear() == dArray[2] && verifier) verifier = true;
    }


    if (!verifier) {
        alert("Le format de la date n'est pas correct.");
        oChamps.value = "";
        oChamps.select();
        oChamps.focus();
    }
}
function VerifierReel(oChamps, sBornes) {
    var verifier = true;
    var dValue, sValue;
    var sStr = "";
    var count;
    var exp;
    sValue = oChamps.value;
    count = sValue.length;
    if (count <= 0) return sStr;
    while (--count >= 0) {
        c = sValue.charAt(count);
        if ((c < "0" || c > "9") && (c != ",") && (c != ".") && (c != "-")) {
            sValue = sValue.substring(0, count) + sValue.substring(count + 1, sValue.length);
        }
        else if (c == ",") {
            sValue = sValue.substring(0, count) + "." + sValue.substring(count + 1, sValue.length);
        }

    }

    dValue = parseFloat(sValue); // au cas ou il y aurait un "." en trop
    oChamps.value = dValue.toString();
    if (sValue == '') {
        oChamps.value = '';
        return false;
    }
    sStr = oChamps.value;
    if (sBornes != '') {
        var i = 0;
        var ld;
        var oTest;
        oTest = new Array();
        oTest = sBornes.split(",");
        var lDec = oTest[2];
        var lMin = oTest[0];
        var lMax = oTest[1];
        //on retire les décimales en trop
        i = sStr.indexOf(".") + 1;
        ld = sStr.length - i;
        if ((ld > lDec) && (i != 0)) {
            alert('Attention : seulement ' + lDec + ' décimales admises');
            sStr = sStr.substring(0, sStr.length - (ld - lDec));
            oChamps.value = sStr;
        }
        if (parseFloat(sStr) < parseFloat(lMin)) {
            alert('Valeur erron&eacute;e. Elle ne doit pas être inférieure a ' + lMin + '.');
            oChamps.value = "";
            oChamps.focus();
            verifier = false;
        }
        else if (parseFloat(sStr) > parseFloat(lMax)) {
            alert('Valeur erron&eacute;e. Elle ne doit pas être supérieure a ' + lMax + '.');
            oChamps.value = "";
            oChamps.focus();
            verifier = false;
        }
    }

    return verifier;
}


// Permet de vérifier qu'on retrourne soit un réel, soit la valeur sValeur
function VerifierReelOu(oChamps, sBornes, sValeur) {
    if (trim(oChamps.value) == '') {
        alert('vous devez saisir un nombre');
        oChamps.focus();
        return false;
    }
    if (oChamps.value != sValeur) {
        return VerifierReel(oChamps, sBornes);
    }
}

//--------------------------------------------------------------------
// Nom de la fonction : verifierDatesInferieures
// ------------------
// Description : vérifie que Date1 <= Date2
// -----------
//
// Paramètres : Obligatoire Date1,Date2 (valeurs des champs date)
// ----------   (la date doit comporter jour mois et année)
//
// ----------------
// Date de création : 01/09/2003 - FG
// ----------------
// --------------------------------------------------------------------
function verifierDatesInferieures(Date1, Date2) {
    var d1, d2;

    var tablo = Date1.split("/");
    Date1 = tablo[1] + "/" + tablo[0] + "/" + tablo[2];
    tablo = Date2.split("/");
    Date2 = tablo[1] + "/" + tablo[0] + "/" + tablo[2];

    d1 = new Date(Date1);
    d2 = new Date(Date2);

    if (Date1 == "" || Date2 == "") return true;
    return (d1.getTime() <= d2.getTime());
}

//--------------------------------------------------------------------
// Nom de la fonction : trim
// ------------------
// Description : enlève les blancs à droite et à gauche
// -----------                        
function trim(s) {
    var r = /\b(.*)\b/.exec(s);
    return (r == null) ? "" : r[1];
}

//--------------------------------------------------------------------
// Nom de la fonction : Arguments
// ------------------
// Description : prend une châine séparée par des virgules et la met dans
// -----------        dans un objet qui a une propriété tableau.
//
// Paramètres : sTopic , la liste des chaînes
// ----------   ex : var oTest = new Arguments("Nom","Prenom")
//                                                           Cette fonction rend un objet avec une propriét length pour
//                                                           le nombre d'arguments et un tableau pour les arguments
// Date de création : 29/10/1999 - Stef
// ----------------
// Date de dermière mise à jour : 29/10/1999 - Stef
// ----------------------------
// --------------------------------------------------------------------
function LesArguments(sTopic) {
    //il faut compter le nombre d'argument
    this.length = LesArguments.arguments.length;
    for (cpt = 0; cpt <= this.length; cpt++) {
        this[cpt] = LesArguments.arguments[cpt];
    }
}

//--------------------------------------------------------------------
// Nom de la fonction : ValiderForm
// ------------------
// Description : Cette fonction de charge de vérifier si tous les champs
// -----------   passés en paramètre sont bien remplis. Elle retourne vrai 
//                                                           la liste des champs est ok sinon, elle retourne faux, avec
//                                                           une alerte.
// Paramètres :  MyForm : le nom ou l'indice du formulaire concerné
// ----------          sListChampsObl : liste des champs obligatoires
//                                                           sDestination : l'URL de destination du formulaire (optionnel)
//                                                           Exemple d'appel : ValiderForm(0,'"Nom","Prenom"','Validation.asp')


// Remarque :    Cette fonction ne traîte pas des radiobox, car il suffit
// --------                             d'en cocher une par défault.    
// Date de création : 29/10/1999 - Stef
// ----------------
// Date de dermière mise à jour : 18/10/2004 - Frédéric Andres
// ----------------------------
// --------------------------------------------------------------------

function ValiderForm(myForm, sListChampsObl, sDestination, sValiderForm) {

    var bStop;
    var bValeur;
    var tabArgs; //Tableau des arguments
    var oChamps;
    var oForm;
    var i = 0;
    var sType;
    var lCpt = 0;
    bStop = false;

    if (!isNaN(myForm)) {
        eval("oForm=document.forms[" + myForm + "]");
    }
    else {
        eval("oForm=document.forms['" + myForm + "']");
    }

    eval("tabArgs= new LesArguments(" + sListChampsObl.replace('&quot;', '\"') + ");");

    while (i < tabArgs.length) {

        //eval('oChamps=oForm.' + tabArgs[i] & ";");                                   
        //oChamps=document.getElementById(tabArgs[i]);
        oChamps = document.forms[myForm].elements[tabArgs[i]];

        if (typeof (oChamps) != "object") {
            alert("Erreur, le champs " + tabArgs[i] + " est inconnu");
            return false;
        }
        sType = oChamps.type;

        if (sType == null) {//Il existe plusieurs champs de même nom (Radio ou checkbox)
            for (j = 0; j < oForm.length; j++) {
                if (oForm.elements[j].name == tabArgs[i]) {//c'est le bon
                    sType = oForm.elements[j].type;
                }
            }
        }
        if ((sType == "text" || sType == "textarea" || sType == "file") && oChamps.value == "") {
            //alert("Vous devez renseigner ce champ.");
            alert("Merci de renseigner tous les champs obligatoires.");
            oChamps.focus();
            return false;
        }

        if (sType == "select-one" && oChamps.selectedIndex == 0) {
            //alert("Vous devez sélectionner un élément dans la cette liste.");
            alert("Merci de renseigner tous les champs obligatoires.");
            oChamps.focus();
            return false;
        }
        if (sType == "select-multiple" && oChamps.selectedIndex == 0) {
            //alert("Vous devez sélectionner un élément dans la cette liste.");
            alert("Merci de renseigner tous les champs obligatoires.");
            oChamps.focus();
            return false;
        }
        if (sType == "checkbox" && !oChamps.checked) {
            alert("Merci de renseigner tous les champs obligatoires.");
            oChamps.focus();
            return false;
        }
        if (sType == "radio" && !oChamps.checked) {
            alert("Merci de renseigner tous les champs obligatoires.");
            oChamps.focus();
            return false;
        }

        i++;
    }

    //if (sValiderForm != null){
    //            if (sDestination != null)
    //            {
    //                           oForm.action = sDestination;
    //            }                              
    //            oForm.submit();
    //}
    return true;
}