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

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

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

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

var Abstract = new Object();

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

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

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

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

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

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

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

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

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

    return returnValue;
  }
}

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

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

    this.registerCallback();
  },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return camelizedString;
  },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Object.extend(Array.prototype, Enumerable);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  activeRequestCount: 0
}

Ajax.Responders = {
  responders: [],

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

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

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

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

Object.extend(Ajax.Responders, Enumerable);

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

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

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

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

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

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

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

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

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

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

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

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

      this.setRequestHeaders();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Ajax.Updater = Class.create();

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

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

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

    this.request(url);
  },

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

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

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

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

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

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

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

    this.start();
  },

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

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

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

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

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

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

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

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

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

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

  element._extended = true;
  return element;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Object.extend(Element, Element.Methods);

var _nativeExtensions = false;

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

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

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

Element.addMethods();

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

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

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

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

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

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

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

var Insertion = new Object();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  findElements: function(scope) {
    var element;

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

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

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

    return results;
  },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return matchingInputs;
  },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var $F = Form.Element.getValue;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  observers: false,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return document.body;
  },

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

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

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

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

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

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

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

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

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

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

    } while (element = element.offsetParent);

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

    return [valueL, valueT];
  },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Element.setOpacity = function(element, value){  
  element= $(element);  
  if (value == 1){
    Element.setStyle(element, { opacity: 
      (/Gecko/.test(navigator.userAgent) && !/Konqueror|Safari|KHTML/.test(navigator.userAgent)) ? 
      0.999999 : 1 });
    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.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.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] || {})
  );
};

['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();
// included	in 1.6.4
Event.KEY_PAGEUP = 33;
Event.KEY_PAGEDOWN = 34;
Event.KEY_HOME = 36;
Event.KEY_END =	35;

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

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

Form.Element.Serializers.button	=
	function(element) {
		return [element.name, element.value];
	};

Form.Element.Serializers.textarea =
	function(element) {
		var value;
		if (element.name && element.form && element.form.id && FormManagers[element.form.id]) {
			value = FormManagers[element.form.id].getValue(element.name);
		}
		else {
			value = element.value;
		}
		return [element.name, value];
	};

// bug in effects.js
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 : 1 });
	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+')'	});
  }
};

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

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

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

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

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

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

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


Position.getViewPortBounds =
	function() {
	var	left;
	var	top;
	var	width;
	var	height;

	if (UserAgent.OPERA || UserAgent.WEBKIT) {
		left = self.pageXOffset;
		top	= self.pageYOffset;
		width = window.innerWidth;
		height = window.innerHeight;
	}
	else if (document.documentElement && document.documentElement.clientHeight) {
		left = document.documentElement.scrollLeft;
		top	= document.documentElement.scrollTop;
		width =	document.documentElement.clientWidth;
		height = document.documentElement.clientHeight;
	}
	else if (document.body) {
		left = document.body.scrollLeft;
		top = document.body.scrollTop;
		width = document.body.clientWidth;
		height = document.body.clientHeight;
	}

	return { left: left, top: top, width: width, height: height	};
	};

// Inheritance
Class.subclass =
	function(subClass, superClass, properties) {
		function inheritance() {};
		inheritance.prototype =	superClass.prototype;
		subClass.prototype = new inheritance();
		if (properties)	{
			for	(property in properties) {
				subClass.prototype[property] = properties[property];
			}
		}
	};

// BASE
var	UserAgent =	{};

if (navigator.userAgent.indexOf('AppleWebKit') > -1) {
	UserAgent.WEBKIT = true;
}
else if	(navigator.userAgent.indexOf('Opera') >	-1)	{
	UserAgent.OPERA	= true;
	UserAgent.VERSION =	navigator.userAgent.match(/Opera.(\d)/)[1];
}
else if	(navigator.userAgent.indexOf('KHTML') >	-1)	{
	UserAgent.KHTML	= true;
}
else if	(navigator.userAgent.indexOf("Gecko") >	-1)	{
	UserAgent.GECKO	= true;
}
else if	(navigator.userAgent.indexOf("MSIE") > -1) {
	UserAgent.MSIE = true;
}

Event.mapMacKeypressKeyCode	=
	function(macKeyCode) {
		var	keyCode;
		switch(macKeyCode) {
		case 63232:
			keyCode	= Event.KEY_UP;
			break;
		case 63233:
			keyCode	= Event.KEY_DOWN;
			break;
		case 63276:
			keyCode	= Event.KEY_PAGEUP;
			break;
		case 63277:
			keyCode	= Event.KEY_PAGEDOWN;
			break;
		case 63273:
			keyCode	= Event.KEY_HOME;
			break;
		case 63275:
			keyCode	= Event.KEY_END;
			break;
		default:
			keyCode	= macKeyCode;
		}
	return keyCode;
	};

Form.Element.value =
	function(input)	{
		input =	$(input);
		var	value;
		if (!UserAgent.MSIE) {
			value =	input.value;
		}
		else {
			value =	input.value.replace(/\r\n/g, '\n');
		}
		return value;
	}

Form.Element.setSelectionRange =
	function(input,	start, end)	{
		input =	$(input);
		if (input.setSelectionRange) {
			input.focus();
			input.setSelectionRange(start, end);
		}
		else if	(input.createTextRange)	{
			var	range =	input.createTextRange();
			range.collapse(true);
			range.moveEnd('character', start);
			range.moveStart('character', end);
			range.select();
		}
	};

Form.Element.selectionStart	=
	function(input)	{
		input =	$(input);
		if (input.selectionStart !=	undefined) {
			return input.selectionStart;
		}
		else if	(document.selection	&& input.createTextRange) {
			var	s =	document.selection.createRange();
			var	r =	input.createTextRange();
			var	pos	= s.getBookmark().charCodeAt(2)	- r.getBookmark().charCodeAt(2);
			return pos;
		}
		else {
			return input.value.length;
		}
	};

Form.Element.selectionEnd =
	function(input)	{
		input =	$(input);
		if (input.selectionEnd != undefined) {
			return input.selectionEnd;
		}
		else if	(document.selection	&& input.createTextRange) {
			var	s =	document.selection.createRange();
			var	r =	input.createTextRange();
			var	pos	= (s.getBookmark().charCodeAt(2) + s.text.length) -	r.getBookmark().charCodeAt(2);
			return pos;
		}
		else {
			return input.value.length;
		}
	};

Form.Element.setCaretToStart =
	function(input)	{
		input =	$(input);
		if (input.setSelectionRange) {
			input.setSelectionRange(0,0);
		}
		else if	(input.createTextRange)	{
			var	range =	input.createTextRange();
			range.collapse(true);
			range.select();
		}
	};

Form.Element.setCaretToEnd =
	function(input)	{
		input =	$(input);
		if (input.setSelectionRange) {
			var	pos	= input.value.length;
			input.setSelectionRange(pos,pos);
		}
		else if	(input.createTextRange)	{
			var	range =	input.createTextRange();
			range.collapse(false);
			range.select();
		}
	};

Form.Element.scrollToEnd =
	function(input)	{
		input =	$(input);
		if (input.scrollTop	!= undefined &&	input.scrollHeight != undefined) input.scrollTop = input.scrollHeight - input.clientHeight;
	};

Form.Element.getRangeBounds	=
	function(element, rangeStart, rangeEnd)	{
		element	= $(element);
		var	value =	Form.Element.value(element);
		var	prefix = value.substr(0, rangeStart);
		var	range =	value.slice(rangeStart,	rangeEnd);
		var	postfix	= value.substr(rangeEnd);

		var	rLeft, rTop, rWidth, rHeight;

		var	r;
		if (element.createTextRange	&& (r =	element.createTextRange()).offsetLeft != undefined)	{
			r.moveStart('character', prefix.length);
			r.moveEnd('character', -postfix.length);
			rLeft =	r.offsetLeft + 2;
			rTop = r.offsetTop - 2;
			rWidth = r.boundingWidth;
			rHeight	= r.boundingHeight + 4;
		}
		if (rLeft == undefined)	{
			var	tfs;
			var	tfs_prefix;
			var	tfs_range;
			var	tfs_postfix;

			if (!Form.Element.tfs) {
				tfs	= document.createElement('div');
				tfs.style.position = 'absolute';
				tfs.style.left = '0px';
				tfs.style.top =	'0px';
				tfs.style.visibility = 'hidden';
				tfs.style.overflow = 'auto';
				tfs.style.border = 'solid black	1px';
				tfs.style.padding =	element.style.padding;
				tfs.style.background = 'red';
				document.body.appendChild(tfs);

				tfs_prefix = document.createElement('span');
				tfs_range =	document.createElement('span');
				tfs_range.style.background = 'green';
				tfs_postfix	= document.createElement('span');

				tfs.appendChild(tfs_prefix);
				tfs.appendChild(tfs_range);
				tfs.appendChild(tfs_postfix);
				Form.Element.tfs = tfs;
				Form.Element.tfs_prefix	= tfs_prefix;
				Form.Element.tfs_range = tfs_range;
				Form.Element.tfs_postfix = tfs_postfix;
			}
			else {
				tfs	= Form.Element.tfs;
				tfs_prefix = Form.Element.tfs_prefix;
				tfs_range =	Form.Element.tfs_range;
				tfs_postfix	= Form.Element.tfs_postfix;
			}

			tfs.style.display =	'';

			if (range.replace(/\s*/, '') ==	'')	range += '|';
			var	elDims = Element.getDimensions(element);

			tfs.style.width	= (elDims.width	- 4) + 'px';
			tfs.style.height = (elDims.height -	2) + 'px';
			tfs.style.fontSize = Element.getStyle(element, 'font-size');
			tfs.style.fontFamily = Element.getStyle(element, 'font-family');
			tfs.style.whiteSpace = 'pre';
			tfs.style.textAlign	= Element.getStyle(element,	'text-align') || 'left';

			tfs_prefix.innerHTML = prefix.replace(/\n/g,'<br/>');
			tfs_range.innerHTML	= range.replace(/\n/g,'<br/>');
			tfs_postfix.innerHTML =	postfix.replace(/\r\n/g,'<br />');
			tfs.scrollLeft = element.scrollLeft;
			tfs.scrollTop =	element.scrollTop;

			rLeft =	(tfs_range.offsetLeft -	tfs.scrollLeft)	+ 4;
			if (rLeft >	elDims.width) rLeft	= elDims.width - (tfs_range.offsetWidth	+ 4);
			rTop = tfs_range.offsetTop - tfs.scrollTop;
			rWidth = tfs_range.offsetWidth;
			rHeight	= tfs_range.offsetHeight + 4;
			tfs.style.display =	'none';
		}
		return { left: rLeft, top: rTop, width:	rWidth,	height:	rHeight	};
	};

var	OBC_TOOLKIT	= {};

OBC_TOOLKIT.tagsNormalize =
    function(value) { return value
		      .strip()
		      .replace(/[\r\n\t\"\'\\]/g, '')
		      .replace(new RegExp('[;' + String.fromCharCode(255 * 256 + 12) + String.fromCharCode(48 *	256 + 1) + ']', 'g'), ',')
		      .replace(/\s+/g, ' ')
		      .replace(/\,\ +/g, ',')
		      .replace(/\,/g, ', ')
		      .replace(/\,(\ ?\,)*/g, ',')
		      .replace(/\,\ ?$/, '')
		      .replace(/\<.*?\>/g, '')
		      .replace(/\</g,'')
		      .replace(/\>/g,'')
		      .replace(/\'/g,'');
    };

OBC_TOOLKIT.annotationNormalize	=
    function(value)	{ return value
			  .strip()
			  .replace(/\n*\s*$/g, '')
    };

Element.deepRemoveIds =
function(element) {
	if (element.nodeType ==	1) {
		element.removeAttribute('id');
		var	elements = element.getElementsByTagName('*');
		for	(var i = 0;	i != elements.length; i++) {
			elements[i].removeAttribute('id');
		}
	}
};

Element.deepVisible	=
function(element) {
	var	visible	= true;
	while (visible && element && element.style)	{
		visible	= (element.style.display !=	'none');
		element	= element.parentNode;
	}
	return visible && element == document;
};

Element.updateAnimated =
	function(element, innerHTML, options) {
		element	= $(element);
		options	= options || {};
		options.afterFinish	= function() { Element.remove(element);	};
		//		var	newElement = document.createElement(element.tagName);
		//		newElement.id =	element.id;
		//		Element.setStyle(newElement, { display:	'none',	width: '100%' });
		// TEST	IE
		var	newElement = element.cloneNode(false);
		Element.setStyle(newElement, { display:	'none' });
		newElement.innerHTML = innerHTML;
		Element.deepRemoveIds(element);
		element.parentNode.insertBefore(newElement,	element);
		return Transition.Morph(element, newElement, options);
	};

Element.replaceAnimated	=
	function(element, html,	options) {
		element	= $(element);
		var	cc = document.createElement('div');
		cc.innerHTML = html.strip();
		while(cc.firstChild	&& cc.firstChild.nodeType != 1)	{
			cc.removeChild(cc.firstChild);
		}
		var	newElement = cc.firstChild;
		if (!newElement) return;

		options	= options || {};
		options.afterFinish	= function() { Element.remove(element);	};

		Element.setStyle(newElement, { display:	'none' });
		if (!element.style.width) {	element.style.width	= '100%'; }
		Element.deepRemoveIds(element);
		element.parentNode.insertBefore(newElement,	element);
		return Transition.Morph(element, newElement, options);
	};

var	Transition = {};

Transition.Morph = function(element1, element2, options) {
	options = Object.extend({}, options || {});
	afterFinish = options.afterFinish || Prototype.emptyFunction;
	element1 = $(element1); element2 = $(element2);
	var oldStyle1 = {
		position: element1.style.position,
		visibility: element1.style.visibility,
		display: 'none',
		overflow: element1.style.overflow,
		width: element1.style.width,
		height:	element1.style.height
	};
	var oldStyle2 = {
		position: element2.style.position,
		visibility: element2.style.visibility,
		display: '',
		overflow: element2.style.overflow,
		width: element2.style.width,
		height:	element2.style.height
	};
	var dim1 = { width: element1.offsetWidth, height: element1.offsetHeight };
	Element.setStyle(element2, { position: 'absolute', visibility: 'hidden', display: '', width: dim1.width + 'px' });
	var	dim2 = { height: element2.offsetHeight };
	var	newStyle1 =	{ position:	'absolute',	visibility:	'',	overflow: 'hidden', width: dim1.width + 'px', height: dim1.height + 'px' };
	var	newStyle2 =	{ position:	'relative',	visibility:	'', overflow: 'hidden', height: dim1.height + 'px' };
	Element.setStyle(element1, newStyle1);
	Element.setOpacity(element2, 0.0);
	Element.setStyle(element2, newStyle2);
	options.afterFinish = 
	function() { 
		Element.setStyle(element1, oldStyle1);
		Element.setStyle(element2, oldStyle2);
		afterFinish(); 
	}.bind(this);
	var	effects	= [	new	Effect.Opacity(element1, { sync: true, from: 1.0, to: 0.0 }),
			new	Effect.Resize(element1,	{ sync:	true, scaleX: false, scaleY: true, newHeight: dim2.height }),
			new	Effect.Opacity(element2, { sync: true, from: 0.0, to: 1.0 }),
			new	Effect.Resize(element2,	{ sync:	true, scaleX: false, scaleY: true, newHeight: dim2.height })];
	return new Effect.Parallel(effects, options);
}

Effect.Resize =	Class.create();
Object.extend(Object.extend(Effect.Resize.prototype, Effect.Base.prototype), {
	initialize:
	function(element) {
		this.element = $(element);
		var	options	= Object.extend({ newWidth:	0, newHeight: 0, scaleX: true, scaleY: true	}, arguments[1]	|| {});
		this.start(options);
	},
		setup:
	function() {
		this.dims =	[this.element.offsetHeight,	this.element.offsetWidth];
		this.delta = [this.options.newHeight - this.dims[0], this.options.newWidth - this.dims[1]];
	},
		update:
	function(position) {
		this.setDimensions(this.dims[0]	+ this.delta[0]	* position,	this.dims[1] + this.delta[1] * position);
	},
		finish:
	function(position) {
	},
		setDimensions:
	function(height, width)	{
		var	d =	{};
		if(this.options.scaleX)	d.width	= width	+ 'px';
		if(this.options.scaleY)	d.height = height +	'px';

		Element.setStyle(this.element, d);
	}
});
// layeredpane.js
function LayeredPane(pane) {
	this.pane =	$(pane);
	this.options = Object.extend( {	transition:	Transition.Morph, duration:	1.0, prefix: ''	}, arguments[1]	|| {});
	this.visibleLayer =	$A(this.pane.childNodes).findAll(function(e) { return e.nodeType ==	1; }).detect(function(l) { return Element.visible(l); });
	this.switching = false;
}

LayeredPane.prototype =	{
	getLayers:
	function() {
		return $A(this.pane.childNodes).findAll(function(e)	{ return e.nodeType	== 1; });
	},

	getVisibleLayer:
	function() {
		return this.visibleLayer;
	},

	addLayer:
	function(layer)	{
		this.pane.appendChild(layer);
	},

	showLayer:
	function(layer,	options) {
	    var	transition;
	    if (layer && typeof layer == 'string') layer = this.options.prefix + layer;
		layer =	$(layer);
		if (!this.switching && layer != this.visibleLayer) {
		    this.switching = true;
		    options = options || {};
		    var	visibleLayer = this.visibleLayer;
		    this.visibleLayer =	layer;
		    transition = this.options.transition(visibleLayer, layer, {	duration: options.duration || this.options.duration, afterFinishInternal: this.afterSwitch.bind(this), afterFinish: options.afterFinish, sync: options.sync });
		}
	    return transition;
	},

	afterSwitch:
	function() {
		this.switching = false;
	}
}

// inplaceEditor.js
function InplaceEditor(instanceId, options)	{
	/* options */
	this.options = Object.extend({ insertStringEmpty: '',
														  insertStringNonEmpty:	'',
														  normalizeValue: function(value) {	return value; }
	}, options || {});

	this.normalizeValue	= this.options.normalizeValue;
	this.insertStringEmpty = this.options.insertStringEmpty;
	this.insertStringNonEmpty =	this.options.insertStringNonEmpty;
	this.insertedString	= '';

	/* get main	element	*/
	this.main		  =	document.getElementById('inplace_' + instanceId);

	/* get buttons */
	this.editButton	  =	document.getElementById('editButton_' +	instanceId);
	this.saveButton	  =	document.getElementById('saveButton_' +	instanceId);
	this.cancelButton =	document.getElementById('cancelButton_'	+ instanceId);

	/* get save	indicator */
	this.saveIndicator = document.getElementById('saveIndicator_' +	instanceId);

	/* get input and display fields	*/
	this.inputField	  =	document.getElementById('inputField_' +	instanceId);
	this.displayField =	document.getElementById('displayField_'	+ instanceId);

	/* get current value */
	this.value	 = this.normalizeValue(this.inputField.value);

	/* set display value */
	this.setDisplayValue(this.value);
	Event.observe(window, 'load', this.scrollDisplay.bind(this));

	/* add hover for display field and edit	button*/
	if (this.displayField) {
		Event.observe( this.displayField,
					   'mouseover',
					   function() {	Element.addClassName( this.displayField, 'hover'); }.bindAsEventListener(this) );

		Event.observe( this.displayField,
					   'mouseout',
					   function() {	Element.removeClassName(this.displayField, 'hover'); }.bindAsEventListener(this) );

		/* add on-click	to display field */
		Event.observe( this.displayField, 'click', this.onClickDisplayPane.bindAsEventListener(this) );

		if (this.editButton) {
			Event.observe( this.editButton,
						   'mouseover',
						   function() {	Element.addClassName( this.displayField, 'hover'); }.bindAsEventListener(this) );

			Event.observe( this.editButton,
						   'mouseout',
						   function() {	Element.removeClassName(this.displayField, 'hover'); }.bindAsEventListener(this) );
		}
	}
	/* add on-clicks to	buttons	*/
	if (this.editButton) {
		Event.observe( this.editButton,	'click', this.onClickDisplayPane.bindAsEventListener(this) );
	}
	if (this.saveButton) {
		Event.observe( this.saveButton,	'click', this.onClickSaveButton.bindAsEventListener(this) );
		/* add key listener	*/
		Event.observe(this.saveButton, (UserAgent.MSIE || UserAgent.KHTML) ? 'keydown' : 'keypress', this.onKeyPressSaveButton.bindAsEventListener(this));
	}
	if (this.cancelButton) {
		Event.observe( this.cancelButton, 'click', this.onClickCancelButton.bindAsEventListener(this) );
	}

	/* add key listener	*/
	Event.observe(this.main, (UserAgent.MSIE ||	UserAgent.KHTML) ? 'keydown' : 'keypress', this.onKeyPressInputField.bindAsEventListener(this));

	/* make	layers */
	this.layeredPane = new LayeredPane(this.main, {	duration: 0.3 });
	var	layers = this.layeredPane.getLayers();
	this.showLayer	 = layers[0];
	this.editLayer	 = layers[1];

	/* flags */
	this.editing = false;
	this.blocked = false;
}

InplaceEditor.prototype	= {
	getInput:
	function() {
	return this.inputField;
	},

	onClickDisplayPane:
	function(event)	{
	Event.stop(event);
	this.edit(event.shiftKey ? 2 : undefined);
	},

	onClickSaveButton:
	function(event)	{
	Event.stop(event);
	this.save(event.shiftKey ? 2 : undefined);
	},

	onClickCancelButton:
	function(event)	{
	Event.stop(event);
	this.cancel(event.shiftKey ? 2 : undefined);
	},

	onKeyPressInputField:
	function(event)	{
	var	keyCode;
	if (UserAgent.WEBKIT) {
		keyCode	= Event.mapMacKeypressKeyCode(event.keyCode);
	}
	else {
		keyCode	= event.keyCode;
	}
	switch(keyCode)	{
		case Event.KEY_RETURN:
		if (!this.options.textareamode)	{
		this.save();
		}
		break;
		case Event.KEY_ESC:
		this.cancel();
		break;
	}
	},

	onKeyPressSaveButton:
	function(event)	{
	var	keyCode;
	if (UserAgent.WEBKIT) {
		keyCode	= Event.mapMacKeypressKeyCode(event.keyCode);
	}
	else {
		keyCode	= event.keyCode;
	}
	switch(keyCode)	{
		case Event.KEY_RETURN:
		this.save();
		break;
	}
	},

	edit:
	function(switchDuration) {
	    if (!this.editing && !this.blocked)	{
		this.editing = true;
		if (this.value == '') {
		    this.inputField.value =	this.value + this.insertStringEmpty;
		    this.insertedString	= this.normalizeValue(this.insertStringEmpty);
		}
		else {
		    this.inputField.value =	this.value + this.insertStringNonEmpty;
		    this.insertedString	= this.normalizeValue(this.insertStringNonEmpty);
		}
		this.layeredPane.showLayer(this.editLayer,
		    { afterFinish: function() {
			if (this.options.textareamode) {
			    Form.Element.setCaretToEnd(this.inputField);
			    Form.Element.scrollToEnd(this.inputField);
			}
			else {
			    Form.Element.setSelectionRange(this.inputField,
							   this.inputField.value.length,
							   this.inputField.value.length	);
			}
			this.inputField.focus();
			if (this.displayField) { Element.removeClassName(this.displayField, 'hover'); }
		    }.bind(this),
		      duration:	switchDuration
		    } );
	    }
	},

	save:
	function(switchDuration) {
		if (this.editing) {
			var	tmpValue = this.normalizeValue(this.inputField.value);
			if (tmpValue.slice(-this.insertedString.length)	== this.insertedString)	{
				tmpValue = tmpValue.slice(0, -this.insertedString.length);
				tmpValue = this.normalizeValue(tmpValue);
			}
			if (tmpValue !=	this.value)	this.setDisplayValue(tmpValue);
			this.layeredPane.showLayer(this.showLayer, { duration: switchDuration, afterFinish: this.afterSwitch.bind(this) });
			if (tmpValue !=	this.value)	{
				this.blocked = true;
				this.value = tmpValue;
				this.editButton.style.display =	'none';
				this.saveIndicator.style.display = 'block';
				var	tmp	= this.options.saveParameters +	'&'	+ encodeURIComponent(this.options.fieldName) + '=' + encodeURIComponent(this.value);
				new	Ajax.Request( this.options.saveAction, { method: 'post', parameters: tmp, onComplete: this.onCompleteSave.bind(this) });
			}
			else {
				this.editing = false;
			}
		}
	},
	
	afterSwitch:
	function() {
		if (!this.blocked) this.editButton.focus();
		this.scrollDisplay();
	},

	onCompleteSave:
	function(transport)	{
		setTimeout(function(transport) {
			this.saveIndicator.style.display = 'none';
			this.editButton.style.display =	'block';
			this.editButton.focus();
			this.editing = false;
			this.blocked = false;
			var	responseObj;
			try	{
				responseObj	= eval(transport.responseText);
			} catch(e) {}
			if (!responseObj ||	responseObj.confirm	!= 'OK') {
				this.displayField.innerHTML	= 'ERROR';
			}
			if (responseObj.exec) {
				eval(responseObj.exec);
			}
		}.bind(this, transport), 500);
	},
	
	cancel:
	function(switchDuration) {
		if (this.editing) {
			this.editing = false;
			this.layeredPane.showLayer(this.showLayer, { duration: switchDuration, afterFinish: this.afterSwitch.bind(this) });
		}
	},
	
	setDisplayValue:
	function(value) {
		var style;
		var displayValue;
		if (value == '') {
			displayValue = this.options.createText;
			style = ' style="color: grey;"';
		}
		else {
			displayValue = value;
			style = '';
		}
		displayValue = displayValue
		.replace(/\</g, '&lt;')
		.replace(/\>/g, '&gt;')
		.replace(/\"/g, '&quot;')
		.replace(/\$/g, '&#x0024;')
		.replace(/\n/g, '<br>');
		this.displayField.innerHTML = '<div class="inlineedit-display"' + style + '>' + displayValue + '</div>';
	},
	
	scrollDisplay:
	function() {
		Form.Element.scrollToEnd(this.displayField.childNodes[0]);
	}
}

// suggestor.js
function SimpleSuggestor(suggestions, options) {
	this.suggestions = suggestions || [];
	this.options = Object.extend({ suggestionClass: SimpleSelectItem }, options || {});
}

SimpleSuggestor.prototype =	{
	setSuggestions:
	function(suggestions) {
		this.suggestions = suggestions || [];
	},

	getSuggestions:
	function(token,	callback) {
		var	normalizedToken	= this.options.normalize ? this.options.normalize(token) : token;
		var	filteredSuggestions	= [];
		for	(var i = 0;	i <	this.suggestions.length; i++) {
			var	normalizedSuggestion = this.options.normalize ?	this.options.normalize(this.suggestions[i])	: this.suggestions[i];
			if (normalizedSuggestion.slice(0, normalizedToken.length) == normalizedToken) {
				var	selectItem;
				if (this.options.suggestionClass) {
					selectItem = new this.options.suggestionClass(this.suggestions[i]);
				}
				else if	(this.options.transformFunction) {
					selectItem = this.options.transformFunction(this.suggestions[i]);
				}
				else {
					selectItem = this.suggestions[i];
				}
				filteredSuggestions.push(selectItem);
			}
		}
		callback(token,	filteredSuggestions);
	}
};

var	Suggestor =	{
	normalize:
	function(token)	{
		var	normalizedToken	= token.replace(/[\	\-\_\&\/]/g, '').toUpperCase();
		return normalizedToken;
	}
}

// popup.js
function PopUp(position, options) {
	this.position =	position;
	this.active	= false;

	this.options = Object.extend({ style: {}, className: '', selects: [] }, options || {});
	var	style =	Object.extend({	display: 'none', position: 'absolute' }, this.options.style);

	this.element = document.createElement('div');
	this.element.className = this.options.className;
	Element.setStyle(this.element, style);
}

PopUp.prototype	= {
	getElement:
	function() {
		return this.element;
	},

	setContent:
	function(content) {
		if (this.content) {
			this.element.replaceChild(content, this.content);
			this.content = content;
		}
		else {
			this.element.appendChild(content);
			this.content = content;
		}
	},

	show:
	function(bounds) {
		if (UserAgent.MSIE) {
			for (var i = 0; i < this.options.selects.length; i++) {
				$(this.options.selects[i]).style.visibility = 'hidden';
			}
		}
		if (this.element.parentNode	!= document.body) {
			document.body.appendChild(this.element);
		}
		if (bounds)	{
			this.position(this.element,	bounds);
		}
		Element.setStyle(this.element, { display: '' });

		this.active	= true;
	},

	hide:
	function() {
		if (UserAgent.MSIE) {
			for (var i = 0; i < this.options.selects.length; i++) {
				$(this.options.selects[i]).style.visibility = '';
			}
		}
	    this.active	= false;
	    Element.setStyle(this.element, { display: 'none', left: '0', top: '0' });
	}
}

PopUp.position =
	function(element, bounds) {
		var	left, top;
		var	elDims = Element.getDimensions(element);
		elDims.width +=	2;

		var	vB = Position.getViewPortBounds();

		var	scrollX	= vB.left; // window.pageXOffset ||	document.documentElement.scrollLeft;
		var	scrollY	= vB.top; // window.pageYOffset	|| document.documentElement.scrollTop;
		var	innerWidth = vB.width; // window.innerWidth	|| document.documentElement.clientWidth;
		var	innerHeight	= vB.height; //	window.innerHeight || document.documentElement.clientHeight;

		if (UserAgent.GECKO) {
			innerWidth = document.body.clientWidth;
			innerHeight	= window.innerHeight;
		}

		else if	(UserAgent.MSIE) {
			innerWidth = document.documentElement.clientWidth;
			innerHeight	= document.documentElement.clientHeight;
			scrollX	= document.documentElement.scrollLeft;
			scrollY	= document.documentElement.scrollTop;
		}

		else if	(UserAgent.WEBKIT) {
			innerWidth = window.innerWidth;
			innerHeight	= window.innerHeight - 1;
		}

		if (innerWidth + scrollX > bounds.left + elDims.width) {
			left = bounds.left + 'px';
		}
		else {
			left = ((innerWidth	- elDims.width)	+ scrollX) + 'px';
		}

		if (innerHeight	+ scrollY >	bounds.top + bounds.height + elDims.height)	{
			top	= (bounds.top +	bounds.height) + 'px';
		}
		else {
			top	= (bounds.top -	elDims.height) + 'px';
		}

		element.style.left = left;
		element.style.top =	top;
	}

// select.js
function Select(options) {
	this.options = Object.extend({ choices:	10, className: '', selectedClassName: 'selected' }, options ||	{});

	this.element = document.createElement('div');
	this.element.className = this.options.className;
	Element.setStyle(this.element, { display: '', position:	'relative', top: '0', left: '0' });

	this.arrowUp = document.createElement('img');
	this.arrowUp.className = 'up-arrow';
	this.arrowUp.src = '/img/xing/arrow_up.gif';
	this.arrowUp.alt = 'up';
	this.arrowUp.style.display = 'none';
	this.element.appendChild(this.arrowUp);

	this.arrowDown = document.createElement('img');
	this.arrowDown.className = 'down-arrow';
	this.arrowDown.src = '/img/xing/arrow_down.gif';
	this.arrowDown.alt = 'down';
	this.arrowDown.style.display = 'none';
	this.element.appendChild(this.arrowDown);

	this.list = document.createElement('ul');
	this.element.appendChild(this.list);

	this.active	= false;
	this.index = undefined;
	this.sO	= undefined;
	this.vRS = undefined;
	this.vRE = undefined;

	this.onMouseMoveListener = this.onMouseMove.bind(this);
	this.onClickListener = this.onClick.bind(this);

	if (UserAgent.MSIE || UserAgent.WEBKIT)	Event.observe(this.element,	"mousewheel", this.onScrollA.bind(this));
	else if	(UserAgent.GECKO) Event.observe(this.element, "DOMMouseScroll",	this.onScrollB.bind(this));
}

Select.prototype = {
	setCallback:
	function(callback) {
		this.callback =	callback;
	},

	getElement:
	function() {
		return this.element;
	},

	setVisibleRange:
	function(vRS) {
		if (this.options.choices < this.sO.length) {
			if (vRS	< 0) {
				vRS	= 0;
			}
			else if	(vRS > this.sO.length -	this.options.choices) {
				vRS	= this.sO.length - this.options.choices;
			}
			if (vRS	== this.vRS	- 1) {
				this.removeSelectItem(this.sO[this.vRE - 1].getDOMElement());
				this.addSelectItem(this.sO[vRS].getDOMElement(), this.sO[this.vRS].getDOMElement());
			}
			else if	(vRS ==	this.vRS + 1) {
				this.removeSelectItem(this.sO[this.vRS].getDOMElement());
				this.addSelectItem(this.sO[this.vRE].getDOMElement());
			}
			else if	(vRS < this.vRS) {
				for	(var i = vRS, j	= this.vRS;	j <	this.vRE; i++, j++)	{
					Event.stopObserving(this.sO[j].getDOMElement(),	"mousemove", this.onMouseMoveListener);
					Event.stopObserving(this.sO[j].getDOMElement(),	"click", this.onClickListener);
					this.list.replaceChild(this.sO[i].getDOMElement(), this.sO[j].getDOMElement());
					Event.observe(this.sO[i].getDOMElement(), "mousemove", this.onMouseMoveListener);
					Event.observe(this.sO[i].getDOMElement(), "click", this.onClickListener);
				}
			}
			else if	(vRS > this.vRS) {
				for	(var i = (vRS +	this.options.choices) -	1, j = this.vRE	- 1; j >= this.vRS;	i--, j--) {
					Event.stopObserving(this.sO[j].getDOMElement(),	"mousemove", this.onMouseMoveListener);
					Event.stopObserving(this.sO[j].getDOMElement(),	"click", this.onClickListener);
					this.list.replaceChild(this.sO[i].getDOMElement(), this.sO[j].getDOMElement());
					Event.observe(this.sO[i].getDOMElement(), "mousemove", this.onMouseMoveListener);
					Event.observe(this.sO[i].getDOMElement(), "click", this.onClickListener);
				}
			}
			this.vRS = vRS;
			this.vRE = vRS + this.options.choices;
			this.setArrows();
		}
	},

	addSelectItem:
	function(element, nextSibiling)	{
		Event.observe(element, "mousemove", this.onMouseMoveListener);
		Event.observe(element, "click", this.onClickListener);
		if (nextSibiling !=	undefined) {
			this.list.insertBefore(element, nextSibiling);
		}
		else {
			this.list.appendChild(element);
		}
	},

	removeSelectItem:
	function(element) {
		this.list.removeChild(element);
		Event.stopObserving(element, "mousemove", this.onMouseMoveListener);
		Event.stopObserving(element, "click", this.onClickListener);
	},

	isActive:
	function() {
		return this.active;
	},

	onKeyPress:
	function(event)	{
		if (this.isActive()) {
			var	keyCode;
			if (UserAgent.WEBKIT) {
				keyCode	= Event.mapMacKeypressKeyCode(event.keyCode);
			}
			else {
				keyCode	= event.keyCode;
			}
			switch(keyCode)	{
				case Event.KEY_UP:
				Event.stop(event);
				this.markPrevious();
				break;
				case Event.KEY_DOWN:
				Event.stop(event);
				this.markNext();
				break;
				case Event.KEY_PAGEUP:
				Event.stop(event);
				this.pageUp();
				break;
				case Event.KEY_PAGEDOWN:
				Event.stop(event);
				this.pageDown();
				break;
				case Event.KEY_HOME:
				Event.stop(event);
				this.posFirst();
				break;
				case Event.KEY_END:
				Event.stop(event);
				this.posLast();
				break;
				case Event.KEY_ESC:
				Event.stop(event);
				this.callback();
				break;
				case Event.KEY_RETURN:
				case Event.KEY_TAB:
				if (this.selectEntry())	{
					Event.stop(event);
				}
				break;
			}
		}
	},

	markPrevious:
	function() {
		if (this.sO) {
			if (this.index != undefined) {
				Element.removeClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
			}
			if (this.index == undefined) {
				this.index = this.sO.length	- 1;
			}
			else if	(this.index	> 0) {
				this.index = this.index	- 1;
			}
			if (this.index < this.vRS) {
				this.setVisibleRange(this.index);
			}
			else if	(this.index	> this.vRE - 1)	{
				this.setVisibleRange((this.index - this.options.choices) + 1);
			}
			if (this.sO[this.index].getValue() != undefined) {
				Element.addClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
			}
		}
	},

	markNext:
	function() {
		if (this.sO) {
			if (this.index != undefined) {
				Element.removeClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
			}
			if (this.index == undefined) {
				this.index = 0;
			}
			else if	(this.index	< this.sO.length - 1) {
				this.index = this.index	+ 1;
			}
			if (this.index < this.vRS) {
				this.setVisibleRange(this.index);
			}
			else if	(this.index	> this.vRE - 1)	{
				this.setVisibleRange((this.index - this.options.choices) + 1);
			}
			if (this.sO[this.index].getValue() != undefined) {
				Element.addClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
			}
		}
	},

	pageUp:
	function() {
		if (this.index != undefined) {
			Element.removeClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
		}
		else {
			this.index = this.sO.length	- 1;
		}
		this.index -= this.options.choices;
		if (this.index < 0)	this.index = 0;
		if (this.sO[this.index].getValue() != undefined) {
			Element.addClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
		}
		this.setVisibleRange(this.vRS -	this.options.choices);
	},

	pageDown:
	function() {
		if (this.index != undefined) {
			Element.removeClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
		}
		else {
			this.index = 0;
		}
		this.index += this.options.choices;
		if (this.index > this.sO.length	- 1) this.index	= this.sO.length - 1;
		if (this.sO[this.index].getValue() != undefined) {
			Element.addClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
		}
		this.setVisibleRange(this.vRS +	this.options.choices);
	},

	posFirst:
	function() {
		if (this.index != undefined) {
			Element.removeClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
		}
		this.index = 0;
		if (this.sO[this.index].getValue() != undefined) {
			Element.addClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
		}
		this.setVisibleRange(0);
	},

	posLast:
	function() {
		if (this.index != undefined) {
			Element.removeClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
		}
		this.index = this.sO.length	- 1;
		if (this.sO[this.index].getValue() != undefined) {
			Element.addClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
		}
		this.setVisibleRange(this.sO.length	- this.options.choices);
	},

	selectEntry:
	function() {
		if (this.index != undefined) {
			this.callback(this.sO[this.index]);
			return true;
		}
		else {
			this.callback();
			return false;
		}
	},

	setSelectOptions:
	function(sO, vRS) {
	    if (this.sO) {
		for (; this.vRS	< this.vRE; this.vRS++)	{
		    this.removeSelectItem(this.sO[this.vRS].getDOMElement());
		}
	    }

	    var	maxWidth = 0;
	    for	(var i = 0;	i <	sO.length; i++)	{
		var curWidth = sO[i].getMinWidth();
		if (curWidth > maxWidth) maxWidth = curWidth;
		sO[i].getDOMElement().autocompleteIndex	= i;
	    }

	    for	(var i = 0; i < sO.length; i++) {
		sO[i].setWidth(maxWidth);
	    }

	    if (!vRS ||	vRS	< 0) {
		vRS	= 0;
	    }
	    else if	(vRS > this.sO.length -	this.options.choices) {
		vRS	= this.sO.length - this.options.choices;
	    }

	    this.index = undefined;
	    this.sO	= sO;
	    this.vRS = vRS;
	    this.vRE = this.vRS;

	    for	(; this.vRE	< this.vRS + this.options.choices && this.vRE <	this.vRS + this.sO.length; this.vRE++) {
		this.addSelectItem(sO[this.vRE].getDOMElement());
	    }

	    this.setArrows();
	},

	selectValue:
	function(value)	{
		if (this.index != undefined) {
			Element.removeClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
		}
		this.index = undefined;
		if (value && this.sO) {
			for	(var i = 0;	this.index == undefined	&& i < this.sO.length; i++)	{
				if (this.sO[i].getValue() == value)	{
					this.index = i;
					Element.addClassName(this.sO[i].getDOMElement(), this.options.selectedClassName);
				}
			}
		}
	},

	getSelectedValue:
	function() {
		return (this.index != undefined) ? this.sO[this.index].getValue() :	undefined;
	},

	setArrows:
	function() {
		if (this.vRS ==	0) {
			this.arrowUp.style.display =	'none';
		}
		else {
			this.arrowUp.style.display =	'';
		}
		if (this.vRE ==	this.sO.length)	{
			this.arrowDown.style.display	= 'none';
		}
		else {
			this.arrowDown.style.display	= '';
		}
	},

	onMouseMove:
	function(event)	{
	    if (this.isActive()) {
		if (this.index >= 0) {
		    Element.removeClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
		}
		this.index = Event.findElement(event, 'LI').autocompleteIndex;
		if (this.sO[this.index].getValue() != undefined) {
		    Element.addClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
		}
	    }
	},

	onClick:
	function(event)	{
		if (this.isActive()) {
			if (this.index >= 0) {
				Element.removeClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
			}
			this.index = Event.findElement(event, 'LI').autocompleteIndex;
			if (this.sO[this.index].getValue() != undefined) {
				Element.addClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
				this.selectEntry();
			}
		}
	},

	onScrollA:
	function(event)	{
		if (this.isActive()) {
			if(event.wheelDelta	> 0) {
				this.setVisibleRange(this.vRS -	1);
			}
			else  {
				this.setVisibleRange(this.vRS +	1);
			}
			Event.stop(event);
		}
	},

	onScrollB:
	function(event)	{
		if (this.isActive()) {
			if(event.detail	< 0) {
				this.setVisibleRange(this.vRS -	1);
			}
			else  {
				this.setVisibleRange(this.vRS +	1);
			}
			Event.stop(event);
		}
	},

	activate:
	function() {
		this.active	= true;
	},

	deactivate:
	function() {
	    this.active	= false;
	    if (this.index != undefined) {
		Element.removeClassName(this.sO[this.index].getDOMElement(), this.options.selectedClassName);
	    }
	    this.index = undefined;
	}
}

function SimpleSelectItem(text)	{
	this.text =	text;
}

SimpleSelectItem.prototype = {
	getDOMElement:
	function() {
		if (this.DOMElement	== undefined) {
			this.DOMElement	= document.createElement('li');
			this.DOMElement.appendChild(document.createTextNode(this.text));
			if (!SimpleSelectItem.wtc) {
				var div = document.createElement('div');
				div.className = 'auto-complete';
				Element.setStyle(div, { position: 'absolute', left: '0', top: '0' });
				document.body.appendChild(div);
				SimpleSelectItem.wtc = document.createElement('ul');
				div.appendChild(SimpleSelectItem.wtc);
			}
			SimpleSelectItem.wtc.appendChild(this.DOMElement);
			this.minWidth =	this.DOMElement.offsetWidth - 33;
			SimpleSelectItem.wtc.removeChild(this.DOMElement);
		}
		return this.DOMElement;
	},

	getMinWidth:
	function() {
		if (this.DOMElement	== undefined) {
			this.getDOMElement();
		}
		return this.minWidth;
	},

	setWidth:
	function(width)	{
		if (this.DOMElement	== undefined) {
			this.getDOMElement();
		}
		Element.setStyle(this.DOMElement, {	width: width + 'px'	});
	},

	getValue:
	function() {
		return this.text;
	}
}


// autocompleter.js
function Autocompleter(element,	options) {
    this.options = Object.extend({ minTokenLength: 1, delimiters: [',',	';', String.fromCharCode(255 * 256 + 12), String.fromCharCode(48 * 256 + 1), '\n'],	insertString: ', ',	delay: 50 }, options ||	{});
    this.ignoreMinTokenLengthOn	= $A(this.options.ignoreMinTokenLengthOn);

    this.element = $(element);
    this.isTextfield = this.element.tagName == 'INPUT';

    Event.observe(this.element,	'blur',	this.onBlur.bindAsEventListener(this), true);
    Event.observe(this.element,	(UserAgent.MSIE	|| UserAgent.KHTML)	? 'keydown'	: 'keypress', this.onKeyPress.bindAsEventListener(this));
    Event.observe(this.element,	'keyup', this.onKeyUp.bindAsEventListener(this));

    this.suggestor = this.options.suggestor;

    this.select = this.options.select;
    this.select.setCallback(this.insert.bind(this));
    Event.observe(this.select.getElement(), 'mousedown', this.blockBlur.bindAsEventListener(this), true);

    this.popup = this.options.popup;
    if (this.popup)	{
	this.popup.setContent(this.select.getElement());
    }

    this.active	= false;
    this.blurBlocked = false;
    this.currentToken =	undefined;
    this.requestedToken	= undefined;
    this.triggerTimeout	= undefined;
}

Autocompleter.prototype	= {
	isActive:
	function() {
		return this.active;
	},

	onKeyPress:
	function(event)	{
		if (this.isActive()) {
			this.select.onKeyPress(event);
		}
		else {
			var	keyCode;
			if (UserAgent.WEBKIT) {
				keyCode	= Event.mapMacKeypressKeyCode(event.keyCode);
			}
			else {
				keyCode	= event.keyCode;
			}
			switch(keyCode)	{
				case Event.KEY_PAGEUP:
				case Event.KEY_PAGEDOWN:
				Event.stop(event);
				this.triggerUpdate(this.ignoreMinTokenLengthOn.detect(function(o) {	return o ==	keyCode; })	!= undefined);
				break;
				case Event.KEY_UP:
				case Event.KEY_DOWN:
				if (this.isTextfield) {
					Event.stop(event);
					this.triggerUpdate(this.ignoreMinTokenLengthOn.detect(function(o) {	return o ==	keyCode; })	!= undefined);
				}
				break;
				default:
				this.select.onKeyPress(event);
			}
		}
	},

	onKeyUp:
	function(event)	{
		if (this.isActive()) {
			switch(event.keyCode) {
				case Event.KEY_UP:
				case Event.KEY_DOWN:
				case Event.KEY_PAGEUP:
				case Event.KEY_PAGEDOWN:
				case Event.KEY_HOME:
				case Event.KEY_END:
				case Event.KEY_RETURN:
				case Event.KEY_TAB:
				case Event.KEY_ESC:
				break;
				default:
				this.triggerUpdate();
				break;
			}
		}
		else {
			switch(event.keyCode) {
				case Event.KEY_LEFT:
				case Event.KEY_RIGHT:
				case Event.KEY_UP:
				case Event.KEY_DOWN:
				case Event.KEY_PAGEUP:
				case Event.KEY_PAGEDOWN:
				case Event.KEY_RETURN:
				case Event.KEY_TAB:
				case Event.KEY_ESC:
				break;
				default:
				this.triggerUpdate(this.ignoreMinTokenLengthOn.detect(function(o) {	return o ==	event.keyCode; }) != undefined);
				break;
			}
		}
	},

	triggerUpdate:
	function(force)	{
		if (this.triggerTimeout) clearTimeout(this.triggerTimeout);
		this.triggerTimeout	= setTimeout(this.updateSuggestions.bind(this, force), this.options.delay);
	},

	updateSuggestions:
	function(force)	{
	    var	token =	this.getToken();
	    if (token.end == token.caretPos && (token.end - token.start >= this.options.minTokenLength || force)) {
		var newToken = token.value.slice(token.start, token.caretPos);
		if (newToken !=	this.requestedToken	&& newToken	!= this.currentToken) {
		    this.requestedToken	= newToken;
		    this.suggestor.getSuggestions(this.requestedToken, this.receiveSuggestions.bind(this));
		}
	    }
	    else if (this.isActive()) {
		this.deactivate();
	    }
	},

	receiveSuggestions:
	function(token,	suggestions) {
		if (token == this.requestedToken &&	suggestions.length > 0)	{
			var	selectedValue;
			if (this.isActive()) {
				selectedValue =	this.select.getSelectedValue();
				this.deactivate();
			}
			this.select.setSelectOptions(suggestions, 0);
			this.select.selectValue(selectedValue);
			this.activate();
			this.requestedToken	= '';
			this.currentToken =	token;
		}
		else if	(this.isActive()) {
			this.deactivate();
		}
	},

	onBlur:
	function(event)	{
		if (this.blurBlocked) {
			Event.stop(event);
			this.blurBlocked = false;
			this.element.focus();
		}
		else {
			this.deactivate();
		}
	},

	blockBlur:
	function(event)	{
		Event.stop(event);
		this.blurBlocked = true;
	},

	insert:
	function(selectItem) {
		var text;
		if (selectItem) {
			text = selectItem.getValue();
		}
		this.deactivate();
		if (text !=	undefined) {
		var token = this.getToken(true);
		var prefix = token.value.slice(0, token.start);
		var postfix = token.value.slice(token.end);
		var insertDelimiter = !this.options.insertDelimiterOnlyAtEnd ||	postfix.replace(/\s*/, '').length == 0;
		this.element.value = prefix + text + (insertDelimiter ?	this.options.insertString : '') + postfix;
		var caretPos = token.start + text.length + (insertDelimiter ? this.options.insertString.length : 0);
		Form.Element.setSelectionRange(this.element, caretPos, caretPos);
	    }
	    this.element.focus();
	},

	getToken:
	function(last) {
		var	newValue = Form.Element.value(this.element);
		if (!last && (this.value !=	newValue ||	this.selectionStart	!= Form.Element.selectionStart(this.element) ||	this.selectionEnd != Form.Element.selectionEnd(this.element))) {
			this.value = newValue;
			this.selectionStart	= Form.Element.selectionStart(this.element);
			this.selectionEnd =	Form.Element.selectionEnd(this.element);

			var	prefix = this.value.slice(0, this.selectionStart);
			var	postfix	= this.value.slice(this.selectionEnd);

			var	delimPosPrefix = -1;
			for	(var i = 0;	i <	this.options.delimiters.length;	i++) {
				var	pos	= prefix.lastIndexOf(this.options.delimiters[i]);
				if (pos	> delimPosPrefix) delimPosPrefix = pos;
			}

			var	delimPosPostfix	= postfix.length;
			for	(var i = 0;	i <	this.options.delimiters.length;	i++) {
				var	pos	= postfix.indexOf(this.options.delimiters[i]);
				if (pos	>= 0 &&	pos	< delimPosPostfix) delimPosPostfix = pos;
			}

			this.token = { changed:	true, start: this.selectionStart - prefix.slice(delimPosPrefix + 1).replace(/^\s*/,'').length,
						   end:	this.selectionEnd +	postfix.slice(0, delimPosPostfix).replace(/\s*$/,'').length,
						   caretPos: this.selectionStart,
						   value: this.value };
		}
		else {
			this.token.changed = false;
		}
		return this.token;
	},

	activate:
	function() {
		this.select.activate();
		if (this.popup)	{
			var	token =	this.getToken();
			var	bounds = Form.Element.getRangeBounds(this.element, token.start,	token.caretPos);
			var	iPos = Position.cumulativeOffset(this.element);
			bounds.left	+= iPos[0] - 1;
			bounds.top += iPos[1];
			this.popup.show(bounds);
		}
		this.active	= true;
	},

	deactivate:
	function() {
		this.active	= false;
		this.blurBlocked = false;
		this.currentToken =	undefined;
		this.requestedToken	= undefined;

		if (this.triggerTimeout) clearTimeout(this.triggerTimeout);
		if (this.popup)	this.popup.hide();
		this.select.deactivate();
	}
}

function DependentSelect(args) {
	this.map			= args['map'];
	this.mapKeys		= args['mapKeys'];

	this.masterSelect		= document.getElementById(args['masterSelect']);
	this.initialInput		= document.getElementById(args['dependentSelect']);
	this.container		= this.initialInput.parentNode;
	this.currentInput		= this.initialInput;
	this.inputs			= {};
	this.labels			= [];
	if (args['labels'])	{
		for	(var i = 0;	i <	args['labels'].length; i++)	{
			var	label_id = args['labels'][i];
			var	label =	document.getElementById(label_id);
			if (label) this.labels.push(label);
		}
	}
	this.noKeyOption	= args['noKeyOption'] || {};
	this.undefinedOption	= args['undefinedOption'] || {};
	this.noOption		= args['noOption'] || {};
	this.singleOption		= args['singleOption'] || {};
	this.multipleOptions	= args['multipleOptions'] || {};
	this.onChangeListener = args['onChange'];

	this.onchange();
	Event.observe(this.masterSelect, 'change', this.onchange.bind(this));
};

DependentSelect.prototype.onchange =
	function(event)	{
		var	value = this.masterSelect.value;
		var key = 'key:' + value;
		var	nextInput;
		var	hideLabel;

		if (!value) {
			if (!this.inputs[key]) {
				if (this.noKeyOption.hidden) this.inputs[key] = this.createHiddenInput();
				else this.inputs[key] = this.initialInput;
			}
			hideLabel = this.noKeyOption.hidden;
		}
		else if (!this.map[value]) {
			if (!this.inputs[key]) {
				if (this.undefinedOption.hidden) this.inputs[key] = this.createHiddenInput();
				else this.inputs[key] = this.initialInput;
			}
			hideLabel = this.undefinedOption.hidden;
		}
		else if	(this.map[value].length == 0) {
			if (!this.inputs[key]) {
				this.inputs[key] = this.createHiddenInput();
			}
			hideLabel =	true;
		}
		else if	(this.map[value].length == 1)	{
			if (!this.inputs[key]) {
				if (this.singleOption.hidden) this.inputs[key] = this.createHiddenInput(this.mapKeys ? this.map[value][0][this.mapKeys.value] : this.map[value][0]);
				else this.inputs[key] = this.createSelect(value, this.singleOption);
			}
			hideLabel =	this.singleOption.hidden;
		}
		else if (this.map[value].length > 1) {
			if (!this.inputs[key]) {
				this.inputs[key] = this.createSelect(value, this.multipleOptions);
			}
			hideLabel =	false;
		}
		if (this.currentInput != this.inputs[key])	{
			var	visibilityAttribute	= hideLabel	? 'hidden' : '';
			for	(var i = 0;	i <	this.labels.length;	i++) {
				this.labels[i].style.visibility	= visibilityAttribute;
			}
			this.container.replaceChild(this.inputs[key], this.currentInput);
			this.currentInput =	this.inputs[key];
		}
		if (this.onChangeListener) this.onChangeListener(value);
	};

DependentSelect.prototype.createHiddenInput =
	function(value) {
		var input = document.createElement('input');
		input.type = 'hidden';
		input.id = this.initialInput.id;
		input.name = this.initialInput.name;
		input.value = value;
		return input;
	};

DependentSelect.prototype.createSelect =
	function(key, selectOptions) {
	var	currentValue	= this.currentInput.value;
	var	select		= document.createElement('select');
	select.id		= this.initialInput.id;
	select.name		= this.initialInput.name;
	select.className	= this.initialInput.className;
	select.style.width	= this.initialInput.style.width;
	select.tabIndex = this.initialInput.tabIndex;
	var	i =	0;
	if (selectOptions.emptyOption) {
		select.options[i] =	new	Option(selectOptions.emptyOption, '');
		i++;
	}
	var	selectedIndex =	0;
	for	(var j = 0;	j <	this.map[key].length; j++, i++)	{
		var	value;
		var	label;
		if (this.mapKeys) {
		value =	this.map[key][j][this.mapKeys.value];
		label =	this.map[key][j][this.mapKeys.label];
		}
		else {
		value =	this.map[key][j];
		label =	this.map[key][j];
		}
		// we cant use the selected	paramter of	the	constructor, since IE magically	selects	previous option
		select.options[i] =	new	Option(label, value, false,	false);
		if (value == currentValue) {
		selectedIndex =	i;
		}
	}
	select.selectedIndex = selectedIndex;
	return select;
	};

var Overlay = {
	start:
	function(options) {
		this.options = options || {};
		if (UserAgent.MSIE)	{
			var	selects	= document.getElementsByTagName('select');
			for	(i = 0;	i <	selects.length;	i++) {
				selects[i].style.visibility	= 'hidden';
			}
		}
		if (!this.overlay) {
			this.refreshDisplayEL = this.refreshDisplay.bind(this);
			this.overlay = document.createElement('div');
			this.overlay.id = 'modal-background';
			this.overlay.className = 'modal-background';
			document.body.appendChild(this.overlay);
		}
		Element.setStyle(this.overlay, { visibility: 'hidden', width: '0', height: '0', display: '' });

		this.refreshDisplay();
		Element.setStyle(this.overlay, { visibility: '' });		

		Event.observe(window, 'resize', this.refreshDisplayEL);
		Event.observe(window, 'scroll', this.refreshDisplayEL);
	},
	
	stop:
	function() {
		Event.stopObserving(window, 'resize', this.refreshDisplayEL);
		Event.stopObserving(window, 'scroll', this.refreshDisplayEL);
		Element.hide(this.overlay);
		if (UserAgent.MSIE)	{
			var	selects	= document.getElementsByTagName('select');
			for	(i = 0;	i <	selects.length;	i++) {
				selects[i].style.visibility	= '';
			}
		}
	},

	refreshDisplay:
	function() {
		var	vB = Position.getViewPortBounds();
		Element.setStyle(this.overlay, { width: (vB.left + vB.width) + 'px', height: (vB.top + vB.height) + 'px' });
		if (this.options.dialog) {
			var left = (vB.left + ((vB.width - this.options.dialog.offsetWidth) / 2));
			var top = (vB.top + ((vB.height - this.options.dialog.offsetHeight) / 2));
			if (left < 0) left = 0;
			if (top < 0) top = 0;
			Element.setStyle(this.options.dialog, { left:  left + 'px', top: top + 'px' });
		}
	}
};

/*
Created	By:	Chris Campbell
Website: http://particletree.com
Date: 2/1/2006

Inspired by	the	lightbox implementation	found at http://www.huddletogether.com/projects/lightbox/

Stripped and adapted by	Michael	Otto.
http://www.epublica.de

Rewritten by Lorenz	Knies.
http://www.epublica.de
*/

// callback
var	do_confirm;

function cool_confirm(args)	{
	if (!args['id']) {
		if (!cool_confirm.initalized) {
			cool_confirm.initalized = true;
			cool_confirm.okLabel = document.getElementById('modal-window:ok_label').innerHTML;
			cool_confirm.cancelLabel = document.getElementById('modal-window:cancel_label').innerHTML;
		}
		else {
			document.getElementById('modal-window:title').innerHTML = '';
			document.getElementById('modal-window:text').innerHTML = '';
			document.getElementById('modal-window:ok_label').innerHTML = cool_confirm.okLabel;
			document.getElementById('modal-window:cancel_label').innerHTML = cool_confirm.cancelLabel;
			document.getElementById('modal-window:title').style.backgroundImage = 'url(/img/xing/icn_help.gif)';
		}
	}
	var	id		= args['id'] ||	'modal-window';
	var	element	= args['element'];
	var	op		= args['op'];
	var	href		= args['href'];
	var	callback	= args['callback'];

	do_confirm = _do_confirm;

	var	modalWindow	= document.getElementById(id);
	modalWindow.className =	'modal-window';
	Element.setStyle(modalWindow, {	visibility:	'hidden', position:	'absolute',	left: '0', top:	'0', display: '' });
	if (modalWindow.parentNode != document.body) document.body.appendChild(modalWindow);

	if (args['icon']) {
		var	div	= document.getElementById(id + ':title');
		if (div) {
			div.style.backgroundImage =	'url(' + args['icon'] +	')';
		}
	}
	for	(var k in {	title: true, text: true, ok_label: true, cancel_label: true	}) {
		if (args[k]) {
			var	div	= document.getElementById(id + ':' + k);
			if (div) {
				div.innerHTML =	args[k];
			}
		}
	}

	Overlay.start({ dialog: modalWindow });
	Element.setStyle(modalWindow, {	visibility:	'' });

	var firstButton = modalWindow.getElementsByTagName('button')[0];
	if (firstButton) firstButton.focus();

	return false;

	function _do_confirm(returncode) {
		Element.hide(modalWindow);
		Overlay.stop();

		if (returncode)	{
			if (callback) {
				callback(returncode);
			}
			else if	(element) {
				if (element.tagName	== 'A')	{
					var	uriComponent;
					var	form = modalWindow.getElementsByTagName('form')[0];
					if (form) {
						uriComponent = Form.serialize(form);
					}
					else {
						uriComponent = '';
					}
					location.href = element.href + '&' + uriComponent;
				}
				else if	(element.tagName == 'BUTTON' || element.tagName == 'INPUT') {
					if (element.type == 'submit') {
						if (op)	element.form.op.value = op;
						element.form.submit();
					}
					else if	(element.type == 'button' && href) {
						location.href = href;
					}
				}
			}
		}
	}
}

function Preview(args) {
	this.callback = args['callback'];
	this.dialog = $(args['dialog']);
	this.container = $(this.dialog.id + ':container');

	if (Preview.innerHTML[this.container.id]) this.container.innerHTML = Preview.innerHTML[this.container.id];

	this.cancelEL = this.cancel.bind(this);
	this.sendEL = this.send.bind(this);
	Event.observe(this.dialog.id + ':cancel', 'click', this.cancelEL);
	Event.observe(this.dialog.id + ':send', 'click', this.sendEL);

	document.body.appendChild(this.dialog);
	new Ajax.Request(args.url, { parameters: args.parameters, onComplete: this.onComplete.bind(this) });
	Element.setStyle(this.dialog, { display: '', visibility: 'hidden' });
	Overlay.start({ dialog: this.dialog });
	Element.setStyle(this.dialog, { visibility: '' });	
}

Preview.innerHTML = {};

Preview.prototype = {
	cancel:
	function() {
		Element.hide(this.dialog);
		Overlay.stop();
		Event.stopObserving(this.dialog.id + ':cancel', 'click', this.cancelEL);
		Event.stopObserving(this.dialog.id + ':send', 'click', this.sendEL);
	},
	
	send:
	function() {
		if (this.loaded) {
			this.cancel();
			this.callback();
		}
	},

	onComplete:
	function(transport) {
		if (!Preview.innerHTML[this.container.id]) Preview.innerHTML[this.container.id] = this.container.innerHTML;
		this.container.innerHTML = transport.responseText;
		Overlay.refreshDisplay();
		this.loaded = true;
	}
}

function SharedData(args) {
	this.prefix	= args['prefix'];
	this.defaults =	args['defaults'];

	this.cbAll = document.getElementById(this.prefix + ':all');
	this.f = this.cbAll.form;
	
	var saveButton = document.getElementById(this.prefix + ':save_button');
	if (saveButton) {
		Event.observe(saveButton, 'click', this.onSubmit.bind(this));
	}

	this.boxRefreshListener	= this.boxRefresh.bindAsEventListener(this);
	this.toggles = {};
	this.expanders = {};
	this.divs =	{};

	Event.observe(this.cbAll, 'click', this.checkAll.bind(this));
	for (var i = 0;	i < this.groups.length;	i++) {
	    var	group =	this.groups[i];
	    this.toggles[group]	= document.getElementById(this.prefix +	':toggle_' + group);
	    this.expanders[group] = document.getElementById(this.prefix	+ ':expander_' + group);
	    this.divs[group] = document.getElementById(this.prefix + ':div_' + group);

	    Event.observe(this.f[group], 'click', this.checkGroup.bind(this, group));
	    Event.observe(this.toggles[group], 'click',	this.toggle.bind(this, group));
	}
	Event.observe(this.f.birth_date, 'click', this.checkBday.bind(this));
	Event.observe(this.f.birth_year, 'click', this.checkByear.bind(this));

	for (var group in this.inputs) {
	    for	(var j = 0; j <	this.inputs[group].length; j++)	{
		Event.observe(this.f[this.inputs[group][j]], 'click', this.boxRefreshListener);
	    }
	}

	var saveDefaultsButton = document.getElementById(this.prefix + ':save_as_defaults');
	if (saveDefaultsButton)	Event.observe(saveDefaultsButton, 'click', this.saveAsDefaults.bindAsEventListener(this));
	var useDefaultsButton =	document.getElementById(this.prefix + ':use_defaults');
	if (useDefaultsButton) Event.observe(useDefaultsButton,	'click', this.useDefaults.bindAsEventListener(this));

	this.boxRefresh();
}

SharedData.prototype = {
	groups:	["business","private","im"],
	inputs:	{"private":	["email_p","city_p","province_p","country_p","address_p","phone_private","fax_p"],
		 "business":	["email","address_business","phone_business","fax_business"],
		 "im":		["im_icq","im_msn","im_aim","im_yahoo","im_skype"],
		 "various":	["birth_date","birth_year","phone_mobile","allow_message"]},

	checkAll:
	function() {
	    var onoff = this.cbAll.checked;
	    for (var group in this.inputs) {
		for (var i = 0;	i < this.inputs[group].length; i++) {
		    this.f[this.inputs[group][i]].checked = onoff;
		}
	    }
	    this.boxRefresh();
	},

	checkGroup:
	function(group)	{
	    var onoff = this.f[group].checked
	    for (var i = 0; i < this.inputs[group].length; i++) {
		this.f[this.inputs[group][i]].checked =	onoff;
	    }
	    this.boxRefresh();
	},

	checkBday:
	function() {
	    if (this.f.birth_year.checked) {
		this.f.birth_year.checked = this.f.birth_date.checked;
	    }
	},

	checkByear:
	function() {
	if (this.f.birth_year.checked == 1)
	this.f.birth_date.checked =	1;
	},

	boxRefresh:
	function() {
	    var allChecked = true;
	    for	(var i = 0;	i <	this.groups.length;	i++) {
		var	group =	this.groups[i];
		var	status = this.mayToggle(group);
		var allChecked = allChecked && status[1];
		this.f[group].checked =	status[1];
		if (status[0]) {
		    this.toggles[group].style.cursor = 'pointer';
		    this.set_expander(this.expanders[group], Element.visible(this.divs[group]));
		}
		else {
		    if (!Element.visible(this.divs[group]))	{
			this.blindDown(this.divs[group]);
		    }
		    this.toggles[group].style.cursor = 'auto';
		    this.unset_expander(this.expanders[group]);
		}
	    }
	    var	status = this.mayToggle('various');
	    allChecked = allChecked && status[1];
	    this.cbAll.checked = allChecked;
	    this.set_ajax_state_none();
	},

	toggle:
	function(group)	{
	if (Element.visible(this.divs[group])) {
		if (this.mayToggle(group)[0]) {
		this.blindUp(this.divs[group]);
		this.set_expander(this.expanders[group], false);
		}
	}
	else {
		this.blindDown(this.divs[group]);
		this.set_expander(this.expanders[group], true);
	}
	},

	mayToggle:
	function(group)	{
	var	allChecked = true;
	var	allUnchecked = true;
	for	(var j = 0;	j <	this.inputs[group].length; j++)	{
		allChecked = allChecked	&& this.f[this.inputs[group][j]].checked;
		allUnchecked = allUnchecked	&& !this.f[this.inputs[group][j]].checked;
	}
	return [(allChecked	|| allUnchecked), allChecked, allUnchecked];
	},

	blindUp:
	function(element) {
	Effect.BlindUp(element,	{ duration:	0.3, afterFinish: function() { this.blocked	= false; }.bind(this) });
	},

	blindDown:
	function(element) {
	Effect.BlindDown(element, {	duration: 0.3, afterFinish:	function() { this.blocked =	false; }.bind(this)	});
	},

	onSubmit:
	function(event)	{
	    Event.stop(event);
	    if (document.getElementById(this.prefix	+ ':global_settings_warning')) Effect.BlindUp(this.prefix +	':global_settings_warning',	{ duration:	0.3	});
	    this.set_ajax_state_waiting();
	    var	parameters = Form.serialize(this.f);
	    new	Ajax.Request('/app/profile/ajax.js',
	    { method: 'post',
			  parameters: parameters,
			  onComplete: function() { this.set_ajax_state_done(); }.bind(this)
										     } );
	},

	saveAsDefaults:
	function (event) {
	Event.stop(event);
	this.set_ajax_state_waiting('ajax_state_save_as_defaults');
	this.defaults =	{};
	var	parameters = 'op=add.save_as_defaults';
	for	(var group in this.inputs) {
		for	(var i = 0;	i <	this.inputs[group].length; i++)	{
		if (this.f[this.inputs[group][i]].checked) {
			parameters += '&' +	this.inputs[group][i] +	'=1';
			this.defaults[this.inputs[group][i]] = 1;
		}
		}
	}
	new	Ajax.Request('/app/contact/ajax.js',
		{ method:	  'post',
		  parameters: parameters,
		  onComplete: function() { this.set_ajax_state_none('ajax_state_save_as_defaults');	}.bind(this)
	});
	},

	useDefaults:
	function(event)	{
	Event.stop(event);
	this.set_ajax_state_waiting('ajax_state_use_defaults');
	for	(var group in this.inputs) {
		for	(var i = 0;	i <	this.inputs[group].length; i++)	{
		this.f[this.inputs[group][i]].checked =	this.defaults[this.inputs[group][i]] ? true	: false;
		}
	}
	this.boxRefresh();
	this.set_ajax_state_none('ajax_state_use_defaults');
	},

	set_ajax_state_none:
	function(ajaxStateId) {
	var	ajaxState =	document.getElementById(this.prefix	+ ':' +	(ajaxStateId ||	'ajax_state'));
	if (ajaxState) {
		setTimeout(function() {
		ajaxState.src =	'/img/no.gif';
		}, 800);
	}
	if (ajaxState) {
		//		ajaxState.src =	'/img/no.gif';
	}
	},

	set_ajax_state_done:
	function(ajaxStateId) {
	var	ajaxState =	document.getElementById(this.prefix	+ ':' +	(ajaxStateId ||	'ajax_state'));
	if (ajaxState) {
		setTimeout(function() {
		ajaxState.src =	'/img/saved_icon.png';
		}, 800);
	}
	},


	set_ajax_state_waiting:
	function(ajaxStateId) {
	var	ajaxState =	document.getElementById(this.prefix	+ ':' +	(ajaxStateId ||	'ajax_state'));
	if (ajaxState) {
		ajaxState.src="/img/ajax_waiting.gif";
	}
	},

	set_expander:
	function(expander, expanded) {
	if (expanded) {
		expander.src='/img/list_minus.png';
	}
	else {
		expander.src='/img/list_plus.png';
	}
	},

	unset_expander:
	function(expander) {
	expander.src="/img/no.gif";
	}
}

function ContextHelp(args) {
	Element.setStyle(args['triggerId'], { cursor: 'help' });
	Event.observe(args['triggerId'], 'click', function(e) {
		Event.stop(e);
		document.getElementById('context-window-help:help-html').innerHTML = args['helpHTML'];
		ContextWindow({ id: 'context-window-help', alignTo: args['triggerId'], xOffset: 8, yOffset: document.getElementById(args['triggerId']).offsetHeight + 8 });
		}.bindAsEventListener(this));
}

function ContextWindow(args) {
	var	id		= args['id'] ||	'context-window';
	var alignTo = $(args['alignTo']);

	if (ContextWindow.alignTo && ContextWindow.alignTo == alignTo) { ContextWindow.hide(); return; }
	if (ContextWindow.alignTo && ContextWindow.alignTo != alignTo) { ContextWindow.hide(); }
	ContextWindow.alignTo = alignTo;
	
	var cw = document.getElementById(id);
	if (cw.parentNode != document.body) {
	    document.body.appendChild(cw);
	    Element.setStyle(cw, { position: 'absolute'	});
	}

	if (!ContextWindow.windowObserver) {
		Event.observe(document, 'click', ContextWindow.hide);
		ContextWindow.windowObserver = true;
	}
	if (!ContextWindow.observers[id]) {
		Event.observe(cw, 'click', function(e) {
			if (e.stopPropagation) {
				e.stopPropagation();
			}
			else {
				e.cancelBubble = true;
			}
		}.bindAsEventListener(this));
	    ContextWindow.observers[id] = true;
	}

	if (args['update_function']) {
	    args['update_function'](cw,	args);
	}

	var pos = Position.cumulativeOffset(ContextWindow.alignTo);
	pos[0] += args['xOffset'] || 0;
	pos[1] += args['yOffset'] || 0;
	ContextWindow.visibleWindow = cw;
	Element.setStyle(cw, { left: (pos[0] - 10) + 'px', top: (pos[1] - 10) + 'px' });
	Effect.Appear(cw, {	duration: 0.3 });
}

ContextWindow.observers = {};

ContextWindow.hide = function() {
    if (ContextWindow.visibleWindow) {
		ContextWindow.visibleWindow.style.display = 'none';
		ContextWindow.visibleWindow = null;
		ContextWindow.alignTo = null;
    }
};

ContextWindow.updateSkypeWindow	= function(cw, args) {
	var as = cw.getElementsByTagName('a');
	for (var i = 0;	i < as.length; i++) {
	    var href = as[i].href;
	    as[i].href = 'skype:' + args['im_skype'] + href.slice(href.lastIndexOf('?'));
	}
}

var FormManagers = {};

function FormManager(args) {
	this.onFocusEL		= this.onFocus.bindAsEventListener(this);
	this.onBlurEL		= this.onBlur.bindAsEventListener(this);

	FormManagers[args['form_id']] = this;
	this.form = document.getElementById(args['form_id']);

	this.checks = [];
	this.hints = {};
	this.observedInputs = {};

	this.addChecks(args['checks'] || []);
	this.addHints(args['hints'] || {});

	this.globalErrorMsg = document.getElementById(args['globalErrorMsg']);

    Event.observe(this.form, 'reset', this.onReset.bindAsEventListener(this));
    Event.observe(this.form, 'submit', this.onSubmit.bindAsEventListener(this));
}

FormManager.prototype = {
	addChecks:
	function(checks) {
		for (var i = 0; i <  checks.length; i++) {
			this.checks.push(checks[i]);
			if (checks[i].inputName) {
				if (!this.observedInputs[checks[i].inputName]) {
					this.observedInputs[checks[i].inputName] = true;
					var input = this.form[checks[i].inputName];
					Event.observe(input, 'focus', this.onFocusEL);
					Event.observe(input, 'blur', this.onBlurEL);
				}
			}
		}
	},

	addHints:
	function(hints) {
		for (var name in hints) {
			this.hints[name] = hints[name];
			if (!this.observedInputs[name]) {
				this.observedInputs[name] = true;
				var input = this.form[name];
				Event.observe(input, 'focus', this.onFocusEL);
				Event.observe(input, 'blur', this.onBlurEL);
			}
			this.setInput(name);
		}
	},

	removeInputs:
	function(names) {
		for (var i = 0; i < names.length; i++) {
			var name = names[i];
			var filteredChecks = [];
			for (var j = 0; j < this.checks.length; j++) {
				if (!this.checks[i].inputName || this.checks[i].inputName != name) filteredChecks.push(this.checks[i]);
			}
			this.checks = filteredChecks;
			delete(this.hints[name]);
			delete(this.observedInputs[name]);
			var input = this.form[name];
			if (input) {
				Event.stopObserving(input, 'focus', this.onFocusEL);
				Event.stopObserving(input, 'blur', this.onBlurEL);
			}
		}
	},

	getValue:
	function(name) {
		var input = this.form[name];

		if (!this.hints[name]) return input.value;
		var hint = this.hints[input.name].replace(/[\r\n]/g, '');
		var value = input.value.replace(/[\r\n]/g, '');
		if (value == hint.substr(0, value.length)) {
			return '';
		}
		else {
			return input.value;
		}
	},

	reset:
	function() {
		this.form.reset();
		this.onReset();
	},

	submit:
	function() {
		if (this.onSubmit()) {
			this.form.submit();
		}
	},
	
    onFocus:
    function(e) {
		var name = Event.element(e).name;
		if (name) this.resetInput(name);
    },
	
    onBlur:
    function(e)	{
		var name = Event.element(e).name;
		if (name) this.setInput(Event.element(e).name);
    },

	onReset:
	function(e) {
		for (var name in this.hints) {
			this.setInput(name);
		}
	},

	onSubmit:
	function(e) {
		if (this.globalErrorMsg) {
			Element.hide(this.globalErrorMsg);
		}
		for (var i = 0; i < this.checks.length; i++) {
			var input = this.checks[i].inputName ? this.form[this.checks[i].inputName] : null;
			var errorClass = this.checks[i].errorClass || 'error-form-field';
			var errorMsg = document.getElementById(this.checks[i].errorMsg || 'error-' + this.checks[i].inputName);
			if (input) Element.removeClassName(input, errorClass);
			if (errorMsg) Element.hide(errorMsg);
		}
		var submit = true;
		for (var i = 0; i < this.checks.length; i++) {
			if (!this.checks[i].onBlur && !this.checks[i].check(this, this.checks[i].inputName)) {
				submit = false;
				var input = this.checks[i].inputName ? this.form[this.checks[i].inputName] : null;
				var errorClass = this.checks[i].errorClass || 'error-form-field';
				var errorMsg = document.getElementById(this.checks[i].errorMsg || 'error-' + this.checks[i].inputName);
				if (input) Element.addClassName(input, errorClass);
				if (errorMsg) Element.show(errorMsg);
			}
		}
		if (submit) {
			for (var name in this.hints) {
				this.resetInput(name);
			}
			if (e) {
				return;
			}
			else {
				return true;
			}
		}
		else {
			if (this.globalErrorMsg) {
				Element.show(this.globalErrorMsg);
				new Effect.ScrollTo(document.body, { duration: 0.5 });
			}
			if (e) {
				Event.stop(e);
				return;
			}
			else {
				return false;
			}
		}
	},

	setInput:
	function(name) {
		var i = this.form[name];
		if (this.hints[name] && this.getValue(name) == '') {
			i.style.color = '#808080';
			i.value = this.hints[name];
		}
		else {
			i.style.color = '#000';
		}
	},

    resetInput:
    function(name) {
		var i = this.form[name];
		i.value = this.getValue(name);
		i.style.color = '#000';
	}
};

var FormValidation = {};

FormValidation.combineAnd = function(checks) {
	return function(formManager, name) {		
		for (var i = 0; i < checks.length; i++) {
			if (!checks[i](formManager, name)) return false;
		}
		return true;
	}
}

FormValidation.combineOr = function(checks) {
	return function(formManager, name) {		
		for (var i = 0; i < checks.length; i++) {
			if (checks[i](formManager, name)) return true;
		}
		return false;
	}
}

FormValidation.valid = function() {
	return function() {
		return true;
	}
}

FormValidation.inValid = function() {
	return function() {
		return false;
	}
}

FormValidation._validEmailAddress = function(formManager, name) {
	return /^[^@ ]+\@([^@ .]+\.)+[^@ .]+$/.test(formManager.getValue(name).strip()); 
};

FormValidation.validEmailAddress = function() {
	return FormValidation._validEmailAddress;
};

FormValidation.strippedMinLength = function(length) {
	return function(formManager, name) {
		return formManager.getValue(name).strip().length >= length;
	}
};

FormValidation.strippedMaxLength = function(length) {
	return function(formManager, name) {
		return formManager.getValue(name).strip().length <= length;
	}
};

FormValidation.matches = function(regexp) {
	return function(formManager, name) {
		return regexp.test(formManager.getValue(name));
	}
}

Form.InlineHints = function(form, hints) {
    this.form = $(form);
	this.hints = {};

    this.onFocusEL	= this.onFocus.bindAsEventListener(this);
    this.onBlurEL	= this.onBlur.bindAsEventListener(this);
    this.setInputsEL	= this.setInputs.bindAsEventListener(this);
    this.resetInputsEL	= this.resetInputs.bindAsEventListener(this)
	
	this.addHints(hints);
    Event.observe(this.form, 'reset', this.setInputsEL);
    Event.observe(this.form, 'submit', this.resetInputsEL);
};

Form.InlineHints.prototype = {
	addHints:
	function(hints) {
		for (var name in hints) {
			this.hints[name] = hints[name];
			var i = this.form[name];
			Event.observe(i, 'focus', this.onFocusEL);
			Event.observe(i, 'blur', this.onBlurEL);
		}
		this.setInputs();
	},

	removeHints:
	function(names) {
		for (var i = 0; i < names.length; i++) {
			delete(this.hints[names[i]]);
		}
	},

    onFocus:
    function(e) {
		var i = Event.element(e);
		if (this.hints[i.name]) {
			var hint = this.hints[i.name].replace(/[\r\n]/g, '');
			var value = i.value.replace(/[\r\n]/g, '');
			if (value == hint.substr(0, value.length)) {
				i.style.color = '#000';
				i.value	= '';
			}
		}
    },
	
    onBlur:
    function(e)	{
		var i = Event.element(e);
		if (i.value	== '') {
			i.style.color =	'#808080';
			i.value	= this.hints[i.name];
		}
    },
	
    setInputs:
    function() {
		for (var name in this.hints) {
			var i = this.form[name];
			var hint = this.hints[i.name].replace(/[\r\n]/g, '');
			var value = i.value.replace(/[\r\n]/g, '');
			if (value == '' || value == hint.substr(0, value.length)) {
				i.style.color = '#808080';
				i.value = this.hints[name];
			}
			else {
				i.style.color = '#000';
			}
		}
    },
	
    resetInputs:
    function() {
		for (var name in this.hints) {
			var i = this.form[name];
			var hint = this.hints[i.name].replace(/[\r\n]/g, '');
			var value = i.value.replace(/[\r\n]/g, '');
			if (value == hint.substr(0, value.length)) {
				i.style.color = '#000';
				i.value = '';
			}
		}
    }
};

function CurrencyConverter(select, amounts, currency) {
	this.select = $(select);
	this.amounts = amounts;
	this.currency = currency;
	Event.observe(this.select, 'change', this.convert.bind(this));
}

CurrencyConverter.prototype = {
	convert:
	function() {
		if (this.select.value == this.currency) {
			this.clearAmounts();
		}
		else {
			var parameters = 'op=convert_amounts&source_currency=' + this.currency + '&target_currency=' + this.select.value + '&amounts=' + this.amounts.join(' ');
			new Ajax.Request('/app/upgrade', { parameters: parameters,
															   onSuccess: this.onSuccess.bind(this),
															   onFailure: this.onFailure.bind(this) });
		}
    },

	onSuccess:
	function(transport) {
		var result;
		try {
			result = eval(transport.responseText);
		} catch(e) {}
		if (result) {
			this.setAmounts(result);
		}
		else {
			this.clearAmounts();
		}
    },

	onFailure:
	function(transport) {
		this.clearAmounts();
    },

	setAmounts:
	function(amounts) {
		for (var i = 0; i < this.amounts.length; i++) {
			$('AM_' + this.amounts[i]).innerHTML = amounts[this.amounts[i]];
		}
    },

	clearAmounts:
	function(amounts) {
		for (var i = 0; i < this.amounts.length; i++) {
			$('AM_' + this.amounts[i]).innerHTML = '';
		}
    }

}

// language_selection.js
var LanguageSelection = {
	initialize: function() {
		this.headerLanguageSelector = document.getElementById('header-language-selector');
		if (!this.headerLanguageSelector) return;
		document.body.appendChild(this.headerLanguageSelector);
		this.languageLink = document.getElementById('language-value');
		this.languageLinkMin = document.getElementById('language-value-min');
		this.languageSelectIframe = document.getElementById('language-select-iframe');
		Event.observe(this.languageLink, 'click', this.showLanguages.bindAsEventListener(this));
		Event.observe(this.languageLink, 'mouseout', this.delayedHideLanguages.bindAsEventListener(this));
		if (this.languageLinkMin) {
			Event.observe(this.languageLinkMin, 'click', this.showLanguages.bindAsEventListener(this));
			Event.observe(this.languageLinkMin, 'mouseout', this.delayedHideLanguages.bindAsEventListener(this));
		}
		Event.observe(this.headerLanguageSelector, 'mouseout', this.delayedHideLanguages.bindAsEventListener(this));
		Event.observe(this.headerLanguageSelector, 'mouseover', this.clearHideLanguages.bindAsEventListener(this));
		if (this.languageSelectIframe) {
			Element.setStyle(this.headerLanguageSelector, { visibility: 'hidden', display: '' });
			this.languageSelectIframe.style.width = this.headerLanguageSelector.offsetWidth + 'px';
			this.languageSelectIframe.style.height = this.headerLanguageSelector.offsetHeight +'px';
			Element.setStyle(this.headerLanguageSelector, { visibility: '', display: 'none' });
		}

	},

	showLanguages: function(e) {
		Event.stop(e);
		var languageLink = Event.element(e);
		languageLink.blur();
		this.clearHideLanguages();
		if (this.visible) {
			this.hideLanguages();
		}
		else {
			var leftBorder = Position.cumulativeOffset(languageLink)[0] + languageLink.offsetWidth;
			this.headerLanguageSelector.style.left = (leftBorder - 168) + 'px';
			this.headerLanguageSelector.style.top  = '20px';
			try {
				Effect.Appear(this.headerLanguageSelector, {duration:0.3});
			} catch(e) {
				Element.show(this.headerLanguageSelector);
			}
			this.visible = true;
		}
	},

	hideLanguages: function(){
		if (this.visible) {
			try {
				Effect.Fade(this.headerLanguageSelector, {duration:0.3});
			} catch(e) {
				Element.hide(this.headerLanguageSelector);
			}
			this.visible = false;
		}
	},

	delayedHideLanguages: function(e) {
		if (this.visible){
			this.clearHideLanguages();
			this.delayID = setTimeout(this.hideLanguages.bind(this), 250);
		}
	},

	clearHideLanguages: function(){
		if (this.delayID) {
			clearTimeout(this.delayID);
			this.delayID = null;
		}
	}
};

var Header = {
	toggle: function(){
		if (!this.visible){
			this.header_min = document.getElementById('header-navigation-min');
			this.header_max = document.getElementById('header-navigation-max');
			this.minimize_link = document.getElementById('minimize-link');
			this.maximize_link = document.getElementById('maximize-link');
			this.visible = this.header_min.style.display == 'none' ? this.header_max : this.header_min;
		}
		if (this.visible.id == 'header-navigation-max'){
			new Ajax.Request('/app/network',{parameters:'op=save_header_state.minimize' } );
			this.minimize_link.style.display = 'none';
			this.maximize_link.style.display = '';
			Transition.Morph(this.header_max, this.header_min, { duration: 0.5 });
			this.visible = this.header_min;
		}
		else {
			new Ajax.Request('/app/network',{parameters:'op=save_header_state.maximize' } );
			this.maximize_link.style.display = 'none';
			this.minimize_link.style.display = '';
			Transition.Morph(this.header_min, this.header_max, { duration: 0.5 });
			this.visible						= this.header_max;
		}
	}
}

Event.observe(window, 'load', LanguageSelection.initialize.bind(LanguageSelection));

var Password = {
	calculateStrength: function(passwd, stopWords) {		
		if (passwd.length == 0) return 0;
		
		stopWords = stopWords || [];

		var tmp = passwd.toLowerCase().strip();
		for (var i = 0; i < stopWords.length; i++) {
			var sw = stopWords[i].toLowerCase().strip();
			if (tmp == sw) return 0;
		}

		var score = 0
		
		if (passwd.length < 5) {
			score += 3;
		}
		else if (passwd.length < 8) {
			score += 6;
		}
		else if (passwd.length < 10) {
			score += 12;
		}
		else {
			score += 18;
		}
		
		var lowerCaseChars = (passwd != passwd.toUpperCase());
		if (lowerCaseChars) {
			score += 1;
		}

		var upperCaseChars = (passwd != passwd.toLowerCase());
		if (upperCaseChars) {
			score += 5;
		}
		
		var chars = (upperCaseChars || lowerCaseChars);
		
		var digits = (passwd.match(/\d/g) || []).length;
		if (digits > 0) {
			score += 5;
		}
		
		if (digits > 2) {
			score += 5;
		}
		
		var specialChars = (passwd.match(/[@!#$%^&*?_~]/g) || []).length;
		if (specialChars > 0) {
			score += 5;
		}
		
		if (specialChars > 1) {
			score += 5;
		}
		
		if (upperCaseChars && lowerCaseChars) {
			score += 2;
		}
		
		if (chars && digits) {
			score += 2;
		}
		
		if (chars && digits && specialChars) {
			score += 2;
		}

		return score / 50;
	}
};
// Indicator
var Indicator = {
    indicator:
    'indicator',
    
    count:
    0,
    
    increase:
    function() {
	if (Indicator.count++ == 0) {
	    if ($(Indicator.indicator)) {
		Element.setStyle(Indicator.indicator, { visibility: '' });
	    }
	    if (!Indicator.timeout) {
		Indicator.timeout = setTimeout(Indicator.checkHide, 1000);
	    }
	}
    },
    
    decrease:
    function() {
	if (--Indicator.count == 0) {
	    if (!Indicator.timeout) {
		if ($(Indicator.indicator)) {
		    Element.setStyle(Indicator.indicator, { visibility: 'hidden' });
		}
	    }
	}
    },
    
    checkHide:
    function() {
	if (Indicator.count == 0) {
	    if ($(Indicator.indicator)) {
		Element.setStyle(Indicator.indicator, { visibility: 'hidden' });
	    }
	}
	Indicator.timeout = undefined;
    }
};

// Effect Animate
Effect.Animate = Class.create();

Object.extend(Object.extend(Effect.Animate.prototype, Effect.Base.prototype), {
	initialize:
	function(elements, options) {
		this.elements = elements.map(function(e) { return $(e); });
		this.steps = this.elements.length - 1;
		var options = arguments[1] || {};
		this.start(options);
	},

		update:
	function(pos) {
		pos = pos * this.steps;
		this.elements.each(function(e,i) { var f = (1 - Math.abs(pos - i)); var o = (f >= 0) ? f : 0; Element.setOpacity(e,o); });
	}
});


// Widget constructor
function Widget(args) {
    this.id				= args['id'];
    $(this.id).style.display = 'none';

    this.currentState	= {};
    this.savedState	= {};
    this.saveStateSet	= args['saveStateSet'] || [];
    
    this.url			= args['url'] || '';
    this.uriComponent	= args['uriComponent'] || '';
}

// Widget members
Widget.prototype = {
    init:
    function(args) {
		Object.extend(this.savedState, args.nextState);
		components = [];
		var container = document.getElementById(this.id);
		for (var i = 0; i < args['components'].length; i++) {
			var component = document.getElementById(this.id + args['components'][i]);
			container.removeChild(component);
			component.id = args['components'][i];
			components.push(component);
		}
		args['components'] = components;
		this.startRequest();
		this.processResponse(args);
    },
    
    show:
    function() {
	Element.setStyle(this.id, { display: 'block' });
    },
    
    block:
    function() {
	this.blocked = true;
    },
    
    unblock:
    function() {
	this.blocked = false; 
    },
    
    startRequest:
    function() {
		if (!this.blocked) {
			this.block();
			this.requestedComponents	= [];
			this.ensured				= {};
			this.updatedComponents		= [];
			this.pushedBackUpdates		= [];
			this.uriComponents			= [], 
			this.nextState				= Object.extend({}, this.currentState);
			this.effects				= [];
			this.scripts				= [];
			
			this.duration = 0.5;
			return true;
		}
		else {
			return false;
		}
    },
    
    finishRequest:
    function() {
		this.updateComponents(this.pushedBackUpdates);
		for (var i = 0; i < this.scripts.length; i++) {
			window.setTimeout(this.scripts[i], 0);
		}
		for (var i = 0; i < this.updatedComponents.length; i++) {
			this.initComponent(this.updatedComponents[i]);
		}
		Object.extend(this.currentState, this.nextState);
		this.unblock();
    },
    
    ensureComponent:
    function(component) {
		if (!$(this.id + component)) {
			if (!this.ensured[component]) {
				this.ensured[component] = true;
				this.requestedComponents.push(component);
			}
		}
    },
    
    addActionURIComponent:
    function(uriComponent) {
		this.uriComponents.push(uriComponent);
    },
    
    addEffect:
    function(effect) {
		this.effects.push(effect);
    },
    
    doRequest:
    function(last) {
		if (this.requestedComponents.length != 0) {
			var encodedComponents = [];
			for (var i = 0; i != this.requestedComponents.length; i++) {
				encodedComponents.push(encodeURIComponent(this.requestedComponents[i]));
			}
			this.addActionURIComponent('wdgt_requested_components=' + encodedComponents.join(' '));
		}
		if (this.uriComponents.length != 0 || this.stateChanged(this.currentState, this.nextState)) {
			this.importantRequest = (this.uriComponents.length != 0);
			this.addActionURIComponent('wdgt_current_state=' + encodeURIComponent(this.serializeState(this.currentState)));
			if (!last) {
				this.addActionURIComponent('wdgt_next_state=' + encodeURIComponent(this.serializeState(this.nextState)));
			}
			this.addActionURIComponent(this.uriComponent);
			var parameters = this.uriComponents.join('&');
			Indicator.increase();
			if (last) {
				new Ajax.Request(this.url, { method: 'post', parameters: parameters });
			}
			else {	
				new Ajax.Request(this.url, { method: 'post', parameters: parameters, onSuccess: this.onSuccess.bind(this), onFailure: this.onFailure.bind(this) });
			}
		}
		else if (!last) {
			this.processResponse({ components: [], nextState: {} });
		}
    },
    
    stateChanged:
    function(stateA, stateB) {
		var changed = false;
		for (var i = 0; !changed && i < this.saveStateSet.length; i++) {
			if (stateA[this.saveStateSet[i]] != stateB[this.saveStateSet[i]]) {
				changed = true;
			}
		}		
		return changed;
    },
    
    serializeState:
    function(state) {
		var parts = [];
		for (var k in state) {
			parts.push(encodeURIComponent(k) + '=' + encodeURIComponent(state[k]));
		}
		return parts.join('&');
    },
	
    onSuccess:
    function(transport) {
		Indicator.decrease();
		var response;
		try {
			response = eval(transport.responseText);
		} catch(e) {}
		if (response) {
			Object.extend(this.savedState, response.nextState);
			response.components = response.components || [];
			var components = [];
			for (var i = 0; i < response.components.length; i += 2) {
				var scripts = response.components[i + 1].extractScripts();
				for (var j = 0; j < scripts.length; j++) {
					this.scripts.push(scripts[j]);
				}
				var component = document.createElement('div');
				component['id'] = response.components[i];
				Element.setStyle(component, { display: 'none' });
				component.innerHTML = response.components[i + 1].stripScripts();
				components.push(component);
			}
			response.components = components;
			this.processResponse(response);
		}
		else {
			this.onFailure(transport);
		}
    },

    onFailure:
    function(transport) {
		Indicator.decrease();
		if (this.importantRequest) {
			var text = transport.status + ' (' + transport.statusText + ')';
			if (transport.responseText) text += '\n' + (transport.responseText.length <= 40 ? transport.responseText : transport.responseText.substr(0, 40) + ' ...');
			alert(text);
		}
		this.unblock();
    },
    
    processResponse:
    function(response) {
		Object.extend(this.nextState, response.nextState);
		this.updateComponents(response.components || []);
		this.establishNextState();
		if (this.effects.length != 0) {
			new Effect.Parallel(this.effects, { duration: this.duration, afterFinish: this.finishRequest.bind(this) });
		}
		else {
			this.finishRequest();
		}
    },
    
    updateComponents:
    function(components) {
		for (var i = 0; i < components.length; i++) {
			this.prepareComponentUpdate(components[i]['id']);
			if (!this.isComponentVisible(components[i]['id'], this.currentState)) {
				this.updatedComponents.push(components[i]['id']);
				components[i]['id'] = this.id + components[i]['id'];
				var component = document.getElementById(components[i]['id']);
				component.parentNode.replaceChild(components[i], component);
			}
			else if (!this.isComponentVisible(components[i]['id'], this.nextState)) {
				this.pushedBackUpdates.push(components[i]);
			}
		}
		///			else {
		//				this.addEffect(Element.updateAnimated(this.id + components[i], components[i + 1], { morphX: false, sync: true }));
		//				this.updatedComponents[components[i]] = true;
		//			}
    },
    
    isComponentVisible:
    function() {
		return false;
    }
}

// LayeredWidget constructor
function LayeredWidget(args) {
	Widget.call(this, args);
}

// LayeredWidget members
Class.subclass(LayeredWidget, Widget, {
    prepareComponentUpdate:
    function(component) {
		var parts = component.split(':');
		var layerId = ':' + parts[1];
		if (!$(this.id + layerId)) {
			var layer = document.createElement('div');
			layer.id = this.id + layerId;
			Element.setStyle(layer, { display: 'none', width: '100%', left: '0', top: '0' });
			$(this.id).appendChild(layer);
		}
    },
	
	establishNextState:
    function() {
	if (!Element.visible(this.id)) {
	    Element.setStyle(this.id + ':' + this.nextState.visibleLayerId, { display: '' });
	    if (this.currentState.visibleLayerId) {
		Element.setStyle(this.id + ':' + this.currentState.visibleLayerId, { display: 'none' });
	    }
	}
	else if (this.nextState.visibleLayerId != this.currentState.visibleLayerId) {
	    Element.setStyle(this.id + ':' + this.nextState.visibleLayerId, { display: 'none' });
	    this.addEffect(Transition.Morph(this.id + ':' + this.currentState.visibleLayerId, this.id + ':' + this.nextState.visibleLayerId, { sync: true }));
	    
	}
    },
	
	isLayerVisible:
    function(layerId) {
	return (layerId == this.currentState.visibleLayerId);
    },
	
	setShow:
    function(layerId) {
	this.nextState.visibleLayerId = layerId;
    },
		
		onFailure:
    function(transport) {
		Indicator.decrease();
		if (this.importantRequest) {
			this.bsodRebootSeconds = 30;
			var bsodTI = '*** STOP: 0x000' + transport.status + ' (' + transport.statusText + ')';
			if (transport.responseText) bsodTI += '\n' + (transport.responseText.length <= 40 ? transport.responseText : transport.responseText.substr(0, 40) + ' ...');
			this.bsodTI = bsodTI.escapeHTML().replace('\n', '<br />');
			this.setBsodText();
			Transition.Morph(this.id + ':' + this.currentState.visibleLayerId, this.bsodLayer, { duration: 0.3 });
			this.bsodBootTimeout = setTimeout(this.rebootCountdown.bind(this), 1000);
		}
	},
									   
    rebootCountdown: 
    function() {
	this.bsodRebootTimeout = null;
	this.bsodRebootSeconds--;
	this.setBsodText();
	if (this.bsodRebootSeconds != 0) {
	   this.bsodRebootTimeout = setTimeout(this.rebootCountdown.bind(this), 1000);
	}
	else {
	    this.reboot();
	}
    },

    reboot:
    function() {
	if (this.bsodRebootTimeout) { 
	    clearTimeout(this.bsodRebootTimeout);
	    this.bsodRebootTimeout = null;
	}
	Transition.Morph(this.bsodLayer, this.id + ':' + this.currentState.visibleLayerId, { duration: 0.3 });
	this.unblock();
    },

	setBsodText:
    function() {
	if (!this.bsodLayer) {
	    this.bsodLayer = document.createElement('div');
	    Element.setStyle(this.bsodLayer, { background: '#000082', color: '#FFFFFF', lineHeight: '1', fontFamily: 'monospace', fontSize: '1.0em', display: 'none' });
	    $(this.id).appendChild(this.bsodLayer);
	    Event.observe(this.bsodLayer, 'click', this.reboot.bind(this));
	}
	this.bsodLayer.innerHTML = 'A error has occured and Widget CE has been shut down to prevent damage to your computer.<br />If you will try to restart this widget, click on this text.<br />If you will try to restart your computer, press Ctrl+Alt+Delete.<br /><br />Technical information:<br /><br />' + this.bsodTI + '<br /><br /><br />The widget will restart automatically<br />after ' + this.bsodRebootSeconds + ' seconds.<br /><br /><br /><br /><br /><br /><br /><br />';
    }
    
    
});

// ExpanderWidget constructor
function ExpanderWidget(args) {
	LayeredWidget.call(this, args);
}

// ExpanderWidget members
Class.subclass(ExpanderWidget, LayeredWidget, {
    prepareComponentUpdate:
    function(component) {
		LayeredWidget.prototype.prepareComponentUpdate.call(this, component);
		
		if (!$(this.id + component)) {
			var parts = component.split(':');
			var layerId = parts[1];
			var layer = $(this.id + ':' + layerId);
			
			var div = document.createElement('div');
			div.id = this.id + component;
			Element.setStyle(div, { display: 'none', width: '100%' });
			layer.appendChild(div);
		}
    },
		
	isComponentVisible:
    function(component, state) {
	return state.visibleLayerId && state.visibleLayerId == component.slice(1, state.visibleLayerId.length + 1) && (state.expanded || component.slice(-4) == 'head');
    },
	
	establishNextState:
    function() {
	if (this.nextState.expanded) {
	    var arrow = $(this.id + ':' + this.nextState.visibleLayerId + ':head:arrow');
	    if (arrow) arrow.src = '/img/xing/btn_down.gif';
	    Element.addClassName(this.id, 'selected');
	}
	if (!Element.visible(this.id)) {
	    Element.setStyle(this.id + ':' + this.nextState.visibleLayerId + ':head', { display: '' });
	    if (this.nextState.expanded) {
		if (!this.currentState.expanded) {
		    this.setupComponent(':' + this.nextState.visibleLayerId + ':body');
		}
		Element.setStyle(this.id + ':' + this.nextState.visibleLayerId + ':body', { display: '' });
	    }
	    else if ($(this.id + ':' + this.nextState.visibleLayerId + ':body')) {
		Element.setStyle(this.id + ':' + this.nextState.visibleLayerId + ':body', { display: 'none' });
	    }
	}
	else if (this.currentState.visibleLayerId == this.nextState.visibleLayerId) {
	    if (this.nextState.expanded && !this.currentState.expanded) {
	this.setupComponent(':' + this.nextState.visibleLayerId + ':body');
		this.addEffect(Effect.BlindDown(this.id + ':' + this.nextState.visibleLayerId + ':body', { sync: true }));
		if (!UserAgent.MSIE) this.addEffect(new Effect.Opacity(this.id + ':' + this.nextState.visibleLayerId + ':body', { from: 0.0, to: 1.0, sync: true }));
	    }
	    else if (!this.nextState.expanded && this.currentState.expanded) {
		this.addEffect(Effect.BlindUp(this.id + ':' + this.nextState.visibleLayerId + ':body', { sync: true }));
		if (!UserAgent.MSIE) this.addEffect(new Effect.Opacity(this.id + ':' + this.nextState.visibleLayerId + ':body', { from: 1.0, to: 0.0, sync: true }));
	    }
	}
	else {
	    Element.setStyle(this.id + ':' + this.nextState.visibleLayerId + ':head', { display: '' });
	    if (this.nextState.expanded) {
		this.setupComponent(':' + this.nextState.visibleLayerId + ':body');
		Element.setStyle(this.id + ':' + this.nextState.visibleLayerId + ':body', { display: '' });
	    }
	    else if ($(this.id + ':' + this.nextState.visibleLayerId + ':body')) {
		Element.setStyle(this.id + ':' + this.nextState.visibleLayerId + ':body', { display: 'none' });
	    }
	}
	
	LayeredWidget.prototype.establishNextState.call(this);
    },

	finishRequest:
    function() {
	LayeredWidget.prototype.finishRequest.call(this);
	if (!this.currentState.expanded) {
	    var arrow = $(this.id + ':' + this.nextState.visibleLayerId + ':head:arrow');
	    if (arrow) arrow.src = '/img/xing/btn_up.gif';
	    Element.removeClassName(this.id, 'selected');
	}
    },
	
	setShow:
    function(layerId, expanded) {
	LayeredWidget.prototype.setShow.call(this, layerId);
	
	this.nextState.expanded = expanded ? 1 : 0;
	this.ensureComponent(':' + layerId + ':head');
	if (expanded) this.ensureComponent(':' + layerId + ':body');
    },
	
	initComponent:
    function(component) {
	var element = $(this.id + component);
	
	var head = (component.slice(-4) == 'head');
	var as = element.getElementsByTagName('a');
	
	var noLinks = as.length == 0;
	if (head) {
	    for (var i = 0; i != as.length; i++) {
		if (as[i].name) {
		    noLinks = false;
		    Event.observe(as[i], 'click', this.toggle.bindAsEventListener(this, as[i]));
		}
	    }
	}
	else {
	    for (var i = 0; i != as.length; i++) {
		if (as[i].name) {
		    Event.observe(as[i], 'click', this.link.bindAsEventListener(this, as[i]));
		}
	    }
	}	    
	if (head && noLinks) {
	    Element.setStyle(element, { cursor: 'pointer' });
	    Event.observe(element, 'click', this.toggle.bindAsEventListener(this));
	}
    },
	
	setupComponent:
    function(component) {
    },

	toggle:
    function(event) {
	var element = Event.element(event);
	if (element.blur) element.blur();
	Event.stop(event);
	if (this.startRequest()) {
	    if (event.shiftKey) this.duration = 5;
	    this.setShow(this.currentState.visibleLayerId, !this.currentState.expanded);
	    this.doRequest();
	}
    },
	
	link:
    function(event, element) {
	var element = Event.element(event);
	if (element.blur) element.blur();
	Event.stop(event);
	if (this.startRequest()) {
	    if (event.shiftKey) this.duration = 5;
	    var parts = element.name.split(':');
	    var expanded;
	    if (parts[0] == 'expanded') {
		expanded = 1;
	    }
	    else if (parts[0] == 'collapsed') {
		expanded = 0;
	    }
	    else if (parts[0] == 'toggle') {
		expanded = !this.currentState.expanded;
	    }
	    var layerId = parts[1] || this.currentState.visibleLayerId;
	    this.setShow(parts[1], expanded);
	    this.doRequest();
	}
    }
});

// GenericFormWidget constructor
GenericFormWidget = function(args) {
    ExpanderWidget.call(this, args);
    this.submitViaAjax = args['submitViaAjax'];
    this.closeOnSubmit = args['closeOnSubmit'];
    this.resetOnExpand = args['resetOnExpand'];
};


// GenericFormWidget members
Class.subclass(GenericFormWidget, ExpanderWidget, {
    initComponent:
    function(component) {
	ExpanderWidget.prototype.initComponent.call(this, component);
	var head = (component.slice(-4) == 'head');
	if (!head) {
	    var forms = $(this.id + component).getElementsByTagName('form');
	    if (forms.length != 0) {
		var elements = Form.getElements(forms[0]);
		for (var i = 0; i < elements.length; i++) {
		    if (elements[i].type == 'submit') {
			if (elements[i].name.slice(0, 6) == 'cancel') {
			    Event.observe(elements[i], 'click', this.cancel.bindAsEventListener(this, elements[i]));
			}
			else {
			    Event.observe(elements[i], 'click', this.submit.bindAsEventListener(this, elements[i]));
			}
		    }
		}
	    }
	}
    },
	
	setupComponent:
    function(component) {
		if (this.resetOnExpand) {
			var head = (component.slice(-4) == 'head');
			if (!head) {
				var forms = $(this.id + component).getElementsByTagName('form');
				if (forms.length != 0) {
					forms[0].reset();
				}
			}
		}
    },
	
	toggle:
    function(event) {
	var element = Event.element(event);
	if (element.blur) element.blur();
	Event.stop(event);
	if (this.startRequest()) {
	    if (event.shiftKey) this.duration = 5;
	    var layerId;
	    var expanded;
	    if (this.currentState.expanded) {
		var forms = $(this.id + ':' + this.currentState.visibleLayerId + ':body').getElementsByTagName('form');
		if (forms.length != 0) {
		    var inputs = Form.getElements(forms[0]);
		    for (var i = 0; i < inputs.length; i++) {
			if (inputs[i].type == 'submit' && inputs[i].name && inputs[i].name.slice(0, 6) == 'cancel') {
			    layerId = inputs[i].name.slice(7);
			    break;
			}
		    }
		}
		expanded = 0;
	    }
	    else {
		expanded = 1;
	    }
	    this.setShow(layerId || this.currentState.visibleLayerId, expanded);
	    this.doRequest();
	}
    },
	
	cancel:
    function(event, element) {
	Event.stop(event);
	if (this.startRequest()) {
	    if (event.shiftKey) this.duration = 5;
	    this.setShow(element.name.slice(7) || this.currentState.visibleLayerId, 0);
	    this.doRequest();
	}
    },
	
	submit:
    function(event, element) {
	if (this.submitViaAjax) {
	    Event.stop(event);
	}
	if (this.startRequest()) {
	    if (event.shiftKey) this.duration = 5;
	    if (this.submitViaAjax) this.addActionURIComponent(Form.serialize(element.form, element));
	    if (this.closeOnSubmit) this.setShow(this.currentState.visibleLayerId, 0);
	    this.doRequest();
	}
    }
});
// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
//           (c) 2005 Sammi Williams (http://www.oriontransfer.co.nz, sammi@oriontransfer.co.nz)
// 
// See scriptaculous.js for full license.

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

var Droppables = {
  drops: [],

  remove: function(element) {
    this.drops = this.drops.reject(function(d) { return d.element==$(element) });
  },

  add: function(element) {
    element = $(element);
    var options = Object.extend({
      greedy:     true,
      hoverclass: null,
      tree:       false
    }, arguments[1] || {});

    // cache containers
    if(options.containment) {
      options._containers = [];
      var containment = options.containment;
      if((typeof containment == 'object') && 
        (containment.constructor == Array)) {
        containment.each( function(c) { options._containers.push($(c)) });
      } else {
        options._containers.push($(containment));
      }
    }
    
    if(options.accept) options.accept = [options.accept].flatten();

    Element.makePositioned(element); // fix IE
    options.element = element;

    this.drops.push(options);
  },
  
  findDeepestChild: function(drops) {
    deepest = drops[0];
      
    for (i = 1; i < drops.length; ++i)
      if (Element.isParent(drops[i].element, deepest.element))
        deepest = drops[i];
    
    return deepest;
  },

  isContained: function(element, drop) {
    var containmentNode;
    if(drop.tree) {
      containmentNode = element.treeNode; 
    } else {
      containmentNode = element.parentNode;
    }
    return drop._containers.detect(function(c) { return containmentNode == c });
  },
  
  isAffected: function(point, element, drop) {
    return (
      (drop.element!=element) &&
      ((!drop._containers) ||
        this.isContained(element, drop)) &&
      ((!drop.accept) ||
        (Element.classNames(element).detect( 
          function(v) { return drop.accept.include(v) } ) )) &&
      Position.within(drop.element, point[0], point[1]) );
  },

  deactivate: function(drop) {
    if(drop.hoverclass)
      Element.removeClassName(drop.element, drop.hoverclass);
    this.last_active = null;
  },

  activate: function(drop) {
    if(drop.hoverclass)
      Element.addClassName(drop.element, drop.hoverclass);
    this.last_active = drop;
  },

  show: function(point, element) {
    if(!this.drops.length) return;
    var affected = [];
    
    if(this.last_active) this.deactivate(this.last_active);
    this.drops.each( function(drop) {
      if(Droppables.isAffected(point, element, drop))
        affected.push(drop);
    });
        
    if(affected.length>0) {
      drop = Droppables.findDeepestChild(affected);
      Position.within(drop.element, point[0], point[1]);
      if(drop.onHover)
        drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
      
      Droppables.activate(drop);
    }
  },

  fire: function(event, element) {
    if(!this.last_active) return;
    Position.prepare();

    if (this.isAffected([Event.pointerX(event), Event.pointerY(event)], element, this.last_active))
      if (this.last_active.onDrop) 
        this.last_active.onDrop(element, this.last_active.element, event);
  },

  reset: function() {
    if(this.last_active)
      this.deactivate(this.last_active);
  }
}

var Draggables = {
  drags: [],
  observers: [],
  
  register: function(draggable) {
    if(this.drags.length == 0) {
      this.eventMouseUp   = this.endDrag.bindAsEventListener(this);
      this.eventMouseMove = this.updateDrag.bindAsEventListener(this);
      this.eventKeypress  = this.keyPress.bindAsEventListener(this);
      
      Event.observe(document, "mouseup", this.eventMouseUp);
      Event.observe(document, "mousemove", this.eventMouseMove);
      Event.observe(document, "keypress", this.eventKeypress);
    }
    this.drags.push(draggable);
  },
  
  unregister: function(draggable) {
    this.drags = this.drags.reject(function(d) { return d==draggable });
    if(this.drags.length == 0) {
      Event.stopObserving(document, "mouseup", this.eventMouseUp);
      Event.stopObserving(document, "mousemove", this.eventMouseMove);
      Event.stopObserving(document, "keypress", this.eventKeypress);
    }
  },
  
  activate: function(draggable) {
    window.focus(); // allows keypress events if window isn't currently focused, fails for Safari
    this.activeDraggable = draggable;
  },
  
  deactivate: function() {
    this.activeDraggable = null;
  },
  
  updateDrag: function(event) {
    if(!this.activeDraggable) return;
    var pointer = [Event.pointerX(event), Event.pointerY(event)];
    // Mozilla-based browsers fire successive mousemove events with
    // the same coordinates, prevent needless redrawing (moz bug?)
    if(this._lastPointer && (this._lastPointer.inspect() == pointer.inspect())) return;
    this._lastPointer = pointer;
    this.activeDraggable.updateDrag(event, pointer);
  },
  
  endDrag: function(event) {
    if(!this.activeDraggable) return;
    this._lastPointer = null;
    this.activeDraggable.endDrag(event);
    this.activeDraggable = null;
  },
  
  keyPress: function(event) {
    if(this.activeDraggable)
      this.activeDraggable.keyPress(event);
  },
  
  addObserver: function(observer) {
    this.observers.push(observer);
    this._cacheObserverCallbacks();
  },
  
  removeObserver: function(element) {  // element instead of observer fixes mem leaks
    this.observers = this.observers.reject( function(o) { return o.element==element });
    this._cacheObserverCallbacks();
  },
  
  notify: function(eventName, draggable, event) {  // 'onStart', 'onEnd', 'onDrag'
    if(this[eventName+'Count'] > 0)
      this.observers.each( function(o) {
        if(o[eventName]) o[eventName](eventName, draggable, event);
      });
  },
  
  _cacheObserverCallbacks: function() {
    ['onStart','onEnd','onDrag'].each( function(eventName) {
      Draggables[eventName+'Count'] = Draggables.observers.select(
        function(o) { return o[eventName]; }
      ).length;
    });
  }
}

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

var Draggable = Class.create();
Draggable.prototype = {
  initialize: function(element) {
    var options = Object.extend({
      handle: false,
      starteffect: function(element) {
        element._opacity = Element.getOpacity(element); 
        new Effect.Opacity(element, {duration:0.2, from:element._opacity, to:0.7}); 
      },
      reverteffect: function(element, top_offset, left_offset) {
        var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
        element._revert = new Effect.Move(element, { x: -left_offset, y: -top_offset, duration: dur});
      },
      endeffect: function(element) {
        var toOpacity = typeof element._opacity == 'number' ? element._opacity : 1.0
        new Effect.Opacity(element, {duration:0.2, from:0.7, to:toOpacity}); 
      },
      zindex: 1000,
      revert: false,
      scroll: false,
      scrollSensitivity: 20,
      scrollSpeed: 15,
      snap: false   // false, or xy or [x,y] or function(x,y){ return [x,y] }
    }, arguments[1] || {});

    this.element = $(element);
    
    if(options.handle && (typeof options.handle == 'string')) {
      var h = Element.childrenWithClassName(this.element, options.handle, true);
      if(h.length>0) this.handle = h[0];
    }
    if(!this.handle) this.handle = $(options.handle);
    if(!this.handle) this.handle = this.element;
    
    if(options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML)
      options.scroll = $(options.scroll);

    Element.makePositioned(this.element); // fix IE    

    this.delta    = this.currentDelta();
    this.options  = options;
    this.dragging = false;   

    this.eventMouseDown = this.initDrag.bindAsEventListener(this);
    Event.observe(this.handle, "mousedown", this.eventMouseDown);
    
    Draggables.register(this);
  },
  
  destroy: function() {
    Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
    Draggables.unregister(this);
  },
  
  currentDelta: function() {
    return([
      parseInt(Element.getStyle(this.element,'left') || '0'),
      parseInt(Element.getStyle(this.element,'top') || '0')]);
  },
  
  initDrag: function(event) {
    if(Event.isLeftClick(event)) {    
      // abort on form elements, fixes a Firefox issue
      var src = Event.element(event);
      if(src.tagName && (
        src.tagName=='INPUT' ||
        src.tagName=='SELECT' ||
        src.tagName=='OPTION' ||
        src.tagName=='BUTTON' ||
        src.tagName=='TEXTAREA')) return;
        
      if(this.element._revert) {
        this.element._revert.cancel();
        this.element._revert = null;
      }
      
      var pointer = [Event.pointerX(event), Event.pointerY(event)];
      var pos     = Position.cumulativeOffset(this.element);
      this.offset = [0,1].map( function(i) { return (pointer[i] - pos[i]) });
      
      Draggables.activate(this);
      Event.stop(event);
    }
  },
  
  startDrag: function(event) {
    this.dragging = true;
    
    if(this.options.zindex) {
      this.originalZ = parseInt(Element.getStyle(this.element,'z-index') || 0);
      this.element.style.zIndex = this.options.zindex;
    }
    
    if(this.options.ghosting) {
      this._clone = this.element.cloneNode(true);
      Position.absolutize(this.element);
      this.element.parentNode.insertBefore(this._clone, this.element);
    }
    
    if(this.options.scroll) {
      if (this.options.scroll == window) {
        var where = this._getWindowScroll(this.options.scroll);
        this.originalScrollLeft = where.left;
        this.originalScrollTop = where.top;
      } else {
        this.originalScrollLeft = this.options.scroll.scrollLeft;
        this.originalScrollTop = this.options.scroll.scrollTop;
      }
    }
    
    Draggables.notify('onStart', this, event);
    if(this.options.starteffect) this.options.starteffect(this.element);
  },
  
  updateDrag: function(event, pointer) {
    if(!this.dragging) this.startDrag(event);
    Position.prepare();
    Droppables.show(pointer, this.element);
    Draggables.notify('onDrag', this, event);
    this.draw(pointer);
    if(this.options.change) this.options.change(this);
    
    if(this.options.scroll) {
      this.stopScrolling();
      
      var p;
      if (this.options.scroll == window) {
        with(this._getWindowScroll(this.options.scroll)) { p = [ left, top, left+width, top+height ]; }
      } else {
        p = Position.page(this.options.scroll);
        p[0] += this.options.scroll.scrollLeft;
        p[1] += this.options.scroll.scrollTop;
        p.push(p[0]+this.options.scroll.offsetWidth);
        p.push(p[1]+this.options.scroll.offsetHeight);
      }
      var speed = [0,0];
      if(pointer[0] < (p[0]+this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[0]+this.options.scrollSensitivity);
      if(pointer[1] < (p[1]+this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[1]+this.options.scrollSensitivity);
      if(pointer[0] > (p[2]-this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[2]-this.options.scrollSensitivity);
      if(pointer[1] > (p[3]-this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[3]-this.options.scrollSensitivity);
      this.startScrolling(speed);
    }
    
    // fix AppleWebKit rendering
    if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
    
    Event.stop(event);
  },
  
  finishDrag: function(event, success) {
    this.dragging = false;

    if(this.options.ghosting) {
      Position.relativize(this.element);
      Element.remove(this._clone);
      this._clone = null;
    }

    if(success) Droppables.fire(event, this.element);
    Draggables.notify('onEnd', this, event);

    var revert = this.options.revert;
    if(revert && typeof revert == 'function') revert = revert(this.element);
    
    var d = this.currentDelta();
    if(revert && this.options.reverteffect) {
      this.options.reverteffect(this.element, 
        d[1]-this.delta[1], d[0]-this.delta[0]);
    } else {
      this.delta = d;
    }

    if(this.options.zindex)
      this.element.style.zIndex = this.originalZ;

    if(this.options.endeffect) 
      this.options.endeffect(this.element);

    Draggables.deactivate(this);
    Droppables.reset();
  },
  
  keyPress: function(event) {
    if(event.keyCode!=Event.KEY_ESC) return;
    this.finishDrag(event, false);
    Event.stop(event);
  },
  
  endDrag: function(event) {
    if(!this.dragging) return;
    this.stopScrolling();
    this.finishDrag(event, true);
    Event.stop(event);
  },
  
  draw: function(point) {
    var pos = Position.cumulativeOffset(this.element);
    var d = this.currentDelta();
    pos[0] -= d[0]; pos[1] -= d[1];
    
    if(this.options.scroll && (this.options.scroll != window)) {
      pos[0] -= this.options.scroll.scrollLeft-this.originalScrollLeft;
      pos[1] -= this.options.scroll.scrollTop-this.originalScrollTop;
    }
    
    var p = [0,1].map(function(i){ 
      return (point[i]-pos[i]-this.offset[i]) 
    }.bind(this));
    
    if(this.options.snap) {
      if(typeof this.options.snap == 'function') {
        p = this.options.snap(p[0],p[1],this);
      } else {
      if(this.options.snap instanceof Array) {
        p = p.map( function(v, i) {
          return Math.round(v/this.options.snap[i])*this.options.snap[i] }.bind(this))
      } else {
        p = p.map( function(v) {
          return Math.round(v/this.options.snap)*this.options.snap }.bind(this))
      }
    }}
    
    var style = this.element.style;
    if((!this.options.constraint) || (this.options.constraint=='horizontal'))
      style.left = p[0] + "px";
    if((!this.options.constraint) || (this.options.constraint=='vertical'))
      style.top  = p[1] + "px";
    if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering
  },
  
  stopScrolling: function() {
    if(this.scrollInterval) {
      clearInterval(this.scrollInterval);
      this.scrollInterval = null;
      Draggables._lastScrollPointer = null;
    }
  },
  
  startScrolling: function(speed) {
    this.scrollSpeed = [speed[0]*this.options.scrollSpeed,speed[1]*this.options.scrollSpeed];
    this.lastScrolled = new Date();
    this.scrollInterval = setInterval(this.scroll.bind(this), 10);
  },
  
  scroll: function() {
    var current = new Date();
    var delta = current - this.lastScrolled;
    this.lastScrolled = current;
    if(this.options.scroll == window) {
      with (this._getWindowScroll(this.options.scroll)) {
        if (this.scrollSpeed[0] || this.scrollSpeed[1]) {
          var d = delta / 1000;
          this.options.scroll.scrollTo( left + d*this.scrollSpeed[0], top + d*this.scrollSpeed[1] );
        }
      }
    } else {
      this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
      this.options.scroll.scrollTop  += this.scrollSpeed[1] * delta / 1000;
    }
    
    Position.prepare();
    Droppables.show(Draggables._lastPointer, this.element);
    Draggables.notify('onDrag', this);
    Draggables._lastScrollPointer = Draggables._lastScrollPointer || $A(Draggables._lastPointer);
    Draggables._lastScrollPointer[0] += this.scrollSpeed[0] * delta / 1000;
    Draggables._lastScrollPointer[1] += this.scrollSpeed[1] * delta / 1000;
    if (Draggables._lastScrollPointer[0] < 0)
      Draggables._lastScrollPointer[0] = 0;
    if (Draggables._lastScrollPointer[1] < 0)
      Draggables._lastScrollPointer[1] = 0;
    this.draw(Draggables._lastScrollPointer);
    
    if(this.options.change) this.options.change(this);
  },
  
  _getWindowScroll: function(w) {
    var T, L, W, H;
    with (w.document) {
      if (w.document.documentElement && documentElement.scrollTop) {
        T = documentElement.scrollTop;
        L = documentElement.scrollLeft;
      } else if (w.document.body) {
        T = body.scrollTop;
        L = body.scrollLeft;
      }
      if (w.innerWidth) {
        W = w.innerWidth;
        H = w.innerHeight;
      } else if (w.document.documentElement && documentElement.clientWidth) {
        W = documentElement.clientWidth;
        H = documentElement.clientHeight;
      } else {
        W = body.offsetWidth;
        H = body.offsetHeight
      }
    }
    return { top: T, left: L, width: W, height: H };
  }
}

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

var SortableObserver = Class.create();
SortableObserver.prototype = {
  initialize: function(element, observer) {
    this.element   = $(element);
    this.observer  = observer;
    this.lastValue = Sortable.serialize(this.element);
  },
  
  onStart: function() {
    this.lastValue = Sortable.serialize(this.element);
  },
  
  onEnd: function() {
    Sortable.unmark();
    if(this.lastValue != Sortable.serialize(this.element))
      this.observer(this.element)
  }
}

var Sortable = {
  sortables: {},
  
  _findRootElement: function(element) {
    while (element.tagName != "BODY") {  
      if(element.id && Sortable.sortables[element.id]) return element;
      element = element.parentNode;
    }
  },

  options: function(element) {
    element = Sortable._findRootElement($(element));
    if(!element) return;
    return Sortable.sortables[element.id];
  },
  
  destroy: function(element){
    var s = Sortable.options(element);
    
    if(s) {
      Draggables.removeObserver(s.element);
      s.droppables.each(function(d){ Droppables.remove(d) });
      s.draggables.invoke('destroy');
      
      delete Sortable.sortables[s.element.id];
    }
  },

  create: function(element) {
    element = $(element);
    var options = Object.extend({ 
      element:     element,
      tag:         'li',       // assumes li children, override with tag: 'tagname'
      dropOnEmpty: false,
      tree:        false,
      treeTag:     'ul',
      overlap:     'vertical', // one of 'vertical', 'horizontal'
      constraint:  'vertical', // one of 'vertical', 'horizontal', false
      containment: element,    // also takes array of elements (or id's); or false
      handle:      false,      // or a CSS class
      only:        false,
      hoverclass:  null,
      ghosting:    false,
      scroll:      false,
      scrollSensitivity: 20,
      scrollSpeed: 15,
      format:      /^[^_]*_(.*)$/,
      onChange:    Prototype.emptyFunction,
      onUpdate:    Prototype.emptyFunction
    }, arguments[1] || {});

    // clear any old sortable with same element
    this.destroy(element);

    // build options for the draggables
    var options_for_draggable = {
      revert:      true,
      scroll:      options.scroll,
      scrollSpeed: options.scrollSpeed,
      scrollSensitivity: options.scrollSensitivity,
      ghosting:    options.ghosting,
      constraint:  options.constraint,
      handle:      options.handle };

    if(options.starteffect)
      options_for_draggable.starteffect = options.starteffect;

    if(options.reverteffect)
      options_for_draggable.reverteffect = options.reverteffect;
    else
      if(options.ghosting) options_for_draggable.reverteffect = function(element) {
        element.style.top  = 0;
        element.style.left = 0;
      };

    if(options.endeffect)
      options_for_draggable.endeffect = options.endeffect;

    if(options.zindex)
      options_for_draggable.zindex = options.zindex;

    // build options for the droppables  
    var options_for_droppable = {
      overlap:     options.overlap,
      containment: options.containment,
      tree:        options.tree,
      hoverclass:  options.hoverclass,
      onHover:     Sortable.onHover
      //greedy:      !options.dropOnEmpty
    }
    
    var options_for_tree = {
      onHover:      Sortable.onEmptyHover,
      overlap:      options.overlap,
      containment:  options.containment,
      hoverclass:   options.hoverclass
    }

    // fix for gecko engine
    Element.cleanWhitespace(element); 

    options.draggables = [];
    options.droppables = [];

    // drop on empty handling
    if(options.dropOnEmpty || options.tree) {
      Droppables.add(element, options_for_tree);
      options.droppables.push(element);
    }

    (this.findElements(element, options) || []).each( function(e) {
      // handles are per-draggable
      var handle = options.handle ? 
        Element.childrenWithClassName(e, options.handle)[0] : e;    
      options.draggables.push(
        new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));
      Droppables.add(e, options_for_droppable);
      if(options.tree) e.treeNode = element;
      options.droppables.push(e);      
    });
    
    if(options.tree) {
      (Sortable.findTreeElements(element, options) || []).each( function(e) {
        Droppables.add(e, options_for_tree);
        e.treeNode = element;
        options.droppables.push(e);
      });
    }

    // keep reference
    this.sortables[element.id] = options;

    // for onupdate
    Draggables.addObserver(new SortableObserver(element, options.onUpdate));

  },

  // return all suitable-for-sortable elements in a guaranteed order
  findElements: function(element, options) {
    return Element.findChildren(
      element, options.only, options.tree ? true : false, options.tag);
  },
  
  findTreeElements: function(element, options) {
    return Element.findChildren(
      element, options.only, options.tree ? true : false, options.treeTag);
  },

  onHover: function(element, dropon, overlap) {
    if(Element.isParent(dropon, element)) return;

    if(overlap > .33 && overlap < .66 && Sortable.options(dropon).tree) {
      return;
    } else if(overlap>0.5) {
      Sortable.mark(dropon, 'before');
      if(dropon.previousSibling != element) {
        var oldParentNode = element.parentNode;
        element.style.visibility = "hidden"; // fix gecko rendering
        dropon.parentNode.insertBefore(element, dropon);
        if(dropon.parentNode!=oldParentNode) 
          Sortable.options(oldParentNode).onChange(element);
        Sortable.options(dropon.parentNode).onChange(element);
      }
    } else {
      Sortable.mark(dropon, 'after');
      var nextElement = dropon.nextSibling || null;
      if(nextElement != element) {
        var oldParentNode = element.parentNode;
        element.style.visibility = "hidden"; // fix gecko rendering
        dropon.parentNode.insertBefore(element, nextElement);
        if(dropon.parentNode!=oldParentNode) 
          Sortable.options(oldParentNode).onChange(element);
        Sortable.options(dropon.parentNode).onChange(element);
      }
    }
  },
  
  onEmptyHover: function(element, dropon, overlap) {
    var oldParentNode = element.parentNode;
    var droponOptions = Sortable.options(dropon);
        
    if(!Element.isParent(dropon, element)) {
      var index;
      
      var children = Sortable.findElements(dropon, {tag: droponOptions.tag});
      var child = null;
            
      if(children) {
        var offset = Element.offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);
        
        for (index = 0; index < children.length; index += 1) {
          if (offset - Element.offsetSize (children[index], droponOptions.overlap) >= 0) {
            offset -= Element.offsetSize (children[index], droponOptions.overlap);
          } else if (offset - (Element.offsetSize (children[index], droponOptions.overlap) / 2) >= 0) {
            child = index + 1 < children.length ? children[index + 1] : null;
            break;
          } else {
            child = children[index];
            break;
          }
        }
      }
      
      dropon.insertBefore(element, child);
      
      Sortable.options(oldParentNode).onChange(element);
      droponOptions.onChange(element);
    }
  },

  unmark: function() {
    if(Sortable._marker) Element.hide(Sortable._marker);
  },

  mark: function(dropon, position) {
    // mark on ghosting only
    var sortable = Sortable.options(dropon.parentNode);
    if(sortable && !sortable.ghosting) return; 

    if(!Sortable._marker) {
      Sortable._marker = $('dropmarker') || document.createElement('DIV');
      Element.hide(Sortable._marker);
      Element.addClassName(Sortable._marker, 'dropmarker');
      Sortable._marker.style.position = 'absolute';
      document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
    }    
    var offsets = Position.cumulativeOffset(dropon);
    Sortable._marker.style.left = offsets[0] + 'px';
    Sortable._marker.style.top = offsets[1] + 'px';
    
    if(position=='after')
      if(sortable.overlap == 'horizontal') 
        Sortable._marker.style.left = (offsets[0]+dropon.clientWidth) + 'px';
      else
        Sortable._marker.style.top = (offsets[1]+dropon.clientHeight) + 'px';
    
    Element.show(Sortable._marker);
  },
  
  _tree: function(element, options, parent) {
    var children = Sortable.findElements(element, options) || [];
  
    for (var i = 0; i < children.length; ++i) {
      var match = children[i].id.match(options.format);

      if (!match) continue;
      
      var child = {
        id: encodeURIComponent(match ? match[1] : null),
        element: element,
        parent: parent,
        children: new Array,
        position: parent.children.length,
        container: Sortable._findChildrenElement(children[i], options.treeTag.toUpperCase())
      }
      
      /* Get the element containing the children and recurse over it */
      if (child.container)
        this._tree(child.container, options, child)
      
      parent.children.push (child);
    }

    return parent; 
  },

  /* Finds the first element of the given tag type within a parent element.
    Used for finding the first LI[ST] within a L[IST]I[TEM].*/
  _findChildrenElement: function (element, containerTag) {
    if (element && element.hasChildNodes)
      for (var i = 0; i < element.childNodes.length; ++i)
        if (element.childNodes[i].tagName == containerTag)
          return element.childNodes[i];
  
    return null;
  },

  tree: function(element) {
    element = $(element);
    var sortableOptions = this.options(element);
    var options = Object.extend({
      tag: sortableOptions.tag,
      treeTag: sortableOptions.treeTag,
      only: sortableOptions.only,
      name: element.id,
      format: sortableOptions.format
    }, arguments[1] || {});
    
    var root = {
      id: null,
      parent: null,
      children: new Array,
      container: element,
      position: 0
    }
    
    return Sortable._tree (element, options, root);
  },

  /* Construct a [i] index for a particular node */
  _constructIndex: function(node) {
    var index = '';
    do {
      if (node.id) index = '[' + node.position + ']' + index;
    } while ((node = node.parent) != null);
    return index;
  },

  sequence: function(element) {
    element = $(element);
    var options = Object.extend(this.options(element), arguments[1] || {});
    
    return $(this.findElements(element, options) || []).map( function(item) {
      return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
    });
  },

  setSequence: function(element, new_sequence) {
    element = $(element);
    var options = Object.extend(this.options(element), arguments[2] || {});
    
    var nodeMap = {};
    this.findElements(element, options).each( function(n) {
        if (n.id.match(options.format))
            nodeMap[n.id.match(options.format)[1]] = [n, n.parentNode];
        n.parentNode.removeChild(n);
    });
   
    new_sequence.each(function(ident) {
      var n = nodeMap[ident];
      if (n) {
        n[1].appendChild(n[0]);
        delete nodeMap[ident];
      }
    });
  },
  
  serialize: function(element) {
    element = $(element);
    var options = Object.extend(Sortable.options(element), arguments[1] || {});
    var name = encodeURIComponent(
      (arguments[1] && arguments[1].name) ? arguments[1].name : element.id);
    
    if (options.tree) {
      return Sortable.tree(element, arguments[1]).children.map( function (item) {
        return [name + Sortable._constructIndex(item) + "=" + 
                encodeURIComponent(item.id)].concat(item.children.map(arguments.callee));
      }).flatten().join('&');
    } else {
      return Sortable.sequence(element, arguments[1]).map( function(item) {
        return name + "[]=" + encodeURIComponent(item);
      }).join('&');
    }
  }
}

/* Returns true if child is contained within element */
Element.isParent = function(child, element) {
  if (!child.parentNode || child == element) return false;

  if (child.parentNode == element) return true;

  return Element.isParent(child.parentNode, element);
}

Element.findChildren = function(element, only, recursive, tagName) {    
  if(!element.hasChildNodes()) return null;
  tagName = tagName.toUpperCase();
  if(only) only = [only].flatten();
  var elements = [];
  $A(element.childNodes).each( function(e) {
    if(e.tagName && e.tagName.toUpperCase()==tagName &&
      (!only || (Element.classNames(e).detect(function(v) { return only.include(v) }))))
        elements.push(e);
    if(recursive) {
      var grandchildren = Element.findChildren(e, only, recursive, tagName);
      if(grandchildren) elements.push(grandchildren);
    }
  });

  return (elements.length>0 ? elements.flatten() : []);
}

Element.offsetSize = function (element, type) {
  if (type == 'vertical' || type == 'height')
    return element.offsetHeight;
  else
    return element.offsetWidth;
}
var InfoboxPane = {
	setup:
	function(id, options) {
		this.parameters = options['parameters'];
		this.infoBoxPane = document.getElementById(id);
		var boxes = [];
		for (var i = 0; i != this.infoBoxPane.childNodes.length; i++) {
			if (this.infoBoxPane.childNodes[i].nodeType != 1) continue;
			var drop = this.infoBoxPane.childNodes[i].getElementsByTagName('div')[0];
			var drag = drop.getElementsByTagName('div')[0];

			Droppables.add(drop, { onHover: this.onHover.bind(this) });
			new Draggable(drag, { revert: true, handle: 'handle', scroll: window, scrollSpeed: 30, zindex: 0, reverteffect: this.revertEffect });
			boxes.push(drag.id.slice(8));
		}
		this.infoBoxOrder = boxes.join(' ');
		Draggables.addObserver({ onStart: this.onStart.bind(this), onEnd: this.onEnd.bind(this) });
	},

	onHover:
	function(dragA, dropB) {
		var dragB = dropB.getElementsByTagName('div')[0];
		var dropA = dragA.parentNode;
		if (dragB != this.lastDragB && dragA != dragB) {
			this.lastDragB = dragB;
			Element.removeClassName(dropA, 'active');
			Element.addClassName(dropB, 'active');
			dropB.removeChild(dragB);
			dropA.removeChild(dragA);
			dropB.appendChild(dragA);
			dropA.appendChild(dragB);
		}
		else {
			this.lastDragB = dragB;
		}
	},

	onStart:
	function(eventName, draggable) {
		Element.addClassName(draggable.element.parentNode, 'active');
	},

	onEnd:
	function(eventName, draggable) {
		this.lastDragB = null;
		var boxes = [];
		for (var i = 0; i != this.infoBoxPane.childNodes.length; i++) {
			if (this.infoBoxPane.childNodes[i].nodeType == 1) {
				boxes.push(this.infoBoxPane.childNodes[i].getElementsByTagName('div')[0].getElementsByTagName('div')[0].id.slice(8));
			}
		}
		var order = boxes.join(' ');
		if (order != this.infoBoxOrder) {
			new Ajax.Request('/app/user', { method: 'post', parameters: this.parameters + '&order=' + encodeURIComponent(order) });
			this.infoBoxOrder = order;
		}
	},

	revertEffect:
	function(element, top_offset, left_offset) {
		var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
		element._revert = new Effect.Move(element, { x: -left_offset, y: -top_offset, duration: dur, afterFinish: function() { Element.removeClassName(element.parentNode, 'active'); }});
	}
}