/* wat issues tussen ff en ie fixxen */


if(!window.console) {
    var console = {};
};

$w("log debug info warn error assert dir dirxml",
    "group groupEnd time timeEnd count trace profile profileEnd").each(function(consoleMethod){
    if(!console[consoleMethod]) {
        console[consoleMethod] = function(){ return true; };
    }
});


var ECube = new Object();


ECube.__onLoadFunctions = $A();
/********************************************************************************************

 registerOnLoadFunction(function) : will cause function to be executed
 during the dom:loaded event.
 unregisterOnLoadFunction(function) : will cause function to not be
 executed during the dom:loaded event
 
********************************************************************************************/
ECube.registerOnLoadFunction = function(fn) {
    ECube.__onLoadFunctions[ECube.__onLoadFunctions.length] = fn;
}
ECube.unregisterOnLoadFunction = function(fn) {
    var newFunctions = $A();
    ECube.__onLoadFunctions.each(function(item){
        if(item != fn){
            newFunctions[newFunctions.length] = item;
        };
    });
    ECube.__onLoadFunctions = newFunctions;
}

/********************************************************************************************

    croak : show a message along with the code that produced it. not terribly useful
            because I haven't figured out how to do full stack traces in JS yet. It
            tells you the function the message came from and the parameters it was
            called with
 
********************************************************************************************/
ECube.croak = function(message){
    var stackMessage = '';
    var callObj = arguments.callee.caller;
    if(callObj){
        stackMessage = stackMessage +  callObj.toString();
        stackMessage = stackMessage + "\n------------------------------------------------------\n";;
        stackMessage = stackMessage + "ARGUMENTS: " + $A(callObj.arguments).toString();
    } else {
        stackMessage = "[top level call]";
    };
    var completeMessage = "======================================================\n";
    completeMessage = completeMessage + 'MESSAGE: ' +  message;
    completeMessage = completeMessage + "\n======================================================\n";
    completeMessage = completeMessage + 'CALLED BY:';
    completeMessage = completeMessage + "\n------------------------------------------------------\n";
    completeMessage = completeMessage + stackMessage;
    completeMessage = completeMessage + "\n======================================================\n";
    console.log(completeMessage);
    return false;
};


/********************************************************************************************

    a debugging object. works the way E*Cube perl debugging works: set a log level and
    assign a log level to every debugging message to indicate for which log levels it
    is relevant. convention says:
    
    3: debugging (dump your vars liberally here)
    2: don't dump so much
    1: tell what is going on but don't overdo it
    0: messages at level 0 are errors
    
    Set the level using ECube.debug.setLogLevel
    
    To log, call ECube.debug.log(relevantLevel, message).
    
    If you don't like typing, you're in luck. ECube.d is an alias for ECube.debug
    
    So this will also work:
    
    ECube.d.log(1, "We do something");
    
********************************************************************************************/

ECube.debug = {
    __logLevel  : 5,
    __lowIsError: true,
    
    setLogLevel: function(levelWanted) {
        ECube.debug.__logLevel = levelWanted
    },
    
    log: function(){
        var args        = $A(arguments);
        var levelWanted = args.splice(0, 1)[0];
        if(levelWanted <= ECube.debug.__logLevel){
            // zero or lower represents an error
            var logMethod
                = (ECube.debug.__lowIsError && (levelWanted<=0))
                ? 'error'
                : 'log';
            
            // add the caller to the log, but only for other browsers then safari
            // while safari only accepts one parameter to the console.log method
            // and functions will be entirely written to the console (argh)
            if (navigator.userAgent.toLowerCase().indexOf("applewebkit") == -1){
              args.unshift(arguments.callee.caller);
            }
            
            args.unshift('[' + levelWanted + ':' + ECube.debug.__logLevel + ']');
            
            // apple webkit doesnt support multiple arguments to the console.log function
            if (navigator.userAgent.toLowerCase().indexOf("applewebkit") != -1) {
              console[logMethod](args);
            }
            // other sane browsers do, so therefore we pass all your arguments
            // directly to the method you requested
            else {
              console[logMethod].apply(this,args);
            }
        };
        return true;
    }
};
// To prevent RSI, give the "debug" element a short alias
ECube.d = ECube.debug;


/********************************************************************************************

 formCombiner : allows you to combine the data from one or more forms into another one.

 register a new formCombiner using the method
    
    * register(combinedFormName, list_of_constituent_forms, callBacks})
    
 (unregister a previously registered one using the method unregister (combinedFormName))
 
 the __init method of formCombiner will automatically setup listeners for defined form combiners
 
 if you need to set up your own listener, use the method
 
 * createListener(combinedFormObj, list_of_constituent_form_objects, callBacks)
 
 callBacks is a hash with callBackName => callBackFunction. Currently only the
 onSubmitCallback is supported
 
********************************************************************************************/

ECube.formCombiner = new Object();

//---------------------------------------------------------------//
//                                                               //
// private methods                                               //
//                                                               //
//---------------------------------------------------------------//

ECube.formCombiner.__combiners = new Object();

// for every defined combiner, create a listener
ECube.formCombiner.__init = function(eventObject){
    ECube.d.log(2, "Starting init function of ECube.formCombiner");
    ECube.d.log(3, "Combiners consists of ", ECube.formCombiner.__combiners);
    Object.keys(ECube.formCombiner.__combiners).each(function(combinedFormName){
        ECube.d.log(2, "Looking for combined form " + combinedFormName);
        var combinedForm = document.forms[combinedFormName];
        // this is not an error. __combiners may be loaded up with all sorts
        // of stuff that isn't relevant on the current page
        if(! combinedForm){
            ECube.d.log(2, "No such form " + combinedFormName);
            return true;
        };
        ECube.d.log(1, "Setting up listener for combined form " + combinedFormName);
        
        var callBacks = ECube.formCombiner.__combiners[combinedFormName]['callBacks'];
        var formNames = ECube.formCombiner.__combiners[combinedFormName]['formsToCombine'];
        
        //the collect gets the form objects. the findAll weeds out those that don't exist
        var formsToCombine = formNames.collect(function(formName){
                return $(document.forms[formName]);
            }).findAll(function(form) { return form });
            
        ECube.d.log(2, "Forms to combine: ", formsToCombine);
        ECube.formCombiner.createListener(
            combinedForm, 
            formsToCombine,
            ECube.formCombiner.__combiners[combinedFormName]['callBacks']);
    });
};
ECube.registerOnLoadFunction(ECube.formCombiner.__init);




//---------------------------------------------------------------//
//                                                               //
// public methods                                                //
//                                                               //
//---------------------------------------------------------------//

// create a listener for combinedForm that combines the data in 
// formsToCombine (form objects, not strings)
ECube.formCombiner.createListener = function(combinedForm, formsToCombine, callBacks){
    
    if(! combinedForm) {
        return Ecube.croak("Attempt to create formCombiner listener but no combined form is supplied");
    };
    try {
        if(! combinedForm.tagName){
            throw("Attempt to create formCombiner listener but no supplied combined form is not an HTML element")
        };
        if(! combinedForm.tagName == 'FORM'){
            throw("Attempt to create formCombiner listener but no supplied combined form is not FORM element")
        }
    } catch(err){
        return ECube.croak(err);
    };
    if(! formsToCombine){
        ECube.d.log(0, "Attempt to create formCombiner listener but no forms supplied to combine");
        return false;
    };
    if(formsToCombine.length == null){
        return ECube.croak("Attempt to create formCombiner listener but formsToCombine parameter is not an array");
    };
    
    $(combinedForm).observe('submit', function(eventObject){
        
        // for binding later on
        var mainForm = $(this);
        
        // check if we have errors in the constituent form. AND (to avoid looping
        // through the forms twice, load the contents of the constituent form
        // into the combined form
        var hasErrors = $(formsToCombine).find(function(constituentForm){
            
            // here's the check
            var validator = new ECube.formValidator(constituentForm);
            if(validator.hasErrors()) {
                window.event? event.returnValue = false : eventObject.preventDefault();
                ECube.d.log(2, 'There were errors in the following constituent form: ', constituentForm);
                validator.markErrors();
                return true;
            };
            // the check passed. load the contents of the form into the combined form
            var formData = constituentForm.serialize(true);
            Object.keys(formData).each(function(fieldName){
                if(! combinedForm[fieldName]) {
                    combinedForm.insert(new Element('input', {
                            'name' : fieldName,
                            'type' : 'hidden'
                    }));
                };
                try {
                    combinedForm[fieldName].value = formData[fieldName];
                } catch(err){
                    window.event? event.returnValue = false : eventObject.preventDefault(); /* IE : standards */
                    return ECube.croak(err);
                };
            });
            
            // done. return false to indicate this form did NOT have errors    
            return false;
        });
        if(hasErrors){
            window.event? event.returnValue = false : eventObject.preventDefault(); /* IE : standards */
            ECube.d.log(1, "One of the constituent forms did not validate. Not submitting");
            return false;
        };
        
        ECube.d.log(2, "All constituent forms are valid and are merged into the combined form. Submitting");
        
        if(callBacks){
            if(callBacks['onSubmit']){
                ECube.d.log(1, "An onSubmit call back is defined. Executing it");
                callBacks['onSubmit'].bind(mainForm)(eventObject);
            };
        };
        return true;
    })
    
};

// set up a combined form (before the onload event triggers)
ECube.formCombiner.register = function(formName, formsToCombine, callBacks){
    if(! formName){
        return ECube.croak("No form name supplied");
    };
    if(! formsToCombine){
        return ECube.croak("No list of forms to combine was supplied")
    };
    if(! formsToCombine.size){
        return ECube.croak("forms to combine must be an array instead of " + formsToCombine);
    };
    ECube.d.log(1, "Setting form combiner for form  " + formName + ' to ' + formsToCombine + ' with callbacks ' + callBacks);
    ECube.formCombiner.__combiners[formName] = {
        'formsToCombine' : formsToCombine,
        'callBacks' : callBacks };
    return true;
}

// remove a previously set up combined form
ECube.formCombiner.unregister = function(formName){
    if(! formName){
        return ECube.croak("No form name supplied");
    };
    ECube.d.log(1, "Removing form combiner for form  " + formName);
    delete ECube.formCombiner.__combiners[formName];
    return true;
}




/********************************************************************************************

 formValidator(formObject) : an object that allows validation of forms using regular
 expressions in the mustmatch attribute of input fields. If the input field has an
 attribute errordisplay that holds the id of an element, that id will be shown if the
 input field value does not match the regular expression in its mustmatch attribute/ If
 the input field also has an attribute errormessage, the contents of this attribute will
 be shown in the element of which the id is in the attribute errordisplay.

 Note that *all* forms on the page will be validated on submit.
 
 customFormValidators : this is a hash that holds custom form validators for specific
 forms. The form name serves as the key. The value is the function that will be bound to
 the submit event for the form. Quite possibly you will want to use the formValidator
 object in your custom validator. To do this, use the following code:

 var validator = new ECube.formValidator(this);
 if(validator.hasErrors()) {
     window.event? event.returnValue = false : eventObject.preventDefault();
     validator.markErrors();
 };

 
********************************************************************************************/
ECube.formValidator = function(formObject) {
    var errors = $A();
    formObject.getElements().each(function(formElement){
        var mustMatch = formElement.readAttribute('mustmatch');
        //console.log("formElement =",formElement.getValue() == undef);
        if(formElement.hasAttribute('notMandatory') && formElement.getValue()== ""){
            return 0; // negeer deze waarde als hij leeg is.
        }
        else{
            if(mustMatch) {
                var matchingElem = $(mustMatch);
                if(matchingElem) {
                    if(formElement.value != matchingElem.value) {
                        errors[errors.length] = formElement;
                    }
                } else {
                    if(formElement.readAttribute('errordisplay')){
                        var errorDisplay = $(formElement.readAttribute('errorDisplay'));
                        if(errorDisplay) {
                            errorDisplay.hide();
                        };
                    };
                    var mustMatchRE = new RegExp(mustMatch);
                    if((formElement.readAttribute('type') == 'radio')  ||
                        (formElement.readAttribute('type') == 'radio')  ||
                        (formElement.readAttribute('type') == 'radio')) {
                        // radios, checkboxes and select-multiple don't work simply by looping through the form elements. if we
                        // encounter them, use old-fashioned form element looping to get their "value"
                        var value = '';
                        var inputName = formElement.readAttribute('name');
                        for(var i = 0, len = formObject.elements.length ; i < len ; ++i) {
                            var inputElement = formObject.elements[i];
                            if(inputElement.name == inputName) {
                                var inputType = inputElement.type;
                                if(inputType == 'radio') {
                                    if(inputElement.checked) {
                                        value=inputElement.value;
                                    };
                                };
                                if(inputType == 'checkbox') {
                                    if(inputElement.checked) {
                                        value=inputElement.value;
                                    };
                                };
                                if(inputType == 'select-multiple') {
                                    value=inputElement.value;
                                };
                            }
                        };
                        if(! value.match(mustMatchRE)){
                            errors[errors.length] = formElement;
                        };
                    } else {
                        if(! formElement.value.match(mustMatchRE)){
                            errors[errors.length] = formElement;
                        };
                    };
                };
            };
        };
    });
    this.hasErrors = function() {
        if(errors.length) {
            return true;
        } else {
            return false;
        };
    };
    this.getErrors = function() {
        return errors;
    };
    this.markErrors = function() {
        errors.each(function(errorElement) {
            // console.log(errorElement);
            if(errorElement.readAttribute('errordisplay')){
                var errorDisplay = $(errorElement.readAttribute('errordisplay'));
                if(errorDisplay) {
                    if(errorElement.readAttribute('errormessage')) {
                        errorDisplay.innerHTML = errorElement.readAttribute('errormessage');
                    };
                    errorDisplay.show();
                } else {
                    console.log('invalid error display object requested', errorElement.readAttribute('errordisplay'));
                };
            } else {
                if(errorElement.onErrorFunction) {
                    errorElement.onErrorFunction(formObject);
                };
            };
            errorElement.focus();
            throw $break;
        });
    };
}


ECube.customFormValidators = new Object();

// attach either a generic validator or a custom validator (if it exists) to a form object
ECube.formValidatorAttach = function(formObj){
    var customValidator = ECube.customFormValidators[formObj.name];
    if(customValidator) {
        $(formObj).observe('submit', customValidator);
    } else {
        $(formObj).observe('submit', function(eventObject){
            var validator = new ECube.formValidator(this);
            if(validator.hasErrors()) {
                window.event? event.returnValue = false : eventObject.preventDefault(); /* IE : standards */
                validator.markErrors();
            };
            validator = null;
        })
    };
};


ECube.registerOnLoadFunction(function(){
    $A(document.getElementsByTagName('FORM')).each(function(form){
        ECube.formValidatorAttach(form);
    })
});


// input elements with class validate_email_input get attached a must match that is the correct RE for
// an email addres. This prevents having to type the same complicated RE again and again
ECube.setMustMatchToEmailRegex = function(inputElement){
    $(inputElement).writeAttribute('mustmatch', "^[^\\@\\s]+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,4})(\\]?)$");
};

ECube.registerOnLoadFunction(function(){
    $$('input.validate_email_input').each(function(inputElement){
        ECube.setMustMatchToEmailRegex(inputElement);
    });
});


/**********************************************************************************
    
    Disable a form for a short while. Optionally do something when
    the form is disabled or when it is found the form is disabled
    
**********************************************************************************/
ECube.canSubmitIfNotSubmittedInLast = function(formObject, numSeconds, onDisableFunction, onIsDisabledFunction) {
    formObject = $(formObject);
    var d = new Date();
    var now = d.getTime();
    // getTime returns unix time in *milliseconds*
    var threshold = now - ( numSeconds * 1000) + 1;
    if(formObject.readAttribute('lastSubmittedOn')) {
        var lastSubmitted = formObject.readAttribute('lastSubmittedOn') * 1;
        if(( lastSubmitted * 1) > (threshold * 1)) {
            if(onIsDisabledFunction) {
                onIsDisabledFunction();
            };
            return false;
        } else {
            formObject.writeAttribute('lastSubmittedOn', now);
            if(onDisableFunction) {
                onDisableFunction();
            };
            return true;
        }
    } else {
        formObject.writeAttribute('lastSubmittedOn', now);
        if(onDisableFunction) {
            onDisableFunction();
        };
        return true;
    }
};

/**********************************************************************************
    
    dateValidator
    
    ECube.dateValidator.validate(day, month, year) 
**********************************************************************************/
ECube.dateValidator = new Object();
// which dates are valid?
ECube.dateValidator['validDates'] = new Object();
ECube.dateValidator['validDates']['1'] = '31';
ECube.dateValidator['validDates']['01'] = '31';
ECube.dateValidator['validDates']['2'] = '29';
ECube.dateValidator['validDates']['02'] = '29';
ECube.dateValidator['validDates']['3'] = '31';
ECube.dateValidator['validDates']['03'] = '31';
ECube.dateValidator['validDates']['4'] = '30';
ECube.dateValidator['validDates']['04'] = '30';
ECube.dateValidator['validDates']['5'] = '31';
ECube.dateValidator['validDates']['05'] = '31';
ECube.dateValidator['validDates']['6'] = '30';
ECube.dateValidator['validDates']['06'] = '30';
ECube.dateValidator['validDates']['7'] = '31';
ECube.dateValidator['validDates']['07'] = '31';
ECube.dateValidator['validDates']['8'] = '31';
ECube.dateValidator['validDates']['08'] = '31';
ECube.dateValidator['validDates']['9'] = '30';
ECube.dateValidator['validDates']['09'] = '30';
ECube.dateValidator['validDates']['10'] = '31';
ECube.dateValidator['validDates']['11'] = '30';
ECube.dateValidator['validDates']['12'] = '31';

ECube.dateValidator.validate = function(day, month, year) {
    if(day && month && year) {
        if((day * 1) > (ECube.dateValidator['validDates'][month] * 1) ) {
            return false;
        };
        if((month == '2') || (month == '02')) {
            if((day * 1) > 28) {
                if((year *1) % 400) {
                    if((year *1) % 4) {
                        return false;
                    };
                    return true;
                } else {
                    return false;
                }; 
            };
        };
        return true;
    };
    return true;
};






/**********************************************************************************
    
    input elements that have an attribute valuedefault 
    
**********************************************************************************/
ECube.registerOnLoadFunction(function(e) {
    var inputs = $A(document.getElementsByTagName('INPUT'));
    inputs.each(function(inputElem) {
        inputElem = $(inputElem);
        if(inputElem.readAttribute('valuedefault')) {
            inputElem.observe('click', function(eventObject){
                var value = this.value;
                var defaultValue = this.readAttribute('valuedefault');
                if(value == defaultValue) {
                    this.value = '';
                };
            });
        };
    });
})



/**********************************************************************************
    
    mouse over images. replace the source
    with the source appended with _hover onmouseover and _hover removed onmouseout
    works for all image types
    
**********************************************************************************/
ECube.setMouseOvers = function(item){
    if(item.src){
        item.observe('mouseover', function(eventObject){
            this.src = this.src.replace(/\.([a-z0-9A-Z]+)$/, '_hover.$1');
        });
        item.observe('mouseout', function(eventObject){
            this.src = this.src.replace(/_hover\.([a-z0-9A-Z]+)$/, '.$1');
        });
    }
}
// images that have a class hashover get their mouseovers set on page load
ECube.registerOnLoadFunction(function(e){
    $$('img.hashover').each(function(imgObject){
        ECube.setMouseOvers(imgObject);
    });
})




/**********************************************************************************

    selects met class onsubmitgotovalue gaan onsubmit naar de gekozen value.
    werkt ook met checkboxes (onclick)

**********************************************************************************/
ECube.registerOnLoadFunction(function(e){
    $$('select.onsubmitgotovalue').each(function(selectObj){
        selectObj.observe('change', function(eventObject){
            if(this.value) {
                location.href = this.value;
            }
        })
    })
    $$('input.onsubmitgotovalue').each(function(inputObj){
        if((inputObj['type'] == 'checkbox') || (inputObj['type'] == 'radio')){
            inputObj.observe('click', function(eventObject){
                if(this.value){
                    location.href = this.value;
                }
            })
        };
    })
})

/**********************************************************************************

    links met class alertonclick tonen een alert met de inhoud van het attribuut message

**********************************************************************************/
ECube.registerOnLoadFunction(function(e){
    $$('a.alertonclick').each(function(aObj){
        if(aObj.readAttribute('message')){
            aObj.observe('click', function(eventObject){
                window.event? event.returnValue = false : eventObject.preventDefault(); /* IE : standards */
                alert(this.readAttribute('message'));
            });
        };
    })
})

/**********************************************************************************

    links met class confirmonclick tonen een confirm met de inhoud van het attribuut message.
    is het attribuut callBackOnError aanwezig is, wordt die functie
    uitgevoerd als er gecancelled wordt.
    is het attribuut callBackOnSuccess aanwezig is, wordt die functie
    uitgevoerd als de bevestiging gegeven is
    is het attribuut callBackOnSuccess niet aanwezig, dan wordt de
    href aangeroepen als de bevestiging gegeven is

**********************************************************************************/
ECube.registerOnLoadFunction(function(e){
    $$('a.confirmonclick').each(function(aObj){
        if(aObj.readAttribute('message')){
            aObj.observe('click', function(eventObject){
                if(confirm(this.readAttribute('message'))){
                    var callBack = this['callBackOnSuccess'];
                    if(callBack){
                        try {
                            callBack.bind(this)(eventObject);
                        } catch(err){
                            console.error('Error executing callback: ',err);
                        }
                    };
                    window.event? event.returnValue = false : eventObject.preventDefault(); /* IE : standards */
                    return true;
                } else {
                    var callBack = this['callBackOnError'];
                    if(callBack){
                        try {
                            callBack.bind(this)(eventObject);
                        } catch(err){
                            console.error('Error executing callback: ',err);
                        }
                    } else {
                        window.event? event.returnValue = false : eventObject.preventDefault(); /* IE : standards */
                    };
                    return false;
                };
            });
        };
    })
})

/**********************************************************************************

    links met class showonclick en met class closeonclick. de ids ztten in
    attributen showonclick en hideonclick. eventueel kan er een functie
    worden meegegeven die wordt uitgevoerd met de div als parameter
    in showonclick_function en hideonclick_function

**********************************************************************************/
ECube.showAndCloseOnClick = new Object();
ECube.showAndCloseOnClick.showOnClick = function(eventObject){
    var idStringToShow = this.readAttribute('showonclick');
    if(! idStringToShow) {
        return true;
    };
    window.event? event.returnValue = false : eventObject.preventDefault(); /* IE : standards */
    var linkObj = this;
    $w(idStringToShow).each(function(idToShow){
        var divToShow = $(idToShow);
        // console.log('div to show is ', divToShow);
        if(divToShow) {
            // showonclick_function from the div itself overrules that of the link object
            var showFunction = linkObj['showonclick_function'];
            if(divToShow['showonclick_function']){
                showFunction = divToShow['showonclick_function'];
            };
            if(showFunction){
                showFunction(linkObj, divToShow);
            } else {
                divToShow.show();
            }
        };
    });
};
ECube.showAndCloseOnClick.closeOnClick = function(eventObject){
    var idStringToHide = this.readAttribute('closeonclick');
    if(! idStringToHide) {
        return true;
    };
    window.event? event.returnValue = false : eventObject.preventDefault(); /* IE : standards */
    var linkObj = this;
    // console.log('trying to hide ', idToHide);
    $w(idStringToHide).each(function(idToHide){
        var divToHide = $(idToHide);
        // console.log('div to hide is ', divToHide);
        if(divToHide) {
            var closeFunction = linkObj['hideonclick_function'];
            if(divToHide['hideonclick_function']){
                closeFunction = divToHide['hideonclick_function'];
            };
            if(closeFunction){
                closeFunction(linkObj, divToHide);
            } else {
                divToHide.hide();
            }
        };
    });
}

ECube.registerOnLoadFunction(function(e){
    $$("a.showonclick").each(function(linkObj){
        $(linkObj).observe("click", ECube.showAndCloseOnClick.showOnClick);
    });
    $$("a.closeonclick").each(function(linkObj){
        $(linkObj).observe("click", ECube.showAndCloseOnClick.closeOnClick);
    })
    
})

/**********************************************************************************
    
    Links that submit forms. Nasty as these are, designers like them. So:
    - links that have class "submitform" and the name of an existing form in
    an attribute formtosubmit submit the named form on click
    
**********************************************************************************/
ECube.formSubmitOnLinkClick = function(eventObject){
    window.event? event.returnValue = false : eventObject.preventDefault(); /* IE : standards */
    var formName = this.readAttribute('formtosubmit');
    if(! formName) {
        return false;
    };
    var formObj = document.forms[formName];
    if(! formObj) {
        return false;
    };
    var functionToCall = this.formsubmitfunction;
    if(functionToCall){
        functionToCall(formObj, eventObject);
    } else {
        formObj.submit();
    }
};
ECube.__register__formSubmitOnLinkClick = function(elementObj) {
    elementObj.observe('click', ECube.formSubmitOnLinkClick);
};
ECube.registerOnLoadFunction(function(e){
    $$('a.submitform').each(ECube.__register__formSubmitOnLinkClick);
});
// submitform


/**********************************************************************************
    
    Cookies . Code nicked from http://www.quirksmode.org/js/cookies.html
    
**********************************************************************************/

// document.cookie =
//  'ppkcookie1=testcookie; expires=Thu, 2 Aug 2001 20:47:11 UTC; path=/'
ECube.cookies = function(){
    var cookies = document.cookie.split(/;\s*/);
    for(var i = 0; i < cookies.length;i++){
        var pair = cookies[i].split("=");
        var name = pair[0];
        var value = pair[1];
        if(name != 'read' && name != 'create' && name != 'erase' && name != 'remove'){
            ECube.cookies[name] = value;
        };
    };
};
ECube.cookies.create = function(name,value,days) {
	if (days) {
		var date = new Date();
		date.setTime(date.getTime()+(days*24*60*60*1000));
		var expires = "; expires="+date.toGMTString();
	}
	else var expires = "";
	document.cookie = name+"="+value+expires+"; path=/";
}

ECube.cookies.read = function(name) {
	var nameEQ = name + "=";
	var ca = document.cookie.split(';');
	for(var i=0;i < ca.length;i++) {
		var c = ca[i];
		while (c.charAt(0)==' ') c = c.substring(1,c.length);
		if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length,c.length);
	}
	return null;
}

ECube.cookies.erase = function(name) {
	ECube.cookies.create(name,"",-1);
}
ECube.cookies.remove = ECube.cookies.erase;
ECube.cookies();

/**********************************************************************************
    
 Query variable fetching
    
**********************************************************************************/

ECube.queryVars = function(){
    var query = window.location.search.substring(1);
    var vars = query.split("&");
    for (var i=0;i<vars.length;i++) {
        var pair = vars[i].split("=");
        var name = pair[0];
        var value = pair[1];
        if(name != 'read'){
            ECube.queryVars[name] = value;
        };
    };
};  
    
ECube.queryVars.read = function(name){
    var query = window.location.search.substring(1);
    var vars = query.split("&");
    for (var i=0;i<vars.length;i++) {
        var pair = vars[i].split("=");
        if (pair[0] == name) {
            return pair[1];
        }
    }
    return null;
}
ECube.queryVars();

/**********************************************************************************
    
    Done. Call the on load functions
    
**********************************************************************************/
document.observe("dom:loaded", function(e) {
    try {
        if(ECube.onLoadFunctionsMustWait){
           if(ECube.onLoadFunctionsCanRun) {
               ECube.__onLoadFunctions.invoke('call');
           } else {
               ECube.__onLoadTimeoutSafety = 0;
               ECube.__onLoadAttempt = function(){
                   if(ECube.onLoadFunctionsCanRun || ECube.__onLoadTimeoutSafety > 10){
                       ECube.d.log(0, "ECube.__onLoadFunctions were called after waiting for onLoadFunctionsCanRun to be set for more than 10 attempts");
                       ECube.__onLoadFunctions.invoke('call');
                   } else {
                       ECube.__onLoadTimeoutSafety++;
                       window.setTimeout(ECube.__onLoadAttempt, 50);
                   };
               };
               ECube.__onLoadAttempt();
           }
        } else {
            ECube.__onLoadFunctions.invoke('call');
        };
    } catch(err){
        ECube.__onLoadFunctions.invoke('call');
    };
});