/* Verify if value of elementToCheck is not empty. If it is that display 
 * block elementMsgError and if classNameForError is not null add this to
 * classes collection of elementToCheck. Else that display none elementMsgError
 * and delete classNameForError from classes collection.
 */
function RequiredTextBox( elementToCheck, elementMsgError, classNameForError )
{
    if( !elementToCheck ) { alert( "elementToCheck must not be null." ); return false; }
    if( !elementMsgError ) { alert( "elementMsgError must not be null." ); return false; }
    if( elementToCheck.value == "" ) 
    { 
        if( classNameForError && !xHasClass( elementToCheck, classNameForError ) ) 
            xAddClass( elementToCheck, classNameForError ); 
        elementMsgError.style.display = "block"; 
        return false; 
    }
    else 
    { 
        if( classNameForError && xHasClass( elementToCheck, classNameForError ) ) 
            xRemoveClass( elementToCheck, classNameForError );
        elementMsgError.style.display = "none";
        return true;
    }
    alert( "Unknown error is occured." ); 
    return false;
}

/* Same as RequiredTextBox function but that process on an array of text box element.
 */
function RequiredMultiTextBox( arrayOfElementToCheck, elementMsgError, classNameForError )
{
    if( !arrayOfElementToCheck ) { alert( "arrayOfElementToCheck must not be null." ); return false; }
    var l = arrayOfElementToCheck.length;
    if( l < 1 ) { alert( "arrayOfElementToCheck must not be empty." ); return false; }
    if( !elementMsgError ) { alert( "elementMsgError must not be null." ); return false; }
    var empty = false;
    for( var i = 0; i < l; i++ ) 
    { 
        if( arrayOfElementToCheck[i].value == "" ) 
        { 
            empty = true; 
            if( classNameForError && !xHasClass( arrayOfElementToCheck[i], classNameForError ) ) 
                xAddClass( arrayOfElementToCheck[i], classNameForError ); 
        }
        else if( classNameForError && xHasClass( arrayOfElementToCheck[i], classNameForError ) ) 
            xRemoveClass( arrayOfElementToCheck[i], classNameForError );
    }
    if( empty ) { elementMsgError.style.display = "block"; return false; }
    else { elementMsgError.style.display = "none"; return true; }
    alert( "Unknown error is occured." ); 
    return false;
}

function ValidTextBox( elementToValid, elementMsgError, patternToMatch, classNameForError )
{
    if( !elementToValid ) { alert( "elementToValid must not be null." ); return false; }
    if( !elementMsgError ) { alert( "elementMsgError must not be null." ); return false; }
    var r = new RegExp( patternToMatch );
    if( !r.test( elementToValid.value ) ) 
    { 
        if( classNameForError && !xHasClass( elementToValid, classNameForError ) ) 
            xAddClass( elementToValid, classNameForError ); 
        elementMsgError.style.display = "block"; 
        return false; 
    }
    else 
    { 
        if( classNameForError && xHasClass( elementToValid, classNameForError ) ) 
            xRemoveClass( elementToValid, classNameForError ); 
        elementMsgError.style.display = "none"; 
        return true; 
    }
    alert( "Unknown error is occured." ); 
    return false;
}

function ValidMultiTextBox( arrayOfElementToValid, elementMsgError, patternToMatch, classNameForError )
{
    if( !arrayOfElementToValid ) { alert( "arrayOfElementToValid must not be null." ); return false; }
    var l = arrayOfElementToValid.length;
    if( l < 1 ) { alert( "arrayOfElementToValid must not be empty." ); return false; }
    if( !elementMsgError ) { alert( "elementMsgError must not be null." ); return false; }
    var valid = true;
    var r = new RegExp( patternToMatch );
    for( var i = 0; i < l; i++ ) 
    { 
        if( !r.test( arrayOfElementToValid[i].value ) ) 
        { 
            valid = false; 
            if( classNameForError && !xHasClass( arrayOfElementToValid[i], classNameForError ) ) 
                xAddClass( arrayOfElementToValid[i], classNameForError ); 
        }
        else if( classNameForError && xHasClass( arrayOfElementToValid[i], classNameForError ) ) 
            xRemoveClass( arrayOfElementToValid[i], classNameForError );
    }
    if( !valid ) { elementMsgError.style.display = "block"; return false; }
    else { elementMsgError.style.display = "none"; return true; }
    alert( "Unknown error is occured." ); 
    return false;
}

function ConfirmTextBox( elementToCompare1, elementToCompare2, elementMsgError, classNameForError )
{
    if( !elementToCompare1 ) { alert( "elementToCompare1 must not be null." ); return false; }
    if( !elementToCompare2 ) { alert( "elementToCompare2 must not be null." ); return false; }
    if( !elementMsgError ) { alert( "elementMsgError must not be null." ); return false; }
    if( elementToCompare1.value != elementToCompare2.value ) 
    { 
        if( classNameForError && !xHasClass( elementToCompare2, classNameForError ) ) 
            xAddClass( elementToCompare2, classNameForError ); 
        elementMsgError.style.display = "block"; 
        return false; 
    }
    else 
    { 
        if( classNameForError && xHasClass( elementToCompare2, classNameForError ) ) 
            xRemoveClass( elementToCompare2, classNameForError ); 
        elementMsgError.style.display = "none";
        return true; 
    }
    alert( "Unknown error is occured." ); 
    return false;
}

function RequiredCheckBox( arrayOfElementToCheck, elementMsgError, classNameForError )
{
    if( !arrayOfElementToCheck ) { alert( "arrayOfElementToCheck must not be null." ); return false; }
    var l = arrayOfElementToCheck.length;
    if( l < 1 ) { alert( "arrayOfElementToCheck must not be empty." ); return false; }
    if( !elementMsgError ) { alert( "elementMsgError must not be null." ); return false; }
    var check = false;
    for( var i = 0; i < l; i++ ) if( arrayOfElementToCheck[i].checked ) check = true;
    if( !check ) 
    { 
        if( classNameForError )
            for( var i = 0; i < l; i++ ) 
                if( !xHasClass( arrayOfElementToCheck[i], classNameForError ) ) 
                    xAddClass( arrayOfElementToCheck[i], classNameForError ); 
        elementMsgError.style.display = "block";
        return false;
    }
    else 
    {
        if( classNameForError )
            for( var i = 0; i < l; i++ ) 
                if( xHasClass( arrayOfElementToCheck[i], classNameForError ) ) 
                    xRemoveClass( arrayOfElementToCheck[i], classNameForError ); 
        elementMsgError.style.display = "none"; 
        return true; 
    }
    alert( "Unknown error is occured." ); 
    return false;
}

function RequiredListBox( elementToCheck, elementMsgError, expectedValue )
{
    if( !elementToCheck ) { alert( "elementToCheck must not be null." ); return false; }
    if( !elementMsgError ) { alert( "elementMsgError must not be null." ); return false; }
    if( elementToCheck[elementToCheck.selectedIndex].value == expectedValue ) 
    { 
        elementMsgError.style.display = "block"; 
        return false; 
    }
    else 
    { 
        elementMsgError.style.display = "none";
        return true;
    }
    alert( "Unknown error is occured." ); 
    return false;
}

function RequiredMultiListBox( arrayOfElementToCheck, elementMsgError, notExpectedValue )
{
    if( !arrayOfElementToCheck ) { alert( "arrayOfElementToCheck must not be null." ); return false; }
    var l = arrayOfElementToCheck.length;
    if( l < 1 ) { alert( "arrayOfElementToCheck must not be empty." ); return false; }
    if( !elementMsgError ) { alert( "elementMsgError must not be null." ); return false; }
    if( !notExpectedValue ) { alert( "notExpectedValue must be specified." ); return false; }
    var good = true;
    for( var i = 0; i < l; i++ ) 
    { 
		var ele = arrayOfElementToCheck[i];
        if( ele[ele.selectIndex].value == notExpectedValue ) good = false;
    }
    if( !good ) { elementMsgError.style.display = "block"; return false; }
    else { elementMsgError.style.display = "none"; return true; }
    alert( "Unknown error is occured." ); 
    return false;
}

/* Check a JSON string. jsonDataToCheck must be an array of JSON object.
 * A checked JSON object must be coposed by :
 *     - Type (name of function that must be used for check the object)
 *     - ElementToCheck or ArrayOfElementToCheck
 *     - ElementMsgError
 *     - ClassNameForError (must be initialized to null)
 *     - ElementToCompare (for compare check)
 *     - PatternToMatch (for match validation)
 *     - NotExpectedValue (for list required functions)
 */
function CheckJSONData( jsonDataToCheck )
{
    if( !jsonDataToCheck ) { alert( "jsonDataToCheck must not be null." ); return false; }
    var l = jsonDataToCheck.length;
    if( l < 1 ) { alert( "jsonDataToCheck must not be empty." ); return false; }
    var good = true;
    for( var i = 0; i < l; i++ )
    {
        var o = jsonDataToCheck[i];
        switch( o.Type )
        {
            case "RequiredTextBox" : 
            {
                if( !RequiredTextBox( o.ElementToCheck, o.ElementMsgError, o.ClassNameForError ) ) good = false; 
                break;
            }
            case "RequiredMultiTextBox" : 
            {
                if( !RequiredMultiTextBox( o.ArrayOfElementToCheck, o.ElementMsgError, o.ClassNameForError ) ) good = false; 
                break;
            }
            case "ValidTextBox" : 
            {
                if( !ValidTextBox( o.ElementToCheck, o.ElementMsgError, o.PatternToMatch, o.ClassNameForError ) ) good = false; 
                break;
            }
            case "ValidMultiTextBox" : 
            {
                if( !ValidMultiTextBox( o.ArrayOfElementToCheck, o.ElementMsgError, o.PatternToMatch, o.ClassNameForError ) ) good = false; 
                break;
            }
            case "ConfirmTextBox" : 
            {
                if( !RequiredTextBox( o.ElementToCheck, o.ElementToCompare, o.ElementMsgError, o.ClassNameForError ) ) good = false; 
                break;
            }
            case "RequiredCheckBox" : 
            {
                if( !RequiredTextBox( o.ArrayOfElementToCheck, o.ElementMsgError, o.ClassNameForError ) ) good = false; 
                break;
            }
            case "RequiredListBox" : 
            {
                if( !RequiredListBox( o.ArrayOfElementToCheck, o.ElementMsgError, o.NotExpectedValue ) ) good = false; 
                break;
            }
            case "RequiredMultiListBox" : 
            {
                if( !RequiredMultiListBox( o.ArrayOfElementToCheck, o.ElementMsgError, o.NotExpectedValue ) ) good = false; 
                break;
            }
        }
    }
    return good;
}

// Display an element if the condition is valid
function DisplayIf( elementToDisplay, conditionToTest )
{
    if( !elementToDisplay ) { alert( "elementToDisplay must not be null." ); return false; }
    if( conditionToTest ) elementToDisplay.style.display = "block";
    else elementToDisplay.style.display = "none";
}

// Valid length of any string in value of elementToValid.
function ValidStringLength( elementToValid, elementMsgError, length, classNameForError )
{
    return ValidTextBox( elementToValid, elementMsgError, "^.{" + length + "}$", classNameForError )
}

// Valid an unsigned integer.
function ValidInteger( elementToValid, elementMsgError, classNameForError )
{
    return ValidTextBox( elementToValid, elementMsgError, "^[0-9]+$", classNameForError )
}

// Valid a signed integer.
function ValidInteger( elementToValid, elementMsgError, classNameForError )
{
    return ValidTextBox( elementToValid, elementMsgError, "^-?[0-9]+$", classNameForError )
}

// Valid a number with one digit after dot or coma.
function ValidSingleDecimalNumber( elementToValid, elementMsgError, classNameForError )
{
    return ValidTextBox( elementToValid, elementMsgError, "^[0-9]+((\\.|\\,)[0-9]{1})?$", classNameForError )
}

// Valid e number with two digit after dot or coma.
function ValidDoubleDecimalNumber( elementToValid, elementMsgError, classNameForError )
{
    return ValidTextBox( elementToValid, elementMsgError, "^[0-9]+((\\.|\\,)[0-9]{1,2})?$", classNameForError )
}

// Valid a resname.
function ValidResName( elementToValid, elementMsgError, classNameForError )
{
    return ValidTextBox( elementToValid, elementMsgError, "^[a-zA-Z0-9_]+(\\.[a-zA-Z0-9_]+)*$", classNameForError )
}

// Valid a french post code. (Five digits without any space or separator char)
function ValidFrenchPostCode( elementToValid, elementMsgError, classNameForError )
{
    return ValidTextBox( elementToValid, elementMsgError, "^[0-9]{5}$", classNameForError )
}

// Valid a frenche phone number. (Ten digits without any space or separator char)
function ValidFrenchPhoneNumber( elementToValid, elementMsgError, classNameForError )
{
    return ValidTextBox( elementToValid, elementMsgError, "^(\\+33|0)[-.\s]?[1-68][-.\s]?([0-9][-.\s]?){8}$", classNameForError )
}

// Valid a simplest email.
function ValidEmail( elementToValid, elementMsgError, classNameForError )
{
    return ValidTextBox( elementToValid, elementMsgError, "^([0-9a-zA-Z]([-_.\\w]*[0-9a-zA-Z])*@(([0-9a-zA-Z])+([-\\w]*[0-9a-zA-Z])*\\.)+[a-zA-Z]{2,9})$", classNameForError )
}