//--------------------------------VALIDATIONS
var Max_Obligatory_Fields = 100; // nombre max de champs obligatoires

// <field name="{@PropertyName}" label="{@FieldLabel}"  />

// FONCTIONS GENERALES
function click_CheckForm(theForm,isCaptcha,isRules) { // fonction à utiliser dans un événement "onclick"
  

    
   // récupération des champs obligatoires, création des objets champs
   var fields = GetObligatoryFields(theForm);

   var ok = true;
   if (fields.length > 0) {
       // contrôle de tous les champs //var input = getObject(fields[i].name); alert(fields[i].name + ' ' + input.name + ' ' + input.innerHTML+ ' ' + fields[i].controlField());
       for (var i=0;i<fields.length;i++){  ok &= fields[i].controlField();}
    
      if (ok){ 
      
        if(isRules)
        {
            var ChkRules = getObject("ChkRules");
            if(!ChkRules || !ChkRules.checked)         
            {            
                var DivRules = getObject("DivRules");
                DivRules.style.backgroundColor = "#f4ff46";
                DivRules.style.backgroundImage = "url(/Images/alert.gif)"; 
                DivRules.style.backgroundRepeat = "no-repeat";
                DivRules.style.backgroundPosition = "right";
                DivRules.focus();
                ok = false;
            }
        } 
        //captcha
        if(isCaptcha){if(!jcap()){ok = false;}} 
        
        if(ok){            
            __doPostBack('LnkFinalSave','');}
      return ok;
      }
       else {ErrorsEdit(fields);return false;}
   }

   // aucun champ
   else return true; //alert("Aucun champ n'a été indiqué pour le contrôle de formulaire");
} 

function GetObligatoryFields(theForm) {
   // retourne un tableau d'objets FormField
   
   var fields = new Array();
   // lecture des infos champs à partir des simili-balises HTML <field />
   for (var i=0;i<Max_Obligatory_Fields;i++) {
       field = document.getElementsByTagName("field")[i];
       if (field) {
           if (field.attributes["label"]) label = field.attributes["label"].nodeValue;
           else label = null;
           if (field.attributes["ctl"]) ctl = field.attributes["ctl"].nodeValue;
           else ctl = null;
           fields[fields.length] = new FormField(theForm, field.attributes["name"].nodeValue, label,ctl);
       }
       else break;
   }       
   return fields;
}

function BackColor(ctrl)
{
//alert(id);
ctrl.style.backgroundColor = '#FFFFFF';
ctrl.style.backgroundImage = 'none';
}

function ErrorsEdit(fields) {
   // édition des erreurs des champs   
   var html = "Le formulaire n'a pu être envoyé pour les raisons suivantes:\n";
   for (var i=0;i<fields.length;i++)
   {
    if(fields[i].ErrorsEdit() != "")
    {      
        var htmlArea = false
        var input = getObjectByName(fields[i].name);
        if(document.all  && input[0].type == 'textarea')
        {
             var Editor = getObject("_"+fields[i].name+"_editor");                      
             if(Editor)
             {                         
                htmlArea = true;                            
                Editor.contentWindow.document.body.onkeypress = function(){BackColor(this);}
                Editor.contentWindow.document.body.style.backgroundColor = "#f4ff46";
                Editor.contentWindow.document.body.style.backgroundImage = "url(/Images/alert.gif)"; 
                Editor.contentWindow.document.body.style.backgroundRepeat = "no-repeat";
                Editor.contentWindow.document.body.style.backgroundPosition = "0% 0%";
                Editor.contentWindow.focus();
              }
        }        
        if(!htmlArea)
        {
                if(input[0].type == "checkbox" || input[0].type == "radio")
                {
                    if(input[0].type == "checkbox")
                    { 
                            checkField = getObject("AnswerCheckBox"+input[0].name);
                    }
                    if(input[0].type == "radio")
                    {                
                         if(input[0].attributes["isScale"])
                            checkField = getObject("AnswerScale"+input[0].name);
                          else
                            checkField = getObject("AnswerRadio"+input[0].name);
                    }
                    
                    checkField.style.backgroundColor = "#f4ff46";
                    checkField.style.backgroundImage = "url(/Images/alert.gif)"; 
                    checkField.style.backgroundRepeat = "no-repeat";
                    checkField.style.backgroundPosition = "right";
                    checkField.focus();
                }
                else
                {
                    if(!document.all && input[0].type == "textarea")
                    {
                        input[0].onkeypress = function(){BackColor(this);}
                    }
                    input[0].style.backgroundColor = "#f4ff46";     
                    input[0].style.backgroundImage = "url(/Images/alert.gif)"; 
                    input[0].style.backgroundRepeat = "no-repeat";
                    input[0].style.backgroundPosition = "right 0%";                                 
                    input[0].focus();
                }
           
            }
       //alert(input.focus()); //input.focus();    alert('la');    
    }
     //html += fields[i].ErrorsEdit();
   }
//   if(control_number
   //alert(html);
  
}
//FIN FONCTIONS GENERALES

//------------------------- CLASS FormField -------------------------------//
function FormField(theForm, name, label,ctl) {
   this.form = theForm;
   this.name = name; 
   this.type = null; 
   this.label = label; 
   this.format = null; 
   this.args = null; 
   this.min = null; 
   this.max = null;
   this.errors = new Array();
   if (ctl) this._analyseFormat(ctl);
}

//------------------------------ méthodes publiques
FormField.prototype.controlField = function() {
   // fonction principale de contrôle d'un champ obligatoire   
  ok = true;
   if (this._IsAField()) {
       this._GetType();
       if (this._IsEmpty()){ ok = false; }
       else{ if (this.format) ok &= this._controlFormat(); }
   }
   else {
       this._AddError("unknown_field");
       ok = false;
   }   
   return ok;
}

FormField.prototype.ErrorsEdit = function() {
   // édite les erreurs du champ   
   var text = "";
   if (this.errors.length > 0) {
       for (var i=0;i<this.errors.length;i++) text += "- " + this.errors[i] + "\n";
   }   
   return text;
}


//---------------------------------méthodes privées
FormField.prototype._IsAField = function() {
   // détermine si un champ existe dans le formulaire   
   if (this.form.elements[this.name]) return true;
   else return false;
}

FormField.prototype._GetType = function() {
   // retourne le type de champ : "text", "^password", "file", "textarea", "select-one", 
   // "select-multiple", "checkbox, "radio", "submit", "reset", "button", 
   // mais "checkbox-set" et "radio-set" pour un ensemble de checkboxes ou radios de même nom
   // si le type n'est pas trouvé ou si le champ n'existe pas : on crée une erreur (this.type reste null)

   with (this.form) {
       if (elements[this.name]) {
           if (elements[this.name].type == undefined) {
               if ((elements[this.name].length != undefined) && (elements[this.name].length > 1))
                   this.type = elements[this.name][0].type + "-set";
               else this._AddError("unknown_type");
           }
           else this.type = elements[this.name].type;
       }
       else this._AddError("unknown_field");
   }
}

FormField.prototype._analyseFormat = function(format) {
   // analyse le format d'un champ
   
   var args = format.split(/,\s?/);
   if (args) {
       this.format = args.shift();
       // si on a un seul argument, this.args est une valeur
       if (args.length == 1) this.args = args[0];
       // sinon, c'est un tableau
       else this.args = args;
   }
}


FormField.prototype._controlFormat = function() {
   // contrôle un champ à l'aide d'un format, indiqué par champ.controle et éventuellement champ.args
   
   if (this.type.IsTextField()) {
       var val = this.form.elements[this.name].value;
   
       var ok = false;
      
       // contrôle en fonction d'un format
       switch (this.format) {   
           case "email" :        
               if (!(ok = controlEmail(val))) this._AddError("format_email"); break;
           case "number" :        
               if (!(ok = controlNumber(val, this.args))) this._AddError("control_number"); break;          
       }
   }

   else this._AddError("non_text_control");
   
   return ok;
}

FormField.prototype._IsEmpty = function() {
   // vérifie si un champ du formulaire est vide
   // retourne null si le champ n'existe pas ou son type est indéterminé ou s'il n'y a aucune valeur
   // retourne undefined pour les boutons et file
   // sinon retourne true, si vide et false si non vide 
   // l'erreur est définie selon le cas

   // s'il n'y a erreur de type, on retourne null 
   if (this.type == null) return null;
   var empty = true;
   
   with (this.form) {
   
       // cas d'une case à cocher ou d'un bouton radio unique
       if ((this.type == "checkbox") || (this.type == "radio")) {
           if (elements[this.nom].checked) empty = false;
           else this._AddError("unchecked_element");
       }
       
       // cas d'une série de boutons radio de même nom (fréquent) ou de cases à cocher de même nom (rare)
       else if ((this.type == "radio-set") || (this.type == "checkbox-set")) {
           var i = 0;
           while (i<elements[this.name].length) {
               if (elements[this.name][i].checked) break;
               else i++;
           }
           if (i == elements[this.name].length) this._AddError("unchecked_element");
           else empty = false;
       }
       
       // cas d'un select-multiple (rare)
       else if (this.type == "select-multiple") {
           var i = 0;
           while (i<elements[this.name].options.length) {
               if (elements[this.name].options[i].selected) break;
               else i++;
           }
           if (i == elements[this.name].options.length) this._AddError("unselected_option");
           else empty = false;
       }
       
       // autres cas (text, password, textarea, hidden, select-one)
       else if (this.type == "select-one"){
        if (((elements[this.name].value.trim()) || (elements[this.name].value.trim() != "")) && (elements[this.name].value != 0)) empty = false
           else this._AddError("unfilled_field");
       }
       else if (this.type.IsTextField()) {
           if(this.type == "textarea" && (elements[this.name].value == "<P>&nbsp;</P>" || elements[this.name].value == "<p>&nbsp;</p>")){ empty = true;this._AddError("unfilled_field"); }
           else if (((elements[this.name].value.trim()) || (elements[this.name].value.trim() != ""))) empty = false;           
           else this._AddError("unfilled_field");
       }
       else empty = undefined;
   }
   
   return empty;
}


FormField.prototype._AddError = function(error) {
   // ajoute une erreur

   switch (error) {
       case "unknown_field" :        
           this.errors.push("Le champ '" + this.label + "' est inconnu"); break;
       case "champ_vide" :        
           this.errors.push("Le champ '" + this.label + "' n'a pas été rempli ou sélectionné"); break;
       case "unfilled_field" :        
          this.errors.push("Le champ '" + this.label + "' n'a pas été rempli"); break;
       case "unchecked_element" :    
           this.errors.push("La case '" + this.label + "' n'a pas été cochée"); break;
       case "unselected_option" :    
           this.errors.push("Aucune option n'a été sélectionnée dans la liste '" + this.label); break;
       case "unknown_type" :        
           this.errors.push("Le type du champ '" + this.label + "' est inconnu"); break;
       case "non_text_control" :        
           this.errors.push("Le champ '" + this.label + "' n'est pas de type texte"); break;   
       case "format_email" :        
           this.errors.push("Le champ '" + this.label + "' n'est pas une adresse e-mail conforme"); break;
       case "control_number" :        
           this.errors.push("Le champ '" + this.label + "' doit être compris entre "); break; 
           
                
   }
}



//----------------------------------- FIN DE LA CLASSE CHAMPFORM

//--------------------------------- méthodes additionnelles
String.prototype.IsTextField = function() {
   // détermine si un champ est un champ text, password, textarea ou hidden
   return ((this == "text") || (this == "password") || (this == "textarea") || (this == "hidden"));
}

String.prototype.trim = function() {
   // retourne la chaîne sans espaces ou tabulations au début et à la fin
   chaine = unescape(this);
   return chaine.replace(/(^\s*)|(\s*$)/g, "");
}

function getObjectByName(objectName) {
		if (document.getElementsByName){return document.getElementsByName(objectName);}
		else {
			if (document.getElementById) return document.getElementById(objectName);
		else {
			if (document.layers) return document.layers[objectName];
			else{if (document.all) return document.all(objectName);}}}
			}

//fonctions de controle de champs
function controlEmail(valeur) {
   // contrôle si la valeur d'un champ est un e-mail conforme 
   // (pas de contrôle si l'adresse e-mail existe réellement)
   
   ctl = /^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+([\.][a-z0-9-]+)+$/;
   if (valeur.search(ctl) != -1) return true;
   else return false;
}



/*function submit_form(formulaire) {
   // fonction à utiliser dans un événement "onsubmit"
   
   // récupération des champs obligatoires, création des objets champs
   var champs = lireChampsObligatoires(formulaire);
   
   if (champs.length > 0) {
       var ok = true;
       // contrôle de tous les champs
       for (var i=0;i<champs.length;i++) ok &= champs[i].controler();
       // s'il y a des erreurs : on les affiche
       if (ok) return true; 
       else {
           editerErreurs(champs);
           return false;
       }
   }
   
   // si aucun champ
   else {
       alert("Aucun champ n'a été indiqué pour le contrôle de formulaire"); 
       return false;
   }
} 


function click_form(formulaire) {
   // fonction à utiliser dans un événement "onclick"

   // récupération des champs obligatoires, création des objets champs
   var champs = lireChampsObligatoires(formulaire);

   var ok = true;
   if (champs.length > 0) {
       // contrôle de tous les champs
       for (var i=0;i<champs.length;i++) ok &= champs[i].controler();
       if (ok) formulaire.submit();
       else editerErreurs(champs);
   }

   // aucun champ
   else alert("Aucun champ n'a été indiqué pour le contrôle de formulaire");
} 


function lireChampsObligatoires(formulaire) {
   // retourne un tableau d'objets ChampForm
   
   var champs = new Array();
   // lecture des infos champs à partir des simili-balises HTML <champ />
   for (var i=0;i<lim_champs_obligatoires;i++) {
       champ = document.getElementsByTagName("champ")[i];
       if (champ) {
           if (champ.attributes["lib"]) lib = champ.attributes["lib"].nodeValue;
           else lib = null;
           if (champ.attributes["ctl"]) ctl = champ.attributes["ctl"].nodeValue;
           else ctl = null;
           if (champ.attributes["lim"]) lim = champ.attributes["lim"].nodeValue;
           else lim = null;
           champs[champs.length] = new ChampForm(formulaire, champ.attributes["nom"].nodeValue, lib, ctl, lim);
       }
       else break;
   }    
   
   return champs;
}


function editerErreurs(champs) {
   // édition des erreurs des champs
   
   var html = "Le formulaire n'a pu être envoyé pour les raisons suivantes:\n";
   for (var i=0;i<champs.length;i++) html += champs[i].editerErreurs();
   alert(html);
}


// CLASSE CHAMPFORM

function ChampForm(formulaire, nom, lib, ctl, lim) {
   this.form = formulaire;
   this.nom = nom; 
   this.type = null; 
   this.lib = lib; 
   this.format = null; 
   this.args = null; 
   this.min = null; 
   this.max = null;
   this.erreurs = new Array();
   if (ctl) this._analyserFormat(ctl);
   if (lim) this._analyserLim(lim);
}


// méthodes publiques

ChampForm.prototype.controler = function() {
   // fonction principale de contrôle d'un champ obligatoire
   
   ok = true;
   if (this._champExiste()) {
       this._lireType();
       if (this._estVide()) ok = false;
       else {
           if (this.min || this.max) ok = this._controlerTaille();
           if (this.format) ok &= this._controlerFormat();
       }
   }
   else {
       this._ajouterErreur("champ_inconnu");
       ok = false;
   }
   
   return ok;
}


ChampForm.prototype.editerErreurs = function() {
   // édite les erreurs du champ
   
   var texte = "";
   if (this.erreurs.length > 0) {
       for (var i=0;i<this.erreurs.length;i++) texte += "- " + this.erreurs[i] + "\n";
   }
   
   return texte;
}


// méthodes privées

ChampForm.prototype._analyserFormat = function(format) {
   // analyse le format d'un champ
   
   var args = format.split(/,\s?/);
   if (args) {
       this.format = args.shift();
       // si on a un seul argument, this.args est une valeur
       if (args.length == 1) this.args = args[0];
       // sinon, c'est un tableau
       else this.args = args;
   }
}


ChampForm.prototype._analyserLim = function(lim) {
   // analyse les limites d'un champ
   
   var min_max = lim.match(/(\d+)(,\s?)?(\d+)?/);
   if (min_max) {
       if (!isNaN(min_max[1])) this.min = min_max[1];
       if (min_max[2]) {
           if (min_max[3] && !isNaN(min_max[3])) this.max = min_max[3];
           else this.max = 0;
       }
       else this.max = -1;
   }
}
   

ChampForm.prototype._champExiste = function() {
   // détermine si un champ existe dans le formulaire
   
   if (this.form.elements[this.nom]) return true;
   else return false;
}


ChampForm.prototype._estVide = function() {
   // vérifie si un champ du formulaire est vide
   // retourne null si le champ n'existe pas ou son type est indéterminé ou s'il n'y a aucune valeur
   // retourne undefined pour les boutons et file
   // sinon retourne true, si vide et false si non vide 
   // l'erreur est définie selon le cas

   // s'il n'y a erreur de type, on retourne null 
   if (this.type == null) return null;
   var vide = true;
   
   with (this.form) {
   
       // cas d'une case à cocher ou d'un bouton radio unique
       if ((this.type == "checkbox") || (this.type == "radio")) {
           if (elements[this.nom].checked) vide = false;
           else this._ajouterErreur("case_non_cochee");
       }
       
       // cas d'une série de boutons radio de même nom (fréquent) ou de cases à cocher de même nom (rare)
       else if ((this.type == "radio-set") || (this.type == "checkbox-set")) {
           var i = 0;
           while (i<elements[this.nom].length) {
               if (elements[this.nom][i].checked) break;
               else i++;
           }
           if (i == elements[this.nom].length) this._ajouterErreur("case_non_cochee");
           else vide = false;
       }
       
       // cas d'un select-multiple (rare)
       else if (this.type == "select-multiple") {
           var i = 0;
           while (i<elements[this.nom].options.length) {
               if (elements[this.nom].options[i].selected) break;
               else i++;
           }
           if (i == elements[this.nom].options.length) this._ajouterErreur("option_non_selec");
           else vide = false;
       }
       
       // autres cas (text, password, textarea, hidden, select-one)
       else if (this.type.estChampTexte() || (this.type == "select-one")) {
           if ((elements[this.nom].value.trim()) || (elements[this.nom].value.trim() != "")) vide = false
           else this._ajouterErreur("champ_non_rempli");
       }
       else vide = undefined;
   }
   
   return vide;
}


ChampForm.prototype._lireType = function() {
   // retourne le type de champ : "text", "^password", "file", "textarea", "select-one", 
   // "select-multiple", "checkbox, "radio", "submit", "reset", "button", 
   // mais "checkbox-set" et "radio-set" pour un ensemble de checkboxes ou radios de même nom
   // si le type n'est pas trouvé ou si le champ n'existe pas : on crée une erreur (this.type reste null)

   with (this.form) {
       if (elements[this.nom]) {
           if (elements[this.nom].type == undefined) {
               if ((elements[this.nom].length != undefined) && (elements[this.nom].length > 1))
                   this.type = elements[this.nom][0].type + "-set";
               else this._ajouterErreur("type_inconnu");
           }
           else this.type = elements[this.nom].type;
       }
       else this._ajouterErreur("champ_inconnu");
   }
}


ChampForm.prototype._controlerTaille = function() {
   // contrôle le nombre de caractères de la valeur d'un champ
   if (this.type.estChampTexte()) {
       var taille = this.form.elements[this.nom].value.length;
   
       var ok = false;
       
       // on a seulement un seul chiffre : contrôle strict de la taille
       if (this.max == -1) {
           if (taille == this.min) ok = true; 
           else this._ajouterErreur("champ_longueur", this.min);
       }
       // si this.min et/ou this.max sont non null, on contrôle la taille
       else if (taille >= this.min) {
           if (this.max) {
               if (taille <= this.max) ok = true; 
               else this._ajouterErreur("champ_trop_long", this.max);
           }
           else ok = true;
       }
       else this._ajouterErreur("champ_trop_court", this.min);
   }
   
   return ok;
}


ChampForm.prototype._controlerFormat = function() {
   // contrôle un champ à l'aide d'un format, indiqué par champ.controle et éventuellement champ.args
   
   if (this.type.estChampTexte()) {
       var valeur = this.form.elements[this.nom].value;
   
       var ok = false;
       
       // contrôle en fonction d'un format
       switch (this.format) {
           case "date" :        
               if (!(ok = controlerDate(valeur))) this._ajouterErreur("format_date"); break;
           case "heure" :        
               if (!(ok = controlerHeure(valeur))) this._ajouterErreur("format_heure"); break;
           case "date-heure" :    
           case "dateheure" :    
           case "date_heure" :    
               if (!(ok = controlerDateHeure(valeur))) this._ajouterErreur("format_date_heure"); break;
           case "email" :        
               if (!(ok = controlerEmail(valeur))) this._ajouterErreur("format_email"); break;
           case "url" :        
               if (!(ok = controlerUrl(valeur))) this._ajouterErreur("format_url"); break;
           case "cp" :            
               if (!(ok = controlerCP(valeur))) this._ajouterErreur("format_cp"); break;
           case "tel" :        
               if (!(ok = controlerTel(valeur))) this._ajouterErreur("format_tel"); break;
           case "nombre" :        
               if (!(ok = controlerNombre(valeur, this.args))) this._ajouterErreur("format_nombre"); break;
           case "html" :        
               if (!(ok = controlerBalisesHTML(valeur))) this._ajouterErreur("format_html"); break;
           case "propre" :    
               // exception : controlerPropre ne fait que nettoyer le champ
               this.form.elements[this.nom].value = controlerPropre(valeur); ok = true; break;
           default    :            
               // fonction perso : on récupère des arguments supplémentaires s'il y en a
               var erreur = controlerFonction(this.format, valeur, this.args); 
               if (erreur) this._ajouterErreur("format_fonction",  erreur);
               else ok = true;
       }
   }

   else this._ajouterErreur("controle_non_texte");
   
   return ok;
}
   

ChampForm.prototype._ajouterErreur = function(erreur) {
   // ajoute une erreur

   switch (erreur) {
       case "champ_mal_ecrit" :        
           this.erreurs.push(this.lib + " : erreur dans la syntaxe du champ à la création du formulaire"); break;
       case "champ_inconnu" :        
           this.erreurs.push("Le champ '" + this.lib + "' est inconnu"); break;
       case "champ_vide" :        
           this.erreurs.push("Le champ '" + this.lib + "' n'a pas été rempli ou sélectionné"); break;
       case "champ_non_rempli" :        
           this.erreurs.push("Le champ '" + this.lib + "' n'a pas été rempli"); break;
       case "case_non_cochee" :    
           this.erreurs.push("La case '" + this.lib + "' n'a pas été cochée"); break;
       case "option_non_selec" :    
           this.erreurs.push("Aucune option n'a été sélectionnée dans la liste '" + this.lib); break;
       case "type_inconnu" :        
           this.erreurs.push("Le type du champ '" + this.lib + "' est inconnu"); break;
       case "champ_index_types_diff" :        
           this.erreurs.push("Les champs '" + this.lib + "' doivent être de type identique"); break;
       case "champ_longueur" :    
           this.erreurs.push("Le champ '" + this.lib + "' doit avoir " + arguments[1] + " caractères"); break;
       case "champ_trop_long" :    
           this.erreurs.push("Le champ '" + this.lib + "' ne doit pas excèder " + arguments[1] + " caractères"); break;
       case "champ_trop_court" :    
           this.erreurs.push("Le champ '" + this.lib + "' doit avoir au minimum " + arguments[1] + " caractères"); break;
       case "format_date" :        
           this.erreurs.push("Le champ '" + this.lib + "' n'est pas une date conforme"); break;
       case "format_heure" :        
           this.erreurs.push("Le champ '" + this.lib + "' n'est pas une heure conforme"); break;
       case "format_date_heure" :    
           this.erreurs.push("Le champ '" + this.lib + "' n'est pas une date/heure conforme"); break;
       case "format_email" :        
           this.erreurs.push("Le champ '" + this.lib + "' n'est pas une adresse e-mail conforme"); break;
       case "format_url" :        
           this.erreurs.push("Le champ '" + this.lib + "' n'est pas une url (adresse internet) conforme"); break;
       case "format_cp" :            
           this.erreurs.push("Le champ '" + this.lib + "' n'est pas un code postal conforme"); break;
       case "format_tel" :        
           this.erreurs.push("Le champ '" + this.lib + "' n'est pas un numéro de téléphone conforme"); break;
       case "format_nombre" :        
           this.erreurs.push("Le champ '" + this.lib + "' est un nombre non valide"); break;
       case "format_html" :        
           this.erreurs.push("Le champ '" + this.lib + "' ne contient pas de balises HTML"); break;
       case "format_fonction" :    
           this.erreurs.push("Le champ '" + this.lib + "' a l'erreur suivante: " + arguments[1]); break;
       case "controle_non_texte" : 
           this.erreurs.push("Le champ '" + this.lib + "' n'est pas un champ de type texte"); break;
   }
}

// FIN DE LA CLASSE CHAMPFORM

// AUTRES FONCTIONS ET MÉTHODES UTILITAIRES

// méthodes additionnelles aux objets Javascript

String.prototype.lastChar = function() {
   // retourne le dernier caractère de la chaîne
   return this.substr(-1, 1);
}


String.prototype.trim = function() {
   // retourne la chaîne sans espaces ou tabulations au début et à la fin
   chaine = unescape(this);
   return chaine.replace(/(^\s*)|(\s*$)/g, "");
}


String.prototype.estChampTexte = function() {
   // détermine si un champ est un champ text, password, textarea ou hidden
   return ((this == "text") || (this == "password") || (this == "textarea") || (this == "hidden"));
}


function is_array(valeur) {
   var source = valeur.toSource();
   return (source.search(/^\[([^,]*,)+[^,]*\]/) != -1);
}



// fonctions de contrôle de champ

function controlerDate(valeur) {
   // contrôle la valeur d'un champ comme une date au format JJ/MM/AAAA (séparateur /, ., -)
   
   var ok = false;
   // vérifie le format date
   ctl = /^(\d\d?)[\/\-\.](\d\d?)[\/\-\.](\d{4,})$/;
   var tab = valeur.match(ctl);
   
   // vérifie si la date existe réellement (dates valables du 1/10/1582 au 31/7/275760)
   if (tab) {
         var unedate = new Date(tab[3], parseInt(tab[2])-1, tab[1]);
         if ((unedate.getFullYear() == tab[3]) && (unedate.getMonth() == tab[2]-1) && (unedate.getDate() == tab[1])) ok = true;
   }    
   
   return ok;
}


function controlerHeure(valeur) {
   // contrôle la valeur d'un champ comme une heure au format HH:MM[:SS] (séparateur /, ., -)
   
   ctl = /^([0-1]?[0-9]|2[0-4]):([0-5][0-9])(:[0-5][0-9])?$/;
   if (valeur.search(ctl) != -1) return true;
   else return false;
}

function controlerDateHeure(valeur) {
   // contrôle cumulé des contrôles de date et d'heure
   
   var date_heure = valeur.split(/\s+/);
   return (controlerDate(date_heure[0]) && controlerHeure(date_heure[1]));
}
       
   

function controlerEmail(valeur) {
   // contrôle si la valeur d'un champ est un e-mail conforme 
   // (pas de contrôle si l'adresse e-mail existe réellement)
   
   ctl = /^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+([\.][a-z0-9-]+)+$/;
   if (valeur.search(ctl) != -1) return true;
   else return false;
}


function controlerUrl(valeur) {
   // contrôle si la valeur d'un champ est une url conforme 
   // (pas de contrôle si l'url existe réellement, fonctionne pour une majorité de cas)
   
   ctl = /^((http(s?)|ftp):\/\/)?([\w\-]+\.)+([\w\-]+)(\/[\w\-\s]+)*(\/(([\w\-]+)(\.[\w]+)*)?(#\w+)?(\?.+)?)?$/;
   if (valeur.search(ctl) != -1) return true;
   else {
       ctl = /^mailto:[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+([\.][a-z0-9-]+)+$/;
       if (valeur.search(ctl) != -1) return true;
       else return false;
   }
}


function controlerCP(valeur) {
   // contrôle si la valeur d'un champ est un code postal conforme 
   
   ctl = /^([A-Z]+\-)?[\d]{5}$/;
   if (valeur.search(ctl) != -1) return true;
   else return false;
}


function controlerTel(valeur) {
   // contrôle si la valeur d'un champ est un numéro de téléphone conforme
   
   ctl = /^(\(\d+\))?([\s\.\-]?\d{2,})+$/;
   if (valeur.search(ctl) != -1) return true;
   else return false;
}


function controlerNombre(valeur, limites) {
   // contrôle si la valeur d'un champ est un nombre conforme 

   valeur = valeur.replace(" ", "");
   if (isNaN(valeur)) var ok = false;
   else {
       if (limites != "") {
           if (typeof limites == "string") 
               eval("ok = (" + valeur + " " + limites + ");");
           else if (limites.length == 2)    
               eval("ok = ((" + valeur + " " + limites[0] + ") && (" + valeur + " " + limites[1] + "));");
       }
       else var ok = true;
   }
   return ok;
}


function controlerBalisesHTML(valeur) {
   // contrôle si la valeur d'un champ contient des balises HTML 
   
   if (valeur.search(/<\/?(\w+)(\s[^>]+)?>/) != -1) return true;
   else return false;
}


function controlerPropre(valeur) {
   // convertit les < en &lt; et les > en &gt;
   
   valeur = valeur.replace(/<(\w+)(\s[^>]+)?>/g, "&lt;$1$2&gt;");
   valeur = valeur.replace(/<\/(\w+)>/g, "&lt;/$1&gt;");
   valeur = valeur.replace(/<([\?%])(\w*)/, "&lt;$1$2");
   valeur = valeur.replace(/([\?%])>/, "$1&gt;");
   return valeur;
}


function controlerFonction(fonction, valeur, args) {
   // contrôle la valeur d'un champ avec une fonction déclarée avec un seul argument "valeur"
   // exemple "function numeroSecu(valeur, arg) {...}" sera appelé par controlerFonction("numeroSecu", valeur, arg)
   // on peut avoir des arguments supplémentaires qui ont été stockés dans le tableau args
   
   if (isNaN(valeur)) var ch_eval = fonction + "(\"" + valeur.replace(/\"/, '\\"') + "\"";
   else var ch_eval = fonction + "(" + valeur;
   
   // arguments supplémentaires, s'il y en a
   if (args) {
       if (is_array(args)) {
           for (i=0;i<args.length;i++) ch_eval += "," + variable_selon_type(args[i]);
       }
       else ch_eval += "," + variable_selon_type(args);
   }
   ch_eval += ");";
   
   return eval(ch_eval);
}

function variable_selon_type(valeur) {
   // retourne une variable en fonction de son type (pour controlerFonction)
   var variable = "";
   if (isNaN(valeur)) {
       if (valeur.search(/^'([^'])+'$/) != -1) valeur = valeur.slice(1, -1);
       if (valeur.indexOf("var ") == 0) variable = valeur.substring(4);
       else variable = "\"" + valeur.replace(/\"/, '\\"') + "\"";
   }
   else variable = valeur;
   return variable;
}

*/