/*  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;
  },

  /* added */
  search: function(s){var le=this.length;for(var i=0;i<le;i++){if(this[i]==s) return i;}return null;},
  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 = {
  /* modified - toLowerCase() */
  setOptions: function(options) {
    this.options = {
      method:       'post',
      asynchronous: true,
      contentType:  'application/x-www-form-urlencoded',
      parameters:   ''
    }
    Object.extend(this.options, options || {});
    this.options.method=this.options.method.toLowerCase();
  },

  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.transport.overrideMimeType&&this.options.XML){this.transport.overrideMimeType('text/xml');}

    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);
    if(!element) return null;
    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';
  },

  /* modified */
  undoClipping: function(element) {
    element = $(element);
    if (element._overflow) return;
    element.style.overflow = (element._overflow||'auto');
    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;
  }
}

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];
  }
}
/* -- added -- */
Element.require=function() {libs=arguments;for(var i=0,max=libs.length;i<max;i++){var scr=document.createElement('script');scr.language='javascript';scr.content='text/javascript'; scr.src=GLOBAL_PATH+libs[i];document.getElementsByTagName('body')[0].appendChild(scr);}}
Element.scrollTo = function (e){x=0;y=0;e=$(e);if(!e) return;do{with(e){x+=offsetLeft;y+=offsetTop};} while(e=e.offsetParent);window.scrollTo(x,y);}
Field.enable=function(element) {$(element).disabled = '';}
Field.disable=function(element) {$(element).disabled = 'true';}

/*---01_prototype.js---*/

var Behaviour={list:new Array,register:function(sheet){Behaviour.list.push(sheet);},start:function(){Behaviour.addLoadEvent(function(){Behaviour.apply();});},apply:function(){for(h=0;sheet=Behaviour.list[h];h++){for(selector in sheet){list=document.getElementsBySelector(selector);if(!list){continue;}for(i=0;element=list[i];i++){sheet[selector](element);}}}},addLoadEvent:function(func){var oldonload=window.onload;if(typeof window.onload!='function'){window.onload=func;}else{window.onload=function(){oldonload();func();}}}}
Behaviour.start();
function getAllChildren(e){return e.all?e.all:e.getElementsByTagName('*');}
document.getElementsBySelector=function(selector){if(!document.getElementsByTagName){return new Array();}var tokens=selector.split(' ');var currentContext=new Array(document);for(var i=0;i<tokens.length;i++){token=tokens[i].replace(/^\s+/,'').replace(/\s+$/,'' );;if (token.indexOf('#')>-1){var bits=token.split('#');var tagName=bits[0];var id=bits[1];var element=document.getElementById(id);if(tagName&&element.nodeName.toLowerCase()!=tagName){return new Array();}currentContext=new Array(element);continue;}if(token.indexOf('.')>-1){var bits=token.split('.');var tagName=bits[0];var className=bits[1];if(!tagName){tagName='*';}var found=new Array;var foundCount=0;for(var h=0;h<currentContext.length;h++){var elements;if(tagName=='*'){elements=getAllChildren(currentContext[h]);}else{elements=currentContext[h].getElementsByTagName(tagName);}for(var j=0;j<elements.length;j++){found[foundCount++]=elements[j];}}currentContext=new Array;var currentContextIndex=0;for(var k=0;k<found.length;k++){if(found[k].className&&found[k].className.match(new RegExp('\\b'+className+'\\b'))){currentContext[currentContextIndex++]=found[k];}}continue;}if(token.match(/^(\w*)\[(\w+)([=~\|\^\$\*]?)=?"?([^\]"]*)"?\]$/) ){var tagName=RegExp.$1;var attrName=RegExp.$2;var attrOperator=RegExp.$3;var attrValue=RegExp.$4;if(!tagName){tagName='*';}var found=new Array;var foundCount=0;for(var h=0;h<currentContext.length;h++){var elements;if(tagName=='*'){elements=getAllChildren(currentContext[h]);}else{elements=currentContext[h].getElementsByTagName(tagName);}for(var j=0;j<elements.length;j++){found[foundCount++]=elements[j];}}currentContext=new Array;var currentContextIndex=0;var checkFunction;switch(attrOperator){case '=':checkFunction=function(e){return (e.getAttribute(attrName)==attrValue);};break;case '~':checkFunction=function(e){return (e.getAttribute(attrName).match(new RegExp('\\b'+attrValue+'\\b')));};break;case '|':checkFunction=function(e){return (e.getAttribute(attrName).match(new RegExp('^'+attrValue+'-?')));};break;case '^':checkFunction=function(e){return (e.getAttribute(attrName).indexOf(attrValue)==0);};break;case '$':checkFunction=function(e){return (e.getAttribute(attrName).lastIndexOf(attrValue)==e.getAttribute(attrName).length-attrValue.length);};break;case '*':checkFunction=function(e){return (e.getAttribute(attrName).indexOf(attrValue)>-1);};break;default:checkFunction=function(e){return e.getAttribute(attrName);};}currentContext=new Array;var currentContextIndex=0;for(var k=0;k<found.length;k++){if(checkFunction(found[k])){currentContext[currentContextIndex++]=found[k];}}continue;}if(!currentContext[0]){return;}tagName=token;var found=new Array;var foundCount=0;for(var h=0;h<currentContext.length;h++){var elements=currentContext[h].getElementsByTagName(tagName);for(var j=0;j<elements.length;j++){found[foundCount++]=elements[j];}}currentContext=found;}return currentContext;}

/*---02_behaviour.js---*/

var PromotionsRotate = Class.create();
Ajax.PeriodicalUpdater.prototype.__onTimerEvent=Ajax.PeriodicalUpdater.prototype.onTimerEvent;
Ajax.PeriodicalUpdater.prototype.__initialize=Ajax.PeriodicalUpdater.prototype.initialize;
PromotionsRotate.prototype = Object.extend(Ajax.PeriodicalUpdater.prototype, {
	pause:false,
	
	initialize: function(container, url, options, pause){
		this.pause=pause;
		this.__initialize(container, url, options);
	},
	
	onTimerEvent: function(){
		if(this.pause) this.updateComplete({responseText:this.lastText});
		else this.__onTimerEvent();
	}
});

/*---AjaxUpdater_ext.js---*/

function getAnchorPosition(anchorname){var useWindow=false;var coordinates=new Object();var x=0,y=0;var use_gebi=false, use_css=false, use_layers=false;if(document.getElementById){use_gebi=true;}else if(document.all){use_css=true;}else if(document.layers){use_layers=true;}if(use_gebi && document.all){x=AnchorPosition_getPageOffsetLeft(document.all[anchorname]);y=AnchorPosition_getPageOffsetTop(document.all[anchorname]);}else if(use_gebi){var o=document.getElementById(anchorname);x=AnchorPosition_getPageOffsetLeft(o);y=AnchorPosition_getPageOffsetTop(o);}else if(use_css){x=AnchorPosition_getPageOffsetLeft(document.all[anchorname]);y=AnchorPosition_getPageOffsetTop(document.all[anchorname]);}else if(use_layers){var found=0;for(var i=0;i<document.anchors.length;i++){if(document.anchors[i].name==anchorname){found=1;break;}}if(found==0){coordinates.x=0;coordinates.y=0;return coordinates;}x=document.anchors[i].x;y=document.anchors[i].y;}else{coordinates.x=0;coordinates.y=0;return coordinates;}coordinates.x=x;coordinates.y=y;return coordinates;}
function getAnchorWindowPosition(anchorname){var coordinates=getAnchorPosition(anchorname);var x=0;var y=0;if(document.getElementById){if(isNaN(window.screenX)){x=coordinates.x-document.body.scrollLeft+window.screenLeft;y=coordinates.y-document.body.scrollTop+window.screenTop;}else{x=coordinates.x+window.screenX+(window.outerWidth-window.innerWidth)-window.pageXOffset;y=coordinates.y+window.screenY+(window.outerHeight-24-window.innerHeight)-window.pageYOffset;}}else if(document.all){x=coordinates.x-document.body.scrollLeft+window.screenLeft;y=coordinates.y-document.body.scrollTop+window.screenTop;}else if(document.layers){x=coordinates.x+window.screenX+(window.outerWidth-window.innerWidth)-window.pageXOffset;y=coordinates.y+window.screenY+(window.outerHeight-24-window.innerHeight)-window.pageYOffset;}coordinates.x=x;coordinates.y=y;return coordinates;}
function AnchorPosition_getPageOffsetLeft(el){var ol=el.offsetLeft;while((el=el.offsetParent) != null){ol += el.offsetLeft;}return ol;}
function AnchorPosition_getWindowOffsetLeft(el){return AnchorPosition_getPageOffsetLeft(el)-document.body.scrollLeft;}
function AnchorPosition_getPageOffsetTop(el){var ot=el.offsetTop;while((el=el.offsetParent) != null){ot += el.offsetTop;}return ot;}
function AnchorPosition_getWindowOffsetTop(el){return AnchorPosition_getPageOffsetTop(el)-document.body.scrollTop;}

/*---AnchorPosition.js---*/

var deleting_image={
	element:null,
	options:{},
	elements:[],
	start:function(id){element=$(id);this.element=element;options = Object.extend({ class_name: null,confirm_txt: '',parent_id: null,whait_txt: 'Please whait...',whait_css: null,onEnd: function(){}}, arguments[1] || {});this.options=options;Element.cleanWhitespace(element);elements=this.find_elements(element);this.elements=elements;this.add_onClick(elements);},
	add_onClick:function(elements){if(!elements || elements.length==0) return false;var self=this;for(var i=0,max=elements.length;i<max;i++){var a=elements[i];a.onclick=function(){this.blur();if(confirm(self.options.confirm_txt)){self.create_whait(this.parentNode);var link=this;var url=this.href.split('?');new Ajax.Request(url[0],{parameters:url[1],method:'get',onComplete:function(a){now=link.parentNode;while(now.id.indexOf(self.options.parent_id)==-1) now=now.parentNode;self.create_done(now);}});}return false;}}},
	create_whait:function(element){if(!element) return false;var div=document.createElement('div');if(this.options.whait_css){div.className=this.options.whait_css;}else{with(div.style){backgroundColor='#f00';color='#fff';border='1px solid black';}}div.appendChild(document.createTextNode(this.options.whait_txt));element.appendChild(div);return true;},
	create_done:function(element){if(!element) return false;var self=this;if (Effect && typeof Effect == 'object') {Effect.BlindUp(element,{scaleMode:'contents',afterFinish:function(effect){Element.remove(effect.element);self.options.onEnd(self.element);}});}else {Element.remove(effect.element);self.options.onEnd(self.element);}return true;},
	find_elements:function(element){if(!element || !element.hasChildNodes() || this.options.class_name==null) return false;var child=element.childNodes;var elements=[];for(var i=0,max=child.length;i<max;i++){if(child[i]&&child[i].className==this.options.class_name) elements.push(child[i]);else {var find=this.find_elements(child[i]);if(find) elements.push(find);}}return (elements.length>0 ? elements.flatten() : null);}
}

/*---delete_image.js---*/

function create_new_tr_after(id,pid){d=document; tr=d.getElementById(id); tds=tr.getElementsByTagName('td');tdsc=tds.length;ret=[];new_td=[];new_tr=d.createElement('tr');for(i=0;a=tds[i];i++){new_td[i]=d.createElement('td');new_tr.appendChild(new_td[i]);}ret['tr']=new_tr;ret['tds']=new_td;d.getElementById(pid).insertBefore(new_tr,tr);return ret;}
function delete_offer(id,txt,el,admin){d=document;div=document.createElement('div');with(div.style){backgroundColor='#f00';color='#fff';border='1px solid black';}div.appendChild(document.createTextNode(txt));el.parentNode.appendChild(div);url=GLOBAL_PATH+'xml_pages/delete_item.php?id='+id;new Ajax.Request(url,{method:'get',onComplete:function(){if(admin){new Effect.Opacity('offer_nr_'+id,{to:0.2});Element.remove($('offer_nr_'+id).getElementsByTagName('input')[0]);var spans=$('offer_nr_'+id).getElementsByTagName('span');for(i=0;i<spans.length;i++)if(Element.hasClassName(spans[i],'item_list_admin_link'))Element.remove(spans[i]);}else{Element.remove('offer_nr_'+id);}}});return false;}

/*---delete_offer.js---*/

var txt_lng=[];
var errors=[];
var FormSend=Class.create();
FormSend.prototype={
	options:{
		action:null,
		XML:false,
		xmlPath:'xml_pages/',
		ext:'.php',
		withCheck:true,
		errBgColor:'#f00',
		okBgColor:'#fff',
		container:null
	},
	element:null,
	errors:[],
	initialize: function(element,options){
		this.element=$(element);
		this.element.s=this;
		this.setOptions(options);
		if(this.options.withCheck)
			this.addCheck();
		this.addSend();
	},
	setOptions: function(options) {
		Object.extend(this.options, options || {});
	},
	addCheck: function(){
		var reqs=this.getElements('req');
		var emails=this.getElements('email');
		var sames=this.getElements('same');
		
		for(var i=0;i<reqs.length;i++){
			reqs[i].s=this;
			reqs[i].onblur=function(){
				if(this.value==''){
					this.style.backgroundColor=this.s.options.errBgColor; 
					errors['req_'+i]=1;
				}
				else{ 
					this.style.backgroundColor=''; 
					errors['req_'+i]=0;
				}
			}
		}
		for(var i=0;i<emails.length;i++){
			emails[i].s=this;
			emails[i].onchange=function(){
				if(!check_mail(this.value)){ 
					this.style.backgroundColor=this.s.options.errBgColor; 
					errors['emails_'+i]=1;
				}
				else{ 
					this.style.backgroundColor=''; 
					errors['emails_'+i]=0;
				}
			}
		}
		for(var i=0;i<sames.length;i++){
			sames[i].s=this;
			sames[i].onchange=function(){
				if($(this.nextSibling.nodeValue) && $(this.nextSibling.nodeValue).value!=this.value){ 
					this.style.backgroundColor=this.s.options.errBgColor; 
					errors['sames_'+i]=1;
				}
				else{ 
					this.style.backgroundColor=''; 
					errors['sames_'+i]=0;
				}
			}
		}
		
		this.element.afterSubmit=function(){
			var reqs=this.s.getElements('req');
			var emails=this.s.getElements('email');
			var sames=this.s.getElements('same');
			for(var i=0;i<reqs.length;i++){ reqs[i].onblur();}
			for(var i=0;i<emails.length;i++){ emails[i].onchange();}
			for(var i=0;i<sames.length;i++){ sames[i].onchange();}
			err=0;
				for(var i in errors) {
					if(errors[i]==1){ err=1; break;}
				}
			if(err){
				alert(txt_lng['alert_err']);
				return false;
			}
			return true;
		}
	},
	getElements: function(className)
	{
		inputs=this.element.elements;
		return_a=new Array();
		m=0;
		for(i=0;i<inputs.length;i++)
		{
			if(Element.hasClassName(inputs[i],className)) return_a[m++]=inputs[i];
		}
		return return_a;
	},
	addSend: function(){
		this.element.onsubmit=function(){
			var url=this.s.prepareUrl(this,this.s);
			if(this.s.options.XML!=false){
				this.s.changeFields(this,false);
				if(typeof this.afterSubmit!='undefined' && !this.afterSubmit()){
					this.s.changeFields(this,true);
					return false;
				}
				var div=document.createElement('div');
				with(div.style){
					backgroundColor=this.s.options.okBgColor;
					color='#000';
					border='1px solid black';
					position='absolute';
					top='50px';
					left='25px';
					zIndex='1000';
					padding='20px';
					fontWeight='bold';
					fontSize='15px';
					textAlign='center';
				}
				div.innerHTML=txt_lng['pls_whait_sending'];
				this.appendChild(div);
				new Ajax.Request(url[0],{
					parameters:url[1],
					XML:(this.s.options.XML==true?true:false),
					onComplete: (function(xmlhttp)
					{
						if(this.s.options.debug) alert(xmlhttp.responseText);
						if(this.s.options.XML!=2)
						{
							var xmlDoc=getXML(xmlhttp);
						}
						this.s.element.lastChild.innerHTML=txt_lng['sending_done'];
						var buttonOk=document.createElement('input');
						buttonOk.type='button';
						buttonOk.value='Ok';
						with(buttonOk.style)
						{
							backgroundColor='#FFEED3';
							fontSize='15px';
							padding='5px';
							width='70px';
							marginTop='10px';
						}
						buttonOk.s=this.s;
						buttonOk.onclick=function(){
							this.s.changeFields(this.s.element,true);
							this.s.element.reset();
							Element.remove(this.parentNode);
						}
						this.s.element.lastChild.appendChild(document.createElement('br'));
						this.s.element.lastChild.appendChild(buttonOk);
					}).bind(this)
				});
			}
			else if(this.s.options.container){
				new Ajax.Updater(this.s.options.container,url[0],{parameters:url[1]});
			}
			return false;
		}
	},
	changeFields: function(element,active){
		element=$(element);
		var elements=element.elements;
		for(var i=0;i<elements.length;i++){
			if(!active){
				elements[i].disabled=true;
				elements[i].readonly=true;
			}
			else{
				elements[i].disabled=false;
				elements[i].readonly=false;
			}
		}
	},
	prepareUrl: function(element,cl){
		element=$(element);
		/*var elements=element.elements;
		var url=[];
		for(var i=0;i<elements.length;i++){
			if(typeof elements[i]=='undefined' || !elements[i].name || !elements[i].value) continue;
			url.push(elements[i].name+'='+elements[i].value);
		}url.join('&')*/
		u=(cl.options.XML ? cl.options.xmlPath:'')+(cl.options.action ? cl.options.action+cl.options.ext : element.action);
		return [u,Form.serialize(element)];
	}
}

/*---FormSend.js---*/

Event.observe(window,'load',function(e){lnk=false;if($('search_links')){lnk=$('search_links').getElementsByTagName('a');}else if($('user_page_icons')){lnk=$('user_page_icons').getElementsByTagName('a');}if(lnk){for(i=0;i<lnk.length;i++){lnk[i].onmouseover=function(e){if(this.tip){this.tip.showDiv(e);}else{this.tip=new ShowTip(e,this);}return false;}}}});

/*---icon.js---*/

var AddingImage=Class.create();
AddingImage.prototype={
	forms:[],
	element:null,
	options:{},
	container:null,
	nowSending:false,
	iframe:null,
	lastIframe:null,
	template:null,
	
	initialize: function(element,options){
		this.setOptions(options);
		this.element=$(element);
		if(this.element.tagName!='FORM') this.element=this.element.getElementsByTagName('form')[0];
		this.element.target=this.options.iframeName;
		this.element.action=GLOBAL_PATH+this.options.action;
		this.template=$(this.options.oneImage+'0').cloneNode(true);
		this.createContainer();
		this.createIframe();
		this.findForms();
		this.addHidden(element);
		this.addEvent(element);
		if(this.options.endButton) this.addOnEnd(this.options.endButton);
		var self=this;
		window.setInterval(function(){self.submitForm();},2000);
		return true;
	},
	
	setOptions: function(options) {
		this.options = {
			formsClass:'image_loading',
			cointainerId:null,
			iframeName:'_load_in_bg',
			action:'xml_pages/add_image.php',
			alertWrong:'Wrong format.',
			loadingText:'Loading...',
			endButton:null,
			endText:null
		};
		Object.extend(this.options, options || {});
	},
	
	findForms: function(){
		this.forms=document.getElementsByClassName(this.options.formsClass);
	},
	
	createContainer: function(){
		if(!this.container) {
			if(this.options.containerId!=null) this.container=$(this.options.containerId);
			else{
				var div=document.createElement('div');
				this.element.parentNode.appendChild(div);
				this.container=this.element.parentNode.lastChild;
				this.container.appendChild(document.createTextNode(''));
			}
		}
	},
	
	createIframe: function(){
		if(!$(this.options.iframeName)){
			var ifr=document.createElement('iframe');
			ifr.name=this.options.iframeName;
			ifr.id=this.options.iframeName;
			Element.hide(ifr);
			document.getElementsByTagName('div')[0].appendChild(ifr);
			this.iframe=document.getElementsByTagName('div')[0].lastChild;
		}
		else this.iframe=$(this.options.iframeName);
	},
	
	addHidden: function(element) {
		var hidden=document.createElement('input');
		hidden.type='hidden';
		hidden.name='id_item';
		var nowId=document.URL.substr(document.URL.indexOf('id')+3);
		if(nowId.indexOf('&')>-1) nowId=nowId.substr(0,nowId.indexOf('&'));
		hidden.value=nowId;
		$(element).appendChild(hidden);
	},
	
	addEvent: function(element,onlyCheck){
		var element=$(element);
		var fields=element.getElementsByTagName('input');
		var self=this;
		for(var i=0,max=fields.length;i<max;i++){
			if(fields[i].type=='file'){
				fields[i].value='';
				fields[i].onchange=function(){
					var v=this.value;
					if(v.toLowerCase().indexOf('.jpg')>-1||v.toLowerCase().indexOf('.jpeg')>-1){
						self.changeImage(this,onlyCheck);
						if(!onlyCheck){
							self.findForms();
							self.submitForm();
						}
					}
					else{
						alert(self.options.alertWrong);
						this.value='';
					}
				}
			}
			else if(fields[i].type=='submit' && !onlyCheck){
				fields[i].onclick=function(){ return false;}
			}
		}
	},
	
	addOnEnd: function(element){
		var element=$(element);
		var self=this;
		onc=element.onclick;
		element.onclick=function(){
			if( self.container.innerHTML=='' || (self.container.innerHTML!='' && confirm(self.options.endText))){
				onc();
			}
		}
	},
	
	changeImage: function(element,onlyCheck){
		if(onlyCheck) return;
		var now=element.parentNode;
		while(now.tagName!='FORM') now=now.parentNode;
		
		var new_form=now.cloneNode(true);
		this.addEvent(new_form);
		
		Element.addClassName(now,this.options.formsClass);
		Element.hide(now);
		
		now.parentNode.insertBefore(new_form,now);
		var text=document.createElement('div');
		
		text.appendChild(document.createTextNode(element.value));
		
		this.container.appendChild(text);
	},
	
	submitForm: function(){
		doc=this.iframe.contentWindow.document.getElementsByTagName('div');
		if(doc.length>0 && doc[0].firstChild.nodeValue!=this.lastIframe){
			this.lastIframe=doc[0].firstChild.nodeValue;
			this.addImage(doc[0].firstChild.nodeValue);
			this.removeLastSend();
			this.findForms();
			this.nowSending=null;
		}
		if(this.forms.length==0 || this.nowSending) {
			return;
		}
		else{
			this.nowSending=this.forms.pop();
			var self=this;
			this.nowSending.submit();
			var div=document.createElement('div');
			with(div.style){
				backgroundColor='#f00';
				color='#fff';
				border='1px solid black';
				display='inline';
				marginLeft='5px';
				padding='0 5px';
			}
			div.appendChild(document.createTextNode(this.options.loadingText));
			if(this.container.getElementsByTagName('div').length>0)
				this.container.getElementsByTagName('div')[0].appendChild(div);
		}
	},
	
	removeLastSend: function(){
		Element.remove(this.nowSending);
		Element.remove(this.container.getElementsByTagName('div')[0]);
		this.findForms();
	},
	
	addImage: function(id){

		var src_file = id.substring(0,1)+id.substring(1,2)+'/'+id.substring(2,3)+id.substring(3,4);
		var allImages=$(this.options.parentId);
		var oneImage=this.template.cloneNode(true);
		if(!oneImage){
			document.location.href=document.URL;
			return;
		}
		var imgs=oneImage.getElementsByTagName('img');
		for(var i=0,max=imgs.length;i<max;i++){
			if(Element.hasClassName(imgs[i],this.options.imageClassName)){
				//imgs[i].src=this.options.imageSrc[0]+id+this.options.imageSrc[1];
				imgs[i].src=this.options.imageSrc[0]+src_file+'/'+id+this.options.imageSrc[1];
			}
		}
		var as=oneImage.getElementsByTagName('a');
		for(var i=0,max=as.length;i<max;i++){
			if(Element.hasClassName(as[i],this.options.aClassName)){
				as[i].href=this.options.aHref+id;
			}
		}
		oneImage.id=this.options.oneImage+id;
		oneImage.style.display='none';
		allImages.appendChild(oneImage);
		Effect.BlindDown(oneImage);
		for(var i=0,max=this.options.onEnd.length;i<max;i++){
			this.options.onEnd[i](allImages);
		}
	}
	
}

/*---image_add.js---*/

function rr(){MM_swapImgRestore();}
var txt_arr=[]; var search_id=Array('van','ciez','tir','nacz','przy','bus','roln','bud','other','parts','all', 'car','wynaj','woz');
var prev_a=[]; var txt_lng=[]; var RELOAD=false;

function clear_all_inputs(t){var tEl=[];var el=t.elements;for(var i=0,max=el.length;i<max;i++){if(typeof el[i].onchange == 'function' && el[i].name!='r'){tEl[tEl.length]=el[i];}}setTimeout(function(){for(var i=0,max=tEl.length;i<max;i++){tEl[i].onchange();if(tEl[i].value!="" && tEl[i].value!="0" && tEl[i].value!="-1" && tEl[i].name.indexOf('cur')==-1) tEl[i].value="";Element.removeClassName(tEl[i],'selected');}},10);}
function change_engine(start,new_layout){
	typ=ACTUAL-1;
	if (start) 
	{
		$('search_engine').style.display='none';
		if(!new_layout){
			t=$('button_'+search_id[typ]).getElementsByTagName('img')[0];
			t.src=t.src.replace('_off.gif','_on.gif');
		}
	}
	if ((typ+1)==0) return;
	//as=$('search_links').getElementsByTagName('a');
	$('button_'+search_id[typ]).onclick();
}

// typ, this, 'adding', 'search_engine', nr_typu, ilosc, nowy
function change_search(id){
	if(!arguments[5]) Element.show('FORMS');
	if(arguments[4]){ACTUAL=arguments[4];}
	new_layout=false;
	if(arguments[6]){new_layout=true;}
	
	if(g=$('search_engine')){
		g.style.display='';
		if($('search_options_'+ACTUAL)) $('search_options_'+ACTUAL).style.display='';
		Element.show('search_engine_belt'); 
		//if((ACTUAL_LINK && arguments[1].href.indexOf(ACTUAL_LINK)==-1)){return true;}
	}
	
	if(gfh=$('text_chose')) gfh.style.visibility='hidden';
	
	if(arguments.length>1){
		if($('choose_user_type')) Element.show('choose_user_type');
		if(prev_a['id']){ 
			if(new_layout)
			{
				rr();
				var reg=/\s*"([^"]+)"\s*,\s*""\s*,\s*"([^"]+)"\s*,\s*"([^"]+)"\s*,\s*""\s*,\s*"([^"]+)"\s*,\s*"([^"]+)"\s*,\s*""\s*,\s*"([^"]+)"\s*/;
				var matches=reg.exec(prev_a['id'].oldover);
				if(!matches)
				{
					var reg=/\s*'([^']+)'\s*,\s*''\s*,\s*'([^']+)'\s*,\s*'([^']+)'\s*,\s*''\s*,\s*'([^']+)'\s*,\s*'([^']+)'\s*,\s*''\s*,\s*'([^']+)'\s*/;
					var matches=reg.exec(prev_a['id'].oldover+'');
				}
				
				if(matches)
				for(i=1;i<matches.length;i+=2)
				{
					$(matches[i]).src=matches[i+1].replace('_over_','_off_');
					$(matches[i]).oSrc=matches[i+1].replace('_over_','_off_');
				}
				prev_a['id'].onmouseover=prev_a['id'].oldover;
				prev_a['id'].onmouseout=prev_a['id'].oldout;
			}
			else{prev_a['id'].className=prev_a['class'];}
		}
		prev_a['id']=arguments[1];
		prev_a['class']=arguments[3];
		t=arguments[1];
		if(new_layout)
		{
			//rr();
			t.oldover=t.onmouseover; t.onmouseover=function(){};
			t.oldout=t.onmouseout; t.onmouseout=function(){};
			//tutaj zmiana obrazka :(
			var reg=/\s*"([^"]+)"\s*,\s*""\s*,\s*"([^"]+)"\s*,\s*"([^"]+)"\s*,\s*""\s*,\s*"([^"]+)"\s*,\s*"([^"]+)"\s*,\s*""\s*,\s*"([^"]+)"\s*/;
			var matches=reg.exec(t.oldover+'');
			if(!matches)
			{
				var reg=/\s*'([^']+)'\s*,\s*''\s*,\s*'([^']+)'\s*,\s*'([^']+)'\s*,\s*''\s*,\s*'([^']+)'\s*,\s*'([^']+)'\s*,\s*''\s*,\s*'([^']+)'\s*/;
				var matches=reg.exec(t.oldover+'');
			}
			if(matches)
			for(i=1;i<matches.length;i+=2)
			{
				$(matches[i]).src=matches[i+1].replace('_over_','_on_');
				$(matches[i]).oSrc=matches[i+1].replace('_over_','_on_');
			}
			t.blur();
		}
		
		else
		{
			img=t.getElementsByTagName('img')[0];
			if (!img.on) {
				img.off=new Image();
				img.off.src=img.src.replace('_on.gif','_off.gif');
				img.on=new Image();
				img.on.src=img.src.replace('_off.gif','_on.gif');
			}
			if (!img.name){ img.name='image_'+id; }
	
			if(img.oSrc) img.oSrc=img.src;
			img.noChange=true;
			
			t.className=arguments[2];
		}
		
		if($('big_search')){
			if(t.getElementsByTagName('img')[0]){
				$('big_search').src=t.getElementsByTagName('img')[0].src.replace('.gif','_big.gif');
				Element.show('big_search');
			}
			else{
				Element.hide('big_search');
			}
		}

		if(x=$('search_text')){ x.innerHTML=search_txt[ACTUAL]; }
		if(typeof arguments[5]!='undefined' && $('search_amount')){$('search_amount').innerHTML=arguments[5];}
		if(arguments.length>4&&arguments[5]!=null) {change_search_results();}
		else{
			if($('logo')){
				var logoImgs=$('logo').getElementsByTagName('img');
	
				if(logoImgs && logoImgs.length>0){
					if(id=='bus'){Element.show('bushandel-logo');Element.hide('truckhandel-logo');}
					else{Element.hide('bushandel-logo');Element.show('truckhandel-logo');}
				}
			}
		}
	} 
	else prev_a=[];
	
	for(i in search_id){
		if(search_id[i]==id) continue;
		else if(x=document.getElementById('search_'+search_id[i])) x.style.display='none';
	}
	if(id!='clear'){document.getElementById('search_'+id).style.display='';}
	return false;
}

var actual_url=null;var int_count=0;var int_int=0;var last_count=null;var int_mod=1;
var USER_LOGGED=false;var SUBMITED=false;var tb_list=[];var inserted=false;var FORM=null;

function check_value(el,par,typ,txt){change_search_results();d=document; va=el.value;if(va=='') return;switch(typ){case 'int':if(!parseInt(va)){el.select();el.focus(); _create_err(el,par,txt);}else _delete_err(par);break;}}
function _create_err(el,par,txt){d=document;divs=_check_is_div(par);if(divs==false){div=d.createElement('div');div.className='error';div.innerHTML=txt;d.getElementById(par).insertBefore(div,el);}else{divs[0].innerHTML=txt;}}
function _delete_err(par){divs=_check_is_div(par);if(divs==false) return;d=document; par=d.getElementById(par);for(i=0;a=divs[i];i++){if(a.className=='error') par.removeChild(a);}}
function _check_is_div(par){par=$(par); if(!par) return false;divs=par.getElementsByTagName('div');if(divs.length==0) return false;else return divs;}
function addEvent(O,E,F,x){return(x=O.addEventListener)?x(E,F,1):(x=O.attachEvent)?x('on'+E,F):!1;}
function removeEvent(O,E,F,x){return(x=O.removeEventListener)?x(E,F,1):(x=O.dettachEvent)?x('on'+E,F):!1;}
function prepare_url(){d=document; f=d.getElementById('form_search_'+ACTUAL); el=f.elements;url1='xml_pages/search_amount_results.php?';url=[];var c=0;for(i=0;i<el.length;i++){a=el[i];if(!a.name || !a.value || (a.type=='checkbox' && a.checked==false)||a.type=='submit'||a.type=='reset'||a.type=='button'||a.value=='') continue;url[c++]=a.name+'='+a.value;}url=url.join('&');return url1+url;}
function check_logged(){d=document; f=d.getElementById('login_register');if(USER_LOGGED==false){ f.submit(); }if(!d.getElementById('login_register')) return true;return USER_LOGGED;}
function prepare_forms(){d=document; f=d.getElementById('FORMS').getElementsByTagName('form'); t=d.getElementsByTagName('tbody');if(!d.getElementById('choose_user_type')) return true;for(i=0;a=f[i];i++){a.onsubmit=function(){ FORM=this;var actual_submit=null;var ele=this.getElementsByTagName('input');for(var i=0,max=ele.length;i<max;i++){if(ele[i].type=='submit'){actual_submit=ele[i];ele[i].disabled=true;break;}}if(check_logged()) return true; else{actual_submit.disabled=false;window.scrollTo(0,0);return false;}}}ac=0;for(i=0;a=t[i];i++){if(a.className=='user_info') {a.style.display='none';tb_list[ac++]=a;}}}
function sleep(t){t1=new Date();do{t2=new Date()}while(t2.getTime()-t1.getTime()<t);}
function change_yellow(t){change_search_results();if(t.value!=''){if(t.value==0) Element.removeClassName(t,'selected');else Element.addClassName(t,'selected');}else Element.removeClassName(t,'selected');}
function validate_key(v){ v.value=v.value.replace(/[^\d]/gi, '');}
function removeNode(el){ el.parentNode.removeChild(el); }
function check_mail(value){return value.match(/^[a-z][\w\.-]*\w@([\w-]+\.)+[a-z]{2,4}$/ )}
function getElementByClassName(t,cl,all){if(!t) return false;var c=0; var c2=0;if(all) var r=[];while(t.childNodes[c]) {x=t.childNodes[c];if(x.className==cl) if(all) {c2++;r[c2]=x; }else return x;c++;}if(all) return r; return null;}
function imageSwap(IMG,before,after){IMG=$(IMG);if(IMG.noChange) return;if(IMG.oSrc){IMG.src=IMG.oSrc;IMG.oSrc='';return;}IMG.oSrc=img.src;IMG.src=before;return;}
function trim(x){return x.replace(/\s+$|^\s+/g,'' )}
function getXML(x){if (typeof x.responseXML=='object'){if(x.responseXML.xml == '')x.responseXML.loadXML(x.responseText);return x.responseXML;}return null;}
function genXML(x){ return getXML(x);}
function number_format(number,laenge,sep,th_sep ) {var pre = "";if(number < 0){pre = "-";number *= (-1);}number = Math.round( number * Math.pow(10, laenge) ) / Math.pow(10,laenge);str_number = number+"";arr_int = str_number.split(".");if(!arr_int[0]) arr_int[0] = "0";if(!arr_int[1]) arr_int[1] = "";if(arr_int[1].length < laenge){nachkomma = arr_int[1];for(i=arr_int[1].length+1; i <= laenge; i++){nachkomma += "0";}arr_int[1] = nachkomma;}if(th_sep != "" && arr_int[0].length > 3){Begriff = arr_int[0];arr_int[0] = "";for(j = 3; j < Begriff.length ; j+=3){Extrakt = Begriff.slice(Begriff.length - j, Begriff.length - j + 3);arr_int[0] = th_sep + Extrakt +  arr_int[0] + "";}str_first = Begriff.substr(0, (Begriff.length % 3 == 0)?3:(Begriff.length% 3));arr_int[0] = str_first + arr_int[0];}return pre+arr_int[0]+sep+arr_int[1]; }
function SetCookie (name, value) {var argv=SetCookie.arguments;var argc=SetCookie.arguments.length;var expires=(argc>2)?argv[2]:null;var path=(argc>3)?argv[3]:null;var domain=(argc>4)?argv[4]:null;var secure=(argc>5)?argv[5]:false;document.cookie=name+"="+escape(value)+((expires == null)?"":("; expires="+expires.toGMTString()))+((path == null) ? "" : ("; path=" + path))+((domain == null) ? "" : ("; domain=" + domain))+((secure == true) ? "; secure" : "");}
function clearNodes(el){el.innerHTML='';}

var initiatedAjax=false;var newURL=document.URL;var countReload=0;
function ReloadPage(t){if (!initiatedAjax){initResponse();initiatedAjax=true;}url=(t||newURL||document.URL).split('?');url[1]=url[1].replace(/(&_=[^&]*)|(&DYNAMIC=1)/i,'');newURL=url[0]+'?'+url[1];if(countReload==20){document.location.href=newURL;return;}countReload++;new Ajax.Updater('center',url[0],{method:'get',parameters:url[1]+'&DYNAMIC=1',evalScripts:true,onComplete:function(){if(typeof Behaviour=='object') {Behaviour.apply();}}});}
function initResponse(){
	Ajax.Responders.register({
			onCreate: function() {
				if(!$('LOADING'))
				{
					var loading=document.createElement('div'); loading.id='LOADING';
					with(loading.style)
					{
						display='block';position='fixed';
						top='0';right='0';
						backgroundColor='#f00';color='#fff';
						padding='5px';width='150px';
    				}
					loading.innerHTML='�?adowanie...';
					document.body.appendChild(loading);
				}
				else {Element.show('LOADING');}
			},
			onComplete: function() {
				if(Ajax.activeRequestCount == 0){Element.hide('LOADING');}
				if (this.container) this.container=[];
				this.transport.responseText='';
			}
		});
}

/*---index.js---*/

function MM_preloadImages() {var d=document; if(d.images){ if(!d.MM_p) d.MM_p=new Array();var i,j=d.MM_p.length,a=MM_preloadImages.arguments; for(i=0; i<a.length; i++)if (a[i].indexOf("#")!=0){ d.MM_p[j]=new Image; d.MM_p[j++].src=a[i];}}}
function MM_swapImgRestore() {var i,x,a=document.MM_sr; for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) x.src=x.oSrc;}
function MM_findObj(n, d) {var p,i,x;  if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document);if(!x && d.getElementById) x=d.getElementById(n); return x;}
function MM_swapImage(){var i,j=0,x,a=MM_swapImage.arguments; document.MM_sr=new Array; for(i=0;i<(a.length-2);i+=3)if ((x=MM_findObj(a[i]))!=null){document.MM_sr[j++]=x; if(!x.oSrc) x.oSrc=x.src; x.src=a[i+2];}}

/*---MM_functions.js---*/

var COUNTER=0;
var toChanged=[];
function notes_prepare_links(height, ADD_ADD_COMMENT){
	d=document; tb=d.getElementById('offer_list'); trs=tb.getElementsByTagName('tr');
	var changed=document.getElementsByClassName('item_list_diff');
	for(i=0,max=changed.length;i<max;i++){
		if(changed[i].firstChild && changed[i].firstChild.nodeValue)
			toChanged.push(changed[i]);
	}
	setInterval(function(){
		COUNTER++;
		for(var i=0,max=toChanged.length;i<max;i++){
			new Effect.Opacity(toChanged[i],
				{
					from:(COUNTER%2?1.0:0.0),
					to:(COUNTER%2?0.0:1.0),
					duration:0.4
				}
			);
		}
	},600);
	for(i=0;a=trs[i];i++){
		divs=a.getElementsByTagName('div');
		for(g=0;b=divs[g];g++){
			if(b.className=='item_list_add_to_notes'){
				if(x=b.getElementsByTagName('a')[1]) x.onclick=remove_notes;
				if(x=b.getElementsByTagName('a')[2]) x.onclick=show_comment;
				h=b.getElementsByTagName('a')[0];
				h.onclick=function() {
					stop_click(this);
					this.blur();
					
					var div2=document.createElement('div');
					div2.style.position='relative'
					var div=document.createElement('div');
					with(div.style){
						position='absolute';
						top='10px';
						backgroundColor='#f00';
						color='#fff';
						padding='5px';
					}
					div.appendChild(document.createTextNode(txt_lng['adding']));
					div2.appendChild(div);
					this.parentNode.insertBefore(div2,this);
					var tid=this.href.substring(this.href.indexOf('id=')+3);
					var t=this;
					if(document.getElementById('notes_a')){
						if(x=$('notes_a').getElementsByTagName('a')[0]) x.style.display='';
						if(x=getElementByClassName($('notes_a'),'clear_notes')) x.style.display='';
						if(x=getElementByClassName($('notes_a'),'add_email')) x.style.display='';
					}
					
					with_function('xml_pages/add_to_notes.php?item='+tid,function(xmlDoc){
						var root=xmlDoc.getElementsByTagName('root')[0];
						var notes=root.getElementsByTagName('notes')[0];
						
						var n_id=notes.getAttribute('n_id');
						var n_price=notes.getAttribute('price');
						var n_currency=notes.getAttribute('currency');
						var p=t.parentNode;
						var tr=p.parentNode.parentNode;
						tr.className+=' item_in_notes';
						var notes_c=$('notes_c');
						if(notes_c){
							if(x=parseInt(notes_c.firstChild.nodeValue)){
								notes_c.firstChild.nodeValue=(x==0?1:++x);
							}
							else{
								notes_c.firstChild.nodeValue=1;//document.createTextNode('1'));
							}
						}
						var n=p.nextSibling;
						var nc=n.childNodes;
						
						
						for(j=0;c=nc[j];j++){
							if(c.className=='notes_price'){
								if(c.firstChild&&c.firstChild.nodeValue)
									c.firstChild.nodeValue=n_price;
								else
									c.appendChild(document.createTextNode(n_price));
							}
							else if(c.className=='notes_currency'){
								if(c.firstChild&&c.firstChild.nodeValue)
									c.firstChild.nodeValue=n_currency;
								else
									c.appendChild(document.createTextNode(n_currency));
							}
						}
						
						if(!ADD_ADD_COMMENT)
						{if(!p.getElementsByTagName('a')[1]){
							//t.firstChild.nodeValue=txt_lng['change_price'];
							t.style.display='none';
							na2=document.createElement('a');
							na2.href=t.href.replace('add_to_notes','del_from_notes');
							na2.onclick=remove_notes;
							na2.style.marginLeft='5px';
							na2.appendChild(document.createTextNode(txt_lng['del_from_notes']));
							p.appendChild(na2);
						}
						}
						else{
						if(!p.getElementsByTagName('a')[2]){
							//t.firstChild.nodeValue=txt_lng['change_price'];
							t.style.display='none';
							na3=document.createElement('a');
							na3.href=document.baseURI;
							na3.onclick=show_comment;
							na3.style.marginLeft='5px';
							na3.appendChild(document.createTextNode(txt_lng['add_comment']));
							p.appendChild(na3);
						}}
						Element.remove(t.previousSibling);
					});
					restart_click(this);
					return false;
				}
			}
			else if(b.className=='item_list_form'){
				b.getElementsByTagName('input')[0].onclick=function(){
					stop_click();
					t=this;
					par=t.parentNode;
					vv=par.getElementsByTagName('textarea')[0].value;
					v=vv.replace("\n",'<br>');
					//vv.split("\n");
					var par_prev=par.previousSibling;
					ppar=par.parentNode;
					dnot=getElementByClassName(ppar,'item_list_add_to_notes');
					var tid=dnot.getElementsByTagName('a')[0].href;
					tid=tid.substring(tid.indexOf('id=')+3);
					//x=dnot.getElementsByTagName('a')[2].firstChild;
					//if(v.length==0 || trim(vv)=='') x.nodeValue=txt_lng['add_comment'];
					//else x.nodeValue=txt_lng['edit_comment'];
					xmlMethod='post';
					xmlSend="desc="+v+"&item="+tid;
					
					//with_function('xml_pages/notes_add_comment.php',
					new Ajax.Request('/xml_pages/notes_add_comment.php',{parameters:xmlSend,onSuccess:function(x){
						//alert(x.responseText);
						var notes=getElementByClassName(par_prev,'notes_user');
						//removeAllNodes(notes);
						/*notes.appendChild(document.createElement('br'));
						for(h=0;h<v.length;h++){
							b=v[h];
							notes.appendChild(document.createTextNode(b));
							notes.appendChild(document.createElement('br'));
						}*/
						notes.innerHTML=v;
						par.style.display='none';
					},onFailure:function(){alert('b');}});
					restart_click();
					return false;
				}
				b.getElementsByTagName('input')[2].onclick=function(){
					stop_click();
					this.parentNode.style.display='none';
				}
				b.getElementsByTagName('input')[1].onclick=function(){
					stop_click();
					this.blur();
					x=this.parentNode.getElementsByTagName('textarea')[0];
					x.value='';
					x.focus();
				}
			}
		}
	}
}

function show_comment(){
	stop_click(this);
	this.blur();
	par=this.parentNode;
	ppar=par.parentNode;
	fnot=getElementByClassName(ppar,'item_list_form');
	fnot.style.display='';
	fnot.getElementsByTagName('textarea')[0].onclick=stop_click;
	fnot.getElementsByTagName('textarea')[0].focus();
	restart_click(this);
	return false;
}

function remove_notes(){
	stop_click(this);
	tid=this.href.substring(this.href.indexOf('id=')+3);
	par=this.parentNode;
	tr=par.parentNode.parentNode;
	next=par.nextSibling;
	next_c=next.childNodes;
	prev=this.previousSibling;
	first=par.getElementsByTagName('a')[0];
	if(par.getElementsByTagName('a')[2]) removeNode(par.getElementsByTagName('a')[2]);
	removeNode(this);
	first.style.display='';
	clearNodes(next);
	if(next)
	{
		br=next.getElementsByTagName('br');
		for(var i=0,max=br.length;i<max;i++) Element.remove(br[i]);
	}
	prev.style.display='';
	tr.className=tr.className.replace('item_in_notes','');
	var notes_c=$('notes_c');
	
	if(notes_c) {
		if(x=parseInt(notes_c.firstChild.nodeValue)){
			notes_c.firstChild.nodeValue=--x;
			if(x==0 && document.getElementById('notes_a')) {
				document.getElementById('notes_a').getElementsByTagName('a')[0].style.display='none';
				getElementByClassName(document.getElementById('notes_a'),'clear_notes').style.display='none';
				//getElementByClassName(document.getElementById('notes_a'),'add_email').style.display='none';
			}
		}
		else{
			notes_c.appendChild(document.createTextNode('0'));
			if(document.getElementById('notes_a'))
			{
				document.getElementById('notes_a').getElementsByTagName('a')[0].style.display='none';
				getElementByClassName(document.getElementById('notes_a'),'clear_notes').style.display='none';
			}
		}
	}
	with_function('xml_pages/del_from_notes.php?item='+tid,function(){});
	restart_click(this);
	return false;
}
function stop_click(el){CLICKED=true;} function restart_click(el){}

/*---notes_actions.js---*/

function prepare_notes_footer(){
	d=document;
	nd=d.getElementById('notes');
	if(x=getElementByClassName(nd,'show_notes')){
		x.onclick=function(){
			this.blur;
			v=this.firstChild.nodeValue;
			vn=v.replace('>>>','').replace('<<<','');
			vn2='<<<'+vn;
			vn3=vn+'>>>';
			tbs=this.parentNode.getElementsByTagName('table')[0].style;
			if(tbs.display=='none'){
				tbs.display='inline';
				this.firstChild.nodeValue=vn2;
				with(this.style){
					position='relative';
					top='-3px';
					borderLeft='1px solid black';
					paddingLeft='3px';
				}
			}
			else{
				tbs.display='none';
				with(this.style){
					position='';
					top='';
					borderLeft='0';
					paddingLeft='0';
				}
				this.firstChild.nodeValue=vn3;
			}
			this.blur();
			return false;
		}
	}
	na=d.getElementById('notes_a');
	nah=na.getElementsByTagName('a');
	for(i=0;a=nah[i];i++){
		switch(a.className){
			case 'clear_email':
				a.onclick=notes_clear_email;
			break;
			
			case 'add_email':
				a.onclick=notes_add_email;
			break;
			
			case 'clear_notes':
			
			break;
		}
	}
}

function notes_clear_email(){
	this.blur();
	t=this;
	with_function('xml_pages/notes_add_email.php?email=null',function(){
		par=t.parentNode;
		em=getElementByClassName(par,'notes_email');
		em_d=getElementByClassName(em,'data');
		if(x=em_d.firstChild && x.nodeValue) x.nodeValue='';
		em.style.display='none';
		t.style.display='none';
		if(x=getElementByClassName(par,'add_email')) x.style.display='';
		else{
			ah=document.createElement('a');
			ah.href='./?';
			ah.className='add_email';
			ah.appendChild(document.createTextNode(txt_lng['add_email']));
			ah.onclick=notes_add_email;
			par.insertBefore(ah,t);
		}
	});
	return false;
}

function notes_add_email(){
	this.blur();
	par=this.parentNode;
	this.style.display='none';
	f=getElementByClassName(par,'add_email_form');
	if(!f){
		form=document.createElement('form');
		form.className='add_email_form';
//		form.style.float='left';
		form.style.margin='0';
		form.style.display='inline';
		form.style.position='relative';
		form.onsubmit=function(){
			email=getElementByClassName(this,'email');
			if(!check_mail(email.value)){
				email.select();
				email.focus();
				email.style.backgroundColor='#ff0';
				div=document.createElement('div');
				div.style.position='absolute';
				div.style.backgroundColor='#f00';
				div.style.color='#fff';
				div.style.border='1px solid #ff0';
				div.style.padding='5px';
				div.style.fontWeight='bold';
				div.style.top='14px';
				div.style.left='5px';
				div.appendChild(document.createTextNode(txt_lng['err_wrong_email']));
				div.className='err_email';
				this.insertBefore(div,email);
				return false;
			}
			t=this;
			with_function('xml_pages/notes_add_email.php?email='+email.value,function(){
				par=t.parentNode;
				if(x=getElementByClassName(par,'clear_email')) x.style.display='';
				else{
					ah=document.createElement('a');
					ah.href='./?';
					ah.className='clear_email';
					ah.appendChild(document.createTextNode(txt_lng['clear_email']));
					ah.onclick=notes_clear_email;
					par.insertBefore(ah,t);
				}
				
				em=getElementByClassName(par,'notes_email');
				em_d=getElementByClassName(em,'data');
				if(x=em_d.firstChild && x.nodeValue) x.nodeValue='';
				clearNodes(em_d);
				em_d.innerHTML='';
				em_d.appendChild(document.createTextNode(email.value));
				em.style.display='';
				removeNode(t);
			});
			return false;
		}
		em=document.createElement('input');
		em.type='text';
		em.className='email';
		em.value=txt_lng['add_email_your_email'];
		em.onkeydown=function(e){
			e=e||event;
			key=e.keyCode;
			if(key==27){
				getElementByClassName(this.parentNode,'cancel').onclick();
			}
		}
		em.onblur=function(){
			this.style.backgroundColor='#fff';
			if(x=getElementByClassName(this.parentNode,'err_email'))
				removeNode(x);
		}
		sb=document.createElement('input');
		sb.type='submit';
		sb.value=txt_lng['add_email_ok'];
		cn=document.createElement('input');
		cn.type='button';
		cn.value=txt_lng['add_email_cancel'];
		cn.className='cancel';
		cn.onclick=function(){
			p=this.parentNode;
			pp=p.parentNode;
			p.style.display='none';
			getElementByClassName(pp,'add_email').style.display='';
		}
		form.appendChild(em);
		form.appendChild(sb);
		form.appendChild(cn);
		par.insertBefore(form,this);
		f=getElementByClassName(par,'add_email_form');
	}
	f.style.display='inline';
	x=getElementByClassName(f,'email');
	x.select();
	x.focus();
	return false;
}

/*---notes_footer.js---*/

var txt_lng=[];
var field_err=null;

function init_recovery(){
	var d=document;
	/*d.getElementById('recovery_a').onclick=function(){
		if(x=document.getElementById('recovery')){
			this.blur();
			if(x.style.display==''){
				x.style.display='none';
				this.parentNode.getElementsByTagName('form')[0].elements[0].focus();
				if(this.oC) this.className=this.oC;
				if(this.PoC) this.parentNode.className=this.PoC;
				this.parentNode.onclick=null;
			}
			else{
				this.PoC=this.parentNode.className;
				this.parentNode.className+=' register_text';
				x.style.display='';
				if(z=x.getElementsByTagName('form')[0])
					z.elements[0].focus();
				this.oC=this.className;
				this.className+=' recovery_showed';
				setTimeout(function(){document.getElementById('recovery_a').parentNode.onclick=function(){
					document.getElementById('recovery_a').onclick();
				}},1000);
			}
			return false;
		}
	}*/
	/*d.getElementById('recovery_b').onclick=function(){
		document.getElementById('recovery_a').onclick();
	}*/
	
	
	f=d.getElementById('recovery_form').getElementsByTagName('form')[0];
	d.getElementById('rec_email').onblur=function(){
		if(this.value!=''&&!check_mail(this.value)){
			create_err(this,'err_mail');
		}
		else if(this.value==''){
			create_err(this,'err_mail_empty');
		}
		else{
			remove_err(this);
		}
	};

	/*
	d.getElementById('rec_tel').onblur=function(){
		if(this.value==''){
			create_err(this,'err_tel');
		}
		else{
			remove_err(this);
		}
	};
	*/

	f.onsubmit=function(){
		r=document.getElementById('rec_sub');
		r.blur();

		ln=this.getElementsByTagName('input')[0];
		//em=this.getElementsByTagName('input')[1];
		em = document.getElementById('rec_email');

		if(field_err){
			field_err.focus();
			return false;
		}
	
		var c=document.createElement('div');
		c.appendChild(document.createTextNode('Proszę czekać...'));
		c.id='waiting';
		this.parentNode.insertBefore(c,this);
		g=this.elements;
		for(i=0;a=g[i];i++){
			g.readonly=true;
			g.disabled=true;
		}
		
		with_function('xml_pages/check_email_nr.php?email='+em.value,function(xmlDoc,xmlhttp){
			root=xmlDoc.getElementsByTagName('root')[0];
			result=root.getElementsByTagName('result')[0];
			email=result.getElementsByTagName('email')[0];
			email_nr=result.getElementsByTagName('email_nr')[0];
	
			Element.remove('waiting');

			z=document.getElementById('recovery_form').getElementsByTagName('form')[0];
			g=z.elements;
			for(i=0;a=g[i];i++){
				g.readonly=false;
				g.disabled=false;
			}
			

			
			if(!email.firstChild || email.firstChild.nodeValue==0){
				create_err(em,'email_no_in_base');
				return false;
			}
			else remove_err(em);
			/*
			if(!email_nr.firstChild || email_nr.firstChild.nodeValue==0){
				create_err(nr,'tel_no_for_email');
				return false;
			}
			else remove_err(nr);
			*/
			
			
			var div=document.createElement('div');
			div.style.fontWeight='bold';
			div.style.fontSize='15px';
			div.style.padding='5px';
			div.style.border='1px solid black';
			div.style.width='230px';
			div.style.backgroundColor='#fff';
			div.style.margin='10px auto';
			div.style.color='green';
			div.appendChild(document.createTextNode(txt_lng['send']));
			z.parentNode.insertBefore(div,z);
			z.parentNode.removeChild(z);
		});
		return false;
	}
}

function create_err(field,txt){
//	field.focus();
	var sp=document.createElement('div');
	var com=document.createTextNode(txt_lng[txt]);
	sp.style.color='#f00';
	sp.style.fontSize='11px';
	sp.appendChild(com);
	field.style.backgroundColor='#dff';
	if(!field.iC){
		field.parentNode.insertBefore(sp,field);
		field.iC=sp;
	}
	field_err=field;
}
function remove_err(field){
	if(field.iC) field.parentNode.removeChild(field.iC);
	field.iC=null;
	field.style.backgroundColor='';
	field_err=null;
}
/*---recovery.js---*/

var glob_interval=null;
function change_search_results(){if(NOT_AJAX) {NOT_AJAX=0;return;}if(typeof this.onc!='undefined') this.onc();int_count++; int_mod=1;var url=GLOBAL_PATH+prepare_url();url=url.split('?');new Ajax.Request(url[0],{method:'post',parameters:url[1],onSuccess: function(xml){$('actual_results_'+ACTUAL).innerHTML=xml.responseText;}});}
function change_search_results2(){int_count++; int_mod=10; change_search_results();}
function _interval_change(){if(int_int>10) int_int=0;if(int_mod>1 && ++int_int%int_mod!=0) return;if(int_count>last_count){url=prepare_url();with_function(url,function(){document.getElementById('actual_results').innerHTML=xmlDoc.getElementsByTagName('root')[0].getElementsByTagName('amount_search')[0].firstChild.nodeValue;});last_count=int_count;}}
var countingChange = {onCreate: function(){Element.show('counting_'+ACTUAL);},onComplete: function(){if(Ajax.activeRequestCount == 0){Element.hide('counting_'+ACTUAL);}}}
Ajax.Responders.register(countingChange);

/*---search.js---*/

var act_img=null; var loaded_img=[]; var now_loaded=null; var imgs=[]; var sgmi=[]; var global=[]; var int_checking=null;
function checking_loaded(){if(!int_checking){show_window_loading();int_checking=setInterval('checking_loaded()',200);}for(var i=0,max=preload.length;i<max;i++){if(!preload[i].done){ document.getElementsByClassName('counter_images')[0].firstChild.nodeValue=i;return; }}cancel_interval();$('big_click').onclick();return;}
function cancel_interval(){clearInterval(int_checking);int_checking=null;lo=document.getElementsByClassName('LOADING');for(var i=0,max=lo.length;i<max;i++){Element.remove(lo[i]);}$('big_click').onclick=$('big_click').oOnClick;$('big_click').oOnClick=null;}
function show_window_loading(){var div=document.createElement('div');with(div.style){position='absolute';zIndex='1000';top='0px';left='0px';backgroundColor='#f00';color='#fff';}div.appendChild(document.createTextNode(txt_lng['loading_image_1']));var sub_div=document.createElement('span');sub_div.appendChild(document.createTextNode('0'));sub_div.className='counter_images';var sub_div2=document.createElement('span');sub_div2.appendChild(document.createTextNode('/ '+preload.length+' '));div.appendChild(sub_div);div.appendChild(sub_div2);div.appendChild(document.createTextNode(txt_lng['loading_image_2']));div.className='LOADING';$('big_click').oOnClick=$('big_click').onclick;$('big_click').onclick=function(){return false;};$('big_click').parentNode.appendChild(div);}
function show_image_window(){
	if(preload.length==0) return false;
	if(preload && preload.length>0){for(var i=0,max=preload.length;i<max;i++){if(!preload[i].done){global['arg0']=arguments[0];global['arg1']=arguments[1];global['arg2']=arguments[2];checking_loaded();return false;}}}
	d=document; par=$('big_images'); //dla zachowania kompatybilnosci
	
	$('img_loading').style.display='none';
	par.innerHTML=''; ex=(arguments[0]||global['arg0']);
	
	m=(arguments[1]||global['arg1'])+ex; b=(arguments[2]||global['arg2'])+ex;
	var c=document.createElement('div'); //all container
	c.id="CONTAINER";
	with(c.style){padding='10px';text='center';paddingTop='0';}
	
	var bi=document.createElement('img'); //big image
	bi.src=act_img+b;
	
	/* <START Komentarz, pierwszy obrazek > */
	var prev_comm_prev=document.createElement('div');
	var prev_comm=document.createElement('div');
	with(prev_comm.style){width='250px';display='none';position='absolute';left='285px';backgroundColor='#ff0';fontSize='13px';fontWeight='bold';}
	
	var prev_comm_span=document.createElement('span');
	prev_comm_span.appendChild(document.createTextNode(txt_lng['this_is_first_image']));
	prev_comm_span.style.padding='5px';
	
	prev_comm.appendChild(prev_comm_span);
	prev_comm_prev.appendChild(prev_comm);
	
	new Effect.Opacity(prev_comm,{from:0.7,to:0.7});
	/* </START> */
	
	
	/* <START Komentarz, ostatni obrazek > */
	var next_comm_prev=document.createElement('div');
	var next_comm=document.createElement('div');
	var next_comm_span=document.createElement('span');
	next_comm_span.appendChild(document.createTextNode(txt_lng['this_is_last_image']));
	next_comm_span.style.padding='5px';
	
	with(next_comm.style){width='250px';display='none';position='absolute';backgroundColor='#ff0';left='285px';fontWeight='bold';fontSize='13px';}
	
	next_comm.appendChild(next_comm_span);
	next_comm_prev.appendChild(next_comm);
	
	new Effect.Opacity(next_comm,{from:0.7,to:0.7});
	/* </START> */
	
	small_img=document.createElement('div'); //small images container
	small_img.style.margin='10px';
	
	aa=-1; small_images=0; //count of images
	for(var i=3;a=arguments[i];i++){
		imgs[aa++]=a+b; sgmi[a+b]=aa;
		span=document.createElement('span');//image parent
		span.style.cursor='pointer';
		span.onclick=function(){
			im=this.getElementsByTagName('img')[0].title;
			spans=this.parentNode.getElementsByTagName(this.tagName);
			for(var ii=0,max=spans.length;ii<max;ii++) {
				aa=spans[ii];
				aa.getElementsByTagName('img')[0].className='small_image_no_active';
			}
			this.getElementsByTagName('img')[0].className='small_image_active';
			now_loaded=sgmi[im];
			if(!loaded_img[im]){
				var tmp2=c.getElementsByTagName('div')[1]; tmp2.style.display='';
				loaded_img[im]=new Image; loaded_img[im].src=im;
				bi.src=im;
				bi.onload=function(){
					tmp2.style.display='none'; this.width=loaded_img[im].width;
					this.height=loaded_img[im].height; return true;
				}
			}
			else{with(bi){src=loaded_img[im].src;width=loaded_img[im].width;height=loaded_img[im].height;}}
			
			if(now_loaded>0) d.getElementById('prev').style.visibility='visible';
			else d.getElementById('prev').style.visibility='hidden';
			
			if(now_loaded<imgs.length) d.getElementById('next').style.visibility='visible';
			else d.getElementById('next').style.visibility='hidden';
		}
		img=document.createElement('img');
		img.src=a+m; img.title=a+b;
		span.appendChild(img); small_img.appendChild(span);
		small_img.appendChild(document.createTextNode(' ')); small_images++;
	}
	
	now_loaded=sgmi[act_img+b];
	
	ah=document.createElement('a'); //close link
	ah.href='javascript:void(0);';
	ah.onclick=function(){
		Effect.BlindUp(par,{scaleMode:'contents',scaleX:true,scaleContent:true,duration:0.5})
		window.scrollTo(0,0); 
		Event.stopObserving(document,'keydown',bodyObserver);
		return false;
	};
	
	with(ah.style){fontSize='17px';textAlign='right';display='block';position='absolute';right='0';top='0';}
	ah.appendChild(document.createTextNode(txt_arr['close']+' [x]'));
	
	
	ah2=document.createElement('a'); //next link
	ah2.id='next';
	ah2.href='javascript:void(0);';
	ah2.appendChild(document.createTextNode(txt_arr['next']));
	ah2.onclick=
	function(e){
		if(now_loaded<imgs.length){
			if(c.getElementsByTagName('span')[now_loaded+1])
				c.getElementsByTagName('span')[now_loaded+1].onclick();
		}
		else{
			if(next_comm.effect) next_comm.effect.cancel();
			if(prev_comm.effect) prev_comm.effect.cancel();
			next_comm.effet=Effect.Appear(next_comm,{
				duration:0,//czas pokazywania
				from:.2,to:.7,
				afterFinish:function(effect){
					setTimeout(function(){Effect.Fade(effect.element);},1000);//czas ile jest pokazany
				}
			});
		}
	}
	
	ah3=document.createElement('a'); //prev link
	ah3.id='prev';
	ah3.href='javascript:void(0);';ah3.appendChild(document.createTextNode(txt_arr['prev']));
	ah3.onclick=
	function(e){
		if(now_loaded>0){
			if(c.getElementsByTagName('span')[now_loaded-1])c.getElementsByTagName('span')[now_loaded-1].onclick();
		}
		else{
			if(prev_comm.effect) prev_comm.effect.cancel();
			if(next_comm.effect) next_comm.effect.cancel();
			prev_comm.effet=Effect.Appear(prev_comm,{
				duration:0,//czas pokazywania
				from:.2,to:.7,
				afterFinish:function(effect){
					setTimeout(function(){Effect.Fade(effect.element);},1000);//czas ile jest pokazany
				}
			});
		}
	}

	c.appendChild(document.createElement('br'));
	
	var cl=ah.cloneNode(true);
	cl.onclick=ah.onclick;
	with(cl){name='close_2';id='close_2';}
	with(cl.style){top='';bottom='0px';}

	ah.style.margin='0';c.appendChild(ah);
	c.appendChild(ah3);c.appendChild(document.createTextNode(' '));
	c.appendChild(ah2);c.appendChild(small_img);
	
	
	if(small_images<2 || small_img.getElementsByTagName('img').length<2){Element.hide(small_img);}
	else{c.appendChild(document.createTextNode(txt_arr['arrows_desc']));c.appendChild(document.createElement('br'));}

	ld=document.createElement('div');
	with(ld.style){position='absolute';display='none';backgroundColor='#f00';color='#fff';}
	c.appendChild(ld);c.appendChild(prev_comm_prev);c.appendChild(next_comm_prev);bi.style.marginBottom='0';
	c.appendChild(bi);cl.style.backgroundColor='#fff';c.appendChild(cl);
	
	with(c.style){textAlign='center';paddingTop='0';paddingBottom='0';}
	with(par.style){paddingTop='0';paddingBottom='15px';width='820px';zIndex='10000';}
	par.appendChild(c);
	
	Effect.BlindDown(par,{scaleX:true,/*scaleContent:true,*/duration:0.3,
		afterFinish: function(effect) {Element.undoClipping(effect.element);oPos=getAnchorPosition('big_images');pPos=getAnchorPosition('close_2');window.scrollTo(oPos.x, pPos.y);}
	}); 
	c.getElementsByTagName('span')[now_loaded].onclick();
	Event.observe(document,'keydown',bodyObserver);
}
function prev_click(e){var c=$('CONTAINER');if(now_loaded>0){if(c.getElementsByTagName('span')[now_loaded-1])c.getElementsByTagName('span')[now_loaded-1].onclick();}}
function next_click(e){var c=$('CONTAINER');if(now_loaded<imgs.length){if(c.getElementsByTagName('span')[now_loaded+1])c.getElementsByTagName('span')[now_loaded+1].onclick();}}
function change_image(im){d=document; i=d.getElementById('thb_img'); ld=d.getElementById('img_loading');ld.style.display='';i.src=im;i.onload=function(){$('img_loading').style.display='none'; return true;};act_img=im.replace('_fit.jpg','');}
function bodyObserver(e){e=e||event;key=e.keyCode;d=document;var c=$('big_images').getElementsByTagName('div')[0];if(key==39){ $('next').onclick();}else if(key==37){$('prev').onclick();}else if(key==27){c.getElementsByTagName('a')[0].onclick();}}

/*---show_images.js---*/

var SmartyAjax = {
  update: function(update_id, url, method, params, callback) {var myAjax = new Ajax.Updater(update_id,url,{method: method,parameters: params,onComplete: callback});},
  call: function(url, method, params, callback, params_func) {if (params_func) {if (params.length != 0) params += "&";params += $H(params_func()).toQueryString();}var myAjax = new Ajax.Request(url,{method: method,parameters: params,onComplete: callback});},
  submit: function(form, params, callback) {var myAjax = new Ajax.Request(form.action,{method: form.method,parameters: Form.serialize(form.id),onComplete: callback || this.onSubmit});},
  onSubmit: function(originalRequest) {var results = originalRequest.responseText.split(";");if (results[0] == "true") {SmartyAjax.Messages.set(results[1], SmartyAjax.Messages.MT_WARNING);} else {SmartyAjax.Messages.clear();SmartyAjax.Messages.setType(SmartyAjax.Messages.MT_ERROR);for (var i = 1; i < results.length; i++) {SmartyAjax.Messages.add(results[i]);}}}
}
SmartyAjax.GlobalHandlers = {
	onCreate: function() {SmartyAjax.Process.show();},
	onComplete: function() {if(Ajax.activeRequestCount == 0){SmartyAjax.Process.hide();}}
};
Ajax.Responders.register(SmartyAjax.GlobalHandlers);
SmartyAjax.Messages = {
  MT_WARNING: 0, MT_ERROR: 1,
  S_MT_WARNING: "Please note:", S_MT_ERROR: "Please fix following errors:",
  initialize: function() {this.messages = $("messages");this.messagesTitle = $("messages-title");},
  clear: function() {if (!this.messagesList) {this.messagesList = $("messages-list");if (!this.messagesList) return;}this.messagesList.innerHTML = "";this.messagesList.style.display = "none";},
  add: function(message) {if (!this.messagesList) {this.messagesList = $("messages-list");if (!this.messagesList) return;}var messageLI = document.createElement("LI");messageLI.innerHTML = message;this.messagesList.appendChild(messageLI);this.messagesList.style.display = "block";Element.scrollTo("messages");},
  set: function(message, type) {this.clear();this.setType(type);this.add(message);},
  setType: function(type) {if (!this.messages) this.messages = $("messages");if (!this.messagesTitle) this.messagesTitle = $("messages-title");switch (type) {case this.MT_ERROR:if (this.messages) this.messages.className = "data-error";if (this.messagesTitle) this.messagesTitle = this.S_MT_ERROR;break;case this.MT_WARNING:default:if (this.messages) this.messages.className = "data-warning";if (this.messagesTitle) this.messagesTitle = this.S_MT_WARNING;}}
}
SmartyAjax.Process = {
  S_PROCESS: "processing request...",
  show: function() {if (!this.process) {this.process = $("ajax-process");if (!this.process) return;}var top = window.pageYOffset ? window.pageYOffset : document.documentElement ? document.documentElement.scrollTop : document.body.scrollTop;this.process.style.top = top + "px";this.process.innerHTML = this.S_PROCESS;this.process.style.display = "inline";},
  hide: function() {if (!this.process) {this.process = $("ajax-process");if (!this.process) return;}this.process.style.display = "none";}
}

/*---smarty_ajax.js---*/

var glob_options={};
function listSortingStart(list){
	options={onUpdate:function(){sorting_update(list);},onStart:hide_arrows,handle:'image',tag:'div',snap:function(x,y,draggable) {
      function constrain(n, lower, upper) {
        if (n > upper) return upper;
        else if (n < lower) return lower;
        else return n;
      }
     
      element_dimensions = Element.getDimensions(draggable.element);
      parent_dimensions = Element.getDimensions(draggable.element.parentNode);
      return[
        constrain(x, 0, parent_dimensions.width - element_dimensions.width),
        constrain(y, 0, parent_dimensions.height - element_dimensions.height)];
    },revert:true};
	Object.extend(glob_options, options || {});Sortable.create(list,glob_options);}
function sorting_update(element){url=document.URL;id=url.substr(url.indexOf('id'));new Ajax.Request(GLOBAL_PATH+'xml_pages/update_images_sort.php',{parameters:id+'&'+Sortable.serialize(element),onComplete: function(x){/*new Effect.Highlight(element,{duration:0.8});/**/}});/**/hide_arrows(element,glob_options,true);/**/}
function hide_arrows(element,options,create_sort)
{
	arrows=document.getElementsByClassName('item_arrows'); 
	cr=0;
	for(i=0,max=arrows.length;i<max;i++)
	{
		a=arrows[i].getElementsByTagName('img');
		for(g=0,maxG=a.length;g<maxG;g++)
		{
			b=a[g];tag=b.parentNode.tagName;
			if(tag=='A' || tag=='a')
			{ 
				c=b.cloneNode(true);
				td=b.parentNode.parentNode;
				td.insertBefore(c,b.parentNode);
				removeNode(b.parentNode);
			}
			else c=b;
			
			img=c;
			
			var src=img.src.replace('_b.gif','.gif').replace('_a.gif','.gif');
			var top=(src.indexOf('top')>-1?true:false);
			var up=(src.indexOf('up')>-1?true:false);
			var down=(src.indexOf('down')>-1?true:false);
			var bottom=(src.indexOf('bottom')>-1?true:false); 
			t=c;
			while(t.tagName!=options.tag.toUpperCase()) 
			{ 
				t=t.parentNode;
			}
			Element.cleanWhitespace(t.parentNode);
			Element.cleanWhitespace(c);
			Element.cleanWhitespace(t);
			prev=(t&&t.previousSibling&&t.previousSibling.tagName==t.tagName&&t.previousSibling.id!='img_0'?true:false);
			next=(t&&t.nextSibling&&t.nextSibling.tagName==t.tagName?true:false); 
			img.src=src;
			c.t=t;
			if ( ( i==0 || i==(max-1) ) && ( (!prev&&(top||up)) || (!next&&(bottom||down))	) ) 
			{	
				img.src=src.replace('.gif','_b.gif');
			}
			else if(c.src.indexOf('_b.gif')==-1)
			{ 
				with(c.style) cursor='pointer';
				c.element=element; 
				c.onmouseover=arrow_over; 
				c.onmouseout=arrow_out;
				if(up) if(t&&t.previousSibling) c.onclick=move_up;
				else if(top) if(t&&t.previousSibling) c.onclick=move_top;
				else if(down) if(t&&t.nextSibling) c.onclick=move_down;
				else if(bottom) if(t&&t.nextSibling) c.onclick=move_bottom; 
			}
		}
	}
	
	if(create_sort==true)
	{ 
		setTimeout(function()
		{
			Sortable.create(element,options);
		},1000);
	}
}
function move_up(){par_new=this.t.cloneNode(true);par=this.t;par.parentNode.insertBefore(par_new,par.previousSibling);removeNode(par);sorting_update(this.element);}
function move_down(){par_new=this.t.cloneNode(true);par=this.t;par.parentNode.insertBefore(par_new,par.nextSibling.nextSibling);removeNode(par);sorting_update(this.element);}
function move_top(){par_new=this.t.cloneNode(true);par=this.t;par.parentNode.insertBefore(par_new,par.parentNode.firstChild);removeNode(par);sorting_update(this.element);}
function move_bottom(){par_new=this.t.cloneNode(true);par=this.t;par.parentNode.appendChild(par_new);removeNode(par);sorting_update(this.element);}
function arrow_over(){this.old_src=this.src;if(this.src.indexOf('_b.gif')==-1){this.src=this.src.replace('.gif','_a.gif');}}
function arrow_out(){if(x=this.old_src) this.src=x; this.old_src=null;}

/*---sorting_update.js---*/

function exPL(x){return x;}
var Sekcja,Wiersze,Tablica_Wierszy=[];
var click_count=0;var last_col=0; 
function initSort(id){if(!document.getElementById) return;Wiersze='';Sekcja='';Sekcja=document.getElementById((!id?'Sort_id':id));if(!Sekcja){alert('Blad: brak zmiennej Sekcja.'+"\n"+'function: initSort');return;}Wiersze=Sekcja.getElementsByTagName('tr');Tablica_Wierszy=[];for(var i=0;i<Wiersze.length;i++)Tablica_Wierszy[i]=Wiersze[i].cloneNode(true);}
function Sortuj(x){if(last_col!=x){last_col=x;click_count=0;}else{click_count++;}d=z=v='';if(arguments[1]!=null){z=arguments[1];if(arguments[2]!=null){d=arguments[2];if(arguments[3]!=null)v=arguments[3];}} if(!Sekcja){alert('Blad: brak zmiennej Sekcja.'+"\n"+'function: Sortuj');return;} if(!document.getElementById||!Wiersze) return false;Tablica_Wierszy.sort(function(A,B,a,b){if(z&&(d||d==0)){if(A.getElementsByTagName('td')[x].getElementsByTagName(z).length>0)a=A.getElementsByTagName('td')[x].getElementsByTagName(z)[d].firstChild.nodeValue;else a=v;if(B.getElementsByTagName('td')[x].getElementsByTagName(z).length>0)b=B.getElementsByTagName('td')[x].getElementsByTagName(z)[d].firstChild.nodeValue;else b=v;}else{ a=A.getElementsByTagName('td')[x].innerHTML;b=B.getElementsByTagName('td')[x].innerHTML;} if(click_count%2==0){a=exPL(a);b=exPL(b);}else{t=a;a=exPL(b);b=exPL(t);t=null;} if(o=parseInt(a)) if(o>0) a=o;if(o=parseInt(b)) if(o>0) b=o;return a>b?1:a<b?-1:0;});while(Wiersze.length)Sekcja.removeChild(Wiersze[0]);for(var i=0;i<Tablica_Wierszy.length;i++){Sekcja.appendChild(Tablica_Wierszy[i]);}} 
function tr_colorate(id){var s=document.getElementById(id).getElementsByTagName('tr');for(var i=0;a=s[i];i++){var bgC='';if(i%2==0) bgC='#eee';else bgC='#fff';a.style.backgroundColor=bgC;var b=a.getElementsByTagName('div');for(var ii=0;aa=b[ii];ii++){if(aa.title!=''){if(aa.title=='index'){aa.style.zIndex=(1000-i);}continue;}aa.style.backgroundColor=bgC;}}}

/*---table_sorting.js---*/

var ShowTip=Class.create();
ShowTip.prototype={
	evt:null,
	element:null,
	options:{},
	initialize: function(e,element){this.evt=e||event;element=$(element);this.element=element;this.setOptions(arguments[1]);this.showDiv(e);},
	setOptions: function(options) {this.options = {value:'TITLE'};Object.extend(this.options, options || {});},
	showDiv: function(e){d=document;E=d.documentElement;b=d.body;if(!E)return;el=this.element;el.onmouseout=function(x) {with(this){title=t.innerHTML.replace(/<br \/>/g, "\|")};if(x=d.getElementById("tooltip"))b.removeChild(x);};el.onmousemove=function(e) {e=e||event;with(this.t.style){left=e.clientX+(E.scrollLeft||b.scrollLeft)+"px";top=e.clientY+(E.scrollTop||b.scrollTop)+"px";}}; with(el.t=d.createElement("div")){id="tooltip";innerHTML=(this.options.value=='TITLE'?el.title:this.options.value).replace(/\|/g, "<br />");}with(el){title="";onmousemove(e)}this.element.title='';imgs=this.element.getElementsByTagName('img');if(imgs.length>0){for(i=0;i<imgs.length;i++) imgs[i].alt='';}b.appendChild(el.t);}
}

/*---tipser.js---*/

var trOnClick=Class.create();
trOnClick.prototype={
	element:null,
	options:{},
	pageLoad:null,
	initialize: function(element,page){element=$(element);this.element=element;this.pageLoad=page;this.setOptions(arguments[2]);this.addEvent();},
	setOptions: function(options) {this.options = {};Object.extend(this.options, options || {});},
	addEvent: function(){var trs=this.element.getElementsByTagName('tr');var self=this;for(var i=0,max=trs.length;i<max;i++){var element=trs[i];if(Element.hasClassName(element,'NO_ACTION')) continue;element.onclick=function(){ if(CLICKED==true){CLICKED=false;return false;}if(Element.hasClassName(this,self.options.className)){Element.removeClassName(this,self.options.className);}else{Element.addClassName(this,self.options.className);}new Ajax.Request(self.pageLoad,{method:'get',parameters:'id='+this.id,onComplete:function(a){}});}}}
}

var trAddClassName=Class.create();
trAddClassName.prototype={
	element:null,
	options:{},
	initialize: function(element){element=$(element);this.element=element;this.setOptions(arguments[1]);this.addClassName();},
	setOptions: function(options) {this.options = {};Object.extend(this.options, options || {});},
	addClassName: function(){var trs=this.element.getElementsByTagName('tr');for(var i=0,max=trs.length;i<max;i++){if(this.options.elements && this.options.elements.search(trs[i].id)) trs[i].className=this.options.className;}}
}

/*---trOnClick.js---*/

var trOver=Class.create();
trOver.prototype={
	element:null, options:{},
	initialize: function(element){element=$(element); this.element=element;this.setOptions(arguments[1]);this.addEvent();},
	setOptions: function(options){this.options = {type:'style',tagName:'tr'};Object.extend(this.options, options || {});},
	addEvent: function(){var self=this;var elements=this.element.getElementsByTagName(this.options.tagName);for(var i=0,max=elements.length;i<max;i++){var el=elements[i];if(Element.hasClassName(el,'NO_ACTION')){continue;}switch(this.options.type){case 'style': el.onmouseover=function() {self.onOverStyle(self,this);}; break;}el.onmouseout=this.onOut;}},
	onOut: function(){for(var i=0,max=this.oldStyle.length;i<max;i+=2){this.style[this.oldStyle[i]]=this.oldStyle[i+1];}},
	onOverStyle: function(self,t){t.oldStyle=[];for(var i=0,max=self.options.style.length;i<max;i+=2){t.oldStyle.push(self.options.style[i]);t.oldStyle.push(t.style[self.options.style[i]]);t.style[self.options.style[i]]=self.options.style[i+1];}}
}

/*---trOver.js---*/

var old_top=null;var form_loaded=false;
function change_top(ac){if(!xmlhttp) return true;old_top=ac.firstChild.nodeValue;url='xml_pages/change_user_page.php?type=top';with_function(url,function(){});return false;}
function show_form_add(id,txt){if(form_loaded==true) return;document.getElementById(id).style.display='';document.getElementById(id).innerHTML=txt;url='xml_pages/show_form.php';with_function(url,function(){document.getElementById(id).innerHTML=xmlhttp.responseText;form_loaded=true;});}
function change_home_page(id,ac){var d=document; var tb=$('offer_list');
new Ajax.Request(
	'/xml_pages/change_offer_for_home_page.php',
	{
		parameters:'id='+id,
		method:'get',
		onComplete:function()
		{
			if(tb) var trs=tb.getElementsByTagName('tr');
			else return true;
			for(i=0;a=trs[i];i++) a.className='';
			$('offer_nr_'+id).className='offer_home';ac.blur();
		}
	}
);return false;}
function change_offer_active(id,ac,admin,activity,sold){CLICKED=true;ac.blur();var d=document; var tb=$('offer_list'); if(!admin){var amount=$('amount_items'); var pack=$('pack_left');var it_am=(amount?parseInt(amount.firstChild.nodeValue):0);var pa_lf=(pack?parseInt(pack.firstChild.nodeValue):0);}if(tb) var trs=tb.getElementsByTagName('tr');else return true;if(admin) idT=id; url=GLOBAL_PATH+'xml_pages/change_offer_active.php';params='id='+id+(activity?'&deactivate=1':'')+(sold?'&sold=1':'')+(newURL||location.search).replace('?','&');if(ac.href.indexOf('?')>-1){params+='&page_user=1';}var div=document.createElement('div');div.appendChild(document.createTextNode(txt_lng['pls_whait']));with(div.style){backgroundColor='#f00';color='#fff';display='inline';}div.id='loading_active'+id;ac.parentNode.appendChild(div);new Ajax.Updater('offer_list_div',url,{parameters:params,method:'get',evalScripts:true,onSuccess:function(xmlhttp) {Element.remove('loading_active'+id);}});return false;}
function sort_list(admin,k,color,color_ac){if(admin) return;var tb=$('offer_list'); if(tb) var trs=tb.getElementsByTagName('tr');var items_active=[]; var a_c=0;var items_noActive=[]; var na_c=0;for(var i=0;i<trs.length;i++){var a=trs[i];if(a.id.indexOf('offer_nr_')==-1) continue;if(admin && k){items_active[k[a.id]]=a.cloneNode(true);}else if(color_ac=='no_active'){if(a.style.backgroundColor==color) items_noActive[na_c++]=a.cloneNode(true);else items_active[a_c++]=a.cloneNode(true);}else if(color_ac=='active'){if(a.style.backgroundColor==color) items_active[a_c++]=a.cloneNode(true);else items_noActive[na_c++]=a.cloneNode(true);}else {if(a.style.backgroundColor=='') items_active[a_c++]=a.cloneNode(true);else items_noActive[na_c++]=a.cloneNode(true);}}if((na_c>0 && a_c>0)||admin){if(!admin){items_active.sort(function(A,B,a,b){a=A.id;b=B.id;return (!admin?a>b?-1:a<b?1:0:a>b?1:a<b?-1:0);});items_noActive.sort(function(A,B,a,b){a=A.id;b=B.id;return (!admin?a>b?-1:a<b?1:0:a>b?1:a<b?-1:0);});}while(trs.length)tb.removeChild(trs[0]);for(i=0;i<items_active.length;i++)if(items_active[i]){tb.appendChild(items_active[i]);if(admin){var empty_cell=document.createElement('tr');empty_cell.style.border='0';var emp=document.createElement('td');emp.innerHTML='&nbsp;';emp.style.border='0';empty_cell.appendChild(emp);tb.appendChild(empty_cell);}}for(i=0;i<items_noActive.length;i++)if(items_noActive[i]){tb.appendChild(items_noActive[i]);if(admin){var empty_cell=document.createElement('tr');empty_cell.style.border='0';var emp=document.createElement('td');emp.innerHTML='&nbsp;';emp.style.border='0';empty_cell.appendChild(emp);tb.appendChild(empty_cell);}}if(admin) {new changePrice();var element=$('netto_brutto');if(element.firstChild.style.color==''){element.firstChild.onclick();}else if(element.lastChild.style.color==''){element.lastChild.onclick();}}}}
function delete_logo(txt,id,ac,img_id){if(!xmlhttp) return true;d=document;url='xml_pages/delete_user_logo.php';with_function(url,function(){$(img_id).style.display='none';$(id).innerHTML=txt;ac.style.display='none';});return false;}

/*---user_page_changes.js---*/

var global_id=null; var url_xml=null; var xmlReady=false; var xmlDoc=null; var xmlMethod="GET"; var xmlSend=null;

function with_function(url,func,func_tick){	
	xmlDoc=null; url=GLOBAL_PATH+url; url=url.split('?'); xmlhttp=null;
	new Ajax.Request(url[0],{
		method:xmlMethod, parameters:(xmlMethod=='post'?xmlSend:url[1]),XML:true,
		onSuccess:function(xmlhttp){ var xmlDoc=getXML(xmlhttp); func(xmlDoc,xmlhttp); },
		onLoading:func_tick
	});	xmlSend=null; xmlMethod="GET"; return false
}

/*---xmlhttp.js---*/

var Builder = {
  NODEMAP: {
    AREA: 'map',
    CAPTION: 'table',
    COL: 'table',
    COLGROUP: 'table',
    LEGEND: 'fieldset',
    OPTGROUP: 'select',
    OPTION: 'select',
    PARAM: 'object',
    TBODY: 'table',
    TD: 'table',
    TFOOT: 'table',
    TH: 'table',
    THEAD: 'table',
    TR: 'table'
  },
  node: function(elementName) {
    elementName = elementName.toUpperCase();
    var parentTag = this.NODEMAP[elementName] || 'div';
    var parentElement = document.createElement(parentTag);
    try {
      parentElement.innerHTML = "<" + elementName + "></" + elementName + ">";
    } catch(e) {}
    var element = parentElement.firstChild || null;
    if(element && (element.tagName != elementName))
      element = element.getElementsByTagName(elementName)[0];
    if(!element) element = document.createElement(elementName);
    if(!element) return;
    if(arguments[1])
      if(this._isStringOrNumber(arguments[1]) ||
        (arguments[1] instanceof Array)) {
          this._children(element, arguments[1]);
        } else {
          var attrs = this._attributes(arguments[1]);
          if(attrs.length) {
            try {
              parentElement.innerHTML = "<" +elementName + " " +
                attrs + "></" + elementName + ">";
            } catch(e) {}
            element = parentElement.firstChild || null;
            if(!element) {
              element = document.createElement(elementName);
              for(attr in arguments[1]) 
                element[attr == 'class' ? 'className' : attr] = arguments[1][attr];
            }
            if(element.tagName != elementName)
              element = parentElement.getElementsByTagName(elementName)[0];
            }
        } 
    if(arguments[2])
      this._children(element, arguments[2]);

     return element;
  },
  _text: function(text) {
     return document.createTextNode(text);
  },
  _attributes: function(attributes) {
    var attrs = [];
    for(attribute in attributes)
      attrs.push((attribute=='className' ? 'class' : attribute) +
          '="' + attributes[attribute].toString().escapeHTML() + '"');
    return attrs.join(" ");
  },
  _children: function(element, children) {
    if(typeof children=='object') {
      children.flatten().each( function(e) {
        if(typeof e=='object')
          element.appendChild(e)
        else
          if(Builder._isStringOrNumber(e))
            element.appendChild(Builder._text(e));
      });
    } else
      if(Builder._isStringOrNumber(children)) 
         element.appendChild(Builder._text(children));
  },
  _isStringOrNumber: function(param) {
    return(typeof param=='string' || typeof param=='number');
  }
}

/*---builder.js---*/

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,
      snap:        false,     //added
      revert:      false      //added
    }, 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, 
      snap:        options.snap, //added
      revert:      options.revert //added
    };

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

/*---dragdrop.js---*/

String.prototype.parseColor = function() {  
  var color = '#';  
  if(this.slice(0,4) == 'rgb(') {  
    var cols = this.slice(4,this.length-1).split(',');  
    var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3);  
  } else {  
    if(this.slice(0,1) == '#') {  
      if(this.length==4) for(var i=1;i<4;i++) color += (this.charAt(i) + this.charAt(i)).toLowerCase();  
      if(this.length==7) color = this.toLowerCase();  
    }  
  }  
  return(color.length==7 ? color : (arguments[0] || this));  
}

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

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

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

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

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

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

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

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

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

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

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

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

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

var Effect2 = Effect; // deprecated

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

Effect.Transitions = {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Element.addMethods();

/*---effects.js---*/
  
var orgValues=[];
function changeS(t,a,k)
{
	if(!k) k='>';
	var v1=$(t+'1_'+a).value;
	var v1P=parseInt(v1);
	var v2=$(t+'2_'+a).value;
	var v2P=parseInt(v2);
	if(!orgValues[t])
	{
		orgValues[t]=[];
		orgValues[t][2]=[];
		for(i=0,max=$(t+'2_'+a).options.length;i!=max;i++)
		{
			orgValues[t][2][i]=[];
			orgValues[t][2][i]['value']=$(t+'2_'+a).options[i].value;
			orgValues[t][2][i]['valueP']=parseInt($(t+'2_'+a).options[i].value);
			orgValues[t][2][i]['text']=$(t+'2_'+a).options[i].text;
		}
	}
	$(t+'2_'+a).innerHTML='';
	$(t+'2_'+a).options.length=0;
	
	for(i=0,max=orgValues[t][2].length;i!=max;i++)
	{
		if(orgValues[t][2][i]['value']=="" || (k==">" && orgValues[t][2][i]['valueP']>=v1P) || (k=="<" && orgValues[t][2][i]['valueP']<=v1P) || v1=="" || orgValues[t][2][i]['value']=="-1")
		{
			$(t+'2_'+a).options[$(t+'2_'+a).options.length]=new Option(orgValues[t][2][i]['text'], orgValues[t][2][i]['value'], false);
		}
	}
	if(v2=="-1" || v2=="" || (k==">" && v2P>v1P) || (k=="<" && v2P<v1P)) $(t+'2_'+a).value=v2;
}