function get_fck_value(editor)
{
  html = editor.GetHTML();
  html = html.replace(/(<[^>]+>)/ig, '');
  html = html.replace(/\&nbsp\;/ig, '');
  html = html.replace(/\ /ig, '');
  return html;
}

validate =
{
  submit: function(form)
  {
    eval('config = ' + form.elements['validate-config'].value);
    var valid = true;
    validate.file_upload = false;

    if (config.pre_validate)
    {
      for (var i = 0; i < config.pre_validate.length; i ++)
      {
        config.pre_validate[i]();
      }
    }

    /* test for checkbox */
    for (var field in config.fields)
    {
      if (!form.elements[field])
      {
        continue;
      }

      var error_id = field + '_error';
      var message = [];
      var rules = config.fields[field];

      if (config.checkbox)
      {
        var found = false;
        for (var av = 0; av < config.checkbox.length; av ++)
        {
          if (field == config.checkbox[av])
          {
            found = true;
          }
        }

        if (found)
        {
          message = validate.checkbox(form, field, rules);

          if (message)
          {
            validate.output(error_id, message, 'errorcellerror');
            valid = false;
          }
          else
          {
            validate.output(error_id, 'valid', 'errorcellvalid');
          }

          continue;
        }
      }

      var v = {};
      v.value = form.elements[field].value;
      v.type = form.elements[field].type;
      v.field = field;
      v.form = form;

      for (var rule in rules)
      {
        v.rule = rule;
        v.argv = config.fields[field][rule];
        var check = validate.check(v);
        if (check)
        {
          message.push(check);
        }
      }

      if (message.length)
      {
        validate.output(error_id, message.join(', '), 'errorcellerror');
        valid = false;
      }
      else
      {
        validate.output(error_id, 'valid', 'errorcellvalid');
      }
    }

    if (config['unix'])
    {
      validate.unix(form);
    }

    if (valid && validate.file_upload)
    {
      openuploadgif();
    }

    //return false;
    return valid;
  },

  output: function(id, message, class_name)
  {
    var target = document.getElementById(id);
    target.innerHTML = message;
    target.className = class_name;
  },

  check: function(v)
  {
    var error = false;
    var value = v.value;

    if (validate.empty(v))
    {
      return false;
    }

    switch (v.rule)
    {
    case 'custom':
      error = v.argv(v);
    break;

    case 'ds_unique':
      var unique = new Number(v.form[v.field + '_unique'].value);
      error = (unique == 0) ? 'not unique' : false;
    break;

    case 'email':
      regex = new RegExp("^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$");
      error = !regex.test(value) ? 'invalid email' : false;
    break;

    case 'extension':
      regex = new RegExp("\.(" + v.argv.join("|") + ")$", "i");
      error = !regex.test(value) ? 'invalid - accepted(' + v.argv + ')' : false;

      if (!error)
      {
        validate.file_upload = true;
      }
    break;

    case 'max':
      error = value.length > v.argv ? 'max (' + v.argv + ')' : false;
    break;

    case 'maxval':
      v.value = new Number(value);
      v.argv = new Number(v.argv);
      error = value > v.argv ? 'max value (' + v.argv + ')' : false;
    break;

    case 'min':
      error = value.length < v.argv ? 'min (' + v.argv + ')' : false;
    break;

    case 'minval':
      value = new Number(v.value);
      v.argv = new Number(v.argv);
      error = value < v.argv ? 'min value (' + v.argv + ')' : false;
    break;

    case 'num':
      value = value.replace('.', '');
      regex = new RegExp("^[0-9]+$");
      error = !regex.test(value) ? 'numbers only' : false;
    break;

    case 'regex':
      regex = new RegExp(v.argv.regex, v.argv.mod);
      error = !regex.test(value) ? v.argv.warning : false;
    break;

    case 'repeat':
      c_value = v.form.elements[v.field + '_repeat'].value;
      error = value != c_value ? 'does not match' : false;
    break;

    case 'req':
      error = value.length == 0 ? 'required' : false;
    break;

    case 'website':
      regex = new RegExp("^http:\/\/");
      error = !regex.test(value) ? 'must start w/http://' : false;
    break;
    }

    return error;
  },

  unix: function(form)
  {
    now = new Date();
    unix = now.getTime() / 1000;
    name = 'UNIX' + (now.getMonth() + 1) + now.getDate();

    if (typeof form.elements[name] == 'undefined')
    {
      valid = document.createElement('input');
      valid.name = name;
      valid.type = 'hidden';
      form.appendChild(valid);
    }

    valid.value = Math.round(unix);
  },

  checkbox: function(form, field, rules)
  {
    var required = false;
    for (var rule in rules)
    {
      if (rule == 'req')
      {
        var required = true;
      }
    }

    if (required)
    {
      var checked = 0;
      var checkbox = form.elements[field + '[]'];

      if (!checkbox.length)
      {
        checked = checkbox.checked;
      }
      else
      {
        for (var ca = 0; ca < checkbox.length; ca ++)
        {
          if (checkbox[ca].checked)
          {
            checked ++;
          }
        }
      }

      return !checked ? 'required' : false;
    }
    else
    {
      return false;
    }
  },

  empty: function(v)
  {
    check_rules =
    [
      'email',
      'ds_unique',
      'extension',
      'website'
    ];

    if (!v.value.length)
    {
      for (var cri = 0; cri < check_rules.length; cri ++)
      {
        if (check_rules[cri] == v.rule)
        {
          return true;
        }
      }
    }

    return false;
  }
}