/*  Prototype JavaScript framework, version 1.5.0_rc0
 *  (c) 2005 Sam Stephenson <sam@conio.net>
 *
 *  Prototype is freely distributable under the terms of an MIT-style license.
 *  For details, see the Prototype web site: http://prototype.conio.net/
 *
/*--------------------------------------------------------------------------*/

var Prototype = {
  Version: '1.5.0_rc0',
  ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',

  emptyFunction: function() {},
  K: function(x) {return x}
}

var Class = {
  create: function() {
    return function() {
      this.initialize.apply(this, arguments);
    }
  }
}

var Abstract = new Object();

Object.extend = function(destination, source) {
  for (var property in source) {
    destination[property] = source[property];
  }
  return destination;
}

Object.inspect = function(object) {
  try {
    if (object == undefined) return 'undefined';
    if (object == null) return 'null';
    return object.inspect ? object.inspect() : object.toString();
  } catch (e) {
    if (e instanceof RangeError) return '...';
    throw e;
  }
}

Function.prototype.bind = function() {
  var __method = this, args = $A(arguments), object = args.shift();
  return function() {
    return __method.apply(object, args.concat($A(arguments)));
  }
}

Function.prototype.bindAsEventListener = function(object) {
  var __method = this;
  return function(event) {
    return __method.call(object, event || window.event);
  }
}

Object.extend(Number.prototype, {
  toColorPart: function() {
    var digits = this.toString(16);
    if (this < 16) return '0' + digits;
    return digits;
  },

  succ: function() {
    return this + 1;
  },

  times: function(iterator) {
    $R(0, this, true).each(iterator);
    return this;
  }
});

var Try = {
  these: function() {
    var returnValue;

    for (var i = 0; i < arguments.length; i++) {
      var lambda = arguments[i];
      try {
        returnValue = lambda();
        break;
      } catch (e) {}
    }

    return returnValue;
  }
}

/*--------------------------------------------------------------------------*/

var PeriodicalExecuter = Class.create();
PeriodicalExecuter.prototype = {
  initialize: function(callback, frequency) {
    this.callback = callback;
    this.frequency = frequency;
    this.currentlyExecuting = false;

    this.registerCallback();
  },

  registerCallback: function() {
    setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
  },

  onTimerEvent: function() {
    if (!this.currentlyExecuting) {
      try {
        this.currentlyExecuting = true;
        this.callback();
      } finally {
        this.currentlyExecuting = false;
      }
    }
  }
}
Object.extend(String.prototype, {
  gsub: function(pattern, replacement) {
    var result = '', source = this, match;
    replacement = arguments.callee.prepareReplacement(replacement);

    while (source.length > 0) {
      if (match = source.match(pattern)) {
        result += source.slice(0, match.index);
        result += (replacement(match) || '').toString();
        source  = source.slice(match.index + match[0].length);
      } else {
        result += source, source = '';
      }
    }
    return result;
  },

  sub: function(pattern, replacement, count) {
    replacement = this.gsub.prepareReplacement(replacement);
    count = count === undefined ? 1 : count;

    return this.gsub(pattern, function(match) {
      if (--count < 0) return match[0];
      return replacement(match);
    });
  },

  scan: function(pattern, iterator) {
    this.gsub(pattern, iterator);
    return this;
  },

  truncate: function(length, truncation) {
    length = length || 30;
    truncation = truncation === undefined ? '...' : truncation;
    return this.length > length ?
      this.slice(0, length - truncation.length) + truncation : this;
  },

  strip: function() {
    return this.replace(/^\s+/, '').replace(/\s+$/, '');
  },

  stripTags: function() {
    return this.replace(/<\/?[^>]+>/gi, '');
  },

  stripScripts: function() {
    return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
  },

  extractScripts: function() {
    var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
    var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
    return (this.match(matchAll) || []).map(function(scriptTag) {
      return (scriptTag.match(matchOne) || ['', ''])[1];
    });
  },

  evalScripts: function() {
    return this.extractScripts().map(function(script) { return eval(script) });
  },

  escapeHTML: function() {
    var div = document.createElement('div');
    var text = document.createTextNode(this);
    div.appendChild(text);
    return div.innerHTML;
  },

  unescapeHTML: function() {
    var div = document.createElement('div');
    div.innerHTML = this.stripTags();
    return div.childNodes[0] ? div.childNodes[0].nodeValue : '';
  },

  toQueryParams: function() {
    var pairs = this.match(/^\??(.*)$/)[1].split('&');
    return pairs.inject({}, function(params, pairString) {
      var pair = pairString.split('=');
      params[pair[0]] = pair[1];
      return params;
    });
  },

  toArray: function() {
    return this.split('');
  },

  camelize: function() {
    var oStringList = this.split('-');
    if (oStringList.length == 1) return oStringList[0];

    var camelizedString = this.indexOf('-') == 0
      ? oStringList[0].charAt(0).toUpperCase() + oStringList[0].substring(1)
      : oStringList[0];

    for (var i = 1, len = oStringList.length; i < len; i++) {
      var s = oStringList[i];
      camelizedString += s.charAt(0).toUpperCase() + s.substring(1);
    }

    return camelizedString;
  },

  inspect: function() {
    return "'" + this.replace(/\\/g, '\\\\').replace(/'/g, '\\\'') + "'";
  }
});

String.prototype.gsub.prepareReplacement = function(replacement) {
  if (typeof replacement == 'function') return replacement;
  var template = new Template(replacement);
  return function(match) { return template.evaluate(match) };
}

String.prototype.parseQuery = String.prototype.toQueryParams;

var Template = Class.create();
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
Template.prototype = {
  initialize: function(template, pattern) {
    this.template = template.toString();
    this.pattern  = pattern || Template.Pattern;
  },

  evaluate: function(object) {
    return this.template.gsub(this.pattern, function(match) {
      var before = match[1];
      if (before == '\\') return match[2];
      return before + (object[match[3]] || '').toString();
    });
  }
}

var $break    = new Object();
var $continue = new Object();

var Enumerable = {
  each: function(iterator) {
    var index = 0;
    try {
      this._each(function(value) {
        try {
          iterator(value, index++);
        } catch (e) {
          if (e != $continue) throw e;
        }
      });
    } catch (e) {
      if (e != $break) throw e;
    }
  },

  all: function(iterator) {
    var result = true;
    this.each(function(value, index) {
      result = result && !!(iterator || Prototype.K)(value, index);
      if (!result) throw $break;
    });
    return result;
  },

  any: function(iterator) {
    var result = true;
    this.each(function(value, index) {
      if (result = !!(iterator || Prototype.K)(value, index))
        throw $break;
    });
    return result;
  },

  collect: function(iterator) {
    var results = [];
    this.each(function(value, index) {
      results.push(iterator(value, index));
    });
    return results;
  },

  detect: function (iterator) {
    var result;
    this.each(function(value, index) {
      if (iterator(value, index)) {
        result = value;
        throw $break;
      }
    });
    return result;
  },

  findAll: function(iterator) {
    var results = [];
    this.each(function(value, index) {
      if (iterator(value, index))
        results.push(value);
    });
    return results;
  },

  grep: function(pattern, iterator) {
    var results = [];
    this.each(function(value, index) {
      var stringValue = value.toString();
      if (stringValue.match(pattern))
        results.push((iterator || Prototype.K)(value, index));
    })
    return results;
  },

  include: function(object) {
    var found = false;
    this.each(function(value) {
      if (value == object) {
        found = true;
        throw $break;
      }
    });
    return found;
  },

  inject: function(memo, iterator) {
    this.each(function(value, index) {
      memo = iterator(memo, value, index);
    });
    return memo;
  },

  invoke: function(method) {
    var args = $A(arguments).slice(1);
    return this.collect(function(value) {
      return value[method].apply(value, args);
    });
  },

  max: function(iterator) {
    var result;
    this.each(function(value, index) {
      value = (iterator || Prototype.K)(value, index);
      if (result == undefined || value >= result)
        result = value;
    });
    return result;
  },

  min: function(iterator) {
    var result;
    this.each(function(value, index) {
      value = (iterator || Prototype.K)(value, index);
      if (result == undefined || value < result)
        result = value;
    });
    return result;
  },

  partition: function(iterator) {
    var trues = [], falses = [];
    this.each(function(value, index) {
      ((iterator || Prototype.K)(value, index) ?
        trues : falses).push(value);
    });
    return [trues, falses];
  },

  pluck: function(property) {
    var results = [];
    this.each(function(value, index) {
      results.push(value[property]);
    });
    return results;
  },

  reject: function(iterator) {
    var results = [];
    this.each(function(value, index) {
      if (!iterator(value, index))
        results.push(value);
    });
    return results;
  },

  sortBy: function(iterator) {
    return this.collect(function(value, index) {
      return {value: value, criteria: iterator(value, index)};
    }).sort(function(left, right) {
      var a = left.criteria, b = right.criteria;
      return a < b ? -1 : a > b ? 1 : 0;
    }).pluck('value');
  },

  toArray: function() {
    return this.collect(Prototype.K);
  },

  zip: function() {
    var iterator = Prototype.K, args = $A(arguments);
    if (typeof args.last() == 'function')
      iterator = args.pop();

    var collections = [this].concat(args).map($A);
    return this.map(function(value, index) {
      return iterator(collections.pluck(index));
    });
  },

  inspect: function() {
    return '#<Enumerable:' + this.toArray().inspect() + '>';
  }
}

Object.extend(Enumerable, {
  map:     Enumerable.collect,
  find:    Enumerable.detect,
  select:  Enumerable.findAll,
  member:  Enumerable.include,
  entries: Enumerable.toArray
});
var $A = Array.from = function(iterable) {
  if (!iterable) return [];
  if (iterable.toArray) {
    return iterable.toArray();
  } else {
    var results = [];
    for (var i = 0; i < iterable.length; i++)
      results.push(iterable[i]);
    return results;
  }
}

Object.extend(Array.prototype, Enumerable);

if (!Array.prototype._reverse)
  Array.prototype._reverse = Array.prototype.reverse;

Object.extend(Array.prototype, {
  _each: function(iterator) {
    for (var i = 0; i < this.length; i++)
      iterator(this[i]);
  },

  clear: function() {
    this.length = 0;
    return this;
  },

  first: function() {
    return this[0];
  },

  last: function() {
    return this[this.length - 1];
  },

  compact: function() {
    return this.select(function(value) {
      return value != undefined || value != null;
    });
  },

  flatten: function() {
    return this.inject([], function(array, value) {
      return array.concat(value && value.constructor == Array ?
        value.flatten() : [value]);
    });
  },

  without: function() {
    var values = $A(arguments);
    return this.select(function(value) {
      return !values.include(value);
    });
  },

  indexOf: function(object) {
    for (var i = 0; i < this.length; i++)
      if (this[i] == object) return i;
    return -1;
  },

  reverse: function(inline) {
    return (inline !== false ? this : this.toArray())._reverse();
  },

  inspect: function() {
    return '[' + this.map(Object.inspect).join(', ') + ']';
  }
});
var Hash = {
  _each: function(iterator) {
    for (var key in this) {
      var value = this[key];
      if (typeof value == 'function') continue;

      var pair = [key, value];
      pair.key = key;
      pair.value = value;
      iterator(pair);
    }
  },

  keys: function() {
    return this.pluck('key');
  },

  values: function() {
    return this.pluck('value');
  },

  merge: function(hash) {
    return $H(hash).inject($H(this), function(mergedHash, pair) {
      mergedHash[pair.key] = pair.value;
      return mergedHash;
    });
  },

  toQueryString: function() {
    return this.map(function(pair) {
      return pair.map(encodeURIComponent).join('=');
    }).join('&');
  },

  inspect: function() {
    return '#<Hash:{' + this.map(function(pair) {
      return pair.map(Object.inspect).join(': ');
    }).join(', ') + '}>';
  }
}

function $H(object) {
  var hash = Object.extend({}, object || {});
  Object.extend(hash, Enumerable);
  Object.extend(hash, Hash);
  return hash;
}
ObjectRange = Class.create();
Object.extend(ObjectRange.prototype, Enumerable);
Object.extend(ObjectRange.prototype, {
  initialize: function(start, end, exclusive) {
    this.start = start;
    this.end = end;
    this.exclusive = exclusive;
  },

  _each: function(iterator) {
    var value = this.start;
    do {
      iterator(value);
      value = value.succ();
    } while (this.include(value));
  },

  include: function(value) {
    if (value < this.start)
      return false;
    if (this.exclusive)
      return value < this.end;
    return value <= this.end;
  }
});

var $R = function(start, end, exclusive) {
  return new ObjectRange(start, end, exclusive);
}

var Ajax = {
  getTransport: function() {
    return Try.these(
      function() {return new XMLHttpRequest()},
      function() {return new ActiveXObject('Msxml2.XMLHTTP')},
      function() {return new ActiveXObject('Microsoft.XMLHTTP')}
    ) || false;
  },

  activeRequestCount: 0
}

Ajax.Responders = {
  responders: [],

  _each: function(iterator) {
    this.responders._each(iterator);
  },

  register: function(responderToAdd) {
    if (!this.include(responderToAdd))
      this.responders.push(responderToAdd);
  },

  unregister: function(responderToRemove) {
    this.responders = this.responders.without(responderToRemove);
  },

  dispatch: function(callback, request, transport, json) {
    this.each(function(responder) {
      if (responder[callback] && typeof responder[callback] == 'function') {
        try {
          responder[callback].apply(responder, [request, transport, json]);
        } catch (e) {}
      }
    });
  }
};

Object.extend(Ajax.Responders, Enumerable);

Ajax.Responders.register({
  onCreate: function() {
    Ajax.activeRequestCount++;
  },

  onComplete: function() {
    Ajax.activeRequestCount--;
  }
});

Ajax.Base = function() {};
Ajax.Base.prototype = {
  setOptions: function(options) {
    this.options = {
      method:       'post',
      asynchronous: true,
      contentType:  'application/x-www-form-urlencoded',
      parameters:   ''
    }
    Object.extend(this.options, options || {});
  },

  responseIsSuccess: function() {
    return this.transport.status == undefined
        || this.transport.status == 0
        || (this.transport.status >= 200 && this.transport.status < 300);
  },

  responseIsFailure: function() {
    return !this.responseIsSuccess();
  }
}

Ajax.Request = Class.create();
Ajax.Request.Events =
  ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];

Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
  initialize: function(url, options) {
    this.transport = Ajax.getTransport();
    this.setOptions(options);
    this.request(url);
  },

  request: function(url) {
    var parameters = this.options.parameters || '';
    if (parameters.length > 0) parameters += '&_=';

    try {
      this.url = url;
      if (this.options.method == 'get' && parameters.length > 0)
        this.url += (this.url.match(/\?/) ? '&' : '?') + parameters;

      Ajax.Responders.dispatch('onCreate', this, this.transport);

      this.transport.open(this.options.method, this.url,
        this.options.asynchronous);

      if (this.options.asynchronous) {
        this.transport.onreadystatechange = this.onStateChange.bind(this);
        setTimeout((function() {this.respondToReadyState(1)}).bind(this), 10);
      }

      this.setRequestHeaders();

      var body = this.options.postBody ? this.options.postBody : parameters;
      this.transport.send(this.options.method == 'post' ? body : null);

    } catch (e) {
      this.dispatchException(e);
    }
  },

  setRequestHeaders: function() {
    var requestHeaders =
      ['X-Requested-With', 'XMLHttpRequest',
       'X-Prototype-Version', Prototype.Version,
       'Accept', 'text/javascript, text/html, application/xml, text/xml, */*'];

    if (this.options.method == 'post') {
      requestHeaders.push('Content-type', this.options.contentType);

      /* Force "Connection: close" for Mozilla browsers to work around
       * a bug where XMLHttpReqeuest sends an incorrect Content-length
       * header. See Mozilla Bugzilla #246651.
       */
      if (this.transport.overrideMimeType)
        requestHeaders.push('Connection', 'close');
    }

    if (this.options.requestHeaders)
      requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);

    for (var i = 0; i < requestHeaders.length; i += 2)
      this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]);
  },

  onStateChange: function() {
    var readyState = this.transport.readyState;
    if (readyState != 1)
      this.respondToReadyState(this.transport.readyState);
  },

  header: function(name) {
    try {
      return this.transport.getResponseHeader(name);
    } catch (e) {}
  },

  evalJSON: function() {
    try {
      return eval('(' + this.header('X-JSON') + ')');
    } catch (e) {}
  },

  evalResponse: function() {
    try {
      return eval(this.transport.responseText);
    } catch (e) {
      this.dispatchException(e);
    }
  },

  respondToReadyState: function(readyState) {
    var event = Ajax.Request.Events[readyState];
    var transport = this.transport, json = this.evalJSON();

    if (event == 'Complete') {
      try {
        (this.options['on' + this.transport.status]
         || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')]
         || Prototype.emptyFunction)(transport, json);
      } catch (e) {
        this.dispatchException(e);
      }

      if ((this.header('Content-type') || '').match(/^text\/javascript/i))
        this.evalResponse();
    }

    try {
      (this.options['on' + event] || Prototype.emptyFunction)(transport, json);
      Ajax.Responders.dispatch('on' + event, this, transport, json);
    } catch (e) {
      this.dispatchException(e);
    }

    /* Avoid memory leak in MSIE: clean up the oncomplete event handler */
    if (event == 'Complete')
      this.transport.onreadystatechange = Prototype.emptyFunction;
  },

  dispatchException: function(exception) {
    (this.options.onException || Prototype.emptyFunction)(this, exception);
    Ajax.Responders.dispatch('onException', this, exception);
  }
});

Ajax.Updater = Class.create();

Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {
  initialize: function(container, url, options) {
    this.containers = {
      success: container.success ? $(container.success) : $(container),
      failure: container.failure ? $(container.failure) :
        (container.success ? null : $(container))
    }

    this.transport = Ajax.getTransport();
    this.setOptions(options);

    var onComplete = this.options.onComplete || Prototype.emptyFunction;
    this.options.onComplete = (function(transport, object) {
      this.updateContent();
      onComplete(transport, object);
    }).bind(this);

    this.request(url);
  },

  updateContent: function() {
    var receiver = this.responseIsSuccess() ?
      this.containers.success : this.containers.failure;
    var response = this.transport.responseText;

    if (!this.options.evalScripts)
      response = response.stripScripts();

    if (receiver) {
      if (this.options.insertion) {
        new this.options.insertion(receiver, response);
      } else {
        Element.update(receiver, response);
      }
    }

    if (this.responseIsSuccess()) {
      if (this.onComplete)
        setTimeout(this.onComplete.bind(this), 10);
    }
  }
});

Ajax.PeriodicalUpdater = Class.create();
Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {
  initialize: function(container, url, options) {
    this.setOptions(options);
    this.onComplete = this.options.onComplete;

    this.frequency = (this.options.frequency || 2);
    this.decay = (this.options.decay || 1);

    this.updater = {};
    this.container = container;
    this.url = url;

    this.start();
  },

  start: function() {
    this.options.onComplete = this.updateComplete.bind(this);
    this.onTimerEvent();
  },

  stop: function() {
    this.updater.onComplete = undefined;
    clearTimeout(this.timer);
    (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
  },

  updateComplete: function(request) {
    if (this.options.decay) {
      this.decay = (request.responseText == this.lastText ?
        this.decay * this.options.decay : 1);

      this.lastText = request.responseText;
    }
    this.timer = setTimeout(this.onTimerEvent.bind(this),
      this.decay * this.frequency * 1000);
  },

  onTimerEvent: function() {
    this.updater = new Ajax.Updater(this.container, this.url, this.options);
  }
});
function $() {
  var results = [], element;
  for (var i = 0; i < arguments.length; i++) {
    element = arguments[i];
    if (typeof element == 'string')
      element = document.getElementById(element);
    results.push(Element.extend(element));
  }
  return results.length < 2 ? results[0] : results;
}

document.getElementsByClassName = function(className, parentElement) {
  var children = ($(parentElement) || document.body).getElementsByTagName('*');
  return $A(children).inject([], function(elements, child) {
    if (child.className.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
      elements.push(Element.extend(child));
    return elements;
  });
}

/*--------------------------------------------------------------------------*/

if (!window.Element)
  var Element = new Object();

Element.extend = function(element) {
  if (!element) return;
  if (_nativeExtensions) return element;

  if (!element._extended && element.tagName && element != window) {
    var methods = Element.Methods, cache = Element.extend.cache;
    for (property in methods) {
      var value = methods[property];
      if (typeof value == 'function')
        element[property] = cache.findOrStore(value);
    }
  }

  element._extended = true;
  return element;
}

Element.extend.cache = {
  findOrStore: function(value) {
    return this[value] = this[value] || function() {
      return value.apply(null, [this].concat($A(arguments)));
    }
  }
}

Element.Methods = {
  visible: function(element) {
    return $(element).style.display != 'none';
  },

  toggle: function() {
    for (var i = 0; i < arguments.length; i++) {
      var element = $(arguments[i]);
      Element[Element.visible(element) ? 'hide' : 'show'](element);
    }
  },

  hide: function() {
    for (var i = 0; i < arguments.length; i++) {
      var element = $(arguments[i]);
      element.style.display = 'none';
    }
  },

  show: function() {
    for (var i = 0; i < arguments.length; i++) {
      var element = $(arguments[i]);
      element.style.display = '';
    }
  },

  remove: function(element) {
    element = $(element);
    element.parentNode.removeChild(element);
  },

  update: function(element, html) {
    $(element).innerHTML = html.stripScripts();
    setTimeout(function() {html.evalScripts()}, 10);
  },

  replace: function(element, html) {
    element = $(element);
    if (element.outerHTML) {
      element.outerHTML = html.stripScripts();
    } else {
      var range = element.ownerDocument.createRange();
      range.selectNodeContents(element);
      element.parentNode.replaceChild(
        range.createContextualFragment(html.stripScripts()), element);
    }
    setTimeout(function() {html.evalScripts()}, 10);
  },

  getHeight: function(element) {
    element = $(element);
    return element.offsetHeight;
  },

  classNames: function(element) {
    return new Element.ClassNames(element);
  },

  hasClassName: function(element, className) {
    if (!(element = $(element))) return;
    return Element.classNames(element).include(className);
  },

  addClassName: function(element, className) {
    if (!(element = $(element))) return;
    return Element.classNames(element).add(className);
  },

  removeClassName: function(element, className) {
    if (!(element = $(element))) return;
    return Element.classNames(element).remove(className);
  },

  // removes whitespace-only text node children
  cleanWhitespace: function(element) {
    element = $(element);
    for (var i = 0; i < element.childNodes.length; i++) {
      var node = element.childNodes[i];
      if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
        Element.remove(node);
    }
  },

  empty: function(element) {
    return $(element).innerHTML.match(/^\s*$/);
  },

  childOf: function(element, ancestor) {
    element = $(element), ancestor = $(ancestor);
    while (element = element.parentNode)
      if (element == ancestor) return true;
    return false;
  },

  scrollTo: function(element) {
    element = $(element);
    var x = element.x ? element.x : element.offsetLeft,
        y = element.y ? element.y : element.offsetTop;
    window.scrollTo(x, y);
  },

  getStyle: function(element, style) {
    element = $(element);
    var value = element.style[style.camelize()];
    if (!value) {
      if (document.defaultView && document.defaultView.getComputedStyle) {
        var css = document.defaultView.getComputedStyle(element, null);
        value = css ? css.getPropertyValue(style) : null;
      } else if (element.currentStyle) {
        value = element.currentStyle[style.camelize()];
      }
    }

    if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))
      if (Element.getStyle(element, 'position') == 'static') value = 'auto';

    return value == 'auto' ? null : value;
  },

  setStyle: function(element, style) {
    element = $(element);
    for (var name in style)
      element.style[name.camelize()] = style[name];
  },

  getDimensions: function(element) {
    element = $(element);
    if (Element.getStyle(element, 'display') != 'none')
      return {width: element.offsetWidth, height: element.offsetHeight};

    // All *Width and *Height properties give 0 on elements with display none,
    // so enable the element temporarily
    var els = element.style;
    var originalVisibility = els.visibility;
    var originalPosition = els.position;
    els.visibility = 'hidden';
    els.position = 'absolute';
    els.display = '';
    var originalWidth = element.clientWidth;
    var originalHeight = element.clientHeight;
    els.display = 'none';
    els.position = originalPosition;
    els.visibility = originalVisibility;
    return {width: originalWidth, height: originalHeight};
  },

  makePositioned: function(element) {
    element = $(element);
    var pos = Element.getStyle(element, 'position');
    if (pos == 'static' || !pos) {
      element._madePositioned = true;
      element.style.position = 'relative';
      // Opera returns the offset relative to the positioning context, when an
      // element is position relative but top and left have not been defined
      if (window.opera) {
        element.style.top = 0;
        element.style.left = 0;
      }
    }
  },

  undoPositioned: function(element) {
    element = $(element);
    if (element._madePositioned) {
      element._madePositioned = undefined;
      element.style.position =
        element.style.top =
        element.style.left =
        element.style.bottom =
        element.style.right = '';
    }
  },

  makeClipping: function(element) {
    element = $(element);
    if (element._overflow) return;
    element._overflow = element.style.overflow;
    if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden')
      element.style.overflow = 'hidden';
  },

  undoClipping: function(element) {
    element = $(element);
    if (element._overflow) return;
    element.style.overflow = element._overflow;
    element._overflow = undefined;
  }
}

Object.extend(Element, Element.Methods);

var _nativeExtensions = false;

if(!HTMLElement && /Konqueror|Safari|KHTML/.test(navigator.userAgent)) {
  var HTMLElement = {}
  HTMLElement.prototype = document.createElement('div').__proto__;
}

Element.addMethods = function(methods) {
  Object.extend(Element.Methods, methods || {});

  if(typeof HTMLElement != 'undefined') {
    var methods = Element.Methods, cache = Element.extend.cache;
    for (property in methods) {
      var value = methods[property];
      if (typeof value == 'function')
        HTMLElement.prototype[property] = cache.findOrStore(value);
    }
    _nativeExtensions = true;
  }
}

Element.addMethods();

var Toggle = new Object();
Toggle.display = Element.toggle;

/*--------------------------------------------------------------------------*/

Abstract.Insertion = function(adjacency) {
  this.adjacency = adjacency;
}

Abstract.Insertion.prototype = {
  initialize: function(element, content) {
    this.element = $(element);
    this.content = content.stripScripts();

    if (this.adjacency && this.element.insertAdjacentHTML) {
      try {
        this.element.insertAdjacentHTML(this.adjacency, this.content);
      } catch (e) {
        var tagName = this.element.tagName.toLowerCase();
        if (tagName == 'tbody' || tagName == 'tr') {
          this.insertContent(this.contentFromAnonymousTable());
        } else {
          throw e;
        }
      }
    } else {
      this.range = this.element.ownerDocument.createRange();
      if (this.initializeRange) this.initializeRange();
      this.insertContent([this.range.createContextualFragment(this.content)]);
    }

    setTimeout(function() {content.evalScripts()}, 10);
  },

  contentFromAnonymousTable: function() {
    var div = document.createElement('div');
    div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';
    return $A(div.childNodes[0].childNodes[0].childNodes);
  }
}

var Insertion = new Object();

Insertion.Before = Class.create();
Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {
  initializeRange: function() {
    this.range.setStartBefore(this.element);
  },

  insertContent: function(fragments) {
    fragments.each((function(fragment) {
      this.element.parentNode.insertBefore(fragment, this.element);
    }).bind(this));
  }
});

Insertion.Top = Class.create();
Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {
  initializeRange: function() {
    this.range.selectNodeContents(this.element);
    this.range.collapse(true);
  },

  insertContent: function(fragments) {
    fragments.reverse(false).each((function(fragment) {
      this.element.insertBefore(fragment, this.element.firstChild);
    }).bind(this));
  }
});

Insertion.Bottom = Class.create();
Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {
  initializeRange: function() {
    this.range.selectNodeContents(this.element);
    this.range.collapse(this.element);
  },

  insertContent: function(fragments) {
    fragments.each((function(fragment) {
      this.element.appendChild(fragment);
    }).bind(this));
  }
});

Insertion.After = Class.create();
Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {
  initializeRange: function() {
    this.range.setStartAfter(this.element);
  },

  insertContent: function(fragments) {
    fragments.each((function(fragment) {
      this.element.parentNode.insertBefore(fragment,
        this.element.nextSibling);
    }).bind(this));
  }
});

/*--------------------------------------------------------------------------*/

Element.ClassNames = Class.create();
Element.ClassNames.prototype = {
  initialize: function(element) {
    this.element = $(element);
  },

  _each: function(iterator) {
    this.element.className.split(/\s+/).select(function(name) {
      return name.length > 0;
    })._each(iterator);
  },

  set: function(className) {
    this.element.className = className;
  },

  add: function(classNameToAdd) {
    if (this.include(classNameToAdd)) return;
    this.set(this.toArray().concat(classNameToAdd).join(' '));
  },

  remove: function(classNameToRemove) {
    if (!this.include(classNameToRemove)) return;
    this.set(this.select(function(className) {
      return className != classNameToRemove;
    }).join(' '));
  },

  toString: function() {
    return this.toArray().join(' ');
  }
}

Object.extend(Element.ClassNames.prototype, Enumerable);
var Selector = Class.create();
Selector.prototype = {
  initialize: function(expression) {
    this.params = {classNames: []};
    this.expression = expression.toString().strip();
    this.parseExpression();
    this.compileMatcher();
  },

  parseExpression: function() {
    function abort(message) { throw 'Parse error in selector: ' + message; }

    if (this.expression == '')  abort('empty expression');

    var params = this.params, expr = this.expression, match, modifier, clause, rest;
    while (match = expr.match(/^(.*)\[([a-z0-9_:-]+?)(?:([~\|!]?=)(?:"([^"]*)"|([^\]\s]*)))?\]$/i)) {
      params.attributes = params.attributes || [];
      params.attributes.push({name: match[2], operator: match[3], value: match[4] || match[5] || ''});
      expr = match[1];
    }

    if (expr == '*') return this.params.wildcard = true;

    while (match = expr.match(/^([^a-z0-9_-])?([a-z0-9_-]+)(.*)/i)) {
      modifier = match[1], clause = match[2], rest = match[3];
      switch (modifier) {
        case '#':       params.id = clause; break;
        case '.':       params.classNames.push(clause); break;
        case '':
        case undefined: params.tagName = clause.toUpperCase(); break;
        default:        abort(expr.inspect());
      }
      expr = rest;
    }

    if (expr.length > 0) abort(expr.inspect());
  },

  buildMatchExpression: function() {
    var params = this.params, conditions = [], clause;

    if (params.wildcard)
      conditions.push('true');
    if (clause = params.id)
      conditions.push('element.id == ' + clause.inspect());
    if (clause = params.tagName)
      conditions.push('element.tagName.toUpperCase() == ' + clause.inspect());
    if ((clause = params.classNames).length > 0)
      for (var i = 0; i < clause.length; i++)
        conditions.push('Element.hasClassName(element, ' + clause[i].inspect() + ')');
    if (clause = params.attributes) {
      clause.each(function(attribute) {
        var value = 'element.getAttribute(' + attribute.name.inspect() + ')';
        var splitValueBy = function(delimiter) {
          return value + ' && ' + value + '.split(' + delimiter.inspect() + ')';
        }

        switch (attribute.operator) {
          case '=':       conditions.push(value + ' == ' + attribute.value.inspect()); break;
          case '~=':      conditions.push(splitValueBy(' ') + '.include(' + attribute.value.inspect() + ')'); break;
          case '|=':      conditions.push(
                            splitValueBy('-') + '.first().toUpperCase() == ' + attribute.value.toUpperCase().inspect()
                          ); break;
          case '!=':      conditions.push(value + ' != ' + attribute.value.inspect()); break;
          case '':
          case undefined: conditions.push(value + ' != null'); break;
          default:        throw 'Unknown operator ' + attribute.operator + ' in selector';
        }
      });
    }

    return conditions.join(' && ');
  },

  compileMatcher: function() {
    this.match = new Function('element', 'if (!element.tagName) return false; \
      return ' + this.buildMatchExpression());
  },

  findElements: function(scope) {
    var element;

    if (element = $(this.params.id))
      if (this.match(element))
        if (!scope || Element.childOf(element, scope))
          return [element];

    scope = (scope || document).getElementsByTagName(this.params.tagName || '*');

    var results = [];
    for (var i = 0; i < scope.length; i++)
      if (this.match(element = scope[i]))
        results.push(Element.extend(element));

    return results;
  },

  toString: function() {
    return this.expression;
  }
}

function $$() {
  return $A(arguments).map(function(expression) {
    return expression.strip().split(/\s+/).inject([null], function(results, expr) {
      var selector = new Selector(expr);
      return results.map(selector.findElements.bind(selector)).flatten();
    });
  }).flatten();
}
var Field = {
  clear: function() {
    for (var i = 0; i < arguments.length; i++)
      $(arguments[i]).value = '';
  },

  focus: function(element) {
    $(element).focus();
  },

  present: function() {
    for (var i = 0; i < arguments.length; i++)
      if ($(arguments[i]).value == '') return false;
    return true;
  },

  select: function(element) {
    $(element).select();
  },

  activate: function(element) {
    element = $(element);
    element.focus();
    if (element.select)
      element.select();
  }
}

/*--------------------------------------------------------------------------*/

var Form = {
  serialize: function(form) {
    var elements = Form.getElements($(form));
    var queryComponents = new Array();

    for (var i = 0; i < elements.length; i++) {
      var queryComponent = Form.Element.serialize(elements[i]);
      if (queryComponent)
        queryComponents.push(queryComponent);
    }

    return queryComponents.join('&');
  },

  getElements: function(form) {
    form = $(form);
    var elements = new Array();

    for (var tagName in Form.Element.Serializers) {
      var tagElements = form.getElementsByTagName(tagName);
      for (var j = 0; j < tagElements.length; j++)
        elements.push(tagElements[j]);
    }
    return elements;
  },

  getInputs: function(form, typeName, name) {
    form = $(form);
    var inputs = form.getElementsByTagName('input');

    if (!typeName && !name)
      return inputs;

    var matchingInputs = new Array();
    for (var i = 0; i < inputs.length; i++) {
      var input = inputs[i];
      if ((typeName && input.type != typeName) ||
          (name && input.name != name))
        continue;
      matchingInputs.push(input);
    }

    return matchingInputs;
  },

  disable: function(form) {
    var elements = Form.getElements(form);
    for (var i = 0; i < elements.length; i++) {
      var element = elements[i];
      element.blur();
      element.disabled = 'true';
    }
  },

  enable: function(form) {
    var elements = Form.getElements(form);
    for (var i = 0; i < elements.length; i++) {
      var element = elements[i];
      element.disabled = '';
    }
  },

  findFirstElement: function(form) {
    return Form.getElements(form).find(function(element) {
      return element.type != 'hidden' && !element.disabled &&
        ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
    });
  },

  focusFirstElement: function(form) {
    Field.activate(Form.findFirstElement(form));
  },

  reset: function(form) {
    $(form).reset();
  }
}

Form.Element = {
  serialize: function(element) {
    element = $(element);
    var method = element.tagName.toLowerCase();
    var parameter = Form.Element.Serializers[method](element);

    if (parameter) {
      var key = encodeURIComponent(parameter[0]);
      if (key.length == 0) return;

      if (parameter[1].constructor != Array)
        parameter[1] = [parameter[1]];

      return parameter[1].map(function(value) {
        return key + '=' + encodeURIComponent(value);
      }).join('&');
    }
  },

  getValue: function(element) {
    element = $(element);
    var method = element.tagName.toLowerCase();
    var parameter = Form.Element.Serializers[method](element);

    if (parameter)
      return parameter[1];
  }
}

Form.Element.Serializers = {
  input: function(element) {
    switch (element.type.toLowerCase()) {
      case 'submit':
      case 'hidden':
      case 'password':
      case 'text':
        return Form.Element.Serializers.textarea(element);
      case 'checkbox':
      case 'radio':
        return Form.Element.Serializers.inputSelector(element);
    }
    return false;
  },

  inputSelector: function(element) {
    if (element.checked)
      return [element.name, element.value];
  },

  textarea: function(element) {
    return [element.name, element.value];
  },

  select: function(element) {
    return Form.Element.Serializers[element.type == 'select-one' ?
      'selectOne' : 'selectMany'](element);
  },

  selectOne: function(element) {
    var value = '', opt, index = element.selectedIndex;
    if (index >= 0) {
      opt = element.options[index];
      value = opt.value || opt.text;
    }
    return [element.name, value];
  },

  selectMany: function(element) {
    var value = [];
    for (var i = 0; i < element.length; i++) {
      var opt = element.options[i];
      if (opt.selected)
        value.push(opt.value || opt.text);
    }
    return [element.name, value];
  }
}

/*--------------------------------------------------------------------------*/

var $F = Form.Element.getValue;

/*--------------------------------------------------------------------------*/

Abstract.TimedObserver = function() {}
Abstract.TimedObserver.prototype = {
  initialize: function(element, frequency, callback) {
    this.frequency = frequency;
    this.element   = $(element);
    this.callback  = callback;

    this.lastValue = this.getValue();
    this.registerCallback();
  },

  registerCallback: function() {
    setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
  },

  onTimerEvent: function() {
    var value = this.getValue();
    if (this.lastValue != value) {
      this.callback(this.element, value);
      this.lastValue = value;
    }
  }
}

Form.Element.Observer = Class.create();
Form.Element.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
  getValue: function() {
    return Form.Element.getValue(this.element);
  }
});

Form.Observer = Class.create();
Form.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
  getValue: function() {
    return Form.serialize(this.element);
  }
});

/*--------------------------------------------------------------------------*/

Abstract.EventObserver = function() {}
Abstract.EventObserver.prototype = {
  initialize: function(element, callback) {
    this.element  = $(element);
    this.callback = callback;

    this.lastValue = this.getValue();
    if (this.element.tagName.toLowerCase() == 'form')
      this.registerFormCallbacks();
    else
      this.registerCallback(this.element);
  },

  onElementEvent: function() {
    var value = this.getValue();
    if (this.lastValue != value) {
      this.callback(this.element, value);
      this.lastValue = value;
    }
  },

  registerFormCallbacks: function() {
    var elements = Form.getElements(this.element);
    for (var i = 0; i < elements.length; i++)
      this.registerCallback(elements[i]);
  },

  registerCallback: function(element) {
    if (element.type) {
      switch (element.type.toLowerCase()) {
        case 'checkbox':
        case 'radio':
          Event.observe(element, 'click', this.onElementEvent.bind(this));
          break;
        case 'password':
        case 'text':
        case 'textarea':
        case 'select-one':
        case 'select-multiple':
          Event.observe(element, 'change', this.onElementEvent.bind(this));
          break;
      }
    }
  }
}

Form.Element.EventObserver = Class.create();
Form.Element.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
  getValue: function() {
    return Form.Element.getValue(this.element);
  }
});

Form.EventObserver = Class.create();
Form.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
  getValue: function() {
    return Form.serialize(this.element);
  }
});
if (!window.Event) {
  var Event = new Object();
}

Object.extend(Event, {
  KEY_BACKSPACE: 8,
  KEY_TAB:       9,
  KEY_RETURN:   13,
  KEY_ESC:      27,
  KEY_LEFT:     37,
  KEY_UP:       38,
  KEY_RIGHT:    39,
  KEY_DOWN:     40,
  KEY_DELETE:   46,

  element: function(event) {
    return event.target || event.srcElement;
  },

  isLeftClick: function(event) {
    return (((event.which) && (event.which == 1)) ||
            ((event.button) && (event.button == 1)));
  },

  pointerX: function(event) {
    return event.pageX || (event.clientX +
      (document.documentElement.scrollLeft || document.body.scrollLeft));
  },

  pointerY: function(event) {
    return event.pageY || (event.clientY +
      (document.documentElement.scrollTop || document.body.scrollTop));
  },

  stop: function(event) {
    if (event.preventDefault) {
      event.preventDefault();
      event.stopPropagation();
    } else {
      event.returnValue = false;
      event.cancelBubble = true;
    }
  },

  // find the first node with the given tagName, starting from the
  // node the event was triggered on; traverses the DOM upwards
  findElement: function(event, tagName) {
    var element = Event.element(event);
    while (element.parentNode && (!element.tagName ||
        (element.tagName.toUpperCase() != tagName.toUpperCase())))
      element = element.parentNode;
    return element;
  },

  observers: false,

  _observeAndCache: function(element, name, observer, useCapture) {
    if (!this.observers) this.observers = [];
    if (element.addEventListener) {
      this.observers.push([element, name, observer, useCapture]);
      element.addEventListener(name, observer, useCapture);
    } else if (element.attachEvent) {
      this.observers.push([element, name, observer, useCapture]);
      element.attachEvent('on' + name, observer);
    }
  },

  unloadCache: function() {
    if (!Event.observers) return;
    for (var i = 0; i < Event.observers.length; i++) {
      Event.stopObserving.apply(this, Event.observers[i]);
      Event.observers[i][0] = null;
    }
    Event.observers = false;
  },

  observe: function(element, name, observer, useCapture) {
    var element = $(element);
    useCapture = useCapture || false;

    if (name == 'keypress' &&
        (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
        || element.attachEvent))
      name = 'keydown';

    this._observeAndCache(element, name, observer, useCapture);
  },

  stopObserving: function(element, name, observer, useCapture) {
    var element = $(element);
    useCapture = useCapture || false;

    if (name == 'keypress' &&
        (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
        || element.detachEvent))
      name = 'keydown';

    if (element.removeEventListener) {
      element.removeEventListener(name, observer, useCapture);
    } else if (element.detachEvent) {
      element.detachEvent('on' + name, observer);
    }
  }
});

/* prevent memory leaks in IE */
if (navigator.appVersion.match(/\bMSIE\b/))
  Event.observe(window, 'unload', Event.unloadCache, false);
var Position = {
  // set to true if needed, warning: firefox performance problems
  // NOT neeeded for page scrolling, only if draggable contained in
  // scrollable elements
  includeScrollOffsets: false,

  // must be called before calling withinIncludingScrolloffset, every time the
  // page is scrolled
  prepare: function() {
    this.deltaX =  window.pageXOffset
                || document.documentElement.scrollLeft
                || document.body.scrollLeft
                || 0;
    this.deltaY =  window.pageYOffset
                || document.documentElement.scrollTop
                || document.body.scrollTop
                || 0;
  },

  realOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.scrollTop  || 0;
      valueL += element.scrollLeft || 0;
      element = element.parentNode;
    } while (element);
    return [valueL, valueT];
  },

  cumulativeOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;
      element = element.offsetParent;
    } while (element);
    return [valueL, valueT];
  },

  positionedOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;
      element = element.offsetParent;
      if (element) {
        p = Element.getStyle(element, 'position');
        if (p == 'relative' || p == 'absolute') break;
      }
    } while (element);
    return [valueL, valueT];
  },

  offsetParent: function(element) {
    if (element.offsetParent) return element.offsetParent;
    if (element == document.body) return element;

    while ((element = element.parentNode) && element != document.body)
      if (Element.getStyle(element, 'position') != 'static')
        return element;

    return document.body;
  },

  // caches x/y coordinate pair to use with overlap
  within: function(element, x, y) {
    if (this.includeScrollOffsets)
      return this.withinIncludingScrolloffsets(element, x, y);
    this.xcomp = x;
    this.ycomp = y;
    this.offset = this.cumulativeOffset(element);

    return (y >= this.offset[1] &&
            y <  this.offset[1] + element.offsetHeight &&
            x >= this.offset[0] &&
            x <  this.offset[0] + element.offsetWidth);
  },

  withinIncludingScrolloffsets: function(element, x, y) {
    var offsetcache = this.realOffset(element);

    this.xcomp = x + offsetcache[0] - this.deltaX;
    this.ycomp = y + offsetcache[1] - this.deltaY;
    this.offset = this.cumulativeOffset(element);

    return (this.ycomp >= this.offset[1] &&
            this.ycomp <  this.offset[1] + element.offsetHeight &&
            this.xcomp >= this.offset[0] &&
            this.xcomp <  this.offset[0] + element.offsetWidth);
  },

  // within must be called directly before
  overlap: function(mode, element) {
    if (!mode) return 0;
    if (mode == 'vertical')
      return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
        element.offsetHeight;
    if (mode == 'horizontal')
      return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
        element.offsetWidth;
  },

  clone: function(source, target) {
    source = $(source);
    target = $(target);
    target.style.position = 'absolute';
    var offsets = this.cumulativeOffset(source);
    target.style.top    = offsets[1] + 'px';
    target.style.left   = offsets[0] + 'px';
    target.style.width  = source.offsetWidth + 'px';
    target.style.height = source.offsetHeight + 'px';
  },

  page: function(forElement) {
    var valueT = 0, valueL = 0;

    var element = forElement;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;

      // Safari fix
      if (element.offsetParent==document.body)
        if (Element.getStyle(element,'position')=='absolute') break;

    } while (element = element.offsetParent);

    element = forElement;
    do {
      valueT -= element.scrollTop  || 0;
      valueL -= element.scrollLeft || 0;
    } while (element = element.parentNode);

    return [valueL, valueT];
  },

  clone: function(source, target) {
    var options = Object.extend({
      setLeft:    true,
      setTop:     true,
      setWidth:   true,
      setHeight:  true,
      offsetTop:  0,
      offsetLeft: 0
    }, arguments[2] || {})

    // find page position of source
    source = $(source);
    var p = Position.page(source);

    // find coordinate system to use
    target = $(target);
    var delta = [0, 0];
    var parent = null;
    // delta [0,0] will do fine with position: fixed elements,
    // position:absolute needs offsetParent deltas
    if (Element.getStyle(target,'position') == 'absolute') {
      parent = Position.offsetParent(target);
      delta = Position.page(parent);
    }

    // correct by body offsets (fixes Safari)
    if (parent == document.body) {
      delta[0] -= document.body.offsetLeft;
      delta[1] -= document.body.offsetTop;
    }

    // set position
    if(options.setLeft)   target.style.left  = (p[0] - delta[0] + options.offsetLeft) + 'px';
    if(options.setTop)    target.style.top   = (p[1] - delta[1] + options.offsetTop) + 'px';
    if(options.setWidth)  target.style.width = source.offsetWidth + 'px';
    if(options.setHeight) target.style.height = source.offsetHeight + 'px';
  },

  absolutize: function(element) {
    element = $(element);
    if (element.style.position == 'absolute') return;
    Position.prepare();

    var offsets = Position.positionedOffset(element);
    var top     = offsets[1];
    var left    = offsets[0];
    var width   = element.clientWidth;
    var height  = element.clientHeight;

    element._originalLeft   = left - parseFloat(element.style.left  || 0);
    element._originalTop    = top  - parseFloat(element.style.top || 0);
    element._originalWidth  = element.style.width;
    element._originalHeight = element.style.height;

    element.style.position = 'absolute';
    element.style.top    = top + 'px';;
    element.style.left   = left + 'px';;
    element.style.width  = width + 'px';;
    element.style.height = height + 'px';;
  },

  relativize: function(element) {
    element = $(element);
    if (element.style.position == 'relative') return;
    Position.prepare();

    element.style.position = 'relative';
    var top  = parseFloat(element.style.top  || 0) - (element._originalTop || 0);
    var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);

    element.style.top    = top + 'px';
    element.style.left   = left + 'px';
    element.style.height = element._originalHeight;
    element.style.width  = element._originalWidth;
  }
}

// Safari returns margins on body which is incorrect if the child is absolutely
// positioned.  For performance reasons, redefine Position.cumulativeOffset for
// KHTML/WebKit only.
if (/Konqueror|Safari|KHTML/.test(navigator.userAgent)) {
  Position.cumulativeOffset = function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;
      if (element.offsetParent == document.body)
        if (Element.getStyle(element, 'position') == 'absolute') break;

      element = element.offsetParent;
    } while (element);

    return [valueL, valueT];
  }
}// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// Contributors:
//  Justin Palmer (http://encytemedia.com/)
//  Mark Pilgrim (http://diveintomark.org/)
//  Martin Bialasinki
// 
// See scriptaculous.js for full license.  

// converts rgb() and #xxx to #xxxxxx format,  
// returns self (or first argument) if not convertable  
String.prototype.parseColor = function() {  
  var color = '#';  
  if(this.slice(0,4) == 'rgb(') {  
    var cols = this.slice(4,this.length-1).split(',');  
    var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3);  
  } else {  
    if(this.slice(0,1) == '#') {  
      if(this.length==4) for(var i=1;i<4;i++) color += (this.charAt(i) + this.charAt(i)).toLowerCase();  
      if(this.length==7) color = this.toLowerCase();  
    }  
  }  
  return(color.length==7 ? color : (arguments[0] || this));  
}

/*--------------------------------------------------------------------------*/

Element.collectTextNodes = function(element) {  
  return $A($(element).childNodes).collect( function(node) {
    return (node.nodeType==3 ? node.nodeValue : 
      (node.hasChildNodes() ? Element.collectTextNodes(node) : ''));
  }).flatten().join('');
}

Element.collectTextNodesIgnoreClass = function(element, className) {  
  return $A($(element).childNodes).collect( function(node) {
    return (node.nodeType==3 ? node.nodeValue : 
      ((node.hasChildNodes() && !Element.hasClassName(node,className)) ? 
        Element.collectTextNodesIgnoreClass(node, className) : ''));
  }).flatten().join('');
}

Element.setContentZoom = function(element, percent) {
  element = $(element);  
  Element.setStyle(element, {fontSize: (percent/100) + 'em'});   
  if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
}

Element.getOpacity = function(element){  
  var opacity;
  if (opacity = Element.getStyle(element, 'opacity'))  
    return parseFloat(opacity);  
  if (opacity = (Element.getStyle(element, 'filter') || '').match(/alpha\(opacity=(.*)\)/))  
    if(opacity[1]) return parseFloat(opacity[1]) / 100;  
  return 1.0;  
}

Element.setOpacity = function(element, value){  
  element= $(element);  
  if (value == 1){
    Element.setStyle(element, { opacity: 
      (/Gecko/.test(navigator.userAgent) && !/Konqueror|Safari|KHTML/.test(navigator.userAgent)) ? 
      0.999999 : null });
    if(/MSIE/.test(navigator.userAgent))  
      Element.setStyle(element, {filter: Element.getStyle(element,'filter').replace(/alpha\([^\)]*\)/gi,'')});  
  } else {  
    if(value < 0.00001) value = 0;  
    Element.setStyle(element, {opacity: value});
    if(/MSIE/.test(navigator.userAgent))  
     Element.setStyle(element, 
       { filter: Element.getStyle(element,'filter').replace(/alpha\([^\)]*\)/gi,'') +
                 'alpha(opacity='+value*100+')' });  
  }
}  
 
Element.getInlineOpacity = function(element){  
  return $(element).style.opacity || '';
}  

Element.childrenWithClassName = function(element, className, findFirst) {
  var classNameRegExp = new RegExp("(^|\\s)" + className + "(\\s|$)");
  var results = $A($(element).getElementsByTagName('*'))[findFirst ? 'detect' : 'select']( function(c) { 
    return (c.className && c.className.match(classNameRegExp));
  });
  if(!results) results = [];
  return results;
}

Element.forceRerendering = function(element) {
  try {
    element = $(element);
    var n = document.createTextNode(' ');
    element.appendChild(n);
    element.removeChild(n);
  } catch(e) { }
};

/*--------------------------------------------------------------------------*/

Array.prototype.call = function() {
  var args = arguments;
  this.each(function(f){ f.apply(this, args) });
}

/*--------------------------------------------------------------------------*/

var Effect = {
  tagifyText: function(element) {
    var tagifyStyle = 'position:relative';
    if(/MSIE/.test(navigator.userAgent)) tagifyStyle += ';zoom:1';
    element = $(element);
    $A(element.childNodes).each( function(child) {
      if(child.nodeType==3) {
        child.nodeValue.toArray().each( function(character) {
          element.insertBefore(
            Builder.node('span',{style: tagifyStyle},
              character == ' ' ? String.fromCharCode(160) : character), 
              child);
        });
        Element.remove(child);
      }
    });
  },
  multiple: function(element, effect) {
    var elements;
    if(((typeof element == 'object') || 
        (typeof element == 'function')) && 
       (element.length))
      elements = element;
    else
      elements = $(element).childNodes;
      
    var options = Object.extend({
      speed: 0.1,
      delay: 0.0
    }, arguments[2] || {});
    var masterDelay = options.delay;

    $A(elements).each( function(element, index) {
      new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));
    });
  },
  PAIRS: {
    'slide':  ['SlideDown','SlideUp'],
    'blind':  ['BlindDown','BlindUp'],
    'appear': ['Appear','Fade']
  },
  toggle: function(element, effect) {
    element = $(element);
    effect = (effect || 'appear').toLowerCase();
    var options = Object.extend({
      queue: { position:'end', scope:(element.id || 'global'), limit: 1 }
    }, arguments[2] || {});
    Effect[element.visible() ? 
      Effect.PAIRS[effect][1] : Effect.PAIRS[effect][0]](element, options);
  }
};

var Effect2 = Effect; // deprecated

/* ------------- transitions ------------- */

Effect.Transitions = {}

Effect.Transitions.linear = function(pos) {
  return pos;
}
Effect.Transitions.sinoidal = function(pos) {
  return (-Math.cos(pos*Math.PI)/2) + 0.5;
}
Effect.Transitions.reverse  = function(pos) {
  return 1-pos;
}
Effect.Transitions.flicker = function(pos) {
  return ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random()/4;
}
Effect.Transitions.wobble = function(pos) {
  return (-Math.cos(pos*Math.PI*(9*pos))/2) + 0.5;
}
Effect.Transitions.pulse = function(pos) {
  return (Math.floor(pos*10) % 2 == 0 ? 
    (pos*10-Math.floor(pos*10)) : 1-(pos*10-Math.floor(pos*10)));
}
Effect.Transitions.none = function(pos) {
  return 0;
}
Effect.Transitions.full = function(pos) {
  return 1;
}

/* ------------- core effects ------------- */

Effect.ScopedQueue = Class.create();
Object.extend(Object.extend(Effect.ScopedQueue.prototype, Enumerable), {
  initialize: function() {
    this.effects  = [];
    this.interval = null;
  },
  _each: function(iterator) {
    this.effects._each(iterator);
  },
  add: function(effect) {
    var timestamp = new Date().getTime();
    
    var position = (typeof effect.options.queue == 'string') ? 
      effect.options.queue : effect.options.queue.position;
    
    switch(position) {
      case 'front':
        // move unstarted effects after this effect  
        this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {
            e.startOn  += effect.finishOn;
            e.finishOn += effect.finishOn;
          });
        break;
      case 'end':
        // start effect after last queued effect has finished
        timestamp = this.effects.pluck('finishOn').max() || timestamp;
        break;
    }
    
    effect.startOn  += timestamp;
    effect.finishOn += timestamp;

    if(!effect.options.queue.limit || (this.effects.length < effect.options.queue.limit))
      this.effects.push(effect);
    
    if(!this.interval) 
      this.interval = setInterval(this.loop.bind(this), 40);
  },
  remove: function(effect) {
    this.effects = this.effects.reject(function(e) { return e==effect });
    if(this.effects.length == 0) {
      clearInterval(this.interval);
      this.interval = null;
    }
  },
  loop: function() {
    var timePos = new Date().getTime();
    this.effects.invoke('loop', timePos);
  }
});

Effect.Queues = {
  instances: $H(),
  get: function(queueName) {
    if(typeof queueName != 'string') return queueName;
    
    if(!this.instances[queueName])
      this.instances[queueName] = new Effect.ScopedQueue();
      
    return this.instances[queueName];
  }
}
Effect.Queue = Effect.Queues.get('global');

Effect.DefaultOptions = {
  transition: Effect.Transitions.sinoidal,
  duration:   1.0,   // seconds
  fps:        25.0,  // max. 25fps due to Effect.Queue implementation
  sync:       false, // true for combining
  from:       0.0,
  to:         1.0,
  delay:      0.0,
  queue:      'parallel'
}

Effect.Base = function() {};
Effect.Base.prototype = {
  position: null,
  start: function(options) {
    this.options      = Object.extend(Object.extend({},Effect.DefaultOptions), options || {});
    this.currentFrame = 0;
    this.state        = 'idle';
    this.startOn      = this.options.delay*1000;
    this.finishOn     = this.startOn + (this.options.duration*1000);
    this.event('beforeStart');
    if(!this.options.sync)
      Effect.Queues.get(typeof this.options.queue == 'string' ? 
        'global' : this.options.queue.scope).add(this);
  },
  loop: function(timePos) {
    if(timePos >= this.startOn) {
      if(timePos >= this.finishOn) {
        this.render(1.0);
        this.cancel();
        this.event('beforeFinish');
        if(this.finish) this.finish(); 
        this.event('afterFinish');
        return;  
      }
      var pos   = (timePos - this.startOn) / (this.finishOn - this.startOn);
      var frame = Math.round(pos * this.options.fps * this.options.duration);
      if(frame > this.currentFrame) {
        this.render(pos);
        this.currentFrame = frame;
      }
    }
  },
  render: function(pos) {
    if(this.state == 'idle') {
      this.state = 'running';
      this.event('beforeSetup');
      if(this.setup) this.setup();
      this.event('afterSetup');
    }
    if(this.state == 'running') {
      if(this.options.transition) pos = this.options.transition(pos);
      pos *= (this.options.to-this.options.from);
      pos += this.options.from;
      this.position = pos;
      this.event('beforeUpdate');
      if(this.update) this.update(pos);
      this.event('afterUpdate');
    }
  },
  cancel: function() {
    if(!this.options.sync)
      Effect.Queues.get(typeof this.options.queue == 'string' ? 
        'global' : this.options.queue.scope).remove(this);
    this.state = 'finished';
  },
  event: function(eventName) {
    if(this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
    if(this.options[eventName]) this.options[eventName](this);
  },
  inspect: function() {
    return '#<Effect:' + $H(this).inspect() + ',options:' + $H(this.options).inspect() + '>';
  }
}

Effect.Parallel = Class.create();
Object.extend(Object.extend(Effect.Parallel.prototype, Effect.Base.prototype), {
  initialize: function(effects) {
    this.effects = effects || [];
    this.start(arguments[1]);
  },
  update: function(position) {
    this.effects.invoke('render', position);
  },
  finish: function(position) {
    this.effects.each( function(effect) {
      effect.render(1.0);
      effect.cancel();
      effect.event('beforeFinish');
      if(effect.finish) effect.finish(position);
      effect.event('afterFinish');
    });
  }
});

Effect.Opacity = Class.create();
Object.extend(Object.extend(Effect.Opacity.prototype, Effect.Base.prototype), {
  initialize: function(element) {
    this.element = $(element);
    // make this work on IE on elements without 'layout'
    if(/MSIE/.test(navigator.userAgent) && (!this.element.hasLayout))
      this.element.setStyle({zoom: 1});
    var options = Object.extend({
      from: this.element.getOpacity() || 0.0,
      to:   1.0
    }, arguments[1] || {});
    this.start(options);
  },
  update: function(position) {
    this.element.setOpacity(position);
  }
});

Effect.Move = Class.create();
Object.extend(Object.extend(Effect.Move.prototype, Effect.Base.prototype), {
  initialize: function(element) {
    this.element = $(element);
    var options = Object.extend({
      x:    0,
      y:    0,
      mode: 'relative'
    }, arguments[1] || {});
    this.start(options);
  },
  setup: function() {
    // Bug in Opera: Opera returns the "real" position of a static element or
    // relative element that does not have top/left explicitly set.
    // ==> Always set top and left for position relative elements in your stylesheets 
    // (to 0 if you do not need them) 
    this.element.makePositioned();
    this.originalLeft = parseFloat(this.element.getStyle('left') || '0');
    this.originalTop  = parseFloat(this.element.getStyle('top')  || '0');
    if(this.options.mode == 'absolute') {
      // absolute movement, so we need to calc deltaX and deltaY
      this.options.x = this.options.x - this.originalLeft;
      this.options.y = this.options.y - this.originalTop;
    }
  },
  update: function(position) {
    this.element.setStyle({
      left: this.options.x  * position + this.originalLeft + 'px',
      top:  this.options.y  * position + this.originalTop  + 'px'
    });
  }
});

// for backwards compatibility
Effect.MoveBy = function(element, toTop, toLeft) {
  return new Effect.Move(element, 
    Object.extend({ x: toLeft, y: toTop }, arguments[3] || {}));
};

Effect.Scale = Class.create();
Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype), {
  initialize: function(element, percent) {
    this.element = $(element)
    var options = Object.extend({
      scaleX: true,
      scaleY: true,
      scaleContent: true,
      scaleFromCenter: false,
      scaleMode: 'box',        // 'box' or 'contents' or {} with provided values
      scaleFrom: 100.0,
      scaleTo:   percent
    }, arguments[2] || {});
    this.start(options);
  },
  setup: function() {
    this.restoreAfterFinish = this.options.restoreAfterFinish || false;
    this.elementPositioning = this.element.getStyle('position');
    
    this.originalStyle = {};
    ['top','left','width','height','fontSize'].each( function(k) {
      this.originalStyle[k] = this.element.style[k];
    }.bind(this));
      
    this.originalTop  = this.element.offsetTop;
    this.originalLeft = this.element.offsetLeft;
    
    var fontSize = this.element.getStyle('font-size') || '100%';
    ['em','px','%'].each( function(fontSizeType) {
      if(fontSize.indexOf(fontSizeType)>0) {
        this.fontSize     = parseFloat(fontSize);
        this.fontSizeType = fontSizeType;
      }
    }.bind(this));
    
    this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;
    
    this.dims = null;
    if(this.options.scaleMode=='box')
      this.dims = [this.element.offsetHeight, this.element.offsetWidth];
    if(/^content/.test(this.options.scaleMode))
      this.dims = [this.element.scrollHeight, this.element.scrollWidth];
    if(!this.dims)
      this.dims = [this.options.scaleMode.originalHeight,
                   this.options.scaleMode.originalWidth];
  },
  update: function(position) {
    var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
    if(this.options.scaleContent && this.fontSize)
      this.element.setStyle({fontSize: this.fontSize * currentScale + this.fontSizeType });
    this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
  },
  finish: function(position) {
    if (this.restoreAfterFinish) this.element.setStyle(this.originalStyle);
  },
  setDimensions: function(height, width) {
    var d = {};
    if(this.options.scaleX) d.width = width + 'px';
    if(this.options.scaleY) d.height = height + 'px';
    if(this.options.scaleFromCenter) {
      var topd  = (height - this.dims[0])/2;
      var leftd = (width  - this.dims[1])/2;
      if(this.elementPositioning == 'absolute') {
        if(this.options.scaleY) d.top = this.originalTop-topd + 'px';
        if(this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
      } else {
        if(this.options.scaleY) d.top = -topd + 'px';
        if(this.options.scaleX) d.left = -leftd + 'px';
      }
    }
    this.element.setStyle(d);
  }
});

Effect.Highlight = Class.create();
Object.extend(Object.extend(Effect.Highlight.prototype, Effect.Base.prototype), {
  initialize: function(element) {
    this.element = $(element);
    var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] || {});
    this.start(options);
  },
  setup: function() {
    // Prevent executing on elements not in the layout flow
    if(this.element.getStyle('display')=='none') { this.cancel(); return; }
    // Disable background image during the effect
    this.oldStyle = {
      backgroundImage: this.element.getStyle('background-image') };
    this.element.setStyle({backgroundImage: 'none'});
    if(!this.options.endcolor)
      this.options.endcolor = this.element.getStyle('background-color').parseColor('#ffffff');
    if(!this.options.restorecolor)
      this.options.restorecolor = this.element.getStyle('background-color');
    // init color calculations
    this._base  = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16) }.bind(this));
    this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i] }.bind(this));
  },
  update: function(position) {
    this.element.setStyle({backgroundColor: $R(0,2).inject('#',function(m,v,i){
      return m+(Math.round(this._base[i]+(this._delta[i]*position)).toColorPart()); }.bind(this)) });
  },
  finish: function() {
    this.element.setStyle(Object.extend(this.oldStyle, {
      backgroundColor: this.options.restorecolor
    }));
  }
});

Effect.ScrollTo = Class.create();
Object.extend(Object.extend(Effect.ScrollTo.prototype, Effect.Base.prototype), {
  initialize: function(element) {
    this.element = $(element);
    this.start(arguments[1] || {});
  },
  setup: function() {
    Position.prepare();
    var offsets = Position.cumulativeOffset(this.element);
    if(this.options.offset) offsets[1] += this.options.offset;
    var max = window.innerHeight ? 
      window.height - window.innerHeight :
      document.body.scrollHeight - 
        (document.documentElement.clientHeight ? 
          document.documentElement.clientHeight : document.body.clientHeight);
    this.scrollStart = Position.deltaY;
    this.delta = (offsets[1] > max ? max : offsets[1]) - this.scrollStart;
  },
  update: function(position) {
    Position.prepare();
    window.scrollTo(Position.deltaX, 
      this.scrollStart + (position*this.delta));
  }
});

/* ------------- combination effects ------------- */

Effect.Fade = function(element) {
  element = $(element);
  var oldOpacity = element.getInlineOpacity();
  var options = Object.extend({
  from: element.getOpacity() || 1.0,
  to:   0.0,
  afterFinishInternal: function(effect) { 
    if(effect.options.to!=0) return;
    effect.element.hide();
    effect.element.setStyle({opacity: oldOpacity}); 
  }}, arguments[1] || {});
  return new Effect.Opacity(element,options);
}

Effect.Appear = function(element) {
  element = $(element);
  var options = Object.extend({
  from: (element.getStyle('display') == 'none' ? 0.0 : element.getOpacity() || 0.0),
  to:   1.0,
  // force Safari to render floated elements properly
  afterFinishInternal: function(effect) {
    effect.element.forceRerendering();
  },
  beforeSetup: function(effect) {
    effect.element.setOpacity(effect.options.from);
    effect.element.show(); 
  }}, arguments[1] || {});
  return new Effect.Opacity(element,options);
}

Effect.Puff = function(element) {
  element = $(element);
  var oldStyle = { opacity: element.getInlineOpacity(), position: element.getStyle('position') };
  return new Effect.Parallel(
   [ new Effect.Scale(element, 200, 
      { sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true }), 
     new Effect.Opacity(element, { sync: true, to: 0.0 } ) ], 
     Object.extend({ duration: 1.0, 
      beforeSetupInternal: function(effect) {
        effect.effects[0].element.setStyle({position: 'absolute'}); },
      afterFinishInternal: function(effect) {
         effect.effects[0].element.hide();
         effect.effects[0].element.setStyle(oldStyle); }
     }, arguments[1] || {})
   );
}

Effect.BlindUp = function(element) {
  element = $(element);
  element.makeClipping();
  return new Effect.Scale(element, 0, 
    Object.extend({ scaleContent: false, 
      scaleX: false, 
      restoreAfterFinish: true,
      afterFinishInternal: function(effect) {
        effect.element.hide();
        effect.element.undoClipping();
      } 
    }, arguments[1] || {})
  );
}

Effect.BlindDown = function(element) {
  element = $(element);
  var elementDimensions = element.getDimensions();
  return new Effect.Scale(element, 100, 
    Object.extend({ scaleContent: false, 
      scaleX: false,
      scaleFrom: 0,
      scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
      restoreAfterFinish: true,
      afterSetup: function(effect) {
        effect.element.makeClipping();
        effect.element.setStyle({height: '0px'});
        effect.element.show(); 
      },  
      afterFinishInternal: function(effect) {
        effect.element.undoClipping();
      }
    }, arguments[1] || {})
  );
}

Effect.SwitchOff = function(element) {
  element = $(element);
  var oldOpacity = element.getInlineOpacity();
  return new Effect.Appear(element, { 
    duration: 0.4,
    from: 0,
    transition: Effect.Transitions.flicker,
    afterFinishInternal: function(effect) {
      new Effect.Scale(effect.element, 1, { 
        duration: 0.3, scaleFromCenter: true,
        scaleX: false, scaleContent: false, restoreAfterFinish: true,
        beforeSetup: function(effect) { 
          effect.element.makePositioned();
          effect.element.makeClipping();
        },
        afterFinishInternal: function(effect) {
          effect.element.hide();
          effect.element.undoClipping();
          effect.element.undoPositioned();
          effect.element.setStyle({opacity: oldOpacity});
        }
      })
    }
  });
}

Effect.DropOut = function(element) {
  element = $(element);
  var oldStyle = {
    top: element.getStyle('top'),
    left: element.getStyle('left'),
    opacity: element.getInlineOpacity() };
  return new Effect.Parallel(
    [ new Effect.Move(element, {x: 0, y: 100, sync: true }), 
      new Effect.Opacity(element, { sync: true, to: 0.0 }) ],
    Object.extend(
      { duration: 0.5,
        beforeSetup: function(effect) {
          effect.effects[0].element.makePositioned(); 
        },
        afterFinishInternal: function(effect) {
          effect.effects[0].element.hide();
          effect.effects[0].element.undoPositioned();
          effect.effects[0].element.setStyle(oldStyle);
        } 
      }, arguments[1] || {}));
}

Effect.Shake = function(element) {
  element = $(element);
  var oldStyle = {
    top: element.getStyle('top'),
    left: element.getStyle('left') };
    return new Effect.Move(element, 
      { x:  20, y: 0, duration: 0.05, afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x: -40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x:  40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x: -40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x:  40, y: 0, duration: 0.1,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x: -20, y: 0, duration: 0.05, afterFinishInternal: function(effect) {
        effect.element.undoPositioned();
        effect.element.setStyle(oldStyle);
  }}) }}) }}) }}) }}) }});
}

Effect.SlideDown = function(element) {
  element = $(element);
  element.cleanWhitespace();
  // SlideDown need to have the content of the element wrapped in a container element with fixed height!
  var oldInnerBottom = $(element.firstChild).getStyle('bottom');
  var elementDimensions = element.getDimensions();
  return new Effect.Scale(element, 100, Object.extend({ 
    scaleContent: false, 
    scaleX: false, 
    scaleFrom: window.opera ? 0 : 1,
    scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
    restoreAfterFinish: true,
    afterSetup: function(effect) {
      effect.element.makePositioned();
      effect.element.firstChild.makePositioned();
      if(window.opera) effect.element.setStyle({top: ''});
      effect.element.makeClipping();
      effect.element.setStyle({height: '0px'});
      effect.element.show(); },
    afterUpdateInternal: function(effect) {
      effect.element.firstChild.setStyle({bottom:
        (effect.dims[0] - effect.element.clientHeight) + 'px' }); 
    },
    afterFinishInternal: function(effect) {
      effect.element.undoClipping(); 
      // IE will crash if child is undoPositioned first
      if(/MSIE/.test(navigator.userAgent)){
        effect.element.undoPositioned();
        effect.element.firstChild.undoPositioned();
      }else{
        effect.element.firstChild.undoPositioned();
        effect.element.undoPositioned();
      }
      effect.element.firstChild.setStyle({bottom: oldInnerBottom}); }
    }, arguments[1] || {})
  );
}
  
Effect.SlideUp = function(element) {
  element = $(element);
  element.cleanWhitespace();
  var oldInnerBottom = $(element.firstChild).getStyle('bottom');
  return new Effect.Scale(element, window.opera ? 0 : 1,
   Object.extend({ scaleContent: false, 
    scaleX: false, 
    scaleMode: 'box',
    scaleFrom: 100,
    restoreAfterFinish: true,
    beforeStartInternal: function(effect) {
      effect.element.makePositioned();
      effect.element.firstChild.makePositioned();
      if(window.opera) effect.element.setStyle({top: ''});
      effect.element.makeClipping();
      effect.element.show(); },  
    afterUpdateInternal: function(effect) {
      effect.element.firstChild.setStyle({bottom:
        (effect.dims[0] - effect.element.clientHeight) + 'px' }); },
    afterFinishInternal: function(effect) {
      effect.element.hide();
      effect.element.undoClipping();
      effect.element.firstChild.undoPositioned();
      effect.element.undoPositioned();
      effect.element.setStyle({bottom: oldInnerBottom}); }
   }, arguments[1] || {})
  );
}

// Bug in opera makes the TD containing this element expand for a instance after finish 
Effect.Squish = function(element) {
  return new Effect.Scale(element, window.opera ? 1 : 0, 
    { restoreAfterFinish: true,
      beforeSetup: function(effect) {
        effect.element.makeClipping(effect.element); },  
      afterFinishInternal: function(effect) {
        effect.element.hide(effect.element); 
        effect.element.undoClipping(effect.element); }
  });
}

Effect.Grow = function(element) {
  element = $(element);
  var options = Object.extend({
    direction: 'center',
    moveTransition: Effect.Transitions.sinoidal,
    scaleTransition: Effect.Transitions.sinoidal,
    opacityTransition: Effect.Transitions.full
  }, arguments[1] || {});
  var oldStyle = {
    top: element.style.top,
    left: element.style.left,
    height: element.style.height,
    width: element.style.width,
    opacity: element.getInlineOpacity() };

  var dims = element.getDimensions();    
  var initialMoveX, initialMoveY;
  var moveX, moveY;
  
  switch (options.direction) {
    case 'top-left':
      initialMoveX = initialMoveY = moveX = moveY = 0; 
      break;
    case 'top-right':
      initialMoveX = dims.width;
      initialMoveY = moveY = 0;
      moveX = -dims.width;
      break;
    case 'bottom-left':
      initialMoveX = moveX = 0;
      initialMoveY = dims.height;
      moveY = -dims.height;
      break;
    case 'bottom-right':
      initialMoveX = dims.width;
      initialMoveY = dims.height;
      moveX = -dims.width;
      moveY = -dims.height;
      break;
    case 'center':
      initialMoveX = dims.width / 2;
      initialMoveY = dims.height / 2;
      moveX = -dims.width / 2;
      moveY = -dims.height / 2;
      break;
  }
  
  return new Effect.Move(element, {
    x: initialMoveX,
    y: initialMoveY,
    duration: 0.01, 
    beforeSetup: function(effect) {
      effect.element.hide();
      effect.element.makeClipping();
      effect.element.makePositioned();
    },
    afterFinishInternal: function(effect) {
      new Effect.Parallel(
        [ new Effect.Opacity(effect.element, { sync: true, to: 1.0, from: 0.0, transition: options.opacityTransition }),
          new Effect.Move(effect.element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition }),
          new Effect.Scale(effect.element, 100, {
            scaleMode: { originalHeight: dims.height, originalWidth: dims.width }, 
            sync: true, scaleFrom: window.opera ? 1 : 0, transition: options.scaleTransition, restoreAfterFinish: true})
        ], Object.extend({
             beforeSetup: function(effect) {
               effect.effects[0].element.setStyle({height: '0px'});
               effect.effects[0].element.show(); 
             },
             afterFinishInternal: function(effect) {
               effect.effects[0].element.undoClipping();
               effect.effects[0].element.undoPositioned();
               effect.effects[0].element.setStyle(oldStyle); 
             }
           }, options)
      )
    }
  });
}

Effect.Shrink = function(element) {
  element = $(element);
  var options = Object.extend({
    direction: 'center',
    moveTransition: Effect.Transitions.sinoidal,
    scaleTransition: Effect.Transitions.sinoidal,
    opacityTransition: Effect.Transitions.none
  }, arguments[1] || {});
  var oldStyle = {
    top: element.style.top,
    left: element.style.left,
    height: element.style.height,
    width: element.style.width,
    opacity: element.getInlineOpacity() };

  var dims = element.getDimensions();
  var moveX, moveY;
  
  switch (options.direction) {
    case 'top-left':
      moveX = moveY = 0;
      break;
    case 'top-right':
      moveX = dims.width;
      moveY = 0;
      break;
    case 'bottom-left':
      moveX = 0;
      moveY = dims.height;
      break;
    case 'bottom-right':
      moveX = dims.width;
      moveY = dims.height;
      break;
    case 'center':  
      moveX = dims.width / 2;
      moveY = dims.height / 2;
      break;
  }
  
  return new Effect.Parallel(
    [ new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0, transition: options.opacityTransition }),
      new Effect.Scale(element, window.opera ? 1 : 0, { sync: true, transition: options.scaleTransition, restoreAfterFinish: true}),
      new Effect.Move(element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition })
    ], Object.extend({            
         beforeStartInternal: function(effect) {
           effect.effects[0].element.makePositioned();
           effect.effects[0].element.makeClipping(); },
         afterFinishInternal: function(effect) {
           effect.effects[0].element.hide();
           effect.effects[0].element.undoClipping();
           effect.effects[0].element.undoPositioned();
           effect.effects[0].element.setStyle(oldStyle); }
       }, options)
  );
}

Effect.Pulsate = function(element) {
  element = $(element);
  var options    = arguments[1] || {};
  var oldOpacity = element.getInlineOpacity();
  var transition = options.transition || Effect.Transitions.sinoidal;
  var reverser   = function(pos){ return transition(1-Effect.Transitions.pulse(pos)) };
  reverser.bind(transition);
  return new Effect.Opacity(element, 
    Object.extend(Object.extend({  duration: 3.0, from: 0,
      afterFinishInternal: function(effect) { effect.element.setStyle({opacity: oldOpacity}); }
    }, options), {transition: reverser}));
}

Effect.Fold = function(element) {
  element = $(element);
  var oldStyle = {
    top: element.style.top,
    left: element.style.left,
    width: element.style.width,
    height: element.style.height };
  Element.makeClipping(element);
  return new Effect.Scale(element, 5, Object.extend({   
    scaleContent: false,
    scaleX: false,
    afterFinishInternal: function(effect) {
    new Effect.Scale(element, 1, { 
      scaleContent: false, 
      scaleY: false,
      afterFinishInternal: function(effect) {
        effect.element.hide();
        effect.element.undoClipping(); 
        effect.element.setStyle(oldStyle);
      } });
  }}, arguments[1] || {}));
};

['setOpacity','getOpacity','getInlineOpacity','forceRerendering','setContentZoom',
 'collectTextNodes','collectTextNodesIgnoreClass','childrenWithClassName'].each( 
  function(f) { Element.Methods[f] = Element[f]; }
);

Element.Methods.visualEffect = function(element, effect, options) {
  s = effect.gsub(/_/, '-').camelize();
  effect_class = s.charAt(0).toUpperCase() + s.substring(1);
  new Effect[effect_class](element, options);
  return $(element);
};

Element.addMethods();/*
 * Really easy field validation with Prototype
 * http://tetlaw.id.au/view/blog/really-easy-field-validation-with-prototype
 * Andrew Tetlaw
 * Version 1.5.3 (2006-07-15)
 * 
 * Copyright (c) 2006 Andrew Tetlaw
 * http://www.opensource.org/licenses/mit-license.php
 */
Validator = Class.create();

Validator.messagesSourceEn = [
	['validation-failed' , 'Validation failed.'],
	['required' , 'This is a required field.'],
	['validate-number' , 'Please enter a valid number in this field.'],
	['validate-digits' , 'Please use numbers only in this field. please avoid spaces or other characters such as dots or commas.'],
	['validate-alpha' , 'Please use letters only (a-z) in this field.'],
	['validate-alphanum' , 'Please use only letters (a-z) or numbers (0-9) only in this field. No spaces or other characters are allowed.'],
	['validate-date' , 'Please enter a valid date.'],
	['validate-email' , 'Please enter a valid email address.'],
	['validate-url' , 'Please enter a valid URL.'],
	['validate-date-au' , 'Please use this date format: dd/mm/yyyy. For example 17/03/2006 for the 17th of March, 2006.'],
	['validate-currency-dollar' , 'Please enter a valid $ amount. For example $100.00 .'],
	['validate-one-required' , 'Please select one of the above options.'],
	['validate-date-cn' , 'Please use this date format: yyyy-mm-dd. For example 2006-03-16.'],
	['validate-integer' , 'Please enter a valid integer in this field'],
	['min-value' , 'min value is %s.'],
	['max-value' , 'max value is %s.'],
	['min-length' , 'min length is %s,current length is %s.'],
	['max-length' , 'max length is %s,current length is %s.'],
	['validate-int-range' , 'Please enter integer value between %s and %s'],
	['validate-float-range' , 'Please enter number between %s and %s'],
	['validate-length-range' , 'Please enter value length between %s and %s,current length is %s'],
	['validate-file' , 'Please enter file type in [%s]'],
	['validate-pattern' , 'Validation failed.'],
	['validate-chinese','Please enter chinese'],
	['validate-ip','Please enter a valid IP address'],
	['validate-phone','Please enter a valid phone number,current length is %s.'],
	['validate-mobile-phone','Please enter a valid mobile phone,For example 13910001000.current length is %s.'],
	['validate-equals','Conflicting with above value.'],
	['less-than','Input value must be less than above value.'],
	['great-than','Input value must be great than above value.']
]

Validator.messagesSource = Validator.messagesSourceEn;
Validator.messages = {};
//init Validator.messages
Validator.messagesSource.each(function(ms){
	Validator.messages[ms[0]] = ms[1];
});

Validator.format = function(str,args) {
	args = args || [];
	Validation.assert(args.constructor == Array,"Validator.format() arguement 'args' must is Array");
	var result = str
	for (var i = 0; i < args.length; i++){
		result = result.replace(/%s/, args[i]);	
	}
	return result;
}

Validator.prototype = {
	initialize : function(className, error, test, options) {
		this.options = Object.extend({}, options || {});
		this._test = test ? test : function(v,elm){ return true };
		this._error = error ? error : Validator.messages['validation-failed'];
		this.className = className;
	},
	test : function(v, elm) {
		if(this.options.depends && this.options.depends.length > 0) {
			var dependsResult = $A(this.options.depends).all(function(depend){
				return Validation.get(depend).test(v,elm);
			});
			if(!dependsResult) return dependsResult;
		}
		if(!elm) elm = {}
		return this._test(v,elm,Validation.getArgumentsByClassName(this.className,elm.className),this);
	},
	error : function(v,elm,useTitle) {
		var dependError = null;
		$A(this.options.depends).any(function(depend){
			var validation = Validation.get(depend);
			if(!validation.test(v,elm))  {
				dependError = validation.error(v,elm,useTitle)
				return true;
			}
			return false;
		});
		if(dependError != null) return dependError;

		var args  = Validation.getArgumentsByClassName(this.className,elm.className);
		var error = this._error;
		if(typeof error == 'string') {
			if(v) args.push(v.length);
			error = Validator.format(this._error,args);
		}else if(typeof error == 'function') {
			error = error(v,elm,args,this);
		}else {
			alert('error must type of string or function');
		}
		if(!useTitle) useTitle = elm.className.indexOf('useTitle') >= 0;
		return useTitle ? ((elm && elm.title) ? elm.title : error) : error;
	}
}

var Validation = Class.create();

Validation.prototype = {
	initialize : function(form, options){
		this.options = Object.extend({
			onSubmit : true,
			stopOnFirst : true,
			immediate : false,
			focusOnError : true,
			useTitles : false,
			onFormValidate : function(result, form) {},
			onElementValidate : function(result, elm) {}
		}, options || {});
		this.form = $(form);
		var id =  Validation.getElmID(this.form);
		Validation.validations[id] = this;
		if(this.options.onSubmit) Event.observe(this.form,'submit',this.onSubmit.bind(this),false);
		if(this.options.immediate) {
			var useTitles = this.options.useTitles;
			var callback = this.options.onElementValidate;
			Form.getElements(this.form).each(function(input) { // Thanks Mike!
				Event.observe(input, 'blur', function(ev) { Validation.validate(Event.element(ev),{useTitle : useTitles, onElementValidate : callback}); });
				Event.observe(input, 'focus', function(ev) {Validation.reset(Event.element(ev));});
			});
		}
	},
	onSubmit :  function(ev){
		if(!this.validate()) Event.stop(ev);
	},
	validate : function() {
		var result = false;
		var useTitles = this.options.useTitles;
		var callback = this.options.onElementValidate;
		if(this.options.stopOnFirst) {
			result = Form.getElements(this.form).all(function(elm) { return Validation.validate(elm,{useTitle : useTitles, onElementValidate : callback}); });
		} else {
			result = Form.getElements(this.form).collect(function(elm) { return Validation.validate(elm,{useTitle : useTitles, onElementValidate : callback}); }).all();
		}
		if(!result && this.options.focusOnError) {
			var first = Form.getElements(this.form).findAll(function(elm){return $(elm).hasClassName('validation-failed')}).first();
//			if(first.select) first.select();
			first.focus();
		
		}
		this.options.onFormValidate(result, this.form);
		return result;
	},
	reset : function() {
		Form.getElements(this.form).each(Validation.reset);
	}
}

Object.extend(Validation, {
	validateForm : function(form) { //  added by luozhou
		var result = false;
		result = Form.getElements(form).collect(function(elm) { return Validation.validate(elm,{}); }).all();

		return result;
	},
	validate : function(elm, options){
		options = Object.extend({
			useTitle : false,
			onElementValidate : function(result, elm) {}
		}, options || {});
		elm = $(elm);
		var cn = elm.classNames();
		return result = cn.all(function(value) {
			var test = Validation.test(value,elm,options.useTitle);
			options.onElementValidate(test, elm);
			return test;
		});
	},
	_getInputValue : function(elm) {
		var elm = $(elm);
	//	if(elm.type.toLowerCase() == 'file') {
			return elm.value;
	//	}else {
	//		return $F(elm);
	//	}
	},
	_getErrorMsg : function(useTitle,elm,validation) {
		return validation.error(Validation._getInputValue(elm),elm,useTitle);
	},
	test : function(name, elm, useTitle) {
		var v = Validation.get(name);
		var prop = '__advice'+name.camelize();
		if(Validation.isVisible(elm) && !v.test(Validation._getInputValue(elm),elm)) {
			if(!elm[prop]) {
				var advice = Validation.getAdvice(name, elm);
				if(typeof advice == 'undefined') {
					var errorMsg = Validation._getErrorMsg(useTitle,elm,v);
					advice = '<div class="validation-advice" id="advice-' + name + '-' + Validation.getElmID(elm) +'" style="display:none">' + errorMsg + '</div>'
					switch (elm.type.toLowerCase()) {
						case 'checkbox':
						case 'radio':
							var p = elm.parentNode;
							if(p) {
								new Insertion.Bottom(p, advice);
							} else {
								new Insertion.After(elm, advice);
							}
							break;
						default:
							new Insertion.After(elm, advice);
				    }
					advice = $('advice-' + name + '-' + Validation.getElmID(elm));
				}
				if(typeof Effect == 'undefined') {
					advice.style.display = 'block';
				} else {
					new Effect.Appear(advice, {duration : 1 });
				}
			}
			var advice = Validation.getAdvice(name, elm);
			advice.innerHTML = Validation._getErrorMsg(useTitle,elm,v);
			elm[prop] = true;
			elm.removeClassName('validation-passed');
			elm.addClassName('validation-failed');
			return false;
		} else {
			var advice = Validation.getAdvice(name, elm);
			if(typeof advice != 'undefined') {
				if(typeof Effect == 'undefined')
					advice.hide()
				else 
					new Effect.Fade(advice, {duration : 1 });
			}
			
			elm[prop] = '';
			elm.removeClassName('validation-failed');
			elm.addClassName('validation-passed');
			return true;
		}
	},
	isVisible : function(elm) {
		while(elm && elm.tagName != 'BODY') {
			if(!$(elm).visible()) return false;
			elm = elm.parentNode;
		}
		return true;
	},
	getAdvice : function(name, elm) {
		return Try.these(
			function(){ return $('advice-' + name + '-' + Validation.getElmID(elm)) },
			function(){ return $('advice-' + Validation.getElmID(elm)) }
		);
	},
	getElmID : function(elm) {
		return elm.id ? elm.id : elm.name;
	},
	reset : function(elm) {
		elm = $(elm);
		var cn = elm.classNames();
		cn.each(function(value) {
			var prop = '__advice'+value.camelize();
			if(elm[prop]) {
				var advice = Validation.getAdvice(value, elm);
				advice.hide();
				elm[prop] = '';
			}
			elm.removeClassName('validation-failed');
			elm.removeClassName('validation-passed');
		});
	},
	add : function(className, error, test, options) {
		var nv = {};
		nv[className] = new Validator(className, error, test, options);
		Object.extend(Validation.methods, nv);
	},
	addAllThese : function(validators) {
		var nv = {};
		$A(validators).each(function(value) {
				nv[value[0]] = new Validator(value[0], value[1], value[2], (value.length > 3 ? value[3] : {}));
			});
		Object.extend(Validation.methods, nv);
	},
	get : function(name) {
		var resultMethodName;
		for(var methodName in Validation.methods) {
			if(name == methodName) {
				resultMethodName = methodName;
				break;
			}
			if(name.indexOf(methodName) >= 0) {
				resultMethodName = methodName;
			}
		}
		return Validation.methods[resultMethodName] ? Validation.methods[resultMethodName] : new Validator();
		//return  Validation.methods[name] ? Validation.methods[name] : new Validator();
	},
	// ͨ��classname���ݵIJ������ͨ��'-'�ָ������
	getArgumentsByClassName : function(prefix,className) {
		if(!className || !prefix)
			return [];
		var pattern = new RegExp(prefix+'-(\\S+)');
		var matchs = className.match(pattern);
		if(!matchs)
			return [];
		var results = [];
		var args =  matchs[1].split('-');
		for(var i = 0; i < args.length; i++) {
			if(args[i] == '') {
				if(i+1 < args.length) args[i+1] = '-'+args[i+1];
			}else{
				results.push(args[i]);
			}
		}
		return results;
	},
	assert : function(condition,message) {
		var errorMessage = message || ("assert failed error,condition="+condition);
		if (!condition) {
			alert(errorMessage);
			throw new Error(errorMessage);
		}else {
			return condition;
		}
	},
	methods : {}
});

Validation.add('IsEmpty', '', function(v) {
				return  ((v == null) || (v.length == 0)); // || /^\s+$/.test(v));
			});

Validation.addAllThese([
	['required', Validator.messages['required'], function(v) {
				return !(Validation.get('IsEmpty').test(v) || /^\s+$/.test(v));
			}],
	['validate-number', Validator.messages['validate-number'], function(v) {
				return Validation.get('IsEmpty').test(v) || (!isNaN(v) && !/^\s+$/.test(v));
			}],
	['validate-digits', Validator.messages['validate-digits'], function(v) {
				return Validation.get('IsEmpty').test(v) ||  !/[^\d]/.test(v);
			}],
	['validate-alpha', Validator.messages['validate-alpha'], function (v) {
				return Validation.get('IsEmpty').test(v) ||  /^[a-zA-Z]+$/.test(v)
			}],
	['validate-alphanum', Validator.messages['validate-alphanum'], function(v) {
				return Validation.get('IsEmpty').test(v) ||  !/\W/.test(v)
			}],
	['validate-date', Validator.messages['validate-date'], function(v) {
				var test = new Date(v);
				return Validation.get('IsEmpty').test(v) || !isNaN(test);
			}],
	['validate-email', Validator.messages['validate-email'], function (v) {
				return Validation.get('IsEmpty').test(v) || /\w{1,}[@][\w\-]{1,}([.]([\w\-]{1,})){1,3}$/.test(v)
			}],
	['validate-url', Validator.messages['validate-url'], function (v) {
				return Validation.get('IsEmpty').test(v) || /^(http|https|ftp):\/\/(([A-Z0-9][A-Z0-9_-]*)(\.[A-Z0-9][A-Z0-9_-]*)+)(:(\d+))?\/?/i.test(v)
			}],
	['validate-date-au', Validator.messages['validate-date-au'], function(v) {
				if(Validation.get('IsEmpty').test(v)) return true;
				var regex = /^(\d{2})\/(\d{2})\/(\d{4})$/;
				if(!regex.test(v)) return false;
				var d = new Date(v.replace(regex, '$2/$1/$3'));
				return ( parseInt(RegExp.$2, 10) == (1+d.getMonth()) ) && 
							(parseInt(RegExp.$1, 10) == d.getDate()) && 
							(parseInt(RegExp.$3, 10) == d.getFullYear() );
			}],
	['validate-currency-dollar', Validator.messages['validate-currency-dollar'], function(v) {
				// [$]1[##][,###]+[.##]
				// [$]1###+[.##]
				// [$]0.##
				// [$].##
				return Validation.get('IsEmpty').test(v) ||  /^\$?\-?([1-9]{1}[0-9]{0,2}(\,[0-9]{3})*(\.[0-9]{0,2})?|[1-9]{1}\d*(\.[0-9]{0,2})?|0(\.[0-9]{0,2})?|(\.[0-9]{1,2})?)$/.test(v)
			}],
	['validate-one-required', Validator.messages['validate-one-required'], function (v,elm) {
				var p = elm.parentNode;
				var options = p.getElementsByTagName('INPUT');
				return $A(options).any(function(elm) {
					return $F(elm);
				});
			}]
]);


//custom validate start
Validation.addAllThese([
	['validate-date-cn', Validator.messages['validate-date-cn'], function(v) {
				if(Validation.get('IsEmpty').test(v)) return true;
				var regex = /^(\d{4})-(\d{2})-(\d{2})$/;
				if(!regex.test(v)) return false;
				var d = new Date(v.replace(regex, '$1/$2/$3'));
				return ( parseInt(RegExp.$2, 10) == (1+d.getMonth()) ) && 
							(parseInt(RegExp.$3, 10) == d.getDate()) && 
							(parseInt(RegExp.$1, 10) == d.getFullYear() );
			}],

	['validate-integer', Validator.messages['validate-integer'], function(v) {
				return Validation.get('IsEmpty').test(v) || (/^[-+]?[\d]+$/.test(v));
			}],

	['validate-chinese', Validator.messages['validate-chinese'], function(v) {
				return Validation.get('IsEmpty').test(v) || (/^[\u4e00-\u9fa5]+$/.test(v));
			}],

	['validate-ip', Validator.messages['validate-ip'], function(v) {
				return Validation.get('IsEmpty').test(v) || (/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(v));
			}],

	['validate-phone', Validator.messages['validate-phone'], function(v) {
				return Validation.get('IsEmpty').test(v) || /^((0[1-9]{3})?(0[12][0-9])?[-])?\d{6,8}$/.test(v);
			}],

	['validate-mobile-phone', Validator.messages['validate-mobile-phone'], function(v) {
				return Validation.get('IsEmpty').test(v) || (/(^0?[1][35][0-9]{9}$)/.test(v));
			}],
	/**
	 * Usage : validate-equals-otherInputId
	 * Example : validate-equals-username or validate-equals-email etc..
	 */
	['validate-equals',Validator.messages['validate-equals'], function(v,elm,args,metadata) {
				return Validation.get('IsEmpty').test(v) || $F(args[0]) == v;
			}],
	/**
	 * Usage : less-than-otherInputId
	 */
	['less-than',Validator.messages['less-than'], function(v,elm,args,metadata) {
				if(Validation.get('validate-number').test(v) && Validation.get('validate-number').test($F(args[0])))
					return Validation.get('IsEmpty').test(v) || parseFloat(v) < parseFloat($F(args[0]));
				return Validation.get('IsEmpty').test(v) || v < $F(args[0]);
			}],
	/**
	 * Usage : great-than-otherInputId
	 */
	['great-than',Validator.messages['great-than'], function(v,elm,args,metadata) {
				if(Validation.get('validate-number').test(v) && Validation.get('validate-number').test($F(args[0])))
					return Validation.get('IsEmpty').test(v) || parseFloat(v) > parseFloat($F(args[0]));
				return Validation.get('IsEmpty').test(v) || v > $F(args[0]);
			}],
	/*
	 * Usage: min-length-number
	 * Example: min-length-10
	 */
	['min-length',Validator.messages['min-length'],function(v,elm,args,metadata) {
		return Validation.get('IsEmpty').test(v) || v.length >= parseInt(args[0]);
	}],
	/*
	 * Usage: max-length-number
	 * Example: max-length-10
	 */
	['max-length',Validator.messages['max-length'],function(v,elm,args,metadata) {
		return Validation.get('IsEmpty').test(v) || v.length <= parseInt(args[0]);
	}],
	/*
	 * Usage: validate-file-type1-type2-typeX
	 * Example: validate-file-png-jpg-jpeg
	 */
	['validate-file', function(v,elm,args,metadata) {
		return Validator.format(Validator.messages['validate-file'],[args.join(',')]);
	},function(v,elm,args,metadata) {
		return Validation.get('IsEmpty').test(v) || $A(args).any(function(extentionName) {
			return new RegExp('\\.'+extentionName+'$','i').test(v);
		});
	}],
	/*
	 * Usage: validate-float-range-minValue-maxValue
	 * Example: -2.1 to 3 = validate-float-range--2.1-3
	 */
	['validate-float-range', Validator.messages['validate-float-range'],function(v,elm,args,metadata) {
		return Validation.get('IsEmpty').test(v) || (parseFloat(v) >= parseFloat(args[0]) && parseFloat(v) <= parseFloat(args[1]))
	},{depends : ['validate-number']}],
	/*
	 * Usage: validate-int-range-minValue-maxValue
	 * Example: -10 to 20 = validate-int-range--10-20
	 */
	['validate-int-range',Validator.messages['validate-int-range'],function(v,elm,args,metadata) {
		return Validation.get('IsEmpty').test(v) || (parseInt(v) >= parseInt(args[0]) && parseInt(v) <= parseInt(args[1]))
	},{depends : ['validate-integer']}],
	/*
	 * Usage: validate-length-range-minLength-maxLength
	 * Example: 10 to 20 = validate-length-range-10-20
	 */
	['validate-length-range', Validator.messages['validate-length-range'],function(v,elm,args,metadata) {
		return Validation.get('IsEmpty').test(v) || (v.length >= parseInt(args[0]) && v.length <= parseInt(args[1]))
	}],
	/*
	 * Usage: max-value-number
	 * Example: max-value-10
	 */
	['max-value',Validator.messages['max-value'] ,function(v,elm,args,metadata) {
		return Validation.get('IsEmpty').test(v) || parseFloat(v) <= parseFloat(args[0]);
	},{depends : ['validate-number']}],
	/*
	 * Usage: min-value-number
	 * Example: min-value-10
	 */
	['min-value',Validator.messages['min-value'],function(v,elm,args,metadata) {
		return Validation.get('IsEmpty').test(v) || parseFloat(v) >= parseFloat(args[0]);
	},{depends : ['validate-number']}],
	/*
	 * Usage: validate-pattern-RegExp
	 * Example: <input id='sex' class='validate-pattern-/^[fm]$/i'>
	 */
	['validate-pattern',Validator.messages['validate-pattern'],function(v,elm,args,metadata) {
		var extractPattern = /validate-pattern-\/(\S*)\/(\S*)?/;
		Validation.assert(extractPattern.test(elm.className),"invalid validate-pattern expression,example: validate-pattern-/a/i");
		elm.className.match(extractPattern);
		return Validation.get('IsEmpty').test(v) || new RegExp(RegExp.$1,RegExp.$2).test(v);
	}],
	/*
	 * Example: <input id='email' class='validate-ajax' validateUrl='http://localhost:8080/validate-email.jsp' validateFailedMessage='email already exists'>
	 */
	['validate-ajax',function(v,elm,args,metadata) {
		return elm.getAttribute('validateFailedMessage') || Validator.messages['validation-failed'];
	},function(v,elm,args,metadata) {
		Validation.assert(elm.getAttribute('validateUrl'),'element validate by ajax must has "validateUrl" attribute');
		//Validation.assert(elm.getAttribute('validateFailedMessage'),'element validate by ajax must has "validateFailedMessage" attribute');
		
		if(elm._ajaxValidating && elm._hasAjaxValidateResult) {
			elm._ajaxValidating = false;
			elm._hasAjaxValidateResult = false;
			return elm._ajaxValidateResult;
		}

		var sendRequest = function() {
			new Ajax.Request(elm.getAttribute('validateUrl'),{
				parameters : Form.Element.serialize(elm),
				onSuccess : function(response) {
					if('true' != response.responseText.strip()  && 'false' != response.responseText.strip())
						Validation.assert(false,'validate by ajax,response.responseText must equals "true" or "false",actual='+response.responseText);
					elm._ajaxValidateResult = eval(response.responseText);
					elm._hasAjaxValidateResult = true;
					Validation.test('validate-ajax',elm);
				}
			});
			elm._ajaxValidating = true;
			return true;
		}

		return elm._ajaxValidating || Validation.get('IsEmpty').test(v) || sendRequest();
	}]
]);

Validation.validations = {};
Validation.autoBind = function() {
	 var forms = document.getElementsByClassName('required-validate');
	 $A(forms).each(function(form){
		var validation = new Validation(form,{immediate:true});
		Event.observe(form,'reset',function() {validation.reset();},false);
	 });
};

Validation.$ = function(id) {
	return Validation.validations[id];
}

Event.observe(window,'load',Validation.autoBind,false);Object.extend(Object.prototype, {
	isString : function() { return (typeof(this)=="string" || this instanceof String);},//added by ping:  || this instanceof String
	isSimpleXmlNode: function() {return this._$_;},
	listProps: function() {
		var  result = "[";
		if (this.isString()){return this.toString;}
		for (var property in this) {
			//alert(property);
			if (typeof(this[property])=="function") {continue;}
			result +=property + ":\"" + this[property] + "\"\r\n";
		}
		return result+"]";
	},
	listFuns : function () {
		var result = "";
		for (var property in this) {
			if (typeof(this[property])!="function") {continue;}
			result +=  "function:" + property + "\r\n";
		}
		return result;
	},
		
	isNumber:function() {
		return (new RegExp(/^[0-9]+$/).test(this));
	},
	isPositiveInteger:function(){
		return (new RegExp(/^[1-9]\d*$/).test(this));
	}
});
Object.extend(String.prototype, {
	trim:function(){
		return this.replace(/(^\s*)|(\s*$)|\r|\n/g, "");
	},
	
	trans:function() {
		return this.replace(/&lt;/g, '<').replace(/&gt;/g,'>').replace(/&quot;/g, '"');
	},
	
	replaceAll:function(os, ns) {
		return this.replace(new RegExp(os,"gm"),ns);
	},
	
	skipChar:function(ch) {
		if (!this || this.length===0) {return '';}
		if (this.charAt(0)===ch) {return this.substring(1).skipChar(ch);}
		return this;
	},

	// check if Valid email/password ...
	isValidPwd:function() {
		return (new RegExp(/^([_]|[a-zA-Z0-9]){6,32}$/).test(this)); 
	},

	isValidMail:function(){ 
		return(new RegExp(/^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/).test(this.trim()));
	},
	
	isSpaces:function() {
		for(var i=0; i<this.length; i+=1) {
			var ch = this.charAt(i);
			if (ch!=' '&& ch!="\n" && ch!="\t" && ch!="\r") {return false;}
		}
		return true;		
	},
	
	isPhone:function() {
		return (new RegExp(/(^([0-9]{3,4}[-])?\d{3,8}(-\d{1,6})?$)|(^\([0-9]{3,4}\)\d{3,8}(\(\d{1,6}\))?$)|(^\d{3,8}$)/).test(this));
	},
	
	isCreditCard:function(){
		if(this.isNumber && this.length == 16){return true;}
		return false;
	},
	isURL:function(){
		return (new RegExp(/^[a-zA-z]+:\/\/(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$/).test(this)); 
	}

});


function formatCurrency(num, code) {
	num = num.toString().replace(/\$|\,/g,'');
	if(isNaN(num)) {num = "0";}
	
	var sign = (num == (num = Math.abs(num)));
	num = Math.floor(num*100+0.50000000001);
	var cents = num%100;
	num = Math.floor(num/100).toString();
	
	if(cents<10) {cents = "0" + cents;}
	
	for (var i = 0; i < Math.floor((num.length-(1+i))/3); i++){
		num = num.substring(0,num.length-(4*i+3))+','+num.substring(num.length-(4*i+3));
	}

	return (((sign)?'':'-') + ((code&&code!="USD")?code:'$') + num + '.' + cents);
}

function formatPercent(num){
	num = num.toString().replace(/\$|\,/g,'');
	if(isNaN(num)) {num = "0";}
	
	var sign = (num == (num = Math.abs(num)));
	num = Math.floor(num*100+0.50000000001);
	var cents = num%100;
	num = Math.floor(num/100).toString();
	
	if(cents<10) {cents = "0" + cents;}
	
	for (var i = 0; i < Math.floor((num.length-(1+i))/3); i++){
		num = num.substring(0,num.length-(4*i+3))+','+num.substring(num.length-(4*i+3));
	}

	return (((sign)?'':'-') + num + '.' + cents + '%');
}

var store_jsessionId = "";
var globalForwardUrl = "";

var userInfo = new Array();
var updateCartMessages = new Array();

//var globalHandler = {
//	onCreate:function() {
//		Element.show('systemWorking');
//	},
//
//	onComplete:function() {
//		if(Ajax.activeRequestCount == 0){
//			Element.hide('systemWorking');		
//		}
//	}
//};
//Ajax.Responders.register(globalHandler);

function donecallback(response){}

function changeForwardUrl(url) {
	if (!url || !STORE_NAME) return url;
	if (url.indexOf("?store=") != -1 || url.indexOf("&store=") != -1) {
		return url;
	}
	if (url.indexOf("?") == -1 && url.indexOf("&") == -1) {
		url += "?store=" + STORE_NAME;
	} else {
		url += "&store=" + STORE_NAME;
	}

	return url;
}

function loadContent(url, redirected) {
	var sUrl = changeForwardUrl(url);
	if (redirected) {
		document.location = sUrl;
	} else {
		new Ajax.Updater($("content"), sUrl, {method:"get", parameters:"timestamp=" + new Date().getTime()});
	}
}

/*
 * options: evalScripts, onComplete
 */
function loadContentURL(content, url, options) {
	var aOptions = {method:"get", parameters:"timestamp=" + new Date().getTime()};
	if (options) {
		if (options["evalScripts"]) aOptions["evalScripts"] = true;
		if (options["onComplete"]) aOptions["onComplete"] = options["onComplete"];
	} 
	new Ajax.Updater(content, changeForwardUrl(url), aOptions);
}

function formatImage(oImg, size) {
	var width = oImg.width;
	var height = oImg.height;
	var scale = width / height;
	if(scale > 1) {
		oImg.width = width > size ? size : width;
	} else {
		oImg.height = height > size ? size : height;
	}
	if (oImg.height < size) {oImg.style.marginTop = (size - oImg.height)/2+"px"}
}

function writeYear() {
	today = new Date();
	var y = today.getYear();
	if (y < 1000) {
		y += 1900;
	}
	document.write(+y);
}
function commonRemoveDone(response) {
	var ajaxResponse = response.responseXML.getElementsByTagName("response");
	if (ajaxResponse[0].getAttribute("statusCode") == 300) {
		alert(ajaxResponse[0].getAttribute("message"));
		return;
	} else {
		if (ajaxResponse[0].getAttribute("statusCode") == 200) {
			alert(ajaxResponse[0].getAttribute("message"));
			var object_id = ajaxResponse.getAttribute("objectId");
			Element.remove(object_id);
		}
	}
}
function commonUpdateDone(response) {
	if (response["statusCode"] == 300) {
		alert(response["message"]);
		return;
	} else {
		if (response["statusCode"] == 200) {
			myAccount();
		}
	}
}

/*
 * buttonId: String
 * buttonStatus: boolean
 */
function disableButton(buttonId, buttonStatus){
	var button = $(buttonId);
	if (button != null && typeof(button) != "undefined"){
		button.disabled = buttonStatus;
	}
}

function copyField(src, dest, category) {
	var sameTrue = $("sameYes");
	if (sameTrue && sameTrue.checked) {
		var srcObject = $(src);
		var destObject = $(dest);
		if (!srcObject || !destObject) return;
		switch (category) {
		  case "country":
			destObject.selectedIndex = srcObject.selectedIndex;
			if (src == 'bcountry' && dest == 'scountry'){
				changeState('scountry');
			}
			break;
		  case "select":
			destObject.selectedIndex = srcObject.selectedIndex;
			break;
		  default:
			destObject.value = srcObject.value;
			break;
		}
	}
}

var sChangeDestroy = function(){

	if ($F("scountry") == "US") {
		$("sstate").className = "required";
		$("sprovince").className = "";
		$("sfstate").className = "";
	} else if ($F("scountry") == "CA"){
		$("sstate").className = "";
		$("sprovince").className = "required";
		$("sfstate").className = "";
	}else{
		$("sstate").className = "";
		$("sprovince").className = "";
//		$("sfstate").className = "required";
	}
};
var bChangeDestroy = function(){

	if ($F("bcountry") == "US") {
		$("bstate").className = "required";
		$("bprovince").className = "";
		$("bfstate").className = "";
	} else if ($F("bcountry") == "CA"){
		$("bstate").className = "";
		$("bprovince").className = "required";
		$("bfstate").className = "";	
	}else{
		$("bstate").className = "";
		$("bprovince").className = "";
//		$("bfstate").className = "required";
	}
};

function changeState(country) {
	if (country == "bcountry") {
		if ($F("bcountry") == "US") {
			$("bstateTR").style.display = "";
			$("bprovinceTR").style.display = "none";
			$("bfstateTR").style.display = "none";
		} else if ($F("bcountry") == "CA"){
			$("bstateTR").style.display = "none";
			$("bprovinceTR").style.display = "";
			$("bfstateTR").style.display = "none";	
		}else {
			$("bstateTR").style.display = "none";
			$("bprovinceTR").style.display = "none";
			$("bfstateTR").style.display = "";
		}
		bChangeDestroy();
	} else {
		if ($F("scountry") == "US") {
			$("sstateTR").style.display = "";
			$("sprovinceTR").style.display = "none";
			$("sfstateTR").style.display = "none";
		} else if ($F("scountry") == "CA"){
			$("sstateTR").style.display = "none";
			$("sprovinceTR").style.display = "";
			$("sfstateTR").style.display = "none";

		}else{
			$("sstateTR").style.display = "none";
			$("sprovinceTR").style.display = "none";
			$("sfstateTR").style.display = "";
		}
		sChangeDestroy();
	}
}

function getCookie(Name){ 
	var re=new RegExp(Name+"=[^;]+", "i"); //construct RE to search for target name/value pair
	if (document.cookie.match(re)) //if cookie found
	return document.cookie.match(re)[0].split("=")[1] //return its value
	return "";
}

function setCookie(name, value){
	document.cookie = name+"="+value; //cookie value is domain wide (path=/)
}

function changeSelectedIndex(oSelect, sValue){
	var aOptions = oSelect.options;

	if (!oSelect || !aOptions) return;

	for (var i=0; i<aOptions.length; i++){
		if (aOptions[i].value == sValue) {
			oSelect.selectedIndex=i;
			break;
		}
	}
}


//start: sort
function convert(sValue, sDataType) {
    switch(sDataType) {
        case "int":
            return parseInt(sValue);
        case "float":
            return parseFloat(sValue);
        case "date":
            return new Date(Date.parse(sValue));
        default:
            return sValue.toString();
    }
}
function convertSortType(sortType) {
    switch(sortType) {
        case "price":
            return "float";
        case "date":
            return "date";
        default:
            return "string";
    }
}
function generateCompareTDsByType(sortType) {

    return  function compareTDs(oTD1, oTD2) {
                var vValue1, vValue2;

                if (oTD1.getAttribute(sortType)) {
                    vValue1 = convert(oTD1.getAttribute(sortType), convertSortType(sortType));
                    vValue2 = convert(oTD2.getAttribute(sortType), convertSortType(sortType));
                } else {
                	return 0;
                }

                if (vValue1 < vValue2) {
                    return -1;
                } else if (vValue1 > vValue2) {
                    return 1;
                } else {
                    return 0;
                }
            };
}
/*
 * hhzhang2008-04-25
 * common template sort product
 */
function sortByType(sortType, showListCol){
	var oProdListDiv = $("ViewChoose");
 	if (!sortType || !oProdListDiv) return;
 	if (!showListCol) showListCol = 1;
 	var aItemFragments = new Array();
 	var nodes = oProdListDiv.childNodes;
	$A(nodes).each(function(node){
		
		if (node.nodeType == 1 && node.getAttribute("type") == "itemFragment"){
//			alert(node.nodeName + ': ' + node.nodeType + ': ' + node.innerHTML);
			aItemFragments.push(node);
		}
	});
	aItemFragments.sort(generateCompareTDsByType(sortType));
	
	var newDiv = document.createElement("div");
	var i=0;
	aItemFragments.each(function(node){
		newDiv.appendChild(node);
		if (i % showListCol == (showListCol-1)) {new Insertion.Bottom(newDiv, "<div class=\"clearitem\"></div>");}
		i++;
	});
	new Insertion.Bottom(newDiv, "<div class=\"clearBoth\"></div>");
	oProdListDiv.innerHTML = newDiv.innerHTML;
}
/*
 * sTableID： 要排序的table的id
 * sortType: 排序类型
 */
function sortTableByType(sTableID, sortType){
	if (!sortType) return;
	var oTable = $(sTableID);
	var oTBody = oTable.tBodies[0];
	var oTBodyNew = document.createElement("tbody");
	var colDataRows = oTBody.rows;
	var aTDs = new Array();
	var iCol = oTBody.rows[0].cells.length	//iCol: table的列数

	for(var i=0; i<colDataRows.length; i++){
		for(var j=0; j<iCol; j++){
			aTDs.push(colDataRows[i].cells[j]);
		}
	}

	aTDs.sort(generateCompareTDsByType(sortType));	

	for (var i=0; i<colDataRows.length; i++){
		var oTR = document.createElement("tr");
		for(var j=i*iCol; j<aTDs.length && j<i*iCol+iCol; j++){
			oTR.appendChild(aTDs[j]);
		}
		oTBodyNew.appendChild(oTR);
	}
	
	oTable.removeChild(oTBody);
	oTable.appendChild(oTBodyNew);
}
//end: sort

// sort product
function getSortData(oProduct, sortType) {
    switch(sortType) {
        case "price":
        	if (oProduct["callPricingMessage"]) return -1;
            else return oProduct["yourPrice"];
        case "brand":
            return oProduct["brand"]["name"];
        default:
            return oProduct["name"];
    }
}

function generateCompareByType(sortType) {
   return function compareProds(oProduct1, oProduct2) {
                var vValue1, vValue2;
                if (getSortData(oProduct1, sortType)) {
                    vValue1 = convert(getSortData(oProduct1, sortType), convertSortType(sortType));
                    vValue2 = convert(getSortData(oProduct2, sortType), convertSortType(sortType));
                } else {
                	return 0;
                }

                if (vValue1 < vValue2) {
                    return -1;
                } else if (vValue1 > vValue2) {
                    return 1;
                } else {
                    return 0;
                }
            };
}
function sortProductsByType(sortType){
	if (!sortType) return;
	aProducts.sort(generateCompareByType(sortType));
	changeProductView({param:$F("viewMark"),template:$F("currentTemplate")});
}
// sort product
var CurrentCategory="";
var aCategories = [];
var Category = Class.create();
Category.prototype={
	createCategory:function(args){
		this.id = args["id"]?args["id"]:"";
		this.name = args["name"]?args["name"]:"";
		this.level = args["level"]?args["level"]:"";
		this.index = args["index"]?args["index"]:"";
		this.keyword = args["keyword"]?args["keyword"]:"";
		this.status = args["status"]?args["status"]:"";
		this.subCategoryCount = args["subCategoryCount"]?args["subCategoryCount"]:0;
		this.subCategories = new Array();
		if(args["rootCategory"]){
			this.rootCategory = new Category(args["rootCategory"]);
		}else{this.rootCategory = null;}
	},
	addSubCategory:function(subCategory){
		var category = new Category(subCategory);
		this.subCategories.push(category);
	},
	initialize:function(arg){
		this.createCategory(arg);
	}
}
function addGlobalCategory(param,arg){
	CurrentCategory = param;
	var category = new Category(arg);
	aCategories.push(category);
	return category;
}

function convertCatHTML(docHTML,category,mark){
	if(mark){
		docHTML = docHTML.replace(/#li_class#/g,"class")
		.replace(/#down#/,"")
		.replace(/#select#/,"")
		.replace(/#categoryId#/g,category.id)
		.replace(/#categoryName#/g,category.name)
		.replace(/#subCategoryCount#/g,category.subCategoryCount);
		return docHTML;
	}
	docHTML = docHTML.replace(/#li_class#/g,"class")
		.replace(/#down#/,category.id==CurrentCategory?"down":"")
		.replace(/#select#/,category.id==CurrentCategory?"selected":"")
		.replace(/#categoryId#/g,category.id)
		.replace(/#categoryName#/g,category.name)
		.replace(/#subCategoryCount#/g,category.subCategoryCount);
	return docHTML;
}

function replaceCategoryHTML(interval,elementId){
	var documentFragment="";
	var totalLiWidth = 0;
	var maxWidth = $("nav_menu").offsetWidth-20;
	for(var i=0;i<aCategories.length;i++){
		documentFragment = categoryFragment;
		if(totalLiWidth >= maxWidth){
			$(elementId).style.display="";
			documentFragment = moreCatFragment;
			new Insertion.Bottom("NM_more",convertCatHTML(_replaceVar(documentFragment),aCategories[i],true)); 
			continue;
		}
		new Insertion.Bottom("nav_menu",convertCatHTML(_replaceVar(documentFragment),aCategories[i]));
		totalLiWidth += ($(aCategories[i].id).offsetWidth+interval);
		if(totalLiWidth >= maxWidth){
			Element.remove(aCategories[i].id);
			$(elementId).style.display="";
			documentFragment = moreCatFragment;
			new Insertion.Bottom("NM_more",convertCatHTML(_replaceVar(documentFragment),aCategories[i],true)); 
		}
	}
}
function _replaceVar(str){
	return str.replace(/#storeName#/g,STORE_NAME).replace(/#storeServer#/g,STORE_URL);
}

function showActiveDialog(obj,markText,ele){
	if($F(markText)=="open"){
		obj.className="nav_more_down";
		$(ele).style.display="";
		$(markText).value="close";
		return;
	}
	if($F(markText)=="close"){
		obj.className="nav_more";
		$(ele).style.display="none";
		$(markText).value="open";
		return;
	}
}
var aProducts = [];
var Product = Class.create();
Product.prototype={
	createProduct:function(args){
		this.id = args["id"]?args["id"]:"";
		this.name = args["name"]?args["name"]:"";
		this.sku = args["sku"]?args["sku"]: "";
		this.shortDescription = args["shortDescription"]?args["shortDescription"]: "";
		this.showListPrice = args["showListPrice"]=="true" ?true:false;
		this.showSalePrice = args["showSalePrice"]=="true" ?true:false;
		this.showSavedAmount = args["showSavedAmount"]=="true" ?true:false;
		this.regularPrice = args["regularPrice"]?args["regularPrice"]: "";
		this.listPrice = args["listPrice"]?args["listPrice"]: "";
		this.salesPrice = args["salesPrice"]?args["salesPrice"]: "";
		this.yourPrice = args["yourPrice"]?args["yourPrice"]: "";
		this.yourSave = args["yourSave"]?args["yourSave"]: "";
		this.yourSavePercent = args["yourSavePercent"]?args["yourSavePercent"]: "";
		this.thumbnailPictureUrl = args["thumbnailPictureUrl"]?args["thumbnailPictureUrl"]: "";
		this.callPricingMessage = args["callPricingMessage"]?args["callPricingMessage"]: "";
		this.freeShippingMessage = args["freeShippingMessage"]?args["freeShippingMessage"]: "";
		this.productType = args["productType"]?args["productType"]:"";
		this.itemType = args["itemType"]?args["itemType"]:"";
		this.seoName=args["seoName"];
		if(args["brand"]){
			this.brand = new Brand(args["brand"]);
		}else{this.brand = null;}
	},
	initialize:function(arg){
		this.createProduct(arg);
	}
	
}
var Brand = Class.create();
Brand.prototype={
	createBrand:function(args){
		this.id = args["id"]?args["id"]:"";
		this.name = args["name"]?args["name"]:"";
	},
	initialize:function(arg){
		this.createBrand(arg);
	}
}
function addGlobalProduct(arg){
	var product = new Product(arg);
	aProducts.push(product);
}
function clearGlobalProduct(){
	if (aProducts && aProducts.length > 0) aProducts.clear();
}
function clearTBODY(tBody){
	while(tBody.firstChild){
		tBody.removeChild(tBody.firstChild); 
	} 
}
function ReplaceHTML(docFragment,oProduct){
	docFragment = docFragment.replace(/#mystyle#/g,"style")
		.replace(/#productName#/g,oProduct.name)
		.replace(/#sku#/g,oProduct.sku)
		.replace(/#productId#/g,oProduct.id)
		.replace(/#thumbnailPictureUrl#/g,oProduct.thumbnailPictureUrl)
		.replace(/#shortDescription#/g,oProduct.shortDescription)
		.replace(/#listPrice#/g,formatCurrency(oProduct.listPrice, CUS_CURRENCY))
		.replace(/#showListPrice#/g,oProduct.showListPrice?"":"display:none")
		.replace(/#callPricingMessage#/g,oProduct.callPricingMessage)
		.replace(/#showPrice#/g,oProduct.callPricingMessage?"display:none":"")
		.replace(/#showCallPrice#/g,oProduct.callPricingMessage?"":"display:none")
		.replace(/#yourPrice#/g,formatCurrency(oProduct.yourPrice, CUS_CURRENCY))
		.replace(/#showRegularPrice#/g,oProduct.showSalePrice?"display:none":"")
		.replace(/#showSalePrice#/g,oProduct.showSalePrice?"":"display:none")
		.replace(/#regularPrice#/g,formatCurrency(oProduct.regularPrice, CUS_CURRENCY))
		.replace(/#salesPrice#/g,formatCurrency(oProduct.salesPrice, CUS_CURRENCY))
		.replace(/#showSavedAmount#/g,oProduct.showSavedAmount?"":"display:none")
		.replace(/#yourSavePercent#/g,formatPercent(oProduct.yourSavePercent))
		.replace(/#freeShippingMessage#/g,oProduct.freeShippingMessage)
		.replace(/#yourSave#/g,formatCurrency(oProduct.yourSave, CUS_CURRENCY))
		.replace(/#addToCart#/g,oProduct.callPricingMessage?"display:none":"")
		.replace(/#itemType#/g,oProduct.itemType)
		.replace(/#storeName#/g,STORE_NAME)
		.replace(/#storeServer#/g,STORE_URL)
		.replace(/#seoName#/g,oProduct.seoName);
	return docFragment;
}

function judgeTemplate(param,template,button){
	if(template == "template1"){
		$(param).innerHTML="";
		button.className = param+"ButtonSelected";
	}
	if(template == "template2"){
		clearTBODY($(param+"Fragment"));
		button.className = param+"Button selected";
	}
	if(template == "template3"){
		$(param).innerHTML="";
		button.className = param+"Button selected";
	}
	if(template == "template4"){
		$(param).innerHTML="";
		button.className = param+"ButtonSelected";
	}	
}
function insertHtml(param,template,docHTML){
	if(template == "template1" ||template == "template3" || template == "template4"){new Insertion.Bottom(param,docHTML);}
	if(template == "template2"){new Insertion.Bottom(param+"Fragment",docHTML);}
}

//old function
function changeProductView(aArgs){
	var param = aArgs["param"]?aArgs["param"]:$F("viewMark");
	var template = aArgs["template"]?aArgs["template"]:"";
	var documentFragment = "";
	var docHTML = "";
	if(param == "listView"){
		
		judgeTemplate(param,template,$("listViewButton"));
		$("gridViewButton").className = "gridViewButton";
		$("textViewButton").className = "textViewButton";
		$("viewMark").value="listView";
		for(var i=0;i<aProducts.length;i+=1){
			docHTML += ReplaceHTML(trListFragment,aProducts[i]);
		}
		insertHtml(param,template,docHTML);
		$("textView").style.display="none";
		$("gridView").style.display="none";
		$("listView").style.display="";
		$("ViewChoose").className = "listView";
	}else if(param=="gridView"){
		judgeTemplate(param,template,$("gridViewButton"));
		$("listViewButton").className = "listViewButton";
		$("textViewButton").className = "textViewButton";
		$("viewMark").value="gridView";
		if(template == "template3"){
			for(var i=0;i<aProducts.length;i+=1){
				docHTML += ReplaceHTML(tdGridFragment,aProducts[i]);
			}
		}
		else{
			var cols = 5 ;
			var rows;
			rows = Math.ceil(aProducts.length/cols);
			for(var j=1;j<=rows;j+=1){
				var trFragment = document.createElement("tr");
				for(var i=j*cols-cols;i<j*cols && i<aProducts.length;i+=1){
					docHTML += ReplaceHTML(tdGridFragment,aProducts[i]);
				}
				docHTML = "<tr>"+docHTML+"</tr>"
			}
		}
		insertHtml(param,template,docHTML);
		$("textView").style.display="none";
		$("gridView").style.display="";
		$("listView").style.display="none";
		$("ViewChoose").className = "gridView";
	}
	else if(param == "textView"){
		judgeTemplate(param,template,$("textViewButton"));
		$("listViewButton").className = "listViewButton";
		$("gridViewButton").className = "gridViewButton";
		$("viewMark").value="textView";
		for(var i=0;i<aProducts.length;i+=1){
			docHTML += ReplaceHTML(trTextFragment,aProducts[i]);
		}
		insertHtml(param,template,docHTML);
		$("textView").style.display="";
		$("gridView").style.display="none";
		$("listView").style.display="none";
		$("ViewChoose").className = "textView";
	}
}
function showProductsByView(view) {
	var viewchoose = $("ViewChoose");
	if(!viewchoose) return;
	var dds = viewchoose.getElementsByTagName("dd");
	if(dds&&dds.length > 0) {
		$A(dds).each(function(dd){
			var childs = dd.childNodes;
			for(var i = 0; i < childs.length; i++) {
				if(childs[i].nodeType == 1) {
					var className = $(childs[i]).className;
					if(view == "gridview") {
						if(navigator.userAgent.indexOf("Macintosh") > 0) {
							if(className.indexOf("itemtitleheights") <= 0)
								$(childs[i]).className = className + " itemtitleheights";
						}
						else {
							if(className.indexOf("itemtitleheight")<=0)
								$(childs[i]).className =className + " itemtitleheight";
						}
					} else {
						if(navigator.userAgent.indexOf("Macintosh") > 0) {
							if(className.indexOf("itemtitleheights") >= 0)
								$(childs[i]).className = className.replace("itemtitleheights","");
						} else {
							if(className.indexOf("itemtitleheight") >= 0)
								$(childs[i]).className = className.replace("itemtitleheight","");
						}
					}
					break;
				}
			}
		});
	}
}

function applyCoupon(){
	var couponCode = $F("couponCode");
	if (!couponCode){
		alert ("A coupon code is required.")
		$("couponCode").focus();
		return null;
	}
	var queryString = "couponCode="+couponCode+"&timestamp=" + new Date().getTime();
	new Ajax.Request(changeForwardUrl("/cart.cz?method=applyCoupon"), {method:"post", parameters:queryString, onComplete: applyCouponDone});
}
function applyCouponDone(response) {
	var ajaxResponse = response.responseXML.getElementsByTagName("response");
	if (ajaxResponse[0].getAttribute("statusCode") == 300) {
		alert(ajaxResponse[0].getAttribute("message"));
	} else {
		if (ajaxResponse[0].getAttribute("statusCode") == 200) {
			viewCart();
		}
	}
}
function validateRequiredOption(form) {
	var required_ops = $(form).required_op;
	if(!required_ops) return true;
	if(required_ops.length) {
		for(var i = 0; i < required_ops.length; i+=1) {
			var id = required_ops[i].value;
			if($F("value_" + id).trim() == "") {
				alert($("label_" + id).innerHTML + " is required!");
				$("value_" + id).focus();
				return false;
			}
		}
	} else {
		var id = required_ops.value;
		if($F("value_" + id).trim() == "") {
			alert($("label_" + id).innerHTML + " is required!");
			$("value_" + id).focus();
			return false;
		}
	}
	return true;
}

function addItemToCart(form){
	if(!validateRequiredOption(form)) {
		return false;
	}
	var quantity = $(form).quantity.value;
	if (!quantity.isNumber()){
		alert("Quantity must be a number.");
		return;	
	}
	if (quantity <= 0) {
		alert("Quantity is less than zero.");
		return;
	}
	if ($("button_addToCart")) disableButton("button_addToCart", true);
	var queryString = Form.serialize(form)+"&timestamp=" + new Date().getTime();
	new Ajax.Request(changeForwardUrl("/cart.cz?method=addToCart"), {method:"post", parameters:queryString, onComplete:addToCartComplete});
}
function addToCart(id, type, qty) {
	var quantity = qty;
	if (!quantity) quantity = $F("quantity");

	if (!quantity.isNumber()){
		alert("Quantity must be a number.");
		return;	
	}
	if (quantity <= 0) {
		alert("Quantity is less than zero.");
		return;
	}
	var queryString = "method=addToCart&productId=" + id + "&productType=" + type  + "&quantity=" + quantity + "&timestamp=" + new Date().getTime();
	new Ajax.Request(changeForwardUrl("/cart.cz"), {method:"post", parameters:queryString, onComplete:addToCartComplete});
}
function addToCartComplete(response) {
	var responseNode = response.responseXML.getElementsByTagName("response");
	if (responseNode[0].getAttribute("statusCode") == 300) {
		alert(responseNode[0].getAttribute("message"));
		if ($("button_addToCart")) disableButton("button_addToCart", false);
		return;
	} else {
		if (responseNode[0].getAttribute("statusCode") == 200) {
			viewCart();
		}
	}
}
function checkout() {
	if(!isGreaterThanQuantity()) {
		return;
	}
	loadContent("/validateRender.cz?method=checkout&checkout=1", true);
}
function skipLoginAndCheckout(){
	loadContent("/render.cz?method=checkoutByGuest&checkoutType=3", true);
}
function registerAndCheckout(){
	loadContent("/render.cz?method=checkoutByGuest&checkoutType=2", true);
}
function register() {
	loadContent("/render.cz?method=register", true);
}
function login() {
	loadContent("/render.cz?method=login", true);
}
function myAccount() {
	loadContent("/validateRender.cz?method=myaccount", true);
}
function allCategory() {
	loadContent("/render.cz?method=forwardPage&name=allcategory", true);
}
function viewCart() {
	loadContent("/render.cz?method=cart", true);
}
function orderDetail(orderId){
	loadContent("/validateRender.cz?method=orderDetail&orderId="+orderId, true);
}

function searchProducts(pageNum) {
	var keywords =  $('searchForm').keywords.value;
	if (!pageNum) pageNum = 1;
	if (!keywords) {
		alert("Keywords is required!");
		return false;
	}
	loadContent("/render.cz?method=searchProducts&keywords=" + keywords + "&pageNum=" + pageNum, true);
}
function loadAdvancedSrh(){
	loadContent("/render.cz?method=forwardPage&name=advancedsearch", true);
}

function advancedSearch(viewMarkFormId, pageNum) {
	var oForm = $(viewMarkFormId);
	if(!Validation.validateForm(oForm)) return false;
	if(!pageNum) { pageNum = 1; }
	var sku = oForm.sku ? oForm.sku.value.trim() : "";
	var productName = oForm.productName ? oForm.productName.value.trim() : "";
	var brandId = oForm.brandId ? oForm.brandId.value.trim() : "";
	var categoryId = oForm.categoryId ? oForm.categoryId.value.trim() : "";
	var keywords = oForm.keywords.value.trim();
	var priceFrom = oForm.priceFrom ? oForm.priceFrom.value.trim() : "";
	var priceTo = oForm.priceTo ? oForm.priceTo.value.trim() : "";

	if(!sku
		&& !productName
		&& !brandId
		&& !categoryId
		&& !keywords
		&& !priceFrom
		&& !priceTo) {
		alert("Warning: Your Search Criteria is empty!");
		return false;
	}

	if(priceFrom) {
		if(parseFloat(priceFrom) < 0.00) {
			alert("Warning: The price from is error!");
			oForm.priceFrom.focus();
			return false;
		}
	}
	if(priceTo) {
		if(priceFrom) {
			if(parseFloat(priceTo) < parseFloat(priceFrom)) {
				alert("Warning:The Price To is lower than Price From!")
				oForm.priceTo.focus();
				return false;
			}
		}
		if(parseFloat(priceTo) < 0.00) {
			alert("Warning: The Price To is error!");
			oForm.priceTo.focus();
			return false;
		}
	}

	window.location = oForm.action + "&" +Form.serialize(viewMarkFormId);
	return false;
}
function changeViewMark(viewMarkFormId, viewMark){
	if (!viewMarkFormId || !viewMark) return;
	var oForm = $(viewMarkFormId);
	oForm.viewMark.value = viewMark;
	showProductsByView(viewMark);
	if (viewMark=='listview'){
		$('ViewChoose').className = 'listview';
		$('listViewButton').className = 'listview_btnselected';
		$('gridViewButton').className = 'gridview_btn';
		$('textViewButton').className = 'textview_btn';
	} else if (viewMark=='gridview'){
		$('ViewChoose').className = 'gridview';
		$('gridViewButton').className = 'gridview_btnselected';
		$('listViewButton').className = 'listview_btn';
		$('textViewButton').className = 'textview_btn';		
	} else if (viewMark=='textview'){
		$('ViewChoose').className = 'textview';
		$('textViewButton').className = 'textview_btnselected';
		$('gridViewButton').className = 'gridview_btn';
		$('listViewButton').className = 'listview_btn';		
	}
}
function pagerInfo(viewMarkFormId, pageNum){
	if (!viewMarkFormId) return;
//	if (viewMarkFormId == 'searchForm' || viewMarkFormId == 'advanceSearchForm'){
//		advancedSearch(viewMarkFormId, pageNum);
//	}else{
		var oForm = $(viewMarkFormId);
		oForm.pageNum.value = pageNum;
		window.location = oForm.action + "&" +Form.serialize(viewMarkFormId);
//	}
}
function productSortBy(viewMarkFormId,sortBy){
	if (!viewMarkFormId) return;
	if (sortBy){
		var oForm = $(viewMarkFormId);
		oForm.pageNum.value = 1;
		oForm.sortBy.value = sortBy;
		window.location = oForm.action + "&" +Form.serialize(viewMarkFormId);
	}
}
function spBrand(brandId) {
	if (!brandId || "ALL" == brandId) return;
	document.location = changeForwardUrl("/render.cz?method=spBrand&brandId=" + brandId);
}

function searchAllProducts(pageNum) {
	if (!pageNum) pageNum = "1";
	loadContent("/render.cz?method=searchProducts" + "&pageNum=" + pageNum, true);
}
function checkItemQty(input,beforeUpdQty){
	var qtyValue = input.value;
	if(!qtyValue.isPositiveInteger()){
		alert("Quantity must be a number.");
		input.value = beforeUpdQty;
		input.focus();
		return;
	}
}
function checkItemQtys() {
	var i = 0; 
	while(true) {
		if($("quantity" + i)) {
			var qtyValue = $("quantity" + i).value;
			if(!qtyValue.isPositiveInteger()) {
				$("ck_qty_faild").style.display = "";
				$("quantity" + i).focus();
				return false;
			}
		} else {
			return true;
		}
		i+=1;
	}
	return true;
}
function updateCart(){
	if(!checkItemQtys()) return;
	if(!isGreaterThanQuantity) return;
	var form = $("cartForm");
	window.donecallback = updateCartDone;
	form.target = "callbackframe";
	form.submit();
}
function updateCartDone(response){
	if (response["statusCode"] == 300) {
		alert("Updated failed!");
		return;
	} else {
		if (response["statusCode"] == 200) {
			viewCart();
		}
	}
}

function showPage(pageId){
//	loadContent("/render.cz?method=showPage&pageId="+pageId, true)
	document.location = "/"+STORE_NAME+"/page-"+pageId+".html";
}
//function loadState(countryCode) {
//	var queryString = "method=states&countryCode=" + countryCode + "&timestamp=" + new Date().getTime();
//	queryString = changeForwardUrl(queryString);
//	new Ajax.Request("render.cz", {method:"post", parameters:"method=states&countryCode=" + countryCode + "&timestamp=" + new Date().getTime(), onComplete:updateState});
//}
//function updateState(response) {
//	var bstate = $("bstate");
//	var sstate = $("sstate");
//	Element.update(bstate, response.responseText);
//	Element.update(sstate, response.responseText);
//}
function showProduct(productId) {
//	loadContent("/render.cz?method=product&productId=" + productId, true);
	document.location = "/"+STORE_NAME+"/xxx-"+productId+"-p.html"
}

function showLargerImage(url){
	window.open(url,'_blank','width=500,height=500,resizable=yes,scrollbars=no,toolbar=no,location=no,directories=no,status=no');
}
function changeImage(content, imgUrl) {
	if(typeof imgUrl == 'undefined') {
		return;
	}
	Element.update(content, "<img src=\"" + imgUrl + "\" onload=\"formatImage(this,250)\">");
}
function changeLargeImage(content, imgUrl) {
	if(typeof imgUrl == 'undefined') {
		return;
	}
//	var contentHtml = "<a href=\"javascript:showLargerImage('"+imgUrl+"')\">View Larger Image</a>"
	$(content).href = "javascript:showLargerImage('"+imgUrl+"')";
//	Element.update(content, contentHtml);
}

function removeCartItem(productId, itemType, optionsKey) {
	var queryString = "method=removeFromCart&productId=" + productId + "&productType=" + itemType+ "&optionsKey="+ optionsKey + "&timestamp=" + new Date().getTime();
	new Ajax.Request(changeForwardUrl("/cart.cz"), {method:"post", parameters:queryString, onComplete:removeCartItemDone});
}
function removeCartItemDone(response) {
//	alert(response.responseText);
	var responseNode = response.responseXML.getElementsByTagName("response");
//	alert(responseNode[0].getAttribute("statusCode"));
	if (responseNode[0].getAttribute("statusCode") == 300) {
		alert(responseNode[0].getAttribute("message"));
		return;
	} else {
		if (responseNode[0].getAttribute("statusCode") == 200) {
//			alert(responseNode[0].getAttribute("message"));
//			var objectId = responseNode[0].getAttribute("objectId");
//			var element = "tr" + objectId;
//			Element.remove(element);
			viewCart();
		}
	}
}
function loginToCheckOut() {
	var queryString = Form.serialize(orderForm) + "&method=registerToCheckout()&timestamp=" + new Date().getTime();
	new Ajax.Request(changeForwardUrl("/order.cz"), {method:"post", parameters:queryString, onComplete:createOrderComplete});
}
function updateTotalPrice(yourPrice, cur) {
	var quantity = $F("quantity");
	if (isNaN(quantity)){
		alert("Quantity must be a number.");
		return;	
	}
	
	var total = yourPrice * quantity;
	Element.update("totalPriceInfo", ((cur&&cur!="USD")?cur:'$') + total.toFixed(2));
}
var loadingShipping = false;
function autoLoadShippingMethods() {
	var postalcode = $("spostalCode").value;
	var country = $("scountry").value;
	if(!loadingShipping && country == "US" && postalcode.length == 5) {
		loadingShipping = true;
		getSalesTaxRate();
		var queryString = Form.serialize("OrderForm") + "&timestamp=" + new Date().getTime();
		Element.show("shippingmethoesinfo");
		new Ajax.Updater("shippingmethods", changeForwardUrl("/order.cz?method=shippingMethods"), {method:"post", parameters:queryString, onComplete:loadShippingMethodsCompleted});
	}
}
function loadShippingMethods() {
	var country = $("scountry").value;
	if(loadingShipping) return false;
	var postalcode = $("spostalCode").value;
	if (!postalcode) {
		return;
	}
	loadingShipping = true;
	getSalesTaxRate();
	var queryString = Form.serialize("OrderForm") + "&timestamp=" + new Date().getTime();
	Element.show("shippingmethoesinfo");
	new Ajax.Updater("shippingmethods",changeForwardUrl("/order.cz?method=shippingMethods"), {method:"post", parameters:queryString, onComplete:loadShippingMethodsCompleted});
}

function loadShippingMethodsForPaypal(postalcode) {
	if (!postalcode) {
		return;
	}
	var queryString = Form.serialize("OrderForm") + "&timestamp=" + new Date().getTime();
	Element.show("shippingmethoesinfo");
	new Ajax.Request(changeForwardUrl("/order.cz?method=shippingMethods"), {method:"post", parameters:queryString, onComplete:loadShippingMethodsCompleted});
}
function loadShippingMethodsCompleted(response) {
	Element.hide("shippingmethoesinfo");
	//var shippingmethods = $("shippingmethods");
	//Element.update(shippingmethods, response.responseText);
	disableButton("button_createOrder", false);
	updateShippingCost();
	loadingShipping = false;
}

function orderReview() {
	var queryString = "&timestamp=" + new Date().getTime();
	new Ajax.Request(changeForwardUrl("/order.cz?method=orderReview"), {method:"post", parameters:queryString});
}

function signin(form) {
	if(!Validation.validateForm(form)) return false;
	
	store_jsessionId = getCookie("JSESSIONID");
	window.donecallback = signinCompleted;
	form.action="/_system/passport/passport.cz?method=signin";
	//form.action="/passport/passport.cz?method=signin";
	form.target = "callbackframe";
	disableButton("button_signIn", true);	
}

function signinCompleted(response) {
	if (store_jsessionId) setCookie("JSESSIONID", store_jsessionId, "", "/", "", "");
	if (response["statusCode"] == 300) {
		disableButton("button_signIn", false);
//		alert(response["message"]);
		alert("Login error: wrong username or password.");
		return;
	} else {
		if (response["statusCode"] == 200) {
			if (response["checkout"]) { checkout();}
			else{
//				if (globalForwardUrl) {
//					loadContent(globalForwardUrl, true);
//				}else{
					myAccount();
//				}
			}
		}
	}
}
function signout() {
	$("signoutForm").submit();
//	document.cookie = "COREZON_AUTHENTICATION=;path=/;domain="+DOMAIN+";expires=Thu, 01-Jan-1970 00:00:01 GMT";
}

function newAccount(form) {

	if(!Validation.validateForm(form)) return false;

	var email = form.email.value;
	var password = form.password.value;
	var companyId = form.corezon_asp_company.value;
	var usertype = form.corezon_asp_usertype.value;
	var backToUrl = form.backToUrl.value;

	userInfo["email"] = email;
	userInfo["companyId"] = companyId;
	userInfo["usertype"] = usertype;
	userInfo["password"] = password;
	userInfo["backToUrl"] = backToUrl;
	
	window.donecallback = newAccountSignin;
	form.action="/account.cz?method=create";
	form.target = "callbackframe";

	disableButton("button_newAccount", true);
}

function newAccountSignin(response) {
	if (response["statusCode"] == 300) {
		disableButton("button_newAccount", false);
		alert(response["message"]);
	} else if (response["statusCode"] == 200) {
		var queryString = "corezon_asp_username="+userInfo["email"]
			+"&corezon_asp_password="+userInfo["password"]
			+"&corezon_asp_usertype="+userInfo["usertype"]
			+"&corezon_asp_company="+userInfo["companyId"]
			+"&backToUrl="+escape(userInfo["backToUrl"])
			+"&timestamp=" + new Date().getTime();
		userInfo.clear();
		loadContent(STORE_SURL+"/signup_done.jsp?"+queryString,true);
	}
}
//start: forget password  
function loadForgetPassword(){
	loadContent("/render.cz?method=forwardPage&name=forgetPassword", true);
}
function forgetPassword(form){
	if(!Validation.validateForm(form)) return false;
	var email = form.corezon_asp_username.value;
	window.donecallback = forgetPasswordCompleted;	
	form.action="/account.cz?method=forgetPassword&email="+email+"&store="+STORE_NAME;
	form.target = "callbackframe";
	disableButton("button_forgetPwd", true);
}
function forgetPasswordCompleted(response){

	if (response["statusCode"] == 300) {
		disableButton("button_forgetPwd", false);
		alert(response["message"]);
		return;
	} else {
		if (response["statusCode"] == 200) {
			Element.update($("forgetEmail"), "<h3>Your password has been sent to you. Please check your email account.</h3>");
			return;
		}
	}
}
//end: forget password
function showGroupItems(groupId){
	loadContent("/render.cz?method=showGroupItems&groupId="+groupId);
}
function loadIndex() {
//	loadContent(STORE_URL+"/index.jsp",true);
	document.location = "/"+STORE_NAME+"/home.html";
}
function listAllCategories(){
	loadContent("/render.cz?method=allcategory", true);
}
function loadCategory(categoryId, pageNum){
	if (!pageNum) pageNum =1;
	loadContent("/render.cz?method=category&categoryId="+categoryId+"&pageNum="+pageNum, true);
}
function loadAccount() {
	loadContent("/validateRender.cz?method=updateAccount", true);
}
function loadBillAddress() {
	loadContent("/validateRender.cz?method=billAddress", true);
}
function loadShipAddress() {
	loadContent("/validateRender.cz?method=shipAddress", true);
}
function editAccount(form) {
	if(!Validation.validateForm(form)) return false;
	
	window.donecallback = commonUpdateDone;	
	form.action="/account.cz?method=update";
	form.target = "callbackframe";
}

function addBillAddress(form) {
	if(!Validation.validateForm(form)) return false;
	
	window.donecallback = operationAddressDone;
	form.action="/account.cz?method=addBillingAddress";
	form.target = "callbackframe";
	
	disableButton("button_newAddr", true);	
}

function addShipAddress(form) {
	if(!Validation.validateForm(form)) return false;
	
	window.donecallback = operationAddressDone;
	form.action="/account.cz?method=addShippingAddress";
	form.target = "callbackframe";

	disableButton("button_newAddr", true);	
}

function removeBillAddress(addressId) {
	if (confirm("Are you sure?")) {
		var queryString = "addressId=" + addressId + "&timestamp=" + new Date().getTime();
		new Ajax.Request(changeForwardUrl("/account.cz?method=removeAddress"), {method:"post", parameters:queryString, onComplete:removeBillAddressDone});		
	}
}

function removeShipAddress(addressId) {
	if (confirm("Are you sure?")) {
		var queryString = "addressId=" + addressId + "&timestamp=" + new Date().getTime();
		new Ajax.Request(changeForwardUrl("/account.cz?method=removeAddress"), {method:"post", parameters:queryString, onComplete:removeShipAddressDone});		
	}
}
function removeBillAddressDone(response) {
	var ajaxResponse = response.responseXML.getElementsByTagName("response");

	if (ajaxResponse[0].getAttribute("statusCode") == 300) {
		alert(ajaxResponse[0].getAttribute("message"));
		return;
	} else {
		if (ajaxResponse[0].getAttribute("statusCode") == 200) {
			loadContentURL("billAddressDiv", "/validateRender.cz?method=billAddressList");
		}
	}
}
function removeShipAddressDone(response) {
	var ajaxResponse = response.responseXML.getElementsByTagName("response");
	if (ajaxResponse[0].getAttribute("statusCode") == 300) {
		alert(ajaxResponse[0].getAttribute("message"));
		return;
	} else {
		if (ajaxResponse[0].getAttribute("statusCode") == 200) {
			loadContentURL("shipAddressDiv", "/validateRender.cz?method=shipAddressList");
		}
	}
}

function operationAddressDone(response) {
	if (response["statusCode"] == 300) {
		disableButton("button_newAddr", false);	
		alert(response["message"]);
		return;
	} else {
		if (response["statusCode"] == 200) {
			myAccount();
		}
	}
}

function loadUpdatePassword(id) {
	loadContent("/validateRender.cz?method=updatePassword&userid=" + id, true);
}

function updatePassword(form) {//alert(Validation.$(form.id).validate())
//	if(!Validation.validateForm(form)) return false;
	if (!Validation.$(form.id).validate()) return false;
	window.donecallback = updatePasswordDone;
	form.action="/account.cz?method=updatePassword";
	form.target = "callbackframe";
}
function updatePasswordDone(response) {
	if (response["statusCode"] == 300) {
		alert(response["message"]);
		return;
	} else {
		if (response["statusCode"] == 200) {
			alert("Your password has been updated.");
			myAccount();
		}
	}
}
function selectBillAddress(address){
	$("bfirstName").value = address["firstName"];
	$("blastName").value = address["lastName"];
	$("baddress").value = address["address"];
	$("baddress2").value = address["address2"];
	$("bcity").value = address["city"];
	$("bfstate").value = address["state"];
	$("bpostalCode").value = address["postalCode"];
	$("bphone").value = address["phone"];
	changeSelectedIndex($("bcountry"), address["country"]);
	changeSelectedIndex($("bstate"), address["state"]);
	changeSelectedIndex($("bprovince"), address["state"]);
	
	sameasbill();
	changeState('bcountry');
	changeState('scountry');
	loadShippingMethods();
}
function selectShipAddress(address){
	$("sfirstName").value = address["firstName"];
	$("slastName").value = address["lastName"];
	$("saddress").value = address["address"];
	$("saddress2").value = address["address2"];
	$("scity").value = address["city"];
	$("sfstate").value = address["fstate"];
	$("spostalCode").value = address["postalCode"];
	$("sphone").value = address["phone"];
	changeSelectedIndex($("scountry"), address["country"]);
	changeSelectedIndex($("sstate"), address["state"]);
	changeSelectedIndex($("sprovince"), address["state"]);
	
	changeState('scountry');
	loadShippingMethods();
}

function createOrder(form) {
	if(!Validation.validateForm(form)) return false;
	window.donecallback = createOrderComplete;
//	form.action="/order.cz?method=checkout";
	form.target = "callbackframe";
	disableButton("button_createOrder", true);
}

function createOrderComplete(response) {

	if (response["statusCode"] == 300) {
		disableButton("button_createOrder", false);
		alert(response["message"]);
		return;
	} else if (response["statusCode"] == 301) { //credit card authorize failed
		alert(response["message"]);
		var oform  = $("OrderForm");
		oform.method.value="reAuthorize";
//		oform.action="/order.cz?method=reAuthorize";
		oform.orderId.value=response["objectId"];
		disableButton("button_createOrder", false);
		return;
	}else if (response["statusCode"] == 200) {
		var orderId = response["objectId"];
		var oPaymentTerm = $("paymentTerm");

		// -----begin by Nainse 
		//Google Checkout
	
//			if(oPaymentTerm && oPaymentTerm.value == "Google Checkout"){
//				if(checkoutMode.checked){
//					submitGoogleCheckout();
//				}
//			}
		//Paypal
		if(oPaymentTerm && oPaymentTerm.value=="Paypal"){
			submitPaypal(orderId.split(",")[0]);
		} else {
			//Credit card
			loadContent("/order.cz?method=orderconfirm&orderId=" + orderId + "&store=" + STORE_NAME, true);	
		}
		// -----end
	}
}

function sameasbill(same) {
	var sameTrue = $("sameYes").checked;
	if (typeof(sameTrue)=="undefined")
		sameTrue = true;
	if (same == "N" || !sameTrue){
		if ($("shppingInfoLayer")) $("shppingInfoLayer").style.display = "";
		$("sfirstName").value = "";
		$("slastName").value = "";
		changeSelectedIndex($("scountry"), "US");
		$("saddress").value = "";
		$("saddress2").value = "";
		$("scity").value = "";
		$("sstate").selectedIndex = "";
		$("sfstate").value = "";
		$("sprovince").selectedIndex = "";
		$("spostalCode").value = "";
		$("sphone").value = "";	
	}else{
		if ($("shppingInfoLayer")) $("shppingInfoLayer").style.display = "none"
		$("sfirstName").value = $("bfirstName").value;
		$("slastName").value = $("blastName").value;	
		$("scountry").selectedIndex = $("bcountry").selectedIndex;
		$("saddress").value = $("baddress").value;
		$("saddress2").value = $("baddress2").value;
		$("scity").value = $("bcity").value;
		$("sstate").selectedIndex = $("bstate").selectedIndex;
		$("sfstate").value = $("bfstate").value;
		$("sprovince").selectedIndex = $("bprovince").selectedIndex;
		$("spostalCode").value = $("bpostalCode").value;
		$("sphone").value = $("bphone").value;
	}
	
}

function checkPassword(pwdDiv) {
	var password = $("password").value;
	var confirmPassword = $("confirmPassword").value;
	if (password != confirmPassword) {
		$(pwdDiv).innerHTML = "<font color=red >password and confirmPassword must be the same</font>";
//		$("confirmPassword").focus();
		return;
	} else {
		$(pwdDiv).innerHTML = "";
	}
}


function getSalesTaxRate(){
	var scountry = $F("scountry");
	var spostalCode = $F("spostalCode");
	var sstate = $F("sstate");
	
	if (!scountry ||!spostalCode || !sstate){
//		alert("The shipping state and postalCode is required!")
		return;
	}
	if (scountry == "US" && spostalCode && sstate) {
		var queryString = "sstate=" + sstate +"&spostalCode=" + spostalCode  + "&timestamp=" + new Date().getTime();
		new Ajax.Request(changeForwardUrl("/order.cz?method=getSalesTaxRate"), {method:"post", parameters:queryString, onComplete:getSalesTaxRateDone});
	}
}

function getSalesTaxRateDone(ajaxResponse) {
	
//	alert("ajaxResponse"+ajaxResponse.responseText);
	var response = ajaxResponse.responseXML.getElementsByTagName("response");
	if (response[0].getAttribute("statusCode") == 300) {
		alert(response[0].getAttribute("message"));
		return;
	}else if (response[0].getAttribute("statusCode") == 200){
		updateTaxRate(response[0].getAttribute("taxRate"));
	}
}
function _getCusCurrency() {
	var cur = $("cus_currency").value;
	return cur;
}
function reloadOrderTotalInfo(){
	if(shippingCostType == 8){
//		$("info_shippingCost").innerHTML = sShippingMessage;
		$("info_shippingCost").innerHTML = formatCurrency($F("order_handingFee"), _getCusCurrency());
	}else {
		$("info_shippingCost").innerHTML = formatCurrency(parseFloat($F("order_shippingCost"))+parseFloat($F("order_handingFee")), _getCusCurrency());
	}
	$("info_tax").innerHTML = formatCurrency($F("order_tax"), _getCusCurrency());
	$("info_total").innerHTML = formatCurrency($F("order_total"), _getCusCurrency());
}

function updateTaxRate(taxRate){
	var discountAmount = parseFloat($F("order_discountAmount"));
	var subTotal = parseFloat($F("order_subTotal"));
	var taxTotal = parseFloat($F("order_taxabletotal"));
	var shippingCost = parseFloat($F("order_shippingCost"));
	var tax = taxRate * taxTotal;
	var handingFee = parseFloat($F("order_handingFee"));
	$("order_tax").value = tax;
	$("order_total").value = subTotal+shippingCost+tax+handingFee-discountAmount;
	reloadOrderTotalInfo();
}
var shippingCostType = 0;
var sShippingMessage = "";
function updateShippingCost(){
	var shippingMethod = document.getElementsByName("shippingMethod");
	for (var i=0; i<shippingMethod.length; i++){
		if (shippingMethod[i].checked == true){
			var shippingCost = shippingMethod[i].value;
			var shippingInfo = shippingCost.split(",");
			shippingCostType = shippingInfo[shippingInfo.length-2];
			sShippingMessage= shippingInfo[shippingInfo.length-1];
			if(shippingCostType != 8){

				shippingCost = shippingInfo[shippingInfo.length-3];
				
				if(!shippingCost){shippingCost = 0;}
				$("order_shippingCost").value=shippingCost;
			}
			break;
		}
	}

	var discountAmount = parseFloat($F("order_discountAmount"));
	var subTotal = parseFloat($F("order_subTotal"));
	var shippingCost = 0;
	if(shippingCostType != 8){shippingCost = parseFloat($F("order_shippingCost"));}
	var tax = parseFloat($F("order_tax"));
	var handingFee = parseFloat($F("order_handingFee"));
	var total= subTotal+shippingCost+tax+handingFee-discountAmount;
	$("order_total").value = total;

	reloadOrderTotalInfo();
}

function listOrdersByAccount(pageNum) {
	if (typeof (pageNum) == "undefined") {
		pageNum = "1";
	}
	loadContentURL("orderListDiv", "/validateRender.cz?method=listOrderByAccount" + "&pageNum=" + pageNum);
}	


function showPaymentForm(value){
	if(value == "Credit Card"){
		$("creditcardinfo").style.display="";
		$("payerName").className="required";
		$("paymentType").className="required";
		$("cardNo").className="required";
		$("expireMonth").className="required";
		$("expireYear").className="required";
		$("papal_alert").style.display = "none";
	}else{
		if(value == 'Paypal') {
			$("papal_alert").style.display = "";
		} else {
			$("papal_alert").style.display = "none";
		}
		$("creditcardinfo").style.display="none";
		$("payerName").className="";
		$("paymentType").className="";
		$("cardNo").className="";
		$("expireMonth").className="";
		$("expireYear").className="";
	}	
}

//////////////////////////////////////////////////

	//start :payment --paypal
function paypalCheckout(){
	if(!isGreaterThanQuantity()) {
		return;
	}
	new Ajax.Request(changeForwardUrl("/paypal.cz?view=SetExpressCheckout"), {method:"post", parameters:Form.serialize("paypalForm"), onComplete:getSetExpressCheckoutDone});
}
function getSetExpressCheckoutDone(ajaxResponse){
	var response = ajaxResponse.responseXML.getElementsByTagName("response");

	if (response[0].getAttribute("statusCode") == 300) {
		alert(response[0].getAttribute("message"));
		return;
	}else if (response[0].getAttribute("statusCode") == 200){
		var url=response[0].getAttribute("forwardUrl");
		window.parent.location=unescape(url);
	}
}
function createPaypalOrder(orderForm) {
	if(!Validation.validateForm(orderForm)) return false;
	
	window.donecallback = createPaypalOrderComplete;	
	orderForm.action="/order.cz?method=checkout";
	orderForm.target = "callbackframe";

	var paypalForm = $("paypalForm");
	paypalForm.shippingAmt.value= parseFloat($F("order_shippingCost"))+parseFloat($F("order_handingFee"));
	paypalForm.taxAmt.value= $F("order_tax");
	paypalForm.itemAmt.value= $F("order_subTotal");
	paypalForm.amt.value= $F("order_total");
	
	disableButton("button_createOrder", true);
}
function createPaypalOrderComplete(response){
	if (response["statusCode"] == 300) {
		disableButton("button_createOrder", false);
		alert(response["message"]);
		return;
	} else {
		if (response["statusCode"] == 200) {
			var orderId = response["objectId"];
			new Ajax.Request(changeForwardUrl("/paypal.cz"), {method:"post", parameters:Form.serialize("paypalForm")+"&view=DECPCheckoutWithPaypal&orderId="+orderId, onComplete:DoExpressCheckoutPaymentDone});
		}
	}
}

function DoExpressCheckoutPaymentDone(ajaxResponse){
	var response = ajaxResponse.responseXML.getElementsByTagName("response");
	if (response[0].getAttribute("statusCode") == 300) {
		alert(response[0].getAttribute("message"));
		return;
	}else if (response[0].getAttribute("statusCode") == 200){
			var orderId = response[0].getAttribute("objectId");
			loadContent("/order.cz?method=orderconfirm&orderId=" + orderId, true);
	}
}
//end:payment --paypal

// ----begin by Nainse   	#08/09/2007
// some functions for  Google Checkout

function getStateName() {
	// get the name State chose by customer
	var scountry = $F("scountry");
	var sstate = $F("sstate");
	if(scountry=='US'){
		$("tax_us_state").value=sstate;
	}
	
}

function getShippingAttributes(){
	// get shipping method ,obtain it's name and price
	
		var shippingMethod = document.getElementsByName("shippingMethod");
	for (var i=0; i<shippingMethod.length; i++){
		if (shippingMethod[i].checked == true){
			var shippingCost = shippingMethod[i].value;
			var array=shippingCost.split(",");
			// Get ShippingMethodName
			$("ship_method_name_1").value =array[1]; 
			// Get ShippingMethodPrice
			$("ship_method_price_1").value =array[2];
			break;
		}
	}
}

function getSalesTaxRateForCheckout(){
	var scountry = $F("scountry");
	var spostalCode = $F("spostalCode");
	var sstate = $F("sstate");
	
	if (!spostalCode || !sstate){
		alert("The shipping state and postalCode is required!")
		return;
	}
	
	if ($F("scountry") == "US" && spostalCode.length > 0 && sstate.length > 0) {
		var queryString = "sstate=" + sstate +"&spostalCode=" + spostalCode  + "&timestamp=" + new Date().getTime();
		new Ajax.Request(changeForwardUrl("/order.cz?method=getSalesTaxRate"), {method:"post", parameters:queryString, onComplete:getSalesTaxRateForCheckoutDone});
	}
}

function getSalesTaxRateForCheckoutDone(ajaxResponse){
	var response = ajaxResponse.responseXML.getElementsByTagName("response");
	if (response[0].getAttribute("statusCode") == 300) {
		alert(response[0].getAttribute("message"));
		return;
	}else if (response[0].getAttribute("statusCode") == 200){
		// fill the checkout form with tax rate of currently State
		$("tax_rate").value = response[0].getAttribute("taxRate"); 
		
		// fill the checkout form with State of US
		getStateName();
		// fill the checkout form with shipping attributes
		getShippingAttributes();
		// submit google checkout form
	    document.forms["googleCheckoutForm"].submit();
	}
}

function submitGoogleCheckout(){
	// correspond to a interface for the function createOrderComplete(ajaxResponse)
	getSalesTaxRateForCheckout();
}

function submitPaypal(orderId){
	window.parent.location = "/order.cz?method=paypalForm&orderId="+orderId + "&store=" + STORE_NAME;
}

function paypalDoExpressCheckoutDone(ajaxResponse){
	var response = ajaxResponse.responseXML.getElementsByTagName("response");
	if (response[0].getAttribute("statusCode") == 300) {
		alert(response[0].getAttribute("message"));
		$("paypalConnectInfo").innerHTML="&nbsp;";
		return;
	}else if (response[0].getAttribute("statusCode") == 200){
		var orderId=response[0].getAttribute("objectId");
		loadContent("/order.cz?method=orderconfirm&orderId=" + orderId, true);
	}
}
// ----end
//start: google checkout
function googleCheckout(){
	if(!isGreaterThanQuantity()) {
		return;
	}
	new Ajax.Request(changeForwardUrl("/render.cz?method=createGoogleOrder"), {method:"post", onComplete:googleCheckoutDone});
}
function googleCheckoutDone(ajaxResponse){
	var response = ajaxResponse.responseXML.getElementsByTagName("response");
	if (response[0].getAttribute("statusCode") == 300) {
		alert(response[0].getAttribute("message"));
		return;
	}else if (response[0].getAttribute("statusCode") == 200){
		var url=response[0].getAttribute("forwardUrl");
		url=url.replace("####","&");
		window.location.href=url;//express checkout 
	}
}
//end :google checkout


function categoryChange(nav_menu,interval){
	   var aWidth = 0;
       var obj = $(nav_menu);
       $A(obj.childNodes).each(function(node){
         var li = document.createElement("li");
	      var span = document.createElement("span");
          if(node.nodeType == 1) {
           var temp = node.childNodes[0].nodeValue;
       	  $(node).innerHTML = "<span>"+temp+"</span>";
            li.appendChild(node);
            obj.appendChild(li);        
            aWidth += ($(li).childNodes[0].offsetWidth+interval);
            $(li).className = $(node).className;
            $(node).className = "";
            if(aWidth > parseInt(obj.style.width)){
            	$(li).parentNode.removeChild($(li));
            	$(node).innerHTML = temp;
                if($("NM_more")){
            	  $("NM_more").appendChild($(li));
                }
            }
       	 }
       });
     if($("NM_more")&&$("NM_more").getElementsByTagName("li").length > 0){
         $("nav_more").show();
     }
}

//end :category style

function categoryChangeSix(nav_menu,interval){
      var liWidth = 0;
      var length = $(nav_menu).offsetWidth;
      $A($("MenuBar1").childNodes).each(function(node){
        if(node.nodeType == 1){  
          liWidth += $(node).offsetWidth + interval;         
          $A($(node).childNodes).each(function(xnode){
             if(xnode.nodeType==1 && xnode.nodeName.toLowerCase()== "a"){
                var span = document.createElement("span");
	  	        $(xnode).appendChild($(span));
             }
             if(xnode.nodeType==1 && xnode.nodeName.toLowerCase()=="ul"){
                if($(xnode).childNodes.length>1){
                  $A($(xnode).childNodes).each(function(inode){
                    if(inode.nodeType==1){
                      var li = document.createElement("li");
                      $(li).appendChild($(inode));
                      $(xnode).appendChild($(li));
                    }
                  });
                }else{
                  $(xnode).parentNode.removeChild($(xnode));
                }
             }
          });             
          if(liWidth > length){
           $(node).parentNode.removeChild($(node));
          }
        }
      }); 
  }

  function isGreaterThanQuantity() {
   var i=0;
   var invcontrol=$F("inventoryControl");
   if(invcontrol=="N" || invcontrol=="")
    return true;
   while(true) {
    if($('quantity'+i)) {
     var id=$('quantity'+i).getAttribute("name").substring(6,38);
     var quantity=$F('cartQuantity'+i);
     var prodQuantity=$F(id);
     var productName=$F('name'+i);
     if(parseInt(quantity)>parseInt(prodQuantity)) {
      alert("Sorry!  We only have "+prodQuantity+" "+productName+" product in stock. Please adjust quantity to "+prodQuantity+" .")
      return false;
     }
     i++;
    }else {
     return true;
    }
    }
  }
  
   function disRequiredItem(obj) {
   var bId = obj.id;
   var sId = "s"+bId.substring(1);
   var eId = "advice-required-"+sId;
     if($("advice-required-"+bId)) {
    $("advice-required-"+bId).style.display='none';
    $(bId).className = "required";
   }
   if($(eId))
    $(eId).style.display='none';
   if($(sId))
    $(sId).className = "required";
  }
  	
  //** Tab Content script- Dynamic Drive DHTML code library (http://www.dynamicdrive.com)
//** Last updated: June 29th, 06

var enabletabpersistence=1; //enable tab persistence via session only cookies, so selected tab is remembered?

////NO NEED TO EDIT BELOW////////////////////////
var tabcontentIDs=new Object();

function expandcontent(linkobj){
	var ulid=linkobj.parentNode.parentNode.id; //id of UL element
	var ullist=document.getElementById(ulid).getElementsByTagName("li"); //get list of LIs corresponding to the tab contents
	for (var i=0; i<ullist.length; i++){
		ullist[i].className="";  //deselect all tabs
		if (typeof tabcontentIDs[ulid][i]!="undefined") //if tab content within this array index exists (exception: More tabs than there are tab contents)
			document.getElementById(tabcontentIDs[ulid][i]).style.display="none"; //hide all tab contents
	}
	linkobj.parentNode.className="selected";  //highlight currently clicked on tab
	document.getElementById(linkobj.getAttribute("rel")).style.display="block"; //expand corresponding tab content
	saveselectedtabcontentid(ulid, linkobj.getAttribute("rel"));
}

function savetabcontentids(ulid, relattribute){// save ids of tab content divs
	if (typeof tabcontentIDs[ulid]=="undefined") //if this array doesn't exist yet
		tabcontentIDs[ulid]=new Array();
	tabcontentIDs[ulid][tabcontentIDs[ulid].length]=relattribute;
}

function saveselectedtabcontentid(ulid, selectedtabid){ //set id of clicked on tab as selected tab id & enter into cookie
	if (enabletabpersistence==1) //if persistence feature turned on
		setCookie(ulid, selectedtabid);
}

function getullistlinkbyId(ulid, tabcontentid){ //returns a tab link based on the ID of the associated tab content
	var ullist=document.getElementById(ulid).getElementsByTagName("li")
	for (var i=0; i<ullist.length; i++){
		if (ullist[i].getElementsByTagName("a")[0].getAttribute("rel")==tabcontentid){
			return ullist[i].getElementsByTagName("a")[0];
			break;
		}
	}
}

function initializetabcontent(){
	for (var i=0; i<arguments.length; i++){ //loop through passed UL ids

		if (enabletabpersistence==0 && getCookie(arguments[i])!="") //clean up cookie if persist=off
		setCookie(arguments[i], "")
		var clickedontab=getCookie(arguments[i]) //retrieve ID of last clicked on tab from cookie, if any
		var ulobj=document.getElementById(arguments[i])
		var ulist=ulobj.getElementsByTagName("li") //array containing the LI elements within UL
		for (var x=0; x<ulist.length; x++){ //loop through each LI element
			var ulistlink=ulist[x].getElementsByTagName("a")[0]
			if (ulistlink.getAttribute("rel")){
				savetabcontentids(arguments[i], ulistlink.getAttribute("rel")) //save id of each tab content as loop runs
				ulistlink.onclick=function(){
					expandcontent(this);
					return false;
				}
				if (ulist[x].className=="selected" && clickedontab=="") //if a tab is set to be selected by default
					expandcontent(ulistlink); //auto load currenly selected tab content
			}
		} //end inner for loop
		if (clickedontab!=""){ //if a tab has been previously clicked on per the cookie value
			if(ulist[0]){
				expandcontent(ulist[0].getElementsByTagName("a")[0]); //just auto load first tab instead
			}
		}
	} //end outer for loop
}