/* <b style="font-size:13px;color:blue; text-decoration:blink;")">[ S ]</b> Opis kategorii (search - search_categoriesdescription) [56292]*/

function show_all() {
	var element= document.getElementById('box_description'); 
	var element2= document.getElementById('button_desc'); 
		if (element.style.display=="block") {
			element.style.display="none" ;
			element2.className="show_desc";
		} else {
			element.style.display="block"; 
			element2.className="hide_desc";
		}
}
/* <b style="font-size:13px;color:blue; text-decoration:blink;")">[ S ]</b>  TOP 4.0 (layout_top - menu_top) [56139]*/

//////////////////////////////////////////////////////////////////////////////////////////////
/////// THUMBNAILS_SWITCH

function StarRotate(click, num, nama)
{

var elems = document.getElementsByName(nama);
if(num ==1)
{
for(i=0; i < elems.length; i++)
     {
      elems[i].className="star_inactive";
     }
click.className="star_active";
}


var j = 1;
if(num==2)
{
for(i=0; i < elems.length; i++)
     {
      if(elems[i].className && elems[i].className == "star_active")
            {
              elems[i].className="star_inactive";
              if(i+1< elems.length){
              i++;
               elems[i].className="star_active";
              i++;
              }
            }
     else
            {
             elems[i].className="star_inactive";
             if(j+1 == elems.length) elems[0].className="star_active";
             }
j++;
     }
}

j = elems.length;
if(num==3)
{
for(i=elems.length -1; i > 0; i--)
     {
      if(elems[i].className && elems[i].className == "star_active")
            {
              elems[i].className="star_inactive";
              if(i-1< elems.length){
              i--;
               elems[i].className="star_active";
              i--;
              }
            }
     else
            {
             elems[i].className="star_inactive";
             if(j == elems.length - 1) {elems[elems.length-1].className="star_active";elems[0].className="star_inactive";}
             }
j--;
     }
}

}function StarRotate(click, num, nama)
{

var elems = document.getElementsByName(nama);
if(num ==1)
{
for(i=0; i < elems.length; i++)
     {
      elems[i].className="star_inactive";
     }
click.className="star_active";
}


var j = 1;
if(num==2)
{
for(i=0; i < elems.length; i++)
     {
      if(elems[i].className && elems[i].className == "star_active")
            {
              elems[i].className="star_inactive";
              if(i+1< elems.length){
              i++;
               elems[i].className="star_active";
              i++;
              }
            }
     else
            {
             elems[i].className="star_inactive";
             if(j+1 == elems.length) elems[0].className="star_active";
             }
j++;
     }
}

j = 1;
if(num==3)
{
for(i=elems.length -1; i > 0; i--)
     {
      if(elems[i].className && elems[i].className == "star_active")
            {
              elems[i].className="star_inactive";
              if(i-1< elems.length){
              i--;
               elems[i].className="star_active";
              i--;
              }
            }
     else
            {
             elems[i].className="star_inactive";
             if(j == elems.length - 1) {elems[0].className="star_inactive";elems[elems.length-1].className="star_active";}
             }
j++;
     }
}

}


var Prototype = {
  Version: '1.5.1',

  Browser: {
    IE:     !!(window.attachEvent && !window.opera),
    Opera:  !!window.opera,
    WebKit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
    Gecko:  navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1
  },

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

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

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

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

  toJSON: function(object) {
    var type = typeof object;
    switch(type) {
      case 'undefined':
      case 'function':
      case 'unknown': return;
      case 'boolean': return object.toString();
    }
    if (object === null) return 'null';
    if (object.toJSON) return object.toJSON();
    if (object.ownerDocument === document) return;
    var results = [];
    for (var property in object) {
      var value = Object.toJSON(object[property]);
      if (value !== undefined)
        results.push(property.toJSON() + ': ' + value);
    }
    return '{' + results.join(', ') + '}';
  },

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

Object.extend(Number.prototype, {
  toColorPart: function() {
    return this.toPaddedString(2, 16);
  },

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

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

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

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

Date.prototype.toJSON = function() {
  return '"' + this.getFullYear() + '-' +
    (this.getMonth() + 1).toPaddedString(2) + '-' +
    this.getDate().toPaddedString(2) + 'T' +
    this.getHours().toPaddedString(2) + ':' +
    this.getMinutes().toPaddedString(2) + ':' +
    this.getSeconds().toPaddedString(2) + '"';
};

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;
      }
    }
  }
}
Object.extend(String, {
  interpret: function(value) {
    return value == null ? '' : String(value);
  },
  specialChar: {
    '\b': '\\b',
    '\t': '\\t',
    '\n': '\\n',
    '\f': '\\f',
    '\r': '\\r',
    '\\': '\\\\'
  }
});

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

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

  sub: function(pattern, replacement, count) {
    replacement = this.gsub.prepareReplacement(replacement);
    count = 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 self = arguments.callee;
    self.text.data = this;
    return self.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 key = decodeURIComponent(pair.shift());
        var value = pair.length > 1 ? pair.join('=') : pair[0];
        if (value != undefined) value = decodeURIComponent(value);

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

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

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

  times: function(count) {
    var result = '';
    for (var i = 0; i < count; i++) result += this;
    return result;
  },

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

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

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

    return camelized;
  },

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

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

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

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

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

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

  evalJSON: function(sanitize) {
    var json = this.unfilterJSON();
    try {
      if (!sanitize || (/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/.test(json)))
        return eval('(' + json + ')');
    } catch (e) { }
    throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
  },

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

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

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

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

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

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

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

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

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

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

var Template = Class.create();
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 = {}, $continue = new Error('"throw $continue" is deprecated, use "return" instead');

var Enumerable = {
  each: function(iterator) {
    var index = 0;
    try {
      this._each(function(value) {
        iterator(value, index++);
      });
    } 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;
  }
}

if (Prototype.Browser.WebKit) {
  $A = Array.from = function(iterable) {
    if (!iterable) return [];
    if (!(typeof iterable == 'function' && iterable == '[object NodeList]') &&
      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(sorted) {
    return this.inject([], function(array, value, index) {
      if (0 == index || (sorted ? array.last() != value : !array.include(value)))
        array.push(value);
      return array;
    });
  },

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

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

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

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

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

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

if (Prototype.Browser.Opera){
  Array.prototype.concat = function() {
    var array = [];
    for (var i = 0, length = this.length; i < length; i++) array.push(this[i]);
    for (var i = 0, length = arguments.length; i < length; i++) {
      if (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(object) {
  if (object instanceof Hash) this.merge(object);
  else Object.extend(this, object || {});
};

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

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

      if (value && typeof value == 'object') {
        if (value.constructor == Array) value.each(function(value) {
          parts.add(pair.key, value);
        });
        return;
      }
      parts.add(pair.key, value);
    });

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

  toJSON: function(object) {
    var results = [];
    this.prototype._each.call(object, function(pair) {
      var value = Object.toJSON(pair.value);
      if (value !== undefined) results.push(pair.key.toJSON() + ': ' + value);
    });
    return '{' + results.join(', ') + '}';
  }
});

Hash.toQueryString.addPair = function(key, value, prefix) {
  key = encodeURIComponent(key);
  if (value === undefined) this.push(key);
  else this.push(key + '=' + (value == null ? '' : encodeURIComponent(value)));
}

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

  toJSON: function() {
    return Hash.toJSON(this);
  }
});

function $H(object) {
  if (object instanceof Hash) return object;
  return new Hash(object);
};

// Safari iterates over shadowed properties
if (function() {
  var i = 0, Test = function(value) { this.key = value };
  Test.prototype.key = 'foo';
  for (var property in new Test('bar')) i++;
  return i > 1;
}()) Hash.prototype._each = function(iterator) {
  var cache = [];
  for (var key in this) {
    var value = this[key];
    if ((value && value == Hash.prototype[key]) || cache.include(key)) continue;
    cache.push(key);
    var pair = [key, value];
    pair.key = key;
    pair.value = value;
    iterator(pair);
  }
};
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 = Object.clone(this.options.parameters);

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

    this.parameters = params;

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

    try {
      if (this.options.onCreate) this.options.onCreate(this.transport);
      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();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Ajax.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) {
    var q = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
    return document._getElementsByXPath(q, parentElement);
  }

} else document.getElementsByClassName = function(className, parentElement) {
  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 = {};

Element.extend = function(element) {
  var F = Prototype.BrowserFeatures;
  if (!element || !element.tagName || element.nodeType == 3 ||
   element._extended || F.SpecificElementExtensions || element == window)
    return element;

  var methods = {}, tagName = element.tagName, cache = Element.extend.cache,
   T = Element.Methods.ByTag;

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

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

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

  element._extended = Prototype.emptyFunction;
  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('*')).each(Element.extend);
  },

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

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

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

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

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

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

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

  down: function(element, expression, index) {
    element = $(element);
    if (arguments.length == 1) return element.firstDescendant();
    var descendants = element.descendants();
    return expression ? Selector.findElement(descendants, expression, index) :
      descendants[index || 0];
  },

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

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

  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 (Prototype.Browser.IE) {
      if (!element.attributes) return null;
      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];
      return attribute ? attribute.nodeValue : null;
    }
    return element.getAttribute(name);
  },

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

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

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

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

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

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

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

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

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

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

  empty: function(element) {
    return $(element).innerHTML.blank();
  },

  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);
    style = style == 'float' ? 'cssFloat' : style.camelize();
    var value = element.style[style];
    if (!value) {
      var css = document.defaultView.getComputedStyle(element, null);
      value = css ? css[style] : null;
    }
    if (style == 'opacity') return value ? parseFloat(value) : 1.0;
    return value == 'auto' ? null : value;
  },

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

  setStyle: function(element, styles, camelized) {
    element = $(element);
    var elementStyle = element.style;

    for (var property in styles)
      if (property == 'opacity') element.setOpacity(styles[property])
      else
        elementStyle[(property == 'float' || property == 'cssFloat') ?
          (elementStyle.styleFloat === undefined ? 'cssFloat' : 'styleFloat') :
          (camelized ? property : property.camelize())] = styles[property];

    return element;
  },

  setOpacity: function(element, value) {
    element = $(element);
    element.style.opacity = (value == 1 || value === '') ? '' :
      (value < 0.00001) ? 0 : value;
    return element;
  },

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

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

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

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

  makeClipping: function(element) {
    element = $(element);
    if (element._overflow) return element;
    element._overflow = element.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,
  childElements: Element.Methods.immediateDescendants
});

if (Prototype.Browser.Opera) {
  Element.Methods._getStyle = Element.Methods.getStyle;
  Element.Methods.getStyle = function(element, style) {
    switch(style) {
      case 'left':
      case 'top':
      case 'right':
      case 'bottom':
        if (Element._getStyle(element, 'position') == 'static') return null;
      default: return Element._getStyle(element, style);
    }
  };
}
else if (Prototype.Browser.IE) {
  Element.Methods.getStyle = function(element, style) {
    element = $(element);
    style = (style == 'float' || style == 'cssFloat') ? 'styleFloat' : style.camelize();
    var value = element.style[style];
    if (!value && element.currentStyle) value = element.currentStyle[style];

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

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

  Element.Methods.setOpacity = function(element, value) {
    element = $(element);
    var filter = element.getStyle('filter'), style = element.style;
    if (value == 1 || value === '') {
      style.filter = filter.replace(/alpha\([^\)]*\)/gi,'');
      return element;
    } else if (value < 0.00001) value = 0;
    style.filter = filter.replace(/alpha\([^\)]*\)/gi, '') +
      'alpha(opacity=' + (value * 100) + ')';
    return element;
  };

  // IE is missing .innerHTML support for TABLE-related elements
  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;
  }
}
else if (Prototype.Browser.Gecko) {
  Element.Methods.setOpacity = function(element, value) {
    element = $(element);
    element.style.opacity = (value == 1) ? 0.999999 :
      (value === '') ? '' : (value < 0.00001) ? 0 : value;
    return element;
  };
}

Element._attributeTranslations = {
  names: {
    colspan:   "colSpan",
    rowspan:   "rowSpan",
    valign:    "vAlign",
    datetime:  "dateTime",
    accesskey: "accessKey",
    tabindex:  "tabIndex",
    enctype:   "encType",
    maxlength: "maxLength",
    readonly:  "readOnly",
    longdesc:  "longDesc"
  },
  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;
    }
  }
};

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

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

Element.Methods.ByTag = {};

Object.extend(Element, Element.Methods);

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

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

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

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

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

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

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

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

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

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

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

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

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

var 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.expression = expression.strip();
    this.compileMatcher();
  },

  compileMatcher: function() {
    // Selectors with namespaced attributes can't use the XPath version
    if (Prototype.BrowserFeatures.XPath && !(/\[[\w-]*?:/).test(this.expression))
      return this.compileXPathMatcher();

    var e = this.expression, ps = Selector.patterns, h = Selector.handlers,
        c = Selector.criteria, le, p, m;

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

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

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

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

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

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

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

  findElements: function(root) {
    root = root || document;
    if (this.xpath) return document._getElementsByXPath(this.xpath, root);
    return this.matcher(root);
  },

  match: function(element) {
    return this.findElements(document).include(element);
  },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  findChildElements: function(element, expressions) {
    var exprs = expressions.join(','), expressions = [];
    exprs.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {
      expressions.push(m[1].strip());
    });
    var results = [], h = Selector.handlers;
    for (var i = 0, l = expressions.length, selector; i < l; i++) {
      selector = new Selector(expressions[i].strip());
      h.concat(results, selector.findElements(element));
    }
    return (l > 1) ? h.unique(results) : results;
  }
});

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 != null) {
         	if (key in result) {
            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(form).invoke('disable');
    return form;
  },

  enable: function(form) {
    form = $(form);
    Form.getElements(form).invoke('enable');
    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;
  },

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

    var params = options.parameters;
    options.parameters = form.serialize(true);

    if (params) {
      if (typeof params == 'string') params = params.toQueryParams();
      Object.extend(options.parameters, params);
    }

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

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

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

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

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

Form.Element.Methods = {
  serialize: function(element) {
    element = $(element);
    if (!element.disabled && element.name) {
      var value = element.getValue();
      if (value != undefined) {
        var pair = {};
        pair[element.name] = value;
        return 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);
    try {
      element.focus();
      if (element.select && (element.tagName.toLowerCase() != 'input' ||
        !['button', 'reset', 'submit'].include(element.type)))
        element.select();
    } catch (e) {}
    return element;
  },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  observers: false,

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

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

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

    if (name == 'keypress' &&
      (Prototype.Browser.WebKit || element.attachEvent))
      name = 'keydown';

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

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

    if (name == 'keypress' &&
        (Prototype.Browser.WebKit || element.attachEvent))
      name = 'keydown';

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

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

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

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

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

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

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

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

    return document.body;
  },

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

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

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

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

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

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

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

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

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

    } while (element = element.offsetParent);

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

    return [valueL, valueT];
  },

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

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

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

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

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

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

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

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

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

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

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

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

// Safari returns margins on body which is incorrect if the child is absolutely
// positioned.  For performance reasons, redefine Position.cumulativeOffset for
// KHTML/WebKit only.
if (Prototype.Browser.WebKit) {
  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();

// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// Contributors:
//  Justin Palmer (http://encytemedia.com/)
//  Mark Pilgrim (http://diveintomark.org/)
//  Martin Bialasinki
// 
// See scriptaculous.js for full license.  

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

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

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

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

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

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

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

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

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

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

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

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

var Effect = {
  _elementDoesNotExistError: {
    name: 'ElementDoesNotExistError',
    message: 'The specified DOM element does not exist, but is required for this effect to operate'
  },
  tagifyText: function(element) {
    if(typeof Builder == 'undefined')
      throw("Effect.tagifyText requires including script.aculo.us' builder.js library");
      
    var tagifyStyle = 'position:relative';
    if(/MSIE/.test(navigator.userAgent) && !window.opera) tagifyStyle += ';zoom:1';
    element = $(element);
    $A(element.childNodes).each( function(child) {
      if(child.nodeType==3) {
        child.nodeValue.toArray().each( function(character) {
          element.insertBefore(
            Builder.node('span',{style: tagifyStyle},
              character == ' ' ? String.fromCharCode(160) : character), 
              child);
        });
        Element.remove(child);
      }
    });
  },
  multiple: function(element, effect) {
    var elements;
    if(((typeof element == 'object') || 
        (typeof element == 'function')) && 
       (element.length))
      elements = element;
    else
      elements = $(element).childNodes;
      
    var options = Object.extend({
      speed: 0.1,
      delay: 0.0
    }, arguments[2] || {});
    var masterDelay = options.delay;

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

var Effect2 = Effect; // deprecated

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

Effect.Transitions = {}

Effect.Transitions.linear = Prototype.K;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Effect.SlideUp = function(element) {
  element = $(element);
  element.cleanWhitespace();
  var oldInnerBottom = $(element.firstChild).getStyle('bottom');
  return new Effect.Scale(element, window.opera ? 0 : 1,
   Object.extend({ scaleContent: false, 
    scaleX: false, 
    scaleMode: 'box',
    scaleFrom: 100,
    restoreAfterFinish: true,
    beforeStartInternal: function(effect) {
      effect.element.makePositioned();
      effect.element.firstChild.makePositioned();
      if(window.opera) effect.element.setStyle({top: ''});
      effect.element.makeClipping();
      effect.element.show(); },  
    afterUpdateInternal: function(effect) {
      effect.element.firstChild.setStyle({bottom:
        (effect.dims[0] - effect.element.clientHeight) + 'px' }); },
    afterFinishInternal: function(effect) {
      effect.element.hide();
      effect.element.undoClipping();
      effect.element.firstChild.undoPositioned();
      effect.element.undoPositioned();
      effect.element.setStyle({bottom: oldInnerBottom}); }
   }, arguments[1] || {})
  );
}

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

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

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

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

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

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

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

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

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

Element.addMethods();


/**
 * @author Bruno Bornsztein <bruno@missingmethod.com>
 * @copyright 2007 Curbly LLC
 * @package Glider
 * @license MIT
 * @url http://www.missingmethod.com/projects/glider/
 * @version 0.0.3
 * @dependencies prototype.js 1.5.1+, effects.js
 */

/*  Thanks to Andrew Dupont for refactoring help and code cleanup - http://andrewdupont.net/  */

Glider = Class.create();
Object.extend(Object.extend(Glider.prototype, Abstract.prototype), {
	initialize: function(wrapper, options){
	    this.scrolling  = false;
	    this.wrapper    = $(wrapper);
	    this.scroller   = this.wrapper.down('div.scroller');
	    this.sections   = this.wrapper.getElementsBySelector('div.section');
	    this.options    = Object.extend({ duration: 1.0, frequency: 3 }, options || {});

	    this.sections.each( function(section, index) {
	      section._index = index;
	    });    

	    this.events = {
	      click: this.click.bind(this)
	    };

	    this.addObservers();
			if(this.options.initialSection) this.moveTo(this.options.initialSection, this.scroller, { duration:this.options.duration });  // initialSection should be the id of the section you want to show up on load
			if(this.options.autoGlide) this.start();
	  },
	
  addObservers: function() {
    var controls = this.wrapper.getElementsBySelector('div.controls a');
    controls.invoke('observe', 'click', this.events.click);
  },	

  click: function(event) {
		this.stop();
    var element = Event.findElement(event, 'a');
    if (this.scrolling) this.scrolling.cancel();
    
    this.moveTo(element.href.split("#")[1], this.scroller, { duration:this.options.duration });     
    Event.stop(event);
  },

	moveTo: function(element, container, options){
			this.current = $(element);

			Position.prepare();
	    var containerOffset = Position.cumulativeOffset(container),
	     elementOffset = Position.cumulativeOffset($(element));

		  this.scrolling 	= new Effect.SmoothScroll(container, 
				{duration:options.duration, x:(elementOffset[0]-containerOffset[0]), y:(elementOffset[1]-containerOffset[1])});
		  return false;
		},
		
  next: function(){
    if (this.current) {
      var currentIndex = this.current._index;
      var nextIndex = (this.sections.length - 1 == currentIndex) ? 0 : currentIndex + 1;      
    } else var nextIndex = 1;

    this.moveTo(this.sections[nextIndex], this.scroller, { 
      duration: this.options.duration
    });
  },
	
  previous: function(){
    if (this.current) {
      var currentIndex = this.current._index;
      var prevIndex = (currentIndex == 0) ? this.sections.length - 1 : 
       currentIndex - 1;
    } else var prevIndex = this.sections.length - 1;
    
    this.moveTo(this.sections[prevIndex], this.scroller, { 
      duration: this.options.duration
    });
  },

	stop: function()
	{
		clearTimeout(this.timer);
	},
	
	start: function()
	{
		this.periodicallyUpdate();
	},
		
	periodicallyUpdate: function()
	{ 
		if (this.timer != null) {
			clearTimeout(this.timer);
			this.next();
		}
		this.timer = setTimeout(this.periodicallyUpdate.bind(this), this.options.frequency*1000);
	}

});






Effect.SmoothScroll = Class.create();
Object.extend(Object.extend(Effect.SmoothScroll.prototype, Effect.Base.prototype), {
  initialize: function(element) {
    this.element = $(element);
    var options = Object.extend({
      x:    0,
      y:    0,
      mode: 'absolute'
    } , arguments[1] || {}  );
    this.start(options);
  },
  setup: function() {
    if (this.options.continuous && !this.element._ext ) {
      this.element.cleanWhitespace();
      this.element._ext=true;
      this.element.appendChild(this.element.firstChild);
    }
   
    this.originalLeft=this.element.scrollLeft;
    this.originalTop=this.element.scrollTop;
   
    if(this.options.mode == 'absolute') {
      this.options.x -= this.originalLeft;
      this.options.y -= this.originalTop;
    } 
  },
  update: function(position) {   
    this.element.scrollLeft = this.options.x * position + this.originalLeft;
    this.element.scrollTop  = this.options.y * position + this.originalTop;
  }
});


/////////////////////////

function getXY_gix(e,id){
                    var element = document.getElementById(id);
             element.style.display = 'block';
             element.style.left = e.clientX+document.body.scrollLeft+'px';
             element.style.top = e.clientY+document.body.scrollTop+10+'px';
                          }
    function hidde_gix(id){
         document.getElementById(id).style.display = 'none';
      }
/* !!! Wyszukiwarka ver. 4.0  ( odchudzony kod i ujednolicony wygląd ) (searching - searching) [54635]*/

function insletter(letter, idk) {
 var inp = document.getElementById (idk);
 inp.value += letter;
 inp.focus();
}

function insletterB(letter, idk) {
 var inp = document.getElementById (idk);
 tv = inp.value;
 tv = tv.substr(0,tv.length-1);
 letter = letter.toUpperCase();

 inp.value = tv+letter;
 inp.focus();
}
/* Formularz wyboru sposobu płatności ver 3.5 (order-newpayment - newpayment_form) [53474]*/

function orderpayment(id) {

document.getElementById('idle_payment').style.display = 'none';
    allDivs = document.getElementsByTagName("div");

    for (i = 0; i < allDivs.length; i++) {
        if ((/^newpayment_form_/).test(allDivs[i].id) == true) {
            allDivs[i].style.display = 'none';
        }
    }

    if (document.getElementById('newpayment_form_'+id) ) {
        document.getElementById('newpayment_form_'+id).style.display = 'block';
    }
}
/* <b style="font-size:12px;color:red; text-decoration:blink">&gt;</b> Wyszukiwarka 4.0 BASIC STYCZEŃ Bez nagłówka Image-Moda (layout_left - menu_search) [56621]*/

function searching_blur(x) {
         if (x.value == '') {
                 x.value = searchtxt;
         }
}


function searching_focus(x) {
         if (x.value != '') {
                 x.value = '';
         }
 }
/* <font style="text-decoration:blink;font-weight:bold;color:green;">[!] </font>koszyk CZERWIEC 08  (basketedit - basketedit_productslist) [55925]*/

function basket_isNumeric(id, precision){
	
		var elem = document.getElementById(id);
	
		if (precision > 0){
			if(elem.value.match("^[0-9]{1,9}[.,]{0,1}[0-9]{0,"+precision+"}$") || elem.value ==''){
				elem.value = elem.value.replace(',', '.'); 
				return true;
			}else{
				elem.value = elem.value.substring(0, elem.value.length-1 );
				return false;
			}
	
		}
		if (precision == 0){
			if(elem.value.match("^[1-9]{1}[0-9]{0,9}$") || elem.value ==''){
				
				return true;
			}else{
				elem.value = elem.value.substring(0, elem.value.length-1 );
				return false;
			}
		}	
	
	


	
}
/* <font style="text-decoration:blink;font-weight:bold;color:green;">[!] </font>Formularz dodawania klienta 4.5 (client-new - client_new_form) [56203]*/
var client_new_txt1 = 'Wysyłka na adres zamawiającego';
var client_new_txt1b = 'Wysyłka na adres z faktury';

var client_new_txt2 = 'Adres zamawiającego';
var client_new_txt2b = 'Dane do faktury';

var client_new_txt3 = 'Dane kontaktowe';
var client_new_txt3b = 'Dane kontaktowe';
var client_new_texts;
if (! client_new_texts) {
var client_new_txt1 = 'Wysyłka na adres zamawiającego';
var client_new_txt1b = 'Wysyłka na adres z faktury';
var client_new_txt2 = 'Adres zamawiającego';
var client_new_txt2b = 'Dane do faktury';
var client_new_txt3 = 'Dane kontaktowe';
var client_new_txt3b = 'Dane kontaktowe';
}

var ClientNew_status = true;
var ClientNew_firma = false;
var ClientNew_adres = true;
var ClientNewMandatoryMail = false; 
var ClientNewMandatoryPhone = false;

var ClientSender = new Array();

var RemoveAddresLink;

var ClientNew = {
    switchDiVDeliveryAddres: function()
    {
        document.getElementById("selectDeliveryAddress").style.display = "none";
        document.getElementById("selectDeliveryAddress2").style.display = "block";
    },

    switchDeliveryAddres: function(id, obj)
    {
        var IdAddress = id;
        if (IdAddress) {
           document.getElementById('delivery_id').value = IdAddress;
            document.getElementById("selectDeliveryAddress").innerHTML = obj.firstChild.innerHTML;

           document.getElementById("selectDeliveryAddress2").style.display = "none";
           document.getElementById("selectDeliveryAddress").style.display = "block";

            document.getElementById('additional_firstname').value = ClientDeliveryAddreses[IdAddress+"_firstname"];
            document.getElementById('additional_lastname').value = ClientDeliveryAddreses[IdAddress+"_lastname"];
            document.getElementById('additional_city').value = ClientDeliveryAddreses[IdAddress+"_city"];
            document.getElementById('additional_additional').value = ClientDeliveryAddreses[IdAddress+"_additional"];
            document.getElementById('additional_street').value = ClientDeliveryAddreses[IdAddress+"_street"];
            document.getElementById('additional_zipcode').value = ClientDeliveryAddreses[IdAddress+"_zipcode"];
            document.getElementById('additional_phone').value = ClientDeliveryAddreses[IdAddress+"_phone"];

            if (document.getElementById('additional_region') && document.getElementById('additional_region').options) {
                for (i=0; i < document.getElementById('additional_region').options.length; i++) {
                    if (document.getElementById('additional_region').options[i].value == ClientDeliveryAddreses[IdAddress+"_region_id"]) {      
                        document.getElementById('additional_region').selectedIndex  = i;
                        break;
                    }
                }
            }
  
            if (ClientDeliveryAddreses[IdAddress+"_removable"] == 'yes') {
                document.getElementById('delete_delivery_address').style.display = '';
                RemoveAddresLink = ClientDeliveryAddreses[IdAddress+"_removelink"];
            } else {
                document.getElementById('delete_delivery_address').style.display = 'none';
                RemoveAddresLink = '';
            }
        } else {
            document.getElementById('delete_delivery_address').style.display = 'none';
            RemoveAddresLink = '';
            document.getElementById('additional_firstname').value = '';
            document.getElementById('additional_lastname').value = '';
            document.getElementById('additional_city').value = '';
            document.getElementById('additional_additional').value = '';
            document.getElementById('additional_street').value = '';
            document.getElementById('additional_zipcode').value = '';
            document.getElementById('additional_phone').value = '';
        }

        if (ClientDeliveryAddreses[IdAddress+"_editable"] == 'no') {
            document.getElementById('additional_firstname').disabled = 'disabled';
            document.getElementById('additional_lastname').disabled = 'disabled';
            document.getElementById('additional_city').disabled = 'disabled';
            document.getElementById('additional_additional').disabled = 'disabled';
            document.getElementById('additional_street').disabled = 'disabled';
            document.getElementById('additional_zipcode').disabled = 'disabled';
            document.getElementById('additional_phone').disabled = 'disabled';
            document.getElementById('additional_region').disabled = 'disabled';
        } else {
            document.getElementById('additional_firstname').disabled = '';
            document.getElementById('additional_lastname').disabled = '';
            document.getElementById('additional_city').disabled = '';
            document.getElementById('additional_additional').disabled = '';
            document.getElementById('additional_street').disabled = '';
            document.getElementById('additional_zipcode').disabled = '';
            document.getElementById('additional_phone').disabled = '';
            document.getElementById('additional_region').disabled = '';
        }
    },

    removeDeliveryAddress: function() 
    {
        if (RemoveAddresLink) {
            if (confirm("Czy na pewno chcesz usunąć ten adres dostawy?")) {
                IAI_Ajax.Request('ajax/client-new.php?removeAddres=true', 'address='+document.getElementById('delivery_id').value, {onSuccess: 'ClientNew.deleteAddress'});
            }
        }
    },

    newDeliveryAddress: function() 
    {
        document.getElementById('delivery_id').value = '';
        document.getElementById('selectDeliveryAddress').style.display = 'none';
        document.getElementById('selectDeliveryAddress2').style.display = 'none';
        document.getElementById('additional_address_list_txt').style.display = 'none';
        document.getElementById('delete_delivery_address').style.display = 'none';
        document.getElementById('newDeliveryAddress').style.display = 'none';
        document.getElementById('saveDeliveryAddress').style.display = 'block';
        RemoveAddresLink = '';
        document.getElementById('additional_firstname').value = '';
        document.getElementById('additional_lastname').value = '';
        document.getElementById('additional_city').value = '';
        document.getElementById('additional_additional').value = '';
        document.getElementById('additional_street').value = '';
        document.getElementById('additional_zipcode').value = '';
        document.getElementById('additional_phone').value = '';

        document.getElementById('additional_firstname').disabled = '';
        document.getElementById('additional_lastname').disabled = '';
        document.getElementById('additional_city').disabled = '';
        document.getElementById('additional_additional').disabled = '';
        document.getElementById('additional_street').disabled = '';
        document.getElementById('additional_zipcode').disabled = '';
        document.getElementById('additional_phone').disabled = '';
        document.getElementById('additional_region').disabled = '';
    },

    deleteAddress: function(x)
    {
        try {
            var response = eval('(' + x + ')');
        } catch (e) {
            return false;
        }
        xr = response;
        
       document.getElementById('delivery_list_id_'+response.remove).style.display = "none";

        ClientNew.switchDeliveryAddres(response.selected, document.getElementById('delivery_list_id_'+response.selected));
    },

    copyDeliveryAddres: function() 
    {
        if (document.getElementById('deliver_to_billingaddr').checked) {
            document.getElementById('delivery_additional').value = ClientNew_firma  ? document.getElementById('client_firm').value : '';
            document.getElementById('delivery_firstname').value  = document.getElementById('client_firstname').value;
            document.getElementById('delivery_lastname').value   = document.getElementById('client_lastname').value;
            document.getElementById('delivery_zipcode').value    = document.getElementById('client_zipcode').value;
            document.getElementById('delivery_street').value     = document.getElementById('client_street').value;
            document.getElementById('delivery_city').value       = document.getElementById('client_city').value;
            document.getElementById('delivery_phone').value    = document.getElementById('client_phone').value;
                
            document.getElementById('box_4').className = 'n56203_box_idle';
            document.getElementById('delivery_additional').disabled = 'disabled';
            document.getElementById('delivery_firstname').disabled = 'disabled';
            document.getElementById('delivery_lastname').disabled = 'disabled';
            document.getElementById('delivery_zipcode').disabled = 'disabled';
            document.getElementById('delivery_street').disabled = 'disabled';
            document.getElementById('delivery_city').disabled = 'disabled';
            if (document.getElementById('delivery_region')) {
                document.getElementById('delivery_region').value     = document.getElementById('client_region').value;
                document.getElementById('delivery_region').disabled = 'disabled';
            } 
        } else {
            document.getElementById('box_4').className = 'n56203_box';
            document.getElementById('delivery_additional').disabled = '';
            document.getElementById('delivery_firstname').disabled = '';
            document.getElementById('delivery_lastname').disabled = '';
            document.getElementById('delivery_zipcode').disabled = '';
            document.getElementById('delivery_street').disabled = '';
            document.getElementById('delivery_city').disabled = '';
            document.getElementById('delivery_phone').disabled = '';

            document.getElementById('delivery_additional_img_off').style.display = document.getElementById('client_firm_img_off').style.display;
	    document.getElementById('delivery_additional_img_on').style.display = document.getElementById('client_firm_img_on').style.display;
            document.getElementById('delivery_firstname_img_off').style.display = document.getElementById('client_firstname_img_off').style.display;
	    document.getElementById('delivery_firstname_img_on').style.display = document.getElementById('client_firstname_img_on').style.display;
            document.getElementById('delivery_lastname_img_off').style.display = document.getElementById('client_lastname_img_off').style.display;
	    document.getElementById('delivery_lastname_img_on').style.display = document.getElementById('client_lastname_img_on').style.display;
            document.getElementById('delivery_zipcode_img_off').style.display = document.getElementById('client_zipcode_img_off').style.display;
	    document.getElementById('delivery_zipcode_img_on').style.display = document.getElementById('client_zipcode_img_on').style.display;
            document.getElementById('delivery_street_img_off').style.display = document.getElementById('client_street_img_off').style.display;
	    document.getElementById('delivery_street_img_on').style.display = document.getElementById('client_street_img_on').style.display;
            document.getElementById('delivery_city_img_off').style.display = document.getElementById('client_city_img_off').style.display;
	    document.getElementById('delivery_city_img_on').style.display = document.getElementById('client_city_img_on').style.display;
            document.getElementById('delivery_phone_img_off').style.display = document.getElementById('client_phone_img_off').style.display;
	    document.getElementById('delivery_phone_img_on').style.display = document.getElementById('client_phone_img_on').style.display;

            if (document.getElementById('delivery_region')) {
                document.getElementById('delivery_region').disabled = '';
            } 
        }
    },

    check_inp: function (idd, name, delay) {
        if (document.getElementById(idd)) {
            idd = document.getElementById(idd);
        }
        var value = idd.value;
        if (ClientSender[name] > 5) {
            ClientSender[name] = 1;
            if (name == 'client_zipcode') { 
                // kod pocztowy przeslany wraz z regionem
                IAI_Ajax.Request('ajax/client-new.php?validAjax=true', 'client_zipcode='+value+'&client_region='+document.getElementById('client_region').value, {onSuccess: 'ClientNew.info', arg: idd.id});
            } else if (name == 'delivery_zipcode') {
                // kod pocztowy dostawy przeslany wraz z regionem
                IAI_Ajax.Request('ajax/client-new.php?validAjax=true', 'delivery_zipcode='+value+'&delivery_region='+document.getElementById('delivery_region').value, {onSuccess: 'ClientNew.info', arg: idd.id});
            } else if (name == 'additional_zipcode') {
                // kod pocztowy dostawy przeslany wraz z regionem
                IAI_Ajax.Request('ajax/client-new.php?validAjax=true', 'additional_zipcode='+value+'&additional_region='+document.getElementById('additional_region').value, {onSuccess: 'ClientNew.info', arg: idd.id});
            } else if (name == 'client_region') { 
                // przy zmianie rogionu konieczne sprawdzenie kodu pocztowego
                ClientNew.check_inp(document.getElementById('client_zipcode'), 'client_zipcode');
             } else if (name == 'delivery_region') {
                // przy zmianie rogionu konieczne sprawdzenie kodu pocztowego dostawy
                ClientNew.check_inp(document.getElementById('delivery_zipcode'), 'delivery_zipcode');
            } else if (name == 'additional_region') {
                // przy zmianie rogionu konieczne sprawdzenie kodu pocztowego dostawy
                ClientNew.check_inp(document.getElementById('additional_zipcode'), 'additional_zipcode');
            } else if (name == 'client_password') {
                // haslo musi byc rozne od loginu
                IAI_Ajax.Request('ajax/client-new.php?validAjax=true', 'client_password='+value+'&client_login='+document.getElementById('client_login').value, {onSuccess: 'ClientNew.info', arg: idd.id});
            } else if (name == 'repeat_password') {
                // hasla musza byc identyczne
                IAI_Ajax.Request('ajax/client-new.php?validAjax=true', 'repeat_password='+value+'&client_password='+document.getElementById('client_password').value, {onSuccess: 'ClientNew.info', arg: idd.id});
            } else {
                // pozostałe wartości wysyłamy pojedynczo
                if (value) {
                    IAI_Ajax.Request('ajax/client-new.php?validAjax=true', name+'='+value, {onSuccess: 'ClientNew.info', arg: idd.id});
                } else {
                    ClientNew.error(idd.id, 0);
                    document.getElementById(idd.id + '_img_off').style.display = "none";
                    document.getElementById(idd.id + '_img_on').style.display = "none";	
                }
            }
        } else {
            if (delay) {
                if (ClientSender[name] > 1) { 
                    ClientSender[name]++;
                    delay++;
                } else {
                    return false;
                }
            } else {
                if (ClientSender[name] > 2) {
                    ClientSender[name]=2;
                    return false;
                } else {
                    ClientSender[name]=2;
                    delay = 1;
                }
                
            }
            setTimeout('ClientNew.check_inp("'+idd.id+'", "'+name+'", "'+delay+'")', 100); 
        }
        if (document.getElementById('deliver_to_billingaddr')) {
            if (document.getElementById('deliver_to_billingaddr').checked) { 
                ClientNew.copyDeliveryAddres();
            }
        }
    },
    info: function (x, obj) {
        try {
            var response = eval('(' + x + ')');
        } catch (e) {
            return false;
        }
        xr = response;
        if (response.errno == 0) {
            // stawiamy poprawny znaczek
            new ClientNew.error(obj, 0);
        } else {
            // bledy
            if (response.message.val[0]) {
                document.getElementById(obj+ '_help').innerHTML = '<div>'+response.message.val[0]+'</div>';
            }
            new ClientNew.error(obj, 1);
        }
    },
    
    button: function (num) {
		if(num == 0 && document.getElementById('terms_agree').checked) {
			document.getElementById('submit_register').className = 'act';
		} else {
			document.getElementById('submit_register').className = 'idle';
		}
		
    }, 
    
    submitform: function () {
                ClientNew_status = true;
                if (!document.getElementById("client_firstname").value) {
                    ClientNew_status = false;
                }
                if (!document.getElementById("client_lastname").value) {
                    ClientNew_status = false;
                }
                if (!document.getElementById("client_email").value) {
                    ClientNew_status = false;
                }
                if (!document.getElementById("client_city").value) {
                    ClientNew_status = false;
                }
                if (!document.getElementById("client_zipcode").value) {
                    ClientNew_status = false;
                }
                if (!document.getElementById("client_street").value) {
                    ClientNew_status = false;
                }
                if (document.getElementById("firm_data2")) {
                    if (document.getElementById("firm_data2").checked && !document.getElementById("client_firm").value && !document.getElementById("client_nip").value) {
                        ClientNew_status = false;
                    }
                }
               if (document.getElementById("client_login")) {
                   if (!document.getElementById("client_login").value) {
                       ClientNew_status = false;
                   }
               }
               if (document.getElementById("client_password")) {
                   if (!document.getElementById("client_password").value || !document.getElementById("repeat_password").value) {
                       ClientNew_status = false;
                   }
               }
               if (document.getElementById("deliver_to_billingaddr")) {
                   if (!document.getElementById("deliver_to_billingaddr").checked) {
                       if ((!document.getElementById("delivery_firstname").value || !document.getElementById("delivery_lastname").value) && !document.getElementById("delivery_additional").value) {
                           ClientNew_status = false;
                       }
                       if (!document.getElementById("delivery_zipcode").value) {
                           ClientNew_status = false;
                       }
                       if (!document.getElementById("delivery_street").value) {
                           ClientNew_status = false;
                       }
                       if (!document.getElementById("delivery_city").value) {
                           ClientNew_status = false;
                       }
                   }
               }
               if (ClientNewMandatoryPhone) {
                   if (! document.getElementById('client_phone').value) {
                       ClientNew_status = false;
                   }
                   if (document.getElementById('additional_phone')) {
                       if ((! document.getElementById('additional_phone').value) && !document.getElementById('additional_phone').disabled ) {
                           ClientNew_status = false;
                        }
                   } else if (document.getElementById('delivery_phone')) {
                       if ((! document.getElementById('delivery_phone').value) && !document.getElementById('delivery_phone').disabled) {
                           ClientNew_status = false;
                        }
                   }
               }
               if (ClientNewMandatoryMail) {
                   if (! document.getElementById('client_email').value) {
                       ClientNew_status = false;
                   }
               }
               if (document.getElementById('terms_agree') ) {
                   if ((!document.getElementById('terms_agree').checked) && document.getElementById('terms_agree').type != 'hidden') {
                       ClientNew_status = false;
                   }
               }
		if(ClientNew_status == true ) {
if (document.getElementById("button_alert")) {
                        document.getElementById("button_alert").style.display = "none";
}
			return true;
		} else {
if (document.getElementById("button_alert")) {
                       document.getElementById("button_alert").style.display = "block";
                        setTimeout('ClientNew.AlertOff()', 5000);
}
			return false;		
		}
    }, 
    
    ramka: function () {
        if (!document.getElementById('terms_agree').checked) {
            document.getElementById('terms_agree_box').className = 'ramka_ON';
        } else {
            document.getElementById('terms_agree_box').className = 'ramka_OFF';	
        }
    },

    AlertOff: function() {
        document.getElementById("button_alert").style.display = "none";
    },
    
    copy_adres: function (type) {
        var CopyData = false;
        if (document.getElementById("firm_data")) {
            CopyData = document.getElementById("firm_data").checked;
        }
        
        if(CopyData && type == 1) {
            document.getElementById('client_firstname').value = document.getElementById('client_firstname_copy').value;
            document.getElementById('client_firstname_img_off').style.display = document.getElementById('client_firstname_copy_img_off').style.display;
	    document.getElementById('client_firstname_img_on').style.display = document.getElementById('client_firstname_copy_img_on').style.display;
            document.getElementById('client_lastname').value = document.getElementById('client_lastname_copy').value;
            document.getElementById('client_lastname_img_off').style.display = document.getElementById('client_lastname_copy_img_off').style.display;
	    document.getElementById('client_lastname_img_on').style.display = document.getElementById('client_lastname_copy_img_on').style.display;
         } else if (type ==2) {
            document.getElementById('client_firstname_copy').value = document.getElementById('client_firstname').value;
            document.getElementById('client_firstname_copy_img_off').style.display = document.getElementById('client_firstname_img_off').style.display;
	    document.getElementById('client_firstname_copy_img_on').style.display = document.getElementById('client_firstname_img_on').style.display;
            document.getElementById('client_lastname_copy').value = document.getElementById('client_lastname').value;
            document.getElementById('client_lastname_copy_img_off').style.display = document.getElementById('client_lastname_img_off').style.display;
	    document.getElementById('client_lastname_copy_img_on').style.display = document.getElementById('client_lastname_img_on').style.display;
         }
    },
    
    error: function (idd, err) {
            if(err == 1) {
			document.getElementById(idd + '_img_off').style.display = "block";
			document.getElementById(idd + '_img_on').style.display = "none";
            if (document.getElementById(idd + '_help')) {
			    document.getElementById(idd + '_help').style.display = "block";
                ClientNew.hide_info_help(idd, 10);
            }
			return false;
		} else {
			document.getElementById(idd + '_img_off').style.display = "none";
			document.getElementById(idd + '_img_on').style.display = "block";
            if (document.getElementById(idd + '_help')) {
                document.getElementById(idd + '_help').style.display = "none";
                ClientNew.hide_info_help(idd, 10);
            }
			return false;		
            }
    }, 

    hide_info_help: function(idd, licznik) {
        if (licznik > 1) {
            setTimeout("ClientNew.hide_info_help('"+idd+"', '"+(licznik-1)+"');", 1000);
        } else if (document.getElementById(idd + '_help')) {
			    document.getElementById(idd + '_help').style.display = "none";
        }
    }
}
var xr;

function agree() {
    if (document.getElementById('terms_agree').checked && ClientNew_status == true) {
        document.getElementById('submit_register').className = 'act';
    } else {
        document.getElementById('submit_register').className = 'idle';

    }
}

function clientnew_firm() {
    if (document.getElementById('firm_data').checked) {
	    ClientNew_firma = false;
        document.getElementById('client_firm_div').style.display = 'none';
        document.getElementById('box_3_header').innerHTML = client_new_txt2;
        document.getElementById('box_1_header').innerHTML = client_new_txt3;
        if (document.getElementById('send_to')) {
             document.getElementById('send_to').innerHTML = client_new_txt1;
        }
        document.getElementById('client_firstname_copy_txt').className = '';
        document.getElementById('client_firstname_copy').className = '';
        document.getElementById('client_lastname_copy_txt').className = '';
        document.getElementById('client_lastname_copy').className = '';
    } else {
	    ClientNew_firma = true;	
        document.getElementById('client_firm_div').style.display = 'block';
        document.getElementById('box_3_header').innerHTML = client_new_txt2b;
        document.getElementById('box_1_header').innerHTML = client_new_txt3b;
        if (document.getElementById('send_to')) {


            document.getElementById('send_to').innerHTML = client_new_txt1b;
        }
        document.getElementById('client_firstname_copy_txt').className = 'hidden';
        document.getElementById('client_firstname_copy').className = 'hidden';
        document.getElementById('client_lastname_copy_txt').className = 'hidden';
        document.getElementById('client_lastname_copy').className = 'hidden';
    }
}
/* Menu kategorii 3.5 UNIW A Krainapościeli (layout_left - menu_categories) [57358]*/

function menu_categories_toggle(id) {

     if (document.getElementById(id).style.display == 'block') {
           document.getElementById(id).style.display='none';
     } else {
           document.getElementById(id).style.display='block';
     }

}
/* Detale produktu NOWA KARTA - Krainapościeli (kopia) (projector - projector_details) [57421]*/
// START Z ROZMIAREM CZY NIE (0 - start bez rozmiaru, 1 - z rozmiarem)
var rozmiar_start = 1;

// JEDNOSTKI MIAR PRZY CENIE (0 - tak, 1 -nie)
var unit_start = 1;

// KOSZTY DOSTAWY (0 - tak, 1 -nie)
var delivery_start = 1;


// PODAJ ILOSC (0 - tak, 1 -nie)
var number_start = 0;

// POKAZ ILOSC (0 - tak, 1 -nie)
var amount_start = 1;

// POKAZ CENE NETTO (0 - tak, 1 -nie)
var pricenetto_start = 1;

var txt_niemastanu = 'Produkt niedostępny';
var txt_status_24 = 'w ciągu 24h';
var txt_status_natychmiast = 'dzisiaj';
var txt_days = ' dni'
var txt_za = ' za ';
var txt_taniej = 'Taniej o ';
var txt_oszczedzasz = 'oszczędzasz ';
var txt_wybrany_rozmiar = 'Rozmiar:  ';
var txt_wysylka = '';
var txt_wysylka_za = 'w ciągu ';
var txt_dostepny = 'Dostawa  ';
var txt_dostepny_za = 'Dostawa za ';
var txt_pkt = ' pkt.';
var txt_tylkotel = 'Skontaktuj się ze sprzedawcą';
var txt_niedostepny = 'Produkt niedostępny';
var txt_status_amount_full = 'większa ilość';
var txt_status_amount_null = 'brak w magazynie';
var txt_forpointsonly ='Produkt możesz kupić za punkty';
var txt_forpoints_txt = 'Zaznacz jak chcesz kupić za punkty';
var txt_disable_desc = '<a href=\"contact.php\">Skontaktuj się z nami</a>';
/**
TESTER
*/

function tester()
{
var itemz='';
for(n in selectSizes)
{
		itemz += n + ' - ' + selectSizes[n] + '<br />';
}

var mycode='<div style=\"background:#fff;position:fixed;top:0;right:0;padding:10px;border:1px solid;\">' +itemz +'</div>';

var tester_id = document.getElementById("'tester");
tester_id.innerHTML = mycode;
}


/**
Alert
*/

var Alertek = {

	alert_cover   : '',
	
	getScrollXY : function () {
		  var scrOfX = 0, scrOfY = 0;
		  if( typeof( window.pageYOffset ) == 'number' ) {
		    //Netscape compliant
		    scrOfY = window.pageYOffset;
		    scrOfX = window.pageXOffset;
		  } else if( document.body && ( document.body.scrollLeft || document.body.scrollTop ) ) {
		    //DOM compliant
		    scrOfY = document.body.scrollTop;
		    scrOfX = document.body.scrollLeft;
		  } else if( document.documentElement && ( document.documentElement.scrollLeft || document.documentElement.scrollTop ) ) {
		    //IE6 standards compliant mode
		    scrOfY = document.documentElement.scrollTop;
		    scrOfX = document.documentElement.scrollLeft;
		  }
		  return scrOfY;
	},	

	pageHeight : function () {
	var heighter = window.innerHeight != null? window.innerHeight: document.documentElement && document.documentElement.clientHeight ? document.documentElement.clientHeight:document.body != null? document.body.clientHeight:null;
	return heighter =  heighter + Alertek.getScrollXY();
	},
	

	
	show_alert : function (txt) {
		Alertek.alert_cover = document.getElementById('alert_cover');
		Alertek.alert_cover.innerHTML = txt;	
		Alertek.alert_cover.style.display='block';

		Alertek.alert_cover.style.top = Alertek.pageHeight() / 2 + 'px';
		Alertek.alert_cover.style.left = ns6? ((Popup.pageSizes()[2] / 2) - (Alertek.alert_cover.clientWidth / 2)) + "px" : ((Popup.pageSizes()[2] / 2) - (Alertek.alert_cover.clientWidth / 2)) + "px";
	
	if (navigator.appVersion.indexOf("MSIE")!=-1){
		temp=navigator.appVersion.split("MSIE");
		ver_brow=parseFloat(temp[1]);

				if (ver_brow<7.0) {
				 Alertek.alert_cover.style.left = (document.body.clientWidth / 2) - (Alertek.alert_cover.clientWidth /2 ) + 'px';
				 }
				if (ver_brow==7.0)
				 {
				 Alertek.alert_cover.style.top = (document.body.clientHeight / 2) - (Alertek.alert_cover.clientHeight) + 'px';
				 Alertek.alert_cover.style.left = (document.body.clientWidth / 2) - (Alertek.alert_cover.clientWidth /2 ) + 'px';
				 }
		 }	
		 
	setTimeout('Alertek.hide_alert()', 3000);		 
	
	},
	
	hide_alert : function () {	
		Alertek.alert_cover = document.getElementById('alert_cover');
		Alertek.alert_cover.style.display='none';
	} 	

}

/**
  Projector
*/


var Projector = {
	status_price : '',
	displayed   : '',
	price_cont  : '',
	phoneprice_cont   :  '',
	sizes_cont  : '',	
	sizes_cont_onesize  : '',		
	price_cont_yousave  : '',	
	proj_btn    : '',
	proj_img_cover_sub    : '',		
	proj_status_gfx    : '',	
	proj_status_desc    : '',	
	forpoints_check	   : '',
	status_amount    : '',
	msg_alert : '',
	temp  : '',
	
	//START  ZEROWY
	start_zero : function () {

	if(zm1 == '1') 
	{
		if(zm2 == 'onesize')
		{
			Projector.start('onesize','onesize');
		}
		else
		{
			Projector.start(zm2);
			//Projector.menus('sizes_menu_list',0,zm3);
			Projector.change_btn(zm2);
		}

	}
	else
	{
		if(rozmiar_start == 0 && zm1 != '1')
		{
			Projector.start();
		}
		else
		{
			Projector.start(zm2);
			//Projector.menus('sizes_menu_list',0,zm3);
			Projector.change_btn(zm2);			
		}
	}


	},

	change_btn : function (rozm) {	
		
		var btn_id = document.getElementById('button_' + rozm);

		var all = document.getElementById('sizes_menu_list');
		var wybrane = all.getElementsByTagName('div');		
		for(i=0;i<wybrane.length;i++)
		{		
			if(wybrane[i].className.indexOf('_active')) wybrane[i].className = wybrane[i].className.replace('_active','');
		}
		btn_id.className = btn_id.className + '_active';
	
	},
	
	start : function (rozm, onesize) {
	
	// CHECKING IF XML TRUE
	var itnum=0;
	for(n in selectSizes)
	{
			itnum++;
	}
	if(itnum == 0) 
	{
		document.getElementById('projector_ALL_component').style.display = 'none';
		Alertek.show_alert('XML ERROR ' + itnum);
		return false;
		
	}
	
	// DEFINICJA WSZYTSKICH ELEMENTOW DO UZYTKU POZNIEJ
	Projector.sizes_cont_onesize = document.getElementById('projector_sizes_cont_onesize');
	Projector.sizes_cont = document.getElementById('projector_sizes_cont');
	Projector.proj_status_cont = document.getElementById('projector_status_cont');
	Projector.proj_status_gfx = document.getElementById('projector_status_gfx');
	Projector.proj_status_gfx_cont = document.getElementById('projector_status_gfx_cont');
	Projector.proj_status_desc = document.getElementById('projector_status_description');
	Projector.proj_status_desc_title = document.getElementById('projector_status_description_title');
	Projector.proj_status_desc2 = document.getElementById('projector_status_description2');	
	Projector.price_cont = document.getElementById('projector_price_cont');
	Projector.price_maxprice = document.getElementById('projector_status_maxprice');
	Projector.price_cont_yousave = document.getElementById('projector_price_cont_yousave');		
	Projector.phoneprice_cont = document.getElementById('projector_phoneprice_cont');
	Projector.forpoints_cont = document.getElementById('projector_forpoints');
	Projector.forpoints_check = document.getElementById('forpoints_check');	
	Projector.pricepoints_sub = document.getElementById('projector_pricepoints_cont');	
	Projector.pricepoints_value = document.getElementById('projector_pricepoints_cont_value');	
	Projector.delivery_sub = document.getElementById('projector_delivery_cont');	
	Projector.delivery_value = document.getElementById('projector_delivery_cont_value');	
	Projector.deliveryfree = document.getElementById('projector_deliveryfree_cont');
	Projector.number_sub = document.getElementById('projector_number_cont');	
	Projector.number_value = document.getElementById('projector_number_value');		
	Projector.amount_sub = document.getElementById('projector_amount_cont');	
	Projector.amount_value = document.getElementById('projector_amount_cont_value');	
	Projector.pricenetto_sub = document.getElementById('projector_pricenetto_cont');	
	Projector.pricenetto_value = document.getElementById('projector_pricenetto_cont_value');	
	
	
		// UZUPELNIENIE FORMUALRZA 
		document.getElementById('form_projector').size.value = rozm;
	
		// ZMIANA OSZCZEDZASZ NA STARCIE
		if(projector_first_price[4] != '' && projector_first_price[5] != '')
		{
			Projector.price_cont_yousave.innerHTML = txt_taniej + projector_first_price[5] + '%, '+ txt_oszczedzasz + projector_first_price[4] + projector_currency;	
		}	
	
	
		// ZMIANA PROMOCJI NA STARCIE
		if(projector_first_price[2] != '') 
		{
			Projector.price_maxprice.innerHTML = projector_first_price[2] + projector_currency;
		}
		
		// ZMIANA CENY NA STARCIE	
		if(projector_first_price[0] == projector_first_price[1] && projector_first_price[0] != 0)
		{
		
				// ZMIANA CENA NETTO NA STARCIE
				if(pricenetto_start == '0' && projector_pricenetto != '') 
				{
					Projector.pricenetto_sub.style.display = "block";
					Projector.pricenetto_value.innerHTML = projector_pricenetto + projector_currency;
				}	
				else
				{
					Projector.pricenetto_sub.style.display = "none";		
				}
				
			Projector.phoneprice_cont.style.display = 'none';		
			Projector.price_cont.innerHTML = projector_first_price[0] + projector_currency;				

		}
		else
		{
			if(projector_first_price[0] != projector_first_price[1] && projector_first_price[0] != 0)
			{
			
				Projector.price_cont.innerHTML = projector_first_price[0] + '-' +projector_first_price[1] + projector_currency;	
			}		
			if(projector_first_price[0] == 0)
			{
				Projector.price_cont.style.display = 'none';
				Projector.phoneprice_cont.style.display = 'block';
			}
		}
		
		//JEDNOSTKA MIARY
		if(projector_unit != '' && unit_start == '0')
		{
			Projector.price_cont.innerHTML += " / " + projector_unit;
		}		
	
		if(rozm) Projector.status_change(rozm, onesize);

		
	},		
	
	
	status_change : function (rozm, onesize) {
	
	// ZMIENNE
	Projector.status_price = selectSizes[rozm][0];
	var status_price_netto = selectSizes[rozm][1];
	var status_price_yousavepercent = selectSizes[rozm][2];
	var status_price_yousave = selectSizes[rozm][3];
	var status_price_maxprice = selectSizes[rozm][4];	
	var status_status = selectSizes[rozm][5];	
	var status_devilery_days = selectSizes[rozm][6];
	var status_desc = selectSizes[rozm][7];
	var status_desc_tel = selectSizes[rozm][8];
	var status_gfx_src = selectSizes[rozm][9];	
	var status_name = selectSizes[rozm][10];	
	var status_phoneprice = selectSizes[rozm][11];	
	var status_forpoints = selectSizes[rozm][12];	
	var status_points = selectSizes[rozm][13];	
	var status_delivery = selectSizes[rozm][14];	
	
	Projector.status_amount = selectSizes[rozm][15];	
	var status_gfx_tel = selectSizes[rozm][16];		
	
	//PODMIANA GRAFIKI  ORAZ TXT CENA NA TEL IF EXIST
	if(status_gfx_tel != '' || status_desc_tel != '')
	{
		if(status_gfx_tel != '')
		{
			Projector.phoneprice_cont.innerHTML = '<img id=\"projector_gfx_phoneprice\" src=\"blank.gif\" alt=\"' + status_desc_tel + '\"/>';
			document.getElementById('projector_gfx_phoneprice').src = status_gfx_tel;
		}
		else if(status_desc_tel != '')
		{
			Projector.phoneprice_cont.innerHTML = status_desc_tel;
		}		
	}

	
	//PUNKTY JEZELI ZALOGWANY
	if(status_forpoints == 'true' && status_status != 'disabled')
	{
		Projector.forpoints_cont.style.display = "block";
	}
	else
	{
		Projector.forpoints_cont.style.display = "none";	
	}
	
	//PUNKTY - WYSWEILERNIE
	if(status_points != '')
	{
		Projector.pricepoints_sub.style.display = "block";
		Projector.pricepoints_value.innerHTML = status_points + txt_pkt;
	}
	else
	{
		Projector.pricepoints_sub.style.display = "none";	
	}
	
	//ILOSC - WYSWIETLENIE
	if(Projector.status_amount != '' && amount_start == '0')
	{
		Projector.amount_sub.style.display = "block";
		if(Projector.status_amount == '0')
		{
			Projector.amount_value.innerHTML = txt_status_amount_null;
		}
		if(Projector.status_amount == '-1')
		{
			Projector.amount_value.innerHTML = txt_status_amount_full;
		}	
		if(parseInt(Projector.status_amount) > 0)
		{
			Projector.amount_value.innerHTML = Projector.status_amount;
		}
	}
	else
	{
		Projector.amount_sub.style.display = "none";	
	}		
	
	//KOSZTY DOSTAWY
	if(status_delivery != '' && delivery_start == '0')
	{
		if(parseInt(status_delivery) > 0)
		{
			Projector.deliveryfree.style.display = "none";		
			Projector.delivery_sub.style.display = "block";
			Projector.delivery_value.innerHTML = status_delivery + projector_currency;
		}
		else
		{
			Projector.delivery_sub.style.display = "none";
			Projector.deliveryfree.style.display = "block";	
		}
	}
	else
	{
		Projector.pricepoints_sub.style.display = "none";	
	}	
	
	//PODAWANIE ILOSCI - WIDOCZNOSC
	if(number_start == '0' && status_status != 'disable')
	{
		Projector.number_sub.style.display = "block";
		Projector.number_value.value = 1;
	}
	else
	{
		Projector.number_sub.style.display = "none";	
	}		


	// UKRYCIE WIDOCZNOSCI SELECTA IF ONESIZE ORAZ WYPISANIE JEDNEGO ROZMIARU JEZELI ROZNY OD ONESIZE
	if(onesize == 'onesize')	
	{	
		if(rozm != 'onesize')
		{
			Projector.sizes_cont_onesize.style.display='block';	
			Projector.sizes_cont_onesize.firstChild.innerHTML = txt_wybrany_rozmiar + status_name;		
		}
		Projector.sizes_cont.style.display='none';
	}
	else
	{
		Projector.sizes_cont.style.display='block';	
	}	
	
	// WLACZENIE WIDOCZNOSCI CONTENERA STATUSU
	Projector.proj_status_cont.style.display = 'block';
	
	
	// ZMIANA CENY
	if(status_price_maxprice != '') 
	{
		Projector.price_maxprice.innerHTML = status_price_maxprice + projector_currency;
	}
	
	if(status_phoneprice == 'true')
	{

		Projector.price_cont.style.display = 'none';		
		Projector.phoneprice_cont.style.display = 'block';	
	}
	else
	{
		Projector.price_cont.style.display = 'block';		
		Projector.phoneprice_cont.style.display = 'none';

		Projector.price_cont.innerHTML = Projector.status_price + projector_currency;				


	}
	
	// ZMIANA CENA NETTO
	if(pricenetto_start == '0' && status_price_netto != '' && status_phoneprice != 'true') 
	{
		Projector.pricenetto_sub.style.display = "block";
		Projector.pricenetto_value.innerHTML = status_price_netto + projector_currency;
	}	
	else
	{
		Projector.pricenetto_sub.style.display = "none";		
	}	

	//JEDNOSTKA MIARY
	if(projector_unit != '' && unit_start == '0')
	{
		Projector.price_cont.innerHTML += " / " + projector_unit;
	}
	
	// ZMIANA OSZCZEDZASZ
	if(status_price_yousavepercent != '' && status_price_yousave != '')
	{
		Projector.price_cont_yousave.innerHTML = txt_taniej + status_price_yousavepercent + '%, '+ txt_oszczedzasz + status_price_yousave + projector_currency;	
	}
		
	// ZMIANA GRAFIKI STATUSU
	if(status_gfx_src != '')
	{
		Projector.proj_status_gfx_cont.style.display = "block";
		Projector.proj_status_gfx.innerHTML = '<img src=\"blank.gif\" />';
		status_imageObj = new Image();
		status_imageObj.src = status_gfx_src;
		Projector.proj_status_gfx.firstChild.src = status_gfx_src;
	}
	else
	{
		Projector.proj_status_gfx_cont.style.display = "none";	
	}

	// ZMIANA TXT STATUSU I DNI
	Projector.proj_status_desc.innerHTML ='';
	Projector.proj_status_desc_title.style.display = "block";	
	
	if(status_status == 'enable' || status_status == 'order')
	{
		if(status_desc != '')
		{	
			Projector.proj_status_desc.innerHTML = status_desc;	
		}		
	}
	
	if(status_status == 'disable')
	{
		if(status_desc != '')
		{	
			Projector.proj_status_desc.innerHTML = status_desc;	
			if(status_devilery_days != '')
			{
			
				if(status_devilery_days == '0')
				{
					Projector.proj_status_desc.innerHTML += txt_status_natychmiast;
				}
				if(status_devilery_days == '1')
				{
					Projector.proj_status_desc.innerHTML += txt_za + txt_status_24;
				}	
				if(status_devilery_days > '1')
				{
					Projector.proj_status_desc.innerHTML += txt_za + status_devilery_days + txt_days;
				}				
			}
		}	
		else
		{
			Projector.proj_status_desc.innerHTML += txt_disable_desc;			
		}
		Projector.proj_status_desc_title.style.display = "none";
	
		
	}
	
	//TXT DOSTAWY np. DOSTAWA ZA 2 DNI
	if(status_status == 'enable' || status_status == 'order' && status_devilery_days != '')
	{	
		Projector.proj_status_desc2.innerHTML = Projector.fun_delivery_days(status_devilery_days, status_status);
	}
	
	// AKTYWACJA LUB NIE BUTTONA DODAJ DO KOSZYKA  i ULUBIONYCH
	Projector.button_act(status_status, status_phoneprice, status_forpoints);
	
	
	},	
	
	// FUNKCJA ZWRACAJACA TXT WYSYLKI X DNI
	fun_delivery_days : function (days,status) {
		var rezult;
		
		if(status == 'disable' && days != '' && parseInt(days) > 1)
		{
			rezult = txt_dostepny_za;
		}
		else if(status == 'disable' && days != '' && parseInt(days) <= 1)
		{
			rezult = txt_dostepny;
		}
		else
		{
			rezult = '';
		}
		
		if(status == 'enable' || status == 'order')
		{
			if(days != '' && parseInt(days) > 1)
			{
				rezult = txt_wysylka_za;
			}
			if(days != '' && parseInt(days) <= 1)
			{
				rezult = txt_wysylka;
			}			
		}		
	
			
			if(days == '0')
			{
				rezult += txt_status_natychmiast;
			}
			if(days == '1')
			{
				rezult += txt_status_24;
			}	
			if(days > '1')
			{
				rezult += days + txt_days;
			}	
		
		return rezult;
	},
	
	imagerotate : function (id) {
		if (Projector.displayed == '') {
			document.getElementById('img_1').style.display = 'none';
		} 
	   else {
	       document.getElementById(Projector.displayed).style.display = 'none';
	   }
	   document.getElementById(id).style.display = '';
	   Projector.displayed = id;
	},
	
	button_act : function (status, phone, points) {

		Projector.forpoints_cont.removeAttribute("onclick");	

		if(status == 'disable' || phone == 'true')
		{		

			Projector.button_deact(txt_niedostepny);
			
			if(phone != '' && phone == 'true')
			{
				Projector.button_deact(txt_tylkotel);
			}
			if(points != '')
			{
				
				if(points == 'true' && phone == 'true') 
				{
					Projector.forpoints_check.disabled = 'disabled';	
					Projector.forpoints_check.checked = true;
					msg_alert = txt_forpointsonly;
					Projector.forpoints_cont.onclick = Projector.onclicker_3;	
					
					Projector.proj_btn = document.getElementById('projector_button_basket');
					Projector.proj_btn.style.cursor ='pointer';
					Projector.proj_btn.onclick = Projector.onclicker_1;						

				}
				else
				{
					Projector.button_deact(txt_tylkotel);
				}
			}
		}
		else
		{
			Projector.forpoints_check.disabled = '';
			Projector.forpoints_check.checked = false;	
			msg_alert = txt_forpoints_txt;
			Projector.forpoints_cont.removeAttribute("onclick");
			
			Projector.proj_btn = document.getElementById('projector_button_basket');
			Projector.proj_btn.style.cursor ='pointer';
			Projector.proj_btn.onclick = Projector.onclicker_1;
		
		}
			// DLA OBSERVE
			var zo = "document.getElementById('iemode').value=2;document.getElementById('form_projector').submit();";
			Projector.proj_btn_observe = document.getElementById('projector_button_observe');	
			Projector.proj_btn_observe.style.cursor ='pointer';		
			Projector.proj_btn_observe.onclick = Projector.onclicker_2;			

		
	},
	
	onclicker_false : function()
	{
		return false;
	},	
	
	onclicker_1 : function()
	{
		document.getElementById('iemode').value=1;
		document.getElementById('form_projector').submit();
	},
	
	onclicker_2 : function()
	{
		document.getElementById('iemode').value=2;
		document.getElementById('form_projector').submit();
	},	
	
	onclicker_3 : function()
	{
		Alertek.show_alert(msg_alert);
		return false;
	},		
	
	button_deact : function (msg) {
		
		msg_alert = msg;
		Projector.proj_btn = document.getElementById('projector_button_basket');
		Projector.proj_btn.style.cursor ='not-allowed';
		Projector.proj_btn.onclick = Projector.onclicker_3;	
	},	
	
	if_isanumber  : function(test)
	{
			if(test.match("^[1-9]{1}[0-9]{0,9}$") || test ==''){
				return test;
			}else
			{
				test = test.substring(0, test.length-1);
				return test;
			}	
	
	},
	
	roundNumber  : function(number, flag) {
		var rnum = number;
		if (flag == 0)var rlength = 0;
		if (flag != 0)var rlength = flag;
		if (rnum > 8191 && rnum < 10485) {
		rnum = rnum-5000;
		var newnumber = Math.round(rnum*Math.pow(10,rlength))/Math.pow(10,rlength);
		newnumber = newnumber+5000;
	} else {
		var newnumber = Math.round(rnum*Math.pow(10,rlength))/Math.pow(10,rlength);
	}
		return newnumber;
	},
	
	number_check  : function()
	{
	
		Projector.number_value.value = Projector.if_isanumber(Projector.number_value.value);
		
		if(Projector.number_value.value >= parseInt(Projector.status_amount) && isFinite(Projector.status_amount) && Projector.status_amount != '-1')
		{
			Projector.number_value.value = parseInt(Projector.status_amount);
			Projector.price_cont.innerHTML = Projector.roundNumber((parseInt(Projector.status_amount) * Projector.status_price),2) + projector_currency;			
		}
		else
		{
			if(Projector.if_isanumber(Projector.number_value.value))
			{
				if(projector_first_price[2] != '') Projector.price_maxprice.innerHTML = Projector.roundNumber((parseInt(Projector.number_value.value) * projector_first_price[2]),2) + projector_currency;
				Projector.price_cont.innerHTML = Projector.roundNumber((parseInt(Projector.number_value.value) * Projector.status_price),2) + projector_currency;			
			}
			else
			{
				Projector.number_value.value = '';
				if(projector_first_price[2] != '') Projector.price_maxprice.innerHTML = projector_first_price[2] + projector_currency;				
				Projector.price_cont.innerHTML = Projector.status_price + projector_currency;
				return false;	
			}
		}
	},
	
	number_up  : function()
	{
		if(isNaN(parseInt(Projector.number_value.value))) Projector.number_value.value = 1;
		if(Projector.number_value.value >= parseInt(Projector.status_amount) && isFinite(Projector.status_amount) && Projector.status_amount != '-1')
		{
			return false;
		}
		else
		{
			Projector.number_value.value = parseInt(Projector.number_value.value) + 1;		
					
		}
		Projector.number_check();
	},
	
	number_down  : function()
	{
		if(isNaN(parseInt(Projector.number_value.value))) Projector.number_value.value = 1;
		if(Projector.number_value.value > 1)
		{
			Projector.number_value.value = parseInt(Projector.number_value.value) - 1;
						
		}
		Projector.number_check();
	},	
	
	onmouseover_img : function()
	{
		this.style.display = 'none';

	},	

	img_cover : function (id) {
	
		/*Projector.proj_img_cover_sub = document.getElementById('projector_img_cover_sub');		
		if(Projector.proj_img_cover_sub.style.display == 'block')
		{
			Projector.proj_img_cover_sub.style.display = 'none';	
		}
		else
		{
			Projector.proj_img_cover_sub.style.display = 'block';	
		}
		if(id != 'null')
		{
			temp = id.getAttribute("onclick");		
			Projector.proj_img_cover_sub.onmouseover = Projector.onmouseover_img;
			Projector.proj_img_cover_sub.style.top = id.firstChild.clientHeight / 2 - 10 + 'px';
			//alert(id.firstChild.clientWidth + ' ---- ' +Projector.proj_img_cover_sub.clientWidth);
			Projector.proj_img_cover_sub.style.left = (id.firstChild.clientWidth  / 2) - (Projector.proj_img_cover_sub.clientWidth / 2) + 'px';		
		} */
	},
	
	menus : function (menu,switc, name) { 

		if(switc==1)
		{
			if(document.getElementById(menu))document.getElementById(menu).style.display='block';
		}
		else
		{
			if(document.getElementById(menu))document.getElementById(menu).style.display='none';	
			
			if (name != 0)
			{

					if(document.getElementById('results_size_lista'))document.getElementById('results_size_lista').innerHTML=name;	
					if(document.getElementById('bok_results_size'))document.getElementById('bok_results_size').innerHTML=name;	
			}
		}
	},
	
	boldclick : function (idek)  {
	
		var boldlist = document.getElementById('sizes_menu_list_cont');
		boldlist = boldlist.getElementsByTagName('div');
		i=0;
		
		while(i < boldlist.length){
		boldlist[i].className = "projector_sizes_onesize_55916";
		i++ ;
		}	
		idek.className = "projector_sizes_onesize_55916_on";
	
	
	},
	
	forpoints : function () { 
		if(Projector.forpoints_cont)
		{
			if(Projector.forpoints_cont.className == 'n53486_points')
			{
				Projector.forpoints_cont.className = 'n53486_points_active'
			}
			else
			{
				Projector.forpoints_cont.className = 'n53486_points'
			}			
		
		
		}
		
	}
		
}


/**
  Popup _ NOWA GALERIA
*/

var ns6=document.getElementById&&!document.all;
var ie=document.all;
var html = document.getElementsByTagName("html");
var Popup = {
        url :'http://' + location.host,
	link   : '',
	width  : 0,
	height : 0,
        loaded : 0,
	show : function (link,x,y) {
		Popup.link = link;
		Popup.width = x;
		Popup.height = y;
        Popup.loaded = 1;
		if (document.getElementById('big_photo')) {
			document.getElementById('big_photo').style.display = "none";
			document.getElementById('big_photo').src = Popup.link;
		}
		if (basecount < 2 || !basecount) {
			document.getElementById('popup_next_prev').style.visibility = "hidden";
		}
		var edit = document.getElementById('show_popup_photo_sub');		
        edit.style.width = parseInt(x) + "px";
        edit.style.height = parseInt(y) + "px";			
		
		if (!ns6) {Popup.hideSelects(1);}
		Popup.creatLayers();
	},
    reload : function () {
              if (Popup.loaded) {
                     Popup.resize(Popup.link,Popup.width,Popup.height);
              }
        },
    next_img : function () {
		Popup.link = document.getElementById('big_photo').src;
                if(Popup.link.indexOf(Popup.url) != '-1') Popup.link= Popup.link.substr(Popup.url.length+1,Popup.link.length);
	        for(n=1; n <= basecount; n++)
			{
				if(Popup_enclosures[n][0] == Popup.link) {
				    n++;
					if(n <= basecount){
						Popup.resize(Popup_enclosures[n][0], Popup_enclosures[n][1],Popup_enclosures[n][2]);
						Popup.link = Popup_enclosures[n][0];
						return false;
					}
					else
					{
						Popup.resize(Popup_enclosures[1][0], Popup_enclosures[1][1],Popup_enclosures[1][2]);
						Popup.link = Popup_enclosures[1][0];
						return false;
					}
				}
			} 

           
        },		
    prev_img : function () {
		Popup.link = document.getElementById('big_photo').src;	
                if(Popup.link.indexOf(Popup.url) != '-1') Popup.link= Popup.link.substr(Popup.url.length+1,Popup.link.length);
	        for(n=basecount; n <= basecount; n--)
			{

				if(Popup_enclosures[n][0] == Popup.link) {
					n--;
					if(n >= 1){
						Popup.resize(Popup_enclosures[n][0], Popup_enclosures[n][1],Popup_enclosures[n][2]);
						Popup.link = Popup_enclosures[n][0];
						return false;
					}
					else
					{
						Popup.resize(Popup_enclosures[basecount][0], Popup_enclosures[basecount][1],Popup_enclosures[basecount][2]);
						Popup.link = Popup_enclosures[basecount][0];
						return false;
					}					
				}
			}
            
        },			
	resize : function (sciezka, width, height) {
		document.getElementById('big_photo').style.display='none';		
		var edit = document.getElementById('show_popup_photo_sub');
		var edit2 = document.getElementById('show_popup_photo');		
        document.getElementById('big_photo').src = sciezka;
        edit.style.width = parseInt(width) + "px";
        edit2.style.width = parseInt(width) + "px";		
        edit.style.height = parseInt(height) + "px";		
		edit2.style.left = ns6? (Popup.pageSizes()[2] - (edit2.clientWidth + 10))/2 + html[0].scrollLeft +"px" : (Popup.pageSizes()[2] - (edit2.clientWidth + 10))/2 + "px";		

	},
	hide : function () {
		var edit = document.getElementById('show_popup_photo');
        var edit_close = document.getElementById('show_popup_photo_close');
		var cover = document.getElementById('cover');
		edit.style.display = "none";
        edit_close.style.display = "none";
		cover.style.display = "none";
        Popup.loaded = 0;
		if (!ns6) {Popup.hideSelects(0);}
	},
	cover : function (wartosc) {
		var cover = document.getElementById('cover');
	    ns6? cover.style.opacity = '.' + wartosc  :  cover.style.filter = "alpha(Opacity=" +wartosc+")";
	    if (window.opera) {
			cover.style.opacity = '.' + wartosc;
		}
	},	
	creatLayers : function () {


var edit = document.getElementById('show_popup_photo');
var edit_close = document.getElementById('show_popup_photo_close');
		edit.style.position = 'absolute';
	    edit.style.display = "block";
	    edit_close.style.display = "block";
		edit.style.width = (Popup.width) + "px";
	    edit.style.left = ns6? (Popup.pageSizes()[2] - (Popup.width + 10))/2 + html[0].scrollLeft +"px" : (Popup.pageSizes()[2] - (Popup.width + 10))/2 + "px";

var ver_brow=0;
if (navigator.appVersion.indexOf("MSIE")!=-1){
temp=navigator.appVersion.split("MSIE");
ver_brow=parseFloat(temp[1]);

if (ver_brow<7.0)
 {
edit.style.top = ((((Popup.pageSizes()[3] - (Popup.height + 10))/2) - 100  + document.body.scrollTop) < 0) ? "50px" : (((Popup.pageSizes()[3] - (Popup.height + 10))/2) - 100  + document.body.scrollTop + 50) + "px";
          }
else
{
edit.style.top = ((((Popup.pageSizes()[3] - (Popup.height + 10))/2) - 100  + html[0].scrollTop) < 0) ? "50px" : (((Popup.pageSizes()[3] - (Popup.height + 10))/2) - 100  + html[0].scrollTop + 50) + "px";
}
}
            else
{
edit.style.top = ((((Popup.pageSizes()[3] - (Popup.height + 10))/2) - 100  + html[0].scrollTop) < 0) ? "50px" : (((Popup.pageSizes()[3] - (Popup.height + 10))/2) - 100  + html[0].scrollTop + 50) + "px";
}



        edit.style.zIndex = 1000;
		edit.style.Background = '#FFFFFF';

	    //'cover'- div do blokowania elementow innych niz edit
	    var cover = document.getElementById('cover');
	    cover.style.display = "block";
        cover.style.position = "absolute";
	    cover.style.zIndex = 900;
	    ns6? cover.style.opacity = .5 :  cover.style.filter = "alpha(Opacity=50)";
	    if (window.opera) {
			cover.style.opacity = .5;
		}
		cover.style.left = "0px";
	    cover.style.top = "0px";
            offsetX = 0;
            if (!ns6 && !window.opera) {
                  offsetX = 20;
            }
	    cover.style.width = ns6? (Popup.pageSizes()[0] - 16) + "px" : Popup.pageSizes()[0] - offsetX + "px"; //ns6? html[0].offsetWidth +"px" : document.body.offsetWidth + "px";
	    cover.style.height = Popup.pageSizes()[1] + "px" //ns6? html[0].offsetHeight +"px" : document.body.offsetHeight + "px";
	},
	pageSizes : function () {
		var xScroll, yScroll;
		if (window.innerHeight && window.scrollMaxY) {	
			xScroll = document.body.scrollWidth;
			yScroll = window.innerHeight + window.scrollMaxY;
		} else if (document.body.scrollHeight > document.body.offsetHeight){

			xScroll = document.body.scrollWidth;
			yScroll = document.body.scrollHeight;
		} else {
			xScroll = document.body.offsetWidth;
			yScroll = document.body.offsetHeight;
		}
		var windowWidth, windowHeight;
		if (self.innerHeight) {
			windowWidth = self.innerWidth;
			windowHeight = self.innerHeight;
		} else if (document.documentElement && document.documentElement.clientHeight) { // Explorer 6 Strict Mode
			windowWidth = document.documentElement.clientWidth;
			windowHeight = document.documentElement.clientHeight;
		} else if (document.body) {
			windowWidth = document.body.clientWidth;
			windowHeight = document.body.clientHeight;
		}	
		if(yScroll < windowHeight){
			pageHeight = windowHeight;
		} else { 
			pageHeight = yScroll;
		}
		if(xScroll < windowWidth){	
			pageWidth = windowWidth;
		} else {
			pageWidth = xScroll;
		}
		arrayPageSize = new Array(pageWidth,pageHeight,windowWidth,windowHeight) 
		return arrayPageSize;
	},
	hideSelects : function (flag) {
		var selects = document.getElementsByTagName('SELECT');
		if (flag == 1) {
			for (i = 0; i < selects.length; i++) {
				selects[i].style.display = 'none';
			}
		} else {
			for (i = 0; i < selects.length; i++) {
				selects[i].style.display = '';
			}
		}
	}
}
window.onresize = function() {if (Popup.loaded == 1) {Popup.reload();}}
/* <b style="font-size:12px;color:red; text-decoration:blink">&gt;</b>  Order 1 NEW z wyborem płatności ver 5.1 - radiobutton!!! (ukrywanie pustych form) + inputy dla kalendarza dostaw (order1 - order1) [54726]*/

function order1_shop_payformdiv(show)
{
    if (show) {
        document.getElementById('payform_div').style.display = 'block';
    } else {
        document.getElementById('payform_div').style.display = 'none';
        document.getElementById('payform_id').selectedIndex = 0;

        allDivs = document.getElementsByTagName("div");
        for (i = 0; i < allDivs.length; i++) {
            if ((/^newpayment_form_/).test(allDivs[i].id) == true) {
                allDivs[i].style.display = 'none';
            }
        }
    }
}

function order1_changepayform()
{
    selVal = document.getElementById('payform_id').value;
    allDivs = document.getElementsByTagName("div");

    for (i = 0; i < allDivs.length; i++) {
        if ((/^newpayment_form_/).test(allDivs[i].id) == true) {
            allDivs[i].style.display = 'none';
        }
    }

    if (document.getElementById('newpayment_form_'+selVal) ) {
        document.getElementById('newpayment_form_'+selVal).style.display = 'block';
    }
}
var Prepaid = {
    changeDelivery: function(time) {
        // zmiana czasu w kalendarzu
        if (window['orderCalendarActive'] == true) {
            OrderCalendar.changeDeliveryTime(time);
        }
    }
};
/* <font style="text-decoration:blink;font-weight:bold;color:green;">[!] </font>Podsumowanie koszyka (basketedit - basketedit_summary) [53833]*/

function countAnnuityZagiel(account, amount)
{ 
window.open('http://www.zagiel.com.pl/kalkulator/index_smart.php?action=getklientdet_si_rata&shopNo=' + account + '&goodsValue=' + amount, 'count_zagiel', 'width=630,height=500,directories=no,location=no,menubar=no,resizable=yes,scrollbars=yes,status=no,toolbar=no');
}
function validate_Zagiel()
{
var zagielconfirm = document.getElementById('zagiel_confirm');
  if (zagielconfirm.checked) {
    return true;
  } else {
    alert(zagielnotconfirmed);
    return false;
  }
}
/* javascript + kod przewijaka (layout_top - menu_javascript) [56857]*/

var IAI_Ajax={
    cO: function()
    {
        var r;
        try {
            r=new ActiveXObject("Msxml2.XMLHTTP");
        } catch(e) {
            try {
                r=new ActiveXObject("Microsoft.XMLHTTP");
            } catch(oc) {
                r=null;
            }
        }
        if (!r&&typeof XMLHttpRequest!="undefined") {
            r=new XMLHttpRequest();
        }
        return r;
    },

    Request: function(url, pd, fun)
    {
        var x;
        x=IAI_Ajax.cO();

        x.open("POST",url,true);
        x.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
        x.setRequestHeader("Accept","text/javascript, text/html, application/xml, text/xml, */*");
        x.setRequestHeader("X-IAI-Version", "1.0");
        
        x.onreadystatechange=function()
        {
            if (x.readyState == 4) {
                if (x.status >= 200 && x.status < 300) {
                    if (fun) {
                        if (fun.onSuccess) {
                            if (fun.arg) {
                                eval(fun.onSuccess+'(\'' +x.responseText+ '\', \''+fun.arg+'\');');
                            } else {
                                eval(fun.onSuccess+'(\'' +x.responseText+ '\');');
                            }
                        }
                    }
                } else {
                    // narazie brak
                }
            }
        }
        x.send(pd);
        delete x;
    }
}

var IDMAIN_Array = new Array('n56248_both','n56254_news','n54677_noreg','n54677_reg');
var IDMAIN_padding = 20;

function MAIN_resizer()
{
    var id_temp;
	for(n in IDMAIN_Array)
	{
		if(document.getElementById(IDMAIN_Array[n]) && document.getElementById(IDMAIN_Array[n]).parentNode)
		{
	    	       var main_td_width = document.getElementById(IDMAIN_Array[n]).parentNode.clientWidth;
			id_temp = document.getElementById(IDMAIN_Array[n]);
			id_temp.style.width = (main_td_width/2) - IDMAIN_padding + "px";
			id_temp.style.position = "relative";
		}
	}
    setTimeout("MAIN_resizer()", 1000);	
}


MAIN_resizer();





var Hlider = {
	
	Navi:function(num, id, id2, clas, nullek)
	{
	Hlider.Hlider_jump = num;
	Hlider.Hlider_mainID = id;
	Hlider.Hlider_naviID = id2;
	Hlider.Hlider_naviclass = clas;
	
	////////////////	
	
	Hlider.mainID = document.getElementById(Hlider.Hlider_mainID);
	Hlider.mainwidth = Hlider.mainID.clientWidth;
	Hlider.lilist = document.getElementById(Hlider.Hlider_mainID).firstChild;

	Hlider.mainwidth = Hlider.mainID.clientWidth;		

	var elements = Hlider.lilist.getElementsByTagName('li');
	Hlider.elements_count = elements.length;
	
	Hlider.navi_count = Math.ceil(Hlider.elements_count / Hlider.Hlider_jump);
	var naviID = document.getElementById(Hlider.Hlider_naviID);
	if(nullek != 'NULL')
	{
		Hlider.width_pasek = 0;	
		naviID.innerHTML = '';
	
		for(i=1; i <= Hlider.navi_count; i++)
		{	
			var newDiv =  document.createElement('div');
			newDiv.className = Hlider.Hlider_naviclass;
			if(i==1) newDiv.className = Hlider.Hlider_naviclass + "_on";	
			newDiv.id = Hlider.Hlider_mainID +"|"+Hlider.Hlider_naviclass;				
			newDiv.innerHTML = "<span>" + i + "</span>";
			newDiv.onclick = Hlider.Start;				
			naviID.appendChild(newDiv);
		}	
		Hlider.mainID.scrollLeft = 0;
	
		var elements = Hlider.lilist.getElementsByTagName('li');	
		Hlider.elements_count = elements.length;
	
		for(n=0; n < Hlider.elements_count;n++)
        {
			Hlider.width_pasek += elements[n].clientWidth;
			Hlider.element_width = elements[n].clientWidth;
		}	

		if(Hlider.element_width == 0)
		{
			setTimeout("Hlider.Navi('" + num + "','" + id +"','"+ id2 +"','"+ clas+"')", 500);
			return false;
		}
	}
	
	},
	
	Clear:function(num)
	{
		var naviID = document.getElementById(Hlider.Hlider_naviID);
		var elements = naviID.getElementsByTagName('div');	
		for(i=0; i < elements.length; i++)
		{	
			if(elements[i].firstChild.innerHTML == num)
			{
				elements[i].className = Hlider.Hlider_naviclass + "_on";			
			}
			else
			{
				elements[i].className = Hlider.Hlider_naviclass;
			}
		}		
	},

	
	Start:function(num)
	{
	var num = parseInt(this.firstChild.innerHTML);
	var table_id = this.id.split("|");
	Hlider.Hlider_naviID = this.parentNode.id;
	Hlider.Hlider_mainID = table_id[0];
	Hlider.Hlider_naviclass = table_id[1];
	Hlider.mainID = document.getElementById(Hlider.Hlider_mainID);	
	Hlider.Move(num);	
	},
	

	Move:function(num)
	{
		Hlider.Clear(num);	
		clearInterval(Hlider.Time);
		Hlider.scroll_width=0;
		for(n=1;n <= num; n++)
		{
				Hlider.scroll_width += (Hlider.element_width * Hlider.Hlider_jump);
		}
		Hlider.scroll_width = Hlider.scroll_width_tmp = Hlider.scroll_width - (Hlider.element_width * Hlider.Hlider_jump);
		Hlider.Time = setInterval("Hlider.Anim()", 40);
	},

	Anim:function()
	{
	
		Hlider.scroll_width = Math.abs(Hlider.mainID.scrollLeft - Hlider.scroll_width_tmp);
		if(Hlider.mainID.scrollLeft < Hlider.scroll_width_tmp)
		{
			Hlider.Scroll = Math.round(Hlider.mainID.scrollLeft) + (Hlider.scroll_width/ Hlider.Hlider_speed);
		}
		else
		{
			Hlider.Scroll = Math.round(Hlider.mainID.scrollLeft) - (Hlider.scroll_width/ Hlider.Hlider_speed);		
		}
		Hlider.scroll_width = Math.round(Hlider.scroll_width/ Hlider.Hlider_speed);
		if(Math.round(Hlider.Scroll) == Hlider.scroll_width_tmp) 
		{
			clearInterval(Hlider.Time);
		}
		Hlider.mainID.scrollLeft = Hlider.Scroll;

	},
	
    Left:function(num, id, id2, clas, nullek) 
    {
	Hlider.Navi(num,id,id2,clas,nullek);	
	
		clearInterval(Hlider.Time);
		Hlider.scroll_width=0;
		var number = Math.round((Hlider.mainID.scrollLeft / Hlider.element_width) / Hlider.Hlider_jump);
		if(number == 0)
		{
			number = Hlider.navi_count;
		}
		Hlider.Move(number);
	},
	
    Right:function(num, id, id2, clas, nullek) 
    {

	Hlider.Navi(num,id,id2,clas, nullek);
	
		clearInterval(Hlider.Time);
		Hlider.scroll_width=0;
		var number = Math.round((Hlider.mainID.scrollLeft / Hlider.element_width) / Hlider.Hlider_jump);
		number++;
		number++;		
		if(number > Hlider.navi_count)
		{
			number = 1;
		}
		Hlider.Move(number);
	},
	
	Hlider_mainID:0,	
	Hlider_naviID:0,
	Hlider_naviclass: 0,
	Hlider_speed: 3,

	Hlider_jump: 0,
	lilist: 0,
	mainwidth: 0,
	mainID:'',
	width_pasek: 0,
	elements_count:0,
	navi_count: 0,
	element_width: 0,
	scroll_width: 0,
	scroll_width_tmp: 0,	
	Time:0,
	Scroll:0,
	SI:0
	
}
/* Wyniki wyszukiwania Ciuszkinamaluszki (kopia) (kopia) (search - search) [57419]*/

// SEARCH - PREVIEWBOX
//////////////////////////////////////////////////////////////////////

function hideprev(id){	
id.style.display='none';
}

function showprev(id, pos){
	

	img_id = document.getElementById('preview');
	img_id.innerHTML = document.getElementById(id).innerHTML;
       document.getElementById(id).style.display = "block";	
	var width_parent = document.getElementById(id).parentNode.clientWidth;
	document.getElementById(id).style.display = "none";
	var height_parent = document.getElementById(id).parentNode.clientHeight;	
	//document.getElementById(id).style.width = document.getElementById(id).parentNode.clientWidth + "px";
	var height_mother = document.getElementById(id).clientHeight;


	coors = findPos (document.getElementById(id).parentNode);
	img_id.style.top = coors[1] + 'px';
	img_id.style.left = coors[0] + 4 + 'px';

	img_id.style.width = width_parent - 19 +'px';
	img_id.style.display="block";
	
	if(height_mother < (height_parent/2))
	{
		img_id.style.height = height_parent - 16 - (height_parent/2) + 'px';
		img_id.style.marginTop= (height_parent/2) + "px";	  
	}
	else
	{

		img_id.style.height = height_mother + 10 + 'px';
		img_id.style.marginTop= (height_parent/2) + "px";	  	
	}
	
	img_id.style.padding="5px";

	
}

function findPos(obj) {
	var curleft = curtop = 0;
	if (obj.offsetParent) {
		curleft = obj.offsetLeft
		curtop = obj.offsetTop
		while (obj = obj.offsetParent) {
			curleft += obj.offsetLeft
			curtop += obj.offsetTop
		}
	}
	return [curleft,curtop];
}
/* <b style="font-size:12px;color:red; text-decoration:blink">&gt;</b>Formularz newslettera 3.5 (kopia) (layout_right - menu_newsletter) [56719]*/

function newsletter_blur(x) {
         if (x.value == '') {
                 x.value = newstxt;
         }
}
function newsletter_focus(x) {
         if (x.value != '') {
                 x.value = '';
         }
}
/* Słownik opisu (projector - projector_dictionary) [56173]*/

// SEARCH - DIALOGBOX
//////////////////////////////////////////////////////////////////////


var offsetfrommouse=[10,15]; //image x,y offsets from cursor position in pixels. Enter 0,0 for no offset
var timer;
var idek;


function truebody(){
return (!window.opera && document.compatMode && document.compatMode!="BackCompat")? document.documentElement : document.body
}


function hidetrail(){	
	document.getElementById(idek).style.display= "none";
	document.onmousemove="";
	document.getElementById(idek).style.left="-2000px";
	clearTimeout(timer);
}

function showtrail(id){
	idek = id;
	if (isNaN(timer)){show();}
	timer = setTimeout("show();",100);
}
function show(){
	
    var docwidth=document.all? truebody().scrollLeft+truebody().clientWidth : pageXOffset+window.innerWidth - offsetfrommouse[0]
	var docheight=document.all? Math.min(truebody().scrollHeight, truebody().clientHeight) : Math.min(window.innerHeight)
	document.onmousemove=followmouse; 
	document.getElementById(idek).style.display="block";

}

function followmouse(e){

	var xcoord=offsetfrommouse[0]
	var ycoord=offsetfrommouse[1]
	
	var docwidth=document.all? truebody().scrollLeft+truebody().clientWidth : pageXOffset+window.innerWidth-15
	var docheight=document.all? Math.min(truebody().scrollHeight, truebody().clientHeight) : Math.min(window.innerHeight)

	if (typeof e != "undefined"){
		if (docwidth - e.pageX <  2*offsetfrommouse[0]){
			xcoord = e.pageX - xcoord; // Move to the left side of the cursor
		} else {
			xcoord += e.pageX;
		}
		if (docheight - e.pageY < 2*offsetfrommouse[1]){
			ycoord += e.pageY - Math.max(0,(2*offsetfrommouse[1] + e.pageY - docheight - truebody().scrollTop));
		} else {
			ycoord += e.pageY;
		}

	} else if (typeof window.event != "undefined"){
		if (docwidth - event.clientX < 2*offsetfrommouse[0]){
			xcoord = event.clientX + truebody().scrollLeft - xcoord; // Move to the left side of the cursor
		} else {
			xcoord += truebody().scrollLeft+event.clientX
		}
		if (docheight - event.clientY < (2*offsetfrommouse[1])){
			ycoord += event.clientY + truebody().scrollTop - Math.max(0,(2*offsetfrommouse[1] + event.clientY - docheight));
		} else {
			ycoord += truebody().scrollTop + event.clientY;
		}
	}

	
	document.getElementById(idek).style.left=xcoord+"px"
	document.getElementById(idek).style.top=ycoord+"px"

}
/* <b style="font-size:12px;color:red; text-decoration:blink">&gt;</b> Formularz kontaktu z tematem input 2 (contact - contact_mailform) [54544]*/

function checkOnSubmit()
{
    if ((/^[0-9a-zA-Z._-]+@[0-9a-zA-Z._-]+.[0-9a-zA-Z]+$/).test(document.getElementById("from").value) == false || document.getElementById("from").value.length == 0){
        alert('Nie podano żadnego adresu e-mail.');
        return false;
    }
    return true;
}
/* <b style="font-size:13px;color:blue; text-decoration:blink;")">[ S ]</b> <b style="color:red; font-weight:bold;">MATKA</b> Ukrywacz menu zakładek <b style="color:red">FULL</b> (projector - projector_components_hiding) [56163]*/
var HOVER_classname_start = 'tab';
var HOVER_classname_stat = 0;

// Włączenie opini jako pierwszych, jeżeli są:
var HOVER_opinions = true;

var HOVER_choosenone = '1'; // TU MUSI BYC COS CO JEST ZAWSZE np. ZADAJ PRODUKT - PODAJ JEGO L.P.
var Hover_Array_Disable = new Array();
var Hover_Array = new Array();
var Hover_Array2 = new Array();


//////////////////////////////////////////////////////////////////////////////////////////////////////

Hover_Array2[6] = new Array('component_projector_sizes','0');
Hover_Array2[2] = new Array('component_projector_opinions','1', '2');
Hover_Array2[7] = new Array('component_projector_associated_zones','0', '1');
Hover_Array2[3] = new Array('component_projector_suggestproduct','0');
Hover_Array2[1] = new Array('component_projector_askforproduct','0');
Hover_Array2[8] = new Array('component_projector_warranty','0');
Hover_Array2[4] = new Array('component_projector_enclosures','0');
Hover_Array2[5] = new Array('component_projector_longdescription','0');
Hover_Array2[9] = new Array('component_projector_dictionary','0');

//////////////////////////////////////////////////////////////////////////////////////////////////////

var Hover_Array_ZONES = new Array();
Hover_Array_ZONES[1] = new Array('component_projector_associated_zone1');
Hover_Array_ZONES[2] = new Array('component_projector_associated_zone2');
Hover_Array_ZONES[3] = new Array('component_projector_associated_zone3');
Hover_Array_ZONES[4] = new Array('component_projector_associated_zone4');

var Hover_Array_OPINIONS = new Array();
Hover_Array_OPINIONS[1] = new Array('component_projector_opinions');
Hover_Array_OPINIONS[2] = new Array('component_projector_addopinions');
//////// Funkcje ukrywacza /////////

function HOVER_sort()
{
	for (i = 1; i<Hover_Array2.length; i++) {
		Hover_Array[i] = Hover_Array2[i];
	}
}


function HOVER(start)
{

//SORTOWANIE TABLICY
HOVER_sort();

var Hover_Elements = new Array();



	for(n in Hover_Array)
	{


		if(start != 1)
		{

		//COPY
if(document.getElementById('btn_' + Hover_Array[n][0]))
{
		Hover_Elements[n] = document.getElementById('btn_' + Hover_Array[n][0]).innerHTML;
		
		//REMOVE CHILD
		document.getElementById('Hover_blanks').removeChild(document.getElementById('btn_' + Hover_Array[n][0]));
		
		//PASTE
		var ni = document.getElementById('Hover_NewMENU');
		var newDiv =  document.createElement('div');
		newDiv.id = 'btn_' + Hover_Array[n][0];
		if(HOVER_classname_stat == 1)
		{
			newDiv.className = Hover_Array[n][0];	
		}
		else
		{
			newDiv.className = HOVER_classname_start;		
		}
		newDiv.style.display = 'none';	
		newDiv.onclick = function(){HOVER_change(this.id)};			
		newDiv.innerHTML = Hover_Elements[n];
		ni.appendChild(newDiv);
}
		}

	
	}


//CHECK IF EXIST
HOVER_disable();

	if(start != 1) HOVER_addhover();	
	
	if(start != 1) HOVER_opinions_show();		
	
	//POKAZYWANIE 
	HOVER_visible();

}

function HOVER_addhover()
{

	for(n in Hover_Array)
	{
		if(Hover_Array_Disable[n] == true)
		{
			document.getElementById('btn_' + Hover_Array[n][0]).onmouseover = HOVER_BUTTOn_onmouseover;
			document.getElementById('btn_' + Hover_Array[n][0]).onmouseout = HOVER_BUTTOn_onmouseout;			
		}
	}

}

function HOVER_BUTTOn_onmouseover()
{

	if(this.className.indexOf('_on') == -1)
	{
		HOVER_className = this.className;	
		this.className = HOVER_className + '_hover';
	}
}

function HOVER_BUTTOn_onmouseout()
{
	if(this.className.indexOf('_on') == -1)
	{
		this.className = HOVER_className;
	}
}

function HOVER_visible()
{

	for(n in Hover_Array)
	{
		if(Hover_Array_Disable[n] == true)
		{
			document.getElementById('btn_' + Hover_Array[n][0]).style.display = "block";	
			if(Hover_Array[n][1] == '1')
			{
				if(HOVER_classname_stat == 1)
				{
					document.getElementById('btn_' + Hover_Array[n][0]).className = Hover_Array[n][0] + '_on';		
				}
				else
				{
					document.getElementById('btn_' + Hover_Array[n][0]).className = HOVER_classname_start + '_on';					
				}
			}
		}
	}

}

function HOVER_opinions_show()
{
	for(n in Hover_Array)
	{
		//IF OPINIONS TRUE TO JE WLACZ
		if(parseInt(HOVER_opinions_counter) > 0 && HOVER_opinions == true)
		{
			Hover_Array[n][1] = '0';
			if(Hover_Array[n][0] == 'component_projector_opinions')
			{
				Hover_Array[n][1] = '1';
				HOVER_disable();		
			}
		
		}
	}

}


function HOVER_disable()
{
	// ZONES CLEAR
	for(n in Hover_Array_ZONES)
	{
		if(document.getElementById(Hover_Array_ZONES[n][0])) document.getElementById(Hover_Array_ZONES[n][0]).style.display = "none";
	}
	
	// OPINIONS CLEAR
	for(n in Hover_Array_OPINIONS)
	{	
		if(document.getElementById(Hover_Array_OPINIONS[n][0])) document.getElementById(Hover_Array_OPINIONS[n][0]).style.display = "none";
	}
	
	for(n in Hover_Array)
	{

if(document.getElementById('btn_' + Hover_Array[n][0]))
{
		//ZEROWANIE
		if(HOVER_classname_stat == 1)
		{
			document.getElementById('btn_' + Hover_Array[n][0]).className = Hover_Array[n][0];	
		}
		else
		{
			document.getElementById('btn_' + Hover_Array[n][0]).className = HOVER_classname_start;			
		}
		Hover_Array_Disable[n] = false;
		
		// JEZELI ISTENIEJE i ROZNY OD ZONES i OPINIONS
		if(document.getElementById(Hover_Array[n][0]) && Hover_Array[n][2] != '1' && Hover_Array[n][2] != '2')
		{
			Hover_Array_Disable[n] = true;
			
			//DISPLAY  DLA KOMPONENTOW			
			if(Hover_Array[n][1] == '1')
			{
				document.getElementById(Hover_Array[n][0]).style.display = "block";				
			}
			else
			{
				document.getElementById(Hover_Array[n][0]).style.display = "none";
			}
		}
			
		// JEZELI ZONES TO
		if(Hover_Array[n][2] == '1')
		{
			// ZONES EXIST
			for(k in Hover_Array_ZONES)
			{
				if(document.getElementById(Hover_Array_ZONES[k][0])) Hover_Array_Disable[n] = true;
			}
			
			//DISPLAY  DLA KOMPONENTOW			
			if(Hover_Array[n][1] == '1')
			{
				// ZONES SHOW
				for(n in Hover_Array_ZONES)
				{
					if(document.getElementById(Hover_Array_ZONES[n][0])) document.getElementById(Hover_Array_ZONES[n][0]).style.display = "block";
				}
			}
		}		
		
		// JEZELI OPINIONS TO
		if(Hover_Array[n][2] == '2')
		{
			// OPNIONS EXIST
			for(k in Hover_Array_OPINIONS)
			{			
				if(document.getElementById(Hover_Array_OPINIONS[k][0])) Hover_Array_Disable[n] = true;
			}
			//DISPLAY  DLA KOMPONENTOW			
			if(Hover_Array[n][1] == '1')
			{
				// ZONES SHOW



				for(n in Hover_Array_OPINIONS)
				{
					if(document.getElementById(Hover_Array_OPINIONS[n][0])) document.getElementById(Hover_Array_OPINIONS[n][0]).style.display = "block";
				}
			}
		}			


		
		//PRZESKOK DO NEXT IF PRIOR 1 I NIE MA KOMPONENTU
		if(Hover_Array_Disable[n] == false && Hover_Array[n][1] == '1')
		{
			Hover_Array[n][1] = '0';

			Hover_Array[HOVER_choosenone][1] = '1';
			HOVER_disable();
		}
}
	
	}

}

function HOVER_clear_prior()
{
	for(n in Hover_Array)
	{
		Hover_Array[n][1] = '0';
	}

}

function HOVER_change(idek)
{
HOVER_clear_prior();

	for(n in Hover_Array)
	{

		if('btn_' + Hover_Array[n][0] == idek)
		{
			Hover_Array[n][1] = '1';
		}
	}
HOVER(1);
}
/* <b style="font-size:12px;color:red; text-decoration:blink">&gt;</b> Newsletter 2 (kopia) (contact - contact_newsletter) [54691]*/
var newstxt = 'twój e-mail';
function newsletter_blur(x) {
         if (x.value == '') {
                 x.value = news_txt;
         }
}
function newsletter_focus(x) {
         if (x.value != '') {
                 x.value = '';
         }
}
/* <b style="font-size:12px;color:red; text-decoration:blink">&gt;</b>Opinie BEZ FORMULARZA 3.6, z foto (kopia) (projector - projector_opinions) [56197]*/

var x;

function showOpinion(id)
{
    element = document.getElementById(id);
    element.style.display='block';
}

function hideOpinion(id)
{
    element = document.getElementById(id);
    element.style.display='none';
}
/* Dodawanie opini do produktu 4.0 NOWE OCENY (projector - projector_opinions_add) [56031]*/

function drop_down(id) 
{
     document.getElementById(id).style.height = '150px';
}


function switcher2(ide, ide2) {
     if (document.getElementById(ide).style.display == 'block') {
           document.getElementById(ide).style.display='none';

     } else {
           document.getElementById(ide).style.display='block';
     }

     if (document.getElementById(ide2).style.display == 'block') {
           document.getElementById(ide2).style.display='none';

     } else {
           document.getElementById(ide2).style.display='block';
     }
}



function opinions_replace(id)
{

var inpt_opinions = document.getElementById('opinions_notes');
var divs_opinions = document.getElementsByTagName('DIV');

	for (i = 0; i < divs_opinions.length; i++) {
		if(divs_opinions[i].id == 'opinions_notes_rank')
		{
			divs_opinions[i].className = "projector_opinions_note";
		}
	}
	
id.className = "projector_opinions_note_on";
inpt_opinions.value = parseInt(id.innerHTML);
	
}
/* <b style="font-size:13px;color:blue; text-decoration:blink;")">[ S ]</b> Zadaj pytanie o produkt 5.0 (projector - projector_askforproduct) [56188]*/

function drop_down(id)
{
document.getElementById(id).style.height = '150px';
}

function roll_back(id)

{
 document.getElementById(id).style.height = '';
}
/* <b style="font-size:13px;color:blue; text-decoration:blink;")">[ S ]</b> Polecanie produktu 5.0 (projector - projector_suggestproduct) [56183]*/

function drop_down(id)
{
document.getElementById(id).style.height = '150px';
}

function roll_back(id)

{
 document.getElementById(id).style.height = '';
}
/* zalaczniki <b>(nie uzywac)</b> (kopia) (projector - projector_enclosures) [56259]*/

/**
Enclosuers - SHOW
*/

var ns6=document.getElementById&&!document.all;
var ie=document.all;
var html = document.getElementsByTagName("html");
var Enc = {
   
	width  : 0,
	height : 0,
	show : function (link,x,y) {

		Enc.width = x;
		Enc.height = y;
	
		var edit = document.getElementById('encVideo_cont');
        var edit_close = document.getElementById('encVideo_close');
		edit.style.display = "block";
        edit_close.style.display = "block";
		
		edit.innerHTML = document.getElementById('encVideo').innerHTML;	
        edit.style.width = parseInt(x) + "px";
       //edit.style.height = parseInt(y) + "px";			
		
		if (!ns6) {Enc.hideSelects(1);}
		Enc.creatLayers();
	},
  
	hide : function () {
		var edit = document.getElementById('encVideo_cont');
        var edit_close = document.getElementById('encVideo_close');
		var cover = document.getElementById('cover_enc');
		edit.style.display = "none";
        edit_close.style.display = "none";
		cover.style.display = "none";
		if (!ns6) {Enc.hideSelects(0);}
	},
	cover : function (wartosc) {
		var cover = document.getElementById('cover');
	    ns6? cover.style.opacity = '.' + wartosc  :  cover.style.filter = "alpha(Opacity=" +wartosc+")";
	    if (window.opera) {
			cover.style.opacity = '.' + wartosc;
		}
	},	
	creatLayers : function () {


var edit = document.getElementById('encVideo_cont');
var edit_close = document.getElementById('encVideo_close');
		edit.style.position = 'absolute';
	    edit.style.display = "block";
	    edit_close.style.display = "block";
		edit.style.width = (Enc.width) + "px";
	    edit.style.left = ns6? (Enc.pageSizes()[2] - (Enc.width + 10))/2 + html[0].scrollLeft +"px" : (Enc.pageSizes()[2] - (Enc.width + 10))/2 + "px";

var ver_brow=0;
if (navigator.appVersion.indexOf("MSIE")!=-1){
temp=navigator.appVersion.split("MSIE");
ver_brow=parseFloat(temp[1]);

if (ver_brow<7.0)
 {
edit.style.top = ((((Enc.pageSizes()[3] - (Enc.height + 10))/2) - 100  + document.body.scrollTop) < 0) ? "50px" : (((Enc.pageSizes()[3] - (Enc.height + 10))/2) - 100  + document.body.scrollTop + 50) + "px";
          }
else
{
edit.style.top = ((((Enc.pageSizes()[3] - (Enc.height + 10))/2) - 100  + html[0].scrollTop) < 0) ? "50px" : (((Enc.pageSizes()[3] - (Enc.height + 10))/2) - 100  + html[0].scrollTop + 50) + "px";
}
}
            else
{
edit.style.top = ((((Enc.pageSizes()[3] - (Enc.height + 10))/2) - 100  + html[0].scrollTop) < 0) ? "50px" : (((Enc.pageSizes()[3] - (Enc.height + 10))/2) - 100  + html[0].scrollTop + 50) + "px";
}



        edit.style.zIndex = 1000;
		edit.style.Background = '#FFFFFF';

	    //'cover'- div do blokowania elementow innych niz edit
	    var cover = document.getElementById('cover_enc');
	    cover.style.display = "block";
        cover.style.position = "absolute";
	    cover.style.zIndex = 900;
	    ns6? cover.style.opacity = .5 :  cover.style.filter = "alpha(Opacity=50)";
	    if (window.opera) {
			cover.style.opacity = .5;
		}
		cover.style.left = "0px";
	    cover.style.top = "0px";
            offsetX = 0;
            if (!ns6 && !window.opera) {
                  offsetX = 20;
            }
	    cover.style.width = ns6? (Enc.pageSizes()[0] - 16) + "px" : Enc.pageSizes()[0] - offsetX + "px"; //ns6? html[0].offsetWidth +"px" : document.body.offsetWidth + "px";
	    cover.style.height = Enc.pageSizes()[1] + "px" //ns6? html[0].offsetHeight +"px" : document.body.offsetHeight + "px";
	},
	pageSizes : function () {
		var xScroll, yScroll;
		if (window.innerHeight && window.scrollMaxY) {	
			xScroll = document.body.scrollWidth;
			yScroll = window.innerHeight + window.scrollMaxY;
		} else if (document.body.scrollHeight > document.body.offsetHeight){
			xScroll = document.body.scrollWidth;
			yScroll = document.body.scrollHeight;
		} else {
			xScroll = document.body.offsetWidth;
			yScroll = document.body.offsetHeight;
		}
		var windowWidth, windowHeight;
		if (self.innerHeight) {
			windowWidth = self.innerWidth;
			windowHeight = self.innerHeight;
		} else if (document.documentElement && document.documentElement.clientHeight) { // Explorer 6 Strict Mode
			windowWidth = document.documentElement.clientWidth;
			windowHeight = document.documentElement.clientHeight;
		} else if (document.body) {
			windowWidth = document.body.clientWidth;
			windowHeight = document.body.clientHeight;
		}	
		if(yScroll < windowHeight){
			pageHeight = windowHeight;
		} else { 
			pageHeight = yScroll;
		}
		if(xScroll < windowWidth){	
			pageWidth = windowWidth;
		} else {
			pageWidth = xScroll;
		}
		arrayPageSize = new Array(pageWidth,pageHeight,windowWidth,windowHeight) 
		return arrayPageSize;
	},
	hideSelects : function (flag) {
		var selects = document.getElementsByTagName('SELECT');
		if (flag == 1) {
			for (i = 0; i < selects.length; i++) {
				selects[i].style.display = 'none';
			}
		} else {
			for (i = 0; i < selects.length; i++) {
				selects[i].style.display = '';
			}
		}
	}
}