/*  prototype javascript framework, version 1.5.0
 *  (c) 2005-2007 sam stephenson
 *
 *  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',
  browserfeatures: {
    xpath: !!document.evaluate
  },

  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.extend(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;
    }
  },

  keys: function(object) {
    var keys = [];
    for (var property in object)
      keys.push(property);
    return keys;
  },

  values: function(object) {
    var values = [];
    for (var property in object)
      values.push(object[property]);
    return values;
  },

  clone: function(object) {
    return object.extend({}, object);
  }
});

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, args = $a(arguments), object = args.shift();
  return function(event) {
    return __method.apply(object, [( event || window.event)].concat(args).concat($a(arguments)));
  }
}

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, length = arguments.length; i < 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() {
    this.timer = setinterval(this.ontimerevent.bind(this), this.frequency * 1000);
  },

  stop: function() {
    if (!this.timer) return;
    clearinterval(this.timer);
    this.timer = null;
  },

  ontimerevent: function() {
    if (!this.currentlyexecuting) {
      try {
        this.currentlyexecuting = true;
        this.callback(this);
      } finally {
        this.currentlyexecuting = false;
      }
    }
  }
}
string.interpret = function(value){
  return value == null ? '' : string(value);
}

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 += string.interpret(replacement(match));
        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.length > 1 ?
      $a(div.childnodes).inject('',function(memo,node){ return memo+node.nodevalue }) :
      div.childnodes[0].nodevalue) : '';
  },

  toqueryparams: function(separator) {
    var match = this.strip().match(/([^?#]*)(#.*)?$/);
    if (!match) return {};

    return match[1].split(separator || '&').inject({}, function(hash, pair) {
      if ((pair = pair.split('='))[0]) {
        var name = decodeuricomponent(pair[0]);
        var value = pair[1] ? decodeuricomponent(pair[1]) : undefined;

        if (hash[name] !== undefined) {
          if (hash[name].constructor != array)
            hash[name] = [hash[name]];
          if (value) hash[name].push(value);
        }
        else hash[name] = value;
      }
      return hash;
    });
  },

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

  succ: function() {
    return this.slice(0, this.length - 1) +
      string.fromcharcode(this.charcodeat(this.length - 1) + 1);
  },

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

    var camelized = this.charat(0) == '-'
      ? parts[0].charat(0).touppercase() + parts[0].substring(1)
      : parts[0];

    for (var i = 1; i < len; i++)
      camelized += parts[i].charat(0).touppercase() + parts[i].substring(1);

    return camelized;
  },

  capitalize: function(){
    return this.charat(0).touppercase() + this.substring(1).tolowercase();
  },

  underscore: function() {
    return this.gsub(/::/, '/').gsub(/([a-z]+)([a-z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([a-z])/,'#{1}_#{2}').gsub(/-/,'_').tolowercase();
  },

  dasherize: function() {
    return this.gsub(/_/,'-');
  },

  inspect: function(usedoublequotes) {
    var escapedstring = this.replace(/\\/g, '\\\\');
    if (usedoublequotes)
      return '"' + escapedstring.replace(/"/g, '\\"') + '"';
    else
      return "'" + escapedstring.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 + string.interpret(object[match[3]]);
    });
  }
}

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;
    }
    return this;
  },

  eachslice: function(number, iterator) {
    var index = -number, slices = [], array = this.toarray();
    while ((index += number) < array.length)
      slices.push(array.slice(index, index+number));
    return slices.map(iterator);
  },

  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 = false;
    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 || prototype.k)(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;
  },

  ingroupsof: function(number, fillwith) {
    fillwith = fillwith === undefined ? null : fillwith;
    return this.eachslice(number, function(slice) {
      while(slice.length < number) slice.push(fillwith);
      return slice;
    });
  },

  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.map(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.map(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.map();
  },

  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));
    });
  },

  size: function() {
    return this.toarray().length;
  },

  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, length = iterable.length; i < 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, length = this.length; i < 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 != 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, length = this.length; i < length; i++)
      if (this[i] == object) return i;
    return -1;
  },

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

  reduce: function() {
    return this.length > 1 ? this : this[0];
  },

  uniq: function() {
    return this.inject([], function(array, value) {
      return array.include(value) ? array : array.concat([value]);
    });
  },

  clone: function() {
    return [].concat(this);
  },

  size: function() {
    return this.length;
  },

  inspect: function() {
    return '[' + this.map(object.inspect).join(', ') + ']';
  }
});

array.prototype.toarray = array.prototype.clone;

function $w(string){
  string = string.strip();
  return string ? string.split(/\s+/) : [];
}

if(window.opera){
  array.prototype.concat = function(){
    var array = [];
    for(var i = 0, length = this.length; i < length; i++) array.push(this[i]);
    for(var i = 0, length = arguments.length; i < length; i++) {
      if(arguments[i].constructor == array) {
        for(var j = 0, arraylength = arguments[i].length; j < arraylength; j++)
          array.push(arguments[i][j]);
      } else {
        array.push(arguments[i]);
      }
    }
    return array;
  }
}
var hash = function(obj) {
  object.extend(this, obj || {});
};

object.extend(hash, {
  toquerystring: function(obj) {
    var parts = [];

	  this.prototype._each.call(obj, function(pair) {
      if (!pair.key) return;

      if (pair.value && pair.value.constructor == array) {
        var values = pair.value.compact();
        if (values.length < 2) pair.value = values.reduce();
        else {
        	key = encodeuricomponent(pair.key);
          values.each(function(value) {
            value = value != undefined ? encodeuricomponent(value) : '';
            parts.push(key + '=' + encodeuricomponent(value));
          });
          return;
        }
      }
      if (pair.value == undefined) pair[1] = '';
      parts.push(pair.map(encodeuricomponent).join('='));
	  });

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

object.extend(hash.prototype, enumerable);
object.extend(hash.prototype, {
  _each: function(iterator) {
    for (var key in this) {
      var value = this[key];
      if (value && value == hash.prototype[key]) 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(this, function(mergedhash, pair) {
      mergedhash[pair.key] = pair.value;
      return mergedhash;
    });
  },

  remove: function() {
    var result;
    for(var i = 0, length = arguments.length; i < length; i++) {
      var value = this[arguments[i]];
      if (value !== undefined){
        if (result === undefined) result = value;
        else {
          if (result.constructor != array) result = [result];
          result.push(value)
        }
      }
      delete this[arguments[i]];
    }
    return result;
  },

  toquerystring: function() {
    return hash.toquerystring(this);
  },

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

function $h(object) {
  if (object && object.constructor == hash) return object;
  return new hash(object);
};
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;
    while (this.include(value)) {
      iterator(value);
      value = value.succ();
    }
  },

  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(responder) {
    if (!this.include(responder))
      this.responders.push(responder);
  },

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

  dispatch: function(callback, request, transport, json) {
    this.each(function(responder) {
      if (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',
      encoding:     'utf-8',
      parameters:   ''
    }
    object.extend(this.options, options || {});

    this.options.method = this.options.method.tolowercase();
    if (typeof this.options.parameters == 'string')
      this.options.parameters = this.options.parameters.toqueryparams();
  }
}

ajax.request = class.create();
ajax.request.events =
  ['uninitialized', 'loading', 'loaded', 'interactive', 'complete'];

ajax.request.prototype = object.extend(new ajax.base(), {
  _complete: false,

  initialize: function(url, options) {
    this.transport = ajax.gettransport();
    this.setoptions(options);
    this.request(url);
  },

  request: function(url) {
    this.url = url;
    this.method = this.options.method;
    var params = this.options.parameters;

    if (!['get', 'post'].include(this.method)) {
      // simulate other verbs over post
      params['_method'] = this.method;
      this.method = 'post';
    }

    params = hash.toquerystring(params);
    if (params && /konqueror|safari|khtml/.test(navigator.useragent)) params += '&_='

    // when get, append parameters to url
    if (this.method == 'get' && params)
      this.url += (this.url.indexof('?') > -1 ? '&' : '?') + params;

    try {
      ajax.responders.dispatch('oncreate', this, this.transport);

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

      if (this.options.asynchronous)
        settimeout(function() { this.respondtoreadystate(1) }.bind(this), 10);

      this.transport.onreadystatechange = this.onstatechange.bind(this);
      this.setrequestheaders();

      var body = this.method == 'post' ? (this.options.postbody || params) : null;

      this.transport.send(body);

      /* force firefox to handle ready state 4 for synchronous requests */
      if (!this.options.asynchronous && this.transport.overridemimetype)
        this.onstatechange();

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

  onstatechange: function() {
    var readystate = this.transport.readystate;
    if (readystate > 1 && !((readystate == 4) && this._complete))
      this.respondtoreadystate(this.transport.readystate);
  },

  setrequestheaders: function() {
    var headers = {
      'x-requested-with': 'xmlhttprequest',
      'x-prototype-version': prototype.version,
      'accept': 'text/javascript, text/html, application/xml, text/xml, */*'
    };

    if (this.method == 'post') {
      headers['content-type'] = this.options.contenttype +
        (this.options.encoding ? '; charset=' + this.options.encoding : '');

      /* force "connection: close" for older mozilla browsers to work
       * around a bug where xmlhttprequest sends an incorrect
       * content-length header. see mozilla bugzilla #246651.
       */
      if (this.transport.overridemimetype &&
          (navigator.useragent.match(/gecko\/(\d{4})/) || [0,2005])[1] < 2005)
            headers['connection'] = 'close';
    }

    // user-defined headers
    if (typeof this.options.requestheaders == 'object') {
      var extras = this.options.requestheaders;

      if (typeof extras.push == 'function')
        for (var i = 0, length = extras.length; i < length; i += 2)
          headers[extras[i]] = extras[i+1];
      else
        $h(extras).each(function(pair) { headers[pair.key] = pair.value });
    }

    for (var name in headers)
      this.transport.setrequestheader(name, headers[name]);
  },

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

  respondtoreadystate: function(readystate) {
    var state = ajax.request.events[readystate];
    var transport = this.transport, json = this.evaljson();

    if (state == 'complete') {
      try {
        this._complete = true;
        (this.options['on' + this.transport.status]
         || this.options['on' + (this.success() ? 'success' : 'failure')]
         || prototype.emptyfunction)(transport, json);
      } catch (e) {
        this.dispatchexception(e);
      }

      if ((this.getheader('content-type') || 'text/javascript').strip().
        match(/^(text|application)\/(x-)?(java|ecma)script(;.*)?$/i))
          this.evalresponse();
    }

    try {
      (this.options['on' + state] || prototype.emptyfunction)(transport, json);
      ajax.responders.dispatch('on' + state, this, transport, json);
    } catch (e) {
      this.dispatchexception(e);
    }

    if (state == 'complete') {
      // avoid memory leak in msie: clean up
      this.transport.onreadystatechange = prototype.emptyfunction;
    }
  },

  getheader: function(name) {
    try {
      return this.transport.getresponseheader(name);
    } catch (e) { return null }
  },

  evaljson: function() {
    try {
      var json = this.getheader('x-json');
      return json ? eval('(' + json + ')') : null;
    } catch (e) { return null }
  },

  evalresponse: function() {
    try {
      return eval(this.transport.responsetext);
    } catch (e) {
      this.dispatchexception(e);
    }
  },

  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.container = {
      success: (container.success || 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, param) {
      this.updatecontent();
      oncomplete(transport, param);
    }).bind(this);

    this.request(url);
  },

  updatecontent: function() {
    var receiver = this.container[this.success() ? 'success' : 'failure'];
    var response = this.transport.responsetext;

    if (!this.options.evalscripts) response = response.stripscripts();

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

    if (this.success()) {
      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.options.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 $(element) {
  if (arguments.length > 1) {
    for (var i = 0, elements = [], length = arguments.length; i < length; i++)
      elements.push($(arguments[i]));
    return elements;
  }
  if (typeof element == 'string')
    element = document.getelementbyid(element);
  return element.extend(element);
}

if (prototype.browserfeatures.xpath) {
  document._getelementsbyxpath = function(expression, parentelement) {
    var results = [];
    var query = document.evaluate(expression, $(parentelement) || document,
      null, xpathresult.ordered_node_snapshot_type, null);
    for (var i = 0, length = query.snapshotlength; i < length; i++)
      results.push(query.snapshotitem(i));
    return results;
  };
}

document.getelementsbyclassname = function(classname, parentelement) {
  if (prototype.browserfeatures.xpath) {
    var q = ".//*[contains(concat(' ', @class, ' '), ' " + classname + " ')]";
    return document._getelementsbyxpath(q, parentelement);
  } else {
    var children = ($(parentelement) || document.body).getelementsbytagname('*');
    var elements = [], child;
    for (var i = 0, length = children.length; i < length; i++) {
      child = children[i];
      if (element.hasclassname(child, classname))
        elements.push(element.extend(child));
    }
    return elements;
  }
};

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

if (!window.element)
  var element = new object();

element.extend = function(element) {
  if (!element || _nativeextensions || element.nodetype == 3) return element;

  if (!element._extended && element.tagname && element != window) {
    var methods = object.clone(element.methods), cache = element.extend.cache;

    if (element.tagname == 'form')
      object.extend(methods, form.methods);
    if (['input', 'textarea', 'select'].include(element.tagname))
      object.extend(methods, form.element.methods);

    object.extend(methods, element.methods.simulated);

    for (var property in methods) {
      var value = methods[property];
      if (typeof value == 'function' && !(property in element))
        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(element) {
    element = $(element);
    element[element.visible(element) ? 'hide' : 'show'](element);
    return element;
  },

  hide: function(element) {
    $(element).style.display = 'none';
    return element;
  },

  show: function(element) {
    $(element).style.display = '';
    return element;
  },

  remove: function(element) {
    element = $(element);
    element.parentnode.removechild(element);
    return element;
  },

  update: function(element, html) {
    html = typeof html == 'undefined' ? '' : html.tostring();
    $(element).innerhtml = html.stripscripts();
    settimeout(function() {html.evalscripts()}, 10);
    return element;
  },

  replace: function(element, html) {
    element = $(element);
    html = typeof html == 'undefined' ? '' : html.tostring();
    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);
    return element;
  },

  inspect: function(element) {
    element = $(element);
    var result = '<' + element.tagname.tolowercase();
    $h({'id': 'id', 'classname': 'class'}).each(function(pair) {
      var property = pair.first(), attribute = pair.last();
      var value = (element[property] || '').tostring();
      if (value) result += ' ' + attribute + '=' + value.inspect(true);
    });
    return result + '>';
  },

  recursivelycollect: function(element, property) {
    element = $(element);
    var elements = [];
    while (element = element[property])
      if (element.nodetype == 1)
        elements.push(element.extend(element));
    return elements;
  },

  ancestors: function(element) {
    return $(element).recursivelycollect('parentnode');
  },

  descendants: function(element) {
    return $a($(element).getelementsbytagname('*'));
  },

  immediatedescendants: function(element) {
    if (!(element = $(element).firstchild)) return [];
    while (element && element.nodetype != 1) element = element.nextsibling;
    if (element) return [element].concat($(element).nextsiblings());
    return [];
  },

  previoussiblings: function(element) {
    return $(element).recursivelycollect('previoussibling');
  },

  nextsiblings: function(element) {
    return $(element).recursivelycollect('nextsibling');
  },

  siblings: function(element) {
    element = $(element);
    return element.previoussiblings().reverse().concat(element.nextsiblings());
  },

  match: function(element, selector) {
    if (typeof selector == 'string')
      selector = new selector(selector);
    return selector.match($(element));
  },

  up: function(element, expression, index) {
    return selector.findelement($(element).ancestors(), expression, index);
  },

  down: function(element, expression, index) {
    return selector.findelement($(element).descendants(), expression, index);
  },

  previous: function(element, expression, index) {
    return selector.findelement($(element).previoussiblings(), expression, index);
  },

  next: function(element, expression, index) {
    return selector.findelement($(element).nextsiblings(), expression, index);
  },

  getelementsbyselector: function() {
    var args = $a(arguments), element = $(args.shift());
    return selector.findchildelements(element, args);
  },

  getelementsbyclassname: function(element, classname) {
    return document.getelementsbyclassname(classname, element);
  },

  readattribute: function(element, name) {
    element = $(element);
    if (document.all && !window.opera) {
      var t = element._attributetranslations;
      if (t.values[name]) return t.values[name](element, name);
      if (t.names[name])  name = t.names[name];
      var attribute = element.attributes[name];
      if(attribute) return attribute.nodevalue;
    }
    return element.getattribute(name);
  },

  getheight: function(element) {
    return $(element).getdimensions().height;
  },

  getwidth: function(element) {
    return $(element).getdimensions().width;
  },

  classnames: function(element) {
    return new element.classnames(element);
  },

  hasclassname: function(element, classname) {
    if (!(element = $(element))) return;
    var elementclassname = element.classname;
    if (elementclassname.length == 0) return false;
    if (elementclassname == classname ||
        elementclassname.match(new regexp("(^|\\s)" + classname + "(\\s|$)")))
      return true;
    return false;
  },

  addclassname: function(element, classname) {
    if (!(element = $(element))) return;
    element.classnames(element).add(classname);
    return element;
  },

  removeclassname: function(element, classname) {
    if (!(element = $(element))) return;
    element.classnames(element).remove(classname);
    return element;
  },

  toggleclassname: function(element, classname) {
    if (!(element = $(element))) return;
    element.classnames(element)[element.hasclassname(classname) ? 'remove' : 'add'](classname);
    return element;
  },

  observe: function() {
    event.observe.apply(event, arguments);
    return $a(arguments).first();
  },

  stopobserving: function() {
    event.stopobserving.apply(event, arguments);
    return $a(arguments).first();
  },

  // removes whitespace-only text node children
  cleanwhitespace: function(element) {
    element = $(element);
    var node = element.firstchild;
    while (node) {
      var nextnode = node.nextsibling;
      if (node.nodetype == 3 && !/\s/.test(node.nodevalue))
        element.removechild(node);
      node = nextnode;
    }
    return element;
  },

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

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

  scrollto: function(element) {
    element = $(element);
    var pos = position.cumulativeoffset(element);
    window.scrollto(pos[0], pos[1]);
    return element;
  },

  getstyle: function(element, style) {
    element = $(element);
    if (['float','cssfloat'].include(style))
      style = (typeof element.style.stylefloat != 'undefined' ? 'stylefloat' : 'cssfloat');
    style = style.camelize();
    var value = element.style[style];
    if (!value) {
      if (document.defaultview && document.defaultview.getcomputedstyle) {
        var css = document.defaultview.getcomputedstyle(element, null);
        value = css ? css[style] : null;
      } else if (element.currentstyle) {
        value = element.currentstyle[style];
      }
    }

    if((value == 'auto') && ['width','height'].include(style) && (element.getstyle('display') != 'none'))
      value = element['offset'+style.capitalize()] + 'px';

    if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))
      if (element.getstyle(element, 'position') == 'static') value = 'auto';
    if(style == 'opacity') {
      if(value) return parsefloat(value);
      if(value = (element.getstyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
        if(value[1]) return parsefloat(value[1]) / 100;
      return 1.0;
    }
    return value == 'auto' ? null : value;
  },

  setstyle: function(element, style) {
    element = $(element);
    for (var name in style) {
      var value = style[name];
      if(name == 'opacity') {
        if (value == 1) {
          value = (/gecko/.test(navigator.useragent) &&
            !/konqueror|safari|khtml/.test(navigator.useragent)) ? 0.999999 : 1.0;
          if(/msie/.test(navigator.useragent) && !window.opera)
            element.style.filter = element.getstyle('filter').replace(/alpha\([^\)]*\)/gi,'');
        } else if(value === '') {
          if(/msie/.test(navigator.useragent) && !window.opera)
            element.style.filter = element.getstyle('filter').replace(/alpha\([^\)]*\)/gi,'');
        } else {
          if(value < 0.00001) value = 0;
          if(/msie/.test(navigator.useragent) && !window.opera)
            element.style.filter = element.getstyle('filter').replace(/alpha\([^\)]*\)/gi,'') +
              'alpha(opacity='+value*100+')';
        }
      } else if(['float','cssfloat'].include(name)) name = (typeof element.style.stylefloat != 'undefined') ? 'stylefloat' : 'cssfloat';
      element.style[name.camelize()] = value;
    }
    return element;
  },

  getdimensions: function(element) {
    element = $(element);
    var display = $(element).getstyle('display');
    if (display != 'none' && display != null) // safari bug
      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;
    var originaldisplay = els.display;
    els.visibility = 'hidden';
    els.position = 'absolute';
    els.display = 'block';
    var originalwidth = element.clientwidth;
    var originalheight = element.clientheight;
    els.display = originaldisplay;
    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;
      }
    }
    return element;
  },

  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 = '';
    }
    return element;
  },

  makeclipping: function(element) {
    element = $(element);
    if (element._overflow) return element;
    element._overflow = element.style.overflow || 'auto';
    if ((element.getstyle(element, 'overflow') || 'visible') != 'hidden')
      element.style.overflow = 'hidden';
    return element;
  },

  undoclipping: function(element) {
    element = $(element);
    if (!element._overflow) return element;
    element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
    element._overflow = null;
    return element;
  }
};

object.extend(element.methods, {childof: element.methods.descendantof});

element._attributetranslations = {};

element._attributetranslations.names = {
  colspan:   "colspan",
  rowspan:   "rowspan",
  valign:    "valign",
  datetime:  "datetime",
  accesskey: "accesskey",
  tabindex:  "tabindex",
  enctype:   "enctype",
  maxlength: "maxlength",
  readonly:  "readonly",
  longdesc:  "longdesc"
};

element._attributetranslations.values = {
  _getattr: function(element, attribute) {
    return element.getattribute(attribute, 2);
  },

  _flag: function(element, attribute) {
    return $(element).hasattribute(attribute) ? attribute : null;
  },

  style: function(element) {
    return element.style.csstext.tolowercase();
  },

  title: function(element) {
    var node = element.getattributenode('title');
    return node.specified ? node.nodevalue : null;
  }
};

object.extend(element._attributetranslations.values, {
  href: element._attributetranslations.values._getattr,
  src:  element._attributetranslations.values._getattr,
  disabled: element._attributetranslations.values._flag,
  checked:  element._attributetranslations.values._flag,
  readonly: element._attributetranslations.values._flag,
  multiple: element._attributetranslations.values._flag
});

element.methods.simulated = {
  hasattribute: function(element, attribute) {
    var t = element._attributetranslations;
    attribute = t.names[attribute] || attribute;
    return $(element).getattributenode(attribute).specified;
  }
};

// ie is missing .innerhtml support for table-related elements
if (document.all && !window.opera){
  element.methods.update = function(element, html) {
    element = $(element);
    html = typeof html == 'undefined' ? '' : html.tostring();
    var tagname = element.tagname.touppercase();
    if (['thead','tbody','tr','td'].include(tagname)) {
      var div = document.createelement('div');
      switch (tagname) {
        case 'thead':
        case 'tbody':
          div.innerhtml = '<table><tbody>' +  html.stripscripts() + '</tbody></table>';
          depth = 2;
          break;
        case 'tr':
          div.innerhtml = '<table><tbody><tr>' +  html.stripscripts() + '</tr></tbody></table>';
          depth = 3;
          break;
        case 'td':
          div.innerhtml = '<table><tbody><tr><td>' +  html.stripscripts() + '</td></tr></tbody></table>';
          depth = 4;
      }
      $a(element.childnodes).each(function(node){
        element.removechild(node)
      });
      depth.times(function(){ div = div.firstchild });

      $a(div.childnodes).each(
        function(node){ element.appendchild(node) });
    } else {
      element.innerhtml = html.stripscripts();
    }
    settimeout(function() {html.evalscripts()}, 10);
    return element;
  }
};

object.extend(element, element.methods);

var _nativeextensions = false;

if(/konqueror|safari|khtml/.test(navigator.useragent))
  ['', 'form', 'input', 'textarea', 'select'].each(function(tag) {
    var classname = 'html' + tag + 'element';
    if(window[classname]) return;
    var klass = window[classname] = {};
    klass.prototype = document.createelement(tag ? tag.tolowercase() : 'div').__proto__;
  });

element.addmethods = function(methods) {
  object.extend(element.methods, methods || {});

  function copy(methods, destination, onlyifabsent) {
    onlyifabsent = onlyifabsent || false;
    var cache = element.extend.cache;
    for (var property in methods) {
      var value = methods[property];
      if (!onlyifabsent || !(property in destination))
        destination[property] = cache.findorstore(value);
    }
  }

  if (typeof htmlelement != 'undefined') {
    copy(element.methods, htmlelement.prototype);
    copy(element.methods.simulated, htmlelement.prototype, true);
    copy(form.methods, htmlformelement.prototype);
    [htmlinputelement, htmltextareaelement, htmlselectelement].each(function(klass) {
      copy(form.element.methods, klass.prototype);
    });
    _nativeextensions = true;
  }
}

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.touppercase();
        if (['tbody', 'tr'].include(tagname)) {
          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($a(this).concat(classnametoadd).join(' '));
  },

  remove: function(classnametoremove) {
    if (!this.include(classnametoremove)) return;
    this.set($a(this).without(classnametoremove).join(' '));
  },

  tostring: function() {
    return $a(this).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.readattribute("id") == ' + clause.inspect());
    if (clause = params.tagname)
      conditions.push('element.tagname.touppercase() == ' + clause.inspect());
    if ((clause = params.classnames).length > 0)
      for (var i = 0, length = clause.length; i < length; i++)
        conditions.push('element.hasclassname(' + clause[i].inspect() + ')');
    if (clause = params.attributes) {
      clause.each(function(attribute) {
        var value = 'element.readattribute(' + 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('element.hasattribute(' + attribute.name.inspect() + ')'); break;
          default:        throw 'unknown operator ' + attribute.operator + ' in selector';
        }
      });
    }

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

  compilematcher: function() {
    this.match = new function('element', 'if (!element.tagname) return false; \
      element = $(element); \
      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, length = scope.length; i < length; i++)
      if (this.match(element = scope[i]))
        results.push(element.extend(element));

    return results;
  },

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

object.extend(selector, {
  matchelements: function(elements, expression) {
    var selector = new selector(expression);
    return elements.select(selector.match.bind(selector)).map(element.extend);
  },

  findelement: function(elements, expression, index) {
    if (typeof expression == 'number') index = expression, expression = false;
    return selector.matchelements(elements, expression || '*')[index || 0];
  },

  findchildelements: function(element, expressions) {
    return expressions.map(function(expression) {
      return expression.match(/[^\s"]+(?:"[^"]*"[^\s"]+)*/g).inject([null], function(results, expr) {
        var selector = new selector(expr);
        return results.inject([], function(elements, result) {
          return elements.concat(selector.findelements(result || element));
        });
      });
    }).flatten();
  }
});

function $$() {
  return selector.findchildelements(document, $a(arguments));
}
var form = {
  reset: function(form) {
    $(form).reset();
    return form;
  },

  serializeelements: function(elements, gethash) {
    var data = elements.inject({}, function(result, element) {
      if (!element.disabled && element.name) {
        var key = element.name, value = $(element).getvalue();
        if (value != undefined) {
          if (result[key]) {
            if (result[key].constructor != array) result[key] = [result[key]];
            result[key].push(value);
          }
          else result[key] = value;
        }
      }
      return result;
    });

    return gethash ? data : hash.toquerystring(data);
  }
};

form.methods = {
  serialize: function(form, gethash) {
    return form.serializeelements(form.getelements(form), gethash);
  },

  getelements: function(form) {
    return $a($(form).getelementsbytagname('*')).inject([],
      function(elements, child) {
        if (form.element.serializers[child.tagname.tolowercase()])
          elements.push(element.extend(child));
        return elements;
      }
    );
  },

  getinputs: function(form, typename, name) {
    form = $(form);
    var inputs = form.getelementsbytagname('input');

    if (!typename && !name) return $a(inputs).map(element.extend);

    for (var i = 0, matchinginputs = [], length = inputs.length; i < length; i++) {
      var input = inputs[i];
      if ((typename && input.type != typename) || (name && input.name != name))
        continue;
      matchinginputs.push(element.extend(input));
    }

    return matchinginputs;
  },

  disable: function(form) {
    form = $(form);
    form.getelements().each(function(element) {
      element.blur();
      element.disabled = 'true';
    });
    return form;
  },

  enable: function(form) {
    form = $(form);
    form.getelements().each(function(element) {
      element.disabled = '';
    });
    return form;
  },

  findfirstelement: function(form) {
    return $(form).getelements().find(function(element) {
      return element.type != 'hidden' && !element.disabled &&
        ['input', 'select', 'textarea'].include(element.tagname.tolowercase());
    });
  },

  focusfirstelement: function(form) {
    form = $(form);
    form.findfirstelement().activate();
    return form;
  }
}

object.extend(form, form.methods);

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

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

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

form.element.methods = {
  serialize: function(element) {
    element = $(element);
    if (!element.disabled && element.name) {
      var value = element.getvalue();
      if (value != undefined) {
        var pair = {};
        pair[element.name] = value;
        return hash.toquerystring(pair);
      }
    }
    return '';
  },

  getvalue: function(element) {
    element = $(element);
    var method = element.tagname.tolowercase();
    return form.element.serializers[method](element);
  },

  clear: function(element) {
    $(element).value = '';
    return element;
  },

  present: function(element) {
    return $(element).value != '';
  },

  activate: function(element) {
    element = $(element);
    element.focus();
    if (element.select && ( element.tagname.tolowercase() != 'input' ||
      !['button', 'reset', 'submit'].include(element.type) ) )
      element.select();
    return element;
  },

  disable: function(element) {
    element = $(element);
    element.disabled = true;
    return element;
  },

  enable: function(element) {
    element = $(element);
    element.blur();
    element.disabled = false;
    return element;
  }
}

object.extend(form.element, form.element.methods);
var field = form.element;
var $f = form.element.getvalue;

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

form.element.serializers = {
  input: function(element) {
    switch (element.type.tolowercase()) {
      case 'checkbox':
      case 'radio':
        return form.element.serializers.inputselector(element);
      default:
        return form.element.serializers.textarea(element);
    }
  },

  inputselector: function(element) {
    return element.checked ? element.value : null;
  },

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

  select: function(element) {
    return this[element.type == 'select-one' ?
      'selectone' : 'selectmany'](element);
  },

  selectone: function(element) {
    var index = element.selectedindex;
    return index >= 0 ? this.optionvalue(element.options[index]) : null;
  },

  selectmany: function(element) {
    var values, length = element.length;
    if (!length) return null;

    for (var i = 0, values = []; i < length; i++) {
      var opt = element.options[i];
      if (opt.selected) values.push(this.optionvalue(opt));
    }
    return values;
  },

  optionvalue: function(opt) {
    // extend element because hasattribute may not be native
    return element.extend(opt).hasattribute('value') ? opt.value : opt.text;
  }
}

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

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();
    var changed = ('string' == typeof this.lastvalue && 'string' == typeof value
      ? this.lastvalue != value : string(this.lastvalue) != string(value));
    if (changed) {
      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() {
    form.getelements(this.element).each(this.registercallback.bind(this));
  },

  registercallback: function(element) {
    if (element.type) {
      switch (element.type.tolowercase()) {
        case 'checkbox':
        case 'radio':
          event.observe(element, 'click', this.onelementevent.bind(this));
          break;
        default:
          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,
  key_home:     36,
  key_end:      35,
  key_pageup:   33,
  key_pagedown: 34,

  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, length = event.observers.length; i < length; i++) {
      event.stopobserving.apply(this, event.observers[i]);
      event.observers[i][0] = null;
    }
    event.observers = false;
  },

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

    if (name == 'keypress' &&
        (navigator.appversion.match(/konqueror|safari|khtml/)
        || element.attachevent))
      name = 'keydown';

    event._observeandcache(element, name, observer, usecapture);
  },

  stopobserving: function(element, name, observer, usecapture) {
    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) {
      try {
        element.detachevent('on' + name, observer);
      } catch (e) {}
    }
  }
});

/* 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) {
        if(element.tagname=='body') break;
        var 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;
  },

  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 {
      if (!window.opera || element.tagname=='body') {
        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];
  }
}

element.addmethods();