/** 
* Copyright 2005-2006 massimocorner.com
* @author      Massimo Foti (massimo@massimocorner.com)
* @version     1.3.1, 2006-07-22
 */

// Create all the validator objects required inside the document
function tmt_validatorInit(){
  var formNodes = document.getElementsByTagName("form");
  for(var i=0; i<formNodes.length; i++){
    if(formNodes[i].getAttribute("tmt:validate") == "true"){
      // Attach a validator object to each form that requires it
      formNodes[i].tmt_validator = new tmt_formValidator(formNodes[i]);
      // Set the form node's onsubmit event 
      // We use a gigantic hack to preserve exiting calls attached to the onsubmit event (most likely validation routines)
/*      if(typeof formNodes[i].onsubmit != "function"){
        formNodes[i].onsubmit = function(){
          return tmt_validateForm(this);
        }
      }
      else{
        // Store a reference to the old function
        formNodes[i].tmt_oldSubmit = formNodes[i].onsubmit;
        formNodes[i].onsubmit = function(){
          // If the existing function return true, send the form
          if(this.tmt_oldSubmit()){
            return tmt_validateForm(this);
          }
          return false;
        }
      }*/
    }
  }
}  

// Perform the validation
function tmt_validateForm(formNode){
  var errorMsg = "";
  var formValidator = formNode.tmt_validator;
  // Be sure the form contains a validator object
  if(formValidator){
    var focusGiven = false;
    // This array will store all the field validators that contains errors
    // They may be required by the callback
    var invalidFields = new Array();
    // Validate all the fields
    for(var i=0; i<formValidator.validators.length; i++){
      if(formValidator.validators[i].validate()){
        // Append to the global error string
        errorMsg += formValidator.validators[i].message + "\n";
        invalidFields[invalidFields.length] = formValidator.validators[i];
        // Give focus to the first invalid text/textarea field
        if(!focusGiven && (formValidator.validators[i].type == "text")){
          formValidator.validators[i].getFocus();
          focusGiven = true;
        }
      }
    }
    if(errorMsg != ""){
      // We have errors, display them
      if(!formValidator.callback){
        // We don't have callbacks, just display an alert
        alert(errorMsg);
      }
      else{
        // Invoke the callbak, it will take care of displaying the errors
        eval(formValidator.callback + "(formNode, invalidFields)");
      }
    }
    else{
      // Everything is fine, disable form submission to avoid multiple submits
      formValidator.blockSubmit();
    }
  }
  return errorMsg.length == 0; 
}

/* Object constructors */

// Form validator
function tmt_formValidator(formNode){
  // Store all the validator objects inside an array
  this.validators = new Array();
  // Add the specified callback only if the function is currently defined
  if(formNode.getAttribute("tmt:callback") && window[formNode.getAttribute("tmt:callback")]){
    this.callback = formNode.getAttribute("tmt:callback");
  }
  var fieldsArray = tmt_getTextfieldNodes(formNode);
  for(var i=0; i<fieldsArray.length; i++){
    // Create a validator for each text field
    this.validators[this.validators.length] = tmt_textValidatorFactory(fieldsArray[i]);
    
    if(fieldsArray[i].getAttribute("type")){
      // Set the onchange event for each image upload validation
      if((fieldsArray[i].getAttribute("type").toLowerCase() == "file") && (fieldsArray[i].getAttribute("tmt:image") == "true")){
        fieldsArray[i].onchange = function(){
          tmt_validateImg(this);
        }
      }
    }
    if(fieldsArray[i].getAttribute("tmt:filters")){
      // Call the filters on the onkeyup and onblur events
      addEvent(fieldsArray[i], "keyup", function(){tmt_filterField(this);});
      addEvent(fieldsArray[i], "blur", function(){tmt_filterField(this);});
    }
  }
  var selectNodes = formNode.getElementsByTagName("select");
  for(var j=0; j<selectNodes.length; j++){
    // Create a validator for each select element
    this.validators[this.validators.length] = tmt_selectValidatorFactory(selectNodes[j]);
  }
  var boxTable = tmt_getNodesTable(formNode, "checkbox");
  for(var boxName in boxTable){
    // Create a validator for each group of checkboxes
    this.validators[this.validators.length] = tmt_boxValidatorFactory(boxTable[boxName]);
  }
  var radioTable = tmt_getNodesTable(formNode, "radio");
  for(var radioName in radioTable){
    // Create a validator for each group of radios
    this.validators[this.validators.length] = tmt_radioValidatorFactory(radioTable[radioName]);
  }
  // Store all the submit buttons
  this.buttons = tmt_getSubmitNodes(formNode);
  // Define a method that can block multiple submits
  this.blockSubmit = function(){
    // Check to see if we want to disable submit buttons
    if(!formNode.getAttribute("tmt:blocksubmit") && !(formNode.getAttribute("tmt:blocksubmit") == "false")){
      // Disable each submit button
      for(var i=0; i<this.buttons.length; i++){
        if(this.buttons[i].getAttribute("tmt:waitmessage")){
          this.buttons[i].value = this.buttons[i].getAttribute("tmt:waitmessage");
        }
        this.buttons[i].disabled = true;
      }
    }
  }
}

// Abstract field validator constructor
function tmt_abstractValidator(fieldNode){
  this.message = "";
  this.name = fieldNode.name;
  if(fieldNode.getAttribute("tmt:message")){
    this.message = fieldNode.getAttribute("tmt:message");
  }
  var errorClass = "";
  if(fieldNode.getAttribute("tmt:errorclass")){
    errorClass = fieldNode.getAttribute("tmt:errorclass");
  }
  this.flagInvalid = function(){
    // Append the CSS class to the existing one
    if(errorClass){
      // Flag only if it's not already flagged
      if(fieldNode.className.indexOf(errorClass) == -1){
        fieldNode.className = fieldNode.className + " " + errorClass;
      }
    }
    // Set the title attribute in order to show a tootip
    fieldNode.setAttribute("title", this.message);
  }
  this.flagValid = function(){
    // Remove the CSS class
    if(errorClass){
      var regClass = new RegExp("\\b" + errorClass);
      fieldNode.className = fieldNode.className.replace(regClass, "");
    }
    fieldNode.removeAttribute("title");
  }
  this.validate = function(){
    // If the field contains error, flag it as invalid and return the error message
    // Be careful, this method contains multiple exit points!!!
    if(fieldNode.disabled){
      // Disabled fields are always valid
      this.flagValid();
      return false;
    }
    if(!this.isValid()){
      this.flagInvalid();
      return true;
    }
    else{
      this.flagValid();
      return false;
    }
  }
}

// Create a validator for text and texarea fields
function tmt_textValidatorFactory(fieldNode){
  // Create a generic validator, than add specific properties and methods as needed
  var obj = new tmt_abstractValidator(fieldNode);
  obj.type = "text";
  var required = false;
  if(fieldNode.getAttribute("tmt:required")){
    required = fieldNode.getAttribute("tmt:required");
  }
  // Put focus and cursor inside the field
  obj.getFocus = function(){
    // This try block is required to solve an obscure issue with IE and hidden fields
    try{
      fieldNode.focus();
      fieldNode.select();
    }
    catch(exception){
    }
  }
  // Check if the field is empty
  obj.isEmpty = function(){
    return fieldNode.value == "";
  }
  // Check if the field is required
  obj.isRequired = function(){
    return required;
  }
  // Check if the field satisfy the rules associated with it
  // Be careful, this method contains multiple exit points!!!
  obj.isValid = function(){
    // The tmt:required="conditional" attribute has a special meaning. 
    // The field isn't strictly required, so it may sometimes be empty, 
    // but before we let it go, we need to check any rule that may apply to it
    if(obj.isEmpty() && (required != "conditional")){
      if(obj.isRequired()){
        return false;
      }
      else{
        return true;
      }
    }
    else{
      // Loop over all the available rules
      for(var rule in tmt_globalRules){
        // Check if the current rule is required for the field
        if(fieldNode.getAttribute("tmt:" + rule)){
          // Invoke the rule
          if(!eval("tmt_globalRules." + rule + "(fieldNode)")){
            return false;
          }
        }
      }
    }
    return true;
  }
  return obj;
}

// Create a validator for <select> fields
function tmt_selectValidatorFactory(selectNode){
  // Create a generic validator, than add specific properties and methods as needed
  var obj = new tmt_abstractValidator(selectNode);
  obj.type = "select";
  var required = false;
  var invalidIndex;
  if(selectNode.getAttribute("tmt:invalidindex")){
    invalidIndex = selectNode.getAttribute("tmt:invalidindex");
  }
  var invalidValue;
  if(selectNode.getAttribute("tmt:invalidvalue") != null){
    invalidValue = selectNode.getAttribute("tmt:invalidvalue");
  }
  // Check if the field is required
  obj.isRequired = function(){
    return required;
  }
  // Check if the field satisfy the rules associated with it
  // Be careful, this method contains multiple exit points!!! // Check if the select validate
  obj.isValid = function(){
    // Check for index
    if(selectNode.selectedIndex == invalidIndex){
      return false;
    }
    // Check for value
    if(selectNode.value == invalidValue){
      return false;
    }
    // Loop over all the available rules
    for(var rule in tmt_globalRules){
      // Check if the current rule is required for the field
      if(selectNode.getAttribute("tmt:" + rule)){
        // Invoke the rule
        if(!eval("tmt_globalRules." + rule + "(selectNode)")){
          return false;
        }
      }
    }
    return true;
  }
  return obj;
}

// Generic validator for grouped fields (radio and checkboxes)
function tmt_groupValidatorFactory(buttonGroup){
  this.name = buttonGroup.name;
  this.message = "";
  this.errorClass = "";
  // Since fields from the same group can have conflicting attribute values, the last one win
  for(var i=0; i<buttonGroup.elements.length; i++){
    if(buttonGroup.elements[i].getAttribute("tmt:message")){
      this.message = buttonGroup.elements[i].getAttribute("tmt:message");
    }
    if(buttonGroup.elements[i].getAttribute("tmt:errorclass")){
      this.errorClass = buttonGroup.elements[i].getAttribute("tmt:errorclass");
    }
  }
  this.flagInvalid = function(){
    // Append the CSS class to the existing one
    if(this.errorClass){
      for(var i=0; i<buttonGroup.elements.length; i++){
        // Flag only if it's not already flagged
        if(buttonGroup.elements[i].className.indexOf(this.errorClass) == -1){
          buttonGroup.elements[i].className = buttonGroup.elements[i].className + " " + this.errorClass;
        }
        buttonGroup.elements[i].setAttribute("title", this.message);
      }
    }
  }
  this.flagValid = function(){
    // Remove the CSS class
    if(this.errorClass){
      var regClass = new RegExp("\\b" + this.errorClass);
      for(var i=0; i<buttonGroup.elements.length; i++){
        buttonGroup.elements[i].className = buttonGroup.elements[i].className.replace(regClass, "");
        buttonGroup.elements[i].removeAttribute("title");
      }
    }
  }
  this.validate = function(){
    var errorMsg = "";
    // If the field group contains error, flag it as invalid and return the error message
    if(!this.isValid()){
      errorMsg += this.message;
      this.flagInvalid();
    }
    else{
      this.flagValid();
    }
    return errorMsg;
  }
}

// Checkbox validator (one for each group of boxes sharing the same name)
function tmt_boxValidatorFactory(boxGroup){
  var obj = new tmt_groupValidatorFactory(boxGroup);
  obj.type = "box";
  var minchecked = 0;
  var maxchecked = boxGroup.elements.length;
  // Since checkboxes from the same group can have conflicting attribute values, the last one win
  for(var i=0; i<boxGroup.elements.length; i++){
    if(boxGroup.elements[i].getAttribute("tmt:minchecked")){
      minchecked = boxGroup.elements[i].getAttribute("tmt:minchecked");
    }
    if(boxGroup.elements[i].getAttribute("tmt:maxchecked")){
      maxchecked = boxGroup.elements[i].getAttribute("tmt:maxchecked");
    }
  }
  // Check if the boxes validate
  obj.isValid = function(){
    var checkCounter = 0;
    for(var i=0; i<boxGroup.elements.length; i++){
        // For each checked box, increase the counter
      if(boxGroup.elements[i].checked){
        checkCounter++;
      }
    }
    return (checkCounter >=  minchecked) && (checkCounter <= maxchecked);
  }
  return obj;
}

// Radio validator (one for each group of radios sharing the same name)
function tmt_radioValidatorFactory(radioGroup){
  var obj = new tmt_groupValidatorFactory(radioGroup);
  obj.type = "radio";

  obj.isRequired = function(){
    var requiredFlag = false;
    // Since radios from the same group can have conflicting attribute values, the last one win
    for(var i=0; i<radioGroup.elements.length; i++){
      if(radioGroup.elements[i].disabled == false){
        if(radioGroup.elements[i].getAttribute("tmt:required")){
          requiredFlag = radioGroup.elements[i].getAttribute("tmt:required");
        }
      }
    }
    return requiredFlag;
  }
  
  // Check if the radio validate
  obj.isValid = function(){
    if(obj.isRequired()){
      for(var i=0; i<radioGroup.elements.length; i++){
        // As soon as one is checked, we are fine
        if(radioGroup.elements[i].checked){
          return true;
        }
      }
      return false;
    }
    // It's not required, so it's fine
    else{
      return true;
    } 
  }
  return obj;
}

// This global objects store all the validation rules
// Every rule is stored as a method that accepts the field node as argument and return a boolean
var tmt_globalRules = new Object;
tmt_globalRules.datepattern = function(fieldNode){
  var globalObj = tmt_globalDatePatterns[fieldNode.getAttribute("tmt:datepattern")];
  if(globalObj){
    // Split the date into 3 different bits using the separator
    var dateBits = fieldNode.value.split(globalObj.s);
    // First try to create a new date out of the bits
    var testDate = new Date(dateBits[globalObj.y], (dateBits[globalObj.m]-1), dateBits[globalObj.d]);
    // Make sure values match after conversion
    var isDate = (testDate.getFullYear() == dateBits[globalObj.y])
         && (testDate.getMonth() == dateBits[globalObj.m]-1)
         && (testDate.getDate() == dateBits[globalObj.d]);
    // If it's a date and it matches the RegExp, it's a go
    return isDate && globalObj.rex.test(fieldNode.value);
  }
}
tmt_globalRules.equalto = function(fieldNode){
  var twinNode = document.getElementById(fieldNode.getAttribute("tmt:equalto"));
  return twinNode.value == fieldNode.value;
}
tmt_globalRules.maxlength = function(fieldNode){
  if(fieldNode.value.length > fieldNode.getAttribute("tmt:maxlength")){
    return false;
  }
  return true;
}
tmt_globalRules.maxnumber = function(fieldNode){
  if(parseFloat(fieldNode.value) > fieldNode.getAttribute("tmt:maxnumber")){
    return false;
  }
  return true;
}
tmt_globalRules.minlength = function(fieldNode){
  if(fieldNode.value.length < fieldNode.getAttribute("tmt:minlength")){
    return false;
  }
  return true;
}
tmt_globalRules.minnumber = function(fieldNode){
  if(parseFloat(fieldNode.value) < fieldNode.getAttribute("tmt:minnumber")){
    return false;
  }
  return true;
}
tmt_globalRules.pattern = function(fieldNode){
  var reg = tmt_globalPatterns[fieldNode.getAttribute("tmt:pattern")];
  if(reg){
    return reg.test(fieldNode.value);
  }
  else{
    // If the pattern is missing, skip it
    return true;  
  }
}

/* Image upload validation */


tmt_globalRules.image = function(fieldNode){
  // If the flag isn't defined we assume things are fine
  if(!fieldNode.isValidImg){
    fieldNode.isValidImg = "true";
  }
  return fieldNode.isValidImg == "true";
}

// Check the currently selected image and set a validity flag
function tmt_validateImg(fieldNode){
  var imgURL = "file:///" + fieldNode.value;
  var img = new Image();
  img.maxSize =  fieldNode.getAttribute("tmt:imagemaxsize");
  img.maxWidth = fieldNode.getAttribute("tmt:imagemaxwidth");
  img.minWidth = fieldNode.getAttribute("tmt:imageminwidth");
  img.maxHeight = fieldNode.getAttribute("tmt:imagemaxheight");
  img.minHeight = fieldNode.getAttribute("tmt:imageminheight");
  // Store a reference to the input field
  img.fieldNode = fieldNode;
  // The image's data can be read only after loading. That's why we need a callback
  img.onload = tmt_validateImgCallback;
  img.src = imgURL;
}

function tmt_validateImgCallback(){
  var errorsCount = 0;
  // Check every constrain and increment the error counter accordingly
  if(this.fileSize && this.maxSize && (this.fileSize/1024) > this.maxSize){
    errorsCount ++;
  }
  if(this.maxWidth && (this.width > this.maxWidth)){
    errorsCount ++;
  }
  if(this.minWidth && (this.width < this.minWidth)){
    errorsCount ++;
  }
  if(this.maxHeight && (this.height > this.maxHeight)){
    errorsCount ++;
  }
  if(this.minHeight && (this.height < this.minHeight)){
    errorsCount ++;
  }
  // Store the valid flag inside the DOM node itself
  this.fieldNode.isValidImg = (errorsCount != 0) ? "false" : "true";
}

// This global objects store all the RegExp patterns for strings
var tmt_globalPatterns = new Object;
tmt_globalPatterns.email = new RegExp("^[\\w\\.=-]+@[\\w\\.-]+\\.[\\w\\.-]{2,4}$");
tmt_globalPatterns.lettersonly = new RegExp("^[a-zA-Z]*$");
tmt_globalPatterns.alphanumeric = new RegExp("^\\w*$");
tmt_globalPatterns.integer = new RegExp("^-?\\d\\d*$");
tmt_globalPatterns.positiveinteger = new RegExp("^\\d\\d*$");
tmt_globalPatterns.number = new RegExp("^-?(\\d\\d*\\.\\d*$)|(^-?\\d\\d*$)|(^-?\\.\\d\\d*$)");
tmt_globalPatterns.filepath_pdf = new RegExp("\\\\[\\w_]*\\.([pP][dD][fF])$");
tmt_globalPatterns.filepath_jpg_gif = new RegExp("\\\\[\\w_]*\\.([gG][iI][fF])|([jJ][pP][eE]?[gG])$");
tmt_globalPatterns.filepath_jpg = new RegExp("\\\\[\\w_]*\\.([jJ][pP][eE]?[gG])$");
tmt_globalPatterns.filepath_zip = new RegExp("\\\\[\\w_]*\\.([zZ][iI][pP])$");
tmt_globalPatterns.filepath = new RegExp("\\\\[\\w_]*\\.\\w{3}$");

// This global objects store all the info required for date validation
var tmt_globalDatePatterns = new Object;
tmt_globalDatePatterns["YYYY-MM-DD"] = tmt_dateInfo("^\([0-9]{4}\)\\-\([0-1][0-9]\)\\-\([0-3][0-9]\)$", 0, 1, 2, "-");
tmt_globalDatePatterns["YYYY-M-D"] = tmt_dateInfo("^\([0-9]{4}\)\\-\([0-1]?[0-9]\)\\-\([0-3]?[0-9]\)$", 0, 1, 2, "-");
tmt_globalDatePatterns["MM.DD.YYYY"] = tmt_dateInfo("^\([0-1][0-9]\)\\.\([0-3][0-9]\)\\.\([0-9]{4}\)$", 2, 0, 1, ".");
tmt_globalDatePatterns["M.D.YYYY"] = tmt_dateInfo("^\([0-1]?[0-9]\)\\.\([0-3]?[0-9]\)\\.\([0-9]{4}\)$", 2, 0, 1, ".");
tmt_globalDatePatterns["MM/DD/YYYY"] = tmt_dateInfo("^\([0-1][0-9]\)\/\([0-3][0-9]\)\/\([0-9]{4}\)$", 2, 0, 1, "/");
tmt_globalDatePatterns["M/D/YYYY"] = tmt_dateInfo("^\([0-1]?[0-9]\)\/\([0-3]?[0-9]\)\/\([0-9]{4}\)$", 2, 0, 1, "/");
tmt_globalDatePatterns["MM-DD-YYYY"] = tmt_dateInfo("^\([0-21][0-9]\)\\-\([0-3][0-9]\)\\-\([0-9]{4}\)$", 2, 0, 1, "-");
tmt_globalDatePatterns["M-D-YYYY"] = tmt_dateInfo("^\([0-1]?[0-9]\)\\-\([0-3]?[0-9]\)\\-\([0-9]{4}\)$", 2, 0, 1, "-");
tmt_globalDatePatterns["DD.MM.YYYY"] = tmt_dateInfo("^\([0-3][0-9]\)\\.\([0-1][0-9]\)\\.\([0-9]{4}\)$", 2, 1, 0, ".");
tmt_globalDatePatterns["D.M.YYYY"] = tmt_dateInfo("^\([0-3]?[0-9]\)\\.\([0-1]?[0-9]\)\\.\([0-9]{4}\)$", 2, 1, 0, ".");
tmt_globalDatePatterns["DD/MM/YYYY"] = tmt_dateInfo("^\([0-3][0-9]\)\/\([0-1][0-9]\)\/\([0-9]{4}\)$", 2, 1, 0, "/");
tmt_globalDatePatterns["D/M/YYYY"] = tmt_dateInfo("^\([0-3]?[0-9]\)\/\([0-1]?[0-9]\)\/\([0-9]{4}\)$", 2, 1, 0, "/");
tmt_globalDatePatterns["DD-MM-YYYY"] = tmt_dateInfo("^\([0-3][0-9]\)\\-\([0-1][0-9]\)\\-\([0-9]{4}\)$", 2, 1, 0, "-");
tmt_globalDatePatterns["D-M-YYYY"] = tmt_dateInfo("^\([0-3]?[0-9]\)\\-\([0-1]?[0-9]\)\\-\([0-9]{4}\)$", 2, 1, 0, "-");

// Create an object that stores date validation's info
function tmt_dateInfo(rex, year, month, day, separator){
  var infoObj = new Object;
  infoObj.rex = new RegExp(rex);
  infoObj.y = year;
  infoObj.m = month;
  infoObj.d = day;
  infoObj.s = separator;
  return infoObj;
}

/* Filters */

// This global objects store all the info required for filters
var tmt_globalFilters = new Object;
tmt_globalFilters.ltrim = tmt_filterInfo("^(\\s*)(\\b[\\w\\W]*)$", "$2");
tmt_globalFilters.rtrim = tmt_filterInfo("^([\\w\\W]*)(\\b\\s*)$", "$1");
tmt_globalFilters.nospaces = tmt_filterInfo("\\s*", "");
tmt_globalFilters.nocommas = tmt_filterInfo(",", "");
tmt_globalFilters.nodots = tmt_filterInfo("\\.", "");
tmt_globalFilters.noquotes = tmt_filterInfo("'", "");
tmt_globalFilters.nodoublequotes = tmt_filterInfo('"', "");
tmt_globalFilters.nohtml = tmt_filterInfo("<[^>]*>", "");
tmt_globalFilters.alphanumericonly = tmt_filterInfo("[^\\w]", "");
tmt_globalFilters.numbersonly = tmt_filterInfo("[^\\d]", "");
tmt_globalFilters.lettersonly = tmt_filterInfo("[^a-zA-Z]", "");
tmt_globalFilters.commastodots = tmt_filterInfo(",", ".");
tmt_globalFilters.dotstocommas = tmt_filterInfo("\\.", ",");
tmt_globalFilters.numberscommas = tmt_filterInfo("[^\\d,]", "");
tmt_globalFilters.numbersdots = tmt_filterInfo("[^\\d\\.]", "");

// Create an object that stores filters's info
function tmt_filterInfo(rex, replaceStr){
  var infoObj = new Object;
  infoObj.rex = new RegExp(rex, "g");
  infoObj.str = replaceStr;
  return infoObj;
}

// Clean up the field based on filter's info
function tmt_filterField(fieldNode){
  var filtersArray = fieldNode.getAttribute("tmt:filters").split(",");
  for(var i=0; i<filtersArray.length; i++){
    var filtObj = tmt_globalFilters[filtersArray[i]];
    // Be sure we have the filter's data, then clean up
    if(filtObj){
      fieldNode.value = fieldNode.value.replace(filtObj.rex, filtObj.str)
    }
    // We handle demoroziner as a special case
    if(filtersArray[i] == "demoronizer"){
      fieldNode.value = tmt_filterDemoronizer(fieldNode.value);
    }
  }
}

// Replace MS Word's non-ISO characters with plausible substitutes
function tmt_filterDemoronizer(str){
  str = str.replace(new RegExp(String.fromCharCode(710), "g"), "^");
  str = str.replace(new RegExp(String.fromCharCode(732), "g"), "~");
  // Evil "smarty" quotes
  str = str.replace(new RegExp(String.fromCharCode(8216), "g"), "'");
  str = str.replace(new RegExp(String.fromCharCode(8217), "g"), "'");
  str = str.replace(new RegExp(String.fromCharCode(8220), "g"), '"');
  str = str.replace(new RegExp(String.fromCharCode(8221), "g"), '"');
  // More MS Word's garbage
  str = str.replace(new RegExp(String.fromCharCode(8211), "g"), "-");
  str = str.replace(new RegExp(String.fromCharCode(8212), "g"), "--");
  str = str.replace(new RegExp(String.fromCharCode(8218), "g"), ",");
  str = str.replace(new RegExp(String.fromCharCode(8222), "g"), ",,");
  str = str.replace(new RegExp(String.fromCharCode(8226), "g"), "*");
  str = str.replace(new RegExp(String.fromCharCode(8230), "g"), "...");
  str = str.replace(new RegExp(String.fromCharCode(8364), "g"), "€");
  return str;
}

/* Helper functions */

// Get an array of submit button nodes contained inside a given node
function tmt_getSubmitNodes(startNode){
  var submitArray = new Array();
  var inputNodes = startNode.getElementsByTagName("input");
  // Get an array of submit nodes
  for(var i=0; i<inputNodes.length; i++){
    if(inputNodes[i].getAttribute("type").toLowerCase() == "submit"){
      submitArray[submitArray.length] = inputNodes[i];
    }
  }
  return submitArray;
}

// Get an array of input and textarea nodes contained inside a given node
function tmt_getTextfieldNodes(startNode){
  var inputsArray = new Array();
  var inputNodes = startNode.getElementsByTagName("input");
  var areaNodes = startNode.getElementsByTagName("textarea");
  // Get an array of text, password and file nodes
  for(var i=0; i<inputNodes.length; i++){
    if(!inputNodes[i].getAttribute("type")){
      inputNodes[i].setAttribute("type", "text");
    }
    var fieldType = inputNodes[i].getAttribute("type").toLowerCase();
    if((fieldType == "text") || (fieldType == "password") || (fieldType == "file") || (fieldType == "hidden")){
      inputsArray[inputsArray.length] = inputNodes[i];
    }
  }
  // Append textarea nodes too
  for(var j=0; j<areaNodes.length; j++){
      inputsArray[inputsArray.length] = areaNodes[j];
  }
  return inputsArray;
}

// Return an object (sort of an hashtable) containing checkboxes/radios data
// The returned object has two properties:
// name: the group name
// boxes: an array containing the DOM node of each checkbox/radio that share the same name
function tmt_getNodesTable(formNode, type){
  // This object will store data fields, just as an hash table
  var boxHolder = new Object;
  var boxNodes = formNode.getElementsByTagName("input");
  for(var i=0; i<boxNodes.length; i++){
    if(boxNodes[i].getAttribute("type") && (boxNodes[i].getAttribute("type").toLowerCase() == type)){
      // Store the reference to make it easier to read the code
      var boxName = boxNodes[i].name;
      if(boxHolder[boxName]){
        // We already have an entry with the same name
        // Append the DOM node to the relevant entry inside the object
        boxHolder[boxName].elements[boxHolder[boxName].elements.length] = boxNodes[i];
      }
      else{
        // Create a brand new entry inside the object
        boxHolder[boxName] = new Object;
        boxHolder[boxName].name = boxName;
        // Initialize the array that will store all the DOM nodes that share the same name
        boxHolder[boxName].elements = new Array;
        boxHolder[boxName].elements[0] = boxNodes[i];
      }
    }
  }
  return boxHolder;
}

// The function below was developed by John Resig
// For additional info see:
// http://ejohn.org/projects/flexible-javascript-events
// http://www.quirksmode.org/blog/archives/2005/10/_and_the_winner_1.html
function addEvent(obj, type, fn){
  if(obj.addEventListener){
    obj.addEventListener(type, fn, false);
  }
  else if(obj.attachEvent){
    obj["e" + type + fn] = fn;
    obj[type + fn] = function(){
        obj["e" + type + fn](window.event);
      }
    obj.attachEvent("on" +type, obj[type+fn]);
  }
}

//addEvent(window, "load", tmt_validatorInit);