/* MS Dynamics Renewal Rhythm - Prototype JavaScript framework, version 1.6.0.2 */

var Prototype = {
  Version: '1.6.0.2',

  Browser: {
    IE:     !!(window.attachEvent && !window.opera),
    Opera:  !!window.opera,
    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,
    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 = Object.extend((function(m) {
          return function() { return ancestor[m].apply(this, arguments) };
        })(property).wrap(method), {
          valueOf:  function() { return method },
          toString: function() { return method.toString() }
        });
      }
      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].split(",").invoke("strip");
    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);
  },

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

Function.prototype.defer = Function.prototype.delay.curry(0.01);

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

with (String.prototype.escapeHTML) div.appendChild(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;
    iterator = iterator.bind(context);
    try {
      this._each(function(value) {
        iterator(value, index++);
      });
    } catch (e) {
      if (e != $break) throw e;
    }
    return this;
  },

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

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

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

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

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

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

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

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

    this.each(function(value, index) {
      if (filter.match(value))
        results.push(iterator(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) {
    iterator = iterator.bind(context);
    this.each(function(value, index) {
      memo = iterator(memo, value, index);
    });
    return memo;
  },

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

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

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

  partition: function(iterator, context) {
    iterator = iterator ? iterator.bind(context) : Prototype.K;
    var trues = [], falses = [];
    this.each(function(value, index) {
      (iterator(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) {
    iterator = iterator.bind(context);
    var results = [];
    this.each(function(value, index) {
      if (!iterator(value, index))
        results.push(value);
    });
    return results;
  },

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

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

  zip: function() {
    var iterator = Prototype.K, args = $A(arguments);
    if (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 [];
    if (!(Object.isFunction(iterable) && iterable == '[object NodeList]') &&
        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) {
    $R(0, this, true).each(iterator);
    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) {
      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.map(function(pair) {
        var key = encodeURIComponent(pair.key), values = pair.value;

        if (values && typeof values == 'object') {
          if (Object.isArray(values))
            return values.map(toQueryPair.curry(key)).join('&');
        }
        return toQueryPair(key, values);
      }).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 || { });
}).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).style.display = 'none';
    return element;
  },

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

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

  update: function(element, 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(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);
    var originalAncestor = ancestor;

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

    if (element.sourceIndex && !Prototype.Browser.Opera) {
      var e = element.sourceIndex, a = ancestor.sourceIndex,
       nextAncestor = ancestor.nextSibling;
      if (!nextAncestor) {
        do { ancestor = ancestor.parentNode; }
        while (!(nextAncestor = ancestor.nextSibling) && ancestor.parentNode);
      }
      if (nextAncestor && nextAncestor.sourceIndex)
       return (e > a && e < nextAncestor.sourceIndex);
    }

    while (element = element.parentNode)
      if (element == originalAncestor) 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) {
      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 (window.opera) {
        element.style.top = 0;
        element.style.left = 0;
      }
    }
    return element;
  },

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

  makeClipping: function(element) {
    element = $(element);
    if (element._overflow) return element;
    element._overflow = Element.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 == '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;
    // 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;
    // 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 == '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);
      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);
        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.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').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 == '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, 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 = { };
    var B = Prototype.Browser;
    $w('width height').each(function(d) {
      var D = d.capitalize();
      dimensions[d] = (B.WebKit && !document.evaluate) ? self['inner' + D] :
        (B.Opera) ? document.body['client' + 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();
    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(this.expression))
      return false;

    return true;
  },

  compileMatcher: function() {
    if (this.shouldUseXPath())
      return this.compileXPathMatcher();

    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;
    if (this.xpath) return document._getElementsByXPath(this.xpath, root);
    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 or translate(text(), ' \t\r\n', '') = '')]",
      'checked':     "[@checked]",
      'disabled':    "[@disabled]",
      'enabled':     "[not(@disabled)]",
      '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]+)\]/,
    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 && !node.innerHTML.match(/^\s*$/))) 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) 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.startsWith(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 != '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.blur();
    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, index) {
    if (Object.isUndefined(index))
      return this[element.type == 'select-one' ?
        'selectOne' : 'selectMany'](element);
    else {
      var opt, value, single = !Object.isArray(index);
      for (var i = 0, length = element.length; i < length; i++) {
        opt = element.options[i];
        value = this.optionValue(opt);
        if (single) {
          if (value == index) {
            opt.selected = true;
            return;
          }
        }
        else opt.selected = index.include(value);
      }
    }
  },

  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) {
      var node = Event.extend(event).target;
      return Element.extend(node.nodeType == Node.TEXT_NODE ? node.parentNode : 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) {
      return {
        x: event.pageX || (event.clientX +
          (document.documentElement.scrollLeft || document.body.scrollLeft)),
        y: event.pageY || (event.clientY +
          (document.documentElement.scrollTop || document.body.scrollTop))
      };
    },

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

  if (window.attachEvent) {
    window.attachEvent("onunload", destroyCache);
  }

  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();
if (!window.Silverlight)
{
    window.Silverlight = { };
}

// Silverlight control instance counter for memory mgt
Silverlight._silverlightCount = 0;
Silverlight.fwlinkRoot='http://go2.microsoft.com/fwlink/?LinkID=';  
Silverlight.onGetSilverlight = null;
Silverlight.onSilverlightInstalled = function () {window.location.reload(false);};

//////////////////////////////////////////////////////////////////
// isInstalled, checks to see if the correct version is installed
//////////////////////////////////////////////////////////////////
Silverlight.isInstalled = function(version)
{
    var isVersionSupported=false;
    var container = null;
    
    try 
    {
        var control = null;
        
        try
        {
            control = new ActiveXObject('AgControl.AgControl');
            if ( version == null )
            {
                isVersionSupported = true;
            }
            else if ( control.IsVersionSupported(version) )
            {
                isVersionSupported = true;
            }
            control = null;
        }
        catch (e)
        {
            var plugin = navigator.plugins["Silverlight Plug-In"] ;
            if ( plugin )
            {
                if ( version === null )
                {
                    isVersionSupported = true;
                }
                else
                {
                    var actualVer = plugin.description;
                    if ( actualVer === "1.0.30226.2")
                        actualVer = "2.0.30226.2";
                    var actualVerArray =actualVer.split(".");
                    while ( actualVerArray.length > 3)
                    {
                        actualVerArray.pop();
                    }
                    while ( actualVerArray.length < 4)
                    {
                        actualVerArray.push(0);
                    }
                    var reqVerArray = version.split(".");
                    while ( reqVerArray.length > 4)
                    {
                        reqVerArray.pop();
                    }
                    
                    var requiredVersionPart ;
                    var actualVersionPart
                    var index = 0;
                    
                    
                    do
                    {
                        requiredVersionPart = parseInt(reqVerArray[index]);
                        actualVersionPart = parseInt(actualVerArray[index]);
                        index++;
                    }
                    while (index < reqVerArray.length && requiredVersionPart === actualVersionPart);
                    
                    if ( requiredVersionPart <= actualVersionPart && !isNaN(requiredVersionPart) )
                    {
                        isVersionSupported = true;
                    }
                }
            }
        }
    }
    catch (e) 
    {
        isVersionSupported = false;
    }
    if (container) 
    {
        document.body.removeChild(container);
    }
    
    return isVersionSupported;
}
Silverlight.WaitForInstallCompletion = function()
{
    if ( ! Silverlight.isBrowserRestartRequired && Silverlight.onSilverlightInstalled )
    {
        try
        {
            navigator.plugins.refresh();
        }
        catch(e)
        {
        }
        if ( Silverlight.isInstalled(null) )
        {
            Silverlight.onSilverlightInstalled();
        }
        else
        {
              setTimeout(Silverlight.WaitForInstallCompletion, 3000);
        }    
    }
}
Silverlight.__startup = function()
{
    Silverlight.isBrowserRestartRequired = Silverlight.isInstalled(null);//(!window.ActiveXObject || Silverlight.isInstalled(null));
    if ( !Silverlight.isBrowserRestartRequired)
    {
        Silverlight.WaitForInstallCompletion();
    }
    if (window.removeEventListener) { 
       window.removeEventListener('load', Silverlight.__startup , false);
    }
    else { 
        window.detachEvent('onload', Silverlight.__startup );
    }
}

if (window.addEventListener) 
{
    window.addEventListener('load', Silverlight.__startup , false);
}
else 
{
    window.attachEvent('onload', Silverlight.__startup );
}

///////////////////////////////////////////////////////////////////////////////
// createObject();  Params:
// parentElement of type Element, the parent element of the Silverlight Control
// source of type String
// id of type string
// properties of type String, object literal notation { name:value, name:value, name:value},
//     current properties are: width, height, background, framerate, isWindowless, enableHtmlAccess, inplaceInstallPrompt:  all are of type string
// events of type String, object literal notation { name:value, name:value, name:value},
//     current events are onLoad onError, both are type string
// initParams of type Object or object literal notation { name:value, name:value, name:value}
// userContext of type Object
/////////////////////////////////////////////////////////////////////////////////

Silverlight.createObject = function(source, parentElement, id, properties, events, initParams, userContext)
{
    var slPluginHelper = new Object();
    var slProperties = properties;
    var slEvents = events;
    
    slPluginHelper.version = slProperties.version;
    slProperties.source = source;    
    slPluginHelper.alt = slProperties.alt;
    
    //rename properties to their tag property names
    if ( initParams )
        slProperties.initParams = initParams;
    if ( slProperties.isWindowless && !slProperties.windowless)
        slProperties.windowless = slProperties.isWindowless;
    if ( slProperties.framerate && !slProperties.maxFramerate)
        slProperties.maxFramerate = slProperties.framerate;
    if ( id && !slProperties.id)
        slProperties.id = id;
    
    // remove elements which are not to be added to the instantiation tag
    delete slProperties.ignoreBrowserVer;
    delete slProperties.inplaceInstallPrompt;
    delete slProperties.version;
    delete slProperties.isWindowless;
    delete slProperties.framerate;
    delete slProperties.data;
    delete slProperties.src;
    delete slProperties.alt;


    // detect that the correct version of Silverlight is installed, else display install

    if (Silverlight.isInstalled(slPluginHelper.version))
    {
        //move unknown events to the slProperties array
        for (var name in slEvents)
        {
            if ( slEvents[name])
            {
                if ( name == "onLoad" && typeof slEvents[name] == "function" && slEvents[name].length != 1 )
                {
                    var onLoadHandler = slEvents[name];
                    slEvents[name]=function (sender){ return onLoadHandler(document.getElementById(id), userContext, sender)};
                }
                var handlerName = Silverlight.__getHandlerName(slEvents[name]);
                if ( handlerName != null )
                {
                    slProperties[name] = handlerName;
                    slEvents[name] = null;
                }
                else
                {
                    throw "typeof events."+name+" must be 'function' or 'string'";
                }
            }
        }
        slPluginHTML = Silverlight.buildHTML(slProperties);
    }
    //The control could not be instantiated. Show the installation prompt
    else 
    {
        slPluginHTML = Silverlight.buildPromptHTML(slPluginHelper);
    }

    // insert or return the HTML
    if(parentElement)
    {
        parentElement.innerHTML = slPluginHTML;
    }
    else
    {
        return slPluginHTML;
    }

}

///////////////////////////////////////////////////////////////////////////////
//
//  create HTML that instantiates the control
//
///////////////////////////////////////////////////////////////////////////////
Silverlight.buildHTML = function( slProperties)
{
    var htmlBuilder = [];

    htmlBuilder.push('<object type=\"application/x-silverlight\" data="data:application/x-silverlight,"');
    if ( slProperties.id != null )
    {
        htmlBuilder.push(' id="' + slProperties.id + '"');
    }
    if ( slProperties.width != null )
    {
        htmlBuilder.push(' width="' + slProperties.width+ '"');
    }
    if ( slProperties.height != null )
    {
        htmlBuilder.push(' height="' + slProperties.height + '"');
    }
    htmlBuilder.push(' >');
    
    delete slProperties.id;
    delete slProperties.width;
    delete slProperties.height;
    
    for (var name in slProperties)
    {
        if (slProperties[name])
        {
            htmlBuilder.push('<param name="'+Silverlight.HtmlAttributeEncode(name)+'" value="'+Silverlight.HtmlAttributeEncode(slProperties[name])+'" />');
        }
    }
    htmlBuilder.push('<\/object>');
    return htmlBuilder.join('');
}




// createObjectEx, takes a single parameter of all createObject parameters enclosed in {}
Silverlight.createObjectEx = function(params)
{
    var parameters = params;
    var html = Silverlight.createObject(parameters.source, parameters.parentElement, parameters.id, parameters.properties, parameters.events, parameters.initParams, parameters.context);
    if (parameters.parentElement == null)
    {
        return html;
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////
// Builds the HTML to prompt the user to download and install Silverlight
///////////////////////////////////////////////////////////////////////////////////////////////
Silverlight.buildPromptHTML = function(slPluginHelper)
{
    var slPluginHTML = "";
    var urlRoot = Silverlight.fwlinkRoot;
    var shortVer = slPluginHelper.version ;
    if ( slPluginHelper.alt )
    {
        slPluginHTML = slPluginHelper.alt;
    }
    else
    {
        if (! shortVer )
        {
            shortVer="";
        }
        slPluginHTML = "<a href='javascript:Silverlight.getSilverlight(\"{1}\");' style='text-decoration: none;'><img src='{2}' alt='Get Microsoft Silverlight' style='border-style: none'/></a>";
        slPluginHTML = slPluginHTML.replace('{1}', shortVer );
        slPluginHTML = slPluginHTML.replace('{2}', urlRoot + '108181');
    }
    
    return slPluginHTML;
}


Silverlight.getSilverlight = function(version)
{
    if (Silverlight.onGetSilverlight )
    {
        Silverlight.onGetSilverlight();
    }
    
    var shortVer = "";
    var reqVerArray = String(version).split(".");
    if (reqVerArray.length > 1)
    {
        var majorNum = parseInt(reqVerArray[0] );
        if ( isNaN(majorNum) || majorNum < 2 )
        {
            shortVer = "1.0";
        }
        else
        {
            shortVer = reqVerArray[0]+'.'+reqVerArray[1];
        }
    }
    
    var verArg = "";
    
    if (shortVer.match(/^\d+\056\d+$/) )
    {
        verArg = "&v="+shortVer;
    }
    
    Silverlight.followFWLink("114576" + verArg);
}


///////////////////////////////////////////////////////////////////////////////////////////////
/// Navigates to a url based on fwlinkid
///////////////////////////////////////////////////////////////////////////////////////////////
Silverlight.followFWLink = function(linkid)
{
    top.location=Silverlight.fwlinkRoot+String(linkid);
}












///////////////////////////////////////////////////////////////////////////////////////////////
/// Encodes special characters in input strings as charcodes
///////////////////////////////////////////////////////////////////////////////////////////////
Silverlight.HtmlAttributeEncode = function( strInput )
{
      var c;
      var retVal = '';

    if(strInput == null)
      {
          return null;
    }
      
      for(var cnt = 0; cnt < strInput.length; cnt++)
      {
            c = strInput.charCodeAt(cnt);

            if (( ( c > 96 ) && ( c < 123 ) ) ||
                  ( ( c > 64 ) && ( c < 91 ) ) ||
                  ( ( c > 43 ) && ( c < 58 ) && (c!=47)) ||
                  ( c == 95 ))
            {
                  retVal = retVal + String.fromCharCode(c);
            }
            else
            {
                  retVal = retVal + '&#' + c + ';';
            }
      }
      
      return retVal;
}
///////////////////////////////////////////////////////////////////////////////
//
//  Default error handling function to be used when a custom error handler is
//  not present
//
///////////////////////////////////////////////////////////////////////////////

Silverlight.default_error_handler = function (sender, args)
{
    var iErrorCode;
    var errorType = args.ErrorType;

    iErrorCode = args.ErrorCode;

    var errMsg = "\nSilverlight error message     \n" ;

    errMsg += "ErrorCode: "+ iErrorCode + "\n";


    errMsg += "ErrorType: " + errorType + "       \n";
    errMsg += "Message: " + args.ErrorMessage + "     \n";

    if (errorType == "ParserError")
    {
        errMsg += "XamlFile: " + args.xamlFile + "     \n";
        errMsg += "Line: " + args.lineNumber + "     \n";
        errMsg += "Position: " + args.charPosition + "     \n";
    }
    else if (errorType == "RuntimeError")
    {
        if (args.lineNumber != 0)
        {
            errMsg += "Line: " + args.lineNumber + "     \n";
            errMsg += "Position: " +  args.charPosition + "     \n";
        }
        errMsg += "MethodName: " + args.methodName + "     \n";
    }
    alert (errMsg);
}

///////////////////////////////////////////////////////////////////////////////////////////////
/// Releases event handler resources when the page is unloaded
///////////////////////////////////////////////////////////////////////////////////////////////
Silverlight.__cleanup = function ()
{
    for (var i = Silverlight._silverlightCount - 1; i >= 0; i--) {
        window['__slEvent' + i] = null;
    }
    Silverlight._silverlightCount = 0;
    if (window.removeEventListener) { 
       window.removeEventListener('unload', Silverlight.__cleanup , false);
    }
    else { 
        window.detachEvent('onunload', Silverlight.__cleanup );
    }
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// Releases event handler resources when the page is unloaded
///////////////////////////////////////////////////////////////////////////////////////////////
Silverlight.__getHandlerName = function (handler)
{
    var handlerName = "";
    if ( typeof handler == "string")
    {
        handlerName = handler;
    }
    else if ( typeof handler == "function" )
    {
        if (Silverlight._silverlightCount == 0)
        {
            if (window.addEventListener) 
            {
                window.addEventListener('onunload', Silverlight.__cleanup , false);
            }
            else 
            {
                window.attachEvent('onunload', Silverlight.__cleanup );
            }
        }
        var count = Silverlight._silverlightCount++;
        handlerName = "__slEvent"+count;
        
        window[handlerName]=handler;
    }
    else
    {
        handlerName = null;
    }
    return handlerName;
}
//PageLoad
var ex = null;
function pageLoad(sender, eventArgs) {    
    //Search functions
    /*if (!eventArgs.get_isPartialLoad()) {
        $addHandler($get("searchBtn"), "click", Function.createDelegate(this, search));
        $addHandler($get("searchBox"), "keypress", Function.createDelegate(this, searchButtonPress));
    }*/
    $addHandler($get("searchBtn"), "click", Function.createDelegate(this, search));
    $addHandler($get("searchBox"), "keypress", Function.createDelegate(this, searchButtonPress));

    //Silverlight Sniffer message
    setTimeout("updateSilverlightMessage()", 0);

    //To restore state from history points
    Sys.Application.add_navigate(onNavigate);
}

function changeHeroClass(newClassName) {
    $("hero_accordion").className = newClassName;    
}

//Gets set once the RightNav loads
var isPRB = true;

var whoClicked = "";
//document.onclick=hideFlyout;
document.onclick = hideOpened;

function hideOpened() {
    hideFlyout();
    hideDropTabs(); //CC only
    hideSharePopUp();
}

//RightNav over states
function changeClass(thisElement, newClassName) {
    var actualClassName = thisElement.className;
    if (actualClassName != newClassName) {
        if (newClassName == "tab_on_last" && actualClassName == "tab_on") {
            // does nothing
        }
        else if (actualClassName == "tab_active") {
            //does nothing
        }
        else {
            thisElement.className = newClassName;

            //Fixing bug for IE (extra spacing on headers)
            if (isIE) {
                if (newClassName == "tab_active") {
                    var baseThis = thisElement.firstChild.lastChild;
                    baseThis.style.height = "3px";
                }
            }            
        }
    }
}

/*:::::::::::::: Tabs CONCERNS/QUESTIONS - Resources page ::::::::::::::*/
function changeTab(thisElement) {    
    var tabs = thisElement.parentNode.childNodes;    

    for (i = 0; i < tabs.length; i++) {
        if (tabs[i] == thisElement) {
            tabs[i].className = "on";
        }
        else {
            tabs[i].className = "off";
        }        
    }
}

function changeTabOver(thisElement) {
    if (thisElement.className == "off") {
        thisElement.className = "off_over";
    }
}

function changeTabOut(thisElement) {
    if (thisElement.className == "off_over") {
        thisElement.className = "off";
    }
}

/*:::::::::::::: ToolTips - Resources page ::::::::::::::*/
var currentTop;
var newTop;

var xCoord = 0;
var yCoord = 0;

var isIE;

document.onmouseover = setXY;

/*function setXY(e) {    
    isIE = document.all;
    
    if (!e) e = window.event;
    if (e) {        
        xCoord = isIE ? (e.clientX + document.body.scrollLeft) : e.pageX;
        yCoord = isIE ? (e.clientY + document.body.scrollTop) : e.pageY;        
    }
}*/


/*var browser = navigator.appName;
var b_version = navigator.appVersion;
var version = parseFloat(b_version);*/

function getIEVersionNumber() {
    var ua = navigator.userAgent;
    var MSIEOffset = ua.indexOf("MSIE ");

    if (MSIEOffset == -1) {
        isIE = false;
        return 0;
    } 
    else {
        isIE = true;
        return parseFloat(ua.substring(MSIEOffset + 5, ua.indexOf(";", MSIEOffset)));
    }
}

var isIE7Min = getIEVersionNumber() >= 7;

function setXY(e) {
    if (!e) e = window.event;
    if (e) {
        xCoord = isIE ? (e.clientX + document.body.scrollLeft) : e.pageX;
        yCoord = isIE ? (e.clientY + document.body.scrollTop) : e.pageY;
    }
}

var tempTop;
function showToolTip(thisElement) {

    var tooltipWraper;

    var linkOver = false;
    var tooltipOver = false;    

    //If rolling over link
    if (thisElement.nodeName == "A") {
        tooltipWraper = thisElement.previousSibling;
        if (tooltipWraper.nodeName != "DIV") {
            tooltipWraper = thisElement.previous();
        }
        linkOver = true;
    }
    //If rolling over tooltip
    else {
        tooltipWraper = thisElement;
        tooltipOver = true;
    }      
        
    if (tooltipWraper.className == "tooltip_wrap hide") {        

        //Position Top
        currentMarginTop = 0;
        
        if (isIE) {
            newTop = currentMarginTop - $(tooltipWraper.id).getHeight() + 3;
        }
        else {
            newTop = currentMarginTop - $(tooltipWraper.id).getHeight();
        }

        var gapCurrentTop_yCoord = yCoord - tooltipWraper.offsetTop;

        //If links takes two lines --> it's height = 24px (12px per line).
        if ($(thisElement).getHeight() > 20) {
            newTop += 13;            
        }
        else {
            //If link takes only one line, but it's the first link on the line
            if ($(thisElement).positionedOffset()["left"] < 100 || $(thisElement).positionedOffset()["left"] > 240) {                
                if (isIE) {                                      
                    
                    if (isIE7Min) {
                        newTop += 5;
                    }
                    else {                        
                        newTop += 10;
                    }                    

                }
                else {
                    newTop += 7;                    
                }
            }
            else {
                if (isIE) {
                    //If IE6
                    if (!isIE7Min) {
                        //newTop -= 13;
                    }

                }
                else {
                    newTop -= 5;
                }
            }
        }        
               
        if (tooltipOver) {
            tooltipWraper.style.marginTop = tempTop + "px";            
        }
        else {
            tooltipWraper.style.marginTop = newTop + "px";
            tempTop = newTop;
        }     
        
        if (linkOver) {
            //Position Left

            var leftSpace = (document.body.clientWidth - 190 - 213) / 2; //602: width hero area, 213:width right nav
            
            if (isIE) {
                if (isIE7Min) {                    
                    tooltipWraper.style.left = xCoord - leftSpace - 60 + "px";
                }
                else {
                    tooltipWraper.style.left = xCoord - 60 - 370 + "px";                    
                }
            }
            else {                
                tooltipWraper.style.left = xCoord - leftSpace - 60 + "px";
            }            
        }

        tooltipWraper.className = "tooltip_wrap";
    }    
}

function hideToolTip(thisElement) {

    var tooltipWraper;    

    //If rolling over link
    if (thisElement.nodeName == "A") {
        tooltipWraper = thisElement.previousSibling;
        if (tooltipWraper.nodeName != "DIV") {
            tooltipWraper = thisElement.previous();
        }
    }
    //If rolling over tooltip
    else {
        tooltipWraper = thisElement;
    }

    if (tooltipWraper.className == "tooltip_wrap") {
        tooltipWraper.className = "tooltip_wrap hide";
        //tooltipWraper.style.top = currentTop + "px";
        //tooltipWraper.style.top = "0px";
    }
}

/*:::::::::::::: ToolTips - Thumbnails Resources page ::::::::::::::*/
function showThumbnailTooltip(thisElement) {
    thisElement.parentNode.parentNode.parentNode.parentNode.className = 'selected_L_on'    
}

function hideThumbnailTooltip(thisElement) {
    thisElement.parentNode.parentNode.parentNode.parentNode.className = 'selected_L'
}

/*:::::::::::::: Rotator - Thumbnails Resources page ::::::::::::::*/
var xPos_ini = 0;
var xPos_limit;
var setInitial = false;
var totalThumbnails;
var totalWidth;
var xPos = xPos_ini; //to start

var timerThumbnails;
var elementToMove;
var arrowLeft;
var arrowRight;

function thumbnailsLeft(thisElement) {

    if (thisElement.className == "thumb_arrow_l") {

        //IE
        if (thisElement.parentNode.nextSibling.nodeName == "DIV") {
            elementToMove = thisElement.parentNode.nextSibling.firstChild;            
            arrowLeft = thisElement;
            arrowRight = thisElement.parentNode.parentNode.lastChild.firstChild;
            if (setInitial) {
                xPos = elementToMove.offsetLeft;
                moveThumbnailsLeft();
            }
            else {
                setInitialValues(thisElement, "left");
            }
        }
        //FF
        else {
            elementToMove = thisElement.parentNode.next().firstDescendant();            
            arrowLeft = thisElement;
            //arrowRight = thisElement.parentNode.parentNode.lastChild.firstDescendant();
            if (setInitial) {
                xPos = elementToMove.offsetLeft;
                moveThumbnailsLeft();
            }
            else {
                setInitialValues(thisElement, "left");
            }
        }        
    }    
}

function thumbnailsRight(thisElement) {

    if (thisElement.className == "thumb_arrow_r") {
        //IE
        if (thisElement.parentNode.previousSibling.nodeName == "DIV") {
            elementToMove = thisElement.parentNode.previousSibling.firstChild;            
            arrowRight = thisElement;
            arrowLeft = thisElement.parentNode.parentNode.firstChild.firstChild;
            if (setInitial) {
                xPos = elementToMove.offsetLeft;
                moveThumbnailsRight();
            }
            else {
                setInitialValues(thisElement, "right");
            }
        }
        //FF
        else {
            elementToMove = thisElement.parentNode.previous().firstDescendant();            
            arrowRight = thisElement;
            arrowLeft = thisElement.parentNode.parentNode.firstDescendant().firstDescendant();            
            if (setInitial) {
                xPos = elementToMove.offsetLeft;
                moveThumbnailsRight();
            }
            else {
                setInitialValues(thisElement, "right");
            }
        }        
    }    
}

function moveThumbnailsLeft() {
    elementToMove.style.width = totalWidth + "px";
    //Move Left
    if (xPos < xPos_ini) {
        xPos += 2;
        elementToMove.style.left = xPos + "px";
        arrowRight.className = "thumb_arrow_r";
    }
    else {
        arrowLeft.className = "thumb_arrow_l_off";
    }

    timerThumbnails = setTimeout("moveThumbnailsLeft()", 0.1);
}

function moveThumbnailsRight() {
    elementToMove.style.width = totalWidth + "px";
    //Move Right
    if (xPos > xPos_limit) {
        xPos -= 2;
        elementToMove.style.left = xPos + "px";
        arrowLeft.className = "thumb_arrow_l";
    }
    else {
        arrowRight.className = "thumb_arrow_r_off";
    }

    timerThumbnails = setTimeout("moveThumbnailsRight()", 0.1);    
}

function setInitialValues(thisElement, side)
{
    if(side =="left")
    {
        //IE
        if (thisElement.parentNode.nextSibling.nodeName == "DIV") {
            totalThumbnails = thisElement.parentNode.nextSibling.firstChild.childNodes.length;
        }
        //FF
        else {            
            totalThumbnails = 0;
            //Counting real childNodes
            for (j = 0; j < thisElement.parentNode.next().firstDescendant().childNodes.length; j++) {
                if (thisElement.parentNode.next().firstDescendant().childNodes[j].nodeName == "A") {
                    totalThumbnails++;
                }
            }            
        }
        
        totalWidth = (totalThumbnails * 75);  //+ 21; //70 = 50px width of the image plus a 20px margin (see css for thumbnail).        
    }
    else
    {
        //IE
        if (thisElement.parentNode.previousSibling.nodeName == "DIV") {
            totalThumbnails = thisElement.parentNode.previousSibling.firstChild.childNodes.length;
        }
        //FF
        else {            
            totalThumbnails = 0;
            //Counting real childNodes            
            for (j = 0; j < thisElement.parentNode.previous().firstDescendant().childNodes.length; j++) {                
                if (thisElement.parentNode.previous().firstDescendant().childNodes[j].nodeName == "A") {
                    totalThumbnails++;
                }
            }            
        }
        
        totalWidth = (totalThumbnails * 75);  //+ 21; //70 = 50px width of the image plus a 20px margin (see css for thumbnail).                
    }
    xPos_limit = 0 - totalWidth + 220; //200px is the width of the limitThumbnails (see css) + 20px margin right.

    setInitial = true;

    if (side == "left") {
        moveThumbnailsLeft();
    }
    else {
        moveThumbnailsRight();
    }
}

function stopThumbnails() {
    clearTimeout(timerThumbnails);
}

/*:::::::::::::: Browse Articles Pagination ::::::::::::::*/
function previousPageArticles(thisElement) {
    $("aNextArticles").className = "nextPage";

    var totalBrowseArticlesPages;
    
    //IE
    if (thisElement.parentNode.previousSibling.nodeName == "DIV") {
        totalBrowseArticlesPages = thisElement.parentNode.previousSibling.childNodes.length;

        for (i = 0; i < totalBrowseArticlesPages; i++) {
            if (thisElement.parentNode.previousSibling.childNodes[i].className == "show") {
                //If it's not the first one
                if (i != 0) {
                    thisElement.parentNode.previousSibling.childNodes[i].className = "hide";
                    thisElement.parentNode.previousSibling.childNodes[i - 1].className = "show";

                    if (i == 1) {
                        $("aPrevArticles").className = "prevPage_off";
                    }

                    return;
                }
            }
        }
    }
    //FF
    else {
        totalBrowseArticlesPages = 0;
        //Counting real childNodes        
        for (j = 0; j < thisElement.parentNode.previous().childNodes.length; j++) {
            if (thisElement.parentNode.previous().childNodes[j].nodeName == "DIV") {
                totalBrowseArticlesPages++;
            }
        }        
        
        //If the first one isn't a DIV then start on the next one
        var startPosition = 0;

        while (thisElement.parentNode.previous().childNodes[startPosition].nodeName != "DIV") {
            startPosition++;
        }


        for (i = startPosition; i <= totalBrowseArticlesPages; i++) {
            
            if (thisElement.parentNode.previous().childNodes[i].className == "show") {
                
                //If it's not the first one
                if (i != startPosition) {                    
                    thisElement.parentNode.previous().childNodes[i].className = "hide";
                    thisElement.parentNode.previous().childNodes[i - 1].className = "show";

                    if (i == (startPosition+1)) {
                        $("aPrevArticles").className = "prevPage_off";
                    }

                    return;
                }                
            }
        }
    }    
}

function nextPageArticles(thisElement) {
    $("aPrevArticles").className = "prevPage";

    var totalBrowseArticlesPages;    

    //IE
    if (thisElement.parentNode.previousSibling.nodeName == "DIV") {
        totalBrowseArticlesPages = thisElement.parentNode.previousSibling.childNodes.length;
        
        for (i = 0; i < totalBrowseArticlesPages; i++) {
            if (thisElement.parentNode.previousSibling.childNodes[i].className == "show") {
                //If it's not the last one
                if (i != totalBrowseArticlesPages - 1) {
                    thisElement.parentNode.previousSibling.childNodes[i].className = "hide";
                    thisElement.parentNode.previousSibling.childNodes[i + 1].className = "show";

                    if (i == totalBrowseArticlesPages - 2) {
                        $("aNextArticles").className = "nextPage_off";
                    }

                    return;
                }
            }
        }
    }
    //FF
    else
    {        
        totalBrowseArticlesPages = 0;
        //Counting real childNodes        
        for (j = 0; j < thisElement.parentNode.previous().childNodes.length; j++) {
            if (thisElement.parentNode.previous().childNodes[j].nodeName == "DIV") {
                totalBrowseArticlesPages++;
                
            }
        }        

        for (i = 0; i < totalBrowseArticlesPages; i++) {
            
            if (thisElement.parentNode.previous().childNodes[i].className == "show") {
                
                thisElement.parentNode.previous().childNodes[i].className = "hide";
                thisElement.parentNode.previous().childNodes[i + 1].className = "show";

                if (i == totalBrowseArticlesPages - 1) {
                    $("aNextArticles").className = "nextPage_off";
                }

                return;
            }
        }
    }
}

/*:::::::::::::: Browse Case Studies Pagination ::::::::::::::*/
function previousPageCaseStudies(thisElement) {
    $("aNextCaseStudies").className = "nextPage";

    var totalBrowseCaseStudiesPages;
    
    //IE
    if (thisElement.parentNode.previousSibling.nodeName == "DIV") {
        totalBrowseCaseStudiesPages = thisElement.parentNode.previousSibling.childNodes.length;

        for (i = 0; i < totalBrowseCaseStudiesPages; i++) {
            if (thisElement.parentNode.previousSibling.childNodes[i].className == "show") {
                //If it's not the first one
                if (i != 0) {
                    thisElement.parentNode.previousSibling.childNodes[i].className = "hide";
                    thisElement.parentNode.previousSibling.childNodes[i - 1].className = "show";

                    if (i == 1) {
                        $("aPrevCaseStudies").className = "prevPage_off";
                    }

                    return;
                }
            }
        }
    }
    //FF
    else {
        totalBrowseCaseStudiesPages = 0;
        //Counting real childNodes        
        for (j = 0; j < thisElement.parentNode.previous().childNodes.length; j++) {
            if (thisElement.parentNode.previous().childNodes[j].nodeName == "DIV") {
                totalBrowseCaseStudiesPages++;
            }
        }

        //If the first one isn't a DIV then start on the next one
        var startPosition = 0;

        while (thisElement.parentNode.previous().childNodes[startPosition].nodeName != "DIV") {
            startPosition++;
        }

        for (i = startPosition; i <= totalBrowseCaseStudiesPages; i++) {
            if (thisElement.parentNode.previous().childNodes[i].className == "show") {
                //If it's not the first one
                if (i != startPosition) {
                    thisElement.parentNode.previous().childNodes[i].className = "hide";
                    thisElement.parentNode.previous().childNodes[i - 1].className = "show";

                    if (i == (startPosition+1)) {
                        $("aPrevCaseStudies").className = "prevPage_off";
                    }

                    return;
                }
            }
        }
    }    
}

function nextPageCaseStudies(thisElement) {
    $("aPrevCaseStudies").className = "prevPage";
    var totalBrowseCaseStudiesPages;

    //IE
    if (thisElement.parentNode.previousSibling.nodeName == "DIV") {
        totalBrowseCaseStudiesPages = thisElement.parentNode.previousSibling.childNodes.length - 1;

        for (i = 0; i < totalBrowseCaseStudiesPages; i++) {
            if (thisElement.parentNode.previousSibling.childNodes[i].className == "show") {
                //If it's not the last one
                if (i != totalBrowseCaseStudiesPages - 1) {
                    thisElement.parentNode.previousSibling.childNodes[i].className = "hide";
                    thisElement.parentNode.previousSibling.childNodes[i + 1].className = "show";

                    if (i == totalBrowseCaseStudiesPages - 2) {
                        $("aNextCaseStudies").className = "nextPage_off";
                    }

                    return;
                }
            }
        }
    }
    //FF
    else {

        totalBrowseCaseStudiesPages = 0;
        //Counting real childNodes        
        for (j = 0; j < thisElement.parentNode.previous().childNodes.length; j++) {
            if (thisElement.parentNode.previous().childNodes[j].nodeName == "DIV") {
                totalBrowseCaseStudiesPages++;

            }
        }
        totalBrowseCaseStudiesPages--;      
        
        for (i = 0; i < totalBrowseCaseStudiesPages; i++) {

            if (thisElement.parentNode.previous().childNodes[i].className == "show") {
                            
                thisElement.parentNode.previous().childNodes[i].className = "hide";
                thisElement.parentNode.previous().childNodes[i + 1].className = "show";

                if (i == totalBrowseCaseStudiesPages - 1) {
                    $("aNextCaseStudies").className = "nextPage_off";
                }

                return;
            }
        }
    }
}

/*:::::::::::::: Items (Concerns/Questions) Pagination ::::::::::::::*/
function previousPageItems(thisElement) {

    var totalItemsPages;
    
    //IE
    if (thisElement.nextSibling.nodeName == "A") {
        thisElement.nextSibling.className = "nextPage";
        totalItemsPages = thisElement.parentNode.previousSibling.childNodes.length;

        for (i = 0; i < totalItemsPages; i++) {
            if (thisElement.parentNode.previousSibling.childNodes[i].className == "show") {
                //If it's not the first one
                if (i != 0) {
                    thisElement.parentNode.previousSibling.childNodes[i].className = "hide";
                    thisElement.parentNode.previousSibling.childNodes[i - 1].className = "show";

                    if (i == 1) {
                        thisElement.className = "prevPage_off";
                    }

                    return;
                }
            }
        }
    }
    //FF
    else {
        thisElement.next().className = "nextPage";        

        totalItemsPages = 0;
        //Counting real childNodes        
        for (j = 0; j < thisElement.parentNode.previous().childNodes.length; j++) {
            if (thisElement.parentNode.previous().childNodes[j].nodeName == "DIV") {
                totalItemsPages++;
            }
        }

        //If the first one isn't a DIV then start on the next one
        var startPosition = 0;

        while (thisElement.parentNode.previous().childNodes[startPosition].nodeName != "DIV") {
            startPosition++;
        }

        for (i = startPosition; i <= totalItemsPages; i++) {
            if (thisElement.parentNode.previous().childNodes[i].className == "show") {
                //If it's not the first one
                if (i != startPosition) {
                    thisElement.parentNode.previous().childNodes[i].className = "hide";
                    thisElement.parentNode.previous().childNodes[i - 1].className = "show";

                    if (i == (startPosition+1)) {
                        thisElement.className = "prevPage_off";
                    }

                    return;
                }
            }
        }
    }    
}

function nextPageItems(thisElement) {

    var totalItemsPages;
    
    //IE
    if (thisElement.previousSibling.nodeName == "A") {
        thisElement.previousSibling.className = "prevPage";
        totalItemsPages = thisElement.parentNode.previousSibling.childNodes.length;
        
        for (i = 0; i < totalItemsPages; i++) {
            if (thisElement.parentNode.previousSibling.childNodes[i].className == "show") {
                
                //If it's not the last one
                if (i != totalItemsPages - 1) {
                    thisElement.parentNode.previousSibling.childNodes[i].className = "hide";
                    thisElement.parentNode.previousSibling.childNodes[i + 1].className = "show";

                    if (i == totalItemsPages - 2) {
                        thisElement.className = "nextPage_off";
                    }

                    return;
                }
            }
        }
    }
    //FF
    else {
        thisElement.previous().className = "prevPage";        

        totalItemsPages = 0;
        //Counting real childNodes        
        for (j = 0; j < thisElement.parentNode.previous().childNodes.length; j++) {
            if (thisElement.parentNode.previous().childNodes[j].nodeName == "DIV") {
                totalItemsPages++;
            }
        }
        
        for (i = 0; i < totalItemsPages; i++) {
            if (thisElement.parentNode.previous().childNodes[i].className == "show") {

                thisElement.parentNode.previous().childNodes[i].className = "hide";
                thisElement.parentNode.previous().childNodes[i + 1].className = "show";

                if (i == totalItemsPages - 1) {
                    thisElement.className = "nextPage_off";
                }

                return;
            }
        }    
    }
}

/*:::::::::::::: Sniffer Pagination ::::::::::::::*/
function previousPageSniffer(thisElement) {
    $("aNextSnifferPage").className = "nextPage";

    var totalSnifferPages;

    totalSnifferPages = $(thisElement.id).ancestors()[0].previous().childElements().length;

    for (i = 0; i < totalSnifferPages; i++) {
        if ($(thisElement.id).ancestors()[0].previous().childElements()[i].className == "show") {
            //If it's not the first one
            if (i != 0) {
                $(thisElement.id).ancestors()[0].previous().childElements()[i].className = "hide";
                $(thisElement.id).ancestors()[0].previous().childElements()[i-1].className = "show";

                if (i == 1) {
                    $("aPrevSnifferPage").className = "prevPage_off";
                }

                return;
            }
        }
    }    
}

function nextPageSniffer(thisElement) {    
    $("aPrevSnifferPage").className = "prevPage";

    var totalSnifferPages;

    totalSnifferPages = $(thisElement.id).ancestors()[0].previous().childElements().length;

    for (i = 0; i < totalSnifferPages; i++) {        
        if ($(thisElement.id).ancestors()[0].previous().childElements()[i].className == "show") {
            //If it's not the last one
            if (i != totalSnifferPages - 1) {                
                $(thisElement.id).ancestors()[0].previous().childElements()[i].className = "hide";
                $(thisElement.id).ancestors()[0].previous().childElements()[i + 1].className = "show";

                if (i == totalSnifferPages - 2) {
                    $("aNextSnifferPage").className = "nextPage_off";
                }

                return;
            }
        }
    }    
}


/*:::::::::::::: Getting installed Silverlight ::::::::::::::*/

var silverlightversion;

if (Silverlight.isInstalled("2.0.31005")) {
    silverlightversion = "2.0.31005";  
}
else if (Silverlight.isInstalled("2.0.30523")) {
    silverlightversion = "2.0.30523";    
}
else if (Silverlight.isInstalled("1.0")) {
    silverlightversion = "1.0";    
}
else if (Silverlight.isInstalled("2.0")) {
    silverlightversion = "2.0";    
}

function updateSilverlightMessage() {   
    
    //If it is not the latest version
    if (silverlightversion != "2.0.31005") {
        //If it is an old version
        if (silverlightversion == "1.0" || silverlightversion == "2.0" || silverlightversion == "2.0.30523") {            
            if ($("divOldInstalled") != null && $("divSLNotInstalled") != null) {                
                $("divOldInstalled").show();
                $("divOldInstalledExtra").show();
                $("divDownloadBtn").show();                
            }
        }
        //If it is not installed
        else {            
            if ($("divOldInstalled") != null && $("divSLNotInstalled") != null) {
                $("divSLNotInstalled").show();                                                              
                $("divDownloadBtn").show();                
            }
        }        
    }
    //If latest is installed
    else {        
        if ($("divlblContent")!=null) {
            $("divlblContent").show();
        }

        //Show whiteBox
        if ($("whiteBoxHero") != null) {            
            //$("titleHero").show();
            //$("contentTitle").show();
        }      
    }
}

function installLatestSilverlight() {
    Silverlight.getSilverlight('2.0');
}

/*:::::::::::::: Show/Hide showDropTabs ::::::::::::::*/

function showDropTabs() {
    //whoClicked = "viewDropTabs";
    
    /*if ($("dropTabs").style.display == "none") {
        $("dropTabs").show();
    }
    else {
        $("dropTabs").hide();
    } */
    $("dropTabs").show();
}

function hideDropTabs() {    
    /*if (whoClicked == "viewDropTabs") {
        whoClicked = "";
    }
    else {
        if ($("dropTabs") != null) {
            $("dropTabs").hide();    
        }        
    }*/
    if ($("dropTabs") != null) {
        $("dropTabs").hide();
    }
}

/*:::::::::::::: Client ID Values Flyouts ::::::::::::::*/

//divFlyout - PRB
var flyoutArticlesClientID;
var flyoutVideosClientID;
var flyoutDemosClientID;
var flyoutEventsClientID;
var flyoutOffersClientID;

//PanelFlyout - PRB
var pnlVideosClientID;
var pnlArticlesClientID;
var pnlDemosClientID;
var pnlEventsClientID;
var pnlOffersClientID;

//wraperRptr - PRB
var wraperRptrArticlesClientID;
var wraperRptrVideosClientID;
var wraperRptrDemosClientID;
var wraperRptrEventsClientID;
var wraperRptrOffersClientID;

//lnkBtnPrev - PRB
var lnkBtnPrevArticlesClientID;
var lnkBtnPrevVideosClientID;
var lnkBtnPrevDemosClientID;
var lnkBtnPrevEventsClientID;
var lnkBtnPrevOffersClientID;

//lnkBtnNext - PRB
var lnkBtnNextArticlesClientID;
var lnkBtnNextVideosClientID;
var lnkBtnNextDemosClientID;
var lnkBtnNextEventsClientID;
var lnkBtnNextOffersClientID;

//wraperRightElements - CC
//var wraperRightOffersClientID;

//To be set once the flyout has been chosen
var linkPrev;
var linkNext;
//--PRB
var totalArticles;
var totalVideos;
var totalDemos;
var totalEvents;
var totalElements;
//--CC
var totalOffers


/*:::::::::::::: Accordion Panes - PRB ::::::::::::::*/
var headerVideosClientID;
var headerArticlesClientID;
var headerDemosClientID;
var headerGraphClientID;
var headerContactsClientID;
var headerToolsClientID;
//var headerOffersPRBClientID;

/*:::::::::::::: Accordion Panes - PRB & CC ::::::::::::::*/
var headerEventsClientID;
var headerOffersClientID;

/*:::::::::::::: Accordion Panes - CC ::::::::::::::*/
var headerFindPartnerClientID;
var headerContactMicrosoftClientID;
var headerTalkTDMClientID;

function changeBackHeaders(site) {

    if (site == "prb") {
        if (headerVideosClientID != null && headerVideosClientID != "")
            $(headerVideosClientID).className = "tab";
        if (headerArticlesClientID != null && headerArticlesClientID != "")
            $(headerArticlesClientID).className = "tab";
        if (headerDemosClientID != null && headerDemosClientID != "")
            $(headerDemosClientID).className = "tab";
        if (headerGraphClientID != null && headerGraphClientID != "")
            $(headerGraphClientID).className = "tab";
        if (headerEventsClientID != null && headerEventsClientID != "")
            $(headerEventsClientID).className = "tab";
        if (headerContactsClientID != null && headerContactsClientID != "")
            $(headerContactsClientID).className = "tab";
        if (headerToolsClientID != null && headerToolsClientID != "")
            $(headerToolsClientID).className = "tab";
        if (headerOffersClientID != null && headerOffersClientID != "") {
            $(headerOffersClientID).className = "tab";

            //Fixing bug for IE (extra spacing on headers)
            if (isIE) {
                var baseThis = $(headerOffersClientID).firstChild.lastChild;
                baseThis.style.height = "10px";
            }            
        }
            
    }
    //If CC
    else {
        if (headerFindPartnerClientID != null && headerFindPartnerClientID != "")
            $(headerFindPartnerClientID).className = "tab";
        if (headerContactMicrosoftClientID != null && headerContactMicrosoftClientID != "")
            $(headerContactMicrosoftClientID).className = "tab";
        if (headerTalkTDMClientID != null && headerTalkTDMClientID != "")
            $(headerTalkTDMClientID).className = "tab";
        if (headerEventsClientID != null && headerEventsClientID != "")
            $(headerEventsClientID).className = "tab";
        if (headerOffersClientID != null && headerOffersClientID != "") {
            $(headerOffersClientID).className = "tab";        
            
            //Fixing bug for IE (extra spacing on headers)
            if (isIE) {
                var baseThis = $(headerOffersClientID).firstChild.lastChild;
                baseThis.style.height = "10px";
            }
        }            
    }    
}


/*:::::::::::::: Accordion Panes hero ::::::::::::::*/

var headerMainHeroClientID = "closeAllTabBtn";

function hideMainHeader() {
    $(headerMainHeroClientID).hide();
}

function showMainHeader() {
    $(headerMainHeroClientID).show();
    $(headerMainHeroClientID).parentNode.style.display = "block";
}

var headerHeroAccordionsString = "";
var headersAccordionArray;

var headersAccordionArray_default = "";
var headersAccordionArray_solutions = "";
var headersAccordionArray_proof = "";
var headersAccordionArray_resources = "";

function setHeaderArrays() {    
    switch (actualPage) {
        case "default":
            if (headersAccordionArray_default == "") {
                headersAccordionArray_default = headerHeroAccordionsString.split(";");
            }            
            break;

        case "solutions":
            if (headersAccordionArray_solutions == "") {
                headersAccordionArray_solutions = headerHeroAccordionsString.split(";");
            }            
            break;

        case "proof":
            if (headersAccordionArray_proof == "") {
                headersAccordionArray_proof = headerHeroAccordionsString.split(";");
            }            
            break;

        case "resources":
            if (headersAccordionArray_resources == "") {
                headersAccordionArray_resources = headerHeroAccordionsString.split(";");
            }            
            break;
    }
}

function changeBackHeadersHero() {       
    switch (actualPage) {
        case "default":
            headersAccordionArray = headersAccordionArray_default;            
            break;

        case "solutions":
            headersAccordionArray = headersAccordionArray_solutions;            
            break;

        case "proof":
            headersAccordionArray = headersAccordionArray_proof;            
            break;

        case "resources":
            headersAccordionArray = headersAccordionArray_resources;            
            break;
    }
    
    
    if (headersAccordionArray != undefined)
    {
        
        for (var i = 0; i < headersAccordionArray.length; i++) {
            
            
            try {
                $(headersAccordionArray[i]).className = "accordionTab";
                
            } catch (ex) {
                //catches error produced when going from tabs 2-4 then to optimize cash flow tab
            }
        }    
    }
}

function changeClassHeaderHero(thisElement, newClassName) {
    var actualClassName = thisElement.className;
    if (actualClassName != newClassName) {
        thisElement.className = newClassName;        
    }
}

function addHeaderID(newHeadersIDs) {
    headerHeroAccordionsString = newHeadersIDs;
    setHeaderArrays();
}

/*:::::::::::::: Show and Hide Flyouts ::::::::::::::*/

var target = ""; //Target to animate
var item; //Item to show and hide (target container)
var wraperRepeater; //Wraper that contains the repeater for the current flyout
var pageFlyout;
var widthFlyout = 520;
var heightFlyout = 450;
//var heightFlyout;
var pageposition;
var maxPagesFlyout;
var flyoutShown = false;
var headerAccordionOpened; //Header to set the top coordinate of the flyout

function showFlyout(type) {    
    whoClicked = "viewFlyout";
    
    setCurrentElements(type);
    
    if(item.style.display == 'block')
    {  
        animateHide();     
    }
    else
    {    
        setFlyout(type);
        item.show();        
        animateShow();
    }
    flyoutShown = true;  
}

function hideFlyout() {
    if (whoClicked == "viewFlyout" || whoClicked == "changePage") {
        whoClicked = "";
    }
    else {
        if (target != "") {
            animateHide();
            flyoutShown = false;         
        }
    }
}

function setCurrentElements(type)
{
    switch(type)
    {
        //----- PRB -----// 
        case "Articles":
            item = $(flyoutArticlesClientID);
            target = pnlArticlesClientID;
            headerAccordionOpened = headerArticlesClientID;
            totalElements = totalArticles;
            wraperRepeater = wraperRptrArticlesClientID;
            linkPrev = lnkBtnPrevArticlesClientID;
            linkNext = lnkBtnNextArticlesClientID;
            break;

        case "Videos":
            item = $(flyoutVideosClientID);
            target = pnlVideosClientID;
            headerAccordionOpened = headerVideosClientID;
            totalElements = totalVideos;
            wraperRepeater = wraperRptrVideosClientID;
            linkPrev = lnkBtnPrevVideosClientID;
            linkNext = lnkBtnNextVideosClientID;
            break;

        case "Demos":
            item = $(flyoutDemosClientID);
            target = pnlDemosClientID;
            headerAccordionOpened = headerDemosClientID;
            totalElements = totalDemos;
            wraperRepeater = wraperRptrDemosClientID;
            linkPrev = lnkBtnPrevDemosClientID;
            linkNext = lnkBtnNextDemosClientID;
            break;        

        //----- PRB & CC -----//
        case "Events":
            item = $(flyoutEventsClientID);
            target = pnlEventsClientID;
            headerAccordionOpened = headerEventsClientID;
            totalElements = totalEvents;
            wraperRepeater = wraperRptrEventsClientID;
            linkPrev = lnkBtnPrevEventsClientID;
            linkNext = lnkBtnNextEventsClientID;
            break;

        case "Offers":
            item = $(flyoutOffersClientID);
            target = pnlOffersClientID;
            headerAccordionOpened = headerOffersClientID;
            totalElements = totalOffers;
            wraperRepeater = wraperRptrOffersClientID;
            linkPrev = lnkBtnPrevOffersClientID;
            linkNext = lnkBtnNextOffersClientID;            
            break;
    }    
}

function setFlyout(type)
{
    //Initial values
    pageFlyout = 1;
    pageposition = 0;
    $(wraperRepeater).style.left = pageposition;  
        
    //Setting pagination   
    if(totalElements<=6)
    {
        $(linkNext).hide();
    }
    else
    {
        $(linkNext).show();
    }
    if(pageFlyout == 1)
    {
        $(linkPrev).hide();
    }
    else
    {
        $(linkPrev).show();
    }    
    
    //Setting Width and Height for the flyout
    var nbElementsVertical = 3;
    var nbElementsFlyout = nbElementsVertical*2;
                 
    var extra;
    
    if(totalElements%nbElementsFlyout)
    {
        extra = 1;
    }
    else
    {
        extra = 0;
    }
        
    maxPagesFlyout = Math.floor((totalElements/nbElementsFlyout) + extra);
    
    var totalWidth = maxPagesFlyout*widthFlyout;
    var totalHeight;

    //totalHeight = $("headlineWrap").offsetHeight + $("wraperRight" + type).offsetHeight + $("wraperViewAll" + type).offsetHeight + 10 + 11; //10 is the top margin + bottom margin on the View All wraper, 11 is for the controls class
        
    totalHeight = $("wraperRight" + type).offsetHeight - $("wraperViewAll" + type).offsetHeight - 5;
    if (isIE) {
        if (isIE7Min) {
            //nothing
        }
        else {
            totalHeight -= 12;
        }
    }

    //$(wraperRepeater).style.height = $("wraperRight" + type).offsetHeight - $("wraperViewAll" + type).offsetHeight - 5 + "px";

    $(wraperRepeater).style.height = totalHeight + "px";
    
    /*if (isPRB) {
        totalHeight = $("headlineWrap").offsetHeight + $("wraperRight" + type).offsetHeight + $("wraperViewAll" + type).offsetHeight + 10 + 11; //10 is the top margin + bottom margin on the View All wraper, 11 is for the controls class
        $(wraperRepeater).style.height = $("wraperRight" + type).offsetHeight - $("wraperViewAll" + type).offsetHeight - 5 + "px";
    }
    else {        
        totalHeight = $("headlineWrap").offsetHeight + $(wraperRightOffersClientID).offsetHeight + $("wraperViewAllElements").offsetHeight + 10 + 11; //10 is the top margin + bottom margin on the View All wraper, 11 is for the controls class
        $(wraperRepeater).style.height = $(wraperRightOffersClientID).offsetHeight - $("wraperViewAllElements").offsetHeight - 5 + "px";
    } */   
    
    $(wraperRepeater).style.width = totalWidth + "px";    
}

window.addEventListener?window.addEventListener("resize", moveFlyout, false):window.attachEvent("onresize", moveFlyout);

function moveFlyout()
{
    if ($(target) != null)
    {
        var flyout = $get(target);
        var header = $get(headerAccordionOpened);
        
        var pnlFlyout = Sys.UI.DomElement.getLocation(flyout);
        var headerLocation = Sys.UI.DomElement.getLocation(header);
    
        flyout.style.left = parseInt(headerLocation.x - 520 + 213, 10) + 'px';
    }
}

/*:::::::::::::: Pagination Flyouts ::::::::::::::*/
function previousPage()
{
    whoClicked = "changePage";
    if(pageFlyout>1)
    {
        pageFlyout --;
        pageposition += widthFlyout;
        $(wraperRepeater).style.left = pageposition + "px";
        if(pageFlyout==1)
        {
            $(linkPrev).hide();
        }
        $(linkNext).show();        
    }
}

function nextPage()
{
    whoClicked = "changePage";
    if(pageFlyout<maxPagesFlyout)
    {
        pageFlyout ++;
        pageposition -= widthFlyout;
        $(wraperRepeater).style.left = pageposition + "px";
        if(pageFlyout==maxPagesFlyout)
        {
            $(linkNext).hide();
        }
        $(linkPrev).show();        
    }
}


/*:::::::::::::: Animation Flyouts ::::::::::::::*/
var animation = null;

function animateShow() 
{
    var coordinatesHeader = $(headerAccordionOpened).cumulativeOffset();
    $(target).style.left = coordinatesHeader[0] + $(headerAccordionOpened).getWidth() + "px";
    var top = coordinatesHeader[1] - 2;
    $(target).style.top = top + "px";
    
    //$AA.MoveAnimation = function(target, duration, fps, horizontal, vertical, relative, unit)
    var animationMoveLeft = new $AA.MoveAnimation($get(target), 0.5, 10, -520, 0, true, "px");

    //$AA.ResizeAnimation = function(target, duration, fps, width, height, unit)
    var animationResizeMaximizeWidth = new $AA.ResizeAnimation($get(target), 0.5, 10, widthFlyout, 25, "px");

    //$AA.ParallelAnimation = function(target, duration, fps, animations)
    var animationMoveLeft_ResizeMaximizeWidth = new $AA.ParallelAnimation($get(target), 0.5, 10, [animationMoveLeft, animationResizeMaximizeWidth]);
    
    //$AA.ResizeAnimation = function(target, duration, fps, width, height, unit)
    var animationResizeMaximizeHeight = new $AA.ResizeAnimation($get(target), 0.5, 10, widthFlyout, heightFlyout, "px");

    //$AA.SequenceAnimation = function(target, duration, fps, animations, iterations)
    if (animation == null) {
        animation = new $AA.SequenceAnimation($get(target), 0.5, 10, [animationMoveLeft_ResizeMaximizeWidth, animationResizeMaximizeHeight], 1);
    }
    animation.play();    
    animation = null;
}

function animateHide() 
{
    if (flyoutShown) {
        //$AA.ResizeAnimation = function(target, duration, fps, width, height, unit)
        var animationResizeMinimizeHeight = new $AA.ResizeAnimation($get(target), 0.5, 10, widthFlyout, 0, "px");

        //$AA.MoveAnimation = function(target, duration, fps, horizontal, vertical, relative, unit)
        var animationMoveRight = new $AA.MoveAnimation($get(target), 0.5, 10, 520, 0, true, "px");

        //$AA.ResizeAnimation = function(target, duration, fps, width, height, unit)
        var animationResizeMinimizeWidth = new $AA.ResizeAnimation($get(target), 0.5, 10, 0, 25, "px");

        //$AA.ParallelAnimation = function(target, duration, fps, animations)
        var animationMoveLeft_ResizeMinimizeWidth = new $AA.ParallelAnimation($get(target), 0.5, 10, [animationResizeMinimizeWidth, animationMoveRight]);

        //$AA.SequenceAnimation = function(target, duration, fps, animations, iterations)
        if (animation == null) {
            animation = new $AA.SequenceAnimation($get(target), 0.5, 10, [animationResizeMinimizeHeight, animationMoveLeft_ResizeMinimizeWidth], 1);
        }
        animation.play();
        animation = null;
    }
}

/*
Download
*/

function openDownloadWindow(downloadPageUrl)
{
    window.open(downloadPageUrl, null, "height=20,width=400,left=100,top=100,status=no,toolbar=no,menubar=no,location=no", false);
}

/* survey assessment section */
function showAssessmentSurvey() {
    $("heroContainer").hide();
    $("assessmentWhitebox").hide();
    $("selfAssesmentSurvey").show();
}


/*:::::::::::::: Search bar ::::::::::::::*/

var locale;

function search(sender, eventArgs) {    
    //document.URL = "http://search.microsoft.com/results.aspx?mkt=en-US&setlang=en-US&q=" + $get("searchBox").value;
    //window.location = "http://search.microsoft.com/results.aspx?mkt=en-US&setlang=en-US&q=" + $get("searchBox").value;

    //window.open("http://search.microsoft.com/results.aspx?mkt=en-US&setlang=en-US&q=" + $get("searchBox").value);
    window.open("http://search.microsoft.com/results.aspx?mkt=" + locale + "&setlang=" + locale + "&q=" + $get("searchBox").value);
    $get("searchBox").value = "";
    return false;
}

function searchButtonPress(sender, eventArgs) {
    if (sender.rawEvent.keyCode == Sys.UI.Key.enter) {
        search(sender, eventArgs);
        return false;
    }
}

function checkKey(e) {
    var characterCode;

    if(e && e.which){ //if which property of event object is supported (NN4)
        e = e;
        characterCode = e.which;  //character code is contained in NN4's which property
    }
    else{
        e = event;
        characterCode = e.keyCode;  //character code is contained in IE's keyCode property
    }

    if(characterCode == 13){ //if generated character code is equal to ascii 13 (if enter key)
        return false;
    }
    else{
        return true;
    }
}

/*:::::::::::::: Share Bar ::::::::::::::*/

function hideSharePopUp() {
    //alert(whoClicked);
    if ($("shareFlyout") != null) {
        if (whoClicked == "share") {
            whoClicked = "";
        }
        else {
            $("shareFlyout").hide();
        }
    }
}

/*:::::::::::::: History Points ::::::::::::::*/

var actualPage = "default";

function changeActualPage(newPage) {
    if (newPage != "default")
    {
        if (actualPage != newPage)
        {
            //pageEventsTracking.initialize();
        }
    }

    actualPage = newPage;
    
    //This is for PRB only --> Carousel Hero
    /*if (newPage == "default") {
        initializeAssets();
        advanceCarousel();
        alert("here coming back to home");
    }*/
}

var userNavigated = true;

function addHistoryPoints(poid, ng) {
    userNavigated = false;
        
    var historyPoints =
        {
            "poid": poid,
            "ng": ng
        };

    Sys.Application.addHistoryPoint(historyPoints);
    userNavigated = true;
}

function onNavigate(sender, e) {
    var poid = e.get_state().poid;
    var ng = e.get_state().ng;
    
    //If back/forward button only
    if (userNavigated && (ng==actualPage)) {
        restoreState(poid);        
    }
}

//var accordionClientID = "ctl00_ctrlHeroPanel_ctl01_ctrlAccordionHero";
var accordionClientID;

function restoreState(poid) {

    if ($(accordionClientID) != null) {
        changeBackHeadersHero();
        $get(accordionClientID).AccordionBehavior.set_SelectedIndex(poid);
                
        if (poid > 0) {
            showMainHeader();
            $(headersAccordionArray[poid - 1]).className = "accordionTab_on";            
        }
    }
}

function setctrlAccordionHeroId(newClientID) {
    accordionClientID = newClientID;
}

/*:::::::::::::: Preloading images ::::::::::::::*/
var imgs = new Array();

//RightNav Over States
imgs[0] = "../Common/img/rightnav_bg_base_last_on.gif";
imgs[1] = "../Common/img/rightnav_bg_base_last_on.png";
imgs[2] = "../Common/img/rightnav_bg_base_on.gif";
imgs[3] = "../Common/img/rightnav_bg_base_on.png";
imgs[4] = "../Common/img/rightnav_bg_on.gif";
imgs[5] = "../Common/img/rightnav_bg_on.png";
imgs[6] = "../Common/img/rightnav_bg_top_on.gif";
imgs[7] = "../Common/img/rightnav_bg_top_on.png";

//Hero Accordion Header Over States
imgs[8] = "../Common/img/hero_accordionTab_on.gif";
imgs[9] = "../Common/img/hero_accordionTab_on.png";
imgs[10] = "../Common/img/hero_accordionTab_on_base.gif";
imgs[11] = "../Common/img/hero_accordionTab_on_base.png";
imgs[12] = "../Common/img/hero_accordionTab_on_base_last.gif";
imgs[13] = "../Common/img/hero_accordionTab_on_base_last.png";
imgs[14] = "../Common/img/hero_accordionTab_on_top.gif";
imgs[15] = "../Common/img/hero_accordionTab_on_top.png";

//Buttons overstates
imgs[17] = "../Common/img/btn_blue_C_over.gif";
imgs[18] = "../Common/img/btn_blue_C_over.png";
imgs[19] = "../Common/img/btn_blue_L_over.gif";
imgs[20] = "../Common/img/btn_blue_L_over.png";
imgs[21] = "../Common/img/btn_blue_R_over.gif";
imgs[22] = "../Common/img/btn_blue_R_over.png";
imgs[23] = "../Common/img/btn_go_C_over.gif";
imgs[24] = "../Common/img/btn_go_C_over.png";
imgs[25] = "../Common/img/btn_go_L_over.gif";
imgs[26] = "../Common/img/btn_go_L_over.png";
imgs[27] = "../Common/img/btn_go_R_over.gif";
imgs[28] = "../Common/img/btn_go_R_over.png";
imgs[29] = "../Common/img/btn_go_C.gif";
imgs[30] = "../Common/img/btn_go_C.png";
imgs[31] = "../Common/img/btn_go_L.gif";
imgs[32] = "../Common/img/btn_go_L.png";
imgs[33] = "../Common/img/btn_go_R.gif";
imgs[34] = "../Common/img/btn_go_R.png";
imgs[35] = "../Common/img/btn_arrow_on.png";

function preload() {
    var tmp = null;

    //Preload images
    for (var i = 0; i < imgs.length; i++) {
        tmp = imgs[i];
        imgs[i] = new Image();
        imgs[i].src = tmp;
    }
}

void (preload());

/*:::::::::::::: Atlas tracking ::::::::::::::*/
//function trackClick(atlasId) {        
//    var s = document.createElement("script");
//    s.type = 'text/javascript';
//    s.src = "http://view.atdmt.com/jaction/" + atlasId;    

//    document.body.appendChild(s);
//}

/*US SMB Omniture Override for tracking*/
function trackClick(atlasId) {        
   pageEventsTracking.setClickEvents(atlasId);
}
function CreateBookmark(title, url, safariText1, safariText2)
{
    var ua = navigator.userAgent.toLowerCase();

    var isSafari = (ua.indexOf('webkit') != -1);
    var isMac = (ua.indexOf('mac') != -1);
    var buttonStr = isMac ? 'Command/Cmd' : 'CTRL';
	
	if (window.sidebar)
	{ 
	    // Mozilla Firefox Bookmark
		window.sidebar.addPanel(title, url, "");
	}
	else if( window.external )
	{ 
	    // IE Favorite
		window.external.AddFavorite(url, title);
    }
    else if (isSafari) { //Safari
        alert(safariText1 + " " + buttonStr + " + D " + safariText2);
    }
	else if(window.opera && window.print)
	{ 
	    // Opera Hotlist
		return true;
	}
 }
function TdmRoleManager(clientId, concernsPanelId, questionsPanelId) {
    this.clientId = clientId;
    this.concernsPanelId = concernsPanelId;
    this.questionsPanelId = questionsPanelId;
}

TdmRoleManager.prototype.showPanel = function(showConcerns) {

    $get(this.concernsPanelId).style.display = showConcerns ? "block" : "none";
    $get(this.questionsPanelId).style.display = !showConcerns ? "block" : "none";

    //alert($get(this.concernsPanelId).style.display);
}

/*
function rotate(left)
{
getMoveAnimation().set_target($get('<%= this.ClientID %>_RoleImagesBlock'));
getMoveAnimation().set_horizontal(left ? -68 : 68);
getRotateAnimation().play();
}

function getMoveAnimation()
{
return getRotateAnimation().get_animations()[1];
}

function getRotateAnimation()
{
return $find('<%= this.ClientID %>_Rotate').get_OnClickBehavior().get_animation();
}
*/

if (typeof (Sys) !== 'undefined') Sys.Application.notifyScriptLoaded();
if(typeof cs=="undefined") var cs={};
if(typeof cs.img=="undefined") cs.img={};
if(typeof cs.view=="undefined") cs.view={};
if(typeof cs.tab=="undefined") cs.tab={};
if(typeof cs.vbp=="undefined") cs.vbp={};
if(typeof cs.tracking=="undefined") cs.tracking={};
if(typeof cs.dom=="undefined") cs.dom={};
if(typeof cs.xml=="undefined") cs.xml={};
if(typeof cs.util=="undefined") cs.util={};
if(typeof cs.cache=="undefined") cs.cache={};
cs={
	lang:"",
	local:"",
	region:"",
	id:"",
	stopAll:false,
	init:function()
	{
		cs.util.setBrowser();
	},
	dispose:function()
	{
		cs.lang=cs.local=cs.region=cs.id='';
	},
	reload:function(lang,local,id)
	{
		var main = cs.cache.get(lang+'-'+local+id+'main');
		cs.lang = main.lang;
		cs.local = main.local;
		cs.region = main.region;
		cs.id = main.id;
		cs.xml.reload(cs.cache.get(lang+'-'+local+id+'xml'));
		cs.img.reload(cs.cache.get(lang+'-'+local+id+'img'));
		cs.view.reload(cs.cache.get(lang+'-'+local+id+'view'));
		cs.showProgress();
		cs.tab.reload();
		cs.mtt.reload();
		cs.vbp.reload();
		cs.util.reload();
		cs.dom.reload();
		cs.dom.get('csContent').innerHTML = cs.view.content.join('');
		cs.stopAll = false;
		cs.view.addHandlers();
	},
	setCaseStudy:function(lang, local, id)
	{
		cs.stopAll = true;
		if (cs.assert.notNull(lang) && cs.assert.notNull(local) && cs.assert.notNull(id)) 
		{
			cs.xml.dispose();
			cs.dom.dispose();
			cs.img.dispose();
			cs.view.dispose();
			cs.tab.dispose();
			cs.mtt.dispose();
			cs.vbp.dispose();
			cs.util.dispose();
			if(cs.assert.isNull(cs.cache.get(lang+'-'+local+id+'main')))
			{
				cs.lang = lang;
				cs.local = local;
				cs.region = cs.lang + "-" + cs.local;
				cs.id = id;
				cs.cache.set(lang+'-'+local+id+'main', {lang:cs.lang, local:cs.local, region:cs.region, id:cs.id});
				cs.img.region = "../Content/" + cs.region + "/Images/CaseStudies/";
				cs.img.global = "../Common/img/";
				cs.img.addPreloadItem("progress", cs.img.global + "caseStudy_progress.gif");
				cs.img.addPreloadItem("tooltip_top", cs.img.global + "caseStudy_tooltip_top.png");
				cs.img.addPreloadItem("tooltip_left", cs.img.global + "caseStudy_tooltip_left.png");
				cs.img.addPreloadItem("tooltip_leftShim", cs.img.global + "caseStudy_tooltip_leftShim.png");
				cs.img.addPreloadItem("tooltip_right", cs.img.global + "caseStudy_tooltip_right.png");
				cs.img.addPreloadItem("tooltip_rightShim", cs.img.global + "caseStudy_tooltip_rightShim.png");
				cs.img.addPreloadItem("tooltip_bottom", cs.img.global + "caseStudy_tooltip_bottom.png");
				cs.img.addPreloadItem("bg", cs.img.global + "caseStudy_bg.jpg");
				cs.img.addPreloadItem("vbp_selected", cs.img.global + "caseStudy_vbp_selected.gif");
				cs.img.addPreloadItem("bgSeparator", cs.img.global + "caseStudy_bgSeparator.gif");
				cs.img.addPreloadItem("mtt_item_image_filler", cs.img.global + "caseStudy_mtt_item_image_filler.gif");
				cs.img.addPreloadItem("mtt_ctrl_item_Show", cs.img.global + "caseStudy_mtt_ctrl_item_Show.gif");
				cs.img.addPreloadItem("mtt_ctrl_next_Out", cs.img.global + "caseStudy_mtt_ctrl_next_Out.gif");
				cs.img.addPreloadItem("mtt_ctrl_next_Over", cs.img.global + "caseStudy_mtt_ctrl_next_Over.gif");
				cs.img.addPreloadItem("mtt_ctrl_next_Hide", cs.img.global + "caseStudy_mtt_ctrl_next_Hide.gif");
				cs.img.addPreloadItem("mtt_ctrl_prev_Out", cs.img.global + "caseStudy_mtt_ctrl_prev_Out.gif");
				cs.img.addPreloadItem("mtt_ctrl_prev_Over", cs.img.global + "caseStudy_mtt_ctrl_prev_Over.gif");
				cs.img.addPreloadItem("mtt_ctrl_prev_Hide", cs.img.global + "caseStudy_mtt_ctrl_prev_Hide.gif");
				cs.img.addPreloadItem("btn_arrow_Over", cs.img.global + "btn_arrow_on.png");
				cs.img.addPreloadItem("btn_arrow_Out", cs.img.global + "btn_arrow_off.png");
				cs.showProgress();
				cs.stopAll = false;
				cs.xml.load("../Content/" + cs.region + "/Data/CaseStudies/Content/" + cs.id + ".xml");
			}
			else
			{
				cs.reload(lang,local,id);
			}
		}
	},
	setVideo:function(videoType)
	{
		cs.vbp.reset();
		if(cs.assert.notNull(videoType)) cs.vbp.setSelected(videoType);
	},
	setTab:function(tabID, tabSubID)
	{
		if(cs.assert.notNull(tabID)) cs.tab.setSelected(tabID, tabSubID);
	},
	showProgress:function()
	{
		cs.dom.get('csContent').innerHTML = '<div id="csBackground"><img src="'+cs.img.get('bg').src+'" width="580" height="248" /></div><img id="caseStudyProgress" src="'+cs.img.get('progress').src+'" />';
	}
}
cs.view={
	content:Array(),
	dispose:function()
	{
		cs.view.content = new Array();
		cs.dom.get('csContent').innerHTML = "";
	},
	reload:function(view)
	{
		cs.view.content = view.content;
	},
	create:function()
	{
		var d = cs.xml.data;
		var i = 0;
		var tBuffer = 8;
		var tSpacer = 40;
		var mttLen = d.MeetTheTeam.TeamMember.length;
		cs.view.content.push("<div class='csBackground' style='background-image:url(\""+cs.img.get('bg').src+"\"); background-repeat:repeat-x;'>");
		cs.view.content.push("	<div class='csMinHeight'>&nbsp;</div>");
		cs.view.content.push("	<div class='csSeparator' style='background-image:url(\""+cs.img.get('bgSeparator').src+"\"); background-repeat:repeat-y;'>&nbsp;</div>");
		cs.view.content.push("	<div id='csTab'>");
		cs.view.content.push("		<div id='csTabMenu'>");
		cs.view.content.push("			<div id='menuSynopsis' class='itemShow' atlasid='"+d.Synopsis.AtlasId+"'>"+d.Synopsis.SectionLabel+"</div>");
		cs.view.content.push("			<div class='separator'>|</div>");
		cs.view.content.push("			<div id='menuMeetTheTeam' class='itemHide' atlasid='"+d.MeetTheTeam.AtlasId+"'>"+d.MeetTheTeam.SectionLabel+"</div>");
		cs.view.content.push("			<div class='separator'>|</div>");
		cs.view.content.push("			<div id='menuRelatedLinks' class='itemHide' atlasid='"+d.RelatedLinks.AtlasId+"'>"+d.RelatedLinks.SectionLabel+"</div>");
		cs.view.content.push("		</div>");
		cs.view.content.push("		<div id='csTabContent'>");
		cs.view.content.push("			<div id='viewSynopsis' class='itemShow'>");
		cs.view.content.push("				<img class='logo' src='"+cs.img.get('SynopsisLogo').src+"' />" + d.Synopsis.Text);
		cs.view.content.push("			</div>");
		cs.view.content.push("			<div id='viewMeetTheTeam' class='itemHide'>");
		cs.view.content.push("				<div class='mttMenu'>");
		if(mttLen > 6)
		{
			cs.view.content.push("					<img id='mttCtrlPrev' src='"+cs.img.get('mtt_ctrl_prev_Hide').src+"' />");
			cs.view.content.push("					<div id='mttItemMask' class='mttItemMask'>");
		}
		else
		{
			cs.view.content.push("					<div style='position:relative; top:0px; left:0px; width:1px; height:48px; z-index:0;'>&nbsp;</div>");
			cs.view.content.push("					<div id='mttItemMask' class='mttItemMask' style='left:0px;'>");
		}
		cs.view.content.push("						<div id='mttContent'>");
		for(i=0; i<mttLen; i++)
		{
			var ID = d.MeetTheTeam.TeamMember[i].ID;
			cs.view.content.push("							<div id='mttItem"+ID+"Hit' class='item'>");
			cs.view.content.push("								<img id='mttItem"+ID+"Over' class='mttItemImageOver' style='display:none;' src='"+cs.img.get(ID+'Over').src+"' />");
			cs.view.content.push("								<img id='mttItem"+ID+"Out' class='mttItemImageOut' src='"+cs.img.get(ID+'Out').src+"' />");
			cs.view.content.push("								<img id='mttSelected"+ID+"' class='itemHide' src='"+cs.img.get('mtt_ctrl_item_Show').src+"' />");
			cs.view.content.push("							</div>");
		}
		cs.view.content.push("						</div>");
		cs.view.content.push("					</div>");
		if(mttLen > 6)
			cs.view.content.push("					<img id='mttCtrlNext' src='"+cs.img.get('mtt_ctrl_next_Hide').src+"' />");
		cs.view.content.push("				</div>");
		cs.view.content.push("				<div id='mttName' class='name'>" + "Nicola Montorsi" + "</div>");
		cs.view.content.push("				<div id='mttTitle' class='title'>" + "Director of Public Affairs, Gulf of Mexico Region" + "</div>");
		cs.view.content.push("				<div id='mttDescription' class='description'>" + "Nicola is responsible for educating the public on how the new storm tracking system helps improve safety and minimize potential environmental issues. She sees another advantage for consumers: The technology helps minimize the gap between shutdown and startup, so we're better able to ensure what's known in the industry as 'security of supply.' In that sense, consumers also benefit.</p>" + "</div>");
		cs.view.content.push("			</div>");
		// add related links
		cs.view.content.push("			<div id='viewRelatedLinks' class='itemHide'>");
		cs.view.content.push("				<ul>");
		var rlLen = d.RelatedLinks.LinkItem.length;
		for(i=0; i<rlLen; i++)
		{
			var linkItem = d.RelatedLinks.LinkItem[i];
			cs.view.content.push("					<li><a class='arrowBlueLink' href='"+linkItem.URLPath+"' target='_blank'>"+linkItem.Label+"</a></li>");
		}
		cs.view.content.push("				</ul>");
		cs.view.content.push("			</div>");
		
		cs.view.content.push("		</div>");
		cs.view.content.push("	</div>");
		cs.view.content.push("	<div id='csVBP'>");
		cs.view.content.push("		<div id='csVBPLabel'>"+d.ViewByPerspective.SectionLabel+"</div>");
		// add view by perpective menu items
		cs.view.content.push("		<div id='csVBPMenu'>");
		var pLen = d.ViewByPerspective.Perspective.length;
		for(i=0; i<pLen; i++)
		{
			var item = d.ViewByPerspective.Perspective[i];
			var type = item.Type;
			var name = item.Name;
			cs.view.content.push("			<div id='menu"+type+"' class='menuItem'>");
			cs.view.content.push("				<div class='itemImage'><img id='icon"+type+"' src='"+cs.img.get(type+'Out').src+"' /></div>");
			cs.view.content.push("				<div id='selected"+type+"' class='itemSelected'><img class='vbpSelected' src='"+cs.img.get('vbp_selected').src+"' /></div>");
			cs.view.content.push("				<div id='label"+type+"' class='itemLabelShow'>"+name+"</div>");
			cs.view.content.push("			</div>");
		}
		cs.view.content.push("		</div>");
		cs.view.content.push("	</div>");
		// add view by perspective menu item tooltips
		cs.view.content.push("	<div id='csVBPTooltip'>");
		for(i=0; i<pLen; i++)
		{
			var item = d.ViewByPerspective.Perspective[i];
			var type = item.Type;
			var name = item.Name;
			var text = item.Text;
			cs.view.content.push("		<div id='tooltip"+type+"' class='item' style='display:none;top:"+(tBuffer+(i*tSpacer))+"px;'>");
			if(cs.util.browserIsIE)
			{
				cs.view.content.push("			<div class='bgTop' style='filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\""+cs.img.get('tooltip_top').src+"\");'></div>");
			}
			else
			{
				cs.view.content.push("			<div class='bgTop' style='background-repeat:no-repeat; background-image:url(\""+cs.img.get('tooltip_top').src+"\");'></div>");
			}
			cs.view.content.push("			<div class='middle'>");
			cs.view.content.push("				<div class='minHeight'>&nbsp;</div>");
			cs.view.content.push("				<div class='background'></div>");
			cs.view.content.push("				<div class='content'>");
			cs.view.content.push("					<div class='label'>"+name+"</div>");
			cs.view.content.push("					<div class='description'>"+text+"</div>");
			cs.view.content.push("				</div>");
			cs.view.content.push("				<div class='bgLeftContainer'>");
			if(cs.util.browserIsIE)
			{
				cs.view.content.push("					<div class='left' style='filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\""+cs.img.get('tooltip_left').src+"\");'></div>");
				cs.view.content.push("					<div class='leftShim' style='filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\""+cs.img.get('tooltip_leftShim').src+"\", sizingMethod=\"scale\");'></div>");
			}
			else
			{
				cs.view.content.push("					<div class='left' style='background-repeat:no-repeat; background-image:url(\""+cs.img.get('tooltip_left').src+"\");'></div>");
				cs.view.content.push("					<div class='leftShim' style='background-repeat:repeat-y; background-image:url(\""+cs.img.get('tooltip_leftShim').src+"\");'></div>");
			}
			cs.view.content.push("				</div>");
			cs.view.content.push("				<div class='bgRightContainer'>");
			if(cs.util.browserIsIE) 
			{
				cs.view.content.push("					<div class='right' style='filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\"" + cs.img.get('tooltip_right').src + "\");'></div>");
				cs.view.content.push("					<div class='rightShim' style='filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\"" + cs.img.get('tooltip_rightShim').src + "\", sizingMethod=\"scale\");'></div>");
			}
			else 
			{
				cs.view.content.push("					<div class='right' style='background-repeat:no-repeat; background-image:url(\""+cs.img.get('tooltip_right').src+"\");'></div>");
				cs.view.content.push("					<div class='rightShim' style='background-repeat:repeat-y; background-image:url(\""+cs.img.get('tooltip_rightShim').src+"\");'></div>");
			}
			cs.view.content.push("				</div>");
			cs.view.content.push("			</div>");
			if(cs.util.browserIsIE)
			{
				cs.view.content.push("			<div class='bgBottom' style='filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\"" + cs.img.get('tooltip_bottom').src + "\");'></div>");
			}
			else
			{
				cs.view.content.push("			<div class='bgBottom' style='background-repeat:no-repeat; background-image:url(\""+cs.img.get('tooltip_bottom').src+"\");'></div>");
			}
			cs.view.content.push("		</div>");
		}
		cs.view.content.push("	</div>");
		cs.view.content.push("</div>");
		cs.cache.set(cs.region+cs.id+'view', {content:cs.view.content});
		cs.dom.get('csContent').innerHTML = cs.view.content.join('');
		cs.view.addHandlers();
	},
	addHandlers:function()
	{
		cs.tab.addHandlers();
		cs.vbp.addHandlers();
		cs.mtt.adjustContent();
		cs.mtt.addHandlers();
		cs.util.disableSelection('csContent');
		cs.mtt.setSelected(cs.xml.data.MeetTheTeam.TeamMember[0].ID);
	}
}
cs.tab={
	list:["Synopsis", "MeetTheTeam", "RelatedLinks"],
	dispose:function(){},
	reload:function(){},
	reset:function()
	{
		var items = cs.tab.list;
		var l = items.length;
		for(var i=0; i<l; i++)
		{
			if(cs.stopAll) return;
			cs.util.toggleCss('menu'+items[i],'itemShow','itemHide');
			cs.util.toggleCss('view'+items[i],'itemShow','itemHide');
		}
	},
	setSelected:function(tabID, tabSubID)
	{
		if(cs.assert.notNull(cs.dom.get('menu'+tabID)))
		{
			cs.tab.reset();
			cs.util.toggleCss('menu'+tabID,'itemHide','itemShow');
			cs.util.toggleCss('view'+tabID,'itemHide','itemShow');
			if(cs.assert.notNull(tabSubID))
			{
				if(tabID==cs.tab.list[0]){}
				else if(tabID==cs.tab.list[1]) cs.mtt.setSelected(tabSubID);
			}
		}
	},
	addHandlers:function()
	{
		var d = cs.xml.data;
		var items = cs.tab.list;
		var l = items.length;
		for(var i=0; i<l; i++)
		{
			if(cs.stopAll) return;
			var item = items[i];
			var menu = cs.dom.get('menu'+item);
			menu._id = item;
			menu._atlasid = d[item].AtlasId;
			menu.onmousedown = function() {cs.tracking.track(this._atlasid); cs.setTab(this._id);}
		}
	}
}
cs.mtt={
	currX:Number(),
	targX:Number(),
	itemW:48,
	contentW:Number(),
	maskW:288,
	contentDiff:Number(),
	interval:50,
	intervalId:Number(),
	ctrlInterval:300,
	ctrlIntervalId:Number(),
	currentlySelected:String(),
	effectDurationShow:0.3,
	effectDurationHide:0.5,
	effectHash:Object(),
	tweenHash:Object(),
	dispose:function()
	{
		cs.mtt.currX = new Number();
		cs.mtt.targX = new Number();
		cs.mtt.contentW = new Number();
		cs.mtt.contentDiff = new Number();
		clearInterval(cs.mtt.intervalId);
		clearInterval(cs.mtt.ctrlIntervalId);
		cs.mtt.intervalId = new Number();
		cs.mtt.ctrlIntervalId = new Number();
		cs.mtt.effectHash = new Object();
		cs.mtt.tweenHash = new Object();
		cs.mtt.currentlySelected = new String();
	},
	reload:function()
	{
		cs.mtt.currX = 0;
		cs.mtt.targX = 0;
	},
	adjustContent:function()
	{
		if(cs.stopAll) return;
		var t = cs.xml.data.MeetTheTeam.TeamMember;
		var l = t.length;
		if(l<6) l=6;
		cs.mtt.contentW = l * cs.mtt.itemW;
		if(cs.mtt.contentW > cs.mtt.maskW) cs.mtt.contentDiff = cs.mtt.contentW - cs.mtt.maskW;
		else cs.mtt.contentDiff = 0;
		cs.util.setStyle('mttContent','width',cs.mtt.contentW,'px');
	},
	addHandlers:function()
	{
		cs.mtt.addItemHandlers();
		cs.mtt.addCtrlHandlers();
	},
	addItemHandlers:function()
	{
		var t = cs.xml.data.MeetTheTeam.TeamMember;
		var l = t.length;
		for(var i=0; i<l; i++)
		{
			if(cs.stopAll) return;
			var item = t[i];
			var id = 'mttItem'+item.ID+'Hit';
			cs.dom.get(id)._id = item.ID;
			cs.dom.get(id)._index = i;
			cs.dom.get(id)._isSelected = false;
			cs.dom.get(id).onmouseover = function() {cs.mtt.handleItemMouseOver(this._id, this._isSelected, 'Over');}
			cs.dom.get(id).onmouseout = function()  {cs.mtt.handleItemMouseOver(this._id, this._isSelected, 'Out');}
			cs.dom.get(id).onmousedown = function() {cs.mtt.handleItemMouseDown(this._id, this._isSelected);}
		}
	},
	addCtrlHandlers:function()
	{
		if(cs.stopAll) return;
		var l = cs.xml.data.MeetTheTeam.TeamMember.length;
		if(l<7) return;
		cs.dom.get('mttCtrlPrev')._isHidden = cs.dom.get('mttCtrlNext')._isHidden = true;
		cs.mtt.currX = cs.mtt.targX = 0;
		if(l>6)
		{
			cs.mtt.toggleCtrl('mttCtrlPrev', 'mtt_ctrl_prev_Hide', true, false);
			cs.mtt.toggleCtrl('mttCtrlNext', 'mtt_ctrl_next_Out', false, true);
		}
		cs.dom.get('mttCtrlPrev').onmouseover = function() {if(!this._isHidden) cs.img.swap('mttCtrlPrev','mtt_ctrl_prev_Over');};
		cs.dom.get('mttCtrlPrev').onmouseout = function()  {if(!this._isHidden) cs.img.swap('mttCtrlPrev','mtt_ctrl_prev_Out');};
		cs.dom.get('mttCtrlPrev').onmousedown = function() {clearInterval(cs.mtt.ctrlIntervalId); if(!this._isHidden) {cs.mtt.handleCtrlPrevMouseDown(); cs.mtt.ctrlIntervalId = setInterval("cs.mtt.handleCtrlPrevMouseDown()", cs.mtt.ctrlInterval);}};
		cs.dom.get('mttCtrlPrev').onmouseup = function()   {cs.mtt.handleCtrlMouseUp();};
		cs.dom.get('mttCtrlNext').onmouseover = function() {if(!this._isHidden) cs.img.swap('mttCtrlNext','mtt_ctrl_next_Over');};
		cs.dom.get('mttCtrlNext').onmouseout = function()  {if(!this._isHidden) cs.img.swap('mttCtrlNext','mtt_ctrl_next_Out');};
		cs.dom.get('mttCtrlNext').onmousedown = function() {clearInterval(cs.mtt.ctrlIntervalId); if(!this._isHidden) {cs.mtt.handleCtrlNextMouseDown(); cs.mtt.ctrlIntervalId = setInterval("cs.mtt.handleCtrlNextMouseDown()", cs.mtt.ctrlInterval);}};
		cs.dom.get('mttCtrlNext').onmouseup = function()   {cs.mtt.handleCtrlMouseUp();}
	},
	updateCtrl:function()
	{
		if(cs.mtt.contentDiff+cs.mtt.targX <= 0) cs.mtt.toggleCtrl('mttCtrlNext', 'mtt_ctrl_next_Hide', true, false);
		else cs.mtt.toggleCtrl('mttCtrlNext', 'mtt_ctrl_next_Out', false, true);
		if(cs.mtt.targX >= 0) cs.mtt.toggleCtrl('mttCtrlPrev', 'mtt_ctrl_prev_Hide', true, false);
		else cs.mtt.toggleCtrl('mttCtrlPrev', 'mtt_ctrl_prev_Out', false, true);
	},
	toggleCtrl:function(id, img, isHidden, isPointer)
	{
		cs.dom.get(id)._isHidden = isHidden;
		cs.img.swap(id,img);
		cs.util.setStyle(id, 'cursor', ((isPointer)?'pointer':'default'));
	},
	reset:function(id)
	{
		if(cs.assert.notNull(id))
		{
			if(cs.stopAll) return;
			cs.dom.get('mttItem'+id+"Hit")._isSelected = false;
			cs.mtt.itemHide(id);
			cs.util.toggleCss('mttSelected'+id,'itemShow','itemHide');
		}
	},
	setSelected:function(id)
	{
		var n = 'mttItem'+id+"Hit";
		if(cs.assert.notNull(cs.dom.get(n))) 
		{
			cs.mtt.reset(cs.mtt.currentlySelected);
			if (Number(Element.getInlineOpacity('mttItem' + id + 'Over')) < 1 || cs.assert.isNull(cs.mtt.currentlySelected)) 
			{
				cs.mtt.itemShow(id);
			}
			cs.mtt.currentlySelected = id;
			var item = cs.xml.data.MeetTheTeam.TeamMember[cs.dom.get(n)._index];
			cs.dom.get(n)._isSelected = true;
			cs.util.toggleCss('mttSelected'+id,'itemHide','itemShow');
			cs.dom.get('mttName').innerHTML = item.Name;
			cs.dom.get('mttTitle').innerHTML = item.Title;
			cs.dom.get('mttDescription').innerHTML = item.Text;
			cs.mtt.isInView(cs.dom.get(n)._index);
		}
	},
	isInView:function(index)
	{
		var currIndex = index+(cs.mtt.currX/cs.mtt.itemW);
		if(currIndex <= 5 && currIndex >= 0) return;
		if(currIndex > 5)
		{
			cs.mtt.targX = -(cs.mtt.itemW*(currIndex-5))+cs.mtt.currX;
			cs.mtt.tween('mttContent');
			cs.mtt.updateCtrl();
		}
		else if(currIndex < 0)
		{
			cs.mtt.targX = -(cs.mtt.itemW*currIndex)+cs.mtt.currX;
			cs.mtt.tween('mttContent');
			cs.mtt.updateCtrl();
		}
	},
	handleItemMouseOver:function(id, isSelected, state)
	{
		if (!isSelected) 
		{
			if (state == "Over") 
			{
				cs.mtt.itemShow(id);
			}
			else 
			{
				cs.mtt.itemHide(id);
			}
		}
	},
	handleItemMouseDown:function(id, isSelected)
	{
		cs.mtt.handleCtrlMouseUp();
		if(!isSelected) cs.mtt.setSelected(id);
	},
	handleCtrlPrevMouseDown:function()
	{
		if(cs.mtt.targX < 0) {cs.mtt.targX+=cs.mtt.itemW; cs.mtt.tween('mttContent');}
		cs.mtt.updateCtrl();
		if(!cs.dom.get('mttCtrlPrev')._isHidden) cs.img.swap('mttCtrlPrev','mtt_ctrl_prev_Over');
	},
	handleCtrlNextMouseDown:function()
	{
		if(cs.mtt.contentDiff+cs.mtt.targX > 0) {cs.mtt.targX-=cs.mtt.itemW; cs.mtt.tween('mttContent');}
		cs.mtt.updateCtrl();
		if(!cs.dom.get('mttCtrlNext')._isHidden) cs.img.swap('mttCtrlNext','mtt_ctrl_next_Over');
	},
	handleCtrlMouseUp:function()
	{
		clearInterval(cs.mtt.ctrlIntervalId);
	},
	itemShow:function(id)
	{
		var n = 'mttItem'+id+'Over';
		if(cs.assert.notNull(cs.mtt.effectHash[n])) cs.mtt.effectHash[n].cancel();
		cs.mtt.effectHash[n] = new Effect.Appear(n, {duration:cs.mtt.effectDurationShow});
	},
	itemHide:function(id)
	{
		var n = 'mttItem'+id+'Over';
		if (cs.assert.notNull(cs.mtt.effectHash[n])) cs.mtt.effectHash[n].cancel();
		cs.mtt.effectHash[n] = new Effect.Fade(n, {duration:cs.mtt.effectDurationHide});
	},
	tween:function(id)
	{
		clearInterval(cs.mtt.intervalId);
		cs.mtt.intervalId = setInterval("cs.mtt.tweener('"+id+"')", cs.mtt.interval);
	},
	tweener:function(id)
	{
		if(cs.stopAll) {clearInterval(cs.mtt.intervalId); return;}
		if(cs.mtt.currX > cs.mtt.targX) cs.mtt.currX += Math.floor((cs.mtt.targX-cs.mtt.currX)/2);
		else cs.mtt.currX += Math.ceil((cs.mtt.targX-cs.mtt.currX)/2);
		cs.dom.get(id).setStyle({left:cs.mtt.currX+'px'});
		if(Math.abs(cs.mtt.targX - cs.mtt.currX) <= 0) clearInterval(cs.mtt.intervalId);
	}
}
cs.vbp={
	effectHash:Object(),
	effectDuration:0.3,
	dispose:function(){
		cs.vbp.effectHash = new Object();
	},
	reload:function(){},
	addHandlers:function()
	{
		var items = cs.xml.data.ViewByPerspective.Perspective;
		var l = items.length;
		for(i=0; i<l; i++)
		{
			if(cs.stopAll) return;
			var item = items[i];
			cs.dom.get('menu'+item.Type)._id = item.Type;
			cs.dom.get('menu'+item.Type)._isSelected = false;
			cs.dom.get('menu'+item.Type)._atlasid = item.AtlasId;
			cs.dom.get('menu'+item.Type).onmousedown = function(){cs.tracking.track(this._atlasid);cs.setVideo(this._id);playVideo(this._id);};
			cs.dom.get('menu'+item.Type).onmouseover = function(){cs.vbp.handleMouseOver(this._id, this._isSelected);};
			cs.dom.get('menu'+item.Type).onmouseout = function() {cs.vbp.handleMouseOut(this._id, this._isSelected);};
		}
	},
	reset:function()
	{
		var items = cs.xml.data.ViewByPerspective.Perspective;
		var l = items.length;
		for(var i=0; i<l; i++)
		{
			if(cs.stopAll) return;
			var n = items[i].Type;
			cs.util.toggleCss('label'+n, 'itemLabelSelected', 'itemLabelShow');
			cs.dom.get('menu'+n)._isSelected = false;
			cs.img.swap('icon'+n, n+'Out');
		}
	},
	setSelected:function(videoType)
	{
		if(cs.assert.notNull(cs.dom.get('menu'+videoType)))
		{
			cs.dom.get('menu'+videoType)._isSelected = true;
			cs.img.swap('icon'+videoType, videoType+'Over');
			cs.util.toggleCss('label'+videoType, 'itemLabelShow', 'itemLabelSelected');
		}
	},
	handleMouseOver:function(id, isSelected)
	{
		cs.vbp.itemShow(id);
		if (!isSelected) 
		{
			cs.img.swap('icon'+id, id+'Over');
			cs.util.toggleCss('label'+id, 'itemLabelShow', 'itemLabelSelected');
		}
	},
	handleMouseOut:function(id, isSelected)
	{
		cs.vbp.itemHide(id);
		if (!isSelected) 
		{
			cs.img.swap('icon'+id, id+'Out');
			cs.util.toggleCss('label'+id, 'itemLabelSelected', 'itemLabelShow');
		}
	},
	itemShow:function(id)
	{
		var n = 'tooltip'+id;
		if (cs.assert.notNull(cs.vbp.effectHash[n])) cs.vbp.effectHash[n].cancel();
		cs.vbp.effectHash[n] = new Effect.Appear(n, {duration:(cs.util.browserIsIE)?0:cs.vbp.effectDuration});
	},
	itemHide:function(id)
	{
		var n = 'tooltip'+id;
		if (cs.assert.notNull(cs.vbp.effectHash[n])) cs.vbp.effectHash[n].cancel();
		cs.vbp.effectHash[n] = new Effect.Fade(n, {duration:(cs.util.browserIsIE)?0:cs.vbp.effectDuration});
	}
}
cs.tracking={
	track:function(trackid)
	{
		try{
			trackClick(trackid);
		}catch(e){};
	}
}
cs.xml={
	data:{},httpRequest:false,
	dispose:function()
	{
		cs.xml.data = null;
		cs.xml.httpRequest = null;
	},
	reload:function(xml)
	{
		cs.xml.data = xml.data;
	},
	load:function(url, params)
	{
		if(window.ActiveXObject){try{cs.xml.httpRequest = new ActiveXObject("Msxml2.XMLHTTP");} catch(e){try{cs.xml.httpRequest = new ActiveXObject("Microsoft.XMLHTTP");} catch(e){}}}
		else if(window.XMLHttpRequest){cs.xml.httpRequest = new XMLHttpRequest(); if(cs.xml.httpRequest.overrideMimeType) cs.xml.httpRequest.overrideMimeType('text/xml');}
		if(!cs.xml.httpRequest){alert('Cannot create XMLHTTP instance'); return false;}
		cs.xml.httpRequest.onreadystatechange = cs.xml.handleOnReadyStateChange;
		cs.xml.httpRequest.open('GET', url+((params==undefined)?"":params), true);
		cs.xml.httpRequest.send(null);
	},
	handleOnReadyStateChange:function()
	{
		if(cs.xml.httpRequest.readyState == 4)
		{
			if(cs.xml.httpRequest.status == 200)
			{
				cs.xml.parse(cs.xml.httpRequest.responseXML);
			}
		}
		else{
			/*fail quietly*/
		}
	},
	parse:function(inXML)
	{
		// create container objects
		var region = cs.img.region;
		var global = cs.img.global;
		var data = new Object();
		data.Synopsis = new Object();
		data.Synopsis.BitmapImage = new Object();
		data.MeetTheTeam = new Object();
		data.MeetTheTeam.TeamMember = new Array();
		data.RelatedLinks = new Object();
		data.RelatedLinks.LinkItem = new Array();
		data.ViewByPerspective = new Object();
		data.ViewByPerspective.Perspective = new Array();
		
		
		// get first nodes
		var xmlObj = this.gn(inXML, 'CaseStudyContent', 0);
		var tabs = this.gn(xmlObj, 'Tabs', 0);
		
		
		// get Synopsis info
		var item = this.gn(tabs, 'Synopsis', 0);
		data.Synopsis.AtlasId = this.ga(tabs, 'Synopsis', 0, 'AtlasId');
		data.Synopsis.SectionLabel = this.gv(item, 'SectionLabel', 0);
		data.Synopsis.BitmapImage.Logo = this.ga(item, 'BitmapImage', 0, 'Logo');
		cs.img.addPreloadItem("SynopsisLogo", region + data.Synopsis.BitmapImage.Logo);
		data.Synopsis.Text = this.gv(item, 'Text', 0);
		
		
		// get MeetTheTeam info
		var MeetTheTeam = this.gn(tabs, 'MeetTheTeam', 0);
		data.MeetTheTeam.AtlasId = this.ga(tabs, 'MeetTheTeam', 0, 'AtlasId');
		data.MeetTheTeam.SectionLabel = this.gv(MeetTheTeam, 'SectionLabel', 0);
		var TeamMember = this.gn(MeetTheTeam, 'TeamMember');
		var len = TeamMember.length;
		var i=0;
		for(i=0; i<len; i++)
		{
			var tm = TeamMember[i];
			var obj = new Object();
			obj.ID = this.ga(MeetTheTeam, 'TeamMember', i, 'ID').split(/\s/).join('');
			obj.BitmapImage = {Over:this.ga(tm, 'BitmapImage', 0, 'Over') , Out:this.ga(tm, 'BitmapImage', 0, 'Out')};
			obj.Name = this.gv(tm, 'Name', 0);
			obj.Title = this.gv(tm, 'Title', 0);
			obj.Text = this.gv(tm, 'Text', 0);
			cs.img.addPreloadItem(obj.ID+'Over', region+obj.BitmapImage.Over);
			cs.img.addPreloadItem(obj.ID+'Out', region+obj.BitmapImage.Out);
			data.MeetTheTeam.TeamMember[i] = obj;
		}
		
		
		// get RelatedLinks info
		var RelatedLinks = this.gn(tabs, 'RelatedLinks', 0);
		data.RelatedLinks.AtlasId = this.ga(tabs, 'RelatedLinks', 0, 'AtlasId');
		data.RelatedLinks.SectionLabel = this.gv(RelatedLinks, 'SectionLabel', 0);
		var LinkItem = this.gn(RelatedLinks, 'LinkItem');
		len = LinkItem.length;
		for(i=0;i<len;i++)
		{
			var li = LinkItem[i];
			var obj = new Object();
			obj.AtlasId = this.ga(RelatedLinks, 'LinkItem', i, 'AtlasId');
			obj.Label = this.gv(li, 'Label', 0);
			obj.URLPath = this.gv(li, 'URLPath', 0);
			data.RelatedLinks.LinkItem[i] = obj;
		}
		
		// get ViewByPerspective info
		var ViewByPerspective = this.gn(xmlObj, 'ViewByPerspective', 0);
		data.ViewByPerspective.SectionLabel = this.gv(ViewByPerspective, 'SectionLabel', 0);
		var Perspective = this.gn(ViewByPerspective, 'Perspective');
		len = Perspective.length;
		for(i=0; i<len; i++)
		{
			var p = Perspective[i];
			var obj = new Object();
			obj.AtlasId = this.ga(ViewByPerspective, 'Perspective', i, 'AtlasId');
			obj.Type = this.ga(ViewByPerspective, 'Perspective', i, 'Type').split(/\s/).join('');
			obj.BitmapImage = {Over:this.ga(p, 'BitmapImage', 0, 'Over') , Out:this.ga(p, 'BitmapImage', 0, 'Out')};
			obj.Name = this.gv(p, 'Name', 0);
			obj.Text = this.gv(p, 'Text', 0);
			cs.img.addPreloadItem(obj.Type+'Over', region+obj.BitmapImage.Over);
			cs.img.addPreloadItem(obj.Type+'Out', region+obj.BitmapImage.Out);
			data.ViewByPerspective.Perspective[i] = obj;
		}
		
		
		cs.xml.data = data;
		cs.cache.set(cs.region+cs.id+'xml', {data:cs.xml.data});
		cs.img.preloadStart();
	},
	gn:function(node, name, index)
	{// return node
		if(isNaN(index)) return node.getElementsByTagName(name);
		else return node.getElementsByTagName(name)[index];
	},
	ga:function(node, name, index, attribute)
	{// return node attribute
		return node.getElementsByTagName(name)[index].getAttribute(attribute);
	},
	gv:function(node, name, index)
	{// return node value
		return node.getElementsByTagName(name)[index].firstChild.nodeValue;
	}
}
cs.assert={
	notNull:function(item)
	{
		if(typeof item=='undefined') return false;
		if(item=='') return false;
		return !(!item);
	},
	isNull:function(item)
	{
		if(typeof item=='undefined') return true;
		if(item=='') return true;
		return (!item);
	}
}
cs.util={
	browserIsIE:Boolean(),
	dispose:function(){},
	reload:function(){},
	setBrowser:function()
	{
		cs.util.browserIsIE = (navigator.appVersion.indexOf("Win") && navigator.appName == "Microsoft Internet Explorer") ? true:false;
	},
	setStyle:function(id, prop, val, suffix)
	{
		cs.dom.get(id).style[prop] = val+((cs.assert.notNull(suffix))?suffix:'');
	},
	addCss:function(element, className)
	{
		cs.dom.get(element).addClassName(className);
	},
	removeCss:function(element, className)
	{
		cs.dom.get(element).removeClassName(className);
	},
	toggleCss:function(id, remove, add)
	{
		cs.util.removeCss(id, remove);
		cs.util.removeCss(id, add);
		cs.util.addCss(id, add);
	},
	notNull:function(item)
	{
		if(typeof item=='undefined') return false;
		if(item=='') return false;
		if(item==null) return false;
		return true;
	},
	disableSelection:function(id)
	{
		if (typeof cs.dom.get(id).onselectstart != "undefined") cs.dom.get(id).onselectstart = function(){return false;};
		else if (typeof cs.dom.get(id).style.MozUserSelect != "undefined") cs.dom.get(id).style.MozUserSelect = "none";
		else cs.dom.get(id).onmousedown = function(){return false;};
		cs.dom.get(id).style.cursor = "default";
	},
	buildTrace:function()
	{
		var w = 200;
		try{document.getElementsByTagName("body")[0].innerHTML += '<div id="helper" style="font-family:Arial; font-size:11px; position:absolute; background-color:#CCCCCC; top:0px; left:0px; width:'+w+'px; z-index:10000; color:#000000; border-width:1px; border-style:solid; border-color:#000000; padding:4px; filter:alpha(opacity=80); -moz-opacity:.80; opacity:.80;"></div>';}catch(e){};
	},
	trace:function(s)
	{
		cs.dom.get('helper').innerHTML += "<p style='margin:0;padding:0;'>" + s + "</p>";
	},
	clear:function()
	{
		cs.dom.get('helper').innerHTML = "";
	}
}
cs.dom={
	hash:Array(),
	dispose:function()
	{
		cs.dom.hash = new Array();
	},
	reload:function(dom){},
	get:function(id)
	{
		if (cs.assert.isNull(cs.dom.hash[id])) cs.dom.hash[id] = $(id);
		return cs.dom.hash[id];
	}
}
cs.img={
	list:Array(),hash:Array(),preloadList:Array(),region:String(),global:String(),preloadCount:Number(),
	dispose:function()
	{
		cs.img.list = new Array();
		cs.img.hash = new Array();
		cs.img.region = cs.img.global = '';
		cs.img.preloadList = new Array();
		cs.img.preloadCount = 0;
	},
	reload:function(img)
	{
		cs.img.list = img.list;
		cs.img.hash = img.hash;
		cs.img.region = img.region;
		cs.img.global = img.global;
	},
	get:function(id)
	{
		return cs.img.list[cs.img.hash[id]];
	},
	swap:function(item, img)
	{
		cs.dom.get(item).src = cs.img.get(img).src;
	},
	addPreloadItem:function(id, src)
	{
		cs.img.list.push({id:id, src:src});
		cs.img.hash[id] = cs.img.list.length - 1;
	},
	preloadStart:function()
	{
		var list = cs.img.list;
		var l = list.length;
		cs.img.preloadCount = l;
		cs.cache.set(cs.region+cs.id+'img',{list:cs.img.list, hash:cs.img.hash, region:cs.img.region, global:cs.img.global});
		for(var i=0; i<l; i++)
		{
			var item = list[i];
			var id = item.id;
			cs.img.preloadList[id] = new Image();
			cs.img.preloadList[id].onLoad = cs.img.preloadComplete(id);
			cs.img.preloadList[id].src = item.src;
		}
	},
	preloadComplete:function(id)
	{
		cs.img.preloadCount -= 1;
		if(cs.img.preloadCount > 0) return;
		cs.view.create();
	}
}
cs.cache={
	hash:Array(),
	get:function(id)
	{
		return cs.cache.hash[id];
	},
	set:function(id,d)
	{
		cs.cache.hash[id] = d;
	}
}

cs.init();

function cs_setCaseStudy(lang, local, id) {
//    alert('cs_setCaseStudy - \r\n lang=[' + lang + ']\r\n local=[' + local + ']\r\n id=[' + id + ']\r\n');
    cs.setCaseStudy(lang, local, id);
}
function cs_setVideo(videoType) {
//    alert('cs_setVideo - \r\n videoType=[' + videoType + ']\r\n');
    cs.setVideo(videoType);
}
function cs_setTab(tabID, tabSubID) {
//    alert('cs_setTab - \r\n tabID=[' + tabID + ']\r\n tabSubID=[' + tabSubID + ']\r\n');
    cs.setTab(tabID, tabSubID);
}
function cs_trace(s) {if(cs.assert.isNull(cs.dom.get('helper'))) cs.util.buildTrace(); cs.util.trace(s);}
function cs_clear() {if(cs.assert.notNull(cs.dom.get('helper'))) cs.util.clear();}


function playVideo(videoTypeID) {
    var slPlugin = document.getElementById("SL_CaseStudiesPlayer")
    slPlugin.content.SL_App.Script_PlayVideo(videoTypeID);
}

function playCaseStudy(caseStudyID, videoTypeID) {
    var slPlugin = document.getElementById("SL_CaseStudiesPlayer")
    slPlugin.content.SL_App.Script_PlayCaseStudy(caseStudyID, videoTypeID);
}

function popUpCaseStudiesPlayer(CaseStudy, VideoType, Seconds) {
    var url = '../Controls/SL_CaseStudiesPlayer_PopUp.aspx?CaseStudyID=' + CaseStudy + '&VideoType=' + VideoType +'&Seconds=' + Seconds + '&IsPopUp=true';
    day = new Date();
    id = day.getTime();
    eval("page" + id + " = window.open(url, '" + id + "', 'toolbar=0,scrollbars=0,location=0,statusbar=0,menubar=0,resizable=0,width=576,height=600');");
}
//Track Watch Trailer
function tagWatchTrailer(csID) {

    var watchTrailerArray = new Array();
    watchTrailerArray['1'] = 'FY09_PRBv2_Proof_Hero_UTC_Trailer_P_99_Final"'; //UTC
    watchTrailerArray['2'] = 'FY09_PRBv2_Proof_Hero_Nortel_Trailer_P_123_Final'; //Nortel
    watchTrailerArray['3'] = 'FY09_PRBv2_Proof_Hero_Energizer_Trailer_P_131_Final'; //Enegizer
    watchTrailerArray['4'] = 'FY09_PRBv2_Proof_Hero_BP_Trailer_P_115_Final'; //BP
    watchTrailerArray['5'] = 'FY09_PRBv2_Proof_Hero_Eastman_Trailer_P_107_Final'; //Eastman

    //alert(watchTrailerArray[csID]);
    trackClick(watchTrailerArray[csID]);
}


//Track Watch Full Video
function tagWatchFullVideo(csID) {

    var watchFullVideoArray = new Array();
    watchFullVideoArray['1'] = 'FY09_PRBv2_Proof_Hero_UTC_BigPicture_P_100_Final"'; //UTC
    watchFullVideoArray['2'] = 'FY09_PRBv2_Proof_Hero_Nortel_BigPicture_P_124_Final'; //Nortel
    watchFullVideoArray['3'] = 'FY09_PRBv2_Proof_Hero_Energizer_BigPicture_P_132_Fina'; //Enegizer
    watchFullVideoArray['4'] = 'FY09_PRBv2_Proof_Hero_BP_BigPicture_P_116_Final'; //BP
    watchFullVideoArray['5'] = 'FY09_PRBv2_Proof_Hero_Eastman_BigPicture_P_108_Final'; //Eastman

    //alert(watchFullVideoArray[csID]);
    trackClick(watchFullVideoArray[csID]);
}


//Track Email Video
function tagEmailVideo(csID, vtID) {

    var emailVideoArray = new Array();
    //UTC
    emailVideoArray['1_0'] = 'FY09_PRBv2_Proof_Hero_UTC_Trailer_Email_P_141_Final';
    emailVideoArray['1_2'] = 'FY09_PRBv2_Proof_Hero_UTC_BigPicture_Email_P_146_Final';
    emailVideoArray['1_3'] = 'FY09_PRBv2_Proof_Hero_UTC_BDM_Email_P_151_Final';
    emailVideoArray['1_4'] = 'FY09_PRBv2_Proof_Hero_UTC_TDM_Email_P_156_Final';
    //Notel
    emailVideoArray['2_0'] = 'FY09_PRBv2_Proof_Hero_Nortel_Trailer_Email_P_142_Final';
    emailVideoArray['2_1'] = 'FY09_PRBv2_Proof_Hero_Nortel_BigPicture_Email_P_147_Final';
    emailVideoArray['2_2'] = 'FY09_PRBv2_Proof_Hero_Nortel_BDM_Email_P_152_Final';
    emailVideoArray['2_3'] = 'FY09_PRBv2_Proof_Hero_Nortel_TDM_Email_P_157_Final';
    //Enegizer
    emailVideoArray['3_0'] = 'FY09_PRBv2_Proof_Hero_Energizer_Trailer_Email_P_143_Final';
    emailVideoArray['3_1'] = 'FY09_PRBv2_Proof_Hero_Energizer_BigPicture_Email_P_148_Final';
    emailVideoArray['3_2'] = 'FY09_PRBv2_Proof_Hero_Energizer_BDM_Email_P_153_Final';
    emailVideoArray['3_3'] = 'FY09_PRBv2_Proof_Hero_Energizer_TDM_Email_P_158_Final';
    //BP	
    emailVideoArray['4_0'] = 'FY09_PRBv2_Proof_Hero_BP_Trailer_Email_P_139_Final';
    emailVideoArray['4_1'] = 'FY09_PRBv2_Proof_Hero_BP_BigPicture_Email_P_144_Final';
    emailVideoArray['4_2'] = 'FY09_PRBv2_Proof_Hero_BP_BigPicture_Email_P_144_Final';
    emailVideoArray['4_3'] = 'FY09_PRBv2_Proof_Hero_BP_TDM_Email_P_154_Final';
    //Eastman
    emailVideoArray['5_0'] = 'FY09_PRBv2_Proof_Hero_Eastman_Trailer_Email_P_140_Final';
    emailVideoArray['5_1'] = 'FY09_PRBv2_Proof_Hero_Eastman_BigPicture_Email_P_145_Final';
    emailVideoArray['5_2'] = 'FY09_PRBv2_Proof_Hero_Eastman_BDM_Email_P_150_Final';
    emailVideoArray['5_3'] = 'FY09_PRBv2_Proof_Hero_Eastman_TDM_Email_P_155_Final';

    var key = csID + '_' + vtID;

    //alert(emailVideoArray[key]);
    trackClick(emailVideoArray[key]);

}


//Track Download Video
function tagDownloadVideo(csID, vtID) {
    var dlVideoArray = new Array();
    //UTC
    dlVideoArray['1_0'] = 'FY09_PRBv2_Proof_Hero_UTC_Trailer_Dwnld_P_161_Final';
    dlVideoArray['1_2'] = 'FY09_PRBv2_Proof_Hero_UTC_BigPicture_Dwnld_P_166_Final';
    dlVideoArray['1_3'] = 'FY09_PRBv2_Proof_Hero_UTC_BDM_Dwnld_P_171_Final';
    dlVideoArray['1_4'] = 'FY09_PRBv2_Proof_Hero_UTC_TDM_Dwnld_P_176_Final';
    //Notel
    dlVideoArray['2_0'] = 'FY09_PRBv2_Proof_Hero_Nortel_Trailer_Email_P_142_Final';
    dlVideoArray['2_1'] = 'FY09_PRBv2_Proof_Hero_Nortel_BigPicture_Dwnld_P_167_Finall';
    dlVideoArray['2_2'] = 'FY09_PRBv2_Proof_Hero_Nortel_BDM_Dwnld_P_172_Final';
    dlVideoArray['2_3'] = 'FY09_PRBv2_Proof_Hero_Nortel_TDM_Dwnld_P_177_Final';
    //Enegizer
    dlVideoArray['3_0'] = 'FY09_PRBv2_Proof_Hero_Energizer_Trailer_Dwnld_P_163_Final';
    dlVideoArray['3_1'] = 'FY09_PRBv2_Proof_Hero_Energizer_BigPicture_Dwnld_P_168_Final';
    dlVideoArray['3_2'] = 'FY09_PRBv2_Proof_Hero_Energizer_BDM_Dwnld_P_173_Final';
    dlVideoArray['3_3'] = 'FY09_PRBv2_Proof_Hero_Energizer_TDM_Dwnld_P_178_Final';
    //BP	
    dlVideoArray['4_0'] = 'FY09_PRBv2_Proof_Hero_BP_Trailer_Dwnld_P_159_Final';
    dlVideoArray['4_1'] = 'FY09_PRBv2_Proof_Hero_BP_BigPicture_Dwnld_P_164_Final';
    dlVideoArray['4_2'] = 'FY09_PRBv2_Proof_Hero_BP_BDM_Dwnld_P_169_Final';
    dlVideoArray['4_3'] = 'FY09_PRBv2_Proof_Hero_BP_TDM_Dwnld_P_174_Final';
    //Eastman
    dlVideoArray['5_0'] = 'FY09_PRBv2_Proof_Hero_Eastman_Trailer_Dwnld_P_160_Final';
    dlVideoArray['5_1'] = 'FY09_PRBv2_Proof_Hero_Eastman_BigPicture_Dwnld_P_165_Final';
    dlVideoArray['5_2'] = 'FY09_PRBv2_Proof_Hero_Eastman_BDM_Dwnld_P_170_Final';
    dlVideoArray['5_3'] = 'FY09_PRBv2_Proof_Hero_Eastman_TDM_Dwnld_P_175_Final';


    var key = csID + '_' + vtID;

    //alert(dlVideoArray[key]);
    trackClick(dlVideoArray[key]);
}


//Track Carousel - **NOTE: Tags be provided at later time**
function tagCarouselItemFullVideo(csID) 
{ 
}

if(typeof(Sys)!=='undefined')Sys.Application.notifyScriptLoaded();