/**
 * hvs_utils.js version 1.0.0
 *
 * LIBRAIRIE DE FONCTIONS UTILITAIRES JAVASCRIPT HARVEST
 */

//pour savoir si un objet est défini ou non
/**
 *@param obj : objet javascript à tester
 *@return false si l'objet est null ou undefined, sinon true
 */
var HvsUtils = {
    isDefined : function(obj) {
        if (obj == null || obj == undefined) {
            return false;
        }
        return true;
    }
}

//pour savoir si une chaine est nulle, undefined ou vide
/**
 *@param obj : objet à tester
 *@return false si l'objet est null, undefined ou s'il s'agit d'une chaine vide, true sinon
 */
var StringUtils = {
    isEmpty : function(obj) {
        if (HvsUtils.isDefined(obj) == false || (typeof(obj) == "string" && obj.length == 0)) {
            return false;
        }
        return true;
    }
}


// Change la classe d'un élément
function changeClass(element, classToRemove, classToAdd) {
    element.removeClassName(classToRemove);
    element.addClassName(classToAdd);
}

var FormUtils = Class.create();

FormUtils.prototype = {
    initialize : function()
    {
    },
    /** Renvoir une liste d'éléments de formulaire compris dans les éléments du dom en entrée.
     */
    getFormElements:function(formElementBlockList)
    {
        var formElList = new Array();
	
        for(i=0; i<formElementBlockList.length; i++)
        {
            blockEl = $(formElementBlockList[i]);

            if(blockEl == null)
            {
                alert("Bloc " + formElementBlockList[i] + " not found");
                return;
            }

            childList = blockEl.childNodes;

            elStack = new Array();

            if(childList)
            {
                elStack.push(blockEl);
            }

            while(elStack.length > 0)
            {
                blockEl = elStack.pop();

                childList = blockEl.childNodes;

                for(j=0; j<childList.length; j++)
                {
                    childEl = childList[j];

                    // Pour les boutons radio, gère les valeurs manuellement
                    // si non sélectionné -> vide, sinon la valeur sélectionnée.
                    if(childEl.type != undefined &&
                        childEl.name && 
                        childEl.name.length > 0 &&
                        childEl.name != "")
                    {
                        formElList.push(childEl);
                    }
					
                    if(childEl.childNodes && childEl.childNodes.length > 0)
                    {
                        elStack.push(childEl);
                    }
                }
            }
        }
        return formElList;
    }
}


var DEBUG_ENABLED = false;
/**
 * Fonction permettant d'afficher dans un div d�di� (id=debug) un message.
 */
function debug(outputString)
{
    var dateC = new Date();
    var strDate = dateC.toString();

    if (DEBUG_ENABLED)
    {
        // creation si le div debug n'existe pas
        var debugDiv = $('debug');
        if (!debugDiv)
        {
            debugDiv = document.createElement('div');
            debugDiv.id = 'debug';
            debugDiv.style.backgroundColor= '#CCDDCC';
            debugDiv.style.overflow='auto';
            debugDiv.style.left='0px';
            debugDiv.style.top='0px';
            debugDiv.style.width='500px';
            debugDiv.style.height='400px';
            var bodyElement = document.getElementsByTagName('body')[0];
            bodyElement.appendChild(debugDiv);
            $Click('debug', function(event){
                var elt = Event.element(event);
                if (elt)
                {
                    Element.hide(elt);
                }
            }
        );
        }

        // insertion ds le doc

        new Insertion.Bottom('debug',  '<br />' + strDate+' : '+ outputString );
        //Element.show('debug');
    }
}

function isVariableDefined(variable)
{
    return (typeof(window[variable]) == "undefined")?  false: true;
}

//fonction pour IE afin de l'�l�ment est �ditable
function isSelectAllowed(evt)
{
    if(evt.srcElement.isContentEditable==true)
    {
        return true;
    }
    return false;
}

function getKeyCode(event)
{
    if(!event)
    {
        event = window.event;
    }
    return event.keyCode ? event.keyCode : event.which ? event.which : event.charCode;
}

/**
 * Modifie la valeur d'une input dans un formulaire.
 * Si l'input n'existe pas, la cr��.
 */
function setFormParameter(formToUse, parameterName, inputType, parameterValue)
{
    var newHiddenInput = getFormElement(formToUse, parameterName);
    var returnValue=false;        
    if(newHiddenInput == null)
    {
        newHiddenInput = document.createElement('input');
        newHiddenInput.setAttribute("type", inputType);
        newHiddenInput.name = parameterName;
        newHiddenInput.id = parameterName;
        formToUse.appendChild(newHiddenInput);
        returnValue=true;
    }
    newHiddenInput.value = parameterValue;
    return returnValue;
}

/**
 * Cette fonction permet de limiter le nombre de caractères d'une textarea
 */
function limitCaracters(evt,size)
{
    var element = Event.element(evt);
    if (element.value.length>size)
    {
        element.value = element.value.substring(0,size);
    }
}

/**
 * Diff�rentes extensions Harvest � la classe String
 */
Object.extend(
String.prototype,
{
    /**
     * LTrim: Returns a String containing a copy of a specified string without leading spaces
     */
    leftTrim : function()
    {
        return this.replace(new RegExp("^[\\s]+", "gm"), "");
    },

    /**
     * RTrim: Returns a String containing a copy of a specified string without trailing spaces
     */
    rightTrim : function()
    {
        return( this.replace(new RegExp("[\\s]+$", "gm"), "") );
    },

    trim : function()
    {
        return this.rightTrim().leftTrim();
    },

    /**
     * Returns true if this string begins with the prefix at the specified index
     */
    startsWith : function(prefix, toffset)
    {
        var ta = this.toArray();
        var pa = prefix.toArray();

        toffset = (!toffset)?0:toffset;
        var to = toffset;
        var po = 0;
        var pc = prefix.length;

        // Note: toffset might be near -1>>>1.
        if((toffset < 0) || (toffset > this.length - pc))
        {
            return false;
        }
        while(--pc >= 0)
        {
            if(ta[to++] != pa[po++])
            {
                return false;
            }
        }
        return true;
    },

    /**
     * Returns true if this string ends with suffix
     */
    endsWith : function(suffix)
    {
        return this.startsWith(suffix, this.length - suffix.length);
    }
});

/**
 * Raccourci permettant d'ajouter un �v�nement sur un element
 */
function addEvent(obj, evType, fn){
    Event.observe(obj, evType, fn, false);
}

/**
 * Raccourci permettant de supprimer un �v�nement sur un element
 */
function removeEvent(obj, evType, fn, useCapture){
    Event.stopObserving(obj, evType, fn, useCapture);
}


/**
 * Fonction charg�e d'afficher un message d'erreur
 */
function displayErrors(description)
{
    Dialog.alert(description, {className: "harvest",  width:400, height:100, title:"Erreur", id: "erreur", okLabel:"OK"});
}

/**
 * Fonction charg�e d'afficher un message d'avertissement
 */
function displayAvertissement(description)
{
    Dialog.alert(description, {className: "harvest",  width:400, height:100, title:"Avertissement", id: "avert", okLabel:"OK"});
}


var formCtrler;

/**
 * M�thode utilitaire pour pouvoir appeler une m�thode d'une r�f�rence d'objet
 * dans certains cas.
 * Quand la m�thode retourn�e est appell�e, la m�thode methodName est appel�e
 * sur l'instance d'objet object.
 */
function createMethodReference(object, methodName)
{
    return function ()
    {
        object[methodName].apply(object, arguments);
    };
}

/**
 *fonction pour factoriser le code de toutes les fonctions $xxx
 *@param elt : id de l'élément
 *@param evt : l'événement à écouter (click, change, ...)
 *@param functionToExecute : fonction à éxécuter si l'événement survient
 *@param stopObserving : pour arrêter d'écouter l'évenement evt sur l'élément en question
 */
function observeEvent(elt, evt, functionToExecute, stopObserving)
{
    //par défaut on arrête d'écouter l'événement evt sur l'élément en question
    if (stopObserving == undefined || stopObserving == "true" || stopObserving == true) {
        stopObservingElement(elt, evt);
    }
    
    if ($(elt) != null) {
        Event.observe($(elt), evt, functionToExecute);
    }
}

/**
 *méthode pour poser un événement click sur un élément
 *@param elt : l'id de l'élément en question
 *@param myFunction : fonction exécutée lorsque l'événement click se déclenche
 *@param stopObserving : s'il est non spécifié ou à true, enlève l'écouteur de la liste
 */
function $Click(elt, myFunction, stopObserving) 
{
    observeEvent(elt, 'click', myFunction, stopObserving);
}

/**
 *méthode pour poser un événement change sur un élément
 *@param elt : l'id de l'élément en question
 *@param myFunction : fonction exécutée lorsque l'événement change se déclenche
 *@param stopObserving : s'il est non spécifié ou à true, enlève l'écouteur de la liste
 */
function $Change(elt, myFunction, stopObserving) 
{
    observeEvent(elt, 'change', myFunction, stopObserving);
}

/**
 *méthode pour poser un événement blur sur un élément
 *@param elt : l'id de l'élément en question
 *@param myFunction : fonction exécutée lorsque l'événement blur se déclenche
 *@param stopObserving : s'il est non spécifié ou à true, enlève l'écouteur de la liste
 */
function $Blur(elt, myFunction, stopObserving) 
{
    observeEvent(elt, 'blur', myFunction, stopObserving);
}

/**
 *méthode pour poser un événement focus sur un élément
 *@param elt : l'id de l'élément en question
 *@param myFunction : fonction exécutée lorsque l'événement focus se déclenche
 *@param stopObserving : s'il est non spécifié ou à true, enlève l'écouteur de la liste
 */
function $Focus(elt, myFunction, stopObserving) 
{
    observeEvent(elt, 'focus', myFunction, stopObserving);
}

/**
 *méthode pour poser un événement keydown sur un élément
 *@param elt : l'id de l'élément en question
 *@param myFunction : fonction exécutée lorsque l'événement keydown se déclenche
 *@param stopObserving : s'il est non spécifié ou à true, enlève l'écouteur de la liste
 */
function $KeyDown(elt, myFunction, stopObserving) 
{
    observeEvent(elt, 'keydown', myFunction, stopObserving);
}

/**
 *méthode pour poser un événement keypress sur un élément
 *@param elt : l'id de l'élément en question
 *@param myFunction : fonction exécutée lorsque l'événement keypress se déclenche
 *@param stopObserving : s'il est non spécifié ou à true, enlève l'écouteur de la liste
 */
function $KeyPress(elt, myFunction, stopObserving) 
{
    observeEvent(elt, 'keypress', myFunction, stopObserving);
}

/**
 *méthode pour poser un événement keyup sur un élément avec un filtre sur les touches
 *@param elt : l'id de l'élément en question
 *@param myFunction : fonction exécutée si le filtrage est passé
 *@param stopObserving : s'il est non spécifié ou à true, enlève l'écouteur de la liste
 *@param filterFunction : fonction de filtrage exécutée lorsque l'événement keyup se déclenche
 */
function $KeyUp(elt, myFunction, stopObserving, filterFunction) 
{
    var functionToExecute = null;
    
    if(HvsUtils.isDefined(filterFunction))
    {
        functionToExecute = function(event)
        {
            filterFunction(event, myFunction);
        };
    }
    else
    {
        functionToExecute = myFunction;
    }
    
    observeEvent(elt, 'keyup', functionToExecute, stopObserving);
}

/**
 *méthode de filtrage des touches pour les dates
 *@param event : évènement déclenché
 *@param myFunction : fonction exécutée si le filtrage est passé
 */
function filterDate(event, myFunction)
{
    var key = event.keyCode ? event.keyCode : event.which ? event.which : event.charCode;

    if((key >= 48 && key <= 57) ||  // Chiffres du haut
    (key >= 96 && key <= 105) ||    // Chiffres du pavé numérique
    key == 111 || key == 191 ||     // '/'
    key == Event.KEY_DELETE ||      // 'Suppr'
    key == Event.KEY_BACKSPACE)     // Backspace
    {
        myFunction(event);
    }
}

/**
 *méthode de filtrage des touches pour les montants
 *@param event : évènement déclenché
 *@param myFunction : fonction exécutée si le filtrage est passé
 */
function filterAmount(event, myFunction)
{
    var key = event.keyCode ? event.keyCode : event.which ? event.which : event.charCode;

    if((key >= 48 && key <= 57) ||  // Chiffres du haut
    (key >= 96 && key <= 105) ||    // Chiffres du pavé numérique
    key == 110 || key == 190 ||     // '.'
    key == 188 ||                   // ','
    key == Event.KEY_DELETE ||      // 'Suppr'
    key == Event.KEY_BACKSPACE)     // Backspace
    {
        myFunction(event);
    }
}

/**
 *méthode pour poser un événement mousedown sur un élément
 *@param elt : l'id de l'élément en question
 *@param myFunction : fonction exécutée lorsque l'événement mousedown se déclenche
 *@param stopObserving : s'il est non spécifié ou à true, enlève l'écouteur de la liste
 */
function $MouseDown(elt, myFunction, stopObserving) 
{
    observeEvent(elt, 'mousedown', myFunction, stopObserving);
}

/**
 *méthode pour poser un événement mousemove sur un élément
 *@param elt : l'id de l'élément en question
 *@param myFunction : fonction exécutée lorsque l'événement mousemove se déclenche
 *@param stopObserving : s'il est non spécifié ou à true, enlève l'écouteur de la liste
 */
function $MouseMove(elt, myFunction, stopObserving) 
{
    observeEvent(elt, 'mousemove', myFunction, stopObserving);
}

/**
 *méthode pour poser un événement mouseout sur un élément
 *@param elt : l'id de l'élément en question
 *@param myFunction : fonction exécutée lorsque l'événement mouseout se déclenche
 *@param stopObserving : s'il est non spécifié ou à true, enlève l'écouteur de la liste
 */
function $MouseOut(elt, myFunction, stopObserving) 
{
    observeEvent(elt, 'mouseout', myFunction, stopObserving);
}

/**
 *méthode pour poser un événement mouseover sur un élément
 *@param elt : l'id de l'élément en question
 *@param myFunction : fonction exécutée lorsque l'événement mouseover se déclenche
 *@param stopObserving : s'il est non spécifié ou à true, enlève l'écouteur de la liste
 */
function $MouseOver(elt, myFunction, stopObserving) 
{
    observeEvent(elt, 'mouseover', myFunction, stopObserving);
}

/**
 *méthode pour poser un événement mouseup sur un élément
 *@param elt : l'id de l'élément en question
 *@param myFunction : fonction exécutée lorsque l'événement mouseup se déclenche
 *@param stopObserving : s'il est non spécifié ou à true, enlève l'écouteur de la liste
 */
function $MouseUp(elt, myFunction, stopObserving) 
{
    observeEvent(elt, 'mouseup', myFunction, stopObserving);
}

/**
 *méthode pour poser un événement dblclick sur un élément
 *@param elt : l'id de l'élément en question
 *@param myFunction : fonction exécutée lorsque l'événement dblclick se déclenche
 *@param stopObserving : s'il est non spécifié ou à true, enlève l'écouteur de la liste
 */
function $DblClick(elt, myFunction, stopObserving) 
{
    observeEvent(elt, 'dblclick', myFunction, stopObserving);
}

/**
 *méthode pour poser un événement select sur un élément
 *@param elt : l'id de l'élément en question
 *@param myFunction : fonction exécutée lorsque l'événement select se déclenche
 *@param stopObserving : s'il est non spécifié ou à true, enlève l'écouteur de la liste
 */
function $Select(elt, myFunction, stopObserving) 
{
    observeEvent(elt, 'select', myFunction, stopObserving);
}

/**
 * Cette fonction lance la validation du formulaire puis déclenche la requète.
 * @param strFormId Id du formulaire sur lequel on doit effectuer la validation (optionnel)
 * Si ce paramètre n'est pas précisé, il prend la valeur du premier formulaire trouvé dans le document.
 * @param options liste de paramètres complémentaires à transmettre lors de l'envoi de requète (optionnel).
 * @param msgMap : map qui contient les codes d'erreurs
 * @param valideFctEx : fonction à éxécuter en cas d'erreur
 */
function validateAndSubmit(strFormId, options, msgMap, valideFctEx)
{
    var comportementSubmit = {
        "formId" : strFormId,
        "msgMap" : msgMap,
        "valideFctEx" : valideFctEx,
        "validate" : "true"
    }
    
    submitForm(options, comportementSubmit);
    
}

/**
 *Cette fonction valide éventuellement le formulaire et envoie une requête
 *@param argsAction : structure JSON contenant les paramètres reliés à l'action 
 *de la requête ({_action:"calculer",_stage:"accueil"})
 *@param comportementSubmit : structure JSON contenant les paramètres au formulaire 
 *({formAction:"",formId:"monForm",ignoreReturn:"false", valideFctEx:function{}})
 */
function submitForm(argsAction, comportementSubmit) {
    //récupération des paramètres via la structure JSON
    var formAction = null;
    var formId = null;
    var ignoreReturn = null;
    var msgMap = null;
    var valideFctEx = null;
    var validate = null;
    if (comportementSubmit != null && comportementSubmit != "" && comportementSubmit != undefined) {
        formAction = testParam(comportementSubmit.formAction);
        formId = testParam(comportementSubmit.formId);
        ignoreReturn = testParam(comportementSubmit.ignoreReturn, false);
        msgMap = testParam(comportementSubmit.msgMap);
        valideFctEx = testParam(comportementSubmit.valideFctEx);
        validate = testParam(comportementSubmit.validate, true);
    }
    
    //par défaut on fait une validation du formulaire
    if (validate == "true" || validate == true)
    {
        checkDefaultFormController(formId);
        var msgError = hasErrorMessage(msgMap, valideFctEx);
        if (msgError!=null)
        {
            displayErrors(msgError);
            return false;
        }
    } 
    
    //envoie de la requête
    getOavRequest().sendFormRequest(formAction, formId, argsAction, ignoreReturn);
    
    return true;
}

/**
 *Cette fonction permet de tester le paramètre passé en argument
 *@param argument : le paramètre à tester
 *@param defaultValue : valeur par défaut du paramètre
 */
function testParam(argument, defaultValue) 
{
    //nb : l'opérateur !== teste la valeur et le type --> pour conter le problème qui
    //survient lorsqu'on a une boolean false qui est égal à ''
    if (argument != null && argument !== '' && argument != undefined) {
        return argument;
    }
    if(defaultValue)
    {
        return defaultValue;
    }
    else
    {
        return null;
    }
}


/**
 * Cette fonction pose un evt onClick sur le composant portant l'id 'compId'
 * Sur le click, il lance la validation  du formulaire puis d�clenche la requ�te
 * (correspondant au form.action).
 * @param compId Id du composant sur lequel on doit poser l'�v�nement.
 * @param formId Id du formulaire sur lequel on doit effectuer la validation (optionnel)
 * Si ce param�tre n'est pas pr�cis�, il prend la valeur du premier formulaire trouv� dans le document.
 * @param options liste de param�tres compl�mentaires � transmettre lors de l'envoi de requ�te (optionnel).
 * @param listenOnce pour enlever l'écouteur
 * @param msgMap : map des codes d'erreurs
 * @param : valideFctEx : fonction exécutée en cas d'erreur
 */
function validateOnClick(compId, formId, options, listenOnce,msgMap,valideFctEx)
{
    var comportementSubmit = {
        "formId" : formId,
        "msgMap" : msgMap,
        "valideFctEx" : valideFctEx,
        "validate" : "true"
    }
    $Click(compId,
    function() {
        submitForm(options, comportementSubmit);
    },
    listenOnce);
}

function hasErrorMessage(msgMap,valideFctEx)
{
    strFormId = document.forms[0];
    if (msgMap)
        formCtrler.setMsgMap(msgMap);
    formCtrler.validate();
    formCtrler.setMsgMap();
    if (formCtrler.hasErrors())
    {
        errList = formCtrler.getErrors();
        return errList[0].getMessage();
    }
    else
    {
        if (valideFctEx!=null)
        {
            var returnMsg = valideFctEx();
            if (returnMsg!=null)
            {
                return returnMsg;
            }
        }
    }
    return null;
}

function checkDefaultFormController(formId,force)
{
    if (formCtrler==null || force)
    {
        if(!formId)
        {
            formIdToUse = document.forms[0];
        }
        else
        {
            formIdToUse = formId;
        }

        formCtrler = new FormController(formIdToUse);
    }
    return formCtrler;
}

/**
 *Pour arrêter d'écouter les événements spécifiés sur un élément donnée
 *Si name est null, on supprime tous les événements associés à l'élément,
 *sinon, on supprime uniquement l'événement correspondant à name
 *@param compId : id de l'élément dont on veut écouter les événements
 *@param name : nom de l'événement à écouter ('click', 'change', ...)
 */
function stopObservingElement(compId, name)
{
    var observers = Event.observers;
    
    if (observers != null) {
        var removed = false;
        
        for (var i=0; i<observers.length; i++) {
            //observer[0] --> l'élément à écouter
            //observer[1] --> name (événement)
            //observer[2] --> observeur
            var observerInfo = observers[i];
            if (observerInfo[0].id == compId && (name == null || name == observerInfo[1])) {
                removed = true;
                Event.stopObserving(compId, observerInfo[1], observerInfo[2]);
                observers[i] = null;
            }
        }
        if (removed) {
            //retourne un tableau sans les null et undefined
            Event.observers = observers.compact();
        }
    }
}

function clickAndSubmit(compId, formId, options, listenOnce)
{
    var comportementSubmit = {
        "formId"   : formId,
        "validate" : "false"
    }
    $Click(compId,
    function() {
        submitForm(options, comportementSubmit);  
    },
    listenOnce);
}

function keyPressedAndSubmit(compId, formId, options, listenOnce)
{
    var comportementSubmit = {
        "formId"   : formId,
        "validate" : "false"
    }
    
    $KeyPress(compId, 
    function() 
    {
        submitForm(options, comportementSubmit);
    },
    listenOnce);
}

function changeAndSubmit(compId, formId, options, listenOnce)
{
    var comportementSubmit = {
        "formId"   : formId,
        "validate" : "false"
    }
    
    $Change(compId, 
    function() 
    {
        submitForm(options, comportementSubmit);
    }, 
    listenOnce);
}



/**
 * Code below taken from - http://www.evolt.org/article/document_body_doctype_switching_and_more/17/30655/
 */
function getViewportWidth()
{
    if (window.innerWidth)
        return window.innerWidth;
    else if (document.documentElement && document.documentElement.clientWidth!=0)
        return document.documentElement.clientWidth;
    else if (document.body)
        return document.body.clientWidth;
    return 0;
}

function getViewportHeight()
{
    if (window.innerHeight)
    {
        return window.innerHeight;
    }
    else if (document.documentElement && document.documentElement.clientHeight!=0)
        return document.documentElement.clientHeight;
    else if (document.body)
        return document.body.clientHeight;
    return 0;
}

/**
 * Rend la largeur de la zone du document visible par l'utilisateur
 */
function getInnerDocumentWidth()
{
    if (window.innerWidth)
        return window.innerWidth;
    else if (document.documentElement && document.documentElement.clientWidth!=0)
        return document.documentElement.clientWidth;
    else if (document.body)
        return document.body.clientWidth;
    return 0;
}

/**
 * Rend la hauteur de la zone du document visible par l'utilisateur
 */
function getInnerDocumentHeight()
{
    if (window.innerHeight)
        return window.innerHeight;
    else if (document.documentElement && document.documentElement.clientHeight!=0)
        return document.documentElement.clientHeight;
    else if (document.body)
        return document.body.clientHeight;
    return 0;
}

/**
 * Rend l'abscisse de la zone visible dans le navigateur.
 */
function getViewportX()
{
    var x;
    if (self.pageYOffset) // all except Explorer
    {
        x = self.pageXOffset;
    }
    else if (document.documentElement && document.documentElement.scrollTop)
    // Explorer 6 Strict
    {
        x = document.documentElement.scrollLeft;
    }
    else if (document.body) // all other Explorers
    {
        x = document.body.scrollLeft;
    }
    return x;
}

/**
 * Rend l'ordonn�e de la zone visible dans le navigateur.
 */
function getViewportY()
{
    var y;
    if (document.documentElement && document.documentElement.scrollTop)
    // Explorer 6 Strict
    {
        y = document.documentElement.scrollTop;
    }
    else if (document.body) // all other Explorers
    {
        y = document.body.scrollTop;
    }
    return y;
}

/**
 * Rend la chaine initiale si elle est valide sinon une valeur par d�faut.
 */
function defaultStringValue(initialValue, defaultValue)
{
    return (!initialValue)?defaultValue:initialValue;
}

/**
 * Rend un �l�ment du formulaire (une input, ...)
 */
function getFormElement(formToUse, elementName)
{
    var theForm = null;
    if(!formToUse)
    {
        theForm = document.forms[0];
    }
    else
    {
        theForm = formToUse;
    }

    if(!theForm)
    {
        return null;
    }

    var elements = Form.getElements(theForm);
    for (var i = 0; i < elements.length; i++)
    {
        element = $(elements[i]);
        if(element.name == elementName)
        {
            return element;
        }
    }
    return null;
}


/**
 * Méthode de comparaison entre deux dates uniquement sur l'année/mois/jour
 **/
Date.prototype.compareOnDate = function(date2) {
    if(date2 == null)
    {
        throw new Error("Date to compare with must not be null");
    }
    
    date1AsInt = this.getFullYear() * 10000 + this.getMonth() * 100 + this.getDate();
    date2AsInt = date2.getFullYear() * 10000 + date2.getMonth() * 100 + date2.getDate();
    
    return date1AsInt - date2AsInt;
};