/*  Prototype JavaScript framework, version 1.6.0.3
 *  (c) 2005-2008 Sam Stephenson
 *
 *  Prototype is freely distributable under the terms of an MIT-style license.
 *  For details, see the Prototype web site: http://www.prototypejs.org/
 *
 *--------------------------------------------------------------------------*/

var Prototype = {
  Version: '1.6.0.3',

  Browser: {
    IE:     !!(window.attachEvent &&
      navigator.userAgent.indexOf('Opera') === -1),
    Opera:  navigator.userAgent.indexOf('Opera') > -1,
    WebKit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
    Gecko:  navigator.userAgent.indexOf('Gecko') > -1 &&
      navigator.userAgent.indexOf('KHTML') === -1,
    MobileSafari: !!navigator.userAgent.match(/Apple.*Mobile.*Safari/)
  },

  BrowserFeatures: {
    XPath: !!document.evaluate,
    SelectorsAPI: !!document.querySelector,
    ElementExtensions: !!window.HTMLElement,
    SpecificElementExtensions:
      document.createElement('div')['__proto__'] &&
      document.createElement('div')['__proto__'] !==
        document.createElement('form')['__proto__']
  },

  ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',
  JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,

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

if (Prototype.Browser.MobileSafari)
  Prototype.BrowserFeatures.SpecificElementExtensions = false;


/* Based on Alex Arnell's inheritance implementation. */
var Class = {
  create: function() {
    var parent = null, properties = $A(arguments);
    if (Object.isFunction(properties[0]))
      parent = properties.shift();

    function klass() {
      this.initialize.apply(this, arguments);
    }

    Object.extend(klass, Class.Methods);
    klass.superclass = parent;
    klass.subclasses = [];

    if (parent) {
      var subclass = function() { };
      subclass.prototype = parent.prototype;
      klass.prototype = new subclass;
      parent.subclasses.push(klass);
    }

    for (var i = 0; i < properties.length; i++)
      klass.addMethods(properties[i]);

    if (!klass.prototype.initialize)
      klass.prototype.initialize = Prototype.emptyFunction;

    klass.prototype.constructor = klass;

    return klass;
  }
};

Class.Methods = {
  addMethods: function(source) {
    var ancestor   = this.superclass && this.superclass.prototype;
    var properties = Object.keys(source);

    if (!Object.keys({ toString: true }).length)
      properties.push("toString", "valueOf");

    for (var i = 0, length = properties.length; i < length; i++) {
      var property = properties[i], value = source[property];
      if (ancestor && Object.isFunction(value) &&
          value.argumentNames().first() == "$super") {
        var method = value;
        value = (function(m) {
          return function() { return ancestor[m].apply(this, arguments) };
        })(property).wrap(method);

        value.valueOf = method.valueOf.bind(method);
        value.toString = method.toString.bind(method);
      }
      this.prototype[property] = value;
    }

    return this;
  }
};

var Abstract = { };

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.isUndefined(object)) return 'undefined';
      if (object === null) return 'null';
      return object.inspect ? object.inspect() : String(object);
    } catch (e) {
      if (e instanceof RangeError) return '...';
      throw e;
    }
  },

  toJSON: function(object) {
    var type = typeof object;
    switch (type) {
      case 'undefined':
      case 'function':
      case 'unknown': return;
      case 'boolean': return object.toString();
    }

    if (object === null) return 'null';
    if (object.toJSON) return object.toJSON();
    if (Object.isElement(object)) return;

    var results = [];
    for (var property in object) {
      var value = Object.toJSON(object[property]);
      if (!Object.isUndefined(value))
        results.push(property.toJSON() + ': ' + value);
    }

    return '{' + results.join(', ') + '}';
  },

  toQueryString: function(object) {
    return $H(object).toQueryString();
  },

  toHTML: function(object) {
    return object && object.toHTML ? object.toHTML() : String.interpret(object);
  },

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

  isElement: function(object) {
    return !!(object && object.nodeType == 1);
  },

  isArray: function(object) {
    return object != null && typeof object == "object" &&
      'splice' in object && 'join' in object;
  },

  isHash: function(object) {
    return object instanceof Hash;
  },

  isFunction: function(object) {
    return typeof object == "function";
  },

  isString: function(object) {
    return typeof object == "string";
  },

  isNumber: function(object) {
    return typeof object == "number";
  },

  isUndefined: function(object) {
    return typeof object == "undefined";
  }
});

Object.extend(Function.prototype, {
  argumentNames: function() {
    var names = this.toString().match(/^[\s\(]*function[^(]*\(([^\)]*)\)/)[1]
      .replace(/\s+/g, '').split(',');
    return names.length == 1 && !names[0] ? [] : names;
  },

  bind: function() {
    if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
    var __method = this, args = $A(arguments), object = args.shift();
    return function() {
      return __method.apply(object, args.concat($A(arguments)));
    }
  },

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

  curry: function() {
    if (!arguments.length) return this;
    var __method = this, args = $A(arguments);
    return function() {
      return __method.apply(this, args.concat($A(arguments)));
    }
  },

  delay: function() {
    var __method = this, args = $A(arguments), timeout = args.shift() * 1000;
    return window.setTimeout(function() {
      return __method.apply(__method, args);
    }, timeout);
  },

  defer: function() {
    var args = [0.01].concat($A(arguments));
    return this.delay.apply(this, args);
  },

  wrap: function(wrapper) {
    var __method = this;
    return function() {
      return wrapper.apply(this, [__method.bind(this)].concat($A(arguments)));
    }
  },

  methodize: function() {
    if (this._methodized) return this._methodized;
    var __method = this;
    return this._methodized = function() {
      return __method.apply(null, [this].concat($A(arguments)));
    };
  }
});

Date.prototype.toJSON = function() {
  return '"' + this.getUTCFullYear() + '-' +
    (this.getUTCMonth() + 1).toPaddedString(2) + '-' +
    this.getUTCDate().toPaddedString(2) + 'T' +
    this.getUTCHours().toPaddedString(2) + ':' +
    this.getUTCMinutes().toPaddedString(2) + ':' +
    this.getUTCSeconds().toPaddedString(2) + 'Z"';
};

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

RegExp.prototype.match = RegExp.prototype.test;

RegExp.escape = function(str) {
  return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
};

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

var PeriodicalExecuter = Class.create({
  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);
  },

  execute: function() {
    this.callback(this);
  },

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

  onTimerEvent: function() {
    if (!this.currentlyExecuting) {
      try {
        this.currentlyExecuting = true;
        this.execute();
      } finally {
        this.currentlyExecuting = false;
      }
    }
  }
});
Object.extend(String, {
  interpret: function(value) {
    return value == null ? '' : String(value);
  },
  specialChar: {
    '\b': '\\b',
    '\t': '\\t',
    '\n': '\\n',
    '\f': '\\f',
    '\r': '\\r',
    '\\': '\\\\'
  }
});

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 = Object.isUndefined(count) ? 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 String(this);
  },

  truncate: function(length, truncation) {
    length = length || 30;
    truncation = Object.isUndefined(truncation) ? '...' : truncation;
    return this.length > length ?
      this.slice(0, length - truncation.length) + truncation : String(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 self = arguments.callee;
    self.text.data = this;
    return self.div.innerHTML;
  },

  unescapeHTML: function() {
    var div = new Element('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 key = decodeURIComponent(pair.shift());
        var value = pair.length > 1 ? pair.join('=') : pair[0];
        if (value != undefined) value = decodeURIComponent(value);

        if (key in hash) {
          if (!Object.isArray(hash[key])) hash[key] = [hash[key]];
          hash[key].push(value);
        }
        else hash[key] = 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);
  },

  times: function(count) {
    return count < 1 ? '' : new Array(count + 1).join(this);
  },

  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.gsub(/[\x00-\x1f\\]/, function(match) {
      var character = String.specialChar[match[0]];
      return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);
    });
    if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
    return "'" + escapedString.replace(/'/g, '\\\'') + "'";
  },

  toJSON: function() {
    return this.inspect(true);
  },

  unfilterJSON: function(filter) {
    return this.sub(filter || Prototype.JSONFilter, '#{1}');
  },

  isJSON: function() {
    var str = this;
    if (str.blank()) return false;
    str = this.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
    return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);
  },

  evalJSON: function(sanitize) {
    var json = this.unfilterJSON();
    try {
      if (!sanitize || json.isJSON()) return eval('(' + json + ')');
    } catch (e) { }
    throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
  },

  include: function(pattern) {
    return this.indexOf(pattern) > -1;
  },

  startsWith: function(pattern) {
    return this.indexOf(pattern) === 0;
  },

  endsWith: function(pattern) {
    var d = this.length - pattern.length;
    return d >= 0 && this.lastIndexOf(pattern) === d;
  },

  empty: function() {
    return this == '';
  },

  blank: function() {
    return /^\s*$/.test(this);
  },

  interpolate: function(object, pattern) {
    return new Template(this, pattern).evaluate(object);
  }
});

if (Prototype.Browser.WebKit || Prototype.Browser.IE) Object.extend(String.prototype, {
  escapeHTML: function() {
    return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
  },
  unescapeHTML: function() {
    return this.stripTags().replace(/&amp;/g,'&').replace(/&lt;/g,'<').replace(/&gt;/g,'>');
  }
});

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

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

Object.extend(String.prototype.escapeHTML, {
  div:  document.createElement('div'),
  text: document.createTextNode('')
});

String.prototype.escapeHTML.div.appendChild(String.prototype.escapeHTML.text);

var Template = Class.create({
  initialize: function(template, pattern) {
    this.template = template.toString();
    this.pattern = pattern || Template.Pattern;
  },

  evaluate: function(object) {
    if (Object.isFunction(object.toTemplateReplacements))
      object = object.toTemplateReplacements();

    return this.template.gsub(this.pattern, function(match) {
      if (object == null) return '';

      var before = match[1] || '';
      if (before == '\\') return match[2];

      var ctx = object, expr = match[3];
      var pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;
      match = pattern.exec(expr);
      if (match == null) return before;

      while (match != null) {
        var comp = match[1].startsWith('[') ? match[2].gsub('\\\\]', ']') : match[1];
        ctx = ctx[comp];
        if (null == ctx || '' == match[3]) break;
        expr = expr.substring('[' == match[3] ? match[1].length : match[0].length);
        match = pattern.exec(expr);
      }

      return before + String.interpret(ctx);
    });
  }
});
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;

var $break = { };

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

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

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

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

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

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

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

  grep: function(filter, iterator, context) {
    iterator = iterator || Prototype.K;
    var results = [];

    if (Object.isString(filter))
      filter = new RegExp(filter);

    this.each(function(value, index) {
      if (filter.match(value))
        results.push(iterator.call(context, value, index));
    });
    return results;
  },

  include: function(object) {
    if (Object.isFunction(this.indexOf))
      if (this.indexOf(object) != -1) return true;

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

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

  inject: function(memo, iterator, context) {
    this.each(function(value, index) {
      memo = iterator.call(context, 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, context) {
    iterator = iterator || Prototype.K;
    var result;
    this.each(function(value, index) {
      value = iterator.call(context, value, index);
      if (result == null || value >= result)
        result = value;
    });
    return result;
  },

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

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

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

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

  sortBy: function(iterator, context) {
    return this.map(function(value, index) {
      return {
        value: value,
        criteria: iterator.call(context, 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 (Object.isFunction(args.last()))
      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,
  filter:  Enumerable.findAll,
  member:  Enumerable.include,
  entries: Enumerable.toArray,
  every:   Enumerable.all,
  some:    Enumerable.any
});
function $A(iterable) {
  if (!iterable) return [];
  if (iterable.toArray) return iterable.toArray();
  var length = iterable.length || 0, results = new Array(length);
  while (length--) results[length] = iterable[length];
  return results;
}

if (Prototype.Browser.WebKit) {
  $A = function(iterable) {
    if (!iterable) return [];
    // In Safari, only use the `toArray` method if it's not a NodeList.
    // A NodeList is a function, has an function `item` property, and a numeric
    // `length` property. Adapted from Google Doctype.
    if (!(typeof iterable === 'function' && typeof iterable.length ===
        'number' && typeof iterable.item === 'function') && iterable.toArray)
      return iterable.toArray();
    var length = iterable.length || 0, results = new Array(length);
    while (length--) results[length] = iterable[length];
    return results;
  };
}

Array.from = $A;

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(Object.isArray(value) ?
        value.flatten() : [value]);
    });
  },

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

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

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

  uniq: function(sorted) {
    return this.inject([], function(array, value, index) {
      if (0 == index || (sorted ? array.last() != value : !array.include(value)))
        array.push(value);
      return array;
    });
  },

  intersect: function(array) {
    return this.uniq().findAll(function(item) {
      return array.detect(function(value) { return item === value });
    });
  },

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

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

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

  toJSON: function() {
    var results = [];
    this.each(function(object) {
      var value = Object.toJSON(object);
      if (!Object.isUndefined(value)) results.push(value);
    });
    return '[' + results.join(', ') + ']';
  }
});

// use native browser JS 1.6 implementation if available
if (Object.isFunction(Array.prototype.forEach))
  Array.prototype._each = Array.prototype.forEach;

if (!Array.prototype.indexOf) Array.prototype.indexOf = function(item, i) {
  i || (i = 0);
  var length = this.length;
  if (i < 0) i = length + i;
  for (; i < length; i++)
    if (this[i] === item) return i;
  return -1;
};

if (!Array.prototype.lastIndexOf) Array.prototype.lastIndexOf = function(item, i) {
  i = isNaN(i) ? this.length : (i < 0 ? this.length + i : i) + 1;
  var n = this.slice(0, i).reverse().indexOf(item);
  return (n < 0) ? n : i - n - 1;
};

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

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

if (Prototype.Browser.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 (Object.isArray(arguments[i])) {
        for (var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
          array.push(arguments[i][j]);
      } else {
        array.push(arguments[i]);
      }
    }
    return array;
  };
}
Object.extend(Number.prototype, {
  toColorPart: function() {
    return this.toPaddedString(2, 16);
  },

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

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

  toPaddedString: function(length, radix) {
    var string = this.toString(radix || 10);
    return '0'.times(length - string.length) + string;
  },

  toJSON: function() {
    return isFinite(this) ? this.toString() : 'null';
  }
});

$w('abs round ceil floor').each(function(method){
  Number.prototype[method] = Math[method].methodize();
});
function $H(object) {
  return new Hash(object);
};

var Hash = Class.create(Enumerable, (function() {

  function toQueryPair(key, value) {
    if (Object.isUndefined(value)) return key;
    return key + '=' + encodeURIComponent(String.interpret(value));
  }

  return {
    initialize: function(object) {
      this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);
    },

    _each: function(iterator) {
      for (var key in this._object) {
        var value = this._object[key], pair = [key, value];
        pair.key = key;
        pair.value = value;
        iterator(pair);
      }
    },

    set: function(key, value) {
      return this._object[key] = value;
    },

    get: function(key) {
      // simulating poorly supported hasOwnProperty
      if (this._object[key] !== Object.prototype[key])
        return this._object[key];
    },

    unset: function(key) {
      var value = this._object[key];
      delete this._object[key];
      return value;
    },

    toObject: function() {
      return Object.clone(this._object);
    },

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

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

    index: function(value) {
      var match = this.detect(function(pair) {
        return pair.value === value;
      });
      return match && match.key;
    },

    merge: function(object) {
      return this.clone().update(object);
    },

    update: function(object) {
      return new Hash(object).inject(this, function(result, pair) {
        result.set(pair.key, pair.value);
        return result;
      });
    },

    toQueryString: function() {
      return this.inject([], function(results, pair) {
        var key = encodeURIComponent(pair.key), values = pair.value;

        if (values && typeof values == 'object') {
          if (Object.isArray(values))
            return results.concat(values.map(toQueryPair.curry(key)));
        } else results.push(toQueryPair(key, values));
        return results;
      }).join('&');
    },

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

    toJSON: function() {
      return Object.toJSON(this.toObject());
    },

    clone: function() {
      return new Hash(this);
    }
  }
})());

Hash.prototype.toTemplateReplacements = Hash.prototype.toObject;
Hash.from = $H;
var ObjectRange = Class.create(Enumerable, {
  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 (Object.isFunction(responder[callback])) {
        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 = Class.create({
  initialize: function(options) {
    this.options = {
      method:       'post',
      asynchronous: true,
      contentType:  'application/x-www-form-urlencoded',
      encoding:     'UTF-8',
      parameters:   '',
      evalJSON:     true,
      evalJS:       true
    };
    Object.extend(this.options, options || { });

    this.options.method = this.options.method.toLowerCase();

    if (Object.isString(this.options.parameters))
      this.options.parameters = this.options.parameters.toQueryParams();
    else if (Object.isHash(this.options.parameters))
      this.options.parameters = this.options.parameters.toObject();
  }
});

Ajax.Request = Class.create(Ajax.Base, {
  _complete: false,

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

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

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

    this.parameters = params;

    if (params = Object.toQueryString(params)) {
      // when GET, append parameters to URL
      if (this.method == 'get')
        this.url += (this.url.include('?') ? '&' : '?') + params;
      else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
        params += '&_=';
    }

    try {
      var response = new Ajax.Response(this);
      if (this.options.onCreate) this.options.onCreate(response);
      Ajax.Responders.dispatch('onCreate', this, response);

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

      if (this.options.asynchronous) this.respondToReadyState.bind(this).defer(1);

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

      this.body = this.method == 'post' ? (this.options.postBody || params) : null;
      this.transport.send(this.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 (Object.isFunction(extras.push))
        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() {
    var status = this.getStatus();
    return !status || (status >= 200 && status < 300);
  },

  getStatus: function() {
    try {
      return this.transport.status || 0;
    } catch (e) { return 0 }
  },

  respondToReadyState: function(readyState) {
    var state = Ajax.Request.Events[readyState], response = new Ajax.Response(this);

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

      var contentType = response.getHeader('Content-type');
      if (this.options.evalJS == 'force'
          || (this.options.evalJS && this.isSameOrigin() && contentType
          && contentType.match(/^\s*(text|application)\/(x-)?(java|ecma)script(;.*)?\s*$/i)))
        this.evalResponse();
    }

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

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

  isSameOrigin: function() {
    var m = this.url.match(/^\s*https?:\/\/[^\/]*/);
    return !m || (m[0] == '#{protocol}//#{domain}#{port}'.interpolate({
      protocol: location.protocol,
      domain: document.domain,
      port: location.port ? ':' + location.port : ''
    }));
  },

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

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

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

Ajax.Request.Events =
  ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];

Ajax.Response = Class.create({
  initialize: function(request){
    this.request = request;
    var transport  = this.transport  = request.transport,
        readyState = this.readyState = transport.readyState;

    if((readyState > 2 && !Prototype.Browser.IE) || readyState == 4) {
      this.status       = this.getStatus();
      this.statusText   = this.getStatusText();
      this.responseText = String.interpret(transport.responseText);
      this.headerJSON   = this._getHeaderJSON();
    }

    if(readyState == 4) {
      var xml = transport.responseXML;
      this.responseXML  = Object.isUndefined(xml) ? null : xml;
      this.responseJSON = this._getResponseJSON();
    }
  },

  status:      0,
  statusText: '',

  getStatus: Ajax.Request.prototype.getStatus,

  getStatusText: function() {
    try {
      return this.transport.statusText || '';
    } catch (e) { return '' }
  },

  getHeader: Ajax.Request.prototype.getHeader,

  getAllHeaders: function() {
    try {
      return this.getAllResponseHeaders();
    } catch (e) { return null }
  },

  getResponseHeader: function(name) {
    return this.transport.getResponseHeader(name);
  },

  getAllResponseHeaders: function() {
    return this.transport.getAllResponseHeaders();
  },

  _getHeaderJSON: function() {
    var json = this.getHeader('X-JSON');
    if (!json) return null;
    json = decodeURIComponent(escape(json));
    try {
      return json.evalJSON(this.request.options.sanitizeJSON ||
        !this.request.isSameOrigin());
    } catch (e) {
      this.request.dispatchException(e);
    }
  },

  _getResponseJSON: function() {
    var options = this.request.options;
    if (!options.evalJSON || (options.evalJSON != 'force' &&
      !(this.getHeader('Content-type') || '').include('application/json')) ||
        this.responseText.blank())
          return null;
    try {
      return this.responseText.evalJSON(options.sanitizeJSON ||
        !this.request.isSameOrigin());
    } catch (e) {
      this.request.dispatchException(e);
    }
  }
});

Ajax.Updater = Class.create(Ajax.Request, {
  initialize: function($super, container, url, options) {
    this.container = {
      success: (container.success || container),
      failure: (container.failure || (container.success ? null : container))
    };

    options = Object.clone(options);
    var onComplete = options.onComplete;
    options.onComplete = (function(response, json) {
      this.updateContent(response.responseText);
      if (Object.isFunction(onComplete)) onComplete(response, json);
    }).bind(this);

    $super(url, options);
  },

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

    if (!options.evalScripts) responseText = responseText.stripScripts();

    if (receiver = $(receiver)) {
      if (options.insertion) {
        if (Object.isString(options.insertion)) {
          var insertion = { }; insertion[options.insertion] = responseText;
          receiver.insert(insertion);
        }
        else options.insertion(receiver, responseText);
      }
      else receiver.update(responseText);
    }
  }
});

Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
  initialize: function($super, container, url, options) {
    $super(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(response) {
    if (this.options.decay) {
      this.decay = (response.responseText == this.lastText ?
        this.decay * this.options.decay : 1);

      this.lastText = response.responseText;
    }
    this.timer = this.onTimerEvent.bind(this).delay(this.decay * this.frequency);
  },

  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 (Object.isString(element))
    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(Element.extend(query.snapshotItem(i)));
    return results;
  };
}

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

if (!window.Node) var Node = { };

if (!Node.ELEMENT_NODE) {
  // DOM level 2 ECMAScript Language Binding
  Object.extend(Node, {
    ELEMENT_NODE: 1,
    ATTRIBUTE_NODE: 2,
    TEXT_NODE: 3,
    CDATA_SECTION_NODE: 4,
    ENTITY_REFERENCE_NODE: 5,
    ENTITY_NODE: 6,
    PROCESSING_INSTRUCTION_NODE: 7,
    COMMENT_NODE: 8,
    DOCUMENT_NODE: 9,
    DOCUMENT_TYPE_NODE: 10,
    DOCUMENT_FRAGMENT_NODE: 11,
    NOTATION_NODE: 12
  });
}

(function() {
  var element = this.Element;
  this.Element = function(tagName, attributes) {
    attributes = attributes || { };
    tagName = tagName.toLowerCase();
    var cache = Element.cache;
    if (Prototype.Browser.IE && attributes.name) {
      tagName = '<' + tagName + ' name="' + attributes.name + '">';
      delete attributes.name;
      return Element.writeAttribute(document.createElement(tagName), attributes);
    }
    if (!cache[tagName]) cache[tagName] = Element.extend(document.createElement(tagName));
    return Element.writeAttribute(cache[tagName].cloneNode(false), attributes);
  };
  Object.extend(this.Element, element || { });
  if (element) this.Element.prototype = element.prototype;
}).call(window);

Element.cache = { };

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 = $(element);
    element.style.display = 'none';
    return element;
  },

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

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

  update: function(element, content) {
    element = $(element);
    if (content && content.toElement) content = content.toElement();
    if (Object.isElement(content)) return element.update().insert(content);
    content = Object.toHTML(content);
    element.innerHTML = content.stripScripts();
    content.evalScripts.bind(content).defer();
    return element;
  },

  replace: function(element, content) {
    element = $(element);
    if (content && content.toElement) content = content.toElement();
    else if (!Object.isElement(content)) {
      content = Object.toHTML(content);
      var range = element.ownerDocument.createRange();
      range.selectNode(element);
      content.evalScripts.bind(content).defer();
      content = range.createContextualFragment(content.stripScripts());
    }
    element.parentNode.replaceChild(content, element);
    return element;
  },

  insert: function(element, insertions) {
    element = $(element);

    if (Object.isString(insertions) || Object.isNumber(insertions) ||
        Object.isElement(insertions) || (insertions && (insertions.toElement || insertions.toHTML)))
          insertions = {bottom:insertions};

    var content, insert, tagName, childNodes;

    for (var position in insertions) {
      content  = insertions[position];
      position = position.toLowerCase();
      insert = Element._insertionTranslations[position];

      if (content && content.toElement) content = content.toElement();
      if (Object.isElement(content)) {
        insert(element, content);
        continue;
      }

      content = Object.toHTML(content);

      tagName = ((position == 'before' || position == 'after')
        ? element.parentNode : element).tagName.toUpperCase();

      childNodes = Element._getContentFromAnonymousElement(tagName, content.stripScripts());

      if (position == 'top' || position == 'after') childNodes.reverse();
      childNodes.each(insert.curry(element));

      content.evalScripts.bind(content).defer();
    }

    return element;
  },

  wrap: function(element, wrapper, attributes) {
    element = $(element);
    if (Object.isElement(wrapper))
      $(wrapper).writeAttribute(attributes || { });
    else if (Object.isString(wrapper)) wrapper = new Element(wrapper, attributes);
    else wrapper = new Element('div', wrapper);
    if (element.parentNode)
      element.parentNode.replaceChild(wrapper, element);
    wrapper.appendChild(element);
    return wrapper;
  },

  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 $(element).select("*");
  },

  firstDescendant: function(element) {
    element = $(element).firstChild;
    while (element && element.nodeType != 1) element = element.nextSibling;
    return $(element);
  },

  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 (Object.isString(selector))
      selector = new Selector(selector);
    return selector.match($(element));
  },

  up: function(element, expression, index) {
    element = $(element);
    if (arguments.length == 1) return $(element.parentNode);
    var ancestors = element.ancestors();
    return Object.isNumber(expression) ? ancestors[expression] :
      Selector.findElement(ancestors, expression, index);
  },

  down: function(element, expression, index) {
    element = $(element);
    if (arguments.length == 1) return element.firstDescendant();
    return Object.isNumber(expression) ? element.descendants()[expression] :
      Element.select(element, expression)[index || 0];
  },

  previous: function(element, expression, index) {
    element = $(element);
    if (arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));
    var previousSiblings = element.previousSiblings();
    return Object.isNumber(expression) ? previousSiblings[expression] :
      Selector.findElement(previousSiblings, expression, index);
  },

  next: function(element, expression, index) {
    element = $(element);
    if (arguments.length == 1) return $(Selector.handlers.nextElementSibling(element));
    var nextSiblings = element.nextSiblings();
    return Object.isNumber(expression) ? nextSiblings[expression] :
      Selector.findElement(nextSiblings, expression, index);
  },

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

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

  identify: function(element) {
    element = $(element);
    var id = element.readAttribute('id'), self = arguments.callee;
    if (id) return id;
    do { id = 'anonymous_element_' + self.counter++ } while ($(id));
    element.writeAttribute('id', id);
    return id;
  },

  readAttribute: function(element, name) {
    element = $(element);
    if (Prototype.Browser.IE) {
      var t = Element._attributeTranslations.read;
      if (t.values[name]) return t.values[name](element, name);
      if (t.names[name]) name = t.names[name];
      if (name.include(':')) {
        return (!element.attributes || !element.attributes[name]) ? null :
         element.attributes[name].value;
      }
    }
    return element.getAttribute(name);
  },

  writeAttribute: function(element, name, value) {
    element = $(element);
    var attributes = { }, t = Element._attributeTranslations.write;

    if (typeof name == 'object') attributes = name;
    else attributes[name] = Object.isUndefined(value) ? true : value;

    for (var attr in attributes) {
      name = t.names[attr] || attr;
      value = attributes[attr];
      if (t.values[attr]) name = t.values[attr](element, value);
      if (value === false || value === null)
        element.removeAttribute(name);
      else if (value === true)
        element.setAttribute(name, name);
      else element.setAttribute(name, value);
    }
    return element;
  },

  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;
    return (elementClassName.length > 0 && (elementClassName == className ||
      new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
  },

  addClassName: function(element, className) {
    if (!(element = $(element))) return;
    if (!element.hasClassName(className))
      element.className += (element.className ? ' ' : '') + className;
    return element;
  },

  removeClassName: function(element, className) {
    if (!(element = $(element))) return;
    element.className = element.className.replace(
      new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
    return element;
  },

  toggleClassName: function(element, className) {
    if (!(element = $(element))) return;
    return element[element.hasClassName(className) ?
      'removeClassName' : 'addClassName'](className);
  },

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

  descendantOf: function(element, ancestor) {
    element = $(element), ancestor = $(ancestor);

    if (element.compareDocumentPosition)
      return (element.compareDocumentPosition(ancestor) & 8) === 8;

    if (ancestor.contains)
      return ancestor.contains(element) && ancestor !== element;

    while (element = element.parentNode)
      if (element == ancestor) return true;

    return false;
  },

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

  getStyle: function(element, style) {
    element = $(element);
    style = style == 'float' ? 'cssFloat' : style.camelize();
    var value = element.style[style];
    if (!value || value == 'auto') {
      var css = document.defaultView.getComputedStyle(element, null);
      value = css ? css[style] : null;
    }
    if (style == 'opacity') return value ? parseFloat(value) : 1.0;
    return value == 'auto' ? null : value;
  },

  getOpacity: function(element) {
    return $(element).getStyle('opacity');
  },

  setStyle: function(element, styles) {
    element = $(element);
    var elementStyle = element.style, match;
    if (Object.isString(styles)) {
      element.style.cssText += ';' + styles;
      return styles.include('opacity') ?
        element.setOpacity(styles.match(/opacity:\s*(\d?\.?\d*)/)[1]) : element;
    }
    for (var property in styles)
      if (property == 'opacity') element.setOpacity(styles[property]);
      else
        elementStyle[(property == 'float' || property == 'cssFloat') ?
          (Object.isUndefined(elementStyle.styleFloat) ? 'cssFloat' : 'styleFloat') :
            property] = styles[property];

    return element;
  },

  setOpacity: function(element, value) {
    element = $(element);
    element.style.opacity = (value == 1 || value === '') ? '' :
      (value < 0.00001) ? 0 : 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 (Prototype.Browser.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.getStyle(element, 'overflow') || 'auto';
    if (element._overflow !== '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;
  },

  cumulativeOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;
      element = element.offsetParent;
    } while (element);
    return Element._returnOffset(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.toUpperCase() == 'BODY') break;
        var p = Element.getStyle(element, 'position');
        if (p !== 'static') break;
      }
    } while (element);
    return Element._returnOffset(valueL, valueT);
  },

  absolutize: function(element) {
    element = $(element);
    if (element.getStyle('position') == 'absolute') return element;
    // Position.prepare(); // To be done manually by Scripty when it needs it.

    var offsets = element.positionedOffset();
    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';
    return element;
  },

  relativize: function(element) {
    element = $(element);
    if (element.getStyle('position') == 'relative') return element;
    // Position.prepare(); // To be done manually by Scripty when it needs it.

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

  cumulativeScrollOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.scrollTop  || 0;
      valueL += element.scrollLeft || 0;
      element = element.parentNode;
    } while (element);
    return Element._returnOffset(valueL, valueT);
  },

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

  viewportOffset: 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 &&
        Element.getStyle(element, 'position') == 'absolute') break;

    } while (element = element.offsetParent);

    element = forElement;
    do {
      if (!Prototype.Browser.Opera || (element.tagName && (element.tagName.toUpperCase() == 'BODY'))) {
        valueT -= element.scrollTop  || 0;
        valueL -= element.scrollLeft || 0;
      }
    } while (element = element.parentNode);

    return Element._returnOffset(valueL, valueT);
  },

  clonePosition: function(element, source) {
    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 = source.viewportOffset();

    // find coordinate system to use
    element = $(element);
    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(element, 'position') == 'absolute') {
      parent = element.getOffsetParent();
      delta = parent.viewportOffset();
    }

    // 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)   element.style.left  = (p[0] - delta[0] + options.offsetLeft) + 'px';
    if (options.setTop)    element.style.top   = (p[1] - delta[1] + options.offsetTop) + 'px';
    if (options.setWidth)  element.style.width = source.offsetWidth + 'px';
    if (options.setHeight) element.style.height = source.offsetHeight + 'px';
    return element;
  }
};

Element.Methods.identify.counter = 1;

Object.extend(Element.Methods, {
  getElementsBySelector: Element.Methods.select,
  childElements: Element.Methods.immediateDescendants
});

Element._attributeTranslations = {
  write: {
    names: {
      className: 'class',
      htmlFor:   'for'
    },
    values: { }
  }
};

if (Prototype.Browser.Opera) {
  Element.Methods.getStyle = Element.Methods.getStyle.wrap(
    function(proceed, element, style) {
      switch (style) {
        case 'left': case 'top': case 'right': case 'bottom':
          if (proceed(element, 'position') === 'static') return null;
        case 'height': case 'width':
          // returns '0px' for hidden elements; we want it to return null
          if (!Element.visible(element)) return null;

          // returns the border-box dimensions rather than the content-box
          // dimensions, so we subtract padding and borders from the value
          var dim = parseInt(proceed(element, style), 10);

          if (dim !== element['offset' + style.capitalize()])
            return dim + 'px';

          var properties;
          if (style === 'height') {
            properties = ['border-top-width', 'padding-top',
             'padding-bottom', 'border-bottom-width'];
          }
          else {
            properties = ['border-left-width', 'padding-left',
             'padding-right', 'border-right-width'];
          }
          return properties.inject(dim, function(memo, property) {
            var val = proceed(element, property);
            return val === null ? memo : memo - parseInt(val, 10);
          }) + 'px';
        default: return proceed(element, style);
      }
    }
  );

  Element.Methods.readAttribute = Element.Methods.readAttribute.wrap(
    function(proceed, element, attribute) {
      if (attribute === 'title') return element.title;
      return proceed(element, attribute);
    }
  );
}

else if (Prototype.Browser.IE) {
  // IE doesn't report offsets correctly for static elements, so we change them
  // to "relative" to get the values, then change them back.
  Element.Methods.getOffsetParent = Element.Methods.getOffsetParent.wrap(
    function(proceed, element) {
      element = $(element);
      // IE throws an error if element is not in document
      try { element.offsetParent }
      catch(e) { return $(document.body) }
      var position = element.getStyle('position');
      if (position !== 'static') return proceed(element);
      element.setStyle({ position: 'relative' });
      var value = proceed(element);
      element.setStyle({ position: position });
      return value;
    }
  );

  $w('positionedOffset viewportOffset').each(function(method) {
    Element.Methods[method] = Element.Methods[method].wrap(
      function(proceed, element) {
        element = $(element);
        try { element.offsetParent }
        catch(e) { return Element._returnOffset(0,0) }
        var position = element.getStyle('position');
        if (position !== 'static') return proceed(element);
        // Trigger hasLayout on the offset parent so that IE6 reports
        // accurate offsetTop and offsetLeft values for position: fixed.
        var offsetParent = element.getOffsetParent();
        if (offsetParent && offsetParent.getStyle('position') === 'fixed')
          offsetParent.setStyle({ zoom: 1 });
        element.setStyle({ position: 'relative' });
        var value = proceed(element);
        element.setStyle({ position: position });
        return value;
      }
    );
  });

  Element.Methods.cumulativeOffset = Element.Methods.cumulativeOffset.wrap(
    function(proceed, element) {
      try { element.offsetParent }
      catch(e) { return Element._returnOffset(0,0) }
      return proceed(element);
    }
  );

  Element.Methods.getStyle = function(element, style) {
    element = $(element);
    style = (style == 'float' || style == 'cssFloat') ? 'styleFloat' : style.camelize();
    var value = element.style[style];
    if (!value && element.currentStyle) value = element.currentStyle[style];

    if (style == 'opacity') {
      if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
        if (value[1]) return parseFloat(value[1]) / 100;
      return 1.0;
    }

    if (value == 'auto') {
      if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
        return element['offset' + style.capitalize()] + 'px';
      return null;
    }
    return value;
  };

  Element.Methods.setOpacity = function(element, value) {
    function stripAlpha(filter){
      return filter.replace(/alpha\([^\)]*\)/gi,'');
    }
    element = $(element);
    var currentStyle = element.currentStyle;
    if ((currentStyle && !currentStyle.hasLayout) ||
      (!currentStyle && element.style.zoom == 'normal'))
        element.style.zoom = 1;

    var filter = element.getStyle('filter'), style = element.style;
    if (value == 1 || value === '') {
      (filter = stripAlpha(filter)) ?
        style.filter = filter : style.removeAttribute('filter');
      return element;
    } else if (value < 0.00001) value = 0;
    style.filter = stripAlpha(filter) +
      'alpha(opacity=' + (value * 100) + ')';
    return element;
  };

  Element._attributeTranslations = {
    read: {
      names: {
        'class': 'className',
        'for':   'htmlFor'
      },
      values: {
        _getAttr: function(element, attribute) {
          return element.getAttribute(attribute, 2);
        },
        _getAttrNode: function(element, attribute) {
          var node = element.getAttributeNode(attribute);
          return node ? node.value : "";
        },
        _getEv: function(element, attribute) {
          attribute = element.getAttribute(attribute);
          return attribute ? attribute.toString().slice(23, -2) : null;
        },
        _flag: function(element, attribute) {
          return $(element).hasAttribute(attribute) ? attribute : null;
        },
        style: function(element) {
          return element.style.cssText.toLowerCase();
        },
        title: function(element) {
          return element.title;
        }
      }
    }
  };

  Element._attributeTranslations.write = {
    names: Object.extend({
      cellpadding: 'cellPadding',
      cellspacing: 'cellSpacing'
    }, Element._attributeTranslations.read.names),
    values: {
      checked: function(element, value) {
        element.checked = !!value;
      },

      style: function(element, value) {
        element.style.cssText = value ? value : '';
      }
    }
  };

  Element._attributeTranslations.has = {};

  $w('colSpan rowSpan vAlign dateTime accessKey tabIndex ' +
      'encType maxLength readOnly longDesc frameBorder').each(function(attr) {
    Element._attributeTranslations.write.names[attr.toLowerCase()] = attr;
    Element._attributeTranslations.has[attr.toLowerCase()] = attr;
  });

  (function(v) {
    Object.extend(v, {
      href:        v._getAttr,
      src:         v._getAttr,
      type:        v._getAttr,
      action:      v._getAttrNode,
      disabled:    v._flag,
      checked:     v._flag,
      readonly:    v._flag,
      multiple:    v._flag,
      onload:      v._getEv,
      onunload:    v._getEv,
      onclick:     v._getEv,
      ondblclick:  v._getEv,
      onmousedown: v._getEv,
      onmouseup:   v._getEv,
      onmouseover: v._getEv,
      onmousemove: v._getEv,
      onmouseout:  v._getEv,
      onfocus:     v._getEv,
      onblur:      v._getEv,
      onkeypress:  v._getEv,
      onkeydown:   v._getEv,
      onkeyup:     v._getEv,
      onsubmit:    v._getEv,
      onreset:     v._getEv,
      onselect:    v._getEv,
      onchange:    v._getEv
    });
  })(Element._attributeTranslations.read.values);
}

else if (Prototype.Browser.Gecko && /rv:1\.8\.0/.test(navigator.userAgent)) {
  Element.Methods.setOpacity = function(element, value) {
    element = $(element);
    element.style.opacity = (value == 1) ? 0.999999 :
      (value === '') ? '' : (value < 0.00001) ? 0 : value;
    return element;
  };
}

else if (Prototype.Browser.WebKit) {
  Element.Methods.setOpacity = function(element, value) {
    element = $(element);
    element.style.opacity = (value == 1 || value === '') ? '' :
      (value < 0.00001) ? 0 : value;

    if (value == 1)
      if(element.tagName.toUpperCase() == 'IMG' && element.width) {
        element.width++; element.width--;
      } else try {
        var n = document.createTextNode(' ');
        element.appendChild(n);
        element.removeChild(n);
      } catch (e) { }

    return element;
  };

  // Safari returns margins on body which is incorrect if the child is absolutely
  // positioned.  For performance reasons, redefine Element#cumulativeOffset for
  // KHTML/WebKit only.
  Element.Methods.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 Element._returnOffset(valueL, valueT);
  };
}

if (Prototype.Browser.IE || Prototype.Browser.Opera) {
  // IE and Opera are missing .innerHTML support for TABLE-related and SELECT elements
  Element.Methods.update = function(element, content) {
    element = $(element);

    if (content && content.toElement) content = content.toElement();
    if (Object.isElement(content)) return element.update().insert(content);

    content = Object.toHTML(content);
    var tagName = element.tagName.toUpperCase();

    if (tagName in Element._insertionTranslations.tags) {
      $A(element.childNodes).each(function(node) { element.removeChild(node) });
      Element._getContentFromAnonymousElement(tagName, content.stripScripts())
        .each(function(node) { element.appendChild(node) });
    }
    else element.innerHTML = content.stripScripts();

    content.evalScripts.bind(content).defer();
    return element;
  };
}

if ('outerHTML' in document.createElement('div')) {
  Element.Methods.replace = function(element, content) {
    element = $(element);

    if (content && content.toElement) content = content.toElement();
    if (Object.isElement(content)) {
      element.parentNode.replaceChild(content, element);
      return element;
    }

    content = Object.toHTML(content);
    var parent = element.parentNode, tagName = parent.tagName.toUpperCase();

    if (Element._insertionTranslations.tags[tagName]) {
      var nextSibling = element.next();
      var fragments = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
      parent.removeChild(element);
      if (nextSibling)
        fragments.each(function(node) { parent.insertBefore(node, nextSibling) });
      else
        fragments.each(function(node) { parent.appendChild(node) });
    }
    else element.outerHTML = content.stripScripts();

    content.evalScripts.bind(content).defer();
    return element;
  };
}

Element._returnOffset = function(l, t) {
  var result = [l, t];
  result.left = l;
  result.top = t;
  return result;
};

Element._getContentFromAnonymousElement = function(tagName, html) {
  var div = new Element('div'), t = Element._insertionTranslations.tags[tagName];
  if (t) {
    div.innerHTML = t[0] + html + t[1];
    t[2].times(function() { div = div.firstChild });
  } else div.innerHTML = html;
  return $A(div.childNodes);
};

Element._insertionTranslations = {
  before: function(element, node) {
    element.parentNode.insertBefore(node, element);
  },
  top: function(element, node) {
    element.insertBefore(node, element.firstChild);
  },
  bottom: function(element, node) {
    element.appendChild(node);
  },
  after: function(element, node) {
    element.parentNode.insertBefore(node, element.nextSibling);
  },
  tags: {
    TABLE:  ['<table>',                '</table>',                   1],
    TBODY:  ['<table><tbody>',         '</tbody></table>',           2],
    TR:     ['<table><tbody><tr>',     '</tr></tbody></table>',      3],
    TD:     ['<table><tbody><tr><td>', '</td></tr></tbody></table>', 4],
    SELECT: ['<select>',               '</select>',                  1]
  }
};

(function() {
  Object.extend(this.tags, {
    THEAD: this.tags.TBODY,
    TFOOT: this.tags.TBODY,
    TH:    this.tags.TD
  });
}).call(Element._insertionTranslations);

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

Element.Methods.ByTag = { };

Object.extend(Element, Element.Methods);

if (!Prototype.BrowserFeatures.ElementExtensions &&
    document.createElement('div')['__proto__']) {
  window.HTMLElement = { };
  window.HTMLElement.prototype = document.createElement('div')['__proto__'];
  Prototype.BrowserFeatures.ElementExtensions = true;
}

Element.extend = (function() {
  if (Prototype.BrowserFeatures.SpecificElementExtensions)
    return Prototype.K;

  var Methods = { }, ByTag = Element.Methods.ByTag;

  var extend = Object.extend(function(element) {
    if (!element || element._extendedByPrototype ||
        element.nodeType != 1 || element == window) return element;

    var methods = Object.clone(Methods),
      tagName = element.tagName.toUpperCase(), property, value;

    // extend methods for specific tags
    if (ByTag[tagName]) Object.extend(methods, ByTag[tagName]);

    for (property in methods) {
      value = methods[property];
      if (Object.isFunction(value) && !(property in element))
        element[property] = value.methodize();
    }

    element._extendedByPrototype = Prototype.emptyFunction;
    return element;

  }, {
    refresh: function() {
      // extend methods for all tags (Safari doesn't need this)
      if (!Prototype.BrowserFeatures.ElementExtensions) {
        Object.extend(Methods, Element.Methods);
        Object.extend(Methods, Element.Methods.Simulated);
      }
    }
  });

  extend.refresh();
  return extend;
})();

Element.hasAttribute = function(element, attribute) {
  if (element.hasAttribute) return element.hasAttribute(attribute);
  return Element.Methods.Simulated.hasAttribute(element, attribute);
};

Element.addMethods = function(methods) {
  var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;

  if (!methods) {
    Object.extend(Form, Form.Methods);
    Object.extend(Form.Element, Form.Element.Methods);
    Object.extend(Element.Methods.ByTag, {
      "FORM":     Object.clone(Form.Methods),
      "INPUT":    Object.clone(Form.Element.Methods),
      "SELECT":   Object.clone(Form.Element.Methods),
      "TEXTAREA": Object.clone(Form.Element.Methods)
    });
  }

  if (arguments.length == 2) {
    var tagName = methods;
    methods = arguments[1];
  }

  if (!tagName) Object.extend(Element.Methods, methods || { });
  else {
    if (Object.isArray(tagName)) tagName.each(extend);
    else extend(tagName);
  }

  function extend(tagName) {
    tagName = tagName.toUpperCase();
    if (!Element.Methods.ByTag[tagName])
      Element.Methods.ByTag[tagName] = { };
    Object.extend(Element.Methods.ByTag[tagName], methods);
  }

  function copy(methods, destination, onlyIfAbsent) {
    onlyIfAbsent = onlyIfAbsent || false;
    for (var property in methods) {
      var value = methods[property];
      if (!Object.isFunction(value)) continue;
      if (!onlyIfAbsent || !(property in destination))
        destination[property] = value.methodize();
    }
  }

  function findDOMClass(tagName) {
    var klass;
    var trans = {
      "OPTGROUP": "OptGroup", "TEXTAREA": "TextArea", "P": "Paragraph",
      "FIELDSET": "FieldSet", "UL": "UList", "OL": "OList", "DL": "DList",
      "DIR": "Directory", "H1": "Heading", "H2": "Heading", "H3": "Heading",
      "H4": "Heading", "H5": "Heading", "H6": "Heading", "Q": "Quote",
      "INS": "Mod", "DEL": "Mod", "A": "Anchor", "IMG": "Image", "CAPTION":
      "TableCaption", "COL": "TableCol", "COLGROUP": "TableCol", "THEAD":
      "TableSection", "TFOOT": "TableSection", "TBODY": "TableSection", "TR":
      "TableRow", "TH": "TableCell", "TD": "TableCell", "FRAMESET":
      "FrameSet", "IFRAME": "IFrame"
    };
    if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
    if (window[klass]) return window[klass];
    klass = 'HTML' + tagName + 'Element';
    if (window[klass]) return window[klass];
    klass = 'HTML' + tagName.capitalize() + 'Element';
    if (window[klass]) return window[klass];

    window[klass] = { };
    window[klass].prototype = document.createElement(tagName)['__proto__'];
    return window[klass];
  }

  if (F.ElementExtensions) {
    copy(Element.Methods, HTMLElement.prototype);
    copy(Element.Methods.Simulated, HTMLElement.prototype, true);
  }

  if (F.SpecificElementExtensions) {
    for (var tag in Element.Methods.ByTag) {
      var klass = findDOMClass(tag);
      if (Object.isUndefined(klass)) continue;
      copy(T[tag], klass.prototype);
    }
  }

  Object.extend(Element, Element.Methods);
  delete Element.ByTag;

  if (Element.extend.refresh) Element.extend.refresh();
  Element.cache = { };
};

document.viewport = {
  getDimensions: function() {
    var dimensions = { }, B = Prototype.Browser;
    $w('width height').each(function(d) {
      var D = d.capitalize();
      if (B.WebKit && !document.evaluate) {
        // Safari <3.0 needs self.innerWidth/Height
        dimensions[d] = self['inner' + D];
      } else if (B.Opera && parseFloat(window.opera.version()) < 9.5) {
        // Opera <9.5 needs document.body.clientWidth/Height
        dimensions[d] = document.body['client' + D]
      } else {
        dimensions[d] = document.documentElement['client' + D];
      }
    });
    return dimensions;
  },

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

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

  getScrollOffsets: function() {
    return Element._returnOffset(
      window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft,
      window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop);
  }
};
/* Portions of the Selector class are derived from Jack Slocum's DomQuery,
 * part of YUI-Ext version 0.40, distributed under the terms of an MIT-style
 * license.  Please see http://www.yui-ext.com/ for more information. */

var Selector = Class.create({
  initialize: function(expression) {
    this.expression = expression.strip();

    if (this.shouldUseSelectorsAPI()) {
      this.mode = 'selectorsAPI';
    } else if (this.shouldUseXPath()) {
      this.mode = 'xpath';
      this.compileXPathMatcher();
    } else {
      this.mode = "normal";
      this.compileMatcher();
    }

  },

  shouldUseXPath: function() {
    if (!Prototype.BrowserFeatures.XPath) return false;

    var e = this.expression;

    // Safari 3 chokes on :*-of-type and :empty
    if (Prototype.Browser.WebKit &&
     (e.include("-of-type") || e.include(":empty")))
      return false;

    // XPath can't do namespaced attributes, nor can it read
    // the "checked" property from DOM nodes
    if ((/(\[[\w-]*?:|:checked)/).test(e))
      return false;

    return true;
  },

  shouldUseSelectorsAPI: function() {
    if (!Prototype.BrowserFeatures.SelectorsAPI) return false;

    if (!Selector._div) Selector._div = new Element('div');

    // Make sure the browser treats the selector as valid. Test on an
    // isolated element to minimize cost of this check.
    try {
      Selector._div.querySelector(this.expression);
    } catch(e) {
      return false;
    }

    return true;
  },

  compileMatcher: function() {
    var e = this.expression, ps = Selector.patterns, h = Selector.handlers,
        c = Selector.criteria, le, p, m;

    if (Selector._cache[e]) {
      this.matcher = Selector._cache[e];
      return;
    }

    this.matcher = ["this.matcher = function(root) {",
                    "var r = root, h = Selector.handlers, c = false, n;"];

    while (e && le != e && (/\S/).test(e)) {
      le = e;
      for (var i in ps) {
        p = ps[i];
        if (m = e.match(p)) {
          this.matcher.push(Object.isFunction(c[i]) ? c[i](m) :
            new Template(c[i]).evaluate(m));
          e = e.replace(m[0], '');
          break;
        }
      }
    }

    this.matcher.push("return h.unique(n);\n}");
    eval(this.matcher.join('\n'));
    Selector._cache[this.expression] = this.matcher;
  },

  compileXPathMatcher: function() {
    var e = this.expression, ps = Selector.patterns,
        x = Selector.xpath, le, m;

    if (Selector._cache[e]) {
      this.xpath = Selector._cache[e]; return;
    }

    this.matcher = ['.//*'];
    while (e && le != e && (/\S/).test(e)) {
      le = e;
      for (var i in ps) {
        if (m = e.match(ps[i])) {
          this.matcher.push(Object.isFunction(x[i]) ? x[i](m) :
            new Template(x[i]).evaluate(m));
          e = e.replace(m[0], '');
          break;
        }
      }
    }

    this.xpath = this.matcher.join('');
    Selector._cache[this.expression] = this.xpath;
  },

  findElements: function(root) {
    root = root || document;
    var e = this.expression, results;

    switch (this.mode) {
      case 'selectorsAPI':
        // querySelectorAll queries document-wide, then filters to descendants
        // of the context element. That's not what we want.
        // Add an explicit context to the selector if necessary.
        if (root !== document) {
          var oldId = root.id, id = $(root).identify();
          e = "#" + id + " " + e;
        }

        results = $A(root.querySelectorAll(e)).map(Element.extend);
        root.id = oldId;

        return results;
      case 'xpath':
        return document._getElementsByXPath(this.xpath, root);
      default:
       return this.matcher(root);
    }
  },

  match: function(element) {
    this.tokens = [];

    var e = this.expression, ps = Selector.patterns, as = Selector.assertions;
    var le, p, m;

    while (e && le !== e && (/\S/).test(e)) {
      le = e;
      for (var i in ps) {
        p = ps[i];
        if (m = e.match(p)) {
          // use the Selector.assertions methods unless the selector
          // is too complex.
          if (as[i]) {
            this.tokens.push([i, Object.clone(m)]);
            e = e.replace(m[0], '');
          } else {
            // reluctantly do a document-wide search
            // and look for a match in the array
            return this.findElements(document).include(element);
          }
        }
      }
    }

    var match = true, name, matches;
    for (var i = 0, token; token = this.tokens[i]; i++) {
      name = token[0], matches = token[1];
      if (!Selector.assertions[name](element, matches)) {
        match = false; break;
      }
    }

    return match;
  },

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

  inspect: function() {
    return "#<Selector:" + this.expression.inspect() + ">";
  }
});

Object.extend(Selector, {
  _cache: { },

  xpath: {
    descendant:   "//*",
    child:        "/*",
    adjacent:     "/following-sibling::*[1]",
    laterSibling: '/following-sibling::*',
    tagName:      function(m) {
      if (m[1] == '*') return '';
      return "[local-name()='" + m[1].toLowerCase() +
             "' or local-name()='" + m[1].toUpperCase() + "']";
    },
    className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
    id:           "[@id='#{1}']",
    attrPresence: function(m) {
      m[1] = m[1].toLowerCase();
      return new Template("[@#{1}]").evaluate(m);
    },
    attr: function(m) {
      m[1] = m[1].toLowerCase();
      m[3] = m[5] || m[6];
      return new Template(Selector.xpath.operators[m[2]]).evaluate(m);
    },
    pseudo: function(m) {
      var h = Selector.xpath.pseudos[m[1]];
      if (!h) return '';
      if (Object.isFunction(h)) return h(m);
      return new Template(Selector.xpath.pseudos[m[1]]).evaluate(m);
    },
    operators: {
      '=':  "[@#{1}='#{3}']",
      '!=': "[@#{1}!='#{3}']",
      '^=': "[starts-with(@#{1}, '#{3}')]",
      '$=': "[substring(@#{1}, (string-length(@#{1}) - string-length('#{3}') + 1))='#{3}']",
      '*=': "[contains(@#{1}, '#{3}')]",
      '~=': "[contains(concat(' ', @#{1}, ' '), ' #{3} ')]",
      '|=': "[contains(concat('-', @#{1}, '-'), '-#{3}-')]"
    },
    pseudos: {
      'first-child': '[not(preceding-sibling::*)]',
      'last-child':  '[not(following-sibling::*)]',
      'only-child':  '[not(preceding-sibling::* or following-sibling::*)]',
      'empty':       "[count(*) = 0 and (count(text()) = 0)]",
      'checked':     "[@checked]",
      'disabled':    "[(@disabled) and (@type!='hidden')]",
      'enabled':     "[not(@disabled) and (@type!='hidden')]",
      'not': function(m) {
        var e = m[6], p = Selector.patterns,
            x = Selector.xpath, le, v;

        var exclusion = [];
        while (e && le != e && (/\S/).test(e)) {
          le = e;
          for (var i in p) {
            if (m = e.match(p[i])) {
              v = Object.isFunction(x[i]) ? x[i](m) : new Template(x[i]).evaluate(m);
              exclusion.push("(" + v.substring(1, v.length - 1) + ")");
              e = e.replace(m[0], '');
              break;
            }
          }
        }
        return "[not(" + exclusion.join(" and ") + ")]";
      },
      'nth-child':      function(m) {
        return Selector.xpath.pseudos.nth("(count(./preceding-sibling::*) + 1) ", m);
      },
      'nth-last-child': function(m) {
        return Selector.xpath.pseudos.nth("(count(./following-sibling::*) + 1) ", m);
      },
      'nth-of-type':    function(m) {
        return Selector.xpath.pseudos.nth("position() ", m);
      },
      'nth-last-of-type': function(m) {
        return Selector.xpath.pseudos.nth("(last() + 1 - position()) ", m);
      },
      'first-of-type':  function(m) {
        m[6] = "1"; return Selector.xpath.pseudos['nth-of-type'](m);
      },
      'last-of-type':   function(m) {
        m[6] = "1"; return Selector.xpath.pseudos['nth-last-of-type'](m);
      },
      'only-of-type':   function(m) {
        var p = Selector.xpath.pseudos; return p['first-of-type'](m) + p['last-of-type'](m);
      },
      nth: function(fragment, m) {
        var mm, formula = m[6], predicate;
        if (formula == 'even') formula = '2n+0';
        if (formula == 'odd')  formula = '2n+1';
        if (mm = formula.match(/^(\d+)$/)) // digit only
          return '[' + fragment + "= " + mm[1] + ']';
        if (mm = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
          if (mm[1] == "-") mm[1] = -1;
          var a = mm[1] ? Number(mm[1]) : 1;
          var b = mm[2] ? Number(mm[2]) : 0;
          predicate = "[((#{fragment} - #{b}) mod #{a} = 0) and " +
          "((#{fragment} - #{b}) div #{a} >= 0)]";
          return new Template(predicate).evaluate({
            fragment: fragment, a: a, b: b });
        }
      }
    }
  },

  criteria: {
    tagName:      'n = h.tagName(n, r, "#{1}", c);      c = false;',
    className:    'n = h.className(n, r, "#{1}", c);    c = false;',
    id:           'n = h.id(n, r, "#{1}", c);           c = false;',
    attrPresence: 'n = h.attrPresence(n, r, "#{1}", c); c = false;',
    attr: function(m) {
      m[3] = (m[5] || m[6]);
      return new Template('n = h.attr(n, r, "#{1}", "#{3}", "#{2}", c); c = false;').evaluate(m);
    },
    pseudo: function(m) {
      if (m[6]) m[6] = m[6].replace(/"/g, '\\"');
      return new Template('n = h.pseudo(n, "#{1}", "#{6}", r, c); c = false;').evaluate(m);
    },
    descendant:   'c = "descendant";',
    child:        'c = "child";',
    adjacent:     'c = "adjacent";',
    laterSibling: 'c = "laterSibling";'
  },

  patterns: {
    // combinators must be listed first
    // (and descendant needs to be last combinator)
    laterSibling: /^\s*~\s*/,
    child:        /^\s*>\s*/,
    adjacent:     /^\s*\+\s*/,
    descendant:   /^\s/,

    // selectors follow
    tagName:      /^\s*(\*|[\w\-]+)(\b|$)?/,
    id:           /^#([\w\-\*]+)(\b|$)/,
    className:    /^\.([\w\-\*]+)(\b|$)/,
    pseudo:
/^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|(?=\s|[:+~>]))/,
    attrPresence: /^\[((?:[\w]+:)?[\w]+)\]/,
    attr:         /\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\4]*?)\4|([^'"][^\]]*?)))?\]/
  },

  // for Selector.match and Element#match
  assertions: {
    tagName: function(element, matches) {
      return matches[1].toUpperCase() == element.tagName.toUpperCase();
    },

    className: function(element, matches) {
      return Element.hasClassName(element, matches[1]);
    },

    id: function(element, matches) {
      return element.id === matches[1];
    },

    attrPresence: function(element, matches) {
      return Element.hasAttribute(element, matches[1]);
    },

    attr: function(element, matches) {
      var nodeValue = Element.readAttribute(element, matches[1]);
      return nodeValue && Selector.operators[matches[2]](nodeValue, matches[5] || matches[6]);
    }
  },

  handlers: {
    // UTILITY FUNCTIONS
    // joins two collections
    concat: function(a, b) {
      for (var i = 0, node; node = b[i]; i++)
        a.push(node);
      return a;
    },

    // marks an array of nodes for counting
    mark: function(nodes) {
      var _true = Prototype.emptyFunction;
      for (var i = 0, node; node = nodes[i]; i++)
        node._countedByPrototype = _true;
      return nodes;
    },

    unmark: function(nodes) {
      for (var i = 0, node; node = nodes[i]; i++)
        node._countedByPrototype = undefined;
      return nodes;
    },

    // mark each child node with its position (for nth calls)
    // "ofType" flag indicates whether we're indexing for nth-of-type
    // rather than nth-child
    index: function(parentNode, reverse, ofType) {
      parentNode._countedByPrototype = Prototype.emptyFunction;
      if (reverse) {
        for (var nodes = parentNode.childNodes, i = nodes.length - 1, j = 1; i >= 0; i--) {
          var node = nodes[i];
          if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
        }
      } else {
        for (var i = 0, j = 1, nodes = parentNode.childNodes; node = nodes[i]; i++)
          if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
      }
    },

    // filters out duplicates and extends all nodes
    unique: function(nodes) {
      if (nodes.length == 0) return nodes;
      var results = [], n;
      for (var i = 0, l = nodes.length; i < l; i++)
        if (!(n = nodes[i])._countedByPrototype) {
          n._countedByPrototype = Prototype.emptyFunction;
          results.push(Element.extend(n));
        }
      return Selector.handlers.unmark(results);
    },

    // COMBINATOR FUNCTIONS
    descendant: function(nodes) {
      var h = Selector.handlers;
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        h.concat(results, node.getElementsByTagName('*'));
      return results;
    },

    child: function(nodes) {
      var h = Selector.handlers;
      for (var i = 0, results = [], node; node = nodes[i]; i++) {
        for (var j = 0, child; child = node.childNodes[j]; j++)
          if (child.nodeType == 1 && child.tagName != '!') results.push(child);
      }
      return results;
    },

    adjacent: function(nodes) {
      for (var i = 0, results = [], node; node = nodes[i]; i++) {
        var next = this.nextElementSibling(node);
        if (next) results.push(next);
      }
      return results;
    },

    laterSibling: function(nodes) {
      var h = Selector.handlers;
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        h.concat(results, Element.nextSiblings(node));
      return results;
    },

    nextElementSibling: function(node) {
      while (node = node.nextSibling)
        if (node.nodeType == 1) return node;
      return null;
    },

    previousElementSibling: function(node) {
      while (node = node.previousSibling)
        if (node.nodeType == 1) return node;
      return null;
    },

    // TOKEN FUNCTIONS
    tagName: function(nodes, root, tagName, combinator) {
      var uTagName = tagName.toUpperCase();
      var results = [], h = Selector.handlers;
      if (nodes) {
        if (combinator) {
          // fastlane for ordinary descendant combinators
          if (combinator == "descendant") {
            for (var i = 0, node; node = nodes[i]; i++)
              h.concat(results, node.getElementsByTagName(tagName));
            return results;
          } else nodes = this[combinator](nodes);
          if (tagName == "*") return nodes;
        }
        for (var i = 0, node; node = nodes[i]; i++)
          if (node.tagName.toUpperCase() === uTagName) results.push(node);
        return results;
      } else return root.getElementsByTagName(tagName);
    },

    id: function(nodes, root, id, combinator) {
      var targetNode = $(id), h = Selector.handlers;
      if (!targetNode) return [];
      if (!nodes && root == document) return [targetNode];
      if (nodes) {
        if (combinator) {
          if (combinator == 'child') {
            for (var i = 0, node; node = nodes[i]; i++)
              if (targetNode.parentNode == node) return [targetNode];
          } else if (combinator == 'descendant') {
            for (var i = 0, node; node = nodes[i]; i++)
              if (Element.descendantOf(targetNode, node)) return [targetNode];
          } else if (combinator == 'adjacent') {
            for (var i = 0, node; node = nodes[i]; i++)
              if (Selector.handlers.previousElementSibling(targetNode) == node)
                return [targetNode];
          } else nodes = h[combinator](nodes);
        }
        for (var i = 0, node; node = nodes[i]; i++)
          if (node == targetNode) return [targetNode];
        return [];
      }
      return (targetNode && Element.descendantOf(targetNode, root)) ? [targetNode] : [];
    },

    className: function(nodes, root, className, combinator) {
      if (nodes && combinator) nodes = this[combinator](nodes);
      return Selector.handlers.byClassName(nodes, root, className);
    },

    byClassName: function(nodes, root, className) {
      if (!nodes) nodes = Selector.handlers.descendant([root]);
      var needle = ' ' + className + ' ';
      for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
        nodeClassName = node.className;
        if (nodeClassName.length == 0) continue;
        if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
          results.push(node);
      }
      return results;
    },

    attrPresence: function(nodes, root, attr, combinator) {
      if (!nodes) nodes = root.getElementsByTagName("*");
      if (nodes && combinator) nodes = this[combinator](nodes);
      var results = [];
      for (var i = 0, node; node = nodes[i]; i++)
        if (Element.hasAttribute(node, attr)) results.push(node);
      return results;
    },

    attr: function(nodes, root, attr, value, operator, combinator) {
      if (!nodes) nodes = root.getElementsByTagName("*");
      if (nodes && combinator) nodes = this[combinator](nodes);
      var handler = Selector.operators[operator], results = [];
      for (var i = 0, node; node = nodes[i]; i++) {
        var nodeValue = Element.readAttribute(node, attr);
        if (nodeValue === null) continue;
        if (handler(nodeValue, value)) results.push(node);
      }
      return results;
    },

    pseudo: function(nodes, name, value, root, combinator) {
      if (nodes && combinator) nodes = this[combinator](nodes);
      if (!nodes) nodes = root.getElementsByTagName("*");
      return Selector.pseudos[name](nodes, value, root);
    }
  },

  pseudos: {
    'first-child': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++) {
        if (Selector.handlers.previousElementSibling(node)) continue;
          results.push(node);
      }
      return results;
    },
    'last-child': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++) {
        if (Selector.handlers.nextElementSibling(node)) continue;
          results.push(node);
      }
      return results;
    },
    'only-child': function(nodes, value, root) {
      var h = Selector.handlers;
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (!h.previousElementSibling(node) && !h.nextElementSibling(node))
          results.push(node);
      return results;
    },
    'nth-child':        function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, formula, root);
    },
    'nth-last-child':   function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, formula, root, true);
    },
    'nth-of-type':      function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, formula, root, false, true);
    },
    'nth-last-of-type': function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, formula, root, true, true);
    },
    'first-of-type':    function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, "1", root, false, true);
    },
    'last-of-type':     function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, "1", root, true, true);
    },
    'only-of-type':     function(nodes, formula, root) {
      var p = Selector.pseudos;
      return p['last-of-type'](p['first-of-type'](nodes, formula, root), formula, root);
    },

    // handles the an+b logic
    getIndices: function(a, b, total) {
      if (a == 0) return b > 0 ? [b] : [];
      return $R(1, total).inject([], function(memo, i) {
        if (0 == (i - b) % a && (i - b) / a >= 0) memo.push(i);
        return memo;
      });
    },

    // handles nth(-last)-child, nth(-last)-of-type, and (first|last)-of-type
    nth: function(nodes, formula, root, reverse, ofType) {
      if (nodes.length == 0) return [];
      if (formula == 'even') formula = '2n+0';
      if (formula == 'odd')  formula = '2n+1';
      var h = Selector.handlers, results = [], indexed = [], m;
      h.mark(nodes);
      for (var i = 0, node; node = nodes[i]; i++) {
        if (!node.parentNode._countedByPrototype) {
          h.index(node.parentNode, reverse, ofType);
          indexed.push(node.parentNode);
        }
      }
      if (formula.match(/^\d+$/)) { // just a number
        formula = Number(formula);
        for (var i = 0, node; node = nodes[i]; i++)
          if (node.nodeIndex == formula) results.push(node);
      } else if (m = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
        if (m[1] == "-") m[1] = -1;
        var a = m[1] ? Number(m[1]) : 1;
        var b = m[2] ? Number(m[2]) : 0;
        var indices = Selector.pseudos.getIndices(a, b, nodes.length);
        for (var i = 0, node, l = indices.length; node = nodes[i]; i++) {
          for (var j = 0; j < l; j++)
            if (node.nodeIndex == indices[j]) results.push(node);
        }
      }
      h.unmark(nodes);
      h.unmark(indexed);
      return results;
    },

    'empty': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++) {
        // IE treats comments as element nodes
        if (node.tagName == '!' || node.firstChild) continue;
        results.push(node);
      }
      return results;
    },

    'not': function(nodes, selector, root) {
      var h = Selector.handlers, selectorType, m;
      var exclusions = new Selector(selector).findElements(root);
      h.mark(exclusions);
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (!node._countedByPrototype) results.push(node);
      h.unmark(exclusions);
      return results;
    },

    'enabled': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (!node.disabled && (!node.type || node.type !== 'hidden'))
          results.push(node);
      return results;
    },

    'disabled': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (node.disabled) results.push(node);
      return results;
    },

    'checked': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (node.checked) results.push(node);
      return results;
    }
  },

  operators: {
    '=':  function(nv, v) { return nv == v; },
    '!=': function(nv, v) { return nv != v; },
    '^=': function(nv, v) { return nv == v || nv && nv.startsWith(v); },
    '$=': function(nv, v) { return nv == v || nv && nv.endsWith(v); },
    '*=': function(nv, v) { return nv == v || nv && nv.include(v); },
    '$=': function(nv, v) { return nv.endsWith(v); },
    '*=': function(nv, v) { return nv.include(v); },
    '~=': function(nv, v) { return (' ' + nv + ' ').include(' ' + v + ' '); },
    '|=': function(nv, v) { return ('-' + (nv || "").toUpperCase() +
     '-').include('-' + (v || "").toUpperCase() + '-'); }
  },

  split: function(expression) {
    var expressions = [];
    expression.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {
      expressions.push(m[1].strip());
    });
    return expressions;
  },

  matchElements: function(elements, expression) {
    var matches = $$(expression), h = Selector.handlers;
    h.mark(matches);
    for (var i = 0, results = [], element; element = elements[i]; i++)
      if (element._countedByPrototype) results.push(element);
    h.unmark(matches);
    return results;
  },

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

  findChildElements: function(element, expressions) {
    expressions = Selector.split(expressions.join(','));
    var results = [], h = Selector.handlers;
    for (var i = 0, l = expressions.length, selector; i < l; i++) {
      selector = new Selector(expressions[i].strip());
      h.concat(results, selector.findElements(element));
    }
    return (l > 1) ? h.unique(results) : results;
  }
});

if (Prototype.Browser.IE) {
  Object.extend(Selector.handlers, {
    // IE returns comment nodes on getElementsByTagName("*").
    // Filter them out.
    concat: function(a, b) {
      for (var i = 0, node; node = b[i]; i++)
        if (node.tagName !== "!") a.push(node);
      return a;
    },

    // IE improperly serializes _countedByPrototype in (inner|outer)HTML.
    unmark: function(nodes) {
      for (var i = 0, node; node = nodes[i]; i++)
        node.removeAttribute('_countedByPrototype');
      return nodes;
    }
  });
}

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

  serializeElements: function(elements, options) {
    if (typeof options != 'object') options = { hash: !!options };
    else if (Object.isUndefined(options.hash)) options.hash = true;
    var key, value, submitted = false, submit = options.submit;

    var data = elements.inject({ }, function(result, element) {
      if (!element.disabled && element.name) {
        key = element.name; value = $(element).getValue();
        if (value != null && element.type != 'file' && (element.type != 'submit' || (!submitted &&
            submit !== false && (!submit || key == submit) && (submitted = true)))) {
          if (key in result) {
            // a key is already present; construct an array of values
            if (!Object.isArray(result[key])) result[key] = [result[key]];
            result[key].push(value);
          }
          else result[key] = value;
        }
      }
      return result;
    });

    return options.hash ? data : Object.toQueryString(data);
  }
};

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

  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(form).invoke('disable');
    return form;
  },

  enable: function(form) {
    form = $(form);
    Form.getElements(form).invoke('enable');
    return form;
  },

  findFirstElement: function(form) {
    var elements = $(form).getElements().findAll(function(element) {
      return 'hidden' != element.type && !element.disabled;
    });
    var firstByIndex = elements.findAll(function(element) {
      return element.hasAttribute('tabIndex') && element.tabIndex >= 0;
    }).sortBy(function(element) { return element.tabIndex }).first();

    return firstByIndex ? firstByIndex : elements.find(function(element) {
      return ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
    });
  },

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

  request: function(form, options) {
    form = $(form), options = Object.clone(options || { });

    var params = options.parameters, action = form.readAttribute('action') || '';
    if (action.blank()) action = window.location.href;
    options.parameters = form.serialize(true);

    if (params) {
      if (Object.isString(params)) params = params.toQueryParams();
      Object.extend(options.parameters, params);
    }

    if (form.hasAttribute('method') && !options.method)
      options.method = form.method;

    return new Ajax.Request(action, options);
  }
};

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

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 Object.toQueryString(pair);
      }
    }
    return '';
  },

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

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

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

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

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

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

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

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

var Field = Form.Element;
var $F = Form.Element.Methods.getValue;

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

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

  inputSelector: function(element, value) {
    if (Object.isUndefined(value)) return element.checked ? element.value : null;
    else element.checked = !!value;
  },

  textarea: function(element, value) {
    if (Object.isUndefined(value)) return element.value;
    else element.value = value;
  },

  select: function(element, value) {
    if (Object.isUndefined(value))
      return this[element.type == 'select-one' ?
        'selectOne' : 'selectMany'](element);
    else {
      var opt, currentValue, single = !Object.isArray(value);
      for (var i = 0, length = element.length; i < length; i++) {
        opt = element.options[i];
        currentValue = this.optionValue(opt);
        if (single) {
          if (currentValue == value) {
            opt.selected = true;
            return;
          }
        }
        else opt.selected = value.include(currentValue);
      }
    }
  },

  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 = Class.create(PeriodicalExecuter, {
  initialize: function($super, element, frequency, callback) {
    $super(callback, frequency);
    this.element   = $(element);
    this.lastValue = this.getValue();
  },

  execute: function() {
    var value = this.getValue();
    if (Object.isString(this.lastValue) && Object.isString(value) ?
        this.lastValue != value : String(this.lastValue) != String(value)) {
      this.callback(this.element, value);
      this.lastValue = value;
    }
  }
});

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

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

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

Abstract.EventObserver = Class.create({
  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, 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(Abstract.EventObserver, {
  getValue: function() {
    return Form.Element.getValue(this.element);
  }
});

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

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,
  KEY_INSERT:   45,

  cache: { },

  relatedTarget: function(event) {
    var element;
    switch(event.type) {
      case 'mouseover': element = event.fromElement; break;
      case 'mouseout':  element = event.toElement;   break;
      default: return null;
    }
    return Element.extend(element);
  }
});

Event.Methods = (function() {
  var isButton;

  if (Prototype.Browser.IE) {
    var buttonMap = { 0: 1, 1: 4, 2: 2 };
    isButton = function(event, code) {
      return event.button == buttonMap[code];
    };

  } else if (Prototype.Browser.WebKit) {
    isButton = function(event, code) {
      switch (code) {
        case 0: return event.which == 1 && !event.metaKey;
        case 1: return event.which == 1 && event.metaKey;
        default: return false;
      }
    };

  } else {
    isButton = function(event, code) {
      return event.which ? (event.which === code + 1) : (event.button === code);
    };
  }

  return {
    isLeftClick:   function(event) { return isButton(event, 0) },
    isMiddleClick: function(event) { return isButton(event, 1) },
    isRightClick:  function(event) { return isButton(event, 2) },

    element: function(event) {
      event = Event.extend(event);

      var node          = event.target,
          type          = event.type,
          currentTarget = event.currentTarget;

      if (currentTarget && currentTarget.tagName) {
        // Firefox screws up the "click" event when moving between radio buttons
        // via arrow keys. It also screws up the "load" and "error" events on images,
        // reporting the document as the target instead of the original image.
        if (type === 'load' || type === 'error' ||
          (type === 'click' && currentTarget.tagName.toLowerCase() === 'input'
            && currentTarget.type === 'radio'))
              node = currentTarget;
      }
      if (node.nodeType == Node.TEXT_NODE) node = node.parentNode;
      return Element.extend(node);
    },

    findElement: function(event, expression) {
      var element = Event.element(event);
      if (!expression) return element;
      var elements = [element].concat(element.ancestors());
      return Selector.findElement(elements, expression, 0);
    },

    pointer: function(event) {
      var docElement = document.documentElement,
      body = document.body || { scrollLeft: 0, scrollTop: 0 };
      return {
        x: event.pageX || (event.clientX +
          (docElement.scrollLeft || body.scrollLeft) -
          (docElement.clientLeft || 0)),
        y: event.pageY || (event.clientY +
          (docElement.scrollTop || body.scrollTop) -
          (docElement.clientTop || 0))
      };
    },

    pointerX: function(event) { return Event.pointer(event).x },
    pointerY: function(event) { return Event.pointer(event).y },

    stop: function(event) {
      Event.extend(event);
      event.preventDefault();
      event.stopPropagation();
      event.stopped = true;
    }
  };
})();

Event.extend = (function() {
  var methods = Object.keys(Event.Methods).inject({ }, function(m, name) {
    m[name] = Event.Methods[name].methodize();
    return m;
  });

  if (Prototype.Browser.IE) {
    Object.extend(methods, {
      stopPropagation: function() { this.cancelBubble = true },
      preventDefault:  function() { this.returnValue = false },
      inspect: function() { return "[object Event]" }
    });

    return function(event) {
      if (!event) return false;
      if (event._extendedByPrototype) return event;

      event._extendedByPrototype = Prototype.emptyFunction;
      var pointer = Event.pointer(event);
      Object.extend(event, {
        target: event.srcElement,
        relatedTarget: Event.relatedTarget(event),
        pageX:  pointer.x,
        pageY:  pointer.y
      });
      return Object.extend(event, methods);
    };

  } else {
    Event.prototype = Event.prototype || document.createEvent("HTMLEvents")['__proto__'];
    Object.extend(Event.prototype, methods);
    return Prototype.K;
  }
})();

Object.extend(Event, (function() {
  var cache = Event.cache;

  function getEventID(element) {
    if (element._prototypeEventID) return element._prototypeEventID[0];
    arguments.callee.id = arguments.callee.id || 1;
    return element._prototypeEventID = [++arguments.callee.id];
  }

  function getDOMEventName(eventName) {
    if (eventName && eventName.include(':')) return "dataavailable";
    return eventName;
  }

  function getCacheForID(id) {
    return cache[id] = cache[id] || { };
  }

  function getWrappersForEventName(id, eventName) {
    var c = getCacheForID(id);
    return c[eventName] = c[eventName] || [];
  }

  function createWrapper(element, eventName, handler) {
    var id = getEventID(element);
    var c = getWrappersForEventName(id, eventName);
    if (c.pluck("handler").include(handler)) return false;

    var wrapper = function(event) {
      if (!Event || !Event.extend ||
        (event.eventName && event.eventName != eventName))
          return false;

      Event.extend(event);
      handler.call(element, event);
    };

    wrapper.handler = handler;
    c.push(wrapper);
    return wrapper;
  }

  function findWrapper(id, eventName, handler) {
    var c = getWrappersForEventName(id, eventName);
    return c.find(function(wrapper) { return wrapper.handler == handler });
  }

  function destroyWrapper(id, eventName, handler) {
    var c = getCacheForID(id);
    if (!c[eventName]) return false;
    c[eventName] = c[eventName].without(findWrapper(id, eventName, handler));
  }

  function destroyCache() {
    for (var id in cache)
      for (var eventName in cache[id])
        cache[id][eventName] = null;
  }


  // Internet Explorer needs to remove event handlers on page unload
  // in order to avoid memory leaks.
  if (window.attachEvent) {
    window.attachEvent("onunload", destroyCache);
  }

  // Safari has a dummy event handler on page unload so that it won't
  // use its bfcache. Safari <= 3.1 has an issue with restoring the "document"
  // object when page is returned to via the back button using its bfcache.
  if (Prototype.Browser.WebKit) {
    window.addEventListener('unload', Prototype.emptyFunction, false);
  }

  return {
    observe: function(element, eventName, handler) {
      element = $(element);
      var name = getDOMEventName(eventName);

      var wrapper = createWrapper(element, eventName, handler);
      if (!wrapper) return element;

      if (element.addEventListener) {
        element.addEventListener(name, wrapper, false);
      } else {
        element.attachEvent("on" + name, wrapper);
      }

      return element;
    },

    stopObserving: function(element, eventName, handler) {
      element = $(element);
      var id = getEventID(element), name = getDOMEventName(eventName);

      if (!handler && eventName) {
        getWrappersForEventName(id, eventName).each(function(wrapper) {
          element.stopObserving(eventName, wrapper.handler);
        });
        return element;

      } else if (!eventName) {
        Object.keys(getCacheForID(id)).each(function(eventName) {
          element.stopObserving(eventName);
        });
        return element;
      }

      var wrapper = findWrapper(id, eventName, handler);
      if (!wrapper) return element;

      if (element.removeEventListener) {
        element.removeEventListener(name, wrapper, false);
      } else {
        element.detachEvent("on" + name, wrapper);
      }

      destroyWrapper(id, eventName, handler);

      return element;
    },

    fire: function(element, eventName, memo) {
      element = $(element);
      if (element == document && document.createEvent && !element.dispatchEvent)
        element = document.documentElement;

      var event;
      if (document.createEvent) {
        event = document.createEvent("HTMLEvents");
        event.initEvent("dataavailable", true, true);
      } else {
        event = document.createEventObject();
        event.eventType = "ondataavailable";
      }

      event.eventName = eventName;
      event.memo = memo || { };

      if (document.createEvent) {
        element.dispatchEvent(event);
      } else {
        element.fireEvent(event.eventType, event);
      }

      return Event.extend(event);
    }
  };
})());

Object.extend(Event, Event.Methods);

Element.addMethods({
  fire:          Event.fire,
  observe:       Event.observe,
  stopObserving: Event.stopObserving
});

Object.extend(document, {
  fire:          Element.Methods.fire.methodize(),
  observe:       Element.Methods.observe.methodize(),
  stopObserving: Element.Methods.stopObserving.methodize(),
  loaded:        false
});

(function() {
  /* Support for the DOMContentLoaded event is based on work by Dan Webb,
     Matthias Miller, Dean Edwards and John Resig. */

  var timer;

  function fireContentLoadedEvent() {
    if (document.loaded) return;
    if (timer) window.clearInterval(timer);
    document.fire("dom:loaded");
    document.loaded = true;
  }

  if (document.addEventListener) {
    if (Prototype.Browser.WebKit) {
      timer = window.setInterval(function() {
        if (/loaded|complete/.test(document.readyState))
          fireContentLoadedEvent();
      }, 0);

      Event.observe(window, "load", fireContentLoadedEvent);

    } else {
      document.addEventListener("DOMContentLoaded",
        fireContentLoadedEvent, false);
    }

  } else {
    document.write("<script id=__onDOMContentLoaded defer src=//:><\/script>");
    $("__onDOMContentLoaded").onreadystatechange = function() {
      if (this.readyState == "complete") {
        this.onreadystatechange = null;
        fireContentLoadedEvent();
      }
    };
  }
})();
/*------------------------------- DEPRECATED -------------------------------*/

Hash.toQueryString = Object.toQueryString;

var Toggle = { display: Element.toggle };

Element.Methods.childOf = Element.Methods.descendantOf;

var Insertion = {
  Before: function(element, content) {
    return Element.insert(element, {before:content});
  },

  Top: function(element, content) {
    return Element.insert(element, {top:content});
  },

  Bottom: function(element, content) {
    return Element.insert(element, {bottom:content});
  },

  After: function(element, content) {
    return Element.insert(element, {after:content});
  }
};

var $continue = new Error('"throw $continue" is deprecated, use "return" instead');

// This should be moved to script.aculo.us; notice the deprecated methods
// further below, that map to the newer Element methods.
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;
  },

  // 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 = Element.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 = Element.cumulativeScrollOffset(element);

    this.xcomp = x + offsetcache[0] - this.deltaX;
    this.ycomp = y + offsetcache[1] - this.deltaY;
    this.offset = Element.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;
  },

  // Deprecation layer -- use newer Element methods now (1.5.2).

  cumulativeOffset: Element.Methods.cumulativeOffset,

  positionedOffset: Element.Methods.positionedOffset,

  absolutize: function(element) {
    Position.prepare();
    return Element.absolutize(element);
  },

  relativize: function(element) {
    Position.prepare();
    return Element.relativize(element);
  },

  realOffset: Element.Methods.cumulativeScrollOffset,

  offsetParent: Element.Methods.getOffsetParent,

  page: Element.Methods.viewportOffset,

  clone: function(source, target, options) {
    options = options || { };
    return Element.clonePosition(target, source, options);
  }
};

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

if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
  function iter(name) {
    return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
  }

  instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
  function(element, className) {
    className = className.toString().strip();
    var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
    return cond ? document._getElementsByXPath('.//*' + cond, element) : [];
  } : function(element, className) {
    className = className.toString().strip();
    var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
    if (!classNames && !className) return elements;

    var nodes = $(element).getElementsByTagName('*');
    className = ' ' + className + ' ';

    for (var i = 0, child, cn; child = nodes[i]; i++) {
      if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
          (classNames && classNames.all(function(name) {
            return !name.toString().blank() && cn.include(' ' + name + ' ');
          }))))
        elements.push(Element.extend(child));
    }
    return elements;
  };

  return function(className, parentElement) {
    return $(parentElement || document.body).getElementsByClassName(className);
  };
}(Element.Methods);

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

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

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

Element.addMethods();// script.aculo.us builder.js v1.8.2, Tue Nov 18 18:30:58 +0100 2008

// Copyright (c) 2005-2008 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) ||
        arguments[1].tagName) {
          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().gsub(/"/,'&quot;') + '"');
    return attrs.join(" ");
  },
  _children: function(element, children) {
    if(children.tagName) {
      element.appendChild(children);
      return;
    }
    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.8.2, Tue Nov 18 18:30:58 +0100 2008

// Copyright (c) 2005-2008 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 (Prototype.Browser.WebKit) window.scrollBy(0,0);
  return element;
};

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

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

var Effect = {
  _elementDoesNotExistError: {
    name: 'ElementDoesNotExistError',
    message: 'The specified DOM element does not exist, but is required for this effect to operate'
  },
  Transitions: {
    linear: Prototype.K,
    sinoidal: function(pos) {
      return (-Math.cos(pos*Math.PI)/2) + .5;
    },
    reverse: function(pos) {
      return 1-pos;
    },
    flicker: function(pos) {
      var pos = ((-Math.cos(pos*Math.PI)/4) + .75) + Math.random()/4;
      return pos > 1 ? 1 : pos;
    },
    wobble: function(pos) {
      return (-Math.cos(pos*Math.PI*(9*pos))/2) + .5;
    },
    pulse: function(pos, pulses) {
      return (-Math.cos((pos*((pulses||5)-.5)*2)*Math.PI)/2) + .5;
    },
    spring: function(pos) {
      return 1 - (Math.cos(pos * 4.5 * Math.PI) * Math.exp(-pos * 6));
    },
    none: function(pos) {
      return 0;
    },
    full: function(pos) {
      return 1;
    }
  },
  DefaultOptions: {
    duration:   1.0,   // seconds
    fps:        100,   // 100= assume 66fps max.
    sync:       false, // true for combining
    from:       0.0,
    to:         1.0,
    delay:      0.0,
    queue:      'parallel'
  },
  tagifyText: function(element) {
    var tagifyStyle = 'position:relative';
    if (Prototype.Browser.IE) tagifyStyle += ';zoom:1';

    element = $(element);
    $A(element.childNodes).each( function(child) {
      if (child.nodeType==3) {
        child.nodeValue.toArray().each( function(character) {
          element.insertBefore(
            new Element('span', {style: tagifyStyle}).update(
              character == ' ' ? String.fromCharCode(160) : character),
              child);
        });
        Element.remove(child);
      }
    });
  },
  multiple: function(element, effect) {
    var elements;
    if (((typeof element == 'object') ||
        Object.isFunction(element)) &&
       (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);
  }
};

Effect.DefaultOptions.transition = Effect.Transitions.sinoidal;

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

Effect.ScopedQueue = Class.create(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 = Object.isString(effect.options.queue) ?
      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++)
      this.effects[i] && this.effects[i].loop(timePos);
  }
});

Effect.Queues = {
  instances: $H(),
  get: function(queueName) {
    if (!Object.isString(queueName)) return queueName;

    return this.instances.get(queueName) ||
      this.instances.set(queueName, new Effect.ScopedQueue());
  }
};
Effect.Queue = Effect.Queues.get('global');

Effect.Base = Class.create({
  position: null,
  start: function(options) {
    function codeForEvent(options,eventName){
      return (
        (options[eventName+'Internal'] ? 'this.options.'+eventName+'Internal(this);' : '') +
        (options[eventName] ? 'this.options.'+eventName+'(this);' : '')
      );
    }
    if (options && options.transition === false) options.transition = Effect.Transitions.linear;
    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.fromToDelta  = this.options.to-this.options.from;
    this.totalTime    = this.finishOn-this.startOn;
    this.totalFrames  = this.options.fps*this.options.duration;

    this.render = (function() {
      function dispatch(effect, eventName) {
        if (effect.options[eventName + 'Internal'])
          effect.options[eventName + 'Internal'](effect);
        if (effect.options[eventName])
          effect.options[eventName](effect);
      }

      return function(pos) {
        if (this.state === "idle") {
          this.state = "running";
          dispatch(this, 'beforeSetup');
          if (this.setup) this.setup();
          dispatch(this, 'afterSetup');
        }
        if (this.state === "running") {
          pos = (this.options.transition(pos) * this.fromToDelta) + this.options.from;
          this.position = pos;
          dispatch(this, 'beforeUpdate');
          if (this.update) this.update(pos);
          dispatch(this, 'afterUpdate');
        }
      };
    })();

    this.event('beforeStart');
    if (!this.options.sync)
      Effect.Queues.get(Object.isString(this.options.queue) ?
        '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.totalTime,
          frame = (pos * this.totalFrames).round();
      if (frame > this.currentFrame) {
        this.render(pos);
        this.currentFrame = frame;
      }
    }
  },
  cancel: function() {
    if (!this.options.sync)
      Effect.Queues.get(Object.isString(this.options.queue) ?
        '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 (!Object.isFunction(this[property])) data.set(property, this[property]);
    return '#<Effect:' + data.inspect() + ',options:' + $H(this.options).inspect() + '>';
  }
});

Effect.Parallel = Class.create(Effect.Base, {
  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.Tween = Class.create(Effect.Base, {
  initialize: function(object, from, to) {
    object = Object.isString(object) ? $(object) : object;
    var args = $A(arguments), method = args.last(),
      options = args.length == 5 ? args[3] : null;
    this.method = Object.isFunction(method) ? method.bind(object) :
      Object.isFunction(object[method]) ? object[method].bind(object) :
      function(value) { object[method] = value };
    this.start(Object.extend({ from: from, to: to }, options || { }));
  },
  update: function(position) {
    this.method(position);
  }
});

Effect.Event = Class.create(Effect.Base, {
  initialize: function() {
    this.start(Object.extend({ duration: 0 }, arguments[0] || { }));
  },
  update: Prototype.emptyFunction
});

Effect.Opacity = Class.create(Effect.Base, {
  initialize: function(element) {
    this.element = $(element);
    if (!this.element) throw(Effect._elementDoesNotExistError);
    // make this work on IE on elements without 'layout'
    if (Prototype.Browser.IE && (!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(Effect.Base, {
  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() {
    this.element.makePositioned();
    this.originalLeft = parseFloat(this.element.getStyle('left') || '0');
    this.originalTop  = parseFloat(this.element.getStyle('top')  || '0');
    if (this.options.mode == 'absolute') {
      this.options.x = this.options.x - this.originalLeft;
      this.options.y = this.options.y - this.originalTop;
    }
  },
  update: function(position) {
    this.element.setStyle({
      left: (this.options.x  * position + this.originalLeft).round() + 'px',
      top:  (this.options.y  * position + this.originalTop).round()  + '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(Effect.Base, {
  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 = width.round() + 'px';
    if (this.options.scaleY) d.height = height.round() + '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(Effect.Base, {
  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+((this._base[i]+(this._delta[i]*position)).round().toColorPart()); }.bind(this)) });
  },
  finish: function() {
    this.element.setStyle(Object.extend(this.oldStyle, {
      backgroundColor: this.options.restorecolor
    }));
  }
});

Effect.ScrollTo = function(element) {
  var options = arguments[1] || { },
  scrollOffsets = document.viewport.getScrollOffsets(),
  elementOffsets = $(element).cumulativeOffset();

  if (options.offset) elementOffsets[1] += options.offset;

  return new Effect.Tween(null,
    scrollOffsets.top,
    elementOffsets[1],
    options,
    function(p){ scrollTo(scrollOffsets.left, p.round()); }
  );
};

/* ------------- 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 options = Object.extend({
    distance: 20,
    duration: 0.5
  }, arguments[1] || {});
  var distance = parseFloat(options.distance);
  var split = parseFloat(options.duration) / 10.0;
  var oldStyle = {
    top: element.getStyle('top'),
    left: element.getStyle('left') };
    return new Effect.Move(element,
      { x:  distance, y: 0, duration: split, afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x: -distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x:  distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x: -distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x:  distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x: -distance, y: 0, duration: split, 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');
  var elementDimensions = element.getDimensions();
  return new Effect.Scale(element, window.opera ? 0 : 1,
   Object.extend({ scaleContent: false,
    scaleX: false,
    scaleMode: 'box',
    scaleFrom: 100,
    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().show();
    },
    afterUpdateInternal: function(effect) {
      effect.element.down().setStyle({bottom:
        (effect.dims[0] - effect.element.clientHeight) + 'px' });
    },
    afterFinishInternal: function(effect) {
      effect.element.hide().undoClipping().undoPositioned();
      effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom});
    }
   }, arguments[1] || { })
  );
};

// Bug in opera makes the TD containing this element expand for a instance after finish
Effect.Squish = function(element) {
  return new Effect.Scale(element, window.opera ? 1 : 0, {
    restoreAfterFinish: true,
    beforeSetup: function(effect) {
      effect.element.makeClipping();
    },
    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] || { },
    oldOpacity = element.getInlineOpacity(),
    transition = options.transition || Effect.Transitions.linear,
    reverser   = function(pos){
      return 1 - transition((-Math.cos((pos*(options.pulses||5)*2)*Math.PI)/2) + .5);
    };

  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(Effect.Base, {
  initialize: function(element) {
    this.element = $(element);
    if (!this.element) throw(Effect._elementDoesNotExistError);
    var options = Object.extend({
      style: { }
    }, arguments[1] || { });

    if (!Object.isString(options.style)) this.style = $H(options.style);
    else {
      if (options.style.include(':'))
        this.style = options.style.parseStyle();
      else {
        this.element.addClassName(options.style);
        this.style = $H(this.element.getStyles());
        this.element.removeClassName(options.style);
        var css = this.element.getStyles();
        this.style = this.style.reject(function(style) {
          return style.value == css[style.key];
        });
        options.afterFinishInternal = function(effect) {
          effect.element.addClassName(effect.options.style);
          effect.transforms.each(function(transform) {
            effect.element.style[transform.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], value = pair[1], unit = null;

      if (value.parseColor('#zzzzzz') != '#zzzzzz') {
        value = value.parseColor();
        unit  = 'color';
      } else if (property == 'opacity') {
        value = parseFloat(value);
        if (Prototype.Browser.IE && (!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 {
        style: property.camelize(),
        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 = { }, transform, i = this.transforms.length;
    while(i--)
      style[(transform = this.transforms[i]).style] =
        transform.unit=='color' ? '#'+
          (Math.round(transform.originalValue[0]+
            (transform.targetValue[0]-transform.originalValue[0])*position)).toColorPart() +
          (Math.round(transform.originalValue[1]+
            (transform.targetValue[1]-transform.originalValue[1])*position)).toColorPart() +
          (Math.round(transform.originalValue[2]+
            (transform.targetValue[2]-transform.originalValue[2])*position)).toColorPart() :
        (transform.originalValue +
          (transform.targetValue - transform.originalValue) * position).toFixed(3) +
            (transform.unit === null ? '' : transform.unit);
    this.element.setStyle(style, true);
  }
});

Effect.Transform = Class.create({
  initialize: function(tracks){
    this.tracks  = [];
    this.options = arguments[1] || { };
    this.addTracks(tracks);
  },
  addTracks: function(tracks){
    tracks.each(function(track){
      track = $H(track);
      var data = track.values().first();
      this.tracks.push($H({
        ids:     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 ids = track.get('ids'), effect = track.get('effect'), options = track.get('options');
        var elements = [$(ids) || $$(ids)].flatten();
        return elements.map(function(e){ return new effect(e, Object.extend({ sync:true }, 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.__parseStyleElement = document.createElement('div');
String.prototype.parseStyle = function(){
  var style, styleRules = $H();
  if (Prototype.Browser.WebKit)
    style = new Element('div',{style:this}).style;
  else {
    String.__parseStyleElement.innerHTML = '<div style="' + this + '"></div>';
    style = String.__parseStyleElement.childNodes[0].style;
  }

  Element.CSS_PROPERTIES.each(function(property){
    if (style[property]) styleRules.set(property, style[property]);
  });

  if (Prototype.Browser.IE && this.include('opacity'))
    styleRules.set('opacity', this.match(/opacity:\s*((?:0|1)?(?:\.\d*)?)/)[1]);

  return styleRules;
};

if (document.defaultView && document.defaultView.getComputedStyle) {
  Element.getStyles = function(element) {
    var css = document.defaultView.getComputedStyle($(element), null);
    return Element.CSS_PROPERTIES.inject({ }, function(styles, property) {
      styles[property] = css[property];
      return styles;
    });
  };
} else {
  Element.getStyles = function(element) {
    element = $(element);
    var css = element.currentStyle, styles;
    styles = Element.CSS_PROPERTIES.inject({ }, function(results, property) {
      results[property] = css[property];
      return results;
    });
    if (!styles.opacity) styles.opacity = element.getOpacity();
    return styles;
  };
}

Effect.Methods = {
  morph: function(element, style) {
    element = $(element);
    new Effect.Morph(element, Object.extend({ style: style }, arguments[2] || { }));
    return element;
  },
  visualEffect: function(element, effect, options) {
    element = $(element);
    var s = effect.dasherize().camelize(), klass = s.charAt(0).toUpperCase() + s.substring(1);
    new Effect[klass](element, options);
    return element;
  },
  highlight: function(element, options) {
    element = $(element);
    new Effect.Highlight(element, options);
    return element;
  }
};

$w('fade appear grow shrink fold blindUp blindDown slideUp slideDown '+
  'pulsate shake puff squish switchOff dropOut').each(
  function(effect) {
    Effect.Methods[effect] = function(element, options){
      element = $(element);
      Effect[effect.charAt(0).toUpperCase() + effect.substring(1)](element, options);
      return element;
    };
  }
);

$w('getInlineOpacity forceRerendering setContentZoom collectTextNodes collectTextNodesIgnoreClass getStyles').each(
  function(f) { Effect.Methods[f] = Element[f]; }
);

Element.addMethods(Effect.Methods);// script.aculo.us dragdrop.js v1.8.2, Tue Nov 18 18:30:58 +0100 2008

// Copyright (c) 2005-2008 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
//           (c) 2005-2008 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(Object.isUndefined(Effect))
  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(Object.isArray(containment)) {
        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 drop, affected = [];

    this.drops.each( function(drop) {
      if(Droppables.isAffected(point, element, drop))
        affected.push(drop);
    });

    if(affected.length>0)
      drop = Droppables.findDeepestChild(affected);

    if(this.last_active && this.last_active != drop) this.deactivate(this.last_active);
    if (drop) {
      Position.within(drop.element, point[0], point[1]);
      if(drop.onHover)
        drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));

      if (drop != this.last_active) 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);
        return true;
      }
  },

  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({
  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 = Object.isNumber(element._opacity) ? 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,
      quiet: 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] || Object.isUndefined(arguments[1].endeffect))
      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 && Object.isString(options.handle))
      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.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(!Object.isUndefined(Draggable._dragging[this.element]) &&
      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.delta)
      this.delta = this.currentDelta();

    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);
      this._originallyAbsolute = (this.element.getStyle('position') == 'absolute');
      if (!this._originallyAbsolute)
        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);

    if(!this.options.quiet){
      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(Prototype.Browser.WebKit) window.scrollBy(0,0);

    Event.stop(event);
  },

  finishDrag: function(event, success) {
    this.dragging = false;

    if(this.options.quiet){
      Position.prepare();
      var pointer = [Event.pointerX(event), Event.pointerY(event)];
      Droppables.show(pointer, this.element);
    }

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

    var dropped = false;
    if(success) {
      dropped = Droppables.fire(event, this.element);
      if (!dropped) dropped = false;
    }
    if(dropped && this.options.onDropped) this.options.onDropped(this.element);
    Draggables.notify('onEnd', this, event);

    var revert = this.options.revert;
    if(revert && Object.isFunction(revert)) revert = revert(this.element);

    var d = this.currentDelta();
    if(revert && this.options.reverteffect) {
      if (dropped == 0 || revert != 'failure')
        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(Object.isFunction(this.options.snap)) {
        p = this.options.snap(p[0],p[1],this);
      } else {
      if(Object.isArray(this.options.snap)) {
        p = p.map( function(v, i) {
          return (v/this.options.snap[i]).round()*this.options.snap[i] }.bind(this));
      } else {
        p = p.map( function(v) {
          return (v/this.options.snap).round()*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 };
  }
});

Draggable._dragging = { };

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

var SortableObserver = Class.create({
  initialize: function(element, observer) {
    this.element   = $(element);
    this.observer  = observer;
    this.lastValue = Sortable.serialize(this.element);
  },

  onStart: function() {
    this.lastValue = Sortable.serialize(this.element);
  },

  onEnd: function() {
    Sortable.unmark();
    if(this.lastValue != Sortable.serialize(this.element))
      this.observer(this.element)
  }
});

var Sortable = {
  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){
    element = $(element);
    var s = Sortable.sortables[element.id];

    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,
      quiet:       false,
      scroll:      false,
      scrollSensitivity: 20,
      scrollSpeed: 15,
      format:      this.SERIALIZE_RULE,

      // these take arrays of elements or ids and can be
      // used for better initialization performance
      elements:    false,
      handles:     false,

      onChange:    Prototype.emptyFunction,
      onUpdate:    Prototype.emptyFunction
    }, arguments[1] || { });

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

    // build options for the draggables
    var options_for_draggable = {
      revert:      true,
      quiet:       options.quiet,
      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);
    }

    (options.elements || this.findElements(element, options) || []).each( function(e,i) {
      var handle = options.handles ? $(options.handles[i]) :
        (options.handle ? $(e).select('.' + options.handle)[0] : e);
      options.draggables.push(
        new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));
      Droppables.add(e, options_for_droppable);
      if(options.tree) e.treeNode = element;
      options.droppables.push(e);
    });

    if(options.tree) {
      (Sortable.findTreeElements(element, options) || []).each( function(e) {
        Droppables.add(e, options_for_tree);
        e.treeNode = element;
        options.droppables.push(e);
      });
    }

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

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

  },

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

  findTreeElements: function(element, options) {
    return Element.findChildren(
      element, options.only, options.tree ? true : false, options.treeTag);
  },

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

    if(overlap > .33 && overlap < .66 && Sortable.options(dropon).tree) {
      return;
    } else if(overlap>0.5) {
      Sortable.mark(dropon, 'before');
      if(dropon.previousSibling != element) {
        var oldParentNode = element.parentNode;
        element.style.visibility = "hidden"; // fix gecko rendering
        dropon.parentNode.insertBefore(element, dropon);
        if(dropon.parentNode!=oldParentNode)
          Sortable.options(oldParentNode).onChange(element);
        Sortable.options(dropon.parentNode).onChange(element);
      }
    } else {
      Sortable.mark(dropon, 'after');
      var nextElement = dropon.nextSibling || null;
      if(nextElement != element) {
        var oldParentNode = element.parentNode;
        element.style.visibility = "hidden"; // fix gecko rendering
        dropon.parentNode.insertBefore(element, nextElement);
        if(dropon.parentNode!=oldParentNode)
          Sortable.options(oldParentNode).onChange(element);
        Sortable.options(dropon.parentNode).onChange(element);
      }
    }
  },

  onEmptyHover: function(element, dropon, overlap) {
    var oldParentNode = element.parentNode;
    var droponOptions = Sortable.options(dropon);

    if(!Element.isParent(dropon, element)) {
      var index;

      var children = Sortable.findElements(dropon, {tag: droponOptions.tag, 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.8.2, Tue Nov 18 18:30:58 +0100 2008

// Copyright (c) 2005-2008 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
//           (c) 2005-2008 Ivan Krstic (http://blogs.law.harvard.edu/ivan)
//           (c) 2005-2008 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 = Class.create({
  baseInitialize: function(element, update, options) {
    element          = $(element);
    this.element     = element;
    this.update      = $(update);
    this.hasFocus    = false;
    this.changed     = false;
    this.active      = false;
    this.index       = 0;
    this.entryCount  = 0;
    this.oldElementValue = this.element.value;

    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);
    // Force carriage returns as token delimiters anyway
    if (!this.options.tokens.include('\n'))
      this.options.tokens.push('\n');

    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, 'keydown', this.onKeyPress.bindAsEventListener(this));
  },

  show: function() {
    if(Element.getStyle(this.update, 'display')=='none') this.options.onShow(this.element, this.update);
    if(!this.iefix &&
      (Prototype.Browser.IE) &&
      (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();
         Event.stop(event);
         return;
       case Event.KEY_DOWN:
         this.markNext();
         this.render();
         Event.stop(event);
         return;
      }
     else
       if(event.keyCode==Event.KEY_TAB || event.keyCode==Event.KEY_RETURN ||
         (Prototype.Browser.WebKit > 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 = $(selectedElement).select('.' + this.options.select) || [];
      if(nodes.length>0) value = Element.collectTextNodes(nodes[0], this.options.select);
    } else
      value = Element.collectTextNodesIgnoreClass(selectedElement, 'informal');

    var bounds = this.getTokenBounds();
    if (bounds[0] != -1) {
      var newValue = this.element.value.substr(0, bounds[0]);
      var whitespace = this.element.value.substr(bounds[0]).match(/^\s+/);
      if (whitespace)
        newValue += whitespace[0];
      this.element.value = newValue + value + this.element.value.substr(bounds[1]);
    } else {
      this.element.value = value;
    }
    this.oldElementValue = this.element.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;
    this.tokenBounds = null;
    if(this.getToken().length>=this.options.minChars) {
      this.getUpdatedChoices();
    } else {
      this.active = false;
      this.hide();
    }
    this.oldElementValue = this.element.value;
  },

  getToken: function() {
    var bounds = this.getTokenBounds();
    return this.element.value.substring(bounds[0], bounds[1]).strip();
  },

  getTokenBounds: function() {
    if (null != this.tokenBounds) return this.tokenBounds;
    var value = this.element.value;
    if (value.strip().empty()) return [-1, 0];
    var diff = arguments.callee.getFirstDifferencePos(value, this.oldElementValue);
    var offset = (diff == this.oldElementValue.length ? 1 : 0);
    var prevTokenPos = -1, nextTokenPos = value.length;
    var tp;
    for (var index = 0, l = this.options.tokens.length; index < l; ++index) {
      tp = value.lastIndexOf(this.options.tokens[index], diff + offset - 1);
      if (tp > prevTokenPos) prevTokenPos = tp;
      tp = value.indexOf(this.options.tokens[index], diff + offset);
      if (-1 != tp && tp < nextTokenPos) nextTokenPos = tp;
    }
    return (this.tokenBounds = [prevTokenPos + 1, nextTokenPos]);
  }
});

Autocompleter.Base.prototype.getTokenBounds.getFirstDifferencePos = function(newS, oldS) {
  var boundary = Math.min(newS.length, oldS.length);
  for (var index = 0; index < boundary; ++index)
    if (newS[index] != oldS[index])
      return index;
  return boundary;
};

Ajax.Autocompleter = Class.create(Autocompleter.Base, {
  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() {
    this.startIndicator();

    var 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.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 and collection editor
// Full rewrite by Christophe Porteneuve <tdd@tddsworld.com> (April 2007).

// 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({
  initialize: function(element, url, options) {
    this.url = url;
    this.element = element = $(element);
    this.prepareOptions();
    this._controls = { };
    arguments.callee.dealWithDeprecatedOptions(options); // DEPRECATION LAYER!!!
    Object.extend(this.options, options || { });
    if (!this.options.formId && this.element.id) {
      this.options.formId = this.element.id + '-inplaceeditor';
      if ($(this.options.formId))
        this.options.formId = '';
    }
    if (this.options.externalControl)
      this.options.externalControl = $(this.options.externalControl);
    if (!this.options.externalControl)
      this.options.externalControlOnly = false;
    this._originalBackground = this.element.getStyle('background-color') || 'transparent';
    this.element.title = this.options.clickToEditText;
    this._boundCancelHandler = this.handleFormCancellation.bind(this);
    this._boundComplete = (this.options.onComplete || Prototype.emptyFunction).bind(this);
    this._boundFailureHandler = this.handleAJAXFailure.bind(this);
    this._boundSubmitHandler = this.handleFormSubmission.bind(this);
    this._boundWrapperHandler = this.wrapUp.bind(this);
    this.registerListeners();
  },
  checkForEscapeOrReturn: function(e) {
    if (!this._editing || e.ctrlKey || e.altKey || e.shiftKey) return;
    if (Event.KEY_ESC == e.keyCode)
      this.handleFormCancellation(e);
    else if (Event.KEY_RETURN == e.keyCode)
      this.handleFormSubmission(e);
  },
  createControl: function(mode, handler, extraClasses) {
    var control = this.options[mode + 'Control'];
    var text = this.options[mode + 'Text'];
    if ('button' == control) {
      var btn = document.createElement('input');
      btn.type = 'submit';
      btn.value = text;
      btn.className = 'editor_' + mode + '_button';
      if ('cancel' == mode)
        btn.onclick = this._boundCancelHandler;
      this._form.appendChild(btn);
      this._controls[mode] = btn;
    } else if ('link' == control) {
      var link = document.createElement('a');
      link.href = '#';
      link.appendChild(document.createTextNode(text));
      link.onclick = 'cancel' == mode ? this._boundCancelHandler : this._boundSubmitHandler;
      link.className = 'editor_' + mode + '_link';
      if (extraClasses)
        link.className += ' ' + extraClasses;
      this._form.appendChild(link);
      this._controls[mode] = link;
    }
  },
  createEditField: function() {
    var text = (this.options.loadTextURL ? this.options.loadingText : this.getText());
    var fld;
    if (1 >= this.options.rows && !/\r|\n/.test(this.getText())) {
      fld = document.createElement('input');
      fld.type = 'text';
      var size = this.options.size || this.options.cols || 0;
      if (0 < size) fld.size = size;
    } else {
      fld = document.createElement('textarea');
      fld.rows = (1 >= this.options.rows ? this.options.autoRows : this.options.rows);
      fld.cols = this.options.cols || 40;
    }
    fld.name = this.options.paramName;
    fld.value = text; // No HTML breaks conversion anymore
    fld.className = 'editor_field';
    if (this.options.submitOnBlur)
      fld.onblur = this._boundSubmitHandler;
    this._controls.editor = fld;
    if (this.options.loadTextURL)
      this.loadExternalText();
    this._form.appendChild(this._controls.editor);
  },
  createForm: function() {
    var ipe = this;
    function addText(mode, condition) {
      var text = ipe.options['text' + mode + 'Controls'];
      if (!text || condition === false) return;
      ipe._form.appendChild(document.createTextNode(text));
    };
    this._form = $(document.createElement('form'));
    this._form.id = this.options.formId;
    this._form.addClassName(this.options.formClassName);
    this._form.onsubmit = this._boundSubmitHandler;
    this.createEditField();
    if ('textarea' == this._controls.editor.tagName.toLowerCase())
      this._form.appendChild(document.createElement('br'));
    if (this.options.onFormCustomization)
      this.options.onFormCustomization(this, this._form);
    addText('Before', this.options.okControl || this.options.cancelControl);
    this.createControl('ok', this._boundSubmitHandler);
    addText('Between', this.options.okControl && this.options.cancelControl);
    this.createControl('cancel', this._boundCancelHandler, 'editor_cancel');
    addText('After', this.options.okControl || this.options.cancelControl);
  },
  destroy: function() {
    if (this._oldInnerHTML)
      this.element.innerHTML = this._oldInnerHTML;
    this.leaveEditMode();
    this.unregisterListeners();
  },
  enterEditMode: function(e) {
    if (this._saving || this._editing) return;
    this._editing = true;
    this.triggerCallback('onEnterEditMode');
    if (this.options.externalControl)
      this.options.externalControl.hide();
    this.element.hide();
    this.createForm();
    this.element.parentNode.insertBefore(this._form, this.element);
    if (!this.options.loadTextURL)
      this.postProcessEditField();
    if (e) Event.stop(e);
  },
  enterHover: function(e) {
    if (this.options.hoverClassName)
      this.element.addClassName(this.options.hoverClassName);
    if (this._saving) return;
    this.triggerCallback('onEnterHover');
  },
  getText: function() {
    return this.element.innerHTML.unescapeHTML();
  },
  handleAJAXFailure: function(transport) {
    this.triggerCallback('onFailure', transport);
    if (this._oldInnerHTML) {
      this.element.innerHTML = this._oldInnerHTML;
      this._oldInnerHTML = null;
    }
  },
  handleFormCancellation: function(e) {
    this.wrapUp();
    if (e) Event.stop(e);
  },
  handleFormSubmission: function(e) {
    var form = this._form;
    var value = $F(this._controls.editor);
    this.prepareSubmission();
    var params = this.options.callback(form, value) || '';
    if (Object.isString(params))
      params = params.toQueryParams();
    params.editorId = this.element.id;
    if (this.options.htmlResponse) {
      var options = Object.extend({ evalScripts: true }, this.options.ajaxOptions);
      Object.extend(options, {
        parameters: params,
        onComplete: this._boundWrapperHandler,
        onFailure: this._boundFailureHandler
      });
      new Ajax.Updater({ success: this.element }, this.url, options);
    } else {
      var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
      Object.extend(options, {
        parameters: params,
        onComplete: this._boundWrapperHandler,
        onFailure: this._boundFailureHandler
      });
      new Ajax.Request(this.url, options);
    }
    if (e) Event.stop(e);
  },
  leaveEditMode: function() {
    this.element.removeClassName(this.options.savingClassName);
    this.removeForm();
    this.leaveHover();
    this.element.style.backgroundColor = this._originalBackground;
    this.element.show();
    if (this.options.externalControl)
      this.options.externalControl.show();
    this._saving = false;
    this._editing = false;
    this._oldInnerHTML = null;
    this.triggerCallback('onLeaveEditMode');
  },
  leaveHover: function(e) {
    if (this.options.hoverClassName)
      this.element.removeClassName(this.options.hoverClassName);
    if (this._saving) return;
    this.triggerCallback('onLeaveHover');
  },
  loadExternalText: function() {
    this._form.addClassName(this.options.loadingClassName);
    this._controls.editor.disabled = true;
    var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
    Object.extend(options, {
      parameters: 'editorId=' + encodeURIComponent(this.element.id),
      onComplete: Prototype.emptyFunction,
      onSuccess: function(transport) {
        this._form.removeClassName(this.options.loadingClassName);
        var text = transport.responseText;
        if (this.options.stripLoadedTextTags)
          text = text.stripTags();
        this._controls.editor.value = text;
        this._controls.editor.disabled = false;
        this.postProcessEditField();
      }.bind(this),
      onFailure: this._boundFailureHandler
    });
    new Ajax.Request(this.options.loadTextURL, options);
  },
  postProcessEditField: function() {
    var fpc = this.options.fieldPostCreation;
    if (fpc)
      $(this._controls.editor)['focus' == fpc ? 'focus' : 'activate']();
  },
  prepareOptions: function() {
    this.options = Object.clone(Ajax.InPlaceEditor.DefaultOptions);
    Object.extend(this.options, Ajax.InPlaceEditor.DefaultCallbacks);
    [this._extraDefaultOptions].flatten().compact().each(function(defs) {
      Object.extend(this.options, defs);
    }.bind(this));
  },
  prepareSubmission: function() {
    this._saving = true;
    this.removeForm();
    this.leaveHover();
    this.showSaving();
  },
  registerListeners: function() {
    this._listeners = { };
    var listener;
    $H(Ajax.InPlaceEditor.Listeners).each(function(pair) {
      listener = this[pair.value].bind(this);
      this._listeners[pair.key] = listener;
      if (!this.options.externalControlOnly)
        this.element.observe(pair.key, listener);
      if (this.options.externalControl)
        this.options.externalControl.observe(pair.key, listener);
    }.bind(this));
  },
  removeForm: function() {
    if (!this._form) return;
    this._form.remove();
    this._form = null;
    this._controls = { };
  },
  showSaving: function() {
    this._oldInnerHTML = this.element.innerHTML;
    this.element.innerHTML = this.options.savingText;
    this.element.addClassName(this.options.savingClassName);
    this.element.style.backgroundColor = this._originalBackground;
    this.element.show();
  },
  triggerCallback: function(cbName, arg) {
    if ('function' == typeof this.options[cbName]) {
      this.options[cbName](this, arg);
    }
  },
  unregisterListeners: function() {
    $H(this._listeners).each(function(pair) {
      if (!this.options.externalControlOnly)
        this.element.stopObserving(pair.key, pair.value);
      if (this.options.externalControl)
        this.options.externalControl.stopObserving(pair.key, pair.value);
    }.bind(this));
  },
  wrapUp: function(transport) {
    this.leaveEditMode();
    // Can't use triggerCallback due to backward compatibility: requires
    // binding + direct element
    this._boundComplete(transport, this.element);
  }
});

Object.extend(Ajax.InPlaceEditor.prototype, {
  dispose: Ajax.InPlaceEditor.prototype.destroy
});

Ajax.InPlaceCollectionEditor = Class.create(Ajax.InPlaceEditor, {
  initialize: function($super, element, url, options) {
    this._extraDefaultOptions = Ajax.InPlaceCollectionEditor.DefaultOptions;
    $super(element, url, options);
  },

  createEditField: function() {
    var list = document.createElement('select');
    list.name = this.options.paramName;
    list.size = 1;
    this._controls.editor = list;
    this._collection = this.options.collection || [];
    if (this.options.loadCollectionURL)
      this.loadCollection();
    else
      this.checkForExternalText();
    this._form.appendChild(this._controls.editor);
  },

  loadCollection: function() {
    this._form.addClassName(this.options.loadingClassName);
    this.showLoadingText(this.options.loadingCollectionText);
    var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
    Object.extend(options, {
      parameters: 'editorId=' + encodeURIComponent(this.element.id),
      onComplete: Prototype.emptyFunction,
      onSuccess: function(transport) {
        var js = transport.responseText.strip();
        if (!/^\[.*\]$/.test(js)) // TODO: improve sanity check
          throw('Server returned an invalid collection representation.');
        this._collection = eval(js);
        this.checkForExternalText();
      }.bind(this),
      onFailure: this.onFailure
    });
    new Ajax.Request(this.options.loadCollectionURL, options);
  },

  showLoadingText: function(text) {
    this._controls.editor.disabled = true;
    var tempOption = this._controls.editor.firstChild;
    if (!tempOption) {
      tempOption = document.createElement('option');
      tempOption.value = '';
      this._controls.editor.appendChild(tempOption);
      tempOption.selected = true;
    }
    tempOption.update((text || '').stripScripts().stripTags());
  },

  checkForExternalText: function() {
    this._text = this.getText();
    if (this.options.loadTextURL)
      this.loadExternalText();
    else
      this.buildOptionList();
  },

  loadExternalText: function() {
    this.showLoadingText(this.options.loadingText);
    var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
    Object.extend(options, {
      parameters: 'editorId=' + encodeURIComponent(this.element.id),
      onComplete: Prototype.emptyFunction,
      onSuccess: function(transport) {
        this._text = transport.responseText.strip();
        this.buildOptionList();
      }.bind(this),
      onFailure: this.onFailure
    });
    new Ajax.Request(this.options.loadTextURL, options);
  },

  buildOptionList: function() {
    this._form.removeClassName(this.options.loadingClassName);
    this._collection = this._collection.map(function(entry) {
      return 2 === entry.length ? entry : [entry, entry].flatten();
    });
    var marker = ('value' in this.options) ? this.options.value : this._text;
    var textFound = this._collection.any(function(entry) {
      return entry[0] == marker;
    }.bind(this));
    this._controls.editor.update('');
    var option;
    this._collection.each(function(entry, index) {
      option = document.createElement('option');
      option.value = entry[0];
      option.selected = textFound ? entry[0] == marker : 0 == index;
      option.appendChild(document.createTextNode(entry[1]));
      this._controls.editor.appendChild(option);
    }.bind(this));
    this._controls.editor.disabled = false;
    Field.scrollFreeActivate(this._controls.editor);
  }
});

//**** DEPRECATION LAYER FOR InPlace[Collection]Editor! ****
//**** This only  exists for a while,  in order to  let ****
//**** users adapt to  the new API.  Read up on the new ****
//**** API and convert your code to it ASAP!            ****

Ajax.InPlaceEditor.prototype.initialize.dealWithDeprecatedOptions = function(options) {
  if (!options) return;
  function fallback(name, expr) {
    if (name in options || expr === undefined) return;
    options[name] = expr;
  };
  fallback('cancelControl', (options.cancelLink ? 'link' : (options.cancelButton ? 'button' :
    options.cancelLink == options.cancelButton == false ? false : undefined)));
  fallback('okControl', (options.okLink ? 'link' : (options.okButton ? 'button' :
    options.okLink == options.okButton == false ? false : undefined)));
  fallback('highlightColor', options.highlightcolor);
  fallback('highlightEndColor', options.highlightendcolor);
};

Object.extend(Ajax.InPlaceEditor, {
  DefaultOptions: {
    ajaxOptions: { },
    autoRows: 3,                                // Use when multi-line w/ rows == 1
    cancelControl: 'link',                      // 'link'|'button'|false
    cancelText: 'cancel',
    clickToEditText: 'Click to edit',
    externalControl: null,                      // id|elt
    externalControlOnly: false,
    fieldPostCreation: 'activate',              // 'activate'|'focus'|false
    formClassName: 'inplaceeditor-form',
    formId: null,                               // id|elt
    highlightColor: '#ffff99',
    highlightEndColor: '#ffffff',
    hoverClassName: '',
    htmlResponse: true,
    loadingClassName: 'inplaceeditor-loading',
    loadingText: 'Loading...',
    okControl: 'button',                        // 'link'|'button'|false
    okText: 'ok',
    paramName: 'value',
    rows: 1,                                    // If 1 and multi-line, uses autoRows
    savingClassName: 'inplaceeditor-saving',
    savingText: 'Saving...',
    size: 0,
    stripLoadedTextTags: false,
    submitOnBlur: false,
    textAfterControls: '',
    textBeforeControls: '',
    textBetweenControls: ''
  },
  DefaultCallbacks: {
    callback: function(form) {
      return Form.serialize(form);
    },
    onComplete: function(transport, element) {
      // For backward compatibility, this one is bound to the IPE, and passes
      // the element directly.  It was too often customized, so we don't break it.
      new Effect.Highlight(element, {
        startcolor: this.options.highlightColor, keepBackgroundImage: true });
    },
    onEnterEditMode: null,
    onEnterHover: function(ipe) {
      ipe.element.style.backgroundColor = ipe.options.highlightColor;
      if (ipe._effect)
        ipe._effect.cancel();
    },
    onFailure: function(transport, ipe) {
      alert('Error communication with the server: ' + transport.responseText.stripTags());
    },
    onFormCustomization: null, // Takes the IPE and its generated form, after editor, before controls.
    onLeaveEditMode: null,
    onLeaveHover: function(ipe) {
      ipe._effect = new Effect.Highlight(ipe.element, {
        startcolor: ipe.options.highlightColor, endcolor: ipe.options.highlightEndColor,
        restorecolor: ipe._originalBackground, keepBackgroundImage: true
      });
    }
  },
  Listeners: {
    click: 'enterEditMode',
    keydown: 'checkForEscapeOrReturn',
    mouseover: 'enterHover',
    mouseout: 'leaveHover'
  }
});

Ajax.InPlaceCollectionEditor.DefaultOptions = {
  loadingCollectionText: 'Loading options...'
};

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

Form.Element.DelayedObserver = Class.create({
  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));
  }
});// script.aculo.us slider.js v1.8.2, Tue Nov 18 18:30:58 +0100 2008

// Copyright (c) 2005-2008 Marty Haught, Thomas Fuchs
//
// 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 (!Control) var Control = { };

// options:
//  axis: 'vertical', or 'horizontal' (default)
//
// callbacks:
//  onChange(value)
//  onSlide(value)
Control.Slider = Class.create({
  initialize: function(handle, track, options) {
    var slider = this;

    if (Object.isArray(handle)) {
      this.handles = handle.collect( function(e) { return $(e) });
    } else {
      this.handles = [$(handle)];
    }

    this.track   = $(track);
    this.options = options || { };

    this.axis      = this.options.axis || 'horizontal';
    this.increment = this.options.increment || 1;
    this.step      = parseInt(this.options.step || '1');
    this.range     = this.options.range || $R(0,1);

    this.value     = 0; // assure backwards compat
    this.values    = this.handles.map( function() { return 0 });
    this.spans     = this.options.spans ? this.options.spans.map(function(s){ return $(s) }) : false;
    this.options.startSpan = $(this.options.startSpan || null);
    this.options.endSpan   = $(this.options.endSpan || null);

    this.restricted = this.options.restricted || false;

    this.maximum   = this.options.maximum || this.range.end;
    this.minimum   = this.options.minimum || this.range.start;

    // Will be used to align the handle onto the track, if necessary
    this.alignX = parseInt(this.options.alignX || '0');
    this.alignY = parseInt(this.options.alignY || '0');

    this.trackLength = this.maximumOffset() - this.minimumOffset();

    this.handleLength = this.isVertical() ?
      (this.handles[0].offsetHeight != 0 ?
        this.handles[0].offsetHeight : this.handles[0].style.height.replace(/px$/,"")) :
      (this.handles[0].offsetWidth != 0 ? this.handles[0].offsetWidth :
        this.handles[0].style.width.replace(/px$/,""));

    this.active   = false;
    this.dragging = false;
    this.disabled = false;

    if (this.options.disabled) this.setDisabled();

    // Allowed values array
    this.allowedValues = this.options.values ? this.options.values.sortBy(Prototype.K) : false;
    if (this.allowedValues) {
      this.minimum = this.allowedValues.min();
      this.maximum = this.allowedValues.max();
    }

    this.eventMouseDown = this.startDrag.bindAsEventListener(this);
    this.eventMouseUp   = this.endDrag.bindAsEventListener(this);
    this.eventMouseMove = this.update.bindAsEventListener(this);

    // Initialize handles in reverse (make sure first handle is active)
    this.handles.each( function(h,i) {
      i = slider.handles.length-1-i;
      slider.setValue(parseFloat(
        (Object.isArray(slider.options.sliderValue) ?
          slider.options.sliderValue[i] : slider.options.sliderValue) ||
         slider.range.start), i);
      h.makePositioned().observe("mousedown", slider.eventMouseDown);
    });

    this.track.observe("mousedown", this.eventMouseDown);
    document.observe("mouseup", this.eventMouseUp);
    document.observe("mousemove", this.eventMouseMove);

    this.initialized = true;
  },
  dispose: function() {
    var slider = this;
    Event.stopObserving(this.track, "mousedown", this.eventMouseDown);
    Event.stopObserving(document, "mouseup", this.eventMouseUp);
    Event.stopObserving(document, "mousemove", this.eventMouseMove);
    this.handles.each( function(h) {
      Event.stopObserving(h, "mousedown", slider.eventMouseDown);
    });
  },
  setDisabled: function(){
    this.disabled = true;
  },
  setEnabled: function(){
    this.disabled = false;
  },
  getNearestValue: function(value){
    if (this.allowedValues){
      if (value >= this.allowedValues.max()) return(this.allowedValues.max());
      if (value <= this.allowedValues.min()) return(this.allowedValues.min());

      var offset = Math.abs(this.allowedValues[0] - value);
      var newValue = this.allowedValues[0];
      this.allowedValues.each( function(v) {
        var currentOffset = Math.abs(v - value);
        if (currentOffset <= offset){
          newValue = v;
          offset = currentOffset;
        }
      });
      return newValue;
    }
    if (value > this.range.end) return this.range.end;
    if (value < this.range.start) return this.range.start;
    return value;
  },
  setValue: function(sliderValue, handleIdx){
    if (!this.active) {
      this.activeHandleIdx = handleIdx || 0;
      this.activeHandle    = this.handles[this.activeHandleIdx];
      this.updateStyles();
    }
    handleIdx = handleIdx || this.activeHandleIdx || 0;
    if (this.initialized && this.restricted) {
      if ((handleIdx>0) && (sliderValue<this.values[handleIdx-1]))
        sliderValue = this.values[handleIdx-1];
      if ((handleIdx < (this.handles.length-1)) && (sliderValue>this.values[handleIdx+1]))
        sliderValue = this.values[handleIdx+1];
    }
    sliderValue = this.getNearestValue(sliderValue);
    this.values[handleIdx] = sliderValue;
    this.value = this.values[0]; // assure backwards compat

    this.handles[handleIdx].style[this.isVertical() ? 'top' : 'left'] =
      this.translateToPx(sliderValue);

    this.drawSpans();
    if (!this.dragging || !this.event) this.updateFinished();
  },
  setValueBy: function(delta, handleIdx) {
    this.setValue(this.values[handleIdx || this.activeHandleIdx || 0] + delta,
      handleIdx || this.activeHandleIdx || 0);
  },
  translateToPx: function(value) {
    return Math.round(
      ((this.trackLength-this.handleLength)/(this.range.end-this.range.start)) *
      (value - this.range.start)) + "px";
  },
  translateToValue: function(offset) {
    return ((offset/(this.trackLength-this.handleLength) *
      (this.range.end-this.range.start)) + this.range.start);
  },
  getRange: function(range) {
    var v = this.values.sortBy(Prototype.K);
    range = range || 0;
    return $R(v[range],v[range+1]);
  },
  minimumOffset: function(){
    return(this.isVertical() ? this.alignY : this.alignX);
  },
  maximumOffset: function(){
    return(this.isVertical() ?
      (this.track.offsetHeight != 0 ? this.track.offsetHeight :
        this.track.style.height.replace(/px$/,"")) - this.alignY :
      (this.track.offsetWidth != 0 ? this.track.offsetWidth :
        this.track.style.width.replace(/px$/,"")) - this.alignX);
  },
  isVertical:  function(){
    return (this.axis == 'vertical');
  },
  drawSpans: function() {
    var slider = this;
    if (this.spans)
      $R(0, this.spans.length-1).each(function(r) { slider.setSpan(slider.spans[r], slider.getRange(r)) });
    if (this.options.startSpan)
      this.setSpan(this.options.startSpan,
        $R(0, this.values.length>1 ? this.getRange(0).min() : this.value ));
    if (this.options.endSpan)
      this.setSpan(this.options.endSpan,
        $R(this.values.length>1 ? this.getRange(this.spans.length-1).max() : this.value, this.maximum));
  },
  setSpan: function(span, range) {
    if (this.isVertical()) {
      span.style.top = this.translateToPx(range.start);
      span.style.height = this.translateToPx(range.end - range.start + this.range.start);
    } else {
      span.style.left = this.translateToPx(range.start);
      span.style.width = this.translateToPx(range.end - range.start + this.range.start);
    }
  },
  updateStyles: function() {
    this.handles.each( function(h){ Element.removeClassName(h, 'selected') });
    Element.addClassName(this.activeHandle, 'selected');
  },
  startDrag: function(event) {
    if (Event.isLeftClick(event)) {
      if (!this.disabled){
        this.active = true;

        var handle = Event.element(event);
        var pointer  = [Event.pointerX(event), Event.pointerY(event)];
        var track = handle;
        if (track==this.track) {
          var offsets  = Position.cumulativeOffset(this.track);
          this.event = event;
          this.setValue(this.translateToValue(
           (this.isVertical() ? pointer[1]-offsets[1] : pointer[0]-offsets[0])-(this.handleLength/2)
          ));
          var offsets  = Position.cumulativeOffset(this.activeHandle);
          this.offsetX = (pointer[0] - offsets[0]);
          this.offsetY = (pointer[1] - offsets[1]);
        } else {
          // find the handle (prevents issues with Safari)
          while((this.handles.indexOf(handle) == -1) && handle.parentNode)
            handle = handle.parentNode;

          if (this.handles.indexOf(handle)!=-1) {
            this.activeHandle    = handle;
            this.activeHandleIdx = this.handles.indexOf(this.activeHandle);
            this.updateStyles();

            var offsets  = Position.cumulativeOffset(this.activeHandle);
            this.offsetX = (pointer[0] - offsets[0]);
            this.offsetY = (pointer[1] - offsets[1]);
          }
        }
      }
      Event.stop(event);
    }
  },
  update: function(event) {
   if (this.active) {
      if (!this.dragging) this.dragging = true;
      this.draw(event);
      if (Prototype.Browser.WebKit) window.scrollBy(0,0);
      Event.stop(event);
   }
  },
  draw: function(event) {
    var pointer = [Event.pointerX(event), Event.pointerY(event)];
    var offsets = Position.cumulativeOffset(this.track);
    pointer[0] -= this.offsetX + offsets[0];
    pointer[1] -= this.offsetY + offsets[1];
    this.event = event;
    this.setValue(this.translateToValue( this.isVertical() ? pointer[1] : pointer[0] ));
    if (this.initialized && this.options.onSlide)
      this.options.onSlide(this.values.length>1 ? this.values : this.value, this);
  },
  endDrag: function(event) {
    if (this.active && this.dragging) {
      this.finishDrag(event, true);
      Event.stop(event);
    }
    this.active = false;
    this.dragging = false;
  },
  finishDrag: function(event, success) {
    this.active = false;
    this.dragging = false;
    this.updateFinished();
  },
  updateFinished: function() {
    if (this.initialized && this.options.onChange)
      this.options.onChange(this.values.length>1 ? this.values : this.value, this);
    this.event = null;
  }
});// script.aculo.us sound.js v1.8.2, Tue Nov 18 18:30:58 +0100 2008

// Copyright (c) 2005-2008 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
//
// Based on code created by Jules Gravinese (http://www.webveteran.com/)
//
// 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/

Sound = {
  tracks: {},
  _enabled: true,
  template:
    new Template('<embed style="height:0" id="sound_#{track}_#{id}" src="#{url}" loop="false" autostart="true" hidden="true"/>'),
  enable: function(){
    Sound._enabled = true;
  },
  disable: function(){
    Sound._enabled = false;
  },
  play: function(url){
    if(!Sound._enabled) return;
    var options = Object.extend({
      track: 'global', url: url, replace: false
    }, arguments[1] || {});

    if(options.replace && this.tracks[options.track]) {
      $R(0, this.tracks[options.track].id).each(function(id){
        var sound = $('sound_'+options.track+'_'+id);
        sound.Stop && sound.Stop();
        sound.remove();
      });
      this.tracks[options.track] = null;
    }

    if(!this.tracks[options.track])
      this.tracks[options.track] = { id: 0 };
    else
      this.tracks[options.track].id++;

    options.id = this.tracks[options.track].id;
    $$('body')[0].insert(
      Prototype.Browser.IE ? new Element('bgsound',{
        id: 'sound_'+options.track+'_'+options.id,
        src: options.url, loop: 1, autostart: true
      }) : Sound.template.evaluate(options));
  }
};

if(Prototype.Browser.Gecko && navigator.userAgent.indexOf("Win") > 0){
  if(navigator.plugins && $A(navigator.plugins).detect(function(p){ return p.name.indexOf('QuickTime') != -1 }))
    Sound.template = new Template('<object id="sound_#{track}_#{id}" width="0" height="0" type="audio/mpeg" data="#{url}"/>');
  else
    Sound.play = function(){};
}/**
 * Image Cropper (v. 1.2.0 - 2006-10-30 )
 * Copyright (c) 2006 David Spurr (http://www.defusion.org.uk/)
 * 
 * The image cropper provides a way to draw a crop area on an image and capture
 * the coordinates of the drawn crop area.
 * 
 * Features include:
 * 		- Based on Prototype and Scriptaculous
 * 		- Image editing package styling, the crop area functions and looks 
 * 		  like those found in popular image editing software
 * 		- Dynamic inclusion of required styles
 * 		- Drag to draw areas
 * 		- Shift drag to draw/resize areas as squares
 * 		- Selection area can be moved 
 * 		- Seleciton area can be resized using resize handles
 * 		- Allows dimension ratio limited crop areas
 * 		- Allows minimum dimension crop areas
 * 		- Allows maximum dimesion crop areas
 * 		- If both min & max dimension options set to the same value for a single axis,then the cropper will not 
 * 		  display the resize handles as appropriate (when min & max dimensions are passed for both axes this
 * 		  results in a 'fixed size' crop area)
 * 		- Allows dynamic preview of resultant crop ( if minimum width & height are provided ), this is
 * 		  implemented as a subclass so can be excluded when not required
 * 		- Movement of selection area by arrow keys ( shift + arrow key will move selection area by
 * 		  10 pixels )
 *		- All operations stay within bounds of image
 * 		- All functionality & display compatible with most popular browsers supported by Prototype:
 * 			PC:	IE 7, 6 & 5.5, Firefox 1.5, Opera 8.5 (see known issues) & 9.0b
 * 			MAC: Camino 1.0, Firefox 1.5, Safari 2.0
 * 
 * Requires:
 * 		- Prototype v. 1.5.0_rc0 > (as packaged with Scriptaculous 1.6.1)
 * 		- Scriptaculous v. 1.6.1 > modules: builder, dragdrop 
 * 		
 * Known issues:
 * 		- Safari animated gifs, only one of each will animate, this seems to be a known Safari issue
 * 
 * 		- After drawing an area and then clicking to start a new drag in IE 5.5 the rendered height 
 *        appears as the last height until the user drags, this appears to be the related to the error 
 *        that the forceReRender() method fixes for IE 6, i.e. IE 5.5 is not redrawing the box properly.
 * 
 * 		- Lack of CSS opacity support in Opera before version 9 mean we disable those style rules, these 
 * 		  could be fixed by using PNGs with transparency if Opera 8.5 support is high priority for you
 * 
 * 		- Marching ants keep reloading in IE <6 (not tested in IE7), it is a known issue in IE and I have 
 *        found no viable workarounds that can be included in the release. If this really is an issue for you
 *        either try this post: http://mir.aculo.us/articles/2005/08/28/internet-explorer-and-ajax-image-caching-woes
 *        or uncomment the 'FIX MARCHING ANTS IN IE' rules in the CSS file
 *		
 *		- Styling & borders on image, any CSS styling applied directly to the image itself (floats, borders, padding, margin, etc.) will 
 *		  cause problems with the cropper. The use of a wrapper element to apply these styles to is recommended.
 * 
 * 		- overflow: auto or overflow: scroll on parent will cause cropper to burst out of parent in IE and Opera (maybe Mac browsers too)
 *		  I'm not sure why yet.
 * 
 * Usage:
 * 		See Cropper.Img & Cropper.ImgWithPreview for usage details
 * 
 * Changelog:
 * v1.2.0 - 2006-10-30
 * 		+ Added id to the preview image element using 'imgCrop_[originalImageID]'
 *      * #00001 - Fixed bug: Doesn't account for scroll offsets
 *      * #00009 - Fixed bug: Placing the cropper inside differently positioned elements causes incorrect co-ordinates and display
 *      * #00013 - Fixed bug: I-bar cursor appears on drag plane
 *      * #00014 - Fixed bug: If ID for image tag is not found in document script throws error
 *      * Fixed bug with drag start co-ordinates if wrapper element has moved in browser (e.g. dragged to a new position)
 *      * Fixed bug with drag start co-ordinates if image contained in a wrapper with scrolling - this may be buggy if image 
 * 		  has other ancestors with scrolling applied (except the body)
 *      * #00015 - Fixed bug: When cropper removed and then reapplied onEndCrop callback gets called multiple times, solution suggestion from Bill Smith
 *      * Various speed increases & code cleanup which meant improved performance in Mac - which allowed removal of different overlay methods for
 *        IE and all other browsers, which led to a fix for:
 * 		* #00010 - Fixed bug: Select area doesn't adhere to image size when image resized using img attributes
 *      - #00006 - Removed default behaviour of automatically setting a ratio when both min width & height passed, the ratioDimensions must be passed in
 * 		+ #00005 - Added ability to set maximum crop dimensions, if both min & max set as the same value then we'll get a fixed cropper size on the axes as appropriate
 *        and the resize handles will not be displayed as appropriate
 * 		* Switched keydown for keypress for moving select area with cursor keys (makes for nicer action) - doesn't appear to work in Safari
 * 
 * v1.1.3 - 2006-08-21
 * 		* Fixed wrong cursor on western handle in CSS
 * 		+ #00008 & #00003 - Added feature: Allow to set dimensions & position for cropper on load
 *      * #00002 - Fixed bug: Pressing 'remove cropper' twice removes image in IE
 * 
 * v1.1.2 - 2006-06-09
 * 		* Fixed bugs with ratios when GCD is low (patch submitted by Andy Skelton)
 * 
 * v1.1.1 - 2006-06-03
 * 		* Fixed bug with rendering issues fix in IE 5.5
 * 		* Fixed bug with endCrop callback issues once cropper had been removed & reset in IE
 * 
 * v1.1.0 - 2006-06-02
 * 		* Fixed bug with IE constantly trying to reload select area background image
 * 		* Applied more robust fix to Safari & IE rendering issues
 * 		+ Added method to reset parameters - useful for when dynamically changing img cropper attached to
 * 		+ Added method to remove cropper from image
 * 
 * v1.0.0 - 2006-05-18 
 * 		+ Initial verison
 * 
 * 
 * Copyright (c) 2006, David Spurr (http://www.defusion.org.uk/)
 * All rights reserved.
 * 
 * 
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 * 
 *     * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
 *     * Neither the name of the David Spurr nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 * http://www.opensource.org/licenses/bsd-license.php
 * 
 * See scriptaculous.js for full scriptaculous licence
 */
 
/**
 * Extend the Draggable class to allow us to pass the rendering
 * down to the Cropper object.
 */
var CropDraggable = Class.create();

Object.extend( Object.extend( CropDraggable.prototype, Draggable.prototype), {
	
	initialize: function(element) {
		this.options = Object.extend(
			{
				/**
				 * The draw method to defer drawing to
				 */
				drawMethod: function() {}
			}, 
			arguments[1] || {}
		);

		this.element = $(element);

		this.handle = this.element;

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

		this.eventMouseDown = this.initDrag.bindAsEventListener(this);
		Event.observe(this.handle, "mousedown", this.eventMouseDown);

		Draggables.register(this);
	},
	
	/**
	 * Defers the drawing of the draggable to the supplied method
	 */
	draw: function(point) {
		var pos = Position.cumulativeOffset(this.element);
		var d = this.currentDelta();
		pos[0] -= d[0]; 
		pos[1] -= d[1];
				
		var p = [0,1].map(function(i) { 
			return (point[i]-pos[i]-this.offset[i]) 
		}.bind(this));
				
		this.options.drawMethod( p );
	}
	
});


/**
 * The Cropper object, this will attach itself to the provided image by wrapping it with 
 * the generated xHTML structure required by the cropper.
 * 
 * Usage:
 * 	@param obj Image element to attach to
 * 	@param obj Optional options:
 * 		- ratioDim obj 
 * 			The pixel dimensions to apply as a restrictive ratio, with properties x & y
 * 
 * 		- minWidth int 
 * 			The minimum width for the select area in pixels
 * 
 * 		- minHeight	int 
 * 			The mimimum height for the select area in pixels
 * 
 * 		- maxWidth int
 * 			The maximum width for the select areas in pixels (if both minWidth & maxWidth set to same the width of the cropper will be fixed)
 * 
 * 		- maxHeight int
 *			The maximum height for the select areas in pixels (if both minHeight & maxHeight set to same the height of the cropper will be fixed)
 * 
 * 		- displayOnInit int 
 * 			Whether to display the select area on initialisation, only used when providing minimum width & height or ratio
 * 
 * 		- onEndCrop func
 * 			The callback function to provide the crop details to on end of a crop (see below)
 * 
 * 		- captureKeys boolean
 * 			Whether to capture the keys for moving the select area, as these can cause some problems at the moment
 * 
 * 		- onloadCoords obj
 * 			A coordinates object with properties x1, y1, x2 & y2; for the coordinates of the select area to display onload
 * 	
 *----------------------------------------------
 * 
 * The callback function provided via the onEndCrop option should accept the following parameters:
 * 		- coords obj
 * 			The coordinates object with properties x1, y1, x2 & y2; for the coordinates of the select area
 * 
 * 		- dimensions obj
 * 			The dimensions object with properites width & height; for the dimensions of the select area
 * 		
 *
 * 		Example:
 * 			function onEndCrop( coords, dimensions ) {
 *				$( 'x1' ).value 	= coords.x1;
 *				$( 'y1' ).value 	= coords.y1;
 *				$( 'x2' ).value 	= coords.x2;
 *				$( 'y2' ).value 	= coords.y2;
 *				$( 'width' ).value 	= dimensions.width;
 *				$( 'height' ).value	= dimensions.height;
 *			}
 * 
 */
var Cropper = {};
Cropper.Img = Class.create();
Cropper.Img.prototype = {
	
	/**
	 * Initialises the class
	 * 
	 * @access public
	 * @param obj Image element to attach to
	 * @param obj Options
	 * @return void
	 */
	initialize: function(element, options, width, height) {
		this.imageWidth = width;
		this.imageHeight = height;
		this.options = Object.extend(
			{
				/**
				 * @var obj
				 * The pixel dimensions to apply as a restrictive ratio
				 */
				ratioDim: { x: 0, y: 0 },
				/**
				 * @var int
				 * The minimum pixel width, also used as restrictive ratio if min height passed too
				 */
				minWidth:		0,
				/**
				 * @var int
				 * The minimum pixel height, also used as restrictive ratio if min width passed too
				 */
				minHeight:		0,
				/**
				 * @var boolean
				 * Whether to display the select area on initialisation, only used when providing minimum width & height or ratio
				 */
				displayOnInit:	false,
				/**
				 * @var function
				 * The call back function to pass the final values to
				 */
				onEndCrop: Prototype.emptyFunction,
				/**
				 * @var boolean
				 * Whether to capture key presses or not
				 */
				captureKeys: true,
				/**
				 * @var obj Coordinate object x1, y1, x2, y2
				 * The coordinates to optionally display the select area at onload
				 */
				onloadCoords: null,
				/**
				 * @var int
				 * The maximum width for the select areas in pixels (if both minWidth & maxWidth set to same the width of the cropper will be fixed)
				 */
				maxWidth: 0,
				/**
				 * @var int
				 * The maximum height for the select areas in pixels (if both minHeight & maxHeight set to same the height of the cropper will be fixed)
				 */
				maxHeight: 0
			}, 
			options || {}
		);				
		/**
		 * @var obj
		 * The img node to attach to
		 */
		this.img			= $( element );
		/**
		 * @var obj
		 * The x & y coordinates of the click point
		 */
		this.clickCoords	= { x: 0, y: 0 };
		/**
		 * @var boolean
		 * Whether the user is dragging
		 */
		this.dragging		= false;
		/**
		 * @var boolean
		 * Whether the user is resizing
		 */
		this.resizing		= false;
		/**
		 * @var boolean
		 * Whether the user is on a webKit browser
		 */
		this.isWebKit 		= /Konqueror|Safari|KHTML/.test( navigator.userAgent );
		/**
		 * @var boolean
		 * Whether the user is on IE
		 */
		this.isIE 			= /MSIE/.test( navigator.userAgent );
		/**
		 * @var boolean
		 * Whether the user is on Opera below version 9
		 */
		this.isOpera8		= /Opera\s[1-8]/.test( navigator.userAgent );
		/**
		 * @var int
		 * The x ratio 
		 */
		this.ratioX			= 0;
		/**
		 * @var int
		 * The y ratio
		 */
		this.ratioY			= 0;
		/**
		 * @var boolean
		 * Whether we've attached sucessfully
		 */
		this.attached		= false;
		/**
		 * @var boolean
		 * Whether we've got a fixed width (if minWidth EQ or GT maxWidth then we have a fixed width
		 * in the case of minWidth > maxWidth maxWidth wins as the fixed width)
		 */
		this.fixedWidth		= ( this.options.maxWidth > 0 && ( this.options.minWidth >= this.options.maxWidth ) );
		/**
		 * @var boolean
		 * Whether we've got a fixed height (if minHeight EQ or GT maxHeight then we have a fixed height
		 * in the case of minHeight > maxHeight maxHeight wins as the fixed height)
		 */
		this.fixedHeight	= ( this.options.maxHeight > 0 && ( this.options.minHeight >= this.options.maxHeight ) );
		
		// quit if the image element doesn't exist
		if( typeof this.img == 'undefined' ) return;
				
		// include the stylesheet		
		$A( document.getElementsByTagName( 'script' ) ).each( 
			function(s) {
				if( s.src.match( /cropper\.js/ ) ) {
					var path 	= s.src.replace( /cropper\.js(.*)?/, '' );
					// '<link rel="stylesheet" type="text/css" href="' + path + 'cropper.css" media="screen" />';
					var style 		= document.createElement( 'link' );
					style.rel 		= 'stylesheet';
					style.type 		= 'text/css';
					style.href 		= path + 'cropper.css';
					style.media 	= 'screen';
					document.getElementsByTagName( 'head' )[0].appendChild( style );
				}
	    	}
	    );   
	
		// calculate the ratio when neccessary
		if( this.options.ratioDim.x > 0 && this.options.ratioDim.y > 0 ) {
			var gcd = this.getGCD( this.options.ratioDim.x, this.options.ratioDim.y );
			this.ratioX = this.options.ratioDim.x / gcd;
			this.ratioY = this.options.ratioDim.y / gcd;
			// dump( 'RATIO : ' + this.ratioX + ':' + this.ratioY + '\n' );
		}
							
		// initialise sub classes
		this.subInitialize();

		// only load the event observers etc. once the image is loaded
		// this is done after the subInitialize() call just in case the sub class does anything
		// that will affect the result of the call to onLoad()
		if( this.img.complete || this.isWebKit ) this.onLoad(); // for some reason Safari seems to support img.complete but returns 'undefined' on the this.img object
		else Event.observe( this.img, 'load', this.onLoad.bindAsEventListener( this) );		
	},
	
	/**
	 * The Euclidean algorithm used to find the greatest common divisor
	 * 
	 * @acces private
	 * @param int Value 1
	 * @param int Value 2
	 * @return int
	 */
	getGCD : function( a , b ) {
		if( b == 0 ) return a;
		return this.getGCD(b, a % b );
	},
	
	/**
	 * Attaches the cropper to the image once it has loaded
	 * 
	 * @access private
	 * @return void
	 */
	onLoad: function( ) {
		/*
		 * Build the container and all related elements, will result in the following
		 *
		 * <div class="imgCrop_wrap">
		 * 		<img ... this.img ... />
		 * 		<div class="imgCrop_dragArea">
		 * 			<!-- the inner spans are only required for IE to stop it making the divs 1px high/wide -->
		 * 			<div class="imgCrop_overlay imageCrop_north"><span></span></div>
		 * 			<div class="imgCrop_overlay imageCrop_east"><span></span></div>
		 * 			<div class="imgCrop_overlay imageCrop_south"><span></span></div>
		 * 			<div class="imgCrop_overlay imageCrop_west"><span></span></div>
		 * 			<div class="imgCrop_selArea">
		 * 				<!-- marquees -->
		 * 				<!-- the inner spans are only required for IE to stop it making the divs 1px high/wide -->
		 * 				<div class="imgCrop_marqueeHoriz imgCrop_marqueeNorth"><span></span></div>
		 * 				<div class="imgCrop_marqueeVert imgCrop_marqueeEast"><span></span></div>
		 * 				<div class="imgCrop_marqueeHoriz imgCrop_marqueeSouth"><span></span></div>
		 * 				<div class="imgCrop_marqueeVert imgCrop_marqueeWest"><span></span></div>			
		 * 				<!-- handles -->
		 * 				<div class="imgCrop_handle imgCrop_handleN"></div>
		 * 				<div class="imgCrop_handle imgCrop_handleNE"></div>
		 * 				<div class="imgCrop_handle imgCrop_handleE"></div>
		 * 				<div class="imgCrop_handle imgCrop_handleSE"></div>
		 * 				<div class="imgCrop_handle imgCrop_handleS"></div>
		 * 				<div class="imgCrop_handle imgCrop_handleSW"></div>
		 * 				<div class="imgCrop_handle imgCrop_handleW"></div>
		 * 				<div class="imgCrop_handle imgCrop_handleNW"></div>
		 * 				<div class="imgCrop_clickArea"></div>
		 * 			</div>	
		 * 			<div class="imgCrop_clickArea"></div>
		 * 		</div>	
		 * </div>
		 */
		var cNamePrefix = 'imgCrop_';
		
		// get the point to insert the container
		var insertPoint = this.img.parentNode;
		
		// apply an extra class to the wrapper to fix Opera below version 9
		var fixOperaClass = '';
		if( this.isOpera8 ) fixOperaClass = ' opera8';
		this.imgWrap = Builder.node( 'div', { 'class': cNamePrefix + 'wrap' + fixOperaClass } );
		
		this.north		= Builder.node( 'div', { 'class': cNamePrefix + 'overlay ' + cNamePrefix + 'north' }, [Builder.node( 'span' )] );
		this.east		= Builder.node( 'div', { 'class': cNamePrefix + 'overlay ' + cNamePrefix + 'east' } , [Builder.node( 'span' )] );
		this.south		= Builder.node( 'div', { 'class': cNamePrefix + 'overlay ' + cNamePrefix + 'south' }, [Builder.node( 'span' )] );
		this.west		= Builder.node( 'div', { 'class': cNamePrefix + 'overlay ' + cNamePrefix + 'west' } , [Builder.node( 'span' )] );
		
		var overlays	= [ this.north, this.east, this.south, this.west ];

		this.dragArea	= Builder.node( 'div', { 'class': cNamePrefix + 'dragArea' }, overlays );
						
		this.handleN	= Builder.node( 'div', { 'class': cNamePrefix + 'handle ' + cNamePrefix + 'handleN' } );
		this.handleNE	= Builder.node( 'div', { 'class': cNamePrefix + 'handle ' + cNamePrefix + 'handleNE' } );
		this.handleE	= Builder.node( 'div', { 'class': cNamePrefix + 'handle ' + cNamePrefix + 'handleE' } );
		this.handleSE	= Builder.node( 'div', { 'class': cNamePrefix + 'handle ' + cNamePrefix + 'handleSE' } );
		this.handleS	= Builder.node( 'div', { 'class': cNamePrefix + 'handle ' + cNamePrefix + 'handleS' } );
		this.handleSW	= Builder.node( 'div', { 'class': cNamePrefix + 'handle ' + cNamePrefix + 'handleSW' } );
		this.handleW	= Builder.node( 'div', { 'class': cNamePrefix + 'handle ' + cNamePrefix + 'handleW' } );
		this.handleNW	= Builder.node( 'div', { 'class': cNamePrefix + 'handle ' + cNamePrefix + 'handleNW' } );
				
		this.selArea	= Builder.node( 'div', { 'class': cNamePrefix + 'selArea' },
			[
				Builder.node( 'div', { 'class': cNamePrefix + 'marqueeHoriz ' + cNamePrefix + 'marqueeNorth' }, [Builder.node( 'span' )] ),
				Builder.node( 'div', { 'class': cNamePrefix + 'marqueeVert ' + cNamePrefix + 'marqueeEast' }  , [Builder.node( 'span' )] ),
				Builder.node( 'div', { 'class': cNamePrefix + 'marqueeHoriz ' + cNamePrefix + 'marqueeSouth' }, [Builder.node( 'span' )] ),
				Builder.node( 'div', { 'class': cNamePrefix + 'marqueeVert ' + cNamePrefix + 'marqueeWest' }  , [Builder.node( 'span' )] ),
				this.handleN,
				this.handleNE,
				this.handleE,
				this.handleSE,
				this.handleS,
				this.handleSW,
				this.handleW,
				this.handleNW,
				Builder.node( 'div', { 'class': cNamePrefix + 'clickArea' } )
			]
		);
				
		this.imgWrap.appendChild( this.img );
		this.imgWrap.appendChild( this.dragArea );
		this.dragArea.appendChild( this.selArea );
		this.dragArea.appendChild( Builder.node( 'div', { 'class': cNamePrefix + 'clickArea' } ) );

		insertPoint.appendChild( this.imgWrap );

		// add event observers
		this.startDragBind 	= this.startDrag.bindAsEventListener( this );
		Event.observe( document, 'mousedown', this.startDragBind );
		
		this.onDragBind 	= this.onDrag.bindAsEventListener( this );
		Event.observe( document, 'mousemove', this.onDragBind );
		
		this.endCropBind 	= this.endCrop.bindAsEventListener( this );
		Event.observe( document, 'mouseup', this.endCropBind );
		
		this.resizeBind		= this.startResize.bindAsEventListener( this );
		this.handles = [ this.handleN, this.handleNE, this.handleE, this.handleSE, this.handleS, this.handleSW, this.handleW, this.handleNW ];
		this.registerHandles( true );
		
		if( this.options.captureKeys ) {
			this.keysBind = this.handleKeys.bindAsEventListener( this );
			Event.observe( document, 'keypress', this.keysBind );
		}

		// attach the dragable to the select area
		new CropDraggable( this.selArea, { drawMethod: this.moveArea.bindAsEventListener( this ) } );
		
		this.setParams();
	},
	
	/**
	 * Manages adding or removing the handle event handler and hiding or displaying them as appropriate
	 * 
	 * @access private
	 * @param boolean registration true = add, false = remove
	 * @return void
	 */
	registerHandles: function( registration ) {	
		for( var i = 0; i < this.handles.length; i++ ) {
			var handle = $( this.handles[i] );
			
			if( registration ) {
				var hideHandle	= false;	// whether to hide the handle
				
				// disable handles asappropriate if we've got fixed dimensions
				// if both dimensions are fixed we don't need to do much
				if( this.fixedWidth && this.fixedHeight ) hideHandle = true;
				else if( this.fixedWidth || this.fixedHeight ) {
					// if one of the dimensions is fixed then just hide those handles
					var isCornerHandle	= handle.className.match( /([S|N][E|W])$/ )
					var isWidthHandle 	= handle.className.match( /(E|W)$/ );
					var isHeightHandle 	= handle.className.match( /(N|S)$/ );
					if( isCornerHandle ) hideHandle = true;
					else if( this.fixedWidth && isWidthHandle ) hideHandle = true;
					else if( this.fixedHeight && isHeightHandle ) hideHandle = true;
				}
				if( hideHandle ) handle.hide();
				else Event.observe( handle, 'mousedown', this.resizeBind );
			} else {
				handle.show();
				Event.stopObserving( handle, 'mousedown', this.resizeBind );
			}
		}
	},
		
	/**
	 * Sets up all the cropper parameters, this can be used to reset the cropper when dynamically
	 * changing the images
	 * 
	 * @access private
	 * @return void
	 */
	setParams: function() {
		/**
		 * @var int
		 * The image width
		 */
		this.imgW = this.imageWidth;
		/**
		 * @var int
		 * The image height
		 */
		this.imgH = this.imageHeight;			

		$( this.north ).setStyle( { height: 0 } );
		$( this.east ).setStyle( { width: 0, height: 0 } );
		$( this.south ).setStyle( { height: 0 } );
		$( this.west ).setStyle( { width: 0, height: 0 } );
		
		// resize the container to fit the image
		$( this.imgWrap ).setStyle( { 'width': this.imgW + 'px', 'height': this.imgH + 'px' } );
		
		// hide the select area
		$( this.selArea ).hide();
						
		// setup the starting position of the select area
		var startCoords = { x1: 0, y1: 0, x2: 0, y2: 0 };
		var validCoordsSet = false;
		
		// display the select area 
		if( this.options.onloadCoords != null ) {
			// if we've being given some coordinates to 
			startCoords = this.cloneCoords( this.options.onloadCoords );
			validCoordsSet = true;
		} else if( this.options.ratioDim.x > 0 && this.options.ratioDim.y > 0 ) {
			// if there is a ratio limit applied and the then set it to initial ratio
			startCoords.x1 = Math.ceil( ( this.imgW - this.options.ratioDim.x ) / 2 );
			startCoords.y1 = Math.ceil( ( this.imgH - this.options.ratioDim.y ) / 2 );
			startCoords.x2 = startCoords.x1 + this.options.ratioDim.x;
			startCoords.y2 = startCoords.y1 + this.options.ratioDim.y;
			validCoordsSet = true;
		}
		
		this.setAreaCoords( startCoords, false, false, 1 );
		
		if( this.options.displayOnInit && validCoordsSet ) {
			this.selArea.show();
			this.drawArea();
			this.endCrop();
		}
		
		this.attached = true;
	},
	
	/**
	 * Removes the cropper
	 * 
	 * @access public
	 * @return void
	 */
	remove: function() {
		if( this.attached ) {
			this.attached = false;
			
			// remove the elements we inserted
			this.imgWrap.parentNode.insertBefore( this.img, this.imgWrap );
			this.imgWrap.parentNode.removeChild( this.imgWrap );
			
			// remove the event observers
			Event.stopObserving( document, 'mousedown', this.startDragBind );
			Event.stopObserving( document, 'mousemove', this.onDragBind );		
			Event.stopObserving( document, 'mouseup', this.endCropBind );
			this.registerHandles( false );
			if( this.options.captureKeys ) Event.stopObserving( document, 'keypress', this.keysBind );
		}
	},
	
	/**
	 * Resets the cropper, can be used either after being removed or any time you wish
	 * 
	 * @access public
	 * @return void
	 */
	reset: function() {
		if( !this.attached ) this.onLoad();
		else this.setParams();
		this.endCrop();
	},
	
	/**
	 * Handles the key functionality, currently just using arrow keys to move, if the user
	 * presses shift then the area will move by 10 pixels
	 */
	handleKeys: function( e ) {
		var dir = { x: 0, y: 0 }; // direction to move it in & the amount in pixels
		if( !this.dragging ) {
			
			// catch the arrow keys
			switch( e.keyCode ) {
				case( 37 ) : // left
					dir.x = -1;
					break;
				case( 38 ) : // up
					dir.y = -1;
					break;
				case( 39 ) : // right
					dir.x = 1;
					break
				case( 40 ) : // down
					dir.y = 1;
					break;
			}
			
			if( dir.x != 0 || dir.y != 0 ) {
				// if shift is pressed then move by 10 pixels
				if( e.shiftKey ) {
					dir.x *= 10;
					dir.y *= 10;
				}
				
				this.moveArea( [ this.areaCoords.x1 + dir.x, this.areaCoords.y1 + dir.y ] );
				Event.stop( e ); 
			}
		}
	},
	
	/**
	 * Calculates the width from the areaCoords
	 * 
	 * @access private
	 * @return int
	 */
	calcW: function() {
		return (this.areaCoords.x2 - this.areaCoords.x1)
	},
	
	/**
	 * Calculates the height from the areaCoords
	 * 
	 * @access private
	 * @return int
	 */
	calcH: function() {
		return (this.areaCoords.y2 - this.areaCoords.y1)
	},
	
	/**
	 * Moves the select area to the supplied point (assumes the point is x1 & y1 of the select area)
	 * 
	 * @access public
	 * @param array Point for x1 & y1 to move select area to
	 * @return void
	 */
	moveArea: function( point ) {
		// dump( 'moveArea        : ' + point[0] + ',' + point[1] + ',' + ( point[0] + ( this.areaCoords.x2 - this.areaCoords.x1 ) ) + ',' + ( point[1] + ( this.areaCoords.y2 - this.areaCoords.y1 ) ) + '\n' );
		this.setAreaCoords( 
			{
				x1: point[0], 
				y1: point[1],
				x2: point[0] + this.calcW(),
				y2: point[1] + this.calcH()
			},
			true,
			false
		);
		this.drawArea();
	},

	/**
	 * Clones a co-ordinates object, stops problems with handling them by reference
	 * 
	 * @access private
	 * @param obj Coordinate object x1, y1, x2, y2
	 * @return obj Coordinate object x1, y1, x2, y2
	 */
	cloneCoords: function( coords ) {
		return { x1: coords.x1, y1: coords.y1, x2: coords.x2, y2: coords.y2 };
	},

	/**
	 * Sets the select coords to those provided but ensures they don't go
	 * outside the bounding box
	 * 
	 * @access private
	 * @param obj Coordinates x1, y1, x2, y2
	 * @param boolean Whether this is a move
	 * @param boolean Whether to apply squaring
	 * @param obj Direction of mouse along both axis x, y ( -1 = negative, 1 = positive ) only required when moving etc.
	 * @param string The current resize handle || null
	 * @return void
	 */
	setAreaCoords: function( coords, moving, square, direction, resizeHandle ) {
		// dump( 'setAreaCoords (in) : ' + coords.x1 + ',' + coords.y1 + ',' + coords.x2 + ',' + coords.y2 );
		if( moving ) {
			// if moving
			var targW = coords.x2 - coords.x1;
			var targH = coords.y2 - coords.y1;
			
			// ensure we're within the bounds
			if( coords.x1 < 0 ) {
				coords.x1 = 0;
				coords.x2 = targW;
			}
			if( coords.y1 < 0 ) {
				coords.y1 = 0;
				coords.y2 = targH;
			}
			if( coords.x2 > this.imgW ) {
				coords.x2 = this.imgW;
				coords.x1 = this.imgW - targW;
			}
			if( coords.y2 > this.imgH ) {
				coords.y2 = this.imgH;
				coords.y1 = this.imgH - targH;
			}			
		} else {
			// ensure we're within the bounds
			if( coords.x1 < 0 ) coords.x1 = 0;
			if( coords.y1 < 0 ) coords.y1 = 0;
			if( coords.x2 > this.imgW ) coords.x2 = this.imgW;
			if( coords.y2 > this.imgH ) coords.y2 = this.imgH;
			
			// This is passed as null in onload
			if( direction != null ) {
								
				// apply the ratio or squaring where appropriate
				if( this.ratioX > 0 ) this.applyRatio( coords, { x: this.ratioX, y: this.ratioY }, direction, resizeHandle );
				else if( square ) this.applyRatio( coords, { x: 1, y: 1 }, direction, resizeHandle );
										
				var mins = [ this.options.minWidth, this.options.minHeight ]; // minimum dimensions [x,y]			
				var maxs = [ this.options.maxWidth, this.options.maxHeight ]; // maximum dimensions [x,y]
		
				// apply dimensions where appropriate
				if( mins[0] > 0 || mins[1] > 0 || maxs[0] > 0 || maxs[1] > 0) {
				
					var coordsTransX 	= { a1: coords.x1, a2: coords.x2 };
					var coordsTransY 	= { a1: coords.y1, a2: coords.y2 };
					var boundsX			= { min: 0, max: this.imgW };
					var boundsY			= { min: 0, max: this.imgH };
					
					// handle squaring properly on single axis minimum dimensions
					if( (mins[0] != 0 || mins[1] != 0) && square ) {
						if( mins[0] > 0 ) mins[1] = mins[0];
						else if( mins[1] > 0 ) mins[0] = mins[1];
					}
					
					if( (maxs[0] != 0 || maxs[0] != 0) && square ) {
						// if we have a max x value & it is less than the max y value then we set the y max to the max x (so we don't go over the minimum maximum of one of the axes - if that makes sense)
						if( maxs[0] > 0 && maxs[0] <= maxs[1] ) maxs[1] = maxs[0];
						else if( maxs[1] > 0 && maxs[1] <= maxs[0] ) maxs[0] = maxs[1];
					}
					
					if( mins[0] > 0 ) this.applyDimRestriction( coordsTransX, mins[0], direction.x, boundsX, 'min' );
					if( mins[1] > 1 ) this.applyDimRestriction( coordsTransY, mins[1], direction.y, boundsY, 'min' );
					
					if( maxs[0] > 0 ) this.applyDimRestriction( coordsTransX, maxs[0], direction.x, boundsX, 'max' );
					if( maxs[1] > 1 ) this.applyDimRestriction( coordsTransY, maxs[1], direction.y, boundsY, 'max' );
					
					coords = { x1: coordsTransX.a1, y1: coordsTransY.a1, x2: coordsTransX.a2, y2: coordsTransY.a2 };
				}
				
			}
		}
		
		// dump( 'setAreaCoords (out) : ' + coords.x1 + ',' + coords.y1 + ',' + coords.x2 + ',' + coords.y2 + '\n' );
		this.areaCoords = coords;
	},
	
	/**
	 * Applies the supplied dimension restriction to the supplied coordinates along a single axis
	 * 
	 * @access private
	 * @param obj Single axis coordinates, a1, a2 (e.g. for the x axis a1 = x1 & a2 = x2)
	 * @param int The restriction value
	 * @param int The direction ( -1 = negative, 1 = positive )
	 * @param obj The bounds of the image ( for this axis )
	 * @param string The dimension restriction type ( 'min' | 'max' )
	 * @return void
	 */
	applyDimRestriction: function( coords, val, direction, bounds, type ) {
		var check;
		if( type == 'min' ) check = ( ( coords.a2 - coords.a1 ) < val );
		else check = ( ( coords.a2 - coords.a1 ) > val );
		if( check ) {
			if( direction == 1 ) coords.a2 = coords.a1 + val;
			else coords.a1 = coords.a2 - val;
			
			// make sure we're still in the bounds (not too pretty for the user, but needed)
			if( coords.a1 < bounds.min ) {
				coords.a1 = bounds.min;
				coords.a2 = val;
			} else if( coords.a2 > bounds.max ) {
				coords.a1 = bounds.max - val;
				coords.a2 = bounds.max;
			}
		}
	},
		
	/**
	 * Applies the supplied ratio to the supplied coordinates
	 * 
	 * @access private
	 * @param obj Coordinates, x1, y1, x2, y2
	 * @param obj Ratio, x, y
	 * @param obj Direction of mouse, x & y : -1 == negative 1 == positive
	 * @param string The current resize handle || null
	 * @return void
	 */
	applyRatio : function( coords, ratio, direction, resizeHandle ) {
		// dump( 'direction.y : ' + direction.y + '\n');
		var newCoords;
		if( resizeHandle == 'N' || resizeHandle == 'S' ) {
			// dump( 'north south \n');
			// if moving on either the lone north & south handles apply the ratio on the y axis
			newCoords = this.applyRatioToAxis( 
				{ a1: coords.y1, b1: coords.x1, a2: coords.y2, b2: coords.x2 },
				{ a: ratio.y, b: ratio.x },
				{ a: direction.y, b: direction.x },
				{ min: 0, max: this.imgW }
			);
			coords.x1 = newCoords.b1;
			coords.y1 = newCoords.a1;
			coords.x2 = newCoords.b2;
			coords.y2 = newCoords.a2;
		} else {
			// otherwise deal with it as if we're applying the ratio on the x axis
			newCoords = this.applyRatioToAxis( 
				{ a1: coords.x1, b1: coords.y1, a2: coords.x2, b2: coords.y2 },
				{ a: ratio.x, b: ratio.y },
				{ a: direction.x, b: direction.y },
				{ min: 0, max: this.imgH }
			);
			coords.x1 = newCoords.a1;
			coords.y1 = newCoords.b1;
			coords.x2 = newCoords.a2;
			coords.y2 = newCoords.b2;
		}
		
	},
	
	/**
	 * Applies the provided ratio to the provided coordinates based on provided direction & bounds,
	 * use to encapsulate functionality to make it easy to apply to either axis. This is probably
	 * quite hard to visualise so see the x axis example within applyRatio()
	 * 
	 * Example in parameter details & comments is for requesting applying ratio to x axis.
	 * 
	 * @access private
	 * @param obj Coords object (a1, b1, a2, b2) where a = x & b = y in example
	 * @param obj Ratio object (a, b) where a = x & b = y in example
	 * @param obj Direction object (a, b) where a = x & b = y in example
	 * @param obj Bounds (min, max)
	 * @return obj Coords object (a1, b1, a2, b2) where a = x & b = y in example
	 */
	applyRatioToAxis: function( coords, ratio, direction, bounds ) {
		var newCoords = Object.extend( coords, {} );
		var calcDimA = newCoords.a2 - newCoords.a1;			// calculate dimension a (e.g. width)
		var targDimB = Math.floor( calcDimA * ratio.b / ratio.a );	// the target dimension b (e.g. height)
		var targB;											// to hold target b (e.g. y value)
		var targDimA;                                		// to hold target dimension a (e.g. width)
		var calcDimB = null;								// to hold calculated dimension b (e.g. height)
		
		// dump( 'newCoords[0]: ' + newCoords.a1 + ',' + newCoords.b1 + ','+ newCoords.a2 + ',' + newCoords.b2 + '\n');
				
		if( direction.b == 1 ) {							// if travelling in a positive direction
			// make sure we're not going out of bounds
			targB = newCoords.b1 + targDimB;
			if( targB > bounds.max ) {
				targB = bounds.max;
				calcDimB = targB - newCoords.b1;			// calcuate dimension b (e.g. height)
			}
			
			newCoords.b2 = targB;
		} else {											// if travelling in a negative direction
			// make sure we're not going out of bounds
			targB = newCoords.b2 - targDimB;
			if( targB < bounds.min ) {
				targB = bounds.min;
				calcDimB = targB + newCoords.b2;			// calcuate dimension b (e.g. height)
			}
			newCoords.b1 = targB;
		}
		
		// dump( 'newCoords[1]: ' + newCoords.a1 + ',' + newCoords.b1 + ','+ newCoords.a2 + ',' + newCoords.b2 + '\n');
			
		// apply the calculated dimensions
		if( calcDimB != null ) {
			targDimA = Math.floor( calcDimB * ratio.a / ratio.b );
			
			if( direction.a == 1 ) newCoords.a2 = newCoords.a1 + targDimA;
			else newCoords.a1 = newCoords.a1 = newCoords.a2 - targDimA;
		}
		
		// dump( 'newCoords[2]: ' + newCoords.a1 + ',' + newCoords.b1 + ','+ newCoords.a2 + ',' + newCoords.b2 + '\n');
			
		return newCoords;
	},
	
	/**
	 * Draws the select area
	 * 
	 * @access private
	 * @return void
	 */
	drawArea: function( ) {	
		/*
		 * NOTE: I'm not using the Element.setStyle() shortcut as they make it 
		 * quite sluggish on Mac based browsers
		 */
		// dump( 'drawArea        : ' + this.areaCoords.x1 + ',' + this.areaCoords.y1 + ',' + this.areaCoords.x2 + ',' + this.areaCoords.y2 + '\n' );
		var areaWidth     = this.calcW();
		var areaHeight    = this.calcH();
		
		/*
		 * Calculate all the style strings before we use them, allows reuse & produces quicker
		 * rendering (especially noticable in Mac based browsers)
		 */
		var px = 'px';
		var params = [
			this.areaCoords.x1 + px, 	// the left of the selArea
			this.areaCoords.y1 + px,		// the top of the selArea
			areaWidth + px,					// width of the selArea
			areaHeight + px,					// height of the selArea
			this.areaCoords.x2 + px,		// bottom of the selArea
			this.areaCoords.y2 + px,		// right of the selArea
			(this.imageWidth - this.areaCoords.x2) + px,	// right edge of selArea
			(this.imageHeight - this.areaCoords.y2) + px	// bottom edge of selArea
		];
				
		// do the select area
		var areaStyle				= this.selArea.style;
		areaStyle.left				= params[0];
		areaStyle.top				= params[1];
		areaStyle.width				= params[2];
		areaStyle.height			= params[3];
			  	
		// position the north, east, south & west handles
		var horizHandlePos = Math.ceil( (areaWidth - 6) / 2 ) + px;
		var vertHandlePos = Math.ceil( (areaHeight - 6) / 2 ) + px;
		
		this.handleN.style.left 	= horizHandlePos;
		this.handleE.style.top 		= vertHandlePos;
		this.handleS.style.left 	= horizHandlePos;
		this.handleW.style.top		= vertHandlePos;
		
		// draw the four overlays
		this.north.style.height 	= params[1];
		
		var eastStyle 				= this.east.style;
		eastStyle.top				= params[1];
		eastStyle.height			= params[3];
		eastStyle.left				= params[4];
	    eastStyle.width				= params[6];
	   
	   	var southStyle 				= this.south.style;
	   	southStyle.top				= params[5];
	   	southStyle.height			= params[7];
	   
	    var westStyle       		= this.west.style;
	    westStyle.top				= params[1];
	    westStyle.height			= params[3];
	   	westStyle.width				= params[0];
	   	
		// call the draw method on sub classes
		this.subDrawArea();
		
		this.forceReRender();
	},
	
	/**
	 * Force the re-rendering of the selArea element which fixes rendering issues in Safari 
	 * & IE PC, especially evident when re-sizing perfectly vertical using any of the south handles
	 * 
	 * @access private
	 * @return void
	 */
	forceReRender: function() {
		if( this.isIE || this.isWebKit) {
			var n = document.createTextNode(' ');
			var d,el,fixEL,i;
		
			if( this.isIE ) fixEl = this.selArea;
			else if( this.isWebKit ) {
				fixEl = document.getElementsByClassName( 'imgCrop_marqueeSouth', this.imgWrap )[0];
				/* we have to be a bit more forceful for Safari, otherwise the the marquee &
				 * the south handles still don't move
				 */ 
				d = Builder.node( 'div', '' );
				d.style.visibility = 'hidden';
				
				var classList = ['SE','S','SW'];
				for( i = 0; i < classList.length; i++ ) {
					el = document.getElementsByClassName( 'imgCrop_handle' + classList[i], this.selArea )[0];
					if( el.childNodes.length ) el.removeChild( el.childNodes[0] );
					el.appendChild(d);
				}
			}
			fixEl.appendChild(n);
			fixEl.removeChild(n);
		}
	},
	
	/**
	 * Starts the resize
	 * 
	 * @access private
	 * @param obj Event
	 * @return void
	 */
	startResize: function( e ) {
		this.startCoords = this.cloneCoords( this.areaCoords );
		
		this.resizing = true;
		this.resizeHandle = Event.element( e ).classNames().toString().replace(/([^N|NE|E|SE|S|SW|W|NW])+/, '');
		// dump( 'this.resizeHandle : ' + this.resizeHandle + '\n' );
		Event.stop( e );
	},
	
	/**
	 * Starts the drag
	 * 
	 * @access private
	 * @param obj Event
	 * @return void
	 */
	startDrag: function( e ) {	
		this.clickCoords = this.getCurPos( e );
		if (this.clickCoords.x >= 0 && this.clickCoords.x <= 425 && this.clickCoords.y >= 0 && this.clickCoords.y <= 380) {
			this.selArea.show();
	
    		this.setAreaCoords( { x1: this.clickCoords.x, y1: this.clickCoords.y, x2: this.clickCoords.x, y2: this.clickCoords.y }, false, false, null );
    	
    		this.dragging = true;
	    	this.onDrag( e ); // incase the user just clicks once after already making a selection
    		Event.stop( e );
    	}
	},
	
	/**
	 * Gets the current cursor position relative to the image
	 * 
	 * @access private
	 * @param obj Event
	 * @return obj x,y pixels of the cursor
	 */
	getCurPos: function( e ) {
		// get the offsets for the wrapper within the document
		var el = this.imgWrap, wrapOffsets = Position.cumulativeOffset( el );
		// remove any scrolling that is applied to the wrapper (this may be buggy) - don't count the scroll on the body as that won't affect us
		while( el != null && el.nodeName != 'BODY' ) {
			wrapOffsets[1] -= el.scrollTop  || 0;
			wrapOffsets[0] -= el.scrollLeft || 0;
			el = el.parentNode;
	    }		
		return curPos = { 
			x: Event.pointerX(e) - wrapOffsets[0],
			y: Event.pointerY(e) - wrapOffsets[1]
		}
	},
  	
  	/**
  	 * Performs the drag for both resize & inital draw dragging
  	 * 
  	 * @access private
	 * @param obj Event
	 * @return void
	 */
  	onDrag: function( e ) {
  		if( this.dragging || this.resizing ) {	
  		
  			var resizeHandle = null;
  			var curPos = this.getCurPos( e );			
			var newCoords = this.cloneCoords( this.areaCoords );
  			var direction = { x: 1, y: 1 };
  	  					
		    if( this.dragging ) {
		    	if( curPos.x < this.clickCoords.x ) direction.x = -1;
		    	if( curPos.y < this.clickCoords.y ) direction.y = -1;
		    	
				this.transformCoords( curPos.x, this.clickCoords.x, newCoords, 'x' );
				this.transformCoords( curPos.y, this.clickCoords.y, newCoords, 'y' );
			} else if( this.resizing ) {
				resizeHandle = this.resizeHandle;			
				// do x movements first
				if( resizeHandle.match(/E/) ) {
					// if we're moving an east handle
					this.transformCoords( curPos.x, this.startCoords.x1, newCoords, 'x' );	
					if( curPos.x < this.startCoords.x1 ) direction.x = -1;
				} else if( resizeHandle.match(/W/) ) {
					// if we're moving an west handle
					this.transformCoords( curPos.x, this.startCoords.x2, newCoords, 'x' );
					if( curPos.x < this.startCoords.x2 ) direction.x = -1;
				}
									
				// do y movements second
				if( resizeHandle.match(/N/) ) {
					// if we're moving an north handle	
					this.transformCoords( curPos.y, this.startCoords.y2, newCoords, 'y' );
					if( curPos.y < this.startCoords.y2 ) direction.y = -1;
				} else if( resizeHandle.match(/S/) ) {
					// if we're moving an south handle
					this.transformCoords( curPos.y, this.startCoords.y1, newCoords, 'y' );	
					if( curPos.y < this.startCoords.y1 ) direction.y = -1;
				}	
							
			}
		
			this.setAreaCoords( newCoords, false, e.shiftKey, direction, resizeHandle );
			this.drawArea();
			Event.stop( e ); // stop the default event (selecting images & text) in Safari & IE PC
		}
	},
	
	/**
	 * Applies the appropriate transform to supplied co-ordinates, on the
	 * defined axis, depending on the relationship of the supplied values
	 * 
	 * @access private
	 * @param int Current value of pointer
	 * @param int Base value to compare current pointer val to
	 * @param obj Coordinates to apply transformation on x1, x2, y1, y2
	 * @param string Axis to apply transformation on 'x' || 'y'
	 * @return void
	 */
	transformCoords : function( curVal, baseVal, coords, axis ) {
		var newVals = [ curVal, baseVal ];
		if( curVal > baseVal ) newVals.reverse();
		coords[ axis + '1' ] = newVals[0];
		coords[ axis + '2' ] = newVals[1];		
	},
	
	/**
	 * Ends the crop & passes the values of the select area on to the appropriate 
	 * callback function on completion of a crop
	 * 
	 * @access private
	 * @return void
	 */
	endCrop : function() {
		this.dragging = false;
		this.resizing = false;
		
		this.options.onEndCrop(
			this.areaCoords,
			{
				width: this.calcW(), 
				height: this.calcH() 
			}
		);
	},
	
	/**
	 * Abstract method called on the end of initialization
	 * 
	 * @access private
	 * @abstract
	 * @return void
	 */
	subInitialize: function() {},
	
	/**
	 * Abstract method called on the end of drawArea()
	 * 
	 * @access private
	 * @abstract
	 * @return void
	 */
	subDrawArea: function() {}
};




/**
 * Extend the Cropper.Img class to allow for presentation of a preview image of the resulting crop,
 * the option for displayOnInit is always overridden to true when displaying a preview image
 * 
 * Usage:
 * 	@param obj Image element to attach to
 * 	@param obj Optional options:
 * 		- see Cropper.Img for base options
 * 		
 * 		- previewWrap obj
 * 			HTML element that will be used as a container for the preview image		
 */
Cropper.ImgWithPreview = Class.create();

Object.extend( Object.extend( Cropper.ImgWithPreview.prototype, Cropper.Img.prototype ), {
	
	/**
	 * Implements the abstract method from Cropper.Img to initialize preview image settings.
	 * Will only attach a preview image is the previewWrap element is defined and the minWidth
	 * & minHeight options are set.
	 * 
	 * @see Croper.Img.subInitialize
	 */
	subInitialize: function() {
		/**
		 * Whether or not we've attached a preview image
		 * @var boolean
		 */
		this.hasPreviewImg = false;
		if( typeof(this.options.previewWrap) != 'undefined' 
			&& this.options.minWidth > 0 
			&& this.options.minHeight > 0
		) {
			/**
			 * The preview image wrapper element
			 * @var obj HTML element
			 */
			this.previewWrap 	= $( this.options.previewWrap );
			/**
			 * The preview image element
			 * @var obj HTML IMG element
			 */
			this.previewImg 	= this.img.cloneNode( false );
			// set the ID of the preview image to be unique
			this.previewImg.id	= 'imgCrop_' + this.previewImg.id;
			
						
			// set the displayOnInit option to true so we display the select area at the same time as the thumbnail
			this.options.displayOnInit = true;

			this.hasPreviewImg 	= true;
			
			this.previewWrap.addClassName( 'imgCrop_previewWrap' );
			
			this.previewWrap.setStyle(
			 { 
			 	width: this.options.minWidth + 'px',
			 	height: this.options.minHeight + 'px'
			 }
			);
			
			this.previewWrap.appendChild( this.previewImg );
		}
	},
	
	/**
	 * Implements the abstract method from Cropper.Img to draw the preview image
	 * 
	 * @see Croper.Img.subDrawArea
	 */
	subDrawArea: function() {
		if( this.hasPreviewImg ) {
			// get the ratio of the select area to the src image
			var calcWidth = this.calcW();
			var calcHeight = this.calcH();
			// ratios for the dimensions of the preview image
			var dimRatio = { 
				x: this.imgW / calcWidth, 
				y: this.imgH / calcHeight 
			}; 
			//ratios for the positions within the preview
			var posRatio = { 
				x: calcWidth / this.options.minWidth, 
				y: calcHeight / this.options.minHeight 
			};
			
			// setting the positions in an obj before apply styles for rendering speed increase
			var calcPos	= {
				w: Math.ceil( this.options.minWidth * dimRatio.x ) + 'px',
				h: Math.ceil( this.options.minHeight * dimRatio.y ) + 'px',
				x: '-' + Math.ceil( this.areaCoords.x1 / posRatio.x )  + 'px',
				y: '-' + Math.ceil( this.areaCoords.y1 / posRatio.y ) + 'px'
			}
			
			var previewStyle 	= this.previewImg.style;
			previewStyle.width 	= calcPos.w;
			previewStyle.height	= calcPos.h;
			previewStyle.left	= calcPos.x;
			previewStyle.top	= calcPos.y;
		}
	}
	
});
/* protoload 0.1 beta by Andreas Kalsch
 * last change: 09.07.2007
 *
 * This simple piece of code automates the creating of Ajax loading symbols.
 * The loading symbol covers an HTML element with correct position and size - example:
 * $('myElement').startWaiting() and $('myElement').stopWaiting()
 */
 
Protoload = {
	// the script to wait this amount of msecs until it shows the loading element
	timeUntilShow: 250,
	
	// opacity of loading element
	opacity: 0.8,

	// Start waiting status - show loading element
	startWaiting: function(element, className, timeUntilShow) {
		if (typeof element == 'string')
			element = document.getElementById(element);
		if (className == undefined)
			className = 'waiting';
		if (timeUntilShow == undefined)
			timeUntilShow = Protoload.timeUntilShow;
		
		element._waiting = true;
		if (!element._loading) {
			var e = document.createElement('div');
			(element.offsetParent || document.body).appendChild(element._loading = e);
			e.style.position = 'absolute';
			try {e.style.opacity = Protoload.opacity;} catch(e) {}
			try {e.style.MozOpacity = Protoload.opacity;} catch(e) {}
			try {e.style.filter = 'alpha(opacity='+Math.round(Protoload.opacity * 100)+')';} catch(e) {}
			try {e.style.KhtmlOpacity = Protoload.opacity;} catch(e) {}
		}
		element._loading.className = className;
		window.setTimeout((function() {
			if (this._waiting) {
				var left = this.positionedOffset()[0],
                	top = this.positionedOffset()[1],
                    width = this.offsetWidth,
                    height = this.offsetHeight,
                    l = this._loading;
                    
				l.style.left = left+'px';
				l.style.top = top+'px';
				l.style.width = width+'px';
				l.style.height = height+'px';
				l.style.display = 'inline';
			}
		}).bind(element), timeUntilShow);
	},
	
	// Stop waiting status - hide loading element
	stopWaiting: function(element) {
		if (element._waiting) {
			element._waiting = false;
			element._loading.parentNode.removeChild(element._loading);
			element._loading = null;
		}
	}/*,
	
	_zIndex: 1000000*/
};

if (Prototype) {
	Element.addMethods(Protoload);
	Object.extend(Element, Protoload);
}
/* *//// FUNCIONES BLIGOO!!!
var BrowserDetect = {
	init: function () {
		this.browser = this.searchString(this.dataBrowser) || "An unknown browser";
		this.version = this.searchVersion(navigator.userAgent)
			|| this.searchVersion(navigator.appVersion)
			|| "an unknown version";
		this.OS = this.searchString(this.dataOS) || "an unknown OS";
	},
	searchString: function (data) {
		for (var i=0;i<data.length;i++)	{
			var dataString = data[i].string;
			var dataProp = data[i].prop;
			this.versionSearchString = data[i].versionSearch || data[i].identity;
			if (dataString) {
				if (dataString.indexOf(data[i].subString) != -1)
					return data[i].identity;
			}
			else if (dataProp)
				return data[i].identity;
		}
	},
	searchVersion: function (dataString) {
		var index = dataString.indexOf(this.versionSearchString);
		if (index == -1) return;
		return parseFloat(dataString.substring(index+this.versionSearchString.length+1));
	},
	dataBrowser: [
		{
			string: navigator.userAgent,
			subString: "Chrome",
			identity: "Chrome"
		},
		{ 	string: navigator.userAgent,
			subString: "OmniWeb",
			versionSearch: "OmniWeb/",
			identity: "OmniWeb"
		},
		{
			string: navigator.vendor,
			subString: "Apple",
			identity: "Safari",
			versionSearch: "Version"
		},
		{
			prop: window.opera,
			identity: "Opera"
		},
		{
			string: navigator.vendor,
			subString: "iCab",
			identity: "iCab"
		},
		{
			string: navigator.vendor,
			subString: "KDE",
			identity: "Konqueror"
		},
		{
			string: navigator.userAgent,
			subString: "Firefox",
			identity: "Firefox"
		},
		{
			string: navigator.vendor,
			subString: "Camino",
			identity: "Camino"
		},
		{		// for newer Netscapes (6+)
			string: navigator.userAgent,
			subString: "Netscape",
			identity: "Netscape"
		},
		{
			string: navigator.userAgent,
			subString: "MSIE",
			identity: "Explorer",
			versionSearch: "MSIE"
		},
		{
			string: navigator.userAgent,
			subString: "Gecko",
			identity: "Mozilla",
			versionSearch: "rv"
		},
		{ 		// for older Netscapes (4-)
			string: navigator.userAgent,
			subString: "Mozilla",
			identity: "Netscape",
			versionSearch: "Mozilla"
		}
	],
	dataOS : [
		{
			string: navigator.platform,
			subString: "Win",
			identity: "Windows"
		},
		{
			string: navigator.platform,
			subString: "Mac",
			identity: "Mac"
		},
		{
			string: navigator.platform,
			subString: "Linux",
			identity: "Linux"
		}
	]

};
BrowserDetect.init();

function isIE6() {
	return BrowserDetect.browser == 'Explorer' && BrowserDetect.version == '6';
}
function enableTinyMCE(editor){
	toggleDisplayElements('embed','none');
	toggleDisplayElements('object','none');
	tinymce.dom.Event.domLoaded = true;
	tinyMCE.execCommand('mceAddControl',false, editor);
}


function toggleDisplayElements(tagName, displayValue){
	var elements = document.getElementsByTagName(tagName);	
	for(i=0;i<elements.length;i++)
		elements[i].style.display = displayValue;
}


var blogId = 0;


function tr(key){
	var value;
        var myAjax = new Ajax.Request(
		'/bligoo/ajaxproxy', 
		{	method: 't'
		,	parameters: {key: key}
		, 	asynchronous: false
		, 	onComplete: function(transport){
                value = transport.responseText;
			}
		});
	return value;
}


function customURLConverter(url, node, on_save) {
    if(url.substring(0,7) != 'http://' && url.substring(0,7) != 'mailto:' && url.substring(0,8) != 'https://' && url.substring(0,6) != 'ftp://'){
         index = url.indexOf('/');
	        if(index >= 0)
	            s = url.substring(0, index); 
         else
             s = url;
         if(s.indexOf('.') > 0)
		        url = 'http://' + url; 
     }
     return url; 
}


var SubmitSpinnerButton = Class.create({
	initialize: function(button) {
		this.button = button;
		button.observe('click', this.click.bindAsEventListener(this));
	},
	click: function() {
		this.button.startWaiting('waiting', 0);
	}
});

Event.observe(window, 'unload', function(event) {
		$$('.spinner-submit').each(function(button) { 
										button.enable(); 
								})
		}
);

//parsear la forma {"key1":"val1","key2":"val2",...,"keyn":"valn"}
function evalJSON(s){
	var data = $H();
	s = s.substr(1,s.length-2);
	myRE = new RegExp('"[^"]+"', "ig");
	results = s.match(myRE);
	if(results != undefined){
		for(var i=0; i<results.length; i+=2){
			var l1 = results[i].length;
			var l2 = results[i+1].length;
			var k = results[i].substr(1,l1-2);	
			var v = results[i+1].substr(1,l2-2);
			data[k] = v;
		}
	}
	return data;
} 


function decodeMsg(s){
	return unescape(s.replace(/\+/g,' '));
}

function decodeHTML(html){
	return unescape(html.replace(/\+/g,' '));
}

function addMCEEditor(){
	if($('content-blog')){
	    tinyMCE.selectedInstance = tinyMCE.getInstanceById('edit[content-blog-generic]');
		tinyMCE.execCommand('mceAddControl',false,'content-blog');
		setTimeout("tinyMCE.execCommand('mceFocus', false,'content-blog');", 1);
	}	
}

function disableTinyMCE(id){
	if($(id)){
		var editor = tinyMCE.get(id);
		if (editor) {
			tinyMCE.execCommand('mceFocus', false,id);
			tinyMCE.execCommand('mceRemoveControl',false,id);
		}
	}
}

var previewWindow;
function tryTheme(href, _name){
	previewWindow = window.open(href,_name,previewOptions);
}

function saveHit(path){
	var hitAjax = new Ajax.Request(
		'/bligoo/ajaxproxy',
			{
				method: 'savehit',
				parameters: {path: path}
			});
}
 
var pressed = 0;
function newContent(path){
       if(pressed == 0){
               pressed = 1;
               document.location.href = path;
       }
}

function habilitaWordLimit(){
	var displayType = $('display-type');
	if ( displayType != null ){
		if (displayType.value == 3 || displayType.value == 4){
			$('word-limit').ancestors().first().show();
		} else{
			$('word-limit').ancestors().first().hide();
		}
	}
}


function isEmail(string) {
    if ( string == null || string == '' || string.strip() == ''){
			return false;
	}
	var filter = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;
	return filter.test(string.strip());
}

var CrossImage = Class.create();
CrossImage.prototype = {
	initialize: function (img, executeFunction, paramsFunction) {
		img.observe('mouseover', function(event) { event.target.src='/bligoo/imgbligoo/bligoobar/delete-active.png'; });
		img.observe('mouseout', function(event) { event.target.src='/bligoo/imgbligoo/bligoobar/delete-inactive.png'; });
		img.setStyle('cursor: pointer');
		img.src='/bligoo/imgbligoo/bligoobar/delete-inactive.png';
		if ( executeFunction != null ){
			Event.observe(img, 'click', executeFunction.bindAsEventListener(this, paramsFunction));
		}
	}
}






function urlParameter( name ){
  name = name.replace(/[\[]/,"\\\[").replace(/[\]]/,"\\\]");
  var regexS = "[\\?&]"+name+"=([^&#]*)";
  var regex = new RegExp( regexS );
  var results = regex.exec( window.location.href );
  if( results == null )
    return "";
  return results[1];
}

function set_cookie( name, value, expires, path, domain, secure ) {
	// set time, it's in milliseconds
	var today = new Date();
	today.setTime( today.getTime() );

	/*
	if the expires variable is set, make the correct 
	expires time, the current script below will set 
	it for x number of days, to make it for hours, 
	delete * 24, for minutes, delete * 60 * 24
	*/
	if ( expires ){
		expires = expires * 1000 * 60 * 60 * 24;
	}
	var expires_date = new Date( today.getTime() + (expires) );

	document.cookie = name + "=" +escape( value ) +
	( ( expires ) ? ";expires=" + expires_date.toGMTString() : "" ) + 
	( ( path ) ? ";path=" + path : "" ) + 
	( ( domain ) ? ";domain=" + domain : "" ) +
	( ( secure ) ? ";secure" : "" );
}
	
function setCookie(c_name,value,expiredays){
	var exdate=new Date();
	exdate.setDate(exdate.getDate()+expiredays);
	document.cookie=c_name+ "=" +escape(value)+
	((expiredays==null) ? "" : ";expires="+exdate.toGMTString());
}

function getCookie(c_name){
	if (document.cookie.length>0){
		c_start=document.cookie.indexOf(c_name + "=");
		if (c_start!=-1){ 
			c_start=c_start + c_name.length+1; 
			c_end=document.cookie.indexOf(";",c_start);
    		if (c_end==-1){ 
    			c_end=document.cookie.length;
    		}
    		return unescape(document.cookie.substring(c_start,c_end));
    	} 
  	}
	return "";
}		
			
// this fixes an issue with the old method, ambiguous values 
// with this test document.cookie.indexOf( name + "=" );
function get_cookie( check_name ) {
	// first we'll split this cookie up into name/value pairs
	// note: document.cookie only returns name=value, not the other components
	var a_all_cookies = document.cookie.split( ';' );
	var a_temp_cookie = '';
	var cookie_name = '';
	var cookie_value = '';
	var b_cookie_found = false; // set boolean t/f default f
	
	for ( i = 0; i < a_all_cookies.length; i++ )
	{
		// now we'll split apart each name=value pair
		a_temp_cookie = a_all_cookies[i].split( '=' );
		
		
		// and trim left/right whitespace while we're at it
		cookie_name = a_temp_cookie[0].replace(/^\s+|\s+$/g, '');
	
		// if the extracted name matches passed check_name
		if ( cookie_name == check_name )
		{
			b_cookie_found = true;
			// we need to handle case where cookie has no value but exists (no = sign, that is):
			if ( a_temp_cookie.length > 1 )
			{
				cookie_value = unescape( a_temp_cookie[1].replace(/^\s+|\s+$/g, '') );
			}
			// note that in cases where cookie is initialized but no value, null is returned
			return cookie_value;
			break;
		}
		a_temp_cookie = null;
		cookie_name = '';
	}
	if ( !b_cookie_found )
	{
		return null;
	}
}		


function trackWizards(window){
	windowId = window.select('input#bligoo-window-step-id')[0];
	if (windowId != null) {
		trackHelper.trackWizard(windowId.value);
	}
}

function initToggleCheckBoxes() {
	$$('.toggle-check').each(function(e) {
            if (e.hasClassName('toggle-check-enable')) {
                    var id = e.id.substring(13);
                    var selector = '#' + id + ' input';
                    e.observe('click', function(event) {
                            $$(selector).each( function(check) {
                                            check.checked = true;
                                    });
                    });
            } else if (e.hasClassName('toggle-check-disable')) {
                    var id = e.id.substring(16);
                    var selector = '#' + id + ' input';
                    e.observe('click', function(event) {
                            $$(selector).each( function(check) {
                                            check.checked = false;
                                    });
                    });
            }
	});
}

var LimitedCheckeables  = Class.create();
LimitedCheckeables.prototype = {
	initialize: function(element){
		this.element = element;
		this.counter = 0;
		var limit = -1;
		element.classNames().each(function(c) {
			if (c.indexOf('max-checkeable-limit') > -1) {
				limit = parseInt(c.split('-')[3]);
			}
		});
		this.limit = limit;
		var parent = this;
        $$('#' + element.id + ' input[type="checkbox"]').each(function (check) { check.observe('click', parent.updateCounter.bindAsEventListener(parent, check));});
	},
    updateCounter: function(event, check) {
            if (check.checked) {
                    this.counter++;
            } else {
                    this.counter--;
            }
            if (this.limit > 0) {
                    if (this.counter >= this.limit) {
                            this.disableUnchecked();
                    } else {
                            this.enableAll();
                    }
            }
    },
    enableAll: function() {
            $$('#' + this.element.id + ' input[type="checkbox"]').each(function (check) { check.disabled = false; });
    },
    disableUnchecked: function() {
            $$('#' + this.element.id + ' input[type="checkbox"]').each(function (check) { if (!check.checked) { check.disabled = true;} });
    }
}


var SubmitStopperClass = new Class.create({
	initialize: function(formId) {
	    $(formId).stopObserving('keydown');
		$(formId).observe('keydown', this.watch.bindAsEventListener(this));
	},
	watch: function(event) {
		if (event.keyCode == 13 && event.target.type != 'textarea' ) { 
			event.stop(); 
			if (event.target.type == 'select' || event.target.type == 'select-one'){
				return;
			}
		}
	}
});

document.observe("page:loaded", function() {
	if ( $('close-messages-link') != null ){
		$('close-messages-link').observe('click', function (e){
			closeBligooMessages();
		});
	}
	
	$$('.spinner-submit').each(function(button) {
		new SubmitSpinnerButton(button);
	});
});

function closeBligooMessages(){
	Effect.BlindUp('message-container',{ duration: 0.5 });
}

function enableColorPicker(selector){
	$$(selector).each(
		function(e){
			var options = {};
			if($(e.id+'-swatch') != null){
				options = {swatch: e.id+'-swatch'};
			}
			var picker = new Control.ColorPicker(e.id, options);
			if ( $('button-enviar') != null ){
				Event.observe($('button-enviar'), "click", function(e){ if(picker.isOpen) {	picker.close(e); } });
			}
		}
	);
}

if (isIE6()) {
	setInterval('document.fire("bligoo:updatefixed")', 100);
}


function displaySiteMessage(msg, closeMsg){
	removeSiteMessage()
	var msgHtml = "<div id='message-container'><div id='alerts' class='messages'><a name='alerts'/>"
	msgHtml += "<ul><li>"+msg+"</li></ul>";
	msgHtml += "<div id='close-message'><a id='close-messages-link' href='javascript:void(0);'>"+closeMsg+"</a>";
	msgHtml += "</div></div>";
	$('main-body').insert({top:msgHtml});
	enableSiteMessageClose();
}
function enableSiteMessageClose(){
	if ( $('close-messages-link') != null ){
		$('close-messages-link').observe('click', function (e){
			closeBligooMessages();
		});
	}
}
function removeSiteMessage(){
	if ( $('message-container') != null ){
		$('message-container').remove();
	}
}

function jsredirect(path){
	location.href = path;
}

function callJSApi(method, parameters) {
	var value;
	new Ajax.Request('/bligoo/apiproxy', 
		{	method: 'jsAPI'
		,	parameters: $H({ callback: method}).merge(parameters)
		, 	asynchronous: false
		, 	onComplete: function(transport){
                value = transport.responseText;
			}
		});
	return value;
}

var TrackHelperClass  = Class.create({
        initialize: function(element){
        this.trackingEvents = $H({
                'mybligoo' : {
                        category: 'portada'
                        , selectors: [    {exp: '#menu-avatar', action: 'Ver mi perfil'}
                        				, {exp: '.bligoo-block-online-users img', action: 'Ver perfil'}
                        				, {exp: '.bligoo-mybligoo-main-user-feed #meta-block-tab-0', action: 'Feed Todos'}
                        				, {exp: '.bligoo-mybligoo-main-user-feed #meta-block-tab-1', action: 'Feed Tus contactos'}
                        				]
                        }
                });
        },
        trackPage: function(page){
                var info = this.trackingEvents.get(page);
                if (info != null) {
                        info.selectors.each(function(selector) {
                                $$(selector.exp).each(function(match) {
                                       	match.observe('click', this.click.bindAsEventListener(this, info.category, selector, page));
                                }.bind(this));
                        }.bind(this));
                        bligooTracker._trackEvent(info.category, 'inicio', page);
                }
        },
        click: function(event, category, selector, page) {
				bligooTracker._trackEvent(category, selector.action, page);
        },
        trackWizard: function(windowUrl){
        	if (windowUrl != null && windowUrl != '' && windowUrl != undefined) {
				bligooTracker._trackPageview('/window/' + windowUrl);
        	}
        }
});

var trackHelper = new TrackHelperClass();

function initTrackingEvents(events) {
       	events.each(function(e) {
                if ($(e.key) != null) {
                        $(e.key).observe('click', function(element) {
                                alert(e.value.category);
                        });
                }
        });
}

function addTrackingEvent(id, values) {
   if ($(id) != null) {
            $(id).observe('click', function(element) {
                    alert(values.category);
            });
    }
}
/*
function initDebug() {
      $('main-body').insert('<div id="debug" style="overflow: auto; height: 600px; float: left; position: absolute; left: 0 ; top: 0; color: red; background: black;">debug</div>');
}
function d(s) {
        $('debug').update($('debug').innerHTML + '<br>' + s);
}
initDebug();

d('hola');
*/




var BligooPluginClass = Class.create({
	initialize: function() {
	}
});

var PluginManagerClass = Class.create({
	initialize: function() {
		this.plugins = [];
	},
	add: function(plugin) {
		this.plugins[this.plugins.length] = plugin;
	},
	init: function() {
		this.plugins.each(function(plugin) {
			plugin.init();
		});
	}
});
var PluginManager = new PluginManagerClass();

function getTinyMCEConfig(key){
	var commonConfig = {
		pagebreak_separator : '<!--break-->',
	   	urlconverter_callback : 'customURLConverter',
	   	relative_urls : false,
	   	theme : 'advanced',
	   	theme_advanced_toolbar_location : 'top',
		convert_urls : true,
		remove_linebreaks : false,
		valid_elements : '*[*]',
		font_size_style_values : '8pt,10pt,12pt,14pt,18pt,24pt,36pt',
		editor_selector : 'bligoo-nb-rich-textarea',
		plugins : 'safari,bligooimages,externalcode,youtube,vimeo,fileupload,pagebreak,flash,paste',
		invalid_elements : 'script,iframe',
		accessibility_focus : false,
		strict_loading_mode : 1,
		theme : 'advanced',
		mode : 'none',
		language : userLanguage
	};
	commonConfig = $H(commonConfig);
	if (key == 'genericBar'){
		return commonConfig.merge({	width: '600',
			theme_advanced_buttons1 : 'link,|,bold,italic,strikethrough,fontsizeselect,|,justifyleft,justifycenter,justifyright,justifyfull,|,forecolor,bullist,numlist,code',
			theme_advanced_buttons2 : '',
			theme_advanced_buttons3 : ''}).toObject();
	} else if ( key == 'blidgets' ){
		return commonConfig.merge({	width: '360',
			theme_advanced_buttons1 : 'link,|,bold,italic,strikethrough,fontsizeselect,|,bullist,numlist,code',
			theme_advanced_buttons2 : 'justifyleft,justifycenter,justifyright,justifyfull,forecolor'+((mediaEnabled)?',bligooimages,youtube,vimeo,flash,fileupload,externalcode':''),
			theme_advanced_buttons3 : ''}).toObject();
	} else if ( key == 'headerAndFooter' ){
		return commonConfig.merge({	width: '600',
			theme_advanced_buttons1 : 'link,|,bold,italic,strikethrough,fontsizeselect,|,bullist,numlist,code',
			theme_advanced_buttons2 : 'justifyleft,justifycenter,justifyright,justifyfull,forecolor'+((mediaEnabled)?',bligooimages,youtube,vimeo,flash,fileupload,externalcode':''),
			theme_advanced_buttons3 : ''}).toObject();
	} else if ( key == 'genericWindow' ){
		return commonConfig.merge({	width: '440',
			theme_advanced_buttons1 : 'link,|,bold,italic,strikethrough,fontsizeselect,|,justifyleft,justifycenter,justifyright,justifyfull,|,forecolor,bullist,numlist,code',
			theme_advanced_buttons2 : '',
			theme_advanced_buttons3 : ''}).toObject();
	} 
}


var CorePluginClass = Class.create(BligooPluginClass, {
	init: function() {
		document.observe("bligoowindow:content-replaced", function(event) {
		 	initToggleCheckBoxes();
		 	trackWizards(event.target);
			$$('.limited-checkeables-inputs').each(function (e) {
					new LimitedCheckeables(e);
			});
			
			if (event.memo.window.id == 'bligoo-window-new-user-wizard' || event.memo.window.id == 'bligoo-window-community-subscribe') {
				if ($('new-password-1') != null) {
					new PasswordCheckerClass($('new-password-1'), $('new-password-2'));
				}
			}  
		});
		document.observe("page:loaded", function() {
			var hint = $$('.bligoo-hint').first();
			if ( hint != null ){
				new BligooTooltipClass($(hint), hint.getAttribute("bligooHintText"), {direction: BligooTooltipClass.TOP, width: 200});
			}
			
		});
	}
});

PluginManager.add(new CorePluginClass());__BLIGOO_BAR_BUSY = false;

var BligooBarAppletManagerClass = Class.create();
BligooBarAppletManagerClass.prototype = {
        initialize: function() {
	        $$('.bligoo-bar-applet').each(function(applet) {
	        	applet.observe('mouseover', this.mouseOver.bindAsEventListener(this, applet));
	        	applet.observe('mouseout', this.mouseOut.bindAsEventListener(this, applet));
	        	applet.select('.bligoo-bar-applet-text').each(function(child) {
		        	child.observe('mouseover', this.mouseOver.bindAsEventListener(this, applet));
		        	child.observe('mouseout', this.mouseOut.bindAsEventListener(this, applet));
	        	}.bind(this));
	        }.bind(this));
        },
        mouseOver: function(event, applet) {
        	if (applet.hasClassName('bligoo-bar-applet')) {
        		applet.addClassName('bligoo-bar-applet-over');
        	}
        },
        mouseOut: function(event, applet) {
	        if (applet.hasClassName('bligoo-bar-applet')) {
    	    	applet.removeClassName('bligoo-bar-applet-over');
    	    }
        }
}

var BligooBarClass = Class.create();
BligooBarClass.prototype = {
        initialize: function(initPath, pagePath){
                this.barWrapper = $('bligoo-bar-wrapper');
                this.bar = $('bligoo-bar');
                this.pagePath = pagePath;
                this.watchMsgConfirm = null;
                this.watchCBfunction = null;
                this.myBligoo = $('bligoo-bar-button-mybligoo');
                this.panel = new BligooBarPanelClass(this);
                this.myBligoo.observe('click', this.myBligooClick.bindAsEventListener(this));
                this.myBligoo.observe('mouseover', this.setMouseOver.bindAsEventListener(this));
                this.myBligoo.observe('mouseout', this.setMouseOut.bindAsEventListener(this));
         	    if (isIE6()) {
	        		this.updatePosition();
		        	Event.observe(window, 'scroll', this.updatePosition.bindAsEventListener(this));
				}
				new BligooBarAppletManagerClass();
				this.barWrapper.fire('bligoobar:initialized', this);
				if (initPath != ''){
					this.openPath(initPath.replace('-', '/'));
				}
        },
        updatePosition: function() {
			var offsets =  document.viewport.getScrollOffsets();
	        var wrapper = $('bligoo-bar-wrapper');
	        wrapper.absolutize();
	        wrapper.setStyle({'top': (offsets[1] + document.viewport.getHeight() - wrapper.getHeight()) + 'px'});
	        var fullwrapper = $('bligoo-panel-wrapper');
	        fullwrapper.absolutize();
	        fullwrapper.setStyle({'top': (offsets[1] + document.viewport.getHeight() - fullwrapper.getHeight() - 38) + 'px'});
	        
	        var colorpicker = $('colorpicker');
	        if(colorpicker != null){
	        	 colorpicker.absolutize();
	       		 colorpicker.setStyle({'top': (offsets[1] + (document.viewport.getHeight()/2) - colorpicker.getHeight()) + 'px'});
	        }
		},
        myBligooClick: function(e){
				if (e != null) {
					if ( e.target.hasClassName('bligoo-bar-selected') ){
						e.target.removeClassName('bligoo-bar-selected');
					}else{
					    e.target.removeClassName('bligoo-bar-over');
						e.target.addClassName('bligoo-bar-selected');
					}
				}
	            this.panel.toggle();
        },
        setMouseOver: function(e){
	        var element = $(e.target);
			if ( element.tagName == 'SPAN' ){
				element = element.up();
			}
			element.addClassName('bligoo-bar-over');
        },
        setMouseOut: function(e){
	        var element = $(e.target);
			if ( element.tagName == 'SPAN' ){
				element = element.up();
			}
			element.removeClassName('bligoo-bar-over');
        },
        setPanelClosed: function(e){
        	this.myBligoo.removeClassName('bligoo-bar-over');
        	this.myBligoo.removeClassName('bligoo-bar-selected');
        },
        openPath: function(path, extraParams){
        	if ( this.panel == null ){
        		alert('Se ha producido un error con la barra de herramienta Bligoo, intenta recargar');
        	}
			if (this.getWatchMsg() != null ){
        		if ( !confirm(this.getWatchMsg()) ){
        			return;
        		}
        	}
        	if ( this.hasWatchFunction() ){
	        	this.executeWatchCBFunction();
        	}
        	this.setWatch(null, null);
        	if (!this.restartOnMyBligooClick){
	        	this.myBligoo.addClassName('bligoo-bar-selected');
	        	if ( this.openApplet != null ){
	        		this.openApplet.close();
	        	}
	        }else{
		        this.myBligoo.removeClassName('bligoo-bar-selected');
	        }
	        if ( extraParams != undefined && extraParams != null  ){
	        	this.panel.extraParams = $H(extraParams);
	        }
        	this.panel.openPath(path);
        },
        openCallBack: function(path, extraParams){
        	if ( this.barItem != null ){
        		var formParams = $H(this.barItem.form.serialize(true));
			    formParams = formParams.merge(extraParams);
			    this.panel.startWaiting('bigWaiting');
        		this.barItem.getResponse(path, formParams);	
        	}
        },
        setWatch: function(msg, callBackFn){
        	this.watchMsgConfirm = msg;
        	this.watchCBfunction = callBackFn;
        },
        getWatchMsg: function(){
        	if ( this.watchMsgConfirm != null && this.watchMsgConfirm != '' ){
        		return this.watchMsgConfirm;
        	}
        	return null;
        },
        hasWatchFunction: function(){
        	if ( this.watchCBfunction != null ){
        		return true;
        	}
        	return false;
        },
        executeWatchCBFunction: function(){
        	if ( this.watchCBfunction != null ){
        		this.watchCBfunction();
        	}
        },
        disableWatch: function(){
        	this.setWatch(null, null);
        },
        closePanel: function(){
        	if (this.panel.panelWrapper.visible() ){
				this.panel.toggle();
			}
        }
};

var BligooBarPanelClass = Class.create();
BligooBarPanelClass.prototype = {
        initialize: function(parent){
            this.panelWrapper = $('bligoo-panel-wrapper');
            this.tabList = new Array();
            this.tabTitleList = new Array();
            this.pathList = new Array();
            this.parent = parent;
            this.tabPathHash = new Hash(); 
           	this.startPath = null;
           	this.hiddenTabs = new Hash();
           	this.isWaiting = false;
           	this.extraParams = $H({});
           	Event.observe(window, 'resize', this.updatePosition.bind(this));
        },
        startWaiting: function(css){
        	if ( this.isWaiting == false ){
        		this.isWaiting = true;
        		if ( css == null ){
		        	$('bligoo-bar-pane-container').startWaiting('bigWaiting');
		        }else{
		        	$('bligoo-bar-pane-container').startWaiting(css);
		        }
	        }
        	
        },
        stopWaiting: function(){
        	$('bligoo-bar-pane-container').stopWaiting();
        	this.isWaiting = false;
        },
        updatePosition: function(){
        	if ( this.panelWrapper != null ) {
				var width = ( document.viewport.getDimensions().width - 865) / 2;
				this.panelWrapper.setStyle({ 'left': width + 'px' });
				if (isIE6()) {
					this.parent.updatePosition();
				}
			}
        },
        toggle:function(){
        	if ( this.menuJSON == null ){
                this.startPath = 'mybligoo'.split('/');
                this.fullPath = 'mybligoo';
            }else{
                this.startPath = null;
                this.fullPath = null;
            }
            if ( this.panelWrapper.visible() ){
                    this.panelWrapper.hide();
                    this.parent.setPanelClosed();
            }else{
	            this.panelWrapper.show();
	            if ( $('bligoo-panel') == null ){
		            this.drawPanel();
		        }
           		this.open();
            }
        },
        open: function(){
        	if ( this.menuJSON == null ){
            	this.getMenu();
            }else{
	            if ( this.startPath != null && this.validatePath(this.menuJSON)){
	            	this.openTab(this.tabPathHash.get(this.startPath[0]));
				}
            }
            this.updatePosition();
        },
        openPath: function(path){
        	if( path != null ){
	        	this.startPath = path.split('/');
	        	this.fullPath = path;
	        }else{
	        	this.startPath = null;
	        }
        	if ( this.panelWrapper.visible() ){
        		this.clearPanel();
        	}
        	this.panelWrapper.show();
            if ( $('bligoo-panel') == null ){
	            this.drawPanel();
	        }
        	this.open();
        },
        validatePath: function(item){
        	if ( item.children != null ){
        		for ( j=0; j<item.children.length; j++ ){
        			var child = item.children[j];
        			if ( this.fullPath == child.path ){
        				return true;
        			}
        			if ( this.fullPath.startsWith(child.path) ){
        				return this.validatePath(child);
        			}
        		}
        	}
   			this.fullPath = null;
   			this.startPath = null;
        	return false;
        },
        clearPanel: function(){
        	this.paneContainer.update();
        },
        getMenu: function(){
        	this.startWaiting();
        	new Ajax.Request('/bligoo/bligoobarproxy', 
				{	method: 'menu'
				,	parameters: {}
				, 	onComplete: this.drawMenu.bind(this)
				});
        },
        drawMenu: function(transport){
			this.menuJSON = transport.responseText.evalJSON();
			this.translations = $H(this.menuJSON.translations);
			if ( this.menuJSON.children != null ){
				var firstLevelChildren = this.menuJSON.children;
				for (i=0; i<firstLevelChildren.length; i++){
					if ( firstLevelChildren[i].hidden != null ){
						this.addTab(firstLevelChildren[i].title, new BligooBarItemClass(firstLevelChildren[i], 1, this.paneContainer, this, null), firstLevelChildren[i].path, true);
					}else{
						this.addTab(firstLevelChildren[i].title, new BligooBarItemClass(firstLevelChildren[i], 1, this.paneContainer, this, null), firstLevelChildren[i].path, false);
					}
				}
			}
			this.drawTabs();
			this.updatePosition();
			if ( this.startPath != null ){
				if (this.validatePath(this.menuJSON)){
					if (this.fullPath == 'mybligoo' ){
						this.openTab(this.tabPathHash.get(this.startPath[0]), this.menuJSON.mybligoo);
					}else{
						this.openTab(this.tabPathHash.get(this.startPath[0]));
					}
				}
			}
			this.stopWaiting();
			this.enableHints($H(this.menuJSON.tips));
        },
        enableHints: function(tips){
        	tips.keys().each(function(key){
        		var elem = $(key);
        		if(elem!=null){
        			elem.setAttribute('bligooHintText', tips.get(key).bligooHintText);
        			elem.setAttribute('bligooHintKey', tips.get(key).bligooHintKey);
        			elem.addClassName(tips.get(key).bligooHintClass);
        		}
				new BligooTooltipClass(elem, elem.getAttribute("bligooHintText"), {direction: BligooTooltipClass.TOP, width: 200});
        	}.bind(this));
        },
        addTab: function(title, pane, path, isHidden){
        	var num = this.tabList.length;
        	this.tabList[num] = pane;
        	this.tabTitleList[this.tabTitleList.length] = title;
            this.pathList[num] = path;
        	this.tabPathHash.set(path,num);
        	if ( isHidden ){
        		this.hiddenTabs.set(num, 1);
        	}
        },
        drawTabs: function(){
        	var ul = Builder.node('ul', {'class': 'bligoo-bar-panel-tabs'});
        	this.tabTitleList.each(function (title,index){
        		var tab = Builder.node('li',{'id': 'bligoo-bar-panel-tab-'+index, 'class': 'bligoo-bar-panel-tab element-selectable bligoo-bar-use-sprite '});
        		if ( this.hiddenTabs.get(index) != null ){
        			tabIcon = Builder.node('div', {'class': 'bligoo-bar-panel-tab-icon bligoo-bar-use-sprite', 'id': 'bligoo-bar-panel-tab-icon-'+this.pathList[index]});
	        		tab.appendChild(Builder.node('div', {'class': 'bligoo-bar-panel-tab-icon-wrapper'}, tabIcon));        			
	        		tab.appendChild(Builder.node('div', {'class': 'bligoo-bar-panel-tab-text'}));        			
        		}else{
	        		tab.appendChild(Builder.node('div', {'class': 'bligoo-bar-panel-tab-icon', 'id': 'bligoo-bar-panel-tab-icon-'+this.pathList[index]}));        			
        			tab.appendChild(Builder.node('div', {'class': 'bligoo-bar-panel-tab-text'},title));        			
        		}
        		tab.appendChild(Builder.node('div', {'class': 'bligoo-bar-panel-tab-right bligoo-bar-use-sprite'} ));
	            ul.appendChild(tab);
        	}.bind(this));
       		var finalTab = Builder.node('li');
       		finalTab.appendChild(Builder.node('div', {'class': 'clear'}));        	
			ul.appendChild(finalTab);
        	$(this.tabContainer).appendChild(ul);
        	this.tabContainer.select('.bligoo-bar-panel-tab.element-selectable').each(function(e){
        		e.observe('click', this.tabClick.bindAsEventListener(this, e));
        		e.observe('mouseover', this.setMouseOver.bindAsEventListener(this, e));
        		e.observe('mouseout', this.setMouseOut.bindAsEventListener(this, e));
        	}.bind(this));
        },
        setMouseOver: function(e, item){
        	if ( item != null ){
				item.addClassName('bligoo-bar-over');
			}
        },
        setMouseOut: function(e, item){
        	if ( item != null ){
				item.removeClassName('bligoo-bar-over');
			}
        },
        tabClick: function(e, tab){
        	var paneId = tab.id.split('-')[4];
        	this.startPath = null;
        	if (this.parent.getWatchMsg() != null ){
        		if ( !confirm(this.parent.getWatchMsg()) ){
        			return;
        		}
        	}
        	if ( this.parent.hasWatchFunction() ){
	        	this.parent.executeWatchCBFunction();
        	}
        	this.parent.setWatch(null, null);
        	this.openTab(paneId);
        },
        openTab: function(paneId, content){
        	this.tabList[paneId].update(content);
        	this.tabContainer.select('.element-selectable.bligoo-bar-panel-tab').each(function(li){
				li.removeClassName('bligoo-bar-selected');
				if ( li.id == 'bligoo-bar-panel-tab-'+paneId ){
					li.addClassName('bligoo-bar-selected');
				}				
        	}.bind(this));
        },
        drawPanel: function(){
        	var panel = Builder.node('div', {'id': 'bligoo-panel', 'class': 'bligoo-panel bligoo-bar-use-sprite'});
        	this.tabContainer = Builder.node('div', {'id': 'bligoo-bar-tabs-container'});
        	panel.appendChild(this.tabContainer);
        	var paneContainerWrapper =  Builder.node('div', {'id': 'bligoo-bar-pane-container-wrapper'});
        	paneContainerWrapper.appendChild( Builder.node('div', {'id': 'bligoo-bar-pane-container', 'class': 'bligoo-bar-pane-level-1'}));
        	panel.appendChild(paneContainerWrapper);
        	this.panelCloseButton = Builder.node('div', {'id': 'bligoo-bar-buttons-container', 'class':  'element-selectable bligoo-bar-use-sprite'});
        	panel.appendChild(this.panelCloseButton);
        	panel.appendChild( Builder.node('div', {'id': 'bligoo-bar-panel-bottom', 'class': 'bligoo-bar-use-sprite'}));
        	
        	this.panelWrapper.appendChild(panel);
        	
        	this.paneContainer = $('bligoo-bar-pane-container');
        	
        	this.panelCloseButton.observe('mouseover', this.setMouseOver.bindAsEventListener(this, this.panelCloseButton));
        	this.panelCloseButton.observe('mouseout', this.setMouseOut.bindAsEventListener(this, this.panelCloseButton));
        	this.panelCloseButton.observe('click', this.closePanel.bindAsEventListener(this));
        },
        closePanel: function(){
        	this.toggle();
        }
};


var BligooBarItemClass = Class.create();
BligooBarItemClass.prototype = {
        initialize: function(menuInfo, level, container, panel, parent){
                this.menuInfo = menuInfo;
                this.level = level;
                this.container = container;
                this.panel = panel;
                this.parent = parent;
                this.containerWidth = 830 - (this.level - 1)*100;
         		this.subContainer = '';
         		this.children = new Array();
         		this.originalContentHeight = 330;
         		
	            this.childLocalPathHash = new Hash();
        },
        update: function(content){
			if (this.panel.parent.getWatchMsg() != null ){
        		if ( !confirm(this.panel.parent.getWatchMsg()) ){
        			return;
        		}
        	}
        	if ( this.panel.parent.hasWatchFunction() ){
	        	this.panel.parent.executeWatchCBFunction();
        	}
        	
        	if ( this.parent != null ) {
        		this.parent.helpButton.hide();
        	}
      		this.panel.parent.setWatch(null, null);
        	this.disableTinyMCE();
            this.updateContainer('');
        	if(this.level > 1){
        		this.container.setStyle('width: '+this.containerWidth+'px;overflow:hidden;left:'+(this.containerWidth - 30)+'px;top:0;background: #fff url(\'/bligoo/imgbligoo/protoload/bigWaiting.gif\') no-repeat center center;');
        		this.container.show();
		        new Effect.Move(this.container,{x:-(this.containerWidth - 130), y:0, mode:'relative', transition: Effect.Transitions.sinoidal, duration: 0.5 , queue: {position: 'end', scope: 'bligoo-bar-menu', limit:2}});
        	} else {
        		this.container.setStyle('overflow:hidden;left:0;top:0;background: #fff url(\'/bligoo/imgbligoo/protoload/bigWaiting.gif\') no-repeat center center;');
        	}
        	if ( content != null ){
        		this.drawResponse(content);
        	}else{
	        	if ( this.menuInfo.children != null ){
	        		this.drawResponse(this.drawChildren());
	        	}else{
	        		if ( this.panel.extraParams == null ) {
		        		this.getResponse(this.menuInfo.path, null);
		        	}else{
		        		this.getResponse(this.menuInfo.path, this.panel.extraParams);
		        		this.panel.extraParams = $H({});
		        	}
	        	} 
	        }
        },
        getResponse: function(path, extraparams) {
        	var params = {path: path};
        	if (this.periodical) {
				this.periodical.stop();
			}
			this.periodical = new PeriodicalExecuter(this.showStillWorkingSign.bind(this), 2);
        	if (extraparams != undefined && extraparams != null) {
        		params = extraparams.merge(params);
        	}
        	new Ajax.Request('/bligoo/bligoobarproxy', 
				{	method: 'path'
				,	parameters: params
				, 	onComplete: this.extractResponse.bind(this)
				});
        },
        extractResponse: function(transport){
        	if ( this.periodical){
	        	this.periodical.stop();
	        }
        	this.drawResponse(transport.responseText);
        },
        drawResponse: function(data) {
                if(this.level > 1){
          			new Effect.Move(this.container, {x:0, y:0, 
          											mode: 'relative', 
          											duration: 0, 
          											queue: {position: 'end', scope: 'bligoo-bar-menu', limit:2}, 
          											afterFinish: function(){
	          												this.container.setStyle('background-image: none;');
	          												this.updateContainer(data);
	          												var barItemContent = $('bligoo-bar-item-content');
															if ( barItemContent != null  ){
																barItemContent.setStyle('overflow-y: auto;');
															}
	          												__BLIGOO_BAR_BUSY = false;
          												}.bind(this)
          											});
          		} else {
          		    this.container.setStyle('background-image: none; overflow-x: hidden; overflow-y: hidden;')
          		    this.container.hide();
     				this.updateContainer(data);
     				new Effect.Appear(this.container, {duration: 0.2, afterFinish: function(e){
     					this.calculateHeight();
     					var barItemContent = $('bligoo-bar-item-content');
						if ( barItemContent != null  ){
							barItemContent.setStyle('overflow-y: auto;');
						}
     				}.bind(this)});
     				__BLIGOO_BAR_BUSY = false;
          		}
        },
        postProcessResponse: function() {
			if ( $('bligoo-bar-menu-item-path') != null ){
				this.realPath = $('bligoo-bar-menu-item-path').value;
			}
        	var forms = this.container.select('.bligoo-bar-menu-item-form');
        	if (forms.length > 0) {
        		this.form = forms[0];
	       		this.form.select('.bligoo-bar-hidden-input').each(function(hidden, index) {
			       		if (hidden.name == 'edit[bligoo-bar-menu-item-form-action]') {
			       			this.action = hidden.value;
			       		}
	       		}.bind(this));
	       		
	       		
				this.container.select('.bligoo-bar-confirm-button').each(function(button) {
	       				button.observe('click', this.confirmAndSubmit.bindAsEventListener(this
	       						, button.getAttribute("bligooPath")
	       						, button.getAttribute("bligooConfirmMessage")
	       						, button.getAttribute("bligooConfirmButton")
	       						, button.getAttribute("bligooCancelButton")));
	       				button.observe('mouseout', this.mouseOutBligooButton.bindAsEventListener(this, button));
	       				button.observe('mouseover', this.mouseOverBligooButton.bindAsEventListener(this, button));
	       				button.addClassName('bligoo-bar-use-sprite');
        		}.bind(this));
	       		
	       		
	       		this.container.select('.bligoo-bar-icon-button').each(function(button) {
        			if (button.hasClassName('bligoo-bar-icon-button-reset')) {
        				button.observe('click', this.resetAndSubmitButtonClick.bindAsEventListener(this, button.getAttribute("bligooPath"), button));
        			}
       				button.observe('mouseout', this.mouseOutBligooButton.bindAsEventListener(this, button));
       				button.observe('mouseover', this.mouseOverBligooButton.bindAsEventListener(this, button));
       				button.addClassName('bligoo-bar-use-sprite');
        		}.bind(this));
	       		
	       		
				this.container.select('.form-button-options').each(function(button) {
	       				button.observe('mouseout', this.mouseOutBligooButton.bindAsEventListener(this, button));
	       				button.observe('mouseover', this.mouseOverBligooButton.bindAsEventListener(this, button));
	       				button.addClassName('bligoo-bar-use-sprite');
        		}.bind(this));
        		
        		this.container.select('.bligoo-bar-button').each(function(button) {
	       				button.observe('mouseout', this.mouseOutBligooButton.bindAsEventListener(this, button));
	       				button.observe('mouseover', this.mouseOverBligooButton.bindAsEventListener(this, button));
	       				button.addClassName('bligoo-bar-use-sprite');
        		}.bind(this));
        		
        		this.container.select('.bligoo-bar-submit-button').each(function(button) {
        			button.observe('click', this.submitButtonClick.bindAsEventListener(this, button.getAttribute("bligooPath"), button));
       				button.observe('mouseout', this.mouseOutBligooButton.bindAsEventListener(this, button));
       				button.observe('mouseover', this.mouseOverBligooButton.bindAsEventListener(this, button));
       				button.addClassName('bligoo-bar-use-sprite');
        		}.bind(this));

        		this.container.select('.bligoo-bar-open-path-button').each(function(button) {
        			button.observe('click', this.openPathButtonClick.bindAsEventListener(this, button.getAttribute("bligooPath"), button));
       				button.observe('mouseout', this.mouseOutBligooButton.bindAsEventListener(this, button));
       				button.observe('mouseover', this.mouseOverBligooButton.bindAsEventListener(this, button));
       				button.addClassName('bligoo-bar-use-sprite');
        		}.bind(this));
        		
        		this.container.select('a.bligoo-bar-ajax-link').each(function(link){
        			link.observe('click', this.ajaxLinkClick.bindAsEventListener(this));			
        		}.bind(this));
        		
        		this.container.select('a.bligoo-bar-open-path-link').each(function(link){
        			link.observe('click', this.ajaxOpenPathLinkClick.bindAsEventListener(this, link));			
        		}.bind(this));
        		
        		var leaveConfirmMsg = this.container.select('#bligoo-bar-menu-item-leave-confirm-msg').first();
	       		var leaveCallbackFn = this.container.select('#bligoo-bar-menu-item-leave-callback-function').first();
	       		if ( leaveConfirmMsg != null ){
		       		this.panel.parent.setWatch(leaveConfirmMsg.value, leaveCallbackFn);
		       	}
        		new SubmitStopperClass('bligoo-bar-menu-item-form');
        	}
        	this.enableTinyMCE();
        	if ( this.level > 1 ){
        		if ( $('bligoo-bar-back-button-status') == null || $('bligoo-bar-back-button-status').value == 'true' ){
		        	$('bligoo-bar-item-buttons').insert({top: this.createBackButton()});
		        }
	        }
         	$('bligoo-bar-item-buttons').insert({top: this.createHelpButton()});
			this.calculateHeight();
			this.panel.parent.barItem = this;
        	this.panel.stopWaiting();
			this.container.fire("bligoobar:leaf-replaced", this.realPath);
        },
        mouseOverBligooButton: function(event, button) {
        	if (!button.hasClassName('bligoo-bar-button-hover')) {
            	button.addClassName('bligoo-bar-button-hover');
            }
        },
        mouseOutBligooButton: function(event, button) {
            if (button.hasClassName('bligoo-bar-button-hover')) {
            	button.removeClassName('bligoo-bar-button-hover');
            }
		},
        addButton: function(value, f){
        	var button = Builder.node('input', {'class': 'bligoo-bar-generic-button', 'type': 'button', 'value': value} );
        	button.observe('click', f.bindAsEventListener(this));
			button.observe('mouseout', this.mouseOutBligooButton.bindAsEventListener(this, button));
   			button.observe('mouseover', this.mouseOverBligooButton.bindAsEventListener(this, button));
        	$('bligoo-bar-item-buttons').appendChild(button);
        },
        addButtons: function(txt){
        	var extraButtons = null;
        	if ($('bligoo-bar-item-buttons').select('#bligoo-bar-item-buttons-extra').first() == null ){
	        	extraButtons = Builder.node('div', {'id': 'bligoo-bar-item-buttons-extra'});
	        	extraButtons.setStyle('margin: 0; padding:0;float:right;');
	        }else{
	        	extraButtons = $('bligoo-bar-item-buttons').select('#bligoo-bar-item-buttons-extra').first();
	        }
	        extraButtons.update(txt);
        	$('bligoo-bar-item-buttons').appendChild(extraButtons);
        	this.observeButtons(extraButtons);
        },
        replaceExtraButtons: function(txt){
        	if ( $('bligoo-bar-item-buttons').select('#bligoo-bar-item-buttons-extra').first() != null ){
        		$('bligoo-bar-item-buttons').select('#bligoo-bar-item-buttons-extra').first().update('');
        	}
        	this.addButtons(txt);
        },
        observeButtons: function(buttonsArea){
        	if ( $(buttonsArea)!= null ){
        		var extraButtons = $(buttonsArea);
        		extraButtons.select('.bligoo-bar-submit-button').each(function(button) {
        			button.observe('click', this.submitButtonClick.bindAsEventListener(this, button.getAttribute("bligooPath"), button));
        		}.bind(this));
        		extraButtons.select('.bligoo-bar-confirm-button').each(function(button) {
	       				button.observe('click', this.confirmAndSubmit.bindAsEventListener(this
	       						, button.getAttribute("bligooPath")
	       						, button.getAttribute("bligooConfirmMessage")
	       						, button.getAttribute("bligooConfirmButton")
	       						, button.getAttribute("bligooCancelButton")));
        		}.bind(this));	
        	}
        },
        ajaxLinkClick: function(e){
        	var link = $(e.target);
        	if ( !link.hasClassName('bligoo-bar-ajax-link') ){
				link = link.up();
			}
        	var params = link.getAttribute("bligooAjaxLinkParams");
        	var path = link.getAttribute("bligooPath");	
        	if (path == null) {
	        	path = this.realPath;
	        } else if ( !path.startsWith('/') ){
	        	path = this.realPath + '/' + path;
	        } else {
	        	path = path.substring(1);
	        }
        	if ( params == "" || params == null ){
        		this.getResponse(path, null);
        		return;
        	}
        	var pSplit = params.split('|');
        	var hparams = new Hash();
        	for(i=0; i< pSplit.length; i++){
        		var pair = pSplit[i].split(':');
        		hparams.set(pair[0], pair[1]);
        	}
        	this.panel.startWaiting('bigWaiting');
       		this.getResponse(path, hparams);
        },
        ajaxOpenPathLinkClick: function(e, link){
        	var params = link.getAttribute("bligooAjaxLinkParams");
        	var path = link.getAttribute("bligooPath");	
        	if (path == null) {
	        	path = this.realPath;
	        } else if ( !path.startsWith('/') ){
	        	path = this.realPath + '/' + path;
	        } else {
	        	path = path.substring(1);
	        }
        	if ( params == "" || params == null ){
        		this.panel.parent.openPath(path, null);
        		return;
        	}
        	var pSplit = params.split('|');
        	var hparams = new Hash();
        	for(i=0; i< pSplit.length; i++){
        		var pair = pSplit[i].split(':');
        		hparams.set(pair[0], pair[1]);
        	}
       		this.panel.parent.openPath(path, hparams);
        },
        updateItemContentHeight: function(e,resize){
        	this.container.select('.bligoo-bar-menu-item-hidden').each(function(div) {
        		div.removeClassName('bligoo-bar-menu-item-hidden');
        	}.bind(this));
			var aux = 0;
			if ( $('bligoo-bar-item-header') != null ){
				aux += $('bligoo-bar-item-header').getHeight();
			}
			if ( $('bligoo-bar-item-footer') != null ){
				aux += $('bligoo-bar-item-footer').getHeight();
			}
			var innerContentHeight = resize - aux;
			var barItemContent = $('bligoo-bar-item-content');
			if ( barItemContent != null  ){
				$('bligoo-bar-item-content').setStyle('overflow-x: hidden; height:'+innerContentHeight+'px;');
			}
			if (isIE6()) {
		    	this.panel.parent.updatePosition();
		    }
			__BLIGOO_BAR_BUSY = false;
        },
        calculateHeight: function(){
        	__BLIGOO_BAR_BUSY = true;
        	var newHeight = this.container.select('#bligoo-bar-height').first();
        	var resize = this.originalContentHeight;
        	if ( newHeight != null ){
				resize = newHeight.value;
        	}
        	var viewportHeight = document.viewport.getDimensions().height;
        	if ( resize > (viewportHeight - (38 + 38 + 49)) ){//panelfooter, barra, tabcontainer
        		resize = viewportHeight - (38 + 38 + 49);
        	}
        	new Effect.Morph($('bligoo-bar-pane-container-wrapper'), {
        		'style': 'height: '+resize+'px', 
        		'duration': 0.1, 
        		'transition': Effect.Transitions.sinoidal, 	
        		'afterFinish': this.updateItemContentHeight.bindAsEventListener(this, resize)
        	});
        },
        backClick: function(e){
			if (this.panel.parent.getWatchMsg() != null ){
        		if ( !confirm(this.panel.parent.getWatchMsg()) ){
        			return;
        		}
        	}
        	if ( this.panel.parent.hasWatchFunction() ){
	        	this.panel.parent.executeWatchCBFunction();
        	}
        	if ( this.parent != null ){
        		this.parent.helpButton.show();
        	}
      		this.panel.parent.setWatch(null, null);
        	var backButton = e.target;
        	__BLIGOO_BAR_BUSY = true;
        	this.cleanParentSelectedMenuOptions();
        	this.updateContainer('');
        	new Effect.Move(this.container, {
        										x:830, y:0, 
      											mode: 'relative', 
      											duration: 0.5, 
      											queue: {
      												position: 'end', scope: 'bligoo-bar-menu', limit:2
      											}, 
      											afterFinish: function(){
      												this.updateContainer('');
      												__BLIGOO_BAR_BUSY = false;
      											}.bind(this)
          									});
        },
        cleanParentSelectedMenuOptions: function(){
        	if ( this.level > 1 ){
        		$$('#bligoo-bar-pane-container-wrapper .bligoo-bar-pane-level-'+(this.level-1)+' li').each(function (item){
        			item.removeClassName('bligoo-bar-selected');
        		}.bind(this));
        	}
        },
        confirmAndSubmit: function(event, path, message, ok, cancel) {
        	if(confirm(message)) {
        		this.panel.startWaiting('bigWaiting');
	        	this.triggerTinyMCE();
        		if (path.startsWith('/')){
	        		this.getResponse(path.substring(1), $H(this.form.serialize(true)));
        		} else {
	        		this.getResponse(this.realPath + '/' + path, $H(this.form.serialize(true)));
	        	}
        	}
        },
        resetAndSubmitButtonClick: function(event, path, button) {
        	this.form.select('#bligoo-bar-filter input').each(function(e) {
        		if (e.type == 'text') {
        			e.value = '';
        		} else if (e.type == 'checkbox') {
        			if (e.getAttribute('bligooDefaultValue') != null) {
        				e.checked = e.getAttribute('bligooDefaultValue') == true;
        			} else {
        				e.checked = false;
        			}
        		}
        		
        	});
        	this.form.select('#bligoo-bar-filter select').each(function(e) {
        		if (e.getAttribute('bligooDefaultValue') != null) {
        			var val =  e.getAttribute('bligooDefaultValue');
        			var options = e.options;
        			for (var i = 0; i < options.length; i++){
						if (options[i].value == val) {
							options[i].selected = true;
						}
					}
        		} else {
	        		e.selectedIndex = 0;
        		}
        	});
        	
        	this.submitButtonClick(event, path, button);
        },
        submitButtonClick: function(event, path, button) {
        	this.panel.startWaiting('bigWaiting');
        	this.triggerTinyMCE();
        	this.disableTinyMCE();
        	if (this.form.action != undefined && this.form.action != null && this.form.action != '') {
	        	if (uploadChecker == null) {
		        	uploadChecker = new UploadCheckerClass();
	        	}
				uploadChecker.start();
        		this.form.submit();
        	} else if (path != null) {
        		var formParams = $H(this.form.serialize(true));
        		if ( button != null ){
				    formParams = formParams.merge({'bligoo-bar-submit-button-value':button.value});
        		}
        		if ( path.startsWith('/') ){
	        		this.getResponse(path.substring(1), formParams);
        		}else{
	        		this.getResponse(this.realPath + '/' + path, formParams);
	        	}
        	} else if (this.action != null) {
        		this.getResponse(this.action, $H(this.form.serialize(true)));
        	}
        }, 
        openPathButtonClick: function(event, path, button) {
			if (path != null) {
        		this.panel.parent.openPath(path, $H({}));
        	} 
        }, 
        redirectIfNeed: function(){
        	if ( this.panel.startPath != null && this.panel.startPath[this.level] != null ){
        		var aux = "bligoo-bar-item";
        		for (i=0; i< this.level; i++){
        			aux+= "-"+this.panel.startPath[i];
        		}
        		aux +="-"+(this.level+1)+"-"+this.childLocalPathHash.get(this.panel.startPath[this.level]);
        		if ( $(aux) != null ){
	        		$(aux).addClassName('bligoo-bar-selected');
	        	}
				this.children[this.childLocalPathHash.get(this.panel.startPath[this.level])].update();
			}else{
				this.panel.startPath = null;
			}
        },
        updateContainer: function(data){
        	if(data.tagName != undefined){
        		this.container.appendChild(data);
        		this.redirectIfNeed();
        	} else {
	        	this.container.innerHTML = data.gsub(/__script__/i, 'script');
	        	data.evalScripts();
	        }
	        if(data != '' && this.level > 1){
	            this.container.setStyle('width: ' + this.containerWidth + 'px');
	        	if(this.container.getWidth() != this.containerWidth){
	        	    var delta = this.container.getWidth() - this.containerWidth + (this.level>2?this.level - 1:0);
	        		this.container.setStyle('width: ' + (this.container.getWidth() - delta * 2) + 'px');
	        	}
	        }
	        if(data.tagName == undefined && data!=''){
	        	this.postProcessResponse();
	        }
        },
        drawChildren: function(){
        	this.subContainer = Builder.node('div', 
        										{'id': 'bligoo-bar-path-'+this.menuInfo.path.replace('/', '-')
        										, 'class': 'bligoo-bar-pane-level-' + (this.level + 1 ) + ' bligoo-bar-content-data'
        									});
            this.subContainer.hide();
            var ul = Builder.node('ul');
            this.menuInfo.children.each(function (child, index){
                var itemIcon = Builder.node('div', {'class': 'bligoo-bar-item-icon bligoo-bar-use-sprite', 'id': 'bligoo-bar-item-icon-' + child.path.replace(/\//g,"-")});                
                var itemEnd = Builder.node('div', {'class': 'bligoo-bar-item-end bligoo-bar-use-sprite'});
                var a = Builder.node('a', {'href': 'javascript: void(0);'}, child.title);
                var li = Builder.node('li', {'id': 'bligoo-bar-item-'+this.menuInfo.path.replace('/', '-')+'-'+(this.level+1)+'-'+index, 'class': 'element-selectable bligoo-bar-use-sprite', 'title': child.title});
                li.appendChild(itemIcon);
                li.appendChild(a);
                li.appendChild(itemEnd);
				li.observe('click', this.clickItem.bindAsEventListener(this));
				li.observe('mouseover', this.setMouseOver.bindAsEventListener(this));
				li.observe('mouseout', this.setMouseOut.bindAsEventListener(this));
                ul.appendChild(li);
                this.children[index] = new BligooBarItemClass(child, this.level+1, this.subContainer, this.panel, this);
                this.childLocalPathHash.set(child.path.split('/')[this.level], index);
            }.bind(this));
            var ret = Builder.node('div');
            var title = Builder.node('h1', {}, this.menuInfo.title);
            var headerDiv = Builder.node('div', {'class': 'bligoo-bar-item-header'});
            headerDiv.appendChild(title);
           	ret.appendChild(headerDiv);
            ret.appendChild(ul);
            
            
            var buttonsContainer = Builder.node('div', {'class': 'bligoo-bar-branch-buttons-container'});
            if ( this.level > 1 ){
	        	buttonsContainer.insert({top: this.createBackButton()});
	        }
        	        	
        	buttonsContainer.insert({top: this.createHelpButton()});
        	ret.appendChild(buttonsContainer);
            ret.appendChild(this.subContainer);
            this.panel.parent.barItem = null;
            return ret;
        },
        createBackButton: function() {
        	var button = Builder.node('input', {'class': 'bligoo-bar-back-button bligoo-bar-use-sprite', 'type': 'button', 'value': this.t('back')} );
	        button.observe('click', this.backClick.bindAsEventListener(this));
	        button.observe('mouseover', this.mouseOverCustom.bindAsEventListener(this, button, 'back-button'));
			button.observe('mouseout', this.mouseOutCustom.bindAsEventListener(this, button, 'back-button'));
			return button;
		},
        createHelpButton: function() {
           	var helpLink = Builder.node('a', {'class': 'bligoo-bar-help-link', 'href': 'javascript:void(0);'}, this.t('help'));
        	var helpImg = Builder.node('div', {'class': 'bligoo-bar-help-img bligoo-bar-use-sprite'});
        	var button = Builder.node('div', {'class': 'bligoo-bar-help-button'});
        	
        	button.appendChild(helpImg);
        	button.appendChild(helpLink);
        	
        	this.helpButton = button;
        	
        	helpImg.observe('click', this.getHelp.bindAsEventListener(this));
        	helpLink.observe('click', this.getHelp.bindAsEventListener(this));
        	
			button.observe('mouseover', this.mouseOverCustom.bindAsEventListener(this, button, 'help-button'));
			button.observe('mouseout', this.mouseOutCustom.bindAsEventListener(this, button, 'help-button'));
			return button;
        },
		mouseOverCustom: function(event, button, label) {
        	if (!button.hasClassName('bligoo-bar-' + label + '-hover')) {
            	button.addClassName('bligoo-bar-' + label + '-hover');
            }
        },
        mouseOutCustom: function(event, button, label) {
            if (button.hasClassName('bligoo-bar-' + label + '-hover')) {
            	button.removeClassName('bligoo-bar-' + label + '-hover');
            }
		},
        clickItem: function(e){
        	if(!__BLIGOO_BAR_BUSY){
        		__BLIGOO_BAR_BUSY = true;
        	} else {
        		return;
        	}
        	var element = $(e.target);
			if ( element.tagName != 'LI' ){
				element = element.up();
			}
			if (this.panel.parent.getWatchMsg() != null ){
        		if ( !confirm(this.panel.parent.getWatchMsg()) ){
        			__BLIGOO_BAR_BUSY = false;
        			return;
        		}
        	}
        	if ( this.panel.parent.hasWatchFunction() ){
	        	this.panel.parent.executeWatchCBFunction();
        	}
        	this.panel.parent.setWatch(null, null);
			element.up().select('li.element-selectable').each(function(li){
				li.removeClassName('bligoo-bar-selected');
			}.bind(this));
			element.addClassName('bligoo-bar-selected');
			var idSplit = element.id.split('-') 
			var id = idSplit[idSplit.length-1];
			this.children[id].update();
        },
        setMouseOver: function(e){
        	var element = $(e.target);
			if ( !element.hasClassName('element-selectable') ){
				element = element.up();
			}
			element.addClassName('bligoo-bar-over');
        },
        setMouseOut: function(e){
	        var element = $(e.target);
			if ( !element.hasClassName('element-selectable') ){
				element = element.up();
			}
			element.removeClassName('bligoo-bar-over');
        },
        enableTinyMCE: function() {
			$$('.bligoo-bar-rich-textarea').each(function(area) {
				tinymce.dom.Event.domLoaded = true;
	            if (area.hasClassName('footer-rich-textarea') || area.hasClassName('header-rich-textarea')) {
	                    tinyMCE.settings = getTinyMCEConfig('headerAndFooter');
	            } else {
	                    tinyMCE.settings = getTinyMCEConfig('genericBar');
	            }
				tinyMCE.execCommand('mceAddControl',false, area.id);
			});
        },
        triggerTinyMCE: function(){
			if ($$('.bligoo-bar-rich-textarea').length > 0) {
				tinyMCE.triggerSave(true,true);
			}
		},
		disableTinyMCE: function(){
			$$('.bligoo-bar-rich-textarea').each(function(area) {
				if ( tinyMCE.get(area.id) != null ){
					tinyMCE.execCommand('mceRemoveControl', false, area.id);
				}
			});
		},
		t: function(key){
			return this.panel.translations.get(key);
		},
		getHelp: function(e){
			this.helpManager = new BligooBarHelpManagerClass(this.menuInfo.path);	
		},
		addMessage: function(txt){
			if ( $('bligoo-bar-messages') != null ){
				$('bligoo-bar-messages').remove();
			}
			var ul = Builder.node('ul', {});
			ul.appendChild(Builder.node('li', {}, txt));
			var div = Builder.node('div', {'class': 'messages', 'id': 'bligoo-bar-messages'});
			var anchor = Builder.node('a', {'name': 'bligoo-bar-messages'});
			div.appendChild(anchor);
			var icon = Builder.node('div', {'class': 'bligoo-bar-messages-img bligoo-bar-use-sprite'});
			div.appendChild(icon);
			div.appendChild(ul);
			$('bligoo-bar-item-title').insert({after: div});
			this.calculateHeight();
			
		},
		showStillWorkingSign: function(){
			this.periodical.stop();
			var workingSign = Builder.node('div', {'id': 'bligoo-bar-still-working-sign'}, this.t('working'));
			this.workingSign = workingSign;
			this.workingSign.hide();
			this.container.appendChild(workingSign);
			this.workingSign.setStyle('background: #ffff99;color: #000;width: auto;text-align:center;z-index: 3000;');			
			var signLeftPosition = ((this.containerWidth - this.workingSign.getWidth())/2);
			var signTopPosition = (this.container.getHeight() /2)+30;
			this.workingSign.setStyle('position:absolute; top:'+signTopPosition+'px;left:'+signLeftPosition+'px;');
			new Effect.BlindDown(this.workingSign,{transition: Effect.Transitions.sinoidal, duration: 0.5 });
			this.periodical = new PeriodicalExecuter(this.highLightWorkingSign.bind(this), 2);
		},
		hideStillWorkingSign: function(){
			if (this.periodical){
				this.periodical.stop();
			}
			var sign = $('bligoo-bar-still-working-sign');
			if ( sign != null ){
				sign.remove();
			}
		},
		highLightWorkingSign: function(){
			if ( this.workingSign == null ){
				this.periodical.stop();
			}
			new Effect.Highlight(this.workingSign, { startcolor: '#fff600',endcolor: '#ffff99' });
		}
};

var BligooBarHelpManagerClass = Class.create();
BligooBarHelpManagerClass.prototype = {
        initialize: function(path){
        	this.path = path;
          	this.openWindow();
        },
        openWindow: function(){
        	this.window = new BligooWindow("bligoo-bar-help-window",
			{
				first: 'getBligooBarHelpWindow'
				, module: 'Menu'
				, parameters: {path: this.path}
				, onComplete: this.postProcessHelpWindow.bind(this)
				, width: 820
				, height: 600
			});
        },
        postProcessHelpWindow: function(){
        	if ( this.window == null ){
        		return;
        	}
        	this.windowContent = this.window.getContent();
        	this.helpMainArea = this.windowContent.select('.bligoo-bar-help-container .bligoo-bar-help-main-container').first();
        	this.helpMainAreaTitle = $('bligoo-bar-help-main-top-title');
        	this.helpMainAreaButtons = $('bligoo-bar-help-main-top-buttons');
        	this.helpMainAreaContent = $('bligoo-bar-help-main-content');
        	this.helpIndexArea = this.windowContent.select('.bligoo-bar-help-container .bligoo-bar-help-index').first();
        	this.enableHelpWindowLinks();
        },
		enableHelpWindowLinks: function(){
			this.helpIndexArea.select('div').each(function(item){
				var itemIdSplit = item.id.split('-');
				var contentId = itemIdSplit[itemIdSplit.length-1];
				item.observe('click', this.openHelpContent.bindAsEventListener(this, contentId));
				item.observe('mouseover', this.setMouseOver.bindAsEventListener(this));
				item.observe('mouseout', this.setMouseOut.bindAsEventListener(this));
			}.bind(this));
		},
		setMouseOver: function(e){
			e.target.addClassName('bligoo-bar-help-item-over');
		},
		setMouseOut: function(e){
			e.target.removeClassName('bligoo-bar-help-item-over');
		},
		openHelpContent: function(e, contentId){
			this.helpMainAreaContent.startWaiting('bigWaiting');
			this.deselectAllItems();
			e.target.addClassName('bligoo-bar-help-item-selected');
			new Ajax.Request(
				'/bligoo/ajaxproxy', {
				method: 'getContentForHelp'
				, parameters: {contentId: contentId}
				, onSuccess: function(transport){
								this.responseJSON = transport.responseText.evalJSON();
								this.helpMainAreaContent.update(this.fixLinksOnContent(this.responseJSON.contentBody));
								this.helpMainAreaTitle.update(this.responseJSON.contentTitle);
								this.enableOpenExternalButton(this.responseJSON.contentURL, this.responseJSON.contentURLText);
								this.helpMainAreaContent.stopWaiting();
							}.bind(this)
				, onFailure: function(transport) {
								this.helpMainAreaContent.innerHTML('error');
								this.helpMainAreaContent.stopWaiting();
							}.bind(this)
			});
		},
		deselectAllItems: function(){
			this.helpIndexArea.select('div').each(function(item){
				item.removeClassName('bligoo-bar-help-item-selected');
			}.bind(this));
		},
		enableOpenExternalButton: function(url, urlText){
			var link = Builder.node('a', {'id': 'bligoo-bar-help-content-external-link', 'href': url, 'target': '_BLANK'}, urlText);
			this.helpMainAreaButtons.update(link);
		},
		fixLinksOnContent: function(content){
			//falta esto.
			return content;
		}
};

// Objeto para manejaar el recargar el sitio completo
var BligooSiteReloaderClass = Class.create();
BligooSiteReloaderClass.prototype = {
        initialize: function(path, timer, msg, affButton, negButton){
        	if ( path != '' ){
	        	this.path = path;
        	} else {
        		this.path = location.href;
        	}
        	this.msg = msg;
        	this.timer = timer;
        	this.affButtonTxt = affButton;
        	this.negButtonTxt = negButton;
        	this.start();
        },
        start: function(){
        	this.waitWindow = new BligooWindow("please-wait",
			{
				  width: 400
				, height: 100
			});
			this.windowContent = this.waitWindow.getContent();
			this.buildSimpleMessageContent();
        },
        buildSimpleMessageContent: function(){
        	this.timerDiv = Builder.node('div', {'id': 'bligoo-site-reloader-timer'}, this.timer);
        	this.timerDiv.setStyle('width: 100px;margin: 5px auto;text-align: center;font-size: 16px');
        	this.windowContent.update('');
        	this.windowContent.appendChild(Builder.node('div', {'class': 'bligoo-site-reloader-msg'}, this.msg));
        	this.windowContent.appendChild(this.timerDiv);
			this.timerChecker = new PeriodicalExecuter(this.updateTimer.bind(this), 1);
			var buttonsDiv = Builder.node('div', {'id': 'bligoo-site-reloader-buttons'});
			if ( this.affButtonTxt != '' ){
				var affButton = Builder.node('input', {'class': 'bligoo-window-button', 'type': 'button', 'value': this.affButtonTxt} );
	        	affButton.observe('click', this.affButtonClick.bindAsEventListener(this));
	        	buttonsDiv.appendChild(affButton);
			}
			if ( this.negButtonTxt != '' ){
				var negButton = Builder.node('input', {'class': 'bligoo-window-button', 'type': 'button', 'value': this.negButtonTxt} );
	        	negButton.observe('click', this.negButtonClick.bindAsEventListener(this));
	        	buttonsDiv.appendChild(negButton);
			}
			this.windowContent.appendChild(buttonsDiv);
        },
        updateTimer: function(){
        	this.timer -= 1;
        	this.timerDiv.update(this.timer);
        	if ( this.timer == 0 ){
        		this.timerChecker.stop();
				this.reloadSite();
        	}
        },
        reloadSite: function(){
        	location.href=this.path;
        },
        negButtonClick: function(e){
        	this.windowContent.destroy();
        },
        affButtonClick: function(e){
        	this.reloadSite();
        }
};

var DeleteItemHelperClass = Class.create();
DeleteItemHelperClass.prototype = {
	initialize: function(areaId, deletePath) {
		this.listArea = $(areaId);
		this.enableSingleDeleteButtons();
		this.deletePath = deletePath;
	},
	enableSingleDeleteButtons: function(){
		this.listArea.select('img.delete-cross').each(function (image){
			new CrossImage(image, this.itemDelete.bindAsEventListener(this));
		}.bindAsEventListener(this));
	},
	itemDelete: function(e, image) {
		var img = $(e.target);
		var confirmTxt = img.getAttribute("bligooDeleteConfirmTxt");
		if ( confirm(confirmTxt) ){
			var idSplit = img.id.split('-');
			var itemId = idSplit[idSplit.length-1];
			BligooBar.openCallBack(this.deletePath,{itemId: itemId});
		}
	}
};



	   
	    Effect.Transitions.SwingFromTo = function(pos) {
	    	var s = 1.70158;
 	    	if ((pos /= 0.5) < 1) {
	    		return 0.5 * (pos * pos * (((s *= 1.525) + 1) * pos - s));
	    	}
		    return 0.5 * ((pos -= 2) * pos * (((s *= 1.525) + 1) * pos + s) + 2);
	    };
	    Effect.Transitions.SwingFrom = function(pos) {
	    	var s = 1.70158;
	    	return pos * pos * ((s + 1) * pos - s);
	    };
	    Effect.Transitions.SwingTo = function(pos) {
	    	var s = 1.70158;
	    	return (pos -= 1) * pos * ((s+1) * pos + s) + 1;
	    };
	
		var BubbleNotificator = Class.create();
BubbleNotificator.prototype = {
    initialize: function(element, params){
            this.element = element;
            this.bubble = Builder.node('div', {'id': this.element.id+'-notification', 'class': 'bligoo-bar-notification-bubble bligoo-bar-use-sprite' });
            this.bubble.setStyle({position: 'absolute', top: '-7px', left: '3px', display: 'none'});
            this.element.insert({bottom: this.bubble});
            this.bubbleQueue = 'bubble-' + this.bubble.id;
            if (params != null && params.onClick != null) {
            	this.bubble.observe('click', params.onClick);
            }
    },
    update: function(val){
            this.bubble.innerHTML = val;
            if (!this.bubble.visible()){
                    new Effect.Appear(this.bubble, {queue: {position: 'end', scope: this.bubbleQueue, limit: 1}, duration: 0.3});
            }
            this.shake();
    },
    setTooltip: function(text) {
    	this.bubble.setAttribute('title', text);
    },
    visible: function() {
    	return this.bubble.visible();
    },
    close: function() {
    	this.bubble.hide();
    },
    shake: function(){
            if ( this.bubble.visible() ){
                    this.bounceAnimation(1, 20, 1);
            }
    },
    bounceAnimation: function(loops, height, duration) {
		this.bubble.setStyle({position: 'absolute', top: '-7px', left: '3px'});
        var duration = duration / 2.0;
        var i = 0;
        for (; i < loops; i++) {
                new Effect.Move(this.bubble,{x: 0, y: -height, mode: 'relative', transition: Effect.Transitions.SwingFrom, duration: 0.4 , queue: {position: 'end', scope: this.bubbleQueue}});
                new Effect.Move(this.bubble,{x: 0, y: height, mode: 'relative', transition: Effect.Transitions.SwingFromTo, duration: 0.4 , queue: {position: 'end', scope: this.bubbleQueue}});
        }
        new Effect.Move(this.bubble,{x:0, y:-height/6, mode:'relative', transition: Effect.Transitions.linear, duration: 0.1 , queue: {position: 'end', scope: this.bubbleQueue}});
        new Effect.Move(this.bubble,{x:0, y:height/6, mode:'relative', transition: Effect.Transitions.linear, duration: 0.1 , queue: {position: 'end', scope: this.bubbleQueue}});
    }
};
		var BligooWindow = Class.create({
	initialize: function(name, config) {
			this.name = name;
			this.updateConfig(config);
			this.createWindow(name);
			this.setSize(config.width, config.height);
			this.callFirst();
			if (isIE6()) {
				Event.observe(window, 'scroll', this.updatePosition.bindAsEventListener(this));
			}
	}, 
	updateConfig: function(config) {
			this.config = config;
			this.width = config.width;
			this.height = config.height;
			this.encType = config.encType;
			this.target = config.target;
			this.action = config.action;
			if ( this.config.parameters != null ){
				this.extraParameters = this.config.parameters;
			}
	}, 
	createWindow: function(name) {
			var win = '<div class="bligoo-fixed-element glass-layer" id="glass-layer-' + this.name + '"></div>'
				+ '<div class="bligoo-fixed-element bligoo-window-wrapper" id="bligoo-window-wrapper-' + this.name + '">'
				+ '<div class="bligoo-window" id="bligoo-window-' + this.name + '">'
				+ '<form id="bligoo-window-form-' + this.name + '"' 
					+ (this.encType != null? ' enctype="' + this.encType + '"': '') 
					+ (this.target != null? ' target="' + this.target + '"': '') 
					+ (this.action != null? ' action="' + this.action + '" method="post"': '') 
					+'>'
				+ '<div class="bligoo-window-content" id="bligoo-window-content-' + this.name + '"></div>'
				+ '</form>'
				+ '</div>';
				
			if ($('bligoo-site-wrapper') != null) {
				$('bligoo-site-wrapper').insert(win);
			} else {
				$('bligoo-wrapper').insert(win);
			}
			this.content = $('bligoo-window-content-' + this.name);
			this.window = $('bligoo-window-' + this.name);
			this.form = $('bligoo-window-form-' + this.name);
			this.glass = $('glass-layer-' + this.name);
			this.wrapper = $('bligoo-window-wrapper-' + this.name);
			
			this.setSpinner();
	},
	callFirst: function(){
			if ( this.config.module && this.config.first ){
				var params = $H({method: 'bligooWindow', module: this.config.module, next: this.config.first});
				if (this.config.parameters != null) { 
					var cparams = $H(this.config.parameters);
					params = params.merge(cparams);
				}
				
				new Ajax.Request('/bligoo/ajaxproxy', {
								parameters: params
								, onSuccess: this.process.bind(this)
								, onFailure: function(transport) {
									alert('Ha ocurrido un error. Por favor intente mas tarde');
								}
							});
			}
	},
	submit: function() {
		if (this.form != null) {
			this.form.submit();
		}
	},
	setSpinner: function() {
		this.setContent('<div class="bligoo-window-spinner" id="bligoo-window-spinner-' + this.name + '"></div>');
		var spinner = $('bligoo-window-spinner-' + this.name);
		if (spinner != null) {
			spinner.setStyle({width: this.width + 'px', height: this.height + 'px'});
		}
	},
	process: function(transport) {
	    if(this.config.skipScripts){
	    	this.content.innerHTML = transport.responseText;
	    } else {
			this.content.update(transport.responseText);
		}
		this.content.fire("bligoowindow:content-replaced", this);
		this.enableEditors();
		new SubmitStopperClass('bligoo-window-form-' + this.name);
		if (this.windowConfig('final')) {
			this.close();
			if (this.config.finalFunction != null) {
				this.config.finalFunction();
			}
			return;
		}
		this.buttons = $$('#bligoo-window-content-' + this.name+' div.bligoo-window-buttons').first();
		this.toolbar = $$('#bligoo-window-content-' + this.name+' div.bligoo-window-buttons div.bligoo-window-buttons-toolbar').first();
		var button = $$('#' + this.content.id + ' .bligoo-button-next').first();
		var skipLinks = $$('#' + this.content.id + ' .bligoo-window-skip-link');
		this.next = $$('#' + this.content.id + ' .bligoo-window-config-next').first();
		this.module = $$('#' + this.content.id + ' .bligoo-window-config-module').first();
		var buttonBack = $$('#' + this.content.id + ' .bligoo-button-back').first();
		var backStep = $$('#' + this.content.id + ' .bligoo-window-config-back').first();
		var backModule = $$('#' + this.content.id + ' .bligoo-window-config-back-module').first();
		
		var close = $$('#' + this.content.id + ' .bligoo-button-close').first();
		if (close) {
			close.observe('click', this.close.bind(this));
		}
		
		
		if (button) {
			button.stopObserving('click');
			if (this.next && this.module) {
				//button.observe('click', this.callNext.bind(this, next.value, module.value));
				button.onclick = this.callNext.bind(this, this.next.value, this.module.value);
				var click = this.callNext.bind(this, this.next.value, this.module.value);
				skipLinks.each(function(link) {
						link.observe('click', click);
					}.bind(this));
			} else {
				//button.observe('click', this.callFunction.bind(this));
				button.onclick = this.callFunction.bind(this);
				var click = this.callFunction.bind(this);
				skipLinks.each(function(link) {
						link.observe('click', click);
					}.bind(this));
			}
		}
		
		if (buttonBack && backStep && backModule) {
		    buttonBack.stopObserving('click');
		    buttonBack.show();
			buttonBack.observe('click', this.callNext.bind(this, backStep.value, backModule.value));
		}
		
		var upper = $$('#' + this.content.id + ' .bligoo-window-upper').first();
		
		if (upper) {
			upper.setStyle({ height: (this.height - this.getDelta()) + 'px'});
		}
		if(this.config.onComplete){
			this.config.onComplete();
		}
		var height = this.windowConfig('height');
		if (parseInt(height.value) > 0) {
			this.setSize(this.width, height.value);
		}
	},
	getDelta: function() {
		if ( this.extraParameters != null ){
			if ( this.extraParameters.delta != null ) {
				return parseInt(this.extraParameters.delta);
			}
		}
        return 70;
	},
	goNext: function(){
		if (this.next && this.module) {
				this.callNext(this.next.value, this.module.value);
		}
	},
	windowConfig: function (key) {
		return $$('#' + this.content.id + ' .bligoo-window-config-' + key).first();
	},
	callFunction: function() {
		if (this.config.endFunction != null ) {
			this.triggerEditorsSave();
			this.disableEditors();
			this.config.endFunction();
		}
	}, 
	callNext: function(next, module) {
		this.triggerEditorsSave();
		this.disableEditors();
		var params = $H(this.form.serialize(true));
        params = params.merge($H({method: 'bligooWindow', module: module, next: next}));
		
		this.setSpinner();
		new Ajax.Request('/bligoo/ajaxproxy', {
							parameters: params
							, onSuccess: this.process.bind(this)
							, onFailure: function(transport) {
								alert('Ha ocurrido un error. Por favor intente mas tarde');
							}
						});
	},
	enableEditors: function(){
		var tmces = $$('#' + this.content.id + ' .rich-text-area');
		for ( var i =0; i<tmces.length ; i++ ){
			tinymce.dom.Event.domLoaded = true;
			if (tmces[i].hasClassName('window-rich-text-area') ){
				tinyMCE.settings = getTinyMCEConfig('genericWindow');
			}else{
				tinyMCE.settings = getTinyMCEConfig('blidgets');
			}
			tinyMCE.execCommand('mceAddControl',false, tmces[i].id);
		}
	},
	disableEditors: function(){
		var tmces = $$('#' + this.content.id + ' .rich-text-area');
		for ( var i =0; i<tmces.length ; i++ ){
			if ( tinyMCE.get(tmces[i].id) != null ){
				tinyMCE.execCommand('mceRemoveControl',false,tmces[i].id);
			}
		}
	},
	triggerEditorsSave: function(){
		var tinymceEditor = $$('#' + this.content.id + ' .rich-text-area');
		if ( tinymceEditor.length > 0 ){
			tinyMCE.triggerSave(true,true);
		}
	},
	setSize: function(width, height) {
			this.width = width;
			this.height = parseInt(height);
			
			this.glass.setStyle({
									top: 0  + 'px'
									, left: 0 + 'px'
									, position: 'fixed'
									, width: '100%'
									, height: '100%'
									, background: '#000000'
									, opacity: 0.2
									, zIndex: 200
								});
								
			var wrapperHeight = this.height + this.getDelta();
			var top =  wrapperHeight > document.viewport.getHeight() ? 
									document.viewport.getHeight() - wrapperHeight - 25 : 
									(document.viewport.getHeight() - wrapperHeight) / 2;
			var left = (document.viewport.getWidth() - width) / 2;
			this.wrapper.setStyle({
										width: 		'100%'
										, height: 	wrapperHeight + 'px'
										, top: 		top + 'px'
										, left: 	'0px'
										, position:	'fixed'
										, zIndex: 	201
			});
			this.window.setStyle({
									width: 		width + 'px'
									, height:		'100%'
									, margin:		'auto'
			});
			
			new Effect.Morph(this.window, {'style': 'width: ' + width + 'px;',duration: 0.1, transition: Effect.Transitions.sinoidal} );
			var upper = $$('#' + this.content.id + ' .bligoo-window-upper').first();
			if (upper) {
				if ( upper.getAttribute('bligooWindowHeaderEnable') == 'true' ){
					upper.setStyle({ height: (this.height - this.getDelta()) + 'px'});
					
				}else{
					upper.setStyle({ height: (this.height) + 'px'});
				}
			}
			this.content.setStyle({ height: (this.height - 5) + 'px'});
			if (isIE6()) {
				this.updatePosition();
			}
	},
	setContent: function(content) {
		this.content.update(content);
	},
	addButton: function(name, value) {
		this.buttons.insert('<div class="form-item"><input class="bligoo-window-button form-button" id="bligoo-window-button-' + this.name + '-' + name + '" type="button" value="' + value + '"></div>');
		return $('bligoo-window-button-' + this.name + '-' + name);
	},
	toggleButtons: function() {
		this.buttons.toggle();
	},
	hideButtons: function() {
		this.buttons.hide();
	},
	showButtons: function() {
		this.buttons.show();
	},
	close: function() {
		this.disableEditors();
		if (this.config.onClose) {
			this.config.onClose();
		}
		//if (isIE6()) {
		//	this.showSelects();
		//}
		this.destroy();
		// this.glass.hide();
		// this.wrapper.hide();
	},
	show: function() {
		// if (isIE6()) {
		// 	this.hideSelects();
		// }
		this.wrapper.show();
		this.glass.show();
	},
	hideSelects: function() {
		$$('div#bligoo-panel-wrapper select').each(function(select) { this.toggleSelect(select); }.bind(this));
		$$('table#main select').each(function(select) { this.toggleSelect(select); }.bind(this));
	}, 
	toggleSelect: function(select) {
		if (select.visible()) {
			select.addClassName('hidden-select');
			select.hide();
		} else {
			select.removeClassName('hidden-select');
			select.show();
		}
	},
	showSelects: function() {
		$$('select.select').each(function(select) { this.toggleSelect(select); }.bind(this));
	}, 
	destroy: function() {
		this.wrapper.remove();
		this.glass.remove();
	},
	getFormContent: function () {
		return this.form.serialize();
	},
	getForm: function() {
		return this.form;
	},
	updatePosition: function(event) {
		var offsets =  document.viewport.getScrollOffsets();
		this.glass.absolutize();
	    this.glass.setStyle({top: offsets[1] + 'px'
	    					, left: offsets[0] + 'px'
	    					, width: document.viewport.getWidth() + 'px'
	    					, height: document.viewport.getHeight() + 'px'});
	 	this.wrapper.absolutize();
	    var height = this.wrapper.getHeight();
	    var top =  height > document.viewport.getHeight() ?
	                   offsets[1] + document.viewport.getHeight() - height - 25 :
	                   offsets[1] + (document.viewport.getHeight() - height) / 2;
	    this.wrapper.setStyle({top:  top + 'px', left: offsets[0] + 'px', width: '100%', height: '100%'});
	},
	getToolbarArea: function(){
		return this.toolbar;
	},
	addToolbarButton: function(name, value) {
		this.toolbar.insert('<div class="form-item"><input class="bligoo-window-button form-button" id="bligoo-window-button-' + this.name + '-' + name + '" type="button" value="' + value + '"></div>');
		return $('bligoo-window-button-' + this.name + '-' + name);
	},
	addToolbarItem: function(item){
		this.toolbar.insert('<div class="form-item">'+item+'</div>');
	},
	getContent: function(){
		return this.content;
	}
});

var BligooWindowLink = Class.create({
	initialize: function(button) {
		this.button = button;
		this.parameters = {
            first: button.getAttribute('bligooMethod')
            , module: button.getAttribute('bligooModule')
		};
		this.name = this.button.getAttribute('bligooName');
		var width = parseInt(button.getAttribute('bligooWidth'));
		var height = parseInt(button.getAttribute('bligooHeight'));
		if (width > 0) {
            this.parameters.width = width;
		}
		if (height > 0) {
		        this.parameters.height = height;
		}
		
		if ( button.getAttribute('bligooParameters') != null ){
			this.parameters.parameters = button.getAttribute('bligooParameters').evalJSON();
		}
		
		if ( button.getAttribute('bligooFormTarget') != null ){
			this.parameters.target = button.getAttribute('bligooFormTarget');
		}
		if ( button.getAttribute('bligooEncType') != null ){
			this.parameters.encType = button.getAttribute('bligooEncType');
		}
		if ( button.getAttribute('bligooFormAction') != null ){
			this.parameters.action = button.getAttribute('bligooFormAction');
		}
		
		if ( button.getAttribute('bligooEndFunction') != null ) {
			var f = null;
			eval('f = ' + button.getAttribute('bligooEndFunction') + '.bind(this)');
			this.parameters.endFunction = f;
		}
		button.observe('click', this.click.bindAsEventListener(this));
	}, 
	click: function(event) {
		this.window = new BligooWindow(this.name, this.parameters);
		this.window.show();
		BligooWindowLink.lastWindow = this.window;
	}
});

BligooWindowLink.lastWindow = null;
var BligooTooltipClass = Class.create();

BligooTooltipClass.RIGHT = 'right';
BligooTooltipClass.LEFT = 'left';
BligooTooltipClass.TOP = 'top';
BligooTooltipClass.BOTTOM = 'bottom';

BligooTooltipClass.prototype = {
	initialize: function(element, content,params) {
		this.element = element;
		this.parent = element.up();
		this.direction = params.direction;
	
		var width = isNaN(params.width) ? 150: params.width;
		this.tip = Builder.node('div', {
					'style': 'position: relative;'
					, 'class': 'bligoo-bar-use-sprite bligoo-tooltip-tip bligoo-tooltip-' + params.direction
					});
		var position = this.element.getStyle('position') == 'fixed' || this.element.getStyle('position') == 'absolute' ? 
				this.element.getStyle('position') : 'absolute';
		this.tipWrapper = Builder.node('div', {
					'style': 'position: ' + position + ';' 
					, 'class': 'bligoo-tooltip-tip-wrapper bligoo-tooltip-wrapper-' + params.direction
					}, this.tip);
		this.parent.appendChild(this.tipWrapper);
		this.body = Builder.node('div', {
						'class': 'bligoo-tooltip-body'
						, 'style': 'width: ' + width + 'px;  position: absolute'});
		var bodyContent = Builder.node('div', {'class': 'bligoo-tooltip-body-content', 'style': 'position: relative;'}, content);
		var bodyX = Builder.node('div', {'class': 'bligoo-tooltip-body-x bligoo-bar-use-sprite', 'style': 'position: absolute; top:4px ;right:4px;'});
		bodyX.observe('click', this.closeHint.bindAsEventListener(this));
		bodyContent.appendChild(bodyX); 
		this.body.appendChild(bodyContent);
		this.tip.appendChild(this.body);
		this.element.observe('click', this.closeHint.bindAsEventListener(this));
		this.calculatePositions();
	},
	calculatePositions: function(){
		this.elementTop = this.element.positionedOffset()[1];
		this.elementLeft = this.element.positionedOffset()[0];
		switch (this.direction) {
			case BligooTooltipClass.TOP: 
				this.tipLeft = this.elementLeft + (this.element.getDimensions().width * 20 / 100);	
				this.tipTop = this.elementTop - this.tipWrapper.getDimensions().height;
				break;
			case BligooTooltipClass.LEFT: 
				this.tipLeft = this.elementLeft - this.tipWrapper.getDimensions().width;	
				this.tipTop = this.elementTop + (this.element.getDimensions().width * 20 / 100);
				break;
			case BligooTooltipClass.RIGHT: 
				this.tipLeft = this.elementLeft + this.element.getDimensions().width;	
				this.tipTop = this.elementTop + (this.element.getDimensions().width * 20 / 100);
				break;
			case BligooTooltipClass.BOTTOM: 
				this.tipLeft = this.elementLeft + (this.element.getDimensions().width * 20 / 100);	
				this.tipTop = this.elementTop + this.element.getDimensions().height;
				break;
		}
		this.tipWrapper.setStyle({'left' : this.tipLeft + 'px', 'top': this.tipTop + 'px'});
		switch (this.direction) {
			case BligooTooltipClass.TOP: 
				this.bodyLeft = -this.body.getDimensions().width * 20 / 100;	
				this.bodyTop = -this.body.getDimensions().height;
				break;
			case BligooTooltipClass.LEFT: 
				this.bodyLeft = -this.body.getDimensions().width;	
				this.bodyTop = -this.body.getDimensions().height * 20 / 100;
				break;
			case BligooTooltipClass.RIGHT: 
				this.bodyLeft = this.tipWrapper.getDimensions().width;	
				this.bodyTop = -this.body.getDimensions().height * 20 / 100;
				break;
			case BligooTooltipClass.BOTTOM: 
				this.bodyLeft = -this.body.getDimensions().width * 20 / 100;	
				this.bodyTop = this.tipWrapper.getDimensions().height;
				break;
		}
		this.body.setStyle({'left' : this.bodyLeft + 'px', 'top': this.bodyTop + 'px'});
	},
	closeHint: function(e){
		if ( this.element.hasClassName('notify-close-hint')){
			new Ajax.Request('/bligoo/ajaxproxy', {method: 'notifyHintClose',	parameters: {key: this.element.getAttribute("bligooHintKey")}});
		}
		this.tipWrapper.remove();
	}
}

document.observe("bligoo:file-uploaded", function(event) {
	if (event.memo.id == 'theme-upload-file') {
		if (event.memo.error != null && $('upload-messages') != null) {
			$('upload-messages').update(event.memo.error);
			$('upload-messages').show();
			return;
		} 
		$('upload-messages').update(event.memo.message);
		$('upload-messages').show();
		if (event.memo.image == true) {
			ImageEditorHelper.edit(event.memo.width, event.memo.height, event.memo.fileId, 'file');
		}
		NewThemeManager.refreshThemeFileList()
	} else if (event.memo.id == 'theme-upload-image-picker') {
		$('theme-manager-selected-image').value = event.memo.filename;
		ThemeEditorManager.updateImageSelected();
		ThemeEditorManager.removeDisabledFromButtons();
	}
});

var NewThemeManagerClass = Class.create();
NewThemeManagerClass.prototype = {
	initialize: function(mode, bligooBar, confirmDeleteThemeMsg, confirmLeaveTxt) {
		this.bligooBar = bligooBar;
		this.confirmMsg = confirmDeleteThemeMsg;
		this.confirmLeaveMsg = confirmLeaveTxt;
    	var link_tag = document.getElementsByTagName("link");
		this.generatedCSS = link_tag[0];
		this.baseCSS = link_tag[1];
		this.initGeneratedCSSHref = this.generatedCSS.href;
		this.initBaseCSSHref = this.baseCSS.href;
		this.mode = mode;
		this.initHeaderContent = $('main-header-content').innerHTML;
		this.initFooterContent = $('main-footer-content').innerHTML;
		this.locateButtons();
	},
	locateButtons: function(){
		if ( this.mode == 'templates'){
			this.delThemeButton = $('bligoo-bar-button-theme-templates-del');
			this.delThemeButton.addClassName('disabled');
			this.copyThemeButton = $('bligoo-bar-button-theme-templates-copy');
			this.copyThemeButton.addClassName('disabled');
			this.useThemeButton = $('bligoo-bar-button-theme-templates-use');
			this.useThemeButton.addClassName('disabled');
			this.enableTemplatesFromList();
		}
	},
	enableTemplatesFromList: function(){
		this.themeList = $('bligoo-bar-menu-item-theme-templates');
		this.themeList.select('div.edit-site-theme-details').each(function (div){
			div.observe('click', this.clickOnTemplate.bindAsEventListener(this));
		}.bind(this));
	},
	clickOnTemplate: function(e){
		var element = $(e.target);
		if ( !element.hasClassName('edit-site-theme-details') ){
			element = $(element.up());
		}
		if (!element.hasClassName('selected') ){
			this.themeList.select('div.edit-site-theme-details').each(function (div){
				div.removeClassName('selected');
			}.bind(this));
			element.addClassName('selected');
			this.tryTheme(element.id);
		}
	},
	tryTheme: function(themeId){
		this.bligooBar.setWatch(this.confirmLeaveMsg, this.resetChanges.bind(this) );
		this.bligooBar.panel.startWaiting();
		this.disableTemplateButtons();
    	new Ajax.Request('/bligoo/ajaxproxy', 
		{	
			method: 'getThemeInfo'
			, parameters: {themeId: themeId}
			, onComplete: function(transport){
    			this.applyTheme(transport.responseText.evalJSON());
    			this.bligooBar.panel.stopWaiting();
    		}.bind(this)
    	});
	},
	applyTheme: function (themeInfo){
		this.selectedThemeId = themeInfo.id;
		if (this.mode == 'templates' ){
			this.enableTemplateButtons(themeInfo);
		}
		var currentDate = new Date();
		this.generatedCSS.href = themeInfo.url+"/generated.css?ver=" + currentDate.valueOf();
		this.baseCSS.href = themeInfo.url+"/base.css?ver=" + currentDate.valueOf();
		
		$('main-header-content').innerHTML = themeInfo.header;
		$('main-footer-content').innerHTML = themeInfo.footer;
	},
	disableTemplateButtons: function(){
		this.delThemeButton.addClassName('disabled');
		this.delThemeButton.stopObserving('click');
		this.useThemeButton.addClassName('disabled');
		this.useThemeButton.stopObserving('click');
		this.copyThemeButton.addClassName('disabled');
		this.copyThemeButton.stopObserving('click');
	},
	enableTemplateButtons: function(themeInfo){
		if (themeInfo.canDelete == true ){
			this.delThemeButton.removeClassName('disabled');
			this.delThemeButton.observe('click', this.deleteTheme.bind(this));
		}else{
			this.delThemeButton.addClassName('disabled');
			this.delThemeButton.stopObserving('click');
		}
		if (themeInfo.canUse == true ){
			this.useThemeButton.removeClassName('disabled');
			this.useThemeButton.observe('click', this.useTheme.bind(this));
		}else{
			this.useThemeButton.addClassName('disabled');
			this.useThemeButton.stopObserving('click');
		}
		if (themeInfo.canCopy == true ){
			this.copyThemeButton.removeClassName('disabled');
			this.copyThemeButton.observe('click', this.copyTheme.bind(this));
		}else{
			this.copyThemeButton.addClassName('disabled');
			this.copyThemeButton.stopObserving('click');
		}
	},
	editTheme: function(){
		this.bligooBar.setWatch(null,null);
		this.bligooBar.openCallBack('theme/edit', {themeId: this.selectedThemeId});
	},
	copyTheme: function(){
		this.copyWindow = new BligooWindow("theme-template-copy",
			{
				  width: 400
				, height: 100
			});
		this.windowContent = this.copyWindow.getContent();
		this.buildCopyWindowContent();
	},
	buildCopyWindowContent: function(){
		var div = Builder.node('div', {'id': 'theme-template-copy-content'});
		div.appendChild(Builder.node('input', {'id': 'theme-template-copy-name', 'name': 'theme-template-copy-name', 'type': 'text'}));
		var saveAsButton = Builder.node('input', {'value': 'ok!', 'type': 'button'});
		var cancelButton = Builder.node('input', {'value': 'cancel!', 'type': 'button'});
		saveAsButton.observe('click', this.saveThemeAs.bind(this));
		cancelButton.observe('click', this.closeCopyWindow.bind(this));
		var buttonsDiv = Builder.node('div', {'id': 'theme-template-copy-content-buttons'});
		buttonsDiv.appendChild(saveAsButton);
		buttonsDiv.appendChild(cancelButton);
		div.appendChild(buttonsDiv);
		this.windowContent.update(div);
	},
	closeCopyWindow: function(){
		if ( this.copyWindow != null ){
			this.copyWindow.destroy();
		}
	},
	saveThemeAs: function(){
		if ( this.copyWindow != null ){
			var inputName = this.windowContent.select('#theme-template-copy-name').first();
			if ( inputName != null && inputName.value != '' ){
				this.closeCopyWindow();
				this.bligooBar.openCallBack('theme/templates/copy', {themeId: this.selectedThemeId, copyName: inputName.value});
			}
		}
	},
	useTheme: function(){
		this.bligooBar.setWatch(null,null);
		this.bligooBar.openCallBack('theme/templates/use', {themeId: this.selectedThemeId});
	},
	deleteTheme: function(){
		if ( confirm(this.confirmMsg) ){
			this.bligooBar.openCallBack('theme/templates/delete', {themeId: this.selectedThemeId});
		}
	},
	resetChanges: function(){
		this.generatedCSS.href = this.initGeneratedCSSHref;
		this.baseCSS.href = this.initBaseCSSHref;
		$('main-header-content').innerHTML = this.initHeaderContent;
		$('main-footer-content').innerHTML = this.initFooterContent;
	}
}
var NewThemeManager = null;


var ThemeEditorManagerClass = Class.create();
ThemeEditorManagerClass.prototype = {
	initialize: function(bligooBar, mode, isUsedTheme, tmpDirUrl,originalThemeInfo, confirmDeleteFileTxt, confirmLeaveTxt) {
		this.bligooBar = bligooBar;
		this.originalThemeInfoData = originalThemeInfo;
		this.confirmTxt = confirmDeleteFileTxt;
		this.confirmLeaveTxt = confirmLeaveTxt;
		this.mode = mode;
		this.tmpDirUrl = tmpDirUrl;
		
 		/* datos originales */
 		this.siteThemeGeneratedCSSHref = this.originalThemeInfoData.url+"/generated.css";
		this.siteThemeBaseCSSHref = this.originalThemeInfoData.url+"/base.css";
 		this.siteHeader = this.originalThemeInfoData.header;
		this.siteFooter = this.originalThemeInfoData.footer;
		
		this.moveToTmpDir();
		this.form = $('bligoo-bar-menu-item-theme-edit').select('form').first();
		this.enableButtons();
		if ( mode == 'basic' ){
			this.enableColorPicker('#bligoo-bar-menu-item-theme-edit .bligoo-color-picker-input');
			this.enableImagePickers();
		}else{
			this.enableExtraFiles();
		}
		if (!isUsedTheme){
			this.enableWatch();
		}
 	},
 	enableExtraFiles: function(){
 		if ( this.extraFilesContainer == null ){
	 		this.extraFilesContainer = $('bligoo-bar-theme-list');
	 	}
 		if ( this.extraFilesContainer != null ){
 			this.extraFilesContainer.select('img.bligoo-bar-theme-file-delete-img').each(function (img){
 				new CrossImage(img, this.deleteExtraFile.bindAsEventListener(this, img.id));
 			}.bind(this));
 			
 		}
 	},
 	deleteExtraFile: function (e, fileId){
 		if ( !confirm(this.confirmTxt) ){
 			return;
 		}
 		new Ajax.Request('/bligoo/ajaxproxy', {
			 method: 'deleteFile'
			,parameters: {fileId: fileId}
			,onComplete: this.refreshExtraFilesList.bind(this)
		});	
 	},
 	refreshExtraFilesList: function(){
 		this.extraFilesContainer.startWaiting('bigWaiting');
		new Ajax.Request('/bligoo/ajaxproxy', {
			 method: 'getThemeFileList'
			,parameters: {}
			,onComplete: function(transport){
				this.extraFilesContainer.update(transport.responseText);
				this.enableExtraFiles();
		 		this.extraFilesContainer.stopWaiting();
			}.bind(this)
		});	
 	},
 	moveToTmpDir: function(){ 		
 		this.bligooBar.panel.startWaiting();
 		var link_tag = document.getElementsByTagName("link");

 		var currentDate = new Date();
		this.generatedCSS = link_tag[0];
		this.baseCSS = link_tag[1];
			
		this.generatedCSS.href = this.tmpDirUrl+"generated.css?v="+currentDate.valueOf();
		this.baseCSS.href = this.tmpDirUrl+"base.css?v="+currentDate.valueOf();
		
		this.initGeneratedCSSHref = this.generatedCSS.href;
		this.initBaseCSSHref = this.baseCSS.href;
		this.bligooBar.panel.stopWaiting();
 	},
 	enableImagePickers: function(){
 		$('bligoo-bar-menu-item-theme-edit').select('img.bligoo-bar-image-picker').each(function (img){
 			img.observe('click', this.openImageSelector.bindAsEventListener(this, img.id));
 		}.bind(this));
 	},
 	enableButtons: function(){
 		if ( $('bligoo-bar-theme-editor-button-apply') != null ){
	 		this.applyButton = $('bligoo-bar-theme-editor-button-apply');
	 		this.applyButton.enable();
 			this.applyButton.observe('click', this.applyChanges.bind(this) );
 		}
 		if ( $('bligoo-bar-theme-editor-button-save-and-use') != null ){
 			this.saveButton = $('bligoo-bar-theme-editor-button-save-and-use');
 			this.saveButton.enable();
 			this.saveButton.observe('click', this.saveAndUse.bind(this));
 		}
 		if ( $('bligoo-bar-theme-editor-button-saveas-and-use') != null ){
 			this.saveButton = $('bligoo-bar-theme-editor-button-saveas-and-use');
 			this.saveButton.enable();
 			this.saveButton.observe('click', this.openSaveAsWindow.bind(this));
 		}
 		if ( $('bligoo-bar-theme-editor-button-saveas') != null ){
 			this.saveButton = $('bligoo-bar-theme-editor-button-saveas');
 			this.saveButton.enable();
 			this.saveButton.observe('click', this.openSaveAsWindow.bind(this));
 		}
 		if ( $('button-to-advanced') != null ){
	 		$('button-to-advanced').enable();
 		}
 		if ( $('button-to-basic') != null ){
	 		$('button-to-basic').enable();
 		}
 	},
 	removeDisabledFromButtons: function(){
 		this.applyButton.enable();
		this.saveButton.enable();
 	 	if ( $('button-to-advanced') != null ){
	 		$('button-to-advanced').enable();
 		}
 		if ( $('button-to-basic') != null ){
	 		$('button-to-basic').enable();
 		}
 	},
 	saveAs: function(){
		var inputName = this.windowContent.select('#theme-save-as-name').first();
		if ( inputName != null && inputName.value != '' ){	
			this.bligooBar.panel.startWaiting();
	 		tinyMCE.triggerSave(true,true);
	 		var formParams = $H(this.form.serialize(true));
	    	formParams = formParams.merge({name: inputName.value});
	    	new Ajax.Request('/bligoo/ajaxproxy', {
				 method: 'saveThemeAs'
				,parameters: formParams
				,onComplete: function(transport){
					this.bligooBar.panel.stopWaiting();
					this.closeSaveAsWindow();
					var data = transport.responseText.evalJSON();
					this.disableWatch();
					if ( data.result == 'ok' ){
						this.refreshCSS(data);					
						this.bligooBar.barItem.addMessage(data.message);
					}else{
						this.bligooBar.barItem.addMessage("ERROR:"+data.message);
					}
				}.bind(this)
			});
	 	}
 	},
 	saveAsAndUse: function(e, button){
 		var inputName = this.windowContent.select('#theme-save-as-name').first();
		if ( inputName != null && inputName.value != '' ){	
			this.bligooBar.panel.startWaiting();
	 		tinyMCE.triggerSave(true,true);
	 		var formParams = $H(this.form.serialize(true));
	    	formParams = formParams.merge({use: "true"});
	    	formParams = formParams.merge({name: inputName.value});
	    	new Ajax.Request('/bligoo/ajaxproxy', {
				 method: 'saveThemeAsAndUse'
				,parameters: formParams
				,onComplete: function(transport){
					this.bligooBar.panel.stopWaiting();
					this.closeSaveAsWindow();
					var data = transport.responseText.evalJSON();
					if ( data.result == 'ok' ){
						this.refreshCSS(data);					
						this.bligooBar.barItem.addMessage(data.message);
						this.saveButton.stopObserving('click');
						this.saveButton.observe('click', this.saveAndUse.bind(this));
						this.disableWatch();
					}else{
						this.bligooBar.barItem.addMessage("ERROR:"+data.message);
					}
				}.bind(this)
			});
	 	}
 	},
 	saveAndUse: function(){
	 	this.bligooBar.panel.startWaiting();
 		tinyMCE.triggerSave(true,true);
 		var formParams = $H(this.form.serialize(true));
	    formParams = formParams.merge({use: "true"});
    	new Ajax.Request('/bligoo/ajaxproxy', {
			 method: 'saveTheme'
			,parameters: formParams
			,onComplete: function(transport){
				var data = transport.responseText.evalJSON();
				this.refreshCSS(data);
				this.bligooBar.panel.stopWaiting();
				this.bligooBar.barItem.addMessage(data.message);
				this.disableWatch();
			}.bind(this)
		});
 	},
 	applyChanges: function(){
 		this.bligooBar.panel.startWaiting();
 		tinyMCE.triggerSave(true,true);
    	new Ajax.Request(
			'/bligoo/ajaxproxy', {
				method: 'saveTmpThemeChanges'
			    ,parameters: this.form.serialize(true)
				,onComplete: function(transport){
					this.refreshCSS(transport.responseText.evalJSON());
					this.enableWatch();
					this.bligooBar.panel.stopWaiting();
				}.bind(this)
			});
 	},
 	enableWatch: function(){
 		this.bligooBar.setWatch(this.confirmLeaveTxt, this.reset.bind(this));
 	},
 	disableWatch: function(){
 		this.bligooBar.setWatch(null, null);
 	},
 	reset: function(){
 		$('main-header-content').innerHTML = this.siteHeader;
		$('main-footer-content').innerHTML = this.siteFooter;
		this.generatedCSS.href = this.siteThemeGeneratedCSSHref;
		this.baseCSS.href = this.siteThemeBaseCSSHref;
		this.disableWatch();
 	},
 	refreshCSS: function(data){
 		var currentDate = new Date();
		this.generatedCSS.href = this.generatedCSS.href+"&v="+currentDate.valueOf();
		this.baseCSS.href = this.baseCSS.href+"&v="+currentDate.valueOf();
		$('main-header-content').innerHTML = data.header;
		$('main-footer-content').innerHTML = data.footer;
 	},
 	openSaveAsWindow: function(){
		this.saveAsWindow = new BligooWindow("theme-theme-save-as",
			{
				  width: 400
				, height: 100
			});
		this.windowContent = this.saveAsWindow.getContent();
		this.buildSaveAsWindowContent();
	},
	buildSaveAsWindowContent: function(){
		var div = Builder.node('div', {'id': 'theme-save-as-content'});
		div.appendChild(Builder.node('p', {}, this.saveButton.getAttribute('bligooConfMsg')));
		div.appendChild(Builder.node('input', {'id': 'theme-save-as-name', 'name': 'theme-save-as-name', 'type': 'text'}));
		var saveAsButton = Builder.node('input', {'value': this.saveButton.getAttribute('bligooConfAffButton'), 'type': 'button', 'class': 'form-button'});
		var cancelButton = Builder.node('input', {'value': this.saveButton.getAttribute('bligooConfNegButton'), 'type': 'button', 'class': 'form-button'});
		saveAsButton.observe('click', eval('this.'+this.saveButton.getAttribute('bligooMethod')+'.bind(this)'));
		cancelButton.observe('click', this.closeSaveAsWindow.bind(this));
		var buttonsDiv = Builder.node('div', {'id': 'theme-template-copy-content-buttons', 'class': 'bligoo-window-buttons'});
		
		var saveButtonFormItem = Builder.node('div', {'class': 'form-item'});
		saveButtonFormItem.appendChild(saveAsButton);
		
		var cancelButtonFormItem = Builder.node('div', {'class': 'form-item'});
		cancelButtonFormItem.appendChild(cancelButton);
		
		buttonsDiv.appendChild(cancelButtonFormItem);
		buttonsDiv.appendChild(saveButtonFormItem);
		div.appendChild(buttonsDiv);
		this.windowContent.update(div);
	},
	closeSaveAsWindow: function(){
		if ( this.saveAsWindow != null ){
			this.saveAsWindow.destroy();
		}
	},
	enableColorPicker: function(selector){
		$$(selector).each(function(e){
				var options = {};
				if($(e.id+'-swatch') != null){
					options = {swatch: e.id+'-swatch'};
				}
				var picker = new Control.ColorPicker(e.id, options);
				if ( $('button-enviar') != null ){
					Event.observe($('button-enviar'), "click", function(e){ if(picker.isOpen) {	picker.close(e); } }.bind(this));
				}
		}.bind());
	},
	openImageSelector: function(e, img){
		var element = img.substring(5);
    	var imagePickerWindow = new BligooWindow("image-selector",
		{
			first: 'getThemeManagerImageSelector'
			, module: 'Blog'
			, action: '/bligoo/bligoo?path=file/save/callback'
			, target: 'target_upload'
			, encType: 'multipart/form-data'
			, parameters: {value: $(element).value}
			, endFunction: this.updateImageSelected.bind(this)
			, onComplete: function(){
							var radios = $('theme-manage-image-selector-list');
							radios.select('input[type="radio"]').each(function (e){
								Event.observe(e, 'click', function (event){
									var val = event.target.value;
									$('theme-manager-selected-image').value = val;
								}.bind(this));
							}.bind(this));
						  }
			, width: 600
			, height: 400
		});
		this.imagePickerWindow = imagePickerWindow;
		this.targetElement = element;
    },
    updateImageSelected: function(){
    	var selectedValue = $('theme-manager-selected-image').value;	
    	if ( selectedValue != '' ){
	    	if (selectedValue != 'none' ){
		    	$(this.targetElement+'-image').src = this.tmpDirUrl + selectedValue;
		    	$(this.targetElement).value = "url('" + selectedValue + "?t=" + new Date().valueOf() + "')";
		    	var idDivRepeater = 'bligoo-bar-theme-basic-item-' + this.targetElement.replace('image', 'repeat');
				var divRepeater = $(idDivRepeater);
				if ( divRepeater != null ){
					divRepeater.show();
				}
		    }else{
			    $(this.targetElement+'-image').src = '/bligoo/imgbligoo/blanco.gif';
			    $(this.targetElement).value = selectedValue;    	
			    var idDivRepeater = 'bligoo-bar-theme-basic-item-'+this.targetElement.replace('image', 'repeat');
				var divRepeater = $(idDivRepeater);
				if ( divRepeater != null ){
					divRepeater.hide();
				}
			    
			}
		}
		this.imagePickerWindow.close();
    },
    fileUploaded: function(response){
    	this.refreshExtraFilesList();
    	if ($('theme-upload-iframe') != null) {
    		$('theme-upload-iframe').src = '/bligoo/bligoo?path=file/theme/upload';
    	}
    }
};

var ThemeEditorManager = null;
var TooltipManagerClass = Class.create();

TooltipManagerClass.prototype = {
    initialize : function() {
	    this.activateTooltips();
    },
    activateTooltips: function (){
		$$('div.form-item-right').each(function(item){
		    var tooltip = item.select('div.description-container.description-tooltip').first();
	    	if ( tooltip != null){
		    	item.observe('mouseover', this.showToolTip.bindAsEventListener(this, tooltip, item));
		    	item.observe('mouseout', this.hideToolTip.bindAsEventListener(this, tooltip, item));
		    	item.select('input').each(function (input){
			    	input.observe('focus', this.showToolTip.bindAsEventListener(this, tooltip, item));
			    	input.observe('blur', this.hideToolTip.bindAsEventListener(this, tooltip, item));
		    	}.bind(this));
		    	item.select('select').each(function (input){
			    	input.observe('focus', this.showToolTip.bindAsEventListener(this, tooltip, item));
			    	input.observe('blur', this.hideToolTip.bindAsEventListener(this, tooltip, item));
		    	}.bind(this));
		    	
	    	}	
		}.bind(this));
	},
	showToolTip: function(event, desc, item){
	    $$('div.description-container').each(function(tooltip){
	    	tooltip.hide();
	    }.bind(this));
		if(!desc.visible()){
			desc.setStyle('top: '+item.getHeight()+'px; left: 50px');
			Effect.Appear(desc, { duration: 0.2, queue: {position: 'end', scope: 'bligoo-tooltips'}});
		}
	},
	hideToolTip: function(event, desc){
		if(desc.visible()){
			Effect.Fade(desc, { duration: 0.1, queue: {position: 'end', scope: 'bligoo-tooltips'}});
		}
	}
};
function updateEventDiv(content, divId){
	if ( $(divId) != null ){
		$(divId).innerHTML = content;
	}
}

var VocabularyHelperClass = Class.create();
VocabularyHelperClass.prototype = {
	initialize: function(id, terms) {
		this.element = $(id);
		this.check = $('inFrontPage');
		if (this.element != null && this.check != null) {
			this.element.observe('change', this.change.bindAsEventListener(this));
			this.terms = terms;
		}
	}, 
	change: function() {
		var options = this.element.options;
		var i = 0;
		for (; i < options.length; i++) {
			var j = 0;
			for (; j < this.terms.length; j++) {
				if (options[i].value == this.terms[j] && options[i].selected) {
					this.check.checked = true;
					this.check.up().up().show();
					return;
				}
			}
		}
	}
};

var ContentCategoriesHelperClass = Class.create();
ContentCategoriesHelperClass.prototype = {
	initialize: function(confirmTxt) {
		this.confirmTxt = confirmTxt;
		this.listArea = $('bligoo-bar-category-list');
		this.enableSingleDeleteButtons();
	},
	enableSingleDeleteButtons: function(){
		this.listArea.select('.bligoo-bar-category-list-item .bligoo-bar-category-list-item-buttons img').each(function (image){
			new CrossImage(image, this.categoryDelete.bindAsEventListener(this));
		}.bindAsEventListener(this));
	},
	categoryDelete: function(e){
		if ( confirm(this.confirmTxt) ){
			var img = $(e.target);
			var idSplit = img.id.split('-');
			var categoryId = idSplit[idSplit.length-1];
			BligooBar.openCallBack('content/category/delete',{categoryId: categoryId});
		}
	}
};

var ContentCategorieTermsHelperClass = Class.create();
ContentCategorieTermsHelperClass.prototype = {
	initialize: function(confirmTxt) {
		this.confirmTxt = confirmTxt;
		this.listArea = $('bligoo-bar-category-terms');
		this.enableSingleDeleteButtons();
	},
	enableSingleDeleteButtons: function(){
		this.listArea.select('.bligoo-bar-category-terms-term img').each(function (image){
			new CrossImage(image, this.termDelete.bindAsEventListener(this));
		}.bindAsEventListener(this));
	},
	termDelete: function(e){
		if ( confirm(this.confirmTxt) ){
			var img = $(e.target);
			var idSplit = img.id.split('-');
			var termId = idSplit[idSplit.length-1];
			BligooBar.openCallBack('content/category/edit/deleteterm',{termId: termId});
		}
	}
};

var TagImageCarrouselClass = Class.create();
TagImageCarrouselClass.prototype = {
	initialize: function(blockId, data, autoSlideDelay, height){
		this.blockId = blockId;
		this.data = data;
		this.autoSlideDelay = autoSlideDelay;
		this.height = height;
		this.contentContainer = $('carrousel-main-content-'+this.blockId);
		this.contentContainer.setStyle('height: '+this.height+'px;');
		this.leftArrow =  $('carrousel-left-arrow-'+this.blockId);
		this.rightArrow =  $('carrousel-right-arrow-'+this.blockId);
		this.contentContainerWidth = this.contentContainer.getWidth();
		this.contentContainerHeight = height;
		this.currentContent = 0;
		this.isBusy = false;
		if ( data != null ){
			this.contentArray = new Array();
			this.processData();
			this.enableArrows();
			if ( this.autoSlideDelay > 0 ){
				this.periodical = new PeriodicalExecuter(this.autoSlide.bind(this), this.autoSlideDelay);
				this.contentContainer.observe('mouseover', this.stopAutoSlide.bind(this));
		        this.contentContainer.observe('mouseout', this.resetDelay.bind(this));
			}
		}
	},
	processData: function(){
		var i =0;
		this.contentContainer.setStyle('overflow: hidden;position: relative;background:#000;');
		this.data.each(function (item){
			var container = Builder.node('div', {'id': 'carrousel-'+this.blockId+'-content-container'+item.contentId, 'class': 'carrousel-content-container carrousel-content-container'+this.blockId});
			container.setStyle('position: absolute;top: 0;background: #000;width:100%;overflow: hidden;height:100%;cursor:pointer;');
			if (i == 0){
				container.setStyle('left: 0;');
			}else{
				container.setStyle('left:5000px;');
			}
			var content = Builder.node('div', {'class': 'carrousel-content-content'});
			content.setStyle('position: relative;height: 100%;width: 100%;');
			container.appendChild(content);
			var contentTitle = Builder.node('div', {'class': 'carrousel-content-title'});
			contentTitle.setStyle('position: absolute;bottom: 0; left:0;width: 100%;background:#000;color:#fff; font-size: 1.1em;font-weight: bold;z-index:10;');
			contentTitle.setOpacity(0.7);
			var contentTitleDiv = Builder.node('div', {'class': 'carrousel-content-title-div'}, item.title);
			contentTitleDiv.setStyle('padding: 5px;');
			contentTitle.appendChild(contentTitleDiv);
			content.appendChild(contentTitle);
			var contentImage = Builder.node('div', {'class': 'carrousel-content-image'});
			contentImage.update(item.imageUrl);
			contentImage.setStyle('position:absolute; top: 0; left:0;height:100%;overflow:hidden;text-align: center;width:100%;');
			var img = contentImage.select('img').first();
			img.removeAttribute('width');
			img.setAttribute('width','100%');	
			content.appendChild(contentImage);
			this.contentContainer.appendChild(container);
			this.contentArray[i] = container;
			this.contentArray[i].observe('click', this.openContent.bindAsEventListener(this, item.contentLink));
			i++;
		}.bind(this));
		this.contentNumber = i - 1;
		
	},
	openContent: function(e, link){
		location.href = link;
	},
	enableArrows: function(){
		var topPosition = (this.contentContainerHeight - this.rightArrow.getHeight())/2;
		if ( topPosition == 0 ) {
			topPosition = 5;
		}
		this.rightArrow.setStyle('position: absolute; top: '+topPosition+'px; right: 5px;z-index: 5;cursor:pointer;');
		this.rightArrow.setOpacity(0.3);
		this.rightArrow.observe('click', this.nextContent.bindAsEventListener(this));
		this.rightArrow.observe('mouseover', this.setMouseOver.bindAsEventListener(this, this.rightArrow));
        this.rightArrow.observe('mouseout', this.setMouseOut.bindAsEventListener(this, this.rightArrow));
        this.leftArrow.setStyle('position: absolute; top: '+topPosition+'px; left: 5px;z-index: 5;cursor:pointer;');
   		this.leftArrow.setOpacity(0.3);
        this.leftArrow.observe('click', this.prevContent.bindAsEventListener(this));
		this.leftArrow.observe('mouseover', this.setMouseOver.bindAsEventListener(this, this.leftArrow));
        this.leftArrow.observe('mouseout', this.setMouseOut.bindAsEventListener(this, this.leftArrow));
	},
	setMouseOver: function(e, arrow){
		arrow.setOpacity(0.7);
	},
	setMouseOut: function(e, arrow){
		arrow.setOpacity(0.3);
	},
	nextContent: function(e){
		e.stop();
		if ( this.isBusy ){
			return;
		}
		this.slideNext();
	},
	slideNext: function(){
		this.isBusy = true;		
		var nextContent = this.currentContent + 1;
		if ( nextContent >= this.contentNumber ){
			nextContent = 0;
		}
		this.contentArray[nextContent].setStyle('left: '+this.contentContainer.getWidth()+'px;');
		new Effect.Move(this.contentArray[nextContent],{x:-(this.contentContainer.getWidth()), y:0, mode:'relative', transition: Effect.Transitions.sinoidal, duration: 0.5 , queue: {position: 'end', scope: 'carrousel-queue-2-'+this.blockId, limit:1}});
		new Effect.Move(this.contentArray[this.currentContent],{x:-(this.contentContainer.getWidth()), y:0, mode:'relative', transition: Effect.Transitions.sinoidal, duration: 0.5 , queue: {position: 'end', scope: 'carrousel-queue-1-'+this.blockId,limit:1}, afterFinish: function(){this.isBusy = false;}.bind(this)});
		this.currentContent = nextContent;
	},
	prevContent: function(e){
		e.stop();
		if ( this.isBusy ){
			return;
		}
		this.isBusy = true;
		var prevContent = this.currentContent - 1;
		if ( prevContent < 0){
			prevContent = this.contentNumber;
		}
		this.contentArray[prevContent].setStyle('left: -'+this.contentContainer.getWidth()+'px;');
		new Effect.Move(this.contentArray[prevContent],{x:this.contentContainer.getWidth(), y:0, mode:'relative', transition: Effect.Transitions.sinoidal, duration: 0.5 , queue: {position: 'end', scope: 'carrousel-queue-2-'+this.blockId, limit:1}});
		new Effect.Move(this.contentArray[this.currentContent],{x:this.contentContainer.getWidth(), y:0, mode:'relative', transition: Effect.Transitions.sinoidal, duration: 0.5 , queue: {position: 'end', scope: 'carrousel-queue-1-'+this.blockId, limit:1}, afterFinish: function(){this.isBusy = false;}.bind(this)});
		this.currentContent = prevContent;
	},
	resetDelay: function(){
		if (this.autoSlideDelay > 0 ){
			this.periodical.stop();
			this.periodical = new PeriodicalExecuter(this.autoSlide.bind(this), this.autoSlideDelay);
		}
	},
	autoSlide: function(){
		if ( this.isBusy ){
			return;
		}
		this.slideNext();
	},
	stopAutoSlide: function(){
		if ( this.periodical != null ){
			this.periodical.stop();
		}
	}
};



document.observe("page:loaded", function() {
	$$('#bligoo-block-135-content div.bligoo-other-feeds-handle').each(function(e) {
		e.observe('click', function(event) {
				event.target.ancestors().first().descendants()[1].toggle();
			});
	});
});
document.observe("bligooBox:reloaded", function(event) {
	$$('#bligoo-block-135-content div.bligoo-other-feeds-handle').each(function(e) {
		e.observe('click', function(event) {
				event.target.ancestors().first().descendants()[1].toggle();
			});
	});
});

var feedApplet = null;
document.observe("bligoobar:initialized", function(event) {
	if ($('bligoo-bar-applet-feed')) {
		
		var FeedAppletClass = Class.create();
		FeedAppletClass.prototype = {
			initialize: function(applet, bar) {
				this.applet = applet;
				this.bar = bar;
				this.createPanel();
				this.applet.observe('click', this.open.bindAsEventListener(this));
				//document.observe('click', this.close.bindAsEventListener(this));
				this.bubble = new BubbleNotificator(this.applet, {onClick: this.open.bindAsEventListener(this)});
				this.originalTooltip = this.applet.getAttribute('title');
                this.updateCount(applet.getAttribute('bligooCount'), applet.getAttribute('bligooMessage'));
			    this.periodicalChecker = new PeriodicalExecuter(this.check.bind(this), 300);
			},
			open: function(event){
				event.stop();
		    	this.bar.openPath('feed');
				this.bubble.close();
				this.applet.setAttribute('title', this.originalTooltip);
			},
			close: function(event) {
				if (event.target.id != this.link.id && this.link.id != $(event.target).up().id) {
					this.panel.hide();
				}
			},
			createPanel: function() {
				this.panel = Builder.node('div', {'id': 'bligoo-bar-feed-panel'});
				this.panel.setStyle({display: 'none'});
				this.container = Builder.node('div', {'id': 'bligoo-bar-feed-panel-container'});
				this.panel.appendChild(this.container);
				this.applet.appendChild(this.panel);
				this.container.setStyle({height: '100%', width: '100%', overflow: 'auto'});
				this.panel.setStyle({height: '200px', width: '300px'});
				this.panel.setStyle({position: 'absolute'
							, top: '-' + (this.panel.getHeight() + 4) + 'px'
							, left: '-' + (this.panel.getWidth() / 2 + 47) + 'px'
							});
			},
	        check: function(){
		        this.periodicalChecker.stop();
				new Ajax.Request(
					'/bligoo/ajaxproxy', {
						method: 'feedUnread'
						, onSuccess: this.update.bind(this)
					});
			},
			update: function(transport) { 
                var info = transport.responseText.evalJSON();
                this.updateCount(info.count, info.message);
                this.messageCount = info.count;
                this.periodicalChecker = new PeriodicalExecuter(this.check.bind(this), 300);
	        },
	        updateCount: function(messages, tooltip) {
	            if (isNaN(messages)) {
                	this.bubble.close();
                	this.applet.setAttribute('title', this.originalTooltip);
	            } else if (messages == 0)  {
                		this.bubble.close();
	                	this.applet.setAttribute('title', this.originalTooltip);
                } else if(messages != this.messageCount) {
                	if (messages > 99 ){ 
    	                    this.bubble.update('99+');
	                } else {
        	                this.bubble.update(messages);
            	    }
            	    this.applet.setAttribute('title', tooltip);
            	}
	        },
	        close: function(){
		        //
	        }
		}
		
		new FeedAppletClass($('bligoo-bar-applet-feed'), event.memo);
	}
});

document.observe("bligoobar:leaf-replaced", function(event) {
	if (event.memo == 'feed') {
		new BligooBarFeedManagerClass();
	} 
});

var BligooBarFeedManagerClass = Class.create({
	initialize: function() {
		this.buttons = $$('#bligoo-bar-filter input');
		if (this.buttons != null ){
			this.enableButtons();
		}
		this.enableViewMoreLinks();
	},
	enableButtons: function(){
		this.buttons.each(function (button){
			if ( button.getAttribute('selected') != null ){
				button.addClassName('mybligoo-action-hover');
			}else{
				new HoverClass(button, 'mybligoo-action-hover');
			}
		}.bind(this));
	},
	enableViewMoreLinks: function(){
		$$('#bligoo-bar-item-content div.bligoo-other-feeds-handle').each(function(e) {
			e.observe('click', function(event) {
				event.target.ancestors().first().descendants()[1].toggle();
			});
		});
	}
});
document.observe("bligoobar:leaf-replaced", function(event) {
	if (event.memo == 'services/url') {
		$$('#bligoo-bar-item-content input.form-radio').each(function(e) {
			e.observe('click', function(event) {
				var val = event.target.value;
				if (val == 1) {
					$('bligoo-bar-dns-config-desc-1').show();
					$('bligoo-bar-dns-config-desc-2').hide();
					
					$('bligoo-bar-dns-config-absolute-url-basic').enable();
					$('bligoo-bar-dns-config-absolute-url-advanced').disable();
				} else if (val == 2) {
					$('bligoo-bar-dns-config-desc-1').hide();
					$('bligoo-bar-dns-config-desc-2').show();
					
					$('bligoo-bar-dns-config-absolute-url-basic').disable();
					$('bligoo-bar-dns-config-absolute-url-advanced').enable();
				} else {
					$('bligoo-bar-dns-config-desc-1').hide();
					$('bligoo-bar-dns-config-desc-2').hide();
					
					$('bligoo-bar-dns-config-absolute-url-basic').disable();
					$('bligoo-bar-dns-config-absolute-url-advanced').disable();
				}
			});
		});
	}
});/* Copyright (c) 2006 Yahoo! Inc. All rights reserved. */

var YAHOO = function() { return {util: {}} } ();
YAHOO.util.Color = new function() {
  
  // Adapted from http://www.easyrgb.com/math.html
  // hsv values = 0 - 1
  // rgb values 0 - 255
  this.hsv2rgb = function (h, s, v) {
    var r, g, b;
    if ( s == 0 ) {
      r = v * 255;
      g = v * 255;
      b = v * 255;
    } else {

      // h must be < 1
      var var_h = h * 6;
      if ( var_h == 6 ) {
        var_h = 0;
      }

      //Or ... var_i = floor( var_h )
      var var_i = Math.floor( var_h );
      var var_1 = v * ( 1 - s );
      var var_2 = v * ( 1 - s * ( var_h - var_i ) );
      var var_3 = v * ( 1 - s * ( 1 - ( var_h - var_i ) ) );

      if ( var_i == 0 ) { 
        var_r = v; 
        var_g = var_3; 
        var_b = var_1;
      } else if ( var_i == 1 ) { 
        var_r = var_2;
        var_g = v;
        var_b = var_1;
      } else if ( var_i == 2 ) {
        var_r = var_1;
        var_g = v;
        var_b = var_3
      } else if ( var_i == 3 ) {
        var_r = var_1;
        var_g = var_2;
        var_b = v;
      } else if ( var_i == 4 ) {
        var_r = var_3;
        var_g = var_1;
        var_b = v;
      } else { 
        var_r = v;
        var_g = var_1;
        var_b = var_2
      }

      r = var_r * 255          //rgb results = 0 � 255
      g = var_g * 255
      b = var_b * 255

      }
    return [Math.round(r), Math.round(g), Math.round(b)];
  };

  // added by Matthias Platzer AT knallgrau.at 
  this.rgb2hsv = function (r, g, b) {
      var r = ( r / 255 );                   //RGB values = 0 � 255
      var g = ( g / 255 );
      var b = ( b / 255 );

      var min = Math.min( r, g, b );    //Min. value of RGB
      var max = Math.max( r, g, b );    //Max. value of RGB
      deltaMax = max - min;             //Delta RGB value

      var v = max;
      var s, h;
      var deltaRed, deltaGreen, deltaBlue;

      if ( deltaMax == 0 )                     //This is a gray, no chroma...
      {
         h = 0;                               //HSV results = 0 � 1
         s = 0;
      }
      else                                    //Chromatic data...
      {
         s = deltaMax / max;

         deltaRed = ( ( ( max - r ) / 6 ) + ( deltaMax / 2 ) ) / deltaMax;
         deltaGreen = ( ( ( max - g ) / 6 ) + ( deltaMax / 2 ) ) / deltaMax;
         deltaBlue = ( ( ( max - b ) / 6 ) + ( deltaMax / 2 ) ) / deltaMax;

         if      ( r == max ) h = deltaBlue - deltaGreen;
         else if ( g == max ) h = ( 1 / 3 ) + deltaRed - deltaBlue;
         else if ( b == max ) h = ( 2 / 3 ) + deltaGreen - deltaRed;

         if ( h < 0 ) h += 1;
         if ( h > 1 ) h -= 1;
      }

      return [h, s, v];
  }

  this.rgb2hex = function (r,g,b) {
    return this.toHex(r) + this.toHex(g) + this.toHex(b);
  };

  this.hexchars = "0123456789ABCDEF";

  this.toHex = function(n) {
    n = n || 0;
    n = parseInt(n, 10);
    if (isNaN(n)) n = 0;
    n = Math.round(Math.min(Math.max(0, n), 255));

    return this.hexchars.charAt((n - n % 16) / 16) + this.hexchars.charAt(n % 16);
  };

  this.toDec = function(hexchar) {
    return this.hexchars.indexOf(hexchar.toUpperCase());
  };

  this.hex2rgb = function(str) { 
    var rgb = [];
    rgb[0] = (this.toDec(str.substr(0, 1)) * 16) + 
            this.toDec(str.substr(1, 1));
    rgb[1] = (this.toDec(str.substr(2, 1)) * 16) + 
            this.toDec(str.substr(3, 1));
    rgb[2] = (this.toDec(str.substr(4, 1)) * 16) + 
            this.toDec(str.substr(5, 1));
    // gLogger.debug("hex2rgb: " + str + ", " + rgb.toString());
    return rgb;
  };

  this.isValidRGB = function(a) { 
    if ((!a[0] && a[0] !=0) || isNaN(a[0]) || a[0] < 0 || a[0] > 255) return false;
    if ((!a[1] && a[1] !=0) || isNaN(a[1]) || a[1] < 0 || a[1] > 255) return false;
    if ((!a[2] && a[2] !=0) || isNaN(a[2]) || a[2] < 0 || a[2] > 255) return false;

    return true;
  };
}


/* 
   colorPicker for script.aculo.us, version 0.9
   REQUIRES prototype.js, yahoo.color.js and script.aculo.us
   written by Matthias Platzer AT knallgrau.at
   for a detailled documentation go to http://www.knallgrau.at/code/colorpicker 
 */

if(!Control) var Control = {};
Control.colorPickers = [];
Control.ColorPicker = Class.create();
Control.ColorPicker.activeColorPicker;
Control.ColorPicker.CONTROL;
/**
 * ColorPicker Control allows you to open a little inline popUp HSV color chooser.
 * This control is bound to an input field, that holds a hex value.
 */
Control.ColorPicker.prototype = {
  initialize : function(field, options) {
    var colorPicker = this;
    Control.colorPickers.push(colorPicker);
    this.field = $(field);
    this.fieldName = this.field.name || this.field.id;
    this.options = Object.extend({
       IMAGE_BASE : "/bligoo/ajax/img/"
    }, options || {});
    this.swatch = $(this.options.swatch) || this.field;
    this.rgb = {};
    this.hsv = {};
    this.isOpen = false;

    // create control (popUp) if not already existing
    // all colorPickers on a page share the same control (popUp)
    if (!Control.ColorPicker.CONTROL) {
      Control.ColorPicker.CONTROL = {};
      if (!$("colorpicker")) {
        var control = Builder.node('div', {id: 'colorpicker'});
        control.innerHTML = 
        
          '<div id="colorpicker-wrapper"><div id="colorpicker-div">' + (
            // apply png fix for ie 5.5 and 6.0
            (/MSIE ((6)|(5\.5))/gi.test(navigator.userAgent) && /windows/i.test(navigator.userAgent) && !/opera/i.test(navigator.userAgent)) ?
              '<img id="colorpicker-bg" src="' + this.options.IMAGE_BASE + 'blank.gif" style="filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\'' + this.options.IMAGE_BASE + 'pickerbg.png\', sizingMethod=\'scale\')" alt="">' :
              '<img id="colorpicker-bg" src="' + this.options.IMAGE_BASE + 'pickerbg.png" alt="">'
             ) +
          '<div id="colorpicker-bg-overlay" style="z-index: 1002;"></div>' +
          '<div id="colorpicker-selector"><img src="' + this.options.IMAGE_BASE + 'select.gif" width="11" height="11" alt="" /></div></div>' +
          '<div id="colorpicker-hue-container"><img src="' + this.options.IMAGE_BASE + 'hue.png" id="colorpicker-hue-bg-img"><div id="colorpicker-hue-slider"><div id="colorpicker-hue-thumb"><img src="' + this.options.IMAGE_BASE + 'hline.png"></div></div></div>' + 
          '<div id="colorpicker-footer"><span id="colorpicker-value">#<input type="text" onclick="this.select()" id="colorpicker-value-input" name="colorpicker-value" value=""></input></span><button id="colorpicker-okbutton">OK</button></div></div>'
        document.body.appendChild(control);
      }
      Control.ColorPicker.CONTROL = {
        popUp : $("colorpicker"),
        pickerArea : $('colorpicker-div'),
        selector : $('colorpicker-selector'),
        okButton : $("colorpicker-okbutton"),
        value : $("colorpicker-value"),
        input : $("colorpicker-value-input"),
        picker : new Draggable($('colorpicker-selector'), {
          snap: function(x, y) {
            return [
              Math.min(Math.max(x, 0), Control.ColorPicker.activeColorPicker.control.pickerArea.offsetWidth), 
              Math.min(Math.max(y, 0), Control.ColorPicker.activeColorPicker.control.pickerArea.offsetHeight)
            ];
          },
          zindex: 1009,
          change: function(draggable) {
            var pos = draggable.currentDelta();
            Control.ColorPicker.activeColorPicker.update(pos[0], pos[1]);
          }
        }),
        hueSlider: new Control.Slider('colorpicker-hue-thumb', 'colorpicker-hue-slider', {
          axis: 'vertical',
          onChange: function(v) {
            Control.ColorPicker.activeColorPicker.updateHue(v);
          }
        })
      };
      Element.hide($("colorpicker"));
    }
    this.control = Control.ColorPicker.CONTROL;

    // bind event listener to properties, so we can use them savely with Event[observe|stopObserving]
    this.toggleOnClickListener = this.toggle.bindAsEventListener(this);
    this.updateOnChangeListener = this.updateFromFieldValue.bindAsEventListener(this);
    this.closeOnClickOkListener = this.close.bindAsEventListener(this);
    this.updateOnClickPickerListener = this.updateSelector.bindAsEventListener(this);

    Event.observe(this.swatch, "click", this.toggleOnClickListener);
    Event.observe(this.field, "change", this.updateOnChangeListener);
    Event.observe(this.control.input, "change", this.updateOnChangeListener);

    this.updateSwatch();
  },
  toggle : function(event) {
    this[(this.isOpen) ? "close" : "open"](event);
    Event.stop(event);    
  },
  open : function(event) {
    Control.colorPickers.each(function(colorPicker) {
      colorPicker.close();
    });
    Control.ColorPicker.activeColorPicker = this;
    this.isOpen = true;
    Element.show(this.control.popUp);
    /*if (this.options.getPopUpPosition) {
       var pos = this.options.getPopUpPosition.bind(this)(event);
    } else {
      var pos = Position.cumulativeOffset(this.swatch || this.field);
      pos[0] = (pos[0] + (this.swatch || this.field).offsetWidth + 10);
    }*/
    //this.control.popUp.style.left = (pos[0]) + "px";
    var top = (document.viewport.getHeight() - 135) / 2;
    this.control.popUp.style.top = top + "px";
    this.updateFromFieldValue();
    Event.observe(this.control.okButton, "click", this.closeOnClickOkListener);
    Event.observe(this.control.pickerArea, "mousedown", this.updateOnClickPickerListener);
    if (this.options.onOpen) this.options.onOpen.bind(this)(event);
    if (isIE6()) {
    	var offsets =  document.viewport.getScrollOffsets();
    	var colorpicker = $('colorpicker');
        if(colorpicker != null){
        	 colorpicker.absolutize();
       		 colorpicker.setStyle({'top': (offsets[1] + (document.viewport.getHeight()/2) - colorpicker.getHeight()) + 'px'});
        }
    }
  },
  close : function(event) {
    if (Control.ColorPicker.activeColorPicker == this) Control.ColorPicker.activeColorPicker = null;
    this.isOpen = false;
    Element.hide(this.control.popUp);
    Event.stopObserving(this.control.okButton, "click", this.closeOnClickOkListener);
    Event.stopObserving(this.control.pickerArea, "mousedown", this.updateOnClickPickerListener);
    if (this.options.onClose) this.options.onClose.bind(this)();
  },
  updateHue : function(v) {
    var h = (this.control.pickerArea.offsetHeight - v * 100) / this.control.pickerArea.offsetHeight;
    if (h == 1) h = 0;
    var rgb = YAHOO.util.Color.hsv2rgb( h, 1, 1 );
    if (!YAHOO.util.Color.isValidRGB(rgb)) return;
    this.control.pickerArea.style.backgroundColor = "rgb(" + rgb[0] + ", " + rgb[1] + ", " + rgb[2] + ")";
    this.update();
  },
  updateFromFieldValue : function(event) {
    if (!this.isOpen) return;
    var field = (event && Event.findElement(event, "input")) || this.field;
    var rgb = YAHOO.util.Color.hex2rgb( field.value );
    if (!YAHOO.util.Color.isValidRGB(rgb)) return;
    var hsv = YAHOO.util.Color.rgb2hsv( rgb[0], rgb[1], rgb[2] );
    this.control.selector.style.left = Math.round(hsv[1] * this.control.pickerArea.offsetWidth) + "px";
    this.control.selector.style.top = Math.round((1 - hsv[2]) * this.control.pickerArea.offsetWidth) + "px";
    this.control.hueSlider.setValue((1 - hsv[0]));
  },
  updateSelector : function(event) {
    var xPos = Event.pointerX(event);
    var yPos = Event.pointerY(event);
    var pos = Position.cumulativeOffset($("colorpicker-bg"));
    this.control.selector.style.left = (xPos - pos[0] - 6) + "px";
    this.control.selector.style.top = (yPos - pos[1] - 6) + "px";
    this.update((xPos - pos[0]), (yPos - pos[1]));
    this.control.picker.initDrag(event);
  },
  updateSwatch : function() {
    var rgb = YAHOO.util.Color.hex2rgb( this.field.value );
    if (!YAHOO.util.Color.isValidRGB(rgb)) return;
    this.field.style.backgroundColor = "rgb(" + rgb[0] + ", " + rgb[1] + ", " + rgb[2] + ")";
    var hsv = YAHOO.util.Color.rgb2hsv( rgb[0], rgb[1], rgb[2] );
    this.field.style.color = (hsv[2] > 0.65) ? "#000000" : "#FFFFFF";
  },
  update : function(x, y) {
    if (!x) x = this.control.picker.currentDelta()[0];
    if (!y) y = this.control.picker.currentDelta()[1];

    var h = (this.control.pickerArea.offsetHeight - this.control.hueSlider.value * 100) / this.control.pickerArea.offsetHeight;
    if (h == 1) { h = 0; };
    this.hsv = {
      hue: 1 - this.control.hueSlider.value,
      saturation: x / this.control.pickerArea.offsetWidth,
      brightness: (this.control.pickerArea.offsetHeight - y) / this.control.pickerArea.offsetHeight
    };
    var rgb = YAHOO.util.Color.hsv2rgb( this.hsv.hue, this.hsv.saturation, this.hsv.brightness );
    this.rgb = {
      red: rgb[0],
      green: rgb[1],
      blue: rgb[2]
    };
    this.field.value = YAHOO.util.Color.rgb2hex(rgb[0], rgb[1], rgb[2]);
    this.control.input.value = this.field.value;
    this.updateSwatch();
    if (this.options.onUpdate) this.options.onUpdate.bind(this)(this.field.value);
  }
}
var DiffusionPluginClass = Class.create(BligooPluginClass, {
  init: function(message) {
	document.observe("page:loaded", function(event) {
		$$('.diffusion-site-block').each(function(e) {
			e.observe('click', function(event) {
				event.stop();
				document.location.href='/diffusion/site#diffusion-form';
			});
		});
	});
	
	document.observe("bligoobar:initialized", function(event) {
		if ($('bligoo-bar-applet-diffusion-spread')) {
			var SpreadAppletClass = Class.create();
			SpreadAppletClass.prototype = {
				initialize: function(applet, bar) {
					applet.observe('click', function(e) {document.location.href='/bligoo/bligoo?path=diffusion/site1#diffusion-form'});
			    }
			}
			new SpreadAppletClass($('bligoo-bar-applet-diffusion-spread'), event.memo);
		}
	});
	
	document.observe("bligoobar:leaf-replaced", function(event) {
		if (event.memo == 'mybligoo') {
			if ($('mybligoo-action-spread') != null) {
				$('mybligoo-action-spread').observe('click', function(e) {
					var window = new BligooWindow('diffusion-site', {
						first: 'windowDiffusionSite'
						, module: 'Diffusion'
						, width: 460
						, height: 440
					});
					window.show();
				});
			}
		}
	});
  }
});

PluginManager.add(new DiffusionPluginClass());//////////////////////////////////////////////////////////////
//  Voto de contenidos ///////////////////////////////////////
//////////////////////////////////////////////////////////////
function voteContentDown(linkId, id, msg){
	$('vote-links-content-'+id).innerHTML= msg;
	new Ajax.Request(
			'/bligoo/ajaxproxy', {
				method: 'votecontentdown'
				, parameters: {contentId: id}
				, onSuccess: function(transport){
								$('vote-links-content-'+id).up().innerHTML = transport.responseText;
								//$('vote-links-content-'+id).innerHTML= transport.responseText;
							}
	});
}
function voteContentUp(linkId, id, msg){
	$('vote-links-content-'+id).innerHTML= msg;
	new Ajax.Request(
			'/bligoo/ajaxproxy', {
				method: 'votecontentup'
				, parameters: {contentId: id}
				, onSuccess: function(transport){
								$('vote-links-content-'+id).up().innerHTML= transport.responseText;
								//$('vote-links-content-'+id).innerHTML= transport.responseText;
							}
	});
}
function nullVoteContent(linkId, id, msg){
	$('vote-links-content-'+id).innerHTML= msg;
	new Ajax.Request(
			'/bligoo/ajaxproxy', {
				method: 'nullcontentvote'
				, parameters: {contentId: id}
				, onSuccess: function(transport){
								$('vote-links-content-'+id).up().innerHTML= transport.responseText;
								//$('vote-links-content-'+id).innerHTML= transport.responseText;
							}
	});
}
//////////////////////////////////////////////////////////////
//  Voto de comentarios //////////////////////////////////////
//////////////////////////////////////////////////////////////
function voteCommentDown(linkId, id, msg){
	$('vote-links-comment-'+id).innerHTML= msg;
	new Ajax.Request(
			'/bligoo/ajaxproxy', {
				method: 'votecommentdown'
				, parameters: {commentId: id}
				, onSuccess: function(transport){
								$('vote-links-comment-'+id).up().innerHTML= transport.responseText;
								//$('vote-links-comment-'+id).innerHTML= transport.responseText;
							}
	});
}
function voteCommentUp(linkId, id, msg){
	$('vote-links-comment-'+id).innerHTML= msg;
	new Ajax.Request(
			'/bligoo/ajaxproxy', {
				method: 'votecommentup'
				, parameters: {commentId: id}
				, onSuccess: function(transport){
								$('vote-links-comment-'+id).up().innerHTML= transport.responseText;
								//$('vote-links-comment-'+id).innerHTML= transport.responseText;
							}
	});
}
function nullVoteComment(linkId, id, msg){
	$('vote-links-comment-'+id).innerHTML= msg;
	new Ajax.Request(
			'/bligoo/ajaxproxy', {
				method: 'nullcommentvote'
				, parameters: {commentId: id}
				, onSuccess: function(transport){
								$('vote-links-comment-'+id).up().innerHTML= transport.responseText;
								//$('vote-links-comment-'+id).innerHTML= transport.responseText;
							}
	});
}

function collapseComments(){
    var commentsToCollapse = $$('span.comment-to-collapse');
    for ( var i=0; i<commentsToCollapse.length; i++){
       	var linkId = commentsToCollapse[i].id;
       	var msgId = linkId.substring(19);
       	var commentContainer = $('comment-'+msgId);
       	var collapsedDivs = commentContainer.select('div.comment-collapsed');
       	collapsedDivs[0].show();
       	var extendedDiv = commentContainer.select('div.comment');
       	extendedDiv[0].hide();
       	var linksDiv = commentContainer.select('div.links');
       	linksDiv[0].hide();

    	Element.observe($('expand-'+msgId), 'click', this.expandComment.bindAsEventListener(this, msgId));
    }
}

function expandComment(event, msgId){
	var commentContainer = $('comment-'+msgId);
    var collapsedDivs = commentContainer.select('div.comment-collapsed');
    collapsedDivs[0].hide();
    var extendedDiv = commentContainer.select('div.comment');
    extendedDiv[0].show();
    var linksDiv = commentContainer.select('div.links');
    linksDiv[0].show();
}
document.observe("page:loaded", function() { 
	collapseComments();
});


var Blidget = Class.create({
  initialize: function(id) {
     this.element = $(id);
     this.configId = this.getConfigId();
     this.id = id;
     this.blockId = this.id.split('-')[1];

     if ( $$('#' + id + ' img.close-button').length == 0 ){
        var handler = Builder.node('div', {'class': 'block-handle', 'id': 'block-handle-' + this.blockId});
        handler.appendChild(Builder.node('img', {'class': 'close-button', 'src': '/bligoo/imgbligoo/blidgets/button-close.gif', 'border': '0'}));
        handler.appendChild(Builder.node('img', {'class': 'block-configure', 'src': '/bligoo/imgbligoo/blidgets/button-config.gif', 'border': '0'}));
	 	this.element.insert({top: handler});
     }
     $$('#' + id + ' img.close-button')[0].observe('click', this.remove.bindAsEventListener(this));
     $$('#' + id + ' img.block-configure')[0].observe('click', this.configure.bindAsEventListener(this));
     
  }, 
  getConfigId: function() {
  	var id = 0;
  	this.element.classNames().each(function(name) {
  			if (name.indexOf('block-id-') == 0) {
  				id = name.split('-')[2];
  			}
  		});
  	return id;
  },
  remove: function(event) {
  	if (!confirm(tr("BlogBean.confirm.blidget.delete"))) {
    	return ;
    } 
    var myAjax = new Ajax.Request(
	"/bligoo/ajaxproxy",{
		method: 'removeBlock' 
		, parameters: { blockId: this.configId}
		, onComplete: function(transport) {this.element.remove();}.bind(this)
	});
  },
  configure : function(event){
	var window = new BligooWindow("blidget-config",
		{
			first: 'getBlockConfigForm'
			, module: 'Block'
			, parameters: {configId: this.configId}
			, endFunction: this.update.bind(this)
			, onComplete: this.postConfigure.bind(this)
			, width: 420
			, height: 500
			, skipScripts: true
		});
	this.window = window;
  },
  postConfigure: function(){
		enableColorPicker('#bligoo-window-blidget-config .bligoo-color-picker-input');
		$('custom-access-content-div').hide();
		$('tag-access-div').hide();
		$('block-form-edit-tab-2').hide();
		var radios = $('block-form-edit-tab-2');
		radios.select('input[type="radio"]').each(function (e){
			if (e.checked && e.value == 4){
				$('custom-access-content-div').show();
			}
			if (e.checked && e.value == 3){
				$('tag-access-div').show();
			}
			e.observe('click', function (event){
				var val = event.target.value;
				if ( val == 4 ){
					$('custom-access-content-div').show();
					$('tag-access-div').hide();
				}else if ( val == 3 ){
					$('tag-access-div').show();
					$('custom-access-content-div').hide();
				}else{
					$('custom-access-content-div').hide();
					$('tag-access-div').hide();
				}
			});
		});
		
		$$('#bligoo-tabs .bligoo-tab').each(function(e){
			e.observe('click', function(tab){
				$$('#bligoo-tabs .bligoo-tab').each(function(t){t.removeClassName('active-tab');});
				$$('#bligoo-tabs .bligoo-tab').each(function(t){t.addClassName('inactive-tab');});
				tab.target.addClassName('active-tab');
				tab.target.removeClassName('inactive-tab');
				if ( tab.target.identify() == 'tab-config' ){
					$('block-form-edit-tab-1').show();
					$('block-form-edit-tab-2').hide();
				} else {
					$('block-form-edit-tab-1').hide();
					$('block-form-edit-tab-2').show();
				}
			});
		}); 
		this.window.show();
	},
	update: function(){
		var formParams = $H(this.window.getForm().serialize(true));
	    formParams = formParams.merge({ blidgetlist: true, edit: true});
		var myAjax = new Ajax.Request(
			"/bligoo/ajaxproxy", 	{
			method: 'updateblockconfigform' 
			, parameters: formParams
			, onComplete: this.updateBlockDisplay.bind(this)
		});
	}, 
	updateBlockDisplay: function(request){
		var text = request.responseText;
		var configId = text.substring(0, text.indexOf("&"));
		text = text.substring(text.indexOf("&") + 1);
		if(configId == 'error'){
			$('errors').style.display = 'block';
			$('errors').update(text);
			this.window.enableEditors();
			return;
		}
		$(configId).update(text);
		new Blidget(configId);
		$('errors').update('');
		$('errors').style.display = 'none';
		this.closeConfigWindow();
	},
	closeConfigWindow: function(){
		this.window.close();
	}
});

var BlidgetsManagerClass = Class.create({
	initialize: function(bligooBar) {
		if (this.isInBlidgets()) {
			this.bligooBar = bligooBar;
			this.pagePath = bligooBar.pagePath;
			this.bligooBar.panel.startWaiting();
			document.observe("bligoobar:blidget-editor-ready", this.enableAll.bindAsEventListener(this));
			this.oldblockids = "";
			this.bligooBar.setWatch(null, this.destroy.bind(this));
			this.observeBlidgetList();
			this.setPageForEdit();
		}
	},
	isInBlidgets: function() {
		return $('bligoo-bar-menu-item-theme-blidgets') != null;
	},
	observeBlidgetList: function(){
		var insertBlidget = this.insertBlidget.bindAsEventListener(this);
		$('bligoo-bar-blidget-list-pane').select('.bligoo-bar-blidget-list-pane-item').each(function (div){
			div.observe('click', insertBlidget);
		});
	},
	setPageForEdit: function(){
		this.bligooBar.panel.startWaiting();
		var myAjax = new Ajax.Request(
			"/bligoo/ajaxproxy", 
			{
				method: 'drawblogcolumns' 
				, parameters: { current: true, edit: true, blidgetlist: true}
				, onComplete: function (transport){
					if (this.isInBlidgets()) {
						this.initBlogColumns();
						this.updateColumns(transport.responseText.evalJSON());
						this.bligooBar.panel.stopWaiting();
						if (!this.isInBlidgets()) {
							this.destroy();
						}
					}
				}.bind(this)
			});	
	},
	updateColumns: function(result){
    	$R(0, 16).each(function(e){
    		if ( $('column-content-'+e) != null ){
    			$('column-content-'+e).innerHTML = eval('result.column'+e);
    		}
		});
		this.createBlidgets(); 
		this.makeColumnsSortable();
	},
	makeColumnsSortable: function(){
		var columns = $A();
		$R(0, 16).each(function(e){
			columns.push('column-content-' + e);	
		});
		
		columns.each(function(column) {
				if($(column) != null){
				    var columnNum = column.split('-')[2];
				    if ( columnNum < 5 ){
						$(column).addClassName('bligoo-blidget-edit-column');
					}else{
						$(column).addClassName('bligoo-blidget-edit-row');
					}
					Sortable.create(column, {
						format: /^[^_\-](?:[A-Za-z0-9\-\_]*)[-](.*)$/
						, dropOnEmpty:true
						, tag:'div'
						, only:'block'
						, containment: columns
						, constraint: false
						, onUpdate: this.endBlockDrag.bind(this)}); 
				}
			}.bind(this));	
	},
	endBlockDrag: function(){
		var ret = '';
		$$('div.column-content').each(function(column){
			var blocks = '';
			$$('#' + column.id + ' > div.block').each(function(block){
				blocks += '@' + this.getConfigId(block.id);
			}.bind(this));
			var colId = column.id.split('-')[2];
			ret += '.' + colId + ',' + blocks;
		}.bind(this));
		if (ret != this.oldblockids) {
			this.oldblockids = ret;
			new Ajax.Request("/bligoo/ajaxproxy",{
				method: 'saveBlocksPositions' 
				,parameters: { blocks: ret	}
			});
		}
	},
	getConfigId: function (id) {
	  	var element = $(id);
  		var configId = 0;
  		element.classNames().each(function(name) {
  			if (name.indexOf('block-id-') == 0) {
  				configId = name.split('-')[2];
  			}
  		}.bind(this));
	  	return configId;
  	},
	createBlidgets: function(){
		$$('div.column div.block').each(function(e) { new Blidget(e.id); });
		$$('td.column div.block').each(function(e) { new Blidget(e.id); });
	},
	initBlogColumns: function(){
	    var header = $$("table#main thead#main-header tr td")[0];
	    var footer = $$("table#main tfoot#main-footer tr td")[0];
	    header.writeAttribute({colspan: 6});
	    footer.writeAttribute({colspan: 6});
	    var mainRow = $$("table#main tbody#main-tbody tr#main-tr")[0];
	    if($('column-0')==null){
	    	mainRow.insert({top: this.makeColumn(0)});
    		$('column-0').setStyle({height: '100%', width: '100px'});
	    }
	    if($('column-1')==null){
	    	$('column-0').insert({after: this.makeColumn(1)});
    		$('column-1').setStyle({height: '100%', width: '100px'});
	    }
	    if($('column-4')==null){
	    	mainRow.insert({bottom: this.makeColumn(4)});
	    	$('column-4').setStyle({height: '100%', width: '100px'});
	    	$('column-content-4').addClassName('recycle-blidgets');
	    }
	    if($('column-3')==null){
	    	$('column-4').insert({before: this.makeColumn(3)});
	    	$('column-3').setStyle({height: '100%', width: '100px'});
	    }
	    if($('column-2')==null){
	    	$('column-3').insert({before: this.makeColumn(2)});
	    	$('column-2').setStyle({height: '100%', width: '100px'});
	    }
	
		$$('a.horizontal-column').each(function(d){
			var id = (d.id).split('-')[2];
			if ( $('column-'+id) == null ){
				d.insert({after: this.makeDivCol(id)});
			}
		}.bind(this));
		if(isIE6()){
			$$('.bligoo-blidget-edit-column').each(function(col){
				col.setStyle({height: '1000px', width: '100px'});
			});
			$$('.bligoo-blidget-edit-row').each(function(row){
				row.setStyle({height: '50px', width: '100%'});
			});
		}
	},
	makeColumn: function(idx){
		var td = Builder.node('td', {'class': 'column', 'id': 'column-'+idx});
		td.appendChild(Builder.node('div', {'class': 'column-content bligoo-blidget-edit-column', 'id': 'column-content-'+idx}));
		return td;
	},
	makeDivCol: function(idx){
		var td = Builder.node('div', {'class': 'column', 'id': 'column-'+idx});
		td.appendChild(Builder.node('div', {'class': 'column-content bligoo-blidget-edit-row', 'id': 'column-content-'+idx}));
		return td;
	},
	getBlock: function(blockName, module) {
		var myAjax = new Ajax.Request(
			"/bligoo/ajaxproxy", {
				method: 'getActiveBlock' 
				, parameters: {blockClass: blockName, module: module, blidgetlist: true, edit: true}
				, onSuccess: this.drawBlock.bind(this)
				, onFailure: function(response){alert(tr("BlockBean.error.block.server.error"));}
		});	 
	},
	drawBlock: function(request) {
		var text = request.responseText;
		var block = text.substring(text.indexOf('|') + 1);
		var id = text.substring(0, text.indexOf('|'));
		$('column-content-0').insert({top: block});
		new Blidget(id);
		$(id).scrollTo();
		this.makeColumnsSortable();
	},
	insertBlidget: function(e){
		var o = e.target;
		if (o != null) {
			while (!o.hasClassName('bligoo-bar-blidget-list-pane-item')) {
				o = o.up();
			}
			var attributes = o.id.split('-');
			this.getBlock(attributes[0], attributes[1]);
		}
	},
	reloadSite: function(){
		this.bligooBar.panel.startWaiting();
		location.reload();
	},
	destroy: function(){
		this.disableColumnsSortable();
		this.resetBlidgets();
	},
	disableColumnsSortable: function(){
		var columns = $A();
		$R(0, 16).each(function(e){
			columns.push('column-content-' + e);	
		});
		columns.each(function(column) {
			if($(column) != null){
				var columnNum = column.split('-')[2];
				if ( columnNum < 4 ){
					Sortable.destroy(column); 
					$(column).removeClassName('bligoo-blidget-edit-column');
					$(column).innerHTML = '';
				}else if ( columnNum == 4 ){
					$(column).remove();
				}else{
					Sortable.destroy(column); 
					$(column).removeClassName('bligoo-blidget-edit-row');
					$(column).innerHTML = '';
				}
			}
		}.bind(this));	
	},
	resetBlidgets: function(){
		this.bligooBar.panel.startWaiting();
		var myAjax = new Ajax.Request(
			"/bligoo/ajaxproxy", 
			{
				method: 'drawblogcolumns' 
				, parameters: { current: true, edit: false, blidgetlist: false, path: this.pagePath}
				, onComplete: function (transport){
					this.finishResetBlidgets(transport.responseText.evalJSON());
					this.bligooBar.panel.stopWaiting();
				}.bind(this)
			});	
	},
	finishResetBlidgets: function(result){
    	$R(0, 16).each(function(e){
    		if ( $('column-content-'+e) != null ){
    			if (eval('result.column'+e) == null || eval('result.column'+e) == '' ){
    				$('column-'+e).remove();
    			}else{
	    			$('column-content-'+e).innerHTML = eval('result.column'+e);
	    		}
    		}
		});
		$('column-4').remove();
	},
	enableAll: function(e){
		this.bligooBar.panel.stopWaiting();
		$(document.body).stopWaiting();
	}
});

var BlidgetsManager = null;
function refreshSiteAvatar(){
	var avatarPic = $('site-avatar-image');
	if ( avatarPic != null ){
		var src = avatarPic.src;
		var srcSplited = src.split('?');
		var baseImageSrcClean = srcSplited[0];
		var currentDate = new Date();
		avatarPic.src = baseImageSrcClean+"?ver="+currentDate.valueOf();
	}
}


function openImageEditWindow(imageTitle, endFunction, width, height, imageEBId){
	new ImageEditor('image-for-edit', endFunction, width, height, imageEBId);
}

var ImageEditor = Class.create();
ImageEditor.prototype = {
initialize: function(imageId, endFunction, width, height, imageEBId, buttonType, table){
		this.imageId = imageId;
		this.table = table;
		this.endFunction = endFunction;
		this.imageWidth = width;
		this.imageHeight = height;
		this.imageEBId = imageEBId;
		this.buttonType = buttonType;
		this.isWaiting = false;
		this.createBligooWindow();
	},
	createBligooWindow: function(){
		this.window = new BligooWindow("image-editor",
		{
			first: 'openImageEditWindow'
			, module: 'ImageUpload'
			, parameters: {imageId: this.imageEBId, buttonType: this.buttonType, table: this.table}
			, onComplete: this.initTools.bind(this)
			, width: 600
			, height: 400
		});
	},
	initTools: function(){
		this.startPageUpdater();
		this.cropper = new CropperTool(this.imageId, this.window, this);
		this.resizer = new ResizeTool(this.imageId, this.window, this);
		this.transform = new TransformTool(this.imageId, this.window, this);
		this.undoButton = $('image-editor-button-undo');
		this.saveButton = $('image-editor-button-save');
		this.saveButton.observe('click', this.saveImage.bind(this));
		this.cancel = $$('#bligoo-window-content-image-editor .bligoo-button-close').first();
		
		if (this.cancel != null) {
			this.cancel.observe('click', this.onBeforeClose.bindAsEventListener(this));
		}
		if (this.undoButton != null) {
			this.undoButton.observe('click', this.undo.bindAsEventListener(this));
			this.setUndoEnabled(false);
		}
		this.image = $('image-for-edit');
		this.imageEditorContainer = $('image-editor-outer-container');
	},
	onBeforeClose: function(event) {
		this.cropper.onBeforeClose();
		this.resizer.onBeforeClose();
		this.transform.onBeforeClose();
	},
	undo: function() {
		if (this.undoButton != null) {
			this.setUndoEnabled(false);
			this.startSpinner();
			new Ajax.Request("/bligoo/ajaxproxy", {
				method: 'undoImageEdit'
				, parameters: {imageId: this.imageEBId, table: this.table}
				, onComplete: this.postUndo.bind(this)
			});
		}
    }
	,setUndoEnabled: function(enabled) {
		this.undoButton.disabled = !enabled;
		if (enabled) {
			this.undoButton.removeClassName('disabled');
		} else {
			if (!this.undoButton.hasClassName('disabled')) {
				this.undoButton.addClassName('disabled');
			}
		}
	}
	, postUndo: function(transport) {
		var ret = transport.responseText.evalJSON();
		this.recreateImage(ret.src);
		this.setImageDirty({width: ret.width, height: ret.height});
		this.setUndoEnabled(false);
		this.stopSpinner();
	}
	, stopSpinner: function(){
			this.imageEditorContainer.stopWaiting();
	}
	, startSpinner: function() {
			this.imageEditorContainer.startWaiting('bigBlackWaiting');
	},
	recreateImage: function(newImageSrc){
		if ( this.cropper != null ){
			this.cropper.cleanAll();
		}
		if ( this.resizer != null ){
			this.resizer.cleanAll();
		}
		if ( this.transform != null ){
			this.transform.cleanAll();
		}
		var img = "<img src='" + newImageSrc + "?v=" + (new Date().valueOf()) + "' id='image-for-edit'/>";
		$('image-editor-container').update(img);
		this.image = $('image-for-edit');
	},
	setImageDirty: function(info){
		if ( info.width != null  && info.width > 0 ){
			this.imageWidth = info.width;
		}
		if ( info.height != null && info.height > 0 ){
			this.imageHeight = info.height;
		}
		this.cropper.update(info);
		this.resizer.update(info);
		this.transform.update(info);
		this.stopSpinner();
		this.setUndoEnabled(true);
	},
	saveImage: function(){
		this.endPeriodical();
		this.startSpinner();
		var myAjax = new Ajax.Request(
		"/bligoo/ajaxproxy", 
		{
			method: 'saveCroppedImage' 
			, parameters: {
				src: this.cleanImgSrc(this.image.src)
				, imageId: this.imageEBId
				, width: this.imageWidth
				, height: this.imageHeight
				, table: this.table
				}
			, onComplete: this.afterSaveImage.bind(this)
		});
	},
	cleanImgSrc: function(src){
		return src.split('?')[0];
	},
	afterSaveImage: function(){
		this.onBeforeClose();
		this.window.close();
		if ( this.endFunction != null ){
			this.endFunction();
		}
	},
	startPageUpdater: function(){
		if ( this.periodical == null ){
			this.periodical = new PeriodicalExecuter(this.scrollMainWindow.bind(this), 1);
			var close = $$('#' + this.window.content.id + ' .bligoo-button-close').first();
			if ( close != null ){
				close.observe('click', this.endPeriodical.bind(this));
			}
		}
	},
	scrollMainWindow: function(){
		if ( this.cropper != null ){
			$('main-body').scrollTo();
		}
	},
	endPeriodical: function(){
		if (this.periodical != null ){
			this.periodical.stop();
		}
	}
};

var CropperTool = Class.create();
CropperTool.prototype = {
	initialize: function(imageId, window, editor){
		this.window = window;
		this.imageId = imageId;
		this.editor = editor;
		this.image = $(imageId);
		this.imageSrc = this.image.src;
		this.selectionWidth = $('image-editor-cropper-tool-selection-width');
		this.selectionHeight = $('image-editor-cropper-tool-selection-height');
		this.cropButton = $('image-editor-cropper-tool-button');
		this.cropButton.observe('click', this.cropImage.bind(this));
		this.enableCropper();		
		this.disableButton();
	},
	enableCropper: function(){
		if (this.cropper != null) {
			this.cropper.remove();
		}
		this.cropper = new Cropper.Img(this.imageId,{ onEndCrop: this.onEndCrop.bind(this) }, this.editor.imageWidth, this.editor.imageHeight);	
	},
	onEndCrop: function(coords, dimensions) {
		this.x1 = coords.x1;
		this.y1 = coords.y1;
		this.x2 = coords.x2;
		this.y2 = coords.y2;
		this.width = dimensions.width;
		this.height= dimensions.height;
		if ( this.width > 0 && this.height > 0 ){
			this.selectionWidth.value = dimensions.width;
			this.selectionHeight.value = dimensions.height;
			this.enableButton();
		}else{
			this.disableButton();
		}
	},
	enableButton: function(){
		this.cropButton.disabled = false;
		this.cropButton.removeClassName('disabled');
	},
	disableButton: function(){
		this.cropButton.disabled = true;
		this.cropButton.addClassName('disabled');
	},
	cropImage: function(){
		if (this.width > 0 && this.height > 0 ){
			this.editor.startSpinner();
			var myAjax = new Ajax.Request(
			"/bligoo/ajaxproxy", 
			{
				method: 'cropImage' 
				, parameters: {x1: this.x1, y1: this.y1, width: this.width, height: this.height, src: this.editor.cleanImgSrc(this.image.src)}
				, onComplete: this.afterCropImage.bind(this)
			});
		}
	},
	afterCropImage: function(transport){
		this.editor.recreateImage(this.image.src);
		this.editor.setImageDirty({width: this.width, height: this.height});
	},
	cleanAll: function(){
		if ( this.cropper != null ){
			this.cropper.remove();
		}
	},
	update: function(info){
		this.enableCropper();
		this.selectionWidth.value = '';
		this.selectionHeight.value = '';
		this.disableButton();
		//this.editor.stopSpinner();
	},
	onBeforeClose: function() {
		if (this.cropper != null) {
			this.cropper.remove();
		}
	}
	
};

var ResizeTool = Class.create();
ResizeTool.prototype = {
	initialize: function(imageId, window, editor){
		this.window = window;
		this.imageId = imageId;
		this.editor = editor;
		this.image = $(imageId);
		this.imageSrc = this.image.src;
		this.imageRatio = true;
		this.resizeWidth = $('image-editor-resizer-tool-width');
		this.resizeHeight = $('image-editor-resizer-tool-height');
		this.resizeWidth.value = this.editor.imageWidth;
		this.resizeHeight.value = this.editor.imageHeight;
		this.originalHeight = this.editor.imageHeight;
		this.originalWidth = this.editor.imageWidth;
		this.originalAspectRatio = this.originalWidth/this.originalHeight;
		this.ratioButtonContainer = $('image-editor-resizer-tool-ratio');
		this.button = $('image-editor-resizer-tool-button');
		this.button.observe('click', this.scaleImage.bind(this));
		this.enableImageRatioFunctions();
	},
	onBeforeClose: function() {
	},
	enableImageRatioFunctions: function(){
		this.addRatioIcon();
		this.ratioButtonIcon.observe('click', this.toggleRatioScale.bind(this));
		if ( this.imageRatio ){
			this.resizeWidth.observe('blur',this.adjustImageHeight.bind(this));
			this.resizeHeight.observe('blur', this.adjustImageWidth.bind(this));
		}else{
			this.resizeWidth.stopObserving('blur',this.adjustImageHeight.bind(this));
			this.resizeHeight.stopObserving('blur', this.adjustImageWidth.bind(this))
		}
	},
	addRatioIcon: function(){
		if ( this.imageRatio ){
			this.ratioButtonContainer.update('<img src="/bligoo/imgbligoo/bligoo/imageeditor/toolbar/ratioOn.jpg" id="ratioButtonIcon"/>');
		}else{
			this.ratioButtonContainer.update('<img src="/bligoo/imgbligoo/bligoo/imageeditor/toolbar/ratioOff.jpg" id="ratioButtonIcon"/>');
		}
		this.ratioButtonIcon = $('ratioButtonIcon');
	},
	toggleRatioScale: function(){
		if ( this.imageRatio ){
			this.imageRatio = false;
		}else{
			this.imageRatio = true;
		}
		this.enableImageRatioFunctions();
	},
	adjustImageHeight: function(){
		if ( this.imageRatio ){
			this.resizeHeight.value = parseInt(this.resizeWidth.value / this.originalAspectRatio);
		}
	},
	adjustImageWidth: function(){
		if (this.imageRatio){
			this.resizeWidth.value = parseInt(this.resizeHeight.value * this.originalAspectRatio);
		}
	},
	enableButton: function(){
		this.button.disabled = false;
		this.button.removeClassName('disabled');
	},
	disableButton: function(){
		this.button.disabled = true;
		this.button.addClassName('disabled');
	},
	scaleImage: function(){
		if ( this.resizeWidth.value > 0 && this.resizeHeight.value > 0 ){
			this.disableButton();
			this.editor.startSpinner();
			if ( this.resizeWidth.value > 1024 || this.resizeHeight.value > 1024 ){
				if ( this.resizeWidth.value > this.resizeHeight.value ){
					this.resizeWidth.value = 1024;
					this.resizeHeight.value = parseInt(1024/this.originalAspectRatio);
				}else{
					this.resizeHeight.value = 1024;
					this.resizeWidth.value = parseInt(1024*this.originalAspectRatio);
				}
			}			
			var myAjax = new Ajax.Request(
			"/bligoo/ajaxproxy", 
			{
				method: 'scaleImage' 
				, parameters: {width: this.resizeWidth.value, height: this.resizeHeight.value, src: this.editor.cleanImgSrc(this.image.src)}
				, onComplete: this.afterScaleImage.bind(this)
			});
		}
	},
	afterScaleImage: function(transport){
		this.enableButton();
		this.editor.recreateImage(this.imageSrc);
		this.editor.setImageDirty({width: this.resizeWidth.value, height: this.resizeHeight.value});
	},
	update: function(info){
		//this.editor.stopSpinner();
		if ( info.width != null && info.width > 0 ){
			this.resizeWidth.value = info.width;
		}
		if ( info.height != null && info.height > 0 ){
			this.resizeHeight.value = info.height;
		}
		if ( info.width != null && info.width > 0 && info.height != null && info.height > 0 ){
			this.originalAspectRatio = info.width/info.height;
		}
	}
	,cleanAll: function(){
	}
};

var TransformTool = Class.create();
TransformTool.prototype = {
	initialize: function(imageId, window, editor){
		this.window = window;
		this.imageId = imageId;
		this.editor = editor;
		this.image = $(imageId);
		this.rotateLeft = $('transform-tool-rotate-left');
		this.rotateRight = $('transform-tool-rotate-right');
		this.flipHorizontal = $('transform-tool-flip-horizontal');
		this.flipVertical = $('transform-tool-flip-vertical');
		
		this.rotateLeft.observe('click', this.rotate.bindAsEventListener(this, 'left'));
		this.rotateRight.observe('click', this.rotate.bindAsEventListener(this, 'right'));
		this.flipHorizontal.observe('click', this.flip.bindAsEventListener(this, 'horizontal'));
		this.flipVertical.observe('click', this.flip.bindAsEventListener(this, 'vertical'));
	},
	onBeforeClose: function() {
	},
	flip: function(event, direction){
		this.editor.startSpinner();
		this.operation = 'flip';
		var myAjax = new Ajax.Request(
			"/bligoo/ajaxproxy", {
				method: 'imageTransform' 
				, parameters: {operation: 'flip', direction: direction, src: this.editor.cleanImgSrc(this.image.src)}
				, onComplete: this.afterTransformImage.bind(this)
			});
	},
	rotate: function(event, direction) {
		this.editor.startSpinner();
		this.operation = 'rotate';
		var myAjax = new Ajax.Request(
			"/bligoo/ajaxproxy", {
				method: 'imageTransform' 
				, parameters: {operation: 'rotate', direction: direction, src: this.editor.cleanImgSrc(this.image.src)}
				, onComplete: this.afterTransformImage.bind(this)
			});
	},
	afterTransformImage: function(transport){
			this.editor.recreateImage(this.image.src);
			var info = {};
			if ( this.operation == 'rotate' ){
				info.width = this.editor.imageHeight;
				info.height = this.editor.imageWidth;
			}
			this.editor.setImageDirty(info);
	},
	update: function(info){
		this.operation = '';
	}
		,cleanAll: function(){
	}
};

var globalImageHelper;
var ImageUploadHelper = Class.create();
ImageUploadHelper.prototype = {
	initialize: function(editor){
		this.editor = editor;
		if (this.editor.selection.getNode().nodeName == 'IMG') {
			this.openConfigWindow(this.editor.selection.getNode());
		} else {
			this.openUploadWindow();
		}
		globalImageHelper = this;
		this.imageListPage = 1;
		this.blogFilter = 0;
	}
	, openConfigWindow: function(node) {
		this.editingNode = node;
		this.window = new BligooWindow("image-config",	{
					first: 'imageConfig'
					, module: 'ImageUpload'
					, width: 400
					, height: 400
					, parameters: {align: this.getAttrib(node, 'align'), border: this.getAttrib(node, 'border'), width: this.getAttrib(node, 'width'), height: this.getAttrib(node, 'height'), vmargin: this.getAttrib(node, 'vspace'), hmargin: this.getAttrib(node, 'hspace'), url: this.getAttrib(node, 'src'), alt: this.getAttrib(node, 'title')}
					, onComplete: this.initImageConfig.bind(this)
				});
	}
	, getAttrib : function(e, at) {
		var ed = this.editor, dom = ed.dom, v, v2;

		if (ed.settings.inline_styles) {
			switch (at) {
				case 'align':
					if (v = dom.getStyle(e, 'float'))
						return v;

					if (v = dom.getStyle(e, 'vertical-align'))
						return v;

					break;

				case 'hspace':
					v = dom.getStyle(e, 'margin-left')
					v2 = dom.getStyle(e, 'margin-right');
					if (v && v == v2)
						return parseInt(v.replace(/[^0-9]/g, ''));

					break;

				case 'vspace':
					v = dom.getStyle(e, 'margin-top')
					v2 = dom.getStyle(e, 'margin-bottom');
					if (v && v == v2)
						return parseInt(v.replace(/[^0-9]/g, ''));

					break;

				case 'border':
					v = 0;

					tinymce.each(['top', 'right', 'bottom', 'left'], function(sv) {
						sv = dom.getStyle(e, 'border-' + sv + '-width');

						// False or not the same as prev
						if (!sv || (sv != v && v !== 0)) {
							v = 0;
							return false;
						}

						if (sv)
							v = sv;
					});

					if (v)
						return parseInt(v.replace(/[^0-9]/g, ''));

					break;
			}
		}

		if (v = dom.getAttrib(e, at))
			return v;

		return '';
	}
	, initImageConfig: function(){
		this.imageEditSrc = $('image-config-url');
		this.imageEditDesc = $('image-config-desc');
		this.imageEditAlign = $('image-config-align');
		this.imageEditWidth = $('image-config-size-width');
		this.imageEditHeight = $('image-config-size-height');
		this.imageEditBorder = $('image-config-border');
		this.imageEditVMargin = $('image-config-vmargin');
		this.imageEditHMargin = $('image-config-hmargin');
		this.applyConfigChangesButton = $('bligoo-image-config-apply-button');
		this.applyConfigChangesButton.observe('click', this.applyConfigChanges.bind(this));
	}
	,serializeStyle : function(o) {
			var s = '';
			var oHash = $H(o);
			oHash.each(function(pair) {
				if (pair.key != '' && pair.value != '') {
					value = pair.value;
					switch (pair.key) {
						case 'margin-left':
						case 'margin-right':
						case 'margin-top':
						case 'margin-bottom':
						case 'margin':
						case 'border':
						case 'float':
						case 'vertical-align':
							s += (s ? ' ' : '') + pair.key + ': ' + value + ';';							
							break;
					}
				}
			});
			return s;
	}
	, applyConfigChanges: function(){
		args = {};
		var styles = new Array();
		if ( this.imageEditHMargin.value != '' ){
			styles['margin-left'] = this.imageEditHMargin.value + 'px';
			styles['margin-right'] = this.imageEditHMargin.value + 'px';
		}
		if ( this.imageEditVMargin.value != '' ){
			styles['margin-top'] = this.imageEditVMargin.value + 'px';
			styles['margin-bottom'] = this.imageEditVMargin.value + 'px';
		}

		if ( this.imageEditBorder.value != '' && !isNaN(this.imageEditBorder.value) ){
			if ( this.imageEditBorder.value == '0' ){
				styles['border'] = '0';
			}else{
				styles['border'] = this.imageEditBorder.value + 'px solid black';
			}
		}
		
		if ( this.imageEditAlign.value != 'none'){
			if ( this.imageEditAlign.value == 'left' || this.imageEditAlign.value == 'right' ){
				styles['float'] = this.imageEditAlign.value;
			}else{
				styles['vertical-align'] = this.imageEditAlign.value;;
			}
		}
		styles = this.editor.dom.parseStyle(this.serializeStyle(styles));
		args.style = this.serializeStyle(styles);
		if ( this.imageEditWidth.value != '' ){
			args.width = this.imageEditWidth.value;
		}
		if ( this.imageEditHeight.value != '' ){
			args.height = this.imageEditHeight.value;
		}
		if ( this.imageEditSrc.value != '' ){
			args.src = this.imageEditSrc.value;
		}
		args.title = this.imageEditDesc.value;
		
		this.editor.dom.setAttribs(this.editingNode, args);
		this.window.close();
	}
	, openUploadWindow: function() {
		this.window = new BligooWindow("tmce-image-uploader",	{
					first: 'imageInsert'
					, module: 'ImageUpload'
					, parameters: {}
					, target: 'target_upload'
					, action: '/bligoo/bligoo?path=image/save'
					, encType: 'multipart/form-data'
					, onComplete: this.init.bind(this)
					, width: 600
					, height: 450
				});
	}
	, init: function() {
		this.initButtons();
		this.updateImageList();
	}
	, initButtons: function(){
		if ($('bligoo-window-submit-extern')) {
			$('bligoo-window-submit-extern').observe('click', this.insertExtern.bindAsEventListener(this));
		}
		if ($('bligoo-window-submit-upload')) {
			$('bligoo-window-submit-upload').observe('click', this.insertUploadImage.bindAsEventListener(this));
		}
	}
	, insertUploadImage: function(event) {
		if (uploadChecker != null) {
			uploadChecker.stop();
		}
		uploadChecker = new UploadCheckerClass();
		uploadChecker.start();
		this.window.submit();
	}
	, insertExtern: function(event) {
		var name = $('image-url').value;
		if (name != null) {
			
		}
		this.insert(name, name);
	}
	, edit: function(src, title, width, height, imageEBId) {
		this.window.close();
		new ImageEditor('image-for-edit', this.insert.bind(this, src, title), width, height, imageEBId, 'image-upload');
	}
	, editAndBack: function(src, title, width, height, imageId) {
		this.window.close();
		new ImageEditor('image-for-edit', this.openUploadWindow.bind(this), width, height, imageId, 'image-edit');
	}
	, insert: function(src, title, data) {
		var args = {src: src + '?v=' + new Date().valueOf(), title: title, style: 'margin-left: 4px; margin-right: 4px; margin-top: 4px; margin-bottom: 4px; border: 0'};
		if (data!= null) {
			if (data.width > 0) {
				args.width = data.width;
			}
			if (data.height > 0) {
				args.height = data.height;
			}
		}
		this.editor.execCommand('mceInsertContent', false, '<img id="__mce_tmp" src="javascript:;" />', {skip_undo : 1});
		this.editor.dom.setAttribs('__mce_tmp', args);
		this.editor.dom.setAttrib('__mce_tmp', 'id', '');
		this.editor.undoManager.add();
		this.window.close();
	}
	, updateImageList: function() {
		if ($('bligoo-image-insert-list')) {
			$('bligoo-image-insert-list').startWaiting('bigWaiting');
			new Ajax.Updater('bligoo-image-insert-list'
				, '/bligoo/ajaxproxy', {
					 method: 'updateImageList'
					,parameters: {page: this.imageListPage, blogFilter: this.blogFilter}
					,onComplete: this.postUpdateList.bind(this)
			});
		}
	}
	, postUpdateList: function(){
		if ( $('image-upload-image-list-pager-prev') != null ){	
			$('image-upload-image-list-pager-prev').observe('click', this.imageListPrevPage.bind(this));
		}
		if ( $('image-upload-image-list-pager-next') != null ){
			$('image-upload-image-list-pager-next').observe('click', this.imageListNextPage.bind(this));
		}
		if ( $('image-upload-image-list-blog-filter') != null ){
			$('image-upload-image-list-blog-filter').observe('change', this.updateBlogFilter.bind(this));
		}
		$('bligoo-image-insert-list').select('.insertable-image').each(function(div) {
			var id = div.select('.image-info-id').first().value;
			var src = div.select('.image-info-src').first().value;
			var width = div.select('.image-info-width').first().value;
			var height = div.select('.image-info-height').first().value;
			var insert = div.select('.image-link-insert').first();
			var img = div.select('img').first();
			var del = div.select('.image-link-delete').first();
			var edit = div.select('.image-link-edit').first();
			insert.observe('click', this.insert.bind(this, src, src, {width: width, height: height}));
			img.observe('click', this.insert.bind(this, src, src, {width: width, height: height}));
			
			del.observe('click', this.deleteImage.bind(this, id));
			
			edit.observe('click', this.editAndBack.bind(this, src, src, width, height, id));
		}.bind(this));
		$('bligoo-image-insert-list').stopWaiting();
	}
	, deleteImage: function(imageId) {
		if(confirm(tr('ImageUploadBean.message.image.delete.confirm'))){
			new Ajax.Request("/bligoo/ajaxproxy", {
				method: 'imageDelete' 
				, parameters: {imageId: imageId}
				, onComplete: this.postDeleteImage.bind(this, imageId)
			});
		}
	}
	, postDeleteImage: function(imageId) {
		var image = $('insertable-image-' + imageId);
		if (image != null) {
			this.updateImageList();
		}
	}
	, updateBlogFilter: function(){
		if ( $('image-upload-image-list-blog-filter').value != this.blogFilter ){
			this.imageListPage = 1;
			this.blogFilter = $('image-upload-image-list-blog-filter').value;
		}
		this.updateImageList();
	}
	, imageListNextPage: function(){
		this.imageListPage++;
		this.updateImageList();
	}
	, imageListPrevPage: function(){
		this.imageListPage--;
		this.updateImageList();
	}
}

var ImageEditorHelperClass = Class.create();
ImageEditorHelperClass.prototype = {
	initialize: function() {
	},
	edit: function(width, height, fileId, type) {
		new ImageEditor('image-for-edit', null, width, height, fileId, 'image-save', type);
	}
}

var ImageEditorHelper = new ImageEditorHelperClass();

document.observe("bligoo:file-uploaded", function(event) {
	if (event.memo.id == 'bar-upload-image') {
		if (event.memo.error != null && $('upload-messages') != null) {
			$('upload-messages').update(event.memo.error);
			$('upload-messages').show();
		} else if (event.memo.message != null && $('upload-messages') != null) {
			$('upload-messages').update(event.memo.message);
			$('upload-messages').show();
			$('bligoo-quota-percent').update(event.memo.quotaPercent);
			$('bligoo-quota-used').update(event.memo.quotaUsed);
			$('bligoo-quota-total').update(event.memo.quotaTotal);
			$('bligoo-bar-progress-bar-ammount').setStyle({ 'width' : event.memo.quotaPercent + '%' });
			BligooBar.panel.stopWaiting();
		}
	} else if (event.memo.id == 'tmce-upload-image') {
		if (event.memo.error != null && $('upload-messages') != null) {
			$('upload-messages').update(event.memo.error);
			$('upload-messages').show();
		} else {
			if (event.memo.image == true) {
				/* ImageEditorHelper.edit(event.memo.width, event.memo.height, event.memo.fileId, 'image'); */
				globalImageHelper.edit(event.memo.url, event.memo.filename, event.memo.width, event.memo.height, event.memo.fileId);
			}
		}
	} else if (event.memo.id == 'upload-avatar' ){
		if ( event.memo.error != null ){
			alert(event.memo.error);
		}else{
			if ($('bligoo-window-edit-avatar-picture') != null){
				var currentDate = new Date();
				$('bligoo-window-edit-avatar-picture').src = event.memo.url + "&ver2=" + currentDate.valueOf();
			}
		}
		if ($('bligoo-window-submit-upload-avatar') != null ){
			$('bligoo-window-submit-upload-avatar').stopWaiting();
		}
	} else if (event.memo.id == 'avatar-tmp-upload' ){
		if (event.memo.error != null) {
			alert(event.memo.error);
		}else{
			var filename = event.memo.avatar;
			if ($('bligoo-window-tmp-avatar-picture') != null ){
				$('bligoo-window-tmp-avatar-picture').src = filename;
			}
		}
		enableButtons();
	}
});

var AvatarUploadHelper = Class.create({
	initialize: function(bligooWindow){
		if ( bligooWindow == null ){
			return;
		}
		this.window = bligooWindow;
		this.enableWindowButtons();
	},
	enableWindowButtons: function(){
		this.uploadButton = $('bligoo-window-submit-upload-avatar');
		this.uploadButton.observe('click', this.uploadAvatar.bind(this));
	},
	uploadAvatar: function(){
		this.uploadButton.startWaiting('waiting');
		/*
		if (uploadChecker != null) {
			uploadChecker.stop();
		}
		uploadChecker = new UploadCheckerClass();
		uploadChecker.start();
		*/
		this.window.submit();
	}
});
document.observe("bligoowindow:content-replaced", function(event) {
	if ( $('bligoo-window-submit-upload-avatar') != null ){
		new AvatarUploadHelper(event.memo);
	}
});function confirmFileDelete(question, fileId){
	var answer = confirm(question);
	if(answer){
		var myAjax = new Ajax.Request(
		"/bligoo/ajaxproxy", 
		{
			method: 'get' 
			, parameters: "method=deleteFile&fileId=" + fileId
			, onComplete: function(request){
					new Effect.Fade('file-info-' + request.responseText);
				}
		});
	}
}

document.observe("bligoo:file-uploaded", function(event) {
	if (event.memo.id == 'bar-upload-file') {
		if (event.memo.error != null && $('upload-messages') != null) {
			$('upload-messages').update(event.memo.error);
			$('upload-messages').show();
		} else if (event.memo.message != null && $('upload-messages') != null) {
			$('upload-messages').update(event.memo.message);
			$('upload-messages').show();
			$('bligoo-quota-percent').update(event.memo.quotaPercent);
			$('bligoo-quota-used').update(event.memo.quotaUsed);
			$('bligoo-quota-total').update(event.memo.quotaTotal);
			$('bligoo-bar-progress-bar-ammount').setStyle({ 'width' : event.memo.quotaPercent + '%' });
			/*
			if (event.memo.image == true) {
				ImageEditorHelper.edit(event.memo.width, event.memo.height, event.memo.fileId, 'file');
			}
			*/
			BligooBar.panel.stopWaiting();
		}
	} else if (event.memo.id == 'tmce-upload-file-full') {
		if (event.memo.error != null && $('upload-messages') != null) {
			alert(event.memo.error);
		} else if (event.memo.message != null && $('upload-messages') != null) {
			alert(event.memo.message);
		}
	}
});

function addAlternatives(groupId, numAlternatives, msg){		
	var altDiv = $(groupId);
	var nAlts = 0;
	var nChilds = altDiv.immediateDescendants().length;	
	var descendants = altDiv.immediateDescendants();
	for(i=0; i<nChilds; i++)
		if(descendants[i].hasClassName('alternative'))
			nAlts++;
	
	var newAltDiv;
	for(i=nAlts+1; i<=numAlternatives+nAlts; i++){
		newAltDiv = createNewAltDiv(i);
		altDiv.appendChild(newAltDiv);
	}
	if(nAlts == 2)
		new Insertion.After('add-alternative','<a class="remove-alternative" id="remove-alternative" href="javascript:void(0);" onclick="javascript: removeAlternative(\''+groupId+'\');">'+msg+'</a>');
}

function removeAlternative(groupId){
	var altDiv = $(groupId);	
	var descendants = altDiv.immediateDescendants();
	var nAlts = descendants.length;
		
	if(nAlts > 2){
		descendants[nAlts-1].innerHTML = '"<div class=\"form-item\">'+nAlts+'. <input class=\"text-field\" name=\"edit[choice-'+nAlts+']\" maxlength=\"255\" size=\"80\" value=\"\" type=\"text\"></div>"';
		descendants[nAlts-1].remove();
	}
	if(nAlts == 3)
		$('remove-alternative').remove();
}

function createNewAltDiv(id){
	var newDiv = document.createElement('div');
	newDiv.className = 'form-item';
	var newInput = document.createElement('input');
	newInput.className = 'text-field';
	newInput.setAttribute('name','edit[choice-'+id+']');
	newInput.setAttribute('maxlength','255');
	newInput.setAttribute('size','80');
	newInput.setAttribute('type','text');
	newDiv.appendChild(document.createTextNode(id+'. '));
	newDiv.appendChild(newInput);
	var ret = document.createElement('div');
	ret.className = 'alternative';
	ret.appendChild(newDiv);
	return ret;
}
function initEmailLoginFields(){
	$$('.login-email-field').each(function(field) {
			field.observe('blur', function(e) {
				var email = Event.element(e).value;
				if(email != null && email.strip() != ''){
					new Ajax.Updater(
						'password-container', 
						'/bligoo/ajaxproxy', {
							method: 'getPasswordField', 
							parameters: {email: email}
						});
				}
			});
		});
}

document.observe("page:loaded", function() {
	initEmailLoginFields();
});
var ContactFormPluginClass = Class.create(BligooPluginClass, {
  init: function(message) {
		document.observe("bligoobar:leaf-replaced", function(event) {
			if (event.memo == 'mybligoo') {
				if ($('mybligoo-action-contact') != null) {
					$('mybligoo-action-contact').observe('click', function(e) {
						var window = new BligooWindow('contact-form', {
							first: 'contactFormWindow'
							, module: 'ContactForm'
							, width: 460
							, height: 440
						});
						window.show();
					});
				}
			}
		});
		
		document.observe("page:loaded", function() {
			$$('.contact-form-block').each(function(e) {
				e.observe('click', function(event) {
					event.stop();
					document.location.href='/contact#contact-form';
				});
			});
		});
	}
});

PluginManager.add(new ContactFormPluginClass());var ImportHelper = Class.create();
ImportHelper.prototype = {
	initialize: function(){
	},
	start: function(type){
		$('import-table').update('');
		this.getContent(type, 0);
	},
	getContent: function (type, next){
		new Ajax.Request('/bligoo/ajaxproxy',{
			method: 'importcontent',
			parameters: {next: next, type: type},
			onComplete: this.onComplete.bind(this)
		});
	},
	onComplete: function(transport){
		var params = transport.responseText.evalJSON();
		if ( params.code == 'error' ){
			//$('spinner').remove();
			new Insertion.Bottom('import-table','<div><strong>' + params.msg + '</strong></div>');
		} else if (params.code == 'end') {
			this.finishImport(blogId);
		} else {
			new Insertion.Top('import-table','<div>' + params.msg + '</div>');
			this.getContent(params.type, params.next);
		}
	},
	finishImport: function(blogId){
		BligooBar.openCallBack('services/import/step2/step3/step4')
	}
}

var BlogImporter = new ImportHelper();

document.observe("bligoo:file-uploaded", function(event) {
	if (event.memo.id == 'import-file-upload') {
		if (event.memo.error != null && $('upload-messages') != null) {
			$('upload-messages').update('<div class="bligoo-bar-errors-img bligoo-bar-use-sprite"></div><ul><li>' + event.memo.error + '<li></ul></div>');
			$('upload-messages').show();
			BligooBar.panel.stopWaiting();
		} else {
			BligooBar.openCallBack('services/import/step2/step3', event.memo)
		}
	}
});
document.observe("bligoobar:leaf-replaced", function(event) {
	if (event.memo == 'people/groups/groups/edit') {
		initPermits();
	} else if (event.memo == 'people/groups/groups') {
		new DeleteItemHelperClass('bligoo-bar-menu-item-people-groups-groups', 'people/groups/groups/delete');
	} else if (event.memo == 'mybligoo') {
		if ($('mybligoo-action-community-subscribe') != null) {
			$('mybligoo-action-community-subscribe').observe('click', function(e) {Profile.communitySubscribe({ email: '', url: '', userId: ''});});
		} else if ($('mybligoo-action-community-unsubscribe') != null) {
			$('mybligoo-action-community-unsubscribe').observe('click', function(e) {
				var text = $('mybligoo-action-community-unsubscribe').getAttribute("bligooText");
				var button = $('mybligoo-action-community-unsubscribe').getAttribute("bligooOkButton");
				var window = new BligooWindow('community-unsubscribe', {
					first: 'communityUnsubscribeWindow'
					, module: 'Group'
					, width: 460
					, height: 300
					, finalFunction: function () {
						new BligooSiteReloaderClass('/', 60, text, button, '');
					}
				});
				window.show();
			});
		}
	} else if (event.memo == 'people/search'){
		new CommunityPeopleSearch(false, BligooBar);
	} else if (event.memo == 'people/manage/suspended' || event.memo == 'people/manage/authors' || event.memo == 'people/manage/editors' || event.memo == 'people/manage/administrators'){
		new CommunityPeopleSearch(true, BligooBar);
	} 
});


function initPermits() {
	$$('#bligoo-bar-menu-item-people-groups-groups-edit .parent-permit-check').each(function(check) {
			var checkId = check.id.substring(22);
			if ($('parent-permit-' + checkId)) {
	  			if (check.checked) {
	  				$('parent-permit-' + checkId).show();
	  			} else {
	  				$('parent-permit-' + checkId).hide();
	  			}
  			}
	  		check.observe('click', function(e) {
				var id = e.target.id.substring(20);
				if ($('parent-permit-' + id)) {
					$('parent-permit-' + id).toggle(); 
				}
				if (!e.target.checked) {
					$$('.child-permit-check-' + id).each(function(child) { 
							child.checked = false; 
							child.disabled = true;
						});
				} else {
					$$('.child-permit-check-' + id).each(function(child) { 
							child.disabled = false;
						});
				}
	  		});
	  });
}


var MembersManager = Class.create();
MembersManager.prototype = {
	initialize: function() {
		if ($('bligoo-filter-mark-all') != null ) {
			$('bligoo-filter-mark-all').observe('click', this.markAll.bindAsEventListener(this));
		}
		if ($('bligoo-filter-mark-none') != null) {
			$('bligoo-filter-mark-none').observe('click', this.markNone.bindAsEventListener(this));
		}
	},
	markAll: function() {
		$$('.manage-member-user-list-item input').each(function(e) { e.checked = true; }); 
	},
	markNone: function() {
		$$('.manage-member-user-list-item input').each(function(e) { e.checked = false; }); 
	}
}

document.observe("bligoobar:initialized", function(event) {

	var SubscribeAppletClass = Class.create();
	SubscribeAppletClass.prototype = {
		initialize: function(link, bar) {
			link.observe('click', this.click.bindAsEventListener(this));
		},
		click: function(event) {
			Profile.communitySubscribe({ email: '', url: '', userId: ''});
		}
	}

	if ($('bligoo-bar-applet-subscribe')) {
		new SubscribeAppletClass($('bligoo-bar-applet-subscribe'), event.memo);
	}
});


var CommunityPeopleSearch = Class.create();
CommunityPeopleSearch.prototype = {
	initialize: function(userSelectables, bligooBar) {
		this.itemsList = $$('#bligoo-bar-item-content .bligoo-bar-user-itemwrapper');
		this.items = new Array();
		this.userSelectables = userSelectables;
		if ( this.itemsList != null ){
			var i=0;
			this.itemsList.each(function (item){
				this.items[i] = new CommunityPeopleItem(item,this.userSelectables, bligooBar);
				i++;
			}.bind(this));
		}
	}
};

var CommunityPeopleItem = Class.create();
CommunityPeopleItem.prototype = {
	initialize: function(item, userSelectables, bligooBar) {
		this.item = item;
		this.bligooBar = bligooBar;
		this.userSelectables = userSelectables;
		this.userId = item.getAttribute('bligooUserId');
		this.enableCheckbox();
		this.selected = this.item.hasClassName('bligoo-bar-user-itemwrapper-selected');
		this.searchForLinks();	
		this.searchForIcon();
		if (this.userSelectables && this.addChk != null && this.remChk != null){
			this.item.observe('mouseover', this.over.bind(this));
			this.item.observe('mouseout', this.out.bind(this));
			this.item.observe('click', this.click.bind(this));
		}
		this.busy = false;
	},
	searchForIcon: function(){
		var icon = this.item.select('.members-user-item-icon').first();
		if (icon != null ){
			this.icon = icon;
			if ( this.selected ){
				this.icon.show();
			}
		}
	},
	enableCheckbox: function(){
		var addChk = this.item.select('input.add').first();
		if ( addChk != null ){
			this.addChk = addChk;
		}else{
			this.addChk = null;
		}
		var remChk = this.item.select('input.remove').first();
		if ( remChk != null ){
			this.remChk = remChk;
		}else{
			this.remChk = null;
		}
	},
	out: function(event){
		this.item.removeClassName('bligoo-bar-user-itemwrapper-over');
	},
	over: function(event){
		this.item.addClassName('bligoo-bar-user-itemwrapper-over');
	},
	click: function(event){
		if ( this.selected ){
			this.selected = false;
			this.item.removeClassName('bligoo-bar-user-itemwrapper-selected');
			if ( this.addChk != null ){
				this.addChk.checked = false;
			}
			if ( this.remChk != null ){
				this.remChk.checked = true;
			}
			if ( this.icon != null ){
				this.icon.hide();
			}
			
		}else{
			this.selected = true;
			this.item.addClassName('bligoo-bar-user-itemwrapper-selected');
			if ( this.addChk != null ){
				this.addChk.checked = true;
			}
			if ( this.remChk != null ){
				this.remChk.checked = false;
			}
			if ( this.icon != null ){
				this.icon.show();
			}
		}
	},
	searchForLinks: function(){
		this.item.select('.profile-view-actions .members-user-item-action').each(function (action){
			if ( action.hasClassName('members-user-action-contact-remove' )){
				action.observe('click', this.removeContact.bind(this));
			}
			if ( action.hasClassName('members-user-action-contact-add' )){
				action.observe('click', this.addContact.bind(this));
			}
			if ( action.hasClassName('members-user-action-write-message' )){
				action.observe('click', this.composeMessage.bind(this));
			}
			if ( action.hasClassName('members-user-action-view-profile')){
				action.observe('click', this.viewProfile.bindAsEventListener(this, action));
			}
		}.bind(this));
	},
	removeContact: function(){	
		if ( !this.busy ){
			this.busy = true;
			this.item.startWaiting('waiting');				
			new Ajax.Request(
				'/bligoo/ajaxproxy', {
					method: 'userContactRemove'
					, parameters: {userId: this.userId}
					, onSuccess: this.refreshActions.bind(this)});
		}
	},
	addContact: function(){
		if ( !this.busy ){
			this.busy = true;
			this.item.startWaiting('waiting');		
			new Ajax.Request(
			'/bligoo/ajaxproxy', {
				method: 'userContactAdd'
				, parameters: {userId: this.userId}
				, onSuccess: this.refreshActions.bind(this)});
		}
	},
	composeMessage: function(){
		BligooBar.openPath('messages', $H({'reply-userId': this.userId, 'return-to': 'people/search'}));
	},
	refreshActions: function(transport){
		actionsArea = this.item.select('.profile-view-actions').first();
		if ( actionsArea != null ){
			actionsArea.update(transport.responseText);
		}
		this.searchForLinks();	
		this.item.stopWaiting();
		new Effect.Highlight(this.item, { startcolor: '#88b6da',endcolor: '#ffffff', afterFinish: function(){
			this.busy = false;
		}.bind(this)});
	},
	viewProfile: function(e, actionItem){
		this.bligooBar.panel.startWaiting();
		location.href = actionItem.getAttribute("urlLink");
	}
};


function updateLocalizationLevel(level){
	var iddivadminpadre = '';
	if($('localization-level-'+(level-1))){
		var elmt = $('select-level-'+(level-1));
		iddivadminpadre = elmt.value;		
	}
	new Ajax.Request('/bligoo/ajaxproxy',{
		method: 'getlocalizationlevel',
		parameters: {iddivadminpadre: iddivadminpadre, level: level},
		onComplete: function(transport){
			var html = transport.responseText;
			if('' == html){
				var i = level;
				var id = 'localization-level-' + i;
				while($(id)){
					$(id).remove();
					i++;
					id = 'localization-level-' + i;
				}
				updateAddressMap();
			}
			else{
				if ($('localization-level-'+level)) {
					$('localization-level-'+level).replace(html);
				} else {
					new Insertion.After('localization-level-'+(level-1),html);
				}
				updateLocalizationLevel(level+1);
			}
		}
	});
}

function updateAddressMap(){
	var i = 1;
	var id = 'localization-level-' + i;
	var preAddress = '';
	while($(id)){
		var elmt = $('select-level-'+(i));
		if (elmt.value > 0){
			if (i ==1){
				preAddress = elmt[elmt.selectedIndex].text;
			}else{
				preAddress += ', '+elmt[elmt.selectedIndex].text;
			}
		}
		i++;
		id = 'localization-level-' + i;
	}
	$('addres-map-frame').src = "/bligoo/map?action=profileAddress&preAddress=" + encodeURIComponent(preAddress)+"&resetXY=true";
}

var FavoriteLink = Class.create();

FavoriteLink.prototype = {
	initialize: function(element, id, labels){
		this.element = element;
		this.labels = labels;
		this.id = id;
		this.element.observe('click', this.click.bindAsEventListener(this));
	}, 
	click: function(event) {
		event.stop();
		if (this.element.hasClassName('favorite')) {
			this.sendAction('remove');
			if (this.labels) {
				this.element.update(tr('FavoritesBean.link.add'));
			}
			this.element.addClassName('not-favorite');
			this.element.removeClassName('favorite');
			if (this.element.getAttribute('bligooAddtitle') != null ){
				this.element.title = this.element.getAttribute('bligooAddtitle');
			}
		} else {
			this.sendAction('add');
			if (this.labels) {
				this.element.update(tr('FavoritesBean.link.remove'));
			}
			this.element.addClassName('favorite');
			this.element.removeClassName('not-favorite');
			if (this.element.getAttribute('bligooRemoveTitle') != null ){
				this.element.title = this.element.getAttribute('bligooRemoveTitle');
			}
		}		
		
	},
	sendAction: function (option) {
		new Ajax.Request(
				'/bligoo/ajaxproxy', {
					method: 'favoritesToggle'
					, parameters: {contentId: this.id, op: option}
					, onComplete: function(transport) {new Effect.Highlight(this.element, {duration: 0.4})}.bind(this)
		});	
	}
};

document.observe("page:loaded", function() {
	$$('a.favorite-link').each(function(e){
		new FavoriteLink(e, e.id.split('-')[2], true);
	});	
	$$('.content-channel-favorite').each(function(div) {
		new FavoriteLink(div, div.id.split('-')[3], false);
	});
});

function composeMessageTo(userId){
	BligooBar.openPath('messages', $H({'reply-userId': userId}));
}


var BligooBarMessageClass = Class.create();
BligooBarMessageClass.prototype = {
	initialize: function(item) {
		this.item = item;
		var dots = this.item.select('.bligoo-bar-message-dot');
		this.dot = dots[0];
		var divs = this.item.select('.bligoo-bar-message-col-1');
		this.div = divs[0];
		var idsplit = this.div.id.split('-');
		this.msgId = idsplit[idsplit.length-1];
		this.initObservers();
	},
	initObservers: function(){
		this.observerRead = this.markRead.bindAsEventListener(this);
		this.observerUnread = this.markUnread.bindAsEventListener(this);
   		this.observerOver = this.showImage.bindAsEventListener(this);
   		this.observerOut  = this.hideImage.bindAsEventListener(this);
   		
   		if ( this.dot.visible() ){
    		this.dot.observe('click', this.observerRead);
    	}else{
    		this.div.observe('mouseover', this.observerOver);
    		this.div.observe('mouseout', this.observerOut );
    		this.dot.observe('click', this.observerUnread);
    	}
	}, 
	markRead: function(){
		new Ajax.Request(
			'/bligoo/ajaxproxy', {
				method: 'markMessageRead'
				, parameters: {messageId: this.msgId}
				, onSuccess: this.successMarkRead.bind(this)});
	},
	successMarkRead: function(transport){
    	this.item.removeClassName('bligoo-bar-message-unreaded');
		this.dot.hide();
		this.dot.stopObserving('click', this.observerRead);
		this.div.observe('mouseover', this.observerOver);
		this.div.observe('mouseout', this.observerOut);
		this.dot.observe('click', this.observerUnread);
		if (messagesApplet != null) {
			messagesApplet.check();
		}
	},
	markUnread: function(){
		new Ajax.Request(
			'/bligoo/ajaxproxy', {
				method: 'markMessageUnread'
				, parameters: {messageId: this.msgId}
				, onSuccess: this.successMarkUnread.bind(this)});
	},
	successMarkUnread: function(transport){
		this.item.addClassName('bligoo-bar-message-unreaded');
		this.dot.show();
	    this.div.stopObserving('mouseover', this.observerOver);
		this.div.stopObserving('mouseout', this.observerOut);
		this.dot.stopObserving('click', this.observerUnread);
		this.dot.observe('click', this.observerRead);
		if (messagesApplet != null) {
			messagesApplet.check();
		}
	},
	showImage: function (event){
		this.dot.show();
	},
	hideImage: function (event){
		this.dot.hide();
	}
}

document.observe("bligoobar:leaf-replaced", function(event) {
	if (event.memo == 'messages') {
		new DeleteItemHelperClass('bligoo-bar-messages-list', 'messages/deletesingle');
		$$('.bligoo-bar-message').each( function (item){
			new BligooBarMessageClass(item);
		});
	}
});

var MessagesAppletClass = Class.create({
	initialize: function(applet, bar) {
		this.bar = bar;
		this.appletDivLink = null;
		this.bubble = new BubbleNotificator(applet, {onClick: this.open.bindAsEventListener(this)});
		this.applet = applet;
		this.originalTooltip = this.applet.getAttribute('title');
		var messages = applet.getAttribute("bligooCount");
		if (messages != null) {
			this.messageCount = parseInt(messages);
			this.bubble.update(this.messageCount);
			this.bubble.setTooltip(applet.getAttribute("bligooMessage"));
			this.applet.setAttribute('title', applet.getAttribute("bligooMessage"));
		} else {
			this.messageCount = 0;
		}
	    this.periodicalChecker = new PeriodicalExecuter(this.check.bind(this), 300);
		this.applet.observe('click', this.open.bindAsEventListener(this));
		document.observe("bligoobar:leaf-replaced", this.checkRead.bind(this));
    },
    checkRead: function(event) {
	    if (event.memo == 'messages/read') {
			this.check();
		}
    },
    open: function(event) {
    	event.stop();
    	this.applet.addClassName("pushed");
    	this.bar.openPath('messages');
    },
    check: function(){
        this.periodicalChecker.stop();
		new Ajax.Request(
			'/bligoo/ajaxproxy', {
				method: 'messagesUnreadInfo'
				, onSuccess: this.update.bind(this)
			});
	},
	update: function(transport) { 
        var info = transport.responseText.evalJSON();
        if (isNaN(info.count)) {
        	this.bubble.close();
        	this.applet.setAttribute('title', this.originalTooltip);
        } else {
            if (info.count == 0) {
            	this.bubble.close();
            	this.applet.setAttribute('title', this.originalTooltip);
            } else if (info.count != this.messageCount) {
                if ( this.messageCount > 99 ){
                   	this.bubble.update('99+');
                } else {
                   	this.bubble.update(info.count);
                }
                this.bubble.setTooltip(info.message);
            	this.applet.setAttribute('title', info.message);
            }
            this.messageCount = info.count;
        }
        this.periodicalChecker = new PeriodicalExecuter(this.check.bind(this), 300);
        
    },
    close: function(){
    	this.appletDivLink.hide();
    }
});

var messagesApplet = null;
document.observe("bligoobar:initialized", function(event) {
	if ($('bligoo-bar-applet-messages')) {
		messagesApplet = new MessagesAppletClass($('bligoo-bar-applet-messages'), event.memo);
	}
});



document.observe("bligoobar:initialized", function(event) {
	if ($('bligoo-bar-applet-logout')) {
		var LogoutAppletClass = Class.create();
		LogoutAppletClass.prototype = {
			initialize: function(applet, bar) {
				applet.observe('click', function(e) {document.location.href='/bligoo/bligoo?path=logout'});
		    }
		}
		
		new LogoutAppletClass($('bligoo-bar-applet-logout'), event.memo);
	}
});


document.observe("bligoobar:leaf-replaced", function(event) {
	if (event.memo == 'mybligoo') {
		$$('.mybligoo-action').each(function(button) {
			new HoverClass(button, 'mybligoo-action-hover');
		});
	}
});

document.observe('page:loaded', function(event) {
 		$$('.country-selector-menu-item').each(function(item) {
 			new HoverClass(item, 'country-selector-menu-item-over');
        });
});


var autoSaveTimeout;

function doSaveChanges(){
	//addButtonMessage('button-save-async', tr('ContentBean.button.saving'));
	saveContentAsync();
} 

var AUTO_SAVE_TIMEOUT = 60000;

function startAutoSave(){
	autoSaveTimeout = setTimeout('saveContentAsync()', AUTO_SAVE_TIMEOUT);
}
function doSaveDraft(){
	if(autoSaveTimeout > 0){
		clearTimeout(autoSaveTimeout);
	}
	showBubble('autosave-bubble', tr('ContentBean.button.saving'));
	saveContentAsync();
} 

function addButtonMessage(button, message){
	if($(button)){
		var value = $(button).value;
		if(value.indexOf('-') > 0){
			value = value.substring(0, value.indexOf('-', -2));
		}
		$(button).value = value.strip() + ' - ' + message;
	}
}

function showBubble(bubble, text){
	if($(bubble)){
		$(bubble).innerHTML = text;
		$(bubble).show();
	}
}

function hideBubble(bubble){
	if($(bubble)){
		$(bubble).hide();
	}
}
// fix TINYMCE
function saveContentAsync(){
	if($('button-save-async') != null){
		$('button-save-async').disabled = true;
	}
	tinyMCE.triggerSave();
 	var myAjax = new Ajax.Request(
		"/bligoo/ajaxproxy", 
		{
			method: 'savecontentasync' 
			, parameters: $('edit-content-form').serialize(true)
			, onSuccess: function(transport){
							if(transport.responseText == 'ok'){
	 							
	 							var currentTime = new Date()
	 							var minutes = getWithZeros(currentTime.getMinutes());
	 							var seconds = getWithZeros(currentTime.getSeconds());
	 							var hours = getWithZeros(currentTime.getHours());
	 							var text = '(' + tr('ContentBean.button.saved.at') + ' ' + hours + ':' + minutes + ':' + seconds + ')'
								showBubble('autosave-bubble', text);				
 							}else{
 								alert(transport.responseText);
 							}
						}
		});
 }

function getWithZeros(value){
	return value < 10 ? '0' + value : value;
}

function funcionOnChange(e){
	if($('button-save-async') && $('button-save-async').disabled){
		autoSaveTimeout = setTimeout('saveContentAsync()', AUTO_SAVE_TIMEOUT);
		$('button-save-async').disabled = false;
		hideBubble('autosave-bubble');
	}
	return true;
}

function addChangeDraftObservers(){
 	$$('#edit-content-form input').each(
 		function(e){
 			if(e.type != 'submit' && e.type != 'button'){
 				var f = function(n){
	 					if($('button-save-async') != null && $('button-save-async').disabled){
 							autoSaveTimeout = setTimeout('saveContentAsync()', AUTO_SAVE_TIMEOUT);
		 					$('button-save-async').disabled = false;
		 					hideBubble('autosave-bubble');
	 					}
	 				};
	 			e.onchange = f;
	 			e.onkeypress = f;
	 			e.onfocus = f;
	 		}
 		}
 	);
 }

 function addChangeObservers(){
 	$$('#edit-content-form input').each(
 		function(e){
 			if(e.type != 'submit' && e.type != 'button'){
 				// alert(e.type);
 				var f = function(n){
	 					if($('button-save-async') != null && $('button-save-async').disabled){
		 					$('button-save-async').disabled = false;
	 					}
	 				};
	 			e.onchange = f;
	 			e.onkeypress = f;
	 			e.onfocus = f;
	 		}
 		}
 	);
 }

function googleSearchInit(noresults, site, keywords) {
	var searchControl = new google.search.SearchControl();
	var searcherOptions = new google.search.SearcherOptions();
	searcherOptions.setNoResultsString(noresults);

	var webSearch = new google.search.WebSearch();
	webSearch.setSiteRestriction(site);
	searchControl.addSearcher(webSearch, searcherOptions);

	/*
	var imageSearch = new google.search.ImageSearch();
	imageSearch.setSiteRestriction(site);
	searchControl.addSearcher(imageSearch, searcherOptions);
	*/
	
	var drawOptions = new google.search.DrawOptions();
	drawOptions.setDrawMode(google.search.SearchControl.DRAW_MODE_TABBED);
	
	searchControl.setResultSetSize(google.search.Search.LARGE_RESULTSET);
	searchControl.draw(document.getElementById('google-search'), drawOptions);
	searchControl.setLinkTarget(google.search.Search.LINK_TARGET_SELF);
	
	searchControl.execute(keywords);
}

function addMP3Players() {
	var i = 0;
	$$('.main-body-content .content-body a').each(function(link) {
		var match = /\.mp3$/i.exec(link.href);
	    if (match != null && match.length > 0) {
	    	 var id = 'flash-mp3-player-' + i;
                var span = new Element('span');
                span.update('<object class="bligoo-mp3-button-player" type="application/x-shockwave-flash" width="20" height="20" data="/bligoo/swf/musicplayer.swf?song_url=' + link.href + '">'     
                            + '<param name="movie" value="/bligoo/swf/musicplayer.swf?song_url=' + link.href + '" />'
							+ '<param name="wmode" value="transparent"></param>'
							+ '<embed class="bligoo-mp3-button-player" src="/bligoo/swf/musicplayer.swf?song_url=' 
								+ link.href + '" wmode="transparent" type="application/x-shockwave-flash" width="20" height="20"></embed>'
                            + '</object>');

                link.insert({before: span});
                i++;
	    }
	});
}


function addContentGeoLocalizationAutoData(){
	var item = google.loader.ClientLocation;
	if ( item != null ){
		$('geolocAddress').value = item.address.country_code+", "+item.address.country+", "+item.address.region+", "+item.address.city;
		$('geolocCountryCode').value = item.address.country_code;
		$('geolocLatitude').value = item.latitude;
		$('geolocLongitude').value = item.longitude;
	}
}

var ContentGeolocalizatedMap = Class.create();
ContentGeolocalizatedMap.prototype = {
	initialize: function( contentId, x, y, baseUrl ) {
		this.contentId = contentId;
		this.baseUrl = baseUrl;
		this.pinx = x;
		this.piny = y;
		this.contentBody = $('body-'+contentId);
		this.mapDisplay = $('content-geolocalization-'+contentId);
		this.mapViewLink = this.contentBody.select('a.view-map-link')[0];
		this.mapViewLink.observe('click', this.goToMapPin.bindAsEventListener(this));
	},
	goToMapPin: function(e){
		var newIframeSrc = this.baseUrl;
		var pinsVar = this.pinx+"|"+this.piny;
		var currentDate = new Date();
		if ( $('content-geolocalizated-map-'+this.contentId) != null ){
			$('content-geolocalizated-map-'+this.contentId).remove();
		}
		newIframeSrc+= '?action=nextEventBlidgetsMap&pins='+pinsVar+'&configId='+this.blidgetId+'&ver='+currentDate.valueOf();
		var content = "<iframe id='content-geolocalizated-map-"+this.contentId+"' src='"+newIframeSrc+"' frameborder='0' class='content-geolocalizated-map'></iframe>";
		this.mapDisplay.insert({after: content});
	}
};

function enableContentMap(contentId, x, y, baseUrl){
	new ContentGeolocalizatedMap(contentId, x, y, baseUrl);
}

var ContentManager = Class.create();
ContentManager.prototype = {
	initialize: function() {
		if ($('more-filters') != null && $('more-filters').visible()) {
			$('more-filters').observe('click', function(e) { 
				$('content-filter-more').toggle(); 
				$('more-filters').toggle(); 
				BligooBar.barItem.calculateHeight();
			});
		}
		if ($('bligoo-filter-mark-all') != null ) {
			$('bligoo-filter-mark-all').observe('click', this.markAll.bindAsEventListener(this));
		}
		if ($('bligoo-filter-mark-none') != null) {
			$('bligoo-filter-mark-none').observe('click', this.markNone.bindAsEventListener(this));
		}
	},
	markAll: function() {
		$$('#bligoo-content-filter-list input').each(function(e) { e.checked = true; }); 
	},
	markNone: function() {
		$$('#bligoo-content-filter-list input').each(function(e) { e.checked = false; }); 
	}
}


document.observe("bligoobar:initialized", function(event) {
	var PublishAppletClass = Class.create();
	PublishAppletClass.prototype = {
		initialize: function(link, div, bar) {
			this.div = div;
			this.link = link;
			this.bar = bar;
			this.divContentBotL = this.div.select('.bligoo-bar-applet-links-dl').first();
			this.divContentBotR = this.div.select('.bligoo-bar-applet-links-dr').first();
			this.divContent = this.div.select('#bligoo-bar-new-content-links-content').first();
			if (div != null) {
				var links = div.select('a');
				if (links.length > 0) {
					if (links.length > 1) {
						this.link.observe('click', this.toggle.bindAsEventListener(this));
						document.observe('click', this.close.bindAsEventListener(this));
					} else {
						this.link.observe('click', this.goTo.bindAsEventListener(this, links[0]));
					}
				}else{
					this.link.observe('click', this.toggle.bindAsEventListener(this));
					document.observe('click', this.close.bindAsEventListener(this));				
				}
			}
			this.alreadyOpened = false;
		},
		close: function(event) {
			if (event.target.id != this.link.id && this.link.id != $(event.target).up().id) {				
				this.div.hide();
				this.link.removeClassName('bligoo-bar-content-applet-pushed');
			}
		},
		toggle: function(event) {
			if (this.link.hasClassName('bligoo-bar-content-applet-pushed')) {
				this.link.removeClassName('bligoo-bar-content-applet-pushed');
			} else {
				this.bar.closePanel();
				this.link.addClassName('bligoo-bar-content-applet-pushed');
				var linkWidth = this.link.getWidth()-2;
				this.divContentBotL.setStyle('width:'+linkWidth+'px;float:left;');
				var newBgPosition = '-'+(416-(150-linkWidth))+'px -356px';
				this.divContentBotR.setStyle('width:'+(150-linkWidth)+'px;float:left;background-position: '+newBgPosition+';');
			}
			this.div.toggle();
			if ( this.div.visible() && !this.alreadyOpened && this.div.getAttribute('bligoo-is-ajax') == 'true'){
				this.getMoreLinks();
			}
		},
		goTo: function(event, src) {
			if (src != undefined) {
				document.location.href = src;
				return;
			}
		},
		getMoreLinks: function(){
			this.loadingDiv = Builder.node('div', {'id': 'bligoo-bar-jumpto-links-waiting'});
			this.loadingDiv.setStyle('height: 20px; width: 100%;');
			this.divContent.insert({top: this.loadingDiv}); 
			$('bligoo-bar-jumpto-links-waiting').startWaiting('blackWaiting');
			new Ajax.Request(
				'/bligoo/ajaxproxy', {
				method: 'getJumptoPublishLinks'
				, onSuccess: function(transport){
								this.alreadyOpened = true;
								$('bligoo-bar-jumpto-links-waiting').stopWaiting();
								this.loadingDiv.remove();
								this.divContent.update(transport.responseText);
							}.bind(this)
				, onFailure: function(transport) {
					//NADA
							}.bind(this)
			});
		}
	}
	

	if ($('bligoo-bar-applet-content-publish')) {
		new PublishAppletClass($('bligoo-bar-applet-content-publish'), $('bligoo-bar-new-content-links'), event.memo);
	}
});

function fileUploadedToChannel(url) {
	if ($('channel-image-selector') != null) {
		var radio = Builder.node('input', {'type': 'radio', 'name': 'edit[image]', 'class': 'form-radio', 'value': url});
		var img =   Builder.node('img', {'border': '0', 'width': '75', 'title': url, 'src': url});
		var label = Builder.node('label', {'class': 'option'}, img);
		var div =   Builder.node('div', {'class': 'form-radio-option'});
		div.appendChild(radio);
		div.appendChild(label);
		$('channel-image-selector').insert(div);
		if ($('channel-upload-frame') != null) {
			$('channel-upload-frame').hide();		
		}
	}
}

var CharacterCounterClass = Class.create({
	initialize: function(textarea, counter) {
		this.textarea = textarea;
		this.counter = counter;
		textarea.observe('keyup', this.keyUp.bindAsEventListener(this));
		this.keyUp();
	},
	keyUp: function(event) {
		if (this.textarea.value != '') {
			this.counter.update('' + this.textarea.value.stripTags().length);
		} else {
			this.counter.update('');
		}
	}
});

document.observe("bligoobar:leaf-replaced", function(event) {
	if (event.memo == 'admin/general/contentshow') {
		var AvatarSizeShowClass = Class.create();
		AvatarSizeShowClass.prototype = {
			initialize: function(element) {
				if (element != null) {
					this.element = element;
					this.element.observe('change', this.show.bindAsEventListener(this));
					this.show();
				}
			},
			show: function() {
				$$('.content-avatar-demo').each(function(e) {e.hide();});
				$$('#content-avatar-demo-' + this.element.value).each(function(e) {e.show();});
			}
		}
		new AvatarSizeShowClass($('content-avatar-size'));
	} else 	if (event.memo == 'sysadmin/content/ranking/edit' 
				|| event.memo == 'sysadmin/content/highlight/edit'
				|| event.memo == 'sysadmin/content/channel/edit') {
			if ($('character-counter') != null && $('content-body') != null) {
				new CharacterCounterClass($('content-body'), $('character-counter'));
			}
				
	}
});


document.observe("page:loaded", function() {
	addMP3Players();
	
	if ($('highlight-body') != null && $('highlight-counter') != null) {
		new CharacterCounterClass($('highlight-body'), $('highlight-counter'));
	}
	
	$$('#highlighted-primary .highlight-body, #highlighted-primary h3').each(function(element) {
		element.setOpacity(0.8);
	});
});


var CaptchaClass = Class.create();
CaptchaClass.prototype = {
	initialize: function(element) {
		this.element = element;
		this.image = this.element.select('.captcha-image')[0];
		this.link = this.element.select('a.reset-captcha')[0];
		this.link.observe('click', this.click.bindAsEventListener(this));
	},
	click: function(event) {
		this.image.src='/bligoo/imgbligoo/captcha?' + new Date().getTime();
	}
}

document.observe("bligoobar:leaf-replaced", function(event) {
	$$('#bligoo-bar-item-content .captcha-item').each(function(item) {
		new CaptchaClass(item);
	});
});


document.observe("bligoowindow:content-replaced", function(event) {
	$$('#' + event.memo.window.id + ' .captcha-item').each(function(item) {
		new CaptchaClass(item);
	});
});

document.observe("page:loaded", function() {
	$$('.captcha-item').each(function(item) {
		new CaptchaClass(item);
	});
});
function initTagGameColums(){
	Droppables.add("interested-box", {accept:'draggable-tag', hoverclass:'dragging-image', onDrop: dropTagInterested});
	Droppables.add("not-interested-box", {accept:'draggable-tag', hoverclass:'dragging-image', onDrop: dropTagNotInterested});
}


function dropTagInterested(e){
	dropTag('interested-box', e.innerHTML, e.id);
}
function dropTagNotInterested(e){
	dropTag('not-interested-box', e.innerHTML, e.id);
}

function dropTag(box, word, id){
	$$('#' + box + ' .no-interest-tag').each(function(e){ e.hide();});
	$(id).remove();
	addTagToBox(box, word, id);
}

var tooltipDelete;

function addTagToBox(box, word, id){
	var first = $(box).firstDescendant();
	var span = '<div class="interest-tag" id="' + id + '">'
				+ '<div class="interest-word" style="float:left;width: 90%;">' + word + '</div>'
				+ '<div style="float:left;align: right; width: 10%; height: 100%;"><img alt="' + tooltipDelete + '" title="' + tooltipDelete + '" style="display: none;" src="/bligoo/imgbligoo/recommendation/games-delete.jpg"/></div>' 
				+ '</div> ';
	if(first){
		first.insert({before: span});
	} else {
		$(box).insert(span);
	}
	new DeleteableTag($(id));
	updateClasses('#' + box + ' .interest-tag');
	updateNextButton();
}

var DeleteableTag  = Class.create();
DeleteableTag.prototype = {
	initialize: function(element){
		this.element = element;
		element.observe('mouseover', this.toggleCross.bindAsEventListener(this));
		element.observe('mouseout', this.toggleCross.bindAsEventListener(this));
		$$('#' + this.element.id + ' img').each(
				function(e){ 
					e.observe('click', function(e){ 
							$(e.target).ancestors()[1].remove(); 
							updateDescription('#interested-box');
							updateDescription('#not-interested-box');
							updateClasses('#not-interested-box .interest-tag');
							updateClasses('#interested-box .interest-tag');
							updateNextButton();
						});
				});		
	},
	toggleCross: function(event){
		$$('#' + this.element.id + ' img').each(function(e){ e.toggle();});;
		this.element.toggleClassName('interest-tag-active');
	}
	
};

function initDraggableTags(){
	$$('#test-container-content .draggable-tag').each(function(e){
		new Draggable(e.id, {revert: true});
		e.observe('mouseover', changeMouseOver);
		e.observe('mouseout', changeMouseOver);
	});
}

function changeMouseOver(e){
	var span = e.target;
	span.toggleClassName('interest-bligoo-tags-active');
	span.toggleClassName('interest-tag');
}

var tagCounter = 100;

function addTagFromInput(div, input){
	var val = input.value;
	if(val){
		val = val.strip().stripTags().stripScripts().toLowerCase();
		var found = false;
		$$('#' + div + ' .intere