/*  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 && decodeURIComponent(queryComponent) !='brandId=Select One Brand'){
          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 value is: %s'],
	['validate-mobile-phone', 'Please enter a valid mobile phone, for example 13910001000, current value 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.messagesSourceEn = [
//  	['validation-failed' , validationFailed['validationFailed']],
//  	['required' ,all_request['all_request']],
//  	['validate-number' , validNumber['validNumber']],
//  	['validate-digits' , onlyNumber['onlyNumber']],
//  	['validate-alpha' , useLetters['useLetters']],
//  	['validate-alphanum' ,lettersNumbers['lettersNumbers']],
//  	['validate-date' , validDate['validDate']],
//  	['validate-email' , email['email']],
//  	['validate-url' , validUrl['validUrl']],
//  	['validate-date-au' , dateFormat['dateFormat']],
//  	['validate-currency-dollar' , validAmount['validAmount']],
//  	['validate-one-required' , selectOptions['selectOptions']],
//  	['validate-date-cn' , useDate['useDate']],
//  	['validate-integer' , validInteger['validInteger']],
//  	['min-value' , minValue['minValue']+' '+'%s'],
//  	['max-value' , maxValue['maxValue']+' '+'%s'],
//  	['min-length' , minLength['minLength']+' '+'%s'+','+currentLength['currentLength']+' '+'%s'],
//  	['max-length' , maxLength['maxLength']+' '+'%s'+','+currentLength['currentLength']+' '+'%s'],
//  	['validate-int-range' , enterInteger['enterInteger']],
//  	['validate-float-range' , enterNumber['enterNumber']+''+'%s'+andto['andto']+' '+'%s'+between['between']],
//  	['validate-length-range' , length['length']+' '+'%s'+andto['andto']+' '+'%s'+','+currentLength['currentLength']+' '+'%s'],
//  	['validate-file' , enterFile['enterFile']+['%s']],
//  	['validate-pattern' , validationFailed['validationFailed']],
//  	['validate-chinese',enterChinese['enterChinese']],
//  	['validate-ip',enterValidIp['enterValidIp']],
//  	['validate-phone',validPhoneNumber['validPhoneNumber']+','+currentLength['currentLength']+' '+'%s'],
//  	['validate-mobile-phone',validMobilePhone['validMobilePhone']+','+currentLength['currentLength']+' '+'%s'],
//  	['validate-equals',equals['equals']],
//  	['less-than',inputValue['inputValue']],
//  	['great-than',inputMaxValue['inputMaxValue']]
//];

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 : false,
			immediate : false,
			focusOnError : false,
			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();
	},

	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]+[\.\w+]*[@](\w)+((\.\w+)+)$/.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:"post", 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 formatImageForNine(oImg, size,size1) {
	var width = oImg.width;
	var height = oImg.height;
	var scale = width / height;
	var scale1 = size / size1;
	if(scale >= scale1){
		oImg.width = size;
		oImg.height = Math.floor((height/width)*size);
	}else if(scale < scale1){
		oImg.height = size1 ;
		oImg.width = Math.floor(scale * size1);
	}
	if (oImg.height < size1) {oImg.style.marginTop = (size1 - 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 if ($F("scountry") == "CN"){
		$("sstate").className = "";
		$("sprovince").className = "";
		$("scstate").className = "required";
		$("sfstate").className = "";
	}else{
		$("sstate").className = "";
		$("sprovince").className = "";
	}
};
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 if ($F("bcountry") == "CN"){
		$("bstate").className = "";
		$("bprovince").className = "";
		$("bcstate").className = "required";
		$("bfstate").className = "";
	}else{
		$("bstate").className = "";
		$("bprovince").className = "";
	}
};

function changeState(country) {
	if (country == "bcountry") {
		if ($F("bcountry") == "US") {
			$("bstateTR").style.display = "";
			$("bcstateTR").style.display = "none";
			$("bprovinceTR").style.display = "none";
			$("bfstateTR").style.display = "none";
		} else if ($F("bcountry") == "CA"){
			$("bstateTR").style.display = "none";
			$("bcstateTR").style.display = "none";
			$("bprovinceTR").style.display = "";
			$("bfstateTR").style.display = "none";
		}else if ($F("bcountry") == "CN"){
			$("bstateTR").style.display = "none";
			$("bcstateTR").style.display = "";
			$("bprovinceTR").style.display = "none";
			$("bfstateTR").style.display = "none";
		}else {
			$("bstateTR").style.display = "none";
			$("bcstateTR").style.display = "none";
			$("bprovinceTR").style.display = "none";
			$("bfstateTR").style.display = "";
		}
		bChangeDestroy();
	} else {
		if($F("scountry") == "US") {
			$("sstateTR").style.display = "";
			$("scstateTR").style.display = "none";
			$("sprovinceTR").style.display = "none";
			$("sfstateTR").style.display = "none";
		}else if ($F("scountry") == "CA"){
			$("sstateTR").style.display = "none";
			$("scstateTR").style.display = "none";
			$("sprovinceTR").style.display = "";
			$("sfstateTR").style.display = "none";
		}else if ($F("scountry") == "CN"){
			$("sstateTR").style.display = "none";
			$("scstateTR").style.display = "";
			$("sprovinceTR").style.display = "none";
			$("sfstateTR").style.display = "none";
		}else{
			$("sstateTR").style.display = "none";
			$("scstateTR").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鐨刬d
 * 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.");
		// alert(test['applyCoupon']);
		$("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 = jQuery("input[name=required_op]");
	if(required_ops.length > 0){
		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;
			}
		}
	}
	return true;
}

function addItemToCart(form) {
	var len = jQuery("#optionSelect").val().split("-").length;
	if(len < jQuery("#optionSize").val()){
		alert("Please select all the options.");
		return;
	}
	
	if ($("button_addToCart"))
		disableButton("button_addToCart", true);
	
	if($("inventoryControl") && $("inventoryControl").value=="true"){
		checkInStock(form);
	}else{
		var optionSelect = jQuery("#optionSelect").val();
		var optionSku = jQuery("#optionSku").val();
		var queryString = Form.serialize(form) + "&optionSelect="+optionSelect+"&optionSku="+optionSku+"&timestamp=" + new Date().getTime();
		new Ajax.Request(changeForwardUrl("/cart.cz?method=addToCart"), {
			method : "post",
			parameters : queryString,
			onComplete : addToCartComplete
		});
	}
}

function checkInStock(form){
	var productId = $(form).productId.value;
	var quantity = $(form).quantity.value;
	var queryString = "&productInfo="+productId+"|"+quantity;
	var optionValueId = "";
	if($("optionStock") && $("optionStock").value=="true"){
		optionValueId = jQuery("#optionSelect").val();
	}
	queryString += "|"+optionValueId;
	queryString += "|"+form;
	queryString += "&timestamp="+ new Date().getTime();
	new Ajax.Request(changeForwardUrl("/cart.cz?method=checkInStock"), {
		method : "post",
		parameters : queryString,
		onComplete : checkInStockComplete
	});
}

function checkInStockComplete(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{
		var form = responseNode[0].getAttribute("objectId");
		var optionSelect = jQuery("#optionSelect").val();
		var optionSku = jQuery("#optionSku").val();
		var queryString = Form.serialize(form) + "&optionSelect="+optionSelect+"&optionSku="+optionSku+"&timestamp=" + new Date().getTime();
		new Ajax.Request(changeForwardUrl("/cart.cz?method=addToCart"), {
			method : "post",
			parameters : queryString,
			onComplete : addToCartComplete
		});
	}
}

// add by bao for rfqcart
function addItemToRFQCart(form) {
	var productId = $(form).productId.value;
	var productType = $(form).productType.value;
	var quantity = $(form).rfq_quantity.value;
	if ($("button_addToRFQCart"))
		disableButton("button_addToRFQCart", true);
	var queryString = "&productId=" + productId +"&productType="+ productType + "&quantity=" +quantity+
					  "&timestamp=" + new Date().getTime();
	new Ajax.Request(changeForwardUrl("/rfq.cz?action=addToRFQCart"), {
		method : "post",
		parameters : queryString,
		onComplete : addToRFQCartComplete
	});
}

function addItemToRfqCart() {
	var quantity = $("quantity_new").value;
	if (quantity == null || quantity == "") {
		alert("Qty is required.");
		$("quantity_new").focus();
		return;
	}else if(quantity == 0) {
		alert("Qty should be bigger than zero.");
		return;
	}
	
	var sku = $("sku_new").value;
	if (sku == null || sku == "") {
		alert("Item # is required.");
		$("sku_new").focus();
		return;
	}
	
	var mfg = $("mfg_new").value;
	if (mfg == null || mfg == "") {
		alert("Manufacturer is required.");
		$("mfg_new").focus();
		return;
	}
	
	var name = $("name_new").value;
	if (name == null || name == "") {
		alert("Product Name is required.");
		$("name_new").focus();
		return;
	}
	
	var queryString = "&productName="+name+"&sku="+sku+"&mfg="+mfg+"&qtyNeeded="+quantity
	     + "&timestamp="+ new Date().getTime();
	new Ajax.Request(changeForwardUrl("/rfq.cz?action=addToRfqCart"), {
		method : "post",
		parameters : queryString,
		onComplete : addToRFQCartComplete
	});
}

function addItemsToOfferCart(){
	if ($("button_addToOfferCart")) disableButton("button_addToOfferCart", true);
	if(!checkOffers()){  
		disableButton("button_addToOfferCart", false);
		return;
	}
	
	var queryString = "";
	var pids = document.getElementsByName("productId");
	var isZero = /^0(\.0*)?$/;
	for(var i=0;i<pids.length;i++){
		var flag = true;
		var quantity = $("quantity"+i).value;
		var price = $("price"+i).value;
		if(quantity != "" && price != "" && !isZero.test(quantity) && !isZero.test(price)){
			queryString = queryString + "&productId="+pids[i].value+"&price="+price+"&qtyNeeded="+quantity;
		}else if(isZero.test(price) && !isZero.test(quantity)){
			document.getElementById("mess").innerHTML = "Offer Price should not be zero.";
			$("showMsg").style.display = "";
			disableButton("button_addToOfferCart", false);
			$("price" + i).focus();
			flag =  false;
			break;
		}else if(!isZero.test(price) && isZero.test(quantity)){
			document.getElementById("mess").innerHTML ="Qty Needed should not be zero."
			$("showMsg").style.display = "";
			disableButton("button_addToOfferCart", false);		
			$("quantity" + i).focus();
			flag = false;
			break;
		}	
	}
	if(flag){
		if(queryString == ""){
			$("showMsg").style.display = "";
			document.getElementById("mess").innerHTML ="Please fill in at least one valid data.";		
			disableButton("button_addToOfferCart", false);
			return flag;
		}
	}else{
		return flag;
	}
	
	queryString = queryString + "&timestamp=" + new Date().getTime();
	/*new Ajax.Request(
		changeForwardUrl("/offer.cz?method=addToOfferCart"),
		{
			method : "get",
			parameters : queryString,
			onComplete : addToOfferCartComplete
		});*/
	loadContent("/offer.cz?method=addToOfferCart" + queryString, true);
}

function addItemToOfferCart(productId) {
	loadContent("/offer.cz?method=addToOfferCart&productId=" + productId, true);
}

function gotoOfferProductList(page) {
	if (!page)
		page = 1;
	loadContent("/offer.cz?method=gotoOfferProductList&pageNum=" + page, true);
}

function checkOffers() {
	var pids = document.getElementsByName("productId");
	var truth = true;
	for ( var i = 0; i < pids.length; i++) {
		var quantity = $("quantity" + i).value;
		var price = $("price" + i).value;
		var qty = $("qty" + i).value;
		if (quantity != "" && !quantity.isNumber()) {
			document.getElementById("mess").innerHTML ="Qty Needed should be a positive number.";
			$("showMsg").style.display = "";
			$("quantity" + i).focus();
			truth = false;
			break;
		}
		if (parseInt(quantity) > parseInt(qty)) {
			document.getElementById("mess").innerHTML ="Qty Needed should not be bigger than Available Quantity.";
			$("showMsg").style.display = "";
			$("quantity" + i).focus();
			truth = false;
			break;
		}
		var checkdecimal1 = /^[1-9]{1}[0-9]{0,7}(\.[0-9]{1,2})?$/;
		var checkdecimal2 = /^0(\.[0-9]{1,2})?$/;
		if (price != "" && !checkdecimal1.test(price)
				&& !checkdecimal2.test(price)) {
			document.getElementById("mess").innerHTML ="Price should be a valid decimal.";
			$("showMsg").style.display = "";
			$("price" + i).focus();
			truth = false;
			break;
		}

		if (quantity == "" && price != "") {
			document.getElementById("mess").innerHTML ="Qty Needed should not be empty.";
			$("showMsg").style.display = "";
			$("quantity" + i).focus();
			truth = false;
			break;
		}

		if (price == "" && quantity != "") {
			document.getElementById("mess").innerHTML ="Price should not be empty.";
			$("showMsg").style.display = "";
			$("price" + i).focus();
			truth = false;
			break;
		}
	}
	if(truth){
		$("showMsg").style.display = "none";
	}
	return truth;
}

function checkQty(obj) {
	var quantity = $("quantity" + obj).value; 
	var isZero = /^0(\.0*)?$/;
	var flag = true;
		if(!isZero.test(quantity)){
			if (!quantity.isPositiveInteger()){
				document.getElementById("mess").innerHTML ="Qty Needed should be a positive number.";
				$("showMsg").style.display = "";
				$("quantity" + obj).focus();
				flag =  false;
			}else{
				var qty = $("qty" + obj).value;
				if(parseInt(quantity) > parseInt(qty)){
					document.getElementById("mess").innerHTML ="Qty Needed should be smaller than Available Quantity.";
					$("showMsg").style.display = "";
					$("quantity" + obj).focus();
					flag =  false;
				}else{
					flag =  true;
				}
			}
		}else{
			var price = $("price" + obj).value;
			if(!isZero.test(price)){
				document.getElementById("mess").innerHTML = "Qty Needed should not be zero.";
				$("showMsg").style.display = "";
				$("quantity" + obj).focus();
				flag =  false;
			}else{
				flag =  true;
			}
		}
	if(flag){
		$("showMsg").style.display = "none";
	}
	return flag;
}	

function checkPrice(obj) {
	var price = $("price" + obj).value;
	var checkdecimal1 = /^[1-9]{1}[0-9]{0,7}(\.[0-9]{1,2})?$/;
	var checkdecimal2 = /^0(\.[0-9]{1,2})?$/;
	var isZero = /^0(\.0*)?$/;
	flag = true;
	if(!isZero.test(price)){
		if(checkdecimal1.test(price) || checkdecimal2.test(price)){
			flag = true;
		}else{
			document.getElementById("mess").innerHTML = "Price should be a valid decimal.";
			$("showMsg").style.display = "";
			$("price" + obj).focus();
			flag = false;
		}	
	}else{
		var quantity = $("quantity" + obj).value;
		if(!isZero.test(quantity)){
			document.getElementById("mess").innerHTML = "Price should not be zero ";
			$("showMsg").style.display = "";
			$("price" + obj).focus();
			flag = false;
		}else{
			flag = true;
		}
	}
	if(flag){
		$("showMsg").style.display = "none";
	}
	return flag;
}

function getProductsInStock(page) {
	if (!page)
		page = 1;
	loadContent("/render.cz?method=getProductsInStock&pageNum=" + page, true);
}

function createRFQ(form) {
	if (!checkItemQtys())
		return;
	
	var company = $("company").value;
	var firstName = $("firstName").value;
	var lastName = $("lastName").value;
	var email = $("email").value;
	var telephone = $("telephone").value;
	var message = $("message").value;
	if (company == "") {
		alert("Company is required");
		// alert(companyRequired['companyRequired']);
		return;
	}
	if (firstName == "") {
		alert("First Name is required");
		// alert(first_Name['first_Name']);
		return;
	}
	if (lastName == "") {
		alert("Last Name is required");
		// alert(last_Name['last_Name']);
		return;
	}
	if (email == "") {
		alert("Email Address is required");
		// alert(email_Add['email_Add']);
		return;
	}
	var reg = /^[\w]+[\.\w+]*[@](\w)+((\.\w+)+)$/;
	if (email != "" && !reg.test(email)) {
		alert("Please enter a valid email address.");
		// alert(email_Valid['email_Valid']);
		return false;
	}
	if (telephone == "") {
		alert("Phone Number is required");
		// alert(phone_Number['phone_Number']);
		return;
	}
	if (message == "") {
		alert("Message is required");
		// alert(rfq_message['rfq_message']);
		return;
	}
	if ($("button_createRFQ"))
		disableButton("button_addToRFQCart", true);
	var queryString = Form.serialize(form) + "&timestamp="
			+ new Date().getTime();
	disableButton("button_createRFQ", true);
	new Ajax.Request(changeForwardUrl("/rfq.cz?action=createRfq"), {
		method : "post",
		parameters : queryString,
		onComplete : createRFQComplete
	});
}

function createRFQ2(form) {
	if (!checkItemQtys())
		return;
	/*if (!isGreaterThanQuantity())
		return;*/
	var message = $("message").value;
	if (message == "") {
		alert("Message is required");
		// alert(rfq_message_cat['rfq_message_cat']);
		return;
	}
	if ($("button_createRFQ"))
		disableButton("button_addToRFQCart", true);
	var queryString = Form.serialize(form) + "&timestamp="
			+ new Date().getTime();
	disableButton("button_createRFQ", true);
	new Ajax.Request(changeForwardUrl("/rfq.cz?action=createRfq"), {
		method : "post",
		parameters : queryString,
		onComplete : createRFQComplete
	});
}

function checkMessage() {
	var notes = $("notes").value;
	var flag = true;
	if (notes != null && notes.length > 200) {
		document.getElementById("mess").innerHTML = "Message length must be smaller than 200.";
		$("showMsg").style.display = "";
		$("notes").value = "";
		$("notes").focus();
		flag = false;
	}
	if(flag){
		$("showMsg").style.display = "none";
	}
	return flag;
}

function createOffer() {
	var productId = document.getElementsByName("productId");
	if(productId.length > 0){	
		if ($("button_createOffer")){
			disableButton("button_createOffer", true);
		}
		if (!checkItemQtys() || !checkItemPrice()
				|| !isGreaterThanQuantityForOffer() || !checkMessage()) {
			disableButton("button_createOffer", false);
			return;
		}
		var queryString = "notes=" + $("notes").value + "&timestamp="
				+ new Date().getTime();
		new Ajax.Request(changeForwardUrl("/offer.cz?method=createOffer"), {
			method : "post",
			parameters : queryString,
			onComplete : createOfferComplete
		});		
	}
}

function createRFQComplete(response) {
	var responseNode = response.responseXML.getElementsByTagName("response");
	if (responseNode[0].getAttribute("statusCode") == 300) {
		alert(responseNode[0].getAttribute("message"));
	} else {

		if (responseNode[0].getAttribute("statusCode") == 200) {
			var rfqNo = responseNode[0].getAttribute("objectId");
			var login = responseNode[0].getAttribute("forwardUrl");
			// location.href="/"+STORE_NAME+"/confirm-"+rfqNo+".html?login="+login;
			loadContent("/rfq.cz?action=confirm&rfqNo=" + rfqNo + "&login="
					+ login, true);
		}
	}
}

function createOfferComplete(response) {
	var responseNode = response.responseXML.getElementsByTagName("response");
	if (responseNode[0].getAttribute("statusCode") == 300) {
		alert(responseNode[0].getAttribute("message"));
	} else {

		if (responseNode[0].getAttribute("statusCode") == 200) {
			var offerIds = responseNode[0].getAttribute("objectId");
			loadContent("/offer.cz?method=confirm&offerIds=" + offerIds, true);
		}
	}
}

function addToCart(id, type, qty) {
	var quantity = qty;
	if (!quantity)
		quantity = $F("quantity");

	if (!qtyValue.isPositiveInteger()) {
		alert("Quantity must be a PositiveNumber.");
		// alert(cart_number['cart_number']);
		return;
	}
	if (quantity <= 0) {
		alert("Quantity is less than zero.");
		// alert(cart_quantity['cart_quantity']);
		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 addToRFQCartComplete(response) {
	var responseNode = response.responseXML.getElementsByTagName("response");
	if (responseNode[0].getAttribute("statusCode") == 300) {
		alert(responseNode[0].getAttribute("message"));
		if ($("button_addToRFQCart"))
			disableButton("button_addToRFQCart", false);
		return;
	} else {
		if (responseNode[0].getAttribute("statusCode") == 200) {
			viewRfqCart();
		}
	}
}
function addToOfferCartComplete(response) {
	var responseNode = response.responseXML.getElementsByTagName("response");
	if (responseNode[0].getAttribute("statusCode") == 300) {
		alert(responseNode[0].getAttribute("message"));
		if ($("button_addToOfferCart"))
			disableButton("button_addToOfferCart", false);
		return;
	} else {
		if (responseNode[0].getAttribute("statusCode") == 200) {
			viewOfferCart();
		}
	}
}
function checkout() {
	/*if (!isGreaterThanQuantity()) {
		return;
	}
	// location.href="/"+STORE_NAME+"/checkout.html";
	loadContent("/validateRender.cz?method=checkout&checkout=1", true);*/
	isGreaterThanQuantity(checkout_fun);
}

function checkout_fun() {
	loadContent("/validateRender.cz?method=checkout&checkout=1", true);
}

function skipLoginAndCheckout() {
	// location.href="/"+STORE_NAME+"/guestcheckout.html";
	loadContent("/render.cz?method=checkoutByGuest&checkoutType=3", true);
}
function registerAndCheckout() {
	// location.href="/"+STORE_NAME+"/regcheckout.html";
	loadContent("/render.cz?method=checkoutByGuest&checkoutType=2", true);
}
function register() {
	loadContent("/render.cz?method=register", true);
}
function login() {
	// location.href="/"+STORE_NAME+"/login.html";
	loadContent("/render.cz?method=login", true);
}
function myAccount() {
	// location.href="/"+STORE_NAME+"/myaccount.html";
	loadContent("/validateRender.cz?method=myaccount", true);
}
function allCategory() {
	loadContent("/render.cz?method=forwardPage&name=allcategory", true);
}
function viewCart() {
	location.href = "/" + STORE_NAME + "/cart.html";
	// loadContent("/render.cz?method=cart", true);
}
function viewRfqCart() {
	location.href = "/" + STORE_NAME + "/inqcart.html";
	// loadContent("/render.cz?method=inqCart", true);
}
function viewOfferCart() {
	// location.href="/"+STORE_NAME+"/offer.html";
	loadContent("/offer.cz?method=goToOfferCart", true);
}
function orderDetail(orderId) {
	location.href = "/" + STORE_NAME + "/orderDetail-" + orderId + "-o.html";
	// loadContent("/validateRender.cz?method=orderDetail&orderId="+orderId,
	// true);
}

function quoteDetail(quoteId) {
	location.href = "/" + STORE_NAME + "/quoteDetail-" + quoteId + "-t.html";
	// loadContent("/validateRender.cz?method=quoteDetail&quoteId="+quoteId,
	// true);
}

function quoteToOrder() {
	// if(!isGreaterThanQuantity()) {
	// return;
	// }
	var quoteId = $("quoteId").value;
	// location.href="/"+STORE_NAME+"/quoteToOrder-"+quoteId+".html";
	loadContent("/validateRender.cz?method=quoteToOrder&quoteId=" + quoteId,
			true);
}

function saveRfqNote() {
	var note = $("rfqNote").value;
	var rfqId = $("rfqId").value;
	if (note == "") {
		alert("Please enter the content");
		// alert(enter_content['enter_content']);
		return;
	}
	disableButton("button_Rfq", true);
	queryString = "?method=saveRfqNote&timestamp=" + new Date().getTime();
	new Ajax.Request('/validateRender.cz' + queryString, {
		method : "post",
		parameters : Form.serialize("renderForm"),
		onComplete : rfqDetail2
	});
}

function saveOrderNote() {
	var note = $("orderNote").value;
	if (note == "") {
		alert("Please enter the content");
		// alert(enter_content['enter_content']);
		return;
	}
	disableButton("button_Order", true);
	var queryString = "?method=saveOrderNote&timestamp=" + new Date().getTime();
	new Ajax.Request('/validateRender.cz' + queryString, {
		method : "post",
		parameters : Form.serialize("renderForm"),
		onComplete : orderDetail2
	});
}

function saveQuoteNote() {
	var note = $("quoteNote").value;
	if (note == "") {
		alert("Please enter the content");
		// alert(enter_content['enter_content']);
		return;
	}
	disableButton("button_Quote", true);
	queryString = "?method=saveQuoteNote&timestamp=" + new Date().getTime();
	new Ajax.Request('/validateRender.cz' + queryString, {
		method : "post",
		parameters : Form.serialize("renderForm"),
		onComplete : quoteDetail2
	});
}

function rfqDetail(rfqId) {
	location.href = "/" + STORE_NAME + "/rfqDetail-" + rfqId + "-f.html";
	// loadContent("/validateRender.cz?method=rfqDetail&rfqId="+rfqId, true);
}

function quoteDetail2(ajaxResponse) {
	var response = ajaxResponse.responseXML.getElementsByTagName("response");
	var rfqId = response[0].getAttribute("objectId");
	location.href = "/" + STORE_NAME + "/quoteDetail-" + rfqId + "-t.html";
	// loadContent("/validateRender.cz?method=quoteDetail&quoteId="+rfqId,
	// true);
}

function orderDetail2(ajaxResponse) {
	var response = ajaxResponse.responseXML.getElementsByTagName("response");
	var rfqId = response[0].getAttribute("objectId");
	location.href = "/" + STORE_NAME + "/orderDetail-" + rfqId + "-o.html";
	// loadContent("/validateRender.cz?method=orderDetail&orderId="+rfqId,
	// true);
}

function rfqDetail2(ajaxResponse) {
	var response = ajaxResponse.responseXML.getElementsByTagName("response");
	var rfqId = response[0].getAttribute("objectId");
	location.href = "/" + STORE_NAME + "/rfqDetail-" + rfqId + "-f.html";
	// loadContent("/validateRender.cz?method=rfqDetail&rfqId="+rfqId, true);
}

function searchProducts(pageNum) {
	var keywords = $('searchForm').keywords.value;
	if (!pageNum)
		pageNum = 1;
	if (!keywords) {
		alert("Keywords is required!");
		// alert(keywords['keywords']);
		return false;
	}
	loadContent("/render.cz?method=searchProducts&keywords=" + keywords
			+ "&pageNum=" + pageNum, true);
}
function loadAdvancedSrh() {
	// location.href="/"+STORE_NAME+"/forwardPage.html?name=advancedsearch";
	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 || brandId == "ALL")
			&& (!categoryId || categoryId == "ALL") && !keywords && !priceFrom
			&& !priceTo) {
		alert(advanced_Search['advanced_Search']);
		return false;
	}

	if (priceFrom) {
		if (parseFloat(priceFrom) < 0.00) {
			alert("Warning: The price from is error!");
			// alert(price_From['price_From']);
			oForm.priceFrom.focus();
			return false;
		}
	}
	if (priceTo) {
		if (priceFrom) {
			if (parseFloat(priceTo) < parseFloat(priceFrom)) {
				alert("Warning:The Price To is lower than Price From!");
				// alert(price_To['price_To']);
				oForm.priceTo.focus();
				return false;
			}
		}
		if (parseFloat(priceTo) < 0.00) {
			alert("Warning: The Price To is error!");
			// alert(price_Float['price_Float']);
			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';
		$('listViewButton1').className = 'listview_btnselected';
		$('gridViewButton1').className = 'gridview_btn';
		$('textViewButton1').className = 'textview_btn';
	} else if (viewMark == 'gridview') {
		$('ViewChoose').className = 'gridview';
		$('gridViewButton').className = 'gridview_btnselected';
		$('listViewButton').className = 'listview_btn';
		$('textViewButton').className = 'textview_btn';
		$('gridViewButton1').className = 'gridview_btnselected';
		$('listViewButton1').className = 'listview_btn';
		$('textViewButton1').className = 'textview_btn';
	} else if (viewMark == 'textview') {
		$('ViewChoose').className = 'textview';
		$('textViewButton').className = 'textview_btnselected';
		$('gridViewButton').className = 'gridview_btn';
		$('listViewButton').className = 'listview_btn';
		$('textViewButton1').className = 'textview_btnselected';
		$('gridViewButton1').className = 'gridview_btn';
		$('listViewButton1').className = 'listview_btn';
	}
	if($("viewMark")){
		$("viewMark").value=viewMark;
	}
}
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;
		/*
		 * location.href="/"+STORE_NAME+"/category-"+oForm.categoryId.value+".html?viewMark="+oForm.viewMark.value+"&pageNum="+oForm.pageNum.value
		 * +"&sortBy="+oForm.sortBy.value;
		 */
		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("Qty must be a positive number.");
		// alert(cart_number['cart_number']);
		input.value = beforeUpdQty;
		input.focus();
		return;
	}
}
function checkItemQtys() {
	var i = 0;
	var flag = false;
	var isZero = /^0(\.0*)?$/;
	var message = "";
	while (!flag) {
		if($("quantity"+i)){
			var qtyValue = $("quantity" + i).value;
			var trueth = 0;
			if(qtyValue.length == 0){
				message = "Quantity is required.";
				trueth = 1;
			}else if(!qtyValue.isPositiveInteger()) {
				message = "Quantity must be a positive number.";
				trueth = 1;
			}else{
				flag = false;
			}
			if(trueth == 1){
				document.getElementById("mess").innerHTML = message;
				$("showMsg").style.display = "";
				$("quantity" + i).focus();
				flag = false;
				break;
			}
		}else{
			flag = true;
		}
		i++;
	}
	if(flag){
		$("showMsg").style.display = "none";
	}
	return flag;
}
function checkItemPrice() {
	var i = 0;
	var flag = false;
	while (!flag) {
		if ($("price" + i)) {
			 var message;
		 	 var trueth = 0;
			 var priceValue = $("price" + i).value;
			 var checkdecimal1 = /^[1-9]{1}[0-9]{0,5}(\.[0-9]{1,2})?$/;  
			 var checkdecimal2 = /^0(\.[0-9]{1,2})?$/; 
			 var isZero = /^0(\.0*)?$/;
			 if(priceValue.length == 0){
				 message="Price is required.";
				 trueth = 1;
			 }else if(!checkdecimal1.test(priceValue) && !checkdecimal2.test(priceValue)){
				 message="Price must be a valid decimal.";
				 trueth = 1;
			 }else if(isZero.test(priceValue)){
				message="Price must be greater than zero.";
				trueth = 1;
			 }else{
				 flag = false;
			 }
			 
			 if(trueth == 1 ){
				 document.getElementById("mess").innerHTML = message;
				 $("showMsg").style.display ="";
				 $("price" + i).focus(); 
				 flag = false;
				 break;				  
			 }
		}else{
			  flag = true;
		}
		i++;
	}
	if(flag){
	  $("showMsg").style.display ="none";
	}
	return flag;
}

function isGreaterThanQuantityForOffer() {
	var flag = false;
	var i = 0;
	while (!flag) {
		if ($("quantity" + i)) {
			var quantity = $("qty" + i).value;
			var prodQuantity = $("quantity" + i).value;		
			var productName = $("name" + i).value;
			
			if (parseInt(prodQuantity) > parseInt(quantity)) {
				 document.getElementById("mess").innerHTML = 				
					 "Sorry! We only have" + " " + quantity + " "
						+ productName + " "
						+ "product in stock.";
				 	$("showMsg").style.display ="";
					$("quantity" + i).focus();
					flag = false;
					break;			
			}else{
				flag = false;
			}
		}else{
			flag = true;
		}
		i++;
	}
	if(flag){
		  $("showMsg").style.display ="none";
	}
	return flag;
}

function updateCart() {
	if (!checkItemQtys())
		return;
	
	/*if (!isGreaterThanQuantity())
		return;
	var form = $("cartForm");
	window.donecallback = updateCartDone;
	form.target = "callbackframe";
	form.submit();*/
	isGreaterThanQuantity(updateCart_fun);
}

function updateCart_fun(){
	var form = $("cartForm");
	window.donecallback = updateCartDone;
	form.target = "callbackframe";
	form.submit();
}

function updateRfqCart() {
	if (!checkItemQtys())
		return;
	
	var form = $("cartForm");
	window.donecallback = updateRfqCartDone;
	form.target = "callbackframe";
	form.submit();
}

function updateOfferCart() {	
	if ($("button_createOffer"))
		disableButton("button_createOffer", true);
	if (!checkItemQtys()){		
		disableButton("button_createOffer", false);
		return;
	}
	if (!isGreaterThanQuantityForOffer()){		
		disableButton("button_createOffer", false);
		return;
	}
	if (!checkItemPrice()){
		disableButton("button_createOffer", false);
		return;
	}
	var form = $("offerForm");
	window.donecallback = updateOfferCartDone;
	form.target = "callbackframe";
	form.submit();
}
function updateCartDone(response) {
	if (response["statusCode"] == 300) {
		alert("Updated failed!");
		// alert(updated_failed['updated_failed']);
		return;
	} else {
		if (response["statusCode"] == 200) {
			viewCart();
		}
	}
}
function updateRfqCartDone(response) {
	if (response["statusCode"] == 300) {
		alert("Updated failed!");
		// alert(updated_failed['updated_failed']);
		return;
	} else {
		if (response["statusCode"] == 200) {
			viewRfqCart();
		}
	}
}
function updateOfferCartDone(response) {
	if ($("button_createOffer")){
		disableButton("button_createOffer", false);
	}
	if (response["statusCode"] == 300) {
		alert("Updated failed!");
		return;
	} else {
		if (response["statusCode"] == 200) {
			viewOfferCart();
		}
	}
}

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 changeSmallImage(content,content1,content2, imgUrl,imgUrl1) {
	if (typeof imgUrl == 'undefined') {
		return;
	}
	
	var html = "<div id='"+content1+"' class='imgsm' style='cursor: pointer;' " +
			"onclick=\"changeImage('stdimage','"+imgUrl1+"'), changeLargeImage('viewLargerImage','"+imgUrl1+"');\">"+
		    "<img id='"+content2+"' src='"+imgUrl+"' onload='formatImageForNine(this,80,80)'/></div>";
	Element.update(content,html);

}

function changeImageForTen(content, imgUrl) {
	if (typeof imgUrl == 'undefined') {
		return;
	}
	Element.update(content, "<img src=\"" + imgUrl
			+ "\" onload=\"formatImage(this,250)\">");
}

function changeImageNine(content, imgUrl) {
	if (typeof imgUrl == 'undefined') {
		return;
	}
	Element.update(content, "<img src=\"" + imgUrlchangeImage
			+ "\" onload=\"formatImageForNine(this,400,528)\">");
}

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 changeSmallImage(content, imgUrl,id) {
	if (typeof imgUrl == 'undefined') {
		return;
	}
	Element.update(content, "<img id='"+id+"' src=\"" + imgUrl
			+ "\" onload=\"formatImageForNine(this,80,80)\">");
}*/

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 removeRfqCartItem(productId, itemType, optionsKey) {
	var queryString = "action=remove&productId=" + productId + "&productType="
			+ itemType + "&optionsKey=" + optionsKey + "&timestamp="
			+ new Date().getTime();
	new Ajax.Request(changeForwardUrl("../rfq.cz"), {
		method : "post",
		parameters : queryString,
		onComplete : removeRfqCartItemDone
	});
}
function removeOfferCartItem(productId, itemType, optionsKey) {
	var queryString = "&productId=" + productId + "&productType=" + itemType
			+ "&optionsKey=" + optionsKey + "&timestamp="
			+ new Date().getTime();
	new Ajax.Request(changeForwardUrl("/offer.cz?method=remove"), {
		method : "post",
		parameters : queryString,
		onComplete : removeOfferCartItemDone
	});
}
function removeCartItemDone(response) {
	var responseNode = response.responseXML.getElementsByTagName("response");
	if (responseNode[0].getAttribute("statusCode") == 300) {
		alert(responseNode[0].getAttribute("message"));
		return;
	} else {
		if (responseNode[0].getAttribute("statusCode") == 200) {
			viewCart();
		}
	}
}
function removeRfqCartItemDone(response) {
	var responseNode = response.responseXML.getElementsByTagName("response");
	if (responseNode[0].getAttribute("statusCode") == 300) {
		alert(responseNode[0].getAttribute("message"));
		return;
	} else {
		if (responseNode[0].getAttribute("statusCode") == 200) {
			viewRfqCart();
		}
	}
}
function removeOfferCartItemDone(response) {
	var responseNode = response.responseXML.getElementsByTagName("response");
	if (responseNode[0].getAttribute("statusCode") == 300) {
		alert(responseNode[0].getAttribute("message"));
		return;
	} else {
		if (responseNode[0].getAttribute("statusCode") == 200) {
			viewOfferCart();
		}
	}
}
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("Qty must be a number.");
		// alert(cart_number['cart_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 quoteId = "";
	if ($("quoteId")) {
		quoteId = $("quoteId").value;
	}
	var country = $("scountry").value;
	if (!loadingShipping && country == "US" && postalcode.length == 5) {
		loadingShipping = true;
		getSalesTaxRate();
		var queryString = Form.serialize("OrderForm") + "&quoteId=" + quoteId
				+ "&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;
//commented by xuyuanzhi
/**	var quoteId = "";
	if ($("quoteId")) {
		quoteId = $("quoteId").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) {
	disableButton("button_signin", true);

	if (!Validation.validateForm(form)) {
		disableButton("button_signin", false);
		return false;
	}
	new Ajax.Request(changeForwardUrl("/login.cz?method=signin"), {
		method : "post",
		parameters : Form.serialize(form),
		asynchronous : true,
		onComplete : function(response) {
			/*var jsonObj = eval(response.responseText);
			if (jsonObj && jsonObj.code == 'S') {
				if (form['backToUrl'] && form['backToUrl'].value != "") {
					window.location = form['backToUrl'].value;
				} else {
					window.location = "/validateRender.cz?method=myaccount";
				}
			} else {
				disableButton("button_signin", false);
				alert(jsonObj.message);
			}*/
			var ajaxResponse = response.responseXML.getElementsByTagName("response");
			if(ajaxResponse[0].getAttribute("statusCode") == 'S') {
				if (form['backToUrl'] && form['backToUrl'].value != "") {
					window.location = form['backToUrl'].value;
				} else {
					window.location = "/validateRender.cz?method=myaccount";
				}
			} else {
				disableButton("button_signin", false);
				alert(ajaxResponse[0].getAttribute("message"));
			}
			return false;
		},
		onError : function() {
			alert("Fail to sign in, please contact administrator.");
		}
	});

	return false;

	// store_jsessionId = getCookie("JSESSIONID");
	// 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["companyId"] = companyId;
	// userInfo["usertype"] = usertype;
	// userInfo["password"] = password;
	// userInfo["backToUrl"] = backToUrl;
	// window.donecallback = toStroeSignin;
	// form.action="/login.cz?method=signin";
	// form.target = "callbackframe";
	// disableButton("button_signin", true);

}
// function toStroeSignin(response){
// if (response["statusCode"] == 300) {
// disableButton("button_signIn", false);
// alert(response["message"]);
// } else if (response["statusCode"] == 200) {
// if (response["checkout"]) { checkout();}
// else{
// myAccount();
// }
// }
// }

// 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.");
// alert(wrong_use['wrong_use']);
// 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 checkemail(email){
// var email = document.getElementById("email").value;
// var e = $F("email");
// var reg = /\w{1,}[@][\w\-]{1,}([.]([\w\-]{1,})){1,3}$/;
// if(email==""){
// $("emailmessage").innerHTML = "<div class=\"field-label\"></div>" +
// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
// style=\"background-color: rgb(255, 0, 0);\"
// class=\"textfieldRequiredMsg\">This is a required
// field.</span></font></div>";
// return false;
// }else{
// $("emailmessage").innerHTML = "";
// }
// if(email != ""&&!reg.(email)){
// $("emailmessage").innerHTML = "<div class=\"field-label\"></div>" +
// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
// style=\"background-color: rgb(255, 0, 0);\"
// class=\"textfieldInvalidFormatMsg\">Please enter a valid email
// address.</span></font></div>";
// request.setAttribute("email2",email);
// return false;
// }else{
// $("emailmessage").innerHTML = "";
// }
// }
//
// function confirmemail(confirmEmail){
// var email = request.getAttribute("email2");
// alert(email);
// if(confirmEmail==""){
// $("confirmEmailM").innerHTML = "<div class=\"field-label\"></div>" +
// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
// style=\"background-color: rgb(255, 0, 0);\"
// class=\"textfieldRequiredMsg\">This is a required
// field.</span></font></div>";
// return false;
// }else{
// $("confirmEmailM").innerHTML = "";
// }
// if(email != confirmEmail){
// $("confirmEmailM").innerHTML = "<div class=\"field-label\"></div>" +
// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
// style=\"background-color: rgb(255, 0, 0);\"
// class=\"textfieldInvalidFormatMsg\">Conflicting with above
// value.</span></font></div>";
// return false;
// }else{
// $("confirmEmailM").innerHTML = "";
// }
// }
//
// function checkpassword(){
// var password = $("password").value;
// if(password==""){
// $("pwmessage").innerHTML = "<div class=\"field-label\">&nbsp;</div>" +
// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
// style=\"background-color: rgb(255, 0, 0);\"
// class=\"textfieldRequiredMsg\">This is a required
// field.</span></font></div>";
// return false;
// }else{
// $("pwmessage").innerHTML = "";
// }
// if(password.length<6||password.length>30){
// $("pwmessage").innerHTML = "<div class=\"field-label\"></div>" +
// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
// style=\"background-color: rgb(255, 0, 0);\"
// class=\"textfieldInvalidFormatMsg\">Please enter value length between 6 and
// 30.</span></font></div>";
// return false;
// }else{
// $("pwmessage").innerHTML = "";
// }
// }
//
// function confirmPW(){
// var password = $("password").value;
// var confirmPassword = $("confirmPassword").value;
// if(confirmPassword==""){
// $("confirmPasswordM").innerHTML = "<div class=\"field-label\"></div>" +
// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
// style=\"background-color: rgb(255, 0, 0);\"
// class=\"textfieldRequiredMsg\">This is a required
// field.</span></font></div>";
// return false;
// }else{
// $("confirmPasswordM").innerHTML = "";
// }
// if(password != confirmPassword){
// $("confirmPasswordM").innerHTML = "<div class=\"field-label\"></div>" +
// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
// style=\"background-color: rgb(255, 0, 0);\"
// class=\"textfieldInvalidFormatMsg\">Conflicting with above
// value.</span></font></div>";
// return false;
// }else{
// $("confirmPasswordM").innerHTML = "";
// }
// }
//
// function checkFirst(){
// var firstName = $("firstName").value;
// if(firstName==""){
// $("FNmessage").innerHTML = "<div class=\"field-label\">&nbsp;</div>" +
// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
// style=\"background-color: rgb(255, 0, 0);\"
// class=\"textfieldRequiredMsg\">This is a required
// field.</span></font></div>";
// return false;
// }else{
// $("FNmessage").innerHTML = "";
// }
// }
//
// function checkLast(){
// var lastName = $("lastName").value;
// if(lastName==""){
// $("LNmessage").innerHTML = "<div class=\"field-label\">&nbsp;</div>" +
// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
// style=\"background-color: rgb(255, 0, 0);\"
// class=\"textfieldRequiredMsg\">This is a required
// field.</span></font></div>";
// return false;
// }else{
// $("LNmessage").innerHTML = "";
// }
// }
//
// function checkPhone(){
// var phone = $("phone").value;
// if(phone !=""&&(phone.length<7||phone.length>30)){
// $("PNmessage").innerHTML = "<div class=\"field-label\">&nbsp;</div>" +
// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
// style=\"background-color: rgb(255, 0, 0);\"
// class=\"textfieldRequiredMsg\">Please enter integer value between 7 and
// 30.</span></font></div>";
// return false;
// }else{
// $("PNmessage").innerHTML = "";
// }
// }

function newAccount(form) {
	disableButton("button_newAccount", true);

	if (!Validation.validateForm(form)) {
		disableButton("button_newAccount", false);
		return false;
	}

	new Ajax.Request(changeForwardUrl("/account.cz?method=create"), {
		method : "post",
		parameters : Form.serialize(form),
		asynchronous : true,
		onComplete : function(response) {
			var jsonObj = JSON.parse(response.responseText);
			if (jsonObj && jsonObj.code == 'S') {
				if (form['backToUrl'] && form['backToUrl'].value != "") {
					window.location = form['backToUrl'].value;
				} else {
					if (form['store'] && form['store'].value != "") {
						window.location = "/account.cz?method=toPage&store="
								+ form['store'].value;
					} else {
						window.location = "/account.cz?method=toPage";
					}
				}
			} else {
				disableButton("button_newAccount", false);
				alert(jsonObj.message);
			}
			// alert(ajaxResponse.code);
			// alert(ajaxResponse.message);
			return false;
		},
		onError : function(response) {
			alert("Fail to sign up, please contact administrator.");
		}
	});

	return false;

	// var email = form.email3.value;
	// // var confirmEmail = form.confirmEmail.value;
	// var password = form.password3.value;
	// // var confirmPassword = form.confirmPassword.value;
	// // var firstName = form.firstName.value;
	// // var lastName = form.lastName.value;
	// // var phone = form.phone.value;
	// var companyId = form.corezon_asp_company.value;
	// var usertype = form.corezon_asp_usertype.value;
	// var backToUrl = form.backToUrl.value;
	// var flag = false;
	//	
	// if(email==""){
	// $("emailmessage").innerHTML = "<div class=\"field-label\"></div>" +
	// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
	// style=\"background-color: rgb(255, 0, 0);\"
	// class=\"textfieldRequiredMsg\">This is a required
	// field.</span></font></div>";
	// flag = true;
	// }
	// if(confirmEmail==""){
	// $("confirmEmailM").innerHTML = "<div class=\"field-label\"></div>" +
	// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
	// style=\"background-color: rgb(255, 0, 0);\"
	// class=\"textfieldRequiredMsg\">This is a required
	// field.</span></font></div>";
	// flag = true;
	// }
	// if(email != confirmEmail){
	// $("confirmEmailM").innerHTML = "<div class=\"field-label\"></div>" +
	// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
	// style=\"background-color: rgb(255, 0, 0);\"
	// class=\"textfieldInvalidFormatMsg\">Conflicting with above
	// value.</span></font></div>";
	// flag = true;
	// }
	//	
	// if(password.length<6||password.length>30){
	// $("pwmessage").innerHTML = "<div class=\"field-label\"></div>" +
	// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
	// style=\"background-color: rgb(255, 0, 0);\"
	// class=\"textfieldInvalidFormatMsg\">Please enter value length between 6
	// and 30.</span></font></div>";
	// flag = true;
	// }
	//	
	// if(password==""){
	// $("pwmessage").innerHTML = "<div class=\"field-label\">&nbsp;</div>" +
	// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
	// style=\"background-color: rgb(255, 0, 0);\"
	// class=\"textfieldRequiredMsg\">This is a required
	// field.</span></font></div>";
	// flag = true;
	// }
	//	
	// if(confirmPassword==""){
	// $("confirmPasswordM").innerHTML = "<div
	// class=\"field-label\">&nbsp;</div>" +
	// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
	// style=\"background-color: rgb(255, 0, 0);\"
	// class=\"textfieldRequiredMsg\">This is a required
	// field.</span></font></div>";
	// flag = true;
	// }
	// if(password != confirmPassword){
	// $("confirmPasswordM").innerHTML = "<div class=\"field-label\"></div>" +
	// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
	// style=\"background-color: rgb(255, 0, 0);\"
	// class=\"textfieldInvalidFormatMsg\">Conflicting with above
	// value.</span></font></div>";
	// flag = true;
	// }
	// if(firstName==""){
	// $("FNmessage").innerHTML = "<div class=\"field-label\">&nbsp;</div>" +
	// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
	// style=\"background-color: rgb(255, 0, 0);\"
	// class=\"textfieldRequiredMsg\">This is a required
	// field.</span></font></div>";
	// flag = true;
	// }
	// if(lastName==""){
	// $("LNmessage").innerHTML = "<div class=\"field-label\">&nbsp;</div>" +
	// "<div class=\"field-widget\"><font color=\"#ffffff\"><span
	// style=\"background-color: rgb(255, 0, 0);\"
	// class=\"textfieldRequiredMsg\">This is a required
	// field.</span></font></div>";
	// flag = true;
	// }
	// if(flag){
	// return false;
	// }

	// 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) {
		// location.href="/"+STORE_NAME+"/toPage.html";
		loadContent(STORE_SURL + "/account.cz?method=toPage", true);
		/*
		 * 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+"/account.cz?method=create&"+queryString,true);
		 */
		// loadContent(STORE_SURL+"/signup_done.jsp?"+queryString,true);
	}
}
// start: forget password
function loadForgetPassword() {
	// location.href="/"+STORE_NAME+"/forwardPage.html?name=forgetPassword";
	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"), forget['forget']);
			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() {
	location.href = "/" + STORE_NAME + "/allcategory.html";
	// 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() {
	// location.href="/"+STORE_NAME+"/billAddress.html";
	loadContent("/validateRender.cz?method=billAddress", true);
}
function loadShipAddress() {
	// location.href="/"+STORE_NAME+"/shipAddress.html";
	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) {
	// location.href="/"+STORE_NAME+"/updatePassword.html";
	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.");
			// alert(update_password['update_password']);
			myAccount();
		}
	}
}
function selectBillAddress(address) {
	$("bfirstName").value = address["firstName"];
	$("blastName").value = address["lastName"];
	$("bcountry").value = address["country"];
	changeState('bcountry');
	$("baddress").value = address["address"];
	$("baddress2").value = address["address2"];
	$("bcity").value = address["city"];
	if (address["country"] == 'US') {
		$("bstate").value = address["state"];
	} else if (address["country"] == 'CA') {
		$("bprovince").value = address["state"];
	} else if (address["country"] == 'CN') {
		$("bcstate").value = address["state"];
	} else {
		$("bfstate").value = address["state"];
	}
	$("bpostalCode").value = address["postalCode"];
	$("bphone").value = address["phone"];
	sameasbill();
	changeState('scountry');
	loadShippingMethods();
}
function selectShipAddress(address) {
	$("sfirstName").value = address["firstName"];
	$("slastName").value = address["lastName"];
	$("scountry").value = address["country"];
	changeState('scountry');
	$("saddress").value = address["address"];
	$("saddress2").value = address["address2"];
	$("scity").value = address["city"];
	if (address["country"] == 'US') {
		$("sstate").value = address["state"];
	} else if (address["country"] == 'CA') {
		$("sprovince").value = address["state"];
	} else if (address["country"] == 'CN') {
		$("scstate").value = address["state"];
	} else {
		$("sfstate").value = address["state"];
	}
	$("spostalCode").value = address["postalCode"];
	$("sphone").value = address["phone"];
	loadShippingMethods();
}

function submitOrder(form) {
	disableButton("button_createOrder", true);
	if (!Validation.validateForm(form)) {
		disableButton("button_createOrder", false);
		return false;
	} else {
		var payMethod = $("paymentTerm").value;
		if (payMethod == "Credit Card") {
			new Ajax.Request(
					changeForwardUrl("/validateRender.cz?method=validateCredit"),
					{
						method : "post",
						parameters : "cardNo=" + $("cardNo").value,
						asynchronous : true,
						onComplete : function(ajaxResponse) {
							var response = ajaxResponse.responseXML
									.getElementsByTagName("response");
							if (response) {
								if (response[0].getAttribute("message") == "1") {
									createOrder(form);
								} else {
									document.getElementById("clearCredit").innerHTML = "Please enter a valid credit card no";
									document.getElementById("clearCredit").style.display = "block";
									disableButton("button_createOrder", false);
									return false;
								}
							} else {
								alert("Fail to validate Credit Card No.");
								disableButton("button_createOrder", false);
								return false;
							}
						}
					});
		} else {
			createOrder(form);
		}
	}
	// checkCreditNo("orderCredit");
}

function createOrder(form) {
	new Ajax.Request(changeForwardUrl("/order.cz?method=checkout"), {
		method : "post",
		parameters : Form.serialize(form),
		asynchronous : true,
		onComplete : function(ajaxResponse) {
			var response = ajaxResponse.responseXML
					.getElementsByTagName("response");
			if (response) {
				if (response[0].getAttribute("statusCode") == 300) {
					disableButton("button_createOrder", false);
					alert(response[0].getAttribute("message"));
					return;
				} else if (response[0].getAttribute("statusCode") == 301) { 
					// credit card  authorize failed
					alert(response[0].getAttribute("message"));
					var oform = $("OrderForm");
					oform.method.value = "reAuthorize";
					// oform.action="/order.cz?method=reAuthorize";
					oform.orderId.value = response[0].getAttribute("objectId");
					disableButton("button_createOrder", false);
					return;
				} else if (response[0].getAttribute("statusCode") == 200) {
					var orderId = response[0].getAttribute("objectId");
					var oPaymentTerm = $("paymentTerm");
					var login = response[0].getAttribute("forwardUrl");
					// -----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
						// location.href="/"+STORE_NAME+"/orderconfirm-"+orderId+".html?login="+login;
						loadContent("/order.cz?method=orderconfirm&orderId="
								+ orderId + "&store=" + STORE_NAME + "&login="
								+ login, true);
					}
					// -----end
				}
			} else {
				alert("Fail to create order.");
				disableButton("button_createOrder", false);
				return false;
			}

		}
	});
}

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

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");
		var login = response["forwardUrl"];
		// -----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
			// location.href="/"+STORE_NAME+"/orderconfirm-"+orderId+".html?login="+login;
			loadContent("/order.cz?method=orderconfirm&orderId=" + orderId
					+ "&store=" + STORE_NAME + "&login=" + login, 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 = "";
		if ($("scstate").nodeName == "select") {
			$("scstate").selectedIndex = "";
		} else if ($("scstate").nodeName == "input") {
			$("scstate").value = "";
		}
		$("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;
		if ($("scstate").nodeName == "SELECT"
				&& $("bcstate").nodeName == "SELECT") {
			$("scstate").selectedIndex = $("bcstate").selectedIndex;
		} else if ($("scstate").nodeName == "INPUT"
				&& $("bcstate").nodeName == "INPUT") {
			$("scstate").value = $("bcstate").value;
		}
		$("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());
	// }
	if ($("info_tax")) {
		$("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"));
	}
	if ($("quote_tax")) {
		var tax = parseFloat($F("quote_tax"));
	} else {
		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 listQuotesByAccount(pageNum) {
	if (typeof (pageNum) == "undefined") {
		pageNum = "1";
	}
	loadContentURL("quoteListDiv",
			"/validateRender.cz?method=listQuoteByAccount" + "&pageNum="
					+ pageNum);
}

function listRfqsByAccount(pageNum) {
	if (typeof (pageNum) == "undefined") {
		pageNum = "1";
	}
	loadContentURL("rfqListDiv", "/validateRender.cz?method=listRfqByAccount"
			+ "&pageNum=" + pageNum);
}
function listOffersByAccount(pageNum) {
	if (typeof (pageNum) == "undefined") {
		pageNum = "1";
	}
	loadContentURL("offerListDiv",
			"/validateRender.cz?method=listOfferByAccount" + "&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
	});*/
	isGreaterThanQuantity(paypalCheckout_fun);
}

function paypalCheckout_fun(){
	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;

	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");

	new Ajax.Request(changeForwardUrl("/order.cz?method=checkout"), {
		method : "post",
		parameters : Form.serialize(orderForm),
		onComplete : createPaypalOrderComplete
	});
	
	disableButton("button_createOrder", true);
}
function createPaypalOrderComplete(response) {
	var ajaxResponse = response.responseXML.getElementsByTagName("response");

	if (ajaxResponse[0].getAttribute("statusCode") == 300) {
		disableButton("button_createOrder", false);
		alert(ajaxResponse[0].getAttribute("message"));
		return;
	} else if (ajaxResponse[0].getAttribute("statusCode") == 200) {
		var orderId = ajaxResponse[0].getAttribute("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!");
		// alert(shipping_state['shipping_state']);
		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="/"+STORE_NAME+"/paypalForm-"+orderId+".html";
	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
	});*/
	isGreaterThanQuantity(googleCheckout_fun);
}

function googleCheckout_fun() {
	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 categoryChangeNine(MenuBar, interval) {
	var aWidth = 0;
	var menu = $("nav_menu");
	var obj = $(MenuBar);
	$A(obj.childNodes)
			.each(
					function(node) {
						if (node.nodeType == 1) {
							$A($(node).childNodes)
									.each(
											function(xnode) {
												if (xnode.nodeType == 1
														&& xnode.nodeName
																.toLowerCase() == "a") {
													var temp = xnode.innerHTML;
													$(xnode).innerHTML = "<span>"
															+ temp + "</span>";
													aWidth += $(xnode).offsetWidth
															+ interval;
												}
												if (aWidth > parseInt(menu.style.width)) {
													$(node).parentNode
															.removeChild($(node));
													if ($("NM_more")) {
														$("NM_more")
																.appendChild(
																		$(node));
													}
												}
											});
						}
					});
	if ($("NM_more") && $("NM_more").getElementsByTagName("li").length > 0) {
		$("nav_more").show();
	}
}

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 categoryChangeTen(MenuBar) {
	var liWidth = 0;
	var length = $(MenuBar).offsetWidth;
	$A($(MenuBar).childNodes).each(function(node) {
		if (node.nodeType == 1) {
			liWidth += $(node).offsetWidth;
			if (liWidth > length) {
				$(node).parentNode.removeChild($(node));
			}
		}
	});
}

/*function isGreaterThanQuantity() {
	var i = 0;
	var flag = false;
	if ($F("inventoryControl") == 'Y') {
		while (!flag) {
			if ($('quantity' + i)) {
				var id = $('quantity' + i).getAttribute("name").substring(6, 38);
				var quantity = $('quantity' + i).value;
				$('cartQuantity' + i).value = $('quantity' + i).value;
				var prodQuantity = $F(id);
				var productName = $F('name' + i);
				if (parseInt(quantity) > parseInt(prodQuantity)) {
					document.getElementById("mess").innerHTML = "Sorry!  We only have"
						+ " "
						+ prodQuantity
						+ " "
						+ productName
						+ " "
						+ "product in stock."
					$("showMsg").style.display = "";
					$("quantity" + i).focus();
					flag = false;
					break;
				}else{
					flag = false;
				}
				i++;
			} else {
				flag = true;
			}
		}
	} else {
		flag =  true;
	}
	if(flag){
		$("showMsg").style.display = "none";
	}
	return flag;
}*/

function isGreaterThanQuantity(cFun) {
	if ($F("inventoryControl") == 'Y') {
		var i = 0;
		var queryString = "";
		while ($('quantity' + i)) {
			var productId = $('quantity' + i).getAttribute("name").substring(6, 38);
			var quantity = $('quantity' + i).value;
			var optionValueId = $('optionValueId' + i).value;
			queryString += "&productInfo="+productId+"|"+quantity+"|"+optionValueId+"|"+i;
			
			i++;
		}
		
		queryString += "&timestamp="+ new Date().getTime();
		new Ajax.Request(changeForwardUrl("/cart.cz?method=checkInStock"), {
			method : "post",
			parameters : queryString,
			onComplete : function(response){
				var responseNode = response.responseXML.getElementsByTagName("response");
				if (responseNode[0].getAttribute("statusCode") == 300) {
					var i = responseNode[0].getAttribute("objectId");
					var productName = $F('name' + i);
					document.getElementById("mess").innerHTML = "Sorry!  We don't have enough " + productName + " in stock."
					$("showMsg").style.display = "";
					$("quantity" + i).focus();
					return;
				}else{
					$("showMsg").style.display = "none";
					cFun();
				}
			}
		});
	} else{
		cFun();
	}
}

function sreachBlur(element, name) {
	if (document.all) {
		if (navigator.userAgent.indexOf("MSIE") > 0) {
			if (element.value == '') {
				element.value = name;
			}
		}

	}
}
function sreachFocus(element, name) {
	if (document.all) {
		if (navigator.userAgent.indexOf("MSIE") > 0) {
			if (element.value == name) {
				element.value = '';
			}
		}
	}
}

function sreachBlur(element, name) {
	if (document.all) {
		if (navigator.userAgent.indexOf("MSIE") > 0) {
			if (element.value == '') {
				element.value = name;
			}
		}
	}
}
function sreachFocus(element, name) {
	if (document.all) {
		if (navigator.userAgent.indexOf("MSIE") > 0) {
			if (element.value == name) {
				element.value = '';
			}
		}
	}
}

function checkCreditNo(obj) {
	if (window.getSelection())
		window.getSelection().removeAllRanges();
	new Ajax.Request(
			changeForwardUrl("/validateRender.cz?method=validateCredit"),
			{
				method : "post",
				parameters : "cardNo=" + obj.value,
				asynchronous : true,
				onComplete : function(ajaxResponse) {
					var response = ajaxResponse.responseXML
							.getElementsByTagName("response");
					if (response) {
						if (response[0].getAttribute("message") != "1") {
							document.getElementById("clearCredit").innerHTML = "Please enter a valid credit card no";
							document.getElementById("clearCredit").style.display = "block";
						}
					} else {
						alert("Fail to validate Credit Card No.");
					}
				}
			});

	// var flag = isValidCreditCardNo(obj.value);
	// alert(flag);
	// if (!flag) {
	// document.getElementById("clearCredit").innerHTML="Please enter a valid
	// credit card no";
	// document.getElementById("clearCredit").style.display="block";
	// }
	// var creditNo=$("cardNo").value;
	// var payMethod=$("paymentTerm").value;
	// var creditCard=$("creditCard").value;
	// if(payMethod == creditCard){
	// if(creditNo==""){
	// return ;
	// }
	//		
	// new
	// Ajax.Request(changeForwardUrl("/validateRender.cz?method=validateCredit"),
	// {method:"post", parameters:"cardNo="+creditNo+"&credit="+credit,
	// onComplete:checkCredutNoDone});
	// }else{
	// submitOrder( $('OrderForm'),true);
	// }
}

// function checkCredutNoDone(ajaxResponse){
// var response = ajaxResponse.responseXML.getElementsByTagName("response");
// if (response[0].getAttribute("message") == "0") {
// document.getElementById("clearCredit").innerHTML="Please enter a valid credit
// card no";
// document.getElementById("clearCredit").style.display="block";
// }else if(response[0].getAttribute("message") == "2"){
// document.getElementById("clearCredit").innerHTML="Please enter a valid credit
// card no";
// document.getElementById("clearCredit").style.display="block";
// submitOrder($('OrderForm'),false);
// }else if(response[0].getAttribute("message") == "3"){
// submitOrder( $('OrderForm'),true);
// }
// }

function clearCreditNo() {
	document.getElementById("clearCredit").innerHTML = "";
  }
  
function checkCreditNo(obj){
	if(window.getSelection()) window.getSelection().removeAllRanges();
	if($("cardNo").value==null ||$("cardNo").value==""){
		return;
	}
	new Ajax.Request(changeForwardUrl("/validateRender.cz?method=validateCredit"), 
			  {method:"post", 
		       parameters:"cardNo="+obj.value,
		       asynchronous:true,
		       onComplete:function(ajaxResponse){
		    	   var response = ajaxResponse.responseXML.getElementsByTagName("response");
		    	   if (response) {
		    		   if (response[0].getAttribute("message") != "1") {
		    			   document.getElementById("clearCredit").innerHTML="Please enter a valid credit card no";
			    		   document.getElementById("clearCredit").style.display="block";
		    		   }
		    	   } else {
		    		   alert("Fail to validate Credit Card No.");
		    	   }
		       }});
	
	
//	var flag = isValidCreditCardNo(obj.value);
//	alert(flag);
//	if (!flag) {
//		document.getElementById("clearCredit").innerHTML="Please enter a valid credit card no";
//		document.getElementById("clearCredit").style.display="block";
//	}
//	var creditNo=$("cardNo").value;
//	var payMethod=$("paymentTerm").value;
//	var creditCard=$("creditCard").value;
//	if(payMethod == creditCard){
//		if(creditNo==""){
//			return ;
//		}
//		
//		new Ajax.Request(changeForwardUrl("/validateRender.cz?method=validateCredit"), {method:"post", parameters:"cardNo="+creditNo+"&credit="+credit, onComplete:checkCredutNoDone});
//	}else{
//		submitOrder( $('OrderForm'),true);
//	}
}

// function isValidCreditCardNo(creditNo) {
// new
// Ajax.Request(changeForwardUrl("/validateRender.cz?method=validateCredit"),
// {method:"post",
// parameters:"cardNo="+creditNo,
// asynchronous:false,
// onComplete:function(ajaxResponse){
// var response = ajaxResponse.responseXML.getElementsByTagName("response");
// alert(ajaxResponse.responseXML);
// if ( response && response[0].getAttribute("message") == "1") {
// alert(response[0].getAttribute("message"));
// return true;
// } else {
// alert("return false");
// return false;
// }
// }});
// }

function  click_right_changeImage(obj){
	var num = parseInt($F("num"));
	var array = new Array(4);
	var id = document.getElementById("smaill3").getElementsByTagName("img")[0].id;
	var count = parseInt(id.substring(3,id.length));
	if(count+1==num){
		return;
	}
	if(count+4 < num){
		for(var i=0;i<4;i++){
			var id = document.getElementById("smaill"+i).getElementsByTagName("img")[0].id;
			var index = parseInt(id.substring(3,id.length));
			array[i] = parseInt(index+4);
		}
	}else{
		for(var i=0;i<4;i++){
			var id = document.getElementById("smaill"+i).getElementsByTagName("img")[0].id;
			var index = parseInt(id.substring(3,id.length));
			array[i] = parseInt(index+num-count-1);
		}
	}
	if(parseInt(array[3]+1)==num){
		$("select_right").style.display = "none";
		$("select_right_img").style.display = "inline";
		
	}
	if(parseInt(array[0]) > 0){
		$("select_left_img").style.display = "none";
		$("select_left").style.display = "inline";
	}else{
		$("select_right").style.display = "none";
		$("select_right_img").style.display = "inline";
		$("select_left_img").style.display = "inline";
		$("select_left").style.display = "none";
	}
	if(parseInt(array[3]) < num){
		for(var j=0;j<4;j++){
			changeSmallImage("imgdiv"+j,"smaill"+j,"img"+array[j],$F("img_"+array[j]),$F("img_big_"+array[j]));
		}
	}
}


function click_left_changeImage(){

	var num = parseInt($F("num"));
	var array = new Array(4);
	var id = document.getElementById("smaill0").getElementsByTagName("img")[0].id;
	var count = parseInt(id.substring(3,id.length));
	if(count ==0){
		return;
	}
	if(count>=4){
		for(var i=0;i<4;i++){
			var id = document.getElementById("smaill"+i).getElementsByTagName("img")[0].id;
			var index = parseInt(id.substring(3,id.length));
			array[i] = parseInt(index-4);
		}
	}else{
		for(var i=0;i<4;i++){
			var id = document.getElementById("smaill"+i).getElementsByTagName("img")[0].id;
			var index = parseInt(id.substring(3,id.length));
			array[i] = parseInt(index-count);
		}
	}
	
	if(parseInt(array[3]+1)==num){
		
		$("select_right").style.display = "inline";
		$("select_right_img").style.display = "none";
		alert("1");
	}else{
		$("select_left_img").style.display = "inline";
		$("select_left").style.display = "none";
	}
	if(parseInt(array[0]) > 0){
		$("select_left_img").style.display = "none";
		$("select_left").style.display = "inline";
		$("select_right").style.display = "inline";
		$("select_right_img").style.display = "none";
	}else{
		$("select_right").style.display = "inline";
		$("select_right_img").style.display = "none";
		$("select_left_img").style.display = "inline";
		$("select_left").style.display = "none";
	}
	if(parseInt(array[0]) >=0){
		for(var j=0;j<4;j++){
			changeSmallImage("imgdiv"+j,"smaill"+j,"img"+array[j],$F("img_"+array[j]),$F("img_big_"+array[j]));
		}
	}
	
}

function submitQuery(name,page,sort){
	if(typeof(page) == 'undefined') {page=0;}
	var viewMark = "";
	if(document.getElementById("viewMark")){
		viewMark = document.getElementById("viewMark").value;
	}
	var sort = "";
	if(document.getElementById("sortBy")){
		sort = document.getElementById("sortBy").value;
	}
	
	var attrs = "";
	var checkBoxes = document.getElementsByName(name);
	for(var i=0;i<checkBoxes.length;i++){
		if(checkBoxes[i].checked){
			attrs += "&attr="+checkBoxes[i].value;
		}
	}
	if(attrs != ""){
		loadContentURL("productList","/render.cz?method=searchProductsByAttribute"+attrs+"&pageNum="+page+"&sort="+sort+"&viewMark="+viewMark, true);
	}else{
		alert("Please select more than one attribute!");
	}
}

jQuery(function(){
	jQuery(".optionValue>ul>li").click(function(){
		if($("inventoryControl").value == "true" && $("optionStock").value == "true"){
			if(!jQuery(this).find("a").hasClass("optinonDisabled") && !jQuery(this).find("a").hasClass("optinonSelect")){
				jQuery(this).parent().find(".optinonSelect").removeClass("optinonSelect").addClass("unSelect");
				jQuery(this).find("a").removeClass("unSelect").addClass("optinonSelect");
				
				refreshOptioncStock();
				
				var sels = jQuery("#shoppingCart").find(".optinonSelect");
				var optionSelect = "";
				for(var i=0;i<sels.length;i++){
					if(i == 0){
						optionSelect = sels[i].id;
					}else{
						optionSelect +="-"+sels[i].id;
					}
				}
				jQuery("#optionSelect").val(optionSelect);
				
				if(jQuery("#optionSize").val() == sels.length){
					var optionStocks = jQuery("input[name=optionStockQty]");
					for(var i=0;i<optionStocks.length;i++){
						if(optionStocks[i].value.indexOf(optionSelect) >= 0){
							var values = optionStocks[i].value.split(";");
							jQuery("#inStockQty").html("("+values[1]+" in stock)");
							if(jQuery(".regularPrice").length>0){
								jQuery(".regularPrice .Value").html(values[2]);
							}
							if(jQuery(".ourPrice").length>0){
								jQuery(".ourPrice .Value").html(values[2]);
							}
							if(jQuery(".sku").length>0){
								jQuery(".sku .Value").html(values[3]);
							}
							jQuery("#optionSku").val(values[3]);
							break;
						}
					}
				}else{
					if ($("button_addToCart"))
						disableButton("button_addToCart", true);
				}
			}
		}else{
			if(!jQuery(this).find("a").hasClass("optinonSelect")){
				jQuery(this).parent().find(".optinonSelect").removeClass("optinonSelect").addClass("unSelect");
				jQuery(this).find("a").removeClass("unSelect").addClass("optinonSelect");
				
				var sels = jQuery("#shoppingCart").find(".optinonSelect");
				var optionSelect = "";
				for(var i=0;i<sels.length;i++){
					if(i == 0){
						optionSelect = sels[i].id;
					}else{
						optionSelect +="-"+sels[i].id;
					}
				}
				jQuery("#optionSelect").val(optionSelect);
				jQuery("#optionSku").val(jQuery.trim(jQuery(".sku .Value").html()));
			}
		}
	});
});

var Option_Array = new Array();
var Option_Array_Index = 0;
function refreshOptioncStock(){
	if(jQuery("#optionSize").val() == 1){
		var optionStockQtys = document.getElementsByName("optionStockQty");
		var lis = document.getElementById("ul_0").getElementsByTagName("li");
		if(optionStockQtys.length < lis.length){
			for(var i=0;i<lis.length;i++){
				var id = lis[i].id;
				var truth = false;
				for(var j=0;j<optionStockQtys.length;j++){
					if(optionStockQtys[j].value.indexOf(id.replace("li_","")) >= 0){
						truth = true;
						break;
					}
				}
				if(!truth){
					jQuery("#"+id).find("a").addClass("optinonDisabled");
				}
			}
		}
	}else{
		var sels = jQuery("#shoppingCart").find(".optinonSelect");
		var temp_selArray = new Array();
		for(var i=0;i<sels.length;i++){
			temp_selArray[i] = sels[i].id;
		}
		
		for(var i=1;i<=temp_selArray.length;i++){
			select(temp_selArray,i);
		}
		
		var unSels = jQuery("#shoppingCart").find(".unSelect");
		for(var i=0;i<unSels.length;i++){
			var unsel_id = unSels[i].id;
			var index = jQuery("#li_"+unsel_id).parent().attr("id").replace("ul_","");
			var disable = false;
			for(var j=0;j<Option_Array.length;j++){
				var sel_ids = Option_Array[j].split("-");
				var isContinue = false;
				for(var k=0;k<sel_ids.length;k++){
					var sel_index = jQuery("#li_"+sel_ids[k]).parent().attr("id").replace("ul_","");
					if(index == sel_index){
						isContinue = true;
						break;
					}
				}
				if(!isContinue){
					var group = Option_Array[j]+"-"+unsel_id;
					disable = checkOptionStock(group);
					if(disable){
						break;
					}
				}
			}
			var obj = jQuery("#"+unsel_id);
			if(disable){
				if(obj.hasClass("optinonSelect")){
					obj.removeClass("optinonSelect");
					obj.addClass("unSelect");
				}
				obj.addClass("optinonDisabled");
			}else{
				if(obj.hasClass("optinonDisabled")){
					obj.removeClass("optinonDisabled");
				}
			}
		}
		Option_Array_Index = 0;
		Option_Array = new Array();
	}
}

function checkOptionStock(str){
	var optionStocks = jQuery("input[name=optionStockQty]");
	var disable = true;
	var values = str.split("-");
	for(var i=0;i<optionStocks.length;i++){
		var group = optionStocks[i].value;
		var truth = true;
		for(var j=0;j<values.length;j++){
			if(group.indexOf(values[j]) < 0){
				truth = false;
				break;
			}
		}
		if(truth){
			disable = false;
			break;
		}
	}
	return disable;
}

function select(array,num){
	var temp_array = new Array(num);
	subselect(0, 1, temp_array,array, num);
}

function subselect(head,index,temp_array,array,num){
	for (var i = head; i < array.length + index - num; i++) {
		if (index < num) {
			temp_array[index-1] = array[i];
			subselect(i + 1, index + 1, temp_array,array, num);
		}else if(index == num){
			temp_array[index - 1] = array[i];
			var result = "";
			for(var j=0;j<temp_array.length;j++){
				if(result != ""){
					result +="-"+temp_array[j];
				}else{
					result = temp_array[j];
				}
			}
			Option_Array[Option_Array_Index] = result;
			Option_Array_Index++;
			subselect(i + 1, index + 1, temp_array,array, num);
		} 
	}
}

function IM_vPrice(obj, type) {
	var num = obj.value;
	var sValidChars = type?"0123456789":".0123456789";
	if(!num || num.length < 1) {
		return;
	}
	var truth = false;
	var zoreCount = 0;
	for(var i = 0; i < num.length; i++) {
		var sChar = num.charAt(i);
		if(sValidChars.indexOf(sChar) < 0) {
			obj.value = num.replace(sChar, '');
			break;
		}else{
			if(sChar == '.'){
				if(i == 0){
					obj.value = num.replace(sChar, '');
					break;
				}else if(truth){
					obj.value = obj.value.substring(0,i);
					break;
				}else{
					truth = true;
				}
			}else{
				var index = num.indexOf('.');
				if(index >= 0 && parseInt(index+2) <= i){
					obj.value = obj.value.substring(0,parseInt(index+3));
					break;
				}else if(!type && index < 0 && i>=6){
					obj.value = obj.value.substring(0,6);
					break;
				}
				
				if(i == 0 && sChar == '0'){
					if(!type && num.indexOf('.') > 1){
						obj.value = obj.value.substring(1,obj.value.length);
						break;
					}else if(type){
						obj.value = obj.value.substring(1,obj.value.length);
					}
				}
			}
		}
	}
	if(obj.value == ""){
		obj.value = type?"1":"1.00";
	}
	return false;
}

function IM_vPriceNull(obj, type){
	var num = obj.value;
	if(!num || num.length < 1) {
		if(type=='int') { 
			obj.value = '1'; 
			return;
		}
		obj.value = '1.00';
	}
}
//** 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])
		if(ulobj){
			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
}