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

var Prototype = {
  Version: '1.5.0',
  BrowserFeatures: {
    XPath: !!document.evaluate
  },

  ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',
  emptyFunction: function() {},
  K: function(x) { return x }
}

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

var Abstract = new Object();

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

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

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

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

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

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

Function.prototype.bindAsEventListener = function(object) {
  var __method = this, args = $A(arguments), object = args.shift();
  return function(event) {
    return __method.apply(object, [( event || window.event)].concat(args).concat($A(arguments)));
  }
}

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

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

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

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

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

    return returnValue;
  }
}

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

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

    this.registerCallback();
  },

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

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

  onTimerEvent: function() {
    if (!this.currentlyExecuting) {
      try {
        this.currentlyExecuting = true;
        this.callback(this);
      } finally {
        this.currentlyExecuting = false;
      }
    }
  }
}
String.interpret = function(value){
  return value == null ? '' : String(value);
}

Object.extend(String.prototype, {
  gsub: function(pattern, replacement) {
    var result = '', source = this, match;
    replacement = arguments.callee.prepareReplacement(replacement);

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

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

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

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

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

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

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

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

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

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

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

  unescapeHTML: function() {
    var div = document.createElement('div');
    div.innerHTML = this.stripTags();
    return div.childNodes[0] ? (div.childNodes.length > 1 ?
      $A(div.childNodes).inject('',function(memo,node){ return memo+node.nodeValue }) :
      div.childNodes[0].nodeValue) : '';
  },

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

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

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

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

  succ: function() {
    return this.slice(0, this.length - 1) +
      String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
  },

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

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

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

    return camelized;
  },

  capitalize: function(){
    return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
  },

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

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

  inspect: function(useDoubleQuotes) {
    var escapedString = this.replace(/\\/g, '\\\\');
    if (useDoubleQuotes)
      return '"' + escapedString.replace(/"/g, '\\"') + '"';
    else
      return "'" + escapedString.replace(/'/g, '\\\'') + "'";
  }
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  inGroupsOf: function(number, fillWith) {
    fillWith = fillWith === undefined ? null : fillWith;
    return this.eachSlice(number, function(slice) {
      while(slice.length < number) slice.push(fillWith);
      return slice;
    });
  },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Object.extend(Array.prototype, Enumerable);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Array.prototype.toArray = Array.prototype.clone;

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

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

Object.extend(Hash, {
  toQueryString: function(obj) {
    var parts = [];

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

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

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

Object.extend(Hash.prototype, Enumerable);
Object.extend(Hash.prototype, {
  _each: function(iterator) {
    for (var key in this) {
      var value = this[key];
      if (value && value == Hash.prototype[key]) continue;

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

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

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

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

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

  toQueryString: function() {
    return Hash.toQueryString(this);
  },

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

function $H(object) {
  if (object && object.constructor == Hash) return object;
  return new Hash(object);
};
ObjectRange = Class.create();
Object.extend(ObjectRange.prototype, Enumerable);
Object.extend(ObjectRange.prototype, {
  initialize: function(start, end, exclusive) {
    this.start = start;
    this.end = end;
    this.exclusive = exclusive;
  },

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

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

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

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

  activeRequestCount: 0
}

Ajax.Responders = {
  responders: [],

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

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

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

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

Object.extend(Ajax.Responders, Enumerable);

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

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

    this.options.method = this.options.method.toLowerCase();
    if (typeof this.options.parameters == 'string')
      this.options.parameters = this.options.parameters.toQueryParams();
  }
}

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

Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
  _complete: false,

  initialize: function(url, options) {
    this.transport = Ajax.getTransport();
    this.setOptions(options);
    this.request(url);
  },

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

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

    // h001
    if (typeof MFApp != 'undefined' && MFApp.getTsl ()) {
      this.url += (this.url.indexOf ('?') > -1 ? '&' : '?') + MFApp.getTsl ();
    }

    params = Hash.toQueryString(params);
    if (params && /Konqueror|Safari|KHTML/.test(navigator.userAgent)) params += '&_='

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

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

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

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

      this.transport.onreadystatechange = this.onStateChange.bind(this);
      this.setRequestHeaders();

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

      this.transport.send(body);

      /* Force Firefox to handle ready state 4 for synchronous requests */
      if (!this.options.asynchronous && this.transport.overrideMimeType)
        this.onStateChange();

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

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

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

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

      /* Force "Connection: close" for older Mozilla browsers to work
       * around a bug where XMLHttpRequest sends an incorrect
       * Content-length header. See Mozilla Bugzilla #246651.
       */
      if (this.transport.overrideMimeType &&
          (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
            headers['Connection'] = 'close';
    }

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

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

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

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

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

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

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

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

    if (state == 'Complete') {
      // avoid memory leak in MSIE: clean up
      this.transport.onreadystatechange = Prototype.emptyFunction;
    }
  },

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

  evalJSON: function() {
    try {
      var json = this.getHeader('X-JSON');
      return json ? eval('(' + json + ')') : null;
    } catch (e) { return null }
  },

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

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

Ajax.Updater = Class.create();

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

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

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

    this.request(url);
  },

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

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

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

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

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

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

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

    this.start();
  },

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

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

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

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

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

if (Prototype.BrowserFeatures.XPath) {
  document._getElementsByXPath = function(expression, parentElement) {
    var results = [];
    var query = document.evaluate(expression, $(parentElement) || document,
      null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
    for (var i = 0, length = query.snapshotLength; i < length; i++)
      results.push(query.snapshotItem(i));
    return results;
  };
}

document.getElementsByClassName = function(className, parentElement) {
  if (Prototype.BrowserFeatures.XPath) {
    var q = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
    return document._getElementsByXPath(q, parentElement);
  } else {
    var children = ($(parentElement) || document.body).getElementsByTagName('*');
    var elements = [], child;
    for (var i = 0, length = children.length; i < length; i++) {
      child = children[i];
      if (Element.hasClassName(child, className))
        elements.push(Element.extend(child));
    }
    return elements;
  }
};

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

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

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

  if (!element._extended && element.tagName && element != window) {
    var methods = Object.clone(Element.Methods), cache = Element.extend.cache;

    if (element.tagName == 'FORM')
      Object.extend(methods, Form.Methods);
    if (['INPUT', 'TEXTAREA', 'SELECT'].include(element.tagName))
      Object.extend(methods, Form.Element.Methods);

    Object.extend(methods, Element.Methods.Simulated);

    for (var property in methods) {
      var value = methods[property];
      if (typeof value == 'function' && !(property in element))
        element[property] = cache.findOrStore(value);
    }
  }

  element._extended = true;
  return element;
};

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

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

  toggle: function(element) {
    element = $(element);
    Element[Element.visible(element) ? 'hide' : 'show'](element);
    return element;
  },

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

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

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

  update: function(element, html) {
    html = typeof html == 'undefined' ? '' : html.toString();
    $(element).innerHTML = html.stripScripts();
    setTimeout(function() {html.evalScripts()}, 10);
    return element;
  },

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

  inspect: function(element) {
    element = $(element);
    var result = '<' + element.tagName.toLowerCase();
    $H({'id': 'id', 'className': 'class'}).each(function(pair) {
      var property = pair.first(), attribute = pair.last();
      var value = (element[property] || '').toString();
      if (value) result += ' ' + attribute + '=' + value.inspect(true);
    });
    return result + '>';
  },

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

  ancestors: function(element) {
    return $(element).recursivelyCollect('parentNode');
  },

  descendants: function(element) {
    return $A($(element).getElementsByTagName('*'));
  },

  immediateDescendants: function(element) {
    if (!(element = $(element).firstChild)) return [];
    while (element && element.nodeType != 1) element = element.nextSibling;
    if (element) return [element].concat($(element).nextSiblings());
    return [];
  },

  previousSiblings: function(element) {
    return $(element).recursivelyCollect('previousSibling');
  },

  nextSiblings: function(element) {
    return $(element).recursivelyCollect('nextSibling');
  },

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

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

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

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

  previous: function(element, expression, index) {
    return Selector.findElement($(element).previousSiblings(), expression, index);
  },

  next: function(element, expression, index) {
    return Selector.findElement($(element).nextSiblings(), expression, index);
  },

  getElementsBySelector: function() {
    var args = $A(arguments), element = $(args.shift());
    return Selector.findChildElements(element, args);
  },

  getElementsByClassName: function(element, className) {
    return document.getElementsByClassName(className, element);
  },

  readAttribute: function(element, name) {
    element = $(element);
    if (document.all && !window.opera) {
      var t = Element._attributeTranslations;
      if (t.values[name]) return t.values[name](element, name);
      if (t.names[name])  name = t.names[name];
      var attribute = element.attributes[name];
      if(attribute) return attribute.nodeValue;
    }
    return element.getAttribute(name);
  },

  getHeight: function(element) {
    return $(element).getDimensions().height;
  },

  getWidth: function(element) {
    return $(element).getDimensions().width;
  },

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

  hasClassName: function(element, className) {
    if (!(element = $(element))) return;
    var elementClassName = element.className;
    if (elementClassName.length == 0) return false;
    if (elementClassName == className ||
        elementClassName.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
      return true;
    return false;
  },

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

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

  toggleClassName: function(element, className) {
    if (!(element = $(element))) return;
    Element.classNames(element)[element.hasClassName(className) ? 'remove' : 'add'](className);
    return element;
  },

  observe: function() {
    Event.observe.apply(Event, arguments);
    return $A(arguments).first();
  },

  stopObserving: function() {
    Event.stopObserving.apply(Event, arguments);
    return $A(arguments).first();
  },

  // removes whitespace-only text node children
  cleanWhitespace: function(element) {
    element = $(element);
    var node = element.firstChild;
    while (node) {
      var nextNode = node.nextSibling;
      if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
        element.removeChild(node);
      node = nextNode;
    }
    return element;
  },

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

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

  scrollTo: function(element) {
    element = $(element);
    var pos = Position.cumulativeOffset(element);
    window.scrollTo(pos[0], pos[1]);
    return element;
  },

  getStyle: function(element, style) {
    element = $(element);
    if (['float','cssFloat'].include(style))
      style = (typeof element.style.styleFloat != 'undefined' ? 'styleFloat' : 'cssFloat');
    style = style.camelize();
    var value = element.style[style];
    if (!value) {
      if (document.defaultView && document.defaultView.getComputedStyle) {
        var css = document.defaultView.getComputedStyle(element, null);
        value = css ? css[style] : null;
      } else if (element.currentStyle) {
        value = element.currentStyle[style];
      }
    }

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

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

  setStyle: function(element, style) {
    element = $(element);
    for (var name in style) {
      var value = style[name];
      if(name == 'opacity') {
        if (value == 1) {
          value = (/Gecko/.test(navigator.userAgent) &&
            !/Konqueror|Safari|KHTML/.test(navigator.userAgent)) ? 0.999999 : 1.0;
          if(/MSIE/.test(navigator.userAgent) && !window.opera)
            element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'');
        } else if(value == '') {
          if(/MSIE/.test(navigator.userAgent) && !window.opera)
            element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'');
        } else {
          if(value < 0.00001) value = 0;
          if(/MSIE/.test(navigator.userAgent) && !window.opera)
            element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'') +
              'alpha(opacity='+value*100+')';
        }
      } else if(['float','cssFloat'].include(name)) name = (typeof element.style.styleFloat != 'undefined') ? 'styleFloat' : 'cssFloat';
      element.style[name.camelize()] = value;
    }
    return element;
  },

  getDimensions: function(element) {
    element = $(element);
    var display = $(element).getStyle('display');
    if (display != 'none' && display != null) // Safari bug
      return {width: element.offsetWidth, height: element.offsetHeight};

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

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

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

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

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

Object.extend(Element.Methods, {childOf: Element.Methods.descendantOf});

Element._attributeTranslations = {};

Element._attributeTranslations.names = {
  colspan:   "colSpan",
  rowspan:   "rowSpan",
  valign:    "vAlign",
  datetime:  "dateTime",
  accesskey: "accessKey",
  tabindex:  "tabIndex",
  enctype:   "encType",
  maxlength: "maxLength",
  readonly:  "readOnly",
  longdesc:  "longDesc"
};

Element._attributeTranslations.values = {
  _getAttr: function(element, attribute) {
    return element.getAttribute(attribute, 2);
  },

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

  style: function(element) {
    return element.style.cssText.toLowerCase();
  },

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

Object.extend(Element._attributeTranslations.values, {
  href: Element._attributeTranslations.values._getAttr,
  src:  Element._attributeTranslations.values._getAttr,
  disabled: Element._attributeTranslations.values._flag,
  checked:  Element._attributeTranslations.values._flag,
  readonly: Element._attributeTranslations.values._flag,
  multiple: Element._attributeTranslations.values._flag
});

Element.Methods.Simulated = {
  hasAttribute: function(element, attribute) {
    var t = Element._attributeTranslations;
    attribute = t.names[attribute] || attribute;
    return $(element).getAttributeNode(attribute).specified;
  }
};

// IE is missing .innerHTML support for TABLE-related elements
if (document.all && !window.opera){
  Element.Methods.update = function(element, html) {
    element = $(element);
    html = typeof html == 'undefined' ? '' : html.toString();
    var tagName = element.tagName.toUpperCase();
    if (['THEAD','TBODY','TR','TD'].include(tagName)) {
      var div = document.createElement('div');
      switch (tagName) {
        case 'THEAD':
        case 'TBODY':
          div.innerHTML = '<table><tbody>' +  html.stripScripts() + '</tbody></table>';
          depth = 2;
          break;
        case 'TR':
          div.innerHTML = '<table><tbody><tr>' +  html.stripScripts() + '</tr></tbody></table>';
          depth = 3;
          break;
        case 'TD':
          div.innerHTML = '<table><tbody><tr><td>' +  html.stripScripts() + '</td></tr></tbody></table>';
          depth = 4;
      }
      $A(element.childNodes).each(function(node){
        element.removeChild(node)
      });
      depth.times(function(){ div = div.firstChild });

      $A(div.childNodes).each(
        function(node){ element.appendChild(node) });
    } else {
      element.innerHTML = html.stripScripts();
    }
    setTimeout(function() {html.evalScripts()}, 10);
    return element;
  }
};

Object.extend(Element, Element.Methods);

var _nativeExtensions = false;

if(/Konqueror|Safari|KHTML/.test(navigator.userAgent))
  ['', 'Form', 'Input', 'TextArea', 'Select'].each(function(tag) {
    var className = 'HTML' + tag + 'Element';
    if(window[className]) return;
    var klass = window[className] = {};
    klass.prototype = document.createElement(tag ? tag.toLowerCase() : 'div').__proto__;
  });

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

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

  if (typeof HTMLElement != 'undefined') {
    copy(Element.Methods, HTMLElement.prototype);
    copy(Element.Methods.Simulated, HTMLElement.prototype, true);
    copy(Form.Methods, HTMLFormElement.prototype);
    [HTMLInputElement, HTMLTextAreaElement, HTMLSelectElement].each(function(klass) {
      copy(Form.Element.Methods, klass.prototype);
    });
    _nativeExtensions = true;
  }
}

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

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

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

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

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

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

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

var Insertion = new Object();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  findElements: function(scope) {
    var element;

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

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

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

    return results;
  },

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

Object.extend(Selector, {
  matchElements: function(elements, expression) {
    var selector = new Selector(expression);
    return elements.select(selector.match.bind(selector)).map(Element.extend);
  },

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

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

function $$() {
  return Selector.findChildElements(document, $A(arguments));
}
var Form = {
  reset: function(form) {
    $(form).reset();
    return form;
  },

  serializeElements: function(elements, getHash) {
    var data = elements.inject({}, function(result, element) {
      if (!element.disabled && element.name) {
        var key = element.name, value = $(element).getValue();
        if (value != undefined) {
          if (result[key]) {
            if (result[key].constructor != Array) result[key] = [result[key]];
            result[key].push(value);
          }
          else result[key] = value;
        }
      }
      return result;
    });

    return getHash ? data : Hash.toQueryString(data);
  }
};

Form.Methods = {
  serialize: function(form, getHash) {
    return Form.serializeElements(Form.getElements(form), getHash);
  },

  getElements: function(form) {
    return $A($(form).getElementsByTagName('*')).inject([],
      function(elements, child) {
        if (Form.Element.Serializers[child.tagName.toLowerCase()])
          elements.push(Element.extend(child));
        return elements;
      }
    );
  },

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

    if (!typeName && !name) return $A(inputs).map(Element.extend);

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

    return matchingInputs;
  },

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

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

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

  focusFirstElement: function(form) {
    form = $(form);
    form.findFirstElement().activate();
    return form;
  }
}

Object.extend(Form, Form.Methods);

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

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

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

Form.Element.Methods = {
  serialize: function(element) {
    element = $(element);
    if (!element.disabled && element.name) {
      var value = element.getValue();
      if (value != undefined) {
        var pair = {};
        pair[element.name] = value;
        return Hash.toQueryString(pair);
      }
    }
    return '';
  },

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

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

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

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

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

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

Object.extend(Form.Element, Form.Element.Methods);
var Field = Form.Element;
var $F = Form.Element.getValue;

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

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

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

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

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

  selectOne: function(element) {
    var index = element.selectedIndex;
    return index >= 0 ? this.optionValue(element.options[index]) : null;
  },

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

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

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

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

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

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

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

  onTimerEvent: function() {
    var value = this.getValue();
    var changed = ('string' == typeof this.lastValue && 'string' == typeof value
      ? this.lastValue != value : String(this.lastValue) != String(value));
    if (changed) {
      this.callback(this.element, value);
      this.lastValue = value;
    }
  }
}

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

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

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

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

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

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

  registerFormCallbacks: function() {
    Form.getElements(this.element).each(this.registerCallback.bind(this));
  },

  registerCallback: function(element) {
    if (element.type) {
      switch (element.type.toLowerCase()) {
        case 'checkbox':
        case 'radio':
          Event.observe(element, 'click', this.onElementEvent.bind(this));
          break;
        default:
          Event.observe(element, 'change', this.onElementEvent.bind(this));
          break;
      }
    }
  }
}

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

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

Object.extend(Event, {
  KEY_BACKSPACE: 8,
  KEY_TAB:       9,
  KEY_RETURN:   13,
  KEY_ESC:      27,
  KEY_LEFT:     37,
  KEY_UP:       38,
  KEY_RIGHT:    39,
  KEY_DOWN:     40,
  KEY_DELETE:   46,
  KEY_HOME:     36,
  KEY_END:      35,
  KEY_PAGEUP:   33,
  KEY_PAGEDOWN: 34,

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

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

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

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

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

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

  observers: false,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return document.body;
  },

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

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

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

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

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

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

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

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

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

    } while (element = element.offsetParent);

    element = forElement;
    do {
      if (!window.opera || element.tagName=='BODY') {
        valueT -= element.scrollTop  || 0;
        valueL -= element.scrollLeft || 0;
      }
    } while (element = element.parentNode);

    return [valueL, valueT];
  },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return [valueL, valueT];
  }
}

Element.addMethods();
// script.aculo.us scriptaculous.js v1.7.0, Fri Jan 19 19:16:36 CET 2007

// Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// 
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// For details, see the script.aculo.us web site: http://script.aculo.us/

var Scriptaculous = {
  Version: '1.7.0',
  require: function(libraryName) {
    // inserting via DOM fails in Safari 2.0, so brute force approach
    document.write('<script type="text/javascript" src="'+libraryName+'"></script>');
  },
  load: function() {
    if((typeof Prototype=='undefined') || 
       (typeof Element == 'undefined') || 
       (typeof Element.Methods=='undefined') ||
       parseFloat(Prototype.Version.split(".")[0] + "." +
                  Prototype.Version.split(".")[1]) < 1.5)
       throw("script.aculo.us requires the Prototype JavaScript framework >= 1.5.0");
    
    $A(document.getElementsByTagName("script")).findAll( function(s) {
      return (s.src && s.src.match(/scriptaculous\.js(\?.*)?$/))
    }).each( function(s) {
      var path = s.src.replace(/scriptaculous\.js(\?.*)?$/,'');
      var includes = s.src.match(/\?.*load=([a-z,]*)/);
      (includes ? includes[1] : 'builder,effects,dragdrop,controls,slider').split(',').each(
       function(include) { Scriptaculous.require(path+include+'.js') });
    });
  }
}
// script.aculo.us builder.js v1.7.0, Fri Jan 19 19:16:36 CET 2007

// Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
//
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

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'
  },
  // note: For Firefox < 1.5, OPTION and OPTGROUP tags are currently broken,
  //       due to a Firefox bug
  node: function(elementName) {
    elementName = elementName.toUpperCase();
    
    // try innerHTML approach
    var parentTag = this.NODEMAP[elementName] || 'div';
    var parentElement = document.createElement(parentTag);
    try { // prevent IE "feature": http://dev.rubyonrails.org/ticket/2707
      parentElement.innerHTML = "<" + elementName + "></" + elementName + ">";
    } catch(e) {}
    var element = parentElement.firstChild || null;
      
    // see if browser added wrapping tags
    if(element && (element.tagName.toUpperCase() != elementName))
      element = element.getElementsByTagName(elementName)[0];
    
    // fallback to createElement approach
    if(!element) element = document.createElement(elementName);
    
    // abort if nothing could be created
    if(!element) return;

    // attributes (or text)
    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 { // prevent IE "feature": http://dev.rubyonrails.org/ticket/2707
              parentElement.innerHTML = "<" +elementName + " " +
                attrs + "></" + elementName + ">";
            } catch(e) {}
            element = parentElement.firstChild || null;
            // workaround firefox 1.0.X bug
            if(!element) {
              element = document.createElement(elementName);
              for(attr in arguments[1]) 
                element[attr == 'class' ? 'className' : attr] = arguments[1][attr];
            }
            if(element.tagName.toUpperCase() != elementName)
              element = parentElement.getElementsByTagName(elementName)[0];
            }
        } 

    // text, or array of children
    if(arguments[2])
      this._children(element, arguments[2]);

     return element;
  },
  _text: function(text) {
     return document.createTextNode(text);
  },

  ATTR_MAP: {
    'className': 'class',
    'htmlFor': 'for'
  },

  _attributes: function(attributes) {
    var attrs = [];
    for(attribute in attributes)
      attrs.push((attribute in this.ATTR_MAP ? this.ATTR_MAP[attribute] : attribute) +
          '="' + attributes[attribute].toString().escapeHTML() + '"');
    return attrs.join(" ");
  },
  _children: function(element, children) {
    if(typeof children=='object') { // array can hold nodes and text
      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');
  },
  build: function(html) {
    var element = this.node('div');
    $(element).update(html.strip());
    return element.down();
  },
  dump: function(scope) { 
    if(typeof scope != 'object' && typeof scope != 'function') scope = window; //global scope 
  
    var tags = ("A ABBR ACRONYM ADDRESS APPLET AREA B BASE BASEFONT BDO BIG BLOCKQUOTE BODY " +
      "BR BUTTON CAPTION CENTER CITE CODE COL COLGROUP DD DEL DFN DIR DIV DL DT EM FIELDSET " +
      "FONT FORM FRAME FRAMESET H1 H2 H3 H4 H5 H6 HEAD HR HTML I IFRAME IMG INPUT INS ISINDEX "+
      "KBD LABEL LEGEND LI LINK MAP MENU META NOFRAMES NOSCRIPT OBJECT OL OPTGROUP OPTION P "+
      "PARAM PRE Q S SAMP SCRIPT SELECT SMALL SPAN STRIKE STRONG STYLE SUB SUP TABLE TBODY TD "+
      "TEXTAREA TFOOT TH THEAD TITLE TR TT U UL VAR").split(/\s+/);
  
    tags.each( function(tag){ 
      scope[tag] = function() { 
        return Builder.node.apply(Builder, [tag].concat($A(arguments)));  
      } 
    });
  }
}
// script.aculo.us effects.js v1.7.0, Fri Jan 19 19:16:36 CET 2007

// Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// Contributors:
//  Justin Palmer (http://encytemedia.com/)
//  Mark Pilgrim (http://diveintomark.org/)
//  Martin Bialasinki
// 
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/ 

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

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

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

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

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

Element.getOpacity = function(element){
  return $(element).getStyle('opacity');
}

Element.setOpacity = function(element, value){
  return $(element).setStyle({opacity:value});
}

Element.getInlineOpacity = function(element){
  return $(element).style.opacity || '';
}

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 = {
  _elementDoesNotExistError: {
    name: 'ElementDoesNotExistError',
    message: 'The specified DOM element does not exist, but is required for this effect to operate'
  },
  tagifyText: function(element) {
    if(typeof Builder == 'undefined')
      throw("Effect.tagifyText requires including script.aculo.us' builder.js library");
      
    var tagifyStyle = 'position:relative';
    if(/MSIE/.test(navigator.userAgent) && !window.opera) 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 = {
  linear: Prototype.K,
  sinoidal: function(pos) {
    return (-Math.cos(pos*Math.PI)/2) + 0.5;
  },
  reverse: function(pos) {
    return 1-pos;
  },
  flicker: function(pos) {
    return ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random()/4;
  },
  wobble: function(pos) {
    return (-Math.cos(pos*Math.PI*(9*pos))/2) + 0.5;
  },
  pulse: function(pos, pulses) { 
    pulses = pulses || 5; 
    return (
      Math.round((pos % (1/pulses)) * pulses) == 0 ? 
            ((pos * pulses * 2) - Math.floor(pos * pulses * 2)) : 
        1 - ((pos * pulses * 2) - Math.floor(pos * pulses * 2))
      );
  },
  none: function(pos) {
    return 0;
  },
  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 'with-last':
        timestamp = this.effects.pluck('startOn').max() || timestamp;
        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), 15);
  },
  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();
    for(var i=0, len=this.effects.length;i<len;i++) 
      if(this.effects[i]) this.effects[i].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:        60.0,  // max. 60fps 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() {
    var data = $H();
    for(property in this)
      if(typeof this[property] != 'function') data[property] = this[property];
    return '#<Effect:' + data.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.Event = Class.create();
Object.extend(Object.extend(Effect.Event.prototype, Effect.Base.prototype), {
  initialize: function() {
    var options = Object.extend({
      duration: 0
    }, arguments[0] || {});
    this.start(options);
  },
  update: Prototype.emptyFunction
});

Effect.Opacity = Class.create();
Object.extend(Object.extend(Effect.Opacity.prototype, Effect.Base.prototype), {
  initialize: function(element) {
    this.element = $(element);
    if(!this.element) throw(Effect._elementDoesNotExistError);
    // make this work on IE on elements without 'layout'
    if(/MSIE/.test(navigator.userAgent) && !window.opera && (!this.element.currentStyle.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);
    if(!this.element) throw(Effect._elementDoesNotExistError);
    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: Math.round(this.options.x  * position + this.originalLeft) + 'px',
      top:  Math.round(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);
    if(!this.element) throw(Effect._elementDoesNotExistError);
    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','%','pt'].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 = Math.round(width) + 'px';
    if(this.options.scaleY) d.height = Math.round(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);
    if(!this.element) throw(Effect._elementDoesNotExistError);
    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 = {};
    if (!this.options.keepBackgroundImage) {
      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().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).show(); 
  }}, arguments[1] || {});
  return new Effect.Opacity(element,options);
}

Effect.Puff = function(element) {
  element = $(element);
  var oldStyle = { 
    opacity: element.getInlineOpacity(), 
    position: element.getStyle('position'),
    top:  element.style.top,
    left: element.style.left,
    width: element.style.width,
    height: element.style.height
  };
  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) {
        Position.absolutize(effect.effects[0].element)
      },
      afterFinishInternal: function(effect) {
         effect.effects[0].element.hide().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().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().setStyle({height: '0px'}).show(); 
    },  
    afterFinishInternal: function(effect) {
      effect.element.undoClipping();
    }
  }, arguments[1] || {}));
}

Effect.SwitchOff = function(element) {
  element = $(element);
  var oldOpacity = element.getInlineOpacity();
  return new Effect.Appear(element, Object.extend({
    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().makeClipping();
        },
        afterFinishInternal: function(effect) {
          effect.element.hide().undoClipping().undoPositioned().setStyle({opacity: oldOpacity});
        }
      })
    }
  }, arguments[1] || {}));
}

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().undoPositioned().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().setStyle(oldStyle);
  }}) }}) }}) }}) }}) }});
}

Effect.SlideDown = function(element) {
  element = $(element).cleanWhitespace();
  // SlideDown need to have the content of the element wrapped in a container element with fixed height!
  var oldInnerBottom = element.down().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.down().makePositioned();
      if(window.opera) effect.element.setStyle({top: ''});
      effect.element.makeClipping().setStyle({height: '0px'}).show(); 
    },
    afterUpdateInternal: function(effect) {
      effect.element.down().setStyle({bottom:
        (effect.dims[0] - effect.element.clientHeight) + 'px' }); 
    },
    afterFinishInternal: function(effect) {
      effect.element.undoClipping().undoPositioned();
      effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom}); }
    }, arguments[1] || {})
  );
}

Effect.SlideUp = function(element) {
  element = $(element).cleanWhitespace();
  var oldInnerBottom = element.down().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.down().makePositioned();
      if(window.opera) effect.element.setStyle({top: ''});
      effect.element.makeClipping().show();
    },  
    afterUpdateInternal: function(effect) {
      effect.element.down().setStyle({bottom:
        (effect.dims[0] - effect.element.clientHeight) + 'px' });
    },
    afterFinishInternal: function(effect) {
      effect.element.hide().undoClipping().undoPositioned().setStyle({bottom: oldInnerBottom});
      effect.element.down().undoPositioned();
    }
   }, 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(); 
    },  
    afterFinishInternal: function(effect) {
      effect.element.hide().undoClipping(); 
    }
  });
}

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().makeClipping().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'}).show(); 
             },
             afterFinishInternal: function(effect) {
               effect.effects[0].element.undoClipping().undoPositioned().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().makeClipping(); 
         },
         afterFinishInternal: function(effect) {
           effect.effects[0].element.hide().undoClipping().undoPositioned().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, options.pulses)) };
  reverser.bind(transition);
  return new Effect.Opacity(element, 
    Object.extend(Object.extend({  duration: 2.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();
  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().undoClipping().setStyle(oldStyle);
      } });
  }}, arguments[1] || {}));
};

Effect.Morph = Class.create();
Object.extend(Object.extend(Effect.Morph.prototype, Effect.Base.prototype), {
  initialize: function(element) {
    this.element = $(element);
    if(!this.element) throw(Effect._elementDoesNotExistError);
    var options = Object.extend({
      style: {}
    }, arguments[1] || {});
    if (typeof options.style == 'string') {
      if(options.style.indexOf(':') == -1) {
        var cssText = '', selector = '.' + options.style;
        $A(document.styleSheets).reverse().each(function(styleSheet) {
          if (styleSheet.cssRules) cssRules = styleSheet.cssRules;
          else if (styleSheet.rules) cssRules = styleSheet.rules;
          $A(cssRules).reverse().each(function(rule) {
            if (selector == rule.selectorText) {
              cssText = rule.style.cssText;
              throw $break;
            }
          });
          if (cssText) throw $break;
        });
        this.style = cssText.parseStyle();
        options.afterFinishInternal = function(effect){
          effect.element.addClassName(effect.options.style);
          effect.transforms.each(function(transform) {
            if(transform.style != 'opacity')
              effect.element.style[transform.style.camelize()] = '';
          });
        }
      } else this.style = options.style.parseStyle();
    } else this.style = $H(options.style)
    this.start(options);
  },
  setup: function(){
    function parseColor(color){
      if(!color || ['rgba(0, 0, 0, 0)','transparent'].include(color)) color = '#ffffff';
      color = color.parseColor();
      return $R(0,2).map(function(i){
        return parseInt( color.slice(i*2+1,i*2+3), 16 ) 
      });
    }
    this.transforms = this.style.map(function(pair){
      var property = pair[0].underscore().dasherize(), value = pair[1], unit = null;

      if(value.parseColor('#zzzzzz') != '#zzzzzz') {
        value = value.parseColor();
        unit  = 'color';
      } else if(property == 'opacity') {
        value = parseFloat(value);
        if(/MSIE/.test(navigator.userAgent) && !window.opera && (!this.element.currentStyle.hasLayout))
          this.element.setStyle({zoom: 1});
      } else if(Element.CSS_LENGTH.test(value)) 
        var components = value.match(/^([\+\-]?[0-9\.]+)(.*)$/),
          value = parseFloat(components[1]), unit = (components.length == 3) ? components[2] : null;

      var originalValue = this.element.getStyle(property);
      return $H({ 
        style: property, 
        originalValue: unit=='color' ? parseColor(originalValue) : parseFloat(originalValue || 0), 
        targetValue: unit=='color' ? parseColor(value) : value,
        unit: unit
      });
    }.bind(this)).reject(function(transform){
      return (
        (transform.originalValue == transform.targetValue) ||
        (
          transform.unit != 'color' &&
          (isNaN(transform.originalValue) || isNaN(transform.targetValue))
        )
      )
    });
  },
  update: function(position) {
    var style = $H(), value = null;
    this.transforms.each(function(transform){
      value = transform.unit=='color' ?
        $R(0,2).inject('#',function(m,v,i){
          return m+(Math.round(transform.originalValue[i]+
            (transform.targetValue[i] - transform.originalValue[i])*position)).toColorPart() }) : 
        transform.originalValue + Math.round(
          ((transform.targetValue - transform.originalValue) * position) * 1000)/1000 + transform.unit;
      style[transform.style] = value;
    });
    this.element.setStyle(style);
  }
});

Effect.Transform = Class.create();
Object.extend(Effect.Transform.prototype, {
  initialize: function(tracks){
    this.tracks  = [];
    this.options = arguments[1] || {};
    this.addTracks(tracks);
  },
  addTracks: function(tracks){
    tracks.each(function(track){
      var data = $H(track).values().first();
      this.tracks.push($H({
        ids:     $H(track).keys().first(),
        effect:  Effect.Morph,
        options: { style: data }
      }));
    }.bind(this));
    return this;
  },
  play: function(){
    return new Effect.Parallel(
      this.tracks.map(function(track){
        var elements = [$(track.ids) || $$(track.ids)].flatten();
        return elements.map(function(e){ return new track.effect(e, Object.extend({ sync:true }, track.options)) });
      }).flatten(),
      this.options
    );
  }
});

Element.CSS_PROPERTIES = $w(
  'backgroundColor backgroundPosition borderBottomColor borderBottomStyle ' + 
  'borderBottomWidth borderLeftColor borderLeftStyle borderLeftWidth ' +
  'borderRightColor borderRightStyle borderRightWidth borderSpacing ' +
  'borderTopColor borderTopStyle borderTopWidth bottom clip color ' +
  'fontSize fontWeight height left letterSpacing lineHeight ' +
  'marginBottom marginLeft marginRight marginTop markerOffset maxHeight '+
  'maxWidth minHeight minWidth opacity outlineColor outlineOffset ' +
  'outlineWidth paddingBottom paddingLeft paddingRight paddingTop ' +
  'right textIndent top width wordSpacing zIndex');
  
Element.CSS_LENGTH = /^(([\+\-]?[0-9\.]+)(em|ex|px|in|cm|mm|pt|pc|\%))|0$/;

String.prototype.parseStyle = function(){
  var element = Element.extend(document.createElement('div'));
  element.innerHTML = '<div style="' + this + '"></div>';
  var style = element.down().style, styleRules = $H();
  
  Element.CSS_PROPERTIES.each(function(property){
    if(style[property]) styleRules[property] = style[property]; 
  });
  if(/MSIE/.test(navigator.userAgent) && !window.opera && this.indexOf('opacity') > -1) {
    styleRules.opacity = this.match(/opacity:\s*((?:0|1)?(?:\.\d*)?)/)[1];
  }
  return styleRules;
};

Element.morph = function(element, style) {
  new Effect.Morph(element, Object.extend({ style: style }, arguments[2] || {}));
  return element;
};

['setOpacity','getOpacity','getInlineOpacity','forceRerendering','setContentZoom',
 'collectTextNodes','collectTextNodesIgnoreClass','morph'].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();
// script.aculo.us dragdrop.js v1.7.0, Fri Jan 19 19:16:36 CET 2007

// Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
//           (c) 2005, 2006 Sammi Williams (http://www.oriontransfer.co.nz, sammi@oriontransfer.co.nz)
// 
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

if(typeof Effect == 'undefined')
  throw("dragdrop.js requires including script.aculo.us' effects.js library");

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) {
    if(draggable.options.delay) { 
      this._timeout = setTimeout(function() { 
        Draggables._timeout = null; 
        window.focus(); 
        Draggables.activeDraggable = draggable; 
      }.bind(this), draggable.options.delay); 
    } else {
      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._timeout) { 
      clearTimeout(this._timeout); 
      this._timeout = null; 
    }
    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);
      });
    if(draggable.options[eventName]) draggable.options[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._dragging    = {};

Draggable.prototype = {
  initialize: function(element) {
    var defaults = {
      handle: false,
      reverteffect: function(element, top_offset, left_offset) {
        var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
        new Effect.Move(element, { x: -left_offset, y: -top_offset, duration: dur,
          queue: {scope:'_draggable', position:'end'}
        });
      },
      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, 
          queue: {scope:'_draggable', position:'end'},
          afterFinish: function(){ 
            Draggable._dragging[element] = false 
          }
        }); 
      },
      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] }
      delay: 0
    };
    
    if(!arguments[1] || typeof arguments[1].endeffect == 'undefined')
      Object.extend(defaults, {
        starteffect: function(element) {
          element._opacity = Element.getOpacity(element);
          Draggable._dragging[element] = true;
          new Effect.Opacity(element, {duration:0.2, from:element._opacity, to:0.7}); 
        }
      });
    
    var options = Object.extend(defaults, arguments[1] || {});

    this.element = $(element);
    
    if(options.handle && (typeof options.handle == 'string'))
      this.handle = this.element.down('.'+options.handle, 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);
      this._isScrollChild = Element.childOf(this.element, 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(typeof Draggable._dragging[this.element] != 'undefined' &&
      Draggable._dragging[this.element]) return;
    if(Event.isLeftClick(event)) {    
      // abort on form elements, fixes a Firefox issue
      var src = Event.element(event);
      if((tag_name = src.tagName.toUpperCase()) && (
        tag_name=='INPUT' ||
        tag_name=='SELECT' ||
        tag_name=='OPTION' ||
        tag_name=='BUTTON' ||
        tag_name=='TEXTAREA')) return;
        
      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 + Position.deltaX;
        p[1] += this.options.scroll.scrollTop + Position.deltaY;
        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);
    if(this.options.ghosting) {
      var r   = Position.realOffset(this.element);
      pos[0] += r[0] - Position.deltaX; pos[1] += r[1] - Position.deltaY;
    }
    
    var d = this.currentDelta();
    pos[0] -= d[0]; pos[1] -= d[1];
    
    if(this.options.scroll && (this.options.scroll != window && this._isScrollChild)) {
      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) {
    if(!(speed[0] || speed[1])) return;
    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);
    if (this._isScrollChild) {
      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, oonStart, oonEnd, oonUpdate) { // h001
    this.element   = $(element);
    this.oonStart  = oonStart;
    this.oonEnd    = oonEnd;
    this.oonUpdate = oonUpdate;
    this.lastValue = Sortable.serialize(this.element);
  },
  
  onStart: function() {
    this.lastValue = Sortable.serialize(this.element);
    this.oonStart ();
  },
  
  onEnd: function() {
    Sortable.unmark();
    if(this.lastValue != Sortable.serialize(this.element))
      this.oonUpdate (this.element);
    this.oonEnd ();
  }
}

var Sortable = {
  SERIALIZE_RULE: /^[^_\-](?:[A-Za-z0-9\-\_]*)[_](.*)$/,
  
  sortables: {},
  
  _findRootElement: function(element) {
    while (element.tagName.toUpperCase() != "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,
      delay:       0,
      hoverclass:  null,
      ghosting:    false,
      scroll:      false,
      scrollSensitivity: 20,
      scrollSpeed: 15,
      format:      this.SERIALIZE_RULE,
      onChange:    Prototype.emptyFunction,
      onUpdate:    Prototype.emptyFunction,
      onStart:     Prototype.emptyFunction, // h002
      onEnd:       Prototype.emptyFunction  // h003
    }, 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,
      delay:       options.delay,
      ghosting:    options.ghosting,
      constraint:  options.constraint,
      handle:      options.handle };

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

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

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

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

    // build options for the droppables  
    var options_for_droppable = {
      overlap:     options.overlap,
      containment: options.containment,
      tree:        options.tree,
      hoverclass:  options.hoverclass,
      onHover:     Sortable.onHover
    }
    
    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 ? 
        $(e).down('.'+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.onStart, options.onEnd, options.onUpdate)); // h004

  },

  // 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, only: droponOptions.only});
      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) Sortable._marker.hide();
  },

  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') || Element.extend(document.createElement('DIV'))).
          hide().addClassName('dropmarker').setStyle({position:'absolute'});
      document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
    }    
    var offsets = Position.cumulativeOffset(dropon);
    Sortable._marker.setStyle({left: offsets[0]+'px', top: offsets[1] + 'px'});
    
    if(position=='after')
      if(sortable.overlap == 'horizontal') 
        Sortable._marker.setStyle({left: (offsets[0]+dropon.clientWidth) + 'px'});
      else
        Sortable._marker.setStyle({top: (offsets[1]+dropon.clientHeight) + 'px'});
    
    Sortable._marker.show();
  },
  
  _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: [],
        position: parent.children.length,
        container: $(children[i]).down(options.treeTag)
      }
      
      /* 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; 
  },

  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: [],
      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) + "[id]=" + 
                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) {
  return element['offset' + ((type=='vertical' || type=='height') ? 'Height' : 'Width')];
}
// script.aculo.us controls.js v1.7.0, Fri Jan 19 19:16:36 CET 2007

// Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
//           (c) 2005, 2006 Ivan Krstic (http://blogs.law.harvard.edu/ivan)
//           (c) 2005, 2006 Jon Tirsen (http://www.tirsen.com)
// Contributors:
//  Richard Livsey
//  Rahul Bhargava
//  Rob Wills
// 
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

// Autocompleter.Base handles all the autocompletion functionality 
// that's independent of the data source for autocompletion. This
// includes drawing the autocompletion menu, observing keyboard
// and mouse events, and similar.
//
// Specific autocompleters need to provide, at the very least, 
// a getUpdatedChoices function that will be invoked every time
// the text inside the monitored textbox changes. This method 
// should get the text for which to provide autocompletion by
// invoking this.getToken(), NOT by directly accessing
// this.element.value. This is to allow incremental tokenized
// autocompletion. Specific auto-completion logic (AJAX, etc)
// belongs in getUpdatedChoices.
//
// Tokenized incremental autocompletion is enabled automatically
// when an autocompleter is instantiated with the 'tokens' option
// in the options parameter, e.g.:
// new Ajax.Autocompleter('id','upd', '/url/', { tokens: ',' });
// will incrementally autocomplete with a comma as the token.
// Additionally, ',' in the above example can be replaced with
// a token array, e.g. { tokens: [',', '\n'] } which
// enables autocompletion on multiple tokens. This is most 
// useful when one of the tokens is \n (a newline), as it 
// allows smart autocompletion after linebreaks.

if(typeof Effect == 'undefined')
  throw("controls.js requires including script.aculo.us' effects.js library");

var Autocompleter = {}
Autocompleter.Base = function() {};
Autocompleter.Base.prototype = {
  baseInitialize: function(element, update, options) {
    this.element     = $(element); 
    this.update      = $(update);  
    this.hasFocus    = false; 
    this.changed     = false; 
    this.active      = false; 
    this.index       = 0;     
    this.entryCount  = 0;

    if(this.setOptions)
      this.setOptions(options);
    else
      this.options = options || {};

    this.options.paramName    = this.options.paramName || this.element.name;
    this.options.tokens       = this.options.tokens || [];
    this.options.frequency    = this.options.frequency || 0.4;
    this.options.minChars     = this.options.minChars || 1;
    this.options.onShow       = this.options.onShow || 
      function(element, update){ 
        if(!update.style.position || update.style.position=='absolute') {
          update.style.position = 'absolute';
          Position.clone(element, update, {
            setHeight: false, 
            offsetTop: element.offsetHeight
          });
        }
        Effect.Appear(update,{duration:0.15});
      };
    this.options.onHide = this.options.onHide || 
      function(element, update){ new Effect.Fade(update,{duration:0.15}) };

    if(typeof(this.options.tokens) == 'string') 
      this.options.tokens = new Array(this.options.tokens);

    this.observer = null;
    
    this.element.setAttribute('autocomplete','off');

    Element.hide(this.update);

    Event.observe(this.element, "blur", this.onBlur.bindAsEventListener(this));
    Event.observe(this.element, "keypress", this.onKeyPress.bindAsEventListener(this));
  },

  show: function() {
    if(Element.getStyle(this.update, 'display')=='none') this.options.onShow(this.element, this.update);
    if(!this.iefix && 
      (navigator.appVersion.indexOf('MSIE')>0) &&
      (navigator.userAgent.indexOf('Opera')<0) &&
      (Element.getStyle(this.update, 'position')=='absolute')) {
      new Insertion.After(this.update, 
       '<iframe id="' + this.update.id + '_iefix" '+
       'style="display:none;position:absolute;filter:progid:DXImageTransform.Microsoft.Alpha(opacity=0);" ' +
       'src="javascript:false;" frameborder="0" scrolling="no"></iframe>');
      this.iefix = $(this.update.id+'_iefix');
    }
    if(this.iefix) setTimeout(this.fixIEOverlapping.bind(this), 50);
  },
  
  fixIEOverlapping: function() {
    Position.clone(this.update, this.iefix, {setTop:(!this.update.style.height)});
    this.iefix.style.zIndex = 1;
    this.update.style.zIndex = 2;
    Element.show(this.iefix);
  },

  hide: function() {
    this.stopIndicator();
    if(Element.getStyle(this.update, 'display')!='none') this.options.onHide(this.element, this.update);
    if(this.iefix) Element.hide(this.iefix);
  },

  startIndicator: function() {
    if(this.options.indicator) Element.show(this.options.indicator);
  },

  stopIndicator: function() {
    if(this.options.indicator) Element.hide(this.options.indicator);
  },

  onKeyPress: function(event) {
    if(this.active)
      switch(event.keyCode) {
       case Event.KEY_TAB:
       case Event.KEY_RETURN:
         this.selectEntry();
         Event.stop(event);
       case Event.KEY_ESC:
         this.hide();
         this.active = false;
         Event.stop(event);
         return;
       case Event.KEY_LEFT:
       case Event.KEY_RIGHT:
         return;
       case Event.KEY_UP:
         this.markPrevious();
         this.render();
         if(navigator.appVersion.indexOf('AppleWebKit')>0) Event.stop(event);
         return;
       case Event.KEY_DOWN:
         this.markNext();
         this.render();
         if(navigator.appVersion.indexOf('AppleWebKit')>0) Event.stop(event);
         return;
      }
     else 
       if(event.keyCode==Event.KEY_TAB || event.keyCode==Event.KEY_RETURN || 
         (navigator.appVersion.indexOf('AppleWebKit') > 0 && event.keyCode == 0)) return;

    this.changed = true;
    this.hasFocus = true;

    if(this.observer) clearTimeout(this.observer);
      this.observer = 
        setTimeout(this.onObserverEvent.bind(this), this.options.frequency*1000);
  },

  activate: function() {
    this.changed = false;
    this.hasFocus = true;
    this.getUpdatedChoices();
  },

  onHover: function(event) {
    var element = Event.findElement(event, 'LI');
    if(this.index != element.autocompleteIndex) 
    {
        this.index = element.autocompleteIndex;
        this.render();
    }
    Event.stop(event);
  },
  
  onClick: function(event) {
    var element = Event.findElement(event, 'LI');
    this.index = element.autocompleteIndex;
    this.selectEntry();
    this.hide();
  },
  
  onBlur: function(event) {
    // needed to make click events working
    setTimeout(this.hide.bind(this), 250);
    this.hasFocus = false;
    this.active = false;     
  }, 
  
  render: function() {
    if(this.entryCount > 0) {
      for (var i = 0; i < this.entryCount; i++)
        this.index==i ? 
          Element.addClassName(this.getEntry(i),"selected") : 
          Element.removeClassName(this.getEntry(i),"selected");
        
      if(this.hasFocus) { 
        this.show();
        this.active = true;
      }
    } else {
      this.active = false;
      this.hide();
    }
  },
  
  markPrevious: function() {
    if(this.index > 0) this.index--
      else this.index = this.entryCount-1;
    this.getEntry(this.index).scrollIntoView(true);
  },
  
  markNext: function() {
    if(this.index < this.entryCount-1) this.index++
      else this.index = 0;
    this.getEntry(this.index).scrollIntoView(false);
  },
  
  getEntry: function(index) {
    return this.update.firstChild.childNodes[index];
  },
  
  getCurrentEntry: function() {
    return this.getEntry(this.index);
  },
  
  selectEntry: function() {
    this.active = false;
    this.updateElement(this.getCurrentEntry());
  },

  updateElement: function(selectedElement) {
    if (this.options.updateElement) {
      this.options.updateElement(selectedElement);
      return;
    }
    var value = '';
    if (this.options.select) {
      var nodes = document.getElementsByClassName(this.options.select, selectedElement) || [];
      if(nodes.length>0) value = Element.collectTextNodes(nodes[0], this.options.select);
    } else
      value = Element.collectTextNodesIgnoreClass(selectedElement, 'informal');
    
    var lastTokenPos = this.findLastToken();
    if (lastTokenPos != -1) {
      var newValue = this.element.value.substr(0, lastTokenPos + 1);
      var whitespace = this.element.value.substr(lastTokenPos + 1).match(/^\s+/);
      if (whitespace)
        newValue += whitespace[0];
      this.element.value = newValue + value;
    } else {
      this.element.value = value;
    }
    this.element.focus();
    
    if (this.options.afterUpdateElement)
      this.options.afterUpdateElement(this.element, selectedElement);
  },

  updateChoices: function(choices) {
    if(!this.changed && this.hasFocus) {
      this.update.innerHTML = choices;
      Element.cleanWhitespace(this.update);
      Element.cleanWhitespace(this.update.down());

      if(this.update.firstChild && this.update.down().childNodes) {
        this.entryCount = 
          this.update.down().childNodes.length;
        for (var i = 0; i < this.entryCount; i++) {
          var entry = this.getEntry(i);
          entry.autocompleteIndex = i;
          this.addObservers(entry);
        }
      } else { 
        this.entryCount = 0;
      }

      this.stopIndicator();
      this.index = 0;
      
      if(this.entryCount==1 && this.options.autoSelect) {
        this.selectEntry();
        this.hide();
      } else {
        this.render();
      }
    }
  },

  addObservers: function(element) {
    Event.observe(element, "mouseover", this.onHover.bindAsEventListener(this));
    Event.observe(element, "click", this.onClick.bindAsEventListener(this));
  },

  onObserverEvent: function() {
    this.changed = false;   
    if(this.getToken().length>=this.options.minChars) {
      this.startIndicator();
      this.getUpdatedChoices();
    } else {
      this.active = false;
      this.hide();
    }
  },

  getToken: function() {
    var tokenPos = this.findLastToken();
    if (tokenPos != -1)
      var ret = this.element.value.substr(tokenPos + 1).replace(/^\s+/,'').replace(/\s+$/,'');
    else
      var ret = this.element.value;

    return /\n/.test(ret) ? '' : ret;
  },

  findLastToken: function() {
    var lastTokenPos = -1;

    for (var i=0; i<this.options.tokens.length; i++) {
      var thisTokenPos = this.element.value.lastIndexOf(this.options.tokens[i]);
      if (thisTokenPos > lastTokenPos)
        lastTokenPos = thisTokenPos;
    }
    return lastTokenPos;
  }
}

Ajax.Autocompleter = Class.create();
Object.extend(Object.extend(Ajax.Autocompleter.prototype, Autocompleter.Base.prototype), {
  initialize: function(element, update, url, options) {
    this.baseInitialize(element, update, options);
    this.options.asynchronous  = true;
    this.options.onComplete    = this.onComplete.bind(this);
    this.options.defaultParams = this.options.parameters || null;
    this.url                   = url;
  },

  getUpdatedChoices: function() {
    entry = encodeURIComponent(this.options.paramName) + '=' + 
      encodeURIComponent(this.getToken());

    this.options.parameters = this.options.callback ?
      this.options.callback(this.element, entry) : entry;

    if(this.options.defaultParams) 
      this.options.parameters += '&' + this.options.defaultParams;

    new Ajax.Request(this.url, this.options);
  },

  onComplete: function(request) {
    this.updateChoices(request.responseText);
  }

});

// The local array autocompleter. Used when you'd prefer to
// inject an array of autocompletion options into the page, rather
// than sending out Ajax queries, which can be quite slow sometimes.
//
// The constructor takes four parameters. The first two are, as usual,
// the id of the monitored textbox, and id of the autocompletion menu.
// The third is the array you want to autocomplete from, and the fourth
// is the options block.
//
// Extra local autocompletion options:
// - choices - How many autocompletion choices to offer
//
// - partialSearch - If false, the autocompleter will match entered
//                    text only at the beginning of strings in the 
//                    autocomplete array. Defaults to true, which will
//                    match text at the beginning of any *word* in the
//                    strings in the autocomplete array. If you want to
//                    search anywhere in the string, additionally set
//                    the option fullSearch to true (default: off).
//
// - fullSsearch - Search anywhere in autocomplete array strings.
//
// - partialChars - How many characters to enter before triggering
//                   a partial match (unlike minChars, which defines
//                   how many characters are required to do any match
//                   at all). Defaults to 2.
//
// - ignoreCase - Whether to ignore case when autocompleting.
//                 Defaults to true.
//
// It's possible to pass in a custom function as the 'selector' 
// option, if you prefer to write your own autocompletion logic.
// In that case, the other options above will not apply unless
// you support them.

Autocompleter.Local = Class.create();
Autocompleter.Local.prototype = Object.extend(new Autocompleter.Base(), {
  initialize: function(element, update, array, options) {
    this.baseInitialize(element, update, options);
    this.options.array = array;
  },

  getUpdatedChoices: function() {
    this.updateChoices(this.options.selector(this));
  },

  setOptions: function(options) {
    this.options = Object.extend({
      choices: 10,
      partialSearch: true,
      partialChars: 2,
      ignoreCase: true,
      fullSearch: false,
      selector: function(instance) {
        var ret       = []; // Beginning matches
        var partial   = []; // Inside matches
        var entry     = instance.getToken();
        var count     = 0;

        for (var i = 0; i < instance.options.array.length &&  
          ret.length < instance.options.choices ; i++) { 

          var elem = instance.options.array[i];
          var foundPos = instance.options.ignoreCase ? 
            elem.toLowerCase().indexOf(entry.toLowerCase()) : 
            elem.indexOf(entry);

          while (foundPos != -1) {
            if (foundPos == 0 && elem.length != entry.length) { 
              ret.push("<li><strong>" + elem.substr(0, entry.length) + "</strong>" + 
                elem.substr(entry.length) + "</li>");
              break;
            } else if (entry.length >= instance.options.partialChars && 
              instance.options.partialSearch && foundPos != -1) {
              if (instance.options.fullSearch || /\s/.test(elem.substr(foundPos-1,1))) {
                partial.push("<li>" + elem.substr(0, foundPos) + "<strong>" +
                  elem.substr(foundPos, entry.length) + "</strong>" + elem.substr(
                  foundPos + entry.length) + "</li>");
                break;
              }
            }

            foundPos = instance.options.ignoreCase ? 
              elem.toLowerCase().indexOf(entry.toLowerCase(), foundPos + 1) : 
              elem.indexOf(entry, foundPos + 1);

          }
        }
        if (partial.length)
          ret = ret.concat(partial.slice(0, instance.options.choices - ret.length))
        return "<ul>" + ret.join('') + "</ul>";
      }
    }, options || {});
  }
});

// AJAX in-place editor
//
// see documentation on http://wiki.script.aculo.us/scriptaculous/show/Ajax.InPlaceEditor

// Use this if you notice weird scrolling problems on some browsers,
// the DOM might be a bit confused when this gets called so do this
// waits 1 ms (with setTimeout) until it does the activation
Field.scrollFreeActivate = function(field) {
  setTimeout(function() {
    Field.activate(field);
  }, 1);
}

Ajax.InPlaceEditor = Class.create();
Ajax.InPlaceEditor.defaultHighlightColor = "#FFFF99";
Ajax.InPlaceEditor.prototype = {
  initialize: function(element, url, options) {
    this.url = url;
    this.element = $(element);

    this.options = Object.extend({
      paramName: "value",
      okButton: true,
      okText: "ok",
      cancelLink: true,
      cancelText: "cancel",
      savingText: "Saving...",
      clickToEditText: "Click to edit",
      okText: "ok",
      rows: 1,
      onComplete: function(transport, element) {
        new Effect.Highlight(element, {startcolor: this.options.highlightcolor});
      },
      onFailure: function(transport) {
        alert("Error communicating with the server: " + transport.responseText.stripTags());
      },
      callback: function(form) {
        return Form.serialize(form);
      },
      handleLineBreaks: true,
      loadingText: 'Loading...',
      savingClassName: 'inplaceeditor-saving',
      loadingClassName: 'inplaceeditor-loading',
      formClassName: 'inplaceeditor-form',
      highlightcolor: Ajax.InPlaceEditor.defaultHighlightColor,
      highlightendcolor: "#FFFFFF",
      externalControl: null,
      submitOnBlur: false,
      ajaxOptions: {},
      evalScripts: false
    }, options || {});

    if(!this.options.formId && this.element.id) {
      this.options.formId = this.element.id + "-inplaceeditor";
      if ($(this.options.formId)) {
        // there's already a form with that name, don't specify an id
        this.options.formId = null;
      }
    }
    
    if (this.options.externalControl) {
      this.options.externalControl = $(this.options.externalControl);
    }
    
    this.originalBackground = Element.getStyle(this.element, 'background-color');
    if (!this.originalBackground) {
      this.originalBackground = "transparent";
    }
    
    this.element.title = this.options.clickToEditText;
    
    this.onclickListener = this.enterEditMode.bindAsEventListener(this);
    this.mouseoverListener = this.enterHover.bindAsEventListener(this);
    this.mouseoutListener = this.leaveHover.bindAsEventListener(this);
    Event.observe(this.element, 'click', this.onclickListener);
    Event.observe(this.element, 'mouseover', this.mouseoverListener);
    Event.observe(this.element, 'mouseout', this.mouseoutListener);
    if (this.options.externalControl) {
      Event.observe(this.options.externalControl, 'click', this.onclickListener);
      Event.observe(this.options.externalControl, 'mouseover', this.mouseoverListener);
      Event.observe(this.options.externalControl, 'mouseout', this.mouseoutListener);
    }
  },
  enterEditMode: function(evt) {
    if (this.saving) return;
    if (this.editing) return;
    this.editing = true;
    this.onEnterEditMode();
    if (this.options.externalControl) {
      Element.hide(this.options.externalControl);
    }
    Element.hide(this.element);
    this.createForm();
    this.element.parentNode.insertBefore(this.form, this.element);
    if (!this.options.loadTextURL) Field.scrollFreeActivate(this.editField);
    // stop the event to avoid a page refresh in Safari
    if (evt) {
      Event.stop(evt);
    }
    return false;
  },
  createForm: function() {
    this.form = document.createElement("form");
    this.form.id = this.options.formId;
    Element.addClassName(this.form, this.options.formClassName)
    this.form.onsubmit = this.onSubmit.bind(this);

    this.createEditField();

    if (this.options.textarea) {
      var br = document.createElement("br");
      this.form.appendChild(br);
    }

    if (this.options.okButton) {
      okButton = document.createElement("input");
      okButton.type = "submit";
      okButton.value = this.options.okText;
      okButton.className = 'editor_ok_button';
      this.form.appendChild(okButton);
    }

    if (this.options.cancelLink) {
      cancelLink = document.createElement("a");
      cancelLink.href = "#";
      cancelLink.appendChild(document.createTextNode(this.options.cancelText));
      cancelLink.onclick = this.onclickCancel.bind(this);
      cancelLink.className = 'editor_cancel';      
      this.form.appendChild(cancelLink);
    }
  },
  hasHTMLLineBreaks: function(string) {
    if (!this.options.handleLineBreaks) return false;
    return string.match(/<br/i) || string.match(/<p>/i);
  },
  convertHTMLLineBreaks: function(string) {
    return string.replace(/<br>/gi, "\n").replace(/<br\/>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<p>/gi, "");
  },
  createEditField: function() {
    var text;
    if(this.options.loadTextURL) {
      text = this.options.loadingText;
    } else {
      text = this.getText();
    }

    var obj = this;
    
    if (this.options.rows == 1 && !this.hasHTMLLineBreaks(text)) {
      this.options.textarea = false;
      var textField = document.createElement("input");
      textField.obj = this;
      textField.type = "text";
      textField.name = this.options.paramName;
      textField.value = text;
      textField.style.backgroundColor = this.options.highlightcolor;
      textField.className = 'editor_field';
      var size = this.options.size || this.options.cols || 0;
      if (size != 0) textField.size = size;
      if (this.options.submitOnBlur)
        textField.onblur = this.onSubmit.bind(this);
      this.editField = textField;
    } else {
      this.options.textarea = true;
      var textArea = document.createElement("textarea");
      textArea.obj = this;
      textArea.name = this.options.paramName;
      textArea.value = this.convertHTMLLineBreaks(text);
      textArea.rows = this.options.rows;
      textArea.cols = this.options.cols || 40;
      textArea.className = 'editor_field';      
      if (this.options.submitOnBlur)
        textArea.onblur = this.onSubmit.bind(this);
      this.editField = textArea;
    }
    
    if(this.options.loadTextURL) {
      this.loadExternalText();
    }
    this.form.appendChild(this.editField);
  },
  getText: function() {
    return this.element.innerHTML;
  },
  loadExternalText: function() {
    Element.addClassName(this.form, this.options.loadingClassName);
    this.editField.disabled = true;
    new Ajax.Request(
      this.options.loadTextURL,
      Object.extend({
        asynchronous: true,
        onComplete: this.onLoadedExternalText.bind(this)
      }, this.options.ajaxOptions)
    );
  },
  onLoadedExternalText: function(transport) {
    Element.removeClassName(this.form, this.options.loadingClassName);
    this.editField.disabled = false;
    this.editField.value = transport.responseText.stripTags();
    Field.scrollFreeActivate(this.editField);
  },
  onclickCancel: function() {
    this.onComplete();
    this.leaveEditMode();
    return false;
  },
  onFailure: function(transport) {
    this.options.onFailure(transport);
    if (this.oldInnerHTML) {
      this.element.innerHTML = this.oldInnerHTML;
      this.oldInnerHTML = null;
    }
    return false;
  },
  onSubmit: function() {
    // onLoading resets these so we need to save them away for the Ajax call
    var form = this.form;
    var value = this.editField.value;
    
    // do this first, sometimes the ajax call returns before we get a chance to switch on Saving...
    // which means this will actually switch on Saving... *after* we've left edit mode causing Saving...
    // to be displayed indefinitely
    this.onLoading();
    
    if (this.options.evalScripts) {
      new Ajax.Request(
        this.url, Object.extend({
          parameters: this.options.callback(form, value),
          onComplete: this.onComplete.bind(this),
          onFailure: this.onFailure.bind(this),
          asynchronous:true, 
          evalScripts:true
        }, this.options.ajaxOptions));
    } else  {
      new Ajax.Updater(
        { success: this.element,
          // don't update on failure (this could be an option)
          failure: null }, 
        this.url, Object.extend({
          parameters: this.options.callback(form, value),
          onComplete: this.onComplete.bind(this),
          onFailure: this.onFailure.bind(this)
        }, this.options.ajaxOptions));
    }
    // stop the event to avoid a page refresh in Safari
    if (arguments.length > 1) {
      Event.stop(arguments[0]);
    }
    return false;
  },
  onLoading: function() {
    this.saving = true;
    this.removeForm();
    this.leaveHover();
    this.showSaving();
  },
  showSaving: function() {
    this.oldInnerHTML = this.element.innerHTML;
    this.element.innerHTML = this.options.savingText;
    Element.addClassName(this.element, this.options.savingClassName);
    this.element.style.backgroundColor = this.originalBackground;
    Element.show(this.element);
  },
  removeForm: function() {
    if(this.form) {
      if (this.form.parentNode) Element.remove(this.form);
      this.form = null;
    }
  },
  enterHover: function() {
    if (this.saving) return;
    this.element.style.backgroundColor = this.options.highlightcolor;
    if (this.effect) {
      this.effect.cancel();
    }
    Element.addClassName(this.element, this.options.hoverClassName)
  },
  leaveHover: function() {
    if (this.options.backgroundColor) {
      this.element.style.backgroundColor = this.oldBackground;
    }
    Element.removeClassName(this.element, this.options.hoverClassName)
    if (this.saving) return;
    this.effect = new Effect.Highlight(this.element, {
      startcolor: this.options.highlightcolor,
      endcolor: this.options.highlightendcolor,
      restorecolor: this.originalBackground
    });
  },
  leaveEditMode: function() {
    Element.removeClassName(this.element, this.options.savingClassName);
    this.removeForm();
    this.leaveHover();
    this.element.style.backgroundColor = this.originalBackground;
    Element.show(this.element);
    if (this.options.externalControl) {
      Element.show(this.options.externalControl);
    }
    this.editing = false;
    this.saving = false;
    this.oldInnerHTML = null;
    this.onLeaveEditMode();
  },
  onComplete: function(transport) {
    this.leaveEditMode();
    this.options.onComplete.bind(this)(transport, this.element);
  },
  onEnterEditMode: function() {},
  onLeaveEditMode: function() {},
  dispose: function() {
    if (this.oldInnerHTML) {
      this.element.innerHTML = this.oldInnerHTML;
    }
    this.leaveEditMode();
    Event.stopObserving(this.element, 'click', this.onclickListener);
    Event.stopObserving(this.element, 'mouseover', this.mouseoverListener);
    Event.stopObserving(this.element, 'mouseout', this.mouseoutListener);
    if (this.options.externalControl) {
      Event.stopObserving(this.options.externalControl, 'click', this.onclickListener);
      Event.stopObserving(this.options.externalControl, 'mouseover', this.mouseoverListener);
      Event.stopObserving(this.options.externalControl, 'mouseout', this.mouseoutListener);
    }
  }
};

Ajax.InPlaceCollectionEditor = Class.create();
Object.extend(Ajax.InPlaceCollectionEditor.prototype, Ajax.InPlaceEditor.prototype);
Object.extend(Ajax.InPlaceCollectionEditor.prototype, {
  createEditField: function() {
    if (!this.cached_selectTag) {
      var selectTag = document.createElement("select");
      var collection = this.options.collection || [];
      var optionTag;
      collection.each(function(e,i) {
        optionTag = document.createElement("option");
        optionTag.value = (e instanceof Array) ? e[0] : e;
        if((typeof this.options.value == 'undefined') && 
          ((e instanceof Array) ? this.element.innerHTML == e[1] : e == optionTag.value)) optionTag.selected = true;
        if(this.options.value==optionTag.value) optionTag.selected = true;
        optionTag.appendChild(document.createTextNode((e instanceof Array) ? e[1] : e));
        selectTag.appendChild(optionTag);
      }.bind(this));
      this.cached_selectTag = selectTag;
    }

    this.editField = this.cached_selectTag;
    if(this.options.loadTextURL) this.loadExternalText();
    this.form.appendChild(this.editField);
    this.options.callback = function(form, value) {
      return "value=" + encodeURIComponent(value);
    }
  }
});

// Delayed observer, like Form.Element.Observer, 
// but waits for delay after last key input
// Ideal for live-search fields

Form.Element.DelayedObserver = Class.create();
Form.Element.DelayedObserver.prototype = {
  initialize: function(element, delay, callback) {
    this.delay     = delay || 0.5;
    this.element   = $(element);
    this.callback  = callback;
    this.timer     = null;
    this.lastValue = $F(this.element); 
    Event.observe(this.element,'keyup',this.delayedListener.bindAsEventListener(this));
  },
  delayedListener: function(event) {
    if(this.lastValue == $F(this.element)) return;
    if(this.timer) clearTimeout(this.timer);
    this.timer = setTimeout(this.onTimerEvent.bind(this), this.delay * 1000);
    this.lastValue = $F(this.element);
  },
  onTimerEvent: function() {
    this.timer = null;
    this.callback(this.element, $F(this.element));
  }
};
/**
 * DatePicker widget using Prototype and Scriptaculous.
 * (c) 2007 Mathieu Jondet <mathieu@eulerian.com>
 * Eulerian Technologies
 *
 * DatePicker is freely distributable under the same terms as Prototype.
 *
 */

var DatePicker = Class.create ();

DatePicker.prototype = {
 Version	: '0.9.2+',
 _input         : null,
 _relative	: null,
 _div		: null,
 _zindex	: 1,
 _keepFieldEmpty: false,
 _daysInMonth	: [31,28,31,30,31,30,31,31,30,31,30,31],
 /* language */
 _language	: 'pl',
 _language_month : $H({
  'en'	: [ 'January', 'February', 'March', 'April', 'May',
	    'June', 'July', 'August', 'September', 'October', 'November', 'December' ],
  'pl'	: [ 'Styczeń', 'Luty', 'Marzec', 'Kwiecień', 'Maj', 'Czerwiec',
	    'Lipiec', 'Sierpień', 'Wrzesień', 'Październik', 'Listopad', 'Grudzień' ]
 }),
 _language_day	: $H({
  'en'	: [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ],
  'pl'	: [ 'pon.', 'wto.', 'śro.', 'czw.', 'pią.', 'sob.', 'nie.' ]
 }),
 _language_close : $H({
  'en'	: 'close',
  'pl'  : 'zamknij'
 }),
 /* date manipulation */
 _todayDate	: new Date(),
 /* _date_regexp	: /^(\d{1,2})(\/|\.|\-)(\d{1,2})(?:\/|\.|\-)(\d{4})$/, */
 _date_regexp	: /^(\d{4})(\/|\.|\-)(\d{1,2})(\/|\.|\-)(\d{1,2})$/,
 _current_date	: null,
 _clickCallback	: Prototype.emptyFunction,
 _date_separator: '-',
 _id_datepicker	: null,
 /* positionning */
 _topOffset	: 30,
 _leftOffset	: 0,
 _isPositionned	: false,
 _relativePosition : true,
 /* return the name of current month in appropriate language */
 getMonthLocale	: function ( month ) {
    return this._language_month[this._language][month];
 },
 getLocaleClose	: function () {
    return this._language_close[this._language];
 },
 _initCurrentDate : function () {
  /* check if value in field is proper, set to today */
  this._current_date = $F(this._input);
  if (!this._date_regexp.test (this._current_date) ) {
   var now	= new Date();
   var day	= this._leftpad_zero(now.getDate(), 2);
   var mon	= this._leftpad_zero(now.getMonth() + 1, 2);

   if (this._language == 'pl')
     this._current_date	= now.getFullYear() + this._date_separator + mon + this._date_separator + day;
   else 
     this._current_date	= day + this._date_separator + mon + this._date_separator + now.getFullYear();
   /* set the field value ? */
   if ( !this._keepFieldEmpty )
    $(this._input).setAttribute ('value', this._current_date);
  }
  var a_date_regexp	= this._current_date.match (this._date_regexp);
  /* fetch date separator as specified in option or via value */
  this._date_separator	= String (a_date_regexp[2]);
  /* check language */
  if ( this._language == 'en' ) {
   this._current_mon	= Number (a_date_regexp[1]) - 1;
   this._current_day	= Number (a_date_regexp[3]);
  } else {
   this._current_day	= Number (a_date_regexp[5]);
   this._current_mon	= Number (a_date_regexp[3]) - 1;
  }
  this._current_year	= Number (a_date_regexp[1]);
 },

 /* init */
 initialize	: function ( h_p ) {
  this._input    = h_p["input"];
  this._relative = h_p["relative"];
  if ( h_p["language"] )
   this._language = h_p["language"];
  this._zindex	= ( h_p["zindex"] ) ? parseInt(Number(h_p["zindex"])) : 1;
  if ( typeof(h_p["keepFieldEmpty"]) != 'undefined' )
   this._keepFieldEmpty	= h_p["keepFieldEmpty"];
  if ( typeof(h_p["clickCallback"]) == 'function' )
   this._clickCallback	= h_p["clickCallback"];
  if ( typeof(h_p["leftOffset"]) != 'undefined' )
   this._leftOffset	= parseInt(h_p["leftOffset"]);
  if ( typeof(h_p["topOffset"]) != 'undefined' )
   this._topOffset	= parseInt(h_p["topOffset"]);
  if ( typeof(h_p["relativePosition"]) != 'undefined' )
   this._relativePosition = h_p["relativePosition"];
  this._id_datepicker		= 'datepicker-'+this._input;
  this._id_datepicker_prev	= this._id_datepicker+'-prev';
  this._id_datepicker_next	= this._id_datepicker+'-next';
  this._id_datepicker_hdr	= this._id_datepicker+'-header';
  this._id_datepicker_ftr	= this._id_datepicker+'-footer';

  if (!$(this._id_datepicker)) {
    /* build up calendar skel */
    this._div = Builder.node ('div', { 
      id : this._id_datepicker,
      className	: 'datepicker',
      style	: 'display: none; z-index: ' + this._zindex 
    }, [
	/* header */
       Builder.node('div', { className : 'datepicker-header' }, [
       Builder.node ('span', { 
	id : this._id_datepicker_prev, style : 'cursor: pointer;' }, ' << '),
       Builder.node ('span', { id : this._id_datepicker_hdr }),
       Builder.node ('span', { 
	id : this._id_datepicker_next, style : 'cursor: pointer;' }, ' >> ')
      ]),
      /* calendar */
      Builder.node('div', { className : 'datepicker-calendar' }, [
       Builder.node('table', { id : this._id_datepicker+'-table' }) ]),
      /* footer */
      Builder.node('div', { 
       id 	: this._id_datepicker_ftr,
       className: 'datepicker-footer hand' }, this.getLocaleClose() )
    ]);
    this.load ();
  }
  else
    this._div = $(this._id_datepicker);
  var self = this;
  $(this._relative).onclick = function () {
    self.click.call (self);
    return false;
  };
 },

 load : function () {
  if (document.body)
    document.body.appendChild (this._div);
  this._initCurrentDate ();
  Event.observe ($(this._id_datepicker_prev), 'click',
		 this.prevMonth.bindAsEventListener(this), false);
  Event.observe ($(this._id_datepicker_next), 'click',
		 this.nextMonth.bindAsEventListener(this), false);
  Event.observe ($(this._id_datepicker_ftr), 'click',
		 this.close.bindAsEventListener(this), false);
 },

 click : function () {
  if (!this._isPositionned && this._relativePosition) {
   /* position the datepicker relatively to element */
   var a_lt = Position.positionedOffset ($(this._relative));
   $(this._id_datepicker).setStyle ({
    'left' : Number (a_lt[0]+this._leftOffset) + 'px',
    'top'  : Number (a_lt[1]+this._topOffset) + 'px'
   });
   this._isPositionned = true;
  }
  if (!$(this._id_datepicker).visible ()) {
   this._initCurrentDate ();
   this._redrawCalendar ();
  }
  /* eval the clickCallback function */
  eval (this._clickCallback());

  new Effect.toggle (this._id_datepicker, 'appear');
 },

 close : function () {
    new Effect.Fade (this._id_datepicker, { duration:0.2 });
 },

 /**
  * setPosition	: set the position of the datepicker.
  *  param : t=top | l=left
  */
 setPosition	: function ( t, l ) {
  var h_pos	= { 'top' : '0px', 'left' : '0px' };
  if ( typeof(t) != 'undefined' )
   h_pos['top']	= Number(t)+this._topOffset+'px';
  if ( typeof(l) != 'undefined' )
   h_pos['left']= Number(l)+this._leftOffset+'px';
  $(this._id_datepicker).setStyle(h_pos);
  this._isPositionned	= true;
 },
 /**
  * _leftpad_zero : pad the provided string to given number of 0
  */
  /** CHECK toPaddedString: from http://dev.rubyonrails.org/changeset/6363 */
 _leftpad_zero	: function ( str, padToLength ) {
  var result	= '';
  for ( var i = 0; i < (padToLength - String(str).length); i++ )
   result	+= '0';
  return	result + str;
 },
 /**
  * _getMonthDays : given the year and month find the number of days.
  */
 _getMonthDays	: function ( year, month ) {
  if (((0 == (year%4)) && 
   ( (0 != (year%100)) || (0 == (year%400)))) && (month == 1))
   return 29;
  return this._daysInMonth[month];
 },
 /**
  * _buildCalendar	: draw the days array for current date
  */
 _buildCalendar		: function () {
  var _self	= this;
  var tbody	= document.createElement('tbody');
  /* generate day headers */
  var trDay	= document.createElement('tr');
  this._language_day[this._language].each( function ( item ) {
   var td	= document.createElement('td');
   td.innerHTML	= item;
   td.className	= 'wday';
   trDay.appendChild( td );
  });
  tbody.appendChild( trDay );
  /* generate the content of days */
  
  /* build-up days matrix */
  var a_d	= [
    [ 0, 0, 0, 0, 0, 0, 0 ]
   ,[ 0, 0, 0, 0, 0, 0, 0 ]
   ,[ 0, 0, 0, 0, 0, 0, 0 ]
   ,[ 0, 0, 0, 0, 0, 0, 0 ]
   ,[ 0, 0, 0, 0, 0, 0, 0 ]
   ,[ 0, 0, 0, 0, 0, 0, 0 ]
  ];
  /* set date at beginning of month to display */
  var d = new Date(this._current_year, this._current_mon, 1, 12);
  /* start the day list on monday */
  var startIndex	= ( !d.getDay() ) ? 6 : d.getDay() - 1;
  var nbDaysInMonth	= this._getMonthDays(
    this._current_year, this._current_mon);
  var daysIndex		= 1;
  for ( var j = startIndex; j < 7; j++ ) {
   a_d[0][j]	= { 
     d : daysIndex
    ,m : this._current_mon
    ,y : this._current_year 
   };
   daysIndex++;
  }
  var a_prevMY	= this._prevMonthYear();
  var nbDaysInMonthPrev	= this._getMonthDays(a_prevMY[1], a_prevMY[0]);
  for ( var j = 0; j < startIndex; j++ ) {
   a_d[0][j]	= { 
     d : Number(nbDaysInMonthPrev - startIndex + j + 1) 
    ,m : Number(a_prevMY[0])
    ,y : a_prevMY[1]
    ,c : 'outbound'
   };
  }
  var switchNextMonth	= false;
  var currentMonth	= this._current_mon;
  var currentYear	= this._current_year;
  for ( var i = 1; i < 6; i++ ) {
   for ( var j = 0; j < 7; j++ ) {
    a_d[i][j]	= { 
      d : daysIndex
     ,m : currentMonth
     ,y : currentYear
     ,c : ( switchNextMonth ) ? 'outbound' : ( 
      ((daysIndex == this._todayDate.getDate()) &&
        (this._current_mon  == this._todayDate.getMonth()) &&
        (this._current_year == this._todayDate.getFullYear())) ? 'today' : null)
    };
    daysIndex++;
    /* if at the end of the month : reset counter */
    if ( daysIndex > nbDaysInMonth ) {
     daysIndex	= 1;
     switchNextMonth = true;
     if ( this._current_mon + 1 > 11 ) {
      currentMonth = 0;
      currentYear += 1;
     } else {
      currentMonth += 1;
     }
    }
   }
  }

  /* generate days for current date */
  for ( var i = 0; i < 6; i++ ) {
   var tr = document.createElement ('tr');
   for ( var j = 0; j < 7; j++ ) {
    var h_ij = a_d[i][j];
    var td = document.createElement ('td');
    /* id is : datepicker-day-mon-year or depending on language other way */
    /* don't forget to add 1 on month for proper formmatting */
    if (this._language == 'pl')
      var id = $A([ this._input, h_ij["y"], this._leftpad_zero((h_ij["m"] +1), 2),
		    this._leftpad_zero(h_ij["d"], 2)]).join('-');
     else
      var id = $A([ this._input, this._leftpad_zero(h_ij["d"], 2),
		    this._leftpad_zero((h_ij["m"] + 1), 2), h_ij["y"] ]).join('-');
    /* set id and classname for cell if exists */
    td.setAttribute ('id', id);
    if (h_ij["c"])
      td.className = h_ij["c"];
    td.className += ' hand';
    /* on onclick : rebuild date value from id of current cell */
    td.onclick = function () { 
     $(_self._input).value = String ($(this).readAttribute ('id')).replace (_self._input + '-', '').replace (/-/g,_self._date_separator); 
     _self.close ();
    };
    td.innerHTML= h_ij["d"];
    tr.appendChild( td );
   }
   tbody.appendChild( tr );
  }
  return tbody;
 },
 /**
  * nextMonth : redraw the calendar content for next month.
  */
 _nextMonthYear	: function () {
  var c_mon	= this._current_mon;
  var c_year	= this._current_year;
  if (c_mon + 1 > 11) {
    c_mon = 0;
    c_year += 1;
  }
  else {
    c_mon += 1;
  }
  return [c_mon, c_year];
 },
 nextMonth : function () {
    var a_next		= this._nextMonthYear ();
    this._current_mon	= a_next[0];
    this._current_year 	= a_next[1];
    this._redrawCalendar ();
 },
 /**
  * prevMonth	: redraw the calendar content for previous month.
  */
 _prevMonthYear	: function () {
  var c_mon	= this._current_mon;
  var c_year	= this._current_year;
  if ( c_mon - 1 < 0 ) {
   c_mon	= 11;
   c_year	-= 1;
  } else {
   c_mon	-= 1;
  }
  return	[ c_mon, c_year ];
 },
 prevMonth : function () {
  var a_prev		= this._prevMonthYear();
  this._current_mon	= a_prev[0];
  this._current_year 	= a_prev[1];
  this._redrawCalendar();
 },
 _redrawCalendar : function () {
  this._setLocaleHdr();
  var table	= $(this._id_datepicker+'-table');
  try {
   while ( table.hasChildNodes() )
    table.removeChild(table.childNodes[0]);
  } catch ( e ) {}
  table.appendChild( this._buildCalendar() );
 },
 _setLocaleHdr : function () {
  /* next link */
  var a_next	= this._nextMonthYear();
  $(this._id_datepicker_next).setAttribute('title',
   this.getMonthLocale(a_next[0])+' '+a_next[1]);
  /* prev link */
  var a_prev	= this._prevMonthYear();
  $(this._id_datepicker_prev).setAttribute('title',
   this.getMonthLocale(a_prev[0])+' '+a_prev[1]);
  /* header */
  $(this._id_datepicker_hdr).update('&nbsp;&nbsp;&nbsp;'+this.getMonthLocale(this._current_mon)+'&nbsp;'+this._current_year+'&nbsp;&nbsp;&nbsp;');
 }
};
/*
 *   mcommon.js
 *   Copyright (C) 2007, 2009 Intercon e-consulting, http://www.intercon.pl
 *   code: Wojciech Polak (http://www.linkedin.com/in/wojciechpolak)
 */

var nua = navigator.userAgent.toLowerCase ();
var opera = nua.indexOf ('opera') != -1;
var msie  = nua.indexOf ('msie') != -1 && (document.all && !opera);
var msie4 = nua.indexOf ('msie 4') != -1 && (document.all && !opera);
var msie5 = nua.indexOf ('msie 5') != -1 && (document.all && !opera);
var msie6 = nua.indexOf ('msie 6') != -1 && (document.all && !opera);
var msie7 = nua.indexOf ('msie 7') != -1 && (document.all && !opera);
var msie8 = nua.indexOf ('msie 8') != -1 && (document.all && !opera);
var webkit = nua.indexOf ('webkit') != -1;
var safari12 = nua.indexOf ('safari') != -1 && nua.indexOf ('chrome') == -1
  && nua.indexOf ('version') == -1;
var linux = nua.indexOf ('linux') != -1;
var ffdeprecated = nua.indexOf ('firefox/1.0') != -1;

function GID (x) {
  return document.getElementById (x);
}

function addEvent (obj, fnc, type) {
  if (!fnc.$$guid) fnc.$$guid = addEvent.guid++;
  if (!obj.events) obj.events = {};
  var hds = obj.events[type];
  if (!hds) {
    hds = obj.events[type] = {};
    if (obj['on' + type])
      hds[0] = obj['on' + type];
  }
  hds[fnc.$$guid] = fnc;
  obj['on' + type] = heEvent;
}
addEvent.guid = 1;

function heEvent (event) {
  event = event || window.event;
  var hds = this.events[event.type];
  for (var i in hds) {
    this.$$heEvent = hds[i];
    this.$$heEvent(event);
  }
}

var MDOM = {
  'traverse' : function (node, cb, args) {
    for (var i = 0; i < node.childNodes.length; i++) {
      var n = node.childNodes[i];
      if (n.tagName != undefined) {
	if (n.childNodes.length) {
	  cb (n, args);
	  MDOM.traverse (n, cb, args);
	} else {
	  cb (n, args);
	}
      }
    }
  },
  'findParentContainer' : function (n, stop) {
    while (n.parentNode) {
      if (n.className == stop)
	return n;
      n = n.parentNode;
    }
    return n;
  },
  'getWindowWidth' : function () {
    if (typeof window.innerWidth != 'undefined')
      return window.innerWidth;
    else if (document.documentElement && 
	     typeof document.documentElement.clientWidth != 'undefined' &&
	     document.documentElement.clientWidth != 0)
      return document.documentElement.clientWidth;
    else if (document.body && typeof document.body.clientWidth != 'undefined')
      return document.body.clientWidth;
    return 0;
  },
  'getWindowHeight' : function () {
    if (typeof window.innerHeight != 'undefined')
      return window.innerHeight;
    else if (document.documentElement && 
	     typeof document.documentElement.clientHeight != 'undefined' &&
	     document.documentElement.clientHeight != 0)
      return document.documentElement.clientHeight;
    else if (document.body && typeof document.body.clientHeight != 'undefined')
      return document.body.clientHeight;
    return 0;
  },
  'getDocumentHeight' : function () {
    if (document.documentElement && 
	typeof document.documentElement.scrollHeight != 'undefined' &&
	document.documentElement.scrollHeight != 0)
      return document.documentElement.scrollHeight;
    return 0;
  },
  'getScrollY' : function () {
    if (document.body && document.body.scrollTop)
      return document.body.scrollTop;
    else if (document.documentElement && document.documentElement.scrollTop)
      return document.documentElement.scrollTop;
    return 0;
  },
  'getInnerWidth' : function (obj) {
    if (obj)
      return obj.clientWidth;
    return 0;
  },
  'getInnerHeight' : function () {
    if (window.innerHeight)
      return window.innerHeight;
    else if (document.body.clientHeight)
      return document.body.clientHeight;
    else
      return 0;
  },
  'getStyle' : function (x, styleProp) {
    if (document.defaultView && document.defaultView.getComputedStyle)
      return document.defaultView.getComputedStyle (x, null).getPropertyValue (styleProp);
    else if (x.currentStyle)
      return x.currentStyle[styleProp];
    return null;
  },
  'center' : function (obj) {
    var innerWidth = 0;
    var innerHeight = 0;
    if (opera || webkit) obj.style.display = 'block';
    var objWidth  = this.getStyle (obj, 'width');
    var objHeight = this.getStyle (obj, 'height');
    if (objWidth == '0px' || objWidth == 'auto') {
      objWidth = obj.offsetWidth + 'px';
      objHeight = obj.offsetHeight + 'px';
    }
    if (objHeight.indexOf ('px') == -1) {
      obj.style.display = 'block';
      objHeight = obj.clientHeight;
    }
    objWidth = parseInt (objWidth);
    objHeight = parseInt (objHeight);
    if (window.innerWidth) {
      innerWidth  = window.innerWidth / 2;
      innerHeight = window.innerHeight / 2 - 20;
    } else if (document.body.clientWidth) {
      innerWidth  = document.body.clientWidth / 2;
      innerHeight = this.getWindowHeight () / 2 - 20;
    }
    var wleft = innerWidth - (objWidth / 2);
    if (wleft < 0) wleft = 0;
    obj.style.left = wleft + 'px';
    obj.style.top  = this.getScrollY () + innerHeight - (objHeight/2) + 'px';
    if (parseInt (obj.style.top) < 1)
      obj.style.top = '1px';
  },
  'findPosX' : function (obj) {
    var left = 0;
    if (obj.offsetParent) {
      while (obj.offsetParent) {
	left += obj.offsetLeft;
	obj = obj.offsetParent;
      }
    }
    else if (obj.x)
      left += obj.x;
    return left;
  },
  'findPosY' : function (obj) {
    var top = 0;
    if (obj.offsetParent) {
      while (obj.offsetParent) {
	top += obj.offsetTop;
	obj = obj.offsetParent;
      }
    }
    else if (obj.y)
      top += obj.y;
    return top;
  },
  'jumpToWTop' : function () {
    if (document.body && document.body.scrollTop)
      document.body.scrollTop = 0;
    else if (document.documentElement && document.documentElement.scrollTop)
      document.documentElement.scrollTop = 0;
  },
  'clearSelection' : function () {
    try {
      if (window.getSelection)
	window.getSelection().removeAllRanges ();
      else if (document.selection)
	document.selection.empty ();
    } catch (e) {}
  },
  'saveCookie' : function (name, value, days) {
    var domain = '';
    var expires = '';
    if (days) {
      var date = new Date ();
      date.setTime (date.getTime () + (days * 86400000));
      var expires = '; expires=' + date.toGMTString ();
    }
    if (!webkit && document.domain != 'localhost') {
      if (document.domain.indexOf ('www.') == 0)
	domain = '; domain=.' + document.domain.substr (4);
      else
	domain = '; domain=' + document.domain;
    }
    document.cookie = name +'='+ value + expires + domain + '; path=/';
  },
  'readCookie' : function (name) {
    var nameEq = name + '=';
    var ca = document.cookie.split (';');
    for (var i = 0; i < ca.length; i++) {
      var c = ca[i];
      while (c.charAt (0) == ' ')
	c = c.substring (1, c.length);
      if (c.indexOf (nameEq) == 0)
	return c.substring (nameEq.length, c.length);
    }
    return null;
  },
  'removeClass' : function (obj, cln) {
    obj.className = obj.className.replace (cln, '');
  },
  'highlight' : function (obj) {
    new Effect.Highlight (obj, {startcolor:'#ff6600', endcolor:'#891d1d', duration:1.0});
  }
}

var MUtils = {
  'formatInputDate' : function (input) {
    input.value = MUtils.formatYYYYMMDD (input.value);
  },
  'formatYYYYMMDD' : function (val) {
    if (!val.match (/^\d{4}-\d{2}-\d{2}$/)) {
      if (val.match (/^\d{2}\s+\d{2}\s+\d{4}$/))
	val = val.replace (/^(\d{2})\s+(\d{2})\s+(\d{4})$/, '$3-$2-$1');
      else if (val.match (/^\d{4}\d{2}\d{2}$/))
	val = val.replace (/^(\d{4})(\d{2})(\d{2})$/, '$1-$2-$3');
      else if (val.match (/^\d{4}\W+\d{2}\W+\d{2}$/))
	val = val.replace (/^(\d{4})\W+(\d{2})\W+(\d{2})$/, '$1-$2-$3');
      else if (val.match (/^\d{2}\W+\d{2}\W+\d{4}$/))
	val = val.replace (/^(\d{2})\W+(\d{2})\W+(\d{4})$/, '$3-$2-$1');
      else if (val.match (/^\d{4}\s+\d{2}\s+\d{2}$/))
	val = val.replace (/^(\d{4})\s+(\d{2})\s+(\d{2})$/, '$1-$2-$3');
      else if (val.match (/^\d{2}\s+\d{2}\d{4}$/))
	val = val.replace (/^(\d{2})\s+(\d{2})(\d{4})$/, '$3-$2-$1');
      else if (val.match (/^\d{2}\d{2}\s+\d{4}$/))
	val = val.replace (/^(\d{2})(\d{2})\s+(\d{4})$/, '$3-$2-$1');
      else if (val.match (/^\d{2}\d{2}\W+\d{4}$/))
	val = val.replace (/^(\d{2})(\d{2})\W+(\d{4})$/, '$3-$2-$1');
      else if (val.match (/^\w{2}\w{2}\w{4}.+$/))
	val = val.replace (/^(\w{2})(\w{2})(\w{4}).+$/, '$3-$2-$1');
      else if (val.length > 10)
	val = val.substring (0, 10);
    }
    return val;
  },
  'focusSearch' : function () {
    if (this.value == this.DEFAULT_SEARCHVAL) {
      this.value = '';
      this.className = 'focus';
    }
  },
  'blurSearch' : function () {
    if (this.value == '') {
      this.value = this.DEFAULT_SEARCHVAL;
      this.className = '';
    }
  },
  'setDefaultSearch' : function (input, defval) {
    if (!input && !defval) return;
    input.DEFAULT_SEARCHVAL = defval;
    input.autocomplete = 'off';
    input.onfocus = MUtils.focusSearch;
    input.onblur  = MUtils.blurSearch;
    if (input.value == '')
      input.value = input.DEFAULT_SEARCHVAL;
  }
};

var Overlay = new function () {
  var visible = false;
  var ovl = null;
  this.enable = function () {
    if (visible) return;
    ovl = document.createElement ('DIV');
    if (ovl) {
      ovl.id = 'overlay';
      ovl.style.position = 'absolute';
      ovl.style.width = '100%';
      ovl.style.height = MDOM.getDocumentHeight () + 'px';
      ovl.style.top = 0;
      ovl.style.left = 0;
      ovl.style.backgroundColor = 'black';
      ovl.style.opacity = '0.80';
      ovl.style.filter = 'alpha(opacity=80)';
      ovl.style.zIndex = '9777';
      ovl.style.display = 'block';
      document.body.appendChild (ovl);
      visible = true;
    }
  };
  this.disable = function () {
    if (ovl) {
      document.body.removeChild (ovl);
      visible = false;
    }
  };
};

var WVManager = new function () {
  var self = this;
  var initied = false;
  var visible = false;

  this.title = '';
  this.element = null;
  this.hd = null;
  this.bd = null;
  this.hd_title = null;
  this.hd_close = null;
  this.onhide = null;
  this.ifr = null;

  this.element = document.createElement ('DIV');
  this.element.id = 'window';
  this.element.className = 'window';
  this.element.style.display = 'none';
  this.hd = document.createElement ('DIV');
  this.hd.id = 'hd_' + this.element.id;
  this.hd.className = 'hd';
  this.bd = document.createElement ('DIV');
  this.bd.id = 'bd_' + this.element.id;
  this.bd.className = 'bd';
  this.element.appendChild (this.hd);
  this.element.appendChild (this.bd);

  for (var i = 1; i <= 4; i++) {
    var cr = 'cr_' + i;
    this[cr] = document.createElement ('DIV');
    this[cr].id = 'cr_module_' + i;
    this[cr].className = cr;
    this.element.appendChild (this[cr]);
  }

  if (msie6 || linux) {
    this.ifr = document.createElement ('IFRAME');
    this.ifr.id = 'window_ifrMSIEfix';
    this.ifr.style.position = 'absolute';
    this.ifr.style.zIndex = '8888';
    this.ifr.style.border = 'none';
    this.ifr.frameBorder = 'none';
  }

  this.hd_icon = document.createElement ('DIV');
  this.hd_icon.className = 'icon';
  this.hd_icon.className += ' ico_szukaj';
  this.hd_icon.style.display = 'block';

  this.hd_title = document.createElement ('DIV');
  this.hd_title.className = 'title';

  this.hd_close = document.createElement ('DIV');
  this.hd_close.className = 'close hand';
  this.hd_close.title = 'Zamknij';
  this.hd_close.onmouseover = function () { self.hd_close.className = 'close_hover hand'; };
  this.hd_close.onmouseout = function () { self.hd_close.className = 'close hand'; };
  this.hd_close.onclick = function (e) {
    if (!e) var e = window.event;
    e.cancelBubble = true;
    if (e.stopPropagation) e.stopPropagation ();
    self.hide ();
  };

  this.hd.appendChild (this.hd_close);
  this.hd.appendChild (this.hd_icon);
  this.hd.appendChild (this.hd_title);

  function init () {
    if (initied) return;
    document.body.appendChild (this.element);
    if (this.ifr)
      document.body.appendChild (this.ifr);
    initied = true;
  }

  this.isVisible = function () {
    return visible;
  };

  this.show = function (title) {
    if (!visible) {
      Overlay.enable ();
      this.onhide = Overlay.disable;
      init.call (this);
      self.resize ();
      if (title)
	this.hd_title.innerHTML = this.title = title;
      if (this.ifr) {
	this.ifr.style.display = 'block';
	MDOM.center (this.ifr);
      }
      MDOM.center (this.element);
      this.element.style.display = 'block';
      if (this.ifr) {
	this.ifr.style.top = this.element.offsetTop + 'px';
	this.ifr.style.left = this.element.offsetLeft + 'px';
      }
      visible = true;
    }
  };

  this.hide = function (nohist) {
    if (visible) {
      this.element.style.display = 'none';
      if (this.ifr) this.ifr.style.display = 'none';
      visible = false;
      if (typeof self.onhide == 'function') {
	self.onhide ();
	self.onhide = null;
      }
      if (window.HistoryManager && typeof nohist == 'undefined')
	HistoryManager.save ({'wvm.hide' : true});
      if (window.init_cf) {
	MFApp.showWs ();
	window.init_cf = null;
      }
    }
  };

  this.showLoader = function () {
    this.hd_title.innerHTML = '<span class="loading">Trwa ładowanie danych...</span>';
  };

  this.hideLoader = function () {
    this.hd_title.innerHTML = this.title;
  };

  this.load = function (url, nohist) {
    self.setBody ('');
    self.showLoader ();
    if (window.HistoryManager && typeof nohist == 'undefined')
      HistoryManager.save ({'wvm.load' : [url, FVManager.isVisible ()]});
    new Ajax.Request ('wv/' + basename (url),
    { method:'get', onSuccess:function (res) {
	self.hideLoader ();
	self.setBody (res.responseText);
	if (typeof self.onload == 'function') {
	  self.onload ();
	  self.onload = null;
	}
      },
	onFailure:function (res) {
	self.hideLoader ();
	self.setBody (MFApp.httpError ());
      }
    });
  };

  this.setOnload = function (fnc) {
    if (typeof fnc == 'function')
      self.onload = fnc;
  }

  this.open = function (title, url) {
    self.show (title);
    self.load (url);
  };

  this.post = function (url, params) {
    self.setBody ('');
    self.showLoader ();
    new Ajax.Request ('wv/' + basename (url),
    { method:'post', parameters:params, onSuccess:function (res) {
	self.hideLoader ();
	self.setBody (res.responseText);
	if (typeof self.onload == 'function') {
	  self.onload ();
	  self.onload = null;
	}
      },
	onFailure:function (res) {
	self.hideLoader ();
	self.setBody (MFApp.httpError ());
      }
    });
  };

  this.resize = function () {
    self.element.style.width = '600px';
    self.element.style.height = '440px';
    self.bd.style.height = (440 - parseInt (MDOM.getStyle (self.hd, 'height')) - 20) + 'px';
    if (self.ifr) {
      self.ifr.style.width = self.element.style.width;
      self.ifr.style.height = self.element.style.height;
    }
  };

  this.setSize = function (width, height) {
    var w = parseInt (width ? width : 600);
    var h = parseInt (height ? height : 440);
    self.element.style.width  = w + 'px';
    self.element.style.height = h + 'px';
    if (self.ifr) {
      self.ifr.style.width = self.element.style.width;
      self.ifr.style.height = self.element.style.height;
    }
  };

  this.setBody = function (src) {
    if (typeof src == 'string')
      this.bd.innerHTML = src;
    else {
      this.bd.innerHTML = '';
      this.bd.appendChild (src);
    }
  };

  function basename (url) {
    var b = url.split ('/');
    if (b.length == 1)
      b = url.split ('\\');
    b = b[b.length - 1];
    return b;
  }
};

var SearchManager = new function () {
  var self = this;
  var driverFV  = 'fv_search.php';
  var driverAPI = 'api/get_category.php';

  var where_stay = '';
  var box_stay  = null;
  var box2_stay = null;
  var box3_stay = null;
  var what_stay = null;

  function setDefault (box2) {
    if (box2 != null) {
      box2.options.length = 0;
      box2.value = '';
      box2.options[0] = new Option ('-- dowolna branża --', '', true, true);
    }
  }

  this.simpleSearch = function (query) {
    FVManager.setOnload (SearchManager.tht);
    FVManager.load (driverFV + '?search=' + encodeURIComponent (query));
  };

  this.openSearchAdvanced = function () {
    FVManager.setOnload (SearchManager.tht);
    FVManager.load (driverFV);
    return false;
  };

  this.browse = function (obj) {
    var p = obj.href.indexOf ('?');
    var q = obj.href.substring (p + 1, obj.href.length);
    FVManager.setOnload (SearchManager.tht);
    FVManager.load (driverFV + '?' + q);
    return false;
  };

  this.openFV = function () {
    FVManager.setOnload (SearchManager.tht);
    FVManager.load (driverFV + '?latest=1');
    return false;
  };

  this.tht = function () {
    MFApp.toggleNav (6);
    MFStats.hit ('search');
    document.title = 'Firmy';
  };

  this.getCategory = function (where, box, box2, box3, what) {
    var show_all = '';
    where_stay = where;
    box_stay = box;
    box2_stay = box2;
    box3_stay = box3;
    what_stay = what;

    var number = null;
    if (where_stay == 'cat1') {
      number = box_stay.options[box_stay.selectedIndex].value;
      setDefault (box3_stay);
      setDefault (box2_stay);
    }
    else if (where_stay == 'cat2') {
      number = box2_stay.options[box2_stay.selectedIndex].value;
      setDefault (box3_stay);
    }
    else
      return null;
         	
    if (number == '')
      return null;

    if (what_stay == 1)
      FVManager.showLoader ();
    else {
      show_all = '&all=1';
      var ld = document.getElementById ('mainLoader');
      if (ld) ld.style.display = 'block';
    }
    var pars = where + '=' + number + show_all;
    new Ajax.Request (driverAPI, { method:'get',
	  parameters:pars, onComplete:getResponseForCategory });
  };

  function getResponseForCategory (res) {
    if (what_stay == 1)
      FVManager.hideLoader ();
    else {
      var ld = document.getElementById ('mainLoader');
      if (ld) ld.style.display = 'none';
    }

    if (where_stay == 'cat1')
      box_stay = box2_stay;
    else if (where_stay == 'cat2')
      box_stay = box3_stay;
    else
      return null;

    var xresult = [];
    try {
      xresult = eval ('(' + res.responseText + ')');
    } catch (e) {
      MFApp.log (e);
    }
    if (xresult.length == 0) {
      setDefault (box_stay);
      return null;
    }
    box_stay.options.length = 0;
    for (i = 0; i < xresult.length; i += 2) {
      box_stay.options[i/2] = new Option (xresult[i], xresult[i+1]);
    }
    box_stay.selectedIndex = 0;
  }
  
  this.hideMOS = function () {
    GID ('fv_search_advanced_more').className = '';
    GID ('fv_search_advanced_mos').className = 'hidden';
    return false;
  };

  this.submitAdvancedForm = function () {
    try {
      var box = null;
      var name = document.search_advanced_form.name.value;
      var address = document.search_advanced_form.address.value;
      var city = document.search_advanced_form.city.value;
      var area = document.search_advanced_form.area.value;

      box = document.search_advanced_form.cat1;
      var cat1 = box.options[box.selectedIndex].value;
      box = document.search_advanced_form.cat2;
      var cat2 = box.options[box.selectedIndex].value;
      box = document.search_advanced_form.cat3;
      var cat3 = box.options[box.selectedIndex].value;

      var pars = 'name=' + encodeURIComponent (name)
	+ "&address=" + encodeURIComponent (address)
	+ "&city=" + encodeURIComponent (city)
	+ "&area=" + encodeURIComponent (area)
	+ "&cat1=" + cat1
	+ "&cat2=" + cat2
	+ "&cat3=" + cat3;

      if (name == '' && address == '' && city == '' && area == '' && cat1 == '')
	MFApp.alert ('Należy coś wpisać lub zaznaczyć.');
      else {
	if ((name != '' && name.length < 2) ||
	    (address != '' && address.length < 2) ||
	    (city != '' && city.length < 2))
	  MFApp.alert ('Wpisz co najmniej 2 znaki');
	else {
	  FVManager.showLoader ();
	  HistoryManager.save ({'fvm.load' : [driverFV + '?' + pars, null]});
	  new Ajax.Request ('fv/' + driverFV, { method:'get', parameters:pars,
		onComplete:function (res) {
		FVManager.setBody (res.responseText);
		FVManager.hideLoader ();
	      }
	  });
	}
      }
    } catch (e) {
      MFApp.log (e);
    }
    return false;
  };
};

var TooltipManager = {
  'tooltip' : null,
  'isEnabled' : true,
  'offsetfromcursorX' : -7,
  'offsetfromcursorY' : 23,
  'offsetdivfrompointerX' : 0,
  'offsetdivfrompointerY' : 0,
  'show' : function () {
    if (!TooltipManager.isEnabled) return;
    var id = this.id.split ('_')[1];
    var ebi = GID ('ebi_' + id);
    if (ebi) {
      if (ebi.innerHTML.length > 0) {
	TooltipManager.tooltip.style.textAlign = 'left';
	TooltipManager.tooltip.style.direction = 'ltr';
	if (typeof ebi.parentNode.dir != 'undefined') {
	  if (ebi.parentNode.dir == 'rtl') {
	    TooltipManager.tooltip.style.textAlign = 'right';
	    TooltipManager.tooltip.style.direction = 'rtl';
	  }
	}
	TooltipManager.tooltip.innerHTML = ebi.innerHTML.unescapeHTML ().stripTags ();
	document.onmousemove = TooltipManager.move;
	TooltipManager.tooltip.style.display = 'block';
      }
    }
  },
  'hide' : function () {
    document.onmousemove = null;
    TooltipManager.tooltip.style.display = 'none';
  },
  'enable' : function () {
    TooltipManager.isEnabled = true;
  },
  'disable' : function () {
    TooltipManager.isEnabled = false;
    TooltipManager.hide ();
  },
  'ietruebody' : function () {
    return (document.compatMode && document.compatMode != 'BackCompat') ? document.documentElement : document.body;
  },
  'move' : function (e) {
    if (!TooltipManager.tooltip) return;
    if (!e) var e = window.event;
    var nondefaultpos = false;
    var curX = (e.pageX) ? e.pageX : e.clientX + TooltipManager.ietruebody ().scrollLeft;
    var curY = (e.pageY) ? e.pageY : e.clientY + TooltipManager.ietruebody ().scrollTop;
    var winwidth = (msie && !opera) ? TooltipManager.ietruebody().clientWidth : window.innerWidth - 20;
    var winheight = (msie && !opera) ? TooltipManager.ietruebody().clientHeight : window.innerHeight - 20;
    var rightedge = (msie && !opera) ? winwidth - e.clientX - TooltipManager.offsetfromcursorX
                                     : winwidth - e.clientX - TooltipManager.offsetfromcursorX;
    var bottomedge = (msie && !opera) ? winheight - e.clientY - TooltipManager.offsetfromcursorY
                                      : winheight - e.clientY - TooltipManager.offsetfromcursorY;
    var leftedge = (TooltipManager.offsetfromcursorX < 0) ? TooltipManager.offsetfromcursorX * (-1) : -1000;

    if (rightedge < TooltipManager.tooltip.offsetWidth) {
      TooltipManager.tooltip.style.left = curX - TooltipManager.tooltip.offsetWidth + 'px';
      nondefaultpos = true;
    }
    else if (curX < leftedge)
      TooltipManager.tooltip.style.left = '5px';
    else
      TooltipManager.tooltip.style.left = curX
	+ TooltipManager.offsetfromcursorX
	- TooltipManager.offsetdivfrompointerX + 'px';
    
    if (bottomedge < TooltipManager.tooltip.offsetHeight) {
      TooltipManager.tooltip.style.top = curY
	- TooltipManager.tooltip.offsetHeight
	- TooltipManager.offsetfromcursorY + 'px';
      nondefaultpos = true;
    }
    else {
      TooltipManager.tooltip.style.top = curY
      + TooltipManager.offsetfromcursorY
      + TooltipManager.offsetdivfrompointerY + 'px';
    }
    TooltipManager.tooltip.style.display = 'block';
  }
}
/*
 *   mcore.js
 *   Copyright (C) 2007-2010 Intercon e-consulting, http://www.intercon.pl
 *   code: Wojciech Polak (http://www.linkedin.com/in/wojciechpolak)
 */

var MFApp = new function () {
  var self = this;
  var version = "2.1 (Make Some Noise Again)";
  var initied = false;
  var psModules = null;
  var psHiddenModules = null;
  var settingsChanged = false;
  var saveSettingsIntv = null;
  this.cookieNameModules       = 'mfModules';
  this.cookieNameHiddenModules = 'mfHiddenModules';

  this.getVersion = function () {
    return version;
  };

  function init () {
    if (initied) return;

    if (msie4 || msie5 || safari12) {
      document.location = 'unsupported.html';
      return;
    }
    checkTsl ();

    var showMainPage =  function () {
      if (FVManager.isVisible () || WVManager.isVisible ()) {
	WVManager.hide (true);
	FVManager.hide (true);
	HistoryManager.save ({'cleanup' : true});
      }
      self.showWs ();
      return false;
    };

    prepareLink ('linkMainPage1', showMainPage);
    prepareLink ('linkMainPage2', showMainPage);
    prepareLink ('linkCards', SearchManager.openFV);
    prepareLink ('linkOffers', OffersManager.openFV);
    prepareLink ('linkBusiness', BusinessManager.openFV);
    prepareLink ('linkRegulamin', function () { return AppManager.openPage1 ('regulamin'); } );
    prepareLink ('linkFAQ', function () { return AppManager.openPage2 ('faq', 'faq_1'); } );
    prepareLink ('linkKontakt', AppManager.composeFeedback);
    prepareLink ('linkKsiegowosc', function () {
        if (userSettings.logged) {
	  if (userSettings.kind == 'B') {
	    MFApp.showLoader (); self.hideWs ();
	    MFApp.toggleNav (4);
	    MFStats.hit ('invoice');
	    var url = this.href;
	    setTimeout (function () { document.location = url; }, 200);
	  }
	  else
	    MFApp.notBusinessError ();
	}
	else
	  MFApp.notLoggedError ();
	return false;
      });
    prepareLink ('linkMBusiness', function () {
	MFStats.hit ('mbusiness');
	AppManager.openPage2 ('mbiznes', 'main');
	MFApp.toggleNav (5);
	return false;
      });
    prepareLink ('linkLoginForm', function () {
	MFStats.hit ('login');
	var url = this.href;
	setTimeout (function () { document.location = url; }, 200);
	return false;
      });
    prepareLink ('linkRegisterForm', function () {
	MFStats.hit ('register');
	var url = this.href;
	setTimeout (function () { document.location = url; }, 200);
	return false;
      });
    prepareLink ('addModule', ModulesManager.openFreeModuleList);

    MUtils.setDefaultSearch (GID ('searchBox'), 'szukaj firmy...');

    var searchForm = GID ('searchForm');
    if (searchForm) {
      searchForm.onsubmit = function () {
	var searchBox = GID ('searchBox');
	if (searchBox.value != '' && searchBox.value != searchBox.DEFAULT_SEARCHVAL) {
	  if (searchBox.value.length < 2)
	    MFApp.alert ('Wpisz co najmniej 2 znaki');
	  else if (searchBox.value.substr (0, 4) == '$mf:') {
	    var cmd = cth (searchBox.value.substr (4));
	    if (cmd == '76657273696F6E')
	      MFApp.alert (MFApp.getVersion ());
	  }
	  else
	    SearchManager.simpleSearch (searchBox.value);
	}
	return false;
      };
    }

    TooltipManager.tooltip = GID ('tooltip');

    HistoryManager.init (historyRestore);
    document.onkeypress = shortcutsHandler;

    if (!msie7 && !msie8) {
      positionFooter ();
      window.onresize = positionFooter;
    }

    MFStats.hit ('main');

    if (window.mfOnLoad && typeof mfOnLoad == 'function')
      mfOnLoad ();
    else {
      initWs ();
      self.showWs ();
    }

    initied = true;
  }

  var initiedWs = false;
  var visibleWs = false;
  var workspace = null;
  function initWs () {
    if (initiedWs) return;
    workspace = GID ('workspace');
    if (!workspace) {
      initiedWs = false;
      return;
    }

    ModulesManager.addColumn (GID ('col1'));
    ModulesManager.addColumn (GID ('col2'));
    ModulesManager.addColumn (GID ('col3'));
    GridResizer.init ();
    loadBaners ();

    var layout = null;
    if (typeof userSettings.modules != 'undefined')
      layout = psModules = userSettings.modules;
    else
      layout = psModules = MDOM.readCookie (self.cookieNameModules);
    if (!layout)
      layout = '10.m12,9.m11,1.m2,2.m3:3.m1,4.m10:5.m9,6.m8,7.m4,8.m6';

    var hiddenModulesCookie = null;
    if (typeof userSettings.hiddenModules != 'undefined')
      hiddenModulesCookie = psHiddenModules = userSettings.hiddenModules;
    else
      hiddenModulesCookie = psHiddenModules = MDOM.readCookie (self.cookieNameHiddenModules);
    var hiddenModules = {};
    if (hiddenModulesCookie) {
      var hmarr = hiddenModulesCookie.split (',');
      for (var i = 0; i < hmarr.length; i++) {
	hiddenModules[hmarr[i]] = true;
      }
    }

    OffersManager.init ();
    NkManager.init ();
    FeedManager.init ();

    // MFApp.log ('l: ' + layout);
    // MFApp.log ('v: ' + hiddenModulesCookie);

    ModulesManager.restoreLayout (layout, hiddenModules);

    if (!ModulesManager.isVisible ('m2'))
      ModulesManager.addModule.call ({'typeId':'m2', 'silent':true});
    if (!ModulesManager.isVisible ('m9'))
      ModulesManager.addModule.call ({'typeId':'m9', 'silent':true});

    if (userSettings.logged) {
      var rls = {
	'r18' : { ts:1202961600, newmod:['m10'] },
	'r19' : { ts:1210251600, newmod:['m11'] },
	'r21' : { ts:1247580000, newmod:['m12'] }
      }
      for (var rl in rls) {
	var diff = rls[rl].ts - userSettings.mstamp;
	if (diff > 0 && rls[rl].ts < systemSettings.time) {
	  for (var i = 0; i < rls[rl].newmod.length; i++) {
	    ModulesManager.prependModule.call ({'typeId':rls[rl].newmod[i]});
	  }
	}
      }
    }

    ModulesManager.initDragging ();

    if (msie || opera)
      window.onunload = exit;
    else
      window.onbeforeunload = exit;

    initiedWs = true;
  }

  this.hideWs = function () {
    if (visibleWs) {
      workspace.className = 'hidden';
      GID ('addModule').style.display = 'none';
      visibleWs = false;
    }
  };

  this.showWs = function () {
    if (!initiedWs) initWs ();
    if (!visibleWs) {
      workspace.className = '';
      workspace.style.height = 'auto';
      GID ('addModule').style.display = 'block';
      self.toggleNav (1);
      document.title = 'mikroFirmy.pl';
      visibleWs = true;
    }
  };

  var tsl = false;
  function checkTsl () {
    var t = GID ('tsl');
    if (t) {
      var z = t.href.lastIndexOf ('/');
      var ts = t.href.substring (z + 1, t.href.length);
      if (ts.charAt (0) == '?') ts = ts.substr (1);
      if (ts.length > 0) tsl = ts;
    }
  };
  this.getTsl = function () {
    return tsl;
  }

  function shortcutsHandler (e) {
    var code;
    if (!e) var e = window.event;
    if (e.keyCode) code = e.keyCode;
    else if (e.which) code = e.which;
    if (e.ctrlKey) return true;
    var el = (window.event) ? e.srcElement : e.target;
    if (el.tagName == 'INPUT' || el.tagName == 'TEXTAREA')
      return;
    switch (code) {
      case 119: /* w */
	if (WVManager.isVisible ())
	  WVManager.hide ();
	else if (FVManager.isVisible ())
	  FVManager.hide ();
	break;
    }
  }

  function cth (s) {
    var hd = ['0','1','2','3','4','5','6','7',
              '8','9','A','B','C','D','E','F'];
    var hs = '';
    var i, n;
    for (i = 0; i < s.length; i++) {
      n = s.charCodeAt (i);
      if (n != 0)
        hs += (hd[(n >> 4) & 0xf] + hd[n & 0xf]);
    }
    return hs;
  }

  function prepareLink (id, fnc) {
    var obj = GID (id);
    if (obj) obj.onclick = fnc;
  }

  function historyRestore (hash, st) {
    for (var cmd in st) {
      if (cmd == 'cleanup') {
	WVManager.hide (true);
	FVManager.hide (true);
      }
      else if (cmd == 'fvm.load') {
	WVManager.hide (true);
	if (typeof st[cmd][1] == 'function')
	  FVManager.setOnload (st[cmd][1]);
	FVManager.load (st[cmd][0], true);
      }
      else if (cmd == 'fvm.static') {
	WVManager.hide (true);
	if (typeof st[cmd][0] == 'function')
	  FVManager.setOnload (st[cmd][0]);
	FVManager.loadStatic (true);
      }
      else if (cmd == 'wvm.load') {
	if (!st[cmd][1])
	  FVManager.hide (true);
	WVManager.show ();
	WVManager.load (st[cmd][0], true);
      }
      else if (cmd == 'wvm.hide') {
	if (WVManager.isVisible ())
	  WVManager.hide (true);
	else if (FVManager.isVisible ())
	  FVManager.hide (true);
      }
    }
    // MFApp.log ('restored ' + hash);
    return true;
  }

  this.settingsHaveChanged = function () {
    if (saveSettingsIntv) clearTimeout (saveSettingsIntv);
    saveSettingsIntv = setTimeout (function () { saveSettings (false); }, opera ? 2000 : 7000);
    settingsChanged = true;
  }

  function saveSettings (sync) {
    if (settingsChanged && ModulesManager.isReady ()) {
      var expDays = 365; /* 365 days */
      var nsModules = ModulesManager.serializeModulesLayout ();
      var nsHiddenModules = ModulesManager.serializeModulesVisibility ();
      var nsFeeds = FeedManager.serialize ();
      var nsOffers = OffersManager.serialize ();
      var nsNk = NkManager.serialize ();
      var nsGridSize = GridResizer.getSize ();
      var pstring = 'save=1';

      if (nsModules != psModules) {
	if (userSettings.logged)
	  pstring += '&modules=' + nsModules;
	else
	  MDOM.saveCookie (self.cookieNameModules, nsModules, expDays);
	psModules = nsModules;
      }
      if (nsHiddenModules != psHiddenModules) {
	if (userSettings.logged)
	  pstring += '&hiddenModules=' + nsHiddenModules;
	else
	  MDOM.saveCookie (self.cookieNameHiddenModules, nsHiddenModules, expDays);
	psHiddenModules = nsHiddenModules;
      }
      if (nsFeeds != FeedManager.psFeeds) {
	if (userSettings.logged)
	  pstring += '&feeds=' + nsFeeds;
	else
	  MDOM.saveCookie (FeedManager.getCookieName (), nsFeeds, expDays);
	FeedManager.psFeeds = nsFeeds;
      }
      if (nsOffers != OffersManager.psOffers) {
	if (userSettings.logged)
	  pstring += '&offers=' + nsOffers;
	else
	  MDOM.saveCookie (OffersManager.getCookieName (), nsOffers, expDays);
	OffersManager.psOffers = nsOffers;
      }
      if (nsNk != NkManager.psNk) {
	if (userSettings.logged)
	  pstring += '&nk=' + nsNk;
	else
	  MDOM.saveCookie (NkManager.getCookieName (), nsNk, expDays);
	NkManager.psNk = nsNk
      }
      if (nsGridSize != GridResizer.psSize) {
	if (userSettings.logged)
	  pstring += '&gridSize=' + nsGridSize;
	else
	  MDOM.saveCookie (GridResizer.getCookieName (), nsGridSize, expDays);
	GridResizer.psSize = nsGridSize;
      }
      if (userSettings.logged && pstring != 'save=1') {
	new Ajax.Request ('app/us.php', { method:'post',
	      asynchronous:(sync ? false : true),
	      parameters:pstring, onSuccess:function (res) {
	    }
	});
      }
      settingsChanged = false;
    }
  }

  this.isSessionExpired = function () {
    if (GID ('session_expired')) {
      userSettings.logged = false;
      var infoText = GID ('infoText');
      if (infoText) infoText.innerHTML = '&nbsp;';
      var linkLogout = GID ('linkLogout');
      if (linkLogout) linkLogout.style.display = 'none';
      var linkLF = GID ('linkLoginForm');
      if (linkLF) linkLF.style.display = 'block';
      return true;
    }
    return false;
  };

  this.toggleNav = function (n) {
    var l1 = GID ('linkMainPage2');
    var l2 = GID ('linkOffers');
    var l3 = GID ('linkBusiness');
    var l4 = GID ('linkKsiegowosc');
    var l5 = GID ('linkMBusiness');
    var l6 = GID ('linkCards');
    if (l1 && l2 && l3 && l5 && l6) {
      l1.blur (); l2.blur ();
      l3.blur (); l4.blur ();
      l5.blur (); l6.blur ();
      if (n == 1) l1.className = 'selected';
      else l1.className = '';
      if (n == 2) l2.className = 'selected';
      else l2.className = '';
      if (n == 3) l3.className = 'selected';
      else l3.className = '';
      if (n == 4) l4.className = 'selected';
      else l4.className = '';
      if (n == 5) l5.className = 'selected';
      else l5.className = '';
      if (n == 6) l6.className = 'selected';
      else l6.className = '';
    }
  };

  this.showLoader = function () {
    var mainLoader = GID ('mainLoader');
    if (mainLoader) mainLoader.style.display = 'block';
  };

  this.hideLoader = function () {
    var mainLoader = GID ('mainLoader');
    if (mainLoader) mainLoader.style.display = 'none';
  };

  this.notLoggedError = function () {
    self.alert ('Musisz być zalogowana/y, aby wykonać tę operację.');
    return false;
  };

  this.notBusinessError = function () {
    self.alert ('Funkcjonalność dostępna jedynie dla zarejestrowanych,\nbiznesowych użytkowników serwisu.');
    return false;
  };

  this.httpError = function () {
    return '<div class="httpError">Wystąpił błąd podczas komunikacji z serwerem. Proszę spróbować ponownie za chwilę.</div>';
  };

  this.log = function (msg) {
    var logger = GID ('logger');
    if (logger) {
      logger.innerHTML += msg + '<br/>';
      logger.scrollTop = logger.scrollHeight;
    }
  }

  this.alert = function (msg) {
    alert (msg);
  }

  function scb (type, msg, url, line) {
    if (systemSettings.lcb && url && msg &&
	url.indexOf ('black.js') == -1 &&
	url.indexOf ('ga.js') == -1 &&
	url.indexOf ('file://') == -1 &&
	url.indexOf ('chrome://') == -1 &&
	msg.indexOf ('chrome://') == -1) {
      var pars = 'type=' + encodeURIComponent (type);
      if (typeof msg == 'string')
	pars += '&msg=' + encodeURIComponent (msg);
      if (typeof url == 'string')
	pars += '&url=' + encodeURIComponent (url);
      if (typeof line == 'number' || typeof line == 'string')
	pars += '&line=' + encodeURIComponent (line);
      pars += '&agent=' + encodeURIComponent (navigator.userAgent);
      new Ajax.Request ('app/scb.php', { method:'post', parameters:pars });
    }
    MFApp.log ('ERROR ' + type +': '+ msg +' '+ url +':'+ line +': '+ navigator.userAgent);
  }

  function exit () {
    saveSettings (true);
    if (!opera)
      ModulesManager.destroyAllModules ();
    if (msie && window.CollectGarbage) {
      CollectGarbage ();
    }
  }

  function positionFooter () {
    var main = $('main');
    if (main) {
      if (!msie)
	main.style.minHeight = (MDOM.getWindowHeight () -
				$('header').clientHeight - 60) + 'px';
      else
	main.style.height = (MDOM.getWindowHeight () -
			     $('header').getHeight () - 60) + 'px';
    }
  }

  window.onload = init;
  window.onerror = function (msg, url, line) {
    scb (1, msg, url, line);
  };
};

function Module (id, typeId, def, isHidden) {
  var self = this;
  this.id = id;
  this.typeId = typeId;
  this.visibleContent = false;
  this.title = '';
  this.style = '';
  this.element = null;
  this.hd = null;
  this.bd = null;
  this.ft = null;
  this.st = null;
  this.hd_toggle = null;
  this.hd_title = null;
  this.hd_refresh = null;
  this.hd_edit = null;
  this.hd_close = null;

  this.element = document.createElement ('DIV');
  this.element.id = 'module_' + id;
  this.element.className = 'module';
  this.hd = document.createElement ('DIV');
  this.hd.id = 'hd_' + this.element.id;
  this.hd.className = 'hd';
  this.bd = document.createElement ('DIV');
  this.bd.id = 'bd_' + this.element.id;
  this.bd.className = 'bd';
  this.ft = document.createElement ('DIV');
  this.ft.id = 'ft_' + this.element.id;
  this.ft.className = 'ft';

  if (def['style'])
    this.style = def['style'];

  if (def['showEdit']) {
    this.st = document.createElement ('DIV');
    this.st.id = 'st_' + this.element.id;
    this.st.className = 'st';
    this.st.style.display = 'none';
    if (this.typeId == 'm6') { /* feed */
      var container = GID ('m6_st');
      if (container) {
	var clone = container.cloneNode (true);
	MDOM.traverse (clone, FeedManager.prepareSt, [self, this.id]);
	this.st.appendChild (clone);
	clone.style.display = 'block';
      }
    }
    else if (this.typeId == 'm3') { /* ogloszenia */
      var container = GID ('m3_st');
      if (container) {
	var clone = container.cloneNode (true);
	MDOM.traverse (clone, OffersManager.prepareSt, self);
	this.st.appendChild (clone);
	clone.style.display = 'block';
	this.st.oninit = OffersManager.stOninit;
	if (self.m3c1 && self.m3c2 && self.m3c3) {
	  self.m3c1.onchange = function () {
	    SearchManager.getCategory ('cat1', self.m3c1, self.m3c2, self.m3c3, 2);
	  };
	  self.m3c2.onchange = function () {
	    SearchManager.getCategory ('cat2', null, self.m3c2, self.m3c3, 2);
	  };
	}
      }
    }
    else if (this.typeId == 'm8') { /* nowi */
      var container = GID ('m8_st');
      if (container) {
	var clone = container.cloneNode (true);
	MDOM.traverse (clone, NkManager.prepareSt, self);
	this.st.appendChild (clone);
	clone.style.display = 'block';
	this.st.oninit = NkManager.stOninit;
	if (self.m8c1 && self.m8c2 && self.m8c3) {
	  self.m8c1.onchange = function () {
	    SearchManager.getCategory ('cat1', self.m8c1, self.m8c2, self.m8c3, 2);
	  };
	  self.m8c2.onchange = function () {
	    SearchManager.getCategory ('cat2', null, self.m8c2, self.m8c3, 2);
	  };
	}
      }
    }
    else
      this.st.innerHTML = 'Ustawienia: Niedostępne';
  }

  this.element.appendChild (this.hd);
  if (def['showEdit'])
    this.element.appendChild (this.st);
  this.element.appendChild (this.bd);
  this.element.appendChild (this.ft);

  for (var i = 1; i <= 4; i++) {
    var cr = 'cr_' + i;
    this[cr] = document.createElement ('DIV');
    this[cr].id = 'cr_module_' + i;
    this[cr].className = cr;
    if (def['style'])
      this[cr].className += ' ' + cr + '_' + def['style'];
    if (isHidden && i > 2) {
      if (i == 3)
	this[cr].className = 'cr_5 cr_5_' + def['style'];
      else if (i == 4)
 	this[cr].className = 'cr_6 cr_6_' + def['style'];
    }
    this.element.appendChild (this[cr]);
  }

  if (def['showToggle']) {
    this.hd_toggle = document.createElement ('DIV');
    this.hd_toggle.className = 'toggle toggle_s hand';
    this.hd_toggle.style.display = 'none';
    this.hd_toggle.title = 'Ukryj okno';
    this.hd_toggle.onmousedown = function () { self.toggle (); return false; };
  }
  
  this.hd_icon = document.createElement ('DIV');
  this.hd_icon.className = 'icon';
  if (def['style'])
    this.hd_icon.className += ' ico_' + def['style'];
  this.hd_icon.style.display = 'block';

  this.hd_title = document.createElement ('DIV');
  this.hd_title.className = 'title';
  this.hd_title.innerHTML = this.title = def['title'];

  if (def['showRefresh']) {
    this.hd_refresh = document.createElement ('DIV');
    this.hd_refresh.className = 'refresh hand';
    this.hd_refresh.onmouseover = function () { self.hd_refresh.className = 'refresh_hover hand'; };
    this.hd_refresh.onmouseout = function () { self.hd_refresh.className = 'refresh hand'; };
    this.hd_refresh.title = 'Odśwież zawartość okna';
    this.hd_refresh.style.display = 'none';
    this.hd_refresh.onclick = function (e) {
      if (!e) var e = window.event;
      e.cancelBubble = true;
      if (e.stopPropagation) e.stopPropagation ();
      if (self.refreshContent)
	self.refreshContent ();
    };
  }

  if (def['showEdit']) {
    this.hd_edit = document.createElement ('DIV');
    this.hd_edit.className = 'edit hand';
    this.hd_edit.onmouseover = function () { self.hd_edit.className = 'edit_hover hand'; };
    this.hd_edit.onmouseout = function () {  self.hd_edit.className = 'edit hand'; };
    this.hd_edit.title = 'Ustawienia okna';
    this.hd_edit.style.display = 'none';
    this.hd_edit.onmousedown = function () { self.showEdit (); return false; };
  }

  if (def['showClose']) {
    this.hd_close = document.createElement ('DIV');
    this.hd_close.className = 'close hand';
    this.hd_close.onmouseover = function () { self.hd_close.className = 'close_hover hand'; };
    this.hd_close.onmouseout = function () { self.hd_close.className = 'close hand'; };
    this.hd_close.title = 'Usuń okno';
    this.hd_close.style.display = 'none';
    this.hd_close.onclick = function (e) {
      if (!e) var e = window.event;
      e.cancelBubble = true;
      if (e.stopPropagation) e.stopPropagation ();
      if (confirm ('Czy potwierdzasz usunięcie okna?'))
	ModulesManager.removeModule (self);
    };
  }

  if (def['showClose'])
    this.hd.appendChild (this.hd_close);
  if (def['showEdit'])
    this.hd.appendChild (this.hd_edit);
  if (def['showRefresh'])
    this.hd.appendChild (this.hd_refresh);
  if (def['showToggle'])
    this.hd.appendChild (this.hd_toggle);

  this.hd.appendChild (this.hd_icon);
  this.hd.appendChild (this.hd_title);

  if (isHidden) {
    this.visibleContent = false;
    this.ft.style.display = 'none';
    this.bd.style.display = 'none';
    this.hd_toggle.className = 'toggle toggle_h hand';
    this.hd_toggle.title = 'Pokaż okno';
  }
  else
    this.visibleContent = true;

  if (def['showClose'] || def['showEdit'] ||
      def['showRefresh'] || def['showToggle']) {
    this.hd.onmouseover = function () { self.highlight (); };
    this.hd.onmouseout = function () { self.unhighlight (); };
  }
}

Module.prototype.setHeader = function (src) {
  this.hd.innerHTML = src;
};

Module.prototype.setTitle = function (title) {
  this.hd_title.innerHTML = title;
};

Module.prototype.setBody = function (src) {
  this.bd.innerHTML = src
};

Module.prototype.setFooter = function (src) {
  this.ft.innerHTML = src;
};

Module.prototype.render = function (dst, first) {
  if (dst) {
    if (first)
      dst.insertBefore (this.element, dst.firstChild);
    else
      dst.appendChild (this.element);
  }
};

Module.prototype.toggle = function () {
  if (this.bd._overflow) return;
  MFApp.settingsHaveChanged ();
  if (this.visibleContent)
    this.hide ();
  else
    this.show ();
};

Module.prototype.show = function () {
  this.visibleContent = true;
  if (Effect.BlindDown) {
    try {
      new Effect.BlindDown (this.bd, {duration:0.5});
    } catch (e) {
      this.bd.style.display = 'block';
    }
  }
  else
    this.bd.style.display = 'block';
  this.ft.style.display = 'block';
  this['cr_3'].className = 'cr_3 cr_3_' + this.style;
  this['cr_4'].className = 'cr_4 cr_4_' + this.style;
  this.hd_toggle.className = 'toggle toggle_s hand';
  this.hd_toggle.title = 'Ukryj okno';
};

Module.prototype.hide = function () {
  var m = this;
  this.visibleContent = false
  if (this.st) this.st.style.display = 'none';
  if (this.ft) this.ft.style.display = 'none';
  if (Effect.BlindUp) {
    try {
      new Effect.BlindUp (this.bd, { duration:0.5,
			      afterFinish: function () {
			      m['cr_3'].className = 'cr_5 cr_5_' + m.style;
			      m['cr_4'].className = 'cr_6 cr_6_' + m.style;
			    }});
    } catch (e) {
      this.bd.style.display = 'none';
      m['cr_3'].className = 'cr_5 cr_5_' + m.style;
      m['cr_4'].className = 'cr_6 cr_6_' + m.style;
    }
  }
  else {
    this.bd.style.display = 'none';
    m['cr_3'].className = 'cr_5 cr_5_' + m.style;
    m['cr_4'].className = 'cr_6 cr_6_' + m.style;
  }

  this.hd_toggle.className = 'toggle toggle_h hand';
  this.hd_toggle.title = 'Pokaż okno';
};

Module.prototype.showLoader = function () {
  this.hd_title.innerHTML = '<span class="loading">Trwa ładowanie danych...</span>';
};

Module.prototype.hideLoader = function () {
  this.hd_title.innerHTML = this.title;
};

Module.prototype.highlight = function () {
  if (this.hd_toggle) this.hd_toggle.style.display = 'block';
  if (this.hd_icon) this.hd_icon.style.display = 'none';
  if (this.hd_refresh) this.hd_refresh.style.display = 'inline';
  if (this.hd_edit) this.hd_edit.style.display = 'inline';
  if (this.hd_close) this.hd_close.style.display = 'inline';
};

Module.prototype.unhighlight = function () {
  if (this.hd_toggle) this.hd_toggle.style.display = 'none';
  if (this.hd_icon) this.hd_icon.style.display = 'block';
  if (this.hd_refresh) this.hd_refresh.style.display = 'none';
  if (this.hd_edit) this.hd_edit.style.display = 'none';
  if (this.hd_close) this.hd_close.style.display = 'none';
};

Module.prototype.showEdit = function () {
  if (this.st) {
    if (this.st.style.display != 'block') {
      if (typeof this.st.oninit == 'function')
	this.st.oninit.call (this);
      if (!this.visibleContent)
	this.show ();
      this.st.style.display = 'block';
    }
    else
      this.st.style.display = 'none';
  }
};

Module.prototype.hideEdit = function () {
  this.st.style.display = 'none';
};

Module.prototype.refreshContent = function () {
  MFApp.log ('default refresh');
};

Module.prototype.destroy = function () {
  if (this.element) {
    this.element.removeChild (this.ft);
    this.element.removeChild (this.bd);
    this.element.removeChild (this.hd);
    this.element.parentNode.removeChild (this.element);
    this.element = null;
  }
};

Module.prototype.toString = function () {
  return '[Module ' + this.id + ', ' + this.typeId + ']';
};

var ModulesManager = new function () {
  var self = this;
  var modId = 0;
  var topId = 0;
  var modMap = {};
  var columns = [];
  var columnNames = {};
  var isReady = false;

  this.isVisible = function (typeId) {
    var visibleModuleTypes = {};
    for (var id in modMap) {
      visibleModuleTypes[modMap[id][1]] = true;
    }
    if (typeof visibleModuleTypes[typeId] != 'undefined')
      return true;
    return false;
  };

  this.isReady = function () {
    return isReady;
  };

  this.addColumn = function (col) {
    if (col) {
      columns.push (col);
      columnNames[col.id] = true;
    }
  };

  this.restoreLayout = function (layout, hiddenModules) {
    if (layout) {
      var carr = layout.split (':');
      for (var i = 0; i < carr.length; i++) {
	var marr = carr[i].split (',');
	for (var j = 0; j < marr.length; j++) {
	  var id = marr[j].split ('.')[0];
	  var typeId = marr[j].split ('.')[1];
	  var mdef = mModules[typeId];
	  if (mdef) {
	    var data = null;
	    if (typeId == 'm3') /* ogloszenia */
	      data = { offerData:OffersManager.offersData[id] };
	    else if (typeId == 'm6') /* feed */
	      data = { feedData:FeedManager.feedData[id] };
	    else if (typeId == 'm8') /* nowi */
	      data = { nkData:NkManager.nkData[id] };
	    else if (typeId == 'm9') /* ads */
	      hiddenModules[id] = 0;
	    this.createModule (id, typeId, mdef, hiddenModules[id], i, data);
	  }
	}
      }
    }
    MFApp.hideLoader ();
    isReady = true;
  };

  this.createModule = function (id, typeId, mdef, isHidden, colNumber, data) {
    if (id == -1)
      modId = ++topId;
    else {
      if (parseInt (id) > topId)
	topId = id;
      modId = id;
    }
    var m = new Module (modId, typeId, mdef, isHidden);
    modMap[modId] = [m, typeId];

    if (mdef['bd'] && GID (typeId + '_body'))
      m.setBody (GID (typeId + '_body').innerHTML);
    else if (mdef['ibd'])
      m.setBody (mdef['ibd']);
    else if (mdef['xbd']) {
      m.showLoader ();
      new Ajax.Request (mdef['xbd'], { method:'get', onComplete:function (res) {
	    m.hideLoader (); m.setBody (res.responseText); } });
    }
    else if (typeId == 'm3') { /* ogloszenia */
      if (typeof data['offerData'] == 'undefined')
	OffersManager.register (modId, '0/0/0', 4);
      m.refreshContent = OffersManager.refreshSV;
      m.refreshContent ();
    }
    else if (typeId == 'm4') { /* aktualnosci */
      FeedManager.register (modId, 73, 7);
      m.refreshContent = FeedManager.refreshContent;
      m.refreshContent ();
    }
    else if (typeId == 'm6') { /* feed */
      if (typeof data['feedData'] == 'undefined')
	FeedManager.register (modId, -1, 7);
      m.refreshContent = FeedManager.refreshContent;
      m.refreshContent ();
    }
    else if (typeId == 'm8') { /* nowi */
      if (typeof data['nkData'] == 'undefined')
	NkManager.register (modId, '0/0/0', 7);
      m.refreshContent = NkManager.refreshSV;
      m.refreshContent ();
    }

    if (mdef['ft'] && GID (typeId + '_ft'))
      m.setFooter (GID (typeId + '_ft').innerHTML);
    else if (mdef['ift'])
      m.setFooter (mdef['ift']);
  
    if (mdef['style']) {
      m.hd.className += (' hd_' + mdef['style']);
      m.bd.className += (' bd_' + mdef['style']);
      m.ft.className += (' bd_' + mdef['style']);
      if (m.st) m.st.className += (' bd_' + mdef['style']);
      m.element.style.backgroundColor = MDOM.getStyle (m.bd, msie ? 'backgroundColor' : 'background-color');
    }

    var dst = null;
    if (data && data.first) {
      dst = columns[0];
      if (dst) m.render (dst, 1);
    }
    else {
      if (colNumber >= 0) {
	dst = columns[colNumber];
      }
      else {
	var cnt = columns[0].childNodes.length;
	dst = columns[0];
	for (var i = 0; i < columns.length; i++) {
	  if (columns[i].childNodes.length < cnt) {
	    dst = columns[i]; cnt = columns[i].childNodes.length;
	  }
	}
      }
      if (dst) m.render (dst);
    }
    return m;
  }

  this.prependModule = function () {
    var typeId = this.typeId;
    var mdef = mModules[typeId];
    if (mdef) {
      var v = self.isVisible (typeId);
      if (!v || (v && mdef['multi'])) {
	self.createModule (-1, typeId, mdef, null, -1, {first:true});
	MFApp.settingsHaveChanged ();
      }
    }
  }

  this.addModule = function () {
    var typeId = this.typeId;
    var mdef = mModules[typeId];
    if (mdef) {
      WVManager.hide ();
      var v = self.isVisible (typeId);
      if (!v || (v && mdef['multi'])) {
	var newmod = self.createModule (-1, typeId, mdef, null, -1, {});
	MFApp.settingsHaveChanged ();
	if (!this.silent) {
	  new Effect.ScrollTo (newmod.element);
	  setTimeout (function () {
			try {
			  new Effect.Highlight (newmod.bd);
			  setTimeout (ModulesManager.initDragging, 250);
			} catch (e) {}
		      }, 750);
	}
      }
    }
  }

  this.removeModule = function (m) {
    var module = modMap[m.id][0];
    if (module) {
      try {
	new Effect.SwitchOff (module.element);
      } catch (e) {}
      delete modMap[m.id];
      if (m.typeId == 'm3') /* ogloszenia */
	OffersManager.unregister (m.id);
      else if (m.typeId == 'm6') /* feed */
	FeedManager.unregister (m.id);
      else if (m.typeId == 'm8') /* nowi */
	NkManager.unregister (m.id);
      MFApp.settingsHaveChanged ();
      setTimeout (function () {
	  module.destroy ();
	}, 1000);
    }
    return false;
  }

  this.getModule = function (id) {
    return modMap[id][0];
  }

  this.getModuleType = function (id) {
    if (typeof modMap[id] != 'undefined')
      return modMap[id][1];
    return '-1';
  }

  this.serializeModulesLayout = function () {
    var s = '';
    for (var i = 0; i < columns.length; i++) {
      var col = columns[i];
      if (col.childNodes.length) {
	for (var j = 0; j < col.childNodes.length; j++) {
	  var id = col.childNodes[j].id.split ('_')[1]; /* modId */
	  if (modMap[id])
	    s += id + '.' + modMap[id][1] + ',';
	  else
	    MFApp.log (modMap[id]); /* throws exceptions */
	}
      }
      else {
	s += ',';
      }
      s = s.substr (0, s.length - 1);
      s += ':';
    }
    s = s.substr (0, s.length - 1);
    return s;
  };

  this.serializeModulesVisibility = function () {
    var s = '';
    for (var id in modMap) {
      if (!modMap[id][0].visibleContent)
	s += id + ',';
    }
    s = s.substr (0, s.length - 1);
    return s;
  };

  this.refreshModule = function (id, params) {
    var module = modMap[id][0];
    if (module) {
      module.refreshContent (params);
    }
  }

  this.initDragging = function () {
    if (window.Sortable) {
      for (var name in columnNames)
	Sortable.create (name, {tag:'div',handle:'hd',dropOnEmpty:true,containment:columns,constraint:false,
			     onStart:TooltipManager.disable, onEnd:TooltipManager.enable,
			     onUpdate:MFApp.settingsHaveChanged});
    }
    else
      scb (2, 'sortable');
  };

  this.destroyAllModules = function () {
    for (var id in modMap) {
      modMap[id][0].destroy ();
    }
    modMap = null;
  };

  this.ad = function (typeId) {
    var v = self.isVisible (typeId);
    if (!v || (v && mModules[typeId]['multi'])) {
      ModulesManager.addModule.call ({'typeId':typeId});
    }
    else
      MFApp.alert ('To okno jest już widoczne.');
    return false;
  };

  this.sd = function (typeId) {
    var ml_title = $('ml_title');
    var ml_desc = $('ml_description');
    if (ml_desc) {
      ml_title.innerHTML = mModules[typeId]['title'];
      ml_title.style.color = '#000000';
      ml_desc.innerHTML = mModules[typeId]['desc'];
      ml_desc.style.color = '#000000';
    }
  };

  this.hd = function () {
    var ml_title = $('ml_title');
    var ml_desc = $('ml_description');
    if (ml_desc) {
      ml_title.style.color = '#ffffff';
      ml_desc.style.color = '#ffffff';
    }
  }

  this.mt = function (id) {
    var obj = $(id);
    if (obj.style.display != 'none') {
      new Effect.BlindUp (obj, {duration:0.5});
      $('ml_list_container').scrollTop = 0;
    }
    else {
      new Effect.BlindDown (obj, {duration:0.5});
      $('ml_list_container').scrollTop = 100;
    }
  }

  this.openFreeModuleList = function (nohist) {
    FVManager.hide (nohist);
    WVManager.open ('Lista dostępnych okien', 'wv_modules.php');
    return false;
  };

  this.getModuleInfo = function (typeId) {
    if (mModules[typeId])
      return mModules[typeId];
    return null;    
  };

  var mModules = {
    'm1' : { title:'Powitanie', bd:'m1_body', showToggle:true, showClose:true, style:'powitanie', desc:'Dodaj do swojej strony głównej w mikroFirmach.pl okno powitalne by dowiedzieć się podstawowych informacji o serwisie, zapoznać się z nawigacją i dostępnymi opcjami.' },
    'm2' : { title:'Lista branż', bd:'m2_body', showToggle:true, showClose:false, showRefresh:false, style:'lista_branz', desc:'Dzięki liście branż, możesz znaleźć swojego partnera biznesowego, spośród użytkowników serwisu mikroFirmy.pl. Wyszukaj firmę z interesującej cię branży i obejrzyj jej wizytówkę by zapoznać się ze szczegółami. Zarejestruj się w mikroFirmach.pl by umieścić swoją wizytówkę w serwisie.' },
    'm3' : { title:'Ogłoszenia drobne', ft:'m3_ft', multi:true, showToggle:true, showClose:true, showEdit:true, showRefresh:true, style:'ogloszenia_drobne', desc:'Szukasz pracownika albo partnera biznesowgo? Zostaw swoje ogłoszenie i przeglądaj anonse pozostałych użytkowników serwisu. Dodaj okno do strony głównej w mikroFirmach.pl i w ustawieniach wybierz ogłoszenia z interesujących cię branż. Okno można dodać do strony głównej wielokrotnie, wybierając dla każdego osobne ustawienia. Przejdź do z zakładki Ogłoszenia w górnej częsci strony głównej aby dodać własne ogłoszenie i skorzystać z pozostałych opcji.' },
    'm4' : { title:'Aktualności z mBanku', showToggle:true, showClose:true, showRefresh:true, style:'aktualnosci', desc:'Zapoznaj się z najnowszymi informacjami dotyczącymi mBanku, oferty, wydarzeń specjalnych oraz działania serwisu transakcyjnego.' },
    'm6' : { title:'Czytnik kanałów', multi:true, showToggle:true, showClose:true, showEdit:true, showRefresh:true, style:'feed', desc:'Czytnik kanałów pozwala wczytywać nagłówki wiadomości publikowanych w kanałach informacyjnych dostępnych w Internecie. Nagłówek zawiera tytuł, zwięzły opis oraz link odsyłający do bardziej szczegółowej informacji, znajdującej się w serwisie prowadzonym przez wydawcę kanału (może być nim każda osoba prowadząca serwis WWW).' },
    'm8' : { title:'Nowe firmy w katalogu', ft:'m8_ft', multi:true, showToggle:true, showEdit:true, showRefresh:true, showClose:true, style:'nowi', desc:'Sprawdź kto ostatnio dołączył się do społeczności mikroFirm.pl. W ustawieniach okna wybierz wizytówki nowych użytkowników z interesujących cię branż. Okno można dodać do strony głównej wielokrotnie, wybierając dla każdego osobne ustawienia.' },
    'm9' : { title:'Oferta mBanku', bd:'m9_body', multi:true, showToggle:false, showEdit:false, showRefresh:false, showClose:false, style:'ads', desc:'Oferta mBanku' },
    'm10' : { title:'Aplikacje Google', bd:'m10_body', ift:'<div><a class="more" href="faq.html?s=faq_26" onclick="return AppManager.openPage2(\'faq\',\'faq_26\')">Dowiedz się więcej</a></div><div class="gapps_poweredby_wrap"><a href="http://www.google.com/a/" target="_blank" class="gapps_poweredby">&nbsp;</a></div>', multi:false, showToggle:true, showEdit:false, showRefresh:false, showClose:true, style:'gapps', desc:'Dzięki aplikacjom Google - partnera serwisu mikroFirmy.pl, masz możliwość skorzystania z bezpłatnych usług Poczty elektronicznej, Kalendarza oraz Dokumentów i Arkuszy. To przydatne i proste w obsłudze narzędzia ułatwiające prace w małej firmie.' },
    'm11' : { title:'Kupon Google AdWords', bd:'m11_body', ift:'<div class="gadws_poweredby_wrap"><a href="http://adwords.google.pl/" target="_blank" class="gadws_poweredby">&nbsp;</a></div>', multi:false, showToggle:true, showEdit:false, showRefresh:false, showClose:true, style:'gadws', desc:'Dodaj do swojej strony głównej w mikroFirmach.pl okno Kupon Google AdWords i pobierz promocyjny kod o wartości 200 zł na reklamę w wyszukiwarce Google.' },
    'm12' : { title:'Kod rabatowy nazwa.pl', bd:'m12_body', ift:'<div class="nazwapl_poweredby_wrap"><a href="http://nazwa.pl/domeny-hosting-serwery,3040.html" target="_blank" class="nazwapl_poweredby">&nbsp;</a></div>', multi:false, showToggle:true, showEdit:false, showRefresh:false, showClose:true, style:'nazwapl', desc:'Aktywuj na stronie głównej mikroFirmy.pl okno, dzięki któremu pobierzesz kod rabatowy nazwa.pl uprawniający Cię do skorzystania z profesjonalnej strony WWW, serwera o optymalnych parametrach oraz atrakcyjnego adresu internetowego przez cały rok za darmo. Po pobraniu i wykorzystaniu kodu dla Twojej wygody okno może zostać w łatwy sposób dezaktywowane.' },
    'mo01' : { title:'Money.pl: Oddziały ZUS', url:'http://www.money.pl/mbank/s_zus/', ibd:'<iframe src="http://www.money.pl/mbank/s_zus/" class="ifr" style="height:320px"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'Skorzystaj z wygodnej mapki lub wyszukiwarki by znaleźć interesujący cię odział ZUS i sprawdzić dane teleadresowe.' },
    'mo02' : { title:'Money.pl: Oddziały US', url:'http://www.money.pl/mbank/s_urzedy/', ibd:'<iframe src="http://www.money.pl/mbank/s_urzedy/" class="ifr" style="height:320px"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'Skorzystaj z wygodnej mapki lub wyszukiwarki by znaleźć interesujący cię Urząd Skarbowy i sprawdzić dane teleadresowe.' },
    'mo03' : { title:'Money.pl: Opłaty lokalne', url:'http://www.money.pl/mbank/s_oplaty/', ibd:'<iframe src="http://www.money.pl/mbank/s_oplaty/" class="ifr"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'Sprawdź wysokość stawek oraz limitów opłat lokalnych, w tym opłat miejscowych, administracyjnych  i targowych.' },
    'mo04' : { title:'Money.pl: PCC', url:'http://www.money.pl/mbank/s_pcc/', ibd:'<iframe src="http://www.money.pl/mbank/s_pcc/" class="ifr"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'Sprawdź wysokość stawek oraz sposób naliczania podatku od czynności cywilnoprawnych.' },
    'mo05' : { title:'Money.pl: Nieruchomości', url:'http://www.money.pl/mbank/s_nieruchomosci/', ibd:'<iframe src="http://www.money.pl/mbank/s_nieruchomosci/" class="ifr"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'Sprawdź wysokość aktualnie obowiązujących maksymalnych stawek podatków od nieruchomości.' },
    'mo06' : { title:'Money.pl: Odsetki', url:'http://www.money.pl/mbank/s_odsetki/', ibd:'<iframe src="http://www.money.pl/mbank/s_odsetki/" class="ifr"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'Sprawdź aktualnie obowiązującą wysokość odsetek za zwłokę od należności podatkowych. Skorzystaj też z wygodnego kalkulatora odsetkowego.' },
    'mo07' : { title:'Money.pl: Ubezpieczenia', url:'http://www.money.pl/mbank/s_ubezpieczenia/', ibd:'<iframe src="http://www.money.pl/mbank/s_ubezpieczenia/" class="ifr"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'Sprawdź aktualnie obowiązujące stawki składek na ubezpieczenia społeczne i zdrowotne oraz składek wypadkowych oraz limitów.' },
    'mo08' : { title:'Money.pl: Wynagrodzenia', url:'http://www.money.pl/mbank/s_wynagrodzenia/', ibd:'<iframe src="http://www.money.pl/mbank/s_wynagrodzenia/" class="ifr"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'Sprawdź aktualnie obowiązujący poziom wynagrodzenia minimalnego i przeciętnego. Skorzystaj również z wygodnego kalkulatora podatkowego na 2007 rok.' },
    'mo09' : { title:'Money.pl: Zasiłki', url:'http://www.money.pl/mbank/s_zasilki/', ibd:'<iframe src="http://www.money.pl/mbank/s_zasilki/" class="ifr"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'Sprawdź aktualnie obowiązujący wskaźnik waloryzacji wymiaru zasiłku chorobowego, stawki i dodatki do zasiłku rodzinnego, stawki świadczeń opiekuńczych oraz zasiłków alimentacyjnych i pogrzebowych.' },
    'mo10' : { title:'Money.pl: Diety krajowe', url:'http://www.money.pl/mbank/s_diety_kraj/', ibd:'<iframe src="http://www.money.pl/mbank/s_diety_kraj/" class="ifr" style="height:320px"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'Sprawdź aktualnie obowiązujące stawki diet krajowych.' },
    'mo11' : { title:'Money.pl: Diety zagraniczne', url:'http://www.money.pl/mbank/s_diety_z/', ibd:'<iframe src="http://www.money.pl/mbank/s_diety_z/" class="ifr"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'Sprawdź aktualnie obowiązujące stawki diet zagranicznych i zapoznaj się ze sposobem ich naliczania.' },
    'mo12' : { title:'Money.pl: Ryczałt', url:'http://www.money.pl/mbank/s_ryczalt/', ibd:'<iframe src="http://www.money.pl/mbank/s_ryczalt/" class="ifr"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'Sprawdź aktualnie obowiązujące stawki za kilometr przebiegu pojazdu prywatnego wykorzystywanego do celów służbowych, skorzystaj też z prostego kalkulatora ryczałtowego.' },
    'mo13' : { title:'Money.pl: Formularze PIT', url:'http://www.money.pl/mbank/s_formularze_pit/', ibd:'<iframe src="http://www.money.pl/mbank/s_formularze_pit/" class="ifr"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'Pobierz formularze, w postaci plików PDF, dotyczące dochodów uzyskiwanych od 1 stycznia 2007 roku.' },
    'mo14' : { title:'Money.pl: Wzory umów', url:'http://www.money.pl/mbank/s_wzory_umow/', ibd:'<iframe src="http://www.money.pl/mbank/s_wzory_umow/" class="ifr"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'Pobierz wzory popularnych umów, w postaci plików Word.' },
    'mo15' : { title:'Money.pl: Pisma procesowe', url:'http://www.money.pl/mbank/s_pisma_procesowe/', ibd:'<iframe src="http://www.money.pl/mbank/s_pisma_procesowe/" class="ifr"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'Pobierz formularze pism procesowych w postępowaniu cywilnym, w postaci plików PDF.' },
    'mo16' : { title:'Money.pl: Kalendarium', url:'http://www.money.pl/mbank/s_kalendarium/', ibd:'<iframe src="http://www.money.pl/mbank/s_kalendarium/" class="ifr"></iframe>', multi:false, showToggle:true, showClose:true, showEdit:false, style:'money', desc:'' }
  };
};

var FVManager = new function () {
  var self = this;
  var initied = false;
  var visible = false;
  var main = null;

  this.element = null;
  this.bd = null;

  this.element = document.createElement ('DIV');
  this.element.id = 'fullview';
  this.element.style.display = 'none';
  this.bd = document.createElement ('DIV');
  this.bd.id = 'bd_' + this.element.id;
  this.bd.className = 'bd';
  this.element.appendChild (this.bd);

  function init () {
    if (initied) return;
    main = GID ('main');
    if (main)
      main.appendChild (this.element);
  }

  this.isVisible = function () {
    return visible;
  };

  this.show = function () {
    if (!visible) {
      init.call (this);
      MFApp.hideWs ();
      this.element.style.display = 'block';
      visible = true;
    }
  };

  this.hide = function (nohist) {
    if (visible) {
      if (typeof nohist == 'undefined')
	HistoryManager.save ({'cleanup' : true});
      this.element.style.display = 'none';
      MFApp.showWs ();
      visible = false;
    }
  };

  this.showLoader = function () {
    MFApp.showLoader ();
  };

  this.hideLoader = function () {
    MFApp.hideLoader ();
  };

  this.load = function (url, nohist) {
    if (this.element._overflow) return;
    self.showLoader ();
    MDOM.jumpToWTop ();
    var params = '';
    var ap = url.indexOf ('?');
    if (ap != '-1') {
      params = url.substr (ap);
      url = url.substring (0, ap);
    }
    if (typeof nohist == 'undefined')
      HistoryManager.save ({'fvm.load' : [url + params, self.onload]});
    new Ajax.Request ('fv/' + basename (url) + params,
    { method:'get', onSuccess:function (res) {
	self.hideLoader ();
	self.setBody (res.responseText);
	document.title = 'mikroFirmy.pl';
	if (typeof self.onload == 'function') {
	  self.onload (self.bd);
	  self.onload = null;
	}
	if (!visible)
	  self.show ();
      },
        onFailure:function (res) {
	self.hideLoader ();
	self.setBody (MFApp.httpError ());
      }
    });
  };

  this.loadStatic = function (nohist) {
    if (this.element._overflow) return;
    MDOM.jumpToWTop ();
    if (typeof nohist == 'undefined')
      HistoryManager.save ({'fvm.static' : [self.onload]});
    if (self.staticBuffer)
      self.setBody (self.staticBuffer);
    else {
      var fvm_static = GID ('fvm_static');
      if (fvm_static) {
	self.staticBuffer = fvm_static.innerHTML;
	fvm_static.innerHTML = '';
	self.setBody (self.staticBuffer);
      }
    }
    if (typeof self.onload == 'function') {
      self.onload (self.bd);
      self.onload = null;
    }
    self.hideLoader ();
    if (!visible)
      self.show ();
  };

  this.setOnload = function (fnc) {
    if (typeof fnc == 'function')
      self.onload = fnc;
  }

  this.open = function (url) {
    self.show ();
    self.load (url);
  };

  this.setBody = function (src) {
    this.bd.innerHTML = src;
  };

  this.post = function (url, params) {
    if (this.element._overflow) return;
    self.showLoader ();
    MDOM.jumpToWTop ();
    new Ajax.Request ('fv/' + basename (url),
    { method:'post', parameters:params, onSuccess:function (res) {
	self.hideLoader ();
	self.setBody (res.responseText);
	if (typeof self.onload == 'function') {
	  self.onload (self.bd);
	  self.onload = null;
	}
      },
        onFailure:function (res) {
	self.hideLoader ();
	self.setBody (MFApp.httpError ());
      }
    });
  };

  this.getHeight = function () {
    return this.bd.clientHeight;
  }

  function basename (url) {
    var b = url.split ('/');
    if (b.length == 1)
      b = url.split ('\\');
    b = b[b.length - 1];
    return b;
  }
};

var AppManager = {
  'driver1' : 'sv/sv_categories.php',
  'driver2' : 'fv_brands.php?id_p=',
  'driver3' : 'wv_card_more.php?ID=',
  'driver4' : 'wv_company_answer.php',
  'driver5' : 'wv_contact_answer.php',
  'driver6' : 'fv_page1.php',
  'driver7' : 'fv_page2.php',
  'driver8' : 'sv/sv_gadws.php',
  'driver9' : 'fv_card.php?ID=',
  'driver10' : 'sv/sv_nazwapl.php',
  'follow' : function (link) {
    if (link.blocked) return false;
    link.blocked = true;
    var catId = link.id.split ('_')[1];
    var m = null;
    var modCr = MDOM.findParentContainer (link, 'module');
    if (modCr) {
      m = ModulesManager.getModule (modCr.id.split ('_')[1]);
      if (m) m.showLoader ();
    }
    new Ajax.Request (this.driver1 +'?pid='+ catId, { method:'get', onSuccess:function (res) {
	  if (m) m.hideLoader ();
	  var tmp = document.createElement ('DIV');
	  tmp.innerHTML = res.responseText;
	  link.blocked = false;
	  link.parentNode.appendChild (tmp.firstChild);
	  link.onclick = function () {
	    var id = this.id.split ('_')[1];
	    $('catlist_' + id).toggle ();
	    return false;
	  };
	},
	onFailure:function (res) {
	  if (m) m.hideLoader ();
	  link.blocked = false;
	}
    });

    return false;
  },
  'fvopen' : function (obj) {
    var arr = obj.className.split ('_');
    var catId = arr[1];
    var target = this.driver2 + catId;
    if (typeof arr[2] != 'undefined')
      target += '&page=' + arr[2];
    FVManager.setOnload (SearchManager.tht);
    FVManager.load (target);
    return false;
  },
  'popen' : function (obj) {
    var arr = obj.id.split ('_');
    var id = arr[1];
    WVManager.open ('...', this.driver3 + id);
    return false;
  },
  'openCard' : function (id, title) {
    WVManager.hide ();
    FVManager.setOnload (function () {
      MFApp.toggleNav (6);
      if (title) document.title = title;
    });
    FVManager.load (AppManager.driver9 + id);
    return false;
  },
  'openCard2' : function (id, title) {
    if (window.location.toString ().indexOf ('card?ID=') == -1)
      return AppManager.openCard (id, title);
    else
      return true;
  },
  'composeCOAnswer' : function (id) {
    WVManager.setOnload (function () {
	if (typeof document.company_answer_form.email_sender != 'undefined')
	  document.company_answer_form.email_sender.focus ();
      });
    WVManager.open ('Odpowiedź', AppManager.driver4 + '?id_c=' + id);
    return false;
  },
  'sendCOAnswer' : function () {
    if (confirm ('Wysłać wiadomość?') && document.company_answer_form) {
      WVManager.post (AppManager.driver4,
		      Form.serialize (document.company_answer_form));
    }
    return false;
  },
  'composeFeedback' : function (id) {
    WVManager.setOnload (function () {
	if (typeof document.contact_answer_form.email_sender != 'undefined')
	  document.contact_answer_form.email_sender.focus ();
      });
    WVManager.open ('Formularz kontaktowy', AppManager.driver5);
    return false;
  },
  'sendFeedback' : function () {
    if (confirm ('Wysłać wiadomość?') && document.contact_answer_form) {
      WVManager.post (AppManager.driver5,
		      Form.serialize (document.contact_answer_form));
    }
    return false;
  },
  'openPage1' : function (page) {
    var cb = function () {
      if (page == 'regulamin')
	document.title = 'Regulamin';
    };
    FVManager.setOnload (cb);
    FVManager.load (AppManager.driver6 + '?page=' + page);
    return false;
  },
  'openPage2' : function (page, subpage) {
    var cb = function (container) {
      MDOM.traverse (container, function (n, args) {
		       if (n.className.indexOf ('link_subpage') != -1) {
			 var s = null;
			 var ap = n.href.lastIndexOf ('?s=');
			 if (ap != '-1') {
			   s = n.href.substr (ap + 3);
			   url = n.href.substring (0, ap);
			 }
			 if (s == subpage)
			   n.className += ' bold';
			 n.onclick = function () {
			   AppManager.openPage2 (page, s);
			   return false;
			 };
		       }
		     });
      if (page == 'faq')
	document.title = 'Pytania i odpowiedzi';
      else if (page == 'mbiznes')
	document.title = 'mBIZNES';
    };
    FVManager.setOnload (cb);
    FVManager.load (AppManager.driver7 + '?page=' + page
		    + '&s=' + subpage);
    if (page == 'faq') MFStats.hit ('faq');
    return false;
  },
  'openPage2sft' : function (page, subpage) {
    var cb = function (container) {
      MDOM.traverse (container, function (n, args) {
		       if (n.className.indexOf ('link_subpage') != -1) {
			 var s = null;
			 var ap = n.href.lastIndexOf ('?s=');
			 if (ap != '-1') {
			   s = n.href.substr (ap + 3);
			   url = n.href.substring (0, ap);
			 }
			 if (s == subpage)
			   n.className += ' bold';
			 n.onclick = function () {
			   AppManager.openPage2 (page, s);
			   return false;
			 };
		       }
		     });
    };
    FVManager.setOnload (cb);
    FVManager.loadStatic ();
  },
  'gappsHit' : function (anchor) {
    if (typeof anchor == 'object') {
      MFStats.hit ('gapps');
      var url = anchor.href;
      setTimeout (function () { document.location = url; }, 200);
      return false;
    }
    return true;
  },
  'gadwsGetCode' : function (obj) {
    var m = null;
    var modCr = MDOM.findParentContainer (obj, 'module');
    if (modCr) {
      m = ModulesManager.getModule (modCr.id.split ('_')[1]);
      if (m) m.showLoader ();
    }
    new Ajax.Request (this.driver8, { method:'post', parameters:'gc=1',
			  onSuccess:function (res) {
			  if (m) m.hideLoader ();
			  m.setBody (res.responseText);
			  var m11b = GID ('m11_body');
			  if (m11b) m11b.innerHTML = res.responseText;
			},
			  onFailure:function (res) {
			  if (m) m.hideLoader ();
			}});
    return false;
  },
  'nazwaplGetCode' : function (obj) {
    var m = null;
    var modCr = MDOM.findParentContainer (obj, 'module');
    if (modCr) {
      m = ModulesManager.getModule (modCr.id.split ('_')[1]);
      if (m) m.showLoader ();
    }
    new Ajax.Request (this.driver10, { method:'post', parameters:'gc=1',
			  onSuccess:function (res) {
			  if (m) m.hideLoader ();
			  m.setBody (res.responseText);
			  var m12b = GID ('m12_body');
			  if (m12b) m12b.innerHTML = res.responseText;
			},
			  onFailure:function (res) {
			  if (m) m.hideLoader ();
			}});
    return false;
  }
};

var FeedManager = new function () {
  var self = this;
  var initied = false;
  var driver     = 'sv/sv_feed.php?id=';
  var driverWV   = 'wv_feed_directory.php?id=';
  var driverCU   = 'sv/sv_feed.php';
  var cookieName = 'mfFeeds';
  var csm        = null;
  this.psFeeds   = null;
  this.feedData  = {};

  this.init = function () {
    if (initied) return;
    var feedDataCookie = null;
    if (typeof userSettings.feeds != 'undefined')
      feedDataCookie = this.psFeeds = userSettings.feeds;
    else
      feedDataCookie = this.psFeeds = MDOM.readCookie (cookieName);

    // MFApp.log ('f: ' + feedDataCookie);

    if (feedDataCookie)
      importData (feedDataCookie);

    initied = true;
  };

  this.register = function (modId, feedId, num) {
    var n = parseInt (num); if (isNaN (n)) n = 7;
    this.feedData[modId] = { 'id':feedId, 'num':n };
  };

  this.unregister = function (modId) {
    delete this.feedData[modId];
  };

  this.isVisible = function (feedId) {
    for (var modId in this.feedData)
      if (this.feedData[modId]['id'] == feedId)
	return modId;
    return false;
  };

  this.getCookieName = function () {
    return cookieName;
  };

  function importData (c) {
    if (c) {
      var carr = c.split (',');
      for (var i = 0; i < carr.length; i++) {
	var h = carr[i].split (':');
	if (h[0] && h[1]) {
	  var g = h[1].split ('.');
	  if (g[0] && g[1]) {
	    self.register (h[0], g[0], g[1]);
	  }
	}
      }
    }
  };

  this.serialize = function () {
    var s = '';
    for (var modId in this.feedData) {
      if (this.feedData[modId]['id'] > 0)
	s += modId + ':' + this.feedData[modId]['id'] + '.' + this.feedData[modId]['num'] + ',';
    }
    s = s.substr (0, s.length - 1);
    return s;
  };

  this.prepareSt = function (n, args) {
    var module = args[0];
    if (n.id == 'm6_st_cc') {
      n.onclick = function () {
	return FeedManager.openDirectory (module);
      };
    }
    else if (n.tagName == 'SELECT' && n.name == 'selectFeedNum') {
      if (typeof FeedManager.feedData[module.id] != 'undefined')
	n.value = FeedManager.feedData[module.id]['num'];
      else if (msie)
	n.value = 7;
      n.onchange = function () {
	this.blur ();
	FeedManager.feedData[module.id]['num'] = this.value;
      };
    }
    else if (n.tagName == 'A') {
      n.onclick = function () {
	this.blur ();
	MFApp.settingsHaveChanged ();
	module.hideEdit ();
	module.refreshContent ();
	return false;
      };
    }
  };

  this.prepareFeedItem = function (n, module) {
    if (n.className == 'entryTitle') {
      if (module.itemCounter++ < FeedManager.feedData[module.id]['num'])
	n.parentNode.className = '';
      var dir = n.getAttribute ('dir');
      if (dir && dir == 'rtl') {
	n.parentNode.style.textAlign = 'right';
	n.parentNode.style.direction = 'rtl';
      }
    }
    else if (n.className == 'entryBody') {
      var dir = n.getAttribute ('dir');
      if (dir && dir == 'rtl') {
	n.style.textAlign = 'right';
	n.style.direction = 'rtl';
      }
    }
    else if (n.className == 'entryLink') {
      n.onmouseover = TooltipManager.show;
      n.onmouseout = TooltipManager.hide;
    }
  };

  this.refreshContent = function (params) {
    var m = this;
    if (FeedManager.feedData[m.id]['id'] != -1) {
      m.showLoader ();
      new Ajax.Request (driver + FeedManager.feedData[m.id]['id'], { method:'get',
	    onSuccess:function (res) {
	    m.hideLoader ();
	    var x = decodeEntities (res.responseText.stripScripts ());
	    x = stripBadTags (x);
	    m.setBody (x);
	    setTimeout (function () {
		m.ft.innerHTML = '';
		var t = GID ('cl_' + FeedManager.feedData[m.id]['id']);
		if (t) {
		  m.setTitle (t.innerHTML);
		  m.ft.appendChild (t);
		  t.innerHTML = 'źródło';
		}
		m.itemCounter = 0;
		MDOM.traverse (m.bd, FeedManager.prepareFeedItem, m);
	      }, 100);
	  },
	  onFailure:function (res) {
	    m.hideLoader ();
	  }
      });
    }
    else
      m.setBody ('<br />Konfiguracja źródła kanału znajduje się w ustawieniach okna. ' +
		 '<a class="more" href="faq.html?s=faq_23" onclick="return AppManager.openPage2(\'faq\',\'faq_23\');">' +
		 'Dowiedz się więcej na temat czytnika RSS</a><br /><br />');
  };

  this.openDirectory = function (m) {
    csm = m;
    WVManager.open ('Katalog kanałów', driverWV + '0');
    return false;
  }

  this.DFD = function (link) { /* follow */
    var id = link.id.split ('_')[1];
    WVManager.showLoader ();
    new Ajax.Request ('wv/' + driverWV + id,
    { method:'get', onSuccess:function (res) {
	WVManager.hideLoader ();
	var tmp = document.createElement ('DIV');
	tmp.innerHTML = res.responseText;
	link.parentNode.appendChild (tmp.firstChild);
	link.onclick = function () {
	  var id = this.id.split ('_')[1];
	  $('feedlist_' + id).toggle ();
	  return false;
	};
      },
	onFailure:function (res) {
	WVManager.hideLoader ();
      }
    });
    return false;
  }

  this.DSF = function (feedid) { /* select */
    var iv = FeedManager.isVisible (feedid);
    if (!iv) {
      FeedManager.register (csm.id, feedid, self.feedData[csm.id]['num']);
      WVManager.hide ();
      csm.refreshContent ();
    }
    else {
      var t = ModulesManager.getModuleType (iv);
      if (t != 'm6') /* feed */
	FeedManager.unregister (iv);
      else
	MFApp.alert ('Ten kanał jest już wyświetlany.');
    }
    return false;
  }

  this.openCustomField = function () {
    $('feed_directory').hide ();
    $('feed_custom_form_div').show ();
    return false;
  };

  this.submitCustomFeed = function () {
    var pars = Form.serialize (document.feed_custom_form);
    new Ajax.Request (driverCU, { method:'post', parameters:pars,
			  onSuccess:function (res) {
			  var xcode = eval ('(' + res.responseText + ')');
			  if (typeof xcode.id != 'undefined') {
			    if (xcode.id != '-1')
			      self.DSF (xcode.id);
			    else
			      MFApp.alert ('Podano nieprawidłowy adres kanału.');
			  }
			}
		      });
    return false;
  };

  function stripBadTags (s) {
    s = s.replace (/<\/?iframe(\n|\r|.)*?>/gi, '');
    s = s.replace (/<\/?object(\n|\r|.)*?<\/object>/gi, '');
    s = s.replace (/<\/?img(\n|\r|.)*?>/gi, '');
    return s;
  }

  function decodeEntities (s) {
    s = s.replace (/&amp;lt;/g, '&#60;');
    s = s.replace (/&amp;gt;/g, '&#62;');
    s = s.replace (/&amp;/g, '&');
    s = s.replace (/&lt;/g, '<');
    s = s.replace (/&gt;/g, '>');
    s = s.replace (/&rsquo;/g, "'");
    return s;
  }
};

var OffersManager = new function () {
  var self = this;
  var initied = false;
  var driverFV    = 'fv_offers.php';
  var driverSV    = 'sv/sv_offers.php';
  var driverWV    = 'wv_offer_answer.php';
  var driverPanel = 'fv_offers_panel.php';
  var driverMy    = 'fv_offers_my.php';
  var cookieName  = 'mfOffers';
  var psOffers    = null;
  this.offersData = {};

  this.init = function () {
    if (initied) return;
    var offersDataCookie = null;
    if (typeof userSettings.offers != 'undefined')
      offersDataCookie = this.psOffers = userSettings.offers;
    else
      offersDataCookie = this.psOffers = MDOM.readCookie (cookieName);

    // MFApp.log ('o: ' + offersDataCookie);

    if (offersDataCookie)
      importData (offersDataCookie);

    initied = true;
  };

  this.register = function (modId, offerPath, offerNum) {
    this.offersData[modId] = { 'path':offerPath, 'num':offerNum };
  };

  this.unregister = function (modId) {
    delete this.offersData[modId];
  };

  this.getCookieName = function () {
    return cookieName;
  };

  function importData (c) {
    if (c) {
      var carr = c.split (',');
      for (var i = 0; i < carr.length; i++) {
	var h = carr[i].split (':');
	if (h[0] && h[1]) {
	  var g = h[1].split ('.');
	  var offerPath = g[0];
	  var offerNum  = g[1];
	  if (g[0] && g[1]) {
	    self.register (h[0], offerPath, offerNum);
	  }
	}
      }
    }
  };

  this.serialize = function () {
    var s = '';
    for (var modId in this.offersData) {
      s += modId + ':' + this.offersData[modId]['path']
	+ '.' + this.offersData[modId]['num'] +  ',';
    }
    s = s.substr (0, s.length - 1);
    return s;
  };

  this.prepareSt = function (n, args) {
    var module = args;
    if (n.name == 'm3c1') {
      module.m3c1 = n;
      if (typeof OffersManager.offersData[module.id] != 'undefined')
	n.value = OffersManager.offersData[module.id]['path'].split ('/')[0];
    }
    else if (n.name == 'm3c2')
      module.m3c2 = n;
    else if (n.name == 'm3c3')
      module.m3c3 = n;
    else if (n.name == 'm3num') {
      module.m3num = n;
      if (typeof OffersManager.offersData[module.id] != 'undefined')
	n.value = OffersManager.offersData[module.id]['num'];
    }
    else if (n.tagName == 'A') {
      n.onclick = function () {
	if (module.st.oninitLocked)
	  return false;
	MFApp.settingsHaveChanged ();
	module.hideEdit ();
	var m3c1v =  module.m3c1.value != '' ? module.m3c1.value : '0';
	var m3c2v =  module.m3c2.value != '' ? module.m3c2.value : '0';
	var m3c3v =  module.m3c3.value != '' ? module.m3c3.value : '0';
	var path  =  m3c1v +'/'+ m3c2v +'/'+ m3c3v;
	self.register (module.id, path, module.m3num.value);
	module.refreshContent ();
	return false;
      };
    }
  }

  this.stOninit = function () {
    module = this;
    if (module.st.oninitLocked)
      return;
    module.st.oninitLocked = true;
    if (module.m3c1 && module.m3c2 && module.m3c3) {
      module.showLoader ();
      var path = OffersManager.offersData[module.id]['path'];
      new Ajax.Request ('api/get_category.php', { method:'get', parameters:'path=' + path,
	    onSuccess:function (res) {
	    module.hideLoader ();
	    try {
	      var xcode = eval ('(' + res.responseText + ')');
	      module.m3c2.options.length = 0;
	      module.m3c3.options.length = 0;
	      for (i = 0; i < xcode['cat1'].length; i += 2) {
		var sel = xcode['cat1'][i+1] == path.split ('/')[1];
		module.m3c2.options[i/2] = new Option (xcode['cat1'][i], xcode['cat1'][i+1], sel);
	      }
	      for (i = 0; i < xcode['cat2'].length; i += 2) {
		var sel = xcode['cat2'][i+1] == path.split ('/')[2];
		module.m3c3.options[i/2] = new Option (xcode['cat2'][i], xcode['cat2'][i+1], sel);
	      }
	      module.m3c1.disabled = false;
	      module.m3c2.disabled = false;
	      module.m3c3.disabled = false;
	      module.m3num.disabled = false;
	      module.st.oninit = null;
	    } catch (e) {}
	    module.st.oninitLocked = false;
	  },
	  onFailure:function (res) {
	    module.hideLoader ();
	    module.st.oninitLocked = false;
	  }
      });
    }
  };

  this.openFV = function (id) {
    FVManager.setOnload (function () { MFApp.toggleNav (2); document.title = 'Ogłoszenia'; });
    if (typeof id == 'string')
      FVManager.load (driverFV + '?ID=' + encodeURIComponent (id));
    else
      FVManager.load (driverFV);
    MFStats.hit ('offers'); 
    return false;
  };

  this.openFVFT = function (anchor) {
    var modId = MDOM.findParentContainer (anchor, 'module').id.split ('_')[1];
    FVManager.setOnload (function () { MFApp.toggleNav (2); });
    FVManager.load (driverFV + '?path=' + this.offersData[modId]['path']);
    MFStats.hit ('offers'); 
    return false;
  };

  this.openPath = function (path) {
    FVManager.setOnload (function () { MFApp.toggleNav (2); });
    FVManager.load (driverFV + '?path=' + path);
    MFStats.hit ('offers'); 
    return false;
  };

  function preparePanelFV () {
    if (MFApp.isSessionExpired ()) return false;
    MFApp.toggleNav (2);
    document.title = 'Dodaj ogłoszenie';
    $('published_date').value = systemSettings.date;
    new DatePicker ({input:'published_date', relative:'calendar_published_date', language:'pl'});
    new DatePicker ({input:'expired_date', relative:'calendar_expired_date', language:'pl', keepFieldEmpty:true});
    highlightPanelMsg ();
  }

  function highlightPanelMsg () {
    var fopm = GID ('fv_offer_panel_msg');
    if (fopm) MDOM.highlight (fopm);
  }

  this.openPanelFV = function () {
    if (userSettings.logged) {
      FVManager.setOnload (preparePanelFV);
      FVManager.load (driverPanel);
    }
    else
      MFApp.notLoggedError ();
    return false;
  };

  function preparePanelMyFV () {
    if (MFApp.isSessionExpired ()) return false;
    MFApp.toggleNav (2);
    document.title = 'Moje ogłoszenia';
  }

  this.openMyFV = function () {
    if (userSettings.logged) {
      FVManager.setOnload (preparePanelMyFV);
      FVManager.load (driverMy);
    }
    else
      MFApp.notLoggedError ();
    return false;
  };

  this.refreshSV = function () {
    var m = this;
    var target = driverSV +'?path='+ self.offersData[m.id]['path'] +'&num='+ self.offersData[m.id]['num'];
    m.showLoader ();
    new Ajax.Request (target, { method:'get', onComplete:function (res) {
	  m.hideLoader ();
	  m.setBody (res.responseText); }
    });
  };

  this.composeAnswer = function (id) {
    WVManager.setOnload (function () {
	if (typeof document.offer_answer_form.email_sender != 'undefined')
	  document.offer_answer_form.email_sender.focus ();
      });
    WVManager.open ('Odpowiedź na ogłoszenie', driverWV + '?id_offer=' + id);
    return false;
  };

  this.getFilters = function (id, end, page, reset) {
    var location = $('location');
    var date = $('date');
    var order = $('order');
    if (id && end) {
      if (typeof reset != 'undefined') {
	FVManager.load (driverFV + '?id_p=' + id + '&end=' + end + '&page=' + page
			+ '&location=1&date=all&order=data');
      }
      else {
	FVManager.load (driverFV + '?id_p=' + id + '&end=' + end + '&page=' + page
			+ '&location=' + location.value	+ '&date=' + date.value
			+ '&order=' + order.value);
      }
    }
  };

  this.deleteOffer = function (obj, id) {
    var t = obj.parentNode.parentNode.cells[0].firstChild.innerHTML;
    if (t.length > 80)
      t = t.substr (0, 80) + '...';
    if (confirm ('Czy na pewno chcesz skasować ogłoszenie "' + t + '"?')) {
      try {
	new Effect.Fade (obj.parentNode.parentNode);
      } catch (e) {}
      setTimeout (function () {
	  FVManager.setOnload (highlightPanelMsg);
	  FVManager.post (driverMy, 'delete=' + encodeURIComponent (id));
	}, 1000);
    }
    return false;
  };

  this.saveOffer = function () {
    if (!assignOfferCategory ())
      return false;
    FVManager.setOnload (preparePanelFV);
    FVManager.post (driverPanel, Form.serialize (document.add_offer_form));
    return false;
  };

  function assignOfferCategory () {
    var level1 = $("level1");
    var level2 = $("level2");
    var level3 = $("level3");

    if (level1 && level1.value == '') {
      level1.className += ' requiredField';
      MFApp.alert ('Wybierz branżę aby dodać ogłoszenie.');
      return false;
    }
    else
      level1.className = level1.className.replace (/requiredField/, '');

    if (level1 && level2 && level3) {
      if ((level2.options.length>1 && level2.value == '') || (level3.options.length>1 && level3.value == '')) {
	level2.className = level2.className.replace (/requiredField/, '');
	level3.className = level3.className.replace (/requiredField/, '');
	if (level2.options.length>1 && level2.value == '')
	  level2.className += ' requiredField';
	else if (level3.options.length>1 && level3.value == '')
	  level3.className += ' requiredField';
	MFApp.alert ("Musisz zawęzić wybór branży.");
      }
      else {
	level2.className = level2.className.replace (/requiredField/, '');
	level3.className = level3.className.replace (/requiredField/, '');
	return true;
      }
    }
    return false;
  };

  this.toggleMore = function (c) {
    var full_content = $('full_content_' + c);
    var content = $('content_' + c);

    if (full_content.className == 'hidden') {
      content.className = 'hidden';
      full_content.className = '';
    }
    else {
      full_content.className = 'hidden';
      content.className = '';
    }
    if (full_content.className != 'hidden')
      new Effect.ScrollTo ($('offer_title_' + c), {offset: -7});
    return false;
  };

  this.sendAnswer = function () {
    if (confirm ('Wysłać wiadomość?') && document.offer_answer_form) {
      WVManager.post (driverWV, Form.serialize (document.offer_answer_form));
    }
    return false;
  };
};

var NkManager = new function () {
  var self = this;
  var initied = false;
  var driverSV    = 'sv/sv_cards.php';
  var cookieName  = 'mfNk';
  var psNk    = null;
  this.nkData = {};

  this.init = function () {
    if (initied) return;
    var nkDataCookie = null;
    if (typeof userSettings.nk != 'undefined')
      nkDataCookie = this.psNk = userSettings.nk;
    else
      nkDataCookie = this.psNk = MDOM.readCookie (cookieName);

    // MFApp.log ('n: ' + nkDataCookie);

    if (nkDataCookie)
      importData (nkDataCookie);

    initied = true;
  };

  this.register = function (modId, nkPath, nkNum) {
    this.nkData[modId] = { 'path':nkPath, 'num':nkNum };
  };

  this.unregister = function (modId) {
    delete this.nkData[modId];
  };

  this.getCookieName = function () {
    return cookieName;
  };

  function importData (c) {
    if (c) {
      var carr = c.split (',');
      for (var i = 0; i < carr.length; i++) {
	var h = carr[i].split (':');
	if (h[0] && h[1]) {
	  var g = h[1].split ('.');
	  var nkPath = g[0];
	  var nkNum  = g[1];
	  if (g[0] && g[1]) {
	    self.register (h[0], nkPath, nkNum);
	  }
	}
      }
    }
  };

  this.serialize = function () {
    var s = '';
    for (var modId in this.nkData) {
      s += modId + ':' + this.nkData[modId]['path']
	+ '.' + this.nkData[modId]['num'] +  ',';
    }
    s = s.substr (0, s.length - 1);
    return s;
  };

  this.prepareSt = function (n, args) {
    var module = args;
    if (n.name == 'm8c1') {
      module.m8c1 = n;
      if (typeof NkManager.nkData[module.id] != 'undefined')
	n.value = NkManager.nkData[module.id]['path'].split ('/')[0];
    }
    else if (n.name == 'm8c2')
      module.m8c2 = n;
    else if (n.name == 'm8c3')
      module.m8c3 = n;
    else if (n.name == 'm8num') {
      module.m8num = n;
      if (typeof NkManager.nkData[module.id] != 'undefined')
	n.value = NkManager.nkData[module.id]['num'];
    }
    else if (n.tagName == 'A') {
      n.onclick = function () {
	this.blur ();
	if (module.st.oninitLocked)
	  return false;
	MFApp.settingsHaveChanged ();
	module.hideEdit ();
	var m8c1v =  module.m8c1.value != '' ? module.m8c1.value : '0';
	var m8c2v =  module.m8c2.value != '' ? module.m8c2.value : '0';
	var m8c3v =  module.m8c3.value != '' ? module.m8c3.value : '0';
	var path  =  m8c1v +'/'+ m8c2v +'/'+ m8c3v;
	self.register (module.id, path, module.m8num.value);
	module.refreshContent ();
	return false;
      };
    }
  }

  this.stOninit = function () {
    module = this;
    if (module.st.oninitLocked)
      return;
    module.st.oninitLocked = true;
    if (module.m8c1 && module.m8c2 && module.m8c3) {
      module.showLoader ();
      var path = NkManager.nkData[module.id]['path'];
      new Ajax.Request ('api/get_category.php', { method:'get', parameters:'path=' + path,
	    onSuccess:function (res) {
	    module.hideLoader ();
	    try {
	      var xcode = eval ('(' + res.responseText + ')');
	      module.m8c2.options.length = 0;
	      module.m8c3.options.length = 0;
	      for (i = 0; i < xcode['cat1'].length; i += 2) {
		var sel = xcode['cat1'][i+1] == path.split ('/')[1];
		module.m8c2.options[i/2] = new Option (xcode['cat1'][i], xcode['cat1'][i+1], sel);
	      }
	      for (i = 0; i < xcode['cat2'].length; i += 2) {
		var sel = xcode['cat2'][i+1] == path.split ('/')[2];
		module.m8c3.options[i/2] = new Option (xcode['cat2'][i], xcode['cat2'][i+1], sel);
	      }
	      module.m8c1.disabled = false;
	      module.m8c2.disabled = false;
	      module.m8c3.disabled = false;
	      module.m8num.disabled = false;
	      module.st.oninit = null;
	    } catch (e) {}
	    module.st.oninitLocked = false;
	  },
	  onFailure:function (res) {
	    module.hideLoader ();
	    module.st.oninitLocked = false;
	  }
      });
    }
  };

  this.refreshSV = function () {
    var m = this;
    var target = driverSV +'?path='+ self.nkData[m.id]['path'] +'&num='+ self.nkData[m.id]['num'];
    m.showLoader ();
    new Ajax.Request (target, { method:'get', onComplete:function (res) {
	  m.hideLoader ();
	  m.setBody (res.responseText); }
    });
  };
};

var BusinessManager = new function () {
  var self = this;
  var initied = false;
  var driverFV = 'fv_business.php';

  this.openFV = function (id_n, page) {
    FVManager.setOnload (setupFV);
    if (id_n && page)
      FVManager.load (driverFV + '?id_n=' + id_n + '&page=' + page);
    else
      FVManager.load (driverFV);
    MFApp.toggleNav (3);
    MFStats.hit ('business');
    return false;
  };

  this.openMBI = function (typeId) {
    var bmc = $('businessMiddleColumn');
    if (bmc) bmc.innerHTML = '<div class="hd hd_articles"><div class="cr_1 cr_1_articles"></div><div class="cr_2 cr_2_articles"></div><div class="icon ico_articles"></div><div class="close hand" title="Zamknij" onmouseover="this.className=\'close_hover hand\'" onmouseout="this.className=\'close hand\'" onclick="FVManager.hide()"></div><div class="title">' + ModulesManager.getModuleInfo (typeId)['title'] + '</div></div><div class="bd bd_white"><div class="cr_3"></div><div class="cr_4"></div><div class="bd_padding"><table width="100%"><tbody id="businessMiddleTable"></tbody></table>';

    var bmt = $('businessMiddleTable');
    if (typeId.indexOf ('mo') == 0 && bmt) {
      var row = bmt.insertRow (0);
      var col = row.insertCell (0);
      row.style.height = '100%';
      col.style.width  = '100%';
      col.style.height = '100%';
      var mifr = $('mifr');
      if (!mifr) {
	mifr = document.createElement ('IFRAME');
	mifr.id = 'mifr';
 	mifr.style.width = '100%';
	mifr.style.height = (FVManager.getHeight () - 5) + 'px';
 	mifr.style.border = 'none';
 	mifr.frameBorder = 'none';
	col.appendChild (mifr);
      }
      var c = null;
      if (mifr && mifr.contentDocument)
	c = mifr.contentDocument;
      else if (mifr && mifr.contentWindow && mifr.contentWindow.document)
	c = mifr.contentWindow.document;
      if (c) {
	c.write ('<b>Trwa ładowanie danych...</b>');
      }
      mifr.onerror = function () {
	var c = null;
	if (mifr && mifr.contentDocument)
	  c = mifr.contentDocument;
	else if (mifr && mifr.contentWindow && mifr.contentWindow.document)
	  c = mifr.contentWindow.document;
	if (c) {
	  c.write ('<b>Nie można pobrać danych.</b>');
	}
      }
      mifr.src = ModulesManager.getModuleInfo (typeId)['url'];
    }
    return false;
  }

  this.load = function (id_n, page) {
    FVManager.setOnload (setupFV);
    FVManager.load (driverFV + '?id_n=' + id_n + '&page=' + page);
    return false;
  }

  this.toggleItem = function (id) {
    var fc = $('fv_business_article_content_' + id);
    fc.toggle ();
    if (fc.style.display != 'none') {
      var ac = $('fv_business_article_title_' + id);
      if (ac) new Effect.ScrollTo (ac, {offset: -3});
    }
    return false; 
  };

  function setupFV () {
    MFApp.toggleNav (3);
    document.title = 'Informacje dla biznesu';
    var bas = document.getElementsByClassName ('tresc_artykulu', $('businessArticles'));
    for (var i = 0; i < bas.length; i++)
      MDOM.traverse (bas[i], prepareArticle, null);
  }

  function prepareArticle (n, args) {
    if (n.tagName == 'A') {
      n.target = '_blank';
    }
  }
};

var HistoryManager = new function () {
  var self = this;
  var ifr = null;
  var state = 0;
  var lastHash = null;
  var historyFrame = null;
  var history = {};
  var historyRoller = [];
  var maxEntries = 25;
  var intv = null;
  var driver = 'ht.html';
  var cbRestore = function () {};

  this.init = function (cb) {
    if (ifr || !cb) return;
    cbRestore = cb;
    ifr = document.getElementById ('htFrame');
    historyFrame = getHistoryFrame ();
    self.save ({'cleanup' : true});
  };

  this.save = function (st) {
    if (ifr && historyFrame && st) {
      try {
	if (intv) clearInterval (intv);
	cleanup ();
	historyFrame.location.assign (systemSettings.site + '/' + driver + '?' + (lastHash =  'state_' + state++));
	history[lastHash] = st;
	historyRoller[historyRoller.length] = [lastHash, history[lastHash]];
	intv = setInterval (pollHistoryFrame, 1000);
	// MFApp.log ('saved ' + lastHash);
      } catch (e) {}
    }
  };

  this.back = function () {
    try {
      historyFrame = getHistoryFrame ();
      if (historyFrame && typeof historyRoller[historyRoller.length - 2][0] != 'undefined') {
	if (intv) clearInterval (intv);
	var prevHash = historyRoller[historyRoller.length - 2][0];
	restore (prevHash);
	cleanup (); /* uhm */
	historyFrame.location.assign (systemSettings.site + '/' + driver + '?' + prevHash);
	intv = setInterval (pollHistoryFrame, 1000);
      }
    } catch (e) {}
  }

  function restore (hash) {
    lastHash = hash;
    var st = history[hash];
    if (st) cbRestore (hash, st);
  };

  function cleanup () {
    for (var i = 0; i < historyRoller.length; i++) {
      if (historyRoller[i][0] == lastHash) {
	historyRoller = historyRoller.slice (0, i + 1);
	break;
      }
    }
    if (historyRoller.length > maxEntries)
      historyRoller = historyRoller.slice (historyRoller.length - maxEntries,
					   historyRoller.length);
    history = {};
    for (var i = 0; i < historyRoller.length; i++) {
      history[historyRoller[i][0]] = historyRoller[i][1];
    }
  }

  function pollHistoryFrame () {
    try {
      var hash = '';
      historyFrame = getHistoryFrame ();
      hash = historyFrame.location.search.substring (historyFrame.location.search.indexOf ('?') + 1,
						     historyFrame.location.search.length);
      if (hash != lastHash && hash != '') {
	// MFApp.log ('history state changed: ' + hash + ' != ' + lastHash);
	restore (hash);
      }
    } catch (e) {}
  }

  function getHistoryFrame () {
    if (ifr && ifr.contentDocument)
      return ifr.contentDocument;
    else if (ifr && ifr.contentWindow && ifr.contentWindow.document)
      return ifr.contentWindow.document;
    return null;
  }
};

var GridResizer = new function () {
  var self = this;
  var cookieName = 'mfGridSize';
  var gsize = null;
  this.psSize = null;

  this.init = function () {
    if (opera || ffdeprecated)
      setEqual ();
    else {
      GID ('gridResizer').className = '';
      restoreLayout ();
    }
  };

  this.getCookieName = function () {
    return cookieName;
  };

  this.getSize = function () {
    return gsize;
  };

  function restoreLayout () {
    var col2_resizer = GID ('col2_resizer');
    if (col2_resizer) {
      col2_resizer.onmousedown = setColWidth;
      col2_resizer.onmouseout  = stopResize;
      col2_resizer.onmouseover = setBKG;
    }
    var col3_resizer = GID ('col3_resizer');
    if (col3_resizer) {
      col3_resizer.onmousedown = setColWidth;
      col3_resizer.onmouseout  = stopResize;
      col3_resizer.onmouseover = setBKG;
    }

    var gridSize = null;
    if (typeof userSettings.gridSize != 'undefined')
      gridSize = self.psSize = userSettings.gridSize;
    else
      gridSize = self.psSize = MDOM.readCookie (cookieName);
    if (gridSize) {
      var cwidth = GID ('workspace').clientWidth;
      var arr = gridSize.split (',');
      GID ('col1').style.width = (parseInt (arr[0]) * cwidth / 100) + 'px';
      GID ('col2').style.width = (parseInt (arr[1]) * cwidth / 100) + 'px';
      GID ('col3').style.width = (parseInt (arr[2]) * cwidth / 100) + 'px';
    }
    else
      setEqual ();
    save ();
  }

  function setEqual () {
    var colwidth = GID ('workspace').clientWidth / 3;
    colwidth = Math.round (colwidth);
    GID ('col1').style.width = colwidth + 'px';
    GID ('col2').style.width = colwidth + 'px';
    GID ('col3').style.width = colwidth + 'px';
  }

  function setBKG () {
    this.className = 'chooseWidth chooseWidthImg2';
  }

  function stopResize () {
    this.className = 'chooseWidth chooseWidthImg1';
    MFApp.settingsHaveChanged ();
    save ();
  }

  function setColWidth (e) {
    if (!e) var e = window.event;
    var el = (window.event) ? e.srcElement : e.target;
    if (el.id == 'col3_resizer') {
      var c1 = GID ('c1');
      var tabX = c1.parentNode.parentNode.offsetWidth;
      var x = c1.offsetWidth;
      c1.style.width = Math.round (x / tabX * 1000) / 10 + '%';
    }
    document.onmousemove = function (e) {
      mouseFollow (e, el);
    }
    document.onmouseup = function (e) {
      stopResize.call (el);
      MDOM.clearSelection ();
      document.onmouseup = null;
      document.onmousemove = null;
    };
    return false;
  }

  function mouseFollow (e, el) {
    if (!e) var e = window.event;
    var posX = e.clientX;
    var col = el.parentNode;
    var prev = parseInt (col.id.substr (1)) - 1;
    var col_p = GID ('c' + prev);
    if (col_p) {
      var col_pX = col_p.offsetLeft;
      var tabX = col.parentNode.parentNode.offsetWidth;
      var colX = col.offsetLeft;
      var x = colX + posX - colX - col_pX;
      try {
	col_p.style.width = Math.round (x / tabX * 1000) / 10 + '%';
      } catch (e) {}
    }
  }

  function save () {
    var s = '';
    var cwidth = GID ('workspace').clientWidth;
    s += (Math.round (100 * GID ('col1').clientWidth / cwidth)) + ','
    s += (Math.round (100 * GID ('col2').clientWidth / cwidth)) + ','
    s += (Math.round (100 * GID ('col3').clientWidth / cwidth));
    gsize = s;
  }
};

var MFStats = new function () {
  var initied = false;
  var _ga_tracker = null;
  var gids = {
    'main'      : { 'gem': 'zDuVVH.BiTJcbq7AGwAnQpcPDfusJwNmGrVPshAu737.V7', 'ga': '/' },
    'search'    : { 'gem': 'd1.rqYsuJNJWFB6Blc.qepYTfXURvy8KUGdmrAYMWjP.C7', 'ga': '/firmy.html' },
    'offers'    : { 'gem': 'zCGacXAEP0SMEMfn81gNdMQLXfY_fiLkn3KWqYkbMsX.v7', 'ga': '/ogloszenia.html' },
    'business'  : { 'gem': 'coWaz0bjP41HkmKWQHnStKQO7H9uC3fV.9Z6iuGxdan.x7', 'ga': '/biznes.html' },
    'invoice'   : { 'gem': 'chswq0bmU3LhmZu1.4g1iaQs.s1uF2Omld52oixi8l..S7', 'ga': '/ksiegowosc.html' },
    'login'     : { 'gem': 'bPpFL485YUCrSXbSsp0g8LbvfbnwYeMwqFSS72KdJ9z.W7', 'ga': '/logowanie.html' },
    'register'  : { 'gem': 'zPBLy28yvO0bbk.BypXjaOTlHbEdvCMA7WrMw6giqiP.j7', 'ga': '/rejestracja.html' },
    'mbusiness' : { 'gem': 'bOuab5.bPw28AQILk9KyxZZzXhYRfyL0Gg92hItR_hf.X7', 'ga': '/mbiznes.html' },
    'gapps'     : { 'gem': 'zIGQbXB0YyuGiUGOwtLhDsQLXhY_fiL0n3J2hAmG_hf.T7', 'ga': '/gapps.html' },
    'faq'       : { 'gem': 'p3Ywt.u8U6pB9rEzIbVJ.GZUHZFB.m9at4ODl6Cgvm3.57', 'ga': '/faq.html' }
  };

  function init () {
    initied = true;
    if (typeof _gat != 'undefined' && systemSettings.ga != '') {
      _ga_tracker = _gat._getTracker (systemSettings.ga);
      _ga_tracker._initData ();
    }
  }

  this.hit = function (sid) {
    if (!initied) init ();
    gemiusHit (sid);
    gaHit (sid);
  };

  function gemiusHit (sid) {
    if (typeof (gids[sid]) != 'undefined') {
      var gemius_url = new String ('http://pro.hit.gemius.pl/_' + (new Date ()).getTime() + '/dot.gif?l=11&id=');
      gemius_url += gids[sid].gem;
      gemius_url += gemius_parameters ();
      var gemius_image = new Image (1,1);
      gemius_image.src = gemius_url;
    }
  }

  function gaHit (sid) {
    if (_ga_tracker && typeof (gids[sid]) != 'undefined') {
      _ga_tracker._trackPageview (gids[sid].ga);
    }
  }

  /* gemius_parameters() - (C) 2000-2004 by Gemius SA */
  function gemius_parameters () {
    var dt = new Date ();
    var url = new String ();
    var d = document;
    url += '&tz=' + dt.getTimezoneOffset ();
    if (d.URL) url += '&href=' + escape (d.URL.substring (0, 299));
    var t = typeof Error;
    if (t != 'undefined') {
      eval ("try { if (top && top.document && top.document.referrer) { url+='&ref='+escape(top.document.referrer.substring(0,299))} else if(d.referrer) { url+='&ref='+escape(d.referrer.substring(0,299))} } catch(exception) {}");
    }
    else if (d.referrer) {
      url += '&ref=' + escape (d.referrer.substring (0,299));
    }
    if (screen) {
      var s = screen;
      if (s.width) url += '&screen=' + s.width + 'x' + s.height;
      if (s.colorDepth) url += '&col=' + s.colorDepth;
    }
    return url;
  }
};
/*
 *   mbaner.js
 */

var linkarray = [];
var flashinstalled = 0; /* nie wiadomo czy zainstalowany */
var flashversion = 0; /* na razie zero, po zakonczeniu powinna przechowywac numer wersji plugina */

if (navigator.plugins && navigator.plugins.length) {
  x = navigator.plugins["Shockwave Flash"];
  if (x) {
    flashinstalled = 2; /* zainstalowany */
    if (x.description) {
      y = x.description;
      flashversion = parseInt (y.replace (/^.*\s+(\d+)\.?\d*\s+\S+$/, "$1"), 10);
    }
  }
  else {
    flashinstalled = 1; /* niezainstalowany */
  }
  if (navigator.plugins["Shockwave Flash 2.0"]) {
    flashinstalled = 2; /* zainstalowany */
    flashversion = 2; /* plugin 2.0 */
  }
}
else if (navigator.mimeTypes && navigator.mimeTypes.length) {
  x = navigator.mimeTypes['application/x-shockwave-flash'];
  if (x && x.enabledPlugin)
    flashinstalled = 2; /* zainstalowany */
  else
    flashinstalled = 1; /* niezainstalowany */
}
else {
  document.write ('<script language="VBScript">\n');
  document.write ('on error resume next\n');
  document.write ('\n');
  document.write ('If 1 = 1 Then\n');
  document.write ('	For i = 2 to 10\n');
  document.write ('		If Not(IsObject(CreateObject("ShockwaveFlash.ShockwaveFlash." & i))) Then\n');
  document.write ('\n');
  document.write ('		Else\n');
  document.write ('			flashinstalled = 2\n');
  document.write ('			flashversion = i\n');
  document.write ('		End If\n');
  document.write ('	Next\n');
  document.write ('End If\n');
  document.write ('\n');
  document.write ('If flashinstalled = 0 Then\n');
  document.write ('	flashinstalled = 1\n');
  document.write ('End If\n');
  document.write ('\n');
  document.write ('<\/script>');
}

function imgComplete () {
  for (var numer = 0; numer < 9; numer++) {
    if (document.getElementById ('start_img_' + numer)) {
      if (!(document.getElementById ('start_img_' + numer).complete)) {
	document.getElementById ('start_img_' + numer).src = document.getElementById ('start_img_' + numer).src;
      }
    }
  }
}

function getGifMsg (numer, gif, w, h, linek, pw, ph) {
  m = '';
  if (!(linek == '')) {
    m += '<a href="' + linek + '">';
  }
  m += '<img src="' +gif+ '" border="0" width="' +w+ '" height="' +h+ '" alt="" id="start_img_' +numer+ '">';
  if (!(linek == ''))
    m += '</a>';
  return m;
}

function setFr (numer, hasGif, opr, flash, gif, instalowac, wersja, w,
		h, linek, flashvars, popup_width, popup_height) {
  try {
    flashname = 'start_movie_' + numer;
    linkarray[numer] = linek;

    if (gif == '') {
      hasGif=0;
    }

    if (isNaN (parseInt (popup_width)) || parseInt (popup_width) < 0 || !popup_width) popup_width = 0;
    if (isNaN (parseInt (popup_height)) || parseInt (popup_height) < 0 || !popup_height) popup_height = 0; 
    var msg = '';

    if (!(linek == '')) {
      if (window.link_w_nowym_oknie == 1) {
	linek = "javascript:window.open('" +linek+ "');void(0);";
      }
      else if (popup_width == 0) {
      }
      else {
	linek = "javascript:window.open('" +linek+ "','_blank','width="
	  +popup_width+ ",height=" +popup_height+ ",scrollbars=yes,status=yes,resizable=yes');void(0);";
      }
    }

    if (flashinstalled == 2 && !(flash == '')) {
      if (wersja <= flashversion) {
	msg += '<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=' +wersja+ ',0,0,0" width="' +w+ '" height="' +h+ '" id="' +flashname+ '">\
				<param name="movie" value="' +flash+ '?link=' +linek+ '"> \
				<param name="allowScriptAccess" value="always">	\
				<param name="quality" value="high">	\
				<param name="flashvars" value="' +flashvars+ '"> \
				<param name="wmode" value="transparent">\
				<embed src="' +flash+ '?link=' +linek+ '" wmode="transparent" allowscriptaccess="always" quality="high" pluginspage="http://www.macromedia.com/go/getflashplayer" type="application/x-shockwave-flash" width="' +w+ '" height="' +h+ '" flashvars="' +flashvars+ '" name="' +flashname+ '"></embed>\
			    </object>';
      }
      else if ((wersja > flashversion && instalowac == 0) && hasGif == 1) {
	msg += getGifMsg (numer, gif, w, h, linek, popup_width, popup_height);
      }
      else if (wersja > flashversion && instalowac == 1) {
	window.open ('http://www.macromedia.com/shockwave/download/download.cgi?P1_Prod_Version=ShockwaveFlash','mm','left=20,top=20,width=450,height=350,scrollbars=1');
      }
    }
    else {
      if (instalowac == 0 && hasGif == 1) {
	msg += getGifMsg (numer, gif, w, h, linek, popup_width, popup_height);
      }
      else if (instalowac == 1) {
	window.open ('http://www.macromedia.com/shockwave/download/download.cgi?P1_Prod_Version=ShockwaveFlash','mm','left=20,top=20,width=450,height=350,scrollbars=1');
      }
    }
    if (document.getElementById ('start_baner_' + numer)) {
      document.getElementById ('start_baner_' + numer).innerHTML = msg;
      timeout1 = setTimeout ('imgComplete()', 5000);
    }
  } catch (e) {}
}

function loadBaners (rid, path) {
  if (systemSettings.startad && systemSettings.bns) {
    for (var i in systemSettings.bns) {
      if (document.getElementById ('scr_' + i)) {
	var url = systemSettings.startad + '/black.js';
	url += '?nr=' + i;
	if (systemSettings.bns[i]['rid'])
	  url += '&rid=' + encodeURIComponent (systemSettings.bns[i]['rid']);
	if (systemSettings.bns[i]['size'])
	  url += '&size=' + encodeURIComponent (systemSettings.bns[i]['size']);
	if (systemSettings.bns[i]['path'])
	  url += '&path=' + encodeURIComponent (systemSettings.bns[i]['path']);
	document.getElementById ('scr_' + i).src = url;
      }
    }
  }
}