if (top.location != location) {
    top.location.href = document.location.href ;
}
var tForm = "";
var tField = "";
function CheckAll(name) {
 var Inputs = document.getElementsByTagName("INPUT");
 for(var i = 0; i < Inputs.length; i++) {
  var Input = Inputs[i];
  if(Input.type == "checkbox" && Input.name == name + "[]") {
   Input.checked= true;
  }
 }
}
function UnCheckAll(name) {
 var Inputs = document.getElementsByTagName("INPUT");
 for(var i = 0; i < Inputs.length; i++) {
  var Input = Inputs[i];
  if(Input.type == "checkbox" && Input.name == name + "[]") {
   Input.checked= false;
  }
 }
}
function CheckDelete(oForm) {
 var oStatus = oForm.elements['status'];
 if(oStatus.value == "deleted") {
  return confirm("Tényleg törölni akarod a kijelölt elemeket?");
 } else {
  return true;
 }
}
function CheckUniqueField(oField) {
 tField = oField;
 var id = tField.form.elements['id'] ? tField.form.elements['id'].value : 0;
 var table = tField.form.elements['table'] ? tField.form.elements['table'].value : 0;
 var field = tField.name;
 var value = tField.value;
 if(oField.getAttribute("typecheck") == 1) {
  var Parameters = { "do" : "check_unique_email_for_registration",
           "value" : value,
           "id" : id,
           "table" : table,
           "field" : field,
           "type" : tField.form.elements['type'].value
          };
 } else {
  var Parameters = { "do" : "check_unique_field",
           "value" : value,
           "id" : id,
           "table" : table,
           "field" : field
          };
 }
 var CheckUniqueField = new Ajax.Request("ajax.php", { method: "post", parameters: $H(Parameters).toQueryString(), onComplete: ParseUniqueField });
}
function ParseUniqueField(response) {
 var response_text = response.responseText;
 if(response_text == "error") {
  tField.setAttribute("avaible", "no");
 } else {
  tField.setAttribute("avaible", "yes");
 }
 CheckForm(tField.form);
}
function GetRadioValue(obj) {
 for(var i = 0; i < obj.length; i++) {
  if(obj[i].checked == true) {
   return obj[i].value;
  }
 }
 return false;
}
function switchProductData(target) {
 var Divs = new Array("product", "artist", "studio");
 for(var i in Divs) {
  var Div = document.getElementById(Divs[i]);
  var Button = document.getElementById(Divs[i] + "_button");
  if(Div) {
   Div.style.display = "none";
   Button.className = "";
  }
 }
 if(document.getElementById(target)) {
  document.getElementById(target).style.display = "block";
 }
 if(document.getElementById(target + "_button")) {
  document.getElementById(target + "_button").className = "active";
 }
}
function switchUserData(target) {
 var Divs = new Array("view_history_tab", "mycart_tab", "favorites_tab");
 for(var i in Divs) {
  var Div = document.getElementById(Divs[i]);
  var Button = document.getElementById(Divs[i] + "_button");
  if(Div) {
   Div.style.display = "none";
   Button.className = "";
  }
 }
 if(document.getElementById(target)) {
  document.getElementById(target).style.display = "block";
 }
 if(document.getElementById(target + "_button")) {
  document.getElementById(target + "_button").className = "active";
 }
}
function switchUserData2(target) {
 var Divs = new Array("wish_list_tab", "mylist_tab", "history_tab");
 for(var i in Divs) {
  var Div = document.getElementById(Divs[i]);
  var Button = document.getElementById(Divs[i] + "_button");
  if(Div) {
   Div.style.display = "none";
   Button.className = "";
  }
 }
 if(document.getElementById(target)) {
  document.getElementById(target).style.display = "block";
 }
 if(document.getElementById(target + "_button")) {
  document.getElementById(target + "_button").className = "active";
 }
}
function showEventCalendar(year, month) {
 var Parameters = { "do" : "show_calendar",
          "year" : year,
          "month" : month
         };
 var EventCalendar = new Ajax.Updater("event_calendar", "ajax.php", { method: "post", parameters: $H(Parameters).toQueryString() });
}
function findUs(oObj) {
 if(oObj.value == "other") {
  oObj.style.width = "80px";
  oObj.form.elements['other_find'].style.display = "inline";
 } else {
  oObj.form.elements['other_find'].style.display = "none";
  oObj.style.width = "";
 }
}//------------------------------------------------------------------------------------------------------------------------------------------------------
function DialogBox(direction) {
 if(direction == "on") {
  if(document.getElementById("dialog")) {
   DestroyDialogBox();
  }
  var Dialog = document.createElement("DIV");
  var DialogBoxOuter = document.createElement("DIV");
  var DialogBox = document.createElement("DIV");
  Dialog.id = "dialog";
  DialogBoxOuter.id = "dialog_box_outer";
  DialogBox.id = "dialog_box";
  if(document.all) {
   Dialog.style.top = document.documentElement.scrollTop;
   Dialog.style.left = document.documentElement.scrollLeft;
  }
  var Selects = document.getElementsByTagName("SELECT");
  for(var i = 0; i < Selects.length; i++) {
   var Select = Selects[i];
   Select.style.visibility = "hidden";
  }
  document.body.appendChild(Dialog);
  document.documentElement.style.overflowY = "hidden";
  document.documentElement.style.overflowX = "hidden";
  Dialog.appendChild(DialogBoxOuter);
  DialogBoxOuter.appendChild(DialogBox);
  DialogBox.innerHTML = "<br><br><span class='loading'><img src='images/others/loading.gif' style='vertical-align:middle'> Loading</span>";
  ArrangeDialogBox();
 } else {
  DestroyDialogBox();
 }
}
function DestroyDialogBox() {
 var Dialog = document.getElementById("dialog");
 document.body.removeChild(Dialog);
 document.documentElement.style.overflowY = "scroll";
 document.documentElement.style.overflowX = "auto";
 var Selects = document.getElementsByTagName("SELECT");
 for(var i = 0; i < Selects.length; i++) {
  var Select = Selects[i];
  Select.style.visibility = "";
 }
}
function ArrangeDialogBox() {
 var DialogBoxOuter = document.getElementById("dialog_box_outer");
 DialogBoxOuter.style.margin = -(DialogBoxOuter.offsetHeight / 2) + "px 0px 0px " + -(DialogBoxOuter.offsetWidth / 2) + "px";
}
var Prototype = {
  Version: '1.5.0',
  BrowserFeatures: {
    XPath: !!document.evaluate
  },
  ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',
  emptyFunction: function() {},
  K: function(x) { return x }
}
var Class = {
  create: function() {
    return function() {
      this.initialize.apply(this, arguments);
    }
  }
}
var Abstract = new Object();
Object.extend = function(destination, source) {
  for (var property in source) {
    destination[property] = source[property];
  }
  return destination;
}
Object.extend(Object, {
  inspect: function(object) {
    try {
      if (object === undefined) return 'undefined';
      if (object === null) return 'null';
      return object.inspect ? object.inspect() : object.toString();
    } catch (e) {
      if (e instanceof RangeError) return '...';
      throw e;
    }
  },
  keys: function(object) {
    var keys = [];
    for (var property in object)
      keys.push(property);
    return keys;
  },
  values: function(object) {
    var values = [];
    for (var property in object)
      values.push(object[property]);
    return values;
  },
  clone: function(object) {
    return Object.extend({}, object);
  }
});
Function.prototype.bind = function() {
  var __method = this, args = $A(arguments), object = args.shift();
  return function() {
    return __method.apply(object, args.concat($A(arguments)));
  }
}
Function.prototype.bindAsEventListener = function(object) {
  var __method = this, args = $A(arguments), object = args.shift();
  return function(event) {
    return __method.apply(object, [( event || window.event)].concat(args).concat($A(arguments)));
  }
}
Object.extend(Number.prototype, {
  toColorPart: function() {
    var digits = this.toString(16);
    if (this < 16) return '0' + digits;
    return digits;
  },
  succ: function() {
    return this + 1;
  },
  times: function(iterator) {
    $R(0, this, true).each(iterator);
    return this;
  }
});
var Try = {
  these: function() {
    var returnValue;
    for (var i = 0, length = arguments.length; i < length; i++) {
      var lambda = arguments[i];
      try {
        returnValue = lambda();
        break;
      } catch (e) {}
    }
    return returnValue;
  }
}
var PeriodicalExecuter = Class.create();
PeriodicalExecuter.prototype = {
  initialize: function(callback, frequency) {
    this.callback = callback;
    this.frequency = frequency;
    this.currentlyExecuting = false;
    this.registerCallback();
  },
  registerCallback: function() {
    this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
  },
  stop: function() {
    if (!this.timer) return;
    clearInterval(this.timer);
    this.timer = null;
  },
  onTimerEvent: function() {
    if (!this.currentlyExecuting) {
      try {
        this.currentlyExecuting = true;
        this.callback(this);
      } finally {
        this.currentlyExecuting = false;
      }
    }
  }
}
String.interpret = function(value){
  return value == null ? '' : String(value);
}
Object.extend(String.prototype, {
  gsub: function(pattern, replacement) {
    var result = '', source = this, match;
    replacement = arguments.callee.prepareReplacement(replacement);
    while (source.length > 0) {
      if (match = source.match(pattern)) {
        result += source.slice(0, match.index);
        result += String.interpret(replacement(match));
        source  = source.slice(match.index + match[0].length);
      } else {
        result += source, source = '';
      }
    }
    return result;
  },
  sub: function(pattern, replacement, count) {
    replacement = this.gsub.prepareReplacement(replacement);
    count = count === undefined ? 1 : count;
    return this.gsub(pattern, function(match) {
      if (--count < 0) return match[0];
      return replacement(match);
    });
  },
  scan: function(pattern, iterator) {
    this.gsub(pattern, iterator);
    return this;
  },
  truncate: function(length, truncation) {
    length = length || 30;
    truncation = truncation === undefined ? '...' : truncation;
    return this.length > length ?
      this.slice(0, length - truncation.length) + truncation : this;
  },
  strip: function() {
    return this.replace(/^\s+/, '').replace(/\s+$/, '');
  },
  stripTags: function() {
    return this.replace(/<\/?[^>]+>/gi, '');
  },
  stripScripts: function() {
    return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
  },
  extractScripts: function() {
    var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
    var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
    return (this.match(matchAll) || []).map(function(scriptTag) {
      return (scriptTag.match(matchOne) || ['', ''])[1];
    });
  },
  evalScripts: function() {
    return this.extractScripts().map(function(script) { return eval(script) });
  },
  escapeHTML: function() {
    var div = document.createElement('div');
    var text = document.createTextNode(this);
    div.appendChild(text);
    return div.innerHTML;
  },
  unescapeHTML: function() {
    var div = document.createElement('div');
    div.innerHTML = this.stripTags();
    return div.childNodes[0] ? (div.childNodes.length > 1 ?
      $A(div.childNodes).inject('',function(memo,node){ return memo+node.nodeValue }) :
      div.childNodes[0].nodeValue) : '';
  },
  toQueryParams: function(separator) {
    var match = this.strip().match(/([^?#]*)(#.*)?$/);
    if (!match) return {};
    return match[1].split(separator || '&').inject({}, function(hash, pair) {
      if ((pair = pair.split('='))[0]) {
        var name = decodeURIComponent(pair[0]);
        var value = pair[1] ? decodeURIComponent(pair[1]) : undefined;
        if (hash[name] !== undefined) {
          if (hash[name].constructor != Array)
            hash[name] = [hash[name]];
          if (value) hash[name].push(value);
        }
        else hash[name] = value;
      }
      return hash;
    });
  },
  toArray: function() {
    return this.split('');
  },
  succ: function() {
    return this.slice(0, this.length - 1) +
      String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
  },
  camelize: function() {
    var parts = this.split('-'), len = parts.length;
    if (len == 1) return parts[0];
    var camelized = this.charAt(0) == '-'
      ? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)
      : parts[0];
    for (var i = 1; i < len; i++)
      camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);
    return camelized;
  },
  capitalize: function(){
    return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
  },
  underscore: function() {
    return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();
  },
  dasherize: function() {
    return this.gsub(/_/,'-');
  },
  inspect: function(useDoubleQuotes) {
    var escapedString = this.replace(/\\/g, '\\\\');
    if (useDoubleQuotes)
      return '"' + escapedString.replace(/"/g, '\\"') + '"';
    else
      return "'" + escapedString.replace(/'/g, '\\\'') + "'";
  }
});
String.prototype.gsub.prepareReplacement = function(replacement) {
  if (typeof replacement == 'function') return replacement;
  var template = new Template(replacement);
  return function(match) { return template.evaluate(match) };
}
String.prototype.parseQuery = String.prototype.toQueryParams;
var Template = Class.create();
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
Template.prototype = {
  initialize: function(template, pattern) {
    this.template = template.toString();
    this.pattern  = pattern || Template.Pattern;
  },
  evaluate: function(object) {
    return this.template.gsub(this.pattern, function(match) {
      var before = match[1];
      if (before == '\\') return match[2];
      return before + String.interpret(object[match[3]]);
    });
  }
}
var $break    = new Object();
var $continue = new Object();
var Enumerable = {
  each: function(iterator) {
    var index = 0;
    try {
      this._each(function(value) {
        try {
          iterator(value, index++);
        } catch (e) {
          if (e != $continue) throw e;
        }
      });
    } catch (e) {
      if (e != $break) throw e;
    }
    return this;
  },
  eachSlice: function(number, iterator) {
    var index = -number, slices = [], array = this.toArray();
    while ((index += number) < array.length)
      slices.push(array.slice(index, index+number));
    return slices.map(iterator);
  },
  all: function(iterator) {
    var result = true;
    this.each(function(value, index) {
      result = result && !!(iterator || Prototype.K)(value, index);
      if (!result) throw $break;
    });
    return result;
  },
  any: function(iterator) {
    var result = false;
    this.each(function(value, index) {
      if (result = !!(iterator || Prototype.K)(value, index))
        throw $break;
    });
    return result;
  },
  collect: function(iterator) {
    var results = [];
    this.each(function(value, index) {
      results.push((iterator || Prototype.K)(value, index));
    });
    return results;
  },
  detect: function(iterator) {
    var result;
    this.each(function(value, index) {
      if (iterator(value, index)) {
        result = value;
        throw $break;
      }
    });
    return result;
  },
  findAll: function(iterator) {
    var results = [];
    this.each(function(value, index) {
      if (iterator(value, index))
        results.push(value);
    });
    return results;
  },
  grep: function(pattern, iterator) {
    var results = [];
    this.each(function(value, index) {
      var stringValue = value.toString();
      if (stringValue.match(pattern))
        results.push((iterator || Prototype.K)(value, index));
    })
    return results;
  },
  include: function(object) {
    var found = false;
    this.each(function(value) {
      if (value == object) {
        found = true;
        throw $break;
      }
    });
    return found;
  },
  inGroupsOf: function(number, fillWith) {
    fillWith = fillWith === undefined ? null : fillWith;
    return this.eachSlice(number, function(slice) {
      while(slice.length < number) slice.push(fillWith);
      return slice;
    });
  },
  inject: function(memo, iterator) {
    this.each(function(value, index) {
      memo = iterator(memo, value, index);
    });
    return memo;
  },
  invoke: function(method) {
    var args = $A(arguments).slice(1);
    return this.map(function(value) {
      return value[method].apply(value, args);
    });
  },
  max: function(iterator) {
    var result;
    this.each(function(value, index) {
      value = (iterator || Prototype.K)(value, index);
      if (result == undefined || value >= result)
        result = value;
    });
    return result;
  },
  min: function(iterator) {
    var result;
    this.each(function(value, index) {
      value = (iterator || Prototype.K)(value, index);
      if (result == undefined || value < result)
        result = value;
    });
    return result;
  },
  partition: function(iterator) {
    var trues = [], falses = [];
    this.each(function(value, index) {
      ((iterator || Prototype.K)(value, index) ?
        trues : falses).push(value);
    });
    return [trues, falses];
  },
  pluck: function(property) {
    var results = [];
    this.each(function(value, index) {
      results.push(value[property]);
    });
    return results;
  },
  reject: function(iterator) {
    var results = [];
    this.each(function(value, index) {
      if (!iterator(value, index))
        results.push(value);
    });
    return results;
  },
  sortBy: function(iterator) {
    return this.map(function(value, index) {
      return {value: value, criteria: iterator(value, index)};
    }).sort(function(left, right) {
      var a = left.criteria, b = right.criteria;
      return a < b ? -1 : a > b ? 1 : 0;
    }).pluck('value');
  },
  toArray: function() {
    return this.map();
  },
  zip: function() {
    var iterator = Prototype.K, args = $A(arguments);
    if (typeof args.last() == 'function')
      iterator = args.pop();
    var collections = [this].concat(args).map($A);
    return this.map(function(value, index) {
      return iterator(collections.pluck(index));
    });
  },
  size: function() {
    return this.toArray().length;
  },
  inspect: function() {
    return '#<Enumerable:' + this.toArray().inspect() + '>';
  }
}
Object.extend(Enumerable, {
  map:     Enumerable.collect,
  find:    Enumerable.detect,
  select:  Enumerable.findAll,
  member:  Enumerable.include,
  entries: Enumerable.toArray
});
var $A = Array.from = function(iterable) {
  if (!iterable) return [];
  if (iterable.toArray) {
    return iterable.toArray();
  } else {
    var results = [];
    for (var i = 0, length = iterable.length; i < length; i++)
      results.push(iterable[i]);
    return results;
  }
}
Object.extend(Array.prototype, Enumerable);
if (!Array.prototype._reverse)
  Array.prototype._reverse = Array.prototype.reverse;
Object.extend(Array.prototype, {
  _each: function(iterator) {
    for (var i = 0, length = this.length; i < length; i++)
      iterator(this[i]);
  },
  clear: function() {
    this.length = 0;
    return this;
  },
  first: function() {
    return this[0];
  },
  last: function() {
    return this[this.length - 1];
  },
  compact: function() {
    return this.select(function(value) {
      return value != null;
    });
  },
  flatten: function() {
    return this.inject([], function(array, value) {
      return array.concat(value && value.constructor == Array ?
        value.flatten() : [value]);
    });
  },
  without: function() {
    var values = $A(arguments);
    return this.select(function(value) {
      return !values.include(value);
    });
  },
  indexOf: function(object) {
    for (var i = 0, length = this.length; i < length; i++)
      if (this[i] == object) return i;
    return -1;
  },
  reverse: function(inline) {
    return (inline !== false ? this : this.toArray())._reverse();
  },
  reduce: function() {
    return this.length > 1 ? this : this[0];
  },
  uniq: function() {
    return this.inject([], function(array, value) {
      return array.include(value) ? array : array.concat([value]);
    });
  },
  clone: function() {
    return [].concat(this);
  },
  size: function() {
    return this.length;
  },
  inspect: function() {
    return '[' + this.map(Object.inspect).join(', ') + ']';
  }
});
Array.prototype.toArray = Array.prototype.clone;
function $w(string){
  string = string.strip();
  return string ? string.split(/\s+/) : [];
}
if(window.opera){
  Array.prototype.concat = function(){
    var array = [];
    for(var i = 0, length = this.length; i < length; i++) array.push(this[i]);
    for(var i = 0, length = arguments.length; i < length; i++) {
      if(arguments[i].constructor == Array) {
        for(var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
          array.push(arguments[i][j]);
      } else {
        array.push(arguments[i]);
      }
    }
    return array;
  }
}
var Hash = function(obj) {
  Object.extend(this, obj || {});
};
Object.extend(Hash, {
  toQueryString: function(obj) {
    var parts = [];
   this.prototype._each.call(obj, function(pair) {
      if (!pair.key) return;
      if (pair.value && pair.value.constructor == Array) {
        var values = pair.value.compact();
        if (values.length < 2) pair.value = values.reduce();
        else {
         key = encodeURIComponent(pair.key);
          values.each(function(value) {
            value = value != undefined ? encodeURIComponent(value) : '';
            parts.push(key + '=' + encodeURIComponent(value));
          });
          return;
        }
      }
      if (pair.value == undefined) pair[1] = '';
      parts.push(pair.map(encodeURIComponent).join('='));
   });
    return parts.join('&');
  }
});
Object.extend(Hash.prototype, Enumerable);
Object.extend(Hash.prototype, {
  _each: function(iterator) {
    for (var key in this) {
      var value = this[key];
      if (value && value == Hash.prototype[key]) continue;
      var pair = [key, value];
      pair.key = key;
      pair.value = value;
      iterator(pair);
    }
  },
  keys: function() {
    return this.pluck('key');
  },
  values: function() {
    return this.pluck('value');
  },
  merge: function(hash) {
    return $H(hash).inject(this, function(mergedHash, pair) {
      mergedHash[pair.key] = pair.value;
      return mergedHash;
    });
  },
  remove: function() {
    var result;
    for(var i = 0, length = arguments.length; i < length; i++) {
      var value = this[arguments[i]];
      if (value !== undefined){
        if (result === undefined) result = value;
        else {
          if (result.constructor != Array) result = [result];
          result.push(value)
        }
      }
      delete this[arguments[i]];
    }
    return result;
  },
  toQueryString: function() {
    return Hash.toQueryString(this);
  },
  inspect: function() {
    return '#<Hash:{' + this.map(function(pair) {
      return pair.map(Object.inspect).join(': ');
    }).join(', ') + '}>';
  }
});
function $H(object) {
  if (object && object.constructor == Hash) return object;
  return new Hash(object);
};
ObjectRange = Class.create();
Object.extend(ObjectRange.prototype, Enumerable);
Object.extend(ObjectRange.prototype, {
  initialize: function(start, end, exclusive) {
    this.start = start;
    this.end = end;
    this.exclusive = exclusive;
  },
  _each: function(iterator) {
    var value = this.start;
    while (this.include(value)) {
      iterator(value);
      value = value.succ();
    }
  },
  include: function(value) {
    if (value < this.start)
      return false;
    if (this.exclusive)
      return value < this.end;
    return value <= this.end;
  }
});
var $R = function(start, end, exclusive) {
  return new ObjectRange(start, end, exclusive);
}
var Ajax = {
  getTransport: function() {
    return Try.these(
      function() {return new XMLHttpRequest()},
      function() {return new ActiveXObject('Msxml2.XMLHTTP')},
      function() {return new ActiveXObject('Microsoft.XMLHTTP')}
    ) || false;
  },
  activeRequestCount: 0
}
Ajax.Responders = {
  responders: [],
  _each: function(iterator) {
    this.responders._each(iterator);
  },
  register: function(responder) {
    if (!this.include(responder))
      this.responders.push(responder);
  },
  unregister: function(responder) {
    this.responders = this.responders.without(responder);
  },
  dispatch: function(callback, request, transport, json) {
    this.each(function(responder) {
      if (typeof responder[callback] == 'function') {
        try {
          responder[callback].apply(responder, [request, transport, json]);
        } catch (e) {}
      }
    });
  }
};
Object.extend(Ajax.Responders, Enumerable);
Ajax.Responders.register({
  onCreate: function() {
    Ajax.activeRequestCount++;
  },
  onComplete: function() {
    Ajax.activeRequestCount--;
  }
});
Ajax.Base = function() {};
Ajax.Base.prototype = {
  setOptions: function(options) {
    this.options = {
      method:       'post',
      asynchronous: true,
      contentType:  'application/x-www-form-urlencoded',
      encoding:     'UTF-8',
      parameters:   ''
    }
    Object.extend(this.options, options || {});
    this.options.method = this.options.method.toLowerCase();
    if (typeof this.options.parameters == 'string')
      this.options.parameters = this.options.parameters.toQueryParams();
  }
}
Ajax.Request = Class.create();
Ajax.Request.Events =
  ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
  _complete: false,
  initialize: function(url, options) {
    this.transport = Ajax.getTransport();
    this.setOptions(options);
    this.request(url);
  },
  request: function(url) {
    this.url = url;
    this.method = this.options.method;
    var params = this.options.parameters;
    if (!['get', 'post'].include(this.method)) {
      params['_method'] = this.method;
      this.method = 'post';
    }
    params = Hash.toQueryString(params);
    if (params && /Konqueror|Safari|KHTML/.test(navigator.userAgent)) params += '&_='
    if (this.method == 'get' && params)
      this.url += (this.url.indexOf('?') > -1 ? '&' : '?') + params;
    try {
      Ajax.Responders.dispatch('onCreate', this, this.transport);
      this.transport.open(this.method.toUpperCase(), this.url,
        this.options.asynchronous);
      if (this.options.asynchronous)
        setTimeout(function() { this.respondToReadyState(1) }.bind(this), 10);
      this.transport.onreadystatechange = this.onStateChange.bind(this);
      this.setRequestHeaders();
      var body = this.method == 'post' ? (this.options.postBody || params) : null;
      this.transport.send(body);
      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 : '');
      if (this.transport.overrideMimeType &&
          (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
            headers['Connection'] = 'close';
    }
    if (typeof this.options.requestHeaders == 'object') {
      var extras = this.options.requestHeaders;
      if (typeof extras.push == 'function')
        for (var i = 0, length = extras.length; i < length; i += 2)
          headers[extras[i]] = extras[i+1];
      else
        $H(extras).each(function(pair) { headers[pair.key] = pair.value });
    }
    for (var name in headers)
      this.transport.setRequestHeader(name, headers[name]);
  },
  success: function() {
    return !this.transport.status
        || (this.transport.status >= 200 && this.transport.status < 300);
  },
  respondToReadyState: function(readyState) {
    var state = Ajax.Request.Events[readyState];
    var transport = this.transport, json = this.evalJSON();
    if (state == 'Complete') {
      try {
        this._complete = true;
        (this.options['on' + this.transport.status]
         || this.options['on' + (this.success() ? 'Success' : 'Failure')]
         || Prototype.emptyFunction)(transport, json);
      } catch (e) {
        this.dispatchException(e);
      }
      if ((this.getHeader('Content-type') || 'text/javascript').strip().
        match(/^(text|application)\/(x-)?(java|ecma)script(;.*)?$/i))
          this.evalResponse();
    }
    try {
      (this.options['on' + state] || Prototype.emptyFunction)(transport, json);
      Ajax.Responders.dispatch('on' + state, this, transport, json);
    } catch (e) {
      this.dispatchException(e);
    }
    if (state == 'Complete') {
      this.transport.onreadystatechange = Prototype.emptyFunction;
    }
  },
  getHeader: function(name) {
    try {
      return this.transport.getResponseHeader(name);
    } catch (e) { return null }
  },
  evalJSON: function() {
    try {
      var json = this.getHeader('X-JSON');
      return json ? eval('(' + json + ')') : null;
    } catch (e) { return null }
  },
  evalResponse: function() {
    try {
      return eval(this.transport.responseText);
    } catch (e) {
      this.dispatchException(e);
    }
  },
  dispatchException: function(exception) {
    (this.options.onException || Prototype.emptyFunction)(this, exception);
    Ajax.Responders.dispatch('onException', this, exception);
  }
});
Ajax.Updater = Class.create();
Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {
  initialize: function(container, url, options) {
    this.container = {
      success: (container.success || container),
      failure: (container.failure || (container.success ? null : container))
    }
    this.transport = Ajax.getTransport();
    this.setOptions(options);
    var onComplete = this.options.onComplete || Prototype.emptyFunction;
    this.options.onComplete = (function(transport, param) {
      this.updateContent();
      onComplete(transport, param);
    }).bind(this);
    this.request(url);
  },
  updateContent: function() {
    var receiver = this.container[this.success() ? 'success' : 'failure'];
    var response = this.transport.responseText;
    if (!this.options.evalScripts) response = response.stripScripts();
    if (receiver = $(receiver)) {
      if (this.options.insertion)
        new this.options.insertion(receiver, response);
      else
        receiver.update(response);
    }
    if (this.success()) {
      if (this.onComplete)
        setTimeout(this.onComplete.bind(this), 10);
    }
  }
});
Ajax.PeriodicalUpdater = Class.create();
Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {
  initialize: function(container, url, options) {
    this.setOptions(options);
    this.onComplete = this.options.onComplete;
    this.frequency = (this.options.frequency || 2);
    this.decay = (this.options.decay || 1);
    this.updater = {};
    this.container = container;
    this.url = url;
    this.start();
  },
  start: function() {
    this.options.onComplete = this.updateComplete.bind(this);
    this.onTimerEvent();
  },
  stop: function() {
    this.updater.options.onComplete = undefined;
    clearTimeout(this.timer);
    (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
  },
  updateComplete: function(request) {
    if (this.options.decay) {
      this.decay = (request.responseText == this.lastText ?
        this.decay * this.options.decay : 1);
      this.lastText = request.responseText;
    }
    this.timer = setTimeout(this.onTimerEvent.bind(this),
      this.decay * this.frequency * 1000);
  },
  onTimerEvent: function() {
    this.updater = new Ajax.Updater(this.container, this.url, this.options);
  }
});
function $(element) {
  if (arguments.length > 1) {
    for (var i = 0, elements = [], length = arguments.length; i < length; i++)
      elements.push($(arguments[i]));
    return elements;
  }
  if (typeof element == 'string')
    element = document.getElementById(element);
  return Element.extend(element);
}
if (Prototype.BrowserFeatures.XPath) {
  document._getElementsByXPath = function(expression, parentElement) {
    var results = [];
    var query = document.evaluate(expression, $(parentElement) || document,
      null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
    for (var i = 0, length = query.snapshotLength; i < length; i++)
      results.push(query.snapshotItem(i));
    return results;
  };
}
document.getElementsByClassName = function(className, parentElement) {
  if (Prototype.BrowserFeatures.XPath) {
    var q = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
    return document._getElementsByXPath(q, parentElement);
  } else {
    var children = ($(parentElement) || document.body).getElementsByTagName('*');
    var elements = [], child;
    for (var i = 0, length = children.length; i < length; i++) {
      child = children[i];
      if (Element.hasClassName(child, className))
        elements.push(Element.extend(child));
    }
    return elements;
  }
};
if (!window.Element)
  var Element = new Object();
Element.extend = function(element) {
  if (!element || _nativeExtensions || element.nodeType == 3) return element;
  if (!element._extended && element.tagName && element != window) {
    var methods = Object.clone(Element.Methods), cache = Element.extend.cache;
    if (element.tagName == 'FORM')
      Object.extend(methods, Form.Methods);
    if (['INPUT', 'TEXTAREA', 'SELECT'].include(element.tagName))
      Object.extend(methods, Form.Element.Methods);
    Object.extend(methods, Element.Methods.Simulated);
    for (var property in methods) {
      var value = methods[property];
      if (typeof value == 'function' && !(property in element))
        element[property] = cache.findOrStore(value);
    }
  }
  element._extended = true;
  return element;
};
Element.extend.cache = {
  findOrStore: function(value) {
    return this[value] = this[value] || function() {
      return value.apply(null, [this].concat($A(arguments)));
    }
  }
};
Element.Methods = {
  visible: function(element) {
    return $(element).style.display != 'none';
  },
  toggle: function(element) {
    element = $(element);
    Element[Element.visible(element) ? 'hide' : 'show'](element);
    return element;
  },
  hide: function(element) {
    $(element).style.display = 'none';
    return element;
  },
  show: function(element) {
    $(element).style.display = '';
    return element;
  },
  remove: function(element) {
    element = $(element);
    element.parentNode.removeChild(element);
    return element;
  },
  update: function(element, html) {
    html = typeof html == 'undefined' ? '' : html.toString();
    $(element).innerHTML = html.stripScripts();
    setTimeout(function() {html.evalScripts()}, 10);
    return element;
  },
  replace: function(element, html) {
    element = $(element);
    html = typeof html == 'undefined' ? '' : html.toString();
    if (element.outerHTML) {
      element.outerHTML = html.stripScripts();
    } else {
      var range = element.ownerDocument.createRange();
      range.selectNodeContents(element);
      element.parentNode.replaceChild(
        range.createContextualFragment(html.stripScripts()), element);
    }
    setTimeout(function() {html.evalScripts()}, 10);
    return element;
  },
  inspect: function(element) {
    element = $(element);
    var result = '<' + element.tagName.toLowerCase();
    $H({'id': 'id', 'className': 'class'}).each(function(pair) {
      var property = pair.first(), attribute = pair.last();
      var value = (element[property] || '').toString();
      if (value) result += ' ' + attribute + '=' + value.inspect(true);
    });
    return result + '>';
  },
  recursivelyCollect: function(element, property) {
    element = $(element);
    var elements = [];
    while (element = element[property])
      if (element.nodeType == 1)
        elements.push(Element.extend(element));
    return elements;
  },
  ancestors: function(element) {
    return $(element).recursivelyCollect('parentNode');
  },
  descendants: function(element) {
    return $A($(element).getElementsByTagName('*'));
  },
  immediateDescendants: function(element) {
    if (!(element = $(element).firstChild)) return [];
    while (element && element.nodeType != 1) element = element.nextSibling;
    if (element) return [element].concat($(element).nextSiblings());
    return [];
  },
  previousSiblings: function(element) {
    return $(element).recursivelyCollect('previousSibling');
  },
  nextSiblings: function(element) {
    return $(element).recursivelyCollect('nextSibling');
  },
  siblings: function(element) {
    element = $(element);
    return element.previousSiblings().reverse().concat(element.nextSiblings());
  },
  match: function(element, selector) {
    if (typeof selector == 'string')
      selector = new Selector(selector);
    return selector.match($(element));
  },
  up: function(element, expression, index) {
    return Selector.findElement($(element).ancestors(), expression, index);
  },
  down: function(element, expression, index) {
    return Selector.findElement($(element).descendants(), expression, index);
  },
  previous: function(element, expression, index) {
    return Selector.findElement($(element).previousSiblings(), expression, index);
  },
  next: function(element, expression, index) {
    return Selector.findElement($(element).nextSiblings(), expression, index);
  },
  getElementsBySelector: function() {
    var args = $A(arguments), element = $(args.shift());
    return Selector.findChildElements(element, args);
  },
  getElementsByClassName: function(element, className) {
    return document.getElementsByClassName(className, element);
  },
  readAttribute: function(element, name) {
    element = $(element);
    if (document.all && !window.opera) {
      var t = Element._attributeTranslations;
      if (t.values[name]) return t.values[name](element, name);
      if (t.names[name])  name = t.names[name];
      var attribute = element.attributes[name];
      if(attribute) return attribute.nodeValue;
    }
    return element.getAttribute(name);
  },
  getHeight: function(element) {
    return $(element).getDimensions().height;
  },
  getWidth: function(element) {
    return $(element).getDimensions().width;
  },
  classNames: function(element) {
    return new Element.ClassNames(element);
  },
  hasClassName: function(element, className) {
    if (!(element = $(element))) return;
    var elementClassName = element.className;
    if (elementClassName.length == 0) return false;
    if (elementClassName == className ||
        elementClassName.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
      return true;
    return false;
  },
  addClassName: function(element, className) {
    if (!(element = $(element))) return;
    Element.classNames(element).add(className);
    return element;
  },
  removeClassName: function(element, className) {
    if (!(element = $(element))) return;
    Element.classNames(element).remove(className);
    return element;
  },
  toggleClassName: function(element, className) {
    if (!(element = $(element))) return;
    Element.classNames(element)[element.hasClassName(className) ? 'remove' : 'add'](className);
    return element;
  },
  observe: function() {
    Event.observe.apply(Event, arguments);
    return $A(arguments).first();
  },
  stopObserving: function() {
    Event.stopObserving.apply(Event, arguments);
    return $A(arguments).first();
  },
  cleanWhitespace: function(element) {
    element = $(element);
    var node = element.firstChild;
    while (node) {
      var nextNode = node.nextSibling;
      if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
        element.removeChild(node);
      node = nextNode;
    }
    return element;
  },
  empty: function(element) {
    return $(element).innerHTML.match(/^\s*$/);
  },
  descendantOf: function(element, ancestor) {
    element = $(element), ancestor = $(ancestor);
    while (element = element.parentNode)
      if (element == ancestor) return true;
    return false;
  },
  scrollTo: function(element) {
    element = $(element);
    var pos = Position.cumulativeOffset(element);
    window.scrollTo(pos[0], pos[1]);
    return element;
  },
  getStyle: function(element, style) {
    element = $(element);
    if (['float','cssFloat'].include(style))
      style = (typeof element.style.styleFloat != 'undefined' ? 'styleFloat' : 'cssFloat');
    style = style.camelize();
    var value = element.style[style];
    if (!value) {
      if (document.defaultView && document.defaultView.getComputedStyle) {
        var css = document.defaultView.getComputedStyle(element, null);
        value = css ? css[style] : null;
      } else if (element.currentStyle) {
        value = element.currentStyle[style];
      }
    }
    if((value == 'auto') && ['width','height'].include(style) && (element.getStyle('display') != 'none'))
      value = element['offset'+style.capitalize()] + 'px';
    if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))
      if (Element.getStyle(element, 'position') == 'static') value = 'auto';
    if(style == 'opacity') {
      if(value) return parseFloat(value);
      if(value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
        if(value[1]) return parseFloat(value[1]) / 100;
      return 1.0;
    }
    return value == 'auto' ? null : value;
  },
  setStyle: function(element, style) {
    element = $(element);
    for (var name in style) {
      var value = style[name];
      if(name == 'opacity') {
        if (value == 1) {
          value = (/Gecko/.test(navigator.userAgent) &&
            !/Konqueror|Safari|KHTML/.test(navigator.userAgent)) ? 0.999999 : 1.0;
          if(/MSIE/.test(navigator.userAgent) && !window.opera)
            element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'');
        } else if(value == '') {
          if(/MSIE/.test(navigator.userAgent) && !window.opera)
            element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'');
        } else {
          if(value < 0.00001) value = 0;
          if(/MSIE/.test(navigator.userAgent) && !window.opera)
            element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'') +
              'alpha(opacity='+value*100+')';
        }
      } else if(['float','cssFloat'].include(name)) name = (typeof element.style.styleFloat != 'undefined') ? 'styleFloat' : 'cssFloat';
      element.style[name.camelize()] = value;
    }
    return element;
  },
  getDimensions: function(element) {
    element = $(element);
    var display = $(element).getStyle('display');
    if (display != 'none' && display != null)
      return {width: element.offsetWidth, height: element.offsetHeight};
    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';
      if (window.opera) {
        element.style.top = 0;
        element.style.left = 0;
      }
    }
    return element;
  },
  undoPositioned: function(element) {
    element = $(element);
    if (element._madePositioned) {
      element._madePositioned = undefined;
      element.style.position =
        element.style.top =
        element.style.left =
        element.style.bottom =
        element.style.right = '';
    }
    return element;
  },
  makeClipping: function(element) {
    element = $(element);
    if (element._overflow) return element;
    element._overflow = element.style.overflow || 'auto';
    if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden')
      element.style.overflow = 'hidden';
    return element;
  },
  undoClipping: function(element) {
    element = $(element);
    if (!element._overflow) return element;
    element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
    element._overflow = null;
    return element;
  }
};
Object.extend(Element.Methods, {childOf: Element.Methods.descendantOf});
Element._attributeTranslations = {};
Element._attributeTranslations.names = {
  colspan:   "colSpan",
  rowspan:   "rowSpan",
  valign:    "vAlign",
  datetime:  "dateTime",
  accesskey: "accessKey",
  tabindex:  "tabIndex",
  enctype:   "encType",
  maxlength: "maxLength",
  readonly:  "readOnly",
  longdesc:  "longDesc"
};
Element._attributeTranslations.values = {
  _getAttr: function(element, attribute) {
    return element.getAttribute(attribute, 2);
  },
  _flag: function(element, attribute) {
    return $(element).hasAttribute(attribute) ? attribute : null;
  },
  style: function(element) {
    return element.style.cssText.toLowerCase();
  },
  title: function(element) {
    var node = element.getAttributeNode('title');
    return node.specified ? node.nodeValue : null;
  }
};
Object.extend(Element._attributeTranslations.values, {
  href: Element._attributeTranslations.values._getAttr,
  src:  Element._attributeTranslations.values._getAttr,
  disabled: Element._attributeTranslations.values._flag,
  checked:  Element._attributeTranslations.values._flag,
  readonly: Element._attributeTranslations.values._flag,
  multiple: Element._attributeTranslations.values._flag
});
Element.Methods.Simulated = {
  hasAttribute: function(element, attribute) {
    var t = Element._attributeTranslations;
    attribute = t.names[attribute] || attribute;
    return $(element).getAttributeNode(attribute).specified;
  }
};
if (document.all && !window.opera){
  Element.Methods.update = function(element, html) {
    element = $(element);
    html = typeof html == 'undefined' ? '' : html.toString();
    var tagName = element.tagName.toUpperCase();
    if (['THEAD','TBODY','TR','TD'].include(tagName)) {
      var div = document.createElement('div');
      switch (tagName) {
        case 'THEAD':
        case 'TBODY':
          div.innerHTML = '<table><tbody>' +  html.stripScripts() + '</tbody></table>';
          depth = 2;
          break;
        case 'TR':
          div.innerHTML = '<table><tbody><tr>' +  html.stripScripts() + '</tr></tbody></table>';
          depth = 3;
          break;
        case 'TD':
          div.innerHTML = '<table><tbody><tr><td>' +  html.stripScripts() + '</td></tr></tbody></table>';
          depth = 4;
      }
      $A(element.childNodes).each(function(node){
        element.removeChild(node)
      });
      depth.times(function(){ div = div.firstChild });
      $A(div.childNodes).each(
        function(node){ element.appendChild(node) });
    } else {
      element.innerHTML = html.stripScripts();
    }
    setTimeout(function() {html.evalScripts()}, 10);
    return element;
  }
};
Object.extend(Element, Element.Methods);
var _nativeExtensions = false;
if(/Konqueror|Safari|KHTML/.test(navigator.userAgent))
  ['', 'Form', 'Input', 'TextArea', 'Select'].each(function(tag) {
    var className = 'HTML' + tag + 'Element';
    if(window[className]) return;
    var klass = window[className] = {};
    klass.prototype = document.createElement(tag ? tag.toLowerCase() : 'div').__proto__;
  });
Element.addMethods = function(methods) {
  Object.extend(Element.Methods, methods || {});
  function copy(methods, destination, onlyIfAbsent) {
    onlyIfAbsent = onlyIfAbsent || false;
    var cache = Element.extend.cache;
    for (var property in methods) {
      var value = methods[property];
      if (!onlyIfAbsent || !(property in destination))
        destination[property] = cache.findOrStore(value);
    }
  }
  if (typeof HTMLElement != 'undefined') {
    copy(Element.Methods, HTMLElement.prototype);
    copy(Element.Methods.Simulated, HTMLElement.prototype, true);
    copy(Form.Methods, HTMLFormElement.prototype);
    [HTMLInputElement, HTMLTextAreaElement, HTMLSelectElement].each(function(klass) {
      copy(Form.Element.Methods, klass.prototype);
    });
    _nativeExtensions = true;
  }
}
var Toggle = new Object();
Toggle.display = Element.toggle;
Abstract.Insertion = function(adjacency) {
  this.adjacency = adjacency;
}
Abstract.Insertion.prototype = {
  initialize: function(element, content) {
    this.element = $(element);
    this.content = content.stripScripts();
    if (this.adjacency && this.element.insertAdjacentHTML) {
      try {
        this.element.insertAdjacentHTML(this.adjacency, this.content);
      } catch (e) {
        var tagName = this.element.tagName.toUpperCase();
        if (['TBODY', 'TR'].include(tagName)) {
          this.insertContent(this.contentFromAnonymousTable());
        } else {
          throw e;
        }
      }
    } else {
      this.range = this.element.ownerDocument.createRange();
      if (this.initializeRange) this.initializeRange();
      this.insertContent([this.range.createContextualFragment(this.content)]);
    }
    setTimeout(function() {content.evalScripts()}, 10);
  },
  contentFromAnonymousTable: function() {
    var div = document.createElement('div');
    div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';
    return $A(div.childNodes[0].childNodes[0].childNodes);
  }
}
var Insertion = new Object();
Insertion.Before = Class.create();
Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {
  initializeRange: function() {
    this.range.setStartBefore(this.element);
  },
  insertContent: function(fragments) {
    fragments.each((function(fragment) {
      this.element.parentNode.insertBefore(fragment, this.element);
    }).bind(this));
  }
});
Insertion.Top = Class.create();
Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {
  initializeRange: function() {
    this.range.selectNodeContents(this.element);
    this.range.collapse(true);
  },
  insertContent: function(fragments) {
    fragments.reverse(false).each((function(fragment) {
      this.element.insertBefore(fragment, this.element.firstChild);
    }).bind(this));
  }
});
Insertion.Bottom = Class.create();
Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {
  initializeRange: function() {
    this.range.selectNodeContents(this.element);
    this.range.collapse(this.element);
  },
  insertContent: function(fragments) {
    fragments.each((function(fragment) {
      this.element.appendChild(fragment);
    }).bind(this));
  }
});
Insertion.After = Class.create();
Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {
  initializeRange: function() {
    this.range.setStartAfter(this.element);
  },
  insertContent: function(fragments) {
    fragments.each((function(fragment) {
      this.element.parentNode.insertBefore(fragment,
        this.element.nextSibling);
    }).bind(this));
  }
});
Element.ClassNames = Class.create();
Element.ClassNames.prototype = {
  initialize: function(element) {
    this.element = $(element);
  },
  _each: function(iterator) {
    this.element.className.split(/\s+/).select(function(name) {
      return name.length > 0;
    })._each(iterator);
  },
  set: function(className) {
    this.element.className = className;
  },
  add: function(classNameToAdd) {
    if (this.include(classNameToAdd)) return;
    this.set($A(this).concat(classNameToAdd).join(' '));
  },
  remove: function(classNameToRemove) {
    if (!this.include(classNameToRemove)) return;
    this.set($A(this).without(classNameToRemove).join(' '));
  },
  toString: function() {
    return $A(this).join(' ');
  }
};
Object.extend(Element.ClassNames.prototype, Enumerable);
var Selector = Class.create();
Selector.prototype = {
  initialize: function(expression) {
    this.params = {classNames: []};
    this.expression = expression.toString().strip();
    this.parseExpression();
    this.compileMatcher();
  },
  parseExpression: function() {
    function abort(message) { throw 'Parse error in selector: ' + message; }
    if (this.expression == '')  abort('empty expression');
    var params = this.params, expr = this.expression, match, modifier, clause, rest;
    while (match = expr.match(/^(.*)\[([a-z0-9_:-]+?)(?:([~\|!]?=)(?:"([^"]*)"|([^\]\s]*)))?\]$/i)) {
      params.attributes = params.attributes || [];
      params.attributes.push({name: match[2], operator: match[3], value: match[4] || match[5] || ''});
      expr = match[1];
    }
    if (expr == '*') return this.params.wildcard = true;
    while (match = expr.match(/^([^a-z0-9_-])?([a-z0-9_-]+)(.*)/i)) {
      modifier = match[1], clause = match[2], rest = match[3];
      switch (modifier) {
        case '#':       params.id = clause; break;
        case '.':       params.classNames.push(clause); break;
        case '':
        case undefined: params.tagName = clause.toUpperCase(); break;
        default:        abort(expr.inspect());
      }
      expr = rest;
    }
    if (expr.length > 0) abort(expr.inspect());
  },
  buildMatchExpression: function() {
    var params = this.params, conditions = [], clause;
    if (params.wildcard)
      conditions.push('true');
    if (clause = params.id)
      conditions.push('element.readAttribute("id") == ' + clause.inspect());
    if (clause = params.tagName)
      conditions.push('element.tagName.toUpperCase() == ' + clause.inspect());
    if ((clause = params.classNames).length > 0)
      for (var i = 0, length = clause.length; i < length; i++)
        conditions.push('element.hasClassName(' + clause[i].inspect() + ')');
    if (clause = params.attributes) {
      clause.each(function(attribute) {
        var value = 'element.readAttribute(' + attribute.name.inspect() + ')';
        var splitValueBy = function(delimiter) {
          return value + ' && ' + value + '.split(' + delimiter.inspect() + ')';
        }
        switch (attribute.operator) {
          case '=':       conditions.push(value + ' == ' + attribute.value.inspect()); break;
          case '~=':      conditions.push(splitValueBy(' ') + '.include(' + attribute.value.inspect() + ')'); break;
          case '|=':      conditions.push(
                            splitValueBy('-') + '.first().toUpperCase() == ' + attribute.value.toUpperCase().inspect()
                          ); break;
          case '!=':      conditions.push(value + ' != ' + attribute.value.inspect()); break;
          case '':
          case undefined: conditions.push('element.hasAttribute(' + attribute.name.inspect() + ')'); break;
          default:        throw 'Unknown operator ' + attribute.operator + ' in selector';
        }
      });
    }
    return conditions.join(' && ');
  },
  compileMatcher: function() {
    this.match = new Function('element', 'if (!element.tagName) return false; \
      element = $(element); \
      return ' + this.buildMatchExpression());
  },
  findElements: function(scope) {
    var element;
    if (element = $(this.params.id))
      if (this.match(element))
        if (!scope || Element.childOf(element, scope))
          return [element];
    scope = (scope || document).getElementsByTagName(this.params.tagName || '*');
    var results = [];
    for (var i = 0, length = scope.length; i < length; i++)
      if (this.match(element = scope[i]))
        results.push(Element.extend(element));
    return results;
  },
  toString: function() {
    return this.expression;
  }
}
Object.extend(Selector, {
  matchElements: function(elements, expression) {
    var selector = new Selector(expression);
    return elements.select(selector.match.bind(selector)).map(Element.extend);
  },
  findElement: function(elements, expression, index) {
    if (typeof expression == 'number') index = expression, expression = false;
    return Selector.matchElements(elements, expression || '*')[index || 0];
  },
  findChildElements: function(element, expressions) {
    return expressions.map(function(expression) {
      return expression.match(/[^\s"]+(?:"[^"]*"[^\s"]+)*/g).inject([null], function(results, expr) {
        var selector = new Selector(expr);
        return results.inject([], function(elements, result) {
          return elements.concat(selector.findElements(result || element));
        });
      });
    }).flatten();
  }
});
function $$() {
  return Selector.findChildElements(document, $A(arguments));
}
var Form = {
  reset: function(form) {
    $(form).reset();
    return form;
  },
  serializeElements: function(elements, getHash) {
    var data = elements.inject({}, function(result, element) {
      if (!element.disabled && element.name) {
        var key = element.name, value = $(element).getValue();
        if (value != undefined) {
          if (result[key]) {
            if (result[key].constructor != Array) result[key] = [result[key]];
            result[key].push(value);
          }
          else result[key] = value;
        }
      }
      return result;
    });
    return getHash ? data : Hash.toQueryString(data);
  }
};
Form.Methods = {
  serialize: function(form, getHash) {
    return Form.serializeElements(Form.getElements(form), getHash);
  },
  getElements: function(form) {
    return $A($(form).getElementsByTagName('*')).inject([],
      function(elements, child) {
        if (Form.Element.Serializers[child.tagName.toLowerCase()])
          elements.push(Element.extend(child));
        return elements;
      }
    );
  },
  getInputs: function(form, typeName, name) {
    form = $(form);
    var inputs = form.getElementsByTagName('input');
    if (!typeName && !name) return $A(inputs).map(Element.extend);
    for (var i = 0, matchingInputs = [], length = inputs.length; i < length; i++) {
      var input = inputs[i];
      if ((typeName && input.type != typeName) || (name && input.name != name))
        continue;
      matchingInputs.push(Element.extend(input));
    }
    return matchingInputs;
  },
  disable: function(form) {
    form = $(form);
    form.getElements().each(function(element) {
      element.blur();
      element.disabled = 'true';
    });
    return form;
  },
  enable: function(form) {
    form = $(form);
    form.getElements().each(function(element) {
      element.disabled = '';
    });
    return form;
  },
  findFirstElement: function(form) {
    return $(form).getElements().find(function(element) {
      return element.type != 'hidden' && !element.disabled &&
        ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
    });
  },
  focusFirstElement: function(form) {
    form = $(form);
    form.findFirstElement().activate();
    return form;
  }
}
Object.extend(Form, Form.Methods);
Form.Element = {
  focus: function(element) {
    $(element).focus();
    return element;
  },
  select: function(element) {
    $(element).select();
    return element;
  }
}
Form.Element.Methods = {
  serialize: function(element) {
    element = $(element);
    if (!element.disabled && element.name) {
      var value = element.getValue();
      if (value != undefined) {
        var pair = {};
        pair[element.name] = value;
        return Hash.toQueryString(pair);
      }
    }
    return '';
  },
  getValue: function(element) {
    element = $(element);
    var method = element.tagName.toLowerCase();
    return Form.Element.Serializers[method](element);
  },
  clear: function(element) {
    $(element).value = '';
    return element;
  },
  present: function(element) {
    return $(element).value != '';
  },
  activate: function(element) {
    element = $(element);
    element.focus();
    if (element.select && ( element.tagName.toLowerCase() != 'input' ||
      !['button', 'reset', 'submit'].include(element.type) ) )
      element.select();
    return element;
  },
  disable: function(element) {
    element = $(element);
    element.disabled = true;
    return element;
  },
  enable: function(element) {
    element = $(element);
    element.blur();
    element.disabled = false;
    return element;
  }
}
Object.extend(Form.Element, Form.Element.Methods);
var Field = Form.Element;
var $F = Form.Element.getValue;
Form.Element.Serializers = {
  input: function(element) {
    switch (element.type.toLowerCase()) {
      case 'checkbox':
      case 'radio':
        return Form.Element.Serializers.inputSelector(element);
      default:
        return Form.Element.Serializers.textarea(element);
    }
  },
  inputSelector: function(element) {
    return element.checked ? element.value : null;
  },
  textarea: function(element) {
    return element.value;
  },
  select: function(element) {
    return this[element.type == 'select-one' ?
      'selectOne' : 'selectMany'](element);
  },
  selectOne: function(element) {
    var index = element.selectedIndex;
    return index >= 0 ? this.optionValue(element.options[index]) : null;
  },
  selectMany: function(element) {
    var values, length = element.length;
    if (!length) return null;
    for (var i = 0, values = []; i < length; i++) {
      var opt = element.options[i];
      if (opt.selected) values.push(this.optionValue(opt));
    }
    return values;
  },
  optionValue: function(opt) {
    return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
  }
}
Abstract.TimedObserver = function() {}
Abstract.TimedObserver.prototype = {
  initialize: function(element, frequency, callback) {
    this.frequency = frequency;
    this.element   = $(element);
    this.callback  = callback;
    this.lastValue = this.getValue();
    this.registerCallback();
  },
  registerCallback: function() {
    setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
  },
  onTimerEvent: function() {
    var value = this.getValue();
    var changed = ('string' == typeof this.lastValue && 'string' == typeof value
      ? this.lastValue != value : String(this.lastValue) != String(value));
    if (changed) {
      this.callback(this.element, value);
      this.lastValue = value;
    }
  }
}
Form.Element.Observer = Class.create();
Form.Element.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
  getValue: function() {
    return Form.Element.getValue(this.element);
  }
});
Form.Observer = Class.create();
Form.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
  getValue: function() {
    return Form.serialize(this.element);
  }
});
Abstract.EventObserver = function() {}
Abstract.EventObserver.prototype = {
  initialize: function(element, callback) {
    this.element  = $(element);
    this.callback = callback;
    this.lastValue = this.getValue();
    if (this.element.tagName.toLowerCase() == 'form')
      this.registerFormCallbacks();
    else
      this.registerCallback(this.element);
  },
  onElementEvent: function() {
    var value = this.getValue();
    if (this.lastValue != value) {
      this.callback(this.element, value);
      this.lastValue = value;
    }
  },
  registerFormCallbacks: function() {
    Form.getElements(this.element).each(this.registerCallback.bind(this));
  },
  registerCallback: function(element) {
    if (element.type) {
      switch (element.type.toLowerCase()) {
        case 'checkbox':
        case 'radio':
          Event.observe(element, 'click', this.onElementEvent.bind(this));
          break;
        default:
          Event.observe(element, 'change', this.onElementEvent.bind(this));
          break;
      }
    }
  }
}
Form.Element.EventObserver = Class.create();
Form.Element.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
  getValue: function() {
    return Form.Element.getValue(this.element);
  }
});
Form.EventObserver = Class.create();
Form.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
  getValue: function() {
    return Form.serialize(this.element);
  }
});
if (!window.Event) {
  var Event = new Object();
}
Object.extend(Event, {
  KEY_BACKSPACE: 8,
  KEY_TAB:       9,
  KEY_RETURN:   13,
  KEY_ESC:      27,
  KEY_LEFT:     37,
  KEY_UP:       38,
  KEY_RIGHT:    39,
  KEY_DOWN:     40,
  KEY_DELETE:   46,
  KEY_HOME:     36,
  KEY_END:      35,
  KEY_PAGEUP:   33,
  KEY_PAGEDOWN: 34,
  element: function(event) {
    return event.target || event.srcElement;
  },
  isLeftClick: function(event) {
    return (((event.which) && (event.which == 1)) ||
            ((event.button) && (event.button == 1)));
  },
  pointerX: function(event) {
    return event.pageX || (event.clientX +
      (document.documentElement.scrollLeft || document.body.scrollLeft));
  },
  pointerY: function(event) {
    return event.pageY || (event.clientY +
      (document.documentElement.scrollTop || document.body.scrollTop));
  },
  stop: function(event) {
    if (event.preventDefault) {
      event.preventDefault();
      event.stopPropagation();
    } else {
      event.returnValue = false;
      event.cancelBubble = true;
    }
  },
  findElement: function(event, tagName) {
    var element = Event.element(event);
    while (element.parentNode && (!element.tagName ||
        (element.tagName.toUpperCase() != tagName.toUpperCase())))
      element = element.parentNode;
    return element;
  },
  observers: false,
  _observeAndCache: function(element, name, observer, useCapture) {
    if (!this.observers) this.observers = [];
    if (element.addEventListener) {
      this.observers.push([element, name, observer, useCapture]);
      element.addEventListener(name, observer, useCapture);
    } else if (element.attachEvent) {
      this.observers.push([element, name, observer, useCapture]);
      element.attachEvent('on' + name, observer);
    }
  },
  unloadCache: function() {
    if (!Event.observers) return;
    for (var i = 0, length = Event.observers.length; i < length; i++) {
      Event.stopObserving.apply(this, Event.observers[i]);
      Event.observers[i][0] = null;
    }
    Event.observers = false;
  },
  observe: function(element, name, observer, useCapture) {
    element = $(element);
    useCapture = useCapture || false;
    if (name == 'keypress' &&
        (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
        || element.attachEvent))
      name = 'keydown';
    Event._observeAndCache(element, name, observer, useCapture);
  },
  stopObserving: function(element, name, observer, useCapture) {
    element = $(element);
    useCapture = useCapture || false;
    if (name == 'keypress' &&
        (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
        || element.detachEvent))
      name = 'keydown';
    if (element.removeEventListener) {
      element.removeEventListener(name, observer, useCapture);
    } else if (element.detachEvent) {
      try {
        element.detachEvent('on' + name, observer);
      } catch (e) {}
    }
  }
});
if (navigator.appVersion.match(/\bMSIE\b/))
  Event.observe(window, 'unload', Event.unloadCache, false);
var Position = {
  includeScrollOffsets: false,
  prepare: function() {
    this.deltaX =  window.pageXOffset
                || document.documentElement.scrollLeft
                || document.body.scrollLeft
                || 0;
    this.deltaY =  window.pageYOffset
                || document.documentElement.scrollTop
                || document.body.scrollTop
                || 0;
  },
  realOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.scrollTop  || 0;
      valueL += element.scrollLeft || 0;
      element = element.parentNode;
    } while (element);
    return [valueL, valueT];
  },
  cumulativeOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;
      element = element.offsetParent;
    } while (element);
    return [valueL, valueT];
  },
  positionedOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;
      element = element.offsetParent;
      if (element) {
        if(element.tagName=='BODY') break;
        var p = Element.getStyle(element, 'position');
        if (p == 'relative' || p == 'absolute') break;
      }
    } while (element);
    return [valueL, valueT];
  },
  offsetParent: function(element) {
    if (element.offsetParent) return element.offsetParent;
    if (element == document.body) return element;
    while ((element = element.parentNode) && element != document.body)
      if (Element.getStyle(element, 'position') != 'static')
        return element;
    return document.body;
  },
  within: function(element, x, y) {
    if (this.includeScrollOffsets)
      return this.withinIncludingScrolloffsets(element, x, y);
    this.xcomp = x;
    this.ycomp = y;
    this.offset = this.cumulativeOffset(element);
    return (y >= this.offset[1] &&
            y <  this.offset[1] + element.offsetHeight &&
            x >= this.offset[0] &&
            x <  this.offset[0] + element.offsetWidth);
  },
  withinIncludingScrolloffsets: function(element, x, y) {
    var offsetcache = this.realOffset(element);
    this.xcomp = x + offsetcache[0] - this.deltaX;
    this.ycomp = y + offsetcache[1] - this.deltaY;
    this.offset = this.cumulativeOffset(element);
    return (this.ycomp >= this.offset[1] &&
            this.ycomp <  this.offset[1] + element.offsetHeight &&
            this.xcomp >= this.offset[0] &&
            this.xcomp <  this.offset[0] + element.offsetWidth);
  },
  overlap: function(mode, element) {
    if (!mode) return 0;
    if (mode == 'vertical')
      return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
        element.offsetHeight;
    if (mode == 'horizontal')
      return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
        element.offsetWidth;
  },
  page: function(forElement) {
    var valueT = 0, valueL = 0;
    var element = forElement;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;
      if (element.offsetParent==document.body)
        if (Element.getStyle(element,'position')=='absolute') break;
    } while (element = element.offsetParent);
    element = forElement;
    do {
      if (!window.opera || element.tagName=='BODY') {
        valueT -= element.scrollTop  || 0;
        valueL -= element.scrollLeft || 0;
      }
    } while (element = element.parentNode);
    return [valueL, valueT];
  },
  clone: function(source, target) {
    var options = Object.extend({
      setLeft:    true,
      setTop:     true,
      setWidth:   true,
      setHeight:  true,
      offsetTop:  0,
      offsetLeft: 0
    }, arguments[2] || {})
    source = $(source);
    var p = Position.page(source);
    target = $(target);
    var delta = [0, 0];
    var parent = null;
    if (Element.getStyle(target,'position') == 'absolute') {
      parent = Position.offsetParent(target);
      delta = Position.page(parent);
    }
    if (parent == document.body) {
      delta[0] -= document.body.offsetLeft;
      delta[1] -= document.body.offsetTop;
    }
    if(options.setLeft)   target.style.left  = (p[0] - delta[0] + options.offsetLeft) + 'px';
    if(options.setTop)    target.style.top   = (p[1] - delta[1] + options.offsetTop) + 'px';
    if(options.setWidth)  target.style.width = source.offsetWidth + 'px';
    if(options.setHeight) target.style.height = source.offsetHeight + 'px';
  },
  absolutize: function(element) {
    element = $(element);
    if (element.style.position == 'absolute') return;
    Position.prepare();
    var offsets = Position.positionedOffset(element);
    var top     = offsets[1];
    var left    = offsets[0];
    var width   = element.clientWidth;
    var height  = element.clientHeight;
    element._originalLeft   = left - parseFloat(element.style.left  || 0);
    element._originalTop    = top  - parseFloat(element.style.top || 0);
    element._originalWidth  = element.style.width;
    element._originalHeight = element.style.height;
    element.style.position = 'absolute';
    element.style.top    = top + 'px';
    element.style.left   = left + 'px';
    element.style.width  = width + 'px';
    element.style.height = height + 'px';
  },
  relativize: function(element) {
    element = $(element);
    if (element.style.position == 'relative') return;
    Position.prepare();
    element.style.position = 'relative';
    var top  = parseFloat(element.style.top  || 0) - (element._originalTop || 0);
    var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);
    element.style.top    = top + 'px';
    element.style.left   = left + 'px';
    element.style.height = element._originalHeight;
    element.style.width  = element._originalWidth;
  }
}
if (/Konqueror|Safari|KHTML/.test(navigator.userAgent)) {
  Position.cumulativeOffset = function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;
      if (element.offsetParent == document.body)
        if (Element.getStyle(element, 'position') == 'absolute') break;
      element = element.offsetParent;
    } while (element);
    return [valueL, valueT];
  }
}
Element.addMethods();//------------------------------------------------------------------------------------------------------------------------------------------------------
function preForm(vPreCheck) {
 var oForms = document.forms;
 for(var i = 0; i < oForms.length; i++) {
  var oForm = oForms[i];
  if(String(oForm.getAttribute("check")) == "yes") {
   SetForm(oForm, vPreCheck);
   if(document.all) {
    oForm.attachEvent("onsubmit", function() {
     DisableForm(window.event.srcElement);
    });
   } else {
    oForm.addEventListener("submit", function() {
     DisableForm(this);
    }, false);
   }
  }
 }
}
var dForm = "";
function DisableForm(oForm) {
 if(oForm.elements['sBtn']) {
  oForm.elements['sBtn'].disabled = true;
 } else {
  document.getElementById(oForm.name + "_sBtn").disabled = true;
 }
 dForm = oForm;
 setTimeout("dForm.disabled = true;", 100);
}
function SetForm(oForm, vPreCheck) {
 var oEls = oForm.elements;
 for(var i = 0; i < oEls.length; i++) {
  var oEl = oEls[i];
  var vRequire = oEl.getAttribute("require");
  var vValid = oEl.getAttribute("valid");
  var vRestrict = oEl.getAttribute("restrict");
  switch(oEl.type) {
   case "text":
   case "password":
    if(vRequire != null || vValid != null) {
     if(oEl.name == "check_number") {
      if(document.all) {
       oEl.attachEvent("onkeyup", CheckNumber);
      } else {
       oEl.addEventListener("keyup", CheckNumber, false);
      }
     }
     if(document.all) {
      oEl.attachEvent("onkeyup", function() {
       if(String(window.event.srcElement.getAttribute('unique')) == "yes") {
        CheckUniqueField(window.event.srcElement);
       }
       CheckForm(window.event.srcElement.form);
      }, false);
      oEl.attachEvent("onblur", function() {
       FilterSpace(window.event.srcElement);
       if(String(window.event.srcElement.getAttribute('unique')) == "yes") {
        CheckUniqueField(window.event.srcElement);
       }
       CheckForm(window.event.srcElement.form);
      }, false);
     } else {
      oEl.addEventListener("keyup", function() {
       if(String(this.getAttribute('unique')) == "yes") {
        CheckUniqueField(this);
       }
       CheckForm(this.form);
      }, false);
      oEl.addEventListener("blur", function() {
       FilterSpace(this);
       if(String(this.getAttribute('unique')) == "yes") {
        CheckUniqueField(this);
       }
       CheckForm(this.form);
      }, false);
     }
    }
    if(vRestrict != null) {
     switch(String(vRestrict)) {
      case "integer":
        oEl.onkeypress = RestrictInteger;
      break;
      case "float":
        oEl.onkeypress = RestrictFloat;
      break;
     }
    }
   break;
   case "select-one":
    if(vRequire != null) {
     if(document.all) {
      oEl.attachEvent("onchange", function() {
       CheckForm(window.event.srcElement.form);
      });
     } else {
      oEl.addEventListener("change", function() {
       CheckForm(this.form);
      }, false);
     }
    }
   break;
   case "checkbox":
    if(vRequire != null) {
     if(document.all) {
      oEl.attachEvent("onclick", function() {
       CheckForm(window.event.srcElement.form);
      });
     } else {
      oEl.addEventListener("click", function() {
       CheckForm(this.form);
      }, false);
     }
    }
   break;
   case "hidden":
    if(vRequire != null) {
     if(document.all) {
      oEl.attachEvent("onpropertychange", function() {
       CheckForm(window.event.srcElement.form);
      });
     } else {
      oEl.addEventListener("propertychange", function() {
       CheckForm(this.form);
      }, false);
     }
    }
   break;
  }
 }
 if(vPreCheck == "precheck") {
  CheckForm(oForm);
 }
}
function CheckForm(oForm) {
 if(!oForm) {
  var oForm = window.event.srcElement.form;
 }
 var oEls = oForm.elements;
 var vOk = false;
 for(var i = 0; i < oEls.length; i++) {
  var oEl = oEls[i];
  var vRequire = oEl.getAttribute("require");
  var vValid = oEl.getAttribute("valid");
  var vOr = oEl.getAttribute("or");
  if(vRequire != null) {
   switch(oEl.type) {
    case "text":
    case "password":
    case "select-one":
     if(vOr) {
      vOk = (CheckElement(oEl) || CheckElement(oForm.elements[vOr])) ? vOk : true;
     } else {
      vOk = (CheckElement(oEl)) ? vOk : true;
     }
    break;
    case "checkbox":
     vOk = (CheckCheckbox(oEl)) ? vOk : true;
    break;
    case "hidden":
     vOk = (CheckHidden(oEl)) ? vOk : true;
    break;
   }
  }
 }
 if(oForm.elements['sBtn']) {
  var Submit = oForm.elements['sBtn'];
 } else if(document.getElementById(oForm.name + "_sBtn")) {
  var Submit = document.getElementById(oForm.name + "_sBtn");
 }
 if(oForm.disabled != true) {
  Submit.disabled = vOk;
  if(document.getElementById(oForm.name + "_standard_error_msg")) {
   if(vOk) {
    document.getElementById(oForm.name + "_standard_error_msg").style.display = "inline";
   } else {
    document.getElementById(oForm.name + "_standard_error_msg").style.display = "none";
   }
  }
 } else {
  Submit.disabled = true;
 }
}
function CheckElement(oEl) {
 var vOk = false;
 if(!oEl) {
  var oEl = window.event.srcElement;
 }
 var vState = parseInt(oEl.form.getAttribute("state"));
 var vRequire = parseInt(oEl.getAttribute("require"));
 var vValid = String(oEl.getAttribute("valid"));
 var vUnique = String(oEl.getAttribute("unique"));
 var vRestrict = String(oEl.getAttribute("restrict"));
 var vAvaible = String(oEl.getAttribute("avaible"));
 var vOkClassName = oEl.className.replace(/\_w$/, "");
 var vErrorClassName = oEl.className.replace(/\_w$/, "") + "_w";
 switch(String(vValid)) {
  case "username":
   if(vAvaible == vUnique && oEl.value.length >= vRequire && ValidUsername(oEl.value)) {
    oEl.className = vOkClassName;
    vOk = true;
    if(!document.getElementById(oEl.form.name + "_error") && vState) {
     SetState(oEl, "ok");
    }
   } else {
    oEl.className = (oEl.value.length > 0) ? vErrorClassName : vOkClassName;
    if(oEl.value.length > 0 && vState) {
     SetState(oEl, "error");
    } else if(oEl.value.length == 0 && vState) {
     SetState(oEl, "required");
    }
   }
  break;
  case "email":
   if(vAvaible == vUnique && (ValidEmail(oEl.value) || oEl.value.length == 0) && oEl.value.length >= vRequire) {
    oEl.className = vOkClassName;
    vOk = true;
    if(vState) {
     SetState(oEl, "ok");
    }
   } else {
    oEl.className = (oEl.value.length > 0) ? vErrorClassName : vOkClassName;
    if(vAvaible == "no" && vUnique == "yes" && ValidEmail(oEl.value) && oEl.value.length > 0 && vState) {
     SetState(oEl, "taken");
    } else if(oEl.value.length > 0 && vState) {
     SetState(oEl, "error");
    } else if(oEl.value.length == 0 && vState) {
     SetState(oEl, "required");
    }
   }
  break;
  case "password":
   if(oEl.value.length >= vRequire && ValidPassword(oEl.value)) {
    oEl.className = vOkClassName;
    vOk = true;
    if(vState) {
     SetState(oEl, "ok");
    }
   } else {
    oEl.className = (oEl.value.length > 0) ? vErrorClassName : vOkClassName;
    if(oEl.value.length > 0 && vState) {
     SetState(oEl, "error");
    } else if(oEl.value.length == 0 && vState) {
     SetState(oEl, "required");
    }
   }
  break;
  case "re-password":
   if(oEl.value == oEl.form.elements['password'].value) {
    oEl.className = vOkClassName;
    vOk = true;
    if(vState) {
     SetState(oEl, "ok");
    }
   } else {
    oEl.className = (oEl.value.length > 0) ? vErrorClassName : vOkClassName;
    if(oEl.value.length > 0 && vState) {
     SetState(oEl, "error");
    } else if(oEl.value.length == 0 && vState) {
     SetState(oEl, "required");
    }
   }
  break;
  case "date":
   if(oEl.value.length >= vRequire && ValidDate(oEl.value)) {
    oEl.className = vOkClassName;
    vOk = true;
    if(vState) {
     SetState(oEl, "ok");
    }
   } else {
    oEl.className = (oEl.value.length > 0) ? vErrorClassName : vOkClassName;
    if(oEl.value.length > 0 && vState) {
     SetState(oEl, "error");
    } else if(oEl.value.length == 0 && vState) {
     SetState(oEl, "required");
    }
   }
  break;
  case "pdate":
   if(oEl.value.length >= vRequire && ValidPastDate(oEl.value) || oEl.disabled) {
    oEl.className = vOkClassName;
    vOk = true;
    if(vState) {
     SetState(oEl, "ok");
    }
   } else {
    oEl.className = (oEl.value.length > 0) ? vErrorClassName : vOkClassName;
    if(oEl.value.length > 0 && vState) {
     SetState(oEl, "error");
    } else if(oEl.value.length == 0 && vState) {
     SetState(oEl, "required");
    }
   }
  break;
  case "fdate":
   if(oEl.value.length >= vRequire && ValidFutureDate(oEl.value) || oEl.disabled) {
    oEl.className = vOkClassName;
    vOk = true;
    if(vState) {
     SetState(oEl, "ok");
    }
   } else {
    oEl.className = (oEl.value.length > 0) ? vErrorClassName : vOkClassName;
    if(oEl.value.length > 0 && vState) {
     SetState(oEl, "error");
    } else if(oEl.value.length == 0 && vState) {
     SetState(oEl, "required");
    }
   }
  break;
  default:
   if(vAvaible == vUnique && oEl.value.length >= vRequire) {
    oEl.className = vOkClassName;
    vOk = true;
    if(vState) {
     SetState(oEl, "ok");
    }
   } else {
    oEl.className = (oEl.value.length > 0) ? vErrorClassName : vOkClassName;
    if(oEl.value.length > 0 && vState) {
     SetState(oEl, "error");
    } else if(oEl.value.length == 0 && vState) {
     SetState(oEl, "required");
    }
   }
  break;
 }
 switch(vRestrict) {
  case "integer":
   FilterInteger(oEl);
  break;
  case "float":
   FilterFloat(oEl);
  break;
 }
 return vOk;
}
function CheckCheckbox(oEl) {
 var vOk = false;
 var vState = oEl.form.getAttribute("state");
 var vRequire = oEl.getAttribute("require");
 switch(String(vRequire)) {
  case "yes":
   if(oEl.checked == true) {
    vOk = true;
    if(vState) {
     SetState(oEl, "ok");
    }
   } else {
    if(vState) {
     SetState(oEl, "required");
    }
   }
  break;
 }
 return vOk;
}
function CheckHidden(oEl) {
 var vOk = false;
 var vState = oEl.form.getAttribute("state");
 var vRequire = oEl.getAttribute("require");
 if(oEl.value.length >= parseInt(vRequire)) {
  vOk = true;
  if(vState) {
   SetState(oEl, "ok");
  }
 } else {
  if(oEl.value.length > 0 && vState) {
   SetState(oEl, "error");
  } else if(oEl.value.length == 0 && vState) {
   SetState(oEl, "required");
  }
 }
 return vOk;
}
function RestrictInteger(oEvt) {
 if(!oEvt) {
  var oEvt = window.event;
 }
 var Keycode = oEvt.keyCode ? String.fromCharCode(oEvt.keyCode) : String.fromCharCode(oEvt.which);
 switch(Keycode) {
  case "0":
  case "1":
  case "2":
  case "3":
  case "4":
  case "5":
  case "6":
  case "7":
  case "8":
  case "9":
  break;
  default:
   if(oEvt.keyCode != 9 && oEvt.keyCode != 13 && oEvt.keyCode != 8 && oEvt.keyCode != 46 && oEvt.keyCode != 37 && oEvt.keyCode != 39) {
    return false;
   }
  break;
 }
}
function RestrictFloat(oEvt) {
 if(!oEvt) {
  var oEvt = window.event;
 }
 var Keycode = oEvt.keyCode ? String.fromCharCode(oEvt.keyCode) : String.fromCharCode(oEvt.which);
 switch(Keycode) {
  case "0":
  case "1":
  case "2":
  case "3":
  case "4":
  case "5":
  case "6":
  case "7":
  case "8":
  case "9":
  case ".":
  case ",":
  break;
  default:
   if(oEvt.keyCode != 9 && oEvt.keyCode != 13 && oEvt.keyCode != 8 && oEvt.keyCode != 46 && oEvt.keyCode != 37 && oEvt.keyCode != 39) {
    return false;
   }
  break;
 }
}
function FilterSpace(oObj) {
 oObj.value = oObj.value.replace(/^\s+|\s+$/g, "");
 oObj.value = oObj.value.replace(/[\s]{2,}/g, " ");
}
function FilterInteger(oObj) {
 oObj.value = oObj.value.replace(/[^0-9]/g, "");
}
function FilterFloat(oObj) {
 oObj.value = oObj.value.replace(/[\.]{2,}|[\,]{1,}/g, ".");
 oObj.value = oObj.value.replace(/[^0-9\.]/g, "");
}
function ValidUsername(vUsername) {
 if(vUsername == vUsername.replace(/([^0-9a-zA-Z\_\[\]\s\-]|[\t\n])/g, "")) {
  return true;
 } else {
  return false;
 }
}
function ValidEmail(vEmail) {
 if(vEmail.match(/^(([\-\w]+)\.?){0,}([\-\w]+)@(([\-\w]+)\.?)+\.[a-zA-Z]{2,4}$/)) {
  return true;
 } else {
  return false;
 }
}
function ValidPassword(vPassword) {
 if(vPassword == vPassword.replace(/[^0-9a-zA-Z]/g, "") && (vPassword.length >= 6 || vPassword.length == 0)) {
  return true;
 } else {
  return false;
 }
}
function ValidDate(vDate) {
 var y = vDate.substr(0,4);
 var m = vDate.substr(4,2);
 var d = vDate.substr(6,2);
 var sDate = new Date(y + "/" + m + "/" + d);
 var mDate = new Date("1960/01/01");
 if(sDate >= mDate && sDate.getFullYear() == y && sDate.getMonth() == m-1 && sDate.getDate() == d) {
  return true;
 } else {
  return false;
 }
}
function ValidPastDate(vDate) {
 var y = vDate.substr(0,4);
 var m = vDate.substr(4,2);
 var d = vDate.substr(6,2);
 var sDate = new Date(y + "/" + m + "/" + d);
 var cDate = new Date();
 var mDate = new Date("1900/01/01");
 cDate.setTime((parseInt(cDate / 1000 / 3600 / 24) + cDate.getTimezoneOffset() / 60 / 24) * 1000 * 3600 * 24);
 if(sDate >= mDate && sDate <= cDate && sDate.getFullYear() == y && sDate.getMonth() == m-1 && sDate.getDate() == d) {
  return true;
 } else {
  return false;
 }
}
function ValidFutureDate(vDate) {
 var y = vDate.substr(0,4);
 var m = vDate.substr(4,2);
 var d = vDate.substr(6,2);
 var sDate = new Date(y + "/" + m + "/" + d);
 var cDate = new Date();
 cDate.setTime((parseInt(cDate / 1000 / 3600 / 24) + cDate.getTimezoneOffset() / 60 / 24) * 1000 * 3600 * 24);
 if(sDate >= cDate && sDate.getFullYear() == y && sDate.getMonth() == m-1 && sDate.getDate() == d) {
  return true;
 } else {
  return false;
 }
}
function SetState(oObj, vState) {
 if(document.getElementById(oObj.id + "_state_required")) {
  document.getElementById(oObj.id + "_state_required").style.display = "none";
 }
 if(document.getElementById(oObj.id + "_state_taken")) {
  document.getElementById(oObj.id + "_state_taken").style.display = "none";
 }
 if(document.getElementById(oObj.id + "_state_error")) {
  document.getElementById(oObj.id + "_state_error").style.display = "none";
 }
 if(document.getElementById(oObj.id + "_state_ok")) {
  document.getElementById(oObj.id + "_state_ok").style.display = "none";
 }
 if(document.getElementById(oObj.id + "_state_" + vState)) {
  document.getElementById(oObj.id + "_state_" + vState).style.display = "";
 }
}
function GeneratePassword(id) {
 var vLetters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 var vPass = "";
 for(var i = 0; i < 10; i++) {
  vPass += vLetters.substr(parseInt(Math.random() * vLetters.length), 1);
 }
 document.getElementById(id).value = vPass;
}
var hs = {
graphicsDir : 'images/highslide/',
restoreCursor : 'zoomout.cur',
expandSteps : 10,
expandDuration : 250,
restoreSteps : 10,
restoreDuration : 250,
marginLeft : 15,
marginRight : 15,
marginTop : 15,
marginBottom : 15,
zIndexCounter : 1001,
restoreTitle : 'Click to close image, click and drag to move. Use arrow keys for next and previous.',
loadingText : 'Loading...',
loadingTitle : 'Click to cancel',
loadingOpacity : 0.75,
focusTitle : 'Click to bring to front',
allowMultipleInstances: true,
numberOfImagesToPreload : 5,
captionSlideSpeed : 1,
padToMinWidth : false,
outlineWhileAnimating : 2,
outlineStartOffset : 3,
fullExpandTitle : 'Expand to actual size',
fullExpandPosition : 'bottom right',
fullExpandOpacity : 1,
showCredits : false,
creditsText : 'Powered by <i>Highslide JS</i>',
creditsHref : 'http://vikjavev.no/highslide/',
creditsTitle : 'Go to the Highslide JS homepage',
enableKeyListener : true,
captionId : null,
spaceForCaption : 30,
slideshowGroup : null,
minWidth: 200,
minHeight: 200,
allowSizeReduction: true,
outlineType : 'drop-shadow',
wrapperClassName : 'highslide-wrapper',
preloadTheseImages : [],
continuePreloading: true,
expanders : [],
overrides : [
 'allowSizeReduction',
 'outlineType',
 'outlineWhileAnimating',
 'spaceForCaption',
 'captionId',
 'captionText',
 'captionEval',
 'wrapperClassName',
 'minWidth',
 'minHeight',
 'slideshowGroup',
 'easing',
 'easingClose',
 'fadeInOut'
],
overlays : [],
idCounter : 0,
faders : [],
pendingOutlines : {},
clones : {},
ie : (document.all && !window.opera),
safari : /Safari/.test(navigator.userAgent),
geckoMac : /Macintosh.+rv:1\.[0-8].+Gecko/.test(navigator.userAgent),
$ : function (id) {
 return document.getElementById(id);
},
push : function (arr, val) {
 arr[arr.length] = val;
},
createElement : function (tag, attribs, styles, parent, nopad) {
 var el = document.createElement(tag);
 if (attribs) hs.setAttribs(el, attribs);
 if (nopad) hs.setStyles(el, {padding: 0, border: 'none', margin: 0});
 if (styles) hs.setStyles(el, styles);
 if (parent) parent.appendChild(el);
 return el;
},
setAttribs : function (el, attribs) {
 for (var x in attribs) el[x] = attribs[x];
},
setStyles : function (el, styles) {
 for (var x in styles) {
  try {
   if (hs.ie && x == 'opacity') {
    if (styles[x] > 0.99) el.style.removeAttribute('filter');
    else el.style.filter = 'alpha(opacity='+ (styles[x] * 100) +')';
   }
   else el.style[x] = styles[x];
  }
  catch (e) {}
 }
},
ieVersion : function () {
 var arr = navigator.appVersion.split("MSIE");
 return arr[1] ? parseFloat(arr[1]) : null;
},
getPageSize : function () {
 var iebody = document.compatMode && document.compatMode != "BackCompat"
  ? document.documentElement : document.body;
 var width = hs.ie ? iebody.clientWidth :
   (document.documentElement.clientWidth || self.innerWidth),
  height = hs.ie ? iebody.clientHeight : self.innerHeight;
 return {
  width: width,
  height: height,
  scrollLeft: hs.ie ? iebody.scrollLeft : pageXOffset,
  scrollTop: hs.ie ? iebody.scrollTop : pageYOffset
 }
},
position : function(el) {
 var p = { x: el.offsetLeft, y: el.offsetTop };
 while (el.offsetParent) {
  el = el.offsetParent;
  p.x += el.offsetLeft;
  p.y += el.offsetTop;
  if (el != document.body && el != document.documentElement) {
   p.x -= el.scrollLeft;
   p.y -= el.scrollTop;
  }
 }
 return p;
},
expand : function(a, params, custom) {
 if (a.getParams) return params;
 try {
  new hs.Expander(a, params, custom);
  return false;
 } catch (e) { return true; }
},
focusTopmost : function() {
 var topZ = 0, topmostKey = -1;
 for (var i = 0; i < hs.expanders.length; i++) {
  if (hs.expanders[i]) {
   if (hs.expanders[i].wrapper.style.zIndex && hs.expanders[i].wrapper.style.zIndex > topZ) {
    topZ = hs.expanders[i].wrapper.style.zIndex;
    topmostKey = i;
   }
  }
 }
 if (topmostKey == -1) hs.focusKey = -1;
 else hs.expanders[topmostKey].focus();
},
getAdjacentAnchor : function(key, op) {
 var aAr = document.getElementsByTagName('A'), hsAr = {}, activeI = -1, j = 0;
 for (var i = 0; i < aAr.length; i++) {
  if (hs.isHsAnchor(aAr[i]) && ((hs.expanders[key].slideshowGroup
    == hs.getParam(aAr[i], 'slideshowGroup')))) {
   hsAr[j] = aAr[i];
   if (hs.expanders[key] && aAr[i] == hs.expanders[key].a) {
    activeI = j;
   }
   j++;
  }
 }
 return hsAr[activeI + op] || null;
},
getParam : function (a, param) {
 a.getParams = a.onclick;
 var p = a.getParams ? a.getParams() : null;
 a.getParams = null;
 return (p && typeof p[param] != 'undefined') ? p[param] :
  (typeof hs[param] != 'undefined' ? hs[param] : null);
},
getSrc : function (a) {
 var src = hs.getParam(a, 'src');
 if (src) return src;
 return a.href;
},
getNode : function (id) {
 var node = hs.$(id), clone = hs.clones[id], a = {};
 if (!node && !clone) return null;
 if (!clone) {
  clone = node.cloneNode(true);
  clone.id = '';
  hs.clones[id] = clone;
  return node;
 } else {
  return clone.cloneNode(true);
 }
},
purge : function(d) {
 var a = d.attributes, i, l, n;
 if (a) {
  l = a.length;
  for (var i = 0; i < l; i += 1) {
   n = a[i].name;
   if (typeof d[n] === 'function') {
    d[n] = null;
   }
  }
 }
 a = d.childNodes;
 if (a) {
  l = a.length;
  for (var i = 0; i < l; i += 1) hs.purge(d.childNodes[i]);
 }
},
discardElement : function(d) {
 if (hs.ie) hs.purge(d);
 hs.garbageBin.appendChild(d);
 hs.garbageBin.innerHTML = '';
},
previousOrNext : function (el, op) {
 var exp = hs.last = hs.getExpander(el);
 try {
  var adj = hs.upcoming =  hs.getAdjacentAnchor(exp.key, op);
  adj.onclick();
 } catch (e){}
 try { exp.close(); } catch (e) {}
 return false;
},
previous : function (el) {
 return hs.previousOrNext(el, -1);
},
next : function (el) {
 return hs.previousOrNext(el, 1);
},
keyHandler : function(e) {
 if (!e) e = window.event;
 if (!e.target) e.target = e.srcElement;
 if (e.target.form) return true;
 var op = null;
 switch (e.keyCode) {
  case 32:
  case 34:
  case 39:
  case 40:
   op = 1;
   break;
  case 8:
  case 33:
  case 37:
  case 38:
   op = -1;
   break;
  case 27:
  case 13:
   op = 0;
 }
 if (op !== null) {
  hs.removeEventListener(document, 'keydown', hs.keyHandler);
  if (!hs.enableKeyListener) return true;
  if (e.preventDefault) e.preventDefault();
     else e.returnValue = false;
  if (op == 0) {
   try { hs.getExpander().close(); } catch (e) {}
   return false;
  } else {
   return hs.previousOrNext(hs.focusKey, op);
  }
 }
 return true;
},
registerOverlay : function (overlay) {
 hs.push(hs.overlays, overlay);
},
getWrapperKey : function (element) {
 var el, re = /^highslide-wrapper-([0-9]+)$/;
 el = element;
 while (el.parentNode) {
  if (el.id && re.test(el.id)) return el.id.replace(re, "$1");
  el = el.parentNode;
 }
 el = element;
 while (el.parentNode) {
  if (el.tagName && hs.isHsAnchor(el)) {
   for (var key = 0; key < hs.expanders.length; key++) {
    var exp = hs.expanders[key];
    if (exp && exp.a == el) return key;
   }
  }
  el = el.parentNode;
 }
 return null;
},
getExpander : function (el) {
 if (typeof el == 'undefined') return hs.expanders[hs.focusKey] || null;
 if (typeof el == 'number') return hs.expanders[el] || null;
 if (typeof el == 'string') el = hs.$(el);
 return hs.expanders[hs.getWrapperKey(el)] || null;
},
isHsAnchor : function (a) {
 return (a.onclick && a.onclick.toString().replace(/\s/g, ' ').match(/hs.(htmlE|e)xpand/));
},
reOrder : function () {
 for (var i = 0; i < hs.expanders.length; i++)
  if (hs.expanders[i] && hs.expanders[i].isExpanded) hs.focusTopmost();
},
mouseClickHandler : function(e)
{
 if (!e) e = window.event;
 if (e.button > 1) return true;
 if (!e.target) e.target = e.srcElement;
 var el = e.target;
 while (el.parentNode
  && !(/highslide-(image|move|html|resize)/.test(el.className)))
 {
  el = el.parentNode;
 }
 var exp = hs.getExpander(el);
 if (exp && (exp.isClosing || !exp.isExpanded)) return true;
 if (exp && e.type == 'mousedown') {
  if (e.target.form) return true;
  var match = el.className.match(/highslide-(image|move|resize)/);
  if (match) {
   hs.dragArgs = { exp: exp , type: match[1], left: exp.x.min, width: exp.x.span, top: exp.y.min,
    height: exp.y.span, clickX: e.clientX, clickY: e.clientY };
   hs.addEventListener(document, 'mousemove', hs.dragHandler);
   if (e.preventDefault) e.preventDefault();
   if (/highslide-(image|html)-blur/.test(exp.content.className)) {
    exp.focus();
    hs.hasFocused = true;
   }
   return false;
  }
 } else if (e.type == 'mouseup') {
  hs.removeEventListener(document, 'mousemove', hs.dragHandler);
  if (hs.dragArgs) {
   if (hs.dragArgs.type == 'image')
    hs.dragArgs.exp.content.style.cursor = hs.styleRestoreCursor;
   var hasDragged = hs.dragArgs.hasDragged;
   if (!hasDragged &&!hs.hasFocused && !/(move|resize)/.test(hs.dragArgs.type)) {
    exp.close();
   }
   else if (hasDragged || (!hasDragged && hs.hasHtmlexpanders)) {
    hs.dragArgs.exp.redoShowHide();
   }
   hs.hasFocused = false;
   hs.dragArgs = null;
  } else if (/highslide-image-blur/.test(el.className)) {
   el.style.cursor = hs.styleRestoreCursor;
  }
 }
 return false;
},
dragHandler : function(e)
{
 if (!hs.dragArgs) return true;
 if (!e) e = window.event;
 var a = hs.dragArgs, exp = a.exp;
 a.dX = e.clientX - a.clickX;
 a.dY = e.clientY - a.clickY;
 var distance = Math.sqrt(Math.pow(a.dX, 2) + Math.pow(a.dY, 2));
 if (!a.hasDragged) a.hasDragged = (a.type != 'image' && distance > 0)
  || (distance > (hs.dragSensitivity || 5));
 if (a.hasDragged && e.clientX > 5 && e.clientY > 5) {
   exp.move(a);
 }
 return false;
},
wrapperMouseHandler : function (e) {
 try {
  if (!e) e = window.event;
  var over = /mouseover/i.test(e.type);
  if (!e.target) e.target = e.srcElement;
  if (hs.ie) e.relatedTarget =
   over ? e.fromElement : e.toElement;
  var exp = hs.getExpander(e.target);
  if (!exp || !e.relatedTarget || hs.getExpander(e.relatedTarget) == exp
   || hs.dragArgs) return;
  for (var i = 0; i < exp.overlays.length; i++) {
   var o = hs.$('hsId'+ exp.overlays[i]);
   if (o && o.getAttribute('hideOnMouseOut')) {
    var from = over ? 0 : o.getAttribute('opacity'),
     to = over ? o.getAttribute('opacity') : 0;
    hs.fade(o, from, to);
   }
  }
 } catch (e) {}
},
addEventListener : function (el, event, func) {
 try {
  el.addEventListener(event, func, false);
 } catch (e) {
  try {
   el.detachEvent('on'+ event, func);
   el.attachEvent('on'+ event, func);
  } catch (e) {
   el['on'+ event] = func;
  }
 }
},
removeEventListener : function (el, event, func) {
 try {
  el.removeEventListener(event, func, false);
 } catch (e) {
  try {
   el.detachEvent('on'+ event, func);
  } catch (e) {
   el['on'+ event] = null;
  }
 }
},
preloadFullImage : function (i) {
 if (hs.continuePreloading && hs.preloadTheseImages[i] && hs.preloadTheseImages[i] != 'undefined') {
  var img = document.createElement('img');
  img.onload = function() {
   img = null;
   hs.preloadFullImage(i + 1);
  };
  img.src = hs.preloadTheseImages[i];
 }
},
preloadImages : function (number) {
 if (number && typeof number != 'object') hs.numberOfImagesToPreload = number;
 var a, re, j = 0;
 var aTags = document.getElementsByTagName('A');
 for (var i = 0; i < aTags.length; i++) {
  a = aTags[i];
  re = hs.isHsAnchor(a);
  if (re && re[0] == 'hs.expand') {
   if (j < hs.numberOfImagesToPreload) {
    hs.preloadTheseImages[j] = hs.getSrc(a);
    j++;
   }
  }
 }
 new hs.Outline(hs.outlineType, function () { hs.preloadFullImage(0)} );
 var cur = hs.createElement('img', { src: hs.graphicsDir + hs.restoreCursor });
},
genContainer : function () {
 if (!hs.container) {
  hs.container = hs.createElement('div',
   null,
   { position: 'absolute', left: 0, top: 0, width: '100%', zIndex: hs.zIndexCounter },
   document.body,
   true
  );
  hs.loading = hs.createElement('a',
   {
    className: 'highslide-loading',
    title: hs.loadingTitle,
    innerHTML: hs.loadingText,
    href: 'javascript:void(0)'
   },
   {
    position: 'absolute',
    opacity: hs.loadingOpacity,
    left: '-9999px',
    zIndex: 1
   }, hs.container
  );
  hs.garbageBin = hs.createElement('div', null, { display: 'none' }, hs.container);
  Math.linearTween = function (t, b, c, d) {
   return c*t/d + b;
  };
  Math.easeInQuad = function (t, b, c, d) {
   return c*(t/=d)*t + b;
  };
 }
},
fade : function (el, o, oFinal, dur, i, dir) {
 if (typeof i == 'undefined') {
  if (typeof dur != 'number') dur = 250;
  if (dur < 25) {
   hs.setStyles( el, { opacity: oFinal });
   return;
  }
  i = hs.faders.length;
  dir = oFinal > o ? 1 : -1;
  var step = (25 / (dur - dur % 25)) * Math.abs(o - oFinal);
 }
 o = parseFloat(o);
 el.style.visibility = (o <= 0) ? 'hidden' : 'visible';
 if (o < 0 || (dir == 1 && o > oFinal)) return;
 if (el.fading && el.fading.i != i) {
  clearTimeout(hs.faders[el.fading.i]);
  o = el.fading.o;
 }
 el.fading = {i: i, o: o, step: (step || el.fading.step)};
 el.style.visibility = (o <= 0) ? 'hidden' : 'visible';
 hs.setStyles(el, { opacity: o });
 hs.faders[i] = setTimeout(function() {
  hs.fade(el, o + el.fading.step * dir, oFinal, null, i, dir);
 }, 25);
},
close : function(el) {
 var exp = hs.getExpander(el);
 if (exp) exp.close();
 return false;
}
};
hs.Outline =  function (outlineType, onLoad) {
 this.onLoad = onLoad;
 this.outlineType = outlineType;
 var v = hs.ieVersion(), tr;
 this.hasAlphaImageLoader = hs.ie && v >= 5.5 && v < 7;
 if (!outlineType) {
  if (onLoad) onLoad();
  return;
 }
 hs.genContainer();
 this.table = hs.createElement(
  'table', { cellSpacing: 0 },
  {
   visibility: 'hidden',
   position: 'absolute',
   borderCollapse: 'collapse'
  },
  hs.container,
  true
 );
 var tbody = hs.createElement('tbody', null, null, this.table, 1);
 this.td = [];
 for (var i = 0; i <= 8; i++) {
  if (i % 3 == 0) tr = hs.createElement('tr', null, { height: 'auto' }, tbody, true);
  this.td[i] = hs.createElement('td', null, null, tr, true);
  var style = i != 4 ? { lineHeight: 0, fontSize: 0} : { position : 'relative' };
  hs.setStyles(this.td[i], style);
 }
 this.td[4].className = outlineType;
 this.preloadGraphic();
};
hs.Outline.prototype = {
preloadGraphic : function () {
 var src = hs.graphicsDir + (hs.outlinesDir || "outlines/")+ this.outlineType +".png";
 var appendTo = hs.safari ? hs.container : null;
 this.graphic = hs.createElement('img', null, { position: 'absolute', left: '-9999px',
  top: '-9999px' }, appendTo, true);
 var pThis = this;
 this.graphic.onload = function() { pThis.onGraphicLoad(); };
 this.graphic.src = src;
},
onGraphicLoad : function () {
 var o = this.offset = this.graphic.width / 4,
  pos = [[0,0],[0,-4],[-2,0],[0,-8],0,[-2,-8],[0,-2],[0,-6],[-2,-2]],
  dim = { height: (2*o) +'px', width: (2*o) +'px' };
 for (var i = 0; i <= 8; i++) {
  if (pos[i]) {
   if (this.hasAlphaImageLoader) {
    var w = (i == 1 || i == 7) ? '100%' : this.graphic.width +'px';
    var div = hs.createElement('div', null, { width: '100%', height: '100%', position: 'relative', overflow: 'hidden'}, this.td[i], true);
    hs.createElement ('div', null, {
      filter: "progid:DXImageTransform.Microsoft.AlphaImageLoader(sizingMethod=scale, src='"+ this.graphic.src + "')",
      position: 'absolute',
      width: w,
      height: this.graphic.height +'px',
      left: (pos[i][0]*o)+'px',
      top: (pos[i][1]*o)+'px'
     },
    div,
    true);
   } else {
    hs.setStyles(this.td[i], { background: 'url('+ this.graphic.src +') '+ (pos[i][0]*o)+'px '+(pos[i][1]*o)+'px'});
   }
   if (window.opera && (i == 3 || i ==5))
    hs.createElement('div', null, dim, this.td[i], true);
   hs.setStyles (this.td[i], dim);
  }
 }
 this.graphic = null;
 if (hs.pendingOutlines[this.outlineType]) hs.pendingOutlines[this.outlineType].destroy();
 hs.pendingOutlines[this.outlineType] = this;
 if (this.onLoad) this.onLoad();
},
setPosition : function (exp, x, y, w, h, vis) {
 if (vis) this.table.style.visibility = (h >= 4 * this.offset)
  ? 'visible' : 'hidden';
 this.table.style.left = (x - this.offset) +'px';
 this.table.style.top = (y - this.offset) +'px';
 this.table.style.width = (w + 2 * (exp.offsetBorderW + this.offset)) +'px';
 w += 2 * (exp.offsetBorderW - this.offset);
 h += + 2 * (exp.offsetBorderH - this.offset);
 this.td[4].style.width = w >= 0 ? w +'px' : 0;
 this.td[4].style.height = h >= 0 ? h +'px' : 0;
 if (this.hasAlphaImageLoader) this.td[3].style.height
  = this.td[5].style.height = this.td[4].style.height;
},
destroy : function(hide) {
 if (hide) this.table.style.visibility = 'hidden';
 else hs.discardElement(this.table);
}
};
hs.Expander = function(a, params, custom, contentType) {
 this.a = a;
 this.custom = custom;
 this.contentType = contentType || 'image';
 this.isImage = !this.isHtml;
 hs.continuePreloading = false;
 hs.genContainer();
 var key = this.key = hs.expanders.length;
 for (var i = 0; i < hs.overrides.length; i++) {
  var name = hs.overrides[i];
  this[name] = params && typeof params[name] != 'undefined' ?
   params[name] : hs[name];
 }
 var el = this.thumb = ((params && params.thumbnailId) ? hs.$(params.thumbnailId) : null)
  || a.getElementsByTagName('img')[0] || a;
 this.thumbsUserSetId = el.id || a.id;
 for (var i = 0; i < hs.expanders.length; i++) {
  if (hs.expanders[i] && hs.expanders[i].a == a) {
   hs.expanders[i].focus();
   return false;
  }
 }
 for (var i = 0; i < hs.expanders.length; i++) {
  if (hs.expanders[i] && hs.expanders[i].thumb != el && !hs.expanders[i].onLoadStarted) {
   hs.expanders[i].cancelLoading();
  }
 }
 hs.expanders[this.key] = this;
 if (!hs.allowMultipleInstances) {
  if (hs.expanders[key-1]) hs.expanders[key-1].close();
  if (typeof hs.focusKey != 'undefined' && hs.expanders[hs.focusKey])
   hs.expanders[hs.focusKey].close();
 }
 var pos = hs.position(el);
 this.thumbWidth = el.width ? el.width : el.offsetWidth;
 this.thumbHeight = el.height ? el.height : el.offsetHeight;
 this.thumbLeft = pos.x;
 this.thumbTop = pos.y;
 this.thumbOffsetBorderW = (this.thumb.offsetWidth - this.thumbWidth) / 2;
 this.thumbOffsetBorderH = (this.thumb.offsetHeight - this.thumbHeight) / 2;
 this.wrapper = hs.createElement(
  'div',
  {
   id: 'highslide-wrapper-'+ this.key,
   className: this.wrapperClassName
  },
  {
   visibility: 'hidden',
   position: 'absolute',
   zIndex: hs.zIndexCounter++
  }, null, true );
 this.wrapper.onmouseover = this.wrapper.onmouseout = hs.wrapperMouseHandler;
 if (this.contentType == 'image' && this.outlineWhileAnimating == 2)
  this.outlineWhileAnimating = 0;
 if (hs.pendingOutlines[this.outlineType]) {
  this.connectOutline();
  this[this.contentType +'Create']();
 } else if (!this.outlineType) {
  this[this.contentType +'Create']();
 } else {
  this.displayLoading();
  var exp = this;
  new hs.Outline(this.outlineType,
   function () {
    exp.connectOutline();
    exp[exp.contentType +'Create']();
   }
  );
 }
 return true;
};
hs.Expander.prototype = {
connectOutline : function(x, y) {
 var w = hs.pendingOutlines[this.outlineType];
 this.objOutline = w;
 w.table.style.zIndex = this.wrapper.style.zIndex;
 hs.pendingOutlines[this.outlineType] = null;
},
displayLoading : function() {
 if (this.onLoadStarted || this.loading) return;
 this.originalCursor = this.a.style.cursor;
 this.a.style.cursor = 'wait';
 this.loading = hs.loading;
 var exp = this;
 this.loading.onclick = function() {
  exp.cancelLoading();
 };
 this.loading.style.top = (this.thumbTop
  + (this.thumbHeight - this.loading.offsetHeight) / 2) +'px';
 var exp = this, left = (this.thumbLeft + this.thumbOffsetBorderW
  + (this.thumbWidth - this.loading.offsetWidth) / 2) +'px';
 setTimeout(function () { if (exp.loading) exp.loading.style.left = left }, 100);
},
imageCreate : function() {
 var exp = this;
 var img = document.createElement('img');
    this.content = img;
    img.onload = function () {
     if (hs.expanders[exp.key]) exp.contentLoaded();
 };
    if (hs.blockRightClick) img.oncontextmenu = function() { return false; };
    img.className = 'highslide-image';
    img.style.visibility = 'hidden';
    img.style.display = 'block';
 img.style.position = 'absolute';
 img.style.maxWidth = 'none';
    img.style.zIndex = 3;
    img.title = hs.restoreTitle;
    if (hs.safari) hs.container.appendChild(img);
    if (hs.ie && hs.flushImgSize) img.src = null;
 img.src = hs.getSrc(this.a);
 this.displayLoading();
},
contentLoaded : function() {
 try {
  if (!this.content) return;
  this.content.onload = null;
  if (this.onLoadStarted) return;
  else this.onLoadStarted = true;
  if (this.loading) {
   hs.setStyles(this.loading, { left: '-9999px', top: '-9999px' });
   this.loading = null;
   this.a.style.cursor = this.originalCursor || '';
  }
  this.marginBottom = hs.marginBottom;
   this.newWidth = this.content.width;
   this.newHeight = this.content.height;
   this.fullExpandWidth = this.newWidth;
   this.fullExpandHeight = this.newHeight;
   this.content.style.width = this.thumbWidth +'px';
   this.content.style.height = this.thumbHeight +'px';
   this.getCaption();
  this.wrapper.appendChild(this.content);
  this.content.style.position = 'relative';
  if (this.caption) this.wrapper.appendChild(this.caption);
  this.wrapper.style.left = this.thumbLeft +'px';
  this.wrapper.style.top = this.thumbTop +'px';
  hs.container.appendChild(this.wrapper);
  this.offsetBorderW = (this.content.offsetWidth - this.thumbWidth) / 2;
  this.offsetBorderH = (this.content.offsetHeight - this.thumbHeight) / 2;
  var modMarginRight = hs.marginRight + 2 * this.offsetBorderW;
  this.marginBottom += 2 * this.offsetBorderH;
  var ratio = this.newWidth / this.newHeight;
  var minWidth = this.allowSizeReduction
   ? this.minWidth : this.newWidth;
  var minHeight = this.allowSizeReduction
   ? this.minHeight : this.newHeight;
  var justify = { x: 'auto', y: 'auto' };
  var page = hs.getPageSize();
  this.x = {
   min: parseInt(this.thumbLeft) - this.offsetBorderW + this.thumbOffsetBorderW,
   span: this.newWidth,
   minSpan: (this.newWidth < minWidth && !hs.padToMinWidth)
    ? this.newWidth : minWidth,
   marginMin: hs.marginLeft,
   marginMax: modMarginRight,
   scroll: page.scrollLeft,
   clientSpan: page.width,
   thumbSpan: this.thumbWidth
  };
  var oldRight = this.x.min + parseInt(this.thumbWidth);
  this.x = this.justify(this.x);
  this.y = {
   min: parseInt(this.thumbTop) - this.offsetBorderH + this.thumbOffsetBorderH,
   span: this.newHeight,
   minSpan: this.newHeight < minHeight ? this.newHeight : minHeight,
   marginMin: hs.marginTop,
   marginMax: this.marginBottom,
   scroll: page.scrollTop,
   clientSpan: page.height,
   thumbSpan: this.thumbHeight
  };
  var oldBottom = this.y.min + parseInt(this.thumbHeight);
  this.y = this.justify(this.y);
   this.correctRatio(ratio);
  var x = this.x;
  var y = this.y;
  this.show();
 } catch (e) {
  window.location.href = hs.getSrc(this.a);
 }
},
justify : function (p) {
 var tgt, dim = p == this.x ? 'x' : 'y';
  var hasMovedMin = false;
  var allowReduce = true;
  p.min = Math.round(p.min - ((p.span - p.thumbSpan) / 2));
  if (p.min < p.scroll + p.marginMin) {
   p.min = p.scroll + p.marginMin;
   hasMovedMin = true;
  }
  if (p.span < p.minSpan) {
   p.span = p.minSpan;
   allowReduce = false;
  }
  if (p.min + p.span > p.scroll + p.clientSpan - p.marginMax) {
   if (hasMovedMin && allowReduce) {
    p.span = p.clientSpan - p.marginMin - p.marginMax;
   } else if (p.span < p.clientSpan - p.marginMin - p.marginMax) {
    p.min = p.scroll + p.clientSpan - p.span - p.marginMin - p.marginMax;
   } else {
    p.min = p.scroll + p.marginMin;
    if (allowReduce) p.span = p.clientSpan - p.marginMin - p.marginMax;
   }
  }
  if (p.span < p.minSpan) {
   p.span = p.minSpan;
   allowReduce = false;
  }
 if (p.min < p.marginMin) {
  tmpMin = p.min;
  p.min = p.marginMin;
  if (allowReduce) p.span = p.span - (p.min - tmpMin);
 }
 return p;
},
correctRatio : function(ratio) {
 var x = this.x;
 var y = this.y;
 var changed = false;
 if (x.span / y.span > ratio) {
  var tmpWidth = x.span;
  x.span = y.span * ratio;
  if (x.span < x.minSpan) {
   if (hs.padToMinWidth) x.imgSpan = x.span;
   x.span = x.minSpan;
   if (!x.imgSpan)
   y.span = x.span / ratio;
  }
  changed = true;
 } else if (x.span / y.span < ratio) {
  var tmpHeight = y.span;
  y.span = x.span / ratio;
  changed = true;
 }
 if (changed) {
  x.min = parseInt(this.thumbLeft) - this.offsetBorderW + this.thumbOffsetBorderW;
  x.minSpan = x.span;
  this.x = this.justify(x);
  y.min = parseInt(this.thumbTop) - this.offsetBorderH + this.thumbOffsetBorderH;
  y.minSpan = y.span;
  this.y = this.justify(y);
 }
},
show : function () {
 var imgPos = {x: this.x.min - 20, y: this.y.min - 20, w: this.x.span + 40,
  h: this.y.span + 40
   + this.spaceForCaption};
 hs.hideSelects = (hs.ie && hs.ieVersion() < 7);
 if (hs.hideSelects) this.showHideElements('SELECT', 'hidden', imgPos);
 hs.hideIframes = ((window.opera && navigator.appVersion < 9) || navigator.vendor == 'KDE'
  || (hs.ie && hs.ieVersion() < 5.5));
 if (hs.hideIframes) this.showHideElements('IFRAME', 'hidden', imgPos);
 if (hs.geckoMac) this.showHideElements('*', 'hidden', imgPos);
 if (this.x.imgSpan) this.content.style.margin = '0 auto';
 this.overlays = [];
 this.changeSize(
  1,
  {
   x: this.thumbLeft + this.thumbOffsetBorderW - this.offsetBorderW,
   y: this.thumbTop + this.thumbOffsetBorderH - this.offsetBorderH,
   w: this.thumbWidth,
   h: this.thumbHeight,
   imgW: this.thumbWidth,
   o: hs.outlineStartOffset
  },
  {
   x: this.x.min,
   y: this.y.min,
   w: this.x.span,
   h: this.y.span,
   imgW: this.x.imgSpan,
   o: this.objOutline ? this.objOutline.offset : 0
  },
  hs.expandDuration,
  hs.expandSteps
 );
},
changeSize : function(up, from, to, dur, steps) {
 if (up && this.objOutline && !this.outlineWhileAnimating)
  this.objOutline.setPosition(this, this.x.min, this.y.min, this.x.span, this.y.span);
 else if (!up && this.objOutline) {
  if (this.outlineWhileAnimating) this.objOutline.setPosition(this, from.x, from.y, from.w, from.h);
  else this.objOutline.destroy();
 }
 if (!up) {
  var n = this.wrapper.childNodes.length;
  for (var i = n - 1; i >= 0 ; i--) {
   var child = this.wrapper.childNodes[i];
   if (child != this.content) hs.discardElement(child);
  }
 }
 if (this.fadeInOut) {
  from.op = up ? 0 : 1;
  to.op = up;
 }
 var t,
 exp = this,
 easing = Math[this.easing] || Math.easeInQuad;
 if (!up) easing = Math[this.easingClose] || easing;
 for (var i = 1; i <= steps; i++) {
  t = Math.round(i * (dur / steps));
  (function(){
   var pI = i, size = {};
   for (var x in from) {
    size[x] = easing(t, from[x], to[x] - from[x], dur);
    if (/[xywh]/.test(x)) size[x] = Math.round(size[x]);
   }
   setTimeout ( function() {
    if (up && pI == 1) {
     exp.content.style.visibility = 'visible';
     exp.a.className += ' highslide-active-anchor';
    }
    exp.setSize(size);
   }, t);
  })();
 }
 if (up) {
  setTimeout(function() {
   if (exp.objOutline) exp.objOutline.table.style.visibility = "visible";
  }, t);
  setTimeout(function() {
   if (exp.caption) exp.writeCaption();
   exp.afterExpand();
  }, t + 50);
 }
 else setTimeout(function() { exp.afterClose(); }, t);
},
setSize : function (to) {
 try {
   this.wrapper.style.width = (to.w + 2*this.offsetBorderW) +'px';
   this.content.style.width =
    ((to.imgW && !isNaN(to.imgW)) ? to.imgW : to.w) +'px';
   if (hs.safari) this.content.style.maxWidth = this.content.style.width;
   this.content.style.height = to.h +'px';
  if (to.op) hs.setStyles(this.wrapper, { opacity: to.op });
  if (this.objOutline && this.outlineWhileAnimating) {
   var o = this.objOutline.offset - to.o;
   this.objOutline.setPosition(this, to.x + o, to.y + o, to.w - 2 * o, to.h - 2 * o, 1);
  }
  hs.setStyles ( this.wrapper,
   {
    'visibility': 'visible',
    'left': to.x +'px',
    'top': to.y +'px'
   }
  );
 } catch (e) { window.location.href = hs.getSrc(this.a); }
},
afterExpand : function() {
 this.isExpanded = true;
 this.focus();
 this.createOverlays();
 if (hs.showCredits) this.writeCredits();
 if (this.isImage && this.fullExpandWidth > this.x.span) this.createFullExpand();
 if (!this.caption) this.prepareNextOutline();
},
prepareNextOutline : function() {
 var key = this.key;
 var outlineType = this.outlineType;
 new hs.Outline(outlineType,
  function () { try { hs.expanders[key].preloadNext(); } catch (e) {} });
},
preloadNext : function() {
 var next = hs.getAdjacentAnchor(this.key, 1);
 if (next.onclick.toString().match(/hs\.expand/))
  var img = hs.createElement('img', { src: hs.getSrc(next) });
},
cancelLoading : function() {
 hs.expanders[this.key] = null;
 this.a.style.cursor = this.originalCursor;
 if (this.loading) hs.loading.style.left = '-9999px';
},
writeCredits : function () {
 this.credits = hs.createElement('a',
  {
   href: hs.creditsHref,
   className: 'highslide-credits',
   innerHTML: hs.creditsText,
   title: hs.creditsTitle
  }
 );
 this.createOverlay({ overlayId: this.credits, position: 'top left' });
},
getCaption : function() {
 if (!this.captionId && this.thumbsUserSetId)
  this.captionId = 'caption-for-'+ this.thumbsUserSetId;
 if (this.captionId) this.caption = hs.getNode(this.captionId);
 if (!this.caption && !this.captionText && this.captionEval) try {
  this.captionText = eval(this.captionEval);
 } catch (e) {}
 if (!this.caption && this.captionText) this.caption = hs.createElement('div',
   { className: 'highslide-caption', innerHTML: this.captionText } );
 if (!this.caption) {
  var next = this.a.nextSibling;
  while (next && !hs.isHsAnchor(next)) {
   if (/highslide-caption/.test(next.className || null)) {
    this.caption = next.cloneNode(1);
    break;
   }
   next = next.nextSibling;
  }
 }
 if (this.caption) {
  this.marginBottom += this.spaceForCaption;
 }
},
writeCaption : function() {
 try {
  hs.setStyles(this.wrapper, { width: this.wrapper.offsetWidth +'px',
   height: this.wrapper.offsetHeight +'px' } );
  hs.setStyles(this.caption, { visibility: 'hidden', marginTop: hs.safari ? 0 : '-'+ this.y.span +'px'});
  this.caption.className += ' highslide-display-block';
  var height, exp = this;
  if (hs.ie && (hs.ieVersion() < 6 || document.compatMode == 'BackCompat')) {
   height = this.caption.offsetHeight;
  } else {
   var temp = hs.createElement('div', {innerHTML: this.caption.innerHTML},
    null, null, true);
   this.caption.innerHTML = '';
   this.caption.appendChild(temp);
   height = this.caption.childNodes[0].offsetHeight;
   this.caption.innerHTML = this.caption.childNodes[0].innerHTML;
  }
  hs.setStyles(this.caption, { overflow: 'hidden', height: 0, zIndex: 2, marginTop: 0 });
  this.wrapper.style.height = 'auto';
  if (hs.captionSlideSpeed) {
   var step = (Math.round(height/50) || 1) * hs.captionSlideSpeed;
  } else {
   this.placeCaption(height, 1);
   return;
  }
  for (var h = height % step, t = 0; h <= height; h += step, t += 10) {
   (function(){
    var pH = h, end = (h == height) ? 1 : 0;
    setTimeout( function() {
     exp.placeCaption(pH, end);
    }, t);
   })();
  }
 } catch (e) {}
},
placeCaption : function(height, end) {
 if (!this.caption) return;
 this.caption.style.height = height +'px';
 this.caption.style.visibility = 'visible';
 this.y.span = this.wrapper.offsetHeight - 2 * this.offsetBorderH;
 var o = this.objOutline;
 if (o) {
  var h = this.wrapper.offsetHeight - 2 * this.objOutline.offset;
  if (h >= 0) o.td[4].style.height = h +'px';
  if (o.hasAlphaImageLoader) o.td[3].style.height = o.td[5].style.height = o.td[4].style.height;
 }
 if (end) this.prepareNextOutline();
},
showHideElements : function (tagName, visibility, imgPos) {
 var els = document.getElementsByTagName(tagName);
 var prop = tagName == '*' ? 'overflow' : 'visibility';
 for (var i = 0; i < els.length; i++) {
  if (prop == 'visibility' || (document.defaultView.getComputedStyle(
    els[i], "").getPropertyValue('overflow') == 'auto'
    || els[i].getAttribute('hidden-by') != null)) {
   var hiddenBy = els[i].getAttribute('hidden-by');
   if (visibility == 'visible' && hiddenBy) {
    hiddenBy = hiddenBy.replace('['+ this.key +']', '');
    els[i].setAttribute('hidden-by', hiddenBy);
    if (!hiddenBy) els[i].style[prop] = els[i].origProp;
   } else if (visibility == 'hidden') {
    var elPos = hs.position(els[i]);
    elPos.w = els[i].offsetWidth;
    elPos.h = els[i].offsetHeight;
     var clearsX = (elPos.x + elPos.w < imgPos.x || elPos.x > imgPos.x + imgPos.w);
     var clearsY = (elPos.y + elPos.h < imgPos.y || elPos.y > imgPos.y + imgPos.h);
    var wrapperKey = hs.getWrapperKey(els[i]);
    if (!clearsX && !clearsY && wrapperKey != this.key) {
     if (!hiddenBy) {
      els[i].setAttribute('hidden-by', '['+ this.key +']');
      els[i].origProp = els[i].style[prop];
      els[i].style[prop] = 'hidden';
     } else if (!hiddenBy.match('['+ this.key +']')) {
      els[i].setAttribute('hidden-by', hiddenBy + '['+ this.key +']');
     }
    } else if (hiddenBy == '['+ this.key +']' || hs.focusKey == wrapperKey) {
     els[i].setAttribute('hidden-by', '');
     els[i].style[prop] = els[i].origProp || '';
    } else if (hiddenBy && hiddenBy.match('['+ this.key +']')) {
     els[i].setAttribute('hidden-by', hiddenBy.replace('['+ this.key +']', ''));
    }
   }
  }
 }
},
focus : function() {
 this.wrapper.style.zIndex = hs.zIndexCounter++;
 for (var i = 0; i < hs.expanders.length; i++) {
  if (hs.expanders[i] && i == hs.focusKey) {
   var blurExp = hs.expanders[i];
   blurExp.content.className += ' highslide-'+ blurExp.contentType +'-blur';
   if (blurExp.caption) {
    blurExp.caption.className += ' highslide-caption-blur';
   }
    blurExp.content.style.cursor = hs.ie ? 'hand' : 'pointer';
    blurExp.content.title = hs.focusTitle;
  }
 }
 if (this.objOutline) this.objOutline.table.style.zIndex
  = this.wrapper.style.zIndex;
 this.content.className = 'highslide-'+ this.contentType;
 if (this.caption) {
  this.caption.className = this.caption.className.replace(' highslide-caption-blur', '');
 }
  this.content.title = hs.restoreTitle;
  hs.styleRestoreCursor = window.opera ? 'pointer' : 'url('+ hs.graphicsDir + hs.restoreCursor +'), pointer';
  if (hs.ie && hs.ieVersion() < 6) hs.styleRestoreCursor = 'hand';
  this.content.style.cursor = hs.styleRestoreCursor;
 hs.focusKey = this.key;
 hs.addEventListener(document, 'keydown', hs.keyHandler);
},
move : function (e) {
 this.x.min = e.left + e.dX;
 this.y.min = e.top + e.dY;
 if (e.type == 'image') this.content.style.cursor = 'move';
 hs.setStyles(this.wrapper, { left: this.x.min +'px', top: this.y.min +'px' });
 if (this.objOutline)
  this.objOutline.setPosition(this, this.x.min, this.y.min, this.x.span, this.y.span);
},
close : function() {
 if (this.isClosing || !this.isExpanded) return;
 this.isClosing = true;
 hs.removeEventListener(document, 'keydown', hs.keyHandler);
 try {
  this.content.style.cursor = 'default';
  this.changeSize(
   0,
   {
    x: this.x.min,
    y: this.y.min,
    w: this.x.span,
    h: parseInt(this.content.style.height),
    imgW: this.x.imgSpan,
    o: this.objOutline ? this.objOutline.offset : 0
   },
   {
    x: this.thumbLeft - this.offsetBorderW + this.thumbOffsetBorderW,
    y: this.thumbTop - this.offsetBorderH + this.thumbOffsetBorderH,
    w: this.thumbWidth,
    h: this.thumbHeight,
    imgW: this.thumbWidth,
    o: hs.outlineStartOffset
   },
   hs.restoreDuration,
   hs.restoreSteps
  );
 } catch (e) { this.afterClose(); }
},
createOverlay : function (o) {
 var el = o.overlayId;
 if (typeof el == 'string') el = hs.getNode(el);
 if (!el || typeof el == 'string') return;
 var overlay = hs.createElement(
  'div',
  { id: 'hsId'+ hs.idCounter++ },
  {
   'left' : 0,
   'top' : 0,
   'position' : 'absolute',
   'zIndex' : 3,
   'visibility' : 'hidden'
  },
  this.wrapper,
  true
 );
 if (o.opacity) hs.setStyles(el, { opacity: o.opacity });
 el.style.styleFloat = 'none';
 el.className += ' highslide-display-block';
 overlay.appendChild(el);
 overlay.hsPos = o.position;
 this.positionOverlay(overlay);
 if (o.hideOnMouseOut) overlay.setAttribute('hideOnMouseOut', true);
 if (!o.opacity) o.opacity = 1;
 overlay.setAttribute('opacity', o.opacity);
 hs.fade(overlay, 0, o.opacity);
 hs.push(this.overlays, hs.idCounter - 1);
},
positionOverlay : function(overlay, conH) {
 var left = this.offsetBorderW,
  dLeft = this.x.span - overlay.offsetWidth,
  top = this.offsetBorderH,
  dTop = (conH || parseInt(this.content.style.height)) - overlay.offsetHeight,
  p = overlay.hsPos || 'center center';
 if (/^bottom/.test(p)) top += dTop;
 if (/^center/.test(p)) top += dTop / 2;
 if (/right$/.test(p)) left += dLeft;
 if (/center$/.test(p)) left += dLeft / 2;
 overlay.style.left = left +'px';
 overlay.style.top = top +'px';
},
createOverlays : function() {
 for (var i = 0; i < hs.overlays.length; i++) {
  var o = hs.overlays[i], tId = o.thumbnailId, sg = o.slideshowGroup;
  if ((!tId && !sg) || tId == this.thumbsUserSetId
    || sg === this.slideshowGroup) {
   this.createOverlay(o);
  }
 }
},
createFullExpand : function () {
 this.fullExpandLabel = hs.createElement(
  'a',
  {
   href: 'javascript:hs.expanders['+ this.key +'].doFullExpand();',
   title: hs.fullExpandTitle,
   className: 'highslide-full-expand'
  }
 );
 this.createOverlay({
  overlayId: this.fullExpandLabel,
  position: hs.fullExpandPosition,
  hideOnMouseOut: true,
  opacity: hs.fullExpandOpacity
 });
},
doFullExpand : function () {
 try {
  if (this.fullExpandLabel) hs.discardElement(this.fullExpandLabel);
  this.focus();
  this.x.min = parseInt(this.wrapper.style.left) - (this.fullExpandWidth - this.content.width) / 2;
  if (this.x.min < hs.marginLeft) this.x.min = hs.marginLeft;
  this.wrapper.style.left = this.x.min +'px';
  hs.setStyles(this.content, { width: this.fullExpandWidth +'px', maxWidth: this.fullExpandWidth +'px',
   height: this.fullExpandHeight +'px'});
  this.x.span = this.fullExpandWidth;
  this.wrapper.style.width = (this.x.span + 2*this.offsetBorderW) +'px';
  this.y.span = this.wrapper.offsetHeight - 2 * this.offsetBorderH;
  if (this.objOutline)
   this.objOutline.setPosition(this, this.x.min, this.y.min, this.x.span, this.y.span);
  for (var i = 0; i < this.overlays.length; i++)
   this.positionOverlay(hs.$('hsId'+ this.overlays[i]));
  this.redoShowHide();
 } catch (e) {
  window.location.href = this.content.src;
 }
},
redoShowHide : function() {
 var imgPos = {
  x: parseInt(this.wrapper.style.left) - 20,
  y: parseInt(this.wrapper.style.top) - 20,
  w: this.content.offsetWidth + 40,
  h: this.content.offsetHeight + 40
   + this.spaceForCaption
 };
 if (hs.hideSelects) this.showHideElements('SELECT', 'hidden', imgPos);
 if (hs.hideIframes) this.showHideElements('IFRAME', 'hidden', imgPos);
 if (hs.geckoMac) this.showHideElements('*', 'hidden', imgPos);
},
afterClose : function () {
 this.a.className = this.a.className.replace('highslide-active-anchor', '');
 if (hs.hideSelects) this.showHideElements('SELECT', 'visible');
 if (hs.hideIframes) this.showHideElements('IFRAME', 'visible');
 if (hs.geckoMac) this.showHideElements('*', 'visible');
  if (this.objOutline && this.outlineWhileAnimating) this.objOutline.destroy();
  hs.discardElement(this.wrapper);
 hs.expanders[this.key] = null;
 hs.reOrder();
}
};
var HsExpander = hs.Expander;
hs.addEventListener(document, 'mousedown', hs.mouseClickHandler);
hs.addEventListener(document, 'mouseup', hs.mouseClickHandler);
hs.addEventListener(window, 'load', hs.preloadImages);




Calendar = function (firstDayOfWeek, dateStr, onSelected, onClose) {
 
 this.activeDiv = null;
 this.currentDateEl = null;
 this.getDateStatus = null;
 this.getDateToolTip = null;
 this.getDateText = null;
 this.timeout = null;
 this.onSelected = onSelected || null;
 this.onClose = onClose || null;
 this.dragging = false;
 this.hidden = false;
 this.minYear = 1970;
 this.maxYear = 2050;
 this.dateFormat = Calendar._TT["DEF_DATE_FORMAT"];
 this.ttDateFormat = Calendar._TT["TT_DATE_FORMAT"];
 this.isPopup = true;
 this.weekNumbers = true;
 this.firstDayOfWeek = typeof firstDayOfWeek == "number" ? firstDayOfWeek : Calendar._FD; 
 this.showsOtherMonths = false;
 this.dateStr = dateStr;
 this.ar_days = null;
 this.showsTime = false;
 this.time24 = true;
 this.yearStep = 2;
 this.hiliteToday = true;
 this.multiple = null;
 
 this.table = null;
 this.element = null;
 this.tbody = null;
 this.firstdayname = null;
 
 this.monthsCombo = null;
 this.yearsCombo = null;
 this.hilitedMonth = null;
 this.activeMonth = null;
 this.hilitedYear = null;
 this.activeYear = null;
 
 this.dateClicked = false;

 
 if (typeof Calendar._SDN == "undefined") {
  
  if (typeof Calendar._SDN_len == "undefined")
   Calendar._SDN_len = 3;
  var ar = new Array();
  for (var i = 8; i > 0;) {
   ar[--i] = Calendar._DN[i].substr(0, Calendar._SDN_len);
  }
  Calendar._SDN = ar;
  
  if (typeof Calendar._SMN_len == "undefined")
   Calendar._SMN_len = 3;
  ar = new Array();
  for (var i = 12; i > 0;) {
   ar[--i] = Calendar._MN[i].substr(0, Calendar._SMN_len);
  }
  Calendar._SMN = ar;
 }
};




Calendar._C = null;


Calendar.is_ie = ( /msie/i.test(navigator.userAgent) &&
     !/opera/i.test(navigator.userAgent) );

Calendar.is_ie5 = ( Calendar.is_ie && /msie 5\.0/i.test(navigator.userAgent) );


Calendar.is_opera = /opera/i.test(navigator.userAgent);


Calendar.is_khtml = /Konqueror|Safari|KHTML/i.test(navigator.userAgent);




Calendar.getAbsolutePos = function(el) {
 var SL = 0, ST = 0;
 var is_div = /^div$/i.test(el.tagName);
 if (is_div && el.scrollLeft)
  SL = el.scrollLeft;
 if (is_div && el.scrollTop)
  ST = el.scrollTop;
 var r = { x: el.offsetLeft - SL, y: el.offsetTop - ST };
 if (el.offsetParent) {
  var tmp = this.getAbsolutePos(el.offsetParent);
  r.x += tmp.x;
  r.y += tmp.y;
 }
 return r;
};

Calendar.isRelated = function (el, evt) {
 var related = evt.relatedTarget;
 if (!related) {
  var type = evt.type;
  if (type == "mouseover") {
   related = evt.fromElement;
  } else if (type == "mouseout") {
   related = evt.toElement;
  }
 }
 while (related) {
  if (related == el) {
   return true;
  }
  related = related.parentNode;
 }
 return false;
};

Calendar.removeClass = function(el, className) {
 if (!(el && el.className)) {
  return;
 }
 var cls = el.className.split(" ");
 var ar = new Array();
 for (var i = cls.length; i > 0;) {
  if (cls[--i] != className) {
   ar[ar.length] = cls[i];
  }
 }
 el.className = ar.join(" ");
};

Calendar.addClass = function(el, className) {
 Calendar.removeClass(el, className);
 el.className += " " + className;
};


Calendar.getElement = function(ev) {
 var f = Calendar.is_ie ? window.event.srcElement : ev.currentTarget;
 while (f.nodeType != 1 || /^div$/i.test(f.tagName))
  f = f.parentNode;
 return f;
};

Calendar.getTargetElement = function(ev) {
 var f = Calendar.is_ie ? window.event.srcElement : ev.target;
 while (f.nodeType != 1)
  f = f.parentNode;
 return f;
};

Calendar.stopEvent = function(ev) {
 ev || (ev = window.event);
 if (Calendar.is_ie) {
  ev.cancelBubble = true;
  ev.returnValue = false;
 } else {
  ev.preventDefault();
  ev.stopPropagation();
 }
 return false;
};

Calendar.addEvent = function(el, evname, func) {
 if (el.attachEvent) { 
  el.attachEvent("on" + evname, func);
 } else if (el.addEventListener) { 
  el.addEventListener(evname, func, true);
 } else {
  el["on" + evname] = func;
 }
};

Calendar.removeEvent = function(el, evname, func) {
 if (el.detachEvent) { 
  el.detachEvent("on" + evname, func);
 } else if (el.removeEventListener) { 
  el.removeEventListener(evname, func, true);
 } else {
  el["on" + evname] = null;
 }
};

Calendar.createElement = function(type, parent) {
 var el = null;
 if (document.createElementNS) {
  
  
  el = document.createElementNS("http://www.w3.org/1999/xhtml", type);
 } else {
  el = document.createElement(type);
 }
 if (typeof parent != "undefined") {
  parent.appendChild(el);
 }
 return el;
};






Calendar._add_evs = function(el) {
 with (Calendar) {
  addEvent(el, "mouseover", dayMouseOver);
  addEvent(el, "mousedown", dayMouseDown);
  addEvent(el, "mouseout", dayMouseOut);
  if (is_ie) {
   addEvent(el, "dblclick", dayMouseDblClick);
   el.setAttribute("unselectable", true);
  }
 }
};

Calendar.findMonth = function(el) {
 if (typeof el.month != "undefined") {
  return el;
 } else if (typeof el.parentNode.month != "undefined") {
  return el.parentNode;
 }
 return null;
};

Calendar.findYear = function(el) {
 if (typeof el.year != "undefined") {
  return el;
 } else if (typeof el.parentNode.year != "undefined") {
  return el.parentNode;
 }
 return null;
};

Calendar.showMonthsCombo = function () {
 var cal = Calendar._C;
 if (!cal) {
  return false;
 }
 var cal = cal;
 var cd = cal.activeDiv;
 var mc = cal.monthsCombo;
 if (cal.hilitedMonth) {
  Calendar.removeClass(cal.hilitedMonth, "hilite");
 }
 if (cal.activeMonth) {
  Calendar.removeClass(cal.activeMonth, "active");
 }
 var mon = cal.monthsCombo.getElementsByTagName("div")[cal.date.getMonth()];
 Calendar.addClass(mon, "active");
 cal.activeMonth = mon;
 var s = mc.style;
 s.display = "block";
 if (cd.navtype < 0)
  s.left = cd.offsetLeft + "px";
 else {
  var mcw = mc.offsetWidth;
  if (typeof mcw == "undefined")
   
   mcw = 50;
  s.left = (cd.offsetLeft + cd.offsetWidth - mcw) + "px";
 }
 s.top = (cd.offsetTop + cd.offsetHeight) + "px";
};

Calendar.showYearsCombo = function (fwd) {
 var cal = Calendar._C;
 if (!cal) {
  return false;
 }
 var cal = cal;
 var cd = cal.activeDiv;
 var yc = cal.yearsCombo;
 if (cal.hilitedYear) {
  Calendar.removeClass(cal.hilitedYear, "hilite");
 }
 if (cal.activeYear) {
  Calendar.removeClass(cal.activeYear, "active");
 }
 cal.activeYear = null;
 var Y = cal.date.getFullYear() + (fwd ? 1 : -1);
 var yr = yc.firstChild;
 var show = false;
 for (var i = 12; i > 0; --i) {
  if (Y >= cal.minYear && Y <= cal.maxYear) {
   yr.innerHTML = Y;
   yr.year = Y;
   yr.style.display = "block";
   show = true;
  } else {
   yr.style.display = "none";
  }
  yr = yr.nextSibling;
  Y += fwd ? cal.yearStep : -cal.yearStep;
 }
 if (show) {
  var s = yc.style;
  s.display = "block";
  if (cd.navtype < 0)
   s.left = cd.offsetLeft + "px";
  else {
   var ycw = yc.offsetWidth;
   if (typeof ycw == "undefined")
    
    ycw = 50;
   s.left = (cd.offsetLeft + cd.offsetWidth - ycw) + "px";
  }
  s.top = (cd.offsetTop + cd.offsetHeight) + "px";
 }
};



Calendar.tableMouseUp = function(ev) {
 var cal = Calendar._C;
 if (!cal) {
  return false;
 }
 if (cal.timeout) {
  clearTimeout(cal.timeout);
 }
 var el = cal.activeDiv;
 if (!el) {
  return false;
 }
 var target = Calendar.getTargetElement(ev);
 ev || (ev = window.event);
 Calendar.removeClass(el, "active");
 if (target == el || target.parentNode == el) {
  Calendar.cellClick(el, ev);
 }
 var mon = Calendar.findMonth(target);
 var date = null;
 if (mon) {
  date = new Date(cal.date);
  if (mon.month != date.getMonth()) {
   date.setMonth(mon.month);
   cal.setDate(date);
   cal.dateClicked = false;
   cal.callHandler();
  }
 } else {
  var year = Calendar.findYear(target);
  if (year) {
   date = new Date(cal.date);
   if (year.year != date.getFullYear()) {
    date.setFullYear(year.year);
    cal.setDate(date);
    cal.dateClicked = false;
    cal.callHandler();
   }
  }
 }
 with (Calendar) {
  removeEvent(document, "mouseup", tableMouseUp);
  removeEvent(document, "mouseover", tableMouseOver);
  removeEvent(document, "mousemove", tableMouseOver);
  cal._hideCombos();
  _C = null;
  return stopEvent(ev);
 }
};

Calendar.tableMouseOver = function (ev) {
 var cal = Calendar._C;
 if (!cal) {
  return;
 }
 var el = cal.activeDiv;
 var target = Calendar.getTargetElement(ev);
 if (target == el || target.parentNode == el) {
  Calendar.addClass(el, "hilite active");
  Calendar.addClass(el.parentNode, "rowhilite");
 } else {
  if (typeof el.navtype == "undefined" || (el.navtype != 50 && (el.navtype == 0 || Math.abs(el.navtype) > 2)))
   Calendar.removeClass(el, "active");
  Calendar.removeClass(el, "hilite");
  Calendar.removeClass(el.parentNode, "rowhilite");
 }
 ev || (ev = window.event);
 if (el.navtype == 50 && target != el) {
  var pos = Calendar.getAbsolutePos(el);
  var w = el.offsetWidth;
  var x = ev.clientX;
  var dx;
  var decrease = true;
  if (x > pos.x + w) {
   dx = x - pos.x - w;
   decrease = false;
  } else
   dx = pos.x - x;

  if (dx < 0) dx = 0;
  var range = el._range;
  var current = el._current;
  var count = Math.floor(dx / 10) % range.length;
  for (var i = range.length; --i >= 0;)
   if (range[i] == current)
    break;
  while (count-- > 0)
   if (decrease) {
    if (--i < 0)
     i = range.length - 1;
   } else if ( ++i >= range.length )
    i = 0;
  var newval = range[i];
  el.innerHTML = newval;

  cal.onUpdateTime();
 }
 var mon = Calendar.findMonth(target);
 if (mon) {
  if (mon.month != cal.date.getMonth()) {
   if (cal.hilitedMonth) {
    Calendar.removeClass(cal.hilitedMonth, "hilite");
   }
   Calendar.addClass(mon, "hilite");
   cal.hilitedMonth = mon;
  } else if (cal.hilitedMonth) {
   Calendar.removeClass(cal.hilitedMonth, "hilite");
  }
 } else {
  if (cal.hilitedMonth) {
   Calendar.removeClass(cal.hilitedMonth, "hilite");
  }
  var year = Calendar.findYear(target);
  if (year) {
   if (year.year != cal.date.getFullYear()) {
    if (cal.hilitedYear) {
     Calendar.removeClass(cal.hilitedYear, "hilite");
    }
    Calendar.addClass(year, "hilite");
    cal.hilitedYear = year;
   } else if (cal.hilitedYear) {
    Calendar.removeClass(cal.hilitedYear, "hilite");
   }
  } else if (cal.hilitedYear) {
   Calendar.removeClass(cal.hilitedYear, "hilite");
  }
 }
 return Calendar.stopEvent(ev);
};

Calendar.tableMouseDown = function (ev) {
 if (Calendar.getTargetElement(ev) == Calendar.getElement(ev)) {
  return Calendar.stopEvent(ev);
 }
};

Calendar.calDragIt = function (ev) {
 var cal = Calendar._C;
 if (!(cal && cal.dragging)) {
  return false;
 }
 var posX;
 var posY;
 if (Calendar.is_ie) {
  posY = window.event.clientY + document.body.scrollTop;
  posX = window.event.clientX + document.body.scrollLeft;
 } else {
  posX = ev.pageX;
  posY = ev.pageY;
 }
 cal.hideShowCovered();
 var st = cal.element.style;
 st.left = (posX - cal.xOffs) + "px";
 st.top = (posY - cal.yOffs) + "px";
 return Calendar.stopEvent(ev);
};

Calendar.calDragEnd = function (ev) {
 var cal = Calendar._C;
 if (!cal) {
  return false;
 }
 cal.dragging = false;
 with (Calendar) {
  removeEvent(document, "mousemove", calDragIt);
  removeEvent(document, "mouseup", calDragEnd);
  tableMouseUp(ev);
 }
 cal.hideShowCovered();
};

Calendar.dayMouseDown = function(ev) {
 var el = Calendar.getElement(ev);
 if (el.disabled) {
  return false;
 }
 var cal = el.calendar;
 cal.activeDiv = el;
 Calendar._C = cal;
 if (el.navtype != 300) with (Calendar) {
  if (el.navtype == 50) {
   el._current = el.innerHTML;
   addEvent(document, "mousemove", tableMouseOver);
  } else
   addEvent(document, Calendar.is_ie5 ? "mousemove" : "mouseover", tableMouseOver);
  addClass(el, "hilite active");
  addEvent(document, "mouseup", tableMouseUp);
 } else if (cal.isPopup) {
  cal._dragStart(ev);
 }
 if (el.navtype == -1 || el.navtype == 1) {
  if (cal.timeout) clearTimeout(cal.timeout);
  cal.timeout = setTimeout("Calendar.showMonthsCombo()", 250);
 } else if (el.navtype == -2 || el.navtype == 2) {
  if (cal.timeout) clearTimeout(cal.timeout);
  cal.timeout = setTimeout((el.navtype > 0) ? "Calendar.showYearsCombo(true)" : "Calendar.showYearsCombo(false)", 250);
 } else {
  cal.timeout = null;
 }
 return Calendar.stopEvent(ev);
};

Calendar.dayMouseDblClick = function(ev) {
 Calendar.cellClick(Calendar.getElement(ev), ev || window.event);
 if (Calendar.is_ie) {
  document.selection.empty();
 }
};

Calendar.dayMouseOver = function(ev) {
 var el = Calendar.getElement(ev);
 if (Calendar.isRelated(el, ev) || Calendar._C || el.disabled) {
  return false;
 }
 if (el.ttip) {
  if (el.ttip.substr(0, 1) == "_") {
   el.ttip = el.caldate.print(el.calendar.ttDateFormat) + el.ttip.substr(1);
  }
  el.calendar.tooltips.innerHTML = el.ttip;
 }
 if (el.navtype != 300) {
  Calendar.addClass(el, "hilite");
  if (el.caldate) {
   Calendar.addClass(el.parentNode, "rowhilite");
  }
 }
 return Calendar.stopEvent(ev);
};

Calendar.dayMouseOut = function(ev) {
 with (Calendar) {
  var el = getElement(ev);
  if (isRelated(el, ev) || _C || el.disabled)
   return false;
  removeClass(el, "hilite");
  if (el.caldate)
   removeClass(el.parentNode, "rowhilite");
  if (el.calendar)
   el.calendar.tooltips.innerHTML = _TT["SEL_DATE"];
  return stopEvent(ev);
 }
};


Calendar.cellClick = function(el, ev) {
 var cal = el.calendar;
 var closing = false;
 var newdate = false;
 var date = null;
 if (typeof el.navtype == "undefined") {
  if (cal.currentDateEl) {
   Calendar.removeClass(cal.currentDateEl, "selected");
   Calendar.addClass(el, "selected");
   closing = (cal.currentDateEl == el);
   if (!closing) {
    cal.currentDateEl = el;
   }
  }
  cal.date.setDateOnly(el.caldate);
  date = cal.date;
  var other_month = !(cal.dateClicked = !el.otherMonth);
  if (!other_month && !cal.currentDateEl)
   cal._toggleMultipleDate(new Date(date));
  else
   newdate = !el.disabled;
  
  if (other_month)
   cal._init(cal.firstDayOfWeek, date);
 } else {
  if (el.navtype == 200) {
   Calendar.removeClass(el, "hilite");
   cal.callCloseHandler();
   return;
  }
  date = new Date(cal.date);
  if (el.navtype == 0)
   date.setDateOnly(new Date()); 
  
  
  
  
  cal.dateClicked = false;
  var year = date.getFullYear();
  var mon = date.getMonth();
  function setMonth(m) {
   var day = date.getDate();
   var max = date.getMonthDays(m);
   if (day > max) {
    date.setDate(max);
   }
   date.setMonth(m);
  };
  switch (el.navtype) {
      case 400:
   Calendar.removeClass(el, "hilite");
   var text = Calendar._TT["ABOUT"];
   if (typeof text != "undefined") {
    text += cal.showsTime ? Calendar._TT["ABOUT_TIME"] : "";
   } else {
    
    text = "Help and about box text is not translated into this language.\n" +
     "If you know this language and you feel generous please update\n" +
     "the corresponding file in \"lang\" subdir to match calendar-en.js\n" +
     "and send it back to <mihai_bazon@yahoo.com> to get it into the distribution  ;-)\n\n" +
     "Thank you!\n" +
     "http://dynarch.com/mishoo/calendar.epl\n";
   }
   alert(text);
   return;
      case -2:
   if (year > cal.minYear) {
    date.setFullYear(year - 1);
   }
   break;
      case -1:
   if (mon > 0) {
    setMonth(mon - 1);
   } else if (year-- > cal.minYear) {
    date.setFullYear(year);
    setMonth(11);
   }
   break;
      case 1:
   if (mon < 11) {
    setMonth(mon + 1);
   } else if (year < cal.maxYear) {
    date.setFullYear(year + 1);
    setMonth(0);
   }
   break;
      case 2:
   if (year < cal.maxYear) {
    date.setFullYear(year + 1);
   }
   break;
      case 100:
   cal.setFirstDayOfWeek(el.fdow);
   return;
      case 50:
   var range = el._range;
   var current = el.innerHTML;
   for (var i = range.length; --i >= 0;)
    if (range[i] == current)
     break;
   if (ev && ev.shiftKey) {
    if (--i < 0)
     i = range.length - 1;
   } else if ( ++i >= range.length )
    i = 0;
   var newval = range[i];
   el.innerHTML = newval;
   cal.onUpdateTime();
   return;
      case 0:
   
   if ((typeof cal.getDateStatus == "function") &&
       cal.getDateStatus(date, date.getFullYear(), date.getMonth(), date.getDate())) {
    return false;
   }
   break;
  }
  if (!date.equalsTo(cal.date)) {
   cal.setDate(date);
   newdate = true;
  } else if (el.navtype == 0)
   newdate = closing = true;
 }
 if (newdate) {
  ev && cal.callHandler();
 }
 if (closing) {
  Calendar.removeClass(el, "hilite");
  ev && cal.callCloseHandler();
 }
};






Calendar.prototype.create = function (_par) {
 var parent = null;
 if (! _par) {
  
  
  parent = document.getElementsByTagName("body")[0];
  this.isPopup = true;
 } else {
  parent = _par;
  this.isPopup = false;
 }
 this.date = this.dateStr ? new Date(this.dateStr) : new Date();

 var table = Calendar.createElement("table");
 this.table = table;
 table.cellSpacing = 0;
 table.cellPadding = 0;
 table.calendar = this;
 Calendar.addEvent(table, "mousedown", Calendar.tableMouseDown);

 var div = Calendar.createElement("div");
 this.element = div;
 div.className = "calendar";
 if (this.isPopup) {
  div.style.position = "absolute";
  div.style.display = "none";
 }
 div.appendChild(table);

 var thead = Calendar.createElement("thead", table);
 var cell = null;
 var row = null;

 var cal = this;
 var hh = function (text, cs, navtype) {
  cell = Calendar.createElement("td", row);
  cell.colSpan = cs;
  cell.className = "button";
  if (navtype != 0 && Math.abs(navtype) <= 2)
   cell.className += " nav";
  Calendar._add_evs(cell);
  cell.calendar = cal;
  cell.navtype = navtype;
  cell.innerHTML = "<div unselectable='on'>" + text + "</div>";
  return cell;
 };

 row = Calendar.createElement("tr", thead);
 var title_length = 6;
 (this.isPopup) && --title_length;
 (this.weekNumbers) && ++title_length;

 hh("?", 1, 400).ttip = Calendar._TT["INFO"];
 this.title = hh("", title_length, 300);
 this.title.className = "title";
 if (this.isPopup) {
  this.title.ttip = Calendar._TT["DRAG_TO_MOVE"];
  this.title.style.cursor = "move";
  hh("&#x00d7;", 1, 200).ttip = Calendar._TT["CLOSE"];
 }

 row = Calendar.createElement("tr", thead);
 row.className = "headrow";

 this._nav_py = hh("&#x00ab;", 1, -2);
 this._nav_py.ttip = Calendar._TT["PREV_YEAR"];

 this._nav_pm = hh("&#x2039;", 1, -1);
 this._nav_pm.ttip = Calendar._TT["PREV_MONTH"];

 this._nav_now = hh(Calendar._TT["TODAY"], this.weekNumbers ? 4 : 3, 0);
 this._nav_now.ttip = Calendar._TT["GO_TODAY"];

 this._nav_nm = hh("&#x203a;", 1, 1);
 this._nav_nm.ttip = Calendar._TT["NEXT_MONTH"];

 this._nav_ny = hh("&#x00bb;", 1, 2);
 this._nav_ny.ttip = Calendar._TT["NEXT_YEAR"];

 
 row = Calendar.createElement("tr", thead);
 row.className = "daynames";
 if (this.weekNumbers) {
  cell = Calendar.createElement("td", row);
  cell.className = "name wn";
  cell.innerHTML = Calendar._TT["WK"];
 }
 for (var i = 7; i > 0; --i) {
  cell = Calendar.createElement("td", row);
  if (!i) {
   cell.navtype = 100;
   cell.calendar = this;
   Calendar._add_evs(cell);
  }
 }
 this.firstdayname = (this.weekNumbers) ? row.firstChild.nextSibling : row.firstChild;
 this._displayWeekdays();

 var tbody = Calendar.createElement("tbody", table);
 this.tbody = tbody;

 for (i = 6; i > 0; --i) {
  row = Calendar.createElement("tr", tbody);
  if (this.weekNumbers) {
   cell = Calendar.createElement("td", row);
  }
  for (var j = 7; j > 0; --j) {
   cell = Calendar.createElement("td", row);
   cell.calendar = this;
   Calendar._add_evs(cell);
  }
 }

 if (this.showsTime) {
  row = Calendar.createElement("tr", tbody);
  row.className = "time";

  cell = Calendar.createElement("td", row);
  cell.className = "time";
  cell.colSpan = 2;
  cell.innerHTML = Calendar._TT["TIME"] || "&nbsp;";

  cell = Calendar.createElement("td", row);
  cell.className = "time";
  cell.colSpan = this.weekNumbers ? 4 : 3;

  (function(){
   function makeTimePart(className, init, range_start, range_end) {
    var part = Calendar.createElement("span", cell);
    part.className = className;
    part.innerHTML = init;
    part.calendar = cal;
    part.ttip = Calendar._TT["TIME_PART"];
    part.navtype = 50;
    part._range = [];
    if (typeof range_start != "number")
     part._range = range_start;
    else {
     for (var i = range_start; i <= range_end; ++i) {
      var txt;
      if (i < 10 && range_end >= 10) txt = '0' + i;
      else txt = '' + i;
      part._range[part._range.length] = txt;
     }
    }
    Calendar._add_evs(part);
    return part;
   };
   var hrs = cal.date.getHours();
   var mins = cal.date.getMinutes();
   var t12 = !cal.time24;
   var pm = (hrs > 12);
   if (t12 && pm) hrs -= 12;
   var H = makeTimePart("hour", hrs, t12 ? 1 : 0, t12 ? 12 : 23);
   var span = Calendar.createElement("span", cell);
   span.innerHTML = ":";
   span.className = "colon";
   var M = makeTimePart("minute", mins, 0, 59);
   var AP = null;
   cell = Calendar.createElement("td", row);
   cell.className = "time";
   cell.colSpan = 2;
   if (t12)
    AP = makeTimePart("ampm", pm ? "pm" : "am", ["am", "pm"]);
   else
    cell.innerHTML = "&nbsp;";

   cal.onSetTime = function() {
    var pm, hrs = this.date.getHours(),
     mins = this.date.getMinutes();
    if (t12) {
     pm = (hrs >= 12);
     if (pm) hrs -= 12;
     if (hrs == 0) hrs = 12;
     AP.innerHTML = pm ? "pm" : "am";
    }
    H.innerHTML = (hrs < 10) ? ("0" + hrs) : hrs;
    M.innerHTML = (mins < 10) ? ("0" + mins) : mins;
   };

   cal.onUpdateTime = function() {
    var date = this.date;
    var h = parseInt(H.innerHTML, 10);
    if (t12) {
     if (/pm/i.test(AP.innerHTML) && h < 12)
      h += 12;
     else if (/am/i.test(AP.innerHTML) && h == 12)
      h = 0;
    }
    var d = date.getDate();
    var m = date.getMonth();
    var y = date.getFullYear();
    date.setHours(h);
    date.setMinutes(parseInt(M.innerHTML, 10));
    date.setFullYear(y);
    date.setMonth(m);
    date.setDate(d);
    this.dateClicked = false;
    this.callHandler();
   };
  })();
 } else {
  this.onSetTime = this.onUpdateTime = function() {};
 }

 var tfoot = Calendar.createElement("tfoot", table);

 row = Calendar.createElement("tr", tfoot);
 row.className = "footrow";

 cell = hh(Calendar._TT["SEL_DATE"], this.weekNumbers ? 8 : 7, 300);
 cell.className = "ttip";
 if (this.isPopup) {
  cell.ttip = Calendar._TT["DRAG_TO_MOVE"];
  cell.style.cursor = "move";
 }
 this.tooltips = cell;

 div = Calendar.createElement("div", this.element);
 this.monthsCombo = div;
 div.className = "combo";
 for (i = 0; i < Calendar._MN.length; ++i) {
  var mn = Calendar.createElement("div");
  mn.className = Calendar.is_ie ? "label-IEfix" : "label";
  mn.month = i;
  mn.innerHTML = Calendar._SMN[i];
  div.appendChild(mn);
 }

 div = Calendar.createElement("div", this.element);
 this.yearsCombo = div;
 div.className = "combo";
 for (i = 12; i > 0; --i) {
  var yr = Calendar.createElement("div");
  yr.className = Calendar.is_ie ? "label-IEfix" : "label";
  div.appendChild(yr);
 }

 this._init(this.firstDayOfWeek, this.date);
 parent.appendChild(this.element);
};


Calendar._keyEvent = function(ev) {
 var cal = window._dynarch_popupCalendar;
 if (!cal || cal.multiple)
  return false;
 (Calendar.is_ie) && (ev = window.event);
 var act = (Calendar.is_ie || ev.type == "keypress"),
  K = ev.keyCode;
 if (ev.ctrlKey) {
  switch (K) {
      case 37: 
   act && Calendar.cellClick(cal._nav_pm);
   break;
      case 38: 
   act && Calendar.cellClick(cal._nav_py);
   break;
      case 39: 
   act && Calendar.cellClick(cal._nav_nm);
   break;
      case 40: 
   act && Calendar.cellClick(cal._nav_ny);
   break;
      default:
   return false;
  }
 } else switch (K) {
     case 32: 
  Calendar.cellClick(cal._nav_now);
  break;
     case 27: 
  act && cal.callCloseHandler();
  break;
     case 37: 
     case 38: 
     case 39: 
     case 40: 
  if (act) {
   var prev, x, y, ne, el, step;
   prev = K == 37 || K == 38;
   step = (K == 37 || K == 39) ? 1 : 7;
   function setVars() {
    el = cal.currentDateEl;
    var p = el.pos;
    x = p & 15;
    y = p >> 4;
    ne = cal.ar_days[y][x];
   };setVars();
   function prevMonth() {
    var date = new Date(cal.date);
    date.setDate(date.getDate() - step);
    cal.setDate(date);
   };
   function nextMonth() {
    var date = new Date(cal.date);
    date.setDate(date.getDate() + step);
    cal.setDate(date);
   };
   while (1) {
    switch (K) {
        case 37: 
     if (--x >= 0)
      ne = cal.ar_days[y][x];
     else {
      x = 6;
      K = 38;
      continue;
     }
     break;
        case 38: 
     if (--y >= 0)
      ne = cal.ar_days[y][x];
     else {
      prevMonth();
      setVars();
     }
     break;
        case 39: 
     if (++x < 7)
      ne = cal.ar_days[y][x];
     else {
      x = 0;
      K = 40;
      continue;
     }
     break;
        case 40: 
     if (++y < cal.ar_days.length)
      ne = cal.ar_days[y][x];
     else {
      nextMonth();
      setVars();
     }
     break;
    }
    break;
   }
   if (ne) {
    if (!ne.disabled)
     Calendar.cellClick(ne);
    else if (prev)
     prevMonth();
    else
     nextMonth();
   }
  }
  break;
     case 13: 
  if (act)
   Calendar.cellClick(cal.currentDateEl, ev);
  break;
     default:
  return false;
 }
 return Calendar.stopEvent(ev);
};


Calendar.prototype._init = function (firstDayOfWeek, date) {
 var today = new Date(),
  TY = today.getFullYear(),
  TM = today.getMonth(),
  TD = today.getDate();
 this.table.style.visibility = "hidden";
 var year = date.getFullYear();
 if (year < this.minYear) {
  year = this.minYear;
  date.setFullYear(year);
 } else if (year > this.maxYear) {
  year = this.maxYear;
  date.setFullYear(year);
 }
 this.firstDayOfWeek = firstDayOfWeek;
 this.date = new Date(date);
 var month = date.getMonth();
 var mday = date.getDate();
 var no_days = date.getMonthDays();

 
 
 
 date.setDate(1);
 var day1 = (date.getDay() - this.firstDayOfWeek) % 7;
 if (day1 < 0)
  day1 += 7;
 date.setDate(-day1);
 date.setDate(date.getDate() + 1);

 var row = this.tbody.firstChild;
 var MN = Calendar._SMN[month];
 var ar_days = this.ar_days = new Array();
 var weekend = Calendar._TT["WEEKEND"];
 var dates = this.multiple ? (this.datesCells = {}) : null;
 for (var i = 0; i < 6; ++i, row = row.nextSibling) {
  var cell = row.firstChild;
  if (this.weekNumbers) {
   cell.className = "day wn";
   cell.innerHTML = date.getWeekNumber();
   cell = cell.nextSibling;
  }
  row.className = "daysrow";
  var hasdays = false, iday, dpos = ar_days[i] = [];
  for (var j = 0; j < 7; ++j, cell = cell.nextSibling, date.setDate(iday + 1)) {
   iday = date.getDate();
   var wday = date.getDay();
   cell.className = "day";
   cell.pos = i << 4 | j;
   dpos[j] = cell;
   var current_month = (date.getMonth() == month);
   if (!current_month) {
    if (this.showsOtherMonths) {
     cell.className += " othermonth";
     cell.otherMonth = true;
    } else {
     cell.className = "emptycell";
     cell.innerHTML = "&nbsp;";
     cell.disabled = true;
     continue;
    }
   } else {
    cell.otherMonth = false;
    hasdays = true;
   }
   cell.disabled = false;
   cell.innerHTML = this.getDateText ? this.getDateText(date, iday) : iday;
   if (dates)
    dates[date.print("%Y%m%d")] = cell;
   if (this.getDateStatus) {
    var status = this.getDateStatus(date, year, month, iday);
    if (this.getDateToolTip) {
     var toolTip = this.getDateToolTip(date, year, month, iday);
     if (toolTip)
      cell.title = toolTip;
    }
    if (status === true) {
     cell.className += " disabled";
     cell.disabled = true;
    } else {
     if (/disabled/i.test(status))
      cell.disabled = true;
     cell.className += " " + status;
    }
   }
   if (!cell.disabled) {
    cell.caldate = new Date(date);
    cell.ttip = "_";
    if (!this.multiple && current_month
        && iday == mday && this.hiliteToday) {
     cell.className += " selected";
     this.currentDateEl = cell;
    }
    if (date.getFullYear() == TY &&
        date.getMonth() == TM &&
        iday == TD) {
     cell.className += " today";
     cell.ttip += Calendar._TT["PART_TODAY"];
    }
    if (weekend.indexOf(wday.toString()) != -1)
     cell.className += cell.otherMonth ? " oweekend" : " weekend";
   }
  }
  if (!(hasdays || this.showsOtherMonths))
   row.className = "emptyrow";
 }
 this.title.innerHTML = Calendar._MN[month] + ", " + year;
 this.onSetTime();
 this.table.style.visibility = "visible";
 this._initMultipleDates();
 
 
};

Calendar.prototype._initMultipleDates = function() {
 if (this.multiple) {
  for (var i in this.multiple) {
   var cell = this.datesCells[i];
   var d = this.multiple[i];
   if (!d)
    continue;
   if (cell)
    cell.className += " selected";
  }
 }
};

Calendar.prototype._toggleMultipleDate = function(date) {
 if (this.multiple) {
  var ds = date.print("%Y%m%d");
  var cell = this.datesCells[ds];
  if (cell) {
   var d = this.multiple[ds];
   if (!d) {
    Calendar.addClass(cell, "selected");
    this.multiple[ds] = date;
   } else {
    Calendar.removeClass(cell, "selected");
    delete this.multiple[ds];
   }
  }
 }
};

Calendar.prototype.setDateToolTipHandler = function (unaryFunction) {
 this.getDateToolTip = unaryFunction;
};


Calendar.prototype.setDate = function (date) {
 if (!date.equalsTo(this.date)) {
  this._init(this.firstDayOfWeek, date);
 }
};


Calendar.prototype.refresh = function () {
 this._init(this.firstDayOfWeek, this.date);
};


Calendar.prototype.setFirstDayOfWeek = function (firstDayOfWeek) {
 this._init(firstDayOfWeek, this.date);
 this._displayWeekdays();
};


Calendar.prototype.setDateStatusHandler = Calendar.prototype.setDisabledHandler = function (unaryFunction) {
 this.getDateStatus = unaryFunction;
};


Calendar.prototype.setRange = function (a, z) {
 this.minYear = a;
 this.maxYear = z;
};


Calendar.prototype.callHandler = function () {
 if (this.onSelected) {
  this.onSelected(this, this.date.print(this.dateFormat));
 }
};


Calendar.prototype.callCloseHandler = function () {
 if (this.onClose) {
  this.onClose(this);
 }
 this.hideShowCovered();
};


Calendar.prototype.destroy = function () {
 var el = this.element.parentNode;
 el.removeChild(this.element);
 Calendar._C = null;
 window._dynarch_popupCalendar = null;
};


Calendar.prototype.reparent = function (new_parent) {
 var el = this.element;
 el.parentNode.removeChild(el);
 new_parent.appendChild(el);
};




Calendar._checkCalendar = function(ev) {
 var calendar = window._dynarch_popupCalendar;
 if (!calendar) {
  return false;
 }
 var el = Calendar.is_ie ? Calendar.getElement(ev) : Calendar.getTargetElement(ev);
 for (; el != null && el != calendar.element; el = el.parentNode);
 if (el == null) {
  
  window._dynarch_popupCalendar.callCloseHandler();
  return Calendar.stopEvent(ev);
 }
};


Calendar.prototype.show = function () {
 var rows = this.table.getElementsByTagName("tr");
 for (var i = rows.length; i > 0;) {
  var row = rows[--i];
  Calendar.removeClass(row, "rowhilite");
  var cells = row.getElementsByTagName("td");
  for (var j = cells.length; j > 0;) {
   var cell = cells[--j];
   Calendar.removeClass(cell, "hilite");
   Calendar.removeClass(cell, "active");
  }
 }
 this.element.style.display = "block";
 this.hidden = false;
 if (this.isPopup) {
  window._dynarch_popupCalendar = this;
  Calendar.addEvent(document, "keydown", Calendar._keyEvent);
  Calendar.addEvent(document, "keypress", Calendar._keyEvent);
  Calendar.addEvent(document, "mousedown", Calendar._checkCalendar);
 }
 this.hideShowCovered();
};


Calendar.prototype.hide = function () {
 if (this.isPopup) {
  Calendar.removeEvent(document, "keydown", Calendar._keyEvent);
  Calendar.removeEvent(document, "keypress", Calendar._keyEvent);
  Calendar.removeEvent(document, "mousedown", Calendar._checkCalendar);
 }
 this.element.style.display = "none";
 this.hidden = true;
 this.hideShowCovered();
};


Calendar.prototype.showAt = function (x, y) {
 var s = this.element.style;
 s.left = x + "px";
 s.top = y + "px";
 this.show();
};


Calendar.prototype.showAtElement = function (el, opts) {
 var self = this;
 var p = Calendar.getAbsolutePos(el);
 if (!opts || typeof opts != "string") {
  this.showAt(p.x, p.y + el.offsetHeight);
  return true;
 }
 function fixPosition(box) {
  if (box.x < 0)
   box.x = 0;
  if (box.y < 0)
   box.y = 0;
  var cp = document.createElement("div");
  var s = cp.style;
  s.position = "absolute";
  s.right = s.bottom = s.width = s.height = "0px";
  document.body.appendChild(cp);
  var br = Calendar.getAbsolutePos(cp);
  document.body.removeChild(cp);
  if (Calendar.is_ie) {
   br.y += document.body.scrollTop;
   br.x += document.body.scrollLeft;
  } else {
   br.y += window.scrollY;
   br.x += window.scrollX;
  }
  var tmp = box.x + box.width - br.x;
  if (tmp > 0) box.x -= tmp;
  tmp = box.y + box.height - br.y;
  if (tmp > 0) box.y -= tmp;
 };
 this.element.style.display = "block";
 Calendar.continuation_for_the_fucking_khtml_browser = function() {
  var w = self.element.offsetWidth;
  var h = self.element.offsetHeight;
  self.element.style.display = "none";
  var valign = opts.substr(0, 1);
  var halign = "l";
  if (opts.length > 1) {
   halign = opts.substr(1, 1);
  }
  
  switch (valign) {
      case "T": p.y -= h; break;
      case "B": p.y += el.offsetHeight; break;
      case "C": p.y += (el.offsetHeight - h) / 2; break;
      case "t": p.y += el.offsetHeight - h; break;
      case "b": break; 
  }
  
  switch (halign) {
      case "L": p.x -= w; break;
      case "R": p.x += el.offsetWidth; break;
      case "C": p.x += (el.offsetWidth - w) / 2; break;
      case "l": p.x += el.offsetWidth - w; break;
      case "r": break; 
  }
  p.width = w;
  p.height = h + 40;
  self.monthsCombo.style.display = "none";
  fixPosition(p);
  self.showAt(p.x, p.y);
 };
 if (Calendar.is_khtml)
  setTimeout("Calendar.continuation_for_the_fucking_khtml_browser()", 10);
 else
  Calendar.continuation_for_the_fucking_khtml_browser();
};


Calendar.prototype.setDateFormat = function (str) {
 this.dateFormat = str;
};


Calendar.prototype.setTtDateFormat = function (str) {
 this.ttDateFormat = str;
};


Calendar.prototype.parseDate = function(str, fmt) {
 if (!fmt)
  fmt = this.dateFormat;
 this.setDate(Date.parseDate(str, fmt));
};

Calendar.prototype.hideShowCovered = function () {
 if (!Calendar.is_ie && !Calendar.is_opera)
  return;
 function getVisib(obj){
  var value = obj.style.visibility;
  if (!value) {
   if (document.defaultView && typeof (document.defaultView.getComputedStyle) == "function") { 
    if (!Calendar.is_khtml)
     value = document.defaultView.
      getComputedStyle(obj, "").getPropertyValue("visibility");
    else
     value = '';
   } else if (obj.currentStyle) { 
    value = obj.currentStyle.visibility;
   } else
    value = '';
  }
  return value;
 };

 var tags = new Array("applet", "iframe", "select");
 var el = this.element;

 var p = Calendar.getAbsolutePos(el);
 var EX1 = p.x;
 var EX2 = el.offsetWidth + EX1;
 var EY1 = p.y;
 var EY2 = el.offsetHeight + EY1;

 for (var k = tags.length; k > 0; ) {
  var ar = document.getElementsByTagName(tags[--k]);
  var cc = null;

  for (var i = ar.length; i > 0;) {
   cc = ar[--i];

   p = Calendar.getAbsolutePos(cc);
   var CX1 = p.x;
   var CX2 = cc.offsetWidth + CX1;
   var CY1 = p.y;
   var CY2 = cc.offsetHeight + CY1;

   if (this.hidden || (CX1 > EX2) || (CX2 < EX1) || (CY1 > EY2) || (CY2 < EY1)) {
    if (!cc.__msh_save_visibility) {
     cc.__msh_save_visibility = getVisib(cc);
    }
    cc.style.visibility = cc.__msh_save_visibility;
   } else {
    if (!cc.__msh_save_visibility) {
     cc.__msh_save_visibility = getVisib(cc);
    }
    cc.style.visibility = "hidden";
   }
  }
 }
};


Calendar.prototype._displayWeekdays = function () {
 var fdow = this.firstDayOfWeek;
 var cell = this.firstdayname;
 var weekend = Calendar._TT["WEEKEND"];
 for (var i = 0; i < 7; ++i) {
  cell.className = "day name";
  var realday = (i + fdow) % 7;
  if (i) {
   cell.ttip = Calendar._TT["DAY_FIRST"].replace("%s", Calendar._DN[realday]);
   cell.navtype = 100;
   cell.calendar = this;
   cell.fdow = realday;
   Calendar._add_evs(cell);
  }
  if (weekend.indexOf(realday.toString()) != -1) {
   Calendar.addClass(cell, "weekend");
  }
  cell.innerHTML = Calendar._SDN[(i + fdow) % 7];
  cell = cell.nextSibling;
 }
};


Calendar.prototype._hideCombos = function () {
 this.monthsCombo.style.display = "none";
 this.yearsCombo.style.display = "none";
};


Calendar.prototype._dragStart = function (ev) {
 if (this.dragging) {
  return;
 }
 this.dragging = true;
 var posX;
 var posY;
 if (Calendar.is_ie) {
  posY = window.event.clientY + document.body.scrollTop;
  posX = window.event.clientX + document.body.scrollLeft;
 } else {
  posY = ev.clientY + window.scrollY;
  posX = ev.clientX + window.scrollX;
 }
 var st = this.element.style;
 this.xOffs = posX - parseInt(st.left);
 this.yOffs = posY - parseInt(st.top);
 with (Calendar) {
  addEvent(document, "mousemove", calDragIt);
  addEvent(document, "mouseup", calDragEnd);
 }
};




Date._MD = new Array(31,28,31,30,31,30,31,31,30,31,30,31);


Date.SECOND = 1000 ;
Date.MINUTE = 60 * Date.SECOND;
Date.HOUR   = 60 * Date.MINUTE;
Date.DAY    = 24 * Date.HOUR;
Date.WEEK   =  7 * Date.DAY;

Date.parseDate = function(str, fmt) {
 var today = new Date();
 var y = 0;
 var m = -1;
 var d = 0;
 var a = str.split(/\W+/);
 var b = fmt.match(/%./g);
 var i = 0, j = 0;
 var hr = 0;
 var min = 0;
 for (i = 0; i < a.length; ++i) {
  if (!a[i])
   continue;
  switch (b[i]) {
      case "%d":
      case "%e":
   d = parseInt(a[i], 10);
   break;

      case "%m":
   m = parseInt(a[i], 10) - 1;
   break;

      case "%Y":
      case "%y":
   y = parseInt(a[i], 10);
   (y < 100) && (y += (y > 29) ? 1900 : 2000);
   break;

      case "%b":
      case "%B":
   for (j = 0; j < 12; ++j) {
    if (Calendar._MN[j].substr(0, a[i].length).toLowerCase() == a[i].toLowerCase()) { m = j; break; }
   }
   break;

      case "%H":
      case "%I":
      case "%k":
      case "%l":
   hr = parseInt(a[i], 10);
   break;

      case "%P":
      case "%p":
   if (/pm/i.test(a[i]) && hr < 12)
    hr += 12;
   else if (/am/i.test(a[i]) && hr >= 12)
    hr -= 12;
   break;

      case "%M":
   min = parseInt(a[i], 10);
   break;
  }
 }
 if (isNaN(y)) y = today.getFullYear();
 if (isNaN(m)) m = today.getMonth();
 if (isNaN(d)) d = today.getDate();
 if (isNaN(hr)) hr = today.getHours();
 if (isNaN(min)) min = today.getMinutes();
 if (y != 0 && m != -1 && d != 0)
  return new Date(y, m, d, hr, min, 0);
 y = 0; m = -1; d = 0;
 for (i = 0; i < a.length; ++i) {
  if (a[i].search(/[a-zA-Z]+/) != -1) {
   var t = -1;
   for (j = 0; j < 12; ++j) {
    if (Calendar._MN[j].substr(0, a[i].length).toLowerCase() == a[i].toLowerCase()) { t = j; break; }
   }
   if (t != -1) {
    if (m != -1) {
     d = m+1;
    }
    m = t;
   }
  } else if (parseInt(a[i], 10) <= 12 && m == -1) {
   m = a[i]-1;
  } else if (parseInt(a[i], 10) > 31 && y == 0) {
   y = parseInt(a[i], 10);
   (y < 100) && (y += (y > 29) ? 1900 : 2000);
  } else if (d == 0) {
   d = a[i];
  }
 }
 if (y == 0)
  y = today.getFullYear();
 if (m != -1 && d != 0)
  return new Date(y, m, d, hr, min, 0);
 return today;
};


Date.prototype.getMonthDays = function(month) {
 var year = this.getFullYear();
 if (typeof month == "undefined") {
  month = this.getMonth();
 }
 if (((0 == (year%4)) && ( (0 != (year%100)) || (0 == (year%400)))) && month == 1) {
  return 29;
 } else {
  return Date._MD[month];
 }
};


Date.prototype.getDayOfYear = function() {
 var now = new Date(this.getFullYear(), this.getMonth(), this.getDate(), 0, 0, 0);
 var then = new Date(this.getFullYear(), 0, 0, 0, 0, 0);
 var time = now - then;
 return Math.floor(time / Date.DAY);
};


Date.prototype.getWeekNumber = function() {
 var d = new Date(this.getFullYear(), this.getMonth(), this.getDate(), 0, 0, 0);
 var DoW = d.getDay();
 d.setDate(d.getDate() - (DoW + 6) % 7 + 3); 
 var ms = d.valueOf(); 
 d.setMonth(0);
 d.setDate(4); 
 return Math.round((ms - d.valueOf()) / (7 * 864e5)) + 1;
};


Date.prototype.equalsTo = function(date) {
 return ((this.getFullYear() == date.getFullYear()) &&
  (this.getMonth() == date.getMonth()) &&
  (this.getDate() == date.getDate()) &&
  (this.getHours() == date.getHours()) &&
  (this.getMinutes() == date.getMinutes()));
};


Date.prototype.setDateOnly = function(date) {
 var tmp = new Date(date);
 this.setDate(1);
 this.setFullYear(tmp.getFullYear());
 this.setMonth(tmp.getMonth());
 this.setDate(tmp.getDate());
};


Date.prototype.print = function (str) {
 var m = this.getMonth();
 var d = this.getDate();
 var y = this.getFullYear();
 var wn = this.getWeekNumber();
 var w = this.getDay();
 var s = {};
 var hr = this.getHours();
 var pm = (hr >= 12);
 var ir = (pm) ? (hr - 12) : hr;
 var dy = this.getDayOfYear();
 if (ir == 0)
  ir = 12;
 var min = this.getMinutes();
 var sec = this.getSeconds();
 s["%a"] = Calendar._SDN[w]; 
 s["%A"] = Calendar._DN[w]; 
 s["%b"] = Calendar._SMN[m]; 
 s["%B"] = Calendar._MN[m]; 
 
 s["%C"] = 1 + Math.floor(y / 100); 
 s["%d"] = (d < 10) ? ("0" + d) : d; 
 s["%e"] = d; 
 
 
 s["%H"] = (hr < 10) ? ("0" + hr) : hr; 
 s["%I"] = (ir < 10) ? ("0" + ir) : ir; 
 s["%j"] = (dy < 100) ? ((dy < 10) ? ("00" + dy) : ("0" + dy)) : dy; 
 s["%k"] = hr;  
 s["%l"] = ir;  
 s["%m"] = (m < 9) ? ("0" + (1+m)) : (1+m); 
 s["%M"] = (min < 10) ? ("0" + min) : min; 
 s["%n"] = "\n";  
 s["%p"] = pm ? "PM" : "AM";
 s["%P"] = pm ? "pm" : "am";
 
 
 s["%s"] = Math.floor(this.getTime() / 1000);
 s["%S"] = (sec < 10) ? ("0" + sec) : sec; 
 s["%t"] = "\t";  
 
 s["%U"] = s["%W"] = s["%V"] = (wn < 10) ? ("0" + wn) : wn;
 s["%u"] = w + 1; 
 s["%w"] = w;  
 
 
 s["%y"] = ('' + y).substr(2, 2); 
 s["%Y"] = y;  
 s["%%"] = "%";  

 var re = /%./g;
 if (!Calendar.is_ie5 && !Calendar.is_khtml)
  return str.replace(re, function (par) { return s[par] || par; });

 var a = str.match(re);
 for (var i = 0; i < a.length; i++) {
  var tmp = s[a[i]];
  if (tmp) {
   re = new RegExp(a[i], 'g');
   str = str.replace(re, tmp);
  }
 }

 return str;
};

Date.prototype.__msh_oldSetFullYear = Date.prototype.setFullYear;
Date.prototype.setFullYear = function(y) {
 var d = new Date(this);
 d.__msh_oldSetFullYear(y);
 if (d.getMonth() != this.getMonth())
  this.setDate(28);
 this.__msh_oldSetFullYear(y);
};





window._dynarch_popupCalendar = null;
// ** I18N











Calendar._DN = new Array
("Sunday",
 "Monday",
 "Tuesday",
 "Wednesday",
 "Thursday",
 "Friday",
 "Saturday",
 "Sunday");












Calendar._SDN = new Array
("Sun",
 "Mon",
 "Tue",
 "Wed",
 "Thu",
 "Fri",
 "Sat",
 "Sun");



Calendar._FD = 0;


Calendar._MN = new Array
("January",
 "February",
 "March",
 "April",
 "May",
 "June",
 "July",
 "August",
 "September",
 "October",
 "November",
 "December");


Calendar._SMN = new Array
("Jan",
 "Feb",
 "Mar",
 "Apr",
 "May",
 "Jun",
 "Jul",
 "Aug",
 "Sep",
 "Oct",
 "Nov",
 "Dec");


Calendar._TT = {};
Calendar._TT["INFO"] = "About the calendar";

Calendar._TT["ABOUT"] =
"DHTML Date/Time Selector\n" +
"(c) dynarch.com 2002-2005 / Author: Mihai Bazon\n" + 
"For latest version visit: http://www.dynarch.com/projects/calendar/\n" +
"Distributed under GNU LGPL.  See http://gnu.org/licenses/lgpl.html for details." +
"\n\n" +
"Date selection:\n" +
"- Use the \xab, \xbb buttons to select year\n" +
"- Use the " + String.fromCharCode(0x2039) + ", " + String.fromCharCode(0x203a) + " buttons to select month\n" +
"- Hold mouse button on any of the above buttons for faster selection.";
Calendar._TT["ABOUT_TIME"] = "\n\n" +
"Time selection:\n" +
"- Click on any of the time parts to increase it\n" +
"- or Shift-click to decrease it\n" +
"- or click and drag for faster selection.";

Calendar._TT["PREV_YEAR"] = "Prev. year (hold for menu)";
Calendar._TT["PREV_MONTH"] = "Prev. month (hold for menu)";
Calendar._TT["GO_TODAY"] = "Go Today";
Calendar._TT["NEXT_MONTH"] = "Next month (hold for menu)";
Calendar._TT["NEXT_YEAR"] = "Next year (hold for menu)";
Calendar._TT["SEL_DATE"] = "Select date";
Calendar._TT["DRAG_TO_MOVE"] = "Drag to move";
Calendar._TT["PART_TODAY"] = " (today)";



Calendar._TT["DAY_FIRST"] = "Display %s first";




Calendar._TT["WEEKEND"] = "0,6";

Calendar._TT["CLOSE"] = "Close";
Calendar._TT["TODAY"] = "Today";
Calendar._TT["TIME_PART"] = "(Shift-)Click or drag to change value";


Calendar._TT["DEF_DATE_FORMAT"] = "%Y-%m-%d";
Calendar._TT["TT_DATE_FORMAT"] = "%a, %b %e";

Calendar._TT["WK"] = "wk";
Calendar._TT["TIME"] = "Time:";





Calendar.setup = function (params) {
 function param_default(pname, def) { if (typeof params[pname] == "undefined") { params[pname] = def; } };

 param_default("inputField",     null);
 param_default("displayArea",    null);
 param_default("button",         null);
 param_default("eventName",      "click");
 param_default("ifFormat",       "%Y/%m/%d");
 param_default("daFormat",       "%Y/%m/%d");
 param_default("singleClick",    true);
 param_default("disableFunc",    null);
 param_default("dateStatusFunc", params["disableFunc"]); 
 param_default("dateText",       null);
 param_default("firstDay",       null);
 param_default("align",          "Br");
 param_default("range",          [2008, 2030]);
 param_default("weekNumbers",    true);
 param_default("flat",           null);
 param_default("flatCallback",   null);
 param_default("onSelect",       null);
 param_default("onClose",        null);
 param_default("onUpdate",       null);
 param_default("date",           null);
 param_default("showsTime",      false);
 param_default("timeFormat",     "24");
 param_default("electric",       true);
 param_default("step",           2);
 param_default("position",       null);
 param_default("cache",          false);
 param_default("showOthers",     false);
 param_default("multiple",       null);

 var tmp = ["inputField", "displayArea", "button"];
 for (var i in tmp) {
  if (typeof params[tmp[i]] == "string") {
   params[tmp[i]] = document.getElementById(params[tmp[i]]);
  }
 }
 if (!(params.flat || params.multiple || params.inputField || params.displayArea || params.button)) {
  alert("Calendar.setup:\n  Nothing to setup (no fields found).  Please check your code");
  return false;
 }

 function onSelect(cal) {
  var p = cal.params;
  var update = (cal.dateClicked || p.electric);
  if (update && p.inputField) {
   p.inputField.value = cal.date.print(p.ifFormat);
   if (typeof p.inputField.onchange == "function")
    p.inputField.onchange();
  }
  if (update && p.displayArea)
   p.displayArea.innerHTML = cal.date.print(p.daFormat);
  if (update && typeof p.onUpdate == "function")
   p.onUpdate(cal);
  if (update && p.flat) {
   if (typeof p.flatCallback == "function")
    p.flatCallback(cal);
  }
  if (update && p.singleClick && cal.dateClicked)
   cal.callCloseHandler();
 };

 if (params.flat != null) {
  if (typeof params.flat == "string")
   params.flat = document.getElementById(params.flat);
  if (!params.flat) {
   alert("Calendar.setup:\n  Flat specified but can't find parent.");
   return false;
  }
  var cal = new Calendar(params.firstDay, params.date, params.onSelect || onSelect);
  cal.showsOtherMonths = params.showOthers;
  cal.showsTime = params.showsTime;
  cal.time24 = (params.timeFormat == "24");
  cal.params = params;
  cal.weekNumbers = params.weekNumbers;
  cal.setRange(params.range[0], params.range[1]);
  cal.setDateStatusHandler(params.dateStatusFunc);
  cal.getDateText = params.dateText;
  if (params.ifFormat) {
   cal.setDateFormat(params.ifFormat);
  }
  if (params.inputField && typeof params.inputField.value == "string") {
   cal.parseDate(params.inputField.value);
  }
  cal.create(params.flat);
  cal.show();
  return false;
 }

 var triggerEl = params.button || params.displayArea || params.inputField;
 triggerEl["on" + params.eventName] = function() {
  var dateEl = params.inputField || params.displayArea;
  var dateFmt = params.inputField ? params.ifFormat : params.daFormat;
  var mustCreate = false;
  var cal = window.calendar;
  if (dateEl)
   params.date = Date.parseDate(dateEl.value || dateEl.innerHTML, dateFmt);
  if (!(cal && params.cache)) {
   window.calendar = cal = new Calendar(params.firstDay,
            params.date,
            params.onSelect || onSelect,
            params.onClose || function(cal) { cal.hide(); });
   cal.showsTime = params.showsTime;
   cal.time24 = (params.timeFormat == "24");
   cal.weekNumbers = params.weekNumbers;
   mustCreate = true;
  } else {
   if (params.date)
    cal.setDate(params.date);
   cal.hide();
  }
  if (params.multiple) {
   cal.multiple = {};
   for (var i = params.multiple.length; --i >= 0;) {
    var d = params.multiple[i];
    var ds = d.print("%Y%m%d");
    cal.multiple[ds] = d;
   }
  }
  cal.showsOtherMonths = params.showOthers;
  cal.yearStep = params.step;
  cal.setRange(params.range[0], params.range[1]);
  cal.params = params;
  cal.setDateStatusHandler(params.dateStatusFunc);
  cal.getDateText = params.dateText;
  cal.setDateFormat(dateFmt);
  if (mustCreate)
   cal.create();
  cal.refresh();
  if (!params.position)
   cal.showAtElement(params.button || params.displayArea || params.inputField, params.align);
  else
   cal.showAt(params.position[0], params.position[1]);
  return false;
 };

 return cal;
};
// JavaScript Document
function Layaway(pieces) {
 if(pieces == 1) {
  document.getElementById("pp").disabled = false;
  document.getElementById("credit_card").disabled = false;
  document.getElementById("first_payment").value = "00000000";
  document.getElementById("first_payment").disabled = true;
  document.getElementById("datepicker").style.display = "none";
 } else {
  document.getElementById("wp").checked = true;
  document.getElementById("pp").disabled = true;
  document.getElementById("credit_card").disabled = true;
  document.getElementById("first_payment").disabled = false;
  document.getElementById("first_payment").value = "";
  document.getElementById("datepicker").style.display = "";
 }
 CheckForm(document.getElementById("wp").form);
}
function DateChanged(calendar) {
 if(calendar.dateClicked) {
  var y = calendar.date.getFullYear();
  var m = calendar.date.getMonth() + 1;
  var d = calendar.date.getDate();
  var Now = new Date();
  var Target = new Date(Now.getFullYear(), Now.getMonth(), Now.getDate());
  if(Target.getTime() <= calendar.date.getTime()) {
   document.getElementById("first_payment").value = y + "-" + m + "-" + d;
  } else {
   document.getElementById("first_payment").value = "";
  }
  CheckForm(document.getElementById("first_payment").form);
    }
}